array progress

10 files changed, 231 insertions, 71 deletions

diff --git a/src/build.h b/src/build.h
index b717a22..80ea007 100644
--- a/src/build.h
+++ b/src/build.h
@@ -35,7 +35,7 @@
 #ifndef BUILD_H
 #define BUILD_H
 
-#define BUILDNR 9209
+#define BUILDNR 9330
 #define OS_FREEBSD
 
 #endif
diff --git a/src/core/convert.c b/src/core/convert.c
index 73fb8a2..081e92e 100644
--- a/src/core/convert.c
+++ b/src/core/convert.c
@@ -33,6 +33,7 @@
  *:*/
 
 #include "convert.h"
+#include "../data/array.h"
 
 void
 convert_to_integer(Token *p_token) {
@@ -47,6 +48,10 @@ convert_to_integer(Token *p_token) {
       token_set_tt(p_token, TT_INTEGER);
       token_set_ival(p_token, atoi(token_get_val(p_token)));
       break;
+   case TT_ARRAY:
+      token_set_tt(p_token, TT_INTEGER);
+      token_set_ival(p_token, array_get_size(p_token->p_array)-1);
+      break;
    default:
       ERROR("Ouups(%s)", tt_get_name(token_get_tt(p_token)));
       break;
@@ -62,6 +67,9 @@ convert_to_integer_get(Token *p_token) {
       return ((int) token_get_dval(p_token));
    case TT_STRING:
       return (atoi(token_get_val(p_token)));
+   case TT_ARRAY:
+      return (array_get_size(p_token->p_array)-1);
+      break;
    default:
       ERROR("Ouups(%s)", tt_get_name(token_get_tt(p_token)));
    }
@@ -82,6 +90,10 @@ convert_to_double(Token *p_token) {
       token_set_tt(p_token, TT_DOUBLE);
       token_set_dval(p_token, atof(token_get_val(p_token)));
       break;
+   case TT_ARRAY:
+      token_set_tt(p_token, TT_DOUBLE);
+      token_set_dval(p_token, array_get_size(p_token->p_array)-1);
+      break;
    default:
       token_print_val(p_token);
       ERROR("Datatype conversion error '%s'", token_get_val(p_token));
@@ -116,6 +128,17 @@ convert_to_string(Token *p_token) {
    break;
    case TT_STRING:
       break;
+   case TT_ARRAY:
+      token_set_tt(p_token, TT_STRING);
+      char c_tmp[1024];
+      sprintf(c_tmp, "%d", array_get_size(p_token->p_array)-1);
+      int i_len = strlen(c_tmp);
+      p_token->c_val = realloc(p_token->c_val, sizeof(char) * (i_len + 1));
+      strcpy(p_token->c_val, c_tmp);
+      p_token->c_val[i_len] = 0;
+	  array_iterate(p_token->p_array, token_delete_cb);
+
+      break;
    default:
       ERROR("Datatype conversion error");
       break;
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
@@ -52,6 +52,34 @@
 		)
 
 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);
    }
 }
 
diff --git a/src/core/interpret.c b/src/core/interpret.c
index 5aa07ef..c3f781c 100644
--- a/src/core/interpret.c
+++ b/src/core/interpret.c
@@ -54,15 +54,16 @@
 #define _NEXT_TT _next_tt(p_interpret)
 #define _SKIP _next(p_interpret);
 
-void _print_lookahead(Interpret *p_interpret);
+int __expression_get(Interpret *p_interpret, List *p_list_block);
+int __array_get(Interpret *p_interpret, Token *p_token_arr);
+void __print_lookahead(Interpret *p_interpret);
 int _next(Interpret *p_interpret);
 int _program(Interpret *p_interpret);
 int _var_decl(Interpret *p_interpret);
 int _var_assign(Interpret *p_interpret);
 int _var_list(Interpret *p_interpret);
-int _expression_get(Interpret *p_interpret, List *p_list_block);
 int _block_get(Interpret *p_interpret, List *p_list_block);
-int _block_skip(Interpret *p_interpret);
+int __block_skip(Interpret *p_interpret);
 int _proc_decl(Interpret *p_interpret);
 int _func_decl(Interpret *p_interpret);
 int _statement(Interpret *p_interpret);
