/* 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_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);
#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 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 */
*/
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
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);
+ }
}
}
}
/* 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.
- */
-
-STATIC void
-S_force_next(pTHX_ I32 type)
-{
- 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;
- }
-}
-
#define XFAKEBRACK 128
STATIC char *
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(); */
}
- /* we always call this with ck_uni == 0 (rafl) */
- /*
- else if (ck_uni)
- check_uni();
- */
if (s < send)
*d = *s++;
d[1] = '\0';
projects / p5sagit/Devel-Declare.git / blobdiff