root/src/rr_context.c

/**
 * rr_context.c -> Part of Crules Programming language
 *
 * Crules is the legal property of its developers. Please refer to the
 * COPYRIGHT file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 **/

#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 <unistd.h>
#include <sys/types.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>

//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_rr_context_push( crl_branch_context * ctx,
                          crl_context_table * stack )
{
  unsigned int idx= stack->length, tsize= 0;
  void *pstack= NULL;

  if( !stack || !ctx )
    crl_fatal("undefined stack or table!\n");

  if( stack->length >= stack->size )
    {
      tsize= threshold_alloc( stack->size );
      pstack= crl_realloc( stack->array,tsize * sizeof(void*) );
      stack->array= pstack;
      stack->size= tsize;
    }

  stack->array[ idx ]= ctx;
  stack->curr= ctx;
  idx++; stack->length= idx;
}

crl_branch_context *
crl_rr_context_pop( crl_context_table * stack, bool deref )
{
  crl_branch_context *ctx = NULL;
  if( !stack || stack->length <= 0 )
    return NULL;

  ctx= stack->array[ ((stack->length)-1) ];
  stack->length--;
  if( stack->length > 0 )
    stack->curr= (stack->array[ (stack->length) - 1 ]);
  else
    stack->curr= NULL;

  if( deref )
    {
      crl_symbol_obj *xret = ctx->return_address;
      void ** arr = ctx->symbol_stack->array;
      unsigned int idx = 0;
      unsigned int n_elms = ctx->symbol_stack->length;
      for( ; idx<n_elms; ++idx )
        {
          crl_symbol_obj *o = (crl_symbol_obj*) arr[ idx ];
          if( o )
            {
              if( o != xret )
                {
                  o->n_ref--;
                  crl_debug("de-referencing object <%p> to count <%i>!\n",
                            (void*)o, o->n_ref );
                }
            }
        }

      // def any local symbols pointing to the objects!
      idx = 0; crl_table_entry *c_arr = ctx->symbol_table->array;
      for( ; idx<(ctx->symbol_table->size); ++idx )
        {
          crl_symbol_obj *o = c_arr[idx].symbol;

          if( o )
            {
              o->n_ref--;
              crl_debug("de-referencing object <%p> to count <%i>!\n",
                        (void*)o, o->n_ref );
            }
        }      
    }

  return ctx;
}

void crl_rr_context_init_table( crl_context_table ** table )
{
  if( table )
    {
      unsigned int xlen= threshold_alloc( 0 );
      (*table)->array= crl_calloc( xlen, sizeof( crl_branch_context * ) );
      (*table)->size= xlen; (*table)->length= 0;
      (*table)->curr= NULL;
    }
  else
    {
      crl_error("null table refernce to a table in table init!\n");
    }
}

unsigned int
crl_rr_context_get_table_size( crl_context_table * stack )
{
  unsigned int retval;
  if( !stack )
    retval= 0;
  else
    retval= (stack->length);

  return retval;
}

crl_table_entry *
crl_rr_context_lookup_symbol( const char* identifier,
                              crl_context_table ** stack )
{
  crl_table_entry *retval;
  if( stack )
    {
      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_rr_context_get_table_size( (*stack) );
      crl_debug("stack frame size :: '%i'!\n", idx );
      crl_branch_context* ctx= NULL; idx--;

      retval= NULL;
      while( idx >= 0 )
        {
          ctx= ( (*stack)->array[ idx ] );
          crl_table_entry *ent= NULL;

          if( ctx->symbol_table->array )
            ent= crl_dd_hash_lookup_table( ctx->symbol_table, h );

          if( ent )
            {
              if( ent->symbol )
                {
                  crl_debug("found symbol <%s> hash <0x%X> frame <%i> addr <%p> ref count <%u>!\n", 
                            identifier, h, (idx+1), (void *) ent->symbol, ent->symbol->n_ref );
                  retval= ent;
                  break;
                }
            }
          idx--;
        }
    }
  else
    {
      crl_error("null stack table for lookup!\n");
      retval= NULL;
    }
  return retval;
}

