[parser] implement error reporting for Scanner errors

src/parsing/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_PARSING_SCANNER_H_
 #define V8_PARSING_SCANNER_H_
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/char-predicates.h"
 #include "src/collector.h"
 #include "src/globals.h"
 #include "src/hashmap.h"
 #include "src/list.h"
+#include "src/messages.h"
 #include "src/parsing/token.h"
 #include "src/unicode.h"
 #include "src/unicode-decoder.h"
 
 namespace v8 {
 namespace internal {
 
 
 class AstRawString;
 class AstValueFactory;
@@ skipping 320 matching lines @@
   // Returns the next token and advances input.
   Token::Value Next();
   // Returns the token following peek()
   Token::Value PeekAhead();
   // Returns the current token again.
   Token::Value current_token() { return current_.token; }
   // Returns the location information for the current token
   // (the token last returned by Next()).
   Location location() const { return current_.location; }
 
+  bool has_error() const { return scanner_error_ != MessageTemplate::kNone; }
+  MessageTemplate::Template error() const { return scanner_error_; }
+  Location error_location() const { return scanner_error_location_; }
+
   // Similar functions for the upcoming token.
 
   // One token look-ahead (past the token returned by Next()).
   Token::Value peek() const { return next_.token; }
 
   Location peek_location() const { return next_.location; }
 
   bool literal_contains_escapes() const {
     return LiteralContainsEscapes(current_);
   }
@@ skipping 102 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;
     next_next_.token = Token::UNINITIALIZED;
     found_html_comment_ = false;
+    scanner_error_ = MessageTemplate::kNone;
   }
 
   // Support BookmarkScope functionality.
   bool SetBookmark();
   void ResetToBookmark();
   bool BookmarkHasBeenSet();
   bool BookmarkHasBeenReset();
   void DropBookmark();
   static void CopyTokenDesc(TokenDesc* to, TokenDesc* from);
 
+  void ReportScannerError(MessageTemplate::Template error, int begin, int end) {

[adamk, 2016/03/18 18:21:55]

Please put the location before |error| (same below), which matches the Parser
methods. Also this one should just take a Location.

[caitp (gmail), 2016/03/21 16:15:03]

Done.

+    if (has_error()) return;
+    scanner_error_ = error;
+    scanner_error_location_ = Location(begin, end);
+  }
+
+  void ReportScannerError(MessageTemplate::Template error, int begin) {
+    if (has_error()) return;
+    scanner_error_ = error;
+    scanner_error_location_ = Location(begin, begin + 1);
+  }
+
   // Literal buffer support
   inline void StartLiteral() {
     LiteralBuffer* free_buffer =
         (current_.literal_chars == &literal_buffer0_)
             ? &literal_buffer1_
             : (current_.literal_chars == &literal_buffer1_) ? &literal_buffer2_
                                                             : &literal_buffer0_;
     free_buffer->Reset();
     next_.literal_chars = free_buffer;
   }
@@ skipping 125 matching lines @@
   }
   Vector<const uint16_t> raw_literal_two_byte_string() {
     DCHECK_NOT_NULL(current_.raw_literal_chars);
     return current_.raw_literal_chars->two_byte_literal();
   }
   bool is_raw_literal_one_byte() {
     DCHECK_NOT_NULL(current_.raw_literal_chars);
     return current_.raw_literal_chars->is_one_byte();
   }
 
-  template <bool capture_raw>
+  template <bool capture_raw, bool unicode = false>
   uc32 ScanHexNumber(int expected_length);
   // Scan a number of any length but not bigger than max_value. For example, the
   // number can be 000000001, so it's very long in characters but its value is
   // small.
   template <bool capture_raw>
-  uc32 ScanUnlimitedLengthHexNumber(int max_value);
+  uc32 ScanUnlimitedLengthHexNumber(int max_value, bool& bad_codepoint);
 
   // Scans a single JavaScript token.
   void Scan();
 
   bool SkipWhiteSpace();
   Token::Value SkipSingleLineComment();
   Token::Value SkipSourceURLComment();
   void TryToParseSourceURLComment();
   Token::Value SkipMultiLineComment();
   // Scans a possible HTML comment -- begins with '<!'.
@@ skipping 100 matching lines @@
   // Whether there is a line terminator whitespace character after
   // the current token, and  before the next. Does not count newlines
   // inside multiline comments.
   bool has_line_terminator_before_next_;
   // Whether there is a multi-line comment that contains a
   // line-terminator after the current token, and before the next.
   bool has_multiline_comment_before_next_;
 
   // Whether this scanner encountered an HTML comment.
   bool found_html_comment_;
+
+  MessageTemplate::Template scanner_error_;
+  Location scanner_error_location_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_SCANNER_H_