From 149af514e654bd9f2ac05a0dd0386dbf3ef75e6f Mon Sep 17 00:00:00 2001 From: Phil Dawes Date: Mon, 17 Aug 2009 21:37:05 +0100 Subject: [PATCH] Dev checkpoint --- vm/bignum.cpp | 119 +++++++++++++++++++++++++++++++++++--------------- vm/vm.hpp | 14 ++++++ 2 files changed, 98 insertions(+), 35 deletions(-) diff --git a/vm/bignum.cpp b/vm/bignum.cpp index a3c3e73ca1..405aff4e5e 100755 --- a/vm/bignum.cpp +++ b/vm/bignum.cpp @@ -189,9 +189,7 @@ bignum *bignum_multiply(bignum * x, bignum * y) } /* allocates memory */ -void -bignum_divide(bignum * numerator, bignum * denominator, - bignum * * quotient, bignum * * remainder) +void factorvm::bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder) { if (BIGNUM_ZERO_P (denominator)) { @@ -261,9 +259,13 @@ bignum_divide(bignum * numerator, bignum * denominator, } } +void bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder) +{ + return vm->bignum_divide(numerator,denominator,quotient,remainder); +} + /* allocates memory */ -bignum * -bignum_quotient(bignum * numerator, bignum * denominator) +bignum *factorvm::bignum_quotient(bignum * numerator, bignum * denominator) { if (BIGNUM_ZERO_P (denominator)) { @@ -314,9 +316,13 @@ bignum_quotient(bignum * numerator, bignum * denominator) } } +bignum *bignum_quotient(bignum * numerator, bignum * denominator) +{ + return vm->bignum_quotient(numerator,denominator); +} + /* allocates memory */ -bignum * -bignum_remainder(bignum * numerator, bignum * denominator) +bignum *factorvm::bignum_remainder(bignum * numerator, bignum * denominator) { if (BIGNUM_ZERO_P (denominator)) { @@ -359,6 +365,11 @@ bignum_remainder(bignum * numerator, bignum * denominator) } } +bignum *bignum_remainder(bignum * numerator, bignum * denominator) +{ + return vm->bignum_remainder(numerator, denominator); +} + #define FOO_TO_BIGNUM(name,type,utype) \ bignum * name##_to_bignum(type n) \ { \ @@ -416,8 +427,7 @@ BIGNUM_TO_FOO(fixnum,fixnum,cell); BIGNUM_TO_FOO(long_long,s64,u64) BIGNUM_TO_FOO(ulong_long,u64,u64) -double -bignum_to_double(bignum * bignum) +double factorvm::bignum_to_double(bignum * bignum) { if (BIGNUM_ZERO_P (bignum)) return (0); @@ -431,6 +441,11 @@ bignum_to_double(bignum * bignum) } } +double bignum_to_double(bignum * bignum) +{ + return vm->bignum_to_double(bignum); +} + #define DTB_WRITE_DIGIT(factor) \ { \ significand *= (factor); \ @@ -442,8 +457,7 @@ bignum_to_double(bignum * bignum) /* allocates memory */ #define inf std::numeric_limits::infinity() -bignum * -double_to_bignum(double x) +bignum *factorvm::double_to_bignum(double x) { if (x == inf || x == -inf || x != x) return (BIGNUM_ZERO ()); int exponent; @@ -474,12 +488,16 @@ double_to_bignum(double x) } } +bignum *double_to_bignum(double x) +{ + return vm->double_to_bignum(x); +} + #undef DTB_WRITE_DIGIT /* Comparisons */ -int -bignum_equal_p_unsigned(bignum * x, bignum * y) +int factorvm::bignum_equal_p_unsigned(bignum * x, bignum * y) { bignum_length_type length = (BIGNUM_LENGTH (x)); if (length != (BIGNUM_LENGTH (y))) @@ -496,8 +514,12 @@ bignum_equal_p_unsigned(bignum * x, bignum * y) } } -enum bignum_comparison -bignum_compare_unsigned(bignum * x, bignum * y) +int bignum_equal_p_unsigned(bignum * x, bignum * y) +{ + return vm->bignum_equal_p_unsigned(x,y); +} + +enum bignum_comparison factorvm::bignum_compare_unsigned(bignum * x, bignum * y) { bignum_length_type x_length = (BIGNUM_LENGTH (x)); bignum_length_type y_length = (BIGNUM_LENGTH (y)); @@ -522,11 +544,15 @@ bignum_compare_unsigned(bignum * x, bignum * y) return (bignum_comparison_equal); } +enum bignum_comparison bignum_compare_unsigned(bignum * x, bignum * y) +{ + return vm->bignum_compare_unsigned(x,y); +} + /* Addition */ /* allocates memory */ -bignum * -bignum_add_unsigned(bignum * x, bignum * y, int negative_p) +bignum *factorvm::bignum_add_unsigned(bignum * x, bignum * y, int negative_p) { GC_BIGNUM(x); GC_BIGNUM(y); @@ -590,11 +616,15 @@ bignum_add_unsigned(bignum * x, bignum * y, int negative_p) } } +bignum *bignum_add_unsigned(bignum * x, bignum * y, int negative_p) +{ + return vm->bignum_add_unsigned(x,y,negative_p); +} + /* Subtraction */ /* allocates memory */ -bignum * -bignum_subtract_unsigned(bignum * x, bignum * y) +bignum *factorvm::bignum_subtract_unsigned(bignum * x, bignum * y) { GC_BIGNUM(x); GC_BIGNUM(y); @@ -665,6 +695,11 @@ bignum_subtract_unsigned(bignum * x, bignum * y) } } +bignum *bignum_subtract_unsigned(bignum * x, bignum * y) +{ + return vm->bignum_subtract_unsigned(x,y); +} + /* Multiplication Maximum value for product_low or product_high: ((R * R) + (R * (R - 2)) + (R - 1)) @@ -672,8 +707,7 @@ bignum_subtract_unsigned(bignum * x, bignum * y) where R == BIGNUM_RADIX_ROOT */ /* allocates memory */ -bignum * -bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p) +bignum *factorvm::bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p) { GC_BIGNUM(x); GC_BIGNUM(y); @@ -743,10 +777,13 @@ bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p) } } +bignum *bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p) +{ + return vm->bignum_multiply_unsigned(x,y,negative_p); +} + /* allocates memory */ -bignum * -bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y, - int negative_p) +bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y,int negative_p) { GC_BIGNUM(x); @@ -760,8 +797,12 @@ bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y, return (bignum_trim (p)); } -void -bignum_destructive_add(bignum * bignum, bignum_digit_type n) +bignum *bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y,int negative_p) +{ + return vm->bignum_multiply_unsigned_small_factor(x,y,negative_p); +} + +void factorvm::bignum_destructive_add(bignum * bignum, bignum_digit_type n) { bignum_digit_type * scan = (BIGNUM_START_PTR (bignum)); bignum_digit_type digit; @@ -784,8 +825,12 @@ bignum_destructive_add(bignum * bignum, bignum_digit_type n) } } -void -bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) +void bignum_destructive_add(bignum * bignum, bignum_digit_type n) +{ + return vm->bignum_destructive_add(bignum,n); +} + +void factorvm::bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) { bignum_digit_type carry = 0; bignum_digit_type * scan = (BIGNUM_START_PTR (bignum)); @@ -814,6 +859,11 @@ bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) #undef product_high } +void bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) +{ + return vm->bignum_destructive_scale_up(bignum,factor); +} + /* Division */ /* For help understanding this algorithm, see: @@ -822,13 +872,7 @@ bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor) section 4.3.1, "Multiple-Precision Arithmetic". */ /* allocates memory */ -void -bignum_divide_unsigned_large_denominator(bignum * numerator, - bignum * denominator, - bignum * * quotient, - bignum * * remainder, - int q_negative_p, - int r_negative_p) +void factorvm::bignum_divide_unsigned_large_denominator(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder, int q_negative_p, int r_negative_p) { GC_BIGNUM(numerator); GC_BIGNUM(denominator); @@ -885,6 +929,11 @@ bignum_divide_unsigned_large_denominator(bignum * numerator, return; } +void bignum_divide_unsigned_large_denominator(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder, int q_negative_p, int r_negative_p) +{ + return vm->bignum_divide_unsigned_large_denominator(numerator,denominator,quotient,remainder,q_negative_p,r_negative_p); +} + void bignum_divide_unsigned_normalized(bignum * u, bignum * v, bignum * q) { diff --git a/vm/vm.hpp b/vm/vm.hpp index 523e1f63e7..c492477db2 100644 --- a/vm/vm.hpp +++ b/vm/vm.hpp @@ -63,6 +63,20 @@ struct factorvm { bignum *bignum_add(bignum * x, bignum * y); bignum *bignum_subtract(bignum * x, bignum * y); bignum *bignum_multiply(bignum * x, bignum * y); + void bignum_divide(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder); + bignum *bignum_quotient(bignum * numerator, bignum * denominator); + bignum *bignum_remainder(bignum * numerator, bignum * denominator); + double bignum_to_double(bignum * bignum); + bignum *double_to_bignum(double x); + int bignum_equal_p_unsigned(bignum * x, bignum * y); + enum bignum_comparison bignum_compare_unsigned(bignum * x, bignum * y); + bignum *bignum_add_unsigned(bignum * x, bignum * y, int negative_p); + bignum *bignum_subtract_unsigned(bignum * x, bignum * y); + bignum *bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p); + bignum *bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y,int negative_p); + void bignum_destructive_add(bignum * bignum, bignum_digit_type n); + void bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor); + void bignum_divide_unsigned_large_denominator(bignum * numerator, bignum * denominator, bignum * * quotient, bignum * * remainder, int q_negative_p, int r_negative_p); // next method here: };