xs-src/MouseAccessor.xs

   1 #include "mouse.h"
   2
   3 #define CHECK_INSTANCE(instance) STMT_START{                           \
   4         assert(instance);                                              \
   5         if(!(SvROK(instance) && SvTYPE(SvRV(instance)) == SVt_PVHV)){  \
   6             croak("Invalid object instance: '%"SVf"'", instance);      \
   7         }                                                              \
   8     } STMT_END
   9
  10
  11 #define MOUSE_mg_attribute(mg) MOUSE_xa_attribute(MOUSE_mg_xa(mg))
  12
  13 static MGVTBL mouse_accessor_vtbl; /* MAGIC identity */
  14
  15 #define dMOUSE_self  SV* const self = mouse_accessor_get_self(aTHX_ ax, items, cv)
  16
  17 STATIC_INLINE SV*
  18 mouse_accessor_get_self(pTHX_ I32 const ax, I32 const items, CV* const cv) {
  19     if(items < 1){
  20         croak("Too few arguments for %s", GvNAME(CvGV(cv)));
  21     }
  22
  23     /* NOTE: If self has GETMAGIC, $self->accessor will invoke GETMAGIC
  24      *       before calling methods, so SvGETMAGIC(self) is not necessarily needed here.
  25      */
  26
  27     return ST(0);
  28 }
  29
  30
  31 CV*
  32 mouse_accessor_generate(pTHX_ SV* const attr, XSUBADDR_t const accessor_impl){
  33     AV* const xa = mouse_get_xa(aTHX_ attr);
  34     CV* xsub;
  35     MAGIC* mg;
  36
  37     xsub = newXS(NULL, accessor_impl, __FILE__);
  38     sv_2mortal((SV*)xsub);
  39
  40     mg = sv_magicext((SV*)xsub, MOUSE_xa_slot(xa),
  41         PERL_MAGIC_ext, &mouse_accessor_vtbl, (char*)xa, HEf_SVKEY);
  42
  43     MOUSE_mg_flags(mg) = (U16)MOUSE_xa_flags(xa);
  44
  45     /* NOTE:
  46      * although we use MAGIC for gc, we also store mg to
  47      * CvXSUBANY for efficiency (gfx)
  48      */
  49     CvXSUBANY(xsub).any_ptr = (void*)mg;
  50
  51     return xsub;
  52 }
  53
  54
  55 #define PUSH_VALUE(value, flags) STMT_START { \
  56         if((flags) & MOUSEf_ATTR_SHOULD_AUTO_DEREF && GIMME_V == G_ARRAY){ \
  57             mouse_push_values(aTHX_ value, (flags));                       \
  58         }                                                                  \
  59         else{                                                              \
  60             dSP;                                                           \
  61             XPUSHs(value ? value : &PL_sv_undef);                          \
  62             PUTBACK;                                                       \
  63         }                                                                  \
  64     } STMT_END                                                             \
  65
  66 /* pushes return values, does auto-deref if needed */
  67 static void
  68 mouse_push_values(pTHX_ SV* const value, U16 const flags){
  69     dSP;
  70
  71     assert( flags & MOUSEf_ATTR_SHOULD_AUTO_DEREF && GIMME_V == G_ARRAY );
  72
  73     if(!(value && SvOK(value))){
  74         return;
  75     }
  76
  77     if(flags & MOUSEf_TC_IS_ARRAYREF){
  78         AV* av;
  79         I32 len;
  80         I32 i;
  81
  82         if(!IsArrayRef(value)){
  83             croak("Mouse-panic: Not an ARRAY reference");
  84         }
  85
  86         av  = (AV*)SvRV(value);
  87         len = av_len(av) + 1;
  88         EXTEND(SP, len);
  89         for(i = 0; i < len; i++){
  90             SV** const svp = av_fetch(av, i, FALSE);
  91             PUSHs(svp ? *svp : &PL_sv_undef);
  92         }
  93     }
  94     else{
  95         HV* hv;
  96         HE* he;
  97
  98         assert(flags & MOUSEf_TC_IS_HASHREF);
  99
 100         if(!IsHashRef(value)){
 101             croak("Mouse-panic: Not a HASH reference");
 102         }
 103
 104         hv = (HV*)SvRV(value);
 105         hv_iterinit(hv);
 106         while((he = hv_iternext(hv))){
 107             EXTEND(SP, 2);
 108             PUSHs(hv_iterkeysv(he));
 109             PUSHs(hv_iterval(hv, he));
 110         }
 111     }
 112
 113     PUTBACK;
 114 }
 115
 116 static void
 117 mouse_attr_get(pTHX_ SV* const self, MAGIC* const mg){
 118     U16 const flags = MOUSE_mg_flags(mg);
 119     SV* value;
 120
 121     value = get_slot(self, MOUSE_mg_slot(mg));
 122
 123     /* check_lazy */
 124     if( !value && flags & MOUSEf_ATTR_IS_LAZY ){
 125         value = mouse_xa_set_default(aTHX_ MOUSE_mg_xa(mg), self);
 126     }
 127
 128     PUSH_VALUE(value, flags);
 129 }
 130
 131 static void
 132 mouse_attr_set(pTHX_ SV* const self, MAGIC* const mg, SV* value){
 133     U16 const flags = MOUSE_mg_flags(mg);
 134     SV* const slot  = MOUSE_mg_slot(mg);
 135
 136     if(flags & MOUSEf_ATTR_HAS_TC){
 137         value = mouse_xa_apply_type_constraint(aTHX_ MOUSE_mg_xa(mg), value, flags);
 138     }
 139
 140     value = set_slot(self, slot, value);
 141
 142     if(flags & MOUSEf_ATTR_IS_WEAK_REF){
 143         weaken_slot(self, slot);
 144     }
 145
 146     if(flags & MOUSEf_ATTR_HAS_TRIGGER){
 147         SV* const trigger = mcall0s(MOUSE_mg_attribute(mg), "trigger");
 148         dSP;
 149
 150         /* NOTE: triggers can remove value, so
 151                  value must be copied here,
 152                  revealed by Net::Google::DataAPI (DANJOU).
 153          */
 154         value = sv_mortalcopy(value);
 155
 156         PUSHMARK(SP);
 157         EXTEND(SP, 2);
 158         PUSHs(self);
 159         PUSHs(value);
 160
 161         PUTBACK;
 162         call_sv_safe(trigger, G_VOID | G_DISCARD);
 163         /* need not SPAGAIN */
 164
 165         assert(SvTYPE(value) != SVTYPEMASK);
 166     }
 167
 168     PUSH_VALUE(value, flags);
 169 }
 170
 171 XS(XS_Mouse_accessor)
 172 {
 173     dVAR; dXSARGS;
 174     dMOUSE_self;
 175     MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
 176
 177     SP -= items; /* PPCODE */
 178     PUTBACK;
 179
 180     if(items == 1){ /* reader */
 181         mouse_attr_get(aTHX_ self, mg);
 182     }
 183     else if (items == 2){ /* writer */
 184         mouse_attr_set(aTHX_ self, mg, ST(1));
 185     }
 186     else{
 187         mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
 188             "Expected exactly one or two argument for an accessor of %"SVf,
 189             MOUSE_mg_slot(mg));
 190     }
 191 }
 192
 193
 194 XS(XS_Mouse_reader)
 195 {
 196     dVAR; dXSARGS;
 197     dMOUSE_self;
 198     MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
 199
 200     if (items != 1) {
 201         mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
 202             "Cannot assign a value to a read-only accessor of %"SVf,
 203             MOUSE_mg_slot(mg));
 204     }
 205
 206     SP -= items; /* PPCODE */
 207     PUTBACK;
 208
 209     mouse_attr_get(aTHX_ self, mg);
 210 }
 211
 212 XS(XS_Mouse_writer)
 213 {
 214     dVAR; dXSARGS;
 215     dMOUSE_self;
 216     MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
 217
 218     if (items != 2) {
 219         mouse_throw_error(MOUSE_mg_attribute(mg), NULL,
 220             "Too few arguments for a write-only accessor of %"SVf,
 221             MOUSE_mg_slot(mg));
 222     }
 223
 224     SP -= items; /* PPCODE */
 225     PUTBACK;
 226
 227     mouse_attr_set(aTHX_ self, mg, ST(1));
 228 }
 229
 230 /* simple accessors */
 231
 232 /*
 233 static MAGIC*
 234 mouse_accessor_get_mg(pTHX_ CV* const xsub){
 235     return moose_mg_find(aTHX_ (SV*)xsub, &mouse_simple_accessor_vtbl, MOOSEf_DIE_ON_FAIL);
 236 }
 237 */
 238
 239 CV*
 240 mouse_simple_accessor_generate(pTHX_
 241     const char* const fq_name, const char* const key, I32 const keylen,
 242     XSUBADDR_t const accessor_impl, void* const dptr, I32 const dlen) {
 243     CV* const xsub = newXS((char*)fq_name, accessor_impl, __FILE__);
 244     SV* const slot = newSVpvn_share(key, keylen, 0U);
 245     MAGIC* mg;
 246
 247     if(!fq_name){
 248         /* anonymous xsubs need sv_2mortal() */
 249         sv_2mortal((SV*)xsub);
 250     }
 251
 252     mg = sv_magicext((SV*)xsub, slot,
 253         PERL_MAGIC_ext, &mouse_accessor_vtbl, (char*)dptr, dlen);
 254
 255     SvREFCNT_dec(slot); /* sv_magicext() increases refcnt in mg_obj */
 256     if(dlen == HEf_SVKEY){
 257         SvREFCNT_dec(dptr);
 258     }
 259
 260     /* NOTE:
 261      * although we use MAGIC for gc, we also store mg to CvXSUBANY
 262      * for efficiency (gfx)
 263      */
 264     CvXSUBANY(xsub).any_ptr = (void*)mg;
 265
 266     return xsub;
 267 }
 268
 269 XS(XS_Mouse_simple_reader)
 270 {
 271     dVAR; dXSARGS;
 272     dMOUSE_self;
 273     MAGIC* const mg = (MAGIC*)XSANY.any_ptr;
 274     SV* value;
 275
 276     if (items != 1) {
 277         croak("Expected exactly one argument for a reader of %"SVf,
 278             MOUSE_mg_slot(mg));
 279     }
 280
 281     value = get_slot(self, MOUSE_mg_slot(mg));
 282     if(!value) {
 283         if(MOUSE_mg_ptr(mg)){
 284             /* the default value must be a SV */
 285             assert(MOUSE_mg_len(mg) == HEf_SVKEY);
 286             value = (SV*)MOUSE_mg_ptr(mg);
 287         }
 288         else{
 289             value = &PL_sv_undef;
 290         }
 291     }
 292
 293     ST(0) = value;
 294     XSRETURN(1);
 295 }
 296
 297
 298 XS(XS_Mouse_simple_writer)
 299 {
 300     dVAR; dXSARGS;
 301     dMOUSE_self;
 302     SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
 303
 304     if (items != 2) {
 305         croak("Expected exactly two argument for a writer of %"SVf,
 306             slot);
 307     }
 308
 309     ST(0) = set_slot(self, slot, ST(1));
 310     XSRETURN(1);
 311 }
 312
 313 XS(XS_Mouse_simple_clearer)
 314 {
 315     dVAR; dXSARGS;
 316     dMOUSE_self;
 317     SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
 318     SV* value;
 319
 320     if (items != 1) {
 321         croak("Expected exactly one argument for a clearer of %"SVf,
 322             slot);
 323     }
 324
 325     value = delete_slot(self, slot);
 326     ST(0) = value ? value : &PL_sv_undef;
 327     XSRETURN(1);
 328 }
 329
 330 XS(XS_Mouse_simple_predicate)
 331 {
 332     dVAR; dXSARGS;
 333     dMOUSE_self;
 334     SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
 335
 336     if (items != 1) {
 337         croak("Expected exactly one argument for a predicate of %"SVf, slot);
 338     }
 339
 340     ST(0) = boolSV( has_slot(self, slot) );
 341     XSRETURN(1);
 342 }
 343
 344 /* Class::Data::Inheritable-like class accessor */
 345 XS(XS_Mouse_inheritable_class_accessor) {
 346     dVAR; dXSARGS;
 347     dMOUSE_self;
 348     SV* const slot = MOUSE_mg_slot((MAGIC*)XSANY.any_ptr);
 349     SV* value;
 350     HV* stash;
 351
 352     if(items == 1){ /* reader */
 353         value = NULL;
 354     }
 355     else if (items == 2){ /* writer */
 356         value = ST(1);
 357     }
 358     else{
 359         croak("Expected exactly one or two argument for a class data accessor"
 360             "of %"SVf, slot);
 361         value = NULL; /* -Wuninitialized */
 362     }
 363
 364     stash = mouse_get_namespace(aTHX_ self);
 365
 366     if(!value) { /* reader */
 367         value = get_slot(self, slot);
 368         if(!value) {
 369             AV* const isa   = mro_get_linear_isa(stash);
 370             I32 const len   = av_len(isa) + 1;
 371             I32 i;
 372             for(i = 1; i < len; i++) {
 373                 SV* const klass = MOUSE_av_at(isa, i);
 374                 SV* const meta  = get_metaclass(klass);
 375                 if(!SvOK(meta)){
 376                     continue; /* skip non-Mouse classes */
 377                 }
 378                 value = get_slot(meta, slot);
 379                 if(value) {
 380                     break;
 381                 }
 382             }
 383             if(!value) {
 384                 value = &PL_sv_undef;
 385             }
 386         }
 387     }
 388     else { /* writer */
 389         set_slot(self, slot, value);
 390         mro_method_changed_in(stash);
 391     }
 392
 393     ST(0) = value;
 394     XSRETURN(1);
 395 }
 396
 397 /* simple instance slot accessor (or Mouse::Meta::Instance) */
 398
 399 SV*
 400 mouse_instance_create(pTHX_ HV* const stash) {
 401     SV* instance;
 402     assert(stash);
 403     assert(SvTYPE(stash) == SVt_PVHV);
 404     instance = sv_bless( newRV_noinc((SV*)newHV()), stash );
 405     return sv_2mortal(instance);
 406 }
 407
 408 SV*
 409 mouse_instance_clone(pTHX_ SV* const instance) {
 410     SV* proto;
 411     CHECK_INSTANCE(instance);
 412     assert(SvOBJECT(SvRV(instance)));
 413
 414     proto = newRV_noinc((SV*)newHVhv((HV*)SvRV(instance)));
 415     sv_bless(proto, SvSTASH(SvRV(instance)));
 416     return sv_2mortal(proto);
 417 }
 418
 419 bool
 420 mouse_instance_has_slot(pTHX_ SV* const instance, SV* const slot) {
 421     assert(slot);
 422     CHECK_INSTANCE(instance);
 423     return hv_exists_ent((HV*)SvRV(instance), slot, 0U);
 424 }
 425
 426 SV*
 427 mouse_instance_get_slot(pTHX_ SV* const instance, SV* const slot) {
 428     HE* he;
 429     assert(slot);
 430     CHECK_INSTANCE(instance);
 431     he = hv_fetch_ent((HV*)SvRV(instance), slot, FALSE, 0U);
 432     return he ? HeVAL(he) : NULL;
 433 }
 434
 435 SV*
 436 mouse_instance_set_slot(pTHX_ SV* const instance, SV* const slot, SV* const value) {
 437     HE* he;
 438     SV* sv;
 439     assert(slot);
 440     assert(value);
 441     CHECK_INSTANCE(instance);
 442     he = hv_fetch_ent((HV*)SvRV(instance), slot, TRUE, 0U);
 443     sv = HeVAL(he);
 444     sv_setsv(sv, value);
 445     SvSETMAGIC(sv);
 446     return sv;
 447 }
 448
 449 SV*
 450 mouse_instance_delete_slot(pTHX_ SV* const instance, SV* const slot) {
 451     assert(instance);
 452     assert(slot);
 453     CHECK_INSTANCE(instance);
 454     return hv_delete_ent((HV*)SvRV(instance), slot, 0, 0U);
 455 }
 456
 457 void
 458 mouse_instance_weaken_slot(pTHX_ SV* const instance, SV* const slot) {
 459     HE* he;
 460     assert(slot);
 461     CHECK_INSTANCE(instance);
 462     he = hv_fetch_ent((HV*)SvRV(instance), slot, FALSE, 0U);
 463     if(he){
 464         sv_rvweaken(HeVAL(he));
 465     }
 466 }
 467
 468 MODULE = Mouse::Meta::Method::Accessor::XS  PACKAGE = Mouse::Meta::Method::Accessor::XS
 469
 470 PROTOTYPES:   DISABLE
 471 VERSIONCHECK: DISABLE
 472
 473 CV*
 474 _generate_accessor(klass, SV* attr, metaclass)
 475 CODE:
 476 {
 477     RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_accessor);
 478 }
 479 OUTPUT:
 480     RETVAL
 481
 482 CV*
 483 _generate_reader(klass, SV* attr, metaclass)
 484 CODE:
 485 {
 486     RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_reader);
 487 }
 488 OUTPUT:
 489     RETVAL
 490
 491 CV*
 492 _generate_writer(klass, SV* attr, metaclass)
 493 CODE:
 494 {
 495     RETVAL = mouse_accessor_generate(aTHX_ attr, XS_Mouse_writer);
 496 }
 497 OUTPUT:
 498     RETVAL
 499
 500 CV*
 501 _generate_clearer(klass, SV* attr, metaclass)
 502 CODE:
 503 {
 504     SV* const slot = mcall0(attr, mouse_name);
 505     STRLEN len;
 506     const char* const pv = SvPV_const(slot, len);
 507     RETVAL = mouse_simple_accessor_generate(aTHX_ NULL, pv, len, XS_Mouse_simple_clearer, NULL, 0);
 508 }
 509 OUTPUT:
 510     RETVAL
 511
 512 CV*
 513 _generate_predicate(klass, SV* attr, metaclass)
 514 CODE:
 515 {
 516     SV* const slot = mcall0(attr, mouse_name);
 517     STRLEN len;
 518     const char* const pv = SvPV_const(slot, len);
 519     RETVAL = mouse_simple_accessor_generate(aTHX_ NULL, pv, len, XS_Mouse_simple_predicate, NULL, 0);
 520 }
 521 OUTPUT:
 522     RETVAL
 523