[gitmo/Mouse.git] / xs-src / MouseAccessor.xs

#include "mouse.h"

#define CHECK_INSTANCE(instance) STMT_START{                          \
        if(!(SvROK(instance) && SvTYPE(SvRV(instance)) == SVt_PVHV)){ \
            croak("Invalid object instance");                         \
        }                                                             \
    } STMT_END


#define MOUSE_mg_attribute(mg) MOUSE_xa_attribute(MOUSE_mg_xa(mg))

static MGVTBL mouse_accessor_vtbl; /* MAGIC identity */

#define dMOUSE_self  SV* const self = mouse_accessor_get_self(aTHX_ ax, items, cv)

static inline SV*
mouse_accessor_get_self(pTHX_ I32 const ax, I32 const items, CV* const cv) {
    if(items < 1){
        croak("Too few arguments for %s", GvNAME(CvGV(cv)));
    }

    /* NOTE: If self has GETMAGIC, $self->accessor will invoke GETMAGIC
     *       before calling methods, so SvGETMAGIC(self) is not necessarily needed here.
     */

    return ST(0);
}


CV*
mouse_accessor_generate(pTHX_ SV* const attr, XSUBADDR_t const accessor_impl){
    AV* const xa = mouse_get_xa(aTHX_ attr);
    CV* xsub;
    MAGIC* mg;

    xsub = newXS(NULL, accessor_impl, __FILE__);
    sv_2mortal((SV*)xsub);

    mg = sv_magicext((SV*)xsub, MOUSE_xa_slot(xa), PERL_MAGIC_ext, &mouse_accessor_vtbl, (char*)xa, HEf_SVKEY);

    MOUSE_mg_flags(mg) = (U16)MOUSE_xa_flags(xa);

    /* NOTE:
     * although we use MAGIC for gc, we also store mg to CvXSUBANY for efficiency (gfx)
     */
    CvXSUBANY(xsub).any_ptr = (void*)mg;

    return xsub;
}


#define PUSH_VALUE(value, flags) STMT_START { \
        if((flags) & MOUSEf_ATTR_SHOULD_AUTO_DEREF && GIMME_V == G_ARRAY){ \
            mouse_push_values(aTHX_ value, (flags));                       \
        }                                                                  \
        else{                                                              \
            dSP;                                                           \
            XPUSHs(value ? value : &PL_sv_undef);                          \
            PUTBACK;                                                       \
        }                                                                  \
    } STMT_END                                                             \

/* pushes return values, does auto-deref if needed */
static void
mouse_push_values(pTHX_ SV* const value, U16 const flags){
    dSP;

    assert( flags & MOUSEf_ATTR_SHOULD_AUTO_DEREF && GIMME_V == G_ARRAY );

    if(!(value && SvOK(value))){
        return;
    }

    if(flags & MOUSEf_TC_IS_ARRAYREF){
        AV* av;
        I32 len;
        I32 i;

        if(!IsArrayRef(value)){
            croak("Mouse-panic: Not an ARRAY reference");
        }

        av  = (AV*)SvRV(value);
        len = av_len(av) + 1;
        EXTEND(SP, len);
        for(i = 0; i < len; i++){
            SV** const svp = av_fetch(av, i, FALSE);
            PUSHs(svp ? *svp : &PL_sv_undef);
        }
    }
    else if(flags & MOUSEf_TC_IS_HASHREF){
        HV* hv;
        HE* he;

        if(!IsHashRef(value)){
            croak("Mouse-panic: Not a HASH reference");
        }

        hv = (HV*)SvRV(value);
        hv_iterinit(hv);
        while((he = hv_iternext(hv))){
            EXTEND(SP, 2);
            PUSHs(hv_iterkeysv(he));
            PUSHs(hv_iterval(hv, he));
        }
    }

    PUTBACK;
}

