Fix scanning of regexp flags.

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 378 matching lines @@
 }
 
 
 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);
+  next_.beg_pos = next_.end_pos = (cursor_ - buffer_) - (seen_equal ? 1 : 0);
 
   // Scan regular expression body: According to ECMA-262, 3rd, 7.8.5,
   // the scanner should pass uninterpreted bodies to the RegExp
   // constructor.
   if (cursor_ >= buffer_end_) return false;
 
   while (*cursor_ != '/' || in_character_class) {
     if (unicode_cache_->IsLineTerminator(*cursor_)) return false;
     if (*cursor_ == '\\') {  // Escape sequence.
       ++cursor_;
@@ skipping 10 matching lines @@
       // of the escape sequence.
 
       // TODO(896): At some point, parse RegExps more throughly to capture
       // octal esacpes in strict mode.
     } else {  // Unescaped character.
       if (*cursor_ == '[') in_character_class = true;
       if (*cursor_ == ']') in_character_class = false;
       if (++cursor_ >= buffer_end_) return false;
     }
   }
+  next_.end_pos = (cursor_ - buffer_);
   ++cursor_;  // consume '/'
   return true;
 }
 
 
 template<typename Char>
 bool ExperimentalScanner<Char>::ScanRegExpFlags() {
+  next_.beg_pos = cursor_ - buffer_;
   // Scan regular expression flags.
   while (cursor_ < buffer_end_ && unicode_cache_->IsIdentifierPart(*cursor_)) {
     if (*cursor_ != '\\') {
       if (++cursor_ >= buffer_end_) break;
     } else {
       if (!ScanLiteralUnicodeEscape()) break;
       if (++cursor_ >= buffer_end_) break;
     }
   }
-  next_.end_pos = cursor_ - buffer_ - 1;
+  next_.end_pos = cursor_ - buffer_;
   return true;
 }
 
 
 template<typename Char>
 uc32 ExperimentalScanner<Char>::ScanHexNumber(int length) {
   // We have seen \uXXXX, let's see what it is.
   uc32 x = 0;
   for (const Char* s = cursor_ - length; s != cursor_; ++s) {
     int d = HexValue(*s);
@@ skipping 143 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