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

#define  NEED_newSVpvn_flags_GLOBAL
#include "mouse.h"

SV* mouse_package;
SV* mouse_namespace;
SV* mouse_methods;
SV* mouse_name;
SV* mouse_get_attribute;
SV* mouse_get_attribute_list;


#define MOUSE_xc_gen(a)         MOUSE_av_at((a), MOUSE_XC_GEN)
#define MOUSE_xc_stash(a)       ( (HV*)MOUSE_av_at((a), MOUSE_XC_STASH) )
#define MOUSE_xc_attrall(a)     ( (AV*)MOUSE_av_at((a), MOUSE_XC_ATTRALL) )
#define MOUSE_xc_buildall(a)    ( (AV*)MOUSE_av_at((a), MOUSE_XC_BUILDALL) )
#define MOUSE_xc_demolishall(a) ( (AV*)MOUSE_av_at((a), MOUSE_XC_DEOLISHALL) )

enum mouse_xc_flags_t {
    MOUSEf_XC_IS_IMMUTABLE   = 0x0001,
    MOUSEf_XC_IS_ANON        = 0x0002,
    MOUSEf_XC_HAS_BUILDARGS  = 0x0004,

    MOUSEf_XC_mask           = 0xFFFF /* not used */
};

/* Mouse XS Metaclass object */
enum mouse_xc_ix_t{
    MOUSE_XC_GEN,          /* class generation */
    MOUSE_XC_STASH,        /* symbol table hash */
    MOUSE_XC_FLAGS,

    MOUSE_XC_BUILDARGS,    /* Custom BUILDARGS */

    MOUSE_XC_ATTRALL,      /* all the attributes */
    MOUSE_XC_BUILDALL,     /* all the BUILD methods */
    MOUSE_XC_DEMOLISHALL,  /* all the DEMOLISH methods */

    MOUSE_XC_last
};

static MGVTBL mouse_xc_vtbl; /* for identity */

static void
mouse_class_push_attribute_list(pTHX_ SV* const metaclass, AV* const attrall, HV* const seen){
    dSP;
    I32 n;

    /* $meta->get_attribute_list */
    PUSHMARK(SP);
    XPUSHs(metaclass);
    PUTBACK;

    n = call_sv(mouse_get_attribute_list, G_ARRAY | G_METHOD);
    for(NOOP; n > 0; n--){
        SV* name;

        SPAGAIN;
        name = POPs;
        PUTBACK;

        if(hv_exists_ent(seen, name, 0U)){
            continue;
        }
        (void)hv_store_ent(seen, name, &PL_sv_undef, 0U);

        av_push(attrall, newSVsv( mcall1(metaclass, mouse_get_attribute, name) ));
    }
}

static int
mouse_class_has_custom_buildargs(pTHX_ HV* const stash) {
    XS(XS_Mouse__Object_BUILDARGS); /* prototype */

    GV* const buildargs = gv_fetchmeth_autoload(stash, "BUILDARGS", sizeof("BUILDARGS")-1, 0);
    CV* const cv        = GvCV(buildargs);

    assert(cv);
    return CvXSUB(cv) == XS_Mouse__Object_BUILDARGS;
}

