/* Create a macro definition that aliases to a function name directly, since
* this method may not be overridden. */
static char*
S_final_method_def(CFCMethod *method, CFCClass *klass) {
const char *self_type = CFCType_to_c(CFCMethod_self_type(method));
const char *full_func_sym = CFCMethod_implementing_func_sym(method);
const char *arg_names
= CFCParamList_name_list(CFCMethod_get_param_list(method));
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);
const char pattern[] = "extern size_t %s;\n#define %s(%s) \\\n %s((%s)%s)\n";
size_t size = sizeof(pattern)
+ strlen(full_offset_sym)
+ strlen(full_meth_sym)
+ strlen(arg_names)
+ strlen(full_func_sym)
+ strlen(self_type)
+ strlen(arg_names)
+ 20;
char *method_def = (char*)MALLOCATE(size);
sprintf(method_def, pattern, full_offset_sym, full_meth_sym, arg_names,
full_func_sym, self_type, arg_names);
FREEMEM(full_offset_sym);
FREEMEM(full_meth_sym);
return method_def;
}
const char*
CFCMethod_full_override_sym(CFCMethod *self) {
if (!self->full_override_sym) {
const char *full_func_sym = CFCMethod_implementing_func_sym(self);
self->full_override_sym
= CFCUtil_sprintf("%s_OVERRIDE", full_func_sym);
}
return self->full_override_sym;
}
void
CFCMethod_override(CFCMethod *self, CFCMethod *orig) {
// Check that the override attempt is legal.
if (CFCMethod_final(orig)) {
const char *orig_class = CFCMethod_get_class_name(orig);
const char *my_class = CFCMethod_get_class_name(self);
CFCUtil_die("Attempt to override final method '%s' from '%s' by '%s'",
orig->macro_sym, orig_class, my_class);
}
if (!CFCMethod_compatible(self, orig)) {
const char *func = CFCMethod_implementing_func_sym(self);
const char *orig_func = CFCMethod_implementing_func_sym(orig);
CFCUtil_die("Non-matching signatures for %s and %s", func, orig_func);
}
// Mark the Method as no longer novel.
self->is_novel = false;
}
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_implementing_func_sym(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_CharBuf *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";
size_t needed = sizeof(pattern)
+ strlen(ret_type_str)
+ strlen(full_func_sym)
+ strlen(params)
+ strlen(vtable_var)
+ strlen(unused)
+ strlen(macro_sym)
+ strlen(return_statement)
+ 50;
char *abstract_def = (char*)MALLOCATE(needed);
sprintf(abstract_def, pattern, ret_type_str, full_func_sym, params,
vtable_var, unused, macro_sym, return_statement);
FREEMEM(unused);
FREEMEM(return_statement);
return abstract_def;
}
char*
CFCBindMeth_spec_def(CFCMethod *method) {
const char *macro_sym = CFCMethod_get_macro_sym(method);
const char *impl_sym = CFCMethod_implementing_func_sym(method);
int is_novel = CFCMethod_novel(method);
const char *full_override_sym = "NULL";
if ((CFCMethod_public(method) || CFCMethod_abstract(method)) && is_novel) {
full_override_sym = CFCMethod_full_override_sym(method);
}
size_t offset_sym_size = CFCMethod_full_offset_sym(method, NULL, NULL, 0);
char *full_offset_sym = (char*)MALLOCATE(offset_sym_size);
CFCMethod_full_offset_sym(method, NULL, full_offset_sym, offset_sym_size);
char pattern[] =
" {\n"
" %d, /* is_novel */\n"
" \"%s\", /* name */\n"
" (cfish_method_t)%s, /* func */\n"
" (cfish_method_t)%s, /* callback_func */\n"
" &%s /* offset */\n"
" }";
size_t size = sizeof(pattern)
+ 10 /* for is_novel */
+ strlen(macro_sym)
+ strlen(impl_sym)
+ strlen(full_override_sym)
+ strlen(full_offset_sym)
+ 30;
char *def = (char*)MALLOCATE(size);
sprintf(def, pattern, is_novel, macro_sym, impl_sym, full_override_sym,
full_offset_sym);
FREEMEM(full_offset_sym);
return def;
}
static void
S_add_load_method(CFCClass *klass) {
CFCMethod *method = S_make_method_obj(klass, "Load");
CFCClass_add_method(klass, method);
CFCBase_decref((CFCBase*)method);
const char *full_func_sym = CFCMethod_implementing_func_sym(method);
const char *full_struct = CFCClass_full_struct_sym(klass);
const char *vtable_var = CFCClass_full_vtable_var(klass);
CFCClass *parent = CFCClass_get_parent(klass);
const char *prefix = CFCClass_get_prefix(klass);
const char *class_cnick = CFCClass_get_cnick(klass);
char buf[BUF_SIZE];
if (parent && CFCClass_has_attribute(parent, "dumpable")) {
char *full_typedef = CFCMethod_full_typedef(method, klass);
char *full_meth = CFCMethod_full_method_sym(method, klass);
const char pattern[] =
"cfish_Obj*\n"
"%s(%s *self, cfish_Obj *dump)\n"
"{\n"
" cfish_Hash *source = (cfish_Hash*)CFISH_CERTIFY(dump, CFISH_HASH);\n"
" %s super_load = CFISH_SUPER_METHOD_PTR(%s, %s);\n"
" %s *loaded = (%s*)super_load(self, dump);\n"
" %sIVARS *ivars = %s%s_IVARS(loaded);\n";
char *autocode
= CFCUtil_sprintf(pattern, full_func_sym, full_struct,
full_typedef, vtable_var, full_meth, full_struct,
full_struct, full_struct, prefix, class_cnick);
CFCClass_append_autocode(klass, autocode);
FREEMEM(full_meth);
FREEMEM(full_typedef);
FREEMEM(autocode);
CFCVariable **fresh = CFCClass_fresh_member_vars(klass);
for (size_t i = 0; fresh[i] != NULL; i++) {
S_process_load_member(klass, fresh[i], buf, BUF_SIZE);
}
FREEMEM(fresh);
}
else {
const char pattern[] =
"cfish_Obj*\n"
"%s(%s *self, cfish_Obj *dump)\n"
"{\n"
" cfish_Hash *source = (cfish_Hash*)CFISH_CERTIFY(dump, CFISH_HASH);\n"
" cfish_CharBuf *class_name = (cfish_CharBuf*)CFISH_CERTIFY(\n"
" Cfish_Hash_Fetch_Str(source, \"_class\", 6), CFISH_CHARBUF);\n"
" cfish_VTable *vtable = cfish_VTable_singleton(class_name, NULL);\n"
" %s *loaded = (%s*)Cfish_VTable_Make_Obj(vtable);\n"
" %sIVARS *ivars = %s%s_IVARS(loaded);\n"
" CHY_UNUSED_VAR(self);\n";
char *autocode
= CFCUtil_sprintf(pattern, full_func_sym, full_struct, full_struct,
full_struct,
full_struct, prefix, class_cnick);
CFCClass_append_autocode(klass, autocode);
FREEMEM(autocode);
CFCVariable **members = CFCClass_member_vars(klass);
for (size_t i = 0; members[i] != NULL; i++) {
S_process_load_member(klass, members[i], buf, BUF_SIZE);
}
}
CFCClass_append_autocode(klass, " return (cfish_Obj*)loaded;\n}\n\n");
}
static void
S_add_dump_method(CFCClass *klass) {
CFCMethod *method = S_make_method_obj(klass, "Dump");
CFCClass_add_method(klass, method);
CFCBase_decref((CFCBase*)method);
const char *full_func_sym = CFCMethod_implementing_func_sym(method);
const char *full_struct = CFCClass_full_struct_sym(klass);
const char *vtable_var = CFCClass_full_vtable_var(klass);
const char *prefix = CFCClass_get_prefix(klass);
const char *class_cnick = CFCClass_get_cnick(klass);
CFCClass *parent = CFCClass_get_parent(klass);
char buf[BUF_SIZE];
if (parent && CFCClass_has_attribute(parent, "dumpable")) {
char *full_typedef = CFCMethod_full_typedef(method, klass);
char *full_meth = CFCMethod_full_method_sym(method, klass);
const char pattern[] =
"cfish_Obj*\n"
"%s(%s *self)\n"
"{\n"
" %sIVARS *ivars = %s%s_IVARS(self);\n"
" %s super_dump = CFISH_SUPER_METHOD_PTR(%s, %s);\n"
" cfish_Hash *dump = (cfish_Hash*)super_dump(self);\n";
char *autocode
= CFCUtil_sprintf(pattern, full_func_sym, full_struct,
full_struct, prefix, class_cnick,
full_typedef, vtable_var, full_meth);
CFCClass_append_autocode(klass, autocode);
FREEMEM(full_meth);
FREEMEM(full_typedef);
FREEMEM(autocode);
CFCVariable **fresh = CFCClass_fresh_member_vars(klass);
for (size_t i = 0; fresh[i] != NULL; i++) {
S_process_dump_member(klass, fresh[i], buf, BUF_SIZE);
}
FREEMEM(fresh);
}
else {
const char pattern[] =
"cfish_Obj*\n"
"%s(%s *self)\n"
"{\n"
" %sIVARS *ivars = %s%s_IVARS(self);\n"
" cfish_Hash *dump = cfish_Hash_new(0);\n"
" Cfish_Hash_Store_Str(dump, \"_class\", 6,\n"
" (cfish_Obj*)Cfish_CB_Clone(Cfish_Obj_Get_Class_Name((cfish_Obj*)self)));\n";
char *autocode
= CFCUtil_sprintf(pattern, full_func_sym, full_struct,
full_struct, prefix, class_cnick);
CFCClass_append_autocode(klass, autocode);
FREEMEM(autocode);
CFCVariable **members = CFCClass_member_vars(klass);
for (size_t i = 0; members[i] != NULL; i++) {
S_process_dump_member(klass, members[i], buf, BUF_SIZE);
}
}
CFCClass_append_autocode(klass, " return (cfish_Obj*)dump;\n}\n\n");
}
