Revision: 2836 http://trac.macosforge.org/projects/ruby/changeset/2836 Author: lsansonetti@apple.com Date: 2009-10-17 01:10:09 -0700 (Sat, 17 Oct 2009) Log Message: ----------- added BigDecimal extension (still experimental, some specs are failing) Modified Paths: -------------- MacRuby/trunk/ext/bigdecimal/bigdecimal.c MacRuby/trunk/ext/bigdecimal/bigdecimal.h MacRuby/trunk/rakelib/builder.rake Modified: MacRuby/trunk/ext/bigdecimal/bigdecimal.c =================================================================== --- MacRuby/trunk/ext/bigdecimal/bigdecimal.c 2009-10-16 21:36:31 UTC (rev 2835) +++ MacRuby/trunk/ext/bigdecimal/bigdecimal.c 2009-10-17 08:10:09 UTC (rev 2836) @@ -159,7 +159,7 @@ * Ruby 1.8.1 thru 1.8.3 return 1.0.1. */ static VALUE -BigDecimal_version(VALUE self) +BigDecimal_version(VALUE self, SEL sel) { /* * 1.0.0: Ruby 1.8.0 @@ -254,7 +254,7 @@ * in use. */ static VALUE -BigDecimal_double_fig(VALUE self) +BigDecimal_double_fig(VALUE self, SEL sel) { return INT2FIX(VpDblFig()); } @@ -269,7 +269,7 @@ * for the BigDecimal. */ static VALUE -BigDecimal_prec(VALUE self) +BigDecimal_prec(VALUE self, SEL sel) { ENTER(1); Real *p; @@ -282,7 +282,7 @@ } static VALUE -BigDecimal_hash(VALUE self) +BigDecimal_hash(VALUE self, SEL sel) { ENTER(1); Real *p; @@ -302,7 +302,7 @@ } static VALUE -BigDecimal_dump(int argc, VALUE *argv, VALUE self) +BigDecimal_dump(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); char sz[50]; @@ -322,7 +322,7 @@ * Internal method used to provide marshalling support. See the Marshal module. */ static VALUE -BigDecimal_load(VALUE self, VALUE str) +BigDecimal_load(VALUE self, SEL sel, VALUE str) { ENTER(2); Real *pv; @@ -385,7 +385,7 @@ * */ static VALUE -BigDecimal_mode(int argc, VALUE *argv, VALUE self) +BigDecimal_mode(VALUE self, SEL sel, int argc, VALUE *argv) { VALUE which; VALUE val; @@ -465,7 +465,7 @@ } VP_EXPORT Real * -VpNewRbClass(U_LONG mx, char *str, VALUE klass) +VpNewRbClass(U_LONG mx, const char *str, VALUE klass) { Real *pv = VpAlloc(mx,str); pv->obj = (VALUE)Data_Wrap_Struct(klass, 0, BigDecimal_delete, pv); @@ -482,7 +482,7 @@ /* Returns True if the value is Not a Number */ static VALUE -BigDecimal_IsNaN(VALUE self) +BigDecimal_IsNaN(VALUE self, SEL sel) { Real *p = GetVpValue(self,1); if(VpIsNaN(p)) return Qtrue; @@ -491,7 +491,7 @@ /* Returns True if the value is infinite */ static VALUE -BigDecimal_IsInfinite(VALUE self) +BigDecimal_IsInfinite(VALUE self, SEL sel) { Real *p = GetVpValue(self,1); if(VpIsPosInf(p)) return INT2FIX(1); @@ -501,7 +501,7 @@ /* Returns True if the value is finite (not NaN or infinite) */ static VALUE -BigDecimal_IsFinite(VALUE self) +BigDecimal_IsFinite(VALUE self, SEL sel) { Real *p = GetVpValue(self,1); if(VpIsNaN(p)) return Qfalse; @@ -514,7 +514,7 @@ * If the BigNumber is infinity or NaN, returns nil. */ static VALUE -BigDecimal_to_i(VALUE self) +BigDecimal_to_i(VALUE self, SEL sel) { ENTER(5); int e,n,i,nf; @@ -570,7 +570,7 @@ } static VALUE -BigDecimal_induced_from(VALUE self, VALUE x) +BigDecimal_induced_from(VALUE self, SEL sel, VALUE x) { Real *p = GetVpValue(x,1); return p->obj; @@ -581,7 +581,7 @@ * Float arithmetic apply. */ static VALUE -BigDecimal_to_f(VALUE self) +BigDecimal_to_f(VALUE self, SEL sel) { ENTER(1); Real *p; @@ -618,13 +618,13 @@ * it requires a special compile-time option when building Ruby. */ static VALUE -BigDecimal_coerce(VALUE self, VALUE other) +BigDecimal_coerce(VALUE self, SEL sel, VALUE other) { ENTER(2); VALUE obj; Real *b; if(TYPE(other) == T_FLOAT) { - obj = rb_assoc_new(other, BigDecimal_to_f(self)); + obj = rb_assoc_new(other, BigDecimal_to_f(self, 0)); } else { GUARD_OBJ(b,GetVpValue(other,1)); obj = rb_assoc_new(b->obj, self); @@ -633,7 +633,7 @@ } static VALUE -BigDecimal_uplus(VALUE self) +BigDecimal_uplus(VALUE self, SEL sel) { return self; } @@ -650,7 +650,7 @@ * digits:: If specified and less than the number of significant digits of the result, the result is rounded to that number of digits, according to BigDecimal.mode. */ static VALUE -BigDecimal_add(VALUE self, VALUE r) +BigDecimal_add(VALUE self, SEL sel, VALUE r) { ENTER(5); Real *c, *a, *b; @@ -688,7 +688,7 @@ * digits:: If specified and less than the number of significant digits of the result, the result is rounded to that number of digits, according to BigDecimal.mode. */ static VALUE -BigDecimal_sub(VALUE self, VALUE r) +BigDecimal_sub(VALUE self, SEL sel, VALUE r) { ENTER(5); Real *c, *a, *b; @@ -721,12 +721,12 @@ BigDecimalCmp(VALUE self, VALUE r,char op) { ENTER(5); - S_INT e; + S_INT e = 0; Real *a, *b; GUARD_OBJ(a,GetVpValue(self,1)); b = GetVpValue(r,0); if(!b) { - ID f; + ID f = 0; switch(op) { @@ -757,7 +757,7 @@ /* Returns True if the value is zero. */ static VALUE -BigDecimal_zero(VALUE self) +BigDecimal_zero(VALUE self, SEL sel) { Real *a = GetVpValue(self,1); return VpIsZero(a) ? Qtrue : Qfalse; @@ -765,7 +765,7 @@ /* Returns True if the value is non-zero. */ static VALUE -BigDecimal_nonzero(VALUE self) +BigDecimal_nonzero(VALUE self, SEL sel) { Real *a = GetVpValue(self,1); return VpIsZero(a) ? Qnil : self; @@ -775,7 +775,7 @@ * a <=> b is 0 if a == b, 1 if a > b, -1 if a < b. */ static VALUE -BigDecimal_comp(VALUE self, VALUE r) +BigDecimal_comp(VALUE self, SEL sel, VALUE r) { return BigDecimalCmp(self, r, '*'); } @@ -791,7 +791,7 @@ * BigDecimal.new('1.0') == 1.0 -> true */ static VALUE -BigDecimal_eq(VALUE self, VALUE r) +BigDecimal_eq(VALUE self, SEL sel, VALUE r) { return BigDecimalCmp(self, r, '='); } @@ -803,7 +803,7 @@ * comparison (see ==, coerce). */ static VALUE -BigDecimal_lt(VALUE self, VALUE r) +BigDecimal_lt(VALUE self, SEL sel, VALUE r) { return BigDecimalCmp(self, r, '<'); } @@ -815,7 +815,7 @@ * perform the comparison (see ==, coerce). */ static VALUE -BigDecimal_le(VALUE self, VALUE r) +BigDecimal_le(VALUE self, SEL sel, VALUE r) { return BigDecimalCmp(self, r, 'L'); } @@ -827,7 +827,7 @@ * perform the comparison (see ==, coerce). */ static VALUE -BigDecimal_gt(VALUE self, VALUE r) +BigDecimal_gt(VALUE self, SEL sel, VALUE r) { return BigDecimalCmp(self, r, '>'); } @@ -839,13 +839,13 @@ * perform the comparison (see ==, coerce) */ static VALUE -BigDecimal_ge(VALUE self, VALUE r) +BigDecimal_ge(VALUE self, SEL sel, VALUE r) { return BigDecimalCmp(self, r, 'G'); } static VALUE -BigDecimal_neg(VALUE self) +BigDecimal_neg(VALUE self, SEL sel) { ENTER(5); Real *c, *a; @@ -867,7 +867,7 @@ * digits:: If specified and less than the number of significant digits of the result, the result is rounded to that number of digits, according to BigDecimal.mode. */ static VALUE -BigDecimal_mult(VALUE self, VALUE r) +BigDecimal_mult(VALUE self, SEL sel, VALUE r) { ENTER(5); Real *c, *a, *b; @@ -922,7 +922,7 @@ * the quotient; see divmod. */ static VALUE -BigDecimal_div(VALUE self, VALUE r) +BigDecimal_div(VALUE self, SEL sel, VALUE r) /* For c = self/r: with round operation */ { ENTER(5); @@ -1006,7 +1006,7 @@ * Returns the modulus from dividing by b. See divmod. */ static VALUE -BigDecimal_mod(VALUE self, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */ +BigDecimal_mod(VALUE self, SEL sel, VALUE r) /* %: a%b = a - (a.to_f/b).floor * b */ { ENTER(3); VALUE obj; @@ -1063,7 +1063,7 @@ * Otherwise, the remainder is the modulus minus the value divided by. */ static VALUE -BigDecimal_remainder(VALUE self, VALUE r) /* remainder */ +BigDecimal_remainder(VALUE self, SEL sel, VALUE r) /* remainder */ { VALUE f; Real *d,*rv=0; @@ -1092,7 +1092,7 @@ * added to q * b to get a. */ static VALUE -BigDecimal_divmod(VALUE self, VALUE r) +BigDecimal_divmod(VALUE self, SEL sel, VALUE r) { ENTER(5); VALUE obj; @@ -1106,7 +1106,7 @@ } static VALUE -BigDecimal_div2(int argc, VALUE *argv, VALUE self) +BigDecimal_div2(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); VALUE b,n; @@ -1120,7 +1120,7 @@ return ToValue(div); } else { /* div in BigDecimal sense */ U_LONG ix = (U_LONG)GetPositiveInt(n); - if(ix==0) return BigDecimal_div(self,b); + if(ix==0) return BigDecimal_div(self, 0, b); else { Real *res=NULL; Real *av=NULL, *bv=NULL, *cv=NULL; @@ -1142,15 +1142,15 @@ } static VALUE -BigDecimal_add2(VALUE self, VALUE b, VALUE n) +BigDecimal_add2(VALUE self, SEL sel, VALUE b, VALUE n) { ENTER(2); Real *cv; U_LONG mx = (U_LONG)GetPositiveInt(n); - if(mx==0) return BigDecimal_add(self,b); + if(mx==0) return BigDecimal_add(self, 0, b); else { U_LONG pl = VpSetPrecLimit(0); - VALUE c = BigDecimal_add(self,b); + VALUE c = BigDecimal_add(self, 0, b); VpSetPrecLimit(pl); GUARD_OBJ(cv,GetVpValue(c,1)); VpLeftRound(cv,VpGetRoundMode(),mx); @@ -1159,15 +1159,15 @@ } static VALUE -BigDecimal_sub2(VALUE self, VALUE b, VALUE n) +BigDecimal_sub2(VALUE self, SEL sel, VALUE b, VALUE n) { ENTER(2); Real *cv; U_LONG mx = (U_LONG)GetPositiveInt(n); - if(mx==0) return BigDecimal_sub(self,b); + if(mx==0) return BigDecimal_sub(self, 0, b); else { U_LONG pl = VpSetPrecLimit(0); - VALUE c = BigDecimal_sub(self,b); + VALUE c = BigDecimal_sub(self, 0, b); VpSetPrecLimit(pl); GUARD_OBJ(cv,GetVpValue(c,1)); VpLeftRound(cv,VpGetRoundMode(),mx); @@ -1176,15 +1176,15 @@ } static VALUE -BigDecimal_mult2(VALUE self, VALUE b, VALUE n) +BigDecimal_mult2(VALUE self, SEL sel, VALUE b, VALUE n) { ENTER(2); Real *cv; U_LONG mx = (U_LONG)GetPositiveInt(n); - if(mx==0) return BigDecimal_mult(self,b); + if(mx==0) return BigDecimal_mult(self, 0, b); else { U_LONG pl = VpSetPrecLimit(0); - VALUE c = BigDecimal_mult(self,b); + VALUE c = BigDecimal_mult(self, 0, b); VpSetPrecLimit(pl); GUARD_OBJ(cv,GetVpValue(c,1)); VpLeftRound(cv,VpGetRoundMode(),mx); @@ -1199,7 +1199,7 @@ * BigDecimal('-3').abs -> 3 */ static VALUE -BigDecimal_abs(VALUE self) +BigDecimal_abs(VALUE self, SEL sel) { ENTER(5); Real *c, *a; @@ -1221,7 +1221,7 @@ * If n is specified, returns at least that many significant digits. */ static VALUE -BigDecimal_sqrt(VALUE self, VALUE nFig) +BigDecimal_sqrt(VALUE self, SEL sel, VALUE nFig) { ENTER(5); Real *c, *a; @@ -1240,7 +1240,7 @@ /* Return the integer part of the number. */ static VALUE -BigDecimal_fix(VALUE self) +BigDecimal_fix(VALUE self, SEL sel) { ENTER(5); Real *c, *a; @@ -1276,7 +1276,7 @@ * rounding is performed; see BigDecimal.mode. */ static VALUE -BigDecimal_round(int argc, VALUE *argv, VALUE self) +BigDecimal_round(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); Real *c, *a; @@ -1338,7 +1338,7 @@ * BigDecimal('13345.234').truncate(-2) -> 13300.0 */ static VALUE -BigDecimal_truncate(int argc, VALUE *argv, VALUE self) +BigDecimal_truncate(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); Real *c, *a; @@ -1365,7 +1365,7 @@ /* Return the fractional part of the number. */ static VALUE -BigDecimal_frac(VALUE self) +BigDecimal_frac(VALUE self, SEL sel) { ENTER(5); Real *c, *a; @@ -1398,7 +1398,7 @@ * BigDecimal('13345.234').floor(-2) -> 13300.0 */ static VALUE -BigDecimal_floor(int argc, VALUE *argv, VALUE self) +BigDecimal_floor(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); Real *c, *a; @@ -1442,7 +1442,7 @@ * BigDecimal('13345.234').ceil(-2) -> 13400.0 */ static VALUE -BigDecimal_ceil(int argc, VALUE *argv, VALUE self) +BigDecimal_ceil(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); Real *c, *a; @@ -1497,13 +1497,13 @@ * BigDecimal.new('123.45678901234567890').to_s(' F') -> ' 123.4567890123456789' */ static VALUE -BigDecimal_to_s(int argc, VALUE *argv, VALUE self) +BigDecimal_to_s(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); int fmt=0; /* 0:E format */ int fPlus=0; /* =0:default,=1: set ' ' before digits ,set '+' before digits. */ Real *vp; - char *psz; + const char *psz; char ch; U_LONG nc; S_INT mc = 0; @@ -1539,14 +1539,14 @@ } if(mc>0) nc += (nc + mc - 1) / mc + 1; - psz = ALLOCA_N(char,(unsigned int)nc); + char *buf = ALLOCA_N(char,(unsigned int)nc); if(fmt) { - VpToFString(vp, psz, mc, fPlus); + VpToFString(vp, buf, mc, fPlus); } else { - VpToString (vp, psz, mc, fPlus); + VpToString (vp, buf, mc, fPlus); } - return rb_str_new2(psz); + return rb_str_new2(buf); } /* Splits a BigDecimal number into four parts, returned as an array of values. @@ -1574,7 +1574,7 @@ * a BigDecimal to a Float.) */ static VALUE -BigDecimal_split(VALUE self) +BigDecimal_split(VALUE self, SEL sel) { ENTER(5); Real *vp; @@ -1607,7 +1607,7 @@ * of digits with no leading zeros, then n is the exponent. */ static VALUE -BigDecimal_exponent(VALUE self) +BigDecimal_exponent(VALUE self, SEL sel) { S_LONG e = VpExponent10(GetVpValue(self,1)); return INT2NUM(e); @@ -1624,7 +1624,7 @@ * maximum number of significant digits, respectively. */ static VALUE -BigDecimal_inspect(VALUE self) +BigDecimal_inspect(VALUE self, SEL sel) { ENTER(5); Real *vp; @@ -1653,7 +1653,7 @@ * Also available as the operator ** */ static VALUE -BigDecimal_power(VALUE self, VALUE p) +BigDecimal_power(VALUE self, SEL sel, VALUE p) { ENTER(5); Real *x, *y; @@ -1677,7 +1677,7 @@ } static VALUE -BigDecimal_global_new(int argc, VALUE *argv, VALUE self) +BigDecimal_global_new(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); Real *pv; @@ -1708,7 +1708,7 @@ * larger than the specified number. */ static VALUE -BigDecimal_new(int argc, VALUE *argv, VALUE self) +BigDecimal_new(VALUE self, SEL sel, int argc, VALUE *argv) { ENTER(5); Real *pv; @@ -1739,7 +1739,7 @@ * specified to instance methods such as ceil, floor, truncate, or round. */ static VALUE -BigDecimal_limit(int argc, VALUE *argv, VALUE self) +BigDecimal_limit(VALUE self, SEL sel, int argc, VALUE *argv) { VALUE nFig; VALUE nCur = INT2NUM(VpGetPrecLimit()); @@ -1774,7 +1774,7 @@ * BigDecimal::SIGN_NEGATIVE_FINITE:: value is negative */ static VALUE -BigDecimal_sign(VALUE self) +BigDecimal_sign(VALUE self, SEL sel) { /* sign */ int s = GetVpValue(self,1)->sign; return INT2FIX(s); @@ -1790,16 +1790,16 @@ rb_cBigDecimal = rb_define_class("BigDecimal",rb_cNumeric); /* Global function */ - rb_define_global_function("BigDecimal", BigDecimal_global_new, -1); + rb_objc_define_module_function(rb_mKernel, "BigDecimal", BigDecimal_global_new, -1); /* Class methods */ - rb_define_singleton_method(rb_cBigDecimal, "new", BigDecimal_new, -1); - rb_define_singleton_method(rb_cBigDecimal, "mode", BigDecimal_mode, -1); - rb_define_singleton_method(rb_cBigDecimal, "limit", BigDecimal_limit, -1); - rb_define_singleton_method(rb_cBigDecimal, "double_fig", BigDecimal_double_fig, 0); - rb_define_singleton_method(rb_cBigDecimal, "induced_from",BigDecimal_induced_from, 1); - rb_define_singleton_method(rb_cBigDecimal, "_load", BigDecimal_load, 1); - rb_define_singleton_method(rb_cBigDecimal, "ver", BigDecimal_version, 0); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "new", BigDecimal_new, -1); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "mode", BigDecimal_mode, -1); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "limit", BigDecimal_limit, -1); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "double_fig", BigDecimal_double_fig, 0); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "induced_from",BigDecimal_induced_from, 1); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "_load", BigDecimal_load, 1); + rb_objc_define_method(*(VALUE *)rb_cBigDecimal, "ver", BigDecimal_version, 0); /* Constants definition */ @@ -1908,56 +1908,56 @@ /* instance methods */ rb_define_method(rb_cBigDecimal, "precs", BigDecimal_prec, 0); - rb_define_method(rb_cBigDecimal, "add", BigDecimal_add2, 2); - rb_define_method(rb_cBigDecimal, "sub", BigDecimal_sub2, 2); - rb_define_method(rb_cBigDecimal, "mult", BigDecimal_mult2, 2); - rb_define_method(rb_cBigDecimal, "div",BigDecimal_div2, -1); - rb_define_method(rb_cBigDecimal, "hash", BigDecimal_hash, 0); - rb_define_method(rb_cBigDecimal, "to_s", BigDecimal_to_s, -1); - rb_define_method(rb_cBigDecimal, "to_i", BigDecimal_to_i, 0); - rb_define_method(rb_cBigDecimal, "to_int", BigDecimal_to_i, 0); - rb_define_method(rb_cBigDecimal, "split", BigDecimal_split, 0); - rb_define_method(rb_cBigDecimal, "+", BigDecimal_add, 1); - rb_define_method(rb_cBigDecimal, "-", BigDecimal_sub, 1); - rb_define_method(rb_cBigDecimal, "+@", BigDecimal_uplus, 0); - rb_define_method(rb_cBigDecimal, "-@", BigDecimal_neg, 0); - rb_define_method(rb_cBigDecimal, "*", BigDecimal_mult, 1); - rb_define_method(rb_cBigDecimal, "/", BigDecimal_div, 1); - rb_define_method(rb_cBigDecimal, "quo", BigDecimal_div, 1); - rb_define_method(rb_cBigDecimal, "%", BigDecimal_mod, 1); - rb_define_method(rb_cBigDecimal, "modulo", BigDecimal_mod, 1); - rb_define_method(rb_cBigDecimal, "remainder", BigDecimal_remainder, 1); - rb_define_method(rb_cBigDecimal, "divmod", BigDecimal_divmod, 1); + rb_objc_define_method(rb_cBigDecimal, "add", BigDecimal_add2, 2); + rb_objc_define_method(rb_cBigDecimal, "sub", BigDecimal_sub2, 2); + rb_objc_define_method(rb_cBigDecimal, "mult", BigDecimal_mult2, 2); + rb_objc_define_method(rb_cBigDecimal, "div", BigDecimal_div2, -1); + rb_objc_define_method(rb_cBigDecimal, "hash", BigDecimal_hash, 0); + rb_objc_define_method(rb_cBigDecimal, "to_s", BigDecimal_to_s, -1); + rb_objc_define_method(rb_cBigDecimal, "to_i", BigDecimal_to_i, 0); + rb_objc_define_method(rb_cBigDecimal, "to_int", BigDecimal_to_i, 0); + rb_objc_define_method(rb_cBigDecimal, "split", BigDecimal_split, 0); + rb_objc_define_method(rb_cBigDecimal, "+", BigDecimal_add, 1); + rb_objc_define_method(rb_cBigDecimal, "-", BigDecimal_sub, 1); + rb_objc_define_method(rb_cBigDecimal, "+@", BigDecimal_uplus, 0); + rb_objc_define_method(rb_cBigDecimal, "-@", BigDecimal_neg, 0); + rb_objc_define_method(rb_cBigDecimal, "*", BigDecimal_mult, 1); + rb_objc_define_method(rb_cBigDecimal, "/", BigDecimal_div, 1); + rb_objc_define_method(rb_cBigDecimal, "quo", BigDecimal_div, 1); + rb_objc_define_method(rb_cBigDecimal, "%", BigDecimal_mod, 1); + rb_objc_define_method(rb_cBigDecimal, "modulo", BigDecimal_mod, 1); + rb_objc_define_method(rb_cBigDecimal, "remainder", BigDecimal_remainder, 1); + rb_objc_define_method(rb_cBigDecimal, "divmod", BigDecimal_divmod, 1); /* rb_define_method(rb_cBigDecimal, "dup", BigDecimal_dup, 0); */ - rb_define_method(rb_cBigDecimal, "to_f", BigDecimal_to_f, 0); - rb_define_method(rb_cBigDecimal, "abs", BigDecimal_abs, 0); - rb_define_method(rb_cBigDecimal, "sqrt", BigDecimal_sqrt, 1); - rb_define_method(rb_cBigDecimal, "fix", BigDecimal_fix, 0); - rb_define_method(rb_cBigDecimal, "round", BigDecimal_round, -1); - rb_define_method(rb_cBigDecimal, "frac", BigDecimal_frac, 0); - rb_define_method(rb_cBigDecimal, "floor", BigDecimal_floor, -1); - rb_define_method(rb_cBigDecimal, "ceil", BigDecimal_ceil, -1); - rb_define_method(rb_cBigDecimal, "power", BigDecimal_power, 1); - rb_define_method(rb_cBigDecimal, "**", BigDecimal_power, 1); - rb_define_method(rb_cBigDecimal, "<=>", BigDecimal_comp, 1); - rb_define_method(rb_cBigDecimal, "==", BigDecimal_eq, 1); - rb_define_method(rb_cBigDecimal, "===", BigDecimal_eq, 1); - rb_define_method(rb_cBigDecimal, "eql?", BigDecimal_eq, 1); - rb_define_method(rb_cBigDecimal, "<", BigDecimal_lt, 1); - rb_define_method(rb_cBigDecimal, "<=", BigDecimal_le, 1); - rb_define_method(rb_cBigDecimal, ">", BigDecimal_gt, 1); - rb_define_method(rb_cBigDecimal, ">=", BigDecimal_ge, 1); - rb_define_method(rb_cBigDecimal, "zero?", BigDecimal_zero, 0); - rb_define_method(rb_cBigDecimal, "nonzero?", BigDecimal_nonzero, 0); - rb_define_method(rb_cBigDecimal, "coerce", BigDecimal_coerce, 1); - rb_define_method(rb_cBigDecimal, "inspect", BigDecimal_inspect, 0); - rb_define_method(rb_cBigDecimal, "exponent", BigDecimal_exponent, 0); - rb_define_method(rb_cBigDecimal, "sign", BigDecimal_sign, 0); - rb_define_method(rb_cBigDecimal, "nan?", BigDecimal_IsNaN, 0); - rb_define_method(rb_cBigDecimal, "infinite?", BigDecimal_IsInfinite, 0); - rb_define_method(rb_cBigDecimal, "finite?", BigDecimal_IsFinite, 0); - rb_define_method(rb_cBigDecimal, "truncate", BigDecimal_truncate, -1); - rb_define_method(rb_cBigDecimal, "_dump", BigDecimal_dump, -1); + rb_objc_define_method(rb_cBigDecimal, "to_f", BigDecimal_to_f, 0); + rb_objc_define_method(rb_cBigDecimal, "abs", BigDecimal_abs, 0); + rb_objc_define_method(rb_cBigDecimal, "sqrt", BigDecimal_sqrt, 1); + rb_objc_define_method(rb_cBigDecimal, "fix", BigDecimal_fix, 0); + rb_objc_define_method(rb_cBigDecimal, "round", BigDecimal_round, -1); + rb_objc_define_method(rb_cBigDecimal, "frac", BigDecimal_frac, 0); + rb_objc_define_method(rb_cBigDecimal, "floor", BigDecimal_floor, -1); + rb_objc_define_method(rb_cBigDecimal, "ceil", BigDecimal_ceil, -1); + rb_objc_define_method(rb_cBigDecimal, "power", BigDecimal_power, 1); + rb_objc_define_method(rb_cBigDecimal, "**", BigDecimal_power, 1); + rb_objc_define_method(rb_cBigDecimal, "<=>", BigDecimal_comp, 1); + rb_objc_define_method(rb_cBigDecimal, "==", BigDecimal_eq, 1); + rb_objc_define_method(rb_cBigDecimal, "===", BigDecimal_eq, 1); + rb_objc_define_method(rb_cBigDecimal, "eql?", BigDecimal_eq, 1); + rb_objc_define_method(rb_cBigDecimal, "<", BigDecimal_lt, 1); + rb_objc_define_method(rb_cBigDecimal, "<=", BigDecimal_le, 1); + rb_objc_define_method(rb_cBigDecimal, ">", BigDecimal_gt, 1); + rb_objc_define_method(rb_cBigDecimal, ">=", BigDecimal_ge, 1); + rb_objc_define_method(rb_cBigDecimal, "zero?", BigDecimal_zero, 0); + rb_objc_define_method(rb_cBigDecimal, "nonzero?", BigDecimal_nonzero, 0); + rb_objc_define_method(rb_cBigDecimal, "coerce", BigDecimal_coerce, 1); + rb_objc_define_method(rb_cBigDecimal, "inspect", BigDecimal_inspect, 0); + rb_objc_define_method(rb_cBigDecimal, "exponent", BigDecimal_exponent, 0); + rb_objc_define_method(rb_cBigDecimal, "sign", BigDecimal_sign, 0); + rb_objc_define_method(rb_cBigDecimal, "nan?", BigDecimal_IsNaN, 0); + rb_objc_define_method(rb_cBigDecimal, "infinite?", BigDecimal_IsInfinite, 0); + rb_objc_define_method(rb_cBigDecimal, "finite?", BigDecimal_IsFinite, 0); + rb_objc_define_method(rb_cBigDecimal, "truncate", BigDecimal_truncate, -1); + rb_objc_define_method(rb_cBigDecimal, "_dump", BigDecimal_dump, -1); } /* @@ -2192,12 +2192,14 @@ return nzero; } +#if 0 VP_EXPORT int VpIsNegDoubleZero(double v) { double z = VpGetDoubleNegZero(); return MemCmp(&v,&z,sizeof(v))==0; } +#endif VP_EXPORT int VpException(unsigned short f, const char *str,int always) @@ -4169,6 +4171,7 @@ /* * m <- ival */ +#if 0 VP_EXPORT void VpItoV(Real *m, S_INT ival) { @@ -4226,6 +4229,7 @@ #endif /* _DEBUG */ return; } +#endif /* * y = SQRT(x), y*y - x =>0 Modified: MacRuby/trunk/ext/bigdecimal/bigdecimal.h =================================================================== --- MacRuby/trunk/ext/bigdecimal/bigdecimal.h 2009-10-16 21:36:31 UTC (rev 2835) +++ MacRuby/trunk/ext/bigdecimal/bigdecimal.h 2009-10-17 08:10:09 UTC (rev 2836) @@ -103,7 +103,7 @@ */ VP_EXPORT Real * -VpNewRbClass(U_LONG mx,char *str,VALUE klass); +VpNewRbClass(U_LONG mx,const char *str,VALUE klass); VP_EXPORT Real *VpCreateRbObject(U_LONG mx,const char *str); @@ -127,7 +127,7 @@ VP_EXPORT unsigned long VpSetRoundMode(unsigned long n); VP_EXPORT int VpException(unsigned short f,const char *str,int always); -VP_EXPORT int VpIsNegDoubleZero(double v); +/*VP_EXPORT int VpIsNegDoubleZero(double v);*/ VP_EXPORT U_LONG VpNumOfChars(Real *vp,const char *pszFmt); VP_EXPORT U_LONG VpInit(U_LONG BaseVal); VP_EXPORT void *VpMemAlloc(U_LONG mb); @@ -146,7 +146,7 @@ VP_EXPORT int VpCtoV(Real *a,const char *int_chr,U_LONG ni,const char *frac,U_LONG nf,const char *exp_chr,U_LONG ne); VP_EXPORT int VpVtoD(double *d,S_LONG *e,Real *m); VP_EXPORT void VpDtoV(Real *m,double d); -VP_EXPORT void VpItoV(Real *m,S_INT ival); +/*VP_EXPORT void VpItoV(Real *m,S_INT ival);*/ VP_EXPORT int VpSqrt(Real *y,Real *x); VP_EXPORT int VpActiveRound(Real *y,Real *x,int f,int il); VP_EXPORT int VpMidRound(Real *y, int f, int nf); Modified: MacRuby/trunk/rakelib/builder.rake =================================================================== --- MacRuby/trunk/rakelib/builder.rake 2009-10-16 21:36:31 UTC (rev 2835) +++ MacRuby/trunk/rakelib/builder.rake 2009-10-17 08:10:09 UTC (rev 2836) @@ -326,7 +326,7 @@ EXTMK_ARGS = "#{SCRIPT_ARGS} --extension --extstatic" INSTRUBY_ARGS = "#{SCRIPT_ARGS} --data-mode=0644 --prog-mode=0755 --installed-list #{INSTALLED_LIST} --mantype=\"doc\" --sym-dest-dir=\"#{SYM_INSTDIR}\"" -EXTENSIONS = ['ripper', 'digest', 'etc', 'readline', 'libyaml', 'fcntl', 'socket', 'zlib'] +EXTENSIONS = ['ripper', 'digest', 'etc', 'readline', 'libyaml', 'fcntl', 'socket', 'zlib', 'bigdecimal'].sort def perform_extensions_target(target) EXTENSIONS.map { |x| File.join('ext', x) }.each do |ext_dir| Dir.glob(File.join(ext_dir, '**/extconf.rb')) do |p|