crl_symbol_obj**
crl_rr_context_lookup_function_def( const char* identifier,
                                    crl_context_table ** stack )
{
  crl_symbol_obj **retval = NULL;
  if( stack )
    {
      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_rr_context_get_table_size( (*stack) );
      crl_debug("stack frame size :: '%i'!\n", idx );
      crl_branch_context* ctx= NULL; idx--;

      retval= NULL;
      while( idx >= 0 )
        {
          ctx= ( (*stack)->array[ idx ] );
          crl_table_entry *ent= NULL;

          if( ctx->function_table->array )
            ent= crl_dd_hash_lookup_table( ctx->function_table, h );

          if( ent )
            {
              if( ent->symbol )
                {
                  crl_debug("found symbol function <%s> - hash <0x%X> frame <%i> addr <%p>!\n", 
                            identifier, h, (idx+1), (void *) ent->symbol );
                  retval= &(ent->symbol);
                  break;
                }
            }
          idx--;
        }
    }
  else
    {
      crl_error("null stack table for lookup!\n");
      retval = NULL;
    }
  return retval;
}

crl_type_obj_def_t **
crl_rr_context_lookup_object_def( const char * identifier,
                                  crl_context_table ** stack )
{
  crl_type_obj_def_t ** retval = NULL;
  if( stack )
    {
      crl_hash_t h= crl_dd_hash_hash( identifier );
      crl_debug( "looking up defintion '%s' - hash 0x%X\n",
                 identifier, h );

      signed int idx= crl_rr_context_get_table_size( (*stack) );
      crl_debug("stack frame size :: '%i'!\n", idx );
      crl_branch_context* ctx= NULL; idx--;

      retval= NULL;
      while( idx >= 0 )
        {
          ctx= ( (*stack)->array[ idx ] );
          crl_table_entry *ent= NULL;

          if( ctx->object_table->array )
            ent= crl_dd_hash_lookup_table( ctx->object_table, h );

          if( ent )
            {
              if( ent->symbol )
                {
                  crl_debug("found object definition <%s> - hash <0x%X> frame <%i> addr <%p>!\n", 
                            identifier, h, (idx+1), (void*) ent->symbol );
                  crl_assert( ent->symbol->type == STRUCTURE_OBJECT_DEF );
                  retval= &( ent->symbol->op_a.object_def );
                  crl_debug("got object def address!\n");
                  break;
                }
            }
          idx--;
        }
    }
  else
    {
      crl_error("null stack table for lookup!\n");
      retval = NULL;
    }
  return retval;
}

bool crl_rr_context_push_function_def( crl_symbol_obj * functor,
                                       crl_context_table ** context )
{
  bool retval = true;
  crl_symbol_obj** f = crl_rr_context_lookup_function_def( functor->identifier, context );
  if( !f )
    {
      // not defined!
      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 )
        {
          crl_error("problem assigning '%s'!\n", functor->identifier );
          retval = false;
        }
    }
  else
    {
      // already defined!
      retval = false;
      crl_error( "error pushing function definition <%s> is already defined!\n",
                 functor->identifier );
    }
  return retval;
}

static
void crl_rr_obj_init_members( struct crl_builtin_member_def_t * members,
                              crl_branch_context * obj_ctx )
{
  return;
}

struct crl_number_prot_t *
crl_rr_context_clone_n_prot( struct crl_number_prot_t * prot )
{
  struct crl_number_prot_t * retval = NULL;
  if( prot )
    {
      retval = crl_malloc( sizeof(struct crl_number_prot_t) );
      retval->init = prot->init;
      retval->n_add = prot->n_add;
      retval->n_sub = prot->n_sub;
      retval->n_div = prot->n_div;
      retval->n_mul = prot->n_mul;
      retval->n_pow = prot->n_pow;
      retval->n_let = prot->n_let;
      retval->n_lee = prot->n_lee;
      retval->n_get = prot->n_get;
      retval->n_gee = prot->n_gee;
      retval->n_eee = prot->n_eee;
      retval->n_nee = prot->n_nee;
      retval->n_orr = prot->n_orr;
      retval->n_and = prot->n_and;
    }
  return retval;
}

