1N/A#define PERL_NO_GET_CONTEXT
1N/A#include "EXTERN.h"
1N/A#include "perl.h"
1N/A#include "XSUB.h"
1N/A
1N/A/* PL_maxo shouldn't differ from MAXO but leave room anyway (see BOOT:) */
1N/A#define OP_MASK_BUF_SIZE (MAXO + 100)
1N/A
1N/A/* XXX op_named_bits and opset_all are never freed */
1N/A#define MY_CXT_KEY "Opcode::_guts" XS_VERSION
1N/A
1N/Atypedef struct {
1N/A HV * x_op_named_bits; /* cache shared for whole process */
1N/A SV * x_opset_all; /* mask with all bits set */
1N/A IV x_opset_len; /* length of opmasks in bytes */
1N/A int x_opcode_debug;
1N/A} my_cxt_t;
1N/A
1N/ASTART_MY_CXT
1N/A
1N/A#define op_named_bits (MY_CXT.x_op_named_bits)
1N/A#define opset_all (MY_CXT.x_opset_all)
1N/A#define opset_len (MY_CXT.x_opset_len)
1N/A#define opcode_debug (MY_CXT.x_opcode_debug)
1N/A
1N/Astatic SV *new_opset (pTHX_ SV *old_opset);
1N/Astatic int verify_opset (pTHX_ SV *opset, int fatal);
1N/Astatic void set_opset_bits (pTHX_ char *bitmap, SV *bitspec, int on, char *opname);
1N/Astatic void put_op_bitspec (pTHX_ char *optag, STRLEN len, SV *opset);
1N/Astatic SV *get_op_bitspec (pTHX_ char *opname, STRLEN len, int fatal);
1N/A
1N/A
1N/A/* Initialise our private op_named_bits HV.
1N/A * It is first loaded with the name and number of each perl operator.
1N/A * Then the builtin tags :none and :all are added.
1N/A * Opcode.pm loads the standard optags from __DATA__
1N/A * XXX leak-alert: data allocated here is never freed, call this
1N/A * at most once
1N/A */
1N/A
1N/Astatic void
1N/Aop_names_init(pTHX)
1N/A{
1N/A int i;
1N/A STRLEN len;
1N/A char **op_names;
1N/A char *bitmap;
1N/A dMY_CXT;
1N/A
1N/A op_named_bits = newHV();
1N/A op_names = get_op_names();
1N/A for(i=0; i < PL_maxo; ++i) {
1N/A SV *sv;
1N/A sv = newSViv(i);
1N/A SvREADONLY_on(sv);
1N/A hv_store(op_named_bits, op_names[i], strlen(op_names[i]), sv, 0);
1N/A }
1N/A
1N/A put_op_bitspec(aTHX_ ":none",0, sv_2mortal(new_opset(aTHX_ Nullsv)));
1N/A
1N/A opset_all = new_opset(aTHX_ Nullsv);
1N/A bitmap = SvPV(opset_all, len);
1N/A i = len-1; /* deal with last byte specially, see below */
1N/A while(i-- > 0)
1N/A bitmap[i] = (char)0xFF;
1N/A /* Take care to set the right number of bits in the last byte */
1N/A bitmap[len-1] = (PL_maxo & 0x07) ? ~(0xFF << (PL_maxo & 0x07)) : 0xFF;
1N/A put_op_bitspec(aTHX_ ":all",0, opset_all); /* don't mortalise */
1N/A}
1N/A
1N/A
1N/A/* Store a new tag definition. Always a mask.
1N/A * The tag must not already be defined.
1N/A * SV *mask is copied not referenced.
1N/A */
1N/A
1N/Astatic void
1N/Aput_op_bitspec(pTHX_ char *optag, STRLEN len, SV *mask)
1N/A{
1N/A SV **svp;
1N/A dMY_CXT;
1N/A
1N/A verify_opset(aTHX_ mask,1);
1N/A if (!len)
1N/A len = strlen(optag);
1N/A svp = hv_fetch(op_named_bits, optag, len, 1);
1N/A if (SvOK(*svp))
1N/A croak("Opcode tag \"%s\" already defined", optag);
1N/A sv_setsv(*svp, mask);
1N/A SvREADONLY_on(*svp);
1N/A}
1N/A
1N/A
1N/A
1N/A/* Fetch a 'bits' entry for an opname or optag (IV/PV).
1N/A * Note that we return the actual entry for speed.
1N/A * Always sv_mortalcopy() if returing it to user code.
1N/A */
1N/A
1N/Astatic SV *
1N/Aget_op_bitspec(pTHX_ char *opname, STRLEN len, int fatal)
1N/A{
1N/A SV **svp;
1N/A dMY_CXT;
1N/A
1N/A if (!len)
1N/A len = strlen(opname);
1N/A svp = hv_fetch(op_named_bits, opname, len, 0);
1N/A if (!svp || !SvOK(*svp)) {
1N/A if (!fatal)
1N/A return Nullsv;
1N/A if (*opname == ':')
1N/A croak("Unknown operator tag \"%s\"", opname);
1N/A if (*opname == '!') /* XXX here later, or elsewhere? */
1N/A croak("Can't negate operators here (\"%s\")", opname);
1N/A if (isALPHA(*opname))
1N/A croak("Unknown operator name \"%s\"", opname);
1N/A croak("Unknown operator prefix \"%s\"", opname);
1N/A }
1N/A return *svp;
1N/A}
1N/A
1N/A
1N/A
1N/Astatic SV *
1N/Anew_opset(pTHX_ SV *old_opset)
1N/A{
1N/A SV *opset;
1N/A dMY_CXT;
1N/A
1N/A if (old_opset) {
1N/A verify_opset(aTHX_ old_opset,1);
1N/A opset = newSVsv(old_opset);
1N/A }
1N/A else {
1N/A opset = NEWSV(1156, opset_len);
1N/A Zero(SvPVX(opset), opset_len + 1, char);
1N/A SvCUR_set(opset, opset_len);
1N/A (void)SvPOK_only(opset);
1N/A }
1N/A /* not mortalised here */
1N/A return opset;
1N/A}
1N/A
1N/A
1N/Astatic int
1N/Averify_opset(pTHX_ SV *opset, int fatal)
1N/A{
1N/A char *err = Nullch;
1N/A dMY_CXT;
1N/A
1N/A if (!SvOK(opset)) err = "undefined";
1N/A else if (!SvPOK(opset)) err = "wrong type";
1N/A else if (SvCUR(opset) != (STRLEN)opset_len) err = "wrong size";
1N/A if (err && fatal) {
1N/A croak("Invalid opset: %s", err);
1N/A }
1N/A return !err;
1N/A}
1N/A
1N/A
1N/Astatic void
1N/Aset_opset_bits(pTHX_ char *bitmap, SV *bitspec, int on, char *opname)
1N/A{
1N/A dMY_CXT;
1N/A
1N/A if (SvIOK(bitspec)) {
1N/A int myopcode = SvIV(bitspec);
1N/A int offset = myopcode >> 3;
1N/A int bit = myopcode & 0x07;
1N/A if (myopcode >= PL_maxo || myopcode < 0)
1N/A croak("panic: opcode \"%s\" value %d is invalid", opname, myopcode);
1N/A if (opcode_debug >= 2)
1N/A warn("set_opset_bits bit %2d (off=%d, bit=%d) %s %s\n",
1N/A myopcode, offset, bit, opname, (on)?"on":"off");
1N/A if (on)
1N/A bitmap[offset] |= 1 << bit;
1N/A else
1N/A bitmap[offset] &= ~(1 << bit);
1N/A }
1N/A else if (SvPOK(bitspec) && SvCUR(bitspec) == (STRLEN)opset_len) {
1N/A
1N/A STRLEN len;
1N/A char *specbits = SvPV(bitspec, len);
1N/A if (opcode_debug >= 2)
1N/A warn("set_opset_bits opset %s %s\n", opname, (on)?"on":"off");
1N/A if (on)
1N/A while(len-- > 0) bitmap[len] |= specbits[len];
1N/A else
1N/A while(len-- > 0) bitmap[len] &= ~specbits[len];
1N/A }
1N/A else
1N/A croak("panic: invalid bitspec for \"%s\" (type %u)",
1N/A opname, (unsigned)SvTYPE(bitspec));
1N/A}
1N/A
1N/A
1N/Astatic void
1N/Aopmask_add(pTHX_ SV *opset) /* THE ONLY FUNCTION TO EDIT PL_op_mask ITSELF */
1N/A{
1N/A int i,j;
1N/A char *bitmask;
1N/A STRLEN len;
1N/A int myopcode = 0;
1N/A dMY_CXT;
1N/A
1N/A verify_opset(aTHX_ opset,1); /* croaks on bad opset */
1N/A
1N/A if (!PL_op_mask) /* caller must ensure PL_op_mask exists */
1N/A croak("Can't add to uninitialised PL_op_mask");
1N/A
1N/A /* OPCODES ALREADY MASKED ARE NEVER UNMASKED. See opmask_addlocal() */
1N/A
1N/A bitmask = SvPV(opset, len);
1N/A for (i=0; i < opset_len; i++) {
1N/A U16 bits = bitmask[i];
1N/A if (!bits) { /* optimise for sparse masks */
1N/A myopcode += 8;
1N/A continue;
1N/A }
1N/A for (j=0; j < 8 && myopcode < PL_maxo; )
1N/A PL_op_mask[myopcode++] |= bits & (1 << j++);
1N/A }
1N/A}
1N/A
1N/Astatic void
1N/Aopmask_addlocal(pTHX_ SV *opset, char *op_mask_buf) /* Localise PL_op_mask then opmask_add() */
1N/A{
1N/A char *orig_op_mask = PL_op_mask;
1N/A dMY_CXT;
1N/A
1N/A SAVEVPTR(PL_op_mask);
1N/A /* XXX casting to an ordinary function ptr from a member function ptr
1N/A * is disallowed by Borland
1N/A */
1N/A if (opcode_debug >= 2)
1N/A SAVEDESTRUCTOR((void(*)(void*))Perl_warn,"PL_op_mask restored");
1N/A PL_op_mask = &op_mask_buf[0];
1N/A if (orig_op_mask)
1N/A Copy(orig_op_mask, PL_op_mask, PL_maxo, char);
1N/A else
1N/A Zero(PL_op_mask, PL_maxo, char);
1N/A opmask_add(aTHX_ opset);
1N/A}
1N/A
1N/A
1N/A
1N/AMODULE = Opcode PACKAGE = Opcode
1N/A
1N/APROTOTYPES: ENABLE
1N/A
1N/ABOOT:
1N/A{
1N/A MY_CXT_INIT;
1N/A assert(PL_maxo < OP_MASK_BUF_SIZE);
1N/A opset_len = (PL_maxo + 7) / 8;
1N/A if (opcode_debug >= 1)
1N/A warn("opset_len %ld\n", (long)opset_len);
1N/A op_names_init(aTHX);
1N/A}
1N/A
1N/Avoid
1N/A_safe_pkg_prep(Package)
1N/A char * Package
1N/APPCODE:
1N/A HV *hv;
1N/A ENTER;
1N/A
1N/A hv = gv_stashpv(Package, GV_ADDWARN); /* should exist already */
1N/A
1N/A if (strNE(HvNAME(hv),"main")) {
1N/A Safefree(HvNAME(hv));
1N/A HvNAME(hv) = savepv("main"); /* make it think it's in main:: */
1N/A hv_store(hv,"_",1,(SV *)PL_defgv,0); /* connect _ to global */
1N/A SvREFCNT_inc((SV *)PL_defgv); /* want to keep _ around! */
1N/A }
1N/A LEAVE;
1N/A
1N/A
1N/A
1N/A
1N/A
1N/Avoid
1N/A_safe_call_sv(Package, mask, codesv)
1N/A char * Package
1N/A SV * mask
1N/A SV * codesv
1N/APPCODE:
1N/A char op_mask_buf[OP_MASK_BUF_SIZE];
1N/A GV *gv;
1N/A HV *dummy_hv;
1N/A
1N/A ENTER;
1N/A
1N/A opmask_addlocal(aTHX_ mask, op_mask_buf);
1N/A
1N/A save_aptr(&PL_endav);
1N/A PL_endav = (AV*)sv_2mortal((SV*)newAV()); /* ignore END blocks for now */
1N/A
1N/A save_hptr(&PL_defstash); /* save current default stash */
1N/A /* the assignment to global defstash changes our sense of 'main' */
1N/A PL_defstash = gv_stashpv(Package, GV_ADDWARN); /* should exist already */
1N/A
1N/A save_hptr(&PL_curstash);
1N/A PL_curstash = PL_defstash;
1N/A
1N/A /* defstash must itself contain a main:: so we'll add that now */
1N/A /* take care with the ref counts (was cause of long standing bug) */
1N/A /* XXX I'm still not sure if this is right, GV_ADDWARN should warn! */
1N/A gv = gv_fetchpv("main::", GV_ADDWARN, SVt_PVHV);
1N/A sv_free((SV*)GvHV(gv));
1N/A GvHV(gv) = (HV*)SvREFCNT_inc(PL_defstash);
1N/A
1N/A /* %INC must be clean for use/require in compartment */
1N/A dummy_hv = save_hash(PL_incgv);
1N/A GvHV(PL_incgv) = (HV*)SvREFCNT_inc(GvHV(gv_HVadd(gv_fetchpv("INC",TRUE,SVt_PVHV))));
1N/A
1N/A PUSHMARK(SP);
1N/A perl_call_sv(codesv, GIMME|G_EVAL|G_KEEPERR); /* use callers context */
1N/A sv_free( (SV *) dummy_hv); /* get rid of what save_hash gave us*/
1N/A SPAGAIN; /* for the PUTBACK added by xsubpp */
1N/A LEAVE;
1N/A
1N/A
1N/Aint
1N/Averify_opset(opset, fatal = 0)
1N/A SV *opset
1N/A int fatal
1N/ACODE:
1N/A RETVAL = verify_opset(aTHX_ opset,fatal);
1N/AOUTPUT:
1N/A RETVAL
1N/A
1N/Avoid
1N/Ainvert_opset(opset)
1N/A SV *opset
1N/ACODE:
1N/A {
1N/A char *bitmap;
1N/A dMY_CXT;
1N/A STRLEN len = opset_len;
1N/A
1N/A opset = sv_2mortal(new_opset(aTHX_ opset)); /* verify and clone opset */
1N/A bitmap = SvPVX(opset);
1N/A while(len-- > 0)
1N/A bitmap[len] = ~bitmap[len];
1N/A /* take care of extra bits beyond PL_maxo in last byte */
1N/A if (PL_maxo & 07)
1N/A bitmap[opset_len-1] &= ~(0xFF << (PL_maxo & 0x07));
1N/A }
1N/A ST(0) = opset;
1N/A
1N/A
1N/Avoid
1N/Aopset_to_ops(opset, desc = 0)
1N/A SV *opset
1N/A int desc
1N/APPCODE:
1N/A {
1N/A STRLEN len;
1N/A int i, j, myopcode;
1N/A char *bitmap = SvPV(opset, len);
1N/A char **names = (desc) ? get_op_descs() : get_op_names();
1N/A dMY_CXT;
1N/A
1N/A verify_opset(aTHX_ opset,1);
1N/A for (myopcode=0, i=0; i < opset_len; i++) {
1N/A U16 bits = bitmap[i];
1N/A for (j=0; j < 8 && myopcode < PL_maxo; j++, myopcode++) {
1N/A if ( bits & (1 << j) )
1N/A XPUSHs(sv_2mortal(newSVpv(names[myopcode], 0)));
1N/A }
1N/A }
1N/A }
1N/A
1N/A
1N/Avoid
1N/Aopset(...)
1N/ACODE:
1N/A int i;
1N/A SV *bitspec, *opset;
1N/A char *bitmap;
1N/A STRLEN len, on;
1N/A
1N/A opset = sv_2mortal(new_opset(aTHX_ Nullsv));
1N/A bitmap = SvPVX(opset);
1N/A for (i = 0; i < items; i++) {
1N/A char *opname;
1N/A on = 1;
1N/A if (verify_opset(aTHX_ ST(i),0)) {
1N/A opname = "(opset)";
1N/A bitspec = ST(i);
1N/A }
1N/A else {
1N/A opname = SvPV(ST(i), len);
1N/A if (*opname == '!') { on=0; ++opname;--len; }
1N/A bitspec = get_op_bitspec(aTHX_ opname, len, 1);
1N/A }
1N/A set_opset_bits(aTHX_ bitmap, bitspec, on, opname);
1N/A }
1N/A ST(0) = opset;
1N/A
1N/A
1N/A#define PERMITING (ix == 0 || ix == 1)
1N/A#define ONLY_THESE (ix == 0 || ix == 2)
1N/A
1N/Avoid
1N/Apermit_only(safe, ...)
1N/A SV *safe
1N/AALIAS:
1N/A permit = 1
1N/A deny_only = 2
1N/A deny = 3
1N/ACODE:
1N/A int i, on;
1N/A SV *bitspec, *mask;
1N/A char *bitmap, *opname;
1N/A STRLEN len;
1N/A dMY_CXT;
1N/A
1N/A if (!SvROK(safe) || !SvOBJECT(SvRV(safe)) || SvTYPE(SvRV(safe))!=SVt_PVHV)
1N/A croak("Not a Safe object");
1N/A mask = *hv_fetch((HV*)SvRV(safe), "Mask",4, 1);
1N/A if (ONLY_THESE) /* *_only = new mask, else edit current */
1N/A sv_setsv(mask, sv_2mortal(new_opset(aTHX_ PERMITING ? opset_all : Nullsv)));
1N/A else
1N/A verify_opset(aTHX_ mask,1); /* croaks */
1N/A bitmap = SvPVX(mask);
1N/A for (i = 1; i < items; i++) {
1N/A on = PERMITING ? 0 : 1; /* deny = mask bit on */
1N/A if (verify_opset(aTHX_ ST(i),0)) { /* it's a valid mask */
1N/A opname = "(opset)";
1N/A bitspec = ST(i);
1N/A }
1N/A else { /* it's an opname/optag */
1N/A opname = SvPV(ST(i), len);
1N/A /* invert if op has ! prefix (only one allowed) */
1N/A if (*opname == '!') { on = !on; ++opname; --len; }
1N/A bitspec = get_op_bitspec(aTHX_ opname, len, 1); /* croaks */
1N/A }
1N/A set_opset_bits(aTHX_ bitmap, bitspec, on, opname);
1N/A }
1N/A ST(0) = &PL_sv_yes;
1N/A
1N/A
1N/A
1N/Avoid
1N/Aopdesc(...)
1N/APPCODE:
1N/A int i, myopcode;
1N/A STRLEN len;
1N/A SV **args;
1N/A char **op_desc = get_op_descs();
1N/A dMY_CXT;
1N/A
1N/A /* copy args to a scratch area since we may push output values onto */
1N/A /* the stack faster than we read values off it if masks are used. */
1N/A args = (SV**)SvPVX(sv_2mortal(newSVpvn((char*)&ST(0), items*sizeof(SV*))));
1N/A for (i = 0; i < items; i++) {
1N/A char *opname = SvPV(args[i], len);
1N/A SV *bitspec = get_op_bitspec(aTHX_ opname, len, 1);
1N/A if (SvIOK(bitspec)) {
1N/A myopcode = SvIV(bitspec);
1N/A if (myopcode < 0 || myopcode >= PL_maxo)
1N/A croak("panic: opcode %d (%s) out of range",myopcode,opname);
1N/A XPUSHs(sv_2mortal(newSVpv(op_desc[myopcode], 0)));
1N/A }
1N/A else if (SvPOK(bitspec) && SvCUR(bitspec) == (STRLEN)opset_len) {
1N/A int b, j;
1N/A STRLEN n_a;
1N/A char *bitmap = SvPV(bitspec,n_a);
1N/A myopcode = 0;
1N/A for (b=0; b < opset_len; b++) {
1N/A U16 bits = bitmap[b];
1N/A for (j=0; j < 8 && myopcode < PL_maxo; j++, myopcode++)
1N/A if (bits & (1 << j))
1N/A XPUSHs(sv_2mortal(newSVpv(op_desc[myopcode], 0)));
1N/A }
1N/A }
1N/A else
1N/A croak("panic: invalid bitspec for \"%s\" (type %u)",
1N/A opname, (unsigned)SvTYPE(bitspec));
1N/A }
1N/A
1N/A
1N/Avoid
1N/Adefine_optag(optagsv, mask)
1N/A SV *optagsv
1N/A SV *mask
1N/ACODE:
1N/A STRLEN len;
1N/A char *optag = SvPV(optagsv, len);
1N/A
1N/A put_op_bitspec(aTHX_ optag, len, mask); /* croaks */
1N/A ST(0) = &PL_sv_yes;
1N/A
1N/A
1N/Avoid
1N/Aempty_opset()
1N/ACODE:
1N/A ST(0) = sv_2mortal(new_opset(aTHX_ Nullsv));
1N/A
1N/Avoid
1N/Afull_opset()
1N/ACODE:
1N/A dMY_CXT;
1N/A ST(0) = sv_2mortal(new_opset(aTHX_ opset_all));
1N/A
1N/Avoid
1N/Aopmask_add(opset)
1N/A SV *opset
1N/APREINIT:
1N/A if (!PL_op_mask)
1N/A Newz(0, PL_op_mask, PL_maxo, char);
1N/ACODE:
1N/A opmask_add(aTHX_ opset);
1N/A
1N/Avoid
1N/Aopcodes()
1N/APPCODE:
1N/A if (GIMME == G_ARRAY) {
1N/A croak("opcodes in list context not yet implemented"); /* XXX */
1N/A }
1N/A else {
1N/A XPUSHs(sv_2mortal(newSViv(PL_maxo)));
1N/A }
1N/A
1N/Avoid
1N/Aopmask()
1N/ACODE:
1N/A ST(0) = sv_2mortal(new_opset(aTHX_ Nullsv));
1N/A if (PL_op_mask) {
1N/A char *bitmap = SvPVX(ST(0));
1N/A int myopcode;
1N/A for(myopcode=0; myopcode < PL_maxo; ++myopcode) {
1N/A if (PL_op_mask[myopcode])
1N/A bitmap[myopcode >> 3] |= 1 << (myopcode & 0x07);
1N/A }
1N/A }
1N/A