1 //===-- CommandObjectSettings.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 "CommandObjectSettings.h" 13 14 // C Includes 15 // C++ Includes 16 // Other libraries and framework includes 17 // Project includes 18 #include "lldb/Interpreter/CommandInterpreter.h" 19 #include "lldb/Interpreter/CommandReturnObject.h" 20 #include "lldb/Interpreter/CommandCompletions.h" 21 22 using namespace lldb; 23 using namespace lldb_private; 24 #include "llvm/ADT/StringRef.h" 25 26 //------------------------------------------------------------------------- 27 // CommandObjectSettingsSet 28 //------------------------------------------------------------------------- 29 30 class CommandObjectSettingsSet : public CommandObjectRaw 31 { 32 public: 33 CommandObjectSettingsSet (CommandInterpreter &interpreter) : 34 CommandObjectRaw (interpreter, 35 "settings set", 36 "Set or change the value of a single debugger setting variable.", 37 NULL), 38 m_options (interpreter) 39 { 40 CommandArgumentEntry arg1; 41 CommandArgumentEntry arg2; 42 CommandArgumentData var_name_arg; 43 CommandArgumentData value_arg; 44 45 // Define the first (and only) variant of this arg. 46 var_name_arg.arg_type = eArgTypeSettingVariableName; 47 var_name_arg.arg_repetition = eArgRepeatPlain; 48 49 // There is only one variant this argument could be; put it into the argument entry. 50 arg1.push_back (var_name_arg); 51 52 // Define the first (and only) variant of this arg. 53 value_arg.arg_type = eArgTypeValue; 54 value_arg.arg_repetition = eArgRepeatPlain; 55 56 // There is only one variant this argument could be; put it into the argument entry. 57 arg2.push_back (value_arg); 58 59 // Push the data for the first argument into the m_arguments vector. 60 m_arguments.push_back (arg1); 61 m_arguments.push_back (arg2); 62 63 SetHelpLong ( 64 "When setting a dictionary or array variable, you can set multiple entries \n\ 65 at once by giving the values to the set command. For example: \n\ 66 \n\ 67 (lldb) settings set target.run-args value1 value2 value3 \n\ 68 (lldb) settings set target.env-vars MYPATH=~/.:/usr/bin SOME_ENV_VAR=12345 \n\ 69 \n\ 70 (lldb) settings show target.run-args \n\ 71 [0]: 'value1' \n\ 72 [1]: 'value2' \n\ 73 [3]: 'value3' \n\ 74 (lldb) settings show target.env-vars \n\ 75 'MYPATH=~/.:/usr/bin'\n\ 76 'SOME_ENV_VAR=12345' \n\ 77 \n\ 78 Warning: The 'set' command re-sets the entire array or dictionary. If you \n\ 79 just want to add, remove or update individual values (or add something to \n\ 80 the end), use one of the other settings sub-commands: append, replace, \n\ 81 insert-before or insert-after.\n"); 82 83 } 84 85 86 virtual 87 ~CommandObjectSettingsSet () {} 88 89 // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString. 90 virtual bool 91 WantsCompletion() { return true; } 92 93 virtual Options * 94 GetOptions () 95 { 96 return &m_options; 97 } 98 99 class CommandOptions : public Options 100 { 101 public: 102 103 CommandOptions (CommandInterpreter &interpreter) : 104 Options (interpreter), 105 m_global (false) 106 { 107 } 108 109 virtual 110 ~CommandOptions () {} 111 112 virtual Error 113 SetOptionValue (uint32_t option_idx, const char *option_arg) 114 { 115 Error error; 116 const int short_option = m_getopt_table[option_idx].val; 117 118 switch (short_option) 119 { 120 case 'g': 121 m_global = true; 122 break; 123 default: 124 error.SetErrorStringWithFormat ("unrecognized options '%c'", short_option); 125 break; 126 } 127 128 return error; 129 } 130 131 void 132 OptionParsingStarting () 133 { 134 m_global = false; 135 } 136 137 const OptionDefinition* 138 GetDefinitions () 139 { 140 return g_option_table; 141 } 142 143 // Options table: Required for subclasses of Options. 144 145 static OptionDefinition g_option_table[]; 146 147 // Instance variables to hold the values for command options. 148 149 bool m_global; 150 }; 151 152 virtual int 153 HandleArgumentCompletion (Args &input, 154 int &cursor_index, 155 int &cursor_char_position, 156 OptionElementVector &opt_element_vector, 157 int match_start_point, 158 int max_return_elements, 159 bool &word_complete, 160 StringList &matches) 161 { 162 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 163 164 const size_t argc = input.GetArgumentCount(); 165 const char *arg = NULL; 166 int setting_var_idx; 167 for (setting_var_idx = 1; setting_var_idx < argc; ++setting_var_idx) 168 { 169 arg = input.GetArgumentAtIndex(setting_var_idx); 170 if (arg && arg[0] != '-') 171 break; // We found our setting variable name index 172 } 173 if (cursor_index == setting_var_idx) 174 { 175 // Attempting to complete setting variable name 176 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 177 CommandCompletions::eSettingsNameCompletion, 178 completion_str.c_str(), 179 match_start_point, 180 max_return_elements, 181 NULL, 182 word_complete, 183 matches); 184 } 185 else 186 { 187 arg = input.GetArgumentAtIndex(cursor_index); 188 189 if (arg) 190 { 191 if (arg[0] == '-') 192 { 193 // Complete option name 194 } 195 else 196 { 197 // Complete setting value 198 const char *setting_var_name = input.GetArgumentAtIndex(setting_var_idx); 199 Error error; 200 lldb::OptionValueSP value_sp (m_interpreter.GetDebugger().GetPropertyValue(&m_exe_ctx, setting_var_name, false, error)); 201 if (value_sp) 202 { 203 value_sp->AutoComplete (m_interpreter, 204 completion_str.c_str(), 205 match_start_point, 206 max_return_elements, 207 word_complete, 208 matches); 209 } 210 } 211 } 212 } 213 return matches.GetSize(); 214 } 215 216 protected: 217 virtual bool 218 DoExecute (const char *command, CommandReturnObject &result) 219 { 220 Args cmd_args(command); 221 222 // Process possible options. 223 if (!ParseOptions (cmd_args, result)) 224 return false; 225 226 const size_t argc = cmd_args.GetArgumentCount (); 227 if ((argc < 2) && (!m_options.m_global)) 228 { 229 result.AppendError ("'settings set' takes more arguments"); 230 result.SetStatus (eReturnStatusFailed); 231 return false; 232 } 233 234 const char *var_name = cmd_args.GetArgumentAtIndex (0); 235 if ((var_name == NULL) || (var_name[0] == '\0')) 236 { 237 result.AppendError ("'settings set' command requires a valid variable name"); 238 result.SetStatus (eReturnStatusFailed); 239 return false; 240 } 241 242 // Split the raw command into var_name and value pair. 243 llvm::StringRef raw_str(command); 244 std::string var_value_string = raw_str.split(var_name).second.str(); 245 const char *var_value_cstr = Args::StripSpaces(var_value_string, true, true, false); 246 247 Error error; 248 if (m_options.m_global) 249 { 250 error = m_interpreter.GetDebugger().SetPropertyValue (NULL, 251 eVarSetOperationAssign, 252 var_name, 253 var_value_cstr); 254 } 255 256 if (error.Success()) 257 { 258 // FIXME this is the same issue as the one in commands script import 259 // we could be setting target.load-script-from-symbol-file which would cause 260 // Python scripts to be loaded, which could run LLDB commands 261 // (e.g. settings set target.process.python-os-plugin-path) and cause a crash 262 // if we did not clear the command's exe_ctx first 263 ExecutionContext exe_ctx(m_exe_ctx); 264 m_exe_ctx.Clear(); 265 error = m_interpreter.GetDebugger().SetPropertyValue (&exe_ctx, 266 eVarSetOperationAssign, 267 var_name, 268 var_value_cstr); 269 } 270 271 if (error.Fail()) 272 { 273 result.AppendError (error.AsCString()); 274 result.SetStatus (eReturnStatusFailed); 275 return false; 276 } 277 else 278 { 279 result.SetStatus (eReturnStatusSuccessFinishResult); 280 } 281 282 return result.Succeeded(); 283 } 284 private: 285 CommandOptions m_options; 286 }; 287 288 OptionDefinition 289 CommandObjectSettingsSet::CommandOptions::g_option_table[] = 290 { 291 { LLDB_OPT_SET_2, false, "global", 'g', no_argument, NULL, 0, eArgTypeNone, "Apply the new value to the global default value." }, 292 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 293 }; 294 295 296 //------------------------------------------------------------------------- 297 // CommandObjectSettingsShow -- Show current values 298 //------------------------------------------------------------------------- 299 300 class CommandObjectSettingsShow : public CommandObjectParsed 301 { 302 public: 303 CommandObjectSettingsShow (CommandInterpreter &interpreter) : 304 CommandObjectParsed (interpreter, 305 "settings show", 306 "Show the specified internal debugger setting variable and its value, or show all the currently set variables and their values, if nothing is specified.", 307 NULL) 308 { 309 CommandArgumentEntry arg1; 310 CommandArgumentData var_name_arg; 311 312 // Define the first (and only) variant of this arg. 313 var_name_arg.arg_type = eArgTypeSettingVariableName; 314 var_name_arg.arg_repetition = eArgRepeatOptional; 315 316 // There is only one variant this argument could be; put it into the argument entry. 317 arg1.push_back (var_name_arg); 318 319 // Push the data for the first argument into the m_arguments vector. 320 m_arguments.push_back (arg1); 321 } 322 323 virtual 324 ~CommandObjectSettingsShow () {} 325 326 327 virtual int 328 HandleArgumentCompletion (Args &input, 329 int &cursor_index, 330 int &cursor_char_position, 331 OptionElementVector &opt_element_vector, 332 int match_start_point, 333 int max_return_elements, 334 bool &word_complete, 335 StringList &matches) 336 { 337 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 338 339 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 340 CommandCompletions::eSettingsNameCompletion, 341 completion_str.c_str(), 342 match_start_point, 343 max_return_elements, 344 NULL, 345 word_complete, 346 matches); 347 return matches.GetSize(); 348 } 349 350 protected: 351 virtual bool 352 DoExecute (Args& args, CommandReturnObject &result) 353 { 354 result.SetStatus (eReturnStatusSuccessFinishResult); 355 356 const size_t argc = args.GetArgumentCount (); 357 if (argc > 0) 358 { 359 for (size_t i=0; i<argc; ++i) 360 { 361 const char *property_path = args.GetArgumentAtIndex (i); 362 363 Error error(m_interpreter.GetDebugger().DumpPropertyValue (&m_exe_ctx, result.GetOutputStream(), property_path, OptionValue::eDumpGroupValue)); 364 if (error.Success()) 365 { 366 result.GetOutputStream().EOL(); 367 } 368 else 369 { 370 result.AppendError (error.AsCString()); 371 result.SetStatus (eReturnStatusFailed); 372 } 373 } 374 } 375 else 376 { 377 m_interpreter.GetDebugger().DumpAllPropertyValues (&m_exe_ctx, result.GetOutputStream(), OptionValue::eDumpGroupValue); 378 } 379 380 return result.Succeeded(); 381 } 382 }; 383 384 //------------------------------------------------------------------------- 385 // CommandObjectSettingsList -- List settable variables 386 //------------------------------------------------------------------------- 387 388 class CommandObjectSettingsList : public CommandObjectParsed 389 { 390 public: 391 CommandObjectSettingsList (CommandInterpreter &interpreter) : 392 CommandObjectParsed (interpreter, 393 "settings list", 394 "List and describe all the internal debugger settings variables that are available to the user to 'set' or 'show', or describe a particular variable or set of variables (by specifying the variable name or a common prefix).", 395 NULL) 396 { 397 CommandArgumentEntry arg; 398 CommandArgumentData var_name_arg; 399 CommandArgumentData prefix_name_arg; 400 401 // Define the first variant of this arg. 402 var_name_arg.arg_type = eArgTypeSettingVariableName; 403 var_name_arg.arg_repetition = eArgRepeatOptional; 404 405 // Define the second variant of this arg. 406 prefix_name_arg.arg_type = eArgTypeSettingPrefix; 407 prefix_name_arg.arg_repetition = eArgRepeatOptional; 408 409 arg.push_back (var_name_arg); 410 arg.push_back (prefix_name_arg); 411 412 // Push the data for the first argument into the m_arguments vector. 413 m_arguments.push_back (arg); 414 } 415 416 virtual 417 ~CommandObjectSettingsList () {} 418 419 virtual int 420 HandleArgumentCompletion (Args &input, 421 int &cursor_index, 422 int &cursor_char_position, 423 OptionElementVector &opt_element_vector, 424 int match_start_point, 425 int max_return_elements, 426 bool &word_complete, 427 StringList &matches) 428 { 429 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 430 431 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 432 CommandCompletions::eSettingsNameCompletion, 433 completion_str.c_str(), 434 match_start_point, 435 max_return_elements, 436 NULL, 437 word_complete, 438 matches); 439 return matches.GetSize(); 440 } 441 442 protected: 443 virtual bool 444 DoExecute (Args& args, CommandReturnObject &result) 445 { 446 result.SetStatus (eReturnStatusSuccessFinishResult); 447 448 const bool will_modify = false; 449 const size_t argc = args.GetArgumentCount (); 450 if (argc > 0) 451 { 452 const bool dump_qualified_name = true; 453 454 for (size_t i=0; i<argc; ++i) 455 { 456 const char *property_path = args.GetArgumentAtIndex (i); 457 458 const Property *property = m_interpreter.GetDebugger().GetValueProperties()->GetPropertyAtPath (&m_exe_ctx, will_modify, property_path); 459 460 if (property) 461 { 462 property->DumpDescription (m_interpreter, result.GetOutputStream(), 0, dump_qualified_name); 463 } 464 else 465 { 466 result.AppendErrorWithFormat ("invalid property path '%s'", property_path); 467 result.SetStatus (eReturnStatusFailed); 468 } 469 } 470 } 471 else 472 { 473 m_interpreter.GetDebugger().DumpAllDescriptions (m_interpreter, result.GetOutputStream()); 474 } 475 476 return result.Succeeded(); 477 } 478 }; 479 480 //------------------------------------------------------------------------- 481 // CommandObjectSettingsRemove 482 //------------------------------------------------------------------------- 483 484 class CommandObjectSettingsRemove : public CommandObjectRaw 485 { 486 public: 487 CommandObjectSettingsRemove (CommandInterpreter &interpreter) : 488 CommandObjectRaw (interpreter, 489 "settings remove", 490 "Remove the specified element from an array or dictionary settings variable.", 491 NULL) 492 { 493 CommandArgumentEntry arg1; 494 CommandArgumentEntry arg2; 495 CommandArgumentData var_name_arg; 496 CommandArgumentData index_arg; 497 CommandArgumentData key_arg; 498 499 // Define the first (and only) variant of this arg. 500 var_name_arg.arg_type = eArgTypeSettingVariableName; 501 var_name_arg.arg_repetition = eArgRepeatPlain; 502 503 // There is only one variant this argument could be; put it into the argument entry. 504 arg1.push_back (var_name_arg); 505 506 // Define the first variant of this arg. 507 index_arg.arg_type = eArgTypeSettingIndex; 508 index_arg.arg_repetition = eArgRepeatPlain; 509 510 // Define the second variant of this arg. 511 key_arg.arg_type = eArgTypeSettingKey; 512 key_arg.arg_repetition = eArgRepeatPlain; 513 514 // Push both variants into this arg 515 arg2.push_back (index_arg); 516 arg2.push_back (key_arg); 517 518 // Push the data for the first argument into the m_arguments vector. 519 m_arguments.push_back (arg1); 520 m_arguments.push_back (arg2); 521 } 522 523 virtual 524 ~CommandObjectSettingsRemove () {} 525 526 virtual int 527 HandleArgumentCompletion (Args &input, 528 int &cursor_index, 529 int &cursor_char_position, 530 OptionElementVector &opt_element_vector, 531 int match_start_point, 532 int max_return_elements, 533 bool &word_complete, 534 StringList &matches) 535 { 536 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 537 538 // Attempting to complete variable name 539 if (cursor_index < 2) 540 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 541 CommandCompletions::eSettingsNameCompletion, 542 completion_str.c_str(), 543 match_start_point, 544 max_return_elements, 545 NULL, 546 word_complete, 547 matches); 548 549 return matches.GetSize(); 550 } 551 552 protected: 553 virtual bool 554 DoExecute (const char *command, CommandReturnObject &result) 555 { 556 result.SetStatus (eReturnStatusSuccessFinishNoResult); 557 558 Args cmd_args(command); 559 560 // Process possible options. 561 if (!ParseOptions (cmd_args, result)) 562 return false; 563 564 const size_t argc = cmd_args.GetArgumentCount (); 565 if (argc == 0) 566 { 567 result.AppendError ("'settings set' takes an array or dictionary item, or an array followed by one or more indexes, or a dictionary followed by one or more key names to remove"); 568 result.SetStatus (eReturnStatusFailed); 569 return false; 570 } 571 572 const char *var_name = cmd_args.GetArgumentAtIndex (0); 573 if ((var_name == NULL) || (var_name[0] == '\0')) 574 { 575 result.AppendError ("'settings set' command requires a valid variable name"); 576 result.SetStatus (eReturnStatusFailed); 577 return false; 578 } 579 580 // Split the raw command into var_name and value pair. 581 llvm::StringRef raw_str(command); 582 std::string var_value_string = raw_str.split(var_name).second.str(); 583 const char *var_value_cstr = Args::StripSpaces(var_value_string, true, true, false); 584 585 Error error (m_interpreter.GetDebugger().SetPropertyValue (&m_exe_ctx, 586 eVarSetOperationRemove, 587 var_name, 588 var_value_cstr)); 589 if (error.Fail()) 590 { 591 result.AppendError (error.AsCString()); 592 result.SetStatus (eReturnStatusFailed); 593 return false; 594 } 595 596 return result.Succeeded(); 597 } 598 }; 599 600 //------------------------------------------------------------------------- 601 // CommandObjectSettingsReplace 602 //------------------------------------------------------------------------- 603 604 class CommandObjectSettingsReplace : public CommandObjectRaw 605 { 606 public: 607 CommandObjectSettingsReplace (CommandInterpreter &interpreter) : 608 CommandObjectRaw (interpreter, 609 "settings replace", 610 "Replace the specified element from an internal debugger settings array or dictionary variable with the specified new value.", 611 NULL) 612 { 613 CommandArgumentEntry arg1; 614 CommandArgumentEntry arg2; 615 CommandArgumentEntry arg3; 616 CommandArgumentData var_name_arg; 617 CommandArgumentData index_arg; 618 CommandArgumentData key_arg; 619 CommandArgumentData value_arg; 620 621 // Define the first (and only) variant of this arg. 622 var_name_arg.arg_type = eArgTypeSettingVariableName; 623 var_name_arg.arg_repetition = eArgRepeatPlain; 624 625 // There is only one variant this argument could be; put it into the argument entry. 626 arg1.push_back (var_name_arg); 627 628 // Define the first (variant of this arg. 629 index_arg.arg_type = eArgTypeSettingIndex; 630 index_arg.arg_repetition = eArgRepeatPlain; 631 632 // Define the second (variant of this arg. 633 key_arg.arg_type = eArgTypeSettingKey; 634 key_arg.arg_repetition = eArgRepeatPlain; 635 636 // Put both variants into this arg 637 arg2.push_back (index_arg); 638 arg2.push_back (key_arg); 639 640 // Define the first (and only) variant of this arg. 641 value_arg.arg_type = eArgTypeValue; 642 value_arg.arg_repetition = eArgRepeatPlain; 643 644 // There is only one variant this argument could be; put it into the argument entry. 645 arg3.push_back (value_arg); 646 647 // Push the data for the first argument into the m_arguments vector. 648 m_arguments.push_back (arg1); 649 m_arguments.push_back (arg2); 650 m_arguments.push_back (arg3); 651 } 652 653 654 virtual 655 ~CommandObjectSettingsReplace () {} 656 657 // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString. 658 virtual bool 659 WantsCompletion() { return true; } 660 661 virtual int 662 HandleArgumentCompletion (Args &input, 663 int &cursor_index, 664 int &cursor_char_position, 665 OptionElementVector &opt_element_vector, 666 int match_start_point, 667 int max_return_elements, 668 bool &word_complete, 669 StringList &matches) 670 { 671 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 672 673 // Attempting to complete variable name 674 if (cursor_index < 2) 675 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 676 CommandCompletions::eSettingsNameCompletion, 677 completion_str.c_str(), 678 match_start_point, 679 max_return_elements, 680 NULL, 681 word_complete, 682 matches); 683 684 return matches.GetSize(); 685 } 686 687 protected: 688 virtual bool 689 DoExecute (const char *command, CommandReturnObject &result) 690 { 691 result.SetStatus (eReturnStatusSuccessFinishNoResult); 692 693 Args cmd_args(command); 694 const char *var_name = cmd_args.GetArgumentAtIndex (0); 695 if ((var_name == NULL) || (var_name[0] == '\0')) 696 { 697 result.AppendError ("'settings replace' command requires a valid variable name; No value supplied"); 698 result.SetStatus (eReturnStatusFailed); 699 return false; 700 } 701 702 703 // Split the raw command into var_name, index_value, and value triple. 704 llvm::StringRef raw_str(command); 705 std::string var_value_string = raw_str.split(var_name).second.str(); 706 const char *var_value_cstr = Args::StripSpaces(var_value_string, true, true, false); 707 708 Error error(m_interpreter.GetDebugger().SetPropertyValue (&m_exe_ctx, 709 eVarSetOperationReplace, 710 var_name, 711 var_value_cstr)); 712 if (error.Fail()) 713 { 714 result.AppendError (error.AsCString()); 715 result.SetStatus (eReturnStatusFailed); 716 return false; 717 } 718 else 719 { 720 result.SetStatus (eReturnStatusSuccessFinishNoResult); 721 722 } 723 724 return result.Succeeded(); 725 } 726 }; 727 728 //------------------------------------------------------------------------- 729 // CommandObjectSettingsInsertBefore 730 //------------------------------------------------------------------------- 731 732 class CommandObjectSettingsInsertBefore : public CommandObjectRaw 733 { 734 public: 735 CommandObjectSettingsInsertBefore (CommandInterpreter &interpreter) : 736 CommandObjectRaw (interpreter, 737 "settings insert-before", 738 "Insert value(s) into an internal debugger settings array variable, immediately before the specified element.", 739 NULL) 740 { 741 CommandArgumentEntry arg1; 742 CommandArgumentEntry arg2; 743 CommandArgumentEntry arg3; 744 CommandArgumentData var_name_arg; 745 CommandArgumentData index_arg; 746 CommandArgumentData value_arg; 747 748 // Define the first (and only) variant of this arg. 749 var_name_arg.arg_type = eArgTypeSettingVariableName; 750 var_name_arg.arg_repetition = eArgRepeatPlain; 751 752 // There is only one variant this argument could be; put it into the argument entry. 753 arg1.push_back (var_name_arg); 754 755 // Define the first (variant of this arg. 756 index_arg.arg_type = eArgTypeSettingIndex; 757 index_arg.arg_repetition = eArgRepeatPlain; 758 759 // There is only one variant this argument could be; put it into the argument entry. 760 arg2.push_back (index_arg); 761 762 // Define the first (and only) variant of this arg. 763 value_arg.arg_type = eArgTypeValue; 764 value_arg.arg_repetition = eArgRepeatPlain; 765 766 // There is only one variant this argument could be; put it into the argument entry. 767 arg3.push_back (value_arg); 768 769 // Push the data for the first argument into the m_arguments vector. 770 m_arguments.push_back (arg1); 771 m_arguments.push_back (arg2); 772 m_arguments.push_back (arg3); 773 } 774 775 virtual 776 ~CommandObjectSettingsInsertBefore () {} 777 778 // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString. 779 virtual bool 780 WantsCompletion() { return true; } 781 782 virtual int 783 HandleArgumentCompletion (Args &input, 784 int &cursor_index, 785 int &cursor_char_position, 786 OptionElementVector &opt_element_vector, 787 int match_start_point, 788 int max_return_elements, 789 bool &word_complete, 790 StringList &matches) 791 { 792 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 793 794 // Attempting to complete variable name 795 if (cursor_index < 2) 796 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 797 CommandCompletions::eSettingsNameCompletion, 798 completion_str.c_str(), 799 match_start_point, 800 max_return_elements, 801 NULL, 802 word_complete, 803 matches); 804 805 return matches.GetSize(); 806 } 807 808 protected: 809 virtual bool 810 DoExecute (const char *command, CommandReturnObject &result) 811 { 812 result.SetStatus (eReturnStatusSuccessFinishNoResult); 813 814 Args cmd_args(command); 815 const size_t argc = cmd_args.GetArgumentCount (); 816 817 if (argc < 3) 818 { 819 result.AppendError ("'settings insert-before' takes more arguments"); 820 result.SetStatus (eReturnStatusFailed); 821 return false; 822 } 823 824 const char *var_name = cmd_args.GetArgumentAtIndex (0); 825 if ((var_name == NULL) || (var_name[0] == '\0')) 826 { 827 result.AppendError ("'settings insert-before' command requires a valid variable name; No value supplied"); 828 result.SetStatus (eReturnStatusFailed); 829 return false; 830 } 831 832 // Split the raw command into var_name, index_value, and value triple. 833 llvm::StringRef raw_str(command); 834 std::string var_value_string = raw_str.split(var_name).second.str(); 835 const char *var_value_cstr = Args::StripSpaces(var_value_string, true, true, false); 836 837 Error error(m_interpreter.GetDebugger().SetPropertyValue (&m_exe_ctx, 838 eVarSetOperationInsertBefore, 839 var_name, 840 var_value_cstr)); 841 if (error.Fail()) 842 { 843 result.AppendError (error.AsCString()); 844 result.SetStatus (eReturnStatusFailed); 845 return false; 846 } 847 848 return result.Succeeded(); 849 } 850 }; 851 852 //------------------------------------------------------------------------- 853 // CommandObjectSettingInsertAfter 854 //------------------------------------------------------------------------- 855 856 class CommandObjectSettingsInsertAfter : public CommandObjectRaw 857 { 858 public: 859 CommandObjectSettingsInsertAfter (CommandInterpreter &interpreter) : 860 CommandObjectRaw (interpreter, 861 "settings insert-after", 862 "Insert value(s) into an internal debugger settings array variable, immediately after the specified element.", 863 NULL) 864 { 865 CommandArgumentEntry arg1; 866 CommandArgumentEntry arg2; 867 CommandArgumentEntry arg3; 868 CommandArgumentData var_name_arg; 869 CommandArgumentData index_arg; 870 CommandArgumentData value_arg; 871 872 // Define the first (and only) variant of this arg. 873 var_name_arg.arg_type = eArgTypeSettingVariableName; 874 var_name_arg.arg_repetition = eArgRepeatPlain; 875 876 // There is only one variant this argument could be; put it into the argument entry. 877 arg1.push_back (var_name_arg); 878 879 // Define the first (variant of this arg. 880 index_arg.arg_type = eArgTypeSettingIndex; 881 index_arg.arg_repetition = eArgRepeatPlain; 882 883 // There is only one variant this argument could be; put it into the argument entry. 884 arg2.push_back (index_arg); 885 886 // Define the first (and only) variant of this arg. 887 value_arg.arg_type = eArgTypeValue; 888 value_arg.arg_repetition = eArgRepeatPlain; 889 890 // There is only one variant this argument could be; put it into the argument entry. 891 arg3.push_back (value_arg); 892 893 // Push the data for the first argument into the m_arguments vector. 894 m_arguments.push_back (arg1); 895 m_arguments.push_back (arg2); 896 m_arguments.push_back (arg3); 897 } 898 899 virtual 900 ~CommandObjectSettingsInsertAfter () {} 901 902 // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString. 903 virtual bool 904 WantsCompletion() { return true; } 905 906 virtual int 907 HandleArgumentCompletion (Args &input, 908 int &cursor_index, 909 int &cursor_char_position, 910 OptionElementVector &opt_element_vector, 911 int match_start_point, 912 int max_return_elements, 913 bool &word_complete, 914 StringList &matches) 915 { 916 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 917 918 // Attempting to complete variable name 919 if (cursor_index < 2) 920 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 921 CommandCompletions::eSettingsNameCompletion, 922 completion_str.c_str(), 923 match_start_point, 924 max_return_elements, 925 NULL, 926 word_complete, 927 matches); 928 929 return matches.GetSize(); 930 } 931 932 protected: 933 virtual bool 934 DoExecute (const char *command, CommandReturnObject &result) 935 { 936 result.SetStatus (eReturnStatusSuccessFinishNoResult); 937 938 Args cmd_args(command); 939 const size_t argc = cmd_args.GetArgumentCount (); 940 941 if (argc < 3) 942 { 943 result.AppendError ("'settings insert-after' takes more arguments"); 944 result.SetStatus (eReturnStatusFailed); 945 return false; 946 } 947 948 const char *var_name = cmd_args.GetArgumentAtIndex (0); 949 if ((var_name == NULL) || (var_name[0] == '\0')) 950 { 951 result.AppendError ("'settings insert-after' command requires a valid variable name; No value supplied"); 952 result.SetStatus (eReturnStatusFailed); 953 return false; 954 } 955 956 // Split the raw command into var_name, index_value, and value triple. 957 llvm::StringRef raw_str(command); 958 std::string var_value_string = raw_str.split(var_name).second.str(); 959 const char *var_value_cstr = Args::StripSpaces(var_value_string, true, true, false); 960 961 Error error(m_interpreter.GetDebugger().SetPropertyValue (&m_exe_ctx, 962 eVarSetOperationInsertAfter, 963 var_name, 964 var_value_cstr)); 965 if (error.Fail()) 966 { 967 result.AppendError (error.AsCString()); 968 result.SetStatus (eReturnStatusFailed); 969 return false; 970 } 971 972 return result.Succeeded(); 973 } 974 }; 975 976 //------------------------------------------------------------------------- 977 // CommandObjectSettingsAppend 978 //------------------------------------------------------------------------- 979 980 class CommandObjectSettingsAppend : public CommandObjectRaw 981 { 982 public: 983 CommandObjectSettingsAppend (CommandInterpreter &interpreter) : 984 CommandObjectRaw (interpreter, 985 "settings append", 986 "Append a new value to the end of an internal debugger settings array, dictionary or string variable.", 987 NULL) 988 { 989 CommandArgumentEntry arg1; 990 CommandArgumentEntry arg2; 991 CommandArgumentData var_name_arg; 992 CommandArgumentData value_arg; 993 994 // Define the first (and only) variant of this arg. 995 var_name_arg.arg_type = eArgTypeSettingVariableName; 996 var_name_arg.arg_repetition = eArgRepeatPlain; 997 998 // There is only one variant this argument could be; put it into the argument entry. 999 arg1.push_back (var_name_arg); 1000 1001 // Define the first (and only) variant of this arg. 1002 value_arg.arg_type = eArgTypeValue; 1003 value_arg.arg_repetition = eArgRepeatPlain; 1004 1005 // There is only one variant this argument could be; put it into the argument entry. 1006 arg2.push_back (value_arg); 1007 1008 // Push the data for the first argument into the m_arguments vector. 1009 m_arguments.push_back (arg1); 1010 m_arguments.push_back (arg2); 1011 } 1012 1013 virtual 1014 ~CommandObjectSettingsAppend () {} 1015 1016 // Overrides base class's behavior where WantsCompletion = !WantsRawCommandString. 1017 virtual bool 1018 WantsCompletion() { return true; } 1019 1020 virtual int 1021 HandleArgumentCompletion (Args &input, 1022 int &cursor_index, 1023 int &cursor_char_position, 1024 OptionElementVector &opt_element_vector, 1025 int match_start_point, 1026 int max_return_elements, 1027 bool &word_complete, 1028 StringList &matches) 1029 { 1030 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 1031 1032 // Attempting to complete variable name 1033 if (cursor_index < 2) 1034 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 1035 CommandCompletions::eSettingsNameCompletion, 1036 completion_str.c_str(), 1037 match_start_point, 1038 max_return_elements, 1039 NULL, 1040 word_complete, 1041 matches); 1042 1043 return matches.GetSize(); 1044 } 1045 1046 protected: 1047 virtual bool 1048 DoExecute (const char *command, CommandReturnObject &result) 1049 { 1050 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1051 Args cmd_args(command); 1052 const size_t argc = cmd_args.GetArgumentCount (); 1053 1054 if (argc < 2) 1055 { 1056 result.AppendError ("'settings append' takes more arguments"); 1057 result.SetStatus (eReturnStatusFailed); 1058 return false; 1059 } 1060 1061 const char *var_name = cmd_args.GetArgumentAtIndex (0); 1062 if ((var_name == NULL) || (var_name[0] == '\0')) 1063 { 1064 result.AppendError ("'settings append' command requires a valid variable name; No value supplied"); 1065 result.SetStatus (eReturnStatusFailed); 1066 return false; 1067 } 1068 1069 // Do not perform cmd_args.Shift() since StringRef is manipulating the 1070 // raw character string later on. 1071 1072 // Split the raw command into var_name and value pair. 1073 llvm::StringRef raw_str(command); 1074 std::string var_value_string = raw_str.split(var_name).second.str(); 1075 const char *var_value_cstr = Args::StripSpaces(var_value_string, true, true, false); 1076 1077 Error error(m_interpreter.GetDebugger().SetPropertyValue (&m_exe_ctx, 1078 eVarSetOperationAppend, 1079 var_name, 1080 var_value_cstr)); 1081 if (error.Fail()) 1082 { 1083 result.AppendError (error.AsCString()); 1084 result.SetStatus (eReturnStatusFailed); 1085 return false; 1086 } 1087 1088 return result.Succeeded(); 1089 } 1090 }; 1091 1092 //------------------------------------------------------------------------- 1093 // CommandObjectSettingsClear 1094 //------------------------------------------------------------------------- 1095 1096 class CommandObjectSettingsClear : public CommandObjectParsed 1097 { 1098 public: 1099 CommandObjectSettingsClear (CommandInterpreter &interpreter) : 1100 CommandObjectParsed (interpreter, 1101 "settings clear", 1102 "Erase all the contents of an internal debugger settings variables; this is only valid for variables with clearable types, i.e. strings, arrays or dictionaries.", 1103 NULL) 1104 { 1105 CommandArgumentEntry arg; 1106 CommandArgumentData var_name_arg; 1107 1108 // Define the first (and only) variant of this arg. 1109 var_name_arg.arg_type = eArgTypeSettingVariableName; 1110 var_name_arg.arg_repetition = eArgRepeatPlain; 1111 1112 // There is only one variant this argument could be; put it into the argument entry. 1113 arg.push_back (var_name_arg); 1114 1115 // Push the data for the first argument into the m_arguments vector. 1116 m_arguments.push_back (arg); 1117 } 1118 1119 virtual 1120 ~CommandObjectSettingsClear () {} 1121 1122 virtual int 1123 HandleArgumentCompletion (Args &input, 1124 int &cursor_index, 1125 int &cursor_char_position, 1126 OptionElementVector &opt_element_vector, 1127 int match_start_point, 1128 int max_return_elements, 1129 bool &word_complete, 1130 StringList &matches) 1131 { 1132 std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position); 1133 1134 // Attempting to complete variable name 1135 if (cursor_index < 2) 1136 CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter, 1137 CommandCompletions::eSettingsNameCompletion, 1138 completion_str.c_str(), 1139 match_start_point, 1140 max_return_elements, 1141 NULL, 1142 word_complete, 1143 matches); 1144 1145 return matches.GetSize(); 1146 } 1147 1148 protected: 1149 virtual bool 1150 DoExecute (Args& command, CommandReturnObject &result) 1151 { 1152 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1153 const size_t argc = command.GetArgumentCount (); 1154 1155 if (argc != 1) 1156 { 1157 result.AppendError ("'setttings clear' takes exactly one argument"); 1158 result.SetStatus (eReturnStatusFailed); 1159 return false; 1160 } 1161 1162 const char *var_name = command.GetArgumentAtIndex (0); 1163 if ((var_name == NULL) || (var_name[0] == '\0')) 1164 { 1165 result.AppendError ("'settings clear' command requires a valid variable name; No value supplied"); 1166 result.SetStatus (eReturnStatusFailed); 1167 return false; 1168 } 1169 1170 Error error (m_interpreter.GetDebugger().SetPropertyValue (&m_exe_ctx, 1171 eVarSetOperationClear, 1172 var_name, 1173 NULL)); 1174 if (error.Fail()) 1175 { 1176 result.AppendError (error.AsCString()); 1177 result.SetStatus (eReturnStatusFailed); 1178 return false; 1179 } 1180 1181 return result.Succeeded(); 1182 } 1183 }; 1184 1185 //------------------------------------------------------------------------- 1186 // CommandObjectMultiwordSettings 1187 //------------------------------------------------------------------------- 1188 1189 CommandObjectMultiwordSettings::CommandObjectMultiwordSettings (CommandInterpreter &interpreter) : 1190 CommandObjectMultiword (interpreter, 1191 "settings", 1192 "A set of commands for manipulating internal settable debugger variables.", 1193 "settings <command> [<command-options>]") 1194 { 1195 LoadSubCommand ("set", CommandObjectSP (new CommandObjectSettingsSet (interpreter))); 1196 LoadSubCommand ("show", CommandObjectSP (new CommandObjectSettingsShow (interpreter))); 1197 LoadSubCommand ("list", CommandObjectSP (new CommandObjectSettingsList (interpreter))); 1198 LoadSubCommand ("remove", CommandObjectSP (new CommandObjectSettingsRemove (interpreter))); 1199 LoadSubCommand ("replace", CommandObjectSP (new CommandObjectSettingsReplace (interpreter))); 1200 LoadSubCommand ("insert-before", CommandObjectSP (new CommandObjectSettingsInsertBefore (interpreter))); 1201 LoadSubCommand ("insert-after", CommandObjectSP (new CommandObjectSettingsInsertAfter (interpreter))); 1202 LoadSubCommand ("append", CommandObjectSP (new CommandObjectSettingsAppend (interpreter))); 1203 LoadSubCommand ("clear", CommandObjectSP (new CommandObjectSettingsClear (interpreter))); 1204 } 1205 1206 CommandObjectMultiwordSettings::~CommandObjectMultiwordSettings () 1207 { 1208 } 1209
