Branch* load_module(const char* module_name, Term* loadCall)
{
Branch* existing = find_loaded_module(module_name);
if (existing != NULL)
return existing;
Value filename;
bool found = find_module_file(module_name, &filename);
if (!found)
return NULL;
Term* import = load_module_from_file(module_name, as_cstring(&filename))->owningTerm;
// If a loadCall is provided, possibly move the new import to be before the loadCall.
if (loadCall != NULL) {
Term* callersModule = find_parent_term_in_branch(loadCall, import->owningBranch);
if (callersModule != NULL && (import->index > callersModule->index))
move_before(import, callersModule);
}
// If the module has static errors, print them now.
print_static_errors_formatted(nested_contents(import));
return nested_contents(import);
}
void for_loop_fix_state_input(Branch* contents)
{
// This function will look at the state access inside for-loop contents.
// If there's state, the default building functions will have created
// terms that look like this:
//
// input() :state -> unpack_state -> pack_state -> output() :state
//
// We want each loop iteration to have its own state container. So we'll
// insert pack/unpack_state_list_n terms so that each iteration accesses
// state from a list. The result will look like:
//
// input() :state -> unpack_state_list_n(index) -> unpack_state -> pack_state
// -> pack_state_list_n(index) -> output() :state
// First insert the unpack_state_list_n call
Term* stateInput = find_state_input(contents);
// Nothing to do if there's no state input
if (stateInput == NULL)
return;
// Nothing to do if unpack_state_list_n term already exists
if (find_user_with_function(stateInput, FUNCS.unpack_state_list_n) != NULL)
return;
Term* unpackState = find_user_with_function(stateInput, FUNCS.unpack_state);
ca_assert(unpackState != NULL);
Term* index = for_loop_find_index(contents);
Term* unpackStateList = apply(contents, FUNCS.unpack_state_list_n,
TermList(stateInput, index));
transfer_users(stateInput, unpackStateList);
move_before(unpackStateList, unpackState);
set_input(unpackState, 0, unpackStateList);
// Now insert the pack_state_list_n call
Term* stateResult = find_open_state_result(contents, contents->length());
Term* packStateList = apply(contents, FUNCS.pack_state_list_n,
TermList(stateInput, stateResult, index));
packStateList->setBoolProp("final", true);
move_after(packStateList, stateResult);
// Make sure the state output uses this result
Term* stateOutput = append_state_output(contents);
set_input(stateOutput, 0, packStateList);
}
void block_update_pack_state_calls(Block* block)
{
if (block->stateType == NULL) {
// No state type, make sure there's no pack_state call.
// TODO: Handle this case properly (should search and destroy an existing pack_state call)
return;
}
int stateOutputIndex = block->length() - 1 - find_state_output(block)->index;
for (int i=0; i < block->length(); i++) {
Term* term = block->get(i);
if (term == NULL)
continue;
if (term->function == FUNCS.pack_state) {
// Update the inputs for this pack_state call
TermList inputs;
list_inputs_to_pack_state(block, i, &inputs);
set_inputs(term, inputs);
}
else if (should_have_preceeding_pack_state(term)) {
// Check if we need to insert a pack_state call
Term* existing = term->input(stateOutputIndex);
if (existing == NULL || existing->function != FUNCS.pack_state) {
TermList inputs;
list_inputs_to_pack_state(block, i, &inputs);
if (inputs.length() != 0) {
Term* pack_state = apply(block, FUNCS.pack_state, inputs);
move_before(pack_state, term);
// Only set as an input for a non-minor block.
if (term->nestedContents == NULL || !is_minor_block(term->nestedContents)) {
set_input(term, stateOutputIndex, pack_state);
set_input_hidden(term, stateOutputIndex, true);
set_input_implicit(term, stateOutputIndex, true);
}
// Advance i to compensate for the term just added
i++;
}
}
}
}
}
void branch_update_existing_pack_state_calls(Branch* branch)
{
if (branch->stateType == NULL) {
// No state type, make sure there's no pack_state call.
// TODO: Handle this case properly (should search and destroy an existing pack_state call)
return;
}
int stateOutputIndex = branch->length() - 1 - find_state_output(branch)->index;
for (int i=0; i < branch->length(); i++) {
Term* term = branch->get(i);
if (term == NULL)
continue;
if (term->function == FUNCS.pack_state) {
// Update the inputs for this pack_state call
TermList inputs;
get_list_of_state_outputs(branch, i, &inputs);
set_inputs(term, inputs);
}
if (term->function == FUNCS.exit_point) {
// Check if we need to insert a pack_state call
Term* existing = term->input(stateOutputIndex);
if (existing == NULL || existing->function != FUNCS.pack_state) {
TermList inputs;
get_list_of_state_outputs(branch, i, &inputs);
if (inputs.length() != 0) {
Term* pack_state = apply(branch, FUNCS.pack_state, inputs);
move_before(pack_state, term);
set_input(term, stateOutputIndex + 1, pack_state);
// Advance i to compensate for the term just added
i++;
}
}
}
}
}
