/*
----------------------------------------------------------------------
- ppport.h -- Perl/Pollution/Portability Version 3.36
+ ppport.h -- Perl/Pollution/Portability Version 3.42
- Automatically created by Devel::PPPort running under perl 5.026000.
+ Automatically created by Devel::PPPort running under perl 5.028000.
Version 3.x, Copyright (c) 2004-2013, Marcus Holland-Moritz.
if (@ARGV && $ARGV[0] eq '--unstrip') {
eval { require Devel::PPPort };
$@ and die "Cannot require Devel::PPPort, please install.\n";
- if (eval $Devel::PPPort::VERSION < 3.36) {
- die "ppport.h was originally generated with Devel::PPPort 3.36.\n"
+ if (eval $Devel::PPPort::VERSION < 3.42) {
+ die "ppport.h was originally generated with Devel::PPPort 3.42.\n"
. "Your Devel::PPPort is only version $Devel::PPPort::VERSION.\n"
. "Please install a newer version, or --unstrip will not work.\n";
}
#define PERL_SUBVERSION SUBVERSION
#endif
#endif
-#define _dpppDEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
-#define PERL_BCDVERSION ((_dpppDEC2BCD(PERL_REVISION)<<24)|(_dpppDEC2BCD(PERL_VERSION)<<12)|_dpppDEC2BCD(PERL_SUBVERSION))
+#define D_PPP_DEC2BCD(dec) ((((dec)/100)<<8)|((((dec)%100)/10)<<4)|((dec)%10))
+#define PERL_BCDVERSION ((D_PPP_DEC2BCD(PERL_REVISION)<<24)|(D_PPP_DEC2BCD(PERL_VERSION)<<12)|D_PPP_DEC2BCD(PERL_SUBVERSION))
#if PERL_REVISION != 5
#error ppport.h only works with Perl version 5
#endif
#ifndef Newxz
#define Newxz(v,n,t) Newz(0,v,n,t)
#endif
+#ifndef PERL_MAGIC_sv
+#define PERL_MAGIC_sv '\0'
+#endif
+#ifndef PERL_MAGIC_overload
+#define PERL_MAGIC_overload 'A'
+#endif
+#ifndef PERL_MAGIC_overload_elem
+#define PERL_MAGIC_overload_elem 'a'
+#endif
+#ifndef PERL_MAGIC_overload_table
+#define PERL_MAGIC_overload_table 'c'
+#endif
+#ifndef PERL_MAGIC_bm
+#define PERL_MAGIC_bm 'B'
+#endif
+#ifndef PERL_MAGIC_regdata
+#define PERL_MAGIC_regdata 'D'
+#endif
+#ifndef PERL_MAGIC_regdatum
+#define PERL_MAGIC_regdatum 'd'
+#endif
+#ifndef PERL_MAGIC_env
+#define PERL_MAGIC_env 'E'
+#endif
+#ifndef PERL_MAGIC_envelem
+#define PERL_MAGIC_envelem 'e'
+#endif
+#ifndef PERL_MAGIC_fm
+#define PERL_MAGIC_fm 'f'
+#endif
+#ifndef PERL_MAGIC_regex_global
+#define PERL_MAGIC_regex_global 'g'
+#endif
+#ifndef PERL_MAGIC_isa
+#define PERL_MAGIC_isa 'I'
+#endif
+#ifndef PERL_MAGIC_isaelem
+#define PERL_MAGIC_isaelem 'i'
+#endif
+#ifndef PERL_MAGIC_nkeys
+#define PERL_MAGIC_nkeys 'k'
+#endif
+#ifndef PERL_MAGIC_dbfile
+#define PERL_MAGIC_dbfile 'L'
+#endif
+#ifndef PERL_MAGIC_dbline
+#define PERL_MAGIC_dbline 'l'
+#endif
+#ifndef PERL_MAGIC_mutex
+#define PERL_MAGIC_mutex 'm'
+#endif
+#ifndef PERL_MAGIC_shared
+#define PERL_MAGIC_shared 'N'
+#endif
+#ifndef PERL_MAGIC_shared_scalar
+#define PERL_MAGIC_shared_scalar 'n'
+#endif
+#ifndef PERL_MAGIC_collxfrm
+#define PERL_MAGIC_collxfrm 'o'
+#endif
+#ifndef PERL_MAGIC_tied
+#define PERL_MAGIC_tied 'P'
+#endif
+#ifndef PERL_MAGIC_tiedelem
+#define PERL_MAGIC_tiedelem 'p'
+#endif
+#ifndef PERL_MAGIC_tiedscalar
+#define PERL_MAGIC_tiedscalar 'q'
+#endif
#ifndef PERL_MAGIC_qr
#define PERL_MAGIC_qr 'r'
#endif
+#ifndef PERL_MAGIC_sig
+#define PERL_MAGIC_sig 'S'
+#endif
+#ifndef PERL_MAGIC_sigelem
+#define PERL_MAGIC_sigelem 's'
+#endif
+#ifndef PERL_MAGIC_taint
+#define PERL_MAGIC_taint 't'
+#endif
+#ifndef PERL_MAGIC_uvar
+#define PERL_MAGIC_uvar 'U'
+#endif
+#ifndef PERL_MAGIC_uvar_elem
+#define PERL_MAGIC_uvar_elem 'u'
+#endif
+#ifndef PERL_MAGIC_vstring
+#define PERL_MAGIC_vstring 'V'
+#endif
+#ifndef PERL_MAGIC_vec
+#define PERL_MAGIC_vec 'v'
+#endif
+#ifndef PERL_MAGIC_utf8
+#define PERL_MAGIC_utf8 'w'
+#endif
+#ifndef PERL_MAGIC_substr
+#define PERL_MAGIC_substr 'x'
+#endif
+#ifndef PERL_MAGIC_defelem
+#define PERL_MAGIC_defelem 'y'
+#endif
+#ifndef PERL_MAGIC_glob
+#define PERL_MAGIC_glob '*'
+#endif
+#ifndef PERL_MAGIC_arylen
+#define PERL_MAGIC_arylen '#'
+#endif
+#ifndef PERL_MAGIC_pos
+#define PERL_MAGIC_pos '.'
+#endif
+#ifndef PERL_MAGIC_backref
+#define PERL_MAGIC_backref '<'
+#endif
+#ifndef PERL_MAGIC_ext
+#define PERL_MAGIC_ext '~'
+#endif
#ifndef cBOOL
#define cBOOL(cbool) ((cbool) ? (bool)1 : (bool)0)
#endif
#ifndef OpMAYBESIB_set
#define OpMAYBESIB_set(o, sib, parent) ((o)->op_sibling = (sib))
#endif
+#ifndef HEf_SVKEY
+#define HEf_SVKEY -2
+#endif
#ifndef SvRX
#if defined(NEED_SvRX)
static void * DPPP_(my_SvRX)(pTHX_ SV *rv);
#else
extern void * DPPP_(my_SvRX)(pTHX_ SV *rv);
#endif
+#if defined(NEED_SvRX) || defined(NEED_SvRX_GLOBAL)
#ifdef SvRX
#undef SvRX
#endif
#define SvRX(a) DPPP_(my_SvRX)(aTHX_ a)
-#if defined(NEED_SvRX) || defined(NEED_SvRX_GLOBAL)
void *
DPPP_(my_SvRX)(pTHX_ SV *rv)
{
#if (PERL_BCDVERSION < 0x5010000)
#undef isPRINT
#endif
-#ifdef HAS_QUAD
+#ifndef WIDEST_UTYPE
+#ifdef QUADKIND
#ifdef U64TYPE
#define WIDEST_UTYPE U64TYPE
#else
#else
#define WIDEST_UTYPE U32
#endif
+#endif
#ifndef isALNUMC
#define isALNUMC(c) (isALPHA(c) || isDIGIT(c))
#endif
#ifndef C_ARRAY_END
#define C_ARRAY_END(a) ((a) + C_ARRAY_LENGTH(a))
#endif
+#ifndef MUTABLE_PTR
+#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#define MUTABLE_PTR(p) ({ void *_p = (p); _p; })
+#else
+#define MUTABLE_PTR(p) ((void *) (p))
+#endif
+#endif
+#ifndef MUTABLE_SV
+#define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p))
+#endif
+#ifdef NEED_mess_sv
+#define NEED_mess
+#endif
+#ifdef NEED_mess
+#define NEED_mess_nocontext
+#define NEED_vmess
+#endif
+#ifndef croak_sv
+#if (PERL_BCDVERSION >= 0x5007003) || ( (PERL_BCDVERSION >= 0x5006001) && (PERL_BCDVERSION < 0x5007000) )
+#if ( (PERL_BCDVERSION >= 0x5008000) && (PERL_BCDVERSION < 0x5008009) ) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5010001) )
+#define D_PPP_FIX_UTF8_ERRSV(errsv, sv) \
+STMT_START { \
+if (sv != ERRSV) \
+SvFLAGS(ERRSV) = (SvFLAGS(ERRSV) & ~SVf_UTF8) | \
+(SvFLAGS(sv) & SVf_UTF8); \
+} STMT_END
+#else
+#define D_PPP_FIX_UTF8_ERRSV(errsv, sv) STMT_START {} STMT_END
+#endif
+#define croak_sv(sv) \
+STMT_START { \
+if (SvROK(sv)) { \
+sv_setsv(ERRSV, sv); \
+croak(NULL); \
+} else { \
+D_PPP_FIX_UTF8_ERRSV(ERRSV, sv); \
+croak("%" SVf, SVfARG(sv)); \
+} \
+} STMT_END
+#elif (PERL_BCDVERSION >= 0x5004000)
+#define croak_sv(sv) croak("%" SVf, SVfARG(sv))
+#else
+#define croak_sv(sv) croak("%s", SvPV_nolen(sv))
+#endif
+#endif
+#ifndef die_sv
+#if defined(NEED_die_sv)
+static OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+static
+#else
+extern OP * DPPP_(my_die_sv)(pTHX_ SV *sv);
+#endif
+#if defined(NEED_die_sv) || defined(NEED_die_sv_GLOBAL)
+#ifdef die_sv
+#undef die_sv
+#endif
+#define die_sv(a) DPPP_(my_die_sv)(aTHX_ a)
+#define Perl_die_sv DPPP_(my_die_sv)
+OP *
+DPPP_(my_die_sv)(pTHX_ SV *sv)
+{
+croak_sv(sv);
+return (OP *)NULL;
+}
+#endif
+#endif
+#ifndef warn_sv
+#if (PERL_BCDVERSION >= 0x5004000)
+#define warn_sv(sv) warn("%" SVf, SVfARG(sv))
+#else
+#define warn_sv(sv) warn("%s", SvPV_nolen(sv))
+#endif
+#endif
+#ifndef vmess
+#if defined(NEED_vmess)
+static SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+static
+#else
+extern SV * DPPP_(my_vmess)(pTHX_ const char * pat, va_list * args);
+#endif
+#if defined(NEED_vmess) || defined(NEED_vmess_GLOBAL)
+#ifdef vmess
+#undef vmess
+#endif
+#define vmess(a,b) DPPP_(my_vmess)(aTHX_ a,b)
+#define Perl_vmess DPPP_(my_vmess)
+SV*
+DPPP_(my_vmess)(pTHX_ const char* pat, va_list* args)
+{
+mess(pat, args);
+return PL_mess_sv;
+}
+#endif
+#endif
+#if (PERL_BCDVERSION < 0x5006000)
+#undef mess
+#endif
+#if !defined(mess_nocontext) && !defined(Perl_mess_nocontext)
+#if defined(NEED_mess_nocontext)
+static SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
+static
+#else
+extern SV * DPPP_(my_mess_nocontext)(const char * pat, ...);
+#endif
+#if defined(NEED_mess_nocontext) || defined(NEED_mess_nocontext_GLOBAL)
+#define mess_nocontext DPPP_(my_mess_nocontext)
+#define Perl_mess_nocontext DPPP_(my_mess_nocontext)
+SV*
+DPPP_(my_mess_nocontext)(const char* pat, ...)
+{
+dTHX;
+SV *sv;
+va_list args;
+va_start(args, pat);
+sv = vmess(pat, &args);
+va_end(args);
+return sv;
+}
+#endif
+#endif
+#ifndef mess
+#if defined(NEED_mess)
+static SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+static
+#else
+extern SV * DPPP_(my_mess)(pTHX_ const char * pat, ...);
+#endif
+#if defined(NEED_mess) || defined(NEED_mess_GLOBAL)
+#define Perl_mess DPPP_(my_mess)
+SV*
+DPPP_(my_mess)(pTHX_ const char* pat, ...)
+{
+SV *sv;
+va_list args;
+va_start(args, pat);
+sv = vmess(pat, &args);
+va_end(args);
+return sv;
+}
+#ifdef mess_nocontext
+#define mess mess_nocontext
+#else
+#define mess Perl_mess_nocontext
+#endif
+#endif
+#endif
+#ifndef mess_sv
+#if defined(NEED_mess_sv)
+static SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+static
+#else
+extern SV * DPPP_(my_mess_sv)(pTHX_ SV * basemsg, bool consume);
+#endif
+#if defined(NEED_mess_sv) || defined(NEED_mess_sv_GLOBAL)
+#ifdef mess_sv
+#undef mess_sv
+#endif
+#define mess_sv(a,b) DPPP_(my_mess_sv)(aTHX_ a,b)
+#define Perl_mess_sv DPPP_(my_mess_sv)
+SV *
+DPPP_(my_mess_sv)(pTHX_ SV *basemsg, bool consume)
+{
+SV *tmp;
+SV *ret;
+if (SvPOK(basemsg) && SvCUR(basemsg) && *(SvEND(basemsg)-1) == '\n') {
+if (consume)
+return basemsg;
+ret = mess("");
+SvSetSV_nosteal(ret, basemsg);
+return ret;
+}
+if (consume) {
+sv_catsv(basemsg, mess(""));
+return basemsg;
+}
+ret = mess("");
+tmp = newSVsv(ret);
+SvSetSV_nosteal(ret, basemsg);
+sv_catsv(ret, tmp);
+sv_dec(tmp);
+return ret;
+}
+#endif
+#endif
+#ifndef warn_nocontext
+#define warn_nocontext warn
+#endif
+#ifndef croak_nocontext
+#define croak_nocontext croak
+#endif
+#ifndef croak_no_modify
+#define croak_no_modify() croak_nocontext("%s", PL_no_modify)
+#define Perl_croak_no_modify() croak_no_modify()
+#endif
+#ifndef croak_memory_wrap
+#if (PERL_BCDVERSION >= 0x5009002) || ( (PERL_BCDVERSION >= 0x5008006) && (PERL_BCDVERSION < 0x5009000) )
+#define croak_memory_wrap() croak_nocontext("%s", PL_memory_wrap)
+#else
+#define croak_memory_wrap() croak_nocontext("panic: memory wrap")
+#endif
+#endif
+#ifndef croak_xs_usage
+#if defined(NEED_croak_xs_usage)
+static void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
+static
+#else
+extern void DPPP_(my_croak_xs_usage)(const CV * const cv, const char * const params);
+#endif
+#if defined(NEED_croak_xs_usage) || defined(NEED_croak_xs_usage_GLOBAL)
+#define croak_xs_usage DPPP_(my_croak_xs_usage)
+#define Perl_croak_xs_usage DPPP_(my_croak_xs_usage)
+#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
+#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)
+#endif
+void
+DPPP_(my_croak_xs_usage)(const CV *const cv, const char *const params)
+{
+dTHX;
+const GV *const gv = CvGV(cv);
+PERL_ARGS_ASSERT_CROAK_XS_USAGE;
+if (gv) {
+const char *const gvname = GvNAME(gv);
+const HV *const stash = GvSTASH(gv);
+const char *const hvname = stash ? HvNAME(stash) : NULL;
+if (hvname)
+croak("Usage: %s::%s(%s)", hvname, gvname, params);
+else
+croak("Usage: %s(%s)", gvname, params);
+} else {
+croak("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
+}
+}
+#endif
+#endif
#ifndef PERL_SIGNALS_UNSAFE_FLAG
#define PERL_SIGNALS_UNSAFE_FLAG 0x0001
#if (PERL_BCDVERSION < 0x5008000)
#else
extern SV* DPPP_(my_eval_pv)(char *p, I32 croak_on_error);
#endif
+#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
#ifdef eval_pv
#undef eval_pv
#endif
#define eval_pv(a,b) DPPP_(my_eval_pv)(aTHX_ a,b)
#define Perl_eval_pv DPPP_(my_eval_pv)
-#if defined(NEED_eval_pv) || defined(NEED_eval_pv_GLOBAL)
SV*
DPPP_(my_eval_pv)(char *p, I32 croak_on_error)
{
SPAGAIN;
sv = POPs;
PUTBACK;
-if (croak_on_error && SvTRUE(GvSV(errgv)))
-croak(SvPVx(GvSV(errgv), na));
+if (croak_on_error && SvTRUEx(ERRSV))
+croak_sv(ERRSV);
return sv;
}
#endif
#else
extern void DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args);
#endif
+#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
#ifdef vload_module
#undef vload_module
#endif
#define vload_module(a,b,c,d) DPPP_(my_vload_module)(aTHX_ a,b,c,d)
#define Perl_vload_module DPPP_(my_vload_module)
-#if defined(NEED_vload_module) || defined(NEED_vload_module_GLOBAL)
void
DPPP_(my_vload_module)(U32 flags, SV *name, SV *ver, va_list *args)
{
#else
extern void DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...);
#endif
+#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
#ifdef load_module
#undef load_module
#endif
#define load_module DPPP_(my_load_module)
#define Perl_load_module DPPP_(my_load_module)
-#if defined(NEED_load_module) || defined(NEED_load_module_GLOBAL)
void
DPPP_(my_load_module)(U32 flags, SV *name, SV *ver, ...)
{
#else
extern SV * DPPP_(my_newRV_noinc)(SV *sv);
#endif
+#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
#ifdef newRV_noinc
#undef newRV_noinc
#endif
#define newRV_noinc(a) DPPP_(my_newRV_noinc)(aTHX_ a)
#define Perl_newRV_noinc DPPP_(my_newRV_noinc)
-#if defined(NEED_newRV_noinc) || defined(NEED_newRV_noinc_GLOBAL)
SV *
DPPP_(my_newRV_noinc)(SV *sv)
{
#else
extern void DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv);
#endif
+#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
#ifdef newCONSTSUB
#undef newCONSTSUB
#endif
#define newCONSTSUB(a,b,c) DPPP_(my_newCONSTSUB)(aTHX_ a,b,c)
#define Perl_newCONSTSUB DPPP_(my_newCONSTSUB)
-#if defined(NEED_newCONSTSUB) || defined(NEED_newCONSTSUB_GLOBAL)
#define D_PPP_PL_copline PL_copline
void
DPPP_(my_newCONSTSUB)(HV *stash, const char *name, SV *sv)
#else
extern SV* DPPP_(my_newSV_type)(pTHX_ svtype const t);
#endif
+#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)
#ifdef newSV_type
#undef newSV_type
#endif
#define newSV_type(a) DPPP_(my_newSV_type)(aTHX_ a)
#define Perl_newSV_type DPPP_(my_newSV_type)
-#if defined(NEED_newSV_type) || defined(NEED_newSV_type_GLOBAL)
SV*
DPPP_(my_newSV_type)(pTHX_ svtype const t)
{
#else
extern SV * DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags);
#endif
+#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
#ifdef newSVpvn_flags
#undef newSVpvn_flags
#endif
#define newSVpvn_flags(a,b,c) DPPP_(my_newSVpvn_flags)(aTHX_ a,b,c)
#define Perl_newSVpvn_flags DPPP_(my_newSVpvn_flags)
-#if defined(NEED_newSVpvn_flags) || defined(NEED_newSVpvn_flags_GLOBAL)
SV *
DPPP_(my_newSVpvn_flags)(pTHX_ const char *s, STRLEN len, U32 flags)
{
#else
extern char * DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp);
#endif
+#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
#ifdef sv_2pvbyte
#undef sv_2pvbyte
#endif
#define sv_2pvbyte(a,b) DPPP_(my_sv_2pvbyte)(aTHX_ a,b)
#define Perl_sv_2pvbyte DPPP_(my_sv_2pvbyte)
-#if defined(NEED_sv_2pvbyte) || defined(NEED_sv_2pvbyte_GLOBAL)
char *
DPPP_(my_sv_2pvbyte)(pTHX_ SV *sv, STRLEN *lp)
{
#else
extern char * DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
#endif
+#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
#ifdef sv_2pv_flags
#undef sv_2pv_flags
#endif
#define sv_2pv_flags(a,b,c) DPPP_(my_sv_2pv_flags)(aTHX_ a,b,c)
#define Perl_sv_2pv_flags DPPP_(my_sv_2pv_flags)
-#if defined(NEED_sv_2pv_flags) || defined(NEED_sv_2pv_flags_GLOBAL)
char *
DPPP_(my_sv_2pv_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
{
#else
extern char * DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags);
#endif
+#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
#ifdef sv_pvn_force_flags
#undef sv_pvn_force_flags
#endif
#define sv_pvn_force_flags(a,b,c) DPPP_(my_sv_pvn_force_flags)(aTHX_ a,b,c)
#define Perl_sv_pvn_force_flags DPPP_(my_sv_pvn_force_flags)
-#if defined(NEED_sv_pvn_force_flags) || defined(NEED_sv_pvn_force_flags_GLOBAL)
char *
DPPP_(my_sv_pvn_force_flags)(pTHX_ SV *sv, STRLEN *lp, I32 flags)
{
#endif
#endif
#if (PERL_BCDVERSION < 0x5008008) || ( (PERL_BCDVERSION >= 0x5009000) && (PERL_BCDVERSION < 0x5009003) )
-#define DPPP_SVPV_NOLEN_LP_ARG &PL_na
+#define D_PPP_SVPV_NOLEN_LP_ARG &PL_na
#else
-#define DPPP_SVPV_NOLEN_LP_ARG 0
+#define D_PPP_SVPV_NOLEN_LP_ARG 0
#endif
#ifndef SvPV_const
#define SvPV_const(sv, lp) SvPV_flags_const(sv, lp, SV_GMAGIC)
#define SvPV_flags_const_nolen(sv, flags) \
((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
? SvPVX_const(sv) : \
-(const char*) sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
+(const char*) sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags|SV_CONST_RETURN))
#endif
#ifndef SvPV_flags_mutable
#define SvPV_flags_mutable(sv, lp, flags) \
#ifndef SvPV_force_flags_nolen
#define SvPV_force_flags_nolen(sv, flags) \
((SvFLAGS(sv) & (SVf_POK|SVf_THINKFIRST)) == SVf_POK \
-? SvPVX(sv) : sv_pvn_force_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, flags))
+? SvPVX(sv) : sv_pvn_force_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, flags))
#endif
#ifndef SvPV_force_flags_mutable
#define SvPV_force_flags_mutable(sv, lp, flags) \
#ifndef SvPV_nolen
#define SvPV_nolen(sv) \
((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
+? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC))
#endif
#ifndef SvPV_nolen_const
#define SvPV_nolen_const(sv) \
((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-? SvPVX_const(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
+? SvPVX_const(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, SV_GMAGIC|SV_CONST_RETURN))
#endif
#ifndef SvPV_nomg
#define SvPV_nomg(sv, lp) SvPV_flags(sv, lp, 0)
#endif
#ifndef SvPV_nomg_nolen
#define SvPV_nomg_nolen(sv) ((SvFLAGS(sv) & (SVf_POK)) == SVf_POK \
-? SvPVX(sv) : sv_2pv_flags(sv, DPPP_SVPV_NOLEN_LP_ARG, 0))
+? SvPVX(sv) : sv_2pv_flags(sv, D_PPP_SVPV_NOLEN_LP_ARG, 0))
#endif
#ifndef SvPV_renew
#define SvPV_renew(sv,n) STMT_START { SvLEN_set(sv, n); \
#else
extern SV * DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args);
#endif
+#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
#ifdef vnewSVpvf
#undef vnewSVpvf
#endif
#define vnewSVpvf(a,b) DPPP_(my_vnewSVpvf)(aTHX_ a,b)
#define Perl_vnewSVpvf DPPP_(my_vnewSVpvf)
-#if defined(NEED_vnewSVpvf) || defined(NEED_vnewSVpvf_GLOBAL)
SV *
DPPP_(my_vnewSVpvf)(pTHX_ const char *pat, va_list *args)
{
#else
extern void DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
#endif
-#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
#if defined(NEED_sv_catpvf_mg) || defined(NEED_sv_catpvf_mg_GLOBAL)
+#define Perl_sv_catpvf_mg DPPP_(my_sv_catpvf_mg)
void
DPPP_(my_sv_catpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
{
#else
extern void DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...);
#endif
+#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
#define sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
#define Perl_sv_catpvf_mg_nocontext DPPP_(my_sv_catpvf_mg_nocontext)
-#if defined(NEED_sv_catpvf_mg_nocontext) || defined(NEED_sv_catpvf_mg_nocontext_GLOBAL)
void
DPPP_(my_sv_catpvf_mg_nocontext)(SV *sv, const char *pat, ...)
{
#else
extern void DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...);
#endif
-#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
#if defined(NEED_sv_setpvf_mg) || defined(NEED_sv_setpvf_mg_GLOBAL)
+#define Perl_sv_setpvf_mg DPPP_(my_sv_setpvf_mg)
void
DPPP_(my_sv_setpvf_mg)(pTHX_ SV *sv, const char *pat, ...)
{
#else
extern void DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...);
#endif
+#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
#define sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
#define Perl_sv_setpvf_mg_nocontext DPPP_(my_sv_setpvf_mg_nocontext)
-#if defined(NEED_sv_setpvf_mg_nocontext) || defined(NEED_sv_setpvf_mg_nocontext_GLOBAL)
void
DPPP_(my_sv_setpvf_mg_nocontext)(SV *sv, const char *pat, ...)
{
#else
extern SV * DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash);
#endif
+#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
#ifdef newSVpvn_share
#undef newSVpvn_share
#endif
#define newSVpvn_share(a,b,c) DPPP_(my_newSVpvn_share)(aTHX_ a,b,c)
#define Perl_newSVpvn_share DPPP_(my_newSVpvn_share)
-#if defined(NEED_newSVpvn_share) || defined(NEED_newSVpvn_share_GLOBAL)
SV *
DPPP_(my_newSVpvn_share)(pTHX_ const char *src, I32 len, U32 hash)
{
#else
extern GV* DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types);
#endif
+#if defined(NEED_gv_fetchpvn_flags) || defined(NEED_gv_fetchpvn_flags_GLOBAL)
#ifdef gv_fetchpvn_flags
#undef gv_fetchpvn_flags
#endif
#define gv_fetchpvn_flags(a,b,c,d) DPPP_(my_gv_fetchpvn_flags)(aTHX_ a,b,c,d)
#define Perl_gv_fetchpvn_flags DPPP_(my_gv_fetchpvn_flags)
-#if defined(NEED_gv_fetchpvn_flags) || defined(NEED_gv_fetchpvn_flags_GLOBAL)
GV*
DPPP_(my_gv_fetchpvn_flags)(pTHX_ const char* name, STRLEN len, int flags, int types) {
char *namepv = savepvn(name, len);
#else
extern void DPPP_(my_warner)(U32 err, const char *pat, ...);
#endif
-#define Perl_warner DPPP_(my_warner)
#if defined(NEED_warner) || defined(NEED_warner_GLOBAL)
+#define Perl_warner DPPP_(my_warner)
void
DPPP_(my_warner)(U32 err, const char *pat, ...)
{
#ifndef SvGETMAGIC
#define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
#endif
-#ifndef HEf_SVKEY
-#define HEf_SVKEY -2
-#endif
-#ifndef MUTABLE_PTR
-#if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
-#define MUTABLE_PTR(p) ({ void *_p = (p); _p; })
-#else
-#define MUTABLE_PTR(p) ((void *) (p))
-#endif
-#endif
-#ifndef MUTABLE_SV
-#define MUTABLE_SV(p) ((SV *)MUTABLE_PTR(p))
-#endif
-#ifndef PERL_MAGIC_sv
-#define PERL_MAGIC_sv '\0'
-#endif
-#ifndef PERL_MAGIC_overload
-#define PERL_MAGIC_overload 'A'
-#endif
-#ifndef PERL_MAGIC_overload_elem
-#define PERL_MAGIC_overload_elem 'a'
-#endif
-#ifndef PERL_MAGIC_overload_table
-#define PERL_MAGIC_overload_table 'c'
-#endif
-#ifndef PERL_MAGIC_bm
-#define PERL_MAGIC_bm 'B'
-#endif
-#ifndef PERL_MAGIC_regdata
-#define PERL_MAGIC_regdata 'D'
-#endif
-#ifndef PERL_MAGIC_regdatum
-#define PERL_MAGIC_regdatum 'd'
-#endif
-#ifndef PERL_MAGIC_env
-#define PERL_MAGIC_env 'E'
-#endif
-#ifndef PERL_MAGIC_envelem
-#define PERL_MAGIC_envelem 'e'
-#endif
-#ifndef PERL_MAGIC_fm
-#define PERL_MAGIC_fm 'f'
-#endif
-#ifndef PERL_MAGIC_regex_global
-#define PERL_MAGIC_regex_global 'g'
-#endif
-#ifndef PERL_MAGIC_isa
-#define PERL_MAGIC_isa 'I'
-#endif
-#ifndef PERL_MAGIC_isaelem
-#define PERL_MAGIC_isaelem 'i'
-#endif
-#ifndef PERL_MAGIC_nkeys
-#define PERL_MAGIC_nkeys 'k'
-#endif
-#ifndef PERL_MAGIC_dbfile
-#define PERL_MAGIC_dbfile 'L'
-#endif
-#ifndef PERL_MAGIC_dbline
-#define PERL_MAGIC_dbline 'l'
-#endif
-#ifndef PERL_MAGIC_mutex
-#define PERL_MAGIC_mutex 'm'
-#endif
-#ifndef PERL_MAGIC_shared
-#define PERL_MAGIC_shared 'N'
-#endif
-#ifndef PERL_MAGIC_shared_scalar
-#define PERL_MAGIC_shared_scalar 'n'
-#endif
-#ifndef PERL_MAGIC_collxfrm
-#define PERL_MAGIC_collxfrm 'o'
-#endif
-#ifndef PERL_MAGIC_tied
-#define PERL_MAGIC_tied 'P'
-#endif
-#ifndef PERL_MAGIC_tiedelem
-#define PERL_MAGIC_tiedelem 'p'
-#endif
-#ifndef PERL_MAGIC_tiedscalar
-#define PERL_MAGIC_tiedscalar 'q'
-#endif
-#ifndef PERL_MAGIC_qr
-#define PERL_MAGIC_qr 'r'
-#endif
-#ifndef PERL_MAGIC_sig
-#define PERL_MAGIC_sig 'S'
-#endif
-#ifndef PERL_MAGIC_sigelem
-#define PERL_MAGIC_sigelem 's'
-#endif
-#ifndef PERL_MAGIC_taint
-#define PERL_MAGIC_taint 't'
-#endif
-#ifndef PERL_MAGIC_uvar
-#define PERL_MAGIC_uvar 'U'
-#endif
-#ifndef PERL_MAGIC_uvar_elem
-#define PERL_MAGIC_uvar_elem 'u'
-#endif
-#ifndef PERL_MAGIC_vstring
-#define PERL_MAGIC_vstring 'V'
-#endif
-#ifndef PERL_MAGIC_vec
-#define PERL_MAGIC_vec 'v'
-#endif
-#ifndef PERL_MAGIC_utf8
-#define PERL_MAGIC_utf8 'w'
-#endif
-#ifndef PERL_MAGIC_substr
-#define PERL_MAGIC_substr 'x'
-#endif
-#ifndef PERL_MAGIC_defelem
-#define PERL_MAGIC_defelem 'y'
-#endif
-#ifndef PERL_MAGIC_glob
-#define PERL_MAGIC_glob '*'
-#endif
-#ifndef PERL_MAGIC_arylen
-#define PERL_MAGIC_arylen '#'
-#endif
-#ifndef PERL_MAGIC_pos
-#define PERL_MAGIC_pos '.'
-#endif
-#ifndef PERL_MAGIC_backref
-#define PERL_MAGIC_backref '<'
-#endif
-#ifndef PERL_MAGIC_ext
-#define PERL_MAGIC_ext '~'
-#endif
#ifndef sv_catpvn_nomg
#define sv_catpvn_nomg sv_catpvn
#endif
#else
extern MAGIC * DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl);
#endif
+#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL)
#define mg_findext DPPP_(my_mg_findext)
#define Perl_mg_findext DPPP_(my_mg_findext)
-#if defined(NEED_mg_findext) || defined(NEED_mg_findext_GLOBAL)
MAGIC *
DPPP_(my_mg_findext)(SV * sv, int type, const MGVTBL *vtbl) {
if (sv) {
#else
extern int DPPP_(my_sv_unmagicext)(pTHX_ SV * const sv, const int type, MGVTBL * vtbl);
#endif
+#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL)
#ifdef sv_unmagicext
#undef sv_unmagicext
#endif
#define sv_unmagicext(a,b,c) DPPP_(my_sv_unmagicext)(aTHX_ a,b,c)
#define Perl_sv_unmagicext DPPP_(my_sv_unmagicext)
-#if defined(NEED_sv_unmagicext) || defined(NEED_sv_unmagicext_GLOBAL)
int
DPPP_(my_sv_unmagicext)(pTHX_ SV *const sv, const int type, MGVTBL *vtbl)
{
#else
extern const PERL_CONTEXT * DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp);
#endif
+#if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL)
#ifdef caller_cx
#undef caller_cx
#endif
#define caller_cx(a,b) DPPP_(my_caller_cx)(aTHX_ a,b)
#define Perl_caller_cx DPPP_(my_caller_cx)
-#if defined(NEED_caller_cx) || defined(NEED_caller_cx_GLOBAL)
const PERL_CONTEXT *
DPPP_(my_caller_cx)(pTHX_ I32 count, const PERL_CONTEXT **dbcxp)
{
#else
extern bool DPPP_(my_grok_numeric_radix)(pTHX_ const char ** sp, const char * send);
#endif
+#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
#ifdef grok_numeric_radix
#undef grok_numeric_radix
#endif
#define grok_numeric_radix(a,b) DPPP_(my_grok_numeric_radix)(aTHX_ a,b)
#define Perl_grok_numeric_radix DPPP_(my_grok_numeric_radix)
-#if defined(NEED_grok_numeric_radix) || defined(NEED_grok_numeric_radix_GLOBAL)
bool
DPPP_(my_grok_numeric_radix)(pTHX_ const char **sp, const char *send)
{
#else
extern int DPPP_(my_grok_number)(pTHX_ const char * pv, STRLEN len, UV * valuep);
#endif
+#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
#ifdef grok_number
#undef grok_number
#endif
#define grok_number(a,b,c) DPPP_(my_grok_number)(aTHX_ a,b,c)
#define Perl_grok_number DPPP_(my_grok_number)
-#if defined(NEED_grok_number) || defined(NEED_grok_number_GLOBAL)
int
DPPP_(my_grok_number)(pTHX_ const char *pv, STRLEN len, UV *valuep)
{
#else
extern UV DPPP_(my_grok_bin)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
#endif
+#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
#ifdef grok_bin
#undef grok_bin
#endif
#define grok_bin(a,b,c,d) DPPP_(my_grok_bin)(aTHX_ a,b,c,d)
#define Perl_grok_bin DPPP_(my_grok_bin)
-#if defined(NEED_grok_bin) || defined(NEED_grok_bin_GLOBAL)
UV
DPPP_(my_grok_bin)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
{
#else
extern UV DPPP_(my_grok_hex)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
#endif
+#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
#ifdef grok_hex
#undef grok_hex
#endif
#define grok_hex(a,b,c,d) DPPP_(my_grok_hex)(aTHX_ a,b,c,d)
#define Perl_grok_hex DPPP_(my_grok_hex)
-#if defined(NEED_grok_hex) || defined(NEED_grok_hex_GLOBAL)
UV
DPPP_(my_grok_hex)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
{
#else
extern UV DPPP_(my_grok_oct)(pTHX_ const char * start, STRLEN * len_p, I32 * flags, NV * result);
#endif
+#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
#ifdef grok_oct
#undef grok_oct
#endif
#define grok_oct(a,b,c,d) DPPP_(my_grok_oct)(aTHX_ a,b,c,d)
#define Perl_grok_oct DPPP_(my_grok_oct)
-#if defined(NEED_grok_oct) || defined(NEED_grok_oct_GLOBAL)
UV
DPPP_(my_grok_oct)(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result)
{
#else
extern int DPPP_(my_my_snprintf)(char * buffer, const Size_t len, const char * format, ...);
#endif
+#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
#define my_snprintf DPPP_(my_my_snprintf)
#define Perl_my_snprintf DPPP_(my_my_snprintf)
-#if defined(NEED_my_snprintf) || defined(NEED_my_snprintf_GLOBAL)
int
DPPP_(my_my_snprintf)(char *buffer, const Size_t len, const char *format, ...)
{
#else
extern int DPPP_(my_my_sprintf)(char * buffer, const char * pat, ...);
#endif
+#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
#define my_sprintf DPPP_(my_my_sprintf)
#define Perl_my_sprintf DPPP_(my_my_sprintf)
-#if defined(NEED_my_sprintf) || defined(NEED_my_sprintf_GLOBAL)
int
DPPP_(my_my_sprintf)(char *buffer, const char* pat, ...)
{
#else
extern Size_t DPPP_(my_my_strlcat)(char * dst, const char * src, Size_t size);
#endif
+#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
#define my_strlcat DPPP_(my_my_strlcat)
#define Perl_my_strlcat DPPP_(my_my_strlcat)
-#if defined(NEED_my_strlcat) || defined(NEED_my_strlcat_GLOBAL)
Size_t
DPPP_(my_my_strlcat)(char *dst, const char *src, Size_t size)
{
#else
extern Size_t DPPP_(my_my_strlcpy)(char * dst, const char * src, Size_t size);
#endif
+#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
#define my_strlcpy DPPP_(my_my_strlcpy)
#define Perl_my_strlcpy DPPP_(my_my_strlcpy)
-#if defined(NEED_my_strlcpy) || defined(NEED_my_strlcpy_GLOBAL)
Size_t
DPPP_(my_my_strlcpy)(char *dst, const char *src, Size_t size)
{
#else
extern char * DPPP_(my_pv_escape)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags);
#endif
+#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
#ifdef pv_escape
#undef pv_escape
#endif
#define pv_escape(a,b,c,d,e,f) DPPP_(my_pv_escape)(aTHX_ a,b,c,d,e,f)
#define Perl_pv_escape DPPP_(my_pv_escape)
-#if defined(NEED_pv_escape) || defined(NEED_pv_escape_GLOBAL)
char *
DPPP_(my_pv_escape)(pTHX_ SV *dsv, char const * const str,
const STRLEN count, const STRLEN max,
#else
extern char * DPPP_(my_pv_pretty)(pTHX_ SV * dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags);
#endif
+#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
#ifdef pv_pretty
#undef pv_pretty
#endif
#define pv_pretty(a,b,c,d,e,f,g) DPPP_(my_pv_pretty)(aTHX_ a,b,c,d,e,f,g)
#define Perl_pv_pretty DPPP_(my_pv_pretty)
-#if defined(NEED_pv_pretty) || defined(NEED_pv_pretty_GLOBAL)
char *
DPPP_(my_pv_pretty)(pTHX_ SV *dsv, char const * const str, const STRLEN count,
const STRLEN max, char const * const start_color, char const * const end_color,
#else
extern char * DPPP_(my_pv_display)(pTHX_ SV * dsv, const char * pv, STRLEN cur, STRLEN len, STRLEN pvlim);
#endif
+#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
#ifdef pv_display
#undef pv_display
#endif
#define pv_display(a,b,c,d,e) DPPP_(my_pv_display)(aTHX_ a,b,c,d,e)
#define Perl_pv_display DPPP_(my_pv_display)
-#if defined(NEED_pv_display) || defined(NEED_pv_display_GLOBAL)
char *
DPPP_(my_pv_display)(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
{
-# basic C types
-int T_IV
-unsigned T_UV
-unsigned int T_UV
-long T_IV
-unsigned long T_UV
-short T_IV
-unsigned short T_UV
-char T_CHAR
-unsigned char T_U_CHAR
-char * T_PV
-unsigned char * T_PV
-const char * T_PV
-caddr_t T_PV
-wchar_t * T_PV
-wchar_t T_IV
-# bool_t is defined in <rpc/rpc.h>
-bool_t T_IV
-size_t T_UV
-ssize_t T_IV
-time_t T_NV
-unsigned long * T_OPAQUEPTR
-char ** T_PACKEDARRAY
-void * T_PTR
-Time_t * T_PV
-SV * T_SV
+################################################################################
+#
+# typemap -- XS type mappings not present in early perls
+#
+################################################################################
+#
+# Version 3.x, Copyright (C) 2004-2013, Marcus Holland-Moritz.
+# Version 2.x, Copyright (C) 2001, Paul Marquess.
+# Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the same terms as Perl itself.
+#
+################################################################################
-# These are the backwards-compatibility AV*/HV* typemaps that
-# do not decrement refcounts. Locally override with
-# "AV* T_AVREF_REFCOUNT_FIXED", "HV* T_HVREF_REFCOUNT_FIXED",
-# "CV* T_CVREF_REFCOUNT_FIXED", "SVREF T_SVREF_REFCOUNT_FIXED",
-# to get the fixed versions.
-SVREF T_SVREF
-CV * T_CVREF
-AV * T_AVREF
-HV * T_HVREF
-
-IV T_IV
-UV T_UV
+UV T_UV
NV T_NV
-I32 T_IV
-I16 T_IV
-I8 T_IV
-STRLEN T_UV
-U32 T_U_LONG
-U16 T_U_SHORT
-U8 T_UV
-Result T_U_CHAR
-Boolean T_BOOL
-float T_FLOAT
-double T_DOUBLE
-SysRet T_SYSRET
-SysRetLong T_SYSRET
-FILE * T_STDIO
-PerlIO * T_INOUT
-FileHandle T_PTROBJ
-InputStream T_IN
-InOutStream T_INOUT
-OutputStream T_OUT
-bool T_BOOL
+HV * T_HVREF
+STRLEN T_UV
-#############################################################################
INPUT
-T_SV
- $var = $arg
-T_SVREF
- STMT_START {
- SV* const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- if (SvROK(xsub_tmp_sv)){
- $var = SvRV(xsub_tmp_sv);
- }
- else{
- Perl_croak_nocontext(\"%s: %s is not a reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_SVREF_REFCOUNT_FIXED
- STMT_START {
- SV* const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- if (SvROK(xsub_tmp_sv)){
- $var = SvRV(xsub_tmp_sv);
- }
- else{
- Perl_croak_nocontext(\"%s: %s is not a reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_AVREF
- STMT_START {
- SV* const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
- $var = (AV*)SvRV(xsub_tmp_sv);
- }
- else{
- Perl_croak_nocontext(\"%s: %s is not an ARRAY reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_AVREF_REFCOUNT_FIXED
- STMT_START {
- SV* const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
- $var = (AV*)SvRV(xsub_tmp_sv);
- }
- else{
- Perl_croak_nocontext(\"%s: %s is not an ARRAY reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_HVREF
- STMT_START {
- SV* const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVHV){
- $var = (HV*)SvRV(xsub_tmp_sv);
- }
- else{
- Perl_croak_nocontext(\"%s: %s is not a HASH reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_HVREF_REFCOUNT_FIXED
- STMT_START {
- SV* const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVHV){
- $var = (HV*)SvRV(xsub_tmp_sv);
- }
- else{
- Perl_croak_nocontext(\"%s: %s is not a HASH reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_CVREF
- STMT_START {
- HV *st;
- GV *gvp;
- SV * const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- $var = sv_2cv(xsub_tmp_sv, &st, &gvp, 0);
- if (!$var) {
- Perl_croak_nocontext(\"%s: %s is not a CODE reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_CVREF_REFCOUNT_FIXED
- STMT_START {
- HV *st;
- GV *gvp;
- SV * const xsub_tmp_sv = $arg;
- SvGETMAGIC(xsub_tmp_sv);
- $var = sv_2cv(xsub_tmp_sv, &st, &gvp, 0);
- if (!$var) {
- Perl_croak_nocontext(\"%s: %s is not a CODE reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\");
- }
- } STMT_END
-T_SYSRET
- $var NOT IMPLEMENTED
T_UV
- $var = ($type)SvUV($arg)
-T_IV
- $var = ($type)SvIV($arg)
-T_INT
- $var = (int)SvIV($arg)
-T_ENUM
- $var = ($type)SvIV($arg)
-T_BOOL
- $var = (bool)SvTRUE($arg)
-T_U_INT
- $var = (unsigned int)SvUV($arg)
-T_SHORT
- $var = (short)SvIV($arg)
-T_U_SHORT
- $var = (unsigned short)SvUV($arg)
-T_LONG
- $var = (long)SvIV($arg)
-T_U_LONG
- $var = (unsigned long)SvUV($arg)
-T_CHAR
- $var = (char)*SvPV_nolen($arg)
-T_U_CHAR
- $var = (unsigned char)SvUV($arg)
-T_FLOAT
- $var = (float)SvNV($arg)
+ $var = ($type)SvUV($arg)
T_NV
- $var = ($type)SvNV($arg)
-T_DOUBLE
- $var = (double)SvNV($arg)
-T_PV
- $var = ($type)SvPV_nolen($arg)
-T_PTR
- $var = INT2PTR($type,SvIV($arg))
-T_PTRREF
- if (SvROK($arg)) {
- IV tmp = SvIV((SV*)SvRV($arg));
- $var = INT2PTR($type,tmp);
- }
- else
- Perl_croak_nocontext(\"%s: %s is not a reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\")
-T_REF_IV_REF
- if (sv_isa($arg, \"${ntype}\")) {
- IV tmp = SvIV((SV*)SvRV($arg));
- $var = *INT2PTR($type *, tmp);
- }
- else
- Perl_croak_nocontext(\"%s: %s is not of type %s\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\", \"$ntype\")
-T_REF_IV_PTR
- if (sv_isa($arg, \"${ntype}\")) {
- IV tmp = SvIV((SV*)SvRV($arg));
- $var = INT2PTR($type, tmp);
- }
- else
- Perl_croak_nocontext(\"%s: %s is not of type %s\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\", \"$ntype\")
-T_PTROBJ
- if (SvROK($arg) && sv_derived_from($arg, \"${ntype}\")) {
- IV tmp = SvIV((SV*)SvRV($arg));
- $var = INT2PTR($type,tmp);
- }
- else
- Perl_croak_nocontext(\"%s: %s is not of type %s\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\", \"$ntype\")
-T_PTRDESC
- if (sv_isa($arg, \"${ntype}\")) {
- IV tmp = SvIV((SV*)SvRV($arg));
- ${type}_desc = (\U${type}_DESC\E*) tmp;
- $var = ${type}_desc->ptr;
- }
- else
- Perl_croak_nocontext(\"%s: %s is not of type %s\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\", \"$ntype\")
-T_REFREF
- if (SvROK($arg)) {
- IV tmp = SvIV((SV*)SvRV($arg));
- $var = *INT2PTR($type,tmp);
- }
- else
- Perl_croak_nocontext(\"%s: %s is not a reference\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\")
-T_REFOBJ
- if (sv_isa($arg, \"${ntype}\")) {
- IV tmp = SvIV((SV*)SvRV($arg));
- $var = *INT2PTR($type,tmp);
- }
- else
- Perl_croak_nocontext(\"%s: %s is not of type %s\",
- ${$ALIAS?\q[GvNAME(CvGV(cv))]:\qq[\"$pname\"]},
- \"$var\", \"$ntype\")
-T_OPAQUE
- $var = *($type *)SvPV_nolen($arg)
-T_OPAQUEPTR
- $var = ($type)SvPV_nolen($arg)
-T_PACKED
- $var = XS_unpack_$ntype($arg)
-T_PACKEDARRAY
- $var = XS_unpack_$ntype($arg)
-T_ARRAY
- U32 ix_$var = $argoff;
- $var = $ntype(items -= $argoff);
- while (items--) {
- DO_ARRAY_ELEM;
- ix_$var++;
- }
- /* this is the number of elements in the array */
- ix_$var -= $argoff
-T_STDIO
- $var = PerlIO_findFILE(IoIFP(sv_2io($arg)))
-T_IN
- $var = IoIFP(sv_2io($arg))
-T_INOUT
- $var = IoIFP(sv_2io($arg))
-T_OUT
- $var = IoOFP(sv_2io($arg))
-#############################################################################
-OUTPUT
-T_SV
- $arg = $var;
-T_SVREF
- $arg = newRV((SV*)$var);
-T_SVREF_REFCOUNT_FIXED
- $arg = newRV_noinc((SV*)$var);
-T_AVREF
- $arg = newRV((SV*)$var);
-T_AVREF_REFCOUNT_FIXED
- $arg = newRV_noinc((SV*)$var);
+ $var = ($type)SvNV($arg)
T_HVREF
- $arg = newRV((SV*)$var);
-T_HVREF_REFCOUNT_FIXED
- $arg = newRV_noinc((SV*)$var);
-T_CVREF
- $arg = newRV((SV*)$var);
-T_CVREF_REFCOUNT_FIXED
- $arg = newRV_noinc((SV*)$var);
-T_IV
- sv_setiv($arg, (IV)$var);
+ if (SvROK($arg) && SvTYPE(SvRV($arg))==SVt_PVHV)
+ $var = (HV*)SvRV($arg);
+ else
+ Perl_croak(aTHX_ \"$var is not a hash reference\")
+
+OUTPUT
T_UV
- sv_setuv($arg, (UV)$var);
-T_INT
- sv_setiv($arg, (IV)$var);
-T_SYSRET
- if ($var != -1) {
- if ($var == 0)
- sv_setpvn($arg, "0 but true", 10);
- else
- sv_setiv($arg, (IV)$var);
- }
-T_ENUM
- sv_setiv($arg, (IV)$var);
-T_BOOL
- ${"$var" eq "RETVAL" ? \"$arg = boolSV($var);" : \"sv_setsv($arg, boolSV($var));"}
-T_U_INT
- sv_setuv($arg, (UV)$var);
-T_SHORT
- sv_setiv($arg, (IV)$var);
-T_U_SHORT
- sv_setuv($arg, (UV)$var);
-T_LONG
- sv_setiv($arg, (IV)$var);
-T_U_LONG
- sv_setuv($arg, (UV)$var);
-T_CHAR
- sv_setpvn($arg, (char *)&$var, 1);
-T_U_CHAR
- sv_setuv($arg, (UV)$var);
-T_FLOAT
- sv_setnv($arg, (double)$var);
+ sv_setuv($arg, (UV)$var);
T_NV
- sv_setnv($arg, (NV)$var);
-T_DOUBLE
- sv_setnv($arg, (double)$var);
-T_PV
- sv_setpv((SV*)$arg, $var);
-T_PTR
- sv_setiv($arg, PTR2IV($var));
-T_PTRREF
- sv_setref_pv($arg, Nullch, (void*)$var);
-T_REF_IV_REF
- sv_setref_pv($arg, \"${ntype}\", (void*)new $ntype($var));
-T_REF_IV_PTR
- sv_setref_pv($arg, \"${ntype}\", (void*)$var);
-T_PTROBJ
- sv_setref_pv($arg, \"${ntype}\", (void*)$var);
-T_PTRDESC
- sv_setref_pv($arg, \"${ntype}\", (void*)new\U${type}_DESC\E($var));
-T_REFREF
- NOT_IMPLEMENTED
-T_REFOBJ
- NOT IMPLEMENTED
-T_OPAQUE
- sv_setpvn($arg, (char *)&$var, sizeof($var));
-T_OPAQUEPTR
- sv_setpvn($arg, (char *)$var, sizeof(*$var));
-T_PACKED
- XS_pack_$ntype($arg, $var);
-T_PACKEDARRAY
- XS_pack_$ntype($arg, $var, count_$ntype);
-T_ARRAY
- {
- U32 ix_$var;
- SSize_t extend_size =
- /* The weird way this is written is because g++ is dumb
- * enough to warn "comparison is always false" on something
- * like:
- *
- * sizeof(a) > sizeof(b) && a > B_t_MAX
- *
- * (where the LH condition is false)
- */
- (size_$var > (sizeof(size_$var) > sizeof(SSize_t)
- ? SSize_t_MAX : size_$var))
- ? -1 : (SSize_t)size_$var;
- EXTEND(SP, extend_size);
- for (ix_$var = 0; ix_$var < size_$var; ix_$var++) {
- ST(ix_$var) = sv_newmortal();
- DO_ARRAY_ELEM
- }
- }
-T_STDIO
- {
- GV *gv = newGVgen("$Package");
- PerlIO *fp = PerlIO_importFILE($var,0);
- if ( fp && do_open(gv, "+<&", 3, FALSE, 0, 0, fp) ) {
- SV *rv = newRV_inc((SV*)gv);
- rv = sv_bless(rv, GvSTASH(gv));
- ${"$var" eq "RETVAL" ? \"$arg = sv_2mortal(rv);"
- : \"sv_setsv($arg, rv);\n\t\tSvREFCNT_dec_NN(rv);"}
- }${"$var" ne "RETVAL" ? \"
- else
- sv_setsv($arg, &PL_sv_undef);\n" : \""}
- }
-T_IN
- {
- GV *gv = newGVgen("$Package");
- if ( do_open(gv, "<&", 2, FALSE, 0, 0, $var) ) {
- SV *rv = newRV_inc((SV*)gv);
- rv = sv_bless(rv, GvSTASH(gv));
- ${"$var" eq "RETVAL" ? \"$arg = sv_2mortal(rv);"
- : \"sv_setsv($arg, rv);\n\t\tSvREFCNT_dec_NN(rv);"}
- }${"$var" ne "RETVAL" ? \"
- else
- sv_setsv($arg, &PL_sv_undef);\n" : \""}
- }
-T_INOUT
- {
- GV *gv = newGVgen("$Package");
- if ( do_open(gv, "+<&", 3, FALSE, 0, 0, $var) ) {
- SV *rv = newRV_inc((SV*)gv);
- rv = sv_bless(rv, GvSTASH(gv));
- ${"$var" eq "RETVAL" ? \"$arg = sv_2mortal(rv);"
- : \"sv_setsv($arg, rv);\n\t\tSvREFCNT_dec_NN(rv);"}
- }${"$var" ne "RETVAL" ? \"
- else
- sv_setsv($arg, &PL_sv_undef);\n" : \""}
- }
-T_OUT
- {
- GV *gv = newGVgen("$Package");
- if ( do_open(gv, "+>&", 3, FALSE, 0, 0, $var) ) {
- SV *rv = newRV_inc((SV*)gv);
- rv = sv_bless(rv, GvSTASH(gv));
- ${"$var" eq "RETVAL" ? \"$arg = sv_2mortal(rv);"
- : \"sv_setsv($arg, rv);\n\t\tSvREFCNT_dec_NN(rv);"}
- }${"$var" ne "RETVAL" ? \"
- else
- sv_setsv($arg, &PL_sv_undef);\n" : \""}
- }
+ sv_setnv($arg, (NV)$var);
projects / irc / kvirc / KVIrc.git / commitdiff
