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