static void
mouse_attr_get(pTHX_ SV* const self, MAGIC* const mg){
    U16 const flags = MOUSE_mg_flags(mg);
    SV* value;

    value = get_slot(self, MOUSE_mg_slot(mg));

    /* check_lazy */
    if( !value && flags & MOUSEf_ATTR_IS_LAZY ){
        value = mouse_xa_set_default(aTHX_ MOUSE_mg_xa(mg), self);
    }

    PUSH_VALUE(value, flags);
}

static void
mouse_attr_set(pTHX_ SV* const self, MAGIC* const mg, SV* value){
    U16 const flags = MOUSE_mg_flags(mg);
    SV* const slot  = MOUSE_mg_slot(mg);

    if(flags & MOUSEf_ATTR_HAS_TC){
        value = mouse_xa_apply_type_constraint(aTHX_ MOUSE_mg_xa(mg), value, flags);
    }

    set_slot(self, slot, value);

    if(flags & MOUSEf_ATTR_IS_WEAK_REF){
        weaken_slot(self, slot);
    }

    if(flags & MOUSEf_ATTR_HAS_TRIGGER){
        SV* const trigger = mcall0s(MOUSE_mg_attribute(mg), "trigger");
        dSP;

        PUSHMARK(SP);
        EXTEND(SP, 2);
        PUSHs(self);
        PUSHs(value);

        PUTBACK;
        call_sv(trigger, G_VOID | G_DISCARD);
        /* need not SPAGAIN */
    }

    PUSH_VALUE(value, flags);
}

XS(XS_Mouse_accessor)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    MAGIC* const mg = (MAGIC*)XSANY.any_ptr;

    SP -= items; /* PPCODE */
    PUTBACK;

    if(items == 1){ /* reader */
        mouse_attr_get(aTHX_ self, mg);
    }
    else if (items == 2){ /* writer */
        mouse_attr_set(aTHX_ self, mg, ST(1));
    }
    else{
        mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
            "Expected exactly one or two argument for an accessor");
    }
}


XS(XS_Mouse_reader)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    MAGIC* const mg = (MAGIC*)XSANY.any_ptr;

    if (items != 1) {
        mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
            "Cannot assign a value to a read-only accessor");
    }

    SP -= items; /* PPCODE */
    PUTBACK;

    mouse_attr_get(aTHX_ self, mg);
}

XS(XS_Mouse_writer)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    MAGIC* const mg = (MAGIC*)XSANY.any_ptr;

    if (items != 2) {
        mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
            "Too few arguments for a write-only accessor");
    }

    SP -= items; /* PPCODE */
    PUTBACK;

    mouse_attr_set(aTHX_ self, mg, ST(1));
}

/* simple accessors */

/*
static MAGIC*
mouse_accessor_get_mg(pTHX_ CV* const xsub){
    return moose_mg_find(aTHX_ (SV*)xsub, &mouse_simple_accessor_vtbl, MOOSEf_DIE_ON_FAIL);
}
*/

CV*
mouse_simple_accessor_generate(pTHX_ const char* const fq_name, const char* const key, I32 const keylen, XSUBADDR_t const accessor_impl, void* const dptr, I32 const dlen){
    CV* const xsub = newXS((char*)fq_name, accessor_impl, __FILE__);
    SV* const slot = newSVpvn_share(key, keylen, 0U);
    MAGIC* mg;

    if(!fq_name){
        /* anonymous xsubs need sv_2mortal */
        sv_2mortal((SV*)xsub);
    }

    mg = sv_magicext((SV*)xsub, slot, PERL_MAGIC_ext, &mouse_accessor_vtbl, (char*)dptr, dlen);
    SvREFCNT_dec(slot); /* sv_magicext() increases refcnt in mg_obj */
    if(dlen == HEf_SVKEY){
        SvREFCNT_dec(dptr);
    }

    /* NOTE:
     * although we use MAGIC for gc, we also store mg to CvXSUBANY for efficiency (gfx)
     */
    CvXSUBANY(xsub).any_ptr = (void*)mg;

    return xsub;
}

