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

   1 //===-- CommandObject.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 "lldb/Interpreter/CommandObject.h"
  13
  14 #include <string>
  15 #include <map>
  16
  17 #include <getopt.h>
  18 #include <stdlib.h>
  19 #include <ctype.h>
  20
  21 #include "lldb/Core/Address.h"
  22 #include "lldb/Core/ArchSpec.h"
  23 #include "lldb/Interpreter/Options.h"
  24
  25 // These are for the Sourcename completers.
  26 // FIXME: Make a separate file for the completers.
  27 #include "lldb/Host/FileSpec.h"
  28 #include "lldb/Core/FileSpecList.h"
  29 #include "lldb/Target/Process.h"
  30 #include "lldb/Target/Target.h"
  31
  32 #include "lldb/Interpreter/CommandInterpreter.h"
  33 #include "lldb/Interpreter/CommandReturnObject.h"
  34 #include "lldb/Interpreter/ScriptInterpreter.h"
  35 #include "lldb/Interpreter/ScriptInterpreterPython.h"
  36
  37 using namespace lldb;
  38 using namespace lldb_private;
  39
  40 //-------------------------------------------------------------------------
  41 // CommandObject
  42 //-------------------------------------------------------------------------
  43
  44 CommandObject::CommandObject
  45 (
  46     CommandInterpreter &interpreter,
  47     const char *name,
  48     const char *help,
  49     const char *syntax,
  50     uint32_t flags
  51 ) :
  52     m_interpreter (interpreter),
  53     m_cmd_name (name),
  54     m_cmd_help_short (),
  55     m_cmd_help_long (),
  56     m_cmd_syntax (),
  57     m_is_alias (false),
  58     m_flags (flags),
  59     m_arguments(),
  60     m_command_override_callback (NULL),
  61     m_command_override_baton (NULL)
  62 {
  63     if (help && help[0])
  64         m_cmd_help_short = help;
  65     if (syntax && syntax[0])
  66         m_cmd_syntax = syntax;
  67 }
  68
  69 CommandObject::~CommandObject ()
  70 {
  71 }
  72
  73 const char *
  74 CommandObject::GetHelp ()
  75 {
  76     return m_cmd_help_short.c_str();
  77 }
  78
  79 const char *
  80 CommandObject::GetHelpLong ()
  81 {
  82     return m_cmd_help_long.c_str();
  83 }
  84
  85 const char *
  86 CommandObject::GetSyntax ()
  87 {
  88     if (m_cmd_syntax.length() == 0)
  89     {
  90         StreamString syntax_str;
  91         syntax_str.Printf ("%s", GetCommandName());
  92         if (GetOptions() != NULL)
  93             syntax_str.Printf (" <cmd-options>");
  94         if (m_arguments.size() > 0)
  95         {
  96             syntax_str.Printf (" ");
  97             if (WantsRawCommandString() && GetOptions() && GetOptions()->NumCommandOptions())
  98                 syntax_str.Printf("-- ");
  99             GetFormattedCommandArguments (syntax_str);
 100         }
 101         m_cmd_syntax = syntax_str.GetData ();
 102     }
 103
 104     return m_cmd_syntax.c_str();
 105 }
 106
 107 const char *
 108 CommandObject::GetCommandName ()
 109 {
 110     return m_cmd_name.c_str();
 111 }
 112
 113 void
 114 CommandObject::SetCommandName (const char *name)
 115 {
 116     m_cmd_name = name;
 117 }
 118
 119 void
 120 CommandObject::SetHelp (const char *cstr)
 121 {
 122     m_cmd_help_short = cstr;
 123 }
 124
 125 void
 126 CommandObject::SetHelpLong (const char *cstr)
 127 {
 128     m_cmd_help_long = cstr;
 129 }
 130
 131 void
 132 CommandObject::SetHelpLong (std::string str)
 133 {
 134     m_cmd_help_long = str;
 135 }
 136
 137 void
 138 CommandObject::SetSyntax (const char *cstr)
 139 {
 140     m_cmd_syntax = cstr;
 141 }
 142
 143 Options *
 144 CommandObject::GetOptions ()
 145 {
 146     // By default commands don't have options unless this virtual function
 147     // is overridden by base classes.
 148     return NULL;
 149 }
 150
 151 bool
 152 CommandObject::ParseOptions
 153 (
 154     Args& args,
 155     CommandReturnObject &result
 156 )
 157 {
 158     // See if the subclass has options?
 159     Options *options = GetOptions();
 160     if (options != NULL)
 161     {
 162         Error error;
 163         options->NotifyOptionParsingStarting();
 164
 165         // ParseOptions calls getopt_long_only, which always skips the zero'th item in the array and starts at position 1,
 166         // so we need to push a dummy value into position zero.
 167         args.Unshift("dummy_string");
 168         error = args.ParseOptions (*options);
 169
 170         // The "dummy_string" will have already been removed by ParseOptions,
 171         // so no need to remove it.
 172
 173         if (error.Success())
 174             error = options->NotifyOptionParsingFinished();
 175
 176         if (error.Success())
 177         {
 178             if (options->VerifyOptions (result))
 179                 return true;
 180         }
 181         else
 182         {
 183             const char *error_cstr = error.AsCString();
 184             if (error_cstr)
 185             {
 186                 // We got an error string, lets use that
 187                 result.AppendError(error_cstr);
 188             }
 189             else
 190             {
 191                 // No error string, output the usage information into result
 192                 options->GenerateOptionUsage (result.GetErrorStream(), this);
 193             }
 194         }
 195         result.SetStatus (eReturnStatusFailed);
 196         return false;
 197     }
 198     return true;
 199 }
 200
 201
 202
 203 bool
 204 CommandObject::CheckRequirements (CommandReturnObject &result)
 205 {
 206 #ifdef LLDB_CONFIGURATION_DEBUG
 207     // Nothing should be stored in m_exe_ctx between running commands as m_exe_ctx
 208     // has shared pointers to the target, process, thread and frame and we don't
 209     // want any CommandObject instances to keep any of these objects around
 210     // longer than for a single command. Every command should call
 211     // CommandObject::Cleanup() after it has completed
 212     assert (m_exe_ctx.GetTargetPtr() == NULL);
 213     assert (m_exe_ctx.GetProcessPtr() == NULL);
 214     assert (m_exe_ctx.GetThreadPtr() == NULL);
 215     assert (m_exe_ctx.GetFramePtr() == NULL);
 216 #endif
 217
 218     // Lock down the interpreter's execution context prior to running the
 219     // command so we guarantee the selected target, process, thread and frame
 220     // can't go away during the execution
 221     m_exe_ctx = m_interpreter.GetExecutionContext();
 222
 223     const uint32_t flags = GetFlags().Get();
 224     if (flags & (eFlagRequiresTarget   |
 225                  eFlagRequiresProcess  |
 226                  eFlagRequiresThread   |
 227                  eFlagRequiresFrame    |
 228                  eFlagTryTargetAPILock ))
 229     {
 230
 231         if ((flags & eFlagRequiresTarget) && !m_exe_ctx.HasTargetScope())
 232         {
 233             result.AppendError (GetInvalidTargetDescription());
 234             return false;
 235         }
 236
 237         if ((flags & eFlagRequiresProcess) && !m_exe_ctx.HasProcessScope())
 238         {
 239             result.AppendError (GetInvalidProcessDescription());
 240             return false;
 241         }
 242
 243         if ((flags & eFlagRequiresThread) && !m_exe_ctx.HasThreadScope())
 244         {
 245             result.AppendError (GetInvalidThreadDescription());
 246             return false;
 247         }
 248
 249         if ((flags & eFlagRequiresFrame) && !m_exe_ctx.HasFrameScope())
 250         {
 251             result.AppendError (GetInvalidFrameDescription());
 252             return false;
 253         }
 254
 255         if ((flags & eFlagRequiresRegContext) && (m_exe_ctx.GetRegisterContext() == NULL))
 256         {
 257             result.AppendError (GetInvalidRegContextDescription());
 258             return false;
 259         }
 260
 261         if (flags & eFlagTryTargetAPILock)
 262         {
 263             Target *target = m_exe_ctx.GetTargetPtr();
 264             if (target)
 265             {
 266                 if (m_api_locker.TryLock (target->GetAPIMutex(), NULL) == false)
 267                 {
 268                     result.AppendError ("failed to get API lock");
 269                     return false;
 270                 }
 271             }
 272         }
 273     }
 274
 275     if (GetFlags().AnySet (CommandObject::eFlagProcessMustBeLaunched | CommandObject::eFlagProcessMustBePaused))
 276     {
 277         Process *process = m_interpreter.GetExecutionContext().GetProcessPtr();
 278         if (process == NULL)
 279         {
 280             // A process that is not running is considered paused.
 281             if (GetFlags().Test(CommandObject::eFlagProcessMustBeLaunched))
 282             {
 283                 result.AppendError ("Process must exist.");
 284                 result.SetStatus (eReturnStatusFailed);
 285                 return false;
 286             }
 287         }
 288         else
 289         {
 290             StateType state = process->GetState();
 291             switch (state)
 292             {
 293             case eStateInvalid:
 294             case eStateSuspended:
 295             case eStateCrashed:
 296             case eStateStopped:
 297                 break;
 298
 299             case eStateConnected:
 300             case eStateAttaching:
 301             case eStateLaunching:
 302             case eStateDetached:
 303             case eStateExited:
 304             case eStateUnloaded:
 305                 if (GetFlags().Test(CommandObject::eFlagProcessMustBeLaunched))
 306                 {
 307                     result.AppendError ("Process must be launched.");
 308                     result.SetStatus (eReturnStatusFailed);
 309                     return false;
 310                 }
 311                 break;
 312
 313             case eStateRunning:
 314             case eStateStepping:
 315                 if (GetFlags().Test(CommandObject::eFlagProcessMustBePaused))
 316                 {
 317                     result.AppendError ("Process is running.  Use 'process interrupt' to pause execution.");
 318                     result.SetStatus (eReturnStatusFailed);
 319                     return false;
 320                 }
 321             }
 322         }
 323     }
 324     return true;
 325 }
 326
 327 void
 328 CommandObject::Cleanup ()
 329 {
 330     m_exe_ctx.Clear();
 331     m_api_locker.Unlock();
 332 }
 333
 334
 335 class CommandDictCommandPartialMatch
 336 {
 337     public:
 338         CommandDictCommandPartialMatch (const char *match_str)
 339         {
 340             m_match_str = match_str;
 341         }
 342         bool operator() (const std::pair<std::string, lldb::CommandObjectSP> map_element) const
 343         {
 344             // A NULL or empty string matches everything.
 345             if (m_match_str == NULL || *m_match_str == '\0')
 346                 return true;
 347
 348             return map_element.first.find (m_match_str, 0) == 0;
 349         }
 350
 351     private:
 352         const char *m_match_str;
 353 };
 354
 355 int
 356 CommandObject::AddNamesMatchingPartialString (CommandObject::CommandMap &in_map, const char *cmd_str,
 357                                               StringList &matches)
 358 {
 359     int number_added = 0;
 360     CommandDictCommandPartialMatch matcher(cmd_str);
 361
 362     CommandObject::CommandMap::iterator matching_cmds = std::find_if (in_map.begin(), in_map.end(), matcher);
 363
 364     while (matching_cmds != in_map.end())
 365     {
 366         ++number_added;
 367         matches.AppendString((*matching_cmds).first.c_str());
 368         matching_cmds = std::find_if (++matching_cmds, in_map.end(), matcher);;
 369     }
 370     return number_added;
 371 }
 372
 373 int
 374 CommandObject::HandleCompletion
 375 (
 376     Args &input,
 377     int &cursor_index,
 378     int &cursor_char_position,
 379     int match_start_point,
 380     int max_return_elements,
 381     bool &word_complete,
 382     StringList &matches
 383 )
 384 {
 385     // Default implmentation of WantsCompletion() is !WantsRawCommandString().
 386     // Subclasses who want raw command string but desire, for example,
 387     // argument completion should override WantsCompletion() to return true,
 388     // instead.
 389     if (WantsRawCommandString() && !WantsCompletion())
 390     {
 391         // FIXME: Abstract telling the completion to insert the completion character.
 392         matches.Clear();
 393         return -1;
 394     }
 395     else
 396     {
 397         // Can we do anything generic with the options?
 398         Options *cur_options = GetOptions();
 399         CommandReturnObject result;
 400         OptionElementVector opt_element_vector;
 401
 402         if (cur_options != NULL)
 403         {
 404             // Re-insert the dummy command name string which will have been
 405             // stripped off:
 406             input.Unshift ("dummy-string");
 407             cursor_index++;
 408
 409
 410             // I stick an element on the end of the input, because if the last element is
 411             // option that requires an argument, getopt_long_only will freak out.
 412
 413             input.AppendArgument ("<FAKE-VALUE>");
 414
 415             input.ParseArgsForCompletion (*cur_options, opt_element_vector, cursor_index);
 416
 417             input.DeleteArgumentAtIndex(input.GetArgumentCount() - 1);
 418
 419             bool handled_by_options;
 420             handled_by_options = cur_options->HandleOptionCompletion (input,
 421                                                                       opt_element_vector,
 422                                                                       cursor_index,
 423                                                                       cursor_char_position,
 424                                                                       match_start_point,
 425                                                                       max_return_elements,
 426                                                                       word_complete,
 427                                                                       matches);
 428             if (handled_by_options)
 429                 return matches.GetSize();
 430         }
 431
 432         // If we got here, the last word is not an option or an option argument.
 433         return HandleArgumentCompletion (input,
 434                                          cursor_index,
 435                                          cursor_char_position,
 436                                          opt_element_vector,
 437                                          match_start_point,
 438                                          max_return_elements,
 439                                          word_complete,
 440                                          matches);
 441     }
 442 }
 443
 444 bool
 445 CommandObject::HelpTextContainsWord (const char *search_word)
 446 {
 447     std::string options_usage_help;
 448
 449     bool found_word = false;
 450
 451     const char *short_help = GetHelp();
 452     const char *long_help = GetHelpLong();
 453     const char *syntax_help = GetSyntax();
 454
 455     if (short_help && strcasestr (short_help, search_word))
 456         found_word = true;
 457     else if (long_help && strcasestr (long_help, search_word))
 458         found_word = true;
 459     else if (syntax_help && strcasestr (syntax_help, search_word))
 460         found_word = true;
 461
 462     if (!found_word
 463         && GetOptions() != NULL)
 464     {
 465         StreamString usage_help;
 466         GetOptions()->GenerateOptionUsage (usage_help, this);
 467         if (usage_help.GetSize() > 0)
 468         {
 469             const char *usage_text = usage_help.GetData();
 470             if (strcasestr (usage_text, search_word))
 471               found_word = true;
 472         }
 473     }
 474
 475     return found_word;
 476 }
 477
 478 int
 479 CommandObject::GetNumArgumentEntries  ()
 480 {
 481     return m_arguments.size();
 482 }
 483
 484 CommandObject::CommandArgumentEntry *
 485 CommandObject::GetArgumentEntryAtIndex (int idx)
 486 {
 487     if (idx < m_arguments.size())
 488         return &(m_arguments[idx]);
 489
 490     return NULL;
 491 }
 492
 493 CommandObject::ArgumentTableEntry *
 494 CommandObject::FindArgumentDataByType (CommandArgumentType arg_type)
 495 {
 496     const ArgumentTableEntry *table = CommandObject::GetArgumentTable();
 497
 498     for (int i = 0; i < eArgTypeLastArg; ++i)
 499         if (table[i].arg_type == arg_type)
 500             return (ArgumentTableEntry *) &(table[i]);
 501
 502     return NULL;
 503 }
 504
 505 void
 506 CommandObject::GetArgumentHelp (Stream &str, CommandArgumentType arg_type, CommandInterpreter &interpreter)
 507 {
 508     const ArgumentTableEntry* table = CommandObject::GetArgumentTable();
 509     ArgumentTableEntry *entry = (ArgumentTableEntry *) &(table[arg_type]);
 510
 511     // The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up...
 512
 513     if (entry->arg_type != arg_type)
 514         entry = CommandObject::FindArgumentDataByType (arg_type);
 515
 516     if (!entry)
 517         return;
 518
 519     StreamString name_str;
 520     name_str.Printf ("<%s>", entry->arg_name);
 521
 522     if (entry->help_function)
 523     {
 524         const char* help_text = entry->help_function();
 525         if (!entry->help_function.self_formatting)
 526         {
 527             interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", help_text,
 528                                                  name_str.GetSize());
 529         }
 530         else
 531         {
 532             interpreter.OutputHelpText(str, name_str.GetData(), "--", help_text,
 533                                        name_str.GetSize());
 534         }
 535     }
 536     else
 537         interpreter.OutputFormattedHelpText (str, name_str.GetData(), "--", entry->help_text, name_str.GetSize());
 538 }
 539
 540 const char *
 541 CommandObject::GetArgumentName (CommandArgumentType arg_type)
 542 {
 543     ArgumentTableEntry *entry = (ArgumentTableEntry *) &(CommandObject::GetArgumentTable()[arg_type]);
 544
 545     // The table is *supposed* to be kept in arg_type order, but someone *could* have messed it up...
 546
 547     if (entry->arg_type != arg_type)
 548         entry = CommandObject::FindArgumentDataByType (arg_type);
 549
 550     if (entry)
 551         return entry->arg_name;
 552
 553     StreamString str;
 554     str << "Arg name for type (" << arg_type << ") not in arg table!";
 555     return str.GetData();
 556 }
 557
 558 bool
 559 CommandObject::IsPairType (ArgumentRepetitionType arg_repeat_type)
 560 {
 561     if ((arg_repeat_type == eArgRepeatPairPlain)
 562         ||  (arg_repeat_type == eArgRepeatPairOptional)
 563         ||  (arg_repeat_type == eArgRepeatPairPlus)
 564         ||  (arg_repeat_type == eArgRepeatPairStar)
 565         ||  (arg_repeat_type == eArgRepeatPairRange)
 566         ||  (arg_repeat_type == eArgRepeatPairRangeOptional))
 567         return true;
 568
 569     return false;
 570 }
 571
 572 static CommandObject::CommandArgumentEntry
 573 OptSetFiltered(uint32_t opt_set_mask, CommandObject::CommandArgumentEntry &cmd_arg_entry)
 574 {
 575     CommandObject::CommandArgumentEntry ret_val;
 576     for (unsigned i = 0; i < cmd_arg_entry.size(); ++i)
 577         if (opt_set_mask & cmd_arg_entry[i].arg_opt_set_association)
 578             ret_val.push_back(cmd_arg_entry[i]);
 579     return ret_val;
 580 }
 581
 582 // Default parameter value of opt_set_mask is LLDB_OPT_SET_ALL, which means take
 583 // all the argument data into account.  On rare cases where some argument sticks
 584 // with certain option sets, this function returns the option set filtered args.
 585 void
 586 CommandObject::GetFormattedCommandArguments (Stream &str, uint32_t opt_set_mask)
 587 {
 588     int num_args = m_arguments.size();
 589     for (int i = 0; i < num_args; ++i)
 590     {
 591         if (i > 0)
 592             str.Printf (" ");
 593         CommandArgumentEntry arg_entry =
 594             opt_set_mask == LLDB_OPT_SET_ALL ? m_arguments[i]
 595                                              : OptSetFiltered(opt_set_mask, m_arguments[i]);
 596         int num_alternatives = arg_entry.size();
 597
 598         if ((num_alternatives == 2)
 599             && IsPairType (arg_entry[0].arg_repetition))
 600         {
 601             const char *first_name = GetArgumentName (arg_entry[0].arg_type);
 602             const char *second_name = GetArgumentName (arg_entry[1].arg_type);
 603             switch (arg_entry[0].arg_repetition)
 604             {
 605                 case eArgRepeatPairPlain:
 606                     str.Printf ("<%s> <%s>", first_name, second_name);
 607                     break;
 608                 case eArgRepeatPairOptional:
 609                     str.Printf ("[<%s> <%s>]", first_name, second_name);
 610                     break;
 611                 case eArgRepeatPairPlus:
 612                     str.Printf ("<%s> <%s> [<%s> <%s> [...]]", first_name, second_name, first_name, second_name);
 613                     break;
 614                 case eArgRepeatPairStar:
 615                     str.Printf ("[<%s> <%s> [<%s> <%s> [...]]]", first_name, second_name, first_name, second_name);
 616                     break;
 617                 case eArgRepeatPairRange:
 618                     str.Printf ("<%s_1> <%s_1> ... <%s_n> <%s_n>", first_name, second_name, first_name, second_name);
 619                     break;
 620                 case eArgRepeatPairRangeOptional:
 621                     str.Printf ("[<%s_1> <%s_1> ... <%s_n> <%s_n>]", first_name, second_name, first_name, second_name);
 622                     break;
 623                 // Explicitly test for all the rest of the cases, so if new types get added we will notice the
 624                 // missing case statement(s).
 625                 case eArgRepeatPlain:
 626                 case eArgRepeatOptional:
 627                 case eArgRepeatPlus:
 628                 case eArgRepeatStar:
 629                 case eArgRepeatRange:
 630                     // These should not be reached, as they should fail the IsPairType test above.
 631                     break;
 632             }
 633         }
 634         else
 635         {
 636             StreamString names;
 637             for (int j = 0; j < num_alternatives; ++j)
 638             {
 639                 if (j > 0)
 640                     names.Printf (" | ");
 641                 names.Printf ("%s", GetArgumentName (arg_entry[j].arg_type));
 642             }
 643             switch (arg_entry[0].arg_repetition)
 644             {
 645                 case eArgRepeatPlain:
 646                     str.Printf ("<%s>", names.GetData());
 647                     break;
 648                 case eArgRepeatPlus:
 649                     str.Printf ("<%s> [<%s> [...]]", names.GetData(), names.GetData());
 650                     break;
 651                 case eArgRepeatStar:
 652                     str.Printf ("[<%s> [<%s> [...]]]", names.GetData(), names.GetData());
 653                     break;
 654                 case eArgRepeatOptional:
 655                     str.Printf ("[<%s>]", names.GetData());
 656                     break;
 657                 case eArgRepeatRange:
 658                     str.Printf ("<%s_1> .. <%s_n>", names.GetData(), names.GetData());
 659                     break;
 660                 // Explicitly test for all the rest of the cases, so if new types get added we will notice the
 661                 // missing case statement(s).
 662                 case eArgRepeatPairPlain:
 663                 case eArgRepeatPairOptional:
 664                 case eArgRepeatPairPlus:
 665                 case eArgRepeatPairStar:
 666                 case eArgRepeatPairRange:
 667                 case eArgRepeatPairRangeOptional:
 668                     // These should not be hit, as they should pass the IsPairType test above, and control should
 669                     // have gone into the other branch of the if statement.
 670                     break;
 671             }
 672         }
 673     }
 674 }
 675
 676 CommandArgumentType
 677 CommandObject::LookupArgumentName (const char *arg_name)
 678 {
 679     CommandArgumentType return_type = eArgTypeLastArg;
 680
 681     std::string arg_name_str (arg_name);
 682     size_t len = arg_name_str.length();
 683     if (arg_name[0] == '<'
 684         && arg_name[len-1] == '>')
 685         arg_name_str = arg_name_str.substr (1, len-2);
 686
 687     const ArgumentTableEntry *table = GetArgumentTable();
 688     for (int i = 0; i < eArgTypeLastArg; ++i)
 689         if (arg_name_str.compare (table[i].arg_name) == 0)
 690             return_type = g_arguments_data[i].arg_type;
 691
 692     return return_type;
 693 }
 694
 695 static const char *
 696 RegisterNameHelpTextCallback ()
 697 {
 698     return "Register names can be specified using the architecture specific names.  "
 699     "They can also be specified using generic names.  Not all generic entities have "
 700     "registers backing them on all architectures.  When they don't the generic name "
 701     "will return an error.\n"
 702     "The generic names defined in lldb are:\n"
 703     "\n"
 704     "pc       - program counter register\n"
 705     "ra       - return address register\n"
 706     "fp       - frame pointer register\n"
 707     "sp       - stack pointer register\n"
 708     "flags    - the flags register\n"
 709     "arg{1-6} - integer argument passing registers.\n";
 710 }
 711
 712 static const char *
 713 BreakpointIDHelpTextCallback ()
 714 {
 715     return "Breakpoint ID's consist major and minor numbers;  the major number "
 716     "corresponds to the single entity that was created with a 'breakpoint set' "
 717     "command; the minor numbers correspond to all the locations that were actually "
 718     "found/set based on the major breakpoint.  A full breakpoint ID might look like "
 719     "3.14, meaning the 14th location set for the 3rd breakpoint.  You can specify "
 720     "all the locations of a breakpoint by just indicating the major breakpoint "
 721     "number. A valid breakpoint id consists either of just the major id number, "
 722     "or the major number, a dot, and the location number (e.g. 3 or 3.2 could "
 723     "both be valid breakpoint ids).";
 724 }
 725
 726 static const char *
 727 BreakpointIDRangeHelpTextCallback ()
 728 {
 729     return "A 'breakpoint id list' is a manner of specifying multiple breakpoints. "
 730     "This can be done  through several mechanisms.  The easiest way is to just "
 731     "enter a space-separated list of breakpoint ids.  To specify all the "
 732     "breakpoint locations under a major breakpoint, you can use the major "
 733     "breakpoint number followed by '.*', eg. '5.*' means all the locations under "
 734     "breakpoint 5.  You can also indicate a range of breakpoints by using "
 735     "<start-bp-id> - <end-bp-id>.  The start-bp-id and end-bp-id for a range can "
 736     "be any valid breakpoint ids.  It is not legal, however, to specify a range "
 737     "using specific locations that cross major breakpoint numbers.  I.e. 3.2 - 3.7"
 738     " is legal; 2 - 5 is legal; but 3.2 - 4.4 is not legal.";
 739 }
 740
 741 static const char *
 742 GDBFormatHelpTextCallback ()
 743 {
 744     return "A GDB format consists of a repeat count, a format letter and a size letter. "
 745     "The repeat count is optional and defaults to 1. The format letter is optional "
 746     "and defaults to the previous format that was used. The size letter is optional "
 747     "and defaults to the previous size that was used.\n"
 748     "\n"
 749     "Format letters include:\n"
 750     "o - octal\n"
 751     "x - hexadecimal\n"
 752     "d - decimal\n"
 753     "u - unsigned decimal\n"
 754     "t - binary\n"
 755     "f - float\n"
 756     "a - address\n"
 757     "i - instruction\n"
 758     "c - char\n"
 759     "s - string\n"
 760     "T - OSType\n"
 761     "A - float as hex\n"
 762     "\n"
 763     "Size letters include:\n"
 764     "b - 1 byte  (byte)\n"
 765     "h - 2 bytes (halfword)\n"
 766     "w - 4 bytes (word)\n"
 767     "g - 8 bytes (giant)\n"
 768     "\n"
 769     "Example formats:\n"
 770     "32xb - show 32 1 byte hexadecimal integer values\n"
 771     "16xh - show 16 2 byte hexadecimal integer values\n"
 772     "64   - show 64 2 byte hexadecimal integer values (format and size from the last format)\n"
 773     "dw   - show 1 4 byte decimal integer value\n"
 774     ;
 775 }
 776
 777 static const char *
 778 FormatHelpTextCallback ()
 779 {
 780
 781     static char* help_text_ptr = NULL;
 782
 783     if (help_text_ptr)
 784         return help_text_ptr;
 785
 786     StreamString sstr;
 787     sstr << "One of the format names (or one-character names) that can be used to show a variable's value:\n";
 788     for (Format f = eFormatDefault; f < kNumFormats; f = Format(f+1))
 789     {
 790         if (f != eFormatDefault)
 791             sstr.PutChar('\n');
 792
 793         char format_char = FormatManager::GetFormatAsFormatChar(f);
 794         if (format_char)
 795             sstr.Printf("'%c' or ", format_char);
 796
 797         sstr.Printf ("\"%s\"", FormatManager::GetFormatAsCString(f));
 798     }
 799
 800     sstr.Flush();
 801
 802     std::string data = sstr.GetString();
 803
 804     help_text_ptr = new char[data.length()+1];
 805
 806     data.copy(help_text_ptr, data.length());
 807
 808     return help_text_ptr;
 809 }
 810
 811 static const char *
 812 LanguageTypeHelpTextCallback ()
 813 {
 814     static char* help_text_ptr = NULL;
 815
 816     if (help_text_ptr)
 817         return help_text_ptr;
 818
 819     StreamString sstr;
 820     sstr << "One of the following languages:\n";
 821
 822     for (unsigned int l = eLanguageTypeUnknown; l < eNumLanguageTypes; ++l)
 823     {
 824         sstr << "  " << LanguageRuntime::GetNameForLanguageType(static_cast<LanguageType>(l)) << "\n";
 825     }
 826
 827     sstr.Flush();
 828
 829     std::string data = sstr.GetString();
 830
 831     help_text_ptr = new char[data.length()+1];
 832
 833     data.copy(help_text_ptr, data.length());
 834
 835     return help_text_ptr;
 836 }
 837
 838 static const char *
 839 SummaryStringHelpTextCallback()
 840 {
 841     return
 842         "A summary string is a way to extract information from variables in order to present them using a summary.\n"
 843         "Summary strings contain static text, variables, scopes and control sequences:\n"
 844         "  - Static text can be any sequence of non-special characters, i.e. anything but '{', '}', '$', or '\\'.\n"
 845         "  - Variables are sequences of characters beginning with ${, ending with } and that contain symbols in the format described below.\n"
 846         "  - Scopes are any sequence of text between { and }. Anything included in a scope will only appear in the output summary if there were no errors.\n"
 847         "  - Control sequences are the usual C/C++ '\\a', '\\n', ..., plus '\\$', '\\{' and '\\}'.\n"
 848         "A summary string works by copying static text verbatim, turning control sequences into their character counterpart, expanding variables and trying to expand scopes.\n"
 849         "A variable is expanded by giving it a value other than its textual representation, and the way this is done depends on what comes after the ${ marker.\n"
 850         "The most common sequence if ${var followed by an expression path, which is the text one would type to access a member of an aggregate types, given a variable of that type"
 851         " (e.g. if type T has a member named x, which has a member named y, and if t is of type T, the expression path would be .x.y and the way to fit that into a summary string would be"
 852         " ${var.x.y}). You can also use ${*var followed by an expression path and in that case the object referred by the path will be dereferenced before being displayed."
 853         " If the object is not a pointer, doing so will cause an error. For additional details on expression paths, you can type 'help expr-path'. \n"
 854         "By default, summary strings attempt to display the summary for any variable they reference, and if that fails the value. If neither can be shown, nothing is displayed."
 855         "In a summary string, you can also use an array index [n], or a slice-like range [n-m]. This can have two different meanings depending on what kind of object the expression"
 856         " path refers to:\n"
 857         "  - if it is a scalar type (any basic type like int, float, ...) the expression is a bitfield, i.e. the bits indicated by the indexing operator are extracted out of the number"
 858         " and displayed as an individual variable\n"
 859         "  - if it is an array or pointer the array items indicated by the indexing operator are shown as the result of the variable. if the expression is an array, real array items are"
 860         " printed; if it is a pointer, the pointer-as-array syntax is used to obtain the values (this means, the latter case can have no range checking)\n"
 861         "If you are trying to display an array for which the size is known, you can also use [] instead of giving an exact range. This has the effect of showing items 0 thru size - 1.\n"
 862         "Additionally, a variable can contain an (optional) format code, as in ${var.x.y%code}, where code can be any of the valid formats described in 'help format', or one of the"
 863         " special symbols only allowed as part of a variable:\n"
 864         "    %V: show the value of the object by default\n"
 865         "    %S: show the summary of the object by default\n"
 866         "    %@: show the runtime-provided object description (for Objective-C, it calls NSPrintForDebugger; for C/C++ it does nothing)\n"
 867         "    %L: show the location of the object (memory address or a register name)\n"
 868         "    %#: show the number of children of the object\n"
 869         "    %T: show the type of the object\n"
 870         "Another variable that you can use in summary strings is ${svar . This sequence works exactly like ${var, including the fact that ${*svar is an allowed sequence, but uses"
 871         " the object's synthetic children provider instead of the actual objects. For instance, if you are using STL synthetic children providers, the following summary string would"
 872         " count the number of actual elements stored in an std::list:\n"
 873         "type summary add -s \"${svar%#}\" -x \"std::list<\"";
 874 }
 875
 876 static const char *
 877 ExprPathHelpTextCallback()
 878 {
 879     return
 880     "An expression path is the sequence of symbols that is used in C/C++ to access a member variable of an aggregate object (class).\n"
 881     "For instance, given a class:\n"
 882     "  class foo {\n"
 883     "      int a;\n"
 884     "      int b; .\n"
 885     "      foo* next;\n"
 886     "  };\n"
 887     "the expression to read item b in the item pointed to by next for foo aFoo would be aFoo.next->b.\n"
 888     "Given that aFoo could just be any object of type foo, the string '.next->b' is the expression path, because it can be attached to any foo instance to achieve the effect.\n"
 889     "Expression paths in LLDB include dot (.) and arrow (->) operators, and most commands using expression paths have ways to also accept the star (*) operator.\n"
 890     "The meaning of these operators is the same as the usual one given to them by the C/C++ standards.\n"
 891     "LLDB also has support for indexing ([ ]) in expression paths, and extends the traditional meaning of the square brackets operator to allow bitfield extraction:\n"
 892     "for objects of native types (int, float, char, ...) saying '[n-m]' as an expression path (where n and m are any positive integers, e.g. [3-5]) causes LLDB to extract"
 893     " bits n thru m from the value of the variable. If n == m, [n] is also allowed as a shortcut syntax. For arrays and pointers, expression paths can only contain one index"
 894     " and the meaning of the operation is the same as the one defined by C/C++ (item extraction). Some commands extend bitfield-like syntax for arrays and pointers with the"
 895     " meaning of array slicing (taking elements n thru m inside the array or pointed-to memory).";
 896 }
 897
 898 void
 899 CommandObject::GenerateHelpText (CommandReturnObject &result)
 900 {
 901     GenerateHelpText(result.GetOutputStream());
 902
 903     result.SetStatus (eReturnStatusSuccessFinishNoResult);
 904 }
 905
 906 void
 907 CommandObject::GenerateHelpText (Stream &output_strm)
 908 {
 909     CommandInterpreter& interpreter = GetCommandInterpreter();
 910     if (GetOptions() != NULL)
 911     {
 912         if (WantsRawCommandString())
 913         {
 914             std::string help_text (GetHelp());
 915             help_text.append ("  This command takes 'raw' input (no need to quote stuff).");
 916             interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1);
 917         }
 918         else
 919             interpreter.OutputFormattedHelpText (output_strm, "", "", GetHelp(), 1);
 920         output_strm.Printf ("\nSyntax: %s\n", GetSyntax());
 921         GetOptions()->GenerateOptionUsage (output_strm, this);
 922         const char *long_help = GetHelpLong();
 923         if ((long_help != NULL)
 924             && (strlen (long_help) > 0))
 925             output_strm.Printf ("\n%s", long_help);
 926         if (WantsRawCommandString() && !WantsCompletion())
 927         {
 928             // Emit the message about using ' -- ' between the end of the command options and the raw input
 929             // conditionally, i.e., only if the command object does not want completion.
 930             interpreter.OutputFormattedHelpText (output_strm, "", "",
 931                                                  "\nIMPORTANT NOTE:  Because this command takes 'raw' input, if you use any command options"
 932                                                  " you must use ' -- ' between the end of the command options and the beginning of the raw input.", 1);
 933         }
 934         else if (GetNumArgumentEntries() > 0
 935                  && GetOptions()
 936                  && GetOptions()->NumCommandOptions() > 0)
 937         {
 938             // Also emit a warning about using "--" in case you are using a command that takes options and arguments.
 939             interpreter.OutputFormattedHelpText (output_strm, "", "",
 940                                                  "\nThis command takes options and free-form arguments.  If your arguments resemble"
 941                                                  " option specifiers (i.e., they start with a - or --), you must use ' -- ' between"
 942                                                  " the end of the command options and the beginning of the arguments.", 1);
 943         }
 944     }
 945     else if (IsMultiwordObject())
 946     {
 947         if (WantsRawCommandString())
 948         {
 949             std::string help_text (GetHelp());
 950             help_text.append ("  This command takes 'raw' input (no need to quote stuff).");
 951             interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1);
 952         }
 953         else
 954             interpreter.OutputFormattedHelpText (output_strm, "", "", GetHelp(), 1);
 955         GenerateHelpText (output_strm);
 956     }
 957     else
 958     {
 959         const char *long_help = GetHelpLong();
 960         if ((long_help != NULL)
 961             && (strlen (long_help) > 0))
 962             output_strm.Printf ("%s", long_help);
 963         else if (WantsRawCommandString())
 964         {
 965             std::string help_text (GetHelp());
 966             help_text.append ("  This command takes 'raw' input (no need to quote stuff).");
 967             interpreter.OutputFormattedHelpText (output_strm, "", "", help_text.c_str(), 1);
 968         }
 969         else
 970             interpreter.OutputFormattedHelpText (output_strm, "", "", GetHelp(), 1);
 971         output_strm.Printf ("\nSyntax: %s\n", GetSyntax());
 972     }
 973 }
 974
 975 void
 976 CommandObject::AddIDsArgumentData(CommandArgumentEntry &arg, CommandArgumentType ID, CommandArgumentType IDRange)
 977 {
 978     CommandArgumentData id_arg;
 979     CommandArgumentData id_range_arg;
 980
 981     // Create the first variant for the first (and only) argument for this command.
 982     id_arg.arg_type = ID;
 983     id_arg.arg_repetition = eArgRepeatOptional;
 984
 985     // Create the second variant for the first (and only) argument for this command.
 986     id_range_arg.arg_type = IDRange;
 987     id_range_arg.arg_repetition = eArgRepeatOptional;
 988
 989     // The first (and only) argument for this command could be either an id or an id_range.
 990     // Push both variants into the entry for the first argument for this command.
 991     arg.push_back(id_arg);
 992     arg.push_back(id_range_arg);
 993 }
 994
 995 const char *
 996 CommandObject::GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type)
 997 {
 998     if (arg_type >=0 && arg_type < eArgTypeLastArg)
 999         return g_arguments_data[arg_type].arg_name;
1000     return NULL;
1001
1002 }
1003
1004 const char *
1005 CommandObject::GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type)
1006 {
1007     if (arg_type >=0 && arg_type < eArgTypeLastArg)
1008         return g_arguments_data[arg_type].help_text;
1009     return NULL;
1010 }
1011
1012 bool
1013 CommandObjectParsed::Execute (const char *args_string, CommandReturnObject &result)
1014 {
1015     CommandOverrideCallback command_callback = GetOverrideCallback();
1016     bool handled = false;
1017     Args cmd_args (args_string);
1018     if (command_callback)
1019     {
1020         Args full_args (GetCommandName ());
1021         full_args.AppendArguments(cmd_args);
1022         handled = command_callback (GetOverrideCallbackBaton(), full_args.GetConstArgumentVector());
1023     }
1024     if (!handled)
1025     {
1026         for (size_t i = 0; i < cmd_args.GetArgumentCount();  ++i)
1027         {
1028             const char *tmp_str = cmd_args.GetArgumentAtIndex (i);
1029             if (tmp_str[0] == '`')  // back-quote
1030                 cmd_args.ReplaceArgumentAtIndex (i, m_interpreter.ProcessEmbeddedScriptCommands (tmp_str));
1031         }
1032
1033         if (CheckRequirements(result))
1034         {
1035             if (ParseOptions (cmd_args, result))
1036             {
1037                 // Call the command-specific version of 'Execute', passing it the already processed arguments.
1038                 handled = DoExecute (cmd_args, result);
1039             }
1040         }
1041
1042         Cleanup();
1043     }
1044     return handled;
1045 }
1046
1047 bool
1048 CommandObjectRaw::Execute (const char *args_string, CommandReturnObject &result)
1049 {
1050     CommandOverrideCallback command_callback = GetOverrideCallback();
1051     bool handled = false;
1052     if (command_callback)
1053     {
1054         std::string full_command (GetCommandName ());
1055         full_command += ' ';
1056         full_command += args_string;
1057         const char *argv[2] = { NULL, NULL };
1058         argv[0] = full_command.c_str();
1059         handled = command_callback (GetOverrideCallbackBaton(), argv);
1060     }
1061     if (!handled)
1062     {
1063         if (CheckRequirements(result))
1064             handled = DoExecute (args_string, result);
1065
1066         Cleanup();
1067     }
1068     return handled;
1069 }
1070
1071 static
1072 const char *arch_helper()
1073 {
1074     static StreamString g_archs_help;
1075     if (g_archs_help.Empty())
1076     {
1077         StringList archs;
1078         ArchSpec::AutoComplete(NULL, archs);
1079         g_archs_help.Printf("These are the supported architecture names:\n");
1080         archs.Join("\n", g_archs_help);
1081     }
1082     return g_archs_help.GetData();
1083 }
1084
1085 CommandObject::ArgumentTableEntry
1086 CommandObject::g_arguments_data[] =
1087 {
1088     { eArgTypeAddress, "address", CommandCompletions::eNoCompletion, { NULL, false }, "A valid address in the target program's execution space." },
1089     { eArgTypeAddressOrExpression, "address-expression", CommandCompletions::eNoCompletion, { NULL, false }, "An expression that resolves to an address." },
1090     { eArgTypeAliasName, "alias-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of an abbreviation (alias) for a debugger command." },
1091     { eArgTypeAliasOptions, "options-for-aliased-command", CommandCompletions::eNoCompletion, { NULL, false }, "Command options to be used as part of an alias (abbreviation) definition.  (See 'help commands alias' for more information.)" },
1092     { eArgTypeArchitecture, "arch", CommandCompletions::eArchitectureCompletion, { arch_helper, true }, "The architecture name, e.g. i386 or x86_64." },
1093     { eArgTypeBoolean, "boolean", CommandCompletions::eNoCompletion, { NULL, false }, "A Boolean value: 'true' or 'false'" },
1094     { eArgTypeBreakpointID, "breakpt-id", CommandCompletions::eNoCompletion, { BreakpointIDHelpTextCallback, false }, NULL },
1095     { eArgTypeBreakpointIDRange, "breakpt-id-list", CommandCompletions::eNoCompletion, { BreakpointIDRangeHelpTextCallback, false }, NULL },
1096     { eArgTypeByteSize, "byte-size", CommandCompletions::eNoCompletion, { NULL, false }, "Number of bytes to use." },
1097     { eArgTypeClassName, "class-name", CommandCompletions::eNoCompletion, { NULL, false }, "Then name of a class from the debug information in the program." },
1098     { eArgTypeCommandName, "cmd-name", CommandCompletions::eNoCompletion, { NULL, false }, "A debugger command (may be multiple words), without any options or arguments." },
1099     { eArgTypeCount, "count", CommandCompletions::eNoCompletion, { NULL, false }, "An unsigned integer." },
1100     { eArgTypeDirectoryName, "directory", CommandCompletions::eDiskDirectoryCompletion, { NULL, false }, "A directory name." },
1101     { eArgTypeDisassemblyFlavor, "disassembly-flavor", CommandCompletions::eNoCompletion, { NULL, false }, "A disassembly flavor recognized by your disassembly plugin.  Currently the only valid options are \"att\" and \"intel\" for Intel targets" },
1102     { eArgTypeEndAddress, "end-address", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1103     { eArgTypeExpression, "expr", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1104     { eArgTypeExpressionPath, "expr-path", CommandCompletions::eNoCompletion, { ExprPathHelpTextCallback, true }, NULL },
1105     { eArgTypeExprFormat, "expression-format", CommandCompletions::eNoCompletion, { NULL, false }, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]" },
1106     { eArgTypeFilename, "filename", CommandCompletions::eDiskFileCompletion, { NULL, false }, "The name of a file (can include path)." },
1107     { eArgTypeFormat, "format", CommandCompletions::eNoCompletion, { FormatHelpTextCallback, true }, NULL },
1108     { eArgTypeFrameIndex, "frame-index", CommandCompletions::eNoCompletion, { NULL, false }, "Index into a thread's list of frames." },
1109     { eArgTypeFullName, "fullname", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1110     { eArgTypeFunctionName, "function-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a function." },
1111     { eArgTypeFunctionOrSymbol, "function-or-symbol", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a function or symbol." },
1112     { eArgTypeGDBFormat, "gdb-format", CommandCompletions::eNoCompletion, { GDBFormatHelpTextCallback, true }, NULL },
1113     { eArgTypeIndex, "index", CommandCompletions::eNoCompletion, { NULL, false }, "An index into a list." },
1114     { eArgTypeLanguage, "language", CommandCompletions::eNoCompletion, { LanguageTypeHelpTextCallback, true }, NULL },
1115     { eArgTypeLineNum, "linenum", CommandCompletions::eNoCompletion, { NULL, false }, "Line number in a source file." },
1116     { eArgTypeLogCategory, "log-category", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a category within a log channel, e.g. all (try \"log list\" to see a list of all channels and their categories." },
1117     { eArgTypeLogChannel, "log-channel", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a log channel, e.g. process.gdb-remote (try \"log list\" to see a list of all channels and their categories)." },
1118     { eArgTypeMethod, "method", CommandCompletions::eNoCompletion, { NULL, false }, "A C++ method name." },
1119     { eArgTypeName, "name", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1120     { eArgTypeNewPathPrefix, "new-path-prefix", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1121     { eArgTypeNumLines, "num-lines", CommandCompletions::eNoCompletion, { NULL, false }, "The number of lines to use." },
1122     { eArgTypeNumberPerLine, "number-per-line", CommandCompletions::eNoCompletion, { NULL, false }, "The number of items per line to display." },
1123     { eArgTypeOffset, "offset", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1124     { eArgTypeOldPathPrefix, "old-path-prefix", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1125     { eArgTypeOneLiner, "one-line-command", CommandCompletions::eNoCompletion, { NULL, false }, "A command that is entered as a single line of text." },
1126     { eArgTypePid, "pid", CommandCompletions::eNoCompletion, { NULL, false }, "The process ID number." },
1127     { eArgTypePlugin, "plugin", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1128     { eArgTypeProcessName, "process-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of the process." },
1129     { eArgTypePythonClass, "python-class", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a Python class." },
1130     { eArgTypePythonFunction, "python-function", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a Python function." },
1131     { eArgTypePythonScript, "python-script", CommandCompletions::eNoCompletion, { NULL, false }, "Source code written in Python." },
1132     { eArgTypeQueueName, "queue-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of the thread queue." },
1133     { eArgTypeRegisterName, "register-name", CommandCompletions::eNoCompletion, { RegisterNameHelpTextCallback, true }, NULL },
1134     { eArgTypeRegularExpression, "regular-expression", CommandCompletions::eNoCompletion, { NULL, false }, "A regular expression." },
1135     { eArgTypeRunArgs, "run-args", CommandCompletions::eNoCompletion, { NULL, false }, "Arguments to be passed to the target program when it starts executing." },
1136     { eArgTypeRunMode, "run-mode", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1137     { eArgTypeScriptedCommandSynchronicity, "script-cmd-synchronicity", CommandCompletions::eNoCompletion, { NULL, false }, "The synchronicity to use to run scripted commands with regard to LLDB event system." },
1138     { eArgTypeScriptLang, "script-language", CommandCompletions::eNoCompletion, { NULL, false }, "The scripting language to be used for script-based commands.  Currently only Python is valid." },
1139     { eArgTypeSearchWord, "search-word", CommandCompletions::eNoCompletion, { NULL, false }, "The word for which you wish to search for information about." },
1140     { eArgTypeSelector, "selector", CommandCompletions::eNoCompletion, { NULL, false }, "An Objective-C selector name." },
1141     { eArgTypeSettingIndex, "setting-index", CommandCompletions::eNoCompletion, { NULL, false }, "An index into a settings variable that is an array (try 'settings list' to see all the possible settings variables and their types)." },
1142     { eArgTypeSettingKey, "setting-key", CommandCompletions::eNoCompletion, { NULL, false }, "A key into a settings variables that is a dictionary (try 'settings list' to see all the possible settings variables and their types)." },
1143     { eArgTypeSettingPrefix, "setting-prefix", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a settable internal debugger variable up to a dot ('.'), e.g. 'target.process.'" },
1144     { eArgTypeSettingVariableName, "setting-variable-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a settable internal debugger variable.  Type 'settings list' to see a complete list of such variables." },
1145     { eArgTypeShlibName, "shlib-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a shared library." },
1146     { eArgTypeSourceFile, "source-file", CommandCompletions::eSourceFileCompletion, { NULL, false }, "The name of a source file.." },
1147     { eArgTypeSortOrder, "sort-order", CommandCompletions::eNoCompletion, { NULL, false }, "Specify a sort order when dumping lists." },
1148     { eArgTypeStartAddress, "start-address", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1149     { eArgTypeSummaryString, "summary-string", CommandCompletions::eNoCompletion, { SummaryStringHelpTextCallback, true }, NULL },
1150     { eArgTypeSymbol, "symbol", CommandCompletions::eSymbolCompletion, { NULL, false }, "Any symbol name (function name, variable, argument, etc.)" },
1151     { eArgTypeThreadID, "thread-id", CommandCompletions::eNoCompletion, { NULL, false }, "Thread ID number." },
1152     { eArgTypeThreadIndex, "thread-index", CommandCompletions::eNoCompletion, { NULL, false }, "Index into the process' list of threads." },
1153     { eArgTypeThreadName, "thread-name", CommandCompletions::eNoCompletion, { NULL, false }, "The thread's name." },
1154     { eArgTypeUnsignedInteger, "unsigned-integer", CommandCompletions::eNoCompletion, { NULL, false }, "An unsigned integer." },
1155     { eArgTypeUnixSignal, "unix-signal", CommandCompletions::eNoCompletion, { NULL, false }, "A valid Unix signal name or number (e.g. SIGKILL, KILL or 9)." },
1156     { eArgTypeVarName, "variable-name", CommandCompletions::eNoCompletion, { NULL, false }, "The name of a variable in your program." },
1157     { eArgTypeValue, "value", CommandCompletions::eNoCompletion, { NULL, false }, "A value could be anything, depending on where and how it is used." },
1158     { eArgTypeWidth, "width", CommandCompletions::eNoCompletion, { NULL, false }, "Help text goes here." },
1159     { eArgTypeNone, "none", CommandCompletions::eNoCompletion, { NULL, false }, "No help available for this." },
1160     { eArgTypePlatform, "platform-name", CommandCompletions::ePlatformPluginCompletion, { NULL, false }, "The name of an installed platform plug-in . Type 'platform list' to see a complete list of installed platforms." },
1161     { eArgTypeWatchpointID, "watchpt-id", CommandCompletions::eNoCompletion, { NULL, false }, "Watchpoint IDs are positive integers." },
1162     { eArgTypeWatchpointIDRange, "watchpt-id-list", CommandCompletions::eNoCompletion, { NULL, false }, "For example, '1-3' or '1 to 3'." },
1163     { eArgTypeWatchType, "watch-type", CommandCompletions::eNoCompletion, { NULL, false }, "Specify the type for a watchpoint." }
1164 };
1165
1166 const CommandObject::ArgumentTableEntry*
1167 CommandObject::GetArgumentTable ()
1168 {
1169     // If this assertion fires, then the table above is out of date with the CommandArgumentType enumeration
1170     assert ((sizeof (CommandObject::g_arguments_data) / sizeof (CommandObject::ArgumentTableEntry)) == eArgTypeLastArg);
1171     return CommandObject::g_arguments_data;
1172 }
1173
1174