Experimental parser: make marker local

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 274 matching lines @@
  public:
   explicit ExperimentalScanner(
       Handle<String> source,
       Isolate* isolate)
       : ScannerBase(isolate),
         source_handle_(source),
         buffer_(NULL),
         buffer_end_(NULL),
         start_(NULL),
         cursor_(NULL),
-        marker_(NULL),
         last_octal_end_(NULL) {
     ASSERT(source->IsFlat());
     UpdateBufferBasedOnHandle();
     current_.beg_pos = current_.end_pos = next_.beg_pos = next_.end_pos = 0;
   }
 
   virtual void Init() {
     Scan();
   }
 
   virtual ~ExperimentalScanner() { }
 
   virtual void SeekForward(int pos);
   virtual void SetEnd(int pos);
   virtual bool ScanRegExpPattern(bool seen_equal);
   virtual bool ScanRegExpFlags();
   virtual Location octal_position() const;
   virtual void clear_octal_position() {
     last_octal_end_ = NULL;
   }
 
   virtual void UpdateBufferBasedOnHandle() {
     // 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_;
       int cursor_offset = cursor_ - buffer_;
-      int marker_offset = marker_ - buffer_;
       int last_octal_end_offset = last_octal_end_ - buffer_;
       buffer_ = new_buffer;
       buffer_end_ = buffer_ + source_handle_->length();
       start_ = buffer_ + start_offset;
       cursor_ = buffer_ + cursor_offset;
-      marker_ = buffer_ + marker_offset;
       if (last_octal_end_ != NULL) {
         last_octal_end_ = buffer_ + last_octal_end_offset;
       }
       ResetLiterals();
     }
   }
 
  protected:
   virtual void Scan();
 
@@ skipping 24 matching lines @@
                                           uc32* result);
   const Char* ScanEscape(const Char* start,
                          const Char* end,
                          LiteralBuffer* literal);
 
   Handle<String> source_handle_;
   const Char* buffer_;
   const Char* buffer_end_;
   const Char* start_;
   const Char* cursor_;
-  const Char* marker_;
 
   // Where we have seen the last octal number or an octal escape inside a
   // string. Used by octal_position().
   const Char* last_octal_end_;
 };
 
 
 template<typename Char>
 void ExperimentalScanner<Char>::SeekForward(int pos) {
   cursor_ = buffer_ + pos;
   start_ = cursor_;
-  marker_ = cursor_;
   has_line_terminator_before_next_ = false;
   has_multiline_comment_before_next_ = false;
   Scan();  // Fills in next_.
 }
 
 
 template<typename Char>
 void ExperimentalScanner<Char>::SetEnd(int pos) {
   buffer_end_ = buffer_ + pos;
 }
@@ skipping 212 matching lines @@
   // character.
   const Char* temp_cursor = last_octal_end_ - 1;
   while (temp_cursor >= buffer_ && *temp_cursor >= '0' && *temp_cursor <= '7')
     --temp_cursor;
   return Location(temp_cursor - buffer_ + 1, last_octal_end_ - buffer_);
 }
 
 } }
 
 #endif  // V8_LEXER_EXPERIMENTAL_SCANNER_H