XS(XS_Mouse_simple_accessor)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
    SV* value;

    if(items == 1){ /* reader */
        value = get_slot(self, MOUSE_mg_slot(mg));
        if(!value){
            value = &PL_sv_undef;
        }
    }
    else if(items == 2){ /* writer */
         value = set_slot(self, MOUSE_mg_slot(mg), ST(1));
    }
    else {
        croak("Expected exactly one or two argument for an accessor for '%"SVf"'", MOUSE_mg_slot(mg));
    }

    ST(0) = value;
    XSRETURN(1);
}

XS(XS_Mouse_simple_reader)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
    SV* value;

    if (items != 1) {
        croak("Expected exactly one argument for a reader for '%"SVf"'", MOUSE_mg_slot(mg));
    }

    value = get_slot(self, MOUSE_mg_slot(mg));
    if(!value) {
        if(MOUSE_mg_ptr(mg)){
            /* the default value must be a SV */
            assert(MOUSE_mg_len(mg) == HEf_SVKEY);
            value = (SV*)MOUSE_mg_ptr(mg);
        }
        else{
            value = &PL_sv_undef;
        }
    }

    ST(0) = value;
    XSRETURN(1);
}


XS(XS_Mouse_simple_writer)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);

    if (items != 2) {
        croak("Expected exactly two argument for a writer for '%"SVf"'", slot);
    }

    ST(0) = set_slot(self, slot, ST(1));
    XSRETURN(1);
}

XS(XS_Mouse_simple_clearer)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
    SV* value;

    if (items != 1) {
        croak("Expected exactly one argument for a clearer for '%"SVf"'", slot);
    }

    value = delete_slot(self, slot);
    ST(0) = value ? value : &PL_sv_undef;
    XSRETURN(1);
}

XS(XS_Mouse_simple_predicate)
{
    dVAR; dXSARGS;
    dMOUSE_self;
    SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);

    if (items != 1) {
        croak("Expected exactly one argument for a predicate for '%"SVf"'", slot);
    }

    ST(0) = boolSV( has_slot(self, slot) );
    XSRETURN(1);
}

/* simple instance slot accessor (or Mouse::Meta::Instance) */

SV*
mouse_instance_create(pTHX_ HV* const stash) {
    assert(stash);
    assert(SvTYPE(stash) == SVt_PVHV);
    return sv_bless( newRV_noinc((SV*)newHV()), stash );
}

SV*
mouse_instance_clone(pTHX_ SV* const instance) {
    HV* proto;
    assert(instance);

    CHECK_INSTANCE(instance);
    proto = newHVhv((HV*)SvRV(instance));
    return sv_bless( newRV_noinc((SV*)proto), SvSTASH(SvRV(instance)) );
}

bool
mouse_instance_has_slot(pTHX_ SV* const instance, SV* const slot) {
    assert(instance);
    assert(slot);
    CHECK_INSTANCE(instance);
    return hv_exists_ent((HV*)SvRV(instance), slot, 0U);
}

SV*
mouse_instance_get_slot(pTHX_ SV* const instance, SV* const slot) {
    HE* he;
    assert(instance);
    assert(slot);
    CHECK_INSTANCE(instance);
    he = hv_fetch_ent((HV*)SvRV(instance), slot, FALSE, 0U);
    return he ? HeVAL(he) : NULL;
}

SV*
mouse_instance_set_slot(pTHX_ SV* const instance, SV* const slot, SV* const value) {
    HE* he;
    SV* sv;
    assert(instance);
    assert(slot);
    assert(value);
    CHECK_INSTANCE(instance);
    he = hv_fetch_ent((HV*)SvRV(instance), slot, TRUE, 0U);
    sv = HeVAL(he);
    sv_setsv(sv, value);
    SvSETMAGIC(sv);
    return sv;
}

SV*
mouse_instance_delete_slot(pTHX_ SV* const instance, SV* const slot) {
    assert(instance);
    assert(slot);
    CHECK_INSTANCE(instance);
    return hv_delete_ent((HV*)SvRV(instance), slot, 0, 0U);
}

