Stas' croak patch and then some

Message-ID: <20051013214212.GA1122@petdance.com>

p4raw-id: //depot/perl@25754

12 files changed, 157 insertions, 155 deletions

diff --git a/embed.fnc b/embed.fnc
index edfba7f2c5..0ba6c4eb5d 100644
--- a/embed.fnc
+++ b/embed.fnc
@@ -128,7 +128,8 @@ ApR	|UV	|cast_uv	|NV f
 ApR	|I32	|my_chsize	|int fd|Off_t length
 #endif
 pR	|OP*	|convert	|I32 optype|I32 flags|NULLOK OP* o
-Afprd	|void	|croak		|NN const char* pat|...
+: croak()'s first parm can be NULL.  Otherwise, mod_perl breaks.
+Afprd	|void	|croak		|NULLOK const char* pat|...
 Apr	|void	|vcroak		|NN const char* pat|NULLOK va_list* args
 #if defined(PERL_IMPLICIT_CONTEXT)
 Afnrp	|void	|croak_nocontext|NN const char* pat|...
@@ -760,7 +761,7 @@ Apd	|int	|getcwd_sv	|NN SV* sv
 Apd	|void	|sv_dec		|NN SV* sv
 Ap	|void	|sv_dump	|NN SV* sv
 ApdR	|bool	|sv_derived_from|NN SV* sv|NN const char* name
-Apd	|I32	|sv_eq		|NN SV* sv1|NN SV* sv2
+Apd	|I32	|sv_eq		|NULLOK SV* sv1|NULLOK SV* sv2
 Apd	|void	|sv_free	|NULLOK SV* sv
 poMX	|void	|sv_free2	|NN SV* sv
 pd	|void	|sv_free_arenas