static void
mouse_class_update_xc(pTHX_ SV* const metaclass PERL_UNUSED_DECL, HV* const stash, AV* const xc) {
    AV* const linearized_isa = mro_get_linear_isa(stash);
    I32 const len            = AvFILLp(linearized_isa);
    I32 i;
    U32 flags             = 0x00;
    AV* const attrall     = newAV();
    AV* const buildall    = newAV();
    AV* const demolishall = newAV();
    HV* const seen        = newHV(); /* for attributes */

    ENTER;
    SAVETMPS;

    sv_2mortal((SV*)seen);

     /* old data will be delete at the end of the perl scope */
    av_delete(xc, MOUSE_XC_DEMOLISHALL, 0x00);
    av_delete(xc, MOUSE_XC_BUILDALL,    0x00);
    av_delete(xc, MOUSE_XC_ATTRALL,     0x00);

    SvREFCNT_inc_simple_void_NN(linearized_isa);
    sv_2mortal((SV*)linearized_isa);

    /* update */

    if(SvTRUEx( mcall0s(metaclass, "is_immutable") )){
        flags |= MOUSEf_XC_IS_IMMUTABLE;
    }

    if(mouse_class_has_custom_buildargs(aTHX_ stash)){
        flags |= MOUSEf_XC_HAS_BUILDARGS;
    }

    av_store(xc, MOUSE_XC_ATTRALL,     (SV*)attrall);
    av_store(xc, MOUSE_XC_BUILDALL,    (SV*)buildall);
    av_store(xc, MOUSE_XC_DEMOLISHALL, (SV*)demolishall);

    for(i = 0; i < len; i++){
        SV* const klass = MOUSE_av_at(linearized_isa, i);
        SV* meta;
        GV* gv;

        gv = stash_fetchs(stash, "BUILD", FALSE);
        if(gv && GvCVu(gv)){
            av_push(buildall, newRV_inc((SV*)GvCV(gv)));
        }

        gv = stash_fetchs(stash, "DEMOLISH", FALSE);
        if(gv && GvCVu(gv)){
            av_push(demolishall, newRV_inc((SV*)GvCV(gv)));
        }

        /* ATTRIBUTES */
        meta = get_metaclass(klass);
        if(!SvOK(meta)){
            continue; /* skip non-Mouse classes */
        }

        mouse_class_push_attribute_list(aTHX_ meta, attrall, seen);
    }

    FREETMPS;
    LEAVE;

    sv_setuv(MOUSE_xc_gen(xc), mro_get_pkg_gen(stash));
}

AV*
mouse_get_xc(pTHX_ SV* const metaclass) {
    AV* xc;
    SV* gen;
    HV* stash;
    MAGIC* mg;

    if(!IsObject(metaclass)){
        croak("Not a Mouse metaclass");
    }

    mg = mouse_mg_find(aTHX_ SvRV(metaclass), &mouse_xc_vtbl, 0x00);
    if(!mg){
        SV* const package = get_slot(metaclass, mouse_package);
        STRLEN len;
        const char* const pv = SvPV_const(package, len);

        stash = gv_stashpvn(pv, len, TRUE);
        xc    = newAV();

        mg = sv_magicext(SvRV(metaclass), (SV*)xc, PERL_MAGIC_ext, &mouse_xc_vtbl, pv, len);
        SvREFCNT_dec(xc); /* refcnt++ in sv_magicext */

        av_extend(xc, MOUSE_XC_last - 1);

        av_store(xc, MOUSE_XC_GEN, newSViv(0));
        av_store(xc, MOUSE_XC_STASH, (SV*)stash);
        SvREFCNT_inc_simple_void_NN(stash);
    }
    else{
        xc    = (AV*)MOUSE_mg_obj(mg);

        assert(xc);
        assert(SvTYPE(xc) == SVt_PVAV);
    }

    gen   = MOUSE_xc_gen(xc);
    stash = MOUSE_xc_stash(xc);

    if(SvUV(gen) != mro_get_pkg_gen(stash)){
        mouse_class_update_xc(aTHX_ metaclass, stash, xc);
    }

    return xc;
}

AV*
mouse_get_all_attributes(pTHX_ SV* const metaclass) {
    AV* const xc = mouse_get_xc(aTHX_ metaclass);
    return MOUSE_xc_attrall(xc);
}

HV*
mouse_build_args(aTHX_ SV* metaclass, SV* const klass, I32 const start, I32 const items, I32 const ax) {
    HV* args;
    if((items - start) == 1){
        SV* const args_ref = ST(start);
        if(!IsHashRef(args_ref)){
            if(!metaclass){ metaclass = get_metaclass(klass); }
            mouse_throw_error(metaclass, NULL, "Single parameters to new() must be a HASH ref");
        }
        args = newHVhv((HV*)SvRV(args_ref));
        sv_2mortal((SV*)args);
    }
    else{
        I32 i;

        args = newHV_mortal();

        if( ((items - start) % 2) != 0 ){
            if(!metaclass){ metaclass = get_metaclass(klass); }
            mouse_throw_error(metaclass, NULL, "Odd number of parameters to new()");
        }

        for(i = start; i < items; i += 2){
            (void)hv_store_ent(args, ST(i), newSVsv(ST(i+1)), 0U);
        }

    }
    return args;
}

