root/src/gg_garbage.c

/**
 * gg_garbage.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 <gmp.h>
#include <mpfr.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>

#define Crl_Free_Table_Quick( x )                       \
  if( x ) { if( x->array ) { crl_free( x->array); }     \
    crl_free( x ); }

typedef struct crl_symbol_node_t {
  crl_symbol_obj * object;
  struct crl_symbol_node_t *next;
} crl_sym_node_t ;

typedef struct crl_symbol_stack {
  unsigned int length;
  crl_sym_node_t * head;
  crl_sym_node_t * tail;
} crl_sym_stack_t ;

/* Declare the tables */
extern crl_stack_t * crl_parse_stk, * crl_lex_stack;
extern crl_context_table * crl_runtime_ctx_table;

static crl_stack_t * crl_runtime_gbg = NULL;
static crl_sym_stack_t * crl_object_table = NULL;

static void free_hash_table_symbols( crl_table_t ** );

void crl_garbage_push_object( crl_symbol_obj * obj )
{
  if( obj )
    {
      crl_debug("pushing object <%p>!\n", (void *) obj );

      if( !crl_object_table )
        {
          crl_object_table = (crl_sym_stack_t *)
            crl_malloc( sizeof(crl_sym_stack_t) );
          crl_object_table->length = 0;
          crl_object_table->head = NULL;
          crl_object_table->tail = NULL;
        }

      crl_object_table->length++;
      if( !(crl_object_table->head) )
        {
          crl_sym_node_t *o = (crl_sym_node_t *)
            crl_malloc( sizeof(crl_sym_node_t) );
          o->object = obj;
          o->next = NULL;

          crl_object_table->head = o;
        }

      crl_sym_node_t * o = (crl_sym_node_t *)
        crl_malloc( sizeof(crl_sym_node_t) );
      o->object = obj;
      o->next = NULL;

      crl_object_table->head->next = o;
      crl_object_table->tail = o;
    }
  else
    {
      crl_warning("invalid object <%p>!\n", (void *) obj );
    }
}

void crl_garbage_lex_free( void )
{
  if( crl_lex_stack )
    {
      char * o;
      while( (o= crl_dd_stack_pop( crl_lex_stack )) )
        {
          crl_free( o );
        }
      crl_dd_stack_free( crl_lex_stack );
      crl_lex_stack= NULL;
    }
}

void crl_garbage_invoke( void )
{
  if( crl_runtime_gbg )
    {
      crl_debug("garbage collector running...\n");
      crl_symbol_obj *p_obj = NULL;

      while( (p_obj= crl_dd_stack_pop( crl_runtime_gbg)) )
        {
          crl_garbage_free_obj( &p_obj );
        }
      crl_dd_stack_free( crl_runtime_gbg );
      crl_runtime_gbg = NULL;
    }
}

void crl_garbage_mark_obj__( crl_symbol_obj ** const sym )
{
  if( sym )
    {
      if( crl_runtime_gbg )
        {
          crl_dd_stack_push( crl_runtime_gbg, (*sym) );
        }
      else
        {
          crl_runtime_gbg= (crl_stack_t *)
            crl_malloc(sizeof(crl_stack_t));
          crl_dd_stack_init( &crl_runtime_gbg );

          crl_dd_stack_push( crl_runtime_gbg, (*sym) );
        }
    }
}

void crl_garbage_invoke_sweep( crl_context_table * context )
{
  unsigned int ctx_l = crl_rr_context_get_table_size( context );
  if( context )
    {
      crl_debug("sweeping context table for garbage length <%u>...\n", ctx_l);
      crl_branch_context* ctx_idx = NULL; signed int idx = (ctx_l - 1);

      while( idx >= 0 )
        {
          ctx_idx = context->array[ idx ];
          void ** s_arr = ctx_idx->symbol_stack->array;

          int i = 0; unsigned int len = (ctx_idx->symbol_stack->length);
          crl_debug("stack length = <%u>!\n", len );
          for( ; i<len; ++i )
            {
              crl_symbol_obj * o = (crl_symbol_obj *) s_arr[ i ];
              if( o )
                {
                  crl_debug( "object <%p> has ref count <%u>!\n",
                             (void *) o, o->n_ref );

                  // If no references remain
                  if( o->n_ref <= 0 )
                    {
                      crl_garbage_mark_obj( &o );
                      s_arr[ i ] = NULL;
                    }
                }
            }
          idx--;
        }
    }
  crl_garbage_invoke( );
}


