X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=stolen_chunk_of_toke.c;h=04dee1aa8089ce7bc4c1326dc36c6d05601da3fa;hb=2688337bafe83db36857a49ecfd39984ef08ee73;hp=ab1a384568f958ce2369b9983e7198a24e955da4;hpb=d229e8e01be8091dd16a1ea2efc12d04afbcdba2;p=p5sagit%2FDevel-Declare.git

diff --git a/stolen_chunk_of_toke.c b/stolen_chunk_of_toke.c
index ab1a384..04dee1a 100644
--- a/stolen_chunk_of_toke.c
+++ b/stolen_chunk_of_toke.c
@@ -24,6 +24,7 @@
 #define filter_gets(a,b,c)      S_filter_gets(aTHX_ a,b,c)
 #define scan_str(a,b,c)         S_scan_str(aTHX_ a,b,c)
 #define scan_word(a,b,c,d,e)    S_scan_word(aTHX_ a,b,c,d,e)
+#define scan_ident(a,b,c,d,e)   S_scan_ident(aTHX_ a,b,c,d,e)
 
 STATIC void     S_incline(pTHX_ char *s);
 STATIC char*    S_skipspace(pTHX_ char *s);
@@ -34,7 +35,6 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow
 #define DPTR2FPTR(t,p) ((t)PTR2nat(p))  /* data pointer to function pointer */
 #define FPTR2DPTR(t,p) ((t)PTR2nat(p))  /* function pointer to data pointer */
 #define PTR2nat(p)       (PTRV)(p)       /* pointer to integer of PTRSIZE */
-#define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t),
 
 /* conditionalise these two because as of 5.9.5 we already get them from
    the headers (mst) */
@@ -44,6 +44,9 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow
 #ifndef SvPVX_const
 #define SvPVX_const(sv) ((const char*) (0 + SvPVX(sv)))
 #endif
+#ifndef MEM_WRAP_CHECK_
+#define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t),
+#endif
 
 #define SvPV_renew(sv,n) \
   STMT_START { SvLEN_set(sv, n); \
@@ -52,6 +55,8 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow
                (MEM_SIZE)((n)))));  \
      } STMT_END
 
+#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')
@@ -59,6 +64,19 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow
 #define SPACE_OR_TAB(c) ((c)==' '||(c)=='\t')
 #endif
 
+/*
+ * Normally, during compile time, PL_curcop == &PL_compiling is true. However,
+ * Devel::Declare makes the interpreter call back to perl during compile time,
+ * which temporarily enters runtime. Then perl space calls various functions
+ * from this file, which are designed to work during compile time. They all
+ * happen to operate on PL_curcop, not PL_compiling. That doesn't make a
+ * difference in the core, but it does for Devel::Declare, which operates at
+ * runtime, but still wants to mangle the things that are about to be compiled.
+ * That's why we define our own PL_curcop and make it point to PL_compiling
+ * here.
+ */
+#define PL_curcop &PL_compiling
+
 #define CLINE (PL_copline = (CopLINE(PL_curcop) < PL_copline ? CopLINE(PL_curcop) : PL_copline))
 
 #define LEX_NORMAL    10 /* normal code (ie not within "...")     */
@@ -83,7 +101,11 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow
 #define PERL_5_8_8_PLUS
 #endif
 
-#ifdef PL_parser
+#if PERL_REVISION == 5 && PERL_VERSION > 8
+#define PERL_5_9_PLUS
+#endif
+
+#ifdef PERL_5_9_PLUS
 /* 5.9+ moves a bunch of things to a PL_parser struct so we need to
    declare the backcompat macros for things to still work (mst) */
 
@@ -129,12 +151,17 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow
 #define PL_tokenbuf             (PL_parser->tokenbuf)
 #define PL_multi_end            (PL_parser->multi_end)
 #define PL_error_count          (PL_parser->error_count)
-/* these three are from the non-PERL_MAD path but I don't -think- I need
+#define PL_nexttoke           (PL_parser->nexttoke)
+/* these are from the non-PERL_MAD path but I don't -think- I need
    the PERL_MAD stuff since my code isn't really populating things (mst) */
-#  define PL_nexttoke           (PL_parser->nexttoke)
+# ifdef PERL_MAD
+#  define PL_curforce		(PL_parser->curforce)
+#  define PL_lasttoke		(PL_parser->lasttoke)
+# else
 #  define PL_nexttype           (PL_parser->nexttype)
 #  define PL_nextval            (PL_parser->nextval)
