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(CopFILEGV(cop));
 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*)CopFILEGV(&PL_compiling));
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     CopFILEGV_set(cop, (GV*)SvREFCNT_inc(CopFILEGV(PL_curcop)));
3281     cop->cop_stash = PL_curstash;
3282
3283     if (PERLDB_LINE && PL_curstash != PL_debstash) {
3284         SV **svp = av_fetch(CopFILEAV(PL_curcop), (I32)CopLINE(cop), 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     CvGV(cv)            = (GV*)SvREFCNT_inc(CvGV(proto));
3945     CvSTASH(cv)         = CvSTASH(proto);
3946     CvROOT(cv)          = CvROOT(proto);
3947     CvSTART(cv)         = CvSTART(proto);
3948     if (outside)
3949         CvOUTSIDE(cv)   = (CV*)SvREFCNT_inc(outside);
3950
3951     if (SvPOK(proto))
3952         sv_setpvn((SV*)cv, SvPVX(proto), SvCUR(proto));
3953
3954     PL_comppad_name = newAV();
3955     for (ix = fname; ix >= 0; ix--)
3956         av_store(PL_comppad_name, ix, SvREFCNT_inc(pname[ix]));
3957
3958     PL_comppad = newAV();
3959
3960     comppadlist = newAV();
3961     AvREAL_off(comppadlist);
3962     av_store(comppadlist, 0, (SV*)PL_comppad_name);
3963     av_store(comppadlist, 1, (SV*)PL_comppad);
3964     CvPADLIST(cv) = comppadlist;
3965     av_fill(PL_comppad, AvFILLp(protopad));
3966     PL_curpad = AvARRAY(PL_comppad);
3967
3968     av = newAV();           /* will be @_ */
3969     av_extend(av, 0);
3970     av_store(PL_comppad, 0, (SV*)av);
3971     AvFLAGS(av) = AVf_REIFY;
3972
3973     for (ix = fpad; ix > 0; ix--) {
3974         SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
3975         if (namesv && namesv != &PL_sv_undef) {
3976             char *name = SvPVX(namesv);    /* XXX */
3977             if (SvFLAGS(namesv) & SVf_FAKE) {   /* lexical from outside? */
3978                 I32 off = pad_findlex(name, ix, SvIVX(namesv),
3979                                       CvOUTSIDE(cv), cxstack_ix, 0, 0);
3980                 if (!off)
3981                     PL_curpad[ix] = SvREFCNT_inc(ppad[ix]);
3982                 else if (off != ix)
3983                     Perl_croak(aTHX_ "panic: cv_clone: %s", name);
3984             }
3985             else {                              /* our own lexical */
3986                 SV* sv;
3987                 if (*name == '&') {
3988                     /* anon code -- we'll come back for it */
3989                     sv = SvREFCNT_inc(ppad[ix]);
3990                 }
3991                 else if (*name == '@')
3992                     sv = (SV*)newAV();
3993                 else if (*name == '%')
3994                     sv = (SV*)newHV();
3995                 else
3996                     sv = NEWSV(0,0);
3997                 if (!SvPADBUSY(sv))
3998                     SvPADMY_on(sv);
3999                 PL_curpad[ix] = sv;
4000             }
4001         }
4002         else {
4003             SV* sv = NEWSV(0,0);
4004             SvPADTMP_on(sv);
4005             PL_curpad[ix] = sv;
4006         }
4007     }
4008
4009     /* Now that vars are all in place, clone nested closures. */
4010
4011     for (ix = fpad; ix > 0; ix--) {
4012         SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
4013         if (namesv
4014             && namesv != &PL_sv_undef
4015             && !(SvFLAGS(namesv) & SVf_FAKE)
4016             && *SvPVX(namesv) == '&'
4017             && CvCLONE(ppad[ix]))
4018         {
4019             CV *kid = cv_clone2((CV*)ppad[ix], cv);
4020             SvREFCNT_dec(ppad[ix]);
4021             CvCLONE_on(kid);
4022             SvPADMY_on(kid);
4023             PL_curpad[ix] = (SV*)kid;
4024         }
4025     }
4026
4027 #ifdef DEBUG_CLOSURES
4028     PerlIO_printf(Perl_debug_log, "Cloned inside:\n");
4029     cv_dump(outside);
4030     PerlIO_printf(Perl_debug_log, "  from:\n");
4031     cv_dump(proto);
4032     PerlIO_printf(Perl_debug_log, "   to:\n");
4033     cv_dump(cv);
4034 #endif
4035
4036     LEAVE;
4037     return cv;
4038 }
4039
4040 CV *
4041 Perl_cv_clone(pTHX_ CV *proto)
4042 {
4043     CV *cv;
4044     MUTEX_LOCK(&PL_cred_mutex);         /* XXX create separate mutex */
4045     cv = cv_clone2(proto, CvOUTSIDE(proto));
4046     MUTEX_UNLOCK(&PL_cred_mutex);       /* XXX create separate mutex */
4047     return cv;
4048 }
4049
4050 void
4051 Perl_cv_ckproto(pTHX_ CV *cv, GV *gv, char *p)
4052 {
4053     dTHR;
4054
4055     if (((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX(cv)))) && ckWARN_d(WARN_UNSAFE)) {
4056         SV* msg = sv_newmortal();
4057         SV* name = Nullsv;
4058
4059         if (gv)
4060             gv_efullname3(name = sv_newmortal(), gv, Nullch);
4061         sv_setpv(msg, "Prototype mismatch:");
4062         if (name)
4063             Perl_sv_catpvf(aTHX_ msg, " sub %_", name);
4064         if (SvPOK(cv))
4065             Perl_sv_catpvf(aTHX_ msg, " (%s)", SvPVX(cv));
4066         sv_catpv(msg, " vs ");
4067         if (p)
4068             Perl_sv_catpvf(aTHX_ msg, "(%s)", p);
4069         else
4070             sv_catpv(msg, "none");
4071         Perl_warner(aTHX_ WARN_UNSAFE, "%_", msg);
4072     }
4073 }
4074
4075 SV *
4076 Perl_cv_const_sv(pTHX_ CV *cv)
4077 {
4078     if (!cv || !SvPOK(cv) || SvCUR(cv))
4079         return Nullsv;
4080     return op_const_sv(CvSTART(cv), cv);
4081 }
4082
4083 SV *
4084 Perl_op_const_sv(pTHX_ OP *o, CV *cv)
4085 {
4086     SV *sv = Nullsv;
4087
4088     if(!o)
4089         return Nullsv;
4090
4091     if(o->op_type == OP_LINESEQ && cLISTOPo->op_first)
4092         o = cLISTOPo->op_first->op_sibling;
4093
4094     for (; o; o = o->op_next) {
4095         OPCODE type = o->op_type;
4096
4097         if (sv && o->op_next == o)
4098             return sv;
4099         if (type == OP_NEXTSTATE || type == OP_NULL || type == OP_PUSHMARK)
4100             continue;
4101         if (type == OP_LEAVESUB || type == OP_RETURN)
4102             break;
4103         if (sv)
4104             return Nullsv;
4105         if (type == OP_CONST)
4106             sv = cSVOPo->op_sv;
4107         else if (type == OP_PADSV && cv) {
4108             AV* padav = (AV*)(AvARRAY(CvPADLIST(cv))[1]);
4109             sv = padav ? AvARRAY(padav)[o->op_targ] : Nullsv;
4110             if (!sv || (!SvREADONLY(sv) && SvREFCNT(sv) > 1))
4111                 return Nullsv;
4112         }
4113         else
4114             return Nullsv;
4115     }
4116     if (sv)
4117         SvREADONLY_on(sv);
4118     return sv;
4119 }
4120
4121 void
4122 Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
4123 {
4124     if (o)
4125         SAVEFREEOP(o);
4126     if (proto)
4127         SAVEFREEOP(proto);
4128     if (attrs)
4129         SAVEFREEOP(attrs);
4130     if (block)
4131         SAVEFREEOP(block);
4132     Perl_croak(aTHX_ "\"my sub\" not yet implemented");
4133 }
4134
4135 CV *
4136 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
4137 {
4138     return Perl_newATTRSUB(aTHX_ floor, o, proto, Nullop, block);
4139 }
4140
4141 CV *
4142 Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
4143 {
4144     dTHR;
4145     STRLEN n_a;
4146     char *name = o ? SvPVx(cSVOPo->op_sv, n_a) : Nullch;
4147     GV *gv = gv_fetchpv(name ? name : "__ANON__",
4148                         GV_ADDMULTI | ((block || attrs) ? 0 : GV_NOINIT),
4149                         SVt_PVCV);
4150     char *ps = proto ? SvPVx(((SVOP*)proto)->op_sv, n_a) : Nullch;
4151     register CV *cv=0;
4152     I32 ix;
4153
4154     if (o)
4155         SAVEFREEOP(o);
4156     if (proto)
4157         SAVEFREEOP(proto);
4158     if (attrs)
4159         SAVEFREEOP(attrs);
4160
4161     if (SvTYPE(gv) != SVt_PVGV) {       /* Maybe prototype now, and had at
4162                                            maximum a prototype before. */
4163         if (SvTYPE(gv) > SVt_NULL) {
4164             if (!SvPOK((SV*)gv) && !(SvIOK((SV*)gv) && SvIVX((SV*)gv) == -1)
4165                 && ckWARN_d(WARN_UNSAFE))
4166             {
4167                 Perl_warner(aTHX_ WARN_UNSAFE, "Runaway prototype");
4168             }
4169             cv_ckproto((CV*)gv, NULL, ps);
4170         }
4171         if (ps)
4172             sv_setpv((SV*)gv, ps);
4173         else
4174             sv_setiv((SV*)gv, -1);
4175         SvREFCNT_dec(PL_compcv);
4176         cv = PL_compcv = NULL;
4177         PL_sub_generation++;
4178         goto noblock;
4179     }
4180
4181     if (!name || GvCVGEN(gv))
4182         cv = Nullcv;
4183     else if (cv = GvCV(gv)) {
4184         cv_ckproto(cv, gv, ps);
4185         /* already defined (or promised)? */
4186         if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
4187             SV* const_sv;
4188             bool const_changed = TRUE;
4189             if (!block && !attrs) {
4190                 /* just a "sub foo;" when &foo is already defined */
4191                 SAVEFREESV(PL_compcv);
4192                 goto done;
4193             }
4194             /* ahem, death to those who redefine active sort subs */
4195             if (PL_curstackinfo->si_type == PERLSI_SORT && PL_sortcop == CvSTART(cv))
4196                 Perl_croak(aTHX_ "Can't redefine active sort subroutine %s", name);
4197             if (!block)
4198                 goto withattrs;
4199             if(const_sv = cv_const_sv(cv))
4200                 const_changed = sv_cmp(const_sv, op_const_sv(block, Nullcv));
4201             if ((const_sv && const_changed) || ckWARN(WARN_REDEFINE)
4202                                         && !(CvGV(cv) && GvSTASH(CvGV(cv))
4203                                         && HvNAME(GvSTASH(CvGV(cv)))
4204                                         && strEQ(HvNAME(GvSTASH(CvGV(cv))),
4205                                                  "autouse"))) {
4206                 line_t oldline = PL_curcop->cop_line;
4207                 PL_curcop->cop_line = PL_copline;
4208                 Perl_warner(aTHX_ WARN_REDEFINE,
4209                         const_sv ? "Constant subroutine %s redefined"
4210                                  : "Subroutine %s redefined", name);
4211                 PL_curcop->cop_line = oldline;
4212             }
4213             SvREFCNT_dec(cv);
4214             cv = Nullcv;
4215         }
4216     }
4217   withattrs:
4218     if (attrs) {
4219         HV *stash;
4220         SV *rcv;
4221
4222         /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>
4223          * before we clobber PL_compcv.
4224          */
4225         if (cv && !block) {
4226             rcv = (SV*)cv;
4227             if (CvGV(cv) && GvSTASH(CvGV(cv)) && HvNAME(GvSTASH(CvGV(cv))))
4228                 stash = GvSTASH(CvGV(cv));
4229             else if (CvSTASH(cv) && HvNAME(CvSTASH(cv)))
4230                 stash = CvSTASH(cv);
4231             else
4232                 stash = PL_curstash;
4233         }
4234         else {
4235             /* possibly about to re-define existing subr -- ignore old cv */
4236             rcv = (SV*)PL_compcv;
4237             if (name && GvSTASH(gv) && HvNAME(GvSTASH(gv)))
4238                 stash = GvSTASH(gv);
4239             else
4240                 stash = PL_curstash;
4241         }
4242         apply_attrs(stash, rcv, attrs);
4243     }
4244     if (cv) {                           /* must reuse cv if autoloaded */
4245         if (!block) {
4246             /* got here with just attrs -- work done, so bug out */
4247             SAVEFREESV(PL_compcv);
4248             goto done;
4249         }
4250         cv_undef(cv);
4251         CvFLAGS(cv) = CvFLAGS(PL_compcv);
4252         CvOUTSIDE(cv) = CvOUTSIDE(PL_compcv);
4253         CvOUTSIDE(PL_compcv) = 0;
4254         CvPADLIST(cv) = CvPADLIST(PL_compcv);
4255         CvPADLIST(PL_compcv) = 0;
4256         if (SvREFCNT(PL_compcv) > 1) /* XXX Make closures transit through stub. */
4257             CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc((SV*)cv);
4258         SvREFCNT_dec(PL_compcv);
4259     }
4260     else {
4261         cv = PL_compcv;
4262         if (name) {
4263             GvCV(gv) = cv;
4264             GvCVGEN(gv) = 0;
4265             PL_sub_generation++;
4266         }
4267     }
4268     CvGV(cv) = (GV*)SvREFCNT_inc(gv);
4269     CvSTASH(cv) = PL_curstash;
4270 #ifdef USE_THREADS
4271     CvOWNER(cv) = 0;
4272     if (!CvMUTEXP(cv)) {
4273         New(666, CvMUTEXP(cv), 1, perl_mutex);
4274         MUTEX_INIT(CvMUTEXP(cv));
4275     }
4276 #endif /* USE_THREADS */
4277
4278     if (ps)
4279         sv_setpv((SV*)cv, ps);
4280
4281     if (PL_error_count) {
4282         op_free(block);
4283         block = Nullop;
4284         if (name) {
4285             char *s = strrchr(name, ':');
4286             s = s ? s+1 : name;
4287             if (strEQ(s, "BEGIN")) {
4288                 char *not_safe =
4289                     "BEGIN not safe after errors--compilation aborted";
4290                 if (PL_in_eval & EVAL_KEEPERR)
4291                     Perl_croak(aTHX_ not_safe);
4292                 else {
4293                     /* force display of errors found but not reported */
4294                     sv_catpv(ERRSV, not_safe);
4295                     Perl_croak(aTHX_ "%s", SvPVx(ERRSV, n_a));
4296                 }
4297             }
4298         }
4299     }
4300     if (!block) {
4301       noblock:
4302         PL_copline = NOLINE;
4303         LEAVE_SCOPE(floor);
4304         return cv;
4305     }
4306
4307     if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad))
4308         av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv);
4309
4310     if (CvCLONE(cv)) {
4311         SV **namep = AvARRAY(PL_comppad_name);
4312         for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4313             SV *namesv;
4314
4315             if (SvIMMORTAL(PL_curpad[ix]))
4316                 continue;
4317             /*
4318              * The only things that a clonable function needs in its
4319              * pad are references to outer lexicals and anonymous subs.
4320              * The rest are created anew during cloning.
4321              */
4322             if (!((namesv = namep[ix]) != Nullsv &&
4323                   namesv != &PL_sv_undef &&
4324                   (SvFAKE(namesv) ||
4325                    *SvPVX(namesv) == '&')))
4326             {
4327                 SvREFCNT_dec(PL_curpad[ix]);
4328                 PL_curpad[ix] = Nullsv;
4329             }
4330         }
4331     }
4332     else {
4333         AV *av = newAV();                       /* Will be @_ */
4334         av_extend(av, 0);
4335         av_store(PL_comppad, 0, (SV*)av);
4336         AvFLAGS(av) = AVf_REIFY;
4337
4338         for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4339             if (SvIMMORTAL(PL_curpad[ix]))
4340                 continue;
4341             if (!SvPADMY(PL_curpad[ix]))
4342                 SvPADTMP_on(PL_curpad[ix]);
4343         }
4344     }
4345
4346     if (CvLVALUE(cv)) {
4347         CvROOT(cv) = newUNOP(OP_LEAVESUBLV, 0, scalarseq(block));
4348     }
4349     else {
4350         CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
4351     }
4352     CvROOT(cv)->op_private |= OPpREFCOUNTED;
4353     OpREFCNT_set(CvROOT(cv), 1);
4354     CvSTART(cv) = LINKLIST(CvROOT(cv));
4355     CvROOT(cv)->op_next = 0;
4356     peep(CvSTART(cv));
4357
4358     if (name) {
4359         char *s;
4360
4361         if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
4362             SV *sv = NEWSV(0,0);
4363             SV *tmpstr = sv_newmortal();
4364             GV *db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
4365             CV *cv;
4366             HV *hv;
4367
4368             Perl_sv_setpvf(aTHX_ sv, "%_:%ld-%ld",
4369                            CopFILESV(PL_curcop),
4370                            (long)PL_subline, (long)CopLINE(PL_curcop));
4371             gv_efullname3(tmpstr, gv, Nullch);
4372             hv_store(GvHV(PL_DBsub), SvPVX(tmpstr), SvCUR(tmpstr), sv, 0);
4373             hv = GvHVn(db_postponed);
4374             if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX(tmpstr), SvCUR(tmpstr))
4375                   && (cv = GvCV(db_postponed))) {
4376                 dSP;
4377                 PUSHMARK(SP);
4378                 XPUSHs(tmpstr);
4379                 PUTBACK;
4380                 call_sv((SV*)cv, G_DISCARD);
4381             }
4382         }
4383
4384         if ((s = strrchr(name,':')))
4385             s++;
4386         else
4387             s = name;
4388         if (strEQ(s, "BEGIN")) {
4389             I32 oldscope = PL_scopestack_ix;
4390             ENTER;
4391             SAVESPTR(CopFILEGV(&PL_compiling));
4392             SAVEI16(PL_compiling.cop_line);
4393             save_svref(&PL_rs);
4394             sv_setsv(PL_rs, PL_nrs);
4395
4396             if (!PL_beginav)
4397                 PL_beginav = newAV();
4398             DEBUG_x( dump_sub(gv) );
4399             av_push(PL_beginav, (SV *)cv);
4400             GvCV(gv) = 0;
4401             call_list(oldscope, PL_beginav);
4402
4403             PL_curcop = &PL_compiling;
4404             PL_compiling.op_private = PL_hints;
4405             LEAVE;
4406         }
4407         else if (strEQ(s, "END") && !PL_error_count) {
4408             if (!PL_endav)
4409                 PL_endav = newAV();
4410             av_unshift(PL_endav, 1);
4411             av_store(PL_endav, 0, (SV *)cv);
4412             GvCV(gv) = 0;
4413         }
4414         else if (strEQ(s, "STOP") && !PL_error_count) {
4415             if (!PL_stopav)
4416                 PL_stopav = newAV();
4417             av_unshift(PL_stopav, 1);
4418             av_store(PL_stopav, 0, (SV *)cv);
4419             GvCV(gv) = 0;
4420         }
4421         else if (strEQ(s, "INIT") && !PL_error_count) {
4422             if (!PL_initav)
4423                 PL_initav = newAV();
4424             av_push(PL_initav, SvREFCNT_inc(cv));
4425             GvCV(gv) = 0;
4426         }
4427     }
4428
4429   done:
4430     PL_copline = NOLINE;
4431     LEAVE_SCOPE(floor);
4432     return cv;
4433 }
4434
4435 /* XXX unsafe for threads if eval_owner isn't held */
4436 void
4437 Perl_newCONSTSUB(pTHX_ HV *stash, char *name, SV *sv)
4438 {
4439     dTHR;
4440     U32 oldhints = PL_hints;
4441     HV *old_cop_stash = PL_curcop->cop_stash;
4442     HV *old_curstash = PL_curstash;
4443     line_t oldline = PL_curcop->cop_line;
4444     PL_curcop->cop_line = PL_copline;
4445
4446     PL_hints &= ~HINT_BLOCK_SCOPE;
4447     if(stash)
4448         PL_curstash = PL_curcop->cop_stash = stash;
4449
4450     newATTRSUB(
4451         start_subparse(FALSE, 0),
4452         newSVOP(OP_CONST, 0, newSVpv(name,0)),
4453         newSVOP(OP_CONST, 0, &PL_sv_no),        /* SvPV(&PL_sv_no) == "" -- GMB */
4454         Nullop,
4455         newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv))
4456     );
4457
4458     PL_hints = oldhints;
4459     PL_curcop->cop_stash = old_cop_stash;
4460     PL_curstash = old_curstash;
4461     PL_curcop->cop_line = oldline;
4462 }
4463
4464 CV *
4465 Perl_newXS(pTHX_ char *name, XSUBADDR_t subaddr, char *filename)
4466 {
4467     dTHR;
4468     GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI, SVt_PVCV);
4469     register CV *cv;
4470
4471     if (cv = (name ? GvCV(gv) : Nullcv)) {
4472         if (GvCVGEN(gv)) {
4473             /* just a cached method */
4474             SvREFCNT_dec(cv);
4475             cv = 0;
4476         }
4477         else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
4478             /* already defined (or promised) */
4479             if (ckWARN(WARN_REDEFINE) && !(CvGV(cv) && GvSTASH(CvGV(cv))
4480                             && HvNAME(GvSTASH(CvGV(cv)))
4481                             && strEQ(HvNAME(GvSTASH(CvGV(cv))), "autouse"))) {
4482                 line_t oldline = PL_curcop->cop_line;
4483                 if (PL_copline != NOLINE)
4484                     PL_curcop->cop_line = PL_copline;
4485                 Perl_warner(aTHX_ WARN_REDEFINE, "Subroutine %s redefined",name);
4486                 PL_curcop->cop_line = oldline;
4487             }
4488             SvREFCNT_dec(cv);
4489             cv = 0;
4490         }
4491     }
4492
4493     if (cv)                             /* must reuse cv if autoloaded */
4494         cv_undef(cv);
4495     else {
4496         cv = (CV*)NEWSV(1105,0);
4497         sv_upgrade((SV *)cv, SVt_PVCV);
4498         if (name) {
4499             GvCV(gv) = cv;
4500             GvCVGEN(gv) = 0;
4501             PL_sub_generation++;
4502         }
4503     }
4504     CvGV(cv) = (GV*)SvREFCNT_inc(gv);
4505 #ifdef USE_THREADS
4506     New(666, CvMUTEXP(cv), 1, perl_mutex);
4507     MUTEX_INIT(CvMUTEXP(cv));
4508     CvOWNER(cv) = 0;
4509 #endif /* USE_THREADS */
4510     (void)gv_fetchfile(filename);
4511     CvXSUB(cv) = subaddr;
4512
4513     if (name) {
4514         char *s = strrchr(name,':');
4515         if (s)
4516             s++;
4517         else
4518             s = name;
4519         if (strEQ(s, "BEGIN")) {
4520             if (!PL_beginav)
4521                 PL_beginav = newAV();
4522             av_push(PL_beginav, (SV *)cv);
4523             GvCV(gv) = 0;
4524         }
4525         else if (strEQ(s, "END")) {
4526             if (!PL_endav)
4527                 PL_endav = newAV();
4528             av_unshift(PL_endav, 1);
4529             av_store(PL_endav, 0, (SV *)cv);
4530             GvCV(gv) = 0;
4531         }
4532         else if (strEQ(s, "STOP")) {
4533             if (!PL_stopav)
4534                 PL_stopav = newAV();
4535             av_unshift(PL_stopav, 1);
4536             av_store(PL_stopav, 0, (SV *)cv);
4537             GvCV(gv) = 0;
4538         }
4539         else if (strEQ(s, "INIT")) {
4540             if (!PL_initav)
4541                 PL_initav = newAV();
4542             av_push(PL_initav, (SV *)cv);
4543             GvCV(gv) = 0;
4544         }
4545     }
4546     else
4547         CvANON_on(cv);
4548
4549     return cv;
4550 }
4551
4552 void
4553 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
4554 {
4555     dTHR;
4556     register CV *cv;
4557     char *name;
4558     GV *gv;
4559     I32 ix;
4560     STRLEN n_a;
4561
4562     if (o)
4563         name = SvPVx(cSVOPo->op_sv, n_a);
4564     else
4565         name = "STDOUT";
4566     gv = gv_fetchpv(name,TRUE, SVt_PVFM);
4567     GvMULTI_on(gv);
4568     if (cv = GvFORM(gv)) {
4569         if (ckWARN(WARN_REDEFINE)) {
4570             line_t oldline = PL_curcop->cop_line;
4571
4572             PL_curcop->cop_line = PL_copline;
4573             Perl_warner(aTHX_ WARN_REDEFINE, "Format %s redefined",name);
4574             PL_curcop->cop_line = oldline;
4575         }
4576         SvREFCNT_dec(cv);
4577     }
4578     cv = PL_compcv;
4579     GvFORM(gv) = cv;
4580     CvGV(cv) = (GV*)SvREFCNT_inc(gv);
4581
4582     for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
4583         if (!SvPADMY(PL_curpad[ix]) && !SvIMMORTAL(PL_curpad[ix]))
4584             SvPADTMP_on(PL_curpad[ix]);
4585     }
4586
4587     CvROOT(cv) = newUNOP(OP_LEAVEWRITE, 0, scalarseq(block));
4588     CvROOT(cv)->op_private |= OPpREFCOUNTED;
4589     OpREFCNT_set(CvROOT(cv), 1);
4590     CvSTART(cv) = LINKLIST(CvROOT(cv));
4591     CvROOT(cv)->op_next = 0;
4592     peep(CvSTART(cv));
4593     op_free(o);
4594     PL_copline = NOLINE;
4595     LEAVE_SCOPE(floor);
4596 }
4597
4598 OP *
4599 Perl_newANONLIST(pTHX_ OP *o)
4600 {
4601     return newUNOP(OP_REFGEN, 0,
4602         mod(list(convert(OP_ANONLIST, 0, o)), OP_REFGEN));
4603 }
4604
4605 OP *
4606 Perl_newANONHASH(pTHX_ OP *o)
4607 {
4608     return newUNOP(OP_REFGEN, 0,
4609         mod(list(convert(OP_ANONHASH, 0, o)), OP_REFGEN));
4610 }
4611
4612 OP *
4613 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
4614 {
4615     return newANONATTRSUB(floor, proto, Nullop, block);
4616 }
4617
4618 OP *
4619 Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block)
4620 {
4621     return newUNOP(OP_REFGEN, 0,
4622         newSVOP(OP_ANONCODE, 0,
4623                 (SV*)newATTRSUB(floor, 0, proto, attrs, block)));
4624 }
4625
4626 OP *
4627 Perl_oopsAV(pTHX_ OP *o)
4628 {
4629     switch (o->op_type) {
4630     case OP_PADSV:
4631         o->op_type = OP_PADAV;
4632         o->op_ppaddr = PL_ppaddr[OP_PADAV];
4633         return ref(o, OP_RV2AV);
4634
4635     case OP_RV2SV:
4636         o->op_type = OP_RV2AV;
4637         o->op_ppaddr = PL_ppaddr[OP_RV2AV];
4638         ref(o, OP_RV2AV);
4639         break;
4640
4641     default:
4642         if (ckWARN_d(WARN_INTERNAL))
4643             Perl_warner(aTHX_ WARN_INTERNAL, "oops: oopsAV");
4644         break;
4645     }
4646     return o;
4647 }
4648
4649 OP *
4650 Perl_oopsHV(pTHX_ OP *o)
4651 {
4652     dTHR;
4653
4654     switch (o->op_type) {
4655     case OP_PADSV:
4656     case OP_PADAV:
4657         o->op_type = OP_PADHV;
4658         o->op_ppaddr = PL_ppaddr[OP_PADHV];
4659         return ref(o, OP_RV2HV);
4660
4661     case OP_RV2SV:
4662     case OP_RV2AV:
4663         o->op_type = OP_RV2HV;
4664         o->op_ppaddr = PL_ppaddr[OP_RV2HV];
4665         ref(o, OP_RV2HV);
4666         break;
4667
4668     default:
4669         if (ckWARN_d(WARN_INTERNAL))
4670             Perl_warner(aTHX_ WARN_INTERNAL, "oops: oopsHV");
4671         break;
4672     }
4673     return o;
4674 }
4675
4676 OP *
4677 Perl_newAVREF(pTHX_ OP *o)
4678 {
4679     if (o->op_type == OP_PADANY) {
4680         o->op_type = OP_PADAV;
4681         o->op_ppaddr = PL_ppaddr[OP_PADAV];
4682         return o;
4683     }
4684     return newUNOP(OP_RV2AV, 0, scalar(o));
4685 }
4686
4687 OP *
4688 Perl_newGVREF(pTHX_ I32 type, OP *o)
4689 {
4690     if (type == OP_MAPSTART || type == OP_GREPSTART || type == OP_SORT)
4691         return newUNOP(OP_NULL, 0, o);
4692     return ref(newUNOP(OP_RV2GV, OPf_REF, o), type);
4693 }
4694
4695 OP *
4696 Perl_newHVREF(pTHX_ OP *o)
4697 {
4698     if (o->op_type == OP_PADANY) {
4699         o->op_type = OP_PADHV;
4700         o->op_ppaddr = PL_ppaddr[OP_PADHV];
4701         return o;
4702     }
4703     return newUNOP(OP_RV2HV, 0, scalar(o));
4704 }
4705
4706 OP *
4707 Perl_oopsCV(pTHX_ OP *o)
4708 {
4709     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
4710     /* STUB */
4711     return o;
4712 }
4713
4714 OP *
4715 Perl_newCVREF(pTHX_ I32 flags, OP *o)
4716 {
4717     return newUNOP(OP_RV2CV, flags, scalar(o));
4718 }
4719
4720 OP *
4721 Perl_newSVREF(pTHX_ OP *o)
4722 {
4723     if (o->op_type == OP_PADANY) {
4724         o->op_type = OP_PADSV;
4725         o->op_ppaddr = PL_ppaddr[OP_PADSV];
4726         return o;
4727     }
4728     else if (o->op_type == OP_THREADSV && !(o->op_flags & OPpDONE_SVREF)) {
4729         o->op_flags |= OPpDONE_SVREF;
4730         return o;
4731     }
4732     return newUNOP(OP_RV2SV, 0, scalar(o));
4733 }
4734
4735 /* Check routines. */
4736
4737 OP *
4738 Perl_ck_anoncode(pTHX_ OP *o)
4739 {
4740     PADOFFSET ix;
4741     SV* name;
4742
4743     name = NEWSV(1106,0);
4744     sv_upgrade(name, SVt_PVNV);
4745     sv_setpvn(name, "&", 1);
4746     SvIVX(name) = -1;
4747     SvNVX(name) = 1;
4748     ix = pad_alloc(o->op_type, SVs_PADMY);
4749     av_store(PL_comppad_name, ix, name);
4750     av_store(PL_comppad, ix, cSVOPo->op_sv);
4751     SvPADMY_on(cSVOPo->op_sv);
4752     cSVOPo->op_sv = Nullsv;
4753     cSVOPo->op_targ = ix;
4754     return o;
4755 }
4756
4757 OP *
4758 Perl_ck_bitop(pTHX_ OP *o)
4759 {
4760     o->op_private = PL_hints;
4761     return o;
4762 }
4763
4764 OP *
4765 Perl_ck_concat(pTHX_ OP *o)
4766 {
4767     if (cUNOPo->op_first->op_type == OP_CONCAT)
4768         o->op_flags |= OPf_STACKED;
4769     return o;
4770 }
4771
4772 OP *
4773 Perl_ck_spair(pTHX_ OP *o)
4774 {
4775     if (o->op_flags & OPf_KIDS) {
4776         OP* newop;
4777         OP* kid;
4778         OPCODE type = o->op_type;
4779         o = modkids(ck_fun(o), type);
4780         kid = cUNOPo->op_first;
4781         newop = kUNOP->op_first->op_sibling;
4782         if (newop &&
4783             (newop->op_sibling ||
4784              !(PL_opargs[newop->op_type] & OA_RETSCALAR) ||
4785              newop->op_type == OP_PADAV || newop->op_type == OP_PADHV ||
4786              newop->op_type == OP_RV2AV || newop->op_type == OP_RV2HV)) {
4787
4788             return o;
4789         }
4790         op_free(kUNOP->op_first);
4791         kUNOP->op_first = newop;
4792     }
4793     o->op_ppaddr = PL_ppaddr[++o->op_type];
4794     return ck_fun(o);
4795 }
4796
4797 OP *
4798 Perl_ck_delete(pTHX_ OP *o)
4799 {
4800     o = ck_fun(o);
4801     o->op_private = 0;
4802     if (o->op_flags & OPf_KIDS) {
4803         OP *kid = cUNOPo->op_first;
4804         if (kid->op_type == OP_HSLICE)
4805             o->op_private |= OPpSLICE;
4806         else if (kid->op_type != OP_HELEM)
4807             Perl_croak(aTHX_ "%s argument is not a HASH element or slice",
4808                   PL_op_desc[o->op_type]);
4809         null(kid);
4810     }
4811     return o;
4812 }
4813
4814 OP *
4815 Perl_ck_eof(pTHX_ OP *o)
4816 {
4817     I32 type = o->op_type;
4818
4819     if (o->op_flags & OPf_KIDS) {
4820         if (cLISTOPo->op_first->op_type == OP_STUB) {
4821             op_free(o);
4822             o = newUNOP(type, OPf_SPECIAL,
4823                 newGVOP(OP_GV, 0, gv_fetchpv("main::ARGV", TRUE, SVt_PVAV)));
4824         }
4825         return ck_fun(o);
4826     }
4827     return o;
4828 }
4829
4830 OP *
4831 Perl_ck_eval(pTHX_ OP *o)
4832 {
4833     PL_hints |= HINT_BLOCK_SCOPE;
4834     if (o->op_flags & OPf_KIDS) {
4835         SVOP *kid = (SVOP*)cUNOPo->op_first;
4836
4837         if (!kid) {
4838             o->op_flags &= ~OPf_KIDS;
4839             null(o);
4840         }
4841         else if (kid->op_type == OP_LINESEQ) {
4842             LOGOP *enter;
4843
4844             kid->op_next = o->op_next;
4845             cUNOPo->op_first = 0;
4846             op_free(o);
4847
4848             NewOp(1101, enter, 1, LOGOP);
4849             enter->op_type = OP_ENTERTRY;
4850             enter->op_ppaddr = PL_ppaddr[OP_ENTERTRY];
4851             enter->op_private = 0;
4852
4853             /* establish postfix order */
4854             enter->op_next = (OP*)enter;
4855
4856             o = prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
4857             o->op_type = OP_LEAVETRY;
4858             o->op_ppaddr = PL_ppaddr[OP_LEAVETRY];
4859             enter->op_other = o;
4860             return o;
4861         }
4862         else
4863             scalar((OP*)kid);
4864     }
4865     else {
4866         op_free(o);
4867         o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP());
4868     }
4869     o->op_targ = (PADOFFSET)PL_hints;
4870     return o;
4871 }
4872
4873 OP *
4874 Perl_ck_exec(pTHX_ OP *o)
4875 {
4876     OP *kid;
4877     if (o->op_flags & OPf_STACKED) {
4878         o = ck_fun(o);
4879         kid = cUNOPo->op_first->op_sibling;
4880         if (kid->op_type == OP_RV2GV)
4881             null(kid);
4882     }
4883     else
4884         o = listkids(o);
4885     return o;
4886 }
4887
4888 OP *
4889 Perl_ck_exists(pTHX_ OP *o)
4890 {
4891     o = ck_fun(o);
4892     if (o->op_flags & OPf_KIDS) {
4893         OP *kid = cUNOPo->op_first;
4894         if (kid->op_type != OP_HELEM)
4895             Perl_croak(aTHX_ "%s argument is not a HASH element", PL_op_desc[o->op_type]);
4896         null(kid);
4897     }
4898     return o;
4899 }
4900
4901 #if 0
4902 OP *
4903 Perl_ck_gvconst(pTHX_ register OP *o)
4904 {
4905     o = fold_constants(o);
4906     if (o->op_type == OP_CONST)
4907         o->op_type = OP_GV;
4908     return o;
4909 }
4910 #endif
4911
4912 OP *
4913 Perl_ck_rvconst(pTHX_ register OP *o)
4914 {
4915     dTHR;
4916     SVOP *kid = (SVOP*)cUNOPo->op_first;
4917
4918     o->op_private |= (PL_hints & HINT_STRICT_REFS);
4919     if (kid->op_type == OP_CONST) {
4920         char *name;
4921         int iscv;
4922         GV *gv;
4923         SV *kidsv = kid->op_sv;
4924         STRLEN n_a;
4925
4926         /* Is it a constant from cv_const_sv()? */
4927         if (SvROK(kidsv) && SvREADONLY(kidsv)) {
4928             SV *rsv = SvRV(kidsv);
4929             int svtype = SvTYPE(rsv);
4930             char *badtype = Nullch;
4931
4932             switch (o->op_type) {
4933             case OP_RV2SV:
4934                 if (svtype > SVt_PVMG)
4935                     badtype = "a SCALAR";
4936                 break;
4937             case OP_RV2AV:
4938                 if (svtype != SVt_PVAV)
4939                     badtype = "an ARRAY";
4940                 break;
4941             case OP_RV2HV:
4942                 if (svtype != SVt_PVHV) {
4943                     if (svtype == SVt_PVAV) {   /* pseudohash? */
4944                         SV **ksv = av_fetch((AV*)rsv, 0, FALSE);
4945                         if (ksv && SvROK(*ksv)
4946                             && SvTYPE(SvRV(*ksv)) == SVt_PVHV)
4947                         {
4948                                 break;
4949                         }
4950                     }
4951                     badtype = "a HASH";
4952                 }
4953                 break;
4954             case OP_RV2CV:
4955                 if (svtype != SVt_PVCV)
4956                     badtype = "a CODE";
4957                 break;
4958             }
4959             if (badtype)
4960                 Perl_croak(aTHX_ "Constant is not %s reference", badtype);
4961             return o;
4962         }
4963         name = SvPV(kidsv, n_a);
4964         if ((PL_hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
4965             char *badthing = Nullch;
4966             switch (o->op_type) {
4967             case OP_RV2SV:
4968                 badthing = "a SCALAR";
4969                 break;
4970             case OP_RV2AV:
4971                 badthing = "an ARRAY";
4972                 break;
4973             case OP_RV2HV:
4974                 badthing = "a HASH";
4975                 break;
4976             }
4977             if (badthing)
4978                 Perl_croak(aTHX_
4979           "Can't use bareword (\"%s\") as %s ref while \"strict refs\" in use",
4980                       name, badthing);
4981         }
4982         /*
4983          * This is a little tricky.  We only want to add the symbol if we
4984          * didn't add it in the lexer.  Otherwise we get duplicate strict
4985          * warnings.  But if we didn't add it in the lexer, we must at
4986          * least pretend like we wanted to add it even if it existed before,
4987          * or we get possible typo warnings.  OPpCONST_ENTERED says
4988          * whether the lexer already added THIS instance of this symbol.
4989          */
4990         iscv = (o->op_type == OP_RV2CV) * 2;
4991         do {
4992             gv = gv_fetchpv(name,
4993                 iscv | !(kid->op_private & OPpCONST_ENTERED),
4994                 iscv
4995                     ? SVt_PVCV
4996                     : o->op_type == OP_RV2SV
4997                         ? SVt_PV
4998                         : o->op_type == OP_RV2AV
4999                             ? SVt_PVAV
5000                             : o->op_type == OP_RV2HV
5001                                 ? SVt_PVHV
5002                                 : SVt_PVGV);
5003         } while (!gv && !(kid->op_private & OPpCONST_ENTERED) && !iscv++);
5004         if (gv) {
5005             kid->op_type = OP_GV;
5006             SvREFCNT_dec(kid->op_sv);
5007             kid->op_sv = SvREFCNT_inc(gv);
5008             kid->op_ppaddr = PL_ppaddr[OP_GV];
5009         }
5010     }
5011     return o;
5012 }
5013
5014 OP *
5015 Perl_ck_ftst(pTHX_ OP *o)
5016 {
5017     dTHR;
5018     I32 type = o->op_type;
5019
5020     if (o->op_flags & OPf_REF)
5021         return o;
5022
5023     if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
5024         SVOP *kid = (SVOP*)cUNOPo->op_first;
5025
5026         if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
5027             STRLEN n_a;
5028             OP *newop = newGVOP(type, OPf_REF,
5029                 gv_fetchpv(SvPVx(kid->op_sv, n_a), TRUE, SVt_PVIO));
5030             op_free(o);
5031             return newop;
5032         }
5033     }
5034     else {
5035         op_free(o);
5036         if (type == OP_FTTTY)
5037            return newGVOP(type, OPf_REF, gv_fetchpv("main::STDIN", TRUE,
5038                                 SVt_PVIO));
5039         else
5040             return newUNOP(type, 0, newDEFSVOP());
5041     }
5042     return o;
5043 }
5044
5045 OP *
5046 Perl_ck_fun(pTHX_ OP *o)
5047 {
5048     dTHR;
5049     register OP *kid;
5050     OP **tokid;
5051     OP *sibl;
5052     I32 numargs = 0;
5053     int type = o->op_type;
5054     register I32 oa = PL_opargs[type] >> OASHIFT;
5055
5056     if (o->op_flags & OPf_STACKED) {
5057         if ((oa & OA_OPTIONAL) && (oa >> 4) && !((oa >> 4) & OA_OPTIONAL))
5058             oa &= ~OA_OPTIONAL;
5059         else
5060             return no_fh_allowed(o);
5061     }
5062
5063     if (o->op_flags & OPf_KIDS) {
5064         STRLEN n_a;
5065         tokid = &cLISTOPo->op_first;
5066         kid = cLISTOPo->op_first;
5067         if (kid->op_type == OP_PUSHMARK ||
5068             kid->op_type == OP_NULL && kid->op_targ == OP_PUSHMARK)
5069         {
5070             tokid = &kid->op_sibling;
5071             kid = kid->op_sibling;
5072         }
5073         if (!kid && PL_opargs[type] & OA_DEFGV)
5074             *tokid = kid = newDEFSVOP();
5075
5076         while (oa && kid) {
5077             numargs++;
5078             sibl = kid->op_sibling;
5079             switch (oa & 7) {
5080             case OA_SCALAR:
5081                 /* list seen where single (scalar) arg expected? */
5082                 if (numargs == 1 && !(oa >> 4)
5083                     && kid->op_type == OP_LIST && type != OP_SCALAR)
5084                 {
5085                     return too_many_arguments(o,PL_op_desc[type]);
5086                 }
5087                 scalar(kid);
5088                 break;
5089             case OA_LIST:
5090                 if (oa < 16) {
5091                     kid = 0;
5092                     continue;
5093                 }
5094                 else
5095                     list(kid);
5096                 break;
5097             case OA_AVREF:
5098                 if (kid->op_type == OP_CONST &&
5099                     (kid->op_private & OPpCONST_BARE))
5100                 {
5101                     char *name = SvPVx(((SVOP*)kid)->op_sv, n_a);
5102                     OP *newop = newAVREF(newGVOP(OP_GV, 0,
5103                         gv_fetchpv(name, TRUE, SVt_PVAV) ));
5104                     if (ckWARN(WARN_SYNTAX))
5105                         Perl_warner(aTHX_ WARN_SYNTAX,
5106                             "Array @%s missing the @ in argument %"IVdf" of %s()",
5107                             name, (IV)numargs, PL_op_desc[type]);
5108                     op_free(kid);
5109                     kid = newop;
5110                     kid->op_sibling = sibl;
5111                     *tokid = kid;
5112                 }
5113                 else if (kid->op_type != OP_RV2AV && kid->op_type != OP_PADAV)
5114                     bad_type(numargs, "array", PL_op_desc[type], kid);
5115                 mod(kid, type);
5116                 break;
5117             case OA_HVREF:
5118                 if (kid->op_type == OP_CONST &&
5119                     (kid->op_private & OPpCONST_BARE))
5120                 {
5121                     char *name = SvPVx(((SVOP*)kid)->op_sv, n_a);
5122                     OP *newop = newHVREF(newGVOP(OP_GV, 0,
5123                         gv_fetchpv(name, TRUE, SVt_PVHV) ));
5124                     if (ckWARN(WARN_SYNTAX))
5125                         Perl_warner(aTHX_ WARN_SYNTAX,
5126                             "Hash %%%s missing the %% in argument %"IVdf" of %s()",
5127                             name, (IV)numargs, PL_op_desc[type]);
5128                     op_free(kid);
5129                     kid = newop;
5130                     kid->op_sibling = sibl;
5131                     *tokid = kid;
5132                 }
5133                 else if (kid->op_type != OP_RV2HV && kid->op_type != OP_PADHV)
5134                     bad_type(numargs, "hash", PL_op_desc[type], kid);
5135                 mod(kid, type);
5136                 break;
5137             case OA_CVREF:
5138                 {
5139                     OP *newop = newUNOP(OP_NULL, 0, kid);
5140                     kid->op_sibling = 0;
5141                     linklist(kid);
5142                     newop->op_next = newop;
5143                     kid = newop;
5144                     kid->op_sibling = sibl;
5145                     *tokid = kid;
5146                 }
5147                 break;
5148             case OA_FILEREF:
5149                 if (kid->op_type != OP_GV && kid->op_type != OP_RV2GV) {
5150                     if (kid->op_type == OP_CONST &&
5151                         (kid->op_private & OPpCONST_BARE))
5152                     {
5153                         OP *newop = newGVOP(OP_GV, 0,
5154                             gv_fetchpv(SvPVx(((SVOP*)kid)->op_sv, n_a), TRUE,
5155                                         SVt_PVIO) );
5156                         op_free(kid);
5157                         kid = newop;
5158                     }
5159                     else if (kid->op_type == OP_READLINE) {
5160                         /* neophyte patrol: open(<FH>), close(<FH>) etc. */
5161                         bad_type(numargs, "HANDLE", PL_op_desc[o->op_type], kid);
5162                     }
5163                     else {
5164                         I32 flags = OPf_SPECIAL;
5165                         I32 priv = 0;
5166                         /* is this op a FH constructor? */
5167                         if (is_handle_constructor(o,numargs)) {
5168                             flags   = 0;
5169                             /* Set a flag to tell rv2gv to vivify
5170                              * need to "prove" flag does not mean something
5171                              * else already - NI-S 1999/05/07
5172                              */
5173                             priv = OPpDEREF;
5174 #if 0
5175                             /* Helps with open($array[$n],...)
5176                                but is too simplistic - need to do selectively
5177                             */
5178                             mod(kid,type);
5179 #endif
5180                         }
5181                         kid->op_sibling = 0;
5182                         kid = newUNOP(OP_RV2GV, flags, scalar(kid));
5183                         if (priv) {
5184                             kid->op_private |= priv;
5185                         }
5186                     }
5187                     kid->op_sibling = sibl;
5188                     *tokid = kid;
5189                 }
5190                 scalar(kid);
5191                 break;
5192             case OA_SCALARREF:
5193                 mod(scalar(kid), type);
5194                 break;
5195             }
5196             oa >>= 4;
5197             tokid = &kid->op_sibling;
5198             kid = kid->op_sibling;
5199         }
5200         o->op_private |= numargs;
5201         if (kid)
5202             return too_many_arguments(o,PL_op_desc[o->op_type]);
5203         listkids(o);
5204     }
5205     else if (PL_opargs[type] & OA_DEFGV) {
5206         op_free(o);
5207         return newUNOP(type, 0, newDEFSVOP());
5208     }
5209
5210     if (oa) {
5211         while (oa & OA_OPTIONAL)
5212             oa >>= 4;
5213         if (oa && oa != OA_LIST)
5214             return too_few_arguments(o,PL_op_desc[o->op_type]);
5215     }
5216     return o;
5217 }
5218
5219 OP *
5220 Perl_ck_glob(pTHX_ OP *o)
5221 {
5222     GV *gv;
5223
5224     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
5225         append_elem(OP_GLOB, o, newDEFSVOP());
5226
5227     if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV)) && GvIMPORTED_CV(gv)))
5228         gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
5229
5230 #if defined(PERL_INTERNAL_GLOB) && !defined(MINIPERL_BUILD)
5231     /* XXX this can be tightened up and made more failsafe. */
5232     if (!gv) {
5233         OP *modname = newSVOP(OP_CONST, 0, newSVpvn("File::Glob", 10));
5234         modname->op_private |= OPpCONST_BARE;
5235         ENTER;
5236         utilize(1, start_subparse(FALSE, 0), Nullop, modname,
5237                 newSVOP(OP_CONST, 0, newSVpvn("globally", 8)));
5238         gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
5239         LEAVE;
5240     }
5241 #endif /* PERL_INTERNAL_GLOB && !MINIPERL_BUILD */
5242
5243     if (gv && GvIMPORTED_CV(gv)) {
5244         append_elem(OP_GLOB, o,
5245                     newSVOP(OP_CONST, 0, newSViv(PL_glob_index++)));
5246         o->op_type = OP_LIST;
5247         o->op_ppaddr = PL_ppaddr[OP_LIST];
5248         cLISTOPo->op_first->op_type = OP_PUSHMARK;
5249         cLISTOPo->op_first->op_ppaddr = PL_ppaddr[OP_PUSHMARK];
5250         o = newUNOP(OP_ENTERSUB, OPf_STACKED,
5251                     append_elem(OP_LIST, o,
5252                                 scalar(newUNOP(OP_RV2CV, 0,
5253                                                newGVOP(OP_GV, 0, gv)))));
5254         o = newUNOP(OP_NULL, 0, ck_subr(o));
5255         o->op_targ = OP_GLOB;           /* hint at what it used to be */
5256         return o;
5257     }
5258     gv = newGVgen("main");
5259     gv_IOadd(gv);
5260     append_elem(OP_GLOB, o, newGVOP(OP_GV, 0, gv));
5261     scalarkids(o);
5262     return ck_fun(o);
5263 }
5264
5265 OP *
5266 Perl_ck_grep(pTHX_ OP *o)
5267 {
5268     LOGOP *gwop;
5269     OP *kid;
5270     OPCODE type = o->op_type == OP_GREPSTART ? OP_GREPWHILE : OP_MAPWHILE;
5271
5272     o->op_ppaddr = PL_ppaddr[OP_GREPSTART];
5273     NewOp(1101, gwop, 1, LOGOP);
5274
5275     if (o->op_flags & OPf_STACKED) {
5276         OP* k;
5277         o = ck_sort(o);
5278         kid = cLISTOPo->op_first->op_sibling;
5279         for (k = cLISTOPo->op_first->op_sibling->op_next; k; k = k->op_next) {
5280             kid = k;
5281         }
5282         kid->op_next = (OP*)gwop;
5283         o->op_flags &= ~OPf_STACKED;
5284     }
5285     kid = cLISTOPo->op_first->op_sibling;
5286     if (type == OP_MAPWHILE)
5287         list(kid);
5288     else
5289         scalar(kid);
5290     o = ck_fun(o);
5291     if (PL_error_count)
5292         return o;
5293     kid = cLISTOPo->op_first->op_sibling;
5294     if (kid->op_type != OP_NULL)
5295         Perl_croak(aTHX_ "panic: ck_grep");
5296     kid = kUNOP->op_first;
5297
5298     gwop->op_type = type;
5299     gwop->op_ppaddr = PL_ppaddr[type];
5300     gwop->op_first = listkids(o);
5301     gwop->op_flags |= OPf_KIDS;
5302     gwop->op_private = 1;
5303     gwop->op_other = LINKLIST(kid);
5304     gwop->op_targ = pad_alloc(type, SVs_PADTMP);
5305     kid->op_next = (OP*)gwop;
5306
5307     kid = cLISTOPo->op_first->op_sibling;
5308     if (!kid || !kid->op_sibling)
5309         return too_few_arguments(o,PL_op_desc[o->op_type]);
5310     for (kid = kid->op_sibling; kid; kid = kid->op_sibling)
5311         mod(kid, OP_GREPSTART);
5312
5313     return (OP*)gwop;
5314 }
5315
5316 OP *
5317 Perl_ck_index(pTHX_ OP *o)
5318 {
5319     if (o->op_flags & OPf_KIDS) {
5320         OP *kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
5321         if (kid)
5322             kid = kid->op_sibling;                      /* get past "big" */
5323         if (kid && kid->op_type == OP_CONST)
5324             fbm_compile(((SVOP*)kid)->op_sv, 0);
5325     }
5326     return ck_fun(o);
5327 }
5328
5329 OP *
5330 Perl_ck_lengthconst(pTHX_ OP *o)
5331 {
5332     /* XXX length optimization goes here */
5333     return ck_fun(o);
5334 }
5335
5336 OP *
5337 Perl_ck_lfun(pTHX_ OP *o)
5338 {
5339     OPCODE type = o->op_type;
5340     return modkids(ck_fun(o), type);
5341 }
5342
5343 OP *
5344 Perl_ck_defined(pTHX_ OP *o)            /* 19990527 MJD */
5345 {
5346     dTHR;
5347     if ((o->op_flags & OPf_KIDS) && ckWARN(WARN_DEPRECATED)) {
5348         switch (cUNOPo->op_first->op_type) {
5349         case OP_RV2AV:
5350             break;                      /* Globals via GV can be undef */
5351         case OP_PADAV:
5352         case OP_AASSIGN:                /* Is this a good idea? */
5353             Perl_warner(aTHX_ WARN_DEPRECATED,
5354                         "defined(@array) is deprecated");
5355             Perl_warner(aTHX_ WARN_DEPRECATED,
5356                         "(Maybe you should just omit the defined()?)\n");
5357         break;
5358         case OP_RV2HV:
5359             break;                      /* Globals via GV can be undef */
5360         case OP_PADHV:
5361             Perl_warner(aTHX_ WARN_DEPRECATED,
5362                         "defined(%hash) is deprecated");
5363             Perl_warner(aTHX_ WARN_DEPRECATED,
5364                         "(Maybe you should just omit the defined()?)\n");
5365             break;
5366         default:
5367             /* no warning */
5368             break;
5369         }
5370     }
5371     return ck_rfun(o);
5372 }
5373
5374 OP *
5375 Perl_ck_rfun(pTHX_ OP *o)
5376 {
5377     OPCODE type = o->op_type;
5378     return refkids(ck_fun(o), type);
5379 }
5380
5381 OP *
5382 Perl_ck_listiob(pTHX_ OP *o)
5383 {
5384     register OP *kid;
5385
5386     kid = cLISTOPo->op_first;
5387     if (!kid) {
5388         o = force_list(o);
5389         kid = cLISTOPo->op_first;
5390     }
5391     if (kid->op_type == OP_PUSHMARK)
5392         kid = kid->op_sibling;
5393     if (kid && o->op_flags & OPf_STACKED)
5394         kid = kid->op_sibling;
5395     else if (kid && !kid->op_sibling) {         /* print HANDLE; */
5396         if (kid->op_type == OP_CONST && kid->op_private & OPpCONST_BARE) {
5397             o->op_flags |= OPf_STACKED; /* make it a filehandle */
5398             kid = newUNOP(OP_RV2GV, OPf_REF, scalar(kid));
5399             cLISTOPo->op_first->op_sibling = kid;
5400             cLISTOPo->op_last = kid;
5401             kid = kid->op_sibling;
5402         }
5403     }
5404
5405     if (!kid)
5406         append_elem(o->op_type, o, newDEFSVOP());
5407
5408     o = listkids(o);
5409
5410     o->op_private = 0;
5411 #ifdef USE_LOCALE
5412     if (PL_hints & HINT_LOCALE)
5413         o->op_private |= OPpLOCALE;
5414 #endif
5415
5416     return o;
5417 }
5418
5419 OP *
5420 Perl_ck_fun_locale(pTHX_ OP *o)
5421 {
5422     o = ck_fun(o);
5423
5424     o->op_private = 0;
5425 #ifdef USE_LOCALE
5426     if (PL_hints & HINT_LOCALE)
5427         o->op_private |= OPpLOCALE;
5428 #endif
5429
5430     return o;
5431 }
5432
5433 OP *
5434 Perl_ck_sassign(pTHX_ OP *o)
5435 {
5436     OP *kid = cLISTOPo->op_first;
5437     /* has a disposable target? */
5438     if ((PL_opargs[kid->op_type] & OA_TARGLEX)
5439         && !(kid->op_flags & OPf_STACKED))
5440     {
5441         OP *kkid = kid->op_sibling;
5442
5443         /* Can just relocate the target. */
5444         if (kkid && kkid->op_type == OP_PADSV
5445             && !(kkid->op_private & OPpLVAL_INTRO))
5446         {
5447             /* Concat has problems if target is equal to right arg. */
5448             if (kid->op_type == OP_CONCAT) {
5449                 if (kLISTOP->op_first->op_sibling->op_type == OP_PADSV
5450                     && kLISTOP->op_first->op_sibling->op_targ == kkid->op_targ)
5451                     return o;
5452             }
5453             else if (kid->op_type == OP_JOIN) {
5454                 /* do_join has problems if the arguments coincide with target.
5455                    In fact the second argument *can* safely coincide,
5456                    but ignore=pessimize this rare occasion. */
5457                 OP *arg = kLISTOP->op_first->op_sibling; /* Skip PUSHMARK */
5458
5459                 while (arg) {
5460                     if (arg->op_type == OP_PADSV
5461                         && arg->op_targ == kkid->op_targ)
5462                         return o;
5463                     arg = arg->op_sibling;
5464                 }
5465             }
5466             else if (kid->op_type == OP_QUOTEMETA) {
5467                 /* quotemeta has problems if the argument coincides with target. */
5468                 if (kLISTOP->op_first->op_type == OP_PADSV
5469                     && kLISTOP->op_first->op_targ == kkid->op_targ)
5470                     return o;
5471             }
5472             kid->op_targ = kkid->op_targ;
5473             /* Now we do not need PADSV and SASSIGN. */
5474             kid->op_sibling = o->op_sibling;    /* NULL */
5475             cLISTOPo->op_first = NULL;
5476             op_free(o);
5477             op_free(kkid);
5478             kid->op_private |= OPpTARGET_MY;    /* Used for context settings */
5479             return kid;
5480         }
5481     }
5482     return o;
5483 }
5484
5485 OP *
5486 Perl_ck_scmp(pTHX_ OP *o)
5487 {
5488     o->op_private = 0;
5489 #ifdef USE_LOCALE
5490     if (PL_hints & HINT_LOCALE)
5491         o->op_private |= OPpLOCALE;
5492 #endif
5493
5494     return o;
5495 }
5496
5497 OP *
5498 Perl_ck_match(pTHX_ OP *o)
5499 {
5500     o->op_private |= OPpRUNTIME;
5501     return o;
5502 }
5503
5504 OP *
5505 Perl_ck_method(pTHX_ OP *o)
5506 {
5507     OP *kid = cUNOPo->op_first;
5508     if (kid->op_type == OP_CONST) {
5509         SV* sv = kSVOP->op_sv;
5510         if (!(strchr(SvPVX(sv), ':') || strchr(SvPVX(sv), '\''))) {
5511             OP *cmop;
5512             sv_upgrade(sv, SVt_PVIV);
5513             SvIOK_on(sv);
5514             PERL_HASH(SvUVX(sv), SvPVX(sv), SvCUR(sv));
5515             cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
5516             kSVOP->op_sv = Nullsv;
5517             op_free(o);
5518             return cmop;
5519         }
5520     }
5521     return o;
5522 }
5523
5524 OP *
5525 Perl_ck_null(pTHX_ OP *o)
5526 {
5527     return o;
5528 }
5529
5530 OP *
5531 Perl_ck_repeat(pTHX_ OP *o)
5532 {
5533     if (cBINOPo->op_first->op_flags & OPf_PARENS) {
5534         o->op_private |= OPpREPEAT_DOLIST;
5535         cBINOPo->op_first = force_list(cBINOPo->op_first);
5536     }
5537     else
5538         scalar(o);
5539     return o;
5540 }
5541
5542 OP *
5543 Perl_ck_require(pTHX_ OP *o)
5544 {
5545     if (o->op_flags & OPf_KIDS) {       /* Shall we supply missing .pm? */
5546         SVOP *kid = (SVOP*)cUNOPo->op_first;
5547
5548         if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
5549             char *s;
5550             for (s = SvPVX(kid->op_sv); *s; s++) {
5551                 if (*s == ':' && s[1] == ':') {
5552                     *s = '/';
5553                     Move(s+2, s+1, strlen(s+2)+1, char);
5554                     --SvCUR(kid->op_sv);
5555                 }
5556             }
5557             sv_catpvn(kid->op_sv, ".pm", 3);
5558         }
5559     }
5560     return ck_fun(o);
5561 }
5562
5563 #if 0
5564 OP *
5565 Perl_ck_retarget(pTHX_ OP *o)
5566 {
5567     Perl_croak(aTHX_ "NOT IMPL LINE %d",__LINE__);
5568     /* STUB */
5569     return o;
5570 }
5571 #endif
5572
5573 OP *
5574 Perl_ck_select(pTHX_ OP *o)
5575 {
5576     OP* kid;
5577     if (o->op_flags & OPf_KIDS) {
5578         kid = cLISTOPo->op_first->op_sibling;   /* get past pushmark */
5579         if (kid && kid->op_sibling) {
5580             o->op_type = OP_SSELECT;
5581             o->op_ppaddr = PL_ppaddr[OP_SSELECT];
5582             o = ck_fun(o);
5583             return fold_constants(o);
5584         }
5585     }
5586     o = ck_fun(o);
5587     kid = cLISTOPo->op_first->op_sibling;    /* get past pushmark */
5588     if (kid && kid->op_type == OP_RV2GV)
5589         kid->op_private &= ~HINT_STRICT_REFS;
5590     return o;
5591 }
5592
5593 OP *
5594 Perl_ck_shift(pTHX_ OP *o)
5595 {
5596     I32 type = o->op_type;
5597
5598     if (!(o->op_flags & OPf_KIDS)) {
5599         OP *argop;
5600
5601         op_free(o);
5602 #ifdef USE_THREADS
5603         if (!CvUNIQUE(PL_compcv)) {
5604             argop = newOP(OP_PADAV, OPf_REF);
5605             argop->op_targ = 0;         /* PL_curpad[0] is @_ */
5606         }
5607         else {
5608             argop = newUNOP(OP_RV2AV, 0,
5609                 scalar(newGVOP(OP_GV, 0,
5610                     gv_fetchpv("ARGV", TRUE, SVt_PVAV))));
5611         }
5612 #else
5613         argop = newUNOP(OP_RV2AV, 0,
5614             scalar(newGVOP(OP_GV, 0, !CvUNIQUE(PL_compcv) ?
5615                            PL_defgv : gv_fetchpv("ARGV", TRUE, SVt_PVAV))));
5616 #endif /* USE_THREADS */
5617         return newUNOP(type, 0, scalar(argop));
5618     }
5619     return scalar(modkids(ck_fun(o), type));
5620 }
5621
5622 OP *
5623 Perl_ck_sort(pTHX_ OP *o)
5624 {
5625     o->op_private = 0;
5626 #ifdef USE_LOCALE
5627     if (PL_hints & HINT_LOCALE)
5628         o->op_private |= OPpLOCALE;
5629 #endif
5630
5631     if (o->op_type == OP_SORT && o->op_flags & OPf_STACKED)
5632         simplify_sort(o);
5633     if (o->op_flags & OPf_STACKED) {                 /* may have been cleared */
5634         OP *kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
5635         OP *k;
5636         kid = kUNOP->op_first;                          /* get past null */
5637
5638         if (kid->op_type == OP_SCOPE || kid->op_type == OP_LEAVE) {
5639             linklist(kid);
5640             if (kid->op_type == OP_SCOPE) {
5641                 k = kid->op_next;
5642                 kid->op_next = 0;
5643             }
5644             else if (kid->op_type == OP_LEAVE) {
5645                 if (o->op_type == OP_SORT) {
5646                     null(kid);                  /* wipe out leave */
5647                     kid->op_next = kid;
5648
5649                     for (k = kLISTOP->op_first->op_next; k; k = k->op_next) {
5650                         if (k->op_next == kid)
5651                             k->op_next = 0;
5652                     }
5653                 }
5654                 else
5655                     kid->op_next = 0;           /* just disconnect the leave */
5656                 k = kLISTOP->op_first;
5657             }
5658             peep(k);
5659
5660             kid = cLISTOPo->op_first->op_sibling;       /* get past pushmark */
5661             if (o->op_type == OP_SORT)
5662                 kid->op_next = kid;
5663             else
5664                 kid->op_next = k;
5665             o->op_flags |= OPf_SPECIAL;
5666         }
5667         else if (kid->op_type == OP_RV2SV || kid->op_type == OP_PADSV)
5668             null(cLISTOPo->op_first->op_sibling);
5669     }
5670
5671     return o;
5672 }
5673
5674 STATIC void
5675 S_simplify_sort(pTHX_ OP *o)
5676 {
5677     dTHR;
5678     register OP *kid = cLISTOPo->op_first->op_sibling;  /* get past pushmark */
5679     OP *k;
5680     int reversed;
5681     if (!(o->op_flags & OPf_STACKED))
5682         return;
5683     GvMULTI_on(gv_fetchpv("a", TRUE, SVt_PV));
5684     GvMULTI_on(gv_fetchpv("b", TRUE, SVt_PV));
5685     kid = kUNOP->op_first;                              /* get past null */
5686     if (kid->op_type != OP_SCOPE)
5687         return;
5688     kid = kLISTOP->op_last;                             /* get past scope */
5689     switch(kid->op_type) {
5690         case OP_NCMP:
5691         case OP_I_NCMP:
5692         case OP_SCMP:
5693             break;
5694         default:
5695             return;
5696     }
5697     k = kid;                                            /* remember this node*/
5698     if (kBINOP->op_first->op_type != OP_RV2SV)
5699         return;
5700     kid = kBINOP->op_first;                             /* get past cmp */
5701     if (kUNOP->op_first->op_type != OP_GV)
5702         return;
5703     kid = kUNOP->op_first;                              /* get past rv2sv */
5704     if (GvSTASH((GV*)kSVOP->op_sv) != PL_curstash)
5705         return;
5706     if (strEQ(GvNAME((GV*)kSVOP->op_sv), "a"))
5707         reversed = 0;
5708     else if(strEQ(GvNAME((GV*)kSVOP->op_sv), "b"))
5709         reversed = 1;
5710     else
5711         return;
5712     kid = k;                                            /* back to cmp */
5713     if (kBINOP->op_last->op_type != OP_RV2SV)
5714         return;
5715     kid = kBINOP->op_last;                              /* down to 2nd arg */
5716     if (kUNOP->op_first->op_type != OP_GV)
5717         return;
5718     kid = kUNOP->op_first;                              /* get past rv2sv */
5719     if (GvSTASH((GV*)kSVOP->op_sv) != PL_curstash
5720         || ( reversed
5721             ? strNE(GvNAME((GV*)kSVOP->op_sv), "a")
5722             : strNE(GvNAME((GV*)kSVOP->op_sv), "b")))
5723         return;
5724     o->op_flags &= ~(OPf_STACKED | OPf_SPECIAL);
5725     if (reversed)
5726         o->op_private |= OPpSORT_REVERSE;
5727     if (k->op_type == OP_NCMP)
5728         o->op_private |= OPpSORT_NUMERIC;
5729     if (k->op_type == OP_I_NCMP)
5730         o->op_private |= OPpSORT_NUMERIC | OPpSORT_INTEGER;
5731     kid = cLISTOPo->op_first->op_sibling;
5732     cLISTOPo->op_first->op_sibling = kid->op_sibling; /* bypass old block */
5733     op_free(kid);                                     /* then delete it */
5734     cLISTOPo->op_children--;
5735 }
5736
5737 OP *
5738 Perl_ck_split(pTHX_ OP *o)
5739 {
5740     register OP *kid;
5741
5742     if (o->op_flags & OPf_STACKED)
5743         return no_fh_allowed(o);
5744
5745     kid = cLISTOPo->op_first;
5746     if (kid->op_type != OP_NULL)
5747         Perl_croak(aTHX_ "panic: ck_split");
5748     kid = kid->op_sibling;
5749     op_free(cLISTOPo->op_first);
5750     cLISTOPo->op_first = kid;
5751     if (!kid) {
5752         cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvn(" ", 1));
5753         cLISTOPo->op_last = kid; /* There was only one element previously */
5754     }
5755
5756     if (kid->op_type != OP_MATCH) {
5757         OP *sibl = kid->op_sibling;
5758         kid->op_sibling = 0;
5759         kid = pmruntime( newPMOP(OP_MATCH, OPf_SPECIAL), kid, Nullop);
5760         if (cLISTOPo->op_first == cLISTOPo->op_last)
5761             cLISTOPo->op_last = kid;
5762         cLISTOPo->op_first = kid;
5763         kid->op_sibling = sibl;
5764     }
5765
5766     kid->op_type = OP_PUSHRE;
5767     kid->op_ppaddr = PL_ppaddr[OP_PUSHRE];
5768     scalar(kid);
5769
5770     if (!kid->op_sibling)
5771         append_elem(OP_SPLIT, o, newDEFSVOP());
5772
5773     kid = kid->op_sibling;
5774     scalar(kid);
5775
5776     if (!kid->op_sibling)
5777         append_elem(OP_SPLIT, o, newSVOP(OP_CONST, 0, newSViv(0)));
5778
5779     kid = kid->op_sibling;
5780     scalar(kid);
5781
5782     if (kid->op_sibling)
5783         return too_many_arguments(o,PL_op_desc[o->op_type]);
5784
5785     return o;
5786 }
5787
5788 OP *
5789 Perl_ck_join(pTHX_ OP *o)
5790 {
5791     if (ckWARN(WARN_SYNTAX)) {
5792         OP *kid = cLISTOPo->op_first->op_sibling;
5793         if (kid && kid->op_type == OP_MATCH) {
5794             char *pmstr = "STRING";
5795             if (kPMOP->op_pmregexp)
5796                 pmstr = kPMOP->op_pmregexp->precomp;
5797             Perl_warner(aTHX_ WARN_SYNTAX,
5798                         "/%s/ should probably be written as \"%s\"",
5799                         pmstr, pmstr);
5800         }
5801     }
5802     return ck_fun(o);
5803 }
5804
5805 OP *
5806 Perl_ck_subr(pTHX_ OP *o)
5807 {
5808     dTHR;
5809     OP *prev = ((cUNOPo->op_first->op_sibling)
5810              ? cUNOPo : ((UNOP*)cUNOPo->op_first))->op_first;
5811     OP *o2 = prev->op_sibling;
5812     OP *cvop;
5813     char *proto = 0;
5814     CV *cv = 0;
5815     GV *namegv = 0;
5816     int optional = 0;
5817     I32 arg = 0;
5818     STRLEN n_a;
5819
5820     o->op_private |= OPpENTERSUB_HASTARG;
5821     for (cvop = o2; cvop->op_sibling; cvop = cvop->op_sibling) ;
5822     if (cvop->op_type == OP_RV2CV) {
5823         SVOP* tmpop;
5824         o->op_private |= (cvop->op_private & OPpENTERSUB_AMPER);
5825         null(cvop);             /* disable rv2cv */
5826         tmpop = (SVOP*)((UNOP*)cvop)->op_first;
5827         if (tmpop->op_type == OP_GV && !(o->op_private & OPpENTERSUB_AMPER)) {
5828             cv = GvCVu(tmpop->op_sv);
5829             if (!cv)
5830                 tmpop->op_private |= OPpEARLY_CV;
5831             else if (SvPOK(cv)) {
5832                 namegv = CvANON(cv) ? (GV*)tmpop->op_sv : CvGV(cv);
5833                 proto = SvPV((SV*)cv, n_a);
5834             }
5835         }
5836     }
5837     else if (cvop->op_type == OP_METHOD || cvop->op_type == OP_METHOD_NAMED) {
5838         if (o2->op_type == OP_CONST)
5839             o2->op_private &= ~OPpCONST_STRICT;
5840         else if (o2->op_type == OP_LIST) {
5841             OP *o = ((UNOP*)o2)->op_first->op_sibling;
5842             if (o && o->op_type == OP_CONST)
5843                 o->op_private &= ~OPpCONST_STRICT;
5844         }
5845     }
5846     o->op_private |= (PL_hints & HINT_STRICT_REFS);
5847     if (PERLDB_SUB && PL_curstash != PL_debstash)
5848         o->op_private |= OPpENTERSUB_DB;
5849     while (o2 != cvop) {
5850         if (proto) {
5851             switch (*proto) {
5852             case '\0':
5853                 return too_many_arguments(o, gv_ename(namegv));
5854             case ';':
5855                 optional = 1;
5856                 proto++;
5857                 continue;
5858             case '$':
5859                 proto++;
5860                 arg++;
5861                 scalar(o2);
5862                 break;
5863             case '%':
5864             case '@':
5865                 list(o2);
5866                 arg++;
5867                 break;
5868             case '&':
5869                 proto++;
5870                 arg++;
5871                 if (o2->op_type != OP_REFGEN && o2->op_type != OP_UNDEF)
5872                     bad_type(arg, "block", gv_ename(namegv), o2);
5873                 break;
5874             case '*':
5875                 /* '*' allows any scalar type, including bareword */
5876                 proto++;
5877                 arg++;
5878                 if (o2->op_type == OP_RV2GV)
5879                     goto wrapref;       /* autoconvert GLOB -> GLOBref */
5880                 else if (o2->op_type == OP_CONST)
5881                     o2->op_private &= ~OPpCONST_STRICT;
5882                 else if (o2->op_type == OP_ENTERSUB) {
5883                     /* accidental subroutine, revert to bareword */
5884                     OP *gvop = ((UNOP*)o2)->op_first;
5885                     if (gvop && gvop->op_type == OP_NULL) {
5886                         gvop = ((UNOP*)gvop)->op_first;
5887                         if (gvop) {
5888                             for (; gvop->op_sibling; gvop = gvop->op_sibling)
5889                                 ;
5890                             if (gvop &&
5891                                 (gvop->op_private & OPpENTERSUB_NOPAREN) &&
5892                                 (gvop = ((UNOP*)gvop)->op_first) &&
5893                                 gvop->op_type == OP_GV)
5894                             {
5895                                 GV *gv = (GV*)((SVOP*)gvop)->op_sv;
5896                                 OP *sibling = o2->op_sibling;
5897                                 SV *n = newSVpvn("",0);
5898                                 op_free(o2);
5899                                 gv_fullname3(n, gv, "");
5900                                 if (SvCUR(n)>6 && strnEQ(SvPVX(n),"main::",6))
5901                                     sv_chop(n, SvPVX(n)+6);
5902                                 o2 = newSVOP(OP_CONST, 0, n);
5903                                 prev->op_sibling = o2;
5904                                 o2->op_sibling = sibling;
5905                             }
5906                         }
5907                     }
5908                 }
5909                 scalar(o2);
5910                 break;
5911             case '\\':
5912                 proto++;
5913                 arg++;
5914                 switch (*proto++) {
5915                 case '*':
5916                     if (o2->op_type != OP_RV2GV)
5917                         bad_type(arg, "symbol", gv_ename(namegv), o2);
5918                     goto wrapref;
5919                 case '&':
5920                     if (o2->op_type != OP_RV2CV)
5921                         bad_type(arg, "sub", gv_ename(namegv), o2);
5922                     goto wrapref;
5923                 case '$':
5924                     if (o2->op_type != OP_RV2SV
5925                         && o2->op_type != OP_PADSV
5926                         && o2->op_type != OP_HELEM
5927                         && o2->op_type != OP_AELEM
5928                         && o2->op_type != OP_THREADSV)
5929                     {
5930                         bad_type(arg, "scalar", gv_ename(namegv), o2);
5931                     }
5932                     goto wrapref;
5933                 case '@':
5934                     if (o2->op_type != OP_RV2AV && o2->op_type != OP_PADAV)
5935                         bad_type(arg, "array", gv_ename(namegv), o2);
5936                     goto wrapref;
5937                 case '%':
5938                     if (o2->op_type != OP_RV2HV && o2->op_type != OP_PADHV)
5939                         bad_type(arg, "hash", gv_ename(namegv), o2);
5940                   wrapref:
5941                     {
5942                         OP* kid = o2;
5943                         OP* sib = kid->op_sibling;
5944                         kid->op_sibling = 0;
5945                         o2 = newUNOP(OP_REFGEN, 0, kid);
5946                         o2->op_sibling = sib;
5947                         prev->op_sibling = o2;
5948                     }
5949                     break;
5950                 default: goto oops;
5951                 }
5952                 break;
5953             case ' ':
5954                 proto++;
5955                 continue;
5956             default:
5957               oops:
5958                 Perl_croak(aTHX_ "Malformed prototype for %s: %s",
5959                         gv_ename(namegv), SvPV((SV*)cv, n_a));
5960             }
5961         }
5962         else
5963             list(o2);
5964         mod(o2, OP_ENTERSUB);
5965         prev = o2;
5966         o2 = o2->op_sibling;
5967     }
5968     if (proto && !optional &&
5969           (*proto && *proto != '@' && *proto != '%' && *proto != ';'))
5970         return too_few_arguments(o, gv_ename(namegv));
5971     return o;
5972 }
5973
5974 OP *
5975 Perl_ck_svconst(pTHX_ OP *o)
5976 {
5977     SvREADONLY_on(cSVOPo->op_sv);
5978     return o;
5979 }
5980
5981 OP *
5982 Perl_ck_trunc(pTHX_ OP *o)
5983 {
5984     if (o->op_flags & OPf_KIDS) {
5985         SVOP *kid = (SVOP*)cUNOPo->op_first;
5986
5987         if (kid->op_type == OP_NULL)
5988             kid = (SVOP*)kid->op_sibling;
5989         if (kid && kid->op_type == OP_CONST &&
5990             (kid->op_private & OPpCONST_BARE))
5991         {
5992             o->op_flags |= OPf_SPECIAL;
5993             kid->op_private &= ~OPpCONST_STRICT;
5994         }
5995     }
5996     return ck_fun(o);
5997 }
5998
5999 /* A peephole optimizer.  We visit the ops in the order they're to execute. */
6000
6001 void
6002 Perl_peep(pTHX_ register OP *o)
6003 {
6004     dTHR;
6005     register OP* oldop = 0;
6006     STRLEN n_a;
6007     OP *last_composite = Nullop;
6008
6009     if (!o || o->op_seq)
6010         return;
6011     ENTER;
6012     SAVEOP();
6013     SAVESPTR(PL_curcop);
6014     for (; o; o = o->op_next) {
6015         if (o->op_seq)
6016             break;
6017         if (!PL_op_seqmax)
6018             PL_op_seqmax++;
6019         PL_op = o;
6020         switch (o->op_type) {
6021         case OP_SETSTATE:
6022         case OP_NEXTSTATE:
6023         case OP_DBSTATE:
6024             PL_curcop = ((COP*)o);              /* for warnings */
6025             o->op_seq = PL_op_seqmax++;
6026             last_composite = Nullop;
6027             break;
6028
6029         case OP_CONST:
6030             if (cSVOPo->op_private & OPpCONST_STRICT)
6031                 no_bareword_allowed(o);
6032             /* FALL THROUGH */
6033         case OP_UC:
6034         case OP_UCFIRST:
6035         case OP_LC:
6036         case OP_LCFIRST:
6037             if ( o->op_next && o->op_next->op_type == OP_STRINGIFY
6038                  && !(o->op_next->op_private & OPpTARGET_MY) )
6039                 null(o->op_next);
6040             o->op_seq = PL_op_seqmax++;
6041             break;
6042         case OP_CONCAT:
6043         case OP_JOIN:
6044         case OP_QUOTEMETA:
6045             if (o->op_next && o->op_next->op_type == OP_STRINGIFY) {
6046                 if (o->op_next->op_private & OPpTARGET_MY) {
6047                     if ((o->op_flags & OPf_STACKED) /* chained concats */
6048                         || (o->op_type == OP_CONCAT
6049             /* Concat has problems if target is equal to right arg. */
6050                             && (((LISTOP*)o)->op_first->op_sibling->op_type
6051                                 == OP_PADSV)
6052                             && (((LISTOP*)o)->op_first->op_sibling->op_targ
6053                                 == o->op_next->op_targ))) {
6054                         goto ignore_optimization;
6055                     }
6056                     else {
6057                         o->op_targ = o->op_next->op_targ;
6058                         o->op_private |= OPpTARGET_MY;
6059                     }
6060                 }
6061                 null(o->op_next);
6062             }
6063           ignore_optimization:
6064             o->op_seq = PL_op_seqmax++;
6065             break;
6066         case OP_STUB:
6067             if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
6068                 o->op_seq = PL_op_seqmax++;
6069                 break; /* Scalar stub must produce undef.  List stub is noop */
6070             }
6071             goto nothin;
6072         case OP_NULL:
6073             if (o->op_targ == OP_NEXTSTATE
6074                 || o->op_targ == OP_DBSTATE
6075                 || o->op_targ == OP_SETSTATE)
6076             {
6077                 PL_curcop = ((COP*)o);
6078             }
6079             goto nothin;
6080         case OP_SCALAR:
6081         case OP_LINESEQ:
6082         case OP_SCOPE:
6083           nothin:
6084             if (oldop && o->op_next) {
6085                 oldop->op_next = o->op_next;
6086                 continue;
6087             }
6088             o->op_seq = PL_op_seqmax++;
6089             break;
6090
6091         case OP_GV:
6092             if (o->op_next->op_type == OP_RV2SV) {
6093                 if (!(o->op_next->op_private & OPpDEREF)) {
6094                     null(o->op_next);
6095                     o->op_private |= o->op_next->op_private & OPpLVAL_INTRO;
6096                     o->op_next = o->op_next->op_next;
6097                     o->op_type = OP_GVSV;
6098                     o->op_ppaddr = PL_ppaddr[OP_GVSV];
6099                 }
6100             }
6101             else if (o->op_next->op_type == OP_RV2AV) {
6102                 OP* pop = o->op_next->op_next;
6103                 IV i;
6104                 if (pop->op_type == OP_CONST &&
6105                     (PL_op = pop->op_next) &&
6106                     pop->op_next->op_type == OP_AELEM &&
6107                     !(pop->op_next->op_private &
6108                       (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) &&
6109                     (i = SvIV(((SVOP*)pop)->op_sv) - PL_compiling.cop_arybase)
6110                                 <= 255 &&
6111                     i >= 0)
6112                 {
6113                     null(o->op_next);
6114                     null(pop->op_next);
6115                     null(pop);
6116                     o->op_flags |= pop->op_next->op_flags & OPf_MOD;
6117                     o->op_next = pop->op_next->op_next;
6118                     o->op_type = OP_AELEMFAST;
6119                     o->op_ppaddr = PL_ppaddr[OP_AELEMFAST];
6120                     o->op_private = (U8)i;
6121                     GvAVn((GV*)((SVOP*)o)->op_sv);
6122                 }
6123             }
6124             else if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_UNSAFE)) {
6125                 GV *gv = (GV*)cSVOPo->op_sv;
6126                 if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX(GvCV(gv))) {
6127                     /* XXX could check prototype here instead of just carping */
6128                     SV *sv = sv_newmortal();
6129                     gv_efullname3(sv, gv, Nullch);
6130                     Perl_warner(aTHX_ WARN_UNSAFE,
6131                                 "%s() called too early to check prototype",
6132                                 SvPV_nolen(sv));
6133                 }
6134             }
6135
6136             o->op_seq = PL_op_seqmax++;
6137             break;
6138
6139         case OP_MAPWHILE:
6140         case OP_GREPWHILE:
6141         case OP_AND:
6142         case OP_OR:
6143         case OP_ANDASSIGN:
6144         case OP_ORASSIGN:
6145         case OP_COND_EXPR:
6146         case OP_RANGE:
6147             o->op_seq = PL_op_seqmax++;
6148             while (cLOGOP->op_other->op_type == OP_NULL)
6149                 cLOGOP->op_other = cLOGOP->op_other->op_next;
6150             peep(cLOGOP->op_other);
6151             break;
6152
6153         case OP_ENTERLOOP:
6154             o->op_seq = PL_op_seqmax++;
6155             peep(cLOOP->op_redoop);
6156             peep(cLOOP->op_nextop);
6157             peep(cLOOP->op_lastop);
6158             break;
6159
6160         case OP_QR:
6161         case OP_MATCH:
6162         case OP_SUBST:
6163             o->op_seq = PL_op_seqmax++;
6164             peep(cPMOP->op_pmreplstart);
6165             break;
6166
6167         case OP_EXEC:
6168             o->op_seq = PL_op_seqmax++;
6169             if (ckWARN(WARN_SYNTAX) && o->op_next
6170                 && o->op_next->op_type == OP_NEXTSTATE) {
6171                 if (o->op_next->op_sibling &&
6172                         o->op_next->op_sibling->op_type != OP_EXIT &&
6173                         o->op_next->op_sibling->op_type != OP_WARN &&
6174                         o->op_next->op_sibling->op_type != OP_DIE) {
6175                     line_t oldline = PL_curcop->cop_line;
6176
6177                     PL_curcop->cop_line = ((COP*)o->op_next)->cop_line;
6178                     Perl_warner(aTHX_ WARN_SYNTAX, "Statement unlikely to be reached");
6179                     Perl_warner(aTHX_ WARN_SYNTAX, "(Maybe you meant system() when you said exec()?)\n");
6180                     PL_curcop->cop_line = oldline;
6181                 }
6182             }
6183             break;
6184
6185         case OP_HELEM: {
6186             UNOP *rop;
6187             SV *lexname;
6188             GV **fields;
6189             SV **svp, **indsvp;
6190             I32 ind;
6191             char *key;
6192             STRLEN keylen;
6193
6194             if ((o->op_private & (OPpLVAL_INTRO))
6195                 || ((BINOP*)o)->op_last->op_type != OP_CONST)
6196                 break;
6197             rop = (UNOP*)((BINOP*)o)->op_first;
6198             if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
6199                 break;
6200             lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
6201             if (!SvOBJECT(lexname))
6202                 break;
6203             fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
6204             if (!fields || !GvHV(*fields))
6205                 break;
6206             svp = &((SVOP*)((BINOP*)o)->op_last)->op_sv;
6207             key = SvPV(*svp, keylen);
6208             indsvp = hv_fetch(GvHV(*fields), key, keylen, FALSE);
6209             if (!indsvp) {
6210                 Perl_croak(aTHX_ "No such pseudo-hash field \"%s\" in variable %s of type %s",
6211                       key, SvPV(lexname, n_a), HvNAME(SvSTASH(lexname)));
6212             }
6213             ind = SvIV(*indsvp);
6214             if (ind < 1)
6215                 Perl_croak(aTHX_ "Bad index while coercing array into hash");
6216             rop->op_type = OP_RV2AV;
6217             rop->op_ppaddr = PL_ppaddr[OP_RV2AV];
6218             o->op_type = OP_AELEM;
6219             o->op_ppaddr = PL_ppaddr[OP_AELEM];
6220             SvREFCNT_dec(*svp);
6221             *svp = newSViv(ind);
6222             break;
6223         }
6224
6225         case OP_RV2AV:
6226         case OP_RV2HV:
6227             if (!(o->op_flags & OPf_WANT)
6228                 || (o->op_flags & OPf_WANT) == OPf_WANT_LIST)
6229             {
6230                 last_composite = o;
6231             }
6232             o->op_seq = PL_op_seqmax++;
6233             break;
6234
6235         case OP_RETURN:
6236             if (o->op_next && o->op_next->op_type != OP_LEAVESUBLV) {
6237                 o->op_seq = PL_op_seqmax++;
6238                 break;
6239             }
6240             /* FALL THROUGH */
6241
6242         case OP_LEAVESUBLV:
6243             if (last_composite) {
6244                 OP *r = last_composite;
6245
6246                 while (r->op_sibling)
6247                    r = r->op_sibling;
6248                 if (r->op_next == o
6249                     || (r->op_next->op_type == OP_LIST
6250                         && r->op_next->op_next == o))
6251                 {
6252                     if (last_composite->op_type == OP_RV2AV)
6253                         yyerror("Lvalue subs returning arrays not implemented yet");
6254                     else
6255                         yyerror("Lvalue subs returning hashes not implemented yet");
6256                         ;
6257                 }
6258             }
6259             /* FALL THROUGH */
6260
6261         default:
6262             o->op_seq = PL_op_seqmax++;
6263             break;
6264         }
6265         oldop = o;
6266     }
6267     LEAVE;
6268 }