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