c_numeric.c

Go to the documentation of this file.

 
/***** Feature test switches ************************************************/
/***** System headers *******************************************************/
//@cond
#include "vm_config.h"
#include <stdio.h>
#include <limits.h>
#if MRBC_USE_FLOAT
#include <math.h>
#endif
//@endcond
 
/***** Local headers ********************************************************/
#include "mrubyc.h"
 
/***** Constat values *******************************************************/
/***** Macros ***************************************************************/
#if MRBC_USE_FLOAT == 1
#define MRBC_POW powf
#else
#define MRBC_POW pow
#endif
 
/***** Typedefs *************************************************************/
/***** Function prototypes **************************************************/
/***** Local variables ******************************************************/
/***** Global variables *****************************************************/
/***** Signal catching functions ********************************************/
/***** Local functions ******************************************************/
 
/***** Integer class ********************************************************/
//================================================================
static void c_integer_bitref(mrbc_vm *vm, mrbc_value v[], int argc)
{
  const int INT_BITS = sizeof(mrbc_int_t) * CHAR_BIT;
 
  if( mrbc_integer(v[1]) < 0 || mrbc_integer(v[1]) >= INT_BITS ||
      (argc != 1 && mrbc_integer(v[2]) <= 0) ) {
    SET_INT_RETURN( 0 );
  } else {
    mrbc_uint_t mask;
    if( argc == 1 ) {
      mask = 1;
    } else if( mrbc_integer(v[2]) >= INT_BITS ) {
      mask = (mrbc_uint_t)-1;
    } else {
      mask = ((mrbc_uint_t)1 << mrbc_integer(v[2])) - 1;
    }
    mrbc_uint_t ret = (mrbc_uint_t)(mrbc_integer(v[0]) >> mrbc_integer(v[1]));
    SET_INT_RETURN( (mrbc_int_t)(ret & mask) );
  }
}
 
 
//================================================================
static void c_integer_positive(mrbc_vm *vm, mrbc_value v[], int argc)
{
  // do nothing
}
 
 
//================================================================
static void c_integer_negative(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[0]);
  SET_INT_RETURN( -num );
}
 
 
//================================================================
static void c_integer_power(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_type(v[1]) == MRBC_TT_INTEGER ) {
    mrbc_int_t x = 1;
 
    if( mrbc_integer(v[1]) < 0 ) x = 0;
    for( int i = 0; i < mrbc_integer(v[1]); i++ ) {
      x *= mrbc_integer(v[0]);
    }
    SET_INT_RETURN( x );
  }
 
#if MRBC_USE_FLOAT && MRBC_USE_MATH
  else if( mrbc_type(v[1]) == MRBC_TT_FLOAT ) {
    SET_FLOAT_RETURN( MRBC_POW( mrbc_integer(v[0]), mrbc_float(v[1])));
  }
