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;
}
static void
S_run_object_tests(CFCTest *test) {
static const char *modifiers[4] = {
"const", "incremented", "decremented", "nullable"
};
static int flags[4] = {
CFCTYPE_CONST,
CFCTYPE_INCREMENTED,
CFCTYPE_DECREMENTED,
CFCTYPE_NULLABLE
};
static int (*accessors[4])(CFCType *type) = {
CFCType_const,
CFCType_incremented,
CFCType_decremented,
CFCType_nullable
};
{
CFCParser *parser = CFCParser_new();
CFCParcel *neato_parcel
= CFCTest_parse_parcel(test, parser, "parcel Neato;");
static const char *specifiers[4] = {
"Foo", "FooJr", "FooIII", "Foo4th"
};
for (int i = 0; i < 4; ++i) {
const char *specifier = specifiers[i];
char *class_code = CFCUtil_sprintf("class %s {}", specifier);
CFCClass *klass = CFCTest_parse_class(test, parser, class_code);
FREEMEM(class_code);
static const char *prefixes[2] = { "", "neato_" };
char *expect = CFCUtil_sprintf("neato_%s", specifier);
for (int j = 0; j < 2; ++j) {
char *src = CFCUtil_sprintf("%s%s*", prefixes[j], specifier);
CFCType *type = CFCTest_parse_type(test, parser, src);
CFCType_resolve(type);
STR_EQ(test, CFCType_get_specifier(type), expect,
"object_type_specifier: %s", src);
OK(test, CFCType_is_object(type), "%s is_object", src);
INT_EQ(test, CFCType_get_indirection(type), 1,
"%s indirection", src);
FREEMEM(src);
CFCBase_decref((CFCBase*)type);
}
FREEMEM(expect);
for (int j = 0; j < 4; ++j) {
char *src = CFCUtil_sprintf("%s %s*", modifiers[j], specifier);
CFCType *type = CFCTest_parse_type(test, parser, src);
OK(test, CFCType_is_object(type), "%s is_object", src);
OK(test, accessors[j](type), "%s accessor", src);
FREEMEM(src);
CFCBase_decref((CFCBase*)type);
}
CFCBase_decref((CFCBase*)klass);
CFCClass_clear_registry();
}
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)parser);
}
CFCParcel *neato_parcel = CFCParcel_new("Neato", NULL, NULL, NULL);
CFCClass *foo_class
= CFCClass_create(neato_parcel, NULL, "Foo", NULL, NULL, NULL, NULL,
NULL, false, false, false);
CFCType *foo = CFCType_new_object(0, neato_parcel, "Foo", 1);
CFCType_resolve(foo);
{
CFCType *another_foo = CFCType_new_object(0, neato_parcel, "Foo", 1);
CFCType_resolve(another_foo);
OK(test, CFCType_equals(foo, another_foo), "equals");
CFCBase_decref((CFCBase*)another_foo);
}
{
CFCClass *bar_class
= CFCClass_create(neato_parcel, NULL, "Bar", NULL, NULL, NULL,
NULL, NULL, false, false, false);
CFCType *bar = CFCType_new_object(0, neato_parcel, "Bar", 1);
CFCType_resolve(bar);
OK(test, !CFCType_equals(foo, bar),
"different specifier spoils equals");
CFCBase_decref((CFCBase*)bar);
CFCBase_decref((CFCBase*)bar_class);
}
{
CFCParcel *foreign_parcel
= CFCParcel_new("Foreign", NULL, NULL, NULL);
CFCClass *foreign_foo_class
= CFCClass_create(foreign_parcel, NULL, "Foreign::Foo", NULL, NULL,
NULL, NULL, NULL, false, false, false);
CFCType *foreign_foo = CFCType_new_object(0, foreign_parcel, "Foo", 1);
CFCType_resolve(foreign_foo);
OK(test, !CFCType_equals(foo, foreign_foo),
"different parcel spoils equals");
STR_EQ(test, CFCType_get_specifier(foreign_foo), "foreign_Foo",
"prepend parcel prefix to specifier");
CFCBase_decref((CFCBase*)foreign_parcel);
CFCBase_decref((CFCBase*)foreign_foo_class);
CFCBase_decref((CFCBase*)foreign_foo);
}
{
for (int i = 0; i < 4; ++i) {
CFCType *modified_foo
= CFCType_new_object(flags[i], neato_parcel, "Foo", 1);
CFCType_resolve(modified_foo);
OK(test, accessors[i](modified_foo), "%s", modifiers[i]);
OK(test, !accessors[i](foo), "not %s", modifiers[i]);
OK(test, !CFCType_equals(foo, modified_foo),
"different %s spoils equals", modifiers[i]);
OK(test, !CFCType_similar(foo, modified_foo),
"different %s spoils similar", modifiers[i]);
CFCBase_decref((CFCBase*)modified_foo);
}
}
{
CFCType *string_type
= CFCType_new_object(0, neato_parcel, "String", 1);
OK(test, CFCType_is_string_type(string_type), "%s", "is_string_type");
OK(test, !CFCType_is_string_type(foo), "not %s", "not is_string_type");
CFCBase_decref((CFCBase*)string_type);
}
CFCBase_decref((CFCBase*)neato_parcel);
CFCBase_decref((CFCBase*)foo_class);
CFCBase_decref((CFCBase*)foo);
CFCClass_clear_registry();
CFCParcel_reap_singletons();
}
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;
}
static char*
S_callback_params(CFCMethod *method) {
const char *micro_sym = CFCSymbol_micro_sym((CFCSymbol*)method);
CFCParamList *param_list = CFCMethod_get_param_list(method);
unsigned num_params = CFCParamList_num_vars(param_list) - 1;
size_t needed = strlen(micro_sym) + 30;
char *params = (char*)MALLOCATE(needed);
// TODO: use something other than micro_sym here.
sprintf(params, "self, \"%s\", %u", micro_sym, num_params);
// Iterate over arguments, mapping them to various arg wrappers which
// conform to Host's callback interface.
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);
size_t name_len = strlen(name);
CFCType *type = CFCVariable_get_type(var);
const char *c_type = CFCType_to_c(type);
size_t size = strlen(params)
+ strlen(c_type)
+ name_len * 2
+ 30;
char *new_buf = (char*)MALLOCATE(size);
if (CFCType_is_string_type(type)) {
sprintf(new_buf, "%s, CFISH_ARG_STR(\"%s\", %s)", params, name, name);
}
else if (CFCType_is_object(type)) {
sprintf(new_buf, "%s, CFISH_ARG_OBJ(\"%s\", %s)", params, name, name);
}
else if (CFCType_is_integer(type)) {
int width = CFCType_get_width(type);
if (width) {
if (width <= 4) {
sprintf(new_buf, "%s, CFISH_ARG_I32(\"%s\", %s)", params,
name, name);
}
else {
sprintf(new_buf, "%s, CFISH_ARG_I64(\"%s\", %s)", params,
name, name);
}
}
else {
sprintf(new_buf, "%s, CFISH_ARG_I(%s, \"%s\", %s)", params,
c_type, name, name);
}
}
else if (CFCType_is_floating(type)) {
sprintf(new_buf, "%s, CFISH_ARG_F64(\"%s\", %s)", params, name, name);
}
else {
// Can't map variable type. Signal to caller.
FREEMEM(params);
FREEMEM(new_buf);
return NULL;
}
FREEMEM(params);
params = new_buf;
}
return params;
}