bool crl_rr_context_init_member_functions( crl_branch_context * context ,
                                           struct crl_builtin_function_def_t * functions )
{
  bool retval = true;
  unsigned int idx = 0;
  while( functions[idx].identifier != NULL )
    {
      crl_debug("initilizing member <%s>!\n", functions[idx].identifier );
      crl_symbol_obj *o;
      Crl_Symbol_Init( o );

      struct crl_builtin_function_def_t * call =
        crl_malloc( sizeof(struct crl_builtin_function_def_t) );
      call->identifier = crl_strdup( functions[idx].identifier );
      memcpy( &(call->n_parameters), &(functions[idx].n_parameters),
              sizeof(int) );
      call->callback = functions[idx].callback;

      o->identifier = crl_strdup( functions[idx].identifier );
      o->type = TYPE_BUILTIN_CALLBACK;
      o->op_a_t = TYPE_BUILTIN_CALLBACK;
      o->op_a.callback = call;

      crl_symbol_obj **s= crl_dd_hash_insert( crl_dd_hash_hash( functions[idx].identifier ),
                                              o, (context->function_table) );
      // this shouldn't happen!
      if( s )
        {
          crl_error("error inserting table defined function <%s> idx <%i>!\n",
                    functions[idx].identifier, idx );
          retval = false;
          break;
        }
      idx++;
    }
  return retval;
}

bool crl_rr_context_push_obj_def( crl_symbol_obj * obj_def,
                                  crl_context_table ** context )
{
  bool retval = true;
  crl_assert( obj_def->op_a_t == TYPE_STRING );
  crl_debug("trying to push module definition <%s>!\n", obj_def->op_a.string );
  
  crl_type_obj_def_t ** chk = crl_rr_context_lookup_object_def( obj_def->op_a.string,
                                                                context );
  if( chk )
    {
      crl_error("object <%s> is already defined!\n", obj_def->op_a.string );
      retval = false;
    }
  else
    {
      crl_branch_context *ctx= (crl_branch_context*)
        crl_malloc(sizeof( crl_branch_context ));
      crl_rr_context_init( &ctx );
      crl_context_table * o_ctx = (crl_context_table *)
        crl_malloc( sizeof(crl_context_table) );
      crl_rr_context_init_table( &(o_ctx) );

      crl_rr_context_push( ((*context)->array[0]), o_ctx );
      crl_rr_context_push( ctx, o_ctx );

      crl_assert( obj_def->op_b_t == TYPE_SYMBOL );
      crl_symbol_obj * t1 = crl_runtime_exec_branch( obj_def->op_b.symbol_table,
                                                     o_ctx );
      if( t1 ) { crl_garbage_mark_obj( &t1 ); }
      crl_branch_context *c_ctx = crl_rr_context_pop( o_ctx,false );
      if( c_ctx != ctx )
        {
          crl_fatal("corruption in context table!\n");
        }
      crl_rr_context_pop( o_ctx, false );
      crl_garbage_free_context_table( &(o_ctx) );

      struct crl_type_obj_def_t * obj = (struct crl_type_obj_def_t *)
        crl_malloc(sizeof(struct crl_type_obj_def_t));
  
      obj->identifier = crl_strdup( obj_def->op_a.string );
      obj->builtin_type_size = 0;
      obj->init_hook = NULL;
      obj->destroy_hook = NULL;
      obj->print_hook = NULL;
      obj->context = ctx;
      obj->binary_protocol = NULL;
      obj->member_fields = NULL;
      obj->member_functions = NULL;
      obj->builtin = false;

      crl_symbol_obj * oo;
      Crl_Symbol_Init( oo );
      oo->type = STRUCTURE_OBJECT_DEF;
      oo->op_a_t = STRUCTURE_OBJECT_DEF;
      oo->op_a.object_def = obj;

      crl_debug("trying to insert object def <%s> <%p>!\n", obj_def->op_a.string, (void *)oo );
      crl_symbol_obj **s= crl_dd_hash_insert( crl_dd_hash_hash( obj_def->op_a.string ),
                                              oo, ((*context)->curr->object_table) );
      if( s )
        {
          crl_error("error inserting object definition <%s>!\n", obj_def->op_a.string );
          retval = false;
        }
    }
  return retval;
}

