lldb/source/Plugins/ExpressionParser/Clang/ClangUtilityFunction.h

   1 //===-- ClangUtilityFunction.h ----------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H
  10 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H
  11
  12 #include <map>
  13 #include <string>
  14 #include <vector>
  15
  16 #include "ClangExpressionHelper.h"
  17
  18 #include "lldb/Expression/UtilityFunction.h"
  19 #include "lldb/lldb-forward.h"
  20 #include "lldb/lldb-private.h"
  21
  22 namespace lldb_private {
  23
  24 /// \class ClangUtilityFunction ClangUtilityFunction.h
  25 /// "lldb/Expression/ClangUtilityFunction.h" Encapsulates a single expression
  26 /// for use with Clang
  27 ///
  28 /// LLDB uses expressions for various purposes, notably to call functions
  29 /// and as a backend for the expr command.  ClangUtilityFunction encapsulates
  30 /// a self-contained function meant to be used from other code.  Utility
  31 /// functions can perform error-checking for ClangUserExpressions, or can
  32 /// simply provide a way to push a function into the target for the debugger
  33 /// to call later on.
  34 class ClangUtilityFunction : public UtilityFunction {
  35   // LLVM RTTI support
  36   static char ID;
  37
  38 public:
  39   bool isA(const void *ClassID) const override {
  40     return ClassID == &ID || UtilityFunction::isA(ClassID);
  41   }
  42   static bool classof(const Expression *obj) { return obj->isA(&ID); }
  43
  44   /// Constructor
  45   ///
  46   /// \param[in] text
  47   ///     The text of the function.  Must be a full translation unit.
  48   ///
  49   /// \param[in] name
  50   ///     The name of the function, as used in the text.
  51   ///
  52   /// \param[in] enable_debugging
  53   ///     Enable debugging of this function.
  54   ClangUtilityFunction(ExecutionContextScope &exe_scope, std::string text,
  55                        std::string name, bool enable_debugging);
  56
  57   ~ClangUtilityFunction() override;
  58
  59   ExpressionTypeSystemHelper *GetTypeSystemHelper() override {
  60     return &m_type_system_helper;
  61   }
  62
  63   ClangExpressionDeclMap *DeclMap() { return m_type_system_helper.DeclMap(); }
  64
  65   void ResetDeclMap() { m_type_system_helper.ResetDeclMap(); }
  66
  67   void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory) {
  68     m_type_system_helper.ResetDeclMap(exe_ctx, keep_result_in_memory);
  69   }
  70
  71   bool Install(DiagnosticManager &diagnostic_manager,
  72                ExecutionContext &exe_ctx) override;
  73
  74 private:
  75   class ClangUtilityFunctionHelper
  76       : public llvm::RTTIExtends<ClangUtilityFunctionHelper,
  77                                  ClangExpressionHelper> {
  78   public:
  79     // LLVM RTTI support
  80     static char ID;
  81
  82     /// Return the object that the parser should use when resolving external
  83     /// values.  May be NULL if everything should be self-contained.
  84     ClangExpressionDeclMap *DeclMap() override {
  85       return m_expr_decl_map_up.get();
  86     }
  87
  88     void ResetDeclMap() { m_expr_decl_map_up.reset(); }
  89
  90     void ResetDeclMap(ExecutionContext &exe_ctx, bool keep_result_in_memory);
  91
  92     /// Return the object that the parser should allow to access ASTs. May be
  93     /// nullptr if the ASTs do not need to be transformed.
  94     ///
  95     /// \param[in] passthrough
  96     ///     The ASTConsumer that the returned transformer should send
  97     ///     the ASTs to after transformation.
  98     clang::ASTConsumer *
  99     ASTTransformer(clang::ASTConsumer *passthrough) override {
 100       return nullptr;
 101     }
 102
 103   private:
 104     std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map_up;
 105   };
 106
 107   /// The map to use when parsing and materializing the expression.
 108   ClangUtilityFunctionHelper m_type_system_helper;
 109 };
 110
 111 } // namespace lldb_private
 112
 113 #endif // LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGUTILITYFUNCTION_H