X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/fa83b5b6263413f922909c255e021c32c808b32d..ff2faa2b5a0809a5124aa90fc1d07503e49a73fb:/toke.c

diff --git a/toke.c b/toke.c
index 24805a7..de31a41 100644
--- a/toke.c
+++ b/toke.c
@@ -1,6 +1,6 @@
 /*    toke.c
  *
- *    Copyright (c) 1991-1994, Larry Wall
+ *    Copyright (c) 1991-1997, Larry Wall
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -22,13 +22,15 @@ static SV *q _((SV *sv));
 static char *scan_const _((char *start));
 static char *scan_formline _((char *s));
 static char *scan_heredoc _((char *s));
-static char *scan_ident _((char *s, char *send, char *dest, I32 ck_uni));
+static char *scan_ident _((char *s, char *send, char *dest, STRLEN destlen,
+			   I32 ck_uni));
 static char *scan_inputsymbol _((char *start));
 static char *scan_pat _((char *start));
 static char *scan_str _((char *start));
 static char *scan_subst _((char *start));
 static char *scan_trans _((char *start));
-static char *scan_word _((char *s, char *dest, int allow_package, STRLEN *slp));
+static char *scan_word _((char *s, char *dest, STRLEN destlen,
+			  int allow_package, STRLEN *slp));
 static char *skipspace _((char *s));
 static void checkcomma _((char *s, char *name, char *what));
 static void force_ident _((char *s, int kind));
@@ -48,6 +50,8 @@ static int uni _((I32 f, char *s));
 static char * filter_gets _((SV *sv, PerlIO *fp, STRLEN append));
 static void restore_rsfp _((void *f));
 
+static char ident_too_long[] = "Identifier too long";
+
 static char *linestart;		/* beg. of most recently read line */
 
 static char pending_ident;	/* pending identifier lookup */
