X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=toke.c;h=737c9aef89c766dc8caaf7fde8675bccb44b9881;hb=b8bfa007e85f190696666dcd944c1c01b7860b92;hp=d1f77df3bdc56b4e4ce0299b0c9a4db84622e8c1;hpb=9edfffed45d005f6a85767a405c48b9f793098df;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/toke.c b/toke.c
index d1f77df..737c9ae 100644
--- a/toke.c
+++ b/toke.c
@@ -1,6 +1,6 @@
 /*    toke.c
  *
- *    Copyright (c) 1991-1999, Larry Wall
+ *    Copyright (c) 1991-2000, 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.
@@ -28,34 +28,17 @@
 static char ident_too_long[] = "Identifier too long";
 
 static void restore_rsfp(pTHXo_ void *f);
-static void restore_expect(pTHXo_ void *e);
-static void restore_lex_expect(pTHXo_ void *e);
 
+#define XFAKEBRACK 128
+#define XENUMMASK 127
+
+/*#define UTF (SvUTF8(PL_linestr) && !(PL_hints & HINT_BYTE))*/
 #define UTF (PL_hints & HINT_UTF8)
-/*
- * Note: we try to be careful never to call the isXXX_utf8() functions
- * unless we're pretty sure we've seen the beginning of a UTF-8 character
- * (that is, the two high bits are set).  Otherwise we risk loading in the
- * heavy-duty SWASHINIT and SWASHGET routines unnecessarily.
- */
-#define isIDFIRST_lazy(p) ((!UTF || (*((U8*)p) < 0xc0)) \
-				? isIDFIRST(*(p)) \
-				: isIDFIRST_utf8((U8*)p))
-#define isALNUM_lazy(p) ((!UTF || (*((U8*)p) < 0xc0)) \
-				? isALNUM(*(p)) \
-				: isALNUM_utf8((U8*)p))
 
 /* In variables name $^X, these are the legal values for X.  
  * 1999-02-27 mjd-perl-patch@plover.com */
 #define isCONTROLVAR(x) (isUPPER(x) || strchr("[\\]^_?", (x)))
 
-/* On MacOS, respect nonbreaking spaces */
-#ifdef MACOS_TRADITIONAL
-#define SPACE_OR_TAB(c) ((c)==' '||(c)=='\312'||(c)=='\t')
-#else
-#define SPACE_OR_TAB(c) ((c)==' '||(c)=='\t')
-#endif
-
 /* LEX_* are values for PL_lex_state, the state of the lexer.
  * They are arranged oddly so that the guard on the switch statement
  * can get by with a single comparison (if the compiler is smart enough).
@@ -75,13 +58,6 @@ static void restore_lex_expect(pTHXo_ void *e);
 #define LEX_FORMLINE		 1
 #define LEX_KNOWNEXT		 0
 
-#ifdef I_FCNTL
-#include <fcntl.h>
-#endif
-#ifdef I_SYS_FILE
-#include <sys/file.h>
-#endif
-
 /* XXX If this causes problems, set i_unistd=undef in the hint file.  */
 #ifdef I_UNISTD
 #  include <unistd.h> /* Needed for execv() */
@@ -111,7 +87,7 @@ int* yychar_pointer = NULL;
 #ifdef CLINE
 #undef CLINE
 #endif
-#define CLINE (PL_copline = (PL_curcop->cop_line < PL_copline ? PL_curcop->cop_line : PL_copline))
+#define CLINE (PL_copline = (CopLINE(PL_curcop) < PL_copline ? CopLINE(PL_curcop) : PL_copline))
 
 /*
  * Convenience functions to return different tokens and prime the
@@ -229,9 +205,9 @@ S_no_op(pTHX_ char *what, char *s)
     yywarn(Perl_form(aTHX_ "%s found where operator expected", what));
     if (is_first)
 	Perl_warn(aTHX_ "\t(Missing semicolon on previous line?)\n");
-    else if (PL_oldoldbufptr && isIDFIRST_lazy(PL_oldoldbufptr)) {
+    else if (PL_oldoldbufptr && isIDFIRST_lazy_if(PL_oldoldbufptr,UTF)) {
 	char *t;
-	for (t = PL_oldoldbufptr; *t && (isALNUM_lazy(t) || *t == ':'); t++) ;
+	for (t = PL_oldoldbufptr; *t && (isALNUM_lazy_if(t,UTF) || *t == ':'); t++) ;
 	if (t < PL_bufptr && isSPACE(*t))
 	    Perl_warn(aTHX_ "\t(Do you need to predeclare %.*s?)\n",
 		t - PL_oldoldbufptr, PL_oldoldbufptr);
@@ -310,18 +286,40 @@ S_depcom(pTHX)
  * utf16-to-utf8-reversed.
  */
 
-#ifdef WIN32
+#ifdef PERL_CR_FILTER
+static void
+strip_return(SV *sv)
+{
+    register char *s = SvPVX(sv);
+    register 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') {
+	    /* hit a CR-LF, need to copy the rest */
+	    register char *d = s - 1;
+	    *d++ = *s++;
+	    while (s < e) {
+		if (*s == '\r' && s[1] == '\n')
+		    s++;
+		*d++ = *s++;
+	    }
+	    SvCUR(sv) -= s - d;
+	    return;
+	}
+    }
+}
 
 STATIC I32
-S_win32_textfilter(pTHX_ int idx, SV *sv, int maxlen)
+S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 {
- I32 count = FILTER_READ(idx+1, sv, maxlen);
- if (count > 0 && !maxlen)
-  win32_strip_return(sv);
- return count;
+    I32 count = FILTER_READ(idx+1, sv, maxlen);
+    if (count > 0 && !maxlen)
+	strip_return(sv);
+    return count;
 }
 #endif
 
+#if 0
 STATIC I32
 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 {
@@ -332,7 +330,6 @@ S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 	New(898, tmps, SvCUR(sv) * 3 / 2 + 1, U8);
 	tend = utf16_to_utf8((U16*)SvPVX(sv), tmps, SvCUR(sv));
 	sv_usepvn(sv, (char*)tmps, tend - tmps);
-    
     }
     return count;
 }
@@ -347,10 +344,10 @@ S_utf16rev_textfilter(pTHX_ int idx, SV *sv, int maxlen)
 	New(898, tmps, SvCUR(sv) * 3 / 2 + 1, U8);
 	tend = utf16_to_utf8_reversed((U16*)SvPVX(sv), tmps, SvCUR(sv));
 	sv_usepvn(sv, (char*)tmps, tend - tmps);
-    
     }
     return count;
 }
+#endif
 
 /*
  * Perl_lex_start
@@ -367,13 +364,21 @@ Perl_lex_start(pTHX_ SV *line)
 
     SAVEI32(PL_lex_dojoin);
     SAVEI32(PL_lex_brackets);
-    SAVEI32(PL_lex_fakebrack);
     SAVEI32(PL_lex_casemods);
     SAVEI32(PL_lex_starts);
     SAVEI32(PL_lex_state);
-    SAVESPTR(PL_lex_inpat);
+    SAVEVPTR(PL_lex_inpat);
     SAVEI32(PL_lex_inwhat);
-    SAVEI16(PL_curcop->cop_line);
+    if (PL_lex_state == LEX_KNOWNEXT) {
+	I32 toke = PL_nexttoke;
+	while (--toke >= 0) {
+	    SAVEI32(PL_nexttype[toke]);
+	    SAVEVPTR(PL_nextval[toke]);
+	}
+	SAVEI32(PL_nexttoke);
+	PL_nexttoke = 0;
+    }
+    SAVECOPLINE(PL_curcop);
     SAVEPPTR(PL_bufptr);
     SAVEPPTR(PL_bufend);
     SAVEPPTR(PL_oldbufptr);
@@ -387,14 +392,13 @@ Perl_lex_start(pTHX_ SV *line)
     SAVEI32(PL_lex_defer);
     SAVEI32(PL_sublex_info.sub_inwhat);
     SAVESPTR(PL_lex_repl);
-    SAVEDESTRUCTOR_X(restore_expect, PL_tokenbuf + PL_expect); /* encode as pointer */
-    SAVEDESTRUCTOR_X(restore_lex_expect, PL_tokenbuf + PL_expect);
+    SAVEINT(PL_expect);
+    SAVEINT(PL_lex_expect);
 
     PL_lex_state = LEX_NORMAL;
     PL_lex_defer = 0;
     PL_expect = XSTATE;
     PL_lex_brackets = 0;
-    PL_lex_fakebrack = 0;
     New(899, PL_lex_brackstack, 120, char);
     New(899, PL_lex_casestack, 12, char);
     SAVEFREEPV(PL_lex_brackstack);
@@ -441,7 +445,7 @@ Perl_lex_end(pTHX)
  * S_incline
  * This subroutine has nothing to do with tilting, whether at windmills
  * or pinball tables.  Its name is short for "increment line".  It
- * increments the current line number in PL_curcop->cop_line and checks
+ * increments the current line number in CopLINE(PL_curcop) and checks
  * to see whether the line starts with a comment of the form
  *    # line 500 "foo.pm"
  * If so, it sets the current line number and file to the values in the comment.
@@ -453,40 +457,48 @@ S_incline(pTHX_ char *s)
     dTHR;
     char *t;
     char *n;
+    char *e;
     char ch;
-    int sawline = 0;
 
-    PERL_ASYNC_CHECK();
-    PL_curcop->cop_line++;
+    CopLINE_inc(PL_curcop);
     if (*s++ != '#')
 	return;
-    while (SPACE_OR_TAB(*s)) s++;
-    if (strnEQ(s, "line ", 5)) {
-	s += 5;
-	sawline = 1;
-    }
+    while (*s == ' ' || *s == '\t') s++;
+    if (strnEQ(s, "line", 4))
+	s += 4;
+    else
+	return;
+    if (*s == ' ' || *s == '\t')
+	s++;
+    else 
+	return;
+    while (*s == ' ' || *s == '\t') s++;
     if (!isDIGIT(*s))
 	return;
     n = s;
     while (isDIGIT(*s))
 	s++;
-    while (SPACE_OR_TAB(*s))
+    while (*s == ' ' || *s == '\t')
 	s++;
-    if (*s == '"' && (t = strchr(s+1, '"')))
+    if (*s == '"' && (t = strchr(s+1, '"'))) {
 	s++;
+	e = t + 1;
+    }
     else {
-	if (!sawline)
-	    return;		/* false alarm */
 	for (t = s; !isSPACE(*t); t++) ;
+	e = t;
     }
+    while (*e == ' ' || *e == '\t' || *e == '\r' || *e == '\f')
+	e++;
+    if (*e != '\n' && *e != '\0')
+	return;		/* false alarm */
+
     ch = *t;
     *t = '\0';
     if (t - s > 0)
-	CopFILEGV_set(PL_curcop, gv_fetchfile(s));
-    else
-	CopFILEGV_set(PL_curcop, gv_fetchfile(PL_origfilename));
+	CopFILE_set(PL_curcop, s);
     *t = ch;
-    PL_curcop->cop_line = atoi(n)-1;
+    CopLINE_set(PL_curcop, atoi(n)-1);
 }
 
 /*
@@ -500,7 +512,7 @@ S_skipspace(pTHX_ register char *s)
 {
     dTHR;
     if (PL_lex_formbrack && PL_lex_brackets <= PL_lex_formbrack) {
-	while (s < PL_bufend && SPACE_OR_TAB(*s))
+	while (s < PL_bufend && (*s == ' ' || *s == '\t'))
 	    s++;
 	return s;
     }
@@ -598,7 +610,7 @@ S_skipspace(pTHX_ register char *s)
 
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setpvn(sv,PL_bufptr,PL_bufend-PL_bufptr);
-	    av_store(CopFILEAV(PL_curcop),(I32)PL_curcop->cop_line,sv);
+	    av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv);
 	}
     }
 }
@@ -623,7 +635,7 @@ S_check_uni(pTHX)
 	return;
     while (isSPACE(*PL_last_uni))
 	PL_last_uni++;
-    for (s = PL_last_uni; isALNUM_lazy(s) || *s == '-'; s++) ;
+    for (s = PL_last_uni; isALNUM_lazy_if(s,UTF) || *s == '-'; s++) ;
     if ((t = strchr(s, '(')) && t < PL_bufptr)
 	return;
     if (ckWARN_d(WARN_AMBIGUOUS)){
@@ -681,7 +693,7 @@ S_uni(pTHX_ I32 f, char *s)
  */
 
 STATIC I32
