X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=p5sagit%2FDevel-Declare.git;a=blobdiff_plain;f=stolen_chunk_of_toke.c;h=038a91c345a2c78626855b6b103d5aea7dd48309;hp=2347cc701fee8bdb426837920196baea7f6b6507;hb=e8e28944ba0dbcaf478071464085b15c5104e104;hpb=e38f5a74a0674263f305ff8228b347171ae4658d diff --git a/stolen_chunk_of_toke.c b/stolen_chunk_of_toke.c index 2347cc7..038a91c 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 "...") */ @@ -87,6 +108,20 @@ STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow #define PERL_5_9_PLUS #endif +#if !defined(PERL_5_9_PLUS) && defined(PERL_IMPLICIT_CONTEXT) +/* These two are not exported from the core on Windows. With 5.9+ + it's not an issue, because they're part of the PL_parser structure, + which is exported. On multiplicity/thread builds we can work + around the lack of export by this formulation, where we provide + a substitute implementation of the unexported accessor functions. + On single-interpreter builds we can't, because access is directly + via symbols that are not exported. */ +# define Perl_Ilinestart_ptr my_Ilinestart_ptr +char **my_Ilinestart_ptr(pTHX) { return &(aTHX->Ilinestart); } +# define Perl_Isublex_info_ptr my_Isublex_info_ptr +static SUBLEXINFO *my_Isublex_info_ptr(pTHX) { return &(aTHX->Isublex_info); } +#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) */ @@ -133,12 +168,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 */ @@ -146,6 +186,25 @@ STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow #define SvPV_nolen_const SvPV_nolen #endif +/* utf8_to_uvchr_buf() not defined in earlier perls, but less-capable + * substitute is available */ + +#ifndef utf8_to_uvchr_buf +#define utf8_to_uvchr_buf(s, e, lp) ((e), utf8_to_uvchr(s, lp)) +#endif + +#ifndef isIDFIRST_lazy_if_safe +# define isIDFIRST_lazy_if_safe(p,e,UTF) \ + ((! UTF || p > e) ? isIDFIRST_lazy_if(p,UTF) : 0) +#endif +#ifndef isALNUM_lazy_if_safe +# define isALNUM_lazy_if_safe(p,e,UTF) \ + ((! UTF || p > e) ? isALNUM_lazy_if(p,UTF) : 0) +#endif +#ifndef isALNUM_utf8_safe +# define isALNUM_utf8_safe(p,e) ((p > e) ? isALNUM_utf8(p) : 0) +#endif + /* and now we're back to the toke.c stuff again (mst) */ static const char ident_too_long[] = @@ -246,7 +305,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)) @@ -258,7 +317,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); } @@ -268,18 +327,26 @@ 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 */ - if (s < PL_bufend || !PL_rsfp || PL_sublex_info.sub_inwhat || + if (s < PL_bufend || !PL_rsfp || PL_lex_inwhat || PL_lex_state == LEX_FORMLINE) return s; @@ -306,16 +373,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); @@ -340,19 +411,22 @@ 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 */ if (PERLDB_LINE && PL_curstash != PL_debstash) { - SV * const sv = NEWSV(85,0); - - sv_upgrade(sv, SVt_PVMG); - sv_setpvn(sv,PL_bufptr,PL_bufend-PL_bufptr); - (void)SvIOK_on(sv); - SvIV_set(sv, 0); - av_store(CopFILEAV(PL_curcop),(I32)CopLINE(PL_curcop),sv); + AV *fileav = CopFILEAV(PL_curcop); + if (fileav) { + SV * const sv = NEWSV(85,0); + sv_upgrade(sv, SVt_PVMG); + sv_setpvn(sv,PL_bufptr,PL_bufend-PL_bufptr); + (void)SvIOK_on(sv); + SvIV_set(sv, 0); + av_store(fileav,(I32)CopLINE(PL_curcop),sv); + } } } } @@ -365,9 +439,30 @@ S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_packag for (;;) { if (d >= e) Perl_croak(aTHX_ ident_too_long); - if (isALNUM(*s)) /* UTF handled below */ - *d++ = *s++; - else if (*s == '\'' && allow_package && isIDFIRST_lazy_if(s+1,UTF)) { + if (UTF && isIDFIRST_utf8_safe((const U8*) s, (const U8*) PL_bufend)) { + /* The UTF-8 case must come first, otherwise things + * like c\N{COMBINING TILDE} would start failing, as the + * isALNUM case below would gobble the 'c' up. + */ + + char *t = s + UTF8SKIP(s); + while (isIDCONT_utf8_safe((const U8*) t, (const U8*) PL_bufend)) { + t += UTF8SKIP(t); + } + if (d + (t - s) > e) + Perl_croak(aTHX_ "%s", ident_too_long); + Copy(s, d, t - s, char); + *d += t - s; + s = t; + } + else if (isALNUM(*s)) + do { + *d++ = *s++; + } while (isWORDCHAR_A(*s) && d < e); + else if ( *s == '\'' + && allow_package + && isIDFIRST_lazy_if_safe(s+1, PL_bufend, UTF)) + { *d++ = ':'; *d++ = ':'; s++; @@ -376,16 +471,6 @@ S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_packag *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 { *d = '\0'; *slp = d - dest; @@ -574,7 +659,7 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) termlen = 1; } else { - termcode = utf8_to_uvchr((U8*)s, &termlen); + termcode = utf8_to_uvchr_buf((U8*)s, PL_bufend, &termlen); Copy(s, termstr, termlen, U8); if (!UTF8_IS_INVARIANT(term)) has_utf8 = TRUE; @@ -776,13 +861,15 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) /* update debugger info */ if (PERLDB_LINE && PL_curstash != PL_debstash) { - SV *sv = NEWSV(88,0); - - sv_upgrade(sv, SVt_PVMG); - sv_setsv(sv,PL_linestr); - (void)SvIOK_on(sv); - SvIV_set(sv, 0); - av_store(CopFILEAV(PL_curcop), (I32)CopLINE(PL_curcop), sv); + AV *fileav = CopFILEAV(PL_curcop); + if (fileav) { + SV *sv = NEWSV(88,0); + sv_upgrade(sv, SVt_PVMG); + sv_setsv(sv,PL_linestr); + (void)SvIOK_on(sv); + SvIV_set(sv, 0); + av_store(fileav, (I32)CopLINE(PL_curcop), sv); + } } /* having changed the buffer, we must update PL_bufend */ @@ -824,23 +911,187 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) return s; } -/* - * S_force_next - * When the lexer realizes it knows the next token (for instance, - * it is reordering tokens for the parser) then it can call S_force_next - * to know what token to return the next time the lexer is called. Caller - * will need to set PL_nextval[], and possibly PL_expect to ensure the lexer - * handles the token correctly. - */ +#define XFAKEBRACK 128 -STATIC void -S_force_next(pTHX_ I32 type) +STATIC char * +S_scan_ident(pTHX_ register char *s, register const char *send, char *dest, STRLEN destlen, I32 ck_uni) { - PL_nexttype[PL_nexttoke] = type; - PL_nexttoke++; - if (PL_lex_state != LEX_KNOWNEXT) { - PL_lex_defer = PL_lex_state; - PL_lex_expect = PL_expect; - PL_lex_state = LEX_KNOWNEXT; + 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 (UTF && isIDFIRST_utf8_safe((const U8*) s, (const U8*) PL_bufend)) { + /* The UTF-8 case must come first, otherwise things + * like c\N{COMBINING TILDE} would start failing, as the + * isALNUM case below would gobble the 'c' up. + */ + + char *t = s + UTF8SKIP(s); + while (isIDCONT_utf8_safe((const U8*) t, (const U8*) PL_bufend)) { + t += UTF8SKIP(t); + } + if (d + (t - s) > e) + Perl_croak(aTHX_ "%s", ident_too_long); + Copy(s, d, t - s, char); + *d += t - s; + s = t; + } + else if (isALNUM(*s)) + do { + *d++ = *s++; + } while (isWORDCHAR_A(*s) && d < e); + else if (*s == '\'' && isIDFIRST_lazy_if_safe(s+1,send,UTF)) { + *d++ = ':'; + *d++ = ':'; + s++; + } + else if (*s == ':' && s[1] == ':') { + *d++ = *s++; + *d++ = *s++; + } + 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_safe(s+1,send,UTF) + || s[1] == '$' || s[1] == '{' || strnEQ(s+1,"::",2)) ) + { + return s; + } + if (*s == '{') { + bracket = s; + s++; + } else if (ck_uni) { + /* we always call this with ck_uni == 0, so no need for check_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_safe(d,d+destlen,UTF)) { + d++; + if (UTF) { + e = s; + while ( ( e < send + && isIDFIRST_utf8_safe(e, send) + || *e == ':')) + { + e += UTF8SKIP(e); + while (e < send && isIDFIRST_utf8_safe(e, send)) + 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; }