#include "EXTERN.h"
#include "perl.h"
+#ifndef PERL_OBJECT
static void check_uni _((void));
static void force_next _((I32 type));
static char *force_version _((char *start));
static char *force_word _((char *start, int token, int check_keyword, int allow_pack, int allow_tick));
-static SV *q _((SV *sv));
+static SV *tokeq _((SV *sv));
static char *scan_const _((char *start));
static char *scan_formline _((char *s));
static char *scan_heredoc _((char *s));
static void restore_rsfp _((void *f));
static void restore_expect _((void *e));
static void restore_lex_expect _((void *e));
+#endif /* PERL_OBJECT */
static char ident_too_long[] = "Identifier too long";
-static char *linestart; /* beg. of most recently read line */
-
-static char pending_ident; /* pending identifier lookup */
-
-static struct {
- I32 super_state; /* lexer state to save */
- I32 sub_inwhat; /* "lex_inwhat" to use */
- OP *sub_op; /* "lex_op" to use */
-} sublex_info;
-
/* The following are arranged oddly so that the guard on the switch statement
* can get by with a single comparison (if the compiler is smart enough).
*/
/* grandfather return to old style */
#define OLDLOP(f) return(yylval.ival=f,expect = XTERM,bufptr = s,(int)LSTOP)
-static int
+STATIC int
ao(int toketype)
{
if (*bufptr == '=') {
return toketype;
}
-static void
+STATIC void
no_op(char *what, char *s)
{
char *oldbp = bufptr;
bufptr = oldbp;
}
-static void
+STATIC void
missingterm(char *s)
{
char tmpbuf[3];
char q;
if (s) {
char *nl = strrchr(s,'\n');
- if (nl)
+ if (nl)
*nl = '\0';
}
else if (multi_close < 32 || multi_close == 127) {
warn("Use of %s is deprecated", s);
}
-static void
+STATIC void
depcom(void)
{
deprecate("comma-less variable list");
#ifdef WIN32
-static I32
+STATIC I32
win32_textfilter(int idx, SV *sv, int maxlen)
{
I32 count = FILTER_READ(idx+1, sv, maxlen);
doextract = FALSE;
}
-static void
+STATIC void
restore_rsfp(void *f)
{
PerlIO *fp = (PerlIO*)f;
rsfp = fp;
}
-static void
+STATIC void
restore_expect(void *e)
{
/* a safe way to store a small integer in a pointer */
expect = (expectation)((char *)e - tokenbuf);
}
-static void
+STATIC void
restore_lex_expect(void *e)
{
/* a safe way to store a small integer in a pointer */
lex_expect = (expectation)((char *)e - tokenbuf);
}
-static void
+STATIC void
incline(char *s)
{
dTHR;
curcop->cop_line = atoi(n)-1;
}
-static char *
+STATIC char *
skipspace(register char *s)
{
dTHR;
}
}
-static void
+STATIC void
check_uni(void) {
char *s;
char ch;
#undef UNI
#define UNI(f) return uni(f,s)
-static int
+STATIC int
uni(I32 f, char *s)
{
yylval.ival = f;
#define LOP(f,x) return lop(f,x,s)
-static I32
+STATIC I32
lop(I32 f, expectation x, char *s)
{
dTHR;
return LSTOP;
}
-static void
+STATIC void
force_next(I32 type)
{
nexttype[nexttoke] = type;
}
}
-static char *
+STATIC char *
force_word(register char *start, int token, int check_keyword, int allow_pack, int allow_initial_tick)
{
register char *s;
return s;
}
-static void
+STATIC void
force_ident(register char *s, int kind)
{
if (s && *s) {
}
}
-static char *
+STATIC char *
force_version(char *s)
{
OP *version = Nullop;
return (s);
}
-static SV *
-q(SV *sv)
+STATIC SV *
+tokeq(SV *sv)
{
register char *s;
register char *send;
return sv;
}
-static I32
+STATIC I32
sublex_start(void)
{
register I32 op_type = yylval.ival;
return THING;
}
if (op_type == OP_CONST || op_type == OP_READLINE) {
- SV *sv = q(lex_stuff);
+ SV *sv = tokeq(lex_stuff);
STRLEN len;
char *p = SvPV(sv, len);
yylval.opval = (OP*)newSVOP(op_type, 0, newSVpv(p, len));
return FUNC;
}
-static I32
+STATIC I32
sublex_push(void)
{
dTHR;
return '(';
}
-static I32
+STATIC I32
sublex_done(void)
{
if (!lex_starts++) {
*/
-static char *
+STATIC char *
scan_const(char *start)
{
register char *send = bufend; /* end of the constant */
}
/* This is the one truly awful dwimmer necessary to conflate C and sed. */
-static int
+STATIC int
intuit_more(register char *s)
{
if (lex_brackets)
return TRUE;
}
-static int
+STATIC int
intuit_method(char *start, GV *gv)
{
char *s = start + (*start == '$');
return 0;
}
-static char*
+STATIC char*
incl_perldb(void)
{
if (perldb) {
/* Call function. The function is expected to */
/* call "FILTER_READ(idx+1, buf_sv)" first. */
/* Return: <0:error, =0:eof, >0:not eof */
- return (*funcp)(idx, buf_sv, maxlen);
+ return (*funcp)(PERL_OBJECT_THIS_ idx, buf_sv, maxlen);
}
-static char *
+STATIC char *
filter_gets(register SV *sv, register PerlIO *fp, STRLEN append)
{
#ifdef WIN32FILTER
if (SvIVX(linestr) == '\'') {
SV *sv = newSVsv(linestr);
if (!lex_inpat)
- sv = q(sv);
+ sv = tokeq(sv);
yylval.opval = (OP*)newSVOP(OP_CONST, 0, sv);
s = bufend;
}
else
lex_brackstack[lex_brackets++] = XOPERATOR;
s = skipspace(s);
- if (*s == '}') {
- if (expect == XSTATE) {
- lex_brackstack[lex_brackets-1] = XSTATE;
- break;
- }
+ if (*s == '}')
OPERATOR(HASHBRACK);
- }
/* This hack serves to disambiguate a pair of curlies
* as being a block or an anon hash. Normally, expectation
* determines that, but in cases where we're not in a
oldoldbufptr < bufptr &&
(oldoldbufptr == last_lop || oldoldbufptr == last_uni) &&
/* NO SKIPSPACE BEFORE HERE! */
- (expect == XREF ||
- ((opargs[last_lop_op] >> OASHIFT)& 7) == OA_FILEREF) )
+ (expect == XREF
+ || ((opargs[last_lop_op] >> OASHIFT)& 7) == OA_FILEREF
+ || (last_lop_op == OP_ENTERSUB
+ && last_proto
+ && last_proto[last_proto[0] == ';' ? 1 : 0] == '*')) )
{
bool immediate_paren = *s == '(';
/* Is there a prototype? */
if (SvPOK(cv)) {
STRLEN len;
- char *proto = SvPV((SV*)cv, len);
+ last_proto = SvPV((SV*)cv, len);
if (!len)
TERM(FUNC0SUB);
- if (strEQ(proto, "$"))
+ if (strEQ(last_proto, "$"))
OPERATOR(UNIOPSUB);
- if (*proto == '&' && *s == '{') {
+ if (*last_proto == '&' && *s == '{') {
sv_setpv(subname,"__ANON__");
PREBLOCK(LSTOPSUB);
}
- }
+ } else
+ last_proto = NULL;
nextval[nexttoke].opval = yylval.opval;
expect = XTERM;
force_next(WORD);
}
}
force_next(')');
- nextval[nexttoke].opval = (OP*)newSVOP(OP_CONST, 0, q(lex_stuff));
+ nextval[nexttoke].opval = (OP*)newSVOP(OP_CONST, 0, tokeq(lex_stuff));
lex_stuff = Nullsv;
force_next(THING);
force_next(',');
return 0;
}
-static void
+STATIC void
checkcomma(register char *s, char *name, char *what)
{
char *w;
}
}
-static char *
+STATIC char *
scan_word(register char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp)
{
register char *d = dest;
}
}
-static char *
+STATIC char *
scan_ident(register char *s, register char *send, char *dest, STRLEN destlen, I32 ck_uni)
{
register char *d;
*pmfl |= PMf_EXTENDED;
}
-static char *
+STATIC char *
scan_pat(char *start)
{
PMOP *pm;
return s;
}
-static char *
+STATIC char *
scan_subst(char *start)
{
register char *s;
return s;
}
-static char *
+STATIC char *
scan_trans(char *start)
{
register char* s;
return s;
}
-static char *
+STATIC char *
scan_heredoc(register char *s)
{
dTHR;
s--, herewas = newSVpv(s,d-s);
s += SvCUR(herewas);
- tmpstr = NEWSV(87,80);
+ tmpstr = NEWSV(87,79);
sv_upgrade(tmpstr, SVt_PVIV);
if (term == '\'') {
op_type = OP_CONST;
}
sv_setpvn(tmpstr,d+1,s-d);
s += len - 1;
- curcop->cop_line++; /* the preceding stmt passes a newline */
+ curcop->cop_line++; /* the preceding stmt passes a newline */
sv_catpvn(herewas,s,bufend-s);
sv_setsv(linestr,herewas);
*/
-static char *
+STATIC char *
scan_inputsymbol(char *start)
{
register char *s = start; /* current position in buffer */
*/
-static char *
+STATIC char *
scan_str(char *start)
{
dTHR;
multi_close = term;
/* create a new SV to hold the contents. 87 is leak category, I'm
- assuming. 80 is the SV's initial length. What a random number. */
- sv = NEWSV(87,80);
+ assuming. 79 is the SV's initial length. What a random number. */
+ sv = NEWSV(87,79);
sv_upgrade(sv, SVt_PVIV);
SvIVX(sv) = term;
(void)SvPOK_only(sv); /* validate pointer */
return s;
}
-static char *
+STATIC char *
scan_formline(register char *s)
{
dTHR;
return s;
}
-static void
+STATIC void
set_csh(void)
{
#ifdef CSH