Declare.xs

filter: Statementstmt 92.1% 444 / 482 Branchbran 59.2% 218 / 368 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 77.8% 662 / 850 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« blib/lib/Enum/Declare/Meta.pm ↑ Summary blib/lib/Enum/Declare.pm »
1 #include "EXTERN.h"
2 #include "perl.h"
3 #include "callparser1.h"
4 #include "XSUB.h"
5 #include "object_types.h"
6  
7 #if !defined(__bool_true_false_are_defined) && !(defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311L)
8 # ifndef true
9 # define true 1
10 # endif
11 # ifndef false
12 # define false 0
13 # endif
14 #endif
15  
16 #ifndef XS_INTERNAL
17 #define XS_INTERNAL(name) static XSPROTO(name)
18 #endif
19  
20 168 static int has_attr(pTHX_ SV *attr_sv, const char *name) {
21 const char *p, *end;
22 STRLEN alen, nlen;
23 168 ▶ if (!SvOK(attr_sv)) return 0;
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(attr_sv)) return 0; 62 106 168
24 106 p = SvPV(attr_sv, alen);
25 106 end = p + alen;
26 106 nlen = strlen(name);
27 202 ▶ while (p < end) {
Branch: 1 branch
BranchTrueFalseTotal
while (p < end) { 133 69 202
28 133 const char *comma = (const char *)memchr(p, ',', end - p);
29 133 ▶ STRLEN seg = comma ? (STRLEN)(comma - p) : (STRLEN)(end - p);
Branch: 1 branch
BranchTrueFalseTotal
STRLEN seg = comma ? (STRLEN)(comma - p) : (STRLEN)(end - p); 36 97 133
30 133 ▶ if (seg == nlen && memEQ(p, name, nlen)) return 1;
Branch: 2 branches
BranchTrueFalseTotal
if (seg == nlen && memEQ(p, name, nlen)) return 1; 37 96 133
if (seg == nlen && memEQ(p, name, nlen)) return 1; 37 0 37
31 96 p += seg + 1;
32 }
33 69 return 0;
34 }
35  
36 typedef struct {
37 HV *val2name; /* value -> name lookup (for check) */
38 HV *lc_name2val; /* lc(name) -> value lookup (for coerce) */
39 IV flags_mask; /* combined bitmask for :Flags enums, -1 if not flags */
40 } EnumTypeData;
41  
42 24 static bool enum_type_check(pTHX_ SV *val, void *data_ptr) {
43 24 EnumTypeData *etd = (EnumTypeData *)data_ptr;
44 const char *pv;
45 STRLEN len;
46 24 ▶ if (!SvOK(val)) return false;
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(val)) return false; 0 24 24
47 24 ▶ if (etd->flags_mask >= 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (etd->flags_mask >= 0) { 6 18 24
48 IV iv;
49 6 ▶ if (!SvIOK(val) && !(SvPOK(val) && looks_like_number(val)))
Branch: 3 branches
BranchTrueFalseTotal
if (!SvIOK(val) && !(SvPOK(val) && looks_like_number(val))) 0 6 6
if (!SvIOK(val) && !(SvPOK(val) && looks_like_number(val))) 0 0 0
if (!SvIOK(val) && !(SvPOK(val) && looks_like_number(val))) 0 0 0
50 0 return false;
51 6 iv = SvIV(val);
52 6 ▶ return iv >= 0 && (iv & ~etd->flags_mask) == 0;
Branch: 2 branches
BranchTrueFalseTotal
return iv >= 0 && (iv & ~etd->flags_mask) == 0; 6 0 6
return iv >= 0 && (iv & ~etd->flags_mask) == 0; 4 2 6
53 }
54 18 pv = SvPV(val, len);
55 18 return hv_exists(etd->val2name, pv, len);
56 }
57  
58 24 static SV *enum_type_coerce(pTHX_ SV *val, void *data_ptr) {
59 24 EnumTypeData *etd = (EnumTypeData *)data_ptr;
60 const char *pv;
61 STRLEN len;
62 SV **found;
63 char *lc;
64 STRLEN i;
65 SV *lc_sv;
66 24 ▶ if (!SvOK(val)) return val;
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(val)) return val; 0 24 24
67 24 pv = SvPV(val, len);
68 24 ▶ if (hv_exists(etd->val2name, pv, len))
Branch: 1 branch
BranchTrueFalseTotal
if (hv_exists(etd->val2name, pv, len)) 10 14 24
69 10 return val;
70 14 lc_sv = newSVpvn(pv, len);
71 14 lc = SvPVX(lc_sv);
72 52 ▶ for (i = 0; i < len; i++) lc[i] = toLOWER(lc[i]);
Branch: 2 branches
BranchTrueFalseTotal
for (i = 0; i < len; i++) lc[i] = toLOWER(lc[i]); 11 27 38
for (i = 0; i < len; i++) lc[i] = toLOWER(lc[i]); 38 14 52
73 14 found = hv_fetch(etd->lc_name2val, lc, len, 0);
74 14 SvREFCNT_dec(lc_sv);
75 14 ▶ if (found) return sv_mortalcopy(*found);
Branch: 1 branch
BranchTrueFalseTotal
if (found) return sv_mortalcopy(*found); 5 9 14
76 9 return val;
77 }
78  
79 219 static SV *lex_read_ident(pTHX) {
80 219 SV *buf = newSVpvs("");
81 I32 c;
82 while (1) {
83 1288 c = lex_peek_unichar(0);
84 1288 ▶ if (c == -1) break;
Branch: 1 branch
BranchTrueFalseTotal
if (c == -1) break; 0 1288 1288
85 1288 ▶ if (!isALNUM(c) && c != '_') break;
Branch: 3 branches
BranchTrueFalseTotal
if (!isALNUM(c) && c != '_') break; 1288 0 1288
if (!isALNUM(c) && c != '_') break; 219 1069 1288
if (!isALNUM(c) && c != '_') break; 219 0 219
86 1069 sv_catpvf(buf, "%c", (int)c);
87 1069 lex_read_unichar(0);
88 }
89 219 ▶ if (SvCUR(buf) == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvCUR(buf) == 0) { 0 219 219
90 0 SvREFCNT_dec(buf);
91 0 return NULL;
92 }
93 219 return buf;
94 }
95  
96 47 static SV *lex_read_attrs(pTHX) {
97 47 SV *attr_sv = &PL_sv_undef;
98 47 I32 c = lex_peek_unichar(0);
99 94 ▶ while (c == ':') {
Branch: 1 branch
BranchTrueFalseTotal
while (c == ':') { 47 47 94
100 SV *a;
101 47 lex_read_unichar(0);
102 47 lex_read_space(0);
103 47 a = lex_read_ident(aTHX);
104 47 ▶ if (!a) croak("Expected attribute name after ':'");
Branch: 1 branch
BranchTrueFalseTotal
if (!a) croak("Expected attribute name after ':'"); 0 47 47
105 47 ▶ if (attr_sv == &PL_sv_undef) {
Branch: 1 branch
BranchTrueFalseTotal
if (attr_sv == &PL_sv_undef) { 35 12 47
106 35 attr_sv = a;
107 } else {
108 12 sv_catpvs(attr_sv, ",");
109 12 sv_catsv(attr_sv, a);
110 12 SvREFCNT_dec(a);
111 }
112 47 lex_read_space(0);
113 47 c = lex_peek_unichar(0);
114 }
115 47 return attr_sv;
116 }
117  
118 11 static SV *lex_read_quoted_string(pTHX) {
119 11 I32 quote = lex_peek_unichar(0);
120 SV *sv;
121 I32 c;
122 11 lex_read_unichar(0);
123 11 sv = newSVpvs("");
124 while (1) {
125 64 c = lex_read_unichar(0);
126 64 ▶ if (c == -1) croak("Unterminated string in enum declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (c == -1) croak("Unterminated string in enum declaration"); 0 64 64
127 64 ▶ if (c == '\\' && quote == '"') {
Branch: 2 branches
BranchTrueFalseTotal
if (c == '\\' && quote == '"') { 0 64 64
if (c == '\\' && quote == '"') { 0 0 0
128 0 I32 next = lex_read_unichar(0);
129 0 ▶ if (next == -1) croak("Unterminated string in enum declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (next == -1) croak("Unterminated string in enum declaration"); 0 0 0
130 0 sv_catpvf(sv, "%c", (int)next);
131 64 ▶ } else if (c == quote) {
Branch: 1 branch
BranchTrueFalseTotal
} else if (c == quote) { 11 53 64
132 11 break;
133 } else {
134 53 sv_catpvf(sv, "%c", (int)c);
135 }
136 }
137 11 return sv;
138 }
139  
140 14 static SV *lex_read_integer(pTHX) {
141 14 int is_neg = 0;
142 SV *buf;
143 IV ival;
144 14 I32 c = lex_peek_unichar(0);
145 14 ▶ if (c == '-') {
Branch: 1 branch
BranchTrueFalseTotal
if (c == '-') { 1 13 14
146 1 is_neg = 1;
147 1 lex_read_unichar(0);
148 1 lex_read_space(0);
149 1 c = lex_peek_unichar(0);
150 }
151 14 ▶ if (!isDIGIT(c))
Branch: 1 branch
BranchTrueFalseTotal
if (!isDIGIT(c)) 0 14 14
152 0 croak("Expected integer or string value after '=' in enum declaration");
153 14 buf = newSVpvs("");
154 while (1) {
155 49 c = lex_peek_unichar(0);
156 49 ▶ if (c == -1 || !isDIGIT(c)) break;
Branch: 2 branches
BranchTrueFalseTotal
if (c == -1 || !isDIGIT(c)) break; 49 0 49
if (c == -1 || !isDIGIT(c)) break; 35 14 49
157 35 sv_catpvf(buf, "%c", (int)c);
158 35 lex_read_unichar(0);
159 }
160 14 ival = SvIV(buf);
161 14 SvREFCNT_dec(buf);
162 14 ▶ if (is_neg) ival = -ival;
Branch: 1 branch
BranchTrueFalseTotal
if (is_neg) ival = -ival; 1 13 14
163 14 return newSViv(ival);
164 }
165  
166 37 static AV *lex_read_variants(pTHX) {
167 37 AV *av = newAV();
168 I32 c;
169 37 lex_read_space(0);
170 37 c = lex_peek_unichar(0);
171 37 ▶ if (c != '{') croak("Expected '{' after enum name");
Branch: 1 branch
BranchTrueFalseTotal
if (c != '{') croak("Expected '{' after enum name"); 0 37 37
172 37 lex_read_unichar(0);
173 120 while (1) {
174 SV *vname;
175 157 lex_read_space(0);
176 157 c = lex_peek_unichar(0);
177 157 ▶ if (c == '}') { lex_read_unichar(0); break; }
Branch: 1 branch
BranchTrueFalseTotal
if (c == '}') { lex_read_unichar(0); break; } 37 120 157
178 120 ▶ if (c == -1) croak("Unexpected end of input in enum declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (c == -1) croak("Unexpected end of input in enum declaration"); 0 120 120
179 120 vname = lex_read_ident(aTHX);
180 120 ▶ if (!vname) croak("Expected variant name in enum declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (!vname) croak("Expected variant name in enum declaration"); 0 120 120
181 120 av_push(av, vname);
182 120 lex_read_space(0);
183 120 c = lex_peek_unichar(0);
184 120 ▶ if (c == '=') {
Branch: 1 branch
BranchTrueFalseTotal
if (c == '=') { 25 95 120
185 25 lex_read_unichar(0);
186 25 lex_read_space(0);
187 25 c = lex_peek_unichar(0);
188 25 ▶ if (c == '"' || c == '\'') {
Branch: 2 branches
BranchTrueFalseTotal
if (c == '"' || c == '\'') { 17 8 25
if (c == '"' || c == '\'') { 3 14 17
189 11 av_push(av, lex_read_quoted_string(aTHX));
190 } else {
191 14 av_push(av, lex_read_integer(aTHX));
192 }
193 } else {
194 95 av_push(av, &PL_sv_undef);
195 }
196 120 lex_read_space(0);
197 120 ▶ if (lex_peek_unichar(0) == ',') lex_read_unichar(0);
Branch: 1 branch
BranchTrueFalseTotal
if (lex_peek_unichar(0) == ',') lex_read_unichar(0); 83 37 120
198 }
199 37 return av;
200 }
201  
202 typedef struct {
203 AV *names;
204 AV *values;
205 HV *name2val;
206 HV *val2name;
207 } EnumData;
208  
209 37 static EnumData build_enum_data(pTHX_ AV *variants, int is_str, int is_flags, const char *pkg, STRLEN pkg_len) {
210 EnumData d;
211 37 IV next_ival = is_flags ? 1 : 0;
212 37 I32 pair_count = av_len(variants) + 1;
213 I32 i;
214 37 d.names = newAV();
215 37 d.values = newAV();
216 37 d.name2val = newHV();
217 37 d.val2name = newHV();
218 157 ▶ for (i = 0; i < pair_count; i += 2) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < pair_count; i += 2) { 120 37 157
219 120 SV **name_p = av_fetch(variants, i, 0);
220 120 SV **val_p = av_fetch(variants, i + 1, 0);
221 120 ▶ SV *vname = name_p ? *name_p : &PL_sv_undef;
Branch: 1 branch
BranchTrueFalseTotal
SV *vname = name_p ? *name_p : &PL_sv_undef; 120 0 120
222 120 ▶ SV *vval = val_p ? *val_p : &PL_sv_undef;
Branch: 1 branch
BranchTrueFalseTotal
SV *vval = val_p ? *val_p : &PL_sv_undef; 120 0 120
223 SV *resolved;
224 const char *vname_pv;
225 STRLEN vname_len;
226 120 vname_pv = SvPV(vname, vname_len);
227 120 ▶ if (SvOK(vval)) {
Branch: 1 branch
BranchTrueFalseTotal
if (SvOK(vval)) { 25 95 120
228 25 ▶ if (is_str) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_str) { 11 14 25
229 11 resolved = newSVsv(vval);
230 } else {
231 14 next_ival = SvIV(vval);
232 14 resolved = newSViv(next_ival);
233 }
234 95 ▶ } else if (is_str) {
Branch: 1 branch
BranchTrueFalseTotal
} else if (is_str) { 24 71 95
235 char *lc;
236 STRLEN j;
237 24 resolved = newSVpvn(vname_pv, vname_len);
238 24 lc = SvPVX(resolved);
239 142 ▶ for (j = 0; j < vname_len; j++) lc[j] = toLOWER(lc[j]);
Branch: 2 branches
BranchTrueFalseTotal
for (j = 0; j < vname_len; j++) lc[j] = toLOWER(lc[j]); 24 94 118
for (j = 0; j < vname_len; j++) lc[j] = toLOWER(lc[j]); 118 24 142
240 } else {
241 71 resolved = newSViv(next_ival);
242 }
243 120 av_push(d.names, newSVpvn(vname_pv, vname_len));
244 120 av_push(d.values, newSVsv(resolved));
245 120 hv_store(d.name2val, vname_pv, vname_len, newSVsv(resolved), 0);
246 {
247 const char *val_pv;
248 STRLEN val_len;
249 120 SV *val_key = newSVsv(resolved);
250 120 val_pv = SvPV(val_key, val_len);
251 120 hv_store(d.val2name, val_pv, val_len,
252 newSVpvn(vname_pv, vname_len), 0);
253 120 SvREFCNT_dec(val_key);
254 }
255 {
256 120 SV *val_copy = newSVsv(resolved);
257 120 newCONSTSUB(gv_stashpvn(pkg, pkg_len, GV_ADD),
258 vname_pv, val_copy);
259 }
260 120 ▶ if (!is_str)
Branch: 1 branch
BranchTrueFalseTotal
if (!is_str) 85 35 120
261 85 ▶ next_ival = is_flags ? next_ival << 1 : next_ival + 1;
Branch: 1 branch
BranchTrueFalseTotal
next_ival = is_flags ? next_ival << 1 : next_ival + 1; 29 56 85
262 120 SvREFCNT_dec(resolved);
263 }
264 37 return d;
265 }
266  
267 8 static void merge_enum_exports(pTHX_ const char *pkg) {
268 8 SV *buf = sv_newmortal();
269 AV *pending, *exp, *exp_ok;
270 I32 j;
271  
272 8 sv_setpvf(buf, "%s::_ENUM_EXPORTS", pkg);
273 8 pending = get_av(SvPV_nolen(buf), 0);
274 8 ▶ if (!pending || av_len(pending) < 0) return;
Branch: 2 branches
BranchTrueFalseTotal
if (!pending || av_len(pending) < 0) return; 8 0 8
if (!pending || av_len(pending) < 0) return; 4 4 8
275  
276 4 sv_setpvf(buf, "%s::EXPORT", pkg);
277 4 exp = get_av(SvPV_nolen(buf), GV_ADD);
278  
279 4 sv_setpvf(buf, "%s::EXPORT_OK", pkg);
280 4 exp_ok = get_av(SvPV_nolen(buf), GV_ADD);
281  
282 25 ▶ for (j = 0; j <= av_len(pending); j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j <= av_len(pending); j++) { 21 4 25
283 21 SV **n = av_fetch(pending, j, 0);
284 21 ▶ if (n) {
Branch: 1 branch
BranchTrueFalseTotal
if (n) { 21 0 21
285 21 av_push(exp, newSVsv(*n));
286 21 av_push(exp_ok, newSVsv(*n));
287 }
288 }
289 4 av_clear(pending);
290 }
291  
292 8 XS_INTERNAL(xs_enum_pkg_import) {
293 8 dXSARGS;
294 const char *pkg;
295 CV *exp_import;
296 I32 j;
297  
298 8 ▶ if (items < 1) croak("Usage: PKG->import(...)");
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) croak("Usage: PKG->import(...)"); 0 8 8
299 8 pkg = SvPV_nolen(ST(0));
300  
301 8 merge_enum_exports(aTHX_ pkg);
302  
303 8 exp_import = get_cv("Exporter::import", 0);
304 8 ▶ if (!exp_import) {
Branch: 1 branch
BranchTrueFalseTotal
if (!exp_import) { 0 8 8
305 0 load_module(PERL_LOADMOD_NOIMPORT, newSVpvs("Exporter"), NULL);
306 0 exp_import = get_cv("Exporter::import", 0);
307 }
308 8 ▶ if (!exp_import) croak("Cannot find Exporter::import");
Branch: 1 branch
BranchTrueFalseTotal
if (!exp_import) croak("Cannot find Exporter::import"); 0 8 8
309  
310 {
311 8 dSP;
312 8 ENTER;
313 8 SAVETMPS;
314 8 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 8 8
315 21 ▶ for (j = 0; j < items; j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < items; j++) { 13 8 21
316 13 ▶ XPUSHs(ST(j));
Branch: 1 branch
BranchTrueFalseTotal
XPUSHs(ST(j)); 0 13 13
317 }
318 8 PUTBACK;
319 8 call_sv((SV*)exp_import, G_VOID | G_DISCARD);
320 8 ▶ FREETMPS;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; 0 8 8
321 8 LEAVE;
322 }
323  
324 8 XSRETURN_EMPTY;
325 }
326  
327 5 static void setup_exports(pTHX_ const char *pkg, STRLEN pkg_len, AV *names, SV *enum_name) {
328 5 SV *buf = sv_newmortal();
329 AV *pending;
330 AV *tag_list;
331 HV *export_tags;
332 I32 j;
333 5 sv_setpvf(buf, "%s::_ENUM_EXPORTS", pkg);
334 5 pending = get_av(SvPV_nolen(buf), GV_ADD);
335 21 ▶ for (j = 0; j <= av_len(names); j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j <= av_len(names); j++) { 16 5 21
336 16 SV **n = av_fetch(names, j, 0);
337 16 ▶ if (n) av_push(pending, newSVsv(*n));
Branch: 1 branch
BranchTrueFalseTotal
if (n) av_push(pending, newSVsv(*n)); 16 0 16
338 }
339 5 ▶ if (enum_name) av_push(pending, newSVsv(enum_name));
Branch: 1 branch
BranchTrueFalseTotal
if (enum_name) av_push(pending, newSVsv(enum_name)); 5 0 5
340 5 ▶ if (enum_name) {
Branch: 1 branch
BranchTrueFalseTotal
if (enum_name) { 5 0 5
341 5 sv_setpvf(buf, "%s::EXPORT_TAGS", pkg);
342 5 export_tags = get_hv(SvPV_nolen(buf), GV_ADD);
343  
344 5 tag_list = newAV();
345 21 ▶ for (j = 0; j <= av_len(names); j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j <= av_len(names); j++) { 16 5 21
346 16 SV **n = av_fetch(names, j, 0);
347 16 ▶ if (n) av_push(tag_list, newSVsv(*n));
Branch: 1 branch
BranchTrueFalseTotal
if (n) av_push(tag_list, newSVsv(*n)); 16 0 16
348 }
349 5 av_push(tag_list, newSVsv(enum_name));
350 5 (void)hv_store_ent(export_tags, enum_name, newRV_noinc((SV*)tag_list), 0);
351 }
352 5 sv_setpvf(buf, "%s::import", pkg);
353 5 ▶ if (!get_cv(SvPV_nolen(buf), 0)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!get_cv(SvPV_nolen(buf), 0)) { 4 1 5
354 4 newXS(SvPV_nolen(buf), xs_enum_pkg_import, __FILE__);
355 }
356 5 }
357  
358 37 static void install_meta(pTHX_ SV *name_sv, const char *pkg, STRLEN pkg_len, EnumData *d, int is_flags, int is_type) {
359 37 dSP;
360 SV *meta;
361 37 const char *ename = SvPV_nolen(name_sv);
362 37 EnumTypeData *etd = NULL;
363 37 ▶ if (is_type) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_type) { 9 28 37
364 HE *he;
365 I32 j;
366 9 Newxz(etd, 1, EnumTypeData);
367 9 etd->val2name = newHV();
368 9 etd->lc_name2val = newHV();
369 9 hv_iterinit(d->val2name);
370 36 ▶ while ((he = hv_iternext(d->val2name))) {
Branch: 1 branch
BranchTrueFalseTotal
while ((he = hv_iternext(d->val2name))) { 27 9 36
371 STRLEN klen;
372 27 ▶ const char *key = HePV(he, klen);
Branch: 1 branch
BranchTrueFalseTotal
const char *key = HePV(he, klen); 0 27 27
373 27 SV *val = HeVAL(he);
374 27 hv_store(etd->val2name, key, klen, newSVsv(val), 0);
375 }
376 9 hv_iterinit(d->name2val);
377 36 ▶ while ((he = hv_iternext(d->name2val))) {
Branch: 1 branch
BranchTrueFalseTotal
while ((he = hv_iternext(d->name2val))) { 27 9 36
378 STRLEN klen;
379 27 ▶ const char *key = HePV(he, klen);
Branch: 1 branch
BranchTrueFalseTotal
const char *key = HePV(he, klen); 0 27 27
380 27 SV *val = HeVAL(he);
381 char *lc_key;
382 STRLEN k;
383 27 Newx(lc_key, klen + 1, char);
384 158 ▶ for (k = 0; k < klen; k++) lc_key[k] = toLOWER(key[k]);
Branch: 2 branches
BranchTrueFalseTotal
for (k = 0; k < klen; k++) lc_key[k] = toLOWER(key[k]); 30 101 131
for (k = 0; k < klen; k++) lc_key[k] = toLOWER(key[k]); 131 27 158
385 27 lc_key[klen] = '\0';
386 27 hv_store(etd->lc_name2val, lc_key, klen, newSVsv(val), 0);
387 27 Safefree(lc_key);
388 }
389 9 ▶ if (is_flags) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_flags) { 3 6 9
390 3 IV mask = 0;
391 12 ▶ for (j = 0; j <= av_len(d->values); j++) {
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j <= av_len(d->values); j++) { 9 3 12
392 9 SV **svp = av_fetch(d->values, j, 0);
393 9 ▶ if (svp) mask |= SvIV(*svp);
Branch: 1 branch
BranchTrueFalseTotal
if (svp) mask |= SvIV(*svp); 9 0 9
394 }
395 3 etd->flags_mask = mask;
396 } else {
397 6 etd->flags_mask = -1;
398 }
399 }
400 37 ENTER;
401 37 SAVETMPS;
402 37 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 37 37
403 37 ▶ mXPUSHs(newSVpvs("Enum::Declare::Meta"));
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(newSVpvs("Enum::Declare::Meta")); 0 37 37
404 37 ▶ mXPUSHs(newSVpvs("enum_name")); mXPUSHs(newSVsv(name_sv));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("enum_name")); mXPUSHs(newSVsv(name_sv)); 0 37 37
mXPUSHs(newSVpvs("enum_name")); mXPUSHs(newSVsv(name_sv)); 0 37 37
405 37 ▶ mXPUSHs(newSVpvs("package")); mXPUSHs(newSVpvn(pkg, pkg_len));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("package")); mXPUSHs(newSVpvn(pkg, pkg_len)); 0 37 37
mXPUSHs(newSVpvs("package")); mXPUSHs(newSVpvn(pkg, pkg_len)); 0 37 37
406 37 ▶ mXPUSHs(newSVpvs("names")); mXPUSHs(newRV_noinc((SV*)d->names));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("names")); mXPUSHs(newRV_noinc((SV*)d->names)); 0 37 37
mXPUSHs(newSVpvs("names")); mXPUSHs(newRV_noinc((SV*)d->names)); 0 37 37
407 37 ▶ mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)d->values));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)d->values)); 0 37 37
mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)d->values)); 0 37 37
408 37 ▶ mXPUSHs(newSVpvs("name2val")); mXPUSHs(newRV_noinc((SV*)d->name2val));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("name2val")); mXPUSHs(newRV_noinc((SV*)d->name2val)); 0 37 37
mXPUSHs(newSVpvs("name2val")); mXPUSHs(newRV_noinc((SV*)d->name2val)); 0 37 37
409 37 ▶ mXPUSHs(newSVpvs("val2name")); mXPUSHs(newRV_noinc((SV*)d->val2name));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("val2name")); mXPUSHs(newRV_noinc((SV*)d->val2name)); 0 37 37
mXPUSHs(newSVpvs("val2name")); mXPUSHs(newRV_noinc((SV*)d->val2name)); 0 37 37
410 37 PUTBACK;
411 37 call_method("new", G_SCALAR);
412 37 SPAGAIN;
413 37 meta = SvREFCNT_inc(POPs);
414 37 PUTBACK;
415 37 ▶ FREETMPS;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; 37 0 37
416 37 LEAVE;
417 {
418 37 HV *registry = get_hv("Enum::Declare::_registry", GV_ADD);
419 37 SV *key = newSVpvf("%s::%s", pkg, ename);
420 37 hv_store_ent(registry, key, newSVsv(meta), 0);
421 37 SvREFCNT_dec(key);
422 }
423 37 newCONSTSUB(gv_stashpvn(pkg, pkg_len, GV_ADD), ename, meta);
424 37 ▶ if (is_type && etd) {
Branch: 2 branches
BranchTrueFalseTotal
if (is_type && etd) { 9 28 37
if (is_type && etd) { 9 0 9
425 9 object_register_type_xs_ex(aTHX_ ename,
426 enum_type_check, enum_type_coerce, (void*)etd);
427 }
428 37 }
429  
430 47 XS_INTERNAL(xs_enum_stub) {
431 47 dXSARGS;
432 PERL_UNUSED_VAR(items);
433 47 XSRETURN_EMPTY;
434 }
435  
436 typedef struct {
437 SV *meta; /* the Enum::Declare::Meta object this set type is bound to */
438 const char *set_name;
439 SV *set_instance; /* the singleton Set used as the type constraint */
440 } EnumSetTypeData;
441  
442 14 static bool enumset_type_check(pTHX_ SV *val, void *data_ptr) {
443 14 EnumSetTypeData *estd = (EnumSetTypeData *)data_ptr;
444 SV *result_sv;
445 bool result;
446 14 dSP;
447 14 ▶ if (sv_isobject(val))
Branch: 1 branch
BranchTrueFalseTotal
if (sv_isobject(val)) 1 13 14
448 1 return false;
449 13 ENTER; SAVETMPS;
450 13 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 13 13
451 13 ▶ XPUSHs(estd->set_instance);
Branch: 1 branch
BranchTrueFalseTotal
XPUSHs(estd->set_instance); 0 13 13
452 13 ▶ XPUSHs(val);
Branch: 1 branch
BranchTrueFalseTotal
XPUSHs(val); 0 13 13
453 13 PUTBACK;
454 13 call_method("has", G_SCALAR);
455 13 SPAGAIN;
456 13 result_sv = POPs;
457 13 result = SvTRUE(result_sv);
458 13 PUTBACK;
459 13 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 13 0 13
460 13 return result;
461 }
462  
463 14 static SV *enumset_type_coerce(pTHX_ SV *val, void *data_ptr) {
464 PERL_UNUSED_ARG(data_ptr);
465 14 return val;
466 }
467  
468 0 XS_INTERNAL(xs_enumset_constructor) {
469 0 dXSARGS;
470 0 SV *meta_sv = (SV*)XSANY.any_ptr;
471 SV *set;
472 AV *vals_av;
473 I32 i;
474  
475 0 vals_av = newAV();
476 0 ▶ for (i = 0; i < items; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < items; i++) { 0 0 0
477 0 av_push(vals_av, newSVsv(ST(i)));
478 }
479  
480 0 ENTER; SAVETMPS;
481 0 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 0 0
482 0 ▶ mXPUSHs(newSVpvs("Enum::Declare::Set"));
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(newSVpvs("Enum::Declare::Set")); 0 0 0
483 0 ▶ mXPUSHs(newSVpvs("meta")); XPUSHs(meta_sv);
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("meta")); XPUSHs(meta_sv); 0 0 0
mXPUSHs(newSVpvs("meta")); XPUSHs(meta_sv); 0 0 0
484 0 ▶ mXPUSHs(newSVpvs("name")); mXPUSHs(newSVpvn(GvNAME(CvGV(cv)), GvNAMELEN(CvGV(cv))));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("name")); mXPUSHs(newSVpvn(GvNAME(CvGV(cv)), GvNAMELEN(CvGV(cv)))); 0 0 0
mXPUSHs(newSVpvs("name")); mXPUSHs(newSVpvn(GvNAME(CvGV(cv)), GvNAMELEN(CvGV(cv)))); 0 0 0
485 0 ▶ mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)vals_av));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)vals_av)); 0 0 0
mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)vals_av)); 0 0 0
486 0 PUTBACK;
487 0 call_method("new", G_SCALAR);
488 0 SPAGAIN;
489 0 set = SvREFCNT_inc(POPs);
490 0 PUTBACK;
491 0 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 0 0 0
492  
493 0 ST(0) = sv_2mortal(set);
494 0 XSRETURN(1);
495 }
496  
497 10 static SV * lookup_enum_meta(pTHX_ const char *pkg, const char *enum_name) {
498 10 HV *registry = get_hv("Enum::Declare::_registry", 0);
499 SV *key;
500 HE *he;
501 10 ▶ if (!registry) return NULL;
Branch: 1 branch
BranchTrueFalseTotal
if (!registry) return NULL; 0 10 10
502 10 key = newSVpvf("%s::%s", pkg, enum_name);
503 10 he = hv_fetch_ent(registry, key, 0, 0);
504 10 SvREFCNT_dec(key);
505 10 ▶ if (!he) return NULL;
Branch: 1 branch
BranchTrueFalseTotal
if (!he) return NULL; 0 10 10
506 10 return HeVAL(he);
507 }
508  
509 4 static AV *lex_read_set_members(pTHX) {
510 4 AV *av = newAV();
511 I32 c;
512 4 lex_read_space(0);
513 4 c = lex_peek_unichar(0);
514 4 ▶ if (c != '{') croak("Expected '{' in enumSet declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (c != '{') croak("Expected '{' in enumSet declaration"); 0 4 4
515 4 lex_read_unichar(0);
516 5 while (1) {
517 SV *vname;
518 9 lex_read_space(0);
519 9 c = lex_peek_unichar(0);
520 9 ▶ if (c == '}') { lex_read_unichar(0); break; }
Branch: 1 branch
BranchTrueFalseTotal
if (c == '}') { lex_read_unichar(0); break; } 4 5 9
521 5 ▶ if (c == -1) croak("Unexpected end of input in enumSet declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (c == -1) croak("Unexpected end of input in enumSet declaration"); 0 5 5
522 5 vname = lex_read_ident(aTHX);
523 5 ▶ if (!vname) croak("Expected variant name in enumSet declaration");
Branch: 1 branch
BranchTrueFalseTotal
if (!vname) croak("Expected variant name in enumSet declaration"); 0 5 5
524 5 av_push(av, vname);
525 5 lex_read_space(0);
526 5 ▶ if (lex_peek_unichar(0) == ',') lex_read_unichar(0);
Branch: 1 branch
BranchTrueFalseTotal
if (lex_peek_unichar(0) == ',') lex_read_unichar(0); 2 3 5
527 }
528 4 return av;
529 }
530  
531 10 static SV *split_enum_from_attrs(pTHX_ SV **attr_sv_ptr) {
532 10 SV *attr_sv = *attr_sv_ptr;
533 SV *enum_name_sv;
534 const char *attr_pv;
535 STRLEN attr_len;
536 char *last_comma;
537  
538 10 ▶ if (attr_sv == &PL_sv_undef)
Branch: 1 branch
BranchTrueFalseTotal
if (attr_sv == &PL_sv_undef) 0 10 10
539 0 croak("Expected ':EnumName' binding in enumSet declaration");
540  
541 10 attr_pv = SvPV(attr_sv, attr_len);
542 10 last_comma = strrchr(attr_pv, ',');
543  
544 10 ▶ if (last_comma) {
Branch: 1 branch
BranchTrueFalseTotal
if (last_comma) { 3 7 10
545 3 enum_name_sv = newSVpv(last_comma + 1, 0);
546 3 SvCUR_set(attr_sv, last_comma - attr_pv);
547 3 *SvEND(attr_sv) = '\0';
548 } else {
549 7 enum_name_sv = newSVsv(attr_sv);
550 7 SvREFCNT_dec(attr_sv);
551 7 *attr_sv_ptr = &PL_sv_undef;
552 }
553 10 return enum_name_sv;
554 }
555  
556 4 static SV *build_frozen_set(pTHX_ AV *member_names, SV *meta, SV *set_name_sv, SV *enum_name_sv) {
557 4 AV *vals_av = newAV();
558 SV *set_obj;
559 I32 i;
560 4 dSP;
561 9 ▶ for (i = 0; i <= av_len(member_names); i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i <= av_len(member_names); i++) { 5 4 9
562 5 SV **name_p = av_fetch(member_names, i, 0);
563 5 ▶ if (name_p) {
Branch: 1 branch
BranchTrueFalseTotal
if (name_p) { 5 0 5
564 SV *val, *val_copy;
565 5 const char *vname = SvPV_nolen(*name_p);
566 5 ENTER; SAVETMPS;
567 5 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 5 5
568 5 ▶ XPUSHs(meta);
Branch: 1 branch
BranchTrueFalseTotal
XPUSHs(meta); 0 5 5
569 5 ▶ mXPUSHs(newSVpv(vname, 0));
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(newSVpv(vname, 0)); 0 5 5
570 5 PUTBACK;
571 5 call_method("value", G_SCALAR);
572 5 SPAGAIN;
573 5 val = POPs;
574 5 PUTBACK;
575 5 ▶ if (!SvOK(val)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!SvOK(val)) { 0 5 5
576 0 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 0 0 0
577 0 ▶ croak("enumSet %s: '%s' is not a variant of %s",
Branch: 1 branch
BranchTrueFalseTotal
croak("enumSet %s: '%s' is not a variant of %s", 0 0 0
578 SvPV_nolen(set_name_sv), vname, SvPV_nolen(enum_name_sv));
579 }
580 5 val_copy = newSVsv(val);
581 5 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 5 0 5
582 5 av_push(vals_av, val_copy);
583 }
584 }
585 4 ENTER; SAVETMPS;
586 4 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 4 4
587 4 ▶ mXPUSHs(newSVpvs("Enum::Declare::Set"));
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(newSVpvs("Enum::Declare::Set")); 0 4 4
588 4 ▶ mXPUSHs(newSVpvs("meta")); XPUSHs(meta);
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("meta")); XPUSHs(meta); 0 4 4
mXPUSHs(newSVpvs("meta")); XPUSHs(meta); 0 4 4
589 4 ▶ mXPUSHs(newSVpvs("name")); XPUSHs(set_name_sv);
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("name")); XPUSHs(set_name_sv); 0 4 4
mXPUSHs(newSVpvs("name")); XPUSHs(set_name_sv); 0 4 4
590 4 ▶ mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)vals_av));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)vals_av)); 0 4 4
mXPUSHs(newSVpvs("values")); mXPUSHs(newRV_noinc((SV*)vals_av)); 0 4 4
591 4 ▶ mXPUSHs(newSVpvs("frozen")); mXPUSHs(newSViv(1));
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("frozen")); mXPUSHs(newSViv(1)); 0 4 4
mXPUSHs(newSVpvs("frozen")); mXPUSHs(newSViv(1)); 0 4 4
592 4 PUTBACK;
593 4 call_method("new", G_SCALAR);
594 4 SPAGAIN;
595 4 set_obj = SvREFCNT_inc(POPs);
596 4 PUTBACK;
597 4 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 4 0 4
598 4 return set_obj;
599 }
600  
601 6 static SV *build_mutable_set(pTHX_ SV *meta, SV *set_name_sv) {
602 SV *set_obj;
603 6 dSP;
604 6 ENTER; SAVETMPS;
605 6 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 6 6
606 6 ▶ mXPUSHs(newSVpvs("Enum::Declare::Set"));
Branch: 1 branch
BranchTrueFalseTotal
mXPUSHs(newSVpvs("Enum::Declare::Set")); 0 6 6
607 6 ▶ mXPUSHs(newSVpvs("meta")); XPUSHs(meta);
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("meta")); XPUSHs(meta); 0 6 6
mXPUSHs(newSVpvs("meta")); XPUSHs(meta); 0 6 6
608 6 ▶ mXPUSHs(newSVpvs("name")); XPUSHs(set_name_sv);
Branch: 2 branches
BranchTrueFalseTotal
mXPUSHs(newSVpvs("name")); XPUSHs(set_name_sv); 0 6 6
mXPUSHs(newSVpvs("name")); XPUSHs(set_name_sv); 0 6 6
609 6 PUTBACK;
610 6 call_method("new", G_SCALAR);
611 6 SPAGAIN;
612 6 set_obj = SvREFCNT_inc(POPs);
613 6 PUTBACK;
614 6 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 6 0 6
615 6 return set_obj;
616 }
617  
618 3 static void register_enumset_type(pTHX_ const char *pkg, SV *set_name_sv, SV *meta) {
619 EnumSetTypeData *estd;
620 SV *fqn, *singleton;
621 GV *gv;
622 3 dSP;
623 3 Newxz(estd, 1, EnumSetTypeData);
624 3 estd->meta = SvREFCNT_inc(meta);
625 3 ▶ estd->set_name = savepv(SvPV_nolen(set_name_sv));
Branch: 1 branch
BranchTrueFalseTotal
estd->set_name = savepv(SvPV_nolen(set_name_sv)); 3 0 3
626 3 fqn = newSVpvf("%s::%s", pkg, SvPV_nolen(set_name_sv));
627 6 ▶ gv = gv_fetchpvn_flags(SvPV_nolen(fqn), SvCUR(fqn), 0, SVt_PV);
Branch: 1 branch
BranchTrueFalseTotal
gv = gv_fetchpvn_flags(SvPV_nolen(fqn), SvCUR(fqn), 0, SVt_PV); 3 0 3
628 3 SvREFCNT_dec(fqn);
629 3 ▶ if (gv && GvCV(gv)) {
Branch: 2 branches
BranchTrueFalseTotal
if (gv && GvCV(gv)) { 3 0 3
if (gv && GvCV(gv)) { 3 0 3
630 3 ENTER; SAVETMPS;
631 3 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 3 3
632 3 PUTBACK;
633 3 call_sv((SV*)GvCV(gv), G_SCALAR);
634 3 SPAGAIN;
635 3 singleton = SvREFCNT_inc(POPs);
636 3 PUTBACK;
637 3 ▶ FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
FREETMPS; LEAVE; 0 3 3
638 } else {
639 0 croak("enumSet %s: failed to retrieve singleton", SvPV_nolen(set_name_sv));
640 }
641 3 estd->set_instance = singleton;
642 3 object_register_type_xs_ex(aTHX_ SvPV_nolen(set_name_sv), enumset_type_check, enumset_type_coerce, (void*)estd);
643 3 }
644  
645 10 static OP *enumset_parser_callback(pTHX_ GV *namegv, SV *psobj, U32 *flagsp) {
646 SV *set_name_sv;
647 SV *attr_sv;
648 SV *enum_name_sv;
649 SV *meta;
650 const char *pkg;
651 STRLEN pkg_len;
652 int is_export, is_type;
653 PERL_UNUSED_ARG(namegv);
654 PERL_UNUSED_ARG(psobj);
655 10 lex_read_space(0);
656 10 set_name_sv = lex_read_ident(aTHX);
657 10 ▶ if (!set_name_sv) croak("Expected enumSet name");
Branch: 1 branch
BranchTrueFalseTotal
if (!set_name_sv) croak("Expected enumSet name"); 0 10 10
658 10 lex_read_space(0);
659 10 attr_sv = lex_read_attrs(aTHX);
660 10 enum_name_sv = split_enum_from_attrs(aTHX_ &attr_sv);
661 10 ▶ pkg = HvNAME(PL_curstash);
Branch: 6 branches
BranchTrueFalseTotal
pkg = HvNAME(PL_curstash); 10 0 10
pkg = HvNAME(PL_curstash); 10 0 10
pkg = HvNAME(PL_curstash); 0 10 10
pkg = HvNAME(PL_curstash); 0 0 0
pkg = HvNAME(PL_curstash); 10 0 10
pkg = HvNAME(PL_curstash); 0 10 10
662 10 pkg_len = strlen(pkg);
663 10 is_export = has_attr(aTHX_ attr_sv, "Export");
664 10 is_type = has_attr(aTHX_ attr_sv, "Type");
665 10 meta = lookup_enum_meta(aTHX_ pkg, SvPV_nolen(enum_name_sv));
666 10 ▶ if (!meta)
Branch: 1 branch
BranchTrueFalseTotal
if (!meta) 0 10 10
667 0 ▶ croak("enumSet %s: unknown enum '%s' in package %s",
Branch: 1 branch
BranchTrueFalseTotal
croak("enumSet %s: unknown enum '%s' in package %s", 0 0 0
668 SvPV_nolen(set_name_sv), SvPV_nolen(enum_name_sv), pkg);
669 10 lex_read_space(0);
670 10 ▶ if (lex_peek_unichar(0) == '{') {
Branch: 1 branch
BranchTrueFalseTotal
if (lex_peek_unichar(0) == '{') { 4 6 10
671 4 AV *member_names = lex_read_set_members(aTHX);
672 4 SV *set_obj = build_frozen_set(aTHX_ member_names, meta, set_name_sv, enum_name_sv);
673 4 newCONSTSUB(gv_stashpvn(pkg, pkg_len, GV_ADD),
674 SvPV_nolen(set_name_sv), set_obj);
675 4 SvREFCNT_dec((SV*)member_names);
676 } else {
677 6 SV *set_obj = build_mutable_set(aTHX_ meta, set_name_sv);
678 6 newCONSTSUB(gv_stashpvn(pkg, pkg_len, GV_ADD),
679 SvPV_nolen(set_name_sv), set_obj);
680 }
681 10 ▶ if (is_export) {
Branch: 1 branch
BranchTrueFalseTotal
if (is_export) { 0 10 10
682 0 AV *name_list = newAV();
683 0 av_push(name_list, newSVsv(set_name_sv));
684 0 setup_exports(aTHX_ pkg, pkg_len, name_list, NULL);
685 0 SvREFCNT_dec((SV*)name_list);
686 }
687 10 ▶ if (is_type)
Branch: 1 branch
BranchTrueFalseTotal
if (is_type) 3 7 10
688 3 register_enumset_type(aTHX_ pkg, set_name_sv, meta);
689 10 ▶ if (attr_sv != &PL_sv_undef) SvREFCNT_dec(attr_sv);
Branch: 1 branch
BranchTrueFalseTotal
if (attr_sv != &PL_sv_undef) SvREFCNT_dec(attr_sv); 3 7 10
690 10 SvREFCNT_dec(set_name_sv);
691 10 SvREFCNT_dec(enum_name_sv);
692 10 *flagsp |= CALLPARSER_STATEMENT;
693 10 return newNULLLIST();
694 }
695  
696 37 static OP *enum_parser_callback(pTHX_ GV *namegv, SV *psobj, U32 *flagsp) {
697 SV *name_sv;
698 SV *attr_sv;
699 AV *variants;
700 const char *pkg;
701 STRLEN pkg_len;
702 EnumData data;
703 int is_flags;
704 PERL_UNUSED_ARG(namegv);
705 PERL_UNUSED_ARG(psobj);
706 37 lex_read_space(0);
707 37 name_sv = lex_read_ident(aTHX);
708 37 ▶ if (!name_sv) croak("Expected enum name");
Branch: 1 branch
BranchTrueFalseTotal
if (!name_sv) croak("Expected enum name"); 0 37 37
709 37 lex_read_space(0);
710 37 attr_sv = lex_read_attrs(aTHX);
711 37 variants = lex_read_variants(aTHX);
712 37 ▶ pkg = HvNAME(PL_curstash);
Branch: 6 branches
BranchTrueFalseTotal
pkg = HvNAME(PL_curstash); 37 0 37
pkg = HvNAME(PL_curstash); 37 0 37
pkg = HvNAME(PL_curstash); 0 37 37
pkg = HvNAME(PL_curstash); 0 0 0
pkg = HvNAME(PL_curstash); 37 0 37
pkg = HvNAME(PL_curstash); 0 37 37
713 37 pkg_len = strlen(pkg);
714 37 is_flags = has_attr(aTHX_ attr_sv, "Flags");
715 37 data = build_enum_data(aTHX_ variants,
716 has_attr(aTHX_ attr_sv, "Str"),
717 is_flags,
718 pkg, pkg_len
719 );
720 37 ▶ if (has_attr(aTHX_ attr_sv, "Export"))
Branch: 1 branch
BranchTrueFalseTotal
if (has_attr(aTHX_ attr_sv, "Export")) 5 32 37
721 5 setup_exports(aTHX_ pkg, pkg_len, data.names, name_sv);
722 37 install_meta(aTHX_ name_sv, pkg, pkg_len, &data, is_flags,
723 has_attr(aTHX_ attr_sv, "Type"));
724 37 ▶ if (attr_sv != &PL_sv_undef) SvREFCNT_dec(attr_sv);
Branch: 1 branch
BranchTrueFalseTotal
if (attr_sv != &PL_sv_undef) SvREFCNT_dec(attr_sv); 25 12 37
725 37 SvREFCNT_dec(name_sv);
726 37 SvREFCNT_dec((SV*)variants);
727 37 *flagsp |= CALLPARSER_STATEMENT;
728 37 return newNULLLIST();
729 }
730  
731 MODULE = Enum::Declare PACKAGE = Enum::Declare
732 PROTOTYPES: DISABLE
733  
734 void import(...)
735 CODE:
736 {
737 37 ▶ const char *caller = CopSTASHPV(PL_curcop);
Branch: 7 branches
BranchTrueFalseTotal
const char *caller = CopSTASHPV(PL_curcop); 37 0 37
const char *caller = CopSTASHPV(PL_curcop); 37 0 37
const char *caller = CopSTASHPV(PL_curcop); 37 0 37
const char *caller = CopSTASHPV(PL_curcop); 0 37 37
const char *caller = CopSTASHPV(PL_curcop); 0 0 0
const char *caller = CopSTASHPV(PL_curcop); 37 0 37
const char *caller = CopSTASHPV(PL_curcop); 0 37 37
738 37 SV *fqn = newSVpvf("%s::enum", caller);
739 37 CV *cv = newXS(SvPV_nolen(fqn), xs_enum_stub, __FILE__);
740 37 cv_set_call_parser(cv, enum_parser_callback, &PL_sv_undef);
741 37 SvREFCNT_dec(fqn);
742 37 fqn = newSVpvf("%s::enumSet", caller);
743 37 cv = newXS(SvPV_nolen(fqn), xs_enum_stub, __FILE__);
744 37 cv_set_call_parser(cv, enumset_parser_callback, &PL_sv_undef);
745 37 SvREFCNT_dec(fqn);
746 }
« blib/lib/Enum/Declare/Meta.pm ↑ Summary blib/lib/Enum/Declare.pm »