From be839900419c7a74c4a46efd279d0ca16b35dc1f Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Thu, 15 May 2008 23:28:07 +0000 Subject: Moved stuff into trunk. --- src/core/function.c | 661 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 661 insertions(+) create mode 100644 src/core/function.c (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c new file mode 100644 index 0000000..fd18ba0 --- /dev/null +++ b/src/core/function.c @@ -0,0 +1,661 @@ +/*:* + *: 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 Buetow (http://www.pblabs.net) + *: 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 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 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 "function.h" + +#include "convert.h" +#include "scope.h" +#include "symbol.h" + +#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_next) { + + TokenType tt_op = token_get_tt(p_token_op); + +#ifdef DEBUG_FUNCTION_PROCESS + printf("PROCESS OPERATOR %s\n", tt_get_name(tt_op)); + + token_print(p_token_next); + printf("\n"); + token_print(p_token_store); + printf("\n"); +#endif /* DEBUG_FUNCTION_PROCESS */ + + + 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("===> %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)); + 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; + 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; + 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; + 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; + 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; + 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; + 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; + 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; + 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; + 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; + 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, + 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_next); + } + + stack_push(p_stack_args, p_token_store); +} + +_Bool +function_is_buildin(Token *p_token_ident) { + 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("integer", 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("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); + + return (false); +} + +void +function_process_buildin(Interpret *p_interpret, Token *p_token_ident, + Stack *p_stack_args) { + + 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); + + Token *p_token = stack_top(p_stack_args); + + 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); + + Token *p_token = stack_top(p_stack_args); + 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(); + printf("ICOUNT %d\n", i_count); + 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); + + Token *p_token = stack_top(p_stack_args); + 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); + + Token *p_token = stack_top(p_stack_args); + 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("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("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("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; + NO_DEFAULT; + } + } + 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); + } +} + +_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; + } +} + -- cgit v1.2.3 From e4689bbb20dade47b98061d48ba73436c856f3ff Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Fri, 8 Aug 2008 09:31:58 +0000 Subject: changed header. --- src/core/function.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index fd18ba0..134024b 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,13 @@ /*:* *: 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 Buetow (http://www.pblabs.net) + *: + *: Copyright (c) 2005 2006 2007 2008, Paul Buetow (http://www.pb-labs.com) *: 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 @@ -15,20 +15,20 @@ *: * 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 + *: * 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 Buetow AS IS'' AND ANY EXPRESS OR - *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: + *: THIS SOFTWARE IS PROVIDED BY Paul 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 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) + *: DISCLAIMED. IN NO EVENT SHALL Paul 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 + *: 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. *:*/ -- cgit v1.2.3 From da52f90a73abd653cfe9726bcf5c96338db0b7a2 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sat, 23 Aug 2008 01:46:47 +0000 Subject: some enhancements --- src/core/function.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 134024b..4225309 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -5,7 +5,7 @@ *: WWW : http://fype.buetow.org *: E-Mail : fype@dev.buetow.org *: - *: Copyright (c) 2005 2006 2007 2008, Paul Buetow (http://www.pb-labs.com) + *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow (http://www.pb-labs.com) *: All rights reserved. *: *: Redistribution and use in source and binary forms, with or without modi- -- cgit v1.2.3 From e9a9ad33583c49df48ae99cab9ba0fd80f150a9e Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sat, 23 Aug 2008 02:03:40 +0000 Subject: changed headers --- src/core/function.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 4225309..7912cf7 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -5,7 +5,7 @@ *: WWW : http://fype.buetow.org *: E-Mail : fype@dev.buetow.org *: - *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow (http://www.pb-labs.com) + *: Copyright (c) 2005 2006 2007 2008, Dipl.-Inf. (FH) Paul C. Buetow *: All rights reserved. *: *: Redistribution and use in source and binary forms, with or without modi- -- cgit v1.2.3 From 7f3055c1f4429a81de3715d5d4173353382e2de2 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 24 Aug 2008 19:30:11 +0000 Subject: some mods --- src/core/function.c | 166 ++++++++++++++++++++++++++++++++++------------------ 1 file changed, 110 insertions(+), 56 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 7912cf7..06e89bb 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,13 @@ /*:* *: 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, Dipl.-Inf. (FH) Paul C. Buetow + *: + *: Copyright (c) 2005 2006 2007 2008, Dipl.-Inf. (FH) 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 @@ -15,20 +15,20 @@ *: * 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 + *: * 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 Buetow AS IS'' AND ANY EXPRESS OR - *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: + *: THIS SOFTWARE IS PROVIDED BY Paul 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 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) + *: DISCLAIMED. IN NO EVENT SHALL Paul 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 + *: 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. *:*/ @@ -53,12 +53,19 @@ void _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, - Token *p_token_next) { + 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 - printf("PROCESS OPERATOR %s\n", tt_get_name(tt_op)); + if (p_token_op2 == NULL) + printf("PROCESS OPERATOR %s\n", tt_get_name(tt_op)); + else + printf("PROCESS OPERATOR %s %s\n", tt_get_name(tt_op), + tt_get_name(tt_op2)); token_print(p_token_next); printf("\n"); @@ -66,34 +73,79 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, printf("\n"); #endif /* DEBUG_FUNCTION_PROCESS */ + if (p_token_op2 != NULL) { +#ifdef DEBUG_FUNCTION_PROCESS + printf("===> %s %s %s %s\n", + tt_get_name(tt_highest), + tt_get_name(tt_op), + tt_get_name(tt_op2), + tt_get_name(tt_highest)); +#endif /* DEBUG_FUNCTION_PROCESS */ - 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); + switch (tt_op) { + case TT_NOT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_NEQ; + default: + break; + } + case TT_ASSIGN: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_EQ; + break; + default: + break; + } + case TT_LT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_LE; + break; + default: + break; + } + case TT_GT: + switch (tt_op2) { + case TT_ASSIGN: + tt_op = TT_GE; + break; + default: + 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)); + 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); - } + 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); + symbol_set_val(p_symbol, p_token_store); + symbol_set_sym(p_symbol, SYM_VARIABLE); - return; - } + return; + } - break; - NO_DEFAULT; + break; + NO_DEFAULT; + } } p_token_next = token_new_copy(p_token_next); @@ -234,89 +286,90 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, NO_DEFAULT; } break; - case TT_LT: + case TT_LE: + printf("DFDF\n"); switch (tt_highest) { case TT_INTEGER: token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) < + (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_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_get_val(p_token_store)) <= 0); token_set_tt(p_token_store, TT_INTEGER); break; NO_DEFAULT; } break; - case TT_GT: + case TT_GE: switch (tt_highest) { case TT_INTEGER: token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) > + (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_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_get_val(p_token_store)) >= 0); token_set_tt(p_token_store, TT_INTEGER); break; NO_DEFAULT; } break; - case TT_LE: + case TT_LT: switch (tt_highest) { case TT_INTEGER: token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) <= + (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_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_get_val(p_token_store)) < 0); token_set_tt(p_token_store, TT_INTEGER); break; NO_DEFAULT; } break; - case TT_GE: + case TT_GT: switch (tt_highest) { case TT_INTEGER: token_set_ival(p_token_store, - (int) token_get_ival(p_token_next) >= + (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_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_get_val(p_token_store)) > 0); token_set_tt(p_token_store, TT_INTEGER); break; NO_DEFAULT; @@ -336,14 +389,15 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, void function_process(Interpret *p_interpret, Token *p_token_op, - Stack *p_stack_args, int i_args) { + 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_next); + _process(p_interpret, p_token_store, p_token_op, + p_token_op2, p_token_next); } stack_push(p_stack_args, p_token_store); -- cgit v1.2.3 From cf9029ee902eda028f3efcb77e8c2aed25205b94 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 24 Aug 2008 19:47:50 +0000 Subject: foo bar baz --- src/core/function.c | 14 +++++--------- 1 file changed, 5 insertions(+), 9 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 06e89bb..39971a1 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -74,22 +74,16 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, #endif /* DEBUG_FUNCTION_PROCESS */ if (p_token_op2 != NULL) { -#ifdef DEBUG_FUNCTION_PROCESS - printf("===> %s %s %s %s\n", - tt_get_name(tt_highest), - tt_get_name(tt_op), - tt_get_name(tt_op2), - tt_get_name(tt_highest)); -#endif /* DEBUG_FUNCTION_PROCESS */ - 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: @@ -98,6 +92,7 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, default: break; } + break; case TT_LT: switch (tt_op2) { case TT_ASSIGN: @@ -106,6 +101,7 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, default: break; } + break; case TT_GT: switch (tt_op2) { case TT_ASSIGN: @@ -114,6 +110,7 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, default: break; } + break; default: break; } @@ -287,7 +284,6 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, } break; case TT_LE: - printf("DFDF\n"); switch (tt_highest) { case TT_INTEGER: token_set_ival(p_token_store, -- cgit v1.2.3 From ec9899c0399f42473d311c7d0a46769d3d933c06 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Mon, 25 Aug 2008 18:48:28 +0000 Subject: bugs fixed, initial array --- src/core/function.c | 147 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 147 insertions(+) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 39971a1..fda40b8 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -111,6 +111,18 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; } @@ -371,6 +383,117 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; + 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; + 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; + 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; + 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; + NO_DEFAULT; + } + break; + default: _FUNCTION_ERROR("No such function/operator", p_token_op); } @@ -449,6 +572,9 @@ function_is_buildin(Token *p_token_ident) { if (strcmp("yes", token_get_val(p_token_ident)) == 0) return (true); + if (strcmp("not", token_get_val(p_token_ident)) == 0) + return (true); + return (false); } @@ -665,6 +791,27 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, } 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; + } } } -- cgit v1.2.3 From 71185ab0ab0b08b4d5bb2e750ff85e11f105a453 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 16 Sep 2008 17:05:51 +0000 Subject: array progress --- src/core/function.c | 86 ++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 62 insertions(+), 24 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index fda40b8..979454d 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -51,6 +51,34 @@ token_get_val(t) \ ) +void +_print_val(Token *p_token) { + 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; + case TT_ARRAY: + { + Array *p_array = p_token->p_array; + ArrayIterator *p_iter = arrayiterator_new(p_array); + while (arrayiterator_has_next(p_iter)) { + Token *p_next = arrayiterator_next(p_iter); + _print_val(p_next); + printf(" "); + } + arrayiterator_delete(p_iter); + } + break; + NO_DEFAULT; + } +} + void _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, Token *p_token_op2, Token *p_token_next) { @@ -575,6 +603,9 @@ function_is_buildin(Token *p_token_ident) { if (strcmp("not", token_get_val(p_token_ident)) == 0) return (true); + if (strcmp("type", token_get_val(p_token_ident)) == 0) + return (true); + return (false); } @@ -734,18 +765,7 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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; - } + _print_val(p_token); } stackiterator_delete(p_iter); @@ -753,18 +773,7 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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; - } + _print_val(p_token); } stackiterator_delete(p_iter); printf("\n"); @@ -812,6 +821,35 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, break; NO_DEFAULT; } + } 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("type", 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 = stack_pop(p_stack_args); + TokenType tt = token_get_tt(p_token); + + Token *p_token_type = token_new_string(tt_get_name(tt)); + stack_push(p_stack_args, p_token_type); } } -- cgit v1.2.3 From d527f50159f056dc165fa7eaf7bf80425a1e758d Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 14 Oct 2008 20:38:27 +0000 Subject: GC removed, temporaly --- src/core/function.c | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 979454d..fdbf308 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -95,10 +95,8 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, printf("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"); + token_print_ln(p_token_next); + token_print_ln(p_token_store); #endif /* DEBUG_FUNCTION_PROCESS */ if (p_token_op2 != NULL) { @@ -527,11 +525,10 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, } #ifdef DEBUG_FUNCTION_PROCESS - token_print(p_token_store); - printf("\n\n"); + token_print_ln(p_token_store); #endif /* DEBUG_FUNCTION_PROCESS */ - token_delete(p_token_next); + //token_delete(p_token_next); } void -- cgit v1.2.3 From cb1450b796eff3c8830616e2e9a3d83d4dfb4900 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sat, 18 Oct 2008 22:47:31 +0000 Subject: backdowngrade --- src/core/function.c | 97 +++++++++++++++++------------------------------------ 1 file changed, 31 insertions(+), 66 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index fdbf308..fda40b8 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -51,34 +51,6 @@ token_get_val(t) \ ) -void -_print_val(Token *p_token) { - 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; - case TT_ARRAY: - { - Array *p_array = p_token->p_array; - ArrayIterator *p_iter = arrayiterator_new(p_array); - while (arrayiterator_has_next(p_iter)) { - Token *p_next = arrayiterator_next(p_iter); - _print_val(p_next); - printf(" "); - } - arrayiterator_delete(p_iter); - } - break; - NO_DEFAULT; - } -} - void _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, Token *p_token_op2, Token *p_token_next) { @@ -95,8 +67,10 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, printf("PROCESS OPERATOR %s %s\n", tt_get_name(tt_op), tt_get_name(tt_op2)); - token_print_ln(p_token_next); - token_print_ln(p_token_store); + token_print(p_token_next); + printf("\n"); + token_print(p_token_store); + printf("\n"); #endif /* DEBUG_FUNCTION_PROCESS */ if (p_token_op2 != NULL) { @@ -525,10 +499,11 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, } #ifdef DEBUG_FUNCTION_PROCESS - token_print_ln(p_token_store); + token_print(p_token_store); + printf("\n\n"); #endif /* DEBUG_FUNCTION_PROCESS */ - //token_delete(p_token_next); + token_delete(p_token_next); } void @@ -600,9 +575,6 @@ function_is_buildin(Token *p_token_ident) { if (strcmp("not", token_get_val(p_token_ident)) == 0) return (true); - if (strcmp("type", token_get_val(p_token_ident)) == 0) - return (true); - return (false); } @@ -762,7 +734,18 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, StackIterator *p_iter = stackiterator_new(p_stack_args); while (stackiterator_has_next(p_iter)) { Token *p_token = stackiterator_next(p_iter); - _print_val(p_token); + 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); @@ -770,7 +753,18 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, StackIterator *p_iter = stackiterator_new(p_stack_args); while (stackiterator_has_next(p_iter)) { Token *p_token = stackiterator_next(p_iter); - _print_val(p_token); + 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); printf("\n"); @@ -818,35 +812,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, break; NO_DEFAULT; } - } 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("type", 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 = stack_pop(p_stack_args); - TokenType tt = token_get_tt(p_token); - - Token *p_token_type = token_new_string(tt_get_name(tt)); - stack_push(p_stack_args, p_token_type); } } -- cgit v1.2.3 From 3d7b35bb37c066489546751e100c2c2b823ccba3 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 19 Oct 2008 17:48:21 +0000 Subject: refs and syms --- src/core/function.c | 11 +++++++++++ 1 file changed, 11 insertions(+) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index fda40b8..c25834d 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -575,6 +575,9 @@ function_is_buildin(Token *p_token_ident) { 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); } @@ -812,6 +815,14 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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); } } -- cgit v1.2.3 From 1956010ec79fbab604efc2b60d0af325e91f67b8 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Mon, 20 Oct 2008 18:36:28 +0000 Subject: Improved GC debugging. Debugging printings now labeled with DEBUG::$NAME::$ETC::..: --- src/core/function.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index c25834d..4d25a60 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -62,9 +62,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, #ifdef DEBUG_FUNCTION_PROCESS if (p_token_op2 == NULL) - printf("PROCESS OPERATOR %s\n", tt_get_name(tt_op)); + printf("DEBUG::FUNCTION::PROCESS: Operator %s\n", tt_get_name(tt_op)); else - printf("PROCESS OPERATOR %s %s\n", tt_get_name(tt_op), + printf("DEBUG::FUNCTION::PROCESS: Operator %s %s\n", tt_get_name(tt_op), tt_get_name(tt_op2)); token_print(p_token_next); @@ -161,7 +161,7 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, TokenType tt_highest = convert_to_highest(p_token_store, p_token_next); #ifdef DEBUG_FUNCTION_PROCESS - printf("===> %s %s %s\n", + printf("DEBUG::FUNCTION::PROCESS: ===> %s %s %s\n", tt_get_name(tt_highest), tt_get_name(tt_op), tt_get_name(tt_highest)); @@ -643,7 +643,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, } else if (strcmp("gc", token_get_val(p_token_ident)) == 0) { int i_count = garbage_collect(); - printf("ICOUNT %d\n", i_count); Token *p_token = token_new_integer(i_count); stack_push(p_stack_args, p_token); @@ -815,7 +814,7 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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); -- cgit v1.2.3 From a5f564d59149de660c4832b8c6e8acd42770479c Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sat, 25 Oct 2008 00:12:08 +0000 Subject: make headers --- src/core/function.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 4d25a60..2796d36 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,13 @@ /*:* *: 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, Dipl.-Inf. (FH) Paul C. Buetow + *: + *: 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 @@ -15,20 +15,20 @@ *: * 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 + *: * 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 Buetow AS IS'' AND ANY EXPRESS OR - *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: + *: THIS SOFTWARE IS PROVIDED BY Paul 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 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) + *: DISCLAIMED. IN NO EVENT SHALL Paul 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 + *: 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. *:*/ -- cgit v1.2.3 From 1c6dd17947050d2f70dd8df6f4ad527180581c68 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sat, 25 Oct 2008 00:23:48 +0000 Subject: astyle. more BSD style in return (FOO); --- src/core/function.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 2796d36..a528aa1 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,13 @@ /*:* *: 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 + *: + *: 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 @@ -15,20 +15,20 @@ *: * 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 + *: * 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 Buetow AS IS'' AND ANY EXPRESS OR - *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: + *: THIS SOFTWARE IS PROVIDED BY Paul 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 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) + *: DISCLAIMED. IN NO EVENT SHALL Paul 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 + *: 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. *:*/ -- cgit v1.2.3 From a1c3f47491b98cd9026f8e853cc9e72630805c12 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 26 Oct 2008 12:51:57 +0000 Subject: added the "scope" function --- src/core/function.c | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index a528aa1..8541960 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -524,6 +524,7 @@ function_process(Interpret *p_interpret, Token *p_token_op, _Bool function_is_buildin(Token *p_token_ident) { + /* TODO: optimize this function */ if (strcmp("assert", token_get_val(p_token_ident)) == 0) return (true); @@ -563,6 +564,9 @@ function_is_buildin(Token *p_token_ident) { 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); @@ -751,6 +755,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, } 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)) { -- cgit v1.2.3 From 1c2c79c47719ca828ce0eb4365ea0327fe89f2d8 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 28 Oct 2008 22:23:40 +0000 Subject: initial references support. run "make headers" --- src/core/function.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 8541960..0c80e0a 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,13 @@ /*:* *: 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 + *: + *: 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 @@ -15,20 +15,20 @@ *: * 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 + *: * 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 Buetow AS IS'' AND ANY EXPRESS OR - *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + *: + *: THIS SOFTWARE IS PROVIDED BY Paul 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 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) + *: DISCLAIMED. IN NO EVENT SHALL Paul 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 + *: 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. *:*/ -- cgit v1.2.3 From 8933f024f5a7374de8d62065a11524875ef68dca Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 28 Oct 2008 23:07:42 +0000 Subject: feierabend f. heute --- src/core/function.c | 1 - 1 file changed, 1 deletion(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 0c80e0a..bf8f1df 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -772,7 +772,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, case TT_STRING: printf("%s", token_get_val(p_token)); break; - NO_DEFAULT; } } stackiterator_delete(p_iter); -- cgit v1.2.3 From eb2a3bdc387eb76908dcd59b165738adccc28786 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sat, 1 Nov 2008 18:57:20 +0000 Subject: modified headers --- src/core/function.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index bf8f1df..2db865a 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -19,10 +19,10 @@ *: be used to endorse or promote products derived from this software *: without specific prior written permission. *: - *: THIS SOFTWARE IS PROVIDED BY Paul Buetow AS IS'' AND ANY EXPRESS OR + *: 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 Buetow BE LIABLE FOR ANY DIRECT, + *: 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) -- cgit v1.2.3 From 43cdc845c8c10bbf0e4c0f70b09a6f5290931832 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 4 Nov 2008 22:19:07 +0000 Subject: bugfix --- src/core/function.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 2db865a..36f57f5 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -179,12 +179,21 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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: + 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; + */ NO_DEFAULT; } break; -- cgit v1.2.3 From 87de8060633801d3793246967f43c6159b0f5351 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 4 Nov 2008 22:55:22 +0000 Subject: astyle --- src/core/function.c | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 36f57f5..fbdf53d 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,13 @@ /*:* *: 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 + *: + *: 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 @@ -15,20 +15,20 @@ *: * 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 + *: * 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 + *: + *: 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) + *: 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 + *: 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. *:*/ @@ -186,14 +186,14 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, atoi(token_get_val(p_token_store))); token_set_tt(p_token_store, TT_INTEGER); break; - /* - case TT_ARRAY: - 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: + 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; + */ NO_DEFAULT; } break; -- cgit v1.2.3 From d2713783c48ca9fbdd6f4ea3aab03fe856fdd52a Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 4 Nov 2008 23:24:42 +0000 Subject: big step forward for arrays in fype. --- src/core/function.c | 94 ++++++++++++++++++++++++++++++++++++----------------- 1 file changed, 65 insertions(+), 29 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index fbdf53d..8d5dbf6 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -186,14 +186,10 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, atoi(token_get_val(p_token_store))); token_set_tt(p_token_store, TT_INTEGER); break; - /* - case TT_ARRAY: - 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; @@ -215,6 +211,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -236,6 +235,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -257,6 +259,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -278,6 +283,8 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, strcmp(token_get_val(p_token_next), token_get_val(p_token_store)) == 0); token_set_tt(p_token_store, TT_INTEGER); + case TT_ARRAY: + ERROR("TT_ARRAY eq TT_ARRAY not yet implemented"); break; NO_DEFAULT; } @@ -301,6 +308,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -323,6 +333,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -345,6 +358,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -367,6 +383,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -389,27 +408,8 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, token_get_val(p_token_store)) > 0); token_set_tt(p_token_store, TT_INTEGER); 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); + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); break; NO_DEFAULT; } @@ -433,6 +433,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -455,6 +458,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -477,6 +483,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -499,6 +508,9 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -617,6 +629,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, if (atoi(token_get_val(p_token)) == 0) _FUNCTION_ERROR("Assert failed", p_token); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } @@ -636,6 +651,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, convert_to_integer(p_token); token_set_ival(p_token, token_get_ival(p_token) - 1); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } @@ -684,6 +702,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, convert_to_integer(p_token); token_set_ival(p_token, token_get_ival(p_token) + 1); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } @@ -716,6 +737,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, token_set_ival(p_token, -atoi(token_get_val(p_token))); token_set_tt(p_token, TT_INTEGER); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } @@ -739,6 +763,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, token_set_ival(p_token, !atoi(token_get_val(p_token))); token_set_tt(p_token, TT_INTEGER); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } } @@ -759,6 +786,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, case TT_STRING: printf("%s", token_get_val(p_token)); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } } @@ -780,6 +810,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, break; case TT_STRING: printf("%s", token_get_val(p_token)); + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; break; } } @@ -827,6 +860,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, token_set_ival(p_token, !atoi(token_get_val(p_token))); token_set_tt(p_token, TT_INTEGER); break; + case TT_ARRAY: + ERROR("ARRAY bla yet implemented"); + break; NO_DEFAULT; } -- cgit v1.2.3 From 7575536c805e379b009630947e72f636c006751f Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Tue, 4 Nov 2008 23:43:30 +0000 Subject: fixed bugs which happened. --- src/core/function.c | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 8d5dbf6..a102d7b 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -283,6 +283,7 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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; @@ -414,6 +415,31 @@ _process(Interpret *p_interpret, Token *p_token_store, Token *p_token_op, 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: @@ -810,10 +836,10 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, break; case TT_STRING: printf("%s", token_get_val(p_token)); + break; case TT_ARRAY: ERROR("ARRAY bla yet implemented"); break; - break; } } stackiterator_delete(p_iter); -- cgit v1.2.3 From a46655f67043af257e70715903badf9d4321c4de Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Fri, 7 Nov 2008 22:11:06 +0000 Subject: one step further for arrays. --- src/core/function.c | 46 +++++++++++++++++----------------------------- 1 file changed, 17 insertions(+), 29 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index a102d7b..0df0b65 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -636,12 +636,27 @@ 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) { + 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); - Token *p_token = stack_top(p_stack_args); - switch (token_get_tt(p_token)) { case TT_INTEGER: if (token_get_ival(p_token) == 0) @@ -655,9 +670,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, if (atoi(token_get_val(p_token)) == 0) _FUNCTION_ERROR("Assert failed", p_token); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } @@ -665,7 +677,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, if (0 == stack_size(p_stack_args)) _FUNCTION_ERROR("No argument given", p_token_ident); - Token *p_token = stack_top(p_stack_args); switch (token_get_tt(p_token)) { case TT_INTEGER: token_set_ival(p_token, token_get_ival(p_token) - 1); @@ -677,9 +688,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, convert_to_integer(p_token); token_set_ival(p_token, token_get_ival(p_token) - 1); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } @@ -707,7 +715,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, if (0 == stack_size(p_stack_args)) _FUNCTION_ERROR("No argument given", p_token_ident); - Token *p_token = stack_top(p_stack_args); p_token = token_new_copy(p_token); convert_to_integer(p_token); exit(token_get_ival(p_token)); @@ -716,7 +723,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, if (0 == stack_size(p_stack_args)) _FUNCTION_ERROR("No argument given", p_token_ident); - Token *p_token = stack_top(p_stack_args); switch (token_get_tt(p_token)) { case TT_INTEGER: token_set_ival(p_token, token_get_ival(p_token) + 1); @@ -728,9 +734,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, convert_to_integer(p_token); token_set_ival(p_token, token_get_ival(p_token) + 1); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } @@ -763,9 +766,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, token_set_ival(p_token, -atoi(token_get_val(p_token))); token_set_tt(p_token, TT_INTEGER); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } @@ -789,9 +789,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, token_set_ival(p_token, !atoi(token_get_val(p_token))); token_set_tt(p_token, TT_INTEGER); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } } @@ -812,9 +809,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, case TT_STRING: printf("%s", token_get_val(p_token)); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } } @@ -837,9 +831,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, case TT_STRING: printf("%s", token_get_val(p_token)); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; } } stackiterator_delete(p_iter); @@ -886,9 +877,6 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, token_set_ival(p_token, !atoi(token_get_val(p_token))); token_set_tt(p_token, TT_INTEGER); break; - case TT_ARRAY: - ERROR("ARRAY bla yet implemented"); - break; NO_DEFAULT; } -- cgit v1.2.3 From 0c69b76e7d7cbc50d4f87e41766a2de1394a6cad Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 9 Nov 2008 11:28:26 +0000 Subject: len and ind implemented --- src/core/function.c | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 0df0b65..e21b029 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -596,9 +596,15 @@ function_is_buildin(Token *p_token_ident) { 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); @@ -639,6 +645,17 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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)) { @@ -649,6 +666,7 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, } arrayiterator_delete(p_iter); + } return; } @@ -737,6 +755,9 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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); @@ -745,6 +766,16 @@ function_process_buildin(Interpret *p_interpret, Token *p_token_ident, 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"); -- cgit v1.2.3 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 --- src/core/function.c | 928 +--------------------------------------------------- 1 file changed, 7 insertions(+), 921 deletions(-) (limited to 'src/core/function.c') 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); } -- cgit v1.2.3 From 117201ad10df2859fb3510e8437d776f3a691f69 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Sun, 9 Nov 2008 13:23:58 +0000 Subject: changed the src headers. --- src/core/function.c | 33 +++++++++++++++++---------------- 1 file changed, 17 insertions(+), 16 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 3d58b86..0a59f8d 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,13 +1,14 @@ /*:* *: 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 + *: AUTHOR : http://paul.buetow.org + *: E-Mail : fype at 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 @@ -15,20 +16,20 @@ *: * 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 + *: * 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 + *: + *: 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) + *: 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 + *: 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. *:*/ -- cgit v1.2.3 From 44c97ead68a274e462460eef33d67e7442c2fa47 Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Mon, 15 Dec 2008 20:57:29 +0000 Subject: say foo[1] works --- src/core/function.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index 0a59f8d..d14dc62 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,14 +1,14 @@ /*:* *: File: ./src/core/function.c *: A simple interpreter - *: + *: *: WWW : http://fype.buetow.org *: AUTHOR : http://paul.buetow.org *: E-Mail : fype at dev.buetow.org - *: - *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow + *: + *: 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 @@ -16,20 +16,20 @@ *: * 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 + *: * 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 + *: + *: 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) + *: 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 + *: 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. *:*/ -- cgit v1.2.3 From 40ad7ffc7ebd91e90f0894badcc4132df9b3c45d Mon Sep 17 00:00:00 2001 From: Paul Buetow Date: Mon, 15 Dec 2008 20:58:59 +0000 Subject: modified headers --- src/core/function.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'src/core/function.c') diff --git a/src/core/function.c b/src/core/function.c index d14dc62..f16e74a 100644 --- a/src/core/function.c +++ b/src/core/function.c @@ -1,14 +1,14 @@ /*:* *: File: ./src/core/function.c *: A simple interpreter - *: + *: *: WWW : http://fype.buetow.org *: AUTHOR : http://paul.buetow.org *: E-Mail : fype at dev.buetow.org - *: - *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow + *: + *: Copyright (c) 2005 - 2008, Paul 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 @@ -16,20 +16,20 @@ *: * 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 + *: * 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 + *: + *: 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) + *: 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 + *: 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. *:*/ -- cgit v1.2.3