Term* start_building_for_loop(Term* forTerm, const char* iteratorName, Type* iteratorType)
{
Branch* contents = nested_contents(forTerm);
// Add input placeholder for the list input
Term* listInput = apply(contents, FUNCS.input, TermList());
// Add loop_index()
Term* index = apply(contents, FUNCS.loop_index, TermList(listInput));
hide_from_source(index);
// Add get_index to fetch the list's current element.
Term* iterator = apply(contents, FUNCS.get_index, TermList(listInput, index),
name_from_string(iteratorName));
if (iteratorType == NULL)
iteratorType = infer_type_of_get_index(forTerm->input(0));
change_declared_type(iterator, iteratorType);
hide_from_source(iterator);
// Add the zero branch
create_branch_unevaluated(contents, "#zero");
// Add an loop output index
Term* loopOutputIndex = apply(contents, FUNCS.loop_output_index, TermList());
return iterator;
}
Term* if_block_append_case(Term* ifBlock, Term* input)
{
Branch* contents = nested_contents(ifBlock);
int insertPos = 0;
for (int i=0; i < contents->length(); i++) {
Term* term = contents->get(i);
if (term->function == FUNCS.input)
insertPos = term->index + 1;
// Insert position is right after the last non-default case.
if (term->function == FUNCS.case_func && term->input(0) != NULL)
insertPos = term->index + 1;
}
Term* newCase = apply(contents, FUNCS.case_func, TermList(input));
contents->move(newCase, insertPos);
// Add existing input placeholders to this case
for (int i=0;; i++) {
Term* placeholder = get_input_placeholder(contents, i);
if (placeholder == NULL) break;
Term* localPlaceholder = append_input_placeholder(nested_contents(newCase));
change_declared_type(localPlaceholder, placeholder->type);
}
return newCase;
}
Term* if_block_add_input(Term* ifBlock, Term* input)
{
Branch* contents = nested_contents(ifBlock);
int existingInputCount = ifBlock->numInputs();
Term* placeholder = append_input_placeholder(contents);
rename(placeholder, input->name);
change_declared_type(placeholder, input->type);
set_input(ifBlock, existingInputCount, input);
// Add a corresponding input placeholder to each case
for (CaseIterator it(contents); it.unfinished(); it.advance()) {
Term* term = it.current();
Branch* caseContents = nested_contents(term);
Term* casePlaceholder = append_input_placeholder(caseContents);
change_declared_type(casePlaceholder, placeholder->type);
rename(casePlaceholder, input->name);
}
return placeholder;
}
void add_implicit_placeholders(Term* forTerm)
{
Branch* contents = nested_contents(forTerm);
std::string listName = forTerm->input(0)->name;
Term* iterator = for_loop_get_iterator(contents);
std::string iteratorName = iterator->name;
std::vector<std::string> reboundNames;
list_names_that_this_branch_rebinds(contents, reboundNames);
int inputIndex = 1;
for (size_t i=0; i < reboundNames.size(); i++) {
std::string const& name = reboundNames[i];
if (name == listName)
continue;
if (name == iteratorName)
continue;
Term* original = find_name_at(forTerm, name.c_str());
// The name might not be found, for certain parser errors.
if (original == NULL)
continue;
Term* result = contents->get(name);
// Create input_placeholder
Term* input = apply(contents, FUNCS.input, TermList(), name_from_string(name));
Type* type = find_common_type(original->type, result->type);
change_declared_type(input, type);
contents->move(input, inputIndex);
set_input(forTerm, inputIndex, original);
// Repoint terms to use our new input_placeholder
for (BranchIterator it(contents); it.unfinished(); it.advance())
remap_pointers_quick(*it, original, input);
// Create output_placeholder
Term* term = apply(contents, FUNCS.output, TermList(result), name_from_string(name));
// Move output into the correct output slot
contents->move(term, contents->length() - 1 - inputIndex);
inputIndex++;
}
}
Term* start_building_for_loop(Term* forTerm, const char* iteratorName)
{
Branch* contents = nested_contents(forTerm);
// Add input placeholder for the list input
Term* listInput = apply(contents, FUNCS.input, TermList());
// Add loop_index()
Term* index = apply(contents, FUNCS.loop_index, TermList(listInput));
hide_from_source(index);
// Add loop_iterator()
Term* iterator = apply(contents, FUNCS.get_index, TermList(listInput, index),
iteratorName);
change_declared_type(iterator, infer_type_of_get_index(forTerm->input(0)));
hide_from_source(iterator);
return iterator;
}
Term* rebind_possible_accessor(Branch* branch, Term* accessor, Term* result)
{
// Check if this isn't a recognized accessor.
if (!has_empty_name(accessor)) {
// Just create a named copy of 'result'.
return apply(branch, FUNCS.copy, TermList(result), accessor->nameSymbol);
}
TermList accessorChain;
trace_accessor_chain(accessor, &accessorChain);
Term* head = accessorChain[0];
// Create the selector
Term* selector = write_selector_for_accessor_chain(branch, &accessorChain);
Term* set = apply(branch, FUNCS.set_with_selector,
TermList(head, selector, result), head->nameSymbol);
change_declared_type(set, declared_type(head));
return set;
}
void if_block_update_output_placeholder_types_from_cases(Term* ifBlock)
{
Branch* masterContents = nested_contents(ifBlock);
for (int outputIndex=0;; outputIndex++) {
Term* masterPlaceholder = get_output_placeholder(masterContents, outputIndex);
if (masterPlaceholder == NULL)
return;
List types;
// Iterate through each case, and collect the output types
for (int i=0; i < masterContents->length(); i++) {
Term* term = masterContents->get(i);
if (term->function != FUNCS.case_func)
continue;
Term* placeholder = get_output_placeholder(nested_contents(term), outputIndex);
set_type(types.append(), placeholder->type);
}
change_declared_type(masterPlaceholder, find_common_type(&types));
}
}
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;
}
