| //===-- REPL.h --------------------------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_EXPRESSION_REPL_H |
| #define LLDB_EXPRESSION_REPL_H |
| |
| #include <string> |
| |
| #include "lldb/Core/IOHandler.h" |
| #include "lldb/Interpreter/OptionGroupFormat.h" |
| #include "lldb/Interpreter/OptionGroupValueObjectDisplay.h" |
| #include "lldb/Target/Target.h" |
| #include "llvm/Support/ExtensibleRTTI.h" |
| |
| namespace lldb_private { |
| |
| class REPL : public IOHandlerDelegate, |
| public llvm::RTTIExtends<REPL, llvm::RTTIRoot> { |
| public: |
| /// LLVM RTTI support |
| static char ID; |
| |
| REPL(Target &target); |
| |
| ~REPL() override; |
| |
| /// Get a REPL with an existing target (or, failing that, a debugger to use), |
| /// and (optional) extra arguments for the compiler. |
| /// |
| /// \param[out] Status |
| /// If this language is supported but the REPL couldn't be created, this |
| /// error is populated with the reason. |
| /// |
| /// \param[in] language |
| /// The language to create a REPL for. |
| /// |
| /// \param[in] debugger |
| /// If provided, and target is nullptr, the debugger to use when setting |
| /// up a top-level REPL. |
| /// |
| /// \param[in] target |
| /// If provided, the target to put the REPL inside. |
| /// |
| /// \param[in] repl_options |
| /// If provided, additional options for the compiler when parsing REPL |
| /// expressions. |
| /// |
| /// \return |
| /// The range of the containing object in the target process. |
| static lldb::REPLSP Create(Status &Status, lldb::LanguageType language, |
| Debugger *debugger, Target *target, |
| const char *repl_options); |
| |
| void SetFormatOptions(const OptionGroupFormat &options) { |
| m_format_options = options; |
| } |
| |
| void |
| SetValueObjectDisplayOptions(const OptionGroupValueObjectDisplay &options) { |
| m_varobj_options = options; |
| } |
| |
| void SetEvaluateOptions(const EvaluateExpressionOptions &options) { |
| m_expr_options = options; |
| } |
| |
| void SetCompilerOptions(const char *options) { |
| if (options) |
| m_compiler_options = options; |
| } |
| |
| lldb::IOHandlerSP GetIOHandler(); |
| |
| Status RunLoop(); |
| |
| // IOHandler::Delegate functions |
| void IOHandlerActivated(IOHandler &io_handler, bool interactive) override; |
| |
| bool IOHandlerInterrupt(IOHandler &io_handler) override; |
| |
| void IOHandlerInputInterrupted(IOHandler &io_handler, |
| std::string &line) override; |
| |
| const char *IOHandlerGetFixIndentationCharacters() override; |
| |
| llvm::StringRef IOHandlerGetControlSequence(char ch) override; |
| |
| const char *IOHandlerGetCommandPrefix() override; |
| |
| const char *IOHandlerGetHelpPrologue() override; |
| |
| bool IOHandlerIsInputComplete(IOHandler &io_handler, |
| StringList &lines) override; |
| |
| int IOHandlerFixIndentation(IOHandler &io_handler, const StringList &lines, |
| int cursor_position) override; |
| |
| void IOHandlerInputComplete(IOHandler &io_handler, |
| std::string &line) override; |
| |
| void IOHandlerComplete(IOHandler &io_handler, |
| CompletionRequest &request) override; |
| |
| protected: |
| /// Method that can be optionally overriden by subclasses to get notified |
| /// whenever an expression has been evaluated. The params of this method |
| /// include the inputs and outputs of the expression evaluation. |
| /// |
| /// Note: meta commands that start with : are not covered by this method. |
| /// |
| /// \return |
| /// An \a Error object that, if it is a failure, aborts the regular |
| /// REPL expression result handling. |
| virtual llvm::Error |
| OnExpressionEvaluated(const ExecutionContext &exe_ctx, llvm::StringRef code, |
| const EvaluateExpressionOptions &expr_options, |
| lldb::ExpressionResults execution_results, |
| const lldb::ValueObjectSP &result_valobj_sp, |
| const Status &error) { |
| return llvm::Error::success(); |
| } |
| |
| static int CalculateActualIndentation(const StringList &lines); |
| |
| // Subclasses should override these functions to implement a functional REPL. |
| |
| virtual Status DoInitialization() = 0; |
| |
| virtual llvm::StringRef GetSourceFileBasename() = 0; |
| |
| virtual const char *GetAutoIndentCharacters() = 0; |
| |
| virtual bool SourceIsComplete(const std::string &source) = 0; |
| |
| virtual lldb::offset_t GetDesiredIndentation( |
| const StringList &lines, int cursor_position, |
| int tab_size) = 0; // LLDB_INVALID_OFFSET means no change |
| |
| virtual lldb::LanguageType GetLanguage() = 0; |
| |
| virtual bool PrintOneVariable(Debugger &debugger, |
| lldb::StreamFileSP &output_sp, |
| lldb::ValueObjectSP &valobj_sp, |
| ExpressionVariable *var = nullptr) = 0; |
| |
| virtual void CompleteCode(const std::string ¤t_code, |
| CompletionRequest &request) = 0; |
| |
| OptionGroupFormat m_format_options = OptionGroupFormat(lldb::eFormatDefault); |
| OptionGroupValueObjectDisplay m_varobj_options; |
| EvaluateExpressionOptions m_expr_options; |
| std::string m_compiler_options; |
| |
| bool m_enable_auto_indent = true; |
| std::string m_indent_str; // Use this string for each level of indentation |
| std::string m_current_indent_str; |
| uint32_t m_current_indent_level = 0; |
| |
| std::string m_repl_source_path; |
| bool m_dedicated_repl_mode = false; |
| |
| StringList m_code; // All accumulated REPL statements are saved here |
| |
| Target &m_target; |
| lldb::IOHandlerSP m_io_handler_sp; |
| |
| private: |
| std::string GetSourcePath(); |
| }; |
| |
| } // namespace lldb_private |
| |
| #endif // LLDB_EXPRESSION_REPL_H |