contrib/llvm/tools/lldb/source/Commands/CommandObjectCommands.cpp

   1 //===-- CommandObjectSource.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 "CommandObjectCommands.h"
  13
  14 // C Includes
  15 // C++ Includes
  16 // Other libraries and framework includes
  17 #include "llvm/ADT/StringRef.h"
  18
  19 // Project includes
  20 #include "lldb/Core/Debugger.h"
  21 #include "lldb/Core/InputReader.h"
  22 #include "lldb/Core/InputReaderEZ.h"
  23 #include "lldb/Core/StringList.h"
  24 #include "lldb/Interpreter/Args.h"
  25 #include "lldb/Interpreter/CommandHistory.h"
  26 #include "lldb/Interpreter/CommandInterpreter.h"
  27 #include "lldb/Interpreter/CommandObjectRegexCommand.h"
  28 #include "lldb/Interpreter/CommandReturnObject.h"
  29 #include "lldb/Interpreter/OptionValueBoolean.h"
  30 #include "lldb/Interpreter/OptionValueUInt64.h"
  31 #include "lldb/Interpreter/Options.h"
  32 #include "lldb/Interpreter/ScriptInterpreter.h"
  33 #include "lldb/Interpreter/ScriptInterpreterPython.h"
  34
  35 using namespace lldb;
  36 using namespace lldb_private;
  37
  38 //-------------------------------------------------------------------------
  39 // CommandObjectCommandsSource
  40 //-------------------------------------------------------------------------
  41
  42 class CommandObjectCommandsHistory : public CommandObjectParsed
  43 {
  44 public:
  45     CommandObjectCommandsHistory(CommandInterpreter &interpreter) :
  46         CommandObjectParsed (interpreter,
  47                              "command history",
  48                              "Dump the history of commands in this session.",
  49                              NULL),
  50         m_options (interpreter)
  51     {
  52     }
  53
  54     ~CommandObjectCommandsHistory () {}
  55
  56     virtual Options *
  57     GetOptions ()
  58     {
  59         return &m_options;
  60     }
  61
  62 protected:
  63
  64     class CommandOptions : public Options
  65     {
  66     public:
  67
  68         CommandOptions (CommandInterpreter &interpreter) :
  69             Options (interpreter),
  70             m_start_idx(0),
  71             m_stop_idx(0),
  72             m_count(0),
  73             m_clear(false)
  74         {
  75         }
  76
  77         virtual
  78         ~CommandOptions (){}
  79
  80         virtual Error
  81         SetOptionValue (uint32_t option_idx, const char *option_arg)
  82         {
  83             Error error;
  84             const int short_option = m_getopt_table[option_idx].val;
  85
  86             switch (short_option)
  87             {
  88                 case 'c':
  89                     error = m_count.SetValueFromCString(option_arg,eVarSetOperationAssign);
  90                     break;
  91                 case 's':
  92                     if (option_arg && strcmp("end", option_arg) == 0)
  93                     {
  94                         m_start_idx.SetCurrentValue(UINT64_MAX);
  95                         m_start_idx.SetOptionWasSet();
  96                     }
  97                     else
  98                         error = m_start_idx.SetValueFromCString(option_arg,eVarSetOperationAssign);
  99                     break;
 100                 case 'e':
 101                     error = m_stop_idx.SetValueFromCString(option_arg,eVarSetOperationAssign);
 102                     break;
 103                 case 'C':
 104                     m_clear.SetCurrentValue(true);
 105                     m_clear.SetOptionWasSet();
 106                     break;
 107                 default:
 108                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
 109                     break;
 110             }
 111
 112             return error;
 113         }
 114
 115         void
 116         OptionParsingStarting ()
 117         {
 118             m_start_idx.Clear();
 119             m_stop_idx.Clear();
 120             m_count.Clear();
 121             m_clear.Clear();
 122         }
 123
 124         const OptionDefinition*
 125         GetDefinitions ()
 126         {
 127             return g_option_table;
 128         }
 129
 130         // Options table: Required for subclasses of Options.
 131
 132         static OptionDefinition g_option_table[];
 133
 134         // Instance variables to hold the values for command options.
 135
 136         OptionValueUInt64 m_start_idx;
 137         OptionValueUInt64 m_stop_idx;
 138         OptionValueUInt64 m_count;
 139         OptionValueBoolean m_clear;
 140     };
 141
 142     bool
 143     DoExecute (Args& command, CommandReturnObject &result)
 144     {
 145         if (m_options.m_clear.GetCurrentValue() && m_options.m_clear.OptionWasSet())
 146         {
 147             m_interpreter.GetCommandHistory().Clear();
 148             result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
 149         }
 150         else
 151         {
 152             if (m_options.m_start_idx.OptionWasSet() && m_options.m_stop_idx.OptionWasSet() && m_options.m_count.OptionWasSet())
 153             {
 154                 result.AppendError("--count, --start-index and --end-index cannot be all specified in the same invocation");
 155                 result.SetStatus(lldb::eReturnStatusFailed);
 156             }
 157             else
 158             {
 159                 std::pair<bool,uint64_t> start_idx = {m_options.m_start_idx.OptionWasSet(),m_options.m_start_idx.GetCurrentValue()};
 160                 std::pair<bool,uint64_t> stop_idx = {m_options.m_stop_idx.OptionWasSet(),m_options.m_stop_idx.GetCurrentValue()};
 161                 std::pair<bool,uint64_t> count = {m_options.m_count.OptionWasSet(),m_options.m_count.GetCurrentValue()};
 162
 163                 const CommandHistory& history(m_interpreter.GetCommandHistory());
 164
 165                 if (start_idx.first && start_idx.second == UINT64_MAX)
 166                 {
 167                     if (count.first)
 168                     {
 169                         start_idx.second = history.GetSize() - count.second;
 170                         stop_idx.second = history.GetSize() - 1;
 171                     }
 172                     else if (stop_idx.first)
 173                     {
 174                         start_idx.second = stop_idx.second;
 175                         stop_idx.second = history.GetSize() - 1;
 176                     }
 177                     else
 178                     {
 179                         start_idx.second = 0;
 180                         stop_idx.second = history.GetSize() - 1;
 181                     }
 182                 }
 183                 else
 184                 {
 185                     if (!start_idx.first && !stop_idx.first && !count.first)
 186                     {
 187                         start_idx.second = 0;
 188                         stop_idx.second = history.GetSize() - 1;
 189                     }
 190                     else if (start_idx.first)
 191                     {
 192                         if (count.first)
 193                         {
 194                             stop_idx.second = start_idx.second + count.second - 1;
 195                         }
 196                         else if (!stop_idx.first)
 197                         {
 198                             stop_idx.second = history.GetSize() - 1;
 199                         }
 200                     }
 201                     else if (stop_idx.first)
 202                     {
 203                         if (count.first)
 204                         {
 205                             if (stop_idx.second >= count.second)
 206                                 start_idx.second = stop_idx.second - count.second + 1;
 207                             else
 208                                 start_idx.second = 0;
 209                         }
 210                     }
 211                     else /* if (count.first) */
 212                     {
 213                         start_idx.second = 0;
 214                         stop_idx.second = count.second - 1;
 215                     }
 216                 }
 217                 history.Dump(result.GetOutputStream(), start_idx.second, stop_idx.second);
 218             }
 219         }
 220         return result.Succeeded();
 221
 222     }
 223
 224     CommandOptions m_options;
 225 };
 226
 227 OptionDefinition
 228 CommandObjectCommandsHistory::CommandOptions::g_option_table[] =
 229 {
 230 { LLDB_OPT_SET_1, false, "count", 'c', required_argument, NULL, 0, eArgTypeUnsignedInteger,        "How many history commands to print."},
 231 { LLDB_OPT_SET_1, false, "start-index", 's', required_argument, NULL, 0, eArgTypeUnsignedInteger,  "Index at which to start printing history commands (or end to mean tail mode)."},
 232 { LLDB_OPT_SET_1, false, "end-index", 'e', required_argument, NULL, 0, eArgTypeUnsignedInteger,    "Index at which to stop printing history commands."},
 233 { LLDB_OPT_SET_2, false, "clear", 'C', no_argument, NULL, 0, eArgTypeBoolean,    "Clears the current command history."},
 234 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
 235 };
 236
 237
 238 //-------------------------------------------------------------------------
 239 // CommandObjectCommandsSource
 240 //-------------------------------------------------------------------------
 241
 242 class CommandObjectCommandsSource : public CommandObjectParsed
 243 {
 244 public:
 245     CommandObjectCommandsSource(CommandInterpreter &interpreter) :
 246         CommandObjectParsed (interpreter,
 247                              "command source",
 248                              "Read in debugger commands from the file <filename> and execute them.",
 249                              NULL),
 250         m_options (interpreter)
 251     {
 252         CommandArgumentEntry arg;
 253         CommandArgumentData file_arg;
 254
 255         // Define the first (and only) variant of this arg.
 256         file_arg.arg_type = eArgTypeFilename;
 257         file_arg.arg_repetition = eArgRepeatPlain;
 258
 259         // There is only one variant this argument could be; put it into the argument entry.
 260         arg.push_back (file_arg);
 261
 262         // Push the data for the first argument into the m_arguments vector.
 263         m_arguments.push_back (arg);
 264     }
 265
 266     ~CommandObjectCommandsSource () {}
 267
 268     virtual const char*
 269     GetRepeatCommand (Args &current_command_args, uint32_t index)
 270     {
 271         return "";
 272     }
 273
 274     virtual int
 275     HandleArgumentCompletion (Args &input,
 276                               int &cursor_index,
 277                               int &cursor_char_position,
 278                               OptionElementVector &opt_element_vector,
 279                               int match_start_point,
 280                               int max_return_elements,
 281                               bool &word_complete,
 282                               StringList &matches)
 283     {
 284         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
 285         completion_str.erase (cursor_char_position);
 286
 287         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
 288                                                              CommandCompletions::eDiskFileCompletion,
 289                                                              completion_str.c_str(),
 290                                                              match_start_point,
 291                                                              max_return_elements,
 292                                                              NULL,
 293                                                              word_complete,
 294                                                              matches);
 295         return matches.GetSize();
 296     }
 297
 298     virtual Options *
 299     GetOptions ()
 300     {
 301         return &m_options;
 302     }
 303
 304 protected:
 305
 306     class CommandOptions : public Options
 307     {
 308     public:
 309
 310         CommandOptions (CommandInterpreter &interpreter) :
 311             Options (interpreter),
 312             m_stop_on_error (true)
 313         {
 314         }
 315
 316         virtual
 317         ~CommandOptions (){}
 318
 319         virtual Error
 320         SetOptionValue (uint32_t option_idx, const char *option_arg)
 321         {
 322             Error error;
 323             const int short_option = m_getopt_table[option_idx].val;
 324             bool success;
 325
 326             switch (short_option)
 327             {
 328                 case 'e':
 329                     error = m_stop_on_error.SetValueFromCString(option_arg);
 330                     break;
 331                 case 'c':
 332                     m_stop_on_continue = Args::StringToBoolean(option_arg, true, &success);
 333                     if (!success)
 334                         error.SetErrorStringWithFormat("invalid value for stop-on-continue: %s", option_arg);
 335                     break;
 336                 case 's':
 337                     m_silent_run = Args::StringToBoolean(option_arg, true, &success);
 338                     if (!success)
 339                         error.SetErrorStringWithFormat("invalid value for silent-run: %s", option_arg);
 340                     break;
 341                 default:
 342                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
 343                     break;
 344             }
 345
 346             return error;
 347         }
 348
 349         void
 350         OptionParsingStarting ()
 351         {
 352             m_stop_on_error.Clear();
 353             m_silent_run = false;
 354             m_stop_on_continue = true;
 355         }
 356
 357         const OptionDefinition*
 358         GetDefinitions ()
 359         {
 360             return g_option_table;
 361         }
 362
 363         // Options table: Required for subclasses of Options.
 364
 365         static OptionDefinition g_option_table[];
 366
 367         // Instance variables to hold the values for command options.
 368
 369         OptionValueBoolean m_stop_on_error;
 370             bool m_silent_run;
 371         bool m_stop_on_continue;
 372     };
 373
 374     bool
 375     DoExecute(Args& command, CommandReturnObject &result)
 376     {
 377         const size_t argc = command.GetArgumentCount();
 378         if (argc == 1)
 379         {
 380             const char *filename = command.GetArgumentAtIndex(0);
 381
 382             result.AppendMessageWithFormat ("Executing commands in '%s'.\n", filename);
 383
 384             FileSpec cmd_file (filename, true);
 385             ExecutionContext *exe_ctx = NULL;  // Just use the default context.
 386             bool echo_commands    = !m_options.m_silent_run;
 387             bool print_results    = true;
 388             bool stop_on_error = m_options.m_stop_on_error.OptionWasSet() ? (bool)m_options.m_stop_on_error : m_interpreter.GetStopCmdSourceOnError();
 389
 390             m_interpreter.HandleCommandsFromFile (cmd_file,
 391                                                   exe_ctx,
 392                                                   m_options.m_stop_on_continue,
 393                                                   stop_on_error,
 394                                                   echo_commands,
 395                                                   print_results,
 396                                                   eLazyBoolCalculate,
 397                                                   result);
 398         }
 399         else
 400         {
 401             result.AppendErrorWithFormat("'%s' takes exactly one executable filename argument.\n", GetCommandName());
 402             result.SetStatus (eReturnStatusFailed);
 403         }
 404         return result.Succeeded();
 405
 406     }
 407     CommandOptions m_options;
 408 };
 409
 410 OptionDefinition
 411 CommandObjectCommandsSource::CommandOptions::g_option_table[] =
 412 {
 413 { LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', required_argument, NULL, 0, eArgTypeBoolean,    "If true, stop executing commands on error."},
 414 { LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', required_argument, NULL, 0, eArgTypeBoolean, "If true, stop executing commands on continue."},
 415 { LLDB_OPT_SET_ALL, false, "silent-run", 's', required_argument, NULL, 0, eArgTypeBoolean, "If true don't echo commands while executing."},
 416 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
 417 };
 418
 419 #pragma mark CommandObjectCommandsAlias
 420 //-------------------------------------------------------------------------
 421 // CommandObjectCommandsAlias
 422 //-------------------------------------------------------------------------
 423
 424 static const char *g_python_command_instructions =   "Enter your Python command(s). Type 'DONE' to end.\n"
 425                                                      "You must define a Python function with this signature:\n"
 426                                                      "def my_command_impl(debugger, args, result, internal_dict):";
 427
 428
 429 class CommandObjectCommandsAlias : public CommandObjectRaw
 430 {
 431
 432
 433 public:
 434     CommandObjectCommandsAlias (CommandInterpreter &interpreter) :
 435         CommandObjectRaw (interpreter,
 436                        "command alias",
 437                        "Allow users to define their own debugger command abbreviations.",
 438                        NULL)
 439     {
 440         SetHelpLong(
 441     "'alias' allows the user to create a short-cut or abbreviation for long \n\
 442     commands, multi-word commands, and commands that take particular options. \n\
 443     Below are some simple examples of how one might use the 'alias' command: \n\
 444     \n    'command alias sc script'            // Creates the abbreviation 'sc' for the 'script' \n\
 445                                          // command. \n\
 446     'command alias bp breakpoint'        // Creates the abbreviation 'bp' for the 'breakpoint' \n\
 447                                          // command.  Since breakpoint commands are two-word \n\
 448                                          // commands, the user will still need to enter the \n\
 449                                          // second word after 'bp', e.g. 'bp enable' or \n\
 450                                          // 'bp delete'. \n\
 451     'command alias bpl breakpoint list'  // Creates the abbreviation 'bpl' for the \n\
 452                                          // two-word command 'breakpoint list'. \n\
 453     \nAn alias can include some options for the command, with the values either \n\
 454     filled in at the time the alias is created, or specified as positional \n\
 455     arguments, to be filled in when the alias is invoked.  The following example \n\
 456     shows how to create aliases with options: \n\
 457     \n\
 458     'command alias bfl breakpoint set -f %1 -l %2' \n\
 459     \nThis creates the abbreviation 'bfl' (for break-file-line), with the -f and -l \n\
 460     options already part of the alias.  So if the user wants to set a breakpoint \n\
 461     by file and line without explicitly having to use the -f and -l options, the \n\
 462     user can now use 'bfl' instead.  The '%1' and '%2' are positional placeholders \n\
 463     for the actual arguments that will be passed when the alias command is used. \n\
 464     The number in the placeholder refers to the position/order the actual value \n\
 465     occupies when the alias is used.  All the occurrences of '%1' in the alias \n\
 466     will be replaced with the first argument, all the occurrences of '%2' in the \n\
 467     alias will be replaced with the second argument, and so on.  This also allows \n\
 468     actual arguments to be used multiple times within an alias (see 'process \n\
 469     launch' example below).  \n\
 470     Note: the positional arguments must substitute as whole words in the resultant\n\
 471     command, so you can't at present do something like:\n\
 472     \n\
 473     command alias bcppfl breakpoint set -f %1.cpp -l %2\n\
 474     \n\
 475     to get the file extension \".cpp\" automatically appended.  For more complex\n\
 476     aliasing, use the \"command regex\" command instead.\n\
 477     \nSo in the 'bfl' case, the actual file value will be \n\
 478     filled in with the first argument following 'bfl' and the actual line number \n\
 479     value will be filled in with the second argument.  The user would use this \n\
 480     alias as follows: \n\
 481     \n    (lldb)  command alias bfl breakpoint set -f %1 -l %2 \n\
 482     <... some time later ...> \n\
 483     (lldb)  bfl my-file.c 137 \n\
 484     \nThis would be the same as if the user had entered \n\
 485     'breakpoint set -f my-file.c -l 137'. \n\
 486     \nAnother example: \n\
 487     \n    (lldb)  command alias pltty  process launch -s -o %1 -e %1 \n\
 488     (lldb)  pltty /dev/tty0 \n\
 489            // becomes 'process launch -s -o /dev/tty0 -e /dev/tty0' \n\
 490     \nIf the user always wanted to pass the same value to a particular option, the \n\
 491     alias could be defined with that value directly in the alias as a constant, \n\
 492     rather than using a positional placeholder: \n\
 493     \n    command alias bl3  breakpoint set -f %1 -l 3  // Always sets a breakpoint on line \n\
 494                                                    // 3 of whatever file is indicated. \n");
 495
 496         CommandArgumentEntry arg1;
 497         CommandArgumentEntry arg2;
 498         CommandArgumentEntry arg3;
 499         CommandArgumentData alias_arg;
 500         CommandArgumentData cmd_arg;
 501         CommandArgumentData options_arg;
 502
 503         // Define the first (and only) variant of this arg.
 504         alias_arg.arg_type = eArgTypeAliasName;
 505         alias_arg.arg_repetition = eArgRepeatPlain;
 506
 507         // There is only one variant this argument could be; put it into the argument entry.
 508         arg1.push_back (alias_arg);
 509
 510         // Define the first (and only) variant of this arg.
 511         cmd_arg.arg_type = eArgTypeCommandName;
 512         cmd_arg.arg_repetition = eArgRepeatPlain;
 513
 514         // There is only one variant this argument could be; put it into the argument entry.
 515         arg2.push_back (cmd_arg);
 516
 517         // Define the first (and only) variant of this arg.
 518         options_arg.arg_type = eArgTypeAliasOptions;
 519         options_arg.arg_repetition = eArgRepeatOptional;
 520
 521         // There is only one variant this argument could be; put it into the argument entry.
 522         arg3.push_back (options_arg);
 523
 524         // Push the data for the first argument into the m_arguments vector.
 525         m_arguments.push_back (arg1);
 526         m_arguments.push_back (arg2);
 527         m_arguments.push_back (arg3);
 528     }
 529
 530     ~CommandObjectCommandsAlias ()
 531     {
 532     }
 533
 534 protected:
 535     virtual bool
 536     DoExecute (const char *raw_command_line, CommandReturnObject &result)
 537     {
 538         Args args (raw_command_line);
 539         std::string raw_command_string (raw_command_line);
 540
 541         size_t argc = args.GetArgumentCount();
 542
 543         if (argc < 2)
 544         {
 545             result.AppendError ("'alias' requires at least two arguments");
 546             result.SetStatus (eReturnStatusFailed);
 547             return false;
 548         }
 549
 550         // Get the alias command.
 551
 552         const std::string alias_command = args.GetArgumentAtIndex (0);
 553
 554         // Strip the new alias name off 'raw_command_string'  (leave it on args, which gets passed to 'Execute', which
 555         // does the stripping itself.
 556         size_t pos = raw_command_string.find (alias_command);
 557         if (pos == 0)
 558         {
 559             raw_command_string = raw_command_string.substr (alias_command.size());
 560             pos = raw_command_string.find_first_not_of (' ');
 561             if ((pos != std::string::npos) && (pos > 0))
 562                 raw_command_string = raw_command_string.substr (pos);
 563         }
 564         else
 565         {
 566             result.AppendError ("Error parsing command string.  No alias created.");
 567             result.SetStatus (eReturnStatusFailed);
 568             return false;
 569         }
 570
 571
 572         // Verify that the command is alias-able.
 573         if (m_interpreter.CommandExists (alias_command.c_str()))
 574         {
 575             result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be redefined.\n",
 576                                           alias_command.c_str());
 577             result.SetStatus (eReturnStatusFailed);
 578             return false;
 579         }
 580
 581         // Get CommandObject that is being aliased. The command name is read from the front of raw_command_string.
 582         // raw_command_string is returned with the name of the command object stripped off the front.
 583         CommandObject *cmd_obj = m_interpreter.GetCommandObjectForCommand (raw_command_string);
 584
 585         if (!cmd_obj)
 586         {
 587             result.AppendErrorWithFormat ("invalid command given to 'alias'. '%s' does not begin with a valid command."
 588                                           "  No alias created.", raw_command_string.c_str());
 589             result.SetStatus (eReturnStatusFailed);
 590             return false;
 591         }
 592         else if (!cmd_obj->WantsRawCommandString ())
 593         {
 594             // Note that args was initialized with the original command, and has not been updated to this point.
 595             // Therefore can we pass it to the version of Execute that does not need/expect raw input in the alias.
 596             return HandleAliasingNormalCommand (args, result);
 597         }
 598         else
 599         {
 600             return HandleAliasingRawCommand (alias_command, raw_command_string, *cmd_obj, result);
 601         }
 602         return result.Succeeded();
 603     }
 604
 605     bool
 606     HandleAliasingRawCommand (const std::string &alias_command, std::string &raw_command_string, CommandObject &cmd_obj, CommandReturnObject &result)
 607     {
 608             // Verify & handle any options/arguments passed to the alias command
 609
 610             OptionArgVectorSP option_arg_vector_sp = OptionArgVectorSP (new OptionArgVector);
 611             OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
 612
 613             CommandObjectSP cmd_obj_sp = m_interpreter.GetCommandSPExact (cmd_obj.GetCommandName(), false);
 614
 615             if (!m_interpreter.ProcessAliasOptionsArgs (cmd_obj_sp, raw_command_string.c_str(), option_arg_vector_sp))
 616             {
 617                 result.AppendError ("Unable to create requested alias.\n");
 618                 result.SetStatus (eReturnStatusFailed);
 619                 return false;
 620             }
 621
 622             // Create the alias
 623             if (m_interpreter.AliasExists (alias_command.c_str())
 624                 || m_interpreter.UserCommandExists (alias_command.c_str()))
 625             {
 626                 OptionArgVectorSP temp_option_arg_sp (m_interpreter.GetAliasOptions (alias_command.c_str()));
 627                 if (temp_option_arg_sp.get())
 628                 {
 629                     if (option_arg_vector->size() == 0)
 630                         m_interpreter.RemoveAliasOptions (alias_command.c_str());
 631                 }
 632                 result.AppendWarningWithFormat ("Overwriting existing definition for '%s'.\n",
 633                                                 alias_command.c_str());
 634             }
 635
 636             if (cmd_obj_sp)
 637             {
 638                 m_interpreter.AddAlias (alias_command.c_str(), cmd_obj_sp);
 639                 if (option_arg_vector->size() > 0)
 640                     m_interpreter.AddOrReplaceAliasOptions (alias_command.c_str(), option_arg_vector_sp);
 641                 result.SetStatus (eReturnStatusSuccessFinishNoResult);
 642             }
 643             else
 644             {
 645                 result.AppendError ("Unable to create requested alias.\n");
 646                 result.SetStatus (eReturnStatusFailed);
 647             }
 648             return result.Succeeded ();
 649     }
 650
 651     bool
 652     HandleAliasingNormalCommand (Args& args, CommandReturnObject &result)
 653     {
 654         size_t argc = args.GetArgumentCount();
 655
 656         if (argc < 2)
 657         {
 658             result.AppendError ("'alias' requires at least two arguments");
 659             result.SetStatus (eReturnStatusFailed);
 660             return false;
 661         }
 662
 663         const std::string alias_command = args.GetArgumentAtIndex(0);
 664         const std::string actual_command = args.GetArgumentAtIndex(1);
 665
 666         args.Shift();  // Shift the alias command word off the argument vector.
 667         args.Shift();  // Shift the old command word off the argument vector.
 668
 669         // Verify that the command is alias'able, and get the appropriate command object.
 670
 671         if (m_interpreter.CommandExists (alias_command.c_str()))
 672         {
 673             result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be redefined.\n",
 674                                          alias_command.c_str());
 675             result.SetStatus (eReturnStatusFailed);
 676         }
 677         else
 678         {
 679              CommandObjectSP command_obj_sp(m_interpreter.GetCommandSPExact (actual_command.c_str(), true));
 680              CommandObjectSP subcommand_obj_sp;
 681              bool use_subcommand = false;
 682              if (command_obj_sp.get())
 683              {
 684                  CommandObject *cmd_obj = command_obj_sp.get();
 685                  CommandObject *sub_cmd_obj = NULL;
 686                  OptionArgVectorSP option_arg_vector_sp = OptionArgVectorSP (new OptionArgVector);
 687                  OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
 688
 689                  while (cmd_obj->IsMultiwordObject() && args.GetArgumentCount() > 0)
 690                  {
 691                      if (argc >= 3)
 692                      {
 693                          const std::string sub_command = args.GetArgumentAtIndex(0);
 694                          assert (sub_command.length() != 0);
 695                          subcommand_obj_sp = cmd_obj->GetSubcommandSP (sub_command.c_str());
 696                          if (subcommand_obj_sp.get())
 697                          {
 698                              sub_cmd_obj = subcommand_obj_sp.get();
 699                              use_subcommand = true;
 700                              args.Shift();  // Shift the sub_command word off the argument vector.
 701                              cmd_obj = sub_cmd_obj;
 702                          }
 703                          else
 704                          {
 705                              result.AppendErrorWithFormat("'%s' is not a valid sub-command of '%s'.  "
 706                                                           "Unable to create alias.\n",
 707                                                           sub_command.c_str(), actual_command.c_str());
 708                              result.SetStatus (eReturnStatusFailed);
 709                              return false;
 710                          }
 711                      }
 712                  }
 713
 714                  // Verify & handle any options/arguments passed to the alias command
 715
 716                  if (args.GetArgumentCount () > 0)
 717                  {
 718                     CommandObjectSP tmp_sp = m_interpreter.GetCommandSPExact (cmd_obj->GetCommandName(), false);
 719                     if (use_subcommand)
 720                         tmp_sp = m_interpreter.GetCommandSPExact (sub_cmd_obj->GetCommandName(), false);
 721
 722                     std::string args_string;
 723                     args.GetCommandString (args_string);
 724
 725                     if (!m_interpreter.ProcessAliasOptionsArgs (tmp_sp, args_string.c_str(), option_arg_vector_sp))
 726                     {
 727                         result.AppendError ("Unable to create requested alias.\n");
 728                         result.SetStatus (eReturnStatusFailed);
 729                         return false;
 730                     }
 731                  }
 732
 733                  // Create the alias.
 734
 735                  if (m_interpreter.AliasExists (alias_command.c_str())
 736                      || m_interpreter.UserCommandExists (alias_command.c_str()))
 737                  {
 738                      OptionArgVectorSP tmp_option_arg_sp (m_interpreter.GetAliasOptions (alias_command.c_str()));
 739                      if (tmp_option_arg_sp.get())
 740                      {
 741                          if (option_arg_vector->size() == 0)
 742                              m_interpreter.RemoveAliasOptions (alias_command.c_str());
 743                      }
 744                      result.AppendWarningWithFormat ("Overwriting existing definition for '%s'.\n",
 745                                                      alias_command.c_str());
 746                  }
 747
 748                  if (use_subcommand)
 749                      m_interpreter.AddAlias (alias_command.c_str(), subcommand_obj_sp);
 750                  else
 751                      m_interpreter.AddAlias (alias_command.c_str(), command_obj_sp);
 752                  if (option_arg_vector->size() > 0)
 753                      m_interpreter.AddOrReplaceAliasOptions (alias_command.c_str(), option_arg_vector_sp);
 754                  result.SetStatus (eReturnStatusSuccessFinishNoResult);
 755              }
 756              else
 757              {
 758                  result.AppendErrorWithFormat ("'%s' is not an existing command.\n", actual_command.c_str());
 759                  result.SetStatus (eReturnStatusFailed);
 760                  return false;
 761              }
 762         }
 763
 764         return result.Succeeded();
 765     }
 766
 767 };
 768
 769 #pragma mark CommandObjectCommandsUnalias
 770 //-------------------------------------------------------------------------
 771 // CommandObjectCommandsUnalias
 772 //-------------------------------------------------------------------------
 773
 774 class CommandObjectCommandsUnalias : public CommandObjectParsed
 775 {
 776 public:
 777     CommandObjectCommandsUnalias (CommandInterpreter &interpreter) :
 778         CommandObjectParsed (interpreter,
 779                        "command unalias",
 780                        "Allow the user to remove/delete a user-defined command abbreviation.",
 781                        NULL)
 782     {
 783         CommandArgumentEntry arg;
 784         CommandArgumentData alias_arg;
 785
 786         // Define the first (and only) variant of this arg.
 787         alias_arg.arg_type = eArgTypeAliasName;
 788         alias_arg.arg_repetition = eArgRepeatPlain;
 789
 790         // There is only one variant this argument could be; put it into the argument entry.
 791         arg.push_back (alias_arg);
 792
 793         // Push the data for the first argument into the m_arguments vector.
 794         m_arguments.push_back (arg);
 795     }
 796
 797     ~CommandObjectCommandsUnalias()
 798     {
 799     }
 800
 801 protected:
 802     bool
 803     DoExecute (Args& args, CommandReturnObject &result)
 804     {
 805         CommandObject::CommandMap::iterator pos;
 806         CommandObject *cmd_obj;
 807
 808         if (args.GetArgumentCount() != 0)
 809         {
 810             const char *command_name = args.GetArgumentAtIndex(0);
 811             cmd_obj = m_interpreter.GetCommandObject(command_name);
 812             if (cmd_obj)
 813             {
 814                 if (m_interpreter.CommandExists (command_name))
 815                 {
 816                     result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be removed.\n",
 817                                                   command_name);
 818                     result.SetStatus (eReturnStatusFailed);
 819                 }
 820                 else
 821                 {
 822
 823                     if (m_interpreter.RemoveAlias (command_name) == false)
 824                     {
 825                         if (m_interpreter.AliasExists (command_name))
 826                             result.AppendErrorWithFormat ("Error occurred while attempting to unalias '%s'.\n",
 827                                                           command_name);
 828                         else
 829                             result.AppendErrorWithFormat ("'%s' is not an existing alias.\n", command_name);
 830                         result.SetStatus (eReturnStatusFailed);
 831                     }
 832                     else
 833                         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 834                 }
 835             }
 836             else
 837             {
 838                 result.AppendErrorWithFormat ("'%s' is not a known command.\nTry 'help' to see a "
 839                                               "current list of commands.\n",
 840                                              command_name);
 841                 result.SetStatus (eReturnStatusFailed);
 842             }
 843         }
 844         else
 845         {
 846             result.AppendError ("must call 'unalias' with a valid alias");
 847             result.SetStatus (eReturnStatusFailed);
 848         }
 849
 850         return result.Succeeded();
 851     }
 852 };
 853
 854 //-------------------------------------------------------------------------
 855 // CommandObjectCommandsAddRegex
 856 //-------------------------------------------------------------------------
 857 #pragma mark CommandObjectCommandsAddRegex
 858
 859 class CommandObjectCommandsAddRegex : public CommandObjectParsed
 860 {
 861 public:
 862     CommandObjectCommandsAddRegex (CommandInterpreter &interpreter) :
 863         CommandObjectParsed (interpreter,
 864                        "command regex",
 865                        "Allow the user to create a regular expression command.",
 866                        "command regex <cmd-name> [s/<regex>/<subst>/ ...]"),
 867         m_options (interpreter)
 868     {
 869         SetHelpLong(
 870 "This command allows the user to create powerful regular expression commands\n"
 871 "with substitutions. The regular expressions and substitutions are specified\n"
 872 "using the regular exression substitution format of:\n"
 873 "\n"
 874 "    s/<regex>/<subst>/\n"
 875 "\n"
 876 "<regex> is a regular expression that can use parenthesis to capture regular\n"
 877 "expression input and substitute the captured matches in the output using %1\n"
 878 "for the first match, %2 for the second, and so on.\n"
 879 "\n"
 880 "The regular expressions can all be specified on the command line if more than\n"
 881 "one argument is provided. If just the command name is provided on the command\n"
 882 "line, then the regular expressions and substitutions can be entered on separate\n"
 883 " lines, followed by an empty line to terminate the command definition.\n"
 884 "\n"
 885 "EXAMPLES\n"
 886 "\n"
 887 "The following example will define a regular expression command named 'f' that\n"
 888 "will call 'finish' if there are no arguments, or 'frame select <frame-idx>' if\n"
 889 "a number follows 'f':\n"
 890 "\n"
 891 "    (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/'\n"
 892 "\n"
 893                     );
 894     }
 895
 896     ~CommandObjectCommandsAddRegex()
 897     {
 898     }
 899
 900
 901 protected:
 902     bool
 903     DoExecute (Args& command, CommandReturnObject &result)
 904     {
 905         const size_t argc = command.GetArgumentCount();
 906         if (argc == 0)
 907         {
 908             result.AppendError ("usage: 'command regex <command-name> [s/<regex1>/<subst1>/ s/<regex2>/<subst2>/ ...]'\n");
 909             result.SetStatus (eReturnStatusFailed);
 910         }
 911         else
 912         {
 913             Error error;
 914             const char *name = command.GetArgumentAtIndex(0);
 915             m_regex_cmd_ap.reset (new CommandObjectRegexCommand (m_interpreter,
 916                                                                  name,
 917                                                                  m_options.GetHelp (),
 918                                                                  m_options.GetSyntax (),
 919                                                                  10));
 920
 921             if (argc == 1)
 922             {
 923                 InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger()));
 924                 if (reader_sp)
 925                 {
 926                     error =reader_sp->Initialize (CommandObjectCommandsAddRegex::InputReaderCallback,
 927                                                   this,                         // baton
 928                                                   eInputReaderGranularityLine,  // token size, to pass to callback function
 929                                                   NULL,                         // end token
 930                                                   "> ",                         // prompt
 931                                                   true);                        // echo input
 932                     if (error.Success())
 933                     {
 934                         m_interpreter.GetDebugger().PushInputReader (reader_sp);
 935                         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 936                         return true;
 937                     }
 938                 }
 939             }
 940             else
 941             {
 942                 for (size_t arg_idx = 1; arg_idx < argc; ++arg_idx)
 943                 {
 944                     llvm::StringRef arg_strref (command.GetArgumentAtIndex(arg_idx));
 945                     error = AppendRegexSubstitution (arg_strref);
 946                     if (error.Fail())
 947                         break;
 948                 }
 949
 950                 if (error.Success())
 951                 {
 952                     AddRegexCommandToInterpreter();
 953                 }
 954             }
 955             if (error.Fail())
 956             {
 957                 result.AppendError (error.AsCString());
 958                 result.SetStatus (eReturnStatusFailed);
 959             }
 960         }
 961
 962         return result.Succeeded();
 963     }
 964
 965     Error
 966     AppendRegexSubstitution (const llvm::StringRef &regex_sed)
 967     {
 968         Error error;
 969
 970         if (m_regex_cmd_ap.get() == NULL)
 971         {
 972             error.SetErrorStringWithFormat("invalid regular expression command object for: '%.*s'",
 973                                            (int)regex_sed.size(),
 974                                            regex_sed.data());
 975             return error;
 976         }
 977
 978         size_t regex_sed_size = regex_sed.size();
 979
 980         if (regex_sed_size <= 1)
 981         {
 982             error.SetErrorStringWithFormat("regular expression substitution string is too short: '%.*s'",
 983                                            (int)regex_sed.size(),
 984                                            regex_sed.data());
 985             return error;
 986         }
 987
 988         if (regex_sed[0] != 's')
 989         {
 990             error.SetErrorStringWithFormat("regular expression substitution string doesn't start with 's': '%.*s'",
 991                                            (int)regex_sed.size(),
 992                                            regex_sed.data());
 993             return error;
 994         }
 995         const size_t first_separator_char_pos = 1;
 996         // use the char that follows 's' as the regex separator character
 997         // so we can have "s/<regex>/<subst>/" or "s|<regex>|<subst>|"
 998         const char separator_char = regex_sed[first_separator_char_pos];
 999         const size_t second_separator_char_pos = regex_sed.find (separator_char, first_separator_char_pos + 1);
1000
1001         if (second_separator_char_pos == std::string::npos)
1002         {
1003             error.SetErrorStringWithFormat("missing second '%c' separator char after '%.*s'",
1004                                            separator_char,
1005                                            (int)(regex_sed.size() - first_separator_char_pos - 1),
1006                                            regex_sed.data() + (first_separator_char_pos + 1));
1007             return error;
1008         }
1009
1010         const size_t third_separator_char_pos = regex_sed.find (separator_char, second_separator_char_pos + 1);
1011
1012         if (third_separator_char_pos == std::string::npos)
1013         {
1014             error.SetErrorStringWithFormat("missing third '%c' separator char after '%.*s'",
1015                                            separator_char,
1016                                            (int)(regex_sed.size() - second_separator_char_pos - 1),
1017                                            regex_sed.data() + (second_separator_char_pos + 1));
1018             return error;
1019         }
1020
1021         if (third_separator_char_pos != regex_sed_size - 1)
1022         {
1023             // Make sure that everything that follows the last regex
1024             // separator char
1025             if (regex_sed.find_first_not_of("\t\n\v\f\r ", third_separator_char_pos + 1) != std::string::npos)
1026             {
1027                 error.SetErrorStringWithFormat("extra data found after the '%.*s' regular expression substitution string: '%.*s'",
1028                                                (int)third_separator_char_pos + 1,
1029                                                regex_sed.data(),
1030                                                (int)(regex_sed.size() - third_separator_char_pos - 1),
1031                                                regex_sed.data() + (third_separator_char_pos + 1));
1032                 return error;
1033             }
1034
1035         }
1036         else if (first_separator_char_pos + 1 == second_separator_char_pos)
1037         {
1038             error.SetErrorStringWithFormat("<regex> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'",
1039                                            separator_char,
1040                                            separator_char,
1041                                            separator_char,
1042                                            (int)regex_sed.size(),
1043                                            regex_sed.data());
1044             return error;
1045         }
1046         else if (second_separator_char_pos + 1 == third_separator_char_pos)
1047         {
1048             error.SetErrorStringWithFormat("<subst> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'",
1049                                            separator_char,
1050                                            separator_char,
1051                                            separator_char,
1052                                            (int)regex_sed.size(),
1053                                            regex_sed.data());
1054             return error;
1055         }
1056         std::string regex(regex_sed.substr(first_separator_char_pos + 1, second_separator_char_pos - first_separator_char_pos - 1));
1057         std::string subst(regex_sed.substr(second_separator_char_pos + 1, third_separator_char_pos - second_separator_char_pos - 1));
1058         m_regex_cmd_ap->AddRegexCommand (regex.c_str(),
1059                                          subst.c_str());
1060         return error;
1061     }
1062
1063     void
1064     AddRegexCommandToInterpreter()
1065     {
1066         if (m_regex_cmd_ap.get())
1067         {
1068             if (m_regex_cmd_ap->HasRegexEntries())
1069             {
1070                 CommandObjectSP cmd_sp (m_regex_cmd_ap.release());
1071                 m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true);
1072             }
1073         }
1074     }
1075
1076     void
1077     InputReaderDidCancel()
1078     {
1079         m_regex_cmd_ap.reset();
1080     }
1081
1082     static size_t
1083     InputReaderCallback (void *baton,
1084                          InputReader &reader,
1085                          lldb::InputReaderAction notification,
1086                          const char *bytes,
1087                          size_t bytes_len)
1088     {
1089         CommandObjectCommandsAddRegex *add_regex_cmd = (CommandObjectCommandsAddRegex *) baton;
1090         bool batch_mode = reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode();
1091
1092         switch (notification)
1093         {
1094             case eInputReaderActivate:
1095                 if (!batch_mode)
1096                 {
1097                     StreamSP out_stream = reader.GetDebugger().GetAsyncOutputStream ();
1098                     out_stream->Printf("%s\n", "Enter regular expressions in the form 's/<regex>/<subst>/' and terminate with an empty line:");
1099                     out_stream->Flush();
1100                 }
1101                 break;
1102             case eInputReaderReactivate:
1103                 break;
1104
1105             case eInputReaderDeactivate:
1106                 break;
1107
1108             case eInputReaderAsynchronousOutputWritten:
1109                 break;
1110
1111             case eInputReaderGotToken:
1112                 while (bytes_len > 0 && (bytes[bytes_len-1] == '\r' || bytes[bytes_len-1] == '\n'))
1113                     --bytes_len;
1114                 if (bytes_len == 0)
1115                     reader.SetIsDone(true);
1116                 else if (bytes)
1117                 {
1118                     llvm::StringRef bytes_strref (bytes, bytes_len);
1119                     Error error (add_regex_cmd->AppendRegexSubstitution (bytes_strref));
1120                     if (error.Fail())
1121                     {
1122                         if (!batch_mode)
1123                         {
1124                             StreamSP out_stream = reader.GetDebugger().GetAsyncOutputStream();
1125                             out_stream->Printf("error: %s\n", error.AsCString());
1126                             out_stream->Flush();
1127                         }
1128                         add_regex_cmd->InputReaderDidCancel ();
1129                         reader.SetIsDone (true);
1130                     }
1131                 }
1132                 break;
1133
1134             case eInputReaderInterrupt:
1135                 {
1136                     reader.SetIsDone (true);
1137                     if (!batch_mode)
1138                     {
1139                         StreamSP out_stream = reader.GetDebugger().GetAsyncOutputStream();
1140                         out_stream->PutCString("Regular expression command creations was cancelled.\n");
1141                         out_stream->Flush();
1142                     }
1143                     add_regex_cmd->InputReaderDidCancel ();
1144                 }
1145                 break;
1146
1147             case eInputReaderEndOfFile:
1148                 reader.SetIsDone (true);
1149                 break;
1150
1151             case eInputReaderDone:
1152                 add_regex_cmd->AddRegexCommandToInterpreter();
1153                 break;
1154         }
1155
1156         return bytes_len;
1157     }
1158
1159 private:
1160     std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_ap;
1161
1162      class CommandOptions : public Options
1163      {
1164      public:
1165
1166          CommandOptions (CommandInterpreter &interpreter) :
1167             Options (interpreter)
1168          {
1169          }
1170
1171          virtual
1172          ~CommandOptions (){}
1173
1174          virtual Error
1175          SetOptionValue (uint32_t option_idx, const char *option_arg)
1176          {
1177              Error error;
1178              const int short_option = m_getopt_table[option_idx].val;
1179
1180              switch (short_option)
1181              {
1182                  case 'h':
1183                      m_help.assign (option_arg);
1184                      break;
1185                  case 's':
1186                      m_syntax.assign (option_arg);
1187                      break;
1188
1189                  default:
1190                      error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1191                      break;
1192              }
1193
1194              return error;
1195          }
1196
1197          void
1198          OptionParsingStarting ()
1199          {
1200              m_help.clear();
1201              m_syntax.clear();
1202          }
1203
1204          const OptionDefinition*
1205          GetDefinitions ()
1206          {
1207              return g_option_table;
1208          }
1209
1210          // Options table: Required for subclasses of Options.
1211
1212          static OptionDefinition g_option_table[];
1213
1214          const char *
1215          GetHelp ()
1216          {
1217              if (m_help.empty())
1218                  return NULL;
1219              return m_help.c_str();
1220          }
1221          const char *
1222          GetSyntax ()
1223          {
1224              if (m_syntax.empty())
1225                  return NULL;
1226              return m_syntax.c_str();
1227          }
1228          // Instance variables to hold the values for command options.
1229      protected:
1230          std::string m_help;
1231          std::string m_syntax;
1232      };
1233
1234      virtual Options *
1235      GetOptions ()
1236      {
1237          return &m_options;
1238      }
1239
1240      CommandOptions m_options;
1241 };
1242
1243 OptionDefinition
1244 CommandObjectCommandsAddRegex::CommandOptions::g_option_table[] =
1245 {
1246 { LLDB_OPT_SET_1, false, "help"  , 'h', required_argument, NULL, 0, eArgTypeNone, "The help text to display for this command."},
1247 { LLDB_OPT_SET_1, false, "syntax", 's', required_argument, NULL, 0, eArgTypeNone, "A syntax string showing the typical usage syntax."},
1248 { 0             , false,  NULL   , 0  , 0                , NULL, 0, eArgTypeNone, NULL }
1249 };
1250
1251
1252 class CommandObjectPythonFunction : public CommandObjectRaw
1253 {
1254 private:
1255     std::string m_function_name;
1256     ScriptedCommandSynchronicity m_synchro;
1257     bool m_fetched_help_long;
1258
1259 public:
1260
1261     CommandObjectPythonFunction (CommandInterpreter &interpreter,
1262                                  std::string name,
1263                                  std::string funct,
1264                                  ScriptedCommandSynchronicity synch) :
1265         CommandObjectRaw (interpreter,
1266                           name.c_str(),
1267                           (std::string("Run Python function ") + funct).c_str(),
1268                           NULL),
1269         m_function_name(funct),
1270         m_synchro(synch),
1271         m_fetched_help_long(false)
1272     {
1273     }
1274
1275     virtual
1276     ~CommandObjectPythonFunction ()
1277     {
1278     }
1279
1280     virtual bool
1281     IsRemovable () const
1282     {
1283         return true;
1284     }
1285
1286     const std::string&
1287     GetFunctionName ()
1288     {
1289         return m_function_name;
1290     }
1291
1292     ScriptedCommandSynchronicity
1293     GetSynchronicity ()
1294     {
1295         return m_synchro;
1296     }
1297
1298     virtual const char *
1299     GetHelpLong ()
1300     {
1301         if (!m_fetched_help_long)
1302         {
1303             ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
1304             if (scripter)
1305             {
1306                 std::string docstring;
1307                 m_fetched_help_long = scripter->GetDocumentationForItem(m_function_name.c_str(),docstring);
1308                 if (!docstring.empty())
1309                     SetHelpLong(docstring);
1310             }
1311         }
1312         return CommandObjectRaw::GetHelpLong();
1313     }
1314
1315 protected:
1316     virtual bool
1317     DoExecute (const char *raw_command_line, CommandReturnObject &result)
1318     {
1319         ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter();
1320
1321         Error error;
1322
1323         result.SetStatus(eReturnStatusInvalid);
1324
1325         if (!scripter || scripter->RunScriptBasedCommand(m_function_name.c_str(),
1326                                                          raw_command_line,
1327                                                          m_synchro,
1328                                                          result,
1329                                                          error) == false)
1330         {
1331             result.AppendError(error.AsCString());
1332             result.SetStatus(eReturnStatusFailed);
1333         }
1334         else
1335         {
1336             // Don't change the status if the command already set it...
1337             if (result.GetStatus() == eReturnStatusInvalid)
1338             {
1339                 if (result.GetOutputData() == NULL || result.GetOutputData()[0] == '\0')
1340                     result.SetStatus(eReturnStatusSuccessFinishNoResult);
1341                 else
1342                     result.SetStatus(eReturnStatusSuccessFinishResult);
1343             }
1344         }
1345
1346         return result.Succeeded();
1347     }
1348
1349 };
1350
1351 //-------------------------------------------------------------------------
1352 // CommandObjectCommandsScriptImport
1353 //-------------------------------------------------------------------------
1354
1355 class CommandObjectCommandsScriptImport : public CommandObjectParsed
1356 {
1357 public:
1358     CommandObjectCommandsScriptImport (CommandInterpreter &interpreter) :
1359         CommandObjectParsed (interpreter,
1360                              "command script import",
1361                              "Import a scripting module in LLDB.",
1362                              NULL),
1363         m_options(interpreter)
1364     {
1365         CommandArgumentEntry arg1;
1366         CommandArgumentData cmd_arg;
1367
1368         // Define the first (and only) variant of this arg.
1369         cmd_arg.arg_type = eArgTypeFilename;
1370         cmd_arg.arg_repetition = eArgRepeatPlain;
1371
1372         // There is only one variant this argument could be; put it into the argument entry.
1373         arg1.push_back (cmd_arg);
1374
1375         // Push the data for the first argument into the m_arguments vector.
1376         m_arguments.push_back (arg1);
1377     }
1378
1379     ~CommandObjectCommandsScriptImport ()
1380     {
1381     }
1382
1383     virtual int
1384     HandleArgumentCompletion (Args &input,
1385                               int &cursor_index,
1386                               int &cursor_char_position,
1387                               OptionElementVector &opt_element_vector,
1388                               int match_start_point,
1389                               int max_return_elements,
1390                               bool &word_complete,
1391                               StringList &matches)
1392     {
1393         std::string completion_str (input.GetArgumentAtIndex(cursor_index));
1394         completion_str.erase (cursor_char_position);
1395
1396         CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
1397                                                              CommandCompletions::eDiskFileCompletion,
1398                                                              completion_str.c_str(),
1399                                                              match_start_point,
1400                                                              max_return_elements,
1401                                                              NULL,
1402                                                              word_complete,
1403                                                              matches);
1404         return matches.GetSize();
1405     }
1406
1407     virtual Options *
1408     GetOptions ()
1409     {
1410         return &m_options;
1411     }
1412
1413 protected:
1414
1415     class CommandOptions : public Options
1416     {
1417     public:
1418
1419         CommandOptions (CommandInterpreter &interpreter) :
1420             Options (interpreter)
1421         {
1422         }
1423
1424         virtual
1425         ~CommandOptions (){}
1426
1427         virtual Error
1428         SetOptionValue (uint32_t option_idx, const char *option_arg)
1429         {
1430             Error error;
1431             const int short_option = m_getopt_table[option_idx].val;
1432
1433             switch (short_option)
1434             {
1435                 case 'r':
1436                     m_allow_reload = true;
1437                     break;
1438                 default:
1439                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1440                     break;
1441             }
1442
1443             return error;
1444         }
1445
1446         void
1447         OptionParsingStarting ()
1448         {
1449             m_allow_reload = true;
1450         }
1451
1452         const OptionDefinition*
1453         GetDefinitions ()
1454         {
1455             return g_option_table;
1456         }
1457
1458         // Options table: Required for subclasses of Options.
1459
1460         static OptionDefinition g_option_table[];
1461
1462         // Instance variables to hold the values for command options.
1463
1464         bool m_allow_reload;
1465     };
1466
1467     bool
1468     DoExecute (Args& command, CommandReturnObject &result)
1469     {
1470
1471         if (m_interpreter.GetDebugger().GetScriptLanguage() != lldb::eScriptLanguagePython)
1472         {
1473             result.AppendError ("only scripting language supported for module importing is currently Python");
1474             result.SetStatus (eReturnStatusFailed);
1475             return false;
1476         }
1477
1478         size_t argc = command.GetArgumentCount();
1479
1480         if (argc != 1)
1481         {
1482             result.AppendError ("'command script import' requires one argument");
1483             result.SetStatus (eReturnStatusFailed);
1484             return false;
1485         }
1486
1487         std::string path = command.GetArgumentAtIndex(0);
1488         Error error;
1489
1490         const bool init_session = true;
1491         // FIXME: this is necessary because CommandObject::CheckRequirements() assumes that
1492         // commands won't ever be recursively invoked, but it's actually possible to craft
1493         // a Python script that does other "command script imports" in __lldb_init_module
1494         // the real fix is to have recursive commands possible with a CommandInvocation object
1495         // separate from the CommandObject itself, so that recursive command invocations
1496         // won't stomp on each other (wrt to execution contents, options, and more)
1497         m_exe_ctx.Clear();
1498         if (m_interpreter.GetScriptInterpreter()->LoadScriptingModule(path.c_str(),
1499                                                                       m_options.m_allow_reload,
1500                                                                       init_session,
1501                                                                       error))
1502         {
1503             result.SetStatus (eReturnStatusSuccessFinishNoResult);
1504         }
1505         else
1506         {
1507             result.AppendErrorWithFormat("module importing failed: %s", error.AsCString());
1508             result.SetStatus (eReturnStatusFailed);
1509         }
1510
1511         return result.Succeeded();
1512     }
1513
1514     CommandOptions m_options;
1515 };
1516
1517 OptionDefinition
1518 CommandObjectCommandsScriptImport::CommandOptions::g_option_table[] =
1519 {
1520     { LLDB_OPT_SET_1, false, "allow-reload", 'r', no_argument, NULL, 0, eArgTypeNone,        "Allow the script to be loaded even if it was already loaded before. This argument exists for backwards compatibility, but reloading is always allowed, whether you specify it or not."},
1521     { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
1522 };
1523
1524
1525 //-------------------------------------------------------------------------
1526 // CommandObjectCommandsScriptAdd
1527 //-------------------------------------------------------------------------
1528
1529 class CommandObjectCommandsScriptAdd : public CommandObjectParsed
1530 {
1531 public:
1532     CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter) :
1533         CommandObjectParsed (interpreter,
1534                              "command script add",
1535                              "Add a scripted function as an LLDB command.",
1536                              NULL),
1537         m_options (interpreter)
1538     {
1539         CommandArgumentEntry arg1;
1540         CommandArgumentData cmd_arg;
1541
1542         // Define the first (and only) variant of this arg.
1543         cmd_arg.arg_type = eArgTypeCommandName;
1544         cmd_arg.arg_repetition = eArgRepeatPlain;
1545
1546         // There is only one variant this argument could be; put it into the argument entry.
1547         arg1.push_back (cmd_arg);
1548
1549         // Push the data for the first argument into the m_arguments vector.
1550         m_arguments.push_back (arg1);
1551     }
1552
1553     ~CommandObjectCommandsScriptAdd ()
1554     {
1555     }
1556
1557     virtual Options *
1558     GetOptions ()
1559     {
1560         return &m_options;
1561     }
1562
1563 protected:
1564
1565     class CommandOptions : public Options
1566     {
1567     public:
1568
1569         CommandOptions (CommandInterpreter &interpreter) :
1570         Options (interpreter)
1571         {
1572         }
1573
1574         virtual
1575         ~CommandOptions (){}
1576
1577         virtual Error
1578         SetOptionValue (uint32_t option_idx, const char *option_arg)
1579         {
1580             Error error;
1581             const int short_option = m_getopt_table[option_idx].val;
1582
1583             switch (short_option)
1584             {
1585                 case 'f':
1586                     m_funct_name = std::string(option_arg);
1587                     break;
1588                 case 's':
1589                     m_synchronous = (ScriptedCommandSynchronicity) Args::StringToOptionEnum(option_arg, g_option_table[option_idx].enum_values, 0, error);
1590                     if (!error.Success())
1591                         error.SetErrorStringWithFormat ("unrecognized value for synchronicity '%s'", option_arg);
1592                     break;
1593                 default:
1594                     error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
1595                     break;
1596             }
1597
1598             return error;
1599         }
1600
1601         void
1602         OptionParsingStarting ()
1603         {
1604             m_funct_name = "";
1605             m_synchronous = eScriptedCommandSynchronicitySynchronous;
1606         }
1607
1608         const OptionDefinition*
1609         GetDefinitions ()
1610         {
1611             return g_option_table;
1612         }
1613
1614         // Options table: Required for subclasses of Options.
1615
1616         static OptionDefinition g_option_table[];
1617
1618         // Instance variables to hold the values for command options.
1619
1620         std::string m_funct_name;
1621         ScriptedCommandSynchronicity m_synchronous;
1622     };
1623
1624 private:
1625     class PythonAliasReader : public InputReaderEZ
1626     {
1627     private:
1628         CommandInterpreter& m_interpreter;
1629         std::string m_cmd_name;
1630         ScriptedCommandSynchronicity m_synchronous;
1631         StringList m_user_input;
1632         DISALLOW_COPY_AND_ASSIGN (PythonAliasReader);
1633     public:
1634         PythonAliasReader(Debugger& debugger,
1635                           CommandInterpreter& interpreter,
1636                           std::string cmd_name,
1637                           ScriptedCommandSynchronicity synch) :
1638         InputReaderEZ(debugger),
1639         m_interpreter(interpreter),
1640         m_cmd_name(cmd_name),
1641         m_synchronous(synch),
1642         m_user_input()
1643         {}
1644
1645         virtual
1646         ~PythonAliasReader()
1647         {
1648         }
1649
1650         virtual void ActivateHandler(HandlerData& data)
1651         {
1652             StreamSP out_stream = data.GetOutStream();
1653             bool batch_mode = data.GetBatchMode();
1654             if (!batch_mode)
1655             {
1656                 out_stream->Printf ("%s\n", g_python_command_instructions);
1657                 if (data.reader.GetPrompt())
1658                     out_stream->Printf ("%s", data.reader.GetPrompt());
1659                 out_stream->Flush();
1660             }
1661         }
1662
1663         virtual void ReactivateHandler(HandlerData& data)
1664         {
1665             StreamSP out_stream = data.GetOutStream();
1666             bool batch_mode = data.GetBatchMode();
1667             if (data.reader.GetPrompt() && !batch_mode)
1668             {
1669                 out_stream->Printf ("%s", data.reader.GetPrompt());
1670                 out_stream->Flush();
1671             }
1672         }
1673         virtual void GotTokenHandler(HandlerData& data)
1674         {
1675             StreamSP out_stream = data.GetOutStream();
1676             bool batch_mode = data.GetBatchMode();
1677             if (data.bytes && data.bytes_len)
1678             {
1679                 m_user_input.AppendString(data.bytes, data.bytes_len);
1680             }
1681             if (!data.reader.IsDone() && data.reader.GetPrompt() && !batch_mode)
1682             {
1683                 out_stream->Printf ("%s", data.reader.GetPrompt());
1684                 out_stream->Flush();
1685             }
1686         }
1687         virtual void InterruptHandler(HandlerData& data)
1688         {
1689             StreamSP out_stream = data.GetOutStream();
1690             bool batch_mode = data.GetBatchMode();
1691             data.reader.SetIsDone (true);
1692             if (!batch_mode)
1693             {
1694                 out_stream->Printf ("Warning: No script attached.\n");
1695                 out_stream->Flush();
1696             }
1697         }
1698         virtual void EOFHandler(HandlerData& data)
1699         {
1700             data.reader.SetIsDone (true);
1701         }
1702         virtual void DoneHandler(HandlerData& data)
1703         {
1704             StreamSP out_stream = data.GetOutStream();
1705
1706             ScriptInterpreter *interpreter = data.reader.GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
1707             if (!interpreter)
1708             {
1709                 out_stream->Printf ("Script interpreter missing: no script attached.\n");
1710                 out_stream->Flush();
1711                 return;
1712             }
1713             std::string funct_name_str;
1714             if (!interpreter->GenerateScriptAliasFunction (m_user_input,
1715                                                            funct_name_str))
1716             {
1717                 out_stream->Printf ("Unable to create function: no script attached.\n");
1718                 out_stream->Flush();
1719                 return;
1720             }
1721             if (funct_name_str.empty())
1722             {
1723                 out_stream->Printf ("Unable to obtain a function name: no script attached.\n");
1724                 out_stream->Flush();
1725                 return;
1726             }
1727             // everything should be fine now, let's add this alias
1728
1729             CommandObjectSP command_obj_sp(new CommandObjectPythonFunction(m_interpreter,
1730                                                                            m_cmd_name,
1731                                                                            funct_name_str.c_str(),
1732                                                                            m_synchronous));
1733
1734             if (!m_interpreter.AddUserCommand(m_cmd_name, command_obj_sp, true))
1735             {
1736                 out_stream->Printf ("Unable to add selected command: no script attached.\n");
1737                 out_stream->Flush();
1738                 return;
1739             }
1740         }
1741     };
1742
1743 protected:
1744     bool
1745     DoExecute (Args& command, CommandReturnObject &result)
1746     {
1747
1748         if (m_interpreter.GetDebugger().GetScriptLanguage() != lldb::eScriptLanguagePython)
1749         {
1750             result.AppendError ("only scripting language supported for scripted commands is currently Python");
1751             result.SetStatus (eReturnStatusFailed);
1752             return false;
1753         }
1754
1755         size_t argc = command.GetArgumentCount();
1756
1757         if (argc != 1)
1758         {
1759             result.AppendError ("'command script add' requires one argument");
1760             result.SetStatus (eReturnStatusFailed);
1761             return false;
1762         }
1763
1764         std::string cmd_name = command.GetArgumentAtIndex(0);
1765
1766         if (m_options.m_funct_name.empty())
1767         {
1768             InputReaderSP reader_sp (new PythonAliasReader (m_interpreter.GetDebugger(),
1769                                                             m_interpreter,
1770                                                             cmd_name,
1771                                                             m_options.m_synchronous));
1772
1773             if (reader_sp)
1774             {
1775
1776                 InputReaderEZ::InitializationParameters ipr;
1777
1778                 Error err (reader_sp->Initialize (ipr.SetBaton(NULL).SetPrompt("     ")));
1779                 if (err.Success())
1780                 {
1781                     m_interpreter.GetDebugger().PushInputReader (reader_sp);
1782                     result.SetStatus (eReturnStatusSuccessFinishNoResult);
1783                 }
1784                 else
1785                 {
1786                     result.AppendError (err.AsCString());
1787                     result.SetStatus (eReturnStatusFailed);
1788                 }
1789             }
1790             else
1791             {
1792                 result.AppendError("out of memory");
1793                 result.SetStatus (eReturnStatusFailed);
1794             }
1795         }
1796         else
1797         {
1798             CommandObjectSP new_cmd(new CommandObjectPythonFunction(m_interpreter,
1799                                                                     cmd_name,
1800                                                                     m_options.m_funct_name,
1801                                                                     m_options.m_synchronous));
1802             if (m_interpreter.AddUserCommand(cmd_name, new_cmd, true))
1803             {
1804                 result.SetStatus (eReturnStatusSuccessFinishNoResult);
1805             }
1806             else
1807             {
1808                 result.AppendError("cannot add command");
1809                 result.SetStatus (eReturnStatusFailed);
1810             }
1811         }
1812
1813         return result.Succeeded();
1814
1815     }
1816
1817     CommandOptions m_options;
1818 };
1819
1820 static OptionEnumValueElement g_script_synchro_type[] =
1821 {
1822     { eScriptedCommandSynchronicitySynchronous,      "synchronous",       "Run synchronous"},
1823     { eScriptedCommandSynchronicityAsynchronous,     "asynchronous",      "Run asynchronous"},
1824     { eScriptedCommandSynchronicityCurrentValue,     "current",           "Do not alter current setting"},
1825     { 0, NULL, NULL }
1826 };
1827
1828 OptionDefinition
1829 CommandObjectCommandsScriptAdd::CommandOptions::g_option_table[] =
1830 {
1831     { LLDB_OPT_SET_1, false, "function", 'f', required_argument, NULL, 0, eArgTypePythonFunction,        "Name of the Python function to bind to this command name."},
1832     { LLDB_OPT_SET_1, false, "synchronicity", 's', required_argument, g_script_synchro_type, 0, eArgTypeScriptedCommandSynchronicity,        "Set the synchronicity of this command's executions with regard to LLDB event system."},
1833     { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
1834 };
1835
1836 //-------------------------------------------------------------------------
1837 // CommandObjectCommandsScriptList
1838 //-------------------------------------------------------------------------
1839
1840 class CommandObjectCommandsScriptList : public CommandObjectParsed
1841 {
1842 private:
1843
1844 public:
1845     CommandObjectCommandsScriptList(CommandInterpreter &interpreter) :
1846     CommandObjectParsed (interpreter,
1847                    "command script list",
1848                    "List defined scripted commands.",
1849                    NULL)
1850     {
1851     }
1852
1853     ~CommandObjectCommandsScriptList ()
1854     {
1855     }
1856
1857     bool
1858     DoExecute (Args& command, CommandReturnObject &result)
1859     {
1860
1861         m_interpreter.GetHelp(result,
1862                               CommandInterpreter::eCommandTypesUserDef);
1863
1864         result.SetStatus (eReturnStatusSuccessFinishResult);
1865
1866         return true;
1867
1868
1869     }
1870 };
1871
1872 //-------------------------------------------------------------------------
1873 // CommandObjectCommandsScriptClear
1874 //-------------------------------------------------------------------------
1875
1876 class CommandObjectCommandsScriptClear : public CommandObjectParsed
1877 {
1878 private:
1879
1880 public:
1881     CommandObjectCommandsScriptClear(CommandInterpreter &interpreter) :
1882         CommandObjectParsed (interpreter,
1883                              "command script clear",
1884                              "Delete all scripted commands.",
1885                              NULL)
1886     {
1887     }
1888
1889     ~CommandObjectCommandsScriptClear ()
1890     {
1891     }
1892
1893 protected:
1894     bool
1895     DoExecute (Args& command, CommandReturnObject &result)
1896     {
1897
1898         m_interpreter.RemoveAllUser();
1899
1900         result.SetStatus (eReturnStatusSuccessFinishResult);
1901
1902         return true;
1903     }
1904 };
1905
1906 //-------------------------------------------------------------------------
1907 // CommandObjectCommandsScriptDelete
1908 //-------------------------------------------------------------------------
1909
1910 class CommandObjectCommandsScriptDelete : public CommandObjectParsed
1911 {
1912 public:
1913     CommandObjectCommandsScriptDelete(CommandInterpreter &interpreter) :
1914         CommandObjectParsed (interpreter,
1915                              "command script delete",
1916                              "Delete a scripted command.",
1917                              NULL)
1918     {
1919         CommandArgumentEntry arg1;
1920         CommandArgumentData cmd_arg;
1921
1922         // Define the first (and only) variant of this arg.
1923         cmd_arg.arg_type = eArgTypeCommandName;
1924         cmd_arg.arg_repetition = eArgRepeatPlain;
1925
1926         // There is only one variant this argument could be; put it into the argument entry.
1927         arg1.push_back (cmd_arg);
1928
1929         // Push the data for the first argument into the m_arguments vector.
1930         m_arguments.push_back (arg1);
1931     }
1932
1933     ~CommandObjectCommandsScriptDelete ()
1934     {
1935     }
1936
1937 protected:
1938     bool
1939     DoExecute (Args& command, CommandReturnObject &result)
1940     {
1941
1942         size_t argc = command.GetArgumentCount();
1943
1944         if (argc != 1)
1945         {
1946             result.AppendError ("'command script delete' requires one argument");
1947             result.SetStatus (eReturnStatusFailed);
1948             return false;
1949         }
1950
1951         const char* cmd_name = command.GetArgumentAtIndex(0);
1952
1953         if (cmd_name && *cmd_name && m_interpreter.HasUserCommands() && m_interpreter.UserCommandExists(cmd_name))
1954         {
1955             m_interpreter.RemoveUser(cmd_name);
1956             result.SetStatus (eReturnStatusSuccessFinishResult);
1957         }
1958         else
1959         {
1960             result.AppendErrorWithFormat ("command %s not found", cmd_name);
1961             result.SetStatus (eReturnStatusFailed);
1962         }
1963
1964         return result.Succeeded();
1965
1966     }
1967 };
1968
1969 #pragma mark CommandObjectMultiwordCommandsScript
1970
1971 //-------------------------------------------------------------------------
1972 // CommandObjectMultiwordCommandsScript
1973 //-------------------------------------------------------------------------
1974
1975 class CommandObjectMultiwordCommandsScript : public CommandObjectMultiword
1976 {
1977 public:
1978     CommandObjectMultiwordCommandsScript (CommandInterpreter &interpreter) :
1979     CommandObjectMultiword (interpreter,
1980                             "command script",
1981                             "A set of commands for managing or customizing script commands.",
1982                             "command script <subcommand> [<subcommand-options>]")
1983     {
1984         LoadSubCommand ("add",  CommandObjectSP (new CommandObjectCommandsScriptAdd (interpreter)));
1985         LoadSubCommand ("delete",   CommandObjectSP (new CommandObjectCommandsScriptDelete (interpreter)));
1986         LoadSubCommand ("clear", CommandObjectSP (new CommandObjectCommandsScriptClear (interpreter)));
1987         LoadSubCommand ("list",   CommandObjectSP (new CommandObjectCommandsScriptList (interpreter)));
1988         LoadSubCommand ("import",   CommandObjectSP (new CommandObjectCommandsScriptImport (interpreter)));
1989     }
1990
1991     ~CommandObjectMultiwordCommandsScript ()
1992     {
1993     }
1994
1995 };
1996
1997
1998 #pragma mark CommandObjectMultiwordCommands
1999
2000 //-------------------------------------------------------------------------
2001 // CommandObjectMultiwordCommands
2002 //-------------------------------------------------------------------------
2003
2004 CommandObjectMultiwordCommands::CommandObjectMultiwordCommands (CommandInterpreter &interpreter) :
2005     CommandObjectMultiword (interpreter,
2006                             "command",
2007                             "A set of commands for managing or customizing the debugger commands.",
2008                             "command <subcommand> [<subcommand-options>]")
2009 {
2010     LoadSubCommand ("source",  CommandObjectSP (new CommandObjectCommandsSource (interpreter)));
2011     LoadSubCommand ("alias",   CommandObjectSP (new CommandObjectCommandsAlias (interpreter)));
2012     LoadSubCommand ("unalias", CommandObjectSP (new CommandObjectCommandsUnalias (interpreter)));
2013     LoadSubCommand ("regex",   CommandObjectSP (new CommandObjectCommandsAddRegex (interpreter)));
2014     LoadSubCommand ("history",   CommandObjectSP (new CommandObjectCommandsHistory (interpreter)));
2015     LoadSubCommand ("script",   CommandObjectSP (new CommandObjectMultiwordCommandsScript (interpreter)));
2016 }
2017
2018 CommandObjectMultiwordCommands::~CommandObjectMultiwordCommands ()
2019 {
2020 }
2021