Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

Location:
EcnlProtoTool/trunk/mruby-1.3.0
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/mruby-1.3.0/src/numeric.c

    r321 r331  
    1010#include <stdlib.h>
    1111
    12 #include "mruby.h"
    13 #include "mruby/array.h"
    14 #include "mruby/numeric.h"
    15 #include "mruby/string.h"
     12#include <mruby.h>
     13#include <mruby/array.h>
     14#include <mruby/numeric.h>
     15#include <mruby/string.h>
     16#include <mruby/class.h>
    1617
    1718#ifdef MRB_USE_FLOAT
     19#define trunc(f) truncf(f)
    1820#define floor(f) floorf(f)
    1921#define ceil(f) ceilf(f)
    … …  
    5153{
    5254  mrb_value y;
    53   mrb_float d, yv;
    54 
    55   mrb_get_args(mrb, "o", &y);
    56   yv = mrb_to_flo(mrb, y);
    57   d = pow(mrb_to_flo(mrb, x), yv);
    58   if (mrb_fixnum_p(x) && mrb_fixnum_p(y) && FIXABLE(d) && yv > 0 &&
    59       (d < 0 || (d > 0 && (mrb_int)d > 0)))
    60     return mrb_fixnum_value((mrb_int)d);
     55  mrb_float d;
     56
     57  mrb_get_args(mrb, "o", &y);
     58  if (mrb_fixnum_p(x) && mrb_fixnum_p(y)) {
     59    /* try ipow() */
     60    mrb_int base = mrb_fixnum(x);
     61    mrb_int exp = mrb_fixnum(y);
     62    mrb_int result = 1;
     63
     64    if (exp < 0) goto float_pow;
     65    for (;;) {
     66      if (exp & 1) {
     67        if (mrb_int_mul_overflow(result, base, &result)) {
     68          goto float_pow;
     69        }
     70      }
     71      exp >>= 1;
     72      if (exp == 0) break;
     73      if (mrb_int_mul_overflow(base, base, &base)) {
     74        goto float_pow;
     75      }
     76    }
     77    return mrb_fixnum_value(result);
     78  }
     79 float_pow:
     80  d = pow(mrb_to_flo(mrb, x), mrb_to_flo(mrb, y));
    6181  return mrb_float_value(mrb, d);
    6282}
    … …  
    272292}
    273293
     294static int64_t
     295value_int64(mrb_state *mrb, mrb_value x)
     296{
     297  switch (mrb_type(x)) {
     298  case MRB_TT_FIXNUM:
     299    return (int64_t)mrb_fixnum(x);
     300    break;
     301  case MRB_TT_FLOAT:
     302    return (int64_t)mrb_float(x);
     303  default:
     304    mrb_raise(mrb, E_TYPE_ERROR, "cannot convert to Integer");
     305    break;
     306  }
     307  /* not reached */
     308  return 0;
     309}
     310
     311static mrb_value
     312int64_value(mrb_state *mrb, int64_t v)
     313{
     314  if (FIXABLE(v)) {
     315    return mrb_fixnum_value((mrb_int)v);
     316  }
     317  return mrb_float_value(mrb, (mrb_float)v);
     318}
     319
     320static mrb_value
     321flo_rev(mrb_state *mrb, mrb_value x)
     322{
     323  int64_t v1;
     324  mrb_get_args(mrb, "");
     325  v1 = (int64_t)mrb_float(x);
     326  return int64_value(mrb, ~v1);
     327}
     328
     329static mrb_value
     330flo_and(mrb_state *mrb, mrb_value x)
     331{
     332  mrb_value y;
     333  int64_t v1, v2;
     334  mrb_get_args(mrb, "o", &y);
     335
     336  v1 = (int64_t)mrb_float(x);
     337  v2 = value_int64(mrb, y);
     338  return int64_value(mrb, v1 & v2);
     339}
     340
     341static mrb_value
     342flo_or(mrb_state *mrb, mrb_value x)
     343{
     344  mrb_value y;
     345  int64_t v1, v2;
     346  mrb_get_args(mrb, "o", &y);
     347
     348  v1 = (int64_t)mrb_float(x);
     349  v2 = value_int64(mrb, y);
     350  return int64_value(mrb, v1 | v2);
     351}
     352
     353static mrb_value
     354flo_xor(mrb_state *mrb, mrb_value x)
     355{
     356  mrb_value y;
     357  int64_t v1, v2;
     358  mrb_get_args(mrb, "o", &y);
     359
     360  v1 = (int64_t)mrb_float(x);
     361  v2 = value_int64(mrb, y);
     362  return int64_value(mrb, v1 ^ v2);
     363}
     364
     365static mrb_value
     366flo_shift(mrb_state *mrb, mrb_value x, mrb_int width)
     367{
     368  mrb_float val;
     369
     370  if (width == 0) {
     371    return x;
     372  }
     373  val = mrb_float(x);
     374  if (width < 0) {
     375    while (width++) {
     376      val /= 2;
     377    }
     378#if defined(_ISOC99_SOURCE)
     379    val = trunc(val);
     380#else
     381    val = val > 0 ? floor(val) : ceil(val);
     382#endif
     383    if (val == 0 && mrb_float(x) < 0) {
     384      return mrb_fixnum_value(-1);
     385    }
     386  }
     387  else {
     388    while (width--) {
     389      val *= 2;
     390    }
     391  }
     392  if (FIXABLE_FLOAT(val)) {
     393    return mrb_fixnum_value((mrb_int)val);
     394  }
     395  return mrb_float_value(mrb, val);
     396}
     397
     398static mrb_value
     399flo_lshift(mrb_state *mrb, mrb_value x)
     400{
     401  mrb_int width;
     402
     403  mrb_get_args(mrb, "i", &width);
     404  return flo_shift(mrb, x, -width);
     405}
     406
     407static mrb_value
     408flo_rshift(mrb_state *mrb, mrb_value x)
     409{
     410  mrb_int width;
     411
     412  mrb_get_args(mrb, "i", &width);
     413  return flo_shift(mrb, x, width);
     414}
     415
    274416/* 15.2.8.3.18 */
    275417/*
    … …  
    285427  char *c;
    286428  size_t i;
    287   int hash;
     429  mrb_int hash;
    288430
    289431  d = (mrb_float)mrb_fixnum(num);
    … …  
    291433  if (d == 0) d = 0.0;
    292434  c = (char*)&d;
    293   for (hash=0, i=0; i<sizeof(mrb_float);i++) {
     435  for (hash=0,i=0; i<sizeof(mrb_float); i++) {
    294436    hash = (hash * 971) ^ (unsigned char)c[i];
    295437  }
    … …  
    351493{
    352494  return mrb_bool_value(isfinite(mrb_float(num)));
     495}
     496
     497void
     498mrb_check_num_exact(mrb_state *mrb, mrb_float num)
     499{
     500  if (isinf(num)) {
     501    mrb_raise(mrb, E_FLOATDOMAIN_ERROR, num < 0 ? "-Infinity" : "Infinity");
     502  }
     503  if (isnan(num)) {
     504    mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
     505  }
    353506}
    354507
    … …  
    371524  mrb_float f = floor(mrb_float(num));
    372525
    373   if (!FIXABLE(f)) {
     526  mrb_check_num_exact(mrb, f);
     527  if (!FIXABLE_FLOAT(f)) {
    374528    return mrb_float_value(mrb, f);
    375529  }
    … …  
    396550  mrb_float f = ceil(mrb_float(num));
    397551
    398   if (!FIXABLE(f)) {
     552  mrb_check_num_exact(mrb, f);
     553  if (!FIXABLE_FLOAT(f)) {
    399554    return mrb_float_value(mrb, f);
    400555  }
    … …  
    443598  number = mrb_float(num);
    444599
    445   if (isinf(number)) {
    446     if (0 < ndigits) return num;
    447     else mrb_raise(mrb, E_FLOATDOMAIN_ERROR, number < 0 ? "-Infinity" : "Infinity");
    448   }
    449   if (isnan(number)) {
    450     if (0 < ndigits) return num;
    451     else mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
    452   }
     600  if (0 < ndigits && (isinf(number) || isnan(number))) {
     601    return num;
     602  }
     603  mrb_check_num_exact(mrb, number);
    453604
    454605  f = 1.0;
    … …  
    506657  if (f < 0.0) f = ceil(f);
    507658
    508   if (!FIXABLE(f)) {
     659  mrb_check_num_exact(mrb, f);
     660  if (!FIXABLE_FLOAT(f)) {
    509661    return mrb_float_value(mrb, f);
    510662  }
    … …  
    542694}
    543695
    544 /*tests if N*N would overflow*/
    545 #define SQRT_INT_MAX ((mrb_int)1<<((MRB_INT_BIT-1-MRB_FIXNUM_SHIFT)/2))
    546 #define FIT_SQRT_INT(n) (((n)<SQRT_INT_MAX)&&((n)>=-SQRT_INT_MAX))
    547 
    548696mrb_value
    549697mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y)
    … …  
    553701  a = mrb_fixnum(x);
    554702  if (mrb_fixnum_p(y)) {
    555     mrb_float c;
    556     mrb_int b;
     703    mrb_int b, c;
    557704
    558705    if (a == 0) return x;
    559706    b = mrb_fixnum(y);
    560     if (FIT_SQRT_INT(a) && FIT_SQRT_INT(b))
    561       return mrb_fixnum_value(a*b);
    562     c = a * b;
    563     if ((a != 0 && c/a != b) || !FIXABLE(c)) {
    564       return mrb_float_value(mrb, (mrb_float)a*(mrb_float)b);
    565     }
    566     return mrb_fixnum_value((mrb_int)c);
     707    if (mrb_int_mul_overflow(a, b, &c)) {
     708      return mrb_float_value(mrb, (mrb_float)a * (mrb_float)b);
     709    }
     710    return mrb_fixnum_value(c);
    567711  }
    568712  return mrb_float_value(mrb, (mrb_float)a * mrb_to_flo(mrb, y));
    … …  
    747891}
    748892
    749 static mrb_value
    750 bit_coerce(mrb_state *mrb, mrb_value x)
    751 {
    752   while (!mrb_fixnum_p(x)) {
    753     if (mrb_float_p(x)) {
    754       mrb_raise(mrb, E_TYPE_ERROR, "can't convert Float into Integer");
    755     }
    756     x = mrb_to_int(mrb, x);
    757   }
    758   return x;
    759 }
     893static mrb_value flo_and(mrb_state *mrb, mrb_value x);
     894static mrb_value flo_or(mrb_state *mrb, mrb_value x);
     895static mrb_value flo_xor(mrb_state *mrb, mrb_value x);
     896#define bit_op(x,y,op1,op2) do {\
     897  if (mrb_fixnum_p(y)) return mrb_fixnum_value(mrb_fixnum(x) op2 mrb_fixnum(y));\
     898  return flo_ ## op1(mrb, mrb_float_value(mrb, mrb_fixnum(x)));\
     899} while(0)
    760900
    761901/* 15.2.8.3.9  */
    … …  
    773913
    774914  mrb_get_args(mrb, "o", &y);
    775 
    776   y = bit_coerce(mrb, y);
    777   return mrb_fixnum_value(mrb_fixnum(x) & mrb_fixnum(y));
     915  bit_op(x, y, and, &);
    778916}
    779917
    … …  
    792930
    793931  mrb_get_args(mrb, "o", &y);
    794 
    795   y = bit_coerce(mrb, y);
    796   return mrb_fixnum_value(mrb_fixnum(x) | mrb_fixnum(y));
     932  bit_op(x, y, or, |);
    797933}
    798934
    … …  
    811947
    812948  mrb_get_args(mrb, "o", &y);
    813 
    814   y = bit_coerce(mrb, y);
    815   return mrb_fixnum_value(mrb_fixnum(x) ^ mrb_fixnum(y));
     949  bit_op(x, y, or, ^);
    816950}
    817951
    … …  
    821955lshift(mrb_state *mrb, mrb_int val, mrb_int width)
    822956{
    823   mrb_assert(width > 0);
    824   if (width > NUMERIC_SHIFT_WIDTH_MAX) {
     957  if (width < 0) {              /* mrb_int overflow */
     958    return mrb_float_value(mrb, INFINITY);
     959  }
     960  if (val > 0) {
     961    if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
     962        (val   > (MRB_INT_MAX >> width))) {
     963      goto bit_overflow;
     964    }
     965  }
     966  else {
     967    if ((width > NUMERIC_SHIFT_WIDTH_MAX) ||
     968        (val   < (MRB_INT_MIN >> width))) {
     969      goto bit_overflow;
     970    }
     971  }
     972
     973  return mrb_fixnum_value(val << width);
     974
     975bit_overflow:
     976  {
    825977    mrb_float f = (mrb_float)val;
    826978    while (width--) {
    … …  
    829981    return mrb_float_value(mrb, f);
    830982  }
    831   return mrb_fixnum_value(val << width);
    832983}
    833984
    … …  
    835986rshift(mrb_int val, mrb_int width)
    836987{
    837   mrb_assert(width > 0);
     988  if (width < 0) {              /* mrb_int overflow */
     989    return mrb_fixnum_value(0);
     990  }
    838991  if (width >= NUMERIC_SHIFT_WIDTH_MAX) {
    839992    if (val < 0) {
    … …  
    845998}
    846999
    847 static inline void
    848 fix_shift_get_width(mrb_state *mrb, mrb_int *width)
    849 {
    850   mrb_value y;
    851 
    852   mrb_get_args(mrb, "o", &y);
    853   *width = mrb_fixnum(bit_coerce(mrb, y));
    854 }
    855 
    8561000/* 15.2.8.3.12 */
    8571001/*
    … …  
    8671011  mrb_int width, val;
    8681012
    869   fix_shift_get_width(mrb, &width);
    870 
     1013  mrb_get_args(mrb, "i", &width);
    8711014  if (width == 0) {
    8721015    return x;
    8731016  }
    8741017  val = mrb_fixnum(x);
     1018  if (val == 0) return x;
    8751019  if (width < 0) {
    8761020    return rshift(val, -width);
    … …  
    8921036  mrb_int width, val;
    8931037
    894   fix_shift_get_width(mrb, &width);
    895 
     1038  mrb_get_args(mrb, "i", &width);
    8961039  if (width == 0) {
    8971040    return x;
    8981041  }
    8991042  val = mrb_fixnum(x);
     1043  if (val == 0) return x;
    9001044  if (width < 0) {
    9011045    return lshift(mrb, val, -width);
    … …  
    9361080mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
    9371081{
    938   mrb_int z;
     1082  mrb_int z = 0;
    9391083
    9401084  if (!mrb_float_p(x)) {
    … …  
    9511095      mrb_raise(mrb, E_FLOATDOMAIN_ERROR, "NaN");
    9521096    }
    953     z = (mrb_int)d;
     1097    if (FIXABLE_FLOAT(d)) {
     1098      z = (mrb_int)d;
     1099    }
     1100    else {
     1101      mrb_raisef(mrb, E_ARGUMENT_ERROR, "number (%S) too big for integer", x);
     1102    }
    9541103  }
    9551104  return mrb_fixnum_value(z);
    … …  
    11501299  numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);                /* 15.2.7 */
    11511300
    1152   mrb_define_method(mrb, numeric, "**",       num_pow,        MRB_ARGS_REQ(1));
    1153   mrb_define_method(mrb, numeric, "/",        num_div,        MRB_ARGS_REQ(1)); /* 15.2.8.3.4  */
    1154   mrb_define_method(mrb, numeric, "quo",      num_div,        MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
    1155   mrb_define_method(mrb, numeric, "<=>",      num_cmp,        MRB_ARGS_REQ(1)); /* 15.2.9.3.6  */
     1301  mrb_define_method(mrb, numeric, "**",       num_pow,         MRB_ARGS_REQ(1));
     1302  mrb_define_method(mrb, numeric, "/",        num_div,         MRB_ARGS_REQ(1)); /* 15.2.8.3.4  */
     1303  mrb_define_method(mrb, numeric, "quo",      num_div,         MRB_ARGS_REQ(1)); /* 15.2.7.4.5 (x) */
     1304  mrb_define_method(mrb, numeric, "<=>",      num_cmp,         MRB_ARGS_REQ(1)); /* 15.2.9.3.6  */
    11561305
    11571306  /* Integer Class */
    11581307  integer = mrb_define_class(mrb, "Integer",  numeric);                          /* 15.2.8 */
     1308  MRB_SET_INSTANCE_TT(integer, MRB_TT_FIXNUM);
    11591309  mrb_undef_class_method(mrb, integer, "new");
    1160   mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE());            /* 15.2.8.3.24 */
    1161   mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE());
     1310  mrb_define_method(mrb, integer, "to_i",     int_to_i,        MRB_ARGS_NONE()); /* 15.2.8.3.24 */
     1311  mrb_define_method(mrb, integer, "to_int",   int_to_i,        MRB_ARGS_NONE());
     1312  mrb_define_method(mrb, integer, "ceil",     int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.8 (x) */
     1313  mrb_define_method(mrb, integer, "floor",    int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.10 (x) */
     1314  mrb_define_method(mrb, integer, "round",    int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.12 (x) */
     1315  mrb_define_method(mrb, integer, "truncate", int_to_i,        MRB_ARGS_REQ(1)); /* 15.2.8.3.15 (x) */
    11621316
    11631317  /* Fixnum Class */
    11641318  mrb->fixnum_class = fixnum = mrb_define_class(mrb, "Fixnum", integer);
    1165   mrb_define_method(mrb, fixnum,  "+",        fix_plus,          MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
    1166   mrb_define_method(mrb, fixnum,  "-",        fix_minus,         MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
    1167   mrb_define_method(mrb, fixnum,  "*",        fix_mul,           MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
    1168   mrb_define_method(mrb, fixnum,  "%",        fix_mod,           MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
    1169   mrb_define_method(mrb, fixnum,  "==",       fix_equal,         MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
    1170   mrb_define_method(mrb, fixnum,  "~",        fix_rev,           MRB_ARGS_NONE()); /* 15.2.8.3.8  */
    1171   mrb_define_method(mrb, fixnum,  "&",        fix_and,           MRB_ARGS_REQ(1)); /* 15.2.8.3.9  */
    1172   mrb_define_method(mrb, fixnum,  "|",        fix_or,            MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
    1173   mrb_define_method(mrb, fixnum,  "^",        fix_xor,           MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
    1174   mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
    1175   mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
    1176   mrb_define_method(mrb, fixnum,  "eql?",     fix_eql,           MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
    1177   mrb_define_method(mrb, fixnum,  "hash",     flo_hash,          MRB_ARGS_NONE()); /* 15.2.8.3.18 */
    1178   mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,          MRB_ARGS_NONE()); /* 15.2.8.3.23 */
    1179   mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,          MRB_ARGS_NONE()); /* 15.2.8.3.25 */
    1180   mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,          MRB_ARGS_NONE());
    1181   mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,        MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
     1319  mrb_define_method(mrb, fixnum,  "+",        fix_plus,        MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
     1320  mrb_define_method(mrb, fixnum,  "-",        fix_minus,       MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
     1321  mrb_define_method(mrb, fixnum,  "*",        fix_mul,         MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
     1322  mrb_define_method(mrb, fixnum,  "%",        fix_mod,         MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
     1323  mrb_define_method(mrb, fixnum,  "==",       fix_equal,       MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
     1324  mrb_define_method(mrb, fixnum,  "~",        fix_rev,         MRB_ARGS_NONE()); /* 15.2.8.3.8  */
     1325  mrb_define_method(mrb, fixnum,  "&",        fix_and,         MRB_ARGS_REQ(1)); /* 15.2.8.3.9  */
     1326  mrb_define_method(mrb, fixnum,  "|",        fix_or,          MRB_ARGS_REQ(1)); /* 15.2.8.3.10 */
     1327  mrb_define_method(mrb, fixnum,  "^",        fix_xor,         MRB_ARGS_REQ(1)); /* 15.2.8.3.11 */
     1328  mrb_define_method(mrb, fixnum,  "<<",       fix_lshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.12 */
     1329  mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,      MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
     1330  mrb_define_method(mrb, fixnum,  "eql?",     fix_eql,         MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
     1331  mrb_define_method(mrb, fixnum,  "hash",     flo_hash,        MRB_ARGS_NONE()); /* 15.2.8.3.18 */
     1332  mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,        MRB_ARGS_NONE()); /* 15.2.8.3.23 */
     1333  mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,        MRB_ARGS_NONE()); /* 15.2.8.3.25 */
     1334  mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,        MRB_ARGS_NONE());
     1335  mrb_define_method(mrb, fixnum,  "divmod",   fix_divmod,      MRB_ARGS_REQ(1)); /* 15.2.8.3.30 (x) */
    11821336
    11831337  /* Float Class */
    11841338  mrb->float_class = fl = mrb_define_class(mrb, "Float", numeric);                 /* 15.2.9 */
     1339  MRB_SET_INSTANCE_TT(fl, MRB_TT_FLOAT);
    11851340  mrb_undef_class_method(mrb,  fl, "new");
    1186   mrb_define_method(mrb, fl,      "+",         flo_plus,         MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
    1187   mrb_define_method(mrb, fl,      "-",         flo_minus,        MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
    1188   mrb_define_method(mrb, fl,      "*",         flo_mul,          MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
    1189   mrb_define_method(mrb, fl,      "%",         flo_mod,          MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
    1190   mrb_define_method(mrb, fl,      "==",        flo_eq,           MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
    1191   mrb_define_method(mrb, fl,      "ceil",      flo_ceil,         MRB_ARGS_NONE()); /* 15.2.9.3.8  */
    1192   mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,     MRB_ARGS_NONE()); /* 15.2.9.3.9  */
    1193   mrb_define_method(mrb, fl,      "floor",     flo_floor,        MRB_ARGS_NONE()); /* 15.2.9.3.10 */
    1194   mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.11 */
    1195   mrb_define_method(mrb, fl,      "round",     flo_round,        MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */
    1196   mrb_define_method(mrb, fl,      "to_f",      flo_to_f,         MRB_ARGS_NONE()); /* 15.2.9.3.13 */
    1197   mrb_define_method(mrb, fl,      "to_i",      flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.14 */
    1198   mrb_define_method(mrb, fl,      "to_int",    flo_truncate,     MRB_ARGS_NONE());
    1199   mrb_define_method(mrb, fl,      "truncate",  flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.15 */
    1200   mrb_define_method(mrb, fl,      "divmod",    flo_divmod,       MRB_ARGS_REQ(1));
    1201   mrb_define_method(mrb, fl,      "eql?",      flo_eql,          MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
    1202 
    1203   mrb_define_method(mrb, fl,      "to_s",      flo_to_s,         MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
    1204   mrb_define_method(mrb, fl,      "inspect",   flo_to_s,         MRB_ARGS_NONE());
    1205   mrb_define_method(mrb, fl,      "nan?",      flo_nan_p,        MRB_ARGS_NONE());
     1341  mrb_define_method(mrb, fl,      "+",         flo_plus,       MRB_ARGS_REQ(1)); /* 15.2.9.3.1  */
     1342  mrb_define_method(mrb, fl,      "-",         flo_minus,      MRB_ARGS_REQ(1)); /* 15.2.9.3.2  */
     1343  mrb_define_method(mrb, fl,      "*",         flo_mul,        MRB_ARGS_REQ(1)); /* 15.2.9.3.3  */
     1344  mrb_define_method(mrb, fl,      "%",         flo_mod,        MRB_ARGS_REQ(1)); /* 15.2.9.3.5  */
     1345  mrb_define_method(mrb, fl,      "==",        flo_eq,         MRB_ARGS_REQ(1)); /* 15.2.9.3.7  */
     1346  mrb_define_method(mrb, fl,      "~",         flo_rev,        MRB_ARGS_NONE());
     1347  mrb_define_method(mrb, fl,      "&",         flo_and,        MRB_ARGS_REQ(1));
     1348  mrb_define_method(mrb, fl,      "|",         flo_or,         MRB_ARGS_REQ(1));
     1349  mrb_define_method(mrb, fl,      "^",         flo_xor,        MRB_ARGS_REQ(1));
     1350  mrb_define_method(mrb, fl,      ">>",        flo_lshift,     MRB_ARGS_REQ(1));
     1351  mrb_define_method(mrb, fl,      "<<",        flo_rshift,     MRB_ARGS_REQ(1));
     1352  mrb_define_method(mrb, fl,      "ceil",      flo_ceil,       MRB_ARGS_NONE()); /* 15.2.9.3.8  */
     1353  mrb_define_method(mrb, fl,      "finite?",   flo_finite_p,   MRB_ARGS_NONE()); /* 15.2.9.3.9  */
     1354  mrb_define_method(mrb, fl,      "floor",     flo_floor,      MRB_ARGS_NONE()); /* 15.2.9.3.10 */
     1355  mrb_define_method(mrb, fl,      "infinite?", flo_infinite_p, MRB_ARGS_NONE()); /* 15.2.9.3.11 */
     1356  mrb_define_method(mrb, fl,      "round",     flo_round,      MRB_ARGS_OPT(1)); /* 15.2.9.3.12 */
     1357  mrb_define_method(mrb, fl,      "to_f",      flo_to_f,       MRB_ARGS_NONE()); /* 15.2.9.3.13 */
     1358  mrb_define_method(mrb, fl,      "to_i",      flo_truncate,   MRB_ARGS_NONE()); /* 15.2.9.3.14 */
     1359  mrb_define_method(mrb, fl,      "to_int",    flo_truncate,   MRB_ARGS_NONE());
     1360  mrb_define_method(mrb, fl,      "truncate",  flo_truncate,   MRB_ARGS_NONE()); /* 15.2.9.3.15 */
     1361  mrb_define_method(mrb, fl,      "divmod",    flo_divmod,     MRB_ARGS_REQ(1));
     1362  mrb_define_method(mrb, fl,      "eql?",      flo_eql,        MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
     1363
     1364  mrb_define_method(mrb, fl,      "to_s",      flo_to_s,       MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
     1365  mrb_define_method(mrb, fl,      "inspect",   flo_to_s,       MRB_ARGS_NONE());
     1366  mrb_define_method(mrb, fl,      "nan?",      flo_nan_p,      MRB_ARGS_NONE());
    12061367
    12071368#ifdef INFINITY
Note: See TracChangeset for help on using the changeset viewer.