1 //===-- CommandObjectType.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 "CommandObjectType.h" 13 14 // C Includes 15 16 #include <ctype.h> 17 18 // C++ Includes 19 20 #include "lldb/Core/ConstString.h" 21 #include "lldb/Core/Debugger.h" 22 #include "lldb/Core/InputReaderEZ.h" 23 #include "lldb/Core/RegularExpression.h" 24 #include "lldb/Core/State.h" 25 #include "lldb/Core/StringList.h" 26 #include "lldb/DataFormatters/DataVisualization.h" 27 #include "lldb/Interpreter/CommandInterpreter.h" 28 #include "lldb/Interpreter/CommandObject.h" 29 #include "lldb/Interpreter/CommandReturnObject.h" 30 #include "lldb/Interpreter/Options.h" 31 #include "lldb/Interpreter/OptionGroupFormat.h" 32 33 using namespace lldb; 34 using namespace lldb_private; 35 36 37 class ScriptAddOptions 38 { 39 40 public: 41 42 TypeSummaryImpl::Flags m_flags; 43 44 StringList m_target_types; 45 StringList m_user_source; 46 47 bool m_regex; 48 49 ConstString m_name; 50 51 std::string m_category; 52 53 ScriptAddOptions(const TypeSummaryImpl::Flags& flags, 54 bool regx, 55 const ConstString& name, 56 std::string catg) : 57 m_flags(flags), 58 m_regex(regx), 59 m_name(name), 60 m_category(catg) 61 { 62 } 63 64 typedef std::shared_ptr<ScriptAddOptions> SharedPointer; 65 66 }; 67 68 class SynthAddOptions 69 { 70 71 public: 72 73 bool m_skip_pointers; 74 bool m_skip_references; 75 bool m_cascade; 76 bool m_regex; 77 StringList m_user_source; 78 StringList m_target_types; 79 80 std::string m_category; 81 82 SynthAddOptions(bool sptr, 83 bool sref, 84 bool casc, 85 bool regx, 86 std::string catg) : 87 m_skip_pointers(sptr), 88 m_skip_references(sref), 89 m_cascade(casc), 90 m_regex(regx), 91 m_user_source(), 92 m_target_types(), 93 m_category(catg) 94 { 95 } 96 97 typedef std::shared_ptr<SynthAddOptions> SharedPointer; 98 99 }; 100 101 102 103 class CommandObjectTypeSummaryAdd : public CommandObjectParsed 104 { 105 106 private: 107 108 class CommandOptions : public Options 109 { 110 public: 111 112 CommandOptions (CommandInterpreter &interpreter) : 113 Options (interpreter) 114 { 115 } 116 117 virtual 118 ~CommandOptions (){} 119 120 virtual Error 121 SetOptionValue (uint32_t option_idx, const char *option_arg); 122 123 void 124 OptionParsingStarting (); 125 126 const OptionDefinition* 127 GetDefinitions () 128 { 129 return g_option_table; 130 } 131 132 // Options table: Required for subclasses of Options. 133 134 static OptionDefinition g_option_table[]; 135 136 // Instance variables to hold the values for command options. 137 138 TypeSummaryImpl::Flags m_flags; 139 bool m_regex; 140 std::string m_format_string; 141 ConstString m_name; 142 std::string m_python_script; 143 std::string m_python_function; 144 bool m_is_add_script; 145 std::string m_category; 146 }; 147 148 CommandOptions m_options; 149 150 virtual Options * 151 GetOptions () 152 { 153 return &m_options; 154 } 155 156 void 157 CollectPythonScript(ScriptAddOptions *options, 158 CommandReturnObject &result); 159 160 bool 161 Execute_ScriptSummary (Args& command, CommandReturnObject &result); 162 163 bool 164 Execute_StringSummary (Args& command, CommandReturnObject &result); 165 166 public: 167 168 enum SummaryFormatType 169 { 170 eRegularSummary, 171 eRegexSummary, 172 eNamedSummary 173 }; 174 175 CommandObjectTypeSummaryAdd (CommandInterpreter &interpreter); 176 177 ~CommandObjectTypeSummaryAdd () 178 { 179 } 180 181 static bool 182 AddSummary(ConstString type_name, 183 lldb::TypeSummaryImplSP entry, 184 SummaryFormatType type, 185 std::string category, 186 Error* error = NULL); 187 protected: 188 bool 189 DoExecute (Args& command, CommandReturnObject &result); 190 191 }; 192 193 class CommandObjectTypeSynthAdd : public CommandObjectParsed 194 { 195 196 private: 197 198 class CommandOptions : public Options 199 { 200 public: 201 202 CommandOptions (CommandInterpreter &interpreter) : 203 Options (interpreter) 204 { 205 } 206 207 virtual 208 ~CommandOptions (){} 209 210 virtual Error 211 SetOptionValue (uint32_t option_idx, const char *option_arg) 212 { 213 Error error; 214 const int short_option = m_getopt_table[option_idx].val; 215 bool success; 216 217 switch (short_option) 218 { 219 case 'C': 220 m_cascade = Args::StringToBoolean(option_arg, true, &success); 221 if (!success) 222 error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg); 223 break; 224 case 'P': 225 handwrite_python = true; 226 break; 227 case 'l': 228 m_class_name = std::string(option_arg); 229 is_class_based = true; 230 break; 231 case 'p': 232 m_skip_pointers = true; 233 break; 234 case 'r': 235 m_skip_references = true; 236 break; 237 case 'w': 238 m_category = std::string(option_arg); 239 break; 240 case 'x': 241 m_regex = true; 242 break; 243 default: 244 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 245 break; 246 } 247 248 return error; 249 } 250 251 void 252 OptionParsingStarting () 253 { 254 m_cascade = true; 255 m_class_name = ""; 256 m_skip_pointers = false; 257 m_skip_references = false; 258 m_category = "default"; 259 is_class_based = false; 260 handwrite_python = false; 261 m_regex = false; 262 } 263 264 const OptionDefinition* 265 GetDefinitions () 266 { 267 return g_option_table; 268 } 269 270 // Options table: Required for subclasses of Options. 271 272 static OptionDefinition g_option_table[]; 273 274 // Instance variables to hold the values for command options. 275 276 bool m_cascade; 277 bool m_skip_references; 278 bool m_skip_pointers; 279 std::string m_class_name; 280 bool m_input_python; 281 std::string m_category; 282 283 bool is_class_based; 284 285 bool handwrite_python; 286 287 bool m_regex; 288 289 }; 290 291 CommandOptions m_options; 292 293 virtual Options * 294 GetOptions () 295 { 296 return &m_options; 297 } 298 299 void 300 CollectPythonScript (SynthAddOptions *options, 301 CommandReturnObject &result); 302 bool 303 Execute_HandwritePython (Args& command, CommandReturnObject &result); 304 305 bool 306 Execute_PythonClass (Args& command, CommandReturnObject &result); 307 308 protected: 309 bool 310 DoExecute (Args& command, CommandReturnObject &result); 311 312 public: 313 314 enum SynthFormatType 315 { 316 eRegularSynth, 317 eRegexSynth 318 }; 319 320 CommandObjectTypeSynthAdd (CommandInterpreter &interpreter); 321 322 ~CommandObjectTypeSynthAdd () 323 { 324 } 325 326 static bool 327 AddSynth(ConstString type_name, 328 lldb::SyntheticChildrenSP entry, 329 SynthFormatType type, 330 std::string category_name, 331 Error* error); 332 }; 333 334 //------------------------------------------------------------------------- 335 // CommandObjectTypeFormatAdd 336 //------------------------------------------------------------------------- 337 338 class CommandObjectTypeFormatAdd : public CommandObjectParsed 339 { 340 341 private: 342 343 class CommandOptions : public OptionGroup 344 { 345 public: 346 347 CommandOptions () : 348 OptionGroup() 349 { 350 } 351 352 virtual 353 ~CommandOptions () 354 { 355 } 356 357 virtual uint32_t 358 GetNumDefinitions (); 359 360 virtual const OptionDefinition* 361 GetDefinitions () 362 { 363 return g_option_table; 364 } 365 366 virtual void 367 OptionParsingStarting (CommandInterpreter &interpreter) 368 { 369 m_cascade = true; 370 m_skip_pointers = false; 371 m_skip_references = false; 372 } 373 virtual Error 374 SetOptionValue (CommandInterpreter &interpreter, 375 uint32_t option_idx, 376 const char *option_value) 377 { 378 Error error; 379 const int short_option = g_option_table[option_idx].short_option; 380 bool success; 381 382 switch (short_option) 383 { 384 case 'C': 385 m_cascade = Args::StringToBoolean(option_value, true, &success); 386 if (!success) 387 error.SetErrorStringWithFormat("invalid value for cascade: %s", option_value); 388 break; 389 case 'p': 390 m_skip_pointers = true; 391 break; 392 case 'r': 393 m_skip_references = true; 394 break; 395 default: 396 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 397 break; 398 } 399 400 return error; 401 } 402 403 // Options table: Required for subclasses of Options. 404 405 static OptionDefinition g_option_table[]; 406 407 // Instance variables to hold the values for command options. 408 409 bool m_cascade; 410 bool m_skip_references; 411 bool m_skip_pointers; 412 }; 413 414 OptionGroupOptions m_option_group; 415 OptionGroupFormat m_format_options; 416 CommandOptions m_command_options; 417 418 virtual Options * 419 GetOptions () 420 { 421 return &m_option_group; 422 } 423 424 public: 425 CommandObjectTypeFormatAdd (CommandInterpreter &interpreter) : 426 CommandObjectParsed (interpreter, 427 "type format add", 428 "Add a new formatting style for a type.", 429 NULL), 430 m_option_group (interpreter), 431 m_format_options (eFormatInvalid), 432 m_command_options () 433 { 434 CommandArgumentEntry type_arg; 435 CommandArgumentData type_style_arg; 436 437 type_style_arg.arg_type = eArgTypeName; 438 type_style_arg.arg_repetition = eArgRepeatPlus; 439 440 type_arg.push_back (type_style_arg); 441 442 m_arguments.push_back (type_arg); 443 444 SetHelpLong( 445 "Some examples of using this command.\n" 446 "We use as reference the following snippet of code:\n" 447 "\n" 448 "typedef int Aint;\n" 449 "typedef float Afloat;\n" 450 "typedef Aint Bint;\n" 451 "typedef Afloat Bfloat;\n" 452 "\n" 453 "Aint ix = 5;\n" 454 "Bint iy = 5;\n" 455 "\n" 456 "Afloat fx = 3.14;\n" 457 "BFloat fy = 3.14;\n" 458 "\n" 459 "Typing:\n" 460 "type format add -f hex AInt\n" 461 "frame variable iy\n" 462 "will produce an hex display of iy, because no formatter is available for Bint and the one for Aint is used instead\n" 463 "To prevent this type\n" 464 "type format add -f hex -C no AInt\n" 465 "\n" 466 "A similar reasoning applies to\n" 467 "type format add -f hex -C no float -p\n" 468 "which now prints all floats and float&s as hexadecimal, but does not format float*s\n" 469 "and does not change the default display for Afloat and Bfloat objects.\n" 470 ); 471 472 // Add the "--format" to all options groups 473 m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT, LLDB_OPT_SET_ALL); 474 m_option_group.Append (&m_command_options); 475 m_option_group.Finalize(); 476 477 } 478 479 ~CommandObjectTypeFormatAdd () 480 { 481 } 482 483 protected: 484 bool 485 DoExecute (Args& command, CommandReturnObject &result) 486 { 487 const size_t argc = command.GetArgumentCount(); 488 489 if (argc < 1) 490 { 491 result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str()); 492 result.SetStatus(eReturnStatusFailed); 493 return false; 494 } 495 496 const Format format = m_format_options.GetFormat(); 497 if (format == eFormatInvalid) 498 { 499 result.AppendErrorWithFormat ("%s needs a valid format.\n", m_cmd_name.c_str()); 500 result.SetStatus(eReturnStatusFailed); 501 return false; 502 } 503 504 TypeFormatImplSP entry; 505 506 entry.reset(new TypeFormatImpl(format, 507 TypeFormatImpl::Flags().SetCascades(m_command_options.m_cascade). 508 SetSkipPointers(m_command_options.m_skip_pointers). 509 SetSkipReferences(m_command_options.m_skip_references))); 510 511 // now I have a valid format, let's add it to every type 512 513 for (size_t i = 0; i < argc; i++) 514 { 515 const char* typeA = command.GetArgumentAtIndex(i); 516 ConstString typeCS(typeA); 517 if (typeCS) 518 DataVisualization::ValueFormats::Add(typeCS, entry); 519 else 520 { 521 result.AppendError("empty typenames not allowed"); 522 result.SetStatus(eReturnStatusFailed); 523 return false; 524 } 525 } 526 527 result.SetStatus(eReturnStatusSuccessFinishNoResult); 528 return result.Succeeded(); 529 } 530 }; 531 532 OptionDefinition 533 CommandObjectTypeFormatAdd::CommandOptions::g_option_table[] = 534 { 535 { LLDB_OPT_SET_ALL, false, "cascade", 'C', required_argument, NULL, 0, eArgTypeBoolean, "If true, cascade through typedef chains."}, 536 { LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."}, 537 { LLDB_OPT_SET_ALL, false, "skip-references", 'r', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for references-to-type objects."}, 538 }; 539 540 541 uint32_t 542 CommandObjectTypeFormatAdd::CommandOptions::GetNumDefinitions () 543 { 544 return sizeof(g_option_table) / sizeof (OptionDefinition); 545 } 546 547 548 //------------------------------------------------------------------------- 549 // CommandObjectTypeFormatDelete 550 //------------------------------------------------------------------------- 551 552 class CommandObjectTypeFormatDelete : public CommandObjectParsed 553 { 554 public: 555 CommandObjectTypeFormatDelete (CommandInterpreter &interpreter) : 556 CommandObjectParsed (interpreter, 557 "type format delete", 558 "Delete an existing formatting style for a type.", 559 NULL) 560 { 561 CommandArgumentEntry type_arg; 562 CommandArgumentData type_style_arg; 563 564 type_style_arg.arg_type = eArgTypeName; 565 type_style_arg.arg_repetition = eArgRepeatPlain; 566 567 type_arg.push_back (type_style_arg); 568 569 m_arguments.push_back (type_arg); 570 571 } 572 573 ~CommandObjectTypeFormatDelete () 574 { 575 } 576 577 protected: 578 bool 579 DoExecute (Args& command, CommandReturnObject &result) 580 { 581 const size_t argc = command.GetArgumentCount(); 582 583 if (argc != 1) 584 { 585 result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); 586 result.SetStatus(eReturnStatusFailed); 587 return false; 588 } 589 590 const char* typeA = command.GetArgumentAtIndex(0); 591 ConstString typeCS(typeA); 592 593 if (!typeCS) 594 { 595 result.AppendError("empty typenames not allowed"); 596 result.SetStatus(eReturnStatusFailed); 597 return false; 598 } 599 600 601 if (DataVisualization::ValueFormats::Delete(typeCS)) 602 { 603 result.SetStatus(eReturnStatusSuccessFinishNoResult); 604 return result.Succeeded(); 605 } 606 else 607 { 608 result.AppendErrorWithFormat ("no custom format for %s.\n", typeA); 609 result.SetStatus(eReturnStatusFailed); 610 return false; 611 } 612 613 } 614 615 }; 616 617 //------------------------------------------------------------------------- 618 // CommandObjectTypeFormatClear 619 //------------------------------------------------------------------------- 620 621 class CommandObjectTypeFormatClear : public CommandObjectParsed 622 { 623 public: 624 CommandObjectTypeFormatClear (CommandInterpreter &interpreter) : 625 CommandObjectParsed (interpreter, 626 "type format clear", 627 "Delete all existing format styles.", 628 NULL) 629 { 630 } 631 632 ~CommandObjectTypeFormatClear () 633 { 634 } 635 636 protected: 637 bool 638 DoExecute (Args& command, CommandReturnObject &result) 639 { 640 DataVisualization::ValueFormats::Clear(); 641 result.SetStatus(eReturnStatusSuccessFinishResult); 642 return result.Succeeded(); 643 } 644 645 }; 646 647 //------------------------------------------------------------------------- 648 // CommandObjectTypeFormatList 649 //------------------------------------------------------------------------- 650 651 bool CommandObjectTypeFormatList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeFormatImplSP& entry); 652 653 class CommandObjectTypeFormatList; 654 655 struct CommandObjectTypeFormatList_LoopCallbackParam { 656 CommandObjectTypeFormatList* self; 657 CommandReturnObject* result; 658 RegularExpression* regex; 659 CommandObjectTypeFormatList_LoopCallbackParam(CommandObjectTypeFormatList* S, CommandReturnObject* R, 660 RegularExpression* X = NULL) : self(S), result(R), regex(X) {} 661 }; 662 663 class CommandObjectTypeFormatList : public CommandObjectParsed 664 { 665 public: 666 CommandObjectTypeFormatList (CommandInterpreter &interpreter) : 667 CommandObjectParsed (interpreter, 668 "type format list", 669 "Show a list of current formatting styles.", 670 NULL) 671 { 672 CommandArgumentEntry type_arg; 673 CommandArgumentData type_style_arg; 674 675 type_style_arg.arg_type = eArgTypeName; 676 type_style_arg.arg_repetition = eArgRepeatOptional; 677 678 type_arg.push_back (type_style_arg); 679 680 m_arguments.push_back (type_arg); 681 } 682 683 ~CommandObjectTypeFormatList () 684 { 685 } 686 687 protected: 688 bool 689 DoExecute (Args& command, CommandReturnObject &result) 690 { 691 const size_t argc = command.GetArgumentCount(); 692 693 CommandObjectTypeFormatList_LoopCallbackParam *param; 694 695 if (argc == 1) 696 { 697 RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); 698 regex->Compile(command.GetArgumentAtIndex(0)); 699 param = new CommandObjectTypeFormatList_LoopCallbackParam(this,&result,regex); 700 } 701 else 702 param = new CommandObjectTypeFormatList_LoopCallbackParam(this,&result); 703 DataVisualization::ValueFormats::LoopThrough(CommandObjectTypeFormatList_LoopCallback, param); 704 delete param; 705 result.SetStatus(eReturnStatusSuccessFinishResult); 706 return result.Succeeded(); 707 } 708 709 private: 710 711 bool 712 LoopCallback (ConstString type, 713 const lldb::TypeFormatImplSP& entry, 714 RegularExpression* regex, 715 CommandReturnObject *result) 716 { 717 if (regex == NULL || regex->Execute(type.AsCString())) 718 { 719 result->GetOutputStream().Printf ("%s: %s\n", type.AsCString(), 720 entry->GetDescription().c_str()); 721 } 722 return true; 723 } 724 725 friend bool CommandObjectTypeFormatList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeFormatImplSP& entry); 726 727 }; 728 729 bool 730 CommandObjectTypeFormatList_LoopCallback ( 731 void* pt2self, 732 ConstString type, 733 const lldb::TypeFormatImplSP& entry) 734 { 735 CommandObjectTypeFormatList_LoopCallbackParam* param = (CommandObjectTypeFormatList_LoopCallbackParam*)pt2self; 736 return param->self->LoopCallback(type, entry, param->regex, param->result); 737 } 738 739 740 #ifndef LLDB_DISABLE_PYTHON 741 742 //------------------------------------------------------------------------- 743 // CommandObjectTypeSummaryAdd 744 //------------------------------------------------------------------------- 745 746 static const char *g_summary_addreader_instructions = "Enter your Python command(s). Type 'DONE' to end.\n" 747 "def function (valobj,internal_dict):\n" 748 " \"\"\"valobj: an SBValue which you want to provide a summary for\n" 749 " internal_dict: an LLDB support object not to be used\"\"\""; 750 751 class TypeScriptAddInputReader : public InputReaderEZ 752 { 753 private: 754 DISALLOW_COPY_AND_ASSIGN (TypeScriptAddInputReader); 755 public: 756 TypeScriptAddInputReader(Debugger& debugger) : 757 InputReaderEZ(debugger) 758 {} 759 760 virtual 761 ~TypeScriptAddInputReader() 762 { 763 } 764 765 virtual void ActivateHandler(HandlerData& data) 766 { 767 StreamSP out_stream = data.reader.GetDebugger().GetAsyncOutputStream(); 768 bool batch_mode = data.reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode(); 769 if (!batch_mode) 770 { 771 out_stream->Printf ("%s\n", g_summary_addreader_instructions); 772 if (data.reader.GetPrompt()) 773 out_stream->Printf ("%s", data.reader.GetPrompt()); 774 out_stream->Flush(); 775 } 776 } 777 778 virtual void ReactivateHandler(HandlerData& data) 779 { 780 StreamSP out_stream = data.reader.GetDebugger().GetAsyncOutputStream(); 781 bool batch_mode = data.reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode(); 782 if (data.reader.GetPrompt() && !batch_mode) 783 { 784 out_stream->Printf ("%s", data.reader.GetPrompt()); 785 out_stream->Flush(); 786 } 787 } 788 virtual void GotTokenHandler(HandlerData& data) 789 { 790 StreamSP out_stream = data.reader.GetDebugger().GetAsyncOutputStream(); 791 bool batch_mode = data.reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode(); 792 if (data.bytes && data.bytes_len && data.baton) 793 { 794 ((ScriptAddOptions*)data.baton)->m_user_source.AppendString(data.bytes, data.bytes_len); 795 } 796 if (!data.reader.IsDone() && data.reader.GetPrompt() && !batch_mode) 797 { 798 out_stream->Printf ("%s", data.reader.GetPrompt()); 799 out_stream->Flush(); 800 } 801 } 802 virtual void InterruptHandler(HandlerData& data) 803 { 804 StreamSP out_stream = data.reader.GetDebugger().GetAsyncOutputStream(); 805 bool batch_mode = data.reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode(); 806 data.reader.SetIsDone (true); 807 if (!batch_mode) 808 { 809 out_stream->Printf ("Warning: No command attached to breakpoint.\n"); 810 out_stream->Flush(); 811 } 812 } 813 virtual void EOFHandler(HandlerData& data) 814 { 815 data.reader.SetIsDone (true); 816 } 817 virtual void DoneHandler(HandlerData& data) 818 { 819 StreamSP out_stream = data.reader.GetDebugger().GetAsyncOutputStream(); 820 ScriptAddOptions *options_ptr = ((ScriptAddOptions*)data.baton); 821 if (!options_ptr) 822 { 823 out_stream->Printf ("internal synchronization information missing or invalid.\n"); 824 out_stream->Flush(); 825 return; 826 } 827 828 ScriptAddOptions::SharedPointer options(options_ptr); // this will ensure that we get rid of the pointer when going out of scope 829 830 ScriptInterpreter *interpreter = data.reader.GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 831 if (!interpreter) 832 { 833 out_stream->Printf ("no script interpreter.\n"); 834 out_stream->Flush(); 835 return; 836 } 837 std::string funct_name_str; 838 if (!interpreter->GenerateTypeScriptFunction (options->m_user_source, 839 funct_name_str)) 840 { 841 out_stream->Printf ("unable to generate a function.\n"); 842 out_stream->Flush(); 843 return; 844 } 845 if (funct_name_str.empty()) 846 { 847 out_stream->Printf ("unable to obtain a valid function name from the script interpreter.\n"); 848 out_stream->Flush(); 849 return; 850 } 851 // now I have a valid function name, let's add this as script for every type in the list 852 853 TypeSummaryImplSP script_format; 854 script_format.reset(new ScriptSummaryFormat(options->m_flags, 855 funct_name_str.c_str(), 856 options->m_user_source.CopyList(" ").c_str())); 857 858 Error error; 859 860 for (size_t i = 0; i < options->m_target_types.GetSize(); i++) 861 { 862 const char *type_name = options->m_target_types.GetStringAtIndex(i); 863 CommandObjectTypeSummaryAdd::AddSummary(ConstString(type_name), 864 script_format, 865 (options->m_regex ? CommandObjectTypeSummaryAdd::eRegexSummary : CommandObjectTypeSummaryAdd::eRegularSummary), 866 options->m_category, 867 &error); 868 if (error.Fail()) 869 { 870 out_stream->Printf ("%s", error.AsCString()); 871 out_stream->Flush(); 872 return; 873 } 874 } 875 876 if (options->m_name) 877 { 878 CommandObjectTypeSummaryAdd::AddSummary (options->m_name, 879 script_format, 880 CommandObjectTypeSummaryAdd::eNamedSummary, 881 options->m_category, 882 &error); 883 if (error.Fail()) 884 { 885 CommandObjectTypeSummaryAdd::AddSummary (options->m_name, 886 script_format, 887 CommandObjectTypeSummaryAdd::eNamedSummary, 888 options->m_category, 889 &error); 890 if (error.Fail()) 891 { 892 out_stream->Printf ("%s", error.AsCString()); 893 out_stream->Flush(); 894 return; 895 } 896 } 897 else 898 { 899 out_stream->Printf ("%s", error.AsCString()); 900 out_stream->Flush(); 901 return; 902 } 903 } 904 else 905 { 906 if (error.AsCString()) 907 { 908 out_stream->PutCString (error.AsCString()); 909 out_stream->Flush(); 910 } 911 return; 912 } 913 } 914 }; 915 916 #endif // #ifndef LLDB_DISABLE_PYTHON 917 918 Error 919 CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg) 920 { 921 Error error; 922 const int short_option = m_getopt_table[option_idx].val; 923 bool success; 924 925 switch (short_option) 926 { 927 case 'C': 928 m_flags.SetCascades(Args::StringToBoolean(option_arg, true, &success)); 929 if (!success) 930 error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg); 931 break; 932 case 'e': 933 m_flags.SetDontShowChildren(false); 934 break; 935 case 'v': 936 m_flags.SetDontShowValue(true); 937 break; 938 case 'c': 939 m_flags.SetShowMembersOneLiner(true); 940 break; 941 case 's': 942 m_format_string = std::string(option_arg); 943 break; 944 case 'p': 945 m_flags.SetSkipPointers(true); 946 break; 947 case 'r': 948 m_flags.SetSkipReferences(true); 949 break; 950 case 'x': 951 m_regex = true; 952 break; 953 case 'n': 954 m_name.SetCString(option_arg); 955 break; 956 case 'o': 957 m_python_script = std::string(option_arg); 958 m_is_add_script = true; 959 break; 960 case 'F': 961 m_python_function = std::string(option_arg); 962 m_is_add_script = true; 963 break; 964 case 'P': 965 m_is_add_script = true; 966 break; 967 case 'w': 968 m_category = std::string(option_arg); 969 break; 970 case 'O': 971 m_flags.SetHideItemNames(true); 972 break; 973 default: 974 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 975 break; 976 } 977 978 return error; 979 } 980 981 void 982 CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting () 983 { 984 m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false); 985 m_flags.SetShowMembersOneLiner(false).SetSkipPointers(false).SetSkipReferences(false).SetHideItemNames(false); 986 987 m_regex = false; 988 m_name.Clear(); 989 m_python_script = ""; 990 m_python_function = ""; 991 m_format_string = ""; 992 m_is_add_script = false; 993 m_category = "default"; 994 } 995 996 #ifndef LLDB_DISABLE_PYTHON 997 void 998 CommandObjectTypeSummaryAdd::CollectPythonScript (ScriptAddOptions *options, 999 CommandReturnObject &result) 1000 { 1001 InputReaderSP reader_sp (new TypeScriptAddInputReader(m_interpreter.GetDebugger())); 1002 if (reader_sp && options) 1003 { 1004 1005 InputReaderEZ::InitializationParameters ipr; 1006 1007 Error err (reader_sp->Initialize (ipr.SetBaton(options).SetPrompt(" "))); 1008 if (err.Success()) 1009 { 1010 m_interpreter.GetDebugger().PushInputReader (reader_sp); 1011 result.SetStatus (eReturnStatusSuccessFinishNoResult); 1012 } 1013 else 1014 { 1015 result.AppendError (err.AsCString()); 1016 result.SetStatus (eReturnStatusFailed); 1017 } 1018 } 1019 else 1020 { 1021 result.AppendError("out of memory"); 1022 result.SetStatus (eReturnStatusFailed); 1023 } 1024 } 1025 1026 bool 1027 CommandObjectTypeSummaryAdd::Execute_ScriptSummary (Args& command, CommandReturnObject &result) 1028 { 1029 const size_t argc = command.GetArgumentCount(); 1030 1031 if (argc < 1 && !m_options.m_name) 1032 { 1033 result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str()); 1034 result.SetStatus(eReturnStatusFailed); 1035 return false; 1036 } 1037 1038 TypeSummaryImplSP script_format; 1039 1040 if (!m_options.m_python_function.empty()) // we have a Python function ready to use 1041 { 1042 const char *funct_name = m_options.m_python_function.c_str(); 1043 if (!funct_name || !funct_name[0]) 1044 { 1045 result.AppendError ("function name empty.\n"); 1046 result.SetStatus (eReturnStatusFailed); 1047 return false; 1048 } 1049 1050 std::string code = (" " + m_options.m_python_function + "(valobj,internal_dict)"); 1051 1052 script_format.reset(new ScriptSummaryFormat(m_options.m_flags, 1053 funct_name, 1054 code.c_str())); 1055 1056 ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter(); 1057 1058 if (interpreter && interpreter->CheckObjectExists(funct_name) == false) 1059 result.AppendWarningWithFormat("The provided function \"%s\" does not exist - " 1060 "please define it before attempting to use this summary.\n", 1061 funct_name); 1062 } 1063 else if (!m_options.m_python_script.empty()) // we have a quick 1-line script, just use it 1064 { 1065 ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter(); 1066 if (!interpreter) 1067 { 1068 result.AppendError ("script interpreter missing - unable to generate function wrapper.\n"); 1069 result.SetStatus (eReturnStatusFailed); 1070 return false; 1071 } 1072 StringList funct_sl; 1073 funct_sl << m_options.m_python_script.c_str(); 1074 std::string funct_name_str; 1075 if (!interpreter->GenerateTypeScriptFunction (funct_sl, 1076 funct_name_str)) 1077 { 1078 result.AppendError ("unable to generate function wrapper.\n"); 1079 result.SetStatus (eReturnStatusFailed); 1080 return false; 1081 } 1082 if (funct_name_str.empty()) 1083 { 1084 result.AppendError ("script interpreter failed to generate a valid function name.\n"); 1085 result.SetStatus (eReturnStatusFailed); 1086 return false; 1087 } 1088 1089 std::string code = " " + m_options.m_python_script; 1090 1091 script_format.reset(new ScriptSummaryFormat(m_options.m_flags, 1092 funct_name_str.c_str(), 1093 code.c_str())); 1094 } 1095 else // use an InputReader to grab Python code from the user 1096 { 1097 ScriptAddOptions *options = new ScriptAddOptions(m_options.m_flags, 1098 m_options.m_regex, 1099 m_options.m_name, 1100 m_options.m_category); 1101 1102 for (size_t i = 0; i < argc; i++) 1103 { 1104 const char* typeA = command.GetArgumentAtIndex(i); 1105 if (typeA && *typeA) 1106 options->m_target_types << typeA; 1107 else 1108 { 1109 result.AppendError("empty typenames not allowed"); 1110 result.SetStatus(eReturnStatusFailed); 1111 return false; 1112 } 1113 } 1114 1115 CollectPythonScript(options,result); 1116 return result.Succeeded(); 1117 } 1118 1119 // if I am here, script_format must point to something good, so I can add that 1120 // as a script summary to all interested parties 1121 1122 Error error; 1123 1124 for (size_t i = 0; i < command.GetArgumentCount(); i++) 1125 { 1126 const char *type_name = command.GetArgumentAtIndex(i); 1127 CommandObjectTypeSummaryAdd::AddSummary(ConstString(type_name), 1128 script_format, 1129 (m_options.m_regex ? eRegexSummary : eRegularSummary), 1130 m_options.m_category, 1131 &error); 1132 if (error.Fail()) 1133 { 1134 result.AppendError(error.AsCString()); 1135 result.SetStatus(eReturnStatusFailed); 1136 return false; 1137 } 1138 } 1139 1140 if (m_options.m_name) 1141 { 1142 AddSummary(m_options.m_name, script_format, eNamedSummary, m_options.m_category, &error); 1143 if (error.Fail()) 1144 { 1145 result.AppendError(error.AsCString()); 1146 result.AppendError("added to types, but not given a name"); 1147 result.SetStatus(eReturnStatusFailed); 1148 return false; 1149 } 1150 } 1151 1152 return result.Succeeded(); 1153 } 1154 1155 #endif 1156 1157 1158 bool 1159 CommandObjectTypeSummaryAdd::Execute_StringSummary (Args& command, CommandReturnObject &result) 1160 { 1161 const size_t argc = command.GetArgumentCount(); 1162 1163 if (argc < 1 && !m_options.m_name) 1164 { 1165 result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str()); 1166 result.SetStatus(eReturnStatusFailed); 1167 return false; 1168 } 1169 1170 if (!m_options.m_flags.GetShowMembersOneLiner() && m_options.m_format_string.empty()) 1171 { 1172 result.AppendError("empty summary strings not allowed"); 1173 result.SetStatus(eReturnStatusFailed); 1174 return false; 1175 } 1176 1177 const char* format_cstr = (m_options.m_flags.GetShowMembersOneLiner() ? "" : m_options.m_format_string.c_str()); 1178 1179 // ${var%S} is an endless recursion, prevent it 1180 if (strcmp(format_cstr, "${var%S}") == 0) 1181 { 1182 result.AppendError("recursive summary not allowed"); 1183 result.SetStatus(eReturnStatusFailed); 1184 return false; 1185 } 1186 1187 Error error; 1188 1189 lldb::TypeSummaryImplSP entry(new StringSummaryFormat(m_options.m_flags, 1190 format_cstr)); 1191 1192 if (error.Fail()) 1193 { 1194 result.AppendError(error.AsCString()); 1195 result.SetStatus(eReturnStatusFailed); 1196 return false; 1197 } 1198 1199 // now I have a valid format, let's add it to every type 1200 1201 for (size_t i = 0; i < argc; i++) 1202 { 1203 const char* typeA = command.GetArgumentAtIndex(i); 1204 if (!typeA || typeA[0] == '\0') 1205 { 1206 result.AppendError("empty typenames not allowed"); 1207 result.SetStatus(eReturnStatusFailed); 1208 return false; 1209 } 1210 ConstString typeCS(typeA); 1211 1212 AddSummary(typeCS, 1213 entry, 1214 (m_options.m_regex ? eRegexSummary : eRegularSummary), 1215 m_options.m_category, 1216 &error); 1217 1218 if (error.Fail()) 1219 { 1220 result.AppendError(error.AsCString()); 1221 result.SetStatus(eReturnStatusFailed); 1222 return false; 1223 } 1224 } 1225 1226 if (m_options.m_name) 1227 { 1228 AddSummary(m_options.m_name, entry, eNamedSummary, m_options.m_category, &error); 1229 if (error.Fail()) 1230 { 1231 result.AppendError(error.AsCString()); 1232 result.AppendError("added to types, but not given a name"); 1233 result.SetStatus(eReturnStatusFailed); 1234 return false; 1235 } 1236 } 1237 1238 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1239 return result.Succeeded(); 1240 } 1241 1242 CommandObjectTypeSummaryAdd::CommandObjectTypeSummaryAdd (CommandInterpreter &interpreter) : 1243 CommandObjectParsed (interpreter, 1244 "type summary add", 1245 "Add a new summary style for a type.", 1246 NULL), 1247 m_options (interpreter) 1248 { 1249 CommandArgumentEntry type_arg; 1250 CommandArgumentData type_style_arg; 1251 1252 type_style_arg.arg_type = eArgTypeName; 1253 type_style_arg.arg_repetition = eArgRepeatPlus; 1254 1255 type_arg.push_back (type_style_arg); 1256 1257 m_arguments.push_back (type_arg); 1258 1259 SetHelpLong( 1260 "Some examples of using this command.\n" 1261 "We use as reference the following snippet of code:\n" 1262 "struct JustADemo\n" 1263 "{\n" 1264 "int* ptr;\n" 1265 "float value;\n" 1266 "JustADemo(int p = 1, float v = 0.1) : ptr(new int(p)), value(v) {}\n" 1267 "};\n" 1268 "JustADemo object(42,3.14);\n" 1269 "struct AnotherDemo : public JustADemo\n" 1270 "{\n" 1271 "uint8_t byte;\n" 1272 "AnotherDemo(uint8_t b = 'E', int p = 1, float v = 0.1) : JustADemo(p,v), byte(b) {}\n" 1273 "};\n" 1274 "AnotherDemo *another_object = new AnotherDemo('E',42,3.14);\n" 1275 "\n" 1276 "type summary add --summary-string \"the answer is ${*var.ptr}\" JustADemo\n" 1277 "when typing frame variable object you will get \"the answer is 42\"\n" 1278 "type summary add --summary-string \"the answer is ${*var.ptr}, and the question is ${var.value}\" JustADemo\n" 1279 "when typing frame variable object you will get \"the answer is 42 and the question is 3.14\"\n" 1280 "\n" 1281 "Alternatively, you could also say\n" 1282 "type summary add --summary-string \"${var%V} -> ${*var}\" \"int *\"\n" 1283 "and replace the above summary string with\n" 1284 "type summary add --summary-string \"the answer is ${var.ptr}, and the question is ${var.value}\" JustADemo\n" 1285 "to obtain a similar result\n" 1286 "\n" 1287 "To add a summary valid for both JustADemo and AnotherDemo you can use the scoping operator, as in:\n" 1288 "type summary add --summary-string \"${var.ptr}, ${var.value},{${var.byte}}\" JustADemo -C yes\n" 1289 "\n" 1290 "This will be used for both variables of type JustADemo and AnotherDemo. To prevent this, change the -C to read -C no\n" 1291 "If you do not want pointers to be shown using that summary, you can use the -p option, as in:\n" 1292 "type summary add --summary-string \"${var.ptr}, ${var.value},{${var.byte}}\" JustADemo -C yes -p\n" 1293 "A similar option -r exists for references.\n" 1294 "\n" 1295 "If you simply want a one-line summary of the content of your variable, without typing an explicit string to that effect\n" 1296 "you can use the -c option, without giving any summary string:\n" 1297 "type summary add -c JustADemo\n" 1298 "frame variable object\n" 1299 "the output being similar to (ptr=0xsomeaddress, value=3.14)\n" 1300 "\n" 1301 "If you want to display some summary text, but also expand the structure of your object, you can add the -e option, as in:\n" 1302 "type summary add -e --summary-string \"*ptr = ${*var.ptr}\" JustADemo\n" 1303 "Here the value of the int* is displayed, followed by the standard LLDB sequence of children objects, one per line.\n" 1304 "to get an output like:\n" 1305 "\n" 1306 "*ptr = 42 {\n" 1307 " ptr = 0xsomeaddress\n" 1308 " value = 3.14\n" 1309 "}\n" 1310 "\n" 1311 "You can also add Python summaries, in which case you will use lldb public API to gather information from your variables" 1312 "and elaborate them to a meaningful summary inside a script written in Python. The variable object will be passed to your" 1313 "script as an SBValue object. The following example might help you when starting to use the Python summaries feature:\n" 1314 "type summary add JustADemo -o \"value = valobj.GetChildMemberWithName('value'); return 'My value is ' + value.GetValue();\"\n" 1315 "If you prefer to type your scripts on multiple lines, you will use the -P option and then type your script, ending it with " 1316 "the word DONE on a line by itself to mark you're finished editing your code:\n" 1317 "(lldb)type summary add JustADemo -P\n" 1318 " value = valobj.GetChildMemberWithName('value');\n" 1319 " return 'My value is ' + value.GetValue();\n" 1320 "DONE\n" 1321 "(lldb) <-- type further LLDB commands here\n" 1322 ); 1323 } 1324 1325 bool 1326 CommandObjectTypeSummaryAdd::DoExecute (Args& command, CommandReturnObject &result) 1327 { 1328 if (m_options.m_is_add_script) 1329 { 1330 #ifndef LLDB_DISABLE_PYTHON 1331 return Execute_ScriptSummary(command, result); 1332 #else 1333 result.AppendError ("python is disabled"); 1334 result.SetStatus(eReturnStatusFailed); 1335 return false; 1336 #endif 1337 } 1338 1339 return Execute_StringSummary(command, result); 1340 } 1341 1342 bool 1343 CommandObjectTypeSummaryAdd::AddSummary(ConstString type_name, 1344 TypeSummaryImplSP entry, 1345 SummaryFormatType type, 1346 std::string category_name, 1347 Error* error) 1348 { 1349 lldb::TypeCategoryImplSP category; 1350 DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), category); 1351 1352 if (type == eRegularSummary) 1353 { 1354 std::string type_name_str(type_name.GetCString()); 1355 if (type_name_str.compare(type_name_str.length() - 2, 2, "[]") == 0) 1356 { 1357 type_name_str.resize(type_name_str.length()-2); 1358 if (type_name_str.back() != ' ') 1359 type_name_str.append(" \\[[0-9]+\\]"); 1360 else 1361 type_name_str.append("\\[[0-9]+\\]"); 1362 type_name.SetCString(type_name_str.c_str()); 1363 type = eRegexSummary; 1364 } 1365 } 1366 1367 if (type == eRegexSummary) 1368 { 1369 RegularExpressionSP typeRX(new RegularExpression()); 1370 if (!typeRX->Compile(type_name.GetCString())) 1371 { 1372 if (error) 1373 error->SetErrorString("regex format error (maybe this is not really a regex?)"); 1374 return false; 1375 } 1376 1377 category->GetRegexSummaryNavigator()->Delete(type_name); 1378 category->GetRegexSummaryNavigator()->Add(typeRX, entry); 1379 1380 return true; 1381 } 1382 else if (type == eNamedSummary) 1383 { 1384 // system named summaries do not exist (yet?) 1385 DataVisualization::NamedSummaryFormats::Add(type_name,entry); 1386 return true; 1387 } 1388 else 1389 { 1390 category->GetSummaryNavigator()->Add(type_name, entry); 1391 return true; 1392 } 1393 } 1394 1395 OptionDefinition 1396 CommandObjectTypeSummaryAdd::CommandOptions::g_option_table[] = 1397 { 1398 { LLDB_OPT_SET_ALL, false, "category", 'w', required_argument, NULL, 0, eArgTypeName, "Add this to the given category instead of the default one."}, 1399 { LLDB_OPT_SET_ALL, false, "cascade", 'C', required_argument, NULL, 0, eArgTypeBoolean, "If true, cascade through typedef chains."}, 1400 { LLDB_OPT_SET_ALL, false, "no-value", 'v', no_argument, NULL, 0, eArgTypeNone, "Don't show the value, just show the summary, for this type."}, 1401 { LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."}, 1402 { LLDB_OPT_SET_ALL, false, "skip-references", 'r', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for references-to-type objects."}, 1403 { LLDB_OPT_SET_ALL, false, "regex", 'x', no_argument, NULL, 0, eArgTypeNone, "Type names are actually regular expressions."}, 1404 { LLDB_OPT_SET_1 , true, "inline-children", 'c', no_argument, NULL, 0, eArgTypeNone, "If true, inline all child values into summary string."}, 1405 { LLDB_OPT_SET_1 , false, "omit-names", 'O', no_argument, NULL, 0, eArgTypeNone, "If true, omit value names in the summary display."}, 1406 { LLDB_OPT_SET_2 , true, "summary-string", 's', required_argument, NULL, 0, eArgTypeSummaryString, "Summary string used to display text and object contents."}, 1407 { LLDB_OPT_SET_3, false, "python-script", 'o', required_argument, NULL, 0, eArgTypePythonScript, "Give a one-liner Python script as part of the command."}, 1408 { LLDB_OPT_SET_3, false, "python-function", 'F', required_argument, NULL, 0, eArgTypePythonFunction, "Give the name of a Python function to use for this type."}, 1409 { LLDB_OPT_SET_3, false, "input-python", 'P', no_argument, NULL, 0, eArgTypeNone, "Input Python code to use for this type manually."}, 1410 { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "expand", 'e', no_argument, NULL, 0, eArgTypeNone, "Expand aggregate data types to show children on separate lines."}, 1411 { LLDB_OPT_SET_2 | LLDB_OPT_SET_3, false, "name", 'n', required_argument, NULL, 0, eArgTypeName, "A name for this summary string."}, 1412 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 1413 }; 1414 1415 1416 //------------------------------------------------------------------------- 1417 // CommandObjectTypeSummaryDelete 1418 //------------------------------------------------------------------------- 1419 1420 class CommandObjectTypeSummaryDelete : public CommandObjectParsed 1421 { 1422 private: 1423 class CommandOptions : public Options 1424 { 1425 public: 1426 1427 CommandOptions (CommandInterpreter &interpreter) : 1428 Options (interpreter) 1429 { 1430 } 1431 1432 virtual 1433 ~CommandOptions (){} 1434 1435 virtual Error 1436 SetOptionValue (uint32_t option_idx, const char *option_arg) 1437 { 1438 Error error; 1439 const int short_option = m_getopt_table[option_idx].val; 1440 1441 switch (short_option) 1442 { 1443 case 'a': 1444 m_delete_all = true; 1445 break; 1446 case 'w': 1447 m_category = std::string(option_arg); 1448 break; 1449 default: 1450 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 1451 break; 1452 } 1453 1454 return error; 1455 } 1456 1457 void 1458 OptionParsingStarting () 1459 { 1460 m_delete_all = false; 1461 m_category = "default"; 1462 } 1463 1464 const OptionDefinition* 1465 GetDefinitions () 1466 { 1467 return g_option_table; 1468 } 1469 1470 // Options table: Required for subclasses of Options. 1471 1472 static OptionDefinition g_option_table[]; 1473 1474 // Instance variables to hold the values for command options. 1475 1476 bool m_delete_all; 1477 std::string m_category; 1478 1479 }; 1480 1481 CommandOptions m_options; 1482 1483 virtual Options * 1484 GetOptions () 1485 { 1486 return &m_options; 1487 } 1488 1489 static bool 1490 PerCategoryCallback(void* param, 1491 const lldb::TypeCategoryImplSP& category_sp) 1492 { 1493 ConstString *name = (ConstString*)param; 1494 category_sp->Delete(*name, eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); 1495 return true; 1496 } 1497 1498 public: 1499 CommandObjectTypeSummaryDelete (CommandInterpreter &interpreter) : 1500 CommandObjectParsed (interpreter, 1501 "type summary delete", 1502 "Delete an existing summary style for a type.", 1503 NULL), 1504 m_options(interpreter) 1505 { 1506 CommandArgumentEntry type_arg; 1507 CommandArgumentData type_style_arg; 1508 1509 type_style_arg.arg_type = eArgTypeName; 1510 type_style_arg.arg_repetition = eArgRepeatPlain; 1511 1512 type_arg.push_back (type_style_arg); 1513 1514 m_arguments.push_back (type_arg); 1515 1516 } 1517 1518 ~CommandObjectTypeSummaryDelete () 1519 { 1520 } 1521 1522 protected: 1523 bool 1524 DoExecute (Args& command, CommandReturnObject &result) 1525 { 1526 const size_t argc = command.GetArgumentCount(); 1527 1528 if (argc != 1) 1529 { 1530 result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); 1531 result.SetStatus(eReturnStatusFailed); 1532 return false; 1533 } 1534 1535 const char* typeA = command.GetArgumentAtIndex(0); 1536 ConstString typeCS(typeA); 1537 1538 if (!typeCS) 1539 { 1540 result.AppendError("empty typenames not allowed"); 1541 result.SetStatus(eReturnStatusFailed); 1542 return false; 1543 } 1544 1545 if (m_options.m_delete_all) 1546 { 1547 DataVisualization::Categories::LoopThrough(PerCategoryCallback, &typeCS); 1548 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1549 return result.Succeeded(); 1550 } 1551 1552 lldb::TypeCategoryImplSP category; 1553 DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); 1554 1555 bool delete_category = category->Delete(typeCS, 1556 eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); 1557 bool delete_named = DataVisualization::NamedSummaryFormats::Delete(typeCS); 1558 1559 if (delete_category || delete_named) 1560 { 1561 result.SetStatus(eReturnStatusSuccessFinishNoResult); 1562 return result.Succeeded(); 1563 } 1564 else 1565 { 1566 result.AppendErrorWithFormat ("no custom summary for %s.\n", typeA); 1567 result.SetStatus(eReturnStatusFailed); 1568 return false; 1569 } 1570 1571 } 1572 }; 1573 1574 OptionDefinition 1575 CommandObjectTypeSummaryDelete::CommandOptions::g_option_table[] = 1576 { 1577 { LLDB_OPT_SET_1, false, "all", 'a', no_argument, NULL, 0, eArgTypeNone, "Delete from every category."}, 1578 { LLDB_OPT_SET_2, false, "category", 'w', required_argument, NULL, 0, eArgTypeName, "Delete from given category."}, 1579 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 1580 }; 1581 1582 class CommandObjectTypeSummaryClear : public CommandObjectParsed 1583 { 1584 private: 1585 1586 class CommandOptions : public Options 1587 { 1588 public: 1589 1590 CommandOptions (CommandInterpreter &interpreter) : 1591 Options (interpreter) 1592 { 1593 } 1594 1595 virtual 1596 ~CommandOptions (){} 1597 1598 virtual Error 1599 SetOptionValue (uint32_t option_idx, const char *option_arg) 1600 { 1601 Error error; 1602 const int short_option = m_getopt_table[option_idx].val; 1603 1604 switch (short_option) 1605 { 1606 case 'a': 1607 m_delete_all = true; 1608 break; 1609 default: 1610 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 1611 break; 1612 } 1613 1614 return error; 1615 } 1616 1617 void 1618 OptionParsingStarting () 1619 { 1620 m_delete_all = false; 1621 } 1622 1623 const OptionDefinition* 1624 GetDefinitions () 1625 { 1626 return g_option_table; 1627 } 1628 1629 // Options table: Required for subclasses of Options. 1630 1631 static OptionDefinition g_option_table[]; 1632 1633 // Instance variables to hold the values for command options. 1634 1635 bool m_delete_all; 1636 bool m_delete_named; 1637 }; 1638 1639 CommandOptions m_options; 1640 1641 virtual Options * 1642 GetOptions () 1643 { 1644 return &m_options; 1645 } 1646 1647 static bool 1648 PerCategoryCallback(void* param, 1649 const lldb::TypeCategoryImplSP& cate) 1650 { 1651 cate->GetSummaryNavigator()->Clear(); 1652 cate->GetRegexSummaryNavigator()->Clear(); 1653 return true; 1654 1655 } 1656 1657 public: 1658 CommandObjectTypeSummaryClear (CommandInterpreter &interpreter) : 1659 CommandObjectParsed (interpreter, 1660 "type summary clear", 1661 "Delete all existing summary styles.", 1662 NULL), 1663 m_options(interpreter) 1664 { 1665 } 1666 1667 ~CommandObjectTypeSummaryClear () 1668 { 1669 } 1670 1671 protected: 1672 bool 1673 DoExecute (Args& command, CommandReturnObject &result) 1674 { 1675 1676 if (m_options.m_delete_all) 1677 DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); 1678 1679 else 1680 { 1681 lldb::TypeCategoryImplSP category; 1682 if (command.GetArgumentCount() > 0) 1683 { 1684 const char* cat_name = command.GetArgumentAtIndex(0); 1685 ConstString cat_nameCS(cat_name); 1686 DataVisualization::Categories::GetCategory(cat_nameCS, category); 1687 } 1688 else 1689 DataVisualization::Categories::GetCategory(ConstString(NULL), category); 1690 category->Clear(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); 1691 } 1692 1693 DataVisualization::NamedSummaryFormats::Clear(); 1694 1695 result.SetStatus(eReturnStatusSuccessFinishResult); 1696 return result.Succeeded(); 1697 } 1698 1699 }; 1700 1701 OptionDefinition 1702 CommandObjectTypeSummaryClear::CommandOptions::g_option_table[] = 1703 { 1704 { LLDB_OPT_SET_ALL, false, "all", 'a', no_argument, NULL, 0, eArgTypeNone, "Clear every category."}, 1705 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 1706 }; 1707 1708 //------------------------------------------------------------------------- 1709 // CommandObjectTypeSummaryList 1710 //------------------------------------------------------------------------- 1711 1712 bool CommandObjectTypeSummaryList_LoopCallback(void* pt2self, ConstString type, const StringSummaryFormat::SharedPointer& entry); 1713 bool CommandObjectTypeRXSummaryList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const StringSummaryFormat::SharedPointer& entry); 1714 1715 class CommandObjectTypeSummaryList; 1716 1717 struct CommandObjectTypeSummaryList_LoopCallbackParam { 1718 CommandObjectTypeSummaryList* self; 1719 CommandReturnObject* result; 1720 RegularExpression* regex; 1721 RegularExpression* cate_regex; 1722 CommandObjectTypeSummaryList_LoopCallbackParam(CommandObjectTypeSummaryList* S, CommandReturnObject* R, 1723 RegularExpression* X = NULL, 1724 RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} 1725 }; 1726 1727 class CommandObjectTypeSummaryList : public CommandObjectParsed 1728 { 1729 1730 class CommandOptions : public Options 1731 { 1732 public: 1733 1734 CommandOptions (CommandInterpreter &interpreter) : 1735 Options (interpreter) 1736 { 1737 } 1738 1739 virtual 1740 ~CommandOptions (){} 1741 1742 virtual Error 1743 SetOptionValue (uint32_t option_idx, const char *option_arg) 1744 { 1745 Error error; 1746 const int short_option = m_getopt_table[option_idx].val; 1747 1748 switch (short_option) 1749 { 1750 case 'w': 1751 m_category_regex = std::string(option_arg); 1752 break; 1753 default: 1754 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 1755 break; 1756 } 1757 1758 return error; 1759 } 1760 1761 void 1762 OptionParsingStarting () 1763 { 1764 m_category_regex = ""; 1765 } 1766 1767 const OptionDefinition* 1768 GetDefinitions () 1769 { 1770 return g_option_table; 1771 } 1772 1773 // Options table: Required for subclasses of Options. 1774 1775 static OptionDefinition g_option_table[]; 1776 1777 // Instance variables to hold the values for command options. 1778 1779 std::string m_category_regex; 1780 1781 }; 1782 1783 CommandOptions m_options; 1784 1785 virtual Options * 1786 GetOptions () 1787 { 1788 return &m_options; 1789 } 1790 1791 public: 1792 CommandObjectTypeSummaryList (CommandInterpreter &interpreter) : 1793 CommandObjectParsed (interpreter, 1794 "type summary list", 1795 "Show a list of current summary styles.", 1796 NULL), 1797 m_options(interpreter) 1798 { 1799 CommandArgumentEntry type_arg; 1800 CommandArgumentData type_style_arg; 1801 1802 type_style_arg.arg_type = eArgTypeName; 1803 type_style_arg.arg_repetition = eArgRepeatOptional; 1804 1805 type_arg.push_back (type_style_arg); 1806 1807 m_arguments.push_back (type_arg); 1808 } 1809 1810 ~CommandObjectTypeSummaryList () 1811 { 1812 } 1813 1814 protected: 1815 bool 1816 DoExecute (Args& command, CommandReturnObject &result) 1817 { 1818 const size_t argc = command.GetArgumentCount(); 1819 1820 CommandObjectTypeSummaryList_LoopCallbackParam *param; 1821 RegularExpression* cate_regex = 1822 m_options.m_category_regex.empty() ? NULL : 1823 new RegularExpression(m_options.m_category_regex.c_str()); 1824 1825 if (argc == 1) 1826 { 1827 RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); 1828 regex->Compile(command.GetArgumentAtIndex(0)); 1829 param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,regex,cate_regex); 1830 } 1831 else 1832 param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,NULL,cate_regex); 1833 1834 DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); 1835 1836 if (DataVisualization::NamedSummaryFormats::GetCount() > 0) 1837 { 1838 result.GetOutputStream().Printf("Named summaries:\n"); 1839 if (argc == 1) 1840 { 1841 RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); 1842 regex->Compile(command.GetArgumentAtIndex(0)); 1843 param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result,regex); 1844 } 1845 else 1846 param = new CommandObjectTypeSummaryList_LoopCallbackParam(this,&result); 1847 DataVisualization::NamedSummaryFormats::LoopThrough(CommandObjectTypeSummaryList_LoopCallback, param); 1848 delete param; 1849 } 1850 1851 if (cate_regex) 1852 delete cate_regex; 1853 1854 result.SetStatus(eReturnStatusSuccessFinishResult); 1855 return result.Succeeded(); 1856 } 1857 1858 private: 1859 1860 static bool 1861 PerCategoryCallback(void* param_vp, 1862 const lldb::TypeCategoryImplSP& cate) 1863 { 1864 1865 CommandObjectTypeSummaryList_LoopCallbackParam* param = 1866 (CommandObjectTypeSummaryList_LoopCallbackParam*)param_vp; 1867 CommandReturnObject* result = param->result; 1868 1869 const char* cate_name = cate->GetName(); 1870 1871 // if the category is disabled or empty and there is no regex, just skip it 1872 if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary) == 0) && param->cate_regex == NULL) 1873 return true; 1874 1875 // if we have a regex and this category does not match it, just skip it 1876 if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) 1877 return true; 1878 1879 result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", 1880 cate_name, 1881 (cate->IsEnabled() ? "enabled" : "disabled")); 1882 1883 cate->GetSummaryNavigator()->LoopThrough(CommandObjectTypeSummaryList_LoopCallback, param_vp); 1884 1885 if (cate->GetRegexSummaryNavigator()->GetCount() > 0) 1886 { 1887 result->GetOutputStream().Printf("Regex-based summaries (slower):\n"); 1888 cate->GetRegexSummaryNavigator()->LoopThrough(CommandObjectTypeRXSummaryList_LoopCallback, param_vp); 1889 } 1890 return true; 1891 } 1892 1893 1894 bool 1895 LoopCallback (const char* type, 1896 const lldb::TypeSummaryImplSP& entry, 1897 RegularExpression* regex, 1898 CommandReturnObject *result) 1899 { 1900 if (regex == NULL || strcmp(type,regex->GetText()) == 0 || regex->Execute(type)) 1901 result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); 1902 return true; 1903 } 1904 1905 friend bool CommandObjectTypeSummaryList_LoopCallback(void* pt2self, ConstString type, const lldb::TypeSummaryImplSP& entry); 1906 friend bool CommandObjectTypeRXSummaryList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const lldb::TypeSummaryImplSP& entry); 1907 }; 1908 1909 bool 1910 CommandObjectTypeSummaryList_LoopCallback ( 1911 void* pt2self, 1912 ConstString type, 1913 const lldb::TypeSummaryImplSP& entry) 1914 { 1915 CommandObjectTypeSummaryList_LoopCallbackParam* param = (CommandObjectTypeSummaryList_LoopCallbackParam*)pt2self; 1916 return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); 1917 } 1918 1919 bool 1920 CommandObjectTypeRXSummaryList_LoopCallback ( 1921 void* pt2self, 1922 lldb::RegularExpressionSP regex, 1923 const lldb::TypeSummaryImplSP& entry) 1924 { 1925 CommandObjectTypeSummaryList_LoopCallbackParam* param = (CommandObjectTypeSummaryList_LoopCallbackParam*)pt2self; 1926 return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); 1927 } 1928 1929 OptionDefinition 1930 CommandObjectTypeSummaryList::CommandOptions::g_option_table[] = 1931 { 1932 { LLDB_OPT_SET_ALL, false, "category-regex", 'w', required_argument, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, 1933 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 1934 }; 1935 1936 //------------------------------------------------------------------------- 1937 // CommandObjectTypeCategoryEnable 1938 //------------------------------------------------------------------------- 1939 1940 class CommandObjectTypeCategoryEnable : public CommandObjectParsed 1941 { 1942 public: 1943 CommandObjectTypeCategoryEnable (CommandInterpreter &interpreter) : 1944 CommandObjectParsed (interpreter, 1945 "type category enable", 1946 "Enable a category as a source of formatters.", 1947 NULL) 1948 { 1949 CommandArgumentEntry type_arg; 1950 CommandArgumentData type_style_arg; 1951 1952 type_style_arg.arg_type = eArgTypeName; 1953 type_style_arg.arg_repetition = eArgRepeatPlus; 1954 1955 type_arg.push_back (type_style_arg); 1956 1957 m_arguments.push_back (type_arg); 1958 1959 } 1960 1961 ~CommandObjectTypeCategoryEnable () 1962 { 1963 } 1964 1965 protected: 1966 bool 1967 DoExecute (Args& command, CommandReturnObject &result) 1968 { 1969 const size_t argc = command.GetArgumentCount(); 1970 1971 if (argc < 1) 1972 { 1973 result.AppendErrorWithFormat ("%s takes 1 or more args.\n", m_cmd_name.c_str()); 1974 result.SetStatus(eReturnStatusFailed); 1975 return false; 1976 } 1977 1978 if (argc == 1 && strcmp(command.GetArgumentAtIndex(0),"*") == 0) 1979 { 1980 // we want to make sure to enable "system" last and "default" first 1981 DataVisualization::Categories::Enable(ConstString("default"), TypeCategoryMap::First); 1982 uint32_t num_categories = DataVisualization::Categories::GetCount(); 1983 for (uint32_t i = 0; i < num_categories; i++) 1984 { 1985 lldb::TypeCategoryImplSP category_sp = DataVisualization::Categories::GetCategoryAtIndex(i); 1986 if (category_sp) 1987 { 1988 if ( ::strcmp(category_sp->GetName(), "system") == 0 || 1989 ::strcmp(category_sp->GetName(), "default") == 0 ) 1990 continue; 1991 else 1992 DataVisualization::Categories::Enable(category_sp, TypeCategoryMap::Default); 1993 } 1994 } 1995 DataVisualization::Categories::Enable(ConstString("system"), TypeCategoryMap::Last); 1996 } 1997 else 1998 { 1999 for (int i = argc - 1; i >= 0; i--) 2000 { 2001 const char* typeA = command.GetArgumentAtIndex(i); 2002 ConstString typeCS(typeA); 2003 2004 if (!typeCS) 2005 { 2006 result.AppendError("empty category name not allowed"); 2007 result.SetStatus(eReturnStatusFailed); 2008 return false; 2009 } 2010 DataVisualization::Categories::Enable(typeCS); 2011 lldb::TypeCategoryImplSP cate; 2012 if (DataVisualization::Categories::GetCategory(typeCS, cate) && cate.get()) 2013 { 2014 if (cate->GetCount() == 0) 2015 { 2016 result.AppendWarning("empty category enabled (typo?)"); 2017 } 2018 } 2019 } 2020 } 2021 2022 result.SetStatus(eReturnStatusSuccessFinishResult); 2023 return result.Succeeded(); 2024 } 2025 2026 }; 2027 2028 //------------------------------------------------------------------------- 2029 // CommandObjectTypeCategoryDelete 2030 //------------------------------------------------------------------------- 2031 2032 class CommandObjectTypeCategoryDelete : public CommandObjectParsed 2033 { 2034 public: 2035 CommandObjectTypeCategoryDelete (CommandInterpreter &interpreter) : 2036 CommandObjectParsed (interpreter, 2037 "type category delete", 2038 "Delete a category and all associated formatters.", 2039 NULL) 2040 { 2041 CommandArgumentEntry type_arg; 2042 CommandArgumentData type_style_arg; 2043 2044 type_style_arg.arg_type = eArgTypeName; 2045 type_style_arg.arg_repetition = eArgRepeatPlus; 2046 2047 type_arg.push_back (type_style_arg); 2048 2049 m_arguments.push_back (type_arg); 2050 2051 } 2052 2053 ~CommandObjectTypeCategoryDelete () 2054 { 2055 } 2056 2057 protected: 2058 bool 2059 DoExecute (Args& command, CommandReturnObject &result) 2060 { 2061 const size_t argc = command.GetArgumentCount(); 2062 2063 if (argc < 1) 2064 { 2065 result.AppendErrorWithFormat ("%s takes 1 or more arg.\n", m_cmd_name.c_str()); 2066 result.SetStatus(eReturnStatusFailed); 2067 return false; 2068 } 2069 2070 bool success = true; 2071 2072 // the order is not relevant here 2073 for (int i = argc - 1; i >= 0; i--) 2074 { 2075 const char* typeA = command.GetArgumentAtIndex(i); 2076 ConstString typeCS(typeA); 2077 2078 if (!typeCS) 2079 { 2080 result.AppendError("empty category name not allowed"); 2081 result.SetStatus(eReturnStatusFailed); 2082 return false; 2083 } 2084 if (!DataVisualization::Categories::Delete(typeCS)) 2085 success = false; // keep deleting even if we hit an error 2086 } 2087 if (success) 2088 { 2089 result.SetStatus(eReturnStatusSuccessFinishResult); 2090 return result.Succeeded(); 2091 } 2092 else 2093 { 2094 result.AppendError("cannot delete one or more categories\n"); 2095 result.SetStatus(eReturnStatusFailed); 2096 return false; 2097 } 2098 } 2099 }; 2100 2101 //------------------------------------------------------------------------- 2102 // CommandObjectTypeCategoryDisable 2103 //------------------------------------------------------------------------- 2104 2105 class CommandObjectTypeCategoryDisable : public CommandObjectParsed 2106 { 2107 public: 2108 CommandObjectTypeCategoryDisable (CommandInterpreter &interpreter) : 2109 CommandObjectParsed (interpreter, 2110 "type category disable", 2111 "Disable a category as a source of formatters.", 2112 NULL) 2113 { 2114 CommandArgumentEntry type_arg; 2115 CommandArgumentData type_style_arg; 2116 2117 type_style_arg.arg_type = eArgTypeName; 2118 type_style_arg.arg_repetition = eArgRepeatPlus; 2119 2120 type_arg.push_back (type_style_arg); 2121 2122 m_arguments.push_back (type_arg); 2123 2124 } 2125 2126 ~CommandObjectTypeCategoryDisable () 2127 { 2128 } 2129 2130 protected: 2131 bool 2132 DoExecute (Args& command, CommandReturnObject &result) 2133 { 2134 const size_t argc = command.GetArgumentCount(); 2135 2136 if (argc < 1) 2137 { 2138 result.AppendErrorWithFormat ("%s takes 1 or more args.\n", m_cmd_name.c_str()); 2139 result.SetStatus(eReturnStatusFailed); 2140 return false; 2141 } 2142 2143 if (argc == 1 && strcmp(command.GetArgumentAtIndex(0),"*") == 0) 2144 { 2145 uint32_t num_categories = DataVisualization::Categories::GetCount(); 2146 for (uint32_t i = 0; i < num_categories; i++) 2147 { 2148 lldb::TypeCategoryImplSP category_sp = DataVisualization::Categories::GetCategoryAtIndex(i); 2149 // no need to check if the category is enabled - disabling a disabled category has no effect 2150 if (category_sp) 2151 DataVisualization::Categories::Disable(category_sp); 2152 } 2153 } 2154 else 2155 { 2156 // the order is not relevant here 2157 for (int i = argc - 1; i >= 0; i--) 2158 { 2159 const char* typeA = command.GetArgumentAtIndex(i); 2160 ConstString typeCS(typeA); 2161 2162 if (!typeCS) 2163 { 2164 result.AppendError("empty category name not allowed"); 2165 result.SetStatus(eReturnStatusFailed); 2166 return false; 2167 } 2168 DataVisualization::Categories::Disable(typeCS); 2169 } 2170 } 2171 2172 result.SetStatus(eReturnStatusSuccessFinishResult); 2173 return result.Succeeded(); 2174 } 2175 2176 }; 2177 2178 //------------------------------------------------------------------------- 2179 // CommandObjectTypeCategoryList 2180 //------------------------------------------------------------------------- 2181 2182 class CommandObjectTypeCategoryList : public CommandObjectParsed 2183 { 2184 private: 2185 2186 struct CommandObjectTypeCategoryList_CallbackParam 2187 { 2188 CommandReturnObject* result; 2189 RegularExpression* regex; 2190 2191 CommandObjectTypeCategoryList_CallbackParam(CommandReturnObject* res, 2192 RegularExpression* rex = NULL) : 2193 result(res), 2194 regex(rex) 2195 { 2196 } 2197 2198 }; 2199 2200 static bool 2201 PerCategoryCallback(void* param_vp, 2202 const lldb::TypeCategoryImplSP& cate) 2203 { 2204 CommandObjectTypeCategoryList_CallbackParam* param = 2205 (CommandObjectTypeCategoryList_CallbackParam*)param_vp; 2206 CommandReturnObject* result = param->result; 2207 RegularExpression* regex = param->regex; 2208 2209 const char* cate_name = cate->GetName(); 2210 2211 if (regex == NULL || strcmp(cate_name, regex->GetText()) == 0 || regex->Execute(cate_name)) 2212 result->GetOutputStream().Printf("Category %s is%s enabled\n", 2213 cate_name, 2214 (cate->IsEnabled() ? "" : " not")); 2215 return true; 2216 } 2217 public: 2218 CommandObjectTypeCategoryList (CommandInterpreter &interpreter) : 2219 CommandObjectParsed (interpreter, 2220 "type category list", 2221 "Provide a list of all existing categories.", 2222 NULL) 2223 { 2224 CommandArgumentEntry type_arg; 2225 CommandArgumentData type_style_arg; 2226 2227 type_style_arg.arg_type = eArgTypeName; 2228 type_style_arg.arg_repetition = eArgRepeatOptional; 2229 2230 type_arg.push_back (type_style_arg); 2231 2232 m_arguments.push_back (type_arg); 2233 } 2234 2235 ~CommandObjectTypeCategoryList () 2236 { 2237 } 2238 2239 protected: 2240 bool 2241 DoExecute (Args& command, CommandReturnObject &result) 2242 { 2243 const size_t argc = command.GetArgumentCount(); 2244 RegularExpression* regex = NULL; 2245 2246 if (argc == 0) 2247 ; 2248 else if (argc == 1) 2249 regex = new RegularExpression(command.GetArgumentAtIndex(0)); 2250 else 2251 { 2252 result.AppendErrorWithFormat ("%s takes 0 or one arg.\n", m_cmd_name.c_str()); 2253 result.SetStatus(eReturnStatusFailed); 2254 return false; 2255 } 2256 2257 CommandObjectTypeCategoryList_CallbackParam param(&result, 2258 regex); 2259 2260 DataVisualization::Categories::LoopThrough(PerCategoryCallback, ¶m); 2261 2262 if (regex) 2263 delete regex; 2264 2265 result.SetStatus(eReturnStatusSuccessFinishResult); 2266 return result.Succeeded(); 2267 } 2268 2269 }; 2270 2271 //------------------------------------------------------------------------- 2272 // CommandObjectTypeFilterList 2273 //------------------------------------------------------------------------- 2274 2275 bool CommandObjectTypeFilterList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); 2276 bool CommandObjectTypeFilterRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); 2277 2278 class CommandObjectTypeFilterList; 2279 2280 struct CommandObjectTypeFilterList_LoopCallbackParam { 2281 CommandObjectTypeFilterList* self; 2282 CommandReturnObject* result; 2283 RegularExpression* regex; 2284 RegularExpression* cate_regex; 2285 CommandObjectTypeFilterList_LoopCallbackParam(CommandObjectTypeFilterList* S, CommandReturnObject* R, 2286 RegularExpression* X = NULL, 2287 RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} 2288 }; 2289 2290 class CommandObjectTypeFilterList : public CommandObjectParsed 2291 { 2292 2293 class CommandOptions : public Options 2294 { 2295 public: 2296 2297 CommandOptions (CommandInterpreter &interpreter) : 2298 Options (interpreter) 2299 { 2300 } 2301 2302 virtual 2303 ~CommandOptions (){} 2304 2305 virtual Error 2306 SetOptionValue (uint32_t option_idx, const char *option_arg) 2307 { 2308 Error error; 2309 const int short_option = m_getopt_table[option_idx].val; 2310 2311 switch (short_option) 2312 { 2313 case 'w': 2314 m_category_regex = std::string(option_arg); 2315 break; 2316 default: 2317 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 2318 break; 2319 } 2320 2321 return error; 2322 } 2323 2324 void 2325 OptionParsingStarting () 2326 { 2327 m_category_regex = ""; 2328 } 2329 2330 const OptionDefinition* 2331 GetDefinitions () 2332 { 2333 return g_option_table; 2334 } 2335 2336 // Options table: Required for subclasses of Options. 2337 2338 static OptionDefinition g_option_table[]; 2339 2340 // Instance variables to hold the values for command options. 2341 2342 std::string m_category_regex; 2343 2344 }; 2345 2346 CommandOptions m_options; 2347 2348 virtual Options * 2349 GetOptions () 2350 { 2351 return &m_options; 2352 } 2353 2354 public: 2355 CommandObjectTypeFilterList (CommandInterpreter &interpreter) : 2356 CommandObjectParsed (interpreter, 2357 "type filter list", 2358 "Show a list of current filters.", 2359 NULL), 2360 m_options(interpreter) 2361 { 2362 CommandArgumentEntry type_arg; 2363 CommandArgumentData type_style_arg; 2364 2365 type_style_arg.arg_type = eArgTypeName; 2366 type_style_arg.arg_repetition = eArgRepeatOptional; 2367 2368 type_arg.push_back (type_style_arg); 2369 2370 m_arguments.push_back (type_arg); 2371 } 2372 2373 ~CommandObjectTypeFilterList () 2374 { 2375 } 2376 2377 protected: 2378 bool 2379 DoExecute (Args& command, CommandReturnObject &result) 2380 { 2381 const size_t argc = command.GetArgumentCount(); 2382 2383 CommandObjectTypeFilterList_LoopCallbackParam *param; 2384 RegularExpression* cate_regex = 2385 m_options.m_category_regex.empty() ? NULL : 2386 new RegularExpression(m_options.m_category_regex.c_str()); 2387 2388 if (argc == 1) 2389 { 2390 RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); 2391 regex->Compile(command.GetArgumentAtIndex(0)); 2392 param = new CommandObjectTypeFilterList_LoopCallbackParam(this,&result,regex,cate_regex); 2393 } 2394 else 2395 param = new CommandObjectTypeFilterList_LoopCallbackParam(this,&result,NULL,cate_regex); 2396 2397 DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); 2398 2399 if (cate_regex) 2400 delete cate_regex; 2401 2402 result.SetStatus(eReturnStatusSuccessFinishResult); 2403 return result.Succeeded(); 2404 } 2405 2406 private: 2407 2408 static bool 2409 PerCategoryCallback(void* param_vp, 2410 const lldb::TypeCategoryImplSP& cate) 2411 { 2412 2413 const char* cate_name = cate->GetName(); 2414 2415 CommandObjectTypeFilterList_LoopCallbackParam* param = 2416 (CommandObjectTypeFilterList_LoopCallbackParam*)param_vp; 2417 CommandReturnObject* result = param->result; 2418 2419 // if the category is disabled or empty and there is no regex, just skip it 2420 if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter) == 0) && param->cate_regex == NULL) 2421 return true; 2422 2423 // if we have a regex and this category does not match it, just skip it 2424 if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) 2425 return true; 2426 2427 result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", 2428 cate_name, 2429 (cate->IsEnabled() ? "enabled" : "disabled")); 2430 2431 cate->GetFilterNavigator()->LoopThrough(CommandObjectTypeFilterList_LoopCallback, param_vp); 2432 2433 if (cate->GetRegexFilterNavigator()->GetCount() > 0) 2434 { 2435 result->GetOutputStream().Printf("Regex-based filters (slower):\n"); 2436 cate->GetRegexFilterNavigator()->LoopThrough(CommandObjectTypeFilterRXList_LoopCallback, param_vp); 2437 } 2438 2439 return true; 2440 } 2441 2442 bool 2443 LoopCallback (const char* type, 2444 const SyntheticChildren::SharedPointer& entry, 2445 RegularExpression* regex, 2446 CommandReturnObject *result) 2447 { 2448 if (regex == NULL || regex->Execute(type)) 2449 result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); 2450 return true; 2451 } 2452 2453 friend bool CommandObjectTypeFilterList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); 2454 friend bool CommandObjectTypeFilterRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); 2455 }; 2456 2457 bool 2458 CommandObjectTypeFilterList_LoopCallback (void* pt2self, 2459 ConstString type, 2460 const SyntheticChildren::SharedPointer& entry) 2461 { 2462 CommandObjectTypeFilterList_LoopCallbackParam* param = (CommandObjectTypeFilterList_LoopCallbackParam*)pt2self; 2463 return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); 2464 } 2465 2466 bool 2467 CommandObjectTypeFilterRXList_LoopCallback (void* pt2self, 2468 lldb::RegularExpressionSP regex, 2469 const SyntheticChildren::SharedPointer& entry) 2470 { 2471 CommandObjectTypeFilterList_LoopCallbackParam* param = (CommandObjectTypeFilterList_LoopCallbackParam*)pt2self; 2472 return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); 2473 } 2474 2475 2476 OptionDefinition 2477 CommandObjectTypeFilterList::CommandOptions::g_option_table[] = 2478 { 2479 { LLDB_OPT_SET_ALL, false, "category-regex", 'w', required_argument, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, 2480 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 2481 }; 2482 2483 #ifndef LLDB_DISABLE_PYTHON 2484 2485 //------------------------------------------------------------------------- 2486 // CommandObjectTypeSynthList 2487 //------------------------------------------------------------------------- 2488 2489 bool CommandObjectTypeSynthList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); 2490 bool CommandObjectTypeSynthRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); 2491 2492 class CommandObjectTypeSynthList; 2493 2494 struct CommandObjectTypeSynthList_LoopCallbackParam { 2495 CommandObjectTypeSynthList* self; 2496 CommandReturnObject* result; 2497 RegularExpression* regex; 2498 RegularExpression* cate_regex; 2499 CommandObjectTypeSynthList_LoopCallbackParam(CommandObjectTypeSynthList* S, CommandReturnObject* R, 2500 RegularExpression* X = NULL, 2501 RegularExpression* CX = NULL) : self(S), result(R), regex(X), cate_regex(CX) {} 2502 }; 2503 2504 class CommandObjectTypeSynthList : public CommandObjectParsed 2505 { 2506 2507 class CommandOptions : public Options 2508 { 2509 public: 2510 2511 CommandOptions (CommandInterpreter &interpreter) : 2512 Options (interpreter) 2513 { 2514 } 2515 2516 virtual 2517 ~CommandOptions (){} 2518 2519 virtual Error 2520 SetOptionValue (uint32_t option_idx, const char *option_arg) 2521 { 2522 Error error; 2523 const int short_option = m_getopt_table[option_idx].val; 2524 2525 switch (short_option) 2526 { 2527 case 'w': 2528 m_category_regex = std::string(option_arg); 2529 break; 2530 default: 2531 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 2532 break; 2533 } 2534 2535 return error; 2536 } 2537 2538 void 2539 OptionParsingStarting () 2540 { 2541 m_category_regex = ""; 2542 } 2543 2544 const OptionDefinition* 2545 GetDefinitions () 2546 { 2547 return g_option_table; 2548 } 2549 2550 // Options table: Required for subclasses of Options. 2551 2552 static OptionDefinition g_option_table[]; 2553 2554 // Instance variables to hold the values for command options. 2555 2556 std::string m_category_regex; 2557 2558 }; 2559 2560 CommandOptions m_options; 2561 2562 virtual Options * 2563 GetOptions () 2564 { 2565 return &m_options; 2566 } 2567 2568 public: 2569 CommandObjectTypeSynthList (CommandInterpreter &interpreter) : 2570 CommandObjectParsed (interpreter, 2571 "type synthetic list", 2572 "Show a list of current synthetic providers.", 2573 NULL), 2574 m_options(interpreter) 2575 { 2576 CommandArgumentEntry type_arg; 2577 CommandArgumentData type_style_arg; 2578 2579 type_style_arg.arg_type = eArgTypeName; 2580 type_style_arg.arg_repetition = eArgRepeatOptional; 2581 2582 type_arg.push_back (type_style_arg); 2583 2584 m_arguments.push_back (type_arg); 2585 } 2586 2587 ~CommandObjectTypeSynthList () 2588 { 2589 } 2590 2591 protected: 2592 bool 2593 DoExecute (Args& command, CommandReturnObject &result) 2594 { 2595 const size_t argc = command.GetArgumentCount(); 2596 2597 CommandObjectTypeSynthList_LoopCallbackParam *param; 2598 RegularExpression* cate_regex = 2599 m_options.m_category_regex.empty() ? NULL : 2600 new RegularExpression(m_options.m_category_regex.c_str()); 2601 2602 if (argc == 1) 2603 { 2604 RegularExpression* regex = new RegularExpression(command.GetArgumentAtIndex(0)); 2605 regex->Compile(command.GetArgumentAtIndex(0)); 2606 param = new CommandObjectTypeSynthList_LoopCallbackParam(this,&result,regex,cate_regex); 2607 } 2608 else 2609 param = new CommandObjectTypeSynthList_LoopCallbackParam(this,&result,NULL,cate_regex); 2610 2611 DataVisualization::Categories::LoopThrough(PerCategoryCallback,param); 2612 2613 if (cate_regex) 2614 delete cate_regex; 2615 2616 result.SetStatus(eReturnStatusSuccessFinishResult); 2617 return result.Succeeded(); 2618 } 2619 2620 private: 2621 2622 static bool 2623 PerCategoryCallback(void* param_vp, 2624 const lldb::TypeCategoryImplSP& cate) 2625 { 2626 2627 CommandObjectTypeSynthList_LoopCallbackParam* param = 2628 (CommandObjectTypeSynthList_LoopCallbackParam*)param_vp; 2629 CommandReturnObject* result = param->result; 2630 2631 const char* cate_name = cate->GetName(); 2632 2633 // if the category is disabled or empty and there is no regex, just skip it 2634 if ((cate->IsEnabled() == false || cate->GetCount(eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth) == 0) && param->cate_regex == NULL) 2635 return true; 2636 2637 // if we have a regex and this category does not match it, just skip it 2638 if(param->cate_regex != NULL && strcmp(cate_name,param->cate_regex->GetText()) != 0 && param->cate_regex->Execute(cate_name) == false) 2639 return true; 2640 2641 result->GetOutputStream().Printf("-----------------------\nCategory: %s (%s)\n-----------------------\n", 2642 cate_name, 2643 (cate->IsEnabled() ? "enabled" : "disabled")); 2644 2645 cate->GetSyntheticNavigator()->LoopThrough(CommandObjectTypeSynthList_LoopCallback, param_vp); 2646 2647 if (cate->GetRegexSyntheticNavigator()->GetCount() > 0) 2648 { 2649 result->GetOutputStream().Printf("Regex-based synthetic providers (slower):\n"); 2650 cate->GetRegexSyntheticNavigator()->LoopThrough(CommandObjectTypeSynthRXList_LoopCallback, param_vp); 2651 } 2652 2653 return true; 2654 } 2655 2656 bool 2657 LoopCallback (const char* type, 2658 const SyntheticChildren::SharedPointer& entry, 2659 RegularExpression* regex, 2660 CommandReturnObject *result) 2661 { 2662 if (regex == NULL || regex->Execute(type)) 2663 result->GetOutputStream().Printf ("%s: %s\n", type, entry->GetDescription().c_str()); 2664 return true; 2665 } 2666 2667 friend bool CommandObjectTypeSynthList_LoopCallback(void* pt2self, ConstString type, const SyntheticChildren::SharedPointer& entry); 2668 friend bool CommandObjectTypeSynthRXList_LoopCallback(void* pt2self, lldb::RegularExpressionSP regex, const SyntheticChildren::SharedPointer& entry); 2669 }; 2670 2671 bool 2672 CommandObjectTypeSynthList_LoopCallback (void* pt2self, 2673 ConstString type, 2674 const SyntheticChildren::SharedPointer& entry) 2675 { 2676 CommandObjectTypeSynthList_LoopCallbackParam* param = (CommandObjectTypeSynthList_LoopCallbackParam*)pt2self; 2677 return param->self->LoopCallback(type.AsCString(), entry, param->regex, param->result); 2678 } 2679 2680 bool 2681 CommandObjectTypeSynthRXList_LoopCallback (void* pt2self, 2682 lldb::RegularExpressionSP regex, 2683 const SyntheticChildren::SharedPointer& entry) 2684 { 2685 CommandObjectTypeSynthList_LoopCallbackParam* param = (CommandObjectTypeSynthList_LoopCallbackParam*)pt2self; 2686 return param->self->LoopCallback(regex->GetText(), entry, param->regex, param->result); 2687 } 2688 2689 2690 OptionDefinition 2691 CommandObjectTypeSynthList::CommandOptions::g_option_table[] = 2692 { 2693 { LLDB_OPT_SET_ALL, false, "category-regex", 'w', required_argument, NULL, 0, eArgTypeName, "Only show categories matching this filter."}, 2694 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 2695 }; 2696 2697 #endif // #ifndef LLDB_DISABLE_PYTHON 2698 //------------------------------------------------------------------------- 2699 // CommandObjectTypeFilterDelete 2700 //------------------------------------------------------------------------- 2701 2702 class CommandObjectTypeFilterDelete : public CommandObjectParsed 2703 { 2704 private: 2705 class CommandOptions : public Options 2706 { 2707 public: 2708 2709 CommandOptions (CommandInterpreter &interpreter) : 2710 Options (interpreter) 2711 { 2712 } 2713 2714 virtual 2715 ~CommandOptions (){} 2716 2717 virtual Error 2718 SetOptionValue (uint32_t option_idx, const char *option_arg) 2719 { 2720 Error error; 2721 const int short_option = m_getopt_table[option_idx].val; 2722 2723 switch (short_option) 2724 { 2725 case 'a': 2726 m_delete_all = true; 2727 break; 2728 case 'w': 2729 m_category = std::string(option_arg); 2730 break; 2731 default: 2732 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 2733 break; 2734 } 2735 2736 return error; 2737 } 2738 2739 void 2740 OptionParsingStarting () 2741 { 2742 m_delete_all = false; 2743 m_category = "default"; 2744 } 2745 2746 const OptionDefinition* 2747 GetDefinitions () 2748 { 2749 return g_option_table; 2750 } 2751 2752 // Options table: Required for subclasses of Options. 2753 2754 static OptionDefinition g_option_table[]; 2755 2756 // Instance variables to hold the values for command options. 2757 2758 bool m_delete_all; 2759 std::string m_category; 2760 2761 }; 2762 2763 CommandOptions m_options; 2764 2765 virtual Options * 2766 GetOptions () 2767 { 2768 return &m_options; 2769 } 2770 2771 static bool 2772 PerCategoryCallback(void* param, 2773 const lldb::TypeCategoryImplSP& cate) 2774 { 2775 ConstString *name = (ConstString*)param; 2776 return cate->Delete(*name, eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter); 2777 } 2778 2779 public: 2780 CommandObjectTypeFilterDelete (CommandInterpreter &interpreter) : 2781 CommandObjectParsed (interpreter, 2782 "type filter delete", 2783 "Delete an existing filter for a type.", 2784 NULL), 2785 m_options(interpreter) 2786 { 2787 CommandArgumentEntry type_arg; 2788 CommandArgumentData type_style_arg; 2789 2790 type_style_arg.arg_type = eArgTypeName; 2791 type_style_arg.arg_repetition = eArgRepeatPlain; 2792 2793 type_arg.push_back (type_style_arg); 2794 2795 m_arguments.push_back (type_arg); 2796 2797 } 2798 2799 ~CommandObjectTypeFilterDelete () 2800 { 2801 } 2802 2803 protected: 2804 bool 2805 DoExecute (Args& command, CommandReturnObject &result) 2806 { 2807 const size_t argc = command.GetArgumentCount(); 2808 2809 if (argc != 1) 2810 { 2811 result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); 2812 result.SetStatus(eReturnStatusFailed); 2813 return false; 2814 } 2815 2816 const char* typeA = command.GetArgumentAtIndex(0); 2817 ConstString typeCS(typeA); 2818 2819 if (!typeCS) 2820 { 2821 result.AppendError("empty typenames not allowed"); 2822 result.SetStatus(eReturnStatusFailed); 2823 return false; 2824 } 2825 2826 if (m_options.m_delete_all) 2827 { 2828 DataVisualization::Categories::LoopThrough(PerCategoryCallback, (void*)&typeCS); 2829 result.SetStatus(eReturnStatusSuccessFinishNoResult); 2830 return result.Succeeded(); 2831 } 2832 2833 lldb::TypeCategoryImplSP category; 2834 DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); 2835 2836 bool delete_category = category->GetFilterNavigator()->Delete(typeCS); 2837 delete_category = category->GetRegexFilterNavigator()->Delete(typeCS) || delete_category; 2838 2839 if (delete_category) 2840 { 2841 result.SetStatus(eReturnStatusSuccessFinishNoResult); 2842 return result.Succeeded(); 2843 } 2844 else 2845 { 2846 result.AppendErrorWithFormat ("no custom synthetic provider for %s.\n", typeA); 2847 result.SetStatus(eReturnStatusFailed); 2848 return false; 2849 } 2850 2851 } 2852 }; 2853 2854 OptionDefinition 2855 CommandObjectTypeFilterDelete::CommandOptions::g_option_table[] = 2856 { 2857 { LLDB_OPT_SET_1, false, "all", 'a', no_argument, NULL, 0, eArgTypeNone, "Delete from every category."}, 2858 { LLDB_OPT_SET_2, false, "category", 'w', required_argument, NULL, 0, eArgTypeName, "Delete from given category."}, 2859 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 2860 }; 2861 2862 #ifndef LLDB_DISABLE_PYTHON 2863 2864 //------------------------------------------------------------------------- 2865 // CommandObjectTypeSynthDelete 2866 //------------------------------------------------------------------------- 2867 2868 class CommandObjectTypeSynthDelete : public CommandObjectParsed 2869 { 2870 private: 2871 class CommandOptions : public Options 2872 { 2873 public: 2874 2875 CommandOptions (CommandInterpreter &interpreter) : 2876 Options (interpreter) 2877 { 2878 } 2879 2880 virtual 2881 ~CommandOptions (){} 2882 2883 virtual Error 2884 SetOptionValue (uint32_t option_idx, const char *option_arg) 2885 { 2886 Error error; 2887 const int short_option = m_getopt_table[option_idx].val; 2888 2889 switch (short_option) 2890 { 2891 case 'a': 2892 m_delete_all = true; 2893 break; 2894 case 'w': 2895 m_category = std::string(option_arg); 2896 break; 2897 default: 2898 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 2899 break; 2900 } 2901 2902 return error; 2903 } 2904 2905 void 2906 OptionParsingStarting () 2907 { 2908 m_delete_all = false; 2909 m_category = "default"; 2910 } 2911 2912 const OptionDefinition* 2913 GetDefinitions () 2914 { 2915 return g_option_table; 2916 } 2917 2918 // Options table: Required for subclasses of Options. 2919 2920 static OptionDefinition g_option_table[]; 2921 2922 // Instance variables to hold the values for command options. 2923 2924 bool m_delete_all; 2925 std::string m_category; 2926 2927 }; 2928 2929 CommandOptions m_options; 2930 2931 virtual Options * 2932 GetOptions () 2933 { 2934 return &m_options; 2935 } 2936 2937 static bool 2938 PerCategoryCallback(void* param, 2939 const lldb::TypeCategoryImplSP& cate) 2940 { 2941 ConstString* name = (ConstString*)param; 2942 return cate->Delete(*name, eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth); 2943 } 2944 2945 public: 2946 CommandObjectTypeSynthDelete (CommandInterpreter &interpreter) : 2947 CommandObjectParsed (interpreter, 2948 "type synthetic delete", 2949 "Delete an existing synthetic provider for a type.", 2950 NULL), 2951 m_options(interpreter) 2952 { 2953 CommandArgumentEntry type_arg; 2954 CommandArgumentData type_style_arg; 2955 2956 type_style_arg.arg_type = eArgTypeName; 2957 type_style_arg.arg_repetition = eArgRepeatPlain; 2958 2959 type_arg.push_back (type_style_arg); 2960 2961 m_arguments.push_back (type_arg); 2962 2963 } 2964 2965 ~CommandObjectTypeSynthDelete () 2966 { 2967 } 2968 2969 protected: 2970 bool 2971 DoExecute (Args& command, CommandReturnObject &result) 2972 { 2973 const size_t argc = command.GetArgumentCount(); 2974 2975 if (argc != 1) 2976 { 2977 result.AppendErrorWithFormat ("%s takes 1 arg.\n", m_cmd_name.c_str()); 2978 result.SetStatus(eReturnStatusFailed); 2979 return false; 2980 } 2981 2982 const char* typeA = command.GetArgumentAtIndex(0); 2983 ConstString typeCS(typeA); 2984 2985 if (!typeCS) 2986 { 2987 result.AppendError("empty typenames not allowed"); 2988 result.SetStatus(eReturnStatusFailed); 2989 return false; 2990 } 2991 2992 if (m_options.m_delete_all) 2993 { 2994 DataVisualization::Categories::LoopThrough(PerCategoryCallback, (void*)&typeCS); 2995 result.SetStatus(eReturnStatusSuccessFinishNoResult); 2996 return result.Succeeded(); 2997 } 2998 2999 lldb::TypeCategoryImplSP category; 3000 DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); 3001 3002 bool delete_category = category->GetSyntheticNavigator()->Delete(typeCS); 3003 delete_category = category->GetRegexSyntheticNavigator()->Delete(typeCS) || delete_category; 3004 3005 if (delete_category) 3006 { 3007 result.SetStatus(eReturnStatusSuccessFinishNoResult); 3008 return result.Succeeded(); 3009 } 3010 else 3011 { 3012 result.AppendErrorWithFormat ("no custom synthetic provider for %s.\n", typeA); 3013 result.SetStatus(eReturnStatusFailed); 3014 return false; 3015 } 3016 3017 } 3018 }; 3019 3020 OptionDefinition 3021 CommandObjectTypeSynthDelete::CommandOptions::g_option_table[] = 3022 { 3023 { LLDB_OPT_SET_1, false, "all", 'a', no_argument, NULL, 0, eArgTypeNone, "Delete from every category."}, 3024 { LLDB_OPT_SET_2, false, "category", 'w', required_argument, NULL, 0, eArgTypeName, "Delete from given category."}, 3025 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 3026 }; 3027 3028 #endif // #ifndef LLDB_DISABLE_PYTHON 3029 3030 //------------------------------------------------------------------------- 3031 // CommandObjectTypeFilterClear 3032 //------------------------------------------------------------------------- 3033 3034 class CommandObjectTypeFilterClear : public CommandObjectParsed 3035 { 3036 private: 3037 3038 class CommandOptions : public Options 3039 { 3040 public: 3041 3042 CommandOptions (CommandInterpreter &interpreter) : 3043 Options (interpreter) 3044 { 3045 } 3046 3047 virtual 3048 ~CommandOptions (){} 3049 3050 virtual Error 3051 SetOptionValue (uint32_t option_idx, const char *option_arg) 3052 { 3053 Error error; 3054 const int short_option = m_getopt_table[option_idx].val; 3055 3056 switch (short_option) 3057 { 3058 case 'a': 3059 m_delete_all = true; 3060 break; 3061 default: 3062 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 3063 break; 3064 } 3065 3066 return error; 3067 } 3068 3069 void 3070 OptionParsingStarting () 3071 { 3072 m_delete_all = false; 3073 } 3074 3075 const OptionDefinition* 3076 GetDefinitions () 3077 { 3078 return g_option_table; 3079 } 3080 3081 // Options table: Required for subclasses of Options. 3082 3083 static OptionDefinition g_option_table[]; 3084 3085 // Instance variables to hold the values for command options. 3086 3087 bool m_delete_all; 3088 bool m_delete_named; 3089 }; 3090 3091 CommandOptions m_options; 3092 3093 virtual Options * 3094 GetOptions () 3095 { 3096 return &m_options; 3097 } 3098 3099 static bool 3100 PerCategoryCallback(void* param, 3101 const lldb::TypeCategoryImplSP& cate) 3102 { 3103 cate->Clear(eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter); 3104 return true; 3105 3106 } 3107 3108 public: 3109 CommandObjectTypeFilterClear (CommandInterpreter &interpreter) : 3110 CommandObjectParsed (interpreter, 3111 "type filter clear", 3112 "Delete all existing filters.", 3113 NULL), 3114 m_options(interpreter) 3115 { 3116 } 3117 3118 ~CommandObjectTypeFilterClear () 3119 { 3120 } 3121 3122 protected: 3123 bool 3124 DoExecute (Args& command, CommandReturnObject &result) 3125 { 3126 3127 if (m_options.m_delete_all) 3128 DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); 3129 3130 else 3131 { 3132 lldb::TypeCategoryImplSP category; 3133 if (command.GetArgumentCount() > 0) 3134 { 3135 const char* cat_name = command.GetArgumentAtIndex(0); 3136 ConstString cat_nameCS(cat_name); 3137 DataVisualization::Categories::GetCategory(cat_nameCS, category); 3138 } 3139 else 3140 DataVisualization::Categories::GetCategory(ConstString(NULL), category); 3141 category->GetFilterNavigator()->Clear(); 3142 category->GetRegexFilterNavigator()->Clear(); 3143 } 3144 3145 result.SetStatus(eReturnStatusSuccessFinishResult); 3146 return result.Succeeded(); 3147 } 3148 3149 }; 3150 3151 OptionDefinition 3152 CommandObjectTypeFilterClear::CommandOptions::g_option_table[] = 3153 { 3154 { LLDB_OPT_SET_ALL, false, "all", 'a', no_argument, NULL, 0, eArgTypeNone, "Clear every category."}, 3155 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 3156 }; 3157 3158 #ifndef LLDB_DISABLE_PYTHON 3159 //------------------------------------------------------------------------- 3160 // CommandObjectTypeSynthClear 3161 //------------------------------------------------------------------------- 3162 3163 class CommandObjectTypeSynthClear : public CommandObjectParsed 3164 { 3165 private: 3166 3167 class CommandOptions : public Options 3168 { 3169 public: 3170 3171 CommandOptions (CommandInterpreter &interpreter) : 3172 Options (interpreter) 3173 { 3174 } 3175 3176 virtual 3177 ~CommandOptions (){} 3178 3179 virtual Error 3180 SetOptionValue (uint32_t option_idx, const char *option_arg) 3181 { 3182 Error error; 3183 const int short_option = m_getopt_table[option_idx].val; 3184 3185 switch (short_option) 3186 { 3187 case 'a': 3188 m_delete_all = true; 3189 break; 3190 default: 3191 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 3192 break; 3193 } 3194 3195 return error; 3196 } 3197 3198 void 3199 OptionParsingStarting () 3200 { 3201 m_delete_all = false; 3202 } 3203 3204 const OptionDefinition* 3205 GetDefinitions () 3206 { 3207 return g_option_table; 3208 } 3209 3210 // Options table: Required for subclasses of Options. 3211 3212 static OptionDefinition g_option_table[]; 3213 3214 // Instance variables to hold the values for command options. 3215 3216 bool m_delete_all; 3217 bool m_delete_named; 3218 }; 3219 3220 CommandOptions m_options; 3221 3222 virtual Options * 3223 GetOptions () 3224 { 3225 return &m_options; 3226 } 3227 3228 static bool 3229 PerCategoryCallback(void* param, 3230 const lldb::TypeCategoryImplSP& cate) 3231 { 3232 cate->Clear(eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth); 3233 return true; 3234 3235 } 3236 3237 public: 3238 CommandObjectTypeSynthClear (CommandInterpreter &interpreter) : 3239 CommandObjectParsed (interpreter, 3240 "type synthetic clear", 3241 "Delete all existing synthetic providers.", 3242 NULL), 3243 m_options(interpreter) 3244 { 3245 } 3246 3247 ~CommandObjectTypeSynthClear () 3248 { 3249 } 3250 3251 protected: 3252 bool 3253 DoExecute (Args& command, CommandReturnObject &result) 3254 { 3255 3256 if (m_options.m_delete_all) 3257 DataVisualization::Categories::LoopThrough(PerCategoryCallback, NULL); 3258 3259 else 3260 { 3261 lldb::TypeCategoryImplSP category; 3262 if (command.GetArgumentCount() > 0) 3263 { 3264 const char* cat_name = command.GetArgumentAtIndex(0); 3265 ConstString cat_nameCS(cat_name); 3266 DataVisualization::Categories::GetCategory(cat_nameCS, category); 3267 } 3268 else 3269 DataVisualization::Categories::GetCategory(ConstString(NULL), category); 3270 category->GetSyntheticNavigator()->Clear(); 3271 category->GetRegexSyntheticNavigator()->Clear(); 3272 } 3273 3274 result.SetStatus(eReturnStatusSuccessFinishResult); 3275 return result.Succeeded(); 3276 } 3277 3278 }; 3279 3280 OptionDefinition 3281 CommandObjectTypeSynthClear::CommandOptions::g_option_table[] = 3282 { 3283 { LLDB_OPT_SET_ALL, false, "all", 'a', no_argument, NULL, 0, eArgTypeNone, "Clear every category."}, 3284 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 3285 }; 3286 3287 3288 //------------------------------------------------------------------------- 3289 // TypeSynthAddInputReader 3290 //------------------------------------------------------------------------- 3291 3292 static const char *g_synth_addreader_instructions = "Enter your Python command(s). Type 'DONE' to end.\n" 3293 "You must define a Python class with these methods:\n" 3294 " def __init__(self, valobj, dict):\n" 3295 " def num_children(self):\n" 3296 " def get_child_at_index(self, index):\n" 3297 " def get_child_index(self, name):\n" 3298 "Optionally, you can also define a method:\n" 3299 " def update(self):\n" 3300 "if your synthetic provider is holding on to any per-object state variables (currently, this is not implemented because of the way LLDB handles instances of SBValue and you should not rely on object persistence and per-object state)\n" 3301 "class synthProvider:"; 3302 3303 class TypeSynthAddInputReader : public InputReaderEZ 3304 { 3305 public: 3306 TypeSynthAddInputReader(Debugger& debugger) : 3307 InputReaderEZ(debugger) 3308 {} 3309 3310 virtual 3311 ~TypeSynthAddInputReader() 3312 { 3313 } 3314 3315 virtual void ActivateHandler(HandlerData& data) 3316 { 3317 StreamSP out_stream = data.GetOutStream(); 3318 bool batch_mode = data.GetBatchMode(); 3319 if (!batch_mode) 3320 { 3321 out_stream->Printf ("%s\n", g_synth_addreader_instructions); 3322 if (data.reader.GetPrompt()) 3323 out_stream->Printf ("%s", data.reader.GetPrompt()); 3324 out_stream->Flush(); 3325 } 3326 } 3327 3328 virtual void ReactivateHandler(HandlerData& data) 3329 { 3330 StreamSP out_stream = data.GetOutStream(); 3331 bool batch_mode = data.GetBatchMode(); 3332 if (data.reader.GetPrompt() && !batch_mode) 3333 { 3334 out_stream->Printf ("%s", data.reader.GetPrompt()); 3335 out_stream->Flush(); 3336 } 3337 } 3338 virtual void GotTokenHandler(HandlerData& data) 3339 { 3340 StreamSP out_stream = data.GetOutStream(); 3341 bool batch_mode = data.GetBatchMode(); 3342 if (data.bytes && data.bytes_len && data.baton) 3343 { 3344 ((SynthAddOptions*)data.baton)->m_user_source.AppendString(data.bytes, data.bytes_len); 3345 } 3346 if (!data.reader.IsDone() && data.reader.GetPrompt() && !batch_mode) 3347 { 3348 out_stream->Printf ("%s", data.reader.GetPrompt()); 3349 out_stream->Flush(); 3350 } 3351 } 3352 virtual void InterruptHandler(HandlerData& data) 3353 { 3354 StreamSP out_stream = data.GetOutStream(); 3355 bool batch_mode = data.GetBatchMode(); 3356 data.reader.SetIsDone (true); 3357 if (!batch_mode) 3358 { 3359 out_stream->Printf ("Warning: No command attached to breakpoint.\n"); 3360 out_stream->Flush(); 3361 } 3362 } 3363 virtual void EOFHandler(HandlerData& data) 3364 { 3365 data.reader.SetIsDone (true); 3366 } 3367 virtual void DoneHandler(HandlerData& data) 3368 { 3369 StreamSP out_stream = data.GetOutStream(); 3370 SynthAddOptions *options_ptr = ((SynthAddOptions*)data.baton); 3371 if (!options_ptr) 3372 { 3373 out_stream->Printf ("internal synchronization data missing.\n"); 3374 out_stream->Flush(); 3375 return; 3376 } 3377 3378 SynthAddOptions::SharedPointer options(options_ptr); // this will ensure that we get rid of the pointer when going out of scope 3379 3380 ScriptInterpreter *interpreter = data.reader.GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 3381 if (!interpreter) 3382 { 3383 out_stream->Printf ("no script interpreter.\n"); 3384 out_stream->Flush(); 3385 return; 3386 } 3387 std::string class_name_str; 3388 if (!interpreter->GenerateTypeSynthClass (options->m_user_source, 3389 class_name_str)) 3390 { 3391 out_stream->Printf ("unable to generate a class.\n"); 3392 out_stream->Flush(); 3393 return; 3394 } 3395 if (class_name_str.empty()) 3396 { 3397 out_stream->Printf ("unable to obtain a proper name for the class.\n"); 3398 out_stream->Flush(); 3399 return; 3400 } 3401 3402 // everything should be fine now, let's add the synth provider class 3403 3404 SyntheticChildrenSP synth_provider; 3405 synth_provider.reset(new ScriptedSyntheticChildren(SyntheticChildren::Flags().SetCascades(options->m_cascade). 3406 SetSkipPointers(options->m_skip_pointers). 3407 SetSkipReferences(options->m_skip_references), 3408 class_name_str.c_str())); 3409 3410 3411 lldb::TypeCategoryImplSP category; 3412 DataVisualization::Categories::GetCategory(ConstString(options->m_category.c_str()), category); 3413 3414 Error error; 3415 3416 for (size_t i = 0; i < options->m_target_types.GetSize(); i++) 3417 { 3418 const char *type_name = options->m_target_types.GetStringAtIndex(i); 3419 ConstString typeCS(type_name); 3420 if (typeCS) 3421 { 3422 if (!CommandObjectTypeSynthAdd::AddSynth(typeCS, 3423 synth_provider, 3424 options->m_regex ? CommandObjectTypeSynthAdd::eRegexSynth : CommandObjectTypeSynthAdd::eRegularSynth, 3425 options->m_category, 3426 &error)) 3427 { 3428 out_stream->Printf("%s\n", error.AsCString()); 3429 out_stream->Flush(); 3430 return; 3431 } 3432 } 3433 else 3434 { 3435 out_stream->Printf ("invalid type name.\n"); 3436 out_stream->Flush(); 3437 return; 3438 } 3439 } 3440 } 3441 3442 private: 3443 DISALLOW_COPY_AND_ASSIGN (TypeSynthAddInputReader); 3444 }; 3445 3446 void 3447 CommandObjectTypeSynthAdd::CollectPythonScript (SynthAddOptions *options, 3448 CommandReturnObject &result) 3449 { 3450 InputReaderSP reader_sp (new TypeSynthAddInputReader(m_interpreter.GetDebugger())); 3451 if (reader_sp && options) 3452 { 3453 3454 InputReaderEZ::InitializationParameters ipr; 3455 3456 Error err (reader_sp->Initialize (ipr.SetBaton(options).SetPrompt(" "))); 3457 if (err.Success()) 3458 { 3459 m_interpreter.GetDebugger().PushInputReader (reader_sp); 3460 result.SetStatus (eReturnStatusSuccessFinishNoResult); 3461 } 3462 else 3463 { 3464 result.AppendError (err.AsCString()); 3465 result.SetStatus (eReturnStatusFailed); 3466 } 3467 } 3468 else 3469 { 3470 result.AppendError("out of memory"); 3471 result.SetStatus (eReturnStatusFailed); 3472 } 3473 } 3474 3475 bool 3476 CommandObjectTypeSynthAdd::Execute_HandwritePython (Args& command, CommandReturnObject &result) 3477 { 3478 SynthAddOptions *options = new SynthAddOptions ( m_options.m_skip_pointers, 3479 m_options.m_skip_references, 3480 m_options.m_cascade, 3481 m_options.m_regex, 3482 m_options.m_category); 3483 3484 const size_t argc = command.GetArgumentCount(); 3485 3486 for (size_t i = 0; i < argc; i++) 3487 { 3488 const char* typeA = command.GetArgumentAtIndex(i); 3489 if (typeA && *typeA) 3490 options->m_target_types << typeA; 3491 else 3492 { 3493 result.AppendError("empty typenames not allowed"); 3494 result.SetStatus(eReturnStatusFailed); 3495 return false; 3496 } 3497 } 3498 3499 CollectPythonScript(options,result); 3500 return result.Succeeded(); 3501 } 3502 3503 bool 3504 CommandObjectTypeSynthAdd::Execute_PythonClass (Args& command, CommandReturnObject &result) 3505 { 3506 const size_t argc = command.GetArgumentCount(); 3507 3508 if (argc < 1) 3509 { 3510 result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str()); 3511 result.SetStatus(eReturnStatusFailed); 3512 return false; 3513 } 3514 3515 if (m_options.m_class_name.empty() && !m_options.m_input_python) 3516 { 3517 result.AppendErrorWithFormat ("%s needs either a Python class name or -P to directly input Python code.\n", m_cmd_name.c_str()); 3518 result.SetStatus(eReturnStatusFailed); 3519 return false; 3520 } 3521 3522 SyntheticChildrenSP entry; 3523 3524 ScriptedSyntheticChildren* impl = new ScriptedSyntheticChildren(SyntheticChildren::Flags(). 3525 SetCascades(m_options.m_cascade). 3526 SetSkipPointers(m_options.m_skip_pointers). 3527 SetSkipReferences(m_options.m_skip_references), 3528 m_options.m_class_name.c_str()); 3529 3530 entry.reset(impl); 3531 3532 ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter(); 3533 3534 if (interpreter && interpreter->CheckObjectExists(impl->GetPythonClassName()) == false) 3535 result.AppendWarning("The provided class does not exist - please define it before attempting to use this synthetic provider"); 3536 3537 // now I have a valid provider, let's add it to every type 3538 3539 lldb::TypeCategoryImplSP category; 3540 DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); 3541 3542 Error error; 3543 3544 for (size_t i = 0; i < argc; i++) 3545 { 3546 const char* typeA = command.GetArgumentAtIndex(i); 3547 ConstString typeCS(typeA); 3548 if (typeCS) 3549 { 3550 if (!AddSynth(typeCS, 3551 entry, 3552 m_options.m_regex ? eRegexSynth : eRegularSynth, 3553 m_options.m_category, 3554 &error)) 3555 { 3556 result.AppendError(error.AsCString()); 3557 result.SetStatus(eReturnStatusFailed); 3558 return false; 3559 } 3560 } 3561 else 3562 { 3563 result.AppendError("empty typenames not allowed"); 3564 result.SetStatus(eReturnStatusFailed); 3565 return false; 3566 } 3567 } 3568 3569 result.SetStatus(eReturnStatusSuccessFinishNoResult); 3570 return result.Succeeded(); 3571 } 3572 3573 CommandObjectTypeSynthAdd::CommandObjectTypeSynthAdd (CommandInterpreter &interpreter) : 3574 CommandObjectParsed (interpreter, 3575 "type synthetic add", 3576 "Add a new synthetic provider for a type.", 3577 NULL), 3578 m_options (interpreter) 3579 { 3580 CommandArgumentEntry type_arg; 3581 CommandArgumentData type_style_arg; 3582 3583 type_style_arg.arg_type = eArgTypeName; 3584 type_style_arg.arg_repetition = eArgRepeatPlus; 3585 3586 type_arg.push_back (type_style_arg); 3587 3588 m_arguments.push_back (type_arg); 3589 3590 } 3591 3592 bool 3593 CommandObjectTypeSynthAdd::AddSynth(ConstString type_name, 3594 SyntheticChildrenSP entry, 3595 SynthFormatType type, 3596 std::string category_name, 3597 Error* error) 3598 { 3599 lldb::TypeCategoryImplSP category; 3600 DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), category); 3601 3602 if (type == eRegularSynth) 3603 { 3604 std::string type_name_str(type_name.GetCString()); 3605 if (type_name_str.compare(type_name_str.length() - 2, 2, "[]") == 0) 3606 { 3607 type_name_str.resize(type_name_str.length()-2); 3608 if (type_name_str.back() != ' ') 3609 type_name_str.append(" \\[[0-9]+\\]"); 3610 else 3611 type_name_str.append("\\[[0-9]+\\]"); 3612 type_name.SetCString(type_name_str.c_str()); 3613 type = eRegularSynth; 3614 } 3615 } 3616 3617 if (category->AnyMatches(type_name, 3618 eFormatCategoryItemFilter | eFormatCategoryItemRegexFilter, 3619 false)) 3620 { 3621 if (error) 3622 error->SetErrorStringWithFormat("cannot add synthetic for type %s when filter is defined in same category!", type_name.AsCString()); 3623 return false; 3624 } 3625 3626 if (type == eRegexSynth) 3627 { 3628 RegularExpressionSP typeRX(new RegularExpression()); 3629 if (!typeRX->Compile(type_name.GetCString())) 3630 { 3631 if (error) 3632 error->SetErrorString("regex format error (maybe this is not really a regex?)"); 3633 return false; 3634 } 3635 3636 category->GetRegexSyntheticNavigator()->Delete(type_name); 3637 category->GetRegexSyntheticNavigator()->Add(typeRX, entry); 3638 3639 return true; 3640 } 3641 else 3642 { 3643 category->GetSyntheticNavigator()->Add(type_name, entry); 3644 return true; 3645 } 3646 } 3647 3648 bool 3649 CommandObjectTypeSynthAdd::DoExecute (Args& command, CommandReturnObject &result) 3650 { 3651 if (m_options.handwrite_python) 3652 return Execute_HandwritePython(command, result); 3653 else if (m_options.is_class_based) 3654 return Execute_PythonClass(command, result); 3655 else 3656 { 3657 result.AppendError("must either provide a children list, a Python class name, or use -P and type a Python class line-by-line"); 3658 result.SetStatus(eReturnStatusFailed); 3659 return false; 3660 } 3661 } 3662 3663 OptionDefinition 3664 CommandObjectTypeSynthAdd::CommandOptions::g_option_table[] = 3665 { 3666 { LLDB_OPT_SET_ALL, false, "cascade", 'C', required_argument, NULL, 0, eArgTypeBoolean, "If true, cascade through typedef chains."}, 3667 { LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."}, 3668 { LLDB_OPT_SET_ALL, false, "skip-references", 'r', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for references-to-type objects."}, 3669 { LLDB_OPT_SET_ALL, false, "category", 'w', required_argument, NULL, 0, eArgTypeName, "Add this to the given category instead of the default one."}, 3670 { LLDB_OPT_SET_2, false, "python-class", 'l', required_argument, NULL, 0, eArgTypePythonClass, "Use this Python class to produce synthetic children."}, 3671 { LLDB_OPT_SET_3, false, "input-python", 'P', no_argument, NULL, 0, eArgTypeNone, "Type Python code to generate a class that provides synthetic children."}, 3672 { LLDB_OPT_SET_ALL, false, "regex", 'x', no_argument, NULL, 0, eArgTypeNone, "Type names are actually regular expressions."}, 3673 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 3674 }; 3675 3676 #endif // #ifndef LLDB_DISABLE_PYTHON 3677 3678 class CommandObjectTypeFilterAdd : public CommandObjectParsed 3679 { 3680 3681 private: 3682 3683 class CommandOptions : public Options 3684 { 3685 typedef std::vector<std::string> option_vector; 3686 public: 3687 3688 CommandOptions (CommandInterpreter &interpreter) : 3689 Options (interpreter) 3690 { 3691 } 3692 3693 virtual 3694 ~CommandOptions (){} 3695 3696 virtual Error 3697 SetOptionValue (uint32_t option_idx, const char *option_arg) 3698 { 3699 Error error; 3700 const int short_option = m_getopt_table[option_idx].val; 3701 bool success; 3702 3703 switch (short_option) 3704 { 3705 case 'C': 3706 m_cascade = Args::StringToBoolean(option_arg, true, &success); 3707 if (!success) 3708 error.SetErrorStringWithFormat("invalid value for cascade: %s", option_arg); 3709 break; 3710 case 'c': 3711 m_expr_paths.push_back(option_arg); 3712 has_child_list = true; 3713 break; 3714 case 'p': 3715 m_skip_pointers = true; 3716 break; 3717 case 'r': 3718 m_skip_references = true; 3719 break; 3720 case 'w': 3721 m_category = std::string(option_arg); 3722 break; 3723 case 'x': 3724 m_regex = true; 3725 break; 3726 default: 3727 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); 3728 break; 3729 } 3730 3731 return error; 3732 } 3733 3734 void 3735 OptionParsingStarting () 3736 { 3737 m_cascade = true; 3738 m_skip_pointers = false; 3739 m_skip_references = false; 3740 m_category = "default"; 3741 m_expr_paths.clear(); 3742 has_child_list = false; 3743 m_regex = false; 3744 } 3745 3746 const OptionDefinition* 3747 GetDefinitions () 3748 { 3749 return g_option_table; 3750 } 3751 3752 // Options table: Required for subclasses of Options. 3753 3754 static OptionDefinition g_option_table[]; 3755 3756 // Instance variables to hold the values for command options. 3757 3758 bool m_cascade; 3759 bool m_skip_references; 3760 bool m_skip_pointers; 3761 bool m_input_python; 3762 option_vector m_expr_paths; 3763 std::string m_category; 3764 3765 bool has_child_list; 3766 3767 bool m_regex; 3768 3769 typedef option_vector::iterator ExpressionPathsIterator; 3770 }; 3771 3772 CommandOptions m_options; 3773 3774 virtual Options * 3775 GetOptions () 3776 { 3777 return &m_options; 3778 } 3779 3780 enum FilterFormatType 3781 { 3782 eRegularFilter, 3783 eRegexFilter 3784 }; 3785 3786 bool 3787 AddFilter(ConstString type_name, 3788 SyntheticChildrenSP entry, 3789 FilterFormatType type, 3790 std::string category_name, 3791 Error* error) 3792 { 3793 lldb::TypeCategoryImplSP category; 3794 DataVisualization::Categories::GetCategory(ConstString(category_name.c_str()), category); 3795 3796 if (type == eRegularFilter) 3797 { 3798 std::string type_name_str(type_name.GetCString()); 3799 if (type_name_str.compare(type_name_str.length() - 2, 2, "[]") == 0) 3800 { 3801 type_name_str.resize(type_name_str.length()-2); 3802 if (type_name_str.back() != ' ') 3803 type_name_str.append(" \\[[0-9]+\\]"); 3804 else 3805 type_name_str.append("\\[[0-9]+\\]"); 3806 type_name.SetCString(type_name_str.c_str()); 3807 type = eRegexFilter; 3808 } 3809 } 3810 3811 if (category->AnyMatches(type_name, 3812 eFormatCategoryItemSynth | eFormatCategoryItemRegexSynth, 3813 false)) 3814 { 3815 if (error) 3816 error->SetErrorStringWithFormat("cannot add filter for type %s when synthetic is defined in same category!", type_name.AsCString()); 3817 return false; 3818 } 3819 3820 if (type == eRegexFilter) 3821 { 3822 RegularExpressionSP typeRX(new RegularExpression()); 3823 if (!typeRX->Compile(type_name.GetCString())) 3824 { 3825 if (error) 3826 error->SetErrorString("regex format error (maybe this is not really a regex?)"); 3827 return false; 3828 } 3829 3830 category->GetRegexFilterNavigator()->Delete(type_name); 3831 category->GetRegexFilterNavigator()->Add(typeRX, entry); 3832 3833 return true; 3834 } 3835 else 3836 { 3837 category->GetFilterNavigator()->Add(type_name, entry); 3838 return true; 3839 } 3840 } 3841 3842 3843 public: 3844 3845 CommandObjectTypeFilterAdd (CommandInterpreter &interpreter) : 3846 CommandObjectParsed (interpreter, 3847 "type filter add", 3848 "Add a new filter for a type.", 3849 NULL), 3850 m_options (interpreter) 3851 { 3852 CommandArgumentEntry type_arg; 3853 CommandArgumentData type_style_arg; 3854 3855 type_style_arg.arg_type = eArgTypeName; 3856 type_style_arg.arg_repetition = eArgRepeatPlus; 3857 3858 type_arg.push_back (type_style_arg); 3859 3860 m_arguments.push_back (type_arg); 3861 3862 SetHelpLong( 3863 "Some examples of using this command.\n" 3864 "We use as reference the following snippet of code:\n" 3865 "\n" 3866 "class Foo {;\n" 3867 " int a;\n" 3868 " int b;\n" 3869 " int c;\n" 3870 " int d;\n" 3871 " int e;\n" 3872 " int f;\n" 3873 " int g;\n" 3874 " int h;\n" 3875 " int i;\n" 3876 "} \n" 3877 "Typing:\n" 3878 "type filter add --child a --child g Foo\n" 3879 "frame variable a_foo\n" 3880 "will produce an output where only a and g are displayed\n" 3881 "Other children of a_foo (b,c,d,e,f,h and i) are available by asking for them, as in:\n" 3882 "frame variable a_foo.b a_foo.c ... a_foo.i\n" 3883 "\n" 3884 "Use option --raw to frame variable prevails on the filter\n" 3885 "frame variable a_foo --raw\n" 3886 "shows all the children of a_foo (a thru i) as if no filter was defined\n" 3887 ); 3888 } 3889 3890 ~CommandObjectTypeFilterAdd () 3891 { 3892 } 3893 3894 protected: 3895 bool 3896 DoExecute (Args& command, CommandReturnObject &result) 3897 { 3898 const size_t argc = command.GetArgumentCount(); 3899 3900 if (argc < 1) 3901 { 3902 result.AppendErrorWithFormat ("%s takes one or more args.\n", m_cmd_name.c_str()); 3903 result.SetStatus(eReturnStatusFailed); 3904 return false; 3905 } 3906 3907 if (m_options.m_expr_paths.size() == 0) 3908 { 3909 result.AppendErrorWithFormat ("%s needs one or more children.\n", m_cmd_name.c_str()); 3910 result.SetStatus(eReturnStatusFailed); 3911 return false; 3912 } 3913 3914 SyntheticChildrenSP entry; 3915 3916 TypeFilterImpl* impl = new TypeFilterImpl(SyntheticChildren::Flags().SetCascades(m_options.m_cascade). 3917 SetSkipPointers(m_options.m_skip_pointers). 3918 SetSkipReferences(m_options.m_skip_references)); 3919 3920 entry.reset(impl); 3921 3922 // go through the expression paths 3923 CommandOptions::ExpressionPathsIterator begin, end = m_options.m_expr_paths.end(); 3924 3925 for (begin = m_options.m_expr_paths.begin(); begin != end; begin++) 3926 impl->AddExpressionPath(*begin); 3927 3928 3929 // now I have a valid provider, let's add it to every type 3930 3931 lldb::TypeCategoryImplSP category; 3932 DataVisualization::Categories::GetCategory(ConstString(m_options.m_category.c_str()), category); 3933 3934 Error error; 3935 3936 for (size_t i = 0; i < argc; i++) 3937 { 3938 const char* typeA = command.GetArgumentAtIndex(i); 3939 ConstString typeCS(typeA); 3940 if (typeCS) 3941 { 3942 if (!AddFilter(typeCS, 3943 entry, 3944 m_options.m_regex ? eRegexFilter : eRegularFilter, 3945 m_options.m_category, 3946 &error)) 3947 { 3948 result.AppendError(error.AsCString()); 3949 result.SetStatus(eReturnStatusFailed); 3950 return false; 3951 } 3952 } 3953 else 3954 { 3955 result.AppendError("empty typenames not allowed"); 3956 result.SetStatus(eReturnStatusFailed); 3957 return false; 3958 } 3959 } 3960 3961 result.SetStatus(eReturnStatusSuccessFinishNoResult); 3962 return result.Succeeded(); 3963 } 3964 3965 }; 3966 3967 OptionDefinition 3968 CommandObjectTypeFilterAdd::CommandOptions::g_option_table[] = 3969 { 3970 { LLDB_OPT_SET_ALL, false, "cascade", 'C', required_argument, NULL, 0, eArgTypeBoolean, "If true, cascade through typedef chains."}, 3971 { LLDB_OPT_SET_ALL, false, "skip-pointers", 'p', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for pointers-to-type objects."}, 3972 { LLDB_OPT_SET_ALL, false, "skip-references", 'r', no_argument, NULL, 0, eArgTypeNone, "Don't use this format for references-to-type objects."}, 3973 { LLDB_OPT_SET_ALL, false, "category", 'w', required_argument, NULL, 0, eArgTypeName, "Add this to the given category instead of the default one."}, 3974 { LLDB_OPT_SET_ALL, false, "child", 'c', required_argument, NULL, 0, eArgTypeExpressionPath, "Include this expression path in the synthetic view."}, 3975 { LLDB_OPT_SET_ALL, false, "regex", 'x', no_argument, NULL, 0, eArgTypeNone, "Type names are actually regular expressions."}, 3976 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL } 3977 }; 3978 3979 class CommandObjectTypeFormat : public CommandObjectMultiword 3980 { 3981 public: 3982 CommandObjectTypeFormat (CommandInterpreter &interpreter) : 3983 CommandObjectMultiword (interpreter, 3984 "type format", 3985 "A set of commands for editing variable value display options", 3986 "type format [<sub-command-options>] ") 3987 { 3988 LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeFormatAdd (interpreter))); 3989 LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeFormatClear (interpreter))); 3990 LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeFormatDelete (interpreter))); 3991 LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeFormatList (interpreter))); 3992 } 3993 3994 3995 ~CommandObjectTypeFormat () 3996 { 3997 } 3998 }; 3999 4000 #ifndef LLDB_DISABLE_PYTHON 4001 4002 class CommandObjectTypeSynth : public CommandObjectMultiword 4003 { 4004 public: 4005 CommandObjectTypeSynth (CommandInterpreter &interpreter) : 4006 CommandObjectMultiword (interpreter, 4007 "type synthetic", 4008 "A set of commands for operating on synthetic type representations", 4009 "type synthetic [<sub-command-options>] ") 4010 { 4011 LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeSynthAdd (interpreter))); 4012 LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeSynthClear (interpreter))); 4013 LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeSynthDelete (interpreter))); 4014 LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeSynthList (interpreter))); 4015 } 4016 4017 4018 ~CommandObjectTypeSynth () 4019 { 4020 } 4021 }; 4022 4023 #endif // #ifndef LLDB_DISABLE_PYTHON 4024 4025 class CommandObjectTypeFilter : public CommandObjectMultiword 4026 { 4027 public: 4028 CommandObjectTypeFilter (CommandInterpreter &interpreter) : 4029 CommandObjectMultiword (interpreter, 4030 "type filter", 4031 "A set of commands for operating on type filters", 4032 "type synthetic [<sub-command-options>] ") 4033 { 4034 LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeFilterAdd (interpreter))); 4035 LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeFilterClear (interpreter))); 4036 LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeFilterDelete (interpreter))); 4037 LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeFilterList (interpreter))); 4038 } 4039 4040 4041 ~CommandObjectTypeFilter () 4042 { 4043 } 4044 }; 4045 4046 class CommandObjectTypeCategory : public CommandObjectMultiword 4047 { 4048 public: 4049 CommandObjectTypeCategory (CommandInterpreter &interpreter) : 4050 CommandObjectMultiword (interpreter, 4051 "type category", 4052 "A set of commands for operating on categories", 4053 "type category [<sub-command-options>] ") 4054 { 4055 LoadSubCommand ("enable", CommandObjectSP (new CommandObjectTypeCategoryEnable (interpreter))); 4056 LoadSubCommand ("disable", CommandObjectSP (new CommandObjectTypeCategoryDisable (interpreter))); 4057 LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeCategoryDelete (interpreter))); 4058 LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeCategoryList (interpreter))); 4059 } 4060 4061 4062 ~CommandObjectTypeCategory () 4063 { 4064 } 4065 }; 4066 4067 class CommandObjectTypeSummary : public CommandObjectMultiword 4068 { 4069 public: 4070 CommandObjectTypeSummary (CommandInterpreter &interpreter) : 4071 CommandObjectMultiword (interpreter, 4072 "type summary", 4073 "A set of commands for editing variable summary display options", 4074 "type summary [<sub-command-options>] ") 4075 { 4076 LoadSubCommand ("add", CommandObjectSP (new CommandObjectTypeSummaryAdd (interpreter))); 4077 LoadSubCommand ("clear", CommandObjectSP (new CommandObjectTypeSummaryClear (interpreter))); 4078 LoadSubCommand ("delete", CommandObjectSP (new CommandObjectTypeSummaryDelete (interpreter))); 4079 LoadSubCommand ("list", CommandObjectSP (new CommandObjectTypeSummaryList (interpreter))); 4080 } 4081 4082 4083 ~CommandObjectTypeSummary () 4084 { 4085 } 4086 }; 4087 4088 //------------------------------------------------------------------------- 4089 // CommandObjectType 4090 //------------------------------------------------------------------------- 4091 4092 CommandObjectType::CommandObjectType (CommandInterpreter &interpreter) : 4093 CommandObjectMultiword (interpreter, 4094 "type", 4095 "A set of commands for operating on the type system", 4096 "type [<sub-command-options>]") 4097 { 4098 LoadSubCommand ("category", CommandObjectSP (new CommandObjectTypeCategory (interpreter))); 4099 LoadSubCommand ("filter", CommandObjectSP (new CommandObjectTypeFilter (interpreter))); 4100 LoadSubCommand ("format", CommandObjectSP (new CommandObjectTypeFormat (interpreter))); 4101 LoadSubCommand ("summary", CommandObjectSP (new CommandObjectTypeSummary (interpreter))); 4102 #ifndef LLDB_DISABLE_PYTHON 4103 LoadSubCommand ("synthetic", CommandObjectSP (new CommandObjectTypeSynth (interpreter))); 4104 #endif 4105 } 4106 4107 4108 CommandObjectType::~CommandObjectType () 4109 { 4110 } 4111 4112 4113