@@ -114,7 +115,7 @@ interpret_delete(Interpret *p_interpret) {
 }
 
 void
-_print_lookahead(Interpret *p_interpret) {
+__print_lookahead(Interpret *p_interpret) {
    ListIterator *p_iter = p_interpret->p_iter;
    ListIteratorState *p_state = listiterator_get_state(p_iter);
 
@@ -175,7 +176,6 @@ _var_decl(Interpret *p_interpret) {
    _CHECK TRACK
 
    switch (p_interpret->tt) {
-   //case TT_ARR: //TODO cleanup TT_ARR
    case TT_MY:
    {
       if (_NEXT_TT != TT_IDENT)
@@ -200,7 +200,7 @@ _var_decl(Interpret *p_interpret) {
       }
    }
    default:
-   	break;
+      break;
    }
 
    return (0);
@@ -226,8 +226,8 @@ _var_assign(Interpret *p_interpret) {
          p_interpret->p_stack = stack_new();
 
          if (_expression_(p_interpret)) {
-            function_process_buildin(p_interpret, p_token, 
-					p_interpret->p_stack);
+            function_process_buildin(p_interpret, p_token,
+                                     p_interpret->p_stack);
 
             stack_merge(p_stack, p_interpret->p_stack);
             stack_delete(p_interpret->p_stack);
@@ -236,7 +236,6 @@ _var_assign(Interpret *p_interpret) {
             p_token = stack_top(p_interpret->p_stack);
             Symbol *p_symbol = symbol_new(SYM_VARIABLE, p_token);
             scope_newset(p_interpret->p_scope, c_name, p_symbol);
-
          } else {
             return (0);
          }
@@ -298,11 +297,10 @@ _block_get(Interpret *p_interpret, List *p_list_block) {
 }
 
 int
-_expression_get(Interpret *p_interpret, List *p_list_expression) {
+__expression_get(Interpret *p_interpret, List *p_list_expression) {
    for (;;) {
-      if (p_interpret->tt == TT_PARANT_CL) {
+      if (p_interpret->tt == TT_PARANT_CL) 
          break; /* for */
-      }
 
       list_add_back(p_list_expression, p_interpret->p_token);
 
@@ -319,7 +317,36 @@ _expression_get(Interpret *p_interpret, List *p_list_expression) {
 }
 
 int
-_block_skip(Interpret *p_interpret) {
+__array_get(Interpret *p_interpret, Token *p_token_arr) {
+#ifdef DEBUG_ARRAY_GET
+   printf("====> ARRAY\n");
+#endif /* DEBUG_ARRAY_GET */
+   Array *p_array = p_token_arr->p_array;
+
+   do {
+      Token *p_token = p_interpret->p_token;
+
+#ifdef DEBUG_ARRAY_GET
+      printf("Insert: ");
+      token_print_ln(p_token);
+#endif /* DEBUG_ARRAY_GET */
+
+      array_unshift(p_array, p_token);
+      token_ref_up(p_token);
+      _NEXT
+   } while (p_interpret->tt != TT_PARANT_AR);
+
+#ifdef DEBUG_ARRAY_GET
+   printf("<==== ARRAY\n");
+#endif /* DEBUG_ARRAY_GET */
+   /* Ignore TT_PARANT_AR */
+   _NEXT
+
+   return (0);
+}
+
+int
+__block_skip(Interpret *p_interpret) {
    if (p_interpret->tt != TT_PARANT_CL)
       _INTERPRET_ERROR("Expected '{'", p_interpret->p_token);
    _NEXT
@@ -523,7 +550,7 @@ _control(Interpret *p_interpret) {
 
       _NEXT
 
-      _expression_get(p_interpret, p_list_expr);
+      __expression_get(p_interpret, p_list_expr);
       _block_get(p_interpret, p_list_block);
       Token *p_token_backup = p_interpret->p_token;
 
@@ -541,7 +568,6 @@ _control(Interpret *p_interpret) {
             Token *p_token_top = stack_pop(p_interpret->p_stack);
 
             if (p_token_top == NULL) {
-               printf("FOO\n");
                exit(0);
             }
             if (tt ==  TT_WHILE) {
@@ -786,6 +812,7 @@ _term(Interpret *p_interpret) {
    case TT_INTEGER:
    case TT_DOUBLE:
    case TT_STRING:
+   case TT_ARRAY:
       stack_push(p_interpret->p_stack, p_interpret->p_token);
       _NEXT
       return (1);
@@ -917,9 +944,13 @@ _term(Interpret *p_interpret) {
       Token *p_token = p_interpret->p_token;
       _NEXT
 
-	  Token *p_token_arr = token_new_array(ARRAY_SIZE);
+      Token *p_token_arr = token_new_array(ARRAY_SIZE);
       stack_push(p_interpret->p_stack, p_token_arr);
-	  _INTERPRET_ERROR("arrays not yet fully implemented", p_token_arr);
+
+      if (__array_get(p_interpret, p_token_arr) != 0)
+         _INTERPRET_ERROR("Array syntax error", p_token);
+
+	  return (1);
    }
    break;
 
diff --git a/src/core/symbol.c b/src/core/symbol.c
index 2343cdb..9a98e63 100644
--- a/src/core/symbol.c
+++ b/src/core/symbol.c
@@ -33,7 +33,9 @@
  *:*/
 
 #include "symbol.h"
+#include "token.h"
 
+#include "../data/array.h"
 #include "../data/list.h"
 
 Symbol*
@@ -55,8 +57,20 @@ symbol_delete(Symbol *p_symbol) {
       list_delete(p_list_token);
    }
    break;
+   case SYM_VARIABLE: 
+   {
+	   Token *p_token = symbol_get_val(p_symbol);
+	   switch (token_get_tt(p_token)) {
+		   case TT_ARRAY:
+			   array_iterate(p_token->p_array, token_delete_cb);
+			   break;
+			   NO_DEFAULT;
+	   }
+   }
+   break;
    NO_DEFAULT;
    }
+
    free(p_symbol);
 }
 
diff --git a/src/core/token.c b/src/core/token.c
index 1a2aec9..49a9721 100644
--- a/src/core/token.c
+++ b/src/core/token.c
@@ -57,7 +57,6 @@ get_tt(char *c_token) {
    CHECK("proc") TT_PROC;
    CHECK("func") TT_FUNC;
    CHECK("my") TT_MY;
-   CHECK("arr") TT_ARR;
    CHECK("!") TT_NOT;
    CHECK("!=") TT_NEQ;
    CHECK("=~") TT_RE;
@@ -123,7 +122,6 @@ tt_get_name(TokenType tt_cur) {
       CASE(TT_PROC,"TT_PROC")
       CASE(TT_FUNC,"TT_FUNC")
       CASE(TT_MY,"TT_MY")
-      CASE(TT_ARR,"TT_ARR")
       CASE(TT_WHILE,"TT_WHILE")
       CASE(TT_UNTIL,"TT_UNTIL")
       CASE(TT_NEXT,"TT_NEXT")
@@ -248,7 +246,11 @@ Token*
 token_new_array(int i_size) {
    Token *p_token = token_new_dummy();
    token_set_tt(p_token, TT_ARRAY);
-   array_resize(p_token->p_array, i_size);
+
+   if (p_token->p_array == NULL)
+      p_token->p_array = array_new();
+
+   //array_resize(p_token->p_array, i_size);
 
    return (p_token);
 }
@@ -305,10 +307,24 @@ void token_copy_vals(Token *p_token_to, Token *p_token_from) {
       i_len = strlen(p_token_from->c_val);
       p_token_to->c_val = calloc(i_len+1, sizeof(char));
       strcpy(p_token_to->c_val, p_token_from->c_val);
+
    } else {
       p_token_to->c_val = NULL;
    }
 
+   if (p_token_from->tt_cur == TT_ARRAY) {
+	   p_token_to->p_array = array_new();
+	   ArrayIterator *p_iter = arrayiterator_new(p_token_from->p_array);
+	   while (arrayiterator_has_next(p_iter)) {
+		   Token *p_token = arrayiterator_next(p_iter);
+		   token_ref_up(p_token);
+		   array_unshift(p_token_to->p_array, p_token);
+	   }
+	   arrayiterator_delete(p_iter);
+   } else {
+	   p_token_to->p_array = NULL;
+   }
+
    p_token_to->tt_cur = p_token_from->tt_cur;
    p_token_to->i_val = p_token_from->i_val;
    p_token_to->d_val = p_token_from->d_val;
@@ -344,8 +360,10 @@ token_delete(Token *p_token) {
          if (p_token->c_val)
             free(p_token->c_val);
 
-		 if (p_token->p_array)
-			 array_delete(p_token->p_array);
+         if (p_token->p_array) {
+            array_iterate(p_token->p_array, token_delete_cb);
+            array_delete(p_token->p_array);
+         }
 
          free(p_token);
       }
@@ -366,16 +384,27 @@ token_delete(Token *p_token) {
 
 void
 token_print(Token *p_token) {
-   printf("(id=%05u, line=%05d, pos=%04d, type=%s, val=%s, ival=%d, dval=%f,"
-          " refs=%d)",
+   printf("(id=%05u, line=%05d, pos=%04d, type=%s",
           p_token->u_token_id,
           p_token->i_line_nr,
           p_token->i_pos_nr,
-          tt_get_name(p_token->tt_cur),
-          p_token->c_val,
-          p_token->i_val,
-          p_token->d_val,
-          p_token->i_ref_count);
+          tt_get_name(p_token->tt_cur));
+
+   if (IS_ARRAY(p_token)) {
+   } else {
+      printf(", val=%s, ival=%d, dval=%f",
+             p_token->c_val,
+             p_token->i_val,
+             p_token->d_val);
+   }
+
+   printf(", refs=%d)", p_token->i_ref_count);
+}
+
+void
+token_print_ln(Token *p_token) {
+   token_print(p_token);
+   printf("\n");
 }
 
 void
diff --git a/src/core/token.h b/src/core/token.h
index caf4854..af74e98 100644
--- a/src/core/token.h
+++ b/src/core/token.h
@@ -53,6 +53,8 @@
 #define IS_ASSIGNABLE(t) (START_ASSIGNABLES < t && t < END_ASSIGNABLES)
 #define IS_NUMERICAL(t) (START_NUMERICAL < t && t < END_NUMERICAL)
 #define IS_NOT_NUMERICAL(t) !(IS_NUMERICAL(t))
+#define IS_ARRAY(t) (t->tt_cur == TT_ARRAY)
+#define IS_NOT_ARRAY(t) !(IS_ARRAY(t))
 
 #define token_get_filename(t) \
 	(t->c_filename != NULL ? t->c_filename : "Code string")
@@ -86,8 +88,8 @@ typedef enum {
    TT_INTEGER,
    TT_DOUBLE,
    END_NUMERICAL,
-   TT_STRING,
    TT_ARRAY,
+   TT_STRING,
    END_ASSIGNABLES,
    TT_IDENT,
    END_TYPES,
@@ -103,7 +105,6 @@ typedef enum {
    TT_PROC,
    TT_FUNC,
    TT_MY,
-   TT_ARR,
    TT_WHILE,
    TT_UNTIL,
    TT_NEXT,
@@ -184,6 +185,7 @@ void* token_copy_cb(void *p_token);
 char* tt_get_name(TokenType tt_cur);
 void token_print_cb(void *p_void);
 void token_print(Token *p_token);
+void token_print_ln(Token *p_token);
 void token_print_val(Token *p_token);
 TokenType get_tt(char *c_token);
 
diff --git a/src/data/array.c b/src/data/array.c
index 2ae4ece..da5bee8 100644
--- a/src/data/array.c
+++ b/src/data/array.c
@@ -41,7 +41,7 @@ array_new() {
    p_array->i_size = 0;
    p_array->pp_ae = NULL;
 
-   return p_array;
+   return (p_array);
 }
 
 
@@ -92,7 +92,7 @@ array_insert(Array *p_array, int i_index, void *p_val) {
 void*
 array_remove(Array *p_array, int i_index) {
    if (p_array->i_size <= i_index)
-      return NULL;
+      return (NULL);
 
    ArrayElement *p_ae = p_array->pp_ae[i_index];
    void *p_ret = p_ae->p_val;
@@ -105,7 +105,7 @@ array_remove(Array *p_array, int i_index) {
 
    array_resize(p_array, p_array->i_size - 1);
 
-   return p_ret;
+   return (p_ret);
 }
 
 void
@@ -147,17 +147,17 @@ array_resize(Array *p_array, int i_size) {
 void*
 array_get(Array *p_array, int i_index) {
    if (p_array->i_size > i_index)
-      return p_array->pp_ae[i_index]->p_val;
+      return (p_array->pp_ae[i_index]->p_val);
 
-   return NULL;
+   return (NULL);
 }
 
 _Bool
 array_defined(Array *p_array, int i_index) {
    if (i_index >= p_array->i_size)
-      return false;
+      return (false);
 
-   return p_array->pp_ae[i_index]->p_val != NULL;
+   return (p_array->pp_ae[i_index]->p_val != NULL);
 }
 
 void
@@ -222,7 +222,7 @@ arrayelement_new(void *p_val) {
 
    p_ae->p_val = p_val;
 
-   return p_ae;
+   return (p_ae);
 }
 
 void
@@ -235,14 +235,27 @@ arrayelement_delete(ArrayElement *p_ae) {
 
 ArrayIterator*
 arrayiterator_new(Array *p_array) {
-   if (!p_array)
-      return NULL;
+   if (p_array == NULL)
+      return (NULL);
 
    ArrayIterator *p_arrayiterator = malloc(sizeof(ArrayIterator));
    p_arrayiterator->p_array = p_array;
    p_arrayiterator->i_cur_pos = 0;
+   p_arrayiterator->b_is_reverse = false;
+
+   return (p_arrayiterator);
+}
+
+ArrayIterator*
+arrayiterator_new_reverse(Array *p_array) {
+   ArrayIterator *p_arrayiterator = arrayiterator_new(p_array);
+   if (p_arrayiterator == NULL)
+      return (NULL);
+
+   p_arrayiterator->b_is_reverse = true;
+   p_arrayiterator->i_cur_pos = p_array->i_size;
 
-   return p_arrayiterator;
+   return (p_arrayiterator);
 }
 
 void
@@ -253,14 +266,21 @@ arrayiterator_delete(ArrayIterator *p_arrayiterator) {
 
 _Bool
 arrayiterator_has_next(ArrayIterator *p_arrayiterator) {
-   return p_arrayiterator->i_cur_pos <
-          array_get_size(p_arrayiterator->p_array);
+   if (p_arrayiterator->b_is_reverse)
+      return (p_arrayiterator->i_cur_pos >= 0);
+
+   return (p_arrayiterator->i_cur_pos <
+           array_get_size(p_arrayiterator->p_array));
 }
 
 void*
 arrayiterator_next(ArrayIterator *p_arrayiterator) {
    if (!arrayiterator_has_next(p_arrayiterator))
-      return NULL;
+      return (NULL);
+
+   if (p_arrayiterator->b_is_reverse)
+      return (array_get(p_arrayiterator->p_array,
+                        p_arrayiterator->i_cur_pos--));
 
-   return array_get(p_arrayiterator->p_array, p_arrayiterator->i_cur_pos++);
+   return (array_get(p_arrayiterator->p_array, p_arrayiterator->i_cur_pos++));
 }
diff --git a/src/data/array.h b/src/data/array.h
index b343521..6170c29 100644
--- a/src/data/array.h
+++ b/src/data/array.h
@@ -58,6 +58,7 @@ typedef struct {
 typedef struct {
    Array *p_array;
    int i_cur_pos;
+   _Bool b_is_reverse;
 } ArrayIterator;
 
 Array *array_new();
@@ -80,6 +81,7 @@ ArrayElement *arrayelement_new(void *p_val);
 void arrayelement_delete(ArrayElement *p_ae);
 
 ArrayIterator *arrayiterator_new(Array *p_array);
+ArrayIterator *arrayiterator_new_reverse(Array *p_array);
 void arrayiterator_delete(ArrayIterator *p_arrayiterator);
 _Bool arrayiterator_has_next(ArrayIterator *p_arrayiterator);
 void *arrayiterator_next(ArrayIterator *p_arrayiterator);
diff --git a/src/defines.h b/src/defines.h
index 569d20a..8cd1114 100644
--- a/src/defines.h
+++ b/src/defines.h
@@ -80,6 +80,7 @@
 //#define DEBUG_TRACK
 //#define DEBUG_BLOCK_GET
 //#define DEBUG_EXPRESSION_GET
+//#define DEBUG_ARRAY_GET
 
 #ifdef DEBUG_TRACK
 #define TRACK \