static const char* const svclassnames[] = {
"B::NULL",
+#if PERL_VERSION >= 9
+ "B::BIND",
+#endif
"B::IV",
"B::NV",
+#if PERL_VERSION <= 10
"B::RV",
+#endif
"B::PV",
"B::PVIV",
"B::PVNV",
"B::PVMG",
+#if PERL_VERSION <= 8
"B::BM",
+#endif
+#if PERL_VERSION >= 11
+ "B::REGEXP",
+#endif
#if PERL_VERSION >= 9
"B::GV",
#endif
return (char *)opclassnames[cc_opclass(aTHX_ o)];
}
+/* FIXME - figure out how to get the typemap to assign this to ST(0), rather
+ than creating a new mortal for ST(0) then passing it in as the first
+ argument. */
static SV *
make_sv_object(pTHX_ SV *arg, SV *sv)
{
const char *type = 0;
IV iv;
dMY_CXT;
-
+
+ if (!arg)
+ arg = sv_newmortal();
+
for (iv = 0; iv < sizeof(specialsv_list)/sizeof(SV*); iv++) {
if (sv == specialsv_list[iv]) {
type = "B::SPECIAL";
return arg;
}
+#if PERL_VERSION >= 9
static SV *
-make_temp_object(pTHX_ SV *arg, SV *temp)
+make_temp_object(pTHX_ SV *temp)
{
SV *target;
+ SV *arg = sv_newmortal();
const char *const type = svclassnames[SvTYPE(temp)];
const IV iv = PTR2IV(temp);
}
static SV *
-make_warnings_object(pTHX_ SV *arg, STRLEN *warnings)
+make_warnings_object(pTHX_ STRLEN *warnings)
{
const char *type = 0;
dMY_CXT;
}
}
if (type) {
+ SV *arg = sv_newmortal();
sv_setiv(newSVrv(arg, type), iv);
return arg;
} else {
/* B assumes that warnings are a regular SV. Seems easier to keep it
happy by making them into a regular SV. */
- return make_temp_object(aTHX_ arg,
- newSVpvn((char *)(warnings + 1), *warnings));
+ return make_temp_object(aTHX_ newSVpvn((char *)(warnings + 1), *warnings));
}
}
static SV *
-make_cop_io_object(pTHX_ SV *arg, COP *cop)
+make_cop_io_object(pTHX_ COP *cop)
{
- if (CopHINTS_get(cop) & HINT_LEXICAL_IO) {
- /* I feel you should be able to simply SvREFCNT_inc the return value
- from this, but if you do (and restore the line
- my $ioix = $cop->io->ix;
- in B::COP::bsave in Bytecode.pm, then you get errors about
- "attempt to free temp prematurely ... during global destruction.
- The SV's flags are consistent with the error, but quite how the
- temp escaped from the save stack is not clear. */
- SV *value = Perl_refcounted_he_fetch(aTHX_ cop->cop_hints_hash,
- 0, "open", 4, 0, 0);
- return make_temp_object(aTHX_ arg, newSVsv(value));
+ SV *const value = newSV(0);
+
+ Perl_emulate_cop_io(aTHX_ cop, value);
+
+ if(SvOK(value)) {
+ return make_sv_object(aTHX_ NULL, value);
} else {
- return make_sv_object(aTHX_ arg, NULL);
+ SvREFCNT_dec(value);
+ return make_sv_object(aTHX_ NULL, NULL);
}
}
+#endif
static SV *
-make_mg_object(pTHX_ SV *arg, MAGIC *mg)
+make_mg_object(pTHX_ MAGIC *mg)
{
+ SV *arg = sv_newmortal();
sv_setiv(newSVrv(arg, "B::MAGIC"), PTR2IV(mg));
return arg;
}
static SV *
cstring(pTHX_ SV *sv, bool perlstyle)
{
- SV *sstr = newSVpvn("", 0);
+ SV *sstr;
if (!SvOK(sv))
- sv_setpvn(sstr, "0", 1);
- else if (perlstyle && SvUTF8(sv)) {
+ return newSVpvs_flags("0", SVs_TEMP);
+
+ sstr = newSVpvs_flags("\"", SVs_TEMP);
+
+ if (perlstyle && SvUTF8(sv)) {
SV *tmpsv = sv_newmortal(); /* Temporary SV to feed sv_uni_display */
const STRLEN len = SvCUR(sv);
const char *s = sv_uni_display(tmpsv, sv, 8*len, UNI_DISPLAY_QQ);
- sv_setpvn(sstr,"\"",1);
while (*s)
{
if (*s == '"')
- sv_catpvn(sstr, "\\\"", 2);
+ sv_catpvs(sstr, "\\\"");
else if (*s == '$')
- sv_catpvn(sstr, "\\$", 2);
+ sv_catpvs(sstr, "\\$");
else if (*s == '@')
- sv_catpvn(sstr, "\\@", 2);
+ sv_catpvs(sstr, "\\@");
else if (*s == '\\')
{
if (strchr("nrftax\\",*(s+1)))
sv_catpvn(sstr, s++, 2);
else
- sv_catpvn(sstr, "\\\\", 2);
+ sv_catpvs(sstr, "\\\\");
}
else /* should always be printable */
sv_catpvn(sstr, s, 1);
++s;
}
- sv_catpv(sstr, "\"");
- return sstr;
}
else
{
/* XXX Optimise? */
STRLEN len;
const char *s = SvPV(sv, len);
- sv_catpv(sstr, "\"");
for (; len; len--, s++)
{
/* At least try a little for readability */
if (*s == '"')
- sv_catpv(sstr, "\\\"");
+ sv_catpvs(sstr, "\\\"");
else if (*s == '\\')
- sv_catpv(sstr, "\\\\");
+ sv_catpvs(sstr, "\\\\");
/* trigraphs - bleagh */
else if (!perlstyle && *s == '?' && len>=3 && s[1] == '?') {
- char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
- sprintf(escbuff, "\\%03o", '?');
- sv_catpv(sstr, escbuff);
+ Perl_sv_catpvf(aTHX_ sstr, "\\%03o", '?');
}
else if (perlstyle && *s == '$')
- sv_catpv(sstr, "\\$");
+ sv_catpvs(sstr, "\\$");
else if (perlstyle && *s == '@')
- sv_catpv(sstr, "\\@");
+ sv_catpvs(sstr, "\\@");
#ifdef EBCDIC
else if (isPRINT(*s))
#else
#endif /* EBCDIC */
sv_catpvn(sstr, s, 1);
else if (*s == '\n')
- sv_catpv(sstr, "\\n");
+ sv_catpvs(sstr, "\\n");
else if (*s == '\r')
- sv_catpv(sstr, "\\r");
+ sv_catpvs(sstr, "\\r");
else if (*s == '\t')
- sv_catpv(sstr, "\\t");
+ sv_catpvs(sstr, "\\t");
else if (*s == '\a')
- sv_catpv(sstr, "\\a");
+ sv_catpvs(sstr, "\\a");
else if (*s == '\b')
- sv_catpv(sstr, "\\b");
+ sv_catpvs(sstr, "\\b");
else if (*s == '\f')
- sv_catpv(sstr, "\\f");
+ sv_catpvs(sstr, "\\f");
else if (!perlstyle && *s == '\v')
- sv_catpv(sstr, "\\v");
+ sv_catpvs(sstr, "\\v");
else
{
/* Don't want promotion of a signed -1 char in sprintf args */
- char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
const unsigned char c = (unsigned char) *s;
- sprintf(escbuff, "\\%03o", c);
- sv_catpv(sstr, escbuff);
+ Perl_sv_catpvf(aTHX_ sstr, "\\%03o", c);
}
/* XXX Add line breaks if string is long */
}
- sv_catpv(sstr, "\"");
}
+ sv_catpvs(sstr, "\"");
return sstr;
}
static SV *
cchar(pTHX_ SV *sv)
{
- SV *sstr = newSVpvn("'", 1);
+ SV *sstr = newSVpvs_flags("'", SVs_TEMP);
const char *s = SvPV_nolen(sv);
+ /* Don't want promotion of a signed -1 char in sprintf args */
+ const unsigned char c = (unsigned char) *s;
- if (*s == '\'')
- sv_catpvn(sstr, "\\'", 2);
- else if (*s == '\\')
- sv_catpvn(sstr, "\\\\", 2);
+ if (c == '\'')
+ sv_catpvs(sstr, "\\'");
+ else if (c == '\\')
+ sv_catpvs(sstr, "\\\\");
#ifdef EBCDIC
- else if (isPRINT(*s))
+ else if (isPRINT(c))
#else
- else if (*s >= ' ' && *s < 127)
+ else if (c >= ' ' && c < 127)
#endif /* EBCDIC */
sv_catpvn(sstr, s, 1);
- else if (*s == '\n')
- sv_catpvn(sstr, "\\n", 2);
- else if (*s == '\r')
- sv_catpvn(sstr, "\\r", 2);
- else if (*s == '\t')
- sv_catpvn(sstr, "\\t", 2);
- else if (*s == '\a')
- sv_catpvn(sstr, "\\a", 2);
- else if (*s == '\b')
- sv_catpvn(sstr, "\\b", 2);
- else if (*s == '\f')
- sv_catpvn(sstr, "\\f", 2);
- else if (*s == '\v')
- sv_catpvn(sstr, "\\v", 2);
+ else if (c == '\n')
+ sv_catpvs(sstr, "\\n");
+ else if (c == '\r')
+ sv_catpvs(sstr, "\\r");
+ else if (c == '\t')
+ sv_catpvs(sstr, "\\t");
+ else if (c == '\a')
+ sv_catpvs(sstr, "\\a");
+ else if (c == '\b')
+ sv_catpvs(sstr, "\\b");
+ else if (c == '\f')
+ sv_catpvs(sstr, "\\f");
+ else if (c == '\v')
+ sv_catpvs(sstr, "\\v");
else
- {
- /* no trigraph support */
- char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
- /* Don't want promotion of a signed -1 char in sprintf args */
- unsigned char c = (unsigned char) *s;
- sprintf(escbuff, "\\%03o", c);
- sv_catpv(sstr, escbuff);
- }
- sv_catpvn(sstr, "'", 1);
+ Perl_sv_catpvf(aTHX_ sstr, "\\%03o", c);
+ sv_catpvs(sstr, "'");
return sstr;
}
+#if PERL_VERSION >= 9
+# define PMOP_pmreplstart(o) o->op_pmstashstartu.op_pmreplstart
+# define PMOP_pmreplroot(o) o->op_pmreplrootu.op_pmreplroot
+#else
+# define PMOP_pmreplstart(o) o->op_pmreplstart
+# define PMOP_pmreplroot(o) o->op_pmreplroot
+# define PMOP_pmpermflags(o) o->op_pmpermflags
+# define PMOP_pmdynflags(o) o->op_pmdynflags
+#endif
+
static void
walkoptree(pTHX_ SV *opsv, const char *method)
{
}
}
if (o && (cc_opclass(aTHX_ o) == OPc_PMOP) && o->op_type != OP_PUSHRE
- && (kid = cPMOPo->op_pmreplroot))
+ && (kid = PMOP_pmreplroot(cPMOPo)))
{
sv_setiv(newSVrv(opsv, cc_opclassname(aTHX_ kid)), PTR2IV(kid));
walkoptree(aTHX_ opsv, method);
XPUSHs(opsv);
switch (o->op_type) {
case OP_SUBST:
- SP = oplist(aTHX_ cPMOPo->op_pmreplstart, SP);
+ SP = oplist(aTHX_ PMOP_pmreplstart(cPMOPo), SP);
continue;
case OP_SORT:
if (o->op_flags & OPf_STACKED && o->op_flags & OPf_SPECIAL) {
typedef SV *B__PV;
typedef SV *B__NV;
typedef SV *B__PVMG;
+#if PERL_VERSION >= 11
+typedef SV *B__REGEXP;
+#endif
typedef SV *B__PVLV;
typedef SV *B__BM;
typedef SV *B__RV;
typedef MAGIC *B__MAGIC;
typedef HE *B__HE;
+#if PERL_VERSION >= 9
typedef struct refcounted_he *B__RHE;
+#endif
+
+#include "const-c.inc"
MODULE = B PACKAGE = B PREFIX = B_
+INCLUDE: const-xs.inc
+
PROTOTYPES: DISABLE
BOOT:
{
- HV *stash = gv_stashpvn("B", 1, TRUE);
- AV *export_ok = perl_get_av("B::EXPORT_OK",TRUE);
+ HV *stash = gv_stashpvs("B", GV_ADD);
+ AV *export_ok = perl_get_av("B::EXPORT_OK", GV_ADD);
MY_CXT_INIT;
specialsv_list[0] = Nullsv;
specialsv_list[1] = &PL_sv_undef;
specialsv_list[5] = (SV *) pWARN_NONE;
specialsv_list[6] = (SV *) pWARN_STD;
#if PERL_VERSION <= 8
-# define CVf_ASSERTION 0
+# define OPpPAD_STATE 0
#endif
-#include "defsubs.h"
}
#define B_main_cv() PL_main_cv
#define B_init_av() PL_initav
#define B_inc_gv() PL_incgv
#define B_check_av() PL_checkav_save
-#define B_unitcheck_av() PL_unitcheckav_save
+#if PERL_VERSION > 8
+# define B_unitcheck_av() PL_unitcheckav_save
+#else
+# define B_unitcheck_av() NULL
+#endif
#define B_begin_av() PL_beginav_save
#define B_end_av() PL_endav
#define B_main_root() PL_main_root
B::AV
B_check_av()
+#if PERL_VERSION >= 9
+
B::AV
B_unitcheck_av()
+#endif
+
B::AV
B_begin_av()
void
B_warnhook()
CODE:
- ST(0) = make_sv_object(aTHX_ sv_newmortal(), PL_warnhook);
+ ST(0) = make_sv_object(aTHX_ NULL, PL_warnhook);
void
B_diehook()
CODE:
- ST(0) = make_sv_object(aTHX_ sv_newmortal(), PL_diehook);
+ ST(0) = make_sv_object(aTHX_ NULL, PL_diehook);
MODULE = B PACKAGE = B
CODE:
ST(0) = sv_newmortal();
if (opnum >= 0 && opnum < PL_maxo) {
- sv_setpvn(ST(0), "pp_", 3);
+ sv_setpvs(ST(0), "pp_");
sv_catpv(ST(0), PL_op_name[opnum]);
}
CODE:
STRLEN len;
U32 hash = 0;
- char hexhash[19]; /* must fit "0xffffffffffffffff" plus trailing \0 */
- const char *s = SvPV(sv, len);
+ const char *s = SvPVbyte(sv, len);
PERL_HASH(hash, s, len);
- sprintf(hexhash, "0x%"UVxf, (UV)hash);
- ST(0) = sv_2mortal(newSVpv(hexhash, 0));
+ ST(0) = sv_2mortal(Perl_newSVpvf(aTHX_ "0x%"UVxf, (UV)hash));
#define cast_I32(foo) (I32)foo
IV
SV *
cstring(sv)
SV * sv
- CODE:
- RETVAL = cstring(aTHX_ sv, 0);
- OUTPUT:
- RETVAL
-
-SV *
-perlstring(sv)
- SV * sv
- CODE:
- RETVAL = cstring(aTHX_ sv, 1);
- OUTPUT:
- RETVAL
-
-SV *
-cchar(sv)
- SV * sv
- CODE:
- RETVAL = cchar(aTHX_ sv);
- OUTPUT:
- RETVAL
+ ALIAS:
+ perlstring = 1
+ cchar = 2
+ PPCODE:
+ PUSHs(ix == 2 ? cchar(aTHX_ sv) : cstring(aTHX_ sv, ix));
void
threadsv_names()
EXTEND(sp, len);
for (i = 0; i < len; i++)
- PUSHs(sv_2mortal(newSVpvn(&PL_threadsv_names[i], 1)));
+ PUSHs(newSVpvn_flags(&PL_threadsv_names[i], 1, SVs_TEMP));
# endif
#endif
#define OP_next(o) o->op_next
#define OP_sibling(o) o->op_sibling
-#define OP_desc(o) (char *)PL_op_desc[o->op_type]
#define OP_targ(o) o->op_targ
-#define OP_type(o) o->op_type
-#if PERL_VERSION >= 9
-# define OP_opt(o) o->op_opt
-# define OP_static(o) o->op_static
-#else
-# define OP_seq(o) o->op_seq
-#endif
#define OP_flags(o) o->op_flags
#define OP_private(o) o->op_private
-#define OP_spare(o) o->op_spare
MODULE = B PACKAGE = B::OP PREFIX = OP_
char *
OP_name(o)
B::OP o
+ ALIAS:
+ desc = 1
CODE:
- RETVAL = (char *)PL_op_name[o->op_type];
+ RETVAL = (char *)(ix ? PL_op_desc : PL_op_name)[o->op_type];
OUTPUT:
RETVAL
-
void
OP_ppaddr(o)
B::OP o
PREINIT:
int i;
- SV *sv = sv_newmortal();
+ SV *sv = newSVpvs_flags("PL_ppaddr[OP_", SVs_TEMP);
CODE:
- sv_setpvn(sv, "PL_ppaddr[OP_", 13);
sv_catpv(sv, PL_op_name[o->op_type]);
for (i=13; (STRLEN)i < SvCUR(sv); ++i)
SvPVX(sv)[i] = toUPPER(SvPVX(sv)[i]);
- sv_catpv(sv, "]");
+ sv_catpvs(sv, "]");
ST(0) = sv;
-char *
-OP_desc(o)
- B::OP o
-
PADOFFSET
OP_targ(o)
B::OP o
-U16
-OP_type(o)
- B::OP o
-
#if PERL_VERSION >= 9
-
-U8
-OP_opt(o)
- B::OP o
-
-U8
-OP_static(o)
+# These 3 are all bitfields, so we can't take their addresses.
+UV
+OP_type(o)
B::OP o
+ ALIAS:
+ opt = 1
+ spare = 2
+ CODE:
+ switch(ix) {
+ case 1:
+ RETVAL = o->op_opt;
+ break;
+ case 2:
+ RETVAL = o->op_spare;
+ break;
+ default:
+ RETVAL = o->op_type;
+ }
+ OUTPUT:
+ RETVAL
#else
-U16
-OP_seq(o)
+UV
+OP_type(o)
B::OP o
+ ALIAS:
+ seq = 1
+ CODE:
+ switch(ix) {
+ case 1:
+ RETVAL = o->op_seq;
+ break;
+ default:
+ RETVAL = o->op_type;
+ }
+ OUTPUT:
+ RETVAL
#endif
OP_private(o)
B::OP o
-#if PERL_VERSION >= 9
-
-U8
-OP_spare(o)
- B::OP o
-
-#endif
-
void
OP_oplist(o)
B::OP o
OUTPUT:
RETVAL
-#define PMOP_pmreplroot(o) o->op_pmreplroot
-#define PMOP_pmreplstart(o) o->op_pmreplstart
#define PMOP_pmnext(o) o->op_pmnext
#define PMOP_pmregexp(o) PM_GETRE(o)
#ifdef USE_ITHREADS
#define PMOP_pmoffset(o) o->op_pmoffset
-#define PMOP_pmstashpv(o) o->op_pmstashpv
+#define PMOP_pmstashpv(o) PmopSTASHPV(o);
#else
-#define PMOP_pmstash(o) o->op_pmstash
+#define PMOP_pmstash(o) PmopSTASH(o);
#endif
#define PMOP_pmflags(o) o->op_pmflags
-#define PMOP_pmpermflags(o) o->op_pmpermflags
-#define PMOP_pmdynflags(o) o->op_pmdynflags
MODULE = B PACKAGE = B::PMOP PREFIX = PMOP_
+#if PERL_VERSION <= 8
+
void
PMOP_pmreplroot(o)
B::PMOP o
root = o->op_pmreplroot;
/* OP_PUSHRE stores an SV* instead of an OP* in op_pmreplroot */
if (o->op_type == OP_PUSHRE) {
-#ifdef USE_ITHREADS
+# ifdef USE_ITHREADS
sv_setiv(ST(0), INT2PTR(PADOFFSET,root) );
-#else
+# else
sv_setiv(newSVrv(ST(0), root ?
svclassnames[SvTYPE((SV*)root)] : "B::SV"),
PTR2IV(root));
-#endif
+# endif
}
else {
sv_setiv(newSVrv(ST(0), cc_opclassname(aTHX_ root)), PTR2IV(root));
}
+#else
+
+void
+PMOP_pmreplroot(o)
+ B::PMOP o
+ CODE:
+ ST(0) = sv_newmortal();
+ if (o->op_type == OP_PUSHRE) {
+# ifdef USE_ITHREADS
+ sv_setiv(ST(0), o->op_pmreplrootu.op_pmtargetoff);
+# else
+ GV *const target = o->op_pmreplrootu.op_pmtargetgv;
+ sv_setiv(newSVrv(ST(0), target ?
+ svclassnames[SvTYPE((SV*)target)] : "B::SV"),
+ PTR2IV(target));
+# endif
+ }
+ else {
+ OP *const root = o->op_pmreplrootu.op_pmreplroot;
+ sv_setiv(newSVrv(ST(0), cc_opclassname(aTHX_ root)),
+ PTR2IV(root));
+ }
+
+#endif
+
B::OP
PMOP_pmreplstart(o)
B::PMOP o
+#if PERL_VERSION < 9
+
B::PMOP
PMOP_pmnext(o)
B::PMOP o
+#endif
+
#ifdef USE_ITHREADS
IV
PMOP_pmflags(o)
B::PMOP o
+#if PERL_VERSION < 9
+
U32
PMOP_pmpermflags(o)
B::PMOP o
PMOP_pmdynflags(o)
B::PMOP o
+#endif
+
void
PMOP_precomp(o)
B::PMOP o
ST(0) = sv_newmortal();
rx = PM_GETRE(o);
if (rx)
- sv_setpvn(ST(0), rx->precomp, rx->prelen);
+ sv_setpvn(ST(0), RX_PRECOMP(rx), RX_PRELEN(rx));
+
+#if PERL_VERSION >= 9
+
+void
+PMOP_reflags(o)
+ B::PMOP o
+ REGEXP * rx = NO_INIT
+ CODE:
+ ST(0) = sv_newmortal();
+ rx = PM_GETRE(o);
+ if (rx)
+ sv_setuv(ST(0), RX_EXTFLAGS(rx));
+
+#endif
#define SVOP_sv(o) cSVOPo->op_sv
#define SVOP_gv(o) ((GV*)cSVOPo->op_sv)
#define PADOP_sv(o) (o->op_padix ? PAD_SVl(o->op_padix) : Nullsv)
#define PADOP_gv(o) ((o->op_padix \
&& SvTYPE(PAD_SVl(o->op_padix)) == SVt_PVGV) \
- ? (GV*)PAD_SVl(o->op_padix) : Nullgv)
+ ? (GV*)PAD_SVl(o->op_padix) : (GV *)NULL)
MODULE = B PACKAGE = B::PADOP PREFIX = PADOP_
{
const short* const tbl = (short*)o->op_pv;
const short entries = 257 + tbl[256];
- ST(0) = sv_2mortal(newSVpv(o->op_pv, entries * sizeof(short)));
+ ST(0) = newSVpvn_flags(o->op_pv, entries * sizeof(short), SVs_TEMP);
}
else if (o->op_type == OP_TRANS) {
- ST(0) = sv_2mortal(newSVpv(o->op_pv, 256 * sizeof(short)));
+ ST(0) = newSVpvn_flags(o->op_pv, 256 * sizeof(short), SVs_TEMP);
}
else
- ST(0) = sv_2mortal(newSVpv(o->op_pv, 0));
+ ST(0) = newSVpvn_flags(o->op_pv, strlen(o->op_pv), SVs_TEMP);
#define LOOP_redoop(o) o->op_redoop
#define LOOP_nextop(o) o->op_nextop
LOOP_lastop(o)
B::LOOP o
-#define COP_label(o) o->cop_label
+#define COP_label(o) CopLABEL(o)
#define COP_stashpv(o) CopSTASHPV(o)
#define COP_stash(o) CopSTASH(o)
#define COP_file(o) CopFILE(o)
MODULE = B PACKAGE = B::COP PREFIX = COP_
+#if PERL_VERSION >= 11
+
+const char *
+COP_label(o)
+ B::COP o
+
+#else
+
char *
COP_label(o)
B::COP o
+#endif
+
char *
COP_stashpv(o)
B::COP o
COP_warnings(o)
B::COP o
PPCODE:
- ST(0) = make_warnings_object(aTHX_ sv_newmortal(), o->cop_warnings);
+#if PERL_VERSION >= 9
+ ST(0) = make_warnings_object(aTHX_ o->cop_warnings);
+#else
+ ST(0) = make_sv_object(aTHX_ NULL, o->cop_warnings);
+#endif
XSRETURN(1);
void
COP_io(o)
B::COP o
PPCODE:
- ST(0) = make_cop_io_object(aTHX_ sv_newmortal(), o);
+#if PERL_VERSION >= 9
+ ST(0) = make_cop_io_object(aTHX_ o);
+#else
+ ST(0) = make_sv_object(aTHX_ NULL, o->cop_io);
+#endif
XSRETURN(1);
-U32
-COP_hints(o)
- B::COP o
+#if PERL_VERSION >= 9
B::RHE
COP_hints_hash(o)
B::COP o
CODE:
- RETVAL = o->cop_hints_hash;
+ RETVAL = CopHINTHASH_get(o);
OUTPUT:
RETVAL
+#endif
+
+U32
+COP_hints(o)
+ B::COP o
+
MODULE = B PACKAGE = B::SV
U32
wp[0] = htonl(((U32)iv) >> (sizeof(UV)*4));
#endif
wp[1] = htonl(iv & 0xffffffff);
- ST(0) = sv_2mortal(newSVpvn((char *)wp, 8));
+ ST(0) = newSVpvn_flags((char *)wp, 8, SVs_TEMP);
} else {
U32 w = htonl((U32)SvIVX(sv));
- ST(0) = sv_2mortal(newSVpvn((char *)&w, 4));
+ ST(0) = newSVpvn_flags((char *)&w, 4, SVs_TEMP);
}
+
+#if PERL_VERSION >= 11
+
+B::SV
+RV(sv)
+ B::IV sv
+ CODE:
+ if( SvROK(sv) ) {
+ RETVAL = SvRV(sv);
+ }
+ else {
+ croak( "argument is not SvROK" );
+ }
+ OUTPUT:
+ RETVAL
+
+#endif
+
MODULE = B PACKAGE = B::NV PREFIX = Sv
NV
SvNVX(sv)
B::NV sv
+U32
+COP_SEQ_RANGE_LOW(sv)
+ B::NV sv
+
+U32
+COP_SEQ_RANGE_HIGH(sv)
+ B::NV sv
+
+U32
+PARENT_PAD_INDEX(sv)
+ B::NV sv
+
+U32
+PARENT_FAKELEX_FLAGS(sv)
+ B::NV sv
+
+#if PERL_VERSION < 11
+
MODULE = B PACKAGE = B::RV PREFIX = Sv
B::SV
SvRV(sv)
B::RV sv
+#endif
+
MODULE = B PACKAGE = B::PV PREFIX = Sv
char*
SvPV(sv)
B::PV sv
CODE:
- ST(0) = sv_newmortal();
if( SvPOK(sv) ) {
+ STRLEN len = SvCUR(sv);
+ const char *p = SvPVX_const(sv);
/* FIXME - we need a better way for B to identify PVs that are
in the pads as variable names. */
- if((SvLEN(sv) && SvCUR(sv) >= SvLEN(sv))) {
+ if((SvLEN(sv) && len >= SvLEN(sv))) {
/* It claims to be longer than the space allocated for it -
presuambly it's a variable name in the pad */
- sv_setpv(ST(0), SvPV_nolen_const(sv));
- } else {
- sv_setpvn(ST(0), SvPVX_const(sv), SvCUR(sv));
+ len = strlen(p);
}
- SvFLAGS(ST(0)) |= SvUTF8(sv);
+ ST(0) = newSVpvn_flags(p, len, SVs_TEMP | SvUTF8(sv));
}
else {
/* XXX for backward compatibility, but should fail */
/* croak( "argument is not SvPOK" ); */
- sv_setpvn(ST(0), NULL, 0);
+ ST(0) = sv_newmortal();
}
+# This used to read 257. I think that that was buggy - should have been 258.
+# (The "\0", the flags byte, and 256 for the table. Not that anything
+# anywhere calls this method. NWC.
void
SvPVBM(sv)
B::PV sv
CODE:
- ST(0) = sv_newmortal();
- sv_setpvn(ST(0), SvPVX_const(sv),
- SvCUR(sv) + (SvTYPE(sv) == SVt_PVBM ? 257 : 0));
+ ST(0) = newSVpvn_flags(SvPVX_const(sv),
+ SvCUR(sv) + (SvVALID(sv) ? 256 + PERL_FBM_TABLE_OFFSET : 0),
+ SVs_TEMP);
STRLEN
MAGIC * mg = NO_INIT
PPCODE:
for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic)
- XPUSHs(make_mg_object(aTHX_ sv_newmortal(), mg));
+ XPUSHs(make_mg_object(aTHX_ mg));
MODULE = B PACKAGE = B::PVMG
SvSTASH(sv)
B::PVMG sv
+MODULE = B PACKAGE = B::REGEXP
+
+#if PERL_VERSION >= 11
+
+IV
+REGEX(sv)
+ B::REGEXP sv
+ CODE:
+ /* FIXME - can we code this method more efficiently? */
+ RETVAL = PTR2IV(sv);
+ OUTPUT:
+ RETVAL
+
+SV*
+precomp(sv)
+ B::REGEXP sv
+ CODE:
+ RETVAL = newSVpvn( RX_PRECOMP(sv), RX_PRELEN(sv) );
+ OUTPUT:
+ RETVAL
+
+#endif
+
#define MgMOREMAGIC(mg) mg->mg_moremagic
#define MgPRIVATE(mg) mg->mg_private
#define MgTYPE(mg) mg->mg_type
REGEXP* rx = (REGEXP*)mg->mg_obj;
RETVAL = Nullsv;
if( rx )
- RETVAL = newSVpvn( rx->precomp, rx->prelen );
+ RETVAL = newSVpvn( RX_PRECOMP(rx), RX_PRELEN(rx) );
}
else {
croak( "precomp is only meaningful on r-magic" );
MgPTR(mg)
B::MAGIC mg
CODE:
- ST(0) = sv_newmortal();
if (mg->mg_ptr){
if (mg->mg_len >= 0){
- sv_setpvn(ST(0), mg->mg_ptr, mg->mg_len);
+ ST(0) = newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
} else if (mg->mg_len == HEf_SVKEY) {
- ST(0) = make_sv_object(aTHX_
- sv_newmortal(), (SV*)mg->mg_ptr);
- }
- }
+ ST(0) = make_sv_object(aTHX_ NULL, (SV*)mg->mg_ptr);
+ } else
+ ST(0) = sv_newmortal();
+ } else
+ ST(0) = sv_newmortal();
MODULE = B PACKAGE = B::PVLV PREFIX = Lv
BmUSEFUL(sv)
B::BM sv
-U16
+U32
BmPREVIOUS(sv)
B::BM sv
CODE:
str = SvPV(sv, len);
/* Boyer-Moore table is just after string and its safety-margin \0 */
- ST(0) = sv_2mortal(newSVpvn(str + len + 1, 256));
+ ST(0) = newSVpvn_flags(str + len + PERL_FBM_TABLE_OFFSET, 256, SVs_TEMP);
MODULE = B PACKAGE = B::GV PREFIX = Gv
GvNAME(gv)
B::GV gv
CODE:
- ST(0) = sv_2mortal(newSVpvn(GvNAME(gv), GvNAMELEN(gv)));
+#if PERL_VERSION >= 10
+ ST(0) = sv_2mortal(newSVhek(GvNAME_HEK(gv)));
+#else
+ ST(0) = newSVpvn_flags(GvNAME(gv), GvNAMELEN(gv), SVs_TEMP);
+#endif
bool
is_empty(gv)
OUTPUT:
RETVAL
+bool
+isGV_with_GP(gv)
+ B::GV gv
+ CODE:
+#if PERL_VERSION >= 9
+ RETVAL = isGV_with_GP(gv) ? TRUE : FALSE;
+#else
+ RETVAL = TRUE; /* In 5.8 and earlier they all are. */
+#endif
+ OUTPUT:
+ RETVAL
+
void*
GvGP(gv)
B::GV gv
IoBOTTOM_GV(io)
B::IO io
+#if PERL_VERSION <= 8
+
short
IoSUBPROCESS(io)
B::IO io
+#endif
+
bool
IsSTD(io,name)
B::IO io
SV **svp = AvARRAY(av);
I32 i;
for (i = 0; i <= AvFILL(av); i++)
- XPUSHs(make_sv_object(aTHX_ sv_newmortal(), svp[i]));
+ XPUSHs(make_sv_object(aTHX_ NULL, svp[i]));
}
void
int idx
PPCODE:
if (idx >= 0 && AvFILL(av) >= 0 && idx <= AvFILL(av))
- XPUSHs(make_sv_object(aTHX_ sv_newmortal(), (AvARRAY(av)[idx])));
+ XPUSHs(make_sv_object(aTHX_ NULL, (AvARRAY(av)[idx])));
else
- XPUSHs(make_sv_object(aTHX_ sv_newmortal(), NULL));
+ XPUSHs(make_sv_object(aTHX_ NULL, NULL));
#if PERL_VERSION < 9
B::OP
CvSTART(cv)
B::CV cv
+ ALIAS:
+ ROOT = 1
CODE:
- RETVAL = CvISXSUB(cv) ? NULL : CvSTART(cv);
- OUTPUT:
- RETVAL
-
-B::OP
-CvROOT(cv)
- B::CV cv
- CODE:
- RETVAL = CvISXSUB(cv) ? NULL : CvROOT(cv);
+ RETVAL = CvISXSUB(cv) ? NULL : ix ? CvROOT(cv) : CvSTART(cv);
OUTPUT:
RETVAL
CvXSUBANY(cv)
B::CV cv
CODE:
- ST(0) = CvCONST(cv) ?
- make_sv_object(aTHX_ sv_newmortal(),(SV *)CvXSUBANY(cv).any_ptr) :
- sv_2mortal(newSViv(CvISXSUB(cv) ? CvXSUBANY(cv).any_iv : 0));
+ ST(0) = CvCONST(cv)
+ ? make_sv_object(aTHX_ NULL, (SV *)CvXSUBANY(cv).any_ptr)
+ : sv_2mortal(newSViv(CvISXSUB(cv) ? CvXSUBANY(cv).any_iv : 0));
MODULE = B PACKAGE = B::CV
(void)hv_iterinit(hv);
EXTEND(sp, HvKEYS(hv) * 2);
while ((sv = hv_iternextsv(hv, &key, &len))) {
- PUSHs(newSVpvn(key, len));
- PUSHs(make_sv_object(aTHX_ sv_newmortal(), sv));
+ mPUSHp(key, len);
+ PUSHs(make_sv_object(aTHX_ NULL, sv));
}
}
MODULE = B PACKAGE = B::RHE PREFIX = RHE_
+#if PERL_VERSION >= 9
+
SV*
RHE_HASH(h)
B::RHE h
CODE:
- RETVAL = newRV( (SV*)Perl_refcounted_he_chain_2hv(aTHX_ h) );
+ RETVAL = newRV( (SV*)cophh_2hv(h, 0) );
OUTPUT:
RETVAL
+
+#endif
https://perl5.git.perl.org / perl5.git / blobdiff