root/src/dd_stack.c

/**
 * builtin_stack.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 <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>

//threshold size alloctor to scale up faster
#define threshold_alloc(x) (((x)+16)*3/2)

void crl_dd_stack_push( crl_stack_t * stack, const void * obj )
{
  unsigned int idx= stack->length, tsize= 0;
  void *pstack= NULL;

  if( !stack || !obj )
    crl_fatal("undefined stack or object!\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]= obj;
  idx++; stack->length= idx;
}

inline
void* crl_dd_stack_pop( crl_stack_t *stack )
{
  void *obj;
  if( !stack || stack->length <= 0 )
    return NULL;

  obj= stack->array[ (stack->length)-1 ];
  stack->length--;

  return obj;
}

inline
void crl_dd_stack_init( crl_stack_t **stack )
{
  if( stack )
    {
      unsigned int len= threshold_alloc( 0 );
      (*stack)->array= crl_calloc( len, sizeof(void*) );
      (*stack)->size= len;
      (*stack)->length= 0;
    }
  else {
    crl_error("null stack refernce to a stack in stack_init!\n");
  }
}

/**
 * Free a stack object
 *    WARNING: does not free the contents of the nodes!
 **/
inline
void crl_dd_stack_free( crl_stack_t *stack )
{
  if( stack )
    {
      if( stack->array )
        crl_free( stack->array );
      crl_free(stack);
    }
}

inline
unsigned int crl_dd_stack_get_size( crl_stack_t *stack )
{
  unsigned int retval;
  if( !stack )
    retval= 0;
  else
    retval= stack->length;

  return retval;
}