Reduce the number of global constructor calls by changing a constant to a

src/conversions-inl.h

 // Copyright 2011 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 25 matching lines @@
 // ----------------------------------------------------------------------------
 // Extra POSIX/ANSI functions for Win32/MSVC.
 
 #include "conversions.h"
 #include "strtod.h"
 #include "platform.h"
 
 namespace v8 {
 namespace internal {
 
+static inline double JunkStringValue() {
+  return std::numeric_limits<double>::quiet_NaN();
+}
+
+
 // The fast double-to-unsigned-int conversion routine does not guarantee
 // rounding towards zero, or any reasonable value if the argument is larger
 // than what fits in an unsigned 32-bit integer.
 static inline unsigned int FastD2UI(double x) {
   // There is no unsigned version of lrint, so there is no fast path
   // in this function as there is in FastD2I. Using lrint doesn't work
   // for values of 2^31 and above.
 
   // Convert "small enough" doubles to uint32_t by fixing the 32
   // least significant non-fractional bits in the low 32 bits of the
@@ skipping 88 matching lines @@
       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(unicode_cache, &current, end)) {
         break;
       } else {
-        return JUNK_STRING_VALUE;
+        return JunkStringValue();
       }
     }
 
     number = number * radix + digit;
     int overflow = static_cast<int>(number >> 53);
     if (overflow != 0) {
       // Overflow occurred. Need to determine which direction to round the
       // result.
       int overflow_bits_count = 1;
       while (overflow > 1) {
         overflow_bits_count++;
         overflow >>= 1;
       }
 
       int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
       int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
       number >>= overflow_bits_count;
       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(unicode_cache, &current, end)) {
-        return JUNK_STRING_VALUE;
+        return JunkStringValue();
       }
 
       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) {
           number++;  // Rounding up.
@@ skipping 27 matching lines @@
   return static_cast<double>(negative ? -number : number) * pow(2.0, exponent);
 }
 
 
 template <class Iterator, class EndMark>
 static double InternalStringToInt(UnicodeCache* unicode_cache,
                                   Iterator current,
                                   EndMark end,
                                   int radix) {
   const bool allow_trailing_junk = true;
-  const double empty_string_val = JUNK_STRING_VALUE;
+  const double empty_string_val = JunkStringValue();
 
   if (!AdvanceToNonspace(unicode_cache, &current, end)) {
     return empty_string_val;
   }
 
   bool negative = false;
   bool leading_zero = false;
 
   if (*current == '+') {
     // Ignore leading sign; skip following spaces.
     ++current;
     if (current == end) {
-      return JUNK_STRING_VALUE;
+      return JunkStringValue();
     }
   } else if (*current == '-') {
     ++current;
     if (current == end) {
-      return JUNK_STRING_VALUE;
+      return JunkStringValue();
     }
     negative = true;
   }
 
   if (radix == 0) {
     // Radix detection.
     if (*current == '0') {
       ++current;
       if (current == end) return SignedZero(negative);
       if (*current == 'x' || *current == 'X') {
         radix = 16;
         ++current;
-        if (current == end) return JUNK_STRING_VALUE;
+        if (current == end) return JunkStringValue();
       } else {
         radix = 8;
         leading_zero = true;
       }
     } else {
       radix = 10;
     }
   } else if (radix == 16) {
     if (*current == '0') {
       // Allow "0x" prefix.
       ++current;
       if (current == end) return SignedZero(negative);
       if (*current == 'x' || *current == 'X') {
         ++current;
-        if (current == end) return JUNK_STRING_VALUE;
+        if (current == end) return JunkStringValue();
       } else {
         leading_zero = true;
       }
     }
   }
 
-  if (radix < 2 || radix > 36) return JUNK_STRING_VALUE;
+  if (radix < 2 || radix > 36) return JunkStringValue();
 
   // Skip leading zeros.
   while (*current == '0') {
     leading_zero = true;
     ++current;
     if (current == end) return SignedZero(negative);
   }
 
   if (!leading_zero && !isDigit(*current, radix)) {
-    return JUNK_STRING_VALUE;
+    return JunkStringValue();
   }
 
   if (IsPowerOf2(radix)) {
     switch (radix) {
       case 2:
         return InternalStringToIntDouble<1>(
             unicode_cache, current, end, negative, allow_trailing_junk);
       case 4:
         return InternalStringToIntDouble<2>(
             unicode_cache, current, end, negative, allow_trailing_junk);
@@ skipping 27 matching lines @@
         // as infinity.
         ASSERT(buffer_pos < kBufferSize);
         buffer[buffer_pos++] = static_cast<char>(*current);
       }
       ++current;
       if (current == end) break;
     }
 
     if (!allow_trailing_junk &&
         AdvanceToNonspace(unicode_cache, &current, end)) {
-      return JUNK_STRING_VALUE;
+      return JunkStringValue();
     }
 
     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
   // than ~2^56. It's explicitly allowed in the spec: "if R is not 2, 4, 8, 10,
@@ skipping 45 matching lines @@
         break;
       }
     }
 
     // Update the value and skip the part in the string.
     v = v * multiplier + part;
   } while (!done);
 
   if (!allow_trailing_junk &&
       AdvanceToNonspace(unicode_cache, &current, end)) {
-    return JUNK_STRING_VALUE;
+    return JunkStringValue();
   }
 
   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.