bool crl_rr_context_push_type_def( struct crl_type_obj_def_t * type_def,
                                   crl_context_table ** context )
{
  bool retval = true;
  crl_debug("trying to push module definition <%s>!\n", type_def->identifier );
  crl_type_obj_def_t ** chk = crl_rr_context_lookup_object_def( type_def->identifier,
                                                                context );
  if( chk )
    {
      crl_error("object <%s> is already defined!\n", type_def->identifier );
      retval = false;
    }
  else
    {
      crl_symbol_obj * obj;
      Crl_Symbol_Init( obj );

      struct crl_type_obj_def_t * obj_def = (struct crl_type_obj_def_t *)
        crl_malloc(sizeof(struct crl_type_obj_def_t));
      obj_def->identifier = crl_strdup( type_def->identifier );
      memcpy( &(obj_def->builtin_type_size), &(type_def->builtin_type_size),
              sizeof( size_t ) );
      obj_def->init_hook = type_def->init_hook;
      obj_def->destroy_hook = type_def->destroy_hook;
      obj_def->print_hook = type_def->print_hook;

      crl_branch_context *ctx= type_def->context;
      if( !ctx )
        {
          ctx= crl_malloc( sizeof( crl_branch_context ) );
          crl_rr_context_init( &ctx );
        }
      if( type_def->member_fields ) {
        crl_rr_obj_init_members( type_def->member_fields, ctx );
      }

      crl_rr_context_init_member_functions( ctx, type_def->member_functions );

      obj_def->context = ctx;
      obj_def->binary_protocol = crl_rr_context_clone_n_prot( type_def->binary_protocol );
      obj_def->member_fields = NULL;
      obj_def->member_functions = NULL;
      obj_def->builtin = true;

      obj->type = STRUCTURE_OBJECT_DEF;
      obj->op_a_t = STRUCTURE_OBJECT_DEF;
      obj->op_a.object_def = obj_def;

      crl_debug("trying to insert object def <%s> <%p>!\n", type_def->identifier, (void *) obj );
      crl_symbol_obj **s= crl_dd_hash_insert( crl_dd_hash_hash( type_def->identifier ),
                                              obj, ((*context)->curr->object_table) );
      if( s )
        {
          crl_error("error inserting object definition <%s>!\n", type_def->identifier );
          retval = false;
        }
    }
  return retval;
}

void crl_rr_context_init( crl_branch_context ** branch )
{
  if( branch )
    {
      (*branch)->return_address= NULL;
      (*branch)->return_ctx= false;
      (*branch)->loop_ctx= false;

      (*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 ) );

      (*branch)->symbol_stack = (crl_stack_t *)
        crl_malloc( sizeof(crl_stack_t) );
      crl_dd_stack_init( &((*branch)->symbol_stack) );

      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
    {
      crl_error("null branch context to init!\n");
    }
}

/**
 * WARNING:
 *   This will not clone the return address even if it exists!
 *
 * workaround: if your using this function you then have the reference to the
 * context you want to clone do:
 *
 * crl_branch_context *ctx = crl_context_clone_branch( &cloneme );
 * if( (ctx->return_ctx) || (ctx->loop_ctx) ) {
 *   ctx->return_address = crl_runtime_obj_clone( cloneme->return_address, ... );
 * }
 *
 * @param ctx the context to clone
 * @returns returns address to cloned context
 **/
crl_branch_context *
crl_rr_context_clone_branch( crl_branch_context ** ctx )
{
  crl_branch_context * retval = (crl_branch_context*)
    crl_malloc(sizeof(crl_branch_context));

  if( ctx )
    {
      retval->return_ctx = (*ctx)->return_ctx;
      retval->loop_ctx = (*ctx)->loop_ctx;

      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;
}

crl_obj_state_t *
crl_rr_context_clone_obj_state( crl_obj_state_t ** obj_s )
{
  crl_debug("clone object state!\n");
  crl_obj_state_t *retval = NULL;
  if( obj_s )
    {
      retval = (crl_obj_state_t *)
        crl_malloc( sizeof(crl_obj_state_t) );

      struct crl_type_obj_def_t ** def = (*obj_s)->definition;
      void * s = crl_malloc( (*def)->builtin_type_size );
      memcpy( s, (*obj_s)->self, (*def)->builtin_type_size );
      retval->self = s;

      retval->identifier = crl_strdup( (*obj_s)->identifier );
      retval->context = crl_rr_context_clone_branch( &((*obj_s)->context) );
      retval->definition = (*obj_s)->definition;
    }
  return retval;
}

bool crl_rr_context_intilize_module( struct crl_type_obj_def_t * module_def,
                                     crl_context_table * context )
{
  bool retval = false;

  retval = crl_rr_context_push_type_def( module_def, &context );

  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_rr_context_init( &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 );

  /* Init object types and modules! */
  crl_builtin_modules_init( crl_runtime_ctx_table );

  crl_debug("System tables initilized!\n");

  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;
}