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 */
/* bignum_to_cell, fixnum_to_cell, long_long_to_cell, ulong_long_to_cell */
#define BIGNUM_TO_FOO(name, type, stype, utype) \
type factor_vm::bignum_to_##name(bignum * bignum) { \
if (BIGNUM_ZERO_P(bignum)) \
type factor_vm::bignum_to_##name(bignum* bn) { \
if (BIGNUM_ZERO_P(bn)) \
return (0); \
{ \
utype accumulator = 0; \
bignum_digit_type* start = (BIGNUM_START_PTR(bignum)); \
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bignum))); \
bignum_digit_type* start = (BIGNUM_START_PTR(bn)); \
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bn))); \
while (start < scan) \
accumulator = ((accumulator << BIGNUM_DIGIT_LENGTH) + (*--scan)); \
return ((BIGNUM_NEGATIVE_P(bignum)) ? ((type)(-(stype) accumulator)) \
: accumulator); \
return ((BIGNUM_NEGATIVE_P(bn)) ? ((type)(-(stype) 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)
/* cannot allocate memory */
fixnum factor_vm::bignum_to_fixnum_strict(bignum* bignum_in) {
fixnum len = BIGNUM_LENGTH(bignum_in);
bignum_digit_type *digits = BIGNUM_START_PTR(bignum_in);
fixnum factor_vm::bignum_to_fixnum_strict(bignum* bn) {
fixnum len = BIGNUM_LENGTH(bn);
bignum_digit_type *digits = BIGNUM_START_PTR(bn);
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);
return fix;
}
@ -682,8 +682,8 @@ bignum* factor_vm::bignum_multiply_unsigned_small_factor(bignum* x,
return (bignum_trim(p));
}
void factor_vm::bignum_destructive_add(bignum* bignum, bignum_digit_type n) {
bignum_digit_type* scan = (BIGNUM_START_PTR(bignum));
void factor_vm::bignum_destructive_add(bignum* bn, bignum_digit_type n) {
bignum_digit_type* scan = (BIGNUM_START_PTR(bn));
bignum_digit_type digit;
digit = ((*scan) + n);
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 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 product_low;
#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));
while (scan < end) {
two_digits = (*scan);
@ -999,10 +999,10 @@ void factor_vm::bignum_destructive_normalization(bignum* source, bignum* target,
return;
}
void factor_vm::bignum_destructive_unnormalization(bignum* bignum,
void factor_vm::bignum_destructive_unnormalization(bignum* bn,
int shift_right) {
bignum_digit_type* start = (BIGNUM_START_PTR(bignum));
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bignum)));
bignum_digit_type* start = (BIGNUM_START_PTR(bn));
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bn)));
bignum_digit_type digit;
bignum_digit_type carry = 0;
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. */
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 remainder = 0;
bignum_digit_type two_digits;
#define quotient_high remainder
bignum_digit_type* start = (BIGNUM_START_PTR(bignum));
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bignum)));
bignum_digit_type* start = (BIGNUM_START_PTR(bn));
bignum_digit_type* scan = (start + (BIGNUM_LENGTH(bn)));
BIGNUM_ASSERT((denominator > 1) && (denominator < BIGNUM_RADIX_ROOT));
while (start < scan) {
two_digits = (*--scan);
@ -1234,33 +1234,33 @@ bignum* factor_vm::allot_bignum_zeroed(bignum_length_type length,
source = reallot_array(source, length + 1)
/* 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 current_length = (BIGNUM_LENGTH(bignum));
bignum_length_type current_length = (BIGNUM_LENGTH(bn));
BIGNUM_ASSERT((length >= 0) || (length <= current_length));
if (length < current_length) {
GC_BIGNUM(bignum);
BIGNUM_REDUCE_LENGTH(bignum, length);
BIGNUM_SET_NEGATIVE_P(bignum, (length != 0) && (BIGNUM_NEGATIVE_P(bignum)));
GC_BIGNUM(bn);
BIGNUM_REDUCE_LENGTH(bn, length);
BIGNUM_SET_NEGATIVE_P(bn, (length != 0) && (BIGNUM_NEGATIVE_P(bn)));
}
return (bignum);
return (bn);
}
/* Allocates memory */
bignum* factor_vm::bignum_trim(bignum* bignum) {
bignum_digit_type* start = (BIGNUM_START_PTR(bignum));
bignum_digit_type* end = (start + (BIGNUM_LENGTH(bignum)));
bignum* factor_vm::bignum_trim(bignum* bn) {
bignum_digit_type* start = (BIGNUM_START_PTR(bn));
bignum_digit_type* end = (start + (BIGNUM_LENGTH(bn)));
bignum_digit_type* scan = end;
while ((start <= scan) && ((*--scan) == 0))
;
scan += 1;
if (scan < end) {
GC_BIGNUM(bignum);
GC_BIGNUM(bn);
bignum_length_type length = (scan - start);
BIGNUM_REDUCE_LENGTH(bignum, length);
BIGNUM_SET_NEGATIVE_P(bignum, (length != 0) && (BIGNUM_NEGATIVE_P(bignum)));
BIGNUM_REDUCE_LENGTH(bn, length);
BIGNUM_SET_NEGATIVE_P(bn, (length != 0) && (BIGNUM_NEGATIVE_P(bn)));
}
return (bignum);
return (bn);
}
/* Copying */
@ -1668,12 +1668,12 @@ int factor_vm::bignum_logbitp(int shift, bignum* arg) {
: bignum_unsigned_logbitp(shift, arg));
}
int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bignum) {
bignum_length_type len = (BIGNUM_LENGTH(bignum));
int factor_vm::bignum_unsigned_logbitp(int shift, bignum* bn) {
bignum_length_type len = (BIGNUM_LENGTH(bn));
int index = shift / BIGNUM_DIGIT_LENGTH;
if (index >= len)
return 0;
bignum_digit_type digit = (BIGNUM_REF(bignum, index));
bignum_digit_type digit = (BIGNUM_REF(bn, index));
int p = shift % BIGNUM_DIGIT_LENGTH;
bignum_digit_type mask = ((fixnum)1) << p;
return (digit & mask) ? 1 : 0;

24
vm/vm.hpp
View File

@ -239,11 +239,11 @@ struct factor_vm {
bignum** remainder);
bignum* bignum_quotient(bignum* numerator, bignum* denominator);
bignum* bignum_remainder(bignum* numerator, bignum* denominator);
cell bignum_to_cell(bignum* bignum);
fixnum bignum_to_fixnum_strict(bignum* bignum);
fixnum bignum_to_fixnum(bignum* bignum);
int64_t bignum_to_long_long(bignum* bignum);
uint64_t bignum_to_ulong_long(bignum* bignum);
cell bignum_to_cell(bignum* bn);
fixnum bignum_to_fixnum_strict(bignum* bn);
fixnum bignum_to_fixnum(bignum* bn);
int64_t bignum_to_long_long(bignum* bn);
uint64_t bignum_to_ulong_long(bignum* bn);
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);
@ -252,8 +252,8 @@ struct factor_vm {
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_destructive_add(bignum* bn, bignum_digit_type n);
void bignum_destructive_scale_up(bignum* bn, 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);
@ -267,7 +267,7 @@ struct factor_vm {
bignum** remainder, int q_negative_p, int r_negative_p);
void bignum_destructive_normalization(bignum* source, bignum* target,
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 uh, bignum_digit_type ul, bignum_digit_type v,
bignum_digit_type* q) /* return value */;
@ -279,15 +279,15 @@ struct factor_vm {
bignum* numerator, bignum_digit_type denominator, bignum** quotient,
bignum** remainder, int q_negative_p, int r_negative_p);
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_digit_type d,
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_zeroed(bignum_length_type length, int negative_p);
bignum* bignum_shorten_length(bignum* bignum, bignum_length_type length);
bignum* bignum_trim(bignum* bignum);
bignum* bignum_shorten_length(bignum* bn, bignum_length_type length);
bignum* bignum_trim(bignum* bn);
bignum* bignum_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);
@ -303,7 +303,7 @@ struct factor_vm {
void bignum_negate_magnitude(bignum* arg);
bignum* bignum_integer_length(bignum* x);
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);
//data heap