op.c

   1 /*    op.c
   2  *
   3  *    Copyright (c) 1991-1999, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 /*
  11  * "You see: Mr. Drogo, he married poor Miss Primula Brandybuck.  She was
  12  * our Mr. Bilbo's first cousin on the mother's side (her mother being the
  13  * youngest of the Old Took's daughters); and Mr. Drogo was his second
  14  * cousin.  So Mr. Frodo is his first *and* second cousin, once removed
  15  * either way, as the saying is, if you follow me."  --the Gaffer
  16  */
  17
  18 #include "EXTERN.h"
  19 #define PERL_IN_OP_C
  20 #include "perl.h"
  21 #include "keywords.h"
  22
  23 /* #define PL_OP_SLAB_ALLOC */
  24
  25 /* XXXXXX testing */
  26 #define OP_REFCNT_LOCK          NOOP
  27 #define OP_REFCNT_UNLOCK        NOOP
  28 #define OpREFCNT_set(o,n)       NOOP
  29 #define OpREFCNT_dec(o)         0
  30
  31 #ifdef PL_OP_SLAB_ALLOC
  32 #define SLAB_SIZE 8192
  33 static char    *PL_OpPtr  = NULL;
  34 static int     PL_OpSpace = 0;
  35 #define NewOp(m,var,c,type) do { if ((PL_OpSpace -= c*sizeof(type)) >= 0)     \
  36                               var =  (type *)(PL_OpPtr -= c*sizeof(type));    \
  37                              else                                             \
  38                               var = (type *) Slab_Alloc(m,c*sizeof(type));    \
  39                            } while (0)
  40
  41 STATIC void *
  42 S_Slab_Alloc(pTHX_ int m, size_t sz)
  43 {
  44  Newz(m,PL_OpPtr,SLAB_SIZE,char);
  45  PL_OpSpace = SLAB_SIZE - sz;
  46  return PL_OpPtr += PL_OpSpace;
  47 }
  48
  49 #else
  50 #define NewOp(m, var, c, type) Newz(m, var, c, type)
  51 #endif
  52 /*
  53  * In the following definition, the ", Nullop" is just to make the compiler
  54  * think the expression is of the right type: croak actually does a Siglongjmp.
  55  */
  56 #define CHECKOP(type,o) \
  57     ((PL_op_mask && PL_op_mask[type])                                   \
  58      ? ( op_free((OP*)o),                                       \
  59          Perl_croak(aTHX_ "%s trapped by operation mask", PL_op_desc[type]),    \
  60          Nullop )                                               \
  61      : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
  62
  63 #define PAD_MAX 999999999
  64
  65 STATIC char*
  66 S_gv_ename(pTHX_ GV *gv)
  67 {
  68     STRLEN n_a;
  69     SV* tmpsv = sv_newmortal();
  70     gv_efullname3(tmpsv, gv, Nullch);
  71     return SvPV(tmpsv,n_a);
  72 }
  73
  74 STATIC OP *
  75 S_no_fh_allowed(pTHX_ OP *o)
  76 {
  77     yyerror(Perl_form(aTHX_ "Missing comma after first argument to %s function",
  78                  PL_op_desc[o->op_type]));
  79     return o;
  80 }
  81
  82 STATIC OP *
  83 S_too_few_arguments(pTHX_ OP *o, char *name)
  84 {
  85     yyerror(Perl_form(aTHX_ "Not enough arguments for %s", name));
  86     return o;
  87 }
  88
  89 STATIC OP *
  90 S_too_many_arguments(pTHX_ OP *o, char *name)
  91 {
  92     yyerror(Perl_form(aTHX_ "Too many arguments for %s", name));
  93     return o;
  94 }
  95
  96 STATIC void
  97 S_bad_type(pTHX_ I32 n, char *t, char *name, OP *kid)
  98 {
  99     yyerror(Perl_form(aTHX_ "Type of arg %d to %s must be %s (not %s)",
 100                  (int)n, name, t, PL_op_desc[kid->op_type]));
 101 }
 102
 103 STATIC void
 104 S_no_bareword_allowed(pTHX_ OP *o)
 105 {
 106     qerror(Perl_mess(aTHX_
 107                      "Bareword \"%s\" not allowed while \"strict subs\" in use",
 108                      SvPV_nolen(cSVOPo->op_sv)));
 109 }
 110
 111 /* "register" allocation */
 112
 113 PADOFFSET
 114 Perl_pad_allocmy(pTHX_ char *name)
 115 {
 116     dTHR;
 117     PADOFFSET off;
 118     SV *sv;
 119
 120     if (!(
 121         PL_in_my == KEY_our ||
 122         isALPHA(name[1]) ||
 123         (PL_hints & HINT_UTF8 && (name[1] & 0xc0) == 0xc0) ||
 124         name[1] == '_' && (int)strlen(name) > 2 ))
 125     {
 126         if (!isPRINT(name[1]) || strchr("\t\n\r\f", name[1])) {
 127             /* 1999-02-27 mjd@plover.com */
 128             char *p;
 129             p = strchr(name, '\0');
 130             /* The next block assumes the buffer is at least 205 chars
 131                long.  At present, it's always at least 256 chars. */
 132             if (p-name > 200) {
 133                 strcpy(name+200, "...");
 134                 p = name+199;
 135             }
 136             else {
 137                 p[1] = '\0';
 138             }
 139             /* Move everything else down one character */
 140             for (; p-name > 2; p--)
 141                 *p = *(p-1);
 142             name[2] = toCTRL(name[1]);
 143             name[1] = '^';
 144         }
 145         yyerror(Perl_form(aTHX_ "Can't use global %s in \"my\"",name));
 146     }
 147     if (ckWARN(WARN_UNSAFE) && AvFILLp(PL_comppad_name) >= 0) {
 148         SV **svp = AvARRAY(PL_comppad_name);
 149         for (off = AvFILLp(PL_comppad_name); off > PL_comppad_name_floor; off--) {
 150             if ((sv = svp[off])
 151                 && sv != &PL_sv_undef
 152                 && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0)
 153                 && strEQ(name, SvPVX(sv)))
 154             {
 155                 Perl_warner(aTHX_ WARN_UNSAFE,
 156                         "\"%s\" variable %s masks earlier declaration in same %s",
 157                         (PL_in_my == KEY_our ? "our" : "my"),
 158                         name,
 159                         (SvIVX(sv) == PAD_MAX ? "scope" : "statement"));
 160                 break;
 161             }
 162         }
 163     }
 164     off = pad_alloc(OP_PADSV, SVs_PADMY);
 165     sv = NEWSV(1102,0);
 166     sv_upgrade(sv, SVt_PVNV);
 167     sv_setpv(sv, name);
 168     if (PL_in_my_stash) {
 169         if (*name != '$')
 170             yyerror(Perl_form(aTHX_ "Can't declare class for non-scalar %s in \"my\"",
 171                          name));
 172         SvOBJECT_on(sv);
 173         (void)SvUPGRADE(sv, SVt_PVMG);
 174         SvSTASH(sv) = (HV*)SvREFCNT_inc(PL_in_my_stash);
 175         PL_sv_objcount++;
 176     }
 177     if (PL_in_my == KEY_our)
 178         SvFLAGS(sv) |= SVpad_OUR;
 179     av_store(PL_comppad_name, off, sv);
 180     SvNVX(sv) = (NV)PAD_MAX;
 181     SvIVX(sv) = 0;                      /* Not yet introduced--see newSTATEOP */
 182     if (!PL_min_intro_pending)
 183         PL_min_intro_pending = off;
 184     PL_max_intro_pending = off;
 185     if (*name == '@')
 186         av_store(PL_comppad, off, (SV*)newAV());
 187     else if (*name == '%')
 188         av_store(PL_comppad, off, (SV*)newHV());
 189     SvPADMY_on(PL_curpad[off]);
 190     return off;
 191 }
 192
 193 #define FINDLEX_NOSEARCH        1               /* don't search outer contexts */
 194
 195 STATIC PADOFFSET
 196 S_pad_findlex(pTHX_ char *name, PADOFFSET newoff, U32 seq, CV* startcv,
 197             I32 cx_ix, I32 saweval, U32 flags)
 198 {
 199     dTHR;
 200     CV *cv;
 201     I32 off;
 202     SV *sv;
 203     register I32 i;
 204     register PERL_CONTEXT *cx;
 205
 206     for (cv = startcv; cv; cv = CvOUTSIDE(cv)) {
 207         AV *curlist = CvPADLIST(cv);
 208         SV **svp = av_fetch(curlist, 0, FALSE);
 209         AV *curname;
 210
 211         if (!svp || *svp == &PL_sv_undef)
 212             continue;
 213         curname = (AV*)*svp;
 214         svp = AvARRAY(curname);
 215         for (off = AvFILLp(curname); off > 0; off--) {
 216             if ((sv = svp[off]) &&
 217                 sv != &PL_sv_undef &&
 218                 seq <= SvIVX(sv) &&
 219                 seq > I_32(SvNVX(sv)) &&
 220                 strEQ(SvPVX(sv), name))
 221             {
 222                 I32 depth;
 223                 AV *oldpad;
 224                 SV *oldsv;
 225
 226                 depth = CvDEPTH(cv);
 227                 if (!depth) {
 228                     if (newoff) {
 229                         if (SvFAKE(sv))
 230                             continue;
 231                         return 0; /* don't clone from inactive stack frame */
 232                     }
 233                     depth = 1;
 234                 }
 235                 oldpad = (AV*)*av_fetch(curlist, depth, FALSE);
 236                 oldsv = *av_fetch(oldpad, off, TRUE);
 237                 if (!newoff) {          /* Not a mere clone operation. */
 238                     SV *namesv = NEWSV(1103,0);
 239                     newoff = pad_alloc(OP_PADSV, SVs_PADMY);
 240                     sv_upgrade(namesv, SVt_PVNV);
 241                     sv_setpv(namesv, name);
 242                     av_store(PL_comppad_name, newoff, namesv);
 243                     SvNVX(namesv) = (NV)PL_curcop->cop_seq;
 244                     SvIVX(namesv) = PAD_MAX;    /* A ref, intro immediately */
 245                     SvFAKE_on(namesv);          /* A ref, not a real var */
 246                     if (SvFLAGS(sv) & SVpad_OUR)/* An "our" variable */
 247                         SvFLAGS(namesv) |= SVpad_OUR;
 248                     if (SvOBJECT(sv)) {         /* A typed var */
 249                         SvOBJECT_on(namesv);
 250                         (void)SvUPGRADE(namesv, SVt_PVMG);
 251                         SvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*)SvSTASH(sv));
 252                         PL_sv_objcount++;
 253                     }
 254                     if (CvANON(PL_compcv) || SvTYPE(PL_compcv) == SVt_PVFM) {
 255                         /* "It's closures all the way down." */
 256                         CvCLONE_on(PL_compcv);
 257                         if (cv == startcv) {
 258                             if (CvANON(PL_compcv))
 259                                 oldsv = Nullsv; /* no need to keep ref */
 260                         }
 261                         else {
 262                             CV *bcv;
 263                             for (bcv = startcv;
 264                                  bcv && bcv != cv && !CvCLONE(bcv);
 265                                  bcv = CvOUTSIDE(bcv))
 266                             {
 267                                 if (CvANON(bcv))
 268                                     CvCLONE_on(bcv);
 269                                 else {
 270                                     if (ckWARN(WARN_CLOSURE)
 271                                         && !CvUNIQUE(bcv) && !CvUNIQUE(cv))
 272                                     {
 273                                         Perl_warner(aTHX_ WARN_CLOSURE,
 274                                           "Variable \"%s\" may be unavailable",
 275                                              name);
 276                                     }
 277                                     break;
 278                                 }
 279                             }
 280                         }
 281                     }
 282                     else if (!CvUNIQUE(PL_compcv)) {
 283                         if (ckWARN(WARN_CLOSURE) && !SvFAKE(sv) && !CvUNIQUE(cv))
 284                             Perl_warner(aTHX_ WARN_CLOSURE,
 285                                 "Variable \"%s\" will not stay shared", name);
 286                     }
 287                 }
 288                 av_store(PL_comppad, newoff, SvREFCNT_inc(oldsv));
 289                 return newoff;
 290             }
 291         }
 292     }
 293
 294     if (flags & FINDLEX_NOSEARCH)
 295         return 0;
 296
 297     /* Nothing in current lexical context--try eval's context, if any.
 298      * This is necessary to let the perldb get at lexically scoped variables.
 299      * XXX This will also probably interact badly with eval tree caching.
 300      */
 301
 302     for (i = cx_ix; i >= 0; i--) {
 303         cx = &cxstack[i];
 304         switch (CxTYPE(cx)) {
 305         default:
 306             if (i == 0 && saweval) {
 307                 seq = cxstack[saweval].blk_oldcop->cop_seq;
 308                 return pad_findlex(name, newoff, seq, PL_main_cv, -1, saweval, 0);
 309             }
 310             break;
 311         case CXt_EVAL:
 312             switch (cx->blk_eval.old_op_type) {
 313             case OP_ENTEREVAL:
 314                 if (CxREALEVAL(cx))
 315                     saweval = i;
 316                 break;
 317             case OP_REQUIRE:
 318                 /* require must have its own scope */
 319                 return 0;
 320             }
 321             break;
 322         case CXt_SUB:
 323             if (!saweval)
 324                 return 0;
 325             cv = cx->blk_sub.cv;
 326             if (PL_debstash && CvSTASH(cv) == PL_debstash) {    /* ignore DB'* scope */
 327                 saweval = i;    /* so we know where we were called from */
 328                 continue;
 329             }
 330             seq = cxstack[saweval].blk_oldcop->cop_seq;
 331             return pad_findlex(name, newoff, seq, cv, i-1, saweval,FINDLEX_NOSEARCH);
 332         }
 333     }
 334
 335     return 0;
 336 }
 337
 338 PADOFFSET
 339 Perl_pad_findmy(pTHX_ char *name)
 340 {
 341     dTHR;
 342     I32 off;
 343     I32 pendoff = 0;
 344     SV *sv;
 345     SV **svp = AvARRAY(PL_comppad_name);
 346     U32 seq = PL_cop_seqmax;
 347     PERL_CONTEXT *cx;
 348     CV *outside;
 349
 350 #ifdef USE_THREADS
 351     /*
 352      * Special case to get lexical (and hence per-thread) @_.
 353      * XXX I need to find out how to tell at parse-time whether use
 354      * of @_ should refer to a lexical (from a sub) or defgv (global
 355      * scope and maybe weird sub-ish things like formats). See
 356      * startsub in perly.y.  It's possible that @_ could be lexical
 357      * (at least from subs) even in non-threaded perl.
 358      */
 359     if (strEQ(name, "@_"))
 360         return 0;               /* success. (NOT_IN_PAD indicates failure) */
 361 #endif /* USE_THREADS */
 362
 363     /* The one we're looking for is probably just before comppad_name_fill. */
 364     for (off = AvFILLp(PL_comppad_name); off > 0; off--) {
 365         if ((sv = svp[off]) &&
 366             sv != &PL_sv_undef &&
 367             (!SvIVX(sv) ||
 368              (seq <= SvIVX(sv) &&
 369               seq > I_32(SvNVX(sv)))) &&
 370             strEQ(SvPVX(sv), name))
 371         {
 372             if (SvIVX(sv) || SvFLAGS(sv) & SVpad_OUR)
 373                 return (PADOFFSET)off;
 374             pendoff = off;      /* this pending def. will override import */
 375         }
 376     }
 377
 378     outside = CvOUTSIDE(PL_compcv);
 379
 380     /* Check if if we're compiling an eval'', and adjust seq to be the
 381      * eval's seq number.  This depends on eval'' having a non-null
 382      * CvOUTSIDE() while it is being compiled.  The eval'' itself is
 383      * identified by CvEVAL being true and CvGV being null. */
 384     if (outside && CvEVAL(PL_compcv) && !CvGV(PL_compcv) && cxstack_ix >= 0) {
 385         cx = &cxstack[cxstack_ix];
 386         if (CxREALEVAL(cx))
 387             seq = cx->blk_oldcop->cop_seq;
 388     }
 389
 390     /* See if it's in a nested scope */
 391     off = pad_findlex(name, 0, seq, outside, cxstack_ix, 0, 0);
 392     if (off) {
 393         /* If there is a pending local definition, this new alias must die */
 394         if (pendoff)
 395             SvIVX(AvARRAY(PL_comppad_name)[off]) = seq;
 396         return off;             /* pad_findlex returns 0 for failure...*/
 397     }
 398     return NOT_IN_PAD;          /* ...but we return NOT_IN_PAD for failure */
 399 }
 400
 401 void
 402 Perl_pad_leavemy(pTHX_ I32 fill)
 403 {
 404     dTHR;
 405     I32 off;
 406     SV **svp = AvARRAY(PL_comppad_name);
 407     SV *sv;
 408     if (PL_min_intro_pending && fill < PL_min_intro_pending) {
 409         for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) {
 410             if ((sv = svp[off]) && sv != &PL_sv_undef && ckWARN_d(WARN_INTERNAL))
 411                 Perl_warner(aTHX_ WARN_INTERNAL, "%s never introduced", SvPVX(sv));
 412         }
 413     }
 414     /* "Deintroduce" my variables that are leaving with this scope. */
 415     for (off = AvFILLp(PL_comppad_name); off > fill; off--) {
 416         if ((sv = svp[off]) && sv != &PL_sv_undef && SvIVX(sv) == PAD_MAX)
 417             SvIVX(sv) = PL_cop_seqmax;
 418     }
 419 }
 420
 421 PADOFFSET
 422 Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
 423 {
 424     dTHR;
 425     SV *sv;
 426     I32 retval;
 427
 428     if (AvARRAY(PL_comppad) != PL_curpad)
 429         Perl_croak(aTHX_ "panic: pad_alloc");
 430     if (PL_pad_reset_pending)
 431         pad_reset();
 432     if (tmptype & SVs_PADMY) {
 433         do {
 434             sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE);
 435         } while (SvPADBUSY(sv));                /* need a fresh one */
 436         retval = AvFILLp(PL_comppad);
 437     }
 438     else {
 439         SV **names = AvARRAY(PL_comppad_name);
 440         SSize_t names_fill = AvFILLp(PL_comppad_name);
 441         for (;;) {
 442             /*
 443              * "foreach" index vars temporarily become aliases to non-"my"
 444              * values.  Thus we must skip, not just pad values that are
 445              * marked as current pad values, but also those with names.
 446              */
 447             if (++PL_padix <= names_fill &&
 448                    (sv = names[PL_padix]) && sv != &PL_sv_undef)
 449                 continue;
 450             sv = *av_fetch(PL_comppad, PL_padix, TRUE);
 451             if (!(SvFLAGS(sv) & (SVs_PADTMP|SVs_PADMY)))
 452                 break;
 453         }
 454         retval = PL_padix;
 455     }
 456     SvFLAGS(sv) |= tmptype;
 457     PL_curpad = AvARRAY(PL_comppad);
 458 #ifdef USE_THREADS
 459     DEBUG_X(PerlIO_printf(Perl_debug_log,
 460                           "0x%"UVxf" Pad 0x%"UVxf" alloc %ld for %s\n",
 461                           PTR2UV(thr), PTR2UV(PL_curpad),
 462                           (long) retval, PL_op_name[optype]));
 463 #else
 464     DEBUG_X(PerlIO_printf(Perl_debug_log,
 465                           "Pad 0x%"UVxf" alloc %ld for %s\n",
 466                           PTR2UV(PL_curpad),
 467                           (long) retval, PL_op_name[optype]));
 468 #endif /* USE_THREADS */
 469     return (PADOFFSET)retval;
 470 }
 471
 472 SV *
 473 Perl_pad_sv(pTHX_ PADOFFSET po)
 474 {
 475     dTHR;
 476 #ifdef USE_THREADS
 477     DEBUG_X(PerlIO_printf(Perl_debug_log,
 478                           "0x%"UVxf" Pad 0x%"UVxf" sv %d\n",
 479                           PTR2UV(thr), PTR2UV(PL_curpad), po));
 480 #else
 481     if (!po)
 482         Perl_croak(aTHX_ "panic: pad_sv po");
 483     DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" sv %d\n",
 484                           PTR2UV(PL_curpad), po));
 485 #endif /* USE_THREADS */
 486     return PL_curpad[po];               /* eventually we'll turn this into a macro */
 487 }
 488
 489 void
 490 Perl_pad_free(pTHX_ PADOFFSET po)
 491 {
 492     dTHR;
 493     if (!PL_curpad)
 494         return;
 495     if (AvARRAY(PL_comppad) != PL_curpad)
 496         Perl_croak(aTHX_ "panic: pad_free curpad");
 497     if (!po)
 498         Perl_croak(aTHX_ "panic: pad_free po");
 499 #ifdef USE_THREADS
 500     DEBUG_X(PerlIO_printf(Perl_debug_log,
 501                           "0x%"UVxf" Pad 0x%"UVxf" free %d\n",
 502                           PTR2UV(thr), PTR2UV(PL_curpad), po));
 503 #else
 504     DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" free %d\n",
 505                           PTR2UV(PL_curpad), po));
 506 #endif /* USE_THREADS */
 507     if (PL_curpad[po] && PL_curpad[po] != &PL_sv_undef)
 508         SvPADTMP_off(PL_curpad[po]);
 509     if ((I32)po < PL_padix)
 510         PL_padix = po - 1;
 511 }
 512
 513 void
 514 Perl_pad_swipe(pTHX_ PADOFFSET po)
 515 {
 516     dTHR;
 517     if (AvARRAY(PL_comppad) != PL_curpad)
 518         Perl_croak(aTHX_ "panic: pad_swipe curpad");
 519     if (!po)
 520         Perl_croak(aTHX_ "panic: pad_swipe po");
 521 #ifdef USE_THREADS
 522     DEBUG_X(PerlIO_printf(Perl_debug_log,
 523                           "0x%"UVxf" Pad 0x%"UVxf" swipe %d\n",
 524                           PTR2UV(thr), PTR2UV(PL_curpad), po));
 525 #else
 526     DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" swipe %d\n",
 527                           PTR2UV(PL_curpad), po));
 528 #endif /* USE_THREADS */
 529     SvPADTMP_off(PL_curpad[po]);
 530     PL_curpad[po] = NEWSV(1107,0);
 531     SvPADTMP_on(PL_curpad[po]);
 532     if ((I32)po < PL_padix)
 533         PL_padix = po - 1;
 534 }
 535
 536 /* XXX pad_reset() is currently disabled because it results in serious bugs.
 537  * It causes pad temp TARGs to be shared between OPs. Since TARGs are pushed
 538  * on the stack by OPs that use them, there are several ways to get an alias
 539  * to  a shared TARG.  Such an alias will change randomly and unpredictably.
 540  * We avoid doing this until we can think of a Better Way.
 541  * GSAR 97-10-29 */
 542 void
 543 Perl_pad_reset(pTHX)
 544 {
 545 #ifdef USE_BROKEN_PAD_RESET
 546     dTHR;
 547     register I32 po;
 548
 549     if (AvARRAY(PL_comppad) != PL_curpad)
 550         Perl_croak(aTHX_ "panic: pad_reset curpad");
 551 #ifdef USE_THREADS
 552     DEBUG_X(PerlIO_printf(Perl_debug_log,
 553                           "0x%"UVxf" Pad 0x%"UVxf" reset\n",
 554                           PTR2UV(thr), PTR2UV(PL_curpad)));
 555 #else
 556     DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" reset\n",
 557                           PTR2UV(PL_curpad)));
 558 #endif /* USE_THREADS */
 559     if (!PL_tainting) { /* Can't mix tainted and non-tainted temporaries. */
 560         for (po = AvMAX(PL_comppad); po > PL_padix_floor; po--) {
 561             if (PL_curpad[po] && !SvIMMORTAL(PL_curpad[po]))
 562                 SvPADTMP_off(PL_curpad[po]);
 563         }
 564         PL_padix = PL_padix_floor;
 565     }
 566 #endif
 567     PL_pad_reset_pending = FALSE;
 568 }
 569
 570 #ifdef USE_THREADS
 571 /* find_threadsv is not reentrant */
 572 PADOFFSET
 573 Perl_find_threadsv(pTHX_ const char *name)
 574 {
 575     dTHR;
 576     char *p;
 577     PADOFFSET key;
 578     SV **svp;
 579     /* We currently only handle names of a single character */
 580     p = strchr(PL_threadsv_names, *name);
 581     if (!p)
 582         return NOT_IN_PAD;
 583     key = p - PL_threadsv_names;
 584     MUTEX_LOCK(&thr->mutex);
 585     svp = av_fetch(thr->threadsv, key, FALSE);
 586     if (svp)
 587         MUTEX_UNLOCK(&thr->mutex);
 588     else {
 589         SV *sv = NEWSV(0, 0);
 590         av_store(thr->threadsv, key, sv);
 591         thr->threadsvp = AvARRAY(thr->threadsv);
 592         MUTEX_UNLOCK(&thr->mutex);
 593         /*
 594          * Some magic variables used to be automagically initialised
 595          * in gv_fetchpv. Those which are now per-thread magicals get
 596          * initialised here instead.
 597          */
 598         switch (*name) {
 599         case '_':
 600             break;
 601         case ';':
 602             sv_setpv(sv, "\034");
 603             sv_magic(sv, 0, 0, name, 1);
 604             break;
 605         case '&':
 606         case '`':
 607         case '\'':
 608             PL_sawampersand = TRUE;
 609             /* FALL THROUGH */
 610         case '1':
 611         case '2':
 612         case '3':
 613         case '4':
 614         case '5':
 615         case '6':
 616         case '7':
 617         case '8':
 618         case '9':
 619             SvREADONLY_on(sv);
 620             /* FALL THROUGH */
 621
 622         /* XXX %! tied to Errno.pm needs to be added here.
 623          * See gv_fetchpv(). */
 624         /* case '!': */
 625
 626         default:
 627             sv_magic(sv, 0, 0, name, 1);
 628         }
 629         DEBUG_S(PerlIO_printf(Perl_error_log,
 630                               "find_threadsv: new SV %p for $%s%c\n",
 631                               sv, (*name < 32) ? "^" : "",
 632                               (*name < 32) ? toCTRL(*name) : *name));
 633     }
 634     return key;
 635 }
 636 #endif /* USE_THREADS */
 637
 638 /* Destructor */
 639
 640 void
 641 Perl_op_free(pTHX_ OP *o)
 642 {
 643     register OP *kid, *nextkid;
 644     OPCODE type;
 645
 646     if (!o || o->op_seq == (U16)-1)
 647         return;
 648
 649     if (o->op_private & OPpREFCOUNTED) {
 650         switch (o->op_type) {
 651         case OP_LEAVESUB:
 652         case OP_LEAVESUBLV:
 653         case OP_LEAVEEVAL:
 654         case OP_LEAVE:
 655         case OP_SCOPE:
 656         case OP_LEAVEWRITE:
 657             OP_REFCNT_LOCK;
 658             if (OpREFCNT_dec(o)) {
 659                 OP_REFCNT_UNLOCK;
 660                 return;
 661             }
 662             OP_REFCNT_UNLOCK;
 663             break;
 664         default:
 665             break;
 666         }
 667     }
 668
 669     if (o->op_flags & OPf_KIDS) {
 670         for (kid = cUNOPo->op_first; kid; kid = nextkid) {
 671             nextkid = kid->op_sibling; /* Get before next freeing kid */
 672             op_free(kid);
 673         }
 674     }
 675     type = o->op_type;
 676     if (type == OP_NULL)
 677         type = o->op_targ;
 678
 679     /* COP* is not cleared by op_clear() so that we may track line
 680      * numbers etc even after null() */
 681     if (type == OP_NEXTSTATE || type == OP_SETSTATE || type == OP_DBSTATE)
 682         cop_free((COP*)o);
 683
 684     op_clear(o);
 685
 686 #ifdef PL_OP_SLAB_ALLOC
 687     if ((char *) o == PL_OpPtr)
 688      {
 689      }
 690 #else
 691     Safefree(o);
 692 #endif
 693 }
 694
 695 STATIC void
 696 S_op_clear(pTHX_ OP *o)
 697 {
 698     switch (o->op_type) {
 699     case OP_NULL:       /* Was holding old type, if any. */
 700     case OP_ENTEREVAL:  /* Was holding hints. */
 701 #ifdef USE_THREADS
 702     case OP_THREADSV:   /* Was holding index into thr->threadsv AV. */
 703 #endif
 704         o->op_targ = 0;
 705         break;
 706 #ifdef USE_THREADS
 707     case OP_ENTERITER:
 708         if (!(o->op_flags & OPf_SPECIAL))
 709             break;
 710         /* FALL THROUGH */
 711 #endif /* USE_THREADS */
 712     default:
 713         if (!(o->op_flags & OPf_REF)
 714             || (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)))
 715             break;
 716         /* FALL THROUGH */
 717     case OP_GVSV:
 718     case OP_GV:
 719     case OP_AELEMFAST:
 720         SvREFCNT_dec(cSVOPo->op_sv);
 721         cSVOPo->op_sv = Nullsv;
 722         break;
 723     case OP_CONST:
 724         SvREFCNT_dec(cSVOPo->op_sv);
 725         cSVOPo->op_sv = Nullsv;
 726         break;
 727     case OP_GOTO:
 728     case OP_NEXT:
 729     case OP_LAST:
 730     case OP_REDO:
 731         if (o->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
 732             break;
 733         /* FALL THROUGH */
 734     case OP_TRANS:
 735         if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
 736             SvREFCNT_dec(cSVOPo->op_sv);
 737             cSVOPo->op_sv = Nullsv;
 738         }
 739         else {
 740             Safefree(cPVOPo->op_pv);
 741             cPVOPo->op_pv = Nullch;
 742         }
 743         break;
 744     case OP_SUBST:
 745         op_free(cPMOPo->op_pmreplroot);
 746         cPMOPo->op_pmreplroot = Nullop;
 747         /* FALL THROUGH */
 748     case OP_PUSHRE:
 749     case OP_MATCH:
 750     case OP_QR:
 751         ReREFCNT_dec(cPMOPo->op_pmregexp);
 752         cPMOPo->op_pmregexp = (REGEXP*)NULL;
 753         break;
 754     }
 755
 756     if (o->op_targ > 0)
 757         pad_free(o->op_targ);
 758 }
 759
 760 STATIC void
 761 S_cop_free(pTHX_ COP* cop)
 762 {
 763     Safefree(cop->cop_label);
 764     SvREFCNT_dec(cop->cop_filegv);
 765     if (! specialWARN(cop->cop_warnings))
 766         SvREFCNT_dec(cop->cop_warnings);
 767 }
 768
 769 STATIC void
 770 S_null(pTHX_ OP *o)
 771 {
 772     if (o->op_type == OP_NULL)
 773         return;
 774     op_clear(o);
 775     o->op_targ = o->op_type;
 776     o->op_type = OP_NULL;
 777     o->op_ppaddr = PL_ppaddr[OP_NULL];
 778 }
 779
 780 /* Contextualizers */
 781
 782 #define LINKLIST(o) ((o)->op_next ? (o)->op_next : linklist((OP*)o))
 783
 784 OP *
 785 Perl_linklist(pTHX_ OP *o)
 786 {
 787     register OP *kid;
 788
 789     if (o->op_next)
 790         return o->op_next;
 791
 792     /* establish postfix order */
 793     if (cUNOPo->op_first) {
 794         o->op_next = LINKLIST(cUNOPo->op_first);
 795         for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
 796             if (kid->op_sibling)
 797                 kid->op_next = LINKLIST(kid->op_sibling);
 798             else
 799                 kid->op_next = o;
 800         }
 801     }
 802     else
 803         o->op_next = o;
 804
 805     return o->op_next;
 806 }
 807
 808 OP *
 809 Perl_scalarkids(pTHX_ OP *o)
 810 {
 811     OP *kid;
 812     if (o && o->op_flags & OPf_KIDS) {
 813         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
 814             scalar(kid);
 815     }
 816     return o;
 817 }
 818
 819 STATIC OP *
 820 S_scalarboolean(pTHX_ OP *o)
 821 {
 822     if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
 823         dTHR;
 824         if (ckWARN(WARN_SYNTAX)) {
 825             line_t oldline = PL_curcop->cop_line;
 826
 827             if (PL_copline != NOLINE)
 828                 PL_curcop->cop_line = PL_copline;
 829             Perl_warner(aTHX_ WARN_SYNTAX, "Found = in conditional, should be ==");
 830             PL_curcop->cop_line = oldline;
 831         }
 832     }
 833     return scalar(o);
 834 }
 835
 836 OP *
 837 Perl_scalar(pTHX_ OP *o)
 838 {
 839     OP *kid;
 840
 841     /* assumes no premature commitment */
 842     if (!o || (o->op_flags & OPf_WANT) || PL_error_count
 843          || o->op_type == OP_RETURN)
 844         return o;
 845
 846     if ((o->op_private & OPpTARGET_MY)
 847         && (PL_opargs[o->op_type] & OA_TARGLEX)) /* OPp share the meaning */
 848         return scalar(o);                       /* As if inside SASSIGN */
 849
 850     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
 851
 852     switch (o->op_type) {
 853     case OP_REPEAT:
 854         if (o->op_private & OPpREPEAT_DOLIST)
 855             null(((LISTOP*)cBINOPo->op_first)->op_first);
 856         scalar(cBINOPo->op_first);
 857         break;
 858     case OP_OR:
 859     case OP_AND:
 860     case OP_COND_EXPR:
 861         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
 862             scalar(kid);
 863         break;
 864     case OP_SPLIT:
 865         if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
 866             if (!kPMOP->op_pmreplroot)
 867                 deprecate("implicit split to @_");
 868         }
 869         /* FALL THROUGH */
 870     case OP_MATCH:
 871     case OP_QR:
 872     case OP_SUBST:
 873     case OP_NULL:
 874     default:
 875         if (o->op_flags & OPf_KIDS) {
 876             for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
 877                 scalar(kid);
 878         }
 879         break;
 880     case OP_LEAVE:
 881     case OP_LEAVETRY:
 882         kid = cLISTOPo->op_first;
 883         scalar(kid);
 884         while (kid = kid->op_sibling) {
 885             if (kid->op_sibling)
 886                 scalarvoid(kid);
 887             else
 888                 scalar(kid);
 889         }
 890         WITH_THR(PL_curcop = &PL_compiling);
 891         break;
 892     case OP_SCOPE:
 893     case OP_LINESEQ:
 894     case OP_LIST:
 895         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
 896             if (kid->op_sibling)
 897                 scalarvoid(kid);
 898             else
 899                 scalar(kid);
 900         }
 901         WITH_THR(PL_curcop = &PL_compiling);
 902         break;
 903     }
 904     return o;
 905 }
 906
 907 OP *
 908 Perl_scalarvoid(pTHX_ OP *o)
 909 {
 910     OP *kid;
 911     char* useless = 0;
 912     SV* sv;
 913     U8 want;
 914
 915     if (o->op_type == OP_NEXTSTATE
 916         || o->op_type == OP_SETSTATE
 917         || o->op_type == OP_DBSTATE
 918         || (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
 919                                       || o->op_targ == OP_SETSTATE
 920                                       || o->op_targ == OP_DBSTATE)))
 921     {
 922         dTHR;
 923         PL_curcop = (COP*)o;            /* for warning below */
 924     }
 925
 926     /* assumes no premature commitment */
 927     want = o->op_flags & OPf_WANT;
 928     if ((want && want != OPf_WANT_SCALAR) || PL_error_count
 929          || o->op_type == OP_RETURN)
 930         return o;
 931
 932     if ((o->op_private & OPpTARGET_MY)
 933         && (PL_opargs[o->op_type] & OA_TARGLEX)) /* OPp share the meaning */
 934         return scalar(o);                       /* As if inside SASSIGN */
 935
 936     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
 937
 938     switch (o->op_type) {
 939     default:
 940         if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
 941             break;
 942         /* FALL THROUGH */
 943     case OP_REPEAT:
 944         if (o->op_flags & OPf_STACKED)
 945             break;
 946         goto func_ops;
 947     case OP_SUBSTR:
 948         if (o->op_private == 4)
 949             break;
 950         /* FALL THROUGH */
 951     case OP_GVSV:
 952     case OP_WANTARRAY:
 953     case OP_GV:
 954     case OP_PADSV:
 955     case OP_PADAV:
 956     case OP_PADHV:
 957     case OP_PADANY:
 958     case OP_AV2ARYLEN:
 959     case OP_REF:
 960     case OP_REFGEN:
 961     case OP_SREFGEN:
 962     case OP_DEFINED:
 963     case OP_HEX:
 964     case OP_OCT:
 965     case OP_LENGTH:
 966     case OP_VEC:
 967     case OP_INDEX:
 968     case OP_RINDEX:
 969     case OP_SPRINTF:
 970     case OP_AELEM:
 971     case OP_AELEMFAST:
 972     case OP_ASLICE:
 973     case OP_HELEM:
 974     case OP_HSLICE:
 975     case OP_UNPACK:
 976     case OP_PACK:
 977     case OP_JOIN:
 978     case OP_LSLICE:
 979     case OP_ANONLIST:
 980     case OP_ANONHASH:
 981     case OP_SORT:
 982     case OP_REVERSE:
 983     case OP_RANGE:
 984     case OP_FLIP:
 985     case OP_FLOP:
 986     case OP_CALLER:
 987     case OP_FILENO:
 988     case OP_EOF:
 989     case OP_TELL:
 990     case OP_GETSOCKNAME:
 991     case OP_GETPEERNAME:
 992     case OP_READLINK:
 993     case OP_TELLDIR:
 994     case OP_GETPPID:
 995     case OP_GETPGRP:
 996     case OP_GETPRIORITY:
 997     case OP_TIME:
 998     case OP_TMS:
 999     case OP_LOCALTIME:
1000     case OP_GMTIME:
1001     case OP_GHBYNAME:
1002     case OP_GHBYADDR:
1003     case OP_GHOSTENT:
1004     case OP_GNBYNAME:
1005     case OP_GNBYADDR:
1006     case OP_GNETENT:
1007     case OP_GPBYNAME:
1008     case OP_GPBYNUMBER:
1009     case OP_GPROTOENT:
1010     case OP_GSBYNAME:
1011     case OP_GSBYPORT:
1012     case OP_GSERVENT:
1013     case OP_GPWNAM:
1014     case OP_GPWUID:
1015     case OP_GGRNAM:
1016     case OP_GGRGID:
1017     case OP_GETLOGIN:
1018       func_ops:
1019         if (!(o->op_private & OPpLVAL_INTRO))
1020             useless = PL_op_desc[o->op_type];
1021         break;
1022
1023     case OP_RV2GV:
1024     case OP_RV2SV:
1025     case OP_RV2AV:
1026     case OP_RV2HV:
1027         if (!(o->op_private & OPpLVAL_INTRO) &&
1028                 (!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
1029             useless = "a variable";
1030         break;
1031
1032     case OP_CONST:
1033         sv = cSVOPo->op_sv;
1034         if (cSVOPo->op_private & OPpCONST_STRICT)
1035             no_bareword_allowed(o);
1036         else {
1037             dTHR;
1038             if (ckWARN(WARN_VOID)) {
1039                 useless = "a constant";
1040                 if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
1041                     useless = 0;
1042                 else if (SvPOK(sv)) {
1043                     if (strnEQ(SvPVX(sv), "di", 2) ||
1044                         strnEQ(SvPVX(sv), "ds", 2) ||
1045                         strnEQ(SvPVX(sv), "ig", 2))
1046                             useless = 0;
1047                 }
1048             }
1049         }
1050         null(o);                /* don't execute or even remember it */
1051         break;
1052
1053     case OP_POSTINC:
1054         o->op_type = OP_PREINC;         /* pre-increment is faster */
1055         o->op_ppaddr = PL_ppaddr[OP_PREINC];
1056         break;
1057
1058     case OP_POSTDEC:
1059         o->op_type = OP_PREDEC;         /* pre-decrement is faster */
1060         o->op_ppaddr = PL_ppaddr[OP_PREDEC];
1061         break;
1062
1063     case OP_OR:
1064     case OP_AND:
1065     case OP_COND_EXPR:
1066         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1067             scalarvoid(kid);
1068         break;
1069
1070     case OP_NULL:
1071         if (o->op_flags & OPf_STACKED)
1072             break;
1073         /* FALL THROUGH */
1074     case OP_NEXTSTATE:
1075     case OP_DBSTATE:
1076     case OP_ENTERTRY:
1077     case OP_ENTER:
1078     case OP_SCALAR:
1079         if (!(o->op_flags & OPf_KIDS))
1080             break;
1081         /* FALL THROUGH */
1082     case OP_SCOPE:
1083     case OP_LEAVE:
1084     case OP_LEAVETRY:
1085     case OP_LEAVELOOP:
1086     case OP_LINESEQ:
1087     case OP_LIST:
1088         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1089             scalarvoid(kid);
1090         break;
1091     case OP_ENTEREVAL:
1092         scalarkids(o);
1093         break;
1094     case OP_REQUIRE:
1095         /* all requires must return a boolean value */
1096         o->op_flags &= ~OPf_WANT;
1097         return scalar(o);
1098     case OP_SPLIT:
1099         if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
1100             if (!kPMOP->op_pmreplroot)
1101                 deprecate("implicit split to @_");
1102         }
1103         break;
1104     }
1105     if (useless) {
1106         dTHR;
1107         if (ckWARN(WARN_VOID))
1108             Perl_warner(aTHX_ WARN_VOID, "Useless use of %s in void context", useless);
1109     }
1110     return o;
1111 }
1112
1113 OP *
1114 Perl_listkids(pTHX_ OP *o)
1115 {
1116     OP *kid;
1117     if (o && o->op_flags & OPf_KIDS) {
1118         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1119             list(kid);
1120     }
1121     return o;
1122 }
1123
1124 OP *
1125 Perl_list(pTHX_ OP *o)
1126 {
1127     OP *kid;
1128
1129     /* assumes no premature commitment */
1130     if (!o || (o->op_flags & OPf_WANT) || PL_error_count
1131          || o->op_type == OP_RETURN)
1132         return o;
1133
1134     if ((o->op_private & OPpTARGET_MY)
1135         && (PL_opargs[o->op_type] & OA_TARGLEX)) /* OPp share the meaning */
1136         return o;                               /* As if inside SASSIGN */
1137
1138     o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
1139
1140     switch (o->op_type) {
1141     case OP_FLOP:
1142     case OP_REPEAT:
1143         list(cBINOPo->op_first);
1144         break;
1145     case OP_OR:
1146     case OP_AND:
1147     case OP_COND_EXPR:
1148         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1149             list(kid);
1150         break;
1151     default:
1152     case OP_MATCH:
1153     case OP_QR:
1154     case OP_SUBST:
1155     case OP_NULL:
1156         if (!(o->op_flags & OPf_KIDS))
1157             break;
1158         if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1159             list(cBINOPo->op_first);
1160             return gen_constant_list(o);
1161         }
1162     case OP_LIST:
1163         listkids(o);
1164         break;
1165     case OP_LEAVE:
1166     case OP_LEAVETRY:
1167         kid = cLISTOPo->op_first;
1168         list(kid);
1169         while (kid = kid->op_sibling) {
1170             if (kid->op_sibling)
1171                 scalarvoid(kid);
1172             else
1173                 list(kid);
1174         }
1175         WITH_THR(PL_curcop = &PL_compiling);
1176         break;
1177     case OP_SCOPE:
1178     case OP_LINESEQ:
1179         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
1180             if (kid->op_sibling)
1181                 scalarvoid(kid);
1182             else
1183                 list(kid);
1184         }
1185         WITH_THR(PL_curcop = &PL_compiling);
1186         break;
1187     case OP_REQUIRE:
1188         /* all requires must return a boolean value */
1189         o->op_flags &= ~OPf_WANT;
1190         return scalar(o);
1191     }
1192     return o;
1193 }
1194
1195 OP *
1196 Perl_scalarseq(pTHX_ OP *o)
1197 {
1198     OP *kid;
1199
1200     if (o) {
1201         if (o->op_type == OP_LINESEQ ||
1202              o->op_type == OP_SCOPE ||
1203              o->op_type == OP_LEAVE ||
1204              o->op_type == OP_LEAVETRY)
1205         {
1206             dTHR;
1207             for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
1208                 if (kid->op_sibling) {
1209                     scalarvoid(kid);
1210                 }
1211             }
1212             PL_curcop = &PL_compiling;
1213         }
1214         o->op_flags &= ~OPf_PARENS;
1215         if (PL_hints & HINT_BLOCK_SCOPE)
1216             o->op_flags |= OPf_PARENS;
1217     }
1218     else
1219         o = newOP(OP_STUB, 0);
1220     return o;
1221 }
1222
1223 STATIC OP *
1224 S_modkids(pTHX_ OP *o, I32 type)
1225 {
1226     OP *kid;
1227     if (o && o->op_flags & OPf_KIDS) {
1228         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1229             mod(kid, type);
1230     }
1231     return o;
1232 }
1233
1234 OP *
1235 Perl_mod(pTHX_ OP *o, I32 type)
1236 {
1237     dTHR;
1238     OP *kid;
1239     SV *sv;
1240     STRLEN n_a;
1241
1242     if (!o || PL_error_count)
1243         return o;
1244
1245     if ((o->op_private & OPpTARGET_MY)
1246         && (PL_opargs[o->op_type] & OA_TARGLEX)) /* OPp share the meaning */
1247         return o;
1248
1249     switch (o->op_type) {
1250     case OP_UNDEF:
1251         PL_modcount++;
1252         return o;
1253     case OP_CONST:
1254         if (!(o->op_private & (OPpCONST_ARYBASE)))
1255             goto nomod;
1256         if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
1257             PL_compiling.cop_arybase = (I32)SvIV(((SVOP*)PL_eval_start)->op_sv);
1258             PL_eval_start = 0;
1259         }
1260         else if (!type) {
1261             SAVEI32(PL_compiling.cop_arybase);
1262             PL_compiling.cop_arybase = 0;
1263         }
1264         else if (type == OP_REFGEN)
1265             goto nomod;
1266         else
1267             Perl_croak(aTHX_ "That use of $[ is unsupported");
1268         break;
1269     case OP_STUB:
1270         if (o->op_flags & OPf_PARENS)
1271             break;
1272         goto nomod;
1273     case OP_ENTERSUB:
1274         if ((type == OP_UNDEF || type == OP_REFGEN) &&
1275             !(o->op_flags & OPf_STACKED)) {
1276             o->op_type = OP_RV2CV;              /* entersub => rv2cv */
1277             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
1278             assert(cUNOPo->op_first->op_type == OP_NULL);
1279             null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
1280             break;
1281         }
1282         else {                          /* lvalue subroutine call */
1283             o->op_private |= OPpLVAL_INTRO;
1284             if (type == OP_GREPSTART || type == OP_ENTERSUB) {
1285                 /* Backward compatibility mode: */
1286                 o->op_private |= OPpENTERSUB_INARGS;
1287                 break;
1288             }
1289             else {                      /* Compile-time error message: */
1290                 OP *kid = cUNOPo->op_first;
1291                 CV *cv;
1292                 OP *okid;
1293
1294                 if (kid->op_type == OP_PUSHMARK)
1295                     goto skip_kids;
1296                 if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
1297                     Perl_croak(aTHX_
1298                                "panic: unexpected lvalue entersub "
1299                                "args: type/targ %ld:%ld",
1300                                (long)kid->op_type,kid->op_targ);
1301                 kid = kLISTOP->op_first;
1302               skip_kids:
1303                 while (kid->op_sibling)
1304                     kid = kid->op_sibling;
1305                 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
1306                     /* Indirect call */
1307                     if (kid->op_type == OP_METHOD_NAMED
1308                         || kid->op_type == OP_METHOD)
1309                     {
1310                         OP *newop;
1311
1312                         if (kid->op_sibling || kid->op_next != kid) {
1313                             yyerror("panic: unexpected optree near method call");
1314                             break;
1315                         }
1316
1317                         NewOp(1101, newop, 1, OP);
1318                         newop->op_type = OP_RV2CV;
1319                         newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
1320                         newop->op_next = newop;
1321                         kid->op_sibling = newop;
1322                         newop->op_private |= OPpLVAL_INTRO;
1323                         break;
1324                     }
1325
1326                     if (kid->op_type != OP_RV2CV)
1327                         Perl_croak(aTHX_
1328                                    "panic: unexpected lvalue entersub "
1329                                    "entry via type/targ %ld:%ld",
1330                                    (long)kid->op_type,kid->op_targ);
1331                     kid->op_private |= OPpLVAL_INTRO;
1332                     break;      /* Postpone until runtime */
1333                 }
1334
1335                 okid = kid;
1336                 kid = kUNOP->op_first;
1337                 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
1338                     kid = kUNOP->op_first;
1339                 if (kid->op_type == OP_NULL)
1340                     Perl_croak(aTHX_
1341                                "Unexpected constant lvalue entersub "
1342                                "entry via type/targ %ld:%ld",
1343                                (long)kid->op_type,kid->op_targ);
1344                 if (kid->op_type != OP_GV) {
1345                     /* Restore RV2CV to check lvalueness */
1346                   restore_2cv:
1347                     if (kid->op_next && kid->op_next != kid) { /* Happens? */
1348                         okid->op_next = kid->op_next;
1349                         kid->op_next = okid;
1350                     }
1351                     else
1352                         okid->op_next = Nullop;
1353                     okid->op_type = OP_RV2CV;
1354                     okid->op_targ = 0;
1355                     okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
1356                     okid->op_private |= OPpLVAL_INTRO;
1357                     break;
1358                 }
1359
1360                 cv = GvCV((GV*)kSVOP->op_sv);
1361                 if (!cv)
1362                     goto restore_2cv;
1363                 if (CvLVALUE(cv))
1364                     break;
1365             }
1366         }
1367         /* FALL THROUGH */
1368     default:
1369       nomod:
1370         /* grep, foreach, subcalls, refgen */
1371         if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN)
1372             break;
1373         yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
1374                      (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
1375                       ? "do block"
1376                       : (o->op_type == OP_ENTERSUB
1377                         ? "non-lvalue subroutine call"
1378                         : PL_op_desc[o->op_type])),
1379                      type ? PL_op_desc[type] : "local"));
1380         return o;
1381
1382     case OP_PREINC:
1383     case OP_PREDEC:
1384     case OP_POW:
1385     case OP_MULTIPLY:
1386     case OP_DIVIDE:
1387     case OP_MODULO:
1388     case OP_REPEAT:
1389     case OP_ADD:
1390     case OP_SUBTRACT:
1391     case OP_CONCAT:
1392     case OP_LEFT_SHIFT:
1393     case OP_RIGHT_SHIFT:
1394     case OP_BIT_AND:
1395     case OP_BIT_XOR:
1396     case OP_BIT_OR:
1397     case OP_I_MULTIPLY:
1398     case OP_I_DIVIDE:
1399     case OP_I_MODULO:
1400     case OP_I_ADD:
1401     case OP_I_SUBTRACT:
1402         if (!(o->op_flags & OPf_STACKED))
1403             goto nomod;
1404         PL_modcount++;
1405         break;
1406
1407     case OP_COND_EXPR:
1408         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1409             mod(kid, type);
1410         break;
1411
1412     case OP_RV2AV:
1413     case OP_RV2HV:
1414         if (!type && cUNOPo->op_first->op_type != OP_GV)
1415             Perl_croak(aTHX_ "Can't localize through a reference");
1416         if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
1417             PL_modcount = 10000;
1418             return o;           /* Treat \(@foo) like ordinary list. */
1419         }
1420         /* FALL THROUGH */
1421     case OP_RV2GV:
1422         if (scalar_mod_type(o, type))
1423             goto nomod;
1424         ref(cUNOPo->op_first, o->op_type);
1425         /* FALL THROUGH */
1426     case OP_AASSIGN:
1427     case OP_ASLICE:
1428     case OP_HSLICE:
1429     case OP_NEXTSTATE:
1430     case OP_DBSTATE:
1431     case OP_REFGEN:
1432     case OP_CHOMP:
1433         PL_modcount = 10000;
1434         break;
1435     case OP_RV2SV:
1436         if (!type && cUNOPo->op_first->op_type != OP_GV)
1437             Perl_croak(aTHX_ "Can't localize through a reference");
1438         ref(cUNOPo->op_first, o->op_type);
1439         /* FALL THROUGH */
1440     case OP_GV:
1441     case OP_AV2ARYLEN:
1442         PL_hints |= HINT_BLOCK_SCOPE;
1443     case OP_SASSIGN:
1444     case OP_ANDASSIGN:
1445     case OP_ORASSIGN:
1446     case OP_AELEMFAST:
1447         PL_modcount++;
1448         break;
1449
1450     case OP_PADAV:
1451     case OP_PADHV:
1452         PL_modcount = 10000;
1453         if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
1454             return o;           /* Treat \(@foo) like ordinary list. */
1455         if (scalar_mod_type(o, type))
1456             goto nomod;
1457         /* FALL THROUGH */
1458     case OP_PADSV:
1459         PL_modcount++;
1460         if (!type)
1461             Perl_croak(aTHX_ "Can't localize lexical variable %s",
1462                 SvPV(*av_fetch(PL_comppad_name, o->op_targ, 4), n_a));
1463         break;
1464
1465 #ifdef USE_THREADS
1466     case OP_THREADSV:
1467         PL_modcount++;  /* XXX ??? */
1468         break;
1469 #endif /* USE_THREADS */
1470
1471     case OP_PUSHMARK:
1472         break;
1473
1474     case OP_KEYS:
1475         if (type != OP_SASSIGN)
1476             goto nomod;
1477         goto lvalue_func;
1478     case OP_SUBSTR:
1479         if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
1480             goto nomod;
1481         /* FALL THROUGH */
1482     case OP_POS:
1483     case OP_VEC:
1484       lvalue_func:
1485         pad_free(o->op_targ);
1486         o->op_targ = pad_alloc(o->op_type, SVs_PADMY);
1487         assert(SvTYPE(PAD_SV(o->op_targ)) == SVt_NULL);
1488         if (o->op_flags & OPf_KIDS)
1489             mod(cBINOPo->op_first->op_sibling, type);
1490         break;
1491
1492     case OP_AELEM:
1493     case OP_HELEM:
1494         ref(cBINOPo->op_first, o->op_type);
1495         if (type == OP_ENTERSUB &&
1496              !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1497             o->op_private |= OPpLVAL_DEFER;
1498         PL_modcount++;
1499         break;
1500
1501     case OP_SCOPE:
1502     case OP_LEAVE:
1503     case OP_ENTER:
1504         if (o->op_flags & OPf_KIDS)
1505             mod(cLISTOPo->op_last, type);
1506         break;
1507
1508     case OP_NULL:
1509         if (o->op_flags & OPf_SPECIAL)          /* do BLOCK */
1510             goto nomod;
1511         else if (!(o->op_flags & OPf_KIDS))
1512             break;
1513         if (o->op_targ != OP_LIST) {
1514             mod(cBINOPo->op_first, type);
1515             break;
1516         }
1517         /* FALL THROUGH */
1518     case OP_LIST:
1519         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1520             mod(kid, type);
1521         break;
1522     }
1523     o->op_flags |= OPf_MOD;
1524
1525     if (type == OP_AASSIGN || type == OP_SASSIGN)
1526         o->op_flags |= OPf_SPECIAL|OPf_REF;
1527     else if (!type) {
1528         o->op_private |= OPpLVAL_INTRO;
1529         o->op_flags &= ~OPf_SPECIAL;
1530         PL_hints |= HINT_BLOCK_SCOPE;
1531     }
1532     else if (type != OP_GREPSTART && type != OP_ENTERSUB)
1533         o->op_flags |= OPf_REF;
1534     return o;
1535 }
1536
1537 STATIC bool
1538 S_scalar_mod_type(pTHX_ OP *o, I32 type)
1539 {
1540     switch (type) {
1541     case OP_SASSIGN:
1542         if (o->op_type == OP_RV2GV)
1543             return FALSE;
1544         /* FALL THROUGH */
1545     case OP_PREINC:
1546     case OP_PREDEC:
1547     case OP_POSTINC:
1548     case OP_POSTDEC:
1549     case OP_I_PREINC:
1550     case OP_I_PREDEC:
1551     case OP_I_POSTINC:
1552     case OP_I_POSTDEC:
1553     case OP_POW:
1554     case OP_MULTIPLY:
1555     case OP_DIVIDE:
1556     case OP_MODULO:
1557     case OP_REPEAT:
1558     case OP_ADD:
1559     case OP_SUBTRACT:
1560     case OP_I_MULTIPLY:
1561     case OP_I_DIVIDE:
1562     case OP_I_MODULO:
1563     case OP_I_ADD:
1564     case OP_I_SUBTRACT:
1565     case OP_LEFT_SHIFT:
1566     case OP_RIGHT_SHIFT:
1567     case OP_BIT_AND:
1568     case OP_BIT_XOR:
1569     case OP_BIT_OR:
1570     case OP_CONCAT:
1571     case OP_SUBST:
1572     case OP_TRANS:
1573     case OP_READ:
1574     case OP_SYSREAD:
1575     case OP_RECV:
1576     case OP_ANDASSIGN:
1577     case OP_ORASSIGN:
1578         return TRUE;
1579     default:
1580         return FALSE;
1581     }
1582 }
1583
1584 STATIC bool
1585 S_is_handle_constructor(pTHX_ OP *o, I32 argnum)
1586 {
1587     switch (o->op_type) {
1588     case OP_PIPE_OP:
1589     case OP_SOCKPAIR:
1590         if (argnum == 2)
1591             return TRUE;
1592         /* FALL THROUGH */
1593     case OP_SYSOPEN:
1594     case OP_OPEN:
1595     case OP_SELECT:             /* XXX c.f. SelectSaver.pm */
1596     case OP_SOCKET:
1597     case OP_OPEN_DIR:
1598     case OP_ACCEPT:
1599         if (argnum == 1)
1600             return TRUE;
1601         /* FALL THROUGH */
1602     default:
1603         return FALSE;
1604     }
1605 }
1606
1607 OP *
1608 Perl_refkids(pTHX_ OP *o, I32 type)
1609 {
1610     OP *kid;
1611     if (o && o->op_flags & OPf_KIDS) {
1612         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1613             ref(kid, type);
1614     }
1615     return o;
1616 }
1617
1618 OP *
1619 Perl_ref(pTHX_ OP *o, I32 type)
1620 {
1621     OP *kid;
1622
1623     if (!o || PL_error_count)
1624         return o;
1625
1626     switch (o->op_type) {
1627     case OP_ENTERSUB:
1628         if ((type == OP_DEFINED || type == OP_LOCK) &&
1629             !(o->op_flags & OPf_STACKED)) {
1630             o->op_type = OP_RV2CV;             /* entersub => rv2cv */
1631             o->op_ppaddr = PL_ppaddr[OP_RV2CV];
1632             assert(cUNOPo->op_first->op_type == OP_NULL);
1633             null(((LISTOP*)cUNOPo->op_first)->op_first);        /* disable pushmark */
1634             o->op_flags |= OPf_SPECIAL;
1635         }
1636         break;
1637
1638     case OP_COND_EXPR:
1639         for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
1640             ref(kid, type);
1641         break;
1642     case OP_RV2SV:
1643         if (type == OP_DEFINED)
1644             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
1645         ref(cUNOPo->op_first, o->op_type);
1646         /* FALL THROUGH */
1647     case OP_PADSV:
1648         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
1649             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1650                               : type == OP_RV2HV ? OPpDEREF_HV
1651                               : OPpDEREF_SV);
1652             o->op_flags |= OPf_MOD;
1653         }
1654         break;
1655
1656     case OP_THREADSV:
1657         o->op_flags |= OPf_MOD;         /* XXX ??? */
1658         break;
1659
1660     case OP_RV2AV:
1661     case OP_RV2HV:
1662         o->op_flags |= OPf_REF;
1663         /* FALL THROUGH */
1664     case OP_RV2GV:
1665         if (type == OP_DEFINED)
1666             o->op_flags |= OPf_SPECIAL;         /* don't create GV */
1667         ref(cUNOPo->op_first, o->op_type);
1668         break;
1669
1670     case OP_PADAV:
1671     case OP_PADHV:
1672         o->op_flags |= OPf_REF;
1673         break;
1674
1675     case OP_SCALAR:
1676     case OP_NULL:
1677         if (!(o->op_flags & OPf_KIDS))
1678             break;
1679         ref(cBINOPo->op_first, type);
1680         break;
1681     case OP_AELEM:
1682     case OP_HELEM:
1683         ref(cBINOPo->op_first, o->op_type);
1684         if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
1685             o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1686                               : type == OP_RV2HV ? OPpDEREF_HV
1687                               : OPpDEREF_SV);
1688             o->op_flags |= OPf_MOD;
1689         }
1690         break;
1691
1692     case OP_SCOPE:
1693     case OP_LEAVE:
1694     case OP_ENTER:
1695     case OP_LIST:
1696         if (!(o->op_flags & OPf_KIDS))
1697             break;
1698         ref(cLISTOPo->op_last, type);
1699         break;
1700     default:
1701         break;
1702     }
1703     return scalar(o);
1704
1705 }
1706
1707 STATIC OP *
1708 S_dup_attrlist(pTHX_ OP *o)
1709 {
1710     OP *rop = Nullop;
1711
1712     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
1713      * where the first kid is OP_PUSHMARK and the remaining ones
1714      * are OP_CONST.  We need to push the OP_CONST values.
1715      */
1716     if (o->op_type == OP_CONST)
1717         rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc(cSVOPo->op_sv));
1718     else {
1719         assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
1720         for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
1721             if (o->op_type == OP_CONST)
1722                 rop = append_elem(OP_LIST, rop,
1723                                   newSVOP(OP_CONST, o->op_flags,
1724                                           SvREFCNT_inc(cSVOPo->op_sv)));
1725         }
1726     }
1727     return rop;
1728 }
1729
1730 STATIC void
1731 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
1732 {
1733     OP *modname;        /* for 'use' */
1734     SV *stashsv;
1735
1736     /* fake up C<use attributes $pkg,$rv,@attrs> */
1737     ENTER;              /* need to protect against side-effects of 'use' */
1738     SAVEINT(PL_expect);
1739     if (stash && HvNAME(stash))
1740         stashsv = newSVpv(HvNAME(stash), 0);
1741     else
1742         stashsv = &PL_sv_no;
1743 #define ATTRSMODULE "attributes"
1744     modname = newSVOP(OP_CONST, 0,
1745                       newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1));
1746     modname->op_private |= OPpCONST_BARE;
1747     /* that flag is required to make 'use' work right */
1748     utilize(1, start_subparse(FALSE, 0),
1749             Nullop, /* version */
1750             modname,
1751             prepend_elem(OP_LIST,
1752                          newSVOP(OP_CONST, 0, stashsv),
1753                          prepend_elem(OP_LIST,
1754                                       newSVOP(OP_CONST, 0, newRV(target)),
1755                                       dup_attrlist(attrs))));
1756     LEAVE;
1757 }
1758
1759 STATIC OP *
1760 S_my_kid(pTHX_ OP *o, OP *attrs)
1761 {
1762     OP *kid;
1763     I32 type;
1764
1765     if (!o || PL_error_count)
1766         return o;
1767
1768     type = o->op_type;
1769     if (type == OP_LIST) {
1770         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
1771             my_kid(kid, attrs);
1772     } else if (type == OP_UNDEF) {
1773         return o;
1774     } else if (type == OP_RV2SV ||      /* "our" declaration */
1775                type == OP_RV2AV ||
1776                type == OP_RV2HV) { /* XXX does this let anything illegal in? */
1777         return o;
1778     } else if (type != OP_PADSV &&
1779              type != OP_PADAV &&
1780              type != OP_PADHV &&
1781              type != OP_PUSHMARK)
1782     {
1783         yyerror(Perl_form(aTHX_ "Can't declare %s in my", PL_op_desc[o->op_type]));
1784         return o;
1785     }
1786     else if (attrs && type != OP_PUSHMARK) {
1787         HV *stash;
1788         SV *padsv;
1789         SV **namesvp;
1790
1791         /* check for C<my Dog $spot> when deciding package */
1792         namesvp = av_fetch(PL_comppad_name, o->op_targ, FALSE);
1793         if (namesvp && *namesvp && SvOBJECT(*namesvp) && HvNAME(SvSTASH(*namesvp)))
1794             stash = SvSTASH(*namesvp);
1795         else
1796             stash = PL_curstash;
1797         padsv = PAD_SV(o->op_targ);
1798         apply_attrs(stash, padsv, attrs);
1799     }
1800     o->op_flags |= OPf_MOD;
1801     o->op_private |= OPpLVAL_INTRO;
1802     return o;
1803 }
1804
1805 OP *
1806 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
1807 {
1808     if (o->op_flags & OPf_PARENS)
1809         list(o);
1810     PL_in_my = FALSE;
1811     PL_in_my_stash = Nullhv;
1812     if (attrs)
1813         SAVEFREEOP(attrs);
1814     return my_kid(o, attrs);
1815 }
1816
1817 OP *
1818 Perl_my(pTHX_ OP *o)
1819 {
1820     return my_kid(o, Nullop);
1821 }
1822
1823 OP *
1824 Perl_sawparens(pTHX_ OP *o)
1825 {
1826     if (o)
1827         o->op_flags |= OPf_PARENS;
1828     return o;
1829 }
1830
1831 OP *
1832 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
1833 {
1834     dTHR;
1835     OP *o;
1836
1837     if (ckWARN(WARN_UNSAFE) &&
1838       (left->op_type == OP_RV2AV ||
1839        left->op_type == OP_RV2HV ||
1840        left->op_type == OP_PADAV ||
1841        left->op_type == OP_PADHV)) {
1842       char *desc = PL_op_desc[(right->op_type == OP_SUBST ||
1843                             right->op_type == OP_TRANS)
1844                            ? right->op_type : OP_MATCH];
1845       const char *sample = ((left->op_type == OP_RV2AV ||
1846                              left->op_type == OP_PADAV)
1847                             ? "@array" : "%hash");
1848       Perl_warner(aTHX_ WARN_UNSAFE,
1849              "Applying %s to %s will act on scalar(%s)",
1850              desc, sample, sample);
1851     }
1852
1853     if (right->op_type == OP_MATCH ||
1854         right->op_type == OP_SUBST ||
1855         right->op_type == OP_TRANS) {
1856         right->op_flags |= OPf_STACKED;
1857         if (right->op_type != OP_MATCH)
1858             left = mod(left, right->op_type);
1859         if (right->op_type == OP_TRANS)
1860             o = newBINOP(OP_NULL, OPf_STACKED, scalar(left), right);
1861         else
1862             o = prepend_elem(right->op_type, scalar(left), right);
1863         if (type == OP_NOT)
1864             return newUNOP(OP_NOT, 0, scalar(o));
1865         return o;
1866     }
1867     else
1868         return bind_match(type, left,
1869                 pmruntime(newPMOP(OP_MATCH, 0), right, Nullop));
1870 }
1871
1872 OP *
1873 Perl_invert(pTHX_ OP *o)
1874 {
1875     if (!o)
1876         return o;
1877     /* XXX need to optimize away NOT NOT here?  Or do we let optimizer do it? */
1878     return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
1879 }
1880
1881 OP *
1882 Perl_scope(pTHX_ OP *o)
1883 {
1884     if (o) {
1885         if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
1886             o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
1887             o->op_type = OP_LEAVE;
1888             o->op_ppaddr = PL_ppaddr[OP_LEAVE];
1889         }
1890         else {
1891             if (o->op_type == OP_LINESEQ) {
1892                 OP *kid;
1893                 o->op_type = OP_SCOPE;
1894                 o->op_ppaddr = PL_ppaddr[OP_SCOPE];
1895                 kid = ((LISTOP*)o)->op_first;
1896                 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE)
1897                     null(kid);
1898             }
1899             else
1900                 o = newLISTOP(OP_SCOPE, 0, o, Nullop);
1901         }
1902     }
1903     return o;
1904 }
1905
1906 void
1907 Perl_save_hints(pTHX)
1908 {
1909     SAVEI32(PL_hints);
1910     SAVESPTR(GvHV(PL_hintgv));
1911     GvHV(PL_hintgv) = newHVhv(GvHV(PL_hintgv));
1912     SAVEFREESV(GvHV(PL_hintgv));
1913 }
1914
1915 int
1916 Perl_block_start(pTHX_ int full)
1917 {
1918     dTHR;
1919     int retval = PL_savestack_ix;
1920
1921     SAVEI32(PL_comppad_name_floor);
1922     if (full) {
1923         if ((PL_comppad_name_fill = AvFILLp(PL_comppad_name)) > 0)
1924             PL_comppad_name_floor = PL_comppad_name_fill;
1925         else
1926             PL_comppad_name_floor = 0;
1927     }
1928     SAVEI32(PL_min_intro_pending);
1929     SAVEI32(PL_max_intro_pending);
1930     PL_min_intro_pending = 0;
1931     SAVEI32(PL_comppad_name_fill);
1932     SAVEI32(PL_padix_floor);
1933     PL_padix_floor = PL_padix;
1934     PL_pad_reset_pending = FALSE;
1935     SAVEHINTS();
1936     PL_hints &= ~HINT_BLOCK_SCOPE;
1937     SAVEPPTR(PL_compiling.cop_warnings);
1938     if (! specialWARN(PL_compiling.cop_warnings)) {
1939         PL_compiling.cop_warnings = newSVsv(PL_compiling.cop_warnings) ;
1940         SAVEFREESV(PL_compiling.cop_warnings) ;
1941     }
1942
1943
1944     return retval;
1945 }
1946
1947 OP*
1948 Perl_block_end(pTHX_ I32 floor, OP *seq)
1949 {
1950     dTHR;
1951     int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
1952     OP* retval = scalarseq(seq);
1953     LEAVE_SCOPE(floor);
1954     PL_pad_reset_pending = FALSE;
1955     PL_compiling.op_private = PL_hints;
1956     if (needblockscope)
1957         PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
1958     pad_leavemy(PL_comppad_name_fill);
1959     PL_cop_seqmax++;
1960     return retval;
1961 }
1962
1963 STATIC OP *
1964 S_newDEFSVOP(pTHX)
1965 {
1966 #ifdef USE_THREADS
1967     OP *o = newOP(OP_THREADSV, 0);
1968     o->op_targ = find_threadsv("_");
1969     return o;
1970 #else
1971     return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
1972 #endif /* USE_THREADS */
1973 }
1974
1975 void
1976 Perl_newPROG(pTHX_ OP *o)
1977 {
1978     dTHR;
1979     if (PL_in_eval) {
1980         if (PL_eval_root)
1981                 return;
1982         PL_eval_root = newUNOP(OP_LEAVEEVAL,
1983                                ((PL_in_eval & EVAL_KEEPERR)
1984                                 ? OPf_SPECIAL : 0), o);
1985         PL_eval_start = linklist(PL_eval_root);
1986         PL_eval_root->op_private |= OPpREFCOUNTED;
1987         OpREFCNT_set(PL_eval_root, 1);
1988         PL_eval_root->op_next = 0;
1989         peep(PL_eval_start);
1990     }
1991     else {
1992         if (!o)
1993             return;
1994         PL_main_root = scope(sawparens(scalarvoid(o)));
1995         PL_curcop = &PL_compiling;
1996         PL_main_start = LINKLIST(PL_main_root);
1997         PL_main_root->op_private |= OPpREFCOUNTED;
1998         OpREFCNT_set(PL_main_root, 1);
1999         PL_main_root->op_next = 0;
2000         peep(PL_main_start);
2001         PL_compcv = 0;
2002
2003         /* Register with debugger */
2004         if (PERLDB_INTER) {
2005             CV *cv = get_cv("DB::postponed", FALSE);
2006             if (cv) {
2007                 dSP;
2008                 PUSHMARK(SP);
2009                 XPUSHs((SV*)PL_compiling.cop_filegv);
2010                 PUTBACK;
2011                 call_sv((SV*)cv, G_DISCARD);
2012             }
2013         }
2014     }
2015 }
2016
2017 OP *
2018 Perl_localize(pTHX_ OP *o, I32 lex)
2019 {
2020     if (o->op_flags & OPf_PARENS)
2021         list(o);
2022     else {
2023         dTHR;
2024         if (ckWARN(WARN_PARENTHESIS) && PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ',') {
2025             char *s;
2026             for (s = PL_bufptr; *s && (isALNUM(*s) || (*s & 0x80) || strchr("@$%, ",*s)); s++) ;
2027             if (*s == ';' || *s == '=')
2028                 Perl_warner(aTHX_ WARN_PARENTHESIS, "Parentheses missing around \"%s\" list",
2029                                 lex ? "my" : "local");
2030         }
2031     }
2032     PL_in_my = FALSE;
2033     PL_in_my_stash = Nullhv;
2034     if (lex)
2035         return my(o);
2036     else
2037         return mod(o, OP_NULL);         /* a bit kludgey */
2038 }
2039
2040 OP *
2041 Perl_jmaybe(pTHX_ OP *o)
2042 {
2043     if (o->op_type == OP_LIST) {
2044         OP *o2;
2045 #ifdef USE_THREADS
2046         o2 = newOP(OP_THREADSV, 0);
2047         o2->op_targ = find_threadsv(";");
2048 #else
2049         o2 = newSVREF(newGVOP(OP_GV, 0, gv_fetchpv(";", TRUE, SVt_PV))),
2050 #endif /* USE_THREADS */
2051         o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
2052     }
2053     return o;
2054 }
2055
2056 OP *
2057 Perl_fold_constants(pTHX_ register OP *o)
2058 {
2059     dTHR;
2060     register OP *curop;
2061     I32 type = o->op_type;
2062     SV *sv;
2063
2064     if (PL_opargs[type] & OA_RETSCALAR)
2065         scalar(o);
2066     if (PL_opargs[type] & OA_TARGET && !o->op_targ)
2067         o->op_targ = pad_alloc(type, SVs_PADTMP);
2068
2069     /* integerize op, unless it happens to be C<-foo>.
2070      * XXX should pp_i_negate() do magic string negation instead? */
2071     if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)
2072         && !(type == OP_NEGATE && cUNOPo->op_first->op_type == OP_CONST
2073              && (cUNOPo->op_first->op_private & OPpCONST_BARE)))
2074     {
2075         o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
2076     }
2077
2078     if (!(PL_opargs[type] & OA_FOLDCONST))
2079         goto nope;
2080
2081     switch (type) {
2082     case OP_NEGATE:
2083         /* XXX might want a ck_negate() for this */
2084         cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
2085         break;
2086     case OP_SPRINTF:
2087     case OP_UCFIRST:
2088     case OP_LCFIRST:
2089     case OP_UC:
2090     case OP_LC:
2091     case OP_SLT:
2092     case OP_SGT:
2093     case OP_SLE:
2094     case OP_SGE:
2095     case OP_SCMP:
2096
2097         if (o->op_private & OPpLOCALE)
2098             goto nope;
2099     }
2100
2101     if (PL_error_count)
2102         goto nope;              /* Don't try to run w/ errors */
2103
2104     for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
2105         if ((curop->op_type != OP_CONST ||
2106              (curop->op_private & OPpCONST_BARE)) &&
2107             curop->op_type != OP_LIST &&
2108             curop->op_type != OP_SCALAR &&
2109             curop->op_type != OP_NULL &&
2110             curop->op_type != OP_PUSHMARK)
2111         {
2112             goto nope;
2113         }
2114     }
2115
2116     curop = LINKLIST(o);
2117     o->op_next = 0;
2118     PL_op = curop;
2119     CALLRUNOPS(aTHX);
2120     sv = *(PL_stack_sp--);
2121     if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */
2122         pad_swipe(o->op_targ);
2123     else if (SvTEMP(sv)) {                      /* grab mortal temp? */
2124         (void)SvREFCNT_inc(sv);
2125         SvTEMP_off(sv);
2126     }
2127     op_free(o);
2128     if (type == OP_RV2GV)
2129         return newGVOP(OP_GV, 0, (GV*)sv);
2130     else {
2131         /* try to smush double to int, but don't smush -2.0 to -2 */
2132         if ((SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK)) == SVf_NOK &&
2133             type != OP_NEGATE)
2134         {
2135             IV iv = SvIV(sv);
2136             if ((NV)iv == SvNV(sv)) {
2137                 SvREFCNT_dec(sv);
2138                 sv = newSViv(iv);
2139             }
2140             else
2141                 SvIOK_off(sv);                  /* undo SvIV() damage */
2142         }
2143         return newSVOP(OP_CONST, 0, sv);
2144     }
2145
2146   nope:
2147     if (!(PL_opargs[type] & OA_OTHERINT))
2148         return o;
2149
2150     if (!(PL_hints & HINT_INTEGER)) {
2151         if (type == OP_MODULO
2152             || type == OP_DIVIDE
2153             || !(o->op_flags & OPf_KIDS))
2154         {
2155             return o;
2156         }
2157
2158         for (curop = ((UNOP*)o)->op_first; curop; curop = curop->op_sibling) {
2159             if (curop->op_type == OP_CONST) {
2160                 if (SvIOK(((SVOP*)curop)->op_sv))
2161                     continue;
2162                 return o;
2163             }
2164             if (PL_opargs[curop->op_type] & OA_RETINTEGER)
2165                 continue;
2166             return o;
2167         }
2168         o->op_ppaddr = PL_ppaddr[++(o->op_type)];
2169     }
2170
2171     return o;
2172 }
2173
2174 OP *
2175 Perl_gen_constant_list(pTHX_ register OP *o)
2176 {
2177     dTHR;
2178     register OP *curop;
2179     I32 oldtmps_floor = PL_tmps_floor;
2180
2181     list(o);
2182     if (PL_error_count)
2183         return o;               /* Don't attempt to run with errors */
2184
2185     PL_op = curop = LINKLIST(o);
2186     o->op_next = 0;
2187     pp_pushmark();
2188     CALLRUNOPS(aTHX);
2189     PL_op = curop;
2190     pp_anonlist();
2191     PL_tmps_floor = oldtmps_floor;
2192
2193     o->op_type = OP_RV2AV;
2194     o->op_ppaddr = PL_ppaddr[OP_RV2AV];
2195     curop = ((UNOP*)o)->op_first;
2196     ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*PL_stack_sp--));
2197     op_free(curop);
2198     linklist(o);
2199     return list(o);
2200 }
2201
2202 OP *
2203 Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
2204 {
2205     OP *kid;
2206     OP *last = 0;
2207
2208     if (!o || o->op_type != OP_LIST)
2209         o = newLISTOP(OP_LIST, 0, o, Nullop);
2210     else
2211         o->op_flags &= ~OPf_WANT;
2212
2213     if (!(PL_opargs[type] & OA_MARK))
2214         null(cLISTOPo->op_first);
2215
2216     o->op_type = type;
2217     o->op_ppaddr = PL_ppaddr[type];
2218     o->op_flags |= flags;
2219
2220     o = CHECKOP(type, o);
2221     if (o->op_type != type)
2222         return o;
2223
2224     if (cLISTOPo->op_children < 7) {
2225         /* XXX do we really need to do this if we're done appending?? */
2226         for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
2227             last = kid;
2228         cLISTOPo->op_last = last;       /* in case check substituted last arg */
2229     }
2230
2231     return fold_constants(o);
2232 }
2233
2234 /* List constructors */
2235
2236 OP *
2237 Perl_append_elem(pTHX_ I32 type, OP *first, OP *last)
2238 {
2239     if (!first)
2240         return last;
2241
2242     if (!last)
2243         return first;
2244
2245     if (first->op_type != type || type==OP_LIST && first->op_flags & OPf_PARENS)
2246             return newLISTOP(type, 0, first, last);
2247
2248     if (first->op_flags & OPf_KIDS)
2249         ((LISTOP*)first)->op_last->op_sibling = last;
2250     else {
2251         first->op_flags |= OPf_KIDS;
2252         ((LISTOP*)first)->op_first = last;
2253     }
2254     ((LISTOP*)first)->op_last = last;
2255     ((LISTOP*)first)->op_children++;
2256     return first;
2257 }
2258
2259 OP *
2260 Perl_append_list(pTHX_ I32 type, LISTOP *first, LISTOP *last)
2261 {
2262     if (!first)
2263         return (OP*)last;
2264
2265     if (!last)
2266         return (OP*)first;
2267
2268     if (first->op_type != type)
2269         return prepend_elem(type, (OP*)first, (OP*)last);
2270
2271     if (last->op_type != type)
2272         return append_elem(type, (OP*)first, (OP*)last);
2273
2274     first->op_last->op_sibling = last->op_first;
2275     first->op_last = last->op_last;
2276     first->op_children += last->op_children;
2277     if (first->op_children)
2278         first->op_flags |= OPf_KIDS;
2279
2280 #ifdef PL_OP_SLAB_ALLOC
2281 #else
2282     Safefree(last);
2283 #endif
2284     return (OP*)first;
2285 }
2286
2287 OP *
2288 Perl_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
2289 {
2290     if (!first)
2291         return last;
2292
2293     if (!last)
2294         return first;
2295
2296     if (last->op_type == type) {
2297         if (type == OP_LIST) {  /* already a PUSHMARK there */
2298             first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
2299             ((LISTOP*)last)->op_first->op_sibling = first;
2300         }
2301         else {
2302             if (!(last->op_flags & OPf_KIDS)) {
2303                 ((LISTOP*)last)->op_last = first;
2304                 last->op_flags |= OPf_KIDS;
2305             }
2306             first->op_sibling = ((LISTOP*)last)->op_first;
2307             ((LISTOP*)last)->op_first = first;
2308         }
2309         ((LISTOP*)last)->op_children++;
2310         return last;
2311     }
2312
2313     return newLISTOP(type, 0, first, last);
2314 }
2315
2316 /* Constructors */
2317
2318 OP *
2319 Perl_newNULLLIST(pTHX)
2320 {
2321     return newOP(OP_STUB, 0);
2322 }
2323
2324 OP *
2325 Perl_force_list(pTHX_ OP *o)
2326 {
2327     if (!o || o->op_type != OP_LIST)
2328         o = newLISTOP(OP_LIST, 0, o, Nullop);
2329     null(o);
2330     return o;
2331 }
2332
2333 OP *
2334 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
2335 {
2336     LISTOP *listop;
2337
2338     NewOp(1101, listop, 1, LISTOP);
2339
2340     listop->op_type = type;
2341     listop->op_ppaddr = PL_ppaddr[type];
2342     listop->op_children = (first != 0) + (last != 0);
2343     listop->op_flags = flags;
2344
2345     if (!last && first)
2346         last = first;
2347     else if (!first && last)
2348         first = last;
2349     else if (first)
2350         first->op_sibling = last;
2351     listop->op_first = first;
2352     listop->op_last = last;
2353     if (type == OP_LIST) {
2354         OP* pushop;
2355         pushop = newOP(OP_PUSHMARK, 0);
2356         pushop->op_sibling = first;
2357         listop->op_first = pushop;
2358         listop->op_flags |= OPf_KIDS;
2359         if (!last)
2360             listop->op_last = pushop;
2361     }
2362     else if (listop->op_children)
2363         listop->op_flags |= OPf_KIDS;
2364
2365     return (OP*)listop;
2366 }
2367
2368 OP *
2369 Perl_newOP(pTHX_ I32 type, I32 flags)
2370 {
2371     OP *o;
2372     NewOp(1101, o, 1, OP);
2373     o->op_type = type;
2374     o->op_ppaddr = PL_ppaddr[type];
2375     o->op_flags = flags;
2376
2377     o->op_next = o;
2378     o->op_private = 0 + (flags >> 8);
2379     if (PL_opargs[type] & OA_RETSCALAR)
2380         scalar(o);
2381     if (PL_opargs[type] & OA_TARGET)
2382         o->op_targ = pad_alloc(type, SVs_PADTMP);
2383     return CHECKOP(type, o);
2384 }
2385
2386 OP *
2387 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
2388 {
2389     UNOP *unop;
2390
2391     if (!first)
2392         first = newOP(OP_STUB, 0);
2393     if (PL_opargs[type] & OA_MARK)
2394         first = force_list(first);
2395
2396     NewOp(1101, unop, 1, UNOP);
2397     unop->op_type = type;
2398     unop->op_ppaddr = PL_ppaddr[type];
2399     unop->op_first = first;
2400     unop->op_flags = flags | OPf_KIDS;
2401     unop->op_private = 1 | (flags >> 8);
2402     unop = (UNOP*) CHECKOP(type, unop);
2403     if (unop->op_next)
2404         return (OP*)unop;
2405
2406     return fold_constants((OP *) unop);
2407 }
2408
2409 OP *
2410 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
2411 {
2412     BINOP *binop;
2413     NewOp(1101, binop, 1, BINOP);
2414
2415     if (!first)
2416         first = newOP(OP_NULL, 0);
2417
2418     binop->op_type = type;
2419     binop->op_ppaddr = PL_ppaddr[type];
2420     binop->op_first = first;
2421     binop->op_flags = flags | OPf_KIDS;
2422     if (!last) {
2423         last = first;
2424         binop->op_private = 1 | (flags >> 8);
2425     }
2426     else {
2427         binop->op_private = 2 | (flags >> 8);
2428         first->op_sibling = last;
2429     }
2430
2431     binop = (BINOP*)CHECKOP(type, binop);
2432     if (binop->op_next || binop->op_type != type)
2433         return (OP*)binop;
2434
2435     binop->op_last = binop->op_first->op_sibling;
2436
2437     return fold_constants((OP *)binop);
2438 }
2439
2440 static int
2441 utf8compare(const void *a, const void *b)
2442 {
2443     int i;
2444     for (i = 0; i < 10; i++) {
2445         if ((*(U8**)a)[i] < (*(U8**)b)[i])
2446             return -1;
2447         if ((*(U8**)a)[i] > (*(U8**)b)[i])
2448             return 1;
2449     }
2450     return 0;
2451 }
2452
2453 OP *
2454 Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
2455 {
2456     SV *tstr = ((SVOP*)expr)->op_sv;
2457     SV *rstr = ((SVOP*)repl)->op_sv;
2458     STRLEN tlen;
2459     STRLEN rlen;
2460     register U8 *t = (U8*)SvPV(tstr, tlen);
2461     register U8 *r = (U8*)SvPV(rstr, rlen);
2462     register I32 i;
2463     register I32 j;
2464     I32 del;
2465     I32 complement;
2466     I32 squash;
2467     register short *tbl;
2468
2469     complement  = o->op_private & OPpTRANS_COMPLEMENT;
2470     del         = o->op_private & OPpTRANS_DELETE;
2471     squash      = o->op_private & OPpTRANS_SQUASH;
2472
2473     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
2474         SV* listsv = newSVpvn("# comment\n",10);
2475         SV* transv = 0;
2476         U8* tend = t + tlen;
2477         U8* rend = r + rlen;
2478         I32 ulen;
2479         U32 tfirst = 1;
2480         U32 tlast = 0;
2481         I32 tdiff;
2482         U32 rfirst = 1;
2483         U32 rlast = 0;
2484         I32 rdiff;
2485         I32 diff;
2486         I32 none = 0;
2487         U32 max = 0;
2488         I32 bits;
2489         I32 grows = 0;
2490         I32 havefinal = 0;
2491         U32 final;
2492         HV *hv;
2493         I32 from_utf    = o->op_private & OPpTRANS_FROM_UTF;
2494         I32 to_utf      = o->op_private & OPpTRANS_TO_UTF;
2495
2496         if (complement) {
2497             U8 tmpbuf[10];
2498             U8** cp;
2499             UV nextmin = 0;
2500             New(1109, cp, tlen, U8*);
2501             i = 0;
2502             transv = newSVpvn("",0);
2503             while (t < tend) {
2504                 cp[i++] = t;
2505                 t += UTF8SKIP(t);
2506                 if (*t == 0xff) {
2507                     t++;
2508                     t += UTF8SKIP(t);
2509                 }
2510             }
2511             qsort(cp, i, sizeof(U8*), utf8compare);
2512             for (j = 0; j < i; j++) {
2513                 U8 *s = cp[j];
2514                 UV val = utf8_to_uv(s, &ulen);
2515                 s += ulen;
2516                 diff = val - nextmin;
2517                 if (diff > 0) {
2518                     t = uv_to_utf8(tmpbuf,nextmin);
2519                     sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2520                     if (diff > 1) {
2521                         t = uv_to_utf8(tmpbuf, val - 1);
2522                         sv_catpvn(transv, "\377", 1);
2523                         sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2524                     }
2525                 }
2526                 if (*s == 0xff)
2527                     val = utf8_to_uv(s+1, &ulen);
2528                 if (val >= nextmin)
2529                     nextmin = val + 1;
2530             }
2531             t = uv_to_utf8(tmpbuf,nextmin);
2532             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2533             t = uv_to_utf8(tmpbuf, 0x7fffffff);
2534             sv_catpvn(transv, "\377", 1);
2535             sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2536             t = (U8*)SvPVX(transv);
2537             tlen = SvCUR(transv);
2538             tend = t + tlen;
2539         }
2540         else if (!rlen && !del) {
2541             r = t; rlen = tlen; rend = tend;
2542         }
2543         if (!squash) {
2544             if (to_utf && from_utf) {   /* only counting characters */
2545                 if (t == r || (tlen == rlen && memEQ(t, r, tlen)))
2546                     o->op_private |= OPpTRANS_IDENTICAL;
2547             }
2548             else {      /* straight latin-1 translation */
2549                 if (tlen == 4 && memEQ(t, "\0\377\303\277", 4) &&
2550                     rlen == 4 && memEQ(r, "\0\377\303\277", 4))
2551                     o->op_private |= OPpTRANS_IDENTICAL;
2552             }
2553         }
2554
2555         while (t < tend || tfirst <= tlast) {
2556             /* see if we need more "t" chars */
2557             if (tfirst > tlast) {
2558                 tfirst = (I32)utf8_to_uv(t, &ulen);
2559                 t += ulen;
2560                 if (t < tend && *t == 0xff) {   /* illegal utf8 val indicates range */
2561                     tlast = (I32)utf8_to_uv(++t, &ulen);
2562                     t += ulen;
2563                 }
2564                 else
2565                     tlast = tfirst;
2566             }
2567
2568             /* now see if we need more "r" chars */
2569             if (rfirst > rlast) {
2570                 if (r < rend) {
2571                     rfirst = (I32)utf8_to_uv(r, &ulen);
2572                     r += ulen;
2573                     if (r < rend && *r == 0xff) {       /* illegal utf8 val indicates range */
2574                         rlast = (I32)utf8_to_uv(++r, &ulen);
2575                         r += ulen;
2576                     }
2577                     else
2578                         rlast = rfirst;
2579                 }
2580                 else {
2581                     if (!havefinal++)
2582                         final = rlast;
2583                     rfirst = rlast = 0xffffffff;
2584                 }
2585             }
2586
2587             /* now see which range will peter our first, if either. */
2588             tdiff = tlast - tfirst;
2589             rdiff = rlast - rfirst;
2590
2591             if (tdiff <= rdiff)
2592                 diff = tdiff;
2593             else
2594                 diff = rdiff;
2595
2596             if (rfirst == 0xffffffff) {
2597                 diff = tdiff;   /* oops, pretend rdiff is infinite */
2598                 if (diff > 0)
2599                     Perl_sv_catpvf(aTHX_ listsv, "%04x\t%04x\tXXXX\n", tfirst, tlast);
2600                 else
2601                     Perl_sv_catpvf(aTHX_ listsv, "%04x\t\tXXXX\n", tfirst);
2602             }
2603             else {
2604                 if (diff > 0)
2605                     Perl_sv_catpvf(aTHX_ listsv, "%04x\t%04x\t%04x\n", tfirst, tfirst + diff, rfirst);
2606                 else
2607                     Perl_sv_catpvf(aTHX_ listsv, "%04x\t\t%04x\n", tfirst, rfirst);
2608
2609                 if (rfirst + diff > max)
2610                     max = rfirst + diff;
2611                 rfirst += diff + 1;
2612                 if (!grows) {
2613                     if (rfirst <= 0x80)
2614                         ;
2615                     else if (rfirst <= 0x800)
2616                         grows |= (tfirst < 0x80);
2617                     else if (rfirst <= 0x10000)
2618                         grows |= (tfirst < 0x800);
2619                     else if (rfirst <= 0x200000)
2620                         grows |= (tfirst < 0x10000);
2621                     else if (rfirst <= 0x4000000)
2622                         grows |= (tfirst < 0x200000);
2623                     else if (rfirst <= 0x80000000)
2624                         grows |= (tfirst < 0x4000000);
2625                 }
2626             }
2627             tfirst += diff + 1;
2628         }
2629
2630         none = ++max;
2631         if (del)
2632             del = ++max;
2633
2634         if (max > 0xffff)
2635             bits = 32;
2636         else if (max > 0xff)
2637             bits = 16;
2638         else
2639             bits = 8;
2640
2641         cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none);
2642         SvREFCNT_dec(listsv);
2643         if (transv)
2644             SvREFCNT_dec(transv);
2645
2646         if (!del && havefinal)
2647             (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5, newSViv((IV)final), 0);
2648
2649         if (grows && to_utf)
2650             o->op_private |= OPpTRANS_GROWS;
2651
2652         op_free(expr);
2653         op_free(repl);
2654         return o;
2655     }
2656
2657     tbl = (short*)cPVOPo->op_pv;
2658     if (complement) {
2659         Zero(tbl, 256, short);
2660         for (i = 0; i < tlen; i++)
2661             tbl[t[i]] = -1;
2662         for (i = 0, j = 0; i < 256; i++) {
2663             if (!tbl[i]) {
2664                 if (j >= rlen) {
2665                     if (del)
2666                         tbl[i] = -2;
2667                     else if (rlen)
2668                         tbl[i] = r[j-1];
2669                     else
2670                         tbl[i] = i;
2671                 }
2672                 else
2673                     tbl[i] = r[j++];
2674             }
2675         }
2676     }
2677     else {
2678         if (!rlen && !del) {
2679             r = t; rlen = tlen;
2680             if (!squash)
2681                 o->op_private |= OPpTRANS_IDENTICAL;
2682         }
2683         for (i = 0; i < 256; i++)
2684             tbl[i] = -1;
2685         for (i = 0, j = 0; i < tlen; i++,j++) {
2686             if (j >= rlen) {
2687                 if (del) {
2688                     if (tbl[t[i]] == -1)
2689                         tbl[t[i]] = -2;
2690                     continue;
2691                 }
2692                 --j;
2693             }
2694             if (tbl[t[i]] == -1)
2695                 tbl[t[i]] = r[j];
2696         }
2697     }
2698     op_free(expr);
2699     op_free(repl);
2700
2701     return o;
2702 }
2703
2704 OP *
2705 Perl_newPMOP(pTHX_ I32 type, I32 flags)
2706 {
2707     dTHR;
2708     PMOP *pmop;
2709
2710     NewOp(1101, pmop, 1, PMOP);
2711     pmop->op_type = type;
2712     pmop->op_ppaddr = PL_ppaddr[type];
2713     pmop->op_flags = flags;
2714     pmop->op_private = 0 | (flags >> 8);
2715
2716     if (PL_hints & HINT_RE_TAINT)
2717         pmop->op_pmpermflags |= PMf_RETAINT;
2718     if (PL_hints & HINT_LOCALE)
2719         pmop->op_pmpermflags |= PMf_LOCALE;
2720     pmop->op_pmflags = pmop->op_pmpermflags;
2721
2722     /* link into pm list */
2723     if (type != OP_TRANS && PL_curstash) {
2724         pmop->op_pmnext = HvPMROOT(PL_curstash);
2725         HvPMROOT(PL_curstash) = pmop;
2726     }
2727
2728     return (OP*)pmop;
2729 }
2730
2731 OP *
2732 Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl)
2733 {
2734     dTHR;
2735     PMOP *pm;
2736     LOGOP *rcop;
2737     I32 repl_has_vars = 0;
2738
2739     if (o->op_type == OP_TRANS)
2740         return pmtrans(o, expr, repl);
2741
2742     PL_hints |= HINT_BLOCK_SCOPE;
2743     pm = (PMOP*)o;
2744
2745     if (expr->op_type == OP_CONST) {
2746         STRLEN plen;
2747         SV *pat = ((SVOP*)expr)->op_sv;
2748         char *p = SvPV(pat, plen);
2749         if ((o->op_flags & OPf_SPECIAL) && strEQ(p, " ")) {
2750             sv_setpvn(pat, "\\s+", 3);
2751             p = SvPV(pat, plen);
2752             pm->op_pmflags |= PMf_SKIPWHITE;
2753         }
2754         pm->op_pmregexp = CALLREGCOMP(aTHX_ p, p + plen, pm);
2755         if (strEQ("\\s+", pm->op_pmregexp->precomp))
2756             pm->op_pmflags |= PMf_WHITE;
2757         op_free(expr);
2758     }
2759     else {
2760         if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL))
2761             expr = newUNOP((!(PL_hints & HINT_RE_EVAL)
2762                             ? OP_REGCRESET
2763                             : OP_REGCMAYBE),0,expr);
2764
2765         NewOp(1101, rcop, 1, LOGOP);
2766         rcop->op_type = OP_REGCOMP;
2767         rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP];
2768         rcop->op_first = scalar(expr);
2769         rcop->op_flags |= ((PL_hints & HINT_RE_EVAL)
2770                            ? (OPf_SPECIAL | OPf_KIDS)
2771                            : OPf_KIDS);
2772         rcop->op_private = 1;
2773         rcop->op_other = o;
2774
2775         /* establish postfix order */
2776         if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) {
2777             LINKLIST(expr);
2778             rcop->op_next = expr;
2779             ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
2780         }
2781         else {
2782             rcop->op_next = LINKLIST(expr);
2783             expr->op_next = (OP*)rcop;
2784         }
2785
2786         prepend_elem(o->op_type, scalar((OP*)rcop), o);
2787     }
2788
2789     if (repl) {
2790         OP *curop;
2791         if (pm->op_pmflags & PMf_EVAL) {
2792             curop = 0;
2793             if (PL_curcop->cop_line < PL_multi_end)
2794                 PL_curcop->cop_line = PL_multi_end;
2795         }
2796 #ifdef USE_THREADS
2797         else if (repl->op_type == OP_THREADSV
2798                  && strchr("&`'123456789+",
2799                            PL_threadsv_names[repl->op_targ]))
2800         {
2801             curop = 0;
2802         }
2803 #endif /* USE_THREADS */
2804         else if (repl->op_type == OP_CONST)
2805             curop = repl;
2806         else {
2807             OP *lastop = 0;
2808             for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
2809                 if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
2810 #ifdef USE_THREADS
2811                     if (curop->op_type == OP_THREADSV) {
2812                         repl_has_vars = 1;
2813                         if (strchr("&`'123456789+", curop->op_private))
2814                             break;
2815                     }
2816 #else
2817                     if (curop->op_type == OP_GV) {
2818                         GV *gv = (GV*)((SVOP*)curop)->op_sv;
2819                         repl_has_vars = 1;
2820                         if (strchr("&`'123456789+", *GvENAME(gv)))
2821                             break;
2822                     }
2823 #endif /* USE_THREADS */
2824                     else if (curop->op_type == OP_RV2CV)
2825                         break;
2826                     else if (curop->op_type == OP_RV2SV ||
2827                              curop->op_type == OP_RV2AV ||
2828                              curop->op_type == OP_RV2HV ||
2829                              curop->op_type == OP_RV2GV) {
2830                         if (lastop && lastop->op_type != OP_GV) /*funny deref?*/
2831                             break;
2832                     }
2833                     else if (curop->op_type == OP_PADSV ||
2834                              curop->op_type == OP_PADAV ||
2835                              curop->op_type == OP_PADHV ||
2836                              curop->op_type == OP_PADANY) {
2837                         repl_has_vars = 1;
2838                     }
2839                     else if (curop->op_type == OP_PUSHRE)
2840                         ; /* Okay here, dangerous in newASSIGNOP */
2841                     else
2842                         break;
2843                 }
2844                 lastop = curop;
2845             }
2846         }
2847         if (curop == repl
2848             && !(repl_has_vars
2849                  && (!pm->op_pmregexp
2850                      || pm->op_pmregexp->reganch & ROPT_EVAL_SEEN))) {
2851             pm->op_pmflags |= PMf_CONST;        /* const for long enough */
2852             pm->op_pmpermflags |= PMf_CONST;    /* const for long enough */
2853             prepend_elem(o->op_type, scalar(repl), o);
2854         }
2855         else {
2856             if (curop == repl && !pm->op_pmregexp) { /* Has variables. */
2857                 pm->op_pmflags |= PMf_MAYBE_CONST;
2858                 pm->op_pmpermflags |= PMf_MAYBE_CONST;
2859             }
2860             NewOp(1101, rcop, 1, LOGOP);
2861             rcop->op_type = OP_SUBSTCONT;
2862             rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT];
2863             rcop->op_first = scalar(repl);
2864             rcop->op_flags |= OPf_KIDS;
2865             rcop->op_private = 1;
2866             rcop->op_other = o;
2867
2868             /* establish postfix order */
2869             rcop->op_next = LINKLIST(repl);
2870             repl->op_next = (OP*)rcop;
2871
2872             pm->op_pmreplroot = scalar((OP*)rcop);
2873             pm->op_pmreplstart = LINKLIST(rcop);
2874             rcop->op_next = 0;
2875         }
2876     }
2877
2878     return (OP*)pm;
2879 }
2880
2881 OP *
2882 Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
2883 {
2884     SVOP *svop;
2885     NewOp(1101, svop, 1, SVOP);
2886     svop->op_type = type;
2887     svop->op_ppaddr = PL_ppaddr[type];
2888     svop->op_sv = sv;
2889     svop->op_next = (OP*)svop;
2890     svop->op_flags = flags;
2891     if (PL_opargs[type] & OA_RETSCALAR)
2892         scalar((OP*)svop);
2893     if (PL_opargs[type] & OA_TARGET)
2894         svop->op_targ = pad_alloc(type, SVs_PADTMP);
2895     return CHECKOP(type, svop);
2896 }
2897
2898 OP *
2899 Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
2900 {
2901     dTHR;
2902     return newSVOP(type, flags, SvREFCNT_inc(gv));
2903 }
2904
2905 OP *
2906 Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
2907 {
2908     PVOP *pvop;
2909     NewOp(1101, pvop, 1, PVOP);
2910     pvop->op_type = type;
2911     pvop->op_ppaddr = PL_ppaddr[type];
2912     pvop->op_pv = pv;
2913     pvop->op_next = (OP*)pvop;
2914     pvop->op_flags = flags;
2915     if (PL_opargs[type] & OA_RETSCALAR)
2916         scalar((OP*)pvop);
2917     if (PL_opargs[type] & OA_TARGET)
2918         pvop->op_targ = pad_alloc(type, SVs_PADTMP);
2919     return CHECKOP(type, pvop);
2920 }
2921
2922 void
2923 Perl_package(pTHX_ OP *o)
2924 {
2925     dTHR;
2926     SV *sv;
2927
2928     save_hptr(&PL_curstash);
2929     save_item(PL_curstname);
2930     if (o) {
2931         STRLEN len;
2932         char *name;
2933         sv = cSVOPo->op_sv;
2934         name = SvPV(sv, len);
2935         PL_curstash = gv_stashpvn(name,len,TRUE);
2936         sv_setpvn(PL_curstname, name, len);
2937         op_free(o);
2938     }
2939     else {
2940         sv_setpv(PL_curstname,"<none>");
2941         PL_curstash = Nullhv;
2942     }
2943     PL_hints |= HINT_BLOCK_SCOPE;
2944     PL_copline = NOLINE;
2945     PL_expect = XSTATE;
2946 }
2947
2948 void
2949 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *id, OP *arg)
2950 {
2951     OP *pack;
2952     OP *meth;
2953     OP *rqop;
2954     OP *imop;
2955     OP *veop;
2956     GV *gv;
2957
2958     if (id->op_type != OP_CONST)
2959         Perl_croak(aTHX_ "Module name must be constant");
2960
2961     veop = Nullop;
2962
2963     if(version != Nullop) {
2964         SV *vesv = ((SVOP*)version)->op_sv;
2965
2966         if (arg == Nullop && !SvNIOK(vesv)) {
2967             arg = version;
2968         }
2969         else {
2970             OP *pack;
2971
2972             if (version->op_type != OP_CONST || !SvNIOK(vesv))
2973                 Perl_croak(aTHX_ "Version number must be constant number");
2974
2975             /* Make copy of id so we don't free it twice */
2976             pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
2977
2978             /* Fake up a method call to VERSION */
2979             veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
2980                             append_elem(OP_LIST,
2981                             prepend_elem(OP_LIST, pack, list(version)),
2982                             newSVOP(OP_METHOD_NAMED, 0,
2983                                     newSVpvn("VERSION", 7))));
2984         }
2985     }
2986
2987     /* Fake up an import/unimport */
2988     if (arg && arg->op_type == OP_STUB)
2989         imop = arg;             /* no import on explicit () */
2990     else if(SvNIOK(((SVOP*)id)->op_sv)) {
2991         imop = Nullop;          /* use 5.0; */
2992     }
2993     else {
2994         /* Make copy of id so we don't free it twice */
2995         pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
2996         imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
2997                     append_elem(OP_LIST,
2998                         prepend_elem(OP_LIST, pack, list(arg)),
2999                         newSVOP(OP_METHOD_NAMED, 0,
3000                                 aver ? newSVpvn("import", 6)
3001                                      : newSVpvn("unimport", 8))));
3002     }
3003
3004     /* Fake up a require, handle override, if any */
3005     gv = gv_fetchpv("require", FALSE, SVt_PVCV);
3006     if (!(gv && GvIMPORTED_CV(gv)))
3007         gv = gv_fetchpv("CORE::GLOBAL::require", FALSE, SVt_PVCV);
3008
3009     if (gv && GvIMPORTED_CV(gv)) {
3010         rqop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
3011                                append_elem(OP_LIST, id,
3012                                            scalar(newUNOP(OP_RV2CV, 0,
3013                                                           newGVOP(OP_GV, 0,
3014                                                                   gv))))));
3015     }
3016     else {
3017         rqop = newUNOP(OP_REQUIRE, 0, id);
3018     }
3019
3020     /* Fake up the BEGIN {}, which does its thing immediately. */
3021     newATTRSUB(floor,
3022         newSVOP(OP_CONST, 0, newSVpvn("BEGIN", 5)),
3023         Nullop,
3024         Nullop,
3025         append_elem(OP_LINESEQ,
3026             append_elem(OP_LINESEQ,
3027                 newSTATEOP(0, Nullch, rqop),
3028                 newSTATEOP(0, Nullch, veop)),
3029             newSTATEOP(0, Nullch, imop) ));
3030
3031     PL_hints |= HINT_BLOCK_SCOPE;
3032     PL_copline = NOLINE;
3033     PL_expect = XSTATE;
3034 }
3035
3036 OP *
3037 Perl_dofile(pTHX_ OP *term)
3038 {
3039     OP *doop;
3040     GV *gv;
3041
3042     gv = gv_fetchpv("do", FALSE, SVt_PVCV);
3043     if (!(gv && GvIMPORTED_CV(gv)))
3044         gv = gv_fetchpv("CORE::GLOBAL::do", FALSE, SVt_PVCV);
3045
3046     if (gv && GvIMPORTED_CV(gv)) {
3047         doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
3048                                append_elem(OP_LIST, term,
3049                                            scalar(newUNOP(OP_RV2CV, 0,
3050                                                           newGVOP(OP_GV, 0,
3051                                                                   gv))))));
3052     }
3053     else {
3054         doop = newUNOP(OP_DOFILE, 0, scalar(term));
3055     }
3056     return doop;
3057 }
3058
3059 OP *
3060 Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listval)
3061 {
3062     return newBINOP(OP_LSLICE, flags,
3063             list(force_list(subscript)),
3064             list(force_list(listval)) );
3065 }
3066
3067 STATIC I32
3068 S_list_assignment(pTHX_ register OP *o)
3069 {
3070     if (!o)
3071         return TRUE;
3072
3073     if (o->op_type == OP_NULL && o->op_flags & OPf_KIDS)
3074         o = cUNOPo->op_first;
3075
3076     if (o->op_type == OP_COND_EXPR) {
3077         I32 t = list_assignment(cLOGOPo->op_first->op_sibling);
3078         I32 f = list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
3079
3080         if (t && f)
3081             return TRUE;
3082         if (t || f)
3083             yyerror("Assignment to both a list and a scalar");
3084         return FALSE;
3085     }
3086
3087     if (o->op_type == OP_LIST || o->op_flags & OPf_PARENS ||
3088         o->op_type == OP_RV2AV || o->op_type == OP_RV2HV ||
3089         o->op_type == OP_ASLICE || o->op_type == OP_HSLICE)
3090         return TRUE;
3091
3092     if (o->op_type == OP_PADAV || o->op_type == OP_PADHV)
3093         return TRUE;
3094
3095     if (o->op_type == OP_RV2SV)
3096         return FALSE;
3097
3098     return FALSE;
3099 }
3100
3101 OP *
3102 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
3103 {
3104     OP *o;
3105
3106     if (optype) {
3107         if (optype == OP_ANDASSIGN || optype == OP_ORASSIGN) {
3108             return newLOGOP(optype, 0,
3109                 mod(scalar(left), optype),
3110                 newUNOP(OP_SASSIGN, 0, scalar(right)));
3111         }
3112         else {
3113             return newBINOP(optype, OPf_STACKED,
3114                 mod(scalar(left), optype), scalar(right));
3115         }
3116     }
3117
3118     if (list_assignment(left)) {
3119         dTHR;
3120         PL_modcount = 0;
3121         PL_eval_start = right;  /* Grandfathering $[ assignment here.  Bletch.*/
3122         left = mod(left, OP_AASSIGN);
3123         if (PL_eval_start)
3124             PL_eval_start = 0;
3125         else {
3126             op_free(left);
3127             op_free(right);
3128             return Nullop;
3129         }
3130         o = newBINOP(OP_AASSIGN, flags,
3131                 list(force_list(right)),
3132                 list(force_list(left)) );
3133         o->op_private = 0 | (flags >> 8);
3134         if (!(left->op_private & OPpLVAL_INTRO)) {
3135             OP *curop;
3136             OP *lastop = o;
3137             PL_generation++;
3138             for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
3139                 if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
3140                     if (curop->op_type == OP_GV) {
3141                         GV *gv = (GV*)((SVOP*)curop)->op_sv;
3142                         if (gv == PL_defgv || SvCUR(gv) == PL_generation)
3143                             break;
3144                         SvCUR(gv) = PL_generation;
3145                     }
3146                     else if (curop->op_type == OP_PADSV ||
3147                              curop->op_type == OP_PADAV ||
3148                              curop->op_type == OP_PADHV ||
3149                              curop->op_type == OP_PADANY) {
3150                         SV **svp = AvARRAY(PL_comppad_name);
3151                         SV *sv = svp[curop->op_targ];
3152                         if (SvCUR(sv) == PL_generation)
3153                             break;
3154                         SvCUR(sv) = PL_generation;      /* (SvCUR not used any more) */
3155                     }
3156                     else if (curop->op_type == OP_RV2CV)
3157                         break;
3158                     else if (curop->op_type == OP_RV2SV ||
3159                              curop->op_type == OP_RV2AV ||
3160                              curop->op_type == OP_RV2HV ||
3161                              curop->op_type == OP_RV2GV) {
3162                         if (lastop->op_type != OP_GV)   /* funny deref? */
3163                             break;
3164                     }
3165                     else if (curop->op_type == OP_PUSHRE) {
3166                         if (((PMOP*)curop)->op_pmreplroot) {
3167                             GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot;
3168                             if (gv == PL_defgv || SvCUR(gv) == PL_generation)
3169                                 break;
3170                             SvCUR(gv) = PL_generation;
3171                         }
3172                     }
3173                     else
3174                         break;
3175                 }
3176                 lastop = curop;
3177             }
3178             if (curop != o)
3179                 o->op_private = OPpASSIGN_COMMON;
3180         }
3181         if (right && right->op_type == OP_SPLIT) {
3182             OP* tmpop;
3183             if ((tmpop = ((LISTOP*)right)->op_first) &&
3184                 tmpop->op_type == OP_PUSHRE)
3185             {
3186                 PMOP *pm = (PMOP*)tmpop;
3187                 if (left->op_type == OP_RV2AV &&
3188                     !(left->op_private & OPpLVAL_INTRO) &&
3189                     !(o->op_private & OPpASSIGN_COMMON) )
3190                 {
3191                     tmpop = ((UNOP*)left)->op_first;
3192                     if (tmpop->op_type == OP_GV && !pm->op_pmreplroot) {
3193                         pm->op_pmreplroot = (OP*)((SVOP*)tmpop)->op_sv;
3194                         pm->op_pmflags |= PMf_ONCE;
3195                         tmpop = cUNOPo->op_first;       /* to list (nulled) */
3196                         tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
3197                         tmpop->op_sibling = Nullop;     /* don't free split */
3198                         right->op_next = tmpop->op_next;  /* fix starting loc */
3199                         op_free(o);                     /* blow off assign */
3200                         right->op_flags &= ~OPf_WANT;
3201                                 /* "I don't know and I don't care." */
3202                         return right;
3203                     }
3204                 }
3205                 else {
3206                     if (PL_modcount < 10000 &&
3207                       ((LISTOP*)right)->op_last->op_type == OP_CONST)
3208                     {
3209                         SV *sv = ((SVOP*)((LISTOP*)right)->op_last)->op_sv;
3210                         if (SvIVX(sv) == 0)
3211                             sv_setiv(sv, PL_modcount+1);
3212                     }
3213                 }
3214             }
3215         }
3216         return o;
3217     }
3218     if (!right)
3219         right = newOP(OP_UNDEF, 0);
3220     if (right->op_type == OP_READLINE) {
3221         right->op_flags |= OPf_STACKED;
3222         return newBINOP(OP_NULL, flags, mod(scalar(left), OP_SASSIGN), scalar(right));
3223     }
3224     else {
3225         PL_eval_start = right;  /* Grandfathering $[ assignment here.  Bletch.*/
3226         o = newBINOP(OP_SASSIGN, flags,
3227             scalar(right), mod(scalar(left), OP_SASSIGN) );
3228         if (PL_eval_start)
3229             PL_eval_start = 0;
3230         else {
3231             op_free(o);
3232             return Nullop;
3233         }
3234     }
3235     return o;
3236 }
3237
3238 OP *
3239 Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
3240 {
3241     dTHR;
3242     U32 seq = intro_my();
3243     register COP *cop;
3244
3245     NewOp(1101, cop, 1, COP);
3246     if (PERLDB_LINE && PL_curcop->cop_line && PL_curstash != PL_debstash) {
3247         cop->op_type = OP_DBSTATE;
3248         cop->op_ppaddr = PL_ppaddr[ OP_DBSTATE ];
3249     }
3250     else {
3251         cop->op_type = OP_NEXTSTATE;
3252         cop->op_ppaddr = PL_ppaddr[ OP_NEXTSTATE ];
3253     }
3254     cop->op_flags = flags;
3255     cop->op_private = (PL_hints & HINT_UTF8);
3256 #ifdef NATIVE_HINTS
3257     cop->op_private |= NATIVE_HINTS;
3258 #endif
3259     PL_compiling.op_private = cop->op_private;
3260     cop->op_next = (OP*)cop;
3261
3262     if (label) {
3263         cop->cop_label = label;
3264         PL_hints |= HINT_BLOCK_SCOPE;
3265     }
3266     cop->cop_seq = seq;
3267     cop->cop_arybase = PL_curcop->cop_arybase;
3268     if (specialWARN(PL_curcop->cop_warnings))
3269         cop->cop_warnings = PL_curcop->cop_warnings ;
3270     else
3271         cop->cop_warnings = newSVsv(PL_curcop->cop_warnings) ;
3272
3273
3274     if (PL_copline == NOLINE)
3275         cop->cop_line = PL_curcop->cop_line;
3276     else {
3277         cop->cop_line = PL_copline;
3278         PL_copline = NOLINE;
3279     }
3280     cop->cop_filegv = (GV*)SvREFCNT_inc(PL_curcop->cop_filegv);
3281     cop->cop_stash = PL_curstash;
3282
3283     if (PERLDB_LINE && PL_curstash != PL_debstash) {
3284         SV **svp = av_fetch(GvAV(PL_curcop->cop_filegv),(I32)cop->cop_line, FALSE);
3285         if (svp && *svp != &PL_sv_undef && !SvIOK(*svp)) {
3286             (void)SvIOK_on(*svp);
3287             SvIVX(*svp) = 1;
3288             SvSTASH(*svp) = (HV*)cop;
3289         }
3290     }
3291
3292     return prepend_elem(OP_LINESEQ, (OP*)cop, o);
3293 }
3294
3295 /* "Introduce" my variables to visible status. */
3296 U32
3297 Perl_intro_my(pTHX)
3298 {
3299     SV **svp;
3300     SV *sv;
3301     I32 i;
3302
3303     if (! PL_min_intro_pending)
3304         return PL_cop_seqmax;
3305
3306     svp = AvARRAY(PL_comppad_name);
3307     for (i = PL_min_intro_pending; i <= PL_max_intro_pending; i++) {
3308         if ((sv = svp[i]) && sv != &PL_sv_undef && !SvIVX(sv)) {
3309             SvIVX(sv) = PAD_MAX;        /* Don't know scope end yet. */
3310             SvNVX(sv) = (NV)PL_cop_seqmax;
3311         }
3312     }
3313     PL_min_intro_pending = 0;
3314     PL_comppad_name_fill = PL_max_intro_pending;        /* Needn't search higher */
3315     return PL_cop_seqmax++;
3316 }
3317
3318 OP *
3319 Perl_newLOGOP(pTHX_ I32 type, I32 flags, OP *first, OP *other)
3320 {
3321     return new_logop(type, flags, &first, &other);
3322 }
3323
3324 STATIC OP *
3325 S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
3326 {
3327     dTHR;
3328     LOGOP *logop;
3329     OP *o;
3330     OP *first = *firstp;
3331     OP *other = *otherp;
3332
3333     if (type == OP_XOR)         /* Not short circuit, but here by precedence. */
3334         return newBINOP(type, flags, scalar(first), scalar(other));
3335
3336     scalarboolean(first);
3337     /* optimize "!a && b" to "a || b", and "!a || b" to "a && b" */
3338     if (first->op_type == OP_NOT && (first->op_flags & OPf_SPECIAL)) {
3339         if (type == OP_AND || type == OP_OR) {
3340             if (type == OP_AND)
3341                 type = OP_OR;
3342             else
3343                 type = OP_AND;
3344             o = first;
3345             first = *firstp = cUNOPo->op_first;
3346             if (o->op_next)
3347                 first->op_next = o->op_next;
3348             cUNOPo->op_first = Nullop;
3349             op_free(o);
3350         }
3351     }
3352     if (first->op_type == OP_CONST) {
3353         if (ckWARN(WARN_PRECEDENCE) && (first->op_private & OPpCONST_BARE))
3354             Perl_warner(aTHX_ WARN_PRECEDENCE, "Probable precedence problem on %s",
3355                         PL_op_desc[type]);
3356         if ((type == OP_AND) == (SvTRUE(((SVOP*)first)->op_sv))) {
3357             op_free(first);
3358             *firstp = Nullop;
3359             return other;
3360         }
3361         else {
3362             op_free(other);
3363             *otherp = Nullop;
3364             return first;
3365         }
3366     }
3367     else if (first->op_type == OP_WANTARRAY) {
3368         if (type == OP_AND)
3369             list(other);
3370         else
3371             scalar(other);
3372     }
3373     else if (ckWARN(WARN_UNSAFE) && (first->op_flags & OPf_KIDS)) {
3374         OP *k1 = ((UNOP*)first)->op_first;
3375         OP *k2 = k1->op_sibling;
3376         OPCODE warnop = 0;
3377         switch (first->op_type)
3378         {
3379         case OP_NULL:
3380             if (k2 && k2->op_type == OP_READLINE
3381                   && (k2->op_flags & OPf_STACKED)
3382                   && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
3383             {
3384                 warnop = k2->op_type;
3385             }
3386             break;
3387
3388         case OP_SASSIGN:
3389             if (k1->op_type == OP_READDIR
3390                   || k1->op_type == OP_GLOB
3391                   || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
3392                   || k1->op_type == OP_EACH)
3393             {
3394                 warnop = ((k1->op_type == OP_NULL)
3395                           ? k1->op_targ : k1->op_type);
3396             }
3397             break;
3398         }
3399         if (warnop) {
3400             line_t oldline = PL_curcop->cop_line;
3401             PL_curcop->cop_line = PL_copline;
3402             Perl_warner(aTHX_ WARN_UNSAFE,
3403                  "Value of %s%s can be \"0\"; test with defined()",
3404                  PL_op_desc[warnop],
3405                  ((warnop == OP_READLINE || warnop == OP_GLOB)
3406                   ? " construct" : "() operator"));
3407             PL_curcop->cop_line = oldline;
3408         }
3409     }
3410
3411     if (!other)
3412         return first;
3413
3414     if (type == OP_ANDASSIGN || type == OP_ORASSIGN)
3415         other->op_private |= OPpASSIGN_BACKWARDS;  /* other is an OP_SASSIGN */
3416
3417     NewOp(1101, logop, 1, LOGOP);
3418
3419     logop->op_type = type;
3420     logop->op_ppaddr = PL_ppaddr[type];
3421     logop->op_first = first;
3422     logop->op_flags = flags | OPf_KIDS;
3423     logop->op_other = LINKLIST(other);
3424     logop->op_private = 1 | (flags >> 8);
3425
3426     /* establish postfix order */
3427     logop->op_next = LINKLIST(first);
3428     first->op_next = (OP*)logop;
3429     first->op_sibling = other;
3430
3431     o = newUNOP(OP_NULL, 0, (OP*)logop);
3432     other->op_next = o;
3433
3434     return o;
3435 }
3436
3437 OP *
3438 Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop)
3439 {
3440     dTHR;
3441     LOGOP *logop;
3442     OP *start;
3443     OP *o;
3444
3445     if (!falseop)
3446         return newLOGOP(OP_AND, 0, first, trueop);
3447     if (!trueop)
3448         return newLOGOP(OP_OR, 0, first, falseop);
3449
3450     scalarboolean(first);
3451     if (first->op_type == OP_CONST) {
3452         if (SvTRUE(((SVOP*)first)->op_sv)) {
3453             op_free(first);
3454             op_free(falseop);
3455             return trueop;
3456         }
3457         else {
3458             op_free(first);
3459             op_free(trueop);
3460             return falseop;
3461         }
3462     }
3463     else if (first->op_type == OP_WANTARRAY) {
3464         list(trueop);
3465         scalar(falseop);
3466     }
3467     NewOp(1101, logop, 1, LOGOP);
3468     logop->op_type = OP_COND_EXPR;
3469     logop->op_ppaddr = PL_ppaddr[OP_COND_EXPR];
3470     logop->op_first = first;
3471     logop->op_flags = flags | OPf_KIDS;
3472     logop->op_private = 1 | (flags >> 8);
3473     logop->op_other = LINKLIST(trueop);
3474     logop->op_next = LINKLIST(falseop);
3475
3476
3477     /* establish postfix order */
3478     start = LINKLIST(first);
3479     first->op_next = (OP*)logop;
3480
3481     first->op_sibling = trueop;
3482     trueop->op_sibling = falseop;
3483     o = newUNOP(OP_NULL, 0, (OP*)logop);
3484
3485     trueop->op_next = falseop->op_next = o;
3486
3487     o->op_next = start;
3488     return o;
3489 }
3490
3491 OP *
3492 Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
3493 {
3494     dTHR;
3495     LOGOP *range;
3496     OP *flip;
3497     OP *flop;
3498     OP *leftstart;
3499     OP *o;
3500
3501     NewOp(1101, range, 1, LOGOP);
3502
3503     range->op_type = OP_RANGE;
3504     range->op_ppaddr = PL_ppaddr[OP_RANGE];
3505     range->op_first = left;
3506     range->op_flags = OPf_KIDS;
3507     leftstart = LINKLIST(left);
3508     range->op_other = LINKLIST(right);
3509     range->op_private = 1 | (flags >> 8);
3510
3511     left->op_sibling = right;
3512
3513     range->op_next = (OP*)range;
3514     flip = newUNOP(OP_FLIP, flags, (OP*)range);
3515     flop = newUNOP(OP_FLOP, 0, flip);
3516     o = newUNOP(OP_NULL, 0, flop);
3517     linklist(flop);
3518     range->op_next = leftstart;
3519
3520     left->op_next = flip;
3521     right->op_next = flop;
3522
3523     range->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
3524     sv_upgrade(PAD_SV(range->op_targ), SVt_PVNV);
3525     flip->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
3526     sv_upgrade(PAD_SV(flip->op_targ), SVt_PVNV);
3527
3528     flip->op_private =  left->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
3529     flop->op_private = right->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
3530
3531     flip->op_next = o;
3532     if (!flip->op_private || !flop->op_private)
3533         linklist(o);            /* blow off optimizer unless constant */
3534
3535     return o;
3536 }
3537
3538 OP *
3539 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
3540 {
3541     dTHR;
3542     OP* listop;
3543     OP* o;
3544     int once = block && block->op_flags & OPf_SPECIAL &&
3545       (block->op_type == OP_ENTERSUB || block->op_type == OP_NULL);
3546
3547     if (expr) {
3548         if (once && expr->op_type == OP_CONST && !SvTRUE(((SVOP*)expr)->op_sv))
3549             return block;       /* do {} while 0 does once */
3550         if (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB
3551             || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB)) {
3552             expr = newUNOP(OP_DEFINED, 0,
3553                 newASSIGNOP(0, newDEFSVOP(), 0, expr) );
3554         } else if (expr->op_flags & OPf_KIDS) {
3555             OP *k1 = ((UNOP*)expr)->op_first;
3556             OP *k2 = (k1) ? k1->op_sibling : NULL;
3557             switch (expr->op_type) {
3558               case OP_NULL:
3559                 if (k2 && k2->op_type == OP_READLINE
3560                       && (k2->op_flags & OPf_STACKED)
3561                       && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
3562                     expr = newUNOP(OP_DEFINED, 0, expr);
3563                 break;
3564
3565               case OP_SASSIGN:
3566                 if (k1->op_type == OP_READDIR
3567                       || k1->op_type == OP_GLOB
3568                       || (k1->op_type == OP_NULL && k1->op_targ == OP_NULL)
3569                       || k1->op_type == OP_EACH)
3570                     expr = newUNOP(OP_DEFINED, 0, expr);
3571                 break;
3572             }
3573         }
3574     }
3575
3576     listop = append_elem(OP_LINESEQ, block, newOP(OP_UNSTACK, 0));
3577     o = new_logop(OP_AND, 0, &expr, &listop);
3578
3579     if (listop)
3580         ((LISTOP*)listop)->op_last->op_next = LINKLIST(o);
3581
3582     if (once && o != listop)
3583         o->op_next = ((LOGOP*)cUNOPo->op_first)->op_other;
3584
3585     if (o == listop)
3586         o = newUNOP(OP_NULL, 0, o);     /* or do {} while 1 loses outer block */
3587
3588     o->op_flags |= flags;
3589     o = scope(o);
3590     o->op_flags |= OPf_SPECIAL; /* suppress POPBLOCK curpm restoration*/
3591     return o;
3592 }
3593
3594 OP *
3595 Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *expr, OP *block, OP *cont)
3596 {
3597     dTHR;
3598     OP *redo;
3599     OP *next = 0;
3600     OP *listop;
3601     OP *o;
3602     OP *condop;
3603
3604     if (expr && (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB
3605                  || (expr->op_type == OP_NULL && expr->op_targ == OP_GLOB))) {
3606         expr = newUNOP(OP_DEFINED, 0,
3607             newASSIGNOP(0, newDEFSVOP(), 0, expr) );
3608     } else if (expr && (expr->op_flags & OPf_KIDS)) {
3609         OP *k1 = ((UNOP*)expr)->op_first;
3610         OP *k2 = (k1) ? k1->op_sibling : NULL;
3611         switch (expr->op_type) {
3612           case OP_NULL:
3613             if (k2 && k2->op_type == OP_READLINE
3614                   && (k2->op_flags & OPf_STACKED)
3615                   && ((k1->op_flags & OPf_WANT) == OPf_WANT_SCALAR))
3616                 expr = newUNOP(OP_DEFINED, 0, expr);
3617             break;
3618
3619           case OP_SASSIGN:
3620             if (k1->op_type == OP_READDIR
3621                   || k1->op_type == OP_GLOB
3622                   || (k1->op_type == OP_NULL && k1->op_targ == OP_GLOB)
3623                   || k1->op_type == OP_EACH)
3624                 expr = newUNOP(OP_DEFINED, 0, expr);
3625             break;
3626         }
3627     }
3628
3629     if (!block)
3630         block = newOP(OP_NULL, 0);
3631
3632     if (cont)
3633         next = LINKLIST(cont);
3634     if (expr) {
3635         cont = append_elem(OP_LINESEQ, cont, newOP(OP_UNSTACK, 0));
3636         if ((line_t)whileline != NOLINE) {
3637             PL_copline = whileline;
3638             cont = append_elem(OP_LINESEQ, cont,
3639                                newSTATEOP(0, Nullch, Nullop));
3640         }
3641     }
3642
3643     listop = append_list(OP_LINESEQ, (LISTOP*)block, (LISTOP*)cont);
3644     redo = LINKLIST(listop);
3645
3646     if (expr) {
3647         PL_copline = whileline;
3648         scalar(listop);
3649         o = new_logop(OP_AND, 0, &expr, &listop);
3650         if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
3651             op_free(expr);              /* oops, it's a while (0) */
3652             op_free((OP*)loop);
3653             return Nullop;              /* listop already freed by new_logop */
3654         }
3655         if (listop)
3656             ((LISTOP*)listop)->op_last->op_next = condop =
3657                 (o == listop ? redo : LINKLIST(o));
3658         if (!next)
3659             next = condop;
3660     }
3661     else
3662         o = listop;
3663
3664     if (!loop) {
3665         NewOp(1101,loop,1,LOOP);
3666         loop->op_type = OP_ENTERLOOP;
3667         loop->op_ppaddr = PL_ppaddr[OP_ENTERLOOP];
3668         loop->op_private = 0;
3669         loop->op_next = (OP*)loop;
3670     }
3671
3672     o = newBINOP(OP_LEAVELOOP, 0, (OP*)loop, o);
3673
3674     loop->op_redoop = redo;
3675     loop->op_lastop = o;
3676
3677     if (next)
3678         loop->op_nextop = next;
3679     else
3680         loop->op_nextop = o;
3681
3682     o->op_flags |= flags;
3683     o->op_private |= (flags >> 8);
3684     return o;
3685 }
3686
3687 OP *
3688 Perl_newFOROP(pTHX_ I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont)
3689 {
3690     LOOP *loop;
3691     LOOP *tmp;
3692     OP *wop;
3693     int padoff = 0;
3694     I32 iterflags = 0;
3695
3696     if (sv) {
3697         if (sv->op_type == OP_RV2SV) {  /* symbol table variable */
3698             sv->op_type = OP_RV2GV;
3699             sv->op_ppaddr = PL_ppaddr[OP_RV2GV];
3700         }
3701         else if (sv->op_type == OP_PADSV) { /* private variable */
3702             padoff = sv->op_targ;
3703             op_free(sv);
3704             sv = Nullop;
3705         }
3706         else if (sv->op_type == OP_THREADSV) { /* per-thread variable */
3707             padoff = sv->op_targ;
3708             iterflags |= OPf_SPECIAL;
3709             op_free(sv);
3710             sv = Nullop;
3711         }
3712         else
3713             Perl_croak(aTHX_ "Can't use %s for loop variable", PL_op_desc[sv->op_type]);
3714     }
3715     else {
3716 #ifdef USE_THREADS
3717         padoff = find_threadsv("_");
3718         iterflags |= OPf_SPECIAL;
3719 #else
3720         sv = newGVOP(OP_GV, 0, PL_defgv);
3721 #endif
3722     }
3723     if (expr->op_type == OP_RV2AV || expr->op_type == OP_PADAV) {
3724         expr = mod(force_list(scalar(ref(expr, OP_ITER))), OP_GREPSTART);
3725         iterflags |= OPf_STACKED;
3726     }
3727     else if (expr->op_type == OP_NULL &&
3728              (expr->op_flags & OPf_KIDS) &&
3729              ((BINOP*)expr)->op_first->op_type == OP_FLOP)
3730     {
3731         /* Basically turn for($x..$y) into the same as for($x,$y), but we
3732          * set the STACKED flag to indicate that these values are to be
3733          * treated as min/max values by 'pp_iterinit'.
3734          */
3735         UNOP* flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
3736         LOGOP* range = (LOGOP*) flip->op_first;
3737         OP* left  = range->op_first;
3738         OP* right = left->op_sibling;
3739         LISTOP* listop;
3740
3741         range->op_flags &= ~OPf_KIDS;
3742         range->op_first = Nullop;
3743
3744         listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
3745         listop->op_first->op_next = range->op_next;
3746         left->op_next = range->op_other;
3747         right->op_next = (OP*)listop;
3748         listop->op_next = listop->op_first;
3749
3750         op_free(expr);
3751         expr = (OP*)(listop);
3752         null(expr);
3753         iterflags |= OPf_STACKED;
3754     }
3755     else {
3756         expr = mod(force_list(expr), OP_GREPSTART);
3757     }
3758
3759
3760     loop = (LOOP*)list(convert(OP_ENTERITER, iterflags,
3761                                append_elem(OP_LIST, expr, scalar(sv))));
3762     assert(!loop->op_next);
3763 #ifdef PL_OP_SLAB_ALLOC
3764     NewOp(1234,tmp,1,LOOP);
3765     Copy(loop,tmp,1,LOOP);
3766     loop = tmp;
3767 #else
3768     Renew(loop, 1, LOOP);
3769 #endif
3770     loop->op_targ = padoff;
3771     wop = newWHILEOP(flags, 1, loop, forline, newOP(OP_ITER, 0), block, cont);
3772     PL_copline = forline;
3773     return newSTATEOP(0, label, wop);
3774 }
3775
3776 OP*
3777 Perl_newLOOPEX(pTHX_ I32 type, OP *label)
3778 {
3779     dTHR;
3780     OP *o;
3781     STRLEN n_a;
3782
3783     if (type != OP_GOTO || label->op_type == OP_CONST) {
3784         /* "last()" means "last" */
3785         if (label->op_type == OP_STUB && (label->op_flags & OPf_PARENS))
3786             o = newOP(type, OPf_SPECIAL);
3787         else {
3788             o = newPVOP(type, 0, savepv(label->op_type == OP_CONST
3789                                         ? SvPVx(((SVOP*)label)->op_sv, n_a)
3790                                         : ""));
3791         }
3792         op_free(label);
3793     }
3794     else {
3795         if (label->op_type == OP_ENTERSUB)
3796             label = newUNOP(OP_REFGEN, 0, mod(label, OP_REFGEN));
3797         o = newUNOP(type, OPf_STACKED, label);
3798     }
3799     PL_hints |= HINT_BLOCK_SCOPE;
3800     return o;
3801 }
3802
3803 void
3804 Perl_cv_undef(pTHX_ CV *cv)
3805 {
3806     dTHR;
3807 #ifdef USE_THREADS
3808     if (CvMUTEXP(cv)) {
3809         MUTEX_DESTROY(CvMUTEXP(cv));
3810         Safefree(CvMUTEXP(cv));
3811         CvMUTEXP(cv) = 0;
3812     }
3813 #endif /* USE_THREADS */
3814
3815     if (!CvXSUB(cv) && CvROOT(cv)) {
3816 #ifdef USE_THREADS
3817         if (CvDEPTH(cv) || (CvOWNER(cv) && CvOWNER(cv) != thr))
3818             Perl_croak(aTHX_ "Can't undef active subroutine");
3819 #else
3820         if (CvDEPTH(cv))
3821             Perl_croak(aTHX_ "Can't undef active subroutine");
3822 #endif /* USE_THREADS */
3823         ENTER;
3824
3825         SAVESPTR(PL_curpad);
3826         PL_curpad = 0;
3827
3828         if (!CvCLONED(cv))
3829             op_free(CvROOT(cv));
3830         CvROOT(cv) = Nullop;
3831         LEAVE;
3832     }
3833     SvPOK_off((SV*)cv);         /* forget prototype */
3834     CvFLAGS(cv) = 0;
3835     SvREFCNT_dec(CvGV(cv));
3836     CvGV(cv) = Nullgv;
3837     SvREFCNT_dec(CvOUTSIDE(cv));
3838     CvOUTSIDE(cv) = Nullcv;
3839     if (CvPADLIST(cv)) {
3840         /* may be during global destruction */
3841         if (SvREFCNT(CvPADLIST(cv))) {
3842             I32 i = AvFILLp(CvPADLIST(cv));
3843             while (i >= 0) {
3844                 SV** svp = av_fetch(CvPADLIST(cv), i--, FALSE);
3845                 SV* sv = svp ? *svp : Nullsv;
3846                 if (!sv)
3847                     continue;
3848                 if (sv == (SV*)PL_comppad_name)
3849                     PL_comppad_name = Nullav;
3850                 else if (sv == (SV*)PL_comppad) {
3851                     PL_comppad = Nullav;
3852                     PL_curpad = Null(SV**);
3853                 }
3854                 SvREFCNT_dec(sv);
3855             }
3856             SvREFCNT_dec((SV*)CvPADLIST(cv));
3857         }
3858         CvPADLIST(cv) = Nullav;
3859     }
3860 }
3861
3862 #ifdef DEBUG_CLOSURES
3863 STATIC void
3864 cv_dump(CV *cv)
3865 {
3866     CV *outside = CvOUTSIDE(cv);
3867     AV* padlist = CvPADLIST(cv);
3868     AV* pad_name;
3869     AV* pad;
3870     SV** pname;
3871     SV** ppad;
3872     I32 ix;
3873
3874     PerlIO_printf(Perl_debug_log,
3875                   "\tCV=0x%"UVxf" (%s), OUTSIDE=0x%"UVxf" (%s)\n",
3876                   PTR2UV(cv),
3877                   (CvANON(cv) ? "ANON"
3878                    : (cv == PL_main_cv) ? "MAIN"
3879                    : CvUNIQUE(cv) ? "UNIQUE"
3880                    : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"),
3881                   PTR2UV(outside),
3882                   (!outside ? "null"
3883                    : CvANON(outside) ? "ANON"
3884                    : (outside == PL_main_cv) ? "MAIN"
3885                    : CvUNIQUE(outside) ? "UNIQUE"
3886                    : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
3887
3888     if (!padlist)
3889         return;
3890
3891     pad_name = (AV*)*av_fetch(padlist, 0, FALSE);
3892     pad = (AV*)*av_fetch(padlist, 1, FALSE);
3893     pname = AvARRAY(pad_name);
3894     ppad = AvARRAY(pad);
3895
3896     for (ix = 1; ix <= AvFILLp(pad_name); ix++) {
3897         if (SvPOK(pname[ix]))
3898             PerlIO_printf(Perl_debug_log,
3899                           "\t%4d. 0x%"UVxf" (%s\"%s\" %"IVdf"-%"IVdf")\n",
3900                           ix, PTR2UV(ppad[ix]),
3901                           SvFAKE(pname[ix]) ? "FAKE " : "",
3902                           SvPVX(pname[ix]),
3903                           (IV)I_32(SvNVX(pname[ix])),
3904                           SvIVX(pname[ix]));
3905     }
3906 }
3907 #endif /* DEBUG_CLOSURES */
3908
3909 STATIC CV *
3910 S_cv_clone2(pTHX_ CV *proto, CV *outside)
3911 {
3912     dTHR;
3913     AV* av;
3914     I32 ix;
3915     AV* protopadlist = CvPADLIST(proto);
3916     AV* protopad_name = (AV*)*av_fetch(protopadlist, 0, FALSE);
3917     AV* protopad = (AV*)*av_fetch(protopadlist, 1, FALSE);
3918     SV** pname = AvARRAY(protopad_name);
3919     SV** ppad = AvARRAY(protopad);
3920     I32 fname = AvFILLp(protopad_name);
3921     I32 fpad = AvFILLp(protopad);
3922     AV* comppadlist;
3923     CV* cv;
3924
3925     assert(!CvUNIQUE(proto));
3926
3927     ENTER;
3928     SAVESPTR(PL_curpad);
3929     SAVESPTR(PL_comppad);
3930     SAVESPTR(PL_comppad_name);
3931     SAVESPTR(PL_compcv);
3932
3933     cv = PL_compcv = (CV*)NEWSV(1104,0);
3934     sv_upgrade((SV *)cv, SvTYPE(proto));
3935     CvCLONED_on(cv);
3936     if (CvANON(proto))
3937         CvANON_on(cv);
3938
3939 #ifdef USE_THREADS
3940     New(666, CvMUTEXP(cv), 1, perl_mutex);
3941     MUTEX_INIT(CvMUTEXP(cv));
3942     CvOWNER(cv)         = 0;
3943 #endif /* USE_THREADS */
3944     CvFILEGV(cv)        = CvFILEGV(proto);
3945     CvGV(cv)            = (GV*)SvREFCNT_inc(CvGV(proto));
3946     CvSTASH(cv)         = CvSTASH(proto);
3947     CvROOT(cv)          = CvROOT(proto);
3948     CvSTART(cv)         = CvSTART(proto);
3949     if (outside)
3950         CvOUTSIDE(cv)   = (CV*)SvREFCNT_inc(outside);
3951
3952     if (SvPOK(proto))
3953         sv_setpvn((SV*)cv, SvPVX(proto), SvCUR(proto));
3954
3955     PL_comppad_name = newAV();
3956     for (ix = fname; ix >= 0; ix--)
3957         av_store(PL_comppad_name, ix, SvREFCNT_inc(pname[ix]));
3958
3959     PL_comppad = newAV();
3960
3961     comppadlist = newAV();
3962     AvREAL_off(comppadlist);
3963     av_store(comppadlist, 0, (SV*)PL_comppad_name);
3964     av_store(comppadlist, 1, (SV*)PL_comppad);
3965     CvPADLIST(cv) = comppadlist;
3966     av_fill(PL_comppad, AvFILLp(protopad));
3967     PL_curpad = AvARRAY(PL_comppad);
3968
3969     av = newAV();           /* will be @_ */
3970     av_extend(av, 0);
3971     av_store(PL_comppad, 0, (SV*)av);
3972     AvFLAGS(av) = AVf_REIFY;
3973
3974     for (ix = fpad; ix > 0; ix--) {
3975         SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
3976         if (namesv && namesv != &PL_sv_undef) {
3977             char *name = SvPVX(namesv);    /* XXX */
3978             if (SvFLAGS(namesv) & SVf_FAKE) {   /* lexical from outside? */
3979                 I32 off = pad_findlex(name, ix, SvIVX(namesv),
3980                                       CvOUTSIDE(cv), cxstack_ix, 0, 0);
3981                 if (!off)
3982                     PL_curpad[ix] = SvREFCNT_inc(ppad[ix]);
3983                 else if (off != ix)
3984                     Perl_croak(aTHX_ "panic: cv_clone: %s", name);
3985             }
3986             else {                              /* our own lexical */
3987                 SV* sv;
3988                 if (*name == '&') {
3989                     /* anon code -- we'll come back for it */
3990                     sv = SvREFCNT_inc(ppad[ix]);
3991                 }
3992                 else if (*name == '@')
3993                     sv = (SV*)newAV();
3994                 else if (*name == '%')
3995                     sv = (SV*)newHV();
3996                 else
3997                     sv = NEWSV(0,0);
3998                 if (!SvPADBUSY(sv))
3999                     SvPADMY_on(sv);
4000                 PL_curpad[ix] = sv;
4001             }
4002         }
4003         else {
4004             SV* sv = NEWSV(0,0);
4005             SvPADTMP_on(sv);
4006             PL_curpad[ix] = sv;
4007         }
4008     }
4009
4010     /* Now that vars are all in place, clone nested closures. */
4011
4012     for (ix = fpad; ix > 0; ix--) {
4013         SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
4014         if (namesv
4015             && namesv != &PL_sv_undef
4016             && !(SvFLAGS(namesv) & SVf_FAKE)
4017             && *SvPVX(namesv) == '&'
4018             && CvCLONE(ppad[ix]))
4019         {
4020             CV *kid = cv_clone2((CV*)ppad[ix], cv);
4021             SvREFCNT_dec(ppad[ix]);
4022             CvCLONE_on(kid);
4023             SvPADMY_on(kid);
4024             PL_curpad[ix] = (SV*)kid;
4025         }
4026     }
4027
4028 #ifdef DEBUG_CLOSURES
4029     PerlIO_printf(Perl_debug_log, "Cloned inside:\n");
4030     cv_dump(outside);
4031     PerlIO_printf(Perl_debug_log, "  from:\n");
4032     cv_dump(proto);
4033     PerlIO_printf(Perl_debug_log, "   to:\n");
4034     cv_dump(cv);
4035 #endif
4036
4037     LEAVE;
4038     return cv;
4039 }
4040
4041 CV *
4042 Perl_cv_clone(pTHX_ CV *proto)
4043 {
4044     CV *cv;
4045     MUTEX_LOCK(&PL_cred_mutex);         /* XXX create separate mutex */
4046     cv = cv_clone2(proto, CvOUTSIDE(proto));
4047     MUTEX_UNLOCK(&PL_cred_mutex);       /* XXX create separate mutex */
4048     return cv;
4049 }
4050
4051 void
4052 Perl_cv_ckproto(pTHX_ CV *cv, GV *gv, char *p)
4053 {
4054     dTHR;
4055
4056     if (((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX(cv)))) && ckWARN_d(WARN_UNSAFE)) {
4057         SV* msg = sv_newmortal();
4058         SV* name = Nullsv;
4059
4060         if (gv)
4061             gv_efullname3(name = sv_newmortal(), gv, Nullch);
4062         sv_setpv(msg, "Prototype mismatch:");
4063         if (name)
4064             Perl_sv_catpvf(aTHX_ msg, " sub %_", name);
4065         if (SvPOK(cv))
4066             Perl_sv_catpvf(aTHX_ msg, " (%s)", SvPVX(cv));
4067         sv_catpv(msg, " vs ");
4068         if (p)
4069             Perl_sv_catpvf(aTHX_ msg, "(%s)", p);
4070         else
4071             sv_catpv(msg, "none");
4072         Perl_warner(aTHX_ WARN_UNSAFE, "%_", msg);
4073     }
4074 }
4075
4076 SV *
4077 Perl_cv_const_sv(pTHX_ CV *cv)
4078 {
4079     if (!cv || !SvPOK(cv) || SvCUR(cv))
4080         return Nullsv;
4081     return op_const_sv(CvSTART(cv), cv);
4082 }
4083
4084 SV *
4085 Perl_op_const_sv(pTHX_ OP *o, CV *cv)
4086 {
4087     SV *sv = Nullsv;
4088
4089     if(!o)
4090         return Nullsv;
4091
4092     if(o->op_type == OP_LINESEQ && cLISTOPo->op_first)
4093         o = cLISTOPo->op_first->op_sibling;
4094
4095     for (; o; o = o->op_next) {
4096         OPCODE type = o->op_type;
4097
4098         if (sv && o->op_next == o)
4099             return sv;
4100         if (type == OP_NEXTSTATE || type == OP_NULL || type == OP_PUSHMARK)
4101             continue;
4102         if (type == OP_LEAVESUB || type == OP_RETURN)
4103             break;
4104         if (sv)
4105             return Nullsv;
4106         if (type == OP_CONST)
4107             sv = cSVOPo->op_sv;
4108         else if (type == OP_PADSV && cv) {
4109             AV* padav = (AV*)(AvARRAY(CvPADLIST(cv))[1]);
4110             sv = padav ? AvARRAY(padav)[o->op_targ] : Nullsv;
4111             if (!sv || (!SvREADONLY(sv) && SvREFCNT(sv) > 1))
4112                 return Nullsv;
4113         }
4114         else
4115             return Nullsv;
4116     }
4117     if (sv)
4118         SvREADONLY_on(sv);
4119     return sv;
4120 }
4121
4122 void
4123 Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
4124 {
4125     if (o)
4126         SAVEFREEOP(o);
4127     if (proto)
4128         SAVEFREEOP(proto);
4129     if (attrs)
4130         SAVEFREEOP(attrs);
4131     if (block)
4132         SAVEFREEOP(block);
4133     Perl_croak(aTHX_ "\"my sub\" not yet implemented");
4134 }
4135
4136 CV *
4137 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
4138 {
4139     return Perl_newATTRSUB(aTHX_ floor, o, proto, Nullop, block);
4140 }
4141
4142 CV *
4143 Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
4144 {
4145     dTHR;
4146     STRLEN n_a;
4147     char *name = o ? SvPVx(cSVOPo->op_sv, n_a) : Nullch;
4148     GV *gv = gv_fetchpv(name ? name : "__ANON__",
4149                         GV_ADDMULTI | ((block || attrs) ? 0 : GV_NOINIT),
4150                         SVt_PVCV);
4151     char *ps = proto ? SvPVx(((SVOP*)proto)->op_sv, n_a) : Nullch;
4152     register CV *cv=0;
4153     I32 ix;
4154
4155     if (o)
4156         SAVEFREEOP(o);
4157     if (proto)
4158         SAVEFREEOP(proto);
4159     if (attrs)
4160         SAVEFREEOP(attrs);
4161
4162     if (SvTYPE(gv) != SVt_PVGV) {       /* Maybe prototype now, and had at
4163                                            maximum a prototype before. */
4164         if (SvTYPE(gv) > SVt_NULL) {
4165             if (!SvPOK((SV*)gv) && !(SvIOK((SV*)gv) && SvIVX((SV*)gv) == -1)
4166                 && ckWARN_d(WARN_UNSAFE))
4167             {
4168                 Perl_warner(aTHX_ WARN_UNSAFE, "Runaway prototype");
4169             }
4170             cv_ckproto((CV*)gv, NULL, ps);
4171         }
4172         if (ps)
4173             sv_setpv((SV*)gv, ps);
4174         else
4175             sv_setiv((SV*)gv, -1);
4176         SvREFCNT_dec(PL_compcv);
4177         cv = PL_compcv = NULL;
4178         PL_sub_generation++;
4179         goto noblock;
4180     }
4181
4182     if (!name || GvCVGEN(gv))
4183         cv = Nullcv;
4184     else if (cv = GvCV(gv)) {
4185         cv_ckproto(cv, gv, ps);
4186         /* already defined (or promised)? */
4187         if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
4188             SV* const_sv;
4189             bool const_changed = TRUE;
4190             if (!block && !attrs) {
4191                 /* just a "sub foo;" when &foo is already defined */
4192                 SAVEFREESV(PL_compcv);
4193                 goto done;
4194             }
4195             /* ahem, death to those who redefine active sort subs */
4196             if (PL_curstackinfo->si_type == PERLSI_SORT && PL_sortcop == CvSTART(cv))
4197                 Perl_croak(aTHX_ "Can't redefine active sort subroutine %s", name);
4198             if (!block)
4199                 goto withattrs;
4200             if(const_sv = cv_const_sv(cv))
4201                 const_changed = sv_cmp(const_sv, op_const_sv(block, Nullcv));
4202             if ((const_sv && const_changed) || ckWARN(WARN_REDEFINE)
4203                                         && !(CvGV(cv) && GvSTASH(CvGV(cv))
4204                                         && HvNAME(GvSTASH(CvGV(cv)))
4205                                         && strEQ(HvNAME(GvSTASH(CvGV(cv))),
4206                                                  "autouse"))) {
4207                 line_t oldline = PL_curcop->cop_line;
4208                 PL_curcop->cop_line = PL_copline;
4209                 Perl_warner(aTHX_ WARN_REDEFINE,
4210                         const_sv ? "Constant subroutine %s redefined"
4211                                  : "Subroutine %s redefined", name);
4212                 PL_curcop->cop_line = oldline;
4213             }
4214             SvREFCNT_dec(cv);
4215             cv = Nullcv;
4216         }
4217     }
4218   withattrs:
4219     if (attrs) {
4220         HV *stash;
4221         SV *rcv;
4222
4223         /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>
4224          * before we clobber PL_compcv.
4225          */
4226         if (cv && !block) {
4227             rcv = (SV*)cv;
4228             if (CvGV(cv) && GvSTASH(CvGV(cv)) && HvNAME(GvSTASH(CvGV(cv))))
4229                 stash = GvSTASH(CvGV(cv));
4230             else if (CvSTASH(cv) && HvNAME(CvSTASH(cv)))
4231                 stash = CvSTASH(cv);
4232             else
4233                 stash = PL_curstash;
4234         }
4235         else {
4236             /* possibly about to re-define existing subr -- ignore old cv */
4237             rcv = (SV*)PL_compcv;
4238             if (name && GvSTASH(gv) && HvNAME(GvSTASH(gv)))
4239                 stash = GvSTASH(gv);
4240             else
4241                 stash = PL_curstash;
4242         }
4243         apply_attrs(stash, rcv, attrs);
4244     }
4245     if (cv) {                           /* must reuse cv if autoloaded */
4246         if (!block) {
4247             /* got here with just attrs -- work done, so bug out */
4248             SAVEFREESV(PL_compcv);
4249             goto done;
4250         }
4251         cv_undef(cv);
4252         CvFLAGS(cv) = CvFLAGS(PL_compcv);
4253         CvOUTSIDE(cv) = CvOUTSIDE(PL_compcv);
4254         CvOUTSIDE(PL_compcv) = 0;
4255         CvPADLIST(cv) = CvPADLIST(PL_compcv);
4256         CvPADLIST(PL_compcv) = 0;
4257         if (SvREFCNT(PL_compcv) > 1) /* XXX Make closures transit through stub. */
4258             CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc((SV*)cv);
4259         SvREFCNT_dec(PL_compcv);
4260     }
4261     else {
4262         cv = PL_compcv;
4263         if (name) {
4264             GvCV(gv) = cv;
4265             GvCVGEN(gv) = 0;
4266             PL_sub_generation++;
4267         }
4268     }
4269     CvGV(cv) = (GV*)SvREFCNT_inc(gv);
4270     CvFILEGV(cv) = PL_curcop->cop_filegv;
4271     CvSTASH(cv) = PL_curstash;
4272 #ifdef USE_THREADS
4273     CvOWNER(cv) = 0;
4274     if (!CvMUTEXP(cv)) {
4275         New(666, CvMUTEXP(cv), 1, perl_mutex);
4276         MUTEX_INIT(CvMUTEXP(cv));
4277     }
4278 #endif /* USE_THREADS */
4279
4280     if (ps)
4281         sv_setpv((SV*)cv, ps);
4282
4283     if (PL_error_count) {
4284         op_free(block);
4285         block = Nullop;
4286         if (name) {
4287             char *s = strrchr(name, ':');
4288             s = s ? s+1 : name;
4289             if (strEQ(s, "BEGIN")) {
4290                 char *not_safe =
4291                     "BEGIN not safe after errors--compilation aborted";
4292                 if (PL_in_eval & EVAL_KEEPERR)
4293                     Perl_croak(aTHX_ not_safe);
4294                 else {
4295                     /* force display of errors found but not reported */
4296                     sv_catpv(ERRSV, not_safe);
4297                     Perl_croak(aTHX_ "%s", SvPVx(ERRSV, n_a));
4298                 }
4299             }
4300         }
4301     }
4302     if (!block) {
4303       noblock:
4304         PL_copline = NOLINE;
4305         LEAVE_SCOPE(floor);
4306         return cv;
4307     }
4308
4309     if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad))
4310         av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv);
4311
4312     if (CvCLONE(cv)) {
4313         SV **namep = AvARRAY(PL_comppad_name);
4314         for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4315             SV *namesv;
4316
4317             if (SvIMMORTAL(PL_curpad[ix]))
4318                 continue;
4319             /*
4320              * The only things that a clonable function needs in its
4321              * pad are references to outer lexicals and anonymous subs.
4322              * The rest are created anew during cloning.
4323              */
4324             if (!((namesv = namep[ix]) != Nullsv &&
4325                   namesv != &PL_sv_undef &&
4326                   (SvFAKE(namesv) ||
4327                    *SvPVX(namesv) == '&')))
4328             {
4329                 SvREFCNT_dec(PL_curpad[ix]);
4330                 PL_curpad[ix] = Nullsv;
4331             }
4332         }
4333     }
4334     else {
4335         AV *av = newAV();                       /* Will be @_ */
4336         av_extend(av, 0);
4337         av_store(PL_comppad, 0, (SV*)av);
4338         AvFLAGS(av) = AVf_REIFY;
4339
4340         for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4341             if (SvIMMORTAL(PL_curpad[ix]))
4342                 continue;
4343             if (!SvPADMY(PL_curpad[ix]))
4344                 SvPADTMP_on(PL_curpad[ix]);
4345         }
4346     }
4347
4348     if (CvLVALUE(cv)) {
4349         CvROOT(cv) = newUNOP(OP_LEAVESUBLV, 0, scalarseq(block));
4350     }
4351     else {
4352         CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
4353     }
4354     CvROOT(cv)->op_private |= OPpREFCOUNTED;
4355     OpREFCNT_set(CvROOT(cv), 1);
4356     CvSTART(cv) = LINKLIST(CvROOT(cv));
4357     CvROOT(cv)->op_next = 0;
4358     peep(CvSTART(cv));
4359
4360     if (name) {
4361         char *s;
4362
4363         if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
4364             SV *sv = NEWSV(0,0);
4365             SV *tmpstr = sv_newmortal();
4366             GV *db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
4367             CV *cv;
4368             HV *hv;
4369
4370             Perl_sv_setpvf(aTHX_ sv, "%_:%ld-%ld",
4371                     GvSV(PL_curcop->cop_filegv),
4372                     (long)PL_subline, (long)PL_curcop->cop_line);
4373             gv_efullname3(tmpstr, gv, Nullch);
4374             hv_store(GvHV(PL_DBsub), SvPVX(tmpstr), SvCUR(tmpstr), sv, 0);
4375             hv = GvHVn(db_postponed);
4376             if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX(tmpstr), SvCUR(tmpstr))
4377                   && (cv = GvCV(db_postponed))) {
4378                 dSP;
4379                 PUSHMARK(SP);
4380                 XPUSHs(tmpstr);
4381                 PUTBACK;
4382                 call_sv((SV*)cv, G_DISCARD);
4383             }
4384         }
4385
4386         if ((s = strrchr(name,':')))
4387             s++;
4388         else
4389             s = name;
4390         if (strEQ(s, "BEGIN")) {
4391             I32 oldscope = PL_scopestack_ix;
4392             ENTER;
4393             SAVESPTR(PL_compiling.cop_filegv);
4394             SAVEI16(PL_compiling.cop_line);
4395             save_svref(&PL_rs);
4396             sv_setsv(PL_rs, PL_nrs);
4397
4398             if (!PL_beginav)
4399                 PL_beginav = newAV();
4400             DEBUG_x( dump_sub(gv) );
4401             av_push(PL_beginav, (SV *)cv);
4402             GvCV(gv) = 0;
4403             call_list(oldscope, PL_beginav);
4404
4405             PL_curcop = &PL_compiling;
4406             PL_compiling.op_private = PL_hints;
4407             LEAVE;
4408         }
4409         else if (strEQ(s, "END") && !PL_error_count) {
4410             if (!PL_endav)
4411                 PL_endav = newAV();
4412             av_unshift(PL_endav, 1);
4413             av_store(PL_endav, 0, (SV *)cv);
4414             GvCV(gv) = 0;
4415         }
4416         else if (strEQ(s, "INIT") && !PL_error_count) {
4417             if (!PL_initav)
4418                 PL_initav = newAV();
4419             av_push(PL_initav, SvREFCNT_inc(cv));
4420             GvCV(gv) = 0;
4421         }
4422     }
4423
4424   done:
4425     PL_copline = NOLINE;
4426     LEAVE_SCOPE(floor);
4427     return cv;
4428 }
4429
4430 /* XXX unsafe for threads if eval_owner isn't held */
4431 void
4432 Perl_newCONSTSUB(pTHX_ HV *stash, char *name, SV *sv)
4433 {
4434     dTHR;
4435     U32 oldhints = PL_hints;
4436     HV *old_cop_stash = PL_curcop->cop_stash;
4437     HV *old_curstash = PL_curstash;
4438     line_t oldline = PL_curcop->cop_line;
4439     PL_curcop->cop_line = PL_copline;
4440
4441     PL_hints &= ~HINT_BLOCK_SCOPE;
4442     if(stash)
4443         PL_curstash = PL_curcop->cop_stash = stash;
4444
4445     newATTRSUB(
4446         start_subparse(FALSE, 0),
4447         newSVOP(OP_CONST, 0, newSVpv(name,0)),
4448         newSVOP(OP_CONST, 0, &PL_sv_no),        /* SvPV(&PL_sv_no) == "" -- GMB */
4449         Nullop,
4450         newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4451     );
4452
4453     PL_hints = oldhints;
4454     PL_curcop->cop_stash = old_cop_stash;
4455     PL_curstash = old_curstash;
4456     PL_curcop->cop_line = oldline;
4457 }
4458
4459 CV *
4460 Perl_newXS(pTHX_ char *name, XSUBADDR_t subaddr, char *filename)
4461 {
4462     dTHR;
4463     GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI, SVt_PVCV);
4464     register CV *cv;
4465
4466     if (cv = (name ? GvCV(gv) : Nullcv)) {
4467         if (GvCVGEN(gv)) {
4468             /* just a cached method */
4469             SvREFCNT_dec(cv);
4470             cv = 0;
4471         }
4472         else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
4473             /* already defined (or promised) */
4474             if (ckWARN(WARN_REDEFINE) && !(CvGV(cv) && GvSTASH(CvGV(cv))
4475                             && HvNAME(GvSTASH(CvGV(cv)))
4476                             && strEQ(HvNAME(GvSTASH(CvGV(cv))), "autouse"))) {
4477                 line_t oldline = PL_curcop->cop_line;
4478                 if (PL_copline != NOLINE)
4479                     PL_curcop->cop_line = PL_copline;
4480                 Perl_warner(aTHX_ WARN_REDEFINE, "Subroutine %s redefined",name);
4481                 PL_curcop->cop_line = oldline;
4482             }
4483             SvREFCNT_dec(cv);
4484             cv = 0;
4485         }
4486     }
4487
4488     if (cv)                             /* must reuse cv if autoloaded */
4489         cv_undef(cv);
4490     else {
4491         cv = (CV*)NEWSV(1105,0);
4492         sv_upgrade((SV *)cv, SVt_PVCV);
4493         if (name) {
4494             GvCV(gv) = cv;
4495             GvCVGEN(gv) = 0;
4496             PL_sub_generation++;
4497         }
4498     }
4499     CvGV(cv) = (GV*)SvREFCNT_inc(gv);
4500 #ifdef USE_THREADS
4501     New(666, CvMUTEXP(cv), 1, perl_mutex);
4502     MUTEX_INIT(CvMUTEXP(cv));
4503     CvOWNER(cv) = 0;
4504 #endif /* USE_THREADS */
4505     CvFILEGV(cv) = gv_fetchfile(filename);
4506     CvXSUB(cv) = subaddr;
4507
4508     if (name) {
4509         char *s = strrchr(name,':');
4510         if (s)
4511             s++;
4512         else
4513             s = name;
4514         if (strEQ(s, "BEGIN")) {
4515             if (!PL_beginav)
4516                 PL_beginav = newAV();
4517             av_push(PL_beginav, (SV *)cv);
4518             GvCV(gv) = 0;
4519         }
4520         else if (strEQ(s, "END")) {
4521             if (!PL_endav)
4522                 PL_endav = newAV();
4523             av_unshift(PL_endav, 1);
4524             av_store(PL_endav, 0, (SV *)cv);
4525             GvCV(gv) = 0;
4526         }
4527         else if (strEQ(s, "INIT")) {
4528             if (!PL_initav)
4529                 PL_initav = newAV();
4530             av_push(PL_initav, (SV *)cv);
4531             GvCV(gv) = 0;
4532         }
4533     }
4534     else
4535         CvANON_on(cv);
4536
4537     return cv;
4538 }
4539
4540 void
4541 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
4542 {
4543     dTHR;
4544     register CV *cv;
4545     char *name;
4546     GV *gv;
4547     I32 ix;
4548     STRLEN n_a;
4549
4550     if (o)
4551         name = SvPVx(cSVOPo->op_sv, n_a);
4552     else
4553         name = "STDOUT";
4554     gv = gv_fetchpv(name,TRUE, SVt_PVFM);
4555     GvMULTI_on(gv);
4556     if (cv = GvFORM(gv)) {
4557         if (ckWARN(WARN_REDEFINE)) {
4558             line_t oldline = PL_curcop->cop_line;
4559
4560             PL_curcop->cop_line = PL_copline;
4561             Perl_warner(aTHX_ WARN_REDEFINE, "Format %s redefined",name);
4562             PL_curcop->cop_line = oldline;
4563         }
4564         SvREFCNT_dec(cv);
4565     }
4566     cv = PL_compcv;
4567     GvFORM(gv) = cv;
4568     CvGV(cv) = (GV*)SvREFCNT_inc(gv);
4569     CvFILEGV(cv) = PL_curcop->cop_filegv;
4570
4571     for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4572         if (!SvPADMY(PL_curpad[ix]) && !SvIMMORTAL(PL_curpad[ix]))
4573             SvPADTMP_on(PL_curpad[ix]);
4574     }
4575
4576     CvROOT(cv) = newUNOP(OP_LEAVEWRITE, 0, scalarseq(block));
4577     CvROOT(cv)->op_private |= OPpREFCOUNTED;
4578     OpREFCNT_set(CvROOT(cv), 1);
4579     CvSTART(cv) = LINKLIST(CvROOT(cv));
4580     CvROOT(cv)->op_next = 0;
4581     peep(CvSTART(cv));
4582     op_free(o);
4583     PL_copline = NOLINE;
4584     LEAVE_SCOPE(floor);
4585 }
4586
4587 OP *
4588 Perl_newANONLIST(pTHX_ OP *o)
4589 {
4590     return newUNOP(OP_REFGEN, 0,
4591         mod(list(convert(OP_ANONLIST, 0, o)), OP_REFGEN));
4592 }
4593
4594 OP *
4595 Perl_newANONHASH(pTHX_ OP *o)
4596 {
4597     return newUNOP(OP_REFGEN, 0,
4598         mod(list(convert(OP_ANONHASH, 0, o)), OP_REFGEN));
4599 }
4600
4601 OP *
4602 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
4603 {
4604     return newANONATTRSUB(floor, proto, Nullop, block);
4605 }
4606
4607 OP *
4608 Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block)
4609 {
4610     return newUNOP(OP_REFGEN, 0,
4611         newSVOP(OP_ANONCODE, 0,
4612                 (SV*)newATTRSUB(floor, 0, proto, attrs, block)));
4613 }
4614
4615 OP *
4616 Perl_oopsAV(pTHX_ OP *o)
4617 {
4618     switch (o->op_type) {
4619     case OP_PADSV:
4620         o->op_type = OP_PADAV;
4621         o->op_ppaddr = PL_ppaddr[OP_PADAV];
4622         return ref(o, OP_RV2AV);
4623
4624     case OP_RV2SV:
4625         o->op_type = OP_RV2AV;
4626         o->op_ppaddr = PL_ppaddr[OP_RV2AV];
4627         ref(o, OP_RV2AV);
4628         break;
4629
4630     default:
4631         if (ckWARN_d(WARN_INTERNAL))
4632             Perl_warner(aTHX_ WARN_INTERNAL, "oops: oopsAV");
4633         break;
4634     }
4635     return o;
4636 }
4637
4638 OP *
4639 Perl_oopsHV(pTHX_ OP *o)
4640 {
4641     dTHR;
4642
4643     switch (o->op_type) {
4644     case OP_PADSV:
4645     case OP_PADAV:
4646         o->op_type = OP_PADHV;
4647         o->op_ppaddr = PL_ppaddr[OP_PADHV];
4648         return ref(o, OP_RV2HV);
4649
4650     case OP_RV2SV:
4651     case OP_RV2AV:
4652         o->op_type = OP_RV2HV;
4653         o->op_ppaddr = PL_ppaddr[OP_RV2HV];
4654         ref(o, OP_RV2HV);
4655         break;
4656
4657     default:
4658         if (ckWARN_d(WARN_INTERNAL))
4659             Perl_warner(aTHX_ WARN_INTERNAL, "oops: oopsHV");
4660         break;
4661     }
4662     return o;
4663 }
4664
4665 OP *
4666 Perl_newAVREF(pTHX_ OP *o)
4667 {
4668     if (o->op_type == OP_PADANY) {
4669         o->op_type = OP_PADAV;
4670         o->op_ppaddr = PL_ppaddr[OP_PADAV];
4671         return o;
4672     }
4673     return newUNOP(OP_RV2AV, 0, scalar(o));
4674 }
4675
4676 OP *
4677 Perl_newGVREF(pTHX_ I32 type, OP *o)
4678 {
4679     if (type == OP_MAPSTART || type == OP_GREPSTART || type == OP_SORT)
4680         return newUNOP(OP_NULL, 0, o);
4681     return ref(newUNOP(OP_RV2GV, OPf_REF, o), type);
4682 }
4683
4684 OP *
4685 Perl_newHVREF(pTHX_ OP *o)
4686 {
4687     if (o->op_type == OP_PADANY) {
4688         o->op_type = OP_PADHV;
4689         o->op_ppaddr = PL_ppaddr[OP_PADHV];
4690         return o;
4691     }
4692     return newUNOP(OP_RV2HV, 0, scalar(o));
4693 }
4694
4695 OP *
4696 Perl_oopsCV(pTHX_ OP *o)
4697 {
4698     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
4699     /* STUB */
4700     return o;
4701 }
4702
4703 OP *
4704 Perl_newCVREF(pTHX_ I32 flags, OP *o)
4705 {
4706     return newUNOP(OP_RV2CV, flags, scalar(o));
4707 }
4708
4709 OP *
4710 Perl_newSVREF(pTHX_ OP *o)
4711 {
4712     if (o->op_type == OP_PADANY) {
4713         o->op_type = OP_PADSV;
4714         o->op_ppaddr = PL_ppaddr[OP_PADSV];
4715         return o;
4716     }
4717     else if (o->op_type == OP_THREADSV && !(o->op_flags & OPpDONE_SVREF)) {
4718         o->op_flags |= OPpDONE_SVREF;
4719         return o;
4720     }
4721     return newUNOP(OP_RV2SV, 0, scalar(o));
4722 }
4723
4724 /* Check routines. */
4725
4726 OP *
4727 Perl_ck_anoncode(pTHX_ OP *o)
4728 {
4729     PADOFFSET ix;
4730     SV* name;
4731
4732     name = NEWSV(1106,0);
4733     sv_upgrade(name, SVt_PVNV);
4734     sv_setpvn(name, "&", 1);
4735     SvIVX(name) = -1;
4736     SvNVX(name) = 1;
4737     ix = pad_alloc(o->op_type, SVs_PADMY);
4738     av_store(PL_comppad_name, ix, name);
4739     av_store(PL_comppad, ix, cSVOPo->op_sv);
4740     SvPADMY_on(cSVOPo->op_sv);
4741     cSVOPo->op_sv = Nullsv;
4742     cSVOPo->op_targ = ix;
4743     return o;
4744 }
4745
4746 OP *
4747 Perl_ck_bitop(pTHX_ OP *o)
4748 {
4749     o->op_private = PL_hints;
4750     return o;
4751 }
4752
4753 OP *
4754 Perl_ck_concat(pTHX_ OP *o)
4755 {
4756     if (cUNOPo->op_first->op_type == OP_CONCAT)
4757         o->op_flags |= OPf_STACKED;
4758     return o;
4759 }
4760
4761 OP *
4762 Perl_ck_spair(pTHX_ OP *o)
4763 {
4764     if (o->op_flags & OPf_KIDS) {
4765         OP* newop;
4766         OP* kid;
4767         OPCODE type = o->op_type;
4768         o = modkids(ck_fun(o), type);
4769         kid = cUNOPo->op_first;
4770         newop = kUNOP->op_first->op_sibling;
4771         if (newop &&
4772             (newop->op_sibling ||
4773              !(PL_opargs[newop->op_type] & OA_RETSCALAR) ||
4774              newop->op_type == OP_PADAV || newop->op_type == OP_PADHV ||
4775              newop->op_type == OP_RV2AV || newop->op_type == OP_RV2HV)) {
4776
4777             return o;
4778         }
4779         op_free(kUNOP->op_first);
4780         kUNOP->op_first = newop;
4781     }
4782     o->op_ppaddr = PL_ppaddr[++o->op_type];
4783     return ck_fun(o);
4784 }
4785
4786 OP *
4787 Perl_ck_delete(pTHX_ OP *o)
4788 {
4789     o = ck_fun(o);
4790     o->op_private = 0;
4791     if (o->op_flags & OPf_KIDS) {
4792         OP *kid = cUNOPo->op_first;
4793         if (kid->op_type == OP_HSLICE)
4794             o->op_private |= OPpSLICE;
4795         else if (kid->op_type != OP_HELEM)
4796             Perl_croak(aTHX_ "%s argument is not a HASH element or slice",
4797                   PL_op_desc[o->op_type]);
4798         null(kid);
4799     }
4800     return o;
4801 }
4802
4803 OP *
4804 Perl_ck_eof(pTHX_ OP *o)
4805 {
4806     I32 type = o->op_type;
4807
4808     if (o->op_flags & OPf_KIDS) {
4809         if (cLISTOPo->op_first->op_type == OP_STUB) {
4810             op_free(o);
4811             o = newUNOP(type, OPf_SPECIAL,
4812                 newGVOP(OP_GV, 0, gv_fetchpv("main::ARGV", TRUE, SVt_PVAV)));
4813         }
4814         return ck_fun(o);
4815     }
4816     return o;
4817 }
4818
4819 OP *
4820 Perl_ck_eval(pTHX_ OP *o)
4821 {
4822     PL_hints |= HINT_BLOCK_SCOPE;
4823     if (o->op_flags & OPf_KIDS) {
4824         SVOP *kid = (SVOP*)cUNOPo->op_first;
4825
4826         if (!kid) {
4827             o->op_flags &= ~OPf_KIDS;
4828             null(o);
4829         }
4830         else if (kid->op_type == OP_LINESEQ) {
4831             LOGOP *enter;
4832
4833             kid->op_next = o->op_next;
4834             cUNOPo->op_first = 0;
4835             op_free(o);
4836
4837             NewOp(1101, enter, 1, LOGOP);
4838             enter->op_type = OP_ENTERTRY;
4839             enter->op_ppaddr = PL_ppaddr[OP_ENTERTRY];
4840             enter->op_private = 0;
4841
4842             /* establish postfix order */
4843             enter->op_next = (OP*)enter;
4844
4845             o = prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
4846             o->op_type = OP_LEAVETRY;
4847             o->op_ppaddr = PL_ppaddr[OP_LEAVETRY];
4848             enter->op_other = o;
4849             return o;
4850         }
4851         else
4852             scalar((OP*)kid);
4853     }
4854     else {
4855         op_free(o);
4856         o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP());
4857     }
4858     o->op_targ = (PADOFFSET)PL_hints;
4859     return o;
4860 }
4861
4862 OP *
4863 Perl_ck_exec(pTHX_ OP *o)
4864 {
4865     OP *kid;
4866     if (o->op_flags & OPf_STACKED) {
4867         o = ck_fun(o);
4868         kid = cUNOPo->op_first->op_sibling;
4869         if (kid->op_type == OP_RV2GV)
4870             null(kid);
4871     }
4872     else
4873         o = listkids(o);
4874     return o;
4875 }
4876
4877 OP *
4878 Perl_ck_exists(pTHX_ OP *o)
4879 {
4880     o = ck_fun(o);
4881     if (o->op_flags & OPf_KIDS) {
4882         OP *kid = cUNOPo->op_first;
4883         if (kid->op_type != OP_HELEM)
4884             Perl_croak(aTHX_ "%s argument is not a HASH element", PL_op_desc[o->op_type]);
4885         null(kid);
4886     }
4887     return o;
4888 }
4889
4890 #if 0
4891 OP *
4892 Perl_ck_gvconst(pTHX_ register OP *o)
4893 {
4894     o = fold_constants(o);
4895     if (o->op_type == OP_CONST)
4896         o->op_type = OP_GV;
4897     return o;
4898 }
4899 #endif
4900
4901 OP *
4902 Perl_ck_rvconst(pTHX_ register OP *o)
4903 {
4904     dTHR;
4905     SVOP *kid = (SVOP*)cUNOPo->op_first;
4906
4907     o->op_private |= (PL_hints & HINT_STRICT_REFS);
4908     if (kid->op_type == OP_CONST) {
4909         char *name;
4910         int iscv;
4911         GV *gv;
4912         SV *kidsv = kid->op_sv;
4913         STRLEN n_a;
4914
4915         /* Is it a constant from cv_const_sv()? */
4916         if (SvROK(kidsv) && SvREADONLY(kidsv)) {
4917             SV *rsv = SvRV(kidsv);
4918             int svtype = SvTYPE(rsv);
4919             char *badtype = Nullch;
4920
4921             switch (o->op_type) {
4922             case OP_RV2SV:
4923                 if (svtype > SVt_PVMG)
4924                     badtype = "a SCALAR";
4925                 break;
4926             case OP_RV2AV:
4927                 if (svtype != SVt_PVAV)
4928                     badtype = "an ARRAY";
4929                 break;
4930             case OP_RV2HV:
4931                 if (svtype != SVt_PVHV) {
4932                     if (svtype == SVt_PVAV) {   /* pseudohash? */
4933                         SV **ksv = av_fetch((AV*)rsv, 0, FALSE);
4934                         if (ksv && SvROK(*ksv)
4935                             && SvTYPE(SvRV(*ksv)) == SVt_PVHV)
4936                         {
4937                                 break;
4938                         }
4939                     }
4940                     badtype = "a HASH";
4941                 }
4942                 break;
4943             case OP_RV2CV:
4944                 if (svtype != SVt_PVCV)
4945                     badtype = "a CODE";
4946                 break;
4947             }
4948             if (badtype)
4949                 Perl_croak(aTHX_ "Constant is not %s reference", badtype);
4950             return o;
4951         }
4952         name = SvPV(kidsv, n_a);
4953         if ((PL_hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
4954             char *badthing = Nullch;
4955             switch (o->op_type) {
4956             case OP_RV2SV:
4957                 badthing = "a SCALAR";
4958                 break;
4959             case OP_RV2AV:
4960                 badthing = "an ARRAY";
4961                 break;
4962             case OP_RV2HV:
4963                 badthing = "a HASH";
4964                 break;
4965             }
4966             if (badthing)
4967                 Perl_croak(aTHX_
4968           "Can't use bareword (\"%s\") as %s ref while \"strict refs\" in use",
4969                       name, badthing);
4970         }
4971         /*
4972          * This is a little tricky.  We only want to add the symbol if we
4973          * didn't add it in the lexer.  Otherwise we get duplicate strict
4974          * warnings.  But if we didn't add it in the lexer, we must at
4975          * least pretend like we wanted to add it even if it existed before,
4976          * or we get possible typo warnings.  OPpCONST_ENTERED says
4977          * whether the lexer already added THIS instance of this symbol.
4978          */
4979         iscv = (o->op_type == OP_RV2CV) * 2;
4980         do {
4981             gv = gv_fetchpv(name,
4982                 iscv | !(kid->op_private & OPpCONST_ENTERED),
4983                 iscv
4984                     ? SVt_PVCV
4985                     : o->op_type == OP_RV2SV
4986                         ? SVt_PV
4987                         : o->op_type == OP_RV2AV
4988                             ? SVt_PVAV
4989                             : o->op_type == OP_RV2HV
4990                                 ? SVt_PVHV
4991                                 : SVt_PVGV);
4992         } while (!gv && !(kid->op_private & OPpCONST_ENTERED) && !iscv++);
4993         if (gv) {
4994             kid->op_type = OP_GV;
4995             SvREFCNT_dec(kid->op_sv);
4996             kid->op_sv = SvREFCNT_inc(gv);
4997             kid->op_ppaddr = PL_ppaddr[OP_GV];
4998         }
4999     }
5000     return o;
5001 }
5002
5003 OP *
5004 Perl_ck_ftst(pTHX_ OP *o)
5005 {
5006     dTHR;
5007     I32 type = o->op_type;
5008
5009     if (o->op_flags & OPf_REF)
5010         return o;
5011
5012     if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
5013         SVOP *kid = (SVOP*)cUNOPo->op_first;
5014
5015         if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
5016             STRLEN n_a;
5017             OP *newop = newGVOP(type, OPf_REF,
5018                 gv_fetchpv(SvPVx(kid->op_sv, n_a), TRUE, SVt_PVIO));
5019             op_free(o);
5020             return newop;
5021         }
5022     }
5023     else {
5024         op_free(o);
5025         if (type == OP_FTTTY)
5026            return newGVOP(type, OPf_REF, gv_fetchpv("main::STDIN", TRUE,
5027                                 SVt_PVIO));
5028         else
5029             return newUNOP(type, 0, newDEFSVOP());
5030     }
5031     return o;
5032 }
5033
5034 OP *
5035 Perl_ck_fun(pTHX_ OP *o)
5036 {
5037     dTHR;
5038     register OP *kid;
5039     OP **tokid;
5040     OP *sibl;
5041     I32 numargs = 0;
5042     int type = o->op_type;
5043     register I32 oa = PL_opargs[type] >> OASHIFT;
5044
5045     if (o->op_flags & OPf_STACKED) {
5046         if ((oa & OA_OPTIONAL) && (oa >> 4) && !((oa >> 4) & OA_OPTIONAL))
5047             oa &= ~OA_OPTIONAL;
5048         else
5049             return no_fh_allowed(o);
5050     }
5051
5052     if (o->op_flags & OPf_KIDS) {
5053         STRLEN n_a;
5054         tokid = &cLISTOPo->op_first;
5055         kid = cLISTOPo->op_first;
5056         if (kid->op_type == OP_PUSHMARK ||
5057             kid->op_type == OP_NULL && kid->op_targ == OP_PUSHMARK)
5058         {
5059             tokid = &kid->op_sibling;
5060             kid = kid->op_sibling;
5061         }
5062         if (!kid && PL_opargs[type] & OA_DEFGV)
5063             *tokid = kid = newDEFSVOP();
5064
5065         while (oa && kid) {
5066             numargs++;
5067             sibl = kid->op_sibling;
5068             switch (oa & 7) {
5069             case OA_SCALAR:
5070                 /* list seen where single (scalar) arg expected? */
5071                 if (numargs == 1 && !(oa >> 4)
5072                     && kid->op_type == OP_LIST && type != OP_SCALAR)
5073                 {
5074                     return too_many_arguments(o,PL_op_desc[type]);
5075                 }
5076                 scalar(kid);
5077                 break;
5078             case OA_LIST:
5079                 if (oa < 16) {
5080                     kid = 0;
5081                     continue;
5082                 }
5083                 else
5084                     list(kid);
5085                 break;
5086             case OA_AVREF:
5087                 if (kid->op_type == OP_CONST &&
5088                     (kid->op_private & OPpCONST_BARE))
5089                 {
5090                     char *name = SvPVx(((SVOP*)kid)->op_sv, n_a);
5091                     OP *newop = newAVREF(newGVOP(OP_GV, 0,
5092                         gv_fetchpv(name, TRUE, SVt_PVAV) ));
5093                     if (ckWARN(WARN_SYNTAX))
5094                         Perl_warner(aTHX_ WARN_SYNTAX,
5095                             "Array @%s missing the @ in argument %"IVdf" of %s()",
5096                             name, (IV)numargs, PL_op_desc[type]);
5097                     op_free(kid);
5098                     kid = newop;
5099                     kid->op_sibling = sibl;
5100                     *tokid = kid;
5101                 }
5102                 else if (kid->op_type != OP_RV2AV && kid->op_type != OP_PADAV)
5103                     bad_type(numargs, "array", PL_op_desc[type], kid);
5104                 mod(kid, type);
5105                 break;
5106             case OA_HVREF:
5107                 if (kid->op_type == OP_CONST &&
5108                     (kid->op_private & OPpCONST_BARE))
5109                 {
5110                     char *name = SvPVx(((SVOP*)kid)->op_sv, n_a);
5111                     OP *newop = newHVREF(newGVOP(OP_GV, 0,
5112                         gv_fetchpv(name, TRUE, SVt_PVHV) ));
5113                     if (ckWARN(WARN_SYNTAX))
5114                         Perl_warner(aTHX_ WARN_SYNTAX,
5115                             "Hash %%%s missing the %% in argument %"IVdf" of %s()",
5116                             name, (IV)numargs, PL_op_desc[type]);
5117                     op_free(kid);
5118                     kid = newop;
5119                     kid->op_sibling = sibl;
5120                     *tokid = kid;
5121                 }
5122                 else if (kid->op_type != OP_RV2HV && kid->op_type != OP_PADHV)
5123                     bad_type(numargs, "hash", PL_op_desc[type], kid);
5124                 mod(kid, type);
5125                 break;
5126             case OA_CVREF:
5127                 {
5128                     OP *newop = newUNOP(OP_NULL, 0, kid);
5129                     kid->op_sibling = 0;
5130                     linklist(kid);
5131                     newop->op_next = newop;
5132                     kid = newop;
5133                     kid->op_sibling = sibl;
5134                     *tokid = kid;
5135                 }
5136                 break;
5137             case OA_FILEREF:
5138                 if (kid->op_type != OP_GV && kid->op_type != OP_RV2GV) {
5139                     if (kid->op_type == OP_CONST &&
5140                         (kid->op_private & OPpCONST_BARE))
5141                     {
5142                         OP *newop = newGVOP(OP_GV, 0,
5143                             gv_fetchpv(SvPVx(((SVOP*)kid)->op_sv, n_a), TRUE,
5144                                         SVt_PVIO) );
5145                         op_free(kid);
5146                         kid = newop;
5147                     }
5148                     else if (kid->op_type == OP_READLINE) {
5149                         /* neophyte patrol: open(<FH>), close(<FH>) etc. */
5150                         bad_type(numargs, "HANDLE", PL_op_desc[o->op_type], kid);
5151                     }
5152                     else {
5153                         I32 flags = OPf_SPECIAL;
5154                         I32 priv = 0;
5155                         /* is this op a FH constructor? */
5156                         if (is_handle_constructor(o,numargs)) {
5157                             flags   = 0;
5158                             /* Set a flag to tell rv2gv to vivify
5159                              * need to "prove" flag does not mean something
5160                              * else already - NI-S 1999/05/07
5161                              */
5162                             priv = OPpDEREF;
5163 #if 0
5164                             /* Helps with open($array[$n],...)
5165                                but is too simplistic - need to do selectively
5166                             */
5167                             mod(kid,type);
5168 #endif
5169                         }
5170                         kid->op_sibling = 0;
5171                         kid = newUNOP(OP_RV2GV, flags, scalar(kid));
5172                         if (priv) {
5173                             kid->op_private |= priv;
5174                         }
5175                     }
5176                     kid->op_sibling = sibl;
5177                     *tokid = kid;
5178                 }
5179                 scalar(kid);
5180                 break;
5181             case OA_SCALARREF:
5182                 mod(scalar(kid), type);
5183                 break;
5184             }
5185             oa >>= 4;
5186             tokid = &kid->op_sibling;
5187             kid = kid->op_sibling;
5188         }
5189         o->op_private |= numargs;
5190         if (kid)
5191             return too_many_arguments(o,PL_op_desc[o->op_type]);
5192         listkids(o);
5193     }
5194     else if (PL_opargs[type] & OA_DEFGV) {
5195         op_free(o);
5196         return newUNOP(type, 0, newDEFSVOP());
5197     }
5198
5199     if (oa) {
5200         while (oa & OA_OPTIONAL)
5201             oa >>= 4;
5202         if (oa && oa != OA_LIST)
5203             return too_few_arguments(o,PL_op_desc[o->op_type]);
5204     }
5205     return o;
5206 }
5207
5208 OP *
5209 Perl_ck_glob(pTHX_ OP *o)
5210 {
5211     GV *gv;
5212
5213     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
5214         append_elem(OP_GLOB, o, newDEFSVOP());
5215
5216     if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV)) && GvIMPORTED_CV(gv)))
5217         gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
5218
5219 #if defined(PERL_INTERNAL_GLOB) && !defined(MINIPERL_BUILD)
5220     /* XXX this can be tightened up and made more failsafe. */
5221     if (!gv) {
5222         OP *modname = newSVOP(OP_CONST, 0, newSVpvn("File::Glob", 10));
5223         modname->op_private |= OPpCONST_BARE;
5224         ENTER;
5225         utilize(1, start_subparse(FALSE, 0), Nullop, modname,
5226                 newSVOP(OP_CONST, 0, newSVpvn("globally", 8)));
5227         gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
5228         LEAVE;
5229     }
5230 #endif /* PERL_INTERNAL_GLOB && !MINIPERL_BUILD */
5231
5232     if (gv && GvIMPORTED_CV(gv)) {
5233         append_elem(OP_GLOB, o,
5234                     newSVOP(OP_CONST, 0, newSViv(PL_glob_index++)));
5235         o->op_type = OP_LIST;
5236         o->op_ppaddr = PL_ppaddr[OP_LIST];
5237         cLISTOPo->op_first->op_type = OP_PUSHMARK;
5238         cLISTOPo->op_first->op_ppaddr = PL_ppaddr[OP_PUSHMARK];
5239         o = newUNOP(OP_ENTERSUB, OPf_STACKED,
5240                     append_elem(OP_LIST, o,
5241                                 scalar(newUNOP(OP_RV2CV, 0,
5242                                                newGVOP(OP_GV, 0, gv)))));
5243         o = newUNOP(OP_NULL, 0, ck_subr(o));
5244         o->op_targ = OP_GLOB;           /* hint at what it used to be */
5245         return o;
5246     }
5247     gv = newGVgen("main");
5248     gv_IOadd(gv);
5249     append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
5250     scalarkids(o);
5251     return ck_fun(o);
5252 }
5253
5254 OP *
5255 Perl_ck_grep(pTHX_ OP *o)
5256 {
5257     LOGOP *gwop;
5258     OP *kid;
5259     OPCODE type = o->op_type == OP_GREPSTART ? OP_GREPWHILE : OP_MAPWHILE;
5260
5261     o->op_ppaddr = PL_ppaddr[OP_GREPSTART];
5262     NewOp(1101, gwop, 1, LOGOP);
5263
5264     if (o->op_flags & OPf_STACKED) {
5265         OP* k;
5266         o = ck_sort(o);
5267         kid = cLISTOPo->op_first->op_sibling;
5268         for (k = cLISTOPo->op_first->op_sibling->op_next; k; k = k->op_next) {
5269             kid = k;
5270         }
5271         kid->op_next = (OP*)gwop;
5272         o->op_flags &= ~OPf_STACKED;
5273     }
5274     kid = cLISTOPo->op_first->op_sibling;
5275     if (type == OP_MAPWHILE)
5276         list(kid);
5277     else
5278         scalar(kid);
5279     o = ck_fun(o);
5280     if (PL_error_count)
5281         return o;
5282     kid = cLISTOPo->op_first->op_sibling;
5283     if (kid->op_type != OP_NULL)
5284         Perl_croak(aTHX_ "panic: ck_grep");
5285     kid = kUNOP->op_first;
5286
5287     gwop->op_type = type;
5288     gwop->op_ppaddr = PL_ppaddr[type];
5289     gwop->op_first = listkids(o);
5290     gwop->op_flags |= OPf_KIDS;
5291     gwop->op_private = 1;
5292     gwop->op_other = LINKLIST(kid);
5293     gwop->op_targ = pad_alloc(type, SVs_PADTMP);
5294     kid->op_next = (OP*)gwop;
5295
5296     kid = cLISTOPo->op_first->op_sibling;
5297     if (!kid || !kid->op_sibling)
5298         return too_few_arguments(o,PL_op_desc[o->op_type]);
5299     for (kid = kid->op_sibling; kid; kid = kid->op_sibling)
5300         mod(kid, OP_GREPSTART);
5301
5302     return (OP*)gwop;
5303 }
5304
5305 OP *
5306 Perl_ck_index(pTHX_ OP *o)
5307 {
5308     if (o->op_flags & OPf_KIDS) {
5309         OP *kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
5310         if (kid)
5311             kid = kid->op_sibling;                      /* get past "big" */
5312         if (kid && kid->op_type == OP_CONST)
5313             fbm_compile(((SVOP*)kid)->op_sv, 0);
5314     }
5315     return ck_fun(o);
5316 }
5317
5318 OP *
5319 Perl_ck_lengthconst(pTHX_ OP *o)
5320 {
5321     /* XXX length optimization goes here */
5322     return ck_fun(o);
5323 }
5324
5325 OP *
5326 Perl_ck_lfun(pTHX_ OP *o)
5327 {
5328     OPCODE type = o->op_type;
5329     return modkids(ck_fun(o), type);
5330 }
5331
5332 OP *
5333 Perl_ck_defined(pTHX_ OP *o)            /* 19990527 MJD */
5334 {
5335     dTHR;
5336     if ((o->op_flags & OPf_KIDS) && ckWARN(WARN_DEPRECATED)) {
5337         switch (cUNOPo->op_first->op_type) {
5338         case OP_RV2AV:
5339             break;                      /* Globals via GV can be undef */
5340         case OP_PADAV:
5341         case OP_AASSIGN:                /* Is this a good idea? */
5342             Perl_warner(aTHX_ WARN_DEPRECATED,
5343                         "defined(@array) is deprecated");
5344             Perl_warner(aTHX_ WARN_DEPRECATED,
5345                         "(Maybe you should just omit the defined()?)\n");
5346         break;
5347         case OP_RV2HV:
5348             break;                      /* Globals via GV can be undef */
5349         case OP_PADHV:
5350             Perl_warner(aTHX_ WARN_DEPRECATED,
5351                         "defined(%hash) is deprecated");
5352             Perl_warner(aTHX_ WARN_DEPRECATED,
5353                         "(Maybe you should just omit the defined()?)\n");
5354             break;
5355         default:
5356             /* no warning */
5357             break;
5358         }
5359     }
5360     return ck_rfun(o);
5361 }
5362
5363 OP *
5364 Perl_ck_rfun(pTHX_ OP *o)
5365 {
5366     OPCODE type = o->op_type;
5367     return refkids(ck_fun(o), type);
5368 }
5369
5370 OP *
5371 Perl_ck_listiob(pTHX_ OP *o)
5372 {
5373     register OP *kid;
5374
5375     kid = cLISTOPo->op_first;
5376     if (!kid) {
5377         o = force_list(o);
5378         kid = cLISTOPo->op_first;
5379     }
5380     if (kid->op_type == OP_PUSHMARK)
5381         kid = kid->op_sibling;
5382     if (kid && o->op_flags & OPf_STACKED)
5383         kid = kid->op_sibling;
5384     else if (kid && !kid->op_sibling) {         /* print HANDLE; */
5385         if (kid->op_type == OP_CONST && kid->op_private & OPpCONST_BARE) {
5386             o->op_flags |= OPf_STACKED; /* make it a filehandle */
5387             kid = newUNOP(OP_RV2GV, OPf_REF, scalar(kid));
5388             cLISTOPo->op_first->op_sibling = kid;
5389             cLISTOPo->op_last = kid;
5390             kid = kid->op_sibling;
5391         }
5392     }
5393
5394     if (!kid)
5395         append_elem(o->op_type, o, newDEFSVOP());
5396
5397     o = listkids(o);
5398
5399     o->op_private = 0;
5400 #ifdef USE_LOCALE
5401     if (PL_hints & HINT_LOCALE)
5402         o->op_private |= OPpLOCALE;
5403 #endif
5404
5405     return o;
5406 }
5407
5408 OP *
5409 Perl_ck_fun_locale(pTHX_ OP *o)
5410 {
5411     o = ck_fun(o);
5412
5413     o->op_private = 0;
5414 #ifdef USE_LOCALE
5415     if (PL_hints & HINT_LOCALE)
5416         o->op_private |= OPpLOCALE;
5417 #endif
5418
5419     return o;
5420 }
5421
5422 OP *
5423 Perl_ck_sassign(pTHX_ OP *o)
5424 {
5425     OP *kid = cLISTOPo->op_first;
5426     /* has a disposable target? */
5427     if ((PL_opargs[kid->op_type] & OA_TARGLEX)
5428         && !(kid->op_flags & OPf_STACKED))
5429     {
5430         OP *kkid = kid->op_sibling;
5431
5432         /* Can just relocate the target. */
5433         if (kkid && kkid->op_type == OP_PADSV
5434             && !(kkid->op_private & OPpLVAL_INTRO))
5435         {
5436             /* Concat has problems if target is equal to right arg. */
5437             if (kid->op_type == OP_CONCAT) {
5438                 if (kLISTOP->op_first->op_sibling->op_type == OP_PADSV
5439                     && kLISTOP->op_first->op_sibling->op_targ == kkid->op_targ)
5440                     return o;
5441             }
5442             else if (kid->op_type == OP_JOIN) {
5443                 /* do_join has problems if the arguments coincide with target.
5444                    In fact the second argument *can* safely coincide,
5445                    but ignore=pessimize this rare occasion. */
5446                 OP *arg = kLISTOP->op_first->op_sibling; /* Skip PUSHMARK */
5447
5448                 while (arg) {
5449                     if (arg->op_type == OP_PADSV
5450                         && arg->op_targ == kkid->op_targ)
5451                         return o;
5452                     arg = arg->op_sibling;
5453                 }
5454             }
5455             else if (kid->op_type == OP_QUOTEMETA) {
5456                 /* quotemeta has problems if the argument coincides with target. */
5457                 if (kLISTOP->op_first->op_type == OP_PADSV
5458                     && kLISTOP->op_first->op_targ == kkid->op_targ)
5459                     return o;
5460             }
5461             kid->op_targ = kkid->op_targ;
5462             /* Now we do not need PADSV and SASSIGN. */
5463             kid->op_sibling = o->op_sibling;    /* NULL */
5464             cLISTOPo->op_first = NULL;
5465             op_free(o);
5466             op_free(kkid);
5467             kid->op_private |= OPpTARGET_MY;    /* Used for context settings */
5468             return kid;
5469         }
5470     }
5471     return o;
5472 }
5473
5474 OP *
5475 Perl_ck_scmp(pTHX_ OP *o)
5476 {
5477     o->op_private = 0;
5478 #ifdef USE_LOCALE
5479     if (PL_hints & HINT_LOCALE)
5480         o->op_private |= OPpLOCALE;
5481 #endif
5482
5483     return o;
5484 }
5485
5486 OP *
5487 Perl_ck_match(pTHX_ OP *o)
5488 {
5489     o->op_private |= OPpRUNTIME;
5490     return o;
5491 }
5492
5493 OP *
5494 Perl_ck_method(pTHX_ OP *o)
5495 {
5496     OP *kid = cUNOPo->op_first;
5497     if (kid->op_type == OP_CONST) {
5498         SV* sv = kSVOP->op_sv;
5499         if (!(strchr(SvPVX(sv), ':') || strchr(SvPVX(sv), '\''))) {
5500             OP *cmop;
5501             sv_upgrade(sv, SVt_PVIV);
5502             SvIOK_on(sv);
5503             PERL_HASH(SvUVX(sv), SvPVX(sv), SvCUR(sv));
5504             cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
5505             kSVOP->op_sv = Nullsv;
5506             op_free(o);
5507             return cmop;
5508         }
5509     }
5510     return o;
5511 }
5512
5513 OP *
5514 Perl_ck_null(pTHX_ OP *o)
5515 {
5516     return o;
5517 }
5518
5519 OP *
5520 Perl_ck_repeat(pTHX_ OP *o)
5521 {
5522     if (cBINOPo->op_first->op_flags & OPf_PARENS) {
5523         o->op_private |= OPpREPEAT_DOLIST;
5524         cBINOPo->op_first = force_list(cBINOPo->op_first);
5525     }
5526     else
5527         scalar(o);
5528     return o;
5529 }
5530
5531 OP *
5532 Perl_ck_require(pTHX_ OP *o)
5533 {
5534     if (o->op_flags & OPf_KIDS) {       /* Shall we supply missing .pm? */
5535         SVOP *kid = (SVOP*)cUNOPo->op_first;
5536
5537         if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
5538             char *s;
5539             for (s = SvPVX(kid->op_sv); *s; s++) {
5540                 if (*s == ':' && s[1] == ':') {
5541                     *s = '/';
5542                     Move(s+2, s+1, strlen(s+2)+1, char);
5543                     --SvCUR(kid->op_sv);
5544                 }
5545             }
5546             sv_catpvn(kid->op_sv, ".pm", 3);
5547         }
5548     }
5549     return ck_fun(o);
5550 }
5551
5552 #if 0
5553 OP *
5554 Perl_ck_retarget(pTHX_ OP *o)
5555 {
5556     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
5557     /* STUB */
5558     return o;
5559 }
5560 #endif
5561
5562 OP *
5563 Perl_ck_select(pTHX_ OP *o)
5564 {
5565     OP* kid;
5566     if (o->op_flags & OPf_KIDS) {
5567         kid = cLISTOPo->op_first->op_sibling;   /* get past pushmark */
5568         if (kid && kid->op_sibling) {
5569             o->op_type = OP_SSELECT;
5570             o->op_ppaddr = PL_ppaddr[OP_SSELECT];
5571             o = ck_fun(o);
5572             return fold_constants(o);
5573         }
5574     }
5575     o = ck_fun(o);
5576     kid = cLISTOPo->op_first->op_sibling;    /* get past pushmark */
5577     if (kid && kid->op_type == OP_RV2GV)
5578         kid->op_private &= ~HINT_STRICT_REFS;
5579     return o;
5580 }
5581
5582 OP *
5583 Perl_ck_shift(pTHX_ OP *o)
5584 {
5585     I32 type = o->op_type;
5586
5587     if (!(o->op_flags & OPf_KIDS)) {
5588         OP *argop;
5589
5590         op_free(o);
5591 #ifdef USE_THREADS
5592         if (!CvUNIQUE(PL_compcv)) {
5593             argop = newOP(OP_PADAV, OPf_REF);
5594             argop->op_targ = 0;         /* PL_curpad[0] is @_ */
5595         }
5596         else {
5597             argop = newUNOP(OP_RV2AV, 0,
5598                 scalar(newGVOP(OP_GV, 0,
5599                     gv_fetchpv("ARGV", TRUE, SVt_PVAV))));
5600         }
5601 #else
5602         argop = newUNOP(OP_RV2AV, 0,
5603             scalar(newGVOP(OP_GV, 0, !CvUNIQUE(PL_compcv) ?
5604                            PL_defgv : gv_fetchpv("ARGV", TRUE, SVt_PVAV))));
5605 #endif /* USE_THREADS */
5606         return newUNOP(type, 0, scalar(argop));
5607     }
5608     return scalar(modkids(ck_fun(o), type));
5609 }
5610
5611 OP *
5612 Perl_ck_sort(pTHX_ OP *o)
5613 {
5614     o->op_private = 0;
5615 #ifdef USE_LOCALE
5616     if (PL_hints & HINT_LOCALE)
5617         o->op_private |= OPpLOCALE;
5618 #endif
5619
5620     if (o->op_type == OP_SORT && o->op_flags & OPf_STACKED)
5621         simplify_sort(o);
5622     if (o->op_flags & OPf_STACKED) {                 /* may have been cleared */
5623         OP *kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
5624         OP *k;
5625         kid = kUNOP->op_first;                          /* get past null */
5626
5627         if (kid->op_type == OP_SCOPE || kid->op_type == OP_LEAVE) {
5628             linklist(kid);
5629             if (kid->op_type == OP_SCOPE) {
5630                 k = kid->op_next;
5631                 kid->op_next = 0;
5632             }
5633             else if (kid->op_type == OP_LEAVE) {
5634                 if (o->op_type == OP_SORT) {
5635                     null(kid);                  /* wipe out leave */
5636                     kid->op_next = kid;
5637
5638                     for (k = kLISTOP->op_first->op_next; k; k = k->op_next) {
5639                         if (k->op_next == kid)
5640                             k->op_next = 0;
5641                     }
5642                 }
5643                 else
5644                     kid->op_next = 0;           /* just disconnect the leave */
5645                 k = kLISTOP->op_first;
5646             }
5647             peep(k);
5648
5649             kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
5650             if (o->op_type == OP_SORT)
5651                 kid->op_next = kid;
5652             else
5653                 kid->op_next = k;
5654             o->op_flags |= OPf_SPECIAL;
5655         }
5656         else if (kid->op_type == OP_RV2SV || kid->op_type == OP_PADSV)
5657             null(cLISTOPo->op_first->op_sibling);
5658     }
5659
5660     return o;
5661 }
5662
5663 STATIC void
5664 S_simplify_sort(pTHX_ OP *o)
5665 {
5666     dTHR;
5667     register OP *kid = cLISTOPo->op_first->op_sibling;  /* get past pushmark */
5668     OP *k;
5669     int reversed;
5670     if (!(o->op_flags & OPf_STACKED))
5671         return;
5672     GvMULTI_on(gv_fetchpv("a", TRUE, SVt_PV));
5673     GvMULTI_on(gv_fetchpv("b", TRUE, SVt_PV));
5674     kid = kUNOP->op_first;                              /* get past null */
5675     if (kid->op_type != OP_SCOPE)
5676         return;
5677     kid = kLISTOP->op_last;                             /* get past scope */
5678     switch(kid->op_type) {
5679         case OP_NCMP:
5680         case OP_I_NCMP:
5681         case OP_SCMP:
5682             break;
5683         default:
5684             return;
5685     }
5686     k = kid;                                            /* remember this node*/
5687     if (kBINOP->op_first->op_type != OP_RV2SV)
5688         return;
5689     kid = kBINOP->op_first;                             /* get past cmp */
5690     if (kUNOP->op_first->op_type != OP_GV)
5691         return;
5692     kid = kUNOP->op_first;                              /* get past rv2sv */
5693     if (GvSTASH((GV*)kSVOP->op_sv) != PL_curstash)
5694         return;
5695     if (strEQ(GvNAME((GV*)kSVOP->op_sv), "a"))
5696         reversed = 0;
5697     else if(strEQ(GvNAME((GV*)kSVOP->op_sv), "b"))
5698         reversed = 1;
5699     else
5700         return;
5701     kid = k;                                            /* back to cmp */
5702     if (kBINOP->op_last->op_type != OP_RV2SV)
5703         return;
5704     kid = kBINOP->op_last;                              /* down to 2nd arg */
5705     if (kUNOP->op_first->op_type != OP_GV)
5706         return;
5707     kid = kUNOP->op_first;                              /* get past rv2sv */
5708     if (GvSTASH((GV*)kSVOP->op_sv) != PL_curstash
5709         || ( reversed
5710             ? strNE(GvNAME((GV*)kSVOP->op_sv), "a")
5711             : strNE(GvNAME((GV*)kSVOP->op_sv), "b")))
5712         return;
5713     o->op_flags &= ~(OPf_STACKED | OPf_SPECIAL);
5714     if (reversed)
5715         o->op_private |= OPpSORT_REVERSE;
5716     if (k->op_type == OP_NCMP)
5717         o->op_private |= OPpSORT_NUMERIC;
5718     if (k->op_type == OP_I_NCMP)
5719         o->op_private |= OPpSORT_NUMERIC | OPpSORT_INTEGER;
5720     kid = cLISTOPo->op_first->op_sibling;
5721     cLISTOPo->op_first->op_sibling = kid->op_sibling; /* bypass old block */
5722     op_free(kid);                                     /* then delete it */
5723     cLISTOPo->op_children--;
5724 }
5725
5726 OP *
5727 Perl_ck_split(pTHX_ OP *o)
5728 {
5729     register OP *kid;
5730
5731     if (o->op_flags & OPf_STACKED)
5732         return no_fh_allowed(o);
5733
5734     kid = cLISTOPo->op_first;
5735     if (kid->op_type != OP_NULL)
5736         Perl_croak(aTHX_ "panic: ck_split");
5737     kid = kid->op_sibling;
5738     op_free(cLISTOPo->op_first);
5739     cLISTOPo->op_first = kid;
5740     if (!kid) {
5741         cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvn(" ", 1));
5742         cLISTOPo->op_last = kid; /* There was only one element previously */
5743     }
5744
5745     if (kid->op_type != OP_MATCH) {
5746         OP *sibl = kid->op_sibling;
5747         kid->op_sibling = 0;
5748         kid = pmruntime( newPMOP(OP_MATCH, OPf_SPECIAL), kid, Nullop);
5749         if (cLISTOPo->op_first == cLISTOPo->op_last)
5750             cLISTOPo->op_last = kid;
5751         cLISTOPo->op_first = kid;
5752         kid->op_sibling = sibl;
5753     }
5754
5755     kid->op_type = OP_PUSHRE;
5756     kid->op_ppaddr = PL_ppaddr[OP_PUSHRE];
5757     scalar(kid);
5758
5759     if (!kid->op_sibling)
5760         append_elem(OP_SPLIT, o, newDEFSVOP());
5761
5762     kid = kid->op_sibling;
5763     scalar(kid);
5764
5765     if (!kid->op_sibling)
5766         append_elem(OP_SPLIT, o, newSVOP(OP_CONST, 0, newSViv(0)));
5767
5768     kid = kid->op_sibling;
5769     scalar(kid);
5770
5771     if (kid->op_sibling)
5772         return too_many_arguments(o,PL_op_desc[o->op_type]);
5773
5774     return o;
5775 }
5776
5777 OP *
5778 Perl_ck_join(pTHX_ OP *o)
5779 {
5780     if (ckWARN(WARN_SYNTAX)) {
5781         OP *kid = cLISTOPo->op_first->op_sibling;
5782         if (kid && kid->op_type == OP_MATCH) {
5783             char *pmstr = "STRING";
5784             if (kPMOP->op_pmregexp)
5785                 pmstr = kPMOP->op_pmregexp->precomp;
5786             Perl_warner(aTHX_ WARN_SYNTAX,
5787                         "/%s/ should probably be written as \"%s\"",
5788                         pmstr, pmstr);
5789         }
5790     }
5791     return ck_fun(o);
5792 }
5793
5794 OP *
5795 Perl_ck_subr(pTHX_ OP *o)
5796 {
5797     dTHR;
5798     OP *prev = ((cUNOPo->op_first->op_sibling)
5799              ? cUNOPo : ((UNOP*)cUNOPo->op_first))->op_first;
5800     OP *o2 = prev->op_sibling;
5801     OP *cvop;
5802     char *proto = 0;
5803     CV *cv = 0;
5804     GV *namegv = 0;
5805     int optional = 0;
5806     I32 arg = 0;
5807     STRLEN n_a;
5808
5809     o->op_private |= OPpENTERSUB_HASTARG;
5810     for (cvop = o2; cvop->op_sibling; cvop = cvop->op_sibling) ;
5811     if (cvop->op_type == OP_RV2CV) {
5812         SVOP* tmpop;
5813         o->op_private |= (cvop->op_private & OPpENTERSUB_AMPER);
5814         null(cvop);             /* disable rv2cv */
5815         tmpop = (SVOP*)((UNOP*)cvop)->op_first;
5816         if (tmpop->op_type == OP_GV && !(o->op_private & OPpENTERSUB_AMPER)) {
5817             cv = GvCVu(tmpop->op_sv);
5818             if (!cv)
5819                 tmpop->op_private |= OPpEARLY_CV;
5820             else if (SvPOK(cv)) {
5821                 namegv = CvANON(cv) ? (GV*)tmpop->op_sv : CvGV(cv);
5822                 proto = SvPV((SV*)cv, n_a);
5823             }
5824         }
5825     }
5826     else if (cvop->op_type == OP_METHOD || cvop->op_type == OP_METHOD_NAMED) {
5827         if (o2->op_type == OP_CONST)
5828             o2->op_private &= ~OPpCONST_STRICT;
5829         else if (o2->op_type == OP_LIST) {
5830             OP *o = ((UNOP*)o2)->op_first->op_sibling;
5831             if (o && o->op_type == OP_CONST)
5832                 o->op_private &= ~OPpCONST_STRICT;
5833         }
5834     }
5835     o->op_private |= (PL_hints & HINT_STRICT_REFS);
5836     if (PERLDB_SUB && PL_curstash != PL_debstash)
5837         o->op_private |= OPpENTERSUB_DB;
5838     while (o2 != cvop) {
5839         if (proto) {
5840             switch (*proto) {
5841             case '\0':
5842                 return too_many_arguments(o, gv_ename(namegv));
5843             case ';':
5844                 optional = 1;
5845                 proto++;
5846                 continue;
5847             case '$':
5848                 proto++;
5849                 arg++;
5850                 scalar(o2);
5851                 break;
5852             case '%':
5853             case '@':
5854                 list(o2);
5855                 arg++;
5856                 break;
5857             case '&':
5858                 proto++;
5859                 arg++;
5860                 if (o2->op_type != OP_REFGEN && o2->op_type != OP_UNDEF)
5861                     bad_type(arg, "block", gv_ename(namegv), o2);
5862                 break;
5863             case '*':
5864                 /* '*' allows any scalar type, including bareword */
5865                 proto++;
5866                 arg++;
5867                 if (o2->op_type == OP_RV2GV)
5868                     goto wrapref;       /* autoconvert GLOB -> GLOBref */
5869                 else if (o2->op_type == OP_CONST)
5870                     o2->op_private &= ~OPpCONST_STRICT;
5871                 else if (o2->op_type == OP_ENTERSUB) {
5872                     /* accidental subroutine, revert to bareword */
5873                     OP *gvop = ((UNOP*)o2)->op_first;
5874                     if (gvop && gvop->op_type == OP_NULL) {
5875                         gvop = ((UNOP*)gvop)->op_first;
5876                         if (gvop) {
5877                             for (; gvop->op_sibling; gvop = gvop->op_sibling)
5878                                 ;
5879                             if (gvop &&
5880                                 (gvop->op_private & OPpENTERSUB_NOPAREN) &&
5881                                 (gvop = ((UNOP*)gvop)->op_first) &&
5882                                 gvop->op_type == OP_GV)
5883                             {
5884                                 GV *gv = (GV*)((SVOP*)gvop)->op_sv;
5885                                 OP *sibling = o2->op_sibling;
5886                                 SV *n = newSVpvn("",0);
5887                                 op_free(o2);
5888                                 gv_fullname3(n, gv, "");
5889                                 if (SvCUR(n)>6 && strnEQ(SvPVX(n),"main::",6))
5890                                     sv_chop(n, SvPVX(n)+6);
5891                                 o2 = newSVOP(OP_CONST, 0, n);
5892                                 prev->op_sibling = o2;
5893                                 o2->op_sibling = sibling;
5894                             }
5895                         }
5896                     }
5897                 }
5898                 scalar(o2);
5899                 break;
5900             case '\\':
5901                 proto++;
5902                 arg++;
5903                 switch (*proto++) {
5904                 case '*':
5905                     if (o2->op_type != OP_RV2GV)
5906                         bad_type(arg, "symbol", gv_ename(namegv), o2);
5907                     goto wrapref;
5908                 case '&':
5909                     if (o2->op_type != OP_RV2CV)
5910                         bad_type(arg, "sub", gv_ename(namegv), o2);
5911                     goto wrapref;
5912                 case '$':
5913                     if (o2->op_type != OP_RV2SV
5914                         && o2->op_type != OP_PADSV
5915                         && o2->op_type != OP_HELEM
5916                         && o2->op_type != OP_AELEM
5917                         && o2->op_type != OP_THREADSV)
5918                     {
5919                         bad_type(arg, "scalar", gv_ename(namegv), o2);
5920                     }
5921                     goto wrapref;
5922                 case '@':
5923                     if (o2->op_type != OP_RV2AV && o2->op_type != OP_PADAV)
5924                         bad_type(arg, "array", gv_ename(namegv), o2);
5925                     goto wrapref;
5926                 case '%':
5927                     if (o2->op_type != OP_RV2HV && o2->op_type != OP_PADHV)
5928                         bad_type(arg, "hash", gv_ename(namegv), o2);
5929                   wrapref:
5930                     {
5931                         OP* kid = o2;
5932                         OP* sib = kid->op_sibling;
5933                         kid->op_sibling = 0;
5934                         o2 = newUNOP(OP_REFGEN, 0, kid);
5935                         o2->op_sibling = sib;
5936                         prev->op_sibling = o2;
5937                     }
5938                     break;
5939                 default: goto oops;
5940                 }
5941                 break;
5942             case ' ':
5943                 proto++;
5944                 continue;
5945             default:
5946               oops:
5947                 Perl_croak(aTHX_ "Malformed prototype for %s: %s",
5948                         gv_ename(namegv), SvPV((SV*)cv, n_a));
5949             }
5950         }
5951         else
5952             list(o2);
5953         mod(o2, OP_ENTERSUB);
5954         prev = o2;
5955         o2 = o2->op_sibling;
5956     }
5957     if (proto && !optional &&
5958           (*proto && *proto != '@' && *proto != '%' && *proto != ';'))
5959         return too_few_arguments(o, gv_ename(namegv));
5960     return o;
5961 }
5962
5963 OP *
5964 Perl_ck_svconst(pTHX_ OP *o)
5965 {
5966     SvREADONLY_on(cSVOPo->op_sv);
5967     return o;
5968 }
5969
5970 OP *
5971 Perl_ck_trunc(pTHX_ OP *o)
5972 {
5973     if (o->op_flags & OPf_KIDS) {
5974         SVOP *kid = (SVOP*)cUNOPo->op_first;
5975
5976         if (kid->op_type == OP_NULL)
5977             kid = (SVOP*)kid->op_sibling;
5978         if (kid && kid->op_type == OP_CONST &&
5979             (kid->op_private & OPpCONST_BARE))
5980         {
5981             o->op_flags |= OPf_SPECIAL;
5982             kid->op_private &= ~OPpCONST_STRICT;
5983         }
5984     }
5985     return ck_fun(o);
5986 }
5987
5988 /* A peephole optimizer.  We visit the ops in the order they're to execute. */
5989
5990 void
5991 Perl_peep(pTHX_ register OP *o)
5992 {
5993     dTHR;
5994     register OP* oldop = 0;
5995     STRLEN n_a;
5996     OP *last_composite = Nullop;
5997
5998     if (!o || o->op_seq)
5999         return;
6000     ENTER;
6001     SAVEOP();
6002     SAVESPTR(PL_curcop);
6003     for (; o; o = o->op_next) {
6004         if (o->op_seq)
6005             break;
6006         if (!PL_op_seqmax)
6007             PL_op_seqmax++;
6008         PL_op = o;
6009         switch (o->op_type) {
6010         case OP_SETSTATE:
6011         case OP_NEXTSTATE:
6012         case OP_DBSTATE:
6013             PL_curcop = ((COP*)o);              /* for warnings */
6014             o->op_seq = PL_op_seqmax++;
6015             last_composite = Nullop;
6016             break;
6017
6018         case OP_CONST:
6019             if (cSVOPo->op_private & OPpCONST_STRICT)
6020                 no_bareword_allowed(o);
6021             /* FALL THROUGH */
6022         case OP_UC:
6023         case OP_UCFIRST:
6024         case OP_LC:
6025         case OP_LCFIRST:
6026             if ( o->op_next && o->op_next->op_type == OP_STRINGIFY
6027                  && !(o->op_next->op_private & OPpTARGET_MY) )
6028                 null(o->op_next);
6029             o->op_seq = PL_op_seqmax++;
6030             break;
6031         case OP_CONCAT:
6032         case OP_JOIN:
6033         case OP_QUOTEMETA:
6034             if (o->op_next && o->op_next->op_type == OP_STRINGIFY) {
6035                 if (o->op_next->op_private & OPpTARGET_MY) {
6036                     if ((o->op_flags & OPf_STACKED) /* chained concats */
6037                         || (o->op_type == OP_CONCAT
6038             /* Concat has problems if target is equal to right arg. */
6039                             && (((LISTOP*)o)->op_first->op_sibling->op_type
6040                                 == OP_PADSV)
6041                             && (((LISTOP*)o)->op_first->op_sibling->op_targ
6042                                 == o->op_next->op_targ))) {
6043                         goto ignore_optimization;
6044                     }
6045                     else {
6046                         o->op_targ = o->op_next->op_targ;
6047                         o->op_private |= OPpTARGET_MY;
6048                     }
6049                 }
6050                 null(o->op_next);
6051             }
6052           ignore_optimization:
6053             o->op_seq = PL_op_seqmax++;
6054             break;
6055         case OP_STUB:
6056             if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
6057                 o->op_seq = PL_op_seqmax++;
6058                 break; /* Scalar stub must produce undef.  List stub is noop */
6059             }
6060             goto nothin;
6061         case OP_NULL:
6062             if (o->op_targ == OP_NEXTSTATE
6063                 || o->op_targ == OP_DBSTATE
6064                 || o->op_targ == OP_SETSTATE)
6065             {
6066                 PL_curcop = ((COP*)o);
6067             }
6068             goto nothin;
6069         case OP_SCALAR:
6070         case OP_LINESEQ:
6071         case OP_SCOPE:
6072           nothin:
6073             if (oldop && o->op_next) {
6074                 oldop->op_next = o->op_next;
6075                 continue;
6076             }
6077             o->op_seq = PL_op_seqmax++;
6078             break;
6079
6080         case OP_GV:
6081             if (o->op_next->op_type == OP_RV2SV) {
6082                 if (!(o->op_next->op_private & OPpDEREF)) {
6083                     null(o->op_next);
6084                     o->op_private |= o->op_next->op_private & OPpLVAL_INTRO;
6085                     o->op_next = o->op_next->op_next;
6086                     o->op_type = OP_GVSV;
6087                     o->op_ppaddr = PL_ppaddr[OP_GVSV];
6088                 }
6089             }
6090             else if (o->op_next->op_type == OP_RV2AV) {
6091                 OP* pop = o->op_next->op_next;
6092                 IV i;
6093                 if (pop->op_type == OP_CONST &&
6094                     (PL_op = pop->op_next) &&
6095                     pop->op_next->op_type == OP_AELEM &&
6096                     !(pop->op_next->op_private &
6097                       (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) &&
6098                     (i = SvIV(((SVOP*)pop)->op_sv) - PL_compiling.cop_arybase)
6099                                 <= 255 &&
6100                     i >= 0)
6101                 {
6102                     null(o->op_next);
6103                     null(pop->op_next);
6104                     null(pop);
6105                     o->op_flags |= pop->op_next->op_flags & OPf_MOD;
6106                     o->op_next = pop->op_next->op_next;
6107                     o->op_type = OP_AELEMFAST;
6108                     o->op_ppaddr = PL_ppaddr[OP_AELEMFAST];
6109                     o->op_private = (U8)i;
6110                     GvAVn((GV*)((SVOP*)o)->op_sv);
6111                 }
6112             }
6113             else if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_UNSAFE)) {
6114                 GV *gv = (GV*)cSVOPo->op_sv;
6115                 if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX(GvCV(gv))) {
6116                     /* XXX could check prototype here instead of just carping */
6117                     SV *sv = sv_newmortal();
6118                     gv_efullname3(sv, gv, Nullch);
6119                     Perl_warner(aTHX_ WARN_UNSAFE,
6120                                 "%s() called too early to check prototype",
6121                                 SvPV_nolen(sv));
6122                 }
6123             }
6124
6125             o->op_seq = PL_op_seqmax++;
6126             break;
6127
6128         case OP_MAPWHILE:
6129         case OP_GREPWHILE:
6130         case OP_AND:
6131         case OP_OR:
6132         case OP_ANDASSIGN:
6133         case OP_ORASSIGN:
6134         case OP_COND_EXPR:
6135         case OP_RANGE:
6136             o->op_seq = PL_op_seqmax++;
6137             while (cLOGOP->op_other->op_type == OP_NULL)
6138                 cLOGOP->op_other = cLOGOP->op_other->op_next;
6139             peep(cLOGOP->op_other);
6140             break;
6141
6142         case OP_ENTERLOOP:
6143             o->op_seq = PL_op_seqmax++;
6144             peep(cLOOP->op_redoop);
6145             peep(cLOOP->op_nextop);
6146             peep(cLOOP->op_lastop);
6147             break;
6148
6149         case OP_QR:
6150         case OP_MATCH:
6151         case OP_SUBST:
6152             o->op_seq = PL_op_seqmax++;
6153             peep(cPMOP->op_pmreplstart);
6154             break;
6155
6156         case OP_EXEC:
6157             o->op_seq = PL_op_seqmax++;
6158             if (ckWARN(WARN_SYNTAX) && o->op_next
6159                 && o->op_next->op_type == OP_NEXTSTATE) {
6160                 if (o->op_next->op_sibling &&
6161                         o->op_next->op_sibling->op_type != OP_EXIT &&
6162                         o->op_next->op_sibling->op_type != OP_WARN &&
6163                         o->op_next->op_sibling->op_type != OP_DIE) {
6164                     line_t oldline = PL_curcop->cop_line;
6165
6166                     PL_curcop->cop_line = ((COP*)o->op_next)->cop_line;
6167                     Perl_warner(aTHX_ WARN_SYNTAX, "Statement unlikely to be reached");
6168                     Perl_warner(aTHX_ WARN_SYNTAX, "(Maybe you meant system() when you said exec()?)\n");
6169                     PL_curcop->cop_line = oldline;
6170                 }
6171             }
6172             break;
6173
6174         case OP_HELEM: {
6175             UNOP *rop;
6176             SV *lexname;
6177             GV **fields;
6178             SV **svp, **indsvp;
6179             I32 ind;
6180             char *key;
6181             STRLEN keylen;
6182
6183             if ((o->op_private & (OPpLVAL_INTRO))
6184                 || ((BINOP*)o)->op_last->op_type != OP_CONST)
6185                 break;
6186             rop = (UNOP*)((BINOP*)o)->op_first;
6187             if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
6188                 break;
6189             lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
6190             if (!SvOBJECT(lexname))
6191                 break;
6192             fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
6193             if (!fields || !GvHV(*fields))
6194                 break;
6195             svp = &((SVOP*)((BINOP*)o)->op_last)->op_sv;
6196             key = SvPV(*svp, keylen);
6197             indsvp = hv_fetch(GvHV(*fields), key, keylen, FALSE);
6198             if (!indsvp) {
6199                 Perl_croak(aTHX_ "No such pseudo-hash field \"%s\" in variable %s of type %s",
6200                       key, SvPV(lexname, n_a), HvNAME(SvSTASH(lexname)));
6201             }
6202             ind = SvIV(*indsvp);
6203             if (ind < 1)
6204                 Perl_croak(aTHX_ "Bad index while coercing array into hash");
6205             rop->op_type = OP_RV2AV;
6206             rop->op_ppaddr = PL_ppaddr[OP_RV2AV];
6207             o->op_type = OP_AELEM;
6208             o->op_ppaddr = PL_ppaddr[OP_AELEM];
6209             SvREFCNT_dec(*svp);
6210             *svp = newSViv(ind);
6211             break;
6212         }
6213
6214         case OP_RV2AV:
6215         case OP_RV2HV:
6216             if (!(o->op_flags & OPf_WANT)
6217                 || (o->op_flags & OPf_WANT) == OPf_WANT_LIST)
6218             {
6219                 last_composite = o;
6220             }
6221             o->op_seq = PL_op_seqmax++;
6222             break;
6223
6224         case OP_RETURN:
6225             if (o->op_next && o->op_next->op_type != OP_LEAVESUBLV) {
6226                 o->op_seq = PL_op_seqmax++;
6227                 break;
6228             }
6229             /* FALL THROUGH */
6230
6231         case OP_LEAVESUBLV:
6232             if (last_composite) {
6233                 OP *r = last_composite;
6234
6235                 while (r->op_sibling)
6236                    r = r->op_sibling;
6237                 if (r->op_next == o
6238                     || (r->op_next->op_type == OP_LIST
6239                         && r->op_next->op_next == o))
6240                 {
6241                     if (last_composite->op_type == OP_RV2AV)
6242                         yyerror("Lvalue subs returning arrays not implemented yet");
6243                     else
6244                         yyerror("Lvalue subs returning hashes not implemented yet");
6245                         ;
6246                 }
6247             }
6248             /* FALL THROUGH */
6249
6250         default:
6251             o->op_seq = PL_op_seqmax++;
6252             break;
6253         }
6254         oldop = o;
6255     }
6256     LEAVE;
6257 }