void
mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const args, bool const invoke_triggers) {
    AV* const xc = mouse_get_xc(aTHX_ meta);

    // TODO
}

MODULE = Mouse  PACKAGE = Mouse

PROTOTYPES: DISABLE

BOOT:
    mouse_package   = newSVpvs_share("package");
    mouse_namespace = newSVpvs_share("namespace");
    mouse_methods   = newSVpvs_share("methods");
    mouse_name      = newSVpvs_share("name");

    mouse_get_attribute      = newSVpvs_share("get_attribute");
    mouse_get_attribute_list = newSVpvs_share("get_attribute_list");

    MOUSE_CALL_BOOT(Mouse__Util);
    MOUSE_CALL_BOOT(Mouse__Util__TypeConstraints);
    MOUSE_CALL_BOOT(Mouse__Meta__Method__Accessor__XS);
    MOUSE_CALL_BOOT(Mouse__Meta__Attribute);


MODULE = Mouse  PACKAGE = Mouse::Meta::Module

BOOT:
    INSTALL_SIMPLE_READER_WITH_KEY(Module, name, package);
    INSTALL_SIMPLE_READER_WITH_KEY(Module, _method_map, methods);
    INSTALL_SIMPLE_READER_WITH_KEY(Module, _attribute_map, attributes);

HV*
namespace(SV* self)
CODE:
{
    SV* const package = get_slot(self, mouse_package);
    if(!(package && SvOK(package))){
        croak("No package name defined");
    }
    RETVAL = gv_stashsv(package, GV_ADDMULTI);
}
OUTPUT:
    RETVAL

# ignore extra arguments for extensibility
void
add_method(SV* self, SV* name, SV* code, ...)
CODE:
{
    SV* const package = get_slot(self, mouse_package); /* $self->{package} */
    SV* const methods = get_slot(self, mouse_methods); /* $self->{methods} */
    GV* gv;
    SV* code_ref;

    if(!(package && SvOK(package))){
        croak("No package name defined");
    }

    SvGETMAGIC(name);
    SvGETMAGIC(code);

    if(!SvOK(name)){
        mouse_throw_error(self, NULL, "You must define a method name");
    }
    if(!SvROK(code)){
        mouse_throw_error(self, NULL, "You must define a CODE reference");
    }

    code_ref = code;
    if(SvTYPE(SvRV(code_ref)) != SVt_PVCV){
        SV*  sv = code_ref;  /* used in tryAMAGICunDEREF */
        SV** sp = &sv;       /* used in tryAMAGICunDEREF */
        tryAMAGICunDEREF(to_cv); /* try \&{$code} */
        if(SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVCV){
            mouse_throw_error(self, NULL, "Not a CODE reference");
        }
        code_ref = sv;
    }

    /*  *{$package . '::' . $name} -> *gv */
    gv = gv_fetchpv(form("%"SVf"::%"SVf, package, name), GV_ADDMULTI, SVt_PVCV);
    if(GvCVu(gv)){ /* delete *slot{gv} to work around "redefine" warning */
        SvREFCNT_dec(GvCV(gv));
        GvCV(gv) = NULL;
    }
    sv_setsv_mg((SV*)gv, code_ref); /* *gv = $code_ref */

    set_slot(methods, name, code); /* $self->{methods}{$name} = $code */

    /* TODO: name the CODE ref if it's anonymous */
    //code_entity = (CV*)SvRV(code_ref);
    //if(CvANON(code_entity)
    //    && CvGV(code_entity) /* a cv under construction has no gv */ ){

    //    CvGV(code_entity) = gv;
    //    CvANON_off(code_entity);
    //}
}

MODULE = Mouse  PACKAGE = Mouse::Meta::Class

BOOT:
    INSTALL_SIMPLE_READER(Class, roles);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Class, is_anon_class, anon_serial_id);

