Optimization for parsing integers of limited length (in digits).

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 359 matching lines @@
   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.
   int exponent = 0;
   int significant_digits = 0;
   int insignificant_digits = 0;
   bool nonzero_digit_dropped = false;
+  bool fractional_part = false;
 
   double signed_zero = 0.0;
 
   if (*current == '+') {
     // Ignore leading sign; skip following spaces.
     ++current;
     if (!AdvanceToNonspace(&current, end)) return JUNK_STRING_VALUE;
   } else if (*current == '-') {
     buffer[buffer_pos++] = '-';
     ++current;
@@ skipping 57 matching lines @@
     octal = octal && *current < '8';
     ++current;
     if (current == end) goto parsing_done;
   }
 
   if (significant_digits == 0) {
     octal = false;
   }
 
   if (*current == '.') {
-    ASSERT(buffer_pos < kBufferSize);
-    buffer[buffer_pos++] = '.';
     ++current;
     if (current == end) {
       if (significant_digits == 0 && !leading_zero) {
         return JUNK_STRING_VALUE;
       } 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') {
         ++current;
         if (current == end) return signed_zero;
         exponent--;  // Move this 0 into the exponent.
       }
     }
 
+    ASSERT(buffer_pos < kBufferSize);
+    buffer[buffer_pos++] = '.';
+    fractional_part = true;
+
     // There is the fractional part.
     while (*current >= '0' && *current <= '9') {
       if (significant_digits < kMaxSignificantDigits) {
         ASSERT(buffer_pos < kBufferSize);
         buffer[buffer_pos++] = static_cast<char>(*current);
         significant_digits++;
       } else {
         // Ignore insignificant digits in the fractional part.
         nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
       }
@@ skipping 84 matching lines @@
       result *= pow(8.0, insignificant_digits);
     }
     return result;
   }
 
   if (nonzero_digit_dropped) {
     if (insignificant_digits) buffer[buffer_pos++] = '.';
     buffer[buffer_pos++] = '1';
   }
 
+  // If the number has no more than kMaxDigitsInInt digits and doesn't have
+  // fractional part it could be parsed faster (without checks for
+  // spaces, overflow, etc.).
+  const int kMaxDigitsInInt = 9 * sizeof(int) / 4;  // NOLINT
+
   if (exponent != 0) {
     ASSERT(buffer_pos < kBufferSize);
     buffer[buffer_pos++] = 'e';
     if (exponent < 0) {
       ASSERT(buffer_pos < kBufferSize);
       buffer[buffer_pos++] = '-';
       exponent = -exponent;
     }
     if (exponent > 999) exponent = 999;  // Result will be Infinity or 0 or -0.
 
     const int exp_digits = 3;
     for (int i = 0; i < exp_digits; i++) {
       buffer[buffer_pos + exp_digits - 1 - i] = '0' + exponent % 10;
       exponent /= 10;
     }
     ASSERT(exponent == 0);
     buffer_pos += exp_digits;
+  } else if (!fractional_part && significant_digits <= kMaxDigitsInInt) {
+    if (significant_digits == 0) return signed_zero;
+    ASSERT(buffer_pos > 0);
+    int num = 0;
+    int start_pos = (buffer[0] == '-' ? 1 : 0);
+    for (int i = start_pos; i < buffer_pos; i++) {
+      ASSERT(buffer[i] >= '0' && buffer[i] <= '9');
+      num = 10 * num + (buffer[i] - '0');
+    }
+    return static_cast<double>(start_pos == 0 ? num : -num);
   }
 
   ASSERT(buffer_pos < kBufferSize);
   buffer[buffer_pos] = '\0';
 
   return gay_strtod(buffer, NULL);
 }
 
 double StringToDouble(String* str, int flags, double empty_string_val) {
   StringShape shape(str);
@@ skipping 378 matching lines @@
   // 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();
 }
 
 
 } }  // namespace v8::internal