ExperimentalScanner += SeekForward.

src/lexer/experimental-scanner.h

 // Copyright 2013 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 163 matching lines @@
     return 0;  // FIXME
   }
 
   uc32 ScanOctalEscape(uc32 c, int length) { return 0; }  // FIXME
 
   Location octal_position() const {
     return Location(0, 0);  // FIXME
   }
   void clear_octal_position() { }  // FIXME
 
-  void SeekForward(int pos) { }  // FIXME
+  // Seek forward to the given position. This operation works for simple cases
+  // such as seeking forward until simple delimiter tokens, which is what it is
+  // used for. After this call, we will have the token at the given position as
+  // the "next" token. The "current" token will be invalid. FIXME: for utf-8,
+  // we need to decide if pos is counted in characters or in bytes.
+  virtual void SeekForward(int pos) = 0;
 
   // Scans the input as a regular expression pattern, previous
   // character(s) must be /(=). Returns true if a pattern is scanned.
   virtual bool ScanRegExpPattern(bool seen_equal) = 0;
   // Returns true if regexp flags are scanned (always since flags can
   // be empty).
   virtual bool ScanRegExpFlags() = 0;
 
  protected:
   struct TokenDesc {
@@ skipping 38 matching lines @@
         cursor_(NULL),
         marker_(NULL) {
     ASSERT(source->IsFlat());
     SetBufferBasedOnHandle();
     Scan();
   }
 
   virtual ~ExperimentalScanner() { }
 
   virtual void Scan();
+  virtual void SeekForward(int pos);
   virtual bool ScanRegExpPattern(bool seen_equal);
   virtual bool ScanRegExpFlags();
 
   virtual void SetBufferBasedOnHandle() {
     // We get a raw pointer from the Handle, but we also update it every time
     // there is a GC, so it is safe.
     DisallowHeapAllocation no_gc;
     const Char* new_buffer = GetNewBufferBasedOnHandle();
     if (new_buffer != buffer_) {
       int start_offset = start_ - buffer_;
@@ skipping 24 matching lines @@
   Handle<String> source_handle_;
   const Char* buffer_;
   const Char* buffer_end_;
   const Char* start_;
   const Char* cursor_;
   const Char* marker_;
 };
 
 
 template<typename Char>
+void ExperimentalScanner<Char>::SeekForward(int pos) {
+  cursor_ = buffer_ + pos;
+  start_ = cursor_;
+  marker_ = cursor_;
+  Scan();  // Fills in next_.
+}
+
+
+template<typename Char>
 bool ExperimentalScanner<Char>::ScanRegExpPattern(bool seen_equal) {
   // Scan: ('/' | '/=') RegularExpressionBody '/' RegularExpressionFlags
   bool in_character_class = false;
 
   // Previous token is either '/' or '/=', in the second case, the
   // pattern starts at =.
   next_.beg_pos = (cursor_ - buffer_) - (seen_equal ? 2 : 1);
   next_.end_pos = (cursor_ - buffer_) - (seen_equal ? 1 : 0);
 
   // Scan regular expression body: According to ECMA-262, 3rd, 7.8.5,
@@ skipping 76 matching lines @@
       i++;
     }
   }
   return i == 6;
 }
 
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H