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;
}
}
