Re: [PATCH] s/Null(gv|hv|sv)/NULL/g

Message-ID: <20060203152449.GI12591@accognoscere.homeunix.org>
Date: Fri, 3 Feb 2006 16:24:49 +0100

p4raw-id: //depot/perl@27065

32 files changed, 291 insertions, 291 deletions

diff --git a/cop.h b/cop.h
index 55c0db9a9f..6c26e0ee5a 100644
--- a/cop.h
+++ b/cop.h
@@ -155,7 +155,7 @@ struct cop {
 #ifdef USE_ITHREADS
 #  define CopFILE(c)		((c)->cop_file)
 #  define CopFILEGV(c)		(CopFILE(c) \
-				 ? gv_fetchfile(CopFILE(c)) : Nullgv)
+				 ? gv_fetchfile(CopFILE(c)) : NULL)
 				 
 #  ifdef NETWARE
 #    define CopFILE_set(c,pv)	((c)->cop_file = savepv(pv))
@@ -164,7 +164,7 @@ struct cop {
 #  endif
 
 #  define CopFILESV(c)		(CopFILE(c) \
-				 ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
+				 ? GvSV(gv_fetchfile(CopFILE(c))) : NULL)
 #  define CopFILEAV(c)		(CopFILE(c) \
 				 ? GvAV(gv_fetchfile(CopFILE(c))) : NULL)
 #  ifdef DEBUGGING
@@ -196,7 +196,7 @@ struct cop {
 #  define CopFILEGV(c)		((c)->cop_filegv)
 #  define CopFILEGV_set(c,gv)	((c)->cop_filegv = (GV*)SvREFCNT_inc(gv))
 #  define CopFILE_set(c,pv)	CopFILEGV_set((c), gv_fetchfile(pv))
-#  define CopFILESV(c)		(CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
+#  define CopFILESV(c)		(CopFILEGV(c) ? GvSV(CopFILEGV(c)) : NULL)
 #  define CopFILEAV(c)		(CopFILEGV(c) ? GvAV(CopFILEGV(c)) : NULL)
 #  ifdef DEBUGGING
 #    define CopFILEAVx(c)	(assert(CopFILEGV(c)), GvAV(CopFILEGV(c)))
@@ -211,7 +211,7 @@ struct cop {
 #  define CopSTASHPV_set(c,pv)	CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
 #  define CopSTASH_eq(c,hv)	(CopSTASH(c) == (hv))
 #  define CopSTASH_free(c)	
-#  define CopFILE_free(c)	(SvREFCNT_dec(CopFILEGV(c)),(CopFILEGV(c) = Nullgv))
+#  define CopFILE_free(c)	(SvREFCNT_dec(CopFILEGV(c)),(CopFILEGV(c) = NULL))
 
 #endif /* USE_ITHREADS */
 
@@ -315,7 +315,7 @@ struct block_sub {
 	}								\
 	sv = (SV*)cx->blk_sub.cv;					\
 	if (sv && (CvDEPTH((CV*)sv) = cx->blk_sub.olddepth))		\
-	    sv = Nullsv;						\
+	    sv = NULL;						\
     } STMT_END
 
 #define LEAVESUB(sv)							\
@@ -344,7 +344,7 @@ struct block_eval {
     STMT_START {							\
 	cx->blk_eval.old_in_eval = PL_in_eval;				\
 	cx->blk_eval.old_op_type = PL_op->op_type;			\
-	cx->blk_eval.old_namesv = (n ? newSVpv(n,0) : Nullsv);		\
+	cx->blk_eval.old_namesv = (n ? newSVpv(n,0) : NULL);		\
 	cx->blk_eval.old_eval_root = PL_eval_root;			\
 	cx->blk_eval.cur_text = PL_linestr;				\
 	cx->blk_eval.cv = NULL; /* set by doeval(), as applicable */	\
@@ -394,14 +394,14 @@ struct block_loop {
 	if ((cx->blk_loop.iterdata = (idata)))				\
 	    cx->blk_loop.itersave = SvREFCNT_inc(*CxITERVAR(cx));	\
 	else								\
-	    cx->blk_loop.itersave = Nullsv;
+	    cx->blk_loop.itersave = NULL;
 #else
 #  define CxITERVAR(c)		((c)->blk_loop.itervar)
 #  define CX_ITERDATA_SET(cx,ivar)					\
 	if ((cx->blk_loop.itervar = (SV**)(ivar)))			\
 	    cx->blk_loop.itersave = SvREFCNT_inc(*CxITERVAR(cx));	\
 	else								\
-	    cx->blk_loop.itersave = Nullsv;
+	    cx->blk_loop.itersave = NULL;
 #endif
 
 #define PUSHLOOP(cx, dat, s)						\
@@ -410,7 +410,7 @@ struct block_loop {
 	cx->blk_loop.redo_op = cLOOP->op_redoop;			\
 	cx->blk_loop.next_op = cLOOP->op_nextop;			\
 	cx->blk_loop.last_op = cLOOP->op_lastop;			\
-	cx->blk_loop.iterlval = Nullsv;					\
+	cx->blk_loop.iterlval = NULL;					\
 	cx->blk_loop.iterary = NULL;					\
 	cx->blk_loop.iterix = -1;					\
 	CX_ITERDATA_SET(cx,dat);
diff --git a/doio.c b/doio.c
index 1b04bc2382..8d55d3f0cf 100644
--- a/doio.c
+++ b/doio.c
@@ -1297,7 +1297,7 @@ Perl_my_stat(pTHX)
 		return PL_laststatval;
 	    if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
 		report_evil_fh(gv, io, PL_op->op_type);
-	    PL_statgv = Nullgv;
+	    PL_statgv = NULL;
 	    sv_setpvn(PL_statname,"", 0);
 	    return (PL_laststatval = -1);
 	}
@@ -1320,7 +1320,7 @@ Perl_my_stat(pTHX)
 	}
 
 	s = SvPV_const(sv, len);
-	PL_statgv = Nullgv;
+	PL_statgv = NULL;
 	sv_setpvn(PL_statname, s, len);
 	s = SvPVX_const(PL_statname);		/* s now NUL-terminated */
 	PL_laststype = OP_STAT;
@@ -1357,7 +1357,7 @@ Perl_my_lstat(pTHX)
 	Perl_croak(aTHX_ no_prev_lstat);
 
     PL_laststype = OP_LSTAT;
-    PL_statgv = Nullgv;
+    PL_statgv = NULL;
     sv = POPs;
     PUTBACK;
     if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVGV && ckWARN(WARN_IO)) {
diff --git a/doop.c b/doop.c
index e84816ae2e..847b18ee9a 100644
--- a/doop.c
+++ b/doop.c
@@ -1034,7 +1034,7 @@ Perl_do_chomp(pTHX_ register SV *sv)
     STRLEN len;
     char *s;
     char *temp_buffer = NULL;
-    SV* svrecode = Nullsv;
+    SV* svrecode = NULL;
 
     if (RsSNARF(PL_rs))
 	return 0;
@@ -1371,7 +1371,7 @@ Perl_do_kv(pTHX)
 	if (PL_op->op_flags & OPf_MOD || LVRET) {	/* lvalue */
 	    dTARGET;		/* make sure to clear its target here */
 	    if (SvTYPE(TARG) == SVt_PVLV)
-		LvTARG(TARG) = Nullsv;
+		LvTARG(TARG) = NULL;
 	    PUSHs(TARG);
 	}
 	RETURN;
@@ -1390,7 +1390,7 @@ Perl_do_kv(pTHX)
 	if (PL_op->op_flags & OPf_MOD || LVRET) {	/* lvalue */
 	    if (SvTYPE(TARG) < SVt_PVLV) {
 		sv_upgrade(TARG, SVt_PVLV);
-		sv_magic(TARG, Nullsv, PERL_MAGIC_nkeys, NULL, 0);
+		sv_magic(TARG, NULL, PERL_MAGIC_nkeys, NULL, 0);
 	    }
 	    LvTYPE(TARG) = 'k';
 	    if (LvTARG(TARG) != (SV*)keys) {
diff --git a/dump.c b/dump.c
index 0612a9cb1a..6799c47541 100644
--- a/dump.c
+++ b/dump.c
@@ -1669,7 +1669,7 @@ Perl_debop(pTHX_ const OP *o)
             AV * const comppad = (AV*)(*av_fetch(padlist, 0, FALSE));
             sv = *av_fetch(comppad, o->op_targ, FALSE);
         } else
-            sv = Nullsv;
+            sv = NULL;
         if (sv)
            PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
         else
diff --git a/embed.pl b/embed.pl
index a1068ab480..b0677c20b2 100755
--- a/embed.pl
+++ b/embed.pl
@@ -537,7 +537,7 @@ print EM <<'END';
 
 #if !defined(PERL_CORE)
 #  define sv_setptrobj(rv,ptr,name)	sv_setref_iv(rv,name,PTR2IV(ptr))
-#  define sv_setptrref(rv,ptr)		sv_setref_iv(rv,Nullch,PTR2IV(ptr))
+#  define sv_setptrref(rv,ptr)		sv_setref_iv(rv,NULL,PTR2IV(ptr))
 #endif
 
 #if !defined(PERL_CORE) && !defined(PERL_NOCOMPAT)
diff --git a/gv.c b/gv.c
index d06bb8d441..955891be7a 100644
--- a/gv.c
+++ b/gv.c
@@ -110,7 +110,7 @@ Perl_gv_fetchfile(pTHX_ const char *name)
     GV *gv;
 
     if (!PL_defstash)
-	return Nullgv;
+	return NULL;
 
     tmplen = strlen(name) + 2;
     if (tmplen < sizeof smallbuf)
@@ -130,7 +130,7 @@ Perl_gv_fetchfile(pTHX_ const char *name)
 	sv_setpvn(GvSV(gv), name, tmplen - 2);
 #endif
 	if (PERLDB_LINE)
-	    hv_magic(GvHVn(gv_AVadd(gv)), Nullgv, PERL_MAGIC_dbfile);
+	    hv_magic(GvHVn(gv_AVadd(gv)), NULL, PERL_MAGIC_dbfile);
     }
     if (tmpbuf != smallbuf)
 	Safefree(tmpbuf);
@@ -313,7 +313,7 @@ Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level)
 
     gvp = (GV**)hv_fetch(stash, name, len, (level >= 0));
     if (!gvp)
-	topgv = Nullgv;
+	topgv = NULL;
     else {
 	topgv = *gvp;
 	if (SvTYPE(topgv) != SVt_PVGV)
@@ -572,7 +572,7 @@ Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
     STRLEN packname_len;
 
     if (len == S_autolen && strnEQ(name, S_autoload, S_autolen))
-	return Nullgv;
+	return NULL;
     if (stash) {
 	if (SvTYPE(stash) < SVt_PVHV) {
 	    packname = SvPV_const((SV*)stash, packname_len);
@@ -584,11 +584,11 @@ Perl_gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method)
 	}
     }
     if (!(gv = gv_fetchmeth(stash, S_autoload, S_autolen, FALSE)))
-	return Nullgv;
+	return NULL;
     cv = GvCV(gv);
 
     if (!(CvROOT(cv) || CvXSUB(cv)))
-	return Nullgv;
+	return NULL;
 
     /*
      * Inheriting AUTOLOAD for non-methods works ... for now.
@@ -652,7 +652,7 @@ S_require_errno(pTHX_ GV *gv)
 	ENTER;
 	save_scalar(gv); /* keep the value of $! */
         Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
-                         newSVpvs("Errno"), Nullsv);
+                         newSVpvs("Errno"), NULL);
 	LEAVE;
 	SPAGAIN;
 	stash = gv_stashpvs("Errno", FALSE);
