void AudioSelector::enableAutoSelect(AudioSource *source, int prio) { assert(branch_map.find(source) != branch_map.end()); Branch *branch = branch_map[source]; branch->setSelectionPrio(prio); branch->enableAutoSelect(); } /* AudioSelector::enableAutoSelect */
void test_snippet(std::string const& source) { Branch branch; branch.compile(source); if (test_fail_on_static_error(&branch)) return; Stack context; evaluate_branch(&context, &branch); if (test_fail_on_runtime_error(context)) return; // Try stripping orphaned state, this should not have an effect. caValue trash; strip_orphaned_state(&branch, &context.state, &trash); if (!is_null(&trash)) { std::cout << "Falsely orphaned state in " << get_current_test_name() << std::endl; std::cout << "Code = " << source << std::endl; std::cout << "Trash = " << trash.toString() << std::endl; declare_current_test_failed(); return; } }
void test_trimmed_state(std::string const& source, std::string const& dest, std::string const& expectedTrash) { Branch sourceBranch; sourceBranch.compile(source); if (test_fail_on_static_error(&sourceBranch)) return; Stack context; evaluate_branch(&context, &sourceBranch); if (test_fail_on_runtime_error(context)) return; Branch destBranch; destBranch.compile(dest); if (test_fail_on_static_error(&destBranch)) return; caValue trash; strip_orphaned_state(&destBranch, &context.state, &trash); if (expectedTrash != trash.toString()) { declare_current_test_failed(); std::cout << "In test " << get_current_test_name() << std::endl; std::cout << expectedTrash << " != " << trash.toString() << std::endl; } }
bool BranchList::add(docstring const & s) { bool added = false; size_t i = 0; while (true) { size_t const j = s.find_first_of(separator_, i); docstring name; if (j == docstring::npos) name = s.substr(i); else name = s.substr(i, j - i); // Is this name already in the list? bool const already = find_if(list.begin(), list.end(), BranchNamesEqual(name)) != list.end(); if (!already) { added = true; Branch br; br.setBranch(name); br.setSelected(false); br.setFileNameSuffix(false); list.push_back(br); } if (j == docstring::npos) break; i = j + 1; } return added; }
void test_state_is_reset_when_if_fails() { Branch branch; Stack context; Term* c = branch.compile("c = true"); branch.compile("if c { state i = 0; i += 1 } else { 'hi' }"); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{i: 1}]}"); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{i: 2}]}"); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{i: 3}]}"); set_bool(c, false); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [null, null]}"); set_bool(c, true); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{i: 1}]}"); }
Tree::Tree(const std::string& name, double initialLength, double initialThickness, int initialBranches, int leavesPerBranch, int leafStartLevel, double thicknessReduction, double lengthReduction, int recursiveDepth, int seed) : SceneNode(name) { totalBranches = 0; totalLeaves = 0; ::initialLength = initialLength; ::initialThickness = initialThickness; ::initialBranches = initialBranches; ::leavesPerBranch = leavesPerBranch; ::leafStartLevel = leafStartLevel; ::thicknessReduction = thicknessReduction; ::lengthReduction = lengthReduction; ::recursiveDepth = recursiveDepth; wood.bump("woodbump.png"); srand( seed ); Branch* trunk = new Branch("Trunk", 0, initialThickness, initialLength); trunk->rotate('x', -90); add_child(trunk); //std::cerr << "Total Branches: " << totalBranches // << " Total Leaves: " << totalLeaves << std::endl; }
Component* Branch::CreatBranch() { Branch *pBranch = new Branch; pBranch->Init(); pBranch->SetSpecial(-1); return pBranch; }
bool RemoteBranchModel::refreshBranches(const QString &workingDirectory, bool remoteBranches, int *currentBranch, QString *errorMessage) { // Run branch command with verbose. QStringList branchArgs; branchArgs << QLatin1String(GitClient::noColorOption) << QLatin1String("-v"); QString output; *currentBranch = -1; if (remoteBranches) branchArgs.push_back(QLatin1String("-r")); if (!runGitBranchCommand(workingDirectory, branchArgs, &output, errorMessage)) return false; if (debug) qDebug() << Q_FUNC_INFO << workingDirectory << output; // Parse output m_workingDirectory = workingDirectory; m_branches.clear(); const QStringList branches = output.split(QLatin1Char('\n')); const int branchCount = branches.size(); bool isCurrent; for (int b = 0; b < branchCount; b++) { Branch newBranch; if (newBranch.parse(branches.at(b), &isCurrent)) { m_branches.push_back(newBranch); if (isCurrent) *currentBranch = b; } } reset(); return true; }
void test_state_is_reset_when_if_fails2() { // Similar to test_state_is_reset_when_if_fails, but this one doesn't // have an 'else' block and it uses test_oracle. internal_debug_function::oracle_clear(); Branch branch; Term* a = branch.compile("a = true"); branch.compile("if a { state s = test_oracle() }"); internal_debug_function::oracle_send(1); internal_debug_function::oracle_send(2); internal_debug_function::oracle_send(3); Stack context; evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{s: 1}]}"); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{s: 1}]}"); set_bool(a, false); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [null, null]}"); set_bool(a, true); evaluate_branch(&context, &branch); test_equals(&context.state, "{_if_block: [{s: 2}]}"); }
void test_type_not_prematurely_used() { // Verify that a circa-defined type is not used until interpreter time. Modifying // a type's release() handler after there are already instances of it, is not good. Branch branch; branch.compile( "type MyType; \n" "def f() -> MyType\n" "def g(MyType t)\n" "s = f()\n" "g(s)\n" "l = [s s s]\n" "type MyCompoundType {\n" " MyType t\n" "}\n" "state MyType st\n" "state MyType st2 = create(MyType)\n" ); Type* myType = (Type*) circa_find_type(&branch, "MyType"); Type* myCompoundType = (Type*) circa_find_type(&branch, "MyCompoundType"); test_assert(!myType->inUse); test_assert(!myCompoundType->inUse); circa::Value value1, value2; create(myType, &value1); create(myCompoundType, &value2); test_assert(myType->inUse); test_assert(myCompoundType->inUse); }
void repro_source_after_rename() { Branch branch; // Simple test Term* a = branch.compile("a = 1"); rename(a, "apple"); test_equals(get_term_source_text(a), "apple = 1"); // Rename a function argument Term* b = branch.compile("b = 5"); Term* add = branch.compile("add( b , 10)"); rename(b, "banana"); test_equals(get_term_source_text(add), "add( banana , 10)"); // Rename a function Term* myfunc = import_function(&branch, NULL, "def myfunc(int)"); Term* myfunc_call = branch.compile("myfunc(555)"); rename(myfunc, "my_renamed_func"); test_equals(get_term_source_text(myfunc_call), "my_renamed_func(555)"); }
void test_lazy() { #ifdef DEFERRED_CALLS_FIRST_DRAFT Branch branch; Term* a = branch.compile("a = add(1 2)"); set_lazy_call(a, true); Stack context; push_frame(&context, &branch); run_interpreter(&context); test_equals(get_register(&context, a), ":Unevaluated"); Frame* frame = push_frame(&context, &branch); frame->pc = a->index; frame->startPc = frame->pc; frame->endPc = frame->pc + 1; frame->strategy = ByDemand; run_interpreter(&context); test_equals(get_register(&context, a), "3"); reset_stack(&context); Term* b = branch.compile("b = add(a a)"); push_frame(&context, &branch); run_interpreter(&context); test_equals(get_register(&context, a), "3"); test_equals(get_register(&context, b), "6"); #endif }
void test_custom_object() { g_currentlyAllocated = 0; g_totalAllocated = 0; Branch branch; branch.compile( "type MyType; \n" "def create_object() -> MyType\n" "def check_object(MyType t)\n" "s = create_object()\n" "check_object(s)\n" ); circa_install_function(&branch, "create_object", create_object); circa_install_function(&branch, "check_object", check_object); circa_setup_object_type(circa_find_type(&branch, "MyType"), sizeof(CustomObject), CustomObjectRelease); // Shouldn't allocate any objects before running. test_equals(g_currentlyAllocated, 0); test_equals(g_totalAllocated, 0); Stack stack; push_frame(&stack, &branch); run_interpreter(&stack); test_assert(&stack); circa_clear_stack(&stack); // Running the script should only cause 1 object allocation. test_equals(g_currentlyAllocated, 0); test_equals(g_totalAllocated, 1); }
void bug_reproducing_list_after_eval() { // There once was a bug where source repro would fail when using a list // in a vectorized function, but only after that piece of code had been // evaluated. This was because vectorize_vv was calling apply() which // was changing the 'statement' property of its inputs. Branch branch; Term* sum = branch.compile("[1 1] + [1 1]"); Term* in0 = sum->input(0); Term* in1 = sum->input(0); test_equals(get_term_source_text(in0), "[1 1]"); test_equals(get_term_source_text(in1), "[1 1]"); test_equals(get_input_source_text(sum, 0), "[1 1] "); test_equals(get_input_source_text(sum, 1), " [1 1]"); test_equals(get_branch_source_text(&branch), "[1 1] + [1 1]"); evaluate_branch(&branch); test_equals(get_term_source_text(in0), "[1 1]"); test_equals(get_term_source_text(in1), "[1 1]"); test_equals(get_input_source_text(sum, 0), "[1 1] "); test_equals(get_input_source_text(sum, 1), " [1 1]"); test_equals(get_branch_source_text(&branch), "[1 1] + [1 1]"); }
std::string cpp_accessor_for_type(Type* type) { #if 0 std::stringstream out; std::string indent = " "; out << "struct " << get_cpp_type_name(type) << "\n"; out << "{\n"; out << indent << "Term* _term\n"; out << "\n"; out << indent << get_cpp_type_name(type) << "(Term* term) : _term(term) {}\n"; out << "\n"; Branch* prototype = type->prototype; for (int i=0; i < prototype.length(); i++) { Term* field = prototype[i]; out << indent << get_cpp_type_name(field->type) << "& " << field->name << "() "; out << "{ return " << get_cpp_type_accessor(field->type) << "(_term->field(" << i << ")); }\n"; } out << "};\n"; return out.str(); #endif return ""; }
void assign_output_type() { Branch branch; branch.compile("a = [1]"); Term* assign = branch.compile("a[0] = 2"); test_equals(assign->type->name, "List"); }
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; }
static vector<Segment> segmentsFromBranch(const Branch& branch) { vector<Segment> segments = branch.body(); for (const auto& childBranch : branch.branches()) { auto branchSegments = segmentsFromBranch(childBranch); move(begin(branchSegments), end(branchSegments), back_inserter(segments)); } return segments; }
void infer_type_of_append() { Branch branch; branch.compile("a = []"); branch.compile("a.append(1)"); Term* b = branch.compile("a[0]"); test_equals(b->type->name, "int"); }
void for_loop_output_type() { Branch branch; branch.compile("a = 1"); branch.compile("for i in [1] { a = 2 }"); test_equals(branch["a"]->type->name, "int"); }
int if_block_count_cases(Term* term) { Branch* contents = nested_contents(term); int result = 0; for (int i=0; i < contents->length(); i++) if (contents->get(i) != NULL && contents->get(i)->function == FUNCS.case_func) result++; return result; }
void AudioSplitter::addSink(AudioSink *sink, bool managed) { Branch *branch = new Branch(this, sink, managed); branches.push_back(branch); if (do_flush) { branch->sinkFlushSamples(); } } /* AudioSplitter::addSink */
void Branch__get_term(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (branch == NULL) return circa_output_error(stack, "NULL branch"); int index = circa_int_input(stack, 1); set_term_ref(circa_output(stack, 0), branch->get(index)); }
/** * Calculates contributions to partial derivatives of LL function wrt * each of the model parameters for current data bin. Contributions are * added to totals in provided deriv argument. */ static void calc_deriv(BkgdEvoMdlParam *ll_deriv, BkgdEvoMdlConfig *conf, const BkgdEvoMdlParam *param, const BkgdBin *bin) { Branch *br; ColType *cltype; int i; double coef; /* calculate branch length and branch substitution probability * partial derivatives */ for(i = 0; i < conf->n_branch; i++) { br = &conf->branches[i]; br->set_dlen(br, bin, param); branch_set_dprob(br, bin, param, conf); } /* calculate column probability partial derivatives */ for(i = 0; i < conf->n_cltype; i++) { cltype = conf->cltypes[i]; if(cltype->subst_type == SUBST_TYPE_CONSERVED) { /* only do columns with substitutions in first step */ continue; } cltype_set_dprob(cltype, param, conf); if(cltype->n > 0) { /* add contribution to LL partial derivs */ coef = cltype->n / cltype->prob; if(isnan(coef)) { fprintf(stderr, "nan coef, cltype->name=%s, cltype->n=%ld, " "cltype->prob=%g\n",cltype->name, cltype->n, cltype->prob); } param_add(&cltype->dprob, coef, ll_deriv); } } /* now conserved column */ if(conf->cons_cltype != NULL) { cltype = conf->cons_cltype; cltype_cons_set_dprob(cltype, param, conf); if(cltype->n) { /* add contribution to LL partial derivs */ coef = cltype->n / cltype->prob; param_add(&cltype->dprob, coef, ll_deriv); } } return; }
int run_repl() { Stack context; Branch branch; bool displayRaw = false; push_frame(&context, &branch); while (true) { std::cout << "> "; std::string input; if (!std::getline(std::cin, input)) break; if (input == "exit" || input == "/exit") break; if (input == "") continue; if (input == "/raw") { displayRaw = !displayRaw; if (displayRaw) std::cout << "Displaying raw output" << std::endl; else std::cout << "Not displaying raw output" << std::endl; continue; } if (input == "/clear") { clear_branch(&branch); std::cout << "Cleared working area" << std::endl; continue; } if (input == "/dump") { dump(&branch); continue; } if (input == "/help") { std::cout << "Special commands: /raw, /help, /clear, /dump, /exit" << std::endl; continue; } int previousHead = branch.length(); repl_evaluate_line(&context, input, std::cout); if (displayRaw) { for (int i=previousHead; i < branch.length(); i++) { std::cout << get_term_to_string_extended(branch[i]) << std::endl; if (nested_contents(branch[i])->length() > 0) print_branch(std::cout, nested_contents(branch[i])); } } } return 0; }
void test_refs_are_destruction_safe() { Branch branch; Term* a = branch.compile("a = 1"); caValue ref; set_ref(&ref, a); test_assert(as_ref(&ref) == a); clear_branch(&branch); test_assert(as_ref(&ref) == NULL); }
void Branch__find_term(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (branch == NULL) return circa_output_error(stack, "NULL branch"); Term* term = branch->get(circa_string_input(stack, 1)); set_term_ref(circa_output(stack, 0), term); }
void test_dont_always_rebind_inner_names() { Branch branch; branch.compile("if false { b = 1 } elif false { c = 1 } elif false { d = 1 } else { e = 1 }"); evaluate_branch(&branch); test_assert(!branch.contains("b")); test_assert(!branch.contains("c")); test_assert(!branch.contains("d")); test_assert(!branch.contains("e")); }
void compare_builtin_types() { Branch branch; Term* aFloat = branch.compile("1.2"); test_assert(term_output_always_satisfies_type(aFloat, unbox_type(FLOAT_TYPE))); test_assert(term_output_never_satisfies_type(aFloat, unbox_type(INT_TYPE))); Term* anInt = branch.compile("1"); test_assert(term_output_always_satisfies_type(anInt, unbox_type(FLOAT_TYPE))); test_assert(term_output_always_satisfies_type(anInt, unbox_type(INT_TYPE))); }
const char* switch_getOutputName(Term* term, int outputIndex) { Branch* contents = nested_contents(term); // check if term is still being initialized: if (contents->length() == 0) return ""; Branch* outerRebinds = contents->getFromEnd(0)->contents(); return outerRebinds->get(outputIndex - 1)->name.c_str(); }