steve
/
factor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

VM: rename all variables named "bignum" in bignum.cpp to "bn" 

The name can cause compiler errors because it's the same as the type
name. It only matters in some functions, but I like consistency so I
renamed it everywhere.
db4
Björn Lindqvist 2014-06-12 18:13:18 +02:00 committed by John Benediktsson
parent 75129d34ad
commit 8ac3b80173
2 changed files with 50 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
vm/bignum.cpp
View File

@ -364,17 +364,17 @@ FOO_TO_BIGNUM(ulong_long, uint64_t, int64_t, uint64_t)
/* cannot allocate memory */ /* cannot allocate memory */
/* bignum_to_cell, fixnum_to_cell, long_long_to_cell, ulong_long_to_cell */ /* bignum_to_cell, fixnum_to_cell, long_long_to_cell, ulong_long_to_cell */
#define BIGNUM_TO_FOO(name, type, stype, utype) \ #define BIGNUM_TO_FOO(name, type, stype, utype) \
type factor_vm::bignum_to_##name(bignum * bignum) { \ type factor_vm::bignum_to_##name(bignum* bn) { \
if (BIGNUM_ZERO_P(bignum)) \ if (BIGNUM_ZERO_P(bn)) \
return (0); \ return (0); \
{ \ { \
utype accumulator = 0; \ utype accumulator = 0; \
bignum_digit_type* start = (BIGNUM_START_PTR(bignum)); \ bignum_digit_type* start = (BIGNUM_START_PTR(bn)); \
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bignum))); \ bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bn))); \
while (start < scan) \ while (start < scan) \
accumulator = ((accumulator << BIGNUM_DIGIT_LENGTH) + (*--scan)); \ accumulator = ((accumulator << BIGNUM_DIGIT_LENGTH) + (*--scan)); \
return ((BIGNUM_NEGATIVE_P(bignum)) ? ((type)(-(stype) accumulator)) \ return ((BIGNUM_NEGATIVE_P(bn)) ? ((type)(-(stype) accumulator)) \
: accumulator); \ : accumulator); \
} \ } \
} }
@ -384,13 +384,13 @@ BIGNUM_TO_FOO(long_long, int64_t, int64_t, uint64_t)
BIGNUM_TO_FOO(ulong_long, uint64_t, int64_t, uint64_t) BIGNUM_TO_FOO(ulong_long, uint64_t, int64_t, uint64_t)
/* cannot allocate memory */ /* cannot allocate memory */
fixnum factor_vm::bignum_to_fixnum_strict(bignum* bignum_in) { fixnum factor_vm::bignum_to_fixnum_strict(bignum* bn) {
fixnum len = BIGNUM_LENGTH(bignum_in); fixnum len = BIGNUM_LENGTH(bn);
bignum_digit_type *digits = BIGNUM_START_PTR(bignum_in); bignum_digit_type *digits = BIGNUM_START_PTR(bn);
if ((len == 1 && digits[0] > fixnum_max) || (len > 1)) { if ((len == 1 && digits[0] > fixnum_max) || (len > 1)) {
general_error(ERROR_OUT_OF_FIXNUM_RANGE, tag<bignum>(bignum_in), false_object); general_error(ERROR_OUT_OF_FIXNUM_RANGE, tag<bignum>(bn), false_object);
} }
fixnum fix = bignum_to_fixnum(bignum_in); fixnum fix = bignum_to_fixnum(bn);
FACTOR_ASSERT(fix <= fixnum_max && fix >= fixnum_min); FACTOR_ASSERT(fix <= fixnum_max && fix >= fixnum_min);
return fix; return fix;
} }
@ -682,8 +682,8 @@ bignum* factor_vm::bignum_multiply_unsigned_small_factor(bignum* x,
return (bignum_trim(p)); return (bignum_trim(p));
} }
void factor_vm::bignum_destructive_add(bignum* bignum, bignum_digit_type n) { void factor_vm::bignum_destructive_add(bignum* bn, bignum_digit_type n) {
bignum_digit_type* scan = (BIGNUM_START_PTR(bignum)); bignum_digit_type* scan = (BIGNUM_START_PTR(bn));
bignum_digit_type digit; bignum_digit_type digit;
digit = ((*scan) + n); digit = ((*scan) + n);
if (digit < BIGNUM_RADIX) { if (digit < BIGNUM_RADIX) {
@ -701,14 +701,14 @@ void factor_vm::bignum_destructive_add(bignum* bignum, bignum_digit_type n) {
} }
} }
void factor_vm::bignum_destructive_scale_up(bignum* bignum, void factor_vm::bignum_destructive_scale_up(bignum* bn,
bignum_digit_type factor) { bignum_digit_type factor) {
bignum_digit_type carry = 0; bignum_digit_type carry = 0;
bignum_digit_type* scan = (BIGNUM_START_PTR(bignum)); bignum_digit_type* scan = (BIGNUM_START_PTR(bn));
bignum_digit_type two_digits; bignum_digit_type two_digits;
bignum_digit_type product_low; bignum_digit_type product_low;
#define product_high carry #define product_high carry
bignum_digit_type* end = (scan + (BIGNUM_LENGTH(bignum))); bignum_digit_type* end = (scan + (BIGNUM_LENGTH(bn)));
BIGNUM_ASSERT((factor > 1) && (factor < BIGNUM_RADIX_ROOT)); BIGNUM_ASSERT((factor > 1) && (factor < BIGNUM_RADIX_ROOT));
while (scan < end) { while (scan < end) {
two_digits = (*scan); two_digits = (*scan);
@ -999,10 +999,10 @@ void factor_vm::bignum_destructive_normalization(bignum* source, bignum* target,
return; return;
} }
void factor_vm::bignum_destructive_unnormalization(bignum* bignum, void factor_vm::bignum_destructive_unnormalization(bignum* bn,
int shift_right) { int shift_right) {
bignum_digit_type* start = (BIGNUM_START_PTR(bignum)); bignum_digit_type* start = (BIGNUM_START_PTR(bn));
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bignum))); bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bn)));
bignum_digit_type digit; bignum_digit_type digit;
bignum_digit_type carry = 0; bignum_digit_type carry = 0;
int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right); int shift_left = (BIGNUM_DIGIT_LENGTH - shift_right);
@ -1160,13 +1160,13 @@ void factor_vm::bignum_divide_unsigned_small_denominator(
that all digits are < BIGNUM_RADIX. */ that all digits are < BIGNUM_RADIX. */
bignum_digit_type factor_vm::bignum_destructive_scale_down( bignum_digit_type factor_vm::bignum_destructive_scale_down(
bignum* bignum, bignum_digit_type denominator) { bignum* bn, bignum_digit_type denominator) {
bignum_digit_type numerator; bignum_digit_type numerator;
bignum_digit_type remainder = 0; bignum_digit_type remainder = 0;
bignum_digit_type two_digits; bignum_digit_type two_digits;
#define quotient_high remainder #define quotient_high remainder
bignum_digit_type* start = (BIGNUM_START_PTR(bignum)); bignum_digit_type* start = (BIGNUM_START_PTR(bn));
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bignum))); bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bn)));
BIGNUM_ASSERT((denominator > 1) && (denominator < BIGNUM_RADIX_ROOT)); BIGNUM_ASSERT((denominator > 1) && (denominator < BIGNUM_RADIX_ROOT));
while (start < scan) { while (start < scan) {
two_digits = (*--scan); two_digits = (*--scan);
@ -1234,33 +1234,33 @@ bignum* factor_vm::allot_bignum_zeroed(bignum_length_type length,
source = reallot_array(source, length + 1) source = reallot_array(source, length + 1)
/* Allocates memory */ /* Allocates memory */
bignum* factor_vm::bignum_shorten_length(bignum* bignum, bignum* factor_vm::bignum_shorten_length(bignum* bn,
bignum_length_type length) { bignum_length_type length) {
bignum_length_type current_length = (BIGNUM_LENGTH(bignum)); bignum_length_type current_length = (BIGNUM_LENGTH(bn));
BIGNUM_ASSERT((length >= 0) || (length <= current_length)); BIGNUM_ASSERT((length >= 0) || (length <= current_length));
if (length < current_length) { if (length < current_length) {
GC_BIGNUM(bignum); GC_BIGNUM(bn);
BIGNUM_REDUCE_LENGTH(bignum, length); BIGNUM_REDUCE_LENGTH(bn, length);
BIGNUM_SET_NEGATIVE_P(bignum, (length != 0) && (BIGNUM_NEGATIVE_P(bignum))); BIGNUM_SET_NEGATIVE_P(bn, (length != 0) && (BIGNUM_NEGATIVE_P(bn)));
} }
return (bignum); return (bn);
} }
/* Allocates memory */ /* Allocates memory */
bignum* factor_vm::bignum_trim(bignum* bignum) { bignum* factor_vm::bignum_trim(bignum* bn) {
bignum_digit_type* start = (BIGNUM_START_PTR(bignum)); bignum_digit_type* start = (BIGNUM_START_PTR(bn));
bignum_digit_type* end = (start + (BIGNUM_LENGTH(bignum))); bignum_digit_type* end = (start + (BIGNUM_LENGTH(bn)));
bignum_digit_type* scan = end; bignum_digit_type* scan = end;
while ((start <= scan) && ((*--scan) == 0)) while ((start <= scan) && ((*--scan) == 0))
; ;
scan += 1; scan += 1;
if (scan < end) { if (scan < end) {
GC_BIGNUM(bignum); GC_BIGNUM(bn);
bignum_length_type length = (scan - start); bignum_length_type length = (scan - start);
BIGNUM_REDUCE_LENGTH(bignum, length); BIGNUM_REDUCE_LENGTH(bn, length);
BIGNUM_SET_NEGATIVE_P(bignum, (length != 0) && (BIGNUM_NEGATIVE_P(bignum))); BIGNUM_SET_NEGATIVE_P(bn, (length != 0) && (BIGNUM_NEGATIVE_P(bn)));
} }
return (bignum); return (bn);
} }
/* Copying */ /* Copying */
@ -1668,12 +1668,12 @@ int factor_vm::bignum_logbitp(int shift, bignum* arg) {
: bignum_unsigned_logbitp(shift, arg)); : bignum_unsigned_logbitp(shift, arg));
} }
int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bignum) { int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bn) {
bignum_length_type len = (BIGNUM_LENGTH(bignum)); bignum_length_type len = (BIGNUM_LENGTH(bn));
int index = shift / BIGNUM_DIGIT_LENGTH; int index = shift / BIGNUM_DIGIT_LENGTH;
if (index >= len) if (index >= len)
return 0; return 0;
bignum_digit_type digit = (BIGNUM_REF(bignum, index)); bignum_digit_type digit = (BIGNUM_REF(bn, index));
int p = shift % BIGNUM_DIGIT_LENGTH; int p = shift % BIGNUM_DIGIT_LENGTH;
bignum_digit_type mask = ((fixnum)1) << p; bignum_digit_type mask = ((fixnum)1) << p;
return (digit & mask) ? 1 : 0; return (digit & mask) ? 1 : 0;

24
vm/vm.hpp
View File

@ -239,11 +239,11 @@ struct factor_vm {
bignum** remainder); bignum** remainder);
bignum* bignum_quotient(bignum* numerator, bignum* denominator); bignum* bignum_quotient(bignum* numerator, bignum* denominator);
bignum* bignum_remainder(bignum* numerator, bignum* denominator); bignum* bignum_remainder(bignum* numerator, bignum* denominator);
cell bignum_to_cell(bignum* bignum); cell bignum_to_cell(bignum* bn);
fixnum bignum_to_fixnum_strict(bignum* bignum); fixnum bignum_to_fixnum_strict(bignum* bn);
fixnum bignum_to_fixnum(bignum* bignum); fixnum bignum_to_fixnum(bignum* bn);
int64_t bignum_to_long_long(bignum* bignum); int64_t bignum_to_long_long(bignum* bn);
uint64_t bignum_to_ulong_long(bignum* bignum); uint64_t bignum_to_ulong_long(bignum* bn);
bignum* double_to_bignum(double x); bignum* double_to_bignum(double x);
int bignum_equal_p_unsigned(bignum* x, bignum* y); int bignum_equal_p_unsigned(bignum* x, bignum* y);
enum bignum_comparison bignum_compare_unsigned(bignum* x, bignum* y); enum bignum_comparison bignum_compare_unsigned(bignum* x, bignum* y);
@ -252,8 +252,8 @@ struct factor_vm {
bignum* bignum_multiply_unsigned(bignum* x, bignum* y, int negative_p); bignum* bignum_multiply_unsigned(bignum* x, bignum* y, int negative_p);
bignum* bignum_multiply_unsigned_small_factor(bignum* x, bignum_digit_type y, bignum* bignum_multiply_unsigned_small_factor(bignum* x, bignum_digit_type y,
int negative_p); int negative_p);
void bignum_destructive_add(bignum* bignum, bignum_digit_type n); void bignum_destructive_add(bignum* bn, bignum_digit_type n);
void bignum_destructive_scale_up(bignum* bignum, bignum_digit_type factor); void bignum_destructive_scale_up(bignum* bn, bignum_digit_type factor);
void bignum_divide_unsigned_large_denominator( void bignum_divide_unsigned_large_denominator(
bignum* numerator, bignum* denominator, bignum** quotient, bignum* numerator, bignum* denominator, bignum** quotient,
bignum** remainder, int q_negative_p, int r_negative_p); bignum** remainder, int q_negative_p, int r_negative_p);
@ -267,7 +267,7 @@ struct factor_vm {
bignum** remainder, int q_negative_p, int r_negative_p); bignum** remainder, int q_negative_p, int r_negative_p);
void bignum_destructive_normalization(bignum* source, bignum* target, void bignum_destructive_normalization(bignum* source, bignum* target,
int shift_left); int shift_left);
void bignum_destructive_unnormalization(bignum* bignum, int shift_right); void bignum_destructive_unnormalization(bignum* bn, int shift_right);
bignum_digit_type bignum_digit_divide( bignum_digit_type bignum_digit_divide(
bignum_digit_type uh, bignum_digit_type ul, bignum_digit_type v, bignum_digit_type uh, bignum_digit_type ul, bignum_digit_type v,
bignum_digit_type* q) /* return value */; bignum_digit_type* q) /* return value */;
@ -279,15 +279,15 @@ struct factor_vm {
bignum* numerator, bignum_digit_type denominator, bignum** quotient, bignum* numerator, bignum_digit_type denominator, bignum** quotient,
bignum** remainder, int q_negative_p, int r_negative_p); bignum** remainder, int q_negative_p, int r_negative_p);
bignum_digit_type bignum_destructive_scale_down( bignum_digit_type bignum_destructive_scale_down(
bignum* bignum, bignum_digit_type denominator); bignum* bn, bignum_digit_type denominator);
bignum* bignum_remainder_unsigned_small_denominator(bignum* n, bignum* bignum_remainder_unsigned_small_denominator(bignum* n,
bignum_digit_type d, bignum_digit_type d,
int negative_p); int negative_p);
bignum* bignum_digit_to_bignum(bignum_digit_type digit, int negative_p); bignum* bignum_digit_to_bignum(bignum_digit_type digit, int negative_p);
bignum* allot_bignum(bignum_length_type length, int negative_p); bignum* allot_bignum(bignum_length_type length, int negative_p);
bignum* allot_bignum_zeroed(bignum_length_type length, int negative_p); bignum* allot_bignum_zeroed(bignum_length_type length, int negative_p);
bignum* bignum_shorten_length(bignum* bignum, bignum_length_type length); bignum* bignum_shorten_length(bignum* bn, bignum_length_type length);
bignum* bignum_trim(bignum* bignum); bignum* bignum_trim(bignum* bn);
bignum* bignum_new_sign(bignum* x, int negative_p); bignum* bignum_new_sign(bignum* x, int negative_p);
bignum* bignum_maybe_new_sign(bignum* x, int negative_p); bignum* bignum_maybe_new_sign(bignum* x, int negative_p);
void bignum_destructive_copy(bignum* source, bignum* target); void bignum_destructive_copy(bignum* source, bignum* target);
@ -303,7 +303,7 @@ struct factor_vm {
void bignum_negate_magnitude(bignum* arg); void bignum_negate_magnitude(bignum* arg);
bignum* bignum_integer_length(bignum* x); bignum* bignum_integer_length(bignum* x);
int bignum_logbitp(int shift, bignum* arg); int bignum_logbitp(int shift, bignum* arg);
int bignum_unsigned_logbitp(int shift, bignum* bignum); int bignum_unsigned_logbitp(int shift, bignum* bn);
bignum* bignum_gcd(bignum* a, bignum* b); bignum* bignum_gcd(bignum* a, bignum* b);
//data heap //data heap