@@ -786,7 +786,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 	    if (!stash)
 		stash = PL_defstash;
 	    if (!stash || !SvREFCNT(stash)) /* symbol table under destruction */
-		return Nullgv;
+		return NULL;
 
 	    len = name_cursor - name;
 	    if (len > 0) {
@@ -802,7 +802,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 		tmpbuf[len++] = ':';
 		tmpbuf[len] = '\0';
 		gvp = (GV**)hv_fetch(stash,tmpbuf,len,add);
-		gv = gvp ? *gvp : Nullgv;
+		gv = gvp ? *gvp : NULL;
 		if (gv && gv != (GV*)&PL_sv_undef) {
 		    if (SvTYPE(gv) != SVt_PVGV)
 			gv_init(gv, stash, tmpbuf, len, (add & GV_ADDMULTI));
@@ -812,7 +812,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 		if (tmpbuf != smallbuf)
 		    Safefree(tmpbuf);
 		if (!gv || gv == (GV*)&PL_sv_undef)
-		    return Nullgv;
+		    return NULL;
 
 		if (!(stash = GvHV(gv)))
 		    stash = GvHV(gv) = newHV();
@@ -929,15 +929,15 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 	    stash = GvHV(gv_fetchpvn_flags("<none>::", 8, GV_ADDMULTI, SVt_PVHV));
 	}
 	else
-	    return Nullgv;
+	    return NULL;
     }
 
     if (!SvREFCNT(stash))	/* symbol table under destruction */
-	return Nullgv;
+	return NULL;
 
     gvp = (GV**)hv_fetch(stash,name,len,add);
     if (!gvp || *gvp == (GV*)&PL_sv_undef)
-	return Nullgv;
+	return NULL;
     gv = *gvp;
     if (SvTYPE(gv) == SVt_PVGV) {
 	if (add) {
@@ -1013,7 +1013,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 		if (strEQ(name2, "VERLOAD")) {
 		    HV* const hv = GvHVn(gv);
 		    GvMULTI_on(gv);
-		    hv_magic(hv, Nullgv, PERL_MAGIC_overload);
+		    hv_magic(hv, NULL, PERL_MAGIC_overload);
 		}
 		break;
 	    case 'S':
@@ -1027,7 +1027,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 		    }
 		    GvMULTI_on(gv);
 		    hv = GvHVn(gv);
-		    hv_magic(hv, Nullgv, PERL_MAGIC_sig);
+		    hv_magic(hv, NULL, PERL_MAGIC_sig);
 		    for (i = 1; i < SIG_SIZE; i++) {
 			SV * const * const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
 			if (init)
@@ -1133,7 +1133,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 	case '-':
 	{
 	    AV* const av = GvAVn(gv);
-            sv_magic((SV*)av, Nullsv, PERL_MAGIC_regdata, NULL, 0);
+            sv_magic((SV*)av, NULL, PERL_MAGIC_regdata, NULL, 0);
 	    SvREADONLY_on(av);
 	    goto magicalize;
 	}
diff --git a/hv.c b/hv.c
index 05b3828835..3f6daf7661 100644
--- a/hv.c
+++ b/hv.c
@@ -372,7 +372,7 @@ Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
     }
     hek = hv_fetch_common (hv, NULL, key, klen, flags,
 			   lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) : HV_FETCH_JUST_SV,
-			   Nullsv, 0);
+			   NULL, 0);
     return hek ? &HeVAL(hek) : NULL;
 }
 
@@ -417,7 +417,7 @@ HE *
 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, register U32 hash)
 {
     return hv_fetch_common(hv, keysv, NULL, 0, 0, 
-			   (lval ? HV_FETCH_LVALUE : 0), Nullsv, hash);
+			   (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
 }
 
 STATIC HE *
@@ -498,10 +498,10 @@ S_hv_fetch_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
 			const char * const nkey = strupr(savepvn(key,klen));
 			/* Note that this fetch is for nkey (the uppercased
 			   key) whereas the store is for key (the original)  */
-			entry = hv_fetch_common(hv, Nullsv, nkey, klen,
+			entry = hv_fetch_common(hv, NULL, nkey, klen,
 						HVhek_FREEKEY, /* free nkey */
 						0 /* non-LVAL fetch */,
-						Nullsv /* no value */,
+						NULL /* no value */,
 						0 /* compute hash */);
 			if (!entry && (action & HV_FETCH_LVALUE)) {
 			    /* This call will free key if necessary.
@@ -962,7 +962,7 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
     int masked_flags;
 
     if (!hv)
-	return Nullsv;
+	return NULL;
 
     if (keysv) {
 	if (k_flags & HVhek_FREEKEY)
@@ -983,7 +983,7 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
 	    SV *sv;
 	    entry = hv_fetch_common(hv, keysv, key, klen,
 				    k_flags & ~HVhek_FREEKEY, HV_FETCH_LVALUE,
-				    Nullsv, hash);
+				    NULL, hash);
 	    sv = entry ? HeVAL(entry) : NULL;
 	    if (sv) {
 		if (SvMAGICAL(sv)) {
@@ -995,7 +995,7 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
 			sv_unmagic(sv, PERL_MAGIC_tiedelem);
 			return sv;
 		    }		
-		    return Nullsv;		/* element cannot be deleted */
+		    return NULL;		/* element cannot be deleted */
 		}
 #ifdef ENV_IS_CASELESS
 		else if (mg_find((SV*)hv, PERL_MAGIC_env)) {
@@ -1015,7 +1015,7 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
     }
     xhv = (XPVHV*)SvANY(hv);
     if (!HvARRAY(hv))
-	return Nullsv;
+	return NULL;
 
     if (is_utf8) {
 	const char * const keysave = key;
@@ -1082,7 +1082,7 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
             Safefree(key);
 
 	if (d_flags & G_DISCARD)
-	    sv = Nullsv;
+	    sv = NULL;
 	else {
 	    sv = sv_2mortal(HeVAL(entry));
 	    HeVAL(entry) = &PL_sv_placeholder;
@@ -1123,7 +1123,7 @@ S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen,
 
     if (k_flags & HVhek_FREEKEY)
 	Safefree(key);
-    return Nullsv;
+    return NULL;
 }
 
 STATIC void
@@ -2301,7 +2301,7 @@ S_unshare_hek_or_pvn(pTHX_ const HEK *hek, const char *str, I32 len, U32 hash)
 
     /* what follows was the moral equivalent of:
     if ((Svp = hv_fetch(PL_strtab, tmpsv, FALSE, hash))) {
-	if (--*Svp == Nullsv)
+	if (--*Svp == NULL)
 	    hv_delete(PL_strtab, str, len, G_DISCARD, hash);
     } */
     xhv = (XPVHV*)SvANY(PL_strtab);
@@ -2397,7 +2397,7 @@ S_share_hek_flags(pTHX_ const char *str, I32 len, register U32 hash, int flags)
     /* what follows is the moral equivalent of:
 
     if (!(Svp = hv_fetch(PL_strtab, str, len, FALSE)))
-	hv_store(PL_strtab, str, len, Nullsv, hash);
+	hv_store(PL_strtab, str, len, NULL, hash);
 
 	Can't rehash the shared string table, so not sure if it's worth
 	counting the number of entries in the linked list
diff --git a/hv.h b/hv.h
index 8c78c7ad20..9f9c1e38e3 100644
--- a/hv.h
+++ b/hv.h
@@ -189,7 +189,7 @@ the length of hash keys. This is very similar to the C<SvPV()> macro
 described elsewhere in this document.
 
 =for apidoc Am|SV*|HeSVKEY|HE* he
-Returns the key as an C<SV*>, or C<Nullsv> if the hash entry does not
+Returns the key as an C<SV*>, or C<NULL> if the hash entry does not
 contain an C<SV*> key.
 
 =for apidoc Am|SV*|HeSVKEY_force|HE* he
@@ -303,7 +303,7 @@ C<SV*>.
 
 #define HeSVKEY(he)		((HeKEY(he) && 				\
 				  HeKLEN(he) == HEf_SVKEY) ?		\
-				 HeKEY_sv(he) : Nullsv)
+				 HeKEY_sv(he) : NULL)
 
 #define HeSVKEY_force(he)	(HeKEY(he) ?				\
 				 ((HeKLEN(he) == HEf_SVKEY) ?		\
diff --git a/intrpvar.h b/intrpvar.h
index 575a5ba17a..08551a593c 100644
--- a/intrpvar.h
+++ b/intrpvar.h
@@ -448,7 +448,7 @@ PERLVARI(Iknown_layers, PerlIO_list_t *,NULL)
 PERLVARI(Idef_layerlist, PerlIO_list_t *,NULL)
 #endif
 
-PERLVARI(Iencoding,	SV*, Nullsv)		/* character encoding */
+PERLVARI(Iencoding,	SV*, NULL)		/* character encoding */
 
 PERLVAR(Idebug_pad,	struct perl_debug_pad)	/* always needed because of the re extension */
 
diff --git a/locale.c b/locale.c
index 86b11c841f..a7f56dd2a8 100644
--- a/locale.c
+++ b/locale.c
@@ -88,7 +88,7 @@ Perl_set_numeric_radix(pTHX)
     if (lc && lc->decimal_point) {
 	if (lc->decimal_point[0] == '.' && lc->decimal_point[1] == 0) {
 	    SvREFCNT_dec(PL_numeric_radix_sv);
-	    PL_numeric_radix_sv = Nullsv;
+	    PL_numeric_radix_sv = NULL;
 	}
 	else {
 	    if (PL_numeric_radix_sv)
@@ -98,7 +98,7 @@ Perl_set_numeric_radix(pTHX)
 	}
     }
     else
-	PL_numeric_radix_sv = Nullsv;
+	PL_numeric_radix_sv = NULL;
 # endif /* HAS_LOCALECONV */
 #endif /* USE_LOCALE_NUMERIC */
 }
diff --git a/mathoms.c b/mathoms.c
index 1371667f37..29dbc571d6 100644
--- a/mathoms.c
+++ b/mathoms.c
@@ -65,7 +65,7 @@ Taint an SV. Use C<SvTAINTED_on> instead.
 void
 Perl_sv_taint(pTHX_ SV *sv)
 {
-    sv_magic((sv), Nullsv, PERL_MAGIC_taint, NULL, 0);
+    sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
 }
 
 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
diff --git a/mg.c b/mg.c
index 2557885b44..2de5a86504 100644
--- a/mg.c
+++ b/mg.c
@@ -1974,7 +1974,7 @@ int
 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
 {
     dVAR;
-    SV *targ = Nullsv;
+    SV *targ = NULL;
     if (LvTARGLEN(sv)) {
 	if (mg->mg_obj) {
 	    SV * const ahv = LvTARG(sv);
@@ -1993,7 +1993,7 @@ Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
 	    LvTARG(sv) = SvREFCNT_inc(targ);
 	    LvTARGLEN(sv) = 0;
 	    SvREFCNT_dec(mg->mg_obj);
-	    mg->mg_obj = Nullsv;
+	    mg->mg_obj = NULL;
 	    mg->mg_flags &= ~MGf_REFCOUNTED;
 	}
     }
@@ -2021,7 +2021,7 @@ Perl_vivify_defelem(pTHX_ SV *sv)
 {
     dVAR;
     MAGIC *mg;
-    SV *value = Nullsv;
+    SV *value = NULL;
 
     if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
 	return;
@@ -2036,7 +2036,7 @@ Perl_vivify_defelem(pTHX_ SV *sv)
     else {
 	AV* const av = (AV*)LvTARG(sv);
 	if ((I32)LvTARGLEN(sv) < 0 && (I32)LvTARGOFF(sv) > AvFILL(av))
-	    LvTARG(sv) = Nullsv;	/* array can't be extended */
+	    LvTARG(sv) = NULL;	/* array can't be extended */
 	else {
 	    SV** const svp = av_fetch(av, LvTARGOFF(sv), TRUE);
 	    if (!svp || (value = *svp) == &PL_sv_undef)
@@ -2048,7 +2048,7 @@ Perl_vivify_defelem(pTHX_ SV *sv)
     LvTARG(sv) = value;
     LvTARGLEN(sv) = 0;
     SvREFCNT_dec(mg->mg_obj);
-    mg->mg_obj = Nullsv;
+    mg->mg_obj = NULL;
     mg->mg_flags &= ~MGf_REFCOUNTED;
 }
 
@@ -2194,7 +2194,7 @@ Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
 		PL_encoding = newSVsv(sv);
 	    }
 	    else {
-		PL_encoding = Nullsv;
+		PL_encoding = NULL;
 	    }
 	}
 	break;
@@ -2336,7 +2336,7 @@ Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
 	    PL_ors_sv = newSVsv(sv);
 	}
 	else {
-	    PL_ors_sv = Nullsv;
+	    PL_ors_sv = NULL;
 	}
 	break;
     case ',':
@@ -2346,7 +2346,7 @@ Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
 	    PL_ofs_sv = newSVsv(sv);
 	}
 	else {
-	    PL_ofs_sv = Nullsv;
+	    PL_ofs_sv = NULL;
 	}
 	break;
     case '[':
@@ -2620,8 +2620,8 @@ Perl_sighandler(int sig)
     dTHX;
 #endif
     dSP;
-    GV *gv = Nullgv;
-    SV *sv = Nullsv;
+    GV *gv = NULL;
+    SV *sv = NULL;
     SV * const tSv = PL_Sv;
     CV *cv = NULL;
     OP *myop = PL_op;
diff --git a/op.c b/op.c
index 51315e42f8..8dd29765ff 100644
--- a/op.c
+++ b/op.c
@@ -349,14 +349,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,
@@ -380,7 +380,7 @@ 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);
@@ -1683,7 +1683,7 @@ Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
 
     Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
 		     newSVpvs(ATTRSMODULE),
