X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=ext%2FOpcode%2FOpcode.xs;h=eba1c86d7d1fb9c616730957a4b1e3f6488fc2f9;hb=13d771f075428106b872fe78aa3d944467de9082;hp=e853cf19a364b091711236a80391d35a6b0cc303;hpb=db15561cb83ed8e36f76d63e4283fc51c30fd71f;p=p5sagit%2Fp5-mst-13.2.git diff --git a/ext/Opcode/Opcode.xs b/ext/Opcode/Opcode.xs index e853cf1..eba1c86 100644 --- a/ext/Opcode/Opcode.xs +++ b/ext/Opcode/Opcode.xs @@ -1,3 +1,4 @@ +#define PERL_NO_GET_CONTEXT #include "EXTERN.h" #include "perl.h" #include "XSUB.h" @@ -6,16 +7,27 @@ #define OP_MASK_BUF_SIZE (MAXO + 100) /* XXX op_named_bits and opset_all are never freed */ -static HV *op_named_bits; /* cache shared for whole process */ -static SV *opset_all; /* mask with all bits set */ -static IV opset_len; /* length of opmasks in bytes */ -static int opcode_debug = 0; +#define MY_CXT_KEY "Opcode::_guts" XS_VERSION -static SV *new_opset _((SV *old_opset)); -static int verify_opset _((SV *opset, int fatal)); -static void set_opset_bits _((char *bitmap, SV *bitspec, int on, char *opname)); -static void put_op_bitspec _((char *optag, STRLEN len, SV *opset)); -static SV *get_op_bitspec _((char *opname, STRLEN len, int fatal)); +typedef struct { + HV * x_op_named_bits; /* cache shared for whole process */ + SV * x_opset_all; /* mask with all bits set */ + IV x_opset_len; /* length of opmasks in bytes */ + int x_opcode_debug; +} my_cxt_t; + +START_MY_CXT + +#define op_named_bits (MY_CXT.x_op_named_bits) +#define opset_all (MY_CXT.x_opset_all) +#define opset_len (MY_CXT.x_opset_len) +#define opcode_debug (MY_CXT.x_opcode_debug) + +static SV *new_opset (pTHX_ SV *old_opset); +static int verify_opset (pTHX_ SV *opset, int fatal); +static void set_opset_bits (pTHX_ char *bitmap, SV *bitspec, int on, const char *opname); +static void put_op_bitspec (pTHX_ const char *optag, STRLEN len, SV *opset); +static SV *get_op_bitspec (pTHX_ const char *opname, STRLEN len, int fatal); /* Initialise our private op_named_bits HV. @@ -27,32 +39,32 @@ static SV *get_op_bitspec _((char *opname, STRLEN len, int fatal)); */ static void -op_names_init(void) +op_names_init(pTHX) { int i; STRLEN len; char **op_names; char *bitmap; + dMY_CXT; op_named_bits = newHV(); op_names = get_op_names(); for(i=0; i < PL_maxo; ++i) { - SV *sv; - sv = newSViv(i); + SV * const sv = newSViv(i); SvREADONLY_on(sv); hv_store(op_named_bits, op_names[i], strlen(op_names[i]), sv, 0); } - put_op_bitspec(":none",0, sv_2mortal(new_opset(Nullsv))); + put_op_bitspec(aTHX_ ":none",0, sv_2mortal(new_opset(aTHX_ Nullsv))); - opset_all = new_opset(Nullsv); + opset_all = new_opset(aTHX_ Nullsv); bitmap = SvPV(opset_all, len); i = len-1; /* deal with last byte specially, see below */ while(i-- > 0) - bitmap[i] = 0xFF; + bitmap[i] = (char)0xFF; /* Take care to set the right number of bits in the last byte */ bitmap[len-1] = (PL_maxo & 0x07) ? ~(0xFF << (PL_maxo & 0x07)) : 0xFF; - put_op_bitspec(":all",0, opset_all); /* don't mortalise */ + put_op_bitspec(aTHX_ ":all",0, opset_all); /* don't mortalise */ } @@ -62,10 +74,12 @@ op_names_init(void) */ static void -put_op_bitspec(char *optag, STRLEN len, SV *mask) +put_op_bitspec(pTHX_ const char *optag, STRLEN len, SV *mask) { SV **svp; - verify_opset(mask,1); + dMY_CXT; + + verify_opset(aTHX_ mask,1); if (!len) len = strlen(optag); svp = hv_fetch(op_named_bits, optag, len, 1); @@ -83,9 +97,11 @@ put_op_bitspec(char *optag, STRLEN len, SV *mask) */ static SV * -get_op_bitspec(char *opname, STRLEN len, int fatal) +get_op_bitspec(pTHX_ const char *opname, STRLEN len, int fatal) { SV **svp; + dMY_CXT; + if (!len) len = strlen(opname); svp = hv_fetch(op_named_bits, opname, len, 0); @@ -106,16 +122,18 @@ get_op_bitspec(char *opname, STRLEN len, int fatal) static SV * -new_opset(SV *old_opset) +new_opset(pTHX_ SV *old_opset) { SV *opset; + dMY_CXT; + if (old_opset) { - verify_opset(old_opset,1); + verify_opset(aTHX_ old_opset,1); opset = newSVsv(old_opset); } else { - opset = NEWSV(1156, opset_len); - Zero(SvPVX(opset), opset_len + 1, char); + opset = newSV(opset_len); + Zero(SvPVX_const(opset), opset_len + 1, char); SvCUR_set(opset, opset_len); (void)SvPOK_only(opset); } @@ -125,12 +143,14 @@ new_opset(SV *old_opset) static int -verify_opset(SV *opset, int fatal) +verify_opset(pTHX_ SV *opset, int fatal) { - char *err = Nullch; + const char *err = Nullch; + dMY_CXT; + if (!SvOK(opset)) err = "undefined"; else if (!SvPOK(opset)) err = "wrong type"; - else if (SvCUR(opset) != opset_len) err = "wrong size"; + else if (SvCUR(opset) != (STRLEN)opset_len) err = "wrong size"; if (err && fatal) { croak("Invalid opset: %s", err); } @@ -139,12 +159,14 @@ verify_opset(SV *opset, int fatal) static void -set_opset_bits(char *bitmap, SV *bitspec, int on, char *opname) +set_opset_bits(pTHX_ char *bitmap, SV *bitspec, int on, const char *opname) { + dMY_CXT; + if (SvIOK(bitspec)) { - int myopcode = SvIV(bitspec); - int offset = myopcode >> 3; - int bit = myopcode & 0x07; + const int myopcode = SvIV(bitspec); + const int offset = myopcode >> 3; + const int bit = myopcode & 0x07; if (myopcode >= PL_maxo || myopcode < 0) croak("panic: opcode \"%s\" value %d is invalid", opname, myopcode); if (opcode_debug >= 2) @@ -155,10 +177,10 @@ set_opset_bits(char *bitmap, SV *bitspec, int on, char *opname) else bitmap[offset] &= ~(1 << bit); } - else if (SvPOK(bitspec) && SvCUR(bitspec) == opset_len) { + else if (SvPOK(bitspec) && SvCUR(bitspec) == (STRLEN)opset_len) { STRLEN len; - char *specbits = SvPV(bitspec, len); + const char * const specbits = SvPV(bitspec, len); if (opcode_debug >= 2) warn("set_opset_bits opset %s %s\n", opname, (on)?"on":"off"); if (on) @@ -173,14 +195,15 @@ set_opset_bits(char *bitmap, SV *bitspec, int on, char *opname) static void -opmask_add(SV *opset) /* THE ONLY FUNCTION TO EDIT PL_op_mask ITSELF */ +opmask_add(pTHX_ SV *opset) /* THE ONLY FUNCTION TO EDIT PL_op_mask ITSELF */ { int i,j; char *bitmask; STRLEN len; int myopcode = 0; + dMY_CXT; - verify_opset(opset,1); /* croaks on bad opset */ + verify_opset(aTHX_ opset,1); /* croaks on bad opset */ if (!PL_op_mask) /* caller must ensure PL_op_mask exists */ croak("Can't add to uninitialised PL_op_mask"); @@ -189,7 +212,7 @@ opmask_add(SV *opset) /* THE ONLY FUNCTION TO EDIT PL_op_mask ITSELF */ bitmask = SvPV(opset, len); for (i=0; i < opset_len; i++) { - U16 bits = bitmask[i]; + const U16 bits = bitmask[i]; if (!bits) { /* optimise for sparse masks */ myopcode += 8; continue; @@ -200,23 +223,23 @@ opmask_add(SV *opset) /* THE ONLY FUNCTION TO EDIT PL_op_mask ITSELF */ } static void -opmask_addlocal(SV *opset, char *op_mask_buf) /* Localise PL_op_mask then opmask_add() */ +opmask_addlocal(pTHX_ SV *opset, char *op_mask_buf) /* Localise PL_op_mask then opmask_add() */ { char *orig_op_mask = PL_op_mask; - SAVEPPTR(PL_op_mask); -#if !defined(PERL_OBJECT) + dMY_CXT; + + SAVEVPTR(PL_op_mask); /* XXX casting to an ordinary function ptr from a member function ptr * is disallowed by Borland */ if (opcode_debug >= 2) - SAVEDESTRUCTOR((void(CPERLscope(*))_((void*)))warn,"PL_op_mask restored"); -#endif + SAVEDESTRUCTOR((void(*)(void*))Perl_warn,"PL_op_mask restored"); PL_op_mask = &op_mask_buf[0]; if (orig_op_mask) Copy(orig_op_mask, PL_op_mask, PL_maxo, char); else Zero(PL_op_mask, PL_maxo, char); - opmask_add(opset); + opmask_add(aTHX_ opset); } @@ -226,11 +249,34 @@ MODULE = Opcode PACKAGE = Opcode PROTOTYPES: ENABLE BOOT: +{ + MY_CXT_INIT; assert(PL_maxo < OP_MASK_BUF_SIZE); opset_len = (PL_maxo + 7) / 8; if (opcode_debug >= 1) warn("opset_len %ld\n", (long)opset_len); - op_names_init(); + op_names_init(aTHX); +} + +void +_safe_pkg_prep(Package) + const char *Package +PPCODE: + HV *hv; + ENTER; + + hv = gv_stashpv(Package, GV_ADDWARN); /* should exist already */ + + if (strNE(HvNAME_get(hv),"main")) { + /* make it think it's in main:: */ + hv_name_set(hv, "main", 4, 0); + hv_store(hv,"_",1,(SV *)PL_defgv,0); /* connect _ to global */ + SvREFCNT_inc((SV *)PL_defgv); /* want to keep _ around! */ + } + LEAVE; + + + void @@ -241,18 +287,22 @@ _safe_call_sv(Package, mask, codesv) PPCODE: char op_mask_buf[OP_MASK_BUF_SIZE]; GV *gv; + HV *dummy_hv; ENTER; - opmask_addlocal(mask, op_mask_buf); + opmask_addlocal(aTHX_ mask, op_mask_buf); save_aptr(&PL_endav); PL_endav = (AV*)sv_2mortal((SV*)newAV()); /* ignore END blocks for now */ - save_hptr(&PL_defstash); /* save current default stack */ + save_hptr(&PL_defstash); /* save current default stash */ /* the assignment to global defstash changes our sense of 'main' */ PL_defstash = gv_stashpv(Package, GV_ADDWARN); /* should exist already */ + save_hptr(&PL_curstash); + PL_curstash = PL_defstash; + /* defstash must itself contain a main:: so we'll add that now */ /* take care with the ref counts (was cause of long standing bug) */ /* XXX I'm still not sure if this is right, GV_ADDWARN should warn! */ @@ -260,8 +310,17 @@ PPCODE: sv_free((SV*)GvHV(gv)); GvHV(gv) = (HV*)SvREFCNT_inc(PL_defstash); + /* %INC must be clean for use/require in compartment */ + dummy_hv = save_hash(PL_incgv); + GvHV(PL_incgv) = (HV*)SvREFCNT_inc(GvHV(gv_HVadd(gv_fetchpv("INC",TRUE,SVt_PVHV)))); + + /* Invalidate ISA and method caches */ + ++PL_sub_generation; + hv_clear(PL_stashcache); + PUSHMARK(SP); perl_call_sv(codesv, GIMME|G_EVAL|G_KEEPERR); /* use callers context */ + sv_free( (SV *) dummy_hv); /* get rid of what save_hash gave us*/ SPAGAIN; /* for the PUTBACK added by xsubpp */ LEAVE; @@ -270,7 +329,10 @@ int verify_opset(opset, fatal = 0) SV *opset int fatal - +CODE: + RETVAL = verify_opset(aTHX_ opset,fatal); +OUTPUT: + RETVAL void invert_opset(opset) @@ -278,8 +340,10 @@ invert_opset(opset) CODE: { char *bitmap; + dMY_CXT; STRLEN len = opset_len; - opset = sv_2mortal(new_opset(opset)); /* verify and clone opset */ + + opset = sv_2mortal(new_opset(aTHX_ opset)); /* verify and clone opset */ bitmap = SvPVX(opset); while(len-- > 0) bitmap[len] = ~bitmap[len]; @@ -298,11 +362,13 @@ PPCODE: { STRLEN len; int i, j, myopcode; - char *bitmap = SvPV(opset, len); + const char * const bitmap = SvPV(opset, len); char **names = (desc) ? get_op_descs() : get_op_names(); - verify_opset(opset,1); + dMY_CXT; + + verify_opset(aTHX_ opset,1); for (myopcode=0, i=0; i < opset_len; i++) { - U16 bits = bitmap[i]; + const U16 bits = bitmap[i]; for (j=0; j < 8 && myopcode < PL_maxo; j++, myopcode++) { if ( bits & (1 << j) ) XPUSHs(sv_2mortal(newSVpv(names[myopcode], 0))); @@ -314,25 +380,25 @@ PPCODE: void opset(...) CODE: - int i, j; - SV *bitspec, *opset; - char *bitmap; + int i; + SV *bitspec; STRLEN len, on; - opset = sv_2mortal(new_opset(Nullsv)); - bitmap = SvPVX(opset); + + SV * const opset = sv_2mortal(new_opset(aTHX_ Nullsv)); + char * const bitmap = SvPVX(opset); for (i = 0; i < items; i++) { - char *opname; + const char *opname; on = 1; - if (verify_opset(ST(i),0)) { + if (verify_opset(aTHX_ ST(i),0)) { opname = "(opset)"; bitspec = ST(i); } else { opname = SvPV(ST(i), len); if (*opname == '!') { on=0; ++opname;--len; } - bitspec = get_op_bitspec(opname, len, 1); + bitspec = get_op_bitspec(aTHX_ opname, len, 1); } - set_opset_bits(bitmap, bitspec, on, opname); + set_opset_bits(aTHX_ bitmap, bitspec, on, opname); } ST(0) = opset; @@ -348,22 +414,24 @@ ALIAS: deny_only = 2 deny = 3 CODE: - int i, on; + int i; SV *bitspec, *mask; - char *bitmap, *opname; + char *bitmap; STRLEN len; + dMY_CXT; if (!SvROK(safe) || !SvOBJECT(SvRV(safe)) || SvTYPE(SvRV(safe))!=SVt_PVHV) croak("Not a Safe object"); mask = *hv_fetch((HV*)SvRV(safe), "Mask",4, 1); if (ONLY_THESE) /* *_only = new mask, else edit current */ - sv_setsv(mask, sv_2mortal(new_opset(PERMITING ? opset_all : Nullsv))); + sv_setsv(mask, sv_2mortal(new_opset(aTHX_ PERMITING ? opset_all : Nullsv))); else - verify_opset(mask,1); /* croaks */ + verify_opset(aTHX_ mask,1); /* croaks */ bitmap = SvPVX(mask); for (i = 1; i < items; i++) { - on = PERMITING ? 0 : 1; /* deny = mask bit on */ - if (verify_opset(ST(i),0)) { /* it's a valid mask */ + const char *opname; + int on = PERMITING ? 0 : 1; /* deny = mask bit on */ + if (verify_opset(aTHX_ ST(i),0)) { /* it's a valid mask */ opname = "(opset)"; bitspec = ST(i); } @@ -371,9 +439,9 @@ CODE: opname = SvPV(ST(i), len); /* invert if op has ! prefix (only one allowed) */ if (*opname == '!') { on = !on; ++opname; --len; } - bitspec = get_op_bitspec(opname, len, 1); /* croaks */ + bitspec = get_op_bitspec(aTHX_ opname, len, 1); /* croaks */ } - set_opset_bits(bitmap, bitspec, on, opname); + set_opset_bits(aTHX_ bitmap, bitspec, on, opname); } ST(0) = &PL_sv_yes; @@ -382,28 +450,30 @@ CODE: void opdesc(...) PPCODE: - int i, myopcode; + int i; STRLEN len; SV **args; char **op_desc = get_op_descs(); + dMY_CXT; + /* copy args to a scratch area since we may push output values onto */ /* the stack faster than we read values off it if masks are used. */ - args = (SV**)SvPVX(sv_2mortal(newSVpv((char*)&ST(0), items*sizeof(SV*)))); + args = (SV**)SvPVX(sv_2mortal(newSVpvn((char*)&ST(0), items*sizeof(SV*)))); for (i = 0; i < items; i++) { - char *opname = SvPV(args[i], len); - SV *bitspec = get_op_bitspec(opname, len, 1); + const char * const opname = SvPV(args[i], len); + SV *bitspec = get_op_bitspec(aTHX_ opname, len, 1); if (SvIOK(bitspec)) { - myopcode = SvIV(bitspec); + const int myopcode = SvIV(bitspec); if (myopcode < 0 || myopcode >= PL_maxo) croak("panic: opcode %d (%s) out of range",myopcode,opname); XPUSHs(sv_2mortal(newSVpv(op_desc[myopcode], 0))); } - else if (SvPOK(bitspec) && SvCUR(bitspec) == opset_len) { + else if (SvPOK(bitspec) && SvCUR(bitspec) == (STRLEN)opset_len) { int b, j; - char *bitmap = SvPV(bitspec,PL_na); - myopcode = 0; + const char * const bitmap = SvPV_nolen_const(bitspec); + int myopcode = 0; for (b=0; b < opset_len; b++) { - U16 bits = bitmap[b]; + const U16 bits = bitmap[b]; for (j=0; j < 8 && myopcode < PL_maxo; j++, myopcode++) if (bits & (1 << j)) XPUSHs(sv_2mortal(newSVpv(op_desc[myopcode], 0))); @@ -421,27 +491,31 @@ define_optag(optagsv, mask) SV *mask CODE: STRLEN len; - char *optag = SvPV(optagsv, len); - put_op_bitspec(optag, len, mask); /* croaks */ + const char *optag = SvPV(optagsv, len); + + put_op_bitspec(aTHX_ optag, len, mask); /* croaks */ ST(0) = &PL_sv_yes; void empty_opset() CODE: - ST(0) = sv_2mortal(new_opset(Nullsv)); + ST(0) = sv_2mortal(new_opset(aTHX_ Nullsv)); void full_opset() CODE: - ST(0) = sv_2mortal(new_opset(opset_all)); + dMY_CXT; + ST(0) = sv_2mortal(new_opset(aTHX_ opset_all)); void opmask_add(opset) SV *opset PREINIT: if (!PL_op_mask) - Newz(0, PL_op_mask, PL_maxo, char); + Newxz(PL_op_mask, PL_maxo, char); +CODE: + opmask_add(aTHX_ opset); void opcodes() @@ -456,9 +530,9 @@ PPCODE: void opmask() CODE: - ST(0) = sv_2mortal(new_opset(Nullsv)); + ST(0) = sv_2mortal(new_opset(aTHX_ Nullsv)); if (PL_op_mask) { - char *bitmap = SvPVX(ST(0)); + char * const bitmap = SvPVX(ST(0)); int myopcode; for(myopcode=0; myopcode < PL_maxo; ++myopcode) { if (PL_op_mask[myopcode])