void
linearized_isa(SV* self)
PPCODE:
{
    SV* const stash_ref = mcall0(self, mouse_namespace); /* $self->namespace */
    AV* linearized_isa;
    I32 len;
    I32 i;
    if(!(SvROK(stash_ref) && SvTYPE(SvRV(stash_ref)) == SVt_PVHV)){
        croak("namespace() didn't return a HASH reference");
    }
    linearized_isa = mro_get_linear_isa((HV*)SvRV(stash_ref));
    len = AvFILLp(linearized_isa) + 1;
    EXTEND(SP, len);
    for(i = 0; i < len; i++){
        PUSHs(AvARRAY(linearized_isa)[i]);
    }
}

void
get_all_attributes(SV* self)
PPCODE:
{
    AV* const all_attrs = mouse_get_all_attributes(aTHX_ self);
    I32 const len       = AvFILLp(all_attrs) + 1;
    I32 i;

    EXTEND(SP, len);
    for(i = 0; i < len; i++){
        PUSHs( MOUSE_av_at(all_attrs, i) );
    }
}

SV*
new_object_(SV* meta, ...)
CODE:
{
    HV* const args = mouse_build_args(aTHX_ meta, NULL, 1, items, ax);
    AV* const xc   = mouse_get_xc(aTHX_ meta);
    RETVAL = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc));
    mouse_class_initialize_object(aTHX_ meta, RETVAL, args, TRUE);
}


void
_initialize_object_(SV* meta, SV* object, HV* args, bool invoke_triggers = TRUE)
CODE:
{
    mouse_class_initialize_object(aTHX_ meta, object, args, invoke_triggers);
}

MODULE = Mouse  PACKAGE = Mouse::Meta::Role

BOOT:
    INSTALL_SIMPLE_READER_WITH_KEY(Role, get_roles, roles);
    INSTALL_SIMPLE_PREDICATE_WITH_KEY(Role, is_anon_role, anon_serial_id);

MODULE = Mouse  PACKAGE = Mouse::Object

HV*
BUILDARGS(SV* klass, ...)
CODE:
{
    RETVAL = mouse_build_args(aTHX_ NULL, klass, 1, items, ax);
}
OUTPUT:
    RETVAL
Commit	Line	Data
1b812057	1	#define NEED_newSVpvn_flags_GLOBAL
df6dd016	2	#include "mouse.h"
df6dd016	3
cccb83de	4	SV* mouse_package;
cccb83de	5	SV* mouse_namespace;
3e44140b	6	SV* mouse_methods;
a5df48e5	7	SV* mouse_name;
047d7af0	8	SV* mouse_get_attribute;
047d7af0	9	SV* mouse_get_attribute_list;
cccb83de	10
da4432f3	11
a39e9541	12	#define MOUSE_xc_gen(a) MOUSE_av_at((a), MOUSE_XC_GEN)
aa2d2e2c	13	#define MOUSE_xc_stash(a) ( (HV*)MOUSE_av_at((a), MOUSE_XC_STASH) )
a39e9541	14	#define MOUSE_xc_attrall(a) ( (AV*)MOUSE_av_at((a), MOUSE_XC_ATTRALL) )
	15	#define MOUSE_xc_buildall(a) ( (AV*)MOUSE_av_at((a), MOUSE_XC_BUILDALL) )
	16	#define MOUSE_xc_demolishall(a) ( (AV*)MOUSE_av_at((a), MOUSE_XC_DEOLISHALL) )
	17
aa2d2e2c	18	enum mouse_xc_flags_t {
	19	MOUSEf_XC_IS_IMMUTABLE = 0x0001,
	20	MOUSEf_XC_IS_ANON = 0x0002,
	21	MOUSEf_XC_HAS_BUILDARGS = 0x0004,
	22
	23	MOUSEf_XC_mask = 0xFFFF /* not used */
	24	};
	25