-                     Nullsv, prepend_elem(OP_LIST,
+                     NULL, prepend_elem(OP_LIST,
 				  newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
 				  prepend_elem(OP_LIST,
 					       newSVOP(OP_CONST, 0,
@@ -3233,13 +3233,13 @@ Perl_dofile(pTHX_ OP *term, I32 force_builtin)
 {
     dVAR;
     OP *doop;
-    GV *gv = Nullgv;
+    GV *gv = NULL;
 
     if (!force_builtin) {
 	gv = gv_fetchpvs("do", GV_NOTQUAL, SVt_PVCV);
 	if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
 	    GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "do", FALSE);
-	    gv = gvp ? *gvp : Nullgv;
+	    gv = gvp ? *gvp : NULL;
 	}
     }
 
@@ -3422,7 +3422,7 @@ 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) */
@@ -4282,7 +4282,7 @@ Perl_cv_undef(pTHX_ CV *cv)
 	LEAVE;
     }
     SvPOK_off((SV*)cv);		/* forget prototype */
-    CvGV(cv) = Nullgv;
+    CvGV(cv) = NULL;
 
     pad_undef(cv);
 
@@ -4308,7 +4308,7 @@ 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, NULL);
@@ -4378,10 +4378,10 @@ SV *
 Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 {
     dVAR;
-    SV *sv = Nullsv;
+    SV *sv = NULL;
 
     if (!o)
-	return Nullsv;
+	return NULL;
 
     if (o->op_type == OP_LINESEQ && cLISTOPo->op_first)
 	o = cLISTOPo->op_first->op_sibling;
@@ -4400,13 +4400,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 */
@@ -4414,7 +4414,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;
@@ -4425,7 +4425,7 @@ Perl_op_const_sv(pTHX_ const OP *o, CV *cv)
 	    }
 	}
 	else {
-	    return Nullsv;
+	    return NULL;
 	}
     }
     return sv;
@@ -4531,7 +4531,7 @@ 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, NULL);
 
@@ -5162,7 +5162,7 @@ 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;
 }
 
@@ -5705,7 +5705,7 @@ Perl_ck_fun(pTHX_ OP *o)
 				 OP *op = ((BINOP*)kid)->op_first;
 				 name = NULL;
 				 if (op) {
-				      SV *tmpstr = Nullsv;
+				      SV *tmpstr = NULL;
 				      const char * const a =
 					   kid->op_type == OP_AELEM ?
 					   "[]" : "{}";
@@ -5814,7 +5814,7 @@ Perl_ck_glob(pTHX_ OP *o)
 	GV *glob_gv;
 	ENTER;
 	Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
-		newSVpvs("File::Glob"), Nullsv, Nullsv, Nullsv);
+		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);
@@ -6108,7 +6108,7 @@ Perl_ck_method(pTHX_ OP *o)
 		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);
@@ -6189,7 +6189,7 @@ OP *
 Perl_ck_require(pTHX_ OP *o)
 {
     dVAR;
-    GV* gv = Nullgv;
+    GV* gv = NULL;
 
     if (o->op_flags & OPf_KIDS) {	/* Shall we supply missing .pm? */
 	SVOP * const kid = (SVOP*)cUNOPo->op_first;
@@ -6227,7 +6227,7 @@ Perl_ck_require(pTHX_ OP *o)
 	gv = gv_fetchpvs("require", GV_NOTQUAL, SVt_PVCV);
 	if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
 	    GV * const * const gvp = (GV**)hv_fetchs(PL_globalstash, "require", FALSE);
-	    gv = gvp ? *gvp : Nullgv;
+	    gv = gvp ? *gvp : NULL;
 	}
     }
 
@@ -6868,7 +6868,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
diff --git a/pad.c b/pad.c
index baf518e176..0b61c3c26c 100644
--- a/pad.c
+++ b/pad.c
@@ -180,7 +180,7 @@ Perl_pad_new(pTHX_ int flags)
 	AvREIFY_only(a0);
     }
     else {
-	av_store(pad, 0, Nullsv);
+	av_store(pad, 0, NULL);
     }
 
     AvREAL_off(padlist);
@@ -264,11 +264,11 @@ Perl_pad_undef(pTHX_ CV* cv)
 		CV * const innercv = (CV*)curpad[ix];
 		U32 inner_rc = SvREFCNT(innercv);
 		assert(inner_rc);
-		namepad[ix] = Nullsv;
+		namepad[ix] = NULL;
 		SvREFCNT_dec(namesv);
 
 		if (SvREFCNT(comppad) < 2) { /* allow for /(?{ sub{} })/  */
-		    curpad[ix] = Nullsv;
+		    curpad[ix] = NULL;
 		    SvREFCNT_dec(innercv);
 		    inner_rc--;
 		}
@@ -736,7 +736,7 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn,
 
 		/* our ? */
 		if ((SvFLAGS(*out_name_sv) & SVpad_OUR)) {
-		    *out_capture = Nullsv;
+		    *out_capture = NULL;
 		    return offset;
 		}
 
@@ -748,7 +748,7 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn,
 		    if (warn && ckWARN(WARN_CLOSURE))
 			Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
 			    "Variable \"%s\" is not available", name);
-		    *out_capture = Nullsv;
+		    *out_capture = NULL;
 		}
 
 		/* real value */
@@ -787,7 +787,7 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn,
 			if (ckWARN(WARN_CLOSURE))
 			    Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
 				"Variable \"%s\" is not available", name);
-			*out_capture = Nullsv;
+			*out_capture = NULL;
 		    }
 		}
 		if (!*out_capture) {
@@ -1180,7 +1180,7 @@ Perl_pad_tidy(pTHX_ padtidy_type type)
 
     /* extend curpad to match namepad */
     if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad))
