1 //===-- CommandInterpreter.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 <string> 11 #include <vector> 12 13 #include <getopt.h> 14 #include <stdlib.h> 15 16 #include "../Commands/CommandObjectApropos.h" 17 #include "../Commands/CommandObjectArgs.h" 18 #include "../Commands/CommandObjectBreakpoint.h" 19 //#include "../Commands/CommandObjectCall.h" 20 #include "../Commands/CommandObjectDisassemble.h" 21 #include "../Commands/CommandObjectExpression.h" 22 //#include "../Commands/CommandObjectFile.h" 23 #include "../Commands/CommandObjectFrame.h" 24 #include "../Commands/CommandObjectHelp.h" 25 #include "../Commands/CommandObjectImage.h" 26 #include "../Commands/CommandObjectLog.h" 27 #include "../Commands/CommandObjectMemory.h" 28 #include "../Commands/CommandObjectPlatform.h" 29 #include "../Commands/CommandObjectProcess.h" 30 #include "../Commands/CommandObjectQuit.h" 31 #include "lldb/Interpreter/CommandObjectRegexCommand.h" 32 #include "../Commands/CommandObjectRegister.h" 33 #include "CommandObjectScript.h" 34 #include "../Commands/CommandObjectSettings.h" 35 #include "../Commands/CommandObjectSource.h" 36 #include "../Commands/CommandObjectCommands.h" 37 #include "../Commands/CommandObjectSyntax.h" 38 #include "../Commands/CommandObjectTarget.h" 39 #include "../Commands/CommandObjectThread.h" 40 #include "../Commands/CommandObjectVersion.h" 41 42 #include "lldb/Interpreter/Args.h" 43 #include "lldb/Core/Debugger.h" 44 #include "lldb/Core/InputReader.h" 45 #include "lldb/Core/Stream.h" 46 #include "lldb/Core/Timer.h" 47 #include "lldb/Host/Host.h" 48 #include "lldb/Target/Process.h" 49 #include "lldb/Target/Thread.h" 50 #include "lldb/Target/TargetList.h" 51 #include "lldb/Utility/CleanUp.h" 52 53 #include "lldb/Interpreter/CommandReturnObject.h" 54 #include "lldb/Interpreter/CommandInterpreter.h" 55 #include "lldb/Interpreter/ScriptInterpreterNone.h" 56 #include "lldb/Interpreter/ScriptInterpreterPython.h" 57 58 using namespace lldb; 59 using namespace lldb_private; 60 61 CommandInterpreter::CommandInterpreter 62 ( 63 Debugger &debugger, 64 ScriptLanguage script_language, 65 bool synchronous_execution 66 ) : 67 Broadcaster ("lldb.command-interpreter"), 68 m_debugger (debugger), 69 m_synchronous_execution (synchronous_execution), 70 m_skip_lldbinit_files (false), 71 m_script_interpreter_ap (), 72 m_comment_char ('#') 73 { 74 const char *dbg_name = debugger.GetInstanceName().AsCString(); 75 std::string lang_name = ScriptInterpreter::LanguageToString (script_language); 76 StreamString var_name; 77 var_name.Printf ("[%s].script-lang", dbg_name); 78 debugger.GetSettingsController()->SetVariable (var_name.GetData(), lang_name.c_str(), 79 eVarSetOperationAssign, false, 80 m_debugger.GetInstanceName().AsCString()); 81 SetEventName (eBroadcastBitThreadShouldExit, "thread-should-exit"); 82 SetEventName (eBroadcastBitResetPrompt, "reset-prompt"); 83 SetEventName (eBroadcastBitQuitCommandReceived, "quit"); 84 } 85 86 void 87 CommandInterpreter::Initialize () 88 { 89 Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); 90 91 CommandReturnObject result; 92 93 LoadCommandDictionary (); 94 95 // Set up some initial aliases. 96 HandleCommand ("command alias q quit", false, result); 97 HandleCommand ("command alias run process launch --", false, result); 98 HandleCommand ("command alias r process launch --", false, result); 99 HandleCommand ("command alias c process continue", false, result); 100 HandleCommand ("command alias continue process continue", false, result); 101 HandleCommand ("command alias expr expression", false, result); 102 HandleCommand ("command alias exit quit", false, result); 103 HandleCommand ("command alias b _regexp-break", false, result); 104 HandleCommand ("command alias bt thread backtrace", false, result); 105 HandleCommand ("command alias si thread step-inst", false, result); 106 HandleCommand ("command alias step thread step-in", false, result); 107 HandleCommand ("command alias s thread step-in", false, result); 108 HandleCommand ("command alias next thread step-over", false, result); 109 HandleCommand ("command alias n thread step-over", false, result); 110 HandleCommand ("command alias f thread step-out", false, result); 111 HandleCommand ("command alias finish thread step-out", false, result); 112 HandleCommand ("command alias x memory read", false, result); 113 HandleCommand ("command alias l source list", false, result); 114 HandleCommand ("command alias list source list", false, result); 115 HandleCommand ("command alias p expression --", false, result); 116 HandleCommand ("command alias print expression --", false, result); 117 HandleCommand ("command alias po expression -o --", false, result); 118 HandleCommand ("command alias up _regexp-up", false, result); 119 HandleCommand ("command alias down _regexp-down", false, result); 120 HandleCommand ("command alias file target create", false, result); 121 122 } 123 124 const char * 125 CommandInterpreter::ProcessEmbeddedScriptCommands (const char *arg) 126 { 127 // This function has not yet been implemented. 128 129 // Look for any embedded script command 130 // If found, 131 // get interpreter object from the command dictionary, 132 // call execute_one_command on it, 133 // get the results as a string, 134 // substitute that string for current stuff. 135 136 return arg; 137 } 138 139 140 void 141 CommandInterpreter::LoadCommandDictionary () 142 { 143 Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); 144 145 // **** IMPORTANT **** IMPORTANT *** IMPORTANT *** **** IMPORTANT **** IMPORTANT *** IMPORTANT *** 146 // 147 // Command objects that are used as cross reference objects (i.e. they inherit from CommandObjectCrossref) 148 // *MUST* be created and put into the command dictionary *BEFORE* any multi-word commands (which may use 149 // the cross-referencing stuff) are created!!! 150 // 151 // **** IMPORTANT **** IMPORTANT *** IMPORTANT *** **** IMPORTANT **** IMPORTANT *** IMPORTANT *** 152 153 154 // Command objects that inherit from CommandObjectCrossref must be created before other command objects 155 // are created. This is so that when another command is created that needs to go into a crossref object, 156 // the crossref object exists and is ready to take the cross reference. Put the cross referencing command 157 // objects into the CommandDictionary now, so they are ready for use when the other commands get created. 158 159 // Non-CommandObjectCrossref commands can now be created. 160 161 lldb::ScriptLanguage script_language = m_debugger.GetScriptLanguage(); 162 163 m_command_dict["apropos"] = CommandObjectSP (new CommandObjectApropos (*this)); 164 m_command_dict["breakpoint"]= CommandObjectSP (new CommandObjectMultiwordBreakpoint (*this)); 165 //m_command_dict["call"] = CommandObjectSP (new CommandObjectCall (*this)); 166 m_command_dict["command"] = CommandObjectSP (new CommandObjectMultiwordCommands (*this)); 167 m_command_dict["disassemble"] = CommandObjectSP (new CommandObjectDisassemble (*this)); 168 m_command_dict["expression"]= CommandObjectSP (new CommandObjectExpression (*this)); 169 // m_command_dict["file"] = CommandObjectSP (new CommandObjectFile (*this)); 170 m_command_dict["frame"] = CommandObjectSP (new CommandObjectMultiwordFrame (*this)); 171 m_command_dict["help"] = CommandObjectSP (new CommandObjectHelp (*this)); 172 m_command_dict["image"] = CommandObjectSP (new CommandObjectImage (*this)); 173 m_command_dict["log"] = CommandObjectSP (new CommandObjectLog (*this)); 174 m_command_dict["memory"] = CommandObjectSP (new CommandObjectMemory (*this)); 175 m_command_dict["platform"] = CommandObjectSP (new CommandObjectPlatform (*this)); 176 m_command_dict["process"] = CommandObjectSP (new CommandObjectMultiwordProcess (*this)); 177 m_command_dict["quit"] = CommandObjectSP (new CommandObjectQuit (*this)); 178 m_command_dict["register"] = CommandObjectSP (new CommandObjectRegister (*this)); 179 m_command_dict["script"] = CommandObjectSP (new CommandObjectScript (*this, script_language)); 180 m_command_dict["settings"] = CommandObjectSP (new CommandObjectMultiwordSettings (*this)); 181 m_command_dict["source"] = CommandObjectSP (new CommandObjectMultiwordSource (*this)); 182 m_command_dict["target"] = CommandObjectSP (new CommandObjectMultiwordTarget (*this)); 183 m_command_dict["thread"] = CommandObjectSP (new CommandObjectMultiwordThread (*this)); 184 m_command_dict["version"] = CommandObjectSP (new CommandObjectVersion (*this)); 185 186 std::auto_ptr<CommandObjectRegexCommand> 187 break_regex_cmd_ap(new CommandObjectRegexCommand (*this, 188 "_regexp-break", 189 "Set a breakpoint using a regular expression to specify the location.", 190 "_regexp-break [<filename>:<linenum>]\n_regexp-break [<address>]\n_regexp-break <...>", 2)); 191 if (break_regex_cmd_ap.get()) 192 { 193 if (break_regex_cmd_ap->AddRegexCommand("^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "breakpoint set --file '%1' --line %2") && 194 break_regex_cmd_ap->AddRegexCommand("^(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1") && 195 break_regex_cmd_ap->AddRegexCommand("^[\"']?([-+]\\[.*\\])[\"']?[[:space:]]*$", "breakpoint set --name '%1'") && 196 break_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full") && 197 break_regex_cmd_ap->AddRegexCommand("^(-.*)$", "breakpoint set %1") && 198 break_regex_cmd_ap->AddRegexCommand("^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%2' --shlib '%1'") && 199 break_regex_cmd_ap->AddRegexCommand("^(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%1'")) 200 { 201 CommandObjectSP break_regex_cmd_sp(break_regex_cmd_ap.release()); 202 m_command_dict[break_regex_cmd_sp->GetCommandName ()] = break_regex_cmd_sp; 203 } 204 } 205 206 std::auto_ptr<CommandObjectRegexCommand> 207 down_regex_cmd_ap(new CommandObjectRegexCommand (*this, 208 "_regexp-down", 209 "Go down \"n\" frames in the stack (1 frame by default).", 210 "_regexp-down [n]", 2)); 211 if (down_regex_cmd_ap.get()) 212 { 213 if (down_regex_cmd_ap->AddRegexCommand("^$", "frame select -r -1") && 214 down_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r -%1")) 215 { 216 CommandObjectSP down_regex_cmd_sp(down_regex_cmd_ap.release()); 217 m_command_dict[down_regex_cmd_sp->GetCommandName ()] = down_regex_cmd_sp; 218 } 219 } 220 221 std::auto_ptr<CommandObjectRegexCommand> 222 up_regex_cmd_ap(new CommandObjectRegexCommand (*this, 223 "_regexp-up", 224 "Go up \"n\" frames in the stack (1 frame by default).", 225 "_regexp-up [n]", 2)); 226 if (up_regex_cmd_ap.get()) 227 { 228 if (up_regex_cmd_ap->AddRegexCommand("^$", "frame select -r 1") && 229 up_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r %1")) 230 { 231 CommandObjectSP up_regex_cmd_sp(up_regex_cmd_ap.release()); 232 m_command_dict[up_regex_cmd_sp->GetCommandName ()] = up_regex_cmd_sp; 233 } 234 } 235 } 236 237 int 238 CommandInterpreter::GetCommandNamesMatchingPartialString (const char *cmd_str, bool include_aliases, 239 StringList &matches) 240 { 241 CommandObject::AddNamesMatchingPartialString (m_command_dict, cmd_str, matches); 242 243 if (include_aliases) 244 { 245 CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd_str, matches); 246 } 247 248 return matches.GetSize(); 249 } 250 251 CommandObjectSP 252 CommandInterpreter::GetCommandSP (const char *cmd_cstr, bool include_aliases, bool exact, StringList *matches) 253 { 254 CommandObject::CommandMap::iterator pos; 255 CommandObjectSP ret_val; 256 257 std::string cmd(cmd_cstr); 258 259 if (HasCommands()) 260 { 261 pos = m_command_dict.find(cmd); 262 if (pos != m_command_dict.end()) 263 ret_val = pos->second; 264 } 265 266 if (include_aliases && HasAliases()) 267 { 268 pos = m_alias_dict.find(cmd); 269 if (pos != m_alias_dict.end()) 270 ret_val = pos->second; 271 } 272 273 if (HasUserCommands()) 274 { 275 pos = m_user_dict.find(cmd); 276 if (pos != m_user_dict.end()) 277 ret_val = pos->second; 278 } 279 280 if (!exact && ret_val == NULL) 281 { 282 // We will only get into here if we didn't find any exact matches. 283 284 CommandObjectSP user_match_sp, alias_match_sp, real_match_sp; 285 286 StringList local_matches; 287 if (matches == NULL) 288 matches = &local_matches; 289 290 unsigned int num_cmd_matches = 0; 291 unsigned int num_alias_matches = 0; 292 unsigned int num_user_matches = 0; 293 294 // Look through the command dictionaries one by one, and if we get only one match from any of 295 // them in toto, then return that, otherwise return an empty CommandObjectSP and the list of matches. 296 297 if (HasCommands()) 298 { 299 num_cmd_matches = CommandObject::AddNamesMatchingPartialString (m_command_dict, cmd_cstr, *matches); 300 } 301 302 if (num_cmd_matches == 1) 303 { 304 cmd.assign(matches->GetStringAtIndex(0)); 305 pos = m_command_dict.find(cmd); 306 if (pos != m_command_dict.end()) 307 real_match_sp = pos->second; 308 } 309 310 if (include_aliases && HasAliases()) 311 { 312 num_alias_matches = CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd_cstr, *matches); 313 314 } 315 316 if (num_alias_matches == 1) 317 { 318 cmd.assign(matches->GetStringAtIndex (num_cmd_matches)); 319 pos = m_alias_dict.find(cmd); 320 if (pos != m_alias_dict.end()) 321 alias_match_sp = pos->second; 322 } 323 324 if (HasUserCommands()) 325 { 326 num_user_matches = CommandObject::AddNamesMatchingPartialString (m_user_dict, cmd_cstr, *matches); 327 } 328 329 if (num_user_matches == 1) 330 { 331 cmd.assign (matches->GetStringAtIndex (num_cmd_matches + num_alias_matches)); 332 333 pos = m_user_dict.find (cmd); 334 if (pos != m_user_dict.end()) 335 user_match_sp = pos->second; 336 } 337 338 // If we got exactly one match, return that, otherwise return the match list. 339 340 if (num_user_matches + num_cmd_matches + num_alias_matches == 1) 341 { 342 if (num_cmd_matches) 343 return real_match_sp; 344 else if (num_alias_matches) 345 return alias_match_sp; 346 else 347 return user_match_sp; 348 } 349 } 350 else if (matches && ret_val != NULL) 351 { 352 matches->AppendString (cmd_cstr); 353 } 354 355 356 return ret_val; 357 } 358 359 bool 360 CommandInterpreter::AddCommand (const char *name, const lldb::CommandObjectSP &cmd_sp, bool can_replace) 361 { 362 if (name && name[0]) 363 { 364 std::string name_sstr(name); 365 if (!can_replace) 366 { 367 if (m_command_dict.find (name_sstr) != m_command_dict.end()) 368 return false; 369 } 370 m_command_dict[name_sstr] = cmd_sp; 371 return true; 372 } 373 return false; 374 } 375 376 377 CommandObjectSP 378 CommandInterpreter::GetCommandSPExact (const char *cmd_cstr, bool include_aliases) 379 { 380 Args cmd_words (cmd_cstr); // Break up the command string into words, in case it's a multi-word command. 381 CommandObjectSP ret_val; // Possibly empty return value. 382 383 if (cmd_cstr == NULL) 384 return ret_val; 385 386 if (cmd_words.GetArgumentCount() == 1) 387 return GetCommandSP(cmd_cstr, include_aliases, true, NULL); 388 else 389 { 390 // We have a multi-word command (seemingly), so we need to do more work. 391 // First, get the cmd_obj_sp for the first word in the command. 392 CommandObjectSP cmd_obj_sp = GetCommandSP (cmd_words.GetArgumentAtIndex (0), include_aliases, true, NULL); 393 if (cmd_obj_sp.get() != NULL) 394 { 395 // Loop through the rest of the words in the command (everything passed in was supposed to be part of a 396 // command name), and find the appropriate sub-command SP for each command word.... 397 size_t end = cmd_words.GetArgumentCount(); 398 for (size_t j= 1; j < end; ++j) 399 { 400 if (cmd_obj_sp->IsMultiwordObject()) 401 { 402 cmd_obj_sp = ((CommandObjectMultiword *) cmd_obj_sp.get())->GetSubcommandSP 403 (cmd_words.GetArgumentAtIndex (j)); 404 if (cmd_obj_sp.get() == NULL) 405 // The sub-command name was invalid. Fail and return the empty 'ret_val'. 406 return ret_val; 407 } 408 else 409 // We have more words in the command name, but we don't have a multiword object. Fail and return 410 // empty 'ret_val'. 411 return ret_val; 412 } 413 // We successfully looped through all the command words and got valid command objects for them. Assign the 414 // last object retrieved to 'ret_val'. 415 ret_val = cmd_obj_sp; 416 } 417 } 418 return ret_val; 419 } 420 421 CommandObject * 422 CommandInterpreter::GetCommandObjectExact (const char *cmd_cstr, bool include_aliases) 423 { 424 return GetCommandSPExact (cmd_cstr, include_aliases).get(); 425 } 426 427 CommandObject * 428 CommandInterpreter::GetCommandObject (const char *cmd_cstr, StringList *matches) 429 { 430 CommandObject *command_obj = GetCommandSP (cmd_cstr, false, true, matches).get(); 431 432 // If we didn't find an exact match to the command string in the commands, look in 433 // the aliases. 434 435 if (command_obj == NULL) 436 { 437 command_obj = GetCommandSP (cmd_cstr, true, true, matches).get(); 438 } 439 440 // Finally, if there wasn't an exact match among the aliases, look for an inexact match 441 // in both the commands and the aliases. 442 443 if (command_obj == NULL) 444 command_obj = GetCommandSP(cmd_cstr, true, false, matches).get(); 445 446 return command_obj; 447 } 448 449 bool 450 CommandInterpreter::CommandExists (const char *cmd) 451 { 452 return m_command_dict.find(cmd) != m_command_dict.end(); 453 } 454 455 bool 456 CommandInterpreter::AliasExists (const char *cmd) 457 { 458 return m_alias_dict.find(cmd) != m_alias_dict.end(); 459 } 460 461 bool 462 CommandInterpreter::UserCommandExists (const char *cmd) 463 { 464 return m_user_dict.find(cmd) != m_user_dict.end(); 465 } 466 467 void 468 CommandInterpreter::AddAlias (const char *alias_name, CommandObjectSP& command_obj_sp) 469 { 470 command_obj_sp->SetIsAlias (true); 471 m_alias_dict[alias_name] = command_obj_sp; 472 } 473 474 bool 475 CommandInterpreter::RemoveAlias (const char *alias_name) 476 { 477 CommandObject::CommandMap::iterator pos = m_alias_dict.find(alias_name); 478 if (pos != m_alias_dict.end()) 479 { 480 m_alias_dict.erase(pos); 481 return true; 482 } 483 return false; 484 } 485 bool 486 CommandInterpreter::RemoveUser (const char *alias_name) 487 { 488 CommandObject::CommandMap::iterator pos = m_user_dict.find(alias_name); 489 if (pos != m_user_dict.end()) 490 { 491 m_user_dict.erase(pos); 492 return true; 493 } 494 return false; 495 } 496 497 void 498 CommandInterpreter::GetAliasHelp (const char *alias_name, const char *command_name, StreamString &help_string) 499 { 500 help_string.Printf ("'%s", command_name); 501 OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name); 502 503 if (option_arg_vector_sp != NULL) 504 { 505 OptionArgVector *options = option_arg_vector_sp.get(); 506 for (int i = 0; i < options->size(); ++i) 507 { 508 OptionArgPair cur_option = (*options)[i]; 509 std::string opt = cur_option.first; 510 OptionArgValue value_pair = cur_option.second; 511 std::string value = value_pair.second; 512 if (opt.compare("<argument>") == 0) 513 { 514 help_string.Printf (" %s", value.c_str()); 515 } 516 else 517 { 518 help_string.Printf (" %s", opt.c_str()); 519 if ((value.compare ("<no-argument>") != 0) 520 && (value.compare ("<need-argument") != 0)) 521 { 522 help_string.Printf (" %s", value.c_str()); 523 } 524 } 525 } 526 } 527 528 help_string.Printf ("'"); 529 } 530 531 size_t 532 CommandInterpreter::FindLongestCommandWord (CommandObject::CommandMap &dict) 533 { 534 CommandObject::CommandMap::const_iterator pos; 535 CommandObject::CommandMap::const_iterator end = dict.end(); 536 size_t max_len = 0; 537 538 for (pos = dict.begin(); pos != end; ++pos) 539 { 540 size_t len = pos->first.size(); 541 if (max_len < len) 542 max_len = len; 543 } 544 return max_len; 545 } 546 547 void 548 CommandInterpreter::GetHelp (CommandReturnObject &result) 549 { 550 CommandObject::CommandMap::const_iterator pos; 551 result.AppendMessage("The following is a list of built-in, permanent debugger commands:"); 552 result.AppendMessage(""); 553 uint32_t max_len = FindLongestCommandWord (m_command_dict); 554 555 for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos) 556 { 557 OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(), 558 max_len); 559 } 560 result.AppendMessage(""); 561 562 if (m_alias_dict.size() > 0) 563 { 564 result.AppendMessage("The following is a list of your current command abbreviations " 565 "(see 'help command alias' for more info):"); 566 result.AppendMessage(""); 567 max_len = FindLongestCommandWord (m_alias_dict); 568 569 for (pos = m_alias_dict.begin(); pos != m_alias_dict.end(); ++pos) 570 { 571 StreamString sstr; 572 StreamString translation_and_help; 573 std::string entry_name = pos->first; 574 std::string second_entry = pos->second.get()->GetCommandName(); 575 GetAliasHelp (pos->first.c_str(), pos->second->GetCommandName(), sstr); 576 577 translation_and_help.Printf ("(%s) %s", sstr.GetData(), pos->second->GetHelp()); 578 OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", 579 translation_and_help.GetData(), max_len); 580 } 581 result.AppendMessage(""); 582 } 583 584 if (m_user_dict.size() > 0) 585 { 586 result.AppendMessage ("The following is a list of your current user-defined commands:"); 587 result.AppendMessage(""); 588 for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos) 589 { 590 result.AppendMessageWithFormat ("%s -- %s\n", pos->first.c_str(), pos->second->GetHelp()); 591 } 592 result.AppendMessage(""); 593 } 594 595 result.AppendMessage("For more information on any particular command, try 'help <command-name>'."); 596 } 597 598 CommandObject * 599 CommandInterpreter::GetCommandObjectForCommand (std::string &command_string) 600 { 601 // This function finds the final, lowest-level, alias-resolved command object whose 'Execute' function will 602 // eventually be invoked by the given command line. 603 604 CommandObject *cmd_obj = NULL; 605 std::string white_space (" \t\v"); 606 size_t start = command_string.find_first_not_of (white_space); 607 size_t end = 0; 608 bool done = false; 609 while (!done) 610 { 611 if (start != std::string::npos) 612 { 613 // Get the next word from command_string. 614 end = command_string.find_first_of (white_space, start); 615 if (end == std::string::npos) 616 end = command_string.size(); 617 std::string cmd_word = command_string.substr (start, end - start); 618 619 if (cmd_obj == NULL) 620 // Since cmd_obj is NULL we are on our first time through this loop. Check to see if cmd_word is a valid 621 // command or alias. 622 cmd_obj = GetCommandObject (cmd_word.c_str()); 623 else if (cmd_obj->IsMultiwordObject ()) 624 { 625 // Our current object is a multi-word object; see if the cmd_word is a valid sub-command for our object. 626 CommandObject *sub_cmd_obj = 627 ((CommandObjectMultiword *) cmd_obj)->GetSubcommandObject (cmd_word.c_str()); 628 if (sub_cmd_obj) 629 cmd_obj = sub_cmd_obj; 630 else // cmd_word was not a valid sub-command word, so we are donee 631 done = true; 632 } 633 else 634 // We have a cmd_obj and it is not a multi-word object, so we are done. 635 done = true; 636 637 // If we didn't find a valid command object, or our command object is not a multi-word object, or 638 // we are at the end of the command_string, then we are done. Otherwise, find the start of the 639 // next word. 640 641 if (!cmd_obj || !cmd_obj->IsMultiwordObject() || end >= command_string.size()) 642 done = true; 643 else 644 start = command_string.find_first_not_of (white_space, end); 645 } 646 else 647 // Unable to find any more words. 648 done = true; 649 } 650 651 if (end == command_string.size()) 652 command_string.clear(); 653 else 654 command_string = command_string.substr(end); 655 656 return cmd_obj; 657 } 658 659 bool 660 CommandInterpreter::StripFirstWord (std::string &command_string, std::string &word) 661 { 662 std::string white_space (" \t\v"); 663 size_t start; 664 size_t end; 665 666 start = command_string.find_first_not_of (white_space); 667 if (start != std::string::npos) 668 { 669 end = command_string.find_first_of (white_space, start); 670 if (end != std::string::npos) 671 { 672 word = command_string.substr (start, end - start); 673 command_string = command_string.substr (end); 674 size_t pos = command_string.find_first_not_of (white_space); 675 if ((pos != 0) && (pos != std::string::npos)) 676 command_string = command_string.substr (pos); 677 } 678 else 679 { 680 word = command_string.substr (start); 681 command_string.erase(); 682 } 683 684 } 685 return true; 686 } 687 688 void 689 CommandInterpreter::BuildAliasResult (const char *alias_name, std::string &raw_input_string, std::string &alias_result, 690 CommandObject *&alias_cmd_obj, CommandReturnObject &result) 691 { 692 Args cmd_args (raw_input_string.c_str()); 693 alias_cmd_obj = GetCommandObject (alias_name); 694 StreamString result_str; 695 696 if (alias_cmd_obj) 697 { 698 std::string alias_name_str = alias_name; 699 if ((cmd_args.GetArgumentCount() == 0) 700 || (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0)) 701 cmd_args.Unshift (alias_name); 702 703 result_str.Printf ("%s", alias_cmd_obj->GetCommandName ()); 704 OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name); 705 706 if (option_arg_vector_sp.get()) 707 { 708 OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); 709 710 for (int i = 0; i < option_arg_vector->size(); ++i) 711 { 712 OptionArgPair option_pair = (*option_arg_vector)[i]; 713 OptionArgValue value_pair = option_pair.second; 714 int value_type = value_pair.first; 715 std::string option = option_pair.first; 716 std::string value = value_pair.second; 717 if (option.compare ("<argument>") == 0) 718 result_str.Printf (" %s", value.c_str()); 719 else 720 { 721 result_str.Printf (" %s", option.c_str()); 722 if (value_type != optional_argument) 723 result_str.Printf (" "); 724 if (value.compare ("<no_argument>") != 0) 725 { 726 int index = GetOptionArgumentPosition (value.c_str()); 727 if (index == 0) 728 result_str.Printf ("%s", value.c_str()); 729 else if (index >= cmd_args.GetArgumentCount()) 730 { 731 732 result.AppendErrorWithFormat 733 ("Not enough arguments provided; you need at least %d arguments to use this alias.\n", 734 index); 735 result.SetStatus (eReturnStatusFailed); 736 return; 737 } 738 else 739 { 740 size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index)); 741 if (strpos != std::string::npos) 742 raw_input_string = raw_input_string.erase (strpos, 743 strlen (cmd_args.GetArgumentAtIndex (index))); 744 result_str.Printf ("%s", cmd_args.GetArgumentAtIndex (index)); 745 } 746 } 747 } 748 } 749 } 750 751 alias_result = result_str.GetData(); 752 } 753 } 754 755 bool 756 CommandInterpreter::HandleCommand (const char *command_line, 757 bool add_to_history, 758 CommandReturnObject &result, 759 ExecutionContext *override_context, 760 bool repeat_on_empty_command) 761 762 { 763 764 bool done = false; 765 CommandObject *cmd_obj = NULL; 766 std::string next_word; 767 bool wants_raw_input = false; 768 std::string command_string (command_line); 769 770 LogSP log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMANDS)); 771 Host::SetCrashDescriptionWithFormat ("HandleCommand(command = \"%s\")", command_line); 772 773 // Make a scoped cleanup object that will clear the crash description string 774 // on exit of this function. 775 lldb_utility::CleanUp <const char *, void> crash_description_cleanup(NULL, Host::SetCrashDescription); 776 777 if (log) 778 log->Printf ("Processing command: %s", command_line); 779 780 Timer scoped_timer (__PRETTY_FUNCTION__, "Handling command: %s.", command_line); 781 782 UpdateExecutionContext (override_context); 783 784 bool empty_command = false; 785 bool comment_command = false; 786 if (command_string.empty()) 787 empty_command = true; 788 else 789 { 790 const char *k_space_characters = "\t\n\v\f\r "; 791 792 size_t non_space = command_string.find_first_not_of (k_space_characters); 793 // Check for empty line or comment line (lines whose first 794 // non-space character is the comment character for this interpreter) 795 if (non_space == std::string::npos) 796 empty_command = true; 797 else if (command_string[non_space] == m_comment_char) 798 comment_command = true; 799 } 800 801 if (empty_command) 802 { 803 if (repeat_on_empty_command) 804 { 805 if (m_command_history.empty()) 806 { 807 result.AppendError ("empty command"); 808 result.SetStatus(eReturnStatusFailed); 809 return false; 810 } 811 else 812 { 813 command_line = m_repeat_command.c_str(); 814 command_string = command_line; 815 if (m_repeat_command.empty()) 816 { 817 result.AppendErrorWithFormat("No auto repeat.\n"); 818 result.SetStatus (eReturnStatusFailed); 819 return false; 820 } 821 } 822 add_to_history = false; 823 } 824 else 825 { 826 result.SetStatus (eReturnStatusSuccessFinishNoResult); 827 return true; 828 } 829 } 830 else if (comment_command) 831 { 832 result.SetStatus (eReturnStatusSuccessFinishNoResult); 833 return true; 834 } 835 836 // Phase 1. 837 838 // Before we do ANY kind of argument processing, etc. we need to figure out what the real/final command object 839 // is for the specified command, and whether or not it wants raw input. This gets complicated by the fact that 840 // the user could have specified an alias, and in translating the alias there may also be command options and/or 841 // even data (including raw text strings) that need to be found and inserted into the command line as part of 842 // the translation. So this first step is plain look-up & replacement, resulting in three things: 1). the command 843 // object whose Execute method will actually be called; 2). a revised command string, with all substitutions & 844 // replacements taken care of; 3). whether or not the Execute function wants raw input or not. 845 846 StreamString revised_command_line; 847 size_t actual_cmd_name_len = 0; 848 while (!done) 849 { 850 StripFirstWord (command_string, next_word); 851 if (!cmd_obj && AliasExists (next_word.c_str())) 852 { 853 std::string alias_result; 854 BuildAliasResult (next_word.c_str(), command_string, alias_result, cmd_obj, result); 855 revised_command_line.Printf ("%s", alias_result.c_str()); 856 if (cmd_obj) 857 { 858 wants_raw_input = cmd_obj->WantsRawCommandString (); 859 actual_cmd_name_len = strlen (cmd_obj->GetCommandName()); 860 } 861 } 862 else if (!cmd_obj) 863 { 864 cmd_obj = GetCommandObject (next_word.c_str()); 865 if (cmd_obj) 866 { 867 actual_cmd_name_len += next_word.length(); 868 revised_command_line.Printf ("%s", next_word.c_str()); 869 wants_raw_input = cmd_obj->WantsRawCommandString (); 870 } 871 else 872 { 873 revised_command_line.Printf ("%s", next_word.c_str()); 874 } 875 } 876 else if (cmd_obj->IsMultiwordObject ()) 877 { 878 CommandObject *sub_cmd_obj = ((CommandObjectMultiword *) cmd_obj)->GetSubcommandObject (next_word.c_str()); 879 if (sub_cmd_obj) 880 { 881 actual_cmd_name_len += next_word.length() + 1; 882 revised_command_line.Printf (" %s", next_word.c_str()); 883 cmd_obj = sub_cmd_obj; 884 wants_raw_input = cmd_obj->WantsRawCommandString (); 885 } 886 else 887 { 888 revised_command_line.Printf (" %s", next_word.c_str()); 889 done = true; 890 } 891 } 892 else 893 { 894 revised_command_line.Printf (" %s", next_word.c_str()); 895 done = true; 896 } 897 898 if (cmd_obj == NULL) 899 { 900 result.AppendErrorWithFormat ("'%s' is not a valid command.\n", next_word.c_str()); 901 result.SetStatus (eReturnStatusFailed); 902 return false; 903 } 904 905 next_word.erase (); 906 if (command_string.length() == 0) 907 done = true; 908 909 } 910 911 if (command_string.size() > 0) 912 revised_command_line.Printf (" %s", command_string.c_str()); 913 914 // End of Phase 1. 915 // At this point cmd_obj should contain the CommandObject whose Execute method will be called, if the command 916 // specified was valid; revised_command_line contains the complete command line (including command name(s)), 917 // fully translated with all substitutions & translations taken care of (still in raw text format); and 918 // wants_raw_input specifies whether the Execute method expects raw input or not. 919 920 921 if (log) 922 { 923 log->Printf ("HandleCommand, cmd_obj : '%s'", cmd_obj ? cmd_obj->GetCommandName() : "<not found>"); 924 log->Printf ("HandleCommand, revised_command_line: '%s'", revised_command_line.GetData()); 925 log->Printf ("HandleCommand, wants_raw_input:'%s'", wants_raw_input ? "True" : "False"); 926 } 927 928 // Phase 2. 929 // Take care of things like setting up the history command & calling the appropriate Execute method on the 930 // CommandObject, with the appropriate arguments. 931 932 if (cmd_obj != NULL) 933 { 934 if (add_to_history) 935 { 936 Args command_args (revised_command_line.GetData()); 937 const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0); 938 if (repeat_command != NULL) 939 m_repeat_command.assign(repeat_command); 940 else 941 m_repeat_command.assign(command_line); 942 943 m_command_history.push_back (command_line); 944 } 945 946 command_string = revised_command_line.GetData(); 947 std::string command_name (cmd_obj->GetCommandName()); 948 std::string remainder; 949 if (actual_cmd_name_len < command_string.length()) 950 remainder = command_string.substr (actual_cmd_name_len); // Note: 'actual_cmd_name_len' may be considerably shorter 951 // than cmd_obj->GetCommandName(), because name completion 952 // allows users to enter short versions of the names, 953 // e.g. 'br s' for 'breakpoint set'. 954 955 // Remove any initial spaces 956 std::string white_space (" \t\v"); 957 size_t pos = remainder.find_first_not_of (white_space); 958 if (pos != 0 && pos != std::string::npos) 959 remainder.erase(0, pos); 960 961 if (log) 962 log->Printf ("HandleCommand, command line after removing command name(s): '%s'\n", remainder.c_str()); 963 964 965 if (wants_raw_input) 966 cmd_obj->ExecuteRawCommandString (remainder.c_str(), result); 967 else 968 { 969 Args cmd_args (remainder.c_str()); 970 cmd_obj->ExecuteWithOptions (cmd_args, result); 971 } 972 } 973 else 974 { 975 // We didn't find the first command object, so complete the first argument. 976 Args command_args (revised_command_line.GetData()); 977 StringList matches; 978 int num_matches; 979 int cursor_index = 0; 980 int cursor_char_position = strlen (command_args.GetArgumentAtIndex(0)); 981 bool word_complete; 982 num_matches = HandleCompletionMatches (command_args, 983 cursor_index, 984 cursor_char_position, 985 0, 986 -1, 987 word_complete, 988 matches); 989 990 if (num_matches > 0) 991 { 992 std::string error_msg; 993 error_msg.assign ("ambiguous command '"); 994 error_msg.append(command_args.GetArgumentAtIndex(0)); 995 error_msg.append ("'."); 996 997 error_msg.append (" Possible completions:"); 998 for (int i = 0; i < num_matches; i++) 999 { 1000 error_msg.append ("\n\t"); 1001 error_msg.append (matches.GetStringAtIndex (i)); 1002 } 1003 error_msg.append ("\n"); 1004 result.AppendRawError (error_msg.c_str(), error_msg.size()); 1005 } 1006 else 1007 result.AppendErrorWithFormat ("Unrecognized command '%s'.\n", command_args.GetArgumentAtIndex (0)); 1008 1009 result.SetStatus (eReturnStatusFailed); 1010 } 1011 1012 return result.Succeeded(); 1013 } 1014 1015 int 1016 CommandInterpreter::HandleCompletionMatches (Args &parsed_line, 1017 int &cursor_index, 1018 int &cursor_char_position, 1019 int match_start_point, 1020 int max_return_elements, 1021 bool &word_complete, 1022 StringList &matches) 1023 { 1024 int num_command_matches = 0; 1025 bool look_for_subcommand = false; 1026 1027 // For any of the command completions a unique match will be a complete word. 1028 word_complete = true; 1029 1030 if (cursor_index == -1) 1031 { 1032 // We got nothing on the command line, so return the list of commands 1033 bool include_aliases = true; 1034 num_command_matches = GetCommandNamesMatchingPartialString ("", include_aliases, matches); 1035 } 1036 else if (cursor_index == 0) 1037 { 1038 // The cursor is in the first argument, so just do a lookup in the dictionary. 1039 CommandObject *cmd_obj = GetCommandObject (parsed_line.GetArgumentAtIndex(0), &matches); 1040 num_command_matches = matches.GetSize(); 1041 1042 if (num_command_matches == 1 1043 && cmd_obj && cmd_obj->IsMultiwordObject() 1044 && matches.GetStringAtIndex(0) != NULL 1045 && strcmp (parsed_line.GetArgumentAtIndex(0), matches.GetStringAtIndex(0)) == 0) 1046 { 1047 look_for_subcommand = true; 1048 num_command_matches = 0; 1049 matches.DeleteStringAtIndex(0); 1050 parsed_line.AppendArgument (""); 1051 cursor_index++; 1052 cursor_char_position = 0; 1053 } 1054 } 1055 1056 if (cursor_index > 0 || look_for_subcommand) 1057 { 1058 // We are completing further on into a commands arguments, so find the command and tell it 1059 // to complete the command. 1060 // First see if there is a matching initial command: 1061 CommandObject *command_object = GetCommandObject (parsed_line.GetArgumentAtIndex(0)); 1062 if (command_object == NULL) 1063 { 1064 return 0; 1065 } 1066 else 1067 { 1068 parsed_line.Shift(); 1069 cursor_index--; 1070 num_command_matches = command_object->HandleCompletion (parsed_line, 1071 cursor_index, 1072 cursor_char_position, 1073 match_start_point, 1074 max_return_elements, 1075 word_complete, 1076 matches); 1077 } 1078 } 1079 1080 return num_command_matches; 1081 1082 } 1083 1084 int 1085 CommandInterpreter::HandleCompletion (const char *current_line, 1086 const char *cursor, 1087 const char *last_char, 1088 int match_start_point, 1089 int max_return_elements, 1090 StringList &matches) 1091 { 1092 // We parse the argument up to the cursor, so the last argument in parsed_line is 1093 // the one containing the cursor, and the cursor is after the last character. 1094 1095 Args parsed_line(current_line, last_char - current_line); 1096 Args partial_parsed_line(current_line, cursor - current_line); 1097 1098 int num_args = partial_parsed_line.GetArgumentCount(); 1099 int cursor_index = partial_parsed_line.GetArgumentCount() - 1; 1100 int cursor_char_position; 1101 1102 if (cursor_index == -1) 1103 cursor_char_position = 0; 1104 else 1105 cursor_char_position = strlen (partial_parsed_line.GetArgumentAtIndex(cursor_index)); 1106 1107 if (cursor > current_line && cursor[-1] == ' ') 1108 { 1109 // We are just after a space. If we are in an argument, then we will continue 1110 // parsing, but if we are between arguments, then we have to complete whatever the next 1111 // element would be. 1112 // We can distinguish the two cases because if we are in an argument (e.g. because the space is 1113 // protected by a quote) then the space will also be in the parsed argument... 1114 1115 const char *current_elem = partial_parsed_line.GetArgumentAtIndex(cursor_index); 1116 if (cursor_char_position == 0 || current_elem[cursor_char_position - 1] != ' ') 1117 { 1118 parsed_line.InsertArgumentAtIndex(cursor_index + 1, "", '"'); 1119 cursor_index++; 1120 cursor_char_position = 0; 1121 } 1122 } 1123 1124 int num_command_matches; 1125 1126 matches.Clear(); 1127 1128 // Only max_return_elements == -1 is supported at present: 1129 assert (max_return_elements == -1); 1130 bool word_complete; 1131 num_command_matches = HandleCompletionMatches (parsed_line, 1132 cursor_index, 1133 cursor_char_position, 1134 match_start_point, 1135 max_return_elements, 1136 word_complete, 1137 matches); 1138 1139 if (num_command_matches <= 0) 1140 return num_command_matches; 1141 1142 if (num_args == 0) 1143 { 1144 // If we got an empty string, insert nothing. 1145 matches.InsertStringAtIndex(0, ""); 1146 } 1147 else 1148 { 1149 // Now figure out if there is a common substring, and if so put that in element 0, otherwise 1150 // put an empty string in element 0. 1151 std::string command_partial_str; 1152 if (cursor_index >= 0) 1153 command_partial_str.assign(parsed_line.GetArgumentAtIndex(cursor_index), 1154 parsed_line.GetArgumentAtIndex(cursor_index) + cursor_char_position); 1155 1156 std::string common_prefix; 1157 matches.LongestCommonPrefix (common_prefix); 1158 int partial_name_len = command_partial_str.size(); 1159 1160 // If we matched a unique single command, add a space... 1161 // Only do this if the completer told us this was a complete word, however... 1162 if (num_command_matches == 1 && word_complete) 1163 { 1164 char quote_char = parsed_line.GetArgumentQuoteCharAtIndex(cursor_index); 1165 if (quote_char != '\0') 1166 common_prefix.push_back(quote_char); 1167 1168 common_prefix.push_back(' '); 1169 } 1170 common_prefix.erase (0, partial_name_len); 1171 matches.InsertStringAtIndex(0, common_prefix.c_str()); 1172 } 1173 return num_command_matches; 1174 } 1175 1176 1177 CommandInterpreter::~CommandInterpreter () 1178 { 1179 } 1180 1181 const char * 1182 CommandInterpreter::GetPrompt () 1183 { 1184 return m_debugger.GetPrompt(); 1185 } 1186 1187 void 1188 CommandInterpreter::SetPrompt (const char *new_prompt) 1189 { 1190 m_debugger.SetPrompt (new_prompt); 1191 } 1192 1193 size_t 1194 CommandInterpreter::GetConfirmationInputReaderCallback 1195 ( 1196 void *baton, 1197 InputReader &reader, 1198 lldb::InputReaderAction action, 1199 const char *bytes, 1200 size_t bytes_len 1201 ) 1202 { 1203 File &out_file = reader.GetDebugger().GetOutputFile(); 1204 bool *response_ptr = (bool *) baton; 1205 1206 switch (action) 1207 { 1208 case eInputReaderActivate: 1209 if (out_file.IsValid()) 1210 { 1211 if (reader.GetPrompt()) 1212 { 1213 out_file.Printf ("%s", reader.GetPrompt()); 1214 out_file.Flush (); 1215 } 1216 } 1217 break; 1218 1219 case eInputReaderDeactivate: 1220 break; 1221 1222 case eInputReaderReactivate: 1223 if (out_file.IsValid() && reader.GetPrompt()) 1224 { 1225 out_file.Printf ("%s", reader.GetPrompt()); 1226 out_file.Flush (); 1227 } 1228 break; 1229 1230 case eInputReaderGotToken: 1231 if (bytes_len == 0) 1232 { 1233 reader.SetIsDone(true); 1234 } 1235 else if (bytes[0] == 'y') 1236 { 1237 *response_ptr = true; 1238 reader.SetIsDone(true); 1239 } 1240 else if (bytes[0] == 'n') 1241 { 1242 *response_ptr = false; 1243 reader.SetIsDone(true); 1244 } 1245 else 1246 { 1247 if (out_file.IsValid() && !reader.IsDone() && reader.GetPrompt()) 1248 { 1249 out_file.Printf ("Please answer \"y\" or \"n\"\n%s", reader.GetPrompt()); 1250 out_file.Flush (); 1251 } 1252 } 1253 break; 1254 1255 case eInputReaderInterrupt: 1256 case eInputReaderEndOfFile: 1257 *response_ptr = false; // Assume ^C or ^D means cancel the proposed action 1258 reader.SetIsDone (true); 1259 break; 1260 1261 case eInputReaderDone: 1262 break; 1263 } 1264 1265 return bytes_len; 1266 1267 } 1268 1269 bool 1270 CommandInterpreter::Confirm (const char *message, bool default_answer) 1271 { 1272 // Check AutoConfirm first: 1273 if (m_debugger.GetAutoConfirm()) 1274 return default_answer; 1275 1276 InputReaderSP reader_sp (new InputReader(GetDebugger())); 1277 bool response = default_answer; 1278 if (reader_sp) 1279 { 1280 std::string prompt(message); 1281 prompt.append(": ["); 1282 if (default_answer) 1283 prompt.append ("Y/n] "); 1284 else 1285 prompt.append ("y/N] "); 1286 1287 Error err (reader_sp->Initialize (CommandInterpreter::GetConfirmationInputReaderCallback, 1288 &response, // baton 1289 eInputReaderGranularityLine, // token size, to pass to callback function 1290 NULL, // end token 1291 prompt.c_str(), // prompt 1292 true)); // echo input 1293 if (err.Success()) 1294 { 1295 GetDebugger().PushInputReader (reader_sp); 1296 } 1297 reader_sp->WaitOnReaderIsDone(); 1298 } 1299 return response; 1300 } 1301 1302 1303 void 1304 CommandInterpreter::CrossRegisterCommand (const char * dest_cmd, const char * object_type) 1305 { 1306 CommandObjectSP cmd_obj_sp = GetCommandSPExact (dest_cmd, true); 1307 1308 if (cmd_obj_sp != NULL) 1309 { 1310 CommandObject *cmd_obj = cmd_obj_sp.get(); 1311 if (cmd_obj->IsCrossRefObject ()) 1312 cmd_obj->AddObject (object_type); 1313 } 1314 } 1315 1316 OptionArgVectorSP 1317 CommandInterpreter::GetAliasOptions (const char *alias_name) 1318 { 1319 OptionArgMap::iterator pos; 1320 OptionArgVectorSP ret_val; 1321 1322 std::string alias (alias_name); 1323 1324 if (HasAliasOptions()) 1325 { 1326 pos = m_alias_options.find (alias); 1327 if (pos != m_alias_options.end()) 1328 ret_val = pos->second; 1329 } 1330 1331 return ret_val; 1332 } 1333 1334 void 1335 CommandInterpreter::RemoveAliasOptions (const char *alias_name) 1336 { 1337 OptionArgMap::iterator pos = m_alias_options.find(alias_name); 1338 if (pos != m_alias_options.end()) 1339 { 1340 m_alias_options.erase (pos); 1341 } 1342 } 1343 1344 void 1345 CommandInterpreter::AddOrReplaceAliasOptions (const char *alias_name, OptionArgVectorSP &option_arg_vector_sp) 1346 { 1347 m_alias_options[alias_name] = option_arg_vector_sp; 1348 } 1349 1350 bool 1351 CommandInterpreter::HasCommands () 1352 { 1353 return (!m_command_dict.empty()); 1354 } 1355 1356 bool 1357 CommandInterpreter::HasAliases () 1358 { 1359 return (!m_alias_dict.empty()); 1360 } 1361 1362 bool 1363 CommandInterpreter::HasUserCommands () 1364 { 1365 return (!m_user_dict.empty()); 1366 } 1367 1368 bool 1369 CommandInterpreter::HasAliasOptions () 1370 { 1371 return (!m_alias_options.empty()); 1372 } 1373 1374 void 1375 CommandInterpreter::BuildAliasCommandArgs (CommandObject *alias_cmd_obj, 1376 const char *alias_name, 1377 Args &cmd_args, 1378 std::string &raw_input_string, 1379 CommandReturnObject &result) 1380 { 1381 OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name); 1382 1383 bool wants_raw_input = alias_cmd_obj->WantsRawCommandString(); 1384 1385 // Make sure that the alias name is the 0th element in cmd_args 1386 std::string alias_name_str = alias_name; 1387 if (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0) 1388 cmd_args.Unshift (alias_name); 1389 1390 Args new_args (alias_cmd_obj->GetCommandName()); 1391 if (new_args.GetArgumentCount() == 2) 1392 new_args.Shift(); 1393 1394 if (option_arg_vector_sp.get()) 1395 { 1396 if (wants_raw_input) 1397 { 1398 // We have a command that both has command options and takes raw input. Make *sure* it has a 1399 // " -- " in the right place in the raw_input_string. 1400 size_t pos = raw_input_string.find(" -- "); 1401 if (pos == std::string::npos) 1402 { 1403 // None found; assume it goes at the beginning of the raw input string 1404 raw_input_string.insert (0, " -- "); 1405 } 1406 } 1407 1408 OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); 1409 int old_size = cmd_args.GetArgumentCount(); 1410 std::vector<bool> used (old_size + 1, false); 1411 1412 used[0] = true; 1413 1414 for (int i = 0; i < option_arg_vector->size(); ++i) 1415 { 1416 OptionArgPair option_pair = (*option_arg_vector)[i]; 1417 OptionArgValue value_pair = option_pair.second; 1418 int value_type = value_pair.first; 1419 std::string option = option_pair.first; 1420 std::string value = value_pair.second; 1421 if (option.compare ("<argument>") == 0) 1422 { 1423 if (!wants_raw_input 1424 || (value.compare("--") != 0)) // Since we inserted this above, make sure we don't insert it twice 1425 new_args.AppendArgument (value.c_str()); 1426 } 1427 else 1428 { 1429 if (value_type != optional_argument) 1430 new_args.AppendArgument (option.c_str()); 1431 if (value.compare ("<no-argument>") != 0) 1432 { 1433 int index = GetOptionArgumentPosition (value.c_str()); 1434 if (index == 0) 1435 { 1436 // value was NOT a positional argument; must be a real value 1437 if (value_type != optional_argument) 1438 new_args.AppendArgument (value.c_str()); 1439 else 1440 { 1441 char buffer[255]; 1442 ::snprintf (buffer, sizeof (buffer), "%s%s", option.c_str(), value.c_str()); 1443 new_args.AppendArgument (buffer); 1444 } 1445 1446 } 1447 else if (index >= cmd_args.GetArgumentCount()) 1448 { 1449 result.AppendErrorWithFormat 1450 ("Not enough arguments provided; you need at least %d arguments to use this alias.\n", 1451 index); 1452 result.SetStatus (eReturnStatusFailed); 1453 return; 1454 } 1455 else 1456 { 1457 // Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string 1458 size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index)); 1459 if (strpos != std::string::npos) 1460 { 1461 raw_input_string = raw_input_string.erase (strpos, strlen (cmd_args.GetArgumentAtIndex (index))); 1462 } 1463 1464 if (value_type != optional_argument) 1465 new_args.AppendArgument (cmd_args.GetArgumentAtIndex (index)); 1466 else 1467 { 1468 char buffer[255]; 1469 ::snprintf (buffer, sizeof(buffer), "%s%s", option.c_str(), 1470 cmd_args.GetArgumentAtIndex (index)); 1471 new_args.AppendArgument (buffer); 1472 } 1473 used[index] = true; 1474 } 1475 } 1476 } 1477 } 1478 1479 for (int j = 0; j < cmd_args.GetArgumentCount(); ++j) 1480 { 1481 if (!used[j] && !wants_raw_input) 1482 new_args.AppendArgument (cmd_args.GetArgumentAtIndex (j)); 1483 } 1484 1485 cmd_args.Clear(); 1486 cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector()); 1487 } 1488 else 1489 { 1490 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1491 // This alias was not created with any options; nothing further needs to be done, unless it is a command that 1492 // wants raw input, in which case we need to clear the rest of the data from cmd_args, since its in the raw 1493 // input string. 1494 if (wants_raw_input) 1495 { 1496 cmd_args.Clear(); 1497 cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector()); 1498 } 1499 return; 1500 } 1501 1502 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1503 return; 1504 } 1505 1506 1507 int 1508 CommandInterpreter::GetOptionArgumentPosition (const char *in_string) 1509 { 1510 int position = 0; // Any string that isn't an argument position, i.e. '%' followed by an integer, gets a position 1511 // of zero. 1512 1513 char *cptr = (char *) in_string; 1514 1515 // Does it start with '%' 1516 if (cptr[0] == '%') 1517 { 1518 ++cptr; 1519 1520 // Is the rest of it entirely digits? 1521 if (isdigit (cptr[0])) 1522 { 1523 const char *start = cptr; 1524 while (isdigit (cptr[0])) 1525 ++cptr; 1526 1527 // We've gotten to the end of the digits; are we at the end of the string? 1528 if (cptr[0] == '\0') 1529 position = atoi (start); 1530 } 1531 } 1532 1533 return position; 1534 } 1535 1536 void 1537 CommandInterpreter::SourceInitFile (bool in_cwd, CommandReturnObject &result) 1538 { 1539 // Don't parse any .lldbinit files if we were asked not to 1540 if (m_skip_lldbinit_files) 1541 return; 1542 1543 const char *init_file_path = in_cwd ? "./.lldbinit" : "~/.lldbinit"; 1544 FileSpec init_file (init_file_path, true); 1545 // If the file exists, tell HandleCommand to 'source' it; this will do the actual broadcasting 1546 // of the commands back to any appropriate listener (see CommandObjectSource::Execute for more details). 1547 1548 if (init_file.Exists()) 1549 { 1550 ExecutionContext *exe_ctx = NULL; // We don't have any context yet. 1551 bool stop_on_continue = true; 1552 bool stop_on_error = false; 1553 bool echo_commands = false; 1554 bool print_results = false; 1555 1556 HandleCommandsFromFile (init_file, exe_ctx, stop_on_continue, stop_on_error, echo_commands, print_results, result); 1557 } 1558 else 1559 { 1560 // nothing to be done if the file doesn't exist 1561 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1562 } 1563 } 1564 1565 PlatformSP 1566 CommandInterpreter::GetPlatform (bool prefer_target_platform) 1567 { 1568 PlatformSP platform_sp; 1569 if (prefer_target_platform && m_exe_ctx.target) 1570 platform_sp = m_exe_ctx.target->GetPlatform(); 1571 1572 if (!platform_sp) 1573 platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform(); 1574 return platform_sp; 1575 } 1576 1577 void 1578 CommandInterpreter::HandleCommands (const StringList &commands, 1579 ExecutionContext *override_context, 1580 bool stop_on_continue, 1581 bool stop_on_error, 1582 bool echo_commands, 1583 bool print_results, 1584 CommandReturnObject &result) 1585 { 1586 size_t num_lines = commands.GetSize(); 1587 1588 // If we are going to continue past a "continue" then we need to run the commands synchronously. 1589 // Make sure you reset this value anywhere you return from the function. 1590 1591 bool old_async_execution = m_debugger.GetAsyncExecution(); 1592 1593 // If we've been given an execution context, set it at the start, but don't keep resetting it or we will 1594 // cause series of commands that change the context, then do an operation that relies on that context to fail. 1595 1596 if (override_context != NULL) 1597 UpdateExecutionContext (override_context); 1598 1599 if (!stop_on_continue) 1600 { 1601 m_debugger.SetAsyncExecution (false); 1602 } 1603 1604 for (int idx = 0; idx < num_lines; idx++) 1605 { 1606 const char *cmd = commands.GetStringAtIndex(idx); 1607 if (cmd[0] == '\0') 1608 continue; 1609 1610 if (echo_commands) 1611 { 1612 result.AppendMessageWithFormat ("%s %s\n", 1613 GetPrompt(), 1614 cmd); 1615 } 1616 1617 CommandReturnObject tmp_result; 1618 bool success = HandleCommand(cmd, false, tmp_result, NULL); 1619 1620 if (print_results) 1621 { 1622 if (tmp_result.Succeeded()) 1623 result.AppendMessageWithFormat("%s", tmp_result.GetOutputData()); 1624 } 1625 1626 if (!success || !tmp_result.Succeeded()) 1627 { 1628 if (stop_on_error) 1629 { 1630 result.AppendErrorWithFormat("Aborting reading of commands after command #%d: '%s' failed.\n", 1631 idx, cmd); 1632 result.SetStatus (eReturnStatusFailed); 1633 m_debugger.SetAsyncExecution (old_async_execution); 1634 return; 1635 } 1636 else if (print_results) 1637 { 1638 result.AppendMessageWithFormat ("Command #%d '%s' failed with error: %s.\n", 1639 idx + 1, 1640 cmd, 1641 tmp_result.GetErrorData()); 1642 } 1643 } 1644 1645 // N.B. Can't depend on DidChangeProcessState, because the state coming into the command execution 1646 // could be running (for instance in Breakpoint Commands. 1647 // So we check the return value to see if it is has running in it. 1648 if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult) 1649 || (tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult)) 1650 { 1651 if (stop_on_continue) 1652 { 1653 // If we caused the target to proceed, and we're going to stop in that case, set the 1654 // status in our real result before returning. This is an error if the continue was not the 1655 // last command in the set of commands to be run. 1656 if (idx != num_lines - 1) 1657 result.AppendErrorWithFormat("Aborting reading of commands after command #%d: '%s' continued the target.\n", 1658 idx + 1, cmd); 1659 else 1660 result.AppendMessageWithFormat ("Command #%d '%s' continued the target.\n", idx + 1, cmd); 1661 1662 result.SetStatus(tmp_result.GetStatus()); 1663 m_debugger.SetAsyncExecution (old_async_execution); 1664 1665 return; 1666 } 1667 } 1668 1669 } 1670 1671 result.SetStatus (eReturnStatusSuccessFinishResult); 1672 m_debugger.SetAsyncExecution (old_async_execution); 1673 1674 return; 1675 } 1676 1677 void 1678 CommandInterpreter::HandleCommandsFromFile (FileSpec &cmd_file, 1679 ExecutionContext *context, 1680 bool stop_on_continue, 1681 bool stop_on_error, 1682 bool echo_command, 1683 bool print_result, 1684 CommandReturnObject &result) 1685 { 1686 if (cmd_file.Exists()) 1687 { 1688 bool success; 1689 StringList commands; 1690 success = commands.ReadFileLines(cmd_file); 1691 if (!success) 1692 { 1693 result.AppendErrorWithFormat ("Error reading commands from file: %s.\n", cmd_file.GetFilename().AsCString()); 1694 result.SetStatus (eReturnStatusFailed); 1695 return; 1696 } 1697 HandleCommands (commands, context, stop_on_continue, stop_on_error, echo_command, print_result, result); 1698 } 1699 else 1700 { 1701 result.AppendErrorWithFormat ("Error reading commands from file %s - file not found.\n", 1702 cmd_file.GetFilename().AsCString()); 1703 result.SetStatus (eReturnStatusFailed); 1704 return; 1705 } 1706 } 1707 1708 ScriptInterpreter * 1709 CommandInterpreter::GetScriptInterpreter () 1710 { 1711 if (m_script_interpreter_ap.get() != NULL) 1712 return m_script_interpreter_ap.get(); 1713 1714 lldb::ScriptLanguage script_lang = GetDebugger().GetScriptLanguage(); 1715 switch (script_lang) 1716 { 1717 case eScriptLanguageNone: 1718 m_script_interpreter_ap.reset (new ScriptInterpreterNone (*this)); 1719 break; 1720 case eScriptLanguagePython: 1721 m_script_interpreter_ap.reset (new ScriptInterpreterPython (*this)); 1722 break; 1723 default: 1724 break; 1725 }; 1726 1727 return m_script_interpreter_ap.get(); 1728 } 1729 1730 1731 1732 bool 1733 CommandInterpreter::GetSynchronous () 1734 { 1735 return m_synchronous_execution; 1736 } 1737 1738 void 1739 CommandInterpreter::SetSynchronous (bool value) 1740 { 1741 m_synchronous_execution = value; 1742 } 1743 1744 void 1745 CommandInterpreter::OutputFormattedHelpText (Stream &strm, 1746 const char *word_text, 1747 const char *separator, 1748 const char *help_text, 1749 uint32_t max_word_len) 1750 { 1751 const uint32_t max_columns = m_debugger.GetTerminalWidth(); 1752 1753 int indent_size = max_word_len + strlen (separator) + 2; 1754 1755 strm.IndentMore (indent_size); 1756 1757 StreamString text_strm; 1758 text_strm.Printf ("%-*s %s %s", max_word_len, word_text, separator, help_text); 1759 1760 size_t len = text_strm.GetSize(); 1761 const char *text = text_strm.GetData(); 1762 if (text[len - 1] == '\n') 1763 { 1764 text_strm.EOL(); 1765 len = text_strm.GetSize(); 1766 } 1767 1768 if (len < max_columns) 1769 { 1770 // Output it as a single line. 1771 strm.Printf ("%s", text); 1772 } 1773 else 1774 { 1775 // We need to break it up into multiple lines. 1776 bool first_line = true; 1777 int text_width; 1778 int start = 0; 1779 int end = start; 1780 int final_end = strlen (text); 1781 int sub_len; 1782 1783 while (end < final_end) 1784 { 1785 if (first_line) 1786 text_width = max_columns - 1; 1787 else 1788 text_width = max_columns - indent_size - 1; 1789 1790 // Don't start the 'text' on a space, since we're already outputting the indentation. 1791 if (!first_line) 1792 { 1793 while ((start < final_end) && (text[start] == ' ')) 1794 start++; 1795 } 1796 1797 end = start + text_width; 1798 if (end > final_end) 1799 end = final_end; 1800 else 1801 { 1802 // If we're not at the end of the text, make sure we break the line on white space. 1803 while (end > start 1804 && text[end] != ' ' && text[end] != '\t' && text[end] != '\n') 1805 end--; 1806 } 1807 1808 sub_len = end - start; 1809 if (start != 0) 1810 strm.EOL(); 1811 if (!first_line) 1812 strm.Indent(); 1813 else 1814 first_line = false; 1815 assert (start <= final_end); 1816 assert (start + sub_len <= final_end); 1817 if (sub_len > 0) 1818 strm.Write (text + start, sub_len); 1819 start = end + 1; 1820 } 1821 } 1822 strm.EOL(); 1823 strm.IndentLess(indent_size); 1824 } 1825 1826 void 1827 CommandInterpreter::AproposAllSubCommands (CommandObject *cmd_obj, const char *prefix, const char *search_word, 1828 StringList &commands_found, StringList &commands_help) 1829 { 1830 CommandObject::CommandMap::const_iterator pos; 1831 CommandObject::CommandMap sub_cmd_dict = ((CommandObjectMultiword *) cmd_obj)->m_subcommand_dict; 1832 CommandObject *sub_cmd_obj; 1833 1834 for (pos = sub_cmd_dict.begin(); pos != sub_cmd_dict.end(); ++pos) 1835 { 1836 const char * command_name = pos->first.c_str(); 1837 sub_cmd_obj = pos->second.get(); 1838 StreamString complete_command_name; 1839 1840 complete_command_name.Printf ("%s %s", prefix, command_name); 1841 1842 if (sub_cmd_obj->HelpTextContainsWord (search_word)) 1843 { 1844 commands_found.AppendString (complete_command_name.GetData()); 1845 commands_help.AppendString (sub_cmd_obj->GetHelp()); 1846 } 1847 1848 if (sub_cmd_obj->IsMultiwordObject()) 1849 AproposAllSubCommands (sub_cmd_obj, complete_command_name.GetData(), search_word, commands_found, 1850 commands_help); 1851 } 1852 1853 } 1854 1855 void 1856 CommandInterpreter::FindCommandsForApropos (const char *search_word, StringList &commands_found, 1857 StringList &commands_help) 1858 { 1859 CommandObject::CommandMap::const_iterator pos; 1860 1861 for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos) 1862 { 1863 const char *command_name = pos->first.c_str(); 1864 CommandObject *cmd_obj = pos->second.get(); 1865 1866 if (cmd_obj->HelpTextContainsWord (search_word)) 1867 { 1868 commands_found.AppendString (command_name); 1869 commands_help.AppendString (cmd_obj->GetHelp()); 1870 } 1871 1872 if (cmd_obj->IsMultiwordObject()) 1873 AproposAllSubCommands (cmd_obj, command_name, search_word, commands_found, commands_help); 1874 1875 } 1876 } 1877 1878 1879 void 1880 CommandInterpreter::UpdateExecutionContext (ExecutionContext *override_context) 1881 { 1882 m_exe_ctx.Clear(); 1883 1884 if (override_context != NULL) 1885 { 1886 m_exe_ctx.target = override_context->target; 1887 m_exe_ctx.process = override_context->process; 1888 m_exe_ctx.thread = override_context->thread; 1889 m_exe_ctx.frame = override_context->frame; 1890 } 1891 else 1892 { 1893 TargetSP target_sp (m_debugger.GetSelectedTarget()); 1894 if (target_sp) 1895 { 1896 m_exe_ctx.target = target_sp.get(); 1897 m_exe_ctx.process = target_sp->GetProcessSP().get(); 1898 if (m_exe_ctx.process && m_exe_ctx.process->IsAlive() && !m_exe_ctx.process->IsRunning()) 1899 { 1900 m_exe_ctx.thread = m_exe_ctx.process->GetThreadList().GetSelectedThread().get(); 1901 if (m_exe_ctx.thread == NULL) 1902 { 1903 m_exe_ctx.thread = m_exe_ctx.process->GetThreadList().GetThreadAtIndex(0).get(); 1904 // If we didn't have a selected thread, select one here. 1905 if (m_exe_ctx.thread != NULL) 1906 m_exe_ctx.process->GetThreadList().SetSelectedThreadByID(m_exe_ctx.thread->GetID()); 1907 } 1908 if (m_exe_ctx.thread) 1909 { 1910 m_exe_ctx.frame = m_exe_ctx.thread->GetSelectedFrame().get(); 1911 if (m_exe_ctx.frame == NULL) 1912 { 1913 m_exe_ctx.frame = m_exe_ctx.thread->GetStackFrameAtIndex (0).get(); 1914 // If we didn't have a selected frame select one here. 1915 if (m_exe_ctx.frame != NULL) 1916 m_exe_ctx.thread->SetSelectedFrame(m_exe_ctx.frame); 1917 } 1918 } 1919 } 1920 } 1921 } 1922 } 1923 1924