Experimental scanner: fix harmony flag setting.

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 70 matching lines @@
   virtual ~ScannerBase() {
     scanners_->erase(this);
     if (scanners_->empty()) {
       isolate_->heap()->RemoveGCEpilogueCallback(
           &ScannerBase::UpdateBuffersAfterGC);
       delete scanners_;
       scanners_ = NULL;
     }
   }
 
+  // Has to be called after creating the scanner and setting the flags.
+  virtual void Init() = 0;
+
+  // 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;
+  virtual void SetEnd(int pos) = 0;
+
+  // Scans the input as a regular expression pattern, previous character(s) must
+  // be /(=). Returns true if a pattern is scanned. FIXME: this won't work for
+  // utf-8 newlines.
+  virtual bool ScanRegExpPattern(bool seen_equal) = 0;
+  // Returns true if regexp flags are scanned (always since flags can
+  // be empty).
+  virtual bool ScanRegExpFlags() = 0;
+
+  // Returns the location of the last seen octal literal.
+  virtual Location octal_position() const = 0;
+  virtual void clear_octal_position() = 0;
+
   // Returns the next token and advances input.
   Token::Value Next() {
     has_line_terminator_before_next_ = false;
     current_ = next_;
     std::swap(current_literal_, next_literal_);
     Scan();  // Virtual! Will fill in next_.
     return current_.token;
   }
 
   // Returns the current token again.
@@ skipping 109 matching lines @@
     return next_literal_->is_ascii;
   }
 
   bool is_next_contextual_keyword(Vector<const char> keyword) {
     if (!is_next_literal_ascii()) return false;
     Vector<const char> literal = next_literal_ascii_string();
     return literal.length() == keyword.length() &&
         (memcmp(literal.start(), keyword.start(), literal.length()) == 0);
   }
 
-  // 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;
-  virtual void SetEnd(int pos) = 0;
-
-  // Scans the input as a regular expression pattern, previous character(s) must
-  // be /(=). Returns true if a pattern is scanned. FIXME: this won't work for
-  // utf-8 newlines.
-  virtual bool ScanRegExpPattern(bool seen_equal) = 0;
-  // Returns true if regexp flags are scanned (always since flags can
-  // be empty).
-  virtual bool ScanRegExpFlags() = 0;
-
-  // Returns the location of the last seen octal literal.
-  virtual Location octal_position() const = 0;
-  virtual void clear_octal_position() = 0;
-
  protected:
   struct TokenDesc {
     Token::Value token;
     int beg_pos;
     int end_pos;
     bool has_escapes;
   };
 
   struct LiteralDesc {
     int beg_pos;
@@ skipping 42 matching lines @@
       : ScannerBase(isolate),
         source_handle_(source),
         buffer_(NULL),
         buffer_end_(NULL),
         start_(NULL),
         cursor_(NULL),
         marker_(NULL),
         last_octal_end_(NULL) {
     ASSERT(source->IsFlat());
     SetBufferBasedOnHandle();
+  }
+
+  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;
@@ skipping 292 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