void
mouse_instance_weaken_slot(pTHX_ SV* const instance, SV* const slot) {
    HE* he;
    assert(instance);
    assert(slot);
    CHECK_INSTANCE(instance);
    he = hv_fetch_ent((HV*)SvRV(instance), slot, FALSE, 0U);
    if(he){
        sv_rvweaken(HeVAL(he));
    }
}
\r
MODULE = Mouse::Meta::Method::Accessor::XS  PACKAGE = Mouse::Meta::Method::Accessor::XS

PROTOTYPES:   DISABLE
VERSIONCHECK: DISABLE

CV*
_generate_accessor(klass, SV* attr, metaclass)
CODE:
{
    RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_accessor);
}
OUTPUT:
    RETVAL

CV*
_generate_reader(klass, SV* attr, metaclass)
CODE:
{
    RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_reader);
}
OUTPUT:
    RETVAL

CV*
_generate_writer(klass, SV* attr, metaclass)
CODE:
{
    RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_writer);
}
OUTPUT:
    RETVAL

CV*
_generate_clearer(klass, SV* attr, metaclass)
CODE:
{
    SV* const slot = mcall0s(attr, "name");
    STRLEN len;
    const char* const pv = SvPV_const(slot, len);
    RETVAL = mouse_simple_accessor_generate(aTHX_ NULL, pv, len, XS_Mouse_simple_clearer, NULL, 0);
}
OUTPUT:
    RETVAL

CV*
_generate_predicate(klass, SV* attr, metaclass)
CODE:
{
    SV* const slot = mcall0s(attr, "name");
    STRLEN len;
    const char* const pv = SvPV_const(slot, len);
    RETVAL = mouse_simple_accessor_generate(aTHX_ NULL, pv, len, XS_Mouse_simple_predicate, NULL, 0);
}
OUTPUT:
    RETVAL
Commit	Line	Data
646c0371	1	#include "mouse.h"
	2
	3	#define CHECK_INSTANCE(instance) STMT_START{ \
	4	if(!(SvROK(instance) && SvTYPE(SvRV(instance)) == SVt_PVHV)){ \
76770976	5	croak("Invalid object instance"); \
646c0371	6	} \
	7	} STMT_END
	8
646c0371	9
	10	#define MOUSE_mg_attribute(mg) MOUSE_xa_attribute(MOUSE_mg_xa(mg))
	11
646c0371	12	static MGVTBL mouse_accessor_vtbl; /* MAGIC identity */
646c0371	13
cc7cd81f	14	#define dMOUSE_self SV* const self = mouse_accessor_get_self(aTHX_ ax, items, cv)
646c0371	15
cc7cd81f	16	static inline SV*
646c0371	17	mouse_accessor_get_self(pTHX_ I32 const ax, I32 const items, CV* const cv) {
646c0371	18	if(items < 1){
	19	croak("Too few arguments for %s", GvNAME(CvGV(cv)));
	20	}
	21
	22	/* NOTE: If self has GETMAGIC, $self->accessor will invoke GETMAGIC
	23	* before calling methods, so SvGETMAGIC(self) is not necessarily needed here.
	24	*/
	25
76770976	26	return ST(0);
646c0371	27	}
	28
	29
	30	CV*
a17f6313	31	mouse_accessor_generate(pTHX_ SV* const attr, XSUBADDR_t const accessor_impl){
0aad0266	32	AV* const xa = mouse_get_xa(aTHX_ attr);
646c0371	33	CV* xsub;
646c0371	34	MAGIC* mg;
646c0371	35
	36	xsub = newXS(NULL, accessor_impl, __FILE__);
	37	sv_2mortal((SV*)xsub);
	38
0aad0266	39	mg = sv_magicext((SV)xsub, MOUSE_xa_slot(xa), PERL_MAGIC_ext, &mouse_accessor_vtbl, (char)xa, HEf_SVKEY);
0aad0266	40
4e7e3250	41	MOUSE_mg_flags(mg) = (U16)MOUSE_xa_flags(xa);
646c0371	42
	43	/* NOTE:
	44	* although we use MAGIC for gc, we also store mg to CvXSUBANY for efficiency (gfx)
	45	*/
	46	CvXSUBANY(xsub).any_ptr = (void*)mg;
	47
646c0371	48	return xsub;
	49	}
	50
