From 8ac3b8017385a070ac21b0e4df8381aa479026fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Lindqvist?= Date: Thu, 12 Jun 2014 18:13:18 +0200 Subject: [PATCH] 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. --- vm/bignum.cpp | 76 +++++++++++++++++++++++++-------------------------- vm/vm.hpp | 24 ++++++++-------- 2 files changed, 50 insertions(+), 50 deletions(-) diff --git a/vm/bignum.cpp b/vm/bignum.cpp index a36ab96b84..d352fa1f98 100644 --- a/vm/bignum.cpp +++ b/vm/bignum.cpp @@ -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_in), false_object); + general_error(ERROR_OUT_OF_FIXNUM_RANGE, tag(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; diff --git a/vm/vm.hpp b/vm/vm.hpp index 6bf51c40e9..ce2c7913cb 100644 --- a/vm/vm.hpp +++ b/vm/vm.hpp @@ -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