X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=stolen_chunk_of_toke.c;h=e231264f0a139bbd9aed2509e73b19c25d7d61d6;hb=mxd_parameterized_bug;hp=54f67e9fee151bbcfab8bc5039178197708f0ac8;hpb=552a9b31980a59c456fef6e3e895714ffe901bd5;p=p5sagit%2FDevel-Declare.git diff --git a/stolen_chunk_of_toke.c b/stolen_chunk_of_toke.c index 54f67e9..e231264 100644 --- a/stolen_chunk_of_toke.c +++ b/stolen_chunk_of_toke.c @@ -19,14 +19,17 @@ /* the following #defines are stolen from assorted headers, not toke.c (mst) */ -#define skipspace(a) S_skipspace(aTHX_ a) +#define skipspace(a) S_skipspace(aTHX_ a, 0) +#define peekspace(a) S_skipspace(aTHX_ a, 1) +#define skipspace_force(a) S_skipspace(aTHX_ a, 2) #define incline(a) S_incline(aTHX_ a) #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); +STATIC char* S_skipspace(pTHX_ char *s, int incline); STATIC char * S_filter_gets(pTHX_ SV *sv, PerlIO *fp, STRLEN append); STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims); STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp); @@ -34,7 +37,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 +46,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 +57,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 +66,20 @@ 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. + */ +#undef PL_curcop +#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 "...") */ @@ -133,17 +154,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 -/* we also need this because we define PERL_CORE so handy.h doesn't provide - it for us (mst) */ -#ifndef NEWSV -#define NEWSV(x,len) newSV(len) +# endif +/* end of backcompat macros from 5.9 toke.c (mst) */ #endif /* when ccflags include -DDEBUGGING we need this for earlier 5.8 perls */ @@ -251,7 +272,7 @@ S_filter_gets(pTHX_ register SV *sv, register PerlIO *fp, STRLEN append) */ STATIC char * -S_skipspace(pTHX_ register char *s) +S_skipspace(pTHX_ register char *s, int incline) { if (PL_lex_formbrack && PL_lex_brackets <= PL_lex_formbrack) { while (s < PL_bufend && SPACE_OR_TAB(*s)) @@ -263,7 +284,7 @@ S_skipspace(pTHX_ register char *s) SSize_t oldprevlen, oldoldprevlen; SSize_t oldloplen = 0, oldunilen = 0; while (s < PL_bufend && isSPACE(*s)) { - if (*s++ == '\n' && PL_in_eval && !PL_rsfp) + if (*s++ == '\n' && ((incline == 2) || PL_in_eval && !PL_rsfp && !incline)) incline(s); } @@ -273,13 +294,21 @@ S_skipspace(pTHX_ register char *s) s++; if (s < PL_bufend) { s++; - if (PL_in_eval && !PL_rsfp) { + if (PL_in_eval && !PL_rsfp && !incline) { incline(s); continue; } } } + /* also skip leading whitespace on the beginning of a line before deciding + * whether or not to recharge the linestr. --rafl + */ + while (s < PL_bufend && isSPACE(*s)) { + if (*s++ == '\n' && PL_in_eval && !PL_rsfp && !incline) + incline(s); + } + /* only continue to recharge the buffer if we're at the end * of the buffer, we're not reading from a source filter, and * we're in normal lexing mode @@ -311,16 +340,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); @@ -345,7 +378,8 @@ S_skipspace(pTHX_ register char *s) PL_last_uni = s + oldunilen; if (PL_last_lop) PL_last_lop = s + oldloplen; - incline(s); + if (!incline) + incline(s); /* debugger active and we're not compiling the debugger code, * so store the line into the debugger's array of lines @@ -841,6 +875,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) { @@ -848,4 +893,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; }