root/src/bb_backend.c

/**
 * bb_backend.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
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <stdarg.h>
#include <signal.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>

// so as we can free the lexer on a fatal!
extern void yylex_destroy( void );

#ifdef DEBUG
static volatile int n_malloc  = 0;
static volatile int n_calloc  = 0;
static volatile int n_realloc = 0;
static volatile int n_free    = 0;
#endif

extern void crl_catch_signal( int signal );

inline
void crl_init_signals( void )
{
  void (*sig_catch)( int );
  sig_catch= &crl_catch_signal;

  signal( SIGINT, sig_catch );
  signal( SIGQUIT, sig_catch );
  signal( SIGTERM, sig_catch );
}

/**
 *\return basic malloc but xmalloc, fail on exhaustion
 **/
inline
void * crl_malloc ( size_t size )
  __crl_malloc
{
  register void* mm= malloc( size );
#ifdef DEBUG
  n_malloc++;
#endif
  if ( !mm )
    crl_fatal("Heap size limit reached!\n");

  return mm;
}

/**
 *\return basic calloc but fail on exhaustion
 **/
inline
void * crl_calloc( size_t num, size_t size )
  __crl_malloc
{
  register void* mm= calloc( num, size );
#ifdef DEBUG
  n_calloc++;
#endif
  if ( !mm )
    crl_fatal("Heap size limit reached!\n");

  return mm;
}

/**
 *\return returns realloc of the pointer to that size
 **/
inline
void * crl_realloc ( void *ptr, size_t size )
  __crl_malloc
{
  register void* mm= realloc( ptr, size );
#ifdef DEBUG
  n_realloc++;
#endif
  if ( !mm )
    crl_fatal("Heap size limit reached!\n");

  return mm;
}

#ifdef DEBUG
inline
void __crl_free__( size_t size )
{
  n_free++;
}
#endif

/**
 *\return returns the string dump of str
 **/
inline
char* crl_strdup( const char* str )
  __crl_pure
{
#ifdef HAVE_STRDUP
  return ( strdup( str ) );
#else
  register size_t len= (crl_strlen( str )+1);
  register char *ret= crl_malloc( len );
  memcpy(ret, str, len);
  return ret;
#endif
}

/**
 * \return the length of the string to the null terminator
 * '\0'
 **/
inline
size_t crl_strlen( const char * str )
  __crl_pure
{
#ifdef HAVE_STRLEN
  return ( strlen( str ) );
#else
  size_t i= 0;
  while( *str != '\0' )
    {
      i++;
      *str++;
    }
  return i;
#endif
}

#ifdef DEBUG
void crl_print_stats( void )
{
  crl_printf("--- Crules Alloc Stats ---\n");
  crl_printf("\t* number malloc\t\t%i\n", n_malloc);
  crl_printf("\t* number calloc\t\t%i\n", n_calloc);
  crl_printf("\t* number realloc\t%i\n", n_realloc);
  crl_printf("\t* number free\t\t%i\n", n_free);
  crl_printf("---  --- --- --- ---\n");
}
#endif

inline
void __crl_printf__( const char* file, unsigned int line,
                     const char* functor, const char* fmt, ... )
  __crl_pure
{
  fprintf( crlerr, "log: <%s:%s:%i> -> ",
           file, functor, line);
  va_list args;
  va_start( args, fmt );
  vfprintf( crlerr, fmt, args );
  va_end( args );
}

inline
void __crl_debug__( const char* file, unsigned int line,
                    const char* functor, const char* fmt, ... )
  __crl_pure
{
#ifdef DEBUG
  fprintf( crlerr, "debug: <%s:%s:%i> -> ",
           file, functor, line);
  va_list args;
  va_start( args, fmt );
  vfprintf( crlerr, fmt, args );
  va_end( args );
#else
  return;
#endif
}

inline
void __crl_error__( const char* file, unsigned int line,
                    const char* functor, const char* fmt, ... )
  __crl_pure
{
#ifdef DEBUG
  fprintf( crlerr, "error: <%s:%s:%i> -> ",
           file, functor, line);
#else
  fprintf( crlerr, "error: -> ");
#endif
  va_list args;
  va_start( args, fmt );
  vfprintf( crlerr, fmt, args );
  va_end( args );
}

inline
void __crl_warning__( const char* file, unsigned int line,
                      const char* functor, const char* fmt, ... )
  __crl_pure
{
#ifdef DEBUG
  fprintf( crlerr, "warning: <%s:%s:%i> -> ",
           file, functor, line);
#else
  fprintf( crlerr, "warning: ->");
#endif
  va_list args;
  va_start( args, fmt );
  vfprintf( crlerr, fmt, args );
  va_end( args );
}

inline
void __crl_fatal__( const char* file, unsigned int line,
                    const char* functor, const char* fmt, ... )
  __crl_no_return
{
#ifdef DEBUG
  fprintf( crlerr, "fatal: <%s:%s:%i> -> ",
           file, functor, line);
#else
  fprintf( crlerr, "error: -> ");
#endif
  va_list args;
  va_start( args, fmt );
  vfprintf( crlerr, fmt, args );
  va_end( args );

  // cleanups before exit!
  crl_cleanup( );
  exit( EXIT_FAILURE );
}

/**
 * a way of overiding assert.h to give a more
 * specific assertion method.. crlassert
 **/
inline
void crl_assertion_failed( const char * assertion, unsigned int line,
                           const char * file, const char * functor )
{
  fprintf( crlout, "fatal: <%s:%s:%i> -> assertion '%s' failed exiting...\n",
           file, functor, line, assertion );
  crl_cleanup( );
  exit( EXIT_FAILURE );
}