#endif
}
 
 
//================================================================
static void c_integer_mod(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_type(v[1]) != MRBC_TT_INTEGER ) {
    mrbc_raise(vm, MRBC_CLASS(TypeError), 0 );
    return;
  }
 
  mrbc_int_t v0 = v[0].i;
  mrbc_int_t v1 = v[1].i;
 
  if( v1 == 0 ) {
    mrbc_raise(vm, MRBC_CLASS(ZeroDivisionError), 0 );
    return;
  }
 
  mrbc_int_t ret = v0 % v1;
 
  if( (ret != 0) && ((v0 ^ v1) < 0) ) ret += v1;
  SET_INT_RETURN( ret );
}
 
 
//================================================================
static void c_integer_and(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[1]);
  SET_INT_RETURN(v->i & num);
}
 
 
//================================================================
static void c_integer_or(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[1]);
  SET_INT_RETURN(v->i | num);
}
 
 
//================================================================
static void c_integer_xor(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[1]);
  SET_INT_RETURN( v->i ^ num );
}
 
 
//================================================================
static void c_integer_not(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[0]);
  SET_INT_RETURN( ~num );
}
 
 
//----------------------------------------------------------------
static mrbc_int_t shift(mrbc_int_t x, mrbc_int_t y)
{
  // Don't support environments that include padding in int.
  const int INT_BITS = sizeof(mrbc_int_t) * CHAR_BIT;
 
  if( y >= INT_BITS ) return 0;
  if( y >= 0 ) return x << y;
  if( y <= -INT_BITS ) return 0;
  return x >> -y;
}
 
 
//================================================================
static void c_integer_lshift(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[1]);
  SET_INT_RETURN( shift(v->i, num) );
}
 
 
//================================================================
static void c_integer_rshift(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t num = mrbc_integer(v[1]);
  SET_INT_RETURN( shift(v->i, -num) );
}
 
 
//================================================================
static void c_integer_plus(mrbc_vm *vm, mrbc_value v[], int argc)
{
  assert( mrbc_type(v[1]) == MRBC_TT_INTEGER );
 
  SET_INT_RETURN( mrbc_integer(v[0]) + mrbc_integer(v[1]) );
}
 
 
//================================================================
static void c_integer_minus(mrbc_vm *vm, mrbc_value v[], int argc)
{
  assert( mrbc_type(v[1]) == MRBC_TT_INTEGER );
 
  SET_INT_RETURN( mrbc_integer(v[0]) - mrbc_integer(v[1]) );
}
 
 
//================================================================
static void c_integer_gt_eq(mrbc_vm *vm, mrbc_value v[], int argc)
{
  assert( mrbc_type(v[1]) == MRBC_TT_INTEGER );
 
  SET_BOOL_RETURN( mrbc_integer(v[0]) >= mrbc_integer(v[1]) );
}
 
 
//================================================================
static void c_integer_abs(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_integer(v[0]) < 0 ) {
    mrbc_integer(v[0]) = -mrbc_integer(v[0]);
  }
}
 
 
//================================================================
static void c_numeric_clamp(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if (argc != 2) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "wrong number of arguments");
    return;
  }
  mrbc_value min = v[1];
  mrbc_value max = v[2];
  if (
    (mrbc_type(min) != MRBC_TT_INTEGER && mrbc_type(min) != MRBC_TT_FLOAT) ||
    (mrbc_type(max) != MRBC_TT_INTEGER && mrbc_type(max) != MRBC_TT_FLOAT)
  ) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "comparison failed");
    return;
  }
  if (mrbc_compare(&max, &min) < 0) {
    mrbc_raise(vm, MRBC_CLASS(ArgumentError), "min argument must be smaller than max argument");
    return;
  }
  if (mrbc_compare(&v[0], &min) < 0) {
    SET_RETURN(min);
    return;
  }
  if (mrbc_compare(&max, &v[0]) < 0) {
    SET_RETURN(max);
    return;
  }
  SET_RETURN(v[0]); /* return self */
}
 
 
#if MRBC_USE_FLOAT
//================================================================
static void c_integer_to_f(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_float_t f = mrbc_integer(v[0]);
  SET_FLOAT_RETURN( f );
}
#endif
 
 
#if MRBC_USE_STRING
//================================================================
#if MRBC_USE_STRING_UTF8
int mrbc_utf8_encode(int32_t codepoint, char *buf)
{
  if( codepoint < 0 || codepoint > 0x10FFFF ) {
    return 0;  // out of range
  }
  if( codepoint >= 0xD800 && codepoint <= 0xDFFF ) {
    return 0;  // surrogate pair - invalid in UTF-8
  }
 
  if( codepoint <= 0x7F ) {
    buf[0] = (char)codepoint;
    return 1;
  } else if( codepoint <= 0x7FF ) {
    buf[0] = (char)(0xC0 | (codepoint >> 6));
    buf[1] = (char)(0x80 | (codepoint & 0x3F));
    return 2;
  } else if( codepoint <= 0xFFFF ) {
    buf[0] = (char)(0xE0 | (codepoint >> 12));
    buf[1] = (char)(0x80 | ((codepoint >> 6) & 0x3F));
    buf[2] = (char)(0x80 | (codepoint & 0x3F));
    return 3;
  } else {
    buf[0] = (char)(0xF0 | (codepoint >> 18));
    buf[1] = (char)(0x80 | ((codepoint >> 12) & 0x3F));
    buf[2] = (char)(0x80 | ((codepoint >> 6) & 0x3F));
    buf[3] = (char)(0x80 | (codepoint & 0x3F));
    return 4;
  }
}
#endif
 
