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