xs-src/MouseAccessor.xs

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