*/
static void
-op_names_init()
+op_names_init(void)
{
int i;
STRLEN len;
- char *opname;
+ char **op_names;
char *bitmap;
op_named_bits = newHV();
+ op_names = get_op_names();
for(i=0; i < maxo; ++i) {
- hv_store(op_named_bits, op_name[i],strlen(op_name[i]),
- Sv=newSViv(i), 0);
- SvREADONLY_on(Sv);
+ SV *sv;
+ 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)));
while(i-- > 0)
bitmap[i] = 0xFF;
/* Take care to set the right number of bits in the last byte */
- bitmap[len-1] = (maxo & 0x07) ? ~(~0 << (maxo & 0x07)) : 0xFF;
+ bitmap[len-1] = (maxo & 0x07) ? ~(0xFF << (maxo & 0x07)) : 0xFF;
put_op_bitspec(":all",0, opset_all); /* don't mortalise */
}
*/
static void
-put_op_bitspec(optag, len, mask)
- char *optag;
- STRLEN len;
- SV *mask;
+put_op_bitspec(char *optag, STRLEN len, SV *mask)
{
SV **svp;
verify_opset(mask,1);
*/
static SV *
-get_op_bitspec(opname, len, fatal)
- char *opname;
- STRLEN len;
- int fatal;
+get_op_bitspec(char *opname, STRLEN len, int fatal)
{
SV **svp;
if (!len)
static SV *
-new_opset(old_opset)
- SV *old_opset;
+new_opset(SV *old_opset)
{
SV *opset;
if (old_opset) {
opset = newSVsv(old_opset);
}
else {
- opset = newSV(opset_len);
- Zero(SvPVX(opset), opset_len, char);
+ opset = NEWSV(1156, opset_len);
+ Zero(SvPVX(opset), opset_len + 1, char);
SvCUR_set(opset, opset_len);
(void)SvPOK_only(opset);
}
static int
-verify_opset(opset, fatal)
- SV *opset;
- int fatal;
+verify_opset(SV *opset, int fatal)
{
char *err = Nullch;
if (!SvOK(opset)) err = "undefined";
static void
-set_opset_bits(bitmap, bitspec, on, opname)
- char *bitmap;
- SV *bitspec;
- int on;
- char *opname;
+set_opset_bits(char *bitmap, SV *bitspec, int on, char *opname)
{
if (SvIOK(bitspec)) {
int myopcode = SvIV(bitspec);
if (myopcode >= maxo || myopcode < 0)
croak("panic: opcode \"%s\" value %d is invalid", opname, myopcode);
if (opcode_debug >= 2)
- warn("set_opset_bits bit %2d (off=%d, bit=%d) %s on\n",
+ warn("set_opset_bits bit %2d (off=%d, bit=%d) %s %s\n",
myopcode, offset, bit, opname, (on)?"on":"off");
if (on)
bitmap[offset] |= 1 << bit;
while(len-- > 0) bitmap[len] &= ~specbits[len];
}
else
- croak("panic: invalid bitspec for \"%s\" (type %d)",
- opname, SvTYPE(bitspec));
+ croak("panic: invalid bitspec for \"%s\" (type %u)",
+ opname, (unsigned)SvTYPE(bitspec));
}
static void
-opmask_add(opset) /* THE ONLY FUNCTION TO EDIT op_mask ITSELF */
- SV *opset;
+opmask_add(SV *opset) /* THE ONLY FUNCTION TO EDIT op_mask ITSELF */
{
int i,j;
char *bitmask;
}
static void
-opmask_addlocal(opset, op_mask_buf) /* Localise op_mask then opmask_add() */
- SV *opset;
- char *op_mask_buf;
+opmask_addlocal(SV *opset, char *op_mask_buf) /* Localise op_mask then opmask_add() */
{
char *orig_op_mask = op_mask;
SAVEPPTR(op_mask);
if (opcode_debug >= 2)
- SAVEDESTRUCTOR((void(*)_((void*)))warn,"op_mask restored");
+ SAVEDESTRUCTOR((void(CPERLscope(*))_((void*)))warn,"op_mask restored");
op_mask = &op_mask_buf[0];
if (orig_op_mask)
Copy(orig_op_mask, op_mask, maxo, char);
assert(maxo < OP_MASK_BUF_SIZE);
opset_len = (maxo + 7) / 8;
if (opcode_debug >= 1)
- warn("opset_len %d\n", opset_len);
+ warn("opset_len %ld\n", (long)opset_len);
op_names_init();
void
-_safe_call_sv(package, mask, codesv)
- char * package
+_safe_call_sv(Package, mask, codesv)
+ char * Package
SV * mask
SV * codesv
PPCODE:
save_hptr(&defstash); /* save current default stack */
/* the assignment to global defstash changes our sense of 'main' */
- defstash = gv_stashpv(package, GV_ADDWARN); /* should exist already */
+ defstash = gv_stashpv(Package, GV_ADDWARN); /* should exist already */
/* defstash must itself contain a main:: so we'll add that now */
/* take care with the ref counts (was cause of long standing bug) */
while(len-- > 0)
bitmap[len] = ~bitmap[len];
/* take care of extra bits beyond maxo in last byte */
- bitmap[opset_len-1] &= ~(0xFF << (maxo & 0x0F));
+ if (maxo & 07)
+ bitmap[opset_len-1] &= ~(0xFF << (maxo & 0x07));
}
ST(0) = opset;
STRLEN len;
int i, j, myopcode;
char *bitmap = SvPV(opset, len);
- char **names = (desc) ? op_desc : op_name;
+ char **names = (desc) ? get_op_descs() : get_op_names();
verify_opset(opset,1);
for (myopcode=0, i=0; i < opset_len; i++) {
U16 bits = bitmap[i];
int i, myopcode;
STRLEN len;
SV **args;
+ char **op_desc = get_op_descs();
/* 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*))));
}
}
else
- croak("panic: invalid bitspec for \"%s\" (type %d)",
- opname, SvTYPE(bitspec));
+ croak("panic: invalid bitspec for \"%s\" (type %u)",
+ opname, (unsigned)SvTYPE(bitspec));
}