a39e9541	26	/* Mouse XS Metaclass object */
	27	enum mouse_xc_ix_t{
	28	MOUSE_XC_GEN, /* class generation */
aa2d2e2c	29	MOUSE_XC_STASH, /* symbol table hash */
	30	MOUSE_XC_FLAGS,
	31
	32	MOUSE_XC_BUILDARGS, /* Custom BUILDARGS */
	33
a39e9541	34	MOUSE_XC_ATTRALL, /* all the attributes */
	35	MOUSE_XC_BUILDALL, /* all the BUILD methods */
	36	MOUSE_XC_DEMOLISHALL, /* all the DEMOLISH methods */
	37
	38	MOUSE_XC_last
	39	};
	40
	41	static MGVTBL mouse_xc_vtbl; /* for identity */
	42
	43	static void
	44	mouse_class_push_attribute_list(pTHX_ SV* const metaclass, AV* const attrall, HV* const seen){
	45	dSP;
	46	I32 n;
	47
	48	/* $meta->get_attribute_list */
	49	PUSHMARK(SP);
	50	XPUSHs(metaclass);
	51	PUTBACK;
	52
047d7af0	53	n = call_sv(mouse_get_attribute_list, G_ARRAY \| G_METHOD);
a39e9541	54	for(NOOP; n > 0; n--){
	55	SV* name;
	56
	57	SPAGAIN;
	58	name = POPs;
	59	PUTBACK;
	60
	61	if(hv_exists_ent(seen, name, 0U)){
	62	continue;
	63	}
	64	(void)hv_store_ent(seen, name, &PL_sv_undef, 0U);
da4432f3	65
047d7af0	66	av_push(attrall, newSVsv( mcall1(metaclass, mouse_get_attribute, name) ));
a39e9541	67	}
a39e9541	68	}
743ca82e	69
aa2d2e2c	70	static int
	71	mouse_class_has_custom_buildargs(pTHX_ HV* const stash) {
	72	XS(XS_Mouse__Object_BUILDARGS); /* prototype */
	73
	74	GV* const buildargs = gv_fetchmeth_autoload(stash, "BUILDARGS", sizeof("BUILDARGS")-1, 0);
	75	CV* const cv = GvCV(buildargs);
	76
	77	assert(cv);
	78	return CvXSUB(cv) == XS_Mouse__Object_BUILDARGS;
	79	}
	80
