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; }
static void S_run_void_tests(CFCTest *test) { CFCParser *parser = CFCParser_new(); { CFCType *type = CFCType_new_void(false); STR_EQ(test, CFCType_get_specifier(type), "void", "get_specifier"); STR_EQ(test, CFCType_to_c(type), "void", "to_c"); OK(test, CFCType_is_void(type), "is_void"); CFCBase_decref((CFCBase*)type); } { CFCType *type = CFCType_new_void(true); STR_EQ(test, CFCType_to_c(type), "const void", "'const' in C representation"); CFCBase_decref((CFCBase*)type); } { CFCType *type = CFCTest_parse_type(test, parser, "void"); OK(test, CFCType_is_void(type), "void is_void"); CFCBase_decref((CFCBase*)type); } { CFCType *type = CFCTest_parse_type(test, parser, "const void"); OK(test, CFCType_is_void(type), "const void is_void"); OK(test, CFCType_const(type), "const void is const"); CFCBase_decref((CFCBase*)type); } CFCBase_decref((CFCBase*)parser); }
char* CFCPerlMethod_callback_def(CFCMethod *method) { CFCType *return_type = CFCMethod_get_return_type(method); char *start = S_callback_start(method); char *callback_def = NULL; char *refcount_mods = S_callback_refcount_mods(method); if (!start) { // Can't map vars, because there's at least one type in the argument // list we don't yet support. Return a callback wrapper that throws // an error error. callback_def = S_invalid_callback_def(method); } else if (CFCType_is_void(return_type)) { callback_def = S_void_callback_def(method, start, refcount_mods); } else if (CFCType_is_object(return_type)) { callback_def = S_obj_callback_def(method, start, refcount_mods); } else if (CFCType_is_integer(return_type) || CFCType_is_floating(return_type) ) { callback_def = S_primitive_callback_def(method, start, refcount_mods); } else { // Can't map return type. callback_def = S_invalid_callback_def(method); } FREEMEM(start); FREEMEM(refcount_mods); return callback_def; }
char* CFCBindMeth_callback_def(CFCMethod *method) { CFCType *return_type = CFCMethod_get_return_type(method); char *params = S_callback_params(method); char *callback_def = NULL; char *refcount_mods = S_callback_refcount_mods(method); if (!params) { // Can't map vars, because there's at least one type in the argument // list we don't yet support. Return a callback wrapper that throws // an error error. callback_def = S_invalid_callback_def(method); } else if (CFCType_is_void(return_type)) { callback_def = S_void_callback_def(method, params, refcount_mods); } else if (CFCType_is_object(return_type)) { callback_def = S_obj_callback_def(method, params, refcount_mods); } else { callback_def = S_primitive_callback_def(method, params, refcount_mods); } FREEMEM(params); FREEMEM(refcount_mods); return callback_def; }
static char* S_gen_code_sample(CFCCallable *func, const char *alias, CFCClass *klass, int is_constructor) { char *prologue = CFCUtil_sprintf(""); char *class_var_name = S_camel_to_lower(CFCClass_get_struct_sym(klass)); CFCType *ret_type = CFCCallable_get_return_type(func); if (!CFCType_is_void(ret_type)) { char *ret_name = S_perl_var_name(ret_type, is_constructor); if (!is_constructor && strcmp(ret_name, class_var_name) == 0) { // Return type equals `klass`. Use a generic variable name // to avoid confusing code samples like // `my $string = $string->trim`. prologue = CFCUtil_cat(prologue, "my $result = ", NULL); } else { prologue = CFCUtil_cat(prologue, "my $", ret_name, " = ", NULL); } FREEMEM(ret_name); } if (is_constructor) { const char *invocant = CFCClass_get_name(klass); prologue = CFCUtil_cat(prologue, invocant, NULL); } else { prologue = CFCUtil_cat(prologue, "$", class_var_name, NULL); } prologue = CFCUtil_cat(prologue, "->", alias, NULL); CFCParamList *param_list = CFCCallable_get_param_list(func); int num_vars = CFCParamList_num_vars(param_list); int start = is_constructor ? 0 : 1; char *sample = NULL; if (start == num_vars) { sample = CFCUtil_sprintf(" %s();\n", prologue); } else if (is_constructor || num_vars - start >= 2) { sample = S_gen_labeled_sample(prologue, param_list, start); } else { sample = S_gen_positional_sample(prologue, param_list, start); } FREEMEM(class_var_name); FREEMEM(prologue); return sample; }
static char* S_maybe_unreachable(CFCType *return_type) { char *return_statement; if (CFCType_is_void(return_type)) { return_statement = CFCUtil_strdup(""); } else { const char *ret_type_str = CFCType_to_c(return_type); char pattern[] = "\n CFISH_UNREACHABLE_RETURN(%s);"; return_statement = CFCUtil_sprintf(pattern, ret_type_str); } return return_statement; }
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; }
static char* S_maybe_unreachable(CFCType *return_type) { char *return_statement; if (CFCType_is_void(return_type)) { return_statement = CFCUtil_strdup(""); } else { const char *ret_type_str = CFCType_to_c(return_type); return_statement = (char*)MALLOCATE(strlen(ret_type_str) + 60); sprintf(return_statement, "\n CHY_UNREACHABLE_RETURN(%s);", ret_type_str); } return return_statement; }
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_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; }
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; }
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_build_pymeth_invocation(CFCMethod *method) { CFCType *return_type = CFCMethod_get_return_type(method); const char *micro_sym = CFCSymbol_get_name((CFCSymbol*)method); char *invocation = NULL; const char *ret_type_str = CFCType_to_c(return_type); if (CFCType_is_void(return_type)) { const char pattern[] = " CALL_PYMETH_VOID((PyObject*)self, \"%s\", cfcb_ARGS);"; invocation = CFCUtil_sprintf(pattern, micro_sym); } else if (CFCType_is_object(return_type)) { const char *nullable = CFCType_nullable(return_type) ? "true" : "false"; const char *ret_class = CFCType_get_class_var(return_type); const char pattern[] = " %s cfcb_RESULT = (%s)CALL_PYMETH_OBJ((PyObject*)self, \"%s\", cfcb_ARGS, %s, %s);"; invocation = CFCUtil_sprintf(pattern, ret_type_str, ret_type_str, micro_sym, ret_class, nullable); } else if (CFCType_is_primitive(return_type)) { char type_upcase[64]; if (strlen(ret_type_str) > 63) { CFCUtil_die("Unexpectedly long type name: %s", ret_type_str); } for (int i = 0, max = strlen(ret_type_str) + 1; i < max; i++) { type_upcase[i] = toupper(ret_type_str[i]); } const char pattern[] = " %s cfcb_RESULT = CALL_PYMETH_%s((PyObject*)self, \"%s\", cfcb_ARGS);"; invocation = CFCUtil_sprintf(pattern, ret_type_str, type_upcase, micro_sym); } else { CFCUtil_die("Unexpected return type: %s", CFCType_to_c(return_type)); } return invocation; }
static char* S_gen_meth_invocation(CFCMethod *method, CFCClass *invoker) { CFCParamList *param_list = CFCMethod_get_param_list(method); char *full_meth = CFCMethod_full_method_sym(method, invoker); char *meth_type_c = CFCMethod_full_typedef(method, invoker); const char *class_var = CFCClass_full_class_var(invoker); char *first_arg = CFCUtil_sprintf("(%s*)self", CFCClass_full_struct_sym(invoker)); char *arg_list = S_gen_arg_list(param_list, first_arg); CFCType *return_type = CFCMethod_get_return_type(method); char *maybe_declare; const char *maybe_assign; if (CFCType_is_void(return_type)) { maybe_declare = CFCUtil_strdup(""); maybe_assign = ""; } else { maybe_declare = CFCUtil_sprintf(" %s retvalCF;\n", CFCType_to_c(return_type)); maybe_assign = "retvalCF = "; } const char pattern[] = "%s" " %s method = CFISH_METHOD_PTR(%s, %s);\n" " CFBIND_TRY(%smethod(%s));\n" ; char *content = CFCUtil_sprintf(pattern, maybe_declare, meth_type_c, class_var, full_meth, maybe_assign, arg_list); FREEMEM(arg_list); FREEMEM(first_arg); FREEMEM(maybe_declare); FREEMEM(full_meth); FREEMEM(meth_type_c); return content; }
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_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; }