Changeset 168c2a5ec263be75f797e77bdf8a7e3011663c1a

Timestamp:

04/19/10 17:59:02 (2 years ago)

Author:

Philip Herron <redbrain@…>

Parents:

8ff7a1b2cf2221d84f8514c3f63e025ca2cb4144

Children:

11b18d6c8033bdf184ee5924e576f0de3e5861aa

git-committer:

Philip Herron <redbrain@omicron.(none)> / 2010-04-19T17:59:02Z+0100

Message:

more refactors

Files:

• include/crules/objects.h (modified) (1 diff)
• include/crules/runtime.h (modified) (2 diffs)
• src/bb_builtin.c (modified) (1 diff)
• src/builtin_hash_table.c (modified) (11 diffs)
• src/builtin_stack.c (modified) (5 diffs)
• src/obj_class.c (modified) (3 diffs)
• src/obj_list.c (modified) (2 diffs)
• src/obj_number.c (modified) (1 diff)
• src/obj_string.c (modified) (2 diffs)
• src/rr_context.c (modified) (21 diffs)
• src/rr_runtime.c (modified) (43 diffs)
• src/ss_lexical.l (modified) (1 diff)
• src/ss_parser.y (modified) (3 diffs)

include/crules/objects.h

@@ -101 +101 @@
                                              crl_context_table *  );
 
+extern crl_symbol_obj * crl_obj_list_print( crl_symbol_obj * , crl_symbol_obj * ,
+                                            crl_context_table * );
+
+extern crl_symbol_obj * crl_obj_list_delete( crl_symbol_obj * , crl_symbol_obj * ,
+                                             crl_context_table * );
+
+// --------------------------------------------------------------------------
+
+extern crl_symbol_obj * crl_obj_string_init( crl_symbol_obj * , crl_symbol_obj * ,
+                                             crl_context_table * );
+
+extern crl_symbol_obj * crl_obj_string_push( crl_symbol_obj * , crl_symbol_obj * ,
+                                             crl_context_table *  );
+
+extern crl_symbol_obj * crl_obj_string_pop( crl_symbol_obj * , crl_symbol_obj * ,
+                                            crl_context_table * );
+
+extern crl_symbol_obj * crl_obj_string_remove( crl_symbol_obj * , crl_symbol_obj * ,
+                                               crl_context_table * );
+
+extern crl_symbol_obj * crl_obj_string_append( crl_symbol_obj * , crl_symbol_obj * ,
+                                               crl_context_table * );
+
+extern crl_symbol_obj * crl_obj_string_length( crl_symbol_obj * , crl_symbol_obj * ,
+                                               crl_context_table *  );
+
+extern crl_symbol_obj * crl_obj_string_print( crl_symbol_obj * , crl_symbol_obj * ,
+                                              crl_context_table * );
+
+extern crl_symbol_obj * crl_obj_string_delete( crl_symbol_obj * , crl_symbol_obj * ,
+                                               crl_context_table * );
+
 #endif //__OBJECTS_H_

include/crules/runtime.h

@@ -32 +32 @@
 // --------------------------------------------------------------------------
 
-extern bool crl_runtime_keyword_delete( crl_symbol_obj * , crl_context_table * );
-
 extern crl_symbol_obj * crl_runtime_loop_for( crl_symbol_obj * , crl_context_table * );
 
@@ -42 +40 @@
 extern crl_symbol_obj * crl_runtime_eval_key_break( crl_context_table * );
 
-extern bool crl_runtime_list_format( crl_table_t * , crl_context_table * );
-
 extern bool crl_runtime_assignment( crl_symbol_obj *,crl_context_table * );
-
-extern bool crl_runtime_list_print( crl_table_t * , crl_context_table *, FILE * );
 
 extern bool crl_runtime_eval_bool_item( crl_symbol_obj * );

src/bb_builtin.c

@@ -61 +61 @@
 struct crl_builtin_function_def_t builtin_module_function_table[] = {
   { "print", PARAM_VARADIC, &crl_builtin_call_print },
-  { NULL, 0 NULL },
+  { NULL, 0, NULL },
 };

src/builtin_hash_table.c

@@ -30 +30 @@
 #include <string.h>
 
-#include <unistd.h>
-#include <sys/types.h>
-
 #include <crules/crules.h>
 #include <crules/opcodes.h>
@@ -45 +42 @@
 #define threshold_alloc(x) (((x)+16)*3/2)
 
-/* Declare the tables */
-crl_table *crl_functors= NULL, *crl_rules= NULL;
-//The runtime table stack!
-crl_context_table *crl_runtime_ctx_table;
-
-static void crl_hash_grow_table( crl_table * );
+static void crl_dd_hash_grow_table( crl_table_t * );
 
 /**
@@ -61 +53 @@
  *  a Digest.., but should avoid conflicts better
  **/
-crl_hash_t crl_hash_hash( const char *string )
+crl_hash_t crl_dd_hash_hash( const char *string )
 {
   crl_hash_t hash= 0x811C9DC5;
@@ -75 +67 @@
 }
 