-S_lop(pTHX_ I32 f, expectation x, char *s)
+S_lop(pTHX_ I32 f, int x, char *s)
 {
     dTHR;
     yylval.ival = f;
@@ -746,7 +758,7 @@ S_force_word(pTHX_ register char *start, int token, int check_keyword, int allow
     
     start = skipspace(start);
     s = start;
-    if (isIDFIRST_lazy(s) ||
+    if (isIDFIRST_lazy_if(s,UTF) ||
 	(allow_pack && *s == ':') ||
 	(allow_initial_tick && *s == '\'') )
     {
@@ -800,6 +812,31 @@ S_force_ident(pTHX_ register char *s, int kind)
     }
 }
 
+NV
+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);
+    char *end = start + len;
+    while (start < end) {
+	I32 skip;
+	UV n;
+	if (utf)
+	    n = utf8_to_uv((U8*)start, &skip);
+	else {
+	    n = *(U8*)start;
+	    skip = 1;
+	}
+	retval += ((NV)n)/nshift;
+	start += skip;
+	nshift *= 1000;
+    }
+    return retval;
+}
+
 /* 
  * S_force_version
  * Forces the next token to be a version number.
@@ -809,19 +846,25 @@ STATIC char *
 S_force_version(pTHX_ char *s)
 {
     OP *version = Nullop;
+    char *d;
 
     s = skipspace(s);
 
-    /* default VERSION number -- GBARR */
-
-    if(isDIGIT(*s)) {
-        char *d;
-        int c;
-        for( d=s, c = 1; isDIGIT(*d) || *d == '_' || (*d == '.' && c--); d++);
-        if((*d == ';' || isSPACE(*d)) && *(skipspace(d)) != ',') {
+    d = s;
+    if (*d == 'v')
+	d++;
+    if (isDIGIT(*d)) {
+        for (; isDIGIT(*d) || *d == '_' || *d == '.'; d++);
+        if (*d == ';' || isSPACE(*d) || *d == '}' || !*d) {
+	    SV *ver;
             s = scan_num(s);
-            /* real VERSION number -- GBARR */
             version = yylval.opval;
+	    ver = cSVOPx(version)->op_sv;
+	    if (SvPOK(ver) && !SvNIOK(ver)) {
+		(void)SvUPGRADE(ver, SVt_PVNV);
+		SvNVX(ver) = str_to_version(ver);
+		SvNOK_on(ver);		/* hint that it is a version */
+	    }
         }
     }
 
@@ -971,13 +1014,12 @@ S_sublex_push(pTHX)
     PL_lex_state = PL_sublex_info.super_state;
     SAVEI32(PL_lex_dojoin);
     SAVEI32(PL_lex_brackets);
-    SAVEI32(PL_lex_fakebrack);
     SAVEI32(PL_lex_casemods);
     SAVEI32(PL_lex_starts);
     SAVEI32(PL_lex_state);
-    SAVESPTR(PL_lex_inpat);
+    SAVEVPTR(PL_lex_inpat);
     SAVEI32(PL_lex_inwhat);
-    SAVEI16(PL_curcop->cop_line);
+    SAVECOPLINE(PL_curcop);
     SAVEPPTR(PL_bufptr);
     SAVEPPTR(PL_oldbufptr);
     SAVEPPTR(PL_oldoldbufptr);
@@ -996,7 +1038,6 @@ S_sublex_push(pTHX)
 
     PL_lex_dojoin = FALSE;
     PL_lex_brackets = 0;
-    PL_lex_fakebrack = 0;
     New(899, PL_lex_brackstack, 120, char);
     New(899, PL_lex_casestack, 12, char);
     SAVEFREEPV(PL_lex_brackstack);
@@ -1005,7 +1046,7 @@ S_sublex_push(pTHX)
     *PL_lex_casestack = '\0';
     PL_lex_starts = 0;
     PL_lex_state = LEX_INTERPCONCAT;
-    PL_curcop->cop_line = PL_multi_start;
+    CopLINE_set(PL_curcop, PL_multi_start);
 
     PL_lex_inwhat = PL_sublex_info.sub_inwhat;
     if (PL_lex_inwhat == OP_MATCH || PL_lex_inwhat == OP_QR || PL_lex_inwhat == OP_SUBST)
@@ -1044,7 +1085,6 @@ S_sublex_done(pTHX)
 	SAVEFREESV(PL_linestr);
 	PL_lex_dojoin = FALSE;
 	PL_lex_brackets = 0;
-	PL_lex_fakebrack = 0;
 	PL_lex_casemods = 0;
 	*PL_lex_casestack = '\0';
 	PL_lex_starts = 0;
@@ -1153,7 +1193,10 @@ S_scan_const(pTHX_ char *start)
     register char *s = start;			/* start of the constant */
     register char *d = SvPVX(sv);		/* destination for copies */
     bool dorange = FALSE;			/* are we in a translit range? */
+    bool has_utf = FALSE;			/* embedded \x{} */
     I32 len;					/* ? */
+    UV uv;
+
     I32 utf = (PL_lex_inwhat == OP_TRANS && PL_sublex_info.sub_op)
 	? (PL_sublex_info.sub_op->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF))
 	: UTF;
@@ -1226,8 +1269,10 @@ S_scan_const(pTHX_ char *start)
 	    if (s[2] == '#') {
 		while (s < send && *s != ')')
 		    *d++ = *s++;
-	    } else if (s[2] == '{'
-		       || s[2] == 'p' && s[3] == '{') {	/* This should march regcomp.c */
+	    }
+	    else if (s[2] == '{' /* This should match regcomp.c */
+		     || ((s[2] == 'p' || s[2] == '?') && s[3] == '{'))
+	    {
 		I32 count = 1;
 		char *regparse = s + (s[2] == '{' ? 3 : 4);
 		char c;
@@ -1258,7 +1303,8 @@ S_scan_const(pTHX_ char *start)
 	}
 
 	/* check for embedded arrays (@foo, @:foo, @'foo, @{foo}, @$foo) */
-	else if (*s == '@' && s[1] && (isALNUM_lazy(s+1) || strchr(":'{$", s[1])))
+	else if (*s == '@' && s[1]
+		 && (isALNUM_lazy_if(s+1,UTF) || strchr(":'{$", s[1])))
 	    break;
 
 	/* check for embedded scalars.  only stop if we're sure it's a
@@ -1274,15 +1320,20 @@ S_scan_const(pTHX_ char *start)
 	/* (now in tr/// code again) */
 
 	if (*s & 0x80 && thisutf) {
-	    dTHR;			/* only for ckWARN */
-	    if (ckWARN(WARN_UTF8)) {
-		(void)utf8_to_uv((U8*)s, &len);	/* could cvt latin-1 to utf8 here... */
-		if (len) {
-		    while (len--)
-			*d++ = *s++;
-		    continue;
-		}
-	    }
+	   (void)utf8_to_uv((U8*)s, &len);
+	   if (len == 1) {
+	       /* illegal UTF8, make it valid */
+	       char *old_pvx = SvPVX(sv);
+	       /* need space for one extra char (NOTE: SvCUR() not set here) */
+	       d = SvGROW(sv, SvLEN(sv) + 1) + (d - old_pvx);
+	       d = (char*)uv_to_utf8((U8*)d, (U8)*s++);
+	   }
+	   else {
+	       while (len--)
+		   *d++ = *s++;
+	   }
+	   has_utf = TRUE;
+	   continue;
 	}
 
 	/* backslashes */
@@ -1326,8 +1377,8 @@ S_scan_const(pTHX_ char *start)
 	    default:
 	        {
 		    dTHR;
-		    if (ckWARN(WARN_UNSAFE) && isALPHA(*s))
-			Perl_warner(aTHX_ WARN_UNSAFE, 
+		    if (ckWARN(WARN_MISC) && isALPHA(*s))
+			Perl_warner(aTHX_ WARN_MISC, 
 			       "Unrecognized escape \\%c passed through",
 			       *s);
 		    /* default action is to copy the quoted character */
@@ -1338,49 +1389,75 @@ S_scan_const(pTHX_ char *start)
 	    /* \132 indicates an octal constant */
 	    case '0': case '1': case '2': case '3':
 	    case '4': case '5': case '6': case '7':
-		*d++ = (char)scan_oct(s, 3, &len);
+		uv = (UV)scan_oct(s, 3, &len);
 		s += len;
-		continue;
+		goto NUM_ESCAPE_INSERT;
 
 	    /* \x24 indicates a hex constant */
 	    case 'x':
 		++s;
 		if (*s == '{') {
 		    char* e = strchr(s, '}');
-
 		    if (!e) {
 			yyerror("Missing right brace on \\x{}");
 			e = s;
 		    }
-		    if (!utf) {
-			dTHR;
-			if (ckWARN(WARN_UTF8))
-			    Perl_warner(aTHX_ WARN_UTF8,
-				   "Use of \\x{} without utf8 declaration");
-		    }
-		    /* note: utf always shorter than hex */
-		    d = (char*)uv_to_utf8((U8*)d,
-					  (UV)scan_hex(s + 1, e - s - 1, &len));
-		    s = e + 1;
+                    uv = (UV)scan_hex(s + 1, e - s - 1, &len);
+                    s = e + 1;
 		}
 		else {
-		    UV uv = (UV)scan_hex(s, 2, &len);
-		    if (utf && PL_lex_inwhat == OP_TRANS &&
-			utf != (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF))
-		    {
-			d = (char*)uv_to_utf8((U8*)d, uv);	/* doing a CU or UC */
-		    }
-		    else {
-			if (uv >= 127 && UTF) {
-			    dTHR;
-			    if (ckWARN(WARN_UTF8))
-				Perl_warner(aTHX_ WARN_UTF8,
-				    "\\x%.*s will produce malformed UTF-8 character; use \\x{%.*s} for that",
-				    len,s,len,s);
+		    uv = (UV)scan_hex(s, 2, &len);
+		    s += len;
+		}
+
+	      NUM_ESCAPE_INSERT:
+		/* Insert oct or hex escaped character.
+		 * There will always enough room in sv since such escapes will
+		 * be longer than any utf8 sequence they can end up as
+		 */
+		if (uv > 127) {
+		    if (!thisutf && !has_utf && uv > 255) {
+		        /* might need to recode whatever we have accumulated so far
+			 * if it contains any hibit chars
+			 */
+		        int hicount = 0;
+			char *c;
+			for (c = SvPVX(sv); c < d; c++) {
+			    if (*c & 0x80)
+			        hicount++;
 			}
-			*d++ = (char)uv;
+			if (hicount) {
+			    char *old_pvx = SvPVX(sv);
+			    char *src, *dst;
+			    d = SvGROW(sv, SvCUR(sv) + hicount + 1) + (d - old_pvx);
+
+			    src = d - 1;
+			    d += hicount;
+			    dst = d - 1;
+
+			    while (src < dst) {
+			        if (*src & 0x80) {
+				    dst--;
+				    uv_to_utf8((U8*)dst, (U8)*src--);
+				    dst--;
+			        }
+			        else {
+				    *dst-- = *src--;
+			        }
+			    }
+                        }
+                    }
+
+                    if (thisutf || uv > 255) {
+		        d = (char*)uv_to_utf8((U8*)d, uv);
+			has_utf = TRUE;
+                    }
+		    else {
+		        *d++ = (char)uv;
 		    }
-		    s += len;
+		}
+		else {
+		    *d++ = (char)uv;
 		}
 		continue;
 
@@ -1389,12 +1466,9 @@ S_scan_const(pTHX_ char *start)
  		++s;
  		if (*s == '{') {
  		    char* e = strchr(s, '}');
- 		    HV *hv;
- 		    SV **svp;
- 		    SV *res, *cv;
+ 		    SV *res;
  		    STRLEN len;
  		    char *str;
- 		    char *why = Nullch;
  
  		    if (!e) {
 			yyerror("Missing right brace on \\N{}");
@@ -1405,6 +1479,14 @@ S_scan_const(pTHX_ char *start)
 		    res = new_constant( Nullch, 0, "charnames", 
 					res, Nullsv, "\\N{...}" );
 		    str = SvPV(res,len);
+		    if (!has_utf && SvUTF8(res)) {
+			char *ostart = SvPVX(sv);
+			SvCUR_set(sv, d - ostart);
+			SvPOK_on(sv);
+			sv_utf8_upgrade(sv);
+			d = SvPVX(sv) + SvCUR(sv);
+			has_utf = TRUE;
+		    }
 		    if (len > e - s + 4) {
 			char *odest = SvPVX(sv);
 
@@ -1428,7 +1510,8 @@ S_scan_const(pTHX_ char *start)
 		*d = *s++;
 		if (isLOWER(*d))
 		   *d = toUPPER(*d);
-		*d++ = toCTRL(*d); 
+		*d = toCTRL(*d); 
+		d++;
 #else
 		len = *s++;
 		*d++ = toCTRL(len);
@@ -1479,6 +1562,8 @@ S_scan_const(pTHX_ char *start)
     *d = '\0';
     SvCUR_set(sv, d - SvPVX(sv));
     SvPOK_on(sv);
+    if (has_utf)
+	SvUTF8_on(sv);
 
     /* shrink the sv if we allocated more than we used */
     if (SvCUR(sv) + 5 < SvLEN(sv)) {
@@ -1587,7 +1672,7 @@ S_intuit_more(pTHX_ register char *s)
 	    case '&':
 	    case '$':
 		weight -= seen[un_char] * 10;
-		if (isALNUM_lazy(s+1)) {
+		if (isALNUM_lazy_if(s+1,UTF)) {
 		    scan_ident(s, send, tmpbuf, sizeof tmpbuf, FALSE);
 		    if ((int)strlen(tmpbuf) > 1 && gv_fetchpv(tmpbuf,FALSE, SVt_PV))
 			weight -= 100;
@@ -1671,7 +1756,7 @@ S_intuit_more(pTHX_ register char *s)
  * Not a method if it's really "print foo $bar"
  * Method if it's really "foo package::" (interpreted as package->foo)
  * Not a method if bar is known to be a subroutne ("sub bar; foo bar")
- * Not a method if bar is a filehandle or package, but is quotd with
+ * Not a method if bar is a filehandle or package, but is quoted with
  *   =>
  */
 
@@ -1772,7 +1857,8 @@ S_incl_perldb(pTHX)
  * store private buffers and state information.
  *
  * The supplied datasv parameter is upgraded to a PVIO type
- * and the IoDIRP field is used to store the function pointer.
+ * and the IoDIRP field is used to store the function pointer,
+ * and IOf_FAKE_DIRP is enabled on datasv to mark this as such.
  * Note that IoTOP_NAME, IoFMT_NAME, IoBOTTOM_NAME, if set for
  * private use must be set using malloc'd pointers.
  */
@@ -1790,6 +1876,7 @@ Perl_filter_add(pTHX_ filter_t funcp, SV *datasv)
     if (!SvUPGRADE(datasv, SVt_PVIO))
         Perl_die(aTHX_ "Can't upgrade filter_add data to SVt_PVIO");
     IoDIRP(datasv) = (DIR*)funcp; /* stash funcp into spare field */
+    IoFLAGS(datasv) |= IOf_FAKE_DIRP;
     DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_add func %p (%s)\n",
 			  funcp, SvPV_nolen(datasv)));
     av_unshift(PL_rsfp_filters, 1);
@@ -1802,12 +1889,15 @@ Perl_filter_add(pTHX_ filter_t funcp, SV *datasv)
 void
 Perl_filter_del(pTHX_ filter_t funcp)
 {
+    SV *datasv;
     DEBUG_P(PerlIO_printf(Perl_debug_log, "filter_del func %p", funcp));
     if (!PL_rsfp_filters || AvFILLp(PL_rsfp_filters)<0)
 	return;
     /* if filter is on top of stack (usual case) just pop it off */
-    if (IoDIRP(FILTER_DATA(AvFILLp(PL_rsfp_filters))) == (DIR*)funcp){
-	IoDIRP(FILTER_DATA(AvFILLp(PL_rsfp_filters))) = NULL;
+    datasv = FILTER_DATA(AvFILLp(PL_rsfp_filters));
+    if (IoDIRP(datasv) == (DIR*)funcp) {
+	IoFLAGS(datasv) &= ~IOf_FAKE_DIRP;
+	IoDIRP(datasv) = (DIR*)NULL;
 	sv_free(av_pop(PL_rsfp_filters));
 
         return;
@@ -1880,9 +1970,9 @@ Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen)
 STATIC char *
 S_filter_gets(pTHX_ register SV *sv, register PerlIO *fp, STRLEN append)
 {
-#ifdef WIN32FILTER
+#ifdef PERL_CR_FILTER
     if (!PL_rsfp_filters) {
-	filter_add(win32_textfilter,NULL);
+	filter_add(S_cr_textfilter,NULL);
     }
 #endif
     if (PL_rsfp_filters) {
@@ -1965,6 +2055,10 @@ Perl_yylex(pTHX)
 	*/
 	if (PL_in_my) {
 	    if (PL_in_my == KEY_our) {	/* "our" is merely analogous to "my" */
+		if (strchr(PL_tokenbuf,':'))
+		    yyerror(Perl_form(aTHX_ "No package name allowed for "
+				      "variable %s in \"our\"",
+				      PL_tokenbuf));
 		tmp = pad_allocmy(PL_tokenbuf);
 	    }
 	    else {
@@ -2002,15 +2096,19 @@ Perl_yylex(pTHX)
 	    }
 #endif /* USE_THREADS */
 	    if ((tmp = pad_findmy(PL_tokenbuf)) != NOT_IN_PAD) {
+		SV *namesv = AvARRAY(PL_comppad_name)[tmp];
 		/* might be an "our" variable" */
-		if (SvFLAGS(AvARRAY(PL_comppad_name)[tmp]) & SVpad_OUR) {
+		if (SvFLAGS(namesv) & SVpad_OUR) {
 		    /* build ops for a bareword */
-		    yylval.opval = (OP*)newSVOP(OP_CONST, 0, newSVpv(PL_tokenbuf+1, 0));
+		    SV *sym = newSVpv(HvNAME(GvSTASH(namesv)),0);
+		    sv_catpvn(sym, "::", 2);
+		    sv_catpv(sym, PL_tokenbuf+1);
+		    yylval.opval = (OP*)newSVOP(OP_CONST, 0, sym);
 		    yylval.opval->op_private = OPpCONST_ENTERED;
-		    gv_fetchpv(PL_tokenbuf+1,
+		    gv_fetchpv(SvPVX(sym),
 			(PL_in_eval
-			    ? (GV_ADDMULTI | GV_ADDINEVAL | GV_ADDOUR)
-			    : GV_ADDOUR
+			    ? (GV_ADDMULTI | GV_ADDINEVAL)
+			    : TRUE
 			),
 			((PL_tokenbuf[0] == '$') ? SVt_PV
 			 : (PL_tokenbuf[0] == '@') ? SVt_PVAV
@@ -2266,7 +2364,7 @@ Perl_yylex(pTHX)
   retry:
     switch (*s) {
     default:
-	if (isIDFIRST_lazy(s))
+	if (isIDFIRST_lazy_if(s,UTF))
 	    goto keylookup;
 	Perl_croak(aTHX_ "Unrecognized character \\x%02X", *s & 255);
     case 4:
@@ -2338,7 +2436,7 @@ Perl_yylex(pTHX)
 
 		sv_upgrade(sv, SVt_PVMG);
 		sv_setsv(sv,PL_linestr);
-		av_store(CopFILEAV(PL_curcop),(I32)PL_curcop->cop_line,sv);
+		av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv);
 	    }
 	    goto retry;
 	}
@@ -2387,10 +2485,10 @@ Perl_yylex(pTHX)
 
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setsv(sv,PL_linestr);
-	    av_store(CopFILEAV(PL_curcop),(I32)PL_curcop->cop_line,sv);
+	    av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv);
 	}
 	PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
-	if (PL_curcop->cop_line == 1) {
+	if (CopLINE(PL_curcop) == 1) {
 	    while (s < PL_bufend && isSPACE(*s))
 		s++;
 	    if (*s == ':' && s[1] != ':') /* for csh execing sh scripts */
@@ -2478,7 +2576,6 @@ Perl_yylex(pTHX)
 			*s = '#';	/* Don't try to parse shebang line */
 		}
 #endif /* ALTERNATE_SHEBANG */
-#ifndef MACOS_TRADITIONAL
 		if (!d &&
 		    *s == '#' &&
 		    ipathend > ipath &&
@@ -2506,14 +2603,13 @@ Perl_yylex(pTHX)
 		    PerlProc_execv(ipath, newargv);
 		    Perl_croak(aTHX_ "Can't exec %s", ipath);
 		}
-#endif
 		if (d) {
 		    U32 oldpdb = PL_perldb;
 		    bool oldn = PL_minus_n;
 		    bool oldp = PL_minus_p;
 
 		    while (*d && !isSPACE(*d)) d++;
-		    while (SPACE_OR_TAB(*d)) d++;
+		    while (*d == ' ' || *d == '\t') d++;
 
 		    if (*d++ == '-') {
 			do {
@@ -2525,8 +2621,8 @@ Perl_yylex(pTHX)
 			    }
 			    d = moreswitches(d);
 			} while (d);
-			if (PERLDB_LINE && !oldpdb ||
-			    ( PL_minus_n || PL_minus_p ) && !(oldn || oldp) )
+			if ((PERLDB_LINE && !oldpdb) ||
+			    ((PL_minus_n || PL_minus_p) && !(oldn || oldp)))
 			      /* if we have already added "LINE: while (<>) {",
 			         we must not do it again */
 			{
@@ -2552,17 +2648,19 @@ Perl_yylex(pTHX)
 #ifdef PERL_STRICT_CR
 	Perl_warn(aTHX_ "Illegal character \\%03o (carriage return)", '\r');
 	Perl_croak(aTHX_ 
-      "(Maybe you didn't strip carriage returns after a network transfer?)\n");
+      "\t(Maybe you didn't strip carriage returns after a network transfer?)\n");
 #endif
     case ' ': case '\t': case '\f': case 013:
-#ifdef MACOS_TRADITIONAL
-    case '\312': /* Them nonbreaking spaces again */
-#endif
 	s++;
 	goto retry;
     case '#':
     case '\n':
 	if (PL_lex_state != LEX_NORMAL || (PL_in_eval && !PL_rsfp)) {
+	    if (*s == '#' && s == PL_linestart && PL_in_eval && !PL_rsfp) {
+		/* handle eval qq[#line 1 "foo"\n ...] */
+		CopLINE_dec(PL_curcop);
+		incline(s);
+	    }
 	    d = PL_bufend;
 	    while (s < d && *s != '\n')
 		s++;
@@ -2586,7 +2684,7 @@ Perl_yylex(pTHX)
 	    PL_bufptr = s;
 	    tmp = *s++;
 
-	    while (s < PL_bufend && SPACE_OR_TAB(*s))
+	    while (s < PL_bufend && (*s == ' ' || *s == '\t'))
 		s++;
 
 	    if (strnEQ(s,"=>",2)) {
@@ -2639,7 +2737,7 @@ Perl_yylex(pTHX)
 	else if (*s == '>') {
 	    s++;
 	    s = skipspace(s);
-	    if (isIDFIRST_lazy(s)) {
+	    if (isIDFIRST_lazy_if(s,UTF)) {
 		s = force_word(s,METHOD,FALSE,TRUE,FALSE);
 		TOKEN(ARROW);
 	    }
@@ -2735,8 +2833,23 @@ Perl_yylex(pTHX)
 	 grabattrs:
 	    s = skipspace(s);
 	    attrs = Nullop;
-	    while (isIDFIRST_lazy(s)) {
+	    while (isIDFIRST_lazy_if(s,UTF)) {
 		d = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len);
+		if (isLOWER(*s) && (tmp = keyword(PL_tokenbuf, len))) {
+		    if (tmp < 0) tmp = -tmp;
+		    switch (tmp) {
+		    case KEY_or:
+		    case KEY_and:
+		    case KEY_for:
+		    case KEY_unless:
+		    case KEY_if:
+		    case KEY_while:
+		    case KEY_until:
+			goto got_attrs;
+		    default:
+			break;
+		    }
+		}
 		if (*d == '(') {
 		    d = scan_str(d,TRUE,TRUE);
 		    if (!d) {
@@ -2768,11 +2881,13 @@ Perl_yylex(pTHX)
 						newSVpvn(s, len)));
 		}
 		s = skipspace(d);
-		while (*s == ',')
+		if (*s == ':' && s[1] != ':')
 		    s = skipspace(s+1);
+		else if (s == d)
+		    break;	/* require real whitespace or :'s */
 	    }
-	    tmp = (PL_expect == XOPERATOR ? '=' : '{'); /*'}' for vi */
-	    if (*s != ';' && *s != tmp) {
+	    tmp = (PL_expect == XOPERATOR ? '=' : '{'); /*'}(' for vi */
+	    if (*s != ';' && *s != tmp && (tmp != '=' || *s != ')')) {
 		char q = ((*s == '\'') ? '"' : '\'');
 		/* If here for an expression, and parsed no attrs, back off. */
 		if (tmp == '=' && !attrs) {
@@ -2792,6 +2907,7 @@ Perl_yylex(pTHX)
 		    op_free(attrs);
 		OPERATOR(':');
 	    }
+	got_attrs:
 	    if (attrs) {
 		PL_nextval[PL_nexttoke].opval = attrs;
 		force_next(THING);
@@ -2807,8 +2923,8 @@ Perl_yylex(pTHX)
 	    PL_expect = XTERM;
 	TOKEN('(');
     case ';':
-	if (PL_curcop->cop_line < PL_copline)
-	    PL_copline = PL_curcop->cop_line;
+	if (CopLINE(PL_curcop) < PL_copline)
+	    PL_copline = CopLINE(PL_curcop);
 	tmp = *s++;
 	OPERATOR(tmp);
     case ')':
@@ -2852,20 +2968,20 @@ Perl_yylex(pTHX)
 		PL_lex_brackstack[PL_lex_brackets++] = XOPERATOR;
 	    OPERATOR(HASHBRACK);
 	case XOPERATOR:
-	    while (s < PL_bufend && SPACE_OR_TAB(*s))
+	    while (s < PL_bufend && (*s == ' ' || *s == '\t'))
 		s++;
 	    d = s;
 	    PL_tokenbuf[0] = '\0';
 	    if (d < PL_bufend && *d == '-') {
 		PL_tokenbuf[0] = '-';
 		d++;
-		while (d < PL_bufend && SPACE_OR_TAB(*d))
+		while (d < PL_bufend && (*d == ' ' || *d == '\t'))
 		    d++;
 	    }
-	    if (d < PL_bufend && isIDFIRST_lazy(d)) {
+	    if (d < PL_bufend && isIDFIRST_lazy_if(d,UTF)) {
 		d = scan_word(d, PL_tokenbuf + 1, sizeof PL_tokenbuf - 1,
 			      FALSE, &len);
-		while (d < PL_bufend && SPACE_OR_TAB(*d))
+		while (d < PL_bufend && (*d == ' ' || *d == '\t'))
 		    d++;
 		if (*d == '}') {
 		    char minus = (PL_tokenbuf[0] == '-');
@@ -2921,7 +3037,8 @@ Perl_yylex(pTHX)
 		    if (++t < PL_bufend
 			&& (!isALNUM(*t)
 			    || ((*t == 'q' || *t == 'x') && ++t < PL_bufend
-				&& !isALNUM(*t)))) {
+				&& !isALNUM(*t))))
+		    {
 			char *tmps;
 			char open, close, term;
 			I32 brackets = 1;
@@ -2952,8 +3069,10 @@ Perl_yylex(pTHX)
 		    }
 		    t++;
 		}
-		else if (isIDFIRST_lazy(s)) {
-		    for (t++; t < PL_bufend && isALNUM_lazy(t); t++) ;
+		else if (isALNUM_lazy_if(t,UTF)) {
+		    t += UTF8SKIP(t);
+		    while (t < PL_bufend && isALNUM_lazy_if(t,UTF))
+			 t += UTF8SKIP(t);
 		}
 		while (t < PL_bufend && isSPACE(*t))
 		    t++;
@@ -2971,7 +3090,7 @@ Perl_yylex(pTHX)
 	    }
 	    break;
 	}
-	yylval.ival = PL_curcop->cop_line;
+	yylval.ival = CopLINE(PL_curcop);
 	if (isSPACE(*s) || *s == '#')
 	    PL_copline = NOLINE;   /* invalidate current command line number */
 	TOKEN('{');
@@ -2986,7 +3105,8 @@ Perl_yylex(pTHX)
 	    PL_lex_formbrack = 0;
 	if (PL_lex_state == LEX_INTERPNORMAL) {
 	    if (PL_lex_brackets == 0) {
-		if (PL_lex_fakebrack) {
+		if (PL_expect & XFAKEBRACK) {
+		    PL_expect &= XENUMMASK;
 		    PL_lex_state = LEX_INTERPEND;
 		    PL_bufptr = s;
 		    return yylex();	/* ignore fake brackets */
@@ -2997,9 +3117,9 @@ Perl_yylex(pTHX)
 		    PL_lex_state = LEX_INTERPEND;
 	    }
 	}
-	if (PL_lex_brackets < PL_lex_fakebrack) {
+	if (PL_expect & XFAKEBRACK) {
+	    PL_expect &= XENUMMASK;
 	    PL_bufptr = s;
-	    PL_lex_fakebrack = 0;
 	    return yylex();		/* ignore fake brackets */
 	}
 	force_next('}');
@@ -3011,10 +3131,12 @@ Perl_yylex(pTHX)
 	    AOPERATOR(ANDAND);
 	s--;
 	if (PL_expect == XOPERATOR) {
-	    if (ckWARN(WARN_SEMICOLON) && isIDFIRST_lazy(s) && PL_bufptr == PL_linestart) {
-		PL_curcop->cop_line--;
+	    if (ckWARN(WARN_SEMICOLON)
+		&& isIDFIRST_lazy_if(s,UTF) && PL_bufptr == PL_linestart)
+	    {
+		CopLINE_dec(PL_curcop);
 		Perl_warner(aTHX_ WARN_SEMICOLON, PL_warn_nosemi);
-		PL_curcop->cop_line++;
+		CopLINE_inc(PL_curcop);
 	    }
 	    BAop(OP_BIT_AND);
 	}
@@ -3076,9 +3198,9 @@ Perl_yylex(pTHX)
 	if (PL_lex_brackets < PL_lex_formbrack) {
 	    char *t;
 #ifdef PERL_STRICT_CR
-	    for (t = s; SPACE_OR_TAB(*t); t++) ;
+	    for (t = s; *t == ' ' || *t == '\t'; t++) ;
 #else
-	    for (t = s; SPACE_OR_TAB(*t) || *t == '\r'; t++) ;
+	    for (t = s; *t == ' ' || *t == '\t' || *t == '\r'; t++) ;
 #endif
 	    if (*t == '\n' || *t == '#') {
 		s--;
@@ -3141,7 +3263,7 @@ Perl_yylex(pTHX)
 	    }
 	}
 
-	if (s[1] == '#' && (isIDFIRST_lazy(s+2) || strchr("{$:+-", s[2]))) {
+	if (s[1] == '#' && (isIDFIRST_lazy_if(s+2,UTF) || strchr("{$:+-", s[2]))) {
 	    PL_tokenbuf[0] = '@';
 	    s = scan_ident(s + 1, PL_bufend, PL_tokenbuf + 1,
 			   sizeof PL_tokenbuf - 1, FALSE);
@@ -3168,7 +3290,7 @@ Perl_yylex(pTHX)
 	/* This kludge not intended to be bulletproof. */
 	if (PL_tokenbuf[1] == '[' && !PL_tokenbuf[2]) {
 	    yylval.opval = newSVOP(OP_CONST, 0,
-				   newSViv((IV)PL_compiling.cop_arybase));
+				   newSViv(PL_compiling.cop_arybase));
 	    yylval.opval->op_private = OPpCONST_ARYBASE;
 	    TERM(THING);
 	}
@@ -3184,7 +3306,7 @@ Perl_yylex(pTHX)
 		PL_tokenbuf[0] = '@';
 		if (ckWARN(WARN_SYNTAX)) {
 		    for(t = s + 1;
-			isSPACE(*t) || isALNUM_lazy(t) || *t == '$';
+			isSPACE(*t) || isALNUM_lazy_if(t,UTF) || *t == '$';
 			t++) ;
 		    if (*t++ == ',') {
 			PL_bufptr = skipspace(PL_bufptr);
@@ -3204,7 +3326,7 @@ Perl_yylex(pTHX)
 		    char tmpbuf[sizeof PL_tokenbuf];
 		    STRLEN len;
 		    for (t++; isSPACE(*t); t++) ;
-		    if (isIDFIRST_lazy(t)) {
+		    if (isIDFIRST_lazy_if(t,UTF)) {
 			t = scan_word(t, tmpbuf, sizeof tmpbuf, TRUE, &len);
 		        for (; isSPACE(*t); t++) ;
 			if (*t == ';' && get_cv(tmpbuf, FALSE))
@@ -3222,12 +3344,12 @@ Perl_yylex(pTHX)
 		PL_expect = XOPERATOR;
 	    else if (strchr("$@\"'`q", *s))
 		PL_expect = XTERM;		/* e.g. print $fh "foo" */
-	    else if (strchr("&*<%", *s) && isIDFIRST_lazy(s+1))
+	    else if (strchr("&*<%", *s) && isIDFIRST_lazy_if(s+1,UTF))
 		PL_expect = XTERM;		/* e.g. print $fh &sub */
-	    else if (isIDFIRST_lazy(s)) {
+	    else if (isIDFIRST_lazy_if(s,UTF)) {
 		char tmpbuf[sizeof PL_tokenbuf];
 		scan_word(s, tmpbuf, sizeof tmpbuf, TRUE, &len);
-		if (tmp = keyword(tmpbuf, len)) {
+		if ((tmp = keyword(tmpbuf, len))) {
 		    /* binary operators exclude handle interpretations */
 		    switch (tmp) {
 		    case -KEY_x:
@@ -3282,7 +3404,7 @@ Perl_yylex(pTHX)
 	    if (ckWARN(WARN_SYNTAX)) {
 		if (*s == '[' || *s == '{') {
 		    char *t = s + 1;
-		    while (*t && (isALNUM_lazy(t) || strchr(" \t$#+-'\"", *t)))
+		    while (*t && (isALNUM_lazy_if(t,UTF) || strchr(" \t$#+-'\"", *t)))
 			t++;
 		    if (*t == '}' || *t == ']') {
 			t++;
@@ -3303,7 +3425,8 @@ Perl_yylex(pTHX)
 	    /* Disable warning on "study /blah/" */
 	    if (PL_oldoldbufptr == PL_last_uni 
 		&& (*PL_last_uni != 's' || s - PL_last_uni < 5 
-		    || memNE(PL_last_uni, "study", 5) || isALNUM_lazy(PL_last_uni+5)))
+		    || memNE(PL_last_uni, "study", 5)
+		    || isALNUM_lazy_if(PL_last_uni+5,UTF)))
 		check_uni();
 	    s = scan_pat(s,OP_MATCH);
 	    TERM(sublex_start());
@@ -3407,6 +3530,31 @@ Perl_yylex(pTHX)
 	    no_op("Backslash",s);
 	OPERATOR(REFGEN);
 
+    case 'v':
+	if (isDIGIT(s[1]) && PL_expect != XOPERATOR) {
+	    char *start = s;
+	    start++;
+	    start++;
+	    while (isDIGIT(*start) || *start == '_')
+		start++;
+	    if (*start == '.' && isDIGIT(start[1])) {
+		s = scan_num(s);
+		TERM(THING);
+	    }
+	    /* avoid v123abc() or $h{v1}, allow C<print v10;> */
+	    else if (!isALPHA(*start) && (PL_expect == XTERM || PL_expect == XREF)) {
+		char c = *start;
+		GV *gv;
+		*start = '\0';
+		gv = gv_fetchpv(s, FALSE, SVt_PVCV);
+		*start = c;
+		if (!gv) {
+		    s = scan_num(s);
+		    TERM(THING);
+		}
+	    }
+	}
+	goto keylookup;
     case 'x':
 	if (isDIGIT(s[1]) && PL_expect == XOPERATOR) {
 	    s++;
@@ -3436,14 +3584,13 @@ Perl_yylex(pTHX)
     case 's': case 'S':
     case 't': case 'T':
     case 'u': case 'U':
-    case 'v': case 'V':
+	      case 'V':
     case 'w': case 'W':
 	      case 'X':
     case 'y': case 'Y':
     case 'z': case 'Z':
 
       keylookup: {
-	STRLEN n_a;
 	gv = Nullgv;
 	gvp = 0;
 
@@ -3451,10 +3598,10 @@ Perl_yylex(pTHX)
 	s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len);
 
 	/* Some keywords can be followed by any delimiter, including ':' */
-	tmp = (len == 1 && strchr("msyq", PL_tokenbuf[0]) ||
-	       len == 2 && ((PL_tokenbuf[0] == 't' && PL_tokenbuf[1] == 'r') ||
-			    (PL_tokenbuf[0] == 'q' &&
-			     strchr("qwxr", PL_tokenbuf[1]))));
+	tmp = ((len == 1 && strchr("msyq", PL_tokenbuf[0])) ||
+	       (len == 2 && ((PL_tokenbuf[0] == 't' && PL_tokenbuf[1] == 'r') ||
+			     (PL_tokenbuf[0] == 'q' &&
+			      strchr("qwxr", PL_tokenbuf[1])))));
 
 	/* x::* is just a word, unless x is "CORE" */
 	if (!tmp && *s == ':' && s[1] == ':' && strNE(PL_tokenbuf, "CORE"))
@@ -3477,7 +3624,7 @@ Perl_yylex(pTHX)
 	tmp = keyword(PL_tokenbuf, len);
 
 	/* Is this a word before a => operator? */
-	if (strnEQ(d,"=>",2)) {
+	if (*d == '=' && d[1] == '>') {
 	    CLINE;
 	    yylval.opval = (OP*)newSVOP(OP_CONST, 0, newSVpv(PL_tokenbuf,0));
 	    yylval.opval->op_private = OPpCONST_BARE;
@@ -3510,6 +3657,7 @@ Perl_yylex(pTHX)
 	    }
 	    else if (gv && !gvp
 		     && -tmp==KEY_lock	/* XXX generalizable kludge */
+		     && GvCVu(gv)
 		     && !hv_fetch(GvHVn(PL_incgv), "Thread.pm", 9, FALSE))
 	    {
 		tmp = 0;		/* any sub overrides "weak" keyword */
@@ -3536,7 +3684,7 @@ Perl_yylex(pTHX)
 
 		/* Get the rest if it looks like a package qualifier */
 
-		if (*s == '\'' || *s == ':' && s[1] == ':') {
+		if (*s == '\'' || (*s == ':' && s[1] == ':')) {
 		    STRLEN morelen;
 		    s = scan_word(s, PL_tokenbuf + len, sizeof PL_tokenbuf - len,
 				  TRUE, &morelen);
@@ -3548,9 +3696,9 @@ Perl_yylex(pTHX)
 
 		if (PL_expect == XOPERATOR) {
 		    if (PL_bufptr == PL_linestart) {
-			PL_curcop->cop_line--;
+			CopLINE_dec(PL_curcop);
 			Perl_warner(aTHX_ WARN_SEMICOLON, PL_warn_nosemi);
-			PL_curcop->cop_line++;
+			CopLINE_inc(PL_curcop);
 		    }
 		    else
 			no_op("Bareword",s);
@@ -3563,8 +3711,8 @@ Perl_yylex(pTHX)
 		if (len > 2 &&
 		    PL_tokenbuf[len - 2] == ':' && PL_tokenbuf[len - 1] == ':')
 		{
-		    if (ckWARN(WARN_UNSAFE) && ! gv_fetchpv(PL_tokenbuf, FALSE, SVt_PVHV))
-			Perl_warner(aTHX_ WARN_UNSAFE, 
+		    if (ckWARN(WARN_BAREWORD) && ! gv_fetchpv(PL_tokenbuf, FALSE, SVt_PVHV))
+			Perl_warner(aTHX_ WARN_BAREWORD, 
 		  	    "Bareword \"%s\" refers to nonexistent package",
 			     PL_tokenbuf);
 		    len -= 2;
@@ -3615,7 +3763,7 @@ Perl_yylex(pTHX)
 
 		    /* Two barewords in a row may indicate method call. */
 
-		    if ((isIDFIRST_lazy(s) || *s == '$') && (tmp=intuit_method(s,gv)))
+		    if ((isIDFIRST_lazy_if(s,UTF) || *s == '$') && (tmp=intuit_method(s,gv)))
 			return tmp;
 
 		    /* If not a declared subroutine, it's an indirect object. */
@@ -3631,14 +3779,22 @@ Perl_yylex(pTHX)
 		    }
 		}
 
-		/* If followed by a paren, it's certainly a subroutine. */
 
 		PL_expect = XOPERATOR;
 		s = skipspace(s);
+
+		/* Is this a word before a => operator? */
+		if (*s == '=' && s[1] == '>') {
+		    CLINE;
+		    sv_setpv(((SVOP*)yylval.opval)->op_sv, PL_tokenbuf);
+		    TERM(WORD);
+		}
+
+		/* If followed by a paren, it's certainly a subroutine. */
 		if (*s == '(') {
 		    CLINE;
 		    if (gv && GvCVu(gv)) {
-			for (d = s + 1; SPACE_OR_TAB(*d); d++) ;
+			for (d = s + 1; *d == ' ' || *d == '\t'; d++) ;
 			if (*d == ')' && (sv = cv_const_sv(GvCV(gv)))) {
 			    s = d + 1;
 			    goto its_constant;
@@ -3661,7 +3817,7 @@ Perl_yylex(pTHX)
 
 		/* If followed by a bareword, see if it looks like indir obj. */
 
-		if ((isIDFIRST_lazy(s) || *s == '$') && (tmp = intuit_method(s,gv)))
+		if ((isIDFIRST_lazy_if(s,UTF) || *s == '$') && (tmp = intuit_method(s,gv)))
 		    return tmp;
 
 		/* Not a method, so call it a subroutine (if defined) */
@@ -3737,12 +3893,12 @@ Perl_yylex(pTHX)
 
 	case KEY___FILE__:
 	    yylval.opval = (OP*)newSVOP(OP_CONST, 0,
-					newSVsv(CopFILESV(PL_curcop)));
+					newSVpv(CopFILE(PL_curcop),0));
 	    TERM(THING);
 
 	case KEY___LINE__:
             yylval.opval = (OP*)newSVOP(OP_CONST, 0,
-                                    Perl_newSVpvf(aTHX_ "%"IVdf, (IV)PL_curcop->cop_line));
+                                    Perl_newSVpvf(aTHX_ "%"IVdf, (IV)CopLINE(PL_curcop)));
 	    TERM(THING);
 
 	case KEY___PACKAGE__:
@@ -3780,6 +3936,28 @@ Perl_yylex(pTHX)
 		    IoTYPE(GvIOp(gv)) = '-';
 		else
 		    IoTYPE(GvIOp(gv)) = '<';
+#if defined(WIN32) && !defined(PERL_TEXTMODE_SCRIPTS)
+		/* if the script was opened in binmode, we need to revert
+		 * it to text mode for compatibility; but only iff it has CRs
+		 * XXX this is a questionable hack at best. */
+		if (PL_bufend-PL_bufptr > 2
+		    && PL_bufend[-1] == '\n' && PL_bufend[-2] == '\r')
+		{
+		    Off_t loc = 0;
+		    if (IoTYPE(GvIOp(gv)) == '<') {
+			loc = PerlIO_tell(PL_rsfp);
+			(void)PerlIO_seek(PL_rsfp, 0L, 0);
+		    }
+		    if (PerlLIO_setmode(PerlIO_fileno(PL_rsfp), O_TEXT) != -1) {
+#if defined(__BORLANDC__)
+			/* XXX see note in do_binmode() */
+			((FILE*)PL_rsfp)->flags |= _F_BIN;
+#endif
+			if (loc > 0)
+			    PerlIO_seek(PL_rsfp, loc, 0);
+		    }
+		}
+#endif
 		PL_rsfp = Nullfp;
 	    }
 	    goto fake_eof;
@@ -3788,9 +3966,9 @@ Perl_yylex(pTHX)
 	case KEY_AUTOLOAD:
 	case KEY_DESTROY:
 	case KEY_BEGIN:
-	case KEY_END:
-	case KEY_STOP:
+	case KEY_CHECK:
 	case KEY_INIT:
+	case KEY_END:
 	    if (PL_expect == XSTATE) {
 		s = PL_bufptr;
 		goto really_sub;
@@ -3802,7 +3980,8 @@ Perl_yylex(pTHX)
 		s += 2;
 		d = s;
 		s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len);
-		tmp = keyword(PL_tokenbuf, len);
+		if (!(tmp = keyword(PL_tokenbuf, len)))
+		    Perl_croak(aTHX_ "CORE::%s is not a keyword", PL_tokenbuf);
 		if (tmp < 0)
 		    tmp = -tmp;
 		goto reserved_word;
@@ -3828,7 +4007,7 @@ Perl_yylex(pTHX)
 	    LOP(OP_BIND,XTERM);
 
 	case KEY_binmode:
-	    UNI(OP_BINMODE);
+	    LOP(OP_BINMODE,XTERM);
 
 	case KEY_bless:
 	    LOP(OP_BLESS,XTERM);
@@ -3865,11 +4044,11 @@ Perl_yylex(pTHX)
 	    LOP(OP_CRYPT,XTERM);
 
 	case KEY_chmod:
-	    if (ckWARN(WARN_OCTAL)) {
+	    if (ckWARN(WARN_CHMOD)) {
 		for (d = s; d < PL_bufend && (isSPACE(*d) || *d == '('); d++) ;
 		if (*d != '0' && isDIGIT(*d))
-		    Perl_warner(aTHX_ WARN_OCTAL,
-		    		"chmod: mode argument is missing initial 0");
+		    Perl_warner(aTHX_ WARN_CHMOD,
+		    		"chmod() mode argument is missing initial 0");
 	    }
 	    LOP(OP_CHMOD,XTERM);
 
@@ -3921,7 +4100,7 @@ Perl_yylex(pTHX)
 	    PREBLOCK(ELSE);
 
 	case KEY_elsif:
-	    yylval.ival = PL_curcop->cop_line;
+	    yylval.ival = CopLINE(PL_curcop);
 	    OPERATOR(ELSIF);
 
 	case KEY_eq:
@@ -3971,9 +4150,9 @@ Perl_yylex(pTHX)
 
 	case KEY_for:
 	case KEY_foreach:
-	    yylval.ival = PL_curcop->cop_line;
+	    yylval.ival = CopLINE(PL_curcop);
 	    s = skipspace(s);
-	    if (PL_expect == XSTATE && isIDFIRST_lazy(s)) {
+	    if (PL_expect == XSTATE && isIDFIRST_lazy_if(s,UTF)) {
 		char *p = s;
 		if ((PL_bufend - p) >= 3 &&
 		    strnEQ(p, "my", 2) && isSPACE(*(p + 2)))
@@ -3982,7 +4161,7 @@ Perl_yylex(pTHX)
 		    strnEQ(p, "our", 3) && isSPACE(*(p + 3)))
 		    p += 3;
 		p = skipspace(p);
-		if (isIDFIRST_lazy(p)) {
+		if (isIDFIRST_lazy_if(p,UTF)) {
 		    p = scan_ident(p, PL_bufend,
 			PL_tokenbuf, sizeof PL_tokenbuf, TRUE);
 		    p = skipspace(p);
@@ -4014,7 +4193,7 @@ Perl_yylex(pTHX)
 	    Rop(OP_SGE);
 
 	case KEY_grep:
-	    LOP(OP_GREPSTART, *s == '(' ? XTERM : XREF);
+	    LOP(OP_GREPSTART, XREF);
 
 	case KEY_goto:
 	    s = force_word(s,WORD,TRUE,FALSE,FALSE);
@@ -4109,7 +4288,7 @@ Perl_yylex(pTHX)
 	    UNI(OP_HEX);
 
 	case KEY_if:
-	    yylval.ival = PL_curcop->cop_line;
+	    yylval.ival = CopLINE(PL_curcop);
 	    OPERATOR(IF);
 
 	case KEY_index:
@@ -4176,7 +4355,7 @@ Perl_yylex(pTHX)
 	    TERM(sublex_start());
 
 	case KEY_map:
-	    LOP(OP_MAPSTART, *s == '(' ? XTERM : XREF);
+	    LOP(OP_MAPSTART, XREF);
 
 	case KEY_mkdir:
 	    LOP(OP_MKDIR,XTERM);
@@ -4197,7 +4376,7 @@ Perl_yylex(pTHX)
 	case KEY_my:
 	    PL_in_my = tmp;
 	    s = skipspace(s);
-	    if (isIDFIRST_lazy(s)) {
+	    if (isIDFIRST_lazy_if(s,UTF)) {
 		s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, TRUE, &len);
 		if (len == 3 && strnEQ(PL_tokenbuf, "sub", 3))
 		    goto really_sub;
@@ -4235,12 +4414,12 @@ Perl_yylex(pTHX)
 
 	case KEY_open:
 	    s = skipspace(s);
-	    if (isIDFIRST_lazy(s)) {
+	    if (isIDFIRST_lazy_if(s,UTF)) {
 		char *t;
-		for (d = s; isALNUM_lazy(d); d++) ;
+		for (d = s; isALNUM_lazy_if(d,UTF); d++) ;
 		t = skipspace(d);
-		if (strchr("|&*+-=!?:.", *t) && ckWARN_d(WARN_AMBIGUOUS))
-		    Perl_warner(aTHX_ WARN_AMBIGUOUS,
+		if (strchr("|&*+-=!?:.", *t) && ckWARN_d(WARN_PRECEDENCE))
+		    Perl_warner(aTHX_ WARN_PRECEDENCE,
 			   "Precedence problem: open %.*s should be open(%.*s)",
 			    d-s,s, d-s,s);
 	    }
@@ -4312,15 +4491,15 @@ Perl_yylex(pTHX)
 		    for (; isSPACE(*d) && len; --len, ++d) ;
 		    if (len) {
 			char *b = d;
-			if (!warned && ckWARN(WARN_SYNTAX)) {
+			if (!warned && ckWARN(WARN_QW)) {
 			    for (; !isSPACE(*d) && len; --len, ++d) {
 				if (*d == ',') {
-				    Perl_warner(aTHX_ WARN_SYNTAX,
+				    Perl_warner(aTHX_ WARN_QW,
 					"Possible attempt to separate words with commas");
 				    ++warned;
 				}
 				else if (*d == '#') {
-				    Perl_warner(aTHX_ WARN_SYNTAX,
+				    Perl_warner(aTHX_ WARN_QW,
 					"Possible attempt to put comments in qw() list");
 				    ++warned;
 				}
@@ -4330,7 +4509,7 @@ Perl_yylex(pTHX)
 			    for (; !isSPACE(*d) && len; --len, ++d) ;
 			}
 			words = append_elem(OP_LIST, words,
-					    newSVOP(OP_CONST, 0, newSVpvn(b, d-b)));
+					    newSVOP(OP_CONST, 0, tokeq(newSVpvn(b, d-b))));
 		    }
 		}
 		if (words) {
@@ -4369,12 +4548,18 @@ Perl_yylex(pTHX)
 	    OLDLOP(OP_RETURN);
 
 	case KEY_require:
-	    *PL_tokenbuf = '\0';
-	    s = force_word(s,WORD,TRUE,TRUE,FALSE);
-	    if (isIDFIRST_lazy(PL_tokenbuf))
-		gv_stashpvn(PL_tokenbuf, strlen(PL_tokenbuf), TRUE);
-	    else if (*s == '<')
-		yyerror("<> should be quotes");
+	    s = skipspace(s);
+	    if (isDIGIT(*s) || (*s == 'v' && isDIGIT(s[1]))) {
+		s = force_version(s);
+	    }
+	    else {
+		*PL_tokenbuf = '\0';
+		s = force_word(s,WORD,TRUE,TRUE,FALSE);
+		if (isIDFIRST_lazy_if(PL_tokenbuf,UTF))
+		    gv_stashpvn(PL_tokenbuf, strlen(PL_tokenbuf), TRUE);
+		else if (*s == '<')
+		    yyerror("<> should be quotes");
+	    }
 	    UNI(OP_REQUIRE);
 
 	case KEY_reset:
@@ -4561,7 +4746,7 @@ Perl_yylex(pTHX)
 
 		s = skipspace(s);
 
-		if (isIDFIRST_lazy(s) || *s == '\'' ||
+		if (isIDFIRST_lazy_if(s,UTF) || *s == '\'' ||
 		    (*s == ':' && s[1] == ':'))
 		{
 		    PL_expect = XBLOCK;
@@ -4701,11 +4886,11 @@ Perl_yylex(pTHX)
 	    UNI(OP_UNTIE);
 
 	case KEY_until:
-	    yylval.ival = PL_curcop->cop_line;
+	    yylval.ival = CopLINE(PL_curcop);
 	    OPERATOR(UNTIL);
 
 	case KEY_unless:
-	    yylval.ival = PL_curcop->cop_line;
+	    yylval.ival = CopLINE(PL_curcop);
 	    OPERATOR(UNLESS);
 
 	case KEY_unlink:
@@ -4721,10 +4906,10 @@ Perl_yylex(pTHX)
 	    LOP(OP_UTIME,XTERM);
 
 	case KEY_umask:
-	    if (ckWARN(WARN_OCTAL)) {
+	    if (ckWARN(WARN_UMASK)) {
 		for (d = s; d < PL_bufend && (isSPACE(*d) || *d == '('); d++) ;
 		if (*d != '0' && isDIGIT(*d)) 
-		    Perl_warner(aTHX_ WARN_OCTAL,
+		    Perl_warner(aTHX_ WARN_UMASK,
 		    		"umask: argument is missing initial 0");
 	    }
 	    UNI(OP_UMASK);
@@ -4736,9 +4921,9 @@ Perl_yylex(pTHX)
 	    if (PL_expect != XSTATE)
 		yyerror("\"use\" not allowed in expression");
 	    s = skipspace(s);
-	    if(isDIGIT(*s)) {
+	    if (isDIGIT(*s) || (*s == 'v' && isDIGIT(s[1]))) {
 		s = force_version(s);
-		if(*s == ';' || (s = skipspace(s), *s == ';')) {
+		if (*s == ';' || (s = skipspace(s), *s == ';')) {
 		    PL_nextval[PL_nexttoke].opval = Nullop;
 		    force_next(WORD);
 		}
@@ -4757,7 +4942,7 @@ Perl_yylex(pTHX)
 	    LOP(OP_VEC,XTERM);
 
 	case KEY_while:
-	    yylval.ival = PL_curcop->cop_line;
+	    yylval.ival = CopLINE(PL_curcop);
 	    OPERATOR(WHILE);
 
 	case KEY_warn:
@@ -4845,6 +5030,7 @@ Perl_keyword(pTHX_ register char *d, I32 len)
 	break;
     case 'C':
 	if (strEQ(d,"CORE"))			return -KEY_CORE;
+	if (strEQ(d,"CHECK"))			return KEY_CHECK;
 	break;
     case 'c':
 	switch (len) {
@@ -5228,9 +5414,6 @@ Perl_keyword(pTHX_ register char *d, I32 len)
 	    break;
 	}
 	break;
-    case 'S':
-	if (strEQ(d,"STOP"))			return KEY_STOP;
-	break;
     case 's':
 	switch (d[1]) {
 	case 0:					return KEY_s;
@@ -5453,9 +5636,9 @@ S_checkcomma(pTHX_ register char *s, char *name, char *what)
 	s++;
     while (s < PL_bufend && isSPACE(*s))
 	s++;
-    if (isIDFIRST_lazy(s)) {
+    if (isIDFIRST_lazy_if(s,UTF)) {
 	w = s++;
-	while (isALNUM_lazy(s))
+	while (isALNUM_lazy_if(s,UTF))
 	    s++;
 	while (s < PL_bufend && isSPACE(*s))
 	    s++;
@@ -5478,37 +5661,35 @@ S_checkcomma(pTHX_ register char *s, char *name, char *what)
 
 STATIC SV *
 S_new_constant(pTHX_ char *s, STRLEN len, const char *key, SV *sv, SV *pv,
-	       const char *type) 
+	       const char *type)
 {
     dSP;
     HV *table = GvHV(PL_hintgv);		 /* ^H */
     SV *res;
     SV **cvp;
     SV *cv, *typesv;
-    const char *why, *why1, *why2;
+    const char *why1, *why2, *why3;
     
-    if (!(PL_hints & HINT_LOCALIZE_HH)) {
+    if (!table || !(PL_hints & HINT_LOCALIZE_HH)) {
 	SV *msg;
 	
-	why = "%^H is not localized";
-    report_short:
-	why1 = why2 = "";
+	why1 = "%^H is not consistent";
+	why2 = strEQ(key,"charnames")
+	       ? " (missing \"use charnames ...\"?)"
+	       : "";
+	why3 = "";
     report:
 	msg = Perl_newSVpvf(aTHX_ "constant(%s): %s%s%s", 
-			    (type ? type: "undef"), why1, why2, why);
+			    (type ? type: "undef"), why1, why2, why3);
 	yyerror(SvPVX(msg));
  	SvREFCNT_dec(msg);
   	return sv;
     }
-    if (!table) {
-	why = "%^H is not defined";
-	goto report_short;
-    }
     cvp = hv_fetch(table, key, strlen(key), FALSE);
     if (!cvp || !SvOK(*cvp)) {
-	why = "} is not defined";
 	why1 = "$^H{";
 	why2 = key;
+	why3 = "} is not defined";
 	goto report;
     }
     sv_2mortal(sv);			/* Parent created it permanently */
@@ -5538,8 +5719,7 @@ S_new_constant(pTHX_ char *s, STRLEN len, const char *key, SV *sv, SV *pv,
     SPAGAIN ;
     
     /* Check the eval first */
-    if (!PL_in_eval && SvTRUE(ERRSV))
-    {
+    if (!PL_in_eval && SvTRUE(ERRSV)) {
 	STRLEN n_a;
  	sv_catpv(ERRSV, "Propagated");
 	yyerror(SvPV(ERRSV, n_a)); /* Duplicates the message inside eval */
@@ -5557,14 +5737,14 @@ S_new_constant(pTHX_ char *s, STRLEN len, const char *key, SV *sv, SV *pv,
     POPSTACK;
     
     if (!SvOK(res)) {
- 	why = "}} did not return a defined value";
  	why1 = "Call to &{$^H{";
  	why2 = key;
+ 	why3 = "}} did not return a defined value";
  	sv = res;
  	goto report;
-     }
+    }
 
-     return res;
+    return res;
 }
   
 STATIC char *
@@ -5577,7 +5757,7 @@ S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_packag
 	    Perl_croak(aTHX_ ident_too_long);
 	if (isALNUM(*s))	/* UTF handled below */
 	    *d++ = *s++;
-	else if (*s == '\'' && allow_package && isIDFIRST_lazy(s+1)) {
+	else if (*s == '\'' && allow_package && isIDFIRST_lazy_if(s+1,UTF)) {
 	    *d++ = ':';
 	    *d++ = ':';
 	    s++;
@@ -5612,8 +5792,6 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
     char *bracket = 0;
     char funny = *s++;
 
-    if (PL_lex_brackets == 0)
-	PL_lex_fakebrack = 0;
     if (isSPACE(*s))
 	s = skipspace(s);
     d = dest;
@@ -5631,7 +5809,7 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
 		Perl_croak(aTHX_ ident_too_long);
 	    if (isALNUM(*s))	/* UTF handled below */
 		*d++ = *s++;
-	    else if (*s == '\'' && isIDFIRST_lazy(s+1)) {
+	    else if (*s == '\'' && isIDFIRST_lazy_if(s+1,UTF)) {
 		*d++ = ':';
 		*d++ = ':';
 		s++;
@@ -5662,7 +5840,7 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
 	return s;
     }
     if (*s == '$' && s[1] &&
-	(isALNUM_lazy(s+1) || strchr("${", s[1]) || strnEQ(s+1,"::",2)) )
+	(isALNUM_lazy_if(s+1,UTF) || strchr("${", s[1]) || strnEQ(s+1,"::",2)) )
     {
 	return s;
     }
@@ -5683,17 +5861,17 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
 	if (isSPACE(s[-1])) {
 	    while (s < send) {
 		char ch = *s++;
-		if (!SPACE_OR_TAB(ch)) {
+		if (ch != ' ' && ch != '\t') {
 		    *d = ch;
 		    break;
 		}
 	    }
 	}
-	if (isIDFIRST_lazy(d)) {
+	if (isIDFIRST_lazy_if(d,UTF)) {
 	    d++;
 	    if (UTF) {
 		e = s;
-		while (e < send && isALNUM_lazy(e) || *e == ':') {
+		while ((e < send && isALNUM_lazy_if(e,UTF)) || *e == ':') {
 		    e += UTF8SKIP(e);
 		    while (e < send && *e & 0x80 && is_utf8_mark((U8*)e))
 			e += UTF8SKIP(e);
@@ -5709,7 +5887,7 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
 		    Perl_croak(aTHX_ ident_too_long);
 	    }
 	    *d = '\0';
-	    while (s < send && SPACE_OR_TAB(*s)) s++;
+	    while (s < send && (*s == ' ' || *s == '\t')) s++;
 	    if ((*s == '[' || (*s == '{' && strNE(dest, "sub")))) {
 		dTHR;			/* only for ckWARN */
 		if (ckWARN(WARN_AMBIGUOUS) && keyword(dest, d - dest)) {
@@ -5718,9 +5896,8 @@ S_scan_ident(pTHX_ register char *s, register char *send, char *dest, STRLEN des
 			"Ambiguous use of %c{%s%s} resolved to %c%s%s",
 			funny, dest, brack, funny, dest, brack);
 		}
-		PL_lex_fakebrack = PL_lex_brackets+1;
 		bracket++;
-		PL_lex_brackstack[PL_lex_brackets++] = XOPERATOR;
+		PL_lex_brackstack[PL_lex_brackets++] = (char)(XOPERATOR | XFAKEBRACK);
 		return s;
 	    }
 	} 
@@ -5984,7 +6161,7 @@ S_scan_heredoc(pTHX_ register char *s)
     e = PL_tokenbuf + sizeof PL_tokenbuf - 1;
     if (!outer)
 	*d++ = '\n';
-    for (peek = s; SPACE_OR_TAB(*peek); peek++) ;
+    for (peek = s; *peek == ' ' || *peek == '\t'; peek++) ;
     if (*peek && strchr("`'\"",*peek)) {
 	s = peek;
 	term = *s++;
@@ -5998,9 +6175,9 @@ S_scan_heredoc(pTHX_ register char *s)
 	    s++, term = '\'';
 	else
 	    term = '"';
-	if (!isALNUM_lazy(s))
+	if (!isALNUM_lazy_if(s,UTF))
 	    deprecate("bare << to mean <<\"\"");
-	for (; isALNUM_lazy(s); s++) {
+	for (; isALNUM_lazy_if(s,UTF); s++) {
 	    if (d < e)
 		*d++ = *s;
 	}
@@ -6053,7 +6230,7 @@ S_scan_heredoc(pTHX_ register char *s)
     }
 
     CLINE;
-    PL_multi_start = PL_curcop->cop_line;
+    PL_multi_start = CopLINE(PL_curcop);
     PL_multi_open = PL_multi_close = '<';
     term = *PL_tokenbuf;
     if (PL_lex_inwhat == OP_SUBST && PL_in_eval && !PL_rsfp) {
@@ -6067,10 +6244,10 @@ S_scan_heredoc(pTHX_ register char *s)
 	while (s < bufend &&
 	  (*s != term || memNE(s,PL_tokenbuf,len)) ) {
 	    if (*s++ == '\n')
-		PL_curcop->cop_line++;
+		CopLINE_inc(PL_curcop);
 	}
 	if (s >= bufend) {
-	    PL_curcop->cop_line = PL_multi_start;
+	    CopLINE_set(PL_curcop, PL_multi_start);
 	    missingterm(PL_tokenbuf);
 	}
 	sv_setpvn(herewas,bufptr,d-bufptr+1);
@@ -6087,15 +6264,15 @@ S_scan_heredoc(pTHX_ register char *s)
 	while (s < PL_bufend &&
 	  (*s != term || memNE(s,PL_tokenbuf,len)) ) {
 	    if (*s++ == '\n')
-		PL_curcop->cop_line++;
+		CopLINE_inc(PL_curcop);
 	}
 	if (s >= PL_bufend) {
-	    PL_curcop->cop_line = PL_multi_start;
+	    CopLINE_set(PL_curcop, PL_multi_start);
 	    missingterm(PL_tokenbuf);
 	}
 	sv_setpvn(tmpstr,d+1,s-d);
 	s += len - 1;
-	PL_curcop->cop_line++;	/* the preceding stmt passes a newline */
+	CopLINE_inc(PL_curcop);	/* the preceding stmt passes a newline */
 
 	sv_catpvn(herewas,s,PL_bufend-s);
 	sv_setsv(PL_linestr,herewas);
@@ -6107,10 +6284,10 @@ S_scan_heredoc(pTHX_ register char *s)
     while (s >= PL_bufend) {	/* multiple line string? */
 	if (!outer ||
 	 !(PL_oldoldbufptr = PL_oldbufptr = s = PL_linestart = filter_gets(PL_linestr, PL_rsfp, 0))) {
-	    PL_curcop->cop_line = PL_multi_start;
+	    CopLINE_set(PL_curcop, PL_multi_start);
 	    missingterm(PL_tokenbuf);
 	}
-	PL_curcop->cop_line++;
+	CopLINE_inc(PL_curcop);
 	PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
 #ifndef PERL_STRICT_CR
 	if (PL_bufend - PL_linestart >= 2) {
@@ -6132,7 +6309,7 @@ S_scan_heredoc(pTHX_ register char *s)
 
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setsv(sv,PL_linestr);
-	    av_store(CopFILEAV(PL_curcop), (I32)PL_curcop->cop_line,sv);
+	    av_store(CopFILEAV(PL_curcop), (I32)CopLINE(PL_curcop),sv);
 	}
 	if (*s == term && memEQ(s,PL_tokenbuf,len)) {
 	    s = PL_bufend - 1;
@@ -6147,7 +6324,7 @@ S_scan_heredoc(pTHX_ register char *s)
     }
     s++;
 retval:
-    PL_multi_end = PL_curcop->cop_line;
+    PL_multi_end = CopLINE(PL_curcop);
     if (SvCUR(tmpstr) + 5 < SvLEN(tmpstr)) {
 	SvLEN_set(tmpstr, SvCUR(tmpstr) + 1);
 	Renew(SvPVX(tmpstr), SvLEN(tmpstr), char);
@@ -6211,7 +6388,7 @@ S_scan_inputsymbol(pTHX_ char *start)
     if (*d == '$' && d[1]) d++;
 
     /* allow <Pkg'VALUE> or <Pkg::VALUE> */
-    while (*d && (isALNUM_lazy(d) || *d == '\'' || *d == ':'))
+    while (*d && (isALNUM_lazy_if(d,UTF) || *d == '\'' || *d == ':'))
 	d++;
 
     /* If we've tried to read what we allow filehandles to look like, and
@@ -6327,6 +6504,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
     register char term;			/* terminating character */
     register char *to;			/* current position in the sv's data */
     I32 brackets = 1;			/* bracket nesting level */
+    bool has_utf = FALSE;		/* is there any utf8 content? */
 
     /* skip space before the delimiter */
     if (isSPACE(*s))
@@ -6337,8 +6515,11 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 
     /* after skipping whitespace, the next character is the terminator */
     term = *s;
+    if ((term & 0x80) && UTF)
+	has_utf = TRUE;
+
     /* mark where we are */
-    PL_multi_start = PL_curcop->cop_line;
+    PL_multi_start = CopLINE(PL_curcop);
     PL_multi_open = term;
 
     /* find corresponding closing delimiter */
@@ -6368,7 +6549,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	    for (; s < PL_bufend; s++,to++) {
 	    	/* embedded newlines increment the current line number */
 		if (*s == '\n' && !PL_rsfp)
-		    PL_curcop->cop_line++;
+		    CopLINE_inc(PL_curcop);
 		/* handle quoted delimiters */
 		if (*s == '\\' && s+1 < PL_bufend && term != '\\') {
 		    if (!keep_quoted && s[1] == term)
@@ -6381,6 +6562,8 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 		   have found the terminator */
 		else if (*s == term)
 		    break;
+		else if (!has_utf && (*s & 0x80) && UTF)
+		    has_utf = TRUE;
 		*to = *s;
 	    }
 	}
@@ -6394,7 +6577,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	    for (; s < PL_bufend; s++,to++) {
 	    	/* embedded newlines increment the line count */
 		if (*s == '\n' && !PL_rsfp)
-		    PL_curcop->cop_line++;
+		    CopLINE_inc(PL_curcop);
 		/* backslashes can escape the open or closing characters */
 		if (*s == '\\' && s+1 < PL_bufend) {
 		    if (!keep_quoted &&
@@ -6408,6 +6591,8 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 		    break;
 		else if (*s == PL_multi_open)
 		    brackets++;
+		else if (!has_utf && (*s & 0x80) && UTF)
+		    has_utf = TRUE;
 		*to = *s;
 	    }
 	}
@@ -6419,7 +6604,8 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	 * this next chunk reads more into the buffer if we're not done yet
 	 */
 
-  	if (s < PL_bufend) break;	/* handle case where we are done yet :-) */
+  	if (s < PL_bufend)
+	    break;		/* handle case where we are done yet :-) */
 
 #ifndef PERL_STRICT_CR
 	if (to - SvPVX(sv) >= 2) {
@@ -6443,11 +6629,11 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 	if (!PL_rsfp ||
 	 !(PL_oldoldbufptr = PL_oldbufptr = s = PL_linestart = filter_gets(PL_linestr, PL_rsfp, 0))) {
 	    sv_free(sv);
-	    PL_curcop->cop_line = PL_multi_start;
+	    CopLINE_set(PL_curcop, PL_multi_start);
 	    return Nullch;
 	}
 	/* we read a line, so increment our line counter */
-	PL_curcop->cop_line++;
+	CopLINE_inc(PL_curcop);
 
 	/* update debugger info */
 	if (PERLDB_LINE && PL_curstash != PL_debstash) {
@@ -6455,7 +6641,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 
 	    sv_upgrade(sv, SVt_PVMG);
 	    sv_setsv(sv,PL_linestr);
-	    av_store(CopFILEAV(PL_curcop), (I32)PL_curcop->cop_line, sv);
+	    av_store(CopFILEAV(PL_curcop), (I32)CopLINE(PL_curcop), sv);
 	}
 
 	/* having changed the buffer, we must update PL_bufend */
@@ -6466,7 +6652,9 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 
     if (keep_delims)
 	sv_catpvn(sv, s, 1);
-    PL_multi_end = PL_curcop->cop_line;
+    if (has_utf)
+	SvUTF8_on(sv);
+    PL_multi_end = CopLINE(PL_curcop);
     s++;
 
     /* if we allocated too much space, give some back */
@@ -6514,9 +6702,8 @@ Perl_scan_num(pTHX_ char *start)
     register char *s = start;		/* current position in buffer */
     register char *d;			/* destination in temp buffer */
     register char *e;			/* end of temp buffer */
-    IV tryiv;				/* used to see if it can be an IV */
     NV value;				/* number read, as a double */
-    SV *sv;				/* place to put the converted number */
+    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";
@@ -6528,8 +6715,7 @@ Perl_scan_num(pTHX_ char *start)
       Perl_croak(aTHX_ "panic: scan_num");
       
     /* if it starts with a 0, it could be an octal number, a decimal in
-       0.13 disguise, or a hexadecimal number, or a binary number.
-    */
+       0.13 disguise, or a hexadecimal number, or a binary number. */
     case '0':
 	{
 	  /* variables:
@@ -6740,6 +6926,11 @@ Perl_scan_num(pTHX_ char *start)
 		if (*s != '_')
 		    *d++ = *s;
 	    }
+	    if (*s == '.' && isDIGIT(s[1])) {
+		/* oops, it's really a v-string, but without the "v" */
+		s = start - 1;
+		goto vstring;
+	    }
 	}
 
 	/* read exponent part, if present */
@@ -6768,6 +6959,15 @@ Perl_scan_num(pTHX_ char *start)
 	/* make an sv from the string */
 	sv = NEWSV(92,0);
 
+	/* unfortunately this monster needs to be on one line or
+	   makedepend will be confused. */
+#if (defined(USE_64_BIT_INT) && (!defined(HAS_STRTOLL)|| !defined(HAS_STRTOULL))) || (!defined(USE_64_BIT_INT) && (!defined(HAS_STRTOL) || !defined(HAS_STRTOUL)))
+
+	/*
+	   No working strto[u]l[l]. Since atoi() doesn't do range checks,
+	   we need to do this the hard way.
+	 */
+
 	value = Atof(PL_tokenbuf);
 
 	/* 
@@ -6780,22 +6980,119 @@ Perl_scan_num(pTHX_ char *start)
 	   Note: if floatit is true, then we don't need to do the
 	   conversion at all.
 	*/
-	tryiv = I_V(value);
-	if (!floatit && (NV)tryiv == value)
-	    sv_setiv(sv, tryiv);
-	else
+	{
+	    UV tryuv = U_V(value);
+	    if (!floatit && (NV)tryuv == value) {
+		if (tryuv <= IV_MAX)
+		    sv_setiv(sv, (IV)tryuv);
+		else
+		    sv_setuv(sv, tryuv);
+	    }
+	    else
+		sv_setnv(sv, value);
+	}
+#else
+	/*
+	   strtol/strtoll sets errno to ERANGE if the number is too big
+	   for an integer. We try to do an integer conversion first
+	   if no characters indicating "float" have been found.
+	 */
+
+	if (!floatit) {
+    	    IV iv;
+    	    UV uv;
+	    errno = 0;
+	    if (*PL_tokenbuf == '-')
+		iv = Strtol(PL_tokenbuf, (char**)NULL, 10);
+	    else
+		uv = Strtoul(PL_tokenbuf, (char**)NULL, 10);
+	    if (errno)
+	    	floatit = TRUE; /* probably just too large */
+	    else if (*PL_tokenbuf == '-')
+	    	sv_setiv(sv, iv);
+	    else
+	    	sv_setuv(sv, uv);
+	}
+	if (floatit) {
+	    value = Atof(PL_tokenbuf);
 	    sv_setnv(sv, value);
+	}
+#endif
 	if ( floatit ? (PL_hints & HINT_NEW_FLOAT) :
 	               (PL_hints & HINT_NEW_INTEGER) )
 	    sv = new_constant(PL_tokenbuf, d - PL_tokenbuf, 
 			      (floatit ? "float" : "integer"),
 			      sv, Nullsv, NULL);
 	break;
+
+    /* if it starts with a v, it could be a v-string */
+    case 'v':
+vstring:
+	{
+	    char *pos = s;
+	    pos++;
+	    while (isDIGIT(*pos) || *pos == '_')
+		pos++;
+	    if (!isALPHA(*pos)) {
+		UV rev;
+		U8 tmpbuf[UTF8_MAXLEN];
+		U8 *tmpend;
+		bool utf8 = FALSE;
+		s++;				/* get past 'v' */
+
+		sv = NEWSV(92,5);
+		sv_setpvn(sv, "", 0);
+
+		for (;;) {
+		    if (*s == '0' && isDIGIT(s[1]))
+			yyerror("Octal number in vector unsupported");
+		    rev = 0;
+		    {
+			/* this is atoi() that tolerates underscores */
+			char *end = pos;
+			UV mult = 1;
+			while (--end >= s) {
+			    UV orev;
+			    if (*end == '_')
+				continue;
+			    orev = rev;
+			    rev += (*end - '0') * mult;
+			    mult *= 10;
+			    if (orev > rev && ckWARN_d(WARN_OVERFLOW))
+				Perl_warner(aTHX_ WARN_OVERFLOW,
+					    "Integer overflow in decimal number");
+			}
+		    }
+		    tmpend = uv_to_utf8(tmpbuf, rev);
+		    utf8 = utf8 || rev > 127;
+		    sv_catpvn(sv, (const char*)tmpbuf, tmpend - tmpbuf);
+		    if (*pos == '.' && isDIGIT(pos[1]))
+			s = ++pos;
+		    else {
+			s = pos;
+			break;
+		    }
+		    while (isDIGIT(*pos) || *pos == '_')
+			pos++;
+		}
+
+		SvPOK_on(sv);
+		SvREADONLY_on(sv);
+		if (utf8) {
+		    SvUTF8_on(sv);
+		    sv_utf8_downgrade(sv, TRUE);
+		}
+	    }
+	}
+	break;
     }
 
     /* make the op for the constant and return */
 
-    yylval.opval = newSVOP(OP_CONST, 0, sv);
+    if (sv)
+	yylval.opval = newSVOP(OP_CONST, 0, sv);
+    else
+	yylval.opval = Nullop;
 
     return s;
 }
@@ -6813,9 +7110,9 @@ S_scan_formline(pTHX_ register char *s)
 	if (*s == '.' || *s == '}') {
 	    /*SUPPRESS 530*/
 #ifdef PERL_STRICT_CR
-	    for (t = s+1;SPACE_OR_TAB(*t); t++) ;
+	    for (t = s+1;*t == ' ' || *t == '\t'; t++) ;
 #else
-	    for (t = s+1;SPACE_OR_TAB(*t) || *t == '\r'; t++) ;
+	    for (t = s+1;*t == ' ' || *t == '\t' || *t == '\r'; t++) ;
 #endif
 	    if (*t == '\n' || t == PL_bufend)
 		break;
@@ -6837,6 +7134,14 @@ S_scan_formline(pTHX_ register char *s)
 		    needargs = TRUE;
 	    }
 	    sv_catpvn(stuff, s, eol-s);
+#ifndef PERL_STRICT_CR
+	    if (eol-s > 1 && eol[-2] == '\r' && eol[-1] == '\n') {
+		char *end = SvPVX(stuff) + SvCUR(stuff);
+		end[-2] = '\n';
+		end[-1] = '\0';
+		SvCUR(stuff)--;
+	    }
+#endif
 	}
 	s = eol;
 	if (PL_rsfp) {
@@ -6894,11 +7199,10 @@ Perl_start_subparse(pTHX_ I32 is_format, U32 flags)
     if (PL_compcv) {
 	assert(SvTYPE(PL_compcv) == SVt_PVCV);
     }
-    save_I32(&PL_subline);
+    SAVEI32(PL_subline);
     save_item(PL_subname);
     SAVEI32(PL_padix);
-    SAVESPTR(PL_curpad);
-    SAVESPTR(PL_comppad);
+    SAVECOMPPAD();
     SAVESPTR(PL_comppad_name);
     SAVESPTR(PL_compcv);
     SAVEI32(PL_comppad_name_fill);
@@ -6917,7 +7221,7 @@ Perl_start_subparse(pTHX_ I32 is_format, U32 flags)
     PL_comppad_name_fill = 0;
     PL_min_intro_pending = 0;
     PL_padix = 0;
-    PL_subline = PL_curcop->cop_line;
+    PL_subline = CopLINE(PL_curcop);
 #ifdef USE_THREADS
     av_store(PL_comppad_name, 0, newSVpvn("@_", 2));
     PL_curpad[0] = (SV*)newAV();
@@ -6977,7 +7281,12 @@ Perl_yyerror(pTHX_ char *s)
     }
     else if (yychar > 255)
 	where = "next token ???";
+#ifdef USE_PURE_BISON
+/*  GNU Bison sets the value -2 */
+    else if (yychar == -2) {
+#else
     else if ((yychar & 127) == 127) {
+#endif
 	if (PL_lex_state == LEX_NORMAL ||
 	   (PL_lex_state == LEX_KNOWNEXT && PL_lex_defer == LEX_NORMAL))
 	    where = "at end of line";
@@ -6997,25 +7306,30 @@ Perl_yyerror(pTHX_ char *s)
 	where = SvPVX(where_sv);
     }
     msg = sv_2mortal(newSVpv(s, 0));
-    Perl_sv_catpvf(aTHX_ msg, " at %_ line %"IVdf", ",
-		   CopFILESV(PL_curcop), (IV)PL_curcop->cop_line);
+    Perl_sv_catpvf(aTHX_ msg, " at %s line %"IVdf", ",
+		   CopFILE(PL_curcop), (IV)CopLINE(PL_curcop));
     if (context)
 	Perl_sv_catpvf(aTHX_ msg, "near \"%.*s\"\n", contlen, context);
     else
 	Perl_sv_catpvf(aTHX_ msg, "%s\n", where);
-    if (PL_multi_start < PL_multi_end &&
-	(U32)(PL_curcop->cop_line - PL_multi_end) <= 1) {
+    if (PL_multi_start < PL_multi_end && (U32)(CopLINE(PL_curcop) - PL_multi_end) <= 1) {
         Perl_sv_catpvf(aTHX_ msg,
-        "   (Might be a runaway multi-line %c%c string starting on line %"IVdf")\n",
+        "  (Might be a runaway multi-line %c%c string starting on line %"IVdf")\n",
                 (int)PL_multi_open,(int)PL_multi_close,(IV)PL_multi_start);
         PL_multi_end = 0;
     }
     if (PL_in_eval & EVAL_WARNONLY)
-	Perl_warn(aTHX_ "%_", msg);
+	Perl_warn(aTHX_ "%"SVf, msg);
     else
 	qerror(msg);
-    if (PL_error_count >= 10)
-	Perl_croak(aTHX_ "%_ has too many errors.\n", CopFILESV(PL_curcop));
+    if (PL_error_count >= 10) {
+	if (PL_in_eval && SvCUR(ERRSV))
+	    Perl_croak(aTHX_ "%_%s has too many errors.\n",
+		       ERRSV, CopFILE(PL_curcop));
+	else
+	    Perl_croak(aTHX_ "%s has too many errors.\n",
+		       CopFILE(PL_curcop));
+    }
     PL_in_my = 0;
     PL_in_my_stash = Nullhv;
     return 0;
@@ -7042,29 +7356,3 @@ restore_rsfp(pTHXo_ void *f)
 	PerlIO_close(PL_rsfp);
     PL_rsfp = fp;
 }
-
-/*
- * restore_expect
- * Restores the state of PL_expect when the lexing that begun with a
- * start_lex() call has ended.
- */ 
-
-static void
-restore_expect(pTHXo_ void *e)
-{
-    /* a safe way to store a small integer in a pointer */
-    PL_expect = (expectation)((char *)e - PL_tokenbuf);
-}
-
-/*
- * restore_lex_expect
- * Restores the state of PL_lex_expect when the lexing that begun with a
- * start_lex() call has ended.
- */ 
-
-static void
-restore_lex_expect(pTHXo_ void *e)
-{
-    /* a safe way to store a small integer in a pointer */
-    PL_lex_expect = (expectation)((char *)e - PL_tokenbuf);
-}