Remove the static qualifier from functions in header files.

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 28 matching lines @@
 
 #include "conversions.h"
 #include "double.h"
 #include "platform.h"
 #include "scanner.h"
 #include "strtod.h"
 
 namespace v8 {
 namespace internal {
 
-static inline double JunkStringValue() {
+inline double JunkStringValue() {
   return BitCast<double, uint64_t>(kQuietNaNMask);
 }
 
 
 // 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) {
+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
   // double, and reading them from there.
   const double k2Pow52 = 4503599627370496.0;
   bool negative = x < 0;
   if (negative) {
     x = -x;
   }
   if (x < k2Pow52) {
     x += k2Pow52;
     uint32_t result;
     Address mantissa_ptr = reinterpret_cast<Address>(&x);
     // Copy least significant 32 bits of mantissa.
     memcpy(&result, mantissa_ptr, sizeof(result));
     return negative ? ~result + 1 : result;
   }
   // Large number (outside uint32 range), Infinity or NaN.
   return 0x80000000u;  // Return integer indefinite.
 }
 
 
-static inline double DoubleToInteger(double x) {
+inline double DoubleToInteger(double x) {
   if (isnan(x)) return 0;
   if (!isfinite(x) || x == 0) return x;
   return (x >= 0) ? floor(x) : ceil(x);
 }
 
 
 int32_t DoubleToInt32(double x) {
   int32_t i = FastD2I(x);
   if (FastI2D(i) == x) return i;
   Double d(x);
   int exponent = d.Exponent();
   if (exponent < 0) {
     if (exponent <= -Double::kSignificandSize) return 0;
     return d.Sign() * static_cast<int32_t>(d.Significand() >> -exponent);
   } else {
     if (exponent > 31) return 0;
     return d.Sign() * static_cast<int32_t>(d.Significand() << exponent);
   }
 }
 
 
 template <class Iterator, class EndMark>
-static bool SubStringEquals(Iterator* current,
+bool SubStringEquals(Iterator* current,
                             EndMark end,

[Erik Corry, 2011/11/29 09:34:56]

Indentation.

[Kevin Millikin (Chromium), 2011/11/29 10:10:34]

Thanks.

                             const char* substring) {
   ASSERT(**current == *substring);
   for (substring++; *substring != '\0'; substring++) {
     ++*current;
     if (*current == end || **current != *substring) return false;
   }
   ++*current;
   return true;
 }
 
 
 // Returns true if a nonspace character has been found and false if the
 // end was been reached before finding a nonspace character.
 template <class Iterator, class EndMark>
-static inline bool AdvanceToNonspace(UnicodeCache* unicode_cache,
+inline bool AdvanceToNonspace(UnicodeCache* unicode_cache,

[Erik Corry, 2011/11/29 09:34:56]

Indentation

                                      Iterator* current,
                                      EndMark end) {
   while (*current != end) {
     if (!unicode_cache->IsWhiteSpace(**current)) return true;
     ++*current;
   }
   return false;
 }
 
 
 // Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
 template <int radix_log_2, class Iterator, class EndMark>
-static double InternalStringToIntDouble(UnicodeCache* unicode_cache,
-                                        Iterator current,
-                                        EndMark end,
-                                        bool negative,
-                                        bool allow_trailing_junk) {
+double InternalStringToIntDouble(UnicodeCache* unicode_cache,
+                                 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;
@@ skipping 78 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(UnicodeCache* unicode_cache,
-                                  Iterator current,
-                                  EndMark end,
-                                  int radix) {
+double InternalStringToInt(UnicodeCache* unicode_cache,
+                           Iterator current,
+                           EndMark end,
+                           int radix) {
   const bool allow_trailing_junk = true;
   const double empty_string_val = JunkStringValue();
 
   if (!AdvanceToNonspace(unicode_cache, &current, end)) {
     return empty_string_val;
   }
 
   bool negative = false;
   bool leading_zero = false;
 
@@ skipping 171 matching lines @@
   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(UnicodeCache* unicode_cache,
-                                     Iterator current,
-                                     EndMark end,
-                                     int flags,
-                                     double empty_string_val) {
+double InternalStringToDouble(UnicodeCache* unicode_cache,
+                              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(unicode_cache, &current, end)) {
     return empty_string_val;
@@ skipping 213 matching lines @@
   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_