-	av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv);
+	av_store(PL_comppad_name, AvFILLp(PL_comppad), NULL);
 
     if (type == padtidy_SUBCLONE) {
 	SV * const * const namep = AvARRAY(PL_comppad_name);
@@ -1196,12 +1196,12 @@ Perl_pad_tidy(pTHX_ padtidy_type type)
 	     * pad are anonymous subs.
 	     * The rest are created anew during cloning.
 	     */
-	    if (!((namesv = namep[ix]) != Nullsv &&
+	    if (!((namesv = namep[ix]) != NULL &&
 		  namesv != &PL_sv_undef &&
 		   *SvPVX_const(namesv) == '&'))
 	    {
 		SvREFCNT_dec(PL_curpad[ix]);
-		PL_curpad[ix] = Nullsv;
+		PL_curpad[ix] = NULL;
 	    }
 	}
     }
@@ -1314,7 +1314,7 @@ Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full)
     for (ix = 1; ix <= AvFILLp(pad_name); ix++) {
         const SV *namesv = pname[ix];
 	if (namesv && namesv == &PL_sv_undef) {
-	    namesv = Nullsv;
+	    namesv = NULL;
 	}
 	if (namesv) {
 	    if (SvFAKE(namesv))
@@ -1473,8 +1473,8 @@ Perl_cv_clone(pTHX_ CV *proto)
     outpad = AvARRAY(AvARRAY(CvPADLIST(outside))[depth]);
 
     for (ix = fpad; ix > 0; ix--) {
-	SV* const namesv = (ix <= fname) ? pname[ix] : Nullsv;
-	SV *sv = Nullsv;
+	SV* const namesv = (ix <= fname) ? pname[ix] : NULL;
+	SV *sv = NULL;
 	if (namesv && namesv != &PL_sv_undef) { /* lexical */
 	    if (SvFAKE(namesv)) {   /* lexical from outside? */
 		sv = outpad[(I32)SvNVX(namesv)];
@@ -1484,7 +1484,7 @@ Perl_cv_clone(pTHX_ CV *proto)
 		    if (ckWARN(WARN_CLOSURE))
 			Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
 			    "Variable \"%s\" is not available", SvPVX_const(namesv));
-		    sv = Nullsv;
+		    sv = NULL;
 		}
 		else {
 		    assert(!SvPADSTALE(sv));
diff --git a/pad.h b/pad.h
index 3733d10739..01370fecfd 100644
--- a/pad.h
+++ b/pad.h
@@ -138,7 +138,7 @@ Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
 
 #define PAD_BASE_SV(padlist, po) \
 	(AvARRAY(padlist)[1]) 	\
-	    ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : Nullsv;
+	    ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : NULL;
     
 
 #define PAD_SET_CUR_NOSAVE(padlist,n) \
diff --git a/perl.c b/perl.c
index 4718aa54d1..3229e16fcc 100644
--- a/perl.c
+++ b/perl.c
@@ -745,14 +745,14 @@ perl_destruct(pTHXx)
 	sv_clean_objs();
 	PL_sv_objcount = 0;
 	if (PL_defoutgv && !SvREFCNT(PL_defoutgv))
-	    PL_defoutgv = Nullgv; /* may have been freed */
+	    PL_defoutgv = NULL; /* may have been freed */
     }
 
     /* unhook hooks which will soon be, or use, destroyed data */
     SvREFCNT_dec(PL_warnhook);
-    PL_warnhook = Nullsv;
+    PL_warnhook = NULL;
     SvREFCNT_dec(PL_diehook);
-    PL_diehook = Nullsv;
+    PL_diehook = NULL;
 
     /* call exit list functions */
     while (PL_exitlistlen-- > 0)
@@ -803,7 +803,7 @@ perl_destruct(pTHXx)
 #endif /* !PERL_MICRO */
 
     /* reset so print() ends up where we expect */
-    setdefout(Nullgv);
+    setdefout(NULL);
 
 #ifdef USE_ITHREADS
     /* the syntax tree is shared between clones
@@ -871,7 +871,7 @@ perl_destruct(pTHXx)
 
     if (PL_e_script) {
 	SvREFCNT_dec(PL_e_script);
-	PL_e_script = Nullsv;
+	PL_e_script = NULL;
     }
 
     PL_perldb = 0;
@@ -879,27 +879,27 @@ perl_destruct(pTHXx)
     /* magical thingies */
 
     SvREFCNT_dec(PL_ofs_sv);	/* $, */
-    PL_ofs_sv = Nullsv;
+    PL_ofs_sv = NULL;
 
     SvREFCNT_dec(PL_ors_sv);	/* $\ */
-    PL_ors_sv = Nullsv;
+    PL_ors_sv = NULL;
 
     SvREFCNT_dec(PL_rs);	/* $/ */
-    PL_rs = Nullsv;
+    PL_rs = NULL;
 
     PL_multiline = 0;		/* $* */
     Safefree(PL_osname);	/* $^O */
     PL_osname = NULL;
 
     SvREFCNT_dec(PL_statname);
-    PL_statname = Nullsv;
-    PL_statgv = Nullgv;
+    PL_statname = NULL;
+    PL_statgv = NULL;
 
     /* defgv, aka *_ should be taken care of elsewhere */
 
     /* clean up after study() */
     SvREFCNT_dec(PL_lastscream);
-    PL_lastscream = Nullsv;
+    PL_lastscream = NULL;
     Safefree(PL_screamfirst);
     PL_screamfirst = 0;
     Safefree(PL_screamnext);
@@ -925,23 +925,23 @@ perl_destruct(pTHXx)
     PL_initav = NULL;
 
     /* shortcuts just get cleared */
-    PL_envgv = Nullgv;
-    PL_incgv = Nullgv;
-    PL_hintgv = Nullgv;
-    PL_errgv = Nullgv;
-    PL_argvgv = Nullgv;
-    PL_argvoutgv = Nullgv;
-    PL_stdingv = Nullgv;
-    PL_stderrgv = Nullgv;
-    PL_last_in_gv = Nullgv;
-    PL_replgv = Nullgv;
-    PL_DBgv = Nullgv;
-    PL_DBline = Nullgv;
-    PL_DBsub = Nullgv;
-    PL_DBsingle = Nullsv;
-    PL_DBtrace = Nullsv;
-    PL_DBsignal = Nullsv;
-    PL_DBassertion = Nullsv;
+    PL_envgv = NULL;
+    PL_incgv = NULL;
+    PL_hintgv = NULL;
+    PL_errgv = NULL;
+    PL_argvgv = NULL;
+    PL_argvoutgv = NULL;
+    PL_stdingv = NULL;
+    PL_stderrgv = NULL;
+    PL_last_in_gv = NULL;
+    PL_replgv = NULL;
+    PL_DBgv = NULL;
+    PL_DBline = NULL;
+    PL_DBsub = NULL;
+    PL_DBsingle = NULL;
+    PL_DBtrace = NULL;
+    PL_DBsignal = NULL;
+    PL_DBassertion = NULL;
     PL_DBcv = NULL;
     PL_dbargs = NULL;
     PL_debstash = NULL;
@@ -954,18 +954,18 @@ perl_destruct(pTHXx)
     SvREFCNT_dec(PL_preambleav);
     PL_preambleav = NULL;
     SvREFCNT_dec(PL_subname);
-    PL_subname = Nullsv;
+    PL_subname = NULL;
     SvREFCNT_dec(PL_linestr);
-    PL_linestr = Nullsv;
+    PL_linestr = NULL;
 #ifdef PERL_USES_PL_PIDSTATUS
     SvREFCNT_dec(PL_pidstatus);
     PL_pidstatus = NULL;
 #endif
     SvREFCNT_dec(PL_toptarget);
-    PL_toptarget = Nullsv;
+    PL_toptarget = NULL;
     SvREFCNT_dec(PL_bodytarget);
-    PL_bodytarget = Nullsv;
-    PL_formtarget = Nullsv;
+    PL_bodytarget = NULL;
+    PL_formtarget = NULL;
 
     /* free locale stuff */
 #ifdef USE_LOCALE_COLLATE
@@ -977,7 +977,7 @@ perl_destruct(pTHXx)
     Safefree(PL_numeric_name);
     PL_numeric_name = NULL;
     SvREFCNT_dec(PL_numeric_radix_sv);
-    PL_numeric_radix_sv = Nullsv;
+    PL_numeric_radix_sv = NULL;
 #endif
 
     /* clear utf8 character classes */
@@ -1001,33 +1001,33 @@ perl_destruct(pTHXx)
     SvREFCNT_dec(PL_utf8_tofold);
     SvREFCNT_dec(PL_utf8_idstart);
     SvREFCNT_dec(PL_utf8_idcont);
-    PL_utf8_alnum	= Nullsv;
-    PL_utf8_alnumc	= Nullsv;
-    PL_utf8_ascii	= Nullsv;
-    PL_utf8_alpha	= Nullsv;
-    PL_utf8_space	= Nullsv;
-    PL_utf8_cntrl	= Nullsv;
-    PL_utf8_graph	= Nullsv;
-    PL_utf8_digit	= Nullsv;
-    PL_utf8_upper	= Nullsv;
-    PL_utf8_lower	= Nullsv;
-    PL_utf8_print	= Nullsv;
-    PL_utf8_punct	= Nullsv;
-    PL_utf8_xdigit	= Nullsv;
-    PL_utf8_mark	= Nullsv;
-    PL_utf8_toupper	= Nullsv;
-    PL_utf8_totitle	= Nullsv;
-    PL_utf8_tolower	= Nullsv;
-    PL_utf8_tofold	= Nullsv;
-    PL_utf8_idstart	= Nullsv;
-    PL_utf8_idcont	= Nullsv;
+    PL_utf8_alnum	= NULL;
+    PL_utf8_alnumc	= NULL;
+    PL_utf8_ascii	= NULL;
+    PL_utf8_alpha	= NULL;
+    PL_utf8_space	= NULL;
+    PL_utf8_cntrl	= NULL;
+    PL_utf8_graph	= NULL;
+    PL_utf8_digit	= NULL;
+    PL_utf8_upper	= NULL;
+    PL_utf8_lower	= NULL;
+    PL_utf8_print	= NULL;
+    PL_utf8_punct	= NULL;
+    PL_utf8_xdigit	= NULL;
+    PL_utf8_mark	= NULL;
+    PL_utf8_toupper	= NULL;
+    PL_utf8_totitle	= NULL;
+    PL_utf8_tolower	= NULL;
+    PL_utf8_tofold	= NULL;
+    PL_utf8_idstart	= NULL;
+    PL_utf8_idcont	= NULL;
 
     if (!specialWARN(PL_compiling.cop_warnings))
 	SvREFCNT_dec(PL_compiling.cop_warnings);
-    PL_compiling.cop_warnings = Nullsv;
+    PL_compiling.cop_warnings = NULL;
     if (!specialCopIO(PL_compiling.cop_io))
 	SvREFCNT_dec(PL_compiling.cop_io);
-    PL_compiling.cop_io = Nullsv;
+    PL_compiling.cop_io = NULL;
     CopFILE_free(&PL_compiling);
     CopSTASH_free(&PL_compiling);
 
@@ -1037,11 +1037,11 @@ perl_destruct(pTHXx)
     PL_defstash = 0;
     SvREFCNT_dec(hv);
     SvREFCNT_dec(PL_curstname);
-    PL_curstname = Nullsv;
+    PL_curstname = NULL;
 
     /* clear queued errors */
     SvREFCNT_dec(PL_errors);
-    PL_errors = Nullsv;
+    PL_errors = NULL;
 
     FREETMPS;
     if (destruct_level >= 2 && ckWARN_d(WARN_INTERNAL)) {
@@ -1206,7 +1206,7 @@ perl_destruct(pTHXx)
 #endif
 
     /* sv_undef needs to stay immortal until after PerlIO_cleanup
-       as currently layers use it rather than Nullsv as a marker
+       as currently layers use it rather than NULL as a marker
        for no arg - and will try and SvREFCNT_dec it.
      */
     SvREFCNT(&PL_sv_undef) = 0;
@@ -1229,7 +1229,7 @@ perl_destruct(pTHXx)
     PL_bitcount = NULL;
     Safefree(PL_psig_pend);
     PL_psig_pend = (int*)NULL;
-    PL_formfeed = Nullsv;
+    PL_formfeed = NULL;
     nuke_stacks();
     PL_tainting = FALSE;
     PL_taint_warn = FALSE;
@@ -1264,7 +1264,7 @@ perl_destruct(pTHXx)
 	SvPV_free(PL_mess_sv);
 	Safefree(SvANY(PL_mess_sv));
 	Safefree(PL_mess_sv);
-	PL_mess_sv = Nullsv;
+	PL_mess_sv = NULL;
     }
     return STATUS_EXIT;
 }
@@ -2178,7 +2178,7 @@ S_parse_body(pTHX_ char **env, XSINIT_t xsinit)
     PL_preprocess = FALSE;
     if (PL_e_script) {
 	SvREFCNT_dec(PL_e_script);
-	PL_e_script = Nullsv;
+	PL_e_script = NULL;
     }
 
     if (PL_do_undump)
@@ -2339,7 +2339,7 @@ Perl_get_sv(pTHX_ const char *name, I32 create)
     gv = gv_fetchpv(name, create, SVt_PV);
     if (gv)
 	return GvSV(gv);
-    return Nullsv;
+    return NULL;
 }
 
 /*
@@ -3097,7 +3097,7 @@ Perl_moreswitches(pTHX_ char *s)
 	s++;
 	if (PL_ors_sv) {
 	    SvREFCNT_dec(PL_ors_sv);
-	    PL_ors_sv = Nullsv;
+	    PL_ors_sv = NULL;
 	}
 	if (isDIGIT(*s)) {
             I32 flags = 0;
@@ -4597,7 +4597,7 @@ S_init_postdump_symbols(pTHX_ register int argc, register char **argv, register
 	HV *hv;
 	GvMULTI_on(PL_envgv);
 	hv = GvHVn(PL_envgv);
-	hv_magic(hv, Nullgv, PERL_MAGIC_env);
+	hv_magic(hv, NULL, PERL_MAGIC_env);
 #ifndef PERL_MICRO
 #ifdef USE_ENVIRON_ARRAY
 	/* Note that if the supplied env parameter is actually a copy
@@ -4823,7 +4823,7 @@ S_incpush(pTHX_ const char *dir, bool addsubdirs, bool addoldvers, bool usesep,
 	  bool canrelocate)
 {
     dVAR;
-    SV *subdir = Nullsv;
+    SV *subdir = NULL;
     const char *p = dir;
 
     if (!p || !*p)
@@ -5319,7 +5319,7 @@ S_my_exit_jump(pTHX)
 
     if (PL_e_script) {
 	SvREFCNT_dec(PL_e_script);
-	PL_e_script = Nullsv;
+	PL_e_script = NULL;
     }
 
     POPSTACK_TO(PL_mainstack);
diff --git a/perlio.c b/perlio.c
index c2633f9239..fa993ec673 100644
--- a/perlio.c
+++ b/perlio.c
@@ -621,7 +621,7 @@ PerlIO_clone_list(pTHX_ PerlIO_list_t *proto, CLONE_PARAMS *param)
 	int i;
 	list = PerlIO_list_alloc(aTHX);
 	for (i=0; i < proto->cur; i++) {
-	    SV *arg = Nullsv;
+	    SV *arg = NULL;
 	    if (proto->array[i].arg)
 		arg = PerlIO_sv_dup(aTHX_ proto->array[i].arg,param);
 	    PerlIO_list_push(aTHX_ list, proto->array[i].funcs, arg);
@@ -776,7 +776,7 @@ PerlIO_find_layer(pTHX_ const char *name, STRLEN len, int load)
 	    /*
 	     * The two SVs are magically freed by load_module
 	     */
-	    Perl_load_module(aTHX_ 0, pkgsv, Nullsv, layer, Nullsv);
+	    Perl_load_module(aTHX_ 0, pkgsv, NULL, layer, NULL);
 	    PL_in_load_module--;
 	    LEAVE;
 	    return PerlIO_find_layer(aTHX_ name, len, 0);
@@ -910,7 +910,7 @@ PerlIO_define_layer(pTHX_ PerlIO_funcs *tab)
     dVAR;
     if (!PL_known_layers)
 	PL_known_layers = PerlIO_list_alloc(aTHX);
-    PerlIO_list_push(aTHX_ PL_known_layers, tab, Nullsv);
+    PerlIO_list_push(aTHX_ PL_known_layers, tab, NULL);
     PerlIO_debug("define %s %p\n", tab->name, (void*)tab);
 }
 
