X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=stolen_chunk_of_toke.c;h=a15c9a1235854d479a27615efb1d892b31a26b8c;hb=fb4e2a38b19e9f6cc64e1b8ade89c8c6890a93dc;hp=4da285e67a9ca452bdd11a119cd598e29d66a598;hpb=0ba8c7aa7fbe181c41b885283412d5b55484326e;p=p5sagit%2FDevel-Declare.git diff --git a/stolen_chunk_of_toke.c b/stolen_chunk_of_toke.c index 4da285e..a15c9a1 100644 --- a/stolen_chunk_of_toke.c +++ b/stolen_chunk_of_toke.c @@ -17,14 +17,37 @@ * up but if it does blame me (Matt S Trout), not the poor original authors */ -/* the following #defines are stolen from assorted headers, not toke.c */ +/* the following #defines are stolen from assorted headers, not toke.c (mst) */ + +#define skipspace(a) S_skipspace(aTHX_ a) +#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_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); #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) */ +#ifndef Newx #define Newx(v,n,t) (v = (MEM_WRAP_CHECK_(n,t) (t*)safemalloc((MEM_SIZE)((n)*sizeof(t))))) +#endif +#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); \ SvPV_set((sv), (MEM_WRAP_CHECK_(n,char) \ @@ -32,6 +55,8 @@ (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') @@ -39,6 +64,20 @@ #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 "...") */ @@ -57,6 +96,82 @@ #define LEX_FORMLINE 1 /* expecting a format line */ #define LEX_KNOWNEXT 0 /* next token known; just return it */ +/* and these two are my own madness (mst) */ + +#if PERL_REVISION == 5 && PERL_VERSION == 8 && PERL_SUBVERSION >= 8 +#define PERL_5_8_8_PLUS +#endif + +#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) */ + +/* XXX temporary backwards compatibility */ +#define PL_lex_brackets (PL_parser->lex_brackets) +#define PL_lex_brackstack (PL_parser->lex_brackstack) +#define PL_lex_casemods (PL_parser->lex_casemods) +#define PL_lex_casestack (PL_parser->lex_casestack) +#define PL_lex_defer (PL_parser->lex_defer) +#define PL_lex_dojoin (PL_parser->lex_dojoin) +#define PL_lex_expect (PL_parser->lex_expect) +#define PL_lex_formbrack (PL_parser->lex_formbrack) +#define PL_lex_inpat (PL_parser->lex_inpat) +#define PL_lex_inwhat (PL_parser->lex_inwhat) +#define PL_lex_op (PL_parser->lex_op) +#define PL_lex_repl (PL_parser->lex_repl) +#define PL_lex_starts (PL_parser->lex_starts) +#define PL_lex_stuff (PL_parser->lex_stuff) +#define PL_multi_start (PL_parser->multi_start) +#define PL_multi_open (PL_parser->multi_open) +#define PL_multi_close (PL_parser->multi_close) +#define PL_pending_ident (PL_parser->pending_ident) +#define PL_preambled (PL_parser->preambled) +#define PL_sublex_info (PL_parser->sublex_info) +#define PL_linestr (PL_parser->linestr) +#define PL_sublex_info (PL_parser->sublex_info) +#define PL_linestr (PL_parser->linestr) +#define PL_expect (PL_parser->expect) +#define PL_copline (PL_parser->copline) +#define PL_bufptr (PL_parser->bufptr) +#define PL_oldbufptr (PL_parser->oldbufptr) +#define PL_oldoldbufptr (PL_parser->oldoldbufptr) +#define PL_linestart (PL_parser->linestart) +#define PL_bufend (PL_parser->bufend) +#define PL_last_uni (PL_parser->last_uni) +#define PL_last_lop (PL_parser->last_lop) +#define PL_last_lop_op (PL_parser->last_lop_op) +#define PL_lex_state (PL_parser->lex_state) +#define PL_rsfp (PL_parser->rsfp) +#define PL_rsfp_filters (PL_parser->rsfp_filters) +#define PL_in_my (PL_parser->in_my) +#define PL_in_my_stash (PL_parser->in_my_stash) +#define PL_tokenbuf (PL_parser->tokenbuf) +#define PL_multi_end (PL_parser->multi_end) +#define PL_error_count (PL_parser->error_count) +#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) */ +# 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) +# endif +/* end of backcompat macros from 5.9 toke.c (mst) */ +#endif + +/* when ccflags include -DDEBUGGING we need this for earlier 5.8 perls */ +#ifndef SvPV_nolen_const +#define SvPV_nolen_const SvPV_nolen +#endif + +/* and now we're back to the toke.c stuff again (mst) */ + static const char ident_too_long[] = "Identifier too long"; static const char c_without_g[] = @@ -215,16 +330,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); @@ -357,6 +476,12 @@ S_incline(pTHX_ char *s) ch = *t; *t = '\0'; if (t - s > 0) { +/* this chunk was added to S_incline during 5.8.8. I don't know why but I don't + honestly care since I probably want to be bug-compatible anyway (mst) */ + +/* ... my kingdom for a perl parser in perl ... (mst) */ + +#ifdef PERL_5_8_8_PLUS #ifndef USE_ITHREADS const char *cf = CopFILE(PL_curcop); if (cf && strlen(cf) > 7 && strnEQ(cf, "(eval ", 6)) { @@ -394,6 +519,8 @@ S_incline(pTHX_ char *s) if (tmpbuf2 != smallbuf2) Safefree(tmpbuf2); } #endif +#endif +/* second endif closes out the "are we 5.8.(8+)" conditional */ CopFILE_free(PL_curcop); CopFILE_set(PL_curcop, s); } @@ -455,7 +582,9 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) I32 brackets = 1; /* bracket nesting level */ bool has_utf8 = FALSE; /* is there any utf8 content? */ I32 termcode; /* terminating char. code */ - U8 termstr[UTF8_MAXBYTES]; /* terminating string */ + /* 5.8.7+ uses UTF8_MAXBYTES but also its utf8.h defs _MAXLEN to it so + I'm reasonably hopeful this won't destroy anything (mst) */ + U8 termstr[UTF8_MAXLEN]; /* terminating string */ STRLEN termlen; /* length of terminating string */ char *last = NULL; /* last position for nesting bracket */ @@ -704,7 +833,12 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) /* if we allocated too much space, give some back */ if (SvCUR(sv) + 5 < SvLEN(sv)) { SvLEN_set(sv, SvCUR(sv) + 1); +/* 5.8.8 uses SvPV_renew, no prior version actually has the damn thing (mst) */ +#ifdef PERL_5_8_8_PLUS SvPV_renew(sv, SvLEN(sv)); +#else + Renew(SvPVX(sv), SvLEN(sv), char); +#endif } /* decide whether this is the first or second quoted string we've read @@ -730,6 +864,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) { @@ -737,4 +882,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; }