1 //===-- CommandObjectFrame.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 "CommandObjectFrame.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Core/Debugger.h" 17 #include "lldb/Core/Module.h" 18 #include "lldb/Core/StreamFile.h" 19 #include "lldb/Core/Timer.h" 20 #include "lldb/Core/Value.h" 21 #include "lldb/Core/ValueObject.h" 22 #include "lldb/Core/ValueObjectVariable.h" 23 #include "lldb/Interpreter/Args.h" 24 #include "lldb/Interpreter/CommandInterpreter.h" 25 #include "lldb/Interpreter/CommandReturnObject.h" 26 #include "lldb/Interpreter/Options.h" 27 #include "lldb/Symbol/ClangASTType.h" 28 #include "lldb/Symbol/ClangASTContext.h" 29 #include "lldb/Symbol/ObjectFile.h" 30 #include "lldb/Symbol/SymbolContext.h" 31 #include "lldb/Symbol/Type.h" 32 #include "lldb/Symbol/Variable.h" 33 #include "lldb/Symbol/VariableList.h" 34 #include "lldb/Target/Process.h" 35 #include "lldb/Target/StackFrame.h" 36 #include "lldb/Target/Thread.h" 37 #include "lldb/Target/Target.h" 38 39 #include "CommandObjectThread.h" 40 41 using namespace lldb; 42 using namespace lldb_private; 43 44 #pragma mark CommandObjectFrameInfo 45 46 //------------------------------------------------------------------------- 47 // CommandObjectFrameInfo 48 //------------------------------------------------------------------------- 49 50 class CommandObjectFrameInfo : public CommandObject 51 { 52 public: 53 54 CommandObjectFrameInfo (CommandInterpreter &interpreter) : 55 CommandObject (interpreter, 56 "frame info", 57 "List information about the currently selected frame in the current thread.", 58 "frame info", 59 eFlagProcessMustBeLaunched | eFlagProcessMustBePaused) 60 { 61 } 62 63 ~CommandObjectFrameInfo () 64 { 65 } 66 67 bool 68 Execute (Args& command, 69 CommandReturnObject &result) 70 { 71 ExecutionContext exe_ctx(m_interpreter.GetDebugger().GetExecutionContext()); 72 if (exe_ctx.frame) 73 { 74 exe_ctx.frame->DumpUsingSettingsFormat (&result.GetOutputStream()); 75 result.GetOutputStream().EOL(); 76 result.SetStatus (eReturnStatusSuccessFinishResult); 77 } 78 else 79 { 80 result.AppendError ("no current frame"); 81 result.SetStatus (eReturnStatusFailed); 82 } 83 return result.Succeeded(); 84 } 85 }; 86 87 #pragma mark CommandObjectFrameSelect 88 89 //------------------------------------------------------------------------- 90 // CommandObjectFrameSelect 91 //------------------------------------------------------------------------- 92 93 class CommandObjectFrameSelect : public CommandObject 94 { 95 public: 96 97 class CommandOptions : public Options 98 { 99 public: 100 101 CommandOptions () : 102 Options() 103 { 104 ResetOptionValues (); 105 } 106 107 virtual 108 ~CommandOptions () 109 { 110 } 111 112 virtual Error 113 SetOptionValue (int option_idx, const char *option_arg) 114 { 115 Error error; 116 bool success = false; 117 char short_option = (char) m_getopt_table[option_idx].val; 118 switch (short_option) 119 { 120 case 'r': 121 relative_frame_offset = Args::StringToSInt32 (option_arg, INT32_MIN, 0, &success); 122 if (!success) 123 error.SetErrorStringWithFormat ("invalid frame offset argument '%s'.\n", option_arg); 124 break; 125 126 default: 127 error.SetErrorStringWithFormat ("Invalid short option character '%c'.\n", short_option); 128 break; 129 } 130 131 return error; 132 } 133 134 void 135 ResetOptionValues () 136 { 137 Options::ResetOptionValues(); 138 relative_frame_offset = INT32_MIN; 139 } 140 141 const lldb::OptionDefinition* 142 GetDefinitions () 143 { 144 return g_option_table; 145 } 146 147 // Options table: Required for subclasses of Options. 148 149 static lldb::OptionDefinition g_option_table[]; 150 int32_t relative_frame_offset; 151 }; 152 153 CommandObjectFrameSelect (CommandInterpreter &interpreter) : 154 CommandObject (interpreter, 155 "frame select", 156 "Select a frame by index from within the current thread and make it the current frame.", 157 NULL, 158 eFlagProcessMustBeLaunched | eFlagProcessMustBePaused) 159 { 160 CommandArgumentEntry arg; 161 CommandArgumentData index_arg; 162 163 // Define the first (and only) variant of this arg. 164 index_arg.arg_type = eArgTypeFrameIndex; 165 index_arg.arg_repetition = eArgRepeatOptional; 166 167 // There is only one variant this argument could be; put it into the argument entry. 168 arg.push_back (index_arg); 169 170 // Push the data for the first argument into the m_arguments vector. 171 m_arguments.push_back (arg); 172 } 173 174 ~CommandObjectFrameSelect () 175 { 176 } 177 178 virtual 179 Options * 180 GetOptions () 181 { 182 return &m_options; 183 } 184 185 186 bool 187 Execute (Args& command, 188 CommandReturnObject &result) 189 { 190 ExecutionContext exe_ctx (m_interpreter.GetDebugger().GetExecutionContext()); 191 if (exe_ctx.thread) 192 { 193 const uint32_t num_frames = exe_ctx.thread->GetStackFrameCount(); 194 uint32_t frame_idx = UINT32_MAX; 195 if (m_options.relative_frame_offset != INT32_MIN) 196 { 197 // The one and only argument is a signed relative frame index 198 frame_idx = exe_ctx.thread->GetSelectedFrameIndex (); 199 if (frame_idx == UINT32_MAX) 200 frame_idx = 0; 201 202 if (m_options.relative_frame_offset < 0) 203 { 204 if (frame_idx >= -m_options.relative_frame_offset) 205 frame_idx += m_options.relative_frame_offset; 206 else 207 frame_idx = 0; 208 } 209 else if (m_options.relative_frame_offset > 0) 210 { 211 if (num_frames - frame_idx > m_options.relative_frame_offset) 212 frame_idx += m_options.relative_frame_offset; 213 else 214 frame_idx = num_frames - 1; 215 } 216 } 217 else 218 { 219 if (command.GetArgumentCount() == 1) 220 { 221 const char *frame_idx_cstr = command.GetArgumentAtIndex(0); 222 frame_idx = Args::StringToUInt32 (frame_idx_cstr, UINT32_MAX, 0); 223 } 224 else 225 { 226 result.AppendError ("invalid arguments.\n"); 227 m_options.GenerateOptionUsage (m_interpreter, result.GetErrorStream(), this); 228 } 229 } 230 231 if (frame_idx < num_frames) 232 { 233 exe_ctx.thread->SetSelectedFrameByIndex (frame_idx); 234 exe_ctx.frame = exe_ctx.thread->GetSelectedFrame ().get(); 235 236 if (exe_ctx.frame) 237 { 238 bool already_shown = false; 239 SymbolContext frame_sc(exe_ctx.frame->GetSymbolContext(eSymbolContextLineEntry)); 240 if (m_interpreter.GetDebugger().GetUseExternalEditor() && frame_sc.line_entry.file && frame_sc.line_entry.line != 0) 241 { 242 already_shown = Host::OpenFileInExternalEditor (frame_sc.line_entry.file, frame_sc.line_entry.line); 243 } 244 245 if (DisplayFrameForExecutionContext (exe_ctx.thread, 246 exe_ctx.frame, 247 m_interpreter, 248 result.GetOutputStream(), 249 true, 250 !already_shown, 251 3, 252 3)) 253 { 254 result.SetStatus (eReturnStatusSuccessFinishResult); 255 return result.Succeeded(); 256 } 257 } 258 } 259 result.AppendErrorWithFormat ("Frame index (%u) out of range.\n", frame_idx); 260 } 261 else 262 { 263 result.AppendError ("no current thread"); 264 } 265 result.SetStatus (eReturnStatusFailed); 266 return false; 267 } 268 protected: 269 270 CommandOptions m_options; 271 }; 272 273 lldb::OptionDefinition 274 CommandObjectFrameSelect::CommandOptions::g_option_table[] = 275 { 276 { LLDB_OPT_SET_1, false, "relative", 'r', required_argument, NULL, 0, eArgTypeOffset, "A relative frame index offset from the current frame index."}, 277 { 0, false, NULL, 0, 0, NULL, NULL, eArgTypeNone, NULL } 278 }; 279 280 #pragma mark CommandObjectFrameVariable 281 //---------------------------------------------------------------------- 282 // List images with associated information 283 //---------------------------------------------------------------------- 284 class CommandObjectFrameVariable : public CommandObject 285 { 286 public: 287 288 class CommandOptions : public Options 289 { 290 public: 291 292 CommandOptions () : 293 Options() 294 { 295 ResetOptionValues (); 296 } 297 298 virtual 299 ~CommandOptions () 300 { 301 } 302 303 virtual Error 304 SetOptionValue (int option_idx, const char *option_arg) 305 { 306 Error error; 307 bool success; 308 char short_option = (char) m_getopt_table[option_idx].val; 309 switch (short_option) 310 { 311 case 'o': use_objc = true; break; 312 case 'r': use_regex = true; break; 313 case 'a': show_args = false; break; 314 case 'l': show_locals = false; break; 315 case 'g': show_globals = true; break; 316 case 't': show_types = true; break; 317 case 'y': show_summary = false; break; 318 case 'L': show_location= true; break; 319 case 'c': show_decl = true; break; 320 case 'D': debug = true; break; 321 case 'f': flat_output = true; break; 322 case 'd': 323 max_depth = Args::StringToUInt32 (option_arg, UINT32_MAX, 0, &success); 324 if (!success) 325 error.SetErrorStringWithFormat("Invalid max depth '%s'.\n", option_arg); 326 break; 327 328 case 'p': 329 ptr_depth = Args::StringToUInt32 (option_arg, 0, 0, &success); 330 if (!success) 331 error.SetErrorStringWithFormat("Invalid pointer depth '%s'.\n", option_arg); 332 break; 333 334 case 'G': 335 globals.push_back(ConstString (option_arg)); 336 break; 337 338 case 's': 339 show_scope = true; 340 break; 341 342 default: 343 error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option); 344 break; 345 } 346 347 return error; 348 } 349 350 void 351 ResetOptionValues () 352 { 353 Options::ResetOptionValues(); 354 355 use_objc = false; 356 use_regex = false; 357 show_args = true; 358 show_locals = true; 359 show_globals = false; 360 show_types = false; 361 show_scope = false; 362 show_summary = true; 363 show_location = false; 364 show_decl = false; 365 debug = false; 366 flat_output = false; 367 max_depth = UINT32_MAX; 368 ptr_depth = 0; 369 globals.clear(); 370 } 371 372 const lldb::OptionDefinition* 373 GetDefinitions () 374 { 375 return g_option_table; 376 } 377 378 // Options table: Required for subclasses of Options. 379 380 static lldb::OptionDefinition g_option_table[]; 381 bool use_objc:1, 382 use_regex:1, 383 show_args:1, 384 show_locals:1, 385 show_globals:1, 386 show_types:1, 387 show_scope:1, 388 show_summary:1, 389 show_location:1, 390 show_decl:1, 391 debug:1, 392 flat_output:1; 393 uint32_t max_depth; // The depth to print when dumping concrete (not pointers) aggreate values 394 uint32_t ptr_depth; // The default depth that is dumped when we find pointers 395 std::vector<ConstString> globals; 396 // Instance variables to hold the values for command options. 397 }; 398 399 CommandObjectFrameVariable (CommandInterpreter &interpreter) : 400 CommandObject (interpreter, 401 "frame variable", 402 "Show frame variables. All argument and local variables " 403 "that are in scope will be shown when no arguments are given. " 404 "If any arguments are specified, they can be names of " 405 "argument, local, file static and file global variables. " 406 "Children of aggregate variables can be specified such as " 407 "'var->child.x'.", 408 NULL, 409 eFlagProcessMustBeLaunched | eFlagProcessMustBePaused) 410 { 411 CommandArgumentEntry arg; 412 CommandArgumentData var_name_arg; 413 414 // Define the first (and only) variant of this arg. 415 var_name_arg.arg_type = eArgTypeVarName; 416 var_name_arg.arg_repetition = eArgRepeatStar; 417 418 // There is only one variant this argument could be; put it into the argument entry. 419 arg.push_back (var_name_arg); 420 421 // Push the data for the first argument into the m_arguments vector. 422 m_arguments.push_back (arg); 423 } 424 425 virtual 426 ~CommandObjectFrameVariable () 427 { 428 } 429 430 virtual 431 Options * 432 GetOptions () 433 { 434 return &m_options; 435 } 436 437 438 virtual bool 439 Execute 440 ( 441 Args& command, 442 CommandReturnObject &result 443 ) 444 { 445 ExecutionContext exe_ctx(m_interpreter.GetDebugger().GetExecutionContext()); 446 if (exe_ctx.frame == NULL) 447 { 448 result.AppendError ("you must be stopped in a valid stack frame to view frame variables."); 449 result.SetStatus (eReturnStatusFailed); 450 return false; 451 } 452 else 453 { 454 Stream &s = result.GetOutputStream(); 455 456 bool get_file_globals = true; 457 VariableList *variable_list = exe_ctx.frame->GetVariableList (get_file_globals); 458 459 VariableSP var_sp; 460 ValueObjectSP valobj_sp; 461 //ValueObjectList &valobj_list = exe_ctx.frame->GetValueObjectList(); 462 const char *name_cstr = NULL; 463 size_t idx; 464 if (!m_options.globals.empty()) 465 { 466 uint32_t fail_count = 0; 467 if (exe_ctx.target) 468 { 469 const size_t num_globals = m_options.globals.size(); 470 for (idx = 0; idx < num_globals; ++idx) 471 { 472 VariableList global_var_list; 473 const uint32_t num_matching_globals = exe_ctx.target->GetImages().FindGlobalVariables (m_options.globals[idx], true, UINT32_MAX, global_var_list); 474 475 if (num_matching_globals == 0) 476 { 477 ++fail_count; 478 result.GetErrorStream().Printf ("error: can't find global variable '%s'\n", m_options.globals[idx].AsCString()); 479 } 480 else 481 { 482 for (uint32_t global_idx=0; global_idx<num_matching_globals; ++global_idx) 483 { 484 var_sp = global_var_list.GetVariableAtIndex(global_idx); 485 if (var_sp) 486 { 487 valobj_sp = exe_ctx.frame->GetValueObjectForFrameVariable (var_sp); 488 if (!valobj_sp) 489 valobj_sp = exe_ctx.frame->TrackGlobalVariable (var_sp); 490 491 if (valobj_sp) 492 { 493 if (m_options.show_decl && var_sp->GetDeclaration ().GetFile()) 494 { 495 var_sp->GetDeclaration ().DumpStopContext (&s, false); 496 s.PutCString (": "); 497 } 498 499 ValueObject::DumpValueObject (result.GetOutputStream(), 500 exe_ctx.frame, 501 valobj_sp.get(), 502 name_cstr, 503 m_options.ptr_depth, 504 0, 505 m_options.max_depth, 506 m_options.show_types, 507 m_options.show_location, 508 m_options.use_objc, 509 false, 510 m_options.flat_output); 511 } 512 } 513 } 514 } 515 } 516 } 517 if (fail_count) 518 result.SetStatus (eReturnStatusFailed); 519 } 520 else if (variable_list) 521 { 522 if (command.GetArgumentCount() > 0) 523 { 524 VariableList regex_var_list; 525 526 // If we have any args to the variable command, we will make 527 // variable objects from them... 528 for (idx = 0; (name_cstr = command.GetArgumentAtIndex(idx)) != NULL; ++idx) 529 { 530 uint32_t ptr_depth = m_options.ptr_depth; 531 532 if (m_options.use_regex) 533 { 534 const uint32_t regex_start_index = regex_var_list.GetSize(); 535 RegularExpression regex (name_cstr); 536 if (regex.Compile(name_cstr)) 537 { 538 size_t num_matches = 0; 539 const size_t num_new_regex_vars = variable_list->AppendVariablesIfUnique(regex, regex_var_list, num_matches); 540 if (num_new_regex_vars > 0) 541 { 542 for (uint32_t regex_idx = regex_start_index, end_index = regex_var_list.GetSize(); 543 regex_idx < end_index; 544 ++regex_idx) 545 { 546 var_sp = regex_var_list.GetVariableAtIndex (regex_idx); 547 if (var_sp) 548 { 549 valobj_sp = exe_ctx.frame->GetValueObjectForFrameVariable (var_sp); 550 if (valobj_sp) 551 { 552 if (m_options.show_decl && var_sp->GetDeclaration ().GetFile()) 553 { 554 var_sp->GetDeclaration ().DumpStopContext (&s, false); 555 s.PutCString (": "); 556 } 557 558 ValueObject::DumpValueObject (result.GetOutputStream(), 559 exe_ctx.frame, 560 valobj_sp.get(), 561 var_sp->GetName().AsCString(), 562 m_options.ptr_depth, 563 0, 564 m_options.max_depth, 565 m_options.show_types, 566 m_options.show_location, 567 m_options.use_objc, 568 false, 569 m_options.flat_output); 570 } 571 } 572 } 573 } 574 else if (num_matches == 0) 575 { 576 result.GetErrorStream().Printf ("error: no variables matched the regular expression '%s'.\n", name_cstr); 577 } 578 } 579 else 580 { 581 char regex_error[1024]; 582 if (regex.GetErrorAsCString(regex_error, sizeof(regex_error))) 583 result.GetErrorStream().Printf ("error: %s\n", regex_error); 584 else 585 result.GetErrorStream().Printf ("error: unkown regex error when compiling '%s'\n", name_cstr); 586 } 587 } 588 else 589 { 590 Error error; 591 const uint32_t expr_path_options = StackFrame::eExpressionPathOptionCheckPtrVsMember; 592 valobj_sp = exe_ctx.frame->GetValueForVariableExpressionPath (name_cstr, expr_path_options, error); 593 if (valobj_sp) 594 { 595 if (m_options.show_decl && var_sp->GetDeclaration ().GetFile()) 596 { 597 var_sp->GetDeclaration ().DumpStopContext (&s, false); 598 s.PutCString (": "); 599 } 600 ValueObject::DumpValueObject (result.GetOutputStream(), 601 exe_ctx.frame, 602 valobj_sp.get(), 603 valobj_sp->GetParent() ? name_cstr : NULL, 604 ptr_depth, 605 0, 606 m_options.max_depth, 607 m_options.show_types, 608 m_options.show_location, 609 m_options.use_objc, 610 false, 611 m_options.flat_output); 612 } 613 else 614 { 615 const char *error_cstr = error.AsCString(NULL); 616 if (error_cstr) 617 result.GetErrorStream().Printf("error: %s\n", error_cstr); 618 else 619 result.GetErrorStream().Printf ("error: unable to find any variable expression path that matches '%s'\n", name_cstr); 620 } 621 } 622 } 623 } 624 else 625 { 626 const uint32_t num_variables = variable_list->GetSize(); 627 628 if (num_variables > 0) 629 { 630 for (uint32_t i=0; i<num_variables; i++) 631 { 632 var_sp = variable_list->GetVariableAtIndex(i); 633 bool dump_variable = true; 634 635 switch (var_sp->GetScope()) 636 { 637 case eValueTypeVariableGlobal: 638 dump_variable = m_options.show_globals; 639 if (dump_variable && m_options.show_scope) 640 s.PutCString("GLOBAL: "); 641 break; 642 643 case eValueTypeVariableStatic: 644 dump_variable = m_options.show_globals; 645 if (dump_variable && m_options.show_scope) 646 s.PutCString("STATIC: "); 647 break; 648 649 case eValueTypeVariableArgument: 650 dump_variable = m_options.show_args; 651 if (dump_variable && m_options.show_scope) 652 s.PutCString(" ARG: "); 653 break; 654 655 case eValueTypeVariableLocal: 656 dump_variable = m_options.show_locals; 657 if (dump_variable && m_options.show_scope) 658 s.PutCString(" LOCAL: "); 659 break; 660 661 default: 662 break; 663 } 664 665 if (dump_variable) 666 { 667 668 // Use the variable object code to make sure we are 669 // using the same APIs as the the public API will be 670 // using... 671 valobj_sp = exe_ctx.frame->GetValueObjectForFrameVariable (var_sp); 672 if (valobj_sp) 673 { 674 // When dumping all variables, don't print any variables 675 // that are not in scope to avoid extra unneeded output 676 if (valobj_sp->IsInScope (exe_ctx.frame)) 677 { 678 if (m_options.show_decl && var_sp->GetDeclaration ().GetFile()) 679 { 680 var_sp->GetDeclaration ().DumpStopContext (&s, false); 681 s.PutCString (": "); 682 } 683 ValueObject::DumpValueObject (result.GetOutputStream(), 684 exe_ctx.frame, 685 valobj_sp.get(), 686 name_cstr, 687 m_options.ptr_depth, 688 0, 689 m_options.max_depth, 690 m_options.show_types, 691 m_options.show_location, 692 m_options.use_objc, 693 false, 694 m_options.flat_output); 695 } 696 } 697 } 698 } 699 } 700 } 701 result.SetStatus (eReturnStatusSuccessFinishResult); 702 } 703 } 704 return result.Succeeded(); 705 } 706 protected: 707 708 CommandOptions m_options; 709 }; 710 711 lldb::OptionDefinition 712 CommandObjectFrameVariable::CommandOptions::g_option_table[] = 713 { 714 { LLDB_OPT_SET_1, false, "debug", 'D', no_argument, NULL, 0, eArgTypeNone, "Enable verbose debug information."}, 715 { LLDB_OPT_SET_1, false, "depth", 'd', required_argument, NULL, 0, eArgTypeCount, "Set the max recurse depth when dumping aggregate types (default is infinity)."}, 716 { LLDB_OPT_SET_1, false, "show-globals",'g', no_argument, NULL, 0, eArgTypeNone, "Show the current frame source file global and static variables."}, 717 { LLDB_OPT_SET_1, false, "find-global",'G', required_argument, NULL, 0, eArgTypeVarName, "Find a global variable by name (which might not be in the current stack frame source file)."}, 718 { LLDB_OPT_SET_1, false, "location", 'L', no_argument, NULL, 0, eArgTypeNone, "Show variable location information."}, 719 { LLDB_OPT_SET_1, false, "show-declaration", 'c', no_argument, NULL, 0, eArgTypeNone, "Show variable declaration information (source file and line where the variable was declared)."}, 720 { LLDB_OPT_SET_1, false, "no-args", 'a', no_argument, NULL, 0, eArgTypeNone, "Omit function arguments."}, 721 { LLDB_OPT_SET_1, false, "no-locals", 'l', no_argument, NULL, 0, eArgTypeNone, "Omit local variables."}, 722 { LLDB_OPT_SET_1, false, "show-types", 't', no_argument, NULL, 0, eArgTypeNone, "Show variable types when dumping values."}, 723 { LLDB_OPT_SET_1, false, "no-summary", 'y', no_argument, NULL, 0, eArgTypeNone, "Omit summary information."}, 724 { LLDB_OPT_SET_1, false, "scope", 's', no_argument, NULL, 0, eArgTypeNone, "Show variable scope (argument, local, global, static)."}, 725 { LLDB_OPT_SET_1, false, "objc", 'o', no_argument, NULL, 0, eArgTypeNone, "When looking up a variable by name, print as an Objective-C object."}, 726 { LLDB_OPT_SET_1, false, "ptr-depth", 'p', required_argument, NULL, 0, eArgTypeCount, "The number of pointers to be traversed when dumping values (default is zero)."}, 727 { LLDB_OPT_SET_1, false, "regex", 'r', no_argument, NULL, 0, eArgTypeRegularExpression, "The <variable-name> argument for name lookups are regular expressions."}, 728 { LLDB_OPT_SET_1, false, "flat", 'f', no_argument, NULL, 0, eArgTypeNone, "Display results in a flat format that uses expression paths for each variable or member."}, 729 { 0, false, NULL, 0, 0, NULL, NULL, eArgTypeNone, NULL } 730 }; 731 #pragma mark CommandObjectMultiwordFrame 732 733 //------------------------------------------------------------------------- 734 // CommandObjectMultiwordFrame 735 //------------------------------------------------------------------------- 736 737 CommandObjectMultiwordFrame::CommandObjectMultiwordFrame (CommandInterpreter &interpreter) : 738 CommandObjectMultiword (interpreter, 739 "frame", 740 "A set of commands for operating on the current thread's frames.", 741 "frame <subcommand> [<subcommand-options>]") 742 { 743 LoadSubCommand ("info", CommandObjectSP (new CommandObjectFrameInfo (interpreter))); 744 LoadSubCommand ("select", CommandObjectSP (new CommandObjectFrameSelect (interpreter))); 745 LoadSubCommand ("variable", CommandObjectSP (new CommandObjectFrameVariable (interpreter))); 746 } 747 748 CommandObjectMultiwordFrame::~CommandObjectMultiwordFrame () 749 { 750 } 751 752