int
CFCType_equals(CFCType *self, CFCType *other) {
if ((CFCType_const(self) ^ CFCType_const(other))
|| (CFCType_nullable(self) ^ CFCType_nullable(other))
|| (CFCType_is_void(self) ^ CFCType_is_void(other))
|| (CFCType_is_object(self) ^ CFCType_is_object(other))
|| (CFCType_is_primitive(self) ^ CFCType_is_primitive(other))
|| (CFCType_is_integer(self) ^ CFCType_is_integer(other))
|| (CFCType_is_floating(self) ^ CFCType_is_floating(other))
|| (CFCType_is_va_list(self) ^ CFCType_is_va_list(other))
|| (CFCType_is_arbitrary(self) ^ CFCType_is_arbitrary(other))
|| (CFCType_is_composite(self) ^ CFCType_is_composite(other))
|| (CFCType_incremented(self) ^ CFCType_incremented(other))
|| (CFCType_decremented(self) ^ CFCType_decremented(other))
|| !!self->child ^ !!other->child
|| !!self->array ^ !!other->array
) {
return false;
}
if (self->indirection != other->indirection) { return false; }
if (strcmp(self->specifier, other->specifier) != 0) { return false; }
if (self->child) {
if (!CFCType_equals(self->child, other->child)) { return false; }
}
if (self->array) {
if (strcmp(self->array, other->array) != 0) { return false; }
}
return true;
}
int
CFCType_similar(CFCType *self, CFCType *other) {
if (!CFCType_is_object(self)) {
CFCUtil_die("Attempt to call 'similar' on a non-object type");
}
if ((CFCType_const(self) ^ CFCType_const(other))
|| (CFCType_nullable(self) ^ CFCType_nullable(other))
|| (CFCType_incremented(self) ^ CFCType_incremented(other))
|| (CFCType_decremented(self) ^ CFCType_decremented(other))
|| (CFCType_is_object(self) ^ CFCType_is_object(other))
) {
return false;
}
return true;
}
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_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_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;
}
char*
CFCPyMethod_wrapper(CFCMethod *method, CFCClass *invoker) {
CFCParamList *param_list = CFCMethod_get_param_list(method);
CFCType *return_type = CFCMethod_get_return_type(method);
char *meth_sym = CFCMethod_full_method_sym(method, invoker);
char *meth_top = S_meth_top(method);
char *increfs = S_gen_arg_increfs(param_list, 1);
char *decrefs = S_gen_decrefs(param_list, 1);
char *invocation = S_gen_meth_invocation(method, invoker);
char *ret;
if (CFCType_is_void(return_type)) {
ret = CFCUtil_strdup(" Py_RETURN_NONE;\n");
}
else if (CFCType_incremented(return_type)) {
ret = CFCUtil_strdup(" return CFBind_cfish_to_py_zeroref((cfish_Obj*)retvalCF);\n");
}
else {
char *conv = CFCPyTypeMap_c_to_py(return_type, "retvalCF");
ret = CFCUtil_sprintf(" return %s;\n", conv);
FREEMEM(conv);
}
char pattern[] =
"static PyObject*\n"
"S_%s%s"
"%s" // increfs
"%s" // invocation
"%s" // decrefs
" if (CFBind_migrate_cferr()) {\n"
" return NULL;\n"
" }\n"
"%s" // ret
"}\n"
;
char *wrapper = CFCUtil_sprintf(pattern, meth_sym, meth_top,
increfs, invocation, decrefs, ret);
FREEMEM(ret);
FREEMEM(invocation);
FREEMEM(decrefs);
FREEMEM(increfs);
FREEMEM(meth_sym);
FREEMEM(meth_top);
return wrapper;
}
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;
}
