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