@@ -1355,7 +1355,7 @@ PerlIO_binmode(pTHX_ PerlIO *f, int iotype, int mode, const char *names)
 	/* Legacy binmode is now _defined_ as being equivalent to pushing :raw
 	   So code that used to be here is now in PerlIORaw_pushed().
 	 */
-	return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, Nullsv) ? TRUE : FALSE;
+	return PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_raw), NULL, NULL) ? TRUE : FALSE;
     }
 }
 
@@ -2069,7 +2069,7 @@ PerlIOBase_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count)
      * Save the position as current head considers it
      */
     const Off_t old = PerlIO_tell(f);
-    PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", Nullsv);
+    PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_pending), "r", NULL);
     PerlIOSelf(f, PerlIOBuf)->posn = old;
     return PerlIOBuf_unread(aTHX_ f, vbuf, count);
 }
@@ -2195,7 +2195,7 @@ SV *
 PerlIO_sv_dup(pTHX_ SV *arg, CLONE_PARAMS *param)
 {
     if (!arg)
-	return Nullsv;
+	return NULL;
 #ifdef sv_dup
     if (param) {
 	return sv_dup(arg, param);
@@ -2229,7 +2229,7 @@ PerlIOBase_dup(pTHX_ PerlIO *f, PerlIO *o, CLONE_PARAMS *param, int flags)
 	if (self->Getarg)
 	    arg = (*self->Getarg)(aTHX_ o, param, flags);
 	else {
-	    arg = Nullsv;
+	    arg = NULL;
 	}
 	f = PerlIO_push(aTHX_ f, self, PerlIO_modestr(o,buf), arg);
 	if (arg) {
@@ -2796,7 +2796,7 @@ PerlIO_importFILE(FILE *stdio, const char *mode)
 	    }
 	    fclose(f2);
 	}
-	if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, Nullsv))) {
+	if ((f = PerlIO_push(aTHX_(f = PerlIO_allocate(aTHX)), PERLIO_FUNCS_CAST(&PerlIO_stdio), mode, NULL))) {
 	    s = PerlIOSelf(f, PerlIOStdio);
 	    s->stdio = stdio;
 	}
@@ -3477,7 +3477,7 @@ PerlIO_exportFILE(PerlIO * f, const char *mode)
 	    PerlIO *f2;
 	    /* De-link any lower layers so new :stdio sticks */
 	    *f = NULL;
-	    if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, Nullsv))) {
+	    if ((f2 = PerlIO_push(aTHX_ f, PERLIO_FUNCS_CAST(&PerlIO_stdio), buf, NULL))) {
 		PerlIOStdio *s = PerlIOSelf((f = f2), PerlIOStdio);
 		s->stdio = stdio;
 		/* Link previous lower layers under new one */
@@ -5001,7 +5001,7 @@ PerlIO_tmpfile(void)
      if (stdio) {
 	  if ((f = PerlIO_push(aTHX_(PerlIO_allocate(aTHX)),
                                PERLIO_FUNCS_CAST(&PerlIO_stdio),
-			       "w+", Nullsv))) {
+			       "w+", NULL))) {
 	       PerlIOStdio * const s = PerlIOSelf(f, PerlIOStdio);
 
                if (s)
diff --git a/perlio.h b/perlio.h
index 8ff2bff2f4..d1e3dd5f55 100644
--- a/perlio.h
+++ b/perlio.h
@@ -174,7 +174,7 @@ PERL_EXPORT_C void PerlIO_clone(pTHX_ PerlInterpreter *proto,
 #endif				/* ifndef PERLIO_NOT_STDIO */
 #endif				/* PERLIO_IS_STDIO */
 
-#define specialCopIO(sv) ((sv) == Nullsv)
+#define specialCopIO(sv) ((sv) == NULL)
 
 /* ----------- fill in things that have not got #define'd  ---------- */
 
diff --git a/pp_ctl.c b/pp_ctl.c
index 7c08c771f4..e5e4dd9a5d 100644
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -2801,7 +2801,7 @@ Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, const char *code, PAD** padp)
     PL_op->op_type = OP_ENTEREVAL;
     PL_op->op_flags = 0;			/* Avoid uninit warning. */
     PUSHBLOCK(cx, CXt_EVAL|(IN_PERL_COMPILETIME ? 0 : CXp_REAL), SP);
-    PUSHEVAL(cx, 0, Nullgv);
+    PUSHEVAL(cx, 0, NULL);
 
     if (runtime)
 	rop = doeval(G_SCALAR, startop, runcv, PL_curcop->cop_seq);
@@ -3394,7 +3394,7 @@ PP(pp_require)
 
     /* switch to eval mode */
     PUSHBLOCK(cx, CXt_EVAL, SP);
-    PUSHEVAL(cx, name, Nullgv);
+    PUSHEVAL(cx, name, NULL);
     cx->blk_eval.retop = PL_op->op_next;
 
     SAVECOPLINE(&PL_compiling);
@@ -3492,7 +3492,7 @@ PP(pp_entereval)
     runcv = find_runcv(&seq);
 
     PUSHBLOCK(cx, (CXt_EVAL|CXp_REAL), SP);
-    PUSHEVAL(cx, 0, Nullgv);
+    PUSHEVAL(cx, 0, NULL);
     cx->blk_eval.retop = PL_op->op_next;
 
     /* prepare to compile string */
@@ -3732,7 +3732,7 @@ S_destroy_matcher(pTHX_ PMOP *matcher)
 /* Do a smart match */
 PP(pp_smartmatch)
 {
-    return do_smartmatch(Nullhv, Nullhv);
+    return do_smartmatch(NULL, NULL);
 }
 
 /* This version of do_smartmatch() implements the following
@@ -3973,11 +3973,11 @@ S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other)
 	    	I32 i;
 	    	const I32 other_len = av_len(other_av);
 
-		if (Nullhv == seen_this) {
+		if (NULL == seen_this) {
 		    seen_this = newHV();
 		    (void) sv_2mortal((SV *) seen_this);
 		}
-		if (Nullhv == seen_other) {
+		if (NULL == seen_other) {
 		    seen_this = newHV();
 		    (void) sv_2mortal((SV *) seen_other);
 		}
@@ -4551,15 +4551,15 @@ S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen)
 	IoLINES(datasv) = 0;
 	if (filter_child_proc) {
 	    SvREFCNT_dec(filter_child_proc);
-	    IoFMT_GV(datasv) = Nullgv;
+	    IoFMT_GV(datasv) = NULL;
 	}
 	if (filter_state) {
 	    SvREFCNT_dec(filter_state);
-	    IoTOP_GV(datasv) = Nullgv;
+	    IoTOP_GV(datasv) = NULL;
 	}
 	if (filter_sub) {
 	    SvREFCNT_dec(filter_sub);
-	    IoBOTTOM_GV(datasv) = Nullgv;
+	    IoBOTTOM_GV(datasv) = NULL;
 	}
 	filter_del(S_run_user_filter);
     }
diff --git a/pp_hot.c b/pp_hot.c
index babcb5e115..fb200e3348 100644
--- a/pp_hot.c
+++ b/pp_hot.c
@@ -1494,7 +1494,7 @@ yup:					/* Confirmed by INTUIT */
 
 	    rx->subbeg = savepvn(t, strend - t);
 #ifdef PERL_OLD_COPY_ON_WRITE
-	    rx->saved_copy = Nullsv;
+	    rx->saved_copy = NULL;
 #endif
 	}
 	rx->sublen = strend - t;
@@ -1961,7 +1961,7 @@ PP(pp_iter)
 
 	if (SvMAGICAL(av) || AvREIFY(av)) {
 	    SV * const * const svp = av_fetch(av, --cx->blk_loop.iterix, FALSE);
-	    sv = svp ? *svp : Nullsv;
+	    sv = svp ? *svp : NULL;
 	}
 	else {
 	    sv = AvARRAY(av)[--cx->blk_loop.iterix];
@@ -1974,7 +1974,7 @@ PP(pp_iter)
 
 	if (SvMAGICAL(av) || AvREIFY(av)) {
 	    SV * const * const svp = av_fetch(av, ++cx->blk_loop.iterix, FALSE);
-	    sv = svp ? *svp : Nullsv;
+	    sv = svp ? *svp : NULL;
 	}
 	else {
 	    sv = AvARRAY(av)[++cx->blk_loop.iterix];
@@ -1982,7 +1982,7 @@ PP(pp_iter)
     }
 
     if (sv && SvIS_FREED(sv)) {
-	*itersvp = Nullsv;
+	*itersvp = NULL;
 	Perl_croak(aTHX_ "Use of freed value in iteration");
     }
 
@@ -1994,7 +1994,7 @@ PP(pp_iter)
 	SV *lv = cx->blk_loop.iterlval;
 	if (lv && SvREFCNT(lv) > 1) {
 	    SvREFCNT_dec(lv);
-	    lv = Nullsv;
+	    lv = NULL;
 	}
 	if (lv)
 	    SvREFCNT_dec(LvTARG(lv));
@@ -2045,10 +2045,10 @@ PP(pp_subst)
 #ifdef PERL_OLD_COPY_ON_WRITE
     bool is_cow;
 #endif
-    SV *nsv = Nullsv;
+    SV *nsv = NULL;
 
     /* known replacement string? */
-    dstr = (pm->op_pmflags & PMf_CONST) ? POPs : Nullsv;
+    dstr = (pm->op_pmflags & PMf_CONST) ? POPs : NULL;
     if (PL_op->op_flags & OPf_STACKED)
 	TARG = POPs;
     else if (PL_op->op_private & OPpTARGET_MY)
@@ -2971,7 +2971,7 @@ PP(pp_aelem)
 	    lv = sv_newmortal();
 	    sv_upgrade(lv, SVt_PVLV);
 	    LvTYPE(lv) = 'y';
-	    sv_magic(lv, Nullsv, PERL_MAGIC_defelem, NULL, 0);
+	    sv_magic(lv, NULL, PERL_MAGIC_defelem, NULL, 0);
 	    LvTARG(lv) = SvREFCNT_inc(av);
 	    LvTARGOFF(lv) = elem;
 	    LvTARGLEN(lv) = 1;
@@ -3056,7 +3056,7 @@ S_method_common(pTHX_ SV* meth, U32* hashp)
     HV* stash;
     STRLEN namelen;
     const char* packname = NULL;
-    SV *packsv = Nullsv;
+    SV *packsv = NULL;
     STRLEN packlen;
     const char * const name = SvPV_const(meth, namelen);
     SV * const sv = *(PL_stack_base + TOPMARK + 1);
diff --git a/pp_pack.c b/pp_pack.c
index 3518298046..a5b81635f6 100644
--- a/pp_pack.c
+++ b/pp_pack.c
@@ -2541,7 +2541,7 @@ S_pack_rec(pTHX_ SV *cat, tempsym_t* symptr, SV **beglist, SV **endlist )
 	SV *fromstr;
 	STRLEN fromlen;
 	I32 len;
-	SV *lengthcode = Nullsv;
+	SV *lengthcode = NULL;
         I32 datumtype = symptr->code;
         howlen_t howlen = symptr->howlen;
 	char *start = SvPVX(cat);
diff --git a/pp_sort.c b/pp_sort.c
index aa363c622b..3ea07d57a0 100644
--- a/pp_sort.c
+++ b/pp_sort.c
@@ -1553,7 +1553,7 @@ PP(pp_sort)
 	    p2 = SP;
 	    for (i=0; i < max; i++) {
 		SV **svp = av_fetch(av, i, FALSE);
-		*SP++ = (svp) ? *svp : Nullsv;
+		*SP++ = (svp) ? *svp : NULL;
 	    }
 	}
 	else {
@@ -1842,7 +1842,7 @@ S_sv_i_ncmp(pTHX_ SV *a, SV *b)
 #define tryCALL_AMAGICbin(left,right,meth) \
     (PL_amagic_generation && (SvAMAGIC(left)||SvAMAGIC(right))) \
 	? amagic_call(left, right, CAT2(meth,_amg), 0) \
-	: Nullsv;
+	: NULL;
 
 static I32
 S_amagic_ncmp(pTHX_ register SV *a, register SV *b)
diff --git a/pp_sys.c b/pp_sys.c
index 8b99106aeb..fdda73034f 100644
--- a/pp_sys.c
+++ b/pp_sys.c
@@ -726,7 +726,7 @@ PP(pp_binmode)
     IO *io;
     PerlIO *fp;
     MAGIC *mg;
-    SV *discp = Nullsv;
+    SV *discp = NULL;
 
     if (MAXARG < 1)
 	RETPUSHUNDEF;
@@ -859,7 +859,7 @@ PP(pp_tie)
 	     SvTYPE(varsv) == SVt_PVHV))
 	    Perl_croak(aTHX_
 		       "Self-ties of arrays and hashes are not supported");
