1 // Copyright 2016 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_PARSE_INFO_H_
6 #define V8_PARSING_PARSE_INFO_H_
7 
8 #include "include/v8.h"
9 #include "src/globals.h"
10 #include "src/handles.h"
11 
12 namespace v8 {
13 
14 class Extension;
15 
16 namespace internal {
17 
18 class AstRawString;
19 class AstValueFactory;
20 class DeclarationScope;
21 class FunctionLiteral;
22 class ScriptData;
23 class SharedFunctionInfo;
24 class UnicodeCache;
25 class Utf16CharacterStream;
26 class Zone;
27 
28 // A container for the inputs, configuration options, and outputs of parsing.
29 class V8_EXPORT_PRIVATE ParseInfo {
30  public:
31   explicit ParseInfo(Zone* zone);
32   ParseInfo(Zone* zone, Handle<Script> script);
33   ParseInfo(Zone* zone, Handle<SharedFunctionInfo> shared);
34 
35   ~ParseInfo();
36 
zone()37   Zone* zone() const { return zone_; }
38 
39 // Convenience accessor methods for flags.
40 #define FLAG_ACCESSOR(flag, getter, setter)     \
41   bool getter() const { return GetFlag(flag); } \
42   void setter() { SetFlag(flag); }              \
43   void setter(bool val) { SetFlag(flag, val); }
44 
FLAG_ACCESSOR(kToplevel,is_toplevel,set_toplevel)45   FLAG_ACCESSOR(kToplevel, is_toplevel, set_toplevel)
46   FLAG_ACCESSOR(kEval, is_eval, set_eval)
47   FLAG_ACCESSOR(kStrictMode, is_strict_mode, set_strict_mode)
48   FLAG_ACCESSOR(kNative, is_native, set_native)
49   FLAG_ACCESSOR(kModule, is_module, set_module)
50   FLAG_ACCESSOR(kAllowLazyParsing, allow_lazy_parsing, set_allow_lazy_parsing)
51   FLAG_ACCESSOR(kAstValueFactoryOwned, ast_value_factory_owned,
52                 set_ast_value_factory_owned)
53   FLAG_ACCESSOR(kIsNamedExpression, is_named_expression,
54                 set_is_named_expression)
55   FLAG_ACCESSOR(kCallsEval, calls_eval, set_calls_eval)
56   FLAG_ACCESSOR(kDebug, is_debug, set_is_debug)
57   FLAG_ACCESSOR(kSerializing, will_serialize, set_will_serialize)
58 
59 #undef FLAG_ACCESSOR
60 
61   void set_parse_restriction(ParseRestriction restriction) {
62     SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION);
63   }
64 
parse_restriction()65   ParseRestriction parse_restriction() const {
66     return GetFlag(kParseRestriction) ? ONLY_SINGLE_FUNCTION_LITERAL
67                                       : NO_PARSE_RESTRICTION;
68   }
69 
source_stream()70   ScriptCompiler::ExternalSourceStream* source_stream() const {
71     return source_stream_;
72   }
set_source_stream(ScriptCompiler::ExternalSourceStream * source_stream)73   void set_source_stream(ScriptCompiler::ExternalSourceStream* source_stream) {
74     source_stream_ = source_stream;
75   }
76 
source_stream_encoding()77   ScriptCompiler::StreamedSource::Encoding source_stream_encoding() const {
78     return source_stream_encoding_;
79   }
set_source_stream_encoding(ScriptCompiler::StreamedSource::Encoding source_stream_encoding)80   void set_source_stream_encoding(
81       ScriptCompiler::StreamedSource::Encoding source_stream_encoding) {
82     source_stream_encoding_ = source_stream_encoding;
83   }
84 
character_stream()85   Utf16CharacterStream* character_stream() const { return character_stream_; }
set_character_stream(Utf16CharacterStream * character_stream)86   void set_character_stream(Utf16CharacterStream* character_stream) {
87     character_stream_ = character_stream;
88   }
89 
extension()90   v8::Extension* extension() const { return extension_; }
set_extension(v8::Extension * extension)91   void set_extension(v8::Extension* extension) { extension_ = extension; }
92 
cached_data()93   ScriptData** cached_data() const { return cached_data_; }
set_cached_data(ScriptData ** cached_data)94   void set_cached_data(ScriptData** cached_data) { cached_data_ = cached_data; }
95 
compile_options()96   ScriptCompiler::CompileOptions compile_options() const {
97     return compile_options_;
98   }
set_compile_options(ScriptCompiler::CompileOptions compile_options)99   void set_compile_options(ScriptCompiler::CompileOptions compile_options) {
100     if (compile_options == ScriptCompiler::kConsumeParserCache) {
101       set_allow_lazy_parsing();
102     }
103     compile_options_ = compile_options;
104   }
105 
script_scope()106   DeclarationScope* script_scope() const { return script_scope_; }
set_script_scope(DeclarationScope * script_scope)107   void set_script_scope(DeclarationScope* script_scope) {
108     script_scope_ = script_scope;
109   }
110 
ast_value_factory()111   AstValueFactory* ast_value_factory() const { return ast_value_factory_; }
set_ast_value_factory(AstValueFactory * ast_value_factory)112   void set_ast_value_factory(AstValueFactory* ast_value_factory) {
113     ast_value_factory_ = ast_value_factory;
114   }
115 
function_name()116   const AstRawString* function_name() const { return function_name_; }
set_function_name(const AstRawString * function_name)117   void set_function_name(const AstRawString* function_name) {
118     function_name_ = function_name;
119   }
120 
literal()121   FunctionLiteral* literal() const { return literal_; }
set_literal(FunctionLiteral * literal)122   void set_literal(FunctionLiteral* literal) { literal_ = literal; }
123 
124   DeclarationScope* scope() const;
125 
unicode_cache()126   UnicodeCache* unicode_cache() const { return unicode_cache_; }
set_unicode_cache(UnicodeCache * unicode_cache)127   void set_unicode_cache(UnicodeCache* unicode_cache) {
128     unicode_cache_ = unicode_cache;
129   }
130 
stack_limit()131   uintptr_t stack_limit() const { return stack_limit_; }
set_stack_limit(uintptr_t stack_limit)132   void set_stack_limit(uintptr_t stack_limit) { stack_limit_ = stack_limit; }
133 
hash_seed()134   uint32_t hash_seed() const { return hash_seed_; }
set_hash_seed(uint32_t hash_seed)135   void set_hash_seed(uint32_t hash_seed) { hash_seed_ = hash_seed; }
136 
compiler_hints()137   int compiler_hints() const { return compiler_hints_; }
set_compiler_hints(int compiler_hints)138   void set_compiler_hints(int compiler_hints) {
139     compiler_hints_ = compiler_hints;
140   }
141 
start_position()142   int start_position() const { return start_position_; }
set_start_position(int start_position)143   void set_start_position(int start_position) {
144     start_position_ = start_position;
145   }
146 
end_position()147   int end_position() const { return end_position_; }
set_end_position(int end_position)148   void set_end_position(int end_position) { end_position_ = end_position; }
149 
150   // Getters for individual compiler hints.
151   bool is_declaration() const;
152   bool requires_class_field_init() const;
153   bool is_class_field_initializer() const;
154   FunctionKind function_kind() const;
155 
156   //--------------------------------------------------------------------------
157   // TODO(titzer): these should not be part of ParseInfo.
158   //--------------------------------------------------------------------------
isolate()159   Isolate* isolate() const { return isolate_; }
shared_info()160   Handle<SharedFunctionInfo> shared_info() const { return shared_; }
script()161   Handle<Script> script() const { return script_; }
maybe_outer_scope_info()162   MaybeHandle<ScopeInfo> maybe_outer_scope_info() const {
163     return maybe_outer_scope_info_;
164   }
clear_script()165   void clear_script() { script_ = Handle<Script>::null(); }
set_isolate(Isolate * isolate)166   void set_isolate(Isolate* isolate) { isolate_ = isolate; }
set_shared_info(Handle<SharedFunctionInfo> shared)167   void set_shared_info(Handle<SharedFunctionInfo> shared) { shared_ = shared; }
set_outer_scope_info(Handle<ScopeInfo> outer_scope_info)168   void set_outer_scope_info(Handle<ScopeInfo> outer_scope_info) {
169     maybe_outer_scope_info_ = outer_scope_info;
170   }
set_script(Handle<Script> script)171   void set_script(Handle<Script> script) { script_ = script; }
172   //--------------------------------------------------------------------------
173 
language_mode()174   LanguageMode language_mode() const {
175     return construct_language_mode(is_strict_mode());
176   }
set_language_mode(LanguageMode language_mode)177   void set_language_mode(LanguageMode language_mode) {
178     STATIC_ASSERT(LANGUAGE_END == 2);
179     set_strict_mode(is_strict(language_mode));
180   }
181 
ReopenHandlesInNewHandleScope()182   void ReopenHandlesInNewHandleScope() {
183     shared_ = Handle<SharedFunctionInfo>(*shared_);
184     script_ = Handle<Script>(*script_);
185     Handle<ScopeInfo> outer_scope_info;
186     if (maybe_outer_scope_info_.ToHandle(&outer_scope_info)) {
187       maybe_outer_scope_info_ = Handle<ScopeInfo>(*outer_scope_info);
188     }
189   }
190 
191 #ifdef DEBUG
192   bool script_is_native() const;
193 #endif  // DEBUG
194 
195  private:
196   // Various configuration flags for parsing.
197   enum Flag {
198     // ---------- Input flags ---------------------------
199     kToplevel = 1 << 0,
200     kLazy = 1 << 1,
201     kEval = 1 << 2,
202     kStrictMode = 1 << 3,
203     kNative = 1 << 4,
204     kParseRestriction = 1 << 5,
205     kModule = 1 << 6,
206     kAllowLazyParsing = 1 << 7,
207     kIsNamedExpression = 1 << 8,
208     kCallsEval = 1 << 9,
209     kDebug = 1 << 10,
210     kSerializing = 1 << 11,
211     // ---------- Output flags --------------------------
212     kAstValueFactoryOwned = 1 << 12
213   };
214 
215   //------------- Inputs to parsing and scope analysis -----------------------
216   Zone* zone_;
217   unsigned flags_;
218   ScriptCompiler::ExternalSourceStream* source_stream_;
219   ScriptCompiler::StreamedSource::Encoding source_stream_encoding_;
220   Utf16CharacterStream* character_stream_;
221   v8::Extension* extension_;
222   ScriptCompiler::CompileOptions compile_options_;
223   DeclarationScope* script_scope_;
224   UnicodeCache* unicode_cache_;
225   uintptr_t stack_limit_;
226   uint32_t hash_seed_;
227   int compiler_hints_;
228   int start_position_;
229   int end_position_;
230 
231   // TODO(titzer): Move handles and isolate out of ParseInfo.
232   Isolate* isolate_;
233   Handle<SharedFunctionInfo> shared_;
234   Handle<Script> script_;
235   MaybeHandle<ScopeInfo> maybe_outer_scope_info_;
236 
237   //----------- Inputs+Outputs of parsing and scope analysis -----------------
238   ScriptData** cached_data_;  // used if available, populated if requested.
239   AstValueFactory* ast_value_factory_;  // used if available, otherwise new.
240   const AstRawString* function_name_;
241 
242   //----------- Output of parsing and scope analysis ------------------------
243   FunctionLiteral* literal_;
244 
SetFlag(Flag f)245   void SetFlag(Flag f) { flags_ |= f; }
SetFlag(Flag f,bool v)246   void SetFlag(Flag f, bool v) { flags_ = v ? flags_ | f : flags_ & ~f; }
GetFlag(Flag f)247   bool GetFlag(Flag f) const { return (flags_ & f) != 0; }
248 };
249 
250 }  // namespace internal
251 }  // namespace v8
252 
253 #endif  // V8_PARSING_PARSE_INFO_H_
254