lib/Clownfish.xs

filter: Statementstmt 30.8% 601 / 1948 Branchbran 18.6% 72 / 386 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 28.8% 673 / 2334 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« autogen/include/Clownfish/Vector.h ↑ Summary lib/Clownfish/Test.xs »
1 /*
2 * ***********************************************
3 *
4 * !!!! DO NOT EDIT !!!!
5 *
6 * This file was auto-generated by Build.PL.
7 *
8 * ***********************************************
9 *
10 * Licensed to the Apache Software Foundation (ASF) under one or more
11 * contributor license agreements. See the NOTICE file distributed with
12 * this work for additional information regarding copyright ownership.
13 * The ASF licenses this file to You under the Apache License, Version 2.0
14 * (the "License"); you may not use this file except in compliance with
15 * the License. You may obtain a copy of the License at
16 *
17 * http://www.apache.org/licenses/LICENSE-2.0
18 *
19 * Unless required by applicable law or agreed to in writing, software
20 * distributed under the License is distributed on an "AS IS" BASIS,
21 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22 * See the License for the specific language governing permissions and
23 * limitations under the License.
24 */
25  
26 #define CFP_CFISH
27  
28 #include "XSBind.h"
29 #include "cfish_perl.h"
30 #include "Clownfish/Obj.h"
31 #include "Clownfish/Blob.h"
32 #include "Clownfish/Boolean.h"
33 #include "Clownfish/ByteBuf.h"
34 #include "Clownfish/CharBuf.h"
35 #include "Clownfish/Class.h"
36 #include "Clownfish/Err.h"
37 #include "Clownfish/Num.h"
38 #include "Clownfish/Hash.h"
39 #include "Clownfish/HashIterator.h"
40 #include "Clownfish/Num.h"
41 #include "Clownfish/Method.h"
42 #include "Clownfish/String.h"
43 #include "Clownfish/String.h"
44 #include "Clownfish/TestHarness/TestBatch.h"
45 #include "Clownfish/TestHarness/TestBatchRunner.h"
46 #include "Clownfish/TestHarness/TestFormatter.h"
47 #include "Clownfish/TestHarness/TestFormatter.h"
48 #include "Clownfish/TestHarness/TestFormatter.h"
49 #include "Clownfish/TestHarness/TestSuite.h"
50 #include "Clownfish/TestHarness/TestSuiteRunner.h"
51 #include "Clownfish/Vector.h"
52 #include "Clownfish/TestHarness/TestUtils.h"
53 #include "Clownfish/Util/Memory.h"
54 #include "Clownfish/Util/SortUtils.h"
55  
56 #ifndef XS_INTERNAL
57 #define XS_INTERNAL XS
58 #endif
59  
60 XS_INTERNAL(XS_Clownfish_Obj_new);
61 9 XS_INTERNAL(XS_Clownfish_Obj_new) {
62 9 dXSARGS;
63 cfish_Obj* arg_self;
64 cfish_Obj* retval;
65  
66 CFISH_UNUSED_VAR(cv);
67 9 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 1 8 9
68 1 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
69 }
70 8 SP -= items;
71  
72 8 arg_self = (cfish_Obj*)XSBind_new_blank_obj(aTHX_ ST(0));
73  
74 8 retval = cfish_Obj_init(arg_self);
75 8 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
76 8 XSRETURN(1);
77 }
78  
79  
80 XS_INTERNAL(XS_Clownfish_Obj_clone);
81 1 XS_INTERNAL(XS_Clownfish_Obj_clone) {
82 1 dXSARGS;
83 cfish_Obj* arg_self;
84 CFISH_Obj_Clone_t method;
85 cfish_Obj* retval;
86  
87 CFISH_UNUSED_VAR(cv);
88 1 SP -= items;
89 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
90 0 XSBind_invalid_args_error(aTHX_ cv, "self");
91 }
92  
93 /* Extract vars from Perl stack. */
94 1 arg_self = (cfish_Obj*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_OBJ, NULL);
95  
96 /* Execute */
97 1 method = CFISH_METHOD_PTR(CFISH_OBJ, CFISH_Obj_Clone);
98 1 retval = method(arg_self);
99 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
100 0 CFISH_DECREF(retval);
101 0 sv_2mortal( ST(0) );
102 0 XSRETURN(1);
103 }
104  
105 XS_INTERNAL(XS_Clownfish_Obj_equals);
106 0 XS_INTERNAL(XS_Clownfish_Obj_equals) {
107 0 dXSARGS;
108 SV *sv;
109 cfish_Obj* arg_self;
110 cfish_Obj* arg_other;
111 CFISH_Obj_Equals_t method;
112 bool retval;
113  
114 CFISH_UNUSED_VAR(cv);
115 0 SP -= items;
116 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
117 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
118 }
119  
120 /* Extract vars from Perl stack. */
121 0 arg_self = (cfish_Obj*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_OBJ, NULL);
122 0 sv = ST(1);
123 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
124  
125 /* Execute */
126 0 method = CFISH_METHOD_PTR(CFISH_OBJ, CFISH_Obj_Equals);
127 0 retval = method(arg_self, arg_other);
128 0 ST(0) = newSViv(!!retval);
129 0 sv_2mortal( ST(0) );
130 0 XSRETURN(1);
131 }
132  
133 XS_INTERNAL(XS_Clownfish_Obj_compare_to);
134 0 XS_INTERNAL(XS_Clownfish_Obj_compare_to) {
135 0 dXSARGS;
136 SV *sv;
137 cfish_Obj* arg_self;
138 cfish_Obj* arg_other;
139 CFISH_Obj_Compare_To_t method;
140 int32_t retval;
141  
142 CFISH_UNUSED_VAR(cv);
143 0 SP -= items;
144 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
145 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
146 }
147  
148 /* Extract vars from Perl stack. */
149 0 arg_self = (cfish_Obj*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_OBJ, NULL);
150 0 sv = ST(1);
151 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
152  
153 /* Execute */
154 0 method = CFISH_METHOD_PTR(CFISH_OBJ, CFISH_Obj_Compare_To);
155 0 retval = method(arg_self, arg_other);
156 0 ST(0) = newSViv(retval);
157 0 sv_2mortal( ST(0) );
158 0 XSRETURN(1);
159 }
160  
161 XS_INTERNAL(XS_Clownfish_Obj_to_string);
162 1 XS_INTERNAL(XS_Clownfish_Obj_to_string) {
163 1 dXSARGS;
164 cfish_Obj* arg_self;
165 CFISH_Obj_To_String_t method;
166 cfish_String* retval;
167  
168 CFISH_UNUSED_VAR(cv);
169 1 SP -= items;
170 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
171 0 XSBind_invalid_args_error(aTHX_ cv, "self");
172 }
173  
174 /* Extract vars from Perl stack. */
175 1 arg_self = (cfish_Obj*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_OBJ, NULL);
176  
177 /* Execute */
178 1 method = CFISH_METHOD_PTR(CFISH_OBJ, CFISH_Obj_To_String);
179 1 retval = method(arg_self);
180 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
181 1 CFISH_DECREF(retval);
182 1 sv_2mortal( ST(0) );
183 1 XSRETURN(1);
184 }
185  
186 XS_INTERNAL(XS_Clownfish_Blob_get_size);
187 1 XS_INTERNAL(XS_Clownfish_Blob_get_size) {
188 1 dXSARGS;
189 cfish_Blob* arg_self;
190 CFISH_Blob_Get_Size_t method;
191 size_t retval;
192  
193 CFISH_UNUSED_VAR(cv);
194 1 SP -= items;
195 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
196 0 XSBind_invalid_args_error(aTHX_ cv, "self");
197 }
198  
199 /* Extract vars from Perl stack. */
200 1 arg_self = (cfish_Blob*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BLOB, NULL);
201  
202 /* Execute */
203 1 method = CFISH_METHOD_PTR(CFISH_BLOB, CFISH_Blob_Get_Size);
204 1 retval = method(arg_self);
205 1 ST(0) = newSViv(retval);
206 1 sv_2mortal( ST(0) );
207 1 XSRETURN(1);
208 }
209  
210 XS_INTERNAL(XS_Clownfish_Blob_equals);
211 3 XS_INTERNAL(XS_Clownfish_Blob_equals) {
212 3 dXSARGS;
213 SV *sv;
214 cfish_Blob* arg_self;
215 cfish_Obj* arg_other;
216 CFISH_Blob_Equals_t method;
217 bool retval;
218  
219 CFISH_UNUSED_VAR(cv);
220 3 SP -= items;
221 3 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 3 3
222 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
223 }
224  
225 /* Extract vars from Perl stack. */
226 3 arg_self = (cfish_Blob*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BLOB, NULL);
227 3 sv = ST(1);
228 3 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
229  
230 /* Execute */
231 3 method = CFISH_METHOD_PTR(CFISH_BLOB, CFISH_Blob_Equals);
232 3 retval = method(arg_self, arg_other);
233 3 ST(0) = newSViv(!!retval);
234 3 sv_2mortal( ST(0) );
235 3 XSRETURN(1);
236 }
237  
238 XS_INTERNAL(XS_Clownfish_Blob_compare_to);
239 1 XS_INTERNAL(XS_Clownfish_Blob_compare_to) {
240 1 dXSARGS;
241 SV *sv;
242 cfish_Blob* arg_self;
243 cfish_Obj* arg_other;
244 CFISH_Blob_Compare_To_t method;
245 int32_t retval;
246  
247 CFISH_UNUSED_VAR(cv);
248 1 SP -= items;
249 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
250 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
251 }
252  
253 /* Extract vars from Perl stack. */
254 1 arg_self = (cfish_Blob*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BLOB, NULL);
255 1 sv = ST(1);
256 1 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
257  
258 /* Execute */
259 1 method = CFISH_METHOD_PTR(CFISH_BLOB, CFISH_Blob_Compare_To);
260 1 retval = method(arg_self, arg_other);
261 1 ST(0) = newSViv(retval);
262 1 sv_2mortal( ST(0) );
263 1 XSRETURN(1);
264 }
265  
266 XS_INTERNAL(XS_Clownfish_Blob_clone);
267 0 XS_INTERNAL(XS_Clownfish_Blob_clone) {
268 0 dXSARGS;
269 cfish_Blob* arg_self;
270 CFISH_Blob_Clone_t method;
271 cfish_Blob* retval;
272  
273 CFISH_UNUSED_VAR(cv);
274 0 SP -= items;
275 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
276 0 XSBind_invalid_args_error(aTHX_ cv, "self");
277 }
278  
279 /* Extract vars from Perl stack. */
280 0 arg_self = (cfish_Blob*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BLOB, NULL);
281  
282 /* Execute */
283 0 method = CFISH_METHOD_PTR(CFISH_BLOB, CFISH_Blob_Clone);
284 0 retval = method(arg_self);
285 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
286 0 CFISH_DECREF(retval);
287 0 sv_2mortal( ST(0) );
288 0 XSRETURN(1);
289 }
290  
291 XS_INTERNAL(XS_Clownfish_Boolean_get_value);
292 2 XS_INTERNAL(XS_Clownfish_Boolean_get_value) {
293 2 dXSARGS;
294 cfish_Boolean* arg_self;
295 CFISH_Bool_Get_Value_t method;
296 bool retval;
297  
298 CFISH_UNUSED_VAR(cv);
299 2 SP -= items;
300 2 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 2 2
301 0 XSBind_invalid_args_error(aTHX_ cv, "self");
302 }
303  
304 /* Extract vars from Perl stack. */
305 2 arg_self = (cfish_Boolean*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BOOLEAN, NULL);
306  
307 /* Execute */
308 2 method = CFISH_METHOD_PTR(CFISH_BOOLEAN, CFISH_Bool_Get_Value);
309 2 retval = method(arg_self);
310 2 ST(0) = newSViv(!!retval);
311 2 sv_2mortal( ST(0) );
312 2 XSRETURN(1);
313 }
314  
315 XS_INTERNAL(XS_Clownfish_Boolean_clone);
316 0 XS_INTERNAL(XS_Clownfish_Boolean_clone) {
317 0 dXSARGS;
318 cfish_Boolean* arg_self;
319 CFISH_Bool_Clone_t method;
320 cfish_Boolean* retval;
321  
322 CFISH_UNUSED_VAR(cv);
323 0 SP -= items;
324 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
325 0 XSBind_invalid_args_error(aTHX_ cv, "self");
326 }
327  
328 /* Extract vars from Perl stack. */
329 0 arg_self = (cfish_Boolean*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BOOLEAN, NULL);
330  
331 /* Execute */
332 0 method = CFISH_METHOD_PTR(CFISH_BOOLEAN, CFISH_Bool_Clone);
333 0 retval = method(arg_self);
334 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
335 0 CFISH_DECREF(retval);
336 0 sv_2mortal( ST(0) );
337 0 XSRETURN(1);
338 }
339  
340 XS_INTERNAL(XS_Clownfish_Boolean_equals);
341 3 XS_INTERNAL(XS_Clownfish_Boolean_equals) {
342 3 dXSARGS;
343 SV *sv;
344 cfish_Boolean* arg_self;
345 cfish_Obj* arg_other;
346 CFISH_Bool_Equals_t method;
347 bool retval;
348  
349 CFISH_UNUSED_VAR(cv);
350 3 SP -= items;
351 3 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 3 3
352 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
353 }
354  
355 /* Extract vars from Perl stack. */
356 3 arg_self = (cfish_Boolean*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BOOLEAN, NULL);
357 3 sv = ST(1);
358 3 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
359  
360 /* Execute */
361 3 method = CFISH_METHOD_PTR(CFISH_BOOLEAN, CFISH_Bool_Equals);
362 3 retval = method(arg_self, arg_other);
363 3 ST(0) = newSViv(!!retval);
364 3 sv_2mortal( ST(0) );
365 3 XSRETURN(1);
366 }
367  
368 XS_INTERNAL(XS_Clownfish_Boolean_to_string);
369 1 XS_INTERNAL(XS_Clownfish_Boolean_to_string) {
370 1 dXSARGS;
371 cfish_Boolean* arg_self;
372 CFISH_Bool_To_String_t method;
373 cfish_String* retval;
374  
375 CFISH_UNUSED_VAR(cv);
376 1 SP -= items;
377 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
378 0 XSBind_invalid_args_error(aTHX_ cv, "self");
379 }
380  
381 /* Extract vars from Perl stack. */
382 1 arg_self = (cfish_Boolean*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BOOLEAN, NULL);
383  
384 /* Execute */
385 1 method = CFISH_METHOD_PTR(CFISH_BOOLEAN, CFISH_Bool_To_String);
386 1 retval = method(arg_self);
387 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
388 1 CFISH_DECREF(retval);
389 1 sv_2mortal( ST(0) );
390 1 XSRETURN(1);
391 }
392  
393 XS_INTERNAL(XS_Clownfish_ByteBuf_set_size);
394 1 XS_INTERNAL(XS_Clownfish_ByteBuf_set_size) {
395 1 dXSARGS;
396 SV *sv;
397 cfish_ByteBuf* arg_self;
398 size_t arg_size;
399 CFISH_BB_Set_Size_t method;
400  
401 CFISH_UNUSED_VAR(cv);
402 1 SP -= items;
403 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
404 0 XSBind_invalid_args_error(aTHX_ cv, "self, size");
405 }
406  
407 /* Extract vars from Perl stack. */
408 1 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
409 1 sv = ST(1);
410 1 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 1 1
411 0 XSBind_undef_arg_error(aTHX_ "size");
412 }
413 1 arg_size = (size_t)SvIV(sv);
414  
415 /* Execute */
416 1 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Set_Size);
417 1 method(arg_self, arg_size);
418 1 XSRETURN(0);
419 }
420  
421 XS_INTERNAL(XS_Clownfish_ByteBuf_get_size);
422 1 XS_INTERNAL(XS_Clownfish_ByteBuf_get_size) {
423 1 dXSARGS;
424 cfish_ByteBuf* arg_self;
425 CFISH_BB_Get_Size_t method;
426 size_t retval;
427  
428 CFISH_UNUSED_VAR(cv);
429 1 SP -= items;
430 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
431 0 XSBind_invalid_args_error(aTHX_ cv, "self");
432 }
433  
434 /* Extract vars from Perl stack. */
435 1 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
436  
437 /* Execute */
438 1 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Get_Size);
439 1 retval = method(arg_self);
440 1 ST(0) = newSViv(retval);
441 1 sv_2mortal( ST(0) );
442 1 XSRETURN(1);
443 }
444  
445 XS_INTERNAL(XS_Clownfish_ByteBuf_get_capacity);
446 0 XS_INTERNAL(XS_Clownfish_ByteBuf_get_capacity) {
447 0 dXSARGS;
448 cfish_ByteBuf* arg_self;
449 CFISH_BB_Get_Capacity_t method;
450 size_t retval;
451  
452 CFISH_UNUSED_VAR(cv);
453 0 SP -= items;
454 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
455 0 XSBind_invalid_args_error(aTHX_ cv, "self");
456 }
457  
458 /* Extract vars from Perl stack. */
459 0 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
460  
461 /* Execute */
462 0 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Get_Capacity);
463 0 retval = method(arg_self);
464 0 ST(0) = newSViv(retval);
465 0 sv_2mortal( ST(0) );
466 0 XSRETURN(1);
467 }
468  
469 XS_INTERNAL(XS_Clownfish_ByteBuf_cat);
470 1 XS_INTERNAL(XS_Clownfish_ByteBuf_cat) {
471 1 dXSARGS;
472 SV *sv;
473 cfish_ByteBuf* arg_self;
474 cfish_Blob* arg_blob;
475 CFISH_BB_Cat_t method;
476  
477 CFISH_UNUSED_VAR(cv);
478 1 SP -= items;
479 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
480 0 XSBind_invalid_args_error(aTHX_ cv, "self, blob");
481 }
482  
483 /* Extract vars from Perl stack. */
484 1 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
485 1 sv = ST(1);
486 1 arg_blob = (cfish_Blob*)XSBind_arg_to_cfish(aTHX_ sv, "blob", CFISH_BLOB, NULL);
487  
488 /* Execute */
489 1 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Cat);
490 1 method(arg_self, arg_blob);
491 1 XSRETURN(0);
492 }
493  
494 XS_INTERNAL(XS_Clownfish_ByteBuf_yield_blob);
495 0 XS_INTERNAL(XS_Clownfish_ByteBuf_yield_blob) {
496 0 dXSARGS;
497 cfish_ByteBuf* arg_self;
498 CFISH_BB_Yield_Blob_t method;
499 cfish_Blob* retval;
500  
501 CFISH_UNUSED_VAR(cv);
502 0 SP -= items;
503 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
504 0 XSBind_invalid_args_error(aTHX_ cv, "self");
505 }
506  
507 /* Extract vars from Perl stack. */
508 0 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
509  
510 /* Execute */
511 0 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Yield_Blob);
512 0 retval = method(arg_self);
513 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
514 0 CFISH_DECREF(retval);
515 0 sv_2mortal( ST(0) );
516 0 XSRETURN(1);
517 }
518  
519 XS_INTERNAL(XS_Clownfish_ByteBuf_utf8_to_string);
520 0 XS_INTERNAL(XS_Clownfish_ByteBuf_utf8_to_string) {
521 0 dXSARGS;
522 cfish_ByteBuf* arg_self;
523 CFISH_BB_Utf8_To_String_t method;
524 cfish_String* retval;
525  
526 CFISH_UNUSED_VAR(cv);
527 0 SP -= items;
528 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
529 0 XSBind_invalid_args_error(aTHX_ cv, "self");
530 }
531  
532 /* Extract vars from Perl stack. */
533 0 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
534  
535 /* Execute */
536 0 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Utf8_To_String);
537 0 retval = method(arg_self);
538 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
539 0 CFISH_DECREF(retval);
540 0 sv_2mortal( ST(0) );
541 0 XSRETURN(1);
542 }
543  
544 XS_INTERNAL(XS_Clownfish_ByteBuf_trusted_utf8_to_string);
545 0 XS_INTERNAL(XS_Clownfish_ByteBuf_trusted_utf8_to_string) {
546 0 dXSARGS;
547 cfish_ByteBuf* arg_self;
548 CFISH_BB_Trusted_Utf8_To_String_t method;
549 cfish_String* retval;
550  
551 CFISH_UNUSED_VAR(cv);
552 0 SP -= items;
553 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
554 0 XSBind_invalid_args_error(aTHX_ cv, "self");
555 }
556  
557 /* Extract vars from Perl stack. */
558 0 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
559  
560 /* Execute */
561 0 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Trusted_Utf8_To_String);
562 0 retval = method(arg_self);
563 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
564 0 CFISH_DECREF(retval);
565 0 sv_2mortal( ST(0) );
566 0 XSRETURN(1);
567 }
568  
569 XS_INTERNAL(XS_Clownfish_ByteBuf_equals);
570 3 XS_INTERNAL(XS_Clownfish_ByteBuf_equals) {
571 3 dXSARGS;
572 SV *sv;
573 cfish_ByteBuf* arg_self;
574 cfish_Obj* arg_other;
575 CFISH_BB_Equals_t method;
576 bool retval;
577  
578 CFISH_UNUSED_VAR(cv);
579 3 SP -= items;
580 3 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 3 3
581 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
582 }
583  
584 /* Extract vars from Perl stack. */
585 3 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
586 3 sv = ST(1);
587 3 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
588  
589 /* Execute */
590 3 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Equals);
591 3 retval = method(arg_self, arg_other);
592 3 ST(0) = newSViv(!!retval);
593 3 sv_2mortal( ST(0) );
594 3 XSRETURN(1);
595 }
596  
597 XS_INTERNAL(XS_Clownfish_ByteBuf_compare_to);
598 1 XS_INTERNAL(XS_Clownfish_ByteBuf_compare_to) {
599 1 dXSARGS;
600 SV *sv;
601 cfish_ByteBuf* arg_self;
602 cfish_Obj* arg_other;
603 CFISH_BB_Compare_To_t method;
604 int32_t retval;
605  
606 CFISH_UNUSED_VAR(cv);
607 1 SP -= items;
608 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
609 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
610 }
611  
612 /* Extract vars from Perl stack. */
613 1 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
614 1 sv = ST(1);
615 1 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
616  
617 /* Execute */
618 1 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Compare_To);
619 1 retval = method(arg_self, arg_other);
620 1 ST(0) = newSViv(retval);
621 1 sv_2mortal( ST(0) );
622 1 XSRETURN(1);
623 }
624  
625 XS_INTERNAL(XS_Clownfish_ByteBuf_clone);
626 0 XS_INTERNAL(XS_Clownfish_ByteBuf_clone) {
627 0 dXSARGS;
628 cfish_ByteBuf* arg_self;
629 CFISH_BB_Clone_t method;
630 cfish_ByteBuf* retval;
631  
632 CFISH_UNUSED_VAR(cv);
633 0 SP -= items;
634 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
635 0 XSBind_invalid_args_error(aTHX_ cv, "self");
636 }
637  
638 /* Extract vars from Perl stack. */
639 0 arg_self = (cfish_ByteBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_BYTEBUF, NULL);
640  
641 /* Execute */
642 0 method = CFISH_METHOD_PTR(CFISH_BYTEBUF, CFISH_BB_Clone);
643 0 retval = method(arg_self);
644 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
645 0 CFISH_DECREF(retval);
646 0 sv_2mortal( ST(0) );
647 0 XSRETURN(1);
648 }
649  
650 XS_INTERNAL(XS_Clownfish_CharBuf_new);
651 1 XS_INTERNAL(XS_Clownfish_CharBuf_new) {
652 1 dXSARGS;
653 static const XSBind_ParamSpec param_specs[1] = {
654 XSBIND_PARAM("capacity", 0)
655 };
656 int32_t locations[1];
657 SV *sv;
658 cfish_CharBuf* arg_self;
659 size_t arg_capacity;
660 cfish_CharBuf* retval;
661  
662 CFISH_UNUSED_VAR(cv);
663 1 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 1 1
664 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
665 }
666 1 SP -= items;
667  
668 1 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
669 locations, 1);
670 1 sv = ST(locations[0]);
671 0 ▶ arg_capacity = locations[0] < items && XSBind_sv_defined(aTHX_ sv)
Branch: 1 branch
BranchTrueFalseTotal
arg_capacity = locations[0] < items && XSBind_sv_defined(aTHX_ sv) 0 0 0
672 1 ▶ ? (size_t)SvIV(sv) : 0;
Branch: 1 branch
BranchTrueFalseTotal
? (size_t)SvIV(sv) : 0; 0 1 1
673 1 arg_self = (cfish_CharBuf*)XSBind_new_blank_obj(aTHX_ ST(0));
674  
675 1 retval = cfish_CB_init(arg_self, arg_capacity);
676 1 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
677 1 XSRETURN(1);
678 }
679  
680  
681 XS_INTERNAL(XS_Clownfish_CharBuf_cat);
682 2 XS_INTERNAL(XS_Clownfish_CharBuf_cat) {
683 2 dXSARGS;
684 SV *sv;
685 cfish_CharBuf* arg_self;
686 cfish_String* arg_string;
687 CFISH_CB_Cat_t method;
688  
689 CFISH_UNUSED_VAR(cv);
690 2 SP -= items;
691 2 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 2 2
692 0 XSBind_invalid_args_error(aTHX_ cv, "self, string");
693 }
694  
695 /* Extract vars from Perl stack. */
696 2 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
697 2 sv = ST(1);
698 2 arg_string = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "string", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
699  
700 /* Execute */
701 2 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Cat);
702 2 method(arg_self, arg_string);
703 2 XSRETURN(0);
704 }
705  
706 XS_INTERNAL(XS_Clownfish_CharBuf_cat_char);
707 1 XS_INTERNAL(XS_Clownfish_CharBuf_cat_char) {
708 1 dXSARGS;
709 SV *sv;
710 cfish_CharBuf* arg_self;
711 int32_t arg_code_point;
712 CFISH_CB_Cat_Char_t method;
713  
714 CFISH_UNUSED_VAR(cv);
715 1 SP -= items;
716 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
717 0 XSBind_invalid_args_error(aTHX_ cv, "self, code_point");
718 }
719  
720 /* Extract vars from Perl stack. */
721 1 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
722 1 sv = ST(1);
723 1 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 1 1
724 0 XSBind_undef_arg_error(aTHX_ "code_point");
725 }
726 1 arg_code_point = (int32_t)SvIV(sv);
727  
728 /* Execute */
729 1 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Cat_Char);
730 1 method(arg_self, arg_code_point);
731 1 XSRETURN(0);
732 }
733  
734 XS_INTERNAL(XS_Clownfish_CharBuf_grow);
735 0 XS_INTERNAL(XS_Clownfish_CharBuf_grow) {
736 0 dXSARGS;
737 SV *sv;
738 cfish_CharBuf* arg_self;
739 size_t arg_capacity;
740 CFISH_CB_Grow_t method;
741  
742 CFISH_UNUSED_VAR(cv);
743 0 SP -= items;
744 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
745 0 XSBind_invalid_args_error(aTHX_ cv, "self, capacity");
746 }
747  
748 /* Extract vars from Perl stack. */
749 0 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
750 0 sv = ST(1);
751 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
752 0 XSBind_undef_arg_error(aTHX_ "capacity");
753 }
754 0 arg_capacity = (size_t)SvIV(sv);
755  
756 /* Execute */
757 0 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Grow);
758 0 method(arg_self, arg_capacity);
759 0 XSRETURN(0);
760 }
761  
762 XS_INTERNAL(XS_Clownfish_CharBuf_clear);
763 1 XS_INTERNAL(XS_Clownfish_CharBuf_clear) {
764 1 dXSARGS;
765 cfish_CharBuf* arg_self;
766 CFISH_CB_Clear_t method;
767  
768 CFISH_UNUSED_VAR(cv);
769 1 SP -= items;
770 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
771 0 XSBind_invalid_args_error(aTHX_ cv, "self");
772 }
773  
774 /* Extract vars from Perl stack. */
775 1 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
776  
777 /* Execute */
778 1 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Clear);
779 1 method(arg_self);
780 1 XSRETURN(0);
781 }
782  
783 XS_INTERNAL(XS_Clownfish_CharBuf_get_size);
784 1 XS_INTERNAL(XS_Clownfish_CharBuf_get_size) {
785 1 dXSARGS;
786 cfish_CharBuf* arg_self;
787 CFISH_CB_Get_Size_t method;
788 size_t retval;
789  
790 CFISH_UNUSED_VAR(cv);
791 1 SP -= items;
792 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
793 0 XSBind_invalid_args_error(aTHX_ cv, "self");
794 }
795  
796 /* Extract vars from Perl stack. */
797 1 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
798  
799 /* Execute */
800 1 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Get_Size);
801 1 retval = method(arg_self);
802 1 ST(0) = newSViv(retval);
803 1 sv_2mortal( ST(0) );
804 1 XSRETURN(1);
805 }
806  
807 XS_INTERNAL(XS_Clownfish_CharBuf_clone);
808 0 XS_INTERNAL(XS_Clownfish_CharBuf_clone) {
809 0 dXSARGS;
810 cfish_CharBuf* arg_self;
811 CFISH_CB_Clone_t method;
812 cfish_CharBuf* retval;
813  
814 CFISH_UNUSED_VAR(cv);
815 0 SP -= items;
816 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
817 0 XSBind_invalid_args_error(aTHX_ cv, "self");
818 }
819  
820 /* Extract vars from Perl stack. */
821 0 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
822  
823 /* Execute */
824 0 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Clone);
825 0 retval = method(arg_self);
826 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
827 0 CFISH_DECREF(retval);
828 0 sv_2mortal( ST(0) );
829 0 XSRETURN(1);
830 }
831  
832 XS_INTERNAL(XS_Clownfish_CharBuf_to_string);
833 1 XS_INTERNAL(XS_Clownfish_CharBuf_to_string) {
834 1 dXSARGS;
835 cfish_CharBuf* arg_self;
836 CFISH_CB_To_String_t method;
837 cfish_String* retval;
838  
839 CFISH_UNUSED_VAR(cv);
840 1 SP -= items;
841 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
842 0 XSBind_invalid_args_error(aTHX_ cv, "self");
843 }
844  
845 /* Extract vars from Perl stack. */
846 1 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
847  
848 /* Execute */
849 1 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_To_String);
850 1 retval = method(arg_self);
851 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
852 1 CFISH_DECREF(retval);
853 1 sv_2mortal( ST(0) );
854 1 XSRETURN(1);
855 }
856  
857 XS_INTERNAL(XS_Clownfish_CharBuf_yield_string);
858 1 XS_INTERNAL(XS_Clownfish_CharBuf_yield_string) {
859 1 dXSARGS;
860 cfish_CharBuf* arg_self;
861 CFISH_CB_Yield_String_t method;
862 cfish_String* retval;
863  
864 CFISH_UNUSED_VAR(cv);
865 1 SP -= items;
866 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
867 0 XSBind_invalid_args_error(aTHX_ cv, "self");
868 }
869  
870 /* Extract vars from Perl stack. */
871 1 arg_self = (cfish_CharBuf*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CHARBUF, NULL);
872  
873 /* Execute */
874 1 method = CFISH_METHOD_PTR(CFISH_CHARBUF, CFISH_CB_Yield_String);
875 1 retval = method(arg_self);
876 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
877 1 CFISH_DECREF(retval);
878 1 sv_2mortal( ST(0) );
879 1 XSRETURN(1);
880 }
881  
882 XS_INTERNAL(XS_Clownfish_Class_make_obj);
883 0 XS_INTERNAL(XS_Clownfish_Class_make_obj) {
884 0 dXSARGS;
885 cfish_Class* arg_self;
886 CFISH_Class_Make_Obj_t method;
887 cfish_Obj* retval;
888  
889 CFISH_UNUSED_VAR(cv);
890 0 SP -= items;
891 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
892 0 XSBind_invalid_args_error(aTHX_ cv, "self");
893 }
894  
895 /* Extract vars from Perl stack. */
896 0 arg_self = (cfish_Class*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CLASS, NULL);
897  
898 /* Execute */
899 0 method = CFISH_METHOD_PTR(CFISH_CLASS, CFISH_Class_Make_Obj);
900 0 retval = method(arg_self);
901 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
902 0 CFISH_DECREF(retval);
903 0 sv_2mortal( ST(0) );
904 0 XSRETURN(1);
905 }
906  
907 XS_INTERNAL(XS_Clownfish_Class_get_name);
908 22 XS_INTERNAL(XS_Clownfish_Class_get_name) {
909 22 dXSARGS;
910 cfish_Class* arg_self;
911 CFISH_Class_Get_Name_t method;
912 cfish_String* retval;
913  
914 CFISH_UNUSED_VAR(cv);
915 22 SP -= items;
916 22 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 22 22
917 0 XSBind_invalid_args_error(aTHX_ cv, "self");
918 }
919  
920 /* Extract vars from Perl stack. */
921 22 arg_self = (cfish_Class*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CLASS, NULL);
922  
923 /* Execute */
924 22 method = CFISH_METHOD_PTR(CFISH_CLASS, CFISH_Class_Get_Name);
925 22 retval = method(arg_self);
926 22 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
927 22 sv_2mortal( ST(0) );
928 22 XSRETURN(1);
929 }
930  
931 XS_INTERNAL(XS_Clownfish_Class_get_parent);
932 0 XS_INTERNAL(XS_Clownfish_Class_get_parent) {
933 0 dXSARGS;
934 cfish_Class* arg_self;
935 CFISH_Class_Get_Parent_t method;
936 cfish_Class* retval;
937  
938 CFISH_UNUSED_VAR(cv);
939 0 SP -= items;
940 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
941 0 XSBind_invalid_args_error(aTHX_ cv, "self");
942 }
943  
944 /* Extract vars from Perl stack. */
945 0 arg_self = (cfish_Class*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CLASS, NULL);
946  
947 /* Execute */
948 0 method = CFISH_METHOD_PTR(CFISH_CLASS, CFISH_Class_Get_Parent);
949 0 retval = method(arg_self);
950 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
951 0 sv_2mortal( ST(0) );
952 0 XSRETURN(1);
953 }
954  
955 XS_INTERNAL(XS_Clownfish_Class_get_obj_alloc_size);
956 0 XS_INTERNAL(XS_Clownfish_Class_get_obj_alloc_size) {
957 0 dXSARGS;
958 cfish_Class* arg_self;
959 CFISH_Class_Get_Obj_Alloc_Size_t method;
960 uint32_t retval;
961  
962 CFISH_UNUSED_VAR(cv);
963 0 SP -= items;
964 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
965 0 XSBind_invalid_args_error(aTHX_ cv, "self");
966 }
967  
968 /* Extract vars from Perl stack. */
969 0 arg_self = (cfish_Class*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CLASS, NULL);
970  
971 /* Execute */
972 0 method = CFISH_METHOD_PTR(CFISH_CLASS, CFISH_Class_Get_Obj_Alloc_Size);
973 0 retval = method(arg_self);
974 0 ST(0) = newSVuv(retval);
975 0 sv_2mortal( ST(0) );
976 0 XSRETURN(1);
977 }
978  
979 XS_INTERNAL(XS_Clownfish_Class_get_methods);
980 0 XS_INTERNAL(XS_Clownfish_Class_get_methods) {
981 0 dXSARGS;
982 cfish_Class* arg_self;
983 CFISH_Class_Get_Methods_t method;
984 cfish_Vector* retval;
985  
986 CFISH_UNUSED_VAR(cv);
987 0 SP -= items;
988 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
989 0 XSBind_invalid_args_error(aTHX_ cv, "self");
990 }
991  
992 /* Extract vars from Perl stack. */
993 0 arg_self = (cfish_Class*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_CLASS, NULL);
994  
995 /* Execute */
996 0 method = CFISH_METHOD_PTR(CFISH_CLASS, CFISH_Class_Get_Methods);
997 0 retval = method(arg_self);
998 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
999 0 CFISH_DECREF(retval);
1000 0 sv_2mortal( ST(0) );
1001 0 XSRETURN(1);
1002 }
1003  
1004 XS_INTERNAL(XS_Clownfish_Err__new);
1005 7 XS_INTERNAL(XS_Clownfish_Err__new) {
1006 7 dXSARGS;
1007 static const XSBind_ParamSpec param_specs[1] = {
1008 XSBIND_PARAM("mess", 1)
1009 };
1010 int32_t locations[1];
1011 SV *sv;
1012 cfish_Err* arg_self;
1013 cfish_String* arg_mess;
1014 cfish_Err* retval;
1015  
1016 CFISH_UNUSED_VAR(cv);
1017 7 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 7 7
1018 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
1019 }
1020 7 SP -= items;
1021  
1022 7 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
1023 locations, 1);
1024 7 sv = ST(locations[0]);
1025 7 arg_mess = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "mess", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1026 7 arg_self = (cfish_Err*)XSBind_new_blank_obj(aTHX_ ST(0));
1027 7 CFISH_INCREF(arg_mess);
1028  
1029 7 retval = cfish_Err_init(arg_self, arg_mess);
1030 7 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
1031 7 XSRETURN(1);
1032 }
1033  
1034  
1035 XS_INTERNAL(XS_Clownfish_Err_to_string);
1036 66 XS_INTERNAL(XS_Clownfish_Err_to_string) {
1037 66 dXSARGS;
1038 cfish_Err* arg_self;
1039 CFISH_Err_To_String_t method;
1040 cfish_String* retval;
1041  
1042 CFISH_UNUSED_VAR(cv);
1043 66 SP -= items;
1044 66 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 66 66
1045 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1046 }
1047  
1048 /* Extract vars from Perl stack. */
1049 66 arg_self = (cfish_Err*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_ERR, NULL);
1050  
1051 /* Execute */
1052 66 method = CFISH_METHOD_PTR(CFISH_ERR, CFISH_Err_To_String);
1053 66 retval = method(arg_self);
1054 66 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1055 66 CFISH_DECREF(retval);
1056 66 sv_2mortal( ST(0) );
1057 66 XSRETURN(1);
1058 }
1059  
1060 XS_INTERNAL(XS_Clownfish_Err_cat_mess);
1061 59 XS_INTERNAL(XS_Clownfish_Err_cat_mess) {
1062 59 dXSARGS;
1063 SV *sv;
1064 cfish_Err* arg_self;
1065 cfish_String* arg_mess;
1066 CFISH_Err_Cat_Mess_t method;
1067  
1068 CFISH_UNUSED_VAR(cv);
1069 59 SP -= items;
1070 59 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 59 59
1071 0 XSBind_invalid_args_error(aTHX_ cv, "self, mess");
1072 }
1073  
1074 /* Extract vars from Perl stack. */
1075 59 arg_self = (cfish_Err*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_ERR, NULL);
1076 59 sv = ST(1);
1077 59 arg_mess = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "mess", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1078  
1079 /* Execute */
1080 59 method = CFISH_METHOD_PTR(CFISH_ERR, CFISH_Err_Cat_Mess);
1081 59 method(arg_self, arg_mess);
1082 59 XSRETURN(0);
1083 }
1084  
1085 XS_INTERNAL(XS_Clownfish_Err_get_mess);
1086 1 XS_INTERNAL(XS_Clownfish_Err_get_mess) {
1087 1 dXSARGS;
1088 cfish_Err* arg_self;
1089 CFISH_Err_Get_Mess_t method;
1090 cfish_String* retval;
1091  
1092 CFISH_UNUSED_VAR(cv);
1093 1 SP -= items;
1094 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1095 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1096 }
1097  
1098 /* Extract vars from Perl stack. */
1099 1 arg_self = (cfish_Err*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_ERR, NULL);
1100  
1101 /* Execute */
1102 1 method = CFISH_METHOD_PTR(CFISH_ERR, CFISH_Err_Get_Mess);
1103 1 retval = method(arg_self);
1104 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1105 1 sv_2mortal( ST(0) );
1106 1 XSRETURN(1);
1107 }
1108  
1109 XS_INTERNAL(XS_Clownfish_Float_get_value);
1110 1 XS_INTERNAL(XS_Clownfish_Float_get_value) {
1111 1 dXSARGS;
1112 cfish_Float* arg_self;
1113 CFISH_Float_Get_Value_t method;
1114 double retval;
1115  
1116 CFISH_UNUSED_VAR(cv);
1117 1 SP -= items;
1118 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1119 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1120 }
1121  
1122 /* Extract vars from Perl stack. */
1123 1 arg_self = (cfish_Float*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_FLOAT, NULL);
1124  
1125 /* Execute */
1126 1 method = CFISH_METHOD_PTR(CFISH_FLOAT, CFISH_Float_Get_Value);
1127 1 retval = method(arg_self);
1128 1 ST(0) = newSVnv(retval);
1129 1 sv_2mortal( ST(0) );
1130 1 XSRETURN(1);
1131 }
1132  
1133 XS_INTERNAL(XS_Clownfish_Float_to_i64);
1134 1 XS_INTERNAL(XS_Clownfish_Float_to_i64) {
1135 1 dXSARGS;
1136 cfish_Float* arg_self;
1137 CFISH_Float_To_I64_t method;
1138 int64_t retval;
1139  
1140 CFISH_UNUSED_VAR(cv);
1141 1 SP -= items;
1142 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1143 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1144 }
1145  
1146 /* Extract vars from Perl stack. */
1147 1 arg_self = (cfish_Float*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_FLOAT, NULL);
1148  
1149 /* Execute */
1150 1 method = CFISH_METHOD_PTR(CFISH_FLOAT, CFISH_Float_To_I64);
1151 1 retval = method(arg_self);
1152 1 ST(0) = sizeof(IV) == 8 ? newSViv((IV)retval) : newSVnv((NV)retval);
1153 1 sv_2mortal( ST(0) );
1154 1 XSRETURN(1);
1155 }
1156  
1157 XS_INTERNAL(XS_Clownfish_Float_to_string);
1158 1 XS_INTERNAL(XS_Clownfish_Float_to_string) {
1159 1 dXSARGS;
1160 cfish_Float* arg_self;
1161 CFISH_Float_To_String_t method;
1162 cfish_String* retval;
1163  
1164 CFISH_UNUSED_VAR(cv);
1165 1 SP -= items;
1166 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1167 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1168 }
1169  
1170 /* Extract vars from Perl stack. */
1171 1 arg_self = (cfish_Float*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_FLOAT, NULL);
1172  
1173 /* Execute */
1174 1 method = CFISH_METHOD_PTR(CFISH_FLOAT, CFISH_Float_To_String);
1175 1 retval = method(arg_self);
1176 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1177 1 CFISH_DECREF(retval);
1178 1 sv_2mortal( ST(0) );
1179 1 XSRETURN(1);
1180 }
1181  
1182 XS_INTERNAL(XS_Clownfish_Float_equals);
1183 3 XS_INTERNAL(XS_Clownfish_Float_equals) {
1184 3 dXSARGS;
1185 SV *sv;
1186 cfish_Float* arg_self;
1187 cfish_Obj* arg_other;
1188 CFISH_Float_Equals_t method;
1189 bool retval;
1190  
1191 CFISH_UNUSED_VAR(cv);
1192 3 SP -= items;
1193 3 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 3 3
1194 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
1195 }
1196  
1197 /* Extract vars from Perl stack. */
1198 3 arg_self = (cfish_Float*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_FLOAT, NULL);
1199 3 sv = ST(1);
1200 3 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1201  
1202 /* Execute */
1203 3 method = CFISH_METHOD_PTR(CFISH_FLOAT, CFISH_Float_Equals);
1204 3 retval = method(arg_self, arg_other);
1205 3 ST(0) = newSViv(!!retval);
1206 3 sv_2mortal( ST(0) );
1207 3 XSRETURN(1);
1208 }
1209  
1210 XS_INTERNAL(XS_Clownfish_Float_compare_to);
1211 1 XS_INTERNAL(XS_Clownfish_Float_compare_to) {
1212 1 dXSARGS;
1213 SV *sv;
1214 cfish_Float* arg_self;
1215 cfish_Obj* arg_other;
1216 CFISH_Float_Compare_To_t method;
1217 int32_t retval;
1218  
1219 CFISH_UNUSED_VAR(cv);
1220 1 SP -= items;
1221 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
1222 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
1223 }
1224  
1225 /* Extract vars from Perl stack. */
1226 1 arg_self = (cfish_Float*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_FLOAT, NULL);
1227 1 sv = ST(1);
1228 1 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1229  
1230 /* Execute */
1231 1 method = CFISH_METHOD_PTR(CFISH_FLOAT, CFISH_Float_Compare_To);
1232 1 retval = method(arg_self, arg_other);
1233 1 ST(0) = newSViv(retval);
1234 1 sv_2mortal( ST(0) );
1235 1 XSRETURN(1);
1236 }
1237  
1238 XS_INTERNAL(XS_Clownfish_Float_clone);
1239 0 XS_INTERNAL(XS_Clownfish_Float_clone) {
1240 0 dXSARGS;
1241 cfish_Float* arg_self;
1242 CFISH_Float_Clone_t method;
1243 cfish_Float* retval;
1244  
1245 CFISH_UNUSED_VAR(cv);
1246 0 SP -= items;
1247 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1248 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1249 }
1250  
1251 /* Extract vars from Perl stack. */
1252 0 arg_self = (cfish_Float*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_FLOAT, NULL);
1253  
1254 /* Execute */
1255 0 method = CFISH_METHOD_PTR(CFISH_FLOAT, CFISH_Float_Clone);
1256 0 retval = method(arg_self);
1257 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1258 0 CFISH_DECREF(retval);
1259 0 sv_2mortal( ST(0) );
1260 0 XSRETURN(1);
1261 }
1262  
1263 XS_INTERNAL(XS_Clownfish_Hash_new);
1264 5 XS_INTERNAL(XS_Clownfish_Hash_new) {
1265 5 dXSARGS;
1266 static const XSBind_ParamSpec param_specs[1] = {
1267 XSBIND_PARAM("capacity", 0)
1268 };
1269 int32_t locations[1];
1270 SV *sv;
1271 cfish_Hash* arg_self;
1272 size_t arg_capacity;
1273 cfish_Hash* retval;
1274  
1275 CFISH_UNUSED_VAR(cv);
1276 5 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 5 5
1277 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
1278 }
1279 5 SP -= items;
1280  
1281 5 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
1282 locations, 1);
1283 5 sv = ST(locations[0]);
1284 1 ▶ arg_capacity = locations[0] < items && XSBind_sv_defined(aTHX_ sv)
Branch: 1 branch
BranchTrueFalseTotal
arg_capacity = locations[0] < items && XSBind_sv_defined(aTHX_ sv) 1 0 1
1285 6 ▶ ? (size_t)SvIV(sv) : 0;
Branch: 1 branch
BranchTrueFalseTotal
? (size_t)SvIV(sv) : 0; 1 4 5
1286 5 arg_self = (cfish_Hash*)XSBind_new_blank_obj(aTHX_ ST(0));
1287  
1288 5 retval = cfish_Hash_init(arg_self, arg_capacity);
1289 5 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
1290 5 XSRETURN(1);
1291 }
1292  
1293  
1294 XS_INTERNAL(XS_Clownfish_Hash_clear);
1295 4 XS_INTERNAL(XS_Clownfish_Hash_clear) {
1296 4 dXSARGS;
1297 cfish_Hash* arg_self;
1298 CFISH_Hash_Clear_t method;
1299  
1300 CFISH_UNUSED_VAR(cv);
1301 4 SP -= items;
1302 4 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 4 4
1303 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1304 }
1305  
1306 /* Extract vars from Perl stack. */
1307 4 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1308  
1309 /* Execute */
1310 4 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Clear);
1311 4 method(arg_self);
1312 4 XSRETURN(0);
1313 }
1314  
1315 XS_INTERNAL(XS_Clownfish_Hash_fetch);
1316 6 XS_INTERNAL(XS_Clownfish_Hash_fetch) {
1317 6 dXSARGS;
1318 SV *sv;
1319 cfish_Hash* arg_self;
1320 cfish_String* arg_key;
1321 CFISH_Hash_Fetch_t method;
1322 cfish_Obj* retval;
1323  
1324 CFISH_UNUSED_VAR(cv);
1325 6 SP -= items;
1326 6 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 6 6
1327 0 XSBind_invalid_args_error(aTHX_ cv, "self, key");
1328 }
1329  
1330 /* Extract vars from Perl stack. */
1331 6 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1332 6 sv = ST(1);
1333 6 arg_key = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "key", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1334  
1335 /* Execute */
1336 6 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Fetch);
1337 6 retval = method(arg_self, arg_key);
1338 6 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1339 6 sv_2mortal( ST(0) );
1340 6 XSRETURN(1);
1341 }
1342  
1343 XS_INTERNAL(XS_Clownfish_Hash_delete);
1344 0 XS_INTERNAL(XS_Clownfish_Hash_delete) {
1345 0 dXSARGS;
1346 SV *sv;
1347 cfish_Hash* arg_self;
1348 cfish_String* arg_key;
1349 CFISH_Hash_Delete_t method;
1350 cfish_Obj* retval;
1351  
1352 CFISH_UNUSED_VAR(cv);
1353 0 SP -= items;
1354 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1355 0 XSBind_invalid_args_error(aTHX_ cv, "self, key");
1356 }
1357  
1358 /* Extract vars from Perl stack. */
1359 0 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1360 0 sv = ST(1);
1361 0 arg_key = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "key", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1362  
1363 /* Execute */
1364 0 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Delete);
1365 0 retval = method(arg_self, arg_key);
1366 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1367 0 CFISH_DECREF(retval);
1368 0 sv_2mortal( ST(0) );
1369 0 XSRETURN(1);
1370 }
1371  
1372 XS_INTERNAL(XS_Clownfish_Hash_has_key);
1373 0 XS_INTERNAL(XS_Clownfish_Hash_has_key) {
1374 0 dXSARGS;
1375 SV *sv;
1376 cfish_Hash* arg_self;
1377 cfish_String* arg_key;
1378 CFISH_Hash_Has_Key_t method;
1379 bool retval;
1380  
1381 CFISH_UNUSED_VAR(cv);
1382 0 SP -= items;
1383 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1384 0 XSBind_invalid_args_error(aTHX_ cv, "self, key");
1385 }
1386  
1387 /* Extract vars from Perl stack. */
1388 0 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1389 0 sv = ST(1);
1390 0 arg_key = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "key", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1391  
1392 /* Execute */
1393 0 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Has_Key);
1394 0 retval = method(arg_self, arg_key);
1395 0 ST(0) = newSViv(!!retval);
1396 0 sv_2mortal( ST(0) );
1397 0 XSRETURN(1);
1398 }
1399  
1400 XS_INTERNAL(XS_Clownfish_Hash_keys);
1401 0 XS_INTERNAL(XS_Clownfish_Hash_keys) {
1402 0 dXSARGS;
1403 cfish_Hash* arg_self;
1404 CFISH_Hash_Keys_t method;
1405 cfish_Vector* retval;
1406  
1407 CFISH_UNUSED_VAR(cv);
1408 0 SP -= items;
1409 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1410 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1411 }
1412  
1413 /* Extract vars from Perl stack. */
1414 0 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1415  
1416 /* Execute */
1417 0 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Keys);
1418 0 retval = method(arg_self);
1419 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1420 0 CFISH_DECREF(retval);
1421 0 sv_2mortal( ST(0) );
1422 0 XSRETURN(1);
1423 }
1424  
1425 XS_INTERNAL(XS_Clownfish_Hash_values);
1426 0 XS_INTERNAL(XS_Clownfish_Hash_values) {
1427 0 dXSARGS;
1428 cfish_Hash* arg_self;
1429 CFISH_Hash_Values_t method;
1430 cfish_Vector* retval;
1431  
1432 CFISH_UNUSED_VAR(cv);
1433 0 SP -= items;
1434 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1435 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1436 }
1437  
1438 /* Extract vars from Perl stack. */
1439 0 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1440  
1441 /* Execute */
1442 0 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Values);
1443 0 retval = method(arg_self);
1444 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1445 0 CFISH_DECREF(retval);
1446 0 sv_2mortal( ST(0) );
1447 0 XSRETURN(1);
1448 }
1449  
1450 XS_INTERNAL(XS_Clownfish_Hash_get_capacity);
1451 0 XS_INTERNAL(XS_Clownfish_Hash_get_capacity) {
1452 0 dXSARGS;
1453 cfish_Hash* arg_self;
1454 CFISH_Hash_Get_Capacity_t method;
1455 size_t retval;
1456  
1457 CFISH_UNUSED_VAR(cv);
1458 0 SP -= items;
1459 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1460 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1461 }
1462  
1463 /* Extract vars from Perl stack. */
1464 0 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1465  
1466 /* Execute */
1467 0 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Get_Capacity);
1468 0 retval = method(arg_self);
1469 0 ST(0) = newSViv(retval);
1470 0 sv_2mortal( ST(0) );
1471 0 XSRETURN(1);
1472 }
1473  
1474 XS_INTERNAL(XS_Clownfish_Hash_get_size);
1475 1 XS_INTERNAL(XS_Clownfish_Hash_get_size) {
1476 1 dXSARGS;
1477 cfish_Hash* arg_self;
1478 CFISH_Hash_Get_Size_t method;
1479 size_t retval;
1480  
1481 CFISH_UNUSED_VAR(cv);
1482 1 SP -= items;
1483 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1484 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1485 }
1486  
1487 /* Extract vars from Perl stack. */
1488 1 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1489  
1490 /* Execute */
1491 1 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Get_Size);
1492 1 retval = method(arg_self);
1493 1 ST(0) = newSViv(retval);
1494 1 sv_2mortal( ST(0) );
1495 1 XSRETURN(1);
1496 }
1497  
1498 XS_INTERNAL(XS_Clownfish_Hash_equals);
1499 0 XS_INTERNAL(XS_Clownfish_Hash_equals) {
1500 0 dXSARGS;
1501 SV *sv;
1502 cfish_Hash* arg_self;
1503 cfish_Obj* arg_other;
1504 CFISH_Hash_Equals_t method;
1505 bool retval;
1506  
1507 CFISH_UNUSED_VAR(cv);
1508 0 SP -= items;
1509 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1510 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
1511 }
1512  
1513 /* Extract vars from Perl stack. */
1514 0 arg_self = (cfish_Hash*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASH, NULL);
1515 0 sv = ST(1);
1516 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1517  
1518 /* Execute */
1519 0 method = CFISH_METHOD_PTR(CFISH_HASH, CFISH_Hash_Equals);
1520 0 retval = method(arg_self, arg_other);
1521 0 ST(0) = newSViv(!!retval);
1522 0 sv_2mortal( ST(0) );
1523 0 XSRETURN(1);
1524 }
1525  
1526 XS_INTERNAL(XS_Clownfish_HashIterator_next);
1527 3 XS_INTERNAL(XS_Clownfish_HashIterator_next) {
1528 3 dXSARGS;
1529 cfish_HashIterator* arg_self;
1530 CFISH_HashIter_Next_t method;
1531 bool retval;
1532  
1533 CFISH_UNUSED_VAR(cv);
1534 3 SP -= items;
1535 3 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 3 3
1536 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1537 }
1538  
1539 /* Extract vars from Perl stack. */
1540 3 arg_self = (cfish_HashIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASHITERATOR, NULL);
1541  
1542 /* Execute */
1543 3 method = CFISH_METHOD_PTR(CFISH_HASHITERATOR, CFISH_HashIter_Next);
1544 3 retval = method(arg_self);
1545 3 ST(0) = newSViv(!!retval);
1546 3 sv_2mortal( ST(0) );
1547 3 XSRETURN(1);
1548 }
1549  
1550 XS_INTERNAL(XS_Clownfish_HashIterator_get_key);
1551 2 XS_INTERNAL(XS_Clownfish_HashIterator_get_key) {
1552 2 dXSARGS;
1553 cfish_HashIterator* arg_self;
1554 CFISH_HashIter_Get_Key_t method;
1555 cfish_String* retval;
1556  
1557 CFISH_UNUSED_VAR(cv);
1558 2 SP -= items;
1559 2 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 2 2
1560 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1561 }
1562  
1563 /* Extract vars from Perl stack. */
1564 2 arg_self = (cfish_HashIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASHITERATOR, NULL);
1565  
1566 /* Execute */
1567 2 method = CFISH_METHOD_PTR(CFISH_HASHITERATOR, CFISH_HashIter_Get_Key);
1568 2 retval = method(arg_self);
1569 2 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1570 2 sv_2mortal( ST(0) );
1571 2 XSRETURN(1);
1572 }
1573  
1574 XS_INTERNAL(XS_Clownfish_HashIterator_get_value);
1575 2 XS_INTERNAL(XS_Clownfish_HashIterator_get_value) {
1576 2 dXSARGS;
1577 cfish_HashIterator* arg_self;
1578 CFISH_HashIter_Get_Value_t method;
1579 cfish_Obj* retval;
1580  
1581 CFISH_UNUSED_VAR(cv);
1582 2 SP -= items;
1583 2 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 2 2
1584 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1585 }
1586  
1587 /* Extract vars from Perl stack. */
1588 2 arg_self = (cfish_HashIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_HASHITERATOR, NULL);
1589  
1590 /* Execute */
1591 2 method = CFISH_METHOD_PTR(CFISH_HASHITERATOR, CFISH_HashIter_Get_Value);
1592 2 retval = method(arg_self);
1593 2 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1594 2 sv_2mortal( ST(0) );
1595 2 XSRETURN(1);
1596 }
1597  
1598 XS_INTERNAL(XS_Clownfish_Integer_get_value);
1599 1 XS_INTERNAL(XS_Clownfish_Integer_get_value) {
1600 1 dXSARGS;
1601 cfish_Integer* arg_self;
1602 CFISH_Int_Get_Value_t method;
1603 int64_t retval;
1604  
1605 CFISH_UNUSED_VAR(cv);
1606 1 SP -= items;
1607 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1608 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1609 }
1610  
1611 /* Extract vars from Perl stack. */
1612 1 arg_self = (cfish_Integer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_INTEGER, NULL);
1613  
1614 /* Execute */
1615 1 method = CFISH_METHOD_PTR(CFISH_INTEGER, CFISH_Int_Get_Value);
1616 1 retval = method(arg_self);
1617 1 ST(0) = sizeof(IV) == 8 ? newSViv((IV)retval) : newSVnv((NV)retval);
1618 1 sv_2mortal( ST(0) );
1619 1 XSRETURN(1);
1620 }
1621  
1622 XS_INTERNAL(XS_Clownfish_Integer_to_f64);
1623 0 XS_INTERNAL(XS_Clownfish_Integer_to_f64) {
1624 0 dXSARGS;
1625 cfish_Integer* arg_self;
1626 CFISH_Int_To_F64_t method;
1627 double retval;
1628  
1629 CFISH_UNUSED_VAR(cv);
1630 0 SP -= items;
1631 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1632 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1633 }
1634  
1635 /* Extract vars from Perl stack. */
1636 0 arg_self = (cfish_Integer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_INTEGER, NULL);
1637  
1638 /* Execute */
1639 0 method = CFISH_METHOD_PTR(CFISH_INTEGER, CFISH_Int_To_F64);
1640 0 retval = method(arg_self);
1641 0 ST(0) = newSVnv(retval);
1642 0 sv_2mortal( ST(0) );
1643 0 XSRETURN(1);
1644 }
1645  
1646 XS_INTERNAL(XS_Clownfish_Integer_to_string);
1647 1 XS_INTERNAL(XS_Clownfish_Integer_to_string) {
1648 1 dXSARGS;
1649 cfish_Integer* arg_self;
1650 CFISH_Int_To_String_t method;
1651 cfish_String* retval;
1652  
1653 CFISH_UNUSED_VAR(cv);
1654 1 SP -= items;
1655 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
1656 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1657 }
1658  
1659 /* Extract vars from Perl stack. */
1660 1 arg_self = (cfish_Integer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_INTEGER, NULL);
1661  
1662 /* Execute */
1663 1 method = CFISH_METHOD_PTR(CFISH_INTEGER, CFISH_Int_To_String);
1664 1 retval = method(arg_self);
1665 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1666 1 CFISH_DECREF(retval);
1667 1 sv_2mortal( ST(0) );
1668 1 XSRETURN(1);
1669 }
1670  
1671 XS_INTERNAL(XS_Clownfish_Integer_equals);
1672 3 XS_INTERNAL(XS_Clownfish_Integer_equals) {
1673 3 dXSARGS;
1674 SV *sv;
1675 cfish_Integer* arg_self;
1676 cfish_Obj* arg_other;
1677 CFISH_Int_Equals_t method;
1678 bool retval;
1679  
1680 CFISH_UNUSED_VAR(cv);
1681 3 SP -= items;
1682 3 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 3 3
1683 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
1684 }
1685  
1686 /* Extract vars from Perl stack. */
1687 3 arg_self = (cfish_Integer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_INTEGER, NULL);
1688 3 sv = ST(1);
1689 3 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1690  
1691 /* Execute */
1692 3 method = CFISH_METHOD_PTR(CFISH_INTEGER, CFISH_Int_Equals);
1693 3 retval = method(arg_self, arg_other);
1694 3 ST(0) = newSViv(!!retval);
1695 3 sv_2mortal( ST(0) );
1696 3 XSRETURN(1);
1697 }
1698  
1699 XS_INTERNAL(XS_Clownfish_Integer_compare_to);
1700 1 XS_INTERNAL(XS_Clownfish_Integer_compare_to) {
1701 1 dXSARGS;
1702 SV *sv;
1703 cfish_Integer* arg_self;
1704 cfish_Obj* arg_other;
1705 CFISH_Int_Compare_To_t method;
1706 int32_t retval;
1707  
1708 CFISH_UNUSED_VAR(cv);
1709 1 SP -= items;
1710 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
1711 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
1712 }
1713  
1714 /* Extract vars from Perl stack. */
1715 1 arg_self = (cfish_Integer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_INTEGER, NULL);
1716 1 sv = ST(1);
1717 1 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
1718  
1719 /* Execute */
1720 1 method = CFISH_METHOD_PTR(CFISH_INTEGER, CFISH_Int_Compare_To);
1721 1 retval = method(arg_self, arg_other);
1722 1 ST(0) = newSViv(retval);
1723 1 sv_2mortal( ST(0) );
1724 1 XSRETURN(1);
1725 }
1726  
1727 XS_INTERNAL(XS_Clownfish_Integer_clone);
1728 0 XS_INTERNAL(XS_Clownfish_Integer_clone) {
1729 0 dXSARGS;
1730 cfish_Integer* arg_self;
1731 CFISH_Int_Clone_t method;
1732 cfish_Integer* retval;
1733  
1734 CFISH_UNUSED_VAR(cv);
1735 0 SP -= items;
1736 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1737 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1738 }
1739  
1740 /* Extract vars from Perl stack. */
1741 0 arg_self = (cfish_Integer*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_INTEGER, NULL);
1742  
1743 /* Execute */
1744 0 method = CFISH_METHOD_PTR(CFISH_INTEGER, CFISH_Int_Clone);
1745 0 retval = method(arg_self);
1746 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1747 0 CFISH_DECREF(retval);
1748 0 sv_2mortal( ST(0) );
1749 0 XSRETURN(1);
1750 }
1751  
1752 XS_INTERNAL(XS_Clownfish_Method_get_name);
1753 0 XS_INTERNAL(XS_Clownfish_Method_get_name) {
1754 0 dXSARGS;
1755 cfish_Method* arg_self;
1756 CFISH_Method_Get_Name_t method;
1757 cfish_String* retval;
1758  
1759 CFISH_UNUSED_VAR(cv);
1760 0 SP -= items;
1761 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1762 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1763 }
1764  
1765 /* Extract vars from Perl stack. */
1766 0 arg_self = (cfish_Method*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_METHOD, NULL);
1767  
1768 /* Execute */
1769 0 method = CFISH_METHOD_PTR(CFISH_METHOD, CFISH_Method_Get_Name);
1770 0 retval = method(arg_self);
1771 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1772 0 sv_2mortal( ST(0) );
1773 0 XSRETURN(1);
1774 }
1775  
1776 XS_INTERNAL(XS_Clownfish_Method_set_host_alias);
1777 0 XS_INTERNAL(XS_Clownfish_Method_set_host_alias) {
1778 0 dXSARGS;
1779 SV *sv;
1780 cfish_Method* arg_self;
1781 cfish_String* arg_name;
1782 CFISH_Method_Set_Host_Alias_t method;
1783  
1784 CFISH_UNUSED_VAR(cv);
1785 0 SP -= items;
1786 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1787 0 XSBind_invalid_args_error(aTHX_ cv, "self, name");
1788 }
1789  
1790 /* Extract vars from Perl stack. */
1791 0 arg_self = (cfish_Method*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_METHOD, NULL);
1792 0 sv = ST(1);
1793 0 arg_name = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "name", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1794  
1795 /* Execute */
1796 0 method = CFISH_METHOD_PTR(CFISH_METHOD, CFISH_Method_Set_Host_Alias);
1797 0 method(arg_self, arg_name);
1798 0 XSRETURN(0);
1799 }
1800  
1801 XS_INTERNAL(XS_Clownfish_Method_get_host_alias);
1802 0 XS_INTERNAL(XS_Clownfish_Method_get_host_alias) {
1803 0 dXSARGS;
1804 cfish_Method* arg_self;
1805 CFISH_Method_Get_Host_Alias_t method;
1806 cfish_String* retval;
1807  
1808 CFISH_UNUSED_VAR(cv);
1809 0 SP -= items;
1810 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1811 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1812 }
1813  
1814 /* Extract vars from Perl stack. */
1815 0 arg_self = (cfish_Method*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_METHOD, NULL);
1816  
1817 /* Execute */
1818 0 method = CFISH_METHOD_PTR(CFISH_METHOD, CFISH_Method_Get_Host_Alias);
1819 0 retval = method(arg_self);
1820 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1821 0 sv_2mortal( ST(0) );
1822 0 XSRETURN(1);
1823 }
1824  
1825 XS_INTERNAL(XS_Clownfish_Method_is_excluded_from_host);
1826 0 XS_INTERNAL(XS_Clownfish_Method_is_excluded_from_host) {
1827 0 dXSARGS;
1828 cfish_Method* arg_self;
1829 CFISH_Method_Is_Excluded_From_Host_t method;
1830 bool retval;
1831  
1832 CFISH_UNUSED_VAR(cv);
1833 0 SP -= items;
1834 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1835 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1836 }
1837  
1838 /* Extract vars from Perl stack. */
1839 0 arg_self = (cfish_Method*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_METHOD, NULL);
1840  
1841 /* Execute */
1842 0 method = CFISH_METHOD_PTR(CFISH_METHOD, CFISH_Method_Is_Excluded_From_Host);
1843 0 retval = method(arg_self);
1844 0 ST(0) = newSViv(!!retval);
1845 0 sv_2mortal( ST(0) );
1846 0 XSRETURN(1);
1847 }
1848  
1849 XS_INTERNAL(XS_Clownfish_Method_host_name);
1850 0 XS_INTERNAL(XS_Clownfish_Method_host_name) {
1851 0 dXSARGS;
1852 cfish_Method* arg_self;
1853 CFISH_Method_Host_Name_t method;
1854 cfish_String* retval;
1855  
1856 CFISH_UNUSED_VAR(cv);
1857 0 SP -= items;
1858 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1859 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1860 }
1861  
1862 /* Extract vars from Perl stack. */
1863 0 arg_self = (cfish_Method*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_METHOD, NULL);
1864  
1865 /* Execute */
1866 0 method = CFISH_METHOD_PTR(CFISH_METHOD, CFISH_Method_Host_Name);
1867 0 retval = method(arg_self);
1868 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1869 0 CFISH_DECREF(retval);
1870 0 sv_2mortal( ST(0) );
1871 0 XSRETURN(1);
1872 }
1873  
1874 XS_INTERNAL(XS_Clownfish_String_cat);
1875 0 XS_INTERNAL(XS_Clownfish_String_cat) {
1876 0 dXSARGS;
1877 SV *sv;
1878 cfish_String* arg_self;
1879 cfish_String* arg_other;
1880 CFISH_Str_Cat_t method;
1881 cfish_String* retval;
1882  
1883 CFISH_UNUSED_VAR(cv);
1884 0 SP -= items;
1885 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1886 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
1887 }
1888  
1889 /* Extract vars from Perl stack. */
1890 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
1891 0 sv = ST(1);
1892 0 arg_other = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
1893  
1894 /* Execute */
1895 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Cat);
1896 0 retval = method(arg_self, arg_other);
1897 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
1898 0 CFISH_DECREF(retval);
1899 0 sv_2mortal( ST(0) );
1900 0 XSRETURN(1);
1901 }
1902  
1903 XS_INTERNAL(XS_Clownfish_String_to_i64);
1904 0 XS_INTERNAL(XS_Clownfish_String_to_i64) {
1905 0 dXSARGS;
1906 cfish_String* arg_self;
1907 CFISH_Str_To_I64_t method;
1908 int64_t retval;
1909  
1910 CFISH_UNUSED_VAR(cv);
1911 0 SP -= items;
1912 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1913 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1914 }
1915  
1916 /* Extract vars from Perl stack. */
1917 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
1918  
1919 /* Execute */
1920 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_To_I64);
1921 0 retval = method(arg_self);
1922 0 ST(0) = sizeof(IV) == 8 ? newSViv((IV)retval) : newSVnv((NV)retval);
1923 0 sv_2mortal( ST(0) );
1924 0 XSRETURN(1);
1925 }
1926  
1927 XS_INTERNAL(XS_Clownfish_String_basex_to_i64);
1928 0 XS_INTERNAL(XS_Clownfish_String_basex_to_i64) {
1929 0 dXSARGS;
1930 SV *sv;
1931 cfish_String* arg_self;
1932 uint32_t arg_base;
1933 CFISH_Str_BaseX_To_I64_t method;
1934 int64_t retval;
1935  
1936 CFISH_UNUSED_VAR(cv);
1937 0 SP -= items;
1938 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1939 0 XSBind_invalid_args_error(aTHX_ cv, "self, base");
1940 }
1941  
1942 /* Extract vars from Perl stack. */
1943 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
1944 0 sv = ST(1);
1945 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
1946 0 XSBind_undef_arg_error(aTHX_ "base");
1947 }
1948 0 arg_base = (uint32_t)SvUV(sv);
1949  
1950 /* Execute */
1951 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_BaseX_To_I64);
1952 0 retval = method(arg_self, arg_base);
1953 0 ST(0) = sizeof(IV) == 8 ? newSViv((IV)retval) : newSVnv((NV)retval);
1954 0 sv_2mortal( ST(0) );
1955 0 XSRETURN(1);
1956 }
1957  
1958 XS_INTERNAL(XS_Clownfish_String_to_f64);
1959 0 XS_INTERNAL(XS_Clownfish_String_to_f64) {
1960 0 dXSARGS;
1961 cfish_String* arg_self;
1962 CFISH_Str_To_F64_t method;
1963 double retval;
1964  
1965 CFISH_UNUSED_VAR(cv);
1966 0 SP -= items;
1967 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
1968 0 XSBind_invalid_args_error(aTHX_ cv, "self");
1969 }
1970  
1971 /* Extract vars from Perl stack. */
1972 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
1973  
1974 /* Execute */
1975 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_To_F64);
1976 0 retval = method(arg_self);
1977 0 ST(0) = newSVnv(retval);
1978 0 sv_2mortal( ST(0) );
1979 0 XSRETURN(1);
1980 }
1981  
1982 XS_INTERNAL(XS_Clownfish_String_starts_with);
1983 0 XS_INTERNAL(XS_Clownfish_String_starts_with) {
1984 0 dXSARGS;
1985 SV *sv;
1986 cfish_String* arg_self;
1987 cfish_String* arg_prefix;
1988 CFISH_Str_Starts_With_t method;
1989 bool retval;
1990  
1991 CFISH_UNUSED_VAR(cv);
1992 0 SP -= items;
1993 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
1994 0 XSBind_invalid_args_error(aTHX_ cv, "self, prefix");
1995 }
1996  
1997 /* Extract vars from Perl stack. */
1998 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
1999 0 sv = ST(1);
2000 0 arg_prefix = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "prefix", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
2001  
2002 /* Execute */
2003 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Starts_With);
2004 0 retval = method(arg_self, arg_prefix);
2005 0 ST(0) = newSViv(!!retval);
2006 0 sv_2mortal( ST(0) );
2007 0 XSRETURN(1);
2008 }
2009  
2010 XS_INTERNAL(XS_Clownfish_String_ends_with);
2011 0 XS_INTERNAL(XS_Clownfish_String_ends_with) {
2012 0 dXSARGS;
2013 SV *sv;
2014 cfish_String* arg_self;
2015 cfish_String* arg_suffix;
2016 CFISH_Str_Ends_With_t method;
2017 bool retval;
2018  
2019 CFISH_UNUSED_VAR(cv);
2020 0 SP -= items;
2021 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2022 0 XSBind_invalid_args_error(aTHX_ cv, "self, suffix");
2023 }
2024  
2025 /* Extract vars from Perl stack. */
2026 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2027 0 sv = ST(1);
2028 0 arg_suffix = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "suffix", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
2029  
2030 /* Execute */
2031 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Ends_With);
2032 0 retval = method(arg_self, arg_suffix);
2033 0 ST(0) = newSViv(!!retval);
2034 0 sv_2mortal( ST(0) );
2035 0 XSRETURN(1);
2036 }
2037  
2038 XS_INTERNAL(XS_Clownfish_String_contains);
2039 0 XS_INTERNAL(XS_Clownfish_String_contains) {
2040 0 dXSARGS;
2041 SV *sv;
2042 cfish_String* arg_self;
2043 cfish_String* arg_substring;
2044 CFISH_Str_Contains_t method;
2045 bool retval;
2046  
2047 CFISH_UNUSED_VAR(cv);
2048 0 SP -= items;
2049 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2050 0 XSBind_invalid_args_error(aTHX_ cv, "self, substring");
2051 }
2052  
2053 /* Extract vars from Perl stack. */
2054 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2055 0 sv = ST(1);
2056 0 arg_substring = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "substring", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
2057  
2058 /* Execute */
2059 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Contains);
2060 0 retval = method(arg_self, arg_substring);
2061 0 ST(0) = newSViv(!!retval);
2062 0 sv_2mortal( ST(0) );
2063 0 XSRETURN(1);
2064 }
2065  
2066 XS_INTERNAL(XS_Clownfish_String_find);
2067 0 XS_INTERNAL(XS_Clownfish_String_find) {
2068 0 dXSARGS;
2069 SV *sv;
2070 cfish_String* arg_self;
2071 cfish_String* arg_substring;
2072 CFISH_Str_Find_t method;
2073 cfish_StringIterator* retval;
2074  
2075 CFISH_UNUSED_VAR(cv);
2076 0 SP -= items;
2077 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2078 0 XSBind_invalid_args_error(aTHX_ cv, "self, substring");
2079 }
2080  
2081 /* Extract vars from Perl stack. */
2082 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2083 0 sv = ST(1);
2084 0 arg_substring = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "substring", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
2085  
2086 /* Execute */
2087 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Find);
2088 0 retval = method(arg_self, arg_substring);
2089 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2090 0 CFISH_DECREF(retval);
2091 0 sv_2mortal( ST(0) );
2092 0 XSRETURN(1);
2093 }
2094  
2095 XS_INTERNAL(XS_Clownfish_String_equals);
2096 0 XS_INTERNAL(XS_Clownfish_String_equals) {
2097 0 dXSARGS;
2098 SV *sv;
2099 cfish_String* arg_self;
2100 cfish_Obj* arg_other;
2101 CFISH_Str_Equals_t method;
2102 bool retval;
2103  
2104 CFISH_UNUSED_VAR(cv);
2105 0 SP -= items;
2106 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2107 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
2108 }
2109  
2110 /* Extract vars from Perl stack. */
2111 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2112 0 sv = ST(1);
2113 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
2114  
2115 /* Execute */
2116 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Equals);
2117 0 retval = method(arg_self, arg_other);
2118 0 ST(0) = newSViv(!!retval);
2119 0 sv_2mortal( ST(0) );
2120 0 XSRETURN(1);
2121 }
2122  
2123 XS_INTERNAL(XS_Clownfish_String_length);
2124 1 XS_INTERNAL(XS_Clownfish_String_length) {
2125 1 dXSARGS;
2126 cfish_String* arg_self;
2127 CFISH_Str_Length_t method;
2128 size_t retval;
2129  
2130 CFISH_UNUSED_VAR(cv);
2131 1 SP -= items;
2132 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 1 0 1
2133 1 XSBind_invalid_args_error(aTHX_ cv, "self");
2134 }
2135  
2136 /* Extract vars from Perl stack. */
2137 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2138  
2139 /* Execute */
2140 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Length);
2141 0 retval = method(arg_self);
2142 0 ST(0) = newSViv(retval);
2143 0 sv_2mortal( ST(0) );
2144 0 XSRETURN(1);
2145 }
2146  
2147 XS_INTERNAL(XS_Clownfish_String_get_size);
2148 0 XS_INTERNAL(XS_Clownfish_String_get_size) {
2149 0 dXSARGS;
2150 cfish_String* arg_self;
2151 CFISH_Str_Get_Size_t method;
2152 size_t retval;
2153  
2154 CFISH_UNUSED_VAR(cv);
2155 0 SP -= items;
2156 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2157 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2158 }
2159  
2160 /* Extract vars from Perl stack. */
2161 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2162  
2163 /* Execute */
2164 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Get_Size);
2165 0 retval = method(arg_self);
2166 0 ST(0) = newSViv(retval);
2167 0 sv_2mortal( ST(0) );
2168 0 XSRETURN(1);
2169 }
2170  
2171 XS_INTERNAL(XS_Clownfish_String_to_bytebuf);
2172 0 XS_INTERNAL(XS_Clownfish_String_to_bytebuf) {
2173 0 dXSARGS;
2174 cfish_String* arg_self;
2175 CFISH_Str_To_ByteBuf_t method;
2176 cfish_ByteBuf* retval;
2177  
2178 CFISH_UNUSED_VAR(cv);
2179 0 SP -= items;
2180 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2181 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2182 }
2183  
2184 /* Extract vars from Perl stack. */
2185 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2186  
2187 /* Execute */
2188 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_To_ByteBuf);
2189 0 retval = method(arg_self);
2190 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2191 0 CFISH_DECREF(retval);
2192 0 sv_2mortal( ST(0) );
2193 0 XSRETURN(1);
2194 }
2195  
2196 XS_INTERNAL(XS_Clownfish_String_clone);
2197 0 XS_INTERNAL(XS_Clownfish_String_clone) {
2198 0 dXSARGS;
2199 cfish_String* arg_self;
2200 CFISH_Str_Clone_t method;
2201 cfish_String* retval;
2202  
2203 CFISH_UNUSED_VAR(cv);
2204 0 SP -= items;
2205 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2206 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2207 }
2208  
2209 /* Extract vars from Perl stack. */
2210 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2211  
2212 /* Execute */
2213 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Clone);
2214 0 retval = method(arg_self);
2215 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2216 0 CFISH_DECREF(retval);
2217 0 sv_2mortal( ST(0) );
2218 0 XSRETURN(1);
2219 }
2220  
2221 XS_INTERNAL(XS_Clownfish_String_is_copy_on_incref);
2222 0 XS_INTERNAL(XS_Clownfish_String_is_copy_on_incref) {
2223 0 dXSARGS;
2224 cfish_String* arg_self;
2225 CFISH_Str_Is_Copy_On_IncRef_t method;
2226 bool retval;
2227  
2228 CFISH_UNUSED_VAR(cv);
2229 0 SP -= items;
2230 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2231 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2232 }
2233  
2234 /* Extract vars from Perl stack. */
2235 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2236  
2237 /* Execute */
2238 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Is_Copy_On_IncRef);
2239 0 retval = method(arg_self);
2240 0 ST(0) = newSViv(!!retval);
2241 0 sv_2mortal( ST(0) );
2242 0 XSRETURN(1);
2243 }
2244  
2245 XS_INTERNAL(XS_Clownfish_String_compare_to);
2246 0 XS_INTERNAL(XS_Clownfish_String_compare_to) {
2247 0 dXSARGS;
2248 SV *sv;
2249 cfish_String* arg_self;
2250 cfish_Obj* arg_other;
2251 CFISH_Str_Compare_To_t method;
2252 int32_t retval;
2253  
2254 CFISH_UNUSED_VAR(cv);
2255 0 SP -= items;
2256 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2257 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
2258 }
2259  
2260 /* Extract vars from Perl stack. */
2261 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2262 0 sv = ST(1);
2263 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
2264  
2265 /* Execute */
2266 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Compare_To);
2267 0 retval = method(arg_self, arg_other);
2268 0 ST(0) = newSViv(retval);
2269 0 sv_2mortal( ST(0) );
2270 0 XSRETURN(1);
2271 }
2272  
2273 XS_INTERNAL(XS_Clownfish_String_hash_sum);
2274 0 XS_INTERNAL(XS_Clownfish_String_hash_sum) {
2275 0 dXSARGS;
2276 cfish_String* arg_self;
2277 CFISH_Str_Hash_Sum_t method;
2278 size_t retval;
2279  
2280 CFISH_UNUSED_VAR(cv);
2281 0 SP -= items;
2282 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2283 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2284 }
2285  
2286 /* Extract vars from Perl stack. */
2287 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2288  
2289 /* Execute */
2290 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Hash_Sum);
2291 0 retval = method(arg_self);
2292 0 ST(0) = newSViv(retval);
2293 0 sv_2mortal( ST(0) );
2294 0 XSRETURN(1);
2295 }
2296  
2297 XS_INTERNAL(XS_Clownfish_String_to_string);
2298 0 XS_INTERNAL(XS_Clownfish_String_to_string) {
2299 0 dXSARGS;
2300 cfish_String* arg_self;
2301 CFISH_Str_To_String_t method;
2302 cfish_String* retval;
2303  
2304 CFISH_UNUSED_VAR(cv);
2305 0 SP -= items;
2306 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2307 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2308 }
2309  
2310 /* Extract vars from Perl stack. */
2311 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2312  
2313 /* Execute */
2314 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_To_String);
2315 0 retval = method(arg_self);
2316 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2317 0 CFISH_DECREF(retval);
2318 0 sv_2mortal( ST(0) );
2319 0 XSRETURN(1);
2320 }
2321  
2322 XS_INTERNAL(XS_Clownfish_String_trim);
2323 0 XS_INTERNAL(XS_Clownfish_String_trim) {
2324 0 dXSARGS;
2325 cfish_String* arg_self;
2326 CFISH_Str_Trim_t method;
2327 cfish_String* retval;
2328  
2329 CFISH_UNUSED_VAR(cv);
2330 0 SP -= items;
2331 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2332 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2333 }
2334  
2335 /* Extract vars from Perl stack. */
2336 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2337  
2338 /* Execute */
2339 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Trim);
2340 0 retval = method(arg_self);
2341 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2342 0 CFISH_DECREF(retval);
2343 0 sv_2mortal( ST(0) );
2344 0 XSRETURN(1);
2345 }
2346  
2347 XS_INTERNAL(XS_Clownfish_String_trim_top);
2348 0 XS_INTERNAL(XS_Clownfish_String_trim_top) {
2349 0 dXSARGS;
2350 cfish_String* arg_self;
2351 CFISH_Str_Trim_Top_t method;
2352 cfish_String* retval;
2353  
2354 CFISH_UNUSED_VAR(cv);
2355 0 SP -= items;
2356 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2357 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2358 }
2359  
2360 /* Extract vars from Perl stack. */
2361 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2362  
2363 /* Execute */
2364 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Trim_Top);
2365 0 retval = method(arg_self);
2366 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2367 0 CFISH_DECREF(retval);
2368 0 sv_2mortal( ST(0) );
2369 0 XSRETURN(1);
2370 }
2371  
2372 XS_INTERNAL(XS_Clownfish_String_trim_tail);
2373 0 XS_INTERNAL(XS_Clownfish_String_trim_tail) {
2374 0 dXSARGS;
2375 cfish_String* arg_self;
2376 CFISH_Str_Trim_Tail_t method;
2377 cfish_String* retval;
2378  
2379 CFISH_UNUSED_VAR(cv);
2380 0 SP -= items;
2381 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2382 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2383 }
2384  
2385 /* Extract vars from Perl stack. */
2386 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2387  
2388 /* Execute */
2389 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Trim_Tail);
2390 0 retval = method(arg_self);
2391 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2392 0 CFISH_DECREF(retval);
2393 0 sv_2mortal( ST(0) );
2394 0 XSRETURN(1);
2395 }
2396  
2397 XS_INTERNAL(XS_Clownfish_String_code_point_at);
2398 0 XS_INTERNAL(XS_Clownfish_String_code_point_at) {
2399 0 dXSARGS;
2400 SV *sv;
2401 cfish_String* arg_self;
2402 size_t arg_tick;
2403 CFISH_Str_Code_Point_At_t method;
2404 int32_t retval;
2405  
2406 CFISH_UNUSED_VAR(cv);
2407 0 SP -= items;
2408 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2409 0 XSBind_invalid_args_error(aTHX_ cv, "self, tick");
2410 }
2411  
2412 /* Extract vars from Perl stack. */
2413 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2414 0 sv = ST(1);
2415 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2416 0 XSBind_undef_arg_error(aTHX_ "tick");
2417 }
2418 0 arg_tick = (size_t)SvIV(sv);
2419  
2420 /* Execute */
2421 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Code_Point_At);
2422 0 retval = method(arg_self, arg_tick);
2423 0 ST(0) = newSViv(retval);
2424 0 sv_2mortal( ST(0) );
2425 0 XSRETURN(1);
2426 }
2427  
2428 XS_INTERNAL(XS_Clownfish_String_code_point_from);
2429 0 XS_INTERNAL(XS_Clownfish_String_code_point_from) {
2430 0 dXSARGS;
2431 SV *sv;
2432 cfish_String* arg_self;
2433 size_t arg_tick;
2434 CFISH_Str_Code_Point_From_t method;
2435 int32_t retval;
2436  
2437 CFISH_UNUSED_VAR(cv);
2438 0 SP -= items;
2439 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2440 0 XSBind_invalid_args_error(aTHX_ cv, "self, tick");
2441 }
2442  
2443 /* Extract vars from Perl stack. */
2444 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2445 0 sv = ST(1);
2446 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2447 0 XSBind_undef_arg_error(aTHX_ "tick");
2448 }
2449 0 arg_tick = (size_t)SvIV(sv);
2450  
2451 /* Execute */
2452 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Code_Point_From);
2453 0 retval = method(arg_self, arg_tick);
2454 0 ST(0) = newSViv(retval);
2455 0 sv_2mortal( ST(0) );
2456 0 XSRETURN(1);
2457 }
2458  
2459 XS_INTERNAL(XS_Clownfish_String_substring);
2460 1 XS_INTERNAL(XS_Clownfish_String_substring) {
2461 1 dXSARGS;
2462 static const XSBind_ParamSpec param_specs[2] = {
2463 XSBIND_PARAM("offset", 1),
2464 XSBIND_PARAM("length", 1)
2465 };
2466 int32_t locations[2];
2467 SV *sv;
2468 cfish_String* arg_self;
2469 size_t arg_offset;
2470 size_t arg_length;
2471 CFISH_Str_SubString_t method;
2472 cfish_String* retval;
2473  
2474 CFISH_UNUSED_VAR(cv);
2475 1 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 1 1
2476 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
2477 }
2478 1 SP -= items;
2479  
2480 /* Locate args on Perl stack. */
2481 1 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
2482 locations, 2);
2483 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2484 0 sv = ST(locations[0]);
2485 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2486 0 XSBind_undef_arg_error(aTHX_ "offset");
2487 }
2488 0 arg_offset = (size_t)SvIV(sv);
2489 0 sv = ST(locations[1]);
2490 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2491 0 XSBind_undef_arg_error(aTHX_ "length");
2492 }
2493 0 arg_length = (size_t)SvIV(sv);
2494  
2495 /* Execute */
2496 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_SubString);
2497 0 retval = method(arg_self, arg_offset, arg_length);
2498 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2499 0 CFISH_DECREF(retval);
2500 0 sv_2mortal( ST(0) );
2501 0 XSRETURN(1);
2502 }
2503  
2504 XS_INTERNAL(XS_Clownfish_String_top);
2505 1 XS_INTERNAL(XS_Clownfish_String_top) {
2506 1 dXSARGS;
2507 cfish_String* arg_self;
2508 CFISH_Str_Top_t method;
2509 cfish_StringIterator* retval;
2510  
2511 CFISH_UNUSED_VAR(cv);
2512 1 SP -= items;
2513 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
2514 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2515 }
2516  
2517 /* Extract vars from Perl stack. */
2518 1 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2519  
2520 /* Execute */
2521 1 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Top);
2522 1 retval = method(arg_self);
2523 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2524 1 CFISH_DECREF(retval);
2525 1 sv_2mortal( ST(0) );
2526 1 XSRETURN(1);
2527 }
2528  
2529 XS_INTERNAL(XS_Clownfish_String_tail);
2530 0 XS_INTERNAL(XS_Clownfish_String_tail) {
2531 0 dXSARGS;
2532 cfish_String* arg_self;
2533 CFISH_Str_Tail_t method;
2534 cfish_StringIterator* retval;
2535  
2536 CFISH_UNUSED_VAR(cv);
2537 0 SP -= items;
2538 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2539 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2540 }
2541  
2542 /* Extract vars from Perl stack. */
2543 0 arg_self = (cfish_String*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRING, NULL);
2544  
2545 /* Execute */
2546 0 method = CFISH_METHOD_PTR(CFISH_STRING, CFISH_Str_Tail);
2547 0 retval = method(arg_self);
2548 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2549 0 CFISH_DECREF(retval);
2550 0 sv_2mortal( ST(0) );
2551 0 XSRETURN(1);
2552 }
2553  
2554 XS_INTERNAL(XS_Clownfish_StringIterator_clone);
2555 0 XS_INTERNAL(XS_Clownfish_StringIterator_clone) {
2556 0 dXSARGS;
2557 cfish_StringIterator* arg_self;
2558 CFISH_StrIter_Clone_t method;
2559 cfish_StringIterator* retval;
2560  
2561 CFISH_UNUSED_VAR(cv);
2562 0 SP -= items;
2563 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2564 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2565 }
2566  
2567 /* Extract vars from Perl stack. */
2568 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2569  
2570 /* Execute */
2571 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Clone);
2572 0 retval = method(arg_self);
2573 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
2574 0 CFISH_DECREF(retval);
2575 0 sv_2mortal( ST(0) );
2576 0 XSRETURN(1);
2577 }
2578  
2579 XS_INTERNAL(XS_Clownfish_StringIterator_assign);
2580 0 XS_INTERNAL(XS_Clownfish_StringIterator_assign) {
2581 0 dXSARGS;
2582 SV *sv;
2583 cfish_StringIterator* arg_self;
2584 cfish_StringIterator* arg_other;
2585 CFISH_StrIter_Assign_t method;
2586  
2587 CFISH_UNUSED_VAR(cv);
2588 0 SP -= items;
2589 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2590 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
2591 }
2592  
2593 /* Extract vars from Perl stack. */
2594 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2595 0 sv = ST(1);
2596 0 arg_other = (cfish_StringIterator*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_STRINGITERATOR, NULL);
2597  
2598 /* Execute */
2599 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Assign);
2600 0 method(arg_self, arg_other);
2601 0 XSRETURN(0);
2602 }
2603  
2604 XS_INTERNAL(XS_Clownfish_StringIterator_equals);
2605 0 XS_INTERNAL(XS_Clownfish_StringIterator_equals) {
2606 0 dXSARGS;
2607 SV *sv;
2608 cfish_StringIterator* arg_self;
2609 cfish_Obj* arg_other;
2610 CFISH_StrIter_Equals_t method;
2611 bool retval;
2612  
2613 CFISH_UNUSED_VAR(cv);
2614 0 SP -= items;
2615 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2616 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
2617 }
2618  
2619 /* Extract vars from Perl stack. */
2620 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2621 0 sv = ST(1);
2622 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
2623  
2624 /* Execute */
2625 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Equals);
2626 0 retval = method(arg_self, arg_other);
2627 0 ST(0) = newSViv(!!retval);
2628 0 sv_2mortal( ST(0) );
2629 0 XSRETURN(1);
2630 }
2631  
2632 XS_INTERNAL(XS_Clownfish_StringIterator_compare_to);
2633 0 XS_INTERNAL(XS_Clownfish_StringIterator_compare_to) {
2634 0 dXSARGS;
2635 SV *sv;
2636 cfish_StringIterator* arg_self;
2637 cfish_Obj* arg_other;
2638 CFISH_StrIter_Compare_To_t method;
2639 int32_t retval;
2640  
2641 CFISH_UNUSED_VAR(cv);
2642 0 SP -= items;
2643 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2644 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
2645 }
2646  
2647 /* Extract vars from Perl stack. */
2648 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2649 0 sv = ST(1);
2650 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
2651  
2652 /* Execute */
2653 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Compare_To);
2654 0 retval = method(arg_self, arg_other);
2655 0 ST(0) = newSViv(retval);
2656 0 sv_2mortal( ST(0) );
2657 0 XSRETURN(1);
2658 }
2659  
2660 XS_INTERNAL(XS_Clownfish_StringIterator_has_next);
2661 0 XS_INTERNAL(XS_Clownfish_StringIterator_has_next) {
2662 0 dXSARGS;
2663 cfish_StringIterator* arg_self;
2664 CFISH_StrIter_Has_Next_t method;
2665 bool retval;
2666  
2667 CFISH_UNUSED_VAR(cv);
2668 0 SP -= items;
2669 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2670 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2671 }
2672  
2673 /* Extract vars from Perl stack. */
2674 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2675  
2676 /* Execute */
2677 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Has_Next);
2678 0 retval = method(arg_self);
2679 0 ST(0) = newSViv(!!retval);
2680 0 sv_2mortal( ST(0) );
2681 0 XSRETURN(1);
2682 }
2683  
2684 XS_INTERNAL(XS_Clownfish_StringIterator_has_prev);
2685 0 XS_INTERNAL(XS_Clownfish_StringIterator_has_prev) {
2686 0 dXSARGS;
2687 cfish_StringIterator* arg_self;
2688 CFISH_StrIter_Has_Prev_t method;
2689 bool retval;
2690  
2691 CFISH_UNUSED_VAR(cv);
2692 0 SP -= items;
2693 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2694 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2695 }
2696  
2697 /* Extract vars from Perl stack. */
2698 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2699  
2700 /* Execute */
2701 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Has_Prev);
2702 0 retval = method(arg_self);
2703 0 ST(0) = newSViv(!!retval);
2704 0 sv_2mortal( ST(0) );
2705 0 XSRETURN(1);
2706 }
2707  
2708 XS_INTERNAL(XS_Clownfish_StringIterator_advance);
2709 0 XS_INTERNAL(XS_Clownfish_StringIterator_advance) {
2710 0 dXSARGS;
2711 SV *sv;
2712 cfish_StringIterator* arg_self;
2713 size_t arg_num;
2714 CFISH_StrIter_Advance_t method;
2715 size_t retval;
2716  
2717 CFISH_UNUSED_VAR(cv);
2718 0 SP -= items;
2719 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2720 0 XSBind_invalid_args_error(aTHX_ cv, "self, num");
2721 }
2722  
2723 /* Extract vars from Perl stack. */
2724 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2725 0 sv = ST(1);
2726 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2727 0 XSBind_undef_arg_error(aTHX_ "num");
2728 }
2729 0 arg_num = (size_t)SvIV(sv);
2730  
2731 /* Execute */
2732 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Advance);
2733 0 retval = method(arg_self, arg_num);
2734 0 ST(0) = newSViv(retval);
2735 0 sv_2mortal( ST(0) );
2736 0 XSRETURN(1);
2737 }
2738  
2739 XS_INTERNAL(XS_Clownfish_StringIterator_recede);
2740 0 XS_INTERNAL(XS_Clownfish_StringIterator_recede) {
2741 0 dXSARGS;
2742 SV *sv;
2743 cfish_StringIterator* arg_self;
2744 size_t arg_num;
2745 CFISH_StrIter_Recede_t method;
2746 size_t retval;
2747  
2748 CFISH_UNUSED_VAR(cv);
2749 0 SP -= items;
2750 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2751 0 XSBind_invalid_args_error(aTHX_ cv, "self, num");
2752 }
2753  
2754 /* Extract vars from Perl stack. */
2755 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2756 0 sv = ST(1);
2757 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2758 0 XSBind_undef_arg_error(aTHX_ "num");
2759 }
2760 0 arg_num = (size_t)SvIV(sv);
2761  
2762 /* Execute */
2763 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Recede);
2764 0 retval = method(arg_self, arg_num);
2765 0 ST(0) = newSViv(retval);
2766 0 sv_2mortal( ST(0) );
2767 0 XSRETURN(1);
2768 }
2769  
2770 XS_INTERNAL(XS_Clownfish_StringIterator_skip_whitespace);
2771 0 XS_INTERNAL(XS_Clownfish_StringIterator_skip_whitespace) {
2772 0 dXSARGS;
2773 cfish_StringIterator* arg_self;
2774 CFISH_StrIter_Skip_Whitespace_t method;
2775 size_t retval;
2776  
2777 CFISH_UNUSED_VAR(cv);
2778 0 SP -= items;
2779 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2780 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2781 }
2782  
2783 /* Extract vars from Perl stack. */
2784 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2785  
2786 /* Execute */
2787 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Skip_Whitespace);
2788 0 retval = method(arg_self);
2789 0 ST(0) = newSViv(retval);
2790 0 sv_2mortal( ST(0) );
2791 0 XSRETURN(1);
2792 }
2793  
2794 XS_INTERNAL(XS_Clownfish_StringIterator_skip_whitespace_back);
2795 0 XS_INTERNAL(XS_Clownfish_StringIterator_skip_whitespace_back) {
2796 0 dXSARGS;
2797 cfish_StringIterator* arg_self;
2798 CFISH_StrIter_Skip_Whitespace_Back_t method;
2799 size_t retval;
2800  
2801 CFISH_UNUSED_VAR(cv);
2802 0 SP -= items;
2803 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
2804 0 XSBind_invalid_args_error(aTHX_ cv, "self");
2805 }
2806  
2807 /* Extract vars from Perl stack. */
2808 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2809  
2810 /* Execute */
2811 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Skip_Whitespace_Back);
2812 0 retval = method(arg_self);
2813 0 ST(0) = newSViv(retval);
2814 0 sv_2mortal( ST(0) );
2815 0 XSRETURN(1);
2816 }
2817  
2818 XS_INTERNAL(XS_Clownfish_StringIterator_starts_with);
2819 0 XS_INTERNAL(XS_Clownfish_StringIterator_starts_with) {
2820 0 dXSARGS;
2821 SV *sv;
2822 cfish_StringIterator* arg_self;
2823 cfish_String* arg_prefix;
2824 CFISH_StrIter_Starts_With_t method;
2825 bool retval;
2826  
2827 CFISH_UNUSED_VAR(cv);
2828 0 SP -= items;
2829 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2830 0 XSBind_invalid_args_error(aTHX_ cv, "self, prefix");
2831 }
2832  
2833 /* Extract vars from Perl stack. */
2834 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2835 0 sv = ST(1);
2836 0 arg_prefix = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "prefix", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
2837  
2838 /* Execute */
2839 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Starts_With);
2840 0 retval = method(arg_self, arg_prefix);
2841 0 ST(0) = newSViv(!!retval);
2842 0 sv_2mortal( ST(0) );
2843 0 XSRETURN(1);
2844 }
2845  
2846 XS_INTERNAL(XS_Clownfish_StringIterator_ends_with);
2847 0 XS_INTERNAL(XS_Clownfish_StringIterator_ends_with) {
2848 0 dXSARGS;
2849 SV *sv;
2850 cfish_StringIterator* arg_self;
2851 cfish_String* arg_suffix;
2852 CFISH_StrIter_Ends_With_t method;
2853 bool retval;
2854  
2855 CFISH_UNUSED_VAR(cv);
2856 0 SP -= items;
2857 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2858 0 XSBind_invalid_args_error(aTHX_ cv, "self, suffix");
2859 }
2860  
2861 /* Extract vars from Perl stack. */
2862 0 arg_self = (cfish_StringIterator*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_STRINGITERATOR, NULL);
2863 0 sv = ST(1);
2864 0 arg_suffix = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "suffix", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
2865  
2866 /* Execute */
2867 0 method = CFISH_METHOD_PTR(CFISH_STRINGITERATOR, CFISH_StrIter_Ends_With);
2868 0 retval = method(arg_self, arg_suffix);
2869 0 ST(0) = newSViv(!!retval);
2870 0 sv_2mortal( ST(0) );
2871 0 XSRETURN(1);
2872 }
2873  
2874 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatch_run);
2875 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatch_run) {
2876 0 dXSARGS;
2877 SV *sv;
2878 cfish_TestBatch* arg_self;
2879 cfish_TestBatchRunner* arg_runner;
2880 CFISH_TestBatch_Run_t method;
2881  
2882 CFISH_UNUSED_VAR(cv);
2883 0 SP -= items;
2884 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2885 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
2886 }
2887  
2888 /* Extract vars from Perl stack. */
2889 0 arg_self = (cfish_TestBatch*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTBATCH, NULL);
2890 0 sv = ST(1);
2891 0 arg_runner = (cfish_TestBatchRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTBATCHRUNNER, NULL);
2892  
2893 /* Execute */
2894 0 method = CFISH_METHOD_PTR(CFISH_TESTBATCH, CFISH_TestBatch_Run);
2895 0 method(arg_self, arg_runner);
2896 0 XSRETURN(0);
2897 }
2898  
2899 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_new);
2900 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_new) {
2901 0 dXSARGS;
2902 static const XSBind_ParamSpec param_specs[1] = {
2903 XSBIND_PARAM("formatter", 1)
2904 };
2905 int32_t locations[1];
2906 SV *sv;
2907 cfish_TestBatchRunner* arg_self;
2908 cfish_TestFormatter* arg_formatter;
2909 cfish_TestBatchRunner* retval;
2910  
2911 CFISH_UNUSED_VAR(cv);
2912 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
2913 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
2914 }
2915 0 SP -= items;
2916  
2917 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
2918 locations, 1);
2919 0 sv = ST(locations[0]);
2920 0 arg_formatter = (cfish_TestFormatter*)XSBind_arg_to_cfish(aTHX_ sv, "formatter", CFISH_TESTFORMATTER, NULL);
2921 0 arg_self = (cfish_TestBatchRunner*)XSBind_new_blank_obj(aTHX_ ST(0));
2922  
2923 0 retval = cfish_TestBatchRunner_init(arg_self, arg_formatter);
2924 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
2925 0 XSRETURN(1);
2926 }
2927  
2928  
2929 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_run_batch);
2930 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_run_batch) {
2931 0 dXSARGS;
2932 SV *sv;
2933 cfish_TestBatchRunner* arg_self;
2934 cfish_TestBatch* arg_batch;
2935 CFISH_TestBatchRunner_Run_Batch_t method;
2936 bool retval;
2937  
2938 CFISH_UNUSED_VAR(cv);
2939 0 SP -= items;
2940 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
2941 0 XSBind_invalid_args_error(aTHX_ cv, "self, batch");
2942 }
2943  
2944 /* Extract vars from Perl stack. */
2945 0 arg_self = (cfish_TestBatchRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTBATCHRUNNER, NULL);
2946 0 sv = ST(1);
2947 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
2948  
2949 /* Execute */
2950 0 method = CFISH_METHOD_PTR(CFISH_TESTBATCHRUNNER, CFISH_TestBatchRunner_Run_Batch);
2951 0 retval = method(arg_self, arg_batch);
2952 0 ST(0) = newSViv(!!retval);
2953 0 sv_2mortal( ST(0) );
2954 0 XSRETURN(1);
2955 }
2956  
2957 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_plan);
2958 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_plan) {
2959 0 dXSARGS;
2960 static const XSBind_ParamSpec param_specs[2] = {
2961 XSBIND_PARAM("batch", 1),
2962 XSBIND_PARAM("num_planned", 1)
2963 };
2964 int32_t locations[2];
2965 SV *sv;
2966 cfish_TestBatchRunner* arg_self;
2967 cfish_TestBatch* arg_batch;
2968 uint32_t arg_num_planned;
2969 CFISH_TestBatchRunner_Plan_t method;
2970  
2971 CFISH_UNUSED_VAR(cv);
2972 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
2973 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
2974 }
2975 0 SP -= items;
2976  
2977 /* Locate args on Perl stack. */
2978 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
2979 locations, 2);
2980 0 arg_self = (cfish_TestBatchRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTBATCHRUNNER, NULL);
2981 0 sv = ST(locations[0]);
2982 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
2983 0 sv = ST(locations[1]);
2984 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
2985 0 XSBind_undef_arg_error(aTHX_ "num_planned");
2986 }
2987 0 arg_num_planned = (uint32_t)SvUV(sv);
2988  
2989 /* Execute */
2990 0 method = CFISH_METHOD_PTR(CFISH_TESTBATCHRUNNER, CFISH_TestBatchRunner_Plan);
2991 0 method(arg_self, arg_batch, arg_num_planned);
2992 0 XSRETURN(0);
2993 }
2994  
2995 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_get_num_planned);
2996 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_get_num_planned) {
2997 0 dXSARGS;
2998 cfish_TestBatchRunner* arg_self;
2999 CFISH_TestBatchRunner_Get_Num_Planned_t method;
3000 uint32_t retval;
3001  
3002 CFISH_UNUSED_VAR(cv);
3003 0 SP -= items;
3004 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3005 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3006 }
3007  
3008 /* Extract vars from Perl stack. */
3009 0 arg_self = (cfish_TestBatchRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTBATCHRUNNER, NULL);
3010  
3011 /* Execute */
3012 0 method = CFISH_METHOD_PTR(CFISH_TESTBATCHRUNNER, CFISH_TestBatchRunner_Get_Num_Planned);
3013 0 retval = method(arg_self);
3014 0 ST(0) = newSVuv(retval);
3015 0 sv_2mortal( ST(0) );
3016 0 XSRETURN(1);
3017 }
3018  
3019 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_get_num_tests);
3020 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_get_num_tests) {
3021 0 dXSARGS;
3022 cfish_TestBatchRunner* arg_self;
3023 CFISH_TestBatchRunner_Get_Num_Tests_t method;
3024 uint32_t retval;
3025  
3026 CFISH_UNUSED_VAR(cv);
3027 0 SP -= items;
3028 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3029 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3030 }
3031  
3032 /* Extract vars from Perl stack. */
3033 0 arg_self = (cfish_TestBatchRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTBATCHRUNNER, NULL);
3034  
3035 /* Execute */
3036 0 method = CFISH_METHOD_PTR(CFISH_TESTBATCHRUNNER, CFISH_TestBatchRunner_Get_Num_Tests);
3037 0 retval = method(arg_self);
3038 0 ST(0) = newSVuv(retval);
3039 0 sv_2mortal( ST(0) );
3040 0 XSRETURN(1);
3041 }
3042  
3043 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_get_num_failed);
3044 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestBatchRunner_get_num_failed) {
3045 0 dXSARGS;
3046 cfish_TestBatchRunner* arg_self;
3047 CFISH_TestBatchRunner_Get_Num_Failed_t method;
3048 uint32_t retval;
3049  
3050 CFISH_UNUSED_VAR(cv);
3051 0 SP -= items;
3052 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3053 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3054 }
3055  
3056 /* Extract vars from Perl stack. */
3057 0 arg_self = (cfish_TestBatchRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTBATCHRUNNER, NULL);
3058  
3059 /* Execute */
3060 0 method = CFISH_METHOD_PTR(CFISH_TESTBATCHRUNNER, CFISH_TestBatchRunner_Get_Num_Failed);
3061 0 retval = method(arg_self);
3062 0 ST(0) = newSVuv(retval);
3063 0 sv_2mortal( ST(0) );
3064 0 XSRETURN(1);
3065 }
3066  
3067 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatter_new);
3068 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatter_new) {
3069 0 dXSARGS;
3070 cfish_TestFormatter* arg_self;
3071 cfish_TestFormatter* retval;
3072  
3073 CFISH_UNUSED_VAR(cv);
3074 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3075 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
3076 }
3077 0 SP -= items;
3078  
3079 0 arg_self = (cfish_TestFormatter*)XSBind_new_blank_obj(aTHX_ ST(0));
3080  
3081 0 retval = cfish_TestFormatter_init(arg_self);
3082 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
3083 0 XSRETURN(1);
3084 }
3085  
3086  
3087 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatter_batch_prologue);
3088 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatter_batch_prologue) {
3089 0 dXSARGS;
3090 static const XSBind_ParamSpec param_specs[2] = {
3091 XSBIND_PARAM("batch", 1),
3092 XSBIND_PARAM("num_planned", 1)
3093 };
3094 int32_t locations[2];
3095 SV *sv;
3096 cfish_TestFormatter* arg_self;
3097 cfish_TestBatch* arg_batch;
3098 uint32_t arg_num_planned;
3099 CFISH_TestFormatter_Batch_Prologue_t method;
3100  
3101 CFISH_UNUSED_VAR(cv);
3102 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
3103 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3104 }
3105 0 SP -= items;
3106  
3107 /* Locate args on Perl stack. */
3108 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3109 locations, 2);
3110 0 arg_self = (cfish_TestFormatter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTFORMATTER, NULL);
3111 0 sv = ST(locations[0]);
3112 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
3113 0 sv = ST(locations[1]);
3114 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3115 0 XSBind_undef_arg_error(aTHX_ "num_planned");
3116 }
3117 0 arg_num_planned = (uint32_t)SvUV(sv);
3118  
3119 /* Execute */
3120 0 method = CFISH_METHOD_PTR(CFISH_TESTFORMATTER, CFISH_TestFormatter_Batch_Prologue);
3121 0 method(arg_self, arg_batch, arg_num_planned);
3122 0 XSRETURN(0);
3123 }
3124  
3125 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatter_summary);
3126 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatter_summary) {
3127 0 dXSARGS;
3128 SV *sv;
3129 cfish_TestFormatter* arg_self;
3130 cfish_TestSuiteRunner* arg_runner;
3131 CFISH_TestFormatter_Summary_t method;
3132  
3133 CFISH_UNUSED_VAR(cv);
3134 0 SP -= items;
3135 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3136 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
3137 }
3138  
3139 /* Extract vars from Perl stack. */
3140 0 arg_self = (cfish_TestFormatter*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTFORMATTER, NULL);
3141 0 sv = ST(1);
3142 0 arg_runner = (cfish_TestSuiteRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTSUITERUNNER, NULL);
3143  
3144 /* Execute */
3145 0 method = CFISH_METHOD_PTR(CFISH_TESTFORMATTER, CFISH_TestFormatter_Summary);
3146 0 method(arg_self, arg_runner);
3147 0 XSRETURN(0);
3148 }
3149  
3150 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterCF_new);
3151 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterCF_new) {
3152 0 dXSARGS;
3153 cfish_TestFormatterCF* arg_self;
3154 cfish_TestFormatterCF* retval;
3155  
3156 CFISH_UNUSED_VAR(cv);
3157 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3158 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
3159 }
3160 0 SP -= items;
3161  
3162 0 arg_self = (cfish_TestFormatterCF*)XSBind_new_blank_obj(aTHX_ ST(0));
3163  
3164 0 retval = cfish_TestFormatterCF_init(arg_self);
3165 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
3166 0 XSRETURN(1);
3167 }
3168  
3169  
3170 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterCF_batch_prologue);
3171 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterCF_batch_prologue) {
3172 0 dXSARGS;
3173 static const XSBind_ParamSpec param_specs[2] = {
3174 XSBIND_PARAM("batch", 1),
3175 XSBIND_PARAM("num_planned", 1)
3176 };
3177 int32_t locations[2];
3178 SV *sv;
3179 cfish_TestFormatterCF* arg_self;
3180 cfish_TestBatch* arg_batch;
3181 uint32_t arg_num_planned;
3182 CFISH_TestFormatterCF_Batch_Prologue_t method;
3183  
3184 CFISH_UNUSED_VAR(cv);
3185 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
3186 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3187 }
3188 0 SP -= items;
3189  
3190 /* Locate args on Perl stack. */
3191 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3192 locations, 2);
3193 0 arg_self = (cfish_TestFormatterCF*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTFORMATTERCF, NULL);
3194 0 sv = ST(locations[0]);
3195 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
3196 0 sv = ST(locations[1]);
3197 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3198 0 XSBind_undef_arg_error(aTHX_ "num_planned");
3199 }
3200 0 arg_num_planned = (uint32_t)SvUV(sv);
3201  
3202 /* Execute */
3203 0 method = CFISH_METHOD_PTR(CFISH_TESTFORMATTERCF, CFISH_TestFormatterCF_Batch_Prologue);
3204 0 method(arg_self, arg_batch, arg_num_planned);
3205 0 XSRETURN(0);
3206 }
3207  
3208 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterCF_summary);
3209 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterCF_summary) {
3210 0 dXSARGS;
3211 SV *sv;
3212 cfish_TestFormatterCF* arg_self;
3213 cfish_TestSuiteRunner* arg_runner;
3214 CFISH_TestFormatterCF_Summary_t method;
3215  
3216 CFISH_UNUSED_VAR(cv);
3217 0 SP -= items;
3218 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3219 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
3220 }
3221  
3222 /* Extract vars from Perl stack. */
3223 0 arg_self = (cfish_TestFormatterCF*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTFORMATTERCF, NULL);
3224 0 sv = ST(1);
3225 0 arg_runner = (cfish_TestSuiteRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTSUITERUNNER, NULL);
3226  
3227 /* Execute */
3228 0 method = CFISH_METHOD_PTR(CFISH_TESTFORMATTERCF, CFISH_TestFormatterCF_Summary);
3229 0 method(arg_self, arg_runner);
3230 0 XSRETURN(0);
3231 }
3232  
3233 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterTAP_new);
3234 15 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterTAP_new) {
3235 15 dXSARGS;
3236 cfish_TestFormatterTAP* arg_self;
3237 cfish_TestFormatterTAP* retval;
3238  
3239 CFISH_UNUSED_VAR(cv);
3240 15 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 15 15
3241 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
3242 }
3243 15 SP -= items;
3244  
3245 15 arg_self = (cfish_TestFormatterTAP*)XSBind_new_blank_obj(aTHX_ ST(0));
3246  
3247 15 retval = cfish_TestFormatterTAP_init(arg_self);
3248 15 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
3249 15 XSRETURN(1);
3250 }
3251  
3252  
3253 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterTAP_batch_prologue);
3254 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterTAP_batch_prologue) {
3255 0 dXSARGS;
3256 static const XSBind_ParamSpec param_specs[2] = {
3257 XSBIND_PARAM("batch", 1),
3258 XSBIND_PARAM("num_planned", 1)
3259 };
3260 int32_t locations[2];
3261 SV *sv;
3262 cfish_TestFormatterTAP* arg_self;
3263 cfish_TestBatch* arg_batch;
3264 uint32_t arg_num_planned;
3265 CFISH_TestFormatterTAP_Batch_Prologue_t method;
3266  
3267 CFISH_UNUSED_VAR(cv);
3268 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
3269 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3270 }
3271 0 SP -= items;
3272  
3273 /* Locate args on Perl stack. */
3274 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3275 locations, 2);
3276 0 arg_self = (cfish_TestFormatterTAP*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTFORMATTERTAP, NULL);
3277 0 sv = ST(locations[0]);
3278 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
3279 0 sv = ST(locations[1]);
3280 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3281 0 XSBind_undef_arg_error(aTHX_ "num_planned");
3282 }
3283 0 arg_num_planned = (uint32_t)SvUV(sv);
3284  
3285 /* Execute */
3286 0 method = CFISH_METHOD_PTR(CFISH_TESTFORMATTERTAP, CFISH_TestFormatterTAP_Batch_Prologue);
3287 0 method(arg_self, arg_batch, arg_num_planned);
3288 0 XSRETURN(0);
3289 }
3290  
3291 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterTAP_summary);
3292 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestFormatterTAP_summary) {
3293 0 dXSARGS;
3294 SV *sv;
3295 cfish_TestFormatterTAP* arg_self;
3296 cfish_TestSuiteRunner* arg_runner;
3297 CFISH_TestFormatterTAP_Summary_t method;
3298  
3299 CFISH_UNUSED_VAR(cv);
3300 0 SP -= items;
3301 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3302 0 XSBind_invalid_args_error(aTHX_ cv, "self, runner");
3303 }
3304  
3305 /* Extract vars from Perl stack. */
3306 0 arg_self = (cfish_TestFormatterTAP*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTFORMATTERTAP, NULL);
3307 0 sv = ST(1);
3308 0 arg_runner = (cfish_TestSuiteRunner*)XSBind_arg_to_cfish(aTHX_ sv, "runner", CFISH_TESTSUITERUNNER, NULL);
3309  
3310 /* Execute */
3311 0 method = CFISH_METHOD_PTR(CFISH_TESTFORMATTERTAP, CFISH_TestFormatterTAP_Summary);
3312 0 method(arg_self, arg_runner);
3313 0 XSRETURN(0);
3314 }
3315  
3316 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_new);
3317 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_new) {
3318 0 dXSARGS;
3319 cfish_TestSuite* arg_self;
3320 cfish_TestSuite* retval;
3321  
3322 CFISH_UNUSED_VAR(cv);
3323 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3324 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
3325 }
3326 0 SP -= items;
3327  
3328 0 arg_self = (cfish_TestSuite*)XSBind_new_blank_obj(aTHX_ ST(0));
3329  
3330 0 retval = cfish_TestSuite_init(arg_self);
3331 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
3332 0 XSRETURN(1);
3333 }
3334  
3335  
3336 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_add_batch);
3337 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_add_batch) {
3338 0 dXSARGS;
3339 SV *sv;
3340 cfish_TestSuite* arg_self;
3341 cfish_TestBatch* arg_batch;
3342 CFISH_TestSuite_Add_Batch_t method;
3343  
3344 CFISH_UNUSED_VAR(cv);
3345 0 SP -= items;
3346 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3347 0 XSBind_invalid_args_error(aTHX_ cv, "self, batch");
3348 }
3349  
3350 /* Extract vars from Perl stack. */
3351 0 arg_self = (cfish_TestSuite*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITE, NULL);
3352 0 sv = ST(1);
3353 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
3354  
3355 /* Execute */
3356 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITE, CFISH_TestSuite_Add_Batch);
3357 0 arg_batch = (cfish_TestBatch*)CFISH_INCREF(arg_batch);
3358 0 method(arg_self, arg_batch);
3359 0 XSRETURN(0);
3360 }
3361  
3362 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_run_batch);
3363 15 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_run_batch) {
3364 15 dXSARGS;
3365 static const XSBind_ParamSpec param_specs[2] = {
3366 XSBIND_PARAM("class_name", 1),
3367 XSBIND_PARAM("formatter", 1)
3368 };
3369 int32_t locations[2];
3370 SV *sv;
3371 cfish_TestSuite* arg_self;
3372 cfish_String* arg_class_name;
3373 cfish_TestFormatter* arg_formatter;
3374 CFISH_TestSuite_Run_Batch_t method;
3375 bool retval;
3376  
3377 CFISH_UNUSED_VAR(cv);
3378 15 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 15 15
3379 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3380 }
3381 15 SP -= items;
3382  
3383 /* Locate args on Perl stack. */
3384 15 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3385 locations, 2);
3386 15 arg_self = (cfish_TestSuite*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITE, NULL);
3387 15 sv = ST(locations[0]);
3388 15 arg_class_name = (cfish_String*)XSBind_arg_to_cfish(aTHX_ sv, "class_name", CFISH_STRING, CFISH_ALLOCA_OBJ(CFISH_STRING));
3389 15 sv = ST(locations[1]);
3390 15 arg_formatter = (cfish_TestFormatter*)XSBind_arg_to_cfish(aTHX_ sv, "formatter", CFISH_TESTFORMATTER, NULL);
3391  
3392 /* Execute */
3393 15 method = CFISH_METHOD_PTR(CFISH_TESTSUITE, CFISH_TestSuite_Run_Batch);
3394 15 retval = method(arg_self, arg_class_name, arg_formatter);
3395 15 ST(0) = newSViv(!!retval);
3396 15 sv_2mortal( ST(0) );
3397 15 XSRETURN(1);
3398 }
3399  
3400 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_run_all_batches);
3401 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuite_run_all_batches) {
3402 0 dXSARGS;
3403 SV *sv;
3404 cfish_TestSuite* arg_self;
3405 cfish_TestFormatter* arg_formatter;
3406 CFISH_TestSuite_Run_All_Batches_t method;
3407 bool retval;
3408  
3409 CFISH_UNUSED_VAR(cv);
3410 0 SP -= items;
3411 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3412 0 XSBind_invalid_args_error(aTHX_ cv, "self, formatter");
3413 }
3414  
3415 /* Extract vars from Perl stack. */
3416 0 arg_self = (cfish_TestSuite*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITE, NULL);
3417 0 sv = ST(1);
3418 0 arg_formatter = (cfish_TestFormatter*)XSBind_arg_to_cfish(aTHX_ sv, "formatter", CFISH_TESTFORMATTER, NULL);
3419  
3420 /* Execute */
3421 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITE, CFISH_TestSuite_Run_All_Batches);
3422 0 retval = method(arg_self, arg_formatter);
3423 0 ST(0) = newSViv(!!retval);
3424 0 sv_2mortal( ST(0) );
3425 0 XSRETURN(1);
3426 }
3427  
3428 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_new);
3429 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_new) {
3430 0 dXSARGS;
3431 static const XSBind_ParamSpec param_specs[1] = {
3432 XSBIND_PARAM("formatter", 1)
3433 };
3434 int32_t locations[1];
3435 SV *sv;
3436 cfish_TestSuiteRunner* arg_self;
3437 cfish_TestFormatter* arg_formatter;
3438 cfish_TestSuiteRunner* retval;
3439  
3440 CFISH_UNUSED_VAR(cv);
3441 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
3442 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
3443 }
3444 0 SP -= items;
3445  
3446 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3447 locations, 1);
3448 0 sv = ST(locations[0]);
3449 0 arg_formatter = (cfish_TestFormatter*)XSBind_arg_to_cfish(aTHX_ sv, "formatter", CFISH_TESTFORMATTER, NULL);
3450 0 arg_self = (cfish_TestSuiteRunner*)XSBind_new_blank_obj(aTHX_ ST(0));
3451  
3452 0 retval = cfish_TestSuiteRunner_init(arg_self, arg_formatter);
3453 0 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
3454 0 XSRETURN(1);
3455 }
3456  
3457  
3458 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_run_batch);
3459 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_run_batch) {
3460 0 dXSARGS;
3461 SV *sv;
3462 cfish_TestSuiteRunner* arg_self;
3463 cfish_TestBatch* arg_batch;
3464 CFISH_TestSuiteRunner_Run_Batch_t method;
3465 bool retval;
3466  
3467 CFISH_UNUSED_VAR(cv);
3468 0 SP -= items;
3469 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3470 0 XSBind_invalid_args_error(aTHX_ cv, "self, batch");
3471 }
3472  
3473 /* Extract vars from Perl stack. */
3474 0 arg_self = (cfish_TestSuiteRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITERUNNER, NULL);
3475 0 sv = ST(1);
3476 0 arg_batch = (cfish_TestBatch*)XSBind_arg_to_cfish(aTHX_ sv, "batch", CFISH_TESTBATCH, NULL);
3477  
3478 /* Execute */
3479 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITERUNNER, CFISH_TestSuiteRunner_Run_Batch);
3480 0 retval = method(arg_self, arg_batch);
3481 0 ST(0) = newSViv(!!retval);
3482 0 sv_2mortal( ST(0) );
3483 0 XSRETURN(1);
3484 }
3485  
3486 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_finish);
3487 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_finish) {
3488 0 dXSARGS;
3489 cfish_TestSuiteRunner* arg_self;
3490 CFISH_TestSuiteRunner_Finish_t method;
3491 bool retval;
3492  
3493 CFISH_UNUSED_VAR(cv);
3494 0 SP -= items;
3495 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3496 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3497 }
3498  
3499 /* Extract vars from Perl stack. */
3500 0 arg_self = (cfish_TestSuiteRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITERUNNER, NULL);
3501  
3502 /* Execute */
3503 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITERUNNER, CFISH_TestSuiteRunner_Finish);
3504 0 retval = method(arg_self);
3505 0 ST(0) = newSViv(!!retval);
3506 0 sv_2mortal( ST(0) );
3507 0 XSRETURN(1);
3508 }
3509  
3510 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_tests);
3511 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_tests) {
3512 0 dXSARGS;
3513 cfish_TestSuiteRunner* arg_self;
3514 CFISH_TestSuiteRunner_Get_Num_Tests_t method;
3515 uint32_t retval;
3516  
3517 CFISH_UNUSED_VAR(cv);
3518 0 SP -= items;
3519 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3520 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3521 }
3522  
3523 /* Extract vars from Perl stack. */
3524 0 arg_self = (cfish_TestSuiteRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITERUNNER, NULL);
3525  
3526 /* Execute */
3527 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITERUNNER, CFISH_TestSuiteRunner_Get_Num_Tests);
3528 0 retval = method(arg_self);
3529 0 ST(0) = newSVuv(retval);
3530 0 sv_2mortal( ST(0) );
3531 0 XSRETURN(1);
3532 }
3533  
3534 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_tests_failed);
3535 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_tests_failed) {
3536 0 dXSARGS;
3537 cfish_TestSuiteRunner* arg_self;
3538 CFISH_TestSuiteRunner_Get_Num_Tests_Failed_t method;
3539 uint32_t retval;
3540  
3541 CFISH_UNUSED_VAR(cv);
3542 0 SP -= items;
3543 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3544 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3545 }
3546  
3547 /* Extract vars from Perl stack. */
3548 0 arg_self = (cfish_TestSuiteRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITERUNNER, NULL);
3549  
3550 /* Execute */
3551 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITERUNNER, CFISH_TestSuiteRunner_Get_Num_Tests_Failed);
3552 0 retval = method(arg_self);
3553 0 ST(0) = newSVuv(retval);
3554 0 sv_2mortal( ST(0) );
3555 0 XSRETURN(1);
3556 }
3557  
3558 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_batches);
3559 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_batches) {
3560 0 dXSARGS;
3561 cfish_TestSuiteRunner* arg_self;
3562 CFISH_TestSuiteRunner_Get_Num_Batches_t method;
3563 uint32_t retval;
3564  
3565 CFISH_UNUSED_VAR(cv);
3566 0 SP -= items;
3567 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3568 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3569 }
3570  
3571 /* Extract vars from Perl stack. */
3572 0 arg_self = (cfish_TestSuiteRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITERUNNER, NULL);
3573  
3574 /* Execute */
3575 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITERUNNER, CFISH_TestSuiteRunner_Get_Num_Batches);
3576 0 retval = method(arg_self);
3577 0 ST(0) = newSVuv(retval);
3578 0 sv_2mortal( ST(0) );
3579 0 XSRETURN(1);
3580 }
3581  
3582 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_batches_failed);
3583 0 XS_INTERNAL(XS_Clownfish_TestHarness_TestSuiteRunner_get_num_batches_failed) {
3584 0 dXSARGS;
3585 cfish_TestSuiteRunner* arg_self;
3586 CFISH_TestSuiteRunner_Get_Num_Batches_Failed_t method;
3587 uint32_t retval;
3588  
3589 CFISH_UNUSED_VAR(cv);
3590 0 SP -= items;
3591 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3592 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3593 }
3594  
3595 /* Extract vars from Perl stack. */
3596 0 arg_self = (cfish_TestSuiteRunner*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_TESTSUITERUNNER, NULL);
3597  
3598 /* Execute */
3599 0 method = CFISH_METHOD_PTR(CFISH_TESTSUITERUNNER, CFISH_TestSuiteRunner_Get_Num_Batches_Failed);
3600 0 retval = method(arg_self);
3601 0 ST(0) = newSVuv(retval);
3602 0 sv_2mortal( ST(0) );
3603 0 XSRETURN(1);
3604 }
3605  
3606 XS_INTERNAL(XS_Clownfish_Vector_new);
3607 14 XS_INTERNAL(XS_Clownfish_Vector_new) {
3608 14 dXSARGS;
3609 static const XSBind_ParamSpec param_specs[1] = {
3610 XSBIND_PARAM("capacity", 0)
3611 };
3612 int32_t locations[1];
3613 SV *sv;
3614 cfish_Vector* arg_self;
3615 size_t arg_capacity;
3616 cfish_Vector* retval;
3617  
3618 CFISH_UNUSED_VAR(cv);
3619 14 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 14 14
3620 0 XSBind_invalid_args_error(aTHX_ cv, "class_name, ...");
3621 }
3622 14 SP -= items;
3623  
3624 14 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3625 locations, 1);
3626 14 sv = ST(locations[0]);
3627 12 ▶ arg_capacity = locations[0] < items && XSBind_sv_defined(aTHX_ sv)
Branch: 1 branch
BranchTrueFalseTotal
arg_capacity = locations[0] < items && XSBind_sv_defined(aTHX_ sv) 12 0 12
3628 26 ▶ ? (size_t)SvIV(sv) : 0;
Branch: 1 branch
BranchTrueFalseTotal
? (size_t)SvIV(sv) : 0; 12 2 14
3629 14 arg_self = (cfish_Vector*)XSBind_new_blank_obj(aTHX_ ST(0));
3630  
3631 13 retval = cfish_Vec_init(arg_self, arg_capacity);
3632 13 ST(0) = sv_2mortal(CFISH_OBJ_TO_SV_NOINC(retval));
3633 13 XSRETURN(1);
3634 }
3635  
3636  
3637 XS_INTERNAL(XS_Clownfish_Vector_push);
3638 35 XS_INTERNAL(XS_Clownfish_Vector_push) {
3639 35 dXSARGS;
3640 SV *sv;
3641 cfish_Vector* arg_self;
3642 cfish_Obj* arg_element;
3643 CFISH_Vec_Push_t method;
3644  
3645 CFISH_UNUSED_VAR(cv);
3646 35 SP -= items;
3647 35 ▶ if (items < 1 || items > 2) {
Branch: 2 branches
BranchTrueFalseTotal
if (items < 1 || items > 2) { 35 0 35
if (items < 1 || items > 2) { 0 35 35
3648 0 XSBind_invalid_args_error(aTHX_ cv, "self, [element]");
3649 }
3650  
3651 /* Extract vars from Perl stack. */
3652 35 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3653 35 sv = ST(1);
3654 35 ▶ arg_element = 1 < items ? (cfish_Obj*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "element", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL;
Branch: 1 branch
BranchTrueFalseTotal
arg_element = 1 < items ? (cfish_Obj*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "element", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL; 35 0 35
3655  
3656 /* Execute */
3657 35 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Push);
3658 35 arg_element = (cfish_Obj*)CFISH_INCREF(arg_element);
3659 35 method(arg_self, arg_element);
3660 35 XSRETURN(0);
3661 }
3662  
3663 XS_INTERNAL(XS_Clownfish_Vector_push_all);
3664 0 XS_INTERNAL(XS_Clownfish_Vector_push_all) {
3665 0 dXSARGS;
3666 SV *sv;
3667 cfish_Vector* arg_self;
3668 cfish_Vector* arg_other;
3669 CFISH_Vec_Push_All_t method;
3670  
3671 CFISH_UNUSED_VAR(cv);
3672 0 SP -= items;
3673 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3674 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
3675 }
3676  
3677 /* Extract vars from Perl stack. */
3678 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3679 0 sv = ST(1);
3680 0 arg_other = (cfish_Vector*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_VECTOR, NULL);
3681  
3682 /* Execute */
3683 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Push_All);
3684 0 method(arg_self, arg_other);
3685 0 XSRETURN(0);
3686 }
3687  
3688 XS_INTERNAL(XS_Clownfish_Vector_pop);
3689 0 XS_INTERNAL(XS_Clownfish_Vector_pop) {
3690 0 dXSARGS;
3691 cfish_Vector* arg_self;
3692 CFISH_Vec_Pop_t method;
3693 cfish_Obj* retval;
3694  
3695 CFISH_UNUSED_VAR(cv);
3696 0 SP -= items;
3697 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3698 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3699 }
3700  
3701 /* Extract vars from Perl stack. */
3702 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3703  
3704 /* Execute */
3705 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Pop);
3706 0 retval = method(arg_self);
3707 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
3708 0 CFISH_DECREF(retval);
3709 0 sv_2mortal( ST(0) );
3710 0 XSRETURN(1);
3711 }
3712  
3713 XS_INTERNAL(XS_Clownfish_Vector_insert);
3714 1 XS_INTERNAL(XS_Clownfish_Vector_insert) {
3715 1 dXSARGS;
3716 static const XSBind_ParamSpec param_specs[2] = {
3717 XSBIND_PARAM("tick", 1),
3718 XSBIND_PARAM("element", 0)
3719 };
3720 int32_t locations[2];
3721 SV *sv;
3722 cfish_Vector* arg_self;
3723 size_t arg_tick;
3724 cfish_Obj* arg_element;
3725 CFISH_Vec_Insert_t method;
3726  
3727 CFISH_UNUSED_VAR(cv);
3728 1 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 1 1
3729 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3730 }
3731 1 SP -= items;
3732  
3733 /* Locate args on Perl stack. */
3734 1 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3735 locations, 2);
3736 1 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3737 1 sv = ST(locations[0]);
3738 1 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 1 1
3739 0 XSBind_undef_arg_error(aTHX_ "tick");
3740 }
3741 1 arg_tick = (size_t)SvIV(sv);
3742 1 sv = ST(locations[1]);
3743 1 ▶ arg_element = locations[1] < items ? (cfish_Obj*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "element", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL;
Branch: 1 branch
BranchTrueFalseTotal
arg_element = locations[1] < items ? (cfish_Obj*)XSBind_arg_to_cfish_nullable(aTHX_ sv, "element", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING)) : NULL; 1 0 1
3744  
3745 /* Execute */
3746 1 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Insert);
3747 1 arg_element = (cfish_Obj*)CFISH_INCREF(arg_element);
3748 1 method(arg_self, arg_tick, arg_element);
3749 1 XSRETURN(0);
3750 }
3751  
3752 XS_INTERNAL(XS_Clownfish_Vector_insert_all);
3753 0 XS_INTERNAL(XS_Clownfish_Vector_insert_all) {
3754 0 dXSARGS;
3755 static const XSBind_ParamSpec param_specs[2] = {
3756 XSBIND_PARAM("tick", 1),
3757 XSBIND_PARAM("other", 1)
3758 };
3759 int32_t locations[2];
3760 SV *sv;
3761 cfish_Vector* arg_self;
3762 size_t arg_tick;
3763 cfish_Vector* arg_other;
3764 CFISH_Vec_Insert_All_t method;
3765  
3766 CFISH_UNUSED_VAR(cv);
3767 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
3768 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3769 }
3770 0 SP -= items;
3771  
3772 /* Locate args on Perl stack. */
3773 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3774 locations, 2);
3775 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3776 0 sv = ST(locations[0]);
3777 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3778 0 XSBind_undef_arg_error(aTHX_ "tick");
3779 }
3780 0 arg_tick = (size_t)SvIV(sv);
3781 0 sv = ST(locations[1]);
3782 0 arg_other = (cfish_Vector*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_VECTOR, NULL);
3783  
3784 /* Execute */
3785 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Insert_All);
3786 0 method(arg_self, arg_tick, arg_other);
3787 0 XSRETURN(0);
3788 }
3789  
3790 XS_INTERNAL(XS_Clownfish_Vector_grow);
3791 0 XS_INTERNAL(XS_Clownfish_Vector_grow) {
3792 0 dXSARGS;
3793 SV *sv;
3794 cfish_Vector* arg_self;
3795 size_t arg_capacity;
3796 CFISH_Vec_Grow_t method;
3797  
3798 CFISH_UNUSED_VAR(cv);
3799 0 SP -= items;
3800 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3801 0 XSBind_invalid_args_error(aTHX_ cv, "self, capacity");
3802 }
3803  
3804 /* Extract vars from Perl stack. */
3805 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3806 0 sv = ST(1);
3807 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3808 0 XSBind_undef_arg_error(aTHX_ "capacity");
3809 }
3810 0 arg_capacity = (size_t)SvIV(sv);
3811  
3812 /* Execute */
3813 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Grow);
3814 0 method(arg_self, arg_capacity);
3815 0 XSRETURN(0);
3816 }
3817  
3818 XS_INTERNAL(XS_Clownfish_Vector_fetch);
3819 0 XS_INTERNAL(XS_Clownfish_Vector_fetch) {
3820 0 dXSARGS;
3821 SV *sv;
3822 cfish_Vector* arg_self;
3823 size_t arg_tick;
3824 CFISH_Vec_Fetch_t method;
3825 cfish_Obj* retval;
3826  
3827 CFISH_UNUSED_VAR(cv);
3828 0 SP -= items;
3829 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3830 0 XSBind_invalid_args_error(aTHX_ cv, "self, tick");
3831 }
3832  
3833 /* Extract vars from Perl stack. */
3834 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3835 0 sv = ST(1);
3836 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3837 0 XSBind_undef_arg_error(aTHX_ "tick");
3838 }
3839 0 arg_tick = (size_t)SvIV(sv);
3840  
3841 /* Execute */
3842 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Fetch);
3843 0 retval = method(arg_self, arg_tick);
3844 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
3845 0 sv_2mortal( ST(0) );
3846 0 XSRETURN(1);
3847 }
3848  
3849 XS_INTERNAL(XS_Clownfish_Vector_delete);
3850 1 XS_INTERNAL(XS_Clownfish_Vector_delete) {
3851 1 dXSARGS;
3852 SV *sv;
3853 cfish_Vector* arg_self;
3854 size_t arg_tick;
3855 CFISH_Vec_Delete_t method;
3856 cfish_Obj* retval;
3857  
3858 CFISH_UNUSED_VAR(cv);
3859 1 SP -= items;
3860 1 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 1 1
3861 0 XSBind_invalid_args_error(aTHX_ cv, "self, tick");
3862 }
3863  
3864 /* Extract vars from Perl stack. */
3865 1 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3866 1 sv = ST(1);
3867 1 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 1 1
3868 0 XSBind_undef_arg_error(aTHX_ "tick");
3869 }
3870 1 arg_tick = (size_t)SvIV(sv);
3871  
3872 /* Execute */
3873 1 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Delete);
3874 1 retval = method(arg_self, arg_tick);
3875 1 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
3876 1 CFISH_DECREF(retval);
3877 1 sv_2mortal( ST(0) );
3878 1 XSRETURN(1);
3879 }
3880  
3881 XS_INTERNAL(XS_Clownfish_Vector_excise);
3882 0 XS_INTERNAL(XS_Clownfish_Vector_excise) {
3883 0 dXSARGS;
3884 static const XSBind_ParamSpec param_specs[2] = {
3885 XSBIND_PARAM("offset", 1),
3886 XSBIND_PARAM("length", 1)
3887 };
3888 int32_t locations[2];
3889 SV *sv;
3890 cfish_Vector* arg_self;
3891 size_t arg_offset;
3892 size_t arg_length;
3893 CFISH_Vec_Excise_t method;
3894  
3895 CFISH_UNUSED_VAR(cv);
3896 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
3897 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
3898 }
3899 0 SP -= items;
3900  
3901 /* Locate args on Perl stack. */
3902 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
3903 locations, 2);
3904 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3905 0 sv = ST(locations[0]);
3906 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3907 0 XSBind_undef_arg_error(aTHX_ "offset");
3908 }
3909 0 arg_offset = (size_t)SvIV(sv);
3910 0 sv = ST(locations[1]);
3911 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3912 0 XSBind_undef_arg_error(aTHX_ "length");
3913 }
3914 0 arg_length = (size_t)SvIV(sv);
3915  
3916 /* Execute */
3917 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Excise);
3918 0 method(arg_self, arg_offset, arg_length);
3919 0 XSRETURN(0);
3920 }
3921  
3922 XS_INTERNAL(XS_Clownfish_Vector_clone);
3923 0 XS_INTERNAL(XS_Clownfish_Vector_clone) {
3924 0 dXSARGS;
3925 cfish_Vector* arg_self;
3926 CFISH_Vec_Clone_t method;
3927 cfish_Vector* retval;
3928  
3929 CFISH_UNUSED_VAR(cv);
3930 0 SP -= items;
3931 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3932 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3933 }
3934  
3935 /* Extract vars from Perl stack. */
3936 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3937  
3938 /* Execute */
3939 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Clone);
3940 0 retval = method(arg_self);
3941 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
3942 0 CFISH_DECREF(retval);
3943 0 sv_2mortal( ST(0) );
3944 0 XSRETURN(1);
3945 }
3946  
3947 XS_INTERNAL(XS_Clownfish_Vector_sort);
3948 0 XS_INTERNAL(XS_Clownfish_Vector_sort) {
3949 0 dXSARGS;
3950 cfish_Vector* arg_self;
3951 CFISH_Vec_Sort_t method;
3952  
3953 CFISH_UNUSED_VAR(cv);
3954 0 SP -= items;
3955 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
3956 0 XSBind_invalid_args_error(aTHX_ cv, "self");
3957 }
3958  
3959 /* Extract vars from Perl stack. */
3960 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3961  
3962 /* Execute */
3963 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Sort);
3964 0 method(arg_self);
3965 0 XSRETURN(0);
3966 }
3967  
3968 XS_INTERNAL(XS_Clownfish_Vector_resize);
3969 0 XS_INTERNAL(XS_Clownfish_Vector_resize) {
3970 0 dXSARGS;
3971 SV *sv;
3972 cfish_Vector* arg_self;
3973 size_t arg_size;
3974 CFISH_Vec_Resize_t method;
3975  
3976 CFISH_UNUSED_VAR(cv);
3977 0 SP -= items;
3978 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
3979 0 XSBind_invalid_args_error(aTHX_ cv, "self, size");
3980 }
3981  
3982 /* Extract vars from Perl stack. */
3983 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
3984 0 sv = ST(1);
3985 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
3986 0 XSBind_undef_arg_error(aTHX_ "size");
3987 }
3988 0 arg_size = (size_t)SvIV(sv);
3989  
3990 /* Execute */
3991 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Resize);
3992 0 method(arg_self, arg_size);
3993 0 XSRETURN(0);
3994 }
3995  
3996 XS_INTERNAL(XS_Clownfish_Vector_clear);
3997 1 XS_INTERNAL(XS_Clownfish_Vector_clear) {
3998 1 dXSARGS;
3999 cfish_Vector* arg_self;
4000 CFISH_Vec_Clear_t method;
4001  
4002 CFISH_UNUSED_VAR(cv);
4003 1 SP -= items;
4004 1 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 1 1
4005 0 XSBind_invalid_args_error(aTHX_ cv, "self");
4006 }
4007  
4008 /* Extract vars from Perl stack. */
4009 1 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
4010  
4011 /* Execute */
4012 1 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Clear);
4013 1 method(arg_self);
4014 1 XSRETURN(0);
4015 }
4016  
4017 XS_INTERNAL(XS_Clownfish_Vector_get_size);
4018 0 XS_INTERNAL(XS_Clownfish_Vector_get_size) {
4019 0 dXSARGS;
4020 cfish_Vector* arg_self;
4021 CFISH_Vec_Get_Size_t method;
4022 size_t retval;
4023  
4024 CFISH_UNUSED_VAR(cv);
4025 0 SP -= items;
4026 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
4027 0 XSBind_invalid_args_error(aTHX_ cv, "self");
4028 }
4029  
4030 /* Extract vars from Perl stack. */
4031 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
4032  
4033 /* Execute */
4034 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Get_Size);
4035 0 retval = method(arg_self);
4036 0 ST(0) = newSViv(retval);
4037 0 sv_2mortal( ST(0) );
4038 0 XSRETURN(1);
4039 }
4040  
4041 XS_INTERNAL(XS_Clownfish_Vector_get_capacity);
4042 0 XS_INTERNAL(XS_Clownfish_Vector_get_capacity) {
4043 0 dXSARGS;
4044 cfish_Vector* arg_self;
4045 CFISH_Vec_Get_Capacity_t method;
4046 size_t retval;
4047  
4048 CFISH_UNUSED_VAR(cv);
4049 0 SP -= items;
4050 0 ▶ if (items != 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 1) { 0 0 0
4051 0 XSBind_invalid_args_error(aTHX_ cv, "self");
4052 }
4053  
4054 /* Extract vars from Perl stack. */
4055 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
4056  
4057 /* Execute */
4058 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Get_Capacity);
4059 0 retval = method(arg_self);
4060 0 ST(0) = newSViv(retval);
4061 0 sv_2mortal( ST(0) );
4062 0 XSRETURN(1);
4063 }
4064  
4065 XS_INTERNAL(XS_Clownfish_Vector_slice);
4066 0 XS_INTERNAL(XS_Clownfish_Vector_slice) {
4067 0 dXSARGS;
4068 static const XSBind_ParamSpec param_specs[2] = {
4069 XSBIND_PARAM("offset", 1),
4070 XSBIND_PARAM("length", 1)
4071 };
4072 int32_t locations[2];
4073 SV *sv;
4074 cfish_Vector* arg_self;
4075 size_t arg_offset;
4076 size_t arg_length;
4077 CFISH_Vec_Slice_t method;
4078 cfish_Vector* retval;
4079  
4080 CFISH_UNUSED_VAR(cv);
4081 0 ▶ if (items < 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (items < 1) { 0 0 0
4082 0 XSBind_invalid_args_error(aTHX_ cv, "self, ...");
4083 }
4084 0 SP -= items;
4085  
4086 /* Locate args on Perl stack. */
4087 0 XSBind_locate_args(aTHX_ &ST(0), 1, items, param_specs,
4088 locations, 2);
4089 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
4090 0 sv = ST(locations[0]);
4091 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
4092 0 XSBind_undef_arg_error(aTHX_ "offset");
4093 }
4094 0 arg_offset = (size_t)SvIV(sv);
4095 0 sv = ST(locations[1]);
4096 0 ▶ if (!XSBind_sv_defined(aTHX_ sv)) {
Branch: 1 branch
BranchTrueFalseTotal
if (!XSBind_sv_defined(aTHX_ sv)) { 0 0 0
4097 0 XSBind_undef_arg_error(aTHX_ "length");
4098 }
4099 0 arg_length = (size_t)SvIV(sv);
4100  
4101 /* Execute */
4102 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Slice);
4103 0 retval = method(arg_self, arg_offset, arg_length);
4104 0 ST(0) = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)retval);
4105 0 CFISH_DECREF(retval);
4106 0 sv_2mortal( ST(0) );
4107 0 XSRETURN(1);
4108 }
4109  
4110 XS_INTERNAL(XS_Clownfish_Vector_equals);
4111 0 XS_INTERNAL(XS_Clownfish_Vector_equals) {
4112 0 dXSARGS;
4113 SV *sv;
4114 cfish_Vector* arg_self;
4115 cfish_Obj* arg_other;
4116 CFISH_Vec_Equals_t method;
4117 bool retval;
4118  
4119 CFISH_UNUSED_VAR(cv);
4120 0 SP -= items;
4121 0 ▶ if (items != 2) {
Branch: 1 branch
BranchTrueFalseTotal
if (items != 2) { 0 0 0
4122 0 XSBind_invalid_args_error(aTHX_ cv, "self, other");
4123 }
4124  
4125 /* Extract vars from Perl stack. */
4126 0 arg_self = (cfish_Vector*)XSBind_perl_to_cfish_noinc(aTHX_ ST(0), CFISH_VECTOR, NULL);
4127 0 sv = ST(1);
4128 0 arg_other = (cfish_Obj*)XSBind_arg_to_cfish(aTHX_ sv, "other", CFISH_OBJ, CFISH_ALLOCA_OBJ(CFISH_STRING));
4129  
4130 /* Execute */
4131 0 method = CFISH_METHOD_PTR(CFISH_VECTOR, CFISH_Vec_Equals);
4132 0 retval = method(arg_self, arg_other);
4133 0 ST(0) = newSViv(!!retval);
4134 0 sv_2mortal( ST(0) );
4135 0 XSRETURN(1);
4136 }
4137  
4138  
4139 MODULE = Clownfish PACKAGE = Clownfish
4140  
4141 BOOT:
4142 {
4143 static const cfish_XSBind_ClassSpec class_specs[] = {
4144 { "Clownfish::Obj", NULL, 5 },
4145 { "Clownfish::Blob", "Clownfish::Obj", 4 },
4146 { "Clownfish::Boolean", "Clownfish::Obj", 4 },
4147 { "Clownfish::ByteBuf", "Clownfish::Obj", 10 },
4148 { "Clownfish::CharBuf", "Clownfish::Obj", 9 },
4149 { "Clownfish::Class", "Clownfish::Obj", 5 },
4150 { "Clownfish::Err", "Clownfish::Obj", 4 },
4151 { "Clownfish::Float", "Clownfish::Obj", 6 },
4152 { "Clownfish::Hash", "Clownfish::Obj", 10 },
4153 { "Clownfish::HashIterator", "Clownfish::Obj", 3 },
4154 { "Clownfish::Integer", "Clownfish::Obj", 6 },
4155 { "Clownfish::Method", "Clownfish::Obj", 5 },
4156 { "Clownfish::String", "Clownfish::Obj", 25 },
4157 { "Clownfish::StringIterator", "Clownfish::Obj", 12 },
4158 { "Clownfish::TestHarness::TestBatch", "Clownfish::Obj", 1 },
4159 { "Clownfish::TestHarness::TestBatchRunner", "Clownfish::Obj", 6 },
4160 { "Clownfish::TestHarness::TestFormatter", "Clownfish::Obj", 3 },
4161 { "Clownfish::TestHarness::TestFormatterCF", "Clownfish::TestHarness::TestFormatter", 3 },
4162 { "Clownfish::TestHarness::TestFormatterTAP", "Clownfish::TestHarness::TestFormatter", 3 },
4163 { "Clownfish::TestHarness::TestSuite", "Clownfish::Obj", 4 },
4164 { "Clownfish::TestHarness::TestSuiteRunner", "Clownfish::Obj", 7 },
4165 { "Clownfish::Vector", "Clownfish::Obj", 18 }
4166 };
4167 static const cfish_XSBind_XSubSpec xsub_specs[] = {
4168 { "new", XS_Clownfish_Obj_new },
4169 { "clone", XS_Clownfish_Obj_clone },
4170 { "equals", XS_Clownfish_Obj_equals },
4171 { "compare_to", XS_Clownfish_Obj_compare_to },
4172 { "to_string", XS_Clownfish_Obj_to_string },
4173 { "get_size", XS_Clownfish_Blob_get_size },
4174 { "equals", XS_Clownfish_Blob_equals },
4175 { "compare_to", XS_Clownfish_Blob_compare_to },
4176 { "clone", XS_Clownfish_Blob_clone },
4177 { "get_value", XS_Clownfish_Boolean_get_value },
4178 { "clone", XS_Clownfish_Boolean_clone },
4179 { "equals", XS_Clownfish_Boolean_equals },
4180 { "to_string", XS_Clownfish_Boolean_to_string },
4181 { "set_size", XS_Clownfish_ByteBuf_set_size },
4182 { "get_size", XS_Clownfish_ByteBuf_get_size },
4183 { "get_capacity", XS_Clownfish_ByteBuf_get_capacity },
4184 { "cat", XS_Clownfish_ByteBuf_cat },
4185 { "yield_blob", XS_Clownfish_ByteBuf_yield_blob },
4186 { "utf8_to_string", XS_Clownfish_ByteBuf_utf8_to_string },
4187 { "trusted_utf8_to_string", XS_Clownfish_ByteBuf_trusted_utf8_to_string },
4188 { "equals", XS_Clownfish_ByteBuf_equals },
4189 { "compare_to", XS_Clownfish_ByteBuf_compare_to },
4190 { "clone", XS_Clownfish_ByteBuf_clone },
4191 { "new", XS_Clownfish_CharBuf_new },
4192 { "cat", XS_Clownfish_CharBuf_cat },
4193 { "cat_char", XS_Clownfish_CharBuf_cat_char },
4194 { "grow", XS_Clownfish_CharBuf_grow },
4195 { "clear", XS_Clownfish_CharBuf_clear },
4196 { "get_size", XS_Clownfish_CharBuf_get_size },
4197 { "clone", XS_Clownfish_CharBuf_clone },
4198 { "to_string", XS_Clownfish_CharBuf_to_string },
4199 { "yield_string", XS_Clownfish_CharBuf_yield_string },
4200 { "make_obj", XS_Clownfish_Class_make_obj },
4201 { "get_name", XS_Clownfish_Class_get_name },
4202 { "get_parent", XS_Clownfish_Class_get_parent },
4203 { "get_obj_alloc_size", XS_Clownfish_Class_get_obj_alloc_size },
4204 { "get_methods", XS_Clownfish_Class_get_methods },
4205 { "_new", XS_Clownfish_Err__new },
4206 { "to_string", XS_Clownfish_Err_to_string },
4207 { "cat_mess", XS_Clownfish_Err_cat_mess },
4208 { "get_mess", XS_Clownfish_Err_get_mess },
4209 { "get_value", XS_Clownfish_Float_get_value },
4210 { "to_i64", XS_Clownfish_Float_to_i64 },
4211 { "to_string", XS_Clownfish_Float_to_string },
4212 { "equals", XS_Clownfish_Float_equals },
4213 { "compare_to", XS_Clownfish_Float_compare_to },
4214 { "clone", XS_Clownfish_Float_clone },
4215 { "new", XS_Clownfish_Hash_new },
4216 { "clear", XS_Clownfish_Hash_clear },
4217 { "fetch", XS_Clownfish_Hash_fetch },
4218 { "delete", XS_Clownfish_Hash_delete },
4219 { "has_key", XS_Clownfish_Hash_has_key },
4220 { "keys", XS_Clownfish_Hash_keys },
4221 { "values", XS_Clownfish_Hash_values },
4222 { "get_capacity", XS_Clownfish_Hash_get_capacity },
4223 { "get_size", XS_Clownfish_Hash_get_size },
4224 { "equals", XS_Clownfish_Hash_equals },
4225 { "next", XS_Clownfish_HashIterator_next },
4226 { "get_key", XS_Clownfish_HashIterator_get_key },
4227 { "get_value", XS_Clownfish_HashIterator_get_value },
4228 { "get_value", XS_Clownfish_Integer_get_value },
4229 { "to_f64", XS_Clownfish_Integer_to_f64 },
4230 { "to_string", XS_Clownfish_Integer_to_string },
4231 { "equals", XS_Clownfish_Integer_equals },
4232 { "compare_to", XS_Clownfish_Integer_compare_to },
4233 { "clone", XS_Clownfish_Integer_clone },
4234 { "get_name", XS_Clownfish_Method_get_name },
4235 { "set_host_alias", XS_Clownfish_Method_set_host_alias },
4236 { "get_host_alias", XS_Clownfish_Method_get_host_alias },
4237 { "is_excluded_from_host", XS_Clownfish_Method_is_excluded_from_host },
4238 { "host_name", XS_Clownfish_Method_host_name },
4239 { "cat", XS_Clownfish_String_cat },
4240 { "to_i64", XS_Clownfish_String_to_i64 },
4241 { "basex_to_i64", XS_Clownfish_String_basex_to_i64 },
4242 { "to_f64", XS_Clownfish_String_to_f64 },
4243 { "starts_with", XS_Clownfish_String_starts_with },
4244 { "ends_with", XS_Clownfish_String_ends_with },
4245 { "contains", XS_Clownfish_String_contains },
4246 { "find", XS_Clownfish_String_find },
4247 { "equals", XS_Clownfish_String_equals },
4248 { "length", XS_Clownfish_String_length },
4249 { "get_size", XS_Clownfish_String_get_size },
4250 { "to_bytebuf", XS_Clownfish_String_to_bytebuf },
4251 { "clone", XS_Clownfish_String_clone },
4252 { "is_copy_on_incref", XS_Clownfish_String_is_copy_on_incref },
4253 { "compare_to", XS_Clownfish_String_compare_to },
4254 { "hash_sum", XS_Clownfish_String_hash_sum },
4255 { "to_string", XS_Clownfish_String_to_string },
4256 { "trim", XS_Clownfish_String_trim },
4257 { "trim_top", XS_Clownfish_String_trim_top },
4258 { "trim_tail", XS_Clownfish_String_trim_tail },
4259 { "code_point_at", XS_Clownfish_String_code_point_at },
4260 { "code_point_from", XS_Clownfish_String_code_point_from },
4261 { "substring", XS_Clownfish_String_substring },
4262 { "top", XS_Clownfish_String_top },
4263 { "tail", XS_Clownfish_String_tail },
4264 { "clone", XS_Clownfish_StringIterator_clone },
4265 { "assign", XS_Clownfish_StringIterator_assign },
4266 { "equals", XS_Clownfish_StringIterator_equals },
4267 { "compare_to", XS_Clownfish_StringIterator_compare_to },
4268 { "has_next", XS_Clownfish_StringIterator_has_next },
4269 { "has_prev", XS_Clownfish_StringIterator_has_prev },
4270 { "advance", XS_Clownfish_StringIterator_advance },
4271 { "recede", XS_Clownfish_StringIterator_recede },
4272 { "skip_whitespace", XS_Clownfish_StringIterator_skip_whitespace },
4273 { "skip_whitespace_back", XS_Clownfish_StringIterator_skip_whitespace_back },
4274 { "starts_with", XS_Clownfish_StringIterator_starts_with },
4275 { "ends_with", XS_Clownfish_StringIterator_ends_with },
4276 { "run", XS_Clownfish_TestHarness_TestBatch_run },
4277 { "new", XS_Clownfish_TestHarness_TestBatchRunner_new },
4278 { "run_batch", XS_Clownfish_TestHarness_TestBatchRunner_run_batch },
4279 { "plan", XS_Clownfish_TestHarness_TestBatchRunner_plan },
4280 { "get_num_planned", XS_Clownfish_TestHarness_TestBatchRunner_get_num_planned },
4281 { "get_num_tests", XS_Clownfish_TestHarness_TestBatchRunner_get_num_tests },
4282 { "get_num_failed", XS_Clownfish_TestHarness_TestBatchRunner_get_num_failed },
4283 { "new", XS_Clownfish_TestHarness_TestFormatter_new },
4284 { "batch_prologue", XS_Clownfish_TestHarness_TestFormatter_batch_prologue },
4285 { "summary", XS_Clownfish_TestHarness_TestFormatter_summary },
4286 { "new", XS_Clownfish_TestHarness_TestFormatterCF_new },
4287 { "batch_prologue", XS_Clownfish_TestHarness_TestFormatterCF_batch_prologue },
4288 { "summary", XS_Clownfish_TestHarness_TestFormatterCF_summary },
4289 { "new", XS_Clownfish_TestHarness_TestFormatterTAP_new },
4290 { "batch_prologue", XS_Clownfish_TestHarness_TestFormatterTAP_batch_prologue },
4291 { "summary", XS_Clownfish_TestHarness_TestFormatterTAP_summary },
4292 { "new", XS_Clownfish_TestHarness_TestSuite_new },
4293 { "add_batch", XS_Clownfish_TestHarness_TestSuite_add_batch },
4294 { "run_batch", XS_Clownfish_TestHarness_TestSuite_run_batch },
4295 { "run_all_batches", XS_Clownfish_TestHarness_TestSuite_run_all_batches },
4296 { "new", XS_Clownfish_TestHarness_TestSuiteRunner_new },
4297 { "run_batch", XS_Clownfish_TestHarness_TestSuiteRunner_run_batch },
4298 { "finish", XS_Clownfish_TestHarness_TestSuiteRunner_finish },
4299 { "get_num_tests", XS_Clownfish_TestHarness_TestSuiteRunner_get_num_tests },
4300 { "get_num_tests_failed", XS_Clownfish_TestHarness_TestSuiteRunner_get_num_tests_failed },
4301 { "get_num_batches", XS_Clownfish_TestHarness_TestSuiteRunner_get_num_batches },
4302 { "get_num_batches_failed", XS_Clownfish_TestHarness_TestSuiteRunner_get_num_batches_failed },
4303 { "new", XS_Clownfish_Vector_new },
4304 { "push", XS_Clownfish_Vector_push },
4305 { "push_all", XS_Clownfish_Vector_push_all },
4306 { "pop", XS_Clownfish_Vector_pop },
4307 { "insert", XS_Clownfish_Vector_insert },
4308 { "insert_all", XS_Clownfish_Vector_insert_all },
4309 { "grow", XS_Clownfish_Vector_grow },
4310 { "fetch", XS_Clownfish_Vector_fetch },
4311 { "delete", XS_Clownfish_Vector_delete },
4312 { "excise", XS_Clownfish_Vector_excise },
4313 { "clone", XS_Clownfish_Vector_clone },
4314 { "sort", XS_Clownfish_Vector_sort },
4315 { "resize", XS_Clownfish_Vector_resize },
4316 { "clear", XS_Clownfish_Vector_clear },
4317 { "get_size", XS_Clownfish_Vector_get_size },
4318 { "get_capacity", XS_Clownfish_Vector_get_capacity },
4319 { "slice", XS_Clownfish_Vector_slice },
4320 { "equals", XS_Clownfish_Vector_equals }
4321 };
4322 28 size_t num_classes
4323 = sizeof(class_specs) / sizeof(class_specs[0]);
4324 28 const char* file = __FILE__;
4325  
4326 28 cfish_bootstrap_perl();
4327  
4328 28 cfish_XSBind_bootstrap(aTHX_ num_classes, class_specs,
4329 xsub_specs, file);
4330 }
4331  
4332 MODULE = Clownfish PACKAGE = Clownfish
4333  
4334 SV*
4335 to_clownfish(sv)
4336 SV *sv;
4337 CODE:
4338 {
4339 6 cfish_Obj *obj = XSBind_perl_to_cfish_nullable(aTHX_ sv, CFISH_OBJ);
4340 6 RETVAL = CFISH_OBJ_TO_SV_NOINC(obj);
4341 }
4342 OUTPUT: RETVAL
4343  
4344 MODULE = Clownfish PACKAGE = Clownfish::Blob
4345  
4346 SV*
4347 new(either_sv, sv)
4348 SV *either_sv;
4349 SV *sv;
4350 CODE:
4351 {
4352 STRLEN size;
4353 4 char *ptr = SvPV(sv, size);
4354 cfish_Blob *self
4355 4 = (cfish_Blob*)XSBind_new_blank_obj(aTHX_ either_sv);
4356 4 cfish_Blob_init(self, ptr, size);
4357 4 RETVAL = CFISH_OBJ_TO_SV_NOINC(self);
4358 }
4359 OUTPUT: RETVAL
4360  
4361 MODULE = Clownfish PACKAGE = Clownfish::Boolean
4362  
4363 SV*
4364 singleton(either_sv, value)
4365 SV *either_sv;
4366 bool value;
4367 CODE:
4368 {
4369 CFISH_UNUSED_VAR(either_sv);
4370 57 RETVAL = CFISH_OBJ_TO_SV_INC(cfish_Bool_singleton(value));
4371 }
4372 OUTPUT: RETVAL
4373  
4374 MODULE = Clownfish PACKAGE = Clownfish::ByteBuf
4375  
4376 SV*
4377 new(either_sv, sv)
4378 SV *either_sv;
4379 SV *sv;
4380 CODE:
4381 {
4382 STRLEN size;
4383 3 char *ptr = SvPV(sv, size);
4384 cfish_ByteBuf *self
4385 3 = (cfish_ByteBuf*)XSBind_new_blank_obj(aTHX_ either_sv);
4386 3 cfish_BB_init_bytes(self, ptr, size);
4387 3 RETVAL = CFISH_OBJ_TO_SV_NOINC(self);
4388 }
4389 OUTPUT: RETVAL
4390  
4391 MODULE = Clownfish PACKAGE = Clownfish::Class
4392  
4393 SV*
4394 fetch_class(unused_sv, class_name)
4395 SV *unused_sv;
4396 cfish_String *class_name;
4397 CODE:
4398 {
4399 1 cfish_Class *klass = cfish_Class_fetch_class(class_name);
4400 CFISH_UNUSED_VAR(unused_sv);
4401 1 ▶ RETVAL = klass ? (SV*)CFISH_Class_To_Host(klass, NULL) : &PL_sv_undef;
Branch: 1 branch
BranchTrueFalseTotal
RETVAL = klass ? (SV*)CFISH_Class_To_Host(klass, NULL) : &PL_sv_undef; 1 0 1
4402 }
4403 OUTPUT: RETVAL
4404  
4405 SV*
4406 singleton(unused_sv, ...)
4407 SV *unused_sv;
4408 CODE:
4409 {
4410 static const XSBind_ParamSpec param_specs[2] = {
4411 XSBIND_PARAM("class_name", true),
4412 XSBIND_PARAM("parent", false),
4413 };
4414 int32_t locations[2];
4415 0 cfish_String *class_name = NULL;
4416 0 cfish_Class *parent = NULL;
4417 0 cfish_Class *singleton = NULL;
4418 CFISH_UNUSED_VAR(unused_sv);
4419 0 XSBind_locate_args(aTHX_ &(ST(0)), 1, items, param_specs, locations, 2);
4420 0 class_name = (cfish_String*)XSBind_arg_to_cfish(
4421 0 aTHX_ ST(locations[0]), "class_name", CFISH_STRING,
4422 0 CFISH_ALLOCA_OBJ(CFISH_STRING));
4423 0 ▶ if (locations[1] < items) {
Branch: 1 branch
BranchTrueFalseTotal
if (locations[1] < items) { 0 0 0
4424 0 parent = (cfish_Class*)XSBind_arg_to_cfish_nullable(
4425 0 aTHX_ ST(locations[1]), "parent", CFISH_CLASS, NULL);
4426 }
4427 0 singleton = cfish_Class_singleton(class_name, parent);
4428 0 RETVAL = (SV*)CFISH_Class_To_Host(singleton, NULL);
4429 }
4430 OUTPUT: RETVAL
4431  
4432 MODULE = Clownfish PACKAGE = Clownfish::Err
4433  
4434 SV*
4435 trap(routine_sv, context_sv)
4436 SV *routine_sv;
4437 SV *context_sv;
4438 CODE:
4439 7 cfish_Err *error = XSBind_trap(routine_sv, context_sv);
4440 7 RETVAL = CFISH_OBJ_TO_SV_NOINC(error);
4441 OUTPUT: RETVAL
4442  
4443 MODULE = Clownfish PACKAGE = Clownfish::Float
4444  
4445 SV*
4446 new(either_sv, value)
4447 SV *either_sv;
4448 double value;
4449 CODE:
4450 {
4451 cfish_Float *self
4452 2 = (cfish_Float*)XSBind_new_blank_obj(aTHX_ either_sv);
4453 2 cfish_Float_init(self, value);
4454 2 RETVAL = CFISH_OBJ_TO_SV_NOINC(self);
4455 }
4456 OUTPUT: RETVAL
4457  
4458 MODULE = Clownfish PACKAGE = Clownfish::Hash
4459 SV*
4460 fetch_raw(self, key)
4461 cfish_Hash *self;
4462 cfish_String *key;
4463 CODE:
4464 5 RETVAL = CFISH_OBJ_TO_SV_INC(CFISH_Hash_Fetch(self, key));
4465 OUTPUT: RETVAL
4466  
4467 void
4468 store(self, key, value_sv);
4469 cfish_Hash *self;
4470 cfish_String *key;
4471 SV *value_sv;
4472 PPCODE:
4473 {
4474 cfish_Obj *value
4475 7 = (cfish_Obj*)XSBind_perl_to_cfish_nullable(aTHX_ value_sv, CFISH_OBJ);
4476 7 CFISH_Hash_Store(self, key, value);
4477 }
4478  
4479 MODULE = Clownfish PACKAGE = Clownfish::HashIterator
4480  
4481 SV*
4482 new(either_sv, hash)
4483 SV *either_sv;
4484 cfish_Hash *hash;
4485 CODE:
4486 {
4487 cfish_HashIterator *self
4488 1 = (cfish_HashIterator*)XSBind_new_blank_obj(aTHX_ either_sv);
4489 1 cfish_HashIter_init(self, hash);
4490 1 RETVAL = CFISH_OBJ_TO_SV_NOINC(self);
4491 }
4492 OUTPUT: RETVAL
4493  
4494 MODULE = Clownfish PACKAGE = Clownfish::Integer
4495  
4496 SV*
4497 new(either_sv, value)
4498 SV *either_sv;
4499 int64_t value;
4500 CODE:
4501 {
4502 cfish_Integer *self
4503 2 = (cfish_Integer*)XSBind_new_blank_obj(aTHX_ either_sv);
4504 2 cfish_Int_init(self, value);
4505 2 RETVAL = CFISH_OBJ_TO_SV_NOINC(self);
4506 }
4507 OUTPUT: RETVAL
4508  
4509 MODULE = Clownfish PACKAGE = Clownfish::Obj
4510  
4511 void
4512 DESTROY(sv)
4513 SV *sv
4514 PPCODE:
4515 232 XSBind_destroy(aTHX_ sv);
4516  
4517 SV*
4518 get_class(self)
4519 cfish_Obj *self
4520 CODE:
4521 1 cfish_Class *klass = cfish_Obj_get_class(self);
4522 1 RETVAL = (SV*)CFISH_Class_To_Host(klass, NULL);
4523 OUTPUT: RETVAL
4524  
4525 SV*
4526 get_class_name(self)
4527 cfish_Obj *self
4528 CODE:
4529 1 cfish_String *class_name = cfish_Obj_get_class_name(self);
4530 1 RETVAL = (SV*)CFISH_Str_To_Host(class_name, NULL);
4531 OUTPUT: RETVAL
4532  
4533 bool
4534 is_a(self, class_name)
4535 cfish_Obj *self;
4536 cfish_String *class_name;
4537 CODE:
4538 {
4539 5 cfish_Class *target = cfish_Class_fetch_class(class_name);
4540 5 RETVAL = cfish_Obj_is_a(self, target);
4541 }
4542 OUTPUT: RETVAL
4543  
4544 SV*
4545 clone_raw(self)
4546 cfish_Obj *self;
4547 CODE:
4548 7 RETVAL = CFISH_OBJ_TO_SV_NOINC(CFISH_Obj_Clone(self));
4549 OUTPUT: RETVAL
4550  
4551 SV*
4552 to_perl(self)
4553 cfish_Obj *self;
4554 CODE:
4555 16 RETVAL = (SV*)CFISH_Obj_To_Host(self, NULL);
4556 OUTPUT: RETVAL
4557  
4558 MODULE = Clownfish PACKAGE = Clownfish::String
4559  
4560 SV*
4561 new(either_sv, sv)
4562 SV *either_sv;
4563 SV *sv;
4564 CODE:
4565 {
4566 STRLEN size;
4567 49 char *ptr = SvPVutf8(sv, size);
4568 49 cfish_String *self = (cfish_String*)XSBind_new_blank_obj(aTHX_ either_sv);
4569 49 cfish_Str_init_from_trusted_utf8(self, ptr, size);
4570 49 RETVAL = CFISH_OBJ_TO_SV_NOINC(self);
4571 }
4572 OUTPUT: RETVAL
4573  
4574 MODULE = Clownfish PACKAGE = Clownfish::StringIterator
4575  
4576 SV*
4577 next(self)
4578 cfish_StringIterator *self;
4579 CODE:
4580 {
4581 7 int32_t cp = CFISH_StrIter_Next(self);
4582  
4583 7 ▶ if (cp == CFISH_STR_OOB) {
Branch: 1 branch
BranchTrueFalseTotal
if (cp == CFISH_STR_OOB) { 1 6 7
4584 1 RETVAL = &PL_sv_undef;
4585 }
4586 6 ▶ else if (cp == 0) {
Branch: 1 branch
BranchTrueFalseTotal
else if (cp == 0) { 1 5 6
4587 /* Zero but true. */
4588 1 RETVAL = newSVpvn("0e0", 3);
4589 }
4590 else {
4591 5 RETVAL = newSViv(cp);
4592 }
4593 }
4594 OUTPUT: RETVAL
4595  
4596 SV*
4597 prev(self)
4598 cfish_StringIterator *self;
4599 CODE:
4600 {
4601 0 int32_t cp = CFISH_StrIter_Prev(self);
4602  
4603 0 ▶ if (cp == CFISH_STR_OOB) {
Branch: 1 branch
BranchTrueFalseTotal
if (cp == CFISH_STR_OOB) { 0 0 0
4604 0 RETVAL = &PL_sv_undef;
4605 }
4606 0 ▶ else if (cp == 0) {
Branch: 1 branch
BranchTrueFalseTotal
else if (cp == 0) { 0 0 0
4607 /* Zero but true. */
4608 0 RETVAL = newSVpvn("0e0", 3);
4609 }
4610 else {
4611 0 RETVAL = newSViv(cp);
4612 }
4613 }
4614 OUTPUT: RETVAL
4615  
4616 MODULE = Clownfish PACKAGE = Clownfish::Vector
4617  
4618 SV*
4619 pop_raw(self)
4620 cfish_Vector *self;
4621 CODE:
4622 0 RETVAL = CFISH_OBJ_TO_SV_NOINC(CFISH_Vec_Pop(self));
4623 OUTPUT: RETVAL
4624  
4625 SV*
4626 delete_raw(self, tick)
4627 cfish_Vector *self;
4628 uint32_t tick;
4629 CODE:
4630 0 RETVAL = CFISH_OBJ_TO_SV_NOINC(CFISH_Vec_Delete(self, tick));
4631 OUTPUT: RETVAL
4632  
4633 void
4634 store(self, tick, value);
4635 cfish_Vector *self;
4636 uint32_t tick;
4637 cfish_Obj *value;
4638 PPCODE:
4639 {
4640 0 ▶ if (value) { CFISH_INCREF(value); }
Branch: 1 branch
BranchTrueFalseTotal
if (value) { CFISH_INCREF(value); } 0 0 0
4641 0 CFISH_Vec_Store(self, tick, value);
4642 }
4643  
4644 SV*
4645 fetch_raw(self, tick)
4646 cfish_Vector *self;
4647 uint32_t tick;
4648 CODE:
4649 5 RETVAL = CFISH_OBJ_TO_SV_INC(CFISH_Vec_Fetch(self, tick));
4650 OUTPUT: RETVAL
4651  
4652  
« autogen/include/Clownfish/Vector.h ↑ Summary lib/Clownfish/Test.xs »