mirror of
https://github.com/espressif/binutils-gdb.git
synced 2025-05-29 07:10:55 +08:00
42a4f53d2b
This commit applies all changes made after running the gdb/copyright.py script. Note that one file was flagged by the script, due to an invalid copyright header (gdb/unittests/basic_string_view/element_access/char/empty.cc). As the file was copied from GCC's libstdc++-v3 testsuite, this commit leaves this file untouched for the time being; a patch to fix the header was sent to gcc-patches first. gdb/ChangeLog: Update copyright year range in all GDB files.
751 lines
26 KiB
Python
751 lines
26 KiB
Python
# GDB 'explore' command.
|
|
# Copyright (C) 2012-2019 Free Software Foundation, Inc.
|
|
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
"""Implementation of the GDB 'explore' command using the GDB Python API."""
|
|
|
|
import gdb
|
|
import sys
|
|
|
|
if sys.version_info[0] > 2:
|
|
# Python 3 renamed raw_input to input
|
|
raw_input = input
|
|
|
|
class Explorer(object):
|
|
"""Internal class which invokes other explorers."""
|
|
|
|
# This map is filled by the Explorer.init_env() function
|
|
type_code_to_explorer_map = { }
|
|
|
|
_SCALAR_TYPE_LIST = (
|
|
gdb.TYPE_CODE_CHAR,
|
|
gdb.TYPE_CODE_INT,
|
|
gdb.TYPE_CODE_BOOL,
|
|
gdb.TYPE_CODE_FLT,
|
|
gdb.TYPE_CODE_VOID,
|
|
gdb.TYPE_CODE_ENUM,
|
|
)
|
|
|
|
@staticmethod
|
|
def guard_expr(expr):
|
|
length = len(expr)
|
|
guard = False
|
|
|
|
if expr[0] == '(' and expr[length-1] == ')':
|
|
pass
|
|
else:
|
|
i = 0
|
|
while i < length:
|
|
c = expr[i]
|
|
if (c == '_' or ('a' <= c and c <= 'z') or
|
|
('A' <= c and c <= 'Z') or ('0' <= c and c <= '9')):
|
|
pass
|
|
else:
|
|
guard = True
|
|
break
|
|
i += 1
|
|
|
|
if guard:
|
|
return "(" + expr + ")"
|
|
else:
|
|
return expr
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Main function to explore an expression value.
|
|
|
|
Arguments:
|
|
expr: The expression string that is being explored.
|
|
value: The gdb.Value value of the expression.
|
|
is_child: Boolean value to indicate if the expression is a child.
|
|
An expression is a child if it is derived from the main
|
|
expression entered by the user. For example, if the user
|
|
entered an expression which evaluates to a struct, then
|
|
when exploring the fields of the struct, is_child is set
|
|
to True internally.
|
|
|
|
Returns:
|
|
No return value.
|
|
"""
|
|
type_code = value.type.code
|
|
if type_code in Explorer.type_code_to_explorer_map:
|
|
explorer_class = Explorer.type_code_to_explorer_map[type_code]
|
|
while explorer_class.explore_expr(expr, value, is_child):
|
|
pass
|
|
else:
|
|
print ("Explorer for type '%s' not yet available.\n" %
|
|
str(value.type))
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Main function to explore a data type.
|
|
|
|
Arguments:
|
|
name: The string representing the path to the data type being
|
|
explored.
|
|
datatype: The gdb.Type value of the data type being explored.
|
|
is_child: Boolean value to indicate if the name is a child.
|
|
A name is a child if it is derived from the main name
|
|
entered by the user. For example, if the user entered
|
|
the name of struct type, then when exploring the fields
|
|
of the struct, is_child is set to True internally.
|
|
|
|
Returns:
|
|
No return value.
|
|
"""
|
|
type_code = datatype.code
|
|
if type_code in Explorer.type_code_to_explorer_map:
|
|
explorer_class = Explorer.type_code_to_explorer_map[type_code]
|
|
while explorer_class.explore_type(name, datatype, is_child):
|
|
pass
|
|
else:
|
|
print ("Explorer for type '%s' not yet available.\n" %
|
|
str(datatype))
|
|
|
|
@staticmethod
|
|
def init_env():
|
|
"""Initializes the Explorer environment.
|
|
This function should be invoked before starting any exploration. If
|
|
invoked before an exploration, it need not be invoked for subsequent
|
|
explorations.
|
|
"""
|
|
Explorer.type_code_to_explorer_map = {
|
|
gdb.TYPE_CODE_CHAR : ScalarExplorer,
|
|
gdb.TYPE_CODE_INT : ScalarExplorer,
|
|
gdb.TYPE_CODE_BOOL : ScalarExplorer,
|
|
gdb.TYPE_CODE_FLT : ScalarExplorer,
|
|
gdb.TYPE_CODE_VOID : ScalarExplorer,
|
|
gdb.TYPE_CODE_ENUM : ScalarExplorer,
|
|
gdb.TYPE_CODE_STRUCT : CompoundExplorer,
|
|
gdb.TYPE_CODE_UNION : CompoundExplorer,
|
|
gdb.TYPE_CODE_PTR : PointerExplorer,
|
|
gdb.TYPE_CODE_REF : ReferenceExplorer,
|
|
gdb.TYPE_CODE_RVALUE_REF : ReferenceExplorer,
|
|
gdb.TYPE_CODE_TYPEDEF : TypedefExplorer,
|
|
gdb.TYPE_CODE_ARRAY : ArrayExplorer
|
|
}
|
|
|
|
@staticmethod
|
|
def is_scalar_type(type):
|
|
"""Checks whether a type is a scalar type.
|
|
A type is a scalar type of its type is
|
|
gdb.TYPE_CODE_CHAR or
|
|
gdb.TYPE_CODE_INT or
|
|
gdb.TYPE_CODE_BOOL or
|
|
gdb.TYPE_CODE_FLT or
|
|
gdb.TYPE_CODE_VOID or
|
|
gdb.TYPE_CODE_ENUM.
|
|
|
|
Arguments:
|
|
type: The type to be checked.
|
|
|
|
Returns:
|
|
'True' if 'type' is a scalar type. 'False' otherwise.
|
|
"""
|
|
return type.code in Explorer._SCALAR_TYPE_LIST
|
|
|
|
@staticmethod
|
|
def return_to_parent_value():
|
|
"""A utility function which prints that the current exploration session
|
|
is returning to the parent value. Useful when exploring values.
|
|
"""
|
|
print ("\nReturning to parent value...\n")
|
|
|
|
@staticmethod
|
|
def return_to_parent_value_prompt():
|
|
"""A utility function which prompts the user to press the 'enter' key
|
|
so that the exploration session can shift back to the parent value.
|
|
Useful when exploring values.
|
|
"""
|
|
raw_input("\nPress enter to return to parent value: ")
|
|
|
|
@staticmethod
|
|
def return_to_enclosing_type():
|
|
"""A utility function which prints that the current exploration session
|
|
is returning to the enclosing type. Useful when exploring types.
|
|
"""
|
|
print ("\nReturning to enclosing type...\n")
|
|
|
|
@staticmethod
|
|
def return_to_enclosing_type_prompt():
|
|
"""A utility function which prompts the user to press the 'enter' key
|
|
so that the exploration session can shift back to the enclosing type.
|
|
Useful when exploring types.
|
|
"""
|
|
raw_input("\nPress enter to return to enclosing type: ")
|
|
|
|
|
|
class ScalarExplorer(object):
|
|
"""Internal class used to explore scalar values."""
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Function to explore scalar values.
|
|
See Explorer.explore_expr and Explorer.is_scalar_type for more
|
|
information.
|
|
"""
|
|
print ("'%s' is a scalar value of type '%s'." %
|
|
(expr, value.type))
|
|
print ("%s = %s" % (expr, str(value)))
|
|
|
|
if is_child:
|
|
Explorer.return_to_parent_value_prompt()
|
|
Explorer.return_to_parent_value()
|
|
|
|
return False
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Function to explore scalar types.
|
|
See Explorer.explore_type and Explorer.is_scalar_type for more
|
|
information.
|
|
"""
|
|
if datatype.code == gdb.TYPE_CODE_ENUM:
|
|
if is_child:
|
|
print ("%s is of an enumerated type '%s'." %
|
|
(name, str(datatype)))
|
|
else:
|
|
print ("'%s' is an enumerated type." % name)
|
|
else:
|
|
if is_child:
|
|
print ("%s is of a scalar type '%s'." %
|
|
(name, str(datatype)))
|
|
else:
|
|
print ("'%s' is a scalar type." % name)
|
|
|
|
if is_child:
|
|
Explorer.return_to_enclosing_type_prompt()
|
|
Explorer.return_to_enclosing_type()
|
|
|
|
return False
|
|
|
|
|
|
class PointerExplorer(object):
|
|
"""Internal class used to explore pointer values."""
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Function to explore pointer values.
|
|
See Explorer.explore_expr for more information.
|
|
"""
|
|
print ("'%s' is a pointer to a value of type '%s'" %
|
|
(expr, str(value.type.target())))
|
|
option = raw_input("Continue exploring it as a pointer to a single "
|
|
"value [y/n]: ")
|
|
if option == "y":
|
|
deref_value = None
|
|
try:
|
|
deref_value = value.dereference()
|
|
str(deref_value)
|
|
except gdb.MemoryError:
|
|
print ("'%s' a pointer pointing to an invalid memory "
|
|
"location." % expr)
|
|
if is_child:
|
|
Explorer.return_to_parent_value_prompt()
|
|
return False
|
|
Explorer.explore_expr("*%s" % Explorer.guard_expr(expr),
|
|
deref_value, is_child)
|
|
return False
|
|
|
|
option = raw_input("Continue exploring it as a pointer to an "
|
|
"array [y/n]: ")
|
|
if option == "y":
|
|
while True:
|
|
index = 0
|
|
try:
|
|
index = int(raw_input("Enter the index of the element you "
|
|
"want to explore in '%s': " % expr))
|
|
except ValueError:
|
|
break
|
|
element_expr = "%s[%d]" % (Explorer.guard_expr(expr), index)
|
|
element = value[index]
|
|
try:
|
|
str(element)
|
|
except gdb.MemoryError:
|
|
print ("Cannot read value at index %d." % index)
|
|
continue
|
|
Explorer.explore_expr(element_expr, element, True)
|
|
return False
|
|
|
|
if is_child:
|
|
Explorer.return_to_parent_value()
|
|
return False
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Function to explore pointer types.
|
|
See Explorer.explore_type for more information.
|
|
"""
|
|
target_type = datatype.target()
|
|
print ("\n%s is a pointer to a value of type '%s'." %
|
|
(name, str(target_type)))
|
|
|
|
Explorer.explore_type("the pointee type of %s" % name,
|
|
target_type,
|
|
is_child)
|
|
return False
|
|
|
|
|
|
class ReferenceExplorer(object):
|
|
"""Internal class used to explore reference (TYPE_CODE_REF) values."""
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Function to explore array values.
|
|
See Explorer.explore_expr for more information.
|
|
"""
|
|
referenced_value = value.referenced_value()
|
|
Explorer.explore_expr(expr, referenced_value, is_child)
|
|
return False
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Function to explore pointer types.
|
|
See Explorer.explore_type for more information.
|
|
"""
|
|
target_type = datatype.target()
|
|
Explorer.explore_type(name, target_type, is_child)
|
|
return False
|
|
|
|
class ArrayExplorer(object):
|
|
"""Internal class used to explore arrays."""
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Function to explore array values.
|
|
See Explorer.explore_expr for more information.
|
|
"""
|
|
target_type = value.type.target()
|
|
print ("'%s' is an array of '%s'." % (expr, str(target_type)))
|
|
index = 0
|
|
try:
|
|
index = int(raw_input("Enter the index of the element you want to "
|
|
"explore in '%s': " % expr))
|
|
except ValueError:
|
|
if is_child:
|
|
Explorer.return_to_parent_value()
|
|
return False
|
|
|
|
element = None
|
|
try:
|
|
element = value[index]
|
|
str(element)
|
|
except gdb.MemoryError:
|
|
print ("Cannot read value at index %d." % index)
|
|
raw_input("Press enter to continue... ")
|
|
return True
|
|
|
|
Explorer.explore_expr("%s[%d]" % (Explorer.guard_expr(expr), index),
|
|
element, True)
|
|
return True
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Function to explore array types.
|
|
See Explorer.explore_type for more information.
|
|
"""
|
|
target_type = datatype.target()
|
|
print ("%s is an array of '%s'." % (name, str(target_type)))
|
|
|
|
Explorer.explore_type("the array element of %s" % name, target_type,
|
|
is_child)
|
|
return False
|
|
|
|
|
|
class CompoundExplorer(object):
|
|
"""Internal class used to explore struct, classes and unions."""
|
|
|
|
@staticmethod
|
|
def _print_fields(print_list):
|
|
"""Internal function which prints the fields of a struct/class/union.
|
|
"""
|
|
max_field_name_length = 0
|
|
for pair in print_list:
|
|
if max_field_name_length < len(pair[0]):
|
|
max_field_name_length = len(pair[0])
|
|
|
|
for pair in print_list:
|
|
print (" %*s = %s" % (max_field_name_length, pair[0], pair[1]))
|
|
|
|
@staticmethod
|
|
def _get_real_field_count(fields):
|
|
real_field_count = 0;
|
|
for field in fields:
|
|
if not field.artificial:
|
|
real_field_count = real_field_count + 1
|
|
|
|
return real_field_count
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Function to explore structs/classes and union values.
|
|
See Explorer.explore_expr for more information.
|
|
"""
|
|
datatype = value.type
|
|
type_code = datatype.code
|
|
fields = datatype.fields()
|
|
|
|
if type_code == gdb.TYPE_CODE_STRUCT:
|
|
type_desc = "struct/class"
|
|
else:
|
|
type_desc = "union"
|
|
|
|
if CompoundExplorer._get_real_field_count(fields) == 0:
|
|
print ("The value of '%s' is a %s of type '%s' with no fields." %
|
|
(expr, type_desc, str(value.type)))
|
|
if is_child:
|
|
Explorer.return_to_parent_value_prompt()
|
|
return False
|
|
|
|
print ("The value of '%s' is a %s of type '%s' with the following "
|
|
"fields:\n" % (expr, type_desc, str(value.type)))
|
|
|
|
has_explorable_fields = False
|
|
choice_to_compound_field_map = { }
|
|
current_choice = 0
|
|
print_list = [ ]
|
|
for field in fields:
|
|
if field.artificial:
|
|
continue
|
|
field_full_name = Explorer.guard_expr(expr) + "." + field.name
|
|
if field.is_base_class:
|
|
field_value = value.cast(field.type)
|
|
else:
|
|
field_value = value[field.name]
|
|
literal_value = ""
|
|
if type_code == gdb.TYPE_CODE_UNION:
|
|
literal_value = ("<Enter %d to explore this field of type "
|
|
"'%s'>" % (current_choice, str(field.type)))
|
|
has_explorable_fields = True
|
|
else:
|
|
if Explorer.is_scalar_type(field.type):
|
|
literal_value = ("%s .. (Value of type '%s')" %
|
|
(str(field_value), str(field.type)))
|
|
else:
|
|
if field.is_base_class:
|
|
field_desc = "base class"
|
|
else:
|
|
field_desc = "field"
|
|
literal_value = ("<Enter %d to explore this %s of type "
|
|
"'%s'>" %
|
|
(current_choice, field_desc,
|
|
str(field.type)))
|
|
has_explorable_fields = True
|
|
|
|
choice_to_compound_field_map[str(current_choice)] = (
|
|
field_full_name, field_value)
|
|
current_choice = current_choice + 1
|
|
|
|
print_list.append((field.name, literal_value))
|
|
|
|
CompoundExplorer._print_fields(print_list)
|
|
print ("")
|
|
|
|
if has_explorable_fields:
|
|
choice = raw_input("Enter the field number of choice: ")
|
|
if choice in choice_to_compound_field_map:
|
|
Explorer.explore_expr(choice_to_compound_field_map[choice][0],
|
|
choice_to_compound_field_map[choice][1],
|
|
True)
|
|
return True
|
|
else:
|
|
if is_child:
|
|
Explorer.return_to_parent_value()
|
|
else:
|
|
if is_child:
|
|
Explorer.return_to_parent_value_prompt()
|
|
|
|
return False
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Function to explore struct/class and union types.
|
|
See Explorer.explore_type for more information.
|
|
"""
|
|
type_code = datatype.code
|
|
type_desc = ""
|
|
if type_code == gdb.TYPE_CODE_STRUCT:
|
|
type_desc = "struct/class"
|
|
else:
|
|
type_desc = "union"
|
|
|
|
fields = datatype.fields()
|
|
if CompoundExplorer._get_real_field_count(fields) == 0:
|
|
if is_child:
|
|
print ("%s is a %s of type '%s' with no fields." %
|
|
(name, type_desc, str(datatype)))
|
|
Explorer.return_to_enclosing_type_prompt()
|
|
else:
|
|
print ("'%s' is a %s with no fields." % (name, type_desc))
|
|
return False
|
|
|
|
if is_child:
|
|
print ("%s is a %s of type '%s' "
|
|
"with the following fields:\n" %
|
|
(name, type_desc, str(datatype)))
|
|
else:
|
|
print ("'%s' is a %s with the following "
|
|
"fields:\n" %
|
|
(name, type_desc))
|
|
|
|
has_explorable_fields = False
|
|
current_choice = 0
|
|
choice_to_compound_field_map = { }
|
|
print_list = [ ]
|
|
for field in fields:
|
|
if field.artificial:
|
|
continue
|
|
if field.is_base_class:
|
|
field_desc = "base class"
|
|
else:
|
|
field_desc = "field"
|
|
rhs = ("<Enter %d to explore this %s of type '%s'>" %
|
|
(current_choice, field_desc, str(field.type)))
|
|
print_list.append((field.name, rhs))
|
|
choice_to_compound_field_map[str(current_choice)] = (
|
|
field.name, field.type, field_desc)
|
|
current_choice = current_choice + 1
|
|
|
|
CompoundExplorer._print_fields(print_list)
|
|
print ("")
|
|
|
|
if len(choice_to_compound_field_map) > 0:
|
|
choice = raw_input("Enter the field number of choice: ")
|
|
if choice in choice_to_compound_field_map:
|
|
if is_child:
|
|
new_name = ("%s '%s' of %s" %
|
|
(choice_to_compound_field_map[choice][2],
|
|
choice_to_compound_field_map[choice][0],
|
|
name))
|
|
else:
|
|
new_name = ("%s '%s' of '%s'" %
|
|
(choice_to_compound_field_map[choice][2],
|
|
choice_to_compound_field_map[choice][0],
|
|
name))
|
|
Explorer.explore_type(new_name,
|
|
choice_to_compound_field_map[choice][1], True)
|
|
return True
|
|
else:
|
|
if is_child:
|
|
Explorer.return_to_enclosing_type()
|
|
else:
|
|
if is_child:
|
|
Explorer.return_to_enclosing_type_prompt()
|
|
|
|
return False
|
|
|
|
|
|
class TypedefExplorer(object):
|
|
"""Internal class used to explore values whose type is a typedef."""
|
|
|
|
@staticmethod
|
|
def explore_expr(expr, value, is_child):
|
|
"""Function to explore typedef values.
|
|
See Explorer.explore_expr for more information.
|
|
"""
|
|
actual_type = value.type.strip_typedefs()
|
|
print ("The value of '%s' is of type '%s' "
|
|
"which is a typedef of type '%s'" %
|
|
(expr, str(value.type), str(actual_type)))
|
|
|
|
Explorer.explore_expr(expr, value.cast(actual_type), is_child)
|
|
return False
|
|
|
|
@staticmethod
|
|
def explore_type(name, datatype, is_child):
|
|
"""Function to explore typedef types.
|
|
See Explorer.explore_type for more information.
|
|
"""
|
|
actual_type = datatype.strip_typedefs()
|
|
if is_child:
|
|
print ("The type of %s is a typedef of type '%s'." %
|
|
(name, str(actual_type)))
|
|
else:
|
|
print ("The type '%s' is a typedef of type '%s'." %
|
|
(name, str(actual_type)))
|
|
|
|
Explorer.explore_type(name, actual_type, is_child)
|
|
return False
|
|
|
|
|
|
class ExploreUtils(object):
|
|
"""Internal class which provides utilities for the main command classes."""
|
|
|
|
@staticmethod
|
|
def check_args(name, arg_str):
|
|
"""Utility to check if adequate number of arguments are passed to an
|
|
explore command.
|
|
|
|
Arguments:
|
|
name: The name of the explore command.
|
|
arg_str: The argument string passed to the explore command.
|
|
|
|
Returns:
|
|
True if adequate arguments are passed, false otherwise.
|
|
|
|
Raises:
|
|
gdb.GdbError if adequate arguments are not passed.
|
|
"""
|
|
if len(arg_str) < 1:
|
|
raise gdb.GdbError("ERROR: '%s' requires an argument."
|
|
% name)
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
@staticmethod
|
|
def get_type_from_str(type_str):
|
|
"""A utility function to deduce the gdb.Type value from a string
|
|
representing the type.
|
|
|
|
Arguments:
|
|
type_str: The type string from which the gdb.Type value should be
|
|
deduced.
|
|
|
|
Returns:
|
|
The deduced gdb.Type value if possible, None otherwise.
|
|
"""
|
|
try:
|
|
# Assume the current language to be C/C++ and make a try.
|
|
return gdb.parse_and_eval("(%s *)0" % type_str).type.target()
|
|
except RuntimeError:
|
|
# If assumption of current language to be C/C++ was wrong, then
|
|
# lookup the type using the API.
|
|
try:
|
|
return gdb.lookup_type(type_str)
|
|
except RuntimeError:
|
|
return None
|
|
|
|
@staticmethod
|
|
def get_value_from_str(value_str):
|
|
"""A utility function to deduce the gdb.Value value from a string
|
|
representing the value.
|
|
|
|
Arguments:
|
|
value_str: The value string from which the gdb.Value value should
|
|
be deduced.
|
|
|
|
Returns:
|
|
The deduced gdb.Value value if possible, None otherwise.
|
|
"""
|
|
try:
|
|
return gdb.parse_and_eval(value_str)
|
|
except RuntimeError:
|
|
return None
|
|
|
|
|
|
class ExploreCommand(gdb.Command):
|
|
"""Explore a value or a type valid in the current context.
|
|
|
|
Usage: explore ARG
|
|
|
|
- ARG is either a valid expression or a type name.
|
|
- At any stage of exploration, hit the return key (instead of a
|
|
choice, if any) to return to the enclosing type or value."""
|
|
|
|
def __init__(self):
|
|
super(ExploreCommand, self).__init__(name = "explore",
|
|
command_class = gdb.COMMAND_DATA,
|
|
prefix = True)
|
|
|
|
def invoke(self, arg_str, from_tty):
|
|
if ExploreUtils.check_args("explore", arg_str) == False:
|
|
return
|
|
|
|
# Check if it is a value
|
|
value = ExploreUtils.get_value_from_str(arg_str)
|
|
if value is not None:
|
|
Explorer.explore_expr(arg_str, value, False)
|
|
return
|
|
|
|
# If it is not a value, check if it is a type
|
|
datatype = ExploreUtils.get_type_from_str(arg_str)
|
|
if datatype is not None:
|
|
Explorer.explore_type(arg_str, datatype, False)
|
|
return
|
|
|
|
# If it is neither a value nor a type, raise an error.
|
|
raise gdb.GdbError(
|
|
("'%s' neither evaluates to a value nor is a type "
|
|
"in the current context." %
|
|
arg_str))
|
|
|
|
|
|
class ExploreValueCommand(gdb.Command):
|
|
"""Explore value of an expression valid in the current context.
|
|
|
|
Usage: explore value ARG
|
|
|
|
- ARG is a valid expression.
|
|
- At any stage of exploration, hit the return key (instead of a
|
|
choice, if any) to return to the enclosing value."""
|
|
|
|
def __init__(self):
|
|
super(ExploreValueCommand, self).__init__(
|
|
name = "explore value", command_class = gdb.COMMAND_DATA)
|
|
|
|
def invoke(self, arg_str, from_tty):
|
|
if ExploreUtils.check_args("explore value", arg_str) == False:
|
|
return
|
|
|
|
value = ExploreUtils.get_value_from_str(arg_str)
|
|
if value is None:
|
|
raise gdb.GdbError(
|
|
(" '%s' does not evaluate to a value in the current "
|
|
"context." %
|
|
arg_str))
|
|
return
|
|
|
|
Explorer.explore_expr(arg_str, value, False)
|
|
|
|
|
|
class ExploreTypeCommand(gdb.Command):
|
|
"""Explore a type or the type of an expression.
|
|
|
|
Usage: explore type ARG
|
|
|
|
- ARG is a valid expression or a type name.
|
|
- At any stage of exploration, hit the return key (instead of a
|
|
choice, if any) to return to the enclosing type."""
|
|
|
|
def __init__(self):
|
|
super(ExploreTypeCommand, self).__init__(
|
|
name = "explore type", command_class = gdb.COMMAND_DATA)
|
|
|
|
def invoke(self, arg_str, from_tty):
|
|
if ExploreUtils.check_args("explore type", arg_str) == False:
|
|
return
|
|
|
|
datatype = ExploreUtils.get_type_from_str(arg_str)
|
|
if datatype is not None:
|
|
Explorer.explore_type(arg_str, datatype, False)
|
|
return
|
|
|
|
value = ExploreUtils.get_value_from_str(arg_str)
|
|
if value is not None:
|
|
print ("'%s' is of type '%s'." % (arg_str, str(value.type)))
|
|
Explorer.explore_type(str(value.type), value.type, False)
|
|
return
|
|
|
|
raise gdb.GdbError(("'%s' is not a type or value in the current "
|
|
"context." % arg_str))
|
|
|
|
|
|
Explorer.init_env()
|
|
|
|
ExploreCommand()
|
|
ExploreValueCommand()
|
|
ExploreTypeCommand()
|