Merge isolates to bleeding_edge.

src/conversions.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 91 matching lines @@
 // must be rounded to the bigger one unless the tail consists of zeros, so
 // we don't need to preserve all the digits.
 const int kMaxSignificantDigits = 772;
 
 
 static const double JUNK_STRING_VALUE = OS::nan_value();
 
 
 // Returns true if a nonspace found and false if the end has reached.
 template <class Iterator, class EndMark>
-static inline bool AdvanceToNonspace(Iterator* current, EndMark end) {
+static inline bool AdvanceToNonspace(ScannerConstants* scanner_constants,
+                                     Iterator* current,
+                                     EndMark end) {
   while (*current != end) {
-    if (!ScannerConstants::kIsWhiteSpace.get(**current)) return true;
+    if (!scanner_constants->IsWhiteSpace(**current)) return true;
     ++*current;
   }
   return false;
 }
 
 
 static bool isDigit(int x, int radix) {
   return (x >= '0' && x <= '9' && x < '0' + radix)
       || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
       || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
 }
 
 
 static double SignedZero(bool negative) {
   return negative ? -0.0 : 0.0;
 }
 
 
 // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
 template <int radix_log_2, class Iterator, class EndMark>
-static double InternalStringToIntDouble(Iterator current,
+static double InternalStringToIntDouble(ScannerConstants* scanner_constants,
+                                        Iterator current,
                                         EndMark end,
                                         bool negative,
                                         bool allow_trailing_junk) {
   ASSERT(current != end);
 
   // Skip leading 0s.
   while (*current == '0') {
     ++current;
     if (current == end) return SignedZero(negative);
   }
 
   int64_t number = 0;
   int exponent = 0;
   const int radix = (1 << radix_log_2);
 
   do {
     int digit;
     if (*current >= '0' && *current <= '9' && *current < '0' + radix) {
       digit = static_cast<char>(*current) - '0';
     } else if (radix > 10 && *current >= 'a' && *current < 'a' + radix - 10) {
       digit = static_cast<char>(*current) - 'a' + 10;
     } else if (radix > 10 && *current >= 'A' && *current < 'A' + radix - 10) {
       digit = static_cast<char>(*current) - 'A' + 10;
     } else {
-      if (allow_trailing_junk || !AdvanceToNonspace(&current, end)) {
+      if (allow_trailing_junk ||
+          !AdvanceToNonspace(scanner_constants, &current, end)) {
         break;
       } else {
         return JUNK_STRING_VALUE;
       }
     }
 
     number = number * radix + digit;
     int overflow = static_cast<int>(number >> 53);
     if (overflow != 0) {
       // Overflow occurred. Need to determine which direction to round the
@@ skipping 10 matching lines @@
       exponent = overflow_bits_count;
 
       bool zero_tail = true;
       while (true) {
         ++current;
         if (current == end || !isDigit(*current, radix)) break;
         zero_tail = zero_tail && *current == '0';
         exponent += radix_log_2;
       }
 
-      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+      if (!allow_trailing_junk &&
+          AdvanceToNonspace(scanner_constants, &current, end)) {
         return JUNK_STRING_VALUE;
       }
 
       int middle_value = (1 << (overflow_bits_count - 1));
       if (dropped_bits > middle_value) {
         number++;  // Rounding up.
       } else if (dropped_bits == middle_value) {
         // Rounding to even to consistency with decimals: half-way case rounds
         // up if significant part is odd and down otherwise.
         if ((number & 1) != 0 || !zero_tail) {
@@ skipping 23 matching lines @@
   }
 
   ASSERT(number != 0);
   // The double could be constructed faster from number (mantissa), exponent
   // and sign. Assuming it's a rare case more simple code is used.
   return static_cast<double>(negative ? -number : number) * pow(2.0, exponent);
 }
 
 
 template <class Iterator, class EndMark>
-static double InternalStringToInt(Iterator current, EndMark end, int radix) {
+static double InternalStringToInt(ScannerConstants* scanner_constants,
+                                  Iterator current,
+                                  EndMark end,
+                                  int radix) {
   const bool allow_trailing_junk = true;
   const double empty_string_val = JUNK_STRING_VALUE;
 
-  if (!AdvanceToNonspace(&current, end)) return empty_string_val;
+  if (!AdvanceToNonspace(scanner_constants, &current, end)) {
+    return empty_string_val;
+  }
 
   bool negative = false;
   bool leading_zero = false;
 
   if (*current == '+') {
     // Ignore leading sign; skip following spaces.
     ++current;
-    if (!AdvanceToNonspace(&current, end)) return JUNK_STRING_VALUE;
+    if (!AdvanceToNonspace(scanner_constants, &current, end)) {
+      return JUNK_STRING_VALUE;
+    }
   } else if (*current == '-') {
     ++current;
-    if (!AdvanceToNonspace(&current, end)) return JUNK_STRING_VALUE;
+    if (!AdvanceToNonspace(scanner_constants, &current, end)) {
+      return JUNK_STRING_VALUE;
+    }
     negative = true;
   }
 
   if (radix == 0) {
     // Radix detection.
     if (*current == '0') {
       ++current;
       if (current == end) return SignedZero(negative);
       if (*current == 'x' || *current == 'X') {
         radix = 16;
@@ skipping 30 matching lines @@
   }
 
   if (!leading_zero && !isDigit(*current, radix)) {
     return JUNK_STRING_VALUE;
   }
 
   if (IsPowerOf2(radix)) {
     switch (radix) {
       case 2:
         return InternalStringToIntDouble<1>(
-                   current, end, negative, allow_trailing_junk);
+            scanner_constants, current, end, negative, allow_trailing_junk);
       case 4:
         return InternalStringToIntDouble<2>(
-                   current, end, negative, allow_trailing_junk);
+            scanner_constants, current, end, negative, allow_trailing_junk);
       case 8:
         return InternalStringToIntDouble<3>(
-                   current, end, negative, allow_trailing_junk);
+            scanner_constants, current, end, negative, allow_trailing_junk);
 
       case 16:
         return InternalStringToIntDouble<4>(
-                   current, end, negative, allow_trailing_junk);
+            scanner_constants, current, end, negative, allow_trailing_junk);
 
       case 32:
         return InternalStringToIntDouble<5>(
-                   current, end, negative, allow_trailing_junk);
+            scanner_constants, current, end, negative, allow_trailing_junk);
       default:
         UNREACHABLE();
     }
   }
 
   if (radix == 10) {
     // Parsing with strtod.
     const int kMaxSignificantDigits = 309;  // Doubles are less than 1.8e308.
     // The buffer may contain up to kMaxSignificantDigits + 1 digits and a zero
     // end.
     const int kBufferSize = kMaxSignificantDigits + 2;
     char buffer[kBufferSize];
     int buffer_pos = 0;
     while (*current >= '0' && *current <= '9') {
       if (buffer_pos <= kMaxSignificantDigits) {
         // If the number has more than kMaxSignificantDigits it will be parsed
         // as infinity.
         ASSERT(buffer_pos < kBufferSize);
         buffer[buffer_pos++] = static_cast<char>(*current);
       }
       ++current;
       if (current == end) break;
     }
 
-    if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+    if (!allow_trailing_junk &&
+        AdvanceToNonspace(scanner_constants, &current, end)) {
       return JUNK_STRING_VALUE;
     }
 
     ASSERT(buffer_pos < kBufferSize);
     buffer[buffer_pos] = '\0';
     Vector<const char> buffer_vector(buffer, buffer_pos);
     return negative ? -Strtod(buffer_vector, 0) : Strtod(buffer_vector, 0);
   }
 
   // The following code causes accumulating rounding error for numbers greater
@@ skipping 44 matching lines @@
       if (current == end) {
         done = true;
         break;
       }
     }
 
     // Update the value and skip the part in the string.
     v = v * multiplier + part;
   } while (!done);
 
-  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+  if (!allow_trailing_junk &&
+      AdvanceToNonspace(scanner_constants, &current, end)) {
     return JUNK_STRING_VALUE;
   }
 
   return negative ? -v : v;
 }
 
 
 // Converts a string to a double value. Assumes the Iterator supports
 // the following operations:
 // 1. current == end (other ops are not allowed), current != end.
 // 2. *current - gets the current character in the sequence.
 // 3. ++current (advances the position).
 template <class Iterator, class EndMark>
-static double InternalStringToDouble(Iterator current,
+static double InternalStringToDouble(ScannerConstants* scanner_constants,
+                                     Iterator current,
                                      EndMark end,
                                      int flags,
                                      double empty_string_val) {
   // To make sure that iterator dereferencing is valid the following
   // convention is used:
   // 1. Each '++current' statement is followed by check for equality to 'end'.
   // 2. If AdvanceToNonspace returned false then current == end.
   // 3. If 'current' becomes be equal to 'end' the function returns or goes to
   // 'parsing_done'.
   // 4. 'current' is not dereferenced after the 'parsing_done' label.
   // 5. Code before 'parsing_done' may rely on 'current != end'.
-  if (!AdvanceToNonspace(&current, end)) return empty_string_val;
+  if (!AdvanceToNonspace(scanner_constants, &current, end)) {
+    return empty_string_val;
+  }
 
   const bool allow_trailing_junk = (flags & ALLOW_TRAILING_JUNK) != 0;
 
   // The longest form of simplified number is: "-<significant digits>'.1eXXX\0".
   const int kBufferSize = kMaxSignificantDigits + 10;
   char buffer[kBufferSize];  // NOLINT: size is known at compile time.
   int buffer_pos = 0;
 
   // Exponent will be adjusted if insignificant digits of the integer part
   // or insignificant leading zeros of the fractional part are dropped.
@@ skipping 14 matching lines @@
     if (current == end) return JUNK_STRING_VALUE;
     negative = true;
   }
 
   static const char kInfinitySymbol[] = "Infinity";
   if (*current == kInfinitySymbol[0]) {
     if (!SubStringEquals(&current, end, kInfinitySymbol)) {
       return JUNK_STRING_VALUE;
     }
 
-    if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+    if (!allow_trailing_junk &&
+        AdvanceToNonspace(scanner_constants, &current, end)) {
       return JUNK_STRING_VALUE;
     }
 
     ASSERT(buffer_pos == 0);
     return negative ? -V8_INFINITY : V8_INFINITY;
   }
 
   bool leading_zero = false;
   if (*current == '0') {
     ++current;
     if (current == end) return SignedZero(negative);
 
     leading_zero = true;
 
     // It could be hexadecimal value.
     if ((flags & ALLOW_HEX) && (*current == 'x' || *current == 'X')) {
       ++current;
       if (current == end || !isDigit(*current, 16)) {
         return JUNK_STRING_VALUE;  // "0x".
       }
 
-      return InternalStringToIntDouble<4>(current,
+      return InternalStringToIntDouble<4>(scanner_constants,
+                                          current,
                                           end,
                                           negative,
                                           allow_trailing_junk);
     }
 
     // Ignore leading zeros in the integer part.
     while (*current == '0') {
       ++current;
       if (current == end) return SignedZero(negative);
     }
@@ skipping 115 matching lines @@
         num = max_exponent;
       } else {
         num = num * 10 + digit;
       }
       ++current;
     } while (current != end && *current >= '0' && *current <= '9');
 
     exponent += (sign == '-' ? -num : num);
   }
 
-  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+  if (!allow_trailing_junk &&
+      AdvanceToNonspace(scanner_constants, &current, end)) {
     return JUNK_STRING_VALUE;
   }
 
   parsing_done:
   exponent += insignificant_digits;
 
   if (octal) {
-    return InternalStringToIntDouble<3>(buffer,
+    return InternalStringToIntDouble<3>(scanner_constants,
+                                        buffer,
                                         buffer + buffer_pos,
                                         negative,
                                         allow_trailing_junk);
   }
 
   if (nonzero_digit_dropped) {
     buffer[buffer_pos++] = '1';
     exponent--;
   }
 
   ASSERT(buffer_pos < kBufferSize);
   buffer[buffer_pos] = '\0';
 
   double converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
   return negative ? -converted : converted;
 }
 
 
 double StringToDouble(String* str, int flags, double empty_string_val) {
+  ScannerConstants* scanner_constants =
+      Isolate::Current()->scanner_constants();
   StringShape shape(str);
   if (shape.IsSequentialAscii()) {
     const char* begin = SeqAsciiString::cast(str)->GetChars();
     const char* end = begin + str->length();
-    return InternalStringToDouble(begin, end, flags, empty_string_val);
+    return InternalStringToDouble(scanner_constants, begin, end, flags,
+                                  empty_string_val);
   } else if (shape.IsSequentialTwoByte()) {
     const uc16* begin = SeqTwoByteString::cast(str)->GetChars();
     const uc16* end = begin + str->length();
-    return InternalStringToDouble(begin, end, flags, empty_string_val);
+    return InternalStringToDouble(scanner_constants, begin, end, flags,
+                                  empty_string_val);
   } else {
     StringInputBuffer buffer(str);
-    return InternalStringToDouble(StringInputBufferIterator(&buffer),
+    return InternalStringToDouble(scanner_constants,
+                                  StringInputBufferIterator(&buffer),
                                   StringInputBufferIterator::EndMarker(),
                                   flags,
                                   empty_string_val);
   }
 }
 
 
 double StringToInt(String* str, int radix) {
+  ScannerConstants* scanner_constants =
+      Isolate::Current()->scanner_constants();
   StringShape shape(str);
   if (shape.IsSequentialAscii()) {
     const char* begin = SeqAsciiString::cast(str)->GetChars();
     const char* end = begin + str->length();
-    return InternalStringToInt(begin, end, radix);
+    return InternalStringToInt(scanner_constants, begin, end, radix);
   } else if (shape.IsSequentialTwoByte()) {
     const uc16* begin = SeqTwoByteString::cast(str)->GetChars();
     const uc16* end = begin + str->length();
-    return InternalStringToInt(begin, end, radix);
+    return InternalStringToInt(scanner_constants, begin, end, radix);
   } else {
     StringInputBuffer buffer(str);
-    return InternalStringToInt(StringInputBufferIterator(&buffer),
+    return InternalStringToInt(scanner_constants,
+                               StringInputBufferIterator(&buffer),
                                StringInputBufferIterator::EndMarker(),
                                radix);
   }
 }
 
 
 double StringToDouble(const char* str, int flags, double empty_string_val) {
+  ScannerConstants* scanner_constants =
+      Isolate::Current()->scanner_constants();
   const char* end = str + StrLength(str);
-  return InternalStringToDouble(str, end, flags, empty_string_val);
+  return InternalStringToDouble(scanner_constants, str, end, flags,
+                                empty_string_val);
 }
 
 
 double StringToDouble(Vector<const char> str,
                       int flags,
                       double empty_string_val) {
+  ScannerConstants* scanner_constants =
+      Isolate::Current()->scanner_constants();
   const char* end = str.start() + str.length();
-  return InternalStringToDouble(str.start(), end, flags, empty_string_val);
+  return InternalStringToDouble(scanner_constants, str.start(), end, flags,
+                                empty_string_val);
 }
 
 
 const char* DoubleToCString(double v, Vector<char> buffer) {
   switch (fpclassify(v)) {
     case FP_NAN: return "NaN";
     case FP_INFINITE: return (v < 0.0 ? "-Infinity" : "Infinity");
     case FP_ZERO: return "0";
     default: {
       StringBuilder builder(buffer.start(), buffer.length());
@@ skipping 348 matching lines @@
   if (decimal_pos > 0) result_size++;
   // Allocate result and fill in the parts.
   StringBuilder builder(result_size + 1);
   builder.AddSubstring(integer_buffer + integer_pos + 1, integer_part_size);
   if (decimal_pos > 0) builder.AddCharacter('.');
   builder.AddSubstring(decimal_buffer, decimal_pos);
   return builder.Finalize();
 }
 
 
+static Mutex* dtoa_lock_one = OS::CreateMutex();
+static Mutex* dtoa_lock_zero = OS::CreateMutex();
+
+
 } }  // namespace v8::internal
+
+
+extern "C" {
+void ACQUIRE_DTOA_LOCK(int n) {
+  ASSERT(n == 0 || n == 1);
+  (n == 0 ? v8::internal::dtoa_lock_zero : v8::internal::dtoa_lock_one)->Lock();
+}
+
+
+void FREE_DTOA_LOCK(int n) {
+  ASSERT(n == 0 || n == 1);
+  (n == 0 ? v8::internal::dtoa_lock_zero : v8::internal::dtoa_lock_one)->
+      Unlock();
+}
+}