@@ skipping 29 matching lines @@
   int significant_digits = 0;
   int insignificant_digits = 0;
   bool nonzero_digit_dropped = false;
   bool fractional_part = false;
 
   bool negative = false;
 
   if (*current == '+') {
     // Ignore leading sign.
     ++current;
-    if (current == end) return JUNK_STRING_VALUE;
+    if (current == end) return JunkStringValue();
   } else if (*current == '-') {
     ++current;
-    if (current == end) return JUNK_STRING_VALUE;
+    if (current == end) return JunkStringValue();
     negative = true;
   }
 
   static const char kInfinitySymbol[] = "Infinity";
   if (*current == kInfinitySymbol[0]) {
     if (!SubStringEquals(&current, end, kInfinitySymbol)) {
-      return JUNK_STRING_VALUE;
+      return JunkStringValue();
     }
 
     if (!allow_trailing_junk &&
         AdvanceToNonspace(unicode_cache, &current, end)) {
-      return JUNK_STRING_VALUE;
+      return JunkStringValue();
     }
 
     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 JunkStringValue();  // "0x".
       }
 
       return InternalStringToIntDouble<4>(unicode_cache,
                                           current,
                                           end,
                                           negative,
                                           allow_trailing_junk);
     }
 
     // Ignore leading zeros in the integer part.
@@ skipping 19 matching lines @@
     octal = octal && *current < '8';
     ++current;
     if (current == end) goto parsing_done;
   }
 
   if (significant_digits == 0) {
     octal = false;
   }
 
   if (*current == '.') {
-    if (octal && !allow_trailing_junk) return JUNK_STRING_VALUE;
+    if (octal && !allow_trailing_junk) return JunkStringValue();
     if (octal) goto parsing_done;
 
     ++current;
     if (current == end) {
       if (significant_digits == 0 && !leading_zero) {
-        return JUNK_STRING_VALUE;
+        return JunkStringValue();
       } else {
         goto parsing_done;
       }
     }
 
     if (significant_digits == 0) {
       // octal = false;
       // Integer part consists of 0 or is absent. Significant digits start after
       // leading zeros (if any).
       while (*current == '0') {
@@ skipping 20 matching lines @@
       ++current;
       if (current == end) goto parsing_done;
     }
   }
 
   if (!leading_zero && exponent == 0 && significant_digits == 0) {
     // If leading_zeros is true then the string contains zeros.
     // If exponent < 0 then string was [+-]\.0*...
     // If significant_digits != 0 the string is not equal to 0.
     // Otherwise there are no digits in the string.
-    return JUNK_STRING_VALUE;
+    return JunkStringValue();
   }
 
   // Parse exponential part.
   if (*current == 'e' || *current == 'E') {
-    if (octal) return JUNK_STRING_VALUE;
+    if (octal) return JunkStringValue();
     ++current;
     if (current == end) {
       if (allow_trailing_junk) {
         goto parsing_done;
       } else {
-        return JUNK_STRING_VALUE;
+        return JunkStringValue();
       }
     }
     char sign = '+';
     if (*current == '+' || *current == '-') {
       sign = static_cast<char>(*current);
       ++current;
       if (current == end) {
         if (allow_trailing_junk) {
           goto parsing_done;
         } else {
-          return JUNK_STRING_VALUE;
+          return JunkStringValue();
         }
       }
     }
 
     if (current == end || *current < '0' || *current > '9') {
       if (allow_trailing_junk) {
         goto parsing_done;
       } else {
-        return JUNK_STRING_VALUE;
+        return JunkStringValue();
       }
     }
 
     const int max_exponent = INT_MAX / 2;
     ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
     int num = 0;
     do {
       // Check overflow.
       int digit = *current - '0';
       if (num >= max_exponent / 10
           && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
         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(unicode_cache, &current, end)) {
-    return JUNK_STRING_VALUE;
+    return JunkStringValue();
   }
 
   parsing_done:
   exponent += insignificant_digits;
 
   if (octal) {
     return InternalStringToIntDouble<3>(unicode_cache,
                                         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;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_CONVERSIONS_INL_H_