-crl_table_entry*
-crl_hash_lookup_table( crl_table *tbl, crl_hash_t h )
+crl_table_entry *
+crl_dd_hash_lookup_table( crl_table_t *tbl, crl_hash_t h )
 {
   crl_table_entry* retval;
@@ -102 +94 @@
 
 crl_symbol_obj**
-crl_hash_insert( crl_hash_t h, crl_symbol_obj* obj,
-                 crl_table *tbl )
+crl_dd_hash_insert( crl_hash_t h, crl_symbol_obj* obj,
+                    crl_table_t *tbl )
 {
   crl_symbol_obj **retval;
   if( tbl->nr >= tbl->size )
-    crl_hash_grow_table( tbl );
+    crl_dd_hash_grow_table( tbl );
 
-  crl_table_entry *entry= crl_hash_lookup_table( tbl, h );
+  crl_table_entry *entry= crl_dd_hash_lookup_table( tbl, h );
   if( entry->symbol )
     retval= &( entry->symbol );
@@ -122 +114 @@
 
 static
-void crl_hash_grow_table( crl_table * tbl )
+void crl_dd_hash_grow_table( crl_table_t * tbl )
 {
   unsigned int prev_size= tbl->size, size= 0, i= 0;
@@ -141 +133 @@
 
       if( s )
-        crl_hash_insert( h, s, tbl );
+        crl_dd_hash_insert( h, s, tbl );
     }
   if( prev_array )
@@ -147 +139 @@
 }
 
-void crl_hash_init_table( crl_table ** tbl )
+void crl_dd_hash_init_table( crl_table_t ** tbl )
 {
   if( tbl )
     {
-      crl_table *tb= *tbl;
+      crl_table_t *tb= *tbl;
       tb->size= 0; tb->nr= 0;
       tb->array= NULL;
@@ -161 +153 @@
 }
 
-crl_table * crl_hash_clone_table( crl_table ** table )
+crl_table_t * crl_dd_hash_clone_table( crl_table_t ** table )
 {
-  crl_table * retval = NULL;
+  crl_table_t * retval = NULL;
   if( table )
     {
-      retval = (crl_table*)
-        crl_malloc( sizeof(crl_table) );
-      crl_hash_init_table( &retval );
+      retval = (crl_table_t*)
+        crl_malloc( sizeof(crl_table_t) );
+      crl_dd_hash_init_table( &retval );
       
       crl_table_entry* array = (crl_table_entry*)
@@ -184 +176 @@
           
           if( s )
-            crl_hash_insert( h, s, retval );
+            crl_dd_hash_insert( h, s, retval );
         }
       
@@ -196 +188 @@
   return retval;
 }
-
-/**
- * Initilizes the memory tables and different
- * symbol tables
- **/
-bool crl_init_tables( void )
-{
-  crl_debug("Initilizing...\n");
-
-  crl_branch_context *ctx= (crl_branch_context*)
-    crl_malloc(sizeof( crl_branch_context ));
-  crl_context_init_context( &ctx );
-
-  crl_runtime_ctx_table= (crl_context_table*)
-    crl_malloc(sizeof( crl_context_table ));
-  crl_context_init_table( &crl_runtime_ctx_table );
-  crl_context_push( ctx, crl_runtime_ctx_table );
-
-  crl_debug("System tables initilized!\n");
-
-  crl_builtin_init( crl_runtime_ctx_table );
-  
-  pid_t pid;
-  /* get the process id */
-  if( (pid = getpid( ) ) < 0 )
-    {
-      crl_warning( "unable to get program pid" );
-    }
-  else
-    {
-      crl_debug( "started with pid <%d>!\n", pid );
-    }
-  return true;
-}

src/builtin_stack.c

@@ -42 +42 @@
 #define threshold_alloc(x) (((x)+16)*3/2)
 
-void crl_dd_stack_push( crl_stack *stack, void *obj )
+void crl_dd_stack_push( crl_stack_t *stack, void *obj )
 {
   unsigned int idx= stack->length, tsize= 0;
@@ -64 +64 @@
 
 inline
-void* crl_dd_stack_pop( crl_stack *stack )
+void* crl_dd_stack_pop( crl_stack_t *stack )
 {
   void *obj;
@@ -77 +77 @@
 
 inline
-void crl_dd_stack_init( crl_stack **stack )
+void crl_dd_stack_init( crl_stack_t **stack )
 {
   if( stack )
@@ -96 +96 @@
  **/
 inline
-void crl_dd_stack_free( crl_stack *stack )
+void crl_dd_stack_free( crl_stack_t *stack )
 {
   if( stack )
@@ -107 +107 @@
 
 inline
-unsigned int crl_dd_stack_get_size( crl_stack *stack )
+unsigned int crl_dd_stack_get_size( crl_stack_t *stack )
 {
   unsigned int retval;

src/obj_class.c

@@ -51 +51 @@
   crl_context_table *object_ctx = (crl_context_table*)
     crl_malloc( sizeof(crl_context_table) );
-  crl_context_init_table( &object_ctx );
-  crl_context_push( (obj->context), object_ctx );
+  crl_rr_context_init_table( &object_ctx );
+  crl_rr_context_push( (obj->context), object_ctx );
 
-  crl_symbol_obj** functor = crl_context_lookup_function( ident, &object_ctx );
+  crl_symbol_obj** functor = crl_rr_context_lookup_function( ident, &object_ctx );
   if( functor )
     {
@@ -66 +66 @@
   }
 
-  crl_context_pop( object_ctx );
+  crl_rr_context_pop( object_ctx );
   crl_garbage_free_context_table( &object_ctx );
 
@@ -78 +78 @@
   crl_branch_context * obj_ctx = obj->context;
 
-  crl_table_entry *ent = crl_hash_lookup_table( obj_ctx->symbol_table, crl_hash_hash(ident) );
+  crl_table_entry *ent = crl_dd_hash_lookup_table( obj_ctx->symbol_table,
+                                                   crl_dd_hash_hash( ident ) );
   if( ent )
     {

src/obj_list.c

@@ -1 +1 @@
 /**
- * object_list.c -> Part of Crules Programming language
+ * obj_list.c -> Part of Crules Programming language
  *
  * Crules is the legal property of its developers. Please refer to the
@@ -104 +104 @@
 
 struct crl_builtin_function_def_t list_module_function_table[] = {
-  { "__init__", 1, &crl_obj_list_init }
+  { "__init__", 1, &crl_obj_list_init },
   { "push", 1, &crl_obj_list_push },
   { "pop", 0, &crl_obj_list_pop },

src/obj_number.c

@@ -41 +41 @@
 crl_symbol_obj*
 crl_obj_number_to_string( crl_symbol_obj * caller,
+                          crl_symbol_obj * self,
                           crl_context_table * context )
 {

src/obj_string.c

@@ -1 +1 @@
 /**
- * string_object.c -> Part of Crules Programming language
+ * obj_string.c -> Part of Crules Programming language
  *
  * Crules is the legal property of its developers. Please refer to the
@@ -19 +19 @@
  **/
 
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#else
+# define CMAKE 1
+# include "config.h.cmake"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <crules/crules.h>
+#include <crules/opcodes.h>
+#include <crules/symbols.h>
+#include <crules/objects.h>
+#include <crules/backend.h>
+#include <crules/runtime.h>
+#include <crules/garbage.h>
+#include <crules/operators.h>
+
+crl_symbol_obj *
+crl_obj_string_init( crl_symbol_obj * caller,
+                     crl_symbol_obj * self,
+                     crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_push( crl_symbol_obj * caller,
+                     crl_symbol_obj * self,
+                     crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_pop( crl_symbol_obj * caller,
+                    crl_symbol_obj * self,
+                    crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_remove( crl_symbol_obj * caller,
+                       crl_symbol_obj * self,
+                       crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_append( crl_symbol_obj * caller,
+                       crl_symbol_obj * self,
+                       crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_length( crl_symbol_obj * caller,
+                       crl_symbol_obj * self,
+                       crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_print( crl_symbol_obj * caller,
+                      crl_symbol_obj * self,
+                      crl_context_table * context )
+{
+  return NULL;
+}
+
+crl_symbol_obj *
+crl_obj_string_delete( crl_symbol_obj * caller,
+                       crl_symbol_obj * self,
+                       crl_context_table * context )
+{
+  return NULL;
+}
+
+struct crl_builtin_function_def_t string_module_function_table[] = {
+  { "__init__", 1, &crl_obj_string_init },
+  { "push", 1, &crl_obj_string_push },
+  { "pop", 0, &crl_obj_string_pop },
+  { "remove", 1, &crl_obj_string_remove },
+  { "append", 1, &crl_obj_string_append },
+  { "length", 0, &crl_obj_string_length },
+  { "print", 0, &crl_obj_string_print },
+  { "delete", 0, &crl_obj_string_delete },
+  { NULL, 0, NULL },
+};

src/rr_context.c

@@ -29 +29 @@
 #include <stdlib.h>
 #include <string.h>
+
+#include <unistd.h>
+#include <sys/types.h>
 
 #include <crules/crules.h>
@@ -39 +42 @@
 #include <crules/operators.h>
 
+//The runtime table stack!
+crl_context_table *crl_runtime_ctx_table;
 //threshold size alloctor to scale up faster
 #define threshold_alloc(x) (((x)+16)*3/2)
 
-void crl_context_push( crl_branch_context * ctx,
+void crl_rr_context_push( crl_branch_context * ctx,
                        crl_context_table * stack )
 {
@@ -65 +70 @@
 
 crl_branch_context *
-crl_context_pop( crl_context_table * stack )
+crl_rr_context_pop( crl_context_table * stack )
 {
   crl_branch_context *ctx;
@@ -81 +86 @@
 }
 
-void crl_context_init_table( crl_context_table ** table )
+void crl_rr_context_init_table( crl_context_table ** table )
 {
   if( table )
@@ -97 +102 @@
 
 unsigned int
-crl_context_get_table_size( crl_context_table * stack )
+crl_rr_context_get_table_size( crl_context_table * stack )
 {
   unsigned int retval;
@@ -109 +114 @@
 
 crl_table_entry *
-crl_context_lookup_symbol( const char* identifier,
-                           crl_context_table ** stack )
+crl_rr_context_lookup_symbol( const char* identifier,
+                              crl_context_table ** stack )
 {
   crl_table_entry *retval;
   if( stack )
     {
-      crl_hash_t h= crl_hash_hash( identifier );
+      crl_hash_t h= crl_dd_hash_hash( identifier );
       crl_debug("looking up symbol '%s' - hash 0x%X\n",
                 identifier, h);
 
-      signed int idx= crl_context_get_table_size( (*stack) );
+      signed int idx= crl_rr_context_get_table_size( (*stack) );
       crl_debug("stack frame size :: '%i'!\n", idx );
       crl_branch_context* ctx= NULL; idx--;
@@ -130 +135 @@
 
           if( ctx->symbol_table->array )
-            ent= crl_hash_lookup_table( ctx->symbol_table, h );
+            ent= crl_dd_hash_lookup_table( ctx->symbol_table, h );
 
           if( ent )
@@ -154 +159 @@
 
 crl_symbol_obj**
-crl_context_lookup_function( const char* identifier,
-                             crl_context_table ** stack )
+crl_rr_context_lookup_function( const char* identifier,
+                                crl_context_table ** stack )
 {
   crl_symbol_obj **retval = NULL;
   if( stack )
     {
-      crl_hash_t h= crl_hash_hash( identifier );
+      crl_hash_t h= crl_dd_hash_hash( identifier );
       crl_debug( "looking up function '%s' - hash 0x%X\n",
                  identifier, h );
 
-      signed int idx= crl_context_get_table_size( (*stack) );
+      signed int idx= crl_rr_context_get_table_size( (*stack) );
       crl_debug("stack frame size :: '%i'!\n", idx );
       crl_branch_context* ctx= NULL; idx--;
@@ -175 +180 @@
 
           if( ctx->function_table->array )
-            ent= crl_hash_lookup_table( ctx->function_table, h );
+            ent= crl_dd_hash_lookup_table( ctx->function_table, h );
 
           if( ent )
@@ -199 +204 @@
 
 crl_obj_state_t **
-crl_context_lookup_object( const char* identifier,
+crl_rr_context_lookup_object( const char* identifier,
                            crl_context_table ** stack )
 {
@@ -205 +210 @@
   if( stack )
     {
-      crl_hash_t h= crl_hash_hash( identifier );
+      crl_hash_t h= crl_dd_hash_hash( identifier );
       crl_debug( "looking up function '%s' - hash 0x%X\n",
                  identifier, h );
 
-      signed int idx= crl_context_get_table_size( (*stack) );
+      signed int idx= crl_rr_context_get_table_size( (*stack) );
       crl_debug("stack frame size :: '%i'!\n", idx );
       crl_branch_context* ctx= NULL; idx--;
@@ -220 +225 @@
 
           if( ctx->object_table->array )
-            ent= crl_hash_lookup_table( ctx->object_table, h );
+            ent= crl_dd_hash_lookup_table( ctx->object_table, h );
 
           if( ent )
@@ -249 +254 @@
 {
   bool retval = true;
-  crl_symbol_obj** f = crl_context_lookup_function( functor->identifier, context );
+  crl_symbol_obj** f = crl_rr_context_lookup_function( functor->identifier, context );
   if( !f )
     {
       // not defined!
-      crl_symbol_obj **s= crl_hash_insert( crl_hash_hash( functor->identifier ),
-                                           functor, ((*context)->curr->function_table) );
+      crl_symbol_obj **s= crl_dd_hash_insert( crl_dd_hash_hash( functor->identifier ),
+                                              functor, ((*context)->curr->function_table) );
       // this shouldn't happen!
       if( s )
@@ -277 +282 @@
 
   crl_assert( object->op_a_t == TYPE_STRING );
-  crl_obj_state_t ** o = crl_context_lookup_object( object->op_a.string,
-                                                    context );
+  crl_obj_state_t ** o = crl_rr_context_lookup_object( object->op_a.string,
+                                                       context );
   bool retval = true;
   if( !o )
@@ -285 +290 @@
       crl_obj_state_t *obj_state = (crl_obj_state_t*)
         crl_malloc( sizeof(crl_obj_state_t) );
+      
       obj_state->identifier = crl_strdup( object->op_a.string );
       obj_state->state = CLASS_UNINIT;
@@ -291 +297 @@
         crl_malloc( sizeof(crl_branch_context) );
 
-      crl_context_init_context( &object_ctx );
-      crl_context_push( object_ctx, (*context) );
+      crl_rr_context_init( &object_ctx );
+      crl_rr_context_push( object_ctx, (*context) );
       
       if( !(retval = crl_runtime_exec_toplevel( object->op_b.symbol_table, (*context) )) )
@@ -298 +304 @@
 
       crl_debug("poping object stack frame!\n");
-      obj_state->context = crl_context_pop( (*context) );
+      obj_state->context = crl_rr_context_pop( (*context) );
 
       crl_symbol_obj *object_def;
@@ -305 +311 @@
       object_def->op_a.object_state = obj_state;
 
-      crl_symbol_obj **s= crl_hash_insert( crl_hash_hash( object->op_a.string ),
+      crl_symbol_obj **s= crl_dd_hash_insert( crl_dd_hash_hash( object->op_a.string ),
                                            object_def, ((*context)->curr->object_table) );
       // this shouldn't happen!
@@ -330 +336 @@
       (*branch)->loop_ctx= false;
 
-      (*branch)->symbol_table= (crl_table *)
-        crl_malloc( sizeof( crl_table ) );
-      (*branch)->function_table= (crl_table *)
-        crl_malloc( sizeof( crl_table ) );
-      (*branch)->object_table= (crl_table *)
-        crl_malloc( sizeof( crl_table ) );
-
-      crl_hash_init_table( &((*branch)->symbol_table) );
-      crl_hash_init_table( &((*branch)->function_table) );
-      crl_hash_init_table( &((*branch)->object_table) );
+      (*branch)->symbol_table= (crl_table_t *)
+        crl_malloc( sizeof( crl_table_t ) );
+      (*branch)->function_table= (crl_table_t *)
+        crl_malloc( sizeof( crl_table_t ) );
+      (*branch)->object_table= (crl_table_t *)
+        crl_malloc( sizeof( crl_table_t ) );
+
+      crl_dd_hash_init_table( &((*branch)->symbol_table) );
+      crl_dd_hash_init_table( &((*branch)->function_table) );
+      crl_dd_hash_init_table( &((*branch)->object_table) );
     }
   else
@@ -373 +379 @@
       retval->loop_ctx = (*ctx)->loop_ctx;
 
-      retval->symbol_table = crl_hash_clone_table( &((*ctx)->symbol_table) );
-      retval->function_table = crl_hash_clone_table( &((*ctx)->function_table) );
-      retval->object_table = crl_hash_clone_table( &((*ctx)->object_table) );
+      retval->symbol_table = crl_dd_hash_clone_table( &((*ctx)->symbol_table) );
+      retval->function_table = crl_dd_hash_clone_table( &((*ctx)->function_table) );
+      retval->object_table = crl_dd_hash_clone_table( &((*ctx)->object_table) );
     }
   return retval;
@@ -396 +402 @@
   return retval;
 }
+
+/**
+ * Initilizes the memory tables and different
+ * symbol tables
+ **/
+bool crl_init_tables( void )
+{
+  crl_debug("Initilizing...\n");
+
+  crl_branch_context *ctx= (crl_branch_context*)
+    crl_malloc(sizeof( crl_branch_context ));
+  crl_context_init_context( &ctx );
+
+  crl_runtime_ctx_table= (crl_context_table*)
+    crl_malloc(sizeof( crl_context_table ));
+  crl_rr_context_init_table( &crl_runtime_ctx_table );
+  crl_rr_context_push( ctx, crl_runtime_ctx_table );
+
+  crl_debug("System tables initilized!\n");
+
+  /* Init object types and modules! */
+  // ....
+  
+  pid_t pid;
+  /* get the process id */
+  if( (pid = getpid( ) ) < 0 )
+    {
+      crl_warning( "unable to get program pid" );
+    }
+  else
+    {
+      crl_debug( "started with pid <%d>!\n", pid );
+    }
+  return true;
+}

src/rr_runtime.c

@@ -1 @@
-#/**
+/**
  * rr_runtime.c -> Part of Crules Programming language
  *
@@ -63 +63 @@
 
 /**
- * @param list is the list to be checked if it is valid or not!
- *
- * @param context holds the stack tables of symbols
- *
- * @returns true or false depending if the list symbols are,
- * valid and within scope of the context
- **/
-bool crl_runtime_list_format( crl_table *list,
-                              crl_context_table *context )
-{
-  crl_debug("formating list...\n");
-  unsigned int i= 0; bool chk= true;
-  crl_table_entry* ei= NULL;
-
-  crl_symbol_obj *t= NULL;
-  for( ; i<list->nr; ++i )
-    {
-      ei= crl_list_access_idx( i, &list );
-      t= crl_runtime_evaluate_expression( ei->symbol, context );
-      crl_garbage_mark_obj( &(ei->symbol) );
-      ei->symbol= t;
-    }
-  return chk;
-}
-
-/**
  * @param sym is the symbol representing the whole assignment
  * should be a symbol of type OP_ASSIGN with operands A and B of
@@ -113 +87 @@
     {
       crl_assert( accessor->op_a_t == TYPE_STRING );
-      var= crl_context_lookup_symbol( accessor->op_a.string, &context );
+      var= crl_rr_context_lookup_symbol( accessor->op_a.string, &context );
 
       if( !var )
         {
           crl_symbol_obj *item= sym->op_b.symbol_table;
-          crl_symbol_obj **s= crl_hash_insert( crl_hash_hash( accessor->op_a.string ),
+          crl_symbol_obj **s= crl_dd_hash_insert( crl_dd_hash_hash( accessor->op_a.string ),
                                                item, context->curr->symbol_table );
           exec= true;
@@ -141 +115 @@
         }
     }
-  else if( accessor->type == SYMBOL_INDEX_REF )
-    {
-      crl_assert( accessor->op_a_t == TYPE_STRING );
-      crl_assert( accessor->op_b_t == TYPE_SYMBOL );
-
-      var= crl_context_lookup_symbol( accessor->op_a.string, &context );
-      if( var )
-        {
-          crl_symbol_obj* ev= crl_runtime_evaluate_expression( accessor->op_b.symbol_table,
-                                                               context );
-          if( var->symbol->op_a_t == TYPE_LIST )
-            {
-              if( ev->op_a_t == TYPE_INTEGER )
-                {
-                  crl_table_entry *e= crl_list_access_idx( ev->op_a.integer,
-                                                           &(var->symbol->op_a.list_table) );
-                  if( !e )
-                    {
-                      crl_fatal("symbol list <%s> item at index <%i> is undefined!\n",
-                                accessor->op_a.string, ev->op_a.integer );
-                    }
-
-                  crl_symbol_obj *p= e->symbol;
-                  crl_symbol_obj *item= sym->op_b.symbol_table;
-                  if( !(e->symbol= item ) )
-                    {
-                      exec= false;
-                      crl_error("error assigning the symbol!\n");
-                    }
-                  crl_garbage_mark_obj( &p );
-                }
-              else
-                {
-                  crl_error("Invalid index accessor type <0x%x>!\n",
-                            ev->op_a_t ); exec= false;
-                }
-            }
-          else if( var->symbol->op_a_t == TYPE_STRING )
-            {
-              crl_fatal("string index access not implemented yet!\n");
-            }
-          else
-            {
-              crl_error("Invalid symbol to access index <0x%X>!\n",
-                        var->symbol->op_a_t );
-            }
-          crl_garbage_mark_obj( &ev );
-        }
-      else
-        {
-          crl_error("undefined symbol <%s>!\n",
-                    accessor->op_a.string ); exec= false;
-        }
-    }
   else
     {
@@ -206 +126 @@
 }
 
-/**
- * @param list is the list to be printed
- * @param context is the symbol table of symbols
- * @param fd the file-descriptor to print to
- *
- * @return returns true or false depending if the operation was valid or not!
- **/
-bool crl_runtime_list_print( crl_table* list,
-                             crl_context_table *context,
-                             FILE * fd )
-{
-  bool retval= false;
-  if( list )
-    {
-      unsigned int i=0, sz= list->nr;
-      fprintf(fd, "[ ");
-      for ( ; i<sz; ++i )
-        {
-          crl_table_entry *e= crl_list_access_idx( i, &list );
-          if( e )
-            {
-              crl_symbol_obj *sym= e->symbol;
-              crl_runtime_object_print( sym, context, fd, false );
-
-              if( i < sz-1 )
-                fprintf(fd, ", ");
-            }
-          else
-            crl_fatal("Undefined list symbol at index %i\n", i);
-        }
-      fprintf( fd, " ] " );
-      retval= true;
-    }
-  else
-    {
-      crl_error("null list in print_list!\n");
-      retval= false;
-    }
-  return retval;
-}
-
 crl_symbol_obj*
 crl_runtime_eval_key_break( crl_context_table *ctx )
@@ -252 +131 @@
   crl_symbol_obj* retval= NULL;
   //look for the loop return address!
-  signed int len= crl_context_get_table_size( ctx );
+  signed int len= crl_rr_context_get_table_size( ctx );
   crl_branch_context *c; len--; bool f= false;
 
@@ -278 +157 @@
   crl_symbol_obj* retval= NULL;
   //look for the loop return address!
-  signed int len= crl_context_get_table_size( ctx );
+  signed int len= crl_rr_context_get_table_size( ctx );
   crl_branch_context *c; len--; bool f= false;
 
@@ -311 +190 @@
   crl_branch_context *loop_ctx= (crl_branch_context*)
     crl_malloc(sizeof( crl_branch_context ));
-  crl_context_init_context( &loop_ctx );
+  crl_rr_context_init( &loop_ctx );
   loop_ctx->loop_ctx= true;
-  crl_context_push( loop_ctx, context );
+  crl_rr_context_push( loop_ctx, context );
 
   crl_symbol_obj *f_ctx = sym->op_a.symbol_table;
@@ -379 +258 @@
 
   crl_debug("freeing local stack frame!\n");
-  crl_branch_context* ctx= crl_context_pop( context );
+  crl_branch_context* ctx= crl_rr_context_pop( context );
   crl_garbage_free_context_branch( &ctx );
   crl_debug("done freeing stack frame!\n");
@@ -403 +282 @@
   crl_branch_context *branch_ctx= (crl_branch_context*)
     crl_malloc(sizeof( crl_branch_context ));
-  crl_context_init_context( &branch_ctx );
+  crl_rr_context_init( &branch_ctx );
   branch_ctx->loop_ctx= true;
-  crl_context_push( branch_ctx, context );
+  crl_rr_context_push( branch_ctx, context );
 
   while( i_eval == true )
@@ -458 +337 @@
 
   crl_debug("freeing local stack frame!\n");
-  crl_branch_context* ctx= crl_context_pop( context );
+  crl_branch_context* ctx= crl_rr_context_pop( context );
   crl_garbage_free_context_branch( &ctx );
   crl_debug("done freeing stack frame!\n");
@@ -473 +352 @@
                           crl_context_table *context )
 {
-  crl_assert( sym->type == SYMBOL_INDEX_REF );
-  crl_assert( sym->op_a_t == TYPE_STRING );
-  crl_assert( sym->op_b_t == TYPE_SYMBOL );
-  crl_symbol_obj *retval = NULL;
-
-  crl_table_entry* var= crl_context_lookup_symbol( sym->op_a.string, &context );
-  if( var )
-    {
-      if( var->symbol->op_a_t == TYPE_LIST )
-        {
-          crl_symbol_obj *o= var->symbol;
-          crl_symbol_obj *eval= crl_runtime_evaluate_expression( sym->op_b.symbol_table,
-                                                                 context );
-          if( eval )
-            {
-              if( eval->op_a_t == TYPE_INTEGER )
-                {
-                  crl_table_entry* e= crl_list_access_idx( eval->op_a.integer,
-                                                           &(o->op_a.list_table) );
-                  if( e )
-                    retval= e->symbol;
-                  else
-                    {
-                      crl_fatal("symbol list <%s> with item at index <%i> is undefined!\n",
-                                sym->op_a.string, eval->op_a.integer );
-                    }
-                }
-              else
-                {
-                  crl_error("invalid index object accessor type <0x%X>!\n",
-                            eval->op_a_t );
-                  retval= NULL;
-                }
-            }
-          else
-            {
-              crl_error("index expression evaluation error!\n");
-              retval= NULL;
-            }
-        }
-      else if( var->symbol->op_a_t == TYPE_STRING )
-        {
-          retval= NULL;
-        }
-      else
-        {
-          crl_error("invalid object type <0x%x> for index access!\n",
-                    var->symbol->op_a_t );
-          retval= NULL;
-        }
-    }
-  else
-    {
-      crl_error("symbol object <%s> is undefined!\n", sym->op_a.string );
-      retval= NULL;
-    }
-  return retval;
+  crl_fatal("not implemented yet!\n");
+  return NULL;
 }
 
@@ -582 +406 @@
 
         case TYPE_LIST:
-          crl_runtime_list_print( sym->op_a.list_table, context, fd );
+          crl_fatal("not imeplemented yet!\n");
           exec= true;
           break;
@@ -624 +448 @@
     {
       crl_assert( sym->op_a_t == TYPE_STRING );
-      crl_table_entry* var= crl_context_lookup_symbol( sym->op_a.string, &context );
+      crl_table_entry* var= crl_rr_context_lookup_symbol( sym->op_a.string, &context );
       if( var )
         {
@@ -670 +494 @@
               sizeof(unsigned short) );
 
-      crl_table *lst= NULL;
+      crl_table_t *lst= NULL;
       switch( (*sym)->op_a_t )
         {
@@ -693 +517 @@
 
         case TYPE_LIST:
-          if( !(lst= crl_list_clone( &((*sym)->op_a.list_table ))) )
-            crl_error("error cloning list!\n");
-          retval->op_a.list_table= lst;
+          crl_fatal("not implemented yet!\n");
           break;
 
@@ -709 +531 @@
 
         case TYPE_OBJECT:
-          retval->op_a.object_state = crl_context_clone_obj_state( &((*sym)->op_a.object_state) );
+          retval->op_a.object_state = crl_rr_context_clone_obj_state( &((*sym)->op_a.object_state) );
           break;
 
         case TYPE_BUILTIN:
-          retval->op_a.callback = crl_builtin_clone_callback( &(*sym)->op_a.callback );
+          crl_fatal("not implemented yet!\n");
           break;
 
@@ -752 +574 @@
 
         case TYPE_LIST:
-          if( !(lst= crl_list_clone( &((*sym)->op_b.list_table ))) )
-            crl_error("error cloning list!\n");
-          retval->op_b.list_table= lst;
+          crl_fatal("not implemented yet!\n");
           break;
 
@@ -770 +590 @@
           if( (*sym)->op_b.stack_table )
             {
-              crl_stack* t= (crl_stack*)
-                crl_malloc( sizeof(crl_stack) );
-              crl_stack_init( &t );
+              crl_stack_t* t= (crl_stack_t*)
+                crl_malloc( sizeof(crl_stack_t) );
+              crl_dd_stack_init( &t );
               unsigned int len=
-                crl_stack_get_size( (*sym)->op_b.stack_table );
+                crl_dd_stack_get_size( (*sym)->op_b.stack_table );
               unsigned int idx= 0;
               for( ; idx<len; ++idx )
@@ -780 +600 @@
                   crl_symbol_obj *o=  (*sym)->op_b.stack_table->array[ idx ];
                   crl_symbol_obj *r= crl_runtime_obj_clone( &o, false );
-                  crl_stack_push( t, r );
+                  crl_dd_stack_push( t, r );
                 }
               retval->op_b.stack_table= t;
@@ -787 +607 @@
 
         case TYPE_OBJECT:
-          retval->op_b.object_state = crl_context_clone_obj_state( &((*sym)->op_b.object_state) );
+          retval->op_b.object_state = crl_rr_context_clone_obj_state( &((*sym)->op_b.object_state) );
           break;
 
         case TYPE_BUILTIN:
-          retval->op_b.callback = crl_builtin_clone_callback( &(*sym)->op_b.callback );
+          crl_fatal("not imeplemented yet!\n");
           break;
 
@@ -1059 +879 @@
     {
       crl_debug("expression is a singleton item!\n");
-      if( sym->op_a_t == TYPE_LIST )
-        {
-          if( crl_runtime_list_format( sym->op_a.list_table, context ) == false )
-            {
-              crl_fatal("problem formating the list assignment!\n");
-              retval = NULL;
-            }
-        }
       retval= crl_runtime_obj_clone( &sym, false );
     }
@@ -1073 +885 @@
       crl_debug("singleton symbol refernce!\n");
       crl_assert( sym->op_a_t == TYPE_STRING );
-      crl_table_entry* ei= crl_context_lookup_symbol( sym->op_a.string,
+      crl_table_entry* ei= crl_rr_context_lookup_symbol( sym->op_a.string,
                                                       &context );
       if( ei )
@@ -1112 +924 @@
     {
       char *object_ident = sym->op_a.symbol_table->op_a.string;
-      crl_obj_state_t ** o = crl_context_lookup_object( object_ident, &context );
+      crl_obj_state_t ** o = crl_rr_context_lookup_object( object_ident, &context );
       if( o )
         {
@@ -1133 +945 @@
           retval->type = SYMBOL_PRIMARY;
           retval->op_a_t = TYPE_OBJECT;
-          retval->op_a.object_state = crl_context_clone_obj_state( o );
+          retval->op_a.object_state = crl_rr_context_clone_obj_state( o );
 
           // its now initilized!
@@ -1238 +1050 @@
       if( sym->op_a_t == TYPE_LIST )
         {
-          if( crl_runtime_list_format( sym->op_a.list_table, context ) == false )
-            {
-              crl_fatal("problem formating the list assignment!\n");
-              retval = NULL;
-            }
+          crl_fatal("not imeplemented yet!\n");
         }
       retval= crl_runtime_obj_clone( &sym, false );
@@ -1250 +1058 @@
       crl_debug("singleton symbol refernce!\n");
       crl_assert( sym->op_a_t == TYPE_STRING );
-      crl_table_entry* ei= crl_context_lookup_symbol( sym->op_a.string,
+      crl_table_entry* ei= crl_rr_context_lookup_symbol( sym->op_a.string,
                                                &context );
       if( ei )
@@ -1289 +1097 @@
     {
       char *object_ident = sym->op_a.symbol_table->op_a.string;
-      crl_obj_state_t ** o = crl_context_lookup_object( object_ident, &context );
+      crl_obj_state_t ** o = crl_rr_context_lookup_object( object_ident, &context );
       if( o )
         {
@@ -1310 +1118 @@
           retval->type = SYMBOL_PRIMARY;
           retval->op_a_t = TYPE_OBJECT;
-          retval->op_a.object_state = crl_context_clone_obj_state( o );
+          retval->op_a.object_state = crl_rr_context_clone_obj_state( o );
 
           // its now initilized!
@@ -1346 +1154 @@
   crl_branch_context *argument_ctx= (crl_branch_context*)
     crl_malloc(sizeof( crl_branch_context ));
-  crl_context_init_context( &argument_ctx );
+  crl_rr_context_init( &argument_ctx );
   argument_ctx->return_ctx= true;
-  crl_context_push( argument_ctx, function_ctx );
+  crl_rr_context_push( argument_ctx, function_ctx );
   
   if( (*functor_def)->op_b_t == TYPE_PARAMETERS )
     {
-      unsigned int n_parameters = crl_stack_get_size( (*functor_def)->op_b.stack_table );
+      unsigned int n_parameters = crl_dd_stack_get_size( (*functor_def)->op_b.stack_table );
       unsigned int n_arguments = 0;
 
@@ -1358 +1166 @@
       if( call->op_b_t == TYPE_ARGUMENTS )
         {
-          n_arguments = crl_stack_get_size( call->op_b.stack_table );
+          n_arguments = crl_dd_stack_get_size( call->op_b.stack_table );
           if( n_arguments >= n_parameters )
             {
@@ -1378 +1186 @@
                   crl_assert( o->type == SYMBOL_PRIMARY );
 
-                  crl_symbol_obj** s= crl_hash_insert( crl_hash_hash( param_idx ) ,
-                                                       o , function_ctx->curr->symbol_table );
+                  crl_symbol_obj** s= crl_dd_hash_insert( crl_dd_hash_hash( param_idx ) ,
+                                                          o , function_ctx->curr->symbol_table );
                   if( s )
                     {
@@ -1405 +1213 @@
 
   crl_debug("Function returned!\n");
-  crl_branch_context* arg_ctx_t= crl_context_pop( function_ctx );
+  crl_branch_context* arg_ctx_t= crl_rr_context_pop( function_ctx );
   if( ctx_retval )
     {
@@ -1423 +1231 @@
 {
   crl_assert( sym->op_a_t == TYPE_STRING ); crl_symbol_obj* retval= NULL;
-  crl_symbol_obj** proc= crl_context_lookup_function( sym->op_a.string, &context ); 
+  crl_symbol_obj** proc= crl_rr_context_lookup_function( sym->op_a.string, &context ); 
 
   if( proc )
@@ -1429 +1237 @@
       crl_context_table *goto_ctx_table= (crl_context_table*)
         crl_malloc(sizeof( crl_context_table ));
-      crl_context_init_table( &goto_ctx_table );
-
-      unsigned int context_length= crl_context_get_table_size( context );
+      crl_rr_context_init_table( &goto_ctx_table );
+
+      unsigned int context_length= crl_rr_context_get_table_size( context );
       unsigned int ctx_idx= 0; crl_branch_context* ctx_t;
 
@@ -1444 +1252 @@
           else
             {
-              crl_context_push( ctx_t, goto_ctx_table );
+              crl_rr_context_push( ctx_t, goto_ctx_table );
             }
         }
@@ -1453 +1261 @@
       unsigned int i = 0;
       for( ; i<ctx_idx; ++i )
-        crl_context_pop( goto_ctx_table );
+        crl_rr_context_pop( goto_ctx_table );
 
       crl_garbage_free_context_table( &goto_ctx_table );
@@ -1478 +1286 @@
     {
       //look for the return address!
-      signed int len= crl_context_get_table_size( ctx );
+      signed int len= crl_rr_context_get_table_size( ctx );
       crl_branch_context *c; len--; bool f= false;
 
@@ -1516 +1324 @@
     crl_malloc(sizeof( crl_branch_context ));
 
-  crl_context_init_context( &branch_ctx );
-  crl_context_push( branch_ctx, context );
+  crl_rr_context_init( &branch_ctx );
+  crl_rr_context_push( branch_ctx, context );
 
   retval= crl_runtime_exec_branch( sym, context );
@@ -1525 +1333 @@
 
   crl_debug("freeing local stack frame!\n");
-  crl_branch_context* ctx= crl_context_pop( context );
+  crl_branch_context* ctx= crl_rr_context_pop( context );
   crl_garbage_free_context_branch( &ctx );
   crl_debug("done freeing stack frame!\n");
 
   return retval;
-}
-
-/**
- * Limited to deleting variables cannot delete functions!
- *
- * Note semanticaly the symbol is marked as garbage, this is
- * a nice hint to the garbage collector if you want to memory
- * consious on low memory systems, remember normal ref-counting
- * and conservative collection continue's, so if it is seen as garbage
- * the collector will eventually delete it.
- **/
-bool crl_runtime_keyword_delete( crl_symbol_obj *sym, 
-                                 crl_context_table *context )
-{
-  crl_assert( sym->type == KEY_DELETE ); bool retval = true;
-  crl_debug("atempting to mark symbol <%s> as garbage!\n", sym->op_a.string );
-
-  crl_table_entry *var= crl_context_lookup_symbol( sym->op_a.string, &context );
-  if( var )
-    {
-      if( var->symbol )
-        {
-          crl_symbol_obj *s = var->symbol;
-          var->symbol = NULL;
-          crl_garbage_mark_obj( &s );
-        }
-    }
-  return (retval);
 }
 
@@ -1620 +1400 @@
             case KEY_BREAK:
               rex= crl_runtime_eval_key_break( context );
-              break;
-
-            case KEY_DELETE:
-              crl_runtime_keyword_delete( sym, context );
               break;
 
@@ -1704 +1480 @@
               break;
 
-            case KEY_DELETE:
-              crl_runtime_keyword_delete( sym, context );
-              break;
-
             case SYMBOL_REFERENCE:
               if( crl_interactive )
@@ -1740 +1512 @@
 
             case STRUCTURE_FUNCTION_DEF:
-              if( crl_context_push_function_def( sym, &context ) == false )
+              if( crl_rr_context_push_function_def( sym, &context ) == false )
                 crl_fatal("error pushing function definition!\n");
               break;
 
             case STRUCTURE_OBJECT_DEF:
-              if( crl_context_push_object_def( sym, &context ) == false)
+              if( crl_rr_context_push_object_def( sym, &context ) == false)
                 crl_fatal("error pushing object definition");
               break;

src/ss_lexical.l

@@ -105 +105 @@
 continue                {  return CONTINUE; }
 return                  {  return RETURN; }
-delete                  {  return DELETE; }
 for                     {  return FOR; }
 while                   {  return WHILE; }

src/ss_parser.y

@@ -76 +76 @@
 %token CONTINUE "conintue"
 %token RETURN "return"
-%token DELETE "delete"
 %token WHILE "while"
 %token FOR "for"
@@ -133 +132 @@
 %type<symbol> return_keyword
 %type<symbol> continue_keyword
-%type<symbol> delete_keyword
 %type<symbol> procedure
 %type<symbol> pblock
@@ -875 +873 @@
          | return_keyword ';'
          | continue_keyword ';'
-         | delete_keyword ';'
          | control_structure
          ;
-
-delete_keyword: DELETE IDENTIFIER
-        {
-          crl_symbol_obj *sym;
-          crl_symbol_init( sym );
-          sym->type= KEY_DELETE;
-          sym->op_a_t = TYPE_STRING;
-          sym->op_a.string = $2;
-          $$= sym;
-        }
 
 continue_keyword: CONTINUE