Experiments
/
libabacus
1
0
Fork 0
Code Issues 4 Pull Requests Releases Wiki Activity

Use the unit type correctly instead of null references.

This commit is contained in:
Danila Fedorin 2018-06-02 16:06:13 -07:00
parent 8207f1f450
commit 62dd41e634
4 changed files with 46 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/libabacus.h
View File

@ -182,6 +182,13 @@ void libab_get_type_function_list(libab* ab, libab_ref* into);
*/
void libab_get_type_unit(libab* ab, libab_ref* into);
/**
* Gets the unit value form this libab instance.
* @param ab the instance to get the unit value from.
* @param into the reference into which to store the unit value.
*/
void libab_get_unit_value(libab* ab, libab_ref* into);
/**
* Executes the given string of code.
* @param ab the libabacus instance to use for executing code.

50
src/interactive.c
View File

@ -2,6 +2,7 @@
#include "util.h"
#include "value.h"
#include <stdio.h>
#include <math.h>
#define TRY(expression) \
if (result == LIBAB_SUCCESS) \
@ -18,25 +19,6 @@ void* impl_parse(const char* string) {
void impl_free(void* data) { free(data); }
libab_result function_atan(libab* ab, libab_ref_vec* params, libab_ref* into) {
printf("atan called\n");
libab_ref_null(into);
return LIBAB_SUCCESS;
}
libab_result function_atan2(libab* ab, libab_ref_vec* params, libab_ref* into) {
printf("atan2 called\n");
libab_ref_null(into);
return LIBAB_SUCCESS;
}
libab_result function_print_num(libab* ab, libab_ref_vec* params, libab_ref* into) {
double* param = libab_unwrap_param(params, 0);
printf("%f\n", *param);
libab_ref_null(into);
return LIBAB_SUCCESS;
}
libab_result create_double_value(libab* ab, double val, libab_ref* into) {
libab_ref type_num;
libab_result result = LIBAB_SUCCESS;
@ -56,6 +38,32 @@ libab_result create_double_value(libab* ab, double val, libab_ref* into) {
return result;
}
libab_result function_atan(libab* ab, libab_ref_vec* params, libab_ref* into) {
printf("atan called\n");
double* val = libab_unwrap_param(params, 0);
return create_double_value(ab, atan(*val), into);
}
libab_result function_atan2(libab* ab, libab_ref_vec* params, libab_ref* into) {
printf("atan2 called\n");
double* left = libab_unwrap_param(params, 0);
double* right = libab_unwrap_param(params, 1);
return create_double_value(ab, atan2(*left, *right), into);
}
libab_result function_print_num(libab* ab, libab_ref_vec* params, libab_ref* into) {
double* param = libab_unwrap_param(params, 0);
printf("%f\n", *param);
libab_get_unit_value(ab, into);
return LIBAB_SUCCESS;
}
libab_result function_print_unit(libab* ab, libab_ref_vec* params, libab_ref* into) {
printf("()\n");
libab_get_unit_value(ab, into);
return LIBAB_SUCCESS;
}
#define OP_FUNCTION(name, expression) \
libab_result name(libab* ab, libab_ref_vec* params, libab_ref* into) { \
libab_result result = LIBAB_SUCCESS; \
@ -79,11 +87,13 @@ libab_result register_functions(libab* ab) {
libab_ref atan2_type;
libab_ref difficult_type;
libab_ref print_num_type;
libab_ref print_unit_type;
result = libab_create_type(ab, &trig_type, "(num)->num");
TRY(libab_create_type(ab, &atan2_type, "(num, num)->num"));
TRY(libab_create_type(ab, &difficult_type, "((num)->num)->num"));
TRY(libab_create_type(ab, &print_num_type, "(num)->unit"));
TRY(libab_create_type(ab, &print_unit_type, "(unit)->unit"));
TRY(libab_register_function(ab, "atan", &trig_type, function_atan));
TRY(libab_register_function(ab, "atan2", &atan2_type, function_atan2));
@ -92,6 +102,7 @@ libab_result register_functions(libab* ab) {
TRY(libab_register_function(ab, "times", &atan2_type, function_times));
TRY(libab_register_function(ab, "divide", &atan2_type, function_divide));
TRY(libab_register_function(ab, "print", &print_num_type, function_print_num));
TRY(libab_register_function(ab, "print", &print_unit_type, function_print_unit));
TRY(libab_register_operator_infix(ab, "+", 0, -1, "plus"));
TRY(libab_register_operator_infix(ab, "-", 0, -1, "minus"));
TRY(libab_register_operator_infix(ab, "*", 1, -1, "times"));
@ -101,6 +112,7 @@ libab_result register_functions(libab* ab) {
libab_ref_free(&atan2_type);
libab_ref_free(&difficult_type);
libab_ref_free(&print_num_type);
libab_ref_free(&print_unit_type);
return result;
}

8
src/interpreter.c
View File

@ -31,8 +31,10 @@ libab_result _interpreter_create_num_val(struct interpreter_state* state,
libab_ref* into, const char* from) {
void* data;
libab_result result = LIBAB_SUCCESS;
libab_ref_null(into);
if ((data = state->ab->impl.parse_num(from))) {
libab_ref_free(into);
result = libab_create_value_raw(into, data, &state->ab->type_num);
if (result != LIBAB_SUCCESS) {
@ -380,8 +382,6 @@ libab_result _interpreter_find_match(libab_function_list* function_values,
if (result == LIBAB_SUCCESS) {
libab_ref_vec_free(&temp_new_types);
if (!found_match)
libab_ref_null(match);
} else {
libab_ref_free(match);
libab_ref_null(match);
@ -776,7 +776,7 @@ libab_result _interpreter_run(struct interpreter_state* state, libab_tree* tree,
} else if (tree->variant == TREE_BASE || tree->variant == TREE_BLOCK) {
size_t index = 0;
libab_ref_null(into);
libab_get_unit_value(state->ab, into);
while (result == LIBAB_SUCCESS && index < tree->children.size) {
libab_ref_free(into);
result = _interpreter_run(state, vec_index(&tree->children, index),
@ -786,7 +786,7 @@ libab_result _interpreter_run(struct interpreter_state* state, libab_tree* tree,
} else if (tree->variant == TREE_NUM) {
result = _interpreter_create_num_val(state, into, tree->string_value);
} else if (tree->variant == TREE_VOID) {
libab_ref_null(into);
libab_get_unit_value(state->ab, into);
} else if (tree->variant == TREE_ID) {
result = _interpreter_require_value(scope, tree->string_value, into);
} else if (tree->variant == TREE_CALL) {

4
src/libabacus.c
View File

@ -387,6 +387,10 @@ void libab_get_type_unit(libab* ab, libab_ref* into) {
libab_ref_copy(&ab->type_unit, into);
}
void libab_get_unit_value(libab* ab, libab_ref* into) {
libab_interpreter_unit_value(&ab->intr, into);
}
libab_result libab_run(libab* ab, const char* string, libab_ref* value) {
libab_result result = LIBAB_SUCCESS;
ll tokens;