a39e9541	81	static void
	82	mouse_class_update_xc(pTHX_ SV* const metaclass PERL_UNUSED_DECL, HV* const stash, AV* const xc) {
	83	AV* const linearized_isa = mro_get_linear_isa(stash);
	84	I32 const len = AvFILLp(linearized_isa);
	85	I32 i;
aa2d2e2c	86	U32 flags = 0x00;
a39e9541	87	AV* const attrall = newAV();
	88	AV* const buildall = newAV();
	89	AV* const demolishall = newAV();
	90	HV* const seen = newHV(); /* for attributes */
da4432f3	91
a39e9541	92	ENTER;
a39e9541	93	SAVETMPS;
da4432f3	94
a39e9541	95	sv_2mortal((SV*)seen);
da4432f3	96
a39e9541	97	/* old data will be delete at the end of the perl scope */
	98	av_delete(xc, MOUSE_XC_DEMOLISHALL, 0x00);
	99	av_delete(xc, MOUSE_XC_BUILDALL, 0x00);
	100	av_delete(xc, MOUSE_XC_ATTRALL, 0x00);
743ca82e	101
a39e9541	102	SvREFCNT_inc_simple_void_NN(linearized_isa);
a39e9541	103	sv_2mortal((SV*)linearized_isa);
da4432f3	104
a39e9541	105	/* update */
da4432f3	106
aa2d2e2c	107	if(SvTRUEx( mcall0s(metaclass, "is_immutable") )){
	108	flags \|= MOUSEf_XC_IS_IMMUTABLE;
	109	}
	110
	111	if(mouse_class_has_custom_buildargs(aTHX_ stash)){
	112	flags \|= MOUSEf_XC_HAS_BUILDARGS;
	113	}
	114
a39e9541	115	av_store(xc, MOUSE_XC_ATTRALL, (SV*)attrall);
	116	av_store(xc, MOUSE_XC_BUILDALL, (SV*)buildall);
	117	av_store(xc, MOUSE_XC_DEMOLISHALL, (SV*)demolishall);
da4432f3	118
a39e9541	119	for(i = 0; i < len; i++){
047d7af0	120	SV* const klass = MOUSE_av_at(linearized_isa, i);
a39e9541	121	SV* meta;
a39e9541	122	GV* gv;
da4432f3	123
a39e9541	124	gv = stash_fetchs(stash, "BUILD", FALSE);
	125	if(gv && GvCVu(gv)){
	126	av_push(buildall, newRV_inc((SV*)GvCV(gv)));
	127	}
da4432f3	128
a39e9541	129	gv = stash_fetchs(stash, "DEMOLISH", FALSE);
	130	if(gv && GvCVu(gv)){
	131	av_push(demolishall, newRV_inc((SV*)GvCV(gv)));
	132	}
da4432f3	133
a39e9541	134	/* ATTRIBUTES */
aa2d2e2c	135	meta = get_metaclass(klass);
a39e9541	136	if(!SvOK(meta)){
	137	continue; /* skip non-Mouse classes */
	138	}
da4432f3	139
a39e9541	140	mouse_class_push_attribute_list(aTHX_ meta, attrall, seen);
a39e9541	141	}
da4432f3	142
a39e9541	143	FREETMPS;
a39e9541	144	LEAVE;
da4432f3	145
a39e9541	146	sv_setuv(MOUSE_xc_gen(xc), mro_get_pkg_gen(stash));
a39e9541	147	}
da4432f3	148
a39e9541	149	AV*
	150	mouse_get_xc(pTHX_ SV* const metaclass) {
	151	AV* xc;
	152	SV* gen;
	153	HV* stash;
	154	MAGIC* mg;
	155
	156	if(!IsObject(metaclass)){
	157	croak("Not a Mouse metaclass");
	158	}
da4432f3	159
a39e9541	160	mg = mouse_mg_find(aTHX_ SvRV(metaclass), &mouse_xc_vtbl, 0x00);
	161	if(!mg){
	162	SV* const package = get_slot(metaclass, mouse_package);
aa2d2e2c	163	STRLEN len;
aa2d2e2c	164	const char* const pv = SvPV_const(package, len);
da4432f3	165
aa2d2e2c	166	stash = gv_stashpvn(pv, len, TRUE);
a39e9541	167	xc = newAV();
da4432f3	168
aa2d2e2c	169	mg = sv_magicext(SvRV(metaclass), (SV*)xc, PERL_MAGIC_ext, &mouse_xc_vtbl, pv, len);
a39e9541	170	SvREFCNT_dec(xc); /* refcnt++ in sv_magicext */
da4432f3	171
a39e9541	172	av_extend(xc, MOUSE_XC_last - 1);
aa2d2e2c	173
a39e9541	174	av_store(xc, MOUSE_XC_GEN, newSViv(0));
aa2d2e2c	175	av_store(xc, MOUSE_XC_STASH, (SV*)stash);
aa2d2e2c	176	SvREFCNT_inc_simple_void_NN(stash);
da4432f3	177	}
a39e9541	178	else{
a39e9541	179	xc = (AV*)MOUSE_mg_obj(mg);
da4432f3	180
a39e9541	181	assert(xc);
	182	assert(SvTYPE(xc) == SVt_PVAV);
	183	}
da4432f3	184
aa2d2e2c	185	gen = MOUSE_xc_gen(xc);
	186	stash = MOUSE_xc_stash(xc);
	187
a39e9541	188	if(SvUV(gen) != mro_get_pkg_gen(stash)){
a39e9541	189	mouse_class_update_xc(aTHX_ metaclass, stash, xc);
da4432f3	190	}
a39e9541	191
	192	return xc;
	193	}
	194
	195	AV*
	196	mouse_get_all_attributes(pTHX_ SV* const metaclass) {
	197	AV* const xc = mouse_get_xc(aTHX_ metaclass);
	198	return MOUSE_xc_attrall(xc);
da4432f3	199	}
da4432f3	200
aa2d2e2c	201	HV*
	202	mouse_build_args(aTHX_ SV* metaclass, SV* const klass, I32 const start, I32 const items, I32 const ax) {
	203	HV* args;
	204	if((items - start) == 1){
	205	SV* const args_ref = ST(start);
	206	if(!IsHashRef(args_ref)){
	207	if(!metaclass){ metaclass = get_metaclass(klass); }
	208	mouse_throw_error(metaclass, NULL, "Single parameters to new() must be a HASH ref");
	209	}
	210	args = newHVhv((HV*)SvRV(args_ref));
	211	sv_2mortal((SV*)args);
	212	}
	213	else{
	214	I32 i;
	215
6fab29c6	216	args = newHV_mortal();
aa2d2e2c	217
	218	if( ((items - start) % 2) != 0 ){
	219	if(!metaclass){ metaclass = get_metaclass(klass); }
	220	mouse_throw_error(metaclass, NULL, "Odd number of parameters to new()");
	221	}
	222
	223	for(i = start; i < items; i += 2){
	224	(void)hv_store_ent(args, ST(i), newSVsv(ST(i+1)), 0U);
	225	}
	226
	227	}
	228	return args;
	229	}
	230
	231	void
	232	mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const args, bool const invoke_triggers) {
	233	AV* const xc = mouse_get_xc(aTHX_ meta);
	234
	235	// TODO
	236	}
	237