-	sv_magic(varsv, (SvRV(sv) == varsv ? Nullsv : sv), how, NULL, 0);
+	sv_magic(varsv, (SvRV(sv) == varsv ? NULL : sv), how, NULL, 0);
     }
     LEAVE;
     SP = PL_stack_base + markoff;
@@ -2752,7 +2752,7 @@ PP(pp_stat)
 	    goto do_fstat;
 	}
 	sv_setpv(PL_statname, SvPV_nolen_const(sv));
-	PL_statgv = Nullgv;
+	PL_statgv = NULL;
 	PL_laststype = PL_op->op_type;
 	if (PL_op->op_type == OP_LSTAT)
 	    PL_laststatval = PerlLIO_lstat(SvPV_nolen_const(PL_statname), &PL_statcache);
@@ -3089,7 +3089,7 @@ PP(pp_fttty)
     dSP;
     int fd;
     GV *gv;
-    SV *tmpsv = Nullsv;
+    SV *tmpsv = NULL;
 
     STACKED_FTEST_CHECK;
 
@@ -3149,7 +3149,7 @@ PP(pp_fttext)
     else if (SvROK(TOPs) && isGV(SvRV(TOPs)))
 	gv = (GV*)SvRV(POPs);
     else
-	gv = Nullgv;
+	gv = NULL;
 
     if (gv) {
 	EXTEND(SP, 1);
@@ -3204,7 +3204,7 @@ PP(pp_fttext)
     else {
 	sv = POPs;
       really_filename:
-	PL_statgv = Nullgv;
+	PL_statgv = NULL;
 	PL_laststype = OP_STAT;
 	sv_setpv(PL_statname, SvPV_nolen_const(sv));
 	if (!(fp = PerlIO_open(SvPVX_const(PL_statname), "r"))) {
@@ -4039,7 +4039,7 @@ PP(pp_system)
 	    value = (I32)do_aexec5(really, MARK, SP, pp[1], did_pipes);
 	}
 	else if (SP - MARK != 1)
-	    value = (I32)do_aexec5(Nullsv, MARK, SP, pp[1], did_pipes);
+	    value = (I32)do_aexec5(NULL, MARK, SP, pp[1], did_pipes);
 	else {
 	    value = (I32)do_exec3(SvPVx_nolen(sv_mortalcopy(*SP)), pp[1], did_pipes);
 	}
@@ -4058,9 +4058,9 @@ PP(pp_system)
     }
     else if (SP - MARK != 1) {
 #  if defined(WIN32) || defined(OS2) || defined(__SYMBIAN32__)
-	value = (I32)do_aspawn(Nullsv, MARK, SP);
+	value = (I32)do_aspawn(NULL, MARK, SP);
 #  else
-	value = (I32)do_aspawn(Nullsv, (void **)MARK, (void **)SP);
+	value = (I32)do_aspawn(NULL, (void **)MARK, (void **)SP);
 #  endif
     }
     else {
@@ -4098,15 +4098,15 @@ PP(pp_exec)
     }
     else if (SP - MARK != 1)
 #ifdef VMS
-	value = (I32)vms_do_aexec(Nullsv, MARK, SP);
+	value = (I32)vms_do_aexec(NULL, MARK, SP);
 #else
 #  ifdef __OPEN_VM
 	{
-	   (void ) do_aspawn(Nullsv, MARK, SP);
+	   (void ) do_aspawn(NULL, MARK, SP);
 	   value = 0;
 	}
 #  else
-	value = (I32)do_aexec(Nullsv, MARK, SP);
+	value = (I32)do_aexec(NULL, MARK, SP);
 #  endif
 #endif
     else {
diff --git a/regexec.c b/regexec.c
index 66d99bc09c..e374871ab6 100644
--- a/regexec.c
+++ b/regexec.c
@@ -832,9 +832,9 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	    SvREFCNT_dec(do_utf8 ? prog->check_utf8 : prog->check_substr);
 	    if (do_utf8 ? prog->check_substr : prog->check_utf8)
 		SvREFCNT_dec(do_utf8 ? prog->check_substr : prog->check_utf8);
-	    prog->check_substr = prog->check_utf8 = Nullsv;	/* disable */
-	    prog->float_substr = prog->float_utf8 = Nullsv;	/* clear */
-	    check = Nullsv;			/* abort */
+	    prog->check_substr = prog->check_utf8 = NULL;	/* disable */
+	    prog->float_substr = prog->float_utf8 = NULL;	/* clear */
+	    check = NULL;			/* abort */
 	    s = strpos;
 	    /* XXXX This is a remnant of the old implementation.  It
 	            looks wasteful, since now INTUIT can use many
@@ -1715,7 +1715,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    PL_reg_ganch = strbeg;
     }
 
-    if (!(flags & REXEC_CHECKED) && (prog->check_substr != Nullsv || prog->check_utf8 != Nullsv)) {
+    if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
 	re_scream_pos_data d;
 
 	d.scream_olds = &scream_olds;
@@ -1841,9 +1841,9 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
                                   "Did not find anchored character...\n")
                );
     }
-    else if (prog->anchored_substr != Nullsv
-	      || prog->anchored_utf8 != Nullsv
-	      || ((prog->float_substr != Nullsv || prog->float_utf8 != Nullsv)
+    else if (prog->anchored_substr != NULL
+	      || prog->anchored_utf8 != NULL
+	      || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
 		  && prog->float_max_offset < strend - s)) {
 	SV *must;
 	I32 back_max;
@@ -1965,7 +1965,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
     }
     else {
 	dontbother = 0;
-	if (prog->float_substr != Nullsv || prog->float_utf8 != Nullsv) {
+	if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
 	    /* Trim the end. */
 	    char *last;
 	    SV* float_real;
diff --git a/scope.c b/scope.c
index 570d9aa8a4..343c6ff607 100644
--- a/scope.c
+++ b/scope.c
@@ -150,7 +150,7 @@ Perl_free_tmps(pTHX)
     const I32 myfloor = PL_tmps_floor;
     while (PL_tmps_ix > myfloor) {      /* clean up after last statement */
 	SV* const sv = PL_tmps_stack[PL_tmps_ix];
-	PL_tmps_stack[PL_tmps_ix--] = Nullsv;
+	PL_tmps_stack[PL_tmps_ix--] = NULL;
 	if (sv && sv != &PL_sv_undef) {
 	    SvTEMP_off(sv);
 	    SvREFCNT_dec(sv);		/* note, can modify tmps_ix!!! */
diff --git a/sv.c b/sv.c
index 2b2f1885f1..0fc488da68 100644
--- a/sv.c
+++ b/sv.c
@@ -4466,7 +4466,7 @@ S_sv_del_backref(pTHX_ SV *tsv, SV *sv)
 		*/
 		svp[i] = svp[fill];
 	    }
-	    svp[fill] = Nullsv;
+	    svp[fill] = NULL;
 	    AvFILLp(av) = fill - 1;
 	}
     }
@@ -4504,7 +4504,7 @@ Perl_sv_kill_backrefs(pTHX_ SV *sv, AV *av)
 			       (UV)SvFLAGS(referrer));
 		}
 
-		*svp = Nullsv;
+		*svp = NULL;
 	    }
 	    svp++;
 	}
@@ -5417,7 +5417,7 @@ Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2)
     STRLEN cur2;
     I32  eq     = 0;
     char *tpv   = NULL;
