X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=gitmo%2FMouse.git;a=blobdiff_plain;f=xs-src%2FMouse.xs;h=143228a794e24cfa541d03e04407e867f22bbe56;hp=93451754d90ba3a362ba8e568b6c4ad4d6644155;hb=70425827d676b2b4130f5e78689bf017fe4c4609;hpb=12872cc1793844cd99267d224a03a39f21e3a373 diff --git a/xs-src/Mouse.xs b/xs-src/Mouse.xs index 9345175..143228a 100644 --- a/xs-src/Mouse.xs +++ b/xs-src/Mouse.xs @@ -1,12 +1,14 @@ #define NEED_newSVpvn_flags_GLOBAL #include "mouse.h" +/* keywords for methods/keys */ SV* mouse_package; SV* mouse_namespace; SV* mouse_methods; SV* mouse_name; SV* mouse_get_attribute; SV* mouse_get_attribute_list; +SV* mouse_coerce; #define MOUSE_xc_flags(a) SvUVX(MOUSE_av_at((a), MOUSE_XC_FLAGS)) #define MOUSE_xc_gen(a) MOUSE_av_at((a), MOUSE_XC_GEN) @@ -19,6 +21,8 @@ enum mouse_xc_flags_t { MOUSEf_XC_IS_IMMUTABLE = 0x0001, MOUSEf_XC_IS_ANON = 0x0002, MOUSEf_XC_HAS_BUILDARGS = 0x0004, + MOUSEf_XC_CONSTRUCTOR_IS_STRICT + = 0x0008, MOUSEf_XC_mask = 0xFFFF /* not used */ }; @@ -113,6 +117,10 @@ mouse_class_update_xc(pTHX_ SV* const metaclass PERL_UNUSED_DECL, HV* const stas flags |= MOUSEf_XC_HAS_BUILDARGS; } + if(predicate_calls(metaclass, "__strict_constructor")){ + flags |= MOUSEf_XC_CONSTRUCTOR_IS_STRICT; + } + av_store(xc, MOUSE_XC_FLAGS, newSVuv(flags)); av_store(xc, MOUSE_XC_ATTRALL, (SV*)attrall); av_store(xc, MOUSE_XC_BUILDALL, (SV*)buildall); @@ -120,15 +128,17 @@ mouse_class_update_xc(pTHX_ SV* const metaclass PERL_UNUSED_DECL, HV* const stas for(i = 0; i < len; i++){ SV* const klass = MOUSE_av_at(linearized_isa, i); + HV* const st = gv_stashsv(klass, TRUE); SV* meta; GV* gv; - gv = stash_fetchs(stash, "BUILD", FALSE); + gv = stash_fetchs(st, "BUILD", FALSE); if(gv && GvCVu(gv)){ - av_push(buildall, newRV_inc((SV*)GvCV(gv))); + av_unshift(buildall, 1); + av_store(buildall, 0, newRV_inc((SV*)GvCV(gv))); } - gv = stash_fetchs(stash, "DEMOLISH", FALSE); + gv = stash_fetchs(st, "DEMOLISH", FALSE); if(gv && GvCVu(gv)){ av_push(demolishall, newRV_inc((SV*)GvCV(gv))); } @@ -148,7 +158,7 @@ mouse_class_update_xc(pTHX_ SV* const metaclass PERL_UNUSED_DECL, HV* const stas sv_setuv(MOUSE_xc_gen(xc), mro_get_pkg_gen(stash)); } -AV* +static AV* mouse_get_xc(pTHX_ SV* const metaclass) { AV* xc; SV* gen; @@ -173,7 +183,7 @@ mouse_get_xc(pTHX_ SV* const metaclass) { av_extend(xc, MOUSE_XC_last - 1); - av_store(xc, MOUSE_XC_GEN, newSViv(0)); + av_store(xc, MOUSE_XC_GEN, newSVuv(0U)); av_store(xc, MOUSE_XC_STASH, (SV*)stash); SvREFCNT_inc_simple_void_NN(stash); @@ -186,20 +196,30 @@ mouse_get_xc(pTHX_ SV* const metaclass) { } gen = MOUSE_xc_gen(xc); + + if(SvUVX(gen) != 0U && MOUSE_xc_flags(xc) & MOUSEf_XC_IS_IMMUTABLE){ + return xc; + } + stash = MOUSE_xc_stash(xc); - if(SvUV(gen) != mro_get_pkg_gen(stash)){ + if(SvUVX(gen) != mro_get_pkg_gen(stash)){ mouse_class_update_xc(aTHX_ metaclass, stash, xc); } return xc; } -HV* -mouse_build_args(pTHX_ SV* metaclass, SV* const klass, I32 const start, I32 const items, I32 const ax) { +static HV* +mouse_buildargs(pTHX_ SV* metaclass, SV* const klass, I32 ax, I32 items) { HV* args; - if((items - start) == 1){ - SV* const args_ref = ST(start); + + /* shift @_ */ + ax++; + items--; + + if(items == 1){ + SV* const args_ref = ST(0); if(!IsHashRef(args_ref)){ if(!metaclass){ metaclass = get_metaclass(klass); } mouse_throw_error(metaclass, NULL, "Single parameters to new() must be a HASH ref"); @@ -212,12 +232,12 @@ mouse_build_args(pTHX_ SV* metaclass, SV* const klass, I32 const start, I32 cons args = newHV_mortal(); - if( ((items - start) % 2) != 0 ){ + if( (items % 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){ + for(i = 0; i < items; i += 2){ (void)hv_store_ent(args, ST(i), newSVsv(ST(i+1)), 0U); } @@ -225,24 +245,70 @@ mouse_build_args(pTHX_ SV* metaclass, SV* const klass, I32 const start, I32 cons return args; } -void +static void +mouse_report_unknown_args(pTHX_ SV* const meta, AV* const attrs, HV* const args) { + HV* const attr_map = newHV_mortal(); + SV* const unknown = newSVpvs_flags("", SVs_TEMP); + I32 const len = AvFILLp(attrs) + 1; + I32 i; + HE* he; + + for(i = 0; i < len; i++){ + SV* const attr = MOUSE_av_at(attrs, i); + AV* const xa = mouse_get_xa(aTHX_ attr); + SV* const init_arg = MOUSE_xa_init_arg(xa); + if(SvOK(init_arg)){ + (void)hv_store_ent(attr_map, init_arg, &PL_sv_undef, 0U); + } + } + + hv_iterinit(args); + while((he = hv_iternext(args))){ + SV* const key = hv_iterkeysv(he); + if(!hv_exists_ent(attr_map, key, 0U)){ + sv_catpvf(unknown, "%"SVf", ", key); + } + } + + if(SvCUR(unknown) > 0){ + SvCUR(unknown) -= 2; /* chop "," */ + } + else{ + sv_setpvs(unknown, "(unknown)"); + } + + mouse_throw_error(meta, NULL, + "Unknown attribute passed to the constructor of %"SVf": %"SVf, + mcall0(meta, mouse_name), unknown); +} + + + +static void mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const args, bool const ignore_triggers) { AV* const xc = mouse_get_xc(aTHX_ meta); AV* const attrs = MOUSE_xc_attrall(xc); I32 len = AvFILLp(attrs) + 1; I32 i; AV* triggers_queue = NULL; + I32 used = 0; - ENTER; - SAVETMPS; + assert(meta || object); + assert(args); + assert(SvTYPE(args) == SVt_PVHV); + + if(mg_find((SV*)args, PERL_MAGIC_tied)){ + croak("You cannot use tied HASH reference as initializing arguments"); + } if(!ignore_triggers){ triggers_queue = newAV_mortal(); } + /* for each attribute */ for(i = 0; i < len; i++){ - SV* const attr = AvARRAY(attrs)[i]; - AV* const xa = mouse_get_xa(aTHX_ AvARRAY(attrs)[i]); + SV* const attr = MOUSE_av_at(attrs, i); + AV* const xa = mouse_get_xa(aTHX_ attr); SV* const slot = MOUSE_xa_slot(xa); U16 const flags = (U16)MOUSE_xa_flags(xa); @@ -254,7 +320,7 @@ mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const if(flags & MOUSEf_ATTR_HAS_TC){ value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags); } - set_slot(object, slot, value); + value = set_slot(object, slot, value); if(SvROK(value) && flags & MOUSEf_ATTR_IS_WEAK_REF){ weaken_slot(object, slot); } @@ -265,6 +331,7 @@ mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const av_push(triggers_queue, (SV*)pair); } + used++; } else { /* no init arg */ if(flags & (MOUSEf_ATTR_HAS_DEFAULT | MOUSEf_ATTR_HAS_BUILDER)){ @@ -276,7 +343,11 @@ mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const mouse_throw_error(attr, NULL, "Attribute (%"SVf") is required", slot); } } - } /* for each attributes */ + } /* for each attribute */ + + if(MOUSE_xc_flags(xc) & MOUSEf_XC_CONSTRUCTOR_IS_STRICT && used < HvUSEDKEYS(args)){ + mouse_report_unknown_args(aTHX_ meta, attrs, args); + } if(triggers_queue){ len = AvFILLp(triggers_queue) + 1; @@ -290,11 +361,54 @@ mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const } if(MOUSE_xc_flags(xc) & MOUSEf_XC_IS_ANON){ - set_slot(object, newSVpvs_flags("__ANON__", SVs_TEMP), meta); + (void)set_slot(object, newSVpvs_flags("__METACLASS__", SVs_TEMP), meta); } - FREETMPS; - LEAVE; +} + +static SV* +mouse_initialize_metaclass(pTHX_ SV* const klass) { + SV* meta = get_metaclass(klass); + + if(!SvOK(meta)){ + dSP; + PUSHMARK(SP); + + EXTEND(SP, 2); + mPUSHp("Mouse::Meta::Class", sizeof("Mouse::Meta::Class")-1); + PUSHs(klass); + PUTBACK; + + call_method("initialize", G_SCALAR); + SPAGAIN; + meta = POPs; + PUTBACK; + } + + return meta; +} + +static void +mouse_buildall(pTHX_ AV* const xc, SV* const object, SV* const args) { + AV* const buildall = MOUSE_xc_buildall(xc); + I32 const len = AvFILLp(buildall) + 1; + I32 i; + for(i = 0; i < len; i++){ + dSP; + + PUSHMARK(SP); + EXTEND(SP, 2); + PUSHs(object); + PUSHs(args); + PUTBACK; + + call_sv(AvARRAY(buildall)[i], G_VOID); + + /* discard a scalar which G_VOID returns */ + SPAGAIN; + (void)POPs; + PUTBACK; + } } MODULE = Mouse PACKAGE = Mouse @@ -306,6 +420,7 @@ BOOT: mouse_namespace = newSVpvs_share("namespace"); mouse_methods = newSVpvs_share("methods"); mouse_name = newSVpvs_share("name"); + mouse_coerce = newSVpvs_share("coerce"); mouse_get_attribute = newSVpvs_share("get_attribute"); mouse_get_attribute_list = newSVpvs_share("get_attribute_list"); @@ -365,8 +480,8 @@ CODE: 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"); + if(!(SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVCV)){ + mouse_throw_error(self, NULL, "You must pass a CODE reference to add_method"); } code_ref = sv; } @@ -379,16 +494,36 @@ CODE: } 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 */ ){ + (void)set_slot(methods, name, code); /* $self->{methods}{$name} = $code */ + + /* name the CODE ref if it's anonymous */ + { + CV* const code_entity = (CV*)SvRV(code_ref); + if(CvANON(code_entity) + && CvGV(code_entity) /* a cv under construction has no gv */ ){ + HV* dbsub; + + /* update %DB::sub to make NYTProf happy */ + if((PL_perldb & (PERLDBf_SUBLINE|PERLDB_NAMEANON)) + && PL_DBsub && (dbsub = GvHV(PL_DBsub)) + ){ + /* see Perl_newATTRSUB() in op.c */ + SV* const subname = sv_newmortal(); + HE* orig; + + gv_efullname3(subname, CvGV(code_entity), NULL); + orig = hv_fetch_ent(dbsub, subname, FALSE, 0U); + if(orig){ + gv_efullname3(subname, gv, NULL); + (void)hv_store_ent(dbsub, subname, HeVAL(orig), 0U); + SvREFCNT_inc_simple_void_NN(HeVAL(orig)); + } + } - // CvGV(code_entity) = gv; - // CvANON_off(code_entity); - //} + CvGV(code_entity) = gv; + CvANON_off(code_entity); + } + } } MODULE = Mouse PACKAGE = Mouse::Meta::Class @@ -396,6 +531,19 @@ MODULE = Mouse PACKAGE = Mouse::Meta::Class BOOT: INSTALL_SIMPLE_READER(Class, roles); INSTALL_SIMPLE_PREDICATE_WITH_KEY(Class, is_anon_class, anon_serial_id); + INSTALL_SIMPLE_READER(Class, is_immutable); + INSTALL_SIMPLE_READER_WITH_KEY(Class, __strict_constructor, strict_constructor); + + INSTALL_CLASS_HOLDER(Class, method_metaclass, "Mouse::Meta::Method"); + INSTALL_CLASS_HOLDER(Class, attribute_metaclass, "Mouse::Meta::Attribute"); + INSTALL_CLASS_HOLDER(Class, constructor_class, "Mouse::Meta::Method::Constructor::XS"); + INSTALL_CLASS_HOLDER(Class, destructor_class, "Mouse::Meta::Method::Destructor::XS"); + + newCONSTSUB(gv_stashpvs("Mouse::Meta::Method::Constructor::XS", TRUE), "_generate_constructor", + newRV_inc((SV*)get_cvs("Mouse::Object::new", TRUE))); + newCONSTSUB(gv_stashpvs("Mouse::Meta::Method::Destructor::XS", TRUE), "_generate_destructor", + newRV_inc((SV*)get_cvs("Mouse::Object::DESTROY", TRUE))); + void linearized_isa(SV* self) @@ -421,7 +569,7 @@ get_all_attributes(SV* self) PPCODE: { AV* const xc = mouse_get_xc(aTHX_ self); - AV* const all_attrs = MOUSE_xc_attrall(xc); + AV* const all_attrs = MOUSE_xc_attrall(xc); I32 const len = AvFILLp(all_attrs) + 1; I32 i; @@ -432,16 +580,17 @@ PPCODE: } SV* -new_object_(SV* meta, ...) +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); + HV* const args = mouse_buildargs(aTHX_ meta, NULL, ax, items); RETVAL = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc)); mouse_class_initialize_object(aTHX_ meta, RETVAL, args, FALSE); } - +OUTPUT: + RETVAL void _initialize_object(SV* meta, SV* object, HV* args, bool ignore_triggers = FALSE) @@ -456,13 +605,150 @@ BOOT: INSTALL_SIMPLE_READER_WITH_KEY(Role, get_roles, roles); INSTALL_SIMPLE_PREDICATE_WITH_KEY(Role, is_anon_role, anon_serial_id); + INSTALL_CLASS_HOLDER(Role, method_metaclass, "Mouse::Meta::Role::Method"); + MODULE = Mouse PACKAGE = Mouse::Object +SV* +new(SV* klass, ...) +CODE: +{ + SV* const meta = mouse_initialize_metaclass(aTHX_ klass); + AV* const xc = mouse_get_xc(aTHX_ meta); + UV const flags = MOUSE_xc_flags(xc); + SV* args; + + /* BUILDARGS */ + if(flags & MOUSEf_XC_HAS_BUILDARGS){ + I32 i; + SPAGAIN; + + PUSHMARK(SP); + EXTEND(SP, items); + for(i = 0; i < items; i++){ + PUSHs(ST(i)); + } + //SP += items; + PUTBACK; + call_method("BUILDARGS", G_SCALAR); + SPAGAIN; + args = POPs; + PUTBACK; + + if(!IsHashRef(args)){ + croak("BUILDARGS did not return a HASH reference"); + } + } + else{ + args = newRV_inc((SV*)mouse_buildargs(aTHX_ meta, klass, ax, items)); + sv_2mortal(args); + } + + /* new_object */ + RETVAL = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc)); + mouse_class_initialize_object(aTHX_ meta, RETVAL, (HV*)SvRV(args), FALSE); + + mouse_buildall(aTHX_ xc, RETVAL, args); +} +OUTPUT: + RETVAL + +void +DESTROY(SV* object) +ALIAS: + DESTROY = 0 + DEMOLISHALL = 1 +CODE: +{ + SV* const meta = get_metaclass(object); + AV* demolishall; + I32 len, i; + + if(!IsObject(object)){ + croak("You must not call %s as a class method", + ix == 0 ? "DESTROY" : "DEMOLISHALL"); + } + + if(SvOK(meta)){ + AV* const xc = mouse_get_xc(aTHX_ meta); + + demolishall = MOUSE_xc_demolishall(xc); + } + else { /* The metaclass is already destroyed */ + AV* const linearized_isa = mro_get_linear_isa(SvSTASH(SvRV(object))); + + len = AvFILLp(linearized_isa) + 1; + + demolishall = newAV_mortal(); + for(i = 0; i < len; i++){ + SV* const klass = MOUSE_av_at(linearized_isa, i); + HV* const st = gv_stashsv(klass, TRUE); + GV* const gv = stash_fetchs(st, "DEMOLISH", FALSE); + if(gv && GvCVu(gv)){ + av_push(demolishall, newRV_inc((SV*)GvCV(gv))); + } + } + } + + len = AvFILLp(demolishall) + 1; + if(len > 0){ + GV* const statusvalue = gv_fetchpvs("?", 0, SVt_PV); + + if(statusvalue){ /* it can be NULL */ + SAVESPTR(GvSV(statusvalue)); /* local $? */ + GvSV(statusvalue) = sv_newmortal(); + } + SAVESPTR(ERRSV); /* local $@ */ + ERRSV = newSVpvs_flags("", SVs_TEMP); + + for(i = 0; i < len; i++){ + SPAGAIN; + + PUSHMARK(SP); + XPUSHs(object); + XPUSHs(boolSV(PL_dirty)); + PUTBACK; + + call_sv(AvARRAY(demolishall)[i], G_VOID | G_EVAL); + + /* discard a scalar which G_VOID returns */ + SPAGAIN; + (void)POPs; + PUTBACK; + + if(sv_true(ERRSV)){ + SV* const e = newSVsv(ERRSV); + + FREETMPS; + LEAVE; + + sv_setsv(ERRSV, e); + SvREFCNT_dec(e); + croak(NULL); /* rethrow */ + } + } + } +} + HV* BUILDARGS(SV* klass, ...) CODE: { - RETVAL = mouse_build_args(aTHX_ NULL, klass, 1, items, ax); + RETVAL = mouse_buildargs(aTHX_ NULL, klass, ax, items); } OUTPUT: RETVAL + + +void +BUILDALL(SV* self, SV* args) +CODE: +{ + SV* const meta = get_metaclass(self); + AV* const xc = mouse_get_xc(aTHX_ meta); + + if(!IsHashRef(args)){ + croak("You must pass a HASH reference to BUILDALL"); + } + mouse_buildall(aTHX_ xc, self, args); +}