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