1//===-- SWIG Interface for SBCommandInterpreter -----------------*- 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
9namespace lldb {
10
11%feature("docstring",
12"SBCommandInterpreterRunOptions controls how the RunCommandInterpreter runs the code it is fed.
13A default SBCommandInterpreterRunOptions object has:
14    StopOnContinue: false
15    StopOnError:    false
16    StopOnCrash:    false
17    EchoCommands:   true
18    PrintResults:   true
19    AddToHistory:   true
20
21") SBCommandInterpreterRunOptions;
22class SBCommandInterpreterRunOptions
23{
24friend class SBDebugger;
25public:
26    SBCommandInterpreterRunOptions();
27    ~SBCommandInterpreterRunOptions();
28
29    bool
30    GetStopOnContinue () const;
31
32    void
33    SetStopOnContinue (bool);
34
35    bool
36    GetStopOnError () const;
37
38    void
39    SetStopOnError (bool);
40
41    bool
42    GetStopOnCrash () const;
43
44    void
45    SetStopOnCrash (bool);
46
47    bool
48    GetEchoCommands () const;
49
50    void
51    SetEchoCommands (bool);
52
53    bool
54    GetPrintResults () const;
55
56    void
57    SetPrintResults (bool);
58
59    bool
60    GetAddToHistory () const;
61
62    void
63    SetAddToHistory (bool);
64private:
65    lldb_private::CommandInterpreterRunOptions *
66    get () const;
67
68    lldb_private::CommandInterpreterRunOptions &
69    ref () const;
70
71    // This is set in the constructor and will always be valid.
72    mutable std::unique_ptr<lldb_private::CommandInterpreterRunOptions> m_opaque_up;
73};
74
75%feature("docstring",
76"SBCommandInterpreter handles/interprets commands for lldb.  You get the
77command interpreter from the SBDebugger instance. For example (from test/
78python_api/interpreter/TestCommandInterpreterAPI.py),
79
80    def command_interpreter_api(self):
81        '''Test the SBCommandInterpreter APIs.'''
82        exe = os.path.join(os.getcwd(), 'a.out')
83
84        # Create a target by the debugger.
85        target = self.dbg.CreateTarget(exe)
86        self.assertTrue(target, VALID_TARGET)
87
88        # Retrieve the associated command interpreter from our debugger.
89        ci = self.dbg.GetCommandInterpreter()
90        self.assertTrue(ci, VALID_COMMAND_INTERPRETER)
91
92        # Exercise some APIs....
93
94        self.assertTrue(ci.HasCommands())
95        self.assertTrue(ci.HasAliases())
96        self.assertTrue(ci.HasAliasOptions())
97        self.assertTrue(ci.CommandExists('breakpoint'))
98        self.assertTrue(ci.CommandExists('target'))
99        self.assertTrue(ci.CommandExists('platform'))
100        self.assertTrue(ci.AliasExists('file'))
101        self.assertTrue(ci.AliasExists('run'))
102        self.assertTrue(ci.AliasExists('bt'))
103
104        res = lldb.SBCommandReturnObject()
105        ci.HandleCommand('breakpoint set -f main.c -l %d' % self.line, res)
106        self.assertTrue(res.Succeeded())
107        ci.HandleCommand('process launch', res)
108        self.assertTrue(res.Succeeded())
109
110        process = ci.GetProcess()
111        self.assertTrue(process)
112
113        ...
114
115The HandleCommand() instance method takes two args: the command string and
116an SBCommandReturnObject instance which encapsulates the result of command
117execution.") SBCommandInterpreter;
118class SBCommandInterpreter
119{
120public:
121    enum
122    {
123        eBroadcastBitThreadShouldExit       = (1 << 0),
124        eBroadcastBitResetPrompt            = (1 << 1),
125        eBroadcastBitQuitCommandReceived    = (1 << 2),           // User entered quit
126        eBroadcastBitAsynchronousOutputData = (1 << 3),
127        eBroadcastBitAsynchronousErrorData  = (1 << 4)
128    };
129
130    SBCommandInterpreter (const lldb::SBCommandInterpreter &rhs);
131
132    ~SBCommandInterpreter ();
133
134    static const char *
135    GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
136
137    static const char *
138    GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type);
139
140    static bool
141    EventIsCommandInterpreterEvent (const lldb::SBEvent &event);
142
143    bool
144    IsValid() const;
145
146    explicit operator bool() const;
147
148    const char *
149    GetIOHandlerControlSequence(char ch);
150
151    bool
152    GetPromptOnQuit();
153
154    void
155    SetPromptOnQuit(bool b);
156
157    void
158    AllowExitCodeOnQuit(bool b);
159
160    bool
161    HasCustomQuitExitCode();
162
163    int
164    GetQuitStatus();
165
166    void
167    ResolveCommand(const char *command_line, SBCommandReturnObject &result);
168
169    bool
170    CommandExists (const char *cmd);
171
172    bool
173    AliasExists (const char *cmd);
174
175    lldb::SBBroadcaster
176    GetBroadcaster ();
177
178    static const char *
179    GetBroadcasterClass ();
180
181    bool
182    HasCommands ();
183
184    bool
185    HasAliases ();
186
187    bool
188    HasAliasOptions ();
189
190    lldb::SBProcess
191    GetProcess ();
192
193    lldb::SBDebugger
194    GetDebugger ();
195
196    void
197    SourceInitFileInHomeDirectory (lldb::SBCommandReturnObject &result);
198
199    void
200    SourceInitFileInCurrentWorkingDirectory (lldb::SBCommandReturnObject &result);
201
202    lldb::ReturnStatus
203    HandleCommand (const char *command_line, lldb::SBCommandReturnObject &result, bool add_to_history = false);
204
205    lldb::ReturnStatus
206    HandleCommand (const char *command_line, SBExecutionContext &exe_ctx, SBCommandReturnObject &result, bool add_to_history = false);
207
208    void
209    HandleCommandsFromFile (lldb::SBFileSpec &file,
210                            lldb::SBExecutionContext &override_context,
211                            lldb::SBCommandInterpreterRunOptions &options,
212                            lldb::SBCommandReturnObject result);
213
214    int
215    HandleCompletion (const char *current_line,
216                      uint32_t cursor_pos,
217                      int match_start_point,
218                      int max_return_elements,
219                      lldb::SBStringList &matches);
220
221    int
222    HandleCompletionWithDescriptions (const char *current_line,
223                                      uint32_t cursor_pos,
224                                      int match_start_point,
225                                      int max_return_elements,
226                                      lldb::SBStringList &matches,
227                                      lldb::SBStringList &descriptions);
228    bool
229    IsActive ();
230
231    bool
232    WasInterrupted () const;
233};
234
235} // namespace lldb
236