//================================================================
static void c_integer_chr(mrbc_vm *vm, mrbc_value v[], int argc)
{
#if MRBC_USE_STRING_UTF8
  mrbc_int_t codepoint = mrbc_integer(v[0]);
  char buf[5];
  int len;
 
  if( codepoint < 0 ) {
    mrbc_raise(vm, MRBC_CLASS(RangeError), "out of char range");
    return;
  }
  if( codepoint >= 0xD800 && codepoint <= 0xDFFF ) {
    mrbc_raise(vm, MRBC_CLASS(RangeError), "invalid codepoint in UTF-8");
    return;
  }
  if( codepoint > 0x10FFFF ) {
    mrbc_raise(vm, MRBC_CLASS(RangeError), "out of char range");
    return;
  }
 
  // chr without encoding argument only accepts 0..255
  if( codepoint > 0xFF ) {
    mrbc_raise(vm, MRBC_CLASS(RangeError), "out of char range");
    return;
  }
 
  buf[0] = (char)codepoint;
  len = 1;
  mrbc_value value = mrbc_string_new(vm, buf, len);
  SET_RETURN(value);
#else
  char buf[2] = { mrbc_integer(v[0]) };
 
  mrbc_value value = mrbc_string_new(vm, buf, 1);
  SET_RETURN(value);
#endif
}
 
 
//================================================================
static void c_integer_inspect(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_type(v[0]) == MRBC_TT_CLASS ) {
    mrbc_object_inspect(vm, v, argc);
    return;
  }
 
  int base = 10;
  if( argc ) {
    base = mrbc_integer(v[1]);
    if( base < 2 || base > 36 ) {
      mrbc_raisef(vm, MRBC_CLASS(ArgumentError), "invalid radix %d", base);
      return;
    }
  }
 
  mrbc_printf_t pf;
  char buf[16];
  mrbc_printf_init( &pf, buf, sizeof(buf), NULL );
  pf.fmt.type = 'd';
  mrbc_printf_int( &pf, v->i, base );
  mrbc_printf_end( &pf );
 
  mrbc_value value = mrbc_string_new_cstr(vm, buf);
  SET_RETURN(value);
}
#endif
 
 
/* MRBC_AUTOGEN_METHOD_TABLE
 
  CLASS("Integer")
  FILE("_autogen_class_integer.h")
 
  METHOD( "[]",         c_integer_bitref )
  METHOD( "+@",         c_integer_positive )
  METHOD( "-@",         c_integer_negative )
  METHOD( "**",         c_integer_power )
  METHOD( "%",          c_integer_mod )
  METHOD( "&",          c_integer_and )
  METHOD( "|",          c_integer_or )
  METHOD( "^",          c_integer_xor )
  METHOD( "~",          c_integer_not )
  METHOD( "<<",         c_integer_lshift )
  METHOD( ">>",         c_integer_rshift )
  METHOD( "+",          c_integer_plus )
  METHOD( "-",          c_integer_minus )
  METHOD( ">=",         c_integer_gt_eq )
  METHOD( "abs",        c_integer_abs )
  METHOD( "to_i",       c_ineffect )
  METHOD( "clamp",      c_numeric_clamp )
#if MRBC_USE_FLOAT
  METHOD( "to_f",       c_integer_to_f )
#endif
#if MRBC_USE_STRING
  METHOD( "chr",        c_integer_chr )
  METHOD( "inspect",    c_integer_inspect )
  METHOD( "to_s",       c_integer_inspect )
#endif
*/
#include "_autogen_class_integer.h"
 
 
 
/***** Float class **********************************************************/
#if MRBC_USE_FLOAT
 
//================================================================
static void c_float_positive(mrbc_vm *vm, mrbc_value v[], int argc)
{
  // do nothing
}
 
 
//================================================================
static void c_float_negative(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_float_t num = mrbc_float(v[0]);
  SET_FLOAT_RETURN( -num );
}
 
 
#if MRBC_USE_MATH
//================================================================
static void c_float_power(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_float_t n = 0;
  switch( mrbc_type(v[1]) ) {
  case MRBC_TT_INTEGER: n = mrbc_integer(v[1]); break;
  case MRBC_TT_FLOAT:   n = mrbc_float(v[1]);   break;
  default:                                      break;
  }
 
  SET_FLOAT_RETURN( MRBC_POW( mrbc_float(v[0]), n ));
}
#endif
 
 
//================================================================
static void c_float_abs(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_float(v[0]) < 0 ) {
    mrbc_float(v[0]) = -mrbc_float(v[0]);
  }
}
 
 
//================================================================
static void c_float_to_i(mrbc_vm *vm, mrbc_value v[], int argc)
{
  mrbc_int_t i = (mrbc_int_t)mrbc_float(v[0]);
  SET_INT_RETURN( i );
}
 
 
#if MRBC_USE_STRING
//================================================================
static void c_float_inspect(mrbc_vm *vm, mrbc_value v[], int argc)
{
  if( mrbc_type(v[0]) == MRBC_TT_CLASS ) {
    mrbc_object_inspect(vm, v, argc);
    return;
  }
 
  char buf[32];
  mrbc_format_float(buf, sizeof(buf), v->d);
  mrbc_value value = mrbc_string_new_cstr(vm, buf);
  SET_RETURN(value);
}
#endif
 
 
/* MRBC_AUTOGEN_METHOD_TABLE
 
  CLASS("Float")
  FILE("_autogen_class_float.h")
 
  METHOD( "+@",         c_float_positive )
  METHOD( "-@",         c_float_negative )
#if MRBC_USE_MATH
  METHOD( "**",         c_float_power )
#endif
  METHOD( "abs",        c_float_abs )
  METHOD( "to_i",       c_float_to_i )
  METHOD( "to_f",       c_ineffect )
  METHOD( "clamp",      c_numeric_clamp )
#if MRBC_USE_STRING
  METHOD( "inspect",    c_float_inspect )
  METHOD( "to_s",       c_float_inspect )
#endif
*/
#include "_autogen_class_float.h"
 
#endif  // MRBC_USE_FLOAT