Line data    Source code

       1             : // Copyright 2017 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_TORQUE_GLOBAL_CONTEXT_H_
       6             : #define V8_TORQUE_GLOBAL_CONTEXT_H_
       7             : 
       8             : #include <map>
       9             : 
      10             : #include "src/torque/declarable.h"
      11             : #include "src/torque/declarations.h"
      12             : #include "src/torque/type-oracle.h"
      13             : 
      14             : namespace v8 {
      15             : namespace internal {
      16             : namespace torque {
      17             : 
      18           6 : class GlobalContext : public ContextualClass<GlobalContext> {
      19             :  public:
      20           3 :   explicit GlobalContext(Ast ast)
      21             :       : verbose_(false),
      22             :         collect_language_server_data_(false),
      23           3 :         ast_(std::move(ast)) {
      24             :     CurrentScope::Scope current_scope(nullptr);
      25             :     CurrentSourcePosition::Scope current_source_position(
      26           3 :         SourcePosition{CurrentSourceFile::Get(), {-1, -1}, {-1, -1}});
      27             :     default_namespace_ =
      28           6 :         RegisterDeclarable(base::make_unique<Namespace>(kBaseNamespaceName));
      29           3 :   }
      30      198473 :   static Namespace* GetDefaultNamespace() { return Get().default_namespace_; }
      31             :   template <class T>
      32        7458 :   T* RegisterDeclarable(std::unique_ptr<T> d) {
      33             :     T* ptr = d.get();
      34       15046 :     declarables_.push_back(std::move(d));
      35        7458 :     return ptr;
      36             :   }
      37             : 
      38             :   static const std::vector<std::unique_ptr<Declarable>>& AllDeclarables() {
      39             :     return Get().declarables_;
      40             :   }
      41             : 
      42          48 :   static const std::vector<Namespace*> GetNamespaces() {
      43             :     std::vector<Namespace*> result;
      44      110546 :     for (auto& declarable : AllDeclarables()) {
      45      110498 :       if (Namespace* n = Namespace::DynamicCast(declarable.get())) {
      46        1852 :         result.push_back(n);
      47             :       }
      48             :     }
      49          48 :     return result;
      50             :   }
      51             : 
      52         121 :   static void RegisterClass(const std::string& name, ClassType* new_class) {
      53         121 :     Get().classes_[name] = new_class;
      54         121 :   }
      55             : 
      56             :   static const std::map<std::string, ClassType*>& GetClasses() {
      57             :     return Get().classes_;
      58             :   }
      59             : 
      60             :   static void AddCppInclude(std::string include_path) {
      61          36 :     Get().cpp_includes_.push_back(std::move(include_path));
      62             :   }
      63             :   static const std::vector<std::string>& CppIncludes() {
      64             :     return Get().cpp_includes_;
      65             :   }
      66             : 
      67           0 :   static void SetVerbose() { Get().verbose_ = true; }
      68        8279 :   static bool verbose() { return Get().verbose_; }
      69             :   static void SetCollectLanguageServerData() {
      70           2 :     Get().collect_language_server_data_ = true;
      71             :   }
      72             :   static bool collect_language_server_data() {
      73       27079 :     return Get().collect_language_server_data_;
      74             :   }
      75           3 :   static Ast* ast() { return &Get().ast_; }
      76             : 
      77             :  private:
      78             :   bool verbose_;
      79             :   bool collect_language_server_data_;
      80             :   Namespace* default_namespace_;
      81             :   Ast ast_;
      82             :   std::vector<std::unique_ptr<Declarable>> declarables_;
      83             :   std::vector<std::string> cpp_includes_;
      84             :   std::map<std::string, ClassType*> classes_;
      85             : };
      86             : 
      87             : template <class T>
      88        7585 : T* RegisterDeclarable(std::unique_ptr<T> d) {
      89       15040 :   return GlobalContext::Get().RegisterDeclarable(std::move(d));
      90             : }
      91             : 
      92             : }  // namespace torque
      93             : }  // namespace internal
      94             : }  // namespace v8
      95             : 
      96             : #endif  // V8_TORQUE_GLOBAL_CONTEXT_H_