Migrate error messages, part 12.

src/preparse-data.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.
 
 #ifndef V8_PREPARSE_DATA_H_
 #define V8_PREPARSE_DATA_H_
 
 #include "src/allocation.h"
 #include "src/hashmap.h"
+#include "src/messages.h"
 #include "src/preparse-data-format.h"
 
 namespace v8 {
 namespace internal {
 
 class ScriptData {
  public:
   ScriptData(const byte* data, int length);
   ~ScriptData() {
     if (owns_data_) DeleteArray(data_);
@@ skipping 31 matching lines @@
   virtual ~ParserRecorder() { }
 
   // Logs the scope and some details of a function literal in the source.
   virtual void LogFunction(int start, int end, int literals, int properties,
                            LanguageMode language_mode,
                            bool uses_super_property) = 0;
 
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
-  virtual void LogMessage(int start, int end, const char* message,
+  virtual void LogMessage(int start, int end, MessageTemplate::Template message,
                           const char* argument_opt,
                           ParseErrorType error_type) = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ParserRecorder);
 };
 
 
 class SingletonLogger : public ParserRecorder {
  public:
@@ skipping 11 matching lines @@
     end_ = end;
     literals_ = literals;
     properties_ = properties;
     language_mode_ = language_mode;
     scope_uses_super_property_ = scope_uses_super_property;
   }
 
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
-  virtual void LogMessage(int start, int end, const char* message,
+  virtual void LogMessage(int start, int end, MessageTemplate::Template message,
                           const char* argument_opt, ParseErrorType error_type) {
     if (has_error_) return;
     has_error_ = true;
     start_ = start;
     end_ = end;
     message_ = message;
     argument_opt_ = argument_opt;
     error_type_ = error_type;
   }
 
@@ skipping 14 matching lines @@
     return language_mode_;
   }
   bool scope_uses_super_property() const {
     DCHECK(!has_error_);
     return scope_uses_super_property_;
   }
   ParseErrorType error_type() const {
     DCHECK(has_error_);
     return error_type_;
   }
-  const char* message() {
+  MessageTemplate::Template message() {
     DCHECK(has_error_);
     return message_;
   }
   const char* argument_opt() const {
     DCHECK(has_error_);
     return argument_opt_;
   }
 
  private:
   bool has_error_;
   int start_;
   int end_;
   // For function entries.
   int literals_;
   int properties_;
   LanguageMode language_mode_;
   bool scope_uses_super_property_;
   // For error messages.
-  const char* message_;
+  MessageTemplate::Template message_;
   const char* argument_opt_;
   ParseErrorType error_type_;
 };
 
 
 class CompleteParserRecorder : public ParserRecorder {
  public:
   struct Key {
     bool is_one_byte;
     Vector<const byte> literal_bytes;
   };
 
   CompleteParserRecorder();
   virtual ~CompleteParserRecorder() {}
 
   virtual void LogFunction(int start, int end, int literals, int properties,
                            LanguageMode language_mode,
                            bool scope_uses_super_property) {
     function_store_.Add(start);
     function_store_.Add(end);
     function_store_.Add(literals);
     function_store_.Add(properties);
     function_store_.Add(language_mode);
     function_store_.Add(scope_uses_super_property);
   }
 
   // Logs an error message and marks the log as containing an error.
   // Further logging will be ignored, and ExtractData will return a vector
   // representing the error only.
-  virtual void LogMessage(int start, int end, const char* message,
+  virtual void LogMessage(int start, int end, MessageTemplate::Template message,
                           const char* argument_opt, ParseErrorType error_type);
   ScriptData* GetScriptData();
 
   bool HasError() {
     return static_cast<bool>(preamble_[PreparseDataConstants::kHasErrorOffset]);
   }
   Vector<unsigned> ErrorMessageData() {
     DCHECK(HasError());
     return function_store_.ToVector();
   }
 
  private:
   void WriteString(Vector<const char> str);
 
-  // Write a non-negative number to the symbol store.
-  void WriteNumber(int number);
-
   Collector<unsigned> function_store_;
   unsigned preamble_[PreparseDataConstants::kHeaderSize];
 
 #ifdef DEBUG
   int prev_start_;
 #endif
 };
 
 
 } }  // namespace v8::internal.
 
 #endif  // V8_PREPARSE_DATA_H_