646c0371	51
208ffaeb	52	#define PUSH_VALUE(value, flags) STMT_START { \
	53	if((flags) & MOUSEf_ATTR_SHOULD_AUTO_DEREF && GIMME_V == G_ARRAY){ \
	54	mouse_push_values(aTHX_ value, (flags)); \
	55	} \
	56	else{ \
	57	dSP; \
	58	XPUSHs(value ? value : &PL_sv_undef); \
	59	PUTBACK; \
	60	} \
	61	} STMT_END \
646c0371	62
	63	/* pushes return values, does auto-deref if needed */
	64	static void
	65	mouse_push_values(pTHX_ SV* const value, U16 const flags){
	66	dSP;
	67
208ffaeb	68	assert( flags & MOUSEf_ATTR_SHOULD_AUTO_DEREF && GIMME_V == G_ARRAY );
646c0371	69
208ffaeb	70	if(!(value && SvOK(value))){
	71	return;
	72	}
646c0371	73
208ffaeb	74	if(flags & MOUSEf_TC_IS_ARRAYREF){
80aa5731	75	AV* av;
208ffaeb	76	I32 len;
208ffaeb	77	I32 i;
646c0371	78
80aa5731	79	if(!IsArrayRef(value)){
208ffaeb	80	croak("Mouse-panic: Not an ARRAY reference");
646c0371	81	}
646c0371	82
80aa5731	83	av = (AV*)SvRV(value);
208ffaeb	84	len = av_len(av) + 1;
	85	EXTEND(SP, len);
	86	for(i = 0; i < len; i++){
	87	SV** const svp = av_fetch(av, i, FALSE);
	88	PUSHs(svp ? *svp : &PL_sv_undef);
646c0371	89	}
646c0371	90	}
208ffaeb	91	else if(flags & MOUSEf_TC_IS_HASHREF){
80aa5731	92	HV* hv;
208ffaeb	93	HE* he;
208ffaeb	94
80aa5731	95	if(!IsHashRef(value)){
208ffaeb	96	croak("Mouse-panic: Not a HASH reference");
	97	}
	98
80aa5731	99	hv = (HV*)SvRV(value);
208ffaeb	100	hv_iterinit(hv);
	101	while((he = hv_iternext(hv))){
	102	EXTEND(SP, 2);
	103	PUSHs(hv_iterkeysv(he));
	104	PUSHs(hv_iterval(hv, he));
	105	}
646c0371	106	}
	107
	108	PUTBACK;
	109	}
	110
	111	static void
	112	mouse_attr_get(pTHX_ SV* const self, MAGIC* const mg){
	113	U16 const flags = MOUSE_mg_flags(mg);
646c0371	114	SV* value;
646c0371	115
4e7e3250	116	value = get_slot(self, MOUSE_mg_slot(mg));
646c0371	117
	118	/* check_lazy */
	119	if( !value && flags & MOUSEf_ATTR_IS_LAZY ){
4e7e3250	120	value = mouse_xa_set_default(aTHX_ MOUSE_mg_xa(mg), self);
646c0371	121	}
646c0371	122
208ffaeb	123	PUSH_VALUE(value, flags);
646c0371	124	}
	125
	126	static void
	127	mouse_attr_set(pTHX_ SV* const self, MAGIC* const mg, SV* value){
	128	U16 const flags = MOUSE_mg_flags(mg);
	129	SV* const slot = MOUSE_mg_slot(mg);
	130
	131	if(flags & MOUSEf_ATTR_HAS_TC){
4e7e3250	132	value = mouse_xa_apply_type_constraint(aTHX_ MOUSE_mg_xa(mg), value, flags);
646c0371	133	}
646c0371	134
6fe2272b	135	set_slot(self, slot, value);
646c0371	136
646c0371	137	if(flags & MOUSEf_ATTR_IS_WEAK_REF){
6fe2272b	138	weaken_slot(self, slot);
646c0371	139	}
	140
	141	if(flags & MOUSEf_ATTR_HAS_TRIGGER){
	142	SV* const trigger = mcall0s(MOUSE_mg_attribute(mg), "trigger");
	143	dSP;
	144
	145	PUSHMARK(SP);
	146	EXTEND(SP, 2);
	147	PUSHs(self);
	148	PUSHs(value);
	149
	150	PUTBACK;
	151	call_sv(trigger, G_VOID \| G_DISCARD);
	152	/* need not SPAGAIN */
	153	}
	154
208ffaeb	155	PUSH_VALUE(value, flags);
646c0371	156	}
646c0371	157
30e11004	158	XS(XS_Mouse_accessor)
646c0371	159	{
	160	dVAR; dXSARGS;
	161	dMOUSE_self;
	162	MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
	163
	164	SP -= items; /* PPCODE */
	165	PUTBACK;
	166
	167	if(items == 1){ /* reader */
	168	mouse_attr_get(aTHX_ self, mg);
	169	}
	170	else if (items == 2){ /* writer */
	171	mouse_attr_set(aTHX_ self, mg, ST(1));
	172	}
	173	else{
	174	mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
	175	"Expected exactly one or two argument for an accessor");
	176	}
	177	}
	178
	179
