X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/6176dd9f323ed71666b3090232f3bc20f1d8ec8b..e06c4d37e9c075c9a909e0cdf8fdf9d851bbe1a4:/toke.c

diff --git a/toke.c b/toke.c
index 6783148..e4350c1 100644
--- a/toke.c
+++ b/toke.c
@@ -26,9 +26,12 @@
 #define yychar	(*PL_yycharp)
 #define yylval	(*PL_yylvalp)
 
-static char ident_too_long[] = "Identifier too long";
-static char c_without_g[] = "Use of /c modifier is meaningless without /g";
-static char c_in_subst[] = "Use of /c modifier is meaningless in s///";
+static const char ident_too_long[] =
+  "Identifier too long";
+static const char c_without_g[] =
+  "Use of /c modifier is meaningless without /g";
+static const char c_in_subst[] =
+  "Use of /c modifier is meaningless in s///";
 
 static void restore_rsfp(pTHX_ void *f);
 #ifndef PERL_NO_UTF16_FILTER
@@ -76,7 +79,7 @@ static I32 utf16rev_textfilter(pTHX_ int idx, SV *sv, int maxlen);
 #define LEX_KNOWNEXT		 0
 
 #ifdef DEBUGGING
-static char* lex_state_names[] = {
+static const char* const lex_state_names[] = {
     "KNOWNEXT",
     "FORMLINE",
     "INTERPCONST",
@@ -164,25 +167,29 @@ static char* lex_state_names[] = {
  * The UNIDOR macro is for unary functions that can be followed by the //
  * operator (such as C<shift // 0>).
  */
-#define UNI2(f,x) return ( \
-	yylval.ival = f, \
-	PL_expect = x, \
-	PL_bufptr = s, \
-	PL_last_uni = PL_oldbufptr, \
-	PL_last_lop_op = f, \
-	REPORT( \
-	    (*s == '(' || (s = skipspace(s), *s == '(')  \
-	    ? (int)FUNC1 : (int)UNIOP)))
+#define UNI2(f,x) { \
+	yylval.ival = f; \
+	PL_expect = x; \
+	PL_bufptr = s; \
+	PL_last_uni = PL_oldbufptr; \
+	PL_last_lop_op = f; \
+	if (*s == '(') \
+	    return REPORT( (int)FUNC1 ); \
+	s = skipspace(s); \
+	return REPORT( *s=='(' ? (int)FUNC1 : (int)UNIOP ); \
+	}
 #define UNI(f)    UNI2(f,XTERM)
 #define UNIDOR(f) UNI2(f,XTERMORDORDOR)
 
-#define UNIBRACK(f) return ( \
-	yylval.ival = f, \
-	PL_bufptr = s, \
-	PL_last_uni = PL_oldbufptr, \
-        REPORT( \
-	    (*s == '(' || (s = skipspace(s), *s == '(') \
-	? (int)FUNC1 : (int)UNIOP)))
+#define UNIBRACK(f) { \
+	yylval.ival = f; \
+	PL_bufptr = s; \
+	PL_last_uni = PL_oldbufptr; \
+	if (*s == '(') \
+	    return REPORT( (int)FUNC1 ); \
+	s = skipspace(s); \
+	return REPORT( (*s == '(') ? (int)FUNC1 : (int)UNIOP ); \
+	}
 
 /* grandfather return to old style */
 #define OLDLOP(f) return(yylval.ival=f,PL_expect = XTERM,PL_bufptr = s,(int)LSTOP)
@@ -199,7 +206,8 @@ enum token_type {
     TOKENTYPE_GVVAL
 };
 
