1 //===-- SBCommandInterpreter.h ----------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #ifndef LLDB_SBCommandInterpreter_h_ 11 #define LLDB_SBCommandInterpreter_h_ 12 13 #include "lldb/API/SBDefines.h" 14 #include "lldb/API/SBDebugger.h" 15 16 namespace lldb { 17 18 class SBCommandInterpreter 19 { 20 public: 21 enum 22 { 23 eBroadcastBitThreadShouldExit = (1 << 0), 24 eBroadcastBitResetPrompt = (1 << 1), 25 eBroadcastBitQuitCommandReceived = (1 << 2), // User entered quit 26 eBroadcastBitAsynchronousOutputData = (1 << 3), 27 eBroadcastBitAsynchronousErrorData = (1 << 4) 28 }; 29 30 SBCommandInterpreter (const lldb::SBCommandInterpreter &rhs); 31 32 const lldb::SBCommandInterpreter & 33 operator = (const lldb::SBCommandInterpreter &rhs); 34 35 ~SBCommandInterpreter (); 36 37 static const char * 38 GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type); 39 40 static const char * 41 GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type); 42 43 bool 44 IsValid() const; 45 46 bool 47 CommandExists (const char *cmd); 48 49 bool 50 AliasExists (const char *cmd); 51 52 lldb::SBBroadcaster 53 GetBroadcaster (); 54 55 static const char * 56 GetBroadcasterClass (); 57 58 bool 59 HasCommands (); 60 61 bool 62 HasAliases (); 63 64 bool 65 HasAliasOptions (); 66 67 lldb::SBProcess 68 GetProcess (); 69 70 lldb::SBDebugger 71 GetDebugger (); 72 73 lldb::SBCommand 74 AddMultiwordCommand (const char* name, const char* help); 75 76 lldb::SBCommand 77 AddCommand (const char* name, lldb::SBCommandPluginInterface *impl, const char* help); 78 79 void 80 SourceInitFileInHomeDirectory (lldb::SBCommandReturnObject &result); 81 82 void 83 SourceInitFileInCurrentWorkingDirectory (lldb::SBCommandReturnObject &result); 84 85 lldb::ReturnStatus 86 HandleCommand (const char *command_line, lldb::SBCommandReturnObject &result, bool add_to_history = false); 87 88 // The pointer based interface is not useful in SWIG, since the cursor & last_char arguments are string pointers INTO current_line 89 // and you can't do that in a scripting language interface in general... 90 91 // In either case, the way this works is that the you give it a line and cursor position in the line. The function 92 // will return the number of completions. The matches list will contain number_of_completions + 1 elements. The first 93 // element is the common substring after the cursor position for all the matches. The rest of the elements are the 94 // matches. The first element is useful if you are emulating the common shell behavior where the tab completes 95 // to the string that is common among all the matches, then you should first check if the first element is non-empty, 96 // and if so just insert it and move the cursor to the end of the insertion. The next tab will return an empty 97 // common substring, and a list of choices (if any), at which point you should display the choices and let the user 98 // type further to disambiguate. 99 100 int 101 HandleCompletion (const char *current_line, 102 const char *cursor, 103 const char *last_char, 104 int match_start_point, 105 int max_return_elements, 106 lldb::SBStringList &matches); 107 108 int 109 HandleCompletion (const char *current_line, 110 uint32_t cursor_pos, 111 int match_start_point, 112 int max_return_elements, 113 lldb::SBStringList &matches); 114 115 // Catch commands before they execute by registering a callback that will 116 // get called when the command gets executed. This allows GUI or command 117 // line interfaces to intercept a command and stop it from happening 118 bool 119 SetCommandOverrideCallback (const char *command_name, 120 lldb::CommandOverrideCallback callback, 121 void *baton); 122 123 SBCommandInterpreter (lldb_private::CommandInterpreter *interpreter_ptr = NULL); // Access using SBDebugger::GetCommandInterpreter(); 124 125 protected: 126 127 lldb_private::CommandInterpreter & 128 ref (); 129 130 lldb_private::CommandInterpreter * 131 get (); 132 133 void 134 reset (lldb_private::CommandInterpreter *); 135 private: 136 friend class SBDebugger; 137 138 static void 139 InitializeSWIG (); 140 141 lldb_private::CommandInterpreter *m_opaque_ptr; 142 }; 143 144 class SBCommandPluginInterface 145 { 146 public: 147 virtual bool DoExecute(lldb::SBDebugger debugger,char ** command,lldb::SBCommandReturnObject & result)148 DoExecute (lldb::SBDebugger debugger, 149 char** command, 150 lldb::SBCommandReturnObject &result) 151 { 152 return false; 153 } 154 155 virtual ~SBCommandPluginInterface()156 ~SBCommandPluginInterface () 157 {} 158 }; 159 160 class SBCommand 161 { 162 public: 163 164 SBCommand (); 165 166 bool 167 IsValid (); 168 169 const char* 170 GetName (); 171 172 const char* 173 GetHelp (); 174 175 lldb::SBCommand 176 AddMultiwordCommand (const char* name, const char* help = NULL); 177 178 lldb::SBCommand 179 AddCommand (const char* name, lldb::SBCommandPluginInterface* impl, const char* help = NULL); 180 181 private: 182 183 friend class SBDebugger; 184 friend class SBCommandInterpreter; 185 186 SBCommand (lldb::CommandObjectSP cmd_sp); 187 188 lldb::CommandObjectSP m_opaque_sp; 189 }; 190 191 } // namespace lldb 192 193 #endif // LLDB_SBCommandInterpreter_h_ 194