Improve ScanJsonNumber performance.

src/scanner.cc

 // Copyright 2010 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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#include <limits.h>
 #include "v8.h"
 
 #include "ast.h"
 #include "handles.h"
 #include "scanner.h"
+#include "strtod.h"
 #include "unicode-inl.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // BufferedUC16CharacterStreams
 
 BufferedUC16CharacterStream::BufferedUC16CharacterStream()
     : UC16CharacterStream(),
@@ skipping 370 matching lines @@
         token = Token::COLON;
         break;
       case ',':
         Advance();
         token = Token::COMMA;
         break;
       case '"':
         token = ScanJsonString();
         break;
       case '-':
+        Advance();
+        token = ScanJsonNumber();
+        number = -number;
+        break;
       case '0':
       case '1':
       case '2':
       case '3':
       case '4':
       case '5':
       case '6':
       case '7':
       case '8':
       case '9':
@@ skipping 75 matching lines @@
       Advance();
     }
   }
   literal.Complete();
   Advance();
   return Token::STRING;
 }
 
 
 Token::Value JsonScanner::ScanJsonNumber() {
-  LiteralScope literal(this);
-  if (c0_ == '-') AddLiteralCharAdvance();
+  // Maximum number of significant digits in decimal representation.
+  // The longest possible double in decimal representation is
+  // (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074
+  // (768 digits). If we parse a number whose first digits are equal to a
+  // mean of 2 adjacent doubles (that could have up to 769 digits) the result
+  // 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;
+  // 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.
+  int exponent = 0;
+  int significant_digits = 0;
+  int insignificant_digits = 0;
+  int i = 0;
+  bool nonzero_digit_dropped = false;
   if (c0_ == '0') {
-    AddLiteralCharAdvance();
+    Advance();
     // Prefix zero is only allowed if it's the only digit before
     // a decimal point or exponent.
     if ('0' <= c0_ && c0_ <= '9') return Token::ILLEGAL;
   } else {
     if (c0_ < '1' || c0_ > '9') return Token::ILLEGAL;
     do {
-      AddLiteralCharAdvance();
+      if (significant_digits < kMaxSignificantDigits) {
+        ASSERT(buffer_pos < kBufferSize);
+        buffer[buffer_pos++] = static_cast<char>(c0_);
+        significant_digits++;
+        i = i * 10 + c0_ - '0';
+      } else {
+        insignificant_digits++;  // Move the digit into the exponential part.
+        nonzero_digit_dropped = nonzero_digit_dropped || c0_ != '0';
+      }
+      Advance();
+    } while (c0_ >= '0' && c0_ <= '9');
+    if (c0_ != '.' && c0_ != 'e' && c0_ != 'E' && significant_digits < 10) {
+      number = i;
+      return Token::NUMBER;
+    }
+  }
+  if (c0_ == '.') {
+    Advance();
+    if (c0_ < '0' || c0_ > '9') return Token::ILLEGAL;
+    if (significant_digits == 0) {
+      // Integer part consists of 0.
+      // Significant digits start after leading zero(s).
+      while (c0_ == '0') {
+        Advance();
+        exponent--;  // Move this 0 into the exponent.
+      }
+      if (c0_ < '0' || c0_ > '9') {
+        number = 0.0;
+        return Token::NUMBER;
+      }
+    }
+    do {
+      if (significant_digits < kMaxSignificantDigits) {
+        ASSERT(buffer_pos < kBufferSize);
+        buffer[buffer_pos++] = static_cast<char>(c0_);
+        significant_digits++;
+        exponent--;
+      } else {
+        // Ignore insignificant digits in the fractional part.
+        nonzero_digit_dropped = nonzero_digit_dropped || c0_ != '0';
+      }
+      Advance();
     } while (c0_ >= '0' && c0_ <= '9');
   }
-  if (c0_ == '.') {
-    AddLiteralCharAdvance();
+  if (c0_ == 'e' || c0_ == 'E') {
+    Advance();
+    bool expsign = (c0_ == '-');
+    if (expsign || c0_ == '+') Advance();
     if (c0_ < '0' || c0_ > '9') return Token::ILLEGAL;
+    const int max_exponent = INT_MAX / 2;
+    ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
+    int num = 0;
     do {
-      AddLiteralCharAdvance();
+      // Check overflow.
+      int digit = c0_ - '0';
+      if (num >= max_exponent / 10
+          && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
+        num = max_exponent;
+      } else {
+        num = num * 10 + digit;
+      }
+      Advance();
     } while (c0_ >= '0' && c0_ <= '9');
+    exponent += (expsign ? -num : num);
   }
-  if (AsciiAlphaToLower(c0_) == 'e') {
-    AddLiteralCharAdvance();
-    if (c0_ == '-' || c0_ == '+') AddLiteralCharAdvance();
-    if (c0_ < '0' || c0_ > '9') return Token::ILLEGAL;
-    do {
-      AddLiteralCharAdvance();
-    } while (c0_ >= '0' && c0_ <= '9');
+
+  exponent += insignificant_digits;
+  if (nonzero_digit_dropped) {
+    buffer[buffer_pos++] = '1';
+    exponent--;
   }
-  literal.Complete();
+  ASSERT(buffer_pos < kBufferSize);
+  buffer[buffer_pos] = '\0';
+  number = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
   return Token::NUMBER;
 }
 
 
 Token::Value JsonScanner::ScanJsonIdentifier(const char* text,
                                              Token::Value token) {
   LiteralScope literal(this);
   while (*text != '\0') {
     if (c0_ != *text) return Token::ILLEGAL;
     Advance();
     text++;
   }
   if (ScannerConstants::kIsIdentifierPart.get(c0_)) return Token::ILLEGAL;
   literal.Complete();
   return token;
 }
 
 
 
 } }  // namespace v8::internal