Implement a 'trial parse' step, that will abort pre-parsing excessively

src/scanner.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Features shared by parsing and pre-parsing scanners.
 
 #include <stdint.h>
 
 #include <cmath>
 
@@ skipping 11 matching lines @@
 
 
 Handle<String> LiteralBuffer::Internalize(Isolate* isolate) const {
   if (is_one_byte()) {
     return isolate->factory()->InternalizeOneByteString(one_byte_literal());
   }
   return isolate->factory()->InternalizeTwoByteString(two_byte_literal());
 }
 
 
+// 'Safe' default implementation for streams that do not support bookmarks.
+bool Utf16CharacterStream::SetBookmark() { return false; }
+bool Utf16CharacterStream::CanResetToBookmark() { return false; }

[marja, 2015/04/22 16:40:56]

I don't get why we need CanResetToBookmark; if SetBookmark returns true, we can
assume that it successfully set the bookmark and can later successfully reset to
it, no?

+bool Utf16CharacterStream::ResetToBookmark() { return false; }

[marja, 2015/04/22 16:40:56]

Also here, if we successfully set a bookmark, I'd assume we can reset to it, and
this function has no way of saying "ha ha, we actually cannot" and returning
false.

+
+

[marja, 2015/04/22 16:40:56]

... or is there some logic here like "this bookmark has already been set to
something and thus we cannot set it to something else"?

(But that could be expressed in a more direct way.)

[vogelheim, 2015/04/22 17:08:35]

(answered elsewhere:) The idea is to support a stream implementation that truly
streams, where you can reset while you're still in the same block, but not when
you're on a new one.

Maybe we simply shouldn't do this, and make any 'streaming' implementation hold
on to past blocks, at least while they have a bookmark set?

 // ----------------------------------------------------------------------------
 // Scanner
 
 Scanner::Scanner(UnicodeCache* unicode_cache)
     : unicode_cache_(unicode_cache),
+      bookmark_c0_(-1),
       octal_pos_(Location::invalid()),
       harmony_modules_(false),
       harmony_classes_(false),
       harmony_unicode_(false) {}
 
 
 void Scanner::Initialize(Utf16CharacterStream* source) {
   source_ = source;
   // Need to capture identifiers in order to recognize "get" and "set"
   // in object literals.
@@ skipping 1372 matching lines @@
 
 
 int Scanner::FindSymbol(DuplicateFinder* finder, int value) {
   if (is_literal_one_byte()) {
     return finder->AddOneByteSymbol(literal_one_byte_string(), value);
   }
   return finder->AddTwoByteSymbol(literal_two_byte_string(), value);
 }
 
 
+bool Scanner::SetBookmark() {
+  bool can_bookmark = (bookmark_c0_ == -1) && source_->SetBookmark();
+  if (can_bookmark) {
+    bookmark_c0_ = c0_;
+    bookmark_current_ = current_;
+    bookmark_current_.literal_chars = nullptr;
+    bookmark_current_.raw_literal_chars = nullptr;
+    bookmark_next_ = next_;
+    bookmark_next_.literal_chars = nullptr;
+    bookmark_next_.raw_literal_chars = nullptr;
+    bookmark_literal_.CopyFrom(next_.literal_chars);
+    bookmark_raw_literal_.CopyFrom(next_.raw_literal_chars);
+  }
+  return can_bookmark;
+}
+
+
+bool Scanner::ResetToBookmark() {
+  DCHECK(bookmark_c0_ >= 0);  // Caller hasn't called SetBookmark.
+  bool can_reset = CanResetBookmark();
+  if (can_reset) {
+    source_->ResetToBookmark();
+    next_ = bookmark_next_;
+    current_ = bookmark_current_;
+    c0_ = bookmark_c0_;
+
+    next_.literal_chars = &literal_buffer1_;
+    next_.literal_chars->CopyFrom(&bookmark_literal_);
+    next_.raw_literal_chars = &raw_literal_buffer1_;
+    next_.raw_literal_chars->CopyFrom(&bookmark_raw_literal_);
+
+    bookmark_c0_ = -2;
+  }
+
+  return can_reset;
+}
+
+
+bool Scanner::CanResetBookmark() {
+  return source_->CanResetToBookmark() && BookmarkHasBeenSet();
+}
+
+
+bool Scanner::BookmarkHasBeenSet() { return bookmark_c0_ >= 0; }
+
+
+bool Scanner::BookmarkHasBeenReset() { return bookmark_c0_ == -2; }
+
+
+void Scanner::DropBookmark() { bookmark_c0_ = -1; }
+
+
 int DuplicateFinder::AddOneByteSymbol(Vector<const uint8_t> key, int value) {
   return AddSymbol(key, true, value);
 }
 
 
 int DuplicateFinder::AddTwoByteSymbol(Vector<const uint16_t> key, int value) {
   return AddSymbol(Vector<const uint8_t>::cast(key), false, value);
 }
 
 
@@ skipping 120 matching lines @@
     }
     backing_store_.Add(static_cast<uint8_t>((one_byte_length >> 7) | 0x80u));
   }
   backing_store_.Add(static_cast<uint8_t>(one_byte_length & 0x7f));
 
   backing_store_.AddBlock(bytes);
   return backing_store_.EndSequence().start();
 }
 
 } }  // namespace v8::internal