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

src/scanner.h

 // 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.
 
 #ifndef V8_SCANNER_H_
 #define V8_SCANNER_H_
 
 #include "src/allocation.h"
@@ skipping 71 matching lines @@
     }
     return SlowSeekForward(code_unit_count);
   }
 
   // Pushes back the most recently read UTF-16 code unit (or negative
   // value if at end of input), i.e., the value returned by the most recent
   // call to Advance.
   // Must not be used right after calling SeekForward.
   virtual void PushBack(int32_t code_unit) = 0;
 
+  virtual bool SetBookmark();
+  virtual bool CanResetToBookmark();
+  virtual bool ResetToBookmark();
+
  protected:
   static const uc32 kEndOfInput = -1;
 
   // Ensures that the buffer_cursor_ points to the code_unit at
   // position pos_ of the input, if possible. If the position
   // is at or after the end of the input, return false. If there
   // are more code_units available, return true.
   virtual bool ReadBlock() = 0;
   virtual size_t SlowSeekForward(size_t code_unit_count) = 0;
 
@@ skipping 159 matching lines @@
     position_ -= delta * (is_one_byte_ ? kOneByteSize : kUC16Size);
   }
 
   void Reset() {
     position_ = 0;
     is_one_byte_ = true;
   }
 
   Handle<String> Internalize(Isolate* isolate) const;
 
+  void CopyFrom(const LiteralBuffer* other) {
+    if (other == nullptr) {
+      Reset();
+    } else {
+      is_one_byte_ = other->is_one_byte_;
+      position_ = other->position_;
+      backing_store_.Dispose();
+      backing_store_ = other->backing_store_.Clone();
+    }
+  }
+
  private:
   static const int kInitialCapacity = 16;
   static const int kGrowthFactory = 4;
   static const int kMinConversionSlack = 256;
   static const int kMaxGrowth = 1 * MB;
   inline int NewCapacity(int min_capacity) {
     int capacity = Max(min_capacity, backing_store_.length());
     int new_capacity = Min(capacity * kGrowthFactory, capacity + kMaxGrowth);
     return new_capacity;
   }
@@ skipping 54 matching lines @@
      }
     void Complete() {
       complete_ = true;
     }
 
    private:
     Scanner* scanner_;
     bool complete_;
   };
 
+  // Scoped helper for a re-settable bookmark.
+  class BookmarkScope {
+   public:
+    explicit BookmarkScope(Scanner* scanner) : scanner_(scanner) {
+      DCHECK_NOT_NULL(scanner_);
+    }
+    ~BookmarkScope() { scanner_->DropBookmark(); }
+
+    bool Set() { return scanner_->SetBookmark(); }
+    bool Reset() { return scanner_->ResetToBookmark(); }
+    bool CanReset() { return scanner_->CanResetBookmark(); }
+    bool HasBeenSet() { return scanner_->BookmarkHasBeenSet(); }
+    bool HasBeenReset() { return scanner_->BookmarkHasBeenReset(); }
+
+   private:
+    Scanner* scanner_;
+  };
+
   // Representation of an interval of source positions.
   struct Location {
     Location(int b, int e) : beg_pos(b), end_pos(e) { }
     Location() : beg_pos(0), end_pos(0) { }
 
     bool IsValid() const {
       return beg_pos >= 0 && end_pos >= beg_pos;
     }
 
     static Location invalid() { return Location(-1, -1); }
@@ skipping 147 matching lines @@
   // Call this after setting source_ to the input.
   void Init() {
     // Set c0_ (one character ahead)
     STATIC_ASSERT(kCharacterLookaheadBufferSize == 1);
     Advance();
     // Initialize current_ to not refer to a literal.
     current_.literal_chars = NULL;
     current_.raw_literal_chars = NULL;
   }
 
+  // Support BookmarkScope functionality.
+  bool SetBookmark();
+  bool ResetToBookmark();
+  bool CanResetBookmark();
+  bool BookmarkHasBeenSet();
+  bool BookmarkHasBeenReset();
+  void DropBookmark();
+
   // Literal buffer support
   inline void StartLiteral() {
     LiteralBuffer* free_buffer = (current_.literal_chars == &literal_buffer1_) ?
             &literal_buffer2_ : &literal_buffer1_;
     free_buffer->Reset();
     next_.literal_chars = free_buffer;
   }
 
   inline void StartRawLiteral() {
     LiteralBuffer* free_buffer =
@@ skipping 182 matching lines @@
   LiteralBuffer source_url_;
   LiteralBuffer source_mapping_url_;
 
   // Buffer to store raw string values
   LiteralBuffer raw_literal_buffer1_;
   LiteralBuffer raw_literal_buffer2_;
 
   TokenDesc current_;  // desc for current token (as returned by Next())
   TokenDesc next_;     // desc for next token (one token look-ahead)
 
+  // Variables for Scanner::BookmarkScope and the *Bookmark implementation.
+  // These variables contain the scanner state when a bookmark is set.
+  // We will use bookmark_c0_ as a 'control' variable, where:
+  // - bookmark_c0_ >= 0: A bookmark has been set and this contains c0_.
+  // - bookmark_c0_ == -1: No bookmark has been set.
+  // - bookmark_c0_ == -2: The bookmark has been applied (ResetToBookmark).
+  TokenDesc bookmark_current_;
+  TokenDesc bookmark_next_;
+  uc32 bookmark_c0_;
+  LiteralBuffer bookmark_literal_;
+  LiteralBuffer bookmark_raw_literal_;

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

Hmm, why can't we just retroactively recover all these once we have set the
stream into the right position?

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

Yeah... I went a bit trial-and-error here and didn't see an /obvious/ way to do
this. I didn't see a hard-and-fast rule when content goes into which literal
buffer. Also, using the stream's push back functionality can create a state that
may not be recoverable by merely going to the old position.

Are there any invariants about the content of the literal buffers? Can I skip
back a bit more, and then read forward until I'm at the right position?

+
   // Input stream. Must be initialized to an Utf16CharacterStream.
   Utf16CharacterStream* source_;
 
 
   // Start position of the octal literal last scanned.
   Location octal_pos_;
 
   // Value of the last smi that was scanned.
   int smi_value_;
 
@@ skipping 11 matching lines @@
   bool harmony_modules_;
   // Whether we scan 'class', 'extends', 'static' and 'super' as keywords.
   bool harmony_classes_;
   // Whether we allow \u{xxxxx}.
   bool harmony_unicode_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_SCANNER_H_