-/* end of backcompat macros form 5.9 toke.c (mst) */
+# endif
+/* end of backcompat macros from 5.9 toke.c (mst) */
 #endif
 
 /* when ccflags include -DDEBUGGING we need this for earlier 5.8 perls */
@@ -302,16 +329,20 @@ S_skipspace(pTHX_ register char *s)
 	    PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr);
 	    PL_last_lop = PL_last_uni = Nullch;
 
-	    /* Close the filehandle.  Could be from -P preprocessor,
+	    /* In perl versions previous to p4-rawid: //depot/perl@32954 -P
+	     * preprocessors were supported here. We don't support -P at all, even
+	     * on perls that support it, and use the following chunk from blead
+	     * perl. (rafl)
+	     */
+
+	    /* Close the filehandle.  Could be from
 	     * STDIN, or a regular file.  If we were reading code from
 	     * STDIN (because the commandline held no -e or filename)
 	     * then we don't close it, we reset it so the code can
 	     * read from STDIN too.
 	     */
 
-	    if (PL_preprocess && !PL_in_eval)
-		(void)PerlProc_pclose(PL_rsfp);
-	    else if ((PerlIO*)PL_rsfp == PerlIO_stdin())
+	    if ((PerlIO*)PL_rsfp == PerlIO_stdin())
 		PerlIO_clearerr(PL_rsfp);
 	    else
 		(void)PerlIO_close(PL_rsfp);