diff --git a/gv.c b/gv.c
index 66003affa1..a2b30a2922 100644
--- a/gv.c
+++ b/gv.c
@@ -958,7 +958,7 @@ Perl_gv_fetchpvn_flags(pTHX_ const char *nambeg, STRLEN full_len, I32 flags,
 		    hv = GvHVn(gv);
 		    hv_magic(hv, Nullgv, PERL_MAGIC_sig);
 		    for (i = 1; i < SIG_SIZE; i++) {
-			SV ** const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
+			SV * const * const init = hv_fetch(hv, PL_sig_name[i], strlen(PL_sig_name[i]), 1);
 			if (init)
 			    sv_setsv(*init, &PL_sv_undef);
 			PL_psig_ptr[i] = 0;
@@ -1263,14 +1263,14 @@ Perl_gv_check(pTHX_ HV *stash)
 		file = GvFILE(gv);
 		/* performance hack: if filename is absolute and it's a standard
 		 * module, don't bother warning */
-		if (file
-		    && PERL_FILE_IS_ABSOLUTE(file)
 #ifdef MACOS_TRADITIONAL
-		    && (instr(file, ":lib:")
+#   define LIB_COMPONENT ":lib:"
 #else
-		    && (instr(file, "/lib/")
+#   define LIB_COMPONENT "/lib/"
 #endif
-		    || instr(file, ".pm")))
+		if (file
+		    && PERL_FILE_IS_ABSOLUTE(file)
+		    && (instr(file, LIB_COMPONENT) || instr(file, ".pm")))
 		{
 		    continue;
 		}
diff --git a/op.c b/op.c
index 6500d49ef4..6b29e3cf0d 100644
--- a/op.c
+++ b/op.c
@@ -128,7 +128,7 @@ Perl_Slab_Alloc(pTHX_ int m, size_t sz)
 void
 Perl_Slab_Free(pTHX_ void *op)
 {
-    I32 ** const ptr = (I32 **) op;
+    I32 * const * const ptr = (I32 **) op;
     I32 * const slab = ptr[-1];
     assert( ptr-1 > (I32 **) slab );
     assert( ptr < ( (I32 **) slab + PERL_SLAB_SIZE) );
@@ -404,9 +404,9 @@ Perl_op_clear(pTHX_ OP *o)
     case OP_QR:
 clear_pmop:
 	{
-	    HV *pmstash = PmopSTASH(cPMOPo);
+	    HV * const pmstash = PmopSTASH(cPMOPo);
 	    if (pmstash && SvREFCNT(pmstash)) {
-		MAGIC *mg = mg_find((SV*)pmstash, PERL_MAGIC_symtab);
+		MAGIC * const mg = mg_find((SV*)pmstash, PERL_MAGIC_symtab);
 		if (mg) {
 		    PMOP *pmop = (PMOP*) mg->mg_obj;
 		    PMOP *lastpmop = NULL;
@@ -560,7 +560,7 @@ Perl_scalar(pTHX_ OP *o)
     OP *kid;
 
     /* assumes no premature commitment */
-    if (!o || (o->op_flags & OPf_WANT) || PL_error_count
+    if (!o || PL_error_count || (o->op_flags & OPf_WANT)
 	 || o->op_type == OP_RETURN)
     {
 	return o;
@@ -1540,7 +1540,7 @@ 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 **svp = hv_fetch(GvHVn(PL_incgv), ATTRSMODULE_PM,
+	SV * const * const svp = hv_fetch(GvHVn(PL_incgv), ATTRSMODULE_PM,
 		       sizeof(ATTRSMODULE_PM)-1, 0);
 	if (svp && *svp != &PL_sv_undef)
 	    ; 		/* already in %INC */
@@ -1676,7 +1676,7 @@ S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 	    yyerror(Perl_form(aTHX_ "Can't declare %s in %s",
 			OP_DESC(o), PL_in_my == KEY_our ? "our" : "my"));
 	} else if (attrs) {
-	    GV *gv = cGVOPx_gv(cUNOPo->op_first);
+	    GV * const gv = cGVOPx_gv(cUNOPo->op_first);
 	    PL_in_my = FALSE;
 	    PL_in_my_stash = Nullhv;
 	    apply_attrs(GvSTASH(gv),
@@ -1773,10 +1773,10 @@ Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
        left->op_type == OP_PADHV)
        && ckWARN(WARN_MISC))
     {
-      const char *desc = PL_op_desc[(right->op_type == OP_SUBST ||
+      const char * const desc = PL_op_desc[(right->op_type == OP_SUBST ||
                             right->op_type == OP_TRANS)
                            ? right->op_type : OP_MATCH];
-      const char *sample = ((left->op_type == OP_RV2AV ||
+      const char * const sample = ((left->op_type == OP_RV2AV ||
 			     left->op_type == OP_PADAV)
 			    ? "@array" : "%hash");
       Perl_warner(aTHX_ packWARN(WARN_MISC),
@@ -1881,7 +1881,7 @@ OP*
 Perl_block_end(pTHX_ I32 floor, OP *seq)
 {
     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
-    OP* retval = scalarseq(seq);
+    OP* const retval = scalarseq(seq);
     LEAVE_SCOPE(floor);
     PL_compiling.op_private = (U8)(PL_hints & HINT_PRIVATE_MASK);
     if (needblockscope)
@@ -1898,7 +1898,7 @@ S_newDEFSVOP(pTHX)
 	return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
     }
     else {
-	OP *o = newOP(OP_PADSV, 0);
+	OP * const o = newOP(OP_PADSV, 0);
 	o->op_targ = offset;
 	return o;
     }
@@ -1937,7 +1937,7 @@ Perl_newPROG(pTHX_ OP *o)
 
 	/* Register with debugger */
 	if (PERLDB_INTER) {
-	    CV *cv = get_cv("DB::postponed", FALSE);
+	    CV * const cv = get_cv("DB::postponed", FALSE);
 	    if (cv) {
 		dSP;
 		PUSHMARK(SP);
@@ -2269,8 +2269,7 @@ Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
     listop->op_first = first;
     listop->op_last = last;
     if (type == OP_LIST) {
-	OP* pushop;
-	pushop = newOP(OP_PUSHMARK, 0);
+	OP* const pushop = newOP(OP_PUSHMARK, 0);
 	pushop->op_sibling = first;
 	listop->op_first = pushop;
 	listop->op_flags |= OPf_KIDS;
@@ -2381,16 +2380,13 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
     const U8 *r = (U8*)SvPV_const(rstr, rlen);
     register I32 i;
     register I32 j;
-    I32 del;
-    I32 complement;
-    I32 squash;
     I32 grows = 0;
     register short *tbl;
 
+    const I32 complement = o->op_private & OPpTRANS_COMPLEMENT;
+    const I32 squash     = o->op_private & OPpTRANS_SQUASH;
+    I32 del              = o->op_private & OPpTRANS_DELETE;
     PL_hints |= HINT_BLOCK_SCOPE;
-    complement	= o->op_private & OPpTRANS_COMPLEMENT;
-    del		= o->op_private & OPpTRANS_DELETE;
-    squash	= o->op_private & OPpTRANS_SQUASH;
 
     if (SvUTF8(tstr))
         o->op_private |= OPpTRANS_FROM_UTF;
@@ -2399,7 +2395,7 @@ 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* listsv = newSVpvn("# comment\n",10);
+	SV* const listsv = newSVpvn("# comment\n",10);
 	SV* transv = 0;
 	const U8* tend = t + tlen;
 	const U8* rend = r + rlen;
@@ -2416,8 +2412,8 @@ Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
 	I32 bits;
 	I32 havefinal = 0;
 	U32 final = 0;
-	I32 from_utf	= o->op_private & OPpTRANS_FROM_UTF;
-	I32 to_utf	= o->op_private & OPpTRANS_TO_UTF;
+	const I32 from_utf  = o->op_private & OPpTRANS_FROM_UTF;
+	const I32 to_utf    = o->op_private & OPpTRANS_TO_UTF;
 	U8* tsave = NULL;
 	U8* rsave = NULL;
 
@@ -2696,19 +2692,16 @@ Perl_newPMOP(pTHX_ I32 type, I32 flags)
     pmop->op_pmflags = pmop->op_pmpermflags;
 
 #ifdef USE_ITHREADS
-    {
-        SV* repointer;
-        if(av_len((AV*) PL_regex_pad[0]) > -1) {
-	    repointer = av_pop((AV*)PL_regex_pad[0]);
-            pmop->op_pmoffset = SvIV(repointer);
-	    SvREPADTMP_off(repointer);
-	    sv_setiv(repointer,0);
-        } else {
-            repointer = newSViv(0);
-            av_push(PL_regex_padav,SvREFCNT_inc(repointer));
-            pmop->op_pmoffset = av_len(PL_regex_padav);
-            PL_regex_pad = AvARRAY(PL_regex_padav);
-        }
+    if (av_len((AV*) PL_regex_pad[0]) > -1) {
+	SV * const repointer = av_pop((AV*)PL_regex_pad[0]);
+	pmop->op_pmoffset = SvIV(repointer);
+	SvREPADTMP_off(repointer);
+	sv_setiv(repointer,0);
+    } else {
+	SV * const repointer = newSViv(0);
+	av_push(PL_regex_padav,SvREFCNT_inc(repointer));
+	pmop->op_pmoffset = av_len(PL_regex_padav);
+	PL_regex_pad = AvARRAY(PL_regex_padav);
     }
 #endif
 
@@ -3028,7 +3021,7 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg)
     veop = Nullop;
 
     if (version) {
-	SV *vesv = ((SVOP*)version)->op_sv;
+	SV * const vesv = ((SVOP*)version)->op_sv;
 
 	if (!arg && !SvNIOKp(vesv)) {
 	    arg = version;
@@ -3149,9 +3142,9 @@ Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
 void
 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
 {
-    OP *modname, *veop, *imop;
+    OP *veop, *imop;
 
-    modname = newSVOP(OP_CONST, 0, name);
+    OP * const modname = newSVOP(OP_CONST, 0, name);
     modname->op_private |= OPpCONST_BARE;
     if (ver) {
 	veop = newSVOP(OP_CONST, 0, ver);
@@ -3195,8 +3188,8 @@ Perl_dofile(pTHX_ OP *term, I32 force_builtin)
     if (!force_builtin) {
 	gv = gv_fetchpv("do", FALSE, SVt_PVCV);
 	if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
-	    GV **gvp = (GV**)hv_fetch(PL_globalstash, "do", 2, FALSE);
-	    if (gvp) gv = *gvp; else gv = Nullgv;
+	    GV * const * const gvp = (GV**)hv_fetch(PL_globalstash, "do", 2, FALSE);
+	    gv = gvp ? *gvp : Nullgv;
 	}
     }
 
@@ -3375,7 +3368,7 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
 	    if ((tmpop = ((LISTOP*)right)->op_first) &&
 		tmpop->op_type == OP_PUSHRE)
 	    {
-		PMOP *pm = (PMOP*)tmpop;
+		PMOP * const pm = (PMOP*)tmpop;
 		if (left->op_type == OP_RV2AV &&
 		    !(left->op_private & OPpLVAL_INTRO) &&
 		    !(o->op_private & OPpASSIGN_COMMON) )
@@ -3486,7 +3479,7 @@ Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o)
     CopSTASH_set(cop, PL_curstash);
 
     if (PERLDB_LINE && PL_curstash != PL_debstash) {
-	SV ** const svp = av_fetch(CopFILEAV(PL_curcop), (I32)CopLINE(cop), FALSE);
+	SV * const * const svp = av_fetch(CopFILEAV(PL_curcop), (I32)CopLINE(cop), FALSE);
 	if (svp && *svp != &PL_sv_undef ) {
 	    (void)SvIOK_on(*svp);
 	    SvIV_set(*svp, PTR2IV(cop));
@@ -3853,7 +3846,7 @@ whileline, OP *expr, OP *block, OP *cont, I32 has_my)
 	next = LINKLIST(cont);
     }
     if (expr) {
-	OP *unstack = newOP(OP_UNSTACK, 0);
+	OP * const unstack = newOP(OP_UNSTACK, 0);
 	if (!next)
 	    next = unstack;
 	cont = append_elem(OP_LINESEQ, cont, unstack);
@@ -3956,8 +3949,8 @@ Perl_newFOROP(pTHX_ I32 flags, char *label, line_t forline, OP *sv, OP *expr, OP
 	 * set the STACKED flag to indicate that these values are to be
 	 * treated as min/max values by 'pp_iterinit'.
 	 */
-	UNOP* flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
-	LOGOP* range = (LOGOP*) flip->op_first;
+	UNOP* const flip = (UNOP*)((UNOP*)((BINOP*)expr)->op_first)->op_first;
+	LOGOP* const range = (LOGOP*) flip->op_first;
 	OP* const left  = range->op_first;
 	OP* const right = left->op_sibling;
 	LISTOP* listop;
@@ -4503,7 +4496,6 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 	    SV *sv = NEWSV(0,0);
 	    SV *tmpstr = sv_newmortal();
 	    GV *db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
-	    CV *pcv;
 	    HV *hv;
 
 	    Perl_sv_setpvf(aTHX_ sv, "%s:%ld-%ld",
@@ -4512,14 +4504,15 @@ Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
 	    gv_efullname3(tmpstr, gv, Nullch);
 	    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))
-		&& (pcv = GvCV(db_postponed)))
-	    {
-		dSP;
-		PUSHMARK(SP);
-		XPUSHs(tmpstr);
-		PUTBACK;
-		call_sv((SV*)pcv, G_DISCARD);
+	    if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX_const(tmpstr), SvCUR(tmpstr))) {
+		CV * const pcv = GvCV(db_postponed);
+		if (pcv) {
+		    dSP;
+		    PUSHMARK(SP);
+		    XPUSHs(tmpstr);
+		    PUTBACK;
+		    call_sv((SV*)pcv, G_DISCARD);
+		}
 	    }
 	}
 
@@ -5028,7 +5021,7 @@ Perl_ck_delete(pTHX_ OP *o)
     o = ck_fun(o);
     o->op_private = 0;
     if (o->op_flags & OPf_KIDS) {
-	OP *kid = cUNOPo->op_first;
+	OP * const kid = cUNOPo->op_first;
 	switch (kid->op_type) {
 	case OP_ASLICE:
 	    o->op_flags |= OPf_SPECIAL;
@@ -5123,9 +5116,9 @@ OP *
 Perl_ck_exit(pTHX_ OP *o)
 {
 #ifdef VMS
-    HV *table = GvHV(PL_hintgv);
+    HV * const table = GvHV(PL_hintgv);
     if (table) {
-       SV **svp = hv_fetch(table, "vmsish_exit", 11, FALSE);
+       SV * const * const svp = hv_fetch(table, "vmsish_exit", 11, FALSE);
        if (svp && *svp && SvTRUE(*svp))
            o->op_private |= OPpEXIT_VMSISH;
     }
@@ -5281,10 +5274,10 @@ Perl_ck_ftst(pTHX_ OP *o)
 	/* nothing */
     }
     else if (o->op_flags & OPf_KIDS && cUNOPo->op_first->op_type != OP_STUB) {
-	SVOP *kid = (SVOP*)cUNOPo->op_first;
+	SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
 	if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
-	    OP *newop = newGVOP(type, OPf_REF,
+	    OP * const newop = newGVOP(type, OPf_REF,
 		gv_fetchsv(kid->op_sv, TRUE, SVt_PVIO));
 	    op_free(o);
 	    o = newop;
@@ -5368,7 +5361,7 @@ Perl_ck_fun(pTHX_ OP *o)
 		if (kid->op_type == OP_CONST &&
 		    (kid->op_private & OPpCONST_BARE))
 		{
-		    OP *newop = newAVREF(newGVOP(OP_GV, 0,
+		    OP * const newop = newAVREF(newGVOP(OP_GV, 0,
 			gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVAV) ));
 		    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
 			Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
@@ -5387,7 +5380,7 @@ Perl_ck_fun(pTHX_ OP *o)
 		if (kid->op_type == OP_CONST &&
 		    (kid->op_private & OPpCONST_BARE))
 		{
-		    OP *newop = newHVREF(newGVOP(OP_GV, 0,
+		    OP * const newop = newHVREF(newGVOP(OP_GV, 0,
 			gv_fetchsv(((SVOP*)kid)->op_sv, TRUE, SVt_PVHV) ));
 		    if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
 			Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
@@ -5404,7 +5397,7 @@ Perl_ck_fun(pTHX_ OP *o)
 		break;
 	    case OA_CVREF:
 		{
-		    OP *newop = newUNOP(OP_NULL, 0, kid);
+		    OP * const newop = newUNOP(OP_NULL, 0, kid);
 		    kid->op_sibling = 0;
 		    linklist(kid);
 		    newop->op_next = newop;
@@ -5465,12 +5458,11 @@ Perl_ck_fun(pTHX_ OP *o)
 			    else if (kid->op_type == OP_AELEM
 				     || kid->op_type == OP_HELEM)
 			    {
-				 OP *op;
-
+				 OP *op = ((BINOP*)kid)->op_first;
 				 name = 0;
-				 if ((op = ((BINOP*)kid)->op_first)) {
+				 if (op) {
 				      SV *tmpstr = Nullsv;
-				      const char *a =
+				      const char * const a =
 					   kid->op_type == OP_AELEM ?
 					   "[]" : "{}";
 				      if (((op->op_type == OP_RV2AV) ||
@@ -5478,7 +5470,7 @@ Perl_ck_fun(pTHX_ OP *o)
 					  (op = ((UNOP*)op)->op_first) &&
 					  (op->op_type == OP_GV)) {
 					   /* packagevar $a[] or $h{} */
-					   GV *gv = cGVOPx_gv(op);
+					   GV * const gv = cGVOPx_gv(op);
 					   if (gv)
 						tmpstr =
 						     Perl_newSVpvf(aTHX_
@@ -5489,7 +5481,7 @@ Perl_ck_fun(pTHX_ OP *o)
 				      else if (op->op_type == OP_PADAV
 					       || op->op_type == OP_PADHV) {
 					   /* lexicalvar $a[] or $h{} */
-					   const char *padname =
+					   const char * const padname =
 						PAD_COMPNAME_PV(op->op_targ);
 					   if (padname)
 						tmpstr =
@@ -5497,7 +5489,6 @@ Perl_ck_fun(pTHX_ OP *o)
 								   "%s%c...%c",
 								   padname + 1,
 								   a[0], a[1]);
-					   
 				      }
 				      if (tmpstr) {
 					   name = SvPV_const(tmpstr, len);
@@ -5786,7 +5777,7 @@ Perl_ck_sassign(pTHX_ OP *o)
 	/* Cannot steal the second time! */
 	&& !(kid->op_private & OPpTARGET_MY))
     {
-	OP *kkid = kid->op_sibling;
+	OP * const kkid = kid->op_sibling;
 
 	/* Can just relocate the target. */
 	if (kkid && kkid->op_type == OP_PADSV
@@ -5805,7 +5796,7 @@ Perl_ck_sassign(pTHX_ OP *o)
     }
     /* optimise C<my $x = undef> to C<my $x> */
     if (kid->op_type == OP_UNDEF) {
-	OP *kkid = kid->op_sibling;
+	OP * const kkid = kid->op_sibling;
 	if (kkid && kkid->op_type == OP_PADSV
 		&& (kkid->op_private & OPpLVAL_INTRO))
 	{
@@ -5837,7 +5828,7 @@ Perl_ck_match(pTHX_ OP *o)
 OP *
 Perl_ck_method(pTHX_ OP *o)
 {
-    OP *kid = cUNOPo->op_first;
+    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), '\''))) {
@@ -5865,13 +5856,11 @@ Perl_ck_null(pTHX_ OP *o)
 OP *
 Perl_ck_open(pTHX_ OP *o)
 {
-    HV *table = GvHV(PL_hintgv);
+    HV * const table = GvHV(PL_hintgv);
     if (table) {
-	SV **svp;
-	I32 mode;
-	svp = hv_fetch(table, "open_IN", 7, FALSE);
+	SV **svp = hv_fetch(table, "open_IN", 7, FALSE);
 	if (svp && *svp) {
-	    mode = mode_from_discipline(*svp);
+	    const I32 mode = mode_from_discipline(*svp);
 	    if (mode & O_BINARY)
 		o->op_private |= OPpOPEN_IN_RAW;
 	    else if (mode & O_TEXT)
@@ -5880,7 +5869,7 @@ Perl_ck_open(pTHX_ OP *o)
 
 	svp = hv_fetch(table, "open_OUT", 8, FALSE);
 	if (svp && *svp) {
-	    mode = mode_from_discipline(*svp);
+	    const I32 mode = mode_from_discipline(*svp);
 	    if (mode & O_BINARY)
 		o->op_private |= OPpOPEN_OUT_RAW;
 	    else if (mode & O_TEXT)
@@ -5892,8 +5881,8 @@ Perl_ck_open(pTHX_ OP *o)
     {
 	 /* In case of three-arg dup open remove strictness
 	  * from the last arg if it is a bareword. */
-	 OP *first = cLISTOPx(o)->op_first; /* The pushmark. */
-	 OP *last  = cLISTOPx(o)->op_last;  /* The bareword. */
+	 OP * const first = cLISTOPx(o)->op_first; /* The pushmark. */
+	 OP * const last  = cLISTOPx(o)->op_last;  /* The bareword. */
 	 OP *oa;
 	 const char *mode;
 
@@ -5930,10 +5919,10 @@ Perl_ck_require(pTHX_ OP *o)
     GV* gv = Nullgv;
 
     if (o->op_flags & OPf_KIDS) {	/* Shall we supply missing .pm? */
-	SVOP *kid = (SVOP*)cUNOPo->op_first;
+	SVOP * const kid = (SVOP*)cUNOPo->op_first;
 
 	if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
-	    SV *sv = kid->op_sv;
+	    SV * const sv = kid->op_sv;
 	    U32 was_readonly = SvREADONLY(sv);
 	    char *s;
 
@@ -5963,13 +5952,13 @@ Perl_ck_require(pTHX_ OP *o)
 	/* handle override, if any */
 	gv = gv_fetchpv("require", FALSE, SVt_PVCV);
 	if (!(gv && GvCVu(gv) && GvIMPORTED_CV(gv))) {
-	    GV **gvp = (GV**)hv_fetch(PL_globalstash, "require", 7, FALSE);
-	    if (gvp) gv = *gvp; else gv = Nullgv;
+	    GV * const * const gvp = (GV**)hv_fetch(PL_globalstash, "require", 7, FALSE);
+	    gv = gvp ? *gvp : Nullgv;
 	}
     }
 
     if (gv && GvCVu(gv) && GvIMPORTED_CV(gv)) {
-	OP *kid = cUNOPo->op_first;
+	OP * const kid = cUNOPo->op_first;
 	cUNOPo->op_first = 0;
 	op_free(o);
 	return ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
@@ -6193,7 +6182,7 @@ Perl_ck_split(pTHX_ OP *o)
     }
 
     if (kid->op_type != OP_MATCH || kid->op_flags & OPf_STACKED) {
-	OP *sibl = kid->op_sibling;
+	OP * const sibl = kid->op_sibling;
 	kid->op_sibling = 0;
 	kid = pmruntime( newPMOP(OP_MATCH, OPf_SPECIAL), kid, 0);
 	if (cLISTOPo->op_first == cLISTOPo->op_last)
@@ -6231,7 +6220,7 @@ Perl_ck_split(pTHX_ OP *o)
 OP *
 Perl_ck_join(pTHX_ OP *o)
 {
-    const OP *kid = cLISTOPo->op_first->op_sibling;
+    const OP * const kid = cLISTOPo->op_first->op_sibling;
     if (kid && kid->op_type == OP_MATCH) {
 	if (ckWARN(WARN_SYNTAX)) {
             const REGEXP *re = PM_GETRE(kPMOP);
@@ -6297,7 +6286,7 @@ 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 *o = ((UNOP*)o2)->op_first->op_sibling;
+	    OP * const o = ((UNOP*)o2)->op_first->op_sibling;
 	    if (o && o->op_type == OP_CONST)
 		o->op_private &= ~OPpCONST_STRICT;
 	}
@@ -6353,9 +6342,9 @@ Perl_ck_subr(pTHX_ OP *o)
 				(gvop = ((UNOP*)gvop)->op_first) &&
 				gvop->op_type == OP_GV)
 			    {
-				GV *gv = cGVOPx_gv(gvop);
-				OP *sibling = o2->op_sibling;
-				SV *n = newSVpvn("",0);
+				GV * const gv = cGVOPx_gv(gvop);
+				OP * const sibling = o2->op_sibling;
+				SV * const n = newSVpvn("",0);
 				op_free(o2);
 				gv_fullname4(n, gv, "", FALSE);
 				o2 = newSVOP(OP_CONST, 0, n);
@@ -6436,8 +6425,8 @@ Perl_ck_subr(pTHX_ OP *o)
 		    break;
 		wrapref:
 		    {
-			OP* kid = o2;
-			OP* sib = kid->op_sibling;
+			OP* const kid = o2;
+			OP* const sib = kid->op_sibling;
 			kid->op_sibling = 0;
 			o2 = newUNOP(OP_REFGEN, 0, kid);
 			o2->op_sibling = sib;
@@ -6467,7 +6456,7 @@ Perl_ck_subr(pTHX_ OP *o)
 	mod(o2, OP_ENTERSUB);
 	prev = o2;
 	o2 = o2->op_sibling;
-    }
+    } /* while */
     if (proto && !optional &&
 	  (*proto && *proto != '@' && *proto != '%' && *proto != ';'))
 	return too_few_arguments(o, gv_ename(namegv));
@@ -6689,10 +6678,10 @@ Perl_peep(pTHX_ register OP *o)
 		}
 	    }
 	    else if ((o->op_private & OPpEARLY_CV) && ckWARN(WARN_PROTOTYPE)) {
-		GV *gv = cGVOPo_gv;
+		GV * const gv = cGVOPo_gv;
 		if (SvTYPE(gv) == SVt_PVGV && GvCV(gv) && SvPVX_const(GvCV(gv))) {
 		    /* XXX could check prototype here instead of just carping */
-		    SV *sv = sv_newmortal();
+		    SV * const sv = sv_newmortal();
 		    gv_efullname3(sv, gv, Nullch);
 		    Perl_warner(aTHX_ packWARN(WARN_PROTOTYPE),
 				"%"SVf"() called too early to check prototype",
@@ -6882,22 +6871,22 @@ Perl_peep(pTHX_ register OP *o)
 
 	case OP_SORT: {
 	    /* will point to RV2AV or PADAV op on LHS/RHS of assign */
-	    OP *oleft, *oright;
+	    OP *oleft;
 	    OP *o2;
 
 	    /* check that RHS of sort is a single plain array */
-	    oright = cUNOPo->op_first;
+	    OP *oright = cUNOPo->op_first;
 	    if (!oright || oright->op_type != OP_PUSHMARK)
 		break;
 
 	    /* reverse sort ... can be optimised.  */
 	    if (!cUNOPo->op_sibling) {
 		/* Nothing follows us on the list. */
-		OP *reverse = o->op_next;
+		OP * const reverse = o->op_next;
 
 		if (reverse->op_type == OP_REVERSE &&
 		    (reverse->op_flags & OPf_WANT) == OPf_WANT_LIST) {
-		    OP *pushmark = cUNOPx(reverse)->op_first;
+		    OP * const pushmark = cUNOPx(reverse)->op_first;
 		    if (pushmark && (pushmark->op_type == OP_PUSHMARK)
 			&& (cUNOPx(pushmark)->op_sibling == o)) {
 			/* reverse -> pushmark -> sort */
diff --git a/pad.c b/pad.c
index 336d816083..4d87758ea8 100644
--- a/pad.c
+++ b/pad.c
@@ -412,7 +412,7 @@ Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
 	retval = AvFILLp(PL_comppad);
     }
     else {
-	SV ** const names = AvARRAY(PL_comppad_name);
+	SV * const * const names = AvARRAY(PL_comppad_name);
         const SSize_t names_fill = AvFILLp(PL_comppad_name);
 	for (;;) {
 	    /*
@@ -584,7 +584,7 @@ Perl_pad_findmy(pTHX_ const char *name)
     nameav = (AV*)AvARRAY(CvPADLIST(PL_compcv))[0];
     name_svp = AvARRAY(nameav);
     for (offset = AvFILLp(nameav); offset > 0; offset--) {
-        const SV *namesv = name_svp[offset];
+        const SV * const namesv = name_svp[offset];
 	if (namesv && namesv != &PL_sv_undef
 	    && !SvFAKE(namesv)
 	    && (SvFLAGS(namesv) & SVpad_OUR)
@@ -665,11 +665,11 @@ S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn,
 
     if (padlist) { /* not an undef CV */
 	I32 fake_offset = 0;
-        const AV *nameav = (AV*)AvARRAY(padlist)[0];
-	SV **name_svp = AvARRAY(nameav);
+        const AV * const nameav = (AV*)AvARRAY(padlist)[0];
+	SV * const * const name_svp = AvARRAY(nameav);
 
 	for (offset = AvFILLp(nameav); offset > 0; offset--) {
-            const SV *namesv = name_svp[offset];
+            const SV * const namesv = name_svp[offset];
 	    if (namesv && namesv != &PL_sv_undef
 		    && strEQ(SvPVX_const(namesv), name))
 	    {
@@ -994,7 +994,7 @@ void
 Perl_pad_leavemy(pTHX)
 {
     I32 off;
-    SV ** const svp = AvARRAY(PL_comppad_name);
+    SV * const * const svp = AvARRAY(PL_comppad_name);
 
     PL_pad_reset_pending = FALSE;
 
@@ -1160,7 +1160,7 @@ Perl_pad_tidy(pTHX_ padtidy_type type)
 	av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv);
 
     if (type == padtidy_SUBCLONE) {
-	SV ** const namep = AvARRAY(PL_comppad_name);
+	SV * const * const namep = AvARRAY(PL_comppad_name);
 	PADOFFSET ix;
 
 	for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
@@ -1503,7 +1503,7 @@ Perl_cv_clone(pTHX_ CV *proto)
 	 * so try to grab the current const value, and if successful,
 	 * turn into a const sub:
 	 */
-	SV* const_sv = op_const_sv(CvSTART(cv), cv);
+	SV* const const_sv = op_const_sv(CvSTART(cv), cv);
 	if (const_sv) {
 	    SvREFCNT_dec(cv);
 	    cv = newCONSTSUB(CvSTASH(proto), Nullch, const_sv);
@@ -1536,7 +1536,7 @@ Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv)
     SV ** const namepad = AvARRAY(comppad_name);
     SV ** const curpad = AvARRAY(comppad);
     for (ix = AvFILLp(comppad_name); ix > 0; ix--) {
-        const SV *namesv = namepad[ix];
+        const SV * const namesv = namepad[ix];
 	if (namesv && namesv != &PL_sv_undef
 	    && *SvPVX_const(namesv) == '&')
 	{
@@ -1598,7 +1598,7 @@ Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
 	    }
 	    else {
 		/* save temporaries on recursion? */
-		SV *sv = NEWSV(0, 0);
+		SV * const sv = NEWSV(0, 0);
 		av_store(newpad, ix, sv);
 		SvPADTMP_on(sv);
 	    }
@@ -1617,7 +1617,7 @@ Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
 HV *
 Perl_pad_compname_type(pTHX_ const PADOFFSET po)
 {
-    SV** const av = av_fetch(PL_comppad_name, po, FALSE);
+    SV* const * const av = av_fetch(PL_comppad_name, po, FALSE);
     if ( SvFLAGS(*av) & SVpad_TYPED ) {
         return SvSTASH(*av);
     }
diff --git a/perl.c b/perl.c
index 42f32fed29..8f9951c502 100644
--- a/perl.c
+++ b/perl.c
@@ -3096,7 +3096,7 @@ Perl_moreswitches(pTHX_ char *s)
 		s+=strlen(s);
 	    }
 	    else if (*s != '\0') {
-		Perl_croak(aTHX_ "Can't use '%c' after -A%.*s", *s, s-start, start);
+		Perl_croak(aTHX_ "Can't use '%c' after -A%.*s", *s, (int)(s-start), start);
 	    }
 	    av_push(PL_preambleav, sv);
 	    return s;
diff --git a/pp_sort.c b/pp_sort.c
index 2bd2c806a3..3dda7cc67e 100644
--- a/pp_sort.c
+++ b/pp_sort.c
@@ -355,11 +355,11 @@ cmp_desc(pTHX_ gptr a, gptr b)
 STATIC void
 S_mergesortsv(pTHX_ gptr *base, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
 {
-    IV i, run, runs, offset;
+    IV i, run, offset;
     I32 sense, level;
+    register gptr *f1, *f2, *t, *b, *p;
     int iwhich;
-    register gptr *f1, *f2, *t, *b, *p, *tp2, *l1, *l2, *q;
-    gptr *aux, *list1, *list2;
+    gptr *aux;
     gptr *p1;
     gptr small[SMALLSORT];
     gptr *which[3];
@@ -388,11 +388,14 @@ S_mergesortsv(pTHX_ gptr *base, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
 	 * is needed at the next level up.  Hop up a level, and,
 	 * as long as stackp->runs is 0, keep merging.
 	 */
-	if ((runs = stackp->runs) == 0) {
+	IV runs = stackp->runs;
+	if (runs == 0) {
+	    gptr *list1, *list2;
 	    iwhich = level & 1;
 	    list1 = which[iwhich];		/* area where runs are now */
 	    list2 = which[++iwhich];		/* area for merged runs */
 	    do {
+		register gptr *l1, *l2, *tp2;
 		offset = stackp->offset;
 		f1 = p1 = list1 + offset;		/* start of first run */
 		p = tp2 = list2 + offset;	/* where merged run will go */
@@ -422,7 +425,7 @@ S_mergesortsv(pTHX_ gptr *base, size_t nmemb, SVCOMPARE_t cmp, U32 flags)
 		    ** and -1 when equality should look high.
 		    */
 
-
+		    register gptr *q;
 		    if (cmp(aTHX_ *f1, *f2) <= 0) {
 			q = f2; b = f1; t = l1;
 			sense = -1;
@@ -1713,7 +1716,7 @@ PP(pp_sort)
 	av_extend(av, max);
 	for (i=0; i < max; i++) {
 	    SV * const sv = base[i];
-	    SV **didstore = av_store(av, i, sv);
+	    SV ** const didstore = av_store(av, i, sv);
 	    if (SvSMAGICAL(sv))
 		mg_set(sv);
 	    if (!didstore)
diff --git a/proto.h b/proto.h
index 703631c8aa..2dc1eaf4cf 100644
--- a/proto.h
+++ b/proto.h
@@ -211,8 +211,7 @@ PERL_CALLCONV OP*	Perl_convert(pTHX_ I32 optype, I32 flags, OP* o)
 
 PERL_CALLCONV void	Perl_croak(pTHX_ const char* pat, ...)
 			__attribute__noreturn__
-			__attribute__format__(__printf__,pTHX_1,pTHX_2)
-			__attribute__nonnull__(pTHX_1);
+			__attribute__format__(__printf__,pTHX_1,pTHX_2);
 
 PERL_CALLCONV void	Perl_vcroak(pTHX_ const char* pat, va_list* args)
 			__attribute__noreturn__
@@ -2126,10 +2125,7 @@ PERL_CALLCONV bool	Perl_sv_derived_from(pTHX_ SV* sv, const char* name)
 			__attribute__nonnull__(pTHX_1)
 			__attribute__nonnull__(pTHX_2);
 
-PERL_CALLCONV I32	Perl_sv_eq(pTHX_ SV* sv1, SV* sv2)
-			__attribute__nonnull__(pTHX_1)
-			__attribute__nonnull__(pTHX_2);
-
+PERL_CALLCONV I32	Perl_sv_eq(pTHX_ SV* sv1, SV* sv2);
 PERL_CALLCONV void	Perl_sv_free(pTHX_ SV* sv);
 PERL_CALLCONV void	Perl_sv_free2(pTHX_ SV* sv)
 			__attribute__nonnull__(pTHX_1);
diff --git a/regcomp.c b/regcomp.c
index 9f81cf5921..744b380f27 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -425,7 +425,7 @@ static const scan_data_t zero_scan_data =
 	MJD_OFFSET_DEBUG(("** (%d) offset of node %d is %d.\n",		\
 		__LINE__, (node), (byte)));				\
 	if((node) < 0) {						\
-	    Perl_croak(aTHX_ "value of node is %d in Offset macro", node); \
+	    Perl_croak(aTHX_ "value of node is %d in Offset macro", (int)(node)); \
 	} else {							\
 	    RExC_offsets[2*(node)-1] = (byte);				\
 	}								\
@@ -439,9 +439,9 @@ static const scan_data_t zero_scan_data =
 #define Set_Node_Length_To_R(node,len) STMT_START {			\
     if (! SIZE_ONLY) {							\
 	MJD_OFFSET_DEBUG(("** (%d) size of node %d is %d.\n",		\
-		__LINE__, (node), (len)));				\
+		__LINE__, (int)(node), (int)(len)));			\
 	if((node) < 0) {						\
-	    Perl_croak(aTHX_ "value of node is %d in Length macro", node); \
+	    Perl_croak(aTHX_ "value of node is %d in Length macro", (int)(node)); \
 	} else {							\
 	    RExC_offsets[2*(node)] = (len);				\
 	}								\
diff --git a/sv.c b/sv.c
index 1b2a0c4ead..2f27a523a1 100644
--- a/sv.c
+++ b/sv.c
@@ -1860,7 +1860,7 @@ S_not_a_number(pTHX_ SV *sv)
           pv = sv_uni_display(dsv, sv, 10, 0);
      } else {
 	  char *d = tmpbuf;
-	  char *limit = tmpbuf + sizeof(tmpbuf) - 8;
+	  const char * const limit = tmpbuf + sizeof(tmpbuf) - 8;
 	  /* each *s can expand to 4 chars + "...\0",
 	     i.e. need room for 8 chars */
 	
@@ -2121,11 +2121,13 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
     }
     if (SvTHINKFIRST(sv)) {
 	if (SvROK(sv)) {
-	  SV* tmpstr;
-          if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
-                (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
-	      return SvIV(tmpstr);
-	  return PTR2IV(SvRV(sv));
+	    if (SvAMAGIC(sv)) {
+		SV * const tmpstr=AMG_CALLun(sv,numer);
+		if (tmpstr && (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
+		    return SvIV(tmpstr);
+		}
+	    }
+	    return PTR2IV(SvRV(sv));
 	}
 	if (SvIsCOW(sv)) {
 	    sv_force_normal_flags(sv, 0);
@@ -10350,8 +10352,7 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
         if(SvTYPE(sstr) == SVt_PVHV &&
 	   (hvname = HvNAME_get(sstr))) {
 	    /** don't clone stashes if they already exist **/
-	    HV* old_stash = gv_stashpv(hvname,0);
-	    return (SV*) old_stash;
+	    return (SV*)gv_stashpv(hvname,0);
         }
     }
 
diff --git a/t/TEST b/t/TEST
index ea0f0932f2..e4aa49b6c3 100755
--- a/t/TEST
+++ b/t/TEST
@@ -17,6 +17,7 @@ $ENV{PERL_CORE} = 1;
 
 # remove empty elements due to insertion of empty symbols via "''p1'" syntax
 @ARGV = grep($_,@ARGV) if $^O eq 'VMS';
+our $show_elapsed_time = $ENV{HARNESS_TIMER} || 0;
 
 # Cheesy version of Getopt::Std.  Maybe we should replace it with that.
 {
@@ -68,6 +69,7 @@ $ENV{EMXSHELL} = 'sh';        # For OS/2
 # Roll your own File::Find!
 use TestInit;
 use File::Spec;
+use Time::HiRes;
 my $curdir = File::Spec->curdir;
 my $updir  = File::Spec->updir;
 
@@ -260,8 +262,8 @@ EOT
     my $tested_files  = 0;
     my $totmax = 0;
 
-    my $test;
-    while ($test = shift @tests) {
+    while (my $test = shift @tests) {
+        my $test_start_time = Time::HiRes::time();
 
 	if ( $::infinite{$test} && $type eq 'compile' ) {
 	    print STDERR "$test creates infinite loop! Skipping.\n";
@@ -291,7 +293,7 @@ EOT
 	# XXX DAPM %OVER not defined anywhere
 	# $test = $OVER{$test} if exists $OVER{$test};
 
-	open(SCRIPT,"<$test") or die "Can't run $test.\n";
+	open(SCRIPT,"<",$test) or die "Can't run $test.\n";
 	$_ = <SCRIPT>;
 	close(SCRIPT) unless ($type eq 'deparse');
 	if ($::with_utf16) {
@@ -560,7 +562,14 @@ EOT
 	}
 	else {
 	    if ($max) {
-		print "${te}ok\n";
+		my $elapsed;
+		if ( $show_elapsed_time ) {
+		    $elapsed = sprintf( " %8.0f ms", (Time::HiRes::time() - $test_start_time) * 1000 );
+		}
+		else {
+		    $elapsed = "";
+		}
+		print "${te}ok$elapsed\n";
 		$good_files++;
 	    }
 	    else {
@@ -568,7 +577,7 @@ EOT
 		$tested_files -= 1;
 	    }
 	}
-    }
+    } # while tests
 
     if ($::bad_files == 0) {
 	if ($good_files) {
diff --git a/toke.c b/toke.c
index 717bfdcfc9..cf81ce855b 100644
--- a/toke.c
+++ b/toke.c
@@ -408,12 +408,12 @@ S_no_op(pTHX_ const char *what, char *s)
 	    if (t < PL_bufptr && isSPACE(*t))
 		Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
 			"\t(Do you need to predeclare %.*s?)\n",
-		    t - PL_oldoldbufptr, PL_oldoldbufptr);
+		    (int)(t - PL_oldoldbufptr), PL_oldoldbufptr);
 	}
 	else {
 	    assert(s >= oldbp);
 	    Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
-		    "\t(Missing operator before %.*s?)\n", s - oldbp, oldbp);
+		    "\t(Missing operator before %.*s?)\n", (int)(s - oldbp), oldbp);
 	}
     }
     PL_bufptr = oldbp;
@@ -2852,7 +2852,7 @@ Perl_yylex(pTHX)
 		     * at least, set argv[0] to the basename of the Perl
 		     * interpreter. So, having found "#!", we'll set it right.
 		     */
-		    SV *x = GvSV(gv_fetchpv("\030", TRUE, SVt_PV)); /* $^X */
+		    SV * const x = GvSV(gv_fetchpv("\030", TRUE, SVt_PV)); /* $^X */
 		    assert(SvPOK(x) || SvGMAGICAL(x));
 		    if (sv_eq(x, CopFILESV(PL_curcop))) {
 			sv_setpvn(x, ipath, ipathend - ipath);
@@ -4964,9 +4964,10 @@ Perl_yylex(pTHX)
 		    /* [perl #16184] */
 		    && !(t[0] == '=' && t[1] == '>')
 		) {
+		    int len = (int)(d-s);
 		    Perl_warner(aTHX_ packWARN(WARN_PRECEDENCE),
 			   "Precedence problem: open %.*s should be open(%.*s)",
-			    d - s, s, d - s, s);
+			    len, s, len, s);
 		}
 	    }
 	    LOP(OP_OPEN,XTERM);
diff --git a/utf8.c b/utf8.c
index 8ea2d7a76d..743dea4b5c 100644
--- a/utf8.c
+++ b/utf8.c
@@ -560,10 +560,12 @@ malformed:
 	    if (s == s0)
 	        Perl_sv_catpvf(aTHX_ sv, "(unexpected non-continuation byte 0x%02"UVxf", immediately after start byte 0x%02"UVxf")",
                            (UV)s[1], startbyte);
-	    else
+	    else {
+		const int len = (int)(s-s0);
 	        Perl_sv_catpvf(aTHX_ sv, "(unexpected non-continuation byte 0x%02"UVxf", %d byte%s after start byte 0x%02"UVxf", expected %d bytes)",
-                           (UV)s[1], s - s0, s - s0 > 1 ? "s" : "", startbyte, (int)expectlen);
-	      
+                           (UV)s[1], len, len > 1 ? "s" : "", startbyte, (int)expectlen);
+	    }
+
 	    break;
 	case UTF8_WARN_FE_FF:
 	    Perl_sv_catpvf(aTHX_ sv, "(byte 0x%02"UVxf")", uv);