-    SV* svrecode = Nullsv;
+    SV* svrecode = NULL;
 
     if (!sv1) {
 	pv1 = "";
@@ -5511,7 +5511,7 @@ Perl_sv_cmp(pTHX_ register SV *sv1, register SV *sv2)
     const char *pv1, *pv2;
     char *tpv = NULL;
     I32  cmp;
-    SV *svrecode = Nullsv;
+    SV *svrecode = NULL;
 
     if (!sv1) {
 	pv1 = "";
@@ -6711,7 +6711,7 @@ Perl_newSVsv(pTHX_ register SV *old)
     if (SvTYPE(old) == SVTYPEMASK) {
         if (ckWARN_d(WARN_INTERNAL))
 	    Perl_warner(aTHX_ packWARN(WARN_INTERNAL), "semi-panic: attempt to dup freed string");
-	return Nullsv;
+	return NULL;
     }
     new_SV(sv);
     /* SV_GMAGIC is the default for sv_setv()
@@ -6872,20 +6872,20 @@ CV *
 Perl_sv_2cv(pTHX_ SV *sv, HV **st, GV **gvp, I32 lref)
 {
     dVAR;
-    GV *gv = Nullgv;
+    GV *gv = NULL;
     CV *cv = NULL;
 
     if (!sv)
-	return *st = NULL, *gvp = Nullgv, NULL;
+	return *st = NULL, *gvp = NULL, NULL;
     switch (SvTYPE(sv)) {
     case SVt_PVCV:
 	*st = CvSTASH(sv);
-	*gvp = Nullgv;
+	*gvp = NULL;
 	return (CV*)sv;
     case SVt_PVHV:
     case SVt_PVAV:
 	*st = NULL;
-	*gvp = Nullgv;
+	*gvp = NULL;
 	return NULL;
     case SVt_PVGV:
 	gv = (GV*)sv;
@@ -6902,7 +6902,7 @@ Perl_sv_2cv(pTHX_ SV *sv, HV **st, GV **gvp, I32 lref)
 	    sv = SvRV(sv);
 	    if (SvTYPE(sv) == SVt_PVCV) {
 		cv = (CV*)sv;
-		*gvp = Nullgv;
+		*gvp = NULL;
 		*st = CvSTASH(cv);
 		return cv;
 	    }
@@ -7835,10 +7835,10 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
     STRLEN origlen;
     I32 svix = 0;
     static const char nullstr[] = "(null)";
-    SV *argsv = Nullsv;
+    SV *argsv = NULL;
     bool has_utf8 = DO_UTF8(sv);    /* has the result utf8? */
     const bool pat_utf8 = has_utf8; /* the pattern is in utf8? */
-    SV *nsv = Nullsv;
+    SV *nsv = NULL;
     /* Times 4: a decimal digit takes more than 3 binary digits.
      * NV_DIG: mantissa takes than many decimal digits.
      * Plus 32: Playing safe. */
@@ -7942,7 +7942,7 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
 
 	const char *eptr = NULL;
 	STRLEN elen = 0;
-	SV *vecsv = Nullsv;
+	SV *vecsv = NULL;
 	const U8 *vecstr = Null(U8*);
 	STRLEN veclen = 0;
 	char c = 0;
@@ -9032,7 +9032,7 @@ Perl_re_dup(pTHX_ const REGEXP *r, CLONE_PARAMS *param)
     else
 	ret->subbeg = NULL;
 #ifdef PERL_OLD_COPY_ON_WRITE
-    ret->saved_copy = Nullsv;
+    ret->saved_copy = NULL;
 #endif
 
     ptr_table_store(PL_ptr_table, r, ret);
@@ -9642,7 +9642,7 @@ Perl_sv_dup(pTHX_ const SV *sstr, CLONE_PARAMS* param)
 		/* don't dup if copying back - CvGV isn't refcounted, so the
 		 * duped GV may never be freed. A bit of a hack! DAPM */
 		CvGV(dstr)	= (param->flags & CLONEf_JOIN_IN) ?
-		    Nullgv : gv_dup(CvGV(dstr), param) ;
+		    NULL : gv_dup(CvGV(dstr), param) ;
 		if (!(param->flags & CLONEf_COPY_STACKS)) {
 		    CvDEPTH(dstr) = 0;
 		}
@@ -10285,8 +10285,8 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_nice_chunk_size	= 0;
     PL_sv_count		= 0;
     PL_sv_objcount	= 0;
-    PL_sv_root		= Nullsv;
-    PL_sv_arenaroot	= Nullsv;
+    PL_sv_root		= NULL;
+    PL_sv_arenaroot	= NULL;
 
     PL_debug		= proto_perl->Idebug;
 
@@ -10516,7 +10516,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_preambleav	= av_dup_inc(proto_perl->Ipreambleav, param);
     PL_laststatval	= proto_perl->Ilaststatval;
     PL_laststype	= proto_perl->Ilaststype;
-    PL_mess_sv		= Nullsv;
+    PL_mess_sv		= NULL;
 
     PL_ors_sv		= sv_dup_inc(proto_perl->Iors_sv, param);
 
@@ -10844,7 +10844,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
 
     PL_op		= proto_perl->Top;
 
-    PL_Sv		= Nullsv;
+    PL_Sv		= NULL;
     PL_Xpv		= (XPV*)NULL;
     PL_na		= proto_perl->Tna;
 
@@ -10891,7 +10891,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_screamfirst	= NULL;
     PL_screamnext	= NULL;
     PL_maxscream	= -1;			/* reinits on demand */
-    PL_lastscream	= Nullsv;
+    PL_lastscream	= NULL;
 
     PL_watchaddr	= NULL;
     PL_watchok		= NULL;
@@ -10923,7 +10923,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_reg_call_cc	= (struct re_cc_state*)NULL;
     PL_reg_re		= (regexp*)NULL;
     PL_reg_ganch	= NULL;
-    PL_reg_sv		= Nullsv;
+    PL_reg_sv		= NULL;
     PL_reg_match_utf8	= FALSE;
     PL_reg_magic	= (MAGIC*)NULL;
     PL_reg_oldpos	= 0;
@@ -10932,7 +10932,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_reg_oldsaved	= NULL;
     PL_reg_oldsavedlen	= 0;
 #ifdef PERL_OLD_COPY_ON_WRITE
-    PL_nrs		= Nullsv;
+    PL_nrs		= NULL;
 #endif
     PL_reg_maxiter	= 0;
     PL_reg_leftiter	= 0;
@@ -11125,7 +11125,7 @@ S_find_hash_subscript(pTHX_ HV *hv, SV* val)
 
     if (!hv || SvMAGICAL(hv) || !HvARRAY(hv) ||
 			(HvTOTALKEYS(hv) > FUV_MAX_SEARCH_SIZE))
-	return Nullsv;
+	return NULL;
 
     array = HvARRAY(hv);
 
@@ -11138,13 +11138,13 @@ S_find_hash_subscript(pTHX_ HV *hv, SV* val)
 		    HeVAL(entry) == &PL_sv_placeholder)
 		continue;
 	    if (!HeKEY(entry))
-		return Nullsv;
+		return NULL;
 	    if (HeKLEN(entry) == HEf_SVKEY)
 		return sv_mortalcopy(HeKEY_sv(entry));
 	    return sv_2mortal(newSVpvn(HeKEY(entry), HeKLEN(entry)));
 	}
     }
-    return Nullsv;
+    return NULL;
 }
 
 /* Look for an entry in the array whose value has the same SV as val;
@@ -11210,7 +11210,7 @@ S_varname(pTHX_ GV *gv, const char gvtype, PADOFFSET targ,
 	AV *av;
 
 	if (!cv || !CvPADLIST(cv))
-	    return Nullsv;
+	    return NULL;
 	av = (AV*)(*av_fetch(CvPADLIST(cv), 0, FALSE));
 	sv = *av_fetch(av, targ, FALSE);
 	/* SvLEN in a pad name is not to be trusted */
@@ -11266,7 +11266,7 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 
     if (!obase || (match && (!uninit_sv || uninit_sv == &PL_sv_undef ||
 			    uninit_sv == &PL_sv_placeholder)))
-	return Nullsv;
+	return NULL;
 
     switch (obase->op_type) {
 
@@ -11278,12 +11278,12 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 	const bool pad  = (obase->op_type == OP_PADAV || obase->op_type == OP_PADHV);
 	const bool hash = (obase->op_type == OP_PADHV || obase->op_type == OP_RV2HV);
 	I32 index = 0;
-	SV *keysv = Nullsv;
+	SV *keysv = NULL;
 	int subscript_type = FUV_SUBSCRIPT_WITHIN;
 
 	if (pad) { /* @lex, %lex */
 	    sv = PAD_SVl(obase->op_targ);
-	    gv = Nullgv;
+	    gv = NULL;
 	}
 	else {
 	    if (cUNOPx(obase)->op_first->op_type == OP_GV) {
@@ -11320,14 +11320,14 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
     case OP_PADSV:
 	if (match && PAD_SVl(obase->op_targ) != uninit_sv)
 	    break;
-	return varname(Nullgv, '$', obase->op_targ,
-				    Nullsv, 0, FUV_SUBSCRIPT_NONE);
+	return varname(NULL, '$', obase->op_targ,
+				    NULL, 0, FUV_SUBSCRIPT_NONE);
 
     case OP_GVSV:
 	gv = cGVOPx_gv(obase);
 	if (!gv || (match && GvSV(gv) != uninit_sv))
 	    break;
-	return varname(gv, '$', 0, Nullsv, 0, FUV_SUBSCRIPT_NONE);
+	return varname(gv, '$', 0, NULL, 0, FUV_SUBSCRIPT_NONE);
 
     case OP_AELEMFAST:
 	if (obase->op_flags & OPf_SPECIAL) { /* lexical array */
@@ -11340,8 +11340,8 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 		if (!svp || *svp != uninit_sv)
 		    break;
 	    }
-	    return varname(Nullgv, '$', obase->op_targ,
-		    Nullsv, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
+	    return varname(NULL, '$', obase->op_targ,
+		    NULL, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
 	}
 	else {
 	    gv = cGVOPx_gv(obase);
@@ -11357,7 +11357,7 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 		    break;
 	    }
 	    return varname(gv, '$', 0,
-		    Nullsv, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
+		    NULL, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
 	}
 	break;
 
@@ -11374,12 +11374,12 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 	    /* $a[uninit_expr] or $h{uninit_expr} */
 	    return find_uninit_var(cBINOPx(obase)->op_last, uninit_sv, match);
 
-	gv = Nullgv;
+	gv = NULL;
 	o = cBINOPx(obase)->op_first;
 	kid = cBINOPx(obase)->op_last;
 
 	/* get the av or hv, and optionally the gv */
-	sv = Nullsv;
+	sv = NULL;
 	if  (o->op_type == OP_PADAV || o->op_type == OP_PADHV) {
 	    sv = PAD_SV(o->op_targ);
 	}
@@ -11414,7 +11414,7 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 		return varname(gv, '%', o->op_targ,
 			    cSVOPx_sv(kid), 0, FUV_SUBSCRIPT_HASH);
 	    else
-		return varname(gv, '@', o->op_targ, Nullsv,
+		return varname(gv, '@', o->op_targ, NULL,
 			    SvIV(cSVOPx_sv(kid)), FUV_SUBSCRIPT_ARRAY);
 	}
 	else  {
@@ -11430,14 +11430,14 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 		const I32 index = S_find_array_subscript(aTHX_ (AV*)sv, uninit_sv);
 		if (index >= 0)
 		    return varname(gv, '@', o->op_targ,
-					Nullsv, index, FUV_SUBSCRIPT_ARRAY);
+					NULL, index, FUV_SUBSCRIPT_ARRAY);
 	    }
 	    if (match)
 		break;
 	    return varname(gv,
 		(o->op_type == OP_PADAV || o->op_type == OP_RV2AV)
 		? '@' : '%',
-		o->op_targ, Nullsv, 0, FUV_SUBSCRIPT_WITHIN);
+		o->op_targ, NULL, 0, FUV_SUBSCRIPT_WITHIN);
 	}
 
 	break;
@@ -11459,7 +11459,7 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 		if (match && GvSV(gv) != uninit_sv)
 		    break;
 		return varname(gv, '$', 0,
-			    Nullsv, 0, FUV_SUBSCRIPT_NONE);
+			    NULL, 0, FUV_SUBSCRIPT_NONE);
 	    }
 	    /* other possibilities not handled are:
 	     * open $x; or open my $x;	should return '${*$x}'
@@ -11545,7 +11545,7 @@ S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 	}
 	break;
     }
-    return Nullsv;
+    return NULL;
 }
 
 
@@ -11562,7 +11562,7 @@ Perl_report_uninit(pTHX_ SV* uninit_sv)
 {
     dVAR;
     if (PL_op) {
-	SV* varname = Nullsv;
+	SV* varname = NULL;
 	if (uninit_sv) {
 	    varname = find_uninit_var(PL_op, uninit_sv,0);
 	    if (varname)
diff --git a/sv.h b/sv.h
index f72db8409d..89b4a9eb7d 100644
--- a/sv.h
+++ b/sv.h
@@ -1054,7 +1054,7 @@ Taints an SV if tainting is enabled.
 =cut
 */
 
-#define sv_taint(sv)	  sv_magic((sv), Nullsv, PERL_MAGIC_taint, NULL, 0)
+#define sv_taint(sv)	  sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0)
 
 #define SvTAINTED(sv)	  (SvMAGICAL(sv) && sv_tainted(sv))
 #define SvTAINTED_on(sv)  STMT_START{ if(PL_tainting){sv_taint(sv);}   }STMT_END