@@ -62,6 +66,8 @@ static struct {
  * can get by with a single comparison (if the compiler is smart enough).
  */
 
+/* #define LEX_NOTPARSING		11 is done in perl.h. */
+
 #define LEX_NORMAL		10
 #define LEX_INTERPNORMAL	 9
 #define LEX_INTERPCASEMOD	 8
@@ -138,8 +144,7 @@ static struct {
 #define OLDLOP(f) return(yylval.ival=f,expect = XTERM,bufptr = s,(int)LSTOP)
 
 static int
-ao(toketype)
-int toketype;
+ao(int toketype)
 {
     if (*bufptr == '=') {
 	bufptr++;
@@ -153,16 +158,13 @@ int toketype;
 }
 
 static void
-no_op(what, s)
-char *what;
-char *s;
+no_op(char *what, char *s)
 {
-    char tmpbuf[128];
     char *oldbp = bufptr;
     bool is_first = (oldbufptr == linestart);
+
     bufptr = s;
-    sprintf(tmpbuf, "%s found where operator expected", what);
-    yywarn(tmpbuf);
+    yywarn(form("%s found where operator expected", what));
     if (is_first)
 	warn("\t(Missing semicolon on previous line?)\n");
     else if (oldoldbufptr && isIDFIRST(*oldoldbufptr)) {
@@ -179,8 +181,7 @@ char *s;
 }
 
 static void
-missingterm(s)
-char *s;
+missingterm(char *s)
 {
     char tmpbuf[3];
     char q;
@@ -206,23 +207,22 @@ char *s;
 }
 
 void
-deprecate(s)
-char *s;
+deprecate(char *s)
 {
     if (dowarn)
 	warn("Use of %s is deprecated", s);
 }
 
 static void
-depcom()
+depcom(void)
 {
     deprecate("comma-less variable list");
 }
 
 void
-lex_start(line)
-SV *line;
+lex_start(SV *line)
 {
+    dTHR;
     char *s;
     STRLEN len;
 
@@ -284,14 +284,13 @@ SV *line;
 }
 
 void
-lex_end()
+lex_end(void)
 {
     doextract = FALSE;
 }
 
 static void
-restore_rsfp(f)
-void *f;
+restore_rsfp(void *f)
 {
     PerlIO *fp = (PerlIO*)f;
 
@@ -303,9 +302,9 @@ void *f;
 }
 
 static void
-incline(s)
-char *s;
+incline(char *s)
 {
+    dTHR;
     char *t;
     char *n;
     char ch;
@@ -344,9 +343,9 @@ char *s;
 }
 
 static char *
-skipspace(s)
-register char *s;
+skipspace(register char *s)
 {
+    dTHR;
     if (lex_formbrack && lex_brackets <= lex_formbrack) {
 	while (s < bufend && (*s == ' ' || *s == '\t'))
 	    s++;
@@ -366,7 +365,9 @@ register char *s;
 	    return s;
 	if ((s = filter_gets(linestr, rsfp, (prevlen = SvCUR(linestr)))) == Nullch) {
 	    if (minus_n || minus_p) {
-		sv_setpv(linestr,minus_p ? ";}continue{print" : "");
+		sv_setpv(linestr,minus_p ?
+			 ";}continue{print or die qq(-p destination: $!\\n)" :
+			 "");
 		sv_catpv(linestr,";}");
 		minus_n = minus_p = 0;
 	    }
@@ -380,6 +381,8 @@ register char *s;
 		PerlIO_clearerr(rsfp);
 	    else
 		(void)PerlIO_close(rsfp);
+	    if (e_fp == rsfp)
+		e_fp = Nullfp;
 	    rsfp = Nullfp;
 	    return s;
 	}
@@ -387,7 +390,7 @@ register char *s;
 	bufend = s + SvCUR(linestr);
 	s = bufptr;
 	incline(s);
-	if (perldb && curstash != debstash) {
+	if (PERLDB_LINE && curstash != debstash) {
 	    SV *sv = NEWSV(85,0);
 
 	    sv_upgrade(sv, SVt_PVMG);
@@ -398,7 +401,7 @@ register char *s;
 }
 
 static void
-check_uni() {
+check_uni(void) {
     char *s;
     char ch;
     char *t;
@@ -422,9 +425,7 @@ check_uni() {
 #define UNI(f) return uni(f,s)
 
 static int
-uni(f,s)
-I32 f;
-char *s;
+uni(I32 f, char *s)
 {
     yylval.ival = f;
     expect = XTERM;
@@ -445,11 +446,17 @@ char *s;
 #define LOP(f,x) return lop(f,x,s)
 
 static I32
-lop(f,x,s)
+lop
+#ifdef CAN_PROTOTYPE
+   (I32 f, expectation x, char *s)
+#else
+   (f,x,s)
 I32 f;
 expectation x;
 char *s;
+#endif /* CAN_PROTOTYPE */
 {
+    dTHR;
     yylval.ival = f;
     CLINE;
     expect = x;
@@ -468,8 +475,7 @@ char *s;
 }
 
 static void 
-force_next(type)
-I32 type;
+force_next(I32 type)
 {
     nexttype[nexttoke] = type;
     nexttoke++;
@@ -481,12 +487,7 @@ I32 type;
 }
 
 static char *
-force_word(start,token,check_keyword,allow_pack,allow_tick)
-register char *start;
-int token;
-int check_keyword;
-int allow_pack;
-int allow_tick;
+force_word(register char *start, int token, int check_keyword, int allow_pack, int allow_tick)
 {
     register char *s;
     STRLEN len;
@@ -497,7 +498,7 @@ int allow_tick;
 	(allow_pack && *s == ':') ||
 	(allow_tick && *s == '\'') )
     {
-	s = scan_word(s, tokenbuf, allow_pack, &len);
+	s = scan_word(s, tokenbuf, sizeof tokenbuf, allow_pack, &len);
 	if (check_keyword && keyword(tokenbuf, len))
 	    return start;
 	if (token == METHOD) {
@@ -518,16 +519,15 @@ int allow_tick;
 }
 
 static void
-force_ident(s, kind)
-register char *s;
-int kind;
+force_ident(register char *s, int kind)
 {
     if (s && *s) {
-	OP* op = (OP*)newSVOP(OP_CONST, 0, newSVpv(s,0));
-	nextval[nexttoke].opval = op;
+	OP* o = (OP*)newSVOP(OP_CONST, 0, newSVpv(s,0));
+	nextval[nexttoke].opval = o;
 	force_next(WORD);
 	if (kind) {
-	    op->op_private = OPpCONST_ENTERED;
+	    dTHR;		/* just for in_eval */
+	    o->op_private = OPpCONST_ENTERED;
 	    /* XXX see note in pp_entereval() for why we forgo typo
 	       warnings if the symbol must be introduced in an eval.
 	       GSAR 96-10-12 */
@@ -542,8 +542,7 @@ int kind;
 }
 
 static char *
-force_version(s)
-char *s;
+force_version(char *s)
 {
     OP *version = Nullop;
 
@@ -570,8 +569,7 @@ char *s;
 }
 
 static SV *
-q(sv)
-SV *sv;
+q(SV *sv)
 {
     register char *s;
     register char *send;
@@ -604,7 +602,7 @@ SV *sv;
 }
 
 static I32
-sublex_start()
+sublex_start(void)
 {
     register I32 op_type = yylval.ival;
 
@@ -614,7 +612,11 @@ sublex_start()
 	return THING;
     }
     if (op_type == OP_CONST || op_type == OP_READLINE) {
-	yylval.opval = (OP*)newSVOP(op_type, 0, q(lex_stuff));
+	SV *sv = q(lex_stuff);
+	STRLEN len;
+	char *p = SvPV(sv, len);
+	yylval.opval = (OP*)newSVOP(op_type, 0, newSVpv(p, len));
+	SvREFCNT_dec(sv);
 	lex_stuff = Nullsv;
 	return THING;
     }
@@ -635,8 +637,9 @@ sublex_start()
 }
 
 static I32
-sublex_push()
+sublex_push(void)
 {
+    dTHR;
     push_scope();
 
     lex_state = sublex_info.super_state;
@@ -687,7 +690,7 @@ sublex_push()
 }
 
 static I32
-sublex_done()
+sublex_done(void)
 {
     if (!lex_starts++) {
 	expect = XOPERATOR;
@@ -732,8 +735,7 @@ sublex_done()
 }
 
 static char *
-scan_const(start)
-char *start;
+scan_const(char *start)
 {
     register char *send = bufend;
     SV *sv = NEWSV(93, send - start);
@@ -741,7 +743,7 @@ char *start;
     register char *d = SvPVX(sv);
     bool dorange = FALSE;
     I32 len;
-    char *leave =
+    char *leaveit =
 	lex_inpat
 	    ? "\\.^$@AGZdDwWsSbB+*?|()-nrtfeaxc0123456789[{]} \t\n\r\f\v#"
 	    : (lex_inwhat & OP_TRANS)
@@ -782,12 +784,12 @@ char *start;
 	else if (*s == '$') {
 	    if (!lex_inpat)	/* not a regexp, so $ must be var */
 		break;
-	    if (s + 1 < send && !strchr(")| \n\t", s[1]))
+	    if (s + 1 < send && !strchr("()| \n\t", s[1]))
 		break;		/* in regexp, $ might be tail anchor */
 	}
 	if (*s == '\\' && s+1 < send) {
 	    s++;
-	    if (*s && strchr(leave, *s)) {
+	    if (*s && strchr(leaveit, *s)) {
 		*d++ = '\\';
 		*d++ = *s++;
 		continue;
@@ -872,8 +874,7 @@ char *start;
 
 /* This is the one truly awful dwimmer necessary to conflate C and sed. */
 static int
-intuit_more(s)
-register char *s;
+intuit_more(register char *s)
 {
     if (lex_brackets)
 	return TRUE;
@@ -911,7 +912,7 @@ register char *s;
 	char seen[256];
 	unsigned char un_char = 0, last_un_char;
 	char *send = strchr(s,']');
-	char tmpbuf[512];
+	char tmpbuf[sizeof tokenbuf * 4];
 
 	if (!send)		/* has to be an expression */
 	    return TRUE;
@@ -936,7 +937,7 @@ register char *s;
 	    case '$':
 		weight -= seen[un_char] * 10;
 		if (isALNUM(s[1])) {
-		    scan_ident(s,send,tmpbuf,FALSE);
+		    scan_ident(s, send, tmpbuf, sizeof tmpbuf, FALSE);
 		    if ((int)strlen(tmpbuf) > 1 && gv_fetchpv(tmpbuf,FALSE, SVt_PV))
 			weight -= 100;
 		    else
@@ -1001,12 +1002,10 @@ register char *s;
 }
 
 static int
-intuit_method(start,gv)
-char *start;
-GV *gv;
+intuit_method(char *start, GV *gv)
 {
     char *s = start + (*start == '$');
-    char tmpbuf[1024];
+    char tmpbuf[sizeof tokenbuf];
     STRLEN len;
     GV* indirgv;
 
@@ -1016,7 +1015,7 @@ GV *gv;
 	if (!GvCVu(gv))
 	    gv = 0;
     }
-    s = scan_word(s, tmpbuf, TRUE, &len);
+    s = scan_word(s, tmpbuf, sizeof tmpbuf, TRUE, &len);
     if (*start == '$') {
 	if (gv || last_lop_op == OP_PRINT || isUPPER(*tokenbuf))
 	    return 0;
@@ -1049,7 +1048,7 @@ GV *gv;
 }
 
 static char*
-incl_perldb()
+incl_perldb(void)
 {
     if (perldb) {
 	char *pdb = getenv("PERL5DB");
@@ -1080,9 +1079,7 @@ incl_perldb()
 static int filter_debug = 0;
 
 SV *
-filter_add(funcp, datasv)
-    filter_t funcp;
-    SV *datasv;
+filter_add(filter_t funcp, SV *datasv)
 {
     if (!funcp){ /* temporary handy debugging hack to be deleted */
 	filter_debug = atoi((char*)datasv);
@@ -1096,7 +1093,7 @@ filter_add(funcp, datasv)
         die("Can't upgrade filter_add data to SVt_PVIO");
     IoDIRP(datasv) = (DIR*)funcp; /* stash funcp into spare field */
     if (filter_debug)
-	warn("filter_add func %lx (%s)", funcp, SvPV(datasv,na));
+	warn("filter_add func %p (%s)", funcp, SvPV(datasv,na));
     av_unshift(rsfp_filters, 1);
     av_store(rsfp_filters, 0, datasv) ;
     return(datasv);
@@ -1105,17 +1102,15 @@ filter_add(funcp, datasv)
 
 /* Delete most recently added instance of this filter function.	*/
 void
-filter_del(funcp)
-    filter_t funcp;
+filter_del(filter_t funcp)
 {
     if (filter_debug)
-	warn("filter_del func %lx", funcp);
+	warn("filter_del func %p", funcp);
     if (!rsfp_filters || AvFILL(rsfp_filters)<0)
 	return;
     /* if filter is on top of stack (usual case) just pop it off */
-    if (IoDIRP(FILTER_DATA(0)) == (void*)funcp){
-	/* sv_free(av_pop(rsfp_filters)); */
-	sv_free(av_shift(rsfp_filters));
+    if (IoDIRP(FILTER_DATA(AvFILL(rsfp_filters))) == (void*)funcp){
+	sv_free(av_pop(rsfp_filters));
 
         return;
     }
@@ -1126,10 +1121,10 @@ filter_del(funcp)
 
 /* Invoke the n'th filter function for the current rsfp.	 */
 I32
-filter_read(idx, buf_sv, maxlen)
-    int idx;
-    SV *buf_sv;
-    int maxlen;		/* 0 = read one text line */
+filter_read(int idx, SV *buf_sv, int maxlen)
+            
+               
+               		/* 0 = read one text line */
 {
     filter_t funcp;
     SV *datasv = NULL;
@@ -1175,7 +1170,7 @@ filter_read(idx, buf_sv, maxlen)
     /* Get function pointer hidden within datasv	*/
     funcp = (filter_t)IoDIRP(datasv);
     if (filter_debug)
-	warn("filter_read %d: via function %lx (%s)\n",
+	warn("filter_read %d: via function %p (%s)\n",
 		idx, funcp, SvPV(datasv,na));
     /* Call function. The function is expected to 	*/
     /* call "FILTER_READ(idx+1, buf_sv)" first.		*/
@@ -1184,10 +1179,7 @@ filter_read(idx, buf_sv, maxlen)
 }
 
 static char *
-filter_gets(sv,fp, append)
-register SV *sv;
-register PerlIO *fp;
-STRLEN append;
+filter_gets(register SV *sv, register FILE *fp, STRLEN append)
 {
     if (rsfp_filters) {
 
@@ -1212,8 +1204,9 @@ STRLEN append;
 EXT int yychar;		/* last token */
 
 int
-yylex()
+yylex(void)
 {
+    dTHR;
     register char *s;
     register char *d;
     register I32 tmp;
@@ -1231,36 +1224,47 @@ yylex()
 	    return PRIVATEREF;
 	}
 
-	if (!strchr(tokenbuf,':') && (tmp = pad_findmy(tokenbuf))) {
-	    if (last_lop_op == OP_SORT &&
-		tokenbuf[0] == '$' &&
-		(tokenbuf[1] == 'a' || tokenbuf[1] == 'b')
-		&& !tokenbuf[2])
+	if (!strchr(tokenbuf,':')) {
+#ifdef USE_THREADS
+	    /* Check for single character per-thread magicals */
+	    if (tokenbuf[0] == '$' && tokenbuf[2] == '\0'
+		&& !isALPHA(tokenbuf[1]) /* Rule out obvious non-magicals */
+		&& (tmp = find_thread_magical(&tokenbuf[1])) != NOT_IN_PAD)
 	    {
-		for (d = in_eval ? oldoldbufptr : linestart;
-		     d < bufend && *d != '\n';
-		     d++)
+		yylval.opval = newOP(OP_THREADSV, 0);
+		yylval.opval->op_targ = tmp;
+		return PRIVATEREF;
+	    }
+#endif /* USE_THREADS */
+	    if ((tmp = pad_findmy(tokenbuf)) != NOT_IN_PAD) {
+		if (last_lop_op == OP_SORT &&
+		    tokenbuf[0] == '$' &&
+		    (tokenbuf[1] == 'a' || tokenbuf[1] == 'b')
+		    && !tokenbuf[2])
 		{
-		    if (strnEQ(d,"<=>",3) || strnEQ(d,"cmp",3)) {
-			croak("Can't use \"my %s\" in sort comparison",
-			      tokenbuf);
+		    for (d = in_eval ? oldoldbufptr : linestart;
+			 d < bufend && *d != '\n';
+			 d++)
+		    {
+			if (strnEQ(d,"<=>",3) || strnEQ(d,"cmp",3)) {
+			    croak("Can't use \"my %s\" in sort comparison",
+				  tokenbuf);
+			}
 		    }
 		}
-	    }
 
-	    yylval.opval = newOP(OP_PADANY, 0);
-	    yylval.opval->op_targ = tmp;
-	    return PRIVATEREF;
+		yylval.opval = newOP(OP_PADANY, 0);
+		yylval.opval->op_targ = tmp;
+		return PRIVATEREF;
+	    }
 	}
 
 	/* Force them to make up their mind on "@foo". */
 	if (pit == '@' && lex_state != LEX_NORMAL && !lex_brackets) {
 	    GV *gv = gv_fetchpv(tokenbuf+1, FALSE, SVt_PVAV);
-	    if (!gv || ((tokenbuf[0] == '@') ? !GvAV(gv) : !GvHV(gv))) {
-		char tmpbuf[1024];
-		sprintf(tmpbuf, "Literal %s now requires backslash", tokenbuf);
-		yyerror(tmpbuf);
-	    }
+	    if (!gv || ((tokenbuf[0] == '@') ? !GvAV(gv) : !GvHV(gv)))
+		yyerror(form("In string, %s now must be written as \\%s",
+			     tokenbuf, tokenbuf));
 	}
 
 	yylval.opval = (OP*)newSVOP(OP_CONST, 0, newSVpv(tokenbuf+1, 0));
@@ -1367,7 +1371,13 @@ yylex()
 	if (lex_dojoin) {
 	    nextval[nexttoke].ival = 0;
 	    force_next(',');
+#ifdef USE_THREADS
+	    nextval[nexttoke].opval = newOP(OP_THREADSV, 0);
+	    nextval[nexttoke].opval->op_targ = find_thread_magical("\"");
+	    force_next(PRIVATEREF);
+#else
 	    force_ident("\"", '$');
+#endif /* USE_THREADS */
 	    nextval[nexttoke].ival = 0;
 	    force_next('$');
 	    nextval[nexttoke].ival = 0;
@@ -1379,9 +1389,7 @@ yylex()
 	    s = bufptr;
 	    Aop(OP_CONCAT);
 	}
-	else
-	    return yylex();
-	break;
+	return yylex();
 
     case LEX_INTERPENDMAYBE:
 	if (intuit_more(bufptr)) {
@@ -1451,8 +1459,7 @@ yylex()
   retry:
     switch (*s) {
     default:
-	warn("Unrecognized character \\%03o ignored", *s++ & 255);
-	goto retry;
+	croak("Unrecognized character \\%03o", *s & 255);
     case 4:
     case 26:
 	goto fake_eof;			/* emulate EOF on ^D or ^Z */
@@ -1487,16 +1494,28 @@ yylex()
 		sv_catpv(linestr, "LINE: while (<>) {");
 		if (minus_l)
 		    sv_catpv(linestr,"chomp;");
-		if (minus_a){
-		    if (minus_F){
-		      char tmpbuf1[50];
-		      if ( splitstr[0] == '/' || 
-		           splitstr[0] == '\'' || 
-		           splitstr[0] == '"' )
-			    sprintf( tmpbuf1, "@F=split(%s);", splitstr );
-		        else
-			    sprintf( tmpbuf1, "@F=split('%s');", splitstr );
-		        sv_catpv(linestr,tmpbuf1);
+		if (minus_a) {
+		    GV* gv = gv_fetchpv("::F", TRUE, SVt_PVAV);
+		    if (gv)
+			GvIMPORTED_AV_on(gv);
+		    if (minus_F) {
+			if (strchr("/'\"", *splitstr)
+			      && strchr(splitstr + 1, *splitstr))
+			    sv_catpvf(linestr, "@F=split(%s);", splitstr);
+			else {
+			    char delim;
+			    s = "'~#\200\1'"; /* surely one char is unused...*/
+			    while (s[1] && strchr(splitstr, *s))  s++;
+			    delim = *s;
+			    sv_catpvf(linestr, "@F=split(%s%c",
+				      "q" + (delim == '\''), delim);
+			    for (s = splitstr; *s; s++) {
+				if (*s == '\\')
+				    sv_catpvn(linestr, "\\", 1);
+				sv_catpvn(linestr, s, 1);
+			    }
+			    sv_catpvf(linestr, "%c);", delim);
+			}
 		    }
 		    else
 		        sv_catpv(linestr,"@F=split(' ');");
@@ -1505,7 +1524,7 @@ yylex()
 	    sv_catpv(linestr, "\n");
 	    oldoldbufptr = oldbufptr = s = linestart = SvPVX(linestr);
 	    bufend = SvPVX(linestr) + SvCUR(linestr);
-	    if (perldb && curstash != debstash) {
+	    if (PERLDB_LINE && curstash != debstash) {
 		SV *sv = NEWSV(85,0);
 
 		sv_upgrade(sv, SVt_PVMG);
@@ -1524,6 +1543,8 @@ yylex()
 			PerlIO_clearerr(rsfp);
 		    else
 			(void)PerlIO_close(rsfp);
+		    if (e_fp == rsfp)
+			e_fp = Nullfp;
 		    rsfp = Nullfp;
 		}
 		if (!in_eval && (minus_n || minus_p)) {
@@ -1553,7 +1574,7 @@ yylex()
 	    incline(s);
 	} while (doextract);
 	oldoldbufptr = oldbufptr = bufptr = linestart = s;
-	if (perldb && curstash != debstash) {
+	if (PERLDB_LINE && curstash != debstash) {
 	    SV *sv = NEWSV(85,0);
 
 	    sv_upgrade(sv, SVt_PVMG);
@@ -1579,35 +1600,33 @@ yylex()
 #endif /* ALTERNATE_SHEBANG */
 	    }
 	    if (d) {
-		/*
-		 * HP-UX (at least) sets argv[0] to the script name,
-		 * which makes $^X incorrect.  And Digital UNIX and Linux,
-		 * 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));
 		char *ipath;
-		char *ibase;
+		char *ipathend;
 
-		while (*d == ' ' || *d == '\t')
+		while (isSPACE(*d))
 		    d++;
 		ipath = d;
-		ibase = Nullch;
-		while (*d && !isSPACE(*d)) {
-		    if (*d++ == '/')
-			ibase = d;
+		while (*d && !isSPACE(*d))
+		    d++;
+		ipathend = d;
+
+#ifdef ARG_ZERO_IS_SCRIPT
+		if (ipathend > ipath) {
+		    /*
+		     * HP-UX (at least) sets argv[0] to the script name,
+		     * which makes $^X incorrect.  And Digital UNIX and Linux,
+		     * 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));
+		    assert(SvPOK(x) || SvGMAGICAL(x));
+		    if (sv_eq(x, GvSV(curcop->cop_filegv))) {
+			sv_setpvn(x, ipath, ipathend - ipath);
+			SvSETMAGIC(x);
+		    }
+		    TAINT_NOT;	/* $^X is always tainted, but that's OK */
 		}
-		assert(SvPOK(x) || SvGMAGICAL(x));
-		if (sv_eq(x, GvSV(curcop->cop_filegv))
-		    || (ibase
-			&& SvCUR(x) == (d - ibase)
-			&& strnEQ(SvPVX(x), ibase, d - ibase)))
-		    sv_setpvn(x, ipath, d - ipath);
-		/*
-		 * $^X is always tainted, but taintedness must be off
-		 * when parsing code, so forget we ever saw it.
-		 */
-		TAINT_NOT;
+#endif /* ARG_ZERO_IS_SCRIPT */
 
 		/*
 		 * Look for options.
@@ -1624,10 +1643,9 @@ yylex()
 		 * other interpreter.  Similarly, if "perl" is there, but
 		 * not in the first 'word' of the line, we assume the line
 		 * contains the start of the Perl program.
-		 * This isn't foolproof, but it's generally a good guess.
 		 */
 		if (d && *s != '#') {
-		    char *c = s;
+		    char *c = ipath;
 		    while (*c && !strchr("; \t\r\n\f\v#", *c))
 			c++;
 		    if (c < d)
@@ -1635,23 +1653,18 @@ yylex()
 		    else
 			*s = '#';	/* Don't try to parse shebang line */
 		}
-#endif
+#endif /* ALTERNATE_SHEBANG */
 		if (!d &&
 		    *s == '#' &&
+		    ipathend > ipath &&
 		    !minus_c &&
 		    !instr(s,"indir") &&
 		    instr(origargv[0],"perl"))
 		{
 		    char **newargv;
-		    char *cmd;
 
-		    s += 2;
-		    if (*s == ' ')
-			s++;
-		    cmd = s;
-		    while (s < bufend && !isSPACE(*s))
-			s++;
-		    *s++ = '\0';
+		    *ipathend = '\0';
+		    s = ipathend + 1;
 		    while (s < bufend && isSPACE(*s))
 			s++;
 		    if (s < bufend) {
@@ -1664,21 +1677,29 @@ yylex()
 		    }
 		    else
 			newargv = origargv;
-		    newargv[0] = cmd;
-		    execv(cmd,newargv);
-		    croak("Can't exec %s", cmd);
+		    newargv[0] = ipath;
+		    execv(ipath, newargv);
+		    croak("Can't exec %s", ipath);
 		}
 		if (d) {
-		    int oldpdb = perldb;
-		    int oldn = minus_n;
-		    int oldp = minus_p;
+		    U32 oldpdb = perldb;
+		    bool oldn = minus_n;
+		    bool oldp = minus_p;
 
 		    while (*d && !isSPACE(*d)) d++;
 		    while (*d == ' ' || *d == '\t') d++;
 
 		    if (*d++ == '-') {
-			while (d = moreswitches(d)) ;
-			if (perldb && !oldpdb ||
+			do {
+			    if (*d == 'M' || *d == 'm') {
+				char *m = d;
+				while (*d && !isSPACE(*d)) d++;
+				croak("Too late for \"-%.*s\" option",
+				      (int)(d - m), m);
+			    }
+			    d = moreswitches(d);
+			} while (d);
+			if (PERLDB_LINE && !oldpdb ||
 			    ( minus_n || minus_p ) && !(oldn || oldp) )
 			      /* if we have already added "LINE: while (<>) {",
 			         we must not do it again */
@@ -1687,7 +1708,7 @@ yylex()
 			    oldoldbufptr = oldbufptr = s = linestart = SvPVX(linestr);
 			    bufend = SvPVX(linestr) + SvCUR(linestr);
 			    preambled = FALSE;
-			    if (perldb)
+			    if (PERLDB_LINE)
 				(void)gv_fetchfile(origfilename);
 			    goto retry;
 			}
@@ -1701,7 +1722,11 @@ yylex()
 	    return yylex();
 	}
 	goto retry;
-    case ' ': case '\t': case '\f': case '\r': case 013:
+    case '\r':
+	warn("Illegal character \\%03o (carriage return)", '\r');
+	croak(
+      "(Maybe you didn't strip carriage returns after a network transfer?)\n");
+    case ' ': case '\t': case '\f': case 013:
 	s++;
 	goto retry;
     case '#':
@@ -1736,7 +1761,7 @@ yylex()
 	    if (strnEQ(s,"=>",2)) {
 		if (dowarn)
 		    warn("Ambiguous use of -%c => resolved to \"-%c\" =>",
-			tmp, tmp);
+			(int)tmp, (int)tmp);
 		s = force_word(bufptr,WORD,FALSE,FALSE,FALSE);
 		OPERATOR('-');		/* unary minus */
 	    }
@@ -1771,7 +1796,7 @@ yylex()
 	    case 'A': gv_fetchpv("\024",TRUE, SVt_PV); FTST(OP_FTATIME);
 	    case 'C': gv_fetchpv("\024",TRUE, SVt_PV); FTST(OP_FTCTIME);
 	    default:
-		croak("Unrecognized file test: -%c", tmp);
+		croak("Unrecognized file test: -%c", (int)tmp);
 		break;
 	    }
 	}
@@ -1822,7 +1847,7 @@ yylex()
 
     case '*':
 	if (expect != XOPERATOR) {
-	    s = scan_ident(s, bufend, tokenbuf, TRUE);
+	    s = scan_ident(s, bufend, tokenbuf, sizeof tokenbuf, TRUE);
 	    expect = XOPERATOR;
 	    force_ident(tokenbuf, '*');
 	    if (!*tokenbuf)
@@ -1842,7 +1867,7 @@ yylex()
 	    Mop(OP_MODULO);
 	}
 	tokenbuf[0] = '%';
-	s = scan_ident(s, bufend, tokenbuf+1, TRUE);
+	s = scan_ident(s, bufend, tokenbuf + 1, sizeof tokenbuf - 1, TRUE);
 	if (!tokenbuf[1]) {
 	    if (s == bufend)
 		yyerror("Final % should be \\% or %name");
@@ -1920,7 +1945,6 @@ yylex()
 	    else
 		lex_brackstack[lex_brackets++] = XOPERATOR;
 	    OPERATOR(HASHBRACK);
-	    break;
 	case XOPERATOR:
 	    while (s < bufend && (*s == ' ' || *s == '\t'))
 		s++;
@@ -1933,7 +1957,8 @@ yylex()
 		    d++;
 	    }
 	    if (d < bufend && isIDFIRST(*d)) {
-		d = scan_word(d, tokenbuf + 1, FALSE, &len);
+		d = scan_word(d, tokenbuf + 1, sizeof tokenbuf - 1,
+			      FALSE, &len);
 		while (d < bufend && (*d == ' ' || *d == '\t'))
 		    d++;
 		if (*d == '}') {
@@ -1967,19 +1992,73 @@ yylex()
 		s = skipspace(s);
 		if (*s == '}')
 		    OPERATOR(HASHBRACK);
-		if (isALPHA(*s)) {
-		    for (t = s; t < bufend && isALNUM(*t); t++) ;
+		/* This hack serves to disambiguate a pair of curlies
+		 * as being a block or an anon hash.  Normally, expectation
+		 * determines that, but in cases where we're not in a
+		 * position to expect anything in particular (like inside
+		 * 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
+		 * curly in order to force resolution as an anon hash.
+		 *
+		 * XXX should probably propagate the outer expectation
+		 * into eval"" to rely less on this hack, but that could
+		 * potentially break current behavior of eval"".
+		 * GSAR 97-07-21
+		 */
+		t = s;
+		if (*s == '\'' || *s == '"' || *s == '`') {
+		    /* common case: get past first string, handling escapes */
+		    for (t++; t < bufend && *t != *s;)
+			if (*t++ == '\\' && (*t == '\\' || *t == *s))
+			    t++;
+		    t++;
+		}
+		else if (*s == 'q') {
+		    if (++t < bufend
+			&& (!isALNUM(*t)
+			    || ((*t == 'q' || *t == 'x') && ++t < bufend
+				&& !isALNUM(*t)))) {
+			char *tmps;
+			char open, close, term;
+			I32 brackets = 1;
+
+			while (t < bufend && isSPACE(*t))
+			    t++;
+			term = *t;
+			open = term;
+			if (term && (tmps = strchr("([{< )]}> )]}>",term)))
+			    term = tmps[5];
+			close = term;
+			if (open == close)
+			    for (t++; t < bufend; t++) {
+				if (*t == '\\' && t+1 < bufend && open != '\\')
+				    t++;
+				else if (*t == open)
+				    break;
+			    }
+			else
+			    for (t++; t < bufend; t++) {
+				if (*t == '\\' && t+1 < bufend)
+				    t++;
+				else if (*t == close && --brackets <= 0)
+				    break;
+				else if (*t == open)
+				    brackets++;
+			    }
+		    }
+		    t++;
 		}
-		else if (*s == '\'' || *s == '"') {
-		    t = strchr(s+1,*s);
-		    if (!t++)
-			t = s;
+		else if (isALPHA(*s)) {
+		    for (t++; t < bufend && isALNUM(*t); t++) ;
 		}
-		else
-		    t = s;
 		while (t < bufend && isSPACE(*t))
 		    t++;
-		if ((*t == ',' && !isLOWER(*s)) || (*t == '=' && t[1] == '>'))
+		/* if comma follows first term, call it an anon hash */
+		/* XXX it could be a comma expression with loop modifiers */
+		if (t < bufend && ((*t == ',' && (*s == 'q' || !isLOWER(*s)))
+				   || (*t == '=' && t[1] == '>')))
 		    OPERATOR(HASHBRACK);
 		if (expect == XREF)
 		    expect = XTERM;
@@ -2038,7 +2117,7 @@ yylex()
 	    BAop(OP_BIT_AND);
 	}
 
-	s = scan_ident(s-1, bufend, tokenbuf, TRUE);
+	s = scan_ident(s - 1, bufend, tokenbuf, sizeof tokenbuf, TRUE);
 	if (*tokenbuf) {
 	    expect = XOPERATOR;
 	    force_ident(tokenbuf, '&');
@@ -2065,7 +2144,7 @@ yylex()
 	if (tmp == '~')
 	    PMop(OP_MATCH);
 	if (dowarn && tmp && isSPACE(*s) && strchr("+-*/%.^&|<",tmp))
-	    warn("Reversed %c= operator",tmp);
+	    warn("Reversed %c= operator",(int)tmp);
 	s--;
 	if (expect == XSTATE && isALPHA(tmp) &&
 		(s == linestart+1 || s[-2] == '\n') )
@@ -2160,7 +2239,8 @@ yylex()
 	    if (expect == XOPERATOR)
 		no_op("Array length", bufptr);
 	    tokenbuf[0] = '@';
-	    s = scan_ident(s+1, bufend, tokenbuf+1, FALSE);
+	    s = scan_ident(s + 1, bufend, tokenbuf + 1, sizeof tokenbuf - 1,
+			   FALSE);
 	    if (!tokenbuf[1])
 		PREREF(DOLSHARP);
 	    expect = XOPERATOR;
@@ -2171,7 +2251,7 @@ yylex()
 	if (expect == XOPERATOR)
 	    no_op("Scalar", bufptr);
 	tokenbuf[0] = '$';
-	s = scan_ident(s, bufend, tokenbuf+1, FALSE);
+	s = scan_ident(s, bufend, tokenbuf + 1, sizeof tokenbuf - 1, FALSE);
 	if (!tokenbuf[1]) {
 	    if (s == bufend)
 		yyerror("Final $ should be \\$ or $name");
@@ -2212,11 +2292,11 @@ yylex()
 		if (dowarn && strEQ(tokenbuf+1, "SIG") &&
 		    (t = strchr(s, '}')) && (t = strchr(t, '=')))
 		{
-		    char tmpbuf[1024];
+		    char tmpbuf[sizeof tokenbuf];
 		    STRLEN len;
 		    for (t++; isSPACE(*t); t++) ;
 		    if (isIDFIRST(*t)) {
-			t = scan_word(t, tmpbuf, TRUE, &len);
+			t = scan_word(t, tmpbuf, sizeof tmpbuf, TRUE, &len);
 			if (*t != '(' && perl_get_cv(tmpbuf, FALSE))
 			    warn("You need to quote \"%s\"", tmpbuf);
 		    }
@@ -2233,6 +2313,32 @@ yylex()
 		expect = XTERM;		/* e.g. print $fh "foo" */
 	    else if (strchr("&*<%", *s) && isIDFIRST(s[1]))
 		expect = XTERM;		/* e.g. print $fh &sub */
+	    else if (isIDFIRST(*s)) {
+		char tmpbuf[sizeof tokenbuf];
+		scan_word(s, tmpbuf, sizeof tmpbuf, TRUE, &len);
+		if (tmp = keyword(tmpbuf, len)) {
+		    /* binary operators exclude handle interpretations */
+		    switch (tmp) {
+		    case -KEY_x:
+		    case -KEY_eq:
+		    case -KEY_ne:
+		    case -KEY_gt:
+		    case -KEY_lt:
+		    case -KEY_ge:
+		    case -KEY_le:
+		    case -KEY_cmp:
+			break;
+		    default:
+			expect = XTERM;	/* e.g. print $fh length() */
+			break;
+		    }
+		}
+		else {
+		    GV *gv = gv_fetchpv(tmpbuf, FALSE, SVt_PVCV);
+		    if (gv && GvCVu(gv))
+			expect = XTERM;	/* e.g. print $fh subr() */
+		}
+	    }
 	    else if (isDIGIT(*s))
 		expect = XTERM;		/* e.g. print $fh 3 */
 	    else if (*s == '.' && isDIGIT(s[1]))
@@ -2249,7 +2355,7 @@ yylex()
 	if (expect == XOPERATOR)
 	    no_op("Array", s);
 	tokenbuf[0] = '@';
-	s = scan_ident(s, bufend, tokenbuf+1, FALSE);
+	s = scan_ident(s, bufend, tokenbuf + 1, sizeof tokenbuf - 1, FALSE);
 	if (!tokenbuf[1]) {
 	    if (s == bufend)
 		yyerror("Final @ should be \\@ or @name");
@@ -2282,7 +2388,11 @@ yylex()
     case '/':			/* may either be division or pattern */
     case '?':			/* may either be conditional or pattern */
 	if (expect != XOPERATOR) {
-	    check_uni();
+	    /* Disable warning on "study /blah/" */
+	    if (oldoldbufptr == last_uni 
+		&& (*last_uni != 's' || s - last_uni < 5 
+		    || memNE(last_uni, "study", 5) || isALNUM(last_uni[5])))
+		check_uni();
 	    s = scan_pat(s);
 	    TERM(sublex_start());
 	}
@@ -2413,9 +2523,12 @@ yylex()
     case 'y': case 'Y':
     case 'z': case 'Z':
 
-      keylookup:
+      keylookup: {
+	GV *gv = Nullgv;
+	GV **gvp = 0;
+
 	bufptr = s;
-	s = scan_word(s, tokenbuf, FALSE, &len);
+	s = scan_word(s, tokenbuf, sizeof tokenbuf, FALSE, &len);
 
 	/* Some keywords can be followed by any delimiter, including ':' */
 	tmp = (len == 1 && strchr("msyq", tokenbuf[0]) ||
@@ -2455,16 +2568,24 @@ yylex()
 	}
 
 	if (tmp < 0) {			/* second-class keyword? */
-	    GV* gv;
-	    if (expect != XOPERATOR &&
-		(*s != ':' || s[1] != ':') &&
-		(gv = gv_fetchpv(tokenbuf, FALSE, SVt_PVCV)) &&
-		GvIMPORTED_CV(gv))
+	    if (expect != XOPERATOR && (*s != ':' || s[1] != ':') &&
+		(((gv = gv_fetchpv(tokenbuf, FALSE, SVt_PVCV)) &&
+		  GvCVu(gv) && GvIMPORTED_CV(gv)) ||
+		 ((gvp = (GV**)hv_fetch(globalstash,tokenbuf,len,FALSE)) &&
+		  (gv = *gvp) != (GV*)&sv_undef &&
+		  GvCVu(gv) && GvIMPORTED_CV(gv))))
 	    {
-		tmp = 0;
+		tmp = 0;		/* overridden by importation */
+	    }
+	    else if (gv && !gvp
+		     && -tmp==KEY_lock	/* XXX generalizable kludge */
+		     && !hv_fetch(GvHVn(incgv), "Thread.pm", 9, FALSE))
+	    {
+		tmp = 0;		/* any sub overrides "weak" keyword */
+	    }
+	    else {
+		tmp = -tmp; gv = Nullgv; gvp = 0;
 	    }
-	    else
-		tmp = -tmp;
 	}
 
       reserved_word:
@@ -2472,13 +2593,14 @@ yylex()
 
 	default:			/* not a keyword */
 	  just_a_word: {
-		GV *gv;
+		SV *sv;
 		char lastchar = (bufptr == oldoldbufptr ? 0 : bufptr[-1]);
 
 		/* Get the rest if it looks like a package qualifier */
 
 		if (*s == '\'' || *s == ':' && s[1] == ':') {
-		    s = scan_word(s, tokenbuf + len, TRUE, &len);
+		    s = scan_word(s, tokenbuf + len, sizeof tokenbuf - len,
+				  TRUE, &len);
 		    if (!len)
 			croak("Bad name after %s::", tokenbuf);
 		}
@@ -2490,17 +2612,24 @@ yylex()
 			curcop->cop_line++;
 		    }
 		    else
-			no_op("Bare word",s);
+			no_op("Bareword",s);
 		}
 
 		/* Look for a subroutine with this name in current package. */
 
-		gv = gv_fetchpv(tokenbuf,FALSE, SVt_PVCV);
+		if (gvp) {
+		    sv = newSVpv("CORE::GLOBAL::",14);
+		    sv_catpv(sv,tokenbuf);
+		}
+		else
+		    sv = newSVpv(tokenbuf,0);
+		if (!gv)
+		    gv = gv_fetchpv(tokenbuf,FALSE, SVt_PVCV);
 
 		/* Presume this is going to be a bareword of some sort. */
 
 		CLINE;
-		yylval.opval = (OP*)newSVOP(OP_CONST, 0, newSVpv(tokenbuf,0));
+		yylval.opval = (OP*)newSVOP(OP_CONST, 0, sv);
 		yylval.opval->op_private = OPpCONST_BARE;
 
 		/* See if it's the indirect object for a list operator. */
@@ -2510,7 +2639,7 @@ yylex()
 		    (oldoldbufptr == last_lop || oldoldbufptr == last_uni) &&
 		    /* NO SKIPSPACE BEFORE HERE! */
 		    (expect == XREF ||
-		     (opargs[last_lop_op] >> OASHIFT & 7) == OA_FILEREF) )
+		     ((opargs[last_lop_op] >> OASHIFT)& 7) == OA_FILEREF) )
 		{
 		    bool immediate_paren = *s == '(';
 
@@ -2539,6 +2668,13 @@ yylex()
 		s = skipspace(s);
 		if (*s == '(') {
 		    CLINE;
+		    if (gv && GvCVu(gv)) {
+			for (d = s + 1; *d == ' ' || *d == '\t'; d++) ;
+			if (*d == ')' && (sv = cv_const_sv(GvCV(gv)))) {
+			    s = d + 1;
+			    goto its_constant;
+			}
+		    }
 		    nextval[nexttoke].opval = yylval.opval;
 		    expect = XOPERATOR;
 		    force_next(WORD);
@@ -2562,28 +2698,20 @@ yylex()
 		/* Not a method, so call it a subroutine (if defined) */
 
 		if (gv && GvCVu(gv)) {
-		    CV* cv = GvCV(gv);
-		    if (*s == '(') {
-			nextval[nexttoke].opval = yylval.opval;
-			expect = XTERM;
-			force_next(WORD);
-			yylval.ival = 0;
-			TOKEN('&');
-		    }
+		    CV* cv;
 		    if (lastchar == '-')
 			warn("Ambiguous use of -%s resolved as -&%s()",
 				tokenbuf, tokenbuf);
 		    last_lop = oldbufptr;
 		    last_lop_op = OP_ENTERSUB;
 		    /* Check for a constant sub */
-		    {
-			SV *sv = cv_const_sv(cv);
-			if (sv) {
-			    SvREFCNT_dec(((SVOP*)yylval.opval)->op_sv);
-			    ((SVOP*)yylval.opval)->op_sv = SvREFCNT_inc(sv);
-			    yylval.opval->op_private = 0;
-			    TOKEN(WORD);
-			}
+		    cv = GvCV(gv);
+		    if ((sv = cv_const_sv(cv))) {
+		  its_constant:
+			SvREFCNT_dec(((SVOP*)yylval.opval)->op_sv);
+			((SVOP*)yylval.opval)->op_sv = SvREFCNT_inc(sv);
+			yylval.opval->op_private = 0;
+			TOKEN(WORD);
 		    }
 
 		    /* Resolve to GV now. */
@@ -2641,15 +2769,22 @@ yylex()
 		TOKEN(WORD);
 	    }
 
+	case KEY___FILE__:
+	    yylval.opval = (OP*)newSVOP(OP_CONST, 0,
+					newSVsv(GvSV(curcop->cop_filegv)));
+	    TERM(THING);
+
 	case KEY___LINE__:
-	case KEY___FILE__: {
-	    if (tokenbuf[2] == 'L')
-		(void)sprintf(tokenbuf,"%ld",(long)curcop->cop_line);
-	    else
-		strcpy(tokenbuf, SvPVX(GvSV(curcop->cop_filegv)));
-	    yylval.opval = (OP*)newSVOP(OP_CONST, 0, newSVpv(tokenbuf,0));
+	    yylval.opval = (OP*)newSVOP(OP_CONST, 0,
+				    newSVpvf("%ld", (long)curcop->cop_line));
+	    TERM(THING);
+
+	case KEY___PACKAGE__:
+	    yylval.opval = (OP*)newSVOP(OP_CONST, 0,
+					(curstash
+					 ? newSVsv(curstname)
+					 : &sv_undef));
 	    TERM(THING);
-	}
 
 	case KEY___DATA__:
 	case KEY___END__: {
@@ -2657,12 +2792,10 @@ yylex()
 
 	    /*SUPPRESS 560*/
 	    if (rsfp && (!in_eval || tokenbuf[2] == 'D')) {
-		char dname[256];
 		char *pname = "main";
 		if (tokenbuf[2] == 'D')
 		    pname = HvNAME(curstash ? curstash : defstash);
-		sprintf(dname,"%s::DATA", pname);
-		gv = gv_fetchpv(dname,TRUE, SVt_PVIO);
+		gv = gv_fetchpv(form("%s::DATA", pname), TRUE, SVt_PVIO);
 		GvMULTI_on(gv);
 		if (!GvIO(gv))
 		    GvIOp(gv) = newIO();
@@ -2690,6 +2823,7 @@ yylex()
 	case KEY_DESTROY:
 	case KEY_BEGIN:
 	case KEY_END:
+	case KEY_INIT:
 	    if (expect == XSTATE) {
 		s = bufptr;
 		goto really_sub;
@@ -2700,7 +2834,7 @@ yylex()
 	    if (*s == ':' && s[1] == ':') {
 		s += 2;
 		d = s;
-		s = scan_word(s, tokenbuf, FALSE, &len);
+		s = scan_word(s, tokenbuf, sizeof tokenbuf, FALSE, &len);
 		tmp = keyword(tokenbuf, len);
 		if (tmp < 0)
 		    tmp = -tmp;
@@ -3052,6 +3186,9 @@ yylex()
 	case KEY_listen:
 	    LOP(OP_LISTEN,XTERM);
 
+	case KEY_lock:
+	    UNI(OP_LOCK);
+
 	case KEY_lstat:
 	    UNI(OP_LSTAT);
 
@@ -3079,6 +3216,17 @@ yylex()
 
 	case KEY_my:
 	    in_my = TRUE;
+	    s = skipspace(s);
+	    if (isIDFIRST(*s)) {
+		s = scan_word(s, tokenbuf, sizeof tokenbuf, TRUE, &len);
+		in_my_stash = gv_stashpv(tokenbuf, FALSE);
+		if (!in_my_stash) {
+		    char tmpbuf[1024];
+		    bufptr = s;
+		    sprintf(tmpbuf, "No such class %.1000s", tokenbuf);
+		    yyerror(tmpbuf);
+		}
+	    }
 	    OPERATOR(MY);
 
 	case KEY_next:
@@ -3405,9 +3553,9 @@ yylex()
 	    s = skipspace(s);
 
 	    if (isIDFIRST(*s) || *s == '\'' || *s == ':') {
-		char tmpbuf[128];
+		char tmpbuf[sizeof tokenbuf];
 		expect = XBLOCK;
-		d = scan_word(s, tmpbuf, TRUE, &len);
+		d = scan_word(s, tmpbuf, sizeof tmpbuf, TRUE, &len);
 		if (strchr(tmpbuf, ':'))
 		    sv_setpv(subname, tmpbuf);
 		else {
@@ -3432,6 +3580,8 @@ yylex()
 
 	    /* Look for a prototype */
 	    if (*s == '(') {
+		char *p;
+
 		s = scan_str(s);
 		if (!s) {
 		    if (lex_stuff)
@@ -3439,6 +3589,16 @@ yylex()
 		    lex_stuff = Nullsv;
 		    croak("Prototype not terminated");
 		}
+		/* strip spaces */
+		d = SvPVX(lex_stuff);
+		tmp = 0;
+		for (p = d; *p; ++p) {
+		    if (!isSPACE(*p))
+			d[tmp++] = *p;
+		}
+		d[tmp] = '\0';
+		SvCUR(lex_stuff) = tmp;
+
 		nexttoke++;
 		nextval[1] = nextval[0];
 		nexttype[1] = nexttype[0];
@@ -3471,6 +3631,9 @@ yylex()
 	case KEY_sysopen:
 	    LOP(OP_SYSOPEN,XTERM);
 
+	case KEY_sysseek:
+	    LOP(OP_SYSSEEK,XTERM);
+
 	case KEY_sysread:
 	    LOP(OP_SYSREAD,XTERM);
 
@@ -3602,19 +3765,18 @@ yylex()
 	    s = scan_trans(s);
 	    TERM(sublex_start());
 	}
-    }
+    }}
 }
 
 I32
-keyword(d, len)
-register char *d;
-I32 len;
+keyword(register char *d, I32 len)
 {
     switch (*d) {
     case '_':
 	if (d[1] == '_') {
-	    if (strEQ(d,"__LINE__"))		return -KEY___LINE__;
 	    if (strEQ(d,"__FILE__"))		return -KEY___FILE__;
+	    if (strEQ(d,"__LINE__"))		return -KEY___LINE__;
+	    if (strEQ(d,"__PACKAGE__"))		return -KEY___PACKAGE__;
 	    if (strEQ(d,"__DATA__"))		return KEY___DATA__;
 	    if (strEQ(d,"__END__"))		return KEY___END__;
 	}
@@ -3841,7 +4003,7 @@ I32 len;
 	case 4:
 	    if (strEQ(d,"grep"))		return KEY_grep;
 	    if (strEQ(d,"goto"))		return KEY_goto;
-	    if (strEQ(d,"glob"))		return -KEY_glob;
+	    if (strEQ(d,"glob"))		return KEY_glob;
 	    break;
 	case 6:
 	    if (strEQ(d,"gmtime"))		return -KEY_gmtime;
@@ -3851,6 +4013,9 @@ I32 len;
     case 'h':
 	if (strEQ(d,"hex"))			return -KEY_hex;
 	break;
+    case 'I':
+	if (strEQ(d,"INIT"))			return KEY_INIT;
+	break;
     case 'i':
 	switch (len) {
 	case 2:
@@ -3893,6 +4058,7 @@ I32 len;
 	case 4:
 	    if (strEQ(d,"last"))		return KEY_last;
 	    if (strEQ(d,"link"))		return -KEY_link;
+	    if (strEQ(d,"lock"))		return -KEY_lock;
 	    break;
 	case 5:
 	    if (strEQ(d,"local"))		return KEY_local;
@@ -4120,10 +4286,11 @@ I32 len;
 		if (strEQ(d,"system"))		return -KEY_system;
 		break;
 	    case 7:
-		if (strEQ(d,"sysopen"))		return -KEY_sysopen;
-		if (strEQ(d,"sysread"))		return -KEY_sysread;
 		if (strEQ(d,"symlink"))		return -KEY_symlink;
 		if (strEQ(d,"syscall"))		return -KEY_syscall;
+		if (strEQ(d,"sysopen"))		return -KEY_sysopen;
+		if (strEQ(d,"sysread"))		return -KEY_sysread;
+		if (strEQ(d,"sysseek"))		return -KEY_sysseek;
 		break;
 	    case 8:
 		if (strEQ(d,"syswrite"))	return -KEY_syswrite;
@@ -4218,10 +4385,7 @@ I32 len;
 }
 
 static void
-checkcomma(s,name,what)
-register char *s;
-char *name;
-char *what;
+checkcomma(register char *s, char *name, char *what)
 {
     char *w;
 
@@ -4235,7 +4399,7 @@ char *what;
 	}
 	if (*w)
 	    for (; *w && isSPACE(*w); w++) ;
-	if (!*w || !strchr(";|})]oa!=", *w))	/* an advisory hack only... */
+	if (!*w || !strchr(";|})]oaiuw!=", *w))	/* an advisory hack only... */
 	    warn("%s (...) interpreted as function",name);
     }
     while (s < bufend && isSPACE(*s))
@@ -4263,14 +4427,13 @@ char *what;
 }
 
 static char *
-scan_word(s, dest, allow_package, slp)
-register char *s;
-char *dest;
-int allow_package;
-STRLEN *slp;
+scan_word(register char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp)
 {
     register char *d = dest;
+    register char *e = d + destlen - 3;  /* two-character token, ending NUL */
     for (;;) {
+	if (d >= e)
+	    croak(ident_too_long);
 	if (isALNUM(*s))
 	    *d++ = *s++;
 	else if (*s == '\'' && allow_package && isIDFIRST(s[1])) {
@@ -4291,13 +4454,10 @@ STRLEN *slp;
 }
 
 static char *
-scan_ident(s,send,dest,ck_uni)
-register char *s;
-register char *send;
-char *dest;
-I32 ck_uni;
+scan_ident(register char *s, register char *send, char *dest, STRLEN destlen, I32 ck_uni)
 {
     register char *d;
+    register char *e;
     char *bracket = 0;
     char funny = *s++;
 
@@ -4306,12 +4466,18 @@ I32 ck_uni;
     if (isSPACE(*s))
 	s = skipspace(s);
     d = dest;
+    e = d + destlen - 3;	/* two-character token, ending NUL */
     if (isDIGIT(*s)) {
-	while (isDIGIT(*s))
+	while (isDIGIT(*s)) {
+	    if (d >= e)
+		croak(ident_too_long);
 	    *d++ = *s++;
+	}
     }
     else {
 	for (;;) {
+	    if (d >= e)
+		croak(ident_too_long);
 	    if (isALNUM(*s))
 		*d++ = *s++;
 	    else if (*s == '\'' && isIDFIRST(s[1])) {
@@ -4335,8 +4501,13 @@ I32 ck_uni;
 	return s;
     }
     if (*s == '$' && s[1] &&
-      (isALPHA(s[1]) || strchr("$_{", s[1]) || strnEQ(s+1,"::",2)) )
-	return s;
+      (isALNUM(s[1]) || strchr("${", s[1]) || strnEQ(s+1,"::",2)) )
+    {
+	if (isDIGIT(s[1]) && lex_state == LEX_INTERPNORMAL)
+	    deprecate("\"$$<digit>\" to mean \"${$}<digit>\"");
+	else
+	    return s;
+    }
     if (*s == '{') {
 	bracket = s;
 	s++;
@@ -4384,7 +4555,7 @@ I32 ck_uni;
 		lex_state = LEX_INTERPEND;
 	    if (funny == '#')
 		funny = '@';
-	    if (dowarn &&
+	    if (dowarn && lex_state == LEX_NORMAL &&
 	      (keyword(dest, d - dest) || perl_get_cv(dest, FALSE)))
 		warn("Ambiguous use of %c{%s} resolved to %c%s",
 		    funny, dest, funny, dest);
@@ -4399,14 +4570,14 @@ I32 ck_uni;
     return s;
 }
 
-void pmflag(pmfl,ch)
-U16* pmfl;
-int ch;
+void pmflag(U16 *pmfl, int ch)
 {
     if (ch == 'i')
 	*pmfl |= PMf_FOLD;
     else if (ch == 'g')
 	*pmfl |= PMf_GLOBAL;
+    else if (ch == 'c')
+	*pmfl |= PMf_CONTINUE;
     else if (ch == 'o')
 	*pmfl |= PMf_KEEP;
     else if (ch == 'm')
@@ -4418,8 +4589,7 @@ int ch;
 }
 
 static char *
-scan_pat(start)
-char *start;
+scan_pat(char *start)
 {
     PMOP *pm;
     char *s;
@@ -4435,7 +4605,7 @@ char *start;
     pm = (PMOP*)newPMOP(OP_MATCH, 0);
     if (multi_open == '?')
 	pm->op_pmflags |= PMf_ONCE;
-    while (*s && strchr("iogmsx", *s))
+    while (*s && strchr("iogcmsx", *s))
 	pmflag(&pm->op_pmflags,*s++);
     pm->op_pmpermflags = pm->op_pmflags;
 
@@ -4445,11 +4615,11 @@ char *start;
 }
 
 static char *
-scan_subst(start)
-char *start;
+scan_subst(char *start)
 {
     register char *s;
     register PMOP *pm;
+    I32 first_start;
     I32 es = 0;
 
     yylval.ival = OP_NULL;
@@ -4466,6 +4636,7 @@ char *start;
     if (s[-1] == multi_open)
 	s--;
 
+    first_start = multi_start;
     s = scan_str(s);
     if (!s) {
 	if (lex_stuff)
@@ -4476,9 +4647,10 @@ char *start;
 	lex_repl = Nullsv;
 	croak("Substitution replacement not terminated");
     }
+    multi_start = first_start;	/* so whole substitution is taken together */
 
     pm = (PMOP*)newPMOP(OP_SUBST, 0);
-    while (*s && strchr("iogmsex", *s)) {
+    while (*s && strchr("iogcmsex", *s)) {
 	if (*s == 'e') {
 	    s++;
 	    es++;
@@ -4507,53 +4679,14 @@ char *start;
     return s;
 }
 
-void
-hoistmust(pm)
-register PMOP *pm;
-{
-    if (!pm->op_pmshort && pm->op_pmregexp->regstart &&
-	(!pm->op_pmregexp->regmust || pm->op_pmregexp->reganch & ROPT_ANCH)
-       ) {
-	if (!(pm->op_pmregexp->reganch & ROPT_ANCH))
-	    pm->op_pmflags |= PMf_SCANFIRST;
-	pm->op_pmshort = SvREFCNT_inc(pm->op_pmregexp->regstart);
-	pm->op_pmslen = SvCUR(pm->op_pmshort);
-    }
-    else if (pm->op_pmregexp->regmust) {/* is there a better short-circuit? */
-	if (pm->op_pmshort &&
-	  sv_eq(pm->op_pmshort,pm->op_pmregexp->regmust))
-	{
-	    if (pm->op_pmflags & PMf_SCANFIRST) {
-		SvREFCNT_dec(pm->op_pmshort);
-		pm->op_pmshort = Nullsv;
-	    }
-	    else {
-		SvREFCNT_dec(pm->op_pmregexp->regmust);
-		pm->op_pmregexp->regmust = Nullsv;
-		return;
-	    }
-	}
-	if (!pm->op_pmshort ||	/* promote the better string */
-	  ((pm->op_pmflags & PMf_SCANFIRST) &&
-	   (SvCUR(pm->op_pmshort) < SvCUR(pm->op_pmregexp->regmust)) )){
-	    SvREFCNT_dec(pm->op_pmshort);		/* ok if null */
-	    pm->op_pmshort = pm->op_pmregexp->regmust;
-	    pm->op_pmslen = SvCUR(pm->op_pmshort);
-	    pm->op_pmregexp->regmust = Nullsv;
-	    pm->op_pmflags |= PMf_SCANFIRST;
-	}
-    }
-}
-
 static char *
-scan_trans(start)
-char *start;
+scan_trans(char *start)
 {
     register char* s;
-    OP *op;
+    OP *o;
     short *tbl;
     I32 squash;
-    I32 delete;
+    I32 Delete;
     I32 complement;
 
     yylval.ival = OP_NULL;
@@ -4580,49 +4713,52 @@ char *start;
     }
 
     New(803,tbl,256,short);
-    op = newPVOP(OP_TRANS, 0, (char*)tbl);
+    o = newPVOP(OP_TRANS, 0, (char*)tbl);
 
-    complement = delete = squash = 0;
+    complement = Delete = squash = 0;
     while (*s == 'c' || *s == 'd' || *s == 's') {
 	if (*s == 'c')
 	    complement = OPpTRANS_COMPLEMENT;
 	else if (*s == 'd')
-	    delete = OPpTRANS_DELETE;
+	    Delete = OPpTRANS_DELETE;
 	else
 	    squash = OPpTRANS_SQUASH;
 	s++;
     }
-    op->op_private = delete|squash|complement;
+    o->op_private = Delete|squash|complement;
 
-    lex_op = op;
+    lex_op = o;
     yylval.ival = OP_TRANS;
     return s;
 }
 
 static char *
-scan_heredoc(s)
-register char *s;
+scan_heredoc(register char *s)
 {
+    dTHR;
     SV *herewas;
     I32 op_type = OP_SCALAR;
     I32 len;
     SV *tmpstr;
     char term;
     register char *d;
+    register char *e;
     char *peek;
+    int outer = (rsfp && !lex_inwhat);
 
     s += 2;
     d = tokenbuf;
-    if (!rsfp)
+    e = tokenbuf + sizeof tokenbuf - 1;
+    if (!outer)
 	*d++ = '\n';
     for (peek = s; *peek == ' ' || *peek == '\t'; peek++) ;
     if (*peek && strchr("`'\"",*peek)) {
 	s = peek;
 	term = *s++;
-	s = cpytill(d,s,bufend,term,&len);
+	s = delimcpy(d, e, s, bufend, term, &len);
+	d += len;
 	if (s < bufend)
 	    s++;
-	d += len;
     }
     else {
 	if (*s == '\\')
@@ -4631,14 +4767,18 @@ register char *s;
 	    term = '"';
 	if (!isALNUM(*s))
 	    deprecate("bare << to mean <<\"\"");
-	while (isALNUM(*s))
-	    *d++ = *s++;
-    }				/* assuming tokenbuf won't clobber */
+	for (; isALNUM(*s); s++) {
+	    if (d < e)
+		*d++ = *s;
+	}
+    }
+    if (d >= tokenbuf + sizeof tokenbuf - 1)
+	croak("Delimiter for here document is too long");
     *d++ = '\n';
     *d = '\0';
     len = d - tokenbuf;
     d = "\n";
-    if (rsfp || !(d=ninstr(s,bufend,d,d+1)))
+    if (outer || !(d=ninstr(s,bufend,d,d+1)))
 	herewas = newSVpv(s,bufend-s);
     else
 	s--, herewas = newSVpv(s,d-s);
@@ -4659,7 +4799,7 @@ register char *s;
     multi_start = curcop->cop_line;
     multi_open = multi_close = '<';
     term = *tokenbuf;
-    if (!rsfp) {
+    if (!outer) {
 	d = s;
 	while (s < bufend &&
 	  (*s != term || memNE(s,tokenbuf,len)) ) {
@@ -4680,13 +4820,13 @@ register char *s;
     else
 	sv_setpvn(tmpstr,"",0);   /* avoid "uninitialized" warning */
     while (s >= bufend) {	/* multiple line string? */
-	if (!rsfp ||
+	if (!outer ||
 	 !(oldoldbufptr = oldbufptr = s = linestart = filter_gets(linestr, rsfp, 0))) {
 	    curcop->cop_line = multi_start;
 	    missingterm(tokenbuf);
 	}
 	curcop->cop_line++;
-	if (perldb && curstash != debstash) {
+	if (PERLDB_LINE && curstash != debstash) {
 	    SV *sv = NEWSV(88,0);
 
 	    sv_upgrade(sv, SVt_PVMG);
@@ -4719,20 +4859,21 @@ register char *s;
 }
 
 static char *
-scan_inputsymbol(start)
-char *start;
+scan_inputsymbol(char *start)
 {
     register char *s = start;
     register char *d;
+    register char *e;
     I32 len;
 
     d = tokenbuf;
-    s = cpytill(d, s+1, bufend, '>', &len);
-    if (s < bufend)
-	s++;
-    else
+    e = tokenbuf + sizeof tokenbuf;
+    s = delimcpy(d, e, s + 1, bufend, '>', &len);
+    if (len >= sizeof tokenbuf)
+	croak("Excessively long <> operator");
+    if (s >= bufend)
 	croak("Unterminated <> operator");
-
+    s++;
     if (*d == '$' && d[1]) d++;
     while (*d && (isALNUM(*d) || *d == '\'' || *d == ':'))
 	d++;
@@ -4750,10 +4891,10 @@ char *start;
 	    (void)strcpy(d,"ARGV");
 	if (*d == '$') {
 	    I32 tmp;
-	    if (tmp = pad_findmy(d)) {
-		OP *op = newOP(OP_PADSV, 0);
-		op->op_targ = tmp;
-		lex_op = (OP*)newUNOP(OP_READLINE, 0, newUNOP(OP_RV2GV, 0, op));
+	    if ((tmp = pad_findmy(d)) != NOT_IN_PAD) {
+		OP *o = newOP(OP_PADSV, 0);
+		o->op_targ = tmp;
+		lex_op = (OP*)newUNOP(OP_READLINE, 0, newUNOP(OP_RV2GV, 0, o));
 	    }
 	    else {
 		GV *gv = gv_fetchpv(d+1,TRUE, SVt_PV);
@@ -4774,9 +4915,9 @@ char *start;
 }
 
 static char *
-scan_str(start)
-char *start;
+scan_str(char *start)
 {
+    dTHR;
     SV *sv;
     char *tmps;
     register char *s = start;
@@ -4821,13 +4962,13 @@ char *start;
 	    for (; s < bufend; s++,to++) {
 		if (*s == '\n' && !rsfp)
 		    curcop->cop_line++;
-		if (*s == '\\' && s+1 < bufend && term != '\\') {
-		    if (s[1] == term)
+		if (*s == '\\' && s+1 < bufend) {
+		    if ((s[1] == multi_open) || (s[1] == multi_close))
 			s++;
 		    else
 			*to++ = *s++;
 		}
-		else if (*s == term && --brackets <= 0)
+		else if (*s == multi_close && --brackets <= 0)
 		    break;
 		else if (*s == multi_open)
 		    brackets++;
@@ -4846,7 +4987,7 @@ char *start;
 	    return Nullch;
 	}
 	curcop->cop_line++;
-	if (perldb && curstash != debstash) {
+	if (PERLDB_LINE && curstash != debstash) {
 	    SV *sv = NEWSV(88,0);
 
 	    sv_upgrade(sv, SVt_PVMG);
@@ -4870,16 +5011,17 @@ char *start;
 }
 
 char *
-scan_num(start)
-char *start;
+scan_num(char *start)
 {
     register char *s = start;
     register char *d;
-    I32 tryi32;
+    register char *e;
+    I32 tryiv;
     double value;
     SV *sv;
     I32 floatit;
     char *lastub = 0;
+    static char number_too_long[] = "Number too long";
 
     switch (*s) {
     default:
@@ -4941,6 +5083,7 @@ char *start;
     case '6': case '7': case '8': case '9': case '.':
       decimal:
 	d = tokenbuf;
+	e = tokenbuf + sizeof tokenbuf - 6; /* room for various punctuation */
 	floatit = FALSE;
 	while (isDIGIT(*s) || *s == '_') {
 	    if (*s == '_') {
@@ -4948,19 +5091,22 @@ char *start;
 		    warn("Misplaced _ in number");
 		lastub = ++s;
 	    }
-	    else
+	    else {
+		if (d >= e)
+		    croak(number_too_long);
 		*d++ = *s++;
+	    }
 	}
 	if (dowarn && lastub && s - lastub != 3)
 	    warn("Misplaced _ in number");
 	if (*s == '.' && s[1] != '.') {
 	    floatit = TRUE;
 	    *d++ = *s++;
-	    while (isDIGIT(*s) || *s == '_') {
-		if (*s == '_')
-		    s++;
-		else
-		    *d++ = *s++;
+	    for (; isDIGIT(*s) || *s == '_'; s++) {
+		if (d >= e)
+		    croak(number_too_long);
+		if (*s != '_')
+		    *d++ = *s;
 	    }
 	}
 	if (*s && strchr("eE",*s) && strchr("+-0123456789",s[1])) {
@@ -4969,18 +5115,21 @@ char *start;
 	    *d++ = 'e';		/* At least some Mach atof()s don't grok 'E' */
 	    if (*s == '+' || *s == '-')
 		*d++ = *s++;
-	    while (isDIGIT(*s))
+	    while (isDIGIT(*s)) {
+		if (d >= e)
+		    croak(number_too_long);
 		*d++ = *s++;
+	    }
 	}
 	*d = '\0';
 	sv = NEWSV(92,0);
 	SET_NUMERIC_STANDARD();
 	value = atof(tokenbuf);
-	tryi32 = I_32(value);
-	if (!floatit && (double)tryi32 == value)
-	    sv_setiv(sv,tryi32);
+	tryiv = I_V(value);
+	if (!floatit && (double)tryiv == value)
+	    sv_setiv(sv, tryiv);
 	else
-	    sv_setnv(sv,value);
+	    sv_setnv(sv, value);
 	break;
     }
 
@@ -4990,9 +5139,9 @@ char *start;
 }
 
 static char *
-scan_formline(s)
-register char *s;
+scan_formline(register char *s)
 {
+    dTHR;
     register char *eol;
     register char *t;
     SV *stuff = newSVpv("",0);
@@ -5060,7 +5209,7 @@ register char *s;
 }
 
 static void
-set_csh()
+set_csh(void)
 {
 #ifdef CSH
     if (!cshlen)
@@ -5068,11 +5217,11 @@ set_csh()
 #endif
 }
 
-int
-start_subparse(flags)
-U32 flags;
+I32
+start_subparse(I32 is_format, U32 flags)
 {
-    int oldsavestack_ix = savestack_ix;
+    dTHR;
+    I32 oldsavestack_ix = savestack_ix;
     CV* outsidecv = compcv;
     AV* comppadlist;
 
@@ -5092,17 +5241,25 @@ U32 flags;
     SAVEI32(pad_reset_pending);
 
     compcv = (CV*)NEWSV(1104,0);
-    sv_upgrade((SV *)compcv, (flags & CVf_FORMAT) ? SVt_PVFM : SVt_PVCV);
+    sv_upgrade((SV *)compcv, is_format ? SVt_PVFM : SVt_PVCV);
     CvFLAGS(compcv) |= flags;
 
     comppad = newAV();
+    av_push(comppad, Nullsv);
+    curpad = AvARRAY(comppad);
     comppad_name = newAV();
     comppad_name_fill = 0;
     min_intro_pending = 0;
-    av_push(comppad, Nullsv);
-    curpad = AvARRAY(comppad);
     padix = 0;
     subline = curcop->cop_line;
+#ifdef USE_THREADS
+    av_store(comppad_name, 0, newSVpv("@_", 2));
+    curpad[0] = (SV*)newAV();
+    SvPADMY_on(curpad[0]);	/* XXX Needed? */
+    CvOWNER(compcv) = 0;
+    New(666, CvMUTEXP(compcv), 1, perl_mutex);
+    MUTEX_INIT(CvMUTEXP(compcv));
+#endif /* USE_THREADS */
 
     comppadlist = newAV();
     AvREAL_off(comppadlist);
@@ -5110,15 +5267,20 @@ U32 flags;
     av_store(comppadlist, 1, (SV*)comppad);
 
     CvPADLIST(compcv) = comppadlist;
-    CvOUTSIDE(compcv) = (CV*)SvREFCNT_inc((SV*)outsidecv);
+    CvOUTSIDE(compcv) = (CV*)SvREFCNT_inc(outsidecv);
+#ifdef USE_THREADS
+    CvOWNER(compcv) = 0;
+    New(666, CvMUTEXP(compcv), 1, perl_mutex);
+    MUTEX_INIT(CvMUTEXP(compcv));
+#endif /* USE_THREADS */
 
     return oldsavestack_ix;
 }
 
 int
-yywarn(s)
-char *s;
+yywarn(char *s)
 {
+    dTHR;
     --error_count;
     in_eval |= 2;
     yyerror(s);
@@ -5127,58 +5289,74 @@ char *s;
 }
 
 int
-yyerror(s)
-char *s;
+yyerror(char *s)
 {
-    char tmpbuf[258];
-    char *tname = tmpbuf;
-
-    if (bufptr > oldoldbufptr && bufptr - oldoldbufptr < 200 &&
+    dTHR;
+    char *where = NULL;
+    char *context = NULL;
+    int contlen = -1;
+    SV *msg;
+
+    if (!yychar || (yychar == ';' && !rsfp))
+	where = "at EOF";
+    else if (bufptr > oldoldbufptr && bufptr - oldoldbufptr < 200 &&
       oldoldbufptr != oldbufptr && oldbufptr != bufptr) {
 	while (isSPACE(*oldoldbufptr))
 	    oldoldbufptr++;
-	sprintf(tname,"near \"%.*s\"",bufptr - oldoldbufptr, oldoldbufptr);
+	context = oldoldbufptr;
+	contlen = bufptr - oldoldbufptr;
     }
     else if (bufptr > oldbufptr && bufptr - oldbufptr < 200 &&
       oldbufptr != bufptr) {
 	while (isSPACE(*oldbufptr))
 	    oldbufptr++;
-	sprintf(tname,"near \"%.*s\"",bufptr - oldbufptr, oldbufptr);
+	context = oldbufptr;
+	contlen = bufptr - oldbufptr;
     }
     else if (yychar > 255)
-	tname = "next token ???";
-    else if (!yychar || (yychar == ';' && !rsfp))
-	(void)strcpy(tname,"at EOF");
+	where = "next token ???";
     else if ((yychar & 127) == 127) {
 	if (lex_state == LEX_NORMAL ||
 	   (lex_state == LEX_KNOWNEXT && lex_defer == LEX_NORMAL))
-	    (void)strcpy(tname,"at end of line");
+	    where = "at end of line";
 	else if (lex_inpat)
-	    (void)strcpy(tname,"within pattern");
+	    where = "within pattern";
 	else
-	    (void)strcpy(tname,"within string");
+	    where = "within string";
     }
-    else if (yychar < 32)
-	(void)sprintf(tname,"next char ^%c",toCTRL(yychar));
+    else {
+	SV *where_sv = sv_2mortal(newSVpv("next char ", 0));
+	if (yychar < 32)
+	    sv_catpvf(where_sv, "^%c", toCTRL(yychar));
+	else if (isPRINT_LC(yychar))
+	    sv_catpvf(where_sv, "%c", yychar);
+	else
+	    sv_catpvf(where_sv, "\\%03o", yychar & 255);
+	where = SvPVX(where_sv);
+    }
+    msg = sv_2mortal(newSVpv(s, 0));
+    sv_catpvf(msg, " at %_ line %ld, ",
+	      GvSV(curcop->cop_filegv), (long)curcop->cop_line);
+    if (context)
+	sv_catpvf(msg, "near \"%.*s\"\n", contlen, context);
     else
-	(void)sprintf(tname,"next char %c",yychar);
-    (void)sprintf(buf, "%s at %s line %d, %s\n",
-      s,SvPVX(GvSV(curcop->cop_filegv)),curcop->cop_line,tname);
-    if (curcop->cop_line == multi_end && multi_start < multi_end) {
-	sprintf(buf+strlen(buf),
-	  "  (Might be a runaway multi-line %c%c string starting on line %ld)\n",
-	  multi_open,multi_close,(long)multi_start);
+	sv_catpvf(msg, "%s\n", where);
+    if (multi_start < multi_end && (U32)(curcop->cop_line - multi_end) <= 1) {
+	sv_catpvf(msg,
+	"  (Might be a runaway multi-line %c%c string starting on line %ld)\n",
+		(int)multi_open,(int)multi_close,(long)multi_start);
         multi_end = 0;
     }
     if (in_eval & 2)
-	warn("%s",buf);
+	warn("%_", msg);
     else if (in_eval)
-	sv_catpv(GvSV(errgv),buf);
+	sv_catsv(ERRSV, msg);
     else
-	PerlIO_printf(PerlIO_stderr(), "%s",buf);
+	PerlIO_write(PerlIO_stderr(), SvPVX(msg), SvCUR(msg));
     if (++error_count >= 10)
-	croak("%s has too many errors.\n",
-	SvPVX(GvSV(curcop->cop_filegv)));
+	croak("%_ has too many errors.\n", GvSV(curcop->cop_filegv));
     in_my = 0;
+    in_my_stash = Nullhv;
     return 0;
 }
+