30e11004	180	XS(XS_Mouse_reader)
646c0371	181	{
	182	dVAR; dXSARGS;
	183	dMOUSE_self;
	184	MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
	185
	186	if (items != 1) {
	187	mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
	188	"Cannot assign a value to a read-only accessor");
	189	}
	190
	191	SP -= items; /* PPCODE */
	192	PUTBACK;
	193
	194	mouse_attr_get(aTHX_ self, mg);
	195	}
	196
30e11004	197	XS(XS_Mouse_writer)
646c0371	198	{
	199	dVAR; dXSARGS;
	200	dMOUSE_self;
	201	MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
	202
	203	if (items != 2) {
	204	mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
	205	"Too few arguments for a write-only accessor");
	206	}
	207
	208	SP -= items; /* PPCODE */
	209	PUTBACK;
	210
	211	mouse_attr_set(aTHX_ self, mg, ST(1));
	212	}
	213
	214	/* simple accessors */
	215
	216	/*
	217	static MAGIC*
	218	mouse_accessor_get_mg(pTHX_ CV* const xsub){
	219	return moose_mg_find(aTHX_ (SV*)xsub, &mouse_simple_accessor_vtbl, MOOSEf_DIE_ON_FAIL);
	220	}
	221	*/
	222
	223	CV*
a17f6313	224	mouse_simple_accessor_generate(pTHX_ const char* const fq_name, const char* const key, I32 const keylen, XSUBADDR_t const accessor_impl, void* const dptr, I32 const dlen){
646c0371	225	CV* const xsub = newXS((char*)fq_name, accessor_impl, __FILE__);
	226	SV* const slot = newSVpvn_share(key, keylen, 0U);
	227	MAGIC* mg;
	228
	229	if(!fq_name){
	230	/* anonymous xsubs need sv_2mortal */
	231	sv_2mortal((SV*)xsub);
	232	}
	233
e058b279	234	mg = sv_magicext((SV)xsub, slot, PERL_MAGIC_ext, &mouse_accessor_vtbl, (char)dptr, dlen);
646c0371	235	SvREFCNT_dec(slot); /* sv_magicext() increases refcnt in mg_obj */
e058b279	236	if(dlen == HEf_SVKEY){
	237	SvREFCNT_dec(dptr);
	238	}
646c0371	239
	240	/* NOTE:
	241	* although we use MAGIC for gc, we also store mg to CvXSUBANY for efficiency (gfx)
	242	*/
	243	CvXSUBANY(xsub).any_ptr = (void*)mg;
	244
	245	return xsub;
	246	}
	247