/* Cleanup the program for exit! */
bool crl_cleanup( void )
{
  crl_debug("cleanup.......\n");
#ifdef DEBUG
  crl_print_stats( );
#endif

  crl_destroy_lexer( );

  crl_garbage_lex_free( );

  mpfr_free_cache( );

  if( crl_runtime_ctx_table )
    {
      crl_debug("freeing runtime context!\n");
      crl_garbage_free_context_table( &crl_runtime_ctx_table );
      crl_debug("done!\n");
    }

  if( crl_parse_stk )
    {
      crl_debug("freeing parse stk!\n");
      crl_dd_stack_free( crl_parse_stk );
      crl_debug("done!\n");
    }

#ifdef DEBUG
  crl_print_stats( );
#endif
  return true;
}

void crl_garbage_free_obj( crl_symbol_obj ** sym )
{
  if( sym )
    {
      crl_debug("deleting object <%p>!\n", (void *) (*sym) );

      if( (*sym)->identifier )
        {
          crl_debug("garbage symbol identifier '%s'\n", (*sym)->identifier );
          crl_free( (*sym)->identifier );
        }

      switch( (*sym)->op_a_t )
        {
        case TYPE_LIST:
          crl_fatal("not implemented yet!\n");
          break;

        case TYPE_STRING:
          if( (*sym)->op_a.string )
            {
              char *xstr= (char*) (*sym)->op_a.string;
              crl_free( xstr );
            }
          break;

        case TYPE_SYMBOL:
          crl_garbage_free_obj( &((*sym)->op_a.symbol_table) );
          break;

        case TYPE_OBJECT:
          if( (*sym)->op_a.object_state )
            {
              crl_obj_state_t * o = (*sym)->op_a.object_state;
              // dont free the definition its used as a reference
              // to the definition hooks!!!
              struct crl_type_obj_def_t *def = (*(o->definition));
              crl_free( o->identifier );
              if( o->self )
                {
                  def->destroy_hook( o->self );
                }
              // crl_garbage_free_context_branch( &(o->context) );
              crl_free( o );
            }
          break;

        case STRUCTURE_OBJECT_DEF:
          if( (*sym)->op_a.object_def )
            {
              struct crl_type_obj_def_t * o = (*sym)->op_a.object_def;
              crl_debug("freeing object definition <%s>!\n", o->identifier );
              crl_free( o->identifier );
              crl_garbage_free_context_branch( NULL, (o->context) );
              if( o->binary_protocol )
                {
                  crl_free( o->binary_protocol );
                }
              crl_free( o );
            }
          break;

        case TYPE_BUILTIN_CALLBACK:
          if( (*sym)->op_a.callback )
            {
              struct crl_builtin_function_def_t * call = (*sym)->op_a.callback;
              crl_free( call->identifier );
              crl_free( call );
            }
          break;

        case TYPE_PARAMETERS:
          if( (*sym)->op_a.stack_table )
            {
              crl_stack_t *p = (*sym)->op_a.stack_table;
              crl_symbol_obj * o = NULL;
              while( (o= (crl_symbol_obj*) crl_dd_stack_pop( p ) ) )
                {
                  printf("freeing param!\n\n");
                  char * i = o->op_a.string;
                  crl_free( i );
                  crl_free( o );
                }
              crl_dd_stack_free( p );
            }
          break;

        default:
          break;
        }

      switch( (*sym)->op_b_t )
        {
        case TYPE_LIST:
          crl_fatal("not implemented yet!\n");
          break;

        case TYPE_STRING:
          if( (*sym)->op_b.string )
            {
              char *xstr= (char*) (*sym)->op_b.string;
              crl_free( xstr );
            }
          break;

        case TYPE_SYMBOL:
          crl_garbage_free_obj( &((*sym)->op_b.symbol_table) );
          break;

        case TYPE_PARAMETERS:
          if( (*sym)->op_b.stack_table )
            {
              crl_stack_t *p = (*sym)->op_b.stack_table;
              crl_symbol_obj * o = NULL;
              while( (o= (crl_symbol_obj*) crl_dd_stack_pop( p )) )
                {
                  char * i = o->op_a.string;
                  crl_free( i );
                  crl_free( o );
                }
              crl_dd_stack_free( p );
            }
          break;

        case TYPE_ARGUMENTS:
          if( (*sym)->op_b.stack_table )
            {
              crl_stack_t *t= (*sym)->op_b.stack_table;
              crl_symbol_obj * o= crl_dd_stack_pop( t );
              while( o )
                {
                  crl_garbage_free_obj( &o );
                  o= crl_dd_stack_pop( t );
                }
              crl_dd_stack_free( t );
            }
          break;

        default:
          break;
        }

      if( (*sym)->next )
        crl_garbage_free_obj( &((*sym)->next) );

      // free this object finally!
      crl_free( (*sym) );
      (*sym) = NULL;
    }
  else
    {
      // just in-case to give us warnings if this happens
      crl_warning( "freeing null symbol at address <%p>!\n",
                   (void*)(sym) );
    }
}

