X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=op.c;h=88cc607dafdb42f6d6add2dba26250f03c18c5f2;hb=ba106d47906768b6e657462b9a484fe0c3a0f0d5;hp=a123b58e78ce1cf13757dfe83f6c53ef60b8ffd7;hpb=f6aaf50100351be0339a4acf484db91a3c02a9ca;p=p5sagit%2Fp5-mst-13.2.git diff --git a/op.c b/op.c index a123b58..88cc607 100644 --- a/op.c +++ b/op.c @@ -1,6 +1,6 @@ /* op.c * - * Copyright (c) 1991-1997, Larry Wall + * Copyright (c) 1991-1999, Larry Wall * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -19,51 +19,80 @@ #include "perl.h" #ifdef PERL_OBJECT -#define CHECKCALL this->*check +#define CHECKCALL this->*PL_check #else -#define CHECKCALL *check +#define CHECKCALL *PL_check +#endif + +/* #define PL_OP_SLAB_ALLOC */ + +#ifdef PL_OP_SLAB_ALLOC +#define SLAB_SIZE 8192 +static char *PL_OpPtr = NULL; +static int PL_OpSpace = 0; +#define NewOp(m,var,c,type) do { if ((PL_OpSpace -= c*sizeof(type)) >= 0) \ + var = (type *)(PL_OpPtr -= c*sizeof(type)); \ + else \ + var = (type *) Slab_Alloc(m,c*sizeof(type)); \ + } while (0) + +static void * +Slab_Alloc(int m, size_t sz) +{ + Newz(m,PL_OpPtr,SLAB_SIZE,char); + PL_OpSpace = SLAB_SIZE - sz; + return PL_OpPtr += PL_OpSpace; +} + +#else +#define NewOp(m, var, c, type) Newz(m, var, c, type) #endif - /* * In the following definition, the ", Nullop" is just to make the compiler * think the expression is of the right type: croak actually does a Siglongjmp. */ #define CHECKOP(type,o) \ - ((op_mask && op_mask[type]) \ + ((PL_op_mask && PL_op_mask[type]) \ ? ( op_free((OP*)o), \ - croak("%s trapped by operation mask", op_desc[type]), \ + croak("%s trapped by operation mask", PL_op_desc[type]), \ Nullop ) \ : (CHECKCALL[type])((OP*)o)) +#define PAD_MAX 999999999 + static bool scalar_mod_type _((OP *o, I32 type)); #ifndef PERL_OBJECT static I32 list_assignment _((OP *o)); static void bad_type _((I32 n, char *t, char *name, OP *kid)); static OP *modkids _((OP *o, I32 type)); static OP *no_fh_allowed _((OP *o)); +static void no_bareword_allowed _((OP *o)); static OP *scalarboolean _((OP *o)); static OP *too_few_arguments _((OP *o, char* name)); static OP *too_many_arguments _((OP *o, char* name)); static void null _((OP* o)); static PADOFFSET pad_findlex _((char* name, PADOFFSET newoff, U32 seq, - CV* startcv, I32 cx_ix)); + CV* startcv, I32 cx_ix, I32 saweval, U32 flags)); static OP *newDEFSVOP _((void)); static OP *new_logop _((I32 type, I32 flags, OP **firstp, OP **otherp)); +static void simplify_sort _((OP *o)); +static bool is_handle_constructor _((OP *o, I32 argnum)); #endif STATIC char* gv_ename(GV *gv) { + STRLEN n_a; SV* tmpsv = sv_newmortal(); gv_efullname3(tmpsv, gv, Nullch); - return SvPV(tmpsv,na); + return SvPV(tmpsv,n_a); } STATIC OP * no_fh_allowed(OP *o) { yyerror(form("Missing comma after first argument to %s function", - op_desc[o->op_type])); + PL_op_desc[o->op_type])); return o; } @@ -85,24 +114,32 @@ STATIC void bad_type(I32 n, char *t, char *name, OP *kid) { yyerror(form("Type of arg %d to %s must be %s (not %s)", - (int)n, name, t, op_desc[kid->op_type])); + (int)n, name, t, PL_op_desc[kid->op_type])); +} + +STATIC void +no_bareword_allowed(OP *o) +{ + warn("Bareword \"%s\" not allowed while \"strict subs\" in use", + SvPV_nolen(cSVOPo->op_sv)); + ++PL_error_count; } void assertref(OP *o) { int type = o->op_type; - if (type != OP_AELEM && type != OP_HELEM) { - yyerror(form("Can't use subscript on %s", op_desc[type])); + if (type != OP_AELEM && type != OP_HELEM && type != OP_GELEM) { + yyerror(form("Can't use subscript on %s", PL_op_desc[type])); if (type == OP_ENTERSUB || type == OP_RV2HV || type == OP_PADHV) { dTHR; SV *msg = sv_2mortal( newSVpvf("(Did you mean $ or @ instead of %c?)\n", type == OP_ENTERSUB ? '&' : '%')); - if (in_eval & 2) + if (PL_in_eval & EVAL_WARNONLY) warn("%_", msg); - else if (in_eval) - sv_catsv(GvSV(errgv), msg); + else if (PL_in_eval) + sv_catsv(GvSV(PL_errgv), msg); else PerlIO_write(PerlIO_stderr(), SvPVX(msg), SvCUR(msg)); } @@ -118,23 +155,43 @@ pad_allocmy(char *name) PADOFFSET off; SV *sv; - if (!(isALPHA(name[1]) || name[1] == '_' && (int)strlen(name) > 2)) { + if (!( + isALPHA(name[1]) || + (PL_hints & HINT_UTF8 && (name[1] & 0xc0) == 0xc0) || + name[1] == '_' && (int)strlen(name) > 2)) + { if (!isPRINT(name[1])) { - name[3] = '\0'; + /* 1999-02-27 mjd@plover.com */ + char *p; + p = strchr(name, '\0'); + /* The next block assumes the buffer is at least 205 chars + long. At present, it's always at least 256 chars. */ + if (p-name > 200) { + strcpy(name+200, "..."); + p = name+199; + } + else { + p[1] = '\0'; + } + /* Move everything else down one character */ + for (; p-name > 2; p--) + *p = *(p-1); name[2] = toCTRL(name[1]); name[1] = '^'; } - croak("Can't use global %s in \"my\"",name); + yyerror(form("Can't use global %s in \"my\"",name)); } - if (dowarn && AvFILLp(comppad_name) >= 0) { - SV **svp = AvARRAY(comppad_name); - for (off = AvFILLp(comppad_name); off > comppad_name_floor; off--) { + if (ckWARN(WARN_UNSAFE) && AvFILLp(PL_comppad_name) >= 0) { + SV **svp = AvARRAY(PL_comppad_name); + for (off = AvFILLp(PL_comppad_name); off > PL_comppad_name_floor; off--) { if ((sv = svp[off]) - && sv != &sv_undef - && SvIVX(sv) == 999999999 /* var is in open scope */ + && sv != &PL_sv_undef + && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0) && strEQ(name, SvPVX(sv))) { - warn("\"my\" variable %s masks earlier declaration in same scope", name); + warner(WARN_UNSAFE, + "\"my\" variable %s masks earlier declaration in same %s", + name, (SvIVX(sv) == PAD_MAX ? "scope" : "statement")); break; } } @@ -143,30 +200,34 @@ pad_allocmy(char *name) sv = NEWSV(1102,0); sv_upgrade(sv, SVt_PVNV); sv_setpv(sv, name); - if (in_my_stash) { + if (PL_in_my_stash) { if (*name != '$') - croak("Can't declare class for non-scalar %s in \"my\"",name); + yyerror(form("Can't declare class for non-scalar %s in \"my\"", + name)); SvOBJECT_on(sv); (void)SvUPGRADE(sv, SVt_PVMG); - SvSTASH(sv) = (HV*)SvREFCNT_inc(in_my_stash); - sv_objcount++; + SvSTASH(sv) = (HV*)SvREFCNT_inc(PL_in_my_stash); + PL_sv_objcount++; } - av_store(comppad_name, off, sv); - SvNVX(sv) = (double)999999999; + av_store(PL_comppad_name, off, sv); + SvNVX(sv) = (double)PAD_MAX; SvIVX(sv) = 0; /* Not yet introduced--see newSTATEOP */ - if (!min_intro_pending) - min_intro_pending = off; - max_intro_pending = off; + if (!PL_min_intro_pending) + PL_min_intro_pending = off; + PL_max_intro_pending = off; if (*name == '@') - av_store(comppad, off, (SV*)newAV()); + av_store(PL_comppad, off, (SV*)newAV()); else if (*name == '%') - av_store(comppad, off, (SV*)newHV()); - SvPADMY_on(curpad[off]); + av_store(PL_comppad, off, (SV*)newHV()); + SvPADMY_on(PL_curpad[off]); return off; } +#define FINDLEX_NOSEARCH 1 /* don't search outer contexts */ + STATIC PADOFFSET -pad_findlex(char *name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix) +pad_findlex(char *name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix, I32 saweval, + U32 flags) { dTHR; CV *cv; @@ -174,20 +235,19 @@ pad_findlex(char *name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix) SV *sv; register I32 i; register PERL_CONTEXT *cx; - int saweval; for (cv = startcv; cv; cv = CvOUTSIDE(cv)) { AV *curlist = CvPADLIST(cv); SV **svp = av_fetch(curlist, 0, FALSE); AV *curname; - if (!svp || *svp == &sv_undef) + if (!svp || *svp == &PL_sv_undef) continue; curname = (AV*)*svp; svp = AvARRAY(curname); for (off = AvFILLp(curname); off > 0; off--) { if ((sv = svp[off]) && - sv != &sv_undef && + sv != &PL_sv_undef && seq <= SvIVX(sv) && seq > I_32(SvNVX(sv)) && strEQ(SvPVX(sv), name)) @@ -212,64 +272,78 @@ pad_findlex(char *name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix) newoff = pad_alloc(OP_PADSV, SVs_PADMY); sv_upgrade(namesv, SVt_PVNV); sv_setpv(namesv, name); - av_store(comppad_name, newoff, namesv); - SvNVX(namesv) = (double)curcop->cop_seq; - SvIVX(namesv) = 999999999; /* A ref, intro immediately */ + av_store(PL_comppad_name, newoff, namesv); + SvNVX(namesv) = (double)PL_curcop->cop_seq; + SvIVX(namesv) = PAD_MAX; /* A ref, intro immediately */ SvFAKE_on(namesv); /* A ref, not a real var */ - if (CvANON(compcv) || SvTYPE(compcv) == SVt_PVFM) { + if (SvOBJECT(sv)) { /* A typed var */ + SvOBJECT_on(namesv); + (void)SvUPGRADE(namesv, SVt_PVMG); + SvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*)SvSTASH(sv)); + PL_sv_objcount++; + } + if (CvANON(PL_compcv) || SvTYPE(PL_compcv) == SVt_PVFM) { /* "It's closures all the way down." */ - CvCLONE_on(compcv); + CvCLONE_on(PL_compcv); if (cv == startcv) { - if (CvANON(compcv)) + if (CvANON(PL_compcv)) oldsv = Nullsv; /* no need to keep ref */ } else { CV *bcv; for (bcv = startcv; bcv && bcv != cv && !CvCLONE(bcv); - bcv = CvOUTSIDE(bcv)) { + bcv = CvOUTSIDE(bcv)) + { if (CvANON(bcv)) CvCLONE_on(bcv); else { - if (dowarn && !CvUNIQUE(cv)) - warn( + if (ckWARN(WARN_CLOSURE) + && !CvUNIQUE(bcv) && !CvUNIQUE(cv)) + { + warner(WARN_CLOSURE, "Variable \"%s\" may be unavailable", name); + } break; } } } } - else if (!CvUNIQUE(compcv)) { - if (dowarn && !SvFAKE(sv) && !CvUNIQUE(cv)) - warn("Variable \"%s\" will not stay shared", name); + else if (!CvUNIQUE(PL_compcv)) { + if (ckWARN(WARN_CLOSURE) && !SvFAKE(sv) && !CvUNIQUE(cv)) + warner(WARN_CLOSURE, + "Variable \"%s\" will not stay shared", name); } } - av_store(comppad, newoff, SvREFCNT_inc(oldsv)); + av_store(PL_comppad, newoff, SvREFCNT_inc(oldsv)); return newoff; } } } + if (flags & FINDLEX_NOSEARCH) + return 0; + /* Nothing in current lexical context--try eval's context, if any. * This is necessary to let the perldb get at lexically scoped variables. * XXX This will also probably interact badly with eval tree caching. */ - saweval = 0; for (i = cx_ix; i >= 0; i--) { cx = &cxstack[i]; - switch (cx->cx_type) { + switch (CxTYPE(cx)) { default: if (i == 0 && saweval) { seq = cxstack[saweval].blk_oldcop->cop_seq; - return pad_findlex(name, newoff, seq, main_cv, 0); + return pad_findlex(name, newoff, seq, PL_main_cv, -1, saweval, 0); } break; case CXt_EVAL: switch (cx->blk_eval.old_op_type) { case OP_ENTEREVAL: - saweval = i; + if (CxREALEVAL(cx)) + saweval = i; break; case OP_REQUIRE: /* require must have its own scope */ @@ -280,12 +354,12 @@ pad_findlex(char *name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix) if (!saweval) return 0; cv = cx->blk_sub.cv; - if (debstash && CvSTASH(cv) == debstash) { /* ignore DB'* scope */ + if (PL_debstash && CvSTASH(cv) == PL_debstash) { /* ignore DB'* scope */ saweval = i; /* so we know where we were called from */ continue; } seq = cxstack[saweval].blk_oldcop->cop_seq; - return pad_findlex(name, newoff, seq, cv, i-1); + return pad_findlex(name, newoff, seq, cv, i-1, saweval,FINDLEX_NOSEARCH); } } @@ -299,8 +373,10 @@ pad_findmy(char *name) I32 off; I32 pendoff = 0; SV *sv; - SV **svp = AvARRAY(comppad_name); - U32 seq = cop_seqmax; + SV **svp = AvARRAY(PL_comppad_name); + U32 seq = PL_cop_seqmax; + PERL_CONTEXT *cx; + CV *outside; #ifdef USE_THREADS /* @@ -316,9 +392,9 @@ pad_findmy(char *name) #endif /* USE_THREADS */ /* The one we're looking for is probably just before comppad_name_fill. */ - for (off = AvFILLp(comppad_name); off > 0; off--) { + for (off = AvFILLp(PL_comppad_name); off > 0; off--) { if ((sv = svp[off]) && - sv != &sv_undef && + sv != &PL_sv_undef && (!SvIVX(sv) || (seq <= SvIVX(sv) && seq > I_32(SvNVX(sv)))) && @@ -330,12 +406,24 @@ pad_findmy(char *name) } } + outside = CvOUTSIDE(PL_compcv); + + /* Check if if we're compiling an eval'', and adjust seq to be the + * eval's seq number. This depends on eval'' having a non-null + * CvOUTSIDE() while it is being compiled. The eval'' itself is + * identified by CvEVAL being true and CvGV being null. */ + if (outside && CvEVAL(PL_compcv) && !CvGV(PL_compcv) && cxstack_ix >= 0) { + cx = &cxstack[cxstack_ix]; + if (CxREALEVAL(cx)) + seq = cx->blk_oldcop->cop_seq; + } + /* See if it's in a nested scope */ - off = pad_findlex(name, 0, seq, CvOUTSIDE(compcv), cxstack_ix); + off = pad_findlex(name, 0, seq, outside, cxstack_ix, 0, 0); if (off) { /* If there is a pending local definition, this new alias must die */ if (pendoff) - SvIVX(AvARRAY(comppad_name)[off]) = seq; + SvIVX(AvARRAY(PL_comppad_name)[off]) = seq; return off; /* pad_findlex returns 0 for failure...*/ } return NOT_IN_PAD; /* ...but we return NOT_IN_PAD for failure */ @@ -345,18 +433,18 @@ void pad_leavemy(I32 fill) { I32 off; - SV **svp = AvARRAY(comppad_name); + SV **svp = AvARRAY(PL_comppad_name); SV *sv; - if (min_intro_pending && fill < min_intro_pending) { - for (off = max_intro_pending; off >= min_intro_pending; off--) { - if ((sv = svp[off]) && sv != &sv_undef) + if (PL_min_intro_pending && fill < PL_min_intro_pending) { + for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) { + if ((sv = svp[off]) && sv != &PL_sv_undef) warn("%s never introduced", SvPVX(sv)); } } /* "Deintroduce" my variables that are leaving with this scope. */ - for (off = AvFILLp(comppad_name); off > fill; off--) { - if ((sv = svp[off]) && sv != &sv_undef && SvIVX(sv) == 999999999) - SvIVX(sv) = cop_seqmax; + for (off = AvFILLp(PL_comppad_name); off > fill; off--) { + if ((sv = svp[off]) && sv != &PL_sv_undef && SvIVX(sv) == PAD_MAX) + SvIVX(sv) = PL_cop_seqmax; } } @@ -367,44 +455,44 @@ pad_alloc(I32 optype, U32 tmptype) SV *sv; I32 retval; - if (AvARRAY(comppad) != curpad) + if (AvARRAY(PL_comppad) != PL_curpad) croak("panic: pad_alloc"); - if (pad_reset_pending) + if (PL_pad_reset_pending) pad_reset(); if (tmptype & SVs_PADMY) { do { - sv = *av_fetch(comppad, AvFILLp(comppad) + 1, TRUE); + sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE); } while (SvPADBUSY(sv)); /* need a fresh one */ - retval = AvFILLp(comppad); + retval = AvFILLp(PL_comppad); } else { - SV **names = AvARRAY(comppad_name); - SSize_t names_fill = AvFILLp(comppad_name); + SV **names = AvARRAY(PL_comppad_name); + SSize_t names_fill = AvFILLp(PL_comppad_name); for (;;) { /* * "foreach" index vars temporarily become aliases to non-"my" * values. Thus we must skip, not just pad values that are * marked as current pad values, but also those with names. */ - if (++padix <= names_fill && - (sv = names[padix]) && sv != &sv_undef) + if (++PL_padix <= names_fill && + (sv = names[PL_padix]) && sv != &PL_sv_undef) continue; - sv = *av_fetch(comppad, padix, TRUE); + sv = *av_fetch(PL_comppad, PL_padix, TRUE); if (!(SvFLAGS(sv) & (SVs_PADTMP|SVs_PADMY))) break; } - retval = padix; + retval = PL_padix; } SvFLAGS(sv) |= tmptype; - curpad = AvARRAY(comppad); + PL_curpad = AvARRAY(PL_comppad); #ifdef USE_THREADS DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx alloc %ld for %s\n", - (unsigned long) thr, (unsigned long) curpad, - (long) retval, op_name[optype])); + (unsigned long) thr, (unsigned long) PL_curpad, + (long) retval, PL_op_name[optype])); #else DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx alloc %ld for %s\n", - (unsigned long) curpad, - (long) retval, op_name[optype])); + (unsigned long) PL_curpad, + (long) retval, PL_op_name[optype])); #endif /* USE_THREADS */ return (PADOFFSET)retval; } @@ -415,59 +503,59 @@ pad_sv(PADOFFSET po) dTHR; #ifdef USE_THREADS DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx sv %d\n", - (unsigned long) thr, (unsigned long) curpad, po)); + (unsigned long) thr, (unsigned long) PL_curpad, po)); #else if (!po) croak("panic: pad_sv po"); DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx sv %d\n", - (unsigned long) curpad, po)); + (unsigned long) PL_curpad, po)); #endif /* USE_THREADS */ - return curpad[po]; /* eventually we'll turn this into a macro */ + return PL_curpad[po]; /* eventually we'll turn this into a macro */ } void pad_free(PADOFFSET po) { dTHR; - if (!curpad) + if (!PL_curpad) return; - if (AvARRAY(comppad) != curpad) + if (AvARRAY(PL_comppad) != PL_curpad) croak("panic: pad_free curpad"); if (!po) croak("panic: pad_free po"); #ifdef USE_THREADS DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx free %d\n", - (unsigned long) thr, (unsigned long) curpad, po)); + (unsigned long) thr, (unsigned long) PL_curpad, po)); #else DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx free %d\n", - (unsigned long) curpad, po)); + (unsigned long) PL_curpad, po)); #endif /* USE_THREADS */ - if (curpad[po] && curpad[po] != &sv_undef) - SvPADTMP_off(curpad[po]); - if ((I32)po < padix) - padix = po - 1; + if (PL_curpad[po] && PL_curpad[po] != &PL_sv_undef) + SvPADTMP_off(PL_curpad[po]); + if ((I32)po < PL_padix) + PL_padix = po - 1; } void pad_swipe(PADOFFSET po) { dTHR; - if (AvARRAY(comppad) != curpad) + if (AvARRAY(PL_comppad) != PL_curpad) croak("panic: pad_swipe curpad"); if (!po) croak("panic: pad_swipe po"); #ifdef USE_THREADS DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx swipe %d\n", - (unsigned long) thr, (unsigned long) curpad, po)); + (unsigned long) thr, (unsigned long) PL_curpad, po)); #else DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx swipe %d\n", - (unsigned long) curpad, po)); + (unsigned long) PL_curpad, po)); #endif /* USE_THREADS */ - SvPADTMP_off(curpad[po]); - curpad[po] = NEWSV(1107,0); - SvPADTMP_on(curpad[po]); - if ((I32)po < padix) - padix = po - 1; + SvPADTMP_off(PL_curpad[po]); + PL_curpad[po] = NEWSV(1107,0); + SvPADTMP_on(PL_curpad[po]); + if ((I32)po < PL_padix) + PL_padix = po - 1; } /* XXX pad_reset() is currently disabled because it results in serious bugs. @@ -483,45 +571,49 @@ pad_reset(void) dTHR; register I32 po; - if (AvARRAY(comppad) != curpad) + if (AvARRAY(PL_comppad) != PL_curpad) croak("panic: pad_reset curpad"); #ifdef USE_THREADS DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx reset\n", - (unsigned long) thr, (unsigned long) curpad)); + (unsigned long) thr, (unsigned long) PL_curpad)); #else DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx reset\n", - (unsigned long) curpad)); + (unsigned long) PL_curpad)); #endif /* USE_THREADS */ - if (!tainting) { /* Can't mix tainted and non-tainted temporaries. */ - for (po = AvMAX(comppad); po > padix_floor; po--) { - if (curpad[po] && !SvIMMORTAL(curpad[po])) - SvPADTMP_off(curpad[po]); + if (!PL_tainting) { /* Can't mix tainted and non-tainted temporaries. */ + for (po = AvMAX(PL_comppad); po > PL_padix_floor; po--) { + if (PL_curpad[po] && !SvIMMORTAL(PL_curpad[po])) + SvPADTMP_off(PL_curpad[po]); } - padix = padix_floor; + PL_padix = PL_padix_floor; } #endif - pad_reset_pending = FALSE; + PL_pad_reset_pending = FALSE; } #ifdef USE_THREADS /* find_threadsv is not reentrant */ PADOFFSET -find_threadsv(char *name) +find_threadsv(const char *name) { dTHR; char *p; PADOFFSET key; SV **svp; /* We currently only handle names of a single character */ - p = strchr(threadsv_names, *name); + p = strchr(PL_threadsv_names, *name); if (!p) return NOT_IN_PAD; - key = p - threadsv_names; + key = p - PL_threadsv_names; + MUTEX_LOCK(&thr->mutex); svp = av_fetch(thr->threadsv, key, FALSE); - if (!svp) { + if (svp) + MUTEX_UNLOCK(&thr->mutex); + else { SV *sv = NEWSV(0, 0); av_store(thr->threadsv, key, sv); thr->threadsvp = AvARRAY(thr->threadsv); + MUTEX_UNLOCK(&thr->mutex); /* * Some magic variables used to be automagically initialised * in gv_fetchpv. Those which are now per-thread magicals get @@ -537,7 +629,17 @@ find_threadsv(char *name) case '&': case '`': case '\'': - sawampersand = TRUE; + PL_sawampersand = TRUE; + /* FALL THROUGH */ + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': SvREADONLY_on(sv); /* FALL THROUGH */ @@ -548,7 +650,7 @@ find_threadsv(char *name) default: sv_magic(sv, 0, 0, name, 1); } - DEBUG_L(PerlIO_printf(PerlIO_stderr(), + DEBUG_S(PerlIO_printf(PerlIO_stderr(), "find_threadsv: new SV %p for $%s%c\n", sv, (*name < 32) ? "^" : "", (*name < 32) ? toCTRL(*name) : *name)); @@ -582,13 +684,17 @@ op_free(OP *o) o->op_targ = 0; /* Was holding hints. */ break; #ifdef USE_THREADS + case OP_ENTERITER: + if (!(o->op_flags & OPf_SPECIAL)) + break; + /* FALL THROUGH */ case OP_THREADSV: o->op_targ = 0; /* Was holding index into thr->threadsv AV. */ break; #endif /* USE_THREADS */ default: if (!(o->op_flags & OPf_REF) - || (check[o->op_type] != FUNC_NAME_TO_PTR(ck_ftst))) + || (PL_check[o->op_type] != FUNC_NAME_TO_PTR(ck_ftst))) break; /* FALL THROUGH */ case OP_GVSV: @@ -600,6 +706,8 @@ op_free(OP *o) case OP_DBSTATE: Safefree(cCOPo->cop_label); SvREFCNT_dec(cCOPo->cop_filegv); + if (cCOPo->cop_warnings != WARN_NONE && cCOPo->cop_warnings != WARN_ALL) + SvREFCNT_dec(cCOPo->cop_warnings); break; case OP_CONST: SvREFCNT_dec(cSVOPo->op_sv); @@ -612,7 +720,10 @@ op_free(OP *o) break; /* FALL THROUGH */ case OP_TRANS: - Safefree(cPVOPo->op_pv); + if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) + SvREFCNT_dec(cSVOPo->op_sv); + else + Safefree(cPVOPo->op_pv); break; case OP_SUBST: op_free(cPMOPo->op_pmreplroot); @@ -627,7 +738,13 @@ op_free(OP *o) if (o->op_targ > 0) pad_free(o->op_targ); +#ifdef PL_OP_SLAB_ALLOC + if ((char *) o == PL_OpPtr) + { + } +#else Safefree(o); +#endif } STATIC void @@ -637,7 +754,7 @@ null(OP *o) pad_free(o->op_targ); o->op_targ = o->op_type; o->op_type = OP_NULL; - o->op_ppaddr = ppaddr[OP_NULL]; + o->op_ppaddr = PL_ppaddr[OP_NULL]; } /* Contextualizers */ @@ -682,15 +799,16 @@ scalarkids(OP *o) STATIC OP * scalarboolean(OP *o) { - if (dowarn && - o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) { + if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) { dTHR; - line_t oldline = curcop->cop_line; + if (ckWARN(WARN_SYNTAX)) { + line_t oldline = PL_curcop->cop_line; - if (copline != NOLINE) - curcop->cop_line = copline; - warn("Found = in conditional, should be =="); - curcop->cop_line = oldline; + if (PL_copline != NOLINE) + PL_curcop->cop_line = PL_copline; + warner(WARN_SYNTAX, "Found = in conditional, should be =="); + PL_curcop->cop_line = oldline; + } } return scalar(o); } @@ -701,7 +819,7 @@ scalar(OP *o) OP *kid; /* assumes no premature commitment */ - if (!o || (o->op_flags & OPf_WANT) || error_count + if (!o || (o->op_flags & OPf_WANT) || PL_error_count || o->op_type == OP_RETURN) return o; @@ -745,7 +863,7 @@ scalar(OP *o) else scalar(kid); } - WITH_THR(curcop = &compiling); + WITH_THR(PL_curcop = &PL_compiling); break; case OP_SCOPE: case OP_LINESEQ: @@ -756,7 +874,7 @@ scalar(OP *o) else scalar(kid); } - WITH_THR(curcop = &compiling); + WITH_THR(PL_curcop = &PL_compiling); break; } return o; @@ -768,9 +886,19 @@ scalarvoid(OP *o) OP *kid; char* useless = 0; SV* sv; + U8 want; + + if (o->op_type == OP_NEXTSTATE || o->op_type == OP_DBSTATE || + (o->op_type == OP_NULL && + (o->op_targ == OP_NEXTSTATE || o->op_targ == OP_DBSTATE))) + { + dTHR; + PL_curcop = (COP*)o; /* for warning below */ + } /* assumes no premature commitment */ - if (!o || (o->op_flags & OPf_WANT) == OPf_WANT_LIST || error_count + want = o->op_flags & OPf_WANT; + if ((want && want != OPf_WANT_SCALAR) || PL_error_count || o->op_type == OP_RETURN) return o; @@ -778,7 +906,7 @@ scalarvoid(OP *o) switch (o->op_type) { default: - if (!(opargs[o->op_type] & OA_FOLDCONST)) + if (!(PL_opargs[o->op_type] & OA_FOLDCONST)) break; /* FALL THROUGH */ case OP_REPEAT: @@ -858,7 +986,7 @@ scalarvoid(OP *o) case OP_GETLOGIN: func_ops: if (!(o->op_private & OPpLVAL_INTRO)) - useless = op_desc[o->op_type]; + useless = PL_op_desc[o->op_type]; break; case OP_RV2GV: @@ -870,22 +998,22 @@ scalarvoid(OP *o) useless = "a variable"; break; - case OP_NEXTSTATE: - case OP_DBSTATE: - WITH_THR(curcop = ((COP*)o)); /* for warning below */ - break; - case OP_CONST: sv = cSVOPo->op_sv; - if (dowarn) { - useless = "a constant"; - if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0)) - useless = 0; - else if (SvPOK(sv)) { - if (strnEQ(SvPVX(sv), "di", 2) || - strnEQ(SvPVX(sv), "ds", 2) || - strnEQ(SvPVX(sv), "ig", 2)) - useless = 0; + if (cSVOPo->op_private & OPpCONST_STRICT) + no_bareword_allowed(o); + else { + dTHR; + if (ckWARN(WARN_VOID)) { + useless = "a constant"; + if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0)) + useless = 0; + else if (SvPOK(sv)) { + if (strnEQ(SvPVX(sv), "di", 2) || + strnEQ(SvPVX(sv), "ds", 2) || + strnEQ(SvPVX(sv), "ig", 2)) + useless = 0; + } } } null(o); /* don't execute a constant */ @@ -894,12 +1022,12 @@ scalarvoid(OP *o) case OP_POSTINC: o->op_type = OP_PREINC; /* pre-increment is faster */ - o->op_ppaddr = ppaddr[OP_PREINC]; + o->op_ppaddr = PL_ppaddr[OP_PREINC]; break; case OP_POSTDEC: o->op_type = OP_PREDEC; /* pre-decrement is faster */ - o->op_ppaddr = ppaddr[OP_PREDEC]; + o->op_ppaddr = PL_ppaddr[OP_PREDEC]; break; case OP_OR: @@ -910,11 +1038,11 @@ scalarvoid(OP *o) break; case OP_NULL: - if (o->op_targ == OP_NEXTSTATE || o->op_targ == OP_DBSTATE) - WITH_THR(curcop = ((COP*)o)); /* for warning below */ if (o->op_flags & OPf_STACKED) break; /* FALL THROUGH */ + case OP_NEXTSTATE: + case OP_DBSTATE: case OP_ENTERTRY: case OP_ENTER: case OP_SCALAR: @@ -944,8 +1072,11 @@ scalarvoid(OP *o) } break; } - if (useless && dowarn) - warn("Useless use of %s in void context", useless); + if (useless) { + dTHR; + if (ckWARN(WARN_VOID)) + warner(WARN_VOID, "Useless use of %s in void context", useless); + } return o; } @@ -966,7 +1097,7 @@ list(OP *o) OP *kid; /* assumes no premature commitment */ - if (!o || (o->op_flags & OPf_WANT) || error_count + if (!o || (o->op_flags & OPf_WANT) || PL_error_count || o->op_type == OP_RETURN) return o; @@ -1007,7 +1138,7 @@ list(OP *o) else list(kid); } - WITH_THR(curcop = &compiling); + WITH_THR(PL_curcop = &PL_compiling); break; case OP_SCOPE: case OP_LINESEQ: @@ -1017,7 +1148,7 @@ list(OP *o) else list(kid); } - WITH_THR(curcop = &compiling); + WITH_THR(PL_curcop = &PL_compiling); break; case OP_REQUIRE: /* all requires must return a boolean value */ @@ -1044,10 +1175,10 @@ scalarseq(OP *o) scalarvoid(kid); } } - curcop = &compiling; + PL_curcop = &PL_compiling; } o->op_flags &= ~OPf_PARENS; - if (hints & HINT_BLOCK_SCOPE) + if (PL_hints & HINT_BLOCK_SCOPE) o->op_flags |= OPf_PARENS; } else @@ -1072,24 +1203,25 @@ mod(OP *o, I32 type) dTHR; OP *kid; SV *sv; + STRLEN n_a; - if (!o || error_count) + if (!o || PL_error_count) return o; switch (o->op_type) { case OP_UNDEF: - modcount++; + PL_modcount++; return o; case OP_CONST: if (!(o->op_private & (OPpCONST_ARYBASE))) goto nomod; - if (eval_start && eval_start->op_type == OP_CONST) { - compiling.cop_arybase = (I32)SvIV(((SVOP*)eval_start)->op_sv); - eval_start = 0; + if (PL_eval_start && PL_eval_start->op_type == OP_CONST) { + PL_compiling.cop_arybase = (I32)SvIV(((SVOP*)PL_eval_start)->op_sv); + PL_eval_start = 0; } else if (!type) { - SAVEI32(compiling.cop_arybase); - compiling.cop_arybase = 0; + SAVEI32(PL_compiling.cop_arybase); + PL_compiling.cop_arybase = 0; } else if (type == OP_REFGEN) goto nomod; @@ -1104,7 +1236,7 @@ mod(OP *o, I32 type) if ((type == OP_UNDEF || type == OP_REFGEN) && !(o->op_flags & OPf_STACKED)) { o->op_type = OP_RV2CV; /* entersub => rv2cv */ - o->op_ppaddr = ppaddr[OP_RV2CV]; + o->op_ppaddr = PL_ppaddr[OP_RV2CV]; assert(cUNOPo->op_first->op_type == OP_NULL); null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */ break; @@ -1116,8 +1248,9 @@ mod(OP *o, I32 type) if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) break; yyerror(form("Can't modify %s in %s", - op_desc[o->op_type], - type ? op_desc[type] : "local")); + (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL) + ? "do block" : PL_op_desc[o->op_type]), + type ? PL_op_desc[type] : "local")); return o; case OP_PREINC: @@ -1142,7 +1275,7 @@ mod(OP *o, I32 type) case OP_I_SUBTRACT: if (!(o->op_flags & OPf_STACKED)) goto nomod; - modcount++; + PL_modcount++; break; case OP_COND_EXPR: @@ -1155,7 +1288,7 @@ mod(OP *o, I32 type) if (!type && cUNOPo->op_first->op_type != OP_GV) croak("Can't localize through a reference"); if (type == OP_REFGEN && o->op_flags & OPf_PARENS) { - modcount = 10000; + PL_modcount = 10000; return o; /* Treat \(@foo) like ordinary list. */ } /* FALL THROUGH */ @@ -1171,7 +1304,7 @@ mod(OP *o, I32 type) case OP_DBSTATE: case OP_REFGEN: case OP_CHOMP: - modcount = 10000; + PL_modcount = 10000; break; case OP_RV2SV: if (!type && cUNOPo->op_first->op_type != OP_GV) @@ -1180,30 +1313,32 @@ mod(OP *o, I32 type) /* FALL THROUGH */ case OP_GV: case OP_AV2ARYLEN: - hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; case OP_SASSIGN: + case OP_ANDASSIGN: + case OP_ORASSIGN: case OP_AELEMFAST: - modcount++; + PL_modcount++; break; case OP_PADAV: case OP_PADHV: - modcount = 10000; + PL_modcount = 10000; if (type == OP_REFGEN && o->op_flags & OPf_PARENS) return o; /* Treat \(@foo) like ordinary list. */ if (scalar_mod_type(o, type)) goto nomod; /* FALL THROUGH */ case OP_PADSV: - modcount++; + PL_modcount++; if (!type) croak("Can't localize lexical variable %s", - SvPV(*av_fetch(comppad_name, o->op_targ, 4), na)); + SvPV(*av_fetch(PL_comppad_name, o->op_targ, 4), n_a)); break; #ifdef USE_THREADS case OP_THREADSV: - modcount++; /* XXX ??? */ + PL_modcount++; /* XXX ??? */ break; #endif /* USE_THREADS */ @@ -1234,7 +1369,7 @@ mod(OP *o, I32 type) if (type == OP_ENTERSUB && !(o->op_private & (OPpLVAL_INTRO | OPpDEREF))) o->op_private |= OPpLVAL_DEFER; - modcount++; + PL_modcount++; break; case OP_SCOPE: @@ -1245,7 +1380,9 @@ mod(OP *o, I32 type) break; case OP_NULL: - if (!(o->op_flags & OPf_KIDS)) + if (o->op_flags & OPf_SPECIAL) /* do BLOCK */ + goto nomod; + else if (!(o->op_flags & OPf_KIDS)) break; if (o->op_targ != OP_LIST) { mod(cBINOPo->op_first, type); @@ -1264,7 +1401,7 @@ mod(OP *o, I32 type) else if (!type) { o->op_private |= OPpLVAL_INTRO; o->op_flags &= ~OPf_SPECIAL; - hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; } else if (type != OP_GREPSTART && type != OP_ENTERSUB) o->op_flags |= OPf_REF; @@ -1310,14 +1447,37 @@ scalar_mod_type(OP *o, I32 type) case OP_READ: case OP_SYSREAD: case OP_RECV: - case OP_ANDASSIGN: /* may work later */ - case OP_ORASSIGN: /* may work later */ + case OP_ANDASSIGN: + case OP_ORASSIGN: return TRUE; default: return FALSE; } } +STATIC bool +is_handle_constructor(OP *o, I32 argnum) +{ + switch (o->op_type) { + case OP_PIPE_OP: + case OP_SOCKPAIR: + if (argnum == 2) + return TRUE; + /* FALL THROUGH */ + case OP_SYSOPEN: + case OP_OPEN: + case OP_SELECT: /* XXX c.f. SelectSaver.pm */ + case OP_SOCKET: + case OP_OPEN_DIR: + case OP_ACCEPT: + if (argnum == 1) + return TRUE; + /* FALL THROUGH */ + default: + return FALSE; + } +} + OP * refkids(OP *o, I32 type) { @@ -1334,7 +1494,7 @@ ref(OP *o, I32 type) { OP *kid; - if (!o || error_count) + if (!o || PL_error_count) return o; switch (o->op_type) { @@ -1342,7 +1502,7 @@ ref(OP *o, I32 type) if ((type == OP_DEFINED || type == OP_LOCK) && !(o->op_flags & OPf_STACKED)) { o->op_type = OP_RV2CV; /* entersub => rv2cv */ - o->op_ppaddr = ppaddr[OP_RV2CV]; + o->op_ppaddr = PL_ppaddr[OP_RV2CV]; assert(cUNOPo->op_first->op_type == OP_NULL); null(((LISTOP*)cUNOPo->op_first)->op_first); /* disable pushmark */ o->op_flags |= OPf_SPECIAL; @@ -1354,6 +1514,8 @@ ref(OP *o, I32 type) ref(kid, type); break; case OP_RV2SV: + if (type == OP_DEFINED) + o->op_flags |= OPf_SPECIAL; /* don't create GV */ ref(cUNOPo->op_first, o->op_type); /* FALL THROUGH */ case OP_PADSV: @@ -1374,6 +1536,8 @@ ref(OP *o, I32 type) o->op_flags |= OPf_REF; /* FALL THROUGH */ case OP_RV2GV: + if (type == OP_DEFINED) + o->op_flags |= OPf_SPECIAL; /* don't create GV */ ref(cUNOPo->op_first, o->op_type); break; @@ -1420,7 +1584,7 @@ my(OP *o) OP *kid; I32 type; - if (!o || error_count) + if (!o || PL_error_count) return o; type = o->op_type; @@ -1434,7 +1598,7 @@ my(OP *o) type != OP_PADHV && type != OP_PUSHMARK) { - yyerror(form("Can't declare %s in my", op_desc[o->op_type])); + yyerror(form("Can't declare %s in my", PL_op_desc[o->op_type])); return o; } o->op_flags |= OPf_MOD; @@ -1453,20 +1617,23 @@ sawparens(OP *o) OP * bind_match(I32 type, OP *left, OP *right) { + dTHR; OP *o; - if (dowarn && - (left->op_type == OP_RV2AV || - left->op_type == OP_RV2HV || - left->op_type == OP_PADAV || - left->op_type == OP_PADHV)) { - char *desc = op_desc[(right->op_type == OP_SUBST || - right->op_type == OP_TRANS) - ? right->op_type : OP_MATCH]; - char *sample = ((left->op_type == OP_RV2AV || - left->op_type == OP_PADAV) - ? "@array" : "%hash"); - warn("Applying %s to %s will act on scalar(%s)", desc, sample, sample); + if (ckWARN(WARN_UNSAFE) && + (left->op_type == OP_RV2AV || + left->op_type == OP_RV2HV || + left->op_type == OP_PADAV || + left->op_type == OP_PADHV)) { + char *desc = PL_op_desc[(right->op_type == OP_SUBST || + right->op_type == OP_TRANS) + ? right->op_type : OP_MATCH]; + char *sample = ((left->op_type == OP_RV2AV || + left->op_type == OP_PADAV) + ? "@array" : "%hash"); + warner(WARN_UNSAFE, + "Applying %s to %s will act on scalar(%s)", + desc, sample, sample); } if (right->op_type == OP_MATCH || @@ -1501,16 +1668,16 @@ OP * scope(OP *o) { if (o) { - if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || tainting) { + if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) { o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o); o->op_type = OP_LEAVE; - o->op_ppaddr = ppaddr[OP_LEAVE]; + o->op_ppaddr = PL_ppaddr[OP_LEAVE]; } else { if (o->op_type == OP_LINESEQ) { OP *kid; o->op_type = OP_SCOPE; - o->op_ppaddr = ppaddr[OP_SCOPE]; + o->op_ppaddr = PL_ppaddr[OP_SCOPE]; kid = ((LISTOP*)o)->op_first; if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE){ SvREFCNT_dec(((COP*)kid)->cop_filegv); @@ -1527,34 +1694,42 @@ scope(OP *o) void save_hints(void) { - SAVEI32(hints); - SAVESPTR(GvHV(hintgv)); - GvHV(hintgv) = newHVhv(GvHV(hintgv)); - SAVEFREESV(GvHV(hintgv)); + SAVEI32(PL_hints); + SAVESPTR(GvHV(PL_hintgv)); + GvHV(PL_hintgv) = newHVhv(GvHV(PL_hintgv)); + SAVEFREESV(GvHV(PL_hintgv)); } int block_start(int full) { dTHR; - int retval = savestack_ix; + int retval = PL_savestack_ix; - SAVEI32(comppad_name_floor); + SAVEI32(PL_comppad_name_floor); if (full) { - if ((comppad_name_fill = AvFILLp(comppad_name)) > 0) - comppad_name_floor = comppad_name_fill; + if ((PL_comppad_name_fill = AvFILLp(PL_comppad_name)) > 0) + PL_comppad_name_floor = PL_comppad_name_fill; else - comppad_name_floor = 0; - } - SAVEI32(min_intro_pending); - SAVEI32(max_intro_pending); - min_intro_pending = 0; - SAVEI32(comppad_name_fill); - SAVEI32(padix_floor); - padix_floor = padix; - pad_reset_pending = FALSE; + PL_comppad_name_floor = 0; + } + SAVEI32(PL_min_intro_pending); + SAVEI32(PL_max_intro_pending); + PL_min_intro_pending = 0; + SAVEI32(PL_comppad_name_fill); + SAVEI32(PL_padix_floor); + PL_padix_floor = PL_padix; + PL_pad_reset_pending = FALSE; SAVEHINTS(); - hints &= ~HINT_BLOCK_SCOPE; + PL_hints &= ~HINT_BLOCK_SCOPE; + SAVEPPTR(PL_compiling.cop_warnings); + if (PL_compiling.cop_warnings != WARN_ALL && + PL_compiling.cop_warnings != WARN_NONE) { + PL_compiling.cop_warnings = newSVsv(PL_compiling.cop_warnings) ; + SAVEFREESV(PL_compiling.cop_warnings) ; + } + + return retval; } @@ -1562,14 +1737,15 @@ OP* block_end(I32 floor, OP *seq) { dTHR; - int needblockscope = hints & HINT_BLOCK_SCOPE; + int needblockscope = PL_hints & HINT_BLOCK_SCOPE; OP* retval = scalarseq(seq); LEAVE_SCOPE(floor); - pad_reset_pending = FALSE; + PL_pad_reset_pending = FALSE; + PL_compiling.op_private = PL_hints; if (needblockscope) - hints |= HINT_BLOCK_SCOPE; /* propagate out */ - pad_leavemy(comppad_name_fill); - cop_seqmax++; + PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */ + pad_leavemy(PL_comppad_name_fill); + PL_cop_seqmax++; return retval; } @@ -1581,7 +1757,7 @@ newDEFSVOP(void) o->op_targ = find_threadsv("_"); return o; #else - return newSVREF(newGVOP(OP_GV, 0, defgv)); + return newSVREF(newGVOP(OP_GV, 0, PL_defgv)); #endif /* USE_THREADS */ } @@ -1589,21 +1765,25 @@ void newPROG(OP *o) { dTHR; - if (in_eval) { - eval_root = newUNOP(OP_LEAVEEVAL, ((in_eval & 4) ? OPf_SPECIAL : 0), o); - eval_start = linklist(eval_root); - eval_root->op_next = 0; - peep(eval_start); + if (PL_in_eval) { + if (PL_eval_root) + return; + PL_eval_root = newUNOP(OP_LEAVEEVAL, + ((PL_in_eval & EVAL_KEEPERR) + ? OPf_SPECIAL : 0), o); + PL_eval_start = linklist(PL_eval_root); + PL_eval_root->op_next = 0; + peep(PL_eval_start); } else { if (!o) return; - main_root = scope(sawparens(scalarvoid(o))); - curcop = &compiling; - main_start = LINKLIST(main_root); - main_root->op_next = 0; - peep(main_start); - compcv = 0; + PL_main_root = scope(sawparens(scalarvoid(o))); + PL_curcop = &PL_compiling; + PL_main_start = LINKLIST(PL_main_root); + PL_main_root->op_next = 0; + peep(PL_main_start); + PL_compcv = 0; /* Register with debugger */ if (PERLDB_INTER) { @@ -1611,7 +1791,7 @@ newPROG(OP *o) if (cv) { dSP; PUSHMARK(SP); - XPUSHs((SV*)compiling.cop_filegv); + XPUSHs((SV*)PL_compiling.cop_filegv); PUTBACK; perl_call_sv((SV*)cv, G_DISCARD); } @@ -1625,15 +1805,17 @@ localize(OP *o, I32 lex) if (o->op_flags & OPf_PARENS) list(o); else { - if (dowarn && bufptr > oldbufptr && bufptr[-1] == ',') { + dTHR; + if (ckWARN(WARN_PARENTHESIS) && PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ',') { char *s; - for (s = bufptr; *s && (isALNUM(*s) || strchr("@$%, ",*s)); s++) ; + for (s = PL_bufptr; *s && (isALNUM(*s) || (*s & 0x80) || strchr("@$%, ",*s)); s++) ; if (*s == ';' || *s == '=') - warn("Parens missing around \"%s\" list", lex ? "my" : "local"); + warner(WARN_PARENTHESIS, "Parentheses missing around \"%s\" list", + lex ? "my" : "local"); } } - in_my = FALSE; - in_my_stash = Nullhv; + PL_in_my = FALSE; + PL_in_my_stash = Nullhv; if (lex) return my(o); else @@ -1664,18 +1846,22 @@ fold_constants(register OP *o) I32 type = o->op_type; SV *sv; - if (opargs[type] & OA_RETSCALAR) + if (PL_opargs[type] & OA_RETSCALAR) scalar(o); - if (opargs[type] & OA_TARGET) + if (PL_opargs[type] & OA_TARGET) o->op_targ = pad_alloc(type, SVs_PADTMP); - if ((opargs[type] & OA_OTHERINT) && (hints & HINT_INTEGER)) - o->op_ppaddr = ppaddr[type = ++(o->op_type)]; + if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)) + o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)]; - if (!(opargs[type] & OA_FOLDCONST)) + if (!(PL_opargs[type] & OA_FOLDCONST)) goto nope; switch (type) { + case OP_NEGATE: + /* XXX might want a ck_negate() for this */ + cUNOPo->op_first->op_private &= ~OPpCONST_STRICT; + break; case OP_SPRINTF: case OP_UCFIRST: case OP_LCFIRST: @@ -1691,24 +1877,25 @@ fold_constants(register OP *o) goto nope; } - if (error_count) + if (PL_error_count) goto nope; /* Don't try to run w/ errors */ for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) { if (curop->op_type != OP_CONST && - curop->op_type != OP_LIST && - curop->op_type != OP_SCALAR && - curop->op_type != OP_NULL && - curop->op_type != OP_PUSHMARK) { + curop->op_type != OP_LIST && + curop->op_type != OP_SCALAR && + curop->op_type != OP_NULL && + curop->op_type != OP_PUSHMARK) + { goto nope; } } curop = LINKLIST(o); o->op_next = 0; - op = curop; + PL_op = curop; CALLRUNOPS(); - sv = *(stack_sp--); + sv = *(PL_stack_sp--); if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */ pad_swipe(o->op_targ); else if (SvTEMP(sv)) { /* grab mortal temp? */ @@ -1735,10 +1922,10 @@ fold_constants(register OP *o) } nope: - if (!(opargs[type] & OA_OTHERINT)) + if (!(PL_opargs[type] & OA_OTHERINT)) return o; - if (!(hints & HINT_INTEGER)) { + if (!(PL_hints & HINT_INTEGER)) { if (type == OP_DIVIDE || !(o->op_flags & OPf_KIDS)) return o; @@ -1748,11 +1935,11 @@ fold_constants(register OP *o) continue; return o; } - if (opargs[curop->op_type] & OA_RETINTEGER) + if (PL_opargs[curop->op_type] & OA_RETINTEGER) continue; return o; } - o->op_ppaddr = ppaddr[++(o->op_type)]; + o->op_ppaddr = PL_ppaddr[++(o->op_type)]; } return o; @@ -1763,24 +1950,24 @@ gen_constant_list(register OP *o) { dTHR; register OP *curop; - I32 oldtmps_floor = tmps_floor; + I32 oldtmps_floor = PL_tmps_floor; list(o); - if (error_count) + if (PL_error_count) return o; /* Don't attempt to run with errors */ - op = curop = LINKLIST(o); + PL_op = curop = LINKLIST(o); o->op_next = 0; pp_pushmark(ARGS); CALLRUNOPS(); - op = curop; + PL_op = curop; pp_anonlist(ARGS); - tmps_floor = oldtmps_floor; + PL_tmps_floor = oldtmps_floor; o->op_type = OP_RV2AV; - o->op_ppaddr = ppaddr[OP_RV2AV]; + o->op_ppaddr = PL_ppaddr[OP_RV2AV]; curop = ((UNOP*)o)->op_first; - ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*stack_sp--)); + ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*PL_stack_sp--)); op_free(curop); linklist(o); return list(o); @@ -1797,11 +1984,11 @@ convert(I32 type, I32 flags, OP *o) else o->op_flags &= ~OPf_WANT; - if (!(opargs[type] & OA_MARK)) + if (!(PL_opargs[type] & OA_MARK)) null(cLISTOPo->op_first); o->op_type = type; - o->op_ppaddr = ppaddr[type]; + o->op_ppaddr = PL_ppaddr[type]; o->op_flags |= flags; o = CHECKOP(type, o); @@ -1862,9 +2049,12 @@ append_list(I32 type, LISTOP *first, LISTOP *last) first->op_last = last->op_last; first->op_children += last->op_children; if (first->op_children) - last->op_flags |= OPf_KIDS; - - Safefree(last); + first->op_flags |= OPf_KIDS; + +#ifdef PL_OP_SLAB_ALLOC +#else + Safefree(last); +#endif return (OP*)first; } @@ -1919,10 +2109,10 @@ newLISTOP(I32 type, I32 flags, OP *first, OP *last) { LISTOP *listop; - Newz(1101, listop, 1, LISTOP); + NewOp(1101, listop, 1, LISTOP); listop->op_type = type; - listop->op_ppaddr = ppaddr[type]; + listop->op_ppaddr = PL_ppaddr[type]; listop->op_children = (first != 0) + (last != 0); listop->op_flags = flags; @@ -1953,16 +2143,16 @@ OP * newOP(I32 type, I32 flags) { OP *o; - Newz(1101, o, 1, OP); + NewOp(1101, o, 1, OP); o->op_type = type; - o->op_ppaddr = ppaddr[type]; + o->op_ppaddr = PL_ppaddr[type]; o->op_flags = flags; o->op_next = o; o->op_private = 0 + (flags >> 8); - if (opargs[type] & OA_RETSCALAR) + if (PL_opargs[type] & OA_RETSCALAR) scalar(o); - if (opargs[type] & OA_TARGET) + if (PL_opargs[type] & OA_TARGET) o->op_targ = pad_alloc(type, SVs_PADTMP); return CHECKOP(type, o); } @@ -1974,12 +2164,12 @@ newUNOP(I32 type, I32 flags, OP *first) if (!first) first = newOP(OP_STUB, 0); - if (opargs[type] & OA_MARK) + if (PL_opargs[type] & OA_MARK) first = force_list(first); - Newz(1101, unop, 1, UNOP); + NewOp(1101, unop, 1, UNOP); unop->op_type = type; - unop->op_ppaddr = ppaddr[type]; + unop->op_ppaddr = PL_ppaddr[type]; unop->op_first = first; unop->op_flags = flags | OPf_KIDS; unop->op_private = 1 | (flags >> 8); @@ -1994,13 +2184,13 @@ OP * newBINOP(I32 type, I32 flags, OP *first, OP *last) { BINOP *binop; - Newz(1101, binop, 1, BINOP); + NewOp(1101, binop, 1, BINOP); if (!first) first = newOP(OP_NULL, 0); binop->op_type = type; - binop->op_ppaddr = ppaddr[type]; + binop->op_ppaddr = PL_ppaddr[type]; binop->op_first = first; binop->op_flags = flags | OPf_KIDS; if (!last) { @@ -2016,11 +2206,24 @@ newBINOP(I32 type, I32 flags, OP *first, OP *last) if (binop->op_next) return (OP*)binop; - binop->op_last = last = binop->op_first->op_sibling; + binop->op_last = binop->op_first->op_sibling; return fold_constants((OP *)binop); } +static int +utf8compare(const void *a, const void *b) +{ + int i; + for (i = 0; i < 10; i++) { + if ((*(U8**)a)[i] < (*(U8**)b)[i]) + return -1; + if ((*(U8**)a)[i] > (*(U8**)b)[i]) + return 1; + } + return 0; +} + OP * pmtrans(OP *o, OP *expr, OP *repl) { @@ -2032,16 +2235,200 @@ pmtrans(OP *o, OP *expr, OP *repl) register U8 *r = (U8*)SvPV(rstr, rlen); register I32 i; register I32 j; - I32 Delete; + I32 del; I32 complement; I32 squash; register short *tbl; - tbl = (short*)cPVOPo->op_pv; complement = o->op_private & OPpTRANS_COMPLEMENT; - Delete = o->op_private & OPpTRANS_DELETE; + del = o->op_private & OPpTRANS_DELETE; squash = o->op_private & OPpTRANS_SQUASH; + if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) { + SV* listsv = newSVpvn("# comment\n",10); + SV* transv = 0; + U8* tend = t + tlen; + U8* rend = r + rlen; + I32 ulen; + U32 tfirst = 1; + U32 tlast = 0; + I32 tdiff; + U32 rfirst = 1; + U32 rlast = 0; + I32 rdiff; + I32 diff; + I32 none = 0; + U32 max = 0; + I32 bits; + I32 grows = 0; + I32 havefinal = 0; + U32 final; + HV *hv; + I32 from_utf = o->op_private & OPpTRANS_FROM_UTF; + I32 to_utf = o->op_private & OPpTRANS_TO_UTF; + + if (complement) { + U8 tmpbuf[10]; + U8** cp; + UV nextmin = 0; + New(1109, cp, tlen, U8*); + i = 0; + transv = newSVpvn("",0); + while (t < tend) { + cp[i++] = t; + t += UTF8SKIP(t); + if (*t == 0xff) { + t++; + t += UTF8SKIP(t); + } + } + qsort(cp, i, sizeof(U8*), utf8compare); + for (j = 0; j < i; j++) { + U8 *s = cp[j]; + UV val = utf8_to_uv(s, &ulen); + s += ulen; + diff = val - nextmin; + if (diff > 0) { + t = uv_to_utf8(tmpbuf,nextmin); + sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf); + if (diff > 1) { + t = uv_to_utf8(tmpbuf, val - 1); + sv_catpvn(transv, "\377", 1); + sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf); + } + } + if (*s == 0xff) + val = utf8_to_uv(s+1, &ulen); + if (val >= nextmin) + nextmin = val + 1; + } + t = uv_to_utf8(tmpbuf,nextmin); + sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf); + t = uv_to_utf8(tmpbuf, 0x7fffffff); + sv_catpvn(transv, "\377", 1); + sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf); + t = (U8*)SvPVX(transv); + tlen = SvCUR(transv); + tend = t + tlen; + } + else if (!rlen && !del) { + r = t; rlen = tlen; rend = tend; + } + if (!squash) { + if (to_utf && from_utf) { /* only counting characters */ + if (t == r || (tlen == rlen && memEQ(t, r, tlen))) + o->op_private |= OPpTRANS_IDENTICAL; + } + else { /* straight latin-1 translation */ + if (tlen == 4 && memEQ(t, "\0\377\303\277", 4) && + rlen == 4 && memEQ(r, "\0\377\303\277", 4)) + o->op_private |= OPpTRANS_IDENTICAL; + } + } + + while (t < tend || tfirst <= tlast) { + /* see if we need more "t" chars */ + if (tfirst > tlast) { + tfirst = (I32)utf8_to_uv(t, &ulen); + t += ulen; + if (t < tend && *t == 0xff) { /* illegal utf8 val indicates range */ + tlast = (I32)utf8_to_uv(++t, &ulen); + t += ulen; + } + else + tlast = tfirst; + } + + /* now see if we need more "r" chars */ + if (rfirst > rlast) { + if (r < rend) { + rfirst = (I32)utf8_to_uv(r, &ulen); + r += ulen; + if (r < rend && *r == 0xff) { /* illegal utf8 val indicates range */ + rlast = (I32)utf8_to_uv(++r, &ulen); + r += ulen; + } + else + rlast = rfirst; + } + else { + if (!havefinal++) + final = rlast; + rfirst = rlast = 0xffffffff; + } + } + + /* now see which range will peter our first, if either. */ + tdiff = tlast - tfirst; + rdiff = rlast - rfirst; + + if (tdiff <= rdiff) + diff = tdiff; + else + diff = rdiff; + + if (rfirst == 0xffffffff) { + diff = tdiff; /* oops, pretend rdiff is infinite */ + if (diff > 0) + sv_catpvf(listsv, "%04x\t%04x\tXXXX\n", tfirst, tlast); + else + sv_catpvf(listsv, "%04x\t\tXXXX\n", tfirst); + } + else { + if (diff > 0) + sv_catpvf(listsv, "%04x\t%04x\t%04x\n", tfirst, tfirst + diff, rfirst); + else + sv_catpvf(listsv, "%04x\t\t%04x\n", tfirst, rfirst); + + if (rfirst + diff > max) + max = rfirst + diff; + rfirst += diff + 1; + if (!grows) { + if (rfirst <= 0x80) + ; + else if (rfirst <= 0x800) + grows |= (tfirst < 0x80); + else if (rfirst <= 0x10000) + grows |= (tfirst < 0x800); + else if (rfirst <= 0x200000) + grows |= (tfirst < 0x10000); + else if (rfirst <= 0x4000000) + grows |= (tfirst < 0x200000); + else if (rfirst <= 0x80000000) + grows |= (tfirst < 0x4000000); + } + } + tfirst += diff + 1; + } + + none = ++max; + if (del) + del = ++max; + + if (max > 0xffff) + bits = 32; + else if (max > 0xff) + bits = 16; + else + bits = 8; + + cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none); + SvREFCNT_dec(listsv); + if (transv) + SvREFCNT_dec(transv); + + if (!del && havefinal) + (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5, newSViv((IV)final), 0); + + if (grows && to_utf) + o->op_private |= OPpTRANS_GROWS; + + op_free(expr); + op_free(repl); + return o; + } + + tbl = (short*)cPVOPo->op_pv; if (complement) { Zero(tbl, 256, short); for (i = 0; i < tlen; i++) @@ -2049,7 +2436,7 @@ pmtrans(OP *o, OP *expr, OP *repl) for (i = 0, j = 0; i < 256; i++) { if (!tbl[i]) { if (j >= rlen) { - if (Delete) + if (del) tbl[i] = -2; else if (rlen) tbl[i] = r[j-1]; @@ -2062,16 +2449,16 @@ pmtrans(OP *o, OP *expr, OP *repl) } } else { - if (!rlen && !Delete) { + if (!rlen && !del) { r = t; rlen = tlen; if (!squash) - o->op_private |= OPpTRANS_COUNTONLY; + o->op_private |= OPpTRANS_IDENTICAL; } for (i = 0; i < 256; i++) tbl[i] = -1; for (i = 0, j = 0; i < tlen; i++,j++) { if (j >= rlen) { - if (Delete) { + if (del) { if (tbl[t[i]] == -1) tbl[t[i]] = -2; continue; @@ -2094,22 +2481,22 @@ newPMOP(I32 type, I32 flags) dTHR; PMOP *pmop; - Newz(1101, pmop, 1, PMOP); + NewOp(1101, pmop, 1, PMOP); pmop->op_type = type; - pmop->op_ppaddr = ppaddr[type]; + pmop->op_ppaddr = PL_ppaddr[type]; pmop->op_flags = flags; pmop->op_private = 0 | (flags >> 8); - if (hints & HINT_RE_TAINT) + if (PL_hints & HINT_RE_TAINT) pmop->op_pmpermflags |= PMf_RETAINT; - if (hints & HINT_LOCALE) + if (PL_hints & HINT_LOCALE) pmop->op_pmpermflags |= PMf_LOCALE; pmop->op_pmflags = pmop->op_pmpermflags; /* link into pm list */ - if (type != OP_TRANS && curstash) { - pmop->op_pmnext = HvPMROOT(curstash); - HvPMROOT(curstash) = pmop; + if (type != OP_TRANS && PL_curstash) { + pmop->op_pmnext = HvPMROOT(PL_curstash); + HvPMROOT(PL_curstash) = pmop; } return (OP*)pmop; @@ -2126,7 +2513,7 @@ pmruntime(OP *o, OP *expr, OP *repl) if (o->op_type == OP_TRANS) return pmtrans(o, expr, repl); - hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; pm = (PMOP*)o; if (expr->op_type == OP_CONST) { @@ -2144,23 +2531,23 @@ pmruntime(OP *o, OP *expr, OP *repl) op_free(expr); } else { - if (pm->op_pmflags & PMf_KEEP || !(hints & HINT_RE_EVAL)) - expr = newUNOP((!(hints & HINT_RE_EVAL) + if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) + expr = newUNOP((!(PL_hints & HINT_RE_EVAL) ? OP_REGCRESET : OP_REGCMAYBE),0,expr); - Newz(1101, rcop, 1, LOGOP); + NewOp(1101, rcop, 1, LOGOP); rcop->op_type = OP_REGCOMP; - rcop->op_ppaddr = ppaddr[OP_REGCOMP]; + rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP]; rcop->op_first = scalar(expr); - rcop->op_flags |= ((hints & HINT_RE_EVAL) + rcop->op_flags |= ((PL_hints & HINT_RE_EVAL) ? (OPf_SPECIAL | OPf_KIDS) : OPf_KIDS); rcop->op_private = 1; rcop->op_other = o; /* establish postfix order */ - if (pm->op_pmflags & PMf_KEEP || !(hints & HINT_RE_EVAL)) { + if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) { LINKLIST(expr); rcop->op_next = expr; ((UNOP*)expr)->op_first->op_next = (OP*)rcop; @@ -2175,12 +2562,15 @@ pmruntime(OP *o, OP *expr, OP *repl) if (repl) { OP *curop; - if (pm->op_pmflags & PMf_EVAL) + if (pm->op_pmflags & PMf_EVAL) { curop = 0; + if (PL_curcop->cop_line < PL_multi_end) + PL_curcop->cop_line = PL_multi_end; + } #ifdef USE_THREADS else if (repl->op_type == OP_THREADSV && strchr("&`'123456789+", - threadsv_names[repl->op_targ])) + PL_threadsv_names[repl->op_targ])) { curop = 0; } @@ -2190,7 +2580,7 @@ pmruntime(OP *o, OP *expr, OP *repl) else { OP *lastop = 0; for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) { - if (opargs[curop->op_type] & OA_DANGEROUS) { + if (PL_opargs[curop->op_type] & OA_DANGEROUS) { #ifdef USE_THREADS if (curop->op_type == OP_THREADSV) { repl_has_vars = 1; @@ -2241,9 +2631,9 @@ pmruntime(OP *o, OP *expr, OP *repl) pm->op_pmflags |= PMf_MAYBE_CONST; pm->op_pmpermflags |= PMf_MAYBE_CONST; } - Newz(1101, rcop, 1, LOGOP); + NewOp(1101, rcop, 1, LOGOP); rcop->op_type = OP_SUBSTCONT; - rcop->op_ppaddr = ppaddr[OP_SUBSTCONT]; + rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT]; rcop->op_first = scalar(repl); rcop->op_flags |= OPf_KIDS; rcop->op_private = 1; @@ -2266,15 +2656,15 @@ OP * newSVOP(I32 type, I32 flags, SV *sv) { SVOP *svop; - Newz(1101, svop, 1, SVOP); + NewOp(1101, svop, 1, SVOP); svop->op_type = type; - svop->op_ppaddr = ppaddr[type]; + svop->op_ppaddr = PL_ppaddr[type]; svop->op_sv = sv; svop->op_next = (OP*)svop; svop->op_flags = flags; - if (opargs[type] & OA_RETSCALAR) + if (PL_opargs[type] & OA_RETSCALAR) scalar((OP*)svop); - if (opargs[type] & OA_TARGET) + if (PL_opargs[type] & OA_TARGET) svop->op_targ = pad_alloc(type, SVs_PADTMP); return CHECKOP(type, svop); } @@ -2284,15 +2674,15 @@ newGVOP(I32 type, I32 flags, GV *gv) { dTHR; GVOP *gvop; - Newz(1101, gvop, 1, GVOP); + NewOp(1101, gvop, 1, GVOP); gvop->op_type = type; - gvop->op_ppaddr = ppaddr[type]; + gvop->op_ppaddr = PL_ppaddr[type]; gvop->op_gv = (GV*)SvREFCNT_inc(gv); gvop->op_next = (OP*)gvop; gvop->op_flags = flags; - if (opargs[type] & OA_RETSCALAR) + if (PL_opargs[type] & OA_RETSCALAR) scalar((OP*)gvop); - if (opargs[type] & OA_TARGET) + if (PL_opargs[type] & OA_TARGET) gvop->op_targ = pad_alloc(type, SVs_PADTMP); return CHECKOP(type, gvop); } @@ -2301,15 +2691,15 @@ OP * newPVOP(I32 type, I32 flags, char *pv) { PVOP *pvop; - Newz(1101, pvop, 1, PVOP); + NewOp(1101, pvop, 1, PVOP); pvop->op_type = type; - pvop->op_ppaddr = ppaddr[type]; + pvop->op_ppaddr = PL_ppaddr[type]; pvop->op_pv = pv; pvop->op_next = (OP*)pvop; pvop->op_flags = flags; - if (opargs[type] & OA_RETSCALAR) + if (PL_opargs[type] & OA_RETSCALAR) scalar((OP*)pvop); - if (opargs[type] & OA_TARGET) + if (PL_opargs[type] & OA_TARGET) pvop->op_targ = pad_alloc(type, SVs_PADTMP); return CHECKOP(type, pvop); } @@ -2320,23 +2710,24 @@ package(OP *o) dTHR; SV *sv; - save_hptr(&curstash); - save_item(curstname); + save_hptr(&PL_curstash); + save_item(PL_curstname); if (o) { STRLEN len; char *name; sv = cSVOPo->op_sv; name = SvPV(sv, len); - curstash = gv_stashpvn(name,len,TRUE); - sv_setpvn(curstname, name, len); + PL_curstash = gv_stashpvn(name,len,TRUE); + sv_setpvn(PL_curstname, name, len); op_free(o); } else { - sv_setpv(curstname,""); - curstash = Nullhv; + sv_setpv(PL_curstname,""); + PL_curstash = Nullhv; } - copline = NOLINE; - expect = XSTATE; + PL_hints |= HINT_BLOCK_SCOPE; + PL_copline = NOLINE; + PL_expect = XSTATE; } void @@ -2347,6 +2738,7 @@ utilize(int aver, I32 floor, OP *version, OP *id, OP *arg) OP *rqop; OP *imop; OP *veop; + GV *gv; if (id->op_type != OP_CONST) croak("Module name must be constant"); @@ -2370,7 +2762,7 @@ utilize(int aver, I32 floor, OP *version, OP *id, OP *arg) pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv)); /* Fake up a method call to VERSION */ - meth = newSVOP(OP_CONST, 0, newSVpv("VERSION", 7)); + meth = newSVOP(OP_CONST, 0, newSVpvn("VERSION", 7)); veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL, append_elem(OP_LIST, prepend_elem(OP_LIST, pack, list(version)), @@ -2389,8 +2781,8 @@ utilize(int aver, I32 floor, OP *version, OP *id, OP *arg) pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv)); meth = newSVOP(OP_CONST, 0, aver - ? newSVpv("import", 6) - : newSVpv("unimport", 8) + ? newSVpvn("import", 6) + : newSVpvn("unimport", 8) ); imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL, append_elem(OP_LIST, @@ -2398,12 +2790,25 @@ utilize(int aver, I32 floor, OP *version, OP *id, OP *arg) newUNOP(OP_METHOD, 0, meth))); } - /* Fake up a require */ - rqop = newUNOP(OP_REQUIRE, 0, id); + /* Fake up a require, handle override, if any */ + gv = gv_fetchpv("require", FALSE, SVt_PVCV); + if (!(gv && GvIMPORTED_CV(gv))) + gv = gv_fetchpv("CORE::GLOBAL::require", FALSE, SVt_PVCV); + + if (gv && GvIMPORTED_CV(gv)) { + rqop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED, + append_elem(OP_LIST, id, + scalar(newUNOP(OP_RV2CV, 0, + newGVOP(OP_GV, 0, + gv)))))); + } + else { + rqop = newUNOP(OP_REQUIRE, 0, id); + } /* Fake up the BEGIN {}, which does its thing immediately. */ newSUB(floor, - newSVOP(OP_CONST, 0, newSVpv("BEGIN", 5)), + newSVOP(OP_CONST, 0, newSVpvn("BEGIN", 5)), Nullop, append_elem(OP_LINESEQ, append_elem(OP_LINESEQ, @@ -2411,8 +2816,31 @@ utilize(int aver, I32 floor, OP *version, OP *id, OP *arg) newSTATEOP(0, Nullch, veop)), newSTATEOP(0, Nullch, imop) )); - copline = NOLINE; - expect = XSTATE; + PL_copline = NOLINE; + PL_expect = XSTATE; +} + +OP * +dofile(OP *term) +{ + OP *doop; + GV *gv; + + gv = gv_fetchpv("do", FALSE, SVt_PVCV); + if (!(gv && GvIMPORTED_CV(gv))) + gv = gv_fetchpv("CORE::GLOBAL::do", FALSE, SVt_PVCV); + + if (gv && GvIMPORTED_CV(gv)) { + doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED, + append_elem(OP_LIST, term, + scalar(newUNOP(OP_RV2CV, 0, + newGVOP(OP_GV, 0, + gv)))))); + } + else { + doop = newUNOP(OP_DOFILE, 0, scalar(term)); + } + return doop; } OP * @@ -2476,11 +2904,11 @@ newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right) if (list_assignment(left)) { dTHR; - modcount = 0; - eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/ + PL_modcount = 0; + PL_eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/ left = mod(left, OP_AASSIGN); - if (eval_start) - eval_start = 0; + if (PL_eval_start) + PL_eval_start = 0; else { op_free(left); op_free(right); @@ -2493,24 +2921,24 @@ newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right) if (!(left->op_private & OPpLVAL_INTRO)) { OP *curop; OP *lastop = o; - generation++; + PL_generation++; for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) { - if (opargs[curop->op_type] & OA_DANGEROUS) { + if (PL_opargs[curop->op_type] & OA_DANGEROUS) { if (curop->op_type == OP_GV) { GV *gv = ((GVOP*)curop)->op_gv; - if (gv == defgv || SvCUR(gv) == generation) + if (gv == PL_defgv || SvCUR(gv) == PL_generation) break; - SvCUR(gv) = generation; + SvCUR(gv) = PL_generation; } else if (curop->op_type == OP_PADSV || curop->op_type == OP_PADAV || curop->op_type == OP_PADHV || curop->op_type == OP_PADANY) { - SV **svp = AvARRAY(comppad_name); + SV **svp = AvARRAY(PL_comppad_name); SV *sv = svp[curop->op_targ]; - if (SvCUR(sv) == generation) + if (SvCUR(sv) == PL_generation) break; - SvCUR(sv) = generation; /* (SvCUR not used any more) */ + SvCUR(sv) = PL_generation; /* (SvCUR not used any more) */ } else if (curop->op_type == OP_RV2CV) break; @@ -2524,9 +2952,9 @@ newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right) else if (curop->op_type == OP_PUSHRE) { if (((PMOP*)curop)->op_pmreplroot) { GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot; - if (gv == defgv || SvCUR(gv) == generation) + if (gv == PL_defgv || SvCUR(gv) == PL_generation) break; - SvCUR(gv) = generation; + SvCUR(gv) = PL_generation; } } else @@ -2562,12 +2990,12 @@ newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right) } } else { - if (modcount < 10000 && + if (PL_modcount < 10000 && ((LISTOP*)right)->op_last->op_type == OP_CONST) { SV *sv = ((SVOP*)((LISTOP*)right)->op_last)->op_sv; if (SvIVX(sv) == 0) - sv_setiv(sv, modcount+1); + sv_setiv(sv, PL_modcount+1); } } } @@ -2581,11 +3009,11 @@ newASSIGNOP(I32 flags, OP *left, I32 optype, OP *right) return newBINOP(OP_NULL, flags, mod(scalar(left), OP_SASSIGN), scalar(right)); } else { - eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/ + PL_eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/ o = newBINOP(OP_SASSIGN, flags, scalar(right), mod(scalar(left), OP_SASSIGN) ); - if (eval_start) - eval_start = 0; + if (PL_eval_start) + PL_eval_start = 0; else { op_free(o); return Nullop; @@ -2601,41 +3029,48 @@ newSTATEOP(I32 flags, char *label, OP *o) U32 seq = intro_my(); register COP *cop; - Newz(1101, cop, 1, COP); - if (PERLDB_LINE && curcop->cop_line && curstash != debstash) { + NewOp(1101, cop, 1, COP); + if (PERLDB_LINE && PL_curcop->cop_line && PL_curstash != PL_debstash) { cop->op_type = OP_DBSTATE; - cop->op_ppaddr = ppaddr[ OP_DBSTATE ]; + cop->op_ppaddr = PL_ppaddr[ OP_DBSTATE ]; } else { cop->op_type = OP_NEXTSTATE; - cop->op_ppaddr = ppaddr[ OP_NEXTSTATE ]; + cop->op_ppaddr = PL_ppaddr[ OP_NEXTSTATE ]; } cop->op_flags = flags; - cop->op_private = 0 | (flags >> 8); + cop->op_private = (PL_hints & HINT_UTF8); #ifdef NATIVE_HINTS cop->op_private |= NATIVE_HINTS; #endif + PL_compiling.op_private = cop->op_private; cop->op_next = (OP*)cop; if (label) { cop->cop_label = label; - hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; } cop->cop_seq = seq; - cop->cop_arybase = curcop->cop_arybase; + cop->cop_arybase = PL_curcop->cop_arybase; + if (PL_curcop->cop_warnings == WARN_NONE + || PL_curcop->cop_warnings == WARN_ALL) + cop->cop_warnings = PL_curcop->cop_warnings ; + else + cop->cop_warnings = newSVsv(PL_curcop->cop_warnings) ; - if (copline == NOLINE) - cop->cop_line = curcop->cop_line; + + if (PL_copline == NOLINE) + cop->cop_line = PL_curcop->cop_line; else { - cop->cop_line = copline; - copline = NOLINE; + cop->cop_line = PL_copline; + PL_copline = NOLINE; } - cop->cop_filegv = (GV*)SvREFCNT_inc(curcop->cop_filegv); - cop->cop_stash = curstash; + cop->cop_filegv = (GV*)SvREFCNT_inc(PL_curcop->cop_filegv); + cop->cop_stash = PL_curstash; - if (PERLDB_LINE && curstash != debstash) { - SV **svp = av_fetch(GvAV(curcop->cop_filegv),(I32)cop->cop_line, FALSE); - if (svp && *svp != &sv_undef && !SvIOK(*svp)) { + if (PERLDB_LINE && PL_curstash != PL_debstash) { + SV **svp = av_fetch(GvAV(PL_curcop->cop_filegv),(I32)cop->cop_line, FALSE); + if (svp && *svp != &PL_sv_undef && !SvIOK(*svp)) { (void)SvIOK_on(*svp); SvIVX(*svp) = 1; SvSTASH(*svp) = (HV*)cop; @@ -2653,19 +3088,19 @@ intro_my(void) SV *sv; I32 i; - if (! min_intro_pending) - return cop_seqmax; + if (! PL_min_intro_pending) + return PL_cop_seqmax; - svp = AvARRAY(comppad_name); - for (i = min_intro_pending; i <= max_intro_pending; i++) { - if ((sv = svp[i]) && sv != &sv_undef && !SvIVX(sv)) { - SvIVX(sv) = 999999999; /* Don't know scope end yet. */ - SvNVX(sv) = (double)cop_seqmax; + svp = AvARRAY(PL_comppad_name); + for (i = PL_min_intro_pending; i <= PL_max_intro_pending; i++) { + if ((sv = svp[i]) && sv != &PL_sv_undef && !SvIVX(sv)) { + SvIVX(sv) = PAD_MAX; /* Don't know scope end yet. */ + SvNVX(sv) = (double)PL_cop_seqmax; } } - min_intro_pending = 0; - comppad_name_fill = max_intro_pending; /* Needn't search higher */ - return cop_seqmax++; + PL_min_intro_pending = 0; + PL_comppad_name_fill = PL_max_intro_pending; /* Needn't search higher */ + return PL_cop_seqmax++; } OP * @@ -2703,8 +3138,9 @@ new_logop(I32 type, I32 flags, OP** firstp, OP** otherp) } } if (first->op_type == OP_CONST) { - if (dowarn && (first->op_private & OPpCONST_BARE)) - warn("Probable precedence problem on %s", op_desc[type]); + if (ckWARN(WARN_PRECEDENCE) && (first->op_private & OPpCONST_BARE)) + warner(WARN_PRECEDENCE, "Probable precedence problem on %s", + PL_op_desc[type]); if ((type == OP_AND) == (SvTRUE(((SVOP*)first)->op_sv))) { op_free(first); *firstp = Nullop; @@ -2722,7 +3158,7 @@ new_logop(I32 type, I32 flags, OP** firstp, OP** otherp) else scalar(other); } - else if (dowarn && (first->op_flags & OPf_KIDS)) { + else if (ckWARN(WARN_UNSAFE) && (first->op_flags & OPf_KIDS)) { OP *k1 = ((UNOP*)first)->op_first; OP *k2 = k1->op_sibling; OPCODE warnop = 0; @@ -2743,13 +3179,14 @@ new_logop(I32 type, I32 flags, OP** firstp, OP** otherp) break; } if (warnop) { - line_t oldline = curcop->cop_line; - curcop->cop_line = copline; - warn("Value of %s%s can be \"0\"; test with defined()", - op_desc[warnop], + line_t oldline = PL_curcop->cop_line; + PL_curcop->cop_line = PL_copline; + warner(WARN_UNSAFE, + "Value of %s%s can be \"0\"; test with defined()", + PL_op_desc[warnop], ((warnop == OP_READLINE || warnop == OP_GLOB) ? " construct" : "() operator")); - curcop->cop_line = oldline; + PL_curcop->cop_line = oldline; } } @@ -2759,10 +3196,10 @@ new_logop(I32 type, I32 flags, OP** firstp, OP** otherp) if (type == OP_ANDASSIGN || type == OP_ORASSIGN) other->op_private |= OPpASSIGN_BACKWARDS; /* other is an OP_SASSIGN */ - Newz(1101, logop, 1, LOGOP); + NewOp(1101, logop, 1, LOGOP); logop->op_type = type; - logop->op_ppaddr = ppaddr[type]; + logop->op_ppaddr = PL_ppaddr[type]; logop->op_first = first; logop->op_flags = flags | OPf_KIDS; logop->op_other = LINKLIST(other); @@ -2808,10 +3245,10 @@ newCONDOP(I32 flags, OP *first, OP *trueop, OP *falseop) list(trueop); scalar(falseop); } - Newz(1101, condop, 1, CONDOP); + NewOp(1101, condop, 1, CONDOP); condop->op_type = OP_COND_EXPR; - condop->op_ppaddr = ppaddr[OP_COND_EXPR]; + condop->op_ppaddr = PL_ppaddr[OP_COND_EXPR]; condop->op_first = first; condop->op_flags = flags | OPf_KIDS; condop->op_true = LINKLIST(trueop); @@ -2841,10 +3278,10 @@ newRANGE(I32 flags, OP *left, OP *right) OP *flop; OP *o; - Newz(1101, condop, 1, CONDOP); + NewOp(1101, condop, 1, CONDOP); condop->op_type = OP_RANGE; - condop->op_ppaddr = ppaddr[OP_RANGE]; + condop->op_ppaddr = PL_ppaddr[OP_RANGE]; condop->op_first = left; condop->op_flags = OPf_KIDS; condop->op_true = LINKLIST(left); @@ -2974,7 +3411,7 @@ newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *expr, OP *b if (expr) { cont = append_elem(OP_LINESEQ, cont, newOP(OP_UNSTACK, 0)); if ((line_t)whileline != NOLINE) { - copline = whileline; + PL_copline = whileline; cont = append_elem(OP_LINESEQ, cont, newSTATEOP(0, Nullch, Nullop)); } @@ -2984,7 +3421,7 @@ newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *expr, OP *b redo = LINKLIST(listop); if (expr) { - copline = whileline; + PL_copline = whileline; scalar(listop); o = new_logop(OP_AND, 0, &expr, &listop); if (o == expr && o->op_type == OP_CONST && !SvTRUE(cSVOPo->op_sv)) { @@ -3002,9 +3439,9 @@ newWHILEOP(I32 flags, I32 debuggable, LOOP *loop, I32 whileline, OP *expr, OP *b o = listop; if (!loop) { - Newz(1101,loop,1,LOOP); + NewOp(1101,loop,1,LOOP); loop->op_type = OP_ENTERLOOP; - loop->op_ppaddr = ppaddr[OP_ENTERLOOP]; + loop->op_ppaddr = PL_ppaddr[OP_ENTERLOOP]; loop->op_private = 0; loop->op_next = (OP*)loop; } @@ -3028,6 +3465,7 @@ OP * newFOROP(I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont) { LOOP *loop; + LOOP *tmp; OP *wop; int padoff = 0; I32 iterflags = 0; @@ -3035,7 +3473,7 @@ newFOROP(I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont if (sv) { if (sv->op_type == OP_RV2SV) { /* symbol table variable */ sv->op_type = OP_RV2GV; - sv->op_ppaddr = ppaddr[OP_RV2GV]; + sv->op_ppaddr = PL_ppaddr[OP_RV2GV]; } else if (sv->op_type == OP_PADSV) { /* private variable */ padoff = sv->op_targ; @@ -3049,14 +3487,14 @@ newFOROP(I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont sv = Nullop; } else - croak("Can't use %s for loop variable", op_desc[sv->op_type]); + croak("Can't use %s for loop variable", PL_op_desc[sv->op_type]); } else { #ifdef USE_THREADS padoff = find_threadsv("_"); iterflags |= OPf_SPECIAL; #else - sv = newGVOP(OP_GV, 0, defgv); + sv = newGVOP(OP_GV, 0, PL_defgv); #endif } if (expr->op_type == OP_RV2AV || expr->op_type == OP_PADAV) { @@ -3099,10 +3537,16 @@ newFOROP(I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont loop = (LOOP*)list(convert(OP_ENTERITER, iterflags, append_elem(OP_LIST, expr, scalar(sv)))); assert(!loop->op_next); +#ifdef PL_OP_SLAB_ALLOC + NewOp(1234,tmp,1,LOOP); + Copy(loop,tmp,1,LOOP); + loop = tmp; +#else Renew(loop, 1, LOOP); +#endif loop->op_targ = padoff; wop = newWHILEOP(flags, 1, loop, forline, newOP(OP_ITER, 0), block, cont); - copline = forline; + PL_copline = forline; return newSTATEOP(0, label, wop); } @@ -3111,13 +3555,15 @@ newLOOPEX(I32 type, OP *label) { dTHR; OP *o; + STRLEN n_a; + if (type != OP_GOTO || label->op_type == OP_CONST) { /* "last()" means "last" */ if (label->op_type == OP_STUB && (label->op_flags & OPf_PARENS)) o = newOP(type, OPf_SPECIAL); else { o = newPVOP(type, 0, savepv(label->op_type == OP_CONST - ? SvPVx(((SVOP*)label)->op_sv, na) + ? SvPVx(((SVOP*)label)->op_sv, n_a) : "")); } op_free(label); @@ -3127,7 +3573,7 @@ newLOOPEX(I32 type, OP *label) label = newUNOP(OP_REFGEN, 0, mod(label, OP_REFGEN)); o = newUNOP(type, OPf_STACKED, label); } - hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; return o; } @@ -3153,8 +3599,8 @@ cv_undef(CV *cv) #endif /* USE_THREADS */ ENTER; - SAVESPTR(curpad); - curpad = 0; + SAVESPTR(PL_curpad); + PL_curpad = 0; if (!CvCLONED(cv)) op_free(CvROOT(cv)); @@ -3176,11 +3622,11 @@ cv_undef(CV *cv) SV* sv = svp ? *svp : Nullsv; if (!sv) continue; - if (sv == (SV*)comppad_name) - comppad_name = Nullav; - else if (sv == (SV*)comppad) { - comppad = Nullav; - curpad = Null(SV**); + if (sv == (SV*)PL_comppad_name) + PL_comppad_name = Nullav; + else if (sv == (SV*)PL_comppad) { + PL_comppad = Nullav; + PL_curpad = Null(SV**); } SvREFCNT_dec(sv); } @@ -3192,8 +3638,7 @@ cv_undef(CV *cv) #ifdef DEBUG_CLOSURES STATIC void -cv_dump(cv) -CV* cv; +cv_dump(CV *cv) { CV *outside = CvOUTSIDE(cv); AV* padlist = CvPADLIST(cv); @@ -3206,13 +3651,13 @@ CV* cv; PerlIO_printf(Perl_debug_log, "\tCV=0x%lx (%s), OUTSIDE=0x%lx (%s)\n", cv, (CvANON(cv) ? "ANON" - : (cv == main_cv) ? "MAIN" - : CvUNIQUE(outside) ? "UNIQUE" + : (cv == PL_main_cv) ? "MAIN" + : CvUNIQUE(cv) ? "UNIQUE" : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"), outside, (!outside ? "null" : CvANON(outside) ? "ANON" - : (outside == main_cv) ? "MAIN" + : (outside == PL_main_cv) ? "MAIN" : CvUNIQUE(outside) ? "UNIQUE" : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED")); @@ -3255,12 +3700,12 @@ cv_clone2(CV *proto, CV *outside) assert(!CvUNIQUE(proto)); ENTER; - SAVESPTR(curpad); - SAVESPTR(comppad); - SAVESPTR(comppad_name); - SAVESPTR(compcv); + SAVESPTR(PL_curpad); + SAVESPTR(PL_comppad); + SAVESPTR(PL_comppad_name); + SAVESPTR(PL_compcv); - cv = compcv = (CV*)NEWSV(1104,0); + cv = PL_compcv = (CV*)NEWSV(1104,0); sv_upgrade((SV *)cv, SvTYPE(proto)); CvCLONED_on(cv); if (CvANON(proto)) @@ -3282,34 +3727,34 @@ cv_clone2(CV *proto, CV *outside) if (SvPOK(proto)) sv_setpvn((SV*)cv, SvPVX(proto), SvCUR(proto)); - comppad_name = newAV(); + PL_comppad_name = newAV(); for (ix = fname; ix >= 0; ix--) - av_store(comppad_name, ix, SvREFCNT_inc(pname[ix])); + av_store(PL_comppad_name, ix, SvREFCNT_inc(pname[ix])); - comppad = newAV(); + PL_comppad = newAV(); comppadlist = newAV(); AvREAL_off(comppadlist); - av_store(comppadlist, 0, (SV*)comppad_name); - av_store(comppadlist, 1, (SV*)comppad); + av_store(comppadlist, 0, (SV*)PL_comppad_name); + av_store(comppadlist, 1, (SV*)PL_comppad); CvPADLIST(cv) = comppadlist; - av_fill(comppad, AvFILLp(protopad)); - curpad = AvARRAY(comppad); + av_fill(PL_comppad, AvFILLp(protopad)); + PL_curpad = AvARRAY(PL_comppad); av = newAV(); /* will be @_ */ av_extend(av, 0); - av_store(comppad, 0, (SV*)av); + av_store(PL_comppad, 0, (SV*)av); AvFLAGS(av) = AVf_REIFY; for (ix = fpad; ix > 0; ix--) { SV* namesv = (ix <= fname) ? pname[ix] : Nullsv; - if (namesv && namesv != &sv_undef) { + if (namesv && namesv != &PL_sv_undef) { char *name = SvPVX(namesv); /* XXX */ if (SvFLAGS(namesv) & SVf_FAKE) { /* lexical from outside? */ I32 off = pad_findlex(name, ix, SvIVX(namesv), - CvOUTSIDE(cv), cxstack_ix); + CvOUTSIDE(cv), cxstack_ix, 0, 0); if (!off) - curpad[ix] = SvREFCNT_inc(ppad[ix]); + PL_curpad[ix] = SvREFCNT_inc(ppad[ix]); else if (off != ix) croak("panic: cv_clone: %s", name); } @@ -3327,13 +3772,13 @@ cv_clone2(CV *proto, CV *outside) sv = NEWSV(0,0); if (!SvPADBUSY(sv)) SvPADMY_on(sv); - curpad[ix] = sv; + PL_curpad[ix] = sv; } } else { SV* sv = NEWSV(0,0); SvPADTMP_on(sv); - curpad[ix] = sv; + PL_curpad[ix] = sv; } } @@ -3342,7 +3787,7 @@ cv_clone2(CV *proto, CV *outside) for (ix = fpad; ix > 0; ix--) { SV* namesv = (ix <= fname) ? pname[ix] : Nullsv; if (namesv - && namesv != &sv_undef + && namesv != &PL_sv_undef && !(SvFLAGS(namesv) & SVf_FAKE) && *SvPVX(namesv) == '&' && CvCLONE(ppad[ix])) @@ -3351,7 +3796,7 @@ cv_clone2(CV *proto, CV *outside) SvREFCNT_dec(ppad[ix]); CvCLONE_on(kid); SvPADMY_on(kid); - curpad[ix] = (SV*)kid; + PL_curpad[ix] = (SV*)kid; } } @@ -3371,7 +3816,11 @@ cv_clone2(CV *proto, CV *outside) CV * cv_clone(CV *proto) { - return cv_clone2(proto, CvOUTSIDE(proto)); + CV *cv; + MUTEX_LOCK(&PL_cred_mutex); /* XXX create separate mutex */ + cv = cv_clone2(proto, CvOUTSIDE(proto)); + MUTEX_UNLOCK(&PL_cred_mutex); /* XXX create separate mutex */ + return cv; } void @@ -3447,10 +3896,11 @@ CV * newSUB(I32 floor, OP *o, OP *proto, OP *block) { dTHR; - char *name = o ? SvPVx(cSVOPo->op_sv, na) : Nullch; + STRLEN n_a; + char *name = o ? SvPVx(cSVOPo->op_sv, n_a) : Nullch; GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI | (block ? 0 : GV_NOINIT), SVt_PVCV); - char *ps = proto ? SvPVx(((SVOP*)proto)->op_sv, na) : Nullch; + char *ps = proto ? SvPVx(((SVOP*)proto)->op_sv, n_a) : Nullch; register CV *cv=0; I32 ix; @@ -3470,9 +3920,9 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) sv_setpv((SV*)gv, ps); else sv_setiv((SV*)gv, -1); - SvREFCNT_dec(compcv); - cv = compcv = NULL; - sub_generation++; + SvREFCNT_dec(PL_compcv); + cv = PL_compcv = NULL; + PL_sub_generation++; goto noblock; } @@ -3486,23 +3936,25 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) bool const_changed = TRUE; if (!block) { /* just a "sub foo;" when &foo is already defined */ - SAVEFREESV(compcv); + SAVEFREESV(PL_compcv); goto done; } /* ahem, death to those who redefine active sort subs */ - if (curstackinfo->si_type == PERLSI_SORT && sortcop == CvSTART(cv)) + if (PL_curstackinfo->si_type == PERLSI_SORT && PL_sortcop == CvSTART(cv)) croak("Can't redefine active sort subroutine %s", name); if(const_sv = cv_const_sv(cv)) const_changed = sv_cmp(const_sv, op_const_sv(block, Nullcv)); - if ((const_sv && const_changed) || dowarn && !(CvGV(cv) && GvSTASH(CvGV(cv)) + if ((const_sv && const_changed) || ckWARN(WARN_REDEFINE) + && !(CvGV(cv) && GvSTASH(CvGV(cv)) && HvNAME(GvSTASH(CvGV(cv))) && strEQ(HvNAME(GvSTASH(CvGV(cv))), "autouse"))) { - line_t oldline = curcop->cop_line; - curcop->cop_line = copline; - warn(const_sv ? "Constant subroutine %s redefined" - : "Subroutine %s redefined", name); - curcop->cop_line = oldline; + line_t oldline = PL_curcop->cop_line; + PL_curcop->cop_line = PL_copline; + warner(WARN_REDEFINE, + const_sv ? "Constant subroutine %s redefined" + : "Subroutine %s redefined", name); + PL_curcop->cop_line = oldline; } SvREFCNT_dec(cv); cv = Nullcv; @@ -3510,37 +3962,38 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) } if (cv) { /* must reuse cv if autoloaded */ cv_undef(cv); - CvFLAGS(cv) = CvFLAGS(compcv); - CvOUTSIDE(cv) = CvOUTSIDE(compcv); - CvOUTSIDE(compcv) = 0; - CvPADLIST(cv) = CvPADLIST(compcv); - CvPADLIST(compcv) = 0; - if (SvREFCNT(compcv) > 1) /* XXX Make closures transit through stub. */ - CvOUTSIDE(compcv) = (CV*)SvREFCNT_inc((SV*)cv); - SvREFCNT_dec(compcv); + CvFLAGS(cv) = CvFLAGS(PL_compcv); + CvOUTSIDE(cv) = CvOUTSIDE(PL_compcv); + CvOUTSIDE(PL_compcv) = 0; + CvPADLIST(cv) = CvPADLIST(PL_compcv); + CvPADLIST(PL_compcv) = 0; + if (SvREFCNT(PL_compcv) > 1) /* XXX Make closures transit through stub. */ + CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc((SV*)cv); + SvREFCNT_dec(PL_compcv); } else { - cv = compcv; + cv = PL_compcv; if (name) { GvCV(gv) = cv; GvCVGEN(gv) = 0; - sub_generation++; + PL_sub_generation++; } } CvGV(cv) = (GV*)SvREFCNT_inc(gv); - CvFILEGV(cv) = curcop->cop_filegv; - CvSTASH(cv) = curstash; + CvFILEGV(cv) = PL_curcop->cop_filegv; + CvSTASH(cv) = PL_curstash; #ifdef USE_THREADS CvOWNER(cv) = 0; - if (!CvMUTEXP(cv)) + if (!CvMUTEXP(cv)) { New(666, CvMUTEXP(cv), 1, perl_mutex); - MUTEX_INIT(CvMUTEXP(cv)); + MUTEX_INIT(CvMUTEXP(cv)); + } #endif /* USE_THREADS */ if (ps) sv_setpv((SV*)cv, ps); - if (error_count) { + if (PL_error_count) { op_free(block); block = Nullop; if (name) { @@ -3549,32 +4002,32 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) if (strEQ(s, "BEGIN")) { char *not_safe = "BEGIN not safe after errors--compilation aborted"; - if (in_eval & 4) + if (PL_in_eval & EVAL_KEEPERR) croak(not_safe); else { /* force display of errors found but not reported */ sv_catpv(ERRSV, not_safe); - croak("%s", SvPVx(ERRSV, na)); + croak("%s", SvPVx(ERRSV, n_a)); } } } } if (!block) { noblock: - copline = NOLINE; + PL_copline = NOLINE; LEAVE_SCOPE(floor); return cv; } - if (AvFILLp(comppad_name) < AvFILLp(comppad)) - av_store(comppad_name, AvFILLp(comppad), Nullsv); + if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad)) + av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv); if (CvCLONE(cv)) { - SV **namep = AvARRAY(comppad_name); - for (ix = AvFILLp(comppad); ix > 0; ix--) { + SV **namep = AvARRAY(PL_comppad_name); + for (ix = AvFILLp(PL_comppad); ix > 0; ix--) { SV *namesv; - if (SvIMMORTAL(curpad[ix])) + if (SvIMMORTAL(PL_curpad[ix])) continue; /* * The only things that a clonable function needs in its @@ -3582,26 +4035,26 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) * The rest are created anew during cloning. */ if (!((namesv = namep[ix]) != Nullsv && - namesv != &sv_undef && + namesv != &PL_sv_undef && (SvFAKE(namesv) || *SvPVX(namesv) == '&'))) { - SvREFCNT_dec(curpad[ix]); - curpad[ix] = Nullsv; + SvREFCNT_dec(PL_curpad[ix]); + PL_curpad[ix] = Nullsv; } } } else { AV *av = newAV(); /* Will be @_ */ av_extend(av, 0); - av_store(comppad, 0, (SV*)av); + av_store(PL_comppad, 0, (SV*)av); AvFLAGS(av) = AVf_REIFY; - for (ix = AvFILLp(comppad); ix > 0; ix--) { - if (SvIMMORTAL(curpad[ix])) + for (ix = AvFILLp(PL_comppad); ix > 0; ix--) { + if (SvIMMORTAL(PL_curpad[ix])) continue; - if (!SvPADMY(curpad[ix])) - SvPADTMP_on(curpad[ix]); + if (!SvPADMY(PL_curpad[ix])) + SvPADTMP_on(PL_curpad[ix]); } } @@ -3613,7 +4066,7 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) if (name) { char *s; - if (PERLDB_SUBLINE && curstash != debstash) { + if (PERLDB_SUBLINE && PL_curstash != PL_debstash) { SV *sv = NEWSV(0,0); SV *tmpstr = sv_newmortal(); GV *db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV); @@ -3621,10 +4074,10 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) HV *hv; sv_setpvf(sv, "%_:%ld-%ld", - GvSV(curcop->cop_filegv), - (long)subline, (long)curcop->cop_line); + GvSV(PL_curcop->cop_filegv), + (long)PL_subline, (long)PL_curcop->cop_line); gv_efullname3(tmpstr, gv, Nullch); - hv_store(GvHV(DBsub), SvPVX(tmpstr), SvCUR(tmpstr), sv, 0); + hv_store(GvHV(PL_DBsub), SvPVX(tmpstr), SvCUR(tmpstr), sv, 0); hv = GvHVn(db_postponed); if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX(tmpstr), SvCUR(tmpstr)) && (cv = GvCV(db_postponed))) { @@ -3641,68 +4094,71 @@ newSUB(I32 floor, OP *o, OP *proto, OP *block) else s = name; if (strEQ(s, "BEGIN")) { - I32 oldscope = scopestack_ix; + I32 oldscope = PL_scopestack_ix; ENTER; - SAVESPTR(compiling.cop_filegv); - SAVEI16(compiling.cop_line); - save_svref(&rs); - sv_setsv(rs, nrs); + SAVESPTR(PL_compiling.cop_filegv); + SAVEI16(PL_compiling.cop_line); + save_svref(&PL_rs); + sv_setsv(PL_rs, PL_nrs); - if (!beginav) - beginav = newAV(); + if (!PL_beginav) + PL_beginav = newAV(); DEBUG_x( dump_sub(gv) ); - av_push(beginav, (SV *)cv); + av_push(PL_beginav, (SV *)cv); GvCV(gv) = 0; - call_list(oldscope, beginav); + call_list(oldscope, PL_beginav); - curcop = &compiling; + PL_curcop = &PL_compiling; + PL_compiling.op_private = PL_hints; LEAVE; } - else if (strEQ(s, "END") && !error_count) { - if (!endav) - endav = newAV(); - av_unshift(endav, 1); - av_store(endav, 0, (SV *)cv); + else if (strEQ(s, "END") && !PL_error_count) { + if (!PL_endav) + PL_endav = newAV(); + av_unshift(PL_endav, 1); + av_store(PL_endav, 0, (SV *)cv); GvCV(gv) = 0; } - else if (strEQ(s, "INIT") && !error_count) { - if (!initav) - initav = newAV(); - av_push(initav, SvREFCNT_inc(cv)); + else if (strEQ(s, "INIT") && !PL_error_count) { + if (!PL_initav) + PL_initav = newAV(); + av_push(PL_initav, SvREFCNT_inc(cv)); + GvCV(gv) = 0; } } done: - copline = NOLINE; + PL_copline = NOLINE; LEAVE_SCOPE(floor); return cv; } +/* XXX unsafe for threads if eval_owner isn't held */ void newCONSTSUB(HV *stash, char *name, SV *sv) { dTHR; - U32 oldhints = hints; - HV *old_cop_stash = curcop->cop_stash; - HV *old_curstash = curstash; - line_t oldline = curcop->cop_line; - curcop->cop_line = copline; + U32 oldhints = PL_hints; + HV *old_cop_stash = PL_curcop->cop_stash; + HV *old_curstash = PL_curstash; + line_t oldline = PL_curcop->cop_line; + PL_curcop->cop_line = PL_copline; - hints &= ~HINT_BLOCK_SCOPE; + PL_hints &= ~HINT_BLOCK_SCOPE; if(stash) - curstash = curcop->cop_stash = stash; + PL_curstash = PL_curcop->cop_stash = stash; newSUB( start_subparse(FALSE, 0), newSVOP(OP_CONST, 0, newSVpv(name,0)), - newSVOP(OP_CONST, 0, &sv_no), /* SvPV(&sv_no) == "" -- GMB */ + newSVOP(OP_CONST, 0, &PL_sv_no), /* SvPV(&PL_sv_no) == "" -- GMB */ newSTATEOP(0, Nullch, newSVOP(OP_CONST, 0, sv)) ); - hints = oldhints; - curcop->cop_stash = old_cop_stash; - curstash = old_curstash; - curcop->cop_line = oldline; + PL_hints = oldhints; + PL_curcop->cop_stash = old_cop_stash; + PL_curstash = old_curstash; + PL_curcop->cop_line = oldline; } CV * @@ -3720,13 +4176,14 @@ newXS(char *name, void (*subaddr) (CV * _CPERLproto), char *filename) } else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) { /* already defined (or promised) */ - if (dowarn && !(CvGV(cv) && GvSTASH(CvGV(cv)) + if (ckWARN(WARN_REDEFINE) && !(CvGV(cv) && GvSTASH(CvGV(cv)) && HvNAME(GvSTASH(CvGV(cv))) && strEQ(HvNAME(GvSTASH(CvGV(cv))), "autouse"))) { - line_t oldline = curcop->cop_line; - curcop->cop_line = copline; - warn("Subroutine %s redefined",name); - curcop->cop_line = oldline; + line_t oldline = PL_curcop->cop_line; + if (PL_copline != NOLINE) + PL_curcop->cop_line = PL_copline; + warner(WARN_REDEFINE, "Subroutine %s redefined",name); + PL_curcop->cop_line = oldline; } SvREFCNT_dec(cv); cv = 0; @@ -3741,7 +4198,7 @@ newXS(char *name, void (*subaddr) (CV * _CPERLproto), char *filename) if (name) { GvCV(gv) = cv; GvCVGEN(gv) = 0; - sub_generation++; + PL_sub_generation++; } } CvGV(cv) = (GV*)SvREFCNT_inc(gv); @@ -3760,22 +4217,23 @@ newXS(char *name, void (*subaddr) (CV * _CPERLproto), char *filename) else s = name; if (strEQ(s, "BEGIN")) { - if (!beginav) - beginav = newAV(); - av_push(beginav, (SV *)cv); + if (!PL_beginav) + PL_beginav = newAV(); + av_push(PL_beginav, (SV *)cv); GvCV(gv) = 0; } else if (strEQ(s, "END")) { - if (!endav) - endav = newAV(); - av_unshift(endav, 1); - av_store(endav, 0, (SV *)cv); + if (!PL_endav) + PL_endav = newAV(); + av_unshift(PL_endav, 1); + av_store(PL_endav, 0, (SV *)cv); GvCV(gv) = 0; } else if (strEQ(s, "INIT")) { - if (!initav) - initav = newAV(); - av_push(initav, (SV *)cv); + if (!PL_initav) + PL_initav = newAV(); + av_push(PL_initav, (SV *)cv); + GvCV(gv) = 0; } } else @@ -3792,31 +4250,32 @@ newFORM(I32 floor, OP *o, OP *block) char *name; GV *gv; I32 ix; + STRLEN n_a; if (o) - name = SvPVx(cSVOPo->op_sv, na); + name = SvPVx(cSVOPo->op_sv, n_a); else name = "STDOUT"; gv = gv_fetchpv(name,TRUE, SVt_PVFM); GvMULTI_on(gv); if (cv = GvFORM(gv)) { - if (dowarn) { - line_t oldline = curcop->cop_line; + if (ckWARN(WARN_REDEFINE)) { + line_t oldline = PL_curcop->cop_line; - curcop->cop_line = copline; - warn("Format %s redefined",name); - curcop->cop_line = oldline; + PL_curcop->cop_line = PL_copline; + warner(WARN_REDEFINE, "Format %s redefined",name); + PL_curcop->cop_line = oldline; } SvREFCNT_dec(cv); } - cv = compcv; + cv = PL_compcv; GvFORM(gv) = cv; CvGV(cv) = (GV*)SvREFCNT_inc(gv); - CvFILEGV(cv) = curcop->cop_filegv; + CvFILEGV(cv) = PL_curcop->cop_filegv; - for (ix = AvFILLp(comppad); ix > 0; ix--) { - if (!SvPADMY(curpad[ix]) && !SvIMMORTAL(curpad[ix])) - SvPADTMP_on(curpad[ix]); + for (ix = AvFILLp(PL_comppad); ix > 0; ix--) { + if (!SvPADMY(PL_curpad[ix]) && !SvIMMORTAL(PL_curpad[ix])) + SvPADTMP_on(PL_curpad[ix]); } CvROOT(cv) = newUNOP(OP_LEAVEWRITE, 0, scalarseq(block)); @@ -3824,7 +4283,7 @@ newFORM(I32 floor, OP *o, OP *block) CvROOT(cv)->op_next = 0; peep(CvSTART(cv)); op_free(o); - copline = NOLINE; + PL_copline = NOLINE; LEAVE_SCOPE(floor); } @@ -3855,12 +4314,12 @@ oopsAV(OP *o) switch (o->op_type) { case OP_PADSV: o->op_type = OP_PADAV; - o->op_ppaddr = ppaddr[OP_PADAV]; - return ref(newUNOP(OP_RV2AV, 0, scalar(o)), OP_RV2AV); + o->op_ppaddr = PL_ppaddr[OP_PADAV]; + return ref(o, OP_RV2AV); case OP_RV2SV: o->op_type = OP_RV2AV; - o->op_ppaddr = ppaddr[OP_RV2AV]; + o->op_ppaddr = PL_ppaddr[OP_RV2AV]; ref(o, OP_RV2AV); break; @@ -3878,13 +4337,13 @@ oopsHV(OP *o) case OP_PADSV: case OP_PADAV: o->op_type = OP_PADHV; - o->op_ppaddr = ppaddr[OP_PADHV]; - return ref(newUNOP(OP_RV2HV, 0, scalar(o)), OP_RV2HV); + o->op_ppaddr = PL_ppaddr[OP_PADHV]; + return ref(o, OP_RV2HV); case OP_RV2SV: case OP_RV2AV: o->op_type = OP_RV2HV; - o->op_ppaddr = ppaddr[OP_RV2HV]; + o->op_ppaddr = PL_ppaddr[OP_RV2HV]; ref(o, OP_RV2HV); break; @@ -3900,7 +4359,7 @@ newAVREF(OP *o) { if (o->op_type == OP_PADANY) { o->op_type = OP_PADAV; - o->op_ppaddr = ppaddr[OP_PADAV]; + o->op_ppaddr = PL_ppaddr[OP_PADAV]; return o; } return newUNOP(OP_RV2AV, 0, scalar(o)); @@ -3909,7 +4368,7 @@ newAVREF(OP *o) OP * newGVREF(I32 type, OP *o) { - if (type == OP_MAPSTART) + if (type == OP_MAPSTART || type == OP_GREPSTART || type == OP_SORT) return newUNOP(OP_NULL, 0, o); return ref(newUNOP(OP_RV2GV, OPf_REF, o), type); } @@ -3919,7 +4378,7 @@ newHVREF(OP *o) { if (o->op_type == OP_PADANY) { o->op_type = OP_PADHV; - o->op_ppaddr = ppaddr[OP_PADHV]; + o->op_ppaddr = PL_ppaddr[OP_PADHV]; return o; } return newUNOP(OP_RV2HV, 0, scalar(o)); @@ -3944,7 +4403,7 @@ newSVREF(OP *o) { if (o->op_type == OP_PADANY) { o->op_type = OP_PADSV; - o->op_ppaddr = ppaddr[OP_PADSV]; + o->op_ppaddr = PL_ppaddr[OP_PADSV]; return o; } else if (o->op_type == OP_THREADSV && !(o->op_flags & OPpDONE_SVREF)) { @@ -3968,8 +4427,8 @@ ck_anoncode(OP *o) SvIVX(name) = -1; SvNVX(name) = 1; ix = pad_alloc(o->op_type, SVs_PADMY); - av_store(comppad_name, ix, name); - av_store(comppad, ix, cSVOPo->op_sv); + av_store(PL_comppad_name, ix, name); + av_store(PL_comppad, ix, cSVOPo->op_sv); SvPADMY_on(cSVOPo->op_sv); cSVOPo->op_sv = Nullsv; cSVOPo->op_targ = ix; @@ -3979,7 +4438,7 @@ ck_anoncode(OP *o) OP * ck_bitop(OP *o) { - o->op_private = hints; + o->op_private = PL_hints; return o; } @@ -4003,7 +4462,7 @@ ck_spair(OP *o) newop = kUNOP->op_first->op_sibling; if (newop && (newop->op_sibling || - !(opargs[newop->op_type] & OA_RETSCALAR) || + !(PL_opargs[newop->op_type] & OA_RETSCALAR) || newop->op_type == OP_PADAV || newop->op_type == OP_PADHV || newop->op_type == OP_RV2AV || newop->op_type == OP_RV2HV)) { @@ -4012,7 +4471,7 @@ ck_spair(OP *o) op_free(kUNOP->op_first); kUNOP->op_first = newop; } - o->op_ppaddr = ppaddr[++o->op_type]; + o->op_ppaddr = PL_ppaddr[++o->op_type]; return ck_fun(o); } @@ -4027,7 +4486,7 @@ ck_delete(OP *o) o->op_private |= OPpSLICE; else if (kid->op_type != OP_HELEM) croak("%s argument is not a HASH element or slice", - op_desc[o->op_type]); + PL_op_desc[o->op_type]); null(kid); } return o; @@ -4052,7 +4511,7 @@ ck_eof(OP *o) OP * ck_eval(OP *o) { - hints |= HINT_BLOCK_SCOPE; + PL_hints |= HINT_BLOCK_SCOPE; if (o->op_flags & OPf_KIDS) { SVOP *kid = (SVOP*)cUNOPo->op_first; @@ -4067,9 +4526,9 @@ ck_eval(OP *o) cUNOPo->op_first = 0; op_free(o); - Newz(1101, enter, 1, LOGOP); + NewOp(1101, enter, 1, LOGOP); enter->op_type = OP_ENTERTRY; - enter->op_ppaddr = ppaddr[OP_ENTERTRY]; + enter->op_ppaddr = PL_ppaddr[OP_ENTERTRY]; enter->op_private = 0; /* establish postfix order */ @@ -4077,7 +4536,7 @@ ck_eval(OP *o) o = prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid); o->op_type = OP_LEAVETRY; - o->op_ppaddr = ppaddr[OP_LEAVETRY]; + o->op_ppaddr = PL_ppaddr[OP_LEAVETRY]; enter->op_other = o; return o; } @@ -4088,7 +4547,7 @@ ck_eval(OP *o) op_free(o); o = newUNOP(OP_ENTEREVAL, 0, newDEFSVOP()); } - o->op_targ = (PADOFFSET)hints; + o->op_targ = (PADOFFSET)PL_hints; return o; } @@ -4114,12 +4573,13 @@ ck_exists(OP *o) if (o->op_flags & OPf_KIDS) { OP *kid = cUNOPo->op_first; if (kid->op_type != OP_HELEM) - croak("%s argument is not a HASH element", op_desc[o->op_type]); + croak("%s argument is not a HASH element", PL_op_desc[o->op_type]); null(kid); } return o; } +#if 0 OP * ck_gvconst(register OP *o) { @@ -4128,6 +4588,7 @@ ck_gvconst(register OP *o) o->op_type = OP_GV; return o; } +#endif OP * ck_rvconst(register OP *o) @@ -4135,14 +4596,53 @@ ck_rvconst(register OP *o) dTHR; SVOP *kid = (SVOP*)cUNOPo->op_first; - o->op_private |= (hints & HINT_STRICT_REFS); + o->op_private |= (PL_hints & HINT_STRICT_REFS); if (kid->op_type == OP_CONST) { char *name; int iscv; GV *gv; + SV *kidsv = kid->op_sv; + STRLEN n_a; + + /* Is it a constant from cv_const_sv()? */ + if (SvROK(kidsv) && SvREADONLY(kidsv)) { + SV *rsv = SvRV(kidsv); + int svtype = SvTYPE(rsv); + char *badtype = Nullch; - name = SvPV(kid->op_sv, na); - if ((hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) { + switch (o->op_type) { + case OP_RV2SV: + if (svtype > SVt_PVMG) + badtype = "a SCALAR"; + break; + case OP_RV2AV: + if (svtype != SVt_PVAV) + badtype = "an ARRAY"; + break; + case OP_RV2HV: + if (svtype != SVt_PVHV) { + if (svtype == SVt_PVAV) { /* pseudohash? */ + SV **ksv = av_fetch((AV*)rsv, 0, FALSE); + if (ksv && SvROK(*ksv) + && SvTYPE(SvRV(*ksv)) == SVt_PVHV) + { + break; + } + } + badtype = "a HASH"; + } + break; + case OP_RV2CV: + if (svtype != SVt_PVCV) + badtype = "a CODE"; + break; + } + if (badtype) + croak("Constant is not %s reference", badtype); + return o; + } + name = SvPV(kidsv, n_a); + if ((PL_hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) { char *badthing = Nullch; switch (o->op_type) { case OP_RV2SV: @@ -4204,8 +4704,9 @@ ck_ftst(OP *o) SVOP *kid = (SVOP*)cUNOPo->op_first; if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) { + STRLEN n_a; OP *newop = newGVOP(type, OPf_REF, - gv_fetchpv(SvPVx(kid->op_sv, na), TRUE, SVt_PVIO)); + gv_fetchpv(SvPVx(kid->op_sv, n_a), TRUE, SVt_PVIO)); op_free(o); return newop; } @@ -4230,7 +4731,7 @@ ck_fun(OP *o) OP *sibl; I32 numargs = 0; int type = o->op_type; - register I32 oa = opargs[type] >> OASHIFT; + register I32 oa = PL_opargs[type] >> OASHIFT; if (o->op_flags & OPf_STACKED) { if ((oa & OA_OPTIONAL) && (oa >> 4) && !((oa >> 4) & OA_OPTIONAL)) @@ -4240,6 +4741,7 @@ ck_fun(OP *o) } if (o->op_flags & OPf_KIDS) { + STRLEN n_a; tokid = &cLISTOPo->op_first; kid = cLISTOPo->op_first; if (kid->op_type == OP_PUSHMARK || @@ -4248,7 +4750,7 @@ ck_fun(OP *o) tokid = &kid->op_sibling; kid = kid->op_sibling; } - if (!kid && opargs[type] & OA_DEFGV) + if (!kid && PL_opargs[type] & OA_DEFGV) *tokid = kid = newDEFSVOP(); while (oa && kid) { @@ -4256,6 +4758,12 @@ ck_fun(OP *o) sibl = kid->op_sibling; switch (oa & 7) { case OA_SCALAR: + /* list seen where single (scalar) arg expected? */ + if (numargs == 1 && !(oa >> 4) + && kid->op_type == OP_LIST && type != OP_SCALAR) + { + return too_many_arguments(o,PL_op_desc[type]); + } scalar(kid); break; case OA_LIST: @@ -4268,38 +4776,42 @@ ck_fun(OP *o) break; case OA_AVREF: if (kid->op_type == OP_CONST && - (kid->op_private & OPpCONST_BARE)) { - char *name = SvPVx(((SVOP*)kid)->op_sv, na); + (kid->op_private & OPpCONST_BARE)) + { + char *name = SvPVx(((SVOP*)kid)->op_sv, n_a); OP *newop = newAVREF(newGVOP(OP_GV, 0, gv_fetchpv(name, TRUE, SVt_PVAV) )); - if (dowarn) - warn("Array @%s missing the @ in argument %ld of %s()", - name, (long)numargs, op_desc[type]); + if (ckWARN(WARN_SYNTAX)) + warner(WARN_SYNTAX, + "Array @%s missing the @ in argument %ld of %s()", + name, (long)numargs, PL_op_desc[type]); op_free(kid); kid = newop; kid->op_sibling = sibl; *tokid = kid; } else if (kid->op_type != OP_RV2AV && kid->op_type != OP_PADAV) - bad_type(numargs, "array", op_desc[o->op_type], kid); + bad_type(numargs, "array", PL_op_desc[type], kid); mod(kid, type); break; case OA_HVREF: if (kid->op_type == OP_CONST && - (kid->op_private & OPpCONST_BARE)) { - char *name = SvPVx(((SVOP*)kid)->op_sv, na); + (kid->op_private & OPpCONST_BARE)) + { + char *name = SvPVx(((SVOP*)kid)->op_sv, n_a); OP *newop = newHVREF(newGVOP(OP_GV, 0, gv_fetchpv(name, TRUE, SVt_PVHV) )); - if (dowarn) - warn("Hash %%%s missing the %% in argument %ld of %s()", - name, (long)numargs, op_desc[type]); + if (ckWARN(WARN_SYNTAX)) + warner(WARN_SYNTAX, + "Hash %%%s missing the %% in argument %ld of %s()", + name, (long)numargs, PL_op_desc[type]); op_free(kid); kid = newop; kid->op_sibling = sibl; *tokid = kid; } else if (kid->op_type != OP_RV2HV && kid->op_type != OP_PADHV) - bad_type(numargs, "hash", op_desc[o->op_type], kid); + bad_type(numargs, "hash", PL_op_desc[type], kid); mod(kid, type); break; case OA_CVREF: @@ -4314,18 +4826,43 @@ ck_fun(OP *o) } break; case OA_FILEREF: - if (kid->op_type != OP_GV) { + if (kid->op_type != OP_GV && kid->op_type != OP_RV2GV) { if (kid->op_type == OP_CONST && - (kid->op_private & OPpCONST_BARE)) { + (kid->op_private & OPpCONST_BARE)) + { OP *newop = newGVOP(OP_GV, 0, - gv_fetchpv(SvPVx(((SVOP*)kid)->op_sv, na), TRUE, + gv_fetchpv(SvPVx(((SVOP*)kid)->op_sv, n_a), TRUE, SVt_PVIO) ); op_free(kid); kid = newop; } + else if (kid->op_type == OP_READLINE) { + /* neophyte patrol: open(), close() etc. */ + bad_type(numargs, "HANDLE", PL_op_desc[o->op_type], kid); + } else { + I32 flags = OPf_SPECIAL; + I32 priv = 0; + /* is this op a FH constructor? */ + if (is_handle_constructor(o,numargs)) { + flags = 0; + /* Set a flag to tell rv2gv to vivify + * need to "prove" flag does not mean something + * else already - NI-S 1999/05/07 + */ + priv = OPpDEREF; +#if 0 + /* Helps with open($array[$n],...) + but is too simplistic - need to do selectively + */ + mod(kid,type); +#endif + } kid->op_sibling = 0; - kid = newUNOP(OP_RV2GV, 0, scalar(kid)); + kid = newUNOP(OP_RV2GV, flags, scalar(kid)); + if (priv) { + kid->op_private |= priv; + } } kid->op_sibling = sibl; *tokid = kid; @@ -4342,10 +4879,10 @@ ck_fun(OP *o) } o->op_private |= numargs; if (kid) - return too_many_arguments(o,op_desc[o->op_type]); + return too_many_arguments(o,PL_op_desc[o->op_type]); listkids(o); } - else if (opargs[type] & OA_DEFGV) { + else if (PL_opargs[type] & OA_DEFGV) { op_free(o); return newUNOP(type, 0, newDEFSVOP()); } @@ -4354,7 +4891,7 @@ ck_fun(OP *o) while (oa & OA_OPTIONAL) oa >>= 4; if (oa && oa != OA_LIST) - return too_few_arguments(o,op_desc[o->op_type]); + return too_few_arguments(o,PL_op_desc[o->op_type]); } return o; } @@ -4371,14 +4908,12 @@ ck_glob(OP *o) gv = gv_fetchpv("CORE::GLOBAL::glob", FALSE, SVt_PVCV); if (gv && GvIMPORTED_CV(gv)) { - static int glob_index; - append_elem(OP_GLOB, o, - newSVOP(OP_CONST, 0, newSViv(glob_index++))); + newSVOP(OP_CONST, 0, newSViv(PL_glob_index++))); o->op_type = OP_LIST; - o->op_ppaddr = ppaddr[OP_LIST]; + o->op_ppaddr = PL_ppaddr[OP_LIST]; cLISTOPo->op_first->op_type = OP_PUSHMARK; - cLISTOPo->op_first->op_ppaddr = ppaddr[OP_PUSHMARK]; + cLISTOPo->op_first->op_ppaddr = PL_ppaddr[OP_PUSHMARK]; o = newUNOP(OP_ENTERSUB, OPf_STACKED, append_elem(OP_LIST, o, scalar(newUNOP(OP_RV2CV, 0, @@ -4401,8 +4936,8 @@ ck_grep(OP *o) OP *kid; OPCODE type = o->op_type == OP_GREPSTART ? OP_GREPWHILE : OP_MAPWHILE; - o->op_ppaddr = ppaddr[OP_GREPSTART]; - Newz(1101, gwop, 1, LOGOP); + o->op_ppaddr = PL_ppaddr[OP_GREPSTART]; + NewOp(1101, gwop, 1, LOGOP); if (o->op_flags & OPf_STACKED) { OP* k; @@ -4420,7 +4955,7 @@ ck_grep(OP *o) else scalar(kid); o = ck_fun(o); - if (error_count) + if (PL_error_count) return o; kid = cLISTOPo->op_first->op_sibling; if (kid->op_type != OP_NULL) @@ -4428,7 +4963,7 @@ ck_grep(OP *o) kid = kUNOP->op_first; gwop->op_type = type; - gwop->op_ppaddr = ppaddr[type]; + gwop->op_ppaddr = PL_ppaddr[type]; gwop->op_first = listkids(o); gwop->op_flags |= OPf_KIDS; gwop->op_private = 1; @@ -4438,7 +4973,7 @@ ck_grep(OP *o) kid = cLISTOPo->op_first->op_sibling; if (!kid || !kid->op_sibling) - return too_few_arguments(o,op_desc[o->op_type]); + return too_few_arguments(o,PL_op_desc[o->op_type]); for (kid = kid->op_sibling; kid; kid = kid->op_sibling) mod(kid, OP_GREPSTART); @@ -4450,6 +4985,8 @@ ck_index(OP *o) { if (o->op_flags & OPf_KIDS) { OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */ + if (kid) + kid = kid->op_sibling; /* get past "big" */ if (kid && kid->op_type == OP_CONST) fbm_compile(((SVOP*)kid)->op_sv, 0); } @@ -4508,7 +5045,7 @@ ck_listiob(OP *o) o->op_private = 0; #ifdef USE_LOCALE - if (hints & HINT_LOCALE) + if (PL_hints & HINT_LOCALE) o->op_private |= OPpLOCALE; #endif @@ -4522,7 +5059,7 @@ ck_fun_locale(OP *o) o->op_private = 0; #ifdef USE_LOCALE - if (hints & HINT_LOCALE) + if (PL_hints & HINT_LOCALE) o->op_private |= OPpLOCALE; #endif @@ -4534,7 +5071,7 @@ ck_scmp(OP *o) { o->op_private = 0; #ifdef USE_LOCALE - if (hints & HINT_LOCALE) + if (PL_hints & HINT_LOCALE) o->op_private |= OPpLOCALE; #endif @@ -4587,6 +5124,7 @@ ck_require(OP *o) return ck_fun(o); } +#if 0 OP * ck_retarget(OP *o) { @@ -4594,6 +5132,7 @@ ck_retarget(OP *o) /* STUB */ return o; } +#endif OP * ck_select(OP *o) @@ -4603,7 +5142,7 @@ ck_select(OP *o) kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */ if (kid && kid->op_sibling) { o->op_type = OP_SSELECT; - o->op_ppaddr = ppaddr[OP_SSELECT]; + o->op_ppaddr = PL_ppaddr[OP_SSELECT]; o = ck_fun(o); return fold_constants(o); } @@ -4625,9 +5164,9 @@ ck_shift(OP *o) op_free(o); #ifdef USE_THREADS - if (!CvUNIQUE(compcv)) { + if (!CvUNIQUE(PL_compcv)) { argop = newOP(OP_PADAV, OPf_REF); - argop->op_targ = 0; /* curpad[0] is @_ */ + argop->op_targ = 0; /* PL_curpad[0] is @_ */ } else { argop = newUNOP(OP_RV2AV, 0, @@ -4636,8 +5175,8 @@ ck_shift(OP *o) } #else argop = newUNOP(OP_RV2AV, 0, - scalar(newGVOP(OP_GV, 0, !CvUNIQUE(compcv) ? - defgv : gv_fetchpv("ARGV", TRUE, SVt_PVAV)))); + scalar(newGVOP(OP_GV, 0, !CvUNIQUE(PL_compcv) ? + PL_defgv : gv_fetchpv("ARGV", TRUE, SVt_PVAV)))); #endif /* USE_THREADS */ return newUNOP(type, 0, scalar(argop)); } @@ -4649,14 +5188,16 @@ ck_sort(OP *o) { o->op_private = 0; #ifdef USE_LOCALE - if (hints & HINT_LOCALE) + if (PL_hints & HINT_LOCALE) o->op_private |= OPpLOCALE; #endif - if (o->op_flags & OPf_STACKED) { + if (o->op_type == OP_SORT && o->op_flags & OPf_STACKED) + simplify_sort(o); + if (o->op_flags & OPf_STACKED) { /* may have been cleared */ OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */ OP *k; - kid = kUNOP->op_first; /* get past rv2gv */ + kid = kUNOP->op_first; /* get past null */ if (kid->op_type == OP_SCOPE || kid->op_type == OP_LEAVE) { linklist(kid); @@ -4681,18 +5222,81 @@ ck_sort(OP *o) peep(k); kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */ - null(kid); /* wipe out rv2gv */ if (o->op_type == OP_SORT) kid->op_next = kid; else kid->op_next = k; o->op_flags |= OPf_SPECIAL; } + else if (kid->op_type == OP_RV2SV || kid->op_type == OP_PADSV) + null(cLISTOPo->op_first->op_sibling); } return o; } +STATIC void +simplify_sort(OP *o) +{ + dTHR; + register OP *kid = cLISTOPo->op_first->op_sibling; /* get past pushmark */ + OP *k; + int reversed; + if (!(o->op_flags & OPf_STACKED)) + return; + GvMULTI_on(gv_fetchpv("a", TRUE, SVt_PV)); + GvMULTI_on(gv_fetchpv("b", TRUE, SVt_PV)); + kid = kUNOP->op_first; /* get past null */ + if (kid->op_type != OP_SCOPE) + return; + kid = kLISTOP->op_last; /* get past scope */ + switch(kid->op_type) { + case OP_NCMP: + case OP_I_NCMP: + case OP_SCMP: + break; + default: + return; + } + k = kid; /* remember this node*/ + if (kBINOP->op_first->op_type != OP_RV2SV) + return; + kid = kBINOP->op_first; /* get past cmp */ + if (kUNOP->op_first->op_type != OP_GV) + return; + kid = kUNOP->op_first; /* get past rv2sv */ + if (GvSTASH(kGVOP->op_gv) != PL_curstash) + return; + if (strEQ(GvNAME(kGVOP->op_gv), "a")) + reversed = 0; + else if(strEQ(GvNAME(kGVOP->op_gv), "b")) + reversed = 1; + else + return; + kid = k; /* back to cmp */ + if (kBINOP->op_last->op_type != OP_RV2SV) + return; + kid = kBINOP->op_last; /* down to 2nd arg */ + if (kUNOP->op_first->op_type != OP_GV) + return; + kid = kUNOP->op_first; /* get past rv2sv */ + if (GvSTASH(kGVOP->op_gv) != PL_curstash + || ( reversed + ? strNE(GvNAME(kGVOP->op_gv), "a") + : strNE(GvNAME(kGVOP->op_gv), "b"))) + return; + o->op_flags &= ~(OPf_STACKED | OPf_SPECIAL); + if (reversed) + o->op_private |= OPpSORT_REVERSE; + if (k->op_type == OP_NCMP) + o->op_private |= OPpSORT_NUMERIC; + if (k->op_type == OP_I_NCMP) + o->op_private |= OPpSORT_NUMERIC | OPpSORT_INTEGER; + op_free(cLISTOPo->op_first->op_sibling); /* delete comparison block */ + cLISTOPo->op_first->op_sibling = cLISTOPo->op_last; + cLISTOPo->op_children = 1; +} + OP * ck_split(OP *o) { @@ -4708,7 +5312,7 @@ ck_split(OP *o) op_free(cLISTOPo->op_first); cLISTOPo->op_first = kid; if (!kid) { - cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpv(" ", 1)); + cLISTOPo->op_first = kid = newSVOP(OP_CONST, 0, newSVpvn(" ", 1)); cLISTOPo->op_last = kid; /* There was only one element previously */ } @@ -4723,7 +5327,7 @@ ck_split(OP *o) } kid->op_type = OP_PUSHRE; - kid->op_ppaddr = ppaddr[OP_PUSHRE]; + kid->op_ppaddr = PL_ppaddr[OP_PUSHRE]; scalar(kid); if (!kid->op_sibling) @@ -4739,7 +5343,7 @@ ck_split(OP *o) scalar(kid); if (kid->op_sibling) - return too_many_arguments(o,op_desc[o->op_type]); + return too_many_arguments(o,PL_op_desc[o->op_type]); return o; } @@ -4757,6 +5361,7 @@ ck_subr(OP *o) GV *namegv = 0; int optional = 0; I32 arg = 0; + STRLEN n_a; for (cvop = o2; cvop->op_sibling; cvop = cvop->op_sibling) ; if (cvop->op_type == OP_RV2CV) { @@ -4768,12 +5373,21 @@ ck_subr(OP *o) cv = GvCVu(tmpop->op_sv); if (cv && SvPOK(cv) && !(o->op_private & OPpENTERSUB_AMPER)) { namegv = CvANON(cv) ? (GV*)tmpop->op_sv : CvGV(cv); - proto = SvPV((SV*)cv, na); + proto = SvPV((SV*)cv, n_a); } } } - o->op_private |= (hints & HINT_STRICT_REFS); - if (PERLDB_SUB && curstash != debstash) + else if (cvop->op_type == OP_METHOD) { + if (o2->op_type == OP_CONST) + o2->op_private &= ~OPpCONST_STRICT; + else if (o2->op_type == OP_LIST) { + OP *o = ((UNOP*)o2)->op_first->op_sibling; + if (o && o->op_type == OP_CONST) + o->op_private &= ~OPpCONST_STRICT; + } + } + o->op_private |= (PL_hints & HINT_STRICT_REFS); + if (PERLDB_SUB && PL_curstash != PL_debstash) o->op_private |= OPpENTERSUB_DB; while (o2 != cvop) { if (proto) { @@ -4801,19 +5415,42 @@ ck_subr(OP *o) bad_type(arg, "block", gv_ename(namegv), o2); break; case '*': + /* '*' allows any scalar type, including bareword */ proto++; arg++; if (o2->op_type == OP_RV2GV) - goto wrapref; - { - OP* kid = o2; - OP* sib = kid->op_sibling; - kid->op_sibling = 0; - o2 = newUNOP(OP_RV2GV, 0, kid); - o2->op_sibling = sib; - prev->op_sibling = o2; + goto wrapref; /* autoconvert GLOB -> GLOBref */ + else if (o2->op_type == OP_CONST) + o2->op_private &= ~OPpCONST_STRICT; + else if (o2->op_type == OP_ENTERSUB) { + /* accidental subroutine, revert to bareword */ + OP *gvop = ((UNOP*)o2)->op_first; + if (gvop && gvop->op_type == OP_NULL) { + gvop = ((UNOP*)gvop)->op_first; + if (gvop) { + for (; gvop->op_sibling; gvop = gvop->op_sibling) + ; + if (gvop && + (gvop->op_private & OPpENTERSUB_NOPAREN) && + (gvop = ((UNOP*)gvop)->op_first) && + gvop->op_type == OP_GV) + { + GV *gv = (GV*)((SVOP*)gvop)->op_sv; + OP *sibling = o2->op_sibling; + SV *n = newSVpvn("",0); + op_free(o2); + gv_fullname3(n, gv, ""); + if (SvCUR(n)>6 && strnEQ(SvPVX(n),"main::",6)) + sv_chop(n, SvPVX(n)+6); + o2 = newSVOP(OP_CONST, 0, n); + prev->op_sibling = o2; + o2->op_sibling = sibling; + } + } + } } - goto wrapref; + scalar(o2); + break; case '\\': proto++; arg++; @@ -4827,8 +5464,12 @@ ck_subr(OP *o) bad_type(arg, "sub", gv_ename(namegv), o2); goto wrapref; case '$': - if (o2->op_type != OP_RV2SV && o2->op_type != OP_PADSV) + if (o2->op_type != OP_RV2SV + && o2->op_type != OP_PADSV + && o2->op_type != OP_THREADSV) + { bad_type(arg, "scalar", gv_ename(namegv), o2); + } goto wrapref; case '@': if (o2->op_type != OP_RV2AV && o2->op_type != OP_PADAV) @@ -4856,7 +5497,7 @@ ck_subr(OP *o) default: oops: croak("Malformed prototype for %s: %s", - gv_ename(namegv), SvPV((SV*)cv, na)); + gv_ename(namegv), SvPV((SV*)cv, n_a)); } } else @@ -4900,26 +5541,31 @@ peep(register OP *o) { dTHR; register OP* oldop = 0; + STRLEN n_a; + if (!o || o->op_seq) return; ENTER; SAVEOP(); - SAVESPTR(curcop); + SAVESPTR(PL_curcop); for (; o; o = o->op_next) { if (o->op_seq) break; - if (!op_seqmax) - op_seqmax++; - op = o; + if (!PL_op_seqmax) + PL_op_seqmax++; + PL_op = o; switch (o->op_type) { case OP_NEXTSTATE: case OP_DBSTATE: - curcop = ((COP*)o); /* for warnings */ - o->op_seq = op_seqmax++; + PL_curcop = ((COP*)o); /* for warnings */ + o->op_seq = PL_op_seqmax++; break; - case OP_CONCAT: case OP_CONST: + if (cSVOPo->op_private & OPpCONST_STRICT) + no_bareword_allowed(o); + /* FALL THROUGH */ + case OP_CONCAT: case OP_JOIN: case OP_UC: case OP_UCFIRST: @@ -4928,17 +5574,17 @@ peep(register OP *o) case OP_QUOTEMETA: if (o->op_next && o->op_next->op_type == OP_STRINGIFY) null(o->op_next); - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; break; case OP_STUB: if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) { - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; break; /* Scalar stub must produce undef. List stub is noop */ } goto nothin; case OP_NULL: if (o->op_targ == OP_NEXTSTATE || o->op_targ == OP_DBSTATE) - curcop = ((COP*)o); + PL_curcop = ((COP*)o); goto nothin; case OP_SCALAR: case OP_LINESEQ: @@ -4948,7 +5594,7 @@ peep(register OP *o) oldop->op_next = o->op_next; continue; } - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; break; case OP_GV: @@ -4958,18 +5604,18 @@ peep(register OP *o) o->op_private |= o->op_next->op_private & OPpLVAL_INTRO; o->op_next = o->op_next->op_next; o->op_type = OP_GVSV; - o->op_ppaddr = ppaddr[OP_GVSV]; + o->op_ppaddr = PL_ppaddr[OP_GVSV]; } } else if (o->op_next->op_type == OP_RV2AV) { OP* pop = o->op_next->op_next; IV i; if (pop->op_type == OP_CONST && - (op = pop->op_next) && + (PL_op = pop->op_next) && pop->op_next->op_type == OP_AELEM && !(pop->op_next->op_private & (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) && - (i = SvIV(((SVOP*)pop)->op_sv) - compiling.cop_arybase) + (i = SvIV(((SVOP*)pop)->op_sv) - PL_compiling.cop_arybase) <= 255 && i >= 0) { @@ -4980,50 +5626,32 @@ peep(register OP *o) o->op_flags |= pop->op_next->op_flags & OPf_MOD; o->op_next = pop->op_next->op_next; o->op_type = OP_AELEMFAST; - o->op_ppaddr = ppaddr[OP_AELEMFAST]; + o->op_ppaddr = PL_ppaddr[OP_AELEMFAST]; o->op_private = (U8)i; GvAVn(((GVOP*)o)->op_gv); } } - o->op_seq = op_seqmax++; - break; - - case OP_PADAV: - if (o->op_next->op_type == OP_RV2AV - && (o->op_next->op_flags & OPf_REF)) - { - null(o->op_next); - o->op_next = o->op_next->op_next; - } - break; - - case OP_PADHV: - if (o->op_next->op_type == OP_RV2HV - && (o->op_next->op_flags & OPf_REF)) - { - null(o->op_next); - o->op_next = o->op_next->op_next; - } + o->op_seq = PL_op_seqmax++; break; case OP_MAPWHILE: case OP_GREPWHILE: case OP_AND: case OP_OR: - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; while (cLOGOP->op_other->op_type == OP_NULL) cLOGOP->op_other = cLOGOP->op_other->op_next; peep(cLOGOP->op_other); break; case OP_COND_EXPR: - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; peep(cCONDOP->op_true); peep(cCONDOP->op_false); break; case OP_ENTERLOOP: - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; peep(cLOOP->op_redoop); peep(cLOOP->op_nextop); peep(cLOOP->op_lastop); @@ -5032,23 +5660,24 @@ peep(register OP *o) case OP_QR: case OP_MATCH: case OP_SUBST: - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; peep(cPMOP->op_pmreplstart); break; case OP_EXEC: - o->op_seq = op_seqmax++; - if (dowarn && o->op_next && o->op_next->op_type == OP_NEXTSTATE) { + o->op_seq = PL_op_seqmax++; + if (ckWARN(WARN_SYNTAX) && o->op_next + && o->op_next->op_type == OP_NEXTSTATE) { if (o->op_next->op_sibling && o->op_next->op_sibling->op_type != OP_EXIT && o->op_next->op_sibling->op_type != OP_WARN && o->op_next->op_sibling->op_type != OP_DIE) { - line_t oldline = curcop->cop_line; + line_t oldline = PL_curcop->cop_line; - curcop->cop_line = ((COP*)o->op_next)->cop_line; - warn("Statement unlikely to be reached"); - warn("(Maybe you meant system() when you said exec()?)\n"); - curcop->cop_line = oldline; + PL_curcop->cop_line = ((COP*)o->op_next)->cop_line; + warner(WARN_SYNTAX, "Statement unlikely to be reached"); + warner(WARN_SYNTAX, "(Maybe you meant system() when you said exec()?)\n"); + PL_curcop->cop_line = oldline; } } break; @@ -5062,13 +5691,13 @@ peep(register OP *o) char *key; STRLEN keylen; - if (o->op_private & (OPpDEREF_HV|OPpDEREF_AV|OPpLVAL_INTRO) + if ((o->op_private & (OPpLVAL_INTRO)) || ((BINOP*)o)->op_last->op_type != OP_CONST) break; rop = (UNOP*)((BINOP*)o)->op_first; if (rop->op_type != OP_RV2HV || rop->op_first->op_type != OP_PADSV) break; - lexname = *av_fetch(comppad_name, rop->op_first->op_targ, TRUE); + lexname = *av_fetch(PL_comppad_name, rop->op_first->op_targ, TRUE); if (!SvOBJECT(lexname)) break; fields = (GV**)hv_fetch(SvSTASH(lexname), "FIELDS", 6, FALSE); @@ -5079,22 +5708,22 @@ peep(register OP *o) indsvp = hv_fetch(GvHV(*fields), key, keylen, FALSE); if (!indsvp) { croak("No such field \"%s\" in variable %s of type %s", - key, SvPV(lexname, na), HvNAME(SvSTASH(lexname))); + key, SvPV(lexname, n_a), HvNAME(SvSTASH(lexname))); } ind = SvIV(*indsvp); if (ind < 1) croak("Bad index while coercing array into hash"); rop->op_type = OP_RV2AV; - rop->op_ppaddr = ppaddr[OP_RV2AV]; + rop->op_ppaddr = PL_ppaddr[OP_RV2AV]; o->op_type = OP_AELEM; - o->op_ppaddr = ppaddr[OP_AELEM]; + o->op_ppaddr = PL_ppaddr[OP_AELEM]; SvREFCNT_dec(*svp); *svp = newSViv(ind); break; } default: - o->op_seq = op_seqmax++; + o->op_seq = PL_op_seqmax++; break; } oldop = o;