1 #define NEED_newSVpvn_flags_GLOBAL
8 SV* mouse_get_attribute;
9 SV* mouse_get_attribute_list;
11 #define MOUSE_xc_flags(a) SvUVX(MOUSE_av_at((a), MOUSE_XC_FLAGS))
12 #define MOUSE_xc_gen(a) MOUSE_av_at((a), MOUSE_XC_GEN)
13 #define MOUSE_xc_stash(a) ( (HV*)MOUSE_av_at((a), MOUSE_XC_STASH) )
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_DEMOLISHALL) )
18 enum mouse_xc_flags_t {
19 MOUSEf_XC_IS_IMMUTABLE = 0x0001,
20 MOUSEf_XC_IS_ANON = 0x0002,
21 MOUSEf_XC_HAS_BUILDARGS = 0x0004,
23 MOUSEf_XC_HAS_STRICT_CONSTRUCTOR
26 MOUSEf_XC_mask = 0xFFFF /* not used */
29 /* Mouse XS Metaclass object */
33 MOUSE_XC_GEN, /* class generation */
34 MOUSE_XC_STASH, /* symbol table hash */
36 MOUSE_XC_ATTRALL, /* all the attributes */
37 MOUSE_XC_BUILDALL, /* all the BUILD methods */
38 MOUSE_XC_DEMOLISHALL, /* all the DEMOLISH methods */
43 static MGVTBL mouse_xc_vtbl; /* for identity */
46 mouse_class_push_attribute_list(pTHX_ SV* const metaclass, AV* const attrall, HV* const seen){
50 /* $meta->get_attribute_list */
55 n = call_sv(mouse_get_attribute_list, G_ARRAY | G_METHOD);
56 for(NOOP; n > 0; n--){
63 if(hv_exists_ent(seen, name, 0U)){
66 (void)hv_store_ent(seen, name, &PL_sv_undef, 0U);
68 av_push(attrall, newSVsv( mcall1(metaclass, mouse_get_attribute, name) ));
73 mouse_class_has_custom_buildargs(pTHX_ HV* const stash) {
74 XS(XS_Mouse__Object_BUILDARGS); /* prototype */
76 GV* const buildargs = gv_fetchmeth_autoload(stash, "BUILDARGS", sizeof("BUILDARGS")-1, 0);
78 return buildargs && CvXSUB(GvCV(buildargs)) != XS_Mouse__Object_BUILDARGS;
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);
87 AV* const attrall = newAV();
88 AV* const buildall = newAV();
89 AV* const demolishall = newAV();
90 HV* const seen = newHV(); /* for attributes */
95 sv_2mortal((SV*)seen);
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);
102 SvREFCNT_inc_simple_void_NN(linearized_isa);
103 sv_2mortal((SV*)linearized_isa);
107 if(predicate_calls(metaclass, "is_immutable")){
108 flags |= MOUSEf_XC_IS_IMMUTABLE;
111 if(predicate_calls(metaclass, "is_anon_class")){
112 flags |= MOUSEf_XC_IS_ANON;
115 if(mouse_class_has_custom_buildargs(aTHX_ stash)){
116 flags |= MOUSEf_XC_HAS_BUILDARGS;
119 if(predicate_calls(metaclass, "_has_strict_constructor")){
120 flags |= MOUSEf_XC_HAS_STRICT_CONSTRUCTOR;
123 av_store(xc, MOUSE_XC_FLAGS, newSVuv(flags));
124 av_store(xc, MOUSE_XC_ATTRALL, (SV*)attrall);
125 av_store(xc, MOUSE_XC_BUILDALL, (SV*)buildall);
126 av_store(xc, MOUSE_XC_DEMOLISHALL, (SV*)demolishall);
128 for(i = 0; i < len; i++){
129 SV* const klass = MOUSE_av_at(linearized_isa, i);
130 HV* const st = gv_stashsv(klass, TRUE);
134 gv = stash_fetchs(st, "BUILD", FALSE);
136 av_unshift(buildall, 1);
137 av_store(buildall, 0, newRV_inc((SV*)GvCV(gv)));
140 gv = stash_fetchs(st, "DEMOLISH", FALSE);
142 av_push(demolishall, newRV_inc((SV*)GvCV(gv)));
146 meta = get_metaclass(klass);
148 continue; /* skip non-Mouse classes */
151 mouse_class_push_attribute_list(aTHX_ meta, attrall, seen);
157 sv_setuv(MOUSE_xc_gen(xc), mro_get_pkg_gen(stash));
161 mouse_get_xc(pTHX_ SV* const metaclass) {
167 if(!IsObject(metaclass)){
168 croak("Not a Mouse metaclass");
171 mg = mouse_mg_find(aTHX_ SvRV(metaclass), &mouse_xc_vtbl, 0x00);
173 SV* const package = get_slot(metaclass, mouse_package);
175 const char* const pv = SvPV_const(package, len);
177 stash = gv_stashpvn(pv, len, TRUE);
180 mg = sv_magicext(SvRV(metaclass), (SV*)xc, PERL_MAGIC_ext, &mouse_xc_vtbl, pv, len);
181 SvREFCNT_dec(xc); /* refcnt++ in sv_magicext */
183 av_extend(xc, MOUSE_XC_last - 1);
185 av_store(xc, MOUSE_XC_GEN, newSVuv(0U));
186 av_store(xc, MOUSE_XC_STASH, (SV*)stash);
188 SvREFCNT_inc_simple_void_NN(stash);
191 xc = (AV*)MOUSE_mg_obj(mg);
194 assert(SvTYPE(xc) == SVt_PVAV);
197 gen = MOUSE_xc_gen(xc);
199 if(SvUVX(gen) != 0U && MOUSE_xc_flags(xc) & MOUSEf_XC_IS_IMMUTABLE){
203 stash = MOUSE_xc_stash(xc);
205 if(SvUVX(gen) != mro_get_pkg_gen(stash)){
206 mouse_class_update_xc(aTHX_ metaclass, stash, xc);
213 mouse_buildargs(pTHX_ SV* metaclass, SV* const klass, I32 ax, I32 items) {
221 SV* const args_ref = ST(0);
222 if(!IsHashRef(args_ref)){
223 if(!metaclass){ metaclass = get_metaclass(klass); }
224 mouse_throw_error(metaclass, NULL, "Single parameters to new() must be a HASH ref");
226 args = newHVhv((HV*)SvRV(args_ref));
227 sv_2mortal((SV*)args);
232 args = newHV_mortal();
234 if( (items % 2) != 0 ){
235 if(!metaclass){ metaclass = get_metaclass(klass); }
236 mouse_throw_error(metaclass, NULL, "Odd number of parameters to new()");
239 for(i = 0; i < items; i += 2){
240 (void)hv_store_ent(args, ST(i), newSVsv(ST(i+1)), 0U);
248 mouse_report_unmatched_keys(pTHX_ SV* const meta, AV* const attrs, HV* const args) {
249 HV* const attr_map = newHV_mortal();
250 I32 const len = AvFILLp(attrs) + 1;
252 SV* const unknown = newSVpvs_flags("", SVs_TEMP);
255 for(i = 0; i < len; i++){
256 SV* const attr = MOUSE_av_at(attrs, i);
257 (void)hv_store_ent(attr_map, mcall0(attr, mouse_name), &PL_sv_yes, 0U);
261 while((he = hv_iternext(args))){
262 SV* const key = hv_iterkeysv(he);
263 if(!hv_exists_ent(attr_map, key, 0U)){
264 sv_catpvf(unknown, " %"SVf",", key);
267 SvCUR(unknown)--; /* chop "," */
268 mouse_throw_error(meta, NULL,
269 "Unknown attribute init_arg passed to the constructor of %"SVf": %"SVf,
270 mcall0(meta, mouse_name), unknown);
274 mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const args, bool const ignore_triggers) {
275 AV* const xc = mouse_get_xc(aTHX_ meta);
276 AV* const attrs = MOUSE_xc_attrall(xc);
277 I32 len = AvFILLp(attrs) + 1;
280 AV* triggers_queue = NULL;
282 assert(meta || object);
284 assert(SvTYPE(args) == SVt_PVHV);
289 if(!ignore_triggers){
290 triggers_queue = newAV_mortal();
293 for(i = 0; i < len; i++){
294 SV* const attr = MOUSE_av_at(attrs, i);
295 AV* const xa = mouse_get_xa(aTHX_ attr);
297 SV* const slot = MOUSE_xa_slot(xa);
298 U16 const flags = (U16)MOUSE_xa_flags(xa);
299 SV* const init_arg = MOUSE_xa_init_arg(xa);
302 if(SvOK(init_arg) && ( he = hv_fetch_ent(args, init_arg, FALSE, 0U) ) ){
303 SV* value = HeVAL(he);
304 if(flags & MOUSEf_ATTR_HAS_TC){
305 value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags);
307 set_slot(object, slot, value);
308 if(SvROK(value) && flags & MOUSEf_ATTR_IS_WEAK_REF){
309 weaken_slot(object, slot);
311 if(flags & MOUSEf_ATTR_HAS_TRIGGER && triggers_queue){
312 AV* const pair = newAV();
313 av_push(pair, newSVsv( mcall0s(attr, "trigger") ));
314 av_push(pair, newSVsv(value));
316 av_push(triggers_queue, (SV*)pair);
321 else { /* no init arg */
322 if(flags & (MOUSEf_ATTR_HAS_DEFAULT | MOUSEf_ATTR_HAS_BUILDER)){
323 if(!(flags & MOUSEf_ATTR_IS_LAZY)){
324 mouse_xa_set_default(aTHX_ xa, object);
327 else if(flags & MOUSEf_ATTR_IS_REQUIRED) {
328 mouse_throw_error(attr, NULL, "Attribute (%"SVf") is required", slot);
331 } /* for each attributes */
334 len = AvFILLp(triggers_queue) + 1;
335 for(i = 0; i < len; i++){
336 AV* const pair = (AV*)AvARRAY(triggers_queue)[i];
337 SV* const trigger = AvARRAY(pair)[0];
338 SV* const value = AvARRAY(pair)[1];
340 mcall1(object, trigger, value);
344 if(MOUSE_xc_flags(xc) & MOUSEf_XC_HAS_STRICT_CONSTRUCTOR && used < HvUSEDKEYS(args)){
345 mouse_report_unmatched_keys(aTHX_ meta, attrs, args);
348 if(MOUSE_xc_flags(xc) & MOUSEf_XC_IS_ANON){
349 set_slot(object, newSVpvs_flags("__METACLASS__", SVs_TEMP), meta);
357 mouse_initialize_metaclass(pTHX_ SV* const klass) {
358 SV* meta = get_metaclass(klass);
365 mPUSHp("Mouse::Meta::Class", sizeof("Mouse::Meta::Class")-1);
369 call_method("initialize", G_SCALAR);
379 mouse_buildall(pTHX_ AV* const xc, SV* const object, SV* const args) {
380 AV* const buildall = MOUSE_xc_buildall(xc);
381 I32 const len = AvFILLp(buildall) + 1;
383 for(i = 0; i < len; i++){
392 call_sv(AvARRAY(buildall)[i], G_VOID | G_DISCARD);
396 MODULE = Mouse PACKAGE = Mouse
401 mouse_package = newSVpvs_share("package");
402 mouse_namespace = newSVpvs_share("namespace");
403 mouse_methods = newSVpvs_share("methods");
404 mouse_name = newSVpvs_share("name");
406 mouse_get_attribute = newSVpvs_share("get_attribute");
407 mouse_get_attribute_list = newSVpvs_share("get_attribute_list");
409 MOUSE_CALL_BOOT(Mouse__Util);
410 MOUSE_CALL_BOOT(Mouse__Util__TypeConstraints);
411 MOUSE_CALL_BOOT(Mouse__Meta__Method__Accessor__XS);
412 MOUSE_CALL_BOOT(Mouse__Meta__Attribute);
415 MODULE = Mouse PACKAGE = Mouse::Meta::Module
418 INSTALL_SIMPLE_READER_WITH_KEY(Module, name, package);
419 INSTALL_SIMPLE_READER_WITH_KEY(Module, _method_map, methods);
420 INSTALL_SIMPLE_READER_WITH_KEY(Module, _attribute_map, attributes);
426 SV* const package = get_slot(self, mouse_package);
427 if(!(package && SvOK(package))){
428 croak("No package name defined");
430 RETVAL = gv_stashsv(package, GV_ADDMULTI);
435 # ignore extra arguments for extensibility
437 add_method(SV* self, SV* name, SV* code, ...)
440 SV* const package = get_slot(self, mouse_package); /* $self->{package} */
441 SV* const methods = get_slot(self, mouse_methods); /* $self->{methods} */
445 if(!(package && SvOK(package))){
446 croak("No package name defined");
453 mouse_throw_error(self, NULL, "You must define a method name");
456 mouse_throw_error(self, NULL, "You must define a CODE reference");
460 if(SvTYPE(SvRV(code_ref)) != SVt_PVCV){
461 SV* sv = code_ref; /* used in tryAMAGICunDEREF */
462 SV** sp = &sv; /* used in tryAMAGICunDEREF */
463 tryAMAGICunDEREF(to_cv); /* try \&{$code} */
464 if(!(SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVCV)){
465 mouse_throw_error(self, NULL, "You must pass a CODE reference to add_method");
470 /* *{$package . '::' . $name} -> *gv */
471 gv = gv_fetchpv(form("%"SVf"::%"SVf, package, name), GV_ADDMULTI, SVt_PVCV);
472 if(GvCVu(gv)){ /* delete *slot{gv} to work around "redefine" warning */
473 SvREFCNT_dec(GvCV(gv));
476 sv_setsv_mg((SV*)gv, code_ref); /* *gv = $code_ref */
478 set_slot(methods, name, code); /* $self->{methods}{$name} = $code */
480 /* name the CODE ref if it's anonymous */
482 CV* const code_entity = (CV*)SvRV(code_ref);
483 if(CvANON(code_entity)
484 && CvGV(code_entity) /* a cv under construction has no gv */ ){
486 CvGV(code_entity) = gv;
487 CvANON_off(code_entity);
492 MODULE = Mouse PACKAGE = Mouse::Meta::Class
495 INSTALL_SIMPLE_READER(Class, roles);
496 INSTALL_SIMPLE_PREDICATE_WITH_KEY(Class, is_anon_class, anon_serial_id);
497 INSTALL_SIMPLE_READER(Class, is_immutable);
498 INSTALL_SIMPLE_READER_WITH_KEY(Class, has_strict_constructor, _strict_constructor);
500 INSTALL_CLASS_HOLDER(Class, method_metaclass, "Mouse::Meta::Method");
501 INSTALL_CLASS_HOLDER(Class, attribute_metaclass, "Mouse::Meta::Attribute");
502 INSTALL_CLASS_HOLDER(Class, constructor_class, "Mouse::Meta::Method::Constructor::XS");
503 INSTALL_CLASS_HOLDER(Class, destructor_class, "Mouse::Meta::Method::Destructor::XS");
505 newCONSTSUB(gv_stashpvs("Mouse::Meta::Method::Constructor::XS", TRUE), "_generate_constructor",
506 newRV_inc((SV*)get_cvs("Mouse::Object::new", TRUE)));
507 newCONSTSUB(gv_stashpvs("Mouse::Meta::Method::Destructor::XS", TRUE), "_generate_destructor",
508 newRV_inc((SV*)get_cvs("Mouse::Object::DESTROY", TRUE)));
512 linearized_isa(SV* self)
515 SV* const stash_ref = mcall0(self, mouse_namespace); /* $self->namespace */
519 if(!(SvROK(stash_ref) && SvTYPE(SvRV(stash_ref)) == SVt_PVHV)){
520 croak("namespace() didn't return a HASH reference");
522 linearized_isa = mro_get_linear_isa((HV*)SvRV(stash_ref));
523 len = AvFILLp(linearized_isa) + 1;
525 for(i = 0; i < len; i++){
526 PUSHs(AvARRAY(linearized_isa)[i]);
531 get_all_attributes(SV* self)
534 AV* const xc = mouse_get_xc(aTHX_ self);
535 AV* const all_attrs = MOUSE_xc_attrall(xc);
536 I32 const len = AvFILLp(all_attrs) + 1;
540 for(i = 0; i < len; i++){
541 PUSHs( MOUSE_av_at(all_attrs, i) );
546 new_object(SV* meta, ...)
549 AV* const xc = mouse_get_xc(aTHX_ meta);
550 HV* const args = mouse_buildargs(aTHX_ meta, NULL, ax, items);
552 RETVAL = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc));
553 mouse_class_initialize_object(aTHX_ meta, RETVAL, args, FALSE);
559 _initialize_object(SV* meta, SV* object, HV* args, bool ignore_triggers = FALSE)
562 mouse_class_initialize_object(aTHX_ meta, object, args, ignore_triggers);
565 MODULE = Mouse PACKAGE = Mouse::Meta::Role
568 INSTALL_SIMPLE_READER_WITH_KEY(Role, get_roles, roles);
569 INSTALL_SIMPLE_PREDICATE_WITH_KEY(Role, is_anon_role, anon_serial_id);
571 INSTALL_CLASS_HOLDER(Role, method_metaclass, "Mouse::Meta::Role::Method");
573 MODULE = Mouse PACKAGE = Mouse::Object
579 SV* const meta = mouse_initialize_metaclass(aTHX_ klass);
580 AV* const xc = mouse_get_xc(aTHX_ meta);
581 UV const flags = MOUSE_xc_flags(xc);
585 if(flags & MOUSEf_XC_HAS_BUILDARGS){
591 for(i = 0; i < items; i++){
596 call_method("BUILDARGS", G_SCALAR);
601 if(!IsHashRef(args)){
602 croak("BUILDARGS did not return a HASH reference");
606 args = newRV_inc((SV*)mouse_buildargs(aTHX_ meta, klass, ax, items));
611 RETVAL = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc));
612 mouse_class_initialize_object(aTHX_ meta, RETVAL, (HV*)SvRV(args), FALSE);
614 mouse_buildall(aTHX_ xc, RETVAL, args);
626 SV* const meta = get_metaclass(object);
632 if(!IsObject(object)){
633 croak("You must not call DESTROY as a class method");
637 AV* const xc = mouse_get_xc(aTHX_ meta);
639 demolishall = MOUSE_xc_demolishall(xc);
641 else { /* The metaclass is already destroyed */
642 AV* const linearized_isa = mro_get_linear_isa(SvSTASH(SvRV(object)));
644 len = AvFILLp(linearized_isa) + 1;
646 demolishall = newAV_mortal();
647 for(i = 0; i < len; i++){
648 SV* const klass = MOUSE_av_at(linearized_isa, i);
649 HV* const st = gv_stashsv(klass, TRUE);
650 GV* const gv = stash_fetchs(st, "DEMOLISH", FALSE);
652 av_push(demolishall, newRV_inc((SV*)GvCV(gv)));
657 len = AvFILLp(demolishall) + 1;
659 GV* const statusvalue = gv_fetchpvs("?", 0, SVt_PV);
660 SAVESPTR(GvSV(statusvalue)); /* local $? */
661 SAVESPTR(ERRSV); /* local $@ */
663 GvSV(statusvalue) = sv_newmortal();
664 ERRSV = newSVpvs_flags("", SVs_TEMP);
665 for(i = 0; i < len; i++){
672 call_sv(AvARRAY(demolishall)[i], G_VOID | G_DISCARD | G_EVAL);
674 SV* const e = newSVsv(ERRSV);
681 croak(NULL); /* rethrow */
688 BUILDARGS(SV* klass, ...)
691 RETVAL = mouse_buildargs(aTHX_ NULL, klass, ax, items);
698 BUILDALL(SV* self, SV* args)
701 SV* const meta = get_metaclass(self);
702 AV* const xc = mouse_get_xc(aTHX_ meta);
704 if(!IsHashRef(args)){
705 croak("You must pass a HASH reference to BUILDALL");
707 if(mg_find(SvRV(args), PERL_MAGIC_tied)){
708 croak("You cannot use tie HASH reference as args");
710 mouse_buildall(aTHX_ xc, self, args);