@@ -832,6 +863,17 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
 STATIC void
 S_force_next(pTHX_ I32 type)
 {
+#ifdef PERL_MAD
+    dVAR;
+    if (PL_curforce < 0)
+    start_force(PL_lasttoke);
+    PL_nexttoke[PL_curforce].next_type = type;
+    if (PL_lex_state != LEX_KNOWNEXT)
+    PL_lex_defer = PL_lex_state;
+    PL_lex_state = LEX_KNOWNEXT;
+    PL_lex_expect = PL_expect;
+    PL_curforce = -1;
+#else
     PL_nexttype[PL_nexttoke] = type;
     PL_nexttoke++;
     if (PL_lex_state != LEX_KNOWNEXT) {
@@ -839,4 +881,180 @@ S_force_next(pTHX_ I32 type)
   PL_lex_expect = PL_expect;
   PL_lex_state = LEX_KNOWNEXT;
     }
+#endif
+}
+
+#define XFAKEBRACK 128
+
+STATIC char *
+S_scan_ident(pTHX_ register char *s, register const char *send, char *dest, STRLEN destlen, I32 ck_uni)
+{
+    register char *d;
+    register char *e;
+    char *bracket = Nullch;
+    char funny = *s++;
+
+    if (isSPACE(*s))
+	s = skipspace(s);
+    d = dest;
+    e = d + destlen - 3;	/* two-character token, ending NUL */
+    if (isDIGIT(*s)) {
+	while (isDIGIT(*s)) {
+	    if (d >= e)
+		Perl_croak(aTHX_ ident_too_long);
+	    *d++ = *s++;
+	}
+    }
+    else {
+	for (;;) {
+	    if (d >= e)
+		Perl_croak(aTHX_ ident_too_long);
+	    if (isALNUM(*s))	/* UTF handled below */
+		*d++ = *s++;
+	    else if (*s == '\'' && isIDFIRST_lazy_if(s+1,UTF)) {
+		*d++ = ':';
+		*d++ = ':';
+		s++;
+	    }
+	    else if (*s == ':' && s[1] == ':') {
+		*d++ = *s++;
+		*d++ = *s++;
+	    }
+	    else if (UTF && UTF8_IS_START(*s) && isALNUM_utf8((U8*)s)) {
+		char *t = s + UTF8SKIP(s);
+		while (UTF8_IS_CONTINUED(*t) && is_utf8_mark((U8*)t))
+		    t += UTF8SKIP(t);
+		if (d + (t - s) > e)
+		    Perl_croak(aTHX_ ident_too_long);
+		Copy(s, d, t - s, char);
+		d += t - s;
+		s = t;
+	    }
+	    else
+		break;
+	}
+    }
+    *d = '\0';
+    d = dest;
+    if (*d) {
+	if (PL_lex_state != LEX_NORMAL)
+	    PL_lex_state = LEX_INTERPENDMAYBE;
+	return s;
+    }
+    if (*s == '$' && s[1] &&
+	(isALNUM_lazy_if(s+1,UTF) || s[1] == '$' || s[1] == '{' || strnEQ(s+1,"::",2)) )
+    {
+	return s;
+    }
+    if (*s == '{') {
+	bracket = s;
+	s++;
+    }
+    /* we always call this with ck_uni == 0 (rafl) */
+    /*
+    else if (ck_uni)
+	check_uni();
+    */
+    if (s < send)
+	*d = *s++;
+    d[1] = '\0';
+    if (*d == '^' && *s && isCONTROLVAR(*s)) {
+	*d = toCTRL(*s);
+	s++;
+    }
+    if (bracket) {
+	if (isSPACE(s[-1])) {
+	    while (s < send) {
+		const char ch = *s++;
+		if (!SPACE_OR_TAB(ch)) {
+		    *d = ch;
+		    break;
+		}
+	    }
+	}
+	if (isIDFIRST_lazy_if(d,UTF)) {
+	    d++;
+	    if (UTF) {
+		e = s;
+		while ((e < send && isALNUM_lazy_if(e,UTF)) || *e == ':') {
+		    e += UTF8SKIP(e);
+		    while (e < send && UTF8_IS_CONTINUED(*e) && is_utf8_mark((U8*)e))
+			e += UTF8SKIP(e);
+		}
+		Copy(s, d, e - s, char);
+		d += e - s;
+		s = e;
+	    }
+	    else {
+		while ((isALNUM(*s) || *s == ':') && d < e)
+		    *d++ = *s++;
+		if (d >= e)
+		    Perl_croak(aTHX_ ident_too_long);
+	    }
+	    *d = '\0';
+	    while (s < send && SPACE_OR_TAB(*s)) s++;
+	    if ((*s == '[' || (*s == '{' && strNE(dest, "sub")))) {
+		/* we don't want perl to guess what is meant. the keyword
+		 * parser decides that later. (rafl)
+		 */
+		/*
+		if (ckWARN(WARN_AMBIGUOUS) && keyword(dest, d - dest)) {
+		    const char *brack = *s == '[' ? "[...]" : "{...}";
+		    Perl_warner(aTHX_ packWARN(WARN_AMBIGUOUS),
+			"Ambiguous use of %c{%s%s} resolved to %c%s%s",
+			funny, dest, brack, funny, dest, brack);
+		}
+		*/
+		bracket++;
+		PL_lex_brackstack[PL_lex_brackets++] = (char)(XOPERATOR | XFAKEBRACK);
+		return s;
+	    }
+	}
+	/* Handle extended ${^Foo} variables
+	 * 1999-02-27 mjd-perl-patch@plover.com */
+	else if (!isALNUM(*d) && !isPRINT(*d) /* isCTRL(d) */
+		 && isALNUM(*s))
+	{
+	    d++;
+	    while (isALNUM(*s) && d < e) {
+		*d++ = *s++;
+	    }
+	    if (d >= e)
+		Perl_croak(aTHX_ ident_too_long);
+	    *d = '\0';
+	}
+	if (*s == '}') {
+	    s++;
+	    if (PL_lex_state == LEX_INTERPNORMAL && !PL_lex_brackets) {
+		PL_lex_state = LEX_INTERPEND;
+		PL_expect = XREF;
+	    }
+	    if (funny == '#')
+		funny = '@';
+	    /* we don't want perl to guess what is meant. the keyword
+	     * parser decides that later. (rafl)
+	     */
+	    /*
+	    if (PL_lex_state == LEX_NORMAL) {
+		if (ckWARN(WARN_AMBIGUOUS) &&
+		    (keyword(dest, d - dest) || get_cv(dest, FALSE)))
+		{
+		    Perl_warner(aTHX_ packWARN(WARN_AMBIGUOUS),
+			"Ambiguous use of %c{%s} resolved to %c%s",
+			funny, dest, funny, dest);
+		}
+	    }
+	    */
+	}
+	else {
+	    s = bracket;		/* let the parser handle it */
+	    *dest = '\0';
+	}
+    }
+    /* don't intuit. we really just want the string. (rafl) */
+    /*
+    else if (PL_lex_state == LEX_INTERPNORMAL && !PL_lex_brackets && !intuit_more(s))
+	PL_lex_state = LEX_INTERPEND;
+    */
+    return s;
 }