root/src/obj_integer.c

/**
 * obj_integer.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 <math.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>
#include <crules/math.h>

static crl_type_integer_t *
crl_obj_integer_init( crl_symbol_obj * args,
                      crl_type_obj_def_t ** def )
{
  crl_type_integer_t *s = crl_malloc( ((*def)->builtin_type_size) );
  crl_assert( args->op_a_t == TYPE_INTEGER );
  memcpy( &(s->integer), &(args->op_a.integer),
          sizeof(long int) );
  return s;
}

crl_symbol_obj *
crl_obj_integer_to_string( crl_symbol_obj * caller, crl_symbol_obj * self,
                           crl_context_table * caller_ctx,
                           crl_context_table * function_ctx )
{
  printf("\nHELLLLLLLLO\n\n");

  return NULL;
}

bool crl_obj_integer_print( crl_type_integer_t * self, FILE * fd,
                            bool newline )
{
  bool retval = true;
  fprintf( fd, "%li", self->integer );
  if( newline )
    {
      fprintf( fd, "\n" );
    }
  return retval;
}

void crl_obj_integer_destroy( crl_type_integer_t * self )
{
  if( self )
    crl_free( self )
}

crl_symbol_obj *
crl_obj_integer_add( crl_symbol_obj * opa, crl_symbol_obj * opb,
                     crl_context_table * context )
{
  crl_symbol_obj * retval = NULL;
  crl_debug("Integer addition!\n");

  crl_obj_state_t *o1, *o2;
  crl_assert( opa->op_a_t == TYPE_OBJECT );
  crl_assert( opb->op_a_t == TYPE_OBJECT );

  o1 = opa->op_a.object_state;
  o2 = opb->op_a.object_state;

  if( !strcmp( o1->identifier, "Int" ) )
    {
      crl_type_integer_t *t1 = (crl_type_integer_t *) o1->self;
      if( !strcmp(o2->identifier, "Int") )
        {
          crl_type_integer_t *t2 = (crl_type_integer_t *) o2->self;

          mpfr_t x,y,z;
          mpfr_init( z );
          mpfr_init_set_si( x, t1->integer, GMP_RNDU );
          mpfr_init_set_si( y, t2->integer, GMP_RNDU );

          if( mpfr_add( z, x, y, GMP_RNDU ) )
            {
              crl_fatal("overflow in integer addition!\n");
            }

          crl_symbol_obj * init;
          Crl_Symbol_Init( init );
          init->type = SYMBOL_PRIMARY;
          init->op_a_t = TYPE_INTEGER;
          init->op_a.integer = mpfr_get_si( z, GMP_RNDU );

          mpfr_clears( x, y, z, (mpfr_ptr)0 );

          retval = crl_rr_literal_fold( init, context );
          crl_garbage_mark_obj( &init );
        }
      else
        {
          crl_fatal("invalid object type <%s>!\n", o2->identifier );
        }
    }
  else
    {
      crl_fatal("invalid object type <%s>!\n", o1->identifier );
    }

  return retval;
}

struct crl_number_prot_t integer_module_binary_ops = {
  true,
  &crl_obj_integer_add,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
  NULL,
};

const struct crl_builtin_function_def_t integer_module_function_table[] = {
  { "to_string", 0, &crl_obj_integer_to_string },
  { NULL, 0, NULL },
} ;

const struct crl_builtin_member_def_t integer_module_member_table[] = {
  { 0, NULL },
} ;

const struct crl_type_obj_def_t integer_object = {
  "Int",
  sizeof( crl_type_integer_t ),
  &crl_obj_integer_init,
  &crl_obj_integer_destroy,
  &crl_obj_integer_print,
  NULL,
  &integer_module_binary_ops,
  integer_module_member_table,
  integer_module_function_table,
  true,
} ;

bool crl_obj_integer_module_init( crl_context_table * context )
{
  bool retval = false;
  retval = crl_rr_context_intilize_module( &integer_object, context );
  return retval;
}