#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)
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 */
};
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);
}
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;
assert(meta || object);
assert(args);
croak("You cannot use tied HASH reference as initializing arguments");
}
- ENTER;
- SAVETMPS;
-
if(!ignore_triggers){
triggers_queue = newAV_mortal();
}
+ /* for each attribute */
for(i = 0; i < len; i++){
SV* const attr = MOUSE_av_at(attrs, i);
AV* const xa = mouse_get_xa(aTHX_ attr);
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);
}
av_push(triggers_queue, (SV*)pair);
}
+ used++;
}
else { /* no init arg */
if(flags & (MOUSEf_ATTR_HAS_DEFAULT | MOUSEf_ATTR_HAS_BUILDER)){
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;
}
if(MOUSE_xc_flags(xc) & MOUSEf_XC_IS_ANON){
- set_slot(object, newSVpvs_flags("__METACLASS__", SVs_TEMP), meta);
+ (void)set_slot(object, newSVpvs_flags("__METACLASS__", SVs_TEMP), meta);
}
- FREETMPS;
- LEAVE;
}
static SV*
PUSHs(args);
PUTBACK;
- call_sv(AvARRAY(buildall)[i], G_VOID | G_DISCARD);
+ call_sv(AvARRAY(buildall)[i], G_VOID);
+
+ /* discard a scalar which G_VOID returns */
+ SPAGAIN;
+ (void)POPs;
+ PUTBACK;
}
}
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");
}
sv_setsv_mg((SV*)gv, code_ref); /* *gv = $code_ref */
- set_slot(methods, name, code); /* $self->{methods}{$name} = $code */
+ (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);
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");
AV* demolishall;
I32 len, i;
- PERL_UNUSED_VAR(ix);
-
if(!IsObject(object)){
- croak("You must not call DESTROY as a class method");
+ croak("You must not call %s as a class method",
+ ix == 0 ? "DESTROY" : "DEMOLISHALL");
}
if(SvOK(meta)){
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;
- call_sv(AvARRAY(demolishall)[i], G_VOID | G_DISCARD | G_EVAL);
- if(SvTRUE(ERRSV)){
+ if(sv_true(ERRSV)){
SV* const e = newSVsv(ERRSV);
FREETMPS;