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 "lldb/lldb-python.h" 11 12#include <string> 13#include <vector> 14#include <stdlib.h> 15 16#include "CommandObjectScript.h" 17#include "lldb/Interpreter/CommandObjectRegexCommand.h" 18 19#include "../Commands/CommandObjectApropos.h" 20#include "../Commands/CommandObjectArgs.h" 21#include "../Commands/CommandObjectBreakpoint.h" 22#include "../Commands/CommandObjectDisassemble.h" 23#include "../Commands/CommandObjectExpression.h" 24#include "../Commands/CommandObjectFrame.h" 25#include "../Commands/CommandObjectGUI.h" 26#include "../Commands/CommandObjectHelp.h" 27#include "../Commands/CommandObjectLog.h" 28#include "../Commands/CommandObjectMemory.h" 29#include "../Commands/CommandObjectPlatform.h" 30#include "../Commands/CommandObjectPlugin.h" 31#include "../Commands/CommandObjectProcess.h" 32#include "../Commands/CommandObjectQuit.h" 33#include "../Commands/CommandObjectRegister.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/CommandObjectType.h" 41#include "../Commands/CommandObjectVersion.h" 42#include "../Commands/CommandObjectWatchpoint.h" 43 44 45#include "lldb/Core/Debugger.h" 46#include "lldb/Core/Log.h" 47#include "lldb/Core/Stream.h" 48#include "lldb/Core/StreamFile.h" 49#include "lldb/Core/Timer.h" 50 51#include "lldb/Host/Editline.h" 52#include "lldb/Host/Host.h" 53 54#include "lldb/Interpreter/Args.h" 55#include "lldb/Interpreter/CommandCompletions.h" 56#include "lldb/Interpreter/CommandInterpreter.h" 57#include "lldb/Interpreter/CommandReturnObject.h" 58#include "lldb/Interpreter/Options.h" 59#include "lldb/Interpreter/ScriptInterpreterNone.h" 60#include "lldb/Interpreter/ScriptInterpreterPython.h" 61 62 63#include "lldb/Target/Process.h" 64#include "lldb/Target/Thread.h" 65#include "lldb/Target/TargetList.h" 66 67#include "lldb/Utility/CleanUp.h" 68 69using namespace lldb; 70using namespace lldb_private; 71 72 73static PropertyDefinition 74g_properties[] = 75{ 76 { "expand-regex-aliases", OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands." }, 77 { "prompt-on-quit", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case." }, 78 { "stop-command-source-on-error", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, LLDB will stop running a 'command source' script upon encountering an error." }, 79 { NULL , OptionValue::eTypeInvalid, true, 0 , NULL, NULL, NULL } 80}; 81 82enum 83{ 84 ePropertyExpandRegexAliases = 0, 85 ePropertyPromptOnQuit = 1, 86 ePropertyStopCmdSourceOnError = 2 87}; 88 89ConstString & 90CommandInterpreter::GetStaticBroadcasterClass () 91{ 92 static ConstString class_name ("lldb.commandInterpreter"); 93 return class_name; 94} 95 96CommandInterpreter::CommandInterpreter 97( 98 Debugger &debugger, 99 ScriptLanguage script_language, 100 bool synchronous_execution 101) : 102 Broadcaster (&debugger, "lldb.command-interpreter"), 103 Properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter")))), 104 IOHandlerDelegate (IOHandlerDelegate::Completion::LLDBCommand), 105 m_debugger (debugger), 106 m_synchronous_execution (synchronous_execution), 107 m_skip_lldbinit_files (false), 108 m_skip_app_init_files (false), 109 m_script_interpreter_ap (), 110 m_command_io_handler_sp (), 111 m_comment_char ('#'), 112 m_batch_command_mode (false), 113 m_truncation_warning(eNoTruncation), 114 m_command_source_depth (0) 115{ 116 debugger.SetScriptLanguage (script_language); 117 SetEventName (eBroadcastBitThreadShouldExit, "thread-should-exit"); 118 SetEventName (eBroadcastBitResetPrompt, "reset-prompt"); 119 SetEventName (eBroadcastBitQuitCommandReceived, "quit"); 120 CheckInWithManager (); 121 m_collection_sp->Initialize (g_properties); 122} 123 124bool 125CommandInterpreter::GetExpandRegexAliases () const 126{ 127 const uint32_t idx = ePropertyExpandRegexAliases; 128 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 129} 130 131bool 132CommandInterpreter::GetPromptOnQuit () const 133{ 134 const uint32_t idx = ePropertyPromptOnQuit; 135 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 136} 137 138bool 139CommandInterpreter::GetStopCmdSourceOnError () const 140{ 141 const uint32_t idx = ePropertyStopCmdSourceOnError; 142 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0); 143} 144 145void 146CommandInterpreter::Initialize () 147{ 148 Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); 149 150 CommandReturnObject result; 151 152 LoadCommandDictionary (); 153 154 // Set up some initial aliases. 155 CommandObjectSP cmd_obj_sp = GetCommandSPExact ("quit", false); 156 if (cmd_obj_sp) 157 { 158 AddAlias ("q", cmd_obj_sp); 159 AddAlias ("exit", cmd_obj_sp); 160 } 161 162 cmd_obj_sp = GetCommandSPExact ("_regexp-attach",false); 163 if (cmd_obj_sp) 164 { 165 AddAlias ("attach", cmd_obj_sp); 166 } 167 168 cmd_obj_sp = GetCommandSPExact ("process detach",false); 169 if (cmd_obj_sp) 170 { 171 AddAlias ("detach", cmd_obj_sp); 172 } 173 174 cmd_obj_sp = GetCommandSPExact ("process continue", false); 175 if (cmd_obj_sp) 176 { 177 AddAlias ("c", cmd_obj_sp); 178 AddAlias ("continue", cmd_obj_sp); 179 } 180 181 cmd_obj_sp = GetCommandSPExact ("_regexp-break",false); 182 if (cmd_obj_sp) 183 AddAlias ("b", cmd_obj_sp); 184 185 cmd_obj_sp = GetCommandSPExact ("_regexp-tbreak",false); 186 if (cmd_obj_sp) 187 AddAlias ("tbreak", cmd_obj_sp); 188 189 cmd_obj_sp = GetCommandSPExact ("thread step-inst", false); 190 if (cmd_obj_sp) 191 { 192 AddAlias ("stepi", cmd_obj_sp); 193 AddAlias ("si", cmd_obj_sp); 194 } 195 196 cmd_obj_sp = GetCommandSPExact ("thread step-inst-over", false); 197 if (cmd_obj_sp) 198 { 199 AddAlias ("nexti", cmd_obj_sp); 200 AddAlias ("ni", cmd_obj_sp); 201 } 202 203 cmd_obj_sp = GetCommandSPExact ("thread step-in", false); 204 if (cmd_obj_sp) 205 { 206 AddAlias ("s", cmd_obj_sp); 207 AddAlias ("step", cmd_obj_sp); 208 } 209 210 cmd_obj_sp = GetCommandSPExact ("thread step-over", false); 211 if (cmd_obj_sp) 212 { 213 AddAlias ("n", cmd_obj_sp); 214 AddAlias ("next", cmd_obj_sp); 215 } 216 217 cmd_obj_sp = GetCommandSPExact ("thread step-out", false); 218 if (cmd_obj_sp) 219 { 220 AddAlias ("finish", cmd_obj_sp); 221 } 222 223 cmd_obj_sp = GetCommandSPExact ("frame select", false); 224 if (cmd_obj_sp) 225 { 226 AddAlias ("f", cmd_obj_sp); 227 } 228 229 cmd_obj_sp = GetCommandSPExact ("thread select", false); 230 if (cmd_obj_sp) 231 { 232 AddAlias ("t", cmd_obj_sp); 233 } 234 235 cmd_obj_sp = GetCommandSPExact ("_regexp-jump",false); 236 if (cmd_obj_sp) 237 { 238 AddAlias ("j", cmd_obj_sp); 239 AddAlias ("jump", cmd_obj_sp); 240 } 241 242 cmd_obj_sp = GetCommandSPExact ("_regexp-list", false); 243 if (cmd_obj_sp) 244 { 245 AddAlias ("l", cmd_obj_sp); 246 AddAlias ("list", cmd_obj_sp); 247 } 248 249 cmd_obj_sp = GetCommandSPExact ("_regexp-env", false); 250 if (cmd_obj_sp) 251 { 252 AddAlias ("env", cmd_obj_sp); 253 } 254 255 cmd_obj_sp = GetCommandSPExact ("memory read", false); 256 if (cmd_obj_sp) 257 AddAlias ("x", cmd_obj_sp); 258 259 cmd_obj_sp = GetCommandSPExact ("_regexp-up", false); 260 if (cmd_obj_sp) 261 AddAlias ("up", cmd_obj_sp); 262 263 cmd_obj_sp = GetCommandSPExact ("_regexp-down", false); 264 if (cmd_obj_sp) 265 AddAlias ("down", cmd_obj_sp); 266 267 cmd_obj_sp = GetCommandSPExact ("_regexp-display", false); 268 if (cmd_obj_sp) 269 AddAlias ("display", cmd_obj_sp); 270 271 cmd_obj_sp = GetCommandSPExact ("disassemble", false); 272 if (cmd_obj_sp) 273 AddAlias ("dis", cmd_obj_sp); 274 275 cmd_obj_sp = GetCommandSPExact ("disassemble", false); 276 if (cmd_obj_sp) 277 AddAlias ("di", cmd_obj_sp); 278 279 280 281 cmd_obj_sp = GetCommandSPExact ("_regexp-undisplay", false); 282 if (cmd_obj_sp) 283 AddAlias ("undisplay", cmd_obj_sp); 284 285 cmd_obj_sp = GetCommandSPExact ("_regexp-bt", false); 286 if (cmd_obj_sp) 287 AddAlias ("bt", cmd_obj_sp); 288 289 cmd_obj_sp = GetCommandSPExact ("target create", false); 290 if (cmd_obj_sp) 291 AddAlias ("file", cmd_obj_sp); 292 293 cmd_obj_sp = GetCommandSPExact ("target modules", false); 294 if (cmd_obj_sp) 295 AddAlias ("image", cmd_obj_sp); 296 297 298 OptionArgVectorSP alias_arguments_vector_sp (new OptionArgVector); 299 300 cmd_obj_sp = GetCommandSPExact ("expression", false); 301 if (cmd_obj_sp) 302 { 303 ProcessAliasOptionsArgs (cmd_obj_sp, "--", alias_arguments_vector_sp); 304 AddAlias ("p", cmd_obj_sp); 305 AddAlias ("print", cmd_obj_sp); 306 AddAlias ("call", cmd_obj_sp); 307 AddOrReplaceAliasOptions ("p", alias_arguments_vector_sp); 308 AddOrReplaceAliasOptions ("print", alias_arguments_vector_sp); 309 AddOrReplaceAliasOptions ("call", alias_arguments_vector_sp); 310 311 alias_arguments_vector_sp.reset (new OptionArgVector); 312 ProcessAliasOptionsArgs (cmd_obj_sp, "-O -- ", alias_arguments_vector_sp); 313 AddAlias ("po", cmd_obj_sp); 314 AddOrReplaceAliasOptions ("po", alias_arguments_vector_sp); 315 } 316 317 cmd_obj_sp = GetCommandSPExact ("process kill", false); 318 if (cmd_obj_sp) 319 { 320 AddAlias ("kill", cmd_obj_sp); 321 } 322 323 cmd_obj_sp = GetCommandSPExact ("process launch", false); 324 if (cmd_obj_sp) 325 { 326 alias_arguments_vector_sp.reset (new OptionArgVector); 327#if defined (__arm__) 328 ProcessAliasOptionsArgs (cmd_obj_sp, "--", alias_arguments_vector_sp); 329#else 330 ProcessAliasOptionsArgs (cmd_obj_sp, "--shell=" LLDB_DEFAULT_SHELL " --", alias_arguments_vector_sp); 331#endif 332 AddAlias ("r", cmd_obj_sp); 333 AddAlias ("run", cmd_obj_sp); 334 AddOrReplaceAliasOptions ("r", alias_arguments_vector_sp); 335 AddOrReplaceAliasOptions ("run", alias_arguments_vector_sp); 336 } 337 338 cmd_obj_sp = GetCommandSPExact ("target symbols add", false); 339 if (cmd_obj_sp) 340 { 341 AddAlias ("add-dsym", cmd_obj_sp); 342 } 343 344 cmd_obj_sp = GetCommandSPExact ("breakpoint set", false); 345 if (cmd_obj_sp) 346 { 347 alias_arguments_vector_sp.reset (new OptionArgVector); 348 ProcessAliasOptionsArgs (cmd_obj_sp, "--func-regex %1", alias_arguments_vector_sp); 349 AddAlias ("rbreak", cmd_obj_sp); 350 AddOrReplaceAliasOptions("rbreak", alias_arguments_vector_sp); 351 } 352} 353 354const char * 355CommandInterpreter::ProcessEmbeddedScriptCommands (const char *arg) 356{ 357 // This function has not yet been implemented. 358 359 // Look for any embedded script command 360 // If found, 361 // get interpreter object from the command dictionary, 362 // call execute_one_command on it, 363 // get the results as a string, 364 // substitute that string for current stuff. 365 366 return arg; 367} 368 369 370void 371CommandInterpreter::LoadCommandDictionary () 372{ 373 Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__); 374 375 lldb::ScriptLanguage script_language = m_debugger.GetScriptLanguage(); 376 377 m_command_dict["apropos"] = CommandObjectSP (new CommandObjectApropos (*this)); 378 m_command_dict["breakpoint"]= CommandObjectSP (new CommandObjectMultiwordBreakpoint (*this)); 379 m_command_dict["command"] = CommandObjectSP (new CommandObjectMultiwordCommands (*this)); 380 m_command_dict["disassemble"] = CommandObjectSP (new CommandObjectDisassemble (*this)); 381 m_command_dict["expression"]= CommandObjectSP (new CommandObjectExpression (*this)); 382 m_command_dict["frame"] = CommandObjectSP (new CommandObjectMultiwordFrame (*this)); 383 m_command_dict["gui"] = CommandObjectSP (new CommandObjectGUI (*this)); 384 m_command_dict["help"] = CommandObjectSP (new CommandObjectHelp (*this)); 385 m_command_dict["log"] = CommandObjectSP (new CommandObjectLog (*this)); 386 m_command_dict["memory"] = CommandObjectSP (new CommandObjectMemory (*this)); 387 m_command_dict["platform"] = CommandObjectSP (new CommandObjectPlatform (*this)); 388 m_command_dict["plugin"] = CommandObjectSP (new CommandObjectPlugin (*this)); 389 m_command_dict["process"] = CommandObjectSP (new CommandObjectMultiwordProcess (*this)); 390 m_command_dict["quit"] = CommandObjectSP (new CommandObjectQuit (*this)); 391 m_command_dict["register"] = CommandObjectSP (new CommandObjectRegister (*this)); 392 m_command_dict["script"] = CommandObjectSP (new CommandObjectScript (*this, script_language)); 393 m_command_dict["settings"] = CommandObjectSP (new CommandObjectMultiwordSettings (*this)); 394 m_command_dict["source"] = CommandObjectSP (new CommandObjectMultiwordSource (*this)); 395 m_command_dict["target"] = CommandObjectSP (new CommandObjectMultiwordTarget (*this)); 396 m_command_dict["thread"] = CommandObjectSP (new CommandObjectMultiwordThread (*this)); 397 m_command_dict["type"] = CommandObjectSP (new CommandObjectType (*this)); 398 m_command_dict["version"] = CommandObjectSP (new CommandObjectVersion (*this)); 399 m_command_dict["watchpoint"]= CommandObjectSP (new CommandObjectMultiwordWatchpoint (*this)); 400 401 const char *break_regexes[][2] = {{"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "breakpoint set --file '%1' --line %2"}, 402 {"^([[:digit:]]+)[[:space:]]*$", "breakpoint set --line %1"}, 403 {"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1"}, 404 {"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$", "breakpoint set --name '%1'"}, 405 {"^(-.*)$", "breakpoint set %1"}, 406 {"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%2' --shlib '%1'"}, 407 {"^\\&(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%1' --skip-prologue=0"}, 408 {"^(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%1'"}}; 409 410 size_t num_regexes = sizeof break_regexes/sizeof(char *[2]); 411 412 std::unique_ptr<CommandObjectRegexCommand> 413 break_regex_cmd_ap(new CommandObjectRegexCommand (*this, 414 "_regexp-break", 415 "Set a breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.", 416 "_regexp-break [<filename>:<linenum>]\n_regexp-break [<linenum>]\n_regexp-break [<address>]\n_regexp-break <...>", 417 2, 418 CommandCompletions::eSymbolCompletion | 419 CommandCompletions::eSourceFileCompletion)); 420 421 if (break_regex_cmd_ap.get()) 422 { 423 bool success = true; 424 for (size_t i = 0; i < num_regexes; i++) 425 { 426 success = break_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], break_regexes[i][1]); 427 if (!success) 428 break; 429 } 430 success = break_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full"); 431 432 if (success) 433 { 434 CommandObjectSP break_regex_cmd_sp(break_regex_cmd_ap.release()); 435 m_command_dict[break_regex_cmd_sp->GetCommandName ()] = break_regex_cmd_sp; 436 } 437 } 438 439 std::unique_ptr<CommandObjectRegexCommand> 440 tbreak_regex_cmd_ap(new CommandObjectRegexCommand (*this, 441 "_regexp-tbreak", 442 "Set a one shot breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.", 443 "_regexp-tbreak [<filename>:<linenum>]\n_regexp-break [<linenum>]\n_regexp-break [<address>]\n_regexp-break <...>", 444 2, 445 CommandCompletions::eSymbolCompletion | 446 CommandCompletions::eSourceFileCompletion)); 447 448 if (tbreak_regex_cmd_ap.get()) 449 { 450 bool success = true; 451 for (size_t i = 0; i < num_regexes; i++) 452 { 453 // If you add a resultant command string longer than 1024 characters be sure to increase the size of this buffer. 454 char buffer[1024]; 455 int num_printed = snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o"); 456 assert (num_printed < 1024); 457 success = tbreak_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], buffer); 458 if (!success) 459 break; 460 } 461 success = tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full"); 462 463 if (success) 464 { 465 CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_ap.release()); 466 m_command_dict[tbreak_regex_cmd_sp->GetCommandName ()] = tbreak_regex_cmd_sp; 467 } 468 } 469 470 std::unique_ptr<CommandObjectRegexCommand> 471 attach_regex_cmd_ap(new CommandObjectRegexCommand (*this, 472 "_regexp-attach", 473 "Attach to a process id if in decimal, otherwise treat the argument as a process name to attach to.", 474 "_regexp-attach [<pid>]\n_regexp-attach [<process-name>]", 475 2)); 476 if (attach_regex_cmd_ap.get()) 477 { 478 if (attach_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", "process attach --pid %1") && 479 attach_regex_cmd_ap->AddRegexCommand("^(-.*|.* -.*)$", "process attach %1") && // Any options that are specified get passed to 'process attach' 480 attach_regex_cmd_ap->AddRegexCommand("^(.+)$", "process attach --name '%1'") && 481 attach_regex_cmd_ap->AddRegexCommand("^$", "process attach")) 482 { 483 CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_ap.release()); 484 m_command_dict[attach_regex_cmd_sp->GetCommandName ()] = attach_regex_cmd_sp; 485 } 486 } 487 488 std::unique_ptr<CommandObjectRegexCommand> 489 down_regex_cmd_ap(new CommandObjectRegexCommand (*this, 490 "_regexp-down", 491 "Go down \"n\" frames in the stack (1 frame by default).", 492 "_regexp-down [n]", 2)); 493 if (down_regex_cmd_ap.get()) 494 { 495 if (down_regex_cmd_ap->AddRegexCommand("^$", "frame select -r -1") && 496 down_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r -%1")) 497 { 498 CommandObjectSP down_regex_cmd_sp(down_regex_cmd_ap.release()); 499 m_command_dict[down_regex_cmd_sp->GetCommandName ()] = down_regex_cmd_sp; 500 } 501 } 502 503 std::unique_ptr<CommandObjectRegexCommand> 504 up_regex_cmd_ap(new CommandObjectRegexCommand (*this, 505 "_regexp-up", 506 "Go up \"n\" frames in the stack (1 frame by default).", 507 "_regexp-up [n]", 2)); 508 if (up_regex_cmd_ap.get()) 509 { 510 if (up_regex_cmd_ap->AddRegexCommand("^$", "frame select -r 1") && 511 up_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r %1")) 512 { 513 CommandObjectSP up_regex_cmd_sp(up_regex_cmd_ap.release()); 514 m_command_dict[up_regex_cmd_sp->GetCommandName ()] = up_regex_cmd_sp; 515 } 516 } 517 518 std::unique_ptr<CommandObjectRegexCommand> 519 display_regex_cmd_ap(new CommandObjectRegexCommand (*this, 520 "_regexp-display", 521 "Add an expression evaluation stop-hook.", 522 "_regexp-display expression", 2)); 523 if (display_regex_cmd_ap.get()) 524 { 525 if (display_regex_cmd_ap->AddRegexCommand("^(.+)$", "target stop-hook add -o \"expr -- %1\"")) 526 { 527 CommandObjectSP display_regex_cmd_sp(display_regex_cmd_ap.release()); 528 m_command_dict[display_regex_cmd_sp->GetCommandName ()] = display_regex_cmd_sp; 529 } 530 } 531 532 std::unique_ptr<CommandObjectRegexCommand> 533 undisplay_regex_cmd_ap(new CommandObjectRegexCommand (*this, 534 "_regexp-undisplay", 535 "Remove an expression evaluation stop-hook.", 536 "_regexp-undisplay stop-hook-number", 2)); 537 if (undisplay_regex_cmd_ap.get()) 538 { 539 if (undisplay_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "target stop-hook delete %1")) 540 { 541 CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_ap.release()); 542 m_command_dict[undisplay_regex_cmd_sp->GetCommandName ()] = undisplay_regex_cmd_sp; 543 } 544 } 545 546 std::unique_ptr<CommandObjectRegexCommand> 547 connect_gdb_remote_cmd_ap(new CommandObjectRegexCommand (*this, 548 "gdb-remote", 549 "Connect to a remote GDB server. If no hostname is provided, localhost is assumed.", 550 "gdb-remote [<hostname>:]<portnum>", 2)); 551 if (connect_gdb_remote_cmd_ap.get()) 552 { 553 if (connect_gdb_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin gdb-remote connect://%1") && 554 connect_gdb_remote_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "process connect --plugin gdb-remote connect://localhost:%1")) 555 { 556 CommandObjectSP command_sp(connect_gdb_remote_cmd_ap.release()); 557 m_command_dict[command_sp->GetCommandName ()] = command_sp; 558 } 559 } 560 561 std::unique_ptr<CommandObjectRegexCommand> 562 connect_kdp_remote_cmd_ap(new CommandObjectRegexCommand (*this, 563 "kdp-remote", 564 "Connect to a remote KDP server. udp port 41139 is the default port number.", 565 "kdp-remote <hostname>[:<portnum>]", 2)); 566 if (connect_kdp_remote_cmd_ap.get()) 567 { 568 if (connect_kdp_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin kdp-remote udp://%1") && 569 connect_kdp_remote_cmd_ap->AddRegexCommand("^(.+)$", "process connect --plugin kdp-remote udp://%1:41139")) 570 { 571 CommandObjectSP command_sp(connect_kdp_remote_cmd_ap.release()); 572 m_command_dict[command_sp->GetCommandName ()] = command_sp; 573 } 574 } 575 576 std::unique_ptr<CommandObjectRegexCommand> 577 bt_regex_cmd_ap(new CommandObjectRegexCommand (*this, 578 "_regexp-bt", 579 "Show a backtrace. An optional argument is accepted; if that argument is a number, it specifies the number of frames to display. If that argument is 'all', full backtraces of all threads are displayed.", 580 "bt [<digit>|all]", 2)); 581 if (bt_regex_cmd_ap.get()) 582 { 583 // accept but don't document "bt -c <number>" -- before bt was a regex command if you wanted to backtrace 584 // three frames you would do "bt -c 3" but the intention is to have this emulate the gdb "bt" command and 585 // so now "bt 3" is the preferred form, in line with gdb. 586 if (bt_regex_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "thread backtrace -c %1") && 587 bt_regex_cmd_ap->AddRegexCommand("^-c ([[:digit:]]+)$", "thread backtrace -c %1") && 588 bt_regex_cmd_ap->AddRegexCommand("^all$", "thread backtrace all") && 589 bt_regex_cmd_ap->AddRegexCommand("^$", "thread backtrace")) 590 { 591 CommandObjectSP command_sp(bt_regex_cmd_ap.release()); 592 m_command_dict[command_sp->GetCommandName ()] = command_sp; 593 } 594 } 595 596 std::unique_ptr<CommandObjectRegexCommand> 597 list_regex_cmd_ap(new CommandObjectRegexCommand (*this, 598 "_regexp-list", 599 "Implements the GDB 'list' command in all of its forms except FILE:FUNCTION and maps them to the appropriate 'source list' commands.", 600 "_regexp-list [<line>]\n_regexp-list [<file>:<line>]\n_regexp-list [<file>:<line>]", 601 2, 602 CommandCompletions::eSourceFileCompletion)); 603 if (list_regex_cmd_ap.get()) 604 { 605 if (list_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", "source list --line %1") && 606 list_regex_cmd_ap->AddRegexCommand("^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "source list --file '%1' --line %2") && 607 list_regex_cmd_ap->AddRegexCommand("^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "source list --address %1") && 608 list_regex_cmd_ap->AddRegexCommand("^-[[:space:]]*$", "source list --reverse") && 609 list_regex_cmd_ap->AddRegexCommand("^-([[:digit:]]+)[[:space:]]*$", "source list --reverse --count %1") && 610 list_regex_cmd_ap->AddRegexCommand("^(.+)$", "source list --name \"%1\"") && 611 list_regex_cmd_ap->AddRegexCommand("^$", "source list")) 612 { 613 CommandObjectSP list_regex_cmd_sp(list_regex_cmd_ap.release()); 614 m_command_dict[list_regex_cmd_sp->GetCommandName ()] = list_regex_cmd_sp; 615 } 616 } 617 618 std::unique_ptr<CommandObjectRegexCommand> 619 env_regex_cmd_ap(new CommandObjectRegexCommand (*this, 620 "_regexp-env", 621 "Implements a shortcut to viewing and setting environment variables.", 622 "_regexp-env\n_regexp-env FOO=BAR", 2)); 623 if (env_regex_cmd_ap.get()) 624 { 625 if (env_regex_cmd_ap->AddRegexCommand("^$", "settings show target.env-vars") && 626 env_regex_cmd_ap->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$", "settings set target.env-vars %1")) 627 { 628 CommandObjectSP env_regex_cmd_sp(env_regex_cmd_ap.release()); 629 m_command_dict[env_regex_cmd_sp->GetCommandName ()] = env_regex_cmd_sp; 630 } 631 } 632 633 std::unique_ptr<CommandObjectRegexCommand> 634 jump_regex_cmd_ap(new CommandObjectRegexCommand (*this, 635 "_regexp-jump", 636 "Sets the program counter to a new address.", 637 "_regexp-jump [<line>]\n" 638 "_regexp-jump [<+-lineoffset>]\n" 639 "_regexp-jump [<file>:<line>]\n" 640 "_regexp-jump [*<addr>]\n", 2)); 641 if (jump_regex_cmd_ap.get()) 642 { 643 if (jump_regex_cmd_ap->AddRegexCommand("^\\*(.*)$", "thread jump --addr %1") && 644 jump_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "thread jump --line %1") && 645 jump_regex_cmd_ap->AddRegexCommand("^([^:]+):([0-9]+)$", "thread jump --file %1 --line %2") && 646 jump_regex_cmd_ap->AddRegexCommand("^([+\\-][0-9]+)$", "thread jump --by %1")) 647 { 648 CommandObjectSP jump_regex_cmd_sp(jump_regex_cmd_ap.release()); 649 m_command_dict[jump_regex_cmd_sp->GetCommandName ()] = jump_regex_cmd_sp; 650 } 651 } 652 653} 654 655int 656CommandInterpreter::GetCommandNamesMatchingPartialString (const char *cmd_str, bool include_aliases, 657 StringList &matches) 658{ 659 CommandObject::AddNamesMatchingPartialString (m_command_dict, cmd_str, matches); 660 661 if (include_aliases) 662 { 663 CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd_str, matches); 664 } 665 666 return matches.GetSize(); 667} 668 669CommandObjectSP 670CommandInterpreter::GetCommandSP (const char *cmd_cstr, bool include_aliases, bool exact, StringList *matches) 671{ 672 CommandObject::CommandMap::iterator pos; 673 CommandObjectSP command_sp; 674 675 std::string cmd(cmd_cstr); 676 677 if (HasCommands()) 678 { 679 pos = m_command_dict.find(cmd); 680 if (pos != m_command_dict.end()) 681 command_sp = pos->second; 682 } 683 684 if (include_aliases && HasAliases()) 685 { 686 pos = m_alias_dict.find(cmd); 687 if (pos != m_alias_dict.end()) 688 command_sp = pos->second; 689 } 690 691 if (HasUserCommands()) 692 { 693 pos = m_user_dict.find(cmd); 694 if (pos != m_user_dict.end()) 695 command_sp = pos->second; 696 } 697 698 if (!exact && !command_sp) 699 { 700 // We will only get into here if we didn't find any exact matches. 701 702 CommandObjectSP user_match_sp, alias_match_sp, real_match_sp; 703 704 StringList local_matches; 705 if (matches == NULL) 706 matches = &local_matches; 707 708 unsigned int num_cmd_matches = 0; 709 unsigned int num_alias_matches = 0; 710 unsigned int num_user_matches = 0; 711 712 // Look through the command dictionaries one by one, and if we get only one match from any of 713 // them in toto, then return that, otherwise return an empty CommandObjectSP and the list of matches. 714 715 if (HasCommands()) 716 { 717 num_cmd_matches = CommandObject::AddNamesMatchingPartialString (m_command_dict, cmd_cstr, *matches); 718 } 719 720 if (num_cmd_matches == 1) 721 { 722 cmd.assign(matches->GetStringAtIndex(0)); 723 pos = m_command_dict.find(cmd); 724 if (pos != m_command_dict.end()) 725 real_match_sp = pos->second; 726 } 727 728 if (include_aliases && HasAliases()) 729 { 730 num_alias_matches = CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd_cstr, *matches); 731 732 } 733 734 if (num_alias_matches == 1) 735 { 736 cmd.assign(matches->GetStringAtIndex (num_cmd_matches)); 737 pos = m_alias_dict.find(cmd); 738 if (pos != m_alias_dict.end()) 739 alias_match_sp = pos->second; 740 } 741 742 if (HasUserCommands()) 743 { 744 num_user_matches = CommandObject::AddNamesMatchingPartialString (m_user_dict, cmd_cstr, *matches); 745 } 746 747 if (num_user_matches == 1) 748 { 749 cmd.assign (matches->GetStringAtIndex (num_cmd_matches + num_alias_matches)); 750 751 pos = m_user_dict.find (cmd); 752 if (pos != m_user_dict.end()) 753 user_match_sp = pos->second; 754 } 755 756 // If we got exactly one match, return that, otherwise return the match list. 757 758 if (num_user_matches + num_cmd_matches + num_alias_matches == 1) 759 { 760 if (num_cmd_matches) 761 return real_match_sp; 762 else if (num_alias_matches) 763 return alias_match_sp; 764 else 765 return user_match_sp; 766 } 767 } 768 else if (matches && command_sp) 769 { 770 matches->AppendString (cmd_cstr); 771 } 772 773 774 return command_sp; 775} 776 777bool 778CommandInterpreter::AddCommand (const char *name, const lldb::CommandObjectSP &cmd_sp, bool can_replace) 779{ 780 if (name && name[0]) 781 { 782 std::string name_sstr(name); 783 bool found = (m_command_dict.find (name_sstr) != m_command_dict.end()); 784 if (found && !can_replace) 785 return false; 786 if (found && m_command_dict[name_sstr]->IsRemovable() == false) 787 return false; 788 m_command_dict[name_sstr] = cmd_sp; 789 return true; 790 } 791 return false; 792} 793 794bool 795CommandInterpreter::AddUserCommand (std::string name, 796 const lldb::CommandObjectSP &cmd_sp, 797 bool can_replace) 798{ 799 if (!name.empty()) 800 { 801 802 const char* name_cstr = name.c_str(); 803 804 // do not allow replacement of internal commands 805 if (CommandExists(name_cstr)) 806 { 807 if (can_replace == false) 808 return false; 809 if (m_command_dict[name]->IsRemovable() == false) 810 return false; 811 } 812 813 if (UserCommandExists(name_cstr)) 814 { 815 if (can_replace == false) 816 return false; 817 if (m_user_dict[name]->IsRemovable() == false) 818 return false; 819 } 820 821 m_user_dict[name] = cmd_sp; 822 return true; 823 } 824 return false; 825} 826 827CommandObjectSP 828CommandInterpreter::GetCommandSPExact (const char *cmd_cstr, bool include_aliases) 829{ 830 Args cmd_words (cmd_cstr); // Break up the command string into words, in case it's a multi-word command. 831 CommandObjectSP ret_val; // Possibly empty return value. 832 833 if (cmd_cstr == NULL) 834 return ret_val; 835 836 if (cmd_words.GetArgumentCount() == 1) 837 return GetCommandSP(cmd_cstr, include_aliases, true, NULL); 838 else 839 { 840 // We have a multi-word command (seemingly), so we need to do more work. 841 // First, get the cmd_obj_sp for the first word in the command. 842 CommandObjectSP cmd_obj_sp = GetCommandSP (cmd_words.GetArgumentAtIndex (0), include_aliases, true, NULL); 843 if (cmd_obj_sp.get() != NULL) 844 { 845 // Loop through the rest of the words in the command (everything passed in was supposed to be part of a 846 // command name), and find the appropriate sub-command SP for each command word.... 847 size_t end = cmd_words.GetArgumentCount(); 848 for (size_t j= 1; j < end; ++j) 849 { 850 if (cmd_obj_sp->IsMultiwordObject()) 851 { 852 cmd_obj_sp = cmd_obj_sp->GetSubcommandSP (cmd_words.GetArgumentAtIndex (j)); 853 if (cmd_obj_sp.get() == NULL) 854 // The sub-command name was invalid. Fail and return the empty 'ret_val'. 855 return ret_val; 856 } 857 else 858 // We have more words in the command name, but we don't have a multiword object. Fail and return 859 // empty 'ret_val'. 860 return ret_val; 861 } 862 // We successfully looped through all the command words and got valid command objects for them. Assign the 863 // last object retrieved to 'ret_val'. 864 ret_val = cmd_obj_sp; 865 } 866 } 867 return ret_val; 868} 869 870CommandObject * 871CommandInterpreter::GetCommandObjectExact (const char *cmd_cstr, bool include_aliases) 872{ 873 return GetCommandSPExact (cmd_cstr, include_aliases).get(); 874} 875 876CommandObject * 877CommandInterpreter::GetCommandObject (const char *cmd_cstr, StringList *matches) 878{ 879 CommandObject *command_obj = GetCommandSP (cmd_cstr, false, true, matches).get(); 880 881 // If we didn't find an exact match to the command string in the commands, look in 882 // the aliases. 883 884 if (command_obj) 885 return command_obj; 886 887 command_obj = GetCommandSP (cmd_cstr, true, true, matches).get(); 888 889 if (command_obj) 890 return command_obj; 891 892 // If there wasn't an exact match then look for an inexact one in just the commands 893 command_obj = GetCommandSP(cmd_cstr, false, false, NULL).get(); 894 895 // Finally, if there wasn't an inexact match among the commands, look for an inexact 896 // match in both the commands and aliases. 897 898 if (command_obj) 899 { 900 if (matches) 901 matches->AppendString(command_obj->GetCommandName()); 902 return command_obj; 903 } 904 905 return GetCommandSP(cmd_cstr, true, false, matches).get(); 906} 907 908bool 909CommandInterpreter::CommandExists (const char *cmd) 910{ 911 return m_command_dict.find(cmd) != m_command_dict.end(); 912} 913 914bool 915CommandInterpreter::ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp, 916 const char *options_args, 917 OptionArgVectorSP &option_arg_vector_sp) 918{ 919 bool success = true; 920 OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); 921 922 if (!options_args || (strlen (options_args) < 1)) 923 return true; 924 925 std::string options_string (options_args); 926 Args args (options_args); 927 CommandReturnObject result; 928 // Check to see if the command being aliased can take any command options. 929 Options *options = cmd_obj_sp->GetOptions (); 930 if (options) 931 { 932 // See if any options were specified as part of the alias; if so, handle them appropriately. 933 options->NotifyOptionParsingStarting (); 934 args.Unshift ("dummy_arg"); 935 args.ParseAliasOptions (*options, result, option_arg_vector, options_string); 936 args.Shift (); 937 if (result.Succeeded()) 938 options->VerifyPartialOptions (result); 939 if (!result.Succeeded() && result.GetStatus() != lldb::eReturnStatusStarted) 940 { 941 result.AppendError ("Unable to create requested alias.\n"); 942 return false; 943 } 944 } 945 946 if (!options_string.empty()) 947 { 948 if (cmd_obj_sp->WantsRawCommandString ()) 949 option_arg_vector->push_back (OptionArgPair ("<argument>", 950 OptionArgValue (-1, 951 options_string))); 952 else 953 { 954 const size_t argc = args.GetArgumentCount(); 955 for (size_t i = 0; i < argc; ++i) 956 if (strcmp (args.GetArgumentAtIndex (i), "") != 0) 957 option_arg_vector->push_back 958 (OptionArgPair ("<argument>", 959 OptionArgValue (-1, 960 std::string (args.GetArgumentAtIndex (i))))); 961 } 962 } 963 964 return success; 965} 966 967bool 968CommandInterpreter::GetAliasFullName (const char *cmd, std::string &full_name) 969{ 970 bool exact_match = (m_alias_dict.find(cmd) != m_alias_dict.end()); 971 if (exact_match) 972 { 973 full_name.assign(cmd); 974 return exact_match; 975 } 976 else 977 { 978 StringList matches; 979 size_t num_alias_matches; 980 num_alias_matches = CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd, matches); 981 if (num_alias_matches == 1) 982 { 983 // Make sure this isn't shadowing a command in the regular command space: 984 StringList regular_matches; 985 const bool include_aliases = false; 986 const bool exact = false; 987 CommandObjectSP cmd_obj_sp(GetCommandSP (cmd, include_aliases, exact, ®ular_matches)); 988 if (cmd_obj_sp || regular_matches.GetSize() > 0) 989 return false; 990 else 991 { 992 full_name.assign (matches.GetStringAtIndex(0)); 993 return true; 994 } 995 } 996 else 997 return false; 998 } 999} 1000 1001bool 1002CommandInterpreter::AliasExists (const char *cmd) 1003{ 1004 return m_alias_dict.find(cmd) != m_alias_dict.end(); 1005} 1006 1007bool 1008CommandInterpreter::UserCommandExists (const char *cmd) 1009{ 1010 return m_user_dict.find(cmd) != m_user_dict.end(); 1011} 1012 1013void 1014CommandInterpreter::AddAlias (const char *alias_name, CommandObjectSP& command_obj_sp) 1015{ 1016 command_obj_sp->SetIsAlias (true); 1017 m_alias_dict[alias_name] = command_obj_sp; 1018} 1019 1020bool 1021CommandInterpreter::RemoveAlias (const char *alias_name) 1022{ 1023 CommandObject::CommandMap::iterator pos = m_alias_dict.find(alias_name); 1024 if (pos != m_alias_dict.end()) 1025 { 1026 m_alias_dict.erase(pos); 1027 return true; 1028 } 1029 return false; 1030} 1031bool 1032CommandInterpreter::RemoveUser (const char *alias_name) 1033{ 1034 CommandObject::CommandMap::iterator pos = m_user_dict.find(alias_name); 1035 if (pos != m_user_dict.end()) 1036 { 1037 m_user_dict.erase(pos); 1038 return true; 1039 } 1040 return false; 1041} 1042 1043void 1044CommandInterpreter::GetAliasHelp (const char *alias_name, const char *command_name, StreamString &help_string) 1045{ 1046 help_string.Printf ("'%s", command_name); 1047 OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name); 1048 1049 if (option_arg_vector_sp) 1050 { 1051 OptionArgVector *options = option_arg_vector_sp.get(); 1052 for (size_t i = 0; i < options->size(); ++i) 1053 { 1054 OptionArgPair cur_option = (*options)[i]; 1055 std::string opt = cur_option.first; 1056 OptionArgValue value_pair = cur_option.second; 1057 std::string value = value_pair.second; 1058 if (opt.compare("<argument>") == 0) 1059 { 1060 help_string.Printf (" %s", value.c_str()); 1061 } 1062 else 1063 { 1064 help_string.Printf (" %s", opt.c_str()); 1065 if ((value.compare ("<no-argument>") != 0) 1066 && (value.compare ("<need-argument") != 0)) 1067 { 1068 help_string.Printf (" %s", value.c_str()); 1069 } 1070 } 1071 } 1072 } 1073 1074 help_string.Printf ("'"); 1075} 1076 1077size_t 1078CommandInterpreter::FindLongestCommandWord (CommandObject::CommandMap &dict) 1079{ 1080 CommandObject::CommandMap::const_iterator pos; 1081 CommandObject::CommandMap::const_iterator end = dict.end(); 1082 size_t max_len = 0; 1083 1084 for (pos = dict.begin(); pos != end; ++pos) 1085 { 1086 size_t len = pos->first.size(); 1087 if (max_len < len) 1088 max_len = len; 1089 } 1090 return max_len; 1091} 1092 1093void 1094CommandInterpreter::GetHelp (CommandReturnObject &result, 1095 uint32_t cmd_types) 1096{ 1097 CommandObject::CommandMap::const_iterator pos; 1098 size_t max_len = FindLongestCommandWord (m_command_dict); 1099 1100 if ( (cmd_types & eCommandTypesBuiltin) == eCommandTypesBuiltin ) 1101 { 1102 1103 result.AppendMessage("The following is a list of built-in, permanent debugger commands:"); 1104 result.AppendMessage(""); 1105 1106 for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos) 1107 { 1108 OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(), 1109 max_len); 1110 } 1111 result.AppendMessage(""); 1112 1113 } 1114 1115 if (!m_alias_dict.empty() && ( (cmd_types & eCommandTypesAliases) == eCommandTypesAliases )) 1116 { 1117 result.AppendMessage("The following is a list of your current command abbreviations " 1118 "(see 'help command alias' for more info):"); 1119 result.AppendMessage(""); 1120 max_len = FindLongestCommandWord (m_alias_dict); 1121 1122 for (pos = m_alias_dict.begin(); pos != m_alias_dict.end(); ++pos) 1123 { 1124 StreamString sstr; 1125 StreamString translation_and_help; 1126 std::string entry_name = pos->first; 1127 std::string second_entry = pos->second.get()->GetCommandName(); 1128 GetAliasHelp (pos->first.c_str(), pos->second->GetCommandName(), sstr); 1129 1130 translation_and_help.Printf ("(%s) %s", sstr.GetData(), pos->second->GetHelp()); 1131 OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", 1132 translation_and_help.GetData(), max_len); 1133 } 1134 result.AppendMessage(""); 1135 } 1136 1137 if (!m_user_dict.empty() && ( (cmd_types & eCommandTypesUserDef) == eCommandTypesUserDef )) 1138 { 1139 result.AppendMessage ("The following is a list of your current user-defined commands:"); 1140 result.AppendMessage(""); 1141 max_len = FindLongestCommandWord (m_user_dict); 1142 for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos) 1143 { 1144 OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(), 1145 max_len); 1146 } 1147 result.AppendMessage(""); 1148 } 1149 1150 result.AppendMessage("For more information on any particular command, try 'help <command-name>'."); 1151} 1152 1153CommandObject * 1154CommandInterpreter::GetCommandObjectForCommand (std::string &command_string) 1155{ 1156 // This function finds the final, lowest-level, alias-resolved command object whose 'Execute' function will 1157 // eventually be invoked by the given command line. 1158 1159 CommandObject *cmd_obj = NULL; 1160 std::string white_space (" \t\v"); 1161 size_t start = command_string.find_first_not_of (white_space); 1162 size_t end = 0; 1163 bool done = false; 1164 while (!done) 1165 { 1166 if (start != std::string::npos) 1167 { 1168 // Get the next word from command_string. 1169 end = command_string.find_first_of (white_space, start); 1170 if (end == std::string::npos) 1171 end = command_string.size(); 1172 std::string cmd_word = command_string.substr (start, end - start); 1173 1174 if (cmd_obj == NULL) 1175 // Since cmd_obj is NULL we are on our first time through this loop. Check to see if cmd_word is a valid 1176 // command or alias. 1177 cmd_obj = GetCommandObject (cmd_word.c_str()); 1178 else if (cmd_obj->IsMultiwordObject ()) 1179 { 1180 // Our current object is a multi-word object; see if the cmd_word is a valid sub-command for our object. 1181 CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (cmd_word.c_str()); 1182 if (sub_cmd_obj) 1183 cmd_obj = sub_cmd_obj; 1184 else // cmd_word was not a valid sub-command word, so we are donee 1185 done = true; 1186 } 1187 else 1188 // We have a cmd_obj and it is not a multi-word object, so we are done. 1189 done = true; 1190 1191 // If we didn't find a valid command object, or our command object is not a multi-word object, or 1192 // we are at the end of the command_string, then we are done. Otherwise, find the start of the 1193 // next word. 1194 1195 if (!cmd_obj || !cmd_obj->IsMultiwordObject() || end >= command_string.size()) 1196 done = true; 1197 else 1198 start = command_string.find_first_not_of (white_space, end); 1199 } 1200 else 1201 // Unable to find any more words. 1202 done = true; 1203 } 1204 1205 if (end == command_string.size()) 1206 command_string.clear(); 1207 else 1208 command_string = command_string.substr(end); 1209 1210 return cmd_obj; 1211} 1212 1213static const char *k_white_space = " \t\v"; 1214static const char *k_valid_command_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"; 1215static void 1216StripLeadingSpaces (std::string &s) 1217{ 1218 if (!s.empty()) 1219 { 1220 size_t pos = s.find_first_not_of (k_white_space); 1221 if (pos == std::string::npos) 1222 s.clear(); 1223 else if (pos == 0) 1224 return; 1225 s.erase (0, pos); 1226 } 1227} 1228 1229static size_t 1230FindArgumentTerminator (const std::string &s) 1231{ 1232 const size_t s_len = s.size(); 1233 size_t offset = 0; 1234 while (offset < s_len) 1235 { 1236 size_t pos = s.find ("--", offset); 1237 if (pos == std::string::npos) 1238 break; 1239 if (pos > 0) 1240 { 1241 if (isspace(s[pos-1])) 1242 { 1243 // Check if the string ends "\s--" (where \s is a space character) 1244 // or if we have "\s--\s". 1245 if ((pos + 2 >= s_len) || isspace(s[pos+2])) 1246 { 1247 return pos; 1248 } 1249 } 1250 } 1251 offset = pos + 2; 1252 } 1253 return std::string::npos; 1254} 1255 1256static bool 1257ExtractCommand (std::string &command_string, std::string &command, std::string &suffix, char "e_char) 1258{ 1259 command.clear(); 1260 suffix.clear(); 1261 StripLeadingSpaces (command_string); 1262 1263 bool result = false; 1264 quote_char = '\0'; 1265 1266 if (!command_string.empty()) 1267 { 1268 const char first_char = command_string[0]; 1269 if (first_char == '\'' || first_char == '"') 1270 { 1271 quote_char = first_char; 1272 const size_t end_quote_pos = command_string.find (quote_char, 1); 1273 if (end_quote_pos == std::string::npos) 1274 { 1275 command.swap (command_string); 1276 command_string.erase (); 1277 } 1278 else 1279 { 1280 command.assign (command_string, 1, end_quote_pos - 1); 1281 if (end_quote_pos + 1 < command_string.size()) 1282 command_string.erase (0, command_string.find_first_not_of (k_white_space, end_quote_pos + 1)); 1283 else 1284 command_string.erase (); 1285 } 1286 } 1287 else 1288 { 1289 const size_t first_space_pos = command_string.find_first_of (k_white_space); 1290 if (first_space_pos == std::string::npos) 1291 { 1292 command.swap (command_string); 1293 command_string.erase(); 1294 } 1295 else 1296 { 1297 command.assign (command_string, 0, first_space_pos); 1298 command_string.erase(0, command_string.find_first_not_of (k_white_space, first_space_pos)); 1299 } 1300 } 1301 result = true; 1302 } 1303 1304 1305 if (!command.empty()) 1306 { 1307 // actual commands can't start with '-' or '_' 1308 if (command[0] != '-' && command[0] != '_') 1309 { 1310 size_t pos = command.find_first_not_of(k_valid_command_chars); 1311 if (pos > 0 && pos != std::string::npos) 1312 { 1313 suffix.assign (command.begin() + pos, command.end()); 1314 command.erase (pos); 1315 } 1316 } 1317 } 1318 1319 return result; 1320} 1321 1322CommandObject * 1323CommandInterpreter::BuildAliasResult (const char *alias_name, 1324 std::string &raw_input_string, 1325 std::string &alias_result, 1326 CommandReturnObject &result) 1327{ 1328 CommandObject *alias_cmd_obj = NULL; 1329 Args cmd_args (raw_input_string.c_str()); 1330 alias_cmd_obj = GetCommandObject (alias_name); 1331 StreamString result_str; 1332 1333 if (alias_cmd_obj) 1334 { 1335 std::string alias_name_str = alias_name; 1336 if ((cmd_args.GetArgumentCount() == 0) 1337 || (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0)) 1338 cmd_args.Unshift (alias_name); 1339 1340 result_str.Printf ("%s", alias_cmd_obj->GetCommandName ()); 1341 OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name); 1342 1343 if (option_arg_vector_sp.get()) 1344 { 1345 OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); 1346 1347 for (size_t i = 0; i < option_arg_vector->size(); ++i) 1348 { 1349 OptionArgPair option_pair = (*option_arg_vector)[i]; 1350 OptionArgValue value_pair = option_pair.second; 1351 int value_type = value_pair.first; 1352 std::string option = option_pair.first; 1353 std::string value = value_pair.second; 1354 if (option.compare ("<argument>") == 0) 1355 result_str.Printf (" %s", value.c_str()); 1356 else 1357 { 1358 result_str.Printf (" %s", option.c_str()); 1359 if (value_type != OptionParser::eOptionalArgument) 1360 result_str.Printf (" "); 1361 if (value.compare ("<OptionParser::eNoArgument>") != 0) 1362 { 1363 int index = GetOptionArgumentPosition (value.c_str()); 1364 if (index == 0) 1365 result_str.Printf ("%s", value.c_str()); 1366 else if (index >= cmd_args.GetArgumentCount()) 1367 { 1368 1369 result.AppendErrorWithFormat 1370 ("Not enough arguments provided; you need at least %d arguments to use this alias.\n", 1371 index); 1372 result.SetStatus (eReturnStatusFailed); 1373 return alias_cmd_obj; 1374 } 1375 else 1376 { 1377 size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index)); 1378 if (strpos != std::string::npos) 1379 raw_input_string = raw_input_string.erase (strpos, 1380 strlen (cmd_args.GetArgumentAtIndex (index))); 1381 result_str.Printf ("%s", cmd_args.GetArgumentAtIndex (index)); 1382 } 1383 } 1384 } 1385 } 1386 } 1387 1388 alias_result = result_str.GetData(); 1389 } 1390 return alias_cmd_obj; 1391} 1392 1393Error 1394CommandInterpreter::PreprocessCommand (std::string &command) 1395{ 1396 // The command preprocessor needs to do things to the command 1397 // line before any parsing of arguments or anything else is done. 1398 // The only current stuff that gets proprocessed is anyting enclosed 1399 // in backtick ('`') characters is evaluated as an expression and 1400 // the result of the expression must be a scalar that can be substituted 1401 // into the command. An example would be: 1402 // (lldb) memory read `$rsp + 20` 1403 Error error; // Error for any expressions that might not evaluate 1404 size_t start_backtick; 1405 size_t pos = 0; 1406 while ((start_backtick = command.find ('`', pos)) != std::string::npos) 1407 { 1408 if (start_backtick > 0 && command[start_backtick-1] == '\\') 1409 { 1410 // The backtick was preceeded by a '\' character, remove the slash 1411 // and don't treat the backtick as the start of an expression 1412 command.erase(start_backtick-1, 1); 1413 // No need to add one to start_backtick since we just deleted a char 1414 pos = start_backtick; 1415 } 1416 else 1417 { 1418 const size_t expr_content_start = start_backtick + 1; 1419 const size_t end_backtick = command.find ('`', expr_content_start); 1420 if (end_backtick == std::string::npos) 1421 return error; 1422 else if (end_backtick == expr_content_start) 1423 { 1424 // Empty expression (two backticks in a row) 1425 command.erase (start_backtick, 2); 1426 } 1427 else 1428 { 1429 std::string expr_str (command, expr_content_start, end_backtick - expr_content_start); 1430 1431 ExecutionContext exe_ctx(GetExecutionContext()); 1432 Target *target = exe_ctx.GetTargetPtr(); 1433 // Get a dummy target to allow for calculator mode while processing backticks. 1434 // This also helps break the infinite loop caused when target is null. 1435 if (!target) 1436 target = Host::GetDummyTarget(GetDebugger()).get(); 1437 if (target) 1438 { 1439 ValueObjectSP expr_result_valobj_sp; 1440 1441 EvaluateExpressionOptions options; 1442 options.SetCoerceToId(false); 1443 options.SetUnwindOnError(true); 1444 options.SetIgnoreBreakpoints(true); 1445 options.SetKeepInMemory(false); 1446 options.SetTryAllThreads(true); 1447 options.SetTimeoutUsec(0); 1448 1449 ExecutionResults expr_result = target->EvaluateExpression (expr_str.c_str(), 1450 exe_ctx.GetFramePtr(), 1451 expr_result_valobj_sp, 1452 options); 1453 1454 if (expr_result == eExecutionCompleted) 1455 { 1456 Scalar scalar; 1457 if (expr_result_valobj_sp->ResolveValue (scalar)) 1458 { 1459 command.erase (start_backtick, end_backtick - start_backtick + 1); 1460 StreamString value_strm; 1461 const bool show_type = false; 1462 scalar.GetValue (&value_strm, show_type); 1463 size_t value_string_size = value_strm.GetSize(); 1464 if (value_string_size) 1465 { 1466 command.insert (start_backtick, value_strm.GetData(), value_string_size); 1467 pos = start_backtick + value_string_size; 1468 continue; 1469 } 1470 else 1471 { 1472 error.SetErrorStringWithFormat("expression value didn't result in a scalar value for the expression '%s'", expr_str.c_str()); 1473 } 1474 } 1475 else 1476 { 1477 error.SetErrorStringWithFormat("expression value didn't result in a scalar value for the expression '%s'", expr_str.c_str()); 1478 } 1479 } 1480 else 1481 { 1482 if (expr_result_valobj_sp) 1483 error = expr_result_valobj_sp->GetError(); 1484 if (error.Success()) 1485 { 1486 1487 switch (expr_result) 1488 { 1489 case eExecutionSetupError: 1490 error.SetErrorStringWithFormat("expression setup error for the expression '%s'", expr_str.c_str()); 1491 break; 1492 case eExecutionCompleted: 1493 break; 1494 case eExecutionDiscarded: 1495 error.SetErrorStringWithFormat("expression discarded for the expression '%s'", expr_str.c_str()); 1496 break; 1497 case eExecutionInterrupted: 1498 error.SetErrorStringWithFormat("expression interrupted for the expression '%s'", expr_str.c_str()); 1499 break; 1500 case eExecutionHitBreakpoint: 1501 error.SetErrorStringWithFormat("expression hit breakpoint for the expression '%s'", expr_str.c_str()); 1502 break; 1503 case eExecutionTimedOut: 1504 error.SetErrorStringWithFormat("expression timed out for the expression '%s'", expr_str.c_str()); 1505 break; 1506 case eExecutionStoppedForDebug: 1507 error.SetErrorStringWithFormat("expression stop at entry point for debugging for the expression '%s'", expr_str.c_str()); 1508 break; 1509 } 1510 } 1511 } 1512 } 1513 } 1514 if (error.Fail()) 1515 break; 1516 } 1517 } 1518 return error; 1519} 1520 1521 1522bool 1523CommandInterpreter::HandleCommand (const char *command_line, 1524 LazyBool lazy_add_to_history, 1525 CommandReturnObject &result, 1526 ExecutionContext *override_context, 1527 bool repeat_on_empty_command, 1528 bool no_context_switching) 1529 1530{ 1531 1532 bool done = false; 1533 CommandObject *cmd_obj = NULL; 1534 bool wants_raw_input = false; 1535 std::string command_string (command_line); 1536 std::string original_command_string (command_line); 1537 1538 Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMANDS)); 1539 Host::SetCrashDescriptionWithFormat ("HandleCommand(command = \"%s\")", command_line); 1540 1541 // Make a scoped cleanup object that will clear the crash description string 1542 // on exit of this function. 1543 lldb_utility::CleanUp <const char *> crash_description_cleanup(NULL, Host::SetCrashDescription); 1544 1545 if (log) 1546 log->Printf ("Processing command: %s", command_line); 1547 1548 Timer scoped_timer (__PRETTY_FUNCTION__, "Handling command: %s.", command_line); 1549 1550 if (!no_context_switching) 1551 UpdateExecutionContext (override_context); 1552 1553 bool add_to_history; 1554 if (lazy_add_to_history == eLazyBoolCalculate) 1555 add_to_history = (m_command_source_depth == 0); 1556 else 1557 add_to_history = (lazy_add_to_history == eLazyBoolYes); 1558 1559 bool empty_command = false; 1560 bool comment_command = false; 1561 if (command_string.empty()) 1562 empty_command = true; 1563 else 1564 { 1565 const char *k_space_characters = "\t\n\v\f\r "; 1566 1567 size_t non_space = command_string.find_first_not_of (k_space_characters); 1568 // Check for empty line or comment line (lines whose first 1569 // non-space character is the comment character for this interpreter) 1570 if (non_space == std::string::npos) 1571 empty_command = true; 1572 else if (command_string[non_space] == m_comment_char) 1573 comment_command = true; 1574 else if (command_string[non_space] == CommandHistory::g_repeat_char) 1575 { 1576 const char *history_string = m_command_history.FindString(command_string.c_str() + non_space); 1577 if (history_string == NULL) 1578 { 1579 result.AppendErrorWithFormat ("Could not find entry: %s in history", command_string.c_str()); 1580 result.SetStatus(eReturnStatusFailed); 1581 return false; 1582 } 1583 add_to_history = false; 1584 command_string = history_string; 1585 original_command_string = history_string; 1586 } 1587 } 1588 1589 if (empty_command) 1590 { 1591 if (repeat_on_empty_command) 1592 { 1593 if (m_command_history.IsEmpty()) 1594 { 1595 result.AppendError ("empty command"); 1596 result.SetStatus(eReturnStatusFailed); 1597 return false; 1598 } 1599 else 1600 { 1601 command_line = m_repeat_command.c_str(); 1602 command_string = command_line; 1603 original_command_string = command_line; 1604 if (m_repeat_command.empty()) 1605 { 1606 result.AppendErrorWithFormat("No auto repeat.\n"); 1607 result.SetStatus (eReturnStatusFailed); 1608 return false; 1609 } 1610 } 1611 add_to_history = false; 1612 } 1613 else 1614 { 1615 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1616 return true; 1617 } 1618 } 1619 else if (comment_command) 1620 { 1621 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1622 return true; 1623 } 1624 1625 1626 Error error (PreprocessCommand (command_string)); 1627 1628 if (error.Fail()) 1629 { 1630 result.AppendError (error.AsCString()); 1631 result.SetStatus(eReturnStatusFailed); 1632 return false; 1633 } 1634 // Phase 1. 1635 1636 // Before we do ANY kind of argument processing, etc. we need to figure out what the real/final command object 1637 // is for the specified command, and whether or not it wants raw input. This gets complicated by the fact that 1638 // the user could have specified an alias, and in translating the alias there may also be command options and/or 1639 // even data (including raw text strings) that need to be found and inserted into the command line as part of 1640 // the translation. So this first step is plain look-up & replacement, resulting in three things: 1). the command 1641 // object whose Execute method will actually be called; 2). a revised command string, with all substitutions & 1642 // replacements taken care of; 3). whether or not the Execute function wants raw input or not. 1643 1644 StreamString revised_command_line; 1645 size_t actual_cmd_name_len = 0; 1646 std::string next_word; 1647 StringList matches; 1648 while (!done) 1649 { 1650 char quote_char = '\0'; 1651 std::string suffix; 1652 ExtractCommand (command_string, next_word, suffix, quote_char); 1653 if (cmd_obj == NULL) 1654 { 1655 std::string full_name; 1656 if (GetAliasFullName(next_word.c_str(), full_name)) 1657 { 1658 std::string alias_result; 1659 cmd_obj = BuildAliasResult (full_name.c_str(), command_string, alias_result, result); 1660 revised_command_line.Printf ("%s", alias_result.c_str()); 1661 if (cmd_obj) 1662 { 1663 wants_raw_input = cmd_obj->WantsRawCommandString (); 1664 actual_cmd_name_len = strlen (cmd_obj->GetCommandName()); 1665 } 1666 } 1667 else 1668 { 1669 cmd_obj = GetCommandObject (next_word.c_str(), &matches); 1670 if (cmd_obj) 1671 { 1672 actual_cmd_name_len += next_word.length(); 1673 revised_command_line.Printf ("%s", next_word.c_str()); 1674 wants_raw_input = cmd_obj->WantsRawCommandString (); 1675 } 1676 else 1677 { 1678 revised_command_line.Printf ("%s", next_word.c_str()); 1679 } 1680 } 1681 } 1682 else 1683 { 1684 if (cmd_obj->IsMultiwordObject ()) 1685 { 1686 CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (next_word.c_str()); 1687 if (sub_cmd_obj) 1688 { 1689 actual_cmd_name_len += next_word.length() + 1; 1690 revised_command_line.Printf (" %s", next_word.c_str()); 1691 cmd_obj = sub_cmd_obj; 1692 wants_raw_input = cmd_obj->WantsRawCommandString (); 1693 } 1694 else 1695 { 1696 if (quote_char) 1697 revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char); 1698 else 1699 revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str()); 1700 done = true; 1701 } 1702 } 1703 else 1704 { 1705 if (quote_char) 1706 revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char); 1707 else 1708 revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str()); 1709 done = true; 1710 } 1711 } 1712 1713 if (cmd_obj == NULL) 1714 { 1715 const size_t num_matches = matches.GetSize(); 1716 if (matches.GetSize() > 1) { 1717 StreamString error_msg; 1718 error_msg.Printf ("Ambiguous command '%s'. Possible matches:\n", next_word.c_str()); 1719 1720 for (uint32_t i = 0; i < num_matches; ++i) { 1721 error_msg.Printf ("\t%s\n", matches.GetStringAtIndex(i)); 1722 } 1723 result.AppendRawError (error_msg.GetString().c_str()); 1724 } else { 1725 // We didn't have only one match, otherwise we wouldn't get here. 1726 assert(num_matches == 0); 1727 result.AppendErrorWithFormat ("'%s' is not a valid command.\n", next_word.c_str()); 1728 } 1729 result.SetStatus (eReturnStatusFailed); 1730 return false; 1731 } 1732 1733 if (cmd_obj->IsMultiwordObject ()) 1734 { 1735 if (!suffix.empty()) 1736 { 1737 1738 result.AppendErrorWithFormat ("command '%s' did not recognize '%s%s%s' as valid (subcommand might be invalid).\n", 1739 cmd_obj->GetCommandName(), 1740 next_word.empty() ? "" : next_word.c_str(), 1741 next_word.empty() ? " -- " : " ", 1742 suffix.c_str()); 1743 result.SetStatus (eReturnStatusFailed); 1744 return false; 1745 } 1746 } 1747 else 1748 { 1749 // If we found a normal command, we are done 1750 done = true; 1751 if (!suffix.empty()) 1752 { 1753 switch (suffix[0]) 1754 { 1755 case '/': 1756 // GDB format suffixes 1757 { 1758 Options *command_options = cmd_obj->GetOptions(); 1759 if (command_options && command_options->SupportsLongOption("gdb-format")) 1760 { 1761 std::string gdb_format_option ("--gdb-format="); 1762 gdb_format_option += (suffix.c_str() + 1); 1763 1764 bool inserted = false; 1765 std::string &cmd = revised_command_line.GetString(); 1766 size_t arg_terminator_idx = FindArgumentTerminator (cmd); 1767 if (arg_terminator_idx != std::string::npos) 1768 { 1769 // Insert the gdb format option before the "--" that terminates options 1770 gdb_format_option.append(1,' '); 1771 cmd.insert(arg_terminator_idx, gdb_format_option); 1772 inserted = true; 1773 } 1774 1775 if (!inserted) 1776 revised_command_line.Printf (" %s", gdb_format_option.c_str()); 1777 1778 if (wants_raw_input && FindArgumentTerminator(cmd) == std::string::npos) 1779 revised_command_line.PutCString (" --"); 1780 } 1781 else 1782 { 1783 result.AppendErrorWithFormat ("the '%s' command doesn't support the --gdb-format option\n", 1784 cmd_obj->GetCommandName()); 1785 result.SetStatus (eReturnStatusFailed); 1786 return false; 1787 } 1788 } 1789 break; 1790 1791 default: 1792 result.AppendErrorWithFormat ("unknown command shorthand suffix: '%s'\n", 1793 suffix.c_str()); 1794 result.SetStatus (eReturnStatusFailed); 1795 return false; 1796 1797 } 1798 } 1799 } 1800 if (command_string.length() == 0) 1801 done = true; 1802 1803 } 1804 1805 if (!command_string.empty()) 1806 revised_command_line.Printf (" %s", command_string.c_str()); 1807 1808 // End of Phase 1. 1809 // At this point cmd_obj should contain the CommandObject whose Execute method will be called, if the command 1810 // specified was valid; revised_command_line contains the complete command line (including command name(s)), 1811 // fully translated with all substitutions & translations taken care of (still in raw text format); and 1812 // wants_raw_input specifies whether the Execute method expects raw input or not. 1813 1814 1815 if (log) 1816 { 1817 log->Printf ("HandleCommand, cmd_obj : '%s'", cmd_obj ? cmd_obj->GetCommandName() : "<not found>"); 1818 log->Printf ("HandleCommand, revised_command_line: '%s'", revised_command_line.GetData()); 1819 log->Printf ("HandleCommand, wants_raw_input:'%s'", wants_raw_input ? "True" : "False"); 1820 } 1821 1822 // Phase 2. 1823 // Take care of things like setting up the history command & calling the appropriate Execute method on the 1824 // CommandObject, with the appropriate arguments. 1825 1826 if (cmd_obj != NULL) 1827 { 1828 if (add_to_history) 1829 { 1830 Args command_args (revised_command_line.GetData()); 1831 const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0); 1832 if (repeat_command != NULL) 1833 m_repeat_command.assign(repeat_command); 1834 else 1835 m_repeat_command.assign(original_command_string.c_str()); 1836 1837 m_command_history.AppendString (original_command_string); 1838 } 1839 1840 command_string = revised_command_line.GetData(); 1841 std::string command_name (cmd_obj->GetCommandName()); 1842 std::string remainder; 1843 if (actual_cmd_name_len < command_string.length()) 1844 remainder = command_string.substr (actual_cmd_name_len); // Note: 'actual_cmd_name_len' may be considerably shorter 1845 // than cmd_obj->GetCommandName(), because name completion 1846 // allows users to enter short versions of the names, 1847 // e.g. 'br s' for 'breakpoint set'. 1848 1849 // Remove any initial spaces 1850 std::string white_space (" \t\v"); 1851 size_t pos = remainder.find_first_not_of (white_space); 1852 if (pos != 0 && pos != std::string::npos) 1853 remainder.erase(0, pos); 1854 1855 if (log) 1856 log->Printf ("HandleCommand, command line after removing command name(s): '%s'", remainder.c_str()); 1857 1858 cmd_obj->Execute (remainder.c_str(), result); 1859 } 1860 else 1861 { 1862 // We didn't find the first command object, so complete the first argument. 1863 Args command_args (revised_command_line.GetData()); 1864 StringList matches; 1865 int num_matches; 1866 int cursor_index = 0; 1867 int cursor_char_position = strlen (command_args.GetArgumentAtIndex(0)); 1868 bool word_complete; 1869 num_matches = HandleCompletionMatches (command_args, 1870 cursor_index, 1871 cursor_char_position, 1872 0, 1873 -1, 1874 word_complete, 1875 matches); 1876 1877 if (num_matches > 0) 1878 { 1879 std::string error_msg; 1880 error_msg.assign ("ambiguous command '"); 1881 error_msg.append(command_args.GetArgumentAtIndex(0)); 1882 error_msg.append ("'."); 1883 1884 error_msg.append (" Possible completions:"); 1885 for (int i = 0; i < num_matches; i++) 1886 { 1887 error_msg.append ("\n\t"); 1888 error_msg.append (matches.GetStringAtIndex (i)); 1889 } 1890 error_msg.append ("\n"); 1891 result.AppendRawError (error_msg.c_str()); 1892 } 1893 else 1894 result.AppendErrorWithFormat ("Unrecognized command '%s'.\n", command_args.GetArgumentAtIndex (0)); 1895 1896 result.SetStatus (eReturnStatusFailed); 1897 } 1898 1899 if (log) 1900 log->Printf ("HandleCommand, command %s", (result.Succeeded() ? "succeeded" : "did not succeed")); 1901 1902 return result.Succeeded(); 1903} 1904 1905int 1906CommandInterpreter::HandleCompletionMatches (Args &parsed_line, 1907 int &cursor_index, 1908 int &cursor_char_position, 1909 int match_start_point, 1910 int max_return_elements, 1911 bool &word_complete, 1912 StringList &matches) 1913{ 1914 int num_command_matches = 0; 1915 bool look_for_subcommand = false; 1916 1917 // For any of the command completions a unique match will be a complete word. 1918 word_complete = true; 1919 1920 if (cursor_index == -1) 1921 { 1922 // We got nothing on the command line, so return the list of commands 1923 bool include_aliases = true; 1924 num_command_matches = GetCommandNamesMatchingPartialString ("", include_aliases, matches); 1925 } 1926 else if (cursor_index == 0) 1927 { 1928 // The cursor is in the first argument, so just do a lookup in the dictionary. 1929 CommandObject *cmd_obj = GetCommandObject (parsed_line.GetArgumentAtIndex(0), &matches); 1930 num_command_matches = matches.GetSize(); 1931 1932 if (num_command_matches == 1 1933 && cmd_obj && cmd_obj->IsMultiwordObject() 1934 && matches.GetStringAtIndex(0) != NULL 1935 && strcmp (parsed_line.GetArgumentAtIndex(0), matches.GetStringAtIndex(0)) == 0) 1936 { 1937 if (parsed_line.GetArgumentCount() == 1) 1938 { 1939 word_complete = true; 1940 } 1941 else 1942 { 1943 look_for_subcommand = true; 1944 num_command_matches = 0; 1945 matches.DeleteStringAtIndex(0); 1946 parsed_line.AppendArgument (""); 1947 cursor_index++; 1948 cursor_char_position = 0; 1949 } 1950 } 1951 } 1952 1953 if (cursor_index > 0 || look_for_subcommand) 1954 { 1955 // We are completing further on into a commands arguments, so find the command and tell it 1956 // to complete the command. 1957 // First see if there is a matching initial command: 1958 CommandObject *command_object = GetCommandObject (parsed_line.GetArgumentAtIndex(0)); 1959 if (command_object == NULL) 1960 { 1961 return 0; 1962 } 1963 else 1964 { 1965 parsed_line.Shift(); 1966 cursor_index--; 1967 num_command_matches = command_object->HandleCompletion (parsed_line, 1968 cursor_index, 1969 cursor_char_position, 1970 match_start_point, 1971 max_return_elements, 1972 word_complete, 1973 matches); 1974 } 1975 } 1976 1977 return num_command_matches; 1978 1979} 1980 1981int 1982CommandInterpreter::HandleCompletion (const char *current_line, 1983 const char *cursor, 1984 const char *last_char, 1985 int match_start_point, 1986 int max_return_elements, 1987 StringList &matches) 1988{ 1989 // We parse the argument up to the cursor, so the last argument in parsed_line is 1990 // the one containing the cursor, and the cursor is after the last character. 1991 1992 Args parsed_line(current_line, last_char - current_line); 1993 Args partial_parsed_line(current_line, cursor - current_line); 1994 1995 // Don't complete comments, and if the line we are completing is just the history repeat character, 1996 // substitute the appropriate history line. 1997 const char *first_arg = parsed_line.GetArgumentAtIndex(0); 1998 if (first_arg) 1999 { 2000 if (first_arg[0] == m_comment_char) 2001 return 0; 2002 else if (first_arg[0] == CommandHistory::g_repeat_char) 2003 { 2004 const char *history_string = m_command_history.FindString (first_arg); 2005 if (history_string != NULL) 2006 { 2007 matches.Clear(); 2008 matches.InsertStringAtIndex(0, history_string); 2009 return -2; 2010 } 2011 else 2012 return 0; 2013 2014 } 2015 } 2016 2017 2018 int num_args = partial_parsed_line.GetArgumentCount(); 2019 int cursor_index = partial_parsed_line.GetArgumentCount() - 1; 2020 int cursor_char_position; 2021 2022 if (cursor_index == -1) 2023 cursor_char_position = 0; 2024 else 2025 cursor_char_position = strlen (partial_parsed_line.GetArgumentAtIndex(cursor_index)); 2026 2027 if (cursor > current_line && cursor[-1] == ' ') 2028 { 2029 // We are just after a space. If we are in an argument, then we will continue 2030 // parsing, but if we are between arguments, then we have to complete whatever the next 2031 // element would be. 2032 // We can distinguish the two cases because if we are in an argument (e.g. because the space is 2033 // protected by a quote) then the space will also be in the parsed argument... 2034 2035 const char *current_elem = partial_parsed_line.GetArgumentAtIndex(cursor_index); 2036 if (cursor_char_position == 0 || current_elem[cursor_char_position - 1] != ' ') 2037 { 2038 parsed_line.InsertArgumentAtIndex(cursor_index + 1, "", '\0'); 2039 cursor_index++; 2040 cursor_char_position = 0; 2041 } 2042 } 2043 2044 int num_command_matches; 2045 2046 matches.Clear(); 2047 2048 // Only max_return_elements == -1 is supported at present: 2049 assert (max_return_elements == -1); 2050 bool word_complete; 2051 num_command_matches = HandleCompletionMatches (parsed_line, 2052 cursor_index, 2053 cursor_char_position, 2054 match_start_point, 2055 max_return_elements, 2056 word_complete, 2057 matches); 2058 2059 if (num_command_matches <= 0) 2060 return num_command_matches; 2061 2062 if (num_args == 0) 2063 { 2064 // If we got an empty string, insert nothing. 2065 matches.InsertStringAtIndex(0, ""); 2066 } 2067 else 2068 { 2069 // Now figure out if there is a common substring, and if so put that in element 0, otherwise 2070 // put an empty string in element 0. 2071 std::string command_partial_str; 2072 if (cursor_index >= 0) 2073 command_partial_str.assign(parsed_line.GetArgumentAtIndex(cursor_index), 2074 parsed_line.GetArgumentAtIndex(cursor_index) + cursor_char_position); 2075 2076 std::string common_prefix; 2077 matches.LongestCommonPrefix (common_prefix); 2078 const size_t partial_name_len = command_partial_str.size(); 2079 2080 // If we matched a unique single command, add a space... 2081 // Only do this if the completer told us this was a complete word, however... 2082 if (num_command_matches == 1 && word_complete) 2083 { 2084 char quote_char = parsed_line.GetArgumentQuoteCharAtIndex(cursor_index); 2085 if (quote_char != '\0') 2086 common_prefix.push_back(quote_char); 2087 2088 common_prefix.push_back(' '); 2089 } 2090 common_prefix.erase (0, partial_name_len); 2091 matches.InsertStringAtIndex(0, common_prefix.c_str()); 2092 } 2093 return num_command_matches; 2094} 2095 2096 2097CommandInterpreter::~CommandInterpreter () 2098{ 2099} 2100 2101void 2102CommandInterpreter::UpdatePrompt (const char *new_prompt) 2103{ 2104 EventSP prompt_change_event_sp (new Event(eBroadcastBitResetPrompt, new EventDataBytes (new_prompt)));; 2105 BroadcastEvent (prompt_change_event_sp); 2106 if (m_command_io_handler_sp) 2107 m_command_io_handler_sp->SetPrompt(new_prompt); 2108} 2109 2110 2111bool 2112CommandInterpreter::Confirm (const char *message, bool default_answer) 2113{ 2114 // Check AutoConfirm first: 2115 if (m_debugger.GetAutoConfirm()) 2116 return default_answer; 2117 2118 IOHandlerConfirm *confirm = new IOHandlerConfirm(m_debugger, 2119 message, 2120 default_answer); 2121 IOHandlerSP io_handler_sp (confirm); 2122 m_debugger.RunIOHandler (io_handler_sp); 2123 return confirm->GetResponse(); 2124} 2125 2126OptionArgVectorSP 2127CommandInterpreter::GetAliasOptions (const char *alias_name) 2128{ 2129 OptionArgMap::iterator pos; 2130 OptionArgVectorSP ret_val; 2131 2132 std::string alias (alias_name); 2133 2134 if (HasAliasOptions()) 2135 { 2136 pos = m_alias_options.find (alias); 2137 if (pos != m_alias_options.end()) 2138 ret_val = pos->second; 2139 } 2140 2141 return ret_val; 2142} 2143 2144void 2145CommandInterpreter::RemoveAliasOptions (const char *alias_name) 2146{ 2147 OptionArgMap::iterator pos = m_alias_options.find(alias_name); 2148 if (pos != m_alias_options.end()) 2149 { 2150 m_alias_options.erase (pos); 2151 } 2152} 2153 2154void 2155CommandInterpreter::AddOrReplaceAliasOptions (const char *alias_name, OptionArgVectorSP &option_arg_vector_sp) 2156{ 2157 m_alias_options[alias_name] = option_arg_vector_sp; 2158} 2159 2160bool 2161CommandInterpreter::HasCommands () 2162{ 2163 return (!m_command_dict.empty()); 2164} 2165 2166bool 2167CommandInterpreter::HasAliases () 2168{ 2169 return (!m_alias_dict.empty()); 2170} 2171 2172bool 2173CommandInterpreter::HasUserCommands () 2174{ 2175 return (!m_user_dict.empty()); 2176} 2177 2178bool 2179CommandInterpreter::HasAliasOptions () 2180{ 2181 return (!m_alias_options.empty()); 2182} 2183 2184void 2185CommandInterpreter::BuildAliasCommandArgs (CommandObject *alias_cmd_obj, 2186 const char *alias_name, 2187 Args &cmd_args, 2188 std::string &raw_input_string, 2189 CommandReturnObject &result) 2190{ 2191 OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name); 2192 2193 bool wants_raw_input = alias_cmd_obj->WantsRawCommandString(); 2194 2195 // Make sure that the alias name is the 0th element in cmd_args 2196 std::string alias_name_str = alias_name; 2197 if (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0) 2198 cmd_args.Unshift (alias_name); 2199 2200 Args new_args (alias_cmd_obj->GetCommandName()); 2201 if (new_args.GetArgumentCount() == 2) 2202 new_args.Shift(); 2203 2204 if (option_arg_vector_sp.get()) 2205 { 2206 if (wants_raw_input) 2207 { 2208 // We have a command that both has command options and takes raw input. Make *sure* it has a 2209 // " -- " in the right place in the raw_input_string. 2210 size_t pos = raw_input_string.find(" -- "); 2211 if (pos == std::string::npos) 2212 { 2213 // None found; assume it goes at the beginning of the raw input string 2214 raw_input_string.insert (0, " -- "); 2215 } 2216 } 2217 2218 OptionArgVector *option_arg_vector = option_arg_vector_sp.get(); 2219 const size_t old_size = cmd_args.GetArgumentCount(); 2220 std::vector<bool> used (old_size + 1, false); 2221 2222 used[0] = true; 2223 2224 for (size_t i = 0; i < option_arg_vector->size(); ++i) 2225 { 2226 OptionArgPair option_pair = (*option_arg_vector)[i]; 2227 OptionArgValue value_pair = option_pair.second; 2228 int value_type = value_pair.first; 2229 std::string option = option_pair.first; 2230 std::string value = value_pair.second; 2231 if (option.compare ("<argument>") == 0) 2232 { 2233 if (!wants_raw_input 2234 || (value.compare("--") != 0)) // Since we inserted this above, make sure we don't insert it twice 2235 new_args.AppendArgument (value.c_str()); 2236 } 2237 else 2238 { 2239 if (value_type != OptionParser::eOptionalArgument) 2240 new_args.AppendArgument (option.c_str()); 2241 if (value.compare ("<no-argument>") != 0) 2242 { 2243 int index = GetOptionArgumentPosition (value.c_str()); 2244 if (index == 0) 2245 { 2246 // value was NOT a positional argument; must be a real value 2247 if (value_type != OptionParser::eOptionalArgument) 2248 new_args.AppendArgument (value.c_str()); 2249 else 2250 { 2251 char buffer[255]; 2252 ::snprintf (buffer, sizeof (buffer), "%s%s", option.c_str(), value.c_str()); 2253 new_args.AppendArgument (buffer); 2254 } 2255 2256 } 2257 else if (index >= cmd_args.GetArgumentCount()) 2258 { 2259 result.AppendErrorWithFormat 2260 ("Not enough arguments provided; you need at least %d arguments to use this alias.\n", 2261 index); 2262 result.SetStatus (eReturnStatusFailed); 2263 return; 2264 } 2265 else 2266 { 2267 // Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string 2268 size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index)); 2269 if (strpos != std::string::npos) 2270 { 2271 raw_input_string = raw_input_string.erase (strpos, strlen (cmd_args.GetArgumentAtIndex (index))); 2272 } 2273 2274 if (value_type != OptionParser::eOptionalArgument) 2275 new_args.AppendArgument (cmd_args.GetArgumentAtIndex (index)); 2276 else 2277 { 2278 char buffer[255]; 2279 ::snprintf (buffer, sizeof(buffer), "%s%s", option.c_str(), 2280 cmd_args.GetArgumentAtIndex (index)); 2281 new_args.AppendArgument (buffer); 2282 } 2283 used[index] = true; 2284 } 2285 } 2286 } 2287 } 2288 2289 for (size_t j = 0; j < cmd_args.GetArgumentCount(); ++j) 2290 { 2291 if (!used[j] && !wants_raw_input) 2292 new_args.AppendArgument (cmd_args.GetArgumentAtIndex (j)); 2293 } 2294 2295 cmd_args.Clear(); 2296 cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector()); 2297 } 2298 else 2299 { 2300 result.SetStatus (eReturnStatusSuccessFinishNoResult); 2301 // This alias was not created with any options; nothing further needs to be done, unless it is a command that 2302 // wants raw input, in which case we need to clear the rest of the data from cmd_args, since its in the raw 2303 // input string. 2304 if (wants_raw_input) 2305 { 2306 cmd_args.Clear(); 2307 cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector()); 2308 } 2309 return; 2310 } 2311 2312 result.SetStatus (eReturnStatusSuccessFinishNoResult); 2313 return; 2314} 2315 2316 2317int 2318CommandInterpreter::GetOptionArgumentPosition (const char *in_string) 2319{ 2320 int position = 0; // Any string that isn't an argument position, i.e. '%' followed by an integer, gets a position 2321 // of zero. 2322 2323 char *cptr = (char *) in_string; 2324 2325 // Does it start with '%' 2326 if (cptr[0] == '%') 2327 { 2328 ++cptr; 2329 2330 // Is the rest of it entirely digits? 2331 if (isdigit (cptr[0])) 2332 { 2333 const char *start = cptr; 2334 while (isdigit (cptr[0])) 2335 ++cptr; 2336 2337 // We've gotten to the end of the digits; are we at the end of the string? 2338 if (cptr[0] == '\0') 2339 position = atoi (start); 2340 } 2341 } 2342 2343 return position; 2344} 2345 2346void 2347CommandInterpreter::SourceInitFile (bool in_cwd, CommandReturnObject &result) 2348{ 2349 FileSpec init_file; 2350 if (in_cwd) 2351 { 2352 // In the current working directory we don't load any program specific 2353 // .lldbinit files, we only look for a "./.lldbinit" file. 2354 if (m_skip_lldbinit_files) 2355 return; 2356 2357 init_file.SetFile ("./.lldbinit", true); 2358 } 2359 else 2360 { 2361 // If we aren't looking in the current working directory we are looking 2362 // in the home directory. We will first see if there is an application 2363 // specific ".lldbinit" file whose name is "~/.lldbinit" followed by a 2364 // "-" and the name of the program. If this file doesn't exist, we fall 2365 // back to just the "~/.lldbinit" file. We also obey any requests to not 2366 // load the init files. 2367 const char *init_file_path = "~/.lldbinit"; 2368 2369 if (m_skip_app_init_files == false) 2370 { 2371 FileSpec program_file_spec (Host::GetProgramFileSpec()); 2372 const char *program_name = program_file_spec.GetFilename().AsCString(); 2373 2374 if (program_name) 2375 { 2376 char program_init_file_name[PATH_MAX]; 2377 ::snprintf (program_init_file_name, sizeof(program_init_file_name), "%s-%s", init_file_path, program_name); 2378 init_file.SetFile (program_init_file_name, true); 2379 if (!init_file.Exists()) 2380 init_file.Clear(); 2381 } 2382 } 2383 2384 if (!init_file && !m_skip_lldbinit_files) 2385 init_file.SetFile (init_file_path, true); 2386 } 2387 2388 // If the file exists, tell HandleCommand to 'source' it; this will do the actual broadcasting 2389 // of the commands back to any appropriate listener (see CommandObjectSource::Execute for more details). 2390 2391 if (init_file.Exists()) 2392 { 2393 const bool saved_batch = SetBatchCommandMode (true); 2394 HandleCommandsFromFile (init_file, 2395 NULL, // Execution context 2396 eLazyBoolYes, // Stop on continue 2397 eLazyBoolNo, // Stop on error 2398 eLazyBoolNo, // Don't echo commands 2399 eLazyBoolNo, // Don't print command output 2400 eLazyBoolNo, // Don't add the commands that are sourced into the history buffer 2401 result); 2402 SetBatchCommandMode (saved_batch); 2403 } 2404 else 2405 { 2406 // nothing to be done if the file doesn't exist 2407 result.SetStatus(eReturnStatusSuccessFinishNoResult); 2408 } 2409} 2410 2411PlatformSP 2412CommandInterpreter::GetPlatform (bool prefer_target_platform) 2413{ 2414 PlatformSP platform_sp; 2415 if (prefer_target_platform) 2416 { 2417 ExecutionContext exe_ctx(GetExecutionContext()); 2418 Target *target = exe_ctx.GetTargetPtr(); 2419 if (target) 2420 platform_sp = target->GetPlatform(); 2421 } 2422 2423 if (!platform_sp) 2424 platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform(); 2425 return platform_sp; 2426} 2427 2428void 2429CommandInterpreter::HandleCommands (const StringList &commands, 2430 ExecutionContext *override_context, 2431 bool stop_on_continue, 2432 bool stop_on_error, 2433 bool echo_commands, 2434 bool print_results, 2435 LazyBool add_to_history, 2436 CommandReturnObject &result) 2437{ 2438 size_t num_lines = commands.GetSize(); 2439 2440 // If we are going to continue past a "continue" then we need to run the commands synchronously. 2441 // Make sure you reset this value anywhere you return from the function. 2442 2443 bool old_async_execution = m_debugger.GetAsyncExecution(); 2444 2445 // If we've been given an execution context, set it at the start, but don't keep resetting it or we will 2446 // cause series of commands that change the context, then do an operation that relies on that context to fail. 2447 2448 if (override_context != NULL) 2449 UpdateExecutionContext (override_context); 2450 2451 if (!stop_on_continue) 2452 { 2453 m_debugger.SetAsyncExecution (false); 2454 } 2455 2456 for (size_t idx = 0; idx < num_lines; idx++) 2457 { 2458 const char *cmd = commands.GetStringAtIndex(idx); 2459 if (cmd[0] == '\0') 2460 continue; 2461 2462 if (echo_commands) 2463 { 2464 result.AppendMessageWithFormat ("%s %s\n", 2465 m_debugger.GetPrompt(), 2466 cmd); 2467 } 2468 2469 CommandReturnObject tmp_result; 2470 // If override_context is not NULL, pass no_context_switching = true for 2471 // HandleCommand() since we updated our context already. 2472 2473 // We might call into a regex or alias command, in which case the add_to_history will get lost. This 2474 // m_command_source_depth dingus is the way we turn off adding to the history in that case, so set it up here. 2475 if (!add_to_history) 2476 m_command_source_depth++; 2477 bool success = HandleCommand(cmd, add_to_history, tmp_result, 2478 NULL, /* override_context */ 2479 true, /* repeat_on_empty_command */ 2480 override_context != NULL /* no_context_switching */); 2481 if (!add_to_history) 2482 m_command_source_depth--; 2483 2484 if (print_results) 2485 { 2486 if (tmp_result.Succeeded()) 2487 result.AppendMessageWithFormat("%s", tmp_result.GetOutputData()); 2488 } 2489 2490 if (!success || !tmp_result.Succeeded()) 2491 { 2492 const char *error_msg = tmp_result.GetErrorData(); 2493 if (error_msg == NULL || error_msg[0] == '\0') 2494 error_msg = "<unknown error>.\n"; 2495 if (stop_on_error) 2496 { 2497 result.AppendErrorWithFormat("Aborting reading of commands after command #%zu: '%s' failed with %s", 2498 idx, cmd, error_msg); 2499 result.SetStatus (eReturnStatusFailed); 2500 m_debugger.SetAsyncExecution (old_async_execution); 2501 return; 2502 } 2503 else if (print_results) 2504 { 2505 result.AppendMessageWithFormat ("Command #%zu '%s' failed with %s", 2506 idx + 1, 2507 cmd, 2508 error_msg); 2509 } 2510 } 2511 2512 if (result.GetImmediateOutputStream()) 2513 result.GetImmediateOutputStream()->Flush(); 2514 2515 if (result.GetImmediateErrorStream()) 2516 result.GetImmediateErrorStream()->Flush(); 2517 2518 // N.B. Can't depend on DidChangeProcessState, because the state coming into the command execution 2519 // could be running (for instance in Breakpoint Commands. 2520 // So we check the return value to see if it is has running in it. 2521 if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult) 2522 || (tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult)) 2523 { 2524 if (stop_on_continue) 2525 { 2526 // If we caused the target to proceed, and we're going to stop in that case, set the 2527 // status in our real result before returning. This is an error if the continue was not the 2528 // last command in the set of commands to be run. 2529 if (idx != num_lines - 1) 2530 result.AppendErrorWithFormat("Aborting reading of commands after command #%zu: '%s' continued the target.\n", 2531 idx + 1, cmd); 2532 else 2533 result.AppendMessageWithFormat ("Command #%zu '%s' continued the target.\n", idx + 1, cmd); 2534 2535 result.SetStatus(tmp_result.GetStatus()); 2536 m_debugger.SetAsyncExecution (old_async_execution); 2537 2538 return; 2539 } 2540 } 2541 2542 } 2543 2544 result.SetStatus (eReturnStatusSuccessFinishResult); 2545 m_debugger.SetAsyncExecution (old_async_execution); 2546 2547 return; 2548} 2549 2550// Make flags that we can pass into the IOHandler so our delegates can do the right thing 2551enum { 2552 eHandleCommandFlagStopOnContinue = (1u << 0), 2553 eHandleCommandFlagStopOnError = (1u << 1), 2554 eHandleCommandFlagEchoCommand = (1u << 2), 2555 eHandleCommandFlagPrintResult = (1u << 3) 2556}; 2557 2558void 2559CommandInterpreter::HandleCommandsFromFile (FileSpec &cmd_file, 2560 ExecutionContext *context, 2561 LazyBool stop_on_continue, 2562 LazyBool stop_on_error, 2563 LazyBool echo_command, 2564 LazyBool print_result, 2565 LazyBool add_to_history, 2566 CommandReturnObject &result) 2567{ 2568 if (cmd_file.Exists()) 2569 { 2570 StreamFileSP input_file_sp (new StreamFile()); 2571 2572 std::string cmd_file_path = cmd_file.GetPath(); 2573 Error error = input_file_sp->GetFile().Open(cmd_file_path.c_str(), File::eOpenOptionRead); 2574 2575 if (error.Success()) 2576 { 2577 Debugger &debugger = GetDebugger(); 2578 2579 uint32_t flags = 0; 2580 2581 if (stop_on_continue == eLazyBoolCalculate) 2582 { 2583 if (m_command_source_flags.empty()) 2584 { 2585 // Stop on continue by default 2586 flags |= eHandleCommandFlagStopOnContinue; 2587 } 2588 else if (m_command_source_flags.back() & eHandleCommandFlagStopOnContinue) 2589 { 2590 flags |= eHandleCommandFlagStopOnContinue; 2591 } 2592 } 2593 else if (stop_on_continue == eLazyBoolYes) 2594 { 2595 flags |= eHandleCommandFlagStopOnContinue; 2596 } 2597 2598 if (stop_on_error == eLazyBoolCalculate) 2599 { 2600 if (m_command_source_flags.empty()) 2601 { 2602 if (GetStopCmdSourceOnError()) 2603 flags |= eHandleCommandFlagStopOnError; 2604 } 2605 else if (m_command_source_flags.back() & eHandleCommandFlagStopOnError) 2606 { 2607 flags |= eHandleCommandFlagStopOnError; 2608 } 2609 } 2610 else if (stop_on_error == eLazyBoolYes) 2611 { 2612 flags |= eHandleCommandFlagStopOnError; 2613 } 2614 2615 if (echo_command == eLazyBoolCalculate) 2616 { 2617 if (m_command_source_flags.empty()) 2618 { 2619 // Echo command by default 2620 flags |= eHandleCommandFlagEchoCommand; 2621 } 2622 else if (m_command_source_flags.back() & eHandleCommandFlagEchoCommand) 2623 { 2624 flags |= eHandleCommandFlagEchoCommand; 2625 } 2626 } 2627 else if (echo_command == eLazyBoolYes) 2628 { 2629 flags |= eHandleCommandFlagEchoCommand; 2630 } 2631 2632 if (print_result == eLazyBoolCalculate) 2633 { 2634 if (m_command_source_flags.empty()) 2635 { 2636 // Print output by default 2637 flags |= eHandleCommandFlagPrintResult; 2638 } 2639 else if (m_command_source_flags.back() & eHandleCommandFlagPrintResult) 2640 { 2641 flags |= eHandleCommandFlagPrintResult; 2642 } 2643 } 2644 else if (print_result == eLazyBoolYes) 2645 { 2646 flags |= eHandleCommandFlagPrintResult; 2647 } 2648 2649 if (flags & eHandleCommandFlagPrintResult) 2650 { 2651 debugger.GetOutputFile()->Printf("Executing commands in '%s'.\n", cmd_file_path.c_str()); 2652 } 2653 2654 // Used for inheriting the right settings when "command source" might have 2655 // nested "command source" commands 2656 lldb::StreamFileSP empty_stream_sp; 2657 m_command_source_flags.push_back(flags); 2658 IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger, 2659 input_file_sp, 2660 empty_stream_sp, // Pass in an empty stream so we inherit the top input reader output stream 2661 empty_stream_sp, // Pass in an empty stream so we inherit the top input reader error stream 2662 flags, 2663 NULL, // Pass in NULL for "editline_name" so no history is saved, or written 2664 debugger.GetPrompt(), 2665 false, // Not multi-line 2666 *this)); 2667 const bool old_async_execution = debugger.GetAsyncExecution(); 2668 2669 // Set synchronous execution if we not stopping when we continue 2670 if ((flags & eHandleCommandFlagStopOnContinue) == 0) 2671 debugger.SetAsyncExecution (false); 2672 2673 m_command_source_depth++; 2674 2675 debugger.RunIOHandler(io_handler_sp); 2676 if (!m_command_source_flags.empty()) 2677 m_command_source_flags.pop_back(); 2678 m_command_source_depth--; 2679 result.SetStatus (eReturnStatusSuccessFinishNoResult); 2680 debugger.SetAsyncExecution (old_async_execution); 2681 } 2682 else 2683 { 2684 result.AppendErrorWithFormat ("error: an error occurred read file '%s': %s\n", cmd_file_path.c_str(), error.AsCString()); 2685 result.SetStatus (eReturnStatusFailed); 2686 } 2687 2688 2689 } 2690 else 2691 { 2692 result.AppendErrorWithFormat ("Error reading commands from file %s - file not found.\n", 2693 cmd_file.GetFilename().AsCString()); 2694 result.SetStatus (eReturnStatusFailed); 2695 return; 2696 } 2697} 2698 2699ScriptInterpreter * 2700CommandInterpreter::GetScriptInterpreter (bool can_create) 2701{ 2702 if (m_script_interpreter_ap.get() != NULL) 2703 return m_script_interpreter_ap.get(); 2704 2705 if (!can_create) 2706 return NULL; 2707 2708 // <rdar://problem/11751427> 2709 // we need to protect the initialization of the script interpreter 2710 // otherwise we could end up with two threads both trying to create 2711 // their instance of it, and for some languages (e.g. Python) 2712 // this is a bulletproof recipe for disaster! 2713 // this needs to be a function-level static because multiple Debugger instances living in the same process 2714 // still need to be isolated and not try to initialize Python concurrently 2715 static Mutex g_interpreter_mutex(Mutex::eMutexTypeRecursive); 2716 Mutex::Locker interpreter_lock(g_interpreter_mutex); 2717 2718 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT)); 2719 if (log) 2720 log->Printf("Initializing the ScriptInterpreter now\n"); 2721 2722 lldb::ScriptLanguage script_lang = GetDebugger().GetScriptLanguage(); 2723 switch (script_lang) 2724 { 2725 case eScriptLanguagePython: 2726#ifndef LLDB_DISABLE_PYTHON 2727 m_script_interpreter_ap.reset (new ScriptInterpreterPython (*this)); 2728 break; 2729#else 2730 // Fall through to the None case when python is disabled 2731#endif 2732 case eScriptLanguageNone: 2733 m_script_interpreter_ap.reset (new ScriptInterpreterNone (*this)); 2734 break; 2735 }; 2736 2737 return m_script_interpreter_ap.get(); 2738} 2739 2740 2741 2742bool 2743CommandInterpreter::GetSynchronous () 2744{ 2745 return m_synchronous_execution; 2746} 2747 2748void 2749CommandInterpreter::SetSynchronous (bool value) 2750{ 2751 m_synchronous_execution = value; 2752} 2753 2754void 2755CommandInterpreter::OutputFormattedHelpText (Stream &strm, 2756 const char *word_text, 2757 const char *separator, 2758 const char *help_text, 2759 size_t max_word_len) 2760{ 2761 const uint32_t max_columns = m_debugger.GetTerminalWidth(); 2762 2763 int indent_size = max_word_len + strlen (separator) + 2; 2764 2765 strm.IndentMore (indent_size); 2766 2767 StreamString text_strm; 2768 text_strm.Printf ("%-*s %s %s", (int)max_word_len, word_text, separator, help_text); 2769 2770 size_t len = text_strm.GetSize(); 2771 const char *text = text_strm.GetData(); 2772 if (text[len - 1] == '\n') 2773 { 2774 text_strm.EOL(); 2775 len = text_strm.GetSize(); 2776 } 2777 2778 if (len < max_columns) 2779 { 2780 // Output it as a single line. 2781 strm.Printf ("%s", text); 2782 } 2783 else 2784 { 2785 // We need to break it up into multiple lines. 2786 bool first_line = true; 2787 int text_width; 2788 size_t start = 0; 2789 size_t end = start; 2790 const size_t final_end = strlen (text); 2791 2792 while (end < final_end) 2793 { 2794 if (first_line) 2795 text_width = max_columns - 1; 2796 else 2797 text_width = max_columns - indent_size - 1; 2798 2799 // Don't start the 'text' on a space, since we're already outputting the indentation. 2800 if (!first_line) 2801 { 2802 while ((start < final_end) && (text[start] == ' ')) 2803 start++; 2804 } 2805 2806 end = start + text_width; 2807 if (end > final_end) 2808 end = final_end; 2809 else 2810 { 2811 // If we're not at the end of the text, make sure we break the line on white space. 2812 while (end > start 2813 && text[end] != ' ' && text[end] != '\t' && text[end] != '\n') 2814 end--; 2815 assert (end > 0); 2816 } 2817 2818 const size_t sub_len = end - start; 2819 if (start != 0) 2820 strm.EOL(); 2821 if (!first_line) 2822 strm.Indent(); 2823 else 2824 first_line = false; 2825 assert (start <= final_end); 2826 assert (start + sub_len <= final_end); 2827 if (sub_len > 0) 2828 strm.Write (text + start, sub_len); 2829 start = end + 1; 2830 } 2831 } 2832 strm.EOL(); 2833 strm.IndentLess(indent_size); 2834} 2835 2836void 2837CommandInterpreter::OutputHelpText (Stream &strm, 2838 const char *word_text, 2839 const char *separator, 2840 const char *help_text, 2841 uint32_t max_word_len) 2842{ 2843 int indent_size = max_word_len + strlen (separator) + 2; 2844 2845 strm.IndentMore (indent_size); 2846 2847 StreamString text_strm; 2848 text_strm.Printf ("%-*s %s %s", max_word_len, word_text, separator, help_text); 2849 2850 const uint32_t max_columns = m_debugger.GetTerminalWidth(); 2851 2852 size_t len = text_strm.GetSize(); 2853 const char *text = text_strm.GetData(); 2854 2855 uint32_t chars_left = max_columns; 2856 2857 for (uint32_t i = 0; i < len; i++) 2858 { 2859 if ((text[i] == ' ' && ::strchr((text+i+1), ' ') && chars_left < ::strchr((text+i+1), ' ')-(text+i)) || text[i] == '\n') 2860 { 2861 chars_left = max_columns - indent_size; 2862 strm.EOL(); 2863 strm.Indent(); 2864 } 2865 else 2866 { 2867 strm.PutChar(text[i]); 2868 chars_left--; 2869 } 2870 2871 } 2872 2873 strm.EOL(); 2874 strm.IndentLess(indent_size); 2875} 2876 2877void 2878CommandInterpreter::FindCommandsForApropos (const char *search_word, StringList &commands_found, 2879 StringList &commands_help, bool search_builtin_commands, bool search_user_commands) 2880{ 2881 CommandObject::CommandMap::const_iterator pos; 2882 2883 if (search_builtin_commands) 2884 { 2885 for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos) 2886 { 2887 const char *command_name = pos->first.c_str(); 2888 CommandObject *cmd_obj = pos->second.get(); 2889 2890 if (cmd_obj->HelpTextContainsWord (search_word)) 2891 { 2892 commands_found.AppendString (command_name); 2893 commands_help.AppendString (cmd_obj->GetHelp()); 2894 } 2895 2896 if (cmd_obj->IsMultiwordObject()) 2897 cmd_obj->AproposAllSubCommands (command_name, 2898 search_word, 2899 commands_found, 2900 commands_help); 2901 2902 } 2903 } 2904 2905 if (search_user_commands) 2906 { 2907 for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos) 2908 { 2909 const char *command_name = pos->first.c_str(); 2910 CommandObject *cmd_obj = pos->second.get(); 2911 2912 if (cmd_obj->HelpTextContainsWord (search_word)) 2913 { 2914 commands_found.AppendString (command_name); 2915 commands_help.AppendString (cmd_obj->GetHelp()); 2916 } 2917 2918 if (cmd_obj->IsMultiwordObject()) 2919 cmd_obj->AproposAllSubCommands (command_name, 2920 search_word, 2921 commands_found, 2922 commands_help); 2923 2924 } 2925 } 2926} 2927 2928void 2929CommandInterpreter::UpdateExecutionContext (ExecutionContext *override_context) 2930{ 2931 if (override_context != NULL) 2932 { 2933 m_exe_ctx_ref = *override_context; 2934 } 2935 else 2936 { 2937 const bool adopt_selected = true; 2938 m_exe_ctx_ref.SetTargetPtr (m_debugger.GetSelectedTarget().get(), adopt_selected); 2939 } 2940} 2941 2942 2943size_t 2944CommandInterpreter::GetProcessOutput () 2945{ 2946 // The process has stuff waiting for stderr; get it and write it out to the appropriate place. 2947 char stdio_buffer[1024]; 2948 size_t len; 2949 size_t total_bytes = 0; 2950 Error error; 2951 TargetSP target_sp (m_debugger.GetTargetList().GetSelectedTarget()); 2952 if (target_sp) 2953 { 2954 ProcessSP process_sp (target_sp->GetProcessSP()); 2955 if (process_sp) 2956 { 2957 while ((len = process_sp->GetSTDOUT (stdio_buffer, sizeof (stdio_buffer), error)) > 0) 2958 { 2959 size_t bytes_written = len; 2960 m_debugger.GetOutputFile()->Write (stdio_buffer, bytes_written); 2961 total_bytes += len; 2962 } 2963 while ((len = process_sp->GetSTDERR (stdio_buffer, sizeof (stdio_buffer), error)) > 0) 2964 { 2965 size_t bytes_written = len; 2966 m_debugger.GetErrorFile()->Write (stdio_buffer, bytes_written); 2967 total_bytes += len; 2968 } 2969 } 2970 } 2971 return total_bytes; 2972} 2973 2974void 2975CommandInterpreter::IOHandlerInputComplete (IOHandler &io_handler, std::string &line) 2976{ 2977 const bool is_interactive = io_handler.GetIsInteractive(); 2978 if (is_interactive == false) 2979 { 2980 // When we are not interactive, don't execute blank lines. This will happen 2981 // sourcing a commands file. We don't want blank lines to repeat the previous 2982 // command and cause any errors to occur (like redefining an alias, get an error 2983 // and stop parsing the commands file). 2984 if (line.empty()) 2985 return; 2986 2987 // When using a non-interactive file handle (like when sourcing commands from a file) 2988 // we need to echo the command out so we don't just see the command output and no 2989 // command... 2990 if (io_handler.GetFlags().Test(eHandleCommandFlagEchoCommand)) 2991 io_handler.GetOutputStreamFile()->Printf("%s%s\n", io_handler.GetPrompt(), line.c_str()); 2992 } 2993 2994 lldb_private::CommandReturnObject result; 2995 HandleCommand(line.c_str(), eLazyBoolCalculate, result); 2996 2997 // Now emit the command output text from the command we just executed 2998 if (io_handler.GetFlags().Test(eHandleCommandFlagPrintResult)) 2999 { 3000 // Display any STDOUT/STDERR _prior_ to emitting the command result text 3001 GetProcessOutput (); 3002 3003 if (!result.GetImmediateOutputStream()) 3004 { 3005 const char *output = result.GetOutputData(); 3006 if (output && output[0]) 3007 io_handler.GetOutputStreamFile()->PutCString(output); 3008 } 3009 3010 // Now emit the command error text from the command we just executed 3011 if (!result.GetImmediateErrorStream()) 3012 { 3013 const char *error = result.GetErrorData(); 3014 if (error && error[0]) 3015 io_handler.GetErrorStreamFile()->PutCString(error); 3016 } 3017 } 3018 3019 switch (result.GetStatus()) 3020 { 3021 case eReturnStatusInvalid: 3022 case eReturnStatusSuccessFinishNoResult: 3023 case eReturnStatusSuccessFinishResult: 3024 case eReturnStatusStarted: 3025 break; 3026 3027 case eReturnStatusSuccessContinuingNoResult: 3028 case eReturnStatusSuccessContinuingResult: 3029 if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnContinue)) 3030 io_handler.SetIsDone(true); 3031 break; 3032 3033 case eReturnStatusFailed: 3034 if (io_handler.GetFlags().Test(eHandleCommandFlagStopOnError)) 3035 io_handler.SetIsDone(true); 3036 break; 3037 3038 case eReturnStatusQuit: 3039 io_handler.SetIsDone(true); 3040 break; 3041 } 3042} 3043 3044void 3045CommandInterpreter::GetLLDBCommandsFromIOHandler (const char *prompt, 3046 IOHandlerDelegate &delegate, 3047 bool asynchronously, 3048 void *baton) 3049{ 3050 Debugger &debugger = GetDebugger(); 3051 IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger, 3052 "lldb", // Name of input reader for history 3053 prompt, // Prompt 3054 true, // Get multiple lines 3055 delegate)); // IOHandlerDelegate 3056 3057 if (io_handler_sp) 3058 { 3059 io_handler_sp->SetUserData (baton); 3060 if (asynchronously) 3061 debugger.PushIOHandler(io_handler_sp); 3062 else 3063 debugger.RunIOHandler(io_handler_sp); 3064 } 3065 3066} 3067 3068 3069void 3070CommandInterpreter::GetPythonCommandsFromIOHandler (const char *prompt, 3071 IOHandlerDelegate &delegate, 3072 bool asynchronously, 3073 void *baton) 3074{ 3075 Debugger &debugger = GetDebugger(); 3076 IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger, 3077 "lldb-python", // Name of input reader for history 3078 prompt, // Prompt 3079 true, // Get multiple lines 3080 delegate)); // IOHandlerDelegate 3081 3082 if (io_handler_sp) 3083 { 3084 io_handler_sp->SetUserData (baton); 3085 if (asynchronously) 3086 debugger.PushIOHandler(io_handler_sp); 3087 else 3088 debugger.RunIOHandler(io_handler_sp); 3089 } 3090 3091} 3092 3093bool 3094CommandInterpreter::IsActive () 3095{ 3096 return m_debugger.IsTopIOHandler (m_command_io_handler_sp); 3097} 3098 3099void 3100CommandInterpreter::RunCommandInterpreter(bool auto_handle_events, 3101 bool spawn_thread) 3102{ 3103 const bool multiple_lines = false; // Only get one line at a time 3104 if (!m_command_io_handler_sp) 3105 m_command_io_handler_sp.reset(new IOHandlerEditline (m_debugger, 3106 m_debugger.GetInputFile(), 3107 m_debugger.GetOutputFile(), 3108 m_debugger.GetErrorFile(), 3109 eHandleCommandFlagEchoCommand | eHandleCommandFlagPrintResult, 3110 "lldb", 3111 m_debugger.GetPrompt(), 3112 multiple_lines, 3113 *this)); 3114 m_debugger.PushIOHandler(m_command_io_handler_sp); 3115 3116 if (auto_handle_events) 3117 m_debugger.StartEventHandlerThread(); 3118 3119 if (spawn_thread) 3120 { 3121 m_debugger.StartIOHandlerThread(); 3122 } 3123 else 3124 { 3125 m_debugger.ExecuteIOHanders(); 3126 3127 if (auto_handle_events) 3128 m_debugger.StopEventHandlerThread(); 3129 } 3130 3131} 3132 3133