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