X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=mg.c;h=2906a4c17311952e4b1fbda317ec60cca767a8df;hb=606932feba6a7c07d368ce4e766975b0fe622bfc;hp=902a8534a27776c23ba4718247c8f63c537be20d;hpb=ba3eb2af450c2577c20a691fb686a5e02955c48b;p=p5sagit%2Fp5-mst-13.2.git diff --git a/mg.c b/mg.c index 902a853..2906a4c 100644 --- a/mg.c +++ b/mg.c @@ -26,34 +26,38 @@ # endif #endif +#ifdef PERL_OBJECT +# define VTBL this->*vtbl +#else +# define VTBL *vtbl +static void restore_magic _((void *p)); +static int magic_methcall(SV *sv, MAGIC *mg, char *meth, I32 f, int n, SV *val); +#endif + /* * Use the "DESTRUCTOR" scope cleanup to reinstate magic. */ -#ifdef PERL_OBJECT - -#define VTBL this->*vtbl - -#else struct magic_state { SV* mgs_sv; U32 mgs_flags; + I32 mgs_ss_ix; }; -typedef struct magic_state MGS; - -static void restore_magic _((void *p)); -#define VTBL *vtbl - -#endif +/* MGS is typedef'ed to struct magic_state in perl.h */ STATIC void -save_magic(MGS *mgs, SV *sv) +save_magic(I32 mgs_ix, SV *sv) { + dTHR; + MGS* mgs; assert(SvMAGICAL(sv)); + SAVEDESTRUCTOR(restore_magic, (void*)mgs_ix); + + mgs = SSPTR(mgs_ix, MGS*); mgs->mgs_sv = sv; mgs->mgs_flags = SvMAGICAL(sv) | SvREADONLY(sv); - SAVEDESTRUCTOR(restore_magic, mgs); + mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */ SvMAGICAL_off(sv); SvREADONLY_off(sv); @@ -63,9 +67,13 @@ save_magic(MGS *mgs, SV *sv) STATIC void restore_magic(void *p) { - MGS* mgs = (MGS*)p; + dTHR; + MGS* mgs = SSPTR((I32)p, MGS*); SV* sv = mgs->mgs_sv; + if (!sv) + return; + if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) { if (mgs->mgs_flags) @@ -75,6 +83,27 @@ restore_magic(void *p) if (SvGMAGICAL(sv)) SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK); } + + mgs->mgs_sv = NULL; /* mark the MGS structure as restored */ + + /* If we're still on top of the stack, pop us off. (That condition + * will be satisfied if restore_magic was called explicitly, but *not* + * if it's being called via leave_scope.) + * The reason for doing this is that otherwise, things like sv_2cv() + * may leave alloc gunk on the savestack, and some code + * (e.g. sighandler) doesn't expect that... + */ + if (PL_savestack_ix == mgs->mgs_ss_ix) + { + I32 popval = SSPOPINT; + assert(popval == SAVEt_DESTRUCTOR); + PL_savestack_ix -= 2; + popval = SSPOPINT; + assert(popval == SAVEt_ALLOC); + popval = SSPOPINT; + PL_savestack_ix -= popval; + } + } void @@ -97,13 +126,14 @@ mg_magical(SV *sv) int mg_get(SV *sv) { - MGS mgs; + dTHR; + I32 mgs_ix; MAGIC* mg; MAGIC** mgp; int mgp_valid = 0; - ENTER; - save_magic(&mgs, sv); + mgs_ix = SSNEW(sizeof(MGS)); + save_magic(mgs_ix, sv); mgp = &SvMAGIC(sv); while ((mg = *mgp) != 0) { @@ -113,7 +143,7 @@ mg_get(SV *sv) /* Ignore this magic if it's been deleted */ if ((mg == (mgp_valid ? *mgp : SvMAGIC(sv))) && (mg->mg_flags & MGf_GSKIP)) - mgs.mgs_flags = 0; + (SSPTR(mgs_ix, MGS*))->mgs_flags = 0; } /* Advance to next magic (complicated by possible deletion) */ if (mg == (mgp_valid ? *mgp : SvMAGIC(sv))) { @@ -124,32 +154,33 @@ mg_get(SV *sv) mgp = &SvMAGIC(sv); /* Re-establish pointer after sv_upgrade */ } - LEAVE; + restore_magic((void*)mgs_ix); return 0; } int mg_set(SV *sv) { - MGS mgs; + dTHR; + I32 mgs_ix; MAGIC* mg; MAGIC* nextmg; - ENTER; - save_magic(&mgs, sv); + mgs_ix = SSNEW(sizeof(MGS)); + save_magic(mgs_ix, sv); for (mg = SvMAGIC(sv); mg; mg = nextmg) { MGVTBL* vtbl = mg->mg_virtual; nextmg = mg->mg_moremagic; /* it may delete itself */ if (mg->mg_flags & MGf_GSKIP) { mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */ - mgs.mgs_flags = 0; + (SSPTR(mgs_ix, MGS*))->mgs_flags = 0; } if (vtbl && (vtbl->svt_set != NULL)) (VTBL->svt_set)(sv, mg); } - LEAVE; + restore_magic((void*)mgs_ix); return 0; } @@ -163,13 +194,13 @@ mg_length(SV *sv) for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) { MGVTBL* vtbl = mg->mg_virtual; if (vtbl && (vtbl->svt_len != NULL)) { - MGS mgs; + I32 mgs_ix; - ENTER; - save_magic(&mgs, sv); + mgs_ix = SSNEW(sizeof(MGS)); + save_magic(mgs_ix, sv); /* omit MGf_GSKIP -- not changed here */ len = (VTBL->svt_len)(sv, mg); - LEAVE; + restore_magic((void*)mgs_ix); return len; } } @@ -187,11 +218,13 @@ mg_size(SV *sv) for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) { MGVTBL* vtbl = mg->mg_virtual; if (vtbl && (vtbl->svt_len != NULL)) { - MGS mgs; - ENTER; + I32 mgs_ix; + + mgs_ix = SSNEW(sizeof(MGS)); + save_magic(mgs_ix, sv); /* omit MGf_GSKIP -- not changed here */ len = (VTBL->svt_len)(sv, mg); - LEAVE; + restore_magic((void*)mgs_ix); return len; } } @@ -212,11 +245,11 @@ mg_size(SV *sv) int mg_clear(SV *sv) { - MGS mgs; + I32 mgs_ix; MAGIC* mg; - ENTER; - save_magic(&mgs, sv); + mgs_ix = SSNEW(sizeof(MGS)); + save_magic(mgs_ix, sv); for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) { MGVTBL* vtbl = mg->mg_virtual; @@ -226,7 +259,7 @@ mg_clear(SV *sv) (VTBL->svt_clear)(sv, mg); } - LEAVE; + restore_magic((void*)mgs_ix); return 0; } @@ -248,7 +281,9 @@ mg_copy(SV *sv, SV *nsv, char *key, I32 klen) MAGIC* mg; for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) { if (isUPPER(mg->mg_type)) { - sv_magic(nsv, mg->mg_obj, toLOWER(mg->mg_type), key, klen); + sv_magic(nsv, + mg->mg_type == 'P' ? SvTIED_obj(sv, mg) : mg->mg_obj, + toLOWER(mg->mg_type), key, klen); count++; } } @@ -283,6 +318,48 @@ mg_free(SV *sv) #endif U32 +magic_regdata_cnt(SV *sv, MAGIC *mg) +{ + dTHR; + register char *s; + register I32 i; + register REGEXP *rx; + char *t; + + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) + return rx->lastparen; + return (U32)-1; +} + +int +magic_regdatum_get(SV *sv, MAGIC *mg) +{ + dTHR; + register I32 paren; + register char *s; + register I32 i; + register REGEXP *rx; + char *t; + + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { + paren = mg->mg_len; + if (paren < 0) + return 0; + if (paren <= rx->nparens && + (s = rx->startp[paren]) && + (t = rx->endp[paren])) + { + if (mg->mg_obj) /* @+ */ + i = t - rx->subbase; + else /* @- */ + i = s - rx->subbase; + sv_setiv(sv,i); + } + } + return 0; +} + +U32 magic_len(SV *sv, MAGIC *mg) { dTHR; @@ -295,7 +372,7 @@ magic_len(SV *sv, MAGIC *mg) switch (*mg->mg_ptr) { case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '&': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { paren = atoi(mg->mg_ptr); getparen: if (paren <= rx->nparens && @@ -309,14 +386,14 @@ magic_len(SV *sv, MAGIC *mg) } return 0; case '+': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { paren = rx->lastparen; if (paren) goto getparen; } return 0; case '`': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { if ((s = rx->subbeg) && rx->startp[0]) { i = rx->startp[0] - s; if (i >= 0) @@ -325,7 +402,7 @@ magic_len(SV *sv, MAGIC *mg) } return 0; case '\'': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { if (rx->subend && (s = rx->endp[0])) { i = rx->subend - s; if (i >= 0) @@ -334,18 +411,46 @@ magic_len(SV *sv, MAGIC *mg) } return 0; case ',': - return (STRLEN)ofslen; + return (STRLEN)PL_ofslen; case '\\': - return (STRLEN)orslen; + return (STRLEN)PL_orslen; } magic_get(sv,mg); if (!SvPOK(sv) && SvNIOK(sv)) - sv_2pv(sv, &na); + sv_2pv(sv, &PL_na); if (SvPOK(sv)) return SvCUR(sv); return 0; } +#if 0 +static char * +printW(sv) +SV * sv ; +{ +#if 1 + return "" ; + +#else + int i ; + static char buffer[50] ; + char buf1[20] ; + char * p ; + + + sprintf(buffer, "Buffer %d, Length = %d - ", sv, SvCUR(sv)) ; + p = SvPVX(sv) ; + for (i = 0; i < SvCUR(sv) ; ++ i) { + sprintf (buf1, " %x [%x]", (p+i), *(p+i)) ; + strcat(buffer, buf1) ; + } + + return buffer ; + +#endif +} +#endif + int magic_get(SV *sv, MAGIC *mg) { @@ -358,10 +463,22 @@ magic_get(SV *sv, MAGIC *mg) switch (*mg->mg_ptr) { case '\001': /* ^A */ - sv_setsv(sv, bodytarget); + sv_setsv(sv, PL_bodytarget); + break; + case '\002': /* ^B */ + /* printf("magic_get $^B: ") ; */ + if (PL_curcop->cop_warnings == WARN_NONE) + /* printf("WARN_NONE\n"), */ + sv_setpvn(sv, WARN_NONEstring, WARNsize) ; + else if (PL_curcop->cop_warnings == WARN_ALL) + /* printf("WARN_ALL\n"), */ + sv_setpvn(sv, WARN_ALLstring, WARNsize) ; + else + /* printf("some %s\n", printW(PL_curcop->cop_warnings)), */ + sv_setsv(sv, PL_curcop->cop_warnings); break; case '\004': /* ^D */ - sv_setiv(sv, (IV)(debug & 32767)); + sv_setiv(sv, (IV)(PL_debug & 32767)); break; case '\005': /* ^E */ #ifdef VMS @@ -382,8 +499,11 @@ magic_get(SV *sv, MAGIC *mg) sv_setnv(sv, (double)errno); sv_setpv(sv, errno ? Strerror(errno) : ""); } else { - if (errno != errno_isOS2) - Perl_rc = _syserrno(); + if (errno != errno_isOS2) { + int tmp = _syserrno(); + if (tmp) /* 2nd call to _syserrno() makes it 0 */ + Perl_rc = tmp; + } sv_setnv(sv, (double)Perl_rc); sv_setpv(sv, os2error(Perl_rc)); } @@ -417,29 +537,29 @@ magic_get(SV *sv, MAGIC *mg) SvNOK_on(sv); /* what a wonderful hack! */ break; case '\006': /* ^F */ - sv_setiv(sv, (IV)maxsysfd); + sv_setiv(sv, (IV)PL_maxsysfd); break; case '\010': /* ^H */ - sv_setiv(sv, (IV)hints); + sv_setiv(sv, (IV)PL_hints); break; - case '\t': /* ^I */ - if (inplace) - sv_setpv(sv, inplace); + case '\011': /* ^I */ /* NOT \t in EBCDIC */ + if (PL_inplace) + sv_setpv(sv, PL_inplace); else - sv_setsv(sv, &sv_undef); + sv_setsv(sv, &PL_sv_undef); break; case '\017': /* ^O */ - sv_setpv(sv, osname); + sv_setpv(sv, PL_osname); break; case '\020': /* ^P */ - sv_setiv(sv, (IV)perldb); + sv_setiv(sv, (IV)PL_perldb); break; case '\023': /* ^S */ { dTHR; - if (lex_state != LEX_NOTPARSING) + if (PL_lex_state != LEX_NOTPARSING) SvOK_off(sv); - else if (in_eval) + else if (PL_in_eval) sv_setiv(sv, 1); else sv_setiv(sv, 0); @@ -447,17 +567,17 @@ magic_get(SV *sv, MAGIC *mg) break; case '\024': /* ^T */ #ifdef BIG_TIME - sv_setnv(sv, basetime); + sv_setnv(sv, PL_basetime); #else - sv_setiv(sv, (IV)basetime); + sv_setiv(sv, (IV)PL_basetime); #endif break; case '\027': /* ^W */ - sv_setiv(sv, (IV)dowarn); + sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) == G_WARN_ON)); break; case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '&': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { /* * Pre-threads, this was paren = atoi(GvENAME((GV*)mg->mg_obj)); * XXX Does the new way break anything? @@ -472,86 +592,85 @@ magic_get(SV *sv, MAGIC *mg) getrx: if (i >= 0) { bool was_tainted; - if (tainting) { - was_tainted = tainted; - tainted = FALSE; + if (PL_tainting) { + was_tainted = PL_tainted; + PL_tainted = FALSE; } sv_setpvn(sv,s,i); - if (tainting) - tainted = was_tainted || RX_MATCH_TAINTED(rx); + if (PL_tainting) + PL_tainted = (was_tainted || RX_MATCH_TAINTED(rx)); break; } } } - sv_setsv(sv,&sv_undef); + sv_setsv(sv,&PL_sv_undef); break; case '+': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { paren = rx->lastparen; if (paren) goto getparen; } - sv_setsv(sv,&sv_undef); + sv_setsv(sv,&PL_sv_undef); break; case '`': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { if ((s = rx->subbeg) && rx->startp[0]) { i = rx->startp[0] - s; goto getrx; } } - sv_setsv(sv,&sv_undef); + sv_setsv(sv,&PL_sv_undef); break; case '\'': - if (curpm && (rx = curpm->op_pmregexp)) { + if (PL_curpm && (rx = PL_curpm->op_pmregexp)) { if (rx->subend && (s = rx->endp[0])) { i = rx->subend - s; goto getrx; } } - sv_setsv(sv,&sv_undef); + sv_setsv(sv,&PL_sv_undef); break; case '.': #ifndef lint - if (GvIO(last_in_gv)) { - sv_setiv(sv, (IV)IoLINES(GvIO(last_in_gv))); + if (GvIO(PL_last_in_gv)) { + sv_setiv(sv, (IV)IoLINES(GvIO(PL_last_in_gv))); } #endif break; case '?': { - dTHR; sv_setiv(sv, (IV)STATUS_CURRENT); #ifdef COMPLEX_STATUS - LvTARGOFF(sv) = statusvalue; - LvTARGLEN(sv) = statusvalue_vms; + LvTARGOFF(sv) = PL_statusvalue; + LvTARGLEN(sv) = PL_statusvalue_vms; #endif } break; case '^': - s = IoTOP_NAME(GvIOp(defoutgv)); + s = IoTOP_NAME(GvIOp(PL_defoutgv)); if (s) sv_setpv(sv,s); else { - sv_setpv(sv,GvENAME(defoutgv)); + sv_setpv(sv,GvENAME(PL_defoutgv)); sv_catpv(sv,"_TOP"); } break; case '~': - s = IoFMT_NAME(GvIOp(defoutgv)); + s = IoFMT_NAME(GvIOp(PL_defoutgv)); if (!s) - s = GvENAME(defoutgv); + s = GvENAME(PL_defoutgv); sv_setpv(sv,s); break; #ifndef lint case '=': - sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(defoutgv))); + sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv))); break; case '-': - sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(defoutgv))); + sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv))); break; case '%': - sv_setiv(sv, (IV)IoPAGE(GvIOp(defoutgv))); + sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv))); break; #endif case ':': @@ -559,19 +678,19 @@ magic_get(SV *sv, MAGIC *mg) case '/': break; case '[': - WITH_THR(sv_setiv(sv, (IV)curcop->cop_arybase)); + WITH_THR(sv_setiv(sv, (IV)PL_curcop->cop_arybase)); break; case '|': - sv_setiv(sv, (IV)(IoFLAGS(GvIOp(defoutgv)) & IOf_FLUSH) != 0 ); + sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 ); break; case ',': - sv_setpvn(sv,ofs,ofslen); + sv_setpvn(sv,PL_ofs,PL_ofslen); break; case '\\': - sv_setpvn(sv,ors,orslen); + sv_setpvn(sv,PL_ors,PL_orslen); break; case '#': - sv_setpv(sv,ofmt); + sv_setpv(sv,PL_ofmt); break; case '!': #ifdef VMS @@ -592,18 +711,18 @@ magic_get(SV *sv, MAGIC *mg) SvNOK_on(sv); /* what a wonderful hack! */ break; case '<': - sv_setiv(sv, (IV)uid); + sv_setiv(sv, (IV)PL_uid); break; case '>': - sv_setiv(sv, (IV)euid); + sv_setiv(sv, (IV)PL_euid); break; case '(': - sv_setiv(sv, (IV)gid); - sv_setpvf(sv, "%Vd", (IV)gid); + sv_setiv(sv, (IV)PL_gid); + sv_setpvf(sv, "%Vd", (IV)PL_gid); goto add_groups; case ')': - sv_setiv(sv, (IV)egid); - sv_setpvf(sv, "%Vd", (IV)egid); + sv_setiv(sv, (IV)PL_egid); + sv_setpvf(sv, "%Vd", (IV)PL_egid); add_groups: #ifdef HAS_GETGROUPS { @@ -655,7 +774,7 @@ magic_setenv(SV *sv, MAGIC *mg) /* waiting in the wings? */ if (!len) { SV **valp; - if ((valp = hv_fetch(GvHVn(envgv), ptr, klen, FALSE))) + if ((valp = hv_fetch(GvHVn(PL_envgv), ptr, klen, FALSE))) s = SvPV(*valp, len); } #endif @@ -663,7 +782,7 @@ magic_setenv(SV *sv, MAGIC *mg) #if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS) /* And you'll never guess what the dog had */ /* in its mouth... */ - if (tainting) { + if (PL_tainting) { MgTAINTEDDIR_off(mg); #ifdef VMS if (s && klen == 8 && strEQ(ptr, "DCL$PATH")) { @@ -717,7 +836,7 @@ magic_setenv(SV *sv, MAGIC *mg) int magic_clearenv(SV *sv, MAGIC *mg) { - my_setenv(MgPV(mg,na),Nullch); + my_setenv(MgPV(mg,PL_na),Nullch); return 0; } @@ -728,14 +847,14 @@ magic_set_all_env(SV *sv, MAGIC *mg) die("Can't make list assignment to %%ENV on this system"); #else dTHR; - if (localizing) { + if (PL_localizing) { HE* entry; magic_clear_all_env(sv,mg); hv_iterinit((HV*)sv); while (entry = hv_iternext((HV*)sv)) { I32 keylen; my_setenv(hv_iterkey(entry, &keylen), - SvPV(hv_iterval((HV*)sv, entry), na)); + SvPV(hv_iterval((HV*)sv, entry), PL_na)); } } #endif @@ -767,7 +886,7 @@ magic_clear_all_env(SV *sv, MAGIC *mg) #else I32 i; - if (environ == origenviron) + if (environ == PL_origenviron) New(901, environ, 1, char*); else for (i = 0; environ[i]; i++) @@ -784,7 +903,7 @@ magic_getsig(SV *sv, MAGIC *mg) { I32 i; /* Are we fetching a signal entry? */ - i = whichsig(MgPV(mg,na)); + i = whichsig(MgPV(mg,PL_na)); if (i) { if(psig_ptr[i]) sv_setsv(sv,psig_ptr[i]); @@ -795,7 +914,7 @@ magic_getsig(SV *sv, MAGIC *mg) if(sigstate == SIG_IGN) sv_setpv(sv,"IGNORE"); else - sv_setsv(sv,&sv_undef); + sv_setsv(sv,&PL_sv_undef); psig_ptr[i] = SvREFCNT_inc(sv); SvTEMP_off(sv); } @@ -807,7 +926,7 @@ magic_clearsig(SV *sv, MAGIC *mg) { I32 i; /* Are we clearing a signal entry? */ - i = whichsig(MgPV(mg,na)); + i = whichsig(MgPV(mg,PL_na)); if (i) { if(psig_ptr[i]) { SvREFCNT_dec(psig_ptr[i]); @@ -829,14 +948,14 @@ magic_setsig(SV *sv, MAGIC *mg) I32 i; SV** svp; - s = MgPV(mg,na); + s = MgPV(mg,PL_na); if (*s == '_') { if (strEQ(s,"__DIE__")) - svp = &diehook; + svp = &PL_diehook; else if (strEQ(s,"__WARN__")) - svp = &warnhook; + svp = &PL_warnhook; else if (strEQ(s,"__PARSE__")) - svp = &parsehook; + svp = &PL_parsehook; else croak("No such hook: %s", s); i = 0; @@ -848,8 +967,8 @@ magic_setsig(SV *sv, MAGIC *mg) else { i = whichsig(s); /* ...no, a brick */ if (!i) { - if (dowarn || strEQ(s,"ALARM")) - warn("No such signal: SIG%s", s); + if (ckWARN(WARN_SIGNAL) || strEQ(s,"ALARM")) + warner(WARN_SIGNAL, "No such signal: SIG%s", s); return 0; } SvREFCNT_dec(psig_name[i]); @@ -861,12 +980,12 @@ magic_setsig(SV *sv, MAGIC *mg) } if (SvTYPE(sv) == SVt_PVGV || SvROK(sv)) { if (i) - (void)rsignal(i, sighandlerp); + (void)rsignal(i, PL_sighandlerp); else *svp = SvREFCNT_inc(sv); return 0; } - s = SvPV_force(sv,na); + s = SvPV_force(sv,PL_na); if (strEQ(s,"IGNORE")) { if (i) (void)rsignal(i, SIG_IGN); @@ -888,7 +1007,7 @@ magic_setsig(SV *sv, MAGIC *mg) if (!strchr(s,':') && !strchr(s,'\'')) sv_setpv(sv, form("main::%s", s)); if (i) - (void)rsignal(i, sighandlerp); + (void)rsignal(i, PL_sighandlerp); else *svp = SvREFCNT_inc(sv); } @@ -898,55 +1017,7 @@ magic_setsig(SV *sv, MAGIC *mg) int magic_setisa(SV *sv, MAGIC *mg) { - HV *stash; - SV **svp; - I32 fill; - HV *basefields = Nullhv; - GV **gvp; - GV *gv; - HE *he; - static char *FIELDS = "FIELDS"; - - sub_generation++; - - if (mg->mg_type == 'i') - return 0; /* Ignore lower-case version of the magic */ - - stash = GvSTASH(mg->mg_obj); - svp = AvARRAY((AV*)sv); - - /* NOTE: No support for tied ISA */ - for (fill = AvFILLp((AV*)sv); fill >= 0; fill--, svp++) { - HV *basestash = gv_stashsv(*svp, FALSE); - - if (!basestash) { - if (dowarn) - warn("No such package \"%_\" in @ISA assignment", *svp); - continue; - } - gvp = (GV**)hv_fetch(basestash, FIELDS, 6, FALSE); - if (gvp && *gvp && GvHV(*gvp)) { - if (basefields) - croak("Can't multiply inherit %%FIELDS"); - basefields = GvHV(*gvp); - } - } - - if (!basefields) - return 0; - - gv = (GV*)*hv_fetch(stash, FIELDS, 6, TRUE); - if (!isGV(gv)) - gv_init(gv, stash, FIELDS, 6, TRUE); - if (!GvHV(gv)) - GvHV(gv) = newHV(); - if (HvKEYS(GvHV(gv))) - croak("Inherited %%FIELDS can't override existing %%FIELDS"); - - hv_iterinit(GvHV(gv)); - while ((he = hv_iternext(basefields))) - hv_store(GvHV(gv), HeKEY(he), HeKLEN(he), HeVAL(he), HeHASH(he)); - + PL_sub_generation++; return 0; } @@ -956,31 +1027,53 @@ int magic_setamagic(SV *sv, MAGIC *mg) { /* HV_badAMAGIC_on(Sv_STASH(sv)); */ - amagic_generation++; + PL_amagic_generation++; return 0; } #endif /* OVERLOAD */ int +magic_getnkeys(SV *sv, MAGIC *mg) +{ + HV *hv = (HV*)LvTARG(sv); + HE *entry; + I32 i = 0; + + if (hv) { + (void) hv_iterinit(hv); + if (! SvTIED_mg((SV*)hv, 'P')) + i = HvKEYS(hv); + else { + /*SUPPRESS 560*/ + while (entry = hv_iternext(hv)) { + i++; + } + } + } + + sv_setiv(sv, (IV)i); + return 0; +} + +int magic_setnkeys(SV *sv, MAGIC *mg) { if (LvTARG(sv)) { hv_ksplit((HV*)LvTARG(sv), SvIV(sv)); - LvTARG(sv) = Nullsv; /* Don't allow a ref to reassign this. */ } return 0; } /* caller is responsible for stack switching/cleanup */ STATIC int -magic_methcall(MAGIC *mg, char *meth, I32 flags, int n, SV *val) +magic_methcall(SV *sv, MAGIC *mg, char *meth, I32 flags, int n, SV *val) { dSP; PUSHMARK(SP); EXTEND(SP, n); - PUSHs(mg->mg_obj); + PUSHs(SvTIED_obj(sv, mg)); if (n > 1) { if (mg->mg_ptr) { if (mg->mg_len >= 0) @@ -1007,13 +1100,13 @@ magic_methpack(SV *sv, MAGIC *mg, char *meth) ENTER; SAVETMPS; - PUSHSTACK(SI_MAGIC); + PUSHSTACKi(PERLSI_MAGIC); - if (magic_methcall(mg, meth, G_SCALAR, 2, NULL)) { - sv_setsv(sv, *stack_sp--); + if (magic_methcall(sv, mg, meth, G_SCALAR, 2, NULL)) { + sv_setsv(sv, *PL_stack_sp--); } - POPSTACK(); + POPSTACK; FREETMPS; LEAVE; return 0; @@ -1033,9 +1126,9 @@ magic_setpack(SV *sv, MAGIC *mg) { dSP; ENTER; - PUSHSTACK(SI_MAGIC); - magic_methcall(mg, "STORE", G_SCALAR|G_DISCARD, 3, sv); - POPSTACK(); + PUSHSTACKi(PERLSI_MAGIC); + magic_methcall(sv, mg, "STORE", G_SCALAR|G_DISCARD, 3, sv); + POPSTACK; LEAVE; return 0; } @@ -1055,12 +1148,12 @@ magic_sizepack(SV *sv, MAGIC *mg) ENTER; SAVETMPS; - PUSHSTACK(SI_MAGIC); - if (magic_methcall(mg, "FETCHSIZE", G_SCALAR, 2, NULL)) { - sv = *stack_sp--; + PUSHSTACKi(PERLSI_MAGIC); + if (magic_methcall(sv, mg, "FETCHSIZE", G_SCALAR, 2, NULL)) { + sv = *PL_stack_sp--; retval = (U32) SvIV(sv)-1; } - POPSTACK(); + POPSTACK; FREETMPS; LEAVE; return retval; @@ -1071,12 +1164,12 @@ int magic_wipepack(SV *sv, MAGIC *mg) dSP; ENTER; - PUSHSTACK(SI_MAGIC); + PUSHSTACKi(PERLSI_MAGIC); PUSHMARK(SP); - XPUSHs(mg->mg_obj); + XPUSHs(SvTIED_obj(sv, mg)); PUTBACK; perl_call_method("CLEAR", G_SCALAR|G_DISCARD); - POPSTACK(); + POPSTACK; LEAVE; return 0; } @@ -1089,18 +1182,18 @@ magic_nextpack(SV *sv, MAGIC *mg, SV *key) ENTER; SAVETMPS; - PUSHSTACK(SI_MAGIC); + PUSHSTACKi(PERLSI_MAGIC); PUSHMARK(SP); EXTEND(SP, 2); - PUSHs(mg->mg_obj); + PUSHs(SvTIED_obj(sv, mg)); if (SvOK(key)) PUSHs(key); PUTBACK; if (perl_call_method(meth, G_SCALAR)) - sv_setsv(key, *stack_sp--); + sv_setsv(key, *PL_stack_sp--); - POPSTACK(); + POPSTACK; FREETMPS; LEAVE; return 0; @@ -1121,10 +1214,10 @@ magic_setdbline(SV *sv, MAGIC *mg) GV* gv; SV** svp; - gv = DBline; + gv = PL_DBline; i = SvTRUE(sv); svp = av_fetch(GvAV(gv), - atoi(MgPV(mg,na)), FALSE); + atoi(MgPV(mg,PL_na)), FALSE); if (svp && SvIOKp(*svp) && (o = (OP*)SvSTASH(*svp))) o->op_private = i; else @@ -1136,7 +1229,7 @@ int magic_getarylen(SV *sv, MAGIC *mg) { dTHR; - sv_setiv(sv, AvFILL((AV*)mg->mg_obj) + curcop->cop_arybase); + sv_setiv(sv, AvFILL((AV*)mg->mg_obj) + PL_curcop->cop_arybase); return 0; } @@ -1144,7 +1237,7 @@ int magic_setarylen(SV *sv, MAGIC *mg) { dTHR; - av_fill((AV*)mg->mg_obj, SvIV(sv) - curcop->cop_arybase); + av_fill((AV*)mg->mg_obj, SvIV(sv) - PL_curcop->cop_arybase); return 0; } @@ -1157,7 +1250,10 @@ magic_getpos(SV *sv, MAGIC *mg) mg = mg_find(lsv, 'g'); if (mg && mg->mg_len >= 0) { dTHR; - sv_setiv(sv, mg->mg_len + curcop->cop_arybase); + I32 i = mg->mg_len; + if (IN_UTF8) + sv_pos_b2u(lsv, &i); + sv_setiv(sv, i + PL_curcop->cop_arybase); return 0; } } @@ -1171,6 +1267,8 @@ magic_setpos(SV *sv, MAGIC *mg) SV* lsv = LvTARG(sv); SSize_t pos; STRLEN len; + STRLEN ulen; + dTHR; mg = 0; @@ -1188,7 +1286,16 @@ magic_setpos(SV *sv, MAGIC *mg) } len = SvPOK(lsv) ? SvCUR(lsv) : sv_len(lsv); - WITH_THR(pos = SvIV(sv) - curcop->cop_arybase); + pos = SvIV(sv) - PL_curcop->cop_arybase; + + if (IN_UTF8) { + ulen = sv_len_utf8(lsv); + if (ulen) + len = ulen; + else + ulen = 0; + } + if (pos < 0) { pos += len; if (pos < 0) @@ -1196,6 +1303,13 @@ magic_setpos(SV *sv, MAGIC *mg) } else if (pos > len) pos = len; + + if (ulen) { + I32 p = pos; + sv_pos_u2b(lsv, &p, 0); + pos = p; + } + mg->mg_len = pos; mg->mg_flags &= ~MGf_MINMATCH; @@ -1223,7 +1337,7 @@ magic_setglob(SV *sv, MAGIC *mg) if (!SvOK(sv)) return 0; - s = SvPV(sv, na); + s = SvPV(sv, PL_na); if (*s == '*' && s[1]) s++; gv = gv_fetchpv(s,TRUE, SVt_PVGV); @@ -1236,6 +1350,23 @@ magic_setglob(SV *sv, MAGIC *mg) } int +magic_getsubstr(SV *sv, MAGIC *mg) +{ + STRLEN len; + SV *lsv = LvTARG(sv); + char *tmps = SvPV(lsv,len); + I32 offs = LvTARGOFF(sv); + I32 rem = LvTARGLEN(sv); + + if (offs > len) + offs = len; + if (rem + offs > len) + rem = len - offs; + sv_setpvn(sv, tmps + offs, (STRLEN)rem); + return 0; +} + +int magic_setsubstr(SV *sv, MAGIC *mg) { STRLEN len; @@ -1257,13 +1388,13 @@ int magic_settaint(SV *sv, MAGIC *mg) { dTHR; - if (localizing) { - if (localizing == 1) + if (PL_localizing) { + if (PL_localizing == 1) mg->mg_len <<= 1; else mg->mg_len >>= 1; } - else if (tainted) + else if (PL_tainted) mg->mg_len |= 1; else mg->mg_len &= ~1; @@ -1271,6 +1402,72 @@ magic_settaint(SV *sv, MAGIC *mg) } int +magic_getvec(SV *sv, MAGIC *mg) +{ + SV *lsv = LvTARG(sv); + unsigned char *s; + unsigned long retnum; + STRLEN lsvlen; + I32 len; + I32 offset; + I32 size; + + if (!lsv) { + SvOK_off(sv); + return 0; + } + s = (unsigned char *) SvPV(lsv, lsvlen); + offset = LvTARGOFF(sv); + size = LvTARGLEN(sv); + len = (offset + size + 7) / 8; + + /* Copied from pp_vec() */ + + if (len > lsvlen) { + if (size <= 8) + retnum = 0; + else { + offset >>= 3; + if (size == 16) { + if (offset >= lsvlen) + retnum = 0; + else + retnum = (unsigned long) s[offset] << 8; + } + else if (size == 32) { + if (offset >= lsvlen) + retnum = 0; + else if (offset + 1 >= lsvlen) + retnum = (unsigned long) s[offset] << 24; + else if (offset + 2 >= lsvlen) + retnum = ((unsigned long) s[offset] << 24) + + ((unsigned long) s[offset + 1] << 16); + else + retnum = ((unsigned long) s[offset] << 24) + + ((unsigned long) s[offset + 1] << 16) + + (s[offset + 2] << 8); + } + } + } + else if (size < 8) + retnum = (s[offset >> 3] >> (offset & 7)) & ((1 << size) - 1); + else { + offset >>= 3; + if (size == 8) + retnum = s[offset]; + else if (size == 16) + retnum = ((unsigned long) s[offset] << 8) + s[offset+1]; + else if (size == 32) + retnum = ((unsigned long) s[offset] << 24) + + ((unsigned long) s[offset + 1] << 16) + + (s[offset + 2] << 8) + s[offset+3]; + } + + sv_setuv(sv, (UV)retnum); + return 0; +} + +int magic_setvec(SV *sv, MAGIC *mg) { do_vecset(sv); /* XXX slurp this routine */ @@ -1283,17 +1480,24 @@ magic_getdefelem(SV *sv, MAGIC *mg) SV *targ = Nullsv; if (LvTARGLEN(sv)) { if (mg->mg_obj) { - HV* hv = (HV*)LvTARG(sv); - HE* he = hv_fetch_ent(hv, mg->mg_obj, FALSE, 0); - if (he) - targ = HeVAL(he); + SV *ahv = LvTARG(sv); + if (SvTYPE(ahv) == SVt_PVHV) { + HE *he = hv_fetch_ent((HV*)ahv, mg->mg_obj, FALSE, 0); + if (he) + targ = HeVAL(he); + } + else { + SV **svp = avhv_fetch_ent((AV*)ahv, mg->mg_obj, FALSE, 0); + if (svp) + targ = *svp; + } } else { - AV* av = (AV*)LvTARG(sv); + AV* av = (AV*)LvTARG(sv); if ((I32)LvTARGOFF(sv) <= AvFILL(av)) targ = AvARRAY(av)[LvTARGOFF(sv)]; } - if (targ && targ != &sv_undef) { + if (targ && targ != &PL_sv_undef) { dTHR; /* just for SvREFCNT_dec */ /* somebody else defined it for us */ SvREFCNT_dec(LvTARG(sv)); @@ -1306,7 +1510,7 @@ magic_getdefelem(SV *sv, MAGIC *mg) } else targ = LvTARG(sv); - sv_setsv(sv, targ ? targ : &sv_undef); + sv_setsv(sv, targ ? targ : &PL_sv_undef); return 0; } @@ -1322,27 +1526,29 @@ magic_setdefelem(SV *sv, MAGIC *mg) return 0; } -int -magic_freedefelem(SV *sv, MAGIC *mg) -{ - SvREFCNT_dec(LvTARG(sv)); - return 0; -} - void vivify_defelem(SV *sv) { dTHR; /* just for SvREFCNT_inc and SvREFCNT_dec*/ - MAGIC* mg; - SV* value; + MAGIC *mg; + SV *value = Nullsv; if (!LvTARGLEN(sv) || !(mg = mg_find(sv, 'y'))) return; if (mg->mg_obj) { - HV* hv = (HV*)LvTARG(sv); - HE* he = hv_fetch_ent(hv, mg->mg_obj, TRUE, 0); - if (!he || (value = HeVAL(he)) == &sv_undef) - croak(no_helem, SvPV(mg->mg_obj, na)); + SV *ahv = LvTARG(sv); + if (SvTYPE(ahv) == SVt_PVHV) { + HE *he = hv_fetch_ent((HV*)ahv, mg->mg_obj, TRUE, 0); + if (he) + value = HeVAL(he); + } + else { + SV **svp = avhv_fetch_ent((AV*)ahv, mg->mg_obj, TRUE, 0); + if (svp) + value = *svp; + } + if (!value || value == &PL_sv_undef) + croak(no_helem, SvPV(mg->mg_obj, PL_na)); } else { AV* av = (AV*)LvTARG(sv); @@ -1350,7 +1556,7 @@ vivify_defelem(SV *sv) LvTARG(sv) = Nullsv; /* array can't be extended */ else { SV** svp = av_fetch(av, LvTARGOFF(sv), TRUE); - if (!svp || (value = *svp) == &sv_undef) + if (!svp || (value = *svp) == &PL_sv_undef) croak(no_aelem, (I32)LvTARGOFF(sv)); } } @@ -1410,7 +1616,7 @@ int magic_setcollxfrm(SV *sv, MAGIC *mg) { /* - * René Descartes said "I think not." + * RenE Descartes said "I think not." * and vanished with a faint plop. */ if (mg->mg_ptr) { @@ -1431,10 +1637,25 @@ magic_set(SV *sv, MAGIC *mg) STRLEN len; switch (*mg->mg_ptr) { case '\001': /* ^A */ - sv_setsv(bodytarget, sv); + sv_setsv(PL_bodytarget, sv); + break; + case '\002': /* ^B */ + if ( ! (PL_dowarn & G_WARN_ALL_MASK)) { + if (memEQ(SvPVX(sv), WARN_ALLstring, WARNsize)) + PL_compiling.cop_warnings = WARN_ALL; + else if (memEQ(SvPVX(sv), WARN_NONEstring, WARNsize)) + PL_compiling.cop_warnings = WARN_NONE; + else { + if (PL_compiling.cop_warnings != WARN_NONE && + PL_compiling.cop_warnings != WARN_ALL) + sv_setsv(PL_compiling.cop_warnings, sv); + else + PL_compiling.cop_warnings = newSVsv(sv) ; + } + } break; case '\004': /* ^D */ - debug = (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) | 0x80000000; + PL_debug = (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) | 0x80000000; DEBUG_x(dump_all()); break; case '\005': /* ^E */ @@ -1450,72 +1671,75 @@ magic_set(SV *sv, MAGIC *mg) #endif break; case '\006': /* ^F */ - maxsysfd = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + PL_maxsysfd = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); break; case '\010': /* ^H */ - hints = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + PL_hints = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); break; - case '\t': /* ^I */ - if (inplace) - Safefree(inplace); + case '\011': /* ^I */ /* NOT \t in EBCDIC */ + if (PL_inplace) + Safefree(PL_inplace); if (SvOK(sv)) - inplace = savepv(SvPV(sv,na)); + PL_inplace = savepv(SvPV(sv,PL_na)); else - inplace = Nullch; + PL_inplace = Nullch; break; case '\017': /* ^O */ - if (osname) - Safefree(osname); + if (PL_osname) + Safefree(PL_osname); if (SvOK(sv)) - osname = savepv(SvPV(sv,na)); + PL_osname = savepv(SvPV(sv,PL_na)); else - osname = Nullch; + PL_osname = Nullch; break; case '\020': /* ^P */ - perldb = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + PL_perldb = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); break; case '\024': /* ^T */ #ifdef BIG_TIME - basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv)); + PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv)); #else - basetime = (Time_t)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); + PL_basetime = (Time_t)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); #endif break; case '\027': /* ^W */ - dowarn = (bool)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); + if ( ! (PL_dowarn & G_WARN_ALL_MASK)) { + i = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + PL_dowarn = (i ? G_WARN_ON : G_WARN_OFF) ; + } break; case '.': - if (localizing) { - if (localizing == 1) - save_sptr((SV**)&last_in_gv); + if (PL_localizing) { + if (PL_localizing == 1) + save_sptr((SV**)&PL_last_in_gv); } - else if (SvOK(sv) && GvIO(last_in_gv)) - IoLINES(GvIOp(last_in_gv)) = (long)SvIV(sv); + else if (SvOK(sv) && GvIO(PL_last_in_gv)) + IoLINES(GvIOp(PL_last_in_gv)) = (long)SvIV(sv); break; case '^': - Safefree(IoTOP_NAME(GvIOp(defoutgv))); - IoTOP_NAME(GvIOp(defoutgv)) = s = savepv(SvPV(sv,na)); - IoTOP_GV(GvIOp(defoutgv)) = gv_fetchpv(s,TRUE, SVt_PVIO); + Safefree(IoTOP_NAME(GvIOp(PL_defoutgv))); + IoTOP_NAME(GvIOp(PL_defoutgv)) = s = savepv(SvPV(sv,PL_na)); + IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchpv(s,TRUE, SVt_PVIO); break; case '~': - Safefree(IoFMT_NAME(GvIOp(defoutgv))); - IoFMT_NAME(GvIOp(defoutgv)) = s = savepv(SvPV(sv,na)); - IoFMT_GV(GvIOp(defoutgv)) = gv_fetchpv(s,TRUE, SVt_PVIO); + Safefree(IoFMT_NAME(GvIOp(PL_defoutgv))); + IoFMT_NAME(GvIOp(PL_defoutgv)) = s = savepv(SvPV(sv,PL_na)); + IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchpv(s,TRUE, SVt_PVIO); break; case '=': - IoPAGE_LEN(GvIOp(defoutgv)) = (long)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); + IoPAGE_LEN(GvIOp(PL_defoutgv)) = (long)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); break; case '-': - IoLINES_LEFT(GvIOp(defoutgv)) = (long)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); - if (IoLINES_LEFT(GvIOp(defoutgv)) < 0L) - IoLINES_LEFT(GvIOp(defoutgv)) = 0L; + IoLINES_LEFT(GvIOp(PL_defoutgv)) = (long)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); + if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L) + IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L; break; case '%': - IoPAGE(GvIOp(defoutgv)) = (long)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); + IoPAGE(GvIOp(PL_defoutgv)) = (long)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)); break; case '|': { - IO *io = GvIOp(defoutgv); + IO *io = GvIOp(PL_defoutgv); if ((SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) == 0) IoFLAGS(io) &= ~IOf_FLUSH; else { @@ -1530,42 +1754,42 @@ magic_set(SV *sv, MAGIC *mg) break; case '*': i = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); - multiline = (i != 0); + PL_multiline = (i != 0); break; case '/': - SvREFCNT_dec(nrs); - nrs = newSVsv(sv); - SvREFCNT_dec(rs); - rs = SvREFCNT_inc(nrs); + SvREFCNT_dec(PL_nrs); + PL_nrs = newSVsv(sv); + SvREFCNT_dec(PL_rs); + PL_rs = SvREFCNT_inc(PL_nrs); break; case '\\': - if (ors) - Safefree(ors); + if (PL_ors) + Safefree(PL_ors); if (SvOK(sv) || SvGMAGICAL(sv)) - ors = savepv(SvPV(sv,orslen)); + PL_ors = savepv(SvPV(sv,PL_orslen)); else { - ors = Nullch; - orslen = 0; + PL_ors = Nullch; + PL_orslen = 0; } break; case ',': - if (ofs) - Safefree(ofs); - ofs = savepv(SvPV(sv, ofslen)); + if (PL_ofs) + Safefree(PL_ofs); + PL_ofs = savepv(SvPV(sv, PL_ofslen)); break; case '#': - if (ofmt) - Safefree(ofmt); - ofmt = savepv(SvPV(sv,na)); + if (PL_ofmt) + Safefree(PL_ofmt); + PL_ofmt = savepv(SvPV(sv,PL_na)); break; case '[': - compiling.cop_arybase = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + PL_compiling.cop_arybase = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); break; case '?': #ifdef COMPLEX_STATUS - if (localizing == 2) { - statusvalue = LvTARGOFF(sv); - statusvalue_vms = LvTARGLEN(sv); + if (PL_localizing == 2) { + PL_statusvalue = LvTARGOFF(sv); + PL_statusvalue_vms = LvTARGLEN(sv); } else #endif @@ -1581,96 +1805,96 @@ magic_set(SV *sv, MAGIC *mg) (SvIV(sv) == EVMSERR) ? 4 : vaxc$errno); break; case '<': - uid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); - if (delaymagic) { - delaymagic |= DM_RUID; + PL_uid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + if (PL_delaymagic) { + PL_delaymagic |= DM_RUID; break; /* don't do magic till later */ } #ifdef HAS_SETRUID - (void)setruid((Uid_t)uid); + (void)setruid((Uid_t)PL_uid); #else #ifdef HAS_SETREUID - (void)setreuid((Uid_t)uid, (Uid_t)-1); + (void)setreuid((Uid_t)PL_uid, (Uid_t)-1); #else #ifdef HAS_SETRESUID - (void)setresuid((Uid_t)uid, (Uid_t)-1, (Uid_t)-1); + (void)setresuid((Uid_t)PL_uid, (Uid_t)-1, (Uid_t)-1); #else - if (uid == euid) /* special case $< = $> */ - (void)PerlProc_setuid(uid); + if (PL_uid == PL_euid) /* special case $< = $> */ + (void)PerlProc_setuid(PL_uid); else { - uid = (I32)PerlProc_getuid(); + PL_uid = (I32)PerlProc_getuid(); croak("setruid() not implemented"); } #endif #endif #endif - uid = (I32)PerlProc_getuid(); - tainting |= (uid && (euid != uid || egid != gid)); + PL_uid = (I32)PerlProc_getuid(); + PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid)); break; case '>': - euid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); - if (delaymagic) { - delaymagic |= DM_EUID; + PL_euid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + if (PL_delaymagic) { + PL_delaymagic |= DM_EUID; break; /* don't do magic till later */ } #ifdef HAS_SETEUID - (void)seteuid((Uid_t)euid); + (void)seteuid((Uid_t)PL_euid); #else #ifdef HAS_SETREUID - (void)setreuid((Uid_t)-1, (Uid_t)euid); + (void)setreuid((Uid_t)-1, (Uid_t)PL_euid); #else #ifdef HAS_SETRESUID - (void)setresuid((Uid_t)-1, (Uid_t)euid, (Uid_t)-1); + (void)setresuid((Uid_t)-1, (Uid_t)PL_euid, (Uid_t)-1); #else - if (euid == uid) /* special case $> = $< */ - PerlProc_setuid(euid); + if (PL_euid == PL_uid) /* special case $> = $< */ + PerlProc_setuid(PL_euid); else { - euid = (I32)PerlProc_geteuid(); + PL_euid = (I32)PerlProc_geteuid(); croak("seteuid() not implemented"); } #endif #endif #endif - euid = (I32)PerlProc_geteuid(); - tainting |= (uid && (euid != uid || egid != gid)); + PL_euid = (I32)PerlProc_geteuid(); + PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid)); break; case '(': - gid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); - if (delaymagic) { - delaymagic |= DM_RGID; + PL_gid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + if (PL_delaymagic) { + PL_delaymagic |= DM_RGID; break; /* don't do magic till later */ } #ifdef HAS_SETRGID - (void)setrgid((Gid_t)gid); + (void)setrgid((Gid_t)PL_gid); #else #ifdef HAS_SETREGID - (void)setregid((Gid_t)gid, (Gid_t)-1); + (void)setregid((Gid_t)PL_gid, (Gid_t)-1); #else #ifdef HAS_SETRESGID - (void)setresgid((Gid_t)gid, (Gid_t)-1, (Gid_t) 1); + (void)setresgid((Gid_t)PL_gid, (Gid_t)-1, (Gid_t) 1); #else - if (gid == egid) /* special case $( = $) */ - (void)PerlProc_setgid(gid); + if (PL_gid == PL_egid) /* special case $( = $) */ + (void)PerlProc_setgid(PL_gid); else { - gid = (I32)PerlProc_getgid(); + PL_gid = (I32)PerlProc_getgid(); croak("setrgid() not implemented"); } #endif #endif #endif - gid = (I32)PerlProc_getgid(); - tainting |= (uid && (euid != uid || egid != gid)); + PL_gid = (I32)PerlProc_getgid(); + PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid)); break; case ')': #ifdef HAS_SETGROUPS { - char *p = SvPV(sv, na); + char *p = SvPV(sv, PL_na); Groups_t gary[NGROUPS]; SET_NUMERIC_STANDARD(); while (isSPACE(*p)) ++p; - egid = I_V(atof(p)); + PL_egid = I_V(atof(p)); for (i = 0; i < NGROUPS; ++i) { while (*p && !isSPACE(*p)) ++p; @@ -1684,45 +1908,45 @@ magic_set(SV *sv, MAGIC *mg) (void)setgroups(i, gary); } #else /* HAS_SETGROUPS */ - egid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); + PL_egid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv); #endif /* HAS_SETGROUPS */ - if (delaymagic) { - delaymagic |= DM_EGID; + if (PL_delaymagic) { + PL_delaymagic |= DM_EGID; break; /* don't do magic till later */ } #ifdef HAS_SETEGID - (void)setegid((Gid_t)egid); + (void)setegid((Gid_t)PL_egid); #else #ifdef HAS_SETREGID - (void)setregid((Gid_t)-1, (Gid_t)egid); + (void)setregid((Gid_t)-1, (Gid_t)PL_egid); #else #ifdef HAS_SETRESGID - (void)setresgid((Gid_t)-1, (Gid_t)egid, (Gid_t)-1); + (void)setresgid((Gid_t)-1, (Gid_t)PL_egid, (Gid_t)-1); #else - if (egid == gid) /* special case $) = $( */ - (void)PerlProc_setgid(egid); + if (PL_egid == PL_gid) /* special case $) = $( */ + (void)PerlProc_setgid(PL_egid); else { - egid = (I32)PerlProc_getegid(); + PL_egid = (I32)PerlProc_getegid(); croak("setegid() not implemented"); } #endif #endif #endif - egid = (I32)PerlProc_getegid(); - tainting |= (uid && (euid != uid || egid != gid)); + PL_egid = (I32)PerlProc_getegid(); + PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid)); break; case ':': - chopset = SvPV_force(sv,na); + PL_chopset = SvPV_force(sv,PL_na); break; case '0': - if (!origalen) { - s = origargv[0]; + if (!PL_origalen) { + s = PL_origargv[0]; s += strlen(s); /* See if all the arguments are contiguous in memory */ - for (i = 1; i < origargc; i++) { - if (origargv[i] == s + 1 + for (i = 1; i < PL_origargc; i++) { + if (PL_origargv[i] == s + 1 #ifdef OS2 - || origargv[i] == s + 2 + || PL_origargv[i] == s + 2 #endif ) s += strlen(++s); /* this one is ok too */ @@ -1730,40 +1954,40 @@ magic_set(SV *sv, MAGIC *mg) break; } /* can grab env area too? */ - if (origenviron && (origenviron[0] == s + 1 + if (PL_origenviron && (PL_origenviron[0] == s + 1 #ifdef OS2 - || (origenviron[0] == s + 9 && (s += 8)) + || (PL_origenviron[0] == s + 9 && (s += 8)) #endif )) { my_setenv("NoNe SuCh", Nullch); /* force copy of environment */ - for (i = 0; origenviron[i]; i++) - if (origenviron[i] == s + 1) + for (i = 0; PL_origenviron[i]; i++) + if (PL_origenviron[i] == s + 1) s += strlen(++s); else break; } - origalen = s - origargv[0]; + PL_origalen = s - PL_origargv[0]; } s = SvPV_force(sv,len); i = len; - if (i >= origalen) { - i = origalen; + if (i >= PL_origalen) { + i = PL_origalen; /* don't allow system to limit $0 seen by script */ /* SvCUR_set(sv, i); *SvEND(sv) = '\0'; */ - Copy(s, origargv[0], i, char); - s = origargv[0]+i; + Copy(s, PL_origargv[0], i, char); + s = PL_origargv[0]+i; *s = '\0'; } else { - Copy(s, origargv[0], i, char); - s = origargv[0]+i; + Copy(s, PL_origargv[0], i, char); + s = PL_origargv[0]+i; *s++ = '\0'; - while (++i < origalen) + while (++i < PL_origalen) *s++ = ' '; - s = origargv[0]+i; - for (i = 1; i < origargc; i++) - origargv[i] = Nullch; + s = PL_origargv[0]+i; + for (i = 1; i < PL_origargc; i++) + PL_origargv[i] = Nullch; } break; #ifdef USE_THREADS @@ -1780,13 +2004,12 @@ int magic_mutexfree(SV *sv, MAGIC *mg) { dTHR; - DEBUG_L(PerlIO_printf(PerlIO_stderr(), "0x%lx: magic_mutexfree 0x%lx\n", + DEBUG_S(PerlIO_printf(PerlIO_stderr(), "0x%lx: magic_mutexfree 0x%lx\n", (unsigned long)thr, (unsigned long)sv);) if (MgOWNER(mg)) croak("panic: magic_mutexfree"); MUTEX_DESTROY(MgMUTEXP(mg)); COND_DESTROY(MgCONDP(mg)); - SvREFCNT_dec(sv); return 0; } #endif /* USE_THREADS */ @@ -1819,7 +2042,7 @@ unwind_handler_stack(void *p) U32 flags = *(U32*)p; if (flags & 1) - savestack_ix -= 5; /* Unprotect save in progress. */ + PL_savestack_ix -= 5; /* Unprotect save in progress. */ /* cxstack_ix-- Not needed, die already unwound it. */ if (flags & 64) SvREFCNT_dec(sig_sv); @@ -1831,20 +2054,20 @@ sighandler(int sig) dSP; GV *gv = Nullgv; HV *st; - SV *sv, *tSv = Sv; + SV *sv, *tSv = PL_Sv; CV *cv = Nullcv; - OP *myop = op; + OP *myop = PL_op; U32 flags = 0; - I32 o_save_i = savestack_ix, type; - XPV *tXpv = Xpv; + I32 o_save_i = PL_savestack_ix, type; + XPV *tXpv = PL_Xpv; - if (savestack_ix + 15 <= savestack_max) + if (PL_savestack_ix + 15 <= PL_savestack_max) flags |= 1; - if (markstack_ptr < markstack_max - 2) + if (PL_markstack_ptr < PL_markstack_max - 2) flags |= 4; - if (retstack_ix < retstack_max - 2) + if (PL_retstack_ix < PL_retstack_max - 2) flags |= 8; - if (scopestack_ix < scopestack_max - 3) + if (PL_scopestack_ix < PL_scopestack_max - 3) flags |= 16; if (!psig_ptr[sig]) @@ -1854,26 +2077,26 @@ sighandler(int sig) /* Max number of items pushed there is 3*n or 4. We cannot fix infinity, so we fix 4 (in fact 5): */ if (flags & 1) { - savestack_ix += 5; /* Protect save in progress. */ - o_save_i = savestack_ix; + PL_savestack_ix += 5; /* Protect save in progress. */ + o_save_i = PL_savestack_ix; SAVEDESTRUCTOR(unwind_handler_stack, (void*)&flags); } if (flags & 4) - markstack_ptr++; /* Protect mark. */ + PL_markstack_ptr++; /* Protect mark. */ if (flags & 8) { - retstack_ix++; - retstack[retstack_ix] = NULL; + PL_retstack_ix++; + PL_retstack[PL_retstack_ix] = NULL; } if (flags & 16) - scopestack_ix += 1; + PL_scopestack_ix += 1; /* sv_2cv is too complicated, try a simpler variant first: */ if (!SvROK(psig_ptr[sig]) || !(cv = (CV*)SvRV(psig_ptr[sig])) || SvTYPE(cv) != SVt_PVCV) cv = sv_2cv(psig_ptr[sig],&st,&gv,TRUE); if (!cv || !CvROOT(cv)) { - if (dowarn) - warn("SIG%s handler \"%s\" not defined.\n", + if (ckWARN(WARN_SIGNAL)) + warner(WARN_SIGNAL, "SIG%s handler \"%s\" not defined.\n", sig_name[sig], (gv ? GvENAME(gv) : ((cv && CvGV(cv)) ? GvENAME(CvGV(cv)) @@ -1890,29 +2113,29 @@ sighandler(int sig) sv_setpv(sv,sig_name[sig]); } - PUSHSTACK(SI_SIGNAL); + PUSHSTACKi(PERLSI_SIGNAL); PUSHMARK(SP); PUSHs(sv); PUTBACK; perl_call_sv((SV*)cv, G_DISCARD); - POPSTACK(); + POPSTACK; cleanup: if (flags & 1) - savestack_ix -= 8; /* Unprotect save in progress. */ + PL_savestack_ix -= 8; /* Unprotect save in progress. */ if (flags & 4) - markstack_ptr--; + PL_markstack_ptr--; if (flags & 8) - retstack_ix--; + PL_retstack_ix--; if (flags & 16) - scopestack_ix -= 1; + PL_scopestack_ix -= 1; if (flags & 64) SvREFCNT_dec(sv); - op = myop; /* Apparently not needed... */ + PL_op = myop; /* Apparently not needed... */ - Sv = tSv; /* Restore global temporaries. */ - Xpv = tXpv; + PL_Sv = tSv; /* Restore global temporaries. */ + PL_Xpv = tXpv; return; }