static char*
S_gen_positional_sample(const char *prologue, CFCParamList *param_list,
int start) {
int num_vars = CFCParamList_num_vars(param_list);
CFCVariable **vars = CFCParamList_get_variables(param_list);
const char **inits = CFCParamList_get_initial_values(param_list);
if (num_vars - start != 1) {
CFCUtil_die("Code samples with multiple positional parameters"
" are not supported yet.");
}
const char *name = CFCVariable_get_name(vars[start]);
char *sample = CFCUtil_sprintf(" %s($%s);\n", prologue, name);
const char *init = inits[start];
if (init) {
if (strcmp(init, "NULL") == 0) { init = "undef"; }
char *def_sample = CFCUtil_sprintf(" %s(); # default: %s\n",
prologue, init);
sample = CFCUtil_cat(sample, def_sample, NULL);
FREEMEM(def_sample);
}
return sample;
}
static char*
S_callback_refcount_mods(CFCParamList *param_list) {
char *refcount_mods = CFCUtil_strdup("");
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
// Adjust refcounts of arguments per method signature, so that Perl code
// does not have to.
for (int i = 0; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
CFCType *type = CFCVariable_get_type(var);
const char *name = CFCVariable_get_name(var);
if (!CFCType_is_object(type)) {
continue;
}
else if (CFCType_incremented(type)) {
refcount_mods = CFCUtil_cat(refcount_mods, " CFISH_INCREF(",
name, ");\n", NULL);
}
else if (CFCType_decremented(type)) {
refcount_mods = CFCUtil_cat(refcount_mods, " CFISH_DECREF(",
name, ");\n", NULL);
}
}
return refcount_mods;
}
static char*
S_invalid_callback_def(CFCMethod *method) {
char *full_method_sym = CFCMethod_full_method_sym(method, NULL);
const char *override_sym = CFCMethod_full_override_sym(method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *params = CFCParamList_to_c(param_list);
CFCVariable **param_vars = CFCParamList_get_variables(param_list);
// Thwart compiler warnings.
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
char *unused = S_build_unused_vars(param_vars);
char *unreachable = S_maybe_unreachable(return_type);
char pattern[] =
"%s\n"
"%s(%s) {%s\n"
" CFISH_THROW(CFISH_ERR, \"Can't override %s via binding\");%s\n"
"}\n";
char *callback_def
= CFCUtil_sprintf(pattern, ret_type_str, override_sym, params, unused,
full_method_sym, unreachable);
FREEMEM(full_method_sym);
FREEMEM(unreachable);
FREEMEM(unused);
return callback_def;
}
char*
CFCBindMeth_abstract_method_def(CFCMethod *method) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *params = CFCParamList_to_c(param_list);
const char *full_func_sym = CFCMethod_imp_func(method);
const char *vtable_var
= CFCType_get_vtable_var(CFCMethod_self_type(method));
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *macro_sym = CFCMethod_get_macro_sym(method);
// Thwart compiler warnings.
CFCVariable **param_vars = CFCParamList_get_variables(param_list);
char *unused = S_build_unused_vars(param_vars + 1);
char *return_statement = S_maybe_unreachable(return_type);
char pattern[] =
"%s\n"
"%s(%s) {\n"
" cfish_String *klass = self ? CFISH_Obj_Get_Class_Name((cfish_Obj*)self) : %s->name;%s\n"
" CFISH_THROW(CFISH_ERR, \"Abstract method '%s' not defined by %%o\", klass);%s\n"
"}\n";
char *abstract_def
= CFCUtil_sprintf(pattern, ret_type_str, full_func_sym, params,
vtable_var, unused, macro_sym, return_statement);
FREEMEM(unused);
FREEMEM(return_statement);
return abstract_def;
}
char*
CFCPerlConstructor_xsub_def(CFCPerlConstructor *self) {
const char *c_name = self->sub.c_name;
CFCParamList *param_list = self->sub.param_list;
const char *name_list = CFCParamList_name_list(param_list);
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
const char *func_sym = CFCFunction_full_func_sym(self->init_func);
char *allot_params = CFCPerlSub_build_allot_params((CFCPerlSub*)self);
CFCVariable *self_var = arg_vars[0];
CFCType *self_type = CFCVariable_get_type(self_var);
const char *self_type_str = CFCType_to_c(self_type);
// Compensate for swallowed refcounts.
char *refcount_mods = CFCUtil_strdup("");
for (size_t i = 0; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
CFCType *type = CFCVariable_get_type(var);
if (CFCType_is_object(type) && CFCType_decremented(type)) {
const char *name = CFCVariable_micro_sym(var);
refcount_mods = CFCUtil_cat(refcount_mods, "\n CFISH_INCREF(",
name, ");", NULL);
}
}
const char pattern[] =
"XS(%s);\n"
"XS(%s) {\n"
" dXSARGS;\n"
" CFISH_UNUSED_VAR(cv);\n"
" if (items < 1) { CFISH_THROW(CFISH_ERR, \"Usage: %%s(class_name, ...)\", GvNAME(CvGV(cv))); }\n"
" SP -= items;\n"
"\n"
" %s\n"
// Create "self" last, so that earlier exceptions while fetching
// params don't trigger a bad invocation of DESTROY.
" %s self = (%s)XSBind_new_blank_obj(ST(0));%s\n"
"\n"
" %s retval = %s(%s);\n"
" if (retval) {\n"
" ST(0) = (SV*)CFISH_Obj_To_Host((cfish_Obj*)retval);\n"
" CFISH_Obj_Dec_RefCount((cfish_Obj*)retval);\n"
" }\n"
" else {\n"
" ST(0) = newSV(0);\n"
" }\n"
" sv_2mortal(ST(0));\n"
" XSRETURN(1);\n"
"}\n\n";
char *xsub_def
= CFCUtil_sprintf(pattern, c_name, c_name, allot_params, self_type_str,
self_type_str, refcount_mods, self_type_str,
func_sym, name_list);
FREEMEM(refcount_mods);
FREEMEM(allot_params);
return xsub_def;
}
int
CFCMethod_compatible(CFCMethod *self, CFCMethod *other) {
if (!other) { return false; }
if (strcmp(self->macro_sym, other->macro_sym)) { return false; }
int my_public = CFCMethod_public(self);
int other_public = CFCMethod_public(other);
if (!!my_public != !!other_public) { return false; }
// Check arguments and initial values.
CFCParamList *my_param_list = self->function.param_list;
CFCParamList *other_param_list = other->function.param_list;
CFCVariable **my_args = CFCParamList_get_variables(my_param_list);
CFCVariable **other_args = CFCParamList_get_variables(other_param_list);
const char **my_vals = CFCParamList_get_initial_values(my_param_list);
const char **other_vals = CFCParamList_get_initial_values(other_param_list);
for (size_t i = 1; ; i++) { // start at 1, skipping self
if (!!my_args[i] != !!other_args[i]) { return false; }
if (!!my_vals[i] != !!other_vals[i]) { return false; }
if (my_vals[i]) {
if (strcmp(my_vals[i], other_vals[i])) { return false; }
}
if (my_args[i]) {
if (!CFCVariable_equals(my_args[i], other_args[i])) {
return false;
}
}
else {
break;
}
}
// Check return types.
CFCType *type = CFCMethod_get_return_type(self);
CFCType *other_type = CFCMethod_get_return_type(other);
if (CFCType_is_object(type)) {
// Weak validation to allow covariant object return types.
if (!CFCType_is_object(other_type)) { return false; }
if (!CFCType_similar(type, other_type)) { return false; }
}
else {
if (!CFCType_equals(type, other_type)) { return false; }
}
return true;
}
CFCMethod*
CFCMethod_init(CFCMethod *self, CFCParcel *parcel, const char *exposure,
const char *class_name, const char *class_cnick,
const char *macro_sym, CFCType *return_type,
CFCParamList *param_list, CFCDocuComment *docucomment,
int is_final, int is_abstract) {
// Validate macro_sym, derive micro_sym.
if (!S_validate_macro_sym(macro_sym)) {
CFCBase_decref((CFCBase*)self);
CFCUtil_die("Invalid macro_sym: '%s'",
macro_sym ? macro_sym : "[NULL]");
}
char *micro_sym = CFCUtil_strdup(macro_sym);
for (size_t i = 0; micro_sym[i] != '\0'; i++) {
micro_sym[i] = tolower(micro_sym[i]);
}
// Super-init and clean up derived micro_sym.
CFCFunction_init((CFCFunction*)self, parcel, exposure, class_name,
class_cnick, micro_sym, return_type, param_list,
docucomment, false);
FREEMEM(micro_sym);
// Verify that the first element in the arg list is a self.
CFCVariable **args = CFCParamList_get_variables(param_list);
if (!args[0]) { CFCUtil_die("Missing 'self' argument"); }
CFCType *type = CFCVariable_get_type(args[0]);
const char *specifier = CFCType_get_specifier(type);
const char *prefix = CFCMethod_get_prefix(self);
const char *last_colon = strrchr(class_name, ':');
const char *struct_sym = last_colon ? last_colon + 1 : class_name;
if (strcmp(specifier, struct_sym) != 0) {
char *wanted = CFCUtil_sprintf("%s%s", prefix, struct_sym);
int mismatch = strcmp(wanted, specifier);
FREEMEM(wanted);
if (mismatch) {
CFCUtil_die("First arg type doesn't match class: '%s' '%s'",
class_name, specifier);
}
}
self->macro_sym = CFCUtil_strdup(macro_sym);
self->full_override_sym = NULL;
self->host_alias = NULL;
self->is_final = is_final;
self->is_abstract = is_abstract;
self->is_excluded = false;
// Assume that this method is novel until we discover when applying
// inheritance that it overrides another.
self->is_novel = true;
return self;
}
static char*
S_gen_decs(CFCParamList *param_list, int first_tick) {
char *decs = CFCUtil_strdup("");
int num_vars = CFCParamList_num_vars(param_list);
CFCVariable **vars = CFCParamList_get_variables(param_list);
for (int i = first_tick; i < num_vars; i++) {
CFCType *type = CFCVariable_get_type(vars[i]);
const char *name = CFCVariable_get_name(vars[i]);
decs = CFCUtil_cat(decs, " ", CFCType_to_c(type), " ", name,
"_ARG = 0;\n", NULL);
}
return decs;
}
char*
CFCBindMeth_abstract_method_def(CFCMethod *method, CFCClass *klass) {
CFCType *ret_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(ret_type);
CFCType *type = CFCMethod_self_type(method);
const char *class_var = CFCType_get_class_var(type);
const char *meth_name = CFCMethod_get_name(method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *params = CFCParamList_to_c(param_list);
CFCVariable **vars = CFCParamList_get_variables(param_list);
const char *invocant = CFCVariable_get_name(vars[0]);
// All variables other than the invocant are unused, and the return is
// unreachable.
char *unused = CFCUtil_strdup("");
for (int i = 1; vars[i] != NULL; i++) {
const char *var_name = CFCVariable_get_name(vars[i]);
size_t size = strlen(unused) + strlen(var_name) + 80;
unused = (char*)REALLOCATE(unused, size);
strcat(unused, "\n CFISH_UNUSED_VAR(");
strcat(unused, var_name);
strcat(unused, ");");
}
char *unreachable;
if (!CFCType_is_void(ret_type)) {
unreachable = CFCUtil_sprintf(" CFISH_UNREACHABLE_RETURN(%s);\n",
ret_type_str);
}
else {
unreachable = CFCUtil_strdup("");
}
char *full_func_sym = CFCMethod_imp_func(method, klass);
char pattern[] =
"%s\n"
"%s(%s) {\n"
"%s"
" cfish_Err_abstract_method_call((cfish_Obj*)%s, %s, \"%s\");\n"
"%s"
"}\n";
char *abstract_def
= CFCUtil_sprintf(pattern, ret_type_str, full_func_sym, params,
unused, invocant, class_var, meth_name,
unreachable);
FREEMEM(unused);
FREEMEM(unreachable);
FREEMEM(full_func_sym);
return abstract_def;
}
void
CFCGoTypeMap_go_meth_receiever(const char *struct_name,
CFCParamList *param_list,
char *buf, size_t buf_len) {
size_t max_required = 2;
if (param_list != NULL && CFCParamList_num_vars(param_list) > 0) {
CFCVariable **vars = CFCParamList_get_variables(param_list);
const char *orig = CFCVariable_get_name(vars[0]);
max_required = strlen(orig) + 1;
}
if (buf_len < max_required) {
CFCUtil_die("Buffer length too short: %d", buf_len);
}
// Find the first letter of the type and lowercase it.
for (size_t i = 0, max = strlen(struct_name); i < max; i++) {
if (isupper(struct_name[i])) {
buf[0] = tolower(struct_name[i]);
buf[1] = '\0';
break;
}
}
// Check for another argument with the same name.
if (param_list != NULL) {
CFCVariable **vars = CFCParamList_get_variables(param_list);
size_t num_vars = CFCParamList_num_vars(param_list);
for (size_t i = 1; i < num_vars; i++) {
const char *name = CFCVariable_get_name(vars[i]);
if (strcmp(name, buf) == 0) {
// Bah, a clash. Use the original name, even though it's
// probably "self" which isn't good Go style.
CFCGoTypeMap_go_arg_name(param_list, 0, buf, buf_len);
break;
}
}
}
}
char*
CFCPyMethod_callback_def(CFCMethod *method, CFCClass *invoker) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
CFCVariable **vars = CFCParamList_get_variables(param_list);
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *params = CFCParamList_to_c(param_list);
char *override_sym = CFCMethod_full_override_sym(method, invoker);
char *content;
if (CFCMethod_can_be_bound(method)) {
char *py_args = S_build_py_args(param_list);
char *invocation = S_build_pymeth_invocation(method);
char *refcount_mods = S_callback_refcount_mods(param_list);
const char *maybe_return = CFCType_is_void(return_type)
? ""
: " return cfcb_RESULT;\n";
const char pattern[] =
"%s\n"
"%s(%s) {\n"
"%s\n"
"%s\n"
"%s"
"%s"
"}\n";
content = CFCUtil_sprintf(pattern, ret_type_str, override_sym, params,
py_args, invocation, refcount_mods,
maybe_return);
}
else {
char *unused = S_build_unused_vars(vars);
char *unreachable = S_maybe_unreachable(return_type);
char *meth_sym = CFCMethod_full_method_sym(method, invoker);
const char pattern[] =
"%s\n"
"%s(%s) {%s\n"
" CFISH_THROW(CFISH_ERR, \"Can't override %s via binding\");%s\n"
"}\n";
content = CFCUtil_sprintf(pattern, ret_type_str, override_sym,
params, unused, meth_sym, unreachable);
FREEMEM(meth_sym);
FREEMEM(unused);
FREEMEM(unreachable);
}
FREEMEM(override_sym);
return content;
}
static char*
S_gen_labeled_sample(const char *prologue, CFCParamList *param_list,
int start) {
int num_vars = CFCParamList_num_vars(param_list);
CFCVariable **vars = CFCParamList_get_variables(param_list);
const char **inits = CFCParamList_get_initial_values(param_list);
size_t max_name_len = 0;
// Find maximum length of parameter name.
for (int i = start; i < num_vars; i++) {
const char *name = CFCVariable_get_name(vars[i]);
size_t name_len = strlen(name);
if (name_len > max_name_len) { max_name_len = name_len; }
}
char *params = CFCUtil_strdup("");
for (int i = start; i < num_vars; i++) {
const char *name = CFCVariable_get_name(vars[i]);
const char *init = inits[i];
char *comment = NULL;
if (init) {
if (strcmp(init, "NULL") == 0) { init = "undef"; }
comment = CFCUtil_sprintf("default: %s", init);
}
else {
comment = CFCUtil_strdup("required");
}
char *line = CFCUtil_sprintf(" %-*s => $%-*s # %s\n",
(int)max_name_len, name,
(int)max_name_len, name,
comment);
params = CFCUtil_cat(params, line, NULL);
FREEMEM(line);
FREEMEM(comment);
}
const char pattern[] =
" %s(\n"
"%s"
" );\n";
char *sample = CFCUtil_sprintf(pattern, prologue, params);
FREEMEM(params);
return sample;
}
char*
CFCPerlSub_arg_name_list(CFCPerlSub *self) {
CFCParamList *param_list = self->param_list;
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
size_t num_vars = CFCParamList_num_vars(param_list);
char *name_list = CFCUtil_strdup("arg_self");
for (int i = 1; i < num_vars; i++) {
CFCVariable *arg_var = arg_vars[i];
const char *var_name = CFCVariable_micro_sym(arg_vars[i]);
name_list = CFCUtil_cat(name_list, ", arg_", var_name, NULL);
}
return name_list;
}
char*
CFCPerlSub_build_allot_params(CFCPerlSub *self) {
CFCParamList *param_list = self->param_list;
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
const char **arg_inits = CFCParamList_get_initial_values(param_list);
size_t num_vars = CFCParamList_num_vars(param_list);
char *allot_params = CFCUtil_strdup("");
// Declare variables and assign default values.
for (size_t i = 1; i < num_vars; i++) {
CFCVariable *arg_var = arg_vars[i];
const char *val = arg_inits[i];
const char *var_name = CFCVariable_micro_sym(arg_var);
if (val == NULL) {
CFCType *arg_type = CFCVariable_get_type(arg_var);
val = CFCType_is_object(arg_type)
? "NULL"
: "0";
}
allot_params = CFCUtil_cat(allot_params, "arg_", var_name, " = ", val,
";\n ", NULL);
}
// Iterate over args in param list.
allot_params
= CFCUtil_cat(allot_params,
"args_ok = XSBind_allot_params(\n"
" &(ST(0)), 1, items,\n", NULL);
for (size_t i = 1; i < num_vars; i++) {
CFCVariable *var = arg_vars[i];
const char *val = arg_inits[i];
int required = val ? 0 : 1;
const char *name = CFCVariable_micro_sym(var);
CFCType *type = CFCVariable_get_type(var);
char *arg = S_allot_params_arg(type, name, required);
allot_params
= CFCUtil_cat(allot_params, " ", arg, ",\n", NULL);
FREEMEM(arg);
}
allot_params
= CFCUtil_cat(allot_params, " NULL);\n",
" if (!args_ok) {\n"
" CFISH_RETHROW(CFISH_INCREF(cfish_Err_get_error()));\n"
" }", NULL);
return allot_params;
}
void
CFCGoTypeMap_go_arg_name(CFCParamList *param_list, size_t tick, char *buf,
size_t buf_len) {
size_t num_vars = CFCParamList_num_vars(param_list);
if (tick >= num_vars) {
CFCUtil_die("Index out of range: %d >= %d", (int)tick, (int)num_vars);
}
CFCVariable **vars = CFCParamList_get_variables(param_list);
const char *orig = CFCVariable_get_name(vars[tick]);
size_t max_required = strlen(orig) + 2;
if (buf_len < max_required || buf_len < 5) {
CFCUtil_die("Buffer length too short: %d", buf_len);
}
// If the argument name is a Go keyword, append an underscore. This is
// ugly but bulletproof.
for (int i = 0; i < num_go_keywords; i++) {
if (strcmp(orig, go_keywords[i]) == 0) {
sprintf(buf, "%s_", orig);
return;
}
}
// Transform into lowerCamelCase.
size_t dest_tick = 0;
int last_was_underscore = 0;
for (size_t i = 0; i <= strlen(orig); i++) {
if (i > buf_len) {
CFCUtil_die("Name too long for buffer of size %d: '%s'", buf_len,
orig);
}
if (orig[i] == '_') {
last_was_underscore = 1;
continue;
}
else if (last_was_underscore) {
buf[dest_tick] = toupper(orig[i]);
}
else {
buf[dest_tick] = orig[i];
}
last_was_underscore = 0;
dest_tick++;
}
}
static char*
S_build_py_args(CFCParamList *param_list) {
int num_vars = CFCParamList_num_vars(param_list);
CFCVariable **vars = CFCParamList_get_variables(param_list);
char pattern[] = " PyObject *cfcb_ARGS = S_pack_tuple(%d";
char *py_args = CFCUtil_sprintf(pattern, num_vars - 1);
for (int i = 1; vars[i] != NULL; i++) {
const char *var_name = CFCVariable_get_name(vars[i]);
CFCType *type = CFCVariable_get_type(vars[i]);
char *conversion = CFCPyTypeMap_c_to_py(type, var_name);
py_args = CFCUtil_cat(py_args, ",\n ", conversion, NULL);
FREEMEM(conversion);
}
py_args = CFCUtil_cat(py_args, ");", NULL);
return py_args;
}
char*
CFCPerlSub_arg_declarations(CFCPerlSub *self) {
CFCParamList *param_list = self->param_list;
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
size_t num_vars = CFCParamList_num_vars(param_list);
char *decls = CFCUtil_strdup("");
// Declare variables.
for (size_t i = 1; i < num_vars; i++) {
CFCVariable *arg_var = arg_vars[i];
CFCType *type = CFCVariable_get_type(arg_var);
const char *type_str = CFCType_to_c(type);
const char *var_name = CFCVariable_micro_sym(arg_var);
decls = CFCUtil_cat(decls, " ", type_str, " arg_", var_name,
";\n", NULL);
}
return decls;
}
static char*
S_gen_arg_list(CFCParamList *param_list, const char *first_arg) {
CFCVariable **vars = CFCParamList_get_variables(param_list);
int num_vars = CFCParamList_num_vars(param_list);
char *arg_list = CFCUtil_strdup("");
for (int i = 0; i < num_vars; i++) {
if (i > 0) {
arg_list = CFCUtil_cat(arg_list, ", ", NULL);
}
if (i == 0 && first_arg != NULL) {
arg_list = CFCUtil_cat(arg_list, first_arg, NULL);
}
else {
arg_list = CFCUtil_cat(arg_list, CFCVariable_get_name(vars[i]),
"_ARG", NULL);
}
}
return arg_list;
}
static char*
S_gen_arg_increfs(CFCParamList *param_list, int first_tick) {
CFCVariable **vars = CFCParamList_get_variables(param_list);
int num_vars = CFCParamList_num_vars(param_list);
char *content = CFCUtil_strdup("");
for (int i = first_tick;i < num_vars; i++) {
CFCType *type = CFCVariable_get_type(vars[i]);
if (CFCType_decremented(type)) {
const char *name = CFCVariable_get_name(vars[i]);
const char *specifier = CFCType_get_specifier(type);
char pattern[] =
" %s_ARG = (%s*)CFISH_INCREF(%s_ARG);\n";
char *incref = CFCUtil_sprintf(pattern, name, specifier, name);
content = CFCUtil_cat(content, incref, NULL);
FREEMEM(incref);
}
}
return content;
}
int
CFCCallable_can_be_bound(CFCCallable *self) {
// Test whether parameters can be mapped automatically.
CFCVariable **arg_vars = CFCParamList_get_variables(self->param_list);
for (size_t i = 0; arg_vars[i] != NULL; i++) {
CFCType *type = CFCVariable_get_type(arg_vars[i]);
if (!CFCType_is_object(type) && !CFCType_is_primitive(type)) {
return false;
}
}
// Test whether return type can be mapped automatically.
if (!CFCType_is_void(self->return_type)
&& !CFCType_is_object(self->return_type)
&& !CFCType_is_primitive(self->return_type)
) {
return false;
}
return true;
}
static char*
S_xsub_def_labeled_params(CFCPerlMethod *self) {
const char *c_name = self->sub.c_name;
CFCParamList *param_list = self->sub.param_list;
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
CFCVariable *self_var = arg_vars[0];
CFCType *self_type = CFCVariable_get_type(self_var);
const char *self_micro_sym = CFCVariable_micro_sym(self_var);
const char *micro_sym = CFCMethod_micro_sym(self->method);
char *self_assign = S_self_assign_statement(self, self_type, micro_sym);
char *allot_params = CFCPerlSub_build_allot_params((CFCPerlSub*)self);
char *body = S_xsub_body(self);
char pattern[] =
"XS(%s);\n"
"XS(%s) {\n"
" dXSARGS;\n"
" CHY_UNUSED_VAR(cv);\n"
" if (items < 1) { CFISH_THROW(CFISH_ERR, \"Usage: %%s(%s, ...)\", GvNAME(CvGV(cv))); }\n"
" SP -= items;\n"
"\n"
" /* Extract vars from Perl stack. */\n"
" %s\n"
" %s\n"
"\n"
" /* Execute */\n"
" %s\n"
"}\n";
char *xsub_def
= CFCUtil_sprintf(pattern, c_name, c_name, self_micro_sym,
allot_params, self_assign, body);
FREEMEM(self_assign);
FREEMEM(allot_params);
FREEMEM(body);
return xsub_def;
}
char*
CFCPerlSub_params_hash_def(CFCPerlSub *self) {
if (!self->use_labeled_params) {
return NULL;
}
char *def = CFCUtil_strdup("");
def = CFCUtil_cat(def, "%", self->perl_name, "_PARAMS = (", NULL);
CFCVariable **arg_vars = CFCParamList_get_variables(self->param_list);
const char **vals = CFCParamList_get_initial_values(self->param_list);
// No labeled params means an empty params hash def.
if (!arg_vars[1]) {
def = CFCUtil_cat(def, ");\n", NULL);
return def;
}
for (int i = 1; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
const char *micro_sym = CFCVariable_micro_sym(var);
const char *val = vals[i];
val = val == NULL
? "undef"
: strcmp(val, "NULL") == 0
? "undef"
: strcmp(val, "true") == 0
? "1"
: strcmp(val, "false") == 0
? "0"
: val;
def = CFCUtil_cat(def, "\n ", micro_sym, " => ", val, ",", NULL);
}
def = CFCUtil_cat(def, "\n);\n", NULL);
return def;
}
static char*
S_callback_refcount_mods(CFCMethod *method) {
char *refcount_mods = CFCUtil_strdup("");
CFCType *return_type = CFCMethod_get_return_type(method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
// Host_callback_obj returns an incremented object. If this method does
// not return an incremented object, we must cancel out that refcount.
// (No function can return a decremented object.)
if (CFCType_is_object(return_type) && !CFCType_incremented(return_type)) {
refcount_mods = CFCUtil_cat(refcount_mods,
"\n CFISH_DECREF(retval);", NULL);
}
// The Host_callback_xxx functions have no effect on the refcounts of
// arguments, so we need to adjust them after the fact.
for (int i = 0; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
CFCType *type = CFCVariable_get_type(var);
const char *name = CFCVariable_micro_sym(var);
if (!CFCType_is_object(type)) {
continue;
}
else if (CFCType_incremented(type)) {
refcount_mods = CFCUtil_cat(refcount_mods, "\n CFISH_INCREF(",
name, ");", NULL);
}
else if (CFCType_decremented(type)) {
refcount_mods = CFCUtil_cat(refcount_mods, "\n CFISH_DECREF(",
name, ");", NULL);
}
}
return refcount_mods;
}
// Prep refcount decrement calls to follow the Clownfish subroutine
// invocation.
static char*
S_gen_decrefs(CFCParamList *param_list, int first_tick) {
CFCVariable **vars = CFCParamList_get_variables(param_list);
int num_vars = CFCParamList_num_vars(param_list);
char *decrefs = CFCUtil_strdup("");
for (int i = first_tick; i < num_vars; i++) {
CFCVariable *var = vars[i];
CFCType *type = CFCVariable_get_type(var);
const char *micro_sym = CFCVariable_get_name(var);
const char *specifier = CFCType_get_specifier(type);
if (strcmp(specifier, "cfish_Obj") == 0
|| strcmp(specifier, "cfish_String") == 0
|| strcmp(specifier, "cfish_Vector") == 0
|| strcmp(specifier, "cfish_Hash") == 0
) {
decrefs = CFCUtil_cat(decrefs, " CFISH_DECREF(", micro_sym,
"_ARG);\n", NULL);
}
}
return decrefs;
}
static char*
S_callback_refcount_mods(CFCMethod *method) {
char *refcount_mods = CFCUtil_strdup("");
CFCType *return_type = CFCMethod_get_return_type(method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
// `XSBind_perl_to_cfish()` returns an incremented object. If this method
// does not return an incremented object, we must cancel out that
// refcount. (No function can return a decremented object.)
if (CFCType_is_object(return_type) && !CFCType_incremented(return_type)) {
refcount_mods = CFCUtil_cat(refcount_mods,
"\n CFISH_DECREF(retval);", NULL);
}
// Adjust refcounts of arguments per method signature, so that Perl code
// does not have to.
for (int i = 0; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
CFCType *type = CFCVariable_get_type(var);
const char *name = CFCVariable_micro_sym(var);
if (!CFCType_is_object(type)) {
continue;
}
else if (CFCType_incremented(type)) {
refcount_mods = CFCUtil_cat(refcount_mods, "\n CFISH_INCREF(",
name, ");", NULL);
}
else if (CFCType_decremented(type)) {
refcount_mods = CFCUtil_cat(refcount_mods, "\n CFISH_DECREF(",
name, ");", NULL);
}
}
return refcount_mods;
}
static char*
S_xsub_body(CFCPerlMethod *self) {
CFCMethod *method = self->method;
CFCParamList *param_list = CFCMethod_get_param_list(method);
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
const char *name_list = CFCParamList_name_list(param_list);
char *body = CFCUtil_strdup("");
CFCParcel *parcel = CFCMethod_get_parcel(method);
const char *class_name = CFCMethod_get_class_name(method);
CFCClass *klass = CFCClass_fetch_singleton(parcel, class_name);
if (!klass) {
CFCUtil_die("Can't find a CFCClass for '%s'", class_name);
}
// Extract the method function pointer.
char *full_typedef = CFCMethod_full_typedef(method, klass);
char *full_meth = CFCMethod_full_method_sym(method, klass);
char *method_ptr
= CFCUtil_sprintf("%s method = CFISH_METHOD_PTR(%s, %s);\n ",
full_typedef, CFCClass_full_vtable_var(klass),
full_meth);
body = CFCUtil_cat(body, method_ptr, NULL);
FREEMEM(full_typedef);
FREEMEM(full_meth);
FREEMEM(method_ptr);
// Compensate for functions which eat refcounts.
for (int i = 0; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
CFCType *type = CFCVariable_get_type(var);
if (CFCType_is_object(type) && CFCType_decremented(type)) {
body = CFCUtil_cat(body, "CFISH_INCREF(",
CFCVariable_micro_sym(var), ");\n ", NULL);
}
}
if (CFCType_is_void(CFCMethod_get_return_type(method))) {
// Invoke method in void context.
body = CFCUtil_cat(body, "method(", name_list,
");\n XSRETURN(0);", NULL);
}
else {
// Return a value for method invoked in a scalar context.
CFCType *return_type = CFCMethod_get_return_type(method);
const char *type_str = CFCType_to_c(return_type);
char *assignment = CFCPerlTypeMap_to_perl(return_type, "retval");
if (!assignment) {
CFCUtil_die("Can't find typemap for '%s'", type_str);
}
body = CFCUtil_cat(body, type_str, " retval = method(",
name_list, ");\n ST(0) = ", assignment, ";",
NULL);
if (CFCType_is_object(return_type)
&& CFCType_incremented(return_type)
) {
body = CFCUtil_cat(body, "\n CFISH_DECREF(retval);", NULL);
}
body = CFCUtil_cat(body, "\n sv_2mortal( ST(0) );\n XSRETURN(1);",
NULL);
FREEMEM(assignment);
}
return body;
}
static char*
S_xsub_def_positional_args(CFCPerlMethod *self) {
CFCMethod *method = self->method;
CFCParamList *param_list = CFCMethod_get_param_list(method);
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
const char **arg_inits = CFCParamList_get_initial_values(param_list);
unsigned num_vars = (unsigned)CFCParamList_num_vars(param_list);
char *body = S_xsub_body(self);
// Determine how many args are truly required and build an error check.
unsigned min_required = 0;
for (unsigned i = 0; i < num_vars; i++) {
if (arg_inits[i] == NULL) {
min_required = i + 1;
}
}
char *xs_name_list = num_vars > 0
? CFCUtil_strdup(CFCVariable_micro_sym(arg_vars[0]))
: CFCUtil_strdup("");
for (unsigned i = 1; i < num_vars; i++) {
const char *var_name = CFCVariable_micro_sym(arg_vars[i]);
if (i < min_required) {
xs_name_list = CFCUtil_cat(xs_name_list, ", ", var_name, NULL);
}
else {
xs_name_list = CFCUtil_cat(xs_name_list, ", [", var_name, "]",
NULL);
}
}
const char num_args_pattern[] =
"if (items %s %u) { CFISH_THROW(CFISH_ERR, \"Usage: %%s(%s)\", GvNAME(CvGV(cv))); }";
char *num_args_check;
if (min_required < num_vars) {
num_args_check = CFCUtil_sprintf(num_args_pattern, "<", min_required,
xs_name_list);
}
else {
num_args_check = CFCUtil_sprintf(num_args_pattern, "!=", num_vars,
xs_name_list);
}
// Var assignments.
char *var_assignments = CFCUtil_strdup("");
for (unsigned i = 0; i < num_vars; i++) {
CFCVariable *var = arg_vars[i];
const char *val = arg_inits[i];
const char *var_name = CFCVariable_micro_sym(var);
CFCType *var_type = CFCVariable_get_type(var);
const char *type_c = CFCType_to_c(var_type);
if (i == 0) { // self
const char *meth_micro_sym = CFCMethod_micro_sym(self->method);
char *statement
= S_self_assign_statement(self, var_type, meth_micro_sym);
var_assignments = CFCUtil_cat(var_assignments, statement, NULL);
FREEMEM(statement);
}
else {
char perl_stack_var[30];
sprintf(perl_stack_var, "ST(%u)", i);
char *conversion
= CFCPerlTypeMap_from_perl(var_type, perl_stack_var);
if (!conversion) {
CFCUtil_die("Can't map type '%s'", type_c);
}
if (val) {
char pattern[] =
"\n %s %s = ( items >= %u && XSBind_sv_defined(ST(%u)) )"
" ? %s : %s;";
char *statement = CFCUtil_sprintf(pattern, type_c, var_name, i,
i, conversion, val);
var_assignments
= CFCUtil_cat(var_assignments, statement, NULL);
FREEMEM(statement);
}
else {
var_assignments
= CFCUtil_cat(var_assignments, "\n ", type_c, " ",
var_name, " = ", conversion, ";", NULL);
}
FREEMEM(conversion);
}
}
char pattern[] =
"XS(%s);\n"
"XS(%s) {\n"
" dXSARGS;\n"
" CHY_UNUSED_VAR(cv);\n"
" SP -= items;\n"
" %s;\n"
"\n"
" /* Extract vars from Perl stack. */\n"
" %s\n"
"\n"
" /* Execute */\n"
" %s\n"
"}\n";
char *xsub
= CFCUtil_sprintf(pattern, self->sub.c_name, self->sub.c_name,
num_args_check, var_assignments, body);
FREEMEM(num_args_check);
FREEMEM(var_assignments);
FREEMEM(body);
return xsub;
}
static char*
S_callback_start(CFCMethod *method) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
static const char pattern[] =
" dSP;\n"
" EXTEND(SP, %d);\n"
" ENTER;\n"
" SAVETMPS;\n"
" PUSHMARK(SP);\n"
" mPUSHs((SV*)Cfish_Obj_To_Host((cfish_Obj*)self));\n";
int num_args = (int)CFCParamList_num_vars(param_list) - 1;
int num_to_extend = num_args == 0 ? 1
: num_args == 1 ? 2
: 1 + (num_args * 2);
char *params = CFCUtil_sprintf(pattern, num_to_extend);
// Iterate over arguments, mapping them to Perl scalars.
CFCVariable **arg_vars = CFCParamList_get_variables(param_list);
for (int i = 1; arg_vars[i] != NULL; i++) {
CFCVariable *var = arg_vars[i];
const char *name = CFCVariable_micro_sym(var);
CFCType *type = CFCVariable_get_type(var);
const char *c_type = CFCType_to_c(type);
// Add labels when there are two or more parameters.
if (num_args > 1) {
char num_buf[20];
sprintf(num_buf, "%d", (int)strlen(name));
params = CFCUtil_cat(params, " mPUSHp(\"", name, "\", ",
num_buf, ");\n", NULL);
}
if (CFCType_is_string_type(type)) {
// Convert Clownfish string type to UTF-8 Perl string scalars.
params = CFCUtil_cat(params, " mPUSHs(XSBind_cb_to_sv(",
"(cfish_CharBuf*)", name, "));\n", NULL);
}
else if (CFCType_is_object(type)) {
// Wrap other Clownfish object types in Perl objects.
params = CFCUtil_cat(params, " mPUSHs(XSBind_cfish_to_perl(",
"(cfish_Obj*)", name, "));\n", NULL);
}
else if (CFCType_is_integer(type)) {
// Convert primitive integer types to IV Perl scalars.
int width = (int)CFCType_get_width(type);
if (width != 0 && width <= 4) {
params = CFCUtil_cat(params, " mPUSHi(",
name, ");\n", NULL);
}
else {
// If the Perl IV integer type is not wide enough, use
// doubles. This may be lossy if the value is above 2**52,
// but practically speaking, it's important to handle numbers
// between 2**32 and 2**52 cleanly.
params = CFCUtil_cat(params,
" if (sizeof(IV) >= sizeof(", c_type,
")) { mPUSHi(", name, "); }\n",
" else { mPUSHn((double)", name,
"); } // lossy \n", NULL);
}
}
else if (CFCType_is_floating(type)) {
// Convert primitive floating point types to NV Perl scalars.
params = CFCUtil_cat(params, " mPUSHn(",
name, ");\n", NULL);
}
else {
// Can't map variable type. Signal to caller.
FREEMEM(params);
return NULL;
}
}
// Restore the Perl stack pointer.
params = CFCUtil_cat(params, " PUTBACK;\n", NULL);
return params;
}
CFCType*
CFCMethod_self_type(CFCMethod *self) {
CFCVariable **vars = CFCParamList_get_variables(self->function.param_list);
return CFCVariable_get_type(vars[0]);
}
/* Generate the code which parses arguments passed from Python and converts
* them to Clownfish-flavored C values.
*/
static char*
S_gen_arg_parsing(CFCParamList *param_list, int first_tick, char **error) {
char *content = NULL;
CFCVariable **vars = CFCParamList_get_variables(param_list);
const char **vals = CFCParamList_get_initial_values(param_list);
int num_vars = CFCParamList_num_vars(param_list);
char *declarations = CFCUtil_strdup("");
char *keywords = CFCUtil_strdup("");
char *format_str = CFCUtil_strdup("");
char *targets = CFCUtil_strdup("");
int optional_started = 0;
for (int i = first_tick; i < num_vars; i++) {
CFCVariable *var = vars[i];
const char *val = vals[i];
const char *var_name = CFCVariable_get_name(var);
keywords = CFCUtil_cat(keywords, "\"", var_name, "\", ", NULL);
// Build up ParseTuple format string.
if (val == NULL) {
if (optional_started) { // problem!
*error = "Required after optional param";
goto CLEAN_UP_AND_RETURN;
}
}
else {
if (!optional_started) {
optional_started = 1;
format_str = CFCUtil_cat(format_str, "|", NULL);
}
}
format_str = CFCUtil_cat(format_str, "O&", NULL);
char *declaration = S_gen_declaration(var, val);
declarations = CFCUtil_cat(declarations, declaration, NULL);
FREEMEM(declaration);
char *target = S_gen_target(var, val);
targets = CFCUtil_cat(targets, target, NULL);
FREEMEM(target);
}
char parse_pattern[] =
"%s"
" char *keywords[] = {%sNULL};\n"
" char *fmt = \"%s\";\n"
" int ok = PyArg_ParseTupleAndKeywords(args, kwargs, fmt,\n"
" keywords%s);\n"
" if (!ok) { return NULL; }\n"
;
content = CFCUtil_sprintf(parse_pattern, declarations, keywords,
format_str, targets);
CLEAN_UP_AND_RETURN:
FREEMEM(declarations);
FREEMEM(keywords);
FREEMEM(format_str);
FREEMEM(targets);
return content;
}