646c0371	238	MODULE = Mouse PACKAGE = Mouse
df6dd016	239
	240	PROTOTYPES: DISABLE
	241
cccb83de	242	BOOT:
	243	mouse_package = newSVpvs_share("package");
	244	mouse_namespace = newSVpvs_share("namespace");
3e44140b	245	mouse_methods = newSVpvs_share("methods");
a5df48e5	246	mouse_name = newSVpvs_share("name");
3e44140b	247
047d7af0	248	mouse_get_attribute = newSVpvs_share("get_attribute");
047d7af0	249	mouse_get_attribute_list = newSVpvs_share("get_attribute_list");
da4432f3	250
646c0371	251	MOUSE_CALL_BOOT(Mouse__Util);
1d5ecd5f	252	MOUSE_CALL_BOOT(Mouse__Util__TypeConstraints);
646c0371	253	MOUSE_CALL_BOOT(Mouse__Meta__Method__Accessor__XS);
aa2d2e2c	254	MOUSE_CALL_BOOT(Mouse__Meta__Attribute);
f48920c1	255
cccb83de	256
7d96ae4d	257	MODULE = Mouse PACKAGE = Mouse::Meta::Module
	258
	259	BOOT:
	260	INSTALL_SIMPLE_READER_WITH_KEY(Module, name, package);
	261	INSTALL_SIMPLE_READER_WITH_KEY(Module, _method_map, methods);
	262	INSTALL_SIMPLE_READER_WITH_KEY(Module, _attribute_map, attributes);
	263
	264	HV*
	265	namespace(SV* self)
	266	CODE:
	267	{
6a97bbda	268	SV* const package = get_slot(self, mouse_package);
7d96ae4d	269	if(!(package && SvOK(package))){
3e44140b	270	croak("No package name defined");
7d96ae4d	271	}
	272	RETVAL = gv_stashsv(package, GV_ADDMULTI);
	273	}
	274	OUTPUT:
	275	RETVAL
	276
