Fix for issue 2233

vm/bigint_operations.cc

 // Copyright 2012 Google Inc. All Rights Reserved.
 
 #include "vm/bigint_operations.h"
 
 #include "platform/utils.h"
 
 #include "vm/double_internals.h"
 #include "vm/exceptions.h"
 #include "vm/object_store.h"
 #include "vm/zone.h"
@@ skipping 101 matching lines @@
       ((str[1] == 'x') || (str[1] == 'X'))) {
     const Bigint& result = Bigint::Handle(FromHexCString(&str[2], space));
     ASSERT(IsClamped(result));
     return result.raw();
   } else {
     return FromDecimalCString(str);
   }
 }
 
 
+intptr_t BigintOperations::ComputeChunkLength(const char* hex_string) {
+  ASSERT(kDigitBitSize % 4 == 0);
+  intptr_t hex_length = strlen(hex_string);
+  // Round up.
+  intptr_t bigint_length = ((hex_length - 1) / kHexCharsPerDigit) + 1;
+  return bigint_length;
+}
+
+
 RawBigint* BigintOperations::FromHexCString(const char* hex_string,
                                             Heap::Space space) {
   // If the string starts with '-' recursively restart the whole operation
   // without the character and then toggle the sign.
   // This allows multiple leading '-' (which will cancel each other out), but
   // we have added an assert, to make sure that the returned result of the
   // recursive call is not negative.
   // We don't catch leading '-'s for zero. Ex: "--0", or "---".
   if (hex_string[0] == '-') {
     const Bigint& value = Bigint::Handle(FromHexCString(&hex_string[1], space));
     value.ToggleSign();
     ASSERT(value.IsZero() || value.IsNegative());
     ASSERT(IsClamped(value));
     return value.raw();
   }
-
-  ASSERT(kDigitBitSize % 4 == 0);
-  const int kHexCharsPerDigit = kDigitBitSize / 4;
-
-  intptr_t hex_length = strlen(hex_string);
-  // Round up.
-  intptr_t bigint_length = ((hex_length - 1) / kHexCharsPerDigit) + 1;
-  const Bigint& result =
-      Bigint::Handle(Bigint::Allocate(bigint_length, space));
-  // The bigint's least significant digit (lsd) is at position 0, whereas the
-  // given string has it's lsd at the last position.
-  // The hex_i index, pointing into the string, starts therefore at the end,
-  // whereas the bigint-index (i) starts at 0.
-  intptr_t hex_i = hex_length - 1;
-  for (intptr_t i = 0; i < bigint_length; i++) {
-    Chunk digit = 0;
-    int shift = 0;
-    for (int j = 0; j < kHexCharsPerDigit; j++) {
-      // Reads a block of hexadecimal digits and stores it in 'digit'.
-      // Ex: "0123456" with kHexCharsPerDigit == 3, hex_i == 6, reads "456".
-      if (hex_i < 0) {
-        break;
-      }
-      ASSERT(hex_i >= 0);
-      char c = hex_string[hex_i--];
-      ASSERT(Utils::IsHexDigit(c));
-      digit += static_cast<Chunk>(Utils::HexDigitToInt(c)) << shift;
-      shift += 4;
-    }
-    result.SetChunkAt(i, digit);
-  }
-  ASSERT(hex_i == -1);
-  Clamp(result);
+  intptr_t bigint_length = ComputeChunkLength(hex_string);
+  const Bigint& result = Bigint::Handle(Bigint::Allocate(bigint_length, space));
+  FromHexCString(hex_string, result);
   return result.raw();
 }
 
 
 RawBigint* BigintOperations::FromDecimalCString(const char* str,
                                                 Heap::Space space) {
   // Read 8 digits a time. 10^8 < 2^27.
   const int kDigitsPerIteration = 8;
   const Chunk kTenMultiplier = 100000000;
   ASSERT(kDigitBitSize >= 27);
@@ skipping 75 matching lines @@
 }
 
 
 const char* BigintOperations::ToHexCString(intptr_t length,
                                            bool is_negative,
                                            void* data,
                                            uword (*allocator)(intptr_t size)) {
   NoGCScope no_gc;
 
   ASSERT(kDigitBitSize % 4 == 0);
-  const int kHexCharsPerDigit = kDigitBitSize / 4;
 
   intptr_t chunk_length = length;
   Chunk* chunk_data = reinterpret_cast<Chunk*>(data);
   if (length == 0) {
     const char* zero = "0x0";
     const int kLength = strlen(zero);
     char* result = reinterpret_cast<char*>(allocator(kLength + 1));
     ASSERT(result != NULL);
     memmove(result, zero, kLength);
     result[kLength] = '\0';
@@ skipping 858 matching lines @@
     return a_is_negative ? -1 : 1;
   }
 
   if (a_is_negative) {
     return -UnsignedCompare(a, b);
   }
   return UnsignedCompare(a, b);
 }
 
 
+void BigintOperations::FromHexCString(const char* hex_string,
+                                      const Bigint& value) {
+  ASSERT(hex_string[0] != '-');
+  intptr_t bigint_length = ComputeChunkLength(hex_string);
+  // The bigint's least significant digit (lsd) is at position 0, whereas the
+  // given string has it's lsd at the last position.
+  // The hex_i index, pointing into the string, starts therefore at the end,
+  // whereas the bigint-index (i) starts at 0.
+  intptr_t hex_length = strlen(hex_string);
+  intptr_t hex_i = hex_length - 1;
+  for (intptr_t i = 0; i < bigint_length; i++) {
+    Chunk digit = 0;
+    int shift = 0;
+    for (int j = 0; j < kHexCharsPerDigit; j++) {
+      // Reads a block of hexadecimal digits and stores it in 'digit'.
+      // Ex: "0123456" with kHexCharsPerDigit == 3, hex_i == 6, reads "456".
+      if (hex_i < 0) {
+        break;
+      }
+      ASSERT(hex_i >= 0);
+      char c = hex_string[hex_i--];
+      ASSERT(Utils::IsHexDigit(c));
+      digit += static_cast<Chunk>(Utils::HexDigitToInt(c)) << shift;
+      shift += 4;
+    }
+    value.SetChunkAt(i, digit);
+  }
+  ASSERT(hex_i == -1);
+  Clamp(value);
+}
+
+
 RawBigint* BigintOperations::AddSubtract(const Bigint& a,
                                          const Bigint& b,
                                          bool negate_b) {
   ASSERT(IsClamped(a));
   ASSERT(IsClamped(b));
   Bigint& result = Bigint::Handle();
   // We perform the subtraction by simulating a negation of the b-argument.
   bool b_is_negative = negate_b ? !b.IsNegative() : b.IsNegative();
 
   // If both are of the same sign, then we can compute the unsigned addition
@@ skipping 353 matching lines @@
 int BigintOperations::CountBits(Chunk digit) {
   int result = 0;
   while (digit != 0) {
     digit >>= 1;
     result++;
   }
   return result;
 }
 
 }  // namespace dart