Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/parsing/preparse-data.h b/src/parsing/preparse-data.h
new file mode 100644
index 0000000..dbe1022
--- /dev/null
+++ b/src/parsing/preparse-data.h
@@ -0,0 +1,212 @@
+// 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_PARSING_PREPARSE_DATA_H_
+#define V8_PARSING_PREPARSE_DATA_H_
+
+#include "src/allocation.h"
+#include "src/hashmap.h"
+#include "src/messages.h"
+#include "src/parsing/preparse-data-format.h"
+
+namespace v8 {
+namespace internal {
+
+class ScriptData {
+ public:
+ ScriptData(const byte* data, int length);
+ ~ScriptData() {
+ if (owns_data_) DeleteArray(data_);
+ }
+
+ const byte* data() const { return data_; }
+ int length() const { return length_; }
+ bool rejected() const { return rejected_; }
+
+ void Reject() { rejected_ = true; }
+
+ void AcquireDataOwnership() {
+ DCHECK(!owns_data_);
+ owns_data_ = true;
+ }
+
+ void ReleaseDataOwnership() {
+ DCHECK(owns_data_);
+ owns_data_ = false;
+ }
+
+ private:
+ bool owns_data_ : 1;
+ bool rejected_ : 1;
+ const byte* data_;
+ int length_;
+
+ DISALLOW_COPY_AND_ASSIGN(ScriptData);
+};
+
+// Abstract interface for preparse data recorder.
+class ParserRecorder {
+ public:
+ ParserRecorder() { }
+ 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,
+ bool calls_eval) = 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, MessageTemplate::Template message,
+ const char* argument_opt,
+ ParseErrorType error_type) = 0;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(ParserRecorder);
+};
+
+
+class SingletonLogger : public ParserRecorder {
+ public:
+ SingletonLogger()
+ : has_error_(false), start_(-1), end_(-1), error_type_(kSyntaxError) {}
+ virtual ~SingletonLogger() {}
+
+ void Reset() { has_error_ = false; }
+
+ virtual void LogFunction(int start, int end, int literals, int properties,
+ LanguageMode language_mode, bool uses_super_property,
+ bool calls_eval) {
+ DCHECK(!has_error_);
+ start_ = start;
+ end_ = end;
+ literals_ = literals;
+ properties_ = properties;
+ language_mode_ = language_mode;
+ uses_super_property_ = uses_super_property;
+ calls_eval_ = calls_eval;
+ }
+
+ // 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, 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;
+ }
+
+ bool has_error() const { return has_error_; }
+
+ int start() const { return start_; }
+ int end() const { return end_; }
+ int literals() const {
+ DCHECK(!has_error_);
+ return literals_;
+ }
+ int properties() const {
+ DCHECK(!has_error_);
+ return properties_;
+ }
+ LanguageMode language_mode() const {
+ DCHECK(!has_error_);
+ return language_mode_;
+ }
+ bool uses_super_property() const {
+ DCHECK(!has_error_);
+ return uses_super_property_;
+ }
+ bool calls_eval() const {
+ DCHECK(!has_error_);
+ return calls_eval_;
+ }
+ ParseErrorType error_type() const {
+ DCHECK(has_error_);
+ return error_type_;
+ }
+ 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 uses_super_property_;
+ bool calls_eval_;
+ // For error messages.
+ 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 uses_super_property,
+ bool calls_eval) {
+ function_store_.Add(start);
+ function_store_.Add(end);
+ function_store_.Add(literals);
+ function_store_.Add(properties);
+ function_store_.Add(language_mode);
+ function_store_.Add(uses_super_property);
+ function_store_.Add(calls_eval);
+ }
+
+ // 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, 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);
+
+ Collector<unsigned> function_store_;
+ unsigned preamble_[PreparseDataConstants::kHeaderSize];
+
+#ifdef DEBUG
+ int prev_start_;
+#endif
+};
+
+
+} // namespace internal
+} // namespace v8.
+
+#endif // V8_PARSING_PREPARSE_DATA_H_