added vm member to gc_bignum

diff --git a/vm/bignum.cpp b/vm/bignum.cpp
index a5310d1c14f0ee9d9540631be9b5983b2aa00de8..62d9952364ea4803728195034814ffa028c23156 100755 (executable)
--- a/vm/bignum.cpp
+++ b/vm/bignum.cpp
@@ -554,7 +554,7 @@ enum bignum_comparison bignum_compare_unsigned(bignum * x, bignum * y)
 /* allocates memory */
 bignum *factorvm::bignum_add_unsigned(bignum * x, bignum * y, int negative_p)
 {
-  GC_BIGNUM(x); GC_BIGNUM(y);
+       GC_BIGNUM(x,this); GC_BIGNUM(y,this);
 
   if ((BIGNUM_LENGTH (y)) > (BIGNUM_LENGTH (x)))
     {
@@ -626,7 +626,7 @@ bignum *bignum_add_unsigned(bignum * x, bignum * y, int negative_p)
 /* allocates memory */
 bignum *factorvm::bignum_subtract_unsigned(bignum * x, bignum * y)
 {
-  GC_BIGNUM(x); GC_BIGNUM(y);
+       GC_BIGNUM(x,this); GC_BIGNUM(y,this);
   
   int negative_p = 0;
   switch (bignum_compare_unsigned (x, y))
@@ -709,7 +709,7 @@ bignum *bignum_subtract_unsigned(bignum * x, bignum * y)
 /* allocates memory */
 bignum *factorvm::bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p)
 {
-  GC_BIGNUM(x); GC_BIGNUM(y);
+       GC_BIGNUM(x,this); GC_BIGNUM(y,this);
 
   if ((BIGNUM_LENGTH (y)) > (BIGNUM_LENGTH (x)))
     {
@@ -785,7 +785,7 @@ bignum *bignum_multiply_unsigned(bignum * x, bignum * y, int negative_p)
 /* allocates memory */
 bignum *factorvm::bignum_multiply_unsigned_small_factor(bignum * x, bignum_digit_type y,int negative_p)
 {
-  GC_BIGNUM(x);
+       GC_BIGNUM(x,this);
   
   bignum_length_type length_x = (BIGNUM_LENGTH (x));
 
@@ -874,7 +874,7 @@ void bignum_destructive_scale_up(bignum * bignum, bignum_digit_type factor)
 /* allocates memory */
 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);
+       GC_BIGNUM(numerator,this); GC_BIGNUM(denominator,this);
   
   bignum_length_type length_n = ((BIGNUM_LENGTH (numerator)) + 1);
   bignum_length_type length_d = (BIGNUM_LENGTH (denominator));
@@ -883,10 +883,10 @@ void factorvm::bignum_divide_unsigned_large_denominator(bignum * numerator, bign
     ((quotient != ((bignum * *) 0))
      ? (allot_bignum ((length_n - length_d), q_negative_p))
      : BIGNUM_OUT_OF_BAND);
-  GC_BIGNUM(q);
+  GC_BIGNUM(q,this);
   
   bignum * u = (allot_bignum (length_n, r_negative_p));
-  GC_BIGNUM(u);
+  GC_BIGNUM(u,this);
   
   int shift = 0;
   BIGNUM_ASSERT (length_d > 1);
@@ -1096,12 +1096,12 @@ bignum_digit_type bignum_divide_subtract(bignum_digit_type * v_start, bignum_dig
 /* allocates memory */
 void factorvm::bignum_divide_unsigned_medium_denominator(bignum * numerator,bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p)
 {
-  GC_BIGNUM(numerator);
+       GC_BIGNUM(numerator,this);
   
   bignum_length_type length_n = (BIGNUM_LENGTH (numerator));
   bignum_length_type length_q;
   bignum * q = NULL;
-  GC_BIGNUM(q);
+  GC_BIGNUM(q,this);
   
   int shift = 0;
   /* Because `bignum_digit_divide' requires a normalized denominator. */
@@ -1351,10 +1351,10 @@ bignum_digit_type bignum_digit_divide_subtract(bignum_digit_type v1, bignum_digi
 /* allocates memory */
 void factorvm::bignum_divide_unsigned_small_denominator(bignum * numerator, bignum_digit_type denominator, bignum * * quotient, bignum * * remainder,int q_negative_p, int r_negative_p)
 {
-  GC_BIGNUM(numerator);
+       GC_BIGNUM(numerator,this);
   
   bignum * q = (bignum_new_sign (numerator, q_negative_p));
-  GC_BIGNUM(q);
+  GC_BIGNUM(q,this);
 
   bignum_digit_type r = (bignum_destructive_scale_down (q, denominator));
 
@@ -1525,7 +1525,7 @@ bignum *bignum_trim(bignum * bignum)
 /* allocates memory */
 bignum *factorvm::bignum_new_sign(bignum * x, int negative_p)
 {
-  GC_BIGNUM(x);
+       GC_BIGNUM(x,this);
   bignum * result = (allot_bignum ((BIGNUM_LENGTH (x)), negative_p));
 
   bignum_destructive_copy (x, result);
@@ -1667,7 +1667,7 @@ bignum *bignum_bitwise_xor(bignum * arg1, bignum * arg2)
 /* assume arg1 is a big number, n is a long */
 bignum *factorvm::bignum_magnitude_ash(bignum * arg1, fixnum n)
 {
-  GC_BIGNUM(arg1);
+       GC_BIGNUM(arg1,this);
   
   bignum * result = NULL;
   bignum_digit_type *scan1;
@@ -1733,7 +1733,7 @@ bignum *bignum_magnitude_ash(bignum * arg1, fixnum n)
 /* allocates memory */
 bignum *factorvm::bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2)
 {
-  GC_BIGNUM(arg1); GC_BIGNUM(arg2);
+       GC_BIGNUM(arg1,this); GC_BIGNUM(arg2,this);
   
   bignum * result;
   bignum_length_type max_length;
@@ -1772,7 +1772,7 @@ bignum *bignum_pospos_bitwise_op(int op, bignum * arg1, bignum * arg2)
 /* allocates memory */
 bignum *factorvm::bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
 {
-  GC_BIGNUM(arg1); GC_BIGNUM(arg2);
+       GC_BIGNUM(arg1,this); GC_BIGNUM(arg2,this);
   
   bignum * result;
   bignum_length_type max_length;
@@ -1829,7 +1829,7 @@ bignum *bignum_posneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
 /* allocates memory */
 bignum *factorvm::bignum_negneg_bitwise_op(int op, bignum * arg1, bignum * arg2)
 {
-  GC_BIGNUM(arg1); GC_BIGNUM(arg2);
+       GC_BIGNUM(arg1,this); GC_BIGNUM(arg2,this);
   
   bignum * result;
   bignum_length_type max_length;
@@ -1926,7 +1926,7 @@ void bignum_negate_magnitude(bignum * arg)
 /* Allocates memory */
 bignum *factorvm::bignum_integer_length(bignum * x)
 {
-  GC_BIGNUM(x);
+       GC_BIGNUM(x,this);
   
   bignum_length_type index = ((BIGNUM_LENGTH (x)) - 1);
   bignum_digit_type digit = (BIGNUM_REF (x, index));

diff --git a/vm/local_roots.hpp b/vm/local_roots.hpp
index e0b33a4d1d85a72b86a169ebf73436dc55d3abe1..26d083be407169dea0e06fb2227774fdd8d46ee0 100644 (file)
--- a/vm/local_roots.hpp
+++ b/vm/local_roots.hpp
@@ -19,9 +19,9 @@ struct gc_root : public tagged<TYPE>
 
        ~gc_root() {
 #ifdef FACTOR_DEBUG
-               assert(vm->gc_locals.back() == (cell)this);
+               assert(myvm->gc_locals.back() == (cell)this);
 #endif
-               vm->gc_locals.pop_back();
+               myvm->gc_locals.pop_back();
        }
 };
 
@@ -30,21 +30,20 @@ struct gc_bignum
 {
        bignum **addr;
        factorvm *myvm;
-       //gc_bignum(bignum **addr_, factorvm *vm) : addr(addr_), myvm(vm) {
-       gc_bignum(bignum **addr_) : addr(addr_), myvm(vm) {
+       gc_bignum(bignum **addr_, factorvm *vm) : addr(addr_), myvm(vm) {
                if(*addr_)
                        check_data_pointer(*addr_);
-               vm->gc_bignums.push_back((cell)addr);
+               myvm->gc_bignums.push_back((cell)addr);
        }
 
        ~gc_bignum() {
 #ifdef FACTOR_DEBUG
-               assert(vm->gc_bignums.back() == (cell)addr);
+               assert(myvm->gc_bignums.back() == (cell)addr);
 #endif
-               vm->gc_bignums.pop_back();
+               myvm->gc_bignums.pop_back();
        }
 };
 
-#define GC_BIGNUM(x) gc_bignum x##__gc_root(&x)
+#define GC_BIGNUM(x,vm) gc_bignum x##__gc_root(&x,vm)
 
 }

diff --git a/vm/math.cpp b/vm/math.cpp
index ac04e906a242d5f4ca65f6bdaa25c33a558a14ce..f273cede0ee6220631c57721488ad0941c07f43a 100755 (executable)
--- a/vm/math.cpp
+++ b/vm/math.cpp
@@ -863,9 +863,9 @@ VM_ASM_API void overflow_fixnum_subtract(fixnum x, fixnum y)
 void factorvm::overflow_fixnum_multiply(fixnum x, fixnum y)
 {
        bignum *bx = fixnum_to_bignum(x);
-       GC_BIGNUM(bx);
+       GC_BIGNUM(bx,this);
        bignum *by = fixnum_to_bignum(y);
-       GC_BIGNUM(by);
+       GC_BIGNUM(by,this);
        drepl(tag<bignum>(bignum_multiply(bx,by)));
 }