contrib/llvm/tools/lldb/source/Interpreter/CommandInterpreter.cpp

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