X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=toke.c;h=8f90366433d4d56c94762690ab6ae463bb976986;hb=d0647d4e83baeaee38f56423fa99ba248e8c0db2;hp=5a0a5b328eef989916e58600fbf2fd333efd3bdf;hpb=0bd48802b00657d8da2da444a1c97fb25cb7d562;p=p5sagit%2Fp5-mst-13.2.git diff --git a/toke.c b/toke.c index 5a0a5b3..8f90366 100644 --- a/toke.c +++ b/toke.c @@ -1,7 +1,7 @@ /* toke.c * * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - * 2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others + * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -27,6 +27,7 @@ #define yylval (*PL_yylvalp) static const char ident_too_long[] = "Identifier too long"; +static const char commaless_variable_list[] = "comma-less variable list"; static void restore_rsfp(pTHX_ void *f); #ifndef PERL_NO_UTF16_FILTER @@ -219,6 +220,7 @@ static struct debug_tokens { const int token, type; const char *name; } { BITOROP, TOKENTYPE_OPNUM, "BITOROP" }, { COLONATTR, TOKENTYPE_NONE, "COLONATTR" }, { CONTINUE, TOKENTYPE_NONE, "CONTINUE" }, + { DEFAULT, TOKENTYPE_NONE, "DEFAULT" }, { DO, TOKENTYPE_NONE, "DO" }, { DOLSHARP, TOKENTYPE_NONE, "DOLSHARP" }, { DORDOR, TOKENTYPE_NONE, "DORDOR" }, @@ -234,6 +236,7 @@ static struct debug_tokens { const int token, type; const char *name; } { FUNC0SUB, TOKENTYPE_OPVAL, "FUNC0SUB" }, { FUNC1, TOKENTYPE_OPNUM, "FUNC1" }, { FUNCMETH, TOKENTYPE_OPVAL, "FUNCMETH" }, + { GIVEN, TOKENTYPE_IVAL, "GIVEN" }, { HASHBRACK, TOKENTYPE_NONE, "HASHBRACK" }, { IF, TOKENTYPE_IVAL, "IF" }, { LABEL, TOKENTYPE_PVAL, "LABEL" }, @@ -269,6 +272,7 @@ static struct debug_tokens { const int token, type; const char *name; } { UNLESS, TOKENTYPE_IVAL, "UNLESS" }, { UNTIL, TOKENTYPE_IVAL, "UNTIL" }, { USE, TOKENTYPE_IVAL, "USE" }, + { WHEN, TOKENTYPE_IVAL, "WHEN" }, { WHILE, TOKENTYPE_IVAL, "WHILE" }, { WORD, TOKENTYPE_OPVAL, "WORD" }, { 0, TOKENTYPE_NONE, 0 } @@ -279,11 +283,12 @@ static struct debug_tokens { const int token, type; const char *name; } STATIC int S_tokereport(pTHX_ I32 rv) { + dVAR; if (DEBUG_T_TEST) { const char *name = Nullch; enum token_type type = TOKENTYPE_NONE; const struct debug_tokens *p; - SV* const report = newSVpvn("<== ", 4); + SV* const report = newSVpvs("<== "); for (p = debug_tokens; p->token; p++) { if (p->token == (int)rv) { @@ -297,7 +302,7 @@ S_tokereport(pTHX_ I32 rv) else if ((char)rv > ' ' && (char)rv < '~') Perl_sv_catpvf(aTHX_ report, "'%c'", (char)rv); else if (!rv) - Perl_sv_catpv(aTHX_ report, "EOF"); + sv_catpvs(report, "EOF"); else Perl_sv_catpvf(aTHX_ report, "?? %"IVdf, (IV)rv); switch (type) { @@ -325,7 +330,7 @@ S_tokereport(pTHX_ I32 rv) } else - Perl_sv_catpv(aTHX_ report, "(opval=null)"); + sv_catpvs(report, "(opval=null)"); break; } PerlIO_printf(Perl_debug_log, "### %s\n\n", SvPV_nolen_const(report)); @@ -339,7 +344,7 @@ S_tokereport(pTHX_ I32 rv) STATIC void S_printbuf(pTHX_ const char* fmt, const char* s) { - SV* const tmp = newSVpvn("", 0); + SV* const tmp = newSVpvs(""); PerlIO_printf(Perl_debug_log, fmt, pv_display(tmp, s, strlen(s), 0, 60)); SvREFCNT_dec(tmp); } @@ -356,6 +361,7 @@ S_printbuf(pTHX_ const char* fmt, const char* s) STATIC int S_ao(pTHX_ int toketype) { + dVAR; if (*PL_bufptr == '=') { PL_bufptr++; if (toketype == ANDAND) @@ -385,6 +391,7 @@ S_ao(pTHX_ int toketype) STATIC void S_no_op(pTHX_ const char *what, char *s) { + dVAR; char * const oldbp = PL_bufptr; const bool is_first = (PL_oldbufptr == PL_linestart); @@ -426,6 +433,7 @@ S_no_op(pTHX_ const char *what, char *s) STATIC void S_missingterm(pTHX_ char *s) { + dVAR; char tmpbuf[3]; char q; if (s) { @@ -454,6 +462,24 @@ S_missingterm(pTHX_ char *s) Perl_croak(aTHX_ "Can't find string terminator %c%s%c anywhere before EOF",q,s,q); } +#define FEATURE_IS_ENABLED(name) \ + ((0 != (PL_hints & HINT_LOCALIZE_HH)) \ + && S_feature_is_enabled(aTHX_ STR_WITH_LEN(name))) +/* + * S_feature_is_enabled + * Check whether the named feature is enabled. + */ +STATIC bool +S_feature_is_enabled(pTHX_ char *name, STRLEN namelen) +{ + dVAR; + HV * const hinthv = GvHV(PL_hintgv); + char he_name[32] = "feature_"; + (void) strncpy(&he_name[8], name, 24); + + return (hinthv && hv_exists(hinthv, he_name, 8 + namelen)); +} + /* * Perl_deprecate */ @@ -482,17 +508,6 @@ Perl_deprecate_old(pTHX_ const char *s) } /* - * depcom - * Deprecate a comma-less variable list. - */ - -STATIC void -S_depcom(pTHX) -{ - deprecate_old("comma-less variable list"); -} - -/* * experimental text filters for win32 carriage-returns, utf16-to-utf8 and * utf16-to-utf8-reversed. */ @@ -539,6 +554,7 @@ S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen) void Perl_lex_start(pTHX_ SV *line) { + dVAR; const char *s; STRLEN len; @@ -599,7 +615,7 @@ Perl_lex_start(pTHX_ SV *line) if (!len || s[len-1] != ';') { if (!(SvFLAGS(PL_linestr) & SVs_TEMP)) PL_linestr = sv_2mortal(newSVsv(PL_linestr)); - sv_catpvn(PL_linestr, "\n;", 2); + sv_catpvs(PL_linestr, "\n;"); } SvTEMP_off(PL_linestr); PL_oldoldbufptr = PL_oldbufptr = PL_bufptr = PL_linestart = SvPVX(PL_linestr); @@ -617,6 +633,7 @@ Perl_lex_start(pTHX_ SV *line) void Perl_lex_end(pTHX) { + dVAR; PL_doextract = FALSE; } @@ -633,6 +650,7 @@ Perl_lex_end(pTHX) STATIC void S_incline(pTHX_ char *s) { + dVAR; char *t; char *n; char *e; @@ -727,6 +745,7 @@ S_incline(pTHX_ char *s) STATIC char * S_skipspace(pTHX_ register char *s) { + dVAR; if (PL_lex_formbrack && PL_lex_brackets <= PL_lex_formbrack) { while (s < PL_bufend && SPACE_OR_TAB(*s)) s++; @@ -825,13 +844,13 @@ S_skipspace(pTHX_ register char *s) * 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 * const sv = newSV(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_store(CopFILEAVx(PL_curcop),(I32)CopLINE(PL_curcop),sv); } } } @@ -848,6 +867,7 @@ S_skipspace(pTHX_ register char *s) STATIC void S_check_uni(pTHX) { + dVAR; char *s; char *t; @@ -858,6 +878,9 @@ S_check_uni(pTHX) for (s = PL_last_uni; isALNUM_lazy_if(s,UTF) || *s == '-'; s++) ; if ((t = strchr(s, '(')) && t < PL_bufptr) return; + + /* XXX Things like this are just so nasty. We shouldn't be modifying + source code, even if we realquick set it back. */ if (ckWARN_d(WARN_AMBIGUOUS)){ const char ch = *s; *s = '\0'; @@ -886,6 +909,7 @@ S_check_uni(pTHX) STATIC I32 S_lop(pTHX_ I32 f, int x, char *s) { + dVAR; yylval.ival = f; CLINE; PL_expect = x; @@ -915,6 +939,7 @@ S_lop(pTHX_ I32 f, int x, char *s) STATIC void S_force_next(pTHX_ I32 type) { + dVAR; PL_nexttype[PL_nexttoke] = type; PL_nexttoke++; if (PL_lex_state != LEX_KNOWNEXT) { @@ -927,6 +952,7 @@ S_force_next(pTHX_ I32 type) STATIC SV * S_newSV_maybe_utf8(pTHX_ const char *start, STRLEN len) { + dVAR; SV * const sv = newSVpvn(start,len); if (UTF && !IN_BYTES && is_utf8_string((const U8*)start, len)) SvUTF8_on(sv); @@ -952,6 +978,7 @@ S_newSV_maybe_utf8(pTHX_ const char *start, STRLEN len) STATIC char * S_force_word(pTHX_ register char *start, int token, int check_keyword, int allow_pack, int allow_initial_tick) { + dVAR; register char *s; STRLEN len; @@ -993,8 +1020,10 @@ S_force_word(pTHX_ register char *start, int token, int check_keyword, int allow STATIC void S_force_ident(pTHX_ register const char *s, int kind) { + dVAR; if (s && *s) { - OP* const o = (OP*)newSVOP(OP_CONST, 0, newSVpv(s,0)); + const STRLEN len = strlen(s); + OP* const o = (OP*)newSVOP(OP_CONST, 0, newSVpvn(s, len)); PL_nextval[PL_nexttoke].opval = o; force_next(WORD); if (kind) { @@ -1002,12 +1031,14 @@ S_force_ident(pTHX_ register const char *s, int kind) /* XXX see note in pp_entereval() for why we forgo typo warnings if the symbol must be introduced in an eval. GSAR 96-10-12 */ - gv_fetchpv(s, PL_in_eval ? (GV_ADDMULTI | GV_ADDINEVAL) : TRUE, - kind == '$' ? SVt_PV : - kind == '@' ? SVt_PVAV : - kind == '%' ? SVt_PVHV : + gv_fetchpvn_flags(s, len, + PL_in_eval ? (GV_ADDMULTI | GV_ADDINEVAL) + : GV_ADD, + kind == '$' ? SVt_PV : + kind == '@' ? SVt_PVAV : + kind == '%' ? SVt_PVHV : SVt_PVGV - ); + ); } } } @@ -1048,6 +1079,7 @@ Perl_str_to_version(pTHX_ SV *sv) STATIC char * S_force_version(pTHX_ char *s, int guessing) { + dVAR; OP *version = Nullop; char *d; @@ -1092,6 +1124,7 @@ S_force_version(pTHX_ char *s, int guessing) STATIC SV * S_tokeq(pTHX_ SV *sv) { + dVAR; register char *s; register char *send; register char *d; @@ -1165,6 +1198,7 @@ S_tokeq(pTHX_ SV *sv) STATIC I32 S_sublex_start(pTHX) { + dVAR; register const I32 op_type = yylval.ival; if (op_type == OP_NULL) { @@ -1280,7 +1314,7 @@ S_sublex_done(pTHX) { dVAR; if (!PL_lex_starts++) { - SV * const sv = newSVpvn("",0); + SV * const sv = newSVpvs(""); if (SvUTF8(PL_linestr)) SvUTF8_on(sv); PL_expect = XOPERATOR; @@ -1406,8 +1440,9 @@ S_sublex_done(pTHX) STATIC char * S_scan_const(pTHX_ char *start) { + dVAR; register char *send = PL_bufend; /* end of the constant */ - SV *sv = NEWSV(93, send - start); /* sv for the constant */ + SV *sv = newSV(send - start); /* sv for the constant */ register char *s = start; /* start of the constant */ register char *d = SvPVX(sv); /* destination for copies */ bool dorange = FALSE; /* are we in a translit range? */ @@ -1936,6 +1971,7 @@ S_scan_const(pTHX_ char *start) STATIC int S_intuit_more(pTHX_ register char *s) { + dVAR; if (PL_lex_brackets) return TRUE; if (*s == '-' && s[1] == '>' && (s[2] == '[' || s[2] == '{')) @@ -1998,8 +2034,10 @@ S_intuit_more(pTHX_ register char *s) case '$': weight -= seen[un_char] * 10; if (isALNUM_lazy_if(s+1,UTF)) { + int len; scan_ident(s, send, tmpbuf, sizeof tmpbuf, FALSE); - if ((int)strlen(tmpbuf) > 1 && gv_fetchpv(tmpbuf,FALSE, SVt_PV)) + len = (int)strlen(tmpbuf); + if (len > 1 && gv_fetchpvn_flags(tmpbuf, len, 0, SVt_PV)) weight -= 100; else weight -= 10; @@ -2088,24 +2126,26 @@ S_intuit_more(pTHX_ register char *s) */ STATIC int -S_intuit_method(pTHX_ char *start, GV *gv) +S_intuit_method(pTHX_ char *start, GV *gv, CV *cv) { + dVAR; char *s = start + (*start == '$'); char tmpbuf[sizeof PL_tokenbuf]; STRLEN len; GV* indirgv; if (gv) { - CV *cv; - if (GvIO(gv)) + if (SvTYPE(gv) == SVt_PVGV && GvIO(gv)) return 0; - if ((cv = GvCVu(gv))) { - const char *proto = SvPVX_const(cv); - if (proto) { - if (*proto == ';') - proto++; - if (*proto == '*') - return 0; + if (cv) { + if (SvPOK(cv)) { + const char *proto = SvPVX_const(cv); + if (proto) { + if (*proto == ';') + proto++; + if (*proto == '*') + return 0; + } } } else gv = 0; @@ -2130,7 +2170,7 @@ S_intuit_method(pTHX_ char *start, GV *gv) tmpbuf[len] = '\0'; goto bare_package; } - indirgv = gv_fetchpv(tmpbuf, FALSE, SVt_PVCV); + indirgv = gv_fetchpvn_flags(tmpbuf, len, 0, SVt_PVCV); if (indirgv && GvCVu(indirgv)) return 0; /* filehandle or package name makes it a method */ @@ -2161,6 +2201,7 @@ S_intuit_method(pTHX_ char *start, GV *gv) STATIC const char* S_incl_perldb(pTHX) { + dVAR; if (PL_perldb) { const char * const pdb = PerlEnv_getenv("PERL5DB"); @@ -2193,13 +2234,14 @@ S_incl_perldb(pTHX) SV * Perl_filter_add(pTHX_ filter_t funcp, SV *datasv) { + dVAR; if (!funcp) return Nullsv; if (!PL_rsfp_filters) PL_rsfp_filters = newAV(); if (!datasv) - datasv = NEWSV(255,0); + datasv = newSV(0); SvUPGRADE(datasv, SVt_PVIO); IoANY(datasv) = FPTR2DPTR(void *, funcp); /* stash funcp into spare field */ IoFLAGS(datasv) |= IOf_FAKE_DIRP; @@ -2215,6 +2257,7 @@ Perl_filter_add(pTHX_ filter_t funcp, SV *datasv) void Perl_filter_del(pTHX_ filter_t funcp) { + dVAR; SV *datasv; #ifdef DEBUGGING @@ -2241,6 +2284,7 @@ Perl_filter_del(pTHX_ filter_t funcp) I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) { + dVAR; filter_t funcp; SV *datasv = NULL; @@ -2297,6 +2341,7 @@ Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) STATIC char * S_filter_gets(pTHX_ register SV *sv, register PerlIO *fp, STRLEN append) { + dVAR; #ifdef PERL_CR_FILTER if (!PL_rsfp_filters) { filter_add(S_cr_textfilter,NULL); @@ -2317,6 +2362,7 @@ S_filter_gets(pTHX_ register SV *sv, register PerlIO *fp, STRLEN append) STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, I32 len) { + dVAR; GV *gv; if (len == 11 && *pkgname == '_' && strEQ(pkgname, "__PACKAGE__")) @@ -2324,13 +2370,13 @@ S_find_in_my_stash(pTHX_ const char *pkgname, I32 len) if (len > 2 && (pkgname[len - 2] == ':' && pkgname[len - 1] == ':') && - (gv = gv_fetchpv(pkgname, FALSE, SVt_PVHV))) + (gv = gv_fetchpvn_flags(pkgname, len, 0, SVt_PVHV))) { return GvHV(gv); /* Foo:: */ } /* use constant CLASS => 'MyClass' */ - if ((gv = gv_fetchpv(pkgname, FALSE, SVt_PVCV))) { + if ((gv = gv_fetchpvn_flags(pkgname, len, 0, SVt_PVCV))) { SV *sv; if (GvCV(gv) && (sv = cv_const_sv(GvCV(gv)))) { pkgname = SvPV_nolen_const(sv); @@ -2342,6 +2388,7 @@ S_find_in_my_stash(pTHX_ const char *pkgname, I32 len) STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) { + dVAR; if (PL_expect != XSTATE) yyerror(Perl_form(aTHX_ "\"%s\" not allowed in expression", is_use ? "use" : "no")); @@ -2403,17 +2450,14 @@ S_tokenize_use(pTHX_ int is_use, char *s) { int Perl_yylex(pTHX) { + dVAR; register char *s = PL_bufptr; register char *d; - register I32 tmp; STRLEN len; - GV *gv = Nullgv; - GV **gvp = 0; bool bof = FALSE; - I32 orig_keyword = 0; DEBUG_T( { - SV* tmp = newSVpvn("", 0); + SV* tmp = newSVpvs(""); PerlIO_printf(Perl_debug_log, "### %"IVdf":LEX_%s/X%s %s\n", (IV)CopLINE(PL_curcop), lex_state_names[PL_lex_state], @@ -2482,6 +2526,7 @@ Perl_yylex(pTHX) return yylex(); } else { + I32 tmp; if (strnEQ(s, "L\\u", 3) || strnEQ(s, "U\\l", 3)) tmp = *s, *s = s[2], s[2] = (char)tmp; /* misordered... */ if ((*s == 'L' || *s == 'U') && @@ -2663,21 +2708,21 @@ Perl_yylex(pTHX) PL_preambled = TRUE; sv_setpv(PL_linestr,incl_perldb()); if (SvCUR(PL_linestr)) - sv_catpvn(PL_linestr,";", 1); + sv_catpvs(PL_linestr,";"); if (PL_preambleav){ while(AvFILLp(PL_preambleav) >= 0) { SV *tmpsv = av_shift(PL_preambleav); sv_catsv(PL_linestr, tmpsv); - sv_catpvn(PL_linestr, ";", 1); + sv_catpvs(PL_linestr, ";"); sv_free(tmpsv); } sv_free((SV*)PL_preambleav); PL_preambleav = NULL; } if (PL_minus_n || PL_minus_p) { - sv_catpv(PL_linestr, "LINE: while (<>) {"); + sv_catpvs(PL_linestr, "LINE: while (<>) {"); if (PL_minus_l) - sv_catpv(PL_linestr,"chomp;"); + sv_catpvs(PL_linestr,"chomp;"); if (PL_minus_a) { if (PL_minus_F) { if ((*PL_splitstr == '/' || *PL_splitstr == '\'' @@ -2687,11 +2732,8 @@ Perl_yylex(pTHX) else { /* "q\0${splitstr}\0" is legal perl. Yes, even NUL bytes can be used as quoting characters. :-) */ - /* The count here deliberately includes the NUL - that terminates the C string constant. This - embeds the opening NUL into the string. */ const char *splits = PL_splitstr; - sv_catpvn(PL_linestr, "our @F=split(q", 15); + sv_catpvs(PL_linestr, "our @F=split(q\0"); do { /* Need to \ \s */ if (*splits == '\\') @@ -2701,25 +2743,27 @@ Perl_yylex(pTHX) /* This loop will embed the trailing NUL of PL_linestr as the last thing it does before terminating. */ - sv_catpvn(PL_linestr, ");", 2); + sv_catpvs(PL_linestr, ");"); } } else - sv_catpv(PL_linestr,"our @F=split(' ');"); + sv_catpvs(PL_linestr,"our @F=split(' ');"); } } - sv_catpvn(PL_linestr, "\n", 1); + if (PL_minus_E) + sv_catpvs(PL_linestr,"use feature ':5.10';"); + sv_catpvs(PL_linestr, "\n"); PL_oldoldbufptr = PL_oldbufptr = s = PL_linestart = SvPVX(PL_linestr); PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr); PL_last_lop = PL_last_uni = Nullch; if (PERLDB_LINE && PL_curstash != PL_debstash) { - SV * const sv = NEWSV(85,0); + SV * const sv = newSV(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_store(CopFILEAVx(PL_curcop),(I32)CopLINE(PL_curcop),sv); } goto retry; } @@ -2800,13 +2844,13 @@ Perl_yylex(pTHX) } while (PL_doextract); PL_oldoldbufptr = PL_oldbufptr = PL_bufptr = PL_linestart = s; if (PERLDB_LINE && PL_curstash != PL_debstash) { - SV * const sv = NEWSV(85,0); + SV * const sv = newSV(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_store(CopFILEAVx(PL_curcop),(I32)CopLINE(PL_curcop),sv); } PL_bufend = SvPVX(PL_linestr) + SvCUR(PL_linestr); PL_last_lop = PL_last_uni = Nullch; @@ -2846,7 +2890,8 @@ Perl_yylex(pTHX) * at least, set argv[0] to the basename of the Perl * interpreter. So, having found "#!", we'll set it right. */ - SV * const x = GvSV(gv_fetchpv("\030", TRUE, SVt_PV)); /* $^X */ + SV * const x + = GvSV(gv_fetchpvs("\030", GV_ADD, SVt_PV)); /* $^X */ assert(SvPOK(x) || SvGMAGICAL(x)); if (sv_eq(x, CopFILESV(PL_curcop))) { sv_setpvn(x, ipath, ipathend - ipath); @@ -2944,15 +2989,15 @@ Perl_yylex(pTHX) } #endif if (d) { - const U32 oldpdb = PL_perldb; - const bool oldn = PL_minus_n; - const bool oldp = PL_minus_p; - while (*d && !isSPACE(*d)) d++; while (SPACE_OR_TAB(*d)) d++; if (*d++ == '-') { const bool switches_done = PL_doswitches; + const U32 oldpdb = PL_perldb; + const bool oldn = PL_minus_n; + const bool oldp = PL_minus_p; + do { if (*d == 'M' || *d == 'm' || *d == 'C') { const char * const m = d; @@ -2984,14 +3029,6 @@ Perl_yylex(pTHX) (void)gv_fetchfile(PL_origfilename); goto retry; } - if (PL_doswitches && !switches_done) { - int argc = PL_origargc; - char **argv = PL_origargv; - do { - argc--,argv++; - } while (argc && argv[0][0] == '-' && argv[0][1]); - init_argv_symbols(argc,argv); - } } } } @@ -3044,6 +3081,7 @@ Perl_yylex(pTHX) case '-': if (s[1] && isALPHA(s[1]) && !isALNUM(s[2])) { I32 ftst = 0; + char tmp; s++; PL_bufptr = s; @@ -3086,7 +3124,7 @@ Perl_yylex(pTHX) case 'T': ftst = OP_FTTEXT; break; case 'B': ftst = OP_FTBINARY; break; case 'M': case 'A': case 'C': - gv_fetchpv("\024",TRUE, SVt_PV); + gv_fetchpvs("\024",GV_ADD, SVt_PV); switch (tmp) { case 'M': ftst = OP_FTMTIME; break; case 'A': ftst = OP_FTATIME; break; @@ -3114,49 +3152,53 @@ Perl_yylex(pTHX) s = --PL_bufptr; } } - tmp = *s++; - if (*s == tmp) { - s++; + { + const char tmp = *s++; + if (*s == tmp) { + s++; + if (PL_expect == XOPERATOR) + TERM(POSTDEC); + else + OPERATOR(PREDEC); + } + else if (*s == '>') { + s++; + s = skipspace(s); + if (isIDFIRST_lazy_if(s,UTF)) { + s = force_word(s,METHOD,FALSE,TRUE,FALSE); + TOKEN(ARROW); + } + else if (*s == '$') + OPERATOR(ARROW); + else + TERM(ARROW); + } if (PL_expect == XOPERATOR) - TERM(POSTDEC); - else - OPERATOR(PREDEC); - } - else if (*s == '>') { - s++; - s = skipspace(s); - if (isIDFIRST_lazy_if(s,UTF)) { - s = force_word(s,METHOD,FALSE,TRUE,FALSE); - TOKEN(ARROW); + Aop(OP_SUBTRACT); + else { + if (isSPACE(*s) || !isSPACE(*PL_bufptr)) + check_uni(); + OPERATOR('-'); /* unary minus */ } - else if (*s == '$') - OPERATOR(ARROW); - else - TERM(ARROW); - } - if (PL_expect == XOPERATOR) - Aop(OP_SUBTRACT); - else { - if (isSPACE(*s) || !isSPACE(*PL_bufptr)) - check_uni(); - OPERATOR('-'); /* unary minus */ } case '+': - tmp = *s++; - if (*s == tmp) { - s++; + { + const char tmp = *s++; + if (*s == tmp) { + s++; + if (PL_expect == XOPERATOR) + TERM(POSTINC); + else + OPERATOR(PREINC); + } if (PL_expect == XOPERATOR) - TERM(POSTINC); - else - OPERATOR(PREINC); - } - if (PL_expect == XOPERATOR) - Aop(OP_ADD); - else { - if (isSPACE(*s) || !isSPACE(*PL_bufptr)) - check_uni(); - OPERATOR('+'); + Aop(OP_ADD); + else { + if (isSPACE(*s) || !isSPACE(*PL_bufptr)) + check_uni(); + OPERATOR('+'); + } } case '*': @@ -3195,13 +3237,22 @@ Perl_yylex(pTHX) PL_lex_brackets++; /* FALL THROUGH */ case '~': + if (s[1] == '~' + && (PL_expect == XOPERATOR || PL_expect == XTERMORDORDOR) + && FEATURE_IS_ENABLED("~~")) + { + s += 2; + Eop(OP_SMARTMATCH); + } case ',': - tmp = *s++; - OPERATOR(tmp); + { + const char tmp = *s++; + OPERATOR(tmp); + } case ':': if (s[1] == ':') { len = 0; - goto just_a_word; + goto just_a_word_zero_gv; } s++; switch (PL_expect) { @@ -3220,6 +3271,7 @@ Perl_yylex(pTHX) s = skipspace(s); attrs = Nullop; while (isIDFIRST_lazy_if(s,UTF)) { + I32 tmp; d = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len); if (isLOWER(*s) && (tmp = keyword(PL_tokenbuf, len))) { if (tmp < 0) tmp = -tmp; @@ -3301,24 +3353,30 @@ Perl_yylex(pTHX) else if (s == d) break; /* require real whitespace or :'s */ } - tmp = (PL_expect == XOPERATOR ? '=' : '{'); /*'}(' for vi */ - if (*s != ';' && *s != '}' && *s != tmp && (tmp != '=' || *s != ')')) { - const char q = ((*s == '\'') ? '"' : '\''); - /* If here for an expression, and parsed no attrs, back off. */ - if (tmp == '=' && !attrs) { - s = PL_bufptr; - break; + { + const char tmp + = (PL_expect == XOPERATOR ? '=' : '{'); /*'}(' for vi */ + if (*s != ';' && *s != '}' && *s != tmp + && (tmp != '=' || *s != ')')) { + const char q = ((*s == '\'') ? '"' : '\''); + /* If here for an expression, and parsed no attrs, back + off. */ + if (tmp == '=' && !attrs) { + s = PL_bufptr; + break; + } + /* MUST advance bufptr here to avoid bogus "at end of line" + context messages from yyerror(). + */ + PL_bufptr = s; + yyerror( *s + ? Perl_form(aTHX_ "Invalid separator character " + "%c%c%c in attribute list", q, *s, q) + : "Unterminated attribute list" ); + if (attrs) + op_free(attrs); + OPERATOR(':'); } - /* MUST advance bufptr here to avoid bogus "at end of line" - context messages from yyerror(). - */ - PL_bufptr = s; - yyerror( *s - ? Perl_form(aTHX_ "Invalid separator character %c%c%c in attribute list", q, *s, q) - : "Unterminated attribute list" ); - if (attrs) - op_free(attrs); - OPERATOR(':'); } got_attrs: if (attrs) { @@ -3338,14 +3396,18 @@ Perl_yylex(pTHX) TOKEN('('); case ';': CLINE; - tmp = *s++; - OPERATOR(tmp); + { + const char tmp = *s++; + OPERATOR(tmp); + } case ')': - tmp = *s++; - s = skipspace(s); - if (*s == '{') - PREBLOCK(tmp); - TERM(tmp); + { + const char tmp = *s++; + s = skipspace(s); + if (*s == '{') + PREBLOCK(tmp); + TERM(tmp); + } case ']': s++; if (PL_lex_brackets <= 0) @@ -3553,8 +3615,7 @@ Perl_yylex(pTHX) TOKEN(';'); case '&': s++; - tmp = *s++; - if (tmp == '&') + if (*s++ == '&') AOPERATOR(ANDAND); s--; if (PL_expect == XOPERATOR) { @@ -3580,47 +3641,50 @@ Perl_yylex(pTHX) case '|': s++; - tmp = *s++; - if (tmp == '|') + if (*s++ == '|') AOPERATOR(OROR); s--; BOop(OP_BIT_OR); case '=': s++; - tmp = *s++; - if (tmp == '=') - Eop(OP_EQ); - if (tmp == '>') - OPERATOR(','); - if (tmp == '~') - PMop(OP_MATCH); - if (tmp && isSPACE(*s) && ckWARN(WARN_SYNTAX) && strchr("+-*/%.^&|<",tmp)) - Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Reversed %c= operator",(int)tmp); - s--; - if (PL_expect == XSTATE && isALPHA(tmp) && - (s == PL_linestart+1 || s[-2] == '\n') ) { - if (PL_in_eval && !PL_rsfp) { - d = PL_bufend; - while (s < d) { - if (*s++ == '\n') { - incline(s); - if (strnEQ(s,"=cut",4)) { - s = strchr(s,'\n'); - if (s) - s++; - else - s = d; - incline(s); - goto retry; + const char tmp = *s++; + if (tmp == '=') + Eop(OP_EQ); + if (tmp == '>') + OPERATOR(','); + if (tmp == '~') + PMop(OP_MATCH); + if (tmp && isSPACE(*s) && ckWARN(WARN_SYNTAX) + && strchr("+-*/%.^&|<",tmp)) + Perl_warner(aTHX_ packWARN(WARN_SYNTAX), + "Reversed %c= operator",(int)tmp); + s--; + if (PL_expect == XSTATE && isALPHA(tmp) && + (s == PL_linestart+1 || s[-2] == '\n') ) + { + if (PL_in_eval && !PL_rsfp) { + d = PL_bufend; + while (s < d) { + if (*s++ == '\n') { + incline(s); + if (strnEQ(s,"=cut",4)) { + s = strchr(s,'\n'); + if (s) + s++; + else + s = d; + incline(s); + goto retry; + } + } } + goto retry; } + s = PL_bufend; + PL_doextract = TRUE; + goto retry; } - goto retry; - } - s = PL_bufend; - PL_doextract = TRUE; - goto retry; } if (PL_lex_brackets < PL_lex_formbrack) { const char *t; @@ -3639,27 +3703,30 @@ Perl_yylex(pTHX) OPERATOR(ASSIGNOP); case '!': s++; - tmp = *s++; - if (tmp == '=') { - /* was this !=~ where !~ was meant? - * warn on m:!=~\s+([/?]|[msy]\W|tr\W): */ - - if (*s == '~' && ckWARN(WARN_SYNTAX)) { - const char *t = s+1; - - while (t < PL_bufend && isSPACE(*t)) - ++t; - - if (*t == '/' || *t == '?' || - ((*t == 'm' || *t == 's' || *t == 'y') && !isALNUM(t[1])) || - (*t == 't' && t[1] == 'r' && !isALNUM(t[2]))) - Perl_warner(aTHX_ packWARN(WARN_SYNTAX), - "!=~ should be !~"); - } - Eop(OP_NE); - } - if (tmp == '~') - PMop(OP_NOT); + { + const char tmp = *s++; + if (tmp == '=') { + /* was this !=~ where !~ was meant? + * warn on m:!=~\s+([/?]|[msy]\W|tr\W): */ + + if (*s == '~' && ckWARN(WARN_SYNTAX)) { + const char *t = s+1; + + while (t < PL_bufend && isSPACE(*t)) + ++t; + + if (*t == '/' || *t == '?' || + ((*t == 'm' || *t == 's' || *t == 'y') + && !isALNUM(t[1])) || + (*t == 't' && t[1] == 'r' && !isALNUM(t[2]))) + Perl_warner(aTHX_ packWARN(WARN_SYNTAX), + "!=~ should be !~"); + } + Eop(OP_NE); + } + if (tmp == '~') + PMop(OP_NOT); + } s--; OPERATOR('!'); case '<': @@ -3673,25 +3740,29 @@ Perl_yylex(pTHX) TERM(sublex_start()); } s++; - tmp = *s++; - if (tmp == '<') - SHop(OP_LEFT_SHIFT); - if (tmp == '=') { - tmp = *s++; - if (tmp == '>') - Eop(OP_NCMP); - s--; - Rop(OP_LE); + { + char tmp = *s++; + if (tmp == '<') + SHop(OP_LEFT_SHIFT); + if (tmp == '=') { + tmp = *s++; + if (tmp == '>') + Eop(OP_NCMP); + s--; + Rop(OP_LE); + } } s--; Rop(OP_LT); case '>': s++; - tmp = *s++; - if (tmp == '>') - SHop(OP_RIGHT_SHIFT); - if (tmp == '=') - Rop(OP_GE); + { + const char tmp = *s++; + if (tmp == '>') + SHop(OP_RIGHT_SHIFT); + if (tmp == '=') + Rop(OP_GE); + } s--; Rop(OP_GT); @@ -3701,7 +3772,7 @@ Perl_yylex(pTHX) if (PL_expect == XOPERATOR) { if (PL_lex_formbrack && PL_lex_brackets == PL_lex_formbrack) { PL_expect = XTERM; - depcom(); + deprecate_old(commaless_variable_list); return REPORT(','); /* grandfather non-comma-format format */ } } @@ -3739,93 +3810,102 @@ Perl_yylex(pTHX) } d = s; - tmp = (I32)*s; - if (PL_lex_state == LEX_NORMAL) - s = skipspace(s); + { + const char tmp = *s; + if (PL_lex_state == LEX_NORMAL) + s = skipspace(s); - if ((PL_expect != XREF || PL_oldoldbufptr == PL_last_lop) && intuit_more(s)) { - if (*s == '[') { - PL_tokenbuf[0] = '@'; - if (ckWARN(WARN_SYNTAX)) { - char *t; - for(t = s + 1; - isSPACE(*t) || isALNUM_lazy_if(t,UTF) || *t == '$'; - t++) ; - if (*t++ == ',') { - PL_bufptr = skipspace(PL_bufptr); - while (t < PL_bufend && *t != ']') - t++; - Perl_warner(aTHX_ packWARN(WARN_SYNTAX), - "Multidimensional syntax %.*s not supported", - (t - PL_bufptr) + 1, PL_bufptr); - } - } - } - else if (*s == '{') { - char *t; - PL_tokenbuf[0] = '%'; - if (strEQ(PL_tokenbuf+1, "SIG") && ckWARN(WARN_SYNTAX) - && (t = strchr(s, '}')) && (t = strchr(t, '='))) - { - char tmpbuf[sizeof PL_tokenbuf]; - for (t++; isSPACE(*t); t++) ; - if (isIDFIRST_lazy_if(t,UTF)) { - STRLEN len; - t = scan_word(t, tmpbuf, sizeof tmpbuf, TRUE, &len); - for (; isSPACE(*t); t++) ; - if (*t == ';' && get_cv(tmpbuf, FALSE)) + if ((PL_expect != XREF || PL_oldoldbufptr == PL_last_lop) + && intuit_more(s)) { + if (*s == '[') { + PL_tokenbuf[0] = '@'; + if (ckWARN(WARN_SYNTAX)) { + char *t; + for(t = s + 1; + isSPACE(*t) || isALNUM_lazy_if(t,UTF) || *t == '$'; + t++) ; + if (*t++ == ',') { + PL_bufptr = skipspace(PL_bufptr); + while (t < PL_bufend && *t != ']') + t++; Perl_warner(aTHX_ packWARN(WARN_SYNTAX), - "You need to quote \"%s\"", tmpbuf); + "Multidimensional syntax %.*s not supported", + (int)((t - PL_bufptr) + 1), PL_bufptr); + } } } + else if (*s == '{') { + char *t; + PL_tokenbuf[0] = '%'; + if (strEQ(PL_tokenbuf+1, "SIG") && ckWARN(WARN_SYNTAX) + && (t = strchr(s, '}')) && (t = strchr(t, '='))) + { + char tmpbuf[sizeof PL_tokenbuf]; + for (t++; isSPACE(*t); t++) ; + if (isIDFIRST_lazy_if(t,UTF)) { + STRLEN len; + t = scan_word(t, tmpbuf, sizeof tmpbuf, TRUE, + &len); + for (; isSPACE(*t); t++) ; + if (*t == ';' && get_cv(tmpbuf, FALSE)) + Perl_warner(aTHX_ packWARN(WARN_SYNTAX), + "You need to quote \"%s\"", + tmpbuf); + } + } + } } - } - PL_expect = XOPERATOR; - if (PL_lex_state == LEX_NORMAL && isSPACE((char)tmp)) { - const bool islop = (PL_last_lop == PL_oldoldbufptr); - if (!islop || PL_last_lop_op == OP_GREPSTART) - PL_expect = XOPERATOR; - else if (strchr("$@\"'`q", *s)) - PL_expect = XTERM; /* e.g. print $fh "foo" */ - else if (strchr("&*<%", *s) && isIDFIRST_lazy_if(s+1,UTF)) - PL_expect = XTERM; /* e.g. print $fh &sub */ - else if (isIDFIRST_lazy_if(s,UTF)) { - char tmpbuf[sizeof PL_tokenbuf]; - scan_word(s, tmpbuf, sizeof tmpbuf, TRUE, &len); - if ((tmp = keyword(tmpbuf, len))) { - /* binary operators exclude handle interpretations */ - switch (tmp) { - case -KEY_x: - case -KEY_eq: - case -KEY_ne: - case -KEY_gt: - case -KEY_lt: - case -KEY_ge: - case -KEY_le: - case -KEY_cmp: - break; - default: - PL_expect = XTERM; /* e.g. print $fh length() */ - break; + PL_expect = XOPERATOR; + if (PL_lex_state == LEX_NORMAL && isSPACE((char)tmp)) { + const bool islop = (PL_last_lop == PL_oldoldbufptr); + if (!islop || PL_last_lop_op == OP_GREPSTART) + PL_expect = XOPERATOR; + else if (strchr("$@\"'`q", *s)) + PL_expect = XTERM; /* e.g. print $fh "foo" */ + else if (strchr("&*<%", *s) && isIDFIRST_lazy_if(s+1,UTF)) + PL_expect = XTERM; /* e.g. print $fh &sub */ + else if (isIDFIRST_lazy_if(s,UTF)) { + char tmpbuf[sizeof PL_tokenbuf]; + int t2; + scan_word(s, tmpbuf, sizeof tmpbuf, TRUE, &len); + if ((t2 = keyword(tmpbuf, len))) { + /* binary operators exclude handle interpretations */ + switch (t2) { + case -KEY_x: + case -KEY_eq: + case -KEY_ne: + case -KEY_gt: + case -KEY_lt: + case -KEY_ge: + case -KEY_le: + case -KEY_cmp: + break; + default: + PL_expect = XTERM; /* e.g. print $fh length() */ + break; + } + } + else { + PL_expect = XTERM; /* e.g. print $fh subr() */ } } - else { - PL_expect = XTERM; /* e.g. print $fh subr() */ - } + else if (isDIGIT(*s)) + PL_expect = XTERM; /* e.g. print $fh 3 */ + else if (*s == '.' && isDIGIT(s[1])) + PL_expect = XTERM; /* e.g. print $fh .3 */ + else if ((*s == '?' || *s == '-' || *s == '+') + && !isSPACE(s[1]) && s[1] != '=') + PL_expect = XTERM; /* e.g. print $fh -1 */ + else if (*s == '/' && !isSPACE(s[1]) && s[1] != '=' + && s[1] != '/') + PL_expect = XTERM; /* e.g. print $fh /.../ + XXX except DORDOR operator + */ + else if (*s == '<' && s[1] == '<' && !isSPACE(s[2]) + && s[2] != '=') + PL_expect = XTERM; /* print $fh <<"EOF" */ } - else if (isDIGIT(*s)) - PL_expect = XTERM; /* e.g. print $fh 3 */ - else if (*s == '.' && isDIGIT(s[1])) - PL_expect = XTERM; /* e.g. print $fh .3 */ - else if ((*s == '?' || *s == '-' || *s == '+') - && !isSPACE(s[1]) && s[1] != '=') - PL_expect = XTERM; /* e.g. print $fh -1 */ - else if (*s == '/' && !isSPACE(s[1]) && s[1] != '=' && s[1] != '/') - PL_expect = XTERM; /* e.g. print $fh /.../ - XXX except DORDOR operator */ - else if (*s == '<' && s[1] == '<' && !isSPACE(s[2]) && s[2] != '=') - PL_expect = XTERM; /* print $fh <<"EOF" */ } PL_pending_ident = '$'; TOKEN('$'); @@ -3855,7 +3935,8 @@ Perl_yylex(pTHX) PL_bufptr = skipspace(PL_bufptr); Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Scalar value %.*s better written as $%.*s", - t-PL_bufptr, PL_bufptr, t-PL_bufptr-1, PL_bufptr+1); + (int)(t-PL_bufptr), PL_bufptr, + (int)(t-PL_bufptr-1), PL_bufptr+1); } } } @@ -3870,7 +3951,7 @@ Perl_yylex(pTHX) } case '?': /* may either be conditional or pattern */ if(PL_expect == XOPERATOR) { - tmp = *s++; + char tmp = *s++; if(tmp == '?') { OPERATOR('?'); } @@ -3912,7 +3993,7 @@ Perl_yylex(pTHX) goto rightbracket; } if (PL_expect == XOPERATOR || !isDIGIT(s[1])) { - tmp = *s++; + char tmp = *s++; if (*s == tmp) { s++; if (*s == tmp) { @@ -3942,7 +4023,7 @@ Perl_yylex(pTHX) if (PL_expect == XOPERATOR) { if (PL_lex_formbrack && PL_lex_brackets == PL_lex_formbrack) { PL_expect = XTERM; - depcom(); + deprecate_old(commaless_variable_list); return REPORT(','); /* grandfather non-comma-format format */ } else @@ -3959,7 +4040,7 @@ Perl_yylex(pTHX) if (PL_expect == XOPERATOR) { if (PL_lex_formbrack && PL_lex_brackets == PL_lex_formbrack) { PL_expect = XTERM; - depcom(); + deprecate_old(commaless_variable_list); return REPORT(','); /* grandfather non-comma-format format */ } else @@ -4014,7 +4095,7 @@ Perl_yylex(pTHX) const char c = *start; GV *gv; *start = '\0'; - gv = gv_fetchpv(s, FALSE, SVt_PVCV); + gv = gv_fetchpv(s, 0, SVt_PVCV); *start = c; if (!gv) { s = scan_num(s, &yylval); @@ -4059,9 +4140,10 @@ Perl_yylex(pTHX) case 'z': case 'Z': keylookup: { - orig_keyword = 0; - gv = Nullgv; - gvp = 0; + I32 tmp; + I32 orig_keyword = 0; + GV *gv = NULL; + GV **gvp = NULL; PL_bufptr = s; s = scan_word(s, PL_tokenbuf, sizeof PL_tokenbuf, FALSE, &len); @@ -4103,11 +4185,11 @@ Perl_yylex(pTHX) } if (tmp < 0) { /* second-class keyword? */ - GV *ogv = Nullgv; /* override (winner) */ - GV *hgv = Nullgv; /* hidden (loser) */ + GV *ogv = NULL; /* override (winner) */ + GV *hgv = NULL; /* hidden (loser) */ if (PL_expect != XOPERATOR && (*s != ':' || s[1] != ':')) { CV *cv; - if ((gv = gv_fetchpv(PL_tokenbuf, FALSE, SVt_PVCV)) && + if ((gv = gv_fetchpvn_flags(PL_tokenbuf, len, 0, SVt_PVCV)) && (cv = GvCVu(gv))) { if (GvIMPORTED_CV(gv)) @@ -4130,20 +4212,10 @@ Perl_yylex(pTHX) else if (gv && !gvp && -tmp==KEY_lock /* XXX generalizable kludge */ && GvCVu(gv) - && !hv_fetch(GvHVn(PL_incgv), "Thread.pm", 9, FALSE)) + && !hv_fetchs(GvHVn(PL_incgv), "Thread.pm", FALSE)) { tmp = 0; /* any sub overrides "weak" keyword */ } - else if (gv && !gvp - && tmp == -KEY_err - && GvCVu(gv) - && PL_expect != XOPERATOR - && PL_expect != XTERMORDORDOR) - { - /* any sub overrides the "err" keyword, except when really an - * operator is expected */ - tmp = 0; - } else { /* no override */ tmp = -tmp; if (tmp == KEY_dump && ckWARN(WARN_MISC)) { @@ -4164,10 +4236,21 @@ Perl_yylex(pTHX) switch (tmp) { default: /* not a keyword */ + /* Trade off - by using this evil construction we can pull the + variable gv into the block labelled keylookup. If not, then + we have to give it function scope so that the goto from the + earlier ':' case doesn't bypass the initialisation. */ + if (0) { + just_a_word_zero_gv: + gv = NULL; + gvp = NULL; + orig_keyword = 0; + } just_a_word: { SV *sv; int pkgname = 0; const char lastchar = (PL_bufptr == PL_oldoldbufptr ? 0 : PL_bufptr[-1]); + CV *cv; /* Get the rest if it looks like a package qualifier */ @@ -4199,7 +4282,8 @@ Perl_yylex(pTHX) if (len > 2 && PL_tokenbuf[len - 2] == ':' && PL_tokenbuf[len - 1] == ':') { - if (ckWARN(WARN_BAREWORD) && ! gv_fetchpv(PL_tokenbuf, FALSE, SVt_PVHV)) + if (ckWARN(WARN_BAREWORD) + && ! gv_fetchpvn_flags(PL_tokenbuf, len, 0, SVt_PVHV)) Perl_warner(aTHX_ packWARN(WARN_BAREWORD), "Bareword \"%s\" refers to nonexistent package", PL_tokenbuf); @@ -4210,14 +4294,20 @@ Perl_yylex(pTHX) } else { len = 0; - if (!gv) - gv = gv_fetchpv(PL_tokenbuf, FALSE, SVt_PVCV); + if (!gv) { + /* Mustn't actually add anything to a symbol table. + But also don't want to "initialise" any placeholder + constants that might already be there into full + blown PVGVs with attached PVCV. */ + gv = gv_fetchpvn_flags(PL_tokenbuf, len, + GV_NOADD_NOINIT, SVt_PVCV); + } } /* if we saw a global override before, get the right name */ if (gvp) { - sv = newSVpvn("CORE::GLOBAL::",14); + sv = newSVpvs("CORE::GLOBAL::"); sv_catpv(sv,PL_tokenbuf); } else { @@ -4242,6 +4332,20 @@ Perl_yylex(pTHX) if (len) goto safe_bareword; + /* Do the explicit type check so that we don't need to force + the initialisation of the symbol table to have a real GV. + Beware - gv may not really be a PVGV, cv may not really be + a PVCV, (because of the space optimisations that gv_init + understands) But they're true if for this symbol there is + respectively a typeglob and a subroutine. + */ + cv = gv ? ((SvTYPE(gv) == SVt_PVGV) + /* Real typeglob, so get the real subroutine: */ + ? GvCVu(gv) + /* A proxy for a subroutine in this package? */ + : SvOK(gv) ? (CV *) gv : NULL) + : NULL; + /* See if it's the indirect object for a list operator. */ if (PL_oldoldbufptr && @@ -4259,7 +4363,8 @@ Perl_yylex(pTHX) /* Two barewords in a row may indicate method call. */ - if ((isIDFIRST_lazy_if(s,UTF) || *s == '$') && (tmp=intuit_method(s,gv))) + if ((isIDFIRST_lazy_if(s,UTF) || *s == '$') && + (tmp = intuit_method(s, gv, cv))) return REPORT(tmp); /* If not a declared subroutine, it's an indirect object. */ @@ -4268,7 +4373,7 @@ Perl_yylex(pTHX) if ( ( !immediate_paren && (PL_last_lop_op == OP_SORT || - ((!gv || !GvCVu(gv)) && + ((!gv || !cv) && (PL_last_lop_op != OP_MAPSTART && PL_last_lop_op != OP_GREPSTART)))) || (PL_tokenbuf[0] == '_' && PL_tokenbuf[1] == '\0' @@ -4295,9 +4400,9 @@ Perl_yylex(pTHX) /* If followed by a paren, it's certainly a subroutine. */ if (*s == '(') { CLINE; - if (gv && GvCVu(gv)) { + if (cv) { for (d = s + 1; SPACE_OR_TAB(*d); d++) ; - if (*d == ')' && (sv = cv_const_sv(GvCV(gv)))) { + if (*d == ')' && (sv = gv_const_sv(gv))) { s = d + 1; goto its_constant; } @@ -4311,7 +4416,7 @@ Perl_yylex(pTHX) /* If followed by var or block, call it a method (unless sub) */ - if ((*s == '$' || *s == '{') && (!gv || !GvCVu(gv))) { + if ((*s == '$' || *s == '{') && (!gv || !cv)) { PL_last_lop = PL_oldbufptr; PL_last_lop_op = OP_METHOD; PREBLOCK(METHOD); @@ -4321,20 +4426,18 @@ Perl_yylex(pTHX) if (!orig_keyword && (isIDFIRST_lazy_if(s,UTF) || *s == '$') - && (tmp = intuit_method(s,gv))) + && (tmp = intuit_method(s, gv, cv))) return REPORT(tmp); /* Not a method, so call it a subroutine (if defined) */ - if (gv && GvCVu(gv)) { - CV* cv; + if (cv) { if (lastchar == '-' && ckWARN_d(WARN_AMBIGUOUS)) Perl_warner(aTHX_ packWARN(WARN_AMBIGUOUS), "Ambiguous use of -%s resolved as -&%s()", PL_tokenbuf, PL_tokenbuf); /* Check for a constant sub */ - cv = GvCV(gv); - if ((sv = cv_const_sv(cv))) { + if ((sv = gv_const_sv(gv))) { its_constant: SvREFCNT_dec(((SVOP*)yylval.opval)->op_sv); ((SVOP*)yylval.opval)->op_sv = SvREFCNT_inc(sv); @@ -4343,6 +4446,14 @@ Perl_yylex(pTHX) } /* Resolve to GV now. */ + if (SvTYPE(gv) != SVt_PVGV) { + gv = gv_fetchpvn_flags(PL_tokenbuf, len, 0, SVt_PVCV); + assert (SvTYPE(gv) == SVt_PVGV); + /* cv must have been some sort of placeholder, so + now needs replacing with a real code reference. */ + cv = GvCV(gv); + } + op_free(yylval.opval); yylval.opval = newCVREF(0, newGVOP(OP_GV, 0, gv)); yylval.opval->op_private |= OPpENTERSUB_NOPAREN; @@ -4423,7 +4534,8 @@ Perl_yylex(pTHX) const char *pname = "main"; if (PL_tokenbuf[2] == 'D') pname = HvNAME_get(PL_curstash ? PL_curstash : PL_defstash); - gv = gv_fetchpv(Perl_form(aTHX_ "%s::DATA", pname), TRUE, SVt_PVIO); + gv = gv_fetchpv(Perl_form(aTHX_ "%s::DATA", pname), GV_ADD, + SVt_PVIO); GvMULTI_on(gv); if (!GvIO(gv)) GvIOp(gv) = newIO(); @@ -4552,14 +4664,34 @@ Perl_yylex(pTHX) case KEY_bless: LOP(OP_BLESS,XTERM); + case KEY_break: + FUN0(OP_BREAK); + case KEY_chop: UNI(OP_CHOP); case KEY_continue: + /* When 'use switch' is in effect, continue has a dual + life as a control operator. */ + { + if (!FEATURE_IS_ENABLED("switch")) + PREBLOCK(CONTINUE); + else { + /* We have to disambiguate the two senses of + "continue". If the next token is a '{' then + treat it as the start of a continue block; + otherwise treat it as a control operator. + */ + s = skipspace(s); + if (*s == '{') PREBLOCK(CONTINUE); + else + FUN0(OP_CONTINUE); + } + } case KEY_chdir: - (void)gv_fetchpv("ENV",TRUE, SVt_PVHV); /* may use HOME */ + (void)gv_fetchpvs("ENV", GV_ADD, SVt_PVHV); /* may use HOME */ UNI(OP_CHDIR); case KEY_close: @@ -4601,6 +4733,9 @@ Perl_yylex(pTHX) case KEY_chroot: UNI(OP_CHROOT); + case KEY_default: + PREBLOCK(DEFAULT); + case KEY_do: s = skipspace(s); if (*s == '{') @@ -4626,7 +4761,7 @@ Perl_yylex(pTHX) UNI(OP_DELETE); case KEY_dbmopen: - gv_fetchpv("AnyDBM_File::ISA", GV_ADDMULTI, SVt_PVAV); + gv_fetchpvs("AnyDBM_File::ISA", GV_ADDMULTI, SVt_PVAV); LOP(OP_DBMOPEN,XTERM); case KEY_dbmclose: @@ -4823,6 +4958,10 @@ Perl_yylex(pTHX) case KEY_getlogin: FUN0(OP_GETLOGIN); + case KEY_given: + yylval.ival = CopLINE(PL_curcop); + OPERATOR(GIVEN); + case KEY_glob: set_csh(); LOP(OP_GLOB,XTERM); @@ -5180,6 +5319,10 @@ Perl_yylex(pTHX) else TOKEN(1); /* force error */ + case KEY_say: + checkcomma(s,PL_tokenbuf,"filehandle"); + LOP(OP_SAY,XREF); + case KEY_chomp: UNI(OP_CHOMP); @@ -5321,7 +5464,7 @@ Perl_yylex(pTHX) sv_setpv(PL_subname, tmpbuf); else { sv_setsv(PL_subname,PL_curstname); - sv_catpvn(PL_subname,"::",2); + sv_catpvs(PL_subname,"::"); sv_catpvn(PL_subname,tmpbuf,len); } s = skipspace(d); @@ -5495,6 +5638,10 @@ Perl_yylex(pTHX) case KEY_vec: LOP(OP_VEC,XTERM); + case KEY_when: + yylval.ival = CopLINE(PL_curcop); + OPERATOR(WHEN); + case KEY_while: yylval.ival = CopLINE(PL_curcop); OPERATOR(WHILE); @@ -5518,10 +5665,10 @@ Perl_yylex(pTHX) char ctl_l[2]; ctl_l[0] = toCTRL('L'); ctl_l[1] = '\0'; - gv_fetchpv(ctl_l,TRUE, SVt_PV); + gv_fetchpvn_flags(ctl_l, 1, GV_ADD, SVt_PV); } #else - gv_fetchpv("\f",TRUE, SVt_PV); /* Make sure $^L is defined */ + gv_fetchpvs("\f", GV_ADD, SVt_PV); /* Make sure $^L is defined */ #endif UNI(OP_ENTERWRITE); @@ -5548,6 +5695,7 @@ Perl_yylex(pTHX) static int S_pending_ident(pTHX) { + dVAR; register char *d; register I32 tmp = 0; /* pit holds the identifier we read and pending_ident is reset */ @@ -5603,7 +5751,7 @@ S_pending_ident(pTHX) HV * const stash = PAD_COMPNAME_OURSTASH(tmp); HEK * const stashname = HvNAME_HEK(stash); SV * const sym = newSVhek(stashname); - sv_catpvn(sym, "::", 2); + sv_catpvs(sym, "::"); sv_catpv(sym, PL_tokenbuf+1); yylval.opval = (OP*)newSVOP(OP_CONST, 0, sym); yylval.opval->op_private = OPpCONST_ENTERED; @@ -5647,7 +5795,7 @@ S_pending_ident(pTHX) table. */ if (pit == '@' && PL_lex_state != LEX_NORMAL && !PL_lex_brackets) { - GV *gv = gv_fetchpv(PL_tokenbuf+1, FALSE, SVt_PVAV); + GV *gv = gv_fetchpv(PL_tokenbuf+1, 0, SVt_PVAV); if ((!gv || ((PL_tokenbuf[0] == '@') ? !GvAV(gv) : !GvHV(gv))) && ckWARN(WARN_AMBIGUOUS)) { @@ -5661,10 +5809,26 @@ S_pending_ident(pTHX) /* build ops for a bareword */ yylval.opval = (OP*)newSVOP(OP_CONST, 0, newSVpv(PL_tokenbuf+1, 0)); yylval.opval->op_private = OPpCONST_ENTERED; - gv_fetchpv(PL_tokenbuf+1, PL_in_eval ? (GV_ADDMULTI | GV_ADDINEVAL) : TRUE, - ((PL_tokenbuf[0] == '$') ? SVt_PV - : (PL_tokenbuf[0] == '@') ? SVt_PVAV - : SVt_PVHV)); + gv_fetchpv( + PL_tokenbuf+1, + /* If the identifier refers to a stash, don't autovivify it. + * Change 24660 had the side effect of causing symbol table + * hashes to always be defined, even if they were freshly + * created and the only reference in the entire program was + * the single statement with the defined %foo::bar:: test. + * It appears that all code in the wild doing this actually + * wants to know whether sub-packages have been loaded, so + * by avoiding auto-vivifying symbol tables, we ensure that + * defined %foo::bar:: continues to be false, and the existing + * tests still give the expected answers, even though what + * they're actually testing has now changed subtly. + */ + (*PL_tokenbuf == '%' && *(d = PL_tokenbuf + strlen(PL_tokenbuf) - 1) == ':' && d[-1] == ':' + ? 0 + : PL_in_eval ? (GV_ADDMULTI | GV_ADDINEVAL) : GV_ADD), + ((PL_tokenbuf[0] == '$') ? SVt_PV + : (PL_tokenbuf[0] == '@') ? SVt_PVAV + : SVt_PVHV)); return WORD; } @@ -5675,6 +5839,7 @@ S_pending_ident(pTHX) I32 Perl_keyword (pTHX_ const char *name, I32 len) { + dVAR; switch (len) { case 1: /* 5 tokens of length 1 */ @@ -5855,7 +6020,7 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; } - case 3: /* 28 tokens of length 3 */ + case 3: /* 29 tokens of length 3 */ switch (name[0]) { case 'E': @@ -5944,7 +6109,7 @@ Perl_keyword (pTHX_ const char *name, I32 len) case 'r': if (name[2] == 'r') { /* err */ - return -KEY_err; + return (FEATURE_IS_ENABLED("err") ? -KEY_err : 0); } goto unknown; @@ -6080,6 +6245,14 @@ Perl_keyword (pTHX_ const char *name, I32 len) case 's': switch (name[1]) { + case 'a': + if (name[2] == 'y') + { /* say */ + return (FEATURE_IS_ENABLED("say") ? -KEY_say : 0); + } + + goto unknown; + case 'i': if (name[2] == 'n') { /* sin */ @@ -6140,7 +6313,7 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; } - case 4: /* 40 tokens of length 4 */ + case 4: /* 41 tokens of length 4 */ switch (name[0]) { case 'C': @@ -6570,8 +6743,9 @@ Perl_keyword (pTHX_ const char *name, I32 len) } case 'w': - if (name[1] == 'a') + switch (name[1]) { + case 'a': switch (name[2]) { case 'i': @@ -6593,6 +6767,12 @@ Perl_keyword (pTHX_ const char *name, I32 len) default: goto unknown; } + + case 'h': + if (name[2] == 'e' && + name[3] == 'n') + { /* when */ + return (FEATURE_IS_ENABLED("switch") ? KEY_when : 0); } goto unknown; @@ -6601,7 +6781,11 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; } - case 5: /* 36 tokens of length 5 */ + default: + goto unknown; + } + + case 5: /* 38 tokens of length 5 */ switch (name[0]) { case 'B': @@ -6654,8 +6838,10 @@ Perl_keyword (pTHX_ const char *name, I32 len) } case 'b': - if (name[1] == 'l' && - name[2] == 'e' && + switch (name[1]) + { + case 'l': + if (name[2] == 'e' && name[3] == 's' && name[4] == 's') { /* bless */ @@ -6664,6 +6850,20 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; + case 'r': + if (name[2] == 'e' && + name[3] == 'a' && + name[4] == 'k') + { /* break */ + return (FEATURE_IS_ENABLED("switch") ? -KEY_break : 0); + } + + goto unknown; + + default: + goto unknown; + } + case 'c': switch (name[1]) { @@ -6777,6 +6977,17 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; } + case 'g': + if (name[1] == 'i' && + name[2] == 'v' && + name[3] == 'e' && + name[4] == 'n') + { /* given */ + return (FEATURE_IS_ENABLED("switch") ? KEY_given : 0); + } + + goto unknown; + case 'i': switch (name[1]) { @@ -7513,7 +7724,7 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; } - case 7: /* 28 tokens of length 7 */ + case 7: /* 29 tokens of length 7 */ switch (name[0]) { case 'D': @@ -7584,9 +7795,22 @@ Perl_keyword (pTHX_ const char *name, I32 len) goto unknown; case 'e': - if (name[2] == 'f' && - name[3] == 'i' && - name[4] == 'n' && + if (name[2] == 'f') + { + switch (name[3]) + { + case 'a': + if (name[4] == 'u' && + name[5] == 'l' && + name[6] == 't') + { /* default */ + return (FEATURE_IS_ENABLED("switch") ? KEY_default : 0); + } + + goto unknown; + + case 'i': + if (name[4] == 'n' && name[5] == 'e' && name[6] == 'd') { /* defined */ @@ -7598,6 +7822,13 @@ Perl_keyword (pTHX_ const char *name, I32 len) default: goto unknown; } + } + + goto unknown; + + default: + goto unknown; + } case 'f': if (name[1] == 'o' && @@ -8973,6 +9204,7 @@ unknown: STATIC void S_checkcomma(pTHX_ register char *s, const char *name, const char *what) { + dVAR; const char *w; if (*s == ' ' && s[1] == '(') { /* XXX gotta be a better way */ @@ -9004,7 +9236,7 @@ S_checkcomma(pTHX_ register char *s, const char *name, const char *what) while (s < PL_bufend && isSPACE(*s)) s++; if (*s == ',') { - int kw; + I32 kw; *s = '\0'; /* XXX If we didn't do this, we could const a lot of toke.c */ kw = keyword(w, s - w) || get_cv(w, FALSE) != 0; *s = ','; @@ -9089,7 +9321,7 @@ S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, SV *sv, SV *pv, /* Check the eval first */ if (!PL_in_eval && SvTRUE(ERRSV)) { - sv_catpv(ERRSV, "Propagated"); + sv_catpvs(ERRSV, "Propagated"); yyerror(SvPV_nolen_const(ERRSV)); /* Duplicates the message inside eval */ (void)POPs; res = SvREFCNT_inc(sv); @@ -9121,6 +9353,7 @@ S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, SV *sv, SV *pv, STATIC char * S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) { + dVAR; register char *d = dest; register char * const e = d + destlen - 3; /* two-character token, ending NUL */ for (;;) { @@ -9158,15 +9391,14 @@ S_scan_word(pTHX_ register char *s, char *dest, STRLEN destlen, int allow_packag 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; + dVAR; + char *bracket = NULL; char funny = *s++; + register char *d = dest; + register char * const e = d + destlen + 3; /* two-character token, ending NUL */ 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) @@ -9241,15 +9473,15 @@ S_scan_ident(pTHX_ register char *s, register const char *send, char *dest, STRL 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); + char *end = s; + while ((end < send && isALNUM_lazy_if(end,UTF)) || *end == ':') { + end += UTF8SKIP(end); + while (end < send && UTF8_IS_CONTINUED(*end) && is_utf8_mark((U8*)end)) + end += UTF8SKIP(end); } - Copy(s, d, e - s, char); - d += e - s; - s = e; + Copy(s, d, end - s, char); + d += end - s; + s = end; } else { while ((isALNUM(*s) || *s == ':') && d < e) @@ -9334,11 +9566,13 @@ Perl_pmflag(pTHX_ U32* pmfl, int ch) STATIC char * S_scan_pat(pTHX_ char *start, I32 type) { + dVAR; PMOP *pm; char *s = scan_str(start,FALSE,FALSE); + const char * const valid_flags = (type == OP_QR) ? "iomsx" : "iogcmsx"; if (!s) { - char * const delimiter = skipspace(start); + const char * const delimiter = skipspace(start); Perl_croak(aTHX_ *delimiter == '?' ? "Search pattern not terminated or ternary operator parsed as search pattern" : "Search pattern not terminated" ); @@ -9347,14 +9581,8 @@ S_scan_pat(pTHX_ char *start, I32 type) pm = (PMOP*)newPMOP(type, 0); if (PL_multi_open == '?') pm->op_pmflags |= PMf_ONCE; - if(type == OP_QR) { - while (*s && strchr("iomsx", *s)) - pmflag(&pm->op_pmflags,*s++); - } - else { - while (*s && strchr("iogcmsx", *s)) - pmflag(&pm->op_pmflags,*s++); - } + while (*s && strchr(valid_flags, *s)) + pmflag(&pm->op_pmflags,*s++); /* issue a warning if /c is specified,but /g is not */ if ((pm->op_pmflags & PMf_CONTINUE) && !(pm->op_pmflags & PMf_GLOBAL) && ckWARN(WARN_REGEXP)) @@ -9416,17 +9644,17 @@ S_scan_subst(pTHX_ char *start) } if (es) { - SV *repl; + SV * const repl = newSVpvs(""); + PL_sublex_info.super_bufptr = s; PL_sublex_info.super_bufend = PL_bufend; PL_multi_end = 0; pm->op_pmflags |= PMf_EVAL; - repl = newSVpvn("",0); while (es-- > 0) sv_catpv(repl, es ? "eval " : "do "); - sv_catpvn(repl, "{ ", 2); + sv_catpvs(repl, "{ "); sv_catsv(repl, PL_lex_repl); - sv_catpvn(repl, " };", 2); + sv_catpvs(repl, " }"); SvEVALED_on(repl); SvREFCNT_dec(PL_lex_repl); PL_lex_repl = repl; @@ -9441,6 +9669,7 @@ S_scan_subst(pTHX_ char *start) STATIC char * S_scan_trans(pTHX_ char *start) { + dVAR; register char* s; OP *o; short *tbl; @@ -9499,12 +9728,12 @@ S_scan_trans(pTHX_ char *start) STATIC char * S_scan_heredoc(pTHX_ register char *s) { + dVAR; SV *herewas; I32 op_type = OP_SCALAR; I32 len; SV *tmpstr; char term; - const char newline[] = "\n"; const char *found_newline; register char *d; register char *e; @@ -9566,7 +9795,7 @@ S_scan_heredoc(pTHX_ register char *s) s = olds; } #endif - if ( outer || !(found_newline = ninstr(s,PL_bufend,newline,newline+1)) ) { + if ( outer || !(found_newline = memchr(s, '\n', PL_bufend - s)) ) { herewas = newSVpvn(s,PL_bufend-s); } else { @@ -9575,7 +9804,7 @@ S_scan_heredoc(pTHX_ register char *s) } s += SvCUR(herewas); - tmpstr = NEWSV(87,79); + tmpstr = newSV(79); sv_upgrade(tmpstr, SVt_PVIV); if (term == '\'') { op_type = OP_CONST; @@ -9591,8 +9820,8 @@ S_scan_heredoc(pTHX_ register char *s) PL_multi_open = PL_multi_close = '<'; term = *PL_tokenbuf; if (PL_lex_inwhat == OP_SUBST && PL_in_eval && !PL_rsfp) { - char *bufptr = PL_sublex_info.super_bufptr; - char *bufend = PL_sublex_info.super_bufend; + char * const bufptr = PL_sublex_info.super_bufptr; + char * const bufend = PL_sublex_info.super_bufend; char * const olds = s - SvCUR(herewas); s = strchr(bufptr, '\n'); if (!s) @@ -9664,13 +9893,13 @@ S_scan_heredoc(pTHX_ register char *s) PL_bufend[-1] = '\n'; #endif if (PERLDB_LINE && PL_curstash != PL_debstash) { - SV *sv = NEWSV(88,0); + SV * const sv = newSV(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_store(CopFILEAVx(PL_curcop), (I32)CopLINE(PL_curcop),sv); } if (*s == term && memEQ(s,PL_tokenbuf,len)) { STRLEN off = PL_bufend - 1 - SvPVX_const(PL_linestr); @@ -9721,14 +9950,14 @@ retval: STATIC char * S_scan_inputsymbol(pTHX_ char *start) { + dVAR; register char *s = start; /* current position in buffer */ - register char *d; - const char *e; char *end; I32 len; - d = PL_tokenbuf; /* start of temp holding space */ - e = PL_tokenbuf + sizeof PL_tokenbuf; /* end of temp holding space */ + char *d = PL_tokenbuf; /* start of temp holding space */ + const char * const e = PL_tokenbuf + sizeof PL_tokenbuf; /* end of temp holding space */ + end = strchr(s, '\n'); if (!end) end = PL_bufend; @@ -9774,7 +10003,7 @@ S_scan_inputsymbol(pTHX_ char *start) } else { bool readline_overriden = FALSE; - GV *gv_readline = Nullgv; + GV *gv_readline; GV **gvp; /* we're in a filehandle read situation */ d = PL_tokenbuf; @@ -9784,10 +10013,11 @@ S_scan_inputsymbol(pTHX_ char *start) Copy("ARGV",d,5,char); /* Check whether readline() is overriden */ - if (((gv_readline = gv_fetchpv("readline", FALSE, SVt_PVCV)) + gv_readline = gv_fetchpvs("readline", 0, SVt_PVCV); + if ((gv_readline && GvCVu(gv_readline) && GvIMPORTED_CV(gv_readline)) || - ((gvp = (GV**)hv_fetch(PL_globalstash, "readline", 8, FALSE)) + ((gvp = (GV**)hv_fetchs(PL_globalstash, "readline", FALSE)) && (gv_readline = *gvp) != (GV*)&PL_sv_undef && GvCVu(gv_readline) && GvIMPORTED_CV(gv_readline))) readline_overriden = TRUE; @@ -9803,16 +10033,16 @@ S_scan_inputsymbol(pTHX_ char *start) */ if ((tmp = pad_findmy(d)) != NOT_IN_PAD) { if (PAD_COMPNAME_FLAGS(tmp) & SVpad_OUR) { - HV *stash = PAD_COMPNAME_OURSTASH(tmp); - HEK *stashname = HvNAME_HEK(stash); - SV *sym = sv_2mortal(newSVhek(stashname)); - sv_catpvn(sym, "::", 2); + HV * const stash = PAD_COMPNAME_OURSTASH(tmp); + HEK * const stashname = HvNAME_HEK(stash); + SV * const sym = sv_2mortal(newSVhek(stashname)); + sv_catpvs(sym, "::"); sv_catpv(sym, d+1); d = SvPVX(sym); goto intro_sym; } else { - OP *o = newOP(OP_PADSV, 0); + OP * const o = newOP(OP_PADSV, 0); o->op_targ = tmp; PL_lex_op = readline_overriden ? (OP*)newUNOP(OP_ENTERSUB, OPf_STACKED, @@ -9848,7 +10078,7 @@ intro_sym: /* If it's none of the above, it must be a literal filehandle ( or ) so build a simple readline OP */ else { - GV *gv = gv_fetchpv(d,TRUE, SVt_PVIO); + GV * const gv = gv_fetchpv(d, GV_ADD, SVt_PVIO); PL_lex_op = readline_overriden ? (OP*)newUNOP(OP_ENTERSUB, OPf_STACKED, append_elem(OP_LIST, @@ -9909,6 +10139,7 @@ intro_sym: STATIC char * S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) { + dVAR; SV *sv; /* scalar value: string */ char *tmps; /* temp string, used for delimiter matching */ register char *s = start; /* current position in the buffer */ @@ -9951,9 +10182,9 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) PL_multi_close = term; - /* create a new SV to hold the contents. 87 is leak category, I'm - assuming. 79 is the SV's initial length. What a random number. */ - sv = NEWSV(87,79); + /* create a new SV to hold the contents. 79 is the SV's initial length. + What a random number. */ + sv = newSV(79); sv_upgrade(sv, SVt_PVIV); SvIV_set(sv, termcode); (void)SvPOK_only(sv); /* validate pointer */ @@ -9970,8 +10201,8 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) int offset = s - SvPVX_const(PL_linestr); const bool found = sv_cat_decode(sv, PL_encoding, PL_linestr, &offset, (char*)termstr, termlen); - const char *ns = SvPVX_const(PL_linestr) + offset; - char *svlast = SvEND(sv) - 1; + const char * const ns = SvPVX_const(PL_linestr) + offset; + char * const svlast = SvEND(sv) - 1; for (; s < ns; s++) { if (*s == '\n' && !PL_rsfp) @@ -10137,13 +10368,13 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) /* update debugger info */ if (PERLDB_LINE && PL_curstash != PL_debstash) { - SV *sv = NEWSV(88,0); + SV * const sv = newSV(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_store(CopFILEAVx(PL_curcop), (I32)CopLINE(PL_curcop), sv); } /* having changed the buffer, we must update PL_bufend */ @@ -10205,13 +10436,14 @@ S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) char * Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp) { + dVAR; register const char *s = start; /* current position in buffer */ register char *d; /* destination in temp buffer */ register char *e; /* end of temp buffer */ NV nv; /* number read, as a double */ SV *sv = Nullsv; /* place to put the converted number */ bool floatit; /* boolean: int or float? */ - const char *lastub = 0; /* position of last underbar */ + const char *lastub = NULL; /* position of last underbar */ static char const number_too_long[] = "Number too long"; /* We use the first character to decide what type of number this is */ @@ -10374,7 +10606,7 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp) Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Misplaced _ in number"); } - sv = NEWSV(92,0); + sv = newSV(0); if (overflowed) { if (n > 4294967295.0 && ckWARN(WARN_PORTABLE)) Perl_warner(aTHX_ packWARN(WARN_PORTABLE), @@ -10527,7 +10759,7 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp) /* make an sv from the string */ - sv = NEWSV(92,0); + sv = newSV(0); /* We try to do an integer conversion first if no characters @@ -10536,7 +10768,7 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp) if (!floatit) { UV uv; - int flags = grok_number (PL_tokenbuf, d - PL_tokenbuf, &uv); + const int flags = grok_number (PL_tokenbuf, d - PL_tokenbuf, &uv); if (flags == IS_NUMBER_IN_UV) { if (uv <= IV_MAX) @@ -10568,7 +10800,7 @@ Perl_scan_num(pTHX_ const char *start, YYSTYPE* lvalp) /* if it starts with a v, it could be a v-string */ case 'v': vstring: - sv = NEWSV(92,5); /* preallocate storage space */ + sv = newSV(5); /* preallocate storage space */ s = scan_vstring(s,sv); break; } @@ -10586,9 +10818,10 @@ vstring: STATIC char * S_scan_formline(pTHX_ register char *s) { + dVAR; register char *eol; register char *t; - SV *stuff = newSVpvn("",0); + SV * const stuff = newSVpvs(""); bool needargs = FALSE; bool eofmt = FALSE; @@ -10681,6 +10914,7 @@ STATIC void S_set_csh(pTHX) { #ifdef CSH + dVAR; if (!PL_cshlen) PL_cshlen = strlen(PL_cshname); #endif @@ -10689,8 +10923,9 @@ S_set_csh(pTHX) I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags) { + dVAR; const I32 oldsavestack_ix = PL_savestack_ix; - CV* outsidecv = PL_compcv; + CV* const outsidecv = PL_compcv; if (PL_compcv) { assert(SvTYPE(PL_compcv) == SVt_PVCV); @@ -10699,7 +10934,7 @@ Perl_start_subparse(pTHX_ I32 is_format, U32 flags) save_item(PL_subname); SAVESPTR(PL_compcv); - PL_compcv = (CV*)NEWSV(1104,0); + PL_compcv = (CV*)newSV(0); sv_upgrade((SV *)PL_compcv, is_format ? SVt_PVFM : SVt_PVCV); CvFLAGS(PL_compcv) |= flags; @@ -10717,6 +10952,7 @@ Perl_start_subparse(pTHX_ I32 is_format, U32 flags) int Perl_yywarn(pTHX_ const char *s) { + dVAR; PL_in_eval |= EVAL_WARNONLY; yyerror(s); PL_in_eval &= ~EVAL_WARNONLY; @@ -10726,6 +10962,7 @@ Perl_yywarn(pTHX_ const char *s) int Perl_yyerror(pTHX_ const char *s) { + dVAR; const char *where = NULL; const char *context = NULL; int contlen = -1; @@ -10778,7 +11015,7 @@ Perl_yyerror(pTHX_ const char *s) where = "within string"; } else { - SV *where_sv = sv_2mortal(newSVpvn("next char ", 10)); + SV * const where_sv = sv_2mortal(newSVpvs("next char ")); if (yychar < 32) Perl_sv_catpvf(aTHX_ where_sv, "^%c", toCTRL(yychar)); else if (isPRINT_LC(yychar)) @@ -10813,7 +11050,7 @@ Perl_yyerror(pTHX_ const char *s) OutCopFILE(PL_curcop)); } PL_in_my = 0; - PL_in_my_stash = Nullhv; + PL_in_my_stash = NULL; return 0; } #ifdef __SC__ @@ -10823,6 +11060,7 @@ Perl_yyerror(pTHX_ const char *s) STATIC char* S_swallow_bom(pTHX_ U8 *s) { + dVAR; const STRLEN slen = SvCUR(PL_linestr); switch (s[0]) { case 0xFF: @@ -10922,6 +11160,7 @@ S_swallow_bom(pTHX_ U8 *s) static void restore_rsfp(pTHX_ void *f) { + dVAR; PerlIO * const fp = (PerlIO*)f; if (PL_rsfp == PerlIO_stdin()) @@ -10935,6 +11174,7 @@ restore_rsfp(pTHX_ void *f) static I32 utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) { + dVAR; const STRLEN old = SvCUR(sv); const I32 count = FILTER_READ(idx+1, sv, maxlen); DEBUG_P(PerlIO_printf(Perl_debug_log, @@ -10956,6 +11196,7 @@ utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) static I32 utf16rev_textfilter(pTHX_ int idx, SV *sv, int maxlen) { + dVAR; const STRLEN old = SvCUR(sv); const I32 count = FILTER_READ(idx+1, sv, maxlen); DEBUG_P(PerlIO_printf(Perl_debug_log, @@ -10981,7 +11222,7 @@ vstring, as well as updating the passed in sv. Function must be called like - sv = NEWSV(92,5); + sv = newSV(5); s = scan_vstring(s,sv); The sv should already be large enough to store the vstring @@ -10992,6 +11233,7 @@ passed in, for performance reasons. char * Perl_scan_vstring(pTHX_ const char *s, SV *sv) { + dVAR; const char *pos = s; const char *start = s; if (*pos == 'v') pos++; /* get past 'v' */