void round(caStack* stack) { float input = circa_float_input(stack, 0); if (input > 0.0) set_int(circa_output(stack, 0), int(input + 0.5)); else set_int(circa_output(stack, 0), int(input - 0.5)); }
void test_oracle(caStack* stack) { if (list_length(g_oracleValues) == 0) set_null(circa_output(stack, 0)); else { copy(list_get(g_oracleValues, 0), circa_output(stack, 0)); list_remove_index(g_oracleValues, 0); } }
void Branch__get_static_errors(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (is_null(&branch->staticErrors)) set_list(circa_output(stack, 0), 0); else copy(&branch->staticErrors, circa_output(stack, 0)); }
void Type__property(caStack* stack) { Type* type = as_type(circa_input(stack, 0)); const char* str = as_cstring(circa_input(stack, 1)); caValue* prop = get_type_property(type, str); if (prop == NULL) set_null(circa_output(stack, 0)); else copy(prop, circa_output(stack, 0)); }
void Branch__owner(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (branch == NULL) { set_term_ref(circa_output(stack, 0), NULL); return; } set_term_ref(circa_output(stack, 0), branch->owningTerm); }
void String__to_camel_case(caStack* stack) { const char* in = circa_string_input(stack, 0); set_string(circa_output(stack, 0), in); char* out = (char*) as_cstring(circa_output(stack, 0)); if (out[0] == 0) return; out[0] = character_to_lower(out[0]); }
int main(int argc, char** argv) { caWorld* world = circa_initialize(); circa_load_module_from_file(world, "ClassA", "ClassA.ca"); // circa_dump_b(circa_kernel(world)); caStack* stack = circa_alloc_stack(world); circa_push_function_by_name(stack, "create_ClassA"); circa_run(stack); if (circa_has_error(stack)) circa_print_error_to_stdout(stack); caValue* classA = circa_alloc_value(); circa_move(circa_output(stack, 0), classA); circa_pop(stack); // Dump to stdout circa_push_function_by_name(stack, "ClassA.dump"); circa_copy(classA, circa_input(stack, 0)); circa_run(stack); if (circa_has_error(stack)) circa_print_error_to_stdout(stack); circa_pop(stack); for (int i=0; i < 5; i++) { // Increment circa_push_function_by_name(stack, "ClassA.increment"); circa_copy(classA, circa_input(stack, 0)); circa_run(stack); if (circa_has_error(stack)) circa_print_error_to_stdout(stack); // Using index #1 not 0: circa_move(circa_output(stack, 1), classA); circa_pop(stack); // And dump circa_push_function_by_name(stack, "ClassA.dump"); circa_copy(classA, circa_input(stack, 0)); circa_run(stack); if (circa_has_error(stack)) circa_print_error_to_stdout(stack); circa_pop(stack); } circa_dealloc_value(classA); circa_dealloc_stack(stack); circa_shutdown(world); }
void Term__input(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) { circa_output_error(stack, "NULL reference"); return; } int index = circa_int_input(stack, 1); if (index >= t->numInputs()) set_term_ref(circa_output(stack, 0), NULL); else set_term_ref(circa_output(stack, 0), t->input(index)); }
// Unpack a state value. Input 1 is the "identifying term" which is used as a key. void unpack_state(caStack* stack) { caValue* container = circa_input(stack, 0); Term* identifyingTerm = (Term*) circa_caller_input_term(stack, 1); caValue* element = get_field(container, unique_name(identifyingTerm)); if (element == NULL) { set_null(circa_output(stack, 0)); } else { copy(element, circa_output(stack, 0)); } }
void Branch__get_static_errors_formatted(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (branch == NULL) return circa_output_error(stack, "NULL branch"); if (is_null(&branch->staticErrors)) set_list(circa_output(stack, 0), 0); caValue* errors = &branch->staticErrors; caValue* out = circa_output(stack, 0); set_list(out, circa_count(errors)); for (int i=0; i < circa_count(out); i++) format_static_error(circa_index(errors, i), circa_index(out, i)); }
void Term__property(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); const char* key = circa_string_input(stack, 1); caValue* value = term_get_property(t, key); if (value == NULL) set_null(circa_output(stack, 0)); else circa::copy(value, circa_output(stack, 0)); }
void Term__to_string(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); set_string(circa_output(stack, 0), circa::to_string(term_value(t))); }
void Branch__format_function_heading(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); caValue* output = circa_output(stack, 0); circa_set_list(output, 0); function_format_header_source(output, branch); }
void Term__properties(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); circa::copy(&t->properties, circa_output(stack, 0)); }
void Branch__version(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (branch == NULL) return circa_output_error(stack, "NULL branch"); set_int(circa_output(stack, 0), branch->version); }
void Branch__file_signature(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); if (branch == NULL) return circa_output_error(stack, "NULL branch"); List* fileOrigin = branch_get_file_origin(branch); if (fileOrigin == NULL) set_null(circa_output(stack, 0)); else { List* output = set_list(circa_output(stack, 0), 2); copy(fileOrigin->get(1), output->get(0)); copy(fileOrigin->get(2), output->get(1)); } }
void Term__type(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); set_type(circa_output(stack, 0), t->type); }
void Term__function(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); set_branch(circa_output(stack, 0), function_contents(as_function(t->function))); }
void Term__to_source_string(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); set_string(circa_output(stack, 0), get_term_source_text(t)); }
void String__to_upper(caStack* stack) { const char* in = circa_string_input(stack, 0); int len = (int) strlen(in); set_string(circa_output(stack, 0), in); char* out = (char*) as_cstring(circa_output(stack, 0)); for (int i=0; i < len; i++) { char c = in[i]; if (c >= 'a' && c <= 'z') c = c + 'A' - 'a'; out[i] = c; } }
void Map__remove(caStack* stack) { caValue* out = circa_output(stack, 0); copy(circa_input(stack, 0), out); hashtable_remove(out, circa_input(stack, 1)); }
void List__slice(caStack* stack) { caValue* input = circa_input(stack, 0); int start = circa_int_input(stack, 1); int end = circa_int_input(stack, 2); caValue* output = circa_output(stack, 0); if (start < 0) start = 0; else if (start > list_length(input)) start = list_length(input); if (end > list_length(input)) end = list_length(input); else if (end < 0) end = list_length(input) + end; if (end < start) { set_list(output, 0); return; } int length = end - start; set_list(output, length); for (int i=0; i < length; i++) copy(list_get(input, start + i), list_get(output, i)); }
void List__insert(caStack* stack) { caValue* out = circa_output(stack, 0); copy(circa_input(stack, 0), out); copy(circa_input(stack, 1), list_insert(out, circa_int_input(stack, 2))); }
void List__resize(caStack* stack) { caValue* out = circa_output(stack, 0); copy(circa_input(stack, 0), out); int count = circa_int_input(stack, 1); circa_resize(out, count); }
void Dict__get(caStack* stack) { caValue* dict = circa_input(stack, 0); const char* key = circa_string_input(stack, 1); copy(dict_get(dict, key), circa_output(stack, 0)); }
void Term__global_id(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); set_int(circa_output(stack, 0), t->id); }
void Branch__format_source(caStack* stack) { Branch* branch = as_branch(circa_input(stack, 0)); caValue* output = circa_output(stack, 0); circa_set_list(output, 0); format_branch_source((caValue*) output, branch); }
void overload__get_contents(caStack* stack) { Branch* self = (Branch*) circa_branch(circa_input(stack, 0)); caValue* out = circa_output(stack, 0); set_list(out, 0); list_overload_contents(self, out); }
void Term__location_string(caStack* stack) { Term* t = as_term_ref(circa_input(stack, 0)); if (t == NULL) return circa_output_error(stack, "NULL reference"); set_string(circa_output(stack, 0), get_short_location(t).c_str()); }
void set_with_selector_evaluate(caStack* stack) { caValue* out = circa_output(stack, 0); copy(circa_input(stack, 0), out); caValue* selector = circa_input(stack, 1); caValue* newValue = circa_input(stack, 2); circa::Value error; set_with_selector(out, selector, newValue, &error); if (!is_null(&error)) { copy(&error, circa_output(stack, 0)); raise_error(stack); return; } }