op.c

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