void metaprogramming_install_functions(Branch* kernel) { static const ImportRecord records[] = { {"term_ref", term_ref}, {"branch_ref", branch_ref}, {"Branch.input", Branch__input}, {"Branch.inputs", Branch__inputs}, {"Branch.is_null", Branch__is_null}, {"Branch.output", Branch__output}, {"Branch.outputs", Branch__outputs}, {"Branch.owner", Branch__owner}, {"Branch.dump", Branch__dump}, {"Branch.call", Branch__call}, {"Branch.file_signature", Branch__file_signature}, {"Branch.statements", Branch__statements}, {"Branch.format_source", Branch__format_source}, {"Branch.format_function_heading", Branch__format_function_heading}, {"Branch.get_term", Branch__get_term}, {"Branch.get_static_errors", Branch__get_static_errors}, {"Branch.get_static_errors_formatted", Branch__get_static_errors_formatted}, {"Branch.has_static_error", Branch__has_static_error}, {"Branch.list_configs", Branch__list_configs}, {"Branch.find_term", Branch__find_term}, {"Branch.functions", Branch__functions}, {"Branch.terms", Branch__terms}, {"Branch.version", Branch__version}, {"Branch.link", Branch__link}, {"Term.assign", Term__assign}, {"Term.asint", Term__asint}, {"Term.asfloat", Term__asfloat}, {"Term.function", Term__function}, {"Term.get_type", Term__type}, {"Term.tweak", Term__tweak}, {"Term.input", Term__input}, {"Term.inputs", Term__inputs}, {"Term.name", Term__name}, {"Term.num_inputs", Term__num_inputs}, {"Term.parent", Term__parent}, {"Term.contents", Term__contents}, {"Term.is_null", Term__is_null}, {"Term.source_location", Term__source_location}, {"Term.location_string", Term__location_string}, {"Term.global_id", Term__global_id}, {"Term.to_string", Term__to_string}, {"Term.to_source_string", Term__to_source_string}, {"Term.properties", Term__properties}, {"Term.property", Term__property}, {"Term.value", Term__value}, {"is_overloaded_func", is_overloaded_func}, {"overload:get_contents", overload__get_contents}, {NULL, NULL} }; install_function_list(kernel, records); }
void bootstrap_kernel() { // First, instanciate the types that are used by Type. TYPES.dict = create_type_uninitialized(); TYPES.null = create_type_uninitialized(); TYPES.string = create_type_uninitialized(); TYPES.type = create_type_uninitialized(); initialize_type(TYPES.dict); initialize_type(TYPES.null); initialize_type(TYPES.string); initialize_type(TYPES.type); string_setup_type(TYPES.string); // Initialize remaining global types. TYPES.any = create_type(); TYPES.block = create_type(); TYPES.bool_type = create_type(); TYPES.error = create_type(); TYPES.eval_context = create_type(); TYPES.float_type = create_type(); TYPES.function = create_type(); TYPES.int_type = create_type(); TYPES.list = create_type(); TYPES.map = create_type(); TYPES.opaque_pointer = create_type(); TYPES.symbol = create_type(); TYPES.term = create_type(); TYPES.void_type = create_type(); any_t::setup_type(TYPES.any); block_setup_type(TYPES.block); bool_t::setup_type(TYPES.bool_type); dict_t::setup_type(TYPES.dict); eval_context_t::setup_type(TYPES.eval_context); function_t::setup_type(TYPES.function); hashtable_setup_type(TYPES.map); int_t::setup_type(TYPES.int_type); list_t::setup_type(TYPES.list); symbol_setup_type(TYPES.symbol); null_t::setup_type(TYPES.null); number_t::setup_type(TYPES.float_type); opaque_pointer_t::setup_type(TYPES.opaque_pointer); term_setup_type(TYPES.term); string_setup_type(TYPES.error); // errors are just stored as strings for now type_t::setup_type(TYPES.type); void_t::setup_type(TYPES.void_type); // Start building World g_world = alloc_world(); g_world->bootstrapStatus = sym_Bootstrapping; // Create root Block. g_world->root = new Block(); Block* kernel = g_world->root; // Create value function Term* valueFunc = kernel->appendNew(); rename(valueFunc, "value"); FUNCS.value = valueFunc; // Create Type type Term* typeType = kernel->appendNew(); typeType->function = FUNCS.value; typeType->type = TYPES.type; term_value(typeType)->value_type = TYPES.type; term_value(typeType)->value_data.ptr = TYPES.type; TYPES.type->declaringTerm = typeType; rename(typeType, "Type"); // Create Any type Term* anyType = kernel->appendNew(); anyType->function = valueFunc; anyType->type = TYPES.type; term_value(anyType)->value_type = TYPES.type; term_value(anyType)->value_data.ptr = TYPES.any; TYPES.any->declaringTerm = anyType; rename(anyType, "any"); // Create Function type Term* functionType = kernel->appendNew(); functionType->function = valueFunc; functionType->type = TYPES.type; TYPES.function->declaringTerm = functionType; term_value(functionType)->value_type = TYPES.type; term_value(functionType)->value_data.ptr = TYPES.function; rename(functionType, "Function"); // Initialize value() func valueFunc->type = TYPES.function; valueFunc->function = valueFunc; make(TYPES.function, term_value(valueFunc)); function_t::initialize(TYPES.function, term_value(valueFunc)); initialize_function(valueFunc); as_function(valueFunc)->name = "value"; block_set_evaluation_empty(function_contents(valueFunc), true); // Initialize primitive types (this requires value() function) create_type_value(kernel, TYPES.bool_type, "bool"); create_type_value(kernel, TYPES.block, "Block"); create_type_value(kernel, TYPES.dict, "Dict"); create_type_value(kernel, TYPES.float_type, "number"); create_type_value(kernel, TYPES.int_type, "int"); create_type_value(kernel, TYPES.list, "List"); create_type_value(kernel, TYPES.opaque_pointer, "opaque_pointer"); create_type_value(kernel, TYPES.string, "String"); create_type_value(kernel, TYPES.symbol, "Symbol"); create_type_value(kernel, TYPES.term, "Term"); create_type_value(kernel, TYPES.void_type, "void"); create_type_value(kernel, TYPES.map, "Map"); // Finish initializing World (this requires List and Hashtable types) world_initialize(g_world); // Create global symbol table (requires Hashtable type) symbol_initialize_global_table(); // Setup output_placeholder() function, needed to declare functions properly. FUNCS.output = create_value(kernel, TYPES.function, "output_placeholder"); function_t::initialize(TYPES.function, term_value(FUNCS.output)); initialize_function(FUNCS.output); as_function(FUNCS.output)->name = "output_placeholder"; as_function(FUNCS.output)->evaluate = NULL; as_function(FUNCS.output)->specializeType = output_placeholder_specializeType; ca_assert(function_get_output_type(FUNCS.output, 0) == TYPES.any); // Fix some holes in value() function { Function* attrs = as_function(valueFunc); Term* output = append_output_placeholder(function_contents(attrs), NULL); change_declared_type(output, TYPES.any); finish_building_function(function_contents(attrs)); } ca_assert(function_get_output_type(valueFunc, 0) == TYPES.any); // input_placeholder() is needed before we can declare a function with inputs FUNCS.input = import_function(kernel, NULL, "input_placeholder() -> any"); block_set_evaluation_empty(function_contents(FUNCS.input), true); // Now that we have input_placeholder() let's declare one input on output_placeholder() apply(function_contents(as_function(FUNCS.output)), FUNCS.input, TermList())->setBoolProp("optional", true); namespace_function::early_setup(kernel); // Setup declare_field() function, needed to represent compound types. FUNCS.declare_field = import_function(kernel, NULL, "declare_field() -> any"); // Initialize a few more types Term* set_type = create_value(kernel, TYPES.type, "Set"); set_t::setup_type(unbox_type(set_type)); Term* indexableType = create_value(kernel, TYPES.type, "Indexable"); indexable_t::setup_type(unbox_type(indexableType)); TYPES.selector = unbox_type(create_value(kernel, TYPES.type, "Selector")); list_t::setup_type(TYPES.selector); control_flow_setup_funcs(kernel); selector_setup_funcs(kernel); loop_setup_functions(kernel); // Setup all the builtin functions defined in src/functions setup_builtin_functions(kernel); FUNCS.section_block = import_function(kernel, NULL, "def section_block() -> any"); as_function(FUNCS.section_block)->formatSource = section_block_formatSource; // Create IMPLICIT_TYPES (deprecated) type_initialize_kernel(kernel); // Now we can build derived functions // Create overloaded functions FUNCS.add = create_overloaded_function(kernel, "add(any a,any b) -> any"); append_to_overloaded_function(FUNCS.add, FUNCS.add_i); append_to_overloaded_function(FUNCS.add, FUNCS.add_f); Term* less_than = create_overloaded_function(kernel, "less_than(any a,any b) -> bool"); append_to_overloaded_function(less_than, kernel->get("less_than_i")); append_to_overloaded_function(less_than, kernel->get("less_than_f")); Term* less_than_eq = create_overloaded_function(kernel, "less_than_eq(any a,any b) -> bool"); append_to_overloaded_function(less_than_eq, kernel->get("less_than_eq_i")); append_to_overloaded_function(less_than_eq, kernel->get("less_than_eq_f")); Term* greater_than = create_overloaded_function(kernel, "greater_than(any a,any b) -> bool"); append_to_overloaded_function(greater_than, kernel->get("greater_than_i")); append_to_overloaded_function(greater_than, kernel->get("greater_than_f")); Term* greater_than_eq = create_overloaded_function(kernel, "greater_than_eq(any a,any b) -> bool"); append_to_overloaded_function(greater_than_eq, kernel->get("greater_than_eq_i")); append_to_overloaded_function(greater_than_eq, kernel->get("greater_than_eq_f")); Term* max_func = create_overloaded_function(kernel, "max(any a,any b) -> any"); append_to_overloaded_function(max_func, kernel->get("max_i")); append_to_overloaded_function(max_func, kernel->get("max_f")); Term* min_func = create_overloaded_function(kernel, "min(any a,any b) -> any"); append_to_overloaded_function(min_func, kernel->get("min_i")); append_to_overloaded_function(min_func, kernel->get("min_f")); Term* remainder_func = create_overloaded_function(kernel, "remainder(any a,any b) -> any"); append_to_overloaded_function(remainder_func, kernel->get("remainder_i")); append_to_overloaded_function(remainder_func, kernel->get("remainder_f")); Term* mod_func = create_overloaded_function(kernel, "mod(any a,any b) -> any"); append_to_overloaded_function(mod_func, kernel->get("mod_i")); append_to_overloaded_function(mod_func, kernel->get("mod_f")); FUNCS.mult = create_overloaded_function(kernel, "mult(any a,any b) -> any"); append_to_overloaded_function(FUNCS.mult, kernel->get("mult_i")); append_to_overloaded_function(FUNCS.mult, kernel->get("mult_f")); FUNCS.neg = create_overloaded_function(kernel, "neg(any n) -> any"); append_to_overloaded_function(FUNCS.neg, kernel->get("neg_i")); append_to_overloaded_function(FUNCS.neg, kernel->get("neg_f")); as_function(FUNCS.neg)->formatSource = neg_function::formatSource; FUNCS.sub = create_overloaded_function(kernel, "sub(any a,any b) -> any"); append_to_overloaded_function(FUNCS.sub, kernel->get("sub_i")); append_to_overloaded_function(FUNCS.sub, kernel->get("sub_f")); // Create vectorized functions Term* add_v = create_function(kernel, "add_v"); create_function_vectorized_vv(function_contents(add_v), FUNCS.add, TYPES.list, TYPES.list); Term* add_s = create_function(kernel, "add_s"); create_function_vectorized_vs(function_contents(add_s), FUNCS.add, TYPES.list, TYPES.any); append_to_overloaded_function(FUNCS.add, add_v); append_to_overloaded_function(FUNCS.add, add_s); Term* sub_v = create_function(kernel, "sub_v"); create_function_vectorized_vv(function_contents(sub_v), FUNCS.sub, TYPES.list, TYPES.list); Term* sub_s = create_function(kernel, "sub_s"); create_function_vectorized_vs(function_contents(sub_s), FUNCS.sub, TYPES.list, TYPES.any); append_to_overloaded_function(FUNCS.sub, sub_v); append_to_overloaded_function(FUNCS.sub, sub_s); // Create vectorized mult() functions Term* mult_v = create_function(kernel, "mult_v"); create_function_vectorized_vv(function_contents(mult_v), FUNCS.mult, TYPES.list, TYPES.list); Term* mult_s = create_function(kernel, "mult_s"); create_function_vectorized_vs(function_contents(mult_s), FUNCS.mult, TYPES.list, TYPES.any); append_to_overloaded_function(FUNCS.mult, mult_v); append_to_overloaded_function(FUNCS.mult, mult_s); Term* div_s = create_function(kernel, "div_s"); create_function_vectorized_vs(function_contents(div_s), FUNCS.div, TYPES.list, TYPES.any); // Need dynamic_method before any hosted functions FUNCS.dynamic_method = import_function(kernel, dynamic_method_call, "def dynamic_method(any inputs :multiple) -> any"); // Load the standard library from stdlib.ca parser::compile(kernel, parser::statement_list, STDLIB_CA_TEXT); // Install C functions static const ImportRecord records[] = { {"assert", hosted_assert}, {"cppbuild:build_module", cppbuild_function::build_module}, {"file:version", file__version}, {"file:exists", file__exists}, {"file:read_text", file__read_text}, {"length", length}, {"from_string", from_string}, {"to_string_repr", to_string_repr}, {"call_actor", call_actor_func}, {"send", send_func}, {"test_spy", test_spy}, {"test_oracle", test_oracle}, {"refactor:rename", refactor__rename}, {"refactor:change_function", refactor__change_function}, {"reflect:this_block", reflect__this_block}, {"reflect:kernel", reflect__kernel}, {"sys:module_search_paths", sys__module_search_paths}, {"sys:perf_stats_reset", sys__perf_stats_reset}, {"sys:perf_stats_dump", sys__perf_stats_dump}, {"Dict.count", Dict__count}, {"Dict.get", Dict__get}, {"Dict.set", Dict__set}, {"Function.block", Function__block}, {"empty_list", empty_list}, {"List.append", List__append}, {"List.concat", List__concat}, {"List.resize", List__resize}, {"List.count", List__count}, {"List.insert", List__insert}, {"List.length", List__length}, {"List.join", List__join}, {"List.slice", List__slice}, {"List.get", List__get}, {"List.set", List__set}, {"Map.contains", Map__contains}, {"Map.remove", Map__remove}, {"Map.get", Map__get}, {"Map.set", Map__set}, {"Map.insertPairs", Map__insertPairs}, {"Mutable.get", Mutable__get}, {"Mutable.set", Mutable__set}, {"String.char_at", String__char_at}, {"String.ends_with", String__ends_with}, {"String.length", String__length}, {"String.substr", String__substr}, {"String.slice", String__slice}, {"String.starts_with", String__starts_with}, {"String.split", String__split}, {"String.to_camel_case", String__to_camel_case}, {"String.to_upper", String__to_upper}, {"String.to_lower", String__to_lower}, {"Type.name", Type__name}, {"Type.property", Type__property}, {"Type.declaringTerm", Type__declaringTerm}, {"type", typeof_func}, {"static_type", static_type_func}, {NULL, NULL} }; install_function_list(kernel, records); closures_install_functions(kernel); modules_install_functions(kernel); reflection_install_functions(kernel); interpreter_install_functions(kernel); // Fetch refereneces to certain builtin funcs. FUNCS.block_dynamic_call = kernel->get("Block.call"); FUNCS.dll_patch = kernel->get("sys:dll_patch"); FUNCS.dynamic_call = kernel->get("dynamic_call"); FUNCS.has_effects = kernel->get("has_effects"); FUNCS.length = kernel->get("length"); FUNCS.list_append = kernel->get("List.append"); FUNCS.native_patch = kernel->get("native_patch"); FUNCS.not_func = kernel->get("not"); FUNCS.output_explicit = kernel->get("output"); FUNCS.type = kernel->get("type"); block_set_has_effects(nested_contents(FUNCS.has_effects), true); // Finish setting up some hosted types TYPES.actor = as_type(kernel->get("Actor")); TYPES.color = as_type(kernel->get("Color")); TYPES.closure = as_type(kernel->get("Closure")); callable_t::setup_type(as_type(kernel->get("Callable"))); TYPES.frame = as_type(kernel->get("Frame")); TYPES.point = as_type(kernel->get("Point")); TYPES.file_signature = as_type(kernel->get("FileSignature")); Type* mutableType = as_type(kernel->get("Mutable")); circa_setup_object_type(mutableType, sizeof(Value), MutableRelease); mutableType->initialize = MutableInitialize; color_t::setup_type(TYPES.color); as_function(FUNCS.list_append)->specializeType = List__append_specializeType; }