1 //===-- CommandObjectHelp.cpp -----------------------------------*- 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 #include "lldb/lldb-python.h"
11
12 #include "CommandObjectHelp.h"
13
14 // C Includes
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 #include "lldb/Interpreter/CommandObjectMultiword.h"
19 #include "lldb/Interpreter/CommandInterpreter.h"
20 #include "lldb/Interpreter/Options.h"
21 #include "lldb/Interpreter/CommandReturnObject.h"
22
23 using namespace lldb;
24 using namespace lldb_private;
25
26 //-------------------------------------------------------------------------
27 // CommandObjectHelp
28 //-------------------------------------------------------------------------
29
CommandObjectHelp(CommandInterpreter & interpreter)30 CommandObjectHelp::CommandObjectHelp (CommandInterpreter &interpreter) :
31 CommandObjectParsed (interpreter,
32 "help",
33 "Show a list of all debugger commands, or give details about specific commands.",
34 "help [<cmd-name>]"), m_options (interpreter)
35 {
36 CommandArgumentEntry arg;
37 CommandArgumentData command_arg;
38
39 // Define the first (and only) variant of this arg.
40 command_arg.arg_type = eArgTypeCommandName;
41 command_arg.arg_repetition = eArgRepeatStar;
42
43 // There is only one variant this argument could be; put it into the argument entry.
44 arg.push_back (command_arg);
45
46 // Push the data for the first argument into the m_arguments vector.
47 m_arguments.push_back (arg);
48 }
49
~CommandObjectHelp()50 CommandObjectHelp::~CommandObjectHelp()
51 {
52 }
53
54 OptionDefinition
55 CommandObjectHelp::CommandOptions::g_option_table[] =
56 {
57 { LLDB_OPT_SET_ALL, false, "show-aliases", 'a', no_argument, NULL, 0, eArgTypeNone, "Show aliases in the command list."},
58 { LLDB_OPT_SET_ALL, false, "hide-user-commands", 'u', no_argument, NULL, 0, eArgTypeNone, "Hide user-defined commands from the list."},
59 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
60 };
61
62 bool
DoExecute(Args & command,CommandReturnObject & result)63 CommandObjectHelp::DoExecute (Args& command, CommandReturnObject &result)
64 {
65 CommandObject::CommandMap::iterator pos;
66 CommandObject *cmd_obj;
67 const size_t argc = command.GetArgumentCount ();
68
69 // 'help' doesn't take any arguments, other than command names. If argc is 0, we show the user
70 // all commands (aliases and user commands if asked for). Otherwise every argument must be the name of a command or a sub-command.
71 if (argc == 0)
72 {
73 uint32_t cmd_types = CommandInterpreter::eCommandTypesBuiltin;
74 if (m_options.m_show_aliases)
75 cmd_types |= CommandInterpreter::eCommandTypesAliases;
76 if (m_options.m_show_user_defined)
77 cmd_types |= CommandInterpreter::eCommandTypesUserDef;
78
79 result.SetStatus (eReturnStatusSuccessFinishNoResult);
80 m_interpreter.GetHelp (result, cmd_types); // General help
81 }
82 else
83 {
84 // Get command object for the first command argument. Only search built-in command dictionary.
85 StringList matches;
86 cmd_obj = m_interpreter.GetCommandObject (command.GetArgumentAtIndex (0), &matches);
87 bool is_alias_command = m_interpreter.AliasExists (command.GetArgumentAtIndex (0));
88 std::string alias_name = command.GetArgumentAtIndex(0);
89
90 if (cmd_obj != NULL)
91 {
92 StringList matches;
93 bool all_okay = true;
94 CommandObject *sub_cmd_obj = cmd_obj;
95 // Loop down through sub_command dictionaries until we find the command object that corresponds
96 // to the help command entered.
97 for (size_t i = 1; i < argc && all_okay; ++i)
98 {
99 std::string sub_command = command.GetArgumentAtIndex(i);
100 matches.Clear();
101 if (! sub_cmd_obj->IsMultiwordObject ())
102 {
103 all_okay = false;
104 }
105 else
106 {
107 CommandObject *found_cmd;
108 found_cmd = sub_cmd_obj->GetSubcommandObject(sub_command.c_str(), &matches);
109 if (found_cmd == NULL)
110 all_okay = false;
111 else if (matches.GetSize() > 1)
112 all_okay = false;
113 else
114 sub_cmd_obj = found_cmd;
115 }
116 }
117
118 if (!all_okay || (sub_cmd_obj == NULL))
119 {
120 std::string cmd_string;
121 command.GetCommandString (cmd_string);
122 if (matches.GetSize() >= 2)
123 {
124 StreamString s;
125 s.Printf ("ambiguous command %s", cmd_string.c_str());
126 size_t num_matches = matches.GetSize();
127 for (size_t match_idx = 0; match_idx < num_matches; match_idx++)
128 {
129 s.Printf ("\n\t%s", matches.GetStringAtIndex(match_idx));
130 }
131 s.Printf ("\n");
132 result.AppendError(s.GetData());
133 result.SetStatus (eReturnStatusFailed);
134 return false;
135 }
136 else if (!sub_cmd_obj)
137 {
138 result.AppendErrorWithFormat("'%s' is not a known command.\n"
139 "Try 'help' to see a current list of commands.\n",
140 cmd_string.c_str());
141 result.SetStatus (eReturnStatusFailed);
142 return false;
143 }
144 else
145 {
146 result.GetOutputStream().Printf("'%s' is not a known command.\n"
147 "Try 'help' to see a current list of commands.\n"
148 "The closest match is '%s'. Help on it follows.\n\n",
149 cmd_string.c_str(),
150 sub_cmd_obj->GetCommandName());
151 }
152 }
153
154 sub_cmd_obj->GenerateHelpText(result);
155
156 if (is_alias_command)
157 {
158 StreamString sstr;
159 m_interpreter.GetAliasHelp (alias_name.c_str(), cmd_obj->GetCommandName(), sstr);
160 result.GetOutputStream().Printf ("\n'%s' is an abbreviation for %s\n", alias_name.c_str(), sstr.GetData());
161 }
162 }
163 else if (matches.GetSize() > 0)
164 {
165 Stream &output_strm = result.GetOutputStream();
166 output_strm.Printf("Help requested with ambiguous command name, possible completions:\n");
167 const size_t match_count = matches.GetSize();
168 for (size_t i = 0; i < match_count; i++)
169 {
170 output_strm.Printf("\t%s\n", matches.GetStringAtIndex(i));
171 }
172 }
173 else
174 {
175 // Maybe the user is asking for help about a command argument rather than a command.
176 const CommandArgumentType arg_type = CommandObject::LookupArgumentName (command.GetArgumentAtIndex (0));
177 if (arg_type != eArgTypeLastArg)
178 {
179 Stream &output_strm = result.GetOutputStream ();
180 CommandObject::GetArgumentHelp (output_strm, arg_type, m_interpreter);
181 result.SetStatus (eReturnStatusSuccessFinishNoResult);
182 }
183 else
184 {
185 result.AppendErrorWithFormat
186 ("'%s' is not a known command.\nTry 'help' to see a current list of commands.\n",
187 command.GetArgumentAtIndex(0));
188 result.SetStatus (eReturnStatusFailed);
189 }
190 }
191 }
192
193 return result.Succeeded();
194 }
195
196 int
HandleCompletion(Args & input,int & cursor_index,int & cursor_char_position,int match_start_point,int max_return_elements,bool & word_complete,StringList & matches)197 CommandObjectHelp::HandleCompletion
198 (
199 Args &input,
200 int &cursor_index,
201 int &cursor_char_position,
202 int match_start_point,
203 int max_return_elements,
204 bool &word_complete,
205 StringList &matches
206 )
207 {
208 // Return the completions of the commands in the help system:
209 if (cursor_index == 0)
210 {
211 return m_interpreter.HandleCompletionMatches (input,
212 cursor_index,
213 cursor_char_position,
214 match_start_point,
215 max_return_elements,
216 word_complete,
217 matches);
218 }
219 else
220 {
221 CommandObject *cmd_obj = m_interpreter.GetCommandObject (input.GetArgumentAtIndex(0));
222
223 // The command that they are getting help on might be ambiguous, in which case we should complete that,
224 // otherwise complete with the command the user is getting help on...
225
226 if (cmd_obj)
227 {
228 input.Shift();
229 cursor_index--;
230 return cmd_obj->HandleCompletion (input,
231 cursor_index,
232 cursor_char_position,
233 match_start_point,
234 max_return_elements,
235 word_complete,
236 matches);
237 }
238 else
239 {
240 return m_interpreter.HandleCompletionMatches (input,
241 cursor_index,
242 cursor_char_position,
243 match_start_point,
244 max_return_elements,
245 word_complete,
246 matches);
247 }
248 }
249 }
250