diff --git a/thrdvar.h b/thrdvar.h
index 18c426ce2e..274547034e 100644
--- a/thrdvar.h
+++ b/thrdvar.h
@@ -77,7 +77,7 @@ PERLVAR(Tna,		STRLEN)		/* for use in SvPV when length is
 PERLVAR(Tstatbuf,	Stat_t)
 PERLVAR(Tstatcache,	Stat_t)		/* _ */
 PERLVAR(Tstatgv,	GV *)
-PERLVARI(Tstatname,	SV *,	Nullsv)
+PERLVARI(Tstatname,	SV *,	NULL)
 
 #ifdef HAS_TIMES
 PERLVAR(Ttimesbuf,	struct tms)
@@ -130,7 +130,7 @@ PERLVAR(Tmainstack,	AV *)		/* the stack when nothing funny is happening */
 
 PERLVAR(Ttop_env,	JMPENV *)	/* ptr. to current sigjmp() environment */
 PERLVAR(Tstart_env,	JMPENV)		/* empty startup sigjmp() environment */
-PERLVARI(Terrors,	SV *, Nullsv)	/* outstanding queued errors */
+PERLVARI(Terrors,	SV *, NULL)	/* outstanding queued errors */
 
 /* statics "owned" by various functions */
 PERLVAR(Tav_fetch_sv,	SV *)		/* unused as of change #19268 */
diff --git a/toke.c b/toke.c
index db51dbcbec..8f01720491 100644
--- a/toke.c
+++ b/toke.c
@@ -605,8 +605,8 @@ Perl_lex_start(pTHX_ SV *line)
     *PL_lex_casestack = '\0';
     PL_lex_dojoin = 0;
     PL_lex_starts = 0;
-    PL_lex_stuff = Nullsv;
-    PL_lex_repl = Nullsv;
+    PL_lex_stuff = NULL;
+    PL_lex_repl = NULL;
     PL_lex_inpat = 0;
     PL_nexttoke = 0;
     PL_lex_inwhat = 0;
@@ -1223,7 +1223,7 @@ S_sublex_start(pTHX)
 	    sv = nsv;
 	}
 	yylval.opval = (OP*)newSVOP(op_type, 0, sv);
-	PL_lex_stuff = Nullsv;
+	PL_lex_stuff = NULL;
 	/* Allow <FH> // "foo" */
 	if (op_type == OP_READLINE)
 	    PL_expect = XTERMORDORDOR;
@@ -1280,7 +1280,7 @@ S_sublex_push(pTHX)
     SAVEGENERICPV(PL_lex_casestack);
 
     PL_linestr = PL_lex_stuff;
-    PL_lex_stuff = Nullsv;
+    PL_lex_stuff = NULL;
 
     PL_bufend = PL_bufptr = PL_oldbufptr = PL_oldoldbufptr = PL_linestart
 	= SvPVX(PL_linestr);
@@ -1353,7 +1353,7 @@ S_sublex_done(pTHX)
 	}
 	else {
 	    PL_lex_state = LEX_INTERPCONCAT;
-	    PL_lex_repl = Nullsv;
+	    PL_lex_repl = NULL;
 	}
 	return ',';
     }
@@ -1789,7 +1789,7 @@ S_scan_const(pTHX_ char *start)
 		    }
 		    res = newSVpvn(s + 1, e - s - 1);
 		    res = new_constant( NULL, 0, "charnames",
-					res, Nullsv, "\\N{...}" );
+					res, NULL, "\\N{...}" );
 		    if (has_utf8)
 			sv_utf8_upgrade(res);
 		    str = SvPV_const(res,len);
@@ -1938,7 +1938,7 @@ S_scan_const(pTHX_ char *start)
     if (s > PL_bufptr) {
 	if ( PL_hints & ( PL_lex_inpat ? HINT_NEW_RE : HINT_NEW_STRING ) )
 	    sv = new_constant(start, s - start, (PL_lex_inpat ? "qr" : "q"),
-			      sv, Nullsv,
+			      sv, NULL,
 			      ( PL_lex_inwhat == OP_TRANS
 				? "tr"
 				: ( (PL_lex_inwhat == OP_SUBST && !PL_lex_inpat)
@@ -2239,7 +2239,7 @@ Perl_filter_add(pTHX_ filter_t funcp, SV *datasv)
 {
     dVAR;
     if (!funcp)
-	return Nullsv;
+	return NULL;
 
     if (!PL_rsfp_filters)
 	PL_rsfp_filters = newAV();
@@ -2622,7 +2622,7 @@ Perl_yylex(pTHX)
 	{
 	    if (PL_bufptr != PL_bufend)
 		Perl_croak(aTHX_ "Bad evalled substitution pattern");
-	    PL_lex_repl = Nullsv;
+	    PL_lex_repl = NULL;
 	}
 	/* FALLTHROUGH */
     case LEX_INTERPCONCAT:
@@ -3311,7 +3311,7 @@ Perl_yylex(pTHX)
 		    attrs = append_elem(OP_LIST, attrs,
 					newSVOP(OP_CONST, 0, sv));
 		    SvREFCNT_dec(PL_lex_stuff);
-		    PL_lex_stuff = Nullsv;
+		    PL_lex_stuff = NULL;
 		}
 		else {
 		    if (len == 6 && strnEQ(s, "unique", len)) {
@@ -4225,7 +4225,7 @@ Perl_yylex(pTHX)
 		    Perl_warner(aTHX_ packWARN(WARN_MISC),
 			    "dump() better written as CORE::dump()");
 		}
-		gv = Nullgv;
+		gv = NULL;
 		gvp = 0;
 		if (hgv && tmp != KEY_x && tmp != KEY_CORE
 			&& ckWARN(WARN_AMBIGUOUS))	/* never ambiguous */
@@ -4292,7 +4292,7 @@ Perl_yylex(pTHX)
 			     PL_tokenbuf);
 		    len -= 2;
 		    PL_tokenbuf[len] = '\0';
-		    gv = Nullgv;
+		    gv = NULL;
 		    gvp = 0;
 		}
 		else {
@@ -5211,7 +5211,7 @@ Perl_yylex(pTHX)
 	    }
 	    if (PL_lex_stuff) {
 		SvREFCNT_dec(PL_lex_stuff);
-		PL_lex_stuff = Nullsv;
+		PL_lex_stuff = NULL;
 	    }
 	    PL_expect = XTERM;
 	    TOKEN('(');
@@ -5535,7 +5535,7 @@ Perl_yylex(pTHX)
 		if (have_proto) {
 		    PL_nextval[PL_nexttoke].opval =
 			(OP*)newSVOP(OP_CONST, 0, PL_lex_stuff);
-		    PL_lex_stuff = Nullsv;
+		    PL_lex_stuff = NULL;
 		    force_next(THING);
 		}
 		if (!have_name) {
@@ -9626,7 +9626,7 @@ S_scan_subst(pTHX_ char *start)
     if (!s) {
 	if (PL_lex_stuff) {
 	    SvREFCNT_dec(PL_lex_stuff);
-	    PL_lex_stuff = Nullsv;
+	    PL_lex_stuff = NULL;
 	}
 	Perl_croak(aTHX_ "Substitution replacement not terminated");
     }
@@ -9694,7 +9694,7 @@ S_scan_trans(pTHX_ char *start)
     if (!s) {
 	if (PL_lex_stuff) {
 	    SvREFCNT_dec(PL_lex_stuff);
-	    PL_lex_stuff = Nullsv;
+	    PL_lex_stuff = NULL;
 	}
 	Perl_croak(aTHX_ "Transliteration replacement not terminated");
     }
@@ -10446,7 +10446,7 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp)
     register char *d;			/* destination in temp buffer */
     register char *e;			/* end of temp buffer */
     NV nv;				/* number read, as a double */
-    SV *sv = Nullsv;			/* place to put the converted number */
+    SV *sv = NULL;			/* place to put the converted number */
     bool floatit;			/* boolean: int or float? */
     const char *lastub = NULL;		/* position of last underbar */
     static char const number_too_long[] = "Number too long";
@@ -10630,9 +10630,9 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp)
 	    }
 	    if (just_zero && (PL_hints & HINT_NEW_INTEGER))
 		sv = new_constant(start, s - start, "integer",
-				  sv, Nullsv, NULL);
+				  sv, NULL, NULL);
 	    else if (PL_hints & HINT_NEW_BINARY)
-		sv = new_constant(start, s - start, "binary", sv, Nullsv, NULL);
+		sv = new_constant(start, s - start, "binary", sv, NULL, NULL);
 	}
 	break;
 
@@ -10799,7 +10799,7 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp)
 	               (PL_hints & HINT_NEW_INTEGER) )
 	    sv = new_constant(PL_tokenbuf, d - PL_tokenbuf,
 			      (floatit ? "float" : "integer"),
-			      sv, Nullsv, NULL);
+			      sv, NULL, NULL);
 	break;
 
     /* if it starts with a v, it could be a v-string */
diff --git a/utf8.c b/utf8.c
index c80802a6e0..d9533301ff 100644
--- a/utf8.c
+++ b/utf8.c
@@ -1597,7 +1597,7 @@ Perl_swash_init(pTHX_ const char* pkg, const char* name, SV *listsv, I32 minbits
 	ENTER;
 	errsv_save = newSVsv(ERRSV);
 	Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT, newSVpvn(pkg,pkg_len),
-			 Nullsv);
+			 NULL);
 	if (!SvTRUE(ERRSV))
 	    sv_setsv(ERRSV, errsv_save);
 	SvREFCNT_dec(errsv_save);
diff --git a/util.c b/util.c
index b70d3154a4..9370b84cbd 100644
--- a/util.c
+++ b/util.c
@@ -461,7 +461,7 @@ Perl_fbm_compile(pTHX_ SV *sv, U32 flags)
 	    s--, i++;
 	}
     }
-    sv_magic(sv, Nullsv, PERL_MAGIC_bm, NULL, 0);	/* deep magic */
+    sv_magic(sv, NULL, PERL_MAGIC_bm, NULL, 0);	/* deep magic */
     SvVALID_on(sv);
 
     s = (const unsigned char*)(SvPVX_const(sv));	/* deeper magic */
@@ -1100,7 +1100,7 @@ Perl_write_to_stderr(pTHX_ const char* message, int msglen)
 
 	save_re_context();
 	SAVESPTR(PL_stderrgv);
-	PL_stderrgv = Nullgv;
+	PL_stderrgv = NULL;
 
 	PUSHSTACKi(PERLSI_MAGIC);
 
@@ -2129,7 +2129,7 @@ Perl_my_popen_list(pTHX_ char *mode, int n, SV **args)
 	    }
 	}
 #endif
-	do_aexec5(Nullsv, args-1, args-1+n, pp[1], did_pipes);
+	do_aexec5(NULL, args-1, args-1+n, pp[1], did_pipes);
 	PerlProc__exit(1);
 #undef THIS
 #undef THAT
diff --git a/warnings.pl b/warnings.pl
index ebe8759cb6..e8971d852b 100644
--- a/warnings.pl
+++ b/warnings.pl
@@ -276,9 +276,9 @@ print WARN <<'EOM' ;
 #define G_WARN_ONCE		8	/* set if 'once' ever enabled */
 #define G_WARN_ALL_MASK		(G_WARN_ALL_ON|G_WARN_ALL_OFF)
 
-#define pWARN_STD		Nullsv
-#define pWARN_ALL		(Nullsv+1)	/* use warnings 'all' */
-#define pWARN_NONE		(Nullsv+2)	/* no  warnings 'all' */
+#define pWARN_STD		NULL
+#define pWARN_ALL		(NULL+1)	/* use warnings 'all' */
+#define pWARN_NONE		(NULL+2)	/* no  warnings 'all' */
 
 #define specialWARN(x)		((x) == pWARN_STD || (x) == pWARN_ALL ||	\
 				 (x) == pWARN_NONE)