Cleanups: int -> intptr_t for "array" lengths, memory sizes.

runtime/vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
@@ skipping 19 matching lines @@
   // Count number of needed Digits.
   intptr_t digit_count = 0;
   intptr_t count_value = value;
   while (count_value > 0) {
     digit_count++;
     count_value >>= kDigitBitSize;
   }
 
   // Allocate a bigint of the correct size and copy the bits.
   const Bigint& result = Bigint::Handle(Bigint::Allocate(digit_count, space));
-  for (int i = 0; i < digit_count; i++) {
+  for (intptr_t i = 0; i < digit_count; i++) {
     result.SetChunkAt(i, static_cast<Chunk>(value & kDigitMask));
     value >>= kDigitBitSize;
   }
   result.SetSign(is_negative);
   ASSERT(IsClamped(result));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::NewFromInt64(int64_t value, Heap::Space space) {
@@ skipping 18 matching lines @@
   // Count number of needed Digits.
   intptr_t digit_count = 0;
   uint64_t count_value = value;
   while (count_value > 0) {
     digit_count++;
     count_value >>= kDigitBitSize;
   }
 
   // Allocate a bigint of the correct size and copy the bits.
   const Bigint& result = Bigint::Handle(Bigint::Allocate(digit_count, space));
-  for (int i = 0; i < digit_count; i++) {
+  for (intptr_t i = 0; i < digit_count; i++) {
     result.SetChunkAt(i, static_cast<Chunk>(value & kDigitMask));
     value >>= kDigitBitSize;
   }
   result.SetSign(false);
   ASSERT(IsClamped(result));
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::NewFromCString(const char* str,
@@ skipping 77 matching lines @@
 
   const intptr_t str_length = strlen(str);
   if (str_length < 0) {
     FATAL("Fatal error in BigintOperations::FromDecimalCString: "
           "string too long");
   }
   intptr_t str_pos = 0;
 
   // Read first digit separately. This avoids a multiplication and addition.
   // The first digit might also not have kDigitsPerIteration decimal digits.
-  int first_digit_decimal_digits = str_length % kDigitsPerIteration;
+  intptr_t first_digit_decimal_digits = str_length % kDigitsPerIteration;
   Chunk digit = 0;
   for (intptr_t i = 0; i < first_digit_decimal_digits; i++) {
     char c = str[str_pos++];
     ASSERT(('0' <= c) && (c <= '9'));
     digit = digit * 10 + c - '0';
   }
   Bigint& result = Bigint::Handle(Bigint::Allocate(1));
   result.SetChunkAt(0, digit);
   Clamp(result);  // Multiplication requires the inputs to be clamped.
 
@@ skipping 31 matching lines @@
     return NewFromSmi(zero, space);
   }
   DoubleInternals internals = DoubleInternals(d);
   if (internals.IsSpecial()) {
     const Array& exception_arguments = Array::Handle(Array::New(1));
     exception_arguments.SetAt(
         0, Object::Handle(String::New("BigintOperations::NewFromDouble")));
     Exceptions::ThrowByType(Exceptions::kInternalError, exception_arguments);
   }
   uint64_t significand = internals.Significand();
-  int exponent = internals.Exponent();
-  int sign = internals.Sign();
+  intptr_t exponent = internals.Exponent();
+  intptr_t sign = internals.Sign();
   if (exponent <= 0) {
     significand >>= -exponent;
     exponent = 0;
   } else if (exponent <= 10) {
     // A double significand has at most 53 bits. The following shift will
     // hence not overflow, and yield an integer of at most 63 bits.
     significand <<= exponent;
     exponent = 0;
   }
   // A significand has at most 63 bits (after the shift above).
@@ skipping 36 matching lines @@
     ASSERT(result != NULL);
     memmove(result, zero, kLength);
     result[kLength] = '\0';
     return result;
   }
   ASSERT(chunk_data != NULL);
 
   // Compute the number of hex-digits that are needed to represent the
   // leading bigint-digit. All other digits need exactly kHexCharsPerDigit
   // characters.
-  int leading_hex_digits = 0;
+  intptr_t leading_hex_digits = 0;
   Chunk leading_digit = chunk_data[chunk_length - 1];
   while (leading_digit != 0) {
     leading_hex_digits++;
     leading_digit >>= 4;
   }
   // Sum up the space that is needed for the string-representation.
   intptr_t required_size = 0;
   if (is_negative) {
     required_size++;  // For the leading "-".
   }
   required_size += 2;  // For the "0x".
   required_size += leading_hex_digits;
   required_size += (chunk_length - 1) * kHexCharsPerDigit;
   required_size++;  // For the trailing '\0'.
   char* result = reinterpret_cast<char*>(allocator(required_size));
   // Print the number into the string.
   // Start from the last position.
   intptr_t pos = required_size - 1;
   result[pos--] = '\0';
   for (intptr_t i = 0; i < (chunk_length - 1); i++) {
     // Print all non-leading characters (which are printed with
     // kHexCharsPerDigit characters.
     Chunk digit = chunk_data[i];
-    for (int j = 0; j < kHexCharsPerDigit; j++) {
+    for (intptr_t j = 0; j < kHexCharsPerDigit; j++) {
       result[pos--] = Utils::IntToHexDigit(static_cast<int>(digit & 0xF));
       digit >>= 4;
     }
   }
   // Print the leading digit.
   leading_digit = chunk_data[chunk_length - 1];
   while (leading_digit != 0) {
     result[pos--] = Utils::IntToHexDigit(static_cast<int>(leading_digit & 0xF));
     leading_digit >>= 4;
   }
@@ skipping 48 matching lines @@
   // Add one byte for the trailing \0 character.
   int64_t required_size = decimal_length + 1;
   if (bigint.IsNegative()) {
     required_size++;
   }
   ASSERT(required_size == static_cast<intptr_t>(required_size));
   // We will fill the result in the inverse order and then exchange at the end.
   char* result =
       reinterpret_cast<char*>(allocator(static_cast<intptr_t>(required_size)));
   ASSERT(result != NULL);
-  int result_pos = 0;
+  intptr_t result_pos = 0;
 
   // We divide the input into pieces of ~27 bits which can be efficiently
   // handled.
   const intptr_t kChunkDivisor = 100000000;
   const int kChunkDigits = 8;
   ASSERT(pow(10.0, kChunkDigits) == kChunkDivisor);
   ASSERT(static_cast<Chunk>(kChunkDivisor) < kDigitMaxValue);
   ASSERT(Smi::IsValid(kChunkDivisor));
   const Chunk divisor = static_cast<Chunk>(kChunkDivisor);
 
@@ skipping 46 matching lines @@
   uintptr_t limit;
   if (bigint.IsNegative()) {
     limit = static_cast<uintptr_t>(-Smi::kMinValue);
   } else {
     limit = static_cast<uintptr_t>(Smi::kMaxValue);
   }
   bool bigint_is_greater = false;
   // Consume the least-significant digits of the bigint.
   // If bigint_is_greater is set, then the processed sub-part of the bigint is
   // greater than the corresponding part of the limit.
-  for (int i = 0; i < bigint_length - 1; i++) {
+  for (intptr_t i = 0; i < bigint_length - 1; i++) {
     Chunk limit_digit = static_cast<Chunk>(limit & kDigitMask);
     Chunk bigint_digit = bigint.GetChunkAt(i);
     if (limit_digit < bigint_digit) {
       bigint_is_greater = true;
     } else if (limit_digit > bigint_digit) {
       bigint_is_greater = false;
     }  // else don't change the boolean.
     limit >>= kDigitBitSize;
 
     // Bail out if the bigint is definitely too big.
     if (limit == 0) {
       return false;
     }
   }
   Chunk most_significant_digit = bigint.GetChunkAt(bigint_length - 1);
   if (limit > most_significant_digit) {
     return true;
   }
   if (limit < most_significant_digit) {
     return false;
   }
   return !bigint_is_greater;
 }
 
 
 RawSmi* BigintOperations::ToSmi(const Bigint& bigint) {
   ASSERT(FitsIntoSmi(bigint));
   intptr_t value = 0;
-  for (int i = bigint.Length() - 1; i >= 0; i--) {
+  for (intptr_t i = bigint.Length() - 1; i >= 0; i--) {
     value <<= kDigitBitSize;
     value += static_cast<intptr_t>(bigint.GetChunkAt(i));
   }
   if (bigint.IsNegative()) {
     value = -value;
   }
   return Smi::New(value);
 }
 
 
@@ skipping 149 matching lines @@
   uint64_t limit;
   if (bigint.IsNegative()) {
     limit = static_cast<uint64_t>(Mint::kMinValue);
   } else {
     limit = static_cast<uint64_t>(Mint::kMaxValue);
   }
   bool bigint_is_greater = false;
   // Consume the least-significant digits of the bigint.
   // If bigint_is_greater is set, then the processed sub-part of the bigint is
   // greater than the corresponding part of the limit.
-  for (int i = 0; i < bigint_length - 1; i++) {
+  for (intptr_t i = 0; i < bigint_length - 1; i++) {
     Chunk limit_digit = static_cast<Chunk>(limit & kDigitMask);
     Chunk bigint_digit = bigint.GetChunkAt(i);
     if (limit_digit < bigint_digit) {
       bigint_is_greater = true;
     } else if (limit_digit > bigint_digit) {
       bigint_is_greater = false;
     }  // else don't change the boolean.
     limit >>= kDigitBitSize;
 
     // Bail out if the bigint is definitely too big.
     if (limit == 0) {
       return false;
     }
   }
   Chunk most_significant_digit = bigint.GetChunkAt(bigint_length - 1);
   if (limit > most_significant_digit) {
     return true;
   }
   if (limit < most_significant_digit) {
     return false;
   }
   return !bigint_is_greater;
 }
 
 
 uint64_t BigintOperations::AbsToUint64(const Bigint& bigint) {
   ASSERT(AbsFitsIntoUint64(bigint));
   uint64_t value = 0;
-  for (int i = bigint.Length() - 1; i >= 0; i--) {
+  for (intptr_t i = bigint.Length() - 1; i >= 0; i--) {
     value <<= kDigitBitSize;
     value += static_cast<intptr_t>(bigint.GetChunkAt(i));
   }
   return value;
 }
 
 
 int64_t BigintOperations::ToInt64(const Bigint& bigint) {
   if (bigint.IsZero()) {
     return 0;
   }
   ASSERT(FitsIntoInt64(bigint));
   int64_t value = AbsToUint64(bigint);
   if (bigint.IsNegative()) {
     value = -value;
   }
   return value;
 }
 
 
 bool BigintOperations::AbsFitsIntoUint64(const Bigint& bigint) {
   intptr_t b_length = bigint.Length();
-  int num_bits = CountBits(bigint.GetChunkAt(b_length - 1));
+  intptr_t num_bits = CountBits(bigint.GetChunkAt(b_length - 1));
   num_bits += (kDigitBitSize * (b_length - 1));
   if (num_bits > 64) return false;
   return true;
 }
 
 
 bool BigintOperations::FitsIntoUint64(const Bigint& bigint) {
   if (bigint.IsNegative()) return false;
   return AbsFitsIntoUint64(bigint);
 }
@@ skipping 1079 matching lines @@
   intptr_t bigint_length = bigint.Length();
   Bigint& copy = Bigint::Handle(Bigint::Allocate(bigint_length));
   for (intptr_t i = 0; i < bigint_length; i++) {
     copy.SetChunkAt(i, bigint.GetChunkAt(i));
   }
   copy.SetSign(bigint.IsNegative());
   return copy.raw();
 }
 
 
-int BigintOperations::CountBits(Chunk digit) {
-  int result = 0;
+intptr_t BigintOperations::CountBits(Chunk digit) {
+  intptr_t result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart