Clownfish-CFC/lib/Clownfish/CFC.xs
/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "CFC.h"
/* Rather than provide an XSUB for each accessor, we can use one multipath
* accessor function per class, with several Perl-space aliases. All set
* functions have odd-numbered aliases, and all get functions have
* even-numbered aliases. These two macros serve as bookends for the switch
* function.
*/
#define START_SET_OR_GET_SWITCH \
SV *retval = &PL_sv_undef; \
/* If called as a setter, make sure the extra arg is there. */ \
if (ix % 2 == 1) { \
if (items != 2) { croak("usage: $object->set_xxxxxx($val)"); } \
} \
else { \
if (items != 1) { croak("usage: $object->get_xxxxx()"); } \
} \
switch (ix) {
#define END_SET_OR_GET_SWITCH \
default: croak("Internal error. ix: %d", (int)ix); \
} \
if (ix % 2 == 0) { \
XPUSHs(sv_2mortal(retval)); \
XSRETURN(1); \
} \
else { \
XSRETURN(0); \
}
static SV*
S_cfcbase_to_perlref(void *thing) {
SV *ref = newSV(0);
if (thing) {
const char *klass = CFCBase_get_cfc_class((CFCBase*)thing);
CFCBase_incref((CFCBase*)thing);
sv_setref_pv(ref, klass, (void*)thing);
}
return ref;
}
// Transform a NULL-terminated array of char* into a Perl arrayref.
static SV*
S_string_array_to_av(const char **strings) {
AV *av = newAV();
for (size_t i = 0; strings[i] != NULL; i++) {
SV *val = newSVpvn(strings[i], strlen(strings[i]));
av_store(av, i, val);
}
SV *retval = newRV_noinc((SV*)av);
return retval;
}
// Transform a NULL-terminated array of CFCBase* into a Perl arrayref.
static SV*
S_array_of_cfcbase_to_av(CFCBase **things) {
AV *av = newAV();
for (size_t i = 0; things[i] != NULL; i++) {
SV *val = S_cfcbase_to_perlref(things[i]);
av_store(av, i, val);
}
SV *retval = newRV((SV*)av);
SvREFCNT_dec(av);
return retval;
}
// Transform a Perl arrayref into a NULL-terminated array of CFCBase*.
static CFCBase**
S_av_to_array_of_cfcbase(SV *ref, const char *class_name) {
if (!SvROK(ref)) { croak("Not an arrayref"); }
SV *sv = SvRV(ref);
if (SvTYPE(sv) != SVt_PVAV) { croak("Not an arrayref"); }
AV *av = (AV*)sv;
size_t size = av_len(av) + 1;
CFCBase **retval = (CFCBase**)CALLOCATE(size + 1, sizeof(CFCBase*));
for (size_t i = 0; i < size; i++) {
SV **elem = av_fetch(av, i, 0);
if (!elem || !sv_derived_from(*elem, class_name)) {
croak("Array element not of type %s", class_name);
}
IV objint = SvIV((SV*)SvRV(*elem));
retval[i] = INT2PTR(CFCBase*, objint);
}
return retval;
}
static SV*
S_sv_eat_c_string(char *string) {
if (string) {
SV *sv = newSVpvn(string, strlen(string));
FREEMEM(string);
return sv;
}
else {
return newSV(0);
}
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Base
void
DESTROY(self)
CFCBase *self;
PPCODE:
CFCBase_decref((CFCBase*)self);
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::CBlock
SV*
_new(contents)
const char *contents;
CODE:
CFCCBlock *self = CFCCBlock_new(contents);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCCBlock *self;
ALIAS:
get_contents = 2
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *contents = CFCCBlock_get_contents(self);
retval = newSVpvn(contents, strlen(contents));
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Class
SV*
_create(parcel, exposure_sv, class_name_sv, class_nickname_sv, docucomment, file_spec, parent_class_name_sv, is_final, is_inert, is_abstract)
CFCParcel *parcel;
SV *exposure_sv;
SV *class_name_sv;
SV *class_nickname_sv;
CFCDocuComment *docucomment;
CFCFileSpec *file_spec;
SV *parent_class_name_sv;
bool is_final;
bool is_inert;
bool is_abstract;
CODE:
const char *exposure =
SvOK(exposure_sv) ? SvPV_nolen(exposure_sv) : NULL;
const char *class_name =
SvOK(class_name_sv) ? SvPV_nolen(class_name_sv) : NULL;
const char *class_nickname =
SvOK(class_nickname_sv) ? SvPV_nolen(class_nickname_sv) : NULL;
const char *parent_class_name =
SvOK(parent_class_name_sv) ? SvPV_nolen(parent_class_name_sv) : NULL;
CFCClass *self
= CFCClass_create(parcel, exposure, class_name, class_nickname,
docucomment, file_spec, parent_class_name,
is_final, is_inert, is_abstract);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
fetch_singleton(unused, class_name)
SV *unused;
const char *class_name;
CODE:
CHY_UNUSED_VAR(unused);
CFCClass *klass = CFCClass_fetch_singleton(class_name);
RETVAL = S_cfcbase_to_perlref(klass);
OUTPUT: RETVAL
void
_clear_registry(...)
PPCODE:
CHY_UNUSED_VAR(items);
CFCClass_clear_registry();
void
add_child(self, child)
CFCClass *self;
CFCClass *child;
PPCODE:
CFCClass_add_child(self, child);
void
add_member_var(self, var)
CFCClass *self;
CFCVariable *var;
PPCODE:
CFCClass_add_member_var(self, var);
void
add_function(self, func)
CFCClass *self;
CFCFunction *func;
PPCODE:
CFCClass_add_function(self, func);
void
add_method(self, method)
CFCClass *self;
CFCMethod *method;
PPCODE:
CFCClass_add_method(self, method);
void
grow_tree(self)
CFCClass *self;
PPCODE:
CFCClass_grow_tree(self);
void
add_inert_var(self, var)
CFCClass *self;
CFCVariable *var;
PPCODE:
CFCClass_add_inert_var(self, var);
SV*
function(self, sym)
CFCClass *self;
const char *sym;
CODE:
CFCFunction *func = CFCClass_function(self, sym);
RETVAL = S_cfcbase_to_perlref(func);
OUTPUT: RETVAL
SV*
method(self, sym)
CFCClass *self;
const char *sym;
CODE:
CFCMethod *method = CFCClass_method(self, sym);
RETVAL = S_cfcbase_to_perlref(method);
OUTPUT: RETVAL
SV*
fresh_method(self, sym)
CFCClass *self;
const char *sym;
CODE:
CFCMethod *method = CFCClass_fresh_method(self, sym);
RETVAL = S_cfcbase_to_perlref(method);
OUTPUT: RETVAL
void
resolve_types(self)
CFCClass *self;
PPCODE:
CFCClass_resolve_types(self);
void
_set_or_get(self, ...)
CFCClass *self;
ALIAS:
get_exposure = 2
get_name = 4
get_nickname = 6
set_parent = 7
get_parent = 8
get_path_part = 10
get_parent_class_name = 12
final = 14
inert = 16
get_struct_sym = 18
full_struct_sym = 20
short_class_var = 22
full_class_var = 24
include_h = 28
get_docucomment = 30
children = 32
functions = 34
methods = 36
member_vars = 38
inert_vars = 40
tree_to_ladder = 42
fresh_methods = 44
fresh_member_vars = 46
privacy_symbol = 48
included = 50
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCClass_get_exposure(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 4: {
const char *value = CFCClass_get_name(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 6: {
const char *value = CFCClass_get_nickname(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 7: {
CFCClass *parent = NULL;
if (SvOK(ST(1))
&& sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")
) {
IV objint = SvIV((SV*)SvRV(ST(1)));
parent = INT2PTR(CFCClass*, objint);
}
CFCClass_set_parent(self, parent);
break;
}
case 8: {
CFCClass *parent = CFCClass_get_parent(self);
retval = S_cfcbase_to_perlref(parent);
break;
}
case 10: {
const char *value = CFCClass_get_path_part(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 12: {
const char *value = CFCClass_get_parent_class_name(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 14:
retval = newSViv(CFCClass_final(self));
break;
case 16:
retval = newSViv(CFCClass_inert(self));
break;
case 18: {
const char *value = CFCClass_get_struct_sym(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 20: {
const char *value = CFCClass_full_struct_sym(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 22: {
const char *value = CFCClass_short_class_var(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 24: {
const char *value = CFCClass_full_class_var(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 28: {
const char *value = CFCClass_include_h(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 30: {
CFCDocuComment *docucomment = CFCClass_get_docucomment(self);
retval = S_cfcbase_to_perlref(docucomment);
}
break;
case 32:
retval = S_array_of_cfcbase_to_av(
(CFCBase**)CFCClass_children(self));
break;
case 34:
retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_functions(self));
break;
case 36:
retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_methods(self));
break;
case 38:
retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_member_vars(self));
break;
case 40:
retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_inert_vars(self));
break;
case 42: {
CFCClass **ladder = CFCClass_tree_to_ladder(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)ladder);
FREEMEM(ladder);
break;
}
case 44: {
CFCMethod **fresh = CFCClass_fresh_methods(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)fresh);
break;
}
case 46: {
CFCVariable **fresh = CFCClass_fresh_member_vars(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)fresh);
break;
}
case 48: {
const char *value = CFCClass_privacy_symbol(self);
retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
}
break;
case 50:
retval = newSViv(CFCClass_included(self));
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::DocuComment
SV*
parse(klass, text)
const char *klass;
const char *text;
CODE:
if (strcmp(klass, "Clownfish::CFC::Model::DocuComment")) {
croak("No subclassing allowed");
}
CFCDocuComment *self = CFCDocuComment_parse(text);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCDocuComment *self;
ALIAS:
get_description = 2
get_brief = 4
get_long = 6
get_param_names = 8
get_param_docs = 10
get_retval = 12
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *description = CFCDocuComment_get_description(self);
retval = newSVpvn(description, strlen(description));
}
break;
case 4: {
const char *brief = CFCDocuComment_get_brief(self);
retval = newSVpvn(brief, strlen(brief));
}
break;
case 6: {
const char *long_description = CFCDocuComment_get_long(self);
retval = newSVpvn(long_description, strlen(long_description));
}
break;
case 8: {
const char **names = CFCDocuComment_get_param_names(self);
retval = S_string_array_to_av(names);
}
break;
case 10: {
const char **docs = CFCDocuComment_get_param_docs(self);
retval = S_string_array_to_av(docs);
}
break;
case 12: {
const char *rv = CFCDocuComment_get_retval(self);
retval = rv ? newSVpvn(rv, strlen(rv)) : newSV(0);
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::File
SV*
_new(parcel, spec)
CFCParcel *parcel;
CFCFileSpec *spec;
CODE:
CFCFile *self = CFCFile_new(parcel, spec);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
add_block(self, block)
CFCFile *self;
CFCBase *block;
PPCODE:
CFCFile_add_block(self, block);
void
_set_or_get(self, ...)
CFCFile *self;
ALIAS:
set_modified = 1
get_modified = 2
get_path_part = 4
guard_name = 6
guard_start = 8
guard_close = 10
blocks = 12
classes = 14
get_source_dir = 16
included = 18
get_parcel = 20
get_path = 22
PPCODE:
{
START_SET_OR_GET_SWITCH
case 1:
CFCFile_set_modified(self, !!SvTRUE(ST(1)));
break;
case 2:
retval = newSViv(CFCFile_get_modified(self));
break;
case 4: {
const char *value = CFCFile_get_path_part(self);
retval = newSVpv(value, strlen(value));
}
break;
case 6: {
const char *value = CFCFile_guard_name(self);
retval = newSVpv(value, strlen(value));
}
break;
case 8: {
const char *value = CFCFile_guard_start(self);
retval = newSVpv(value, strlen(value));
}
break;
case 10: {
const char *value = CFCFile_guard_close(self);
retval = newSVpv(value, strlen(value));
}
break;
case 12:
retval = S_array_of_cfcbase_to_av(CFCFile_blocks(self));
break;
case 14:
retval = S_array_of_cfcbase_to_av(
(CFCBase**)CFCFile_classes(self));
break;
case 16: {
const char *value = CFCFile_get_source_dir(self);
retval = newSVpv(value, strlen(value));
}
break;
case 18:
retval = newSViv(CFCFile_included(self));
break;
case 20: {
CFCParcel *parcel = CFCFile_get_parcel(self);
retval = S_cfcbase_to_perlref(parcel);
}
break;
case 22: {
const char *value = CFCFile_get_path(self);
retval = newSVpv(value, strlen(value));
}
break;
END_SET_OR_GET_SWITCH
}
SV*
_gen_path(self, base_dir = NULL)
CFCFile *self;
const char *base_dir;
ALIAS:
c_path = 1
h_path = 2
CODE:
{
char *buf;
switch (ix) {
case 1:
buf = CFCFile_c_path(self, base_dir);
break;
case 2:
buf = CFCFile_h_path(self, base_dir);
break;
default:
croak("unexpected ix value: %d", (int)ix);
}
RETVAL = newSVpvn(buf, strlen(buf));
FREEMEM(buf);
}
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::FileSpec
SV*
_new(source_dir, path_part, ext, is_included)
const char *source_dir;
const char *path_part;
const char *ext;
bool is_included;
CODE:
CFCFileSpec *self = CFCFileSpec_new(source_dir, path_part, ext,
is_included);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCFileSpec *self;
ALIAS:
get_source_dir = 2
get_path_part = 4
included = 6
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCFileSpec_get_source_dir(self);
retval = newSVpv(value, strlen(value));
}
break;
case 4: {
const char *value = CFCFileSpec_get_path_part(self);
retval = newSVpv(value, strlen(value));
}
break;
case 6:
retval = newSViv(CFCFileSpec_included(self));
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Function
SV*
_new(exposure_sv, name_sv, return_type, param_list, docucomment, is_inline)
SV *exposure_sv;
SV *name_sv;
CFCType *return_type;
CFCParamList *param_list;
CFCDocuComment *docucomment;
int is_inline;
CODE:
const char *exposure =
SvOK(exposure_sv) ? SvPV_nolen(exposure_sv) : NULL;
const char *name =
SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
CFCFunction *self = CFCFunction_new(exposure, name, return_type,
param_list, docucomment, is_inline);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
resolve_types(self)
CFCFunction *self;
PPCODE:
CFCFunction_resolve_types(self);
SV*
_various_function_syms(self, klass)
CFCFunction *self;
CFCClass *klass;
ALIAS:
short_func_sym = 1
full_func_sym = 2
CODE:
char *buf;
switch (ix) {
case 1:
buf = CFCFunction_short_func_sym(self, klass);
break;
case 2:
buf = CFCFunction_full_func_sym(self, klass);
break;
default: croak("Unexpected ix: %d", (int)ix);
}
RETVAL = S_sv_eat_c_string(buf);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCFunction *self;
ALIAS:
get_return_type = 2
get_param_list = 4
get_docucomment = 6
inline = 8
void = 10
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
CFCType *type = CFCFunction_get_return_type(self);
retval = S_cfcbase_to_perlref(type);
}
break;
case 4: {
CFCParamList *param_list = CFCFunction_get_param_list(self);
retval = S_cfcbase_to_perlref(param_list);
}
break;
case 6: {
CFCDocuComment *docucomment
= CFCFunction_get_docucomment(self);
retval = S_cfcbase_to_perlref(docucomment);
}
break;
case 8:
retval = newSViv(CFCFunction_inline(self));
break;
case 10:
retval = newSViv(CFCFunction_void(self));
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Hierarchy
SV*
_new(dest)
const char *dest;
CODE:
CFCHierarchy *self = CFCHierarchy_new(dest);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
add_source_dir(self, source_dir)
CFCHierarchy *self;
const char *source_dir;
PPCODE:
CFCHierarchy_add_source_dir(self, source_dir);
void
add_include_dir(self, include_dir)
CFCHierarchy *self;
const char *include_dir;
PPCODE:
CFCHierarchy_add_include_dir(self, include_dir);
void
build(self)
CFCHierarchy *self;
PPCODE:
CFCHierarchy_build(self);
void
read_host_data_json(self)
CFCHierarchy *self;
PPCODE:
CFCHierarchy_read_host_data_json(self, "perl");
int
propagate_modified(self, ...)
CFCHierarchy *self;
CODE:
int modified = items > 1 ? !!SvTRUE(ST(1)) : 0;
RETVAL = CFCHierarchy_propagate_modified(self, modified);
OUTPUT: RETVAL
void
write_log(self)
CFCHierarchy *self;
PPCODE:
CFCHierarchy_write_log(self);
void
_set_or_get(self, ...)
CFCHierarchy *self;
ALIAS:
get_dest = 2
get_include_dest = 4
get_source_dest = 6
files = 8
ordered_classes = 10
get_source_dirs = 12
get_include_dirs = 14
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCHierarchy_get_dest(self);
retval = newSVpv(value, strlen(value));
}
break;
case 4: {
const char *value = CFCHierarchy_get_include_dest(self);
retval = newSVpv(value, strlen(value));
}
break;
case 6: {
const char *value = CFCHierarchy_get_source_dest(self);
retval = newSVpv(value, strlen(value));
}
break;
case 8:
retval = S_array_of_cfcbase_to_av(
(CFCBase**)CFCHierarchy_files(self));
break;
case 10: {
CFCClass **ladder = CFCHierarchy_ordered_classes(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)ladder);
FREEMEM(ladder);
}
break;
case 12: {
const char **source_dirs = CFCHierarchy_get_source_dirs(self);
retval = S_string_array_to_av(source_dirs);
}
break;
case 14: {
const char **include_dirs = CFCHierarchy_get_include_dirs(self);
retval = S_string_array_to_av(include_dirs);
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Method
SV*
_new(exposure_sv, name, return_type, param_list, docucomment, class_name_sv, is_final, is_abstract)
SV *exposure_sv;
const char *name;
CFCType *return_type;
CFCParamList *param_list;
CFCDocuComment *docucomment;
SV *class_name_sv;
int is_final;
int is_abstract;
CODE:
const char *exposure =
SvOK(exposure_sv) ? SvPV_nolen(exposure_sv) : NULL;
const char *class_name =
SvOK(class_name_sv) ? SvPV_nolen(class_name_sv) : NULL;
CFCMethod *self
= CFCMethod_new(exposure, name, return_type, param_list, docucomment,
class_name, is_final, is_abstract);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
int
compatible(self, other)
CFCMethod *self;
CFCMethod *other;
CODE:
RETVAL = CFCMethod_compatible(self, other);
OUTPUT: RETVAL
void
override(self, other)
CFCMethod *self;
CFCMethod *other;
PPCODE:
CFCMethod_override(self, other);
SV*
finalize(self)
CFCMethod *self;
CODE:
CFCMethod *finalized = CFCMethod_finalize(self);
RETVAL = S_cfcbase_to_perlref(finalized);
CFCBase_decref((CFCBase*)finalized);
OUTPUT: RETVAL
void
resolve_types(self)
CFCMethod *self;
PPCODE:
CFCMethod_resolve_types(self);
void
exclude_from_host(self)
CFCMethod *self;
PPCODE:
CFCMethod_exclude_from_host(self);
SV*
_various_method_syms(self, invoker)
CFCMethod *self;
CFCClass *invoker;
ALIAS:
short_method_sym = 1
full_method_sym = 2
full_offset_sym = 3
short_typedef = 4
full_typedef = 5
full_override_sym = 6
CODE:
char *buf;
switch (ix) {
case 1:
buf = CFCMethod_short_method_sym(self, invoker);
break;
case 2:
buf = CFCMethod_full_method_sym(self, invoker);
break;
case 3:
buf = CFCMethod_full_offset_sym(self, invoker);
break;
case 4:
buf = CFCMethod_short_typedef(self, invoker);
break;
case 5:
buf = CFCMethod_full_typedef(self, invoker);
break;
case 6:
buf = CFCMethod_full_override_sym(self, invoker);
break;
default: croak("Unexpected ix: %d", (int)ix);
}
RETVAL = newSVpvn(buf, strlen(buf));
FREEMEM(buf);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCMethod *self;
ALIAS:
abstract = 12
novel = 14
final = 16
self_type = 18
set_host_alias = 19
get_host_alias = 20
excluded_from_host = 22
PPCODE:
{
START_SET_OR_GET_SWITCH
case 12:
retval = newSViv(CFCMethod_abstract(self));
break;
case 14:
retval = newSViv(CFCMethod_novel(self));
break;
case 16:
retval = newSViv(CFCMethod_final(self));
break;
case 18: {
CFCType *type = CFCMethod_self_type(self);
retval = S_cfcbase_to_perlref(type);
}
break;
case 19: {
const char *value = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
CFCMethod_set_host_alias(self, value);
}
break;
case 20: {
const char *value = CFCMethod_get_host_alias(self);
if (value) {
retval = newSVpvn(value, strlen(value));
}
}
break;
case 22:
retval = newSViv(CFCMethod_excluded_from_host(self));
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::ParamList
SV*
_new(variadic)
int variadic;
CODE:
CFCParamList *self = CFCParamList_new(variadic);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
add_param(self, variable, value_sv)
CFCParamList *self;
CFCVariable *variable;
SV *value_sv;
PPCODE:
const char *value = SvOK(value_sv) ? SvPV_nolen(value_sv) : NULL;
CFCParamList_add_param(self, variable, value);
void
resolve_types(self)
CFCParamList *self;
PPCODE:
CFCParamList_resolve_types(self);
void
_set_or_get(self, ...)
CFCParamList *self;
ALIAS:
get_variables = 2
get_initial_values = 4
variadic = 6
num_vars = 8
to_c = 10
name_list = 12
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
AV *av = newAV();
CFCVariable **vars = CFCParamList_get_variables(self);
int num_vars = CFCParamList_num_vars(self);
for (int i = 0; i < num_vars; i++) {
SV *ref = S_cfcbase_to_perlref(vars[i]);
av_store(av, i, ref);
}
retval = newRV((SV*)av);
SvREFCNT_dec(av);
break;
}
case 4: {
AV *av = newAV();
const char **values = CFCParamList_get_initial_values(self);
int num_vars = CFCParamList_num_vars(self);
for (int i = 0; i < num_vars; i++) {
if (values[i] != NULL) {
SV *val_sv = newSVpvn(values[i], strlen(values[i]));
av_store(av, i, val_sv);
}
else {
av_store(av, i, newSV(0));
}
}
retval = newRV((SV*)av);
SvREFCNT_dec(av);
break;
}
case 6:
retval = newSViv(CFCParamList_variadic(self));
break;
case 8:
retval = newSViv(CFCParamList_num_vars(self));
break;
case 10: {
const char *value = CFCParamList_to_c(self);
retval = newSVpv(value, strlen(value));
}
break;
case 12: {
const char *value = CFCParamList_name_list(self);
retval = newSVpv(value, strlen(value));
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Parcel
SV*
_new(name_sv, nickname_sv, version, major_version, file_spec)
SV *name_sv;
SV *nickname_sv;
CFCVersion *version;
CFCVersion *major_version;
CFCFileSpec *file_spec;
CODE:
const char *name = SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
const char *nickname = SvOK(nickname_sv) ? SvPV_nolen(nickname_sv) : NULL;
CFCParcel *self = CFCParcel_new(name, nickname, version, major_version,
file_spec);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_from_file(file_spec)
CFCFileSpec *file_spec;
CODE:
CFCParcel *self = CFCParcel_new_from_file(file_spec);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_from_json(json, file_spec)
const char *json;
CFCFileSpec *file_spec;
CODE:
CFCParcel *self = CFCParcel_new_from_json(json, file_spec);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
fetch(unused, name_sv)
SV *unused;
SV *name_sv;
CODE:
CHY_UNUSED_VAR(unused);
const char *name = SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
CFCParcel *self = CFCParcel_fetch(name);
RETVAL = S_cfcbase_to_perlref(self);
OUTPUT: RETVAL
void
register(self)
CFCParcel *self;
PPCODE:
CFCParcel_register(self);
int
equals(self, other)
CFCParcel *self;
CFCParcel *other;
CODE:
RETVAL = CFCParcel_equals(self, other);
OUTPUT: RETVAL
SV*
all_parcels(...)
CODE:
CHY_UNUSED_VAR(items);
CFCParcel **all_parcels = CFCParcel_all_parcels();
RETVAL = S_array_of_cfcbase_to_av((CFCBase**)all_parcels);
OUTPUT: RETVAL
void
add_inherited_parcel(self, inherited)
CFCParcel *self;
CFCParcel *inherited;
PPCODE:
CFCParcel_add_inherited_parcel(self, inherited);
int
has_prereq(self, parcel)
CFCParcel *self;
CFCParcel *parcel;
CODE:
RETVAL = CFCParcel_has_prereq(self, parcel);
OUTPUT: RETVAL
void
add_struct_sym(self, struct_sym)
CFCParcel *self;
const char *struct_sym;
PPCODE:
CFCParcel_add_struct_sym(self, struct_sym);
SV*
lookup_struct_sym(self, struct_sym)
CFCParcel *self;
const char *struct_sym;
CODE:
CFCParcel *parcel = CFCParcel_lookup_struct_sym(self, struct_sym);
RETVAL = S_cfcbase_to_perlref(parcel);
OUTPUT: RETVAL
void
reap_singletons(...)
PPCODE:
CHY_UNUSED_VAR(items);
CFCParcel_reap_singletons();
void
_set_or_get(self, ...)
CFCParcel *self;
ALIAS:
get_name = 2
get_nickname = 4
get_prefix = 6
get_Prefix = 8
get_PREFIX = 10
get_version = 12
get_prereqs = 14
included = 16
prereq_parcels = 20
inherited_parcels = 22
get_xs_module = 24
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *name = CFCParcel_get_name(self);
retval = newSVpvn(name, strlen(name));
}
break;
case 4: {
const char *nickname = CFCParcel_get_nickname(self);
retval = newSVpvn(nickname, strlen(nickname));
}
break;
case 6: {
const char *value = CFCParcel_get_prefix(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 8: {
const char *value = CFCParcel_get_Prefix(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 10: {
const char *value = CFCParcel_get_PREFIX(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 12: {
CFCVersion *value = CFCParcel_get_version(self);
retval = S_cfcbase_to_perlref(value);
}
break;
case 14: {
CFCPrereq **prereqs = CFCParcel_get_prereqs(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)prereqs);
}
break;
case 16:
retval = newSViv(CFCParcel_included(self));
break;
case 20: {
CFCParcel **parcels = CFCParcel_prereq_parcels(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)parcels);
FREEMEM(parcels);
}
break;
case 22: {
CFCParcel **parcels = CFCParcel_inherited_parcels(self);
retval = S_array_of_cfcbase_to_av((CFCBase**)parcels);
FREEMEM(parcels);
}
break;
case 24: {
const char *xs_module = CFCParcel_get_host_module_name(self);
retval = newSVpvn(xs_module, strlen(xs_module));
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Prereq
SV*
_new(name_sv, version)
SV *name_sv;
CFCVersion *version;
CODE:
const char *name = SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
CFCPrereq *self = CFCPrereq_new(name, version);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCPrereq *self;
ALIAS:
get_name = 2
get_version = 4
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *name = CFCPrereq_get_name(self);
retval = newSVpvn(name, strlen(name));
}
break;
case 4: {
CFCVersion *value = CFCPrereq_get_version(self);
retval = S_cfcbase_to_perlref(value);
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Symbol
SV*
_new(exposure, name_sv)
const char *exposure;
SV *name_sv;
CODE:
const char *name = SvOK(name_sv)
? SvPV_nolen(name_sv)
: NULL;
CFCSymbol *self = CFCSymbol_new(exposure, name);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
int
equals(self, other)
CFCSymbol *self;
CFCSymbol *other;
CODE:
RETVAL = CFCSymbol_equals(self, other);
OUTPUT: RETVAL
SV*
_various_syms(self, klass)
CFCSymbol *self;
CFCClass *klass;
ALIAS:
short_sym = 1
full_sym = 2
CODE:
char *buf;
switch (ix) {
case 1:
buf = CFCSymbol_short_sym(self, klass);
break;
case 2:
buf = CFCSymbol_full_sym(self, klass);
break;
default: croak("Unexpected ix: %d", (int)ix);
}
RETVAL = S_sv_eat_c_string(buf);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCSymbol *self;
ALIAS:
get_exposure = 8
get_name = 10
public = 18
private = 20
parcel = 22
local = 24
PPCODE:
{
START_SET_OR_GET_SWITCH
case 8: {
const char *exposure = CFCSymbol_get_exposure(self);
retval = newSVpvn(exposure, strlen(exposure));
}
break;
case 10: {
const char *name = CFCSymbol_get_name(self);
retval = newSVpvn(name, strlen(name));
}
break;
case 18:
retval = newSViv(CFCSymbol_public(self));
break;
case 20:
retval = newSViv(CFCSymbol_private(self));
break;
case 22:
retval = newSViv(CFCSymbol_parcel(self));
break;
case 24:
retval = newSViv(CFCSymbol_local(self));
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Type
SV*
_new(flags, parcel, specifier, indirection)
int flags;
CFCParcel *parcel;
const char *specifier;
int indirection;
CODE:
CFCType *self = CFCType_new(flags, parcel, specifier, indirection);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_integer(flags, specifier)
int flags;
const char *specifier;
CODE:
CFCType *self = CFCType_new_integer(flags, specifier);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_float(flags, specifier)
int flags;
const char *specifier;
CODE:
CFCType *self = CFCType_new_float(flags, specifier);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_object(flags, parcel, specifier, indirection)
int flags;
CFCParcel *parcel;
const char *specifier;
int indirection;
CODE:
CFCType *self = CFCType_new_object(flags, parcel, specifier, indirection);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_composite(flags, child_sv, indirection, array)
int flags;
SV *child_sv;
int indirection;
const char *array;
CODE:
CFCType *child = NULL;
if (SvOK(child_sv) && sv_derived_from(child_sv, "Clownfish::CFC::Model::Type")) {
IV objint = SvIV((SV*)SvRV(child_sv));
child = INT2PTR(CFCType*, objint);
}
else {
croak("Param 'child' not a Clownfish::CFC::Model::Type");
}
CFCType *self = CFCType_new_composite(flags, child, indirection, array);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_void(is_const)
int is_const;
CODE:
CFCType *self = CFCType_new_void(is_const);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_va_list()
CODE:
CFCType *self = CFCType_new_va_list();
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
_new_arbitrary(parcel, specifier)
CFCParcel *parcel;
const char *specifier;
CODE:
CFCType *self = CFCType_new_arbitrary(parcel, specifier);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
int
equals(self, other)
CFCType *self;
CFCType *other;
CODE:
RETVAL = CFCType_equals(self, other);
OUTPUT: RETVAL
int
similar(self, other)
CFCType *self;
CFCType *other;
CODE:
RETVAL = CFCType_similar(self, other);
OUTPUT: RETVAL
unsigned
CONST(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_CONST;
OUTPUT: RETVAL
unsigned
NULLABLE(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_NULLABLE;
OUTPUT: RETVAL
unsigned
INCREMENTED(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_INCREMENTED;
OUTPUT: RETVAL
unsigned
DECREMENTED(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_DECREMENTED;
OUTPUT: RETVAL
unsigned
VOID(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_VOID;
OUTPUT: RETVAL
unsigned
OBJECT(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_OBJECT;
OUTPUT: RETVAL
unsigned
PRIMITIVE(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_PRIMITIVE;
OUTPUT: RETVAL
unsigned
INTEGER(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_INTEGER;
OUTPUT: RETVAL
unsigned
FLOATING(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_FLOATING;
OUTPUT: RETVAL
unsigned
CFISH_STRING(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_CFISH_STRING;
OUTPUT: RETVAL
unsigned
VA_LIST(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_VA_LIST;
OUTPUT: RETVAL
unsigned
ARBITRARY(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_ARBITRARY;
OUTPUT: RETVAL
unsigned
COMPOSITE(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = CFCTYPE_COMPOSITE;
OUTPUT: RETVAL
void
resolve(self)
CFCType *self;
PPCODE:
CFCType_resolve(self);
void
_set_or_get(self, ...)
CFCType *self;
ALIAS:
set_specifier = 1
get_specifier = 2
get_parcel = 4
get_indirection = 6
to_c = 8
const = 10
set_nullable = 11
nullable = 12
is_void = 14
is_object = 16
is_primitive = 18
is_integer = 20
is_floating = 22
cfish_string = 24
is_va_list = 26
is_arbitrary = 28
is_composite = 30
get_width = 32
incremented = 34
decremented = 36
get_array = 38
PPCODE:
{
START_SET_OR_GET_SWITCH
case 1:
CFCType_set_specifier(self, SvPV_nolen(ST(1)));
break;
case 2: {
const char *specifier = CFCType_get_specifier(self);
retval = newSVpvn(specifier, strlen(specifier));
}
break;
case 4: {
CFCParcel *parcel = CFCType_get_parcel(self);
retval = S_cfcbase_to_perlref(parcel);
}
break;
case 6:
retval = newSViv(CFCType_get_indirection(self));
break;
case 8: {
const char *c_string = CFCType_to_c(self);
retval = newSVpvn(c_string, strlen(c_string));
}
break;
case 10:
retval = newSViv(CFCType_const(self));
break;
case 11:
CFCType_set_nullable(self, !!SvTRUE(ST(1)));
break;
case 12:
retval = newSViv(CFCType_nullable(self));
break;
case 14:
retval = newSViv(CFCType_is_void(self));
break;
case 16:
retval = newSViv(CFCType_is_object(self));
break;
case 18:
retval = newSViv(CFCType_is_primitive(self));
break;
case 20:
retval = newSViv(CFCType_is_integer(self));
break;
case 22:
retval = newSViv(CFCType_is_floating(self));
break;
case 24:
retval = newSViv(CFCType_cfish_string(self));
break;
case 26:
retval = newSViv(CFCType_is_va_list(self));
break;
case 28:
retval = newSViv(CFCType_is_arbitrary(self));
break;
case 30:
retval = newSViv(CFCType_is_composite(self));
break;
case 32:
retval = newSVuv(CFCType_get_width(self));
break;
case 34:
retval = newSVuv(CFCType_incremented(self));
break;
case 36:
retval = newSVuv(CFCType_decremented(self));
break;
case 38: {
const char *array = CFCType_get_array(self);
retval = array
? newSVpvn(array, strlen(array))
: newSV(0);
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Util
SV*
trim_whitespace(text)
SV *text;
CODE:
RETVAL = newSVsv(text);
STRLEN len;
char *ptr = SvPV(RETVAL, len);
CFCUtil_trim_whitespace(ptr);
SvCUR_set(RETVAL, strlen(ptr));
OUTPUT: RETVAL
SV*
slurp_text(path)
const char *path;
CODE:
size_t len;
char *contents = CFCUtil_slurp_text(path, &len);
RETVAL = newSVpvn(contents, len);
FREEMEM(contents);
OUTPUT: RETVAL
int
current(orig, dest)
const char *orig;
const char *dest;
CODE:
RETVAL = CFCUtil_current(orig, dest);
OUTPUT: RETVAL
void
write_if_changed(path, content_sv)
const char *path;
SV *content_sv;
PPCODE:
STRLEN len;
char *content = SvPV(content_sv, len);
CFCUtil_write_if_changed(path, content, len);
int
is_dir(path)
const char *path;
CODE:
RETVAL = CFCUtil_is_dir(path);
OUTPUT: RETVAL
int
make_dir(dir)
const char *dir;
CODE:
RETVAL = CFCUtil_make_dir(dir);
OUTPUT: RETVAL
int
make_path(path)
const char *path;
CODE:
RETVAL = CFCUtil_make_path(path);
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Variable
SV*
_new(exposure, name_sv, type_sv, inert_sv)
const char *exposure;
SV *name_sv;
SV *type_sv;
SV *inert_sv;
CODE:
const char *name = SvOK(name_sv)
? SvPV_nolen(name_sv)
: NULL;
int inert = SvOK(inert_sv)
? !!SvTRUE(inert_sv) : 0;
CFCType *type = NULL;
if (SvOK(type_sv) && sv_derived_from(type_sv, "Clownfish::CFC::Model::Type")) {
IV objint = SvIV((SV*)SvRV(type_sv));
type = INT2PTR(CFCType*, objint);
}
else {
croak("Param 'type' is not a Clownfish::CFC::Model::Type");
}
CFCVariable *self = CFCVariable_new(exposure, name, type, inert);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
int
equals(self, other)
CFCVariable *self;
CFCVariable *other;
CODE:
RETVAL = CFCVariable_equals(self, other);
OUTPUT: RETVAL
void
resolve_type(self)
CFCVariable *self;
PPCODE:
CFCVariable_resolve_type(self);
SV*
global_c(self, klass)
CFCVariable *self;
CFCClass *klass;
CODE:
char *global_c = CFCVariable_global_c(self, klass);
RETVAL = S_sv_eat_c_string(global_c);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCVariable *self;
ALIAS:
get_type = 2
local_c = 4
local_declaration = 8
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
CFCType *type = CFCVariable_get_type(self);
retval = S_cfcbase_to_perlref(type);
}
break;
case 4: {
const char *local_c = CFCVariable_local_c(self);
retval = newSVpvn(local_c, strlen(local_c));
}
break;
case 8: {
const char *local_dec = CFCVariable_local_declaration(self);
retval = newSVpvn(local_dec, strlen(local_dec));
}
break;
END_SET_OR_GET_SWITCH
}
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::Version
SV*
_new(vstring)
const char *vstring;
CODE:
CFCVersion *self = CFCVersion_new(vstring);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCVersion *self;
ALIAS:
get_major = 2
get_vstring = 4
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2:
retval = newSVuv(CFCVersion_get_major(self));
break;
case 4: {
const char *value = CFCVersion_get_vstring(self);
retval = newSVpvn(value, strlen(value));
}
break;
END_SET_OR_GET_SWITCH
}
int
compare_to(self, other)
CFCVersion *self;
CFCVersion *other;
CODE:
RETVAL = CFCVersion_compare_to(self, other);
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core
SV*
_new(hierarchy, header, footer)
CFCHierarchy *hierarchy;
const char *header;
const char *footer;
CODE:
CFCBindCore *self = CFCBindCore_new(hierarchy, header, footer);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
int
write_all_modified(self, ...)
CFCBindCore *self;
CODE:
{
int modified = 0;
if (items > 1 && SvOK(ST(1))) {
modified = !!SvIV(ST(1));
}
RETVAL = CFCBindCore_write_all_modified(self, modified);
}
OUTPUT: RETVAL
void
copy_headers(self, dest_dir)
CFCBindCore *self;
const char *dest_dir;
PPCODE:
CFCBindCore_copy_headers(self, dest_dir);
void
write_host_data_json(self, dest_dir)
CFCBindCore *self;
const char *dest_dir;
PPCODE:
CFCBindCore_write_host_data_json(self, dest_dir, "perl");
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core::Function
SV*
func_declaration(unused, func, klass)
SV *unused;
CFCFunction *func;
CFCClass *klass;
CODE:
CHY_UNUSED_VAR(unused);
RETVAL = S_sv_eat_c_string(CFCBindFunc_func_declaration(func, klass));
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core::Method
SV*
abstract_method_def(unused, meth, klass)
SV *unused;
CFCMethod *meth;
CFCClass *klass;
CODE:
CHY_UNUSED_VAR(unused);
RETVAL = S_sv_eat_c_string(CFCBindMeth_abstract_method_def(meth, klass));
OUTPUT: RETVAL
SV*
_method_def(meth, klass)
CFCMethod *meth;
CFCClass *klass;
CODE:
RETVAL = S_sv_eat_c_string(CFCBindMeth_method_def(meth, klass));
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core::Aliases
SV*
c_aliases(...)
CODE:
CHY_UNUSED_VAR(items);
RETVAL = S_sv_eat_c_string(CFCBindAliases_c_aliases());
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core::Class
SV*
_new(client)
CFCClass *client;
CODE:
CFCBindClass *self = CFCBindClass_new(client);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
to_c_data(self)
CFCBindClass *self;
CODE:
RETVAL = S_sv_eat_c_string(CFCBindClass_to_c_data(self));
OUTPUT: RETVAL
SV*
to_c_header(self)
CFCBindClass *self;
CODE:
RETVAL = S_sv_eat_c_string(CFCBindClass_to_c_header(self));
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core::File
void
_write_h(file, dest, header, footer)
CFCFile *file;
const char *dest;
const char *header;
const char *footer;
PPCODE:
CFCBindFile_write_h(file, dest, header, footer);
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl
SV*
_new(hierarchy, lib_dir, header, footer)
CFCHierarchy *hierarchy;
const char *lib_dir;
const char *header;
const char *footer;
CODE:
CFCPerl *self = CFCPerl_new(hierarchy, lib_dir, header, footer);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
write_pod(self)
CFCPerl *self;
CODE:
char **written = CFCPerl_write_pod(self);
AV *modified = newAV();
for (size_t i = 0; written[i] != NULL; i++) {
SV *path = S_sv_eat_c_string(written[i]);
av_push(modified, path);
}
FREEMEM(written);
RETVAL = newRV_noinc((SV*)modified);
OUTPUT: RETVAL
void
write_host_code(self)
CFCPerl *self;
PPCODE:
CFCPerl_write_host_code(self);
void
write_hostdefs(self)
CFCPerl *self;
PPCODE:
CFCPerl_write_hostdefs(self);
void
_write_bindings(self, boot_class, sv)
CFCPerl *self;
const char *boot_class;
SV *sv;
PPCODE:
CFCParcel **parcels = (CFCParcel**)
S_av_to_array_of_cfcbase(sv, "Clownfish::CFC::Model::Parcel");
CFCPerl_write_bindings(self, boot_class, parcels);
FREEMEM(parcels);
void
write_xs_typemap(self)
CFCPerl *self;
PPCODE:
CFCPerl_write_xs_typemap(self);
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::Subroutine
void
_set_or_get(self, ...)
CFCPerlSub *self;
ALIAS:
get_class_name = 2
use_labeled_params = 4
perl_name = 6
get_param_list = 8
c_name = 10
c_name_list = 12
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCPerlSub_get_class_name(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 4:
retval = newSViv(CFCPerlSub_use_labeled_params(self));
break;
case 6: {
const char *value = CFCPerlSub_perl_name(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 8: {
CFCParamList *value = CFCPerlSub_get_param_list(self);
retval = S_cfcbase_to_perlref(value);
}
break;
case 10: {
const char *value = CFCPerlSub_c_name(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 12: {
const char *value = CFCPerlSub_c_name_list(self);
retval = newSVpvn(value, strlen(value));
}
break;
END_SET_OR_GET_SWITCH
}
SV*
build_param_specs(self, first)
CFCPerlSub *self;
int first;
CODE:
RETVAL = S_sv_eat_c_string(CFCPerlSub_build_param_specs(self, first));
OUTPUT: RETVAL
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::Method
SV*
_new(klass, method)
CFCClass *klass
CFCMethod *method;
CODE:
CFCPerlMethod *self = CFCPerlMethod_new(klass, method);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
xsub_def(self, klass)
CFCPerlMethod *self;
CFCClass *klass;
CODE:
RETVAL = S_sv_eat_c_string(CFCPerlMethod_xsub_def(self, klass));
OUTPUT: RETVAL
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::Constructor
SV*
_new(klass, alias, init_sv)
CFCClass *klass;
const char *alias;
SV *init_sv;
CODE:
const char *init = SvOK(init_sv) ? SvPVutf8_nolen(init_sv) : NULL;
CFCPerlConstructor *self = CFCPerlConstructor_new(klass, alias, init);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
xsub_def(self, klass)
CFCPerlConstructor *self;
CFCClass *klass;
CODE:
RETVAL = S_sv_eat_c_string(CFCPerlConstructor_xsub_def(self, klass));
OUTPUT: RETVAL
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::Class
SV*
_new(parcel, class_name)
CFCParcel *parcel;
const char *class_name;
CODE:
CFCPerlClass *self = CFCPerlClass_new(parcel, class_name);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
register(unused, binding)
SV *unused;
CFCPerlClass *binding;
PPCODE:
CHY_UNUSED_VAR(unused);
CFCPerlClass_add_to_registry(binding);
SV*
singleton(unused_sv, class_name)
SV *unused_sv;
const char *class_name;
CODE:
CHY_UNUSED_VAR(unused_sv);
CFCPerlClass *binding = CFCPerlClass_singleton(class_name);
RETVAL = S_cfcbase_to_perlref(binding);
OUTPUT: RETVAL
SV*
registered(...)
CODE:
CHY_UNUSED_VAR(items);
CFCPerlClass **registry = CFCPerlClass_registry();
RETVAL = S_array_of_cfcbase_to_av((CFCBase**)registry);
OUTPUT: RETVAL
void
_clear_registry(...)
PPCODE:
CHY_UNUSED_VAR(items);
CFCPerlClass_clear_registry();
void
_bind_method(self, alias_sv, meth_sv)
CFCPerlClass *self;
SV *alias_sv;
SV *meth_sv;
PPCODE:
const char *alias = SvOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
const char *meth = SvOK(meth_sv) ? SvPVutf8_nolen(meth_sv) : NULL;
CFCPerlClass_bind_method(self, alias, meth);
void
_bind_constructor(self, alias_sv, init_sv)
CFCPerlClass *self;
SV *alias_sv;
SV *init_sv;
PPCODE:
const char *alias = SvOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
const char *init = SvOK(init_sv) ? SvPVutf8_nolen(init_sv) : NULL;
CFCPerlClass_bind_constructor(self, alias, init);
void
exclude_method(self, method)
CFCPerlClass *self;
const char *method;
PPCODE:
CFCPerlClass_exclude_method(self, method);
void
exclude_constructor(self)
CFCPerlClass *self;
PPCODE:
CFCPerlClass_exclude_constructor(self);
void
append_xs(self, xs)
CFCPerlClass *self;
const char *xs;
PPCODE:
CFCPerlClass_append_xs(self, xs);
SV*
method_bindings(unused, klass)
SV *unused;
CFCClass *klass;
CODE:
CHY_UNUSED_VAR(unused);
CFCPerlMethod **bound = CFCPerlClass_method_bindings(klass);
RETVAL = S_array_of_cfcbase_to_av((CFCBase**)bound);
FREEMEM(bound);
OUTPUT: RETVAL
SV*
constructor_bindings(unused, klass)
SV *unused;
CFCClass *klass;
CODE:
CHY_UNUSED_VAR(unused);
CFCPerlConstructor **bound = CFCPerlClass_constructor_bindings(klass);
RETVAL = S_array_of_cfcbase_to_av((CFCBase**)bound);
FREEMEM(bound);
OUTPUT: RETVAL
SV*
create_pod(self)
CFCPerlClass *self;
CODE:
char *pod = CFCPerlClass_create_pod(self);
RETVAL = S_sv_eat_c_string(pod);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCPerlClass *self;
ALIAS:
get_class_name = 2
get_client = 4
get_xs_code = 6
set_pod_spec = 7
get_pod_spec = 8
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCPerlClass_get_class_name(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 4: {
CFCClass *value = CFCPerlClass_get_client(self);
retval = S_cfcbase_to_perlref(value);
}
break;
case 6: {
const char *value = CFCPerlClass_get_xs_code(self);
retval = value
? newSVpvn(value, strlen(value))
: newSV(0);
}
break;
case 7: {
CFCPerlPod *pod_spec = NULL;
if (SvOK(ST(1))
&& sv_derived_from(ST(1), "Clownfish::CFC::Binding::Perl::Pod")
) {
IV objint = SvIV((SV*)SvRV(ST(1)));
pod_spec = INT2PTR(CFCPerlPod*, objint);
}
CFCPerlClass_set_pod_spec(self, pod_spec);
break;
}
case 8: {
CFCPerlPod *value = CFCPerlClass_get_pod_spec(self);
retval = S_cfcbase_to_perlref(value);
}
break;
END_SET_OR_GET_SWITCH
}
void
add_class_alias(self, alias)
CFCPerlClass *self;
const char *alias;
PPCODE:
CFCPerlClass_add_class_alias(self, alias);
SV*
get_class_aliases(self)
CFCPerlClass *self;
CODE:
const char **aliases = CFCPerlClass_get_class_aliases(self);
RETVAL = S_string_array_to_av(aliases);
OUTPUT: RETVAL
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::Pod
SV*
new(unused)
SV *unused;
CODE:
CHY_UNUSED_VAR(unused);
CFCPerlPod *self = CFCPerlPod_new();
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
void
_add_method(self, alias, method_sv, sample_sv, pod_sv)
CFCPerlPod *self;
const char *alias;
SV *method_sv;
SV *sample_sv;
SV *pod_sv;
PPCODE:
const char *method = SvPOK(method_sv) ? SvPVutf8_nolen(method_sv) : NULL;
const char *sample = SvPOK(sample_sv) ? SvPVutf8_nolen(sample_sv) : NULL;
const char *pod = SvPOK(pod_sv) ? SvPVutf8_nolen(pod_sv) : NULL;
CFCPerlPod_add_method(self, alias, method, sample, pod);
void
_add_constructor(self, alias_sv, func_sv, sample_sv, pod_sv)
CFCPerlPod *self;
SV *alias_sv;
SV *func_sv;
SV *sample_sv;
SV *pod_sv;
PPCODE:
const char *alias = SvPOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
const char *func = SvPOK(func_sv) ? SvPVutf8_nolen(func_sv) : NULL;
const char *sample = SvPOK(sample_sv) ? SvPVutf8_nolen(sample_sv) : NULL;
const char *pod = SvPOK(pod_sv) ? SvPVutf8_nolen(pod_sv) : NULL;
CFCPerlPod_add_constructor(self, alias, func, sample, pod);
SV*
methods_pod(self, klass)
CFCPerlPod *self;
CFCClass *klass;
CODE:
char *methods_pod = CFCPerlPod_methods_pod(self, klass);
RETVAL = S_sv_eat_c_string(methods_pod);
OUTPUT: RETVAL
SV*
constructors_pod(self, klass)
CFCPerlPod *self;
CFCClass *klass;
CODE:
char *constructors_pod = CFCPerlPod_constructors_pod(self, klass);
RETVAL = S_sv_eat_c_string(constructors_pod);
OUTPUT: RETVAL
void
_set_or_get(self, ...)
CFCPerlPod *self;
ALIAS:
set_synopsis = 1
get_synopsis = 2
set_description = 3
get_description = 4
PPCODE:
{
START_SET_OR_GET_SWITCH
case 1: {
const char *val = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
CFCPerlPod_set_synopsis(self, val);
}
break;
case 2: {
const char *value = CFCPerlPod_get_synopsis(self);
retval = newSVpvn(value, strlen(value));
}
break;
case 3: {
const char *val = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
CFCPerlPod_set_description(self, val);
}
break;
case 4: {
const char *value = CFCPerlPod_get_description(self);
retval = newSVpvn(value, strlen(value));
}
break;
END_SET_OR_GET_SWITCH
}
SV*
_md_to_pod(source, klass, header_level)
CFCClass *klass;
const char *source;
int header_level;
CODE:
RETVAL = S_sv_eat_c_string(CFCPerlPod_md_to_pod(source, klass,
header_level));
OUTPUT: RETVAL
SV*
_gen_subroutine_pod(func, alias, klass, code_sample, class_name, is_constructor)
CFCCallable *func;
const char *alias;
CFCClass *klass;
const char *code_sample;
const char *class_name;
int is_constructor;
CODE:
char *value = CFCPerlPod_gen_subroutine_pod(func, alias, klass,
code_sample, class_name,
is_constructor);
RETVAL = S_sv_eat_c_string(value);
OUTPUT: RETVAL
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::TypeMap
SV*
from_perl(type, xs_var, label)
CFCType *type;
const char *xs_var;
const char *label;
CODE:
RETVAL = S_sv_eat_c_string(CFCPerlTypeMap_from_perl(type, xs_var, label));
OUTPUT: RETVAL
SV*
to_perl(type, cf_var)
CFCType *type;
const char *cf_var;
CODE:
RETVAL = S_sv_eat_c_string(CFCPerlTypeMap_to_perl(type, cf_var));
OUTPUT: RETVAL
void
_write_xs_typemap(hierarchy)
CFCHierarchy *hierarchy;
PPCODE:
CFCPerlTypeMap_write_xs_typemap(hierarchy);
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Parser
SV*
new(klass)
const char *klass;
CODE:
if (strcmp(klass, "Clownfish::CFC::Parser")) {
croak("No subclassing allowed");
}
CFCParser *self = CFCParser_new();
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
SV*
parse(self, string)
CFCParser *self;
const char *string;
CODE:
CFCBase *got = CFCParser_parse(self, string);
RETVAL = S_cfcbase_to_perlref(got);
CFCBase_decref((CFCBase*)got);
OUTPUT: RETVAL
SV*
_parse_file(self, string, file_spec)
CFCParser *self;
const char *string;
CFCFileSpec *file_spec;
CODE:
CFCFile *got = CFCParser_parse_file(self, string, file_spec);
RETVAL = S_cfcbase_to_perlref(got);
CFCBase_decref((CFCBase*)got);
OUTPUT: RETVAL
void
set_parcel(self, parcel)
CFCParser *self;
CFCParcel *parcel;
PPCODE:
CFCParser_set_parcel(self, parcel);
void
set_class_name(self, class_name)
CFCParser *self;
const char *class_name;
PPCODE:
CFCParser_set_class_name(self, class_name);
SV*
get_parcel(self)
CFCParser *self;
CODE:
CFCParcel *parcel = CFCParser_get_parcel(self);
RETVAL = S_cfcbase_to_perlref((CFCBase*)parcel);
OUTPUT: RETVAL
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Test
SV*
_new(formatter_name)
const char *formatter_name;
CODE:
CFCTest *self = CFCTest_new(formatter_name);
RETVAL = S_cfcbase_to_perlref(self);
CFCBase_decref((CFCBase*)self);
OUTPUT: RETVAL
int
run_batch(self, klass, test_files_dir = NULL)
CFCTest *self;
const char *klass;
const char *test_files_dir;
CODE:
RETVAL = CFCTest_run_batch(self, klass, test_files_dir);
OUTPUT: RETVAL