1 // Copyright 2011 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_PARSING_PREPARSE_DATA_H_ 6 #define V8_PARSING_PREPARSE_DATA_H_ 7 8 #include "src/allocation.h" 9 #include "src/hashmap.h" 10 #include "src/messages.h" 11 #include "src/parsing/preparse-data-format.h" 12 13 namespace v8 { 14 namespace internal { 15 16 class ScriptData { 17 public: 18 ScriptData(const byte* data, int length); 19 ~ScriptData() { 20 if (owns_data_) DeleteArray(data_); 21 } 22 23 const byte* data() const { return data_; } 24 int length() const { return length_; } 25 bool rejected() const { return rejected_; } 26 27 void Reject() { rejected_ = true; } 28 29 void AcquireDataOwnership() { 30 DCHECK(!owns_data_); 31 owns_data_ = true; 32 } 33 34 void ReleaseDataOwnership() { 35 DCHECK(owns_data_); 36 owns_data_ = false; 37 } 38 39 private: 40 bool owns_data_ : 1; 41 bool rejected_ : 1; 42 const byte* data_; 43 int length_; 44 45 DISALLOW_COPY_AND_ASSIGN(ScriptData); 46 }; 47 48 // Abstract interface for preparse data recorder. 49 class ParserRecorder { 50 public: 51 ParserRecorder() { } 52 virtual ~ParserRecorder() { } 53 54 // Logs the scope and some details of a function literal in the source. 55 virtual void LogFunction(int start, int end, int literals, int properties, 56 LanguageMode language_mode, bool uses_super_property, 57 bool calls_eval) = 0; 58 59 // Logs an error message and marks the log as containing an error. 60 // Further logging will be ignored, and ExtractData will return a vector 61 // representing the error only. 62 virtual void LogMessage(int start, int end, MessageTemplate::Template message, 63 const char* argument_opt, 64 ParseErrorType error_type) = 0; 65 66 private: 67 DISALLOW_COPY_AND_ASSIGN(ParserRecorder); 68 }; 69 70 71 class SingletonLogger : public ParserRecorder { 72 public: 73 SingletonLogger() 74 : has_error_(false), start_(-1), end_(-1), error_type_(kSyntaxError) {} 75 virtual ~SingletonLogger() {} 76 77 void Reset() { has_error_ = false; } 78 79 virtual void LogFunction(int start, int end, int literals, int properties, 80 LanguageMode language_mode, bool uses_super_property, 81 bool calls_eval) { 82 DCHECK(!has_error_); 83 start_ = start; 84 end_ = end; 85 literals_ = literals; 86 properties_ = properties; 87 language_mode_ = language_mode; 88 uses_super_property_ = uses_super_property; 89 calls_eval_ = calls_eval; 90 } 91 92 // Logs an error message and marks the log as containing an error. 93 // Further logging will be ignored, and ExtractData will return a vector 94 // representing the error only. 95 virtual void LogMessage(int start, int end, MessageTemplate::Template message, 96 const char* argument_opt, ParseErrorType error_type) { 97 if (has_error_) return; 98 has_error_ = true; 99 start_ = start; 100 end_ = end; 101 message_ = message; 102 argument_opt_ = argument_opt; 103 error_type_ = error_type; 104 } 105 106 bool has_error() const { return has_error_; } 107 108 int start() const { return start_; } 109 int end() const { return end_; } 110 int literals() const { 111 DCHECK(!has_error_); 112 return literals_; 113 } 114 int properties() const { 115 DCHECK(!has_error_); 116 return properties_; 117 } 118 LanguageMode language_mode() const { 119 DCHECK(!has_error_); 120 return language_mode_; 121 } 122 bool uses_super_property() const { 123 DCHECK(!has_error_); 124 return uses_super_property_; 125 } 126 bool calls_eval() const { 127 DCHECK(!has_error_); 128 return calls_eval_; 129 } 130 ParseErrorType error_type() const { 131 DCHECK(has_error_); 132 return error_type_; 133 } 134 MessageTemplate::Template message() { 135 DCHECK(has_error_); 136 return message_; 137 } 138 const char* argument_opt() const { 139 DCHECK(has_error_); 140 return argument_opt_; 141 } 142 143 private: 144 bool has_error_; 145 int start_; 146 int end_; 147 // For function entries. 148 int literals_; 149 int properties_; 150 LanguageMode language_mode_; 151 bool uses_super_property_; 152 bool calls_eval_; 153 // For error messages. 154 MessageTemplate::Template message_; 155 const char* argument_opt_; 156 ParseErrorType error_type_; 157 }; 158 159 160 class CompleteParserRecorder : public ParserRecorder { 161 public: 162 struct Key { 163 bool is_one_byte; 164 Vector<const byte> literal_bytes; 165 }; 166 167 CompleteParserRecorder(); 168 virtual ~CompleteParserRecorder() {} 169 170 virtual void LogFunction(int start, int end, int literals, int properties, 171 LanguageMode language_mode, bool uses_super_property, 172 bool calls_eval) { 173 function_store_.Add(start); 174 function_store_.Add(end); 175 function_store_.Add(literals); 176 function_store_.Add(properties); 177 function_store_.Add(language_mode); 178 function_store_.Add(uses_super_property); 179 function_store_.Add(calls_eval); 180 } 181 182 // Logs an error message and marks the log as containing an error. 183 // Further logging will be ignored, and ExtractData will return a vector 184 // representing the error only. 185 virtual void LogMessage(int start, int end, MessageTemplate::Template message, 186 const char* argument_opt, ParseErrorType error_type); 187 ScriptData* GetScriptData(); 188 189 bool HasError() { 190 return static_cast<bool>(preamble_[PreparseDataConstants::kHasErrorOffset]); 191 } 192 Vector<unsigned> ErrorMessageData() { 193 DCHECK(HasError()); 194 return function_store_.ToVector(); 195 } 196 197 private: 198 void WriteString(Vector<const char> str); 199 200 Collector<unsigned> function_store_; 201 unsigned preamble_[PreparseDataConstants::kHeaderSize]; 202 203 #ifdef DEBUG 204 int prev_start_; 205 #endif 206 }; 207 208 209 } // namespace internal 210 } // namespace v8. 211 212 #endif // V8_PARSING_PREPARSE_DATA_H_ 213
