root/src/rr_math.c

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

#define Crl_Lookup_Object_DEF( x,y,z )                  \
  x = crl_rr_context_lookup_object_def( y, z );         \
  if( !x ) {                                            \
    crl_error("object <%s> not defined!\n", y );        \
  }

#define Crl_Eval_Primary( x,y,z )               \
  crl_assert( x->type == SYMBOL_PRIMARY );      \
  if( x->op_a_t != TYPE_OBJECT ) {              \
    y = crl_rr_literal_fold( x, z );            \
    y->n_ref--;                                 \
  }                                             \
  else { y = x; }


crl_symbol_obj *
crl_rr_math_dispatch( crl_symbol_obj *opa, crl_symbol_obj * opb,
                      crl_context_table * ctx, crl_opcode_t operator )
{
  crl_debug("inside math dispatch!\n");
  crl_symbol_obj *t1, *t2, *retval = NULL;
  crl_debug( "opa->op_a_t = <0x%x> opb->op_a_t = <0x%x>!\n",
             opa->op_a_t, opb->op_a_t );
  Crl_Eval_Primary( opa, t1, ctx );
  Crl_Eval_Primary( opb, t2, ctx );

  struct crl_type_obj_def_t ** def = t1->op_a.object_state->definition;
  struct crl_number_prot_t * p = (*def)->binary_protocol;
  char * op_str = NULL;

  if( p->init )
    {
      binary_op op = NULL;
      switch( operator )
        {
        case OP_BIN_ADDITION:
          op = p->n_add;
          op_str = " + ";
          break;

          //....

        default:
          crl_error("un handled operator type <0x%x>!\n", operator );
          break;
        }

      if( op )
        {
          crl_debug( "got operator <0x%x> for type <%s>!\n",
                     operator, t1->op_a.object_state->identifier );
#ifdef DEBUG
          Crl_Math_Operation_Echo( t1, t2, op_str );
#endif
          // call the operator!
          retval = op( t1, t2, ctx );
#ifdef DEBUG
          if( retval )
            {
              fprintf( crlerr, "debug: <%s:%s:%i> -> ", __FILE__, __func__, __LINE__ );
              crl_runtime_object_print( retval, NULL, crlerr, false );
              fprintf( crlerr, "!\n" );
            }
#endif
        }
    }
  else
    {
      crl_error( "object <%s> has no binary operator protocol!\n",
                 t1->identifier );
    }

  return retval;
}