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