-static struct debug_tokens { int token, type; char *name;} debug_tokens[] =
+static struct debug_tokens { const int token, type; const char *name; }
+  const debug_tokens[] =
 {
     { ADDOP,		TOKENTYPE_OPNUM,	"ADDOP" },
     { ANDAND,		TOKENTYPE_NONE,		"ANDAND" },
@@ -269,13 +277,13 @@ static struct debug_tokens { int token, type; char *name;} debug_tokens[] =
 /* dump the returned token in rv, plus any optional arg in yylval */
 
 STATIC int
-S_tokereport(pTHX_ char* s, I32 rv)
+S_tokereport(pTHX_ const char* s, I32 rv)
 {
     if (DEBUG_T_TEST) {
-	char *name = Nullch;
+	const char *name = Nullch;
 	enum token_type type = TOKENTYPE_NONE;
-	struct debug_tokens *p;
-        SV* report = newSVpvn("<== ", 4);
+	const struct debug_tokens *p;
+	SV* report = newSVpvn("<== ", 4);
 
 	for (p = debug_tokens; p->token; p++) {
 	    if (p->token == (int)rv) {
@@ -297,7 +305,7 @@ S_tokereport(pTHX_ char* s, I32 rv)
 	case TOKENTYPE_GVVAL: /* doesn't appear to be used */
 	    break;
 	case TOKENTYPE_IVAL:
-	    Perl_sv_catpvf(aTHX_ report, "(ival=%"IVdf")", yylval.ival);
+	    Perl_sv_catpvf(aTHX_ report, "(ival=%"IVdf")", (IV)yylval.ival);
 	    break;
 	case TOKENTYPE_OPNUM:
 	    Perl_sv_catpvf(aTHX_ report, "(ival=op_%s)",
@@ -314,7 +322,7 @@ S_tokereport(pTHX_ char* s, I32 rv)
 		Perl_sv_catpv(aTHX_ report, "(opval=null)");
 	    break;
 	}
-        Perl_sv_catpvf(aTHX_ report, " at line %d [", CopLINE(PL_curcop));
+        Perl_sv_catpvf(aTHX_ report, " at line %"IVdf" [", (IV)CopLINE(PL_curcop));
         if (s - PL_bufptr > 0)
             sv_catpvn(report, PL_bufptr, s - PL_bufptr);
         else {
@@ -365,7 +373,7 @@ S_ao(pTHX_ int toketype)
  */
 
 STATIC void
-S_no_op(pTHX_ char *what, char *s)
+S_no_op(pTHX_ const char *what, char *s)
 {
     char *oldbp = PL_bufptr;
     bool is_first = (PL_oldbufptr == PL_linestart);
@@ -380,7 +388,7 @@ S_no_op(pTHX_ char *what, char *s)
 	    Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
 		    "\t(Missing semicolon on previous line?)\n");
 	else if (PL_oldoldbufptr && isIDFIRST_lazy_if(PL_oldoldbufptr,UTF)) {
-	    char *t;
+	    const char *t;
 	    for (t = PL_oldoldbufptr; *t && (isALNUM_lazy_if(t,UTF) || *t == ':'); t++) ;
 	    if (t < PL_bufptr && isSPACE(*t))
 		Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
@@ -441,14 +449,14 @@ S_missingterm(pTHX_ char *s)
  */
 
 void
-Perl_deprecate(pTHX_ char *s)
+Perl_deprecate(pTHX_ const char *s)
 {
     if (ckWARN(WARN_DEPRECATED))
 	Perl_warner(aTHX_ packWARN(WARN_DEPRECATED), "Use of %s is deprecated", s);
 }
 
 void
-Perl_deprecate_old(pTHX_ char *s)
+Perl_deprecate_old(pTHX_ const char *s)
 {
     /* This function should NOT be called for any new deprecated warnings */
     /* Use Perl_deprecate instead                                         */
@@ -459,7 +467,7 @@ Perl_deprecate_old(pTHX_ char *s)
     /* in its own right.                                                  */
 
     if (ckWARN2(WARN_DEPRECATED, WARN_SYNTAX))
-	Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX), 
+	Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_SYNTAX),
 			"Use of %s is deprecated", s);
 }
 
@@ -483,8 +491,8 @@ S_depcom(pTHX)
 static void
 strip_return(SV *sv)
 {
-    register char *s = SvPVX(sv);
-    register char *e = s + SvCUR(sv);
+    register const char *s = SvPVX_const(sv);
+    register const char *e = s + SvCUR(sv);
     /* outer loop optimized to do nothing if there are no CR-LFs */
     while (s < e) {
 	if (*s++ == '\r' && *s == '\n') {
@@ -505,7 +513,7 @@ strip_return(SV *sv)
 STATIC I32
 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 {
-    I32 count = FILTER_READ(idx+1, sv, maxlen);
+    const I32 count = FILTER_READ(idx+1, sv, maxlen);
     if (count > 0 && !maxlen)
 	strip_return(sv);
     return count;
@@ -775,7 +783,7 @@ S_skipspace(pTHX_ register char *s)
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setpvn(sv,PL_bufptr,PL_bufend-PL_bufptr);
             (void)SvIOK_on(sv);
-            SvIVX(sv) = 0;
+            SvIV_set(sv, 0);
 	    av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv);
 	}
     }
@@ -873,7 +881,7 @@ STATIC SV *
 S_newSV_maybe_utf8(pTHX_ const char *start, STRLEN len)
 {
     SV *sv = newSVpvn(start,len);
-    if (UTF && !IN_BYTES && is_utf8_string((U8*)start, len))
+    if (UTF && !IN_BYTES && is_utf8_string((const U8*)start, len))
 	SvUTF8_on(sv);
     return sv;
 }
@@ -936,10 +944,10 @@ S_force_word(pTHX_ register char *start, int token, int check_keyword, int allow
  */
 
 STATIC void
-S_force_ident(pTHX_ register char *s, int kind)
+S_force_ident(pTHX_ register const char *s, int kind)
 {
     if (s && *s) {
-	OP* o = (OP*)newSVOP(OP_CONST, 0, newSVpv(s,0));
+	OP* const o = (OP*)newSVOP(OP_CONST, 0, newSVpv(s,0));
 	PL_nextval[PL_nexttoke].opval = o;
 	force_next(WORD);
 	if (kind) {
@@ -963,9 +971,9 @@ Perl_str_to_version(pTHX_ SV *sv)
     NV retval = 0.0;
     NV nshift = 1.0;
     STRLEN len;
-    char *start = SvPVx(sv,len);
-    bool utf = SvUTF8(sv) ? TRUE : FALSE;
-    char *end = start + len;
+    const char *start = SvPVx_const(sv,len);
+    const char *end = start + len;
+    const bool utf = SvUTF8(sv) ? TRUE : FALSE;
     while (start < end) {
 	STRLEN skip;
 	UV n;
@@ -1010,8 +1018,8 @@ S_force_version(pTHX_ char *s, int guessing)
             version = yylval.opval;
 	    ver = cSVOPx(version)->op_sv;
 	    if (SvPOK(ver) && !SvNIOK(ver)) {
-		(void)SvUPGRADE(ver, SVt_PVNV);
-		SvNVX(ver) = str_to_version(ver);
+		SvUPGRADE(ver, SVt_PVNV);
+		SvNV_set(ver, str_to_version(ver));
 		SvNOK_on(ver);		/* hint that it is a version */
 	    }
         }
@@ -1056,7 +1064,7 @@ S_tokeq(pTHX_ SV *sv)
 	goto finish;
     d = s;
     if ( PL_hints & HINT_NEW_STRING ) {
-	pv = sv_2mortal(newSVpvn(SvPVX(pv), len));
+	pv = sv_2mortal(newSVpvn(SvPVX_const(pv), len));
 	if (SvUTF8(sv))
 	    SvUTF8_on(pv);
     }
@@ -1068,7 +1076,7 @@ S_tokeq(pTHX_ SV *sv)
 	*d++ = *s++;
     }
     *d = '\0';
-    SvCUR_set(sv, d - SvPVX(sv));
+    SvCUR_set(sv, d - SvPVX_const(sv));
   finish:
     if ( PL_hints & HINT_NEW_STRING )
        return new_constant(NULL, 0, "q", sv, pv, "q");
@@ -1110,7 +1118,7 @@ S_tokeq(pTHX_ SV *sv)
 STATIC I32
 S_sublex_start(pTHX)
 {
-    register I32 op_type = yylval.ival;
+    const register I32 op_type = yylval.ival;
 
     if (op_type == OP_NULL) {
 	yylval.opval = PL_lex_op;
@@ -1123,11 +1131,8 @@ S_sublex_start(pTHX)
 	if (SvTYPE(sv) == SVt_PVIV) {
 	    /* Overloaded constants, nothing fancy: Convert to SVt_PV: */
 	    STRLEN len;
-	    char *p;
-	    SV *nsv;
-
-	    p = SvPV(sv, len);
-	    nsv = newSVpvn(p, len);
+	    const char *p = SvPV(sv, len);
+	    SV * const nsv = newSVpvn(p, len);
 	    if (SvUTF8(sv))
 		SvUTF8_on(nsv);
 	    SvREFCNT_dec(sv);
@@ -1167,6 +1172,7 @@ S_sublex_start(pTHX)
 STATIC I32
 S_sublex_push(pTHX)
 {
+    dVAR;
     ENTER;
 
     PL_lex_state = PL_sublex_info.super_state;
@@ -1225,6 +1231,7 @@ S_sublex_push(pTHX)
 STATIC I32
 S_sublex_done(pTHX)
 {
+    dVAR;
     if (!PL_lex_starts++) {
 	SV *sv = newSVpvn("",0);
 	if (SvUTF8(PL_linestr))
@@ -1395,7 +1402,7 @@ S_scan_const(pTHX_ char *start)
 		    continue;
 		}
 
-		i = d - SvPVX(sv);		/* remember current offset */
+		i = d - SvPVX_const(sv);		/* remember current offset */
 		SvGROW(sv, SvLEN(sv) + 256);	/* never more than 256 chars in a range */
 		d = SvPVX(sv) + i;		/* refresh d after realloc */
 		d -= 2;				/* eat the first char and the - */
@@ -1549,7 +1556,7 @@ S_scan_const(pTHX_ char *start)
 	    default:
 	        {
 		    if (ckWARN(WARN_MISC) &&
-			isALNUM(*s) && 
+			isALNUM(*s) &&
 			*s != '_')
 			Perl_warner(aTHX_ packWARN(WARN_MISC),
 			       "Unrecognized escape \\%c passed through",
@@ -1622,7 +1629,7 @@ S_scan_const(pTHX_ char *start)
 			    }
 			}
 			if (hicount) {
-			    STRLEN offset = d - SvPVX(sv);
+			    STRLEN offset = d - SvPVX_const(sv);
 			    U8 *src, *dst;
 			    d = SvGROW(sv, SvLEN(sv) + hicount + 1) + offset;
 			    src = (U8 *)d - 1;
@@ -1712,7 +1719,7 @@ S_scan_const(pTHX_ char *start)
 		    }
 #endif
 		    if (!has_utf8 && SvUTF8(res)) {
-			char *ostart = SvPVX(sv);
+			const char *ostart = SvPVX_const(sv);
 			SvCUR_set(sv, d - ostart);
 			SvPOK_on(sv);
 			*d = '\0';
@@ -1723,7 +1730,7 @@ S_scan_const(pTHX_ char *start)
 			has_utf8 = TRUE;
 		    }
 		    if (len > (STRLEN)(e - s + 4)) { /* I _guess_ 4 is \N{} --jhi */
-			char *odest = SvPVX(sv);
+			const char *odest = SvPVX_const(sv);
 
 			SvGROW(sv, (SvLEN(sv) + len - (e - s + 4)));
 			d = SvPVX(sv) + (d - odest);
@@ -1792,7 +1799,7 @@ S_scan_const(pTHX_ char *start)
 	    s += len;
 	    if (need > len) {
 		/* encoded value larger than old, need extra space (NOTE: SvCUR() not set here) */
-		STRLEN off = d - SvPVX(sv);
+		STRLEN off = d - SvPVX_const(sv);
 		d = SvGROW(sv, SvLEN(sv) + (need-len)) + off;
 	    }
 	    d = (char*)uvchr_to_utf8((U8*)d, uv);
@@ -1805,7 +1812,7 @@ S_scan_const(pTHX_ char *start)
 
     /* terminate the string and set up the sv */
     *d = '\0';
-    SvCUR_set(sv, d - SvPVX(sv));
+    SvCUR_set(sv, d - SvPVX_const(sv));
     if (SvCUR(sv) >= SvLEN(sv))
 	Perl_croak(aTHX_ "panic: constant overflowed allocated space");
 
@@ -1825,8 +1832,7 @@ S_scan_const(pTHX_ char *start)
 
     /* shrink the sv if we allocated more than we used */
     if (SvCUR(sv) + 5 < SvLEN(sv)) {
-	SvLEN_set(sv, SvCUR(sv) + 1);
-	Renew(SvPVX(sv), SvLEN(sv), char);
+	SvPV_shrink_to_cur(sv);
     }
 
     /* return the substring (via yylval) only if we parsed anything */
@@ -1905,7 +1911,7 @@ S_intuit_more(pTHX_ register char *s)
 	int weight = 2;		/* let's weigh the evidence */
 	char seen[256];
 	unsigned char un_char = 255, last_un_char;
-	char *send = strchr(s,']');
+	const char *send = strchr(s,']');
 	char tmpbuf[sizeof PL_tokenbuf * 4];
 
 	if (!send)		/* has to be an expression */
@@ -2033,7 +2039,7 @@ S_intuit_method(pTHX_ char *start, GV *gv)
 	if (GvIO(gv))
 	    return 0;
 	if ((cv = GvCVu(gv))) {
-	    char *proto = SvPVX(cv);
+	    const char *proto = SvPVX_const(cv);
 	    if (proto) {
 		if (*proto == ';')
 		    proto++;
@@ -2091,11 +2097,11 @@ S_intuit_method(pTHX_ char *start, GV *gv)
  * compile-time require of perl5db.pl.
  */
 
-STATIC char*
+STATIC const char*
 S_incl_perldb(pTHX)
 {
     if (PL_perldb) {
-	char *pdb = PerlEnv_getenv("PERL5DB");
+	const char *pdb = PerlEnv_getenv("PERL5DB");
 
 	if (pdb)
 	    return pdb;
@@ -2133,12 +2139,11 @@ Perl_filter_add(pTHX_ filter_t funcp, SV *datasv)
 	PL_rsfp_filters = newAV();
     if (!datasv)
 	datasv = NEWSV(255,0);
-    if (!SvUPGRADE(datasv, SVt_PVIO))
-        Perl_die(aTHX_ "Can't upgrade filter_add data to SVt_PVIO");
-    IoANY(datasv) = (void *)funcp; /* stash funcp into spare field */
+    SvUPGRADE(datasv, SVt_PVIO);
+    IoANY(datasv) = FPTR2DPTR(void *, funcp); /* stash funcp into spare field */
     IoFLAGS(datasv) |= IOf_FAKE_DIRP;
     DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_add func %p (%s)\n",
-			  (void*)funcp, SvPV_nolen(datasv)));
+			  IoANY(datasv), SvPV_nolen(datasv)));
     av_unshift(PL_rsfp_filters, 1);
     av_store(PL_rsfp_filters, 0, datasv) ;
     return(datasv);
@@ -2150,12 +2155,15 @@ void
 Perl_filter_del(pTHX_ filter_t funcp)
 {
     SV *datasv;
-    DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_del func %p", (void*)funcp));
+
+#ifdef DEBUGGING
+    DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_del func %p", FPTR2DPTR(XPVIO *, funcp)));
+#endif
     if (!PL_rsfp_filters || AvFILLp(PL_rsfp_filters)<0)
 	return;
     /* if filter is on top of stack (usual case) just pop it off */
     datasv = FILTER_DATA(AvFILLp(PL_rsfp_filters));
-    if (IoANY(datasv) == (void *)funcp) {
+    if (IoANY(datasv) == FPTR2DPTR(void *, funcp)) {
 	IoFLAGS(datasv) &= ~IOf_FAKE_DIRP;
 	IoANY(datasv) = (void *)NULL;
 	sv_free(av_pop(PL_rsfp_filters));
@@ -2185,7 +2193,7 @@ Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen)
 	if (maxlen) {
  	    /* Want a block */
 	    int len ;
-	    int old_len = SvCUR(buf_sv) ;
+	    const int old_len = SvCUR(buf_sv);
 
 	    /* ensure buf_sv is large enough */
 	    SvGROW(buf_sv, (STRLEN)(old_len + maxlen)) ;
@@ -2215,10 +2223,10 @@ Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen)
 	return FILTER_READ(idx+1, buf_sv, maxlen); /* recurse */
     }
     /* Get function pointer hidden within datasv	*/
-    funcp = (filter_t)IoANY(datasv);
+    funcp = DPTR2FPTR(filter_t, IoANY(datasv));
     DEBUG_P(PerlIO_printf(Perl_debug_log,
 			  "filter_read %d: via function %p (%s)\n",
-			  idx, (void*)funcp, SvPV_nolen(datasv)));
+			  idx, datasv, SvPV_nolen(datasv)));
     /* Call function. The function is expected to 	*/
     /* call "FILTER_READ(idx+1, buf_sv)" first.		*/
     /* Return: <0:error, =0:eof, >0:not eof 		*/
@@ -2264,7 +2272,7 @@ S_find_in_my_stash(pTHX_ const char *pkgname, I32 len)
     if ((gv = gv_fetchpv(pkgname, FALSE, SVt_PVCV))) {
         SV *sv;
         if (GvCV(gv) && (sv = cv_const_sv(GvCV(gv)))) {
-            pkgname = SvPV_nolen(sv);
+            pkgname = SvPV_nolen_const(sv);
         }
     }
 
@@ -2272,7 +2280,7 @@ S_find_in_my_stash(pTHX_ const char *pkgname, I32 len)
 }
 
 #ifdef DEBUGGING
-    static char* exp_name[] =
+    static const char* const exp_name[] =
 	{ "OPERATOR", "TERM", "REF", "STATE", "BLOCK", "ATTRBLOCK",
 	  "ATTRTERM", "TERMBLOCK", "TERMORDORDOR"
 	};
@@ -2361,11 +2369,9 @@ Perl_yylex(pTHX)
 #endif
 	/* handle \E or end of string */
        	if (PL_bufptr == PL_bufend || PL_bufptr[1] == 'E') {
-	    char oldmod;
-
 	    /* if at a \E */
 	    if (PL_lex_casemods) {
-		oldmod = PL_lex_casestack[--PL_lex_casemods];
+		const char oldmod = PL_lex_casestack[--PL_lex_casemods];
 		PL_lex_casestack[PL_lex_casemods] = '\0';
 
 		if (PL_bufptr != PL_bufend
@@ -2603,14 +2609,14 @@ Perl_yylex(pTHX)
 			    /* The count here deliberately includes the NUL
 			       that terminates the C string constant.  This
 			       embeds the opening NUL into the string.  */
+			    const char *splits = PL_splitstr;
 			    sv_catpvn(PL_linestr, "our @F=split(q", 15);
-			    s = PL_splitstr;
 			    do {
 				/* Need to \ \s  */
-				if (*s == '\\')
-				    sv_catpvn(PL_linestr, s, 1);
-				sv_catpvn(PL_linestr, s, 1);
-			    } while (*s++);
+				if (*splits == '\\')
+				    sv_catpvn(PL_linestr, splits, 1);
+				sv_catpvn(PL_linestr, splits, 1);
+			    } while (*splits++);
 			    /* This loop will embed the trailing NUL of
 			       PL_linestr as the last thing it does before
 			       terminating.  */
@@ -2631,7 +2637,7 @@ Perl_yylex(pTHX)
 		sv_upgrade(sv, SVt_PVMG);
 		sv_setsv(sv,PL_linestr);
                 (void)SvIOK_on(sv);
-                SvIVX(sv) = 0;
+                SvIV_set(sv, 0);
 		av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv);
 	    }
 	    goto retry;
@@ -2661,7 +2667,7 @@ Perl_yylex(pTHX)
 		}
 		PL_oldoldbufptr = PL_oldbufptr = s = PL_linestart = SvPVX(PL_linestr);
 		PL_last_lop = PL_last_uni = Nullch;
-		sv_setpv(PL_linestr,"");
+		sv_setpvn(PL_linestr,"",0);
 		TOKEN(';');	/* not infinite loop because rsfp is NULL now */
 	    }
 	    /* If it looks like the start of a BOM or raw UTF-16,
@@ -2702,7 +2708,7 @@ Perl_yylex(pTHX)
 	    if (PL_doextract) {
 		/* Incest with pod. */
 		if (*s == '=' && strnEQ(s, "=cut", 4)) {
-		    sv_setpv(PL_linestr, "");
+		    sv_setpvn(PL_linestr, "", 0);
 		    PL_oldoldbufptr = PL_oldbufptr = s = PL_linestart = SvPVX(PL_linestr);
 		    PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
 		    PL_last_lop = PL_last_uni = Nullch;
@@ -2718,7 +2724,7 @@ Perl_yylex(pTHX)
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setsv(sv,PL_linestr);
             (void)SvIOK_on(sv);
-            SvIVX(sv) = 0;
+            SvIV_set(sv, 0);
 	    av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv);
 	}
 	PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
@@ -2734,7 +2740,7 @@ Perl_yylex(pTHX)
 		    d = s + 2;
 #ifdef ALTERNATE_SHEBANG
 		else {
-		    static char as[] = ALTERNATE_SHEBANG;
+		    static char const as[] = ALTERNATE_SHEBANG;
 		    if (*s == as[0] && strnEQ(s, as, sizeof(as) - 1))
 			d = s + (sizeof(as) - 1);
 		}
@@ -2768,8 +2774,8 @@ Perl_yylex(pTHX)
 		    else {
 			STRLEN blen;
 			STRLEN llen;
-			char *bstart = SvPV(CopFILESV(PL_curcop),blen);
-			char *lstart = SvPV(x,llen);
+			const char *bstart = SvPV(CopFILESV(PL_curcop),blen);
+			const char *lstart = SvPV(x,llen);
 			if (llen < blen) {
 			    bstart += blen - llen;
 			    if (strnEQ(bstart, lstart, llen) &&	bstart[-1] == '/') {
@@ -2815,7 +2821,7 @@ Perl_yylex(pTHX)
 		 * contains the start of the Perl program.
 		 */
 		if (d && *s != '#') {
-		    char *c = ipath;
+		    const char *c = ipath;
 		    while (*c && !strchr("; \t\r\n\f\v#", *c))
 			c++;
 		    if (c < d)
@@ -2832,6 +2838,7 @@ Perl_yylex(pTHX)
 		    !instr(s,"indir") &&
 		    instr(PL_origargv[0],"perl"))
 		{
+		    dVAR;
 		    char **newargv;
 
 		    *ipathend = '\0';
@@ -2856,18 +2863,18 @@ Perl_yylex(pTHX)
 		}
 #endif
 		if (d) {
-		    U32 oldpdb = PL_perldb;
-		    bool oldn = PL_minus_n;
-		    bool oldp = PL_minus_p;
+		    const U32 oldpdb = PL_perldb;
+		    const bool oldn = PL_minus_n;
+		    const bool oldp = PL_minus_p;
 
 		    while (*d && !isSPACE(*d)) d++;
 		    while (SPACE_OR_TAB(*d)) d++;
 
 		    if (*d++ == '-') {
-			bool switches_done = PL_doswitches;
+			const bool switches_done = PL_doswitches;
 			do {
-			    if (*d == 'M' || *d == 'm') {
-				char *m = d;
+			    if (*d == 'M' || *d == 'm' || *d == 'C') {
+				const char *m = d;
 				while (*d && !isSPACE(*d)) d++;
 				Perl_croak(aTHX_ "Too late for \"-%.*s\" option",
 				      (int)(d - m), m);
@@ -2887,7 +2894,7 @@ Perl_yylex(pTHX)
 			      /* if we have already added "LINE: while (<>) {",
 			         we must not do it again */
 			{
-			    sv_setpv(PL_linestr, "");
+			    sv_setpvn(PL_linestr, "", 0);
 			    PL_oldoldbufptr = PL_oldbufptr = s = PL_linestart = SvPVX(PL_linestr);
 			    PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
 			    PL_last_lop = PL_last_uni = Nullch;
@@ -3178,7 +3185,7 @@ Perl_yylex(pTHX)
 #else
 			    ; /* skip to avoid loading attributes.pm */
 #endif
-			else 
+			else
 			    Perl_croak(aTHX_ "The 'unique' attribute may only be applied to 'our' variables");
 		    }
 
@@ -3215,7 +3222,7 @@ Perl_yylex(pTHX)
 	    }
 	    tmp = (PL_expect == XOPERATOR ? '=' : '{'); /*'}(' for vi */
 	    if (*s != ';' && *s != '}' && *s != tmp && (tmp != '=' || *s != ')')) {
-		char q = ((*s == '\'') ? '"' : '\'');
+		const char q = ((*s == '\'') ? '"' : '\'');
 		/* If here for an expression, and parsed no attrs, back off. */
 		if (tmp == '=' && !attrs) {
 		    s = PL_bufptr;
@@ -3307,7 +3314,7 @@ Perl_yylex(pTHX)
 		while (d < PL_bufend && SPACE_OR_TAB(*d))
 		    d++;
 		if (*d == '}') {
-		    char minus = (PL_tokenbuf[0] == '-');
+		    const char minus = (PL_tokenbuf[0] == '-');
 		    s = force_word(s + minus, WORD, FALSE, TRUE, FALSE);
 		    if (minus)
 			force_next('-');
@@ -3325,7 +3332,7 @@ Perl_yylex(pTHX)
 	    PL_expect = XSTATE;
 	    break;
 	default: {
-		char *t;
+		const char *t;
 		if (PL_oldoldbufptr == PL_last_lop)
 		    PL_lex_brackstack[PL_lex_brackets++] = XTERM;
 		else
@@ -3348,7 +3355,7 @@ Perl_yylex(pTHX)
 		 * eval"") we have to resolve the ambiguity.  This code
 		 * covers the case where the first term in the curlies is a
 		 * quoted string.  Most other cases need to be explicitly
-		 * disambiguated by prepending a `+' before the opening
+		 * disambiguated by prepending a "+" before the opening
 		 * curly in order to force resolution as an anon hash.
 		 *
 		 * XXX should probably propagate the outer expectation
@@ -3371,7 +3378,7 @@ Perl_yylex(pTHX)
 				&& !isALNUM(*t))))
 		    {
 			/* skip q//-like construct */
-			char *tmps;
+			const char *tmps;
 			char open, close, term;
 			I32 brackets = 1;
 
@@ -3537,7 +3544,7 @@ Perl_yylex(pTHX)
 	    goto retry;
 	}
 	if (PL_lex_brackets < PL_lex_formbrack) {
-	    char *t;
+	    const char *t;
 #ifdef PERL_STRICT_CR
 	    for (t = s; SPACE_OR_TAB(*t); t++) ;
 #else
@@ -3559,7 +3566,7 @@ Perl_yylex(pTHX)
              * warn on m:!=~\s+([/?]|[msy]\W|tr\W): */
 
             if (*s == '~' && ckWARN(WARN_SYNTAX)) {
-                char *t = s+1;
+		const char *t = s+1;
 
                 while (t < PL_bufend && isSPACE(*t))
                     ++t;
@@ -3681,9 +3688,9 @@ Perl_yylex(pTHX)
 		    (t = strchr(s, '}')) && (t = strchr(t, '=')))
 		{
 		    char tmpbuf[sizeof PL_tokenbuf];
-		    STRLEN len;
 		    for (t++; isSPACE(*t); t++) ;
 		    if (isIDFIRST_lazy_if(t,UTF)) {
+		        STRLEN len;
 			t = scan_word(t, tmpbuf, sizeof tmpbuf, TRUE, &len);
 		        for (; isSPACE(*t); t++) ;
 			if (*t == ';' && get_cv(tmpbuf, FALSE))
@@ -3696,7 +3703,7 @@ Perl_yylex(pTHX)
 
 	PL_expect = XOPERATOR;
 	if (PL_lex_state == LEX_NORMAL && isSPACE((char)tmp)) {
-	    bool islop = (PL_last_lop == PL_oldoldbufptr);
+	    const bool islop = (PL_last_lop == PL_oldoldbufptr);
 	    if (!islop || PL_last_lop_op == OP_GREPSTART)
 		PL_expect = XOPERATOR;
 	    else if (strchr("$@\"'`q", *s))
@@ -3760,7 +3767,7 @@ Perl_yylex(pTHX)
 	    /* Warn about @ where they meant $. */
 	    if (ckWARN(WARN_SYNTAX)) {
 		if (*s == '[' || *s == '{') {
-		    char *t = s + 1;
+		    const char *t = s + 1;
 		    while (*t && (isALNUM_lazy_if(t,UTF) || strchr(" \t$#+-'\"", *t)))
 			t++;
 		    if (*t == '}' || *t == ']') {
@@ -3919,9 +3926,7 @@ Perl_yylex(pTHX)
 
     case 'v':
 	if (isDIGIT(s[1]) && PL_expect != XOPERATOR) {
-	    char *start = s;
-	    start++;
-	    start++;
+	    char *start = s + 2;
 	    while (isDIGIT(*start) || *start == '_')
 		start++;
 	    if (*start == '.' && isDIGIT(start[1])) {
@@ -3932,7 +3937,7 @@ Perl_yylex(pTHX)
 	    else if (!isALPHA(*start) && (PL_expect == XTERM
 			|| PL_expect == XREF || PL_expect == XSTATE
 			|| PL_expect == XTERMORDORDOR)) {
-		char c = *start;
+		const char c = *start;
 		GV *gv;
 		*start = '\0';
 		gv = gv_fetchpv(s, FALSE, SVt_PVCV);
@@ -4088,7 +4093,7 @@ Perl_yylex(pTHX)
 	  just_a_word: {
 		SV *sv;
 		int pkgname = 0;
-		char lastchar = (PL_bufptr == PL_oldoldbufptr ? 0 : PL_bufptr[-1]);
+		const char lastchar = (PL_bufptr == PL_oldoldbufptr ? 0 : PL_bufptr[-1]);
 
 		/* Get the rest if it looks like a package qualifier */
 
@@ -4155,7 +4160,7 @@ Perl_yylex(pTHX)
 		yylval.opval->op_private = OPpCONST_BARE;
 		/* UTF-8 package name? */
 		if (UTF && !IN_BYTES &&
-		    is_utf8_string((U8*)SvPVX(sv), SvCUR(sv)))
+		    is_utf8_string((U8*)SvPVX_const(sv), SvCUR(sv)))
 		    SvUTF8_on(sv);
 
 		/* And if "Foo::", then that's what it certainly is. */
@@ -4275,7 +4280,7 @@ Perl_yylex(pTHX)
 			while (*proto == ';')
 			    proto++;
 			if (*proto == '&' && *s == '{') {
-			    sv_setpv(PL_subname, PL_curstash ? 
+			    sv_setpv(PL_subname, PL_curstash ?
 					"__ANON__" : "__ANON__::__ANON__");
 			    PREBLOCK(LSTOPSUB);
 			}
@@ -4328,7 +4333,7 @@ Perl_yylex(pTHX)
 	case KEY___PACKAGE__:
 	    yylval.opval = (OP*)newSVOP(OP_CONST, 0,
 					(PL_curstash
-					 ? newSVpv(HvNAME(PL_curstash), 0)
+					 ? newSVhek(HvNAME_HEK(PL_curstash))
 					 : &PL_sv_undef));
 	    TERM(THING);
 
@@ -4338,9 +4343,9 @@ Perl_yylex(pTHX)
 
 	    /*SUPPRESS 560*/
 	    if (PL_rsfp && (!PL_in_eval || PL_tokenbuf[2] == 'D')) {
-		char *pname = "main";
+		const char *pname = "main";
 		if (PL_tokenbuf[2] == 'D')
-		    pname = HvNAME(PL_curstash ? PL_curstash : PL_defstash);
+		    pname = HvNAME_get(PL_curstash ? PL_curstash : PL_defstash);
 		gv = gv_fetchpv(Perl_form(aTHX_ "%s::DATA", pname), TRUE, SVt_PVIO);
 		GvMULTI_on(gv);
 		if (!GvIO(gv))
@@ -4348,7 +4353,7 @@ Perl_yylex(pTHX)
 		IoIFP(GvIOp(gv)) = PL_rsfp;
 #if defined(HAS_FCNTL) && defined(F_SETFD)
 		{
-		    int fd = PerlIO_fileno(PL_rsfp);
+		    const int fd = PerlIO_fileno(PL_rsfp);
 		    fcntl(fd,F_SETFD,fd >= 3);
 		}
 #endif
@@ -4405,7 +4410,7 @@ Perl_yylex(pTHX)
 			SPAGAIN;
 			name = POPs;
 			PUTBACK;
-			PerlIO_apply_layers(aTHX_ PL_rsfp, NULL, 
+			PerlIO_apply_layers(aTHX_ PL_rsfp, NULL,
 					    Perl_form(aTHX_ ":encoding(%"SVf")",
 						      name));
 			FREETMPS;
@@ -4867,7 +4872,7 @@ Perl_yylex(pTHX)
 	case KEY_open:
 	    s = skipspace(s);
 	    if (isIDFIRST_lazy_if(s,UTF)) {
-		char *t;
+		const char *t;
 		for (d = s; isALNUM_lazy_if(d,UTF); d++) ;
 		for (t=d; *t && isSPACE(*t); t++) ;
 		if ( *t && strchr("|&*+-=!?:.", *t) && ckWARN_d(WARN_PRECEDENCE)
@@ -4938,6 +4943,7 @@ Perl_yylex(pTHX)
 	    s = scan_str(s,FALSE,FALSE);
 	    if (!s)
 		missingterm((char*)0);
+	    PL_expect = XOPERATOR;
 	    force_next(')');
 	    if (SvCUR(PL_lex_stuff)) {
 		OP *words = Nullop;
@@ -4947,7 +4953,7 @@ Perl_yylex(pTHX)
 		    SV *sv;
 		    for (; isSPACE(*d) && len; --len, ++d) ;
 		    if (len) {
-			char *b = d;
+			const char *b = d;
 			if (!warned && ckWARN(WARN_QW)) {
 			    for (; !isSPACE(*d) && len; --len, ++d) {
 				if (*d == ',') {
@@ -4990,7 +4996,7 @@ Perl_yylex(pTHX)
 		missingterm((char*)0);
 	    yylval.ival = OP_STRINGIFY;
 	    if (SvIVX(PL_lex_stuff) == '\'')
-		SvIVX(PL_lex_stuff) = 0;	/* qq'$foo' should intepolate */
+		SvIV_set(PL_lex_stuff, 0);	/* qq'$foo' should intepolate */
 	    TERM(sublex_start());
 
 	case KEY_qr:
@@ -5205,7 +5211,7 @@ Perl_yylex(pTHX)
 		SSize_t tboffset = 0;
 		expectation attrful;
 		bool have_name, have_proto, bad_proto;
-		int key = tmp;
+		const int key = tmp;
 
 		s = skipspace(s);
 
@@ -5232,7 +5238,7 @@ Perl_yylex(pTHX)
 			Perl_croak(aTHX_ "Missing name in \"my sub\"");
 		    PL_expect = XTERMBLOCK;
 		    attrful = XATTRTERM;
-		    sv_setpv(PL_subname,"?");
+		    sv_setpvn(PL_subname,"?",1);
 		    have_name = FALSE;
 		}
 
@@ -5268,7 +5274,7 @@ Perl_yylex(pTHX)
 			Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
 				    "Illegal character in prototype for %"SVf" : %s",
 				    PL_subname, d);
-		    SvCUR(PL_lex_stuff) = tmp;
+		    SvCUR_set(PL_lex_stuff, tmp);
 		    have_proto = TRUE;
 
 		    s = skipspace(s);
@@ -5518,7 +5524,9 @@ S_pending_ident(pTHX)
             /* might be an "our" variable" */
             if (PAD_COMPNAME_FLAGS(tmp) & SVpad_OUR) {
                 /* build ops for a bareword */
-                SV *sym = newSVpv(HvNAME(PAD_COMPNAME_OURSTASH(tmp)), 0);
+		HV *stash = PAD_COMPNAME_OURSTASH(tmp);
+		HEK *stashname = HvNAME_HEK(stash);
+                SV *sym = newSVhek(stashname);
                 sv_catpvn(sym, "::", 2);
                 sv_catpv(sym, PL_tokenbuf+1);
                 yylval.opval = (OP*)newSVOP(OP_CONST, 0, sym);
@@ -5589,7 +5597,7 @@ S_pending_ident(pTHX)
  */
 
 I32
-Perl_keyword (pTHX_ char *name, I32 len)
+Perl_keyword (pTHX_ const char *name, I32 len)
 {
   switch (len)
   {
@@ -8887,9 +8895,9 @@ unknown:
 }
 
 STATIC void
-S_checkcomma(pTHX_ register char *s, char *name, char *what)
+S_checkcomma(pTHX_ register char *s, const char *name, const char *what)
 {
-    char *w;
+    const char *w;
 
     if (*s == ' ' && s[1] == '(') {	/* XXX gotta be a better way */
 	if (ckWARN(WARN_SYNTAX)) {
@@ -8921,7 +8929,7 @@ S_checkcomma(pTHX_ register char *s, char *name, char *what)
 	    s++;
 	if (*s == ',') {
 	    int kw;
-	    *s = '\0';
+	    *s = '\0'; /* XXX If we didn't do this, we could const a lot of toke.c */
 	    kw = keyword(w, s - w) || get_cv(w, FALSE) != 0;
 	    *s = ',';
 	    if (kw)
@@ -8940,7 +8948,7 @@ STATIC SV *
 S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, SV *sv, SV *pv,
 	       const char *type)
 {
-    dSP;
+    dVAR; dSP;
     HV *table = GvHV(PL_hintgv);		 /* ^H */
     SV *res;
     SV **cvp;
@@ -8967,7 +8975,7 @@ S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, SV *sv, SV *pv,
 	msg = Perl_newSVpvf(aTHX_ "Constant(%s): %s%s%s",
 			    (type ? type: "undef"), why1, why2, why3);
     msgdone:
-	yyerror(SvPVX(msg));
+	yyerror(SvPVX_const(msg));
  	SvREFCNT_dec(msg);
   	return sv;
     }
@@ -9005,9 +9013,8 @@ S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, SV *sv, SV *pv,
 
     /* Check the eval first */
     if (!PL_in_eval && SvTRUE(ERRSV)) {
-	STRLEN n_a;
  	sv_catpv(ERRSV, "Propagated");
-	yyerror(SvPV(ERRSV, n_a)); /* Duplicates the message inside eval */
+	yyerror(SvPV_nolen_const(ERRSV)); /* Duplicates the message inside eval */
 	(void)POPs;
  	res = SvREFCNT_inc(sv);
     }
@@ -9073,7 +9080,7 @@ S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_packag
 }
 
 STATIC char *
-S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN destlen, I32 ck_uni)
+S_scan_ident(pTHX_ register char *s, register const char *send, char *dest, STRLEN destlen, I32 ck_uni)
 {
     register char *d;
     register char *e;
@@ -9148,7 +9155,7 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
     if (bracket) {
 	if (isSPACE(s[-1])) {
 	    while (s < send) {
-		char ch = *s++;
+		const char ch = *s++;
 		if (!SPACE_OR_TAB(ch)) {
 		    *d = ch;
 		    break;
@@ -9252,9 +9259,8 @@ STATIC char *
 S_scan_pat(pTHX_ char *start, I32 type)
 {
     PMOP *pm;
-    char *s;
+    char *s = scan_str(start,FALSE,FALSE);
 
-    s = scan_str(start,FALSE,FALSE);
     if (!s)
 	Perl_croak(aTHX_ "Search pattern not terminated");
 
@@ -9270,7 +9276,7 @@ S_scan_pat(pTHX_ char *start, I32 type)
 	    pmflag(&pm->op_pmflags,*s++);
     }
     /* issue a warning if /c is specified,but /g is not */
-    if (ckWARN(WARN_REGEXP) && 
+    if (ckWARN(WARN_REGEXP) &&
         (pm->op_pmflags & PMf_CONTINUE) && !(pm->op_pmflags & PMf_GLOBAL))
     {
         Perl_warner(aTHX_ packWARN(WARN_REGEXP), c_without_g);
@@ -9286,6 +9292,7 @@ S_scan_pat(pTHX_ char *start, I32 type)
 STATIC char *
 S_scan_subst(pTHX_ char *start)
 {
+    dVAR;
     register char *s;
     register PMOP *pm;
     I32 first_start;
@@ -9419,10 +9426,12 @@ S_scan_heredoc(pTHX_ register char *s)
     I32 len;
     SV *tmpstr;
     char term;
+    const char newline[] = "\n";
+    const char *found_newline;
     register char *d;
     register char *e;
     char *peek;
-    int outer = (PL_rsfp && !(PL_lex_inwhat == OP_SCALAR));
+    const int outer = (PL_rsfp && !(PL_lex_inwhat == OP_SCALAR));
 
     s += 2;
     d = PL_tokenbuf;
@@ -9458,7 +9467,7 @@ S_scan_heredoc(pTHX_ register char *s)
 #ifndef PERL_STRICT_CR
     d = strchr(s, '\r');
     if (d) {
-	char *olds = s;
+	char * const olds = s;
 	s = d;
 	while (s < PL_bufend) {
 	    if (*s == '\r') {
@@ -9475,26 +9484,28 @@ S_scan_heredoc(pTHX_ register char *s)
 	}
 	*d = '\0';
 	PL_bufend = d;
-	SvCUR_set(PL_linestr, PL_bufend - SvPVX(PL_linestr));
+	SvCUR_set(PL_linestr, PL_bufend - SvPVX_const(PL_linestr));
 	s = olds;
     }
 #endif
-    d = "\n";
-    if (outer || !(d=ninstr(s,PL_bufend,d,d+1)))
-	herewas = newSVpvn(s,PL_bufend-s);
-    else
-	s--, herewas = newSVpvn(s,d-s);
+    if ( outer || !(found_newline = ninstr(s,PL_bufend,newline,newline+1)) ) {
+        herewas = newSVpvn(s,PL_bufend-s);
+    }
+    else {
+        s--;
+        herewas = newSVpvn(s,found_newline-s);
+    }
     s += SvCUR(herewas);
 
     tmpstr = NEWSV(87,79);
     sv_upgrade(tmpstr, SVt_PVIV);
     if (term == '\'') {
 	op_type = OP_CONST;
-	SvIVX(tmpstr) = -1;
+	SvIV_set(tmpstr, -1);
     }
     else if (term == '`') {
 	op_type = OP_BACKTICK;
-	SvIVX(tmpstr) = '\\';
+	SvIV_set(tmpstr, '\\');
     }
 
     CLINE;
@@ -9504,7 +9515,7 @@ S_scan_heredoc(pTHX_ register char *s)
     if (PL_lex_inwhat == OP_SUBST && PL_in_eval && !PL_rsfp) {
 	char *bufptr = PL_sublex_info.super_bufptr;
 	char *bufend = PL_sublex_info.super_bufend;
-	char *olds = s - SvCUR(herewas);
+	char * const olds = s - SvCUR(herewas);
 	s = strchr(bufptr, '\n');
 	if (!s)
 	    s = bufend;
@@ -9522,7 +9533,7 @@ S_scan_heredoc(pTHX_ register char *s)
 	sv_setpvn(tmpstr,d+1,s-d);
 	s += len - 1;
 	sv_catpvn(herewas,s,bufend-s);
-	Copy(SvPVX(herewas),bufptr,SvCUR(herewas) + 1,char);
+	Copy(SvPVX_const(herewas),bufptr,SvCUR(herewas) + 1,char);
 
 	s = olds;
 	goto retval;
@@ -9566,7 +9577,7 @@ S_scan_heredoc(pTHX_ register char *s)
 	    {
 		PL_bufend[-2] = '\n';
 		PL_bufend--;
-		SvCUR_set(PL_linestr, PL_bufend - SvPVX(PL_linestr));
+		SvCUR_set(PL_linestr, PL_bufend - SvPVX_const(PL_linestr));
 	    }
 	    else if (PL_bufend[-1] == '\r')
 		PL_bufend[-1] = '\n';
@@ -9580,11 +9591,11 @@ S_scan_heredoc(pTHX_ register char *s)
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setsv(sv,PL_linestr);
             (void)SvIOK_on(sv);
-            SvIVX(sv) = 0;
+            SvIV_set(sv, 0);
 	    av_store(CopFILEAV(PL_curcop), (I32)CopLINE(PL_curcop),sv);
 	}
 	if (*s == term && memEQ(s,PL_tokenbuf,len)) {
-	    STRLEN off = PL_bufend - 1 - SvPVX(PL_linestr);
+	    STRLEN off = PL_bufend - 1 - SvPVX_const(PL_linestr);
 	    *(SvPVX(PL_linestr) + off ) = ' ';
 	    sv_catsv(PL_linestr,herewas);
 	    PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
@@ -9599,12 +9610,11 @@ S_scan_heredoc(pTHX_ register char *s)
 retval:
     PL_multi_end = CopLINE(PL_curcop);
     if (SvCUR(tmpstr) + 5 < SvLEN(tmpstr)) {
-	SvLEN_set(tmpstr, SvCUR(tmpstr) + 1);
-	Renew(SvPVX(tmpstr), SvLEN(tmpstr), char);
+	SvPV_shrink_to_cur(tmpstr);
     }
     SvREFCNT_dec(herewas);
     if (!IN_BYTES) {
-	if (UTF && is_utf8_string((U8*)SvPVX(tmpstr), SvCUR(tmpstr)))
+	if (UTF && is_utf8_string((U8*)SvPVX_const(tmpstr), SvCUR(tmpstr)))
 	    SvUTF8_on(tmpstr);
 	else if (PL_encoding)
 	    sv_recode_to_utf8(tmpstr, PL_encoding);
@@ -9715,8 +9725,9 @@ S_scan_inputsymbol(pTHX_ char *start)
 	    */
 	    if ((tmp = pad_findmy(d)) != NOT_IN_PAD) {
 		if (PAD_COMPNAME_FLAGS(tmp) & SVpad_OUR) {
-		    SV *sym = sv_2mortal(
-			    newSVpv(HvNAME(PAD_COMPNAME_OURSTASH(tmp)),0));
+		    HV *stash = PAD_COMPNAME_OURSTASH(tmp);
+		    HEK *stashname = HvNAME_HEK(stash);
+		    SV *sym = sv_2mortal(newSVhek(stashname));
 		    sv_catpvn(sym, "::", 2);
 		    sv_catpv(sym, d+1);
 		    d = SvPVX(sym);
@@ -9866,7 +9877,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
        assuming.  79 is the SV's initial length.  What a random number. */
     sv = NEWSV(87,79);
     sv_upgrade(sv, SVt_PVIV);
-    SvIVX(sv) = termcode;
+    SvIV_set(sv, termcode);
     (void)SvPOK_only(sv);		/* validate pointer */
 
     /* move past delimiter and try to read a complete string */
@@ -9878,10 +9889,10 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	    bool cont = TRUE;
 
 	    while (cont) {
-		int offset = s - SvPVX(PL_linestr);
-		bool found = sv_cat_decode(sv, PL_encoding, PL_linestr,
+		int offset = s - SvPVX_const(PL_linestr);
+		const bool found = sv_cat_decode(sv, PL_encoding, PL_linestr,
 					   &offset, (char*)termstr, termlen);
-		char *ns = SvPVX(PL_linestr) + offset;
+		const char *ns = SvPVX_const(PL_linestr) + offset;
 		char *svlast = SvEND(sv) - 1;
 
 		for (; s < ns; s++) {
@@ -9893,8 +9904,8 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 		else {
 		    /* handle quoted delimiters */
 		    if (SvCUR(sv) > 1 && *(svlast-1) == '\\') {
-			char *t;
-			for (t = svlast-2; t >= SvPVX(sv) && *t == '\\';)
+			const char *t;
+			for (t = svlast-2; t >= SvPVX_const(sv) && *t == '\\';)
 			    t--;
 			if ((svlast-1 - t) % 2) {
 			    if (!keep_quoted) {
@@ -9909,10 +9920,11 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 			cont = FALSE;
 		    }
 		    else {
-			char *t, *w;
+			const char *t;
+			char *w;
 			if (!last)
 			    last = SvPVX(sv);
-			for (w = t = last; t < svlast; w++, t++) {
+			for (t = w = last; t < svlast; w++, t++) {
 			    /* At here, all closes are "was quoted" one,
 			       so we don't check PL_multi_close. */
 			    if (*t == '\\') {
@@ -9929,7 +9941,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 			if (w < t) {
 			    *w++ = term;
 			    *w = '\0';
-			    SvCUR_set(sv, w - SvPVX(sv));
+			    SvCUR_set(sv, w - SvPVX_const(sv));
 			}
 			last = w;
 			if (--brackets <= 0)
@@ -10007,7 +10019,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	}
 	/* terminate the copied string and update the sv's end-of-string */
 	*to = '\0';
-	SvCUR_set(sv, to - SvPVX(sv));
+	SvCUR_set(sv, to - SvPVX_const(sv));
 
 	/*
 	 * this next chunk reads more into the buffer if we're not done yet
@@ -10017,18 +10029,18 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	    break;		/* handle case where we are done yet :-) */
 
 #ifndef PERL_STRICT_CR
-	if (to - SvPVX(sv) >= 2) {
+	if (to - SvPVX_const(sv) >= 2) {
 	    if ((to[-2] == '\r' && to[-1] == '\n') ||
 		(to[-2] == '\n' && to[-1] == '\r'))
 	    {
 		to[-2] = '\n';
 		to--;
-		SvCUR_set(sv, to - SvPVX(sv));
+		SvCUR_set(sv, to - SvPVX_const(sv));
 	    }
 	    else if (to[-1] == '\r')
 		to[-1] = '\n';
 	}
-	else if (to - SvPVX(sv) == 1 && to[-1] == '\r')
+	else if (to - SvPVX_const(sv) == 1 && to[-1] == '\r')
 	    to[-1] = '\n';
 #endif
 	
@@ -10052,7 +10064,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setsv(sv,PL_linestr);
             (void)SvIOK_on(sv);
-            SvIVX(sv) = 0;
+            SvIV_set(sv, 0);
 	    av_store(CopFILEAV(PL_curcop), (I32)CopLINE(PL_curcop), sv);
 	}
 
@@ -10076,7 +10088,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
     /* if we allocated too much space, give some back */
     if (SvCUR(sv) + 5 < SvLEN(sv)) {
 	SvLEN_set(sv, SvCUR(sv) + 1);
-	Renew(SvPVX(sv), SvLEN(sv), char);
+	SvPV_renew(sv, SvLEN(sv));
     }
 
     /* decide whether this is the first or second quoted string we've read
@@ -10113,16 +10125,16 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 */
 
 char *
-Perl_scan_num(pTHX_ char *start, YYSTYPE* lvalp)
+Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp)
 {
-    register char *s = start;		/* current position in buffer */
+    register const char *s = start;	/* current position in buffer */
     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 */
     bool floatit;			/* boolean: int or float? */
-    char *lastub = 0;			/* position of last underbar */
-    static char number_too_long[] = "Number too long";
+    const char *lastub = 0;		/* position of last underbar */
+    static char const number_too_long[] = "Number too long";
 
     /* We use the first character to decide what type of number this is */
 
@@ -10149,17 +10161,18 @@ Perl_scan_num(pTHX_ char *start, YYSTYPE* lvalp)
 	    I32 shift;
 	    bool overflowed = FALSE;
 	    bool just_zero  = TRUE;	/* just plain 0 or binary number? */
-	    static NV nvshift[5] = { 1.0, 2.0, 4.0, 8.0, 16.0 };
-	    static char* bases[5] = { "", "binary", "", "octal",
-				      "hexadecimal" };
-	    static char* Bases[5] = { "", "Binary", "", "Octal",
-				      "Hexadecimal" };
-	    static char *maxima[5] = { "",
-				       "0b11111111111111111111111111111111",
-				       "",
-				       "037777777777",
-				       "0xffffffff" };
-	    char *base, *Base, *max;
+	    static const NV nvshift[5] = { 1.0, 2.0, 4.0, 8.0, 16.0 };
+	    static const char* const bases[5] =
+	      { "", "binary", "", "octal", "hexadecimal" };
+	    static const char* const Bases[5] =
+	      { "", "Binary", "", "Octal", "Hexadecimal" };
+	    static const char* const maxima[5] =
+	      { "",
+		"0b11111111111111111111111111111111",
+		"",
+		"037777777777",
+		"0xffffffff" };
+	    const char *base, *Base, *max;
 
 	    /* check for hex */
 	    if (s[1] == 'x') {
@@ -10301,7 +10314,7 @@ Perl_scan_num(pTHX_ char *start, YYSTYPE* lvalp)
 		sv_setuv(sv, u);
 	    }
 	    if (just_zero && (PL_hints & HINT_NEW_INTEGER))
-		sv = new_constant(start, s - start, "integer", 
+		sv = new_constant(start, s - start, "integer",
 				  sv, Nullsv, NULL);
 	    else if (PL_hints & HINT_NEW_BINARY)
 		sv = new_constant(start, s - start, "binary", sv, Nullsv, NULL);
@@ -10489,7 +10502,7 @@ vstring:
     else
 	lvalp->opval = Nullop;
 
-    return s;
+    return (char *)s;
 }
 
 STATIC char *
@@ -10515,7 +10528,7 @@ S_scan_formline(pTHX_ register char *s)
             }
 	}
 	if (PL_in_eval && !PL_rsfp) {
-	    eol = memchr(s,'\n',PL_bufend-s);
+	    eol = (char *) memchr(s,'\n',PL_bufend-s);
 	    if (!eol++)
 		eol = PL_bufend;
 	}
@@ -10537,14 +10550,14 @@ S_scan_formline(pTHX_ register char *s)
 		    char *end = SvPVX(stuff) + SvCUR(stuff);
 		    end[-2] = '\n';
 		    end[-1] = '\0';
-		    SvCUR(stuff)--;
+		    SvCUR_set(stuff, SvCUR(stuff) - 1);
 		}
 #endif
 	    }
 	    else
 	      break;
 	}
-	s = eol;
+	s = (char*)eol;
 	if (PL_rsfp) {
 	    s = filter_gets(PL_linestr, PL_rsfp, 0);
 	    PL_oldoldbufptr = PL_oldbufptr = PL_bufptr = PL_linestart = SvPVX(PL_linestr);
@@ -10568,7 +10581,7 @@ S_scan_formline(pTHX_ register char *s)
 	else
 	    PL_lex_state = LEX_FORMLINE;
 	if (!IN_BYTES) {
-	    if (UTF && is_utf8_string((U8*)SvPVX(stuff), SvCUR(stuff)))
+	    if (UTF && is_utf8_string((U8*)SvPVX_const(stuff), SvCUR(stuff)))
 		SvUTF8_on(stuff);
 	    else if (PL_encoding)
 		sv_recode_to_utf8(stuff, PL_encoding);
@@ -10599,7 +10612,7 @@ S_set_csh(pTHX)
 I32
 Perl_start_subparse(pTHX_ I32 is_format, U32 flags)
 {
-    I32 oldsavestack_ix = PL_savestack_ix;
+    const I32 oldsavestack_ix = PL_savestack_ix;
     CV* outsidecv = PL_compcv;
 
     if (PL_compcv) {
@@ -10625,7 +10638,7 @@ Perl_start_subparse(pTHX_ I32 is_format, U32 flags)
 #pragma segment Perl_yylex
 #endif
 int
-Perl_yywarn(pTHX_ char *s)
+Perl_yywarn(pTHX_ const char *s)
 {
     PL_in_eval |= EVAL_WARNONLY;
     yyerror(s);
@@ -10634,17 +10647,18 @@ Perl_yywarn(pTHX_ char *s)
 }
 
 int
-Perl_yyerror(pTHX_ char *s)
+Perl_yyerror(pTHX_ const char *s)
 {
-    char *where = NULL;
-    char *context = NULL;
+    const char *where = NULL;
+    const char *context = NULL;
     int contlen = -1;
     SV *msg;
 
     if (!yychar || (yychar == ';' && !PL_rsfp))
 	where = "at EOF";
-    else if (PL_bufptr > PL_oldoldbufptr && PL_bufptr - PL_oldoldbufptr < 200 &&
-      PL_oldoldbufptr != PL_oldbufptr && PL_oldbufptr != PL_bufptr) {
+    else if (PL_oldoldbufptr && PL_bufptr > PL_oldoldbufptr &&
+      PL_bufptr - PL_oldoldbufptr < 200 && PL_oldoldbufptr != PL_oldbufptr &&
+      PL_oldbufptr != PL_bufptr) {
 	/*
 		Only for NetWare:
 		The code below is removed for NetWare because it abends/crashes on NetWare
@@ -10659,8 +10673,8 @@ Perl_yyerror(pTHX_ char *s)
 	context = PL_oldoldbufptr;
 	contlen = PL_bufptr - PL_oldoldbufptr;
     }
-    else if (PL_bufptr > PL_oldbufptr && PL_bufptr - PL_oldbufptr < 200 &&
-      PL_oldbufptr != PL_bufptr) {
+    else if (PL_oldbufptr && PL_bufptr > PL_oldbufptr &&
+      PL_bufptr - PL_oldbufptr < 200 && PL_oldbufptr != PL_bufptr) {
 	/*
 		Only for NetWare:
 		The code below is removed for NetWare because it abends/crashes on NetWare
@@ -10694,7 +10708,7 @@ Perl_yyerror(pTHX_ char *s)
 	    Perl_sv_catpvf(aTHX_ where_sv, "%c", yychar);
 	else
 	    Perl_sv_catpvf(aTHX_ where_sv, "\\%03o", yychar & 255);
-	where = SvPVX(where_sv);
+	where = SvPVX_const(where_sv);
     }
     msg = sv_2mortal(newSVpv(s, 0));
     Perl_sv_catpvf(aTHX_ msg, " at %s line %"IVdf", ",
@@ -10732,8 +10746,7 @@ Perl_yyerror(pTHX_ char *s)
 STATIC char*
 S_swallow_bom(pTHX_ U8 *s)
 {
-    STRLEN slen;
-    slen = SvCUR(PL_linestr);
+    const STRLEN slen = SvCUR(PL_linestr);
     switch (s[0]) {
     case 0xFF:
 	if (s[1] == 0xFE) {
@@ -10845,8 +10858,8 @@ restore_rsfp(pTHX_ void *f)
 static I32
 utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 {
-    STRLEN old = SvCUR(sv);
-    I32 count = FILTER_READ(idx+1, sv, maxlen);
+    const STRLEN old = SvCUR(sv);
+    const I32 count = FILTER_READ(idx+1, sv, maxlen);
     DEBUG_P(PerlIO_printf(Perl_debug_log,
 			  "utf16_textfilter(%p): %d %d (%d)\n",
 			  utf16_textfilter, idx, maxlen, (int) count));
@@ -10854,8 +10867,8 @@ utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 	U8* tmps;
 	I32 newlen;
 	New(898, tmps, SvCUR(sv) * 3 / 2 + 1, U8);
-	Copy(SvPVX(sv), tmps, old, char);
-	utf16_to_utf8((U8*)SvPVX(sv) + old, tmps + old,
+	Copy(SvPVX_const(sv), tmps, old, char);
+	utf16_to_utf8((U8*)SvPVX_const(sv) + old, tmps + old,
 		      SvCUR(sv) - old, &newlen);
 	sv_usepvn(sv, (char*)tmps, (STRLEN)newlen + old);
     }
@@ -10866,8 +10879,8 @@ utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 static I32
 utf16rev_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 {
-    STRLEN old = SvCUR(sv);
-    I32 count = FILTER_READ(idx+1, sv, maxlen);
+    const STRLEN old = SvCUR(sv);
+    const I32 count = FILTER_READ(idx+1, sv, maxlen);
     DEBUG_P(PerlIO_printf(Perl_debug_log,
 			  "utf16rev_textfilter(%p): %d %d (%d)\n",
 			  utf16rev_textfilter, idx, maxlen, (int) count));
@@ -10875,8 +10888,8 @@ utf16rev_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 	U8* tmps;
 	I32 newlen;
 	New(898, tmps, SvCUR(sv) * 3 / 2 + 1, U8);
-	Copy(SvPVX(sv), tmps, old, char);
-	utf16_to_utf8((U8*)SvPVX(sv) + old, tmps + old,
+	Copy(SvPVX_const(sv), tmps, old, char);
+	utf16_to_utf8((U8*)SvPVX_const(sv) + old, tmps + old,
 		      SvCUR(sv) - old, &newlen);
 	sv_usepvn(sv, (char*)tmps, (STRLEN)newlen + old);
     }
@@ -10900,22 +10913,22 @@ passed in, for performance reasons.
 */
 
 char *
-Perl_scan_vstring(pTHX_ char *s, SV *sv)
+Perl_scan_vstring(pTHX_ const char *s, SV *sv)
 {
-    char *pos = s;
-    char *start = s;
+    const char *pos = s;
+    const char *start = s;
     if (*pos == 'v') pos++;  /* get past 'v' */
     while (pos < PL_bufend && (isDIGIT(*pos) || *pos == '_'))
 	pos++;
     if ( *pos != '.') {
 	/* this may not be a v-string if followed by => */
-	char *next = pos;
+	const char *next = pos;
 	while (next < PL_bufend && isSPACE(*next))
 	    ++next;
 	if ((PL_bufend - next) >= 2 && *next == '=' && next[1] == '>' ) {
 	    /* return string not v-string */
 	    sv_setpvn(sv,(char *)s,pos-s);
-	    return pos;
+	    return (char *)pos;
 	}
     }
 
@@ -10932,7 +10945,7 @@ Perl_scan_vstring(pTHX_ char *s, SV *sv)
 	    rev = 0;
 	    {
 		/* this is atoi() that tolerates underscores */
-		char *end = pos;
+		const char *end = pos;
 		UV mult = 1;
 		while (--end >= s) {
 		    UV orev;
@@ -10968,6 +10981,15 @@ Perl_scan_vstring(pTHX_ char *s, SV *sv)
 	sv_magic(sv,NULL,PERL_MAGIC_vstring,(const char*)start, pos-start);
 	SvRMAGICAL_on(sv);
     }
-    return s;
+    return (char *)s;
 }
 
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */