OLD type

src/parser.h

 // Copyright 2012 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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // TODO(titzer): remove this include dependency
@@ skipping 35 matching lines @@
   bool getter() const { return GetFlag(flag); } \
   void setter() { SetFlag(flag); }              \
   void setter(bool val) { SetFlag(flag, val); }
 
   FLAG_ACCESSOR(kToplevel, is_toplevel, set_toplevel)
   FLAG_ACCESSOR(kLazy, is_lazy, set_lazy)
   FLAG_ACCESSOR(kEval, is_eval, set_eval)
   FLAG_ACCESSOR(kGlobal, is_global, set_global)
   FLAG_ACCESSOR(kStrictMode, is_strict_mode, set_strict_mode)
   FLAG_ACCESSOR(kStrongMode, is_strong_mode, set_strong_mode)
+  FLAG_ACCESSOR(kAsmFunction, is_asm_function, set_asm_function)
+  FLAG_ACCESSOR(kAsmModule, is_asm_module, set_asm_module)
   FLAG_ACCESSOR(kNative, is_native, set_native)
   FLAG_ACCESSOR(kModule, is_module, set_module)
   FLAG_ACCESSOR(kAllowLazyParsing, allow_lazy_parsing, set_allow_lazy_parsing)
   FLAG_ACCESSOR(kAstValueFactoryOwned, ast_value_factory_owned,
                 set_ast_value_factory_owned)
 
 #undef FLAG_ACCESSOR
 
   void set_parse_restriction(ParseRestriction restriction) {
     SetFlag(kParseRestriction, restriction != NO_PARSE_RESTRICTION);
@@ skipping 74 matching lines @@
 
   LanguageMode language_mode() {
     return construct_language_mode(is_strict_mode(), is_strong_mode());
   }
   void set_language_mode(LanguageMode language_mode) {
     STATIC_ASSERT(LANGUAGE_END == 3);
     set_strict_mode(language_mode & STRICT_BIT);
     set_strong_mode(language_mode & STRONG_BIT);
   }
 
+  AsmMode asm_mode() {
+    return construct_asm_mode(is_asm_function(), is_asm_module());
+  }
+  void set_asm_mode(AsmMode asm_mode) {
+    STATIC_ASSERT(ASM_END == 3);
+    set_asm_function(asm_mode & ASM_FUNCTION_BIT);
+    set_asm_module(asm_mode & ASM_MODULE_BIT);
+  }
+
   void ReopenHandlesInNewHandleScope() {
     closure_ = Handle<JSFunction>(*closure_);
     shared_ = Handle<SharedFunctionInfo>(*shared_);
     script_ = Handle<Script>(*script_);
     context_ = Handle<Context>(*context_);
   }
 
  private:
   // Various configuration flags for parsing.
   enum Flag {
     // ---------- Input flags ---------------------------
     kToplevel = 1 << 0,
     kLazy = 1 << 1,
     kEval = 1 << 2,
     kGlobal = 1 << 3,
     kStrictMode = 1 << 4,
     kStrongMode = 1 << 5,
     kNative = 1 << 6,
     kParseRestriction = 1 << 7,
     kModule = 1 << 8,
     kAllowLazyParsing = 1 << 9,
+    kAsmFunction = 1 << 10,
+    kAsmModule = 1 << 11,
     // ---------- Output flags --------------------------
-    kAstValueFactoryOwned = 1 << 10
+    kAstValueFactoryOwned = 1 << 12
   };
 
   //------------- Inputs to parsing and scope analysis -----------------------
   Zone* zone_;
   unsigned flags_;
   ScriptCompiler::ExternalSourceStream* source_stream_;
   ScriptCompiler::StreamedSource::Encoding source_stream_encoding_;
   v8::Extension* extension_;
   ScriptCompiler::CompileOptions compile_options_;
   Scope* script_scope_;
@@ skipping 25 matching lines @@
 };
 
 class FunctionEntry BASE_EMBEDDED {
  public:
   enum {
     kStartPositionIndex,
     kEndPositionIndex,
     kLiteralCountIndex,
     kPropertyCountIndex,
     kLanguageModeIndex,
+    kAsmModeIndex,
     kUsesSuperPropertyIndex,
     kCallsEvalIndex,
     kSize
   };
 
   explicit FunctionEntry(Vector<unsigned> backing)
     : backing_(backing) { }
 
   FunctionEntry() : backing_() { }
 
   int start_pos() { return backing_[kStartPositionIndex]; }
   int end_pos() { return backing_[kEndPositionIndex]; }
   int literal_count() { return backing_[kLiteralCountIndex]; }
   int property_count() { return backing_[kPropertyCountIndex]; }
   LanguageMode language_mode() {
     DCHECK(is_valid_language_mode(backing_[kLanguageModeIndex]));
     return static_cast<LanguageMode>(backing_[kLanguageModeIndex]);
   }
+
+  AsmMode asm_mode() {
+    DCHECK(backing_[kAsmModeIndex] == ASM_NO ||
+           backing_[kAsmModeIndex] == ASM_MODULE ||
+           backing_[kAsmModeIndex] == ASM_FUNCTION);
+    return static_cast<AsmMode>(backing_[kAsmModeIndex]);
+  }
+
   bool uses_super_property() { return backing_[kUsesSuperPropertyIndex]; }
   bool calls_eval() { return backing_[kCallsEvalIndex]; }
 
   bool is_valid() { return !backing_.is_empty(); }
 
  private:
   Vector<unsigned> backing_;
 };
 
 
@@ skipping 1030 matching lines @@
 }
 
 
 Expression* ParserTraits::SpreadCallNew(
     Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
   return parser_->SpreadCallNew(function, args, pos);
 }
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_