3e44140b	277	# ignore extra arguments for extensibility
	278	void
	279	add_method(SV* self, SV* name, SV* code, ...)
	280	CODE:
	281	{
6a97bbda	282	SV* const package = get_slot(self, mouse_package); /* $self->{package} */
6a97bbda	283	SV* const methods = get_slot(self, mouse_methods); /* $self->{methods} */
3e44140b	284	GV* gv;
	285	SV* code_ref;
	286
	287	if(!(package && SvOK(package))){
	288	croak("No package name defined");
	289	}
	290
	291	SvGETMAGIC(name);
	292	SvGETMAGIC(code);
	293
	294	if(!SvOK(name)){
	295	mouse_throw_error(self, NULL, "You must define a method name");
	296	}
	297	if(!SvROK(code)){
	298	mouse_throw_error(self, NULL, "You must define a CODE reference");
	299	}
	300
	301	code_ref = code;
	302	if(SvTYPE(SvRV(code_ref)) != SVt_PVCV){
	303	SV* sv = code_ref; /* used in tryAMAGICunDEREF */
	304	SV** sp = &sv; /* used in tryAMAGICunDEREF */
	305	tryAMAGICunDEREF(to_cv); /* try \&{$code} */
	306	if(SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVCV){
	307	mouse_throw_error(self, NULL, "Not a CODE reference");
	308	}
	309	code_ref = sv;
	310	}
	311
	312	/* {$package . '::' . $name} -> gv */
	313	gv = gv_fetchpv(form("%"SVf"::%"SVf, package, name), GV_ADDMULTI, SVt_PVCV);
	314	if(GvCVu(gv)){ /* delete slot{gv} to work around "redefine" warning /
	315	SvREFCNT_dec(GvCV(gv));
	316	GvCV(gv) = NULL;
	317	}
	318	sv_setsv_mg((SV)gv, code_ref); / gv = $code_ref /
	319
6fe2272b	320	set_slot(methods, name, code); /* $self->{methods}{$name} = $code */
3e44140b	321
	322	/* TODO: name the CODE ref if it's anonymous */
	323	//code_entity = (CV*)SvRV(code_ref);
	324	//if(CvANON(code_entity)
	325	// && CvGV(code_entity) /* a cv under construction has no gv */ ){
	326
	327	// CvGV(code_entity) = gv;
	328	// CvANON_off(code_entity);
	329	//}
	330	}
	331
43165725	332	MODULE = Mouse PACKAGE = Mouse::Meta::Class
	333
	334	BOOT:
	335	INSTALL_SIMPLE_READER(Class, roles);
	336	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Class, is_anon_class, anon_serial_id);
	337
cccb83de	338	void
	339	linearized_isa(SV* self)
	340	PPCODE:
	341	{
	342	SV* const stash_ref = mcall0(self, mouse_namespace); /* $self->namespace */
	343	AV* linearized_isa;
	344	I32 len;
	345	I32 i;
	346	if(!(SvROK(stash_ref) && SvTYPE(SvRV(stash_ref)) == SVt_PVHV)){
	347	croak("namespace() didn't return a HASH reference");
	348	}
	349	linearized_isa = mro_get_linear_isa((HV*)SvRV(stash_ref));
	350	len = AvFILLp(linearized_isa) + 1;
	351	EXTEND(SP, len);
	352	for(i = 0; i < len; i++){
	353	PUSHs(AvARRAY(linearized_isa)[i]);
	354	}
	355	}
	356
da4432f3	357	void
	358	get_all_attributes(SV* self)
	359	PPCODE:
	360	{
	361	AV* const all_attrs = mouse_get_all_attributes(aTHX_ self);
	362	I32 const len = AvFILLp(all_attrs) + 1;
	363	I32 i;
	364
	365	EXTEND(SP, len);
	366	for(i = 0; i < len; i++){
	367	PUSHs( MOUSE_av_at(all_attrs, i) );
	368	}
	369	}
441964ce	370
aa2d2e2c	371	SV*
	372	new_object_(SV* meta, ...)
	373	CODE:
	374	{
	375	HV* const args = mouse_build_args(aTHX_ meta, NULL, 1, items, ax);
	376	AV* const xc = mouse_get_xc(aTHX_ meta);
	377	RETVAL = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc));
	378	mouse_class_initialize_object(aTHX_ meta, RETVAL, args, TRUE);
	379	}
	380
	381
	382	void
	383	_initialize_object_(SV* meta, SV* object, HV* args, bool invoke_triggers = TRUE)
	384	CODE:
	385	{
	386	mouse_class_initialize_object(aTHX_ meta, object, args, invoke_triggers);
	387	}
	388
43165725	389	MODULE = Mouse PACKAGE = Mouse::Meta::Role
	390
	391	BOOT:
	392	INSTALL_SIMPLE_READER_WITH_KEY(Role, get_roles, roles);
	393	INSTALL_SIMPLE_PREDICATE_WITH_KEY(Role, is_anon_role, anon_serial_id);
	394
aa2d2e2c	395	MODULE = Mouse PACKAGE = Mouse::Object
43165725	396
aa2d2e2c	397	HV*
	398	BUILDARGS(SV* klass, ...)
	399	CODE:
	400	{
	401	RETVAL = mouse_build_args(aTHX_ NULL, klass, 1, items, ax);
	402	}
	403	OUTPUT:
	404	RETVAL
93540011	405