void crl_garbage_free_hash_table( crl_table_t ** table )
{
  crl_debug("freeing hash table!\n");
  free_hash_table_symbols( table );
  crl_free( (*table) );
}

static
void free_hash_table_symbols( crl_table_t ** table )
{
  if( table )
    {
      crl_debug("free_hash_table_symbols!\n");
      unsigned int idx = 0;
      crl_table_entry *array= (*table)->array;
      if( array )
        {
          for( ; idx<(*table)->size; ++idx )
            {
              crl_symbol_obj *sym= array[ idx ].symbol;
              if( sym ) {
                crl_garbage_free_obj( &sym );
              }
            }
          crl_free( (*table)->array );
        }
      (*table)->array = NULL;
      (*table)->size = 0;
      (*table)->nr = 0;
    }
  else
    {
      crl_error("freeing null hash table!\n");
    }
}

void crl_garbage_free_context_branch( crl_branch_context * head,
                                      crl_branch_context * ctx )
{
  if( ctx )
    {
      Crl_Free_Table_Quick( ctx->symbol_table );
      Crl_Free_Table_Quick( ctx->function_table );
      Crl_Free_Table_Quick( ctx->object_table );

      void ** s_arr = ctx->symbol_stack->array;
      unsigned int idx = 0, straggers = 0; crl_symbol_obj *it = NULL;
      for( ; idx<ctx->symbol_stack->length; ++idx )
        {
          it = (crl_symbol_obj*) s_arr[ idx ];
          if( it )
            {
              if( it->n_ref <= 0 )
                {
                  crl_debug("marking object <%p>!\n", (void*)it );
                  crl_garbage_mark_obj( &it );
                  s_arr[ idx ] = NULL;
                }
            }
        }

      idx = 0; // reset to loop over for any stragglers!
      for( ; idx<ctx->symbol_stack->length; ++idx )
        {
          it = (crl_symbol_obj*) s_arr[ idx ];
          if( it )
            {
              if( head )
                {
                  // push this into the the other ctx!
                  crl_debug("pushing up object <%p> ref count <%i>!\n",
                            (void*)it, it->n_ref );
                  crl_dd_stack_push( head->symbol_stack, it );
                  s_arr[idx] = NULL;
                }
              else
                {
                  straggers++;
                  crl_debug("stragger object <%p> with ref count <%i>!\n",
                            (void*)it, it->n_ref);
                }
            }
        }
      // finally free the context!
      crl_free( ctx );
    }
  else {
    crl_fatal("null context branch frame!\n");
  }
}

void crl_garbage_free_context_table( crl_context_table ** stack )
{
  signed int len= crl_rr_context_get_table_size( *stack );
  crl_debug("stack frame size :: '%i'!\n", len );
  crl_branch_context* table = NULL;

  while( (table = crl_rr_context_pop( (*stack),true )) )
    {
      if( table )
        {
          crl_garbage_free_context_branch( Crl_Ctx_Head_Branch((*stack)), table );
        }
    }

  if( ((*stack)->array) ) {
    crl_free( ((*stack)->array) );
  }
  crl_free( (*stack) );
}