// For the given field name static Term* find_output_term_for_state_field(Branch* branch, const char* fieldName, int position) { Term* result = find_from_unique_name(branch, fieldName); // For declared state, the result is the last term with the given name if (result->function == FUNCS.declared_state) { return find_local_name(branch, result->name.c_str(), position); } ca_assert(result != NULL); // This term might be the actual state result, or the state result might be // found in an extra output. Look around and see if this term has a stateful // extra output. for (int outputIndex=0;; outputIndex++) { Term* extraOutput = get_extra_output(result, outputIndex); if (extraOutput == NULL) break; if (is_state_output(extraOutput)) return extraOutput; } return result; }
void insert_looped_placeholders(Block* contents) { Value names; list_names_that_must_be_looped(contents, &names); for (ListIterator it(&names); it; ++it) { Term* inputPlaceholder = append_input_placeholder(contents); Value* name = it.value(); rename(inputPlaceholder, name); Value owningTermVal; owningTermVal.set_term(contents->owningTerm); Term* outsideTerm = find_name_at(&owningTermVal, name); Term* innerResult = find_local_name(contents, name); Term* outputPlaceholder = append_output_placeholder(contents, innerResult); rename(outputPlaceholder, name); set_inputs(inputPlaceholder, TermList(outsideTerm, outputPlaceholder)); for (BlockInputIterator it(contents); it; ++it) { Term* term = it.currentTerm(); if (it.currentInput() == outsideTerm && term != inputPlaceholder) set_input(term, it.currentInputIndex(), inputPlaceholder); } } }
void for_loop_remake_zero_branch(Branch* forContents) { Branch* zero = for_loop_get_zero_branch(forContents); clear_branch(zero); // Clone inputs for (int i=0;; i++) { Term* placeholder = get_input_placeholder(forContents, i); if (placeholder == NULL) break; Term* clone = append_input_placeholder(zero); rename(clone, placeholder->nameSymbol); } Term* loopOutput = create_list(zero); // Clone outputs for (int i=0;; i++) { Term* placeholder = get_output_placeholder(forContents, i); if (placeholder == NULL) break; // Find the appropriate connection Term* result = find_local_name(zero, placeholder->name.c_str()); if (i == 0) result = loopOutput; Term* clone = append_output_placeholder(zero, result); rename(clone, placeholder->nameSymbol); } branch_finish_changes(zero); }
void Block__term_named(VM* vm) { Block* block = as_block(vm->input(0)); if (block == NULL) return vm->throw_str("NULL block"); Value* name = vm->input(1); set_term_ref(vm->output(), find_local_name(block, name)); }
void native_patch_apply_patch(NativePatch* module, Block* block) { // Walk through list of patches, and try to find any functions to apply them to. std::map<std::string, EvaluateFunc>::const_iterator it; for (it = module->patches.begin(); it != module->patches.end(); ++it) { std::string const& name = it->first; EvaluateFunc evaluateFunc = it->second; Term* term = find_local_name(block, name.c_str()); if (term == NULL) continue; if (!is_function(term)) continue; install_function(term, evaluateFunc); } }
void block_link_missing_functions(Block* block, Block* source) { for (BlockIterator it(block); it; ++it) { Term* term = *it; if (term->function == NULL || term->function == FUNCS.unknown_function || term->function == FUNCS.unknown_function_prelude) { std::string funcName = term->stringProp(s_Syntax_FunctionName, ""); if (funcName == "") continue; // try to find this function Term* func = find_local_name(source, funcName.c_str(), s_LookupFunction); if (func != NULL) change_function(term, func); } } }
Term* Block::operator[](std::string const& name) { return find_local_name(this, name.c_str()); }
Term* Block::getNamed(const char* name) { return find_local_name(this, name); }