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
16namespace lldb {
17
18class SBCommandInterpreter
19{
20public:
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
125protected:
126
127    lldb_private::CommandInterpreter &
128    ref ();
129
130    lldb_private::CommandInterpreter *
131    get ();
132
133    void
134    reset (lldb_private::CommandInterpreter *);
135private:
136    friend class SBDebugger;
137
138    static void
139    InitializeSWIG ();
140
141    lldb_private::CommandInterpreter *m_opaque_ptr;
142};
143
144class SBCommandPluginInterface
145{
146public:
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
160class SBCommand
161{
162public:
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
181private:
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