From 1be344574cb24e30e13fdc23b2cece65b14ff199 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 9 Nov 2008 12:10:09 +0000 Subject: splitted function.c into function.c and functions.c --- docs/help.txt | 2 +- docs/stats.txt | 4 +- docs/version.txt | 2 +- fype | Bin 457100 -> 470663 bytes src/build.h | 2 +- src/core/function.c | 928 +----------------------------------------------- src/core/function.h | 18 +- src/core/functions.c | 984 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/core/functions.h | 63 ++++ src/core/interpret.c | 20 +- tags | 19 +- test.out | 89 +++-- 12 files changed, 1146 insertions(+), 985 deletions(-) create mode 100644 src/core/functions.c create mode 100644 src/core/functions.h diff --git a/docs/help.txt b/docs/help.txt index f528b8c..95c1cab 100644 --- a/docs/help.txt +++ b/docs/help.txt @@ -1,4 +1,4 @@ -Fype v0.1-devel Build 9609 +Fype v0.1-devel Build 9630 (c) Paul C. Buetow (2005 - 2008) -e Executes given code string (see synopses) -h Prints this help diff --git a/docs/stats.txt b/docs/stats.txt index 80adb30..029a413 100644 --- a/docs/stats.txt +++ b/docs/stats.txt @@ -1,4 +1,4 @@ -===> Num of C source files : 44 -===> Num of C source lines : 8032 +===> Num of C source files : 46 +===> Num of C source lines : 8157 ===> Num of Fype source examples : 14 ===> Num of Fype source lines : 362 diff --git a/docs/version.txt b/docs/version.txt index 3eb92b7..2186474 100644 --- a/docs/version.txt +++ b/docs/version.txt @@ -1 +1 @@ -Fype v0.1-devel Build 9609 +Fype v0.1-devel Build 9630 diff --git a/fype b/fype index 4746410..ee01307 100755 Binary files a/fype and b/fype differ diff --git a/src/build.h b/src/build.h index 242be89..8b22346 100644 --- a/src/build.h +++ b/src/build.h @@ -35,7 +35,7 @@ #ifndef BUILD_H #define BUILD_H -#define BUILDNR 9627 +#define BUILDNR 9632 #define OS_FREEBSD #endif diff --git a/src/core/function.c b/src/core/function.c index e21b029..3d58b86 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -32,933 +32,19 @@ *: POSSIBILITY OF SUCH DAMAGE. *:*/ -#include -#include -#include +#include "../defines.h" #include "function.h" -#include "convert.h" -#include "scope.h" -#include "symbol.h" +Function* +function_new() { + Function *p_function = malloc(sizeof(Function)); -#define _FUNCTION_ERROR(m,t) \ - ERROR(\ - "%s: Function error in %s line %d pos %d near '%s'", m, \ - token_get_filename(t), \ - token_get_line_nr(t), \ - token_get_pos_nr(t), \ - token_get_val(t) \ - ) - -void -_process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, - Token *p_token_op2, Token *p_token_next) { - - TokenType tt_op = token_get_tt(p_token_op); - TokenType tt_op2 = p_token_op2 == NULL - ? TT_NONE - : token_get_tt(p_token_op2); - -#ifdef DEBUG_FUNCTION_PROCESS - if (p_token_op2 == NULL) - printf("DEBUG::FUNCTION::PROCESS: Operator %s\n", tt_get_name(tt_op)); - else - printf("DEBUG::FUNCTION::PROCESS: Operator %s %s\n", tt_get_name(tt_op), - tt_get_name(tt_op2)); - - token_print(p_token_next); - printf("\n"); - token_print(p_token_store); - printf("\n"); -#endif /* DEBUG_FUNCTION_PROCESS */ - - if (p_token_op2 != NULL) { - switch (tt_op) { - case TT_NOT: - switch (tt_op2) { - case TT_ASSIGN: - tt_op = TT_NEQ; - break; - default: - break; - } - break; - case TT_ASSIGN: - switch (tt_op2) { - case TT_ASSIGN: - tt_op = TT_EQ; - break; - default: - break; - } - break; - case TT_LT: - switch (tt_op2) { - case TT_ASSIGN: - tt_op = TT_LE; - break; - default: - break; - } - break; - case TT_GT: - switch (tt_op2) { - case TT_ASSIGN: - tt_op = TT_GE; - break; - default: - break; - } - break; - case TT_DDOT: - switch (tt_op2) { - case TT_LT: - tt_op = TT_LSHIFT; - break; - case TT_GT: - tt_op = TT_RSHIFT; - break; - default: - break; - } - break; - default: - break; - } - } else { - switch (tt_op) { - case TT_ASSIGN: - { - Token *p_token_assign = p_interpret->p_token_temp; - TokenType tt_assign = token_get_tt(p_token_assign); - - if (tt_assign != TT_IDENT) { - _FUNCTION_ERROR("Can only assign to symbols", - p_token_store); - } - - Symbol *p_symbol = scope_get(p_interpret->p_scope, - token_get_val(p_token_assign)); - - if (p_symbol == NULL) { - _FUNCTION_ERROR("No such symbol", - p_token_assign); - } - - symbol_set_val(p_symbol, p_token_store); - symbol_set_sym(p_symbol, SYM_VARIABLE); - - return; - } - - break; - NO_DEFAULT; - } - } - - p_token_next = token_new_copy(p_token_next); - TokenType tt_highest = convert_to_highest(p_token_store, p_token_next); - -#ifdef DEBUG_FUNCTION_PROCESS - printf("DEBUG::FUNCTION::PROCESS: ===> %s %s %s\n", - tt_get_name(tt_highest), - tt_get_name(tt_op), - tt_get_name(tt_highest)); -#endif /* DEBUG_FUNCTION_PROCESS */ - - switch (tt_op) { - case TT_ADD: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - token_get_ival(p_token_next) + - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_dval(p_token_store, - token_get_dval(p_token_next) + - token_get_dval(p_token_store)); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) + - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - array_append(p_token_store->p_array, - p_token_next->p_array); - break; - NO_DEFAULT; - } - break; - case TT_SUB: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - token_get_ival(p_token_next) - - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_dval(p_token_store, - token_get_dval(p_token_next) - - token_get_dval(p_token_store)); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) - - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("TT_ARRAY - TT_ARRAY not yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_MULT: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - token_get_ival(p_token_next) * - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_dval(p_token_store, - token_get_dval(p_token_next) * - token_get_dval(p_token_store)); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) * - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("TT_ARRAY * TT_ARRAY not yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_DIV: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) / - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_dval(p_token_store, - token_get_dval(p_token_next) / - token_get_dval(p_token_store)); - break; - case TT_STRING: - token_set_dval(p_token_store, - atof(token_get_val(p_token_next)) / - atof(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_DOUBLE); - break; - case TT_ARRAY: - ERROR("TT_ARRAY / TT_ARRAY not yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_EQ: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) == - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - token_get_dval(p_token_next) == - token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - strcmp(token_get_val(p_token_next), - token_get_val(p_token_store)) == 0); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("TT_ARRAY eq TT_ARRAY not yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_NEQ: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) != - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - token_get_dval(p_token_next) != - token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - strcmp(token_get_val(p_token_next), - token_get_val(p_token_store)) != 0); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_LE: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) <= - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - token_get_dval(p_token_next) <= - token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - strcmp(token_get_val(p_token_next), - token_get_val(p_token_store)) <= 0); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_GE: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) >= - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - token_get_dval(p_token_next) >= - token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - strcmp(token_get_val(p_token_next), - token_get_val(p_token_store)) >= 0); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_LT: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) < - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - token_get_dval(p_token_next) < - token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - strcmp(token_get_val(p_token_next), - token_get_val(p_token_store)) < 0); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_GT: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) > - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - token_get_dval(p_token_next) > - token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - strcmp(token_get_val(p_token_next), - token_get_val(p_token_store)) > 0); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_AND: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) & - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - (int) token_get_dval(p_token_next) & - (int) token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) & - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_OR: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) | - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - (int) token_get_dval(p_token_next) | - (int) token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) | - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_XOR: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) ^ - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - (int) token_get_dval(p_token_next) ^ - (int) token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) ^ - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_LSHIFT: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) << - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - (int) token_get_dval(p_token_next) << - (int) token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) << - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - case TT_RSHIFT: - switch (tt_highest) { - case TT_INTEGER: - token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) >> - token_get_ival(p_token_store)); - break; - case TT_DOUBLE: - token_set_ival(p_token_store, - (int) token_get_dval(p_token_next) >> - (int) token_get_dval(p_token_store)); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_STRING: - token_set_ival(p_token_store, - atoi(token_get_val(p_token_next)) >> - atoi(token_get_val(p_token_store))); - token_set_tt(p_token_store, TT_INTEGER); - break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; - NO_DEFAULT; - } - break; - - default: - _FUNCTION_ERROR("No such function/operator", p_token_op); - } - -#ifdef DEBUG_FUNCTION_PROCESS - token_print(p_token_store); - printf("\n\n"); -#endif /* DEBUG_FUNCTION_PROCESS */ - - token_delete(p_token_next); -} - -void -function_process(Interpret *p_interpret, Token *p_token_op, - Token *p_token_op2, Stack *p_stack_args, int i_args) { - - Token *p_token_store = token_new_copy(stack_pop(p_stack_args)); - - for (int i = 0; i < i_args -1 && !stack_empty(p_stack_args); ++i) { - Token *p_token_next = stack_pop(p_stack_args); - - _process(p_interpret, p_token_store, p_token_op, - p_token_op2, p_token_next); - } - - stack_push(p_stack_args, p_token_store); -} - -_Bool -function_is_buildin(Token *p_token_ident) { - /* TODO: optimize this function */ - if (strcmp("assert", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("decr", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("double", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("end", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("exit", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("fork", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("gc", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("incr", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("ind", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("integer", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("len", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("ln", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("neg", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("no", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("put", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("scope", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("say", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("string", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("yes", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("not", token_get_val(p_token_ident)) == 0) - return (true); - - if (strcmp("refs", token_get_val(p_token_ident)) == 0) - return (true); - - return (false); -} - -void -function_process_buildin(Interpret *p_interpret, Token *p_token_ident, - Stack *p_stack_args) { - - Token *p_token = stack_top(p_stack_args); - - if (token_get_tt(p_token) == TT_ARRAY) { - if (strcmp("len", token_get_val(p_token_ident)) == 0) { - stack_pop(p_stack_args); - stack_push(p_stack_args, - token_new_integer(array_get_used(p_token->p_array))); - - } else if (strcmp("ind", token_get_val(p_token_ident)) == 0) { - stack_pop(p_stack_args); - stack_push(p_stack_args, - token_new_integer(array_get_ind(p_token->p_array))); - - } else { - ArrayIterator *p_iter = arrayiterator_new(p_token->p_array); - - while (arrayiterator_has_next(p_iter)) { - stack_push(p_stack_args, arrayiterator_next(p_iter)); - function_process_buildin(p_interpret, p_token_ident, - p_stack_args); - stack_pop(p_stack_args); - } - - arrayiterator_delete(p_iter); - } - - return; - } - - if (strcmp("assert", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - switch (token_get_tt(p_token)) { - case TT_INTEGER: - if (token_get_ival(p_token) == 0) - _FUNCTION_ERROR("Assert failed", p_token); - break; - case TT_DOUBLE: - if (token_get_dval(p_token) == 0) - _FUNCTION_ERROR("Assert failed", p_token); - break; - case TT_STRING: - if (atoi(token_get_val(p_token)) == 0) - _FUNCTION_ERROR("Assert failed", p_token); - break; - NO_DEFAULT; - } - - } else if (strcmp("decr", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - switch (token_get_tt(p_token)) { - case TT_INTEGER: - token_set_ival(p_token, token_get_ival(p_token) - 1); - break; - case TT_DOUBLE: - token_set_dval(p_token, token_get_dval(p_token) - 1); - break; - case TT_STRING: - convert_to_integer(p_token); - token_set_ival(p_token, token_get_ival(p_token) - 1); - break; - NO_DEFAULT; - } - - } else if (strcmp("double", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token = token_new_copy(stack_pop(p_stack_args)); - convert_to_double(p_token); - stack_push(p_stack_args, p_token); - - } else if (strcmp("end", token_get_val(p_token_ident)) == 0) { - exit(0); - - } else if (strcmp("fork", token_get_val(p_token_ident)) == 0) { - Token *p_token = token_new_integer((int) fork()); - stack_push(p_stack_args, p_token); - - } else if (strcmp("gc", token_get_val(p_token_ident)) == 0) { - int i_count = garbage_collect(); - Token *p_token = token_new_integer(i_count); - stack_push(p_stack_args, p_token); - - } else if (strcmp("exit", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - p_token = token_new_copy(p_token); - convert_to_integer(p_token); - exit(token_get_ival(p_token)); - - } else if (strcmp("incr", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - switch (token_get_tt(p_token)) { - case TT_INTEGER: - token_set_ival(p_token, token_get_ival(p_token) + 1); - break; - case TT_DOUBLE: - token_set_dval(p_token, token_get_dval(p_token) + 1); - break; - case TT_STRING: - convert_to_integer(p_token); - token_set_ival(p_token, token_get_ival(p_token) + 1); - break; - NO_DEFAULT; - } - - } else if (strcmp("ind", token_get_val(p_token_ident)) == 0) { - _FUNCTION_ERROR("Expected array", p_token_ident); - - } else if (strcmp("integer", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token = token_new_copy(stack_pop(p_stack_args)); - convert_to_integer(p_token); - stack_push(p_stack_args, p_token); - - } else if (strcmp("len", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token = token_new_copy(stack_pop(p_stack_args)); - convert_to_string(p_token); - token_set_tt(p_token, TT_INTEGER); - token_set_ival(p_token, strlen(token_get_val(p_token))); - stack_push(p_stack_args, p_token); - - } else if (strcmp("ln", token_get_val(p_token_ident)) == 0) { - printf("\n"); - - } else if (strcmp("neg", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token = token_new_copy(stack_pop(p_stack_args)); - stack_push(p_stack_args, p_token); - - switch (token_get_tt(p_token)) { - case TT_INTEGER: - token_set_ival(p_token, -token_get_ival(p_token)); - break; - case TT_DOUBLE: - token_set_dval(p_token, -token_get_dval(p_token)); - break; - case TT_STRING: - token_set_ival(p_token, -atoi(token_get_val(p_token))); - token_set_tt(p_token, TT_INTEGER); - break; - NO_DEFAULT; - } - - } else if (strcmp("no", token_get_val(p_token_ident)) == 0) { - Token *p_token = NULL; - - if (0 == stack_size(p_stack_args)) { - p_token = token_new_integer(0); - - } else { - p_token = token_new_copy(stack_pop(p_stack_args)); - - switch (token_get_tt(p_token)) { - case TT_INTEGER: - token_set_ival(p_token, !token_get_ival(p_token)); - break; - case TT_DOUBLE: - token_set_dval(p_token, !token_get_dval(p_token)); - break; - case TT_STRING: - token_set_ival(p_token, !atoi(token_get_val(p_token))); - token_set_tt(p_token, TT_INTEGER); - break; - NO_DEFAULT; - } - } - - stack_push(p_stack_args, p_token); - - } else if (strcmp("put", token_get_val(p_token_ident)) == 0) { - StackIterator *p_iter = stackiterator_new(p_stack_args); - while (stackiterator_has_next(p_iter)) { - Token *p_token = stackiterator_next(p_iter); - switch (token_get_tt(p_token)) { - case TT_INTEGER: - printf("%d", token_get_ival(p_token)); - break; - case TT_DOUBLE: - printf("%f", token_get_dval(p_token)); - break; - case TT_STRING: - printf("%s", token_get_val(p_token)); - break; - NO_DEFAULT; - } - } - stackiterator_delete(p_iter); - - } else if (strcmp("scope", token_get_val(p_token_ident)) == 0) { - scope_print(p_interpret->p_scope); - - } else if (strcmp("say", token_get_val(p_token_ident)) == 0) { - StackIterator *p_iter = stackiterator_new(p_stack_args); - while (stackiterator_has_next(p_iter)) { - Token *p_token = stackiterator_next(p_iter); - switch (token_get_tt(p_token)) { - case TT_INTEGER: - printf("%d", token_get_ival(p_token)); - break; - case TT_DOUBLE: - printf("%f", token_get_dval(p_token)); - break; - case TT_STRING: - printf("%s", token_get_val(p_token)); - break; - } - } - stackiterator_delete(p_iter); - printf("\n"); - - } else if (strcmp("string", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token = token_new_copy(stack_pop(p_stack_args)); - convert_to_string(p_token); - stack_push(p_stack_args, p_token); - - } else if (strcmp("yes", token_get_val(p_token_ident)) == 0) { - Token *p_token = NULL; - - if (0 == stack_size(p_stack_args)) { - p_token = token_new_integer(1); - - } else { - p_token = token_new_copy(stack_pop(p_stack_args)); - token_set_ival(p_token, 1); - token_set_tt(p_token, TT_INTEGER); - - } - - stack_push(p_stack_args, p_token); - - } else if (strcmp("not", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token = token_new_copy(stack_pop(p_stack_args)); - stack_push(p_stack_args, p_token); - - switch (token_get_tt(p_token)) { - case TT_INTEGER: - token_set_ival(p_token, !token_get_ival(p_token)); - break; - case TT_DOUBLE: - token_set_dval(p_token, !token_get_dval(p_token)); - break; - case TT_STRING: - token_set_ival(p_token, !atoi(token_get_val(p_token))); - token_set_tt(p_token, TT_INTEGER); - break; - NO_DEFAULT; - } - - } else if (strcmp("refs", token_get_val(p_token_ident)) == 0) { - if (0 == stack_size(p_stack_args)) - _FUNCTION_ERROR("No argument given", p_token_ident); - - Token *p_token_top = stack_pop(p_stack_args); - Token *p_token = token_new_integer(p_token_top->i_ref_count); - stack_push(p_stack_args, p_token); - } -} - -_Bool -function_is_self_defined(Interpret *p_interpret) { - Symbol *p_symbol = scope_get(p_interpret->p_scope, - token_get_val(p_interpret->p_token)); - - if (p_symbol == NULL) - return (false); - - switch (symbol_get_sym(p_symbol)) { - case SYM_PROCEDURE: - case SYM_FUNCTION: - return (true); - NO_DEFAULT; - } - - return (false); + return (p_function); } void -function_process_self_defined(Interpret *p_interpret, Token *p_token_ident) { - Symbol *p_symbol = scope_get(p_interpret->p_scope, - token_get_val(p_token_ident)); - - switch (symbol_get_sym(p_symbol)) { - case SYM_PROCEDURE: - { - List *p_list_token = symbol_get_val(p_symbol); - interpret_subprocess(p_interpret, p_list_token); - } - break; - case SYM_FUNCTION: - { - List *p_list_token = symbol_get_val(p_symbol); - scope_up(p_interpret->p_scope); - interpret_subprocess(p_interpret, p_list_token); - scope_down(p_interpret->p_scope); - } - NO_DEFAULT; - } +function_delete(Function *p_function) { + free(p_function); } diff --git a/src/core/function.h b/src/core/function.h index 2e3e72e..c07f609 100644 --- a/src/core/function.h +++ b/src/core/function.h @@ -35,19 +35,11 @@ #ifndef FUNCTION_H #define FUNCTION_H -#include "token.h" +typedef struct { + char *c_name; +} Function; -#include "interpret.h" -#include "../data/stack.h" - -void function_process(Interpret *p_interp, Token *p_token_op, - Token *p_token_op2, Stack *p_stack_args, int i_args); -_Bool function_is_buildin(Token *p_token_ident); -void function_process_buildin(Interpret *p_interpret, - Token *p_token_ident, - Stack *p_stack_args); -_Bool function_is_self_defined(Interpret *p_interpret); -void function_process_self_defined(Interpret *p_interpret, - Token *p_token_ident); +Function* function_new(); +void function_delete(Function *p_function); #endif /* FUNCTION_H */ diff --git a/src/core/functions.c b/src/core/functions.c new file mode 100644 index 0000000..b2d0b0c --- /dev/null +++ b/src/core/functions.c @@ -0,0 +1,984 @@ +/*:* + *: File: ./src/core/function.c + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: E-Mail : fype@dev.buetow.org + *: + *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow + *: All rights reserved. + *: + *: Redistribution and use in source and binary forms, with or without modi- + *: fication, are permitted provided that the following conditions are met: + *: * Redistributions of source code must retain the above copyright + *: notice, this list of conditions and the following disclaimer. + *: * Redistributions in binary form must reproduce the above copyright + *: notice, this list of conditions and the following disclaimer in the + *: documentation and/or other materials provided with the distribution. + *: * Neither the name of P. B. Labs nor the names of its contributors may + *: be used to endorse or promote products derived from this software + *: without specific prior written permission. + *: + *: THIS SOFTWARE IS PROVIDED BY PAUL C. BUETOW AS IS'' AND ANY EXPRESS OR + *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + *: DISCLAIMED. IN NO EVENT SHALL PAUL C. BUETOW BE LIABLE FOR ANY DIRECT, + *: INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + *: (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + *: SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + *: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + *: STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + *: IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + *: POSSIBILITY OF SUCH DAMAGE. + *:*/ + +#include +#include +#include + +#include "functions.h" + +#include "convert.h" +#include "scope.h" +#include "symbol.h" + +#define _FUNCTIONS_ERROR(m,t) \ + ERROR(\ + "%s: Function error in %s line %d pos %d near '%s'", m, \ + token_get_filename(t), \ + token_get_line_nr(t), \ + token_get_pos_nr(t), \ + token_get_val(t) \ + ) + +Functions* +functions_new() { + Functions *p_functions = malloc(sizeof(Functions)); + + p_functions->p_hash_functions = hash_new(1024); + functions_init(p_functions); + + return (p_functions); +} + +void +functions_delete(Functions *p_functions) { + hash_delete(p_functions->p_hash_functions); + free(p_functions); +} + + +void +_process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, + Token *p_token_op2, Token *p_token_next) { + + TokenType tt_op = token_get_tt(p_token_op); + TokenType tt_op2 = p_token_op2 == NULL + ? TT_NONE + : token_get_tt(p_token_op2); + +#ifdef DEBUG_FUNCTION_PROCESS + if (p_token_op2 == NULL) + printf("DEBUG::FUNCTION::PROCESS: Operator %s\n", tt_get_name(tt_op)); + else + printf("DEBUG::FUNCTION::PROCESS: Operator %s %s\n", tt_get_name(tt_op), + tt_get_name(tt_op2)); + + token_print(p_token_next); + printf("\n"); + token_print(p_token_store); + printf("\n"); +#endif /* DEBUG_FUNCTION_PROCESS */ + + if (p_token_op2 != NULL) { + switch (tt_op) { + case TT_NOT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_NEQ; + break; + default: + break; + } + break; + case TT_ASSIGN: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_EQ; + break; + default: + break; + } + break; + case TT_LT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_LE; + break; + default: + break; + } + break; + case TT_GT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_GE; + break; + default: + break; + } + break; + case TT_DDOT: + switch (tt_op2) { + case TT_LT: + tt_op = TT_LSHIFT; + break; + case TT_GT: + tt_op = TT_RSHIFT; + break; + default: + break; + } + break; + default: + break; + } + } else { + switch (tt_op) { + case TT_ASSIGN: + { + Token *p_token_assign = p_interpret->p_token_temp; + TokenType tt_assign = token_get_tt(p_token_assign); + + if (tt_assign != TT_IDENT) { + _FUNCTIONS_ERROR("Can only assign to symbols", + p_token_store); + } + + Symbol *p_symbol = scope_get(p_interpret->p_scope, + token_get_val(p_token_assign)); + + if (p_symbol == NULL) { + _FUNCTIONS_ERROR("No such symbol", + p_token_assign); + } + + symbol_set_val(p_symbol, p_token_store); + symbol_set_sym(p_symbol, SYM_VARIABLE); + + return; + } + + break; + NO_DEFAULT; + } + } + + p_token_next = token_new_copy(p_token_next); + TokenType tt_highest = convert_to_highest(p_token_store, p_token_next); + +#ifdef DEBUG_FUNCTION_PROCESS + printf("DEBUG::FUNCTION::PROCESS: ===> %s %s %s\n", + tt_get_name(tt_highest), + tt_get_name(tt_op), + tt_get_name(tt_highest)); +#endif /* DEBUG_FUNCTION_PROCESS */ + + switch (tt_op) { + case TT_ADD: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + token_get_ival(p_token_next) + + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) + + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) + + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + array_append(p_token_store->p_array, + p_token_next->p_array); + break; + NO_DEFAULT; + } + break; + case TT_SUB: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + token_get_ival(p_token_next) - + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) - + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) - + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("TT_ARRAY - TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_MULT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + token_get_ival(p_token_next) * + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) * + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) * + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("TT_ARRAY * TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_DIV: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) / + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_dval(p_token_store, + token_get_dval(p_token_next) / + token_get_dval(p_token_store)); + break; + case TT_STRING: + token_set_dval(p_token_store, + atof(token_get_val(p_token_next)) / + atof(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_DOUBLE); + break; + case TT_ARRAY: + ERROR("TT_ARRAY / TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_EQ: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) == + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) == + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) == 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("TT_ARRAY eq TT_ARRAY not yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_NEQ: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) != + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) != + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) != 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_LE: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) <= + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) <= + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) <= 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_GE: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) >= + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) >= + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) >= 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_LT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) < + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) < + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) < 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_GT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) > + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + token_get_dval(p_token_next) > + token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + strcmp(token_get_val(p_token_next), + token_get_val(p_token_store)) > 0); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_AND: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) & + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) & + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) & + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_OR: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) | + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) | + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) | + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_XOR: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) ^ + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) ^ + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) ^ + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_LSHIFT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) << + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) << + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) << + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + case TT_RSHIFT: + switch (tt_highest) { + case TT_INTEGER: + token_set_ival(p_token_store, + (int) token_get_ival(p_token_next) >> + token_get_ival(p_token_store)); + break; + case TT_DOUBLE: + token_set_ival(p_token_store, + (int) token_get_dval(p_token_next) >> + (int) token_get_dval(p_token_store)); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_STRING: + token_set_ival(p_token_store, + atoi(token_get_val(p_token_next)) >> + atoi(token_get_val(p_token_store))); + token_set_tt(p_token_store, TT_INTEGER); + break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; + NO_DEFAULT; + } + break; + + default: + _FUNCTIONS_ERROR("No such function/operator", p_token_op); + } + +#ifdef DEBUG_FUNCTION_PROCESS + token_print(p_token_store); + printf("\n\n"); +#endif /* DEBUG_FUNCTION_PROCESS */ + + token_delete(p_token_next); +} + +void +function_process(Interpret *p_interpret, Token *p_token_op, + Token *p_token_op2, Stack *p_stack_args, int i_args) { + + Token *p_token_store = token_new_copy(stack_pop(p_stack_args)); + + for (int i = 0; i < i_args -1 && !stack_empty(p_stack_args); ++i) { + Token *p_token_next = stack_pop(p_stack_args); + + _process(p_interpret, p_token_store, p_token_op, + p_token_op2, p_token_next); + } + + stack_push(p_stack_args, p_token_store); +} + +_Bool +function_is_buildin(Token *p_token_ident) { + /* TODO: optimize this function */ + if (strcmp("assert", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("decr", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("double", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("end", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("exit", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("fork", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("gc", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("incr", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("ind", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("integer", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("len", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("ln", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("neg", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("no", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("put", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("scope", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("say", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("string", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("yes", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("not", token_get_val(p_token_ident)) == 0) + return (true); + + if (strcmp("refs", token_get_val(p_token_ident)) == 0) + return (true); + + return (false); +} + +void +function_process_buildin(Interpret *p_interpret, Token *p_token_ident, + Stack *p_stack_args) { + + Token *p_token = stack_top(p_stack_args); + + if (token_get_tt(p_token) == TT_ARRAY) { + if (strcmp("len", token_get_val(p_token_ident)) == 0) { + stack_pop(p_stack_args); + stack_push(p_stack_args, + token_new_integer(array_get_used(p_token->p_array))); + + } else if (strcmp("ind", token_get_val(p_token_ident)) == 0) { + stack_pop(p_stack_args); + stack_push(p_stack_args, + token_new_integer(array_get_ind(p_token->p_array))); + + } else { + ArrayIterator *p_iter = arrayiterator_new(p_token->p_array); + + while (arrayiterator_has_next(p_iter)) { + stack_push(p_stack_args, arrayiterator_next(p_iter)); + function_process_buildin(p_interpret, p_token_ident, + p_stack_args); + stack_pop(p_stack_args); + } + + arrayiterator_delete(p_iter); + } + + return; + } + + if (strcmp("assert", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + if (token_get_ival(p_token) == 0) + _FUNCTIONS_ERROR("Assert failed", p_token); + break; + case TT_DOUBLE: + if (token_get_dval(p_token) == 0) + _FUNCTIONS_ERROR("Assert failed", p_token); + break; + case TT_STRING: + if (atoi(token_get_val(p_token)) == 0) + _FUNCTIONS_ERROR("Assert failed", p_token); + break; + NO_DEFAULT; + } + + } else if (strcmp("decr", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, token_get_ival(p_token) - 1); + break; + case TT_DOUBLE: + token_set_dval(p_token, token_get_dval(p_token) - 1); + break; + case TT_STRING: + convert_to_integer(p_token); + token_set_ival(p_token, token_get_ival(p_token) - 1); + break; + NO_DEFAULT; + } + + } else if (strcmp("double", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_double(p_token); + stack_push(p_stack_args, p_token); + + } else if (strcmp("end", token_get_val(p_token_ident)) == 0) { + exit(0); + + } else if (strcmp("fork", token_get_val(p_token_ident)) == 0) { + Token *p_token = token_new_integer((int) fork()); + stack_push(p_stack_args, p_token); + + } else if (strcmp("gc", token_get_val(p_token_ident)) == 0) { + int i_count = garbage_collect(); + Token *p_token = token_new_integer(i_count); + stack_push(p_stack_args, p_token); + + } else if (strcmp("exit", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + p_token = token_new_copy(p_token); + convert_to_integer(p_token); + exit(token_get_ival(p_token)); + + } else if (strcmp("incr", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, token_get_ival(p_token) + 1); + break; + case TT_DOUBLE: + token_set_dval(p_token, token_get_dval(p_token) + 1); + break; + case TT_STRING: + convert_to_integer(p_token); + token_set_ival(p_token, token_get_ival(p_token) + 1); + break; + NO_DEFAULT; + } + + } else if (strcmp("ind", token_get_val(p_token_ident)) == 0) { + _FUNCTIONS_ERROR("Expected array", p_token_ident); + + } else if (strcmp("integer", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_integer(p_token); + stack_push(p_stack_args, p_token); + + } else if (strcmp("len", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_string(p_token); + token_set_tt(p_token, TT_INTEGER); + token_set_ival(p_token, strlen(token_get_val(p_token))); + stack_push(p_stack_args, p_token); + + } else if (strcmp("ln", token_get_val(p_token_ident)) == 0) { + printf("\n"); + + } else if (strcmp("neg", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + stack_push(p_stack_args, p_token); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, -token_get_ival(p_token)); + break; + case TT_DOUBLE: + token_set_dval(p_token, -token_get_dval(p_token)); + break; + case TT_STRING: + token_set_ival(p_token, -atoi(token_get_val(p_token))); + token_set_tt(p_token, TT_INTEGER); + break; + NO_DEFAULT; + } + + } else if (strcmp("no", token_get_val(p_token_ident)) == 0) { + Token *p_token = NULL; + + if (0 == stack_size(p_stack_args)) { + p_token = token_new_integer(0); + + } else { + p_token = token_new_copy(stack_pop(p_stack_args)); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, !token_get_ival(p_token)); + break; + case TT_DOUBLE: + token_set_dval(p_token, !token_get_dval(p_token)); + break; + case TT_STRING: + token_set_ival(p_token, !atoi(token_get_val(p_token))); + token_set_tt(p_token, TT_INTEGER); + break; + NO_DEFAULT; + } + } + + stack_push(p_stack_args, p_token); + + } else if (strcmp("put", token_get_val(p_token_ident)) == 0) { + StackIterator *p_iter = stackiterator_new(p_stack_args); + while (stackiterator_has_next(p_iter)) { + Token *p_token = stackiterator_next(p_iter); + switch (token_get_tt(p_token)) { + case TT_INTEGER: + printf("%d", token_get_ival(p_token)); + break; + case TT_DOUBLE: + printf("%f", token_get_dval(p_token)); + break; + case TT_STRING: + printf("%s", token_get_val(p_token)); + break; + NO_DEFAULT; + } + } + stackiterator_delete(p_iter); + + } else if (strcmp("scope", token_get_val(p_token_ident)) == 0) { + scope_print(p_interpret->p_scope); + + } else if (strcmp("say", token_get_val(p_token_ident)) == 0) { + StackIterator *p_iter = stackiterator_new(p_stack_args); + while (stackiterator_has_next(p_iter)) { + Token *p_token = stackiterator_next(p_iter); + switch (token_get_tt(p_token)) { + case TT_INTEGER: + printf("%d", token_get_ival(p_token)); + break; + case TT_DOUBLE: + printf("%f", token_get_dval(p_token)); + break; + case TT_STRING: + printf("%s", token_get_val(p_token)); + break; + } + } + stackiterator_delete(p_iter); + printf("\n"); + + } else if (strcmp("string", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + convert_to_string(p_token); + stack_push(p_stack_args, p_token); + + } else if (strcmp("yes", token_get_val(p_token_ident)) == 0) { + Token *p_token = NULL; + + if (0 == stack_size(p_stack_args)) { + p_token = token_new_integer(1); + + } else { + p_token = token_new_copy(stack_pop(p_stack_args)); + token_set_ival(p_token, 1); + token_set_tt(p_token, TT_INTEGER); + + } + + stack_push(p_stack_args, p_token); + + } else if (strcmp("not", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token = token_new_copy(stack_pop(p_stack_args)); + stack_push(p_stack_args, p_token); + + switch (token_get_tt(p_token)) { + case TT_INTEGER: + token_set_ival(p_token, !token_get_ival(p_token)); + break; + case TT_DOUBLE: + token_set_dval(p_token, !token_get_dval(p_token)); + break; + case TT_STRING: + token_set_ival(p_token, !atoi(token_get_val(p_token))); + token_set_tt(p_token, TT_INTEGER); + break; + NO_DEFAULT; + } + + } else if (strcmp("refs", token_get_val(p_token_ident)) == 0) { + if (0 == stack_size(p_stack_args)) + _FUNCTIONS_ERROR("No argument given", p_token_ident); + + Token *p_token_top = stack_pop(p_stack_args); + Token *p_token = token_new_integer(p_token_top->i_ref_count); + stack_push(p_stack_args, p_token); + } +} + +_Bool +function_is_self_defined(Interpret *p_interpret) { + Symbol *p_symbol = scope_get(p_interpret->p_scope, + token_get_val(p_interpret->p_token)); + + if (p_symbol == NULL) + return (false); + + switch (symbol_get_sym(p_symbol)) { + case SYM_PROCEDURE: + case SYM_FUNCTION: + return (true); + NO_DEFAULT; + } + + return (false); +} + +void +function_process_self_defined(Interpret *p_interpret, Token *p_token_ident) { + Symbol *p_symbol = scope_get(p_interpret->p_scope, + token_get_val(p_token_ident)); + + switch (symbol_get_sym(p_symbol)) { + case SYM_PROCEDURE: + { + List *p_list_token = symbol_get_val(p_symbol); + interpret_subprocess(p_interpret, p_list_token); + } + break; + case SYM_FUNCTION: + { + List *p_list_token = symbol_get_val(p_symbol); + scope_up(p_interpret->p_scope); + interpret_subprocess(p_interpret, p_list_token); + scope_down(p_interpret->p_scope); + } + NO_DEFAULT; + } +} + +void +functions_init(Functions *p_functions) { +} diff --git a/src/core/functions.h b/src/core/functions.h new file mode 100644 index 0000000..637a655 --- /dev/null +++ b/src/core/functions.h @@ -0,0 +1,63 @@ +/*:* + *: File: ./src/core/function.h + *: A simple interpreter + *: + *: WWW : http://fype.buetow.org + *: E-Mail : fype@dev.buetow.org + *: + *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow + *: All rights reserved. + *: + *: Redistribution and use in source and binary forms, with or without modi- + *: fication, are permitted provided that the following conditions are met: + *: * Redistributions of source code must retain the above copyright + *: notice, this list of conditions and the following disclaimer. + *: * Redistributions in binary form must reproduce the above copyright + *: notice, this list of conditions and the following disclaimer in the + *: documentation and/or other materials provided with the distribution. + *: * Neither the name of P. B. Labs nor the names of its contributors may + *: be used to endorse or promote products derived from this software + *: without specific prior written permission. + *: + *: THIS SOFTWARE IS PROVIDED BY PAUL C. BUETOW AS IS'' AND ANY EXPRESS OR + *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + *: DISCLAIMED. IN NO EVENT SHALL PAUL C. BUETOW BE LIABLE FOR ANY DIRECT, + *: INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + *: (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + *: SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + *: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + *: STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + *: IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + *: POSSIBILITY OF SUCH DAMAGE. + *:*/ + +#ifndef FUNCTIONS_H +#define FUNCTIONS_H + +#include "token.h" + +#include "interpret.h" +#include "../data/stack.h" +#include "../data/hash.h" + +typedef struct { + Hash *p_hash_functions; +} Functions; + +Functions* functions_new(); +void functions_delete(Functions *p_functions); +void functions_init(Functions *p_functions); + +void function_process(Interpret *p_interp, Token *p_token_op, + Token *p_token_op2, Stack *p_stack_args, + int i_args); +_Bool function_is_buildin(Token *p_token_ident); +void function_process_buildin(Interpret *p_interpret, + Token *p_token_ident, + Stack *p_stack_args); +_Bool function_is_self_defined(Interpret *p_interpret); +void function_process_self_defined(Interpret *p_interpret, + Token *p_token_ident); + +#endif /* FUNCTIONS_H */ diff --git a/src/core/interpret.c b/src/core/interpret.c index 65e5fee..2853fa8 100644 --- a/src/core/interpret.c +++ b/src/core/interpret.c @@ -36,7 +36,7 @@ #include "../defines.h" #include "convert.h" -#include "function.h" +#include "functions.h" #include "symbol.h" #define _INTERPRET_ERROR(m,t) \ @@ -467,7 +467,7 @@ _expression(Interpret *p_interpret) { _CHECK TRACK if (_expression_(p_interpret)) { - TokenType tt = p_interpret->tt; + TokenType tt = p_interpret->tt; if (tt == TT_SEMICOLON || tt == TT_NONE) { _NEXT @@ -806,13 +806,13 @@ _term(Interpret *p_interpret) { case TT_DOUBLE: case TT_ARRAY: stack_push(p_interpret->p_stack, p_interpret->p_token); - // Checks if the term is the last element of an array - // say ["element"] # The "element" - // or of a function - // func foo { say 1 } # The 1 - if (_NEXT_TT != TT_PARANT_AR && _NEXT_TT != TT_PARANT_CR) - _NEXT - return (1); + // Checks if the term is the last element of an array + // say ["element"] # The "element" + // or of a function + // func foo { say 1 } # The 1 + if (_NEXT_TT != TT_PARANT_AR && _NEXT_TT != TT_PARANT_CR) + _NEXT + return (1); case TT_IDENT: { @@ -975,7 +975,7 @@ _term(Interpret *p_interpret) { array_unshift(p_array, stack_pop(p_interpret->p_stack)); } - + _NEXT } diff --git a/tags b/tags index 38492ee..271e21f 100644 --- a/tags +++ b/tags @@ -1,7 +1,7 @@ CASE ./src/core/token.c /^#define CASE(t,r) case t: return r;$/ CHECK ./src/core/token.c /^#define CHECK(...) if (!strcmp(c_token, __VA_ARGS_/ Mmain ./src/main.c /^main(int i_argc, char **pc_argv) {$/ -_FUNCTION_ERROR ./src/core/function.c /^#define _FUNCTION_ERROR(m,t) \\$/ +_FUNCTIONS_ERROR ./src/core/functions.c /^#define _FUNCTIONS_ERROR(m,t) \\$/ _GARBAGE_ERROR ./src/core/garbage.c /^#define _GARBAGE_ERROR(m) \\$/ _Garbage ./src/core/garbage.c /^} _Garbage;$/ _INTERPRET_ERROR ./src/core/interpret.c /^#define _INTERPRET_ERROR(m,t) \\$/ @@ -21,7 +21,7 @@ _next ./src/core/interpret.c /^_next(Interpret *p_interpret) {$/ _next_tt ./src/core/interpret.c /^_next_tt(Interpret *p_interpret) {$/ _print_lookahead ./src/core/interpret.c /^_print_lookahead(Interpret *p_interpret) {$/ _proc_decl ./src/core/interpret.c /^_proc_decl(Interpret *p_interpret) {$/ -_process ./src/core/function.c /^_process(Interpret *p_interpret, Token *p_token_st/ +_process ./src/core/functions.c /^_process(Interpret *p_interpret, Token *p_token_st/ _product ./src/core/interpret.c /^_product(Interpret *p_interpret) {$/ _product2 ./src/core/interpret.c /^_product2(Interpret *p_interpret) {$/ _program ./src/core/interpret.c /^_program(Interpret *p_interpret) {$/ @@ -108,11 +108,16 @@ datiter_new ./src/data/dat.c /^datiter_new(Dat *p_dat) {$/ datiter_next ./src/data/dat.c /^datiter_next(DatIter *p_iter) {$/ datiter_next_t ./src/data/dat.c /^datiter_next_t(DatIter *p_iter, TYPE *p_type) {$/ datiter_skip ./src/data/dat.c /^datiter_skip(DatIter *p_iter, unsigned i_num) {$/ -function_is_buildin ./src/core/function.c /^function_is_buildin(Token *p_token_ident) {$/ -function_is_self_defined ./src/core/function.c /^function_is_self_defined(Interpret *p_interpret) {/ -function_process ./src/core/function.c /^function_process(Interpret *p_interpret, Token *p_/ -function_process_buildin ./src/core/function.c /^function_process_buildin(Interpret *p_interpret, T/ -function_process_self_defined ./src/core/function.c /^function_process_self_defined(Interpret *p_interpr/ +function_delete ./src/core/function.c /^function_delete(Function *p_function) {$/ +function_is_buildin ./src/core/functions.c /^function_is_buildin(Token *p_token_ident) {$/ +function_is_self_defined ./src/core/functions.c /^function_is_self_defined(Interpret *p_interpret) {/ +function_new ./src/core/function.c /^function_new() {$/ +function_process ./src/core/functions.c /^function_process(Interpret *p_interpret, Token *p_/ +function_process_buildin ./src/core/functions.c /^function_process_buildin(Interpret *p_interpret, T/ +function_process_self_defined ./src/core/functions.c /^function_process_self_defined(Interpret *p_interpr/ +functions_delete ./src/core/functions.c /^functions_delete(Functions *p_functions) {$/ +functions_init ./src/core/functions.c /^functions_init(Functions *p_functions) {$/ +functions_new ./src/core/functions.c /^functions_new() {$/ fype_delete ./src/fype.c /^fype_delete(Fype *p_fype) {$/ fype_new ./src/fype.c /^fype_new() {$/ fype_run ./src/fype.c /^fype_run(int i_argc, char **pc_argv) {$/ diff --git a/test.out b/test.out index d568169..0caafb1 100644 --- a/test.out +++ b/test.out @@ -2,14 +2,20 @@ * Examples of how to use arrays *# -# Create a function bar, it returns 0 by default +# Create a function bar, returns 0 by default func bar { say "bar" } -# Create an array foo, print out "bar" -my foo = [bar, 6/2, 3*3, "string", ["_A", ["__BA", "__BB"]]; +# Create a multi dimensional array foo +my foo = [bar, 1, 4/2, double "3", ["A", ["BA", "BB"]]]; -# +# Run on each element of foo recursive 'say' say foo; + +# Print the length of the array +assert 5 == say len foo; + +# Print the last index of the array +assert 4 == say ind foo; Token (id=00000, line=00006, pos=0005, type=TT_FUNC, val=func, ival=0, dval=0.000000, refs=1) Token (id=00001, line=00006, pos=0009, type=TT_IDENT, val=bar, ival=0, dval=0.000000, refs=1) Token (id=00002, line=00006, pos=0011, type=TT_PARANT_CL, val={, ival=0, dval=0.000000, refs=1) @@ -22,29 +28,54 @@ Token (id=00008, line=00009, pos=0009, type=TT_ASSIGN, val==, ival=0, dval=0.000 Token (id=00009, line=00009, pos=0011, type=TT_PARANT_AL, val=[, ival=0, dval=0.000000, refs=1) Token (id=00010, line=00009, pos=0014, type=TT_IDENT, val=bar, ival=0, dval=0.000000, refs=1) Token (id=00011, line=00009, pos=0015, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) -Token (id=00012, line=00009, pos=0017, type=TT_INTEGER, val=6, ival=6, dval=0.000000, refs=1) -Token (id=00013, line=00009, pos=0018, type=TT_DIV, val=/, ival=0, dval=0.000000, refs=1) -Token (id=00014, line=00009, pos=0019, type=TT_INTEGER, val=2, ival=2, dval=0.000000, refs=1) -Token (id=00015, line=00009, pos=0020, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) -Token (id=00016, line=00009, pos=0022, type=TT_INTEGER, val=3, ival=3, dval=0.000000, refs=1) -Token (id=00017, line=00009, pos=0023, type=TT_MULT, val=*, ival=0, dval=0.000000, refs=1) -Token (id=00018, line=00009, pos=0024, type=TT_INTEGER, val=3, ival=3, dval=0.000000, refs=1) -Token (id=00019, line=00009, pos=0025, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) -Token (id=00020, line=00009, pos=0026, type=TT_STRING, val=string, ival=0, dval=0.000000, refs=1) -Token (id=00021, line=00009, pos=0028, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) -Token (id=00022, line=00009, pos=0030, type=TT_PARANT_AL, val=[, ival=0, dval=0.000000, refs=1) -Token (id=00023, line=00009, pos=0030, type=TT_STRING, val=_A, ival=0, dval=0.000000, refs=1) -Token (id=00024, line=00009, pos=0032, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) -Token (id=00025, line=00009, pos=0034, type=TT_PARANT_AL, val=[, ival=0, dval=0.000000, refs=1) -Token (id=00026, line=00009, pos=0034, type=TT_STRING, val=__BA, ival=0, dval=0.000000, refs=1) -Token (id=00027, line=00009, pos=0036, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) -Token (id=00028, line=00009, pos=0037, type=TT_STRING, val=__BB, ival=0, dval=0.000000, refs=1) -Token (id=00029, line=00009, pos=0039, type=TT_PARANT_AR, val=], ival=0, dval=0.000000, refs=1) -Token (id=00030, line=00009, pos=0039, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) -Token (id=00031, line=00009, pos=0040, type=TT_PARANT_AR, val=], ival=0, dval=0.000000, refs=1) -Token (id=00032, line=00009, pos=0041, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) -Token (id=00033, line=00012, pos=0004, type=TT_IDENT, val=say, ival=0, dval=0.000000, refs=1) -Token (id=00034, line=00012, pos=0008, type=TT_IDENT, val=foo, ival=0, dval=0.000000, refs=1) -Token (id=00035, line=00012, pos=0009, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) +Token (id=00012, line=00009, pos=0017, type=TT_INTEGER, val=1, ival=1, dval=0.000000, refs=1) +Token (id=00013, line=00009, pos=0018, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) +Token (id=00014, line=00009, pos=0020, type=TT_INTEGER, val=4, ival=4, dval=0.000000, refs=1) +Token (id=00015, line=00009, pos=0021, type=TT_DIV, val=/, ival=0, dval=0.000000, refs=1) +Token (id=00016, line=00009, pos=0022, type=TT_INTEGER, val=2, ival=2, dval=0.000000, refs=1) +Token (id=00017, line=00009, pos=0023, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) +Token (id=00018, line=00009, pos=0030, type=TT_IDENT, val=double, ival=0, dval=0.000000, refs=1) +Token (id=00019, line=00009, pos=0031, type=TT_STRING, val=3, ival=0, dval=0.000000, refs=1) +Token (id=00020, line=00009, pos=0033, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) +Token (id=00021, line=00009, pos=0035, type=TT_PARANT_AL, val=[, ival=0, dval=0.000000, refs=1) +Token (id=00022, line=00009, pos=0035, type=TT_STRING, val=A, ival=0, dval=0.000000, refs=1) +Token (id=00023, line=00009, pos=0037, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) +Token (id=00024, line=00009, pos=0039, type=TT_PARANT_AL, val=[, ival=0, dval=0.000000, refs=1) +Token (id=00025, line=00009, pos=0039, type=TT_STRING, val=BA, ival=0, dval=0.000000, refs=1) +Token (id=00026, line=00009, pos=0041, type=TT_COMMA, val=,, ival=0, dval=0.000000, refs=1) +Token (id=00027, line=00009, pos=0042, type=TT_STRING, val=BB, ival=0, dval=0.000000, refs=1) +Token (id=00028, line=00009, pos=0044, type=TT_PARANT_AR, val=], ival=0, dval=0.000000, refs=1) +Token (id=00029, line=00009, pos=0044, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) +Token (id=00030, line=00009, pos=0045, type=TT_PARANT_AR, val=], ival=0, dval=0.000000, refs=1) +Token (id=00031, line=00009, pos=0045, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) +Token (id=00032, line=00009, pos=0046, type=TT_PARANT_AR, val=], ival=0, dval=0.000000, refs=1) +Token (id=00033, line=00009, pos=0047, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) +Token (id=00034, line=00012, pos=0004, type=TT_IDENT, val=say, ival=0, dval=0.000000, refs=1) +Token (id=00035, line=00012, pos=0008, type=TT_IDENT, val=foo, ival=0, dval=0.000000, refs=1) +Token (id=00036, line=00012, pos=0009, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) +Token (id=00037, line=00015, pos=0007, type=TT_IDENT, val=assert, ival=0, dval=0.000000, refs=1) +Token (id=00038, line=00015, pos=0009, type=TT_INTEGER, val=5, ival=5, dval=0.000000, refs=1) +Token (id=00039, line=00015, pos=0011, type=TT_ASSIGN, val==, ival=0, dval=0.000000, refs=1) +Token (id=00040, line=00015, pos=0012, type=TT_ASSIGN, val==, ival=0, dval=0.000000, refs=1) +Token (id=00041, line=00015, pos=0016, type=TT_IDENT, val=say, ival=0, dval=0.000000, refs=1) +Token (id=00042, line=00015, pos=0020, type=TT_IDENT, val=len, ival=0, dval=0.000000, refs=1) +Token (id=00043, line=00015, pos=0024, type=TT_IDENT, val=foo, ival=0, dval=0.000000, refs=1) +Token (id=00044, line=00015, pos=0025, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) +Token (id=00045, line=00018, pos=0007, type=TT_IDENT, val=assert, ival=0, dval=0.000000, refs=1) +Token (id=00046, line=00018, pos=0009, type=TT_INTEGER, val=4, ival=4, dval=0.000000, refs=1) +Token (id=00047, line=00018, pos=0011, type=TT_ASSIGN, val==, ival=0, dval=0.000000, refs=1) +Token (id=00048, line=00018, pos=0012, type=TT_ASSIGN, val==, ival=0, dval=0.000000, refs=1) +Token (id=00049, line=00018, pos=0016, type=TT_IDENT, val=say, ival=0, dval=0.000000, refs=1) +Token (id=00050, line=00018, pos=0020, type=TT_IDENT, val=ind, ival=0, dval=0.000000, refs=1) +Token (id=00051, line=00018, pos=0024, type=TT_IDENT, val=foo, ival=0, dval=0.000000, refs=1) +Token (id=00052, line=00018, pos=0025, type=TT_SEMICOLON, val=;, ival=0, dval=0.000000, refs=1) bar -No such symbol: Interpret error in ./test.fy line 12 pos 8 near 'foo' (Fype @ ./src/core/interpret.c line 874) +0 +1 +2 +3.000000 +A +BA +BB +5 +4 -- cgit v1.2.3