542f20ad	248	XS(XS_Mouse_simple_accessor)
	249	{
	250	dVAR; dXSARGS;
	251	dMOUSE_self;
	252	MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
	253	SV* value;
	254
	255	if(items == 1){ /* reader */
	256	value = get_slot(self, MOUSE_mg_slot(mg));
2468f1d7	257	if(!value){
2468f1d7	258	value = &PL_sv_undef;
542f20ad	259	}
	260	}
	261	else if(items == 2){ /* writer */
	262	value = set_slot(self, MOUSE_mg_slot(mg), ST(1));
	263	}
	264	else {
	265	croak("Expected exactly one or two argument for an accessor for '%"SVf"'", MOUSE_mg_slot(mg));
	266	}
	267
	268	ST(0) = value;
	269	XSRETURN(1);
	270	}
	271
30e11004	272	XS(XS_Mouse_simple_reader)
646c0371	273	{
	274	dVAR; dXSARGS;
	275	dMOUSE_self;
e058b279	276	MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
646c0371	277	SV* value;
	278
	279	if (items != 1) {
e058b279	280	croak("Expected exactly one argument for a reader for '%"SVf"'", MOUSE_mg_slot(mg));
646c0371	281	}
646c0371	282
e058b279	283	value = get_slot(self, MOUSE_mg_slot(mg));
2468f1d7	284	if(!value) {
	285	if(MOUSE_mg_ptr(mg)){
	286	/* the default value must be a SV */
	287	assert(MOUSE_mg_len(mg) == HEf_SVKEY);
	288	value = (SV*)MOUSE_mg_ptr(mg);
	289	}
	290	else{
	291	value = &PL_sv_undef;
	292	}
	293	}
	294
	295	ST(0) = value;
646c0371	296	XSRETURN(1);
	297	}
	298
	299
30e11004	300	XS(XS_Mouse_simple_writer)
646c0371	301	{
	302	dVAR; dXSARGS;
	303	dMOUSE_self;
	304	SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
	305
	306	if (items != 2) {
	307	croak("Expected exactly two argument for a writer for '%"SVf"'", slot);
	308	}
	309
6fe2272b	310	ST(0) = set_slot(self, slot, ST(1));
646c0371	311	XSRETURN(1);
	312	}
	313
30e11004	314	XS(XS_Mouse_simple_clearer)
646c0371	315	{
	316	dVAR; dXSARGS;
	317	dMOUSE_self;
	318	SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
	319	SV* value;
	320
	321	if (items != 1) {
	322	croak("Expected exactly one argument for a clearer for '%"SVf"'", slot);
	323	}
	324
6fe2272b	325	value = delete_slot(self, slot);
646c0371	326	ST(0) = value ? value : &PL_sv_undef;
	327	XSRETURN(1);
	328	}
	329
30e11004	330	XS(XS_Mouse_simple_predicate)
646c0371	331	{
	332	dVAR; dXSARGS;
	333	dMOUSE_self;
	334	SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
	335
	336	if (items != 1) {
	337	croak("Expected exactly one argument for a predicate for '%"SVf"'", slot);
	338	}
	339
6fe2272b	340	ST(0) = boolSV( has_slot(self, slot) );
646c0371	341	XSRETURN(1);
	342	}
	343
