* up but if it does blame me (Matt S Trout), not the poor original authors
*/
+#include "ppport.h"
+
/* the following #defines are stolen from assorted headers, not toke.c (mst) */
+#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, 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);
+
#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 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); \
(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')
#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 "...") */
#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) */
#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) */
-/* we also need this because we define PERL_CORE so handy.h doesn't provide
- it for us (mst) */
-#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 */
#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[] =
*/
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))
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);
}
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;
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);
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);
+ }
}
}
}
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++;
*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;
* If so, it sets the current line number and file to the values in the comment.
*/
-/* 5.9+ make the char *s in S_incline const and declare it in proto.h so we
- need to do the same to avoid a prototype mismatch (mst) */
-#ifdef PERL_5_9_PLUS
-#define S_INCLINE_CONST const
-#else
-#define S_INCLINE_CONST
-#endif
-
STATIC void
-S_incline(pTHX_ S_INCLINE_CONST char *s)
+S_incline(pTHX_ char *s)
{
char *t;
- S_INCLINE_CONST char *n;
- S_INCLINE_CONST char *e;
+ char *n;
+ char *e;
char ch;
CopLINE_inc(PL_curcop);
e = t + 1;
}
else {
- /* explicitly cast to char * in case S_INCLINE_CONST in force (mst) */
- for (t = (char *)s; !isSPACE(*t); t++) ;
+ for (t = s; !isSPACE(*t); t++) ;
e = t;
}
while (SPACE_OR_TAB(*e) || *e == '\r' || *e == '\f')
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;
/* 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 */
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;
}
projects / p5sagit/Devel-Declare.git / blobdiff