#ifdef PERL_MAD
/* XXX these probably need to be made into PL vars */
-static I32 realtokenstart;
-static I32 faketokens = 0;
-static MADPROP *thismad;
-static SV *thistoken;
-static SV *thisopen;
-static SV *thisstuff;
-static SV *thisclose;
-static SV *thiswhite;
-static SV *nextwhite;
-static SV *skipwhite;
-static SV *endwhite;
-static I32 curforce = -1;
+static I32 PL_realtokenstart;
+static I32 PL_faketokens = 0;
+static MADPROP *PL_thismad;
+static SV *PL_thistoken;
+static SV *PL_thisopen;
+static SV *PL_thisstuff;
+static SV *PL_thisclose;
+static SV *PL_thiswhite;
+static SV *PL_nextwhite;
+static SV *PL_skipwhite;
+static SV *PL_endwhite;
+static I32 PL_curforce = -1;
# define CURMAD(slot,sv) if (PL_madskills) { curmad(slot,sv); sv = 0; }
-# define NEXTVAL_NEXTTOKE PL_nexttoke[curforce].next_val
+# define NEXTVAL_NEXTTOKE PL_nexttoke[PL_curforce].next_val
#else
# define CURMAD(slot,sv)
# define NEXTVAL_NEXTTOKE PL_nextval[PL_nexttoke]
SAVEI32(PL_lasttoke);
}
if (PL_madskills) {
- SAVESPTR(thistoken);
- SAVESPTR(thiswhite);
- SAVESPTR(nextwhite);
- SAVESPTR(thisopen);
- SAVESPTR(thisclose);
- SAVESPTR(thisstuff);
- SAVEVPTR(thismad);
- SAVEI32(realtokenstart);
- SAVEI32(faketokens);
- }
- SAVEI32(curforce);
+ SAVESPTR(PL_thistoken);
+ SAVESPTR(PL_thiswhite);
+ SAVESPTR(PL_nextwhite);
+ SAVESPTR(PL_thisopen);
+ SAVESPTR(PL_thisclose);
+ SAVESPTR(PL_thisstuff);
+ SAVEVPTR(PL_thismad);
+ SAVEI32(PL_realtokenstart);
+ SAVEI32(PL_faketokens);
+ }
+ SAVEI32(PL_curforce);
#else
if (PL_lex_state == LEX_KNOWNEXT) {
I32 toke = PL_nexttoke;
}
#ifdef PERL_MAD
-/* skip space before thistoken */
+/* skip space before PL_thistoken */
STATIC char *
S_skipspace0(pTHX_ register char *s)
s = skipspace(s);
if (!PL_madskills)
return s;
- if (skipwhite) {
- if (!thiswhite)
- thiswhite = newSVpvn("",0);
- sv_catsv(thiswhite, skipwhite);
- sv_free(skipwhite);
- skipwhite = 0;
- }
- realtokenstart = s - SvPVX(PL_linestr);
+ if (PL_skipwhite) {
+ if (!PL_thiswhite)
+ PL_thiswhite = newSVpvn("",0);
+ sv_catsv(PL_thiswhite, PL_skipwhite);
+ sv_free(PL_skipwhite);
+ PL_skipwhite = 0;
+ }
+ PL_realtokenstart = s - SvPVX(PL_linestr);
return s;
}
-/* skip space after thistoken */
+/* skip space after PL_thistoken */
STATIC char *
S_skipspace1(pTHX_ register char *s)
if (!PL_madskills)
return s;
start = SvPVX(PL_linestr) + startoff;
- if (!thistoken && realtokenstart >= 0) {
- char *tstart = SvPVX(PL_linestr) + realtokenstart;
- thistoken = newSVpvn(tstart, start - tstart);
- }
- realtokenstart = -1;
- if (skipwhite) {
- if (!nextwhite)
- nextwhite = newSVpvn("",0);
- sv_catsv(nextwhite, skipwhite);
- sv_free(skipwhite);
- skipwhite = 0;
+ if (!PL_thistoken && PL_realtokenstart >= 0) {
+ char *tstart = SvPVX(PL_linestr) + PL_realtokenstart;
+ PL_thistoken = newSVpvn(tstart, start - tstart);
+ }
+ PL_realtokenstart = -1;
+ if (PL_skipwhite) {
+ if (!PL_nextwhite)
+ PL_nextwhite = newSVpvn("",0);
+ sv_catsv(PL_nextwhite, PL_skipwhite);
+ sv_free(PL_skipwhite);
+ PL_skipwhite = 0;
}
return s;
}
if (!PL_madskills || !svp)
return s;
start = SvPVX(PL_linestr) + startoff;
- if (!thistoken && realtokenstart >= 0) {
- char *tstart = SvPVX(PL_linestr) + realtokenstart;
- thistoken = newSVpvn(tstart, start - tstart);
- realtokenstart = -1;
+ if (!PL_thistoken && PL_realtokenstart >= 0) {
+ char *tstart = SvPVX(PL_linestr) + PL_realtokenstart;
+ PL_thistoken = newSVpvn(tstart, start - tstart);
+ PL_realtokenstart = -1;
}
- if (skipwhite) {
+ if (PL_skipwhite) {
if (!*svp)
*svp = newSVpvn("",0);
- sv_setsv(*svp, skipwhite);
- sv_free(skipwhite);
- skipwhite = 0;
+ sv_setsv(*svp, PL_skipwhite);
+ sv_free(PL_skipwhite);
+ PL_skipwhite = 0;
}
return s;
int curoff;
int startoff = s - SvPVX(PL_linestr);
- if (skipwhite) {
- sv_free(skipwhite);
- skipwhite = 0;
+ if (PL_skipwhite) {
+ sv_free(PL_skipwhite);
+ PL_skipwhite = 0;
}
#endif
{
#ifdef PERL_MAD
if (PL_madskills && curoff != startoff) {
- if (!skipwhite)
- skipwhite = newSVpvn("",0);
- sv_catpvn(skipwhite, SvPVX(PL_linestr) + startoff,
+ if (!PL_skipwhite)
+ PL_skipwhite = newSVpvn("",0);
+ sv_catpvn(PL_skipwhite, SvPVX(PL_linestr) + startoff,
curoff - startoff);
}
#endif
/* end of file. Add on the -p or -n magic */
- /* XXX these shouldn't really be added here, can't set faketokens */
+ /* XXX these shouldn't really be added here, can't set PL_faketokens */
if (PL_minus_p) {
#ifdef PERL_MAD
sv_catpv(PL_linestr,
#ifdef PERL_MAD
done:
if (PL_madskills) {
- if (!skipwhite)
- skipwhite = newSVpvn("",0);
+ if (!PL_skipwhite)
+ PL_skipwhite = newSVpvn("",0);
curoff = s - SvPVX(PL_linestr);
if (curoff - startoff)
- sv_catpvn(skipwhite, SvPVX(PL_linestr) + startoff,
+ sv_catpvn(PL_skipwhite, SvPVX(PL_linestr) + startoff,
curoff - startoff);
}
return s;
{
int i;
- if (where < 0) /* so people can duplicate start_force(curforce) */
+ if (where < 0) /* so people can duplicate start_force(PL_curforce) */
where = PL_lasttoke;
- assert(curforce < 0 || curforce == where);
- if (curforce != where) {
+ assert(PL_curforce < 0 || PL_curforce == where);
+ if (PL_curforce != where) {
for (i = PL_lasttoke; i > where; --i) {
PL_nexttoke[i] = PL_nexttoke[i-1];
}
PL_lasttoke++;
}
- if (curforce < 0) /* in case of duplicate start_force() */
+ if (PL_curforce < 0) /* in case of duplicate start_force() */
Zero(&PL_nexttoke[where], 1, NEXTTOKE);
- curforce = where;
- if (nextwhite) {
+ PL_curforce = where;
+ if (PL_nextwhite) {
if (PL_madskills)
curmad('^', newSVpvn("",0));
- CURMAD('_', nextwhite);
+ CURMAD('_', PL_nextwhite);
}
}
if (!sv)
return;
- if (curforce < 0)
- where = &thismad;
+ if (PL_curforce < 0)
+ where = &PL_thismad;
else
- where = &PL_nexttoke[curforce].next_mad;
+ where = &PL_nexttoke[PL_curforce].next_mad;
- if (faketokens)
+ if (PL_faketokens)
sv_setpvn(sv, "", 0);
else {
if (!IN_BYTES) {
{
dVAR;
#ifdef PERL_MAD
- if (curforce < 0)
+ if (PL_curforce < 0)
start_force(PL_lasttoke);
- PL_nexttoke[curforce].next_type = type;
+ 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;
- curforce = -1;
+ PL_curforce = -1;
#else
PL_nexttype[PL_nexttoke] = type;
PL_nexttoke++;
s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, allow_pack, &len);
if (check_keyword && keyword(PL_tokenbuf, len))
return start;
- start_force(curforce);
+ start_force(PL_curforce);
if (PL_madskills)
curmad('X', newSVpvn(start,s-start));
if (token == METHOD) {
if (s && *s) {
const STRLEN len = strlen(s);
OP* const o = (OP*)newSVOP(OP_CONST, 0, newSVpvn(s, len));
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = o;
force_next(WORD);
if (kind) {
d++;
#ifdef PERL_MAD
if (PL_madskills) {
- start_force(curforce);
+ start_force(PL_curforce);
curmad('X', newSVpvn(s,d-s));
}
#endif
else if (guessing) {
#ifdef PERL_MAD
if (PL_madskills) {
- sv_free(nextwhite); /* let next token collect whitespace */
- nextwhite = 0;
+ sv_free(PL_nextwhite); /* let next token collect whitespace */
+ PL_nextwhite = 0;
s = SvPVX(PL_linestr) + startoff;
}
#endif
#ifdef PERL_MAD
if (PL_madskills && !version) {
- sv_free(nextwhite); /* let next token collect whitespace */
- nextwhite = 0;
+ sv_free(PL_nextwhite); /* let next token collect whitespace */
+ PL_nextwhite = 0;
s = SvPVX(PL_linestr) + startoff;
}
#endif
/* NOTE: The parser sees the package name and the VERSION swapped */
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = version;
force_next(WORD);
else {
#ifdef PERL_MAD
if (PL_madskills) {
- if (thiswhite) {
- if (!endwhite)
- endwhite = newSVpvn("",0);
- sv_catsv(endwhite, thiswhite);
- thiswhite = 0;
- }
- if (thistoken)
- sv_setpvn(thistoken,"",0);
+ if (PL_thiswhite) {
+ if (!PL_endwhite)
+ PL_endwhite = newSVpvn("",0);
+ sv_catsv(PL_endwhite, PL_thiswhite);
+ PL_thiswhite = 0;
+ }
+ if (PL_thistoken)
+ sv_setpvn(PL_thistoken,"",0);
else
- realtokenstart = -1;
+ PL_realtokenstart = -1;
}
#endif
LEAVE;
if ((PL_bufend - s) >= 2 && *s == '=' && *(s+1) == '>')
return 0; /* no assumptions -- "=>" quotes bearword */
bare_package:
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = (OP*)newSVOP(OP_CONST, 0,
newSVpvn(tmpbuf,len));
NEXTVAL_NEXTTOKE.opval->op_private = OPpCONST_BARE;
int optype;
char *s = PL_bufptr;
- /* make sure thiswhite is initialized */
- thiswhite = 0;
- thismad = 0;
+ /* make sure PL_thiswhite is initialized */
+ PL_thiswhite = 0;
+ PL_thismad = 0;
- /* just do what yylex would do on pending identifier; leave thiswhite alone */
+ /* just do what yylex would do on pending identifier; leave PL_thiswhite alone */
if (PL_pending_ident)
return S_pending_ident(aTHX);
/* previous token ate up our whitespace? */
- if (!PL_lasttoke && nextwhite) {
- thiswhite = nextwhite;
- nextwhite = 0;
+ if (!PL_lasttoke && PL_nextwhite) {
+ PL_thiswhite = PL_nextwhite;
+ PL_nextwhite = 0;
}
/* isolate the token, and figure out where it is without whitespace */
- realtokenstart = -1;
- thistoken = 0;
+ PL_realtokenstart = -1;
+ PL_thistoken = 0;
optype = yylex();
s = PL_bufptr;
- assert(curforce < 0);
+ assert(PL_curforce < 0);
- if (!thismad || thismad->mad_key == '^') { /* not forced already? */
- if (!thistoken) {
- if (realtokenstart < 0 || !CopLINE(PL_curcop))
- thistoken = newSVpvn("",0);
+ if (!PL_thismad || PL_thismad->mad_key == '^') { /* not forced already? */
+ if (!PL_thistoken) {
+ if (PL_realtokenstart < 0 || !CopLINE(PL_curcop))
+ PL_thistoken = newSVpvn("",0);
else {
- char *tstart = SvPVX(PL_linestr) + realtokenstart;
- thistoken = newSVpvn(tstart, s - tstart);
+ char *tstart = SvPVX(PL_linestr) + PL_realtokenstart;
+ PL_thistoken = newSVpvn(tstart, s - tstart);
}
}
- if (thismad) /* install head */
- CURMAD('X', thistoken);
+ if (PL_thismad) /* install head */
+ CURMAD('X', PL_thistoken);
}
/* last whitespace of a sublex? */
- if (optype == ')' && endwhite) {
- CURMAD('X', endwhite);
+ if (optype == ')' && PL_endwhite) {
+ CURMAD('X', PL_endwhite);
}
- if (!thismad) {
+ if (!PL_thismad) {
/* if no whitespace and we're at EOF, bail. Otherwise fake EOF below. */
- if (!thiswhite && !endwhite && !optype) {
- sv_free(thistoken);
- thistoken = 0;
+ if (!PL_thiswhite && !PL_endwhite && !optype) {
+ sv_free(PL_thistoken);
+ PL_thistoken = 0;
return 0;
}
/* put off final whitespace till peg */
if (optype == ';' && !PL_rsfp) {
- nextwhite = thiswhite;
- thiswhite = 0;
+ PL_nextwhite = PL_thiswhite;
+ PL_thiswhite = 0;
}
- else if (thisopen) {
- CURMAD('q', thisopen);
- if (thistoken)
- sv_free(thistoken);
- thistoken = 0;
+ else if (PL_thisopen) {
+ CURMAD('q', PL_thisopen);
+ if (PL_thistoken)
+ sv_free(PL_thistoken);
+ PL_thistoken = 0;
}
else {
/* Store actual token text as madprop X */
- CURMAD('X', thistoken);
+ CURMAD('X', PL_thistoken);
}
- if (thiswhite) {
+ if (PL_thiswhite) {
/* add preceding whitespace as madprop _ */
- CURMAD('_', thiswhite);
+ CURMAD('_', PL_thiswhite);
}
- if (thisstuff) {
+ if (PL_thisstuff) {
/* add quoted material as madprop = */
- CURMAD('=', thisstuff);
+ CURMAD('=', PL_thisstuff);
}
- if (thisclose) {
+ if (PL_thisclose) {
/* add terminating quote as madprop Q */
- CURMAD('Q', thisclose);
+ CURMAD('Q', PL_thisclose);
}
}
case UNIOPSUB:
case LSTOPSUB:
if (yylval.opval)
- append_madprops(thismad, yylval.opval, 0);
- thismad = 0;
+ append_madprops(PL_thismad, yylval.opval, 0);
+ PL_thismad = 0;
return optype;
/* fake EOF */
case 0:
optype = PEG;
- if (endwhite) {
- addmad(newMADsv('p', endwhite), &thismad, 0);
- endwhite = 0;
+ if (PL_endwhite) {
+ addmad(newMADsv('p', PL_endwhite), &PL_thismad, 0);
+ PL_endwhite = 0;
}
break;
case ']':
case '}':
- if (faketokens)
+ if (PL_faketokens)
break;
/* remember any fake bracket that lexer is about to discard */
if (PL_lex_brackets == 1 &&
while (s < PL_bufend && (*s == ' ' || *s == '\t'))
s++;
if (*s == '}') {
- thiswhite = newSVpvn(PL_bufptr, ++s - PL_bufptr);
- addmad(newMADsv('#', thiswhite), &thismad, 0);
- thiswhite = 0;
+ PL_thiswhite = newSVpvn(PL_bufptr, ++s - PL_bufptr);
+ addmad(newMADsv('#', PL_thiswhite), &PL_thismad, 0);
+ PL_thiswhite = 0;
PL_bufptr = s - 1;
break; /* don't bother looking for trailing comment */
}
/* attach a trailing comment to its statement instead of next token */
case ';':
- if (faketokens)
+ if (PL_faketokens)
break;
if (PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == optype) {
s = PL_bufptr;
s++;
if (s < PL_bufend)
s++;
- thiswhite = newSVpvn(PL_bufptr, s - PL_bufptr);
- addmad(newMADsv('#', thiswhite), &thismad, 0);
- thiswhite = 0;
+ PL_thiswhite = newSVpvn(PL_bufptr, s - PL_bufptr);
+ addmad(newMADsv('#', PL_thiswhite), &PL_thismad, 0);
+ PL_thiswhite = 0;
PL_bufptr = s;
}
}
}
/* Create new token struct. Note: opvals return early above. */
- yylval.tkval = newTOKEN(optype, yylval, thismad);
- thismad = 0;
+ yylval.tkval = newTOKEN(optype, yylval, PL_thismad);
+ PL_thismad = 0;
return optype;
}
#endif
if (isDIGIT(*s) || (*s == 'v' && isDIGIT(s[1]))) {
s = force_version(s, TRUE);
if (*s == ';' || (s = SKIPSPACE1(s), *s == ';')) {
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = NULL;
force_next(WORD);
}
PL_lasttoke--;
yylval = PL_nexttoke[PL_lasttoke].next_val;
if (PL_madskills) {
- thismad = PL_nexttoke[PL_lasttoke].next_mad;
+ PL_thismad = PL_nexttoke[PL_lasttoke].next_mad;
PL_nexttoke[PL_lasttoke].next_mad = 0;
- if (thismad && thismad->mad_key == '_') {
- thiswhite = (SV*)thismad->mad_val;
- thismad->mad_val = 0;
- mad_free(thismad);
- thismad = 0;
+ if (PL_thismad && PL_thismad->mad_key == '_') {
+ PL_thiswhite = (SV*)PL_thismad->mad_val;
+ PL_thismad->mad_val = 0;
+ mad_free(PL_thismad);
+ PL_thismad = 0;
}
}
if (!PL_lasttoke) {
PL_lex_state = LEX_INTERPCONCAT;
#ifdef PERL_MAD
if (PL_madskills)
- thistoken = newSVpvn("\\E",2);
+ PL_thistoken = newSVpvn("\\E",2);
#endif
}
return REPORT(')');
#ifdef PERL_MAD
while (PL_bufptr != PL_bufend &&
PL_bufptr[0] == '\\' && PL_bufptr[1] == 'E') {
- if (!thiswhite)
- thiswhite = newSVpvn("",0);
- sv_catpvn(thiswhite, PL_bufptr, 2);
+ if (!PL_thiswhite)
+ PL_thiswhite = newSVpvn("",0);
+ sv_catpvn(PL_thiswhite, PL_bufptr, 2);
PL_bufptr += 2;
}
#else
s = PL_bufptr + 1;
if (s[1] == '\\' && s[2] == 'E') {
#ifdef PERL_MAD
- if (!thiswhite)
- thiswhite = newSVpvn("",0);
- sv_catpvn(thiswhite, PL_bufptr, 4);
+ if (!PL_thiswhite)
+ PL_thiswhite = newSVpvn("",0);
+ sv_catpvn(PL_thiswhite, PL_bufptr, 4);
#endif
PL_bufptr = s + 3;
PL_lex_state = LEX_INTERPCONCAT;
PL_lex_casestack[PL_lex_casemods++] = *s;
PL_lex_casestack[PL_lex_casemods] = '\0';
PL_lex_state = LEX_INTERPCONCAT;
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = 0;
force_next('(');
- start_force(curforce);
+ start_force(PL_curforce);
if (*s == 'l')
NEXTVAL_NEXTTOKE.ival = OP_LCFIRST;
else if (*s == 'u')
PL_lex_starts = 0;
#ifdef PERL_MAD
if (PL_madskills) {
- if (thistoken)
- sv_free(thistoken);
- thistoken = newSVpvn("",0);
+ if (PL_thistoken)
+ sv_free(PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
}
#endif
/* commas only at base level: /$a\Ub$c/ => ($a,uc(b.$c)) */
PL_lex_dojoin = (*PL_bufptr == '@');
PL_lex_state = LEX_INTERPNORMAL;
if (PL_lex_dojoin) {
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = 0;
force_next(',');
- start_force(curforce);
+ start_force(PL_curforce);
force_ident("\"", '$');
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = 0;
force_next('$');
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = 0;
force_next('(');
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = OP_JOIN; /* emulate join($", ...) */
force_next(FUNC);
}
s = PL_bufptr;
#ifdef PERL_MAD
if (PL_madskills) {
- if (thistoken)
- sv_free(thistoken);
- thistoken = newSVpvn("",0);
+ if (PL_thistoken)
+ sv_free(PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
}
#endif
/* commas only at base level: /$a\Ub$c/ => ($a,uc(b.$c)) */
PL_lex_state = LEX_INTERPCONCAT;
#ifdef PERL_MAD
if (PL_madskills) {
- if (thistoken)
- sv_free(thistoken);
- thistoken = newSVpvn("",0);
+ if (PL_thistoken)
+ sv_free(PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
}
#endif
return REPORT(')');
}
if (s != PL_bufptr) {
- start_force(curforce);
+ start_force(PL_curforce);
if (PL_madskills) {
curmad('X', newSVpvn(PL_bufptr,s-PL_bufptr));
}
if (PL_lex_starts++) {
#ifdef PERL_MAD
if (PL_madskills) {
- if (thistoken)
- sv_free(thistoken);
- thistoken = newSVpvn("",0);
+ if (PL_thistoken)
+ sv_free(PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
}
#endif
/* commas only at base level: /$a\Ub$c/ => ($a,uc(b.$c)) */
retry:
#ifdef PERL_MAD
- if (thistoken) {
- sv_free(thistoken);
- thistoken = 0;
+ if (PL_thistoken) {
+ sv_free(PL_thistoken);
+ PL_thistoken = 0;
}
- realtokenstart = s - SvPVX(PL_linestr); /* assume but undo on ws */
+ PL_realtokenstart = s - SvPVX(PL_linestr); /* assume but undo on ws */
#endif
switch (*s) {
default:
case 0:
#ifdef PERL_MAD
if (PL_madskills)
- faketokens = 0;
+ PL_faketokens = 0;
#endif
if (!PL_rsfp) {
PL_last_uni = 0;
PL_preambled = TRUE;
#ifdef PERL_MAD
if (PL_madskills)
- faketokens = 1;
+ PL_faketokens = 1;
#endif
sv_setpv(PL_linestr,incl_perldb());
if (SvCUR(PL_linestr))
if ((s = filter_gets(PL_linestr, PL_rsfp, 0)) == NULL) {
fake_eof:
#ifdef PERL_MAD
- realtokenstart = -1;
+ PL_realtokenstart = -1;
#endif
if (PL_rsfp) {
if (PL_preprocess && !PL_in_eval)
if (!PL_in_eval && (PL_minus_n || PL_minus_p)) {
#ifdef PERL_MAD
if (PL_madskills)
- faketokens = 1;
+ PL_faketokens = 1;
#endif
sv_setpv(PL_linestr,PL_minus_p
? ";}continue{print;}" : ";}");
/* Incest with pod. */
#ifdef PERL_MAD
if (PL_madskills)
- sv_catsv(thiswhite, PL_linestr);
+ sv_catsv(PL_thiswhite, PL_linestr);
#endif
if (*s == '=' && strnEQ(s, "=cut", 4)) {
sv_setpvn(PL_linestr, "", 0);
s++;
#ifdef PERL_MAD
if (PL_madskills)
- thiswhite = newSVpvn(PL_linestart, s - PL_linestart);
+ PL_thiswhite = newSVpvn(PL_linestart, s - PL_linestart);
#endif
d = NULL;
if (!PL_in_eval) {
case '\312':
#endif
#ifdef PERL_MAD
- realtokenstart = -1;
+ PL_realtokenstart = -1;
s = SKIPSPACE0(s);
#else
s++;
case '#':
case '\n':
#ifdef PERL_MAD
- realtokenstart = -1;
+ PL_realtokenstart = -1;
if (PL_madskills)
- faketokens = 0;
+ PL_faketokens = 0;
#endif
if (PL_lex_state != LEX_NORMAL || (PL_in_eval && !PL_rsfp)) {
if (*s == '#' && s == PL_linestart && PL_in_eval && !PL_rsfp) {
Perl_croak(aTHX_ "panic: input overflow");
#ifdef PERL_MAD
if (PL_madskills)
- thiswhite = newSVpvn(s, d - s);
+ PL_thiswhite = newSVpvn(s, d - s);
#endif
s = d;
incline(s);
#ifdef PERL_MAD
if (PL_madskills && CopLINE(PL_curcop) >= 1 && !PL_lex_formbrack) {
if (CopLINE(PL_curcop) == 1 && s[0] == '#' && s[1] == '!') {
- faketokens = 0;
+ PL_faketokens = 0;
s = SKIPSPACE0(s);
TOKEN(PEG); /* make sure any #! line is accessible */
}
else if (d > PL_bufend) /* Found by Ilya: feed random input to Perl. */
Perl_croak(aTHX_ "panic: input overflow");
if (PL_madskills && CopLINE(PL_curcop) >= 1) {
- if (!thiswhite)
- thiswhite = newSVpvn("",0);
+ if (!PL_thiswhite)
+ PL_thiswhite = newSVpvn("",0);
if (CopLINE(PL_curcop) == 1) {
- sv_setpvn(thiswhite, "", 0);
- faketokens = 0;
+ sv_setpvn(PL_thiswhite, "", 0);
+ PL_faketokens = 0;
}
- sv_catpvn(thiswhite, s, d - s);
+ sv_catpvn(PL_thiswhite, s, d - s);
}
s = d;
/* }
}
got_attrs:
if (attrs) {
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = attrs;
- CURMAD('_', nextwhite);
+ CURMAD('_', PL_nextwhite);
force_next(THING);
}
#ifdef PERL_MAD
if (PL_madskills) {
- thistoken = newSVpvn(SvPVX(PL_linestr) + stuffstart,
+ PL_thistoken = newSVpvn(SvPVX(PL_linestr) + stuffstart,
(s - SvPVX(PL_linestr)) - stuffstart);
}
#endif
PL_bufptr = s;
#if 0
if (PL_madskills) {
- if (!thiswhite)
- thiswhite = newSVpvn("",0);
- sv_catpvn(thiswhite,"}",1);
+ if (!PL_thiswhite)
+ PL_thiswhite = newSVpvn("",0);
+ sv_catpvn(PL_thiswhite,"}",1);
}
#endif
return yylex(); /* ignore fake brackets */
PL_bufptr = s;
return yylex(); /* ignore fake brackets */
}
- start_force(curforce);
+ start_force(PL_curforce);
if (PL_madskills) {
curmad('X', newSVpvn(s-1,1));
- CURMAD('_', thiswhite);
+ CURMAD('_', PL_thiswhite);
}
force_next('}');
#ifdef PERL_MAD
- if (!thistoken)
- thistoken = newSVpvn("",0);
+ if (!PL_thistoken)
+ PL_thistoken = newSVpvn("",0);
#endif
TOKEN(';');
case '&':
}
#ifdef PERL_MAD
if (PL_madskills) {
- if (!thiswhite)
- thiswhite = newSVpvn("",0);
- sv_catpvn(thiswhite, PL_linestart,
+ if (!PL_thiswhite)
+ PL_thiswhite = newSVpvn("",0);
+ sv_catpvn(PL_thiswhite, PL_linestart,
PL_bufend - PL_linestart);
}
#endif
const char lastchar = (PL_bufptr == PL_oldoldbufptr ? 0 : PL_bufptr[-1]);
CV *cv;
#ifdef PERL_MAD
- SV *nextnextwhite = 0;
+ SV *nextPL_nextwhite = 0;
#endif
sv = newSVpv(PL_tokenbuf,len);
}
#ifdef PERL_MAD
- if (PL_madskills && !thistoken) {
- char *start = SvPVX(PL_linestr) + realtokenstart;
- thistoken = newSVpv(start,s - start);
- realtokenstart = s - SvPVX(PL_linestr);
+ if (PL_madskills && !PL_thistoken) {
+ char *start = SvPVX(PL_linestr) + PL_realtokenstart;
+ PL_thistoken = newSVpv(start,s - start);
+ PL_realtokenstart = s - SvPVX(PL_linestr);
}
#endif
bool immediate_paren = *s == '(';
/* (Now we can afford to cross potential line boundary.) */
- s = SKIPSPACE2(s,nextnextwhite);
+ s = SKIPSPACE2(s,nextPL_nextwhite);
#ifdef PERL_MAD
- nextwhite = nextnextwhite; /* assume no & deception */
+ PL_nextwhite = nextPL_nextwhite; /* assume no & deception */
#endif
/* Two barewords in a row may indicate method call. */
PL_expect = XOPERATOR;
#ifdef PERL_MAD
if (isSPACE(*s))
- s = SKIPSPACE2(s,nextnextwhite);
- nextwhite = nextnextwhite;
+ s = SKIPSPACE2(s,nextPL_nextwhite);
+ PL_nextwhite = nextPL_nextwhite;
#else
s = skipspace(s);
#endif
s = d + 1;
#ifdef PERL_MAD
if (PL_madskills) {
- char *par = SvPVX(PL_linestr) + realtokenstart;
- sv_catpvn(thistoken, par, s - par);
- if (nextwhite) {
- sv_free(nextwhite);
- nextwhite = 0;
+ char *par = SvPVX(PL_linestr) + PL_realtokenstart;
+ sv_catpvn(PL_thistoken, par, s - par);
+ if (PL_nextwhite) {
+ sv_free(PL_nextwhite);
+ PL_nextwhite = 0;
}
}
#endif
}
#ifdef PERL_MAD
if (PL_madskills) {
- nextwhite = thiswhite;
- thiswhite = 0;
+ PL_nextwhite = PL_thiswhite;
+ PL_thiswhite = 0;
}
- start_force(curforce);
+ start_force(PL_curforce);
#endif
NEXTVAL_NEXTTOKE.opval = yylval.opval;
PL_expect = XOPERATOR;
#ifdef PERL_MAD
if (PL_madskills) {
- nextwhite = nextnextwhite;
- curmad('X', thistoken);
- thistoken = newSVpvn("",0);
+ PL_nextwhite = nextPL_nextwhite;
+ curmad('X', PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
}
#endif
force_next(WORD);
#ifdef PERL_MAD
{
if (PL_madskills) {
- nextwhite = thiswhite;
- thiswhite = 0;
+ PL_nextwhite = PL_thiswhite;
+ PL_thiswhite = 0;
}
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = yylval.opval;
PL_expect = XTERM;
if (PL_madskills) {
- nextwhite = nextnextwhite;
- curmad('X', thistoken);
- thistoken = newSVpvn("",0);
+ PL_nextwhite = nextPL_nextwhite;
+ curmad('X', PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
}
force_next(WORD);
TOKEN(NOAMP);
yylval.opval->op_private |= OPpENTERSUB_NOPAREN;
PL_last_lop = PL_oldbufptr;
PL_last_lop_op = OP_ENTERSUB;
- nextwhite = thiswhite;
- thiswhite = 0;
- start_force(curforce);
+ PL_nextwhite = PL_thiswhite;
+ PL_thiswhite = 0;
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = yylval.opval;
PL_expect = XTERM;
- nextwhite = nextnextwhite;
- curmad('X', thistoken);
- thistoken = newSVpvn("",0);
+ PL_nextwhite = nextPL_nextwhite;
+ curmad('X', PL_thistoken);
+ PL_thistoken = newSVpvn("",0);
force_next(WORD);
TOKEN(NOAMP);
}
#endif
#ifdef PERL_MAD
if (PL_madskills) {
- if (realtokenstart >= 0) {
- char *tstart = SvPVX(PL_linestr) + realtokenstart;
- if (!endwhite)
- endwhite = newSVpvn("",0);
- sv_catsv(endwhite, thiswhite);
- thiswhite = 0;
- sv_catpvn(endwhite, tstart, PL_bufend - tstart);
- realtokenstart = -1;
+ if (PL_realtokenstart >= 0) {
+ char *tstart = SvPVX(PL_linestr) + PL_realtokenstart;
+ if (!PL_endwhite)
+ PL_endwhite = newSVpvn("",0);
+ sv_catsv(PL_endwhite, PL_thiswhite);
+ PL_thiswhite = 0;
+ sv_catpvn(PL_endwhite, tstart, PL_bufend - tstart);
+ PL_realtokenstart = -1;
}
- while ((s = filter_gets(endwhite, PL_rsfp,
- SvCUR(endwhite))) != Nullch) ;
+ while ((s = filter_gets(PL_endwhite, PL_rsfp,
+ SvCUR(PL_endwhite))) != Nullch) ;
}
#endif
PL_rsfp = NULL;
}
#ifdef PERL_MAD
if (PL_madskills) { /* just add type to declarator token */
- sv_catsv(thistoken, nextwhite);
- nextwhite = 0;
- sv_catpvn(thistoken, start, s - start);
+ sv_catsv(PL_thistoken, PL_nextwhite);
+ PL_nextwhite = 0;
+ sv_catpvn(PL_thistoken, start, s - start);
}
#endif
}
}
}
if (words) {
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = words;
force_next(THING);
}
#ifdef PERL_MAD
SV *tmpwhite = 0;
- char *tstart = SvPVX(PL_linestr) + realtokenstart;
+ char *tstart = SvPVX(PL_linestr) + PL_realtokenstart;
SV *subtoken = newSVpvn(tstart, s - tstart);
- thistoken = 0;
+ PL_thistoken = 0;
d = s;
s = SKIPSPACE2(s,tmpwhite);
if (*s == '=')
PL_lex_formbrack = PL_lex_brackets + 1;
#ifdef PERL_MAD
- thistoken = subtoken;
+ PL_thistoken = subtoken;
s = d;
#else
if (have_name)
#ifdef PERL_MAD
start_force(0);
- CURMAD('q', thisopen);
+ CURMAD('q', PL_thisopen);
CURMAD('_', tmpwhite);
- CURMAD('=', thisstuff);
- CURMAD('Q', thisclose);
+ CURMAD('=', PL_thisstuff);
+ CURMAD('Q', PL_thisclose);
NEXTVAL_NEXTTOKE.opval =
(OP*)newSVOP(OP_CONST, 0, PL_lex_stuff);
PL_lex_stuff = Nullsv;
}
force_next(0);
- thistoken = subtoken;
+ PL_thistoken = subtoken;
#else
if (have_proto) {
NEXTVAL_NEXTTOKE.opval =
char pit = PL_pending_ident;
PL_pending_ident = 0;
- /* realtokenstart = realtokenend = PL_bufptr - SvPVX(PL_linestr); */
+ /* PL_realtokenstart = realtokenend = PL_bufptr - SvPVX(PL_linestr); */
DEBUG_T({ PerlIO_printf(Perl_debug_log,
"### Pending identifier '%s'\n", PL_tokenbuf); });
s--;
#ifdef PERL_MAD
if (PL_madskills) {
- CURMAD('q', thisopen);
- CURMAD('_', thiswhite);
- CURMAD('E', thisstuff);
- CURMAD('Q', thisclose);
- realtokenstart = s - SvPVX(PL_linestr);
+ CURMAD('q', PL_thisopen);
+ CURMAD('_', PL_thiswhite);
+ CURMAD('E', PL_thisstuff);
+ CURMAD('Q', PL_thisclose);
+ PL_realtokenstart = s - SvPVX(PL_linestr);
}
#endif
#ifdef PERL_MAD
if (PL_madskills) {
- CURMAD('z', thisopen);
- CURMAD('R', thisstuff);
- CURMAD('Z', thisclose);
+ CURMAD('z', PL_thisopen);
+ CURMAD('R', PL_thisstuff);
+ CURMAD('Z', PL_thisclose);
}
modstart = s;
#endif
if (PL_madskills) {
if (modstart != s)
curmad('m', newSVpvn(modstart, s - modstart));
- append_madprops(thismad, (OP*)pm, 0);
- thismad = 0;
+ append_madprops(PL_thismad, (OP*)pm, 0);
+ PL_thismad = 0;
}
#endif
if ((pm->op_pmflags & PMf_CONTINUE) && ckWARN(WARN_REGEXP)) {
s--;
#ifdef PERL_MAD
if (PL_madskills) {
- CURMAD('q', thisopen);
- CURMAD('_', thiswhite);
- CURMAD('E', thisstuff);
- CURMAD('Q', thisclose);
- realtokenstart = s - SvPVX(PL_linestr);
+ CURMAD('q', PL_thisopen);
+ CURMAD('_', PL_thiswhite);
+ CURMAD('E', PL_thisstuff);
+ CURMAD('Q', PL_thisclose);
+ PL_realtokenstart = s - SvPVX(PL_linestr);
}
#endif
Perl_croak(aTHX_ "Transliteration replacement not terminated");
}
if (PL_madskills) {
- CURMAD('z', thisopen);
- CURMAD('R', thisstuff);
- CURMAD('Z', thisclose);
+ CURMAD('z', PL_thisopen);
+ CURMAD('R', PL_thisstuff);
+ CURMAD('Z', PL_thisclose);
}
complement = del = squash = 0;
if (PL_madskills) {
if (modstart != s)
curmad('m', newSVpvn(modstart, s - modstart));
- append_madprops(thismad, o, 0);
- thismad = 0;
+ append_madprops(PL_thismad, o, 0);
+ PL_thismad = 0;
}
#endif
I32 stuffstart = s - SvPVX(PL_linestr);
char *tstart;
- realtokenstart = -1;
+ PL_realtokenstart = -1;
#endif
s += 2;
#ifdef PERL_MAD
if (PL_madskills) {
tstart = PL_tokenbuf + !outer;
- thisclose = newSVpvn(tstart, len - !outer);
+ PL_thisclose = newSVpvn(tstart, len - !outer);
tstart = SvPVX(PL_linestr) + stuffstart;
- thisopen = newSVpvn(tstart, s - tstart);
+ PL_thisopen = newSVpvn(tstart, s - tstart);
stuffstart = s - SvPVX(PL_linestr);
}
#endif
#ifdef PERL_MAD
if (PL_madskills) {
tstart = SvPVX(PL_linestr) + stuffstart;
- if (thisstuff)
- sv_catpvn(thisstuff, tstart, s - tstart);
+ if (PL_thisstuff)
+ sv_catpvn(PL_thisstuff, tstart, s - tstart);
else
- thisstuff = newSVpvn(tstart, s - tstart);
+ PL_thisstuff = newSVpvn(tstart, s - tstart);
}
#endif
s += SvCUR(herewas);
sv_setpvn(tmpstr,d+1,s-d);
#ifdef PERL_MAD
if (PL_madskills) {
- if (thisstuff)
- sv_catpvn(thisstuff, d + 1, s - d);
+ if (PL_thisstuff)
+ sv_catpvn(PL_thisstuff, d + 1, s - d);
else
- thisstuff = newSVpvn(d + 1, s - d);
+ PL_thisstuff = newSVpvn(d + 1, s - d);
stuffstart = s - SvPVX(PL_linestr);
}
#endif
#ifdef PERL_MAD
if (PL_madskills) {
tstart = SvPVX(PL_linestr) + stuffstart;
- if (thisstuff)
- sv_catpvn(thisstuff, tstart, PL_bufend - tstart);
+ if (PL_thisstuff)
+ sv_catpvn(PL_thisstuff, tstart, PL_bufend - tstart);
else
- thisstuff = newSVpvn(tstart, PL_bufend - tstart);
+ PL_thisstuff = newSVpvn(tstart, PL_bufend - tstart);
}
#endif
if (!outer ||
}
#ifdef PERL_MAD
- if (realtokenstart >= 0) {
- stuffstart = realtokenstart;
- realtokenstart = -1;
+ if (PL_realtokenstart >= 0) {
+ stuffstart = PL_realtokenstart;
+ PL_realtokenstart = -1;
}
else
stuffstart = start - SvPVX(PL_linestr);
s += termlen;
#ifdef PERL_MAD
tstart = SvPVX(PL_linestr) + stuffstart;
- if (!thisopen && !keep_delims) {
- thisopen = newSVpvn(tstart, s - tstart);
+ if (!PL_thisopen && !keep_delims) {
+ PL_thisopen = newSVpvn(tstart, s - tstart);
stuffstart = s - SvPVX(PL_linestr);
}
#endif
#ifdef PERL_MAD
if (PL_madskills) {
char *tstart = SvPVX(PL_linestr) + stuffstart;
- if (thisstuff)
- sv_catpvn(thisstuff, tstart, PL_bufend - tstart);
+ if (PL_thisstuff)
+ sv_catpvn(PL_thisstuff, tstart, PL_bufend - tstart);
else
- thisstuff = newSVpvn(tstart, PL_bufend - tstart);
+ PL_thisstuff = newSVpvn(tstart, PL_bufend - tstart);
}
#endif
if (!PL_rsfp ||
#ifdef PERL_MAD
if (PL_madskills) {
char *tstart = SvPVX(PL_linestr) + stuffstart;
- if (thisstuff)
- sv_catpvn(thisstuff, tstart, s - tstart);
+ if (PL_thisstuff)
+ sv_catpvn(PL_thisstuff, tstart, s - tstart);
else
- thisstuff = newSVpvn(tstart, s - tstart);
- if (!thisclose && !keep_delims)
- thisclose = newSVpvn(s,termlen);
+ PL_thisstuff = newSVpvn(tstart, s - tstart);
+ if (!PL_thisclose && !keep_delims)
+ PL_thisclose = newSVpvn(s,termlen);
}
#endif
else {
if (PL_madskills) {
char *tstart = SvPVX(PL_linestr) + stuffstart;
- if (thisstuff)
- sv_catpvn(thisstuff, tstart, s - tstart - termlen);
+ if (PL_thisstuff)
+ sv_catpvn(PL_thisstuff, tstart, s - tstart - termlen);
else
- thisstuff = newSVpvn(tstart, s - tstart - termlen);
- if (!thisclose && !keep_delims)
- thisclose = newSVpvn(s - termlen,termlen);
+ PL_thisstuff = newSVpvn(tstart, s - tstart - termlen);
+ if (!PL_thisclose && !keep_delims)
+ PL_thisclose = newSVpvn(s - termlen,termlen);
}
}
#endif
SV* savewhite;
if (PL_madskills) {
- savewhite = thiswhite;
- thiswhite = 0;
+ savewhite = PL_thiswhite;
+ PL_thiswhite = 0;
}
#endif
if (PL_rsfp) {
#ifdef PERL_MAD
if (PL_madskills) {
- if (thistoken)
- sv_catpvn(thistoken, tokenstart, PL_bufend - tokenstart);
+ if (PL_thistoken)
+ sv_catpvn(PL_thistoken, tokenstart, PL_bufend - tokenstart);
else
- thistoken = newSVpvn(tokenstart, PL_bufend - tokenstart);
+ PL_thistoken = newSVpvn(tokenstart, PL_bufend - tokenstart);
}
#endif
s = filter_gets(PL_linestr, PL_rsfp, 0);
PL_expect = XTERM;
if (needargs) {
PL_lex_state = LEX_NORMAL;
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = 0;
force_next(',');
}
else if (PL_encoding)
sv_recode_to_utf8(stuff, PL_encoding);
}
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.opval = (OP*)newSVOP(OP_CONST, 0, stuff);
force_next(THING);
- start_force(curforce);
+ start_force(PL_curforce);
NEXTVAL_NEXTTOKE.ival = OP_FORMLINE;
force_next(LSTOP);
}
}
#ifdef PERL_MAD
if (PL_madskills) {
- if (thistoken)
- sv_catpvn(thistoken, tokenstart, s - tokenstart);
+ if (PL_thistoken)
+ sv_catpvn(PL_thistoken, tokenstart, s - tokenstart);
else
- thistoken = newSVpvn(tokenstart, s - tokenstart);
- thiswhite = savewhite;
+ PL_thistoken = newSVpvn(tokenstart, s - tokenstart);
+ PL_thiswhite = savewhite;
}
#endif
return s;
projects / p5sagit/p5-mst-13.2.git / commitdiff