static CFCMethod* S_make_method_obj(CFCClass *klass, const char *method_name) { const char *klass_full_struct_sym = CFCClass_full_struct_sym(klass); const char *klass_name = CFCClass_get_class_name(klass); const char *klass_cnick = CFCClass_get_cnick(klass); CFCParcel *klass_parcel = CFCClass_get_parcel(klass); CFCType *return_type = CFCType_new_object(CFCTYPE_INCREMENTED, klass_parcel, "cfish_Obj", 1); CFCType *self_type = CFCType_new_object(0, klass_parcel, klass_full_struct_sym, 1); CFCVariable *self_var = CFCVariable_new(NULL, NULL, NULL, NULL, "self", self_type, false); CFCParamList *param_list = NULL; if (strcmp(method_name, "Dump") == 0) { param_list = CFCParamList_new(false); CFCParamList_add_param(param_list, self_var, NULL); } else if (strcmp(method_name, "Load") == 0) { CFCType *dump_type = CFCType_new_object(0, klass_parcel, "cfish_Obj", 1); CFCVariable *dump_var = CFCVariable_new(NULL, NULL, NULL, NULL, "dump", dump_type, false); param_list = CFCParamList_new(false); CFCParamList_add_param(param_list, self_var, NULL); CFCParamList_add_param(param_list, dump_var, NULL); CFCBase_decref((CFCBase*)dump_var); CFCBase_decref((CFCBase*)dump_type); } else { CFCUtil_die("Unexpected method_name: '%s'", method_name); } CFCMethod *method = CFCMethod_new(klass_parcel, "public", klass_name, klass_cnick, method_name, return_type, param_list, NULL, false, false); CFCBase_decref((CFCBase*)param_list); CFCBase_decref((CFCBase*)self_type); CFCBase_decref((CFCBase*)self_var); CFCBase_decref((CFCBase*)return_type); return method; }
static void S_run_composite_tests(CFCTest *test) { CFCParser *parser = CFCParser_new(); CFCParcel *neato_parcel = CFCParcel_new("Neato", NULL, NULL, NULL); CFCParser_set_parcel(parser, neato_parcel); { static const char *type_strings[14] = { "char*", "char**", "char***", "int32_t*", "Obj**", "int8_t[]", "int8_t[1]", "neato_method_t[]", "neato_method_t[1]", "multi_dimensional_t[1][10]", "char * * ", "const Obj**", "const void*", "int8_t[ 3 ]" }; for (int i = 0; i < 14; ++i) { const char *type_string = type_strings[i]; CFCType *type = CFCTest_parse_type(test, parser, type_string); OK(test, CFCType_is_composite(type), "composite type %s", type_string); CFCBase_decref((CFCBase*)type); } } { CFCType *foo = CFCType_new_object(0, neato_parcel, "Foo", 1); CFCType *const_foo = CFCType_new_object(CFCTYPE_CONST, neato_parcel, "Foo", 1); CFCType *composite = CFCType_new_composite(0, foo, 1, NULL); OK(test, CFCType_is_composite(composite), "is_composite"); STR_EQ(test, CFCType_get_specifier(composite), "Foo", "get_specifier delegates to child" ); CFCType *twin = CFCType_new_composite(0, foo, 1, NULL); OK(test, CFCType_equals(composite, twin), "equals"); CFCBase_decref((CFCBase*)twin); CFCType *const_composite = CFCType_new_composite(0, const_foo, 1, NULL); OK(test, !CFCType_equals(composite, const_composite), "equals spoiled by different child"); CFCBase_decref((CFCBase*)const_composite); CFCBase_decref((CFCBase*)composite); CFCBase_decref((CFCBase*)foo); CFCBase_decref((CFCBase*)const_foo); } { CFCType *foo_array = CFCTest_parse_type(test, parser, "foo_t[]"); CFCType_resolve(foo_array); STR_EQ(test, CFCType_get_array(foo_array), "[]", "get_array"); STR_EQ(test, CFCType_to_c(foo_array), "foo_t", "array subscripts not included by to_c"); CFCType *foo_array_array = CFCTest_parse_type(test, parser, "foo_t[][]"); OK(test, !CFCType_equals(foo_array, foo_array_array), "equals spoiled by different array postfixes"); CFCBase_decref((CFCBase*)foo_array); CFCBase_decref((CFCBase*)foo_array_array); } { CFCType *foo_star = CFCTest_parse_type(test, parser, "foo_t*"); CFCType *foo_star_star = CFCTest_parse_type(test, parser, "foo_t**"); OK(test, !CFCType_equals(foo_star, foo_star_star), "equals spoiled by different levels of indirection"); INT_EQ(test, CFCType_get_indirection(foo_star), 1, "foo_t* indirection"); INT_EQ(test, CFCType_get_indirection(foo_star_star), 2, "foo_t** indirection"); CFCBase_decref((CFCBase*)foo_star); CFCBase_decref((CFCBase*)foo_star_star); } CFCBase_decref((CFCBase*)neato_parcel); CFCBase_decref((CFCBase*)parser); }
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(); }