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;
}
static char*
S_primitive_callback_def(CFCMethod *method, const char *callback_start,
const char *refcount_mods) {
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *micro_sym = CFCMethod_micro_sym(method);
char callback_func[50];
if (CFCType_is_integer(return_type)) {
strcpy(callback_func, "S_finish_callback_i64");
}
else if (CFCType_is_floating(return_type)) {
strcpy(callback_func, "S_finish_callback_f64");
}
else {
CFCUtil_die("Unexpected type: %s", ret_type_str);
}
char pattern[] =
"%s\n"
"%s(%s) {\n"
"%s"
" %s retval = (%s)%s(\"%s\");%s\n"
" return retval;\n"
"}\n";
char *callback_def
= CFCUtil_sprintf(pattern, ret_type_str, override_sym, params,
callback_start, ret_type_str, ret_type_str,
callback_func, micro_sym, refcount_mods);
return callback_def;
}
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_imp_declaration(CFCMethod *method) {
CFCType *return_type = CFCMethod_get_return_type(method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *full_imp_sym = CFCMethod_imp_func(method);
const char *param_list_str = CFCParamList_to_c(param_list);
char *buf = CFCUtil_sprintf("%s\n%s(%s);", ret_type_str,
full_imp_sym, param_list_str);
return buf;
}
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;
}
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;
}
char*
CFCBindMeth_callback_dec(CFCMethod *method) {
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
char pattern[] =
"%s\n"
"%s(%s);\n";
char *callback_dec
= CFCUtil_sprintf(pattern, ret_type_str, override_sym, params);
return callback_dec;
}
static char*
S_obj_callback_def(CFCMethod *method, const char *callback_params,
const char *refcount_mods) {
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *cb_func_name = CFCType_is_string_type(return_type)
? "cfish_Host_callback_str"
: "cfish_Host_callback_obj";
char *nullable_check = CFCUtil_strdup("");
if (!CFCType_nullable(return_type)) {
const char *macro_sym = CFCMethod_get_macro_sym(method);
char pattern[] =
"\n if (!retval) { CFISH_THROW(CFISH_ERR, "
"\"%s() for class '%%o' cannot return NULL\", "
"Cfish_Obj_Get_Class_Name((cfish_Obj*)self)); }";
size_t size = sizeof(pattern) + strlen(macro_sym) + 30;
nullable_check = (char*)REALLOCATE(nullable_check, size);
sprintf(nullable_check, pattern, macro_sym);
}
char pattern[] =
"%s\n"
"%s(%s) {\n"
" %s retval = (%s)%s(%s);%s%s\n"
" return retval;\n"
"}\n";
size_t size = sizeof(pattern)
+ strlen(ret_type_str)
+ strlen(override_sym)
+ strlen(params)
+ strlen(ret_type_str)
+ strlen(ret_type_str)
+ strlen(cb_func_name)
+ strlen(callback_params)
+ strlen(nullable_check)
+ strlen(refcount_mods)
+ 30;
char *callback_def = (char*)MALLOCATE(size);
sprintf(callback_def, pattern, ret_type_str, override_sym, params,
ret_type_str, ret_type_str, cb_func_name, callback_params,
nullable_check, refcount_mods);
FREEMEM(nullable_check);
return callback_def;
}
char*
CFCBindMeth_typedef_dec(struct CFCMethod *method, CFCClass *klass) {
const char *params_end
= CFCParamList_to_c(CFCMethod_get_param_list(method));
while (*params_end && *params_end != '*') {
params_end++;
}
const char *self_struct = CFCClass_full_struct_sym(klass);
const char *ret_type = CFCType_to_c(CFCMethod_get_return_type(method));
char *full_typedef = CFCMethod_full_typedef(method, klass);
char *buf = CFCUtil_sprintf("typedef %s\n(*%s)(%s%s);\n", ret_type,
full_typedef, self_struct,
params_end);
FREEMEM(full_typedef);
return buf;
}
static char*
S_virtual_method_def(CFCMethod *method, CFCClass *klass) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *PREFIX = CFCClass_get_PREFIX(klass);
const char *invoker_struct = CFCClass_full_struct_sym(klass);
char *full_meth_sym = CFCMethod_full_method_sym(method, klass);
char *full_offset_sym = CFCMethod_full_offset_sym(method, klass);
char *full_typedef = CFCMethod_full_typedef(method, klass);
// Prepare parameter lists, minus invoker. The invoker gets forced to
// "self" later.
if (CFCParamList_variadic(param_list)) {
CFCUtil_die("Variadic methods not supported");
}
const char *arg_names_minus_invoker = CFCParamList_name_list(param_list);
const char *params_minus_invoker = CFCParamList_to_c(param_list);
while (*arg_names_minus_invoker && *arg_names_minus_invoker != ',') {
arg_names_minus_invoker++;
}
while (*params_minus_invoker && *params_minus_invoker != ',') {
params_minus_invoker++;
}
// Prepare a return statement... or not.
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *maybe_return = CFCType_is_void(return_type) ? "" : "return ";
const char pattern[] =
"extern %sVISIBLE size_t %s;\n"
"static CFISH_INLINE %s\n"
"%s(%s *self%s) {\n"
" const %s method = (%s)cfish_obj_method(self, %s);\n"
" %smethod(self%s);\n"
"}\n";
char *method_def
= CFCUtil_sprintf(pattern, PREFIX, full_offset_sym, ret_type_str,
full_meth_sym, invoker_struct, params_minus_invoker,
full_typedef, full_typedef, full_offset_sym,
maybe_return, arg_names_minus_invoker);
FREEMEM(full_offset_sym);
FREEMEM(full_meth_sym);
FREEMEM(full_typedef);
return method_def;
}
static char*
S_void_callback_def(CFCMethod *method, const char *callback_start,
const char *refcount_mods) {
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
const char *micro_sym = CFCMethod_micro_sym(method);
const char pattern[] =
"void\n"
"%s(%s) {\n"
"%s"
" S_finish_callback_void(\"%s\");%s\n"
"}\n";
char *callback_def
= CFCUtil_sprintf(pattern, override_sym, params, callback_start,
micro_sym, refcount_mods);
return callback_def;
}
char*
CFCBindMeth_typedef_dec(struct CFCMethod *method, CFCClass *klass) {
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
const char *ret_type = CFCType_to_c(CFCMethod_get_return_type(method));
size_t full_typedef_size = CFCMethod_full_typedef(method, klass, NULL, 0);
char *full_typedef = (char*)MALLOCATE(full_typedef_size);
CFCMethod_full_typedef(method, klass, full_typedef, full_typedef_size);
size_t size = strlen(params)
+ strlen(ret_type)
+ strlen(full_typedef)
+ 20
+ sizeof("\0");
char *buf = (char*)MALLOCATE(size);
sprintf(buf, "typedef %s\n(*%s)(%s);\n", ret_type, full_typedef, params);
FREEMEM(full_typedef);
return buf;
}
static char*
S_primitive_callback_def(CFCMethod *method, const char *callback_params,
const char *refcount_mods) {
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
char cb_func_name[40];
if (CFCType_is_floating(return_type)) {
strcpy(cb_func_name, "cfish_Host_callback_f64");
}
else if (CFCType_is_integer(return_type)) {
strcpy(cb_func_name, "cfish_Host_callback_i64");
}
else if (strcmp(ret_type_str, "void*") == 0) {
strcpy(cb_func_name, "cfish_Host_callback_host");
}
else {
CFCUtil_die("unrecognized type: %s", ret_type_str);
}
char pattern[] =
"%s\n"
"%s(%s) {\n"
" return (%s)%s(%s);%s\n"
"}\n";
size_t size = sizeof(pattern)
+ strlen(ret_type_str)
+ strlen(override_sym)
+ strlen(params)
+ strlen(ret_type_str)
+ strlen(cb_func_name)
+ strlen(callback_params)
+ strlen(refcount_mods)
+ 20;
char *callback_def = (char*)MALLOCATE(size);
sprintf(callback_def, pattern, ret_type_str, override_sym, params,
ret_type_str, cb_func_name, callback_params, refcount_mods);
return callback_def;
}
static char*
S_void_callback_def(CFCMethod *method, const char *callback_params,
const char *refcount_mods) {
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
const char pattern[] =
"void\n"
"%s(%s) {\n"
" cfish_Host_callback(%s);%s\n"
"}\n";
size_t size = sizeof(pattern)
+ strlen(override_sym)
+ strlen(params)
+ strlen(callback_params)
+ strlen(refcount_mods)
+ 200;
char *callback_def = (char*)MALLOCATE(size);
sprintf(callback_def, pattern, override_sym, params, callback_params,
refcount_mods);
return callback_def;
}
static char*
S_obj_callback_def(CFCMethod *method, const char *callback_start,
const char *refcount_mods) {
const char *override_sym = CFCMethod_full_override_sym(method);
const char *params = CFCParamList_to_c(CFCMethod_get_param_list(method));
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *micro_sym = CFCMethod_micro_sym(method);
const char *nullable = CFCType_nullable(return_type) ? "true" : "false";
char pattern[] =
"%s\n"
"%s(%s) {\n"
"%s"
" %s retval = (%s)S_finish_callback_obj(self, \"%s\", %s);%s\n"
" return retval;\n"
"}\n";
char *callback_def
= CFCUtil_sprintf(pattern, ret_type_str, override_sym, params,
callback_start, ret_type_str, ret_type_str,
micro_sym, nullable, refcount_mods);
return callback_def;
}
static char*
S_method_def(CFCMethod *method, CFCClass *klass, int optimized_final_meth) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *PREFIX = CFCClass_get_PREFIX(klass);
const char *invoker_struct = CFCClass_full_struct_sym(klass);
const char *self_name = CFCParamList_param_name(param_list, 0);
char *full_meth_sym = CFCMethod_full_method_sym(method, klass);
char *full_offset_sym = CFCMethod_full_offset_sym(method, klass);
char *full_typedef = CFCMethod_full_typedef(method, klass);
char *full_imp_sym = CFCMethod_imp_func(method, klass);
// Prepare parameter lists, minus the type of the invoker.
if (CFCParamList_variadic(param_list)) {
CFCUtil_die("Variadic methods not supported");
}
const char *arg_names = CFCParamList_name_list(param_list);
const char *params_end = CFCParamList_to_c(param_list);
while (*params_end && *params_end != '*') {
params_end++;
}
// Prepare a return statement... or not.
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *maybe_return = CFCType_is_void(return_type) ? "" : "return ";
const char innards_pattern[] =
" const %s method = (%s)cfish_obj_method(%s, %s);\n"
" %smethod(%s);\n"
;
char *innards = CFCUtil_sprintf(innards_pattern, full_typedef,
full_typedef, self_name, full_offset_sym,
maybe_return, arg_names);
if (optimized_final_meth) {
CFCParcel *parcel = CFCClass_get_parcel(klass);
const char *privacy_sym = CFCParcel_get_privacy_sym(parcel);
char *invoker_cast = CFCUtil_strdup("");
if (!CFCMethod_is_fresh(method, klass)) {
CFCType *self_type = CFCMethod_self_type(method);
invoker_cast = CFCUtil_cat(invoker_cast, "(",
CFCType_to_c(self_type), ")", NULL);
}
const char pattern[] =
"#ifdef %s\n"
" %s%s(%s%s);\n"
"#else\n"
"%s"
"#endif\n"
;
char *temp = CFCUtil_sprintf(pattern, privacy_sym,
maybe_return, full_imp_sym,
invoker_cast, arg_names, innards);
FREEMEM(innards);
innards = temp;
FREEMEM(invoker_cast);
}
const char pattern[] =
"extern %sVISIBLE uint32_t %s;\n"
"static CFISH_INLINE %s\n"
"%s(%s%s) {\n"
"%s"
"}\n";
char *method_def
= CFCUtil_sprintf(pattern, PREFIX, full_offset_sym, ret_type_str,
full_meth_sym, invoker_struct, params_end, innards);
FREEMEM(innards);
FREEMEM(full_imp_sym);
FREEMEM(full_offset_sym);
FREEMEM(full_meth_sym);
FREEMEM(full_typedef);
return method_def;
}
static char*
S_virtual_method_def(CFCMethod *method, CFCClass *klass) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
const char *invoker_struct = CFCClass_full_struct_sym(klass);
const char *common_struct
= CFCType_get_specifier(CFCMethod_self_type(method));
const char *visibility = CFCClass_included(klass)
? "CHY_IMPORT" : "CHY_EXPORT";
size_t meth_sym_size = CFCMethod_full_method_sym(method, klass, NULL, 0);
char *full_meth_sym = (char*)MALLOCATE(meth_sym_size);
CFCMethod_full_method_sym(method, klass, full_meth_sym, meth_sym_size);
size_t offset_sym_size = CFCMethod_full_offset_sym(method, klass, NULL, 0);
char *full_offset_sym = (char*)MALLOCATE(offset_sym_size);
CFCMethod_full_offset_sym(method, klass, full_offset_sym, offset_sym_size);
size_t full_typedef_size = CFCMethod_full_typedef(method, klass, NULL, 0);
char *full_typedef = (char*)MALLOCATE(full_typedef_size);
CFCMethod_full_typedef(method, klass, full_typedef, full_typedef_size);
// Prepare parameter lists, minus invoker. The invoker gets forced to
// "self" later.
const char *arg_names_minus_invoker = CFCParamList_name_list(param_list);
const char *params_minus_invoker = CFCParamList_to_c(param_list);
while (*arg_names_minus_invoker && *arg_names_minus_invoker != ',') {
arg_names_minus_invoker++;
}
while (*params_minus_invoker && *params_minus_invoker != ',') {
params_minus_invoker++;
}
// Prepare a return statement... or not.
CFCType *return_type = CFCMethod_get_return_type(method);
const char *ret_type_str = CFCType_to_c(return_type);
const char *maybe_return = CFCType_is_void(return_type) ? "" : "return ";
const char pattern[] =
"extern %s size_t %s;\n"
"static CHY_INLINE %s\n"
"%s(const %s *self%s) {\n"
" char *const method_address = *(char**)self + %s;\n"
" const %s method = *((%s*)method_address);\n"
" %smethod((%s*)self%s);\n"
"}\n";
size_t size = sizeof(pattern)
+ strlen(visibility)
+ strlen(full_offset_sym)
+ strlen(ret_type_str)
+ strlen(full_meth_sym)
+ strlen(invoker_struct)
+ strlen(params_minus_invoker)
+ strlen(full_offset_sym)
+ strlen(full_typedef)
+ strlen(full_typedef)
+ strlen(maybe_return)
+ strlen(common_struct)
+ strlen(arg_names_minus_invoker)
+ 40;
char *method_def = (char*)MALLOCATE(size);
sprintf(method_def, pattern, visibility, full_offset_sym, ret_type_str,
full_meth_sym, invoker_struct, params_minus_invoker,
full_offset_sym, full_typedef, full_typedef, maybe_return,
common_struct, arg_names_minus_invoker);
FREEMEM(full_offset_sym);
FREEMEM(full_meth_sym);
FREEMEM(full_typedef);
return method_def;
}