• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- ExpressionParser.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_EXPRESSION_EXPRESSIONPARSER_H
10 #define LLDB_EXPRESSION_EXPRESSIONPARSER_H
11 
12 #include "lldb/Utility/CompletionRequest.h"
13 #include "lldb/Utility/Status.h"
14 #include "lldb/lldb-private-enumerations.h"
15 #include "lldb/lldb-public.h"
16 
17 namespace lldb_private {
18 
19 class IRExecutionUnit;
20 
21 /// \class ExpressionParser ExpressionParser.h
22 /// "lldb/Expression/ExpressionParser.h" Encapsulates an instance of a
23 /// compiler that can parse expressions.
24 ///
25 /// ExpressionParser is the base class for llvm based Expression parsers.
26 class ExpressionParser {
27 public:
28   /// Constructor
29   ///
30   /// Initializes class variables.
31   ///
32   /// \param[in] exe_scope
33   ///     If non-NULL, an execution context scope that can help to
34   ///     correctly create an expression with a valid process for
35   ///     optional tuning Objective-C runtime support. Can be NULL.
36   ///
37   /// \param[in] expr
38   ///     The expression to be parsed.
ExpressionParser(ExecutionContextScope * exe_scope,Expression & expr,bool generate_debug_info)39   ExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
40                    bool generate_debug_info)
41       : m_expr(expr), m_generate_debug_info(generate_debug_info) {}
42 
43   /// Destructor
~ExpressionParser()44   virtual ~ExpressionParser(){};
45 
46   /// Attempts to find possible command line completions for the given
47   /// expression.
48   ///
49   /// \param[out] request
50   ///     The completion request to fill out. The completion should be a string
51   ///     that would complete the current token at the cursor position.
52   ///     Note that the string in the list replaces the current token
53   ///     in the command line.
54   ///
55   /// \param[in] line
56   ///     The line with the completion cursor inside the expression as a string.
57   ///     The first line in the expression has the number 0.
58   ///
59   /// \param[in] pos
60   ///     The character position in the line with the completion cursor.
61   ///     If the value is 0, then the cursor is on top of the first character
62   ///     in the line (i.e. the user has requested completion from the start of
63   ///     the expression).
64   ///
65   /// \param[in] typed_pos
66   ///     The cursor position in the line as typed by the user. If the user
67   ///     expression has not been transformed in some form (e.g. wrapping it
68   ///     in a function body for C languages), then this is equal to the
69   ///     'pos' parameter. The semantics of this value are otherwise equal to
70   ///     'pos' (e.g. a value of 0 means the cursor is at start of the
71   ///     expression).
72   ///
73   /// \return
74   ///     True if we added any completion results to the output;
75   ///     false otherwise.
76   virtual bool Complete(CompletionRequest &request, unsigned line, unsigned pos,
77                         unsigned typed_pos) = 0;
78 
79   /// Try to use the FixIts in the diagnostic_manager to rewrite the
80   /// expression.  If successful, the rewritten expression is stored in the
81   /// diagnostic_manager, get it out with GetFixedExpression.
82   ///
83   /// \param[in] diagnostic_manager
84   ///     The diagnostic manager containing fixit's to apply.
85   ///
86   /// \return
87   ///     \b true if the rewrite was successful, \b false otherwise.
RewriteExpression(DiagnosticManager & diagnostic_manager)88   virtual bool RewriteExpression(DiagnosticManager &diagnostic_manager) {
89     return false;
90   }
91 
92   /// Ready an already-parsed expression for execution, possibly evaluating it
93   /// statically.
94   ///
95   /// \param[out] func_addr
96   ///     The address to which the function has been written.
97   ///
98   /// \param[out] func_end
99   ///     The end of the function's allocated memory region.  (func_addr
100   ///     and func_end do not delimit an allocated region; the allocated
101   ///     region may begin before func_addr.)
102   ///
103   /// \param[in] execution_unit_sp
104   ///     After parsing, ownership of the execution unit for
105   ///     for the expression is handed to this shared pointer.
106   ///
107   /// \param[in] exe_ctx
108   ///     The execution context to write the function into.
109   ///
110   /// \param[out] can_interpret
111   ///     Set to true if the expression could be interpreted statically;
112   ///     untouched otherwise.
113   ///
114   /// \param[in] execution_policy
115   ///     Determines whether the expression must be JIT-compiled, must be
116   ///     evaluated statically, or whether this decision may be made
117   ///     opportunistically.
118   ///
119   /// \return
120   ///     An error code indicating the success or failure of the operation.
121   ///     Test with Success().
122   virtual Status
123   PrepareForExecution(lldb::addr_t &func_addr, lldb::addr_t &func_end,
124                       std::shared_ptr<IRExecutionUnit> &execution_unit_sp,
125                       ExecutionContext &exe_ctx, bool &can_interpret,
126                       lldb_private::ExecutionPolicy execution_policy) = 0;
127 
GetGenerateDebugInfo()128   bool GetGenerateDebugInfo() const { return m_generate_debug_info; }
129 
130 protected:
131   Expression &m_expr; ///< The expression to be parsed
132   bool m_generate_debug_info;
133 };
134 }
135 
136 #endif // LLDB_EXPRESSION_EXPRESSIONPARSER_H
137