LLVM: SBCommandInterpreter.h Source File
Description: C++ source code API documentation for LLDB.
Keywords: LLDB,C++,doxygen,API,documentation

LLDB API Documentation

- Main Page
- Namespaces
- Classes
- Files

- File List

SBCommandInterpreter.h
Go to the documentation of this file.
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
148 DoExecute (lldb::SBDebugger debugger,
149 char** command,
150 lldb::SBCommandReturnObject &result)
151 {
152 return false;
153 }
154
155 virtual
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_