X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/7b9ef14019d3c4d1aa14641dbd421c81c2cd18a4..3b6547f5bf85b73b309ae78aa34853ad20561fb6:/op.c

diff --git a/op.c b/op.c
index 3dd0cdb..ae5c6a8 100644
--- a/op.c
+++ b/op.c
@@ -1,7 +1,7 @@
 /*    op.c
  *
  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- *    2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
+ *    2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -146,14 +146,14 @@ Perl_Slab_Free(pTHX_ void *op)
 }
 #endif
 /*
- * In the following definition, the ", Nullop" is just to make the compiler
+ * In the following definition, the ", (OP*)0" is just to make the compiler
  * think the expression is of the right type: croak actually does a Siglongjmp.
  */
 #define CHECKOP(type,o) \
-    ((PL_op_mask && PL_op_mask[type])					\
+    ((PL_op_mask && PL_op_mask[type])				\
      ? ( op_free((OP*)o),					\
 	 Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]),	\
-	 Nullop )						\
+	 (OP*)0 )						\
      : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
 
 #define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
@@ -162,7 +162,7 @@ STATIC const char*
 S_gv_ename(pTHX_ GV *gv)
 {
     SV* const tmpsv = sv_newmortal();
-    gv_efullname3(tmpsv, gv, Nullch);
+    gv_efullname3(tmpsv, gv, NULL);
     return SvPV_nolen_const(tmpsv);
 }
 