76770976	344	/* simple instance slot accessor (or Mouse::Meta::Instance) */
646c0371	345
	346	SV*
	347	mouse_instance_create(pTHX_ HV* const stash) {
	348	assert(stash);
aa2d2e2c	349	assert(SvTYPE(stash) == SVt_PVHV);
646c0371	350	return sv_bless( newRV_noinc((SV*)newHV()), stash );
	351	}
	352
	353	SV*
	354	mouse_instance_clone(pTHX_ SV* const instance) {
	355	HV* proto;
	356	assert(instance);
	357
	358	CHECK_INSTANCE(instance);
	359	proto = newHVhv((HV*)SvRV(instance));
	360	return sv_bless( newRV_noinc((SV*)proto), SvSTASH(SvRV(instance)) );
	361	}
	362
	363	bool
	364	mouse_instance_has_slot(pTHX_ SV* const instance, SV* const slot) {
	365	assert(instance);
	366	assert(slot);
	367	CHECK_INSTANCE(instance);
	368	return hv_exists_ent((HV*)SvRV(instance), slot, 0U);
	369	}
	370
	371	SV*
	372	mouse_instance_get_slot(pTHX_ SV* const instance, SV* const slot) {
	373	HE* he;
	374	assert(instance);
	375	assert(slot);
	376	CHECK_INSTANCE(instance);
	377	he = hv_fetch_ent((HV*)SvRV(instance), slot, FALSE, 0U);
	378	return he ? HeVAL(he) : NULL;
	379	}
	380
	381	SV*
	382	mouse_instance_set_slot(pTHX_ SV* const instance, SV* const slot, SV* const value) {
	383	HE* he;
	384	SV* sv;
	385	assert(instance);
	386	assert(slot);
	387	assert(value);
	388	CHECK_INSTANCE(instance);
	389	he = hv_fetch_ent((HV*)SvRV(instance), slot, TRUE, 0U);
	390	sv = HeVAL(he);
957474ad	391	sv_setsv(sv, value);
957474ad	392	SvSETMAGIC(sv);
646c0371	393	return sv;
	394	}
	395
	396	SV*
	397	mouse_instance_delete_slot(pTHX_ SV* const instance, SV* const slot) {
	398	assert(instance);
	399	assert(slot);
	400	CHECK_INSTANCE(instance);
	401	return hv_delete_ent((HV*)SvRV(instance), slot, 0, 0U);
	402	}
	403
	404	void
	405	mouse_instance_weaken_slot(pTHX_ SV* const instance, SV* const slot) {
	406	HE* he;
	407	assert(instance);
	408	assert(slot);
	409	CHECK_INSTANCE(instance);
	410	he = hv_fetch_ent((HV*)SvRV(instance), slot, FALSE, 0U);
	411	if(he){
	412	sv_rvweaken(HeVAL(he));
	413	}
	414	}
	415	\r
	416	MODULE = Mouse::Meta::Method::Accessor::XS PACKAGE = Mouse::Meta::Method::Accessor::XS
	417
	418	PROTOTYPES: DISABLE
	419	VERSIONCHECK: DISABLE
	420
	421	CV*
	422	_generate_accessor(klass, SV* attr, metaclass)
	423	CODE:
	424	{
a17f6313	425	RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_accessor);
646c0371	426	}
	427	OUTPUT:
	428	RETVAL
	429
	430	CV*
	431	_generate_reader(klass, SV* attr, metaclass)
	432	CODE:
	433	{
a17f6313	434	RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_reader);
646c0371	435	}
	436	OUTPUT:
	437	RETVAL
	438
	439	CV*
	440	_generate_writer(klass, SV* attr, metaclass)
	441	CODE:
	442	{
a17f6313	443	RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_writer);
646c0371	444	}
	445	OUTPUT:
	446	RETVAL
	447
	448	CV*
	449	_generate_clearer(klass, SV* attr, metaclass)
	450	CODE:
	451	{
	452	SV* const slot = mcall0s(attr, "name");
	453	STRLEN len;
	454	const char* const pv = SvPV_const(slot, len);
a17f6313	455	RETVAL = mouse_simple_accessor_generate(aTHX_ NULL, pv, len, XS_Mouse_simple_clearer, NULL, 0);
646c0371	456	}
	457	OUTPUT:
	458	RETVAL
	459
	460	CV*
	461	_generate_predicate(klass, SV* attr, metaclass)
	462	CODE:
	463	{
	464	SV* const slot = mcall0s(attr, "name");
	465	STRLEN len;
	466	const char* const pv = SvPV_const(slot, len);
a17f6313	467	RETVAL = mouse_simple_accessor_generate(aTHX_ NULL, pv, len, XS_Mouse_simple_predicate, NULL, 0);
646c0371	468	}
	469	OUTPUT:
	470	RETVAL
	471