Commit | Line | Data |
aa2d2e2c |
1 | #include "mouse.h" |
2 | |
c6b8ac47 |
3 | static MGVTBL mouse_xa_vtbl; /* identity */ |
0aad0266 |
4 | |
c6b8ac47 |
5 | static AV* |
6 | mouse_build_xa(pTHX_ SV* const attr) { |
7 | AV* xa; |
0aad0266 |
8 | MAGIC* mg; |
9 | |
c6b8ac47 |
10 | SV* slot; |
11 | STRLEN len; |
12 | const char* pv; |
13 | U16 flags = 0x00; |
0aad0266 |
14 | |
c6b8ac47 |
15 | ENTER; |
16 | SAVETMPS; |
0aad0266 |
17 | |
bc97157e |
18 | xa = newAV(); |
0aad0266 |
19 | |
c6b8ac47 |
20 | mg = sv_magicext(SvRV(attr), (SV*)xa, PERL_MAGIC_ext, &mouse_xa_vtbl, NULL, 0); |
21 | SvREFCNT_dec(xa); /* refcnt++ in sv_magicext */ |
0aad0266 |
22 | |
c6b8ac47 |
23 | av_extend(xa, MOUSE_XA_last - 1); |
0aad0266 |
24 | |
c6b8ac47 |
25 | slot = mcall0(attr, mouse_name); |
26 | pv = SvPV_const(slot, len); |
27 | av_store(xa, MOUSE_XA_SLOT, newSVpvn_share(pv, len, 0U)); |
0aad0266 |
28 | |
c6b8ac47 |
29 | av_store(xa, MOUSE_XA_ATTRIBUTE, newSVsv(attr)); |
0aad0266 |
30 | |
c6b8ac47 |
31 | av_store(xa, MOUSE_XA_INIT_ARG, newSVsv(mcall0s(attr, "init_arg"))); |
4e7e3250 |
32 | |
c6b8ac47 |
33 | if(predicate_calls(attr, "has_type_constraint")){ |
34 | SV* tc; |
35 | flags |= MOUSEf_ATTR_HAS_TC; |
0aad0266 |
36 | |
c6b8ac47 |
37 | tc = mcall0s(attr, "type_constraint"); |
38 | av_store(xa, MOUSE_XA_TC, newSVsv(tc)); |
0aad0266 |
39 | |
c6b8ac47 |
40 | if(predicate_calls(attr, "should_auto_deref")){ |
41 | SV* const is_a_type_of = sv_2mortal(newSVpvs_share("is_a_type_of")); |
0aad0266 |
42 | |
c6b8ac47 |
43 | flags |= MOUSEf_ATTR_SHOULD_AUTO_DEREF; |
44 | if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("ArrayRef", SVs_TEMP))) ){ |
45 | flags |= MOUSEf_TC_IS_ARRAYREF; |
0aad0266 |
46 | } |
c6b8ac47 |
47 | else if( sv_true(mcall1(tc, is_a_type_of, newSVpvs_flags("HashRef", SVs_TEMP))) ){ |
48 | flags |= MOUSEf_TC_IS_HASHREF; |
49 | } |
50 | else{ |
51 | mouse_throw_error(attr, tc, |
52 | "Can not auto de-reference the type constraint '%"SVf"'", |
53 | mcall0(tc, mouse_name)); |
0aad0266 |
54 | } |
0aad0266 |
55 | } |
56 | |
de0d4152 |
57 | if(predicate_calls(attr, "should_coerce") && predicate_calls(tc, "has_coercion")){ |
c6b8ac47 |
58 | flags |= MOUSEf_ATTR_SHOULD_COERCE; |
0aad0266 |
59 | } |
60 | |
c6b8ac47 |
61 | } |
0aad0266 |
62 | |
c6b8ac47 |
63 | if(predicate_calls(attr, "has_trigger")){ |
64 | flags |= MOUSEf_ATTR_HAS_TRIGGER; |
65 | } |
0aad0266 |
66 | |
c6b8ac47 |
67 | if(predicate_calls(attr, "is_lazy")){ |
68 | flags |= MOUSEf_ATTR_IS_LAZY; |
69 | } |
70 | if(predicate_calls(attr, "has_builder")){ |
71 | flags |= MOUSEf_ATTR_HAS_BUILDER; |
72 | } |
73 | else if(predicate_calls(attr, "has_default")){ |
74 | flags |= MOUSEf_ATTR_HAS_DEFAULT; |
75 | } |
76 | |
77 | if(predicate_calls(attr, "is_weak_ref")){ |
78 | flags |= MOUSEf_ATTR_IS_WEAK_REF; |
79 | } |
80 | |
81 | if(predicate_calls(attr, "is_required")){ |
82 | flags |= MOUSEf_ATTR_IS_REQUIRED; |
83 | } |
84 | |
85 | av_store(xa, MOUSE_XA_FLAGS, newSVuv(flags)); |
86 | MOUSE_mg_flags(mg) = flags; |
87 | |
88 | FREETMPS; |
89 | LEAVE; |
90 | |
91 | return xa; |
92 | } |
93 | |
94 | AV* |
95 | mouse_get_xa(pTHX_ SV* const attr) { |
96 | AV* xa; |
97 | MAGIC* mg; |
0aad0266 |
98 | |
c6b8ac47 |
99 | if(!IsObject(attr)){ |
100 | croak("Not a Mouse meta attribute"); |
101 | } |
0aad0266 |
102 | |
c6b8ac47 |
103 | mg = mouse_mg_find(aTHX_ SvRV(attr), &mouse_xa_vtbl, 0x00); |
104 | if(!mg){ |
105 | xa = mouse_build_xa(aTHX_ attr); |
0aad0266 |
106 | } |
107 | else{ |
c6b8ac47 |
108 | xa = (AV*)MOUSE_mg_obj(mg); |
0aad0266 |
109 | |
110 | assert(xa); |
111 | assert(SvTYPE(xa) == SVt_PVAV); |
112 | } |
113 | |
114 | return xa; |
115 | } |
116 | |
4e7e3250 |
117 | SV* |
118 | mouse_xa_apply_type_constraint(pTHX_ AV* const xa, SV* value, U16 const flags){ |
119 | SV* const tc = MOUSE_xa_tc(xa); |
120 | SV* tc_code; |
121 | |
122 | if(flags & MOUSEf_ATTR_SHOULD_COERCE){ |
d39ac61c |
123 | value = mcall1(tc, mouse_coerce, value); |
4e7e3250 |
124 | } |
125 | |
126 | if(!SvOK(MOUSE_xa_tc_code(xa))){ |
127 | tc_code = mcall0s(tc, "_compiled_type_constraint"); |
128 | av_store(xa, MOUSE_XA_TC_CODE, newSVsv(tc_code)); |
129 | |
130 | if(!IsCodeRef(tc_code)){ |
131 | mouse_throw_error(MOUSE_xa_attribute(xa), tc, "Not a CODE reference"); |
132 | } |
133 | } |
134 | else{ |
135 | tc_code = MOUSE_xa_tc_code(xa); |
136 | } |
137 | |
138 | if(!mouse_tc_check(aTHX_ tc_code, value)){ |
139 | mouse_throw_error(MOUSE_xa_attribute(xa), value, |
140 | "Attribute (%"SVf") does not pass the type constraint because: %"SVf, |
141 | mcall0(MOUSE_xa_attribute(xa), mouse_name), |
142 | mcall1s(tc, "get_message", value)); |
143 | } |
144 | |
145 | return value; |
146 | } |
147 | |
148 | |
149 | SV* |
150 | mouse_xa_set_default(pTHX_ AV* const xa, SV* const object) { |
151 | U16 const flags = (U16)MOUSE_xa_flags(xa); |
152 | SV* value; |
153 | |
3f2c3dc7 |
154 | ENTER; |
155 | SAVETMPS; |
156 | |
4e7e3250 |
157 | /* get default value by $attr->builder or $attr->default */ |
158 | if(flags & MOUSEf_ATTR_HAS_BUILDER){ |
159 | SV* const builder = mcall0s(MOUSE_xa_attribute(xa), "builder"); |
160 | value = mcall0(object, builder); /* $object->$builder() */ |
161 | } |
162 | else { |
163 | value = mcall0s(MOUSE_xa_attribute(xa), "default"); |
164 | |
165 | if(IsCodeRef(value)){ |
166 | value = mcall0(object, value); |
167 | } |
168 | } |
169 | |
170 | /* apply coerce and type constraint */ |
171 | if(flags & MOUSEf_ATTR_HAS_TC){ |
172 | value = mouse_xa_apply_type_constraint(aTHX_ xa, value, flags); |
173 | } |
174 | |
175 | /* store value to slot */ |
176 | value = set_slot(object, MOUSE_xa_slot(xa), value); |
4e7e3250 |
177 | if(flags & MOUSEf_ATTR_IS_WEAK_REF && SvROK(value)){ |
178 | weaken_slot(object, MOUSE_xa_slot(xa)); |
179 | } |
180 | |
3f2c3dc7 |
181 | FREETMPS; |
182 | LEAVE; |
183 | |
4e7e3250 |
184 | return value; |
185 | } |
0aad0266 |
186 | |
fc7e5b5f |
187 | /* checks $isa->does($does) */ |
d503a4f3 |
188 | static void |
189 | mouse_check_isa_does_does(pTHX_ SV* const klass, SV* const name, SV* const isa, SV* const does){ |
190 | STRLEN len; |
191 | const char* const pv = SvPV_const(isa, len); /* need strigify */ |
192 | bool does_ok; |
193 | dSP; |
194 | |
195 | ENTER; |
196 | SAVETMPS; |
197 | |
198 | SAVESPTR(ERRSV); |
199 | ERRSV = sv_newmortal(); |
200 | |
201 | PUSHMARK(SP); |
202 | EXTEND(SP, 2); |
203 | mPUSHp(pv, len); |
204 | PUSHs(does); |
205 | PUTBACK; |
206 | |
207 | call_method("does", G_EVAL | G_SCALAR); |
208 | |
209 | SPAGAIN; |
210 | does_ok = sv_true(POPs); |
211 | PUTBACK; |
212 | |
213 | FREETMPS; |
214 | LEAVE; |
215 | |
216 | if(!does_ok){ |
217 | mouse_throw_error(klass, NULL, |
218 | "Cannot have both an isa option and a does option" |
219 | "because '%"SVf"' does not do '%"SVf"' on attribute (%"SVf")", |
220 | isa, does, name |
221 | ); |
222 | } |
223 | } |
224 | |
aa2d2e2c |
225 | MODULE = Mouse::Meta::Attribute PACKAGE = Mouse::Meta::Attribute |
226 | |
227 | PROTOTYPES: DISABLE |
228 | |
229 | BOOT: |
230 | /* readers */ |
231 | INSTALL_SIMPLE_READER(Attribute, name); |
232 | INSTALL_SIMPLE_READER(Attribute, associated_class); |
233 | INSTALL_SIMPLE_READER(Attribute, accessor); |
234 | INSTALL_SIMPLE_READER(Attribute, reader); |
235 | INSTALL_SIMPLE_READER(Attribute, writer); |
236 | INSTALL_SIMPLE_READER(Attribute, predicate); |
237 | INSTALL_SIMPLE_READER(Attribute, clearer); |
238 | INSTALL_SIMPLE_READER(Attribute, handles); |
239 | |
240 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, _is_metadata, is); |
241 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_required, required); |
242 | INSTALL_SIMPLE_READER(Attribute, default); |
243 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy, lazy); |
244 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_lazy_build, lazy_build); |
245 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, is_weak_ref, weak_ref); |
246 | INSTALL_SIMPLE_READER(Attribute, init_arg); |
247 | INSTALL_SIMPLE_READER(Attribute, type_constraint); |
248 | INSTALL_SIMPLE_READER(Attribute, trigger); |
249 | INSTALL_SIMPLE_READER(Attribute, builder); |
250 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_auto_deref, auto_deref); |
251 | INSTALL_SIMPLE_READER_WITH_KEY(Attribute, should_coerce, coerce); |
252 | INSTALL_SIMPLE_READER(Attribute, documentation); |
beb51b30 |
253 | INSTALL_SIMPLE_READER(Attribute, insertion_order); |
aa2d2e2c |
254 | |
255 | /* predicates */ |
256 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_accessor, accessor); |
257 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_reader, reader); |
258 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_writer, writer); |
259 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_predicate, predicate); |
260 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_clearer, clearer); |
261 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_handles, handles); |
262 | |
263 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_default, default); |
264 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_type_constraint, type_constraint); |
265 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_trigger, trigger); |
266 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_builder, builder); |
267 | INSTALL_SIMPLE_PREDICATE_WITH_KEY(Attribute, has_documentation, documentation); |
268 | |
787f84c2 |
269 | INSTALL_CLASS_HOLDER(Attribute, accessor_metaclass, "Mouse::Meta::Method::Accessor::XS"); |
aa2d2e2c |
270 | |
ba1f50a2 |
271 | void |
272 | _process_options(SV* klass, SV* name, HV* args) |
273 | CODE: |
274 | { |
fc7e5b5f |
275 | /* TODO: initialize 'xa' here */ |
ba1f50a2 |
276 | SV** svp; |
277 | SV* tc = NULL; |
278 | |
279 | /* 'required' requires eigher 'init_arg', 'builder', or 'default' */ |
280 | bool can_be_required = FALSE; |
281 | bool has_default = FALSE; |
282 | bool has_builder = FALSE; |
283 | |
284 | /* taken from Class::MOP::Attribute::new */ |
285 | |
d06d9266 |
286 | must_defined(name, "an attribute name"); |
ba1f50a2 |
287 | |
288 | svp = hv_fetchs(args, "init_arg", FALSE); |
289 | if(!svp){ |
290 | (void)hv_stores(args, "init_arg", newSVsv(name)); |
291 | can_be_required = TRUE; |
292 | } |
293 | else{ |
294 | can_be_required = SvOK(*svp) ? TRUE : FALSE; |
295 | } |
296 | |
297 | svp = hv_fetchs(args, "builder", FALSE); |
298 | if(svp){ |
299 | if(!SvOK(*svp)){ |
077f2efd |
300 | mouse_throw_error(klass, *svp, |
ba1f50a2 |
301 | "builder must be a defined scalar value which is a method name"); |
302 | } |
303 | can_be_required = TRUE; |
304 | has_builder = TRUE; |
305 | } |
306 | else if((svp = hv_fetchs(args, "default", FALSE))){ |
307 | if(SvROK(*svp) && SvTYPE(SvRV(*svp)) != SVt_PVCV) { |
077f2efd |
308 | mouse_throw_error(klass, *svp, |
ba1f50a2 |
309 | "References are not allowed as default values, you must " |
310 | "wrap the default of '%"SVf"' in a CODE reference " |
311 | "(ex: sub { [] } and not [])", name); |
312 | } |
313 | can_be_required = TRUE; |
314 | has_default = TRUE; |
315 | } |
316 | |
317 | svp = hv_fetchs(args, "required", FALSE); |
318 | if( (svp && sv_true(*svp)) && !can_be_required){ |
319 | mouse_throw_error(klass, NULL, |
320 | "You cannot have a required attribute (%"SVf") " |
321 | "without a default, builder, or an init_arg", name); |
322 | } |
323 | |
bc97157e |
324 | /* taken from Mouse::Meta::Attribute->new and ->_process_args */ |
ba1f50a2 |
325 | |
326 | svp = hv_fetchs(args, "is", FALSE); |
327 | if(svp){ |
328 | const char* const is = SvOK(*svp) ? SvPV_nolen_const(*svp) : "undef"; |
329 | if(strEQ(is, "ro")){ |
330 | svp = hv_fetchs(args, "reader", TRUE); |
331 | if(!sv_true(*svp)){ |
332 | sv_setsv(*svp, name); |
333 | } |
334 | } |
335 | else if(strEQ(is, "rw")){ |
336 | if(hv_fetchs(args, "writer", FALSE)){ |
337 | svp = hv_fetchs(args, "reader", TRUE); |
338 | } |
339 | else{ |
340 | svp = hv_fetchs(args, "accessor", TRUE); |
341 | } |
0464d337 |
342 | if(!SvOK(*svp)) { |
343 | sv_setsv(*svp, name); |
344 | } |
ba1f50a2 |
345 | } |
346 | else if(strEQ(is, "bare")){ |
bc97157e |
347 | /* do nothing, but might complain later about missing methods */ |
ba1f50a2 |
348 | } |
349 | else{ |
350 | mouse_throw_error(klass, NULL, |
351 | "I do not understand this option (is => %s) on attribute (%"SVf")", |
352 | is, name); |
353 | } |
354 | } |
355 | |
356 | svp = hv_fetchs(args, "isa", FALSE); |
357 | if(svp){ |
358 | SPAGAIN; |
359 | PUSHMARK(SP); |
360 | XPUSHs(*svp); |
361 | PUTBACK; |
362 | |
363 | call_pv("Mouse::Util::TypeConstraints::find_or_create_isa_type_constraint", |
364 | G_SCALAR); |
365 | SPAGAIN; |
366 | tc = newSVsv(POPs); |
367 | PUTBACK; |
368 | } |
ba1f50a2 |
369 | |
d503a4f3 |
370 | if((svp = hv_fetchs(args, "does", FALSE))){ |
371 | /* check 'isa' does 'does' */ |
372 | if(tc){ |
373 | mouse_check_isa_does_does(aTHX_ klass, name, tc, *svp); |
374 | /* nothing to do */ |
375 | } |
376 | else{ |
377 | SPAGAIN; |
378 | PUSHMARK(SP); |
379 | XPUSHs(*svp); |
380 | PUTBACK; |
381 | |
382 | call_pv("Mouse::Util::TypeConstraints::find_or_create_does_type_constraint", |
383 | G_SCALAR); |
384 | SPAGAIN; |
385 | tc = newSVsv(POPs); |
386 | PUTBACK; |
387 | } |
ba1f50a2 |
388 | } |
389 | if(tc){ |
390 | (void)hv_stores(args, "type_constraint", tc); |
391 | } |
392 | |
393 | svp = hv_fetchs(args, "coerce", FALSE); |
394 | if(svp){ |
395 | if(!tc){ |
396 | mouse_throw_error(klass, NULL, |
397 | "You cannot have coercion without specifying a type constraint " |
398 | "on attribute (%"SVf")", name); |
399 | } |
400 | svp = hv_fetchs(args, "weak_ref", FALSE); |
401 | if(svp && sv_true(*svp)){ |
402 | mouse_throw_error(klass, NULL, |
403 | "You cannot have a weak reference to a coerced value on " |
404 | "attribute (%"SVf")", name); |
405 | } |
406 | } |
407 | |
408 | svp = hv_fetchs(args, "lazy_build", FALSE); |
409 | if(svp){ |
410 | SV* clearer; |
411 | SV* predicate; |
412 | if(has_default){ |
413 | mouse_throw_error(klass, NULL, |
414 | "You can not use lazy_build and default for the same " |
415 | "attribute (%"SVf")", name); |
416 | } |
417 | |
418 | svp = hv_fetchs(args, "lazy", TRUE); |
419 | sv_setiv(*svp, TRUE); |
420 | |
421 | svp = hv_fetchs(args, "builder", TRUE); |
422 | if(!sv_true(*svp)){ |
423 | sv_setpvf(*svp, "_build_%"SVf, name); |
424 | } |
425 | has_builder = TRUE; |
426 | |
427 | clearer = *hv_fetchs(args, "clearer", TRUE); |
428 | predicate = *hv_fetchs(args, "predicate", TRUE); |
429 | |
430 | if(SvPV_nolen_const(name)[0] == '_'){ |
431 | if(!sv_true(clearer)){ |
432 | sv_setpvf(clearer, "_clear%"SVf, name); |
433 | } |
434 | if(!sv_true(predicate)){ |
435 | sv_setpvf(predicate, "_has%"SVf, name); |
436 | } |
437 | } |
438 | else{ |
439 | if(!sv_true(clearer)){ |
440 | sv_setpvf(clearer, "clear_%"SVf, name); |
441 | } |
442 | if(!sv_true(predicate)){ |
443 | sv_setpvf(predicate, "has_%"SVf, name); |
444 | } |
445 | } |
446 | } |
447 | |
448 | svp = hv_fetchs(args, "auto_deref", FALSE); |
449 | if(svp && sv_true(*svp)){ |
450 | SV* const meth = sv_2mortal(newSVpvs_share("is_a_type_of")); |
451 | if(!tc){ |
452 | mouse_throw_error(klass, NULL, |
453 | "You cannot auto-dereference without specifying a type " |
454 | "constraint on attribute (%"SVf")", name); |
455 | } |
456 | |
457 | if(!(sv_true(mcall1(tc, meth, newSVpvs_flags("ArrayRef", SVs_TEMP))) |
458 | || sv_true(mcall1(tc, meth, newSVpvs_flags("HashRef", SVs_TEMP))) )){ |
459 | mouse_throw_error(klass, NULL, |
460 | "You cannot auto-dereference anything other than a ArrayRef " |
461 | "or HashRef on attribute (%"SVf")", name); |
462 | } |
463 | } |
464 | |
465 | svp = hv_fetchs(args, "trigger", FALSE); |
466 | if(svp){ |
467 | if(!IsCodeRef(*svp)){ |
468 | mouse_throw_error(klass, NULL, |
469 | "Trigger must be a CODE ref on attribute (%"SVf")", |
470 | name); |
471 | } |
472 | } |
473 | |
474 | |
475 | svp = hv_fetchs(args, "lazy", FALSE); |
476 | if(svp && sv_true(*svp)){ |
477 | if(!(has_default || has_builder)){ |
478 | mouse_throw_error(klass, NULL, |
2c689df4 |
479 | "You cannot have a lazy attribute (%"SVf") without specifying " |
ba1f50a2 |
480 | "a default value for it", name); |
481 | } |
482 | } |
483 | } |