xs-src/Mouse.xs

   1 #define  NEED_newSVpvn_flags_GLOBAL
   2 #include "mouse.h"
   3
   4 /* keywords for methods/keys */
   5 SV* mouse_package;
   6 SV* mouse_namespace;
   7 SV* mouse_methods;
   8 SV* mouse_name;
   9 SV* mouse_get_attribute;
  10 SV* mouse_get_attribute_list;
  11 SV* mouse_coerce;
  12
  13 #define MOUSE_xc_flags(a)       SvUVX(MOUSE_av_at((a), MOUSE_XC_FLAGS))
  14 #define MOUSE_xc_gen(a)         MOUSE_av_at((a), MOUSE_XC_GEN)
  15 #define MOUSE_xc_stash(a)       ( (HV*)MOUSE_av_at((a), MOUSE_XC_STASH) )
  16 #define MOUSE_xc_attrall(a)     ( (AV*)MOUSE_av_at((a), MOUSE_XC_ATTRALL) )
  17 #define MOUSE_xc_buildall(a)    ( (AV*)MOUSE_av_at((a), MOUSE_XC_BUILDALL) )
  18 #define MOUSE_xc_demolishall(a) ( (AV*)MOUSE_av_at((a), MOUSE_XC_DEMOLISHALL) )
  19
  20 enum mouse_xc_flags_t {
  21     MOUSEf_XC_IS_IMMUTABLE   = 0x0001,
  22     MOUSEf_XC_IS_ANON        = 0x0002,
  23     MOUSEf_XC_HAS_BUILDARGS  = 0x0004,
  24     MOUSEf_XC_CONSTRUCTOR_IS_STRICT
  25                              = 0x0008,
  26
  27     MOUSEf_XC_mask           = 0xFFFF /* not used */
  28 };
  29
  30 /* Mouse XS Metaclass object */
  31 enum mouse_xc_ix_t{
  32     MOUSE_XC_FLAGS,
  33
  34     MOUSE_XC_GEN,          /* class generation */
  35     MOUSE_XC_STASH,        /* symbol table hash */
  36
  37     MOUSE_XC_ATTRALL,      /* all the attributes */
  38     MOUSE_XC_BUILDALL,     /* all the BUILD methods */
  39     MOUSE_XC_DEMOLISHALL,  /* all the DEMOLISH methods */
  40
  41     MOUSE_XC_last
  42 };
  43
  44 enum mouse_modifier_t {
  45     MOUSE_M_BEFORE,
  46     MOUSE_M_AROUND,
  47     MOUSE_M_AFTER,
  48 };
  49
  50 static MGVTBL mouse_xc_vtbl; /* for identity */
  51
  52 HV*
  53 mouse_get_namespace(pTHX_ SV* const meta) {
  54     SV* const package = get_slot(meta, mouse_package);
  55     if(!(package && SvOK(package))){
  56         croak("No package name defined for metaclass");
  57     }
  58     return gv_stashsv(package, GV_ADDMULTI);
  59 }
  60
  61 static AV*
  62 mouse_calculate_all_attributes(pTHX_ SV* const metaclass) {
  63     SV* const avref = mcall0s(metaclass, "_calculate_all_attributes");
  64     if(!(SvROK(avref) && SvTYPE(SvRV(avref)) == SVt_PVAV)) {
  65         croak("$meta->_calculate_all_attributes did not return an ARRAY reference");
  66     }
  67     return (AV*)SvRV(avref);
  68 }
  69
  70 XS(XS_Mouse__Object_BUILDARGS); /* prototype */
  71
  72 static int
  73 mouse_class_has_custom_buildargs(pTHX_ HV* const stash) {
  74     GV* const buildargs = gv_fetchmeth_autoload(stash, "BUILDARGS", sizeof("BUILDARGS")-1, 0);
  75
  76     return buildargs && CvXSUB(GvCV(buildargs)) != XS_Mouse__Object_BUILDARGS;
  77 }
  78
  79 static AV*
  80 mouse_class_update_xc(pTHX_ SV* const metaclass PERL_UNUSED_DECL, AV* const xc) {
  81     HV* const stash          = MOUSE_xc_stash(xc);
  82     AV* const linearized_isa = mro_get_linear_isa(stash);
  83     I32 const len            = AvFILLp(linearized_isa) + 1;
  84     I32 i;
  85     U32 flags             = 0x00;
  86     AV* const buildall    = newAV();
  87     AV* const demolishall = newAV();
  88     AV* attrall;
  89
  90     ENTER;
  91     SAVETMPS;
  92
  93      /* old data will be delete at the end of the perl scope */
  94     av_delete(xc, MOUSE_XC_DEMOLISHALL, 0x00);
  95     av_delete(xc, MOUSE_XC_BUILDALL,    0x00);
  96     av_delete(xc, MOUSE_XC_ATTRALL,     0x00);
  97
  98     SvREFCNT_inc_simple_void_NN(linearized_isa);
  99     sv_2mortal((SV*)linearized_isa);
 100
 101     /* update */
 102
 103     av_store(xc, MOUSE_XC_BUILDALL,    (SV*)buildall);
 104     av_store(xc, MOUSE_XC_DEMOLISHALL, (SV*)demolishall);
 105
 106     attrall = mouse_calculate_all_attributes(aTHX_ metaclass);
 107     SvREFCNT_inc_simple_void_NN(attrall);
 108     av_store(xc, MOUSE_XC_ATTRALL,     (SV*)attrall);
 109
 110     if(predicate_calls(metaclass, "is_immutable")){
 111         flags |= MOUSEf_XC_IS_IMMUTABLE;
 112     }
 113
 114     if(predicate_calls(metaclass, "is_anon_class")){
 115         flags |= MOUSEf_XC_IS_ANON;
 116     }
 117
 118     if(mouse_class_has_custom_buildargs(aTHX_ stash)){
 119         flags |= MOUSEf_XC_HAS_BUILDARGS;
 120     }
 121
 122     if(predicate_calls(metaclass, "strict_constructor")){
 123         flags |= MOUSEf_XC_CONSTRUCTOR_IS_STRICT;
 124     }
 125
 126     av_store(xc, MOUSE_XC_FLAGS,       newSVuv(flags));
 127
 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);
 131         GV* gv;
 132
 133         gv = stash_fetchs(st, "BUILD", FALSE);
 134         if(gv && GvCVu(gv)){
 135             av_unshift(buildall, 1);
 136             av_store(buildall, 0, newRV_inc((SV*)GvCV(gv)));
 137         }
 138
 139         gv = stash_fetchs(st, "DEMOLISH", FALSE);
 140         if(gv && GvCVu(gv)){
 141             av_push(demolishall, newRV_inc((SV*)GvCV(gv)));
 142         }
 143     }
 144
 145     FREETMPS;
 146     LEAVE;
 147
 148     sv_setuv(MOUSE_xc_gen(xc), mro_get_pkg_gen(stash));
 149     return xc;
 150 }
 151
 152 static AV*
 153 mouse_get_xc_wo_check(pTHX_ SV* const metaclass) {
 154     AV* xc;
 155     MAGIC* mg;
 156
 157     if(!IsObject(metaclass)){
 158         croak("Not a Mouse metaclass");
 159     }
 160
 161     mg = mouse_mg_find(aTHX_ SvRV(metaclass), &mouse_xc_vtbl, 0x00);
 162     if(!mg){
 163         /* cache stash for performance */
 164         HV* const stash = mouse_get_namespace(aTHX_ metaclass);
 165         xc    = newAV();
 166
 167         mg = sv_magicext(SvRV(metaclass), (SV*)xc, PERL_MAGIC_ext,
 168             &mouse_xc_vtbl, NULL, 0);
 169         SvREFCNT_dec(xc); /* refcnt++ in sv_magicext */
 170
 171         av_extend(xc, MOUSE_XC_last - 1);
 172
 173         av_store(xc, MOUSE_XC_GEN, newSVuv(0U));
 174         av_store(xc, MOUSE_XC_STASH, (SV*)stash);
 175         SvREFCNT_inc_simple_void_NN(stash);
 176     }
 177     else{
 178         xc    = (AV*)MOUSE_mg_obj(mg);
 179
 180         assert(xc);
 181         assert(SvTYPE(xc) == SVt_PVAV);
 182     }
 183     return xc;
 184 }
 185
 186 static int
 187 mouse_xc_is_fresh(pTHX_ AV* const xc) {
 188     HV* const stash = MOUSE_xc_stash(xc);
 189     SV* const gen   = MOUSE_xc_gen(xc);
 190     if(SvUVX(gen) != 0U && MOUSE_xc_flags(xc) & MOUSEf_XC_IS_IMMUTABLE) {
 191         return TRUE;
 192     }
 193     return SvUVX(gen) == mro_get_pkg_gen(stash);
 194 }
 195
 196 STATIC_INLINE AV*
 197 mouse_get_xc(pTHX_ SV* const metaclass) {
 198     AV* const xc = mouse_get_xc_wo_check(aTHX_ metaclass);
 199     return mouse_xc_is_fresh(aTHX_ xc)
 200         ? xc
 201         : mouse_class_update_xc(aTHX_ metaclass, xc);
 202 }
 203
 204 static AV*
 205 mouse_get_xc_if_fresh(pTHX_ SV* const metaclass) {
 206     AV* const xc = mouse_get_xc_wo_check(aTHX_ metaclass);
 207     return mouse_xc_is_fresh(aTHX_ xc)
 208         ? xc
 209         : NULL;
 210 }
 211
 212 static HV*
 213 mouse_buildargs(pTHX_ SV* metaclass, SV* const klass, I32 ax, I32 items) {
 214     HV* args;
 215
 216     /* shift @_ */
 217     ax++;
 218     items--;
 219
 220     if(items == 1){
 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");
 225         }
 226         args = newHVhv((HV*)SvRV(args_ref));
 227         sv_2mortal((SV*)args);
 228     }
 229     else{
 230         I32 i;
 231
 232         if( (items % 2) != 0 ){
 233             if(!metaclass){ metaclass = get_metaclass(klass); }
 234             mouse_throw_error(metaclass, NULL, "Odd number of parameters to new()");
 235         }
 236
 237         args = newHV_mortal();
 238         for(i = 0; i < items; i += 2){
 239             (void)hv_store_ent(args, ST(i), newSVsv(ST(i+1)), 0U);
 240         }
 241
 242     }
 243     return args;
 244 }
 245
 246 static void
 247 mouse_report_unknown_args(pTHX_ SV* const meta, AV* const attrs, HV* const args) {
 248     HV* const attr_map = newHV_mortal();
 249     SV* const unknown  = newSVpvs_flags("", SVs_TEMP);
 250     I32 const len      = AvFILLp(attrs) + 1;
 251     I32 i;
 252     HE* he;
 253
 254     for(i = 0; i < len; i++){
 255         SV* const attr = MOUSE_av_at(attrs, i);
 256         AV* const xa   = mouse_get_xa(aTHX_ attr);
 257         SV* const init_arg = MOUSE_xa_init_arg(xa);
 258         if(SvOK(init_arg)){
 259             (void)hv_store_ent(attr_map, init_arg, &PL_sv_undef, 0U);
 260         }
 261     }
 262
 263     hv_iterinit(args);
 264     while((he = hv_iternext(args))){
 265         SV* const key = hv_iterkeysv(he);
 266         if(!hv_exists_ent(attr_map, key, 0U)){
 267             sv_catpvf(unknown, "%"SVf", ", key);
 268         }
 269     }
 270
 271     if(SvCUR(unknown) > 0){
 272         SvCUR(unknown) -= 2; /* chop "," */
 273     }
 274     else{
 275         sv_setpvs(unknown, "(unknown)");
 276     }
 277
 278     mouse_throw_error(meta, NULL,
 279         "Unknown attribute passed to the constructor of %"SVf": %"SVf,
 280         mcall0(meta, mouse_name), unknown);
 281 }
 282
 283
 284
 285 static void
 286 mouse_class_initialize_object(pTHX_ SV* const meta, SV* const object, HV* const args, bool const is_cloning) {
 287     AV* const xc    = mouse_get_xc(aTHX_ meta);
 288     AV* const attrs = MOUSE_xc_attrall(xc);
 289     I32 const len   = AvFILLp(attrs) + 1;
 290     I32 i;
 291     AV* triggers_queue = NULL;
 292     I32 used = 0;
 293
 294     assert(meta || object);
 295     assert(args);
 296     assert(SvTYPE(args) == SVt_PVHV);
 297
 298     if(mg_find((SV*)args, PERL_MAGIC_tied)){
 299         croak("You cannot use tied HASH reference as initializing arguments");
 300     }
 301
 302     /* for each attribute */
 303     for(i = 0; i < len; i++){
 304         SV* const attr = MOUSE_av_at(attrs, i);
 305         AV* const xa   = mouse_get_xa(aTHX_ attr);
 306
 307         SV* const slot     = MOUSE_xa_slot(xa);
 308         U16 const flags    = (U16)MOUSE_xa_flags(xa);
 309         SV* const init_arg = MOUSE_xa_init_arg(xa);
 310         HE* he;
 311
 312         if(SvOK(init_arg) && ( he = hv_fetch_ent(args, init_arg, FALSE, 0U) ) ){
 313             SV* value = HeVAL(he);
 314             if(flags & MOUSEf_ATTR_HAS_TC){
 315                 value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags);
 316             }
 317             value = set_slot(object, slot, value);
 318             if(flags & MOUSEf_ATTR_IS_WEAK_REF && SvROK(value)){
 319                 weaken_slot(object, slot);
 320             }
 321             if(flags & MOUSEf_ATTR_HAS_TRIGGER){
 322                 AV* const pair = newAV();
 323                 av_push(pair, newSVsv( mcall0s(attr, "trigger") ));
 324                 av_push(pair, newSVsv(value));
 325
 326                 if(!triggers_queue) {
 327                     triggers_queue = newAV_mortal();
 328                 }
 329                 av_push(triggers_queue, (SV*)pair);
 330             }
 331             used++;
 332         }
 333         else { /* no init arg */
 334             if(flags & (MOUSEf_ATTR_HAS_DEFAULT | MOUSEf_ATTR_HAS_BUILDER)){
 335                 /* skip if the object has the slot (it occurs on cloning/reblessing) */
 336                 if(!(flags & MOUSEf_ATTR_IS_LAZY) && !has_slot(object, slot)){
 337                     mouse_xa_set_default(aTHX_ xa, object);
 338                 }
 339             }
 340             else if(is_cloning) {
 341                 if(flags & MOUSEf_ATTR_IS_WEAK_REF){
 342                     SV* const value = get_slot(object, slot);
 343                     if(SvROK(value)) {
 344                         weaken_slot(object, slot);
 345                     }
 346                 }
 347             }
 348             /* don't check "required" while cloning (or reblesseing) */
 349             else if(flags & MOUSEf_ATTR_IS_REQUIRED) {
 350                 mouse_throw_error(attr, NULL, "Attribute (%"SVf") is required", slot);
 351             }
 352         }
 353     } /* for each attribute */
 354
 355     if(MOUSE_xc_flags(xc) & MOUSEf_XC_CONSTRUCTOR_IS_STRICT
 356             && used < (I32)HvUSEDKEYS(args)){
 357         mouse_report_unknown_args(aTHX_ meta, attrs, args);
 358     }
 359
 360     if(triggers_queue){
 361         I32 const len = AvFILLp(triggers_queue) + 1;
 362         for(i = 0; i < len; i++){
 363             AV* const pair    = (AV*)AvARRAY(triggers_queue)[i];
 364             SV* const trigger = AvARRAY(pair)[0];
 365             SV* const value   = AvARRAY(pair)[1];
 366
 367             mcall1(object, trigger, value);
 368         }
 369     }
 370
 371     if(MOUSE_xc_flags(xc) & MOUSEf_XC_IS_ANON){
 372         (void)set_slot(object, newSVpvs_flags("__METACLASS__", SVs_TEMP), meta);
 373     }
 374 }
 375
 376 STATIC_INLINE SV*
 377 mouse_initialize_metaclass(pTHX_ SV* const klass) {
 378     SV* const meta = get_metaclass(klass);
 379     if(LIKELY(SvOK(meta))){
 380         return meta;
 381     }
 382     return mcall1s(newSVpvs_flags("Mouse::Meta::Class", SVs_TEMP),
 383             "initialize", klass);
 384 }
 385
 386 static void
 387 mouse_buildall(pTHX_ AV* const xc, SV* const object, SV* const args) {
 388     AV* const buildall = MOUSE_xc_buildall(xc);
 389     I32 const len      = AvFILLp(buildall) + 1;
 390     I32 i;
 391     for(i = 0; i < len; i++){
 392         dSP;
 393
 394         PUSHMARK(SP);
 395         EXTEND(SP, 2);
 396         PUSHs(object);
 397         PUSHs(args);
 398         PUTBACK;
 399
 400         call_sv_safe(AvARRAY(buildall)[i], G_VOID);
 401
 402         /* discard a scalar which G_VOID returns */
 403         SPAGAIN;
 404         (void)POPs;
 405         PUTBACK;
 406     }
 407 }
 408
 409 static AV*
 410 mouse_get_modifier_storage(pTHX_
 411         SV* const meta,
 412         enum mouse_modifier_t const m, SV* const name) {
 413     static const char* const keys[] = {
 414         "before",
 415         "around",
 416         "after",
 417     };
 418     SV* const key = sv_2mortal(Perl_newSVpvf(aTHX_ "%s_method_modifiers", keys[m]));
 419     SV* table;
 420     SV* storage_ref;
 421
 422     must_defined(name, "a method name");
 423
 424     table = get_slot(meta, key);
 425
 426     if(!table){
 427         /* $meta->{$key} = {} */
 428         table = sv_2mortal(newRV_noinc((SV*)newHV()));
 429         set_slot(meta, key, table);
 430     }
 431
 432     storage_ref = get_slot(table, name);
 433
 434     if(!storage_ref){
 435         storage_ref = sv_2mortal(newRV_noinc((SV*)newAV()));
 436         set_slot(table, name, storage_ref);
 437     }
 438     else{
 439         if(!IsArrayRef(storage_ref)){
 440             croak("Modifier strorage for '%s' is not an ARRAY reference", keys[m]);
 441         }
 442     }
 443
 444     return (AV*)SvRV(storage_ref);
 445 }
 446
 447 static
 448 XSPROTO(XS_Mouse_value_holder) {
 449     dVAR; dXSARGS;
 450     SV* const value = (SV*)XSANY.any_ptr;
 451     assert(value);
 452     PERL_UNUSED_VAR(items);
 453     ST(0) = value;
 454     XSRETURN(1);
 455 }
 456
 457 DECL_BOOT(Mouse__Util);
 458 DECL_BOOT(Mouse__Util__TypeConstraints);
 459 DECL_BOOT(Mouse__Meta__Method__Accessor__XS);
 460 DECL_BOOT(Mouse__Meta__Attribute);
 461
 462 MODULE = Mouse  PACKAGE = Mouse
 463
 464 PROTOTYPES: DISABLE
 465
 466 BOOT:
 467 {
 468     mouse_package   = newSVpvs_share("package");
 469     mouse_namespace = newSVpvs_share("namespace");
 470     mouse_methods   = newSVpvs_share("methods");
 471     mouse_name      = newSVpvs_share("name");
 472     mouse_coerce    = newSVpvs_share("coerce");
 473
 474     mouse_get_attribute      = newSVpvs_share("get_attribute");
 475     mouse_get_attribute_list = newSVpvs_share("get_attribute_list");
 476
 477     CALL_BOOT(Mouse__Util);
 478     CALL_BOOT(Mouse__Util__TypeConstraints);
 479     CALL_BOOT(Mouse__Meta__Method__Accessor__XS);
 480     CALL_BOOT(Mouse__Meta__Attribute);
 481 }
 482
 483 MODULE = Mouse  PACKAGE = Mouse::Meta::Module
 484
 485 BOOT:
 486     INSTALL_SIMPLE_READER_WITH_KEY(Module, name, package);
 487     INSTALL_SIMPLE_READER_WITH_KEY(Module, _method_map, methods);
 488     INSTALL_SIMPLE_READER_WITH_KEY(Module, _attribute_map, attributes);
 489
 490 HV*
 491 namespace(SV* self)
 492 CODE:
 493 {
 494     RETVAL = mouse_get_namespace(aTHX_ self);
 495 }
 496 OUTPUT:
 497     RETVAL
 498
 499 # ignore extra arguments for extensibility
 500 void
 501 add_method(SV* self, SV* name, SV* code, ...)
 502 CODE:
 503 {
 504     SV* const package = get_slot(self, mouse_package); /* $self->{package} */
 505     SV* const methods = get_slot(self, mouse_methods); /* $self->{methods} */
 506     GV* gv;
 507     SV* code_ref;
 508
 509     if(!(package && SvOK(package))){
 510         croak("No package name defined");
 511     }
 512
 513     must_defined(name, "a method name");
 514     must_ref    (code, "a CODE reference", SVt_NULL); /* any reftype is OK */
 515
 516     code_ref = code;
 517     if(SvTYPE(SvRV(code_ref)) != SVt_PVCV){
 518         SV*  sv = code_ref;  /* used in tryAMAGICunDEREF */
 519         SV** sp = &sv;       /* used in tryAMAGICunDEREF */
 520         tryAMAGICunDEREF(to_cv); /* try \&{$code} */
 521         must_ref(code, "a CODE reference", SVt_PVCV);
 522         code_ref = sv;
 523     }
 524
 525     /*  *{$package . '::' . $name} -> *gv */
 526     gv = gv_fetchpv(form("%"SVf"::%"SVf, package, name), GV_ADDMULTI, SVt_PVCV);
 527     mouse_install_sub(aTHX_ gv, code_ref);
 528     /* CvMETHOD_on((CV*)SvRV(code_ref)); */
 529     (void)set_slot(methods, name, code); /* $self->{methods}{$name} = $code */
 530 }
 531
 532 MODULE = Mouse  PACKAGE = Mouse::Meta::Class
 533
 534 BOOT:
 535 {
 536     CV* xsub;
 537
 538     INSTALL_SIMPLE_READER(Class, roles);
 539     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Class, is_anon_class, anon_serial_id);
 540     INSTALL_SIMPLE_READER(Class, is_immutable);
 541
 542     INSTALL_INHERITABLE_CLASS_ACCESSOR(strict_constructor);
 543
 544     INSTALL_CLASS_HOLDER(Class, method_metaclass,     "Mouse::Meta::Method");
 545     INSTALL_CLASS_HOLDER(Class, attribute_metaclass,  "Mouse::Meta::Attribute");
 546     INSTALL_CLASS_HOLDER(Class, constructor_class,    "Mouse::Meta::Method::Constructor::XS");
 547     INSTALL_CLASS_HOLDER(Class, destructor_class,     "Mouse::Meta::Method::Destructor::XS");
 548
 549     xsub = newXS("Mouse::Meta::Method::Constructor::XS::_generate_constructor",
 550         XS_Mouse_value_holder, file);
 551     CvXSUBANY(xsub).any_ptr
 552         = newRV_inc((SV*)get_cvs("Mouse::Object::new", GV_ADD));
 553
 554     xsub = newXS("Mouse::Meta::Method::Destructor::XS::_generate_destructor",
 555         XS_Mouse_value_holder, file);
 556     CvXSUBANY(xsub).any_ptr
 557         = newRV_inc((SV*)get_cvs("Mouse::Object::DESTROY", GV_ADD));
 558 }
 559
 560
 561 void
 562 linearized_isa(SV* self)
 563 PPCODE:
 564 {
 565     /* MOUSE_xc_stash() is not available because the xc system depends on
 566        linearized_isa() */
 567     HV* const stash          = mouse_get_namespace(aTHX_ self);
 568     AV* const linearized_isa = mro_get_linear_isa(stash);
 569     I32 const            len = AvFILLp(linearized_isa) + 1;
 570     I32 i;
 571     EXTEND(SP, len);
 572     for(i = 0; i < len; i++){
 573         PUSHs(AvARRAY(linearized_isa)[i]);
 574     }
 575 }
 576
 577 void
 578 get_all_attributes(SV* self)
 579 PPCODE:
 580 {
 581     AV* const xc        = mouse_get_xc(aTHX_ self);
 582     AV* const all_attrs = MOUSE_xc_attrall(xc);
 583     I32 const len       = AvFILLp(all_attrs) + 1;
 584     I32 i;
 585
 586     EXTEND(SP, len);
 587     for(i = 0; i < len; i++){
 588         PUSHs( MOUSE_av_at(all_attrs, i) );
 589     }
 590 }
 591
 592 void
 593 new_object(SV* meta, ...)
 594 CODE:
 595 {
 596     AV* const xc   = mouse_get_xc(aTHX_ meta);
 597     HV* const args = mouse_buildargs(aTHX_ meta, NULL, ax, items);
 598     SV* object;
 599
 600     object = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc));
 601     mouse_class_initialize_object(aTHX_ meta, object, args, FALSE);
 602     mouse_buildall(aTHX_ xc, object, sv_2mortal(newRV_inc((SV*)args)));
 603     ST(0) = object; /* because object is mortal, we should return it as is */
 604     XSRETURN(1);
 605 }
 606
 607 void
 608 clone_object(SV* meta, SV* object, ...)
 609 CODE:
 610 {
 611     AV* const xc   = mouse_get_xc(aTHX_ meta);
 612     HV* const args = mouse_buildargs(aTHX_ meta, NULL, ax + 1, items - 1);
 613     SV* proto;
 614
 615     if(!mouse_is_an_instance_of(aTHX_ MOUSE_xc_stash(xc), object)) {
 616         mouse_throw_error(meta, object,
 617             "You must pass an instance of the metaclass (%"SVf"), not (%"SVf")",
 618             mcall0(meta, mouse_name), object);
 619     }
 620
 621     proto = mouse_instance_clone(aTHX_ object);
 622     mouse_class_initialize_object(aTHX_ meta, proto, args, TRUE);
 623     ST(0) = proto; /* because object is mortal, we should return it as is */
 624     XSRETURN(1);
 625 }
 626
 627 void
 628 _initialize_object(SV* meta, SV* object, HV* args, bool is_cloning = FALSE)
 629 CODE:
 630 {
 631     mouse_class_initialize_object(aTHX_ meta, object, args, is_cloning);
 632 }
 633
 634 void
 635 _invalidate_metaclass_cache(SV* meta)
 636 CODE:
 637 {
 638     AV* const xc = mouse_get_xc_if_fresh(aTHX_ meta);
 639     if(xc) {
 640         SV* const gen = MOUSE_xc_gen(xc);
 641         sv_setuv(gen, 0U);
 642     }
 643     delete_slot(meta, newSVpvs_flags("_mouse_cache_", SVs_TEMP));
 644 }
 645
 646
 647 MODULE = Mouse  PACKAGE = Mouse::Meta::Role
 648
 649 BOOT:
 650     INSTALL_SIMPLE_READER_WITH_KEY(Role, get_roles, roles);
 651     INSTALL_SIMPLE_PREDICATE_WITH_KEY(Role, is_anon_role, anon_serial_id);
 652
 653     INSTALL_CLASS_HOLDER(Role, method_metaclass,  "Mouse::Meta::Role::Method");
 654
 655 void
 656 add_before_modifier(SV* self, SV* name, SV* modifier)
 657 CODE:
 658 {
 659     av_push(mouse_get_modifier_storage(aTHX_ self, (enum mouse_modifier_t)ix, name), newSVsv(modifier));
 660 }
 661 ALIAS:
 662     add_before_method_modifier = MOUSE_M_BEFORE
 663     add_around_method_modifier = MOUSE_M_AROUND
 664     add_after_method_modifier  = MOUSE_M_AFTER
 665
 666 void
 667 get_before_modifiers(SV* self, SV* name)
 668 ALIAS:
 669     get_before_method_modifiers = MOUSE_M_BEFORE
 670     get_around_method_modifiers = MOUSE_M_AROUND
 671     get_after_method_modifiers  = MOUSE_M_AFTER
 672 PPCODE:
 673 {
 674     AV* const storage = mouse_get_modifier_storage(aTHX_ self,
 675                             (enum mouse_modifier_t)ix, name);
 676     I32 const len     = av_len(storage) + 1;
 677     if(GIMME_V == G_ARRAY) {
 678         I32 i;
 679         EXTEND(SP, len);
 680         for(i = 0; i < len; i++){
 681             PUSHs(*av_fetch(storage, i, TRUE));
 682         }
 683     }
 684     else{
 685         mPUSHi(len);
 686     }
 687 }
 688
 689 void
 690 add_metaclass_accessor(SV* self, SV* name)
 691 CODE:
 692 {
 693     SV* const klass = mcall0(self, mouse_name);
 694     const char* fq_name = form("%"SVf"::%"SVf, klass, name);
 695     STRLEN keylen;
 696     const char* const key = SvPV_const(name, keylen);
 697     mouse_simple_accessor_generate(aTHX_ fq_name, key, keylen,
 698         XS_Mouse_inheritable_class_accessor, NULL, 0);
 699 }
 700
 701 MODULE = Mouse  PACKAGE = Mouse::Object
 702
 703 void
 704 new(SV* klass, ...)
 705 CODE:
 706 {
 707     SV* const meta = mouse_initialize_metaclass(aTHX_ klass);
 708     AV* const xc   = mouse_get_xc(aTHX_ meta);
 709     UV const flags = MOUSE_xc_flags(xc);
 710     SV* args;
 711     SV* object;
 712
 713     /* BUILDARGS */
 714     if(flags & MOUSEf_XC_HAS_BUILDARGS){
 715         I32 i;
 716         SPAGAIN;
 717
 718         PUSHMARK(SP);
 719         EXTEND(SP, items);
 720         for(i = 0; i < items; i++){
 721             PUSHs(ST(i));
 722         }
 723
 724         PUTBACK;
 725         call_method_safes("BUILDARGS", G_SCALAR);
 726
 727         SPAGAIN;
 728         args = POPs;
 729         PUTBACK;
 730
 731         if(!IsHashRef(args)){
 732             croak("BUILDARGS did not return a HASH reference");
 733         }
 734     }
 735     else{
 736         args = newRV_inc((SV*)mouse_buildargs(aTHX_ meta, klass, ax, items));
 737         sv_2mortal(args);
 738     }
 739
 740     /* new_object */
 741     object = mouse_instance_create(aTHX_ MOUSE_xc_stash(xc));
 742     mouse_class_initialize_object(aTHX_ meta, object, (HV*)SvRV(args), FALSE);
 743     /* BUILDALL */
 744     mouse_buildall(aTHX_ xc, object, args);
 745     ST(0) = object; /* because object is mortal, we should return it as is */
 746     XSRETURN(1);
 747 }
 748
 749 void
 750 DESTROY(SV* object)
 751 ALIAS:
 752     DESTROY     = 0
 753     DEMOLISHALL = 1
 754 CODE:
 755 {
 756     SV* const meta = get_metaclass(object);
 757     AV* xc;
 758     AV* demolishall;
 759     I32 len;
 760     I32 i;
 761
 762     if(!IsObject(object)){
 763         croak("You must not call %s as a class method",
 764             ix == 0 ? "DESTROY" : "DEMOLISHALL");
 765     }
 766
 767     if(SvOK(meta) && (xc = mouse_get_xc_if_fresh(aTHX_ meta))) {
 768         demolishall = MOUSE_xc_demolishall(xc);
 769     }
 770     else { /* The metaclass is already destroyed */
 771         AV* const linearized_isa = mro_get_linear_isa(SvSTASH(SvRV(object)));
 772
 773         len = AvFILLp(linearized_isa) + 1;
 774
 775         demolishall = newAV_mortal();
 776         for(i = 0; i < len; i++){
 777             SV* const klass = MOUSE_av_at(linearized_isa, i);
 778             HV* const st    = gv_stashsv(klass, TRUE);
 779             GV* const gv    = stash_fetchs(st, "DEMOLISH", FALSE);
 780             if(gv && GvCVu(gv)){
 781                 av_push(demolishall, newRV_inc((SV*)GvCV(gv)));
 782             }
 783         }
 784     }
 785
 786     len  = AvFILLp(demolishall) + 1;
 787     if(len > 0){
 788         SV* const in_global_destruction = boolSV(PL_dirty);
 789         SAVEI32(PL_statusvalue); /* local $? */
 790         PL_statusvalue = 0;
 791
 792         SAVESPTR(ERRSV); /* local $@ */
 793         ERRSV = sv_newmortal();
 794
 795         EXTEND(SP, 2);
 796
 797         for(i = 0; i < len; i++){
 798             SPAGAIN;
 799
 800             PUSHMARK(SP);
 801             PUSHs(object);
 802             PUSHs(in_global_destruction);
 803             PUTBACK;
 804
 805             call_sv(AvARRAY(demolishall)[i], G_VOID | G_EVAL);
 806
 807             /* discard a scalar which G_VOID returns */
 808             SPAGAIN;
 809             (void)POPs;
 810             PUTBACK;
 811
 812             if(sv_true(ERRSV)){
 813                 SV* const e = newSVsv(ERRSV);
 814
 815                 FREETMPS;
 816                 LEAVE;
 817
 818                 sv_setsv(ERRSV, e);
 819                 SvREFCNT_dec(e);
 820                 croak(NULL); /* rethrow */
 821             }
 822         }
 823     }
 824 }
 825
 826 HV*
 827 BUILDARGS(SV* klass, ...)
 828 CODE:
 829 {
 830     RETVAL = mouse_buildargs(aTHX_ NULL, klass, ax, items);
 831 }
 832 OUTPUT:
 833     RETVAL
 834
 835
 836 void
 837 BUILDALL(SV* self, SV* args)
 838 CODE:
 839 {
 840     SV* const meta = get_metaclass(self);
 841     AV* const xc   = mouse_get_xc(aTHX_ meta);
 842
 843     must_ref(args, "a HASH reference to BUILDALL", SVt_PVHV);
 844     mouse_buildall(aTHX_ xc, self, args);
 845 }