@@ -208,11 +208,13 @@ S_no_bareword_allowed(pTHX_ const OP *o)
 PADOFFSET
 Perl_allocmy(pTHX_ char *name)
 {
+    dVAR;
     PADOFFSET off;
+    const bool is_our = (PL_in_my == KEY_our);
 
     /* complain about "my $<special_var>" etc etc */
     if (*name &&
-	!(PL_in_my == KEY_our ||
+	!(is_our ||
 	  isALPHA(name[1]) ||
 	  (USE_UTF8_IN_NAMES && UTF8_IS_START(name[1])) ||
 	  (name[1] == '_' && (*name == '$' || name[2]))))
@@ -241,22 +243,19 @@ Perl_allocmy(pTHX_ char *name)
     }
 
     /* check for duplicate declaration */
-    pad_check_dup(name,
-		(bool)(PL_in_my == KEY_our),
-		(PL_curstash ? PL_curstash : PL_defstash)
-    );
+    pad_check_dup(name, is_our, (PL_curstash ? PL_curstash : PL_defstash));
 
     if (PL_in_my_stash && *name != '$') {
 	yyerror(Perl_form(aTHX_
 		    "Can't declare class for non-scalar %s in \"%s\"",
-		     name, PL_in_my == KEY_our ? "our" : "my"));
+		     name, is_our ? "our" : "my"));
     }
 
     /* allocate a spare slot and store the name in that slot */
 
     off = pad_add_name(name,
 		    PL_in_my_stash,
-		    (PL_in_my == KEY_our 
+		    (is_our
 		        /* $_ is always in main::, even with our */
 			? (PL_curstash && !strEQ(name,"$_") ? PL_curstash : PL_defstash)
 			: NULL
@@ -273,24 +272,27 @@ Perl_op_free(pTHX_ OP *o)
 {
     dVAR;
     OPCODE type;
-    PADOFFSET refcnt;
 
     if (!o || o->op_static)
 	return;
 
+    type = o->op_type;
     if (o->op_private & OPpREFCOUNTED) {
-	switch (o->op_type) {
+	switch (type) {
 	case OP_LEAVESUB:
 	case OP_LEAVESUBLV:
 	case OP_LEAVEEVAL:
 	case OP_LEAVE:
 	case OP_SCOPE:
 	case OP_LEAVEWRITE:
+	    {
+	    PADOFFSET refcnt;
 	    OP_REFCNT_LOCK;
 	    refcnt = OpREFCNT_dec(o);
 	    OP_REFCNT_UNLOCK;
 	    if (refcnt)
 		return;
+	    }
 	    break;
 	default:
 	    break;
@@ -304,7 +306,6 @@ Perl_op_free(pTHX_ OP *o)
 	    op_free(kid);
 	}
     }
-    type = o->op_type;
     if (type == OP_NULL)
 	type = (OPCODE)o->op_targ;
 
@@ -317,7 +318,7 @@ Perl_op_free(pTHX_ OP *o)
     FreeOp(o);
 #ifdef DEBUG_LEAKING_SCALARS
     if (PL_op == o)
-	PL_op = Nullop;
+	PL_op = NULL;
 #endif
 }
 
@@ -350,14 +351,14 @@ Perl_op_clear(pTHX_ OP *o)
 	    }
 #else
 	    SvREFCNT_dec(cSVOPo->op_sv);
-	    cSVOPo->op_sv = Nullsv;
+	    cSVOPo->op_sv = NULL;
 #endif
 	}
 	break;
     case OP_METHOD_NAMED:
     case OP_CONST:
 	SvREFCNT_dec(cSVOPo->op_sv);
-	cSVOPo->op_sv = Nullsv;
+	cSVOPo->op_sv = NULL;
 #ifdef USE_ITHREADS
 	/** Bug #15654
 	  Even if op_clear does a pad_free for the target of the op,
@@ -381,11 +382,11 @@ Perl_op_clear(pTHX_ OP *o)
     case OP_TRANS:
 	if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
 	    SvREFCNT_dec(cSVOPo->op_sv);
-	    cSVOPo->op_sv = Nullsv;
+	    cSVOPo->op_sv = NULL;
 	}
 	else {
 	    Safefree(cPVOPo->op_pv);
-	    cPVOPo->op_pv = Nullch;
+	    cPVOPo->op_pv = NULL;
 	}
 	break;
     case OP_SUBST:
@@ -427,7 +428,7 @@ clear_pmop:
 	    }
 	    PmopSTASH_free(cPMOPo);
 	}
-	cPMOPo->op_pmreplroot = Nullop;
+	cPMOPo->op_pmreplroot = NULL;
         /* we use the "SAFE" version of the PM_ macros here
          * since sv_clean_all might release some PMOPs
          * after PL_regex_padav has been cleared
@@ -435,7 +436,7 @@ clear_pmop:
          * happen before sv_clean_all
          */
 	ReREFCNT_dec(PM_GETRE_SAFE(cPMOPo));
-	PM_SETRE_SAFE(cPMOPo, (REGEXP*)NULL);
+	PM_SETRE_SAFE(cPMOPo, NULL);
 #ifdef USE_ITHREADS
 	if(PL_regex_pad) {        /* We could be in destruction */
             av_push((AV*) PL_regex_pad[0],(SV*) PL_regex_pad[(cPMOPo)->op_pmoffset]);
@@ -463,11 +464,7 @@ S_cop_free(pTHX_ COP* cop)
 	SvREFCNT_dec(cop->cop_warnings);
     if (! specialCopIO(cop->cop_io)) {
 #ifdef USE_ITHREADS
-#if 0
-	STRLEN len;
-        char *s = SvPV(cop->cop_io,len);
-	Perl_warn(aTHX_ "io='%.*s'",(int) len,s); /* ??? --jhi */
-#endif
+	/*EMPTY*/
 #else
 	SvREFCNT_dec(cop->cop_io);
 #endif
@@ -490,6 +487,7 @@ void
 Perl_op_refcnt_lock(pTHX)
 {
     dVAR;
+    PERL_UNUSED_CONTEXT;
     OP_REFCNT_LOCK;
 }
 
@@ -497,6 +495,7 @@ void
 Perl_op_refcnt_unlock(pTHX)
 {
     dVAR;
+    PERL_UNUSED_CONTEXT;
     OP_REFCNT_UNLOCK;
 }
 
@@ -507,19 +506,25 @@ Perl_op_refcnt_unlock(pTHX)
 OP *
 Perl_linklist(pTHX_ OP *o)
 {
+    OP *first;
 
     if (o->op_next)
 	return o->op_next;
 
     /* establish postfix order */
-    if (cUNOPo->op_first) {
+    first = cUNOPo->op_first;
+    if (first) {
         register OP *kid;
-	o->op_next = LINKLIST(cUNOPo->op_first);
-	for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
-	    if (kid->op_sibling)
+	o->op_next = LINKLIST(first);
+	kid = first;
+	for (;;) {
+	    if (kid->op_sibling) {
 		kid->op_next = LINKLIST(kid->op_sibling);
-	    else
+		kid = kid->op_sibling;
+	    } else {
 		kid->op_next = o;
+		break;
+	    }
 	}
     }
     else
@@ -542,6 +547,7 @@ Perl_scalarkids(pTHX_ OP *o)
 STATIC OP *
 S_scalarboolean(pTHX_ OP *o)
 {
+    dVAR;
     if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
 	if (ckWARN(WARN_SYNTAX)) {
 	    const line_t oldline = CopLINE(PL_curcop);
@@ -631,7 +637,7 @@ Perl_scalarvoid(pTHX_ OP *o)
 {
     dVAR;
     OP *kid;
-    const char* useless = 0;
+    const char* useless = NULL;
     SV* sv;
     U8 want;
 
@@ -770,6 +776,8 @@ Perl_scalarvoid(pTHX_ OP *o)
 	else {
 	    if (ckWARN(WARN_VOID)) {
 		useless = "a constant";
+		if (o->op_private & OPpCONST_ARYBASE)
+		    useless = 0;
 		/* don't warn on optimised away booleans, eg 
 		 * use constant Foo, 5; Foo || print; */
 		if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
@@ -786,9 +794,10 @@ Perl_scalarvoid(pTHX_ OP *o)
                      built upon these three nroff macros being used in
                      void context. The pink camel has the details in
                      the script wrapman near page 319. */
-		    if (strnEQ(SvPVX_const(sv), "di", 2) ||
-			strnEQ(SvPVX_const(sv), "ds", 2) ||
-			strnEQ(SvPVX_const(sv), "ig", 2))
+		    const char * const maybe_macro = SvPVX_const(sv);
+		    if (strnEQ(maybe_macro, "di", 2) ||
+			strnEQ(maybe_macro, "ds", 2) ||
+			strnEQ(maybe_macro, "ig", 2))
 			    useless = 0;
 		}
 	    }
@@ -959,6 +968,7 @@ Perl_list(pTHX_ OP *o)
 OP *
 Perl_scalarseq(pTHX_ OP *o)
 {
+    dVAR;
     if (o) {
 	if (o->op_type == OP_LINESEQ ||
 	     o->op_type == OP_SCOPE ||
@@ -1027,8 +1037,9 @@ Perl_mod(pTHX_ OP *o, I32 type)
 	PL_modcount++;
 	return o;
     case OP_CONST:
-	if (!(o->op_private & (OPpCONST_ARYBASE)))
+	if (!(o->op_private & OPpCONST_ARYBASE))
 	    goto nomod;
+	localize = 0;
 	if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
 	    PL_compiling.cop_arybase = (I32)SvIV(cSVOPx(PL_eval_start)->op_sv);
 	    PL_eval_start = 0;
@@ -1050,6 +1061,10 @@ Perl_mod(pTHX_ OP *o, I32 type)
 	if ((type == OP_UNDEF || type == OP_REFGEN) &&
 	    !(o->op_flags & OPf_STACKED)) {
 	    o->op_type = OP_RV2CV;		/* entersub => rv2cv */
+	    /* The default is to set op_private to the number of children,
+	       which for a UNOP such as RV2CV is always 1. And w're using
+	       the bit for a flag in RV2CV, so we need it clear.  */
+	    o->op_private &= ~1;
 	    o->op_ppaddr = PL_ppaddr[OP_RV2CV];
 	    assert(cUNOPo->op_first->op_type == OP_NULL);
 	    op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
@@ -1091,10 +1106,11 @@ Perl_mod(pTHX_ OP *o, I32 type)
 			NewOp(1101, newop, 1, UNOP);
 			newop->op_type = OP_RV2CV;
 			newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
-			newop->op_first = Nullop;
+			newop->op_first = NULL;
                         newop->op_next = (OP*)newop;
 			kid->op_sibling = (OP*)newop;
 			newop->op_private |= OPpLVAL_INTRO;
+			newop->op_private &= ~1;
 			break;
 		    }
 
@@ -1124,11 +1140,12 @@ Perl_mod(pTHX_ OP *o, I32 type)
 			kid->op_next = okid;
 		    }
 		    else
-			okid->op_next = Nullop;
+			okid->op_next = NULL;
 		    okid->op_type = OP_RV2CV;
 		    okid->op_targ = 0;
 		    okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
 		    okid->op_private |= OPpLVAL_INTRO;
+		    okid->op_private &= ~1;
 		    break;
 		}
 
@@ -1347,7 +1364,7 @@ Perl_mod(pTHX_ OP *o, I32 type)
 }
 
 STATIC bool
-S_scalar_mod_type(pTHX_ const OP *o, I32 type)
+S_scalar_mod_type(const OP *o, I32 type)
 {
     switch (type) {
     case OP_SASSIGN:
@@ -1394,7 +1411,7 @@ S_scalar_mod_type(pTHX_ const OP *o, I32 type)
 }
 
 STATIC bool
-S_is_handle_constructor(pTHX_ const OP *o, I32 numargs)
+S_is_handle_constructor(const OP *o, I32 numargs)
 {
     switch (o->op_type) {
     case OP_PIPE_OP:
@@ -1410,7 +1427,7 @@ S_is_handle_constructor(pTHX_ const OP *o, I32 numargs)
     case OP_ACCEPT:
 	if (numargs == 1)
 	    return TRUE;
-	/* FALL THROUGH */
+	/* FALLTHROUGH */
     default:
 	return FALSE;
     }
@@ -1445,6 +1462,7 @@ Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
 	    assert(cUNOPo->op_first->op_type == OP_NULL);
 	    op_null(((LISTOP*)cUNOPo->op_first)->op_first);	/* disable pushmark */
 	    o->op_flags |= OPf_SPECIAL;
+	    o->op_private &= ~1;
 	}
 	break;
 
@@ -1524,6 +1542,7 @@ Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
 STATIC OP *
 S_dup_attrlist(pTHX_ OP *o)
 {
+    dVAR;
     OP *rop;
 
     /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
@@ -1531,15 +1550,15 @@ S_dup_attrlist(pTHX_ OP *o)
      * are OP_CONST.  We need to push the OP_CONST values.
      */
     if (o->op_type == OP_CONST)
-	rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc(cSVOPo->op_sv));
+	rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
     else {
 	assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
-	rop = Nullop;
+	rop = NULL;
 	for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
 	    if (o->op_type == OP_CONST)
 		rop = append_elem(OP_LIST, rop,
 				  newSVOP(OP_CONST, o->op_flags,
-					  SvREFCNT_inc(cSVOPo->op_sv)));
+					  SvREFCNT_inc_NN(cSVOPo->op_sv)));
 	}
     }
     return rop;
@@ -1561,19 +1580,17 @@ S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
 
     if (for_my) {
 	/* Don't force the C<use> if we don't need it. */
-	SV * const * const svp = hv_fetch(GvHVn(PL_incgv), ATTRSMODULE_PM,
-		       sizeof(ATTRSMODULE_PM)-1, 0);
+	SV * const * const svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
 	if (svp && *svp != &PL_sv_undef)
-	    ; 		/* already in %INC */
+	    /*EMPTY*/; 		/* already in %INC */
 	else
 	    Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
-			     newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
-			     Nullsv);
+			     newSVpvs(ATTRSMODULE), NULL);
     }
     else {
 	Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
-			 newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
-			 Nullsv,
+			 newSVpvs(ATTRSMODULE),
+			 NULL,
 			 prepend_elem(OP_LIST,
 				      newSVOP(OP_CONST, 0, stashsv),
 				      prepend_elem(OP_LIST,
@@ -1587,6 +1604,7 @@ S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
 STATIC void
 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
 {
+    dVAR;
     OP *pack, *imop, *arg;
     SV *meth, *stashsv;
 
@@ -1601,7 +1619,7 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
     apply_attrs(stash, PAD_SV(target->op_targ), attrs, TRUE);
 
     /* Need package name for method call. */
-    pack = newSVOP(OP_CONST, 0, newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1));
+    pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
 
     /* Build up the real arg-list. */
     stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
@@ -1616,7 +1634,7 @@ S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
 				    dup_attrlist(attrs)));
 
     /* Fake up a method call to import */
-    meth = newSVpvn_share("import", 6, 0);
+    meth = newSVpvs_share("import");
     imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
 		   append_elem(OP_LIST,
 			       prepend_elem(OP_LIST, pack, list(arg)),
@@ -1648,7 +1666,7 @@ void
 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
                         const char *attrstr, STRLEN len)
 {
-    OP *attrs = Nullop;
+    OP *attrs = NULL;
 
     if (!len) {
         len = strlen(attrstr);
@@ -1666,8 +1684,8 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
     }
 
     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
-                     newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
-                     Nullsv, prepend_elem(OP_LIST,
+		     newSVpvs(ATTRSMODULE),
+                     NULL, prepend_elem(OP_LIST,
 				  newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
 				  prepend_elem(OP_LIST,
 					       newSVOP(OP_CONST, 0,
@@ -1678,6 +1696,7 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
 STATIC OP *
 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 {
+    dVAR;
     I32 type;
 
     if (!o || PL_error_count)
@@ -1739,6 +1758,7 @@ S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 OP *
 Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 {
+    dVAR;
     OP *rops;
     int maybe_scalar = 0;
 
@@ -1754,7 +1774,7 @@ Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 #endif
     if (attrs)
 	SAVEFREEOP(attrs);
-    rops = Nullop;
+    rops = NULL;
     o = my_kid(o, attrs, &rops);
     if (rops) {
 	if (maybe_scalar && o->op_type == OP_PADSV) {
@@ -1772,12 +1792,13 @@ Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 OP *
 Perl_my(pTHX_ OP *o)
 {
-    return my_attrs(o, Nullop);
+    return my_attrs(o, NULL);
 }
 
 OP *
 Perl_sawparens(pTHX_ OP *o)
 {
+    PERL_UNUSED_CONTEXT;
     if (o)
 	o->op_flags |= OPf_PARENS;
     return o;
@@ -1874,7 +1895,7 @@ Perl_scope(pTHX_ OP *o)
 	    }
 	}
 	else
-	    o = newLISTOP(OP_SCOPE, 0, o, Nullop);
+	    o = newLISTOP(OP_SCOPE, 0, o, NULL);
     }
     return o;
 }
@@ -1882,6 +1903,7 @@ Perl_scope(pTHX_ OP *o)
 int
 Perl_block_start(pTHX_ int full)
 {
+    dVAR;
     const int retval = PL_savestack_ix;
     pad_block_start(full);
     SAVEHINTS();
@@ -1902,6 +1924,7 @@ Perl_block_start(pTHX_ int full)
 OP*
 Perl_block_end(pTHX_ I32 floor, OP *seq)
 {
+    dVAR;
     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
     OP* const retval = scalarseq(seq);
     LEAVE_SCOPE(floor);
@@ -1915,8 +1938,9 @@ Perl_block_end(pTHX_ I32 floor, OP *seq)
 STATIC OP *
 S_newDEFSVOP(pTHX)
 {
+    dVAR;
     const I32 offset = pad_findmy("$_");
-    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS(offset) & SVpad_OUR) {
+    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
 	return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
     }
     else {
@@ -1929,6 +1953,7 @@ S_newDEFSVOP(pTHX)
 void
 Perl_newPROG(pTHX_ OP *o)
 {
+    dVAR;
     if (PL_in_eval) {
 	if (PL_eval_root)
 		return;
@@ -1974,13 +1999,14 @@ Perl_newPROG(pTHX_ OP *o)
 OP *
 Perl_localize(pTHX_ OP *o, I32 lex)
 {
+    dVAR;
     if (o->op_flags & OPf_PARENS)
 /* [perl #17376]: this appears to be premature, and results in code such as
    C< our(%x); > executing in list mode rather than void mode */
 #if 0
 	list(o);
 #else
-	;
+	/*EMPTY*/;
 #endif
     else {
 	if ( PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ','
@@ -2027,8 +2053,9 @@ OP *
 Perl_jmaybe(pTHX_ OP *o)
 {
     if (o->op_type == OP_LIST) {
-	OP *o2;
-	o2 = newSVREF(newGVOP(OP_GV, 0, gv_fetchpv(";", TRUE, SVt_PV))),
+	OP * const o2
+	    = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL,
+						     SVt_PV)));
 	o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
     }
     return o;
@@ -2101,7 +2128,7 @@ Perl_fold_constants(pTHX_ register OP *o)
     if (o->op_targ && sv == PAD_SV(o->op_targ))	/* grab pad temp? */
 	pad_swipe(o->op_targ,  FALSE);
     else if (SvTEMP(sv)) {			/* grab mortal temp? */
-	(void)SvREFCNT_inc(sv);
+	SvREFCNT_inc_simple_void(sv);
 	SvTEMP_off(sv);
     }
     op_free(o);
@@ -2139,7 +2166,7 @@ Perl_gen_constant_list(pTHX_ register OP *o)
     o->op_flags |= OPf_PARENS;	/* and flatten \(1..2,3) */
     o->op_opt = 0;		/* needs to be revisited in peep() */
     curop = ((UNOP*)o)->op_first;
-    ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*PL_stack_sp--));
+    ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc_NN(*PL_stack_sp--));
     op_free(curop);
     linklist(o);
     return list(o);
@@ -2150,7 +2177,7 @@ Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
 {
     dVAR;
     if (!o || o->op_type != OP_LIST)
-	o = newLISTOP(OP_LIST, 0, o, Nullop);
+	o = newLISTOP(OP_LIST, 0, o, NULL);
     else
 	o->op_flags &= ~OPf_WANT;
 
@@ -2262,7 +2289,7 @@ OP *
 Perl_force_list(pTHX_ OP *o)
 {
     if (!o || o->op_type != OP_LIST)
-	o = newLISTOP(OP_LIST, 0, o, Nullop);
+	o = newLISTOP(OP_LIST, 0, o, NULL);
     op_null(o);
     return o;
 }
@@ -2376,7 +2403,10 @@ Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
     return fold_constants((OP *)binop);
 }
 
-static int uvcompare(const void *a, const void *b) __attribute__nonnull__(1) __attribute__nonnull__(2) __attribute__pure__;
+static int uvcompare(const void *a, const void *b)
+    __attribute__nonnull__(1)
+    __attribute__nonnull__(2)
+    __attribute__pure__;
 static int uvcompare(const void *a, const void *b)
 {
     if (*((const UV *)a) < (*(const UV *)b))
@@ -2393,6 +2423,7 @@ static int uvcompare(const void *a, const void *b)
 OP *
 Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 {
+    dVAR;
     SV * const tstr = ((SVOP*)expr)->op_sv;
     SV * const rstr = ((SVOP*)repl)->op_sv;
     STRLEN tlen;
@@ -2416,8 +2447,8 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
         o->op_private |= OPpTRANS_TO_UTF;
 
     if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
-	SV* const listsv = newSVpvn("# comment\n",10);
-	SV* transv = 0;
+	SV* const listsv = newSVpvs("# comment\n");
+	SV* transv = NULL;
 	const U8* tend = t + tlen;
 	const U8* rend = r + rlen;
 	STRLEN ulen;
@@ -2461,7 +2492,7 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 	    UV nextmin = 0;
 	    Newx(cp, 2*tlen, UV);
 	    i = 0;
-	    transv = newSVpvn("",0);
+	    transv = newSVpvs("");
 	    while (t < tend) {
 		cp[2*i] = utf8n_to_uvuni(t, tend-t, &ulen, 0);
 		t += ulen;
@@ -2602,8 +2633,7 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 	Safefree(cPVOPo->op_pv);
 	cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none);
 	SvREFCNT_dec(listsv);
-	if (transv)
-	    SvREFCNT_dec(transv);
+	SvREFCNT_dec(transv);
 
 	if (!del && havefinal && rlen)
 	    (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5,
@@ -2612,10 +2642,8 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 	if (grows)
 	    o->op_private |= OPpTRANS_GROWS;
 
-	if (tsave)
-	    Safefree(tsave);
-	if (rsave)
-	    Safefree(rsave);
+	Safefree(tsave);
+	Safefree(rsave);
 
 	op_free(expr);
 	op_free(repl);
@@ -2720,7 +2748,7 @@ Perl_newPMOP(pTHX_ I32 type, I32 flags)
 	sv_setiv(repointer,0);
     } else {
 	SV * const repointer = newSViv(0);
-	av_push(PL_regex_padav,SvREFCNT_inc(repointer));
+	av_push(PL_regex_padav, SvREFCNT_inc_simple_NN(repointer));
 	pmop->op_pmoffset = av_len(PL_regex_padav);
 	PL_regex_pad = AvARRAY(PL_regex_padav);
     }
@@ -2760,7 +2788,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
     PMOP *pm;
     LOGOP *rcop;
     I32 repl_has_vars = 0;
-    OP* repl  = Nullop;
+    OP* repl = NULL;
     bool reglist;
 
     if (o->op_type == OP_SUBST || o->op_type == OP_TRANS) {
@@ -2770,7 +2798,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
 	kid = cLISTOPx(expr)->op_first;
 	while (kid->op_sibling != repl)
 	    kid = kid->op_sibling;
-	kid->op_sibling = Nullop;
+	kid->op_sibling = NULL;
 	cLISTOPx(expr)->op_last = kid;
     }
 
@@ -2780,8 +2808,8 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
 	/* convert single element list to element */
 	OP* const oe = expr;
 	expr = cLISTOPx(oe)->op_first->op_sibling;
-	cLISTOPx(oe)->op_first->op_sibling = Nullop;
-	cLISTOPx(oe)->op_last = Nullop;
+	cLISTOPx(oe)->op_first->op_sibling = NULL;
+	cLISTOPx(oe)->op_last = NULL;
 	op_free(oe);
     }
 
@@ -2798,7 +2826,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
 
     if (expr->op_type == OP_CONST) {
 	STRLEN plen;
-	SV *pat = ((SVOP*)expr)->op_sv;
+	SV * const pat = ((SVOP*)expr)->op_sv;
 	const char *p = SvPV_const(pat, plen);
 	if ((o->op_flags & OPf_SPECIAL) && (*p == ' ' && p[1] == '\0')) {
 	    U32 was_readonly = SvREADONLY(pat);
@@ -2866,18 +2894,18 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
     if (repl) {
 	OP *curop;
 	if (pm->op_pmflags & PMf_EVAL) {
-	    curop = 0;
+	    curop = NULL;
 	    if (CopLINE(PL_curcop) < (line_t)PL_multi_end)
 		CopLINE_set(PL_curcop, (line_t)PL_multi_end);
 	}
 	else if (repl->op_type == OP_CONST)
 	    curop = repl;
 	else {
-	    OP *lastop = 0;
+	    OP *lastop = NULL;
 	    for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
 		if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
 		    if (curop->op_type == OP_GV) {
-			GV *gv = cGVOPx_gv(curop);
+			GV * const gv = cGVOPx_gv(curop);
 			repl_has_vars = 1;
 			if (strchr("&`'123456789+-\016\022", *GvENAME(gv)))
 			    break;
@@ -2898,7 +2926,7 @@ Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg)
 			repl_has_vars = 1;
 		    }
 		    else if (curop->op_type == OP_PUSHRE)
-			; /* Okay here, dangerous in newASSIGNOP */
+			/*EMPTY*/; /* Okay here, dangerous in newASSIGNOP */
 		    else
 			break;
 		}
@@ -2986,9 +3014,9 @@ Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
 #ifdef USE_ITHREADS
     if (gv)
 	GvIN_PAD_on(gv);
-    return newPADOP(type, flags, SvREFCNT_inc(gv));
+    return newPADOP(type, flags, SvREFCNT_inc_simple(gv));
 #else
-    return newSVOP(type, flags, SvREFCNT_inc(gv));
+    return newSVOP(type, flags, SvREFCNT_inc_simple(gv));
 #endif
 }
 
@@ -3013,6 +3041,7 @@ Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
 void
 Perl_package(pTHX_ OP *o)
 {
+    dVAR;
     const char *name;
     STRLEN len;
 
@@ -3032,6 +3061,7 @@ Perl_package(pTHX_ OP *o)
 void
 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 {
+    dVAR;
     OP *pack;
     OP *imop;
     OP *veop;
@@ -3039,7 +3069,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
     if (idop->op_type != OP_CONST)
 	Perl_croak(aTHX_ "Module name must be constant");
 
-    veop = Nullop;
+    veop = NULL;
 
     if (version) {
 	SV * const vesv = ((SVOP*)version)->op_sv;
@@ -3058,7 +3088,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 	    pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)idop)->op_sv));
 
 	    /* Fake up a method call to VERSION */
-	    meth = newSVpvn_share("VERSION", 7, 0);
+	    meth = newSVpvs_share("VERSION");
 	    veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
 			    append_elem(OP_LIST,
 					prepend_elem(OP_LIST, pack, list(version)),
@@ -3070,7 +3100,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
     if (arg && arg->op_type == OP_STUB)
 	imop = arg;		/* no import on explicit () */
     else if (SvNIOKp(((SVOP*)idop)->op_sv)) {
-	imop = Nullop;		/* use 5.0; */
+	imop = NULL;		/* use 5.0; */
 	if (!aver)
 	    idop->op_private |= OPpCONST_NOVER;
     }
@@ -3082,7 +3112,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 
 	/* Fake up a method call to import/unimport */
 	meth = aver
-	    ? newSVpvn_share("import",6, 0) : newSVpvn_share("unimport", 8, 0);
+	    ? newSVpvs_share("import") : newSVpvs_share("unimport");
 	imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
 		       append_elem(OP_LIST,
 				   prepend_elem(OP_LIST, pack, list(arg)),
@@ -3091,14 +3121,14 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
 
     /* Fake up the BEGIN {}, which does its thing immediately. */
     newATTRSUB(floor,
-	newSVOP(OP_CONST, 0, newSVpvn_share("BEGIN", 5, 0)),
-	Nullop,
-	Nullop,
+	newSVOP(OP_CONST, 0, newSVpvs_share("BEGIN")),
+	NULL,
+	NULL,
 	append_elem(OP_LINESEQ,
 	    append_elem(OP_LINESEQ,
-	        newSTATEOP(0, Nullch, newUNOP(OP_REQUIRE, 0, idop)),
-	        newSTATEOP(0, Nullch, veop)),
-	    newSTATEOP(0, Nullch, imop) ));
+	        newSTATEOP(0, NULL, newUNOP(OP_REQUIRE, 0, idop)),
+	        newSTATEOP(0, NULL, veop)),
+	    newSTATEOP(0, NULL, imop) ));
 
     /* The "did you use incorrect case?" warning used to be here.
      * The problem is that on case-insensitive filesystems one
@@ -3163,6 +3193,7 @@ Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
 void
 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 {
+    dVAR;
     OP *veop, *imop;
 
     OP * const modname = newSVOP(OP_CONST, 0, name);
@@ -3171,7 +3202,7 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 	veop = newSVOP(OP_CONST, 0, ver);
     }
     else
-	veop = Nullop;
+	veop = NULL;
     if (flags & PERL_LOADMOD_NOIMPORT) {
 	imop = sawparens(newNULLLIST());
     }
@@ -3180,7 +3211,7 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
     }
     else {
 	SV *sv;
-	imop = Nullop;
+	imop = NULL;
 	sv = va_arg(*args, SV*);
 	while (sv) {
 	    imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
@@ -3203,14 +3234,15 @@ Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 OP *
 Perl_dofile(pTHX_ OP *term, I32 force_builtin)
 {
+    dVAR;
     OP *doop;
-    GV *gv = Nullgv;
+    GV *gv = NULL;
 
     if (!force_builtin) {
-	gv = gv_fetchpv("do", FALSE, SVt_PVCV);
+	gv = gv_fetchpvs("do", GV_NOTQUAL, SVt_PVCV);
 	if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
-	    GV * const * const gvp = (GV**)hv_fetch(PL_globalstash, "do", 2, FALSE);
-	    gv = gvp ? *gvp : Nullgv;
+	    GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "do", FALSE);
+	    gv = gvp ? *gvp : NULL;
 	}
     }
 
@@ -3277,6 +3309,7 @@ S_is_list_assignment(pTHX_ register const OP *o)
 OP *
 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 {
+    dVAR;
     OP *o;
 
     if (optype) {
@@ -3330,9 +3363,10 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 		if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
 		    if (curop->op_type == OP_GV) {
 			GV *gv = cGVOPx_gv(curop);
-			if (gv == PL_defgv || (int)SvCUR(gv) == PL_generation)
+			if (gv == PL_defgv
+			    || (int)GvASSIGN_GENERATION(gv) == PL_generation)
 			    break;
-			SvCUR_set(gv, PL_generation);
+			GvASSIGN_GENERATION_set(gv, PL_generation);
 		    }
 		    else if (curop->op_type == OP_PADSV ||
 			     curop->op_type == OP_PADAV ||
@@ -3362,9 +3396,11 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 #else
 			    GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot;
 #endif
-			    if (gv == PL_defgv || (int)SvCUR(gv) == PL_generation)
+			    if (gv == PL_defgv
+				|| (int)GvASSIGN_GENERATION(gv) == PL_generation)
 				break;
-			    SvCUR_set(gv, PL_generation);
+			    GvASSIGN_GENERATION_set(gv, PL_generation);
+			    GvASSIGN_GENERATION_set(gv, PL_generation);
 			}
 		    }
 		    else
@@ -3392,12 +3428,12 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 			cPADOPx(tmpop)->op_padix = 0;	/* steal it */
 #else
 			pm->op_pmreplroot = (OP*)cSVOPx(tmpop)->op_sv;
-			cSVOPx(tmpop)->op_sv = Nullsv;	/* steal it */
+			cSVOPx(tmpop)->op_sv = NULL;	/* steal it */
 #endif
 			pm->op_pmflags |= PMf_ONCE;
 			tmpop = cUNOPo->op_first;	/* to list (nulled) */
 			tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
-			tmpop->op_sibling = Nullop;	/* don't free split */
+			tmpop->op_sibling = NULL;	/* don't free split */
 			right->op_next = tmpop->op_next;  /* fix starting loc */
 			op_free(o);			/* blow off assign */
 			right->op_flags &= ~OPf_WANT;
@@ -3431,7 +3467,9 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 	if (PL_eval_start)
 	    PL_eval_start = 0;
 	else {
+	    op_free(o);
 	    o = newSVOP(OP_CONST, 0, newSViv(PL_compiling.cop_arybase));
+	    o->op_private |= OPpCONST_ARYBASE;
 	}
     }
     return o;
@@ -3491,7 +3529,7 @@ Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
     CopSTASH_set(cop, PL_curstash);
 
     if (PERLDB_LINE && PL_curstash != PL_debstash) {
-	SV * const * const svp = av_fetch(CopFILEAV(PL_curcop), (I32)CopLINE(cop), FALSE);
+	SV * const * const svp = av_fetch(CopFILEAVx(PL_curcop), (I32)CopLINE(cop), FALSE);
 	if (svp && *svp != &PL_sv_undef ) {
 	    (void)SvIOK_on(*svp);
 	    SvIV_set(*svp, PTR2IV(cop));
@@ -3533,7 +3571,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
 	    first = *firstp = cUNOPo->op_first;
 	    if (o->op_next)
 		first->op_next = o->op_next;
-	    cUNOPo->op_first = Nullop;
+	    cUNOPo->op_first = NULL;
 	    op_free(o);
 	}
     }
@@ -3546,7 +3584,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
 	    (type == OP_OR  && !SvTRUE(((SVOP*)first)->op_sv)) ||
 	    (type == OP_DOR && !SvOK(((SVOP*)first)->op_sv))) {
 	    op_free(first);
-	    *firstp = Nullop;
+	    *firstp = NULL;
 	    if (other->op_type == OP_CONST)
 		other->op_private |= OPpCONST_SHORTCIRCUIT;
 	    return other;
@@ -3570,7 +3608,7 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp)
 	    }
 
 	    op_free(other);
-	    *otherp = Nullop;
+	    *otherp = NULL;
 	    if (first->op_type == OP_CONST)
 		first->op_private |= OPpCONST_SHORTCIRCUIT;
 	    return first;
@@ -3750,6 +3788,7 @@ Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right)
 OP *
 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block)
 {
+    dVAR;
     OP* listop;
     OP* o;
     const bool once = block && block->op_flags & OPf_SPECIAL &&
@@ -3814,7 +3853,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
 {
     dVAR;
     OP *redo;
-    OP *next = 0;
+    OP *next = NULL;
     OP *listop;
     OP *o;
     U8 loopflags = 0;
@@ -3874,7 +3913,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
 	if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) {
 	    op_free(expr);		/* oops, it's a while (0) */
 	    op_free((OP*)loop);
-	    return Nullop;		/* listop already freed by new_logop */
+	    return NULL;		/* listop already freed by new_logop */
 	}
 	if (listop)
 	    ((LISTOP*)listop)->op_last->op_next =
@@ -3930,14 +3969,14 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
 	    padoff = sv->op_targ;
 	    sv->op_targ = 0;
 	    op_free(sv);
-	    sv = Nullop;
+	    sv = NULL;
 	}
 	else if (sv->op_type == OP_THREADSV) { /* per-thread variable */
 	    padoff = sv->op_targ;
 	    sv->op_targ = 0;
 	    iterflags |= OPf_SPECIAL;
 	    op_free(sv);
-	    sv = Nullop;
+	    sv = NULL;
 	}
 	else
 	    Perl_croak(aTHX_ "Can't use %s for loop variable", PL_op_desc[sv->op_type]);
@@ -3946,7 +3985,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
     }
     else {
         const I32 offset = pad_findmy("$_");
-	if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS(offset) & SVpad_OUR) {
+	if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
 	    sv = newGVOP(OP_GV, 0, PL_defgv);
 	}
 	else {
@@ -3973,7 +4012,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
 	LISTOP* listop;
 
 	range->op_flags &= ~OPf_KIDS;
-	range->op_first = Nullop;
+	range->op_first = NULL;
 
 	listop = (LISTOP*)newLISTOP(OP_LIST, 0, left, right);
 	listop->op_first->op_next = range->op_next;
@@ -4016,6 +4055,7 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
 OP*
 Perl_newLOOPEX(pTHX_ I32 type, OP *label)
 {
+    dVAR;
     OP *o;
 
     if (type != OP_GOTO || label->op_type == OP_CONST) {
@@ -4075,6 +4115,7 @@ S_newGIVWHENOP(pTHX_ OP *cond, OP *block,
 		   I32 enter_opcode, I32 leave_opcode,
 		   PADOFFSET entertarg)
 {
+    dVAR;
     LOGOP *enterop;
     OP *o;
 
@@ -4127,6 +4168,7 @@ STATIC
 bool
 S_looks_like_bool(pTHX_ OP *o)
 {
+    dVAR;
     switch(o->op_type) {
 	case OP_OR:
 	    return looks_like_bool(cLOGOPo->op_first);
@@ -4182,6 +4224,7 @@ S_looks_like_bool(pTHX_ OP *o)
 OP *
 Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off)
 {
+    dVAR;
     assert( cond );
     return newGIVWHENOP(
     	ref_array_or_hash(cond),
@@ -4227,27 +4270,27 @@ Perl_cv_undef(pTHX_ CV *cv)
 {
     dVAR;
 #ifdef USE_ITHREADS
-    if (CvFILE(cv) && !CvXSUB(cv)) {
+    if (CvFILE(cv) && !CvISXSUB(cv)) {
 	/* for XSUBs CvFILE point directly to static memory; __FILE__ */
 	Safefree(CvFILE(cv));
     }
     CvFILE(cv) = 0;
 #endif
 
-    if (!CvXSUB(cv) && CvROOT(cv)) {
-	if (CvDEPTH(cv))
+    if (!CvISXSUB(cv) && CvROOT(cv)) {
+	if (SvTYPE(cv) == SVt_PVCV && CvDEPTH(cv))
 	    Perl_croak(aTHX_ "Can't undef active subroutine");
 	ENTER;
 
 	PAD_SAVE_SETNULLPAD();
 
 	op_free(CvROOT(cv));
-	CvROOT(cv) = Nullop;
-	CvSTART(cv) = Nullop;
+	CvROOT(cv) = NULL;
+	CvSTART(cv) = NULL;
 	LEAVE;
     }
     SvPOK_off((SV*)cv);		/* forget prototype */
-    CvGV(cv) = Nullgv;
+    CvGV(cv) = NULL;
 
     pad_undef(cv);
 
@@ -4255,14 +4298,14 @@ Perl_cv_undef(pTHX_ CV *cv)
     if (!SvREFCNT(cv) && CvOUTSIDE(cv)) {
 	if (!CvWEAKOUTSIDE(cv))
 	    SvREFCNT_dec(CvOUTSIDE(cv));
-	CvOUTSIDE(cv) = Nullcv;
+	CvOUTSIDE(cv) = NULL;
     }
     if (CvCONST(cv)) {
 	SvREFCNT_dec((SV*)CvXSUBANY(cv).any_ptr);
 	CvCONST_off(cv);
     }
-    if (CvXSUB(cv)) {
-        CvXSUB(cv) = 0;
+    if (CvISXSUB(cv) && CvXSUB(cv)) {
+	CvXSUB(cv) = NULL;
     }
     /* delete all flags except WEAKOUTSIDE */
     CvFLAGS(cv) &= CVf_WEAKOUTSIDE;
@@ -4273,22 +4316,22 @@ Perl_cv_ckproto(pTHX_ const CV *cv, const GV *gv, const char *p)
 {
     if (((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX_const(cv)))) && ckWARN_d(WARN_PROTOTYPE)) {
 	SV* const msg = sv_newmortal();
-	SV* name = Nullsv;
+	SV* name = NULL;
 
 	if (gv)
-	    gv_efullname3(name = sv_newmortal(), gv, Nullch);
+	    gv_efullname3(name = sv_newmortal(), gv, NULL);
 	sv_setpv(msg, "Prototype mismatch:");
 	if (name)
 	    Perl_sv_catpvf(aTHX_ msg, " sub %"SVf, name);
 	if (SvPOK(cv))
 	    Perl_sv_catpvf(aTHX_ msg, " (%"SVf")", (const SV *)cv);
 	else
-	    Perl_sv_catpv(aTHX_ msg, ": none");
-	sv_catpv(msg, " vs ");
+	    sv_catpvs(msg, ": none");
+	sv_catpvs(msg, " vs ");
 	if (p)
 	    Perl_sv_catpvf(aTHX_ msg, "(%s)", p);
 	else
-	    sv_catpv(msg, "none");
+	    sv_catpvs(msg, "none");
 	Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE), "%"SVf, msg);
     }
 }
@@ -4312,9 +4355,12 @@ L<perlsub/"Constant Functions">.
 SV *
 Perl_cv_const_sv(pTHX_ CV *cv)
 {
-    if (!cv || !CvCONST(cv))
-	return Nullsv;
-    return (SV*)CvXSUBANY(cv).any_ptr;
+    PERL_UNUSED_CONTEXT;
+    if (!cv)
+	return NULL;
+    if (!(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM))
+	return NULL;
+    return CvCONST(cv) ? (SV*)CvXSUBANY(cv).any_ptr : NULL;
 }
 
 /* op_const_sv:  examine an optree to determine whether it's in-lineable.
@@ -4340,10 +4386,11 @@ Perl_cv_const_sv(pTHX_ CV *cv)
 SV *
 Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 {
-    SV *sv = Nullsv;
+    dVAR;
+    SV *sv = NULL;
 
     if (!o)
-	return Nullsv;
+	return NULL;
 
     if (o->op_type == OP_LINESEQ && cLISTOPo->op_first)
 	o = cLISTOPo->op_first->op_sibling;
@@ -4362,13 +4409,13 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 	if (type == OP_LEAVESUB || type == OP_RETURN)
 	    break;
 	if (sv)
-	    return Nullsv;
+	    return NULL;
 	if (type == OP_CONST && cSVOPo->op_sv)
 	    sv = cSVOPo->op_sv;
 	else if (cv && type == OP_CONST) {
 	    sv = PAD_BASE_SV(CvPADLIST(cv), o->op_targ);
 	    if (!sv)
-		return Nullsv;
+		return NULL;
 	}
 	else if (cv && type == OP_PADSV) {
 	    if (CvCONST(cv)) { /* newly cloned anon */
@@ -4376,7 +4423,7 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 		/* the candidate should have 1 ref from this pad and 1 ref
 		 * from the parent */
 		if (!sv || SvREFCNT(sv) != 2)
-		    return Nullsv;
+		    return NULL;
 		sv = newSVsv(sv);
 		SvREADONLY_on(sv);
 		return sv;
@@ -4387,7 +4434,7 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 	    }
 	}
 	else {
-	    return Nullsv;
+	    return NULL;
 	}
     }
     return sv;
@@ -4412,7 +4459,7 @@ Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 CV *
 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
 {
-    return Perl_newATTRSUB(aTHX_ floor, o, proto, Nullop, block);
+    return Perl_newATTRSUB(aTHX_ floor, o, proto, NULL, block);
 }
 
 CV *
@@ -4423,18 +4470,24 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
     GV *gv;
     const char *ps;
     STRLEN ps_len;
-    register CV *cv=0;
+    register CV *cv = NULL;
     SV *const_sv;
-    I32 gv_fetch_flags;
-
-    const char * const name = o ? SvPVx_nolen_const(cSVOPo->op_sv) : Nullch;
+    /* If the subroutine has no body, no attributes, and no builtin attributes
+       then it's just a sub declaration, and we may be able to get away with
+       storing with a placeholder scalar in the symbol table, rather than a
+       full GV and CV.  If anything is present then it will take a full CV to
+       store it.  */
+    const I32 gv_fetch_flags
+	= (block || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
+	? GV_ADDMULTI : GV_ADDMULTI | GV_NOINIT;
+    const char * const name = o ? SvPVx_nolen_const(cSVOPo->op_sv) : NULL;
 
     if (proto) {
 	assert(proto->op_type == OP_CONST);
 	ps = SvPVx_const(((SVOP*)proto)->op_sv, ps_len);
     }
     else
-	ps = Nullch;
+	ps = NULL;
 
     if (!name && PERLDB_NAMEANON && CopLINE(PL_curcop)) {
 	SV * const sv = sv_newmortal();
@@ -4444,10 +4497,8 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 	aname = SvPVX_const(sv);
     }
     else
-	aname = Nullch;
+	aname = NULL;
 
-    gv_fetch_flags = (block || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
-	? GV_ADDMULTI : GV_ADDMULTI | GV_NOINIT;
     gv = name ? gv_fetchsv(cSVOPo->op_sv, gv_fetch_flags, SVt_PVCV)
 	: gv_fetchpv(aname ? aname
 		     : (PL_curstash ? "__ANON__" : "__ANON__::__ANON__"),
@@ -4480,7 +4531,7 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 	goto done;
     }
 
-    cv = (!name || GvCVGEN(gv)) ? Nullcv : GvCV(gv);
+    cv = (!name || GvCVGEN(gv)) ? NULL : GvCV(gv);
 
 #ifdef GV_UNIQUE_CHECK
     if (cv && GvUNIQUE(gv) && SvREADONLY(cv)) {
@@ -4489,9 +4540,9 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 #endif
 
     if (!block || !ps || *ps || attrs || (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS))
-	const_sv = Nullsv;
+	const_sv = NULL;
     else
-	const_sv = op_const_sv(block, Nullcv);
+	const_sv = op_const_sv(block, NULL);
 
     if (cv) {
         const bool exists = CvROOT(cv) || CvXSUB(cv);
@@ -4533,21 +4584,22 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 		    CopLINE_set(PL_curcop, oldline);
 		}
 		SvREFCNT_dec(cv);
-		cv = Nullcv;
+		cv = NULL;
 	    }
 	}
     }
     if (const_sv) {
-	(void)SvREFCNT_inc(const_sv);
+	SvREFCNT_inc_void_NN(const_sv);
 	if (cv) {
 	    assert(!CvROOT(cv) && !CvCONST(cv));
 	    sv_setpvn((SV*)cv, "", 0);  /* prototype is "" */
 	    CvXSUBANY(cv).any_ptr = const_sv;
 	    CvXSUB(cv) = const_sv_xsub;
 	    CvCONST_on(cv);
+	    CvISXSUB_on(cv);
 	}
 	else {
-	    GvCV(gv) = Nullcv;
+	    GvCV(gv) = NULL;
 	    cv = newCONSTSUB(NULL, name, const_sv);
 	}
 	op_free(block);
@@ -4625,7 +4677,7 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 
     if (PL_error_count) {
 	op_free(block);
-	block = Nullop;
+	block = NULL;
 	if (name) {
 	    const char *s = strrchr(name, ':');
 	    s = s ? s+1 : name;
@@ -4653,7 +4705,7 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 	/* This makes sub {}; work as expected.  */
 	if (block->op_type == OP_STUB) {
 	    op_free(block);
-	    block = newSTATEOP(0, Nullch, 0);
+	    block = newSTATEOP(0, NULL, 0);
 	}
 	CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
     }
@@ -4678,15 +4730,16 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 	const char * const tname = (name ? name : aname);
 
 	if (PERLDB_SUBLINE && PL_curstash != PL_debstash) {
-	    SV * const sv = NEWSV(0,0);
+	    SV * const sv = newSV(0);
 	    SV * const tmpstr = sv_newmortal();
-	    GV * const db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
+	    GV * const db_postponed = gv_fetchpvs("DB::postponed",
+						  GV_ADDMULTI, SVt_PVHV);
 	    HV *hv;
 
 	    Perl_sv_setpvf(aTHX_ sv, "%s:%ld-%ld",
 			   CopFILE(PL_curcop),
 			   (long)PL_subline, (long)CopLINE(PL_curcop));
-	    gv_efullname3(tmpstr, gv, Nullch);
+	    gv_efullname3(tmpstr, gv, NULL);
 	    hv_store(GvHV(PL_DBsub), SvPVX_const(tmpstr), SvCUR(tmpstr), sv, 0);
 	    hv = GvHVn(db_postponed);
 	    if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvCUR(tmpstr))) {
@@ -4817,6 +4870,7 @@ Used by C<xsubpp> to hook up XSUBs as Perl subs.
 CV *
 Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
 {
+    dVAR;
     GV * const gv = gv_fetchpv(name ? name :
 			(PL_curstash ? "__ANON__" : "__ANON__::__ANON__"),
 			GV_ADDMULTI, SVt_PVCV);
@@ -4825,11 +4879,11 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
     if (!subaddr)
 	Perl_croak(aTHX_ "panic: no address for '%s' in '%s'", name, filename);
 
-    if ((cv = (name ? GvCV(gv) : Nullcv))) {
+    if ((cv = (name ? GvCV(gv) : NULL))) {
 	if (GvCVGEN(gv)) {
 	    /* just a cached method */
 	    SvREFCNT_dec(cv);
-	    cv = Nullcv;
+	    cv = NULL;
 	}
 	else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
 	    /* already defined (or promised) */
@@ -4839,8 +4893,8 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
 		if (gvcv) {
 		    HV * const stash = GvSTASH(gvcv);
 		    if (stash) {
-			const char *name = HvNAME_get(stash);
-			if ( strEQ(name,"autouse") ) {
+			const char *redefined_name = HvNAME_get(stash);
+			if ( strEQ(redefined_name,"autouse") ) {
 			    const line_t oldline = CopLINE(PL_curcop);
 			    if (PL_copline != NOLINE)
 				CopLINE_set(PL_curcop, PL_copline);
@@ -4854,14 +4908,14 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
 		}
 	    }
 	    SvREFCNT_dec(cv);
-	    cv = Nullcv;
+	    cv = NULL;
 	}
     }
 
     if (cv)				/* must reuse cv if autoloaded */
 	cv_undef(cv);
     else {
-	cv = (CV*)NEWSV(1105,0);
+	cv = (CV*)newSV(0);
 	sv_upgrade((SV *)cv, SVt_PVCV);
 	if (name) {
 	    GvCV(gv) = cv;
@@ -4873,6 +4927,7 @@ Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename)
     (void)gv_fetchfile(filename);
     CvFILE(cv) = (char *)filename; /* NOTE: not copied, as it is expected to be
 				   an external constant string */
+    CvISXSUB_on(cv);
     CvXSUB(cv) = subaddr;
 
     if (name) {
@@ -4926,11 +4981,12 @@ done:
 void
 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block)
 {
+    dVAR;
     register CV *cv;
 
     GV * const gv = o
-	? gv_fetchsv(cSVOPo->op_sv, TRUE, SVt_PVFM)
-	: gv_fetchpv("STDOUT", TRUE, SVt_PVFM);
+	? gv_fetchsv(cSVOPo->op_sv, GV_ADD, SVt_PVFM)
+	: gv_fetchpvs("STDOUT", GV_ADD|GV_NOTQUAL, SVt_PVFM);
 
 #ifdef GV_UNIQUE_CHECK
     if (GvUNIQUE(gv)) {
@@ -4985,7 +5041,7 @@ Perl_newANONHASH(pTHX_ OP *o)
 OP *
 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block)
 {
-    return newANONATTRSUB(floor, proto, Nullop, block);
+    return newANONATTRSUB(floor, proto, NULL, block);
 }
 
 OP *
@@ -5117,13 +5173,14 @@ OP *
 Perl_ck_anoncode(pTHX_ OP *o)
 {
     cSVOPo->op_targ = pad_add_anon(cSVOPo->op_sv, o->op_type);
-    cSVOPo->op_sv = Nullsv;
+    cSVOPo->op_sv = NULL;
     return o;
 }
 
 OP *
 Perl_ck_bitop(pTHX_ OP *o)
 {
+    dVAR;
 #define OP_IS_NUMCOMPARE(op) \
 	((op) == OP_LT   || (op) == OP_I_LT || \
 	 (op) == OP_GT   || (op) == OP_I_GT || \
@@ -5158,6 +5215,7 @@ OP *
 Perl_ck_concat(pTHX_ OP *o)
 {
     const OP * const kid = cUNOPo->op_first;
+    PERL_UNUSED_CONTEXT;
     if (kid->op_type == OP_CONCAT && !(kid->op_private & OPpTARGET_MY) &&
 	    !(kUNOP->op_first->op_flags & OPf_MOD))
         o->op_flags |= OPf_STACKED;
@@ -5230,6 +5288,7 @@ Perl_ck_die(pTHX_ OP *o)
 OP *
 Perl_ck_eof(pTHX_ OP *o)
 {
+    dVAR;
     const I32 type = o->op_type;
 
     if (o->op_flags & OPf_KIDS) {
@@ -5284,8 +5343,7 @@ Perl_ck_eval(pTHX_ OP *o)
 	o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP());
     }
     o->op_targ = (PADOFFSET)PL_hints;
-    if ((PL_hints & HINT_HH_FOR_EVAL) != 0 && GvHV(PL_hintgv))
-    {
+    if ((PL_hints & HINT_LOCALIZE_HH) != 0 && GvHV(PL_hintgv)) {
 	/* Store a copy of %^H that pp_entereval can pick up */
 	OP *hhop = newSVOP(OP_CONST, 0, (SV*)newHVhv(GvHV(PL_hintgv)));
 	cUNOPo->op_first->op_sibling = hhop;
@@ -5300,7 +5358,7 @@ Perl_ck_exit(pTHX_ OP *o)
 #ifdef VMS
     HV * const table = GvHV(PL_hintgv);
     if (table) {
-       SV * const * const svp = hv_fetch(table, "vmsish_exit", 11, FALSE);
+       SV * const * const svp = hv_fetchs(table, "vmsish_exit", FALSE);
        if (svp && *svp && SvTRUE(*svp))
            o->op_private |= OPpEXIT_VMSISH;
     }
@@ -5327,6 +5385,7 @@ Perl_ck_exec(pTHX_ OP *o)
 OP *
 Perl_ck_exists(pTHX_ OP *o)
 {
+    dVAR;
     o = ck_fun(o);
     if (o->op_flags & OPf_KIDS) {
 	OP * const kid = cUNOPo->op_first;
@@ -5354,6 +5413,9 @@ Perl_ck_rvconst(pTHX_ register OP *o)
     SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
     o->op_private |= (PL_hints & HINT_STRICT_REFS);
+    if (o->op_type == OP_RV2CV)
+	o->op_private &= ~1;
+
     if (kid->op_type == OP_CONST) {
 	int iscv;
 	GV *gv;
@@ -5363,7 +5425,7 @@ Perl_ck_rvconst(pTHX_ register OP *o)
 	if (SvROK(kidsv) && SvREADONLY(kidsv)) {
 	    SV * const rsv = SvRV(kidsv);
 	    const int svtype = SvTYPE(rsv);
-            const char *badtype = Nullch;
+            const char *badtype = NULL;
 
 	    switch (o->op_type) {
 	    case OP_RV2SV:
@@ -5387,8 +5449,19 @@ Perl_ck_rvconst(pTHX_ register OP *o)
 		Perl_croak(aTHX_ "Constant is not %s reference", badtype);
 	    return o;
 	}
-	if ((PL_hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
-            const char *badthing = Nullch;
+	else if ((o->op_type == OP_RV2HV || o->op_type == OP_RV2SV) &&
+		(PL_hints & HINT_STRICT_REFS) && SvPOK(kidsv)) {
+	    /* If this is an access to a stash, disable "strict refs", because
+	     * stashes aren't auto-vivified at compile-time (unless we store
+	     * symbols in them), and we don't want to produce a run-time
+	     * stricture error when auto-vivifying the stash. */
+	    const char *s = SvPV_nolen(kidsv);
+	    const STRLEN l = SvCUR(kidsv);
+	    if (l > 1 && s[l-1] == ':' && s[l-2] == ':')
+		o->op_private &= ~HINT_STRICT_REFS;
+	}
+	if ((o->op_private & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
+	    const char *badthing;
 	    switch (o->op_type) {
 	    case OP_RV2SV:
 		badthing = "a SCALAR";
@@ -5399,6 +5472,9 @@ Perl_ck_rvconst(pTHX_ register OP *o)
 	    case OP_RV2HV:
 		badthing = "a HASH";
 		break;
+	    default:
+		badthing = NULL;
+		break;
 	    }
 	    if (badthing)
 		Perl_croak(aTHX_
@@ -5435,9 +5511,9 @@ Perl_ck_rvconst(pTHX_ register OP *o)
 	    kPADOP->op_padix = pad_alloc(OP_GV, SVs_PADTMP);
 	    SvREFCNT_dec(PAD_SVl(kPADOP->op_padix));
 	    GvIN_PAD_on(gv);
-	    PAD_SETSV(kPADOP->op_padix, (SV*) SvREFCNT_inc(gv));
+	    PAD_SETSV(kPADOP->op_padix, (SV*) SvREFCNT_inc_simple_NN(gv));
 #else
-	    kid->op_sv = SvREFCNT_inc(gv);
+	    kid->op_sv = SvREFCNT_inc_simple_NN(gv);
 #endif
 	    kid->op_private = 0;
 	    kid->op_ppaddr = PL_ppaddr[OP_GV];
@@ -5453,14 +5529,14 @@ Perl_ck_ftst(pTHX_ OP *o)
     const I32 type = o->op_type;
 
     if (o->op_flags & OPf_REF) {
-	/* nothing */
+	/*EMPTY*/;
     }
     else if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
 	SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
 	if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
 	    OP * const newop = newGVOP(type, OPf_REF,
-		gv_fetchsv(kid->op_sv, TRUE, SVt_PVIO));
+		gv_fetchsv(kid->op_sv, GV_ADD, SVt_PVIO));
 	    op_free(o);
 	    o = newop;
 	    return o;
@@ -5487,6 +5563,7 @@ Perl_ck_ftst(pTHX_ OP *o)
 OP *
 Perl_ck_fun(pTHX_ OP *o)
 {
+    dVAR;
     const int type = o->op_type;
     register I32 oa = PL_opargs[type] >> OASHIFT;
 
@@ -5544,7 +5621,7 @@ Perl_ck_fun(pTHX_ OP *o)
 		    (kid->op_private & OPpCONST_BARE))
 		{
 		    OP * const newop = newAVREF(newGVOP(OP_GV, 0,
-			gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVAV) ));
+			gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVAV) ));
 		    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
 			Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
 			    "Array @%"SVf" missing the @ in argument %"IVdf" of %s()",
@@ -5563,7 +5640,7 @@ Perl_ck_fun(pTHX_ OP *o)
 		    (kid->op_private & OPpCONST_BARE))
 		{
 		    OP * const newop = newHVREF(newGVOP(OP_GV, 0,
-			gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVHV) ));
+			gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVHV) ));
 		    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
 			Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
 			    "Hash %%%"SVf" missing the %% in argument %"IVdf" of %s()",
@@ -5594,7 +5671,7 @@ Perl_ck_fun(pTHX_ OP *o)
 			(kid->op_private & OPpCONST_BARE))
 		    {
 			OP * const newop = newGVOP(OP_GV, 0,
-			    gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVIO) );
+			    gv_fetchsv(((SVOP*)kid)->op_sv, GV_ADD, SVt_PVIO));
 			if (!(o->op_private & 1) && /* if not unop */
 			    kid == cLISTOPo->op_last)
 			    cLISTOPo->op_last = newop;
@@ -5612,7 +5689,7 @@ Perl_ck_fun(pTHX_ OP *o)
 
 			/* is this op a FH constructor? */
 			if (is_handle_constructor(o,numargs)) {
-                            const char *name = Nullch;
+                            const char *name = NULL;
 			    STRLEN len = 0;
 
 			    flags = 0;
@@ -5641,9 +5718,9 @@ Perl_ck_fun(pTHX_ OP *o)
 				     || kid->op_type == OP_HELEM)
 			    {
 				 OP *op = ((BINOP*)kid)->op_first;
-				 name = 0;
+				 name = NULL;
 				 if (op) {
-				      SV *tmpstr = Nullsv;
+				      SV *tmpstr = NULL;
 				      const char * const a =
 					   kid->op_type == OP_AELEM ?
 					   "[]" : "{}";
@@ -5740,10 +5817,10 @@ Perl_ck_glob(pTHX_ OP *o)
     if ((o->op_flags & OPf_KIDS) && !cLISTOPo->op_first->op_sibling)
 	append_elem(OP_GLOB, o, newDEFSVOP());
 
-    if (!((gv = gv_fetchpv("glob", FALSE, SVt_PVCV))
+    if (!((gv = gv_fetchpvs("glob", GV_NOTQUAL, SVt_PVCV))
 	  && GvCVu(gv) && GvIMPORTED_CV(gv)))
     {
-	gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
+	gv = gv_fetchpvs("CORE::GLOBAL::glob", 0, SVt_PVCV);
     }
 
 #if !defined(PERL_EXTERNAL_GLOB)
@@ -5752,11 +5829,11 @@ Perl_ck_glob(pTHX_ OP *o)
 	GV *glob_gv;
 	ENTER;
 	Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
-		newSVpvn("File::Glob", 10), Nullsv, Nullsv, Nullsv);
-	gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV);
-	glob_gv = gv_fetchpv("File::Glob::csh_glob", FALSE, SVt_PVCV);
+		newSVpvs("File::Glob"), NULL, NULL, NULL);
+	gv = gv_fetchpvs("CORE::GLOBAL::glob", 0, SVt_PVCV);
+	glob_gv = gv_fetchpvs("File::Glob::csh_glob", 0, SVt_PVCV);
 	GvCV(gv) = GvCV(glob_gv);
-	(void)SvREFCNT_inc((SV*)GvCV(gv));
+	SvREFCNT_inc_void((SV*)GvCV(gv));
 	GvIMPORTED_CV_on(gv);
 	LEAVE;
     }
@@ -5829,7 +5906,7 @@ Perl_ck_grep(pTHX_ OP *o)
     gwop->op_other = LINKLIST(kid);
     kid->op_next = (OP*)gwop;
     offset = pad_findmy("$_");
-    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS(offset) & SVpad_OUR) {
+    if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
 	o->op_private = gwop->op_private = 0;
 	gwop->op_targ = pad_alloc(type, SVs_PADTMP);
     }
@@ -5955,19 +6032,20 @@ Perl_ck_say(pTHX_ OP *o)
     o = ck_listiob(o);
     o->op_type = OP_PRINT;
     cLISTOPo->op_last = cLISTOPo->op_last->op_sibling
-    	= newSVOP(OP_CONST, 0, newSVpvn("\n", 1));
+    	= newSVOP(OP_CONST, 0, newSVpvs("\n"));
     return o;
 }
 
 OP *
 Perl_ck_smartmatch(pTHX_ OP *o)
 {
+    dVAR;
     if (0 == (o->op_flags & OPf_SPECIAL)) {
 	OP *first  = cBINOPo->op_first;
 	OP *second = first->op_sibling;
 	
 	/* Implicitly take a reference to an array or hash */
-	first->op_sibling = Nullop;
+	first->op_sibling = NULL;
 	first = cBINOPo->op_first = ref_array_or_hash(first);
 	second = first->op_sibling = ref_array_or_hash(second);
 	
@@ -6019,9 +6097,10 @@ Perl_ck_sassign(pTHX_ OP *o)
 OP *
 Perl_ck_match(pTHX_ OP *o)
 {
+    dVAR;
     if (o->op_type != OP_QR && PL_compcv) {
 	const I32 offset = pad_findmy("$_");
-	if (offset != NOT_IN_PAD && !(PAD_COMPNAME_FLAGS(offset) & SVpad_OUR)) {
+	if (offset != NOT_IN_PAD && !(PAD_COMPNAME_FLAGS_isOUR(offset))) {
 	    o->op_targ = offset;
 	    o->op_private |= OPpTARGET_MY;
 	}
@@ -6037,13 +6116,14 @@ Perl_ck_method(pTHX_ OP *o)
     OP * const kid = cUNOPo->op_first;
     if (kid->op_type == OP_CONST) {
 	SV* sv = kSVOP->op_sv;
-	if (!(strchr(SvPVX_const(sv), ':') || strchr(SvPVX_const(sv), '\''))) {
+	const char * const method = SvPVX_const(sv);
+	if (!(strchr(method, ':') || strchr(method, '\''))) {
 	    OP *cmop;
 	    if (!SvREADONLY(sv) || !SvFAKE(sv)) {
-		sv = newSVpvn_share(SvPVX_const(sv), SvCUR(sv), 0);
+		sv = newSVpvn_share(method, SvCUR(sv), 0);
 	    }
 	    else {
-		kSVOP->op_sv = Nullsv;
+		kSVOP->op_sv = NULL;
 	    }
 	    cmop = newSVOP(OP_METHOD_NAMED, 0, sv);
 	    op_free(o);
@@ -6056,15 +6136,17 @@ Perl_ck_method(pTHX_ OP *o)
 OP *
 Perl_ck_null(pTHX_ OP *o)
 {
+    PERL_UNUSED_CONTEXT;
     return o;
 }
 
 OP *
 Perl_ck_open(pTHX_ OP *o)
 {
+    dVAR;
     HV * const table = GvHV(PL_hintgv);
     if (table) {
-	SV **svp = hv_fetch(table, "open_IN", 7, FALSE);
+	SV **svp = hv_fetchs(table, "open_IN", FALSE);
 	if (svp && *svp) {
 	    const I32 mode = mode_from_discipline(*svp);
 	    if (mode & O_BINARY)
@@ -6073,7 +6155,7 @@ Perl_ck_open(pTHX_ OP *o)
 		o->op_private |= OPpOPEN_IN_CRLF;
 	}
 
-	svp = hv_fetch(table, "open_OUT", 8, FALSE);
+	svp = hv_fetchs(table, "open_OUT", FALSE);
 	if (svp && *svp) {
 	    const I32 mode = mode_from_discipline(*svp);
 	    if (mode & O_BINARY)
@@ -6122,7 +6204,8 @@ Perl_ck_repeat(pTHX_ OP *o)
 OP *
 Perl_ck_require(pTHX_ OP *o)
 {
-    GV* gv = Nullgv;
+    dVAR;
+    GV* gv = NULL;
 
     if (o->op_flags & OPf_KIDS) {	/* Shall we supply missing .pm? */
 	SVOP * const kid = (SVOP*)cUNOPo->op_first;
@@ -6150,17 +6233,17 @@ Perl_ck_require(pTHX_ OP *o)
 		    SvCUR_set(sv, SvCUR(sv) - 1);
 		}
 	    }
-	    sv_catpvn(sv, ".pm", 3);
+	    sv_catpvs(sv, ".pm");
 	    SvFLAGS(sv) |= was_readonly;
 	}
     }
 
     if (!(o->op_flags & OPf_SPECIAL)) { /* Wasn't written as CORE::require */
 	/* handle override, if any */
-	gv = gv_fetchpv("require", FALSE, SVt_PVCV);
+	gv = gv_fetchpvs("require", GV_NOTQUAL, SVt_PVCV);
 	if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
-	    GV * const * const gvp = (GV**)hv_fetch(PL_globalstash, "require", 7, FALSE);
-	    gv = gvp ? *gvp : Nullgv;
+	    GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "require", FALSE);
+	    gv = gvp ? *gvp : NULL;
 	}
     }
 
@@ -6181,6 +6264,7 @@ Perl_ck_require(pTHX_ OP *o)
 OP *
 Perl_ck_return(pTHX_ OP *o)
 {
+    dVAR;
     if (CvLVALUE(PL_compcv)) {
         OP *kid;
 	for (kid = cLISTOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
@@ -6213,6 +6297,7 @@ Perl_ck_select(pTHX_ OP *o)
 OP *
 Perl_ck_shift(pTHX_ OP *o)
 {
+    dVAR;
     const I32 type = o->op_type;
 
     if (!(o->op_flags & OPf_KIDS)) {
@@ -6229,15 +6314,16 @@ Perl_ck_shift(pTHX_ OP *o)
 OP *
 Perl_ck_sort(pTHX_ OP *o)
 {
+    dVAR;
     OP *firstkid;
 
     if (o->op_type == OP_SORT && (PL_hints & HINT_LOCALIZE_HH) != 0)
     {
-	HV *hinthv = GvHV(PL_hintgv);
+	HV * const hinthv = GvHV(PL_hintgv);
 	if (hinthv) {
-	    SV **svp = hv_fetch(hinthv, "sort", 4, 0);
+	    SV ** const svp = hv_fetchs(hinthv, "sort", FALSE);
 	    if (svp) {
-		I32 sorthints = (I32)SvIV(*svp);
+		const I32 sorthints = (I32)SvIV(*svp);
 		if ((sorthints & HINT_SORT_QUICKSORT) != 0)
 		    o->op_private |= OPpSORT_QSORT;
 		if ((sorthints & HINT_SORT_STABLE) != 0)
@@ -6307,6 +6393,7 @@ Perl_ck_sort(pTHX_ OP *o)
 STATIC void
 S_simplify_sort(pTHX_ OP *o)
 {
+    dVAR;
     register OP *kid = cLISTOPo->op_first->op_sibling;	/* get past pushmark */
     OP *k;
     int descending;
@@ -6314,8 +6401,8 @@ S_simplify_sort(pTHX_ OP *o)
     const char *gvname;
     if (!(o->op_flags & OPf_STACKED))
 	return;
-    GvMULTI_on(gv_fetchpv("a", TRUE, SVt_PV));
-    GvMULTI_on(gv_fetchpv("b", TRUE, SVt_PV));
+    GvMULTI_on(gv_fetchpvs("a", GV_ADD|GV_NOTQUAL, SVt_PV));
+    GvMULTI_on(gv_fetchpvs("b", GV_ADD|GV_NOTQUAL, SVt_PV));
     kid = kUNOP->op_first;				/* get past null */
     if (kid->op_type != OP_SCOPE)
 	return;
@@ -6389,7 +6476,7 @@ Perl_ck_split(pTHX_ OP *o)
     op_free(cLISTOPo->op_first);
     cLISTOPo->op_first = kid;
     if (!kid) {
-	cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvn(" ", 1));
+	cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvs(" "));
 	cLISTOPo->op_last = kid; /* There was only one element previously */
     }
 
@@ -6448,17 +6535,18 @@ Perl_ck_join(pTHX_ OP *o)
 OP *
 Perl_ck_subr(pTHX_ OP *o)
 {
+    dVAR;
     OP *prev = ((cUNOPo->op_first->op_sibling)
 	     ? cUNOPo : ((UNOP*)cUNOPo->op_first))->op_first;
     OP *o2 = prev->op_sibling;
     OP *cvop;
-    char *proto = 0;
-    CV *cv = 0;
-    GV *namegv = 0;
+    char *proto = NULL;
+    CV *cv = NULL;
+    GV *namegv = NULL;
     int optional = 0;
     I32 arg = 0;
     I32 contextclass = 0;
-    char *e = 0;
+    char *e = NULL;
     bool delete_op = 0;
 
     o->op_private |= OPpENTERSUB_HASTARG;
@@ -6498,9 +6586,9 @@ Perl_ck_subr(pTHX_ OP *o)
 	if (o2->op_type == OP_CONST)
 	    o2->op_private &= ~OPpCONST_STRICT;
 	else if (o2->op_type == OP_LIST) {
-	    OP * const o = ((UNOP*)o2)->op_first->op_sibling;
-	    if (o && o->op_type == OP_CONST)
-		o->op_private &= ~OPpCONST_STRICT;
+	    OP * const sib = ((UNOP*)o2)->op_first->op_sibling;
+	    if (sib && sib->op_type == OP_CONST)
+		sib->op_private &= ~OPpCONST_STRICT;
 	}
     }
     o->op_private |= (PL_hints & HINT_STRICT_REFS);
@@ -6556,7 +6644,7 @@ Perl_ck_subr(pTHX_ OP *o)
 			    {
 				GV * const gv = cGVOPx_gv(gvop);
 				OP * const sibling = o2->op_sibling;
-				SV * const n = newSVpvn("",0);
+				SV * const n = newSVpvs("");
 				op_free(o2);
 				gv_fullname4(n, gv, "", FALSE);
 				o2 = newSVOP(OP_CONST, 0, n);
@@ -6683,11 +6771,28 @@ Perl_ck_subr(pTHX_ OP *o)
 OP *
 Perl_ck_svconst(pTHX_ OP *o)
 {
+    PERL_UNUSED_CONTEXT;
     SvREADONLY_on(cSVOPo->op_sv);
     return o;
 }
 
 OP *
+Perl_ck_chdir(pTHX_ OP *o)
+{
+    if (o->op_flags & OPf_KIDS) {
+	SVOP *kid = (SVOP*)cUNOPo->op_first;
+
+	if (kid && kid->op_type == OP_CONST &&
+	    (kid->op_private & OPpCONST_BARE))
+	{
+	    o->op_flags |= OPf_SPECIAL;
+	    kid->op_private &= ~OPpCONST_STRICT;
+	}
+    }
+    return ck_fun(o);
+}
+
+OP *
 Perl_ck_trunc(pTHX_ OP *o)
 {
     if (o->op_flags & OPf_KIDS) {
@@ -6741,7 +6846,7 @@ void
 Perl_peep(pTHX_ register OP *o)
 {
     dVAR;
-    register OP* oldop = 0;
+    register OP* oldop = NULL;
 
     if (!o || o->op_opt)
 	return;
@@ -6777,6 +6882,18 @@ Perl_peep(pTHX_ register OP *o)
 		    SvREADONLY_on(PAD_SVl(ix));
 		    SvREFCNT_dec(cSVOPo->op_sv);
 		}
+		else if (o->op_type == OP_CONST
+			 && cSVOPo->op_sv == &PL_sv_undef) {
+		    /* PL_sv_undef is hack - it's unsafe to store it in the
+		       AV that is the pad, because av_fetch treats values of
+		       PL_sv_undef as a "free" AV entry and will merrily
+		       replace them with a new SV, causing pad_alloc to think
+		       that this pad slot is free. (When, clearly, it is not)
+		    */
+		    SvOK_off(PAD_SVl(ix));
+		    SvPADTMP_on(PAD_SVl(ix));
+		    SvREADONLY_on(PAD_SVl(ix));
+		}
 		else {
 		    SvREFCNT_dec(PAD_SVl(ix));
 		    SvPADTMP_on(cSVOPo->op_sv);
@@ -6784,7 +6901,7 @@ Perl_peep(pTHX_ register OP *o)
 		    /* XXX I don't know how this isn't readonly already. */
 		    SvREADONLY_on(PAD_SVl(ix));
 		}
-		cSVOPo->op_sv = Nullsv;
+		cSVOPo->op_sv = NULL;
 		o->op_targ = ix;
 	    }
 #endif
@@ -6895,7 +7012,7 @@ Perl_peep(pTHX_ register OP *o)
 		if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
 		    /* XXX could check prototype here instead of just carping */
 		    SV * const sv = sv_newmortal();
-		    gv_efullname3(sv, gv, Nullch);
+		    gv_efullname3(sv, gv, NULL);
 		    Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
 				"%"SVf"() called too early to check prototype",
 				sv);
@@ -7008,9 +7125,9 @@ Perl_peep(pTHX_ register OP *o)
 	    if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV)
 		break;
 	    lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE);
-	    if (!(SvFLAGS(lexname) & SVpad_TYPED))
+	    if (!SvPAD_TYPED(lexname))
 		break;
-	    fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
+	    fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
 	    if (!fields || !GvHV(*fields))
 		break;
 	    key = SvPV_const(*svp, keylen);
@@ -7057,9 +7174,9 @@ Perl_peep(pTHX_ register OP *o)
 	    }
 		    
 	    lexname = *av_fetch(PL_comppad_name, rop->op_targ, TRUE);
-	    if (!(SvFLAGS(lexname) & SVpad_TYPED))
+	    if (!SvPAD_TYPED(lexname))
 		break;
-	    fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE);
+	    fields = (GV**)hv_fetchs(SvSTASH(lexname), "FIELDS", FALSE);
 	    if (!fields || !GvHV(*fields))
 		break;
 	    /* Again guessing that the pushmark can be jumped over.... */
@@ -7290,6 +7407,58 @@ Perl_peep(pTHX_ register OP *o)
 	    
 	    break;
 	}
+
+	case OP_SASSIGN: {
+	    OP *rv2gv;
+	    UNOP *refgen, *rv2cv;
+	    LISTOP *exlist;
+
+	    /* I do not understand this, but if o->op_opt isn't set to 1,
+	       various tests in ext/B/t/bytecode.t fail with no readily
+	       apparent cause.  */
+
+	    o->op_opt = 1;
+
+
+	    if ((o->op_flags && OPf_WANT) != OPf_WANT_VOID)
+		break;
+
+	    if ((o->op_private & ~OPpASSIGN_BACKWARDS) != 2)
+		break;
+
+	    rv2gv = ((BINOP *)o)->op_last;
+	    if (!rv2gv || rv2gv->op_type != OP_RV2GV)
+		break;
+
+	    refgen = (UNOP *)((BINOP *)o)->op_first;
+
+	    if (!refgen || refgen->op_type != OP_REFGEN)
+		break;
+
+	    exlist = (LISTOP *)refgen->op_first;
+	    if (!exlist || exlist->op_type != OP_NULL
+		|| exlist->op_targ != OP_LIST)
+		break;
+
+	    if (exlist->op_first->op_type != OP_PUSHMARK)
+		break;
+
+	    rv2cv = (UNOP*)exlist->op_last;
+
+	    if (rv2cv->op_type != OP_RV2CV)
+		break;
+
+	    assert ((rv2gv->op_private & OPpDONT_INIT_GV) == 0);
+	    assert ((o->op_private & OPpASSIGN_CV_TO_GV) == 0);
+	    assert ((rv2cv->op_private & OPpMAY_RETURN_CONSTANT) == 0);
+
+	    o->op_private |= OPpASSIGN_CV_TO_GV;
+	    rv2gv->op_private |= OPpDONT_INIT_GV;
+	    rv2cv->op_private |= OPpMAY_RETURN_CONSTANT;
+
+	    break;
+	}
+
 	
 	default:
 	    o->op_opt = 1;
@@ -7303,6 +7472,7 @@ Perl_peep(pTHX_ register OP *o)
 char*
 Perl_custom_op_name(pTHX_ const OP* o)
 {
+    dVAR;
     const IV index = PTR2IV(o->op_ppaddr);
     SV* keysv;
     HE* he;
@@ -7322,6 +7492,7 @@ Perl_custom_op_name(pTHX_ const OP* o)
 char*
 Perl_custom_op_desc(pTHX_ const OP* o)
 {
+    dVAR;
     const IV index = PTR2IV(o->op_ppaddr);
     SV* keysv;
     HE* he;
@@ -7344,8 +7515,10 @@ Perl_custom_op_desc(pTHX_ const OP* o)
 static void
 const_sv_xsub(pTHX_ CV* cv)
 {
+    dVAR;
     dXSARGS;
     if (items != 0) {
+	/*EMPTY*/;
 #if 0
         Perl_croak(aTHX_ "usage: %s::%s()",
                    HvNAME_get(GvSTASH(CvGV(cv))), GvNAME(CvGV(cv)));