op.c

   1 #line 2 "op.c"
   2 /*    op.c
   3  *
   4  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
   5  *    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
   6  *
   7  *    You may distribute under the terms of either the GNU General Public
   8  *    License or the Artistic License, as specified in the README file.
   9  *
  10  */
  11
  12 /*
  13  * 'You see: Mr. Drogo, he married poor Miss Primula Brandybuck.  She was
  14  *  our Mr. Bilbo's first cousin on the mother's side (her mother being the
  15  *  youngest of the Old Took's daughters); and Mr. Drogo was his second
  16  *  cousin.  So Mr. Frodo is his first *and* second cousin, once removed
  17  *  either way, as the saying is, if you follow me.'       --the Gaffer
  18  *
  19  *     [p.23 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
  20  */
  21
  22 /* This file contains the functions that create, manipulate and optimize
  23  * the OP structures that hold a compiled perl program.
  24  *
  25  * A Perl program is compiled into a tree of OPs. Each op contains
  26  * structural pointers (eg to its siblings and the next op in the
  27  * execution sequence), a pointer to the function that would execute the
  28  * op, plus any data specific to that op. For example, an OP_CONST op
  29  * points to the pp_const() function and to an SV containing the constant
  30  * value. When pp_const() is executed, its job is to push that SV onto the
  31  * stack.
  32  *
  33  * OPs are mainly created by the newFOO() functions, which are mainly
  34  * called from the parser (in perly.y) as the code is parsed. For example
  35  * the Perl code $a + $b * $c would cause the equivalent of the following
  36  * to be called (oversimplifying a bit):
  37  *
  38  *  newBINOP(OP_ADD, flags,
  39  *      newSVREF($a),
  40  *      newBINOP(OP_MULTIPLY, flags, newSVREF($b), newSVREF($c))
  41  *  )
  42  *
  43  * Note that during the build of miniperl, a temporary copy of this file
  44  * is made, called opmini.c.
  45  */
  46
  47 /*
  48 Perl's compiler is essentially a 3-pass compiler with interleaved phases:
  49
  50     A bottom-up pass
  51     A top-down pass
  52     An execution-order pass
  53
  54 The bottom-up pass is represented by all the "newOP" routines and
  55 the ck_ routines.  The bottom-upness is actually driven by yacc.
  56 So at the point that a ck_ routine fires, we have no idea what the
  57 context is, either upward in the syntax tree, or either forward or
  58 backward in the execution order.  (The bottom-up parser builds that
  59 part of the execution order it knows about, but if you follow the "next"
  60 links around, you'll find it's actually a closed loop through the
  61 top level node.)
  62
  63 Whenever the bottom-up parser gets to a node that supplies context to
  64 its components, it invokes that portion of the top-down pass that applies
  65 to that part of the subtree (and marks the top node as processed, so
  66 if a node further up supplies context, it doesn't have to take the
  67 plunge again).  As a particular subcase of this, as the new node is
  68 built, it takes all the closed execution loops of its subcomponents
  69 and links them into a new closed loop for the higher level node.  But
  70 it's still not the real execution order.
  71
  72 The actual execution order is not known till we get a grammar reduction
  73 to a top-level unit like a subroutine or file that will be called by
  74 "name" rather than via a "next" pointer.  At that point, we can call
  75 into peep() to do that code's portion of the 3rd pass.  It has to be
  76 recursive, but it's recursive on basic blocks, not on tree nodes.
  77 */
  78
  79 /* To implement user lexical pragmas, there needs to be a way at run time to
  80    get the compile time state of %^H for that block.  Storing %^H in every
  81    block (or even COP) would be very expensive, so a different approach is
  82    taken.  The (running) state of %^H is serialised into a tree of HE-like
  83    structs.  Stores into %^H are chained onto the current leaf as a struct
  84    refcounted_he * with the key and the value.  Deletes from %^H are saved
  85    with a value of PL_sv_placeholder.  The state of %^H at any point can be
  86    turned back into a regular HV by walking back up the tree from that point's
  87    leaf, ignoring any key you've already seen (placeholder or not), storing
  88    the rest into the HV structure, then removing the placeholders. Hence
  89    memory is only used to store the %^H deltas from the enclosing COP, rather
  90    than the entire %^H on each COP.
  91
  92    To cause actions on %^H to write out the serialisation records, it has
  93    magic type 'H'. This magic (itself) does nothing, but its presence causes
  94    the values to gain magic type 'h', which has entries for set and clear.
  95    C<Perl_magic_sethint> updates C<PL_compiling.cop_hints_hash> with a store
  96    record, with deletes written by C<Perl_magic_clearhint>. C<SAVEHINTS>
  97    saves the current C<PL_compiling.cop_hints_hash> on the save stack, so that
  98    it will be correctly restored when any inner compiling scope is exited.
  99 */
 100
 101 #include "EXTERN.h"
 102 #define PERL_IN_OP_C
 103 #include "perl.h"
 104 #include "keywords.h"
 105 #include "feature.h"
 106 #include "regcomp.h"
 107
 108 #define CALL_PEEP(o) PL_peepp(aTHX_ o)
 109 #define CALL_RPEEP(o) PL_rpeepp(aTHX_ o)
 110 #define CALL_OPFREEHOOK(o) if (PL_opfreehook) PL_opfreehook(aTHX_ o)
 111
 112 /* See the explanatory comments above struct opslab in op.h. */
 113
 114 #ifdef PERL_DEBUG_READONLY_OPS
 115 #  define PERL_SLAB_SIZE 128
 116 #  define PERL_MAX_SLAB_SIZE 4096
 117 #  include <sys/mman.h>
 118 #endif
 119
 120 #ifndef PERL_SLAB_SIZE
 121 #  define PERL_SLAB_SIZE 64
 122 #endif
 123 #ifndef PERL_MAX_SLAB_SIZE
 124 #  define PERL_MAX_SLAB_SIZE 2048
 125 #endif
 126
 127 /* rounds up to nearest pointer */
 128 #define SIZE_TO_PSIZE(x)        (((x) + sizeof(I32 *) - 1)/sizeof(I32 *))
 129 #define DIFF(o,p)               ((size_t)((I32 **)(p) - (I32**)(o)))
 130
 131 static OPSLAB *
 132 S_new_slab(pTHX_ size_t sz)
 133 {
 134 #ifdef PERL_DEBUG_READONLY_OPS
 135     OPSLAB *slab = (OPSLAB *) mmap(0, sz * sizeof(I32 *),
 136                                    PROT_READ|PROT_WRITE,
 137                                    MAP_ANON|MAP_PRIVATE, -1, 0);
 138     DEBUG_m(PerlIO_printf(Perl_debug_log, "mapped %lu at %p\n",
 139                           (unsigned long) sz, slab));
 140     if (slab == MAP_FAILED) {
 141         perror("mmap failed");
 142         abort();
 143     }
 144     slab->opslab_size = (U16)sz;
 145 #else
 146     OPSLAB *slab = (OPSLAB *)PerlMemShared_calloc(sz, sizeof(I32 *));
 147 #endif
 148     slab->opslab_first = (OPSLOT *)((I32 **)slab + sz - 1);
 149     return slab;
 150 }
 151
 152 /* requires double parens and aTHX_ */
 153 #define DEBUG_S_warn(args)                                             \
 154     DEBUG_S(                                                            \
 155         PerlIO_printf(Perl_debug_log, "%s", SvPVx_nolen(Perl_mess args)) \
 156     )
 157
 158 void *
 159 Perl_Slab_Alloc(pTHX_ size_t sz)
 160 {
 161     dVAR;
 162     OPSLAB *slab;
 163     OPSLAB *slab2;
 164     OPSLOT *slot;
 165     OP *o;
 166     size_t opsz, space;
 167
 168     /* We only allocate ops from the slab during subroutine compilation.
 169        We find the slab via PL_compcv, hence that must be non-NULL. It could
 170        also be pointing to a subroutine which is now fully set up (CvROOT()
 171        pointing to the top of the optree for that sub), or a subroutine
 172        which isn't using the slab allocator. If our sanity checks aren't met,
 173        don't use a slab, but allocate the OP directly from the heap.  */
 174     if (!PL_compcv || CvROOT(PL_compcv)
 175      || (CvSTART(PL_compcv) && !CvSLABBED(PL_compcv)))
 176         return PerlMemShared_calloc(1, sz);
 177
 178     /* While the subroutine is under construction, the slabs are accessed via
 179        CvSTART(), to avoid needing to expand PVCV by one pointer for something
 180        unneeded at runtime. Once a subroutine is constructed, the slabs are
 181        accessed via CvROOT(). So if CvSTART() is NULL, no slab has been
 182        allocated yet.  See the commit message for 8be227ab5eaa23f2 for more
 183        details.  */
 184     if (!CvSTART(PL_compcv)) {
 185         CvSTART(PL_compcv) =
 186             (OP *)(slab = S_new_slab(aTHX_ PERL_SLAB_SIZE));
 187         CvSLABBED_on(PL_compcv);
 188         slab->opslab_refcnt = 2; /* one for the CV; one for the new OP */
 189     }
 190     else ++(slab = (OPSLAB *)CvSTART(PL_compcv))->opslab_refcnt;
 191
 192     opsz = SIZE_TO_PSIZE(sz);
 193     sz = opsz + OPSLOT_HEADER_P;
 194
 195     /* The slabs maintain a free list of OPs. In particular, constant folding
 196        will free up OPs, so it makes sense to re-use them where possible. A
 197        freed up slot is used in preference to a new allocation.  */
 198     if (slab->opslab_freed) {
 199         OP **too = &slab->opslab_freed;
 200         o = *too;
 201         DEBUG_S_warn((aTHX_ "found free op at %p, slab %p", o, slab));
 202         while (o && DIFF(OpSLOT(o), OpSLOT(o)->opslot_next) < sz) {
 203             DEBUG_S_warn((aTHX_ "Alas! too small"));
 204             o = *(too = &o->op_next);
 205             if (o) { DEBUG_S_warn((aTHX_ "found another free op at %p", o)); }
 206         }
 207         if (o) {
 208             *too = o->op_next;
 209             Zero(o, opsz, I32 *);
 210             o->op_slabbed = 1;
 211             return (void *)o;
 212         }
 213     }
 214
 215 #define INIT_OPSLOT \
 216             slot->opslot_slab = slab;                   \
 217             slot->opslot_next = slab2->opslab_first;    \
 218             slab2->opslab_first = slot;                 \
 219             o = &slot->opslot_op;                       \
 220             o->op_slabbed = 1
 221
 222     /* The partially-filled slab is next in the chain. */
 223     slab2 = slab->opslab_next ? slab->opslab_next : slab;
 224     if ((space = DIFF(&slab2->opslab_slots, slab2->opslab_first)) < sz) {
 225         /* Remaining space is too small. */
 226
 227         /* If we can fit a BASEOP, add it to the free chain, so as not
 228            to waste it. */
 229         if (space >= SIZE_TO_PSIZE(sizeof(OP)) + OPSLOT_HEADER_P) {
 230             slot = &slab2->opslab_slots;
 231             INIT_OPSLOT;
 232             o->op_type = OP_FREED;
 233             o->op_next = slab->opslab_freed;
 234             slab->opslab_freed = o;
 235         }
 236
 237         /* Create a new slab.  Make this one twice as big. */
 238         slot = slab2->opslab_first;
 239         while (slot->opslot_next) slot = slot->opslot_next;
 240         slab2 = S_new_slab(aTHX_
 241                             (DIFF(slab2, slot)+1)*2 > PERL_MAX_SLAB_SIZE
 242                                         ? PERL_MAX_SLAB_SIZE
 243                                         : (DIFF(slab2, slot)+1)*2);
 244         slab2->opslab_next = slab->opslab_next;
 245         slab->opslab_next = slab2;
 246     }
 247     assert(DIFF(&slab2->opslab_slots, slab2->opslab_first) >= sz);
 248
 249     /* Create a new op slot */
 250     slot = (OPSLOT *)((I32 **)slab2->opslab_first - sz);
 251     assert(slot >= &slab2->opslab_slots);
 252     if (DIFF(&slab2->opslab_slots, slot)
 253          < SIZE_TO_PSIZE(sizeof(OP)) + OPSLOT_HEADER_P)
 254         slot = &slab2->opslab_slots;
 255     INIT_OPSLOT;
 256     DEBUG_S_warn((aTHX_ "allocating op at %p, slab %p", o, slab));
 257     return (void *)o;
 258 }
 259
 260 #undef INIT_OPSLOT
 261
 262 #ifdef PERL_DEBUG_READONLY_OPS
 263 void
 264 Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
 265 {
 266     PERL_ARGS_ASSERT_SLAB_TO_RO;
 267
 268     if (slab->opslab_readonly) return;
 269     slab->opslab_readonly = 1;
 270     for (; slab; slab = slab->opslab_next) {
 271         /*DEBUG_U(PerlIO_printf(Perl_debug_log,"mprotect ->ro %lu at %p\n",
 272                               (unsigned long) slab->opslab_size, slab));*/
 273         if (mprotect(slab, slab->opslab_size * sizeof(I32 *), PROT_READ))
 274             Perl_warn(aTHX_ "mprotect for %p %lu failed with %d", slab,
 275                              (unsigned long)slab->opslab_size, errno);
 276     }
 277 }
 278
 279 void
 280 Perl_Slab_to_rw(pTHX_ OPSLAB *const slab)
 281 {
 282     OPSLAB *slab2;
 283
 284     PERL_ARGS_ASSERT_SLAB_TO_RW;
 285
 286     if (!slab->opslab_readonly) return;
 287     slab2 = slab;
 288     for (; slab2; slab2 = slab2->opslab_next) {
 289         /*DEBUG_U(PerlIO_printf(Perl_debug_log,"mprotect ->rw %lu at %p\n",
 290                               (unsigned long) size, slab2));*/
 291         if (mprotect((void *)slab2, slab2->opslab_size * sizeof(I32 *),
 292                      PROT_READ|PROT_WRITE)) {
 293             Perl_warn(aTHX_ "mprotect RW for %p %lu failed with %d", slab,
 294                              (unsigned long)slab2->opslab_size, errno);
 295         }
 296     }
 297     slab->opslab_readonly = 0;
 298 }
 299
 300 #else
 301 #  define Slab_to_rw(op)    NOOP
 302 #endif
 303
 304 /* This cannot possibly be right, but it was copied from the old slab
 305    allocator, to which it was originally added, without explanation, in
 306    commit 083fcd5. */
 307 #ifdef NETWARE
 308 #    define PerlMemShared PerlMem
 309 #endif
 310
 311 void
 312 Perl_Slab_Free(pTHX_ void *op)
 313 {
 314     dVAR;
 315     OP * const o = (OP *)op;
 316     OPSLAB *slab;
 317
 318     PERL_ARGS_ASSERT_SLAB_FREE;
 319
 320     if (!o->op_slabbed) {
 321         if (!o->op_static)
 322             PerlMemShared_free(op);
 323         return;
 324     }
 325
 326     slab = OpSLAB(o);
 327     /* If this op is already freed, our refcount will get screwy. */
 328     assert(o->op_type != OP_FREED);
 329     o->op_type = OP_FREED;
 330     o->op_next = slab->opslab_freed;
 331     slab->opslab_freed = o;
 332     DEBUG_S_warn((aTHX_ "free op at %p, recorded in slab %p", o, slab));
 333     OpslabREFCNT_dec_padok(slab);
 334 }
 335
 336 void
 337 Perl_opslab_free_nopad(pTHX_ OPSLAB *slab)
 338 {
 339     dVAR;
 340     const bool havepad = !!PL_comppad;
 341     PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD;
 342     if (havepad) {
 343         ENTER;
 344         PAD_SAVE_SETNULLPAD();
 345     }
 346     opslab_free(slab);
 347     if (havepad) LEAVE;
 348 }
 349
 350 void
 351 Perl_opslab_free(pTHX_ OPSLAB *slab)
 352 {
 353     dVAR;
 354     OPSLAB *slab2;
 355     PERL_ARGS_ASSERT_OPSLAB_FREE;
 356     DEBUG_S_warn((aTHX_ "freeing slab %p", slab));
 357     assert(slab->opslab_refcnt == 1);
 358     for (; slab; slab = slab2) {
 359         slab2 = slab->opslab_next;
 360 #ifdef DEBUGGING
 361         slab->opslab_refcnt = ~(size_t)0;
 362 #endif
 363 #ifdef PERL_DEBUG_READONLY_OPS
 364         DEBUG_m(PerlIO_printf(Perl_debug_log, "Deallocate slab at %p\n",
 365                                                slab));
 366         if (munmap(slab, slab->opslab_size * sizeof(I32 *))) {
 367             perror("munmap failed");
 368             abort();
 369         }
 370 #else
 371         PerlMemShared_free(slab);
 372 #endif
 373     }
 374 }
 375
 376 void
 377 Perl_opslab_force_free(pTHX_ OPSLAB *slab)
 378 {
 379     OPSLAB *slab2;
 380     OPSLOT *slot;
 381 #ifdef DEBUGGING
 382     size_t savestack_count = 0;
 383 #endif
 384     PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE;
 385     slab2 = slab;
 386     do {
 387         for (slot = slab2->opslab_first;
 388              slot->opslot_next;
 389              slot = slot->opslot_next) {
 390             if (slot->opslot_op.op_type != OP_FREED
 391              && !(slot->opslot_op.op_savefree
 392 #ifdef DEBUGGING
 393                   && ++savestack_count
 394 #endif
 395                  )
 396             ) {
 397                 assert(slot->opslot_op.op_slabbed);
 398                 op_free(&slot->opslot_op);
 399                 if (slab->opslab_refcnt == 1) goto free;
 400             }
 401         }
 402     } while ((slab2 = slab2->opslab_next));
 403     /* > 1 because the CV still holds a reference count. */
 404     if (slab->opslab_refcnt > 1) { /* still referenced by the savestack */
 405 #ifdef DEBUGGING
 406         assert(savestack_count == slab->opslab_refcnt-1);
 407 #endif
 408         /* Remove the CV’s reference count. */
 409         slab->opslab_refcnt--;
 410         return;
 411     }
 412    free:
 413     opslab_free(slab);
 414 }
 415
 416 #ifdef PERL_DEBUG_READONLY_OPS
 417 OP *
 418 Perl_op_refcnt_inc(pTHX_ OP *o)
 419 {
 420     if(o) {
 421         OPSLAB *const slab = o->op_slabbed ? OpSLAB(o) : NULL;
 422         if (slab && slab->opslab_readonly) {
 423             Slab_to_rw(slab);
 424             ++o->op_targ;
 425             Slab_to_ro(slab);
 426         } else {
 427             ++o->op_targ;
 428         }
 429     }
 430     return o;
 431
 432 }
 433
 434 PADOFFSET
 435 Perl_op_refcnt_dec(pTHX_ OP *o)
 436 {
 437     PADOFFSET result;
 438     OPSLAB *const slab = o->op_slabbed ? OpSLAB(o) : NULL;
 439
 440     PERL_ARGS_ASSERT_OP_REFCNT_DEC;
 441
 442     if (slab && slab->opslab_readonly) {
 443         Slab_to_rw(slab);
 444         result = --o->op_targ;
 445         Slab_to_ro(slab);
 446     } else {
 447         result = --o->op_targ;
 448     }
 449     return result;
 450 }
 451 #endif
 452 /*
 453  * In the following definition, the ", (OP*)0" is just to make the compiler
 454  * think the expression is of the right type: croak actually does a Siglongjmp.
 455  */
 456 #define CHECKOP(type,o) \
 457     ((PL_op_mask && PL_op_mask[type])                           \
 458      ? ( op_free((OP*)o),                                       \
 459          Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),  \
 460          (OP*)0 )                                               \
 461      : PL_check[type](aTHX_ (OP*)o))
 462
 463 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
 464
 465 #define CHANGE_TYPE(o,type) \
 466     STMT_START {                                \
 467         o->op_type = (OPCODE)type;              \
 468         o->op_ppaddr = PL_ppaddr[type];         \
 469     } STMT_END
 470
 471 STATIC SV*
 472 S_gv_ename(pTHX_ GV *gv)
 473 {
 474     SV* const tmpsv = sv_newmortal();
 475
 476     PERL_ARGS_ASSERT_GV_ENAME;
 477
 478     gv_efullname3(tmpsv, gv, NULL);
 479     return tmpsv;
 480 }
 481
 482 STATIC OP *
 483 S_no_fh_allowed(pTHX_ OP *o)
 484 {
 485     PERL_ARGS_ASSERT_NO_FH_ALLOWED;
 486
 487     yyerror(Perl_form(aTHX_ "Missing comma after first argument to %s function",
 488                  OP_DESC(o)));
 489     return o;
 490 }
 491
 492 STATIC OP *
 493 S_too_few_arguments_sv(pTHX_ OP *o, SV *namesv, U32 flags)
 494 {
 495     PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV;
 496     yyerror_pv(Perl_form(aTHX_ "Not enough arguments for %"SVf, namesv),
 497                                     SvUTF8(namesv) | flags);
 498     return o;
 499 }
 500
 501 STATIC OP *
 502 S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags)
 503 {
 504     PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV;
 505     yyerror_pv(Perl_form(aTHX_ "Not enough arguments for %s", name), flags);
 506     return o;
 507 }
 508
 509 STATIC OP *
 510 S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags)
 511 {
 512     PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV;
 513
 514     yyerror_pv(Perl_form(aTHX_ "Too many arguments for %s", name), flags);
 515     return o;
 516 }
 517
 518 STATIC OP *
 519 S_too_many_arguments_sv(pTHX_ OP *o, SV *namesv, U32 flags)
 520 {
 521     PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV;
 522
 523     yyerror_pv(Perl_form(aTHX_ "Too many arguments for %"SVf, SVfARG(namesv)),
 524                 SvUTF8(namesv) | flags);
 525     return o;
 526 }
 527
 528 STATIC void
 529 S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid)
 530 {
 531     PERL_ARGS_ASSERT_BAD_TYPE_PV;
 532
 533     yyerror_pv(Perl_form(aTHX_ "Type of arg %d to %s must be %s (not %s)",
 534                  (int)n, name, t, OP_DESC(kid)), flags);
 535 }
 536
 537 STATIC void
 538 S_bad_type_gv(pTHX_ I32 n, const char *t, GV *gv, U32 flags, const OP *kid)
 539 {
 540     SV * const namesv = gv_ename(gv);
 541     PERL_ARGS_ASSERT_BAD_TYPE_GV;
 542
 543     yyerror_pv(Perl_form(aTHX_ "Type of arg %d to %"SVf" must be %s (not %s)",
 544                  (int)n, SVfARG(namesv), t, OP_DESC(kid)), SvUTF8(namesv) | flags);
 545 }
 546
 547 STATIC void
 548 S_no_bareword_allowed(pTHX_ OP *o)
 549 {
 550     PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED;
 551
 552     if (PL_madskills)
 553         return;         /* various ok barewords are hidden in extra OP_NULL */
 554     qerror(Perl_mess(aTHX_
 555                      "Bareword \"%"SVf"\" not allowed while \"strict subs\" in use",
 556                      SVfARG(cSVOPo_sv)));
 557     o->op_private &= ~OPpCONST_STRICT; /* prevent warning twice about the same OP */
 558 }
 559
 560 /* "register" allocation */
 561
 562 PADOFFSET
 563 Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
 564 {
 565     dVAR;
 566     PADOFFSET off;
 567     const bool is_our = (PL_parser->in_my == KEY_our);
 568
 569     PERL_ARGS_ASSERT_ALLOCMY;
 570
 571     if (flags & ~SVf_UTF8)
 572         Perl_croak(aTHX_ "panic: allocmy illegal flag bits 0x%" UVxf,
 573                    (UV)flags);
 574
 575     /* Until we're using the length for real, cross check that we're being
 576        told the truth.  */
 577     assert(strlen(name) == len);
 578
 579     /* complain about "my $<special_var>" etc etc */
 580     if (len &&
 581         !(is_our ||
 582           isALPHA(name[1]) ||
 583           ((flags & SVf_UTF8) && isIDFIRST_utf8((U8 *)name+1)) ||
 584           (name[1] == '_' && (*name == '$' || len > 2))))
 585     {
 586         /* name[2] is true if strlen(name) > 2  */
 587         if (!(flags & SVf_UTF8 && UTF8_IS_START(name[1]))
 588          && (!isPRINT(name[1]) || strchr("\t\n\r\f", name[1]))) {
 589             yyerror(Perl_form(aTHX_ "Can't use global %c^%c%.*s in \"%s\"",
 590                               name[0], toCTRL(name[1]), (int)(len - 2), name + 2,
 591                               PL_parser->in_my == KEY_state ? "state" : "my"));
 592         } else {
 593             yyerror_pv(Perl_form(aTHX_ "Can't use global %.*s in \"%s\"", (int) len, name,
 594                               PL_parser->in_my == KEY_state ? "state" : "my"), flags & SVf_UTF8);
 595         }
 596     }
 597     else if (len == 2 && name[1] == '_' && !is_our)
 598         /* diag_listed_as: Use of my $_ is experimental */
 599         Perl_ck_warner_d(aTHX_ packWARN(WARN_EXPERIMENTAL__LEXICAL_TOPIC),
 600                               "Use of %s $_ is experimental",
 601                                PL_parser->in_my == KEY_state
 602                                  ? "state"
 603                                  : "my");
 604
 605     /* allocate a spare slot and store the name in that slot */
 606
 607     off = pad_add_name_pvn(name, len,
 608                        (is_our ? padadd_OUR :
 609                         PL_parser->in_my == KEY_state ? padadd_STATE : 0)
 610                             | ( flags & SVf_UTF8 ? SVf_UTF8 : 0 ),
 611                     PL_parser->in_my_stash,
 612                     (is_our
 613                         /* $_ is always in main::, even with our */
 614                         ? (PL_curstash && !strEQ(name,"$_") ? PL_curstash : PL_defstash)
 615                         : NULL
 616                     )
 617     );
 618     /* anon sub prototypes contains state vars should always be cloned,
 619      * otherwise the state var would be shared between anon subs */
 620
 621     if (PL_parser->in_my == KEY_state && CvANON(PL_compcv))
 622         CvCLONE_on(PL_compcv);
 623
 624     return off;
 625 }
 626
 627 /*
 628 =for apidoc alloccopstash
 629
 630 Available only under threaded builds, this function allocates an entry in
 631 C<PL_stashpad> for the stash passed to it.
 632
 633 =cut
 634 */
 635
 636 #ifdef USE_ITHREADS
 637 PADOFFSET
 638 Perl_alloccopstash(pTHX_ HV *hv)
 639 {
 640     PADOFFSET off = 0, o = 1;
 641     bool found_slot = FALSE;
 642
 643     PERL_ARGS_ASSERT_ALLOCCOPSTASH;
 644
 645     if (PL_stashpad[PL_stashpadix] == hv) return PL_stashpadix;
 646
 647     for (; o < PL_stashpadmax; ++o) {
 648         if (PL_stashpad[o] == hv) return PL_stashpadix = o;
 649         if (!PL_stashpad[o] || SvTYPE(PL_stashpad[o]) != SVt_PVHV)
 650             found_slot = TRUE, off = o;
 651     }
 652     if (!found_slot) {
 653         Renew(PL_stashpad, PL_stashpadmax + 10, HV *);
 654         Zero(PL_stashpad + PL_stashpadmax, 10, HV *);
 655         off = PL_stashpadmax;
 656         PL_stashpadmax += 10;
 657     }
 658
 659     PL_stashpad[PL_stashpadix = off] = hv;
 660     return off;
 661 }
 662 #endif
 663
 664 /* free the body of an op without examining its contents.
 665  * Always use this rather than FreeOp directly */
 666
 667 static void
 668 S_op_destroy(pTHX_ OP *o)
 669 {
 670     FreeOp(o);
 671 }
 672
 673 /* Destructor */
 674
 675 void
 676 Perl_op_free(pTHX_ OP *o)
 677 {
 678     dVAR;
 679     OPCODE type;
 680
 681     /* Though ops may be freed twice, freeing the op after its slab is a
 682        big no-no. */
 683     assert(!o || !o->op_slabbed || OpSLAB(o)->opslab_refcnt != ~(size_t)0);
 684     /* During the forced freeing of ops after compilation failure, kidops
 685        may be freed before their parents. */
 686     if (!o || o->op_type == OP_FREED)
 687         return;
 688
 689     type = o->op_type;
 690     if (o->op_private & OPpREFCOUNTED) {
 691         switch (type) {
 692         case OP_LEAVESUB:
 693         case OP_LEAVESUBLV:
 694         case OP_LEAVEEVAL:
 695         case OP_LEAVE:
 696         case OP_SCOPE:
 697         case OP_LEAVEWRITE:
 698             {
 699             PADOFFSET refcnt;
 700             OP_REFCNT_LOCK;
 701             refcnt = OpREFCNT_dec(o);
 702             OP_REFCNT_UNLOCK;
 703             if (refcnt) {
 704                 /* Need to find and remove any pattern match ops from the list
 705                    we maintain for reset().  */
 706                 find_and_forget_pmops(o);
 707                 return;
 708             }
 709             }
 710             break;
 711         default:
 712             break;
 713         }
 714     }
 715
 716     /* Call the op_free hook if it has been set. Do it now so that it's called
 717      * at the right time for refcounted ops, but still before all of the kids
 718      * are freed. */
 719     CALL_OPFREEHOOK(o);
 720
 721     if (o->op_flags & OPf_KIDS) {
 722         OP *kid, *nextkid;
 723         for (kid = cUNOPo->op_first; kid; kid = nextkid) {
 724             nextkid = kid->op_sibling; /* Get before next freeing kid */
 725             op_free(kid);
 726         }
 727     }
 728     if (type == OP_NULL)
 729         type = (OPCODE)o->op_targ;
 730
 731     if (o->op_slabbed)
 732         Slab_to_rw(OpSLAB(o));
 733
 734     /* COP* is not cleared by op_clear() so that we may track line
 735      * numbers etc even after null() */
 736     if (type == OP_NEXTSTATE || type == OP_DBSTATE) {
 737         cop_free((COP*)o);
 738     }
 739
 740     op_clear(o);
 741     FreeOp(o);
 742 #ifdef DEBUG_LEAKING_SCALARS
 743     if (PL_op == o)
 744         PL_op = NULL;
 745 #endif
 746 }
 747
 748 void
 749 Perl_op_clear(pTHX_ OP *o)
 750 {
 751
 752     dVAR;
 753
 754     PERL_ARGS_ASSERT_OP_CLEAR;
 755
 756 #ifdef PERL_MAD
 757     mad_free(o->op_madprop);
 758     o->op_madprop = 0;
 759 #endif
 760
 761  retry:
 762     switch (o->op_type) {
 763     case OP_NULL:       /* Was holding old type, if any. */
 764         if (PL_madskills && o->op_targ != OP_NULL) {
 765             o->op_type = (Optype)o->op_targ;
 766             o->op_targ = 0;
 767             goto retry;
 768         }
 769     case OP_ENTERTRY:
 770     case OP_ENTEREVAL:  /* Was holding hints. */
 771         o->op_targ = 0;
 772         break;
 773     default:
 774         if (!(o->op_flags & OPf_REF)
 775             || (PL_check[o->op_type] != Perl_ck_ftst))
 776             break;
 777         /* FALL THROUGH */
 778     case OP_GVSV:
 779     case OP_GV:
 780     case OP_AELEMFAST:
 781         {
 782             GV *gv = (o->op_type == OP_GV || o->op_type == OP_GVSV)
 783 #ifdef USE_ITHREADS
 784                         && PL_curpad
 785 #endif
 786                         ? cGVOPo_gv : NULL;
 787             /* It's possible during global destruction that the GV is freed
 788                before the optree. Whilst the SvREFCNT_inc is happy to bump from
 789                0 to 1 on a freed SV, the corresponding SvREFCNT_dec from 1 to 0
 790                will trigger an assertion failure, because the entry to sv_clear
 791                checks that the scalar is not already freed.  A check of for
 792                !SvIS_FREED(gv) turns out to be invalid, because during global
 793                destruction the reference count can be forced down to zero
 794                (with SVf_BREAK set).  In which case raising to 1 and then
 795                dropping to 0 triggers cleanup before it should happen.  I
 796                *think* that this might actually be a general, systematic,
 797                weakness of the whole idea of SVf_BREAK, in that code *is*
 798                allowed to raise and lower references during global destruction,
 799                so any *valid* code that happens to do this during global
 800                destruction might well trigger premature cleanup.  */
 801             bool still_valid = gv && SvREFCNT(gv);
 802
 803             if (still_valid)
 804                 SvREFCNT_inc_simple_void(gv);
 805 #ifdef USE_ITHREADS
 806             if (cPADOPo->op_padix > 0) {
 807                 /* No GvIN_PAD_off(cGVOPo_gv) here, because other references
 808                  * may still exist on the pad */
 809                 pad_swipe(cPADOPo->op_padix, TRUE);
 810                 cPADOPo->op_padix = 0;
 811             }
 812 #else
 813             SvREFCNT_dec(cSVOPo->op_sv);
 814             cSVOPo->op_sv = NULL;
 815 #endif
 816             if (still_valid) {
 817                 int try_downgrade = SvREFCNT(gv) == 2;
 818                 SvREFCNT_dec_NN(gv);
 819                 if (try_downgrade)
 820                     gv_try_downgrade(gv);
 821             }
 822         }
 823         break;
 824     case OP_METHOD_NAMED:
 825     case OP_CONST:
 826     case OP_HINTSEVAL:
 827         SvREFCNT_dec(cSVOPo->op_sv);
 828         cSVOPo->op_sv = NULL;
 829 #ifdef USE_ITHREADS
 830         /** Bug #15654
 831           Even if op_clear does a pad_free for the target of the op,
 832           pad_free doesn't actually remove the sv that exists in the pad;
 833           instead it lives on. This results in that it could be reused as
 834           a target later on when the pad was reallocated.
 835         **/
 836         if(o->op_targ) {
 837           pad_swipe(o->op_targ,1);
 838           o->op_targ = 0;
 839         }
 840 #endif
 841         break;
 842     case OP_DUMP:
 843     case OP_GOTO:
 844     case OP_NEXT:
 845     case OP_LAST:
 846     case OP_REDO:
 847         if (o->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
 848             break;
 849         /* FALL THROUGH */
 850     case OP_TRANS:
 851     case OP_TRANSR:
 852         if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
 853             assert(o->op_type == OP_TRANS || o->op_type == OP_TRANSR);
 854 #ifdef USE_ITHREADS
 855             if (cPADOPo->op_padix > 0) {
 856                 pad_swipe(cPADOPo->op_padix, TRUE);
 857                 cPADOPo->op_padix = 0;
 858             }
 859 #else
 860             SvREFCNT_dec(cSVOPo->op_sv);
 861             cSVOPo->op_sv = NULL;
 862 #endif
 863         }
 864         else {
 865             PerlMemShared_free(cPVOPo->op_pv);
 866             cPVOPo->op_pv = NULL;
 867         }
 868         break;
 869     case OP_SUBST:
 870         op_free(cPMOPo->op_pmreplrootu.op_pmreplroot);
 871         goto clear_pmop;
 872     case OP_PUSHRE:
 873 #ifdef USE_ITHREADS
 874         if (cPMOPo->op_pmreplrootu.op_pmtargetoff) {
 875             /* No GvIN_PAD_off here, because other references may still
 876              * exist on the pad */
 877             pad_swipe(cPMOPo->op_pmreplrootu.op_pmtargetoff, TRUE);
 878         }
 879 #else
 880         SvREFCNT_dec(MUTABLE_SV(cPMOPo->op_pmreplrootu.op_pmtargetgv));
 881 #endif
 882         /* FALL THROUGH */
 883     case OP_MATCH:
 884     case OP_QR:
 885 clear_pmop:
 886         if (!(cPMOPo->op_pmflags & PMf_CODELIST_PRIVATE))
 887             op_free(cPMOPo->op_code_list);
 888         cPMOPo->op_code_list = NULL;
 889         forget_pmop(cPMOPo);
 890         cPMOPo->op_pmreplrootu.op_pmreplroot = NULL;
 891         /* we use the same protection as the "SAFE" version of the PM_ macros
 892          * here since sv_clean_all might release some PMOPs
 893          * after PL_regex_padav has been cleared
 894          * and the clearing of PL_regex_padav needs to
 895          * happen before sv_clean_all
 896          */
 897 #ifdef USE_ITHREADS
 898         if(PL_regex_pad) {        /* We could be in destruction */
 899             const IV offset = (cPMOPo)->op_pmoffset;
 900             ReREFCNT_dec(PM_GETRE(cPMOPo));
 901             PL_regex_pad[offset] = &PL_sv_undef;
 902             sv_catpvn_nomg(PL_regex_pad[0], (const char *)&offset,
 903                            sizeof(offset));
 904         }
 905 #else
 906         ReREFCNT_dec(PM_GETRE(cPMOPo));
 907         PM_SETRE(cPMOPo, NULL);
 908 #endif
 909
 910         break;
 911     }
 912
 913     if (o->op_targ > 0) {
 914         pad_free(o->op_targ);
 915         o->op_targ = 0;
 916     }
 917 }
 918
 919 STATIC void
 920 S_cop_free(pTHX_ COP* cop)
 921 {
 922     PERL_ARGS_ASSERT_COP_FREE;
 923
 924     CopFILE_free(cop);
 925     if (! specialWARN(cop->cop_warnings))
 926         PerlMemShared_free(cop->cop_warnings);
 927     cophh_free(CopHINTHASH_get(cop));
 928     if (PL_curcop == cop)
 929        PL_curcop = NULL;
 930 }
 931
 932 STATIC void
 933 S_forget_pmop(pTHX_ PMOP *const o
 934               )
 935 {
 936     HV * const pmstash = PmopSTASH(o);
 937
 938     PERL_ARGS_ASSERT_FORGET_PMOP;
 939
 940     if (pmstash && !SvIS_FREED(pmstash) && SvMAGICAL(pmstash)) {
 941         MAGIC * const mg = mg_find((const SV *)pmstash, PERL_MAGIC_symtab);
 942         if (mg) {
 943             PMOP **const array = (PMOP**) mg->mg_ptr;
 944             U32 count = mg->mg_len / sizeof(PMOP**);
 945             U32 i = count;
 946
 947             while (i--) {
 948                 if (array[i] == o) {
 949                     /* Found it. Move the entry at the end to overwrite it.  */
 950                     array[i] = array[--count];
 951                     mg->mg_len = count * sizeof(PMOP**);
 952                     /* Could realloc smaller at this point always, but probably
 953                        not worth it. Probably worth free()ing if we're the
 954                        last.  */
 955                     if(!count) {
 956                         Safefree(mg->mg_ptr);
 957                         mg->mg_ptr = NULL;
 958                     }
 959                     break;
 960                 }
 961             }
 962         }
 963     }
 964     if (PL_curpm == o)
 965         PL_curpm = NULL;
 966 }
 967
 968 STATIC void
 969 S_find_and_forget_pmops(pTHX_ OP *o)
 970 {
 971     PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS;
 972
 973     if (o->op_flags & OPf_KIDS) {
 974         OP *kid = cUNOPo->op_first;
 975         while (kid) {
 976             switch (kid->op_type) {
 977             case OP_SUBST:
 978             case OP_PUSHRE:
 979             case OP_MATCH:
 980             case OP_QR:
 981                 forget_pmop((PMOP*)kid);
 982             }
 983             find_and_forget_pmops(kid);
 984             kid = kid->op_sibling;
 985         }
 986     }
 987 }
 988
 989 void
 990 Perl_op_null(pTHX_ OP *o)
 991 {
 992     dVAR;
 993
 994     PERL_ARGS_ASSERT_OP_NULL;
 995
 996     if (o->op_type == OP_NULL)
 997         return;
 998     if (!PL_madskills)
 999         op_clear(o);
1000     o->op_targ = o->op_type;
1001     o->op_type = OP_NULL;
1002     o->op_ppaddr = PL_ppaddr[OP_NULL];
1003 }
1004
1005 void
1006 Perl_op_refcnt_lock(pTHX)
1007 {
1008     dVAR;
1009     PERL_UNUSED_CONTEXT;
1010     OP_REFCNT_LOCK;
1011 }
1012
1013 void
1014 Perl_op_refcnt_unlock(pTHX)
1015 {
1016     dVAR;
1017     PERL_UNUSED_CONTEXT;
1018     OP_REFCNT_UNLOCK;
1019 }
1020
1021 /* Contextualizers */
1022
1023 /*
1024 =for apidoc Am|OP *|op_contextualize|OP *o|I32 context
1025
1026 Applies a syntactic context to an op tree representing an expression.
1027 I<o> is the op tree, and I<context> must be C<G_SCALAR>, C<G_ARRAY>,
1028 or C<G_VOID> to specify the context to apply.  The modified op tree
1029 is returned.
1030
1031 =cut
1032 */
1033
1034 OP *
1035 Perl_op_contextualize(pTHX_ OP *o, I32 context)
1036 {
1037     PERL_ARGS_ASSERT_OP_CONTEXTUALIZE;
1038     switch (context) {
1039         case G_SCALAR: return scalar(o);
1040         case G_ARRAY:  return list(o);
1041         case G_VOID:   return scalarvoid(o);
1042         default:
1043             Perl_croak(aTHX_ "panic: op_contextualize bad context %ld",
1044                        (long) context);
1045             return o;
1046     }
1047 }
1048
1049 /*
1050 =head1 Optree Manipulation Functions
1051
1052 =for apidoc Am|OP*|op_linklist|OP *o
1053 This function is the implementation of the L</LINKLIST> macro. It should
1054 not be called directly.
1055
1056 =cut
1057 */
1058
1059 OP *
1060 Perl_op_linklist(pTHX_ OP *o)
1061 {
1062     OP *first;
1063
1064     PERL_ARGS_ASSERT_OP_LINKLIST;
1065
1066     if (o->op_next)
1067         return o->op_next;
1068
1069     /* establish postfix order */
1070     first = cUNOPo->op_first;
1071     if (first) {
1072         OP *kid;
1073         o->op_next = LINKLIST(first);
1074         kid = first;
1075         for (;;) {
1076             if (kid->op_sibling) {
1077                 kid->op_next = LINKLIST(kid->op_sibling);
1078                 kid = kid->op_sibling;
1079             } else {
1080                 kid->op_next = o;
1081                 break;
1082             }
1083         }
1084     }
1085     else
1086         o->op_next = o;
1087
1088     return o->op_next;
1089 }
1090
1091 static OP *
1092 S_scalarkids(pTHX_ OP *o)
1093 {
1094     if (o && o->op_flags & OPf_KIDS) {
1095         OP *kid;
1096         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1097             scalar(kid);
1098     }
1099     return o;
1100 }
1101
1102 STATIC OP *
1103 S_scalarboolean(pTHX_ OP *o)
1104 {
1105     dVAR;
1106
1107     PERL_ARGS_ASSERT_SCALARBOOLEAN;
1108
1109     if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST
1110      && !(cBINOPo->op_first->op_flags & OPf_SPECIAL)) {
1111         if (ckWARN(WARN_SYNTAX)) {
1112             const line_t oldline = CopLINE(PL_curcop);
1113
1114             if (PL_parser && PL_parser->copline != NOLINE) {
1115                 /* This ensures that warnings are reported at the first line
1116                    of the conditional, not the last.  */
1117                 CopLINE_set(PL_curcop, PL_parser->copline);
1118             }
1119             Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Found = in conditional, should be ==");
1120             CopLINE_set(PL_curcop, oldline);
1121         }
1122     }
1123     return scalar(o);
1124 }
1125
1126 static SV *
1127 S_op_varname(pTHX_ const OP *o)
1128 {
1129     assert(o);
1130     assert(o->op_type == OP_PADAV || o->op_type == OP_RV2AV ||
1131            o->op_type == OP_PADHV || o->op_type == OP_RV2HV);
1132     {
1133         const char funny  = o->op_type == OP_PADAV
1134                          || o->op_type == OP_RV2AV ? '@' : '%';
1135         if (o->op_type == OP_RV2AV || o->op_type == OP_RV2HV) {
1136             GV *gv;
1137             if (cUNOPo->op_first->op_type != OP_GV
1138              || !(gv = cGVOPx_gv(cUNOPo->op_first)))
1139                 return NULL;
1140             return varname(gv, funny, 0, NULL, 0, 1);
1141         }
1142         return
1143             varname(MUTABLE_GV(PL_compcv), funny, o->op_targ, NULL, 0, 1);
1144     }
1145 }
1146
1147 static void
1148 S_scalar_slice_warning(pTHX_ const OP *o)
1149 {
1150     OP *kid;
1151     const char lbrack =
1152         o->op_type == OP_KVHSLICE || o->op_type == OP_HSLICE ? '{' : '[';
1153     const char rbrack =
1154         o->op_type == OP_KVHSLICE || o->op_type == OP_HSLICE ? '}' : ']';
1155     const char funny =
1156         o->op_type == OP_ASLICE || o->op_type == OP_HSLICE ? '@' : '%';
1157     SV *name;
1158     SV *keysv;
1159     const char *key = NULL;
1160
1161     if (!(o->op_private & OPpSLICEWARNING))
1162         return;
1163     if (PL_parser && PL_parser->error_count)
1164         /* This warning can be nonsensical when there is a syntax error. */
1165         return;
1166
1167     kid = cLISTOPo->op_first;
1168     kid = kid->op_sibling; /* get past pushmark */
1169     /* weed out false positives: any ops that can return lists */
1170     switch (kid->op_type) {
1171     case OP_BACKTICK:
1172     case OP_GLOB:
1173     case OP_READLINE:
1174     case OP_MATCH:
1175     case OP_RV2AV:
1176     case OP_EACH:
1177     case OP_VALUES:
1178     case OP_KEYS:
1179     case OP_SPLIT:
1180     case OP_LIST:
1181     case OP_SORT:
1182     case OP_REVERSE:
1183     case OP_ENTERSUB:
1184     case OP_CALLER:
1185     case OP_LSTAT:
1186     case OP_STAT:
1187     case OP_READDIR:
1188     case OP_SYSTEM:
1189     case OP_TMS:
1190     case OP_LOCALTIME:
1191     case OP_GMTIME:
1192     case OP_ENTEREVAL:
1193     case OP_REACH:
1194     case OP_RKEYS:
1195     case OP_RVALUES:
1196         return;
1197     }
1198     assert(kid->op_sibling);
1199     name = S_op_varname(aTHX_ kid->op_sibling);
1200     if (!name) /* XS module fiddling with the op tree */
1201         return;
1202     if (kid->op_type == OP_CONST) {
1203         keysv = kSVOP_sv;
1204         if (SvPOK(kSVOP_sv)) {
1205             SV *sv = keysv;
1206             keysv = sv_newmortal();
1207             pv_pretty(keysv, SvPVX_const(sv), SvCUR(sv), 32, NULL, NULL,
1208                       PERL_PV_PRETTY_DUMP |PERL_PV_ESCAPE_UNI_DETECT);
1209         }
1210         else if (!SvOK(keysv))
1211             key = "undef";
1212     }
1213     else key = "...";
1214     assert(SvPOK(name));
1215     sv_chop(name,SvPVX(name)+1);
1216     if (key)
1217        /* diag_listed_as: Scalar value %%s[%s] better written as $%s[%s] */
1218         Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
1219                    "Scalar value %c%"SVf"%c%s%c better written as $%"SVf
1220                    "%c%s%c",
1221                     funny, SVfARG(name), lbrack, key, rbrack, SVfARG(name),
1222                     lbrack, key, rbrack);
1223     else
1224        /* diag_listed_as: Scalar value %%s[%s] better written as $%s[%s] */
1225         Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
1226                    "Scalar value %c%"SVf"%c%"SVf"%c better written as $%"
1227                     SVf"%c%"SVf"%c",
1228                     funny, SVfARG(name), lbrack, keysv, rbrack,
1229                     SVfARG(name), lbrack, keysv, rbrack);
1230 }
1231
1232 OP *
1233 Perl_scalar(pTHX_ OP *o)
1234 {
1235     dVAR;
1236     OP *kid;
1237
1238     /* assumes no premature commitment */
1239     if (!o || (PL_parser && PL_parser->error_count)
1240          || (o->op_flags & OPf_WANT)
1241          || o->op_type == OP_RETURN)
1242     {
1243         return o;
1244     }
1245
1246     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
1247
1248     switch (o->op_type) {
1249     case OP_REPEAT:
1250         scalar(cBINOPo->op_first);
1251         break;
1252     case OP_OR:
1253     case OP_AND:
1254     case OP_COND_EXPR:
1255         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1256             scalar(kid);
1257         break;
1258         /* FALL THROUGH */
1259     case OP_SPLIT:
1260     case OP_MATCH:
1261     case OP_QR:
1262     case OP_SUBST:
1263     case OP_NULL:
1264     default:
1265         if (o->op_flags & OPf_KIDS) {
1266             for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
1267                 scalar(kid);
1268         }
1269         break;
1270     case OP_LEAVE:
1271     case OP_LEAVETRY:
1272         kid = cLISTOPo->op_first;
1273         scalar(kid);
1274         kid = kid->op_sibling;
1275     do_kids:
1276         while (kid) {
1277             OP *sib = kid->op_sibling;
1278             if (sib && kid->op_type != OP_LEAVEWHEN)
1279                 scalarvoid(kid);
1280             else
1281                 scalar(kid);
1282             kid = sib;
1283         }
1284         PL_curcop = &PL_compiling;
1285         break;
1286     case OP_SCOPE:
1287     case OP_LINESEQ:
1288     case OP_LIST:
1289         kid = cLISTOPo->op_first;
1290         goto do_kids;
1291     case OP_SORT:
1292         Perl_ck_warner(aTHX_ packWARN(WARN_VOID), "Useless use of sort in scalar context");
1293         break;
1294     case OP_KVHSLICE:
1295     case OP_KVASLICE:
1296         S_scalar_slice_warning(aTHX_ o);
1297     }
1298     return o;
1299 }
1300
1301 OP *
1302 Perl_scalarvoid(pTHX_ OP *o)
1303 {
1304     dVAR;
1305     OP *kid;
1306     SV *useless_sv = NULL;
1307     const char* useless = NULL;
1308     SV* sv;
1309     U8 want;
1310
1311     PERL_ARGS_ASSERT_SCALARVOID;
1312
1313     /* trailing mad null ops don't count as "there" for void processing */
1314     if (PL_madskills &&
1315         o->op_type != OP_NULL &&
1316         o->op_sibling &&
1317         o->op_sibling->op_type == OP_NULL)
1318     {
1319         OP *sib;
1320         for (sib = o->op_sibling;
1321                 sib && sib->op_type == OP_NULL;
1322                 sib = sib->op_sibling) ;
1323
1324         if (!sib)
1325             return o;
1326     }
1327
1328     if (o->op_type == OP_NEXTSTATE
1329         || o->op_type == OP_DBSTATE
1330         || (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
1331                                       || o->op_targ == OP_DBSTATE)))
1332         PL_curcop = (COP*)o;            /* for warning below */
1333
1334     /* assumes no premature commitment */
1335     want = o->op_flags & OPf_WANT;
1336     if ((want && want != OPf_WANT_SCALAR)
1337          || (PL_parser && PL_parser->error_count)
1338          || o->op_type == OP_RETURN || o->op_type == OP_REQUIRE || o->op_type == OP_LEAVEWHEN)
1339     {
1340         return o;
1341     }
1342
1343     if ((o->op_private & OPpTARGET_MY)
1344         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1345     {
1346         return scalar(o);                       /* As if inside SASSIGN */
1347     }
1348
1349     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
1350
1351     switch (o->op_type) {
1352     default:
1353         if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
1354             break;
1355         /* FALL THROUGH */
1356     case OP_REPEAT:
1357         if (o->op_flags & OPf_STACKED)
1358             break;
1359         goto func_ops;
1360     case OP_SUBSTR:
1361         if (o->op_private == 4)
1362             break;
1363         /* FALL THROUGH */
1364     case OP_GVSV:
1365     case OP_WANTARRAY:
1366     case OP_GV:
1367     case OP_SMARTMATCH:
1368     case OP_PADSV:
1369     case OP_PADAV:
1370     case OP_PADHV:
1371     case OP_PADANY:
1372     case OP_AV2ARYLEN:
1373     case OP_REF:
1374     case OP_REFGEN:
1375     case OP_SREFGEN:
1376     case OP_DEFINED:
1377     case OP_HEX:
1378     case OP_OCT:
1379     case OP_LENGTH:
1380     case OP_VEC:
1381     case OP_INDEX:
1382     case OP_RINDEX:
1383     case OP_SPRINTF:
1384     case OP_AELEM:
1385     case OP_AELEMFAST:
1386     case OP_AELEMFAST_LEX:
1387     case OP_ASLICE:
1388     case OP_KVASLICE:
1389     case OP_HELEM:
1390     case OP_HSLICE:
1391     case OP_KVHSLICE:
1392     case OP_UNPACK:
1393     case OP_PACK:
1394     case OP_JOIN:
1395     case OP_LSLICE:
1396     case OP_ANONLIST:
1397     case OP_ANONHASH:
1398     case OP_SORT:
1399     case OP_REVERSE:
1400     case OP_RANGE:
1401     case OP_FLIP:
1402     case OP_FLOP:
1403     case OP_CALLER:
1404     case OP_FILENO:
1405     case OP_EOF:
1406     case OP_TELL:
1407     case OP_GETSOCKNAME:
1408     case OP_GETPEERNAME:
1409     case OP_READLINK:
1410     case OP_TELLDIR:
1411     case OP_GETPPID:
1412     case OP_GETPGRP:
1413     case OP_GETPRIORITY:
1414     case OP_TIME:
1415     case OP_TMS:
1416     case OP_LOCALTIME:
1417     case OP_GMTIME:
1418     case OP_GHBYNAME:
1419     case OP_GHBYADDR:
1420     case OP_GHOSTENT:
1421     case OP_GNBYNAME:
1422     case OP_GNBYADDR:
1423     case OP_GNETENT:
1424     case OP_GPBYNAME:
1425     case OP_GPBYNUMBER:
1426     case OP_GPROTOENT:
1427     case OP_GSBYNAME:
1428     case OP_GSBYPORT:
1429     case OP_GSERVENT:
1430     case OP_GPWNAM:
1431     case OP_GPWUID:
1432     case OP_GGRNAM:
1433     case OP_GGRGID:
1434     case OP_GETLOGIN:
1435     case OP_PROTOTYPE:
1436     case OP_RUNCV:
1437       func_ops:
1438         if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)))
1439             /* Otherwise it's "Useless use of grep iterator" */
1440             useless = OP_DESC(o);
1441         break;
1442
1443     case OP_SPLIT:
1444         kid = cLISTOPo->op_first;
1445         if (kid && kid->op_type == OP_PUSHRE
1446 #ifdef USE_ITHREADS
1447                 && !((PMOP*)kid)->op_pmreplrootu.op_pmtargetoff)
1448 #else
1449                 && !((PMOP*)kid)->op_pmreplrootu.op_pmtargetgv)
1450 #endif
1451             useless = OP_DESC(o);
1452         break;
1453
1454     case OP_NOT:
1455        kid = cUNOPo->op_first;
1456        if (kid->op_type != OP_MATCH && kid->op_type != OP_SUBST &&
1457            kid->op_type != OP_TRANS && kid->op_type != OP_TRANSR) {
1458                 goto func_ops;
1459        }
1460        useless = "negative pattern binding (!~)";
1461        break;
1462
1463     case OP_SUBST:
1464         if (cPMOPo->op_pmflags & PMf_NONDESTRUCT)
1465             useless = "non-destructive substitution (s///r)";
1466         break;
1467
1468     case OP_TRANSR:
1469         useless = "non-destructive transliteration (tr///r)";
1470         break;
1471
1472     case OP_RV2GV:
1473     case OP_RV2SV:
1474     case OP_RV2AV:
1475     case OP_RV2HV:
1476         if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)) &&
1477                 (!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
1478             useless = "a variable";
1479         break;
1480
1481     case OP_CONST:
1482         sv = cSVOPo_sv;
1483         if (cSVOPo->op_private & OPpCONST_STRICT)
1484             no_bareword_allowed(o);
1485         else {
1486             if (ckWARN(WARN_VOID)) {
1487                 /* don't warn on optimised away booleans, eg
1488                  * use constant Foo, 5; Foo || print; */
1489                 if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
1490                     useless = NULL;
1491                 /* the constants 0 and 1 are permitted as they are
1492                    conventionally used as dummies in constructs like
1493                         1 while some_condition_with_side_effects;  */
1494                 else if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
1495                     useless = NULL;
1496                 else if (SvPOK(sv)) {
1497                     SV * const dsv = newSVpvs("");
1498                     useless_sv
1499                         = Perl_newSVpvf(aTHX_
1500                                         "a constant (%s)",
1501                                         pv_pretty(dsv, SvPVX_const(sv),
1502                                                   SvCUR(sv), 32, NULL, NULL,
1503                                                   PERL_PV_PRETTY_DUMP
1504                                                   | PERL_PV_ESCAPE_NOCLEAR
1505                                                   | PERL_PV_ESCAPE_UNI_DETECT));
1506                     SvREFCNT_dec_NN(dsv);
1507                 }
1508                 else if (SvOK(sv)) {
1509                     useless_sv = Perl_newSVpvf(aTHX_ "a constant (%"SVf")", sv);
1510                 }
1511                 else
1512                     useless = "a constant (undef)";
1513             }
1514         }
1515         op_null(o);             /* don't execute or even remember it */
1516         break;
1517
1518     case OP_POSTINC:
1519         o->op_type = OP_PREINC;         /* pre-increment is faster */
1520         o->op_ppaddr = PL_ppaddr[OP_PREINC];
1521         break;
1522
1523     case OP_POSTDEC:
1524         o->op_type = OP_PREDEC;         /* pre-decrement is faster */
1525         o->op_ppaddr = PL_ppaddr[OP_PREDEC];
1526         break;
1527
1528     case OP_I_POSTINC:
1529         o->op_type = OP_I_PREINC;       /* pre-increment is faster */
1530         o->op_ppaddr = PL_ppaddr[OP_I_PREINC];
1531         break;
1532
1533     case OP_I_POSTDEC:
1534         o->op_type = OP_I_PREDEC;       /* pre-decrement is faster */
1535         o->op_ppaddr = PL_ppaddr[OP_I_PREDEC];
1536         break;
1537
1538     case OP_SASSIGN: {
1539         OP *rv2gv;
1540         UNOP *refgen, *rv2cv;
1541         LISTOP *exlist;
1542
1543         if ((o->op_private & ~OPpASSIGN_BACKWARDS) != 2)
1544             break;
1545
1546         rv2gv = ((BINOP *)o)->op_last;
1547         if (!rv2gv || rv2gv->op_type != OP_RV2GV)
1548             break;
1549
1550         refgen = (UNOP *)((BINOP *)o)->op_first;
1551
1552         if (!refgen || refgen->op_type != OP_REFGEN)
1553             break;
1554
1555         exlist = (LISTOP *)refgen->op_first;
1556         if (!exlist || exlist->op_type != OP_NULL
1557             || exlist->op_targ != OP_LIST)
1558             break;
1559
1560         if (exlist->op_first->op_type != OP_PUSHMARK)
1561             break;
1562
1563         rv2cv = (UNOP*)exlist->op_last;
1564
1565         if (rv2cv->op_type != OP_RV2CV)
1566             break;
1567
1568         assert ((rv2gv->op_private & OPpDONT_INIT_GV) == 0);
1569         assert ((o->op_private & OPpASSIGN_CV_TO_GV) == 0);
1570         assert ((rv2cv->op_private & OPpMAY_RETURN_CONSTANT) == 0);
1571
1572         o->op_private |= OPpASSIGN_CV_TO_GV;
1573         rv2gv->op_private |= OPpDONT_INIT_GV;
1574         rv2cv->op_private |= OPpMAY_RETURN_CONSTANT;
1575
1576         break;
1577     }
1578
1579     case OP_AASSIGN: {
1580         inplace_aassign(o);
1581         break;
1582     }
1583
1584     case OP_OR:
1585     case OP_AND:
1586         kid = cLOGOPo->op_first;
1587         if (kid->op_type == OP_NOT
1588             && (kid->op_flags & OPf_KIDS)
1589             && !PL_madskills) {
1590             if (o->op_type == OP_AND) {
1591                 o->op_type = OP_OR;
1592                 o->op_ppaddr = PL_ppaddr[OP_OR];
1593             } else {
1594                 o->op_type = OP_AND;
1595                 o->op_ppaddr = PL_ppaddr[OP_AND];
1596             }
1597             op_null(kid);
1598         }
1599
1600     case OP_DOR:
1601     case OP_COND_EXPR:
1602     case OP_ENTERGIVEN:
1603     case OP_ENTERWHEN:
1604         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1605             scalarvoid(kid);
1606         break;
1607
1608     case OP_NULL:
1609         if (o->op_flags & OPf_STACKED)
1610             break;
1611         /* FALL THROUGH */
1612     case OP_NEXTSTATE:
1613     case OP_DBSTATE:
1614     case OP_ENTERTRY:
1615     case OP_ENTER:
1616         if (!(o->op_flags & OPf_KIDS))
1617             break;
1618         /* FALL THROUGH */
1619     case OP_SCOPE:
1620     case OP_LEAVE:
1621     case OP_LEAVETRY:
1622     case OP_LEAVELOOP:
1623     case OP_LINESEQ:
1624     case OP_LIST:
1625     case OP_LEAVEGIVEN:
1626     case OP_LEAVEWHEN:
1627         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1628             scalarvoid(kid);
1629         break;
1630     case OP_ENTEREVAL:
1631         scalarkids(o);
1632         break;
1633     case OP_SCALAR:
1634         return scalar(o);
1635     }
1636
1637     if (useless_sv) {
1638         /* mortalise it, in case warnings are fatal.  */
1639         Perl_ck_warner(aTHX_ packWARN(WARN_VOID),
1640                        "Useless use of %"SVf" in void context",
1641                        sv_2mortal(useless_sv));
1642     }
1643     else if (useless) {
1644        Perl_ck_warner(aTHX_ packWARN(WARN_VOID),
1645                       "Useless use of %s in void context",
1646                       useless);
1647     }
1648     return o;
1649 }
1650
1651 static OP *
1652 S_listkids(pTHX_ OP *o)
1653 {
1654     if (o && o->op_flags & OPf_KIDS) {
1655         OP *kid;
1656         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1657             list(kid);
1658     }
1659     return o;
1660 }
1661
1662 OP *
1663 Perl_list(pTHX_ OP *o)
1664 {
1665     dVAR;
1666     OP *kid;
1667
1668     /* assumes no premature commitment */
1669     if (!o || (o->op_flags & OPf_WANT)
1670          || (PL_parser && PL_parser->error_count)
1671          || o->op_type == OP_RETURN)
1672     {
1673         return o;
1674     }
1675
1676     if ((o->op_private & OPpTARGET_MY)
1677         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1678     {
1679         return o;                               /* As if inside SASSIGN */
1680     }
1681
1682     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
1683
1684     switch (o->op_type) {
1685     case OP_FLOP:
1686     case OP_REPEAT:
1687         list(cBINOPo->op_first);
1688         break;
1689     case OP_OR:
1690     case OP_AND:
1691     case OP_COND_EXPR:
1692         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1693             list(kid);
1694         break;
1695     default:
1696     case OP_MATCH:
1697     case OP_QR:
1698     case OP_SUBST:
1699     case OP_NULL:
1700         if (!(o->op_flags & OPf_KIDS))
1701             break;
1702         if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1703             list(cBINOPo->op_first);
1704             return gen_constant_list(o);
1705         }
1706     case OP_LIST:
1707         listkids(o);
1708         break;
1709     case OP_LEAVE:
1710     case OP_LEAVETRY:
1711         kid = cLISTOPo->op_first;
1712         list(kid);
1713         kid = kid->op_sibling;
1714     do_kids:
1715         while (kid) {
1716             OP *sib = kid->op_sibling;
1717             if (sib && kid->op_type != OP_LEAVEWHEN)
1718                 scalarvoid(kid);
1719             else
1720                 list(kid);
1721             kid = sib;
1722         }
1723         PL_curcop = &PL_compiling;
1724         break;
1725     case OP_SCOPE:
1726     case OP_LINESEQ:
1727         kid = cLISTOPo->op_first;
1728         goto do_kids;
1729     }
1730     return o;
1731 }
1732
1733 static OP *
1734 S_scalarseq(pTHX_ OP *o)
1735 {
1736     dVAR;
1737     if (o) {
1738         const OPCODE type = o->op_type;
1739
1740         if (type == OP_LINESEQ || type == OP_SCOPE ||
1741             type == OP_LEAVE || type == OP_LEAVETRY)
1742         {
1743             OP *kid;
1744             for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
1745                 if (kid->op_sibling) {
1746                     scalarvoid(kid);
1747                 }
1748             }
1749             PL_curcop = &PL_compiling;
1750         }
1751         o->op_flags &= ~OPf_PARENS;
1752         if (PL_hints & HINT_BLOCK_SCOPE)
1753             o->op_flags |= OPf_PARENS;
1754     }
1755     else
1756         o = newOP(OP_STUB, 0);
1757     return o;
1758 }
1759
1760 STATIC OP *
1761 S_modkids(pTHX_ OP *o, I32 type)
1762 {
1763     if (o && o->op_flags & OPf_KIDS) {
1764         OP *kid;
1765         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1766             op_lvalue(kid, type);
1767     }
1768     return o;
1769 }
1770
1771 /*
1772 =for apidoc finalize_optree
1773
1774 This function finalizes the optree. Should be called directly after
1775 the complete optree is built. It does some additional
1776 checking which can't be done in the normal ck_xxx functions and makes
1777 the tree thread-safe.
1778
1779 =cut
1780 */
1781 void
1782 Perl_finalize_optree(pTHX_ OP* o)
1783 {
1784     PERL_ARGS_ASSERT_FINALIZE_OPTREE;
1785
1786     ENTER;
1787     SAVEVPTR(PL_curcop);
1788
1789     finalize_op(o);
1790
1791     LEAVE;
1792 }
1793
1794 STATIC void
1795 S_finalize_op(pTHX_ OP* o)
1796 {
1797     PERL_ARGS_ASSERT_FINALIZE_OP;
1798
1799 #if defined(PERL_MAD) && defined(USE_ITHREADS)
1800     {
1801         /* Make sure mad ops are also thread-safe */
1802         MADPROP *mp = o->op_madprop;
1803         while (mp) {
1804             if (mp->mad_type == MAD_OP && mp->mad_vlen) {
1805                 OP *prop_op = (OP *) mp->mad_val;
1806                 /* We only need "Relocate sv to the pad for thread safety.", but this
1807                    easiest way to make sure it traverses everything */
1808                 if (prop_op->op_type == OP_CONST)
1809                     cSVOPx(prop_op)->op_private &= ~OPpCONST_STRICT;
1810                 finalize_op(prop_op);
1811             }
1812             mp = mp->mad_next;
1813         }
1814     }
1815 #endif
1816
1817     switch (o->op_type) {
1818     case OP_NEXTSTATE:
1819     case OP_DBSTATE:
1820         PL_curcop = ((COP*)o);          /* for warnings */
1821         break;
1822     case OP_EXEC:
1823         if ( o->op_sibling
1824             && (o->op_sibling->op_type == OP_NEXTSTATE || o->op_sibling->op_type == OP_DBSTATE)
1825             && ckWARN(WARN_EXEC))
1826             {
1827                 if (o->op_sibling->op_sibling) {
1828                     const OPCODE type = o->op_sibling->op_sibling->op_type;
1829                     if (type != OP_EXIT && type != OP_WARN && type != OP_DIE) {
1830                         const line_t oldline = CopLINE(PL_curcop);
1831                         CopLINE_set(PL_curcop, CopLINE((COP*)o->op_sibling));
1832                         Perl_warner(aTHX_ packWARN(WARN_EXEC),
1833                             "Statement unlikely to be reached");
1834                         Perl_warner(aTHX_ packWARN(WARN_EXEC),
1835                             "\t(Maybe you meant system() when you said exec()?)\n");
1836                         CopLINE_set(PL_curcop, oldline);
1837                     }
1838                 }
1839             }
1840         break;
1841
1842     case OP_GV:
1843         if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_PROTOTYPE)) {
1844             GV * const gv = cGVOPo_gv;
1845             if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
1846                 /* XXX could check prototype here instead of just carping */
1847                 SV * const sv = sv_newmortal();
1848                 gv_efullname3(sv, gv, NULL);
1849                 Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
1850                     "%"SVf"() called too early to check prototype",
1851                     SVfARG(sv));
1852             }
1853         }
1854         break;
1855
1856     case OP_CONST:
1857         if (cSVOPo->op_private & OPpCONST_STRICT)
1858             no_bareword_allowed(o);
1859         /* FALLTHROUGH */
1860 #ifdef USE_ITHREADS
1861     case OP_HINTSEVAL:
1862     case OP_METHOD_NAMED:
1863         /* Relocate sv to the pad for thread safety.
1864          * Despite being a "constant", the SV is written to,
1865          * for reference counts, sv_upgrade() etc. */
1866         if (cSVOPo->op_sv) {
1867             const PADOFFSET ix = pad_alloc(OP_CONST, SVf_READONLY);
1868             SvREFCNT_dec(PAD_SVl(ix));
1869             PAD_SETSV(ix, cSVOPo->op_sv);
1870             /* XXX I don't know how this isn't readonly already. */
1871             if (!SvIsCOW(PAD_SVl(ix))) SvREADONLY_on(PAD_SVl(ix));
1872             cSVOPo->op_sv = NULL;
1873             o->op_targ = ix;
1874         }
1875 #endif
1876         break;
1877
1878     case OP_HELEM: {
1879         UNOP *rop;
1880         SV *lexname;
1881         GV **fields;
1882         SV **svp, *sv;
1883         const char *key = NULL;
1884         STRLEN keylen;
1885
1886         if (((BINOP*)o)->op_last->op_type != OP_CONST)
1887             break;
1888
1889         /* Make the CONST have a shared SV */
1890         svp = cSVOPx_svp(((BINOP*)o)->op_last);
1891         if ((!SvIsCOW_shared_hash(sv = *svp))
1892             && SvTYPE(sv) < SVt_PVMG && SvOK(sv) && !SvROK(sv)) {
1893             key = SvPV_const(sv, keylen);
1894             lexname = newSVpvn_share(key,
1895                 SvUTF8(sv) ? -(I32)keylen : (I32)keylen,
1896                 0);
1897             SvREFCNT_dec_NN(sv);
1898             *svp = lexname;
1899         }
1900
1901         if ((o->op_private & (OPpLVAL_INTRO)))
1902             break;
1903
1904         rop = (UNOP*)((BINOP*)o)->op_first;
1905         if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
1906             break;
1907         lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
1908         if (!SvPAD_TYPED(lexname))
1909             break;
1910         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1911         if (!fields || !GvHV(*fields))
1912             break;
1913         if (!hv_fetch_ent(GvHV(*fields), *svp, FALSE, 0)) {
1914             Perl_croak(aTHX_ "No such class field \"%"SVf"\" "
1915                            "in variable %"SVf" of type %"HEKf,
1916                       SVfARG(*svp), SVfARG(lexname),
1917                       HEKfARG(HvNAME_HEK(SvSTASH(lexname))));
1918         }
1919         break;
1920     }
1921
1922     case OP_HSLICE: {
1923         UNOP *rop;
1924         SV *lexname;
1925         GV **fields;
1926         SV **svp;
1927         SVOP *first_key_op, *key_op;
1928
1929         S_scalar_slice_warning(aTHX_ o);
1930
1931         if ((o->op_private & (OPpLVAL_INTRO))
1932             /* I bet there's always a pushmark... */
1933             || ((LISTOP*)o)->op_first->op_sibling->op_type != OP_LIST)
1934             /* hmmm, no optimization if list contains only one key. */
1935             break;
1936         rop = (UNOP*)((LISTOP*)o)->op_last;
1937         if (rop->op_type != OP_RV2HV)
1938             break;
1939         if (rop->op_first->op_type == OP_PADSV)
1940             /* @$hash{qw(keys here)} */
1941             rop = (UNOP*)rop->op_first;
1942         else {
1943             /* @{$hash}{qw(keys here)} */
1944             if (rop->op_first->op_type == OP_SCOPE
1945                 && cLISTOPx(rop->op_first)->op_last->op_type == OP_PADSV)
1946                 {
1947                     rop = (UNOP*)cLISTOPx(rop->op_first)->op_last;
1948                 }
1949             else
1950                 break;
1951         }
1952
1953         lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
1954         if (!SvPAD_TYPED(lexname))
1955             break;
1956         fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
1957         if (!fields || !GvHV(*fields))
1958             break;
1959         /* Again guessing that the pushmark can be jumped over.... */
1960         first_key_op = (SVOP*)((LISTOP*)((LISTOP*)o)->op_first->op_sibling)
1961             ->op_first->op_sibling;
1962         for (key_op = first_key_op; key_op;
1963              key_op = (SVOP*)key_op->op_sibling) {
1964             if (key_op->op_type != OP_CONST)
1965                 continue;
1966             svp = cSVOPx_svp(key_op);
1967             if (!hv_fetch_ent(GvHV(*fields), *svp, FALSE, 0)) {
1968                 Perl_croak(aTHX_ "No such class field \"%"SVf"\" "
1969                            "in variable %"SVf" of type %"HEKf,
1970                       SVfARG(*svp), SVfARG(lexname),
1971                       HEKfARG(HvNAME_HEK(SvSTASH(lexname))));
1972             }
1973         }
1974         break;
1975     }
1976     case OP_ASLICE:
1977         S_scalar_slice_warning(aTHX_ o);
1978         break;
1979
1980     case OP_SUBST: {
1981         if (cPMOPo->op_pmreplrootu.op_pmreplroot)
1982             finalize_op(cPMOPo->op_pmreplrootu.op_pmreplroot);
1983         break;
1984     }
1985     default:
1986         break;
1987     }
1988
1989     if (o->op_flags & OPf_KIDS) {
1990         OP *kid;
1991         for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
1992             finalize_op(kid);
1993     }
1994 }
1995
1996 /*
1997 =for apidoc Amx|OP *|op_lvalue|OP *o|I32 type
1998
1999 Propagate lvalue ("modifiable") context to an op and its children.
2000 I<type> represents the context type, roughly based on the type of op that
2001 would do the modifying, although C<local()> is represented by OP_NULL,
2002 because it has no op type of its own (it is signalled by a flag on
2003 the lvalue op).
2004
2005 This function detects things that can't be modified, such as C<$x+1>, and
2006 generates errors for them. For example, C<$x+1 = 2> would cause it to be
2007 called with an op of type OP_ADD and a C<type> argument of OP_SASSIGN.
2008
2009 It also flags things that need to behave specially in an lvalue context,
2010 such as C<$$x = 5> which might have to vivify a reference in C<$x>.
2011
2012 =cut
2013 */
2014
2015 OP *
2016 Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags)
2017 {
2018     dVAR;
2019     OP *kid;
2020     /* -1 = error on localize, 0 = ignore localize, 1 = ok to localize */
2021     int localize = -1;
2022
2023     if (!o || (PL_parser && PL_parser->error_count))
2024         return o;
2025
2026     if ((o->op_private & OPpTARGET_MY)
2027         && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
2028     {
2029         return o;
2030     }
2031
2032     assert( (o->op_flags & OPf_WANT) != OPf_WANT_VOID );
2033
2034     if (type == OP_PRTF || type == OP_SPRINTF) type = OP_ENTERSUB;
2035
2036     switch (o->op_type) {
2037     case OP_UNDEF:
2038         PL_modcount++;
2039         return o;
2040     case OP_STUB:
2041         if ((o->op_flags & OPf_PARENS) || PL_madskills)
2042             break;
2043         goto nomod;
2044     case OP_ENTERSUB:
2045         if ((type == OP_UNDEF || type == OP_REFGEN || type == OP_LOCK) &&
2046             !(o->op_flags & OPf_STACKED)) {
2047             o->op_type = OP_RV2CV;              /* entersub => rv2cv */
2048             /* Both ENTERSUB and RV2CV use this bit, but for different pur-
2049                poses, so we need it clear.  */
2050             o->op_private &= ~1;
2051             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
2052             assert(cUNOPo->op_first->op_type == OP_NULL);
2053             op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
2054             break;
2055         }
2056         else {                          /* lvalue subroutine call */
2057             o->op_private |= OPpLVAL_INTRO
2058                            |(OPpENTERSUB_INARGS * (type == OP_LEAVESUBLV));
2059             PL_modcount = RETURN_UNLIMITED_NUMBER;
2060             if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
2061                 /* Potential lvalue context: */
2062                 o->op_private |= OPpENTERSUB_INARGS;
2063                 break;
2064             }
2065             else {                      /* Compile-time error message: */
2066                 OP *kid = cUNOPo->op_first;
2067                 CV *cv;
2068
2069                 if (kid->op_type != OP_PUSHMARK) {
2070                     if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
2071                         Perl_croak(aTHX_
2072                                 "panic: unexpected lvalue entersub "
2073                                 "args: type/targ %ld:%"UVuf,
2074                                 (long)kid->op_type, (UV)kid->op_targ);
2075                     kid = kLISTOP->op_first;
2076                 }
2077                 while (kid->op_sibling)
2078                     kid = kid->op_sibling;
2079                 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
2080                     break;      /* Postpone until runtime */
2081                 }
2082
2083                 kid = kUNOP->op_first;
2084                 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
2085                     kid = kUNOP->op_first;
2086                 if (kid->op_type == OP_NULL)
2087                     Perl_croak(aTHX_
2088                                "Unexpected constant lvalue entersub "
2089                                "entry via type/targ %ld:%"UVuf,
2090                                (long)kid->op_type, (UV)kid->op_targ);
2091                 if (kid->op_type != OP_GV) {
2092                     break;
2093                 }
2094
2095                 cv = GvCV(kGVOP_gv);
2096                 if (!cv)
2097                     break;
2098                 if (CvLVALUE(cv))
2099                     break;
2100             }
2101         }
2102         /* FALL THROUGH */
2103     default:
2104       nomod:
2105         if (flags & OP_LVALUE_NO_CROAK) return NULL;
2106         /* grep, foreach, subcalls, refgen */
2107         if (type == OP_GREPSTART || type == OP_ENTERSUB
2108          || type == OP_REFGEN    || type == OP_LEAVESUBLV)
2109             break;
2110         yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
2111                      (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
2112                       ? "do block"
2113                       : (o->op_type == OP_ENTERSUB
2114                         ? "non-lvalue subroutine call"
2115                         : OP_DESC(o))),
2116                      type ? PL_op_desc[type] : "local"));
2117         return o;
2118
2119     case OP_PREINC:
2120     case OP_PREDEC:
2121     case OP_POW:
2122     case OP_MULTIPLY:
2123     case OP_DIVIDE:
2124     case OP_MODULO:
2125     case OP_REPEAT:
2126     case OP_ADD:
2127     case OP_SUBTRACT:
2128     case OP_CONCAT:
2129     case OP_LEFT_SHIFT:
2130     case OP_RIGHT_SHIFT:
2131     case OP_BIT_AND:
2132     case OP_BIT_XOR:
2133     case OP_BIT_OR:
2134     case OP_I_MULTIPLY:
2135     case OP_I_DIVIDE:
2136     case OP_I_MODULO:
2137     case OP_I_ADD:
2138     case OP_I_SUBTRACT:
2139         if (!(o->op_flags & OPf_STACKED))
2140             goto nomod;
2141         PL_modcount++;
2142         break;
2143
2144     case OP_COND_EXPR:
2145         localize = 1;
2146         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
2147             op_lvalue(kid, type);
2148         break;
2149
2150     case OP_RV2AV:
2151     case OP_RV2HV:
2152         if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
2153            PL_modcount = RETURN_UNLIMITED_NUMBER;
2154             return o;           /* Treat \(@foo) like ordinary list. */
2155         }
2156         /* FALL THROUGH */
2157     case OP_RV2GV:
2158         if (scalar_mod_type(o, type))
2159             goto nomod;
2160         ref(cUNOPo->op_first, o->op_type);
2161         /* FALL THROUGH */
2162     case OP_ASLICE:
2163     case OP_HSLICE:
2164         localize = 1;
2165         /* FALL THROUGH */
2166     case OP_AASSIGN:
2167         if (type == OP_LEAVESUBLV)
2168             o->op_private |= OPpMAYBE_LVSUB;
2169         /* FALL THROUGH */
2170     case OP_NEXTSTATE:
2171     case OP_DBSTATE:
2172        PL_modcount = RETURN_UNLIMITED_NUMBER;
2173         break;
2174     case OP_KVHSLICE:
2175     case OP_KVASLICE:
2176         if (type == OP_LEAVESUBLV)
2177             o->op_private |= OPpMAYBE_LVSUB;
2178         goto nomod;
2179     case OP_AV2ARYLEN:
2180         PL_hints |= HINT_BLOCK_SCOPE;
2181         if (type == OP_LEAVESUBLV)
2182             o->op_private |= OPpMAYBE_LVSUB;
2183         PL_modcount++;
2184         break;
2185     case OP_RV2SV:
2186         ref(cUNOPo->op_first, o->op_type);
2187         localize = 1;
2188         /* FALL THROUGH */
2189     case OP_GV:
2190         PL_hints |= HINT_BLOCK_SCOPE;
2191     case OP_SASSIGN:
2192     case OP_ANDASSIGN:
2193     case OP_ORASSIGN:
2194     case OP_DORASSIGN:
2195         PL_modcount++;
2196         break;
2197
2198     case OP_AELEMFAST:
2199     case OP_AELEMFAST_LEX:
2200         localize = -1;
2201         PL_modcount++;
2202         break;
2203
2204     case OP_PADAV:
2205     case OP_PADHV:
2206        PL_modcount = RETURN_UNLIMITED_NUMBER;
2207         if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
2208             return o;           /* Treat \(@foo) like ordinary list. */
2209         if (scalar_mod_type(o, type))
2210             goto nomod;
2211         if (type == OP_LEAVESUBLV)
2212             o->op_private |= OPpMAYBE_LVSUB;
2213         /* FALL THROUGH */
2214     case OP_PADSV:
2215         PL_modcount++;
2216         if (!type) /* local() */
2217             Perl_croak(aTHX_ "Can't localize lexical variable %"SVf,
2218                  PAD_COMPNAME_SV(o->op_targ));
2219         break;
2220
2221     case OP_PUSHMARK:
2222         localize = 0;
2223         break;
2224
2225     case OP_KEYS:
2226     case OP_RKEYS:
2227         if (type != OP_SASSIGN && type != OP_LEAVESUBLV)
2228             goto nomod;
2229         goto lvalue_func;
2230     case OP_SUBSTR:
2231         if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
2232             goto nomod;
2233         /* FALL THROUGH */
2234     case OP_POS:
2235     case OP_VEC:
2236       lvalue_func:
2237         if (type == OP_LEAVESUBLV)
2238             o->op_private |= OPpMAYBE_LVSUB;
2239         if (o->op_flags & OPf_KIDS)
2240             op_lvalue(cBINOPo->op_first->op_sibling, type);
2241         break;
2242
2243     case OP_AELEM:
2244     case OP_HELEM:
2245         ref(cBINOPo->op_first, o->op_type);
2246         if (type == OP_ENTERSUB &&
2247              !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
2248             o->op_private |= OPpLVAL_DEFER;
2249         if (type == OP_LEAVESUBLV)
2250             o->op_private |= OPpMAYBE_LVSUB;
2251         localize = 1;
2252         PL_modcount++;
2253         break;
2254
2255     case OP_SCOPE:
2256     case OP_LEAVE:
2257     case OP_ENTER:
2258     case OP_LINESEQ:
2259         localize = 0;
2260         if (o->op_flags & OPf_KIDS)
2261             op_lvalue(cLISTOPo->op_last, type);
2262         break;
2263
2264     case OP_NULL:
2265         localize = 0;
2266         if (o->op_flags & OPf_SPECIAL)          /* do BLOCK */
2267             goto nomod;
2268         else if (!(o->op_flags & OPf_KIDS))
2269             break;
2270         if (o->op_targ != OP_LIST) {
2271             op_lvalue(cBINOPo->op_first, type);
2272             break;
2273         }
2274         /* FALL THROUGH */
2275     case OP_LIST:
2276         localize = 0;
2277         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2278             /* elements might be in void context because the list is
2279                in scalar context or because they are attribute sub calls */
2280             if ( (kid->op_flags & OPf_WANT) != OPf_WANT_VOID )
2281                 op_lvalue(kid, type);
2282         break;
2283
2284     case OP_RETURN:
2285         if (type != OP_LEAVESUBLV)
2286             goto nomod;
2287         break; /* op_lvalue()ing was handled by ck_return() */
2288
2289     case OP_COREARGS:
2290         return o;
2291     }
2292
2293     /* [20011101.069] File test operators interpret OPf_REF to mean that
2294        their argument is a filehandle; thus \stat(".") should not set
2295        it. AMS 20011102 */
2296     if (type == OP_REFGEN &&
2297         PL_check[o->op_type] == Perl_ck_ftst)
2298         return o;
2299
2300     if (type != OP_LEAVESUBLV)
2301         o->op_flags |= OPf_MOD;
2302
2303     if (type == OP_AASSIGN || type == OP_SASSIGN)
2304         o->op_flags |= OPf_SPECIAL|OPf_REF;
2305     else if (!type) { /* local() */
2306         switch (localize) {
2307         case 1:
2308             o->op_private |= OPpLVAL_INTRO;
2309             o->op_flags &= ~OPf_SPECIAL;
2310             PL_hints |= HINT_BLOCK_SCOPE;
2311             break;
2312         case 0:
2313             break;
2314         case -1:
2315             Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
2316                            "Useless localization of %s", OP_DESC(o));
2317         }
2318     }
2319     else if (type != OP_GREPSTART && type != OP_ENTERSUB
2320              && type != OP_LEAVESUBLV)
2321         o->op_flags |= OPf_REF;
2322     return o;
2323 }
2324
2325 STATIC bool
2326 S_scalar_mod_type(const OP *o, I32 type)
2327 {
2328     switch (type) {
2329     case OP_POS:
2330     case OP_SASSIGN:
2331         if (o && o->op_type == OP_RV2GV)
2332             return FALSE;
2333         /* FALL THROUGH */
2334     case OP_PREINC:
2335     case OP_PREDEC:
2336     case OP_POSTINC:
2337     case OP_POSTDEC:
2338     case OP_I_PREINC:
2339     case OP_I_PREDEC:
2340     case OP_I_POSTINC:
2341     case OP_I_POSTDEC:
2342     case OP_POW:
2343     case OP_MULTIPLY:
2344     case OP_DIVIDE:
2345     case OP_MODULO:
2346     case OP_REPEAT:
2347     case OP_ADD:
2348     case OP_SUBTRACT:
2349     case OP_I_MULTIPLY:
2350     case OP_I_DIVIDE:
2351     case OP_I_MODULO:
2352     case OP_I_ADD:
2353     case OP_I_SUBTRACT:
2354     case OP_LEFT_SHIFT:
2355     case OP_RIGHT_SHIFT:
2356     case OP_BIT_AND:
2357     case OP_BIT_XOR:
2358     case OP_BIT_OR:
2359     case OP_CONCAT:
2360     case OP_SUBST:
2361     case OP_TRANS:
2362     case OP_TRANSR:
2363     case OP_READ:
2364     case OP_SYSREAD:
2365     case OP_RECV:
2366     case OP_ANDASSIGN:
2367     case OP_ORASSIGN:
2368     case OP_DORASSIGN:
2369         return TRUE;
2370     default:
2371         return FALSE;
2372     }
2373 }
2374
2375 STATIC bool
2376 S_is_handle_constructor(const OP *o, I32 numargs)
2377 {
2378     PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR;
2379
2380     switch (o->op_type) {
2381     case OP_PIPE_OP:
2382     case OP_SOCKPAIR:
2383         if (numargs == 2)
2384             return TRUE;
2385         /* FALL THROUGH */
2386     case OP_SYSOPEN:
2387     case OP_OPEN:
2388     case OP_SELECT:             /* XXX c.f. SelectSaver.pm */
2389     case OP_SOCKET:
2390     case OP_OPEN_DIR:
2391     case OP_ACCEPT:
2392         if (numargs == 1)
2393             return TRUE;
2394         /* FALLTHROUGH */
2395     default:
2396         return FALSE;
2397     }
2398 }
2399
2400 static OP *
2401 S_refkids(pTHX_ OP *o, I32 type)
2402 {
2403     if (o && o->op_flags & OPf_KIDS) {
2404         OP *kid;
2405         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2406             ref(kid, type);
2407     }
2408     return o;
2409 }
2410
2411 OP *
2412 Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
2413 {
2414     dVAR;
2415     OP *kid;
2416
2417     PERL_ARGS_ASSERT_DOREF;
2418
2419     if (!o || (PL_parser && PL_parser->error_count))
2420         return o;
2421
2422     switch (o->op_type) {
2423     case OP_ENTERSUB:
2424         if ((type == OP_EXISTS || type == OP_DEFINED) &&
2425             !(o->op_flags & OPf_STACKED)) {
2426             o->op_type = OP_RV2CV;             /* entersub => rv2cv */
2427             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
2428             assert(cUNOPo->op_first->op_type == OP_NULL);
2429             op_null(((LISTOP*)cUNOPo->op_first)->op_first);     /* disable pushmark */
2430             o->op_flags |= OPf_SPECIAL;
2431             o->op_private &= ~1;
2432         }
2433         else if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV){
2434             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2435                               : type == OP_RV2HV ? OPpDEREF_HV
2436                               : OPpDEREF_SV);
2437             o->op_flags |= OPf_MOD;
2438         }
2439
2440         break;
2441
2442     case OP_COND_EXPR:
2443         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
2444             doref(kid, type, set_op_ref);
2445         break;
2446     case OP_RV2SV:
2447         if (type == OP_DEFINED)
2448             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2449         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2450         /* FALL THROUGH */
2451     case OP_PADSV:
2452         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2453             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2454                               : type == OP_RV2HV ? OPpDEREF_HV
2455                               : OPpDEREF_SV);
2456             o->op_flags |= OPf_MOD;
2457         }
2458         break;
2459
2460     case OP_RV2AV:
2461     case OP_RV2HV:
2462         if (set_op_ref)
2463             o->op_flags |= OPf_REF;
2464         /* FALL THROUGH */
2465     case OP_RV2GV:
2466         if (type == OP_DEFINED)
2467             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
2468         doref(cUNOPo->op_first, o->op_type, set_op_ref);
2469         break;
2470
2471     case OP_PADAV:
2472     case OP_PADHV:
2473         if (set_op_ref)
2474             o->op_flags |= OPf_REF;
2475         break;
2476
2477     case OP_SCALAR:
2478     case OP_NULL:
2479         if (!(o->op_flags & OPf_KIDS) || type == OP_DEFINED)
2480             break;
2481         doref(cBINOPo->op_first, type, set_op_ref);
2482         break;
2483     case OP_AELEM:
2484     case OP_HELEM:
2485         doref(cBINOPo->op_first, o->op_type, set_op_ref);
2486         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
2487             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
2488                               : type == OP_RV2HV ? OPpDEREF_HV
2489                               : OPpDEREF_SV);
2490             o->op_flags |= OPf_MOD;
2491         }
2492         break;
2493
2494     case OP_SCOPE:
2495     case OP_LEAVE:
2496         set_op_ref = FALSE;
2497         /* FALL THROUGH */
2498     case OP_ENTER:
2499     case OP_LIST:
2500         if (!(o->op_flags & OPf_KIDS))
2501             break;
2502         doref(cLISTOPo->op_last, type, set_op_ref);
2503         break;
2504     default:
2505         break;
2506     }
2507     return scalar(o);
2508
2509 }
2510
2511 STATIC OP *
2512 S_dup_attrlist(pTHX_ OP *o)
2513 {
2514     dVAR;
2515     OP *rop;
2516
2517     PERL_ARGS_ASSERT_DUP_ATTRLIST;
2518
2519     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
2520      * where the first kid is OP_PUSHMARK and the remaining ones
2521      * are OP_CONST.  We need to push the OP_CONST values.
2522      */
2523     if (o->op_type == OP_CONST)
2524         rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
2525 #ifdef PERL_MAD
2526     else if (o->op_type == OP_NULL)
2527         rop = NULL;
2528 #endif
2529     else {
2530         assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
2531         rop = NULL;
2532         for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
2533             if (o->op_type == OP_CONST)
2534                 rop = op_append_elem(OP_LIST, rop,
2535                                   newSVOP(OP_CONST, o->op_flags,
2536                                           SvREFCNT_inc_NN(cSVOPo->op_sv)));
2537         }
2538     }
2539     return rop;
2540 }
2541
2542 STATIC void
2543 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
2544 {
2545     dVAR;
2546     SV * const stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2547
2548     PERL_ARGS_ASSERT_APPLY_ATTRS;
2549
2550     /* fake up C<use attributes $pkg,$rv,@attrs> */
2551     ENTER;              /* need to protect against side-effects of 'use' */
2552
2553 #define ATTRSMODULE "attributes"
2554 #define ATTRSMODULE_PM "attributes.pm"
2555
2556     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2557                          newSVpvs(ATTRSMODULE),
2558                          NULL,
2559                          op_prepend_elem(OP_LIST,
2560                                       newSVOP(OP_CONST, 0, stashsv),
2561                                       op_prepend_elem(OP_LIST,
2562                                                    newSVOP(OP_CONST, 0,
2563                                                            newRV(target)),
2564                                                    dup_attrlist(attrs))));
2565     LEAVE;
2566 }
2567
2568 STATIC void
2569 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
2570 {
2571     dVAR;
2572     OP *pack, *imop, *arg;
2573     SV *meth, *stashsv, **svp;
2574
2575     PERL_ARGS_ASSERT_APPLY_ATTRS_MY;
2576
2577     if (!attrs)
2578         return;
2579
2580     assert(target->op_type == OP_PADSV ||
2581            target->op_type == OP_PADHV ||
2582            target->op_type == OP_PADAV);
2583
2584     /* Ensure that attributes.pm is loaded. */
2585     ENTER;              /* need to protect against side-effects of 'use' */
2586     /* Don't force the C<use> if we don't need it. */
2587     svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
2588     if (svp && *svp != &PL_sv_undef)
2589         NOOP;   /* already in %INC */
2590     else
2591         Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
2592                                newSVpvs(ATTRSMODULE), NULL);
2593     LEAVE;
2594
2595     /* Need package name for method call. */
2596     pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
2597
2598     /* Build up the real arg-list. */
2599     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2600
2601     arg = newOP(OP_PADSV, 0);
2602     arg->op_targ = target->op_targ;
2603     arg = op_prepend_elem(OP_LIST,
2604                        newSVOP(OP_CONST, 0, stashsv),
2605                        op_prepend_elem(OP_LIST,
2606                                     newUNOP(OP_REFGEN, 0,
2607                                             op_lvalue(arg, OP_REFGEN)),
2608                                     dup_attrlist(attrs)));
2609
2610     /* Fake up a method call to import */
2611     meth = newSVpvs_share("import");
2612     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
2613                    op_append_elem(OP_LIST,
2614                                op_prepend_elem(OP_LIST, pack, list(arg)),
2615                                newSVOP(OP_METHOD_NAMED, 0, meth)));
2616
2617     /* Combine the ops. */
2618     *imopsp = op_append_elem(OP_LIST, *imopsp, imop);
2619 }
2620
2621 /*
2622 =notfor apidoc apply_attrs_string
2623
2624 Attempts to apply a list of attributes specified by the C<attrstr> and
2625 C<len> arguments to the subroutine identified by the C<cv> argument which
2626 is expected to be associated with the package identified by the C<stashpv>
2627 argument (see L<attributes>).  It gets this wrong, though, in that it
2628 does not correctly identify the boundaries of the individual attribute
2629 specifications within C<attrstr>.  This is not really intended for the
2630 public API, but has to be listed here for systems such as AIX which
2631 need an explicit export list for symbols.  (It's called from XS code
2632 in support of the C<ATTRS:> keyword from F<xsubpp>.)  Patches to fix it
2633 to respect attribute syntax properly would be welcome.
2634
2635 =cut
2636 */
2637
2638 void
2639 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
2640                         const char *attrstr, STRLEN len)
2641 {
2642     OP *attrs = NULL;
2643
2644     PERL_ARGS_ASSERT_APPLY_ATTRS_STRING;
2645
2646     if (!len) {
2647         len = strlen(attrstr);
2648     }
2649
2650     while (len) {
2651         for (; isSPACE(*attrstr) && len; --len, ++attrstr) ;
2652         if (len) {
2653             const char * const sstr = attrstr;
2654             for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
2655             attrs = op_append_elem(OP_LIST, attrs,
2656                                 newSVOP(OP_CONST, 0,
2657                                         newSVpvn(sstr, attrstr-sstr)));
2658         }
2659     }
2660
2661     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
2662                      newSVpvs(ATTRSMODULE),
2663                      NULL, op_prepend_elem(OP_LIST,
2664                                   newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
2665                                   op_prepend_elem(OP_LIST,
2666                                                newSVOP(OP_CONST, 0,
2667                                                        newRV(MUTABLE_SV(cv))),
2668                                                attrs)));
2669 }
2670
2671 STATIC OP *
2672 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
2673 {
2674     dVAR;
2675     I32 type;
2676     const bool stately = PL_parser && PL_parser->in_my == KEY_state;
2677
2678     PERL_ARGS_ASSERT_MY_KID;
2679
2680     if (!o || (PL_parser && PL_parser->error_count))
2681         return o;
2682
2683     type = o->op_type;
2684     if (PL_madskills && type == OP_NULL && o->op_flags & OPf_KIDS) {
2685         (void)my_kid(cUNOPo->op_first, attrs, imopsp);
2686         return o;
2687     }
2688
2689     if (type == OP_LIST) {
2690         OP *kid;
2691         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2692             my_kid(kid, attrs, imopsp);
2693         return o;
2694     } else if (type == OP_UNDEF || type == OP_STUB) {
2695         return o;
2696     } else if (type == OP_RV2SV ||      /* "our" declaration */
2697                type == OP_RV2AV ||
2698                type == OP_RV2HV) { /* XXX does this let anything illegal in? */
2699         if (cUNOPo->op_first->op_type != OP_GV) { /* MJD 20011224 */
2700             yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2701                         OP_DESC(o),
2702                         PL_parser->in_my == KEY_our
2703                             ? "our"
2704                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2705         } else if (attrs) {
2706             GV * const gv = cGVOPx_gv(cUNOPo->op_first);
2707             PL_parser->in_my = FALSE;
2708             PL_parser->in_my_stash = NULL;
2709             apply_attrs(GvSTASH(gv),
2710                         (type == OP_RV2SV ? GvSV(gv) :
2711                          type == OP_RV2AV ? MUTABLE_SV(GvAV(gv)) :
2712                          type == OP_RV2HV ? MUTABLE_SV(GvHV(gv)) : MUTABLE_SV(gv)),
2713                         attrs);
2714         }
2715         o->op_private |= OPpOUR_INTRO;
2716         return o;
2717     }
2718     else if (type != OP_PADSV &&
2719              type != OP_PADAV &&
2720              type != OP_PADHV &&
2721              type != OP_PUSHMARK)
2722     {
2723         yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
2724                           OP_DESC(o),
2725                           PL_parser->in_my == KEY_our
2726                             ? "our"
2727                             : PL_parser->in_my == KEY_state ? "state" : "my"));
2728         return o;
2729     }
2730     else if (attrs && type != OP_PUSHMARK) {
2731         HV *stash;
2732
2733         PL_parser->in_my = FALSE;
2734         PL_parser->in_my_stash = NULL;
2735
2736         /* check for C<my Dog $spot> when deciding package */
2737         stash = PAD_COMPNAME_TYPE(o->op_targ);
2738         if (!stash)
2739             stash = PL_curstash;
2740         apply_attrs_my(stash, o, attrs, imopsp);
2741     }
2742     o->op_flags |= OPf_MOD;
2743     o->op_private |= OPpLVAL_INTRO;
2744     if (stately)
2745         o->op_private |= OPpPAD_STATE;
2746     return o;
2747 }
2748
2749 OP *
2750 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2751 {
2752     dVAR;
2753     OP *rops;
2754     int maybe_scalar = 0;
2755
2756     PERL_ARGS_ASSERT_MY_ATTRS;
2757
2758 /* [perl #17376]: this appears to be premature, and results in code such as
2759    C< our(%x); > executing in list mode rather than void mode */
2760 #if 0
2761     if (o->op_flags & OPf_PARENS)
2762         list(o);
2763     else
2764         maybe_scalar = 1;
2765 #else
2766     maybe_scalar = 1;
2767 #endif
2768     if (attrs)
2769         SAVEFREEOP(attrs);
2770     rops = NULL;
2771     o = my_kid(o, attrs, &rops);
2772     if (rops) {
2773         if (maybe_scalar && o->op_type == OP_PADSV) {
2774             o = scalar(op_append_list(OP_LIST, rops, o));
2775             o->op_private |= OPpLVAL_INTRO;
2776         }
2777         else {
2778             /* The listop in rops might have a pushmark at the beginning,
2779                which will mess up list assignment. */
2780             LISTOP * const lrops = (LISTOP *)rops; /* for brevity */
2781             if (rops->op_type == OP_LIST &&
2782                 lrops->op_first && lrops->op_first->op_type == OP_PUSHMARK)
2783             {
2784                 OP * const pushmark = lrops->op_first;
2785                 lrops->op_first = pushmark->op_sibling;
2786                 op_free(pushmark);
2787             }
2788             o = op_append_list(OP_LIST, o, rops);
2789         }
2790     }
2791     PL_parser->in_my = FALSE;
2792     PL_parser->in_my_stash = NULL;
2793     return o;
2794 }
2795
2796 OP *
2797 Perl_sawparens(pTHX_ OP *o)
2798 {
2799     PERL_UNUSED_CONTEXT;
2800     if (o)
2801         o->op_flags |= OPf_PARENS;
2802     return o;
2803 }
2804
2805 OP *
2806 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
2807 {
2808     OP *o;
2809     bool ismatchop = 0;
2810     const OPCODE ltype = left->op_type;
2811     const OPCODE rtype = right->op_type;
2812
2813     PERL_ARGS_ASSERT_BIND_MATCH;
2814
2815     if ( (ltype == OP_RV2AV || ltype == OP_RV2HV || ltype == OP_PADAV
2816           || ltype == OP_PADHV) && ckWARN(WARN_MISC))
2817     {
2818       const char * const desc
2819           = PL_op_desc[(
2820                           rtype == OP_SUBST || rtype == OP_TRANS
2821                        || rtype == OP_TRANSR
2822                        )
2823                        ? (int)rtype : OP_MATCH];
2824       const bool isary = ltype == OP_RV2AV || ltype == OP_PADAV;
2825       SV * const name =
2826         S_op_varname(aTHX_ left);
2827       if (name)
2828         Perl_warner(aTHX_ packWARN(WARN_MISC),
2829              "Applying %s to %"SVf" will act on scalar(%"SVf")",
2830              desc, name, name);
2831       else {
2832         const char * const sample = (isary
2833              ? "@array" : "%hash");
2834         Perl_warner(aTHX_ packWARN(WARN_MISC),
2835              "Applying %s to %s will act on scalar(%s)",
2836              desc, sample, sample);
2837       }
2838     }
2839
2840     if (rtype == OP_CONST &&
2841         cSVOPx(right)->op_private & OPpCONST_BARE &&
2842         cSVOPx(right)->op_private & OPpCONST_STRICT)
2843     {
2844         no_bareword_allowed(right);
2845     }
2846
2847     /* !~ doesn't make sense with /r, so error on it for now */
2848     if (rtype == OP_SUBST && (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT) &&
2849         type == OP_NOT)
2850         yyerror("Using !~ with s///r doesn't make sense");
2851     if (rtype == OP_TRANSR && type == OP_NOT)
2852         yyerror("Using !~ with tr///r doesn't make sense");
2853
2854     ismatchop = (rtype == OP_MATCH ||
2855                  rtype == OP_SUBST ||
2856                  rtype == OP_TRANS || rtype == OP_TRANSR)
2857              && !(right->op_flags & OPf_SPECIAL);
2858     if (ismatchop && right->op_private & OPpTARGET_MY) {
2859         right->op_targ = 0;
2860         right->op_private &= ~OPpTARGET_MY;
2861     }
2862     if (!(right->op_flags & OPf_STACKED) && ismatchop) {
2863         OP *newleft;
2864
2865         right->op_flags |= OPf_STACKED;
2866         if (rtype != OP_MATCH && rtype != OP_TRANSR &&
2867             ! (rtype == OP_TRANS &&
2868                right->op_private & OPpTRANS_IDENTICAL) &&
2869             ! (rtype == OP_SUBST &&
2870                (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT)))
2871             newleft = op_lvalue(left, rtype);
2872         else
2873             newleft = left;
2874         if (right->op_type == OP_TRANS || right->op_type == OP_TRANSR)
2875             o = newBINOP(OP_NULL, OPf_STACKED, scalar(newleft), right);
2876         else
2877             o = op_prepend_elem(rtype, scalar(newleft), right);
2878         if (type == OP_NOT)
2879             return newUNOP(OP_NOT, 0, scalar(o));
2880         return o;
2881     }
2882     else
2883         return bind_match(type, left,
2884                 pmruntime(newPMOP(OP_MATCH, 0), right, 0, 0));
2885 }
2886
2887 OP *
2888 Perl_invert(pTHX_ OP *o)
2889 {
2890     if (!o)
2891         return NULL;
2892     return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
2893 }
2894
2895 /*
2896 =for apidoc Amx|OP *|op_scope|OP *o
2897
2898 Wraps up an op tree with some additional ops so that at runtime a dynamic
2899 scope will be created.  The original ops run in the new dynamic scope,
2900 and then, provided that they exit normally, the scope will be unwound.
2901 The additional ops used to create and unwind the dynamic scope will
2902 normally be an C<enter>/C<leave> pair, but a C<scope> op may be used
2903 instead if the ops are simple enough to not need the full dynamic scope
2904 structure.
2905
2906 =cut
2907 */
2908
2909 OP *
2910 Perl_op_scope(pTHX_ OP *o)
2911 {
2912     dVAR;
2913     if (o) {
2914         if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || TAINTING_get) {
2915             o = op_prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
2916             o->op_type = OP_LEAVE;
2917             o->op_ppaddr = PL_ppaddr[OP_LEAVE];
2918         }
2919         else if (o->op_type == OP_LINESEQ) {
2920             OP *kid;
2921             o->op_type = OP_SCOPE;
2922             o->op_ppaddr = PL_ppaddr[OP_SCOPE];
2923             kid = ((LISTOP*)o)->op_first;
2924             if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
2925                 op_null(kid);
2926
2927                 /* The following deals with things like 'do {1 for 1}' */
2928                 kid = kid->op_sibling;
2929                 if (kid &&
2930                     (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE))
2931                     op_null(kid);
2932             }
2933         }
2934         else
2935             o = newLISTOP(OP_SCOPE, 0, o, NULL);
2936     }
2937     return o;
2938 }
2939
2940 OP *
2941 Perl_op_unscope(pTHX_ OP *o)
2942 {
2943     if (o && o->op_type == OP_LINESEQ) {
2944         OP *kid = cLISTOPo->op_first;
2945         for(; kid; kid = kid->op_sibling)
2946             if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE)
2947                 op_null(kid);
2948     }
2949     return o;
2950 }
2951
2952 int
2953 Perl_block_start(pTHX_ int full)
2954 {
2955     dVAR;
2956     const int retval = PL_savestack_ix;
2957
2958     pad_block_start(full);
2959     SAVEHINTS();
2960     PL_hints &= ~HINT_BLOCK_SCOPE;
2961     SAVECOMPILEWARNINGS();
2962     PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
2963
2964     CALL_BLOCK_HOOKS(bhk_start, full);
2965
2966     return retval;
2967 }
2968
2969 OP*
2970 Perl_block_end(pTHX_ I32 floor, OP *seq)
2971 {
2972     dVAR;
2973     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
2974     OP* retval = scalarseq(seq);
2975     OP *o;
2976
2977     CALL_BLOCK_HOOKS(bhk_pre_end, &retval);
2978
2979     LEAVE_SCOPE(floor);
2980     if (needblockscope)
2981         PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
2982     o = pad_leavemy();
2983
2984     if (o) {
2985         /* pad_leavemy has created a sequence of introcv ops for all my
2986            subs declared in the block.  We have to replicate that list with
2987            clonecv ops, to deal with this situation:
2988
2989                sub {
2990                    my sub s1;
2991                    my sub s2;
2992                    sub s1 { state sub foo { \&s2 } }
2993                }->()
2994
2995            Originally, I was going to have introcv clone the CV and turn
2996            off the stale flag.  Since &s1 is declared before &s2, the
2997            introcv op for &s1 is executed (on sub entry) before the one for
2998            &s2.  But the &foo sub inside &s1 (which is cloned when &s1 is
2999            cloned, since it is a state sub) closes over &s2 and expects
3000            to see it in its outer CV’s pad.  If the introcv op clones &s1,
3001            then &s2 is still marked stale.  Since &s1 is not active, and
3002            &foo closes over &s1’s implicit entry for &s2, we get a ‘Varia-
3003            ble will not stay shared’ warning.  Because it is the same stub
3004            that will be used when the introcv op for &s2 is executed, clos-
3005            ing over it is safe.  Hence, we have to turn off the stale flag
3006            on all lexical subs in the block before we clone any of them.
3007            Hence, having introcv clone the sub cannot work.  So we create a
3008            list of ops like this:
3009
3010                lineseq
3011                   |
3012                   +-- introcv
3013                   |
3014                   +-- introcv
3015                   |
3016                   +-- introcv
3017                   |
3018                   .
3019                   .
3020                   .
3021                   |
3022                   +-- clonecv
3023                   |
3024                   +-- clonecv
3025                   |
3026                   +-- clonecv
3027                   |
3028                   .
3029                   .
3030                   .
3031          */
3032         OP *kid = o->op_flags & OPf_KIDS ? cLISTOPo->op_first : o;
3033         OP * const last = o->op_flags & OPf_KIDS ? cLISTOPo->op_last : o;
3034         for (;; kid = kid->op_sibling) {
3035             OP *newkid = newOP(OP_CLONECV, 0);
3036             newkid->op_targ = kid->op_targ;
3037             o = op_append_elem(OP_LINESEQ, o, newkid);
3038             if (kid == last) break;
3039         }
3040         retval = op_prepend_elem(OP_LINESEQ, o, retval);
3041     }
3042
3043     CALL_BLOCK_HOOKS(bhk_post_end, &retval);
3044
3045     return retval;
3046 }
3047
3048 /*
3049 =head1 Compile-time scope hooks
3050
3051 =for apidoc Aox||blockhook_register
3052
3053 Register a set of hooks to be called when the Perl lexical scope changes
3054 at compile time. See L<perlguts/"Compile-time scope hooks">.
3055
3056 =cut
3057 */
3058
3059 void
3060 Perl_blockhook_register(pTHX_ BHK *hk)
3061 {
3062     PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER;
3063
3064     Perl_av_create_and_push(aTHX_ &PL_blockhooks, newSViv(PTR2IV(hk)));
3065 }
3066
3067 STATIC OP *
3068 S_newDEFSVOP(pTHX)
3069 {
3070     dVAR;
3071     const PADOFFSET offset = pad_findmy_pvs("$_", 0);
3072     if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
3073         return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
3074     }
3075     else {
3076         OP * const o = newOP(OP_PADSV, 0);
3077         o->op_targ = offset;
3078         return o;
3079     }
3080 }
3081
3082 void
3083 Perl_newPROG(pTHX_ OP *o)
3084 {
3085     dVAR;
3086
3087     PERL_ARGS_ASSERT_NEWPROG;
3088
3089     if (PL_in_eval) {
3090         PERL_CONTEXT *cx;
3091         I32 i;
3092         if (PL_eval_root)
3093                 return;
3094         PL_eval_root = newUNOP(OP_LEAVEEVAL,
3095                                ((PL_in_eval & EVAL_KEEPERR)
3096                                 ? OPf_SPECIAL : 0), o);
3097
3098         cx = &cxstack[cxstack_ix];
3099         assert(CxTYPE(cx) == CXt_EVAL);
3100
3101         if ((cx->blk_gimme & G_WANT) == G_VOID)
3102             scalarvoid(PL_eval_root);
3103         else if ((cx->blk_gimme & G_WANT) == G_ARRAY)
3104             list(PL_eval_root);
3105         else
3106             scalar(PL_eval_root);
3107
3108         PL_eval_start = op_linklist(PL_eval_root);
3109         PL_eval_root->op_private |= OPpREFCOUNTED;
3110         OpREFCNT_set(PL_eval_root, 1);
3111         PL_eval_root->op_next = 0;
3112         i = PL_savestack_ix;
3113         SAVEFREEOP(o);
3114         ENTER;
3115         CALL_PEEP(PL_eval_start);
3116         finalize_optree(PL_eval_root);
3117         LEAVE;
3118         PL_savestack_ix = i;
3119     }
3120     else {
3121         if (o->op_type == OP_STUB) {
3122             /* This block is entered if nothing is compiled for the main
3123                program. This will be the case for an genuinely empty main
3124                program, or one which only has BEGIN blocks etc, so already
3125                run and freed.
3126
3127                Historically (5.000) the guard above was !o. However, commit
3128                f8a08f7b8bd67b28 (Jun 2001), integrated to blead as
3129                c71fccf11fde0068, changed perly.y so that newPROG() is now
3130                called with the output of block_end(), which returns a new
3131                OP_STUB for the case of an empty optree. ByteLoader (and
3132                maybe other things) also take this path, because they set up
3133                PL_main_start and PL_main_root directly, without generating an
3134                optree.
3135
3136                If the parsing the main program aborts (due to parse errors,
3137                or due to BEGIN or similar calling exit), then newPROG()
3138                isn't even called, and hence this code path and its cleanups
3139                are skipped. This shouldn't make a make a difference:
3140                * a non-zero return from perl_parse is a failure, and
3141                  perl_destruct() should be called immediately.
3142                * however, if exit(0) is called during the parse, then
3143                  perl_parse() returns 0, and perl_run() is called. As
3144                  PL_main_start will be NULL, perl_run() will return
3145                  promptly, and the exit code will remain 0.
3146             */
3147
3148             PL_comppad_name = 0;
3149             PL_compcv = 0;
3150             S_op_destroy(aTHX_ o);
3151             return;
3152         }
3153         PL_main_root = op_scope(sawparens(scalarvoid(o)));
3154         PL_curcop = &PL_compiling;
3155         PL_main_start = LINKLIST(PL_main_root);
3156         PL_main_root->op_private |= OPpREFCOUNTED;
3157         OpREFCNT_set(PL_main_root, 1);
3158         PL_main_root->op_next = 0;
3159         CALL_PEEP(PL_main_start);
3160         finalize_optree(PL_main_root);
3161         cv_forget_slab(PL_compcv);
3162         PL_compcv = 0;
3163
3164         /* Register with debugger */
3165         if (PERLDB_INTER) {
3166             CV * const cv = get_cvs("DB::postponed", 0);
3167             if (cv) {
3168                 dSP;
3169                 PUSHMARK(SP);
3170                 XPUSHs(MUTABLE_SV(CopFILEGV(&PL_compiling)));
3171                 PUTBACK;
3172                 call_sv(MUTABLE_SV(cv), G_DISCARD);
3173             }
3174         }
3175     }
3176 }
3177
3178 OP *
3179 Perl_localize(pTHX_ OP *o, I32 lex)
3180 {
3181     dVAR;
3182
3183     PERL_ARGS_ASSERT_LOCALIZE;
3184
3185     if (o->op_flags & OPf_PARENS)
3186 /* [perl #17376]: this appears to be premature, and results in code such as
3187    C< our(%x); > executing in list mode rather than void mode */
3188 #if 0
3189         list(o);
3190 #else
3191         NOOP;
3192 #endif
3193     else {
3194         if ( PL_parser->bufptr > PL_parser->oldbufptr
3195             && PL_parser->bufptr[-1] == ','
3196             && ckWARN(WARN_PARENTHESIS))
3197         {
3198             char *s = PL_parser->bufptr;
3199             bool sigil = FALSE;
3200
3201             /* some heuristics to detect a potential error */
3202             while (*s && (strchr(", \t\n", *s)))
3203                 s++;
3204
3205             while (1) {
3206                 if (*s && strchr("@$%*", *s) && *++s
3207                        && (isWORDCHAR(*s) || UTF8_IS_CONTINUED(*s))) {
3208                     s++;
3209                     sigil = TRUE;
3210                     while (*s && (isWORDCHAR(*s) || UTF8_IS_CONTINUED(*s)))
3211                         s++;
3212                     while (*s && (strchr(", \t\n", *s)))
3213                         s++;
3214                 }
3215                 else
3216                     break;
3217             }
3218             if (sigil && (*s == ';' || *s == '=')) {
3219                 Perl_warner(aTHX_ packWARN(WARN_PARENTHESIS),
3220                                 "Parentheses missing around \"%s\" list",
3221                                 lex
3222                                     ? (PL_parser->in_my == KEY_our
3223                                         ? "our"
3224                                         : PL_parser->in_my == KEY_state
3225                                             ? "state"
3226                                             : "my")
3227                                     : "local");
3228             }
3229         }
3230     }
3231     if (lex)
3232         o = my(o);
3233     else
3234         o = op_lvalue(o, OP_NULL);              /* a bit kludgey */
3235     PL_parser->in_my = FALSE;
3236     PL_parser->in_my_stash = NULL;
3237     return o;
3238 }
3239
3240 OP *
3241 Perl_jmaybe(pTHX_ OP *o)
3242 {
3243     PERL_ARGS_ASSERT_JMAYBE;
3244
3245     if (o->op_type == OP_LIST) {
3246         OP * const o2
3247             = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL, SVt_PV)));
3248         o = convert(OP_JOIN, 0, op_prepend_elem(OP_LIST, o2, o));
3249     }
3250     return o;
3251 }
3252
3253 PERL_STATIC_INLINE OP *
3254 S_op_std_init(pTHX_ OP *o)
3255 {
3256     I32 type = o->op_type;
3257
3258     PERL_ARGS_ASSERT_OP_STD_INIT;
3259
3260     if (PL_opargs[type] & OA_RETSCALAR)
3261         scalar(o);
3262     if (PL_opargs[type] & OA_TARGET && !o->op_targ)
3263         o->op_targ = pad_alloc(type, SVs_PADTMP);
3264
3265     return o;
3266 }
3267
3268 PERL_STATIC_INLINE OP *
3269 S_op_integerize(pTHX_ OP *o)
3270 {
3271     I32 type = o->op_type;
3272
3273     PERL_ARGS_ASSERT_OP_INTEGERIZE;
3274
3275     /* integerize op. */
3276     if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER))
3277     {
3278         dVAR;
3279         o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
3280     }
3281
3282     if (type == OP_NEGATE)
3283         /* XXX might want a ck_negate() for this */
3284         cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
3285
3286     return o;
3287 }
3288
3289 static OP *
3290 S_fold_constants(pTHX_ OP *o)
3291 {
3292     dVAR;
3293     OP * VOL curop;
3294     OP *newop;
3295     VOL I32 type = o->op_type;
3296     SV * VOL sv = NULL;
3297     int ret = 0;
3298     I32 oldscope;
3299     OP *old_next;
3300     SV * const oldwarnhook = PL_warnhook;
3301     SV * const olddiehook  = PL_diehook;
3302     COP not_compiling;
3303     dJMPENV;
3304
3305     PERL_ARGS_ASSERT_FOLD_CONSTANTS;
3306
3307     if (!(PL_opargs[type] & OA_FOLDCONST))
3308         goto nope;
3309
3310     switch (type) {
3311     case OP_UCFIRST:
3312     case OP_LCFIRST:
3313     case OP_UC:
3314     case OP_LC:
3315     case OP_FC:
3316     case OP_SLT:
3317     case OP_SGT:
3318     case OP_SLE:
3319     case OP_SGE:
3320     case OP_SCMP:
3321     case OP_SPRINTF:
3322         /* XXX what about the numeric ops? */
3323         if (IN_LOCALE_COMPILETIME)
3324             goto nope;
3325         break;
3326     case OP_PACK:
3327         if (!cLISTOPo->op_first->op_sibling
3328           || cLISTOPo->op_first->op_sibling->op_type != OP_CONST)
3329             goto nope;
3330         {
3331             SV * const sv = cSVOPx_sv(cLISTOPo->op_first->op_sibling);
3332             if (!SvPOK(sv) || SvGMAGICAL(sv)) goto nope;
3333             {
3334                 const char *s = SvPVX_const(sv);
3335                 while (s < SvEND(sv)) {
3336                     if (*s == 'p' || *s == 'P') goto nope;
3337                     s++;
3338                 }
3339             }
3340         }
3341         break;
3342     case OP_REPEAT:
3343         if (o->op_private & OPpREPEAT_DOLIST) goto nope;
3344         break;
3345     case OP_SREFGEN:
3346         if (cUNOPx(cUNOPo->op_first)->op_first->op_type != OP_CONST
3347          || SvPADTMP(cSVOPx_sv(cUNOPx(cUNOPo->op_first)->op_first)))
3348             goto nope;
3349     }
3350
3351     if (PL_parser && PL_parser->error_count)
3352         goto nope;              /* Don't try to run w/ errors */
3353
3354     for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
3355         const OPCODE type = curop->op_type;
3356         if ((type != OP_CONST || (curop->op_private & OPpCONST_BARE)) &&
3357             type != OP_LIST &&
3358             type != OP_SCALAR &&
3359             type != OP_NULL &&
3360             type != OP_PUSHMARK)
3361         {
3362             goto nope;
3363         }
3364     }
3365
3366     curop = LINKLIST(o);
3367     old_next = o->op_next;
3368     o->op_next = 0;
3369     PL_op = curop;
3370
3371     oldscope = PL_scopestack_ix;
3372     create_eval_scope(G_FAKINGEVAL);
3373
3374     /* Verify that we don't need to save it:  */
3375     assert(PL_curcop == &PL_compiling);
3376     StructCopy(&PL_compiling, &not_compiling, COP);
3377     PL_curcop = &not_compiling;
3378     /* The above ensures that we run with all the correct hints of the
3379        currently compiling COP, but that IN_PERL_RUNTIME is not true. */
3380     assert(IN_PERL_RUNTIME);
3381     PL_warnhook = PERL_WARNHOOK_FATAL;
3382     PL_diehook  = NULL;
3383     JMPENV_PUSH(ret);
3384
3385     switch (ret) {
3386     case 0:
3387         CALLRUNOPS(aTHX);
3388         sv = *(PL_stack_sp--);
3389         if (o->op_targ && sv == PAD_SV(o->op_targ)) {   /* grab pad temp? */
3390 #ifdef PERL_MAD
3391             /* Can't simply swipe the SV from the pad, because that relies on
3392                the op being freed "real soon now". Under MAD, this doesn't
3393                happen (see the #ifdef below).  */
3394             sv = newSVsv(sv);
3395 #else
3396             pad_swipe(o->op_targ,  FALSE);
3397 #endif
3398         }
3399         else if (SvTEMP(sv)) {                  /* grab mortal temp? */
3400             SvREFCNT_inc_simple_void(sv);
3401             SvTEMP_off(sv);
3402         }
3403         else { assert(SvIMMORTAL(sv)); }
3404         break;
3405     case 3:
3406         /* Something tried to die.  Abandon constant folding.  */
3407         /* Pretend the error never happened.  */
3408         CLEAR_ERRSV();
3409         o->op_next = old_next;
3410         break;
3411     default:
3412         JMPENV_POP;
3413         /* Don't expect 1 (setjmp failed) or 2 (something called my_exit)  */
3414         PL_warnhook = oldwarnhook;
3415         PL_diehook  = olddiehook;
3416         /* XXX note that this croak may fail as we've already blown away
3417          * the stack - eg any nested evals */
3418         Perl_croak(aTHX_ "panic: fold_constants JMPENV_PUSH returned %d", ret);
3419     }
3420     JMPENV_POP;
3421     PL_warnhook = oldwarnhook;
3422     PL_diehook  = olddiehook;
3423     PL_curcop = &PL_compiling;
3424
3425     if (PL_scopestack_ix > oldscope)
3426         delete_eval_scope();
3427
3428     if (ret)
3429         goto nope;
3430
3431 #ifndef PERL_MAD
3432     op_free(o);
3433 #endif
3434     assert(sv);
3435     if (type == OP_STRINGIFY) SvPADTMP_off(sv);
3436     else if (!SvIMMORTAL(sv)) SvPADTMP_on(sv);
3437     if (type == OP_RV2GV)
3438         newop = newGVOP(OP_GV, 0, MUTABLE_GV(sv));
3439     else
3440     {
3441         newop = newSVOP(OP_CONST, 0, MUTABLE_SV(sv));
3442         if (type != OP_STRINGIFY) newop->op_folded = 1;
3443     }
3444     op_getmad(o,newop,'f');
3445     return newop;
3446
3447  nope:
3448     return o;
3449 }
3450
3451 static OP *
3452 S_gen_constant_list(pTHX_ OP *o)
3453 {
3454     dVAR;
3455     OP *curop;
3456     const SSize_t oldtmps_floor = PL_tmps_floor;
3457     SV **svp;
3458     AV *av;
3459
3460     list(o);
3461     if (PL_parser && PL_parser->error_count)
3462         return o;               /* Don't attempt to run with errors */
3463
3464     PL_op = curop = LINKLIST(o);
3465     o->op_next = 0;
3466     CALL_PEEP(curop);
3467     Perl_pp_pushmark(aTHX);
3468     CALLRUNOPS(aTHX);
3469     PL_op = curop;
3470     assert (!(curop->op_flags & OPf_SPECIAL));
3471     assert(curop->op_type == OP_RANGE);
3472     Perl_pp_anonlist(aTHX);
3473     PL_tmps_floor = oldtmps_floor;
3474
3475     o->op_type = OP_RV2AV;
3476     o->op_ppaddr = PL_ppaddr[OP_RV2AV];
3477     o->op_flags &= ~OPf_REF;    /* treat \(1..2) like an ordinary list */
3478     o->op_flags |= OPf_PARENS;  /* and flatten \(1..2,3) */
3479     o->op_opt = 0;              /* needs to be revisited in rpeep() */
3480     curop = ((UNOP*)o)->op_first;
3481     av = (AV *)SvREFCNT_inc_NN(*PL_stack_sp--);
3482     ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, (SV *)av);
3483     if (AvFILLp(av) != -1)
3484         for (svp = AvARRAY(av) + AvFILLp(av); svp >= AvARRAY(av); --svp)
3485             SvPADTMP_on(*svp);
3486 #ifdef PERL_MAD
3487     op_getmad(curop,o,'O');
3488 #else
3489     op_free(curop);
3490 #endif
3491     LINKLIST(o);
3492     return list(o);
3493 }
3494
3495 OP *
3496 Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
3497 {
3498     dVAR;
3499     if (type < 0) type = -type, flags |= OPf_SPECIAL;
3500     if (!o || o->op_type != OP_LIST)
3501         o = newLISTOP(OP_LIST, 0, o, NULL);
3502     else
3503         o->op_flags &= ~OPf_WANT;
3504
3505     if (!(PL_opargs[type] & OA_MARK))
3506         op_null(cLISTOPo->op_first);
3507     else {
3508         OP * const kid2 = cLISTOPo->op_first->op_sibling;
3509         if (kid2 && kid2->op_type == OP_COREARGS) {
3510             op_null(cLISTOPo->op_first);
3511             kid2->op_private |= OPpCOREARGS_PUSHMARK;
3512         }
3513     }
3514
3515     o->op_type = (OPCODE)type;
3516     o->op_ppaddr = PL_ppaddr[type];
3517     o->op_flags |= flags;
3518
3519     o = CHECKOP(type, o);
3520     if (o->op_type != (unsigned)type)
3521         return o;
3522
3523     return fold_constants(op_integerize(op_std_init(o)));
3524 }
3525
3526 /*
3527 =head1 Optree Manipulation Functions
3528 */
3529
3530 /* List constructors */
3531
3532 /*
3533 =for apidoc Am|OP *|op_append_elem|I32 optype|OP *first|OP *last
3534
3535 Append an item to the list of ops contained directly within a list-type
3536 op, returning the lengthened list.  I<first> is the list-type op,
3537 and I<last> is the op to append to the list.  I<optype> specifies the
3538 intended opcode for the list.  If I<first> is not already a list of the
3539 right type, it will be upgraded into one.  If either I<first> or I<last>
3540 is null, the other is returned unchanged.
3541
3542 =cut
3543 */
3544
3545 OP *
3546 Perl_op_append_elem(pTHX_ I32 type, OP *first, OP *last)
3547 {
3548     if (!first)
3549         return last;
3550
3551     if (!last)
3552         return first;
3553
3554     if (first->op_type != (unsigned)type
3555         || (type == OP_LIST && (first->op_flags & OPf_PARENS)))
3556     {
3557         return newLISTOP(type, 0, first, last);
3558     }
3559
3560     if (first->op_flags & OPf_KIDS)
3561         ((LISTOP*)first)->op_last->op_sibling = last;
3562     else {
3563         first->op_flags |= OPf_KIDS;
3564         ((LISTOP*)first)->op_first = last;
3565     }
3566     ((LISTOP*)first)->op_last = last;
3567     return first;
3568 }
3569
3570 /*
3571 =for apidoc Am|OP *|op_append_list|I32 optype|OP *first|OP *last
3572
3573 Concatenate the lists of ops contained directly within two list-type ops,
3574 returning the combined list.  I<first> and I<last> are the list-type ops
3575 to concatenate.  I<optype> specifies the intended opcode for the list.
3576 If either I<first> or I<last> is not already a list of the right type,
3577 it will be upgraded into one.  If either I<first> or I<last> is null,
3578 the other is returned unchanged.
3579
3580 =cut
3581 */
3582
3583 OP *
3584 Perl_op_append_list(pTHX_ I32 type, OP *first, OP *last)
3585 {
3586     if (!first)
3587         return last;
3588
3589     if (!last)
3590         return first;
3591
3592     if (first->op_type != (unsigned)type)
3593         return op_prepend_elem(type, first, last);
3594
3595     if (last->op_type != (unsigned)type)
3596         return op_append_elem(type, first, last);
3597
3598     ((LISTOP*)first)->op_last->op_sibling = ((LISTOP*)last)->op_first;
3599     ((LISTOP*)first)->op_last = ((LISTOP*)last)->op_last;
3600     first->op_flags |= (last->op_flags & OPf_KIDS);
3601
3602 #ifdef PERL_MAD
3603     if (((LISTOP*)last)->op_first && first->op_madprop) {
3604         MADPROP *mp = ((LISTOP*)last)->op_first->op_madprop;
3605         if (mp) {
3606             while (mp->mad_next)
3607                 mp = mp->mad_next;
3608             mp->mad_next = first->op_madprop;
3609         }
3610         else {
3611             ((LISTOP*)last)->op_first->op_madprop = first->op_madprop;
3612         }
3613     }
3614     first->op_madprop = last->op_madprop;
3615     last->op_madprop = 0;
3616 #endif
3617
3618     S_op_destroy(aTHX_ last);
3619
3620     return first;
3621 }
3622
3623 /*
3624 =for apidoc Am|OP *|op_prepend_elem|I32 optype|OP *first|OP *last
3625
3626 Prepend an item to the list of ops contained directly within a list-type
3627 op, returning the lengthened list.  I<first> is the op to prepend to the
3628 list, and I<last> is the list-type op.  I<optype> specifies the intended
3629 opcode for the list.  If I<last> is not already a list of the right type,
3630 it will be upgraded into one.  If either I<first> or I<last> is null,
3631 the other is returned unchanged.
3632
3633 =cut
3634 */
3635
3636 OP *
3637 Perl_op_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
3638 {
3639     if (!first)
3640         return last;
3641
3642     if (!last)
3643         return first;
3644
3645     if (last->op_type == (unsigned)type) {
3646         if (type == OP_LIST) {  /* already a PUSHMARK there */
3647             first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
3648             ((LISTOP*)last)->op_first->op_sibling = first;
3649             if (!(first->op_flags & OPf_PARENS))
3650                 last->op_flags &= ~OPf_PARENS;
3651         }
3652         else {
3653             if (!(last->op_flags & OPf_KIDS)) {
3654                 ((LISTOP*)last)->op_last = first;
3655                 last->op_flags |= OPf_KIDS;
3656             }
3657             first->op_sibling = ((LISTOP*)last)->op_first;
3658             ((LISTOP*)last)->op_first = first;
3659         }
3660         last->op_flags |= OPf_KIDS;
3661         return last;
3662     }
3663
3664     return newLISTOP(type, 0, first, last);
3665 }
3666
3667 /* Constructors */
3668
3669 #ifdef PERL_MAD
3670
3671 TOKEN *
3672 Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop)
3673 {
3674     TOKEN *tk;
3675     Newxz(tk, 1, TOKEN);
3676     tk->tk_type = (OPCODE)optype;
3677     tk->tk_type = 12345;
3678     tk->tk_lval = lval;
3679     tk->tk_mad = madprop;
3680     return tk;
3681 }
3682
3683 void
3684 Perl_token_free(pTHX_ TOKEN* tk)
3685 {
3686     PERL_ARGS_ASSERT_TOKEN_FREE;
3687
3688     if (tk->tk_type != 12345)
3689         return;
3690     mad_free(tk->tk_mad);
3691     Safefree(tk);
3692 }
3693
3694 void
3695 Perl_token_getmad(pTHX_ TOKEN* tk, OP* o, char slot)
3696 {
3697     MADPROP* mp;
3698     MADPROP* tm;
3699
3700     PERL_ARGS_ASSERT_TOKEN_GETMAD;
3701
3702     if (tk->tk_type != 12345) {
3703         Perl_warner(aTHX_ packWARN(WARN_MISC),
3704              "Invalid TOKEN object ignored");
3705         return;
3706     }
3707     tm = tk->tk_mad;
3708     if (!tm)
3709         return;
3710
3711     /* faked up qw list? */
3712     if (slot == '(' &&
3713         tm->mad_type == MAD_SV &&
3714         SvPVX((SV *)tm->mad_val)[0] == 'q')
3715             slot = 'x';
3716
3717     if (o) {
3718         mp = o->op_madprop;
3719         if (mp) {
3720             for (;;) {
3721                 /* pretend constant fold didn't happen? */
3722                 if (mp->mad_key == 'f' &&
3723                     (o->op_type == OP_CONST ||
3724                      o->op_type == OP_GV) )
3725                 {
3726                     token_getmad(tk,(OP*)mp->mad_val,slot);
3727                     return;
3728                 }
3729                 if (!mp->mad_next)
3730                     break;
3731                 mp = mp->mad_next;
3732             }
3733             mp->mad_next = tm;
3734             mp = mp->mad_next;
3735         }
3736         else {
3737             o->op_madprop = tm;
3738             mp = o->op_madprop;
3739         }
3740         if (mp->mad_key == 'X')
3741             mp->mad_key = slot; /* just change the first one */
3742
3743         tk->tk_mad = 0;
3744     }
3745     else
3746         mad_free(tm);
3747     Safefree(tk);
3748 }
3749
3750 void
3751 Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot)
3752 {
3753     MADPROP* mp;
3754     if (!from)
3755         return;
3756     if (o) {
3757         mp = o->op_madprop;
3758         if (mp) {
3759             for (;;) {
3760                 /* pretend constant fold didn't happen? */
3761                 if (mp->mad_key == 'f' &&
3762                     (o->op_type == OP_CONST ||
3763                      o->op_type == OP_GV) )
3764                 {
3765                     op_getmad(from,(OP*)mp->mad_val,slot);
3766                     return;
3767                 }
3768                 if (!mp->mad_next)
3769                     break;
3770                 mp = mp->mad_next;
3771             }
3772             mp->mad_next = newMADPROP(slot,MAD_OP,from,0);
3773         }
3774         else {
3775             o->op_madprop = newMADPROP(slot,MAD_OP,from,0);
3776         }
3777     }
3778 }
3779
3780 void
3781 Perl_op_getmad(pTHX_ OP* from, OP* o, char slot)
3782 {
3783     MADPROP* mp;
3784     if (!from)
3785         return;
3786     if (o) {
3787         mp = o->op_madprop;
3788         if (mp) {
3789             for (;;) {
3790                 /* pretend constant fold didn't happen? */
3791                 if (mp->mad_key == 'f' &&
3792                     (o->op_type == OP_CONST ||
3793                      o->op_type == OP_GV) )
3794                 {
3795                     op_getmad(from,(OP*)mp->mad_val,slot);
3796                     return;
3797                 }
3798                 if (!mp->mad_next)
3799                     break;
3800                 mp = mp->mad_next;
3801             }
3802             mp->mad_next = newMADPROP(slot,MAD_OP,from,1);
3803         }
3804         else {
3805             o->op_madprop = newMADPROP(slot,MAD_OP,from,1);
3806         }
3807     }
3808     else {
3809         PerlIO_printf(PerlIO_stderr(),
3810                       "DESTROYING op = %0"UVxf"\n", PTR2UV(from));
3811         op_free(from);
3812     }
3813 }
3814
3815 void
3816 Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot)
3817 {
3818     MADPROP* tm;
3819     if (!mp || !o)
3820         return;
3821     if (slot)
3822         mp->mad_key = slot;
3823     tm = o->op_madprop;
3824     o->op_madprop = mp;
3825     for (;;) {
3826         if (!mp->mad_next)
3827             break;
3828         mp = mp->mad_next;
3829     }
3830     mp->mad_next = tm;
3831 }
3832
3833 void
3834 Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot)
3835 {
3836     if (!o)
3837         return;
3838     addmad(tm, &(o->op_madprop), slot);
3839 }
3840
3841 void
3842 Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot)
3843 {
3844     MADPROP* mp;
3845     if (!tm || !root)
3846         return;
3847     if (slot)
3848         tm->mad_key = slot;
3849     mp = *root;
3850     if (!mp) {
3851         *root = tm;
3852         return;
3853     }
3854     for (;;) {
3855         if (!mp->mad_next)
3856             break;
3857         mp = mp->mad_next;
3858     }
3859     mp->mad_next = tm;
3860 }
3861
3862 MADPROP *
3863 Perl_newMADsv(pTHX_ char key, SV* sv)
3864 {
3865     PERL_ARGS_ASSERT_NEWMADSV;
3866
3867     return newMADPROP(key, MAD_SV, sv, 0);
3868 }
3869
3870 MADPROP *
3871 Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen)
3872 {
3873     MADPROP *const mp = (MADPROP *) PerlMemShared_malloc(sizeof(MADPROP));
3874     mp->mad_next = 0;
3875     mp->mad_key = key;
3876     mp->mad_vlen = vlen;
3877     mp->mad_type = type;
3878     mp->mad_val = val;
3879 /*    PerlIO_printf(PerlIO_stderr(), "NEW  mp = %0x\n", mp);  */
3880     return mp;
3881 }
3882
3883 void
3884 Perl_mad_free(pTHX_ MADPROP* mp)
3885 {
3886 /*    PerlIO_printf(PerlIO_stderr(), "FREE mp = %0x\n", mp); */
3887     if (!mp)
3888         return;
3889     if (mp->mad_next)
3890         mad_free(mp->mad_next);
3891 /*    if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING && mp->mad_vlen)
3892         PerlIO_printf(PerlIO_stderr(), "DESTROYING '%c'=<%s>\n", mp->mad_key & 255, mp->mad_val); */
3893     switch (mp->mad_type) {
3894     case MAD_NULL:
3895         break;
3896     case MAD_PV:
3897         Safefree(mp->mad_val);
3898         break;
3899     case MAD_OP:
3900         if (mp->mad_vlen)       /* vlen holds "strong/weak" boolean */
3901             op_free((OP*)mp->mad_val);
3902         break;
3903     case MAD_SV:
3904         sv_free(MUTABLE_SV(mp->mad_val));
3905         break;
3906     default:
3907         PerlIO_printf(PerlIO_stderr(), "Unrecognized mad\n");
3908         break;
3909     }
3910     PerlMemShared_free(mp);
3911 }
3912
3913 #endif
3914
3915 /*
3916 =head1 Optree construction
3917
3918 =for apidoc Am|OP *|newNULLLIST
3919
3920 Constructs, checks, and returns a new C<stub> op, which represents an
3921 empty list expression.
3922
3923 =cut
3924 */
3925
3926 OP *
3927 Perl_newNULLLIST(pTHX)
3928 {
3929     return newOP(OP_STUB, 0);
3930 }
3931
3932 static OP *
3933 S_force_list(pTHX_ OP *o)
3934 {
3935     if (!o || o->op_type != OP_LIST)
3936         o = newLISTOP(OP_LIST, 0, o, NULL);
3937     op_null(o);
3938     return o;
3939 }
3940
3941 /*
3942 =for apidoc Am|OP *|newLISTOP|I32 type|I32 flags|OP *first|OP *last
3943
3944 Constructs, checks, and returns an op of any list type.  I<type> is
3945 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
3946 C<OPf_KIDS> will be set automatically if required.  I<first> and I<last>
3947 supply up to two ops to be direct children of the list op; they are
3948 consumed by this function and become part of the constructed op tree.
3949
3950 =cut
3951 */
3952
3953 OP *
3954 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
3955 {
3956     dVAR;
3957     LISTOP *listop;
3958
3959     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LISTOP);
3960
3961     NewOp(1101, listop, 1, LISTOP);
3962
3963     listop->op_type = (OPCODE)type;
3964     listop->op_ppaddr = PL_ppaddr[type];
3965     if (first || last)
3966         flags |= OPf_KIDS;
3967     listop->op_flags = (U8)flags;
3968
3969     if (!last && first)
3970         last = first;
3971     else if (!first && last)
3972         first = last;
3973     else if (first)
3974         first->op_sibling = last;
3975     listop->op_first = first;
3976     listop->op_last = last;
3977     if (type == OP_LIST) {
3978         OP* const pushop = newOP(OP_PUSHMARK, 0);
3979         pushop->op_sibling = first;
3980         listop->op_first = pushop;
3981         listop->op_flags |= OPf_KIDS;
3982         if (!last)
3983             listop->op_last = pushop;
3984     }
3985
3986     return CHECKOP(type, listop);
3987 }
3988
3989 /*
3990 =for apidoc Am|OP *|newOP|I32 type|I32 flags
3991
3992 Constructs, checks, and returns an op of any base type (any type that
3993 has no extra fields).  I<type> is the opcode.  I<flags> gives the
3994 eight bits of C<op_flags>, and, shifted up eight bits, the eight bits
3995 of C<op_private>.
3996
3997 =cut
3998 */
3999
4000 OP *
4001 Perl_newOP(pTHX_ I32 type, I32 flags)
4002 {
4003     dVAR;
4004     OP *o;
4005
4006     if (type == -OP_ENTEREVAL) {
4007         type = OP_ENTEREVAL;
4008         flags |= OPpEVAL_BYTES<<8;
4009     }
4010
4011     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP
4012         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
4013         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
4014         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
4015
4016     NewOp(1101, o, 1, OP);
4017     o->op_type = (OPCODE)type;
4018     o->op_ppaddr = PL_ppaddr[type];
4019     o->op_flags = (U8)flags;
4020
4021     o->op_next = o;
4022     o->op_private = (U8)(0 | (flags >> 8));
4023     if (PL_opargs[type] & OA_RETSCALAR)
4024         scalar(o);
4025     if (PL_opargs[type] & OA_TARGET)
4026         o->op_targ = pad_alloc(type, SVs_PADTMP);
4027     return CHECKOP(type, o);
4028 }
4029
4030 /*
4031 =for apidoc Am|OP *|newUNOP|I32 type|I32 flags|OP *first
4032
4033 Constructs, checks, and returns an op of any unary type.  I<type> is
4034 the opcode.  I<flags> gives the eight bits of C<op_flags>, except that
4035 C<OPf_KIDS> will be set automatically if required, and, shifted up eight
4036 bits, the eight bits of C<op_private>, except that the bit with value 1
4037 is automatically set.  I<first> supplies an optional op to be the direct
4038 child of the unary op; it is consumed by this function and become part
4039 of the constructed op tree.
4040
4041 =cut
4042 */
4043
4044 OP *
4045 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
4046 {
4047     dVAR;
4048     UNOP *unop;
4049
4050     if (type == -OP_ENTEREVAL) {
4051         type = OP_ENTEREVAL;
4052         flags |= OPpEVAL_BYTES<<8;
4053     }
4054
4055     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_UNOP
4056         || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
4057         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
4058         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP
4059         || type == OP_SASSIGN
4060         || type == OP_ENTERTRY
4061         || type == OP_NULL );
4062
4063     if (!first)
4064         first = newOP(OP_STUB, 0);
4065     if (PL_opargs[type] & OA_MARK)
4066         first = force_list(first);
4067
4068     NewOp(1101, unop, 1, UNOP);
4069     unop->op_type = (OPCODE)type;
4070     unop->op_ppaddr = PL_ppaddr[type];
4071     unop->op_first = first;
4072     unop->op_flags = (U8)(flags | OPf_KIDS);
4073     unop->op_private = (U8)(1 | (flags >> 8));
4074     unop = (UNOP*) CHECKOP(type, unop);
4075     if (unop->op_next)
4076         return (OP*)unop;
4077
4078     return fold_constants(op_integerize(op_std_init((OP *) unop)));
4079 }
4080
4081 /*
4082 =for apidoc Am|OP *|newBINOP|I32 type|I32 flags|OP *first|OP *last
4083
4084 Constructs, checks, and returns an op of any binary type.  I<type>
4085 is the opcode.  I<flags> gives the eight bits of C<op_flags>, except
4086 that C<OPf_KIDS> will be set automatically, and, shifted up eight bits,
4087 the eight bits of C<op_private>, except that the bit with value 1 or
4088 2 is automatically set as required.  I<first> and I<last> supply up to
4089 two ops to be the direct children of the binary op; they are consumed
4090 by this function and become part of the constructed op tree.
4091
4092 =cut
4093 */
4094
4095 OP *
4096 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
4097 {
4098     dVAR;
4099     BINOP *binop;
4100
4101     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BINOP
4102         || type == OP_SASSIGN || type == OP_NULL );
4103
4104     NewOp(1101, binop, 1, BINOP);
4105
4106     if (!first)
4107         first = newOP(OP_NULL, 0);
4108
4109     binop->op_type = (OPCODE)type;
4110     binop->op_ppaddr = PL_ppaddr[type];
4111     binop->op_first = first;
4112     binop->op_flags = (U8)(flags | OPf_KIDS);
4113     if (!last) {
4114         last = first;
4115         binop->op_private = (U8)(1 | (flags >> 8));
4116     }
4117     else {
4118         binop->op_private = (U8)(2 | (flags >> 8));
4119         first->op_sibling = last;
4120     }
4121
4122     binop = (BINOP*)CHECKOP(type, binop);
4123     if (binop->op_next || binop->op_type != (OPCODE)type)
4124         return (OP*)binop;
4125
4126     binop->op_last = binop->op_first->op_sibling;
4127
4128     return fold_constants(op_integerize(op_std_init((OP *)binop)));
4129 }
4130
4131 static int uvcompare(const void *a, const void *b)
4132     __attribute__nonnull__(1)
4133     __attribute__nonnull__(2)
4134     __attribute__pure__;
4135 static int uvcompare(const void *a, const void *b)
4136 {
4137     if (*((const UV *)a) < (*(const UV *)b))
4138         return -1;
4139     if (*((const UV *)a) > (*(const UV *)b))
4140         return 1;
4141     if (*((const UV *)a+1) < (*(const UV *)b+1))
4142         return -1;
4143     if (*((const UV *)a+1) > (*(const UV *)b+1))
4144         return 1;
4145     return 0;
4146 }
4147
4148 static OP *
4149 S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
4150 {
4151     dVAR;
4152     SV * const tstr = ((SVOP*)expr)->op_sv;
4153     SV * const rstr =
4154 #ifdef PERL_MAD
4155                         (repl->op_type == OP_NULL)
4156                             ? ((SVOP*)((LISTOP*)repl)->op_first)->op_sv :
4157 #endif
4158                               ((SVOP*)repl)->op_sv;
4159     STRLEN tlen;
4160     STRLEN rlen;
4161     const U8 *t = (U8*)SvPV_const(tstr, tlen);
4162     const U8 *r = (U8*)SvPV_const(rstr, rlen);
4163     I32 i;
4164     I32 j;
4165     I32 grows = 0;
4166     short *tbl;
4167
4168     const I32 complement = o->op_private & OPpTRANS_COMPLEMENT;
4169     const I32 squash     = o->op_private & OPpTRANS_SQUASH;
4170     I32 del              = o->op_private & OPpTRANS_DELETE;
4171     SV* swash;
4172
4173     PERL_ARGS_ASSERT_PMTRANS;
4174
4175     PL_hints |= HINT_BLOCK_SCOPE;
4176
4177     if (SvUTF8(tstr))
4178         o->op_private |= OPpTRANS_FROM_UTF;
4179
4180     if (SvUTF8(rstr))
4181         o->op_private |= OPpTRANS_TO_UTF;
4182
4183     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
4184         SV* const listsv = newSVpvs("# comment\n");
4185         SV* transv = NULL;
4186         const U8* tend = t + tlen;
4187         const U8* rend = r + rlen;
4188         STRLEN ulen;
4189         UV tfirst = 1;
4190         UV tlast = 0;
4191         IV tdiff;
4192         UV rfirst = 1;
4193         UV rlast = 0;
4194         IV rdiff;
4195         IV diff;
4196         I32 none = 0;
4197         U32 max = 0;
4198         I32 bits;
4199         I32 havefinal = 0;
4200         U32 final = 0;
4201         const I32 from_utf  = o->op_private & OPpTRANS_FROM_UTF;
4202         const I32 to_utf    = o->op_private & OPpTRANS_TO_UTF;
4203         U8* tsave = NULL;
4204         U8* rsave = NULL;
4205         const U32 flags = UTF8_ALLOW_DEFAULT;
4206
4207         if (!from_utf) {
4208             STRLEN len = tlen;
4209             t = tsave = bytes_to_utf8(t, &len);
4210             tend = t + len;
4211         }
4212         if (!to_utf && rlen) {
4213             STRLEN len = rlen;
4214             r = rsave = bytes_to_utf8(r, &len);
4215             rend = r + len;
4216         }
4217
4218 /* There is a  snag with this code on EBCDIC: scan_const() in toke.c has
4219  * encoded chars in native encoding which makes ranges in the EBCDIC 0..255
4220  * odd.  */
4221
4222         if (complement) {
4223             U8 tmpbuf[UTF8_MAXBYTES+1];
4224             UV *cp;
4225             UV nextmin = 0;
4226             Newx(cp, 2*tlen, UV);
4227             i = 0;
4228             transv = newSVpvs("");
4229             while (t < tend) {
4230                 cp[2*i] = utf8n_to_uvchr(t, tend-t, &ulen, flags);
4231                 t += ulen;
4232                 if (t < tend && *t == ILLEGAL_UTF8_BYTE) {
4233                     t++;
4234                     cp[2*i+1] = utf8n_to_uvchr(t, tend-t, &ulen, flags);
4235                     t += ulen;
4236                 }
4237                 else {
4238                  cp[2*i+1] = cp[2*i];
4239                 }
4240                 i++;
4241             }
4242             qsort(cp, i, 2*sizeof(UV), uvcompare);
4243             for (j = 0; j < i; j++) {
4244                 UV  val = cp[2*j];
4245                 diff = val - nextmin;
4246                 if (diff > 0) {
4247                     t = uvchr_to_utf8(tmpbuf,nextmin);
4248                     sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4249                     if (diff > 1) {
4250                         U8  range_mark = ILLEGAL_UTF8_BYTE;
4251                         t = uvchr_to_utf8(tmpbuf, val - 1);
4252                         sv_catpvn(transv, (char *)&range_mark, 1);
4253                         sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4254                     }
4255                 }
4256                 val = cp[2*j+1];
4257                 if (val >= nextmin)
4258                     nextmin = val + 1;
4259             }
4260             t = uvchr_to_utf8(tmpbuf,nextmin);
4261             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4262             {
4263                 U8 range_mark = ILLEGAL_UTF8_BYTE;
4264                 sv_catpvn(transv, (char *)&range_mark, 1);
4265             }
4266             t = uvchr_to_utf8(tmpbuf, 0x7fffffff);
4267             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
4268             t = (const U8*)SvPVX_const(transv);
4269             tlen = SvCUR(transv);
4270             tend = t + tlen;
4271             Safefree(cp);
4272         }
4273         else if (!rlen && !del) {
4274             r = t; rlen = tlen; rend = tend;
4275         }
4276         if (!squash) {
4277                 if ((!rlen && !del) || t == r ||
4278                     (tlen == rlen && memEQ((char *)t, (char *)r, tlen)))
4279                 {
4280                     o->op_private |= OPpTRANS_IDENTICAL;
4281                 }
4282         }
4283
4284         while (t < tend || tfirst <= tlast) {
4285             /* see if we need more "t" chars */
4286             if (tfirst > tlast) {
4287                 tfirst = (I32)utf8n_to_uvchr(t, tend - t, &ulen, flags);
4288                 t += ulen;
4289                 if (t < tend && *t == ILLEGAL_UTF8_BYTE) {      /* illegal utf8 val indicates range */
4290                     t++;
4291                     tlast = (I32)utf8n_to_uvchr(t, tend - t, &ulen, flags);
4292                     t += ulen;
4293                 }
4294                 else
4295                     tlast = tfirst;
4296             }
4297
4298             /* now see if we need more "r" chars */
4299             if (rfirst > rlast) {
4300                 if (r < rend) {
4301                     rfirst = (I32)utf8n_to_uvchr(r, rend - r, &ulen, flags);
4302                     r += ulen;
4303                     if (r < rend && *r == ILLEGAL_UTF8_BYTE) {  /* illegal utf8 val indicates range */
4304                         r++;
4305                         rlast = (I32)utf8n_to_uvchr(r, rend - r, &ulen, flags);
4306                         r += ulen;
4307                     }
4308                     else
4309                         rlast = rfirst;
4310                 }
4311                 else {
4312                     if (!havefinal++)
4313                         final = rlast;
4314                     rfirst = rlast = 0xffffffff;
4315                 }
4316             }
4317
4318             /* now see which range will peter our first, if either. */
4319             tdiff = tlast - tfirst;
4320             rdiff = rlast - rfirst;
4321
4322             if (tdiff <= rdiff)
4323                 diff = tdiff;
4324             else
4325                 diff = rdiff;
4326
4327             if (rfirst == 0xffffffff) {
4328                 diff = tdiff;   /* oops, pretend rdiff is infinite */
4329                 if (diff > 0)
4330                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\tXXXX\n",
4331                                    (long)tfirst, (long)tlast);
4332                 else
4333                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\tXXXX\n", (long)tfirst);
4334             }
4335             else {
4336                 if (diff > 0)
4337                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\t%04lx\n",
4338                                    (long)tfirst, (long)(tfirst + diff),
4339                                    (long)rfirst);
4340                 else
4341                     Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\t%04lx\n",
4342                                    (long)tfirst, (long)rfirst);
4343
4344                 if (rfirst + diff > max)
4345                     max = rfirst + diff;
4346                 if (!grows)
4347                     grows = (tfirst < rfirst &&
4348                              UNISKIP(tfirst) < UNISKIP(rfirst + diff));
4349                 rfirst += diff + 1;
4350             }
4351             tfirst += diff + 1;
4352         }
4353
4354         none = ++max;
4355         if (del)
4356             del = ++max;
4357
4358         if (max > 0xffff)
4359             bits = 32;
4360         else if (max > 0xff)
4361             bits = 16;
4362         else
4363             bits = 8;
4364
4365         swash = MUTABLE_SV(swash_init("utf8", "", listsv, bits, none));
4366 #ifdef USE_ITHREADS
4367         cPADOPo->op_padix = pad_alloc(OP_TRANS, SVf_READONLY);
4368         SvREFCNT_dec(PAD_SVl(cPADOPo->op_padix));
4369         PAD_SETSV(cPADOPo->op_padix, swash);
4370         SvPADTMP_on(swash);
4371         SvREADONLY_on(swash);
4372 #else
4373         cSVOPo->op_sv = swash;
4374 #endif
4375         SvREFCNT_dec(listsv);
4376         SvREFCNT_dec(transv);
4377
4378         if (!del && havefinal && rlen)
4379             (void)hv_store(MUTABLE_HV(SvRV(swash)), "FINAL", 5,
4380                            newSVuv((UV)final), 0);
4381
4382         if (grows)
4383             o->op_private |= OPpTRANS_GROWS;
4384
4385         Safefree(tsave);
4386         Safefree(rsave);
4387
4388 #ifdef PERL_MAD
4389         op_getmad(expr,o,'e');
4390         op_getmad(repl,o,'r');
4391 #else
4392         op_free(expr);
4393         op_free(repl);
4394 #endif
4395         return o;
4396     }
4397
4398     tbl = (short*)PerlMemShared_calloc(
4399         (o->op_private & OPpTRANS_COMPLEMENT) &&
4400             !(o->op_private & OPpTRANS_DELETE) ? 258 : 256,
4401         sizeof(short));
4402     cPVOPo->op_pv = (char*)tbl;
4403     if (complement) {
4404         for (i = 0; i < (I32)tlen; i++)
4405             tbl[t[i]] = -1;
4406         for (i = 0, j = 0; i < 256; i++) {
4407             if (!tbl[i]) {
4408                 if (j >= (I32)rlen) {
4409                     if (del)
4410                         tbl[i] = -2;
4411                     else if (rlen)
4412                         tbl[i] = r[j-1];
4413                     else
4414                         tbl[i] = (short)i;
4415                 }
4416                 else {
4417                     if (i < 128 && r[j] >= 128)
4418                         grows = 1;
4419                     tbl[i] = r[j++];
4420                 }
4421             }
4422         }
4423         if (!del) {
4424             if (!rlen) {
4425                 j = rlen;
4426                 if (!squash)
4427                     o->op_private |= OPpTRANS_IDENTICAL;
4428             }
4429             else if (j >= (I32)rlen)
4430                 j = rlen - 1;
4431             else {
4432                 tbl =
4433                     (short *)
4434                     PerlMemShared_realloc(tbl,
4435                                           (0x101+rlen-j) * sizeof(short));
4436                 cPVOPo->op_pv = (char*)tbl;
4437             }
4438             tbl[0x100] = (short)(rlen - j);
4439             for (i=0; i < (I32)rlen - j; i++)
4440                 tbl[0x101+i] = r[j+i];
4441         }
4442     }
4443     else {
4444         if (!rlen && !del) {
4445             r = t; rlen = tlen;
4446             if (!squash)
4447                 o->op_private |= OPpTRANS_IDENTICAL;
4448         }
4449         else if (!squash && rlen == tlen && memEQ((char*)t, (char*)r, tlen)) {
4450             o->op_private |= OPpTRANS_IDENTICAL;
4451         }
4452         for (i = 0; i < 256; i++)
4453             tbl[i] = -1;
4454         for (i = 0, j = 0; i < (I32)tlen; i++,j++) {
4455             if (j >= (I32)rlen) {
4456                 if (del) {
4457                     if (tbl[t[i]] == -1)
4458                         tbl[t[i]] = -2;
4459                     continue;
4460                 }
4461                 --j;
4462             }
4463             if (tbl[t[i]] == -1) {
4464                 if (t[i] < 128 && r[j] >= 128)
4465                     grows = 1;
4466                 tbl[t[i]] = r[j];
4467             }
4468         }
4469     }
4470
4471     if(del && rlen == tlen) {
4472         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Useless use of /d modifier in transliteration operator");
4473     } else if(rlen > tlen && !complement) {
4474         Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Replacement list is longer than search list");
4475     }
4476
4477     if (grows)
4478         o->op_private |= OPpTRANS_GROWS;
4479 #ifdef PERL_MAD
4480     op_getmad(expr,o,'e');
4481     op_getmad(repl,o,'r');
4482 #else
4483     op_free(expr);
4484     op_free(repl);
4485 #endif
4486
4487     return o;
4488 }
4489
4490 /*
4491 =for apidoc Am|OP *|newPMOP|I32 type|I32 flags
4492
4493 Constructs, checks, and returns an op of any pattern matching type.
4494 I<type> is the opcode.  I<flags> gives the eight bits of C<op_flags>
4495 and, shifted up eight bits, the eight bits of C<op_private>.
4496
4497 =cut
4498 */
4499
4500 OP *
4501 Perl_newPMOP(pTHX_ I32 type, I32 flags)
4502 {
4503     dVAR;
4504     PMOP *pmop;
4505
4506     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PMOP);
4507
4508     NewOp(1101, pmop, 1, PMOP);
4509     pmop->op_type = (OPCODE)type;
4510     pmop->op_ppaddr = PL_ppaddr[type];
4511     pmop->op_flags = (U8)flags;
4512     pmop->op_private = (U8)(0 | (flags >> 8));
4513
4514     if (PL_hints & HINT_RE_TAINT)
4515         pmop->op_pmflags |= PMf_RETAINT;
4516     if (IN_LOCALE_COMPILETIME) {
4517         set_regex_charset(&(pmop->op_pmflags), REGEX_LOCALE_CHARSET);
4518     }
4519     else if ((! (PL_hints & HINT_BYTES))
4520                 /* Both UNI_8_BIT and locale :not_characters imply Unicode */
4521              && (PL_hints & (HINT_UNI_8_BIT|HINT_LOCALE_NOT_CHARS)))
4522     {
4523         set_regex_charset(&(pmop->op_pmflags), REGEX_UNICODE_CHARSET);
4524     }
4525     if (PL_hints & HINT_RE_FLAGS) {
4526         SV *reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4527          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags"), 0, 0
4528         );
4529         if (reflags && SvOK(reflags)) pmop->op_pmflags |= SvIV(reflags);
4530         reflags = Perl_refcounted_he_fetch_pvn(aTHX_
4531          PL_compiling.cop_hints_hash, STR_WITH_LEN("reflags_charset"), 0, 0
4532         );
4533         if (reflags && SvOK(reflags)) {
4534             set_regex_charset(&(pmop->op_pmflags), (regex_charset)SvIV(reflags));
4535         }
4536     }
4537
4538
4539 #ifdef USE_ITHREADS
4540     assert(SvPOK(PL_regex_pad[0]));
4541     if (SvCUR(PL_regex_pad[0])) {
4542         /* Pop off the "packed" IV from the end.  */
4543         SV *const repointer_list = PL_regex_pad[0];
4544         const char *p = SvEND(repointer_list) - sizeof(IV);
4545         const IV offset = *((IV*)p);
4546
4547         assert(SvCUR(repointer_list) % sizeof(IV) == 0);
4548
4549         SvEND_set(repointer_list, p);
4550
4551         pmop->op_pmoffset = offset;
4552         /* This slot should be free, so assert this:  */
4553         assert(PL_regex_pad[offset] == &PL_sv_undef);
4554     } else {
4555         SV * const repointer = &PL_sv_undef;
4556         av_push(PL_regex_padav, repointer);
4557         pmop->op_pmoffset = av_len(PL_regex_padav);
4558         PL_regex_pad = AvARRAY(PL_regex_padav);
4559     }
4560 #endif
4561
4562     return CHECKOP(type, pmop);
4563 }
4564
4565 /* Given some sort of match op o, and an expression expr containing a
4566  * pattern, either compile expr into a regex and attach it to o (if it's
4567  * constant), or convert expr into a runtime regcomp op sequence (if it's
4568  * not)
4569  *
4570  * isreg indicates that the pattern is part of a regex construct, eg
4571  * $x =~ /pattern/ or split /pattern/, as opposed to $x =~ $pattern or
4572  * split "pattern", which aren't. In the former case, expr will be a list
4573  * if the pattern contains more than one term (eg /a$b/) or if it contains
4574  * a replacement, ie s/// or tr///.
4575  *
4576  * When the pattern has been compiled within a new anon CV (for
4577  * qr/(?{...})/ ), then floor indicates the savestack level just before
4578  * the new sub was created
4579  */
4580
4581 OP *
4582 Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor)
4583 {
4584     dVAR;
4585     PMOP *pm;
4586     LOGOP *rcop;
4587     I32 repl_has_vars = 0;
4588     OP* repl = NULL;
4589     bool is_trans = (o->op_type == OP_TRANS || o->op_type == OP_TRANSR);
4590     bool is_compiletime;
4591     bool has_code;
4592
4593     PERL_ARGS_ASSERT_PMRUNTIME;
4594
4595     /* for s/// and tr///, last element in list is the replacement; pop it */
4596
4597     if (is_trans || o->op_type == OP_SUBST) {
4598         OP* kid;
4599         repl = cLISTOPx(expr)->op_last;
4600         kid = cLISTOPx(expr)->op_first;
4601         while (kid->op_sibling != repl)
4602             kid = kid->op_sibling;
4603         kid->op_sibling = NULL;
4604         cLISTOPx(expr)->op_last = kid;
4605     }
4606
4607     /* for TRANS, convert LIST/PUSH/CONST into CONST, and pass to pmtrans() */
4608
4609     if (is_trans) {
4610         OP* const oe = expr;
4611         assert(expr->op_type == OP_LIST);
4612         assert(cLISTOPx(expr)->op_first->op_type == OP_PUSHMARK);
4613         assert(cLISTOPx(expr)->op_first->op_sibling == cLISTOPx(expr)->op_last);
4614         expr = cLISTOPx(oe)->op_last;
4615         cLISTOPx(oe)->op_first->op_sibling = NULL;
4616         cLISTOPx(oe)->op_last = NULL;
4617         op_free(oe);
4618
4619         return pmtrans(o, expr, repl);
4620     }
4621
4622     /* find whether we have any runtime or code elements;
4623      * at the same time, temporarily set the op_next of each DO block;
4624      * then when we LINKLIST, this will cause the DO blocks to be excluded
4625      * from the op_next chain (and from having LINKLIST recursively
4626      * applied to them). We fix up the DOs specially later */
4627
4628     is_compiletime = 1;
4629     has_code = 0;
4630     if (expr->op_type == OP_LIST) {
4631         OP *o;
4632         for (o = cLISTOPx(expr)->op_first; o; o = o->op_sibling) {
4633             if (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)) {
4634                 has_code = 1;
4635                 assert(!o->op_next && o->op_sibling);
4636                 o->op_next = o->op_sibling;
4637             }
4638             else if (o->op_type != OP_CONST && o->op_type != OP_PUSHMARK)
4639                 is_compiletime = 0;
4640         }
4641     }
4642     else if (expr->op_type != OP_CONST)
4643         is_compiletime = 0;
4644
4645     LINKLIST(expr);
4646
4647     /* fix up DO blocks; treat each one as a separate little sub;
4648      * also, mark any arrays as LIST/REF */
4649
4650     if (expr->op_type == OP_LIST) {
4651         OP *o;
4652         for (o = cLISTOPx(expr)->op_first; o; o = o->op_sibling) {
4653
4654             if (o->op_type == OP_PADAV || o->op_type == OP_RV2AV) {
4655                 assert( !(o->op_flags  & OPf_WANT));
4656                 /* push the array rather than its contents. The regex
4657                  * engine will retrieve and join the elements later */
4658                 o->op_flags |= (OPf_WANT_LIST | OPf_REF);
4659                 continue;
4660             }
4661
4662             if (!(o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)))
4663                 continue;
4664             o->op_next = NULL; /* undo temporary hack from above */
4665             scalar(o);
4666             LINKLIST(o);
4667             if (cLISTOPo->op_first->op_type == OP_LEAVE) {
4668                 LISTOP *leaveop = cLISTOPx(cLISTOPo->op_first);
4669                 /* skip ENTER */
4670                 assert(leaveop->op_first->op_type == OP_ENTER);
4671                 assert(leaveop->op_first->op_sibling);
4672                 o->op_next = leaveop->op_first->op_sibling;
4673                 /* skip leave */
4674                 assert(leaveop->op_flags & OPf_KIDS);
4675                 assert(leaveop->op_last->op_next == (OP*)leaveop);
4676                 leaveop->op_next = NULL; /* stop on last op */
4677                 op_null((OP*)leaveop);
4678             }
4679             else {
4680                 /* skip SCOPE */
4681                 OP *scope = cLISTOPo->op_first;
4682                 assert(scope->op_type == OP_SCOPE);
4683                 assert(scope->op_flags & OPf_KIDS);
4684                 scope->op_next = NULL; /* stop on last op */
4685                 op_null(scope);
4686             }
4687             /* have to peep the DOs individually as we've removed it from
4688              * the op_next chain */
4689             CALL_PEEP(o);
4690             if (is_compiletime)
4691                 /* runtime finalizes as part of finalizing whole tree */
4692                 finalize_optree(o);
4693         }
4694     }
4695     else if (expr->op_type == OP_PADAV || expr->op_type == OP_RV2AV) {
4696         assert( !(expr->op_flags  & OPf_WANT));
4697         /* push the array rather than its contents. The regex
4698          * engine will retrieve and join the elements later */
4699         expr->op_flags |= (OPf_WANT_LIST | OPf_REF);
4700     }
4701
4702     PL_hints |= HINT_BLOCK_SCOPE;
4703     pm = (PMOP*)o;
4704     assert(floor==0 || (pm->op_pmflags & PMf_HAS_CV));
4705
4706     if (is_compiletime) {
4707         U32 rx_flags = pm->op_pmflags & RXf_PMf_COMPILETIME;
4708         regexp_engine const *eng = current_re_engine();
4709
4710         if (o->op_flags & OPf_SPECIAL)
4711             rx_flags |= RXf_SPLIT;
4712
4713         if (!has_code || !eng->op_comp) {
4714             /* compile-time simple constant pattern */
4715
4716             if ((pm->op_pmflags & PMf_HAS_CV) && !has_code) {
4717                 /* whoops! we guessed that a qr// had a code block, but we
4718                  * were wrong (e.g. /[(?{}]/ ). Throw away the PL_compcv
4719                  * that isn't required now. Note that we have to be pretty
4720                  * confident that nothing used that CV's pad while the
4721                  * regex was parsed */
4722                 assert(AvFILLp(PL_comppad) == 0); /* just @_ */
4723                 /* But we know that one op is using this CV's slab. */
4724                 cv_forget_slab(PL_compcv);
4725                 LEAVE_SCOPE(floor);
4726                 pm->op_pmflags &= ~PMf_HAS_CV;
4727             }
4728
4729             PM_SETRE(pm,
4730                 eng->op_comp
4731                     ? eng->op_comp(aTHX_ NULL, 0, expr, eng, NULL, NULL,
4732                                         rx_flags, pm->op_pmflags)
4733                     : Perl_re_op_compile(aTHX_ NULL, 0, expr, eng, NULL, NULL,
4734                                         rx_flags, pm->op_pmflags)
4735             );
4736 #ifdef PERL_MAD
4737             op_getmad(expr,(OP*)pm,'e');
4738 #else
4739             op_free(expr);
4740 #endif
4741         }
4742         else {
4743             /* compile-time pattern that includes literal code blocks */
4744             REGEXP* re = eng->op_comp(aTHX_ NULL, 0, expr, eng, NULL, NULL,
4745                         rx_flags,
4746                         (pm->op_pmflags |
4747                             ((PL_hints & HINT_RE_EVAL) ? PMf_USE_RE_EVAL : 0))
4748                     );
4749             PM_SETRE(pm, re);
4750             if (pm->op_pmflags & PMf_HAS_CV) {
4751                 CV *cv;
4752                 /* this QR op (and the anon sub we embed it in) is never
4753                  * actually executed. It's just a placeholder where we can
4754                  * squirrel away expr in op_code_list without the peephole
4755                  * optimiser etc processing it for a second time */
4756                 OP *qr = newPMOP(OP_QR, 0);
4757                 ((PMOP*)qr)->op_code_list = expr;
4758
4759                 /* handle the implicit sub{} wrapped round the qr/(?{..})/ */
4760                 SvREFCNT_inc_simple_void(PL_compcv);
4761                 cv = newATTRSUB(floor, 0, NULL, NULL, qr);
4762                 ReANY(re)->qr_anoncv = cv;
4763
4764                 /* attach the anon CV to the pad so that
4765                  * pad_fixup_inner_anons() can find it */
4766                 (void)pad_add_anon(cv, o->op_type);
4767                 SvREFCNT_inc_simple_void(cv);
4768             }
4769             else {
4770                 pm->op_code_list = expr;
4771             }
4772         }
4773     }
4774     else {
4775         /* runtime pattern: build chain of regcomp etc ops */
4776         bool reglist;
4777         PADOFFSET cv_targ = 0;
4778
4779         reglist = isreg && expr->op_type == OP_LIST;
4780         if (reglist)
4781             op_null(expr);
4782
4783         if (has_code) {
4784             pm->op_code_list = expr;
4785             /* don't free op_code_list; its ops are embedded elsewhere too */
4786             pm->op_pmflags |= PMf_CODELIST_PRIVATE;
4787         }
4788
4789         if (o->op_flags & OPf_SPECIAL)
4790             pm->op_pmflags |= PMf_SPLIT;
4791
4792         /* the OP_REGCMAYBE is a placeholder in the non-threaded case
4793          * to allow its op_next to be pointed past the regcomp and
4794          * preceding stacking ops;
4795          * OP_REGCRESET is there to reset taint before executing the
4796          * stacking ops */
4797         if (pm->op_pmflags & PMf_KEEP || TAINTING_get)
4798             expr = newUNOP((TAINTING_get ? OP_REGCRESET : OP_REGCMAYBE),0,expr);
4799
4800         if (pm->op_pmflags & PMf_HAS_CV) {
4801             /* we have a runtime qr with literal code. This means
4802              * that the qr// has been wrapped in a new CV, which
4803              * means that runtime consts, vars etc will have been compiled
4804              * against a new pad. So... we need to execute those ops
4805              * within the environment of the new CV. So wrap them in a call
4806              * to a new anon sub. i.e. for
4807              *
4808              *     qr/a$b(?{...})/,
4809              *
4810              * we build an anon sub that looks like
4811              *
4812              *     sub { "a", $b, '(?{...})' }
4813              *
4814              * and call it, passing the returned list to regcomp.
4815              * Or to put it another way, the list of ops that get executed
4816              * are:
4817              *
4818              *     normal              PMf_HAS_CV
4819              *     ------              -------------------
4820              *                         pushmark (for regcomp)
4821              *                         pushmark (for entersub)
4822              *                         pushmark (for refgen)
4823              *                         anoncode
4824              *                         refgen
4825              *                         entersub
4826              *     regcreset                  regcreset
4827              *     pushmark                   pushmark
4828              *     const("a")                 const("a")
4829              *     gvsv(b)                    gvsv(b)
4830              *     const("(?{...})")          const("(?{...})")
4831              *                                leavesub
4832              *     regcomp             regcomp
4833              */
4834
4835             SvREFCNT_inc_simple_void(PL_compcv);
4836             /* these lines are just an unrolled newANONATTRSUB */
4837             expr = newSVOP(OP_ANONCODE, 0,
4838                     MUTABLE_SV(newATTRSUB(floor, 0, NULL, NULL, expr)));
4839             cv_targ = expr->op_targ;
4840             expr = newUNOP(OP_REFGEN, 0, expr);
4841
4842             expr = list(force_list(newUNOP(OP_ENTERSUB, 0, scalar(expr))));
4843         }
4844
4845         NewOp(1101, rcop, 1, LOGOP);
4846         rcop->op_type = OP_REGCOMP;
4847         rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP];
4848         rcop->op_first = scalar(expr);
4849         rcop->op_flags |= OPf_KIDS
4850                             | ((PL_hints & HINT_RE_EVAL) ? OPf_SPECIAL : 0)
4851                             | (reglist ? OPf_STACKED : 0);
4852         rcop->op_private = 0;
4853         rcop->op_other = o;
4854         rcop->op_targ = cv_targ;
4855
4856         /* /$x/ may cause an eval, since $x might be qr/(?{..})/  */
4857         if (PL_hints & HINT_RE_EVAL) PL_cv_has_eval = 1;
4858
4859         /* establish postfix order */
4860         if (expr->op_type == OP_REGCRESET || expr->op_type == OP_REGCMAYBE) {
4861             LINKLIST(expr);
4862             rcop->op_next = expr;
4863             ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
4864         }
4865         else {
4866             rcop->op_next = LINKLIST(expr);
4867             expr->op_next = (OP*)rcop;
4868         }
4869
4870         op_prepend_elem(o->op_type, scalar((OP*)rcop), o);
4871     }
4872
4873     if (repl) {
4874         OP *curop = repl;
4875         bool konst;
4876         /* If we are looking at s//.../e with a single statement, get past
4877            the implicit do{}. */
4878         if (curop->op_type == OP_NULL && curop->op_flags & OPf_KIDS
4879          && cUNOPx(curop)->op_first->op_type == OP_SCOPE
4880          && cUNOPx(curop)->op_first->op_flags & OPf_KIDS) {
4881             OP *kid = cUNOPx(cUNOPx(curop)->op_first)->op_first;
4882             if (kid->op_type == OP_NULL && kid->op_sibling
4883              && !kid->op_sibling->op_sibling)
4884                 curop = kid->op_sibling;
4885         }
4886         if (curop->op_type == OP_CONST)
4887             konst = TRUE;
4888         else if (( (curop->op_type == OP_RV2SV ||
4889                     curop->op_type == OP_RV2AV ||
4890                     curop->op_type == OP_RV2HV ||
4891                     curop->op_type == OP_RV2GV)
4892                    && cUNOPx(curop)->op_first
4893                    && cUNOPx(curop)->op_first->op_type == OP_GV )
4894                 || curop->op_type == OP_PADSV
4895                 || curop->op_type == OP_PADAV
4896                 || curop->op_type == OP_PADHV
4897                 || curop->op_type == OP_PADANY) {
4898             repl_has_vars = 1;
4899             konst = TRUE;
4900         }
4901         else konst = FALSE;
4902         if (konst
4903             && !(repl_has_vars
4904                  && (!PM_GETRE(pm)
4905                      || !RX_PRELEN(PM_GETRE(pm))
4906                      || RX_EXTFLAGS(PM_GETRE(pm)) & RXf_EVAL_SEEN)))
4907         {
4908             pm->op_pmflags |= PMf_CONST;        /* const for long enough */
4909             op_prepend_elem(o->op_type, scalar(repl), o);
4910         }
4911         else {
4912             NewOp(1101, rcop, 1, LOGOP);
4913             rcop->op_type = OP_SUBSTCONT;
4914             rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT];
4915             rcop->op_first = scalar(repl);
4916             rcop->op_flags |= OPf_KIDS;
4917             rcop->op_private = 1;
4918             rcop->op_other = o;
4919
4920             /* establish postfix order */
4921             rcop->op_next = LINKLIST(repl);
4922             repl->op_next = (OP*)rcop;
4923
4924             pm->op_pmreplrootu.op_pmreplroot = scalar((OP*)rcop);
4925             assert(!(pm->op_pmflags & PMf_ONCE));
4926             pm->op_pmstashstartu.op_pmreplstart = LINKLIST(rcop);
4927             rcop->op_next = 0;
4928         }
4929     }
4930
4931     return (OP*)pm;
4932 }
4933
4934 /*
4935 =for apidoc Am|OP *|newSVOP|I32 type|I32 flags|SV *sv
4936
4937 Constructs, checks, and returns an op of any type that involves an
4938 embedded SV.  I<type> is the opcode.  I<flags> gives the eight bits
4939 of C<op_flags>.  I<sv> gives the SV to embed in the op; this function
4940 takes ownership of one reference to it.
4941
4942 =cut
4943 */
4944
4945 OP *
4946 Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
4947 {
4948     dVAR;
4949     SVOP *svop;
4950
4951     PERL_ARGS_ASSERT_NEWSVOP;
4952
4953     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_SVOP
4954         || (PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4955         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP);
4956
4957     NewOp(1101, svop, 1, SVOP);
4958     svop->op_type = (OPCODE)type;
4959     svop->op_ppaddr = PL_ppaddr[type];
4960     svop->op_sv = sv;
4961     svop->op_next = (OP*)svop;
4962     svop->op_flags = (U8)flags;
4963     svop->op_private = (U8)(0 | (flags >> 8));
4964     if (PL_opargs[type] & OA_RETSCALAR)
4965         scalar((OP*)svop);
4966     if (PL_opargs[type] & OA_TARGET)
4967         svop->op_targ = pad_alloc(type, SVs_PADTMP);
4968     return CHECKOP(type, svop);
4969 }
4970
4971 #ifdef USE_ITHREADS
4972
4973 /*
4974 =for apidoc Am|OP *|newPADOP|I32 type|I32 flags|SV *sv
4975
4976 Constructs, checks, and returns an op of any type that involves a
4977 reference to a pad element.  I<type> is the opcode.  I<flags> gives the
4978 eight bits of C<op_flags>.  A pad slot is automatically allocated, and
4979 is populated with I<sv>; this function takes ownership of one reference
4980 to it.
4981
4982 This function only exists if Perl has been compiled to use ithreads.
4983
4984 =cut
4985 */
4986
4987 OP *
4988 Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv)
4989 {
4990     dVAR;
4991     PADOP *padop;
4992
4993     PERL_ARGS_ASSERT_NEWPADOP;
4994
4995     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_SVOP
4996         || (PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
4997         || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP);
4998
4999     NewOp(1101, padop, 1, PADOP);
5000     padop->op_type = (OPCODE)type;
5001     padop->op_ppaddr = PL_ppaddr[type];
5002     padop->op_padix = pad_alloc(type, SVs_PADTMP);
5003     SvREFCNT_dec(PAD_SVl(padop->op_padix));
5004     PAD_SETSV(padop->op_padix, sv);
5005     assert(sv);
5006     SvPADTMP_on(sv);
5007     padop->op_next = (OP*)padop;
5008     padop->op_flags = (U8)flags;
5009     if (PL_opargs[type] & OA_RETSCALAR)
5010         scalar((OP*)padop);
5011     if (PL_opargs[type] & OA_TARGET)
5012         padop->op_targ = pad_alloc(type, SVs_PADTMP);
5013     return CHECKOP(type, padop);
5014 }
5015
5016 #endif /* USE_ITHREADS */
5017
5018 /*
5019 =for apidoc Am|OP *|newGVOP|I32 type|I32 flags|GV *gv
5020
5021 Constructs, checks, and returns an op of any type that involves an
5022 embedded reference to a GV.  I<type> is the opcode.  I<flags> gives the
5023 eight bits of C<op_flags>.  I<gv> identifies the GV that the op should
5024 reference; calling this function does not transfer ownership of any
5025 reference to it.
5026
5027 =cut
5028 */
5029
5030 OP *
5031 Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
5032 {
5033     dVAR;
5034
5035     PERL_ARGS_ASSERT_NEWGVOP;
5036
5037 #ifdef USE_ITHREADS
5038     GvIN_PAD_on(gv);
5039     return newPADOP(type, flags, SvREFCNT_inc_simple_NN(gv));
5040 #else
5041     return newSVOP(type, flags, SvREFCNT_inc_simple_NN(gv));
5042 #endif
5043 }
5044
5045 /*
5046 =for apidoc Am|OP *|newPVOP|I32 type|I32 flags|char *pv
5047
5048 Constructs, checks, and returns an op of any type that involves an
5049 embedded C-level pointer (PV).  I<type> is the opcode.  I<flags> gives
5050 the eight bits of C<op_flags>.  I<pv> supplies the C-level pointer, which
5051 must have been allocated using C<PerlMemShared_malloc>; the memory will
5052 be freed when the op is destroyed.
5053
5054 =cut
5055 */
5056
5057 OP *
5058 Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
5059 {
5060     dVAR;
5061     const bool utf8 = cBOOL(flags & SVf_UTF8);
5062     PVOP *pvop;
5063
5064     flags &= ~SVf_UTF8;
5065
5066     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_PVOP_OR_SVOP
5067         || type == OP_RUNCV
5068         || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
5069
5070     NewOp(1101, pvop, 1, PVOP);
5071     pvop->op_type = (OPCODE)type;
5072     pvop->op_ppaddr = PL_ppaddr[type];
5073     pvop->op_pv = pv;
5074     pvop->op_next = (OP*)pvop;
5075     pvop->op_flags = (U8)flags;
5076     pvop->op_private = utf8 ? OPpPV_IS_UTF8 : 0;
5077     if (PL_opargs[type] & OA_RETSCALAR)
5078         scalar((OP*)pvop);
5079     if (PL_opargs[type] & OA_TARGET)
5080         pvop->op_targ = pad_alloc(type, SVs_PADTMP);
5081     return CHECKOP(type, pvop);
5082 }
5083
5084 #ifdef PERL_MAD
5085 OP*
5086 #else
5087 void
5088 #endif
5089 Perl_package(pTHX_ OP *o)
5090 {
5091     dVAR;
5092     SV *const sv = cSVOPo->op_sv;
5093 #ifdef PERL_MAD
5094     OP *pegop;
5095 #endif
5096
5097     PERL_ARGS_ASSERT_PACKAGE;
5098
5099     SAVEGENERICSV(PL_curstash);
5100     save_item(PL_curstname);
5101
5102     PL_curstash = (HV *)SvREFCNT_inc(gv_stashsv(sv, GV_ADD));
5103
5104     sv_setsv(PL_curstname, sv);
5105
5106     PL_hints |= HINT_BLOCK_SCOPE;
5107     PL_parser->copline = NOLINE;
5108     PL_parser->expect = XSTATE;
5109
5110 #ifndef PERL_MAD
5111     op_free(o);
5112 #else
5113     if (!PL_madskills) {
5114         op_free(o);
5115         return NULL;
5116     }
5117
5118     pegop = newOP(OP_NULL,0);
5119     op_getmad(o,pegop,'P');
5120     return pegop;
5121 #endif
5122 }
5123
5124 void
5125 Perl_package_version( pTHX_ OP *v )
5126 {
5127     dVAR;
5128     U32 savehints = PL_hints;
5129     PERL_ARGS_ASSERT_PACKAGE_VERSION;
5130     PL_hints &= ~HINT_STRICT_VARS;
5131     sv_setsv( GvSV(gv_fetchpvs("VERSION", GV_ADDMULTI, SVt_PV)), cSVOPx(v)->op_sv );
5132     PL_hints = savehints;
5133     op_free(v);
5134 }
5135
5136 #ifdef PERL_MAD
5137 OP*
5138 #else
5139 void
5140 #endif
5141 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
5142 {
5143     dVAR;
5144     OP *pack;
5145     OP *imop;
5146     OP *veop;
5147 #ifdef PERL_MAD
5148     OP *pegop = PL_madskills ? newOP(OP_NULL,0) : NULL;
5149 #endif
5150     SV *use_version = NULL;
5151
5152     PERL_ARGS_ASSERT_UTILIZE;
5153
5154     if (idop->op_type != OP_CONST)
5155         Perl_croak(aTHX_ "Module name must be constant");
5156
5157     if (PL_madskills)
5158         op_getmad(idop,pegop,'U');
5159
5160     veop = NULL;
5161
5162     if (version) {
5163         SV * const vesv = ((SVOP*)version)->op_sv;
5164
5165         if (PL_madskills)
5166             op_getmad(version,pegop,'V');
5167         if (!arg && !SvNIOKp(vesv)) {
5168             arg = version;
5169         }
5170         else {
5171             OP *pack;
5172             SV *meth;
5173
5174             if (version->op_type != OP_CONST || !SvNIOKp(vesv))
5175                 Perl_croak(aTHX_ "Version number must be a constant number");
5176
5177             /* Make copy of idop so we don't free it twice */
5178             pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
5179
5180             /* Fake up a method call to VERSION */
5181             meth = newSVpvs_share("VERSION");
5182             veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
5183                             op_append_elem(OP_LIST,
5184                                         op_prepend_elem(OP_LIST, pack, list(version)),
5185                                         newSVOP(OP_METHOD_NAMED, 0, meth)));
5186         }
5187     }
5188
5189     /* Fake up an import/unimport */
5190     if (arg && arg->op_type == OP_STUB) {
5191         if (PL_madskills)
5192             op_getmad(arg,pegop,'S');
5193         imop = arg;             /* no import on explicit () */
5194     }
5195     else if (SvNIOKp(((SVOP*)idop)->op_sv)) {
5196         imop = NULL;            /* use 5.0; */
5197         if (aver)
5198             use_version = ((SVOP*)idop)->op_sv;
5199         else
5200             idop->op_private |= OPpCONST_NOVER;
5201     }
5202     else {
5203         SV *meth;
5204
5205         if (PL_madskills)
5206             op_getmad(arg,pegop,'A');
5207
5208         /* Make copy of idop so we don't free it twice */
5209         pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
5210
5211         /* Fake up a method call to import/unimport */
5212         meth = aver
5213             ? newSVpvs_share("import") : newSVpvs_share("unimport");
5214         imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
5215                        op_append_elem(OP_LIST,
5216                                    op_prepend_elem(OP_LIST, pack, list(arg)),
5217                                    newSVOP(OP_METHOD_NAMED, 0, meth)));
5218     }
5219
5220     /* Fake up the BEGIN {}, which does its thing immediately. */
5221     newATTRSUB(floor,
5222         newSVOP(OP_CONST, 0, newSVpvs_share("BEGIN")),
5223         NULL,
5224         NULL,
5225         op_append_elem(OP_LINESEQ,
5226             op_append_elem(OP_LINESEQ,
5227                 newSTATEOP(0, NULL, newUNOP(OP_REQUIRE, 0, idop)),
5228                 newSTATEOP(0, NULL, veop)),
5229             newSTATEOP(0, NULL, imop) ));
5230
5231     if (use_version) {
5232         /* Enable the
5233          * feature bundle that corresponds to the required version. */
5234         use_version = sv_2mortal(new_version(use_version));
5235         S_enable_feature_bundle(aTHX_ use_version);
5236
5237         /* If a version >= 5.11.0 is requested, strictures are on by default! */
5238         if (vcmp(use_version,
5239                  sv_2mortal(upg_version(newSVnv(5.011000), FALSE))) >= 0) {
5240             if (!(PL_hints & HINT_EXPLICIT_STRICT_REFS))
5241                 PL_hints |= HINT_STRICT_REFS;
5242             if (!(PL_hints & HINT_EXPLICIT_STRICT_SUBS))
5243                 PL_hints |= HINT_STRICT_SUBS;
5244             if (!(PL_hints & HINT_EXPLICIT_STRICT_VARS))
5245                 PL_hints |= HINT_STRICT_VARS;
5246         }
5247         /* otherwise they are off */
5248         else {
5249             if (!(PL_hints & HINT_EXPLICIT_STRICT_REFS))
5250                 PL_hints &= ~HINT_STRICT_REFS;
5251             if (!(PL_hints & HINT_EXPLICIT_STRICT_SUBS))
5252                 PL_hints &= ~HINT_STRICT_SUBS;
5253             if (!(PL_hints & HINT_EXPLICIT_STRICT_VARS))
5254                 PL_hints &= ~HINT_STRICT_VARS;
5255         }
5256     }
5257
5258     /* The "did you use incorrect case?" warning used to be here.
5259      * The problem is that on case-insensitive filesystems one
5260      * might get false positives for "use" (and "require"):
5261      * "use Strict" or "require CARP" will work.  This causes
5262      * portability problems for the script: in case-strict
5263      * filesystems the script will stop working.
5264      *
5265      * The "incorrect case" warning checked whether "use Foo"
5266      * imported "Foo" to your namespace, but that is wrong, too:
5267      * there is no requirement nor promise in the language that
5268      * a Foo.pm should or would contain anything in package "Foo".
5269      *
5270      * There is very little Configure-wise that can be done, either:
5271      * the case-sensitivity of the build filesystem of Perl does not
5272      * help in guessing the case-sensitivity of the runtime environment.
5273      */
5274
5275     PL_hints |= HINT_BLOCK_SCOPE;
5276     PL_parser->copline = NOLINE;
5277     PL_parser->expect = XSTATE;
5278     PL_cop_seqmax++; /* Purely for B::*'s benefit */
5279     if (PL_cop_seqmax == PERL_PADSEQ_INTRO) /* not a legal value */
5280         PL_cop_seqmax++;
5281
5282 #ifdef PERL_MAD
5283     return pegop;
5284 #endif
5285 }
5286
5287 /*
5288 =head1 Embedding Functions
5289
5290 =for apidoc load_module
5291
5292 Loads the module whose name is pointed to by the string part of name.
5293 Note that the actual module name, not its filename, should be given.
5294 Eg, "Foo::Bar" instead of "Foo/Bar.pm".  flags can be any of
5295 PERL_LOADMOD_DENY, PERL_LOADMOD_NOIMPORT, or PERL_LOADMOD_IMPORT_OPS
5296 (or 0 for no flags). ver, if specified and not NULL, provides version semantics
5297 similar to C<use Foo::Bar VERSION>.  The optional trailing SV*
5298 arguments can be used to specify arguments to the module's import()
5299 method, similar to C<use Foo::Bar VERSION LIST>.  They must be
5300 terminated with a final NULL pointer.  Note that this list can only
5301 be omitted when the PERL_LOADMOD_NOIMPORT flag has been used.
5302 Otherwise at least a single NULL pointer to designate the default
5303 import list is required.
5304
5305 The reference count for each specified C<SV*> parameter is decremented.
5306
5307 =cut */
5308
5309 void
5310 Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...)
5311 {
5312     va_list args;
5313
5314     PERL_ARGS_ASSERT_LOAD_MODULE;
5315
5316     va_start(args, ver);
5317     vload_module(flags, name, ver, &args);
5318     va_end(args);
5319 }
5320
5321 #ifdef PERL_IMPLICIT_CONTEXT
5322 void
5323 Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
5324 {
5325     dTHX;
5326     va_list args;
5327     PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT;
5328     va_start(args, ver);
5329     vload_module(flags, name, ver, &args);
5330     va_end(args);
5331 }
5332 #endif
5333
5334 void
5335 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
5336 {
5337     dVAR;
5338     OP *veop, *imop;
5339     OP * const modname = newSVOP(OP_CONST, 0, name);
5340
5341     PERL_ARGS_ASSERT_VLOAD_MODULE;
5342
5343     modname->op_private |= OPpCONST_BARE;
5344     if (ver) {
5345         veop = newSVOP(OP_CONST, 0, ver);
5346     }
5347     else
5348         veop = NULL;
5349     if (flags & PERL_LOADMOD_NOIMPORT) {
5350         imop = sawparens(newNULLLIST());
5351     }
5352     else if (flags & PERL_LOADMOD_IMPORT_OPS) {
5353         imop = va_arg(*args, OP*);
5354     }
5355     else {
5356         SV *sv;
5357         imop = NULL;
5358         sv = va_arg(*args, SV*);
5359         while (sv) {
5360             imop = op_append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
5361             sv = va_arg(*args, SV*);
5362         }
5363     }
5364
5365     /* utilize() fakes up a BEGIN { require ..; import ... }, so make sure
5366      * that it has a PL_parser to play with while doing that, and also
5367      * that it doesn't mess with any existing parser, by creating a tmp
5368      * new parser with lex_start(). This won't actually be used for much,
5369      * since pp_require() will create another parser for the real work. */
5370
5371     ENTER;
5372     SAVEVPTR(PL_curcop);
5373     lex_start(NULL, NULL, LEX_START_SAME_FILTER);
5374     utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
5375             veop, modname, imop);
5376     LEAVE;
5377 }
5378
5379 OP *
5380 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
5381 {
5382     dVAR;
5383     OP *doop;
5384     GV *gv = NULL;
5385
5386     PERL_ARGS_ASSERT_DOFILE;
5387
5388     if (!force_builtin) {
5389         gv = gv_fetchpvs("do", GV_NOTQUAL, SVt_PVCV);
5390         if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
5391             GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "do", FALSE);
5392             gv = gvp ? *gvp : NULL;
5393         }
5394     }
5395
5396     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
5397         doop = newUNOP(OP_ENTERSUB, OPf_STACKED,
5398                                op_append_elem(OP_LIST, term,
5399                                            scalar(newUNOP(OP_RV2CV, 0,
5400                                                           newGVOP(OP_GV, 0, gv)))));
5401     }
5402     else {
5403         doop = newUNOP(OP_DOFILE, 0, scalar(term));
5404     }
5405     return doop;
5406 }
5407
5408 /*
5409 =head1 Optree construction
5410
5411 =for apidoc Am|OP *|newSLICEOP|I32 flags|OP *subscript|OP *listval
5412
5413 Constructs, checks, and returns an C<lslice> (list slice) op.  I<flags>
5414 gives the eight bits of C<op_flags>, except that C<OPf_KIDS> will
5415 be set automatically, and, shifted up eight bits, the eight bits of
5416 C<op_private>, except that the bit with value 1 or 2 is automatically
5417 set as required.  I<listval> and I<subscript> supply the parameters of
5418 the slice; they are consumed by this function and become part of the
5419 constructed op tree.
5420
5421 =cut
5422 */
5423
5424 OP *
5425 Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listval)
5426 {
5427     return newBINOP(OP_LSLICE, flags,
5428             list(force_list(subscript)),
5429             list(force_list(listval)) );
5430 }
5431
5432 STATIC I32
5433 S_is_list_assignment(pTHX_ const OP *o)
5434 {
5435     unsigned type;
5436     U8 flags;
5437
5438     if (!o)
5439         return TRUE;
5440
5441     if ((o->op_type == OP_NULL) && (o->op_flags & OPf_KIDS))
5442         o = cUNOPo->op_first;
5443
5444     flags = o->op_flags;
5445     type = o->op_type;
5446     if (type == OP_COND_EXPR) {
5447         const I32 t = is_list_assignment(cLOGOPo->op_first->op_sibling);
5448         const I32 f = is_list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
5449
5450         if (t && f)
5451             return TRUE;
5452         if (t || f)
5453             yyerror("Assignment to both a list and a scalar");
5454         return FALSE;
5455     }
5456
5457     if (type == OP_LIST &&
5458         (flags & OPf_WANT) == OPf_WANT_SCALAR &&
5459         o->op_private & OPpLVAL_INTRO)
5460         return FALSE;
5461
5462     if (type == OP_LIST || flags & OPf_PARENS ||
5463         type == OP_RV2AV || type == OP_RV2HV ||
5464         type == OP_ASLICE || type == OP_HSLICE ||
5465         type == OP_KVASLICE || type == OP_KVHSLICE)
5466         return TRUE;
5467
5468     if (type == OP_PADAV || type == OP_PADHV)
5469         return TRUE;
5470
5471     if (type == OP_RV2SV)
5472         return FALSE;
5473
5474     return FALSE;
5475 }
5476
5477 /*
5478   Helper function for newASSIGNOP to detection commonality between the
5479   lhs and the rhs.  Marks all variables with PL_generation.  If it
5480   returns TRUE the assignment must be able to handle common variables.
5481 */
5482 PERL_STATIC_INLINE bool
5483 S_aassign_common_vars(pTHX_ OP* o)
5484 {
5485     OP *curop;
5486     for (curop = cUNOPo->op_first; curop; curop=curop->op_sibling) {
5487         if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
5488             if (curop->op_type == OP_GV) {
5489                 GV *gv = cGVOPx_gv(curop);
5490                 if (gv == PL_defgv
5491                     || (int)GvASSIGN_GENERATION(gv) == PL_generation)
5492                     return TRUE;
5493                 GvASSIGN_GENERATION_set(gv, PL_generation);
5494             }
5495             else if (curop->op_type == OP_PADSV ||
5496                 curop->op_type == OP_PADAV ||
5497                 curop->op_type == OP_PADHV ||
5498                 curop->op_type == OP_PADANY)
5499                 {
5500                     if (PAD_COMPNAME_GEN(curop->op_targ)
5501                         == (STRLEN)PL_generation)
5502                         return TRUE;
5503                     PAD_COMPNAME_GEN_set(curop->op_targ, PL_generation);
5504
5505                 }
5506             else if (curop->op_type == OP_RV2CV)
5507                 return TRUE;
5508             else if (curop->op_type == OP_RV2SV ||
5509                 curop->op_type == OP_RV2AV ||
5510                 curop->op_type == OP_RV2HV ||
5511                 curop->op_type == OP_RV2GV) {
5512                 if (cUNOPx(curop)->op_first->op_type != OP_GV)  /* funny deref? */
5513                     return TRUE;
5514             }
5515             else if (curop->op_type == OP_PUSHRE) {
5516                 GV *const gv =
5517 #ifdef USE_ITHREADS
5518                     ((PMOP*)curop)->op_pmreplrootu.op_pmtargetoff
5519                         ? MUTABLE_GV(PAD_SVl(((PMOP*)curop)->op_pmreplrootu.op_pmtargetoff))
5520                         : NULL;
5521 #else
5522                     ((PMOP*)curop)->op_pmreplrootu.op_pmtargetgv;
5523 #endif
5524                 if (gv) {
5525                     if (gv == PL_defgv
5526                         || (int)GvASSIGN_GENERATION(gv) == PL_generation)
5527                         return TRUE;
5528                     GvASSIGN_GENERATION_set(gv, PL_generation);
5529                 }
5530             }
5531             else
5532                 return TRUE;
5533         }
5534
5535         if (curop->op_flags & OPf_KIDS) {
5536             if (aassign_common_vars(curop))
5537                 return TRUE;
5538         }
5539     }
5540     return FALSE;
5541 }
5542
5543 /*
5544 =for apidoc Am|OP *|newASSIGNOP|I32 flags|OP *left|I32 optype|OP *right
5545
5546 Constructs, checks, and returns an assignment op.  I<left> and I<right>
5547 supply the parameters of the assignment; they are consumed by this
5548 function and become part of the constructed op tree.
5549
5550 If I<optype> is C<OP_ANDASSIGN>, C<OP_ORASSIGN>, or C<OP_DORASSIGN>, then
5551 a suitable conditional optree is constructed.  If I<optype> is the opcode
5552 of a binary operator, such as C<OP_BIT_OR>, then an op is constructed that
5553 performs the binary operation and assigns the result to the left argument.
5554 Either way, if I<optype> is non-zero then I<flags> has no effect.
5555
5556 If I<optype> is zero, then a plain scalar or list assignment is
5557 constructed.  Which type of assignment it is is automatically determined.
5558 I<flags> gives the eight bits of C<op_flags>, except that C<OPf_KIDS>
5559 will be set automatically, and, shifted up eight bits, the eight bits
5560 of C<op_private>, except that the bit with value 1 or 2 is automatically
5561 set as required.
5562
5563 =cut
5564 */
5565
5566 OP *
5567 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
5568 {
5569     dVAR;
5570     OP *o;
5571
5572     if (optype) {
5573         if (optype == OP_ANDASSIGN || optype == OP_ORASSIGN || optype == OP_DORASSIGN) {
5574             return newLOGOP(optype, 0,
5575                 op_lvalue(scalar(left), optype),
5576                 newUNOP(OP_SASSIGN, 0, scalar(right)));
5577         }
5578         else {
5579             return newBINOP(optype, OPf_STACKED,
5580                 op_lvalue(scalar(left), optype), scalar(right));
5581         }
5582     }
5583
5584     if (is_list_assignment(left)) {
5585         static const char no_list_state[] = "Initialization of state variables"
5586             " in list context currently forbidden";
5587         OP *curop;
5588         bool maybe_common_vars = TRUE;
5589
5590         if (left->op_type == OP_ASLICE || left->op_type == OP_HSLICE)
5591             left->op_private &= ~ OPpSLICEWARNING;
5592
5593         PL_modcount = 0;
5594         left = op_lvalue(left, OP_AASSIGN);
5595         curop = list(force_list(left));
5596         o = newBINOP(OP_AASSIGN, flags, list(force_list(right)), curop);
5597         o->op_private = (U8)(0 | (flags >> 8));
5598
5599         if ((left->op_type == OP_LIST
5600              || (left->op_type == OP_NULL && left->op_targ == OP_LIST)))
5601         {
5602             OP* lop = ((LISTOP*)left)->op_first;
5603             maybe_common_vars = FALSE;
5604             while (lop) {
5605                 if (lop->op_type == OP_PADSV ||
5606                     lop->op_type == OP_PADAV ||
5607                     lop->op_type == OP_PADHV ||
5608                     lop->op_type == OP_PADANY) {
5609                     if (!(lop->op_private & OPpLVAL_INTRO))
5610                         maybe_common_vars = TRUE;
5611
5612                     if (lop->op_private & OPpPAD_STATE) {
5613                         if (left->op_private & OPpLVAL_INTRO) {
5614                             /* Each variable in state($a, $b, $c) = ... */
5615                         }
5616                         else {
5617                             /* Each state variable in
5618                                (state $a, my $b, our $c, $d, undef) = ... */
5619                         }
5620                         yyerror(no_list_state);
5621                     } else {
5622                         /* Each my variable in
5623                            (state $a, my $b, our $c, $d, undef) = ... */
5624                     }
5625                 } else if (lop->op_type == OP_UNDEF ||
5626                            lop->op_type == OP_PUSHMARK) {
5627                     /* undef may be interesting in
5628                        (state $a, undef, state $c) */
5629                 } else {
5630                     /* Other ops in the list. */
5631                     maybe_common_vars = TRUE;
5632                 }
5633                 lop = lop->op_sibling;
5634             }
5635         }
5636         else if ((left->op_private & OPpLVAL_INTRO)
5637                 && (   left->op_type == OP_PADSV
5638                     || left->op_type == OP_PADAV
5639                     || left->op_type == OP_PADHV
5640                     || left->op_type == OP_PADANY))
5641         {
5642             if (left->op_type == OP_PADSV) maybe_common_vars = FALSE;
5643             if (left->op_private & OPpPAD_STATE) {
5644                 /* All single variable list context state assignments, hence
5645                    state ($a) = ...
5646                    (state $a) = ...
5647                    state @a = ...
5648                    state (@a) = ...
5649                    (state @a) = ...
5650                    state %a = ...
5651                    state (%a) = ...
5652                    (state %a) = ...
5653                 */
5654                 yyerror(no_list_state);
5655             }
5656         }
5657
5658         /* PL_generation sorcery:
5659          * an assignment like ($a,$b) = ($c,$d) is easier than
5660          * ($a,$b) = ($c,$a), since there is no need for temporary vars.
5661          * To detect whether there are common vars, the global var
5662          * PL_generation is incremented for each assign op we compile.
5663          * Then, while compiling the assign op, we run through all the
5664          * variables on both sides of the assignment, setting a spare slot
5665          * in each of them to PL_generation. If any of them already have
5666          * that value, we know we've got commonality.  We could use a
5667          * single bit marker, but then we'd have to make 2 passes, first
5668          * to clear the flag, then to test and set it.  To find somewhere
5669          * to store these values, evil chicanery is done with SvUVX().
5670          */
5671
5672         if (maybe_common_vars) {
5673             PL_generation++;
5674             if (aassign_common_vars(o))
5675                 o->op_private |= OPpASSIGN_COMMON;
5676             LINKLIST(o);
5677         }
5678
5679         if (right && right->op_type == OP_SPLIT && !PL_madskills) {
5680             OP* tmpop = ((LISTOP*)right)->op_first;
5681             if (tmpop && (tmpop->op_type == OP_PUSHRE)) {
5682                 PMOP * const pm = (PMOP*)tmpop;
5683                 if (left->op_type == OP_RV2AV &&
5684                     !(left->op_private & OPpLVAL_INTRO) &&
5685                     !(o->op_private & OPpASSIGN_COMMON) )
5686                 {
5687                     tmpop = ((UNOP*)left)->op_first;
5688                     if (tmpop->op_type == OP_GV
5689 #ifdef USE_ITHREADS
5690                         && !pm->op_pmreplrootu.op_pmtargetoff
5691 #else
5692                         && !pm->op_pmreplrootu.op_pmtargetgv
5693 #endif
5694                         ) {
5695 #ifdef USE_ITHREADS
5696                         pm->op_pmreplrootu.op_pmtargetoff
5697                             = cPADOPx(tmpop)->op_padix;
5698                         cPADOPx(tmpop)->op_padix = 0;   /* steal it */
5699 #else
5700                         pm->op_pmreplrootu.op_pmtargetgv
5701                             = MUTABLE_GV(cSVOPx(tmpop)->op_sv);
5702                         cSVOPx(tmpop)->op_sv = NULL;    /* steal it */
5703 #endif
5704                         tmpop = cUNOPo->op_first;       /* to list (nulled) */
5705                         tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
5706                         tmpop->op_sibling = NULL;       /* don't free split */
5707                         right->op_next = tmpop->op_next;  /* fix starting loc */
5708                         op_free(o);                     /* blow off assign */
5709                         right->op_flags &= ~OPf_WANT;
5710                                 /* "I don't know and I don't care." */
5711                         return right;
5712                     }
5713                 }
5714                 else {
5715                    if (PL_modcount < RETURN_UNLIMITED_NUMBER &&
5716                       ((LISTOP*)right)->op_last->op_type == OP_CONST)
5717                     {
5718                         SV ** const svp =
5719                             &((SVOP*)((LISTOP*)right)->op_last)->op_sv;
5720                         SV * const sv = *svp;
5721                         if (SvIOK(sv) && SvIVX(sv) == 0)
5722                         {
5723                           if (right->op_private & OPpSPLIT_IMPLIM) {
5724                             /* our own SV, created in ck_split */
5725                             SvREADONLY_off(sv);
5726                             sv_setiv(sv, PL_modcount+1);
5727                           }
5728                           else {
5729                             /* SV may belong to someone else */
5730                             SvREFCNT_dec(sv);
5731                             *svp = newSViv(PL_modcount+1);
5732                           }
5733                         }
5734                     }
5735                 }
5736             }
5737         }
5738         return o;
5739     }
5740     if (!right)
5741         right = newOP(OP_UNDEF, 0);
5742     if (right->op_type == OP_READLINE) {
5743         right->op_flags |= OPf_STACKED;
5744         return newBINOP(OP_NULL, flags, op_lvalue(scalar(left), OP_SASSIGN),
5745                 scalar(right));
5746     }
5747     else {
5748         o = newBINOP(OP_SASSIGN, flags,
5749             scalar(right), op_lvalue(scalar(left), OP_SASSIGN) );
5750     }
5751     return o;
5752 }
5753
5754 /*
5755 =for apidoc Am|OP *|newSTATEOP|I32 flags|char *label|OP *o
5756
5757 Constructs a state op (COP).  The state op is normally a C<nextstate> op,
5758 but will be a C<dbstate> op if debugging is enabled for currently-compiled
5759 code.  The state op is populated from C<PL_curcop> (or C<PL_compiling>).
5760 If I<label> is non-null, it supplies the name of a label to attach to
5761 the state op; this function takes ownership of the memory pointed at by
5762 I<label>, and will free it.  I<flags> gives the eight bits of C<op_flags>
5763 for the state op.
5764
5765 If I<o> is null, the state op is returned.  Otherwise the state op is
5766 combined with I<o> into a C<lineseq> list op, which is returned.  I<o>
5767 is consumed by this function and becomes part of the returned op tree.
5768
5769 =cut
5770 */
5771
5772 OP *
5773 Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
5774 {
5775     dVAR;
5776     const U32 seq = intro_my();
5777     const U32 utf8 = flags & SVf_UTF8;
5778     COP *cop;
5779
5780     flags &= ~SVf_UTF8;
5781
5782     NewOp(1101, cop, 1, COP);
5783     if (PERLDB_LINE && CopLINE(PL_curcop) && PL_curstash != PL_debstash) {
5784         cop->op_type = OP_DBSTATE;
5785         cop->op_ppaddr = PL_ppaddr[ OP_DBSTATE ];
5786     }
5787     else {
5788         cop->op_type = OP_NEXTSTATE;
5789         cop->op_ppaddr = PL_ppaddr[ OP_NEXTSTATE ];
5790     }
5791     cop->op_flags = (U8)flags;
5792     CopHINTS_set(cop, PL_hints);
5793 #ifdef NATIVE_HINTS
5794     cop->op_private |= NATIVE_HINTS;
5795 #endif
5796     cop->op_next = (OP*)cop;
5797
5798     cop->cop_seq = seq;
5799     cop->cop_warnings = DUP_WARNINGS(PL_curcop->cop_warnings);
5800     CopHINTHASH_set(cop, cophh_copy(CopHINTHASH_get(PL_curcop)));
5801     if (label) {
5802         Perl_cop_store_label(aTHX_ cop, label, strlen(label), utf8);
5803
5804         PL_hints |= HINT_BLOCK_SCOPE;
5805         /* It seems that we need to defer freeing this pointer, as other parts
5806            of the grammar end up wanting to copy it after this op has been
5807            created. */
5808         SAVEFREEPV(label);
5809     }
5810
5811     if (PL_parser->preambling != NOLINE) {
5812         CopLINE_set(cop, PL_parser->preambling);
5813         PL_parser->copline = NOLINE;
5814     }
5815     else if (PL_parser->copline == NOLINE)
5816         CopLINE_set(cop, CopLINE(PL_curcop));
5817     else {
5818         CopLINE_set(cop, PL_parser->copline);
5819         PL_parser->copline = NOLINE;
5820     }
5821 #ifdef USE_ITHREADS
5822     CopFILE_set(cop, CopFILE(PL_curcop));       /* XXX share in a pvtable? */
5823 #else
5824     CopFILEGV_set(cop, CopFILEGV(PL_curcop));
5825 #endif
5826     CopSTASH_set(cop, PL_curstash);
5827
5828     if ((PERLDB_LINE || PERLDB_SAVESRC) && PL_curstash != PL_debstash) {
5829         /* this line can have a breakpoint - store the cop in IV */
5830         AV *av = CopFILEAVx(PL_curcop);
5831         if (av) {
5832             SV * const * const svp = av_fetch(av, CopLINE(cop), FALSE);
5833             if (svp && *svp != &PL_sv_undef ) {
5834                 (void)SvIOK_on(*svp);
5835                 SvIV_set(*svp, PTR2IV(cop));
5836             }
5837         }
5838     }
5839
5840     if (flags & OPf_SPECIAL)
5841         op_null((OP*)cop);
5842     return op_prepend_elem(OP_LINESEQ, (OP*)cop, o);
5843 }
5844
5845 /*
5846 =for apidoc Am|OP *|newLOGOP|I32 type|I32 flags|OP *first|OP *other
5847
5848 Constructs, checks, and returns a logical (flow control) op.  I<type>
5849 is the opcode.  I<flags> gives the eight bits of C<op_flags>, except
5850 that C<OPf_KIDS> will be set automatically, and, shifted up eight bits,
5851 the eight bits of C<op_private>, except that the bit with value 1 is
5852 automatically set.  I<first> supplies the expression controlling the
5853 flow, and I<other> supplies the side (alternate) chain of ops; they are
5854 consumed by this function and become part of the constructed op tree.
5855
5856 =cut
5857 */
5858
5859 OP *
5860 Perl_newLOGOP(pTHX_ I32 type, I32 flags, OP *first, OP *other)
5861 {
5862     dVAR;
5863
5864     PERL_ARGS_ASSERT_NEWLOGOP;
5865
5866     return new_logop(type, flags, &first, &other);
5867 }
5868
5869 STATIC OP *
5870 S_search_const(pTHX_ OP *o)
5871 {
5872     PERL_ARGS_ASSERT_SEARCH_CONST;
5873
5874     switch (o->op_type) {
5875         case OP_CONST:
5876             return o;
5877         case OP_NULL:
5878             if (o->op_flags & OPf_KIDS)
5879                 return search_const(cUNOPo->op_first);
5880             break;
5881         case OP_LEAVE:
5882         case OP_SCOPE:
5883         case OP_LINESEQ:
5884         {
5885             OP *kid;
5886             if (!(o->op_flags & OPf_KIDS))
5887                 return NULL;
5888             kid = cLISTOPo->op_first;
5889             do {
5890                 switch (kid->op_type) {
5891                     case OP_ENTER:
5892                     case OP_NULL:
5893                     case OP_NEXTSTATE:
5894                         kid = kid->op_sibling;
5895                         break;
5896                     default:
5897                         if (kid != cLISTOPo->op_last)
5898                             return NULL;
5899                         goto last;
5900                 }
5901             } while (kid);
5902             if (!kid)
5903                 kid = cLISTOPo->op_last;
5904 last:
5905             return search_const(kid);
5906         }
5907     }
5908
5909     return NULL;
5910 }
5911
5912 STATIC OP *
5913 S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
5914 {
5915     dVAR;
5916     LOGOP *logop;
5917     OP *o;
5918     OP *first;
5919     OP *other;
5920     OP *cstop = NULL;
5921     int prepend_not = 0;
5922
5923     PERL_ARGS_ASSERT_NEW_LOGOP;
5924
5925     first = *firstp;
5926     other = *otherp;
5927
5928     /* [perl #59802]: Warn about things like "return $a or $b", which
5929        is parsed as "(return $a) or $b" rather than "return ($a or
5930        $b)".  NB: This also applies to xor, which is why we do it
5931        here.
5932      */
5933     switch (first->op_type) {
5934     case OP_NEXT:
5935     case OP_LAST:
5936     case OP_REDO:
5937         /* XXX: Perhaps we should emit a stronger warning for these.
5938            Even with the high-precedence operator they don't seem to do
5939            anything sensible.
5940
5941            But until we do, fall through here.
5942          */
5943     case OP_RETURN:
5944     case OP_EXIT:
5945     case OP_DIE:
5946     case OP_GOTO:
5947         /* XXX: Currently we allow people to "shoot themselves in the
5948            foot" by explicitly writing "(return $a) or $b".
5949
5950            Warn unless we are looking at the result from folding or if
5951            the programmer explicitly grouped the operators like this.
5952            The former can occur with e.g.
5953
5954                 use constant FEATURE => ( $] >= ... );
5955                 sub { not FEATURE and return or do_stuff(); }
5956          */
5957         if (!first->op_folded && !(first->op_flags & OPf_PARENS))
5958             Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
5959                            "Possible precedence issue with control flow operator");
5960         /* XXX: Should we optimze this to "return $a;" (i.e. remove
5961            the "or $b" part)?
5962         */
5963         break;
5964     }
5965
5966     if (type == OP_XOR)         /* Not short circuit, but here by precedence. */
5967         return newBINOP(type, flags, scalar(first), scalar(other));
5968
5969     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LOGOP);
5970
5971     scalarboolean(first);
5972     /* optimize AND and OR ops that have NOTs as children */
5973     if (first->op_type == OP_NOT
5974         && (first->op_flags & OPf_KIDS)
5975         && ((first->op_flags & OPf_SPECIAL) /* unless ($x) { } */
5976             || (other->op_type == OP_NOT))  /* if (!$x && !$y) { } */
5977         && !PL_madskills) {
5978         if (type == OP_AND || type == OP_OR) {
5979             if (type == OP_AND)
5980                 type = OP_OR;
5981             else
5982                 type = OP_AND;
5983             op_null(first);
5984             if (other->op_type == OP_NOT) { /* !a AND|OR !b => !(a OR|AND b) */
5985                 op_null(other);
5986                 prepend_not = 1; /* prepend a NOT op later */
5987             }
5988         }
5989     }
5990     /* search for a constant op that could let us fold the test */
5991     if ((cstop = search_const(first))) {
5992         if (cstop->op_private & OPpCONST_STRICT)
5993             no_bareword_allowed(cstop);
5994         else if ((cstop->op_private & OPpCONST_BARE))
5995                 Perl_ck_warner(aTHX_ packWARN(WARN_BAREWORD), "Bareword found in conditional");
5996         if ((type == OP_AND &&  SvTRUE(((SVOP*)cstop)->op_sv)) ||
5997             (type == OP_OR  && !SvTRUE(((SVOP*)cstop)->op_sv)) ||
5998             (type == OP_DOR && !SvOK(((SVOP*)cstop)->op_sv))) {
5999             *firstp = NULL;
6000             if (other->op_type == OP_CONST)
6001                 other->op_private |= OPpCONST_SHORTCIRCUIT;
6002             if (PL_madskills) {
6003                 OP *newop = newUNOP(OP_NULL, 0, other);
6004                 op_getmad(first, newop, '1');
6005                 newop->op_targ = type;  /* set "was" field */
6006                 return newop;
6007             }
6008             op_free(first);
6009             if (other->op_type == OP_LEAVE)
6010                 other = newUNOP(OP_NULL, OPf_SPECIAL, other);
6011             else if (other->op_type == OP_MATCH
6012                   || other->op_type == OP_SUBST
6013                   || other->op_type == OP_TRANSR
6014                   || other->op_type == OP_TRANS)
6015                 /* Mark the op as being unbindable with =~ */
6016                 other->op_flags |= OPf_SPECIAL;
6017
6018             other->op_folded = 1;
6019             return other;
6020         }
6021         else {
6022             /* check for C<my $x if 0>, or C<my($x,$y) if 0> */
6023             const OP *o2 = other;
6024             if ( ! (o2->op_type == OP_LIST
6025                     && (( o2 = cUNOPx(o2)->op_first))
6026                     && o2->op_type == OP_PUSHMARK
6027                     && (( o2 = o2->op_sibling)) )
6028             )
6029                 o2 = other;
6030             if ((o2->op_type == OP_PADSV || o2->op_type == OP_PADAV
6031                         || o2->op_type == OP_PADHV)
6032                 && o2->op_private & OPpLVAL_INTRO
6033                 && !(o2->op_private & OPpPAD_STATE))
6034             {
6035                 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
6036                                  "Deprecated use of my() in false conditional");
6037             }
6038
6039             *otherp = NULL;
6040             if (cstop->op_type == OP_CONST)
6041                 cstop->op_private |= OPpCONST_SHORTCIRCUIT;
6042             if (PL_madskills) {
6043                 first = newUNOP(OP_NULL, 0, first);
6044                 op_getmad(other, first, '2');
6045                 first->op_targ = type;  /* set "was" field */
6046             }
6047             else
6048                 op_free(other);
6049             return first;
6050         }
6051     }
6052     else if ((first->op_flags & OPf_KIDS) && type != OP_DOR
6053         && ckWARN(WARN_MISC)) /* [#24076] Don't warn for <FH> err FOO. */
6054     {
6055         const OP * const k1 = ((UNOP*)first)->op_first;
6056         const OP * const k2 = k1->op_sibling;
6057         OPCODE warnop = 0;
6058         switch (first->op_type)
6059         {
6060         case OP_NULL:
6061             if (k2 && k2->op_type == OP_READLINE
6062                   && (k2->op_flags & OPf_STACKED)
6063                   && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
6064             {
6065                 warnop = k2->op_type;
6066             }
6067             break;
6068
6069         case OP_SASSIGN:
6070             if (k1->op_type == OP_READDIR
6071                   || k1->op_type == OP_GLOB
6072                   || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
6073                  || k1->op_type == OP_EACH
6074                  || k1->op_type == OP_AEACH)
6075             {
6076                 warnop = ((k1->op_type == OP_NULL)
6077                           ? (OPCODE)k1->op_targ : k1->op_type);
6078             }
6079             break;
6080         }
6081         if (warnop) {
6082             const line_t oldline = CopLINE(PL_curcop);
6083             /* This ensures that warnings are reported at the first line
6084                of the construction, not the last.  */
6085             CopLINE_set(PL_curcop, PL_parser->copline);
6086             Perl_warner(aTHX_ packWARN(WARN_MISC),
6087                  "Value of %s%s can be \"0\"; test with defined()",
6088                  PL_op_desc[warnop],
6089                  ((warnop == OP_READLINE || warnop == OP_GLOB)
6090                   ? " construct" : "() operator"));
6091             CopLINE_set(PL_curcop, oldline);
6092         }
6093     }
6094
6095     if (!other)
6096         return first;
6097
6098     if (type == OP_ANDASSIGN || type == OP_ORASSIGN || type == OP_DORASSIGN)
6099         other->op_private |= OPpASSIGN_BACKWARDS;  /* other is an OP_SASSIGN */
6100
6101     NewOp(1101, logop, 1, LOGOP);
6102
6103     logop->op_type = (OPCODE)type;
6104     logop->op_ppaddr = PL_ppaddr[type];
6105     logop->op_first = first;
6106     logop->op_flags = (U8)(flags | OPf_KIDS);
6107     logop->op_other = LINKLIST(other);
6108     logop->op_private = (U8)(1 | (flags >> 8));
6109
6110     /* establish postfix order */
6111     logop->op_next = LINKLIST(first);
6112     first->op_next = (OP*)logop;
6113     first->op_sibling = other;
6114
6115     CHECKOP(type,logop);
6116
6117     o = newUNOP(prepend_not ? OP_NOT : OP_NULL, 0, (OP*)logop);
6118     other->op_next = o;
6119
6120     return o;
6121 }
6122
6123 /*
6124 =for apidoc Am|OP *|newCONDOP|I32 flags|OP *first|OP *trueop|OP *falseop
6125
6126 Constructs, checks, and returns a conditional-expression (C<cond_expr>)
6127 op.  I<flags> gives the eight bits of C<op_flags>, except that C<OPf_KIDS>
6128 will be set automatically, and, shifted up eight bits, the eight bits of
6129 C<op_private>, except that the bit with value 1 is automatically set.
6130 I<first> supplies the expression selecting between the two branches,
6131 and I<trueop> and I<falseop> supply the branches; they are consumed by
6132 this function and become part of the constructed op tree.
6133
6134 =cut
6135 */
6136
6137 OP *
6138 Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop)
6139 {
6140     dVAR;
6141     LOGOP *logop;
6142     OP *start;
6143     OP *o;
6144     OP *cstop;
6145
6146     PERL_ARGS_ASSERT_NEWCONDOP;
6147
6148     if (!falseop)
6149         return newLOGOP(OP_AND, 0, first, trueop);
6150     if (!trueop)
6151         return newLOGOP(OP_OR, 0, first, falseop);
6152
6153     scalarboolean(first);
6154     if ((cstop = search_const(first))) {
6155         /* Left or right arm of the conditional?  */
6156         const bool left = SvTRUE(((SVOP*)cstop)->op_sv);
6157         OP *live = left ? trueop : falseop;
6158         OP *const dead = left ? falseop : trueop;
6159         if (cstop->op_private & OPpCONST_BARE &&
6160             cstop->op_private & OPpCONST_STRICT) {
6161             no_bareword_allowed(cstop);
6162         }
6163         if (PL_madskills) {
6164             /* This is all dead code when PERL_MAD is not defined.  */
6165             live = newUNOP(OP_NULL, 0, live);
6166             op_getmad(first, live, 'C');
6167             op_getmad(dead, live, left ? 'e' : 't');
6168         } else {
6169             op_free(first);
6170             op_free(dead);
6171         }
6172         if (live->op_type == OP_LEAVE)
6173             live = newUNOP(OP_NULL, OPf_SPECIAL, live);
6174         else if (live->op_type == OP_MATCH || live->op_type == OP_SUBST
6175               || live->op_type == OP_TRANS || live->op_type == OP_TRANSR)
6176             /* Mark the op as being unbindable with =~ */
6177             live->op_flags |= OPf_SPECIAL;
6178         live->op_folded = 1;
6179         return live;
6180     }
6181     NewOp(1101, logop, 1, LOGOP);
6182     logop->op_type = OP_COND_EXPR;
6183     logop->op_ppaddr = PL_ppaddr[OP_COND_EXPR];
6184     logop->op_first = first;
6185     logop->op_flags = (U8)(flags | OPf_KIDS);
6186     logop->op_private = (U8)(1 | (flags >> 8));
6187     logop->op_other = LINKLIST(trueop);
6188     logop->op_next = LINKLIST(falseop);
6189
6190     CHECKOP(OP_COND_EXPR, /* that's logop->op_type */
6191             logop);
6192
6193     /* establish postfix order */
6194     start = LINKLIST(first);
6195     first->op_next = (OP*)logop;
6196
6197     first->op_sibling = trueop;
6198     trueop->op_sibling = falseop;
6199     o = newUNOP(OP_NULL, 0, (OP*)logop);
6200
6201     trueop->op_next = falseop->op_next = o;
6202
6203     o->op_next = start;
6204     return o;
6205 }
6206
6207 /*
6208 =for apidoc Am|OP *|newRANGE|I32 flags|OP *left|OP *right
6209
6210 Constructs and returns a C<range> op, with subordinate C<flip> and
6211 C<flop> ops.  I<flags> gives the eight bits of C<op_flags> for the
6212 C<flip> op and, shifted up eight bits, the eight bits of C<op_private>
6213 for both the C<flip> and C<range> ops, except that the bit with value
6214 1 is automatically set.  I<left> and I<right> supply the expressions
6215 controlling the endpoints of the range; they are consumed by this function
6216 and become part of the constructed op tree.
6217
6218 =cut
6219 */
6220
6221 OP *
6222 Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
6223 {
6224     dVAR;
6225     LOGOP *range;
6226     OP *flip;
6227     OP *flop;
6228     OP *leftstart;
6229     OP *o;
6230
6231     PERL_ARGS_ASSERT_NEWRANGE;
6232
6233     NewOp(1101, range, 1, LOGOP);
6234
6235     range->op_type = OP_RANGE;
6236     range->op_ppaddr = PL_ppaddr[OP_RANGE];
6237     range->op_first = left;
6238     range->op_flags = OPf_KIDS;
6239     leftstart = LINKLIST(left);
6240     range->op_other = LINKLIST(right);
6241     range->op_private = (U8)(1 | (flags >> 8));
6242
6243     left->op_sibling = right;
6244
6245     range->op_next = (OP*)range;
6246     flip = newUNOP(OP_FLIP, flags, (OP*)range);
6247     flop = newUNOP(OP_FLOP, 0, flip);
6248     o = newUNOP(OP_NULL, 0, flop);
6249     LINKLIST(flop);
6250     range->op_next = leftstart;
6251
6252     left->op_next = flip;
6253     right->op_next = flop;
6254
6255     range->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
6256     sv_upgrade(PAD_SV(range->op_targ), SVt_PVNV);
6257     flip->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
6258     sv_upgrade(PAD_SV(flip->op_targ), SVt_PVNV);
6259
6260     flip->op_private =  left->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
6261     flop->op_private = right->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
6262
6263     /* check barewords before they might be optimized aways */
6264     if (flip->op_private && cSVOPx(left)->op_private & OPpCONST_STRICT)
6265         no_bareword_allowed(left);
6266     if (flop->op_private && cSVOPx(right)->op_private & OPpCONST_STRICT)
6267         no_bareword_allowed(right);
6268
6269     flip->op_next = o;
6270     if (!flip->op_private || !flop->op_private)
6271         LINKLIST(o);            /* blow off optimizer unless constant */
6272
6273     return o;
6274 }
6275
6276 /*
6277 =for apidoc Am|OP *|newLOOPOP|I32 flags|I32 debuggable|OP *expr|OP *block
6278
6279 Constructs, checks, and returns an op tree expressing a loop.  This is
6280 only a loop in the control flow through the op tree; it does not have
6281 the heavyweight loop structure that allows exiting the loop by C<last>
6282 and suchlike.  I<flags> gives the eight bits of C<op_flags> for the
6283 top-level op, except that some bits will be set automatically as required.
6284 I<expr> supplies the expression controlling loop iteration, and I<block>
6285 supplies the body of the loop; they are consumed by this function and
6286 become part of the constructed op tree.  I<debuggable> is currently
6287 unused and should always be 1.
6288
6289 =cut
6290 */
6291
6292 OP *
6293 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
6294 {
6295     dVAR;
6296     OP* listop;
6297     OP* o;
6298     const bool once = block && block->op_flags & OPf_SPECIAL &&
6299       (block->op_type == OP_ENTERSUB || block->op_type == OP_NULL);
6300
6301     PERL_UNUSED_ARG(debuggable);
6302
6303     if (expr) {
6304         if (once && expr->op_type == OP_CONST && !SvTRUE(((SVOP*)expr)->op_sv))
6305             return block;       /* do {} while 0 does once */
6306         if (expr->op_type == OP_READLINE
6307             || expr->op_type == OP_READDIR
6308             || expr->op_type == OP_GLOB
6309             || expr->op_type == OP_EACH || expr->op_type == OP_AEACH
6310             || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB)) {
6311             expr = newUNOP(OP_DEFINED, 0,
6312                 newASSIGNOP(0, newDEFSVOP(), 0, expr) );
6313         } else if (expr->op_flags & OPf_KIDS) {
6314             const OP * const k1 = ((UNOP*)expr)->op_first;
6315             const OP * const k2 = k1 ? k1->op_sibling : NULL;
6316             switch (expr->op_type) {
6317               case OP_NULL:
6318                 if (k2 && (k2->op_type == OP_READLINE || k2->op_type == OP_READDIR)
6319                       && (k2->op_flags & OPf_STACKED)
6320                       && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
6321                     expr = newUNOP(OP_DEFINED, 0, expr);
6322                 break;
6323
6324               case OP_SASSIGN:
6325                 if (k1 && (k1->op_type == OP_READDIR
6326                       || k1->op_type == OP_GLOB
6327                       || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
6328                      || k1->op_type == OP_EACH
6329                      || k1->op_type == OP_AEACH))
6330                     expr = newUNOP(OP_DEFINED, 0, expr);
6331                 break;
6332             }
6333         }
6334     }
6335
6336     /* if block is null, the next op_append_elem() would put UNSTACK, a scalar
6337      * op, in listop. This is wrong. [perl #27024] */
6338     if (!block)
6339         block = newOP(OP_NULL, 0);
6340     listop = op_append_elem(OP_LINESEQ, block, newOP(OP_UNSTACK, 0));
6341     o = new_logop(OP_AND, 0, &expr, &listop);
6342
6343     if (listop)
6344         ((LISTOP*)listop)->op_last->op_next = LINKLIST(o);
6345
6346     if (once && o != listop)
6347         o->op_next = ((LOGOP*)cUNOPo->op_first)->op_other;
6348
6349     if (o == listop)
6350         o = newUNOP(OP_NULL, 0, o);     /* or do {} while 1 loses outer block */
6351
6352     o->op_flags |= flags;
6353     o = op_scope(o);
6354     o->op_flags |= OPf_SPECIAL; /* suppress POPBLOCK curpm restoration*/
6355     return o;
6356 }
6357
6358 /*
6359 =for apidoc Am|OP *|newWHILEOP|I32 flags|I32 debuggable|LOOP *loop|OP *expr|OP *block|OP *cont|I32 has_my
6360
6361 Constructs, checks, and returns an op tree expressing a C<while> loop.
6362 This is a heavyweight loop, with structure that allows exiting the loop
6363 by C<last> and suchlike.
6364
6365 I<loop> is an optional preconstructed C<enterloop> op to use in the
6366 loop; if it is null then a suitable op will be constructed automatically.
6367 I<expr> supplies the loop's controlling expression.  I<block> supplies the
6368 main body of the loop, and I<cont> optionally supplies a C<continue> block
6369 that operates as a second half of the body.  All of these optree inputs
6370 are consumed by this function and become part of the constructed op tree.
6371
6372 I<flags> gives the eight bits of C<op_flags> for the C<leaveloop>
6373 op and, shifted up eight bits, the eight bits of C<op_private> for
6374 the C<leaveloop> op, except that (in both cases) some bits will be set
6375 automatically.  I<debuggable> is currently unused and should always be 1.
6376 I<has_my> can be supplied as true to force the
6377 loop body to be enclosed in its own scope.
6378
6379 =cut
6380 */
6381
6382 OP *
6383 Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop,
6384         OP *expr, OP *block, OP *cont, I32 has_my)
6385 {
6386     dVAR;
6387     OP *redo;
6388     OP *next = NULL;
6389     OP *listop;
6390     OP *o;
6391     U8 loopflags = 0;
6392
6393     PERL_UNUSED_ARG(debuggable);
6394
6395     if (expr) {
6396         if (expr->op_type == OP_READLINE
6397          || expr->op_type == OP_READDIR
6398          || expr->op_type == OP_GLOB
6399          || expr->op_type == OP_EACH || expr->op_type == OP_AEACH
6400                      || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB)) {
6401             expr = newUNOP(OP_DEFINED, 0,
6402                 newASSIGNOP(0, newDEFSVOP(), 0, expr) );
6403         } else if (expr->op_flags & OPf_KIDS) {
6404             const OP * const k1 = ((UNOP*)expr)->op_first;
6405             const OP * const k2 = (k1) ? k1->op_sibling : NULL;
6406             switch (expr->op_type) {
6407               case OP_NULL:
6408                 if (k2 && (k2->op_type == OP_READLINE || k2->op_type == OP_READDIR)
6409                       && (k2->op_flags & OPf_STACKED)
6410                       && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
6411                     expr = newUNOP(OP_DEFINED, 0, expr);
6412                 break;
6413
6414               case OP_SASSIGN:
6415                 if (k1 && (k1->op_type == OP_READDIR
6416                       || k1->op_type == OP_GLOB
6417                       || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
6418                      || k1->op_type == OP_EACH
6419                      || k1->op_type == OP_AEACH))
6420                     expr = newUNOP(OP_DEFINED, 0, expr);
6421                 break;
6422             }
6423         }
6424     }
6425
6426     if (!block)
6427         block = newOP(OP_NULL, 0);
6428     else if (cont || has_my) {
6429         block = op_scope(block);
6430     }
6431
6432     if (cont) {
6433         next = LINKLIST(cont);
6434     }
6435     if (expr) {
6436         OP * const unstack = newOP(OP_UNSTACK, 0);
6437         if (!next)
6438             next = unstack;
6439         cont = op_append_elem(OP_LINESEQ, cont, unstack);
6440     }
6441
6442     assert(block);
6443     listop = op_append_list(OP_LINESEQ, block, cont);
6444     assert(listop);
6445     redo = LINKLIST(listop);
6446
6447     if (expr) {
6448         scalar(listop);
6449         o = new_logop(OP_AND, 0, &expr, &listop);
6450         if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
6451             op_free((OP*)loop);
6452             return expr;                /* listop already freed by new_logop */
6453         }
6454         if (listop)
6455             ((LISTOP*)listop)->op_last->op_next =
6456                 (o == listop ? redo : LINKLIST(o));
6457     }
6458     else
6459         o = listop;
6460
6461     if (!loop) {
6462         NewOp(1101,loop,1,LOOP);
6463         loop->op_type = OP_ENTERLOOP;
6464         loop->op_ppaddr = PL_ppaddr[OP_ENTERLOOP];
6465         loop->op_private = 0;
6466         loop->op_next = (OP*)loop;
6467     }
6468
6469     o = newBINOP(OP_LEAVELOOP, 0, (OP*)loop, o);
6470
6471     loop->op_redoop = redo;
6472     loop->op_lastop = o;
6473     o->op_private |= loopflags;
6474
6475     if (next)
6476         loop->op_nextop = next;
6477     else
6478         loop->op_nextop = o;
6479
6480     o->op_flags |= flags;
6481     o->op_private |= (flags >> 8);
6482     return o;
6483 }
6484
6485 /*
6486 =for apidoc Am|OP *|newFOROP|I32 flags|OP *sv|OP *expr|OP *block|OP *cont
6487
6488 Constructs, checks, and returns an op tree expressing a C<foreach>
6489 loop (iteration through a list of values).  This is a heavyweight loop,
6490 with structure that allows exiting the loop by C<last> and suchlike.
6491
6492 I<sv> optionally supplies the variable that will be aliased to each
6493 item in turn; if null, it defaults to C<$_> (either lexical or global).
6494 I<expr> supplies the list of values to iterate over.  I<block> supplies
6495 the main body of the loop, and I<cont> optionally supplies a C<continue>
6496 block that operates as a second half of the body.  All of these optree
6497 inputs are consumed by this function and become part of the constructed
6498 op tree.
6499
6500 I<flags> gives the eight bits of C<op_flags> for the C<leaveloop>
6501 op and, shifted up eight bits, the eight bits of C<op_private> for
6502 the C<leaveloop> op, except that (in both cases) some bits will be set
6503 automatically.
6504
6505 =cut
6506 */
6507
6508 OP *
6509 Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont)
6510 {
6511     dVAR;
6512     LOOP *loop;
6513     OP *wop;
6514     PADOFFSET padoff = 0;
6515     I32 iterflags = 0;
6516     I32 iterpflags = 0;
6517     OP *madsv = NULL;
6518
6519     PERL_ARGS_ASSERT_NEWFOROP;
6520
6521     if (sv) {
6522         if (sv->op_type == OP_RV2SV) {  /* symbol table variable */
6523             iterpflags = sv->op_private & OPpOUR_INTRO; /* for our $x () */
6524             sv->op_type = OP_RV2GV;
6525             sv->op_ppaddr = PL_ppaddr[OP_RV2GV];
6526
6527             /* The op_type check is needed to prevent a possible segfault
6528              * if the loop variable is undeclared and 'strict vars' is in
6529              * effect. This is illegal but is nonetheless parsed, so we
6530              * may reach this point with an OP_CONST where we're expecting
6531              * an OP_GV.
6532              */
6533             if (cUNOPx(sv)->op_first->op_type == OP_GV
6534              && cGVOPx_gv(cUNOPx(sv)->op_first) == PL_defgv)
6535                 iterpflags |= OPpITER_DEF;
6536         }
6537         else if (sv->op_type == OP_PADSV) { /* private variable */
6538             iterpflags = sv->op_private & OPpLVAL_INTRO; /* for my $x () */
6539             padoff = sv->op_targ;
6540             if (PL_madskills)
6541                 madsv = sv;
6542             else {
6543                 sv->op_targ = 0;
6544                 op_free(sv);
6545             }
6546             sv = NULL;
6547         }
6548         else
6549             Perl_croak(aTHX_ "Can't use %s for loop variable", PL_op_desc[sv->op_type]);
6550         if (padoff) {
6551             SV *const namesv = PAD_COMPNAME_SV(padoff);
6552             STRLEN len;
6553             const char *const name = SvPV_const(namesv, len);
6554
6555             if (len == 2 && name[0] == '$' && name[1] == '_')
6556                 iterpflags |= OPpITER_DEF;
6557         }
6558     }
6559     else {
6560         const PADOFFSET offset = pad_findmy_pvs("$_", 0);
6561         if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
6562             sv = newGVOP(OP_GV, 0, PL_defgv);
6563         }
6564         else {
6565             padoff = offset;
6566         }
6567         iterpflags |= OPpITER_DEF;
6568     }
6569     if (expr->op_type == OP_RV2AV || expr->op_type == OP_PADAV) {
6570         expr = op_lvalue(force_list(scalar(ref(expr, OP_ITER))), OP_GREPSTART);
6571         iterflags |= OPf_STACKED;
6572     }
6573     else if (expr->op_type == OP_NULL &&
6574              (expr->op_flags & OPf_KIDS) &&
6575              ((BINOP*)expr)->op_first->op_type == OP_FLOP)
6576     {
6577         /* Basically turn for($x..$y) into the same as for($x,$y), but we
6578          * set the STACKED flag to indicate that these values are to be
6579          * treated as min/max values by 'pp_enteriter'.
6580          */
6581         const UNOP* const flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
6582         LOGOP* const range = (LOGOP*) flip->op_first;
6583         OP* const left  = range->op_first;
6584         OP* const right = left->op_sibling;
6585         LISTOP* listop;
6586
6587         range->op_flags &= ~OPf_KIDS;
6588         range->op_first = NULL;
6589
6590         listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
6591         listop->op_first->op_next = range->op_next;
6592         left->op_next = range->op_other;
6593         right->op_next = (OP*)listop;
6594         listop->op_next = listop->op_first;
6595
6596 #ifdef PERL_MAD
6597         op_getmad(expr,(OP*)listop,'O');
6598 #else
6599         op_free(expr);
6600 #endif
6601         expr = (OP*)(listop);
6602         op_null(expr);
6603         iterflags |= OPf_STACKED;
6604     }
6605     else {
6606         expr = op_lvalue(force_list(expr), OP_GREPSTART);
6607     }
6608
6609     loop = (LOOP*)list(convert(OP_ENTERITER, iterflags,
6610                                op_append_elem(OP_LIST, expr, scalar(sv))));
6611     assert(!loop->op_next);
6612     /* for my  $x () sets OPpLVAL_INTRO;
6613      * for our $x () sets OPpOUR_INTRO */
6614     loop->op_private = (U8)iterpflags;
6615     if (loop->op_slabbed
6616      && DIFF(loop, OpSLOT(loop)->opslot_next)
6617          < SIZE_TO_PSIZE(sizeof(LOOP)))
6618     {
6619         LOOP *tmp;
6620         NewOp(1234,tmp,1,LOOP);
6621         Copy(loop,tmp,1,LISTOP);
6622         S_op_destroy(aTHX_ (OP*)loop);
6623         loop = tmp;
6624     }
6625     else if (!loop->op_slabbed)
6626         loop = (LOOP*)PerlMemShared_realloc(loop, sizeof(LOOP));
6627     loop->op_targ = padoff;
6628     wop = newWHILEOP(flags, 1, loop, newOP(OP_ITER, 0), block, cont, 0);
6629     if (madsv)
6630         op_getmad(madsv, (OP*)loop, 'v');
6631     return wop;
6632 }
6633
6634 /*
6635 =for apidoc Am|OP *|newLOOPEX|I32 type|OP *label
6636
6637 Constructs, checks, and returns a loop-exiting op (such as C<goto>
6638 or C<last>).  I<type> is the opcode.  I<label> supplies the parameter
6639 determining the target of the op; it is consumed by this function and
6640 becomes part of the constructed op tree.
6641
6642 =cut
6643 */
6644
6645 OP*
6646 Perl_newLOOPEX(pTHX_ I32 type, OP *label)
6647 {
6648     dVAR;
6649     OP *o = NULL;
6650
6651     PERL_ARGS_ASSERT_NEWLOOPEX;
6652
6653     assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
6654
6655     if (type != OP_GOTO) {
6656         /* "last()" means "last" */
6657         if (label->op_type == OP_STUB && (label->op_flags & OPf_PARENS)) {
6658             o = newOP(type, OPf_SPECIAL);
6659         }
6660     }
6661     else {
6662         /* Check whether it's going to be a goto &function */
6663         if (label->op_type == OP_ENTERSUB
6664                 && !(label->op_flags & OPf_STACKED))
6665             label = newUNOP(OP_REFGEN, 0, op_lvalue(label, OP_REFGEN));
6666     }
6667
6668     /* Check for a constant argument */
6669     if (label->op_type == OP_CONST) {
6670             SV * const sv = ((SVOP *)label)->op_sv;
6671             STRLEN l;
6672             const char *s = SvPV_const(sv,l);
6673             if (l == strlen(s)) {
6674                 o = newPVOP(type,
6675                             SvUTF8(((SVOP*)label)->op_sv),
6676                             savesharedpv(
6677                                 SvPV_nolen_const(((SVOP*)label)->op_sv)));
6678             }
6679     }
6680
6681     /* If we have already created an op, we do not need the label. */
6682     if (o)
6683 #ifdef PERL_MAD
6684                 op_getmad(label,o,'L');
6685 #else
6686                 op_free(label);
6687 #endif
6688     else o = newUNOP(type, OPf_STACKED, label);
6689
6690     PL_hints |= HINT_BLOCK_SCOPE;
6691     return o;
6692 }
6693
6694 /* if the condition is a literal array or hash
6695    (or @{ ... } etc), make a reference to it.
6696  */
6697 STATIC OP *
6698 S_ref_array_or_hash(pTHX_ OP *cond)
6699 {
6700     if (cond
6701     && (cond->op_type == OP_RV2AV
6702     ||  cond->op_type == OP_PADAV
6703     ||  cond->op_type == OP_RV2HV
6704     ||  cond->op_type == OP_PADHV))
6705
6706         return newUNOP(OP_REFGEN, 0, op_lvalue(cond, OP_REFGEN));
6707
6708     else if(cond
6709     && (cond->op_type == OP_ASLICE
6710     ||  cond->op_type == OP_KVASLICE
6711     ||  cond->op_type == OP_HSLICE
6712     ||  cond->op_type == OP_KVHSLICE)) {
6713
6714         /* anonlist now needs a list from this op, was previously used in
6715          * scalar context */
6716         cond->op_flags |= ~(OPf_WANT_SCALAR | OPf_REF);
6717         cond->op_flags |= OPf_WANT_LIST;
6718
6719         return newANONLIST(op_lvalue(cond, OP_ANONLIST));
6720     }
6721
6722     else
6723         return cond;
6724 }
6725
6726 /* These construct the optree fragments representing given()
6727    and when() blocks.
6728
6729    entergiven and enterwhen are LOGOPs; the op_other pointer
6730    points up to the associated leave op. We need this so we
6731    can put it in the context and make break/continue work.
6732    (Also, of course, pp_enterwhen will jump straight to
6733    op_other if the match fails.)
6734  */
6735
6736 STATIC OP *
6737 S_newGIVWHENOP(pTHX_ OP *cond, OP *block,
6738                    I32 enter_opcode, I32 leave_opcode,
6739                    PADOFFSET entertarg)
6740 {
6741     dVAR;
6742     LOGOP *enterop;
6743     OP *o;
6744
6745     PERL_ARGS_ASSERT_NEWGIVWHENOP;
6746
6747     NewOp(1101, enterop, 1, LOGOP);
6748     enterop->op_type = (Optype)enter_opcode;
6749     enterop->op_ppaddr = PL_ppaddr[enter_opcode];
6750     enterop->op_flags =  (U8) OPf_KIDS;
6751     enterop->op_targ = ((entertarg == NOT_IN_PAD) ? 0 : entertarg);
6752     enterop->op_private = 0;
6753
6754     o = newUNOP(leave_opcode, 0, (OP *) enterop);
6755
6756     if (cond) {
6757         enterop->op_first = scalar(cond);
6758         cond->op_sibling = block;
6759
6760         o->op_next = LINKLIST(cond);
6761         cond->op_next = (OP *) enterop;
6762     }
6763     else {
6764         /* This is a default {} block */
6765         enterop->op_first = block;
6766         enterop->op_flags |= OPf_SPECIAL;
6767         o      ->op_flags |= OPf_SPECIAL;
6768
6769         o->op_next = (OP *) enterop;
6770     }
6771
6772     CHECKOP(enter_opcode, enterop); /* Currently does nothing, since
6773                                        entergiven and enterwhen both
6774                                        use ck_null() */
6775
6776     enterop->op_next = LINKLIST(block);
6777     block->op_next = enterop->op_other = o;
6778
6779     return o;
6780 }
6781
6782 /* Does this look like a boolean operation? For these purposes
6783    a boolean operation is:
6784      - a subroutine call [*]
6785      - a logical connective
6786      - a comparison operator
6787      - a filetest operator, with the exception of -s -M -A -C
6788      - defined(), exists() or eof()
6789      - /$re/ or $foo =~ /$re/
6790
6791    [*] possibly surprising
6792  */
6793 STATIC bool
6794 S_looks_like_bool(pTHX_ const OP *o)
6795 {
6796     dVAR;
6797
6798     PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL;
6799
6800     switch(o->op_type) {
6801         case OP_OR:
6802         case OP_DOR:
6803             return looks_like_bool(cLOGOPo->op_first);
6804
6805         case OP_AND:
6806             return (
6807                 looks_like_bool(cLOGOPo->op_first)
6808              && looks_like_bool(cLOGOPo->op_first->op_sibling));
6809
6810         case OP_NULL:
6811         case OP_SCALAR:
6812             return (
6813                 o->op_flags & OPf_KIDS
6814             && looks_like_bool(cUNOPo->op_first));
6815
6816         case OP_ENTERSUB:
6817
6818         case OP_NOT:    case OP_XOR:
6819
6820         case OP_EQ:     case OP_NE:     case OP_LT:
6821         case OP_GT:     case OP_LE:     case OP_GE:
6822
6823         case OP_I_EQ:   case OP_I_NE:   case OP_I_LT:
6824         case OP_I_GT:   case OP_I_LE:   case OP_I_GE:
6825
6826         case OP_SEQ:    case OP_SNE:    case OP_SLT:
6827         case OP_SGT:    case OP_SLE:    case OP_SGE:
6828
6829         case OP_SMARTMATCH:
6830
6831         case OP_FTRREAD:  case OP_FTRWRITE: case OP_FTREXEC:
6832         case OP_FTEREAD:  case OP_FTEWRITE: case OP_FTEEXEC:
6833         case OP_FTIS:     case OP_FTEOWNED: case OP_FTROWNED:
6834         case OP_FTZERO:   case OP_FTSOCK:   case OP_FTCHR:
6835         case OP_FTBLK:    case OP_FTFILE:   case OP_FTDIR:
6836         case OP_FTPIPE:   case OP_FTLINK:   case OP_FTSUID:
6837         case OP_FTSGID:   case OP_FTSVTX:   case OP_FTTTY:
6838         case OP_FTTEXT:   case OP_FTBINARY:
6839
6840         case OP_DEFINED: case OP_EXISTS:
6841         case OP_MATCH:   case OP_EOF:
6842
6843         case OP_FLOP:
6844
6845             return TRUE;
6846
6847         case OP_CONST:
6848             /* Detect comparisons that have been optimized away */
6849             if (cSVOPo->op_sv == &PL_sv_yes
6850             ||  cSVOPo->op_sv == &PL_sv_no)
6851
6852                 return TRUE;
6853             else
6854                 return FALSE;
6855
6856         /* FALL THROUGH */
6857         default:
6858             return FALSE;
6859     }
6860 }
6861
6862 /*
6863 =for apidoc Am|OP *|newGIVENOP|OP *cond|OP *block|PADOFFSET defsv_off
6864
6865 Constructs, checks, and returns an op tree expressing a C<given> block.
6866 I<cond> supplies the expression that will be locally assigned to a lexical
6867 variable, and I<block> supplies the body of the C<given> construct; they
6868 are consumed by this function and become part of the constructed op tree.
6869 I<defsv_off> is the pad offset of the scalar lexical variable that will
6870 be affected.  If it is 0, the global $_ will be used.
6871
6872 =cut
6873 */
6874
6875 OP *
6876 Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off)
6877 {
6878     dVAR;
6879     PERL_ARGS_ASSERT_NEWGIVENOP;
6880     return newGIVWHENOP(
6881         ref_array_or_hash(cond),
6882         block,
6883         OP_ENTERGIVEN, OP_LEAVEGIVEN,
6884         defsv_off);
6885 }
6886
6887 /*
6888 =for apidoc Am|OP *|newWHENOP|OP *cond|OP *block
6889
6890 Constructs, checks, and returns an op tree expressing a C<when> block.
6891 I<cond> supplies the test expression, and I<block> supplies the block
6892 that will be executed if the test evaluates to true; they are consumed
6893 by this function and become part of the constructed op tree.  I<cond>
6894 will be interpreted DWIMically, often as a comparison against C<$_>,
6895 and may be null to generate a C<default> block.
6896
6897 =cut
6898 */
6899
6900 OP *
6901 Perl_newWHENOP(pTHX_ OP *cond, OP *block)
6902 {
6903     const bool cond_llb = (!cond || looks_like_bool(cond));
6904     OP *cond_op;
6905
6906     PERL_ARGS_ASSERT_NEWWHENOP;
6907
6908     if (cond_llb)
6909         cond_op = cond;
6910     else {
6911         cond_op = newBINOP(OP_SMARTMATCH, OPf_SPECIAL,
6912                 newDEFSVOP(),
6913                 scalar(ref_array_or_hash(cond)));
6914     }
6915
6916     return newGIVWHENOP(cond_op, block, OP_ENTERWHEN, OP_LEAVEWHEN, 0);
6917 }
6918
6919 void
6920 Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p,
6921                     const STRLEN len, const U32 flags)
6922 {
6923     SV *name = NULL, *msg;
6924     const char * cvp = SvROK(cv) ? "" : CvPROTO(cv);
6925     STRLEN clen = CvPROTOLEN(cv), plen = len;
6926
6927     PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS;
6928
6929     if (p == NULL && cvp == NULL)
6930         return;
6931
6932     if (!ckWARN_d(WARN_PROTOTYPE))
6933         return;
6934
6935     if (p && cvp) {
6936         p = S_strip_spaces(aTHX_ p, &plen);
6937         cvp = S_strip_spaces(aTHX_ cvp, &clen);
6938         if ((flags & SVf_UTF8) == SvUTF8(cv)) {
6939             if (plen == clen && memEQ(cvp, p, plen))
6940                 return;
6941         } else {
6942             if (flags & SVf_UTF8) {
6943                 if (bytes_cmp_utf8((const U8 *)cvp, clen, (const U8 *)p, plen) == 0)
6944                     return;
6945             }
6946             else {
6947                 if (bytes_cmp_utf8((const U8 *)p, plen, (const U8 *)cvp, clen) == 0)
6948                     return;
6949             }
6950         }
6951     }
6952
6953     msg = sv_newmortal();
6954
6955     if (gv)
6956     {
6957         if (isGV(gv))
6958             gv_efullname3(name = sv_newmortal(), gv, NULL);
6959         else if (SvPOK(gv) && *SvPVX((SV *)gv) == '&')
6960             name = newSVpvn_flags(SvPVX((SV *)gv)+1, SvCUR(gv)-1, SvUTF8(gv)|SVs_TEMP);
6961         else name = (SV *)gv;
6962     }
6963     sv_setpvs(msg, "Prototype mismatch:");
6964     if (name)
6965         Perl_sv_catpvf(aTHX_ msg, " sub %"SVf, SVfARG(name));
6966     if (cvp)
6967         Perl_sv_catpvf(aTHX_ msg, " (%"UTF8f")",
6968             UTF8fARG(SvUTF8(cv),clen,cvp)
6969         );
6970     else
6971         sv_catpvs(msg, ": none");
6972     sv_catpvs(msg, " vs ");
6973     if (p)
6974         Perl_sv_catpvf(aTHX_ msg, "(%"UTF8f")", UTF8fARG(flags & SVf_UTF8,len,p));
6975     else
6976         sv_catpvs(msg, "none");
6977     Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE), "%"SVf, SVfARG(msg));
6978 }
6979
6980 static void const_sv_xsub(pTHX_ CV* cv);
6981 static void const_av_xsub(pTHX_ CV* cv);
6982
6983 /*
6984
6985 =head1 Optree Manipulation Functions
6986
6987 =for apidoc cv_const_sv
6988
6989 If C<cv> is a constant sub eligible for inlining. returns the constant
6990 value returned by the sub.  Otherwise, returns NULL.
6991
6992 Constant subs can be created with C<newCONSTSUB> or as described in
6993 L<perlsub/"Constant Functions">.
6994
6995 =cut
6996 */
6997 SV *
6998 Perl_cv_const_sv(pTHX_ const CV *const cv)
6999 {
7000     SV *sv;
7001     PERL_UNUSED_CONTEXT;
7002     if (!cv)
7003         return NULL;
7004     if (!(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM))
7005         return NULL;
7006     sv = CvCONST(cv) ? MUTABLE_SV(CvXSUBANY(cv).any_ptr) : NULL;
7007     if (sv && SvTYPE(sv) == SVt_PVAV) return NULL;
7008     return sv;
7009 }
7010
7011 SV *
7012 Perl_cv_const_sv_or_av(pTHX_ const CV * const cv)
7013 {
7014     PERL_UNUSED_CONTEXT;
7015     if (!cv)
7016         return NULL;
7017     assert (SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM);
7018     return CvCONST(cv) ? MUTABLE_SV(CvXSUBANY(cv).any_ptr) : NULL;
7019 }
7020
7021 /* op_const_sv:  examine an optree to determine whether it's in-lineable.
7022  */
7023
7024 SV *
7025 Perl_op_const_sv(pTHX_ const OP *o)
7026 {
7027     dVAR;
7028     SV *sv = NULL;
7029
7030     if (PL_madskills)
7031         return NULL;
7032
7033     if (!o)
7034         return NULL;
7035
7036     if (o->op_type == OP_LINESEQ && cLISTOPo->op_first)
7037         o = cLISTOPo->op_first->op_sibling;
7038
7039     for (; o; o = o->op_next) {
7040         const OPCODE type = o->op_type;
7041
7042         if (sv && o->op_next == o)
7043             return sv;
7044         if (o->op_next != o) {
7045             if (type == OP_NEXTSTATE
7046              || (type == OP_NULL && !(o->op_flags & OPf_KIDS))
7047              || type == OP_PUSHMARK)
7048                 continue;
7049             if (type == OP_DBSTATE)
7050                 continue;
7051         }
7052         if (type == OP_LEAVESUB || type == OP_RETURN)
7053             break;
7054         if (sv)
7055             return NULL;
7056         if (type == OP_CONST && cSVOPo->op_sv)
7057             sv = cSVOPo->op_sv;
7058         else {
7059             return NULL;
7060         }
7061     }
7062     return sv;
7063 }
7064
7065 static bool
7066 S_already_defined(pTHX_ CV *const cv, OP * const block, OP * const o,
7067                         PADNAME * const name, SV ** const const_svp)
7068 {
7069     assert (cv);
7070     assert (o || name);
7071     assert (const_svp);
7072     if ((!block
7073 #ifdef PERL_MAD
7074          || block->op_type == OP_NULL
7075 #endif
7076          )) {
7077         if (CvFLAGS(PL_compcv)) {
7078             /* might have had built-in attrs applied */
7079             const bool pureperl = !CvISXSUB(cv) && CvROOT(cv);
7080             if (CvLVALUE(PL_compcv) && ! CvLVALUE(cv) && pureperl
7081              && ckWARN(WARN_MISC))
7082             {
7083                 /* protect against fatal warnings leaking compcv */
7084                 SAVEFREESV(PL_compcv);
7085                 Perl_warner(aTHX_ packWARN(WARN_MISC), "lvalue attribute ignored after the subroutine has been defined");
7086                 SvREFCNT_inc_simple_void_NN(PL_compcv);
7087             }
7088             CvFLAGS(cv) |=
7089                 (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS
7090                   & ~(CVf_LVALUE * pureperl));
7091         }
7092         return FALSE;
7093     }
7094
7095     /* redundant check for speed: */
7096     if (CvCONST(cv) || ckWARN(WARN_REDEFINE)) {
7097         const line_t oldline = CopLINE(PL_curcop);
7098         SV *namesv = o
7099             ? cSVOPo->op_sv
7100             : sv_2mortal(newSVpvn_utf8(
7101                 PadnamePV(name)+1,PadnameLEN(name)-1, PadnameUTF8(name)
7102               ));
7103         if (PL_parser && PL_parser->copline != NOLINE)
7104             /* This ensures that warnings are reported at the first
7105                line of a redefinition, not the last.  */
7106             CopLINE_set(PL_curcop, PL_parser->copline);
7107         /* protect against fatal warnings leaking compcv */
7108         SAVEFREESV(PL_compcv);
7109         report_redefined_cv(namesv, cv, const_svp);
7110         SvREFCNT_inc_simple_void_NN(PL_compcv);
7111         CopLINE_set(PL_curcop, oldline);
7112     }
7113 #ifdef PERL_MAD
7114     if (!PL_minus_c)    /* keep old one around for madskills */
7115 #endif
7116     {
7117         /* (PL_madskills unset in used file.) */
7118         SvREFCNT_dec(cv);
7119     }
7120     return TRUE;
7121 }
7122
7123 CV *
7124 Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
7125 {
7126     dVAR;
7127     CV **spot;
7128     SV **svspot;
7129     const char *ps;
7130     STRLEN ps_len = 0; /* init it to avoid false uninit warning from icc */
7131     U32 ps_utf8 = 0;
7132     CV *cv = NULL;
7133     CV *compcv = PL_compcv;
7134     SV *const_sv;
7135     PADNAME *name;
7136     PADOFFSET pax = o->op_targ;
7137     CV *outcv = CvOUTSIDE(PL_compcv);
7138     CV *clonee = NULL;
7139     HEK *hek = NULL;
7140     bool reusable = FALSE;
7141
7142     PERL_ARGS_ASSERT_NEWMYSUB;
7143
7144     /* Find the pad slot for storing the new sub.
7145        We cannot use PL_comppad, as it is the pad owned by the new sub.  We
7146        need to look in CvOUTSIDE and find the pad belonging to the enclos-
7147        ing sub.  And then we need to dig deeper if this is a lexical from
7148        outside, as in:
7149            my sub foo; sub { sub foo { } }
7150      */
7151    redo:
7152     name = PadlistNAMESARRAY(CvPADLIST(outcv))[pax];
7153     if (PadnameOUTER(name) && PARENT_PAD_INDEX(name)) {
7154         pax = PARENT_PAD_INDEX(name);
7155         outcv = CvOUTSIDE(outcv);
7156         assert(outcv);
7157         goto redo;
7158     }
7159     svspot =
7160         &PadARRAY(PadlistARRAY(CvPADLIST(outcv))
7161                         [CvDEPTH(outcv) ? CvDEPTH(outcv) : 1])[pax];
7162     spot = (CV **)svspot;
7163
7164     if (proto) {
7165         assert(proto->op_type == OP_CONST);
7166         ps = SvPV_const(((SVOP*)proto)->op_sv, ps_len);
7167         ps_utf8 = SvUTF8(((SVOP*)proto)->op_sv);
7168     }
7169     else
7170         ps = NULL;
7171
7172     if (!PL_madskills) {
7173         if (proto)
7174             SAVEFREEOP(proto);
7175         if (attrs)
7176             SAVEFREEOP(attrs);
7177     }
7178
7179     if (PL_parser && PL_parser->error_count) {
7180         op_free(block);
7181         SvREFCNT_dec(PL_compcv);
7182         PL_compcv = 0;
7183         goto done;
7184     }
7185
7186     if (CvDEPTH(outcv) && CvCLONE(compcv)) {
7187         cv = *spot;
7188         svspot = (SV **)(spot = &clonee);
7189     }
7190     else if (PadnameIsSTATE(name) || CvDEPTH(outcv))
7191         cv = *spot;
7192     else {
7193         MAGIC *mg;
7194         SvUPGRADE(name, SVt_PVMG);
7195         mg = mg_find(name, PERL_MAGIC_proto);
7196         assert (SvTYPE(*spot) == SVt_PVCV);
7197         if (CvNAMED(*spot))
7198             hek = CvNAME_HEK(*spot);
7199         else {
7200             CvNAME_HEK_set(*spot, hek =
7201                 share_hek(
7202                     PadnamePV(name)+1,
7203                     PadnameLEN(name)-1 * (PadnameUTF8(name) ? -1 : 1), 0
7204                 )
7205             );
7206         }
7207         if (mg) {
7208             assert(mg->mg_obj);
7209             cv = (CV *)mg->mg_obj;
7210         }
7211         else {
7212             sv_magic(name, &PL_sv_undef, PERL_MAGIC_proto, NULL, 0);
7213             mg = mg_find(name, PERL_MAGIC_proto);
7214         }
7215         spot = (CV **)(svspot = &mg->mg_obj);
7216     }
7217
7218     if (!block || !ps || *ps || attrs
7219         || (CvFLAGS(compcv) & CVf_BUILTIN_ATTRS)
7220 #ifdef PERL_MAD
7221         || block->op_type == OP_NULL
7222 #endif
7223         )
7224         const_sv = NULL;
7225     else
7226         const_sv = op_const_sv(block);
7227
7228     if (cv) {
7229         const bool exists = CvROOT(cv) || CvXSUB(cv);
7230
7231         /* if the subroutine doesn't exist and wasn't pre-declared
7232          * with a prototype, assume it will be AUTOLOADed,
7233          * skipping the prototype check
7234          */
7235         if (exists || SvPOK(cv))
7236             cv_ckproto_len_flags(cv, (GV *)name, ps, ps_len, ps_utf8);
7237         /* already defined? */
7238         if (exists) {
7239             if (S_already_defined(aTHX_ cv, block, NULL, name, &const_sv))
7240                 cv = NULL;
7241             else {
7242                 if (attrs) goto attrs;
7243                 /* just a "sub foo;" when &foo is already defined */
7244                 SAVEFREESV(compcv);
7245                 goto done;
7246             }
7247         }
7248         else if (CvDEPTH(outcv) && CvCLONE(compcv)) {
7249             cv = NULL;
7250             reusable = TRUE;
7251         }
7252     }
7253     if (const_sv) {
7254         SvREFCNT_inc_simple_void_NN(const_sv);
7255         SvFLAGS(const_sv) = (SvFLAGS(const_sv) & ~SVs_PADMY) | SVs_PADTMP;
7256         if (cv) {
7257             assert(!CvROOT(cv) && !CvCONST(cv));
7258             cv_forget_slab(cv);
7259         }
7260         else {
7261             cv = MUTABLE_CV(newSV_type(SVt_PVCV));
7262             CvFILE_set_from_cop(cv, PL_curcop);
7263             CvSTASH_set(cv, PL_curstash);
7264             *spot = cv;
7265         }
7266         sv_setpvs(MUTABLE_SV(cv), "");  /* prototype is "" */
7267         CvXSUBANY(cv).any_ptr = const_sv;
7268         CvXSUB(cv) = const_sv_xsub;
7269         CvCONST_on(cv);
7270         CvISXSUB_on(cv);
7271         if (PL_madskills)
7272             goto install_block;
7273         op_free(block);
7274         SvREFCNT_dec(compcv);
7275         PL_compcv = NULL;
7276         goto setname;
7277     }
7278     /* Checking whether outcv is CvOUTSIDE(compcv) is not sufficient to
7279        determine whether this sub definition is in the same scope as its
7280        declaration.  If this sub definition is inside an inner named pack-
7281        age sub (my sub foo; sub bar { sub foo { ... } }), outcv points to
7282        the package sub.  So check PadnameOUTER(name) too.
7283      */
7284     if (outcv == CvOUTSIDE(compcv) && !PadnameOUTER(name)) {
7285         assert(!CvWEAKOUTSIDE(compcv));
7286         SvREFCNT_dec(CvOUTSIDE(compcv));
7287         CvWEAKOUTSIDE_on(compcv);
7288     }
7289     /* XXX else do we have a circular reference? */
7290     if (cv) {   /* must reuse cv in case stub is referenced elsewhere */
7291         /* transfer PL_compcv to cv */
7292         if (block
7293 #ifdef PERL_MAD
7294                   && block->op_type != OP_NULL
7295 #endif
7296         ) {
7297             cv_flags_t preserved_flags =
7298                 CvFLAGS(cv) & (CVf_BUILTIN_ATTRS|CVf_NAMED);
7299             PADLIST *const temp_padl = CvPADLIST(cv);
7300             CV *const temp_cv = CvOUTSIDE(cv);
7301             const cv_flags_t other_flags =
7302                 CvFLAGS(cv) & (CVf_SLABBED|CVf_WEAKOUTSIDE);
7303             OP * const cvstart = CvSTART(cv);
7304
7305             SvPOK_off(cv);
7306             CvFLAGS(cv) =
7307                 CvFLAGS(compcv) | preserved_flags;
7308             CvOUTSIDE(cv) = CvOUTSIDE(compcv);
7309             CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(compcv);
7310             CvPADLIST(cv) = CvPADLIST(compcv);
7311             CvOUTSIDE(compcv) = temp_cv;
7312             CvPADLIST(compcv) = temp_padl;
7313             CvSTART(cv) = CvSTART(compcv);
7314             CvSTART(compcv) = cvstart;
7315             CvFLAGS(compcv) &= ~(CVf_SLABBED|CVf_WEAKOUTSIDE);
7316             CvFLAGS(compcv) |= other_flags;
7317
7318             if (CvFILE(cv) && CvDYNFILE(cv)) {
7319                 Safefree(CvFILE(cv));
7320             }
7321
7322             /* inner references to compcv must be fixed up ... */
7323             pad_fixup_inner_anons(CvPADLIST(cv), compcv, cv);
7324             if (PERLDB_INTER)/* Advice debugger on the new sub. */
7325               ++PL_sub_generation;
7326         }
7327         else {
7328             /* Might have had built-in attributes applied -- propagate them. */
7329             CvFLAGS(cv) |= (CvFLAGS(compcv) & CVf_BUILTIN_ATTRS);
7330         }
7331         /* ... before we throw it away */
7332         SvREFCNT_dec(compcv);
7333         PL_compcv = compcv = cv;
7334     }
7335     else {
7336         cv = compcv;
7337         *spot = cv;
7338     }
7339    setname:
7340     if (!CvNAME_HEK(cv)) {
7341         CvNAME_HEK_set(cv,
7342          hek
7343           ? share_hek_hek(hek)
7344           : share_hek(PadnamePV(name)+1,
7345                       PadnameLEN(name)-1 * (PadnameUTF8(name) ? -1 : 1),
7346                       0)
7347         );
7348     }
7349     if (const_sv) goto clone;
7350
7351     CvFILE_set_from_cop(cv, PL_curcop);
7352     CvSTASH_set(cv, PL_curstash);
7353
7354     if (ps) {
7355         sv_setpvn(MUTABLE_SV(cv), ps, ps_len);
7356         if ( ps_utf8 ) SvUTF8_on(MUTABLE_SV(cv));
7357     }
7358
7359  install_block:
7360     if (!block)
7361         goto attrs;
7362
7363     /* If we assign an optree to a PVCV, then we've defined a subroutine that
7364        the debugger could be able to set a breakpoint in, so signal to
7365        pp_entereval that it should not throw away any saved lines at scope
7366        exit.  */
7367
7368     PL_breakable_sub_gen++;
7369     /* This makes sub {}; work as expected.  */
7370     if (block->op_type == OP_STUB) {
7371             OP* const newblock = newSTATEOP(0, NULL, 0);
7372 #ifdef PERL_MAD
7373             op_getmad(block,newblock,'B');
7374 #else
7375             op_free(block);
7376 #endif
7377             block = newblock;
7378     }
7379     CvROOT(cv) = CvLVALUE(cv)
7380                    ? newUNOP(OP_LEAVESUBLV, 0,
7381                              op_lvalue(scalarseq(block), OP_LEAVESUBLV))
7382                    : newUNOP(OP_LEAVESUB, 0, scalarseq(block));
7383     CvROOT(cv)->op_private |= OPpREFCOUNTED;
7384     OpREFCNT_set(CvROOT(cv), 1);
7385     /* The cv no longer needs to hold a refcount on the slab, as CvROOT
7386        itself has a refcount. */
7387     CvSLABBED_off(cv);
7388     OpslabREFCNT_dec_padok((OPSLAB *)CvSTART(cv));
7389     CvSTART(cv) = LINKLIST(CvROOT(cv));
7390     CvROOT(cv)->op_next = 0;
7391     CALL_PEEP(CvSTART(cv));
7392     finalize_optree(CvROOT(cv));
7393
7394     /* now that optimizer has done its work, adjust pad values */
7395
7396     pad_tidy(CvCLONE(cv) ? padtidy_SUBCLONE : padtidy_SUB);
7397
7398   attrs:
7399     if (attrs) {
7400         /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>. */
7401         apply_attrs(PL_curstash, MUTABLE_SV(cv), attrs);
7402     }
7403
7404     if (block) {
7405         if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
7406             SV * const tmpstr = sv_newmortal();
7407             GV * const db_postponed = gv_fetchpvs("DB::postponed",
7408                                                   GV_ADDMULTI, SVt_PVHV);
7409             HV *hv;
7410             SV * const sv = Perl_newSVpvf(aTHX_ "%s:%ld-%ld",
7411                                           CopFILE(PL_curcop),
7412                                           (long)PL_subline,
7413                                           (long)CopLINE(PL_curcop));
7414             if (HvNAME_HEK(PL_curstash)) {
7415                 sv_sethek(tmpstr, HvNAME_HEK(PL_curstash));
7416                 sv_catpvs(tmpstr, "::");
7417             }
7418             else sv_setpvs(tmpstr, "__ANON__::");
7419             sv_catpvn_flags(tmpstr, PadnamePV(name)+1, PadnameLEN(name)-1,
7420                             PadnameUTF8(name) ? SV_CATUTF8 : SV_CATBYTES);
7421             (void)hv_store(GvHV(PL_DBsub), SvPVX_const(tmpstr),
7422                     SvUTF8(tmpstr) ? -(I32)SvCUR(tmpstr) : (I32)SvCUR(tmpstr), sv, 0);
7423             hv = GvHVn(db_postponed);
7424             if (HvTOTALKEYS(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvUTF8(tmpstr) ? -(I32)SvCUR(tmpstr) : (I32)SvCUR(tmpstr))) {
7425                 CV * const pcv = GvCV(db_postponed);
7426                 if (pcv) {
7427                     dSP;
7428                     PUSHMARK(SP);
7429                     XPUSHs(tmpstr);
7430                     PUTBACK;
7431                     call_sv(MUTABLE_SV(pcv), G_DISCARD);
7432                 }
7433             }
7434         }
7435     }
7436
7437   clone:
7438     if (clonee) {
7439         assert(CvDEPTH(outcv));
7440         spot = (CV **)
7441             &PadARRAY(PadlistARRAY(CvPADLIST(outcv))[CvDEPTH(outcv)])[pax];
7442         if (reusable) cv_clone_into(clonee, *spot);
7443         else *spot = cv_clone(clonee);
7444         SvREFCNT_dec_NN(clonee);
7445         cv = *spot;
7446         SvPADMY_on(cv);
7447     }
7448     if (CvDEPTH(outcv) && !reusable && PadnameIsSTATE(name)) {
7449         PADOFFSET depth = CvDEPTH(outcv);
7450         while (--depth) {
7451             SV *oldcv;
7452             svspot = &PadARRAY(PadlistARRAY(CvPADLIST(outcv))[depth])[pax];
7453             oldcv = *svspot;
7454             *svspot = SvREFCNT_inc_simple_NN(cv);
7455             SvREFCNT_dec(oldcv);
7456         }
7457     }
7458
7459   done:
7460     if (PL_parser)
7461         PL_parser->copline = NOLINE;
7462     LEAVE_SCOPE(floor);
7463     if (o) op_free(o);
7464     return cv;
7465 }
7466
7467 CV *
7468 Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
7469 {
7470     return newATTRSUB_flags(floor, o, proto, attrs, block, 0);
7471 }
7472
7473 CV *
7474 Perl_newATTRSUB_flags(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs,
7475                             OP *block, U32 flags)
7476 {
7477     dVAR;
7478     GV *gv;
7479     const char *ps;
7480     STRLEN ps_len = 0; /* init it to avoid false uninit warning from icc */
7481     U32 ps_utf8 = 0;
7482     CV *cv = NULL;
7483     SV *const_sv;
7484     const bool ec = PL_parser && PL_parser->error_count;
7485     /* If the subroutine has no body, no attributes, and no builtin attributes
7486        then it's just a sub declaration, and we may be able to get away with
7487        storing with a placeholder scalar in the symbol table, rather than a
7488        full GV and CV.  If anything is present then it will take a full CV to
7489        store it.  */
7490     const I32 gv_fetch_flags
7491         = ec ? GV_NOADD_NOINIT :
7492          (block || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS)
7493            || PL_madskills)
7494         ? GV_ADDMULTI : GV_ADDMULTI | GV_NOINIT;
7495     STRLEN namlen = 0;
7496     const bool o_is_gv = flags & 1;
7497     const char * const name =
7498          o ? SvPV_const(o_is_gv ? (SV *)o : cSVOPo->op_sv, namlen) : NULL;
7499     bool has_name;
7500     bool name_is_utf8 = o && !o_is_gv && SvUTF8(cSVOPo->op_sv);
7501 #ifdef PERL_DEBUG_READONLY_OPS
7502     OPSLAB *slab = NULL;
7503 #endif
7504
7505     if (proto) {
7506         assert(proto->op_type == OP_CONST);
7507         ps = SvPV_const(((SVOP*)proto)->op_sv, ps_len);
7508         ps_utf8 = SvUTF8(((SVOP*)proto)->op_sv);
7509     }
7510     else
7511         ps = NULL;
7512
7513     if (o_is_gv) {
7514         gv = (GV*)o;
7515         o = NULL;
7516         has_name = TRUE;
7517     } else if (name) {
7518         gv = gv_fetchsv(cSVOPo->op_sv, gv_fetch_flags, SVt_PVCV);
7519         has_name = TRUE;
7520     } else if (PERLDB_NAMEANON && CopLINE(PL_curcop)) {
7521         SV * const sv = sv_newmortal();
7522         Perl_sv_setpvf(aTHX_ sv, "%s[%s:%"IVdf"]",
7523                        PL_curstash ? "__ANON__" : "__ANON__::__ANON__",
7524                        CopFILE(PL_curcop), (IV)CopLINE(PL_curcop));
7525         gv = gv_fetchsv(sv, gv_fetch_flags, SVt_PVCV);
7526         has_name = TRUE;
7527     } else if (PL_curstash) {
7528         gv = gv_fetchpvs("__ANON__", gv_fetch_flags, SVt_PVCV);
7529         has_name = FALSE;
7530     } else {
7531         gv = gv_fetchpvs("__ANON__::__ANON__", gv_fetch_flags, SVt_PVCV);
7532         has_name = FALSE;
7533     }
7534
7535     if (!PL_madskills) {
7536         if (o)
7537             SAVEFREEOP(o);
7538         if (proto)
7539             SAVEFREEOP(proto);
7540         if (attrs)
7541             SAVEFREEOP(attrs);
7542     }
7543
7544     if (ec) {
7545         op_free(block);
7546         if (name) SvREFCNT_dec(PL_compcv);
7547         else cv = PL_compcv;
7548         PL_compcv = 0;
7549         if (name && block) {
7550             const char *s = strrchr(name, ':');
7551             s = s ? s+1 : name;
7552             if (strEQ(s, "BEGIN")) {
7553                 if (PL_in_eval & EVAL_KEEPERR)
7554                     Perl_croak_nocontext("BEGIN not safe after errors--compilation aborted");
7555                 else {
7556                     SV * const errsv = ERRSV;
7557                     /* force display of errors found but not reported */
7558                     sv_catpvs(errsv, "BEGIN not safe after errors--compilation aborted");
7559                     Perl_croak_nocontext("%"SVf, SVfARG(errsv));
7560                 }
7561             }
7562         }
7563         goto done;
7564     }
7565
7566     if (SvTYPE(gv) != SVt_PVGV) {       /* Maybe prototype now, and had at
7567                                            maximum a prototype before. */
7568         if (SvTYPE(gv) > SVt_NULL) {
7569             cv_ckproto_len_flags((const CV *)gv,
7570                                  o ? (const GV *)cSVOPo->op_sv : NULL, ps,
7571                                  ps_len, ps_utf8);
7572         }
7573         if (ps) {
7574             sv_setpvn(MUTABLE_SV(gv), ps, ps_len);
7575             if ( ps_utf8 ) SvUTF8_on(MUTABLE_SV(gv));
7576         }
7577         else
7578             sv_setiv(MUTABLE_SV(gv), -1);
7579
7580         SvREFCNT_dec(PL_compcv);
7581         cv = PL_compcv = NULL;
7582         goto done;
7583     }
7584
7585     cv = (!name || GvCVGEN(gv)) ? NULL : GvCV(gv);
7586
7587     if (!block || !ps || *ps || attrs
7588         || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS)
7589 #ifdef PERL_MAD
7590         || block->op_type == OP_NULL
7591 #endif
7592         )
7593         const_sv = NULL;
7594     else
7595         const_sv = op_const_sv(block);
7596
7597     if (cv) {
7598         const bool exists = CvROOT(cv) || CvXSUB(cv);
7599
7600         /* if the subroutine doesn't exist and wasn't pre-declared
7601          * with a prototype, assume it will be AUTOLOADed,
7602          * skipping the prototype check
7603          */
7604         if (exists || SvPOK(cv))
7605             cv_ckproto_len_flags(cv, gv, ps, ps_len, ps_utf8);
7606         /* already defined (or promised)? */
7607         if (exists || GvASSUMECV(gv)) {
7608             if (S_already_defined(aTHX_ cv, block, o, NULL, &const_sv))
7609                 cv = NULL;
7610             else {
7611                 if (attrs) goto attrs;
7612                 /* just a "sub foo;" when &foo is already defined */
7613                 SAVEFREESV(PL_compcv);
7614                 goto done;
7615             }
7616         }
7617     }
7618     if (const_sv) {
7619         SvREFCNT_inc_simple_void_NN(const_sv);
7620         SvFLAGS(const_sv) = (SvFLAGS(const_sv) & ~SVs_PADMY) | SVs_PADTMP;
7621         if (cv) {
7622             assert(!CvROOT(cv) && !CvCONST(cv));
7623             cv_forget_slab(cv);
7624             sv_setpvs(MUTABLE_SV(cv), "");  /* prototype is "" */
7625             CvXSUBANY(cv).any_ptr = const_sv;
7626             CvXSUB(cv) = const_sv_xsub;
7627             CvCONST_on(cv);
7628             CvISXSUB_on(cv);
7629         }
7630         else {
7631             GvCV_set(gv, NULL);
7632             cv = newCONSTSUB_flags(
7633                 NULL, name, namlen, name_is_utf8 ? SVf_UTF8 : 0,
7634                 const_sv
7635             );
7636         }
7637         if (PL_madskills)
7638             goto install_block;
7639         op_free(block);
7640         SvREFCNT_dec(PL_compcv);
7641         PL_compcv = NULL;
7642         goto done;
7643     }
7644     if (cv) {                           /* must reuse cv if autoloaded */
7645         /* transfer PL_compcv to cv */
7646         if (block
7647 #ifdef PERL_MAD
7648                   && block->op_type != OP_NULL
7649 #endif
7650         ) {
7651             cv_flags_t existing_builtin_attrs = CvFLAGS(cv) & CVf_BUILTIN_ATTRS;
7652             PADLIST *const temp_av = CvPADLIST(cv);
7653             CV *const temp_cv = CvOUTSIDE(cv);
7654             const cv_flags_t other_flags =
7655                 CvFLAGS(cv) & (CVf_SLABBED|CVf_WEAKOUTSIDE);
7656             OP * const cvstart = CvSTART(cv);
7657
7658             CvGV_set(cv,gv);
7659             assert(!CvCVGV_RC(cv));
7660             assert(CvGV(cv) == gv);
7661
7662             SvPOK_off(cv);
7663             CvFLAGS(cv) = CvFLAGS(PL_compcv) | existing_builtin_attrs;
7664             CvOUTSIDE(cv) = CvOUTSIDE(PL_compcv);
7665             CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(PL_compcv);
7666             CvPADLIST(cv) = CvPADLIST(PL_compcv);
7667             CvOUTSIDE(PL_compcv) = temp_cv;
7668             CvPADLIST(PL_compcv) = temp_av;
7669             CvSTART(cv) = CvSTART(PL_compcv);
7670             CvSTART(PL_compcv) = cvstart;
7671             CvFLAGS(PL_compcv) &= ~(CVf_SLABBED|CVf_WEAKOUTSIDE);
7672             CvFLAGS(PL_compcv) |= other_flags;
7673
7674             if (CvFILE(cv) && CvDYNFILE(cv)) {
7675                 Safefree(CvFILE(cv));
7676     }
7677             CvFILE_set_from_cop(cv, PL_curcop);
7678             CvSTASH_set(cv, PL_curstash);
7679
7680             /* inner references to PL_compcv must be fixed up ... */
7681             pad_fixup_inner_anons(CvPADLIST(cv), PL_compcv, cv);
7682             if (PERLDB_INTER)/* Advice debugger on the new sub. */
7683               ++PL_sub_generation;
7684         }
7685         else {
7686             /* Might have had built-in attributes applied -- propagate them. */
7687             CvFLAGS(cv) |= (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS);
7688         }
7689         /* ... before we throw it away */
7690         SvREFCNT_dec(PL_compcv);
7691         PL_compcv = cv;
7692     }
7693     else {
7694         cv = PL_compcv;
7695         if (name) {
7696             GvCV_set(gv, cv);
7697             GvCVGEN(gv) = 0;
7698             if (HvENAME_HEK(GvSTASH(gv)))
7699                 /* sub Foo::bar { (shift)+1 } */
7700                 gv_method_changed(gv);
7701         }
7702     }
7703     if (!CvGV(cv)) {
7704         CvGV_set(cv, gv);
7705         CvFILE_set_from_cop(cv, PL_curcop);
7706         CvSTASH_set(cv, PL_curstash);
7707     }
7708
7709     if (ps) {
7710         sv_setpvn(MUTABLE_SV(cv), ps, ps_len);
7711         if ( ps_utf8 ) SvUTF8_on(MUTABLE_SV(cv));
7712     }
7713
7714  install_block:
7715     if (!block)
7716         goto attrs;
7717
7718     /* If we assign an optree to a PVCV, then we've defined a subroutine that
7719        the debugger could be able to set a breakpoint in, so signal to
7720        pp_entereval that it should not throw away any saved lines at scope
7721        exit.  */
7722
7723     PL_breakable_sub_gen++;
7724     /* This makes sub {}; work as expected.  */
7725     if (block->op_type == OP_STUB) {
7726             OP* const newblock = newSTATEOP(0, NULL, 0);
7727 #ifdef PERL_MAD
7728             op_getmad(block,newblock,'B');
7729 #else
7730             op_free(block);
7731 #endif
7732             block = newblock;
7733     }
7734     CvROOT(cv) = CvLVALUE(cv)
7735                    ? newUNOP(OP_LEAVESUBLV, 0,
7736                              op_lvalue(scalarseq(block), OP_LEAVESUBLV))
7737                    : newUNOP(OP_LEAVESUB, 0, scalarseq(block));
7738     CvROOT(cv)->op_private |= OPpREFCOUNTED;
7739     OpREFCNT_set(CvROOT(cv), 1);
7740     /* The cv no longer needs to hold a refcount on the slab, as CvROOT
7741        itself has a refcount. */
7742     CvSLABBED_off(cv);
7743     OpslabREFCNT_dec_padok((OPSLAB *)CvSTART(cv));
7744 #ifdef PERL_DEBUG_READONLY_OPS
7745     slab = (OPSLAB *)CvSTART(cv);
7746 #endif
7747     CvSTART(cv) = LINKLIST(CvROOT(cv));
7748     CvROOT(cv)->op_next = 0;
7749     CALL_PEEP(CvSTART(cv));
7750     finalize_optree(CvROOT(cv));
7751
7752     /* now that optimizer has done its work, adjust pad values */
7753
7754     pad_tidy(CvCLONE(cv) ? padtidy_SUBCLONE : padtidy_SUB);
7755
7756   attrs:
7757     if (attrs) {
7758         /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>. */
7759         HV *stash = name && GvSTASH(CvGV(cv)) ? GvSTASH(CvGV(cv)) : PL_curstash;
7760         if (!name) SAVEFREESV(cv);
7761         apply_attrs(stash, MUTABLE_SV(cv), attrs);
7762         if (!name) SvREFCNT_inc_simple_void_NN(cv);
7763     }
7764
7765     if (block && has_name) {
7766         if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
7767             SV * const tmpstr = sv_newmortal();
7768             GV * const db_postponed = gv_fetchpvs("DB::postponed",
7769                                                   GV_ADDMULTI, SVt_PVHV);
7770             HV *hv;
7771             SV * const sv = Perl_newSVpvf(aTHX_ "%s:%ld-%ld",
7772                                           CopFILE(PL_curcop),
7773                                           (long)PL_subline,
7774                                           (long)CopLINE(PL_curcop));
7775             gv_efullname3(tmpstr, gv, NULL);
7776             (void)hv_store(GvHV(PL_DBsub), SvPVX_const(tmpstr),
7777                     SvUTF8(tmpstr) ? -(I32)SvCUR(tmpstr) : (I32)SvCUR(tmpstr), sv, 0);
7778             hv = GvHVn(db_postponed);
7779             if (HvTOTALKEYS(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvUTF8(tmpstr) ? -(I32)SvCUR(tmpstr) : (I32)SvCUR(tmpstr))) {
7780                 CV * const pcv = GvCV(db_postponed);
7781                 if (pcv) {
7782                     dSP;
7783                     PUSHMARK(SP);
7784                     XPUSHs(tmpstr);
7785                     PUTBACK;
7786                     call_sv(MUTABLE_SV(pcv), G_DISCARD);
7787                 }
7788             }
7789         }
7790
7791         if (name && ! (PL_parser && PL_parser->error_count))
7792             process_special_blocks(floor, name, gv, cv);
7793     }
7794
7795   done:
7796     if (PL_parser)
7797         PL_parser->copline = NOLINE;
7798     LEAVE_SCOPE(floor);
7799 #ifdef PERL_DEBUG_READONLY_OPS
7800     /* Watch out for BEGIN blocks */
7801     if (slab && gv && isGV(gv) && GvCV(gv)) Slab_to_ro(slab);
7802 #endif
7803     return cv;
7804 }
7805
7806 STATIC void
7807 S_process_special_blocks(pTHX_ I32 floor, const char *const fullname,
7808                          GV *const gv,
7809                          CV *const cv)
7810 {
7811     const char *const colon = strrchr(fullname,':');
7812     const char *const name = colon ? colon + 1 : fullname;
7813
7814     PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS;
7815
7816     if (*name == 'B') {
7817         if (strEQ(name, "BEGIN")) {
7818             const I32 oldscope = PL_scopestack_ix;
7819             if (floor) LEAVE_SCOPE(floor);
7820             ENTER;
7821             SAVECOPFILE(&PL_compiling);
7822             SAVECOPLINE(&PL_compiling);
7823             SAVEVPTR(PL_curcop);
7824
7825             DEBUG_x( dump_sub(gv) );
7826             Perl_av_create_and_push(aTHX_ &PL_beginav, MUTABLE_SV(cv));
7827             GvCV_set(gv,0);             /* cv has been hijacked */
7828             call_list(oldscope, PL_beginav);
7829
7830             LEAVE;
7831         }
7832         else
7833             return;
7834     } else {
7835         if (*name == 'E') {
7836             if strEQ(name, "END") {
7837                 DEBUG_x( dump_sub(gv) );
7838                 Perl_av_create_and_unshift_one(aTHX_ &PL_endav, MUTABLE_SV(cv));
7839             } else
7840                 return;
7841         } else if (*name == 'U') {
7842             if (strEQ(name, "UNITCHECK")) {
7843                 /* It's never too late to run a unitcheck block */
7844                 Perl_av_create_and_unshift_one(aTHX_ &PL_unitcheckav, MUTABLE_SV(cv));
7845             }
7846             else
7847                 return;
7848         } else if (*name == 'C') {
7849             if (strEQ(name, "CHECK")) {
7850                 if (PL_main_start)
7851                     /* diag_listed_as: Too late to run %s block */
7852                     Perl_ck_warner(aTHX_ packWARN(WARN_VOID),
7853                                    "Too late to run CHECK block");
7854                 Perl_av_create_and_unshift_one(aTHX_ &PL_checkav, MUTABLE_SV(cv));
7855             }
7856             else
7857                 return;
7858         } else if (*name == 'I') {
7859             if (strEQ(name, "INIT")) {
7860                 if (PL_main_start)
7861                     /* diag_listed_as: Too late to run %s block */
7862                     Perl_ck_warner(aTHX_ packWARN(WARN_VOID),
7863                                    "Too late to run INIT block");
7864                 Perl_av_create_and_push(aTHX_ &PL_initav, MUTABLE_SV(cv));
7865             }
7866             else
7867                 return;
7868         } else
7869             return;
7870         DEBUG_x( dump_sub(gv) );
7871         GvCV_set(gv,0);         /* cv has been hijacked */
7872     }
7873 }
7874
7875 /*
7876 =for apidoc newCONSTSUB
7877
7878 See L</newCONSTSUB_flags>.
7879
7880 =cut
7881 */
7882
7883 CV *
7884 Perl_newCONSTSUB(pTHX_ HV *stash, const char *name, SV *sv)
7885 {
7886     return newCONSTSUB_flags(stash, name, name ? strlen(name) : 0, 0, sv);
7887 }
7888
7889 /*
7890 =for apidoc newCONSTSUB_flags
7891
7892 Creates a constant sub equivalent to Perl C<sub FOO () { 123 }> which is
7893 eligible for inlining at compile-time.
7894
7895 Currently, the only useful value for C<flags> is SVf_UTF8.
7896
7897 The newly created subroutine takes ownership of a reference to the passed in
7898 SV.
7899
7900 Passing NULL for SV creates a constant sub equivalent to C<sub BAR () {}>,
7901 which won't be called if used as a destructor, but will suppress the overhead
7902 of a call to C<AUTOLOAD>.  (This form, however, isn't eligible for inlining at
7903 compile time.)
7904
7905 =cut
7906 */
7907
7908 CV *
7909 Perl_newCONSTSUB_flags(pTHX_ HV *stash, const char *name, STRLEN len,
7910                              U32 flags, SV *sv)
7911 {
7912     dVAR;
7913     CV* cv;
7914     const char *const file = CopFILE(PL_curcop);
7915
7916     ENTER;
7917
7918     if (IN_PERL_RUNTIME) {
7919         /* at runtime, it's not safe to manipulate PL_curcop: it may be
7920          * an op shared between threads. Use a non-shared COP for our
7921          * dirty work */
7922          SAVEVPTR(PL_curcop);
7923          SAVECOMPILEWARNINGS();
7924          PL_compiling.cop_warnings = DUP_WARNINGS(PL_curcop->cop_warnings);
7925          PL_curcop = &PL_compiling;
7926     }
7927     SAVECOPLINE(PL_curcop);
7928     CopLINE_set(PL_curcop, PL_parser ? PL_parser->copline : NOLINE);
7929
7930     SAVEHINTS();
7931     PL_hints &= ~HINT_BLOCK_SCOPE;
7932
7933     if (stash) {
7934         SAVEGENERICSV(PL_curstash);
7935         PL_curstash = (HV *)SvREFCNT_inc_simple_NN(stash);
7936     }
7937
7938     /* Protect sv against leakage caused by fatal warnings. */
7939     if (sv) SAVEFREESV(sv);
7940
7941     /* file becomes the CvFILE. For an XS, it's usually static storage,
7942        and so doesn't get free()d.  (It's expected to be from the C pre-
7943        processor __FILE__ directive). But we need a dynamically allocated one,
7944        and we need it to get freed.  */
7945     cv = newXS_len_flags(name, len,
7946                          sv && SvTYPE(sv) == SVt_PVAV
7947                              ? const_av_xsub
7948                              : const_sv_xsub,
7949                          file ? file : "", "",
7950                          &sv, XS_DYNAMIC_FILENAME | flags);
7951     CvXSUBANY(cv).any_ptr = SvREFCNT_inc_simple(sv);
7952     CvCONST_on(cv);
7953
7954     LEAVE;
7955
7956     return cv;
7957 }
7958
7959 CV *
7960 Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr,
7961                  const char *const filename, const char *const proto,
7962                  U32 flags)
7963 {
7964     PERL_ARGS_ASSERT_NEWXS_FLAGS;
7965     return newXS_len_flags(
7966        name, name ? strlen(name) : 0, subaddr, filename, proto, NULL, flags
7967     );
7968 }
7969
7970 CV *
7971 Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len,
7972                            XSUBADDR_t subaddr, const char *const filename,
7973                            const char *const proto, SV **const_svp,
7974                            U32 flags)
7975 {
7976     CV *cv;
7977
7978     PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS;
7979
7980     {
7981         GV * const gv = gv_fetchpvn(
7982                             name ? name : PL_curstash ? "__ANON__" : "__ANON__::__ANON__",
7983                             name ? len : PL_curstash ? sizeof("__ANON__") - 1:
7984                                 sizeof("__ANON__::__ANON__") - 1,
7985                             GV_ADDMULTI | flags, SVt_PVCV);
7986
7987         if (!subaddr)
7988             Perl_croak(aTHX_ "panic: no address for '%s' in '%s'", name, filename);
7989
7990         if ((cv = (name ? GvCV(gv) : NULL))) {
7991             if (GvCVGEN(gv)) {
7992                 /* just a cached method */
7993                 SvREFCNT_dec(cv);
7994                 cv = NULL;
7995             }
7996             else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
7997                 /* already defined (or promised) */
7998                 /* Redundant check that allows us to avoid creating an SV
7999                    most of the time: */
8000                 if (CvCONST(cv) || ckWARN(WARN_REDEFINE)) {
8001                     report_redefined_cv(newSVpvn_flags(
8002                                          name,len,(flags&SVf_UTF8)|SVs_TEMP
8003                                         ),
8004                                         cv, const_svp);
8005                 }
8006                 SvREFCNT_dec_NN(cv);
8007                 cv = NULL;
8008             }
8009         }
8010
8011         if (cv)                         /* must reuse cv if autoloaded */
8012             cv_undef(cv);
8013         else {
8014             cv = MUTABLE_CV(newSV_type(SVt_PVCV));
8015             if (name) {
8016                 GvCV_set(gv,cv);
8017                 GvCVGEN(gv) = 0;
8018                 if (HvENAME_HEK(GvSTASH(gv)))
8019                     gv_method_changed(gv); /* newXS */
8020             }
8021         }
8022         if (!name)
8023             CvANON_on(cv);
8024         CvGV_set(cv, gv);
8025         (void)gv_fetchfile(filename);
8026         CvFILE(cv) = (char *)filename; /* NOTE: not copied, as it is expected to be
8027                                     an external constant string */
8028         assert(!CvDYNFILE(cv)); /* cv_undef should have turned it off */
8029         CvISXSUB_on(cv);
8030         CvXSUB(cv) = subaddr;
8031
8032         if (name)
8033             process_special_blocks(0, name, gv, cv);
8034     }
8035
8036     if (flags & XS_DYNAMIC_FILENAME) {
8037         CvFILE(cv) = savepv(filename);
8038         CvDYNFILE_on(cv);
8039     }
8040     sv_setpv(MUTABLE_SV(cv), proto);
8041     return cv;
8042 }
8043
8044 CV *
8045 Perl_newSTUB(pTHX_ GV *gv, bool fake)
8046 {
8047     CV *cv = MUTABLE_CV(newSV_type(SVt_PVCV));
8048     GV *cvgv;
8049     PERL_ARGS_ASSERT_NEWSTUB;
8050     assert(!GvCVu(gv));
8051     GvCV_set(gv, cv);
8052     GvCVGEN(gv) = 0;
8053     if (!fake && HvENAME_HEK(GvSTASH(gv)))
8054         gv_method_changed(gv);
8055     if (SvFAKE(gv)) {
8056         cvgv = gv_fetchsv((SV *)gv, GV_ADDMULTI, SVt_PVCV);
8057         SvFAKE_off(cvgv);
8058     }
8059     else cvgv = gv;
8060     CvGV_set(cv, cvgv);
8061     CvFILE_set_from_cop(cv, PL_curcop);
8062     CvSTASH_set(cv, PL_curstash);
8063     GvMULTI_on(gv);
8064     return cv;
8065 }
8066
8067 /*
8068 =for apidoc U||newXS
8069
8070 Used by C<xsubpp> to hook up XSUBs as Perl subs.  I<filename> needs to be
8071 static storage, as it is used directly as CvFILE(), without a copy being made.
8072
8073 =cut
8074 */
8075
8076 CV *
8077 Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
8078 {
8079     PERL_ARGS_ASSERT_NEWXS;
8080     return newXS_len_flags(
8081         name, name ? strlen(name) : 0, subaddr, filename, NULL, NULL, 0
8082     );
8083 }
8084
8085 #ifdef PERL_MAD
8086 OP *
8087 #else
8088 void
8089 #endif
8090 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
8091 {
8092     dVAR;
8093     CV *cv;
8094 #ifdef PERL_MAD
8095     OP* pegop = newOP(OP_NULL, 0);
8096 #endif
8097
8098     GV *gv;
8099
8100     if (PL_parser && PL_parser->error_count) {
8101         op_free(block);
8102         goto finish;
8103     }
8104
8105     gv = o
8106         ? gv_fetchsv(cSVOPo->op_sv, GV_ADD, SVt_PVFM)
8107         : gv_fetchpvs("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVFM);
8108
8109     GvMULTI_on(gv);
8110     if ((cv = GvFORM(gv))) {
8111         if (ckWARN(WARN_REDEFINE)) {
8112             const line_t oldline = CopLINE(PL_curcop);
8113             if (PL_parser && PL_parser->copline != NOLINE)
8114                 CopLINE_set(PL_curcop, PL_parser->copline);
8115             if (o) {
8116                 Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
8117                             "Format %"SVf" redefined", SVfARG(cSVOPo->op_sv));
8118             } else {
8119                 /* diag_listed_as: Format %s redefined */
8120                 Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
8121                             "Format STDOUT redefined");
8122             }
8123             CopLINE_set(PL_curcop, oldline);
8124         }
8125         SvREFCNT_dec(cv);
8126     }
8127     cv = PL_compcv;
8128     GvFORM(gv) = (CV *)SvREFCNT_inc_simple_NN(cv);
8129     CvGV_set(cv, gv);
8130     CvFILE_set_from_cop(cv, PL_curcop);
8131
8132
8133     pad_tidy(padtidy_FORMAT);
8134     CvROOT(cv) = newUNOP(OP_LEAVEWRITE, 0, scalarseq(block));
8135     CvROOT(cv)->op_private |= OPpREFCOUNTED;
8136     OpREFCNT_set(CvROOT(cv), 1);
8137     CvSTART(cv) = LINKLIST(CvROOT(cv));
8138     CvROOT(cv)->op_next = 0;
8139     CALL_PEEP(CvSTART(cv));
8140     finalize_optree(CvROOT(cv));
8141     cv_forget_slab(cv);
8142
8143   finish:
8144 #ifdef PERL_MAD
8145     op_getmad(o,pegop,'n');
8146     op_getmad_weak(block, pegop, 'b');
8147 #else
8148     op_free(o);
8149 #endif
8150     if (PL_parser)
8151         PL_parser->copline = NOLINE;
8152     LEAVE_SCOPE(floor);
8153 #ifdef PERL_MAD
8154     return pegop;
8155 #endif
8156 }
8157
8158 OP *
8159 Perl_newANONLIST(pTHX_ OP *o)
8160 {
8161     return convert(OP_ANONLIST, OPf_SPECIAL, o);
8162 }
8163
8164 OP *
8165 Perl_newANONHASH(pTHX_ OP *o)
8166 {
8167     return convert(OP_ANONHASH, OPf_SPECIAL, o);
8168 }
8169
8170 OP *
8171 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
8172 {
8173     return newANONATTRSUB(floor, proto, NULL, block);
8174 }
8175
8176 OP *
8177 Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block)
8178 {
8179     return newUNOP(OP_REFGEN, 0,
8180         newSVOP(OP_ANONCODE, 0,
8181                 MUTABLE_SV(newATTRSUB(floor, 0, proto, attrs, block))));
8182 }
8183
8184 OP *
8185 Perl_oopsAV(pTHX_ OP *o)
8186 {
8187     dVAR;
8188
8189     PERL_ARGS_ASSERT_OOPSAV;
8190
8191     switch (o->op_type) {
8192     case OP_PADSV:
8193     case OP_PADHV:
8194         o->op_type = OP_PADAV;
8195         o->op_ppaddr = PL_ppaddr[OP_PADAV];
8196         return ref(o, OP_RV2AV);
8197
8198     case OP_RV2SV:
8199     case OP_RV2HV:
8200         o->op_type = OP_RV2AV;
8201         o->op_ppaddr = PL_ppaddr[OP_RV2AV];
8202         ref(o, OP_RV2AV);
8203         break;
8204
8205     default:
8206         Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL), "oops: oopsAV");
8207         break;
8208     }
8209     return o;
8210 }
8211
8212 OP *
8213 Perl_oopsHV(pTHX_ OP *o)
8214 {
8215     dVAR;
8216
8217     PERL_ARGS_ASSERT_OOPSHV;
8218
8219     switch (o->op_type) {
8220     case OP_PADSV:
8221     case OP_PADAV:
8222         o->op_type = OP_PADHV;
8223         o->op_ppaddr = PL_ppaddr[OP_PADHV];
8224         return ref(o, OP_RV2HV);
8225
8226     case OP_RV2SV:
8227     case OP_RV2AV:
8228         o->op_type = OP_RV2HV;
8229         o->op_ppaddr = PL_ppaddr[OP_RV2HV];
8230         ref(o, OP_RV2HV);
8231         break;
8232
8233     default:
8234         Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL), "oops: oopsHV");
8235         break;
8236     }
8237     return o;
8238 }
8239
8240 OP *
8241 Perl_newAVREF(pTHX_ OP *o)
8242 {
8243     dVAR;
8244
8245     PERL_ARGS_ASSERT_NEWAVREF;
8246
8247     if (o->op_type == OP_PADANY) {
8248         o->op_type = OP_PADAV;
8249         o->op_ppaddr = PL_ppaddr[OP_PADAV];
8250         return o;
8251     }
8252     else if ((o->op_type == OP_RV2AV || o->op_type == OP_PADAV)) {
8253         Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
8254                        "Using an array as a reference is deprecated");
8255     }
8256     return newUNOP(OP_RV2AV, 0, scalar(o));
8257 }
8258
8259 OP *
8260 Perl_newGVREF(pTHX_ I32 type, OP *o)
8261 {
8262     if (type == OP_MAPSTART || type == OP_GREPSTART || type == OP_SORT)
8263         return newUNOP(OP_NULL, 0, o);
8264     return ref(newUNOP(OP_RV2GV, OPf_REF, o), type);
8265 }
8266
8267 OP *
8268 Perl_newHVREF(pTHX_ OP *o)
8269 {
8270     dVAR;
8271
8272     PERL_ARGS_ASSERT_NEWHVREF;
8273
8274     if (o->op_type == OP_PADANY) {
8275         o->op_type = OP_PADHV;
8276         o->op_ppaddr = PL_ppaddr[OP_PADHV];
8277         return o;
8278     }
8279     else if ((o->op_type == OP_RV2HV || o->op_type == OP_PADHV)) {
8280         Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
8281                        "Using a hash as a reference is deprecated");
8282     }
8283     return newUNOP(OP_RV2HV, 0, scalar(o));
8284 }
8285
8286 OP *
8287 Perl_newCVREF(pTHX_ I32 flags, OP *o)
8288 {
8289     if (o->op_type == OP_PADANY) {
8290         dVAR;
8291         o->op_type = OP_PADCV;
8292         o->op_ppaddr = PL_ppaddr[OP_PADCV];
8293     }
8294     return newUNOP(OP_RV2CV, flags, scalar(o));
8295 }
8296
8297 OP *
8298 Perl_newSVREF(pTHX_ OP *o)
8299 {
8300     dVAR;
8301
8302     PERL_ARGS_ASSERT_NEWSVREF;
8303
8304     if (o->op_type == OP_PADANY) {
8305         o->op_type = OP_PADSV;
8306         o->op_ppaddr = PL_ppaddr[OP_PADSV];
8307         return o;
8308     }
8309     return newUNOP(OP_RV2SV, 0, scalar(o));
8310 }
8311
8312 /* Check routines. See the comments at the top of this file for details
8313  * on when these are called */
8314
8315 OP *
8316 Perl_ck_anoncode(pTHX_ OP *o)
8317 {
8318     PERL_ARGS_ASSERT_CK_ANONCODE;
8319
8320     cSVOPo->op_targ = pad_add_anon((CV*)cSVOPo->op_sv, o->op_type);
8321     if (!PL_madskills)
8322         cSVOPo->op_sv = NULL;
8323     return o;
8324 }
8325
8326 OP *
8327 Perl_ck_bitop(pTHX_ OP *o)
8328 {
8329     dVAR;
8330
8331     PERL_ARGS_ASSERT_CK_BITOP;
8332
8333     o->op_private = (U8)(PL_hints & HINT_INTEGER);
8334     if (!(o->op_flags & OPf_STACKED) /* Not an assignment */
8335             && (o->op_type == OP_BIT_OR
8336              || o->op_type == OP_BIT_AND
8337              || o->op_type == OP_BIT_XOR))
8338     {
8339         const OP * const left = cBINOPo->op_first;
8340         const OP * const right = left->op_sibling;
8341         if ((OP_IS_NUMCOMPARE(left->op_type) &&
8342                 (left->op_flags & OPf_PARENS) == 0) ||
8343             (OP_IS_NUMCOMPARE(right->op_type) &&
8344                 (right->op_flags & OPf_PARENS) == 0))
8345             Perl_ck_warner(aTHX_ packWARN(WARN_PRECEDENCE),
8346                            "Possible precedence problem on bitwise %c operator",
8347                            o->op_type == OP_BIT_OR ? '|'
8348                            : o->op_type == OP_BIT_AND ? '&' : '^'
8349                            );
8350     }
8351     return o;
8352 }
8353
8354 PERL_STATIC_INLINE bool
8355 is_dollar_bracket(pTHX_ const OP * const o)
8356 {
8357     const OP *kid;
8358     return o->op_type == OP_RV2SV && o->op_flags & OPf_KIDS
8359         && (kid = cUNOPx(o)->op_first)
8360         && kid->op_type == OP_GV
8361         && strEQ(GvNAME(cGVOPx_gv(kid)), "[");
8362 }
8363
8364 OP *
8365 Perl_ck_cmp(pTHX_ OP *o)
8366 {
8367     PERL_ARGS_ASSERT_CK_CMP;
8368     if (ckWARN(WARN_SYNTAX)) {
8369         const OP *kid = cUNOPo->op_first;
8370         if (kid && (
8371                 (
8372                    is_dollar_bracket(aTHX_ kid)
8373                 && kid->op_sibling && kid->op_sibling->op_type == OP_CONST
8374                 )
8375              || (  kid->op_type == OP_CONST
8376                 && (kid = kid->op_sibling) && is_dollar_bracket(aTHX_ kid))
8377            ))
8378             Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
8379                         "$[ used in %s (did you mean $] ?)", OP_DESC(o));
8380     }
8381     return o;
8382 }
8383
8384 OP *
8385 Perl_ck_concat(pTHX_ OP *o)
8386 {
8387     const OP * const kid = cUNOPo->op_first;
8388
8389     PERL_ARGS_ASSERT_CK_CONCAT;
8390     PERL_UNUSED_CONTEXT;
8391
8392     if (kid->op_type == OP_CONCAT && !(kid->op_private & OPpTARGET_MY) &&
8393             !(kUNOP->op_first->op_flags & OPf_MOD))
8394         o->op_flags |= OPf_STACKED;
8395     return o;
8396 }
8397
8398 OP *
8399 Perl_ck_spair(pTHX_ OP *o)
8400 {
8401     dVAR;
8402
8403     PERL_ARGS_ASSERT_CK_SPAIR;
8404
8405     if (o->op_flags & OPf_KIDS) {
8406         OP* newop;
8407         OP* kid;
8408         const OPCODE type = o->op_type;
8409         o = modkids(ck_fun(o), type);
8410         kid = cUNOPo->op_first;
8411         newop = kUNOP->op_first->op_sibling;
8412         if (newop) {
8413             const OPCODE type = newop->op_type;
8414             if (newop->op_sibling || !(PL_opargs[type] & OA_RETSCALAR) ||
8415                     type == OP_PADAV || type == OP_PADHV ||
8416                     type == OP_RV2AV || type == OP_RV2HV)
8417                 return o;
8418         }
8419 #ifdef PERL_MAD
8420         op_getmad(kUNOP->op_first,newop,'K');
8421 #else
8422         op_free(kUNOP->op_first);
8423 #endif
8424         kUNOP->op_first = newop;
8425     }
8426     /* transforms OP_REFGEN into OP_SREFGEN, OP_CHOP into OP_SCHOP,
8427      * and OP_CHOMP into OP_SCHOMP */
8428     o->op_ppaddr = PL_ppaddr[++o->op_type];
8429     return ck_fun(o);
8430 }
8431
8432 OP *
8433 Perl_ck_delete(pTHX_ OP *o)
8434 {
8435     PERL_ARGS_ASSERT_CK_DELETE;
8436
8437     o = ck_fun(o);
8438     o->op_private = 0;
8439     if (o->op_flags & OPf_KIDS) {
8440         OP * const kid = cUNOPo->op_first;
8441         switch (kid->op_type) {
8442         case OP_ASLICE:
8443             o->op_flags |= OPf_SPECIAL;
8444             /* FALL THROUGH */
8445         case OP_HSLICE:
8446             o->op_private |= OPpSLICE;
8447             break;
8448         case OP_AELEM:
8449             o->op_flags |= OPf_SPECIAL;
8450             /* FALL THROUGH */
8451         case OP_HELEM:
8452             break;
8453         case OP_KVASLICE:
8454             Perl_croak(aTHX_ "delete argument is index/value array slice,"
8455                              " use array slice");
8456         case OP_KVHSLICE:
8457             Perl_croak(aTHX_ "delete argument is key/value hash slice, use"
8458                              " hash slice");
8459         default:
8460             Perl_croak(aTHX_ "delete argument is not a HASH or ARRAY "
8461                              "element or slice");
8462         }
8463         if (kid->op_private & OPpLVAL_INTRO)
8464             o->op_private |= OPpLVAL_INTRO;
8465         op_null(kid);
8466     }
8467     return o;
8468 }
8469
8470 OP *
8471 Perl_ck_die(pTHX_ OP *o)
8472 {
8473     PERL_ARGS_ASSERT_CK_DIE;
8474
8475 #ifdef VMS
8476     if (VMSISH_HUSHED) o->op_private |= OPpHUSH_VMSISH;
8477 #endif
8478     return ck_fun(o);
8479 }
8480
8481 OP *
8482 Perl_ck_eof(pTHX_ OP *o)
8483 {
8484     dVAR;
8485
8486     PERL_ARGS_ASSERT_CK_EOF;
8487
8488     if (o->op_flags & OPf_KIDS) {
8489         OP *kid;
8490         if (cLISTOPo->op_first->op_type == OP_STUB) {
8491             OP * const newop
8492                 = newUNOP(o->op_type, OPf_SPECIAL, newGVOP(OP_GV, 0, PL_argvgv));
8493 #ifdef PERL_MAD
8494             op_getmad(o,newop,'O');
8495 #else
8496             op_free(o);
8497 #endif
8498             o = newop;
8499         }
8500         o = ck_fun(o);
8501         kid = cLISTOPo->op_first;
8502         if (kid->op_type == OP_RV2GV)
8503             kid->op_private |= OPpALLOW_FAKE;
8504     }
8505     return o;
8506 }
8507
8508 OP *
8509 Perl_ck_eval(pTHX_ OP *o)
8510 {
8511     dVAR;
8512
8513     PERL_ARGS_ASSERT_CK_EVAL;
8514
8515     PL_hints |= HINT_BLOCK_SCOPE;
8516     if (o->op_flags & OPf_KIDS) {
8517         SVOP * const kid = (SVOP*)cUNOPo->op_first;
8518         assert(kid);
8519
8520         if (kid->op_type == OP_LINESEQ || kid->op_type == OP_STUB) {
8521             LOGOP *enter;
8522 #ifdef PERL_MAD
8523             OP* const oldo = o;
8524 #endif
8525
8526             cUNOPo->op_first = 0;
8527 #ifndef PERL_MAD
8528             op_free(o);
8529 #endif
8530
8531             NewOp(1101, enter, 1, LOGOP);
8532             enter->op_type = OP_ENTERTRY;
8533             enter->op_ppaddr = PL_ppaddr[OP_ENTERTRY];
8534             enter->op_private = 0;
8535
8536             /* establish postfix order */
8537             enter->op_next = (OP*)enter;
8538
8539             o = op_prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
8540             o->op_type = OP_LEAVETRY;
8541             o->op_ppaddr = PL_ppaddr[OP_LEAVETRY];
8542             enter->op_other = o;
8543             op_getmad(oldo,o,'O');
8544             return o;
8545         }
8546         else {
8547             scalar((OP*)kid);
8548             PL_cv_has_eval = 1;
8549         }
8550     }
8551     else {
8552         const U8 priv = o->op_private;
8553 #ifdef PERL_MAD
8554         OP* const oldo = o;
8555 #else
8556         op_free(o);
8557 #endif
8558         o = newUNOP(OP_ENTEREVAL, priv <<8, newDEFSVOP());
8559         op_getmad(oldo,o,'O');
8560     }
8561     o->op_targ = (PADOFFSET)PL_hints;
8562     if (o->op_private & OPpEVAL_BYTES) o->op_targ &= ~HINT_UTF8;
8563     if ((PL_hints & HINT_LOCALIZE_HH) != 0
8564      && !(o->op_private & OPpEVAL_COPHH) && GvHV(PL_hintgv)) {
8565         /* Store a copy of %^H that pp_entereval can pick up. */
8566         OP *hhop = newSVOP(OP_HINTSEVAL, 0,
8567                            MUTABLE_SV(hv_copy_hints_hv(GvHV(PL_hintgv))));
8568         cUNOPo->op_first->op_sibling = hhop;
8569         o->op_private |= OPpEVAL_HAS_HH;
8570     }
8571     if (!(o->op_private & OPpEVAL_BYTES)
8572          && FEATURE_UNIEVAL_IS_ENABLED)
8573             o->op_private |= OPpEVAL_UNICODE;
8574     return o;
8575 }
8576
8577 OP *
8578 Perl_ck_exit(pTHX_ OP *o)
8579 {
8580     PERL_ARGS_ASSERT_CK_EXIT;
8581
8582 #ifdef VMS
8583     HV * const table = GvHV(PL_hintgv);
8584     if (table) {
8585        SV * const * const svp = hv_fetchs(table, "vmsish_exit", FALSE);
8586        if (svp && *svp && SvTRUE(*svp))
8587            o->op_private |= OPpEXIT_VMSISH;
8588     }
8589     if (VMSISH_HUSHED) o->op_private |= OPpHUSH_VMSISH;
8590 #endif
8591     return ck_fun(o);
8592 }
8593
8594 OP *
8595 Perl_ck_exec(pTHX_ OP *o)
8596 {
8597     PERL_ARGS_ASSERT_CK_EXEC;
8598
8599     if (o->op_flags & OPf_STACKED) {
8600         OP *kid;
8601         o = ck_fun(o);
8602         kid = cUNOPo->op_first->op_sibling;
8603         if (kid->op_type == OP_RV2GV)
8604             op_null(kid);
8605     }
8606     else
8607         o = listkids(o);
8608     return o;
8609 }
8610
8611 OP *
8612 Perl_ck_exists(pTHX_ OP *o)
8613 {
8614     dVAR;
8615
8616     PERL_ARGS_ASSERT_CK_EXISTS;
8617
8618     o = ck_fun(o);
8619     if (o->op_flags & OPf_KIDS) {
8620         OP * const kid = cUNOPo->op_first;
8621         if (kid->op_type == OP_ENTERSUB) {
8622             (void) ref(kid, o->op_type);
8623             if (kid->op_type != OP_RV2CV
8624                         && !(PL_parser && PL_parser->error_count))
8625                 Perl_croak(aTHX_
8626                           "exists argument is not a subroutine name");
8627             o->op_private |= OPpEXISTS_SUB;
8628         }
8629         else if (kid->op_type == OP_AELEM)
8630             o->op_flags |= OPf_SPECIAL;
8631         else if (kid->op_type != OP_HELEM)
8632             Perl_croak(aTHX_ "exists argument is not a HASH or ARRAY "
8633                              "element or a subroutine");
8634         op_null(kid);
8635     }
8636     return o;
8637 }
8638
8639 OP *
8640 Perl_ck_rvconst(pTHX_ OP *o)
8641 {
8642     dVAR;
8643     SVOP * const kid = (SVOP*)cUNOPo->op_first;
8644
8645     PERL_ARGS_ASSERT_CK_RVCONST;
8646
8647     o->op_private |= (PL_hints & HINT_STRICT_REFS);
8648     if (o->op_type == OP_RV2CV)
8649         o->op_private &= ~1;
8650
8651     if (kid->op_type == OP_CONST) {
8652         int iscv;
8653         GV *gv;
8654         SV * const kidsv = kid->op_sv;
8655
8656         /* Is it a constant from cv_const_sv()? */
8657         if (SvROK(kidsv) && SvREADONLY(kidsv)) {
8658             SV * const rsv = SvRV(kidsv);
8659             const svtype type = SvTYPE(rsv);
8660             const char *badtype = NULL;
8661
8662             switch (o->op_type) {
8663             case OP_RV2SV:
8664                 if (type > SVt_PVMG)
8665                     badtype = "a SCALAR";
8666                 break;
8667             case OP_RV2AV:
8668                 if (type != SVt_PVAV)
8669                     badtype = "an ARRAY";
8670                 break;
8671             case OP_RV2HV:
8672                 if (type != SVt_PVHV)
8673                     badtype = "a HASH";
8674                 break;
8675             case OP_RV2CV:
8676                 if (type != SVt_PVCV)
8677                     badtype = "a CODE";
8678                 break;
8679             }
8680             if (badtype)
8681                 Perl_croak(aTHX_ "Constant is not %s reference", badtype);
8682             return o;
8683         }
8684         if (SvTYPE(kidsv) == SVt_PVAV) return o;
8685         if ((o->op_private & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
8686             const char *badthing;
8687             switch (o->op_type) {
8688             case OP_RV2SV:
8689                 badthing = "a SCALAR";
8690                 break;
8691             case OP_RV2AV:
8692                 badthing = "an ARRAY";
8693                 break;
8694             case OP_RV2HV:
8695                 badthing = "a HASH";
8696                 break;
8697             default:
8698                 badthing = NULL;
8699                 break;
8700             }
8701             if (badthing)
8702                 Perl_croak(aTHX_
8703                            "Can't use bareword (\"%"SVf"\") as %s ref while \"strict refs\" in use",
8704                            SVfARG(kidsv), badthing);
8705         }
8706         /*
8707          * This is a little tricky.  We only want to add the symbol if we
8708          * didn't add it in the lexer.  Otherwise we get duplicate strict
8709          * warnings.  But if we didn't add it in the lexer, we must at
8710          * least pretend like we wanted to add it even if it existed before,
8711          * or we get possible typo warnings.  OPpCONST_ENTERED says
8712          * whether the lexer already added THIS instance of this symbol.
8713          */
8714         iscv = (o->op_type == OP_RV2CV) * 2;
8715         do {
8716             gv = gv_fetchsv(kidsv,
8717                 iscv | !(kid->op_private & OPpCONST_ENTERED),
8718                 iscv
8719                     ? SVt_PVCV
8720                     : o->op_type == OP_RV2SV
8721                         ? SVt_PV
8722                         : o->op_type == OP_RV2AV
8723                             ? SVt_PVAV
8724                             : o->op_type == OP_RV2HV
8725                                 ? SVt_PVHV
8726                                 : SVt_PVGV);
8727         } while (!gv && !(kid->op_private & OPpCONST_ENTERED) && !iscv++);
8728         if (gv) {
8729             kid->op_type = OP_GV;
8730             SvREFCNT_dec(kid->op_sv);
8731 #ifdef USE_ITHREADS
8732             /* XXX hack: dependence on sizeof(PADOP) <= sizeof(SVOP) */
8733             assert (sizeof(PADOP) <= sizeof(SVOP));
8734             kPADOP->op_padix = pad_alloc(OP_GV, SVs_PADTMP);
8735             SvREFCNT_dec(PAD_SVl(kPADOP->op_padix));
8736             GvIN_PAD_on(gv);
8737             PAD_SETSV(kPADOP->op_padix, MUTABLE_SV(SvREFCNT_inc_simple_NN(gv)));
8738 #else
8739             kid->op_sv = SvREFCNT_inc_simple_NN(gv);
8740 #endif
8741             kid->op_private = 0;
8742             kid->op_ppaddr = PL_ppaddr[OP_GV];
8743             /* FAKE globs in the symbol table cause weird bugs (#77810) */
8744             SvFAKE_off(gv);
8745         }
8746     }
8747     return o;
8748 }
8749
8750 OP *
8751 Perl_ck_ftst(pTHX_ OP *o)
8752 {
8753     dVAR;
8754     const I32 type = o->op_type;
8755
8756     PERL_ARGS_ASSERT_CK_FTST;
8757
8758     if (o->op_flags & OPf_REF) {
8759         NOOP;
8760     }
8761     else if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
8762         SVOP * const kid = (SVOP*)cUNOPo->op_first;
8763         const OPCODE kidtype = kid->op_type;
8764
8765         if (kidtype == OP_CONST && (kid->op_private & OPpCONST_BARE)
8766          && !kid->op_folded) {
8767             OP * const newop = newGVOP(type, OPf_REF,
8768                 gv_fetchsv(kid->op_sv, GV_ADD, SVt_PVIO));
8769 #ifdef PERL_MAD
8770             op_getmad(o,newop,'O');
8771 #else
8772             op_free(o);
8773 #endif
8774             return newop;
8775         }
8776         if ((PL_hints & HINT_FILETEST_ACCESS) && OP_IS_FILETEST_ACCESS(o->op_type))
8777             o->op_private |= OPpFT_ACCESS;
8778         if (PL_check[kidtype] == Perl_ck_ftst
8779                 && kidtype != OP_STAT && kidtype != OP_LSTAT) {
8780             o->op_private |= OPpFT_STACKED;
8781             kid->op_private |= OPpFT_STACKING;
8782             if (kidtype == OP_FTTTY && (
8783                    !(kid->op_private & OPpFT_STACKED)
8784                 || kid->op_private & OPpFT_AFTER_t
8785                ))
8786                 o->op_private |= OPpFT_AFTER_t;
8787         }
8788     }
8789     else {
8790 #ifdef PERL_MAD
8791         OP* const oldo = o;
8792 #else
8793         op_free(o);
8794 #endif
8795         if (type == OP_FTTTY)
8796             o = newGVOP(type, OPf_REF, PL_stdingv);
8797         else
8798             o = newUNOP(type, 0, newDEFSVOP());
8799         op_getmad(oldo,o,'O');
8800     }
8801     return o;
8802 }
8803
8804 OP *
8805 Perl_ck_fun(pTHX_ OP *o)
8806 {
8807     dVAR;
8808     const int type = o->op_type;
8809     I32 oa = PL_opargs[type] >> OASHIFT;
8810
8811     PERL_ARGS_ASSERT_CK_FUN;
8812
8813     if (o->op_flags & OPf_STACKED) {
8814         if ((oa & OA_OPTIONAL) && (oa >> 4) && !((oa >> 4) & OA_OPTIONAL))
8815             oa &= ~OA_OPTIONAL;
8816         else
8817             return no_fh_allowed(o);
8818     }
8819
8820     if (o->op_flags & OPf_KIDS) {
8821         OP **tokid = &cLISTOPo->op_first;
8822         OP *kid = cLISTOPo->op_first;
8823         OP *sibl;
8824         I32 numargs = 0;
8825         bool seen_optional = FALSE;
8826
8827         if (kid->op_type == OP_PUSHMARK ||
8828             (kid->op_type == OP_NULL && kid->op_targ == OP_PUSHMARK))
8829         {
8830             tokid = &kid->op_sibling;
8831             kid = kid->op_sibling;
8832         }
8833         if (kid && kid->op_type == OP_COREARGS) {
8834             bool optional = FALSE;
8835             while (oa) {
8836                 numargs++;
8837                 if (oa & OA_OPTIONAL) optional = TRUE;
8838                 oa = oa >> 4;
8839             }
8840             if (optional) o->op_private |= numargs;
8841             return o;
8842         }
8843
8844         while (oa) {
8845             if (oa & OA_OPTIONAL || (oa & 7) == OA_LIST) {
8846                 if (!kid && !seen_optional && PL_opargs[type] & OA_DEFGV)
8847                     *tokid = kid = newDEFSVOP();
8848                 seen_optional = TRUE;
8849             }
8850             if (!kid) break;
8851
8852             numargs++;
8853             sibl = kid->op_sibling;
8854 #ifdef PERL_MAD
8855             if (!sibl && kid->op_type == OP_STUB) {
8856                 numargs--;
8857                 break;
8858             }
8859 #endif
8860             switch (oa & 7) {
8861             case OA_SCALAR:
8862                 /* list seen where single (scalar) arg expected? */
8863                 if (numargs == 1 && !(oa >> 4)
8864                     && kid->op_type == OP_LIST && type != OP_SCALAR)
8865                 {
8866                     return too_many_arguments_pv(o,PL_op_desc[type], 0);
8867                 }
8868                 scalar(kid);
8869                 break;
8870             case OA_LIST:
8871                 if (oa < 16) {
8872                     kid = 0;
8873                     continue;
8874                 }
8875                 else
8876                     list(kid);
8877                 break;
8878             case OA_AVREF:
8879                 if ((type == OP_PUSH || type == OP_UNSHIFT)
8880                     && !kid->op_sibling)
8881                     Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
8882                                    "Useless use of %s with no values",
8883                                    PL_op_desc[type]);
8884
8885                 if (kid->op_type == OP_CONST &&
8886                     (kid->op_private & OPpCONST_BARE))
8887                 {
8888                     OP * const newop = newAVREF(newGVOP(OP_GV, 0,
8889                         gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVAV) ));
8890                     Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
8891                                    "Array @%"SVf" missing the @ in argument %"IVdf" of %s()",
8892                                    SVfARG(((SVOP*)kid)->op_sv), (IV)numargs, PL_op_desc[type]);
8893 #ifdef PERL_MAD
8894                     op_getmad(kid,newop,'K');
8895 #else
8896                     op_free(kid);
8897 #endif
8898                     kid = newop;
8899                     kid->op_sibling = sibl;
8900                     *tokid = kid;
8901                 }
8902                 else if (kid->op_type == OP_CONST
8903                       && (  !SvROK(cSVOPx_sv(kid))
8904                          || SvTYPE(SvRV(cSVOPx_sv(kid))) != SVt_PVAV  )
8905                         )
8906                     bad_type_pv(numargs, "array", PL_op_desc[type], 0, kid);
8907                 /* Defer checks to run-time if we have a scalar arg */
8908                 if (kid->op_type == OP_RV2AV || kid->op_type == OP_PADAV)
8909                     op_lvalue(kid, type);
8910                 else scalar(kid);
8911                 break;
8912             case OA_HVREF:
8913                 if (kid->op_type == OP_CONST &&
8914                     (kid->op_private & OPpCONST_BARE))
8915                 {
8916                     OP * const newop = newHVREF(newGVOP(OP_GV, 0,
8917                         gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVHV) ));
8918                     Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
8919                                    "Hash %%%"SVf" missing the %% in argument %"IVdf" of %s()",
8920                                    SVfARG(((SVOP*)kid)->op_sv), (IV)numargs, PL_op_desc[type]);
8921 #ifdef PERL_MAD
8922                     op_getmad(kid,newop,'K');
8923 #else
8924                     op_free(kid);
8925 #endif
8926                     kid = newop;
8927                     kid->op_sibling = sibl;
8928                     *tokid = kid;
8929                 }
8930                 else if (kid->op_type != OP_RV2HV && kid->op_type != OP_PADHV)
8931                     bad_type_pv(numargs, "hash", PL_op_desc[type], 0, kid);
8932                 op_lvalue(kid, type);
8933                 break;
8934             case OA_CVREF:
8935                 {
8936                     OP * const newop = newUNOP(OP_NULL, 0, kid);
8937                     kid->op_sibling = 0;
8938                     newop->op_next = newop;
8939                     kid = newop;
8940                     kid->op_sibling = sibl;
8941                     *tokid = kid;
8942                 }
8943                 break;
8944             case OA_FILEREF:
8945                 if (kid->op_type != OP_GV && kid->op_type != OP_RV2GV) {
8946                     if (kid->op_type == OP_CONST &&
8947                         (kid->op_private & OPpCONST_BARE))
8948                     {
8949                         OP * const newop = newGVOP(OP_GV, 0,
8950                             gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVIO));
8951                         if (!(o->op_private & 1) && /* if not unop */
8952                             kid == cLISTOPo->op_last)
8953                             cLISTOPo->op_last = newop;
8954 #ifdef PERL_MAD
8955                         op_getmad(kid,newop,'K');
8956 #else
8957                         op_free(kid);
8958 #endif
8959                         kid = newop;
8960                     }
8961                     else if (kid->op_type == OP_READLINE) {
8962                         /* neophyte patrol: open(<FH>), close(<FH>) etc. */
8963                         bad_type_pv(numargs, "HANDLE", OP_DESC(o), 0, kid);
8964                     }
8965                     else {
8966                         I32 flags = OPf_SPECIAL;
8967                         I32 priv = 0;
8968                         PADOFFSET targ = 0;
8969
8970                         /* is this op a FH constructor? */
8971                         if (is_handle_constructor(o,numargs)) {
8972                             const char *name = NULL;
8973                             STRLEN len = 0;
8974                             U32 name_utf8 = 0;
8975                             bool want_dollar = TRUE;
8976
8977                             flags = 0;
8978                             /* Set a flag to tell rv2gv to vivify
8979                              * need to "prove" flag does not mean something
8980                              * else already - NI-S 1999/05/07
8981                              */
8982                             priv = OPpDEREF;
8983                             if (kid->op_type == OP_PADSV) {
8984                                 SV *const namesv
8985                                     = PAD_COMPNAME_SV(kid->op_targ);
8986                                 name = SvPV_const(namesv, len);
8987                                 name_utf8 = SvUTF8(namesv);
8988                             }
8989                             else if (kid->op_type == OP_RV2SV
8990                                      && kUNOP->op_first->op_type == OP_GV)
8991                             {
8992                                 GV * const gv = cGVOPx_gv(kUNOP->op_first);
8993                                 name = GvNAME(gv);
8994                                 len = GvNAMELEN(gv);
8995                                 name_utf8 = GvNAMEUTF8(gv) ? SVf_UTF8 : 0;
8996                             }
8997                             else if (kid->op_type == OP_AELEM
8998                                      || kid->op_type == OP_HELEM)
8999                             {
9000                                  OP *firstop;
9001                                  OP *op = ((BINOP*)kid)->op_first;
9002                                  name = NULL;
9003                                  if (op) {
9004                                       SV *tmpstr = NULL;
9005                                       const char * const a =
9006                                            kid->op_type == OP_AELEM ?
9007                                            "[]" : "{}";
9008                                       if (((op->op_type == OP_RV2AV) ||
9009                                            (op->op_type == OP_RV2HV)) &&
9010                                           (firstop = ((UNOP*)op)->op_first) &&
9011                                           (firstop->op_type == OP_GV)) {
9012                                            /* packagevar $a[] or $h{} */
9013                                            GV * const gv = cGVOPx_gv(firstop);
9014                                            if (gv)
9015                                                 tmpstr =
9016                                                      Perl_newSVpvf(aTHX_
9017                                                                    "%s%c...%c",
9018                                                                    GvNAME(gv),
9019                                                                    a[0], a[1]);
9020                                       }
9021                                       else if (op->op_type == OP_PADAV
9022                                                || op->op_type == OP_PADHV) {
9023                                            /* lexicalvar $a[] or $h{} */
9024                                            const char * const padname =
9025                                                 PAD_COMPNAME_PV(op->op_targ);
9026                                            if (padname)
9027                                                 tmpstr =
9028                                                      Perl_newSVpvf(aTHX_
9029                                                                    "%s%c...%c",
9030                                                                    padname + 1,
9031                                                                    a[0], a[1]);
9032                                       }
9033                                       if (tmpstr) {
9034                                            name = SvPV_const(tmpstr, len);
9035                                            name_utf8 = SvUTF8(tmpstr);
9036                                            sv_2mortal(tmpstr);
9037                                       }
9038                                  }
9039                                  if (!name) {
9040                                       name = "__ANONIO__";
9041                                       len = 10;
9042                                       want_dollar = FALSE;
9043                                  }
9044                                  op_lvalue(kid, type);
9045                             }
9046                             if (name) {
9047                                 SV *namesv;
9048                                 targ = pad_alloc(OP_RV2GV, SVf_READONLY);
9049                                 namesv = PAD_SVl(targ);
9050                                 if (want_dollar && *name != '$')
9051                                     sv_setpvs(namesv, "$");
9052                                 else
9053                                     sv_setpvs(namesv, "");
9054                                 sv_catpvn(namesv, name, len);
9055                                 if ( name_utf8 ) SvUTF8_on(namesv);
9056                             }
9057                         }
9058                         kid->op_sibling = 0;
9059                         kid = newUNOP(OP_RV2GV, flags, scalar(kid));
9060                         kid->op_targ = targ;
9061                         kid->op_private |= priv;
9062                     }
9063                     kid->op_sibling = sibl;
9064                     *tokid = kid;
9065                 }
9066                 scalar(kid);
9067                 break;
9068             case OA_SCALARREF:
9069                 if ((type == OP_UNDEF || type == OP_POS)
9070                     && numargs == 1 && !(oa >> 4)
9071                     && kid->op_type == OP_LIST)
9072                     return too_many_arguments_pv(o,PL_op_desc[type], 0);
9073                 op_lvalue(scalar(kid), type);
9074                 break;
9075             }
9076             oa >>= 4;
9077             tokid = &kid->op_sibling;
9078             kid = kid->op_sibling;
9079         }
9080 #ifdef PERL_MAD
9081         if (kid && kid->op_type != OP_STUB)
9082             return too_many_arguments_pv(o,OP_DESC(o), 0);
9083         o->op_private |= numargs;
9084 #else
9085         /* FIXME - should the numargs move as for the PERL_MAD case?  */
9086         o->op_private |= numargs;
9087         if (kid)
9088             return too_many_arguments_pv(o,OP_DESC(o), 0);
9089 #endif
9090         listkids(o);
9091     }
9092     else if (PL_opargs[type] & OA_DEFGV) {
9093 #ifdef PERL_MAD
9094         OP *newop = newUNOP(type, 0, newDEFSVOP());
9095         op_getmad(o,newop,'O');
9096         return newop;
9097 #else
9098         /* Ordering of these two is important to keep f_map.t passing.  */
9099         op_free(o);
9100         return newUNOP(type, 0, newDEFSVOP());
9101 #endif
9102     }
9103
9104     if (oa) {
9105         while (oa & OA_OPTIONAL)
9106             oa >>= 4;
9107         if (oa && oa != OA_LIST)
9108             return too_few_arguments_pv(o,OP_DESC(o), 0);
9109     }
9110     return o;
9111 }
9112
9113 OP *
9114 Perl_ck_glob(pTHX_ OP *o)
9115 {
9116     dVAR;
9117     GV *gv;
9118     const bool core = o->op_flags & OPf_SPECIAL;
9119
9120     PERL_ARGS_ASSERT_CK_GLOB;
9121
9122     o = ck_fun(o);
9123     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
9124         op_append_elem(OP_GLOB, o, newDEFSVOP()); /* glob() => glob($_) */
9125
9126     if (core) gv = NULL;
9127     else if (!((gv = gv_fetchpvs("glob", GV_NOTQUAL, SVt_PVCV))
9128           && GvCVu(gv) && GvIMPORTED_CV(gv)))
9129     {
9130         GV * const * const gvp =
9131             (GV **)hv_fetchs(PL_globalstash, "glob", FALSE);
9132         gv = gvp ? *gvp : NULL;
9133     }
9134
9135     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
9136         /* convert
9137          *     glob
9138          *       \ null - const(wildcard)
9139          * into
9140          *     null
9141          *       \ enter
9142          *            \ list
9143          *                 \ mark - glob - rv2cv
9144          *                             |        \ gv(CORE::GLOBAL::glob)
9145          *                             |
9146          *                              \ null - const(wildcard)
9147          */
9148         o->op_flags |= OPf_SPECIAL;
9149         o->op_targ = pad_alloc(OP_GLOB, SVs_PADTMP);
9150         o = newLISTOP(OP_LIST, 0, o, NULL);
9151         o = newUNOP(OP_ENTERSUB, OPf_STACKED,
9152                     op_append_elem(OP_LIST, o,
9153                                 scalar(newUNOP(OP_RV2CV, 0,
9154                                                newGVOP(OP_GV, 0, gv)))));
9155         o = newUNOP(OP_NULL, 0, o);
9156         o->op_targ = OP_GLOB; /* hint at what it used to be: eg in newWHILEOP */
9157         return o;
9158     }
9159     else o->op_flags &= ~OPf_SPECIAL;
9160 #if !defined(PERL_EXTERNAL_GLOB)
9161     if (!PL_globhook) {
9162         ENTER;
9163         Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
9164                                newSVpvs("File::Glob"), NULL, NULL, NULL);
9165         LEAVE;
9166     }
9167 #endif /* !PERL_EXTERNAL_GLOB */
9168     gv = (GV *)newSV(0);
9169     gv_init(gv, 0, "", 0, 0);
9170     gv_IOadd(gv);
9171     op_append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
9172     SvREFCNT_dec_NN(gv); /* newGVOP increased it */
9173     scalarkids(o);
9174     return o;
9175 }
9176
9177 OP *
9178 Perl_ck_grep(pTHX_ OP *o)
9179 {
9180     dVAR;
9181     LOGOP *gwop;
9182     OP *kid;
9183     const OPCODE type = o->op_type == OP_GREPSTART ? OP_GREPWHILE : OP_MAPWHILE;
9184     PADOFFSET offset;
9185
9186     PERL_ARGS_ASSERT_CK_GREP;
9187
9188     o->op_ppaddr = PL_ppaddr[OP_GREPSTART];
9189     /* don't allocate gwop here, as we may leak it if PL_parser->error_count > 0 */
9190
9191     if (o->op_flags & OPf_STACKED) {
9192         kid = cUNOPx(cLISTOPo->op_first->op_sibling)->op_first;
9193         if (kid->op_type != OP_SCOPE && kid->op_type != OP_LEAVE)
9194             return no_fh_allowed(o);
9195         o->op_flags &= ~OPf_STACKED;
9196     }
9197     kid = cLISTOPo->op_first->op_sibling;
9198     if (type == OP_MAPWHILE)
9199         list(kid);
9200     else
9201         scalar(kid);
9202     o = ck_fun(o);
9203     if (PL_parser && PL_parser->error_count)
9204         return o;
9205     kid = cLISTOPo->op_first->op_sibling;
9206     if (kid->op_type != OP_NULL)
9207         Perl_croak(aTHX_ "panic: ck_grep, type=%u", (unsigned) kid->op_type);
9208     kid = kUNOP->op_first;
9209
9210     NewOp(1101, gwop, 1, LOGOP);
9211     gwop->op_type = type;
9212     gwop->op_ppaddr = PL_ppaddr[type];
9213     gwop->op_first = o;
9214     gwop->op_flags |= OPf_KIDS;
9215     gwop->op_other = LINKLIST(kid);
9216     kid->op_next = (OP*)gwop;
9217     offset = pad_findmy_pvs("$_", 0);
9218     if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
9219         o->op_private = gwop->op_private = 0;
9220         gwop->op_targ = pad_alloc(type, SVs_PADTMP);
9221     }
9222     else {
9223         o->op_private = gwop->op_private = OPpGREP_LEX;
9224         gwop->op_targ = o->op_targ = offset;
9225     }
9226
9227     kid = cLISTOPo->op_first->op_sibling;
9228     for (kid = kid->op_sibling; kid; kid = kid->op_sibling)
9229         op_lvalue(kid, OP_GREPSTART);
9230
9231     return (OP*)gwop;
9232 }
9233
9234 OP *
9235 Perl_ck_index(pTHX_ OP *o)
9236 {
9237     PERL_ARGS_ASSERT_CK_INDEX;
9238
9239     if (o->op_flags & OPf_KIDS) {
9240         OP *kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
9241         if (kid)
9242             kid = kid->op_sibling;                      /* get past "big" */
9243         if (kid && kid->op_type == OP_CONST) {
9244             const bool save_taint = TAINT_get;
9245             SV *sv = kSVOP->op_sv;
9246             if ((!SvPOK(sv) || SvNIOKp(sv)) && SvOK(sv) && !SvROK(sv)) {
9247                 sv = newSV(0);
9248                 sv_copypv(sv, kSVOP->op_sv);
9249                 SvREFCNT_dec_NN(kSVOP->op_sv);
9250                 kSVOP->op_sv = sv;
9251             }
9252             if (SvOK(sv)) fbm_compile(sv, 0);
9253             TAINT_set(save_taint);
9254 #ifdef NO_TAINT_SUPPORT
9255             PERL_UNUSED_VAR(save_taint);
9256 #endif
9257         }
9258     }
9259     return ck_fun(o);
9260 }
9261
9262 OP *
9263 Perl_ck_lfun(pTHX_ OP *o)
9264 {
9265     const OPCODE type = o->op_type;
9266
9267     PERL_ARGS_ASSERT_CK_LFUN;
9268
9269     return modkids(ck_fun(o), type);
9270 }
9271
9272 OP *
9273 Perl_ck_defined(pTHX_ OP *o)            /* 19990527 MJD */
9274 {
9275     PERL_ARGS_ASSERT_CK_DEFINED;
9276
9277     if ((o->op_flags & OPf_KIDS)) {
9278         switch (cUNOPo->op_first->op_type) {
9279         case OP_RV2AV:
9280         case OP_PADAV:
9281         case OP_AASSIGN:                /* Is this a good idea? */
9282             Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
9283                            "defined(@array) is deprecated");
9284             Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
9285                            "\t(Maybe you should just omit the defined()?)\n");
9286         break;
9287         case OP_RV2HV:
9288         case OP_PADHV:
9289             Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
9290                            "defined(%%hash) is deprecated");
9291             Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED),
9292                            "\t(Maybe you should just omit the defined()?)\n");
9293             break;
9294         default:
9295             /* no warning */
9296             break;
9297         }
9298     }
9299     return ck_rfun(o);
9300 }
9301
9302 OP *
9303 Perl_ck_readline(pTHX_ OP *o)
9304 {
9305     PERL_ARGS_ASSERT_CK_READLINE;
9306
9307     if (o->op_flags & OPf_KIDS) {
9308          OP *kid = cLISTOPo->op_first;
9309          if (kid->op_type == OP_RV2GV) kid->op_private |= OPpALLOW_FAKE;
9310     }
9311     else {
9312         OP * const newop
9313             = newUNOP(OP_READLINE, 0, newGVOP(OP_GV, 0, PL_argvgv));
9314 #ifdef PERL_MAD
9315         op_getmad(o,newop,'O');
9316 #else
9317         op_free(o);
9318 #endif
9319         return newop;
9320     }
9321     return o;
9322 }
9323
9324 OP *
9325 Perl_ck_rfun(pTHX_ OP *o)
9326 {
9327     const OPCODE type = o->op_type;
9328
9329     PERL_ARGS_ASSERT_CK_RFUN;
9330
9331     return refkids(ck_fun(o), type);
9332 }
9333
9334 OP *
9335 Perl_ck_listiob(pTHX_ OP *o)
9336 {
9337     OP *kid;
9338
9339     PERL_ARGS_ASSERT_CK_LISTIOB;
9340
9341     kid = cLISTOPo->op_first;
9342     if (!kid) {
9343         o = force_list(o);
9344         kid = cLISTOPo->op_first;
9345     }
9346     if (kid->op_type == OP_PUSHMARK)
9347         kid = kid->op_sibling;
9348     if (kid && o->op_flags & OPf_STACKED)
9349         kid = kid->op_sibling;
9350     else if (kid && !kid->op_sibling) {         /* print HANDLE; */
9351         if (kid->op_type == OP_CONST && kid->op_private & OPpCONST_BARE
9352          && !kid->op_folded) {
9353             o->op_flags |= OPf_STACKED; /* make it a filehandle */
9354             kid = newUNOP(OP_RV2GV, OPf_REF, scalar(kid));
9355             cLISTOPo->op_first->op_sibling = kid;
9356             cLISTOPo->op_last = kid;
9357             kid = kid->op_sibling;
9358         }
9359     }
9360
9361     if (!kid)
9362         op_append_elem(o->op_type, o, newDEFSVOP());
9363
9364     if (o->op_type == OP_PRTF) return modkids(listkids(o), OP_PRTF);
9365     return listkids(o);
9366 }
9367
9368 OP *
9369 Perl_ck_smartmatch(pTHX_ OP *o)
9370 {
9371     dVAR;
9372     PERL_ARGS_ASSERT_CK_SMARTMATCH;
9373     if (0 == (o->op_flags & OPf_SPECIAL)) {
9374         OP *first  = cBINOPo->op_first;
9375         OP *second = first->op_sibling;
9376
9377         /* Implicitly take a reference to an array or hash */
9378         first->op_sibling = NULL;
9379         first = cBINOPo->op_first = ref_array_or_hash(first);
9380         second = first->op_sibling = ref_array_or_hash(second);
9381
9382         /* Implicitly take a reference to a regular expression */
9383         if (first->op_type == OP_MATCH) {
9384             first->op_type = OP_QR;
9385             first->op_ppaddr = PL_ppaddr[OP_QR];
9386         }
9387         if (second->op_type == OP_MATCH) {
9388             second->op_type = OP_QR;
9389             second->op_ppaddr = PL_ppaddr[OP_QR];
9390         }
9391     }
9392
9393     return o;
9394 }
9395
9396
9397 OP *
9398 Perl_ck_sassign(pTHX_ OP *o)
9399 {
9400     dVAR;
9401     OP * const kid = cLISTOPo->op_first;
9402
9403     PERL_ARGS_ASSERT_CK_SASSIGN;
9404
9405     /* has a disposable target? */
9406     if ((PL_opargs[kid->op_type] & OA_TARGLEX)
9407         && !(kid->op_flags & OPf_STACKED)
9408         /* Cannot steal the second time! */
9409         && !(kid->op_private & OPpTARGET_MY)
9410         /* Keep the full thing for madskills */
9411         && !PL_madskills
9412         )
9413     {
9414         OP * const kkid = kid->op_sibling;
9415
9416         /* Can just relocate the target. */
9417         if (kkid && kkid->op_type == OP_PADSV
9418             && !(kkid->op_private & OPpLVAL_INTRO))
9419         {
9420             kid->op_targ = kkid->op_targ;
9421             kkid->op_targ = 0;
9422             /* Now we do not need PADSV and SASSIGN. */
9423             kid->op_sibling = o->op_sibling;    /* NULL */
9424             cLISTOPo->op_first = NULL;
9425             op_free(o);
9426             op_free(kkid);
9427             kid->op_private |= OPpTARGET_MY;    /* Used for context settings */
9428             return kid;
9429         }
9430     }
9431     if (kid->op_sibling) {
9432         OP *kkid = kid->op_sibling;
9433         /* For state variable assignment, kkid is a list op whose op_last
9434            is a padsv. */
9435         if ((kkid->op_type == OP_PADSV ||
9436              (kkid->op_type == OP_LIST &&
9437               (kkid = cLISTOPx(kkid)->op_last)->op_type == OP_PADSV
9438              )
9439             )
9440                 && (kkid->op_private & OPpLVAL_INTRO)
9441                 && SvPAD_STATE(*av_fetch(PL_comppad_name, kkid->op_targ, FALSE))) {
9442             const PADOFFSET target = kkid->op_targ;
9443             OP *const other = newOP(OP_PADSV,
9444                                     kkid->op_flags
9445                                     | ((kkid->op_private & ~OPpLVAL_INTRO) << 8));
9446             OP *const first = newOP(OP_NULL, 0);
9447             OP *const nullop = newCONDOP(0, first, o, other);
9448             OP *const condop = first->op_next;
9449             /* hijacking PADSTALE for uninitialized state variables */
9450             SvPADSTALE_on(PAD_SVl(target));
9451
9452             condop->op_type = OP_ONCE;
9453             condop->op_ppaddr = PL_ppaddr[OP_ONCE];
9454             condop->op_targ = target;
9455             other->op_targ = target;
9456
9457             /* Because we change the type of the op here, we will skip the
9458                assignment binop->op_last = binop->op_first->op_sibling; at the
9459                end of Perl_newBINOP(). So need to do it here. */
9460             cBINOPo->op_last = cBINOPo->op_first->op_sibling;
9461
9462             return nullop;
9463         }
9464     }
9465     return o;
9466 }
9467
9468 OP *
9469 Perl_ck_match(pTHX_ OP *o)
9470 {
9471     dVAR;
9472
9473     PERL_ARGS_ASSERT_CK_MATCH;
9474
9475     if (o->op_type != OP_QR && PL_compcv) {
9476         const PADOFFSET offset = pad_findmy_pvs("$_", 0);
9477         if (offset != NOT_IN_PAD && !(PAD_COMPNAME_FLAGS_isOUR(offset))) {
9478             o->op_targ = offset;
9479             o->op_private |= OPpTARGET_MY;
9480         }
9481     }
9482     if (o->op_type == OP_MATCH || o->op_type == OP_QR)
9483         o->op_private |= OPpRUNTIME;
9484     return o;
9485 }
9486
9487 OP *
9488 Perl_ck_method(pTHX_ OP *o)
9489 {
9490     OP * const kid = cUNOPo->op_first;
9491
9492     PERL_ARGS_ASSERT_CK_METHOD;
9493
9494     if (kid->op_type == OP_CONST) {
9495         SV* sv = kSVOP->op_sv;
9496         const char * const method = SvPVX_const(sv);
9497         if (!(strchr(method, ':') || strchr(method, '\''))) {
9498             OP *cmop;
9499             if (!SvIsCOW_shared_hash(sv)) {
9500                 sv = newSVpvn_share(method, SvUTF8(sv) ? -(I32)SvCUR(sv) : (I32)SvCUR(sv), 0);
9501             }
9502             else {
9503                 kSVOP->op_sv = NULL;
9504             }
9505             cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
9506 #ifdef PERL_MAD
9507             op_getmad(o,cmop,'O');
9508 #else
9509             op_free(o);
9510 #endif
9511             return cmop;
9512         }
9513     }
9514     return o;
9515 }
9516
9517 OP *
9518 Perl_ck_null(pTHX_ OP *o)
9519 {
9520     PERL_ARGS_ASSERT_CK_NULL;
9521     PERL_UNUSED_CONTEXT;
9522     return o;
9523 }
9524
9525 OP *
9526 Perl_ck_open(pTHX_ OP *o)
9527 {
9528     dVAR;
9529     HV * const table = GvHV(PL_hintgv);
9530
9531     PERL_ARGS_ASSERT_CK_OPEN;
9532
9533     if (table) {
9534         SV **svp = hv_fetchs(table, "open_IN", FALSE);
9535         if (svp && *svp) {
9536             STRLEN len = 0;
9537             const char *d = SvPV_const(*svp, len);
9538             const I32 mode = mode_from_discipline(d, len);
9539             if (mode & O_BINARY)
9540                 o->op_private |= OPpOPEN_IN_RAW;
9541             else if (mode & O_TEXT)
9542                 o->op_private |= OPpOPEN_IN_CRLF;
9543         }
9544
9545         svp = hv_fetchs(table, "open_OUT", FALSE);
9546         if (svp && *svp) {
9547             STRLEN len = 0;
9548             const char *d = SvPV_const(*svp, len);
9549             const I32 mode = mode_from_discipline(d, len);
9550             if (mode & O_BINARY)
9551                 o->op_private |= OPpOPEN_OUT_RAW;
9552             else if (mode & O_TEXT)
9553                 o->op_private |= OPpOPEN_OUT_CRLF;
9554         }
9555     }
9556     if (o->op_type == OP_BACKTICK) {
9557         if (!(o->op_flags & OPf_KIDS)) {
9558             OP * const newop = newUNOP(OP_BACKTICK, 0, newDEFSVOP());
9559 #ifdef PERL_MAD
9560             op_getmad(o,newop,'O');
9561 #else
9562             op_free(o);
9563 #endif
9564             return newop;
9565         }
9566         return o;
9567     }
9568     {
9569          /* In case of three-arg dup open remove strictness
9570           * from the last arg if it is a bareword. */
9571          OP * const first = cLISTOPx(o)->op_first; /* The pushmark. */
9572          OP * const last  = cLISTOPx(o)->op_last;  /* The bareword. */
9573          OP *oa;
9574          const char *mode;
9575
9576          if ((last->op_type == OP_CONST) &&             /* The bareword. */
9577              (last->op_private & OPpCONST_BARE) &&
9578              (last->op_private & OPpCONST_STRICT) &&
9579              (oa = first->op_sibling) &&                /* The fh. */
9580              (oa = oa->op_sibling) &&                   /* The mode. */
9581              (oa->op_type == OP_CONST) &&
9582              SvPOK(((SVOP*)oa)->op_sv) &&
9583              (mode = SvPVX_const(((SVOP*)oa)->op_sv)) &&
9584              mode[0] == '>' && mode[1] == '&' &&        /* A dup open. */
9585              (last == oa->op_sibling))                  /* The bareword. */
9586               last->op_private &= ~OPpCONST_STRICT;
9587     }
9588     return ck_fun(o);
9589 }
9590
9591 OP *
9592 Perl_ck_repeat(pTHX_ OP *o)
9593 {
9594     PERL_ARGS_ASSERT_CK_REPEAT;
9595
9596     if (cBINOPo->op_first->op_flags & OPf_PARENS) {
9597         o->op_private |= OPpREPEAT_DOLIST;
9598         cBINOPo->op_first = force_list(cBINOPo->op_first);
9599     }
9600     else
9601         scalar(o);
9602     return o;
9603 }
9604
9605 OP *
9606 Perl_ck_require(pTHX_ OP *o)
9607 {
9608     dVAR;
9609     GV* gv = NULL;
9610
9611     PERL_ARGS_ASSERT_CK_REQUIRE;
9612
9613     if (o->op_flags & OPf_KIDS) {       /* Shall we supply missing .pm? */
9614         SVOP * const kid = (SVOP*)cUNOPo->op_first;
9615
9616         if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
9617             SV * const sv = kid->op_sv;
9618             U32 was_readonly = SvREADONLY(sv);
9619             char *s;
9620             STRLEN len;
9621             const char *end;
9622
9623             if (was_readonly) {
9624                     SvREADONLY_off(sv);
9625             }
9626             if (SvIsCOW(sv)) sv_force_normal_flags(sv, 0);
9627
9628             s = SvPVX(sv);
9629             len = SvCUR(sv);
9630             end = s + len;
9631             for (; s < end; s++) {
9632                 if (*s == ':' && s[1] == ':') {
9633                     *s = '/';
9634                     Move(s+2, s+1, end - s - 1, char);
9635                     --end;
9636                 }
9637             }
9638             SvEND_set(sv, end);
9639             sv_catpvs(sv, ".pm");
9640             SvFLAGS(sv) |= was_readonly;
9641         }
9642     }
9643
9644     if (!(o->op_flags & OPf_SPECIAL)) { /* Wasn't written as CORE::require */
9645         /* handle override, if any */
9646         gv = gv_fetchpvs("require", GV_NOTQUAL, SVt_PVCV);
9647         if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
9648             GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "require", FALSE);
9649             gv = gvp ? *gvp : NULL;
9650         }
9651     }
9652
9653     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
9654         OP *kid, *newop;
9655         if (o->op_flags & OPf_KIDS) {
9656             kid = cUNOPo->op_first;
9657             cUNOPo->op_first = NULL;
9658         }
9659         else {
9660             kid = newDEFSVOP();
9661         }
9662 #ifndef PERL_MAD
9663         op_free(o);
9664 #endif
9665         newop = newUNOP(OP_ENTERSUB, OPf_STACKED,
9666                                 op_append_elem(OP_LIST, kid,
9667                                             scalar(newUNOP(OP_RV2CV, 0,
9668                                                            newGVOP(OP_GV, 0,
9669                                                                    gv)))));
9670         op_getmad(o,newop,'O');
9671         return newop;
9672     }
9673
9674     return scalar(ck_fun(o));
9675 }
9676
9677 OP *
9678 Perl_ck_return(pTHX_ OP *o)
9679 {
9680     dVAR;
9681     OP *kid;
9682
9683     PERL_ARGS_ASSERT_CK_RETURN;
9684
9685     kid = cLISTOPo->op_first->op_sibling;
9686     if (CvLVALUE(PL_compcv)) {
9687         for (; kid; kid = kid->op_sibling)
9688             op_lvalue(kid, OP_LEAVESUBLV);
9689     }
9690
9691     return o;
9692 }
9693
9694 OP *
9695 Perl_ck_select(pTHX_ OP *o)
9696 {
9697     dVAR;
9698     OP* kid;
9699
9700     PERL_ARGS_ASSERT_CK_SELECT;
9701
9702     if (o->op_flags & OPf_KIDS) {
9703         kid = cLISTOPo->op_first->op_sibling;   /* get past pushmark */
9704         if (kid && kid->op_sibling) {
9705             o->op_type = OP_SSELECT;
9706             o->op_ppaddr = PL_ppaddr[OP_SSELECT];
9707             o = ck_fun(o);
9708             return fold_constants(op_integerize(op_std_init(o)));
9709         }
9710     }
9711     o = ck_fun(o);
9712     kid = cLISTOPo->op_first->op_sibling;    /* get past pushmark */
9713     if (kid && kid->op_type == OP_RV2GV)
9714         kid->op_private &= ~HINT_STRICT_REFS;
9715     return o;
9716 }
9717
9718 OP *
9719 Perl_ck_shift(pTHX_ OP *o)
9720 {
9721     dVAR;
9722     const I32 type = o->op_type;
9723
9724     PERL_ARGS_ASSERT_CK_SHIFT;
9725
9726     if (!(o->op_flags & OPf_KIDS)) {
9727         OP *argop;
9728
9729         if (!CvUNIQUE(PL_compcv)) {
9730             o->op_flags |= OPf_SPECIAL;
9731             return o;
9732         }
9733
9734         argop = newUNOP(OP_RV2AV, 0, scalar(newGVOP(OP_GV, 0, PL_argvgv)));
9735 #ifdef PERL_MAD
9736         {
9737             OP * const oldo = o;
9738             o = newUNOP(type, 0, scalar(argop));
9739             op_getmad(oldo,o,'O');
9740             return o;
9741         }
9742 #else
9743         op_free(o);
9744         return newUNOP(type, 0, scalar(argop));
9745 #endif
9746     }
9747     return scalar(ck_fun(o));
9748 }
9749
9750 OP *
9751 Perl_ck_sort(pTHX_ OP *o)
9752 {
9753     dVAR;
9754     OP *firstkid;
9755     OP *kid;
9756     HV * const hinthv =
9757         PL_hints & HINT_LOCALIZE_HH ? GvHV(PL_hintgv) : NULL;
9758     U8 stacked;
9759
9760     PERL_ARGS_ASSERT_CK_SORT;
9761
9762     if (hinthv) {
9763             SV ** const svp = hv_fetchs(hinthv, "sort", FALSE);
9764             if (svp) {
9765                 const I32 sorthints = (I32)SvIV(*svp);
9766                 if ((sorthints & HINT_SORT_QUICKSORT) != 0)
9767                     o->op_private |= OPpSORT_QSORT;
9768                 if ((sorthints & HINT_SORT_STABLE) != 0)
9769                     o->op_private |= OPpSORT_STABLE;
9770             }
9771     }
9772
9773     if (o->op_flags & OPf_STACKED)
9774         simplify_sort(o);
9775     firstkid = cLISTOPo->op_first->op_sibling;          /* get past pushmark */
9776     if ((stacked = o->op_flags & OPf_STACKED)) {        /* may have been cleared */
9777         OP *kid = cUNOPx(firstkid)->op_first;           /* get past null */
9778
9779         if (kid->op_type == OP_SCOPE || kid->op_type == OP_LEAVE) {
9780             LINKLIST(kid);
9781             if (kid->op_type == OP_LEAVE)
9782                     op_null(kid);                       /* wipe out leave */
9783             /* Prevent execution from escaping out of the sort block. */
9784             kid->op_next = 0;
9785
9786             /* provide scalar context for comparison function/block */
9787             kid = scalar(firstkid);
9788             kid->op_next = kid;
9789             o->op_flags |= OPf_SPECIAL;
9790         }
9791
9792         firstkid = firstkid->op_sibling;
9793     }
9794
9795     for (kid = firstkid; kid; kid = kid->op_sibling) {
9796         /* provide list context for arguments */
9797         list(kid);
9798         if (stacked)
9799             op_lvalue(kid, OP_GREPSTART);
9800     }
9801
9802     return o;
9803 }
9804
9805 STATIC void
9806 S_simplify_sort(pTHX_ OP *o)
9807 {
9808     dVAR;
9809     OP *kid = cLISTOPo->op_first->op_sibling;   /* get past pushmark */
9810     OP *k;
9811     int descending;
9812     GV *gv;
9813     const char *gvname;
9814     bool have_scopeop;
9815
9816     PERL_ARGS_ASSERT_SIMPLIFY_SORT;
9817
9818     GvMULTI_on(gv_fetchpvs("a", GV_ADD|GV_NOTQUAL, SVt_PV));
9819     GvMULTI_on(gv_fetchpvs("b", GV_ADD|GV_NOTQUAL, SVt_PV));
9820     kid = kUNOP->op_first;                              /* get past null */
9821     if (!(have_scopeop = kid->op_type == OP_SCOPE)
9822      && kid->op_type != OP_LEAVE)
9823         return;
9824     kid = kLISTOP->op_last;                             /* get past scope */
9825     switch(kid->op_type) {
9826         case OP_NCMP:
9827         case OP_I_NCMP:
9828         case OP_SCMP:
9829             if (!have_scopeop) goto padkids;
9830             break;
9831         default:
9832             return;
9833     }
9834     k = kid;                                            /* remember this node*/
9835     if (kBINOP->op_first->op_type != OP_RV2SV
9836      || kBINOP->op_last ->op_type != OP_RV2SV)
9837     {
9838         /*
9839            Warn about my($a) or my($b) in a sort block, *if* $a or $b is
9840            then used in a comparison.  This catches most, but not
9841            all cases.  For instance, it catches
9842                sort { my($a); $a <=> $b }
9843            but not
9844                sort { my($a); $a < $b ? -1 : $a == $b ? 0 : 1; }
9845            (although why you'd do that is anyone's guess).
9846         */
9847
9848        padkids:
9849         if (!ckWARN(WARN_SYNTAX)) return;
9850         kid = kBINOP->op_first;
9851         do {
9852             if (kid->op_type == OP_PADSV) {
9853                 SV * const name = AvARRAY(PL_comppad_name)[kid->op_targ];
9854                 if (SvCUR(name) == 2 && *SvPVX(name) == '$'
9855                  && (SvPVX(name)[1] == 'a' || SvPVX(name)[1] == 'b'))
9856                     /* diag_listed_as: "my %s" used in sort comparison */
9857                     Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
9858                                      "\"%s %s\" used in sort comparison",
9859                                       SvPAD_STATE(name) ? "state" : "my",
9860                                       SvPVX(name));
9861             }
9862         } while ((kid = kid->op_sibling));
9863         return;
9864     }
9865     kid = kBINOP->op_first;                             /* get past cmp */
9866     if (kUNOP->op_first->op_type != OP_GV)
9867         return;
9868     kid = kUNOP->op_first;                              /* get past rv2sv */
9869     gv = kGVOP_gv;
9870     if (GvSTASH(gv) != PL_curstash)
9871         return;
9872     gvname = GvNAME(gv);
9873     if (*gvname == 'a' && gvname[1] == '\0')
9874         descending = 0;
9875     else if (*gvname == 'b' && gvname[1] == '\0')
9876         descending = 1;
9877     else
9878         return;
9879
9880     kid = k;                                            /* back to cmp */
9881     /* already checked above that it is rv2sv */
9882     kid = kBINOP->op_last;                              /* down to 2nd arg */
9883     if (kUNOP->op_first->op_type != OP_GV)
9884         return;
9885     kid = kUNOP->op_first;                              /* get past rv2sv */
9886     gv = kGVOP_gv;
9887     if (GvSTASH(gv) != PL_curstash)
9888         return;
9889     gvname = GvNAME(gv);
9890     if ( descending
9891          ? !(*gvname == 'a' && gvname[1] == '\0')
9892          : !(*gvname == 'b' && gvname[1] == '\0'))
9893         return;
9894     o->op_flags &= ~(OPf_STACKED | OPf_SPECIAL);
9895     if (descending)
9896         o->op_private |= OPpSORT_DESCEND;
9897     if (k->op_type == OP_NCMP)
9898         o->op_private |= OPpSORT_NUMERIC;
9899     if (k->op_type == OP_I_NCMP)
9900         o->op_private |= OPpSORT_NUMERIC | OPpSORT_INTEGER;
9901     kid = cLISTOPo->op_first->op_sibling;
9902     cLISTOPo->op_first->op_sibling = kid->op_sibling; /* bypass old block */
9903 #ifdef PERL_MAD
9904     op_getmad(kid,o,'S');                             /* then delete it */
9905 #else
9906     op_free(kid);                                     /* then delete it */
9907 #endif
9908 }
9909
9910 OP *
9911 Perl_ck_split(pTHX_ OP *o)
9912 {
9913     dVAR;
9914     OP *kid;
9915
9916     PERL_ARGS_ASSERT_CK_SPLIT;
9917
9918     if (o->op_flags & OPf_STACKED)
9919         return no_fh_allowed(o);
9920
9921     kid = cLISTOPo->op_first;
9922     if (kid->op_type != OP_NULL)
9923         Perl_croak(aTHX_ "panic: ck_split, type=%u", (unsigned) kid->op_type);
9924     kid = kid->op_sibling;
9925     op_free(cLISTOPo->op_first);
9926     if (kid)
9927         cLISTOPo->op_first = kid;
9928     else {
9929         cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvs(" "));
9930         cLISTOPo->op_last = kid; /* There was only one element previously */
9931     }
9932
9933     if (kid->op_type != OP_MATCH || kid->op_flags & OPf_STACKED) {
9934         OP * const sibl = kid->op_sibling;
9935         kid->op_sibling = 0;
9936         kid = pmruntime( newPMOP(OP_MATCH, OPf_SPECIAL), kid, 0, 0); /* OPf_SPECIAL is used to trigger split " " behavior */
9937         if (cLISTOPo->op_first == cLISTOPo->op_last)
9938             cLISTOPo->op_last = kid;
9939         cLISTOPo->op_first = kid;
9940         kid->op_sibling = sibl;
9941     }
9942
9943     kid->op_type = OP_PUSHRE;
9944     kid->op_ppaddr = PL_ppaddr[OP_PUSHRE];
9945     scalar(kid);
9946     if (((PMOP *)kid)->op_pmflags & PMf_GLOBAL) {
9947       Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP),
9948                      "Use of /g modifier is meaningless in split");
9949     }
9950
9951     if (!kid->op_sibling)
9952         op_append_elem(OP_SPLIT, o, newDEFSVOP());
9953
9954     kid = kid->op_sibling;
9955     scalar(kid);
9956
9957     if (!kid->op_sibling)
9958     {
9959         op_append_elem(OP_SPLIT, o, newSVOP(OP_CONST, 0, newSViv(0)));
9960         o->op_private |= OPpSPLIT_IMPLIM;
9961     }
9962     assert(kid->op_sibling);
9963
9964     kid = kid->op_sibling;
9965     scalar(kid);
9966
9967     if (kid->op_sibling)
9968         return too_many_arguments_pv(o,OP_DESC(o), 0);
9969
9970     return o;
9971 }
9972
9973 OP *
9974 Perl_ck_join(pTHX_ OP *o)
9975 {
9976     const OP * const kid = cLISTOPo->op_first->op_sibling;
9977
9978     PERL_ARGS_ASSERT_CK_JOIN;
9979
9980     if (kid && kid->op_type == OP_MATCH) {
9981         if (ckWARN(WARN_SYNTAX)) {
9982             const REGEXP *re = PM_GETRE(kPMOP);
9983             const SV *msg = re
9984                     ? newSVpvn_flags( RX_PRECOMP_const(re), RX_PRELEN(re),
9985                                             SVs_TEMP | ( RX_UTF8(re) ? SVf_UTF8 : 0 ) )
9986                     : newSVpvs_flags( "STRING", SVs_TEMP );
9987             Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
9988                         "/%"SVf"/ should probably be written as \"%"SVf"\"",
9989                         SVfARG(msg), SVfARG(msg));
9990         }
9991     }
9992     return ck_fun(o);
9993 }
9994
9995 /*
9996 =for apidoc Am|CV *|rv2cv_op_cv|OP *cvop|U32 flags
9997
9998 Examines an op, which is expected to identify a subroutine at runtime,
9999 and attempts to determine at compile time which subroutine it identifies.
10000 This is normally used during Perl compilation to determine whether
10001 a prototype can be applied to a function call.  I<cvop> is the op
10002 being considered, normally an C<rv2cv> op.  A pointer to the identified
10003 subroutine is returned, if it could be determined statically, and a null
10004 pointer is returned if it was not possible to determine statically.
10005
10006 Currently, the subroutine can be identified statically if the RV that the
10007 C<rv2cv> is to operate on is provided by a suitable C<gv> or C<const> op.
10008 A C<gv> op is suitable if the GV's CV slot is populated.  A C<const> op is
10009 suitable if the constant value must be an RV pointing to a CV.  Details of
10010 this process may change in future versions of Perl.  If the C<rv2cv> op
10011 has the C<OPpENTERSUB_AMPER> flag set then no attempt is made to identify
10012 the subroutine statically: this flag is used to suppress compile-time
10013 magic on a subroutine call, forcing it to use default runtime behaviour.
10014
10015 If I<flags> has the bit C<RV2CVOPCV_MARK_EARLY> set, then the handling
10016 of a GV reference is modified.  If a GV was examined and its CV slot was
10017 found to be empty, then the C<gv> op has the C<OPpEARLY_CV> flag set.
10018 If the op is not optimised away, and the CV slot is later populated with
10019 a subroutine having a prototype, that flag eventually triggers the warning
10020 "called too early to check prototype".
10021
10022 If I<flags> has the bit C<RV2CVOPCV_RETURN_NAME_GV> set, then instead
10023 of returning a pointer to the subroutine it returns a pointer to the
10024 GV giving the most appropriate name for the subroutine in this context.
10025 Normally this is just the C<CvGV> of the subroutine, but for an anonymous
10026 (C<CvANON>) subroutine that is referenced through a GV it will be the
10027 referencing GV.  The resulting C<GV*> is cast to C<CV*> to be returned.
10028 A null pointer is returned as usual if there is no statically-determinable
10029 subroutine.
10030
10031 =cut
10032 */
10033
10034 /* shared by toke.c:yylex */
10035 CV *
10036 Perl_find_lexical_cv(pTHX_ PADOFFSET off)
10037 {
10038     PADNAME *name = PAD_COMPNAME(off);
10039     CV *compcv = PL_compcv;
10040     while (PadnameOUTER(name)) {
10041         assert(PARENT_PAD_INDEX(name));
10042         compcv = CvOUTSIDE(PL_compcv);
10043         name = PadlistNAMESARRAY(CvPADLIST(compcv))
10044                 [off = PARENT_PAD_INDEX(name)];
10045     }
10046     assert(!PadnameIsOUR(name));
10047     if (!PadnameIsSTATE(name) && SvMAGICAL(name)) {
10048         MAGIC * mg = mg_find(name, PERL_MAGIC_proto);
10049         assert(mg);
10050         assert(mg->mg_obj);
10051         return (CV *)mg->mg_obj;
10052     }
10053     return (CV *)AvARRAY(PadlistARRAY(CvPADLIST(compcv))[1])[off];
10054 }
10055
10056 CV *
10057 Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags)
10058 {
10059     OP *rvop;
10060     CV *cv;
10061     GV *gv;
10062     PERL_ARGS_ASSERT_RV2CV_OP_CV;
10063     if (flags & ~(RV2CVOPCV_MARK_EARLY|RV2CVOPCV_RETURN_NAME_GV))
10064         Perl_croak(aTHX_ "panic: rv2cv_op_cv bad flags %x", (unsigned)flags);
10065     if (cvop->op_type != OP_RV2CV)
10066         return NULL;
10067     if (cvop->op_private & OPpENTERSUB_AMPER)
10068         return NULL;
10069     if (!(cvop->op_flags & OPf_KIDS))
10070         return NULL;
10071     rvop = cUNOPx(cvop)->op_first;
10072     switch (rvop->op_type) {
10073         case OP_GV: {
10074             gv = cGVOPx_gv(rvop);
10075             cv = GvCVu(gv);
10076             if (!cv) {
10077                 if (flags & RV2CVOPCV_MARK_EARLY)
10078                     rvop->op_private |= OPpEARLY_CV;
10079                 return NULL;
10080             }
10081         } break;
10082         case OP_CONST: {
10083             SV *rv = cSVOPx_sv(rvop);
10084             if (!SvROK(rv))
10085                 return NULL;
10086             cv = (CV*)SvRV(rv);
10087             gv = NULL;
10088         } break;
10089         case OP_PADCV: {
10090             cv = find_lexical_cv(rvop->op_targ);
10091             gv = NULL;
10092         } break;
10093         default: {
10094             return NULL;
10095         } break;
10096     }
10097     if (SvTYPE((SV*)cv) != SVt_PVCV)
10098         return NULL;
10099     if (flags & RV2CVOPCV_RETURN_NAME_GV) {
10100         if (!CvANON(cv) || !gv)
10101             gv = CvGV(cv);
10102         return (CV*)gv;
10103     } else {
10104         return cv;
10105     }
10106 }
10107
10108 /*
10109 =for apidoc Am|OP *|ck_entersub_args_list|OP *entersubop
10110
10111 Performs the default fixup of the arguments part of an C<entersub>
10112 op tree.  This consists of applying list context to each of the
10113 argument ops.  This is the standard treatment used on a call marked
10114 with C<&>, or a method call, or a call through a subroutine reference,
10115 or any other call where the callee can't be identified at compile time,
10116 or a call where the callee has no prototype.
10117
10118 =cut
10119 */
10120
10121 OP *
10122 Perl_ck_entersub_args_list(pTHX_ OP *entersubop)
10123 {
10124     OP *aop;
10125     PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST;
10126     aop = cUNOPx(entersubop)->op_first;
10127     if (!aop->op_sibling)
10128         aop = cUNOPx(aop)->op_first;
10129     for (aop = aop->op_sibling; aop->op_sibling; aop = aop->op_sibling) {
10130         if (!(PL_madskills && aop->op_type == OP_STUB)) {
10131             list(aop);
10132             op_lvalue(aop, OP_ENTERSUB);
10133         }
10134     }
10135     return entersubop;
10136 }
10137
10138 /*
10139 =for apidoc Am|OP *|ck_entersub_args_proto|OP *entersubop|GV *namegv|SV *protosv
10140
10141 Performs the fixup of the arguments part of an C<entersub> op tree
10142 based on a subroutine prototype.  This makes various modifications to
10143 the argument ops, from applying context up to inserting C<refgen> ops,
10144 and checking the number and syntactic types of arguments, as directed by
10145 the prototype.  This is the standard treatment used on a subroutine call,
10146 not marked with C<&>, where the callee can be identified at compile time
10147 and has a prototype.
10148
10149 I<protosv> supplies the subroutine prototype to be applied to the call.
10150 It may be a normal defined scalar, of which the string value will be used.
10151 Alternatively, for convenience, it may be a subroutine object (a C<CV*>
10152 that has been cast to C<SV*>) which has a prototype.  The prototype
10153 supplied, in whichever form, does not need to match the actual callee
10154 referenced by the op tree.
10155
10156 If the argument ops disagree with the prototype, for example by having
10157 an unacceptable number of arguments, a valid op tree is returned anyway.
10158 The error is reflected in the parser state, normally resulting in a single
10159 exception at the top level of parsing which covers all the compilation
10160 errors that occurred.  In the error message, the callee is referred to
10161 by the name defined by the I<namegv> parameter.
10162
10163 =cut
10164 */
10165
10166 OP *
10167 Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv)
10168 {
10169     STRLEN proto_len;
10170     const char *proto, *proto_end;
10171     OP *aop, *prev, *cvop;
10172     int optional = 0;
10173     I32 arg = 0;
10174     I32 contextclass = 0;
10175     const char *e = NULL;
10176     PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO;
10177     if (SvTYPE(protosv) == SVt_PVCV ? !SvPOK(protosv) : !SvOK(protosv))
10178         Perl_croak(aTHX_ "panic: ck_entersub_args_proto CV with no proto, "
10179                    "flags=%lx", (unsigned long) SvFLAGS(protosv));
10180     if (SvTYPE(protosv) == SVt_PVCV)
10181          proto = CvPROTO(protosv), proto_len = CvPROTOLEN(protosv);
10182     else proto = SvPV(protosv, proto_len);
10183     proto = S_strip_spaces(aTHX_ proto, &proto_len);
10184     proto_end = proto + proto_len;
10185     aop = cUNOPx(entersubop)->op_first;
10186     if (!aop->op_sibling)
10187         aop = cUNOPx(aop)->op_first;
10188     prev = aop;
10189     aop = aop->op_sibling;
10190     for (cvop = aop; cvop->op_sibling; cvop = cvop->op_sibling) ;
10191     while (aop != cvop) {
10192         OP* o3;
10193         if (PL_madskills && aop->op_type == OP_STUB) {
10194             aop = aop->op_sibling;
10195             continue;
10196         }
10197         if (PL_madskills && aop->op_type == OP_NULL)
10198             o3 = ((UNOP*)aop)->op_first;
10199         else
10200             o3 = aop;
10201
10202         if (proto >= proto_end)
10203             return too_many_arguments_sv(entersubop, gv_ename(namegv), 0);
10204
10205         switch (*proto) {
10206             case ';':
10207                 optional = 1;
10208                 proto++;
10209                 continue;
10210             case '_':
10211                 /* _ must be at the end */
10212                 if (proto[1] && !strchr(";@%", proto[1]))
10213                     goto oops;
10214             case '$':
10215                 proto++;
10216                 arg++;
10217                 scalar(aop);
10218                 break;
10219             case '%':
10220             case '@':
10221                 list(aop);
10222                 arg++;
10223                 break;
10224             case '&':
10225                 proto++;
10226                 arg++;
10227                 if (o3->op_type != OP_REFGEN && o3->op_type != OP_UNDEF)
10228                     bad_type_gv(arg,
10229                             arg == 1 ? "block or sub {}" : "sub {}",
10230                             namegv, 0, o3);
10231                 break;
10232             case '*':
10233                 /* '*' allows any scalar type, including bareword */
10234                 proto++;
10235                 arg++;
10236                 if (o3->op_type == OP_RV2GV)
10237                     goto wrapref;       /* autoconvert GLOB -> GLOBref */
10238                 else if (o3->op_type == OP_CONST)
10239                     o3->op_private &= ~OPpCONST_STRICT;
10240                 else if (o3->op_type == OP_ENTERSUB) {
10241                     /* accidental subroutine, revert to bareword */
10242                     OP *gvop = ((UNOP*)o3)->op_first;
10243                     if (gvop && gvop->op_type == OP_NULL) {
10244                         gvop = ((UNOP*)gvop)->op_first;
10245                         if (gvop) {
10246                             for (; gvop->op_sibling; gvop = gvop->op_sibling)
10247                                 ;
10248                             if (gvop &&
10249                                     (gvop->op_private & OPpENTERSUB_NOPAREN) &&
10250                                     (gvop = ((UNOP*)gvop)->op_first) &&
10251                                     gvop->op_type == OP_GV)
10252                             {
10253                                 GV * const gv = cGVOPx_gv(gvop);
10254                                 OP * const sibling = aop->op_sibling;
10255                                 SV * const n = newSVpvs("");
10256 #ifdef PERL_MAD
10257                                 OP * const oldaop = aop;
10258 #else
10259                                 op_free(aop);
10260 #endif
10261                                 gv_fullname4(n, gv, "", FALSE);
10262                                 aop = newSVOP(OP_CONST, 0, n);
10263                                 op_getmad(oldaop,aop,'O');
10264                                 prev->op_sibling = aop;
10265                                 aop->op_sibling = sibling;
10266                             }
10267                         }
10268                     }
10269                 }
10270                 scalar(aop);
10271                 break;
10272             case '+':
10273                 proto++;
10274                 arg++;
10275                 if (o3->op_type == OP_RV2AV ||
10276                     o3->op_type == OP_PADAV ||
10277                     o3->op_type == OP_RV2HV ||
10278                     o3->op_type == OP_PADHV
10279                 ) {
10280                     goto wrapref;
10281                 }
10282                 scalar(aop);
10283                 break;
10284             case '[': case ']':
10285                 goto oops;
10286                 break;
10287             case '\\':
10288                 proto++;
10289                 arg++;
10290             again:
10291                 switch (*proto++) {
10292                     case '[':
10293                         if (contextclass++ == 0) {
10294                             e = strchr(proto, ']');
10295                             if (!e || e == proto)
10296                                 goto oops;
10297                         }
10298                         else
10299                             goto oops;
10300                         goto again;
10301                         break;
10302                     case ']':
10303                         if (contextclass) {
10304                             const char *p = proto;
10305                             const char *const end = proto;
10306                             contextclass = 0;
10307                             while (*--p != '[')
10308                                 /* \[$] accepts any scalar lvalue */
10309                                 if (*p == '$'
10310                                  && Perl_op_lvalue_flags(aTHX_
10311                                      scalar(o3),
10312                                      OP_READ, /* not entersub */
10313                                      OP_LVALUE_NO_CROAK
10314                                     )) goto wrapref;
10315                             bad_type_gv(arg, Perl_form(aTHX_ "one of %.*s",
10316                                         (int)(end - p), p),
10317                                     namegv, 0, o3);
10318                         } else
10319                             goto oops;
10320                         break;
10321                     case '*':
10322                         if (o3->op_type == OP_RV2GV)
10323                             goto wrapref;
10324                         if (!contextclass)
10325                             bad_type_gv(arg, "symbol", namegv, 0, o3);
10326                         break;
10327                     case '&':
10328                         if (o3->op_type == OP_ENTERSUB)
10329                             goto wrapref;
10330                         if (!contextclass)
10331                             bad_type_gv(arg, "subroutine entry", namegv, 0,
10332                                     o3);
10333                         break;
10334                     case '$':
10335                         if (o3->op_type == OP_RV2SV ||
10336                                 o3->op_type == OP_PADSV ||
10337                                 o3->op_type == OP_HELEM ||
10338                                 o3->op_type == OP_AELEM)
10339                             goto wrapref;
10340                         if (!contextclass) {
10341                             /* \$ accepts any scalar lvalue */
10342                             if (Perl_op_lvalue_flags(aTHX_
10343                                     scalar(o3),
10344                                     OP_READ,  /* not entersub */
10345                                     OP_LVALUE_NO_CROAK
10346                                )) goto wrapref;
10347                             bad_type_gv(arg, "scalar", namegv, 0, o3);
10348                         }
10349                         break;
10350                     case '@':
10351                         if (o3->op_type == OP_RV2AV ||
10352                                 o3->op_type == OP_PADAV)
10353                             goto wrapref;
10354                         if (!contextclass)
10355                             bad_type_gv(arg, "array", namegv, 0, o3);
10356                         break;
10357                     case '%':
10358                         if (o3->op_type == OP_RV2HV ||
10359                                 o3->op_type == OP_PADHV)
10360                             goto wrapref;
10361                         if (!contextclass)
10362                             bad_type_gv(arg, "hash", namegv, 0, o3);
10363                         break;
10364                     wrapref:
10365                         {
10366                             OP* const kid = aop;
10367                             OP* const sib = kid->op_sibling;
10368                             kid->op_sibling = 0;
10369                             aop = newUNOP(OP_REFGEN, 0, kid);
10370                             aop->op_sibling = sib;
10371                             prev->op_sibling = aop;
10372                         }
10373                         if (contextclass && e) {
10374                             proto = e + 1;
10375                             contextclass = 0;
10376                         }
10377                         break;
10378                     default: goto oops;
10379                 }
10380                 if (contextclass)
10381                     goto again;
10382                 break;
10383             case ' ':
10384                 proto++;
10385                 continue;
10386             default:
10387             oops: {
10388                 SV* const tmpsv = sv_newmortal();
10389                 gv_efullname3(tmpsv, namegv, NULL);
10390                 Perl_croak(aTHX_ "Malformed prototype for %"SVf": %"SVf,
10391                         SVfARG(tmpsv), SVfARG(protosv));
10392             }
10393         }
10394
10395         op_lvalue(aop, OP_ENTERSUB);
10396         prev = aop;
10397         aop = aop->op_sibling;
10398     }
10399     if (aop == cvop && *proto == '_') {
10400         /* generate an access to $_ */
10401         aop = newDEFSVOP();
10402         aop->op_sibling = prev->op_sibling;
10403         prev->op_sibling = aop; /* instead of cvop */
10404     }
10405     if (!optional && proto_end > proto &&
10406         (*proto != '@' && *proto != '%' && *proto != ';' && *proto != '_'))
10407         return too_few_arguments_sv(entersubop, gv_ename(namegv), 0);
10408     return entersubop;
10409 }
10410
10411 /*
10412 =for apidoc Am|OP *|ck_entersub_args_proto_or_list|OP *entersubop|GV *namegv|SV *protosv
10413
10414 Performs the fixup of the arguments part of an C<entersub> op tree either
10415 based on a subroutine prototype or using default list-context processing.
10416 This is the standard treatment used on a subroutine call, not marked
10417 with C<&>, where the callee can be identified at compile time.
10418
10419 I<protosv> supplies the subroutine prototype to be applied to the call,
10420 or indicates that there is no prototype.  It may be a normal scalar,
10421 in which case if it is defined then the string value will be used
10422 as a prototype, and if it is undefined then there is no prototype.
10423 Alternatively, for convenience, it may be a subroutine object (a C<CV*>
10424 that has been cast to C<SV*>), of which the prototype will be used if it
10425 has one.  The prototype (or lack thereof) supplied, in whichever form,
10426 does not need to match the actual callee referenced by the op tree.
10427
10428 If the argument ops disagree with the prototype, for example by having
10429 an unacceptable number of arguments, a valid op tree is returned anyway.
10430 The error is reflected in the parser state, normally resulting in a single
10431 exception at the top level of parsing which covers all the compilation
10432 errors that occurred.  In the error message, the callee is referred to
10433 by the name defined by the I<namegv> parameter.
10434
10435 =cut
10436 */
10437
10438 OP *
10439 Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop,
10440         GV *namegv, SV *protosv)
10441 {
10442     PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST;
10443     if (SvTYPE(protosv) == SVt_PVCV ? SvPOK(protosv) : SvOK(protosv))
10444         return ck_entersub_args_proto(entersubop, namegv, protosv);
10445     else
10446         return ck_entersub_args_list(entersubop);
10447 }
10448
10449 OP *
10450 Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv)
10451 {
10452     int opnum = SvTYPE(protosv) == SVt_PVCV ? 0 : (int)SvUV(protosv);
10453     OP *aop = cUNOPx(entersubop)->op_first;
10454
10455     PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE;
10456
10457     if (!opnum) {
10458         OP *cvop;
10459         if (!aop->op_sibling)
10460             aop = cUNOPx(aop)->op_first;
10461         aop = aop->op_sibling;
10462         for (cvop = aop; cvop->op_sibling; cvop = cvop->op_sibling) ;
10463         if (PL_madskills) while (aop != cvop && aop->op_type == OP_STUB) {
10464             aop = aop->op_sibling;
10465         }
10466         if (aop != cvop)
10467             (void)too_many_arguments_pv(entersubop, GvNAME(namegv), 0);
10468
10469         op_free(entersubop);
10470         switch(GvNAME(namegv)[2]) {
10471         case 'F': return newSVOP(OP_CONST, 0,
10472                                         newSVpv(CopFILE(PL_curcop),0));
10473         case 'L': return newSVOP(
10474                            OP_CONST, 0,
10475                            Perl_newSVpvf(aTHX_
10476                              "%"IVdf, (IV)CopLINE(PL_curcop)
10477                            )
10478                          );
10479         case 'P': return newSVOP(OP_CONST, 0,
10480                                    (PL_curstash
10481                                      ? newSVhek(HvNAME_HEK(PL_curstash))
10482                                      : &PL_sv_undef
10483                                    )
10484                                 );
10485         }
10486         assert(0);
10487     }
10488     else {
10489         OP *prev, *cvop;
10490         U32 flags;
10491 #ifdef PERL_MAD
10492         bool seenarg = FALSE;
10493 #endif
10494         if (!aop->op_sibling)
10495             aop = cUNOPx(aop)->op_first;
10496
10497         prev = aop;
10498         aop = aop->op_sibling;
10499         prev->op_sibling = NULL;
10500         for (cvop = aop;
10501              cvop->op_sibling;
10502              prev=cvop, cvop = cvop->op_sibling)
10503 #ifdef PERL_MAD
10504             if (PL_madskills && cvop->op_sibling
10505              && cvop->op_type != OP_STUB) seenarg = TRUE
10506 #endif
10507             ;
10508         prev->op_sibling = NULL;
10509         flags = OPf_SPECIAL * !(cvop->op_private & OPpENTERSUB_NOPAREN);
10510         op_free(cvop);
10511         if (aop == cvop) aop = NULL;
10512         op_free(entersubop);
10513
10514         if (opnum == OP_ENTEREVAL
10515          && GvNAMELEN(namegv)==9 && strnEQ(GvNAME(namegv), "evalbytes", 9))
10516             flags |= OPpEVAL_BYTES <<8;
10517
10518         switch (PL_opargs[opnum] & OA_CLASS_MASK) {
10519         case OA_UNOP:
10520         case OA_BASEOP_OR_UNOP:
10521         case OA_FILESTATOP:
10522             return aop ? newUNOP(opnum,flags,aop) : newOP(opnum,flags);
10523         case OA_BASEOP:
10524             if (aop) {
10525 #ifdef PERL_MAD
10526                 if (!PL_madskills || seenarg)
10527 #endif
10528                     (void)too_many_arguments_pv(aop, GvNAME(namegv), 0);
10529                 op_free(aop);
10530             }
10531             return opnum == OP_RUNCV
10532                 ? newPVOP(OP_RUNCV,0,NULL)
10533                 : newOP(opnum,0);
10534         default:
10535             return convert(opnum,0,aop);
10536         }
10537     }
10538     assert(0);
10539     return entersubop;
10540 }
10541
10542 /*
10543 =for apidoc Am|void|cv_get_call_checker|CV *cv|Perl_call_checker *ckfun_p|SV **ckobj_p
10544
10545 Retrieves the function that will be used to fix up a call to I<cv>.
10546 Specifically, the function is applied to an C<entersub> op tree for a
10547 subroutine call, not marked with C<&>, where the callee can be identified
10548 at compile time as I<cv>.
10549
10550 The C-level function pointer is returned in I<*ckfun_p>, and an SV
10551 argument for it is returned in I<*ckobj_p>.  The function is intended
10552 to be called in this manner:
10553
10554     entersubop = (*ckfun_p)(aTHX_ entersubop, namegv, (*ckobj_p));
10555
10556 In this call, I<entersubop> is a pointer to the C<entersub> op,
10557 which may be replaced by the check function, and I<namegv> is a GV
10558 supplying the name that should be used by the check function to refer
10559 to the callee of the C<entersub> op if it needs to emit any diagnostics.
10560 It is permitted to apply the check function in non-standard situations,
10561 such as to a call to a different subroutine or to a method call.
10562
10563 By default, the function is
10564 L<Perl_ck_entersub_args_proto_or_list|/ck_entersub_args_proto_or_list>,
10565 and the SV parameter is I<cv> itself.  This implements standard
10566 prototype processing.  It can be changed, for a particular subroutine,
10567 by L</cv_set_call_checker>.
10568
10569 =cut
10570 */
10571
10572 void
10573 Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)
10574 {
10575     MAGIC *callmg;
10576     PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER;
10577     callmg = SvMAGICAL((SV*)cv) ? mg_find((SV*)cv, PERL_MAGIC_checkcall) : NULL;
10578     if (callmg) {
10579         *ckfun_p = DPTR2FPTR(Perl_call_checker, callmg->mg_ptr);
10580         *ckobj_p = callmg->mg_obj;
10581     } else {
10582         *ckfun_p = Perl_ck_entersub_args_proto_or_list;
10583         *ckobj_p = (SV*)cv;
10584     }
10585 }
10586
10587 /*
10588 =for apidoc Am|void|cv_set_call_checker|CV *cv|Perl_call_checker ckfun|SV *ckobj
10589
10590 Sets the function that will be used to fix up a call to I<cv>.
10591 Specifically, the function is applied to an C<entersub> op tree for a
10592 subroutine call, not marked with C<&>, where the callee can be identified
10593 at compile time as I<cv>.
10594
10595 The C-level function pointer is supplied in I<ckfun>, and an SV argument
10596 for it is supplied in I<ckobj>.  The function is intended to be called
10597 in this manner:
10598
10599     entersubop = ckfun(aTHX_ entersubop, namegv, ckobj);
10600
10601 In this call, I<entersubop> is a pointer to the C<entersub> op,
10602 which may be replaced by the check function, and I<namegv> is a GV
10603 supplying the name that should be used by the check function to refer
10604 to the callee of the C<entersub> op if it needs to emit any diagnostics.
10605 It is permitted to apply the check function in non-standard situations,
10606 such as to a call to a different subroutine or to a method call.
10607
10608 The current setting for a particular CV can be retrieved by
10609 L</cv_get_call_checker>.
10610
10611 =cut
10612 */
10613
10614 void
10615 Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj)
10616 {
10617     PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER;
10618     if (ckfun == Perl_ck_entersub_args_proto_or_list && ckobj == (SV*)cv) {
10619         if (SvMAGICAL((SV*)cv))
10620             mg_free_type((SV*)cv, PERL_MAGIC_checkcall);
10621     } else {
10622         MAGIC *callmg;
10623         sv_magic((SV*)cv, &PL_sv_undef, PERL_MAGIC_checkcall, NULL, 0);
10624         callmg = mg_find((SV*)cv, PERL_MAGIC_checkcall);
10625         if (callmg->mg_flags & MGf_REFCOUNTED) {
10626             SvREFCNT_dec(callmg->mg_obj);
10627             callmg->mg_flags &= ~MGf_REFCOUNTED;
10628         }
10629         callmg->mg_ptr = FPTR2DPTR(char *, ckfun);
10630         callmg->mg_obj = ckobj;
10631         if (ckobj != (SV*)cv) {
10632             SvREFCNT_inc_simple_void_NN(ckobj);
10633             callmg->mg_flags |= MGf_REFCOUNTED;
10634         }
10635         callmg->mg_flags |= MGf_COPY;
10636     }
10637 }
10638
10639 OP *
10640 Perl_ck_subr(pTHX_ OP *o)
10641 {
10642     OP *aop, *cvop;
10643     CV *cv;
10644     GV *namegv;
10645
10646     PERL_ARGS_ASSERT_CK_SUBR;
10647
10648     aop = cUNOPx(o)->op_first;
10649     if (!aop->op_sibling)
10650         aop = cUNOPx(aop)->op_first;
10651     aop = aop->op_sibling;
10652     for (cvop = aop; cvop->op_sibling; cvop = cvop->op_sibling) ;
10653     cv = rv2cv_op_cv(cvop, RV2CVOPCV_MARK_EARLY);
10654     namegv = cv ? (GV*)rv2cv_op_cv(cvop, RV2CVOPCV_RETURN_NAME_GV) : NULL;
10655
10656     o->op_private &= ~1;
10657     o->op_private |= OPpENTERSUB_HASTARG;
10658     o->op_private |= (PL_hints & HINT_STRICT_REFS);
10659     if (PERLDB_SUB && PL_curstash != PL_debstash)
10660         o->op_private |= OPpENTERSUB_DB;
10661     if (cvop->op_type == OP_RV2CV) {
10662         o->op_private |= (cvop->op_private & OPpENTERSUB_AMPER);
10663         op_null(cvop);
10664     } else if (cvop->op_type == OP_METHOD || cvop->op_type == OP_METHOD_NAMED) {
10665         if (aop->op_type == OP_CONST)
10666             aop->op_private &= ~OPpCONST_STRICT;
10667         else if (aop->op_type == OP_LIST) {
10668             OP * const sib = ((UNOP*)aop)->op_first->op_sibling;
10669             if (sib && sib->op_type == OP_CONST)
10670                 sib->op_private &= ~OPpCONST_STRICT;
10671         }
10672     }
10673
10674     if (!cv) {
10675         return ck_entersub_args_list(o);
10676     } else {
10677         Perl_call_checker ckfun;
10678         SV *ckobj;
10679         cv_get_call_checker(cv, &ckfun, &ckobj);
10680         if (!namegv) { /* expletive! */
10681             /* XXX The call checker API is public.  And it guarantees that
10682                    a GV will be provided with the right name.  So we have
10683                    to create a GV.  But it is still not correct, as its
10684                    stringification will include the package.  What we
10685                    really need is a new call checker API that accepts a
10686                    GV or string (or GV or CV). */
10687             HEK * const hek = CvNAME_HEK(cv);
10688             /* After a syntax error in a lexical sub, the cv that
10689                rv2cv_op_cv returns may be a nameless stub. */
10690             if (!hek) return ck_entersub_args_list(o);;
10691             namegv = (GV *)sv_newmortal();
10692             gv_init_pvn(namegv, PL_curstash, HEK_KEY(hek), HEK_LEN(hek),
10693                         SVf_UTF8 * !!HEK_UTF8(hek));
10694         }
10695         return ckfun(aTHX_ o, namegv, ckobj);
10696     }
10697 }
10698
10699 OP *
10700 Perl_ck_svconst(pTHX_ OP *o)
10701 {
10702     SV * const sv = cSVOPo->op_sv;
10703     PERL_ARGS_ASSERT_CK_SVCONST;
10704     PERL_UNUSED_CONTEXT;
10705 #ifdef PERL_OLD_COPY_ON_WRITE
10706     if (SvIsCOW(sv)) sv_force_normal(sv);
10707 #elif defined(PERL_NEW_COPY_ON_WRITE)
10708     /* Since the read-only flag may be used to protect a string buffer, we
10709        cannot do copy-on-write with existing read-only scalars that are not
10710        already copy-on-write scalars.  To allow $_ = "hello" to do COW with
10711        that constant, mark the constant as COWable here, if it is not
10712        already read-only. */
10713     if (!SvREADONLY(sv) && !SvIsCOW(sv) && SvCANCOW(sv)) {
10714         SvIsCOW_on(sv);
10715         CowREFCNT(sv) = 0;
10716     }
10717 #endif
10718     SvREADONLY_on(sv);
10719     return o;
10720 }
10721
10722 OP *
10723 Perl_ck_trunc(pTHX_ OP *o)
10724 {
10725     PERL_ARGS_ASSERT_CK_TRUNC;
10726
10727     if (o->op_flags & OPf_KIDS) {
10728         SVOP *kid = (SVOP*)cUNOPo->op_first;
10729
10730         if (kid->op_type == OP_NULL)
10731             kid = (SVOP*)kid->op_sibling;
10732         if (kid && kid->op_type == OP_CONST &&
10733             (kid->op_private & OPpCONST_BARE) &&
10734             !kid->op_folded)
10735         {
10736             o->op_flags |= OPf_SPECIAL;
10737             kid->op_private &= ~OPpCONST_STRICT;
10738         }
10739     }
10740     return ck_fun(o);
10741 }
10742
10743 OP *
10744 Perl_ck_substr(pTHX_ OP *o)
10745 {
10746     PERL_ARGS_ASSERT_CK_SUBSTR;
10747
10748     o = ck_fun(o);
10749     if ((o->op_flags & OPf_KIDS) && (o->op_private == 4)) {
10750         OP *kid = cLISTOPo->op_first;
10751
10752         if (kid->op_type == OP_NULL)
10753             kid = kid->op_sibling;
10754         if (kid)
10755             kid->op_flags |= OPf_MOD;
10756
10757     }
10758     return o;
10759 }
10760
10761 OP *
10762 Perl_ck_tell(pTHX_ OP *o)
10763 {
10764     PERL_ARGS_ASSERT_CK_TELL;
10765     o = ck_fun(o);
10766     if (o->op_flags & OPf_KIDS) {
10767      OP *kid = cLISTOPo->op_first;
10768      if (kid->op_type == OP_NULL && kid->op_sibling) kid = kid->op_sibling;
10769      if (kid->op_type == OP_RV2GV) kid->op_private |= OPpALLOW_FAKE;
10770     }
10771     return o;
10772 }
10773
10774 OP *
10775 Perl_ck_each(pTHX_ OP *o)
10776 {
10777     dVAR;
10778     OP *kid = o->op_flags & OPf_KIDS ? cUNOPo->op_first : NULL;
10779     const unsigned orig_type  = o->op_type;
10780     const unsigned array_type = orig_type == OP_EACH ? OP_AEACH
10781                               : orig_type == OP_KEYS ? OP_AKEYS : OP_AVALUES;
10782     const unsigned ref_type   = orig_type == OP_EACH ? OP_REACH
10783                               : orig_type == OP_KEYS ? OP_RKEYS : OP_RVALUES;
10784
10785     PERL_ARGS_ASSERT_CK_EACH;
10786
10787     if (kid) {
10788         switch (kid->op_type) {
10789             case OP_PADHV:
10790             case OP_RV2HV:
10791                 break;
10792             case OP_PADAV:
10793             case OP_RV2AV:
10794                 CHANGE_TYPE(o, array_type);
10795                 break;
10796             case OP_CONST:
10797                 if (kid->op_private == OPpCONST_BARE
10798                  || !SvROK(cSVOPx_sv(kid))
10799                  || (  SvTYPE(SvRV(cSVOPx_sv(kid))) != SVt_PVAV
10800                     && SvTYPE(SvRV(cSVOPx_sv(kid))) != SVt_PVHV  )
10801                    )
10802                     /* we let ck_fun handle it */
10803                     break;
10804             default:
10805                 CHANGE_TYPE(o, ref_type);
10806                 scalar(kid);
10807         }
10808     }
10809     /* if treating as a reference, defer additional checks to runtime */
10810     return o->op_type == ref_type ? o : ck_fun(o);
10811 }
10812
10813 OP *
10814 Perl_ck_length(pTHX_ OP *o)
10815 {
10816     PERL_ARGS_ASSERT_CK_LENGTH;
10817
10818     o = ck_fun(o);
10819
10820     if (ckWARN(WARN_SYNTAX)) {
10821         const OP *kid = o->op_flags & OPf_KIDS ? cLISTOPo->op_first : NULL;
10822
10823         if (kid) {
10824             SV *name = NULL;
10825             const bool hash = kid->op_type == OP_PADHV
10826                            || kid->op_type == OP_RV2HV;
10827             switch (kid->op_type) {
10828                 case OP_PADHV:
10829                 case OP_PADAV:
10830                 case OP_RV2HV:
10831                 case OP_RV2AV:
10832                     name = S_op_varname(aTHX_ kid);
10833                     break;
10834                 default:
10835                     return o;
10836             }
10837             if (name)
10838                 Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
10839                     "length() used on %"SVf" (did you mean \"scalar(%s%"SVf
10840                     ")\"?)",
10841                     name, hash ? "keys " : "", name
10842                 );
10843             else if (hash)
10844      /* diag_listed_as: length() used on %s (did you mean "scalar(%s)"?) */
10845                 Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
10846                     "length() used on %%hash (did you mean \"scalar(keys %%hash)\"?)");
10847             else
10848      /* diag_listed_as: length() used on %s (did you mean "scalar(%s)"?) */
10849                 Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
10850                     "length() used on @array (did you mean \"scalar(@array)\"?)");
10851         }
10852     }
10853
10854     return o;
10855 }
10856
10857 /* Check for in place reverse and sort assignments like "@a = reverse @a"
10858    and modify the optree to make them work inplace */
10859
10860 STATIC void
10861 S_inplace_aassign(pTHX_ OP *o) {
10862
10863     OP *modop, *modop_pushmark;
10864     OP *oright;
10865     OP *oleft, *oleft_pushmark;
10866
10867     PERL_ARGS_ASSERT_INPLACE_AASSIGN;
10868
10869     assert((o->op_flags & OPf_WANT) == OPf_WANT_VOID);
10870
10871     assert(cUNOPo->op_first->op_type == OP_NULL);
10872     modop_pushmark = cUNOPx(cUNOPo->op_first)->op_first;
10873     assert(modop_pushmark->op_type == OP_PUSHMARK);
10874     modop = modop_pushmark->op_sibling;
10875
10876     if (modop->op_type != OP_SORT && modop->op_type != OP_REVERSE)
10877         return;
10878
10879     /* no other operation except sort/reverse */
10880     if (modop->op_sibling)
10881         return;
10882
10883     assert(cUNOPx(modop)->op_first->op_type == OP_PUSHMARK);
10884     if (!(oright = cUNOPx(modop)->op_first->op_sibling)) return;
10885
10886     if (modop->op_flags & OPf_STACKED) {
10887         /* skip sort subroutine/block */
10888         assert(oright->op_type == OP_NULL);
10889         oright = oright->op_sibling;
10890     }
10891
10892     assert(cUNOPo->op_first->op_sibling->op_type == OP_NULL);
10893     oleft_pushmark = cUNOPx(cUNOPo->op_first->op_sibling)->op_first;
10894     assert(oleft_pushmark->op_type == OP_PUSHMARK);
10895     oleft = oleft_pushmark->op_sibling;
10896
10897     /* Check the lhs is an array */
10898     if (!oleft ||
10899         (oleft->op_type != OP_RV2AV && oleft->op_type != OP_PADAV)
10900         || oleft->op_sibling
10901         || (oleft->op_private & OPpLVAL_INTRO)
10902     )
10903         return;
10904
10905     /* Only one thing on the rhs */
10906     if (oright->op_sibling)
10907         return;
10908
10909     /* check the array is the same on both sides */
10910     if (oleft->op_type == OP_RV2AV) {
10911         if (oright->op_type != OP_RV2AV
10912             || !cUNOPx(oright)->op_first
10913             || cUNOPx(oright)->op_first->op_type != OP_GV
10914             || cUNOPx(oleft )->op_first->op_type != OP_GV
10915             || cGVOPx_gv(cUNOPx(oleft)->op_first) !=
10916                cGVOPx_gv(cUNOPx(oright)->op_first)
10917         )
10918             return;
10919     }
10920     else if (oright->op_type != OP_PADAV
10921         || oright->op_targ != oleft->op_targ
10922     )
10923         return;
10924
10925     /* This actually is an inplace assignment */
10926
10927     modop->op_private |= OPpSORT_INPLACE;
10928
10929     /* transfer MODishness etc from LHS arg to RHS arg */
10930     oright->op_flags = oleft->op_flags;
10931
10932     /* remove the aassign op and the lhs */
10933     op_null(o);
10934     op_null(oleft_pushmark);
10935     if (oleft->op_type == OP_RV2AV && cUNOPx(oleft)->op_first)
10936         op_null(cUNOPx(oleft)->op_first);
10937     op_null(oleft);
10938 }
10939
10940 #define MAX_DEFERRED 4
10941
10942 #define DEFER(o) \
10943   STMT_START { \
10944     if (defer_ix == (MAX_DEFERRED-1)) { \
10945         CALL_RPEEP(defer_queue[defer_base]); \
10946         defer_base = (defer_base + 1) % MAX_DEFERRED; \
10947         defer_ix--; \
10948     } \
10949     defer_queue[(defer_base + ++defer_ix) % MAX_DEFERRED] = o; \
10950   } STMT_END
10951
10952 /* A peephole optimizer.  We visit the ops in the order they're to execute.
10953  * See the comments at the top of this file for more details about when
10954  * peep() is called */
10955
10956 void
10957 Perl_rpeep(pTHX_ OP *o)
10958 {
10959     dVAR;
10960     OP* oldop = NULL;
10961     OP* oldoldop = NULL;
10962     OP* defer_queue[MAX_DEFERRED]; /* small queue of deferred branches */
10963     int defer_base = 0;
10964     int defer_ix = -1;
10965
10966     if (!o || o->op_opt)
10967         return;
10968     ENTER;
10969     SAVEOP();
10970     SAVEVPTR(PL_curcop);
10971     for (;; o = o->op_next) {
10972         if (o && o->op_opt)
10973             o = NULL;
10974         if (!o) {
10975             while (defer_ix >= 0)
10976                 CALL_RPEEP(defer_queue[(defer_base + defer_ix--) % MAX_DEFERRED]);
10977             break;
10978         }
10979
10980         /* By default, this op has now been optimised. A couple of cases below
10981            clear this again.  */
10982         o->op_opt = 1;
10983         PL_op = o;
10984         switch (o->op_type) {
10985         case OP_DBSTATE:
10986             PL_curcop = ((COP*)o);              /* for warnings */
10987             break;
10988         case OP_NEXTSTATE:
10989             PL_curcop = ((COP*)o);              /* for warnings */
10990
10991             /* Two NEXTSTATEs in a row serve no purpose. Except if they happen
10992                to carry two labels. For now, take the easier option, and skip
10993                this optimisation if the first NEXTSTATE has a label.  */
10994             if (!CopLABEL((COP*)o) && !PERLDB_NOOPT) {
10995                 OP *nextop = o->op_next;
10996                 while (nextop && nextop->op_type == OP_NULL)
10997                     nextop = nextop->op_next;
10998
10999                 if (nextop && (nextop->op_type == OP_NEXTSTATE)) {
11000                     COP *firstcop = (COP *)o;
11001                     COP *secondcop = (COP *)nextop;
11002                     /* We want the COP pointed to by o (and anything else) to
11003                        become the next COP down the line.  */
11004                     cop_free(firstcop);
11005
11006                     firstcop->op_next = secondcop->op_next;
11007
11008                     /* Now steal all its pointers, and duplicate the other
11009                        data.  */
11010                     firstcop->cop_line = secondcop->cop_line;
11011 #ifdef USE_ITHREADS
11012                     firstcop->cop_stashoff = secondcop->cop_stashoff;
11013                     firstcop->cop_file = secondcop->cop_file;
11014 #else
11015                     firstcop->cop_stash = secondcop->cop_stash;
11016                     firstcop->cop_filegv = secondcop->cop_filegv;
11017 #endif
11018                     firstcop->cop_hints = secondcop->cop_hints;
11019                     firstcop->cop_seq = secondcop->cop_seq;
11020                     firstcop->cop_warnings = secondcop->cop_warnings;
11021                     firstcop->cop_hints_hash = secondcop->cop_hints_hash;
11022
11023 #ifdef USE_ITHREADS
11024                     secondcop->cop_stashoff = 0;
11025                     secondcop->cop_file = NULL;
11026 #else
11027                     secondcop->cop_stash = NULL;
11028                     secondcop->cop_filegv = NULL;
11029 #endif
11030                     secondcop->cop_warnings = NULL;
11031                     secondcop->cop_hints_hash = NULL;
11032
11033                     /* If we use op_null(), and hence leave an ex-COP, some
11034                        warnings are misreported. For example, the compile-time
11035                        error in 'use strict; no strict refs;'  */
11036                     secondcop->op_type = OP_NULL;
11037                     secondcop->op_ppaddr = PL_ppaddr[OP_NULL];
11038                 }
11039             }
11040             break;
11041
11042         case OP_CONCAT:
11043             if (o->op_next && o->op_next->op_type == OP_STRINGIFY) {
11044                 if (o->op_next->op_private & OPpTARGET_MY) {
11045                     if (o->op_flags & OPf_STACKED) /* chained concats */
11046                         break; /* ignore_optimization */
11047                     else {
11048                         /* assert(PL_opargs[o->op_type] & OA_TARGLEX); */
11049                         o->op_targ = o->op_next->op_targ;
11050                         o->op_next->op_targ = 0;
11051                         o->op_private |= OPpTARGET_MY;
11052                     }
11053                 }
11054                 op_null(o->op_next);
11055             }
11056             break;
11057         case OP_STUB:
11058             if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
11059                 break; /* Scalar stub must produce undef.  List stub is noop */
11060             }
11061             goto nothin;
11062         case OP_NULL:
11063             if (o->op_targ == OP_NEXTSTATE
11064                 || o->op_targ == OP_DBSTATE)
11065             {
11066                 PL_curcop = ((COP*)o);
11067             }
11068             /* XXX: We avoid setting op_seq here to prevent later calls
11069                to rpeep() from mistakenly concluding that optimisation
11070                has already occurred. This doesn't fix the real problem,
11071                though (See 20010220.007). AMS 20010719 */
11072             /* op_seq functionality is now replaced by op_opt */
11073             o->op_opt = 0;
11074             /* FALL THROUGH */
11075         case OP_SCALAR:
11076         case OP_LINESEQ:
11077         case OP_SCOPE:
11078         nothin:
11079             if (oldop && o->op_next) {
11080                 oldop->op_next = o->op_next;
11081                 o->op_opt = 0;
11082                 continue;
11083             }
11084             break;
11085
11086         case OP_PUSHMARK:
11087
11088             /* Convert a series of PAD ops for my vars plus support into a
11089              * single padrange op. Basically
11090              *
11091              *    pushmark -> pad[ahs]v -> pad[ahs]?v -> ... -> (list) -> rest
11092              *
11093              * becomes, depending on circumstances, one of
11094              *
11095              *    padrange  ----------------------------------> (list) -> rest
11096              *    padrange  --------------------------------------------> rest
11097              *
11098              * where all the pad indexes are sequential and of the same type
11099              * (INTRO or not).
11100              * We convert the pushmark into a padrange op, then skip
11101              * any other pad ops, and possibly some trailing ops.
11102              * Note that we don't null() the skipped ops, to make it
11103              * easier for Deparse to undo this optimisation (and none of
11104              * the skipped ops are holding any resourses). It also makes
11105              * it easier for find_uninit_var(), as it can just ignore
11106              * padrange, and examine the original pad ops.
11107              */
11108         {
11109             OP *p;
11110             OP *followop = NULL; /* the op that will follow the padrange op */
11111             U8 count = 0;
11112             U8 intro = 0;
11113             PADOFFSET base = 0; /* init only to stop compiler whining */
11114             U8 gimme       = 0; /* init only to stop compiler whining */
11115             bool defav = 0;  /* seen (...) = @_ */
11116             bool reuse = 0;  /* reuse an existing padrange op */
11117
11118             /* look for a pushmark -> gv[_] -> rv2av */
11119
11120             {
11121                 GV *gv;
11122                 OP *rv2av, *q;
11123                 p = o->op_next;
11124                 if (   p->op_type == OP_GV
11125                     && (gv = cGVOPx_gv(p))
11126                     && GvNAMELEN_get(gv) == 1
11127                     && *GvNAME_get(gv) == '_'
11128                     && GvSTASH(gv) == PL_defstash
11129                     && (rv2av = p->op_next)
11130                     && rv2av->op_type == OP_RV2AV
11131                     && !(rv2av->op_flags & OPf_REF)
11132                     && !(rv2av->op_private & (OPpLVAL_INTRO|OPpMAYBE_LVSUB))
11133                     && ((rv2av->op_flags & OPf_WANT) == OPf_WANT_LIST)
11134                     && o->op_sibling == rv2av /* these two for Deparse */
11135                     && cUNOPx(rv2av)->op_first == p
11136                 ) {
11137                     q = rv2av->op_next;
11138                     if (q->op_type == OP_NULL)
11139                         q = q->op_next;
11140                     if (q->op_type == OP_PUSHMARK) {
11141                         defav = 1;
11142                         p = q;
11143                     }
11144                 }
11145             }
11146             if (!defav) {
11147                 /* To allow Deparse to pessimise this, it needs to be able
11148                  * to restore the pushmark's original op_next, which it
11149                  * will assume to be the same as op_sibling. */
11150                 if (o->op_next != o->op_sibling)
11151                     break;
11152                 p = o;
11153             }
11154
11155             /* scan for PAD ops */
11156
11157             for (p = p->op_next; p; p = p->op_next) {
11158                 if (p->op_type == OP_NULL)
11159                     continue;
11160
11161                 if ((     p->op_type != OP_PADSV
11162                        && p->op_type != OP_PADAV
11163                        && p->op_type != OP_PADHV
11164                     )
11165                       /* any private flag other than INTRO? e.g. STATE */
11166                    || (p->op_private & ~OPpLVAL_INTRO)
11167                 )
11168                     break;
11169
11170                 /* let $a[N] potentially be optimised into ALEMFAST_LEX
11171                  * instead */
11172                 if (   p->op_type == OP_PADAV
11173                     && p->op_next
11174                     && p->op_next->op_type == OP_CONST
11175                     && p->op_next->op_next
11176                     && p->op_next->op_next->op_type == OP_AELEM
11177                 )
11178                     break;
11179
11180                 /* for 1st padop, note what type it is and the range
11181                  * start; for the others, check that it's the same type
11182                  * and that the targs are contiguous */
11183                 if (count == 0) {
11184                     intro = (p->op_private & OPpLVAL_INTRO);
11185                     base = p->op_targ;
11186                     gimme = (p->op_flags & OPf_WANT);
11187                 }
11188                 else {
11189                     if ((p->op_private & OPpLVAL_INTRO) != intro)
11190                         break;
11191                     /* Note that you'd normally  expect targs to be
11192                      * contiguous in my($a,$b,$c), but that's not the case
11193                      * when external modules start doing things, e.g.
11194                      i* Function::Parameters */
11195                     if (p->op_targ != base + count)
11196                         break;
11197                     assert(p->op_targ == base + count);
11198                     /* all the padops should be in the same context */
11199                     if (gimme != (p->op_flags & OPf_WANT))
11200                         break;
11201                 }
11202
11203                 /* for AV, HV, only when we're not flattening */
11204                 if (   p->op_type != OP_PADSV
11205                     && gimme != OPf_WANT_VOID
11206                     && !(p->op_flags & OPf_REF)
11207                 )
11208                     break;
11209
11210                 if (count >= OPpPADRANGE_COUNTMASK)
11211                     break;
11212
11213                 /* there's a biggest base we can fit into a
11214                  * SAVEt_CLEARPADRANGE in pp_padrange */
11215                 if (intro && base >
11216                         (UV_MAX >> (OPpPADRANGE_COUNTSHIFT+SAVE_TIGHT_SHIFT)))
11217                     break;
11218
11219                 /* Success! We've got another valid pad op to optimise away */
11220                 count++;
11221                 followop = p->op_next;
11222             }
11223
11224             if (count < 1)
11225                 break;
11226
11227             /* pp_padrange in specifically compile-time void context
11228              * skips pushing a mark and lexicals; in all other contexts
11229              * (including unknown till runtime) it pushes a mark and the
11230              * lexicals. We must be very careful then, that the ops we
11231              * optimise away would have exactly the same effect as the
11232              * padrange.
11233              * In particular in void context, we can only optimise to
11234              * a padrange if see see the complete sequence
11235              *     pushmark, pad*v, ...., list, nextstate
11236              * which has the net effect of of leaving the stack empty
11237              * (for now we leave the nextstate in the execution chain, for
11238              * its other side-effects).
11239              */
11240             assert(followop);
11241             if (gimme == OPf_WANT_VOID) {
11242                 if (followop->op_type == OP_LIST
11243                         && gimme == (followop->op_flags & OPf_WANT)
11244                         && (   followop->op_next->op_type == OP_NEXTSTATE
11245                             || followop->op_next->op_type == OP_DBSTATE))
11246                 {
11247                     followop = followop->op_next; /* skip OP_LIST */
11248
11249                     /* consolidate two successive my(...);'s */
11250
11251                     if (   oldoldop
11252                         && oldoldop->op_type == OP_PADRANGE
11253                         && (oldoldop->op_flags & OPf_WANT) == OPf_WANT_VOID
11254                         && (oldoldop->op_private & OPpLVAL_INTRO) == intro
11255                         && !(oldoldop->op_flags & OPf_SPECIAL)
11256                     ) {
11257                         U8 old_count;
11258                         assert(oldoldop->op_next == oldop);
11259                         assert(   oldop->op_type == OP_NEXTSTATE
11260                                || oldop->op_type == OP_DBSTATE);
11261                         assert(oldop->op_next == o);
11262
11263                         old_count
11264                             = (oldoldop->op_private & OPpPADRANGE_COUNTMASK);
11265
11266                        /* Do not assume pad offsets for $c and $d are con-
11267                           tiguous in
11268                             my ($a,$b,$c);
11269                             my ($d,$e,$f);
11270                         */
11271                         if (  oldoldop->op_targ + old_count == base
11272                            && old_count < OPpPADRANGE_COUNTMASK - count) {
11273                             base = oldoldop->op_targ;
11274                             count += old_count;
11275                             reuse = 1;
11276                         }
11277                     }
11278
11279                     /* if there's any immediately following singleton
11280                      * my var's; then swallow them and the associated
11281                      * nextstates; i.e.
11282                      *    my ($a,$b); my $c; my $d;
11283                      * is treated as
11284                      *    my ($a,$b,$c,$d);
11285                      */
11286
11287                     while (    ((p = followop->op_next))
11288                             && (  p->op_type == OP_PADSV
11289                                || p->op_type == OP_PADAV
11290                                || p->op_type == OP_PADHV)
11291                             && (p->op_flags & OPf_WANT) == OPf_WANT_VOID
11292                             && (p->op_private & OPpLVAL_INTRO) == intro
11293                             && p->op_next
11294                             && (   p->op_next->op_type == OP_NEXTSTATE
11295                                 || p->op_next->op_type == OP_DBSTATE)
11296                             && count < OPpPADRANGE_COUNTMASK
11297                             && base + count == p->op_targ
11298                     ) {
11299                         count++;
11300                         followop = p->op_next;
11301                     }
11302                 }
11303                 else
11304                     break;
11305             }
11306
11307             if (reuse) {
11308                 assert(oldoldop->op_type == OP_PADRANGE);
11309                 oldoldop->op_next = followop;
11310                 oldoldop->op_private = (intro | count);
11311                 o = oldoldop;
11312                 oldop = NULL;
11313                 oldoldop = NULL;
11314             }
11315             else {
11316                 /* Convert the pushmark into a padrange.
11317                  * To make Deparse easier, we guarantee that a padrange was
11318                  * *always* formerly a pushmark */
11319                 assert(o->op_type == OP_PUSHMARK);
11320                 o->op_next = followop;
11321                 o->op_type = OP_PADRANGE;
11322                 o->op_ppaddr = PL_ppaddr[OP_PADRANGE];
11323                 o->op_targ = base;
11324                 /* bit 7: INTRO; bit 6..0: count */
11325                 o->op_private = (intro | count);
11326                 o->op_flags = ((o->op_flags & ~(OPf_WANT|OPf_SPECIAL))
11327                                     | gimme | (defav ? OPf_SPECIAL : 0));
11328             }
11329             break;
11330         }
11331
11332         case OP_PADAV:
11333         case OP_GV:
11334             if (o->op_type == OP_PADAV || o->op_next->op_type == OP_RV2AV) {
11335                 OP* const pop = (o->op_type == OP_PADAV) ?
11336                             o->op_next : o->op_next->op_next;
11337                 IV i;
11338                 if (pop && pop->op_type == OP_CONST &&
11339                     ((PL_op = pop->op_next)) &&
11340                     pop->op_next->op_type == OP_AELEM &&
11341                     !(pop->op_next->op_private &
11342                       (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF|OPpMAYBE_LVSUB)) &&
11343                     (i = SvIV(((SVOP*)pop)->op_sv)) <= 255 && i >= 0)
11344                 {
11345                     GV *gv;
11346                     if (cSVOPx(pop)->op_private & OPpCONST_STRICT)
11347                         no_bareword_allowed(pop);
11348                     if (o->op_type == OP_GV)
11349                         op_null(o->op_next);
11350                     op_null(pop->op_next);
11351                     op_null(pop);
11352                     o->op_flags |= pop->op_next->op_flags & OPf_MOD;
11353                     o->op_next = pop->op_next->op_next;
11354                     o->op_ppaddr = PL_ppaddr[OP_AELEMFAST];
11355                     o->op_private = (U8)i;
11356                     if (o->op_type == OP_GV) {
11357                         gv = cGVOPo_gv;
11358                         GvAVn(gv);
11359                         o->op_type = OP_AELEMFAST;
11360                     }
11361                     else
11362                         o->op_type = OP_AELEMFAST_LEX;
11363                 }
11364                 break;
11365             }
11366
11367             if (o->op_next->op_type == OP_RV2SV) {
11368                 if (!(o->op_next->op_private & OPpDEREF)) {
11369                     op_null(o->op_next);
11370                     o->op_private |= o->op_next->op_private & (OPpLVAL_INTRO
11371                                                                | OPpOUR_INTRO);
11372                     o->op_next = o->op_next->op_next;
11373                     o->op_type = OP_GVSV;
11374                     o->op_ppaddr = PL_ppaddr[OP_GVSV];
11375                 }
11376             }
11377             else if (o->op_next->op_type == OP_READLINE
11378                     && o->op_next->op_next->op_type == OP_CONCAT
11379                     && (o->op_next->op_next->op_flags & OPf_STACKED))
11380             {
11381                 /* Turn "$a .= <FH>" into an OP_RCATLINE. AMS 20010917 */
11382                 o->op_type   = OP_RCATLINE;
11383                 o->op_flags |= OPf_STACKED;
11384                 o->op_ppaddr = PL_ppaddr[OP_RCATLINE];
11385                 op_null(o->op_next->op_next);
11386                 op_null(o->op_next);
11387             }
11388
11389             break;
11390
11391         {
11392             OP *fop;
11393             OP *sop;
11394
11395 #define HV_OR_SCALARHV(op)                                   \
11396     (  (op)->op_type == OP_PADHV || (op)->op_type == OP_RV2HV \
11397        ? (op)                                                  \
11398        : (op)->op_type == OP_SCALAR && (op)->op_flags & OPf_KIDS \
11399        && (  cUNOPx(op)->op_first->op_type == OP_PADHV          \
11400           || cUNOPx(op)->op_first->op_type == OP_RV2HV)          \
11401          ? cUNOPx(op)->op_first                                   \
11402          : NULL)
11403
11404         case OP_NOT:
11405             if ((fop = HV_OR_SCALARHV(cUNOP->op_first)))
11406                 fop->op_private |= OPpTRUEBOOL;
11407             break;
11408
11409         case OP_AND:
11410         case OP_OR:
11411         case OP_DOR:
11412             fop = cLOGOP->op_first;
11413             sop = fop->op_sibling;
11414             while (cLOGOP->op_other->op_type == OP_NULL)
11415                 cLOGOP->op_other = cLOGOP->op_other->op_next;
11416             while (o->op_next && (   o->op_type == o->op_next->op_type
11417                                   || o->op_next->op_type == OP_NULL))
11418                 o->op_next = o->op_next->op_next;
11419             DEFER(cLOGOP->op_other);
11420
11421             o->op_opt = 1;
11422             fop = HV_OR_SCALARHV(fop);
11423             if (sop) sop = HV_OR_SCALARHV(sop);
11424             if (fop || sop
11425             ){
11426                 OP * nop = o;
11427                 OP * lop = o;
11428                 if (!((nop->op_flags & OPf_WANT) == OPf_WANT_VOID)) {
11429                     while (nop && nop->op_next) {
11430                         switch (nop->op_next->op_type) {
11431                             case OP_NOT:
11432                             case OP_AND:
11433                             case OP_OR:
11434                             case OP_DOR:
11435                                 lop = nop = nop->op_next;
11436                                 break;
11437                             case OP_NULL:
11438                                 nop = nop->op_next;
11439                                 break;
11440                             default:
11441                                 nop = NULL;
11442                                 break;
11443                         }
11444                     }
11445                 }
11446                 if (fop) {
11447                     if (  (lop->op_flags & OPf_WANT) == OPf_WANT_VOID
11448                       || o->op_type == OP_AND  )
11449                         fop->op_private |= OPpTRUEBOOL;
11450                     else if (!(lop->op_flags & OPf_WANT))
11451                         fop->op_private |= OPpMAYBE_TRUEBOOL;
11452                 }
11453                 if (  (lop->op_flags & OPf_WANT) == OPf_WANT_VOID
11454                    && sop)
11455                     sop->op_private |= OPpTRUEBOOL;
11456             }
11457
11458
11459             break;
11460
11461         case OP_COND_EXPR:
11462             if ((fop = HV_OR_SCALARHV(cLOGOP->op_first)))
11463                 fop->op_private |= OPpTRUEBOOL;
11464 #undef HV_OR_SCALARHV
11465             /* GERONIMO! */
11466         }
11467
11468         case OP_MAPWHILE:
11469         case OP_GREPWHILE:
11470         case OP_ANDASSIGN:
11471         case OP_ORASSIGN:
11472         case OP_DORASSIGN:
11473         case OP_RANGE:
11474         case OP_ONCE:
11475             while (cLOGOP->op_other->op_type == OP_NULL)
11476                 cLOGOP->op_other = cLOGOP->op_other->op_next;
11477             DEFER(cLOGOP->op_other);
11478             break;
11479
11480         case OP_ENTERLOOP:
11481         case OP_ENTERITER:
11482             while (cLOOP->op_redoop->op_type == OP_NULL)
11483                 cLOOP->op_redoop = cLOOP->op_redoop->op_next;
11484             while (cLOOP->op_nextop->op_type == OP_NULL)
11485                 cLOOP->op_nextop = cLOOP->op_nextop->op_next;
11486             while (cLOOP->op_lastop->op_type == OP_NULL)
11487                 cLOOP->op_lastop = cLOOP->op_lastop->op_next;
11488             /* a while(1) loop doesn't have an op_next that escapes the
11489              * loop, so we have to explicitly follow the op_lastop to
11490              * process the rest of the code */
11491             DEFER(cLOOP->op_lastop);
11492             break;
11493
11494         case OP_SUBST:
11495             assert(!(cPMOP->op_pmflags & PMf_ONCE));
11496             while (cPMOP->op_pmstashstartu.op_pmreplstart &&
11497                    cPMOP->op_pmstashstartu.op_pmreplstart->op_type == OP_NULL)
11498                 cPMOP->op_pmstashstartu.op_pmreplstart
11499                     = cPMOP->op_pmstashstartu.op_pmreplstart->op_next;
11500             DEFER(cPMOP->op_pmstashstartu.op_pmreplstart);
11501             break;
11502
11503         case OP_SORT: {
11504             OP *oright;
11505
11506             if (o->op_flags & OPf_STACKED) {
11507                 OP * const kid =
11508                     cUNOPx(cLISTOP->op_first->op_sibling)->op_first;
11509                 if (kid->op_type == OP_SCOPE
11510                  || (kid->op_type == OP_NULL && kid->op_targ == OP_LEAVE))
11511                     DEFER(kLISTOP->op_first);
11512             }
11513
11514             /* check that RHS of sort is a single plain array */
11515             oright = cUNOPo->op_first;
11516             if (!oright || oright->op_type != OP_PUSHMARK)
11517                 break;
11518
11519             if (o->op_private & OPpSORT_INPLACE)
11520                 break;
11521
11522             /* reverse sort ... can be optimised.  */
11523             if (!cUNOPo->op_sibling) {
11524                 /* Nothing follows us on the list. */
11525                 OP * const reverse = o->op_next;
11526
11527                 if (reverse->op_type == OP_REVERSE &&
11528                     (reverse->op_flags & OPf_WANT) == OPf_WANT_LIST) {
11529                     OP * const pushmark = cUNOPx(reverse)->op_first;
11530                     if (pushmark && (pushmark->op_type == OP_PUSHMARK)
11531                         && (cUNOPx(pushmark)->op_sibling == o)) {
11532                         /* reverse -> pushmark -> sort */
11533                         o->op_private |= OPpSORT_REVERSE;
11534                         op_null(reverse);
11535                         pushmark->op_next = oright->op_next;
11536                         op_null(oright);
11537                     }
11538                 }
11539             }
11540
11541             break;
11542         }
11543
11544         case OP_REVERSE: {
11545             OP *ourmark, *theirmark, *ourlast, *iter, *expushmark, *rv2av;
11546             OP *gvop = NULL;
11547             LISTOP *enter, *exlist;
11548
11549             if (o->op_private & OPpSORT_INPLACE)
11550                 break;
11551
11552             enter = (LISTOP *) o->op_next;
11553             if (!enter)
11554                 break;
11555             if (enter->op_type == OP_NULL) {
11556                 enter = (LISTOP *) enter->op_next;
11557                 if (!enter)
11558                     break;
11559             }
11560             /* for $a (...) will have OP_GV then OP_RV2GV here.
11561                for (...) just has an OP_GV.  */
11562             if (enter->op_type == OP_GV) {
11563                 gvop = (OP *) enter;
11564                 enter = (LISTOP *) enter->op_next;
11565                 if (!enter)
11566                     break;
11567                 if (enter->op_type == OP_RV2GV) {
11568                   enter = (LISTOP *) enter->op_next;
11569                   if (!enter)
11570                     break;
11571                 }
11572             }
11573
11574             if (enter->op_type != OP_ENTERITER)
11575                 break;
11576
11577             iter = enter->op_next;
11578             if (!iter || iter->op_type != OP_ITER)
11579                 break;
11580
11581             expushmark = enter->op_first;
11582             if (!expushmark || expushmark->op_type != OP_NULL
11583                 || expushmark->op_targ != OP_PUSHMARK)
11584                 break;
11585
11586             exlist = (LISTOP *) expushmark->op_sibling;
11587             if (!exlist || exlist->op_type != OP_NULL
11588                 || exlist->op_targ != OP_LIST)
11589                 break;
11590
11591             if (exlist->op_last != o) {
11592                 /* Mmm. Was expecting to point back to this op.  */
11593                 break;
11594             }
11595             theirmark = exlist->op_first;
11596             if (!theirmark || theirmark->op_type != OP_PUSHMARK)
11597                 break;
11598
11599             if (theirmark->op_sibling != o) {
11600                 /* There's something between the mark and the reverse, eg
11601                    for (1, reverse (...))
11602                    so no go.  */
11603                 break;
11604             }
11605
11606             ourmark = ((LISTOP *)o)->op_first;
11607             if (!ourmark || ourmark->op_type != OP_PUSHMARK)
11608                 break;
11609
11610             ourlast = ((LISTOP *)o)->op_last;
11611             if (!ourlast || ourlast->op_next != o)
11612                 break;
11613
11614             rv2av = ourmark->op_sibling;
11615             if (rv2av && rv2av->op_type == OP_RV2AV && rv2av->op_sibling == 0
11616                 && rv2av->op_flags == (OPf_WANT_LIST | OPf_KIDS)
11617                 && enter->op_flags == (OPf_WANT_LIST | OPf_KIDS)) {
11618                 /* We're just reversing a single array.  */
11619                 rv2av->op_flags = OPf_WANT_SCALAR | OPf_KIDS | OPf_REF;
11620                 enter->op_flags |= OPf_STACKED;
11621             }
11622
11623             /* We don't have control over who points to theirmark, so sacrifice
11624                ours.  */
11625             theirmark->op_next = ourmark->op_next;
11626             theirmark->op_flags = ourmark->op_flags;
11627             ourlast->op_next = gvop ? gvop : (OP *) enter;
11628             op_null(ourmark);
11629             op_null(o);
11630             enter->op_private |= OPpITER_REVERSED;
11631             iter->op_private |= OPpITER_REVERSED;
11632
11633             break;
11634         }
11635
11636         case OP_QR:
11637         case OP_MATCH:
11638             if (!(cPMOP->op_pmflags & PMf_ONCE)) {
11639                 assert (!cPMOP->op_pmstashstartu.op_pmreplstart);
11640             }
11641             break;
11642
11643         case OP_RUNCV:
11644             if (!(o->op_private & OPpOFFBYONE) && !CvCLONE(PL_compcv)) {
11645                 SV *sv;
11646                 if (CvEVAL(PL_compcv)) sv = &PL_sv_undef;
11647                 else {
11648                     sv = newRV((SV *)PL_compcv);
11649                     sv_rvweaken(sv);
11650                     SvREADONLY_on(sv);
11651                 }
11652                 o->op_type = OP_CONST;
11653                 o->op_ppaddr = PL_ppaddr[OP_CONST];
11654                 o->op_flags |= OPf_SPECIAL;
11655                 cSVOPo->op_sv = sv;
11656             }
11657             break;
11658
11659         case OP_SASSIGN:
11660             if (OP_GIMME(o,0) == G_VOID) {
11661                 OP *right = cBINOP->op_first;
11662                 if (right) {
11663                     OP *left = right->op_sibling;
11664                     if (left->op_type == OP_SUBSTR
11665                          && (left->op_private & 7) < 4) {
11666                         op_null(o);
11667                         cBINOP->op_first = left;
11668                         right->op_sibling =
11669                             cBINOPx(left)->op_first->op_sibling;
11670                         cBINOPx(left)->op_first->op_sibling = right;
11671                         left->op_private |= OPpSUBSTR_REPL_FIRST;
11672                         left->op_flags =
11673                             (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
11674                     }
11675                 }
11676             }
11677             break;
11678
11679         case OP_CUSTOM: {
11680             Perl_cpeep_t cpeep =
11681                 XopENTRY(Perl_custom_op_xop(aTHX_ o), xop_peep);
11682             if (cpeep)
11683                 cpeep(aTHX_ o, oldop);
11684             break;
11685         }
11686
11687         }
11688         oldoldop = oldop;
11689         oldop = o;
11690     }
11691     LEAVE;
11692 }
11693
11694 void
11695 Perl_peep(pTHX_ OP *o)
11696 {
11697     CALL_RPEEP(o);
11698 }
11699
11700 /*
11701 =head1 Custom Operators
11702
11703 =for apidoc Ao||custom_op_xop
11704 Return the XOP structure for a given custom op. This function should be
11705 considered internal to OP_NAME and the other access macros: use them instead.
11706
11707 =cut
11708 */
11709
11710 const XOP *
11711 Perl_custom_op_xop(pTHX_ const OP *o)
11712 {
11713     SV *keysv;
11714     HE *he = NULL;
11715     XOP *xop;
11716
11717     static const XOP xop_null = { 0, 0, 0, 0, 0 };
11718
11719     PERL_ARGS_ASSERT_CUSTOM_OP_XOP;
11720     assert(o->op_type == OP_CUSTOM);
11721
11722     /* This is wrong. It assumes a function pointer can be cast to IV,
11723      * which isn't guaranteed, but this is what the old custom OP code
11724      * did. In principle it should be safer to Copy the bytes of the
11725      * pointer into a PV: since the new interface is hidden behind
11726      * functions, this can be changed later if necessary.  */
11727     /* Change custom_op_xop if this ever happens */
11728     keysv = sv_2mortal(newSViv(PTR2IV(o->op_ppaddr)));
11729
11730     if (PL_custom_ops)
11731         he = hv_fetch_ent(PL_custom_ops, keysv, 0, 0);
11732
11733     /* assume noone will have just registered a desc */
11734     if (!he && PL_custom_op_names &&
11735         (he = hv_fetch_ent(PL_custom_op_names, keysv, 0, 0))
11736     ) {
11737         const char *pv;
11738         STRLEN l;
11739
11740         /* XXX does all this need to be shared mem? */
11741         Newxz(xop, 1, XOP);
11742         pv = SvPV(HeVAL(he), l);
11743         XopENTRY_set(xop, xop_name, savepvn(pv, l));
11744         if (PL_custom_op_descs &&
11745             (he = hv_fetch_ent(PL_custom_op_descs, keysv, 0, 0))
11746         ) {
11747             pv = SvPV(HeVAL(he), l);
11748             XopENTRY_set(xop, xop_desc, savepvn(pv, l));
11749         }
11750         Perl_custom_op_register(aTHX_ o->op_ppaddr, xop);
11751         return xop;
11752     }
11753
11754     if (!he) return &xop_null;
11755
11756     xop = INT2PTR(XOP *, SvIV(HeVAL(he)));
11757     return xop;
11758 }
11759
11760 /*
11761 =for apidoc Ao||custom_op_register
11762 Register a custom op. See L<perlguts/"Custom Operators">.
11763
11764 =cut
11765 */
11766
11767 void
11768 Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop)
11769 {
11770     SV *keysv;
11771
11772     PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER;
11773
11774     /* see the comment in custom_op_xop */
11775     keysv = sv_2mortal(newSViv(PTR2IV(ppaddr)));
11776
11777     if (!PL_custom_ops)
11778         PL_custom_ops = newHV();
11779
11780     if (!hv_store_ent(PL_custom_ops, keysv, newSViv(PTR2IV(xop)), 0))
11781         Perl_croak(aTHX_ "panic: can't register custom OP %s", xop->xop_name);
11782 }
11783
11784 /*
11785 =head1 Functions in file op.c
11786
11787 =for apidoc core_prototype
11788 This function assigns the prototype of the named core function to C<sv>, or
11789 to a new mortal SV if C<sv> is NULL.  It returns the modified C<sv>, or
11790 NULL if the core function has no prototype.  C<code> is a code as returned
11791 by C<keyword()>.  It must not be equal to 0 or -KEY_CORE.
11792
11793 =cut
11794 */
11795
11796 SV *
11797 Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code,
11798                           int * const opnum)
11799 {
11800     int i = 0, n = 0, seen_question = 0, defgv = 0;
11801     I32 oa;
11802 #define MAX_ARGS_OP ((sizeof(I32) - 1) * 2)
11803     char str[ MAX_ARGS_OP * 2 + 2 ]; /* One ';', one '\0' */
11804     bool nullret = FALSE;
11805
11806     PERL_ARGS_ASSERT_CORE_PROTOTYPE;
11807
11808     assert (code && code != -KEY_CORE);
11809
11810     if (!sv) sv = sv_newmortal();
11811
11812 #define retsetpvs(x,y) sv_setpvs(sv, x); if(opnum) *opnum=(y); return sv
11813
11814     switch (code < 0 ? -code : code) {
11815     case KEY_and   : case KEY_chop: case KEY_chomp:
11816     case KEY_cmp   : case KEY_defined: case KEY_delete: case KEY_exec  :
11817     case KEY_exists: case KEY_eq     : case KEY_ge    : case KEY_goto  :
11818     case KEY_grep  : case KEY_gt     : case KEY_last  : case KEY_le    :
11819     case KEY_lt    : case KEY_map    : case KEY_ne    : case KEY_next  :
11820     case KEY_or    : case KEY_print  : case KEY_printf: case KEY_qr    :
11821     case KEY_redo  : case KEY_require: case KEY_return: case KEY_say   :
11822     case KEY_select: case KEY_sort   : case KEY_split : case KEY_system:
11823     case KEY_x     : case KEY_xor    :
11824         if (!opnum) return NULL; nullret = TRUE; goto findopnum;
11825     case KEY_glob:    retsetpvs("_;", OP_GLOB);
11826     case KEY_keys:    retsetpvs("+", OP_KEYS);
11827     case KEY_values:  retsetpvs("+", OP_VALUES);
11828     case KEY_each:    retsetpvs("+", OP_EACH);
11829     case KEY_push:    retsetpvs("+@", OP_PUSH);
11830     case KEY_unshift: retsetpvs("+@", OP_UNSHIFT);
11831     case KEY_pop:     retsetpvs(";+", OP_POP);
11832     case KEY_shift:   retsetpvs(";+", OP_SHIFT);
11833     case KEY_pos:     retsetpvs(";\\[$*]", OP_POS);
11834     case KEY_splice:
11835         retsetpvs("+;$$@", OP_SPLICE);
11836     case KEY___FILE__: case KEY___LINE__: case KEY___PACKAGE__:
11837         retsetpvs("", 0);
11838     case KEY_evalbytes:
11839         name = "entereval"; break;
11840     case KEY_readpipe:
11841         name = "backtick";
11842     }
11843
11844 #undef retsetpvs
11845
11846   findopnum:
11847     while (i < MAXO) {  /* The slow way. */
11848         if (strEQ(name, PL_op_name[i])
11849             || strEQ(name, PL_op_desc[i]))
11850         {
11851             if (nullret) { assert(opnum); *opnum = i; return NULL; }
11852             goto found;
11853         }
11854         i++;
11855     }
11856     return NULL;
11857   found:
11858     defgv = PL_opargs[i] & OA_DEFGV;
11859     oa = PL_opargs[i] >> OASHIFT;
11860     while (oa) {
11861         if (oa & OA_OPTIONAL && !seen_question && (
11862               !defgv || (oa & (OA_OPTIONAL - 1)) == OA_FILEREF
11863         )) {
11864             seen_question = 1;
11865             str[n++] = ';';
11866         }
11867         if ((oa & (OA_OPTIONAL - 1)) >= OA_AVREF
11868             && (oa & (OA_OPTIONAL - 1)) <= OA_SCALARREF
11869             /* But globs are already references (kinda) */
11870             && (oa & (OA_OPTIONAL - 1)) != OA_FILEREF
11871         ) {
11872             str[n++] = '\\';
11873         }
11874         if ((oa & (OA_OPTIONAL - 1)) == OA_SCALARREF
11875          && !scalar_mod_type(NULL, i)) {
11876             str[n++] = '[';
11877             str[n++] = '$';
11878             str[n++] = '@';
11879             str[n++] = '%';
11880             if (i == OP_LOCK || i == OP_UNDEF) str[n++] = '&';
11881             str[n++] = '*';
11882             str[n++] = ']';
11883         }
11884         else str[n++] = ("?$@@%&*$")[oa & (OA_OPTIONAL - 1)];
11885         if (oa & OA_OPTIONAL && defgv && str[n-1] == '$') {
11886             str[n-1] = '_'; defgv = 0;
11887         }
11888         oa = oa >> 4;
11889     }
11890     if (code == -KEY_not || code == -KEY_getprotobynumber) str[n++] = ';';
11891     str[n++] = '\0';
11892     sv_setpvn(sv, str, n - 1);
11893     if (opnum) *opnum = i;
11894     return sv;
11895 }
11896
11897 OP *
11898 Perl_coresub_op(pTHX_ SV * const coreargssv, const int code,
11899                       const int opnum)
11900 {
11901     OP * const argop = newSVOP(OP_COREARGS,0,coreargssv);
11902     OP *o;
11903
11904     PERL_ARGS_ASSERT_CORESUB_OP;
11905
11906     switch(opnum) {
11907     case 0:
11908         return op_append_elem(OP_LINESEQ,
11909                        argop,
11910                        newSLICEOP(0,
11911                                   newSVOP(OP_CONST, 0, newSViv(-code % 3)),
11912                                   newOP(OP_CALLER,0)
11913                        )
11914                );
11915     case OP_SELECT: /* which represents OP_SSELECT as well */
11916         if (code)
11917             return newCONDOP(
11918                          0,
11919                          newBINOP(OP_GT, 0,
11920                                   newAVREF(newGVOP(OP_GV, 0, PL_defgv)),
11921                                   newSVOP(OP_CONST, 0, newSVuv(1))
11922                                  ),
11923                          coresub_op(newSVuv((UV)OP_SSELECT), 0,
11924                                     OP_SSELECT),
11925                          coresub_op(coreargssv, 0, OP_SELECT)
11926                    );
11927         /* FALL THROUGH */
11928     default:
11929         switch (PL_opargs[opnum] & OA_CLASS_MASK) {
11930         case OA_BASEOP:
11931             return op_append_elem(
11932                         OP_LINESEQ, argop,
11933                         newOP(opnum,
11934                               opnum == OP_WANTARRAY || opnum == OP_RUNCV
11935                                 ? OPpOFFBYONE << 8 : 0)
11936                    );
11937         case OA_BASEOP_OR_UNOP:
11938             if (opnum == OP_ENTEREVAL) {
11939                 o = newUNOP(OP_ENTEREVAL,OPpEVAL_COPHH<<8,argop);
11940                 if (code == -KEY_evalbytes) o->op_private |= OPpEVAL_BYTES;
11941             }
11942             else o = newUNOP(opnum,0,argop);
11943             if (opnum == OP_CALLER) o->op_private |= OPpOFFBYONE;
11944             else {
11945           onearg:
11946               if (is_handle_constructor(o, 1))
11947                 argop->op_private |= OPpCOREARGS_DEREF1;
11948               if (scalar_mod_type(NULL, opnum))
11949                 argop->op_private |= OPpCOREARGS_SCALARMOD;
11950             }
11951             return o;
11952         default:
11953             o = convert(opnum,OPf_SPECIAL*(opnum == OP_GLOB),argop);
11954             if (is_handle_constructor(o, 2))
11955                 argop->op_private |= OPpCOREARGS_DEREF2;
11956             if (opnum == OP_SUBSTR) {
11957                 o->op_private |= OPpMAYBE_LVSUB;
11958                 return o;
11959             }
11960             else goto onearg;
11961         }
11962     }
11963 }
11964
11965 void
11966 Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv,
11967                                SV * const *new_const_svp)
11968 {
11969     const char *hvname;
11970     bool is_const = !!CvCONST(old_cv);
11971     SV *old_const_sv = is_const ? cv_const_sv(old_cv) : NULL;
11972
11973     PERL_ARGS_ASSERT_REPORT_REDEFINED_CV;
11974
11975     if (is_const && new_const_svp && old_const_sv == *new_const_svp)
11976         return;
11977         /* They are 2 constant subroutines generated from
11978            the same constant. This probably means that
11979            they are really the "same" proxy subroutine
11980            instantiated in 2 places. Most likely this is
11981            when a constant is exported twice.  Don't warn.
11982         */
11983     if (
11984         (ckWARN(WARN_REDEFINE)
11985          && !(
11986                 CvGV(old_cv) && GvSTASH(CvGV(old_cv))
11987              && HvNAMELEN(GvSTASH(CvGV(old_cv))) == 7
11988              && (hvname = HvNAME(GvSTASH(CvGV(old_cv))),
11989                  strEQ(hvname, "autouse"))
11990              )
11991         )
11992      || (is_const
11993          && ckWARN_d(WARN_REDEFINE)
11994          && (!new_const_svp || sv_cmp(old_const_sv, *new_const_svp))
11995         )
11996     )
11997         Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
11998                           is_const
11999                             ? "Constant subroutine %"SVf" redefined"
12000                             : "Subroutine %"SVf" redefined",
12001                           name);
12002 }
12003
12004 /*
12005 =head1 Hook manipulation
12006
12007 These functions provide convenient and thread-safe means of manipulating
12008 hook variables.
12009
12010 =cut
12011 */
12012
12013 /*
12014 =for apidoc Am|void|wrap_op_checker|Optype opcode|Perl_check_t new_checker|Perl_check_t *old_checker_p
12015
12016 Puts a C function into the chain of check functions for a specified op
12017 type.  This is the preferred way to manipulate the L</PL_check> array.
12018 I<opcode> specifies which type of op is to be affected.  I<new_checker>
12019 is a pointer to the C function that is to be added to that opcode's
12020 check chain, and I<old_checker_p> points to the storage location where a
12021 pointer to the next function in the chain will be stored.  The value of
12022 I<new_pointer> is written into the L</PL_check> array, while the value
12023 previously stored there is written to I<*old_checker_p>.
12024
12025 L</PL_check> is global to an entire process, and a module wishing to
12026 hook op checking may find itself invoked more than once per process,
12027 typically in different threads.  To handle that situation, this function
12028 is idempotent.  The location I<*old_checker_p> must initially (once
12029 per process) contain a null pointer.  A C variable of static duration
12030 (declared at file scope, typically also marked C<static> to give
12031 it internal linkage) will be implicitly initialised appropriately,
12032 if it does not have an explicit initialiser.  This function will only
12033 actually modify the check chain if it finds I<*old_checker_p> to be null.
12034 This function is also thread safe on the small scale.  It uses appropriate
12035 locking to avoid race conditions in accessing L</PL_check>.
12036
12037 When this function is called, the function referenced by I<new_checker>
12038 must be ready to be called, except for I<*old_checker_p> being unfilled.
12039 In a threading situation, I<new_checker> may be called immediately,
12040 even before this function has returned.  I<*old_checker_p> will always
12041 be appropriately set before I<new_checker> is called.  If I<new_checker>
12042 decides not to do anything special with an op that it is given (which
12043 is the usual case for most uses of op check hooking), it must chain the
12044 check function referenced by I<*old_checker_p>.
12045
12046 If you want to influence compilation of calls to a specific subroutine,
12047 then use L</cv_set_call_checker> rather than hooking checking of all
12048 C<entersub> ops.
12049
12050 =cut
12051 */
12052
12053 void
12054 Perl_wrap_op_checker(pTHX_ Optype opcode,
12055     Perl_check_t new_checker, Perl_check_t *old_checker_p)
12056 {
12057     dVAR;
12058
12059     PERL_ARGS_ASSERT_WRAP_OP_CHECKER;
12060     if (*old_checker_p) return;
12061     OP_CHECK_MUTEX_LOCK;
12062     if (!*old_checker_p) {
12063         *old_checker_p = PL_check[opcode];
12064         PL_check[opcode] = new_checker;
12065     }
12066     OP_CHECK_MUTEX_UNLOCK;
12067 }
12068
12069 #include "XSUB.h"
12070
12071 /* Efficient sub that returns a constant scalar value. */
12072 static void
12073 const_sv_xsub(pTHX_ CV* cv)
12074 {
12075     dVAR;
12076     dXSARGS;
12077     SV *const sv = MUTABLE_SV(XSANY.any_ptr);
12078     PERL_UNUSED_ARG(items);
12079     if (!sv) {
12080         XSRETURN(0);
12081     }
12082     EXTEND(sp, 1);
12083     ST(0) = sv;
12084     XSRETURN(1);
12085 }
12086
12087 static void
12088 const_av_xsub(pTHX_ CV* cv)
12089 {
12090     dVAR;
12091     dXSARGS;
12092     AV * const av = MUTABLE_AV(XSANY.any_ptr);
12093     SP -= items;
12094     assert(av);
12095 #ifndef DEBUGGING
12096     if (!av) {
12097         XSRETURN(0);
12098     }
12099 #endif
12100     if (SvRMAGICAL(av))
12101         Perl_croak(aTHX_ "Magical list constants are not supported");
12102     if (GIMME_V != G_ARRAY) {
12103         EXTEND(SP, 1);
12104         ST(0) = newSViv((IV)AvFILLp(av)+1);
12105         XSRETURN(1);
12106     }
12107     EXTEND(SP, AvFILLp(av)+1);
12108     Copy(AvARRAY(av), &ST(0), AvFILLp(av)+1, SV *);
12109     XSRETURN(AvFILLp(av)+1);
12110 }
12111
12112 /*
12113  * Local variables:
12114  * c-indentation-style: bsd
12115  * c-basic-offset: 4
12116  * indent-tabs-mode: nil
12117  * End:
12118  *
12119  * ex: set ts=8 sts=4 sw=4 et:
12120  */