@@ -13,19 +13,24 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
# Load the xmethods if GDB supports them.
def gdb_has_xmethods():
try:
import gdb.xmethod
+
return True
except ImportError:
return False
+
def register_libstdcxx_printers(obj):
# Load the pretty-printers.
from .printers import register_libstdcxx_printers
+
register_libstdcxx_printers(obj)
if gdb_has_xmethods():
from .xmethods import register_libstdcxx_xmethods
+
register_libstdcxx_xmethods(obj)
@@ -15,12 +15,13 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-import gdb
+import datetime
+import errno
import itertools
import re
import sys
-import errno
-import datetime
+
+import gdb
# Python 2 + Python 3 compatibility code
@@ -78,6 +79,7 @@ else:
def dst(self, dt):
return datetime.timedelta(0)
+
_utc_timezone = UTC()
# Try to use the new-style pretty-printing if available.
@@ -91,6 +93,7 @@ except ImportError:
_use_type_printing = False
try:
import gdb.types
+
if hasattr(gdb.types, 'TypePrinter'):
_use_type_printing = True
except ImportError:
@@ -148,6 +151,7 @@ def lookup_templ_spec(templ, *args):
pass
raise e
+
# Use this to find container node types instead of find_type,
# see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91997 for details.
def lookup_node_type(nodename, containertype):
@@ -177,8 +181,9 @@ def lookup_node_type(nodename, containertype):
except gdb.error:
# For debug mode containers the node is in std::__cxx1998.
if is_member_of_namespace(nodename, 'std'):
- if is_member_of_namespace(containertype, 'std::__cxx1998',
- 'std::__debug', '__gnu_debug'):
+ if is_member_of_namespace(
+ containertype, 'std::__cxx1998', 'std::__debug', '__gnu_debug'
+ ):
nodename = nodename.replace('::', '::__cxx1998::', 1)
try:
return lookup_templ_spec(nodename, valtype)
@@ -296,7 +301,9 @@ class SharedPointerPrinter(printer_base):
state = 'expired, weak count %d' % weakcount
else:
state = 'use count %d, weak count %d' % (
- usecount, weakcount - 1)
+ usecount,
+ weakcount - 1,
+ )
return '%s<%s> (%s)' % (self._typename, targ, state)
@@ -305,13 +312,15 @@ def _tuple_impl_get(val):
bases = val.type.fields()
if not bases[-1].is_base_class:
raise ValueError(
- "Unsupported implementation for std::tuple: %s" % str(val.type))
+ "Unsupported implementation for std::tuple: %s" % str(val.type)
+ )
# Get the _Head_base<N, T> base class:
head_base = val.cast(bases[-1].type)
fields = head_base.type.fields()
if len(fields) == 0:
raise ValueError(
- "Unsupported implementation for std::tuple: %s" % str(val.type))
+ "Unsupported implementation for std::tuple: %s" % str(val.type)
+ )
if fields[0].name == '_M_head_impl':
# The tuple element is the _Head_base::_M_head_impl data member.
return head_base['_M_head_impl']
@@ -321,7 +330,8 @@ def _tuple_impl_get(val):
return head_base.cast(fields[0].type)
else:
raise ValueError(
- "Unsupported implementation for std::tuple: %s" % str(val.type))
+ "Unsupported implementation for std::tuple: %s" % str(val.type)
+ )
def tuple_get(n, val):
@@ -345,14 +355,16 @@ def unique_ptr_get(val):
# or within a data member of type __uniq_ptr_data.
impl_type = val.type.fields()[0].type.strip_typedefs()
# Check for new implementations first:
- if is_specialization_of(impl_type, '__uniq_ptr_data') \
- or is_specialization_of(impl_type, '__uniq_ptr_impl'):
+ if is_specialization_of(
+ impl_type, '__uniq_ptr_data'
+ ) or is_specialization_of(impl_type, '__uniq_ptr_impl'):
tuple_member = val['_M_t']['_M_t']
elif is_specialization_of(impl_type, 'tuple'):
tuple_member = val['_M_t']
else:
raise ValueError(
- "Unsupported implementation for unique_ptr: %s" % str(impl_type))
+ "Unsupported implementation for unique_ptr: %s" % str(impl_type)
+ )
return tuple_get(0, tuple_member)
@@ -438,9 +450,12 @@ class NodeIteratorPrinter(printer_base):
def to_string(self):
if not self._val['_M_node']:
- return 'non-dereferenceable iterator for std::%s' % (self._contname)
- node = self._val['_M_node'].cast(
- self._nodetype.pointer()).dereference()
+ return 'non-dereferenceable iterator for std::%s' % (
+ self._contname
+ )
+ node = (
+ self._val['_M_node'].cast(self._nodetype.pointer()).dereference()
+ )
return str(get_value_from_list_node(node))
@@ -455,8 +470,9 @@ class StdFwdListIteratorPrinter(NodeIteratorPrinter):
"""Print std::forward_list::iterator."""
def __init__(self, typename, val):
- NodeIteratorPrinter.__init__(self, typename, val, 'forward_list',
- '_Fwd_list_node')
+ NodeIteratorPrinter.__init__(
+ self, typename, val, 'forward_list', '_Fwd_list_node'
+ )
class StdSlistPrinter(printer_base):
@@ -503,8 +519,11 @@ class StdSlistIteratorPrinter(printer_base):
if not self._val['_M_node']:
return 'non-dereferenceable iterator for __gnu_cxx::slist'
nodetype = lookup_node_type(
- '__gnu_cxx::_Slist_node', self._val.type).pointer()
- return str(self._val['_M_node'].cast(nodetype).dereference()['_M_data'])
+ '__gnu_cxx::_Slist_node', self._val.type
+ ).pointer()
+ return str(
+ self._val['_M_node'].cast(nodetype).dereference()['_M_data']
+ )
class StdVectorPrinter(printer_base):
@@ -550,13 +569,16 @@ class StdVectorPrinter(printer_base):
def __init__(self, typename, val):
self._typename = strip_versioned_namespace(typename)
self._val = val
- self._is_bool = val.type.template_argument(
- 0).code == gdb.TYPE_CODE_BOOL
+ self._is_bool = (
+ val.type.template_argument(0).code == gdb.TYPE_CODE_BOOL
+ )
def children(self):
- return self._iterator(self._val['_M_impl']['_M_start'],
- self._val['_M_impl']['_M_finish'],
- self._is_bool)
+ return self._iterator(
+ self._val['_M_impl']['_M_start'],
+ self._val['_M_impl']['_M_finish'],
+ self._is_bool,
+ )
def to_string(self):
start = self._val['_M_impl']['_M_start']
@@ -570,11 +592,17 @@ class StdVectorPrinter(printer_base):
bl = 8 * itype.sizeof
length = bl * (finish - start) + fo
capacity = bl * (end - start)
- return ('%s<bool> of length %d, capacity %d'
- % (self._typename, int(length), int(capacity)))
+ return '%s<bool> of length %d, capacity %d' % (
+ self._typename,
+ int(length),
+ int(capacity),
+ )
else:
- return ('%s of length %d, capacity %d'
- % (self._typename, int(finish - start), int(end - start)))
+ return '%s of length %d, capacity %d' % (
+ self._typename,
+ int(finish - start),
+ int(end - start),
+ )
def display_hint(self):
return 'array'
@@ -601,8 +629,9 @@ class StdBitIteratorPrinter(printer_base):
def to_string(self):
if not self._val['_M_p']:
return 'non-dereferenceable iterator for std::vector<bool>'
- return bool(self._val['_M_p'].dereference()
- & (1 << self._val['_M_offset']))
+ return bool(
+ self._val['_M_p'].dereference() & (1 << self._val['_M_offset'])
+ )
class StdBitReferencePrinter(printer_base):
@@ -631,7 +660,8 @@ class StdTuplePrinter(printer_base):
elif len(nodes) == 0:
return False
raise ValueError(
- "Top of tuple tree does not consist of a single node.")
+ "Top of tuple tree does not consist of a single node."
+ )
def __init__(self, head):
self._head = head
@@ -659,7 +689,8 @@ class StdTuplePrinter(printer_base):
# Check that this iteration has an expected structure.
if len(nodes) > 2:
raise ValueError(
- "Cannot parse more than 2 nodes in a tuple tree.")
+ "Cannot parse more than 2 nodes in a tuple tree."
+ )
if len(nodes) == 1:
# This is the last node of a GCC 5+ std::tuple.
@@ -713,8 +744,10 @@ class StdStackOrQueuePrinter(printer_base):
return self._visualizer.children()
def to_string(self):
- return '%s wrapping: %s' % (self._typename,
- self._visualizer.to_string())
+ return '%s wrapping: %s' % (
+ self._typename,
+ self._visualizer.to_string(),
+ )
def display_hint(self):
if hasattr(self._visualizer, 'display_hint'):
@@ -777,6 +810,7 @@ def get_value_from_Rb_tree_node(node):
pass
raise ValueError("Unsupported implementation for %s" % str(node.type))
+
# This is a pretty printer for std::_Rb_tree_iterator (which is
# std::map::iterator), and has nothing to do with the RbtreeIterator
# class above.
@@ -852,8 +886,10 @@ class StdMapPrinter(printer_base):
self._val = val
def to_string(self):
- return '%s with %s' % (self._typename,
- num_elements(len(RbtreeIterator(self._val))))
+ return '%s with %s' % (
+ self._typename,
+ num_elements(len(RbtreeIterator(self._val))),
+ )
def children(self):
node = lookup_node_type('_Rb_tree_node', self._val.type).pointer()
@@ -891,8 +927,10 @@ class StdSetPrinter(printer_base):
self._val = val
def to_string(self):
- return '%s with %s' % (self._typename,
- num_elements(len(RbtreeIterator(self._val))))
+ return '%s with %s' % (
+ self._typename,
+ num_elements(len(RbtreeIterator(self._val))),
+ )
def children(self):
node = lookup_node_type('_Rb_tree_node', self._val.type).pointer()
@@ -1004,8 +1042,13 @@ class StdDequePrinter(printer_base):
def children(self):
start = self._val['_M_impl']['_M_start']
end = self._val['_M_impl']['_M_finish']
- return self._iter(start['_M_node'], start['_M_cur'], start['_M_last'],
- end['_M_cur'], self._buffer_size)
+ return self._iter(
+ start['_M_node'],
+ start['_M_cur'],
+ start['_M_last'],
+ end['_M_cur'],
+ self._buffer_size,
+ )
def display_hint(self):
return 'array'
@@ -1104,7 +1147,9 @@ class StdStringStreamPrinter(printer_base):
def to_string(self):
if self._was_redirected:
return "%s redirected to %s" % (
- self._typename, self._streambuf.dereference())
+ self._typename,
+ self._streambuf.dereference(),
+ )
return self._val['_M_stringbuf']
def display_hint(self):
@@ -1150,8 +1195,11 @@ class StdHashtableIterator(Iterator):
self._node = hashtable['_M_before_begin']['_M_nxt']
valtype = hashtable.type.template_argument(1)
cached = hashtable.type.template_argument(9).template_argument(0)
- node_type = lookup_templ_spec('std::__detail::_Hash_node', str(valtype),
- 'true' if cached else 'false')
+ node_type = lookup_templ_spec(
+ 'std::__detail::_Hash_node',
+ str(valtype),
+ 'true' if cached else 'false',
+ )
self._node_type = node_type.pointer()
def __iter__(self):
@@ -1229,11 +1277,13 @@ class Tr1UnorderedMapPrinter(printer_base):
# Map over the hash table and flatten the result.
if self._typename.startswith('std::tr1'):
data = self._flatten(
- imap(self._format_one, Tr1HashtableIterator(self._hashtable())))
+ imap(self._format_one, Tr1HashtableIterator(self._hashtable()))
+ )
# Zip the two iterators together.
return izip(counter, data)
data = self._flatten(
- imap(self._format_one, StdHashtableIterator(self._hashtable())))
+ imap(self._format_one, StdHashtableIterator(self._hashtable()))
+ )
# Zip the two iterators together.
return izip(counter, data)
@@ -1291,8 +1341,9 @@ class SingleObjContainerPrinter(printer_base):
global _use_type_printing
if not _use_type_printing:
return str(type)
- return gdb.types.apply_type_recognizers(gdb.types.get_type_recognizers(),
- type) or str(type)
+ return gdb.types.apply_type_recognizers(
+ gdb.types.get_type_recognizers(), type
+ ) or str(type)
class _contained(Iterator):
def __init__(self, val):
@@ -1316,8 +1367,9 @@ class SingleObjContainerPrinter(printer_base):
return self._contained(self._contained_value)
def display_hint(self):
- if (hasattr(self._visualizer, 'children')
- and hasattr(self._visualizer, 'display_hint')):
+ if hasattr(self._visualizer, 'children') and hasattr(
+ self._visualizer, 'display_hint'
+ ):
# If contained value is a map we want to display in the same way.
return self._visualizer.display_hint()
return self._hint
@@ -1352,8 +1404,12 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
def __init__(self, typename, val):
self._typename = strip_versioned_namespace(typename)
- self._typename = re.sub(r'^std::experimental::fundamentals_v\d::',
- 'std::experimental::', self._typename, 1)
+ self._typename = re.sub(
+ r'^std::experimental::fundamentals_v\d::',
+ 'std::experimental::',
+ self._typename,
+ 1,
+ )
self._val = val
self._contained_type = None
contained_value = None
@@ -1363,7 +1419,8 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
func = function_pointer_to_name(mgr)
if not func:
raise ValueError(
- "Invalid function pointer in %s" % (self._typename))
+ "Invalid function pointer in %s" % (self._typename)
+ )
# We want to use this regular expression:
# T::_Manager_xxx<.*>::_S_manage\(T::_Op, const T\*, T::_Arg\*\)
# where T is std::any or std::experimental::any.
@@ -1377,7 +1434,8 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
m = re.match(rx, func)
if not m:
raise ValueError(
- "Unknown manager function in %s" % self._typename)
+ "Unknown manager function in %s" % self._typename
+ )
mgrname = m.group(1)
# FIXME need to expand 'std::string' so that gdb.lookup_type works
@@ -1413,9 +1471,11 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
valptr = self._val['_M_storage']['_M_ptr']
else:
raise ValueError(
- "Unknown manager function in %s" % self._typename)
+ "Unknown manager function in %s" % self._typename
+ )
contained_value = valptr.cast(
- self._contained_type.pointer()).dereference()
+ self._contained_type.pointer()
+ ).dereference()
visualizer = gdb.default_visualizer(contained_value)
super(StdExpAnyPrinter, self).__init__(contained_value, visualizer)
@@ -1436,8 +1496,7 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
strings = {str(gdb.lookup_type('std::string').strip_typedefs())}
# So also consider all the other possible std::string types!
s = 'basic_string<char, std::char_traits<char>, std::allocator<char> >'
- quals = ['std::', 'std::__cxx11::',
- 'std::' + _versioned_namespace]
+ quals = ['std::', 'std::__cxx11::', 'std::' + _versioned_namespace]
strings |= {q + s for q in quals} # set of unique strings
return strings
@@ -1449,7 +1508,10 @@ class StdExpOptionalPrinter(SingleObjContainerPrinter):
typename = strip_versioned_namespace(typename)
self._typename = re.sub(
r'^std::(experimental::|)(fundamentals_v\d::|)(.*)',
- r'std::\1\3', typename, 1)
+ r'std::\1\3',
+ typename,
+ 1,
+ )
payload = val['_M_payload']
if self._typename.startswith('std::experimental'):
engaged = val['_M_engaged']
@@ -1466,14 +1528,17 @@ class StdExpOptionalPrinter(SingleObjContainerPrinter):
if not engaged:
contained_value = None
super(StdExpOptionalPrinter, self).__init__(
- contained_value, visualizer)
+ contained_value, visualizer
+ )
def to_string(self):
if self._contained_value is None:
return "%s [no contained value]" % self._typename
if hasattr(self._visualizer, 'children'):
- return "%s containing %s" % (self._typename,
- self._visualizer.to_string())
+ return "%s containing %s" % (
+ self._typename,
+ self._visualizer.to_string(),
+ )
return self._typename
@@ -1492,17 +1557,22 @@ class StdVariantPrinter(SingleObjContainerPrinter):
self._contained_type = alternatives[int(self._index)]
addr = val['_M_u']['_M_first']['_M_storage'].address
contained_value = addr.cast(
- self._contained_type.pointer()).dereference()
+ self._contained_type.pointer()
+ ).dereference()
visualizer = gdb.default_visualizer(contained_value)
super(StdVariantPrinter, self).__init__(
- contained_value, visualizer, 'array')
+ contained_value, visualizer, 'array'
+ )
def to_string(self):
if self._contained_value is None:
return "%s [no contained value]" % self._typename
if hasattr(self._visualizer, 'children'):
- return "%s [index %d] containing %s" % (self._typename, self._index,
- self._visualizer.to_string())
+ return "%s [index %d] containing %s" % (
+ self._typename,
+ self._index,
+ self._visualizer.to_string(),
+ )
return "%s [index %d]" % (self._typename, self._index)
@@ -1513,24 +1583,30 @@ class StdNodeHandlePrinter(SingleObjContainerPrinter):
self._value_type = val.type.template_argument(1)
nodetype = val.type.template_argument(2).template_argument(0)
self._is_rb_tree_node = is_specialization_of(
- nodetype.name, '_Rb_tree_node')
+ nodetype.name, '_Rb_tree_node'
+ )
self._is_map_node = val.type.template_argument(0) != self._value_type
nodeptr = val['_M_ptr']
if nodeptr:
if self._is_rb_tree_node:
contained_value = get_value_from_Rb_tree_node(
- nodeptr.dereference())
+ nodeptr.dereference()
+ )
else:
- contained_value = get_value_from_aligned_membuf(nodeptr['_M_storage'],
- self._value_type)
+ contained_value = get_value_from_aligned_membuf(
+ nodeptr['_M_storage'], self._value_type
+ )
visualizer = gdb.default_visualizer(contained_value)
else:
contained_value = None
visualizer = None
optalloc = val['_M_alloc']
- self._alloc = optalloc['_M_payload'] if optalloc['_M_engaged'] else None
- super(StdNodeHandlePrinter, self).__init__(contained_value, visualizer,
- 'array')
+ self._alloc = (
+ optalloc['_M_payload'] if optalloc['_M_engaged'] else None
+ )
+ super(StdNodeHandlePrinter, self).__init__(
+ contained_value, visualizer, 'array'
+ )
def to_string(self):
desc = 'node handle for '
@@ -1662,7 +1738,7 @@ class StdPathPrinter(printer_base):
char_type = gdb.lookup_type('char')
impl = impl.cast(int_type.pointer())
size = impl.dereference()
- #self._capacity = (impl + 1).dereference()
+ # self._capacity = (impl + 1).dereference()
if hasattr(gdb.Type, 'alignof'):
sizeof_Impl = max(2 * int_type.sizeof, cmpt_type.alignof)
else:
@@ -1732,7 +1808,7 @@ class StdCmpCatPrinter(printer_base):
"""Print a comparison category object."""
def __init__(self, typename, val):
- self._typename = typename[typename.rfind(':') + 1:]
+ self._typename = typename[typename.rfind(':') + 1 :]
self._val = val['_M_value']
def to_string(self):
@@ -1756,6 +1832,7 @@ class StdErrorCodePrinter(printer_base):
if StdErrorCodePrinter._system_is_posix is None:
try:
import posix
+
StdErrorCodePrinter._system_is_posix = True
except ImportError:
StdErrorCodePrinter._system_is_posix = False
@@ -1846,8 +1923,10 @@ class StdErrorCodePrinter(printer_base):
cat = self._val['_M_cat']
name, alt_name, enum, is_errno = self._category_info(cat)
if value == 0:
- default_cats = {'error_code': 'system',
- 'error_condition': 'generic'}
+ default_cats = {
+ 'error_code': 'system',
+ 'error_condition': 'generic',
+ }
if name == default_cats[self._unqualified_name(self._typename)]:
return self._typename + ' = { }' # default-constructed value
@@ -1880,14 +1959,21 @@ class StdRegexStatePrinter(printer_base):
opcode = opcode[25:]
next_id = self._val['_M_next']
- variants = {'repeat': 'alt', 'alternative': 'alt',
- 'subexpr_begin': 'subexpr', 'subexpr_end': 'subexpr',
- 'line_begin_assertion': None, 'line_end_assertion': None,
- 'word_boundary': 'neg', 'subexpr_lookahead': 'neg',
- 'backref': 'backref_index',
- 'match': None, 'accept': None,
- 'dummy': None, 'unknown': None
- }
+ variants = {
+ 'repeat': 'alt',
+ 'alternative': 'alt',
+ 'subexpr_begin': 'subexpr',
+ 'subexpr_end': 'subexpr',
+ 'line_begin_assertion': None,
+ 'line_end_assertion': None,
+ 'word_boundary': 'neg',
+ 'subexpr_lookahead': 'neg',
+ 'backref': 'backref_index',
+ 'match': None,
+ 'accept': None,
+ 'dummy': None,
+ 'unknown': None,
+ }
v = variants[opcode]
s = "opcode={}, next={}".format(opcode, next_id)
@@ -1963,8 +2049,9 @@ class StdAtomicPrinter(printer_base):
self._value_type = self._val.type.template_argument(0)
if self._value_type.tag is not None:
typ = strip_versioned_namespace(self._value_type.tag)
- if (typ.startswith('std::shared_ptr<')
- or typ.startswith('std::weak_ptr<')):
+ if typ.startswith('std::shared_ptr<') or typ.startswith(
+ 'std::weak_ptr<'
+ ):
impl = val['_M_impl']
self._shptr_printer = SharedPointerPrinter(typename, impl)
self.children = self._shptr_children
@@ -1991,6 +2078,7 @@ class StdAtomicPrinter(printer_base):
class StdFormatArgsPrinter(printer_base):
"""Print a std::basic_format_args."""
+
# TODO: add printer for basic_format_arg<Context> and print out children.
# TODO: add printer for __format::_ArgStore<Context, Args...>.
@@ -2068,8 +2156,10 @@ class StdChronoTimePointPrinter(printer_base):
def _clock(self):
clock = self._val.type.template_argument(0)
name = strip_versioned_namespace(clock.name)
- if name == 'std::chrono::_V2::system_clock' \
- or name == 'std::chrono::system_clock':
+ if (
+ name == 'std::chrono::_V2::system_clock'
+ or name == 'std::chrono::system_clock'
+ ):
return ('std::chrono::sys_time', 0)
# XXX need to remove leap seconds from utc, gps, and tai
if name == 'std::chrono::utc_clock':
@@ -2120,11 +2210,32 @@ class StdChronoZonedTimePrinter(printer_base):
return 'std::chrono::zoned_time = {{ {} {} }}'.format(zone, time)
-months = [None, 'January', 'February', 'March', 'April', 'May', 'June',
- 'July', 'August', 'September', 'October', 'November', 'December']
-
-weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
- 'Saturday', 'Sunday']
+months = [
+ None,
+ 'January',
+ 'February',
+ 'March',
+ 'April',
+ 'May',
+ 'June',
+ 'July',
+ 'August',
+ 'September',
+ 'October',
+ 'November',
+ 'December',
+]
+
+weekdays = [
+ 'Sunday',
+ 'Monday',
+ 'Tuesday',
+ 'Wednesday',
+ 'Thursday',
+ 'Friday',
+ 'Saturday',
+ 'Sunday',
+]
class StdChronoCalendarPrinter(printer_base):
@@ -2180,8 +2291,9 @@ class StdChronoCalendarPrinter(printer_base):
if typ.startswith('std::chrono::hh_mm_ss'):
fract = ''
if val['fractional_width'] != 0:
- fract = '.{:0{}d}'.format(int(val['_M_ss']['_M_r']),
- int(val['fractional_width']))
+ fract = '.{:0{}d}'.format(
+ int(val['_M_ss']['_M_r']), int(val['fractional_width'])
+ )
h = int(val['_M_h']['__r'])
m = int(val['_M_m']['__r'])
s = int(val['_M_s']['__r'])
@@ -2239,8 +2351,15 @@ class StdChronoTimeZoneRulePrinter(printer_base):
on = self._val['on']
kind = on['kind']
month = months[on['month']]
- suffixes = {1: 'st', 2: 'nd', 3: 'rd',
- 21: 'st', 22: 'nd', 23: 'rd', 31: 'st'}
+ suffixes = {
+ 1: 'st',
+ 2: 'nd',
+ 3: 'rd',
+ 21: 'st',
+ 22: 'nd',
+ 23: 'rd',
+ 31: 'st',
+ }
day = on['day_of_month']
ordinal_day = '{}{}'.format(day, suffixes.get(day, 'th'))
if kind == 0: # DayOfMonth
@@ -2255,11 +2374,12 @@ class StdChronoTimeZoneRulePrinter(printer_base):
else:
direction = ('first', '>=')
day = on['day_of_month']
- start = '{} {} {} {} {}'.format(direction[0], weekday,
- direction[1], month,
- ordinal_day)
+ start = '{} {} {} {} {}'.format(
+ direction[0], weekday, direction[1], month, ordinal_day
+ )
return 'time_zone rule {} from {} to {} starting on {}'.format(
- self._val['name'], self._val['from'], self._val['to'], start)
+ self._val['name'], self._val['from'], self._val['to'], start
+ )
class StdLocalePrinter(printer_base):
@@ -2292,7 +2412,7 @@ class StdLocalePrinter(printer_base):
if len(uniq_names) == 1:
name = n
elif len(uniq_names) == 2:
- n1, n2 = (uniq_names)
+ n1, n2 = uniq_names
name_list = list(cat_names.values())
other = None
if name_list.count(n1) == 1:
@@ -2326,6 +2446,7 @@ class RxPrinter(object):
return self._function(self.name, value)
+
# A pretty-printer that conforms to the "PrettyPrinter" protocol from
# gdb.printing. It can also be used directly as an old-style printer.
@@ -2344,7 +2465,8 @@ class Printer(object):
# FIXME
if not self._compiled_rx.match(name):
raise ValueError(
- 'libstdc++ programming error: "%s" does not match' % name)
+ 'libstdc++ programming error: "%s" does not match' % name
+ )
printer = RxPrinter(name, function)
self._subprinters.append(printer)
self._lookup[name] = printer
@@ -2353,8 +2475,9 @@ class Printer(object):
def add_version(self, base, name, function):
self.add(base + name, function)
if '__cxx11' not in base:
- vbase = re.sub('^(std|__gnu_cxx)::', r'\g<0>%s' %
- _versioned_namespace, base)
+ vbase = re.sub(
+ '^(std|__gnu_cxx)::', r'\g<0>%s' % _versioned_namespace, base
+ )
self.add(vbase + name, function)
# Add a name using _GLIBCXX_BEGIN_NAMESPACE_CONTAINER.
@@ -2468,7 +2591,7 @@ class TemplateTypePrinter(object):
displayed_args.append(self._recognize_subtype(targ))
# This assumes no class templates in the nested-name-specifier:
- template_name = type_obj.tag[0:type_obj.tag.find('<')]
+ template_name = type_obj.tag[0 : type_obj.tag.find('<')]
template_name = strip_inline_namespaces(template_name)
return template_name + '<' + ', '.join(displayed_args) + '>'
@@ -2491,7 +2614,8 @@ class TemplateTypePrinter(object):
return self._recognize_subtype(type_obj.target()) + '&&'
type_str = gdb.types.apply_type_recognizers(
- gdb.types.get_type_recognizers(), type_obj)
+ gdb.types.get_type_recognizers(), type_obj
+ )
if type_str:
return type_str
return str(type_obj)
@@ -2528,8 +2652,9 @@ def add_one_template_type_printer(obj, name, defargs):
# Add second type printer for same type in versioned namespace:
ns = 'std::' + _versioned_namespace
# PR 86112 Cannot use dict comprehension here:
- defargs = dict((n, d.replace('std::', ns))
- for (n, d) in defargs.items())
+ defargs = dict(
+ (n, d.replace('std::', ns)) for (n, d) in defargs.items()
+ )
printer = TemplateTypePrinter(ns + name, defargs)
gdb.types.register_type_printer(obj, printer)
@@ -2595,7 +2720,8 @@ class FilteringTypePrinter(object):
try:
self._type_obj = gdb.lookup_type(
- self.name).strip_typedefs()
+ self.name
+ ).strip_typedefs()
except:
pass
@@ -2638,27 +2764,45 @@ def register_type_printers(obj):
return
# Add type printers for typedefs std::string, std::wstring etc.
- for ch in (('', 'char'),
- ('w', 'wchar_t'),
- ('u8', 'char8_t'),
- ('u16', 'char16_t'),
- ('u32', 'char32_t')):
+ for ch in (
+ ('', 'char'),
+ ('w', 'wchar_t'),
+ ('u8', 'char8_t'),
+ ('u16', 'char16_t'),
+ ('u32', 'char32_t'),
+ ):
add_one_type_printer(obj, 'basic_string', ch[0] + 'string', ch[1])
- add_one_type_printer(obj, '__cxx11::basic_string',
- ch[0] + 'string', ch[1])
+ add_one_type_printer(
+ obj, '__cxx11::basic_string', ch[0] + 'string', ch[1]
+ )
# Typedefs for __cxx11::basic_string used to be in namespace __cxx11:
- add_one_type_printer(obj, '__cxx11::basic_string',
- '__cxx11::' + ch[0] + 'string', ch[1])
- add_one_type_printer(obj, 'basic_string_view',
- ch[0] + 'string_view', ch[1])
+ add_one_type_printer(
+ obj, '__cxx11::basic_string', '__cxx11::' + ch[0] + 'string', ch[1]
+ )
+ add_one_type_printer(
+ obj, 'basic_string_view', ch[0] + 'string_view', ch[1]
+ )
# Add type printers for typedefs std::istream, std::wistream etc.
for ch in (('', 'char'), ('w', 'wchar_t')):
- for x in ('ios', 'streambuf', 'istream', 'ostream', 'iostream',
- 'filebuf', 'ifstream', 'ofstream', 'fstream'):
+ for x in (
+ 'ios',
+ 'streambuf',
+ 'istream',
+ 'ostream',
+ 'iostream',
+ 'filebuf',
+ 'ifstream',
+ 'ofstream',
+ 'fstream',
+ ):
add_one_type_printer(obj, 'basic_' + x, ch[0] + x, ch[1])
- for x in ('stringbuf', 'istringstream', 'ostringstream',
- 'stringstream'):
+ for x in (
+ 'stringbuf',
+ 'istringstream',
+ 'ostringstream',
+ 'stringstream',
+ ):
add_one_type_printer(obj, 'basic_' + x, ch[0] + x, ch[1])
# <sstream> types are in __cxx11 namespace, but typedefs aren't:
add_one_type_printer(obj, '__cxx11::basic_' + x, ch[0] + x, ch[1])
@@ -2666,11 +2810,13 @@ def register_type_printers(obj):
# Add type printers for typedefs regex, wregex, cmatch, wcmatch etc.
for abi in ('', '__cxx11::'):
for ch in (('', 'char'), ('w', 'wchar_t')):
- add_one_type_printer(obj, abi + 'basic_regex',
- abi + ch[0] + 'regex', ch[1])
+ add_one_type_printer(
+ obj, abi + 'basic_regex', abi + ch[0] + 'regex', ch[1]
+ )
for ch in ('c', 's', 'wc', 'ws'):
add_one_type_printer(
- obj, abi + 'match_results', abi + ch + 'match')
+ obj, abi + 'match_results', abi + ch + 'match'
+ )
for x in ('sub_match', 'regex_iterator', 'regex_token_iterator'):
add_one_type_printer(obj, abi + x, abi + ch + x)
@@ -2679,8 +2825,18 @@ def register_type_printers(obj):
add_one_type_printer(obj, 'fpos', 'streampos')
# Add type printers for <chrono> typedefs.
- for dur in ('nanoseconds', 'microseconds', 'milliseconds', 'seconds',
- 'minutes', 'hours', 'days', 'weeks', 'years', 'months'):
+ for dur in (
+ 'nanoseconds',
+ 'microseconds',
+ 'milliseconds',
+ 'seconds',
+ 'minutes',
+ 'hours',
+ 'days',
+ 'weeks',
+ 'years',
+ 'months',
+ ):
add_one_type_printer(obj, 'chrono::duration', 'chrono::' + dur)
# Add type printers for <random> typedefs.
@@ -2696,50 +2852,82 @@ def register_type_printers(obj):
# Add type printers for experimental::basic_string_view typedefs.
ns = 'experimental::fundamentals_v1::'
- for ch in (('', 'char'),
- ('w', 'wchar_t'),
- ('u8', 'char8_t'),
- ('u16', 'char16_t'),
- ('u32', 'char32_t')):
- add_one_type_printer(obj, ns + 'basic_string_view',
- ns + ch[0] + 'string_view', ch[1])
+ for ch in (
+ ('', 'char'),
+ ('w', 'wchar_t'),
+ ('u8', 'char8_t'),
+ ('u16', 'char16_t'),
+ ('u32', 'char32_t'),
+ ):
+ add_one_type_printer(
+ obj, ns + 'basic_string_view', ns + ch[0] + 'string_view', ch[1]
+ )
# Do not show defaulted template arguments in class templates.
- add_one_template_type_printer(obj, 'unique_ptr',
- {1: 'std::default_delete<{0}>'})
+ add_one_template_type_printer(
+ obj, 'unique_ptr', {1: 'std::default_delete<{0}>'}
+ )
add_one_template_type_printer(obj, 'deque', {1: 'std::allocator<{0}>'})
add_one_template_type_printer(
- obj, 'forward_list', {1: 'std::allocator<{0}>'})
+ obj, 'forward_list', {1: 'std::allocator<{0}>'}
+ )
add_one_template_type_printer(obj, 'list', {1: 'std::allocator<{0}>'})
add_one_template_type_printer(
- obj, '__cxx11::list', {1: 'std::allocator<{0}>'})
+ obj, '__cxx11::list', {1: 'std::allocator<{0}>'}
+ )
add_one_template_type_printer(obj, 'vector', {1: 'std::allocator<{0}>'})
- add_one_template_type_printer(obj, 'map',
- {2: 'std::less<{0}>',
- 3: 'std::allocator<std::pair<{0} const, {1}>>'})
- add_one_template_type_printer(obj, 'multimap',
- {2: 'std::less<{0}>',
- 3: 'std::allocator<std::pair<{0} const, {1}>>'})
- add_one_template_type_printer(obj, 'set',
- {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'})
- add_one_template_type_printer(obj, 'multiset',
- {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'})
- add_one_template_type_printer(obj, 'unordered_map',
- {2: 'std::hash<{0}>',
- 3: 'std::equal_to<{0}>',
- 4: 'std::allocator<std::pair<{0} const, {1}>>'})
- add_one_template_type_printer(obj, 'unordered_multimap',
- {2: 'std::hash<{0}>',
- 3: 'std::equal_to<{0}>',
- 4: 'std::allocator<std::pair<{0} const, {1}>>'})
- add_one_template_type_printer(obj, 'unordered_set',
- {1: 'std::hash<{0}>',
- 2: 'std::equal_to<{0}>',
- 3: 'std::allocator<{0}>'})
- add_one_template_type_printer(obj, 'unordered_multiset',
- {1: 'std::hash<{0}>',
- 2: 'std::equal_to<{0}>',
- 3: 'std::allocator<{0}>'})
+ add_one_template_type_printer(
+ obj,
+ 'map',
+ {2: 'std::less<{0}>', 3: 'std::allocator<std::pair<{0} const, {1}>>'},
+ )
+ add_one_template_type_printer(
+ obj,
+ 'multimap',
+ {2: 'std::less<{0}>', 3: 'std::allocator<std::pair<{0} const, {1}>>'},
+ )
+ add_one_template_type_printer(
+ obj, 'set', {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'}
+ )
+ add_one_template_type_printer(
+ obj, 'multiset', {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'}
+ )
+ add_one_template_type_printer(
+ obj,
+ 'unordered_map',
+ {
+ 2: 'std::hash<{0}>',
+ 3: 'std::equal_to<{0}>',
+ 4: 'std::allocator<std::pair<{0} const, {1}>>',
+ },
+ )
+ add_one_template_type_printer(
+ obj,
+ 'unordered_multimap',
+ {
+ 2: 'std::hash<{0}>',
+ 3: 'std::equal_to<{0}>',
+ 4: 'std::allocator<std::pair<{0} const, {1}>>',
+ },
+ )
+ add_one_template_type_printer(
+ obj,
+ 'unordered_set',
+ {
+ 1: 'std::hash<{0}>',
+ 2: 'std::equal_to<{0}>',
+ 3: 'std::allocator<{0}>',
+ },
+ )
+ add_one_template_type_printer(
+ obj,
+ 'unordered_multiset',
+ {
+ 1: 'std::hash<{0}>',
+ 2: 'std::equal_to<{0}>',
+ 3: 'std::allocator<{0}>',
+ },
+ )
def register_libstdcxx_printers(obj):
@@ -2768,7 +2956,8 @@ def build_libstdcxx_dictionary():
# http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01847.html
libstdcxx_printer.add_version('std::', 'basic_string', StdStringPrinter)
libstdcxx_printer.add_version(
- 'std::__cxx11::', 'basic_string', StdStringPrinter)
+ 'std::__cxx11::', 'basic_string', StdStringPrinter
+ )
libstdcxx_printer.add_container('std::', 'bitset', StdBitsetPrinter)
libstdcxx_printer.add_container('std::', 'deque', StdDequePrinter)
libstdcxx_printer.add_container('std::', 'list', StdListPrinter)
@@ -2777,8 +2966,9 @@ def build_libstdcxx_dictionary():
libstdcxx_printer.add_container('std::', 'multimap', StdMapPrinter)
libstdcxx_printer.add_container('std::', 'multiset', StdSetPrinter)
libstdcxx_printer.add_version('std::', 'pair', StdPairPrinter)
- libstdcxx_printer.add_version('std::', 'priority_queue',
- StdStackOrQueuePrinter)
+ libstdcxx_printer.add_version(
+ 'std::', 'priority_queue', StdStackOrQueuePrinter
+ )
libstdcxx_printer.add_version('std::', 'queue', StdStackOrQueuePrinter)
libstdcxx_printer.add_version('std::', 'tuple', StdTuplePrinter)
libstdcxx_printer.add_container('std::', 'set', StdSetPrinter)
@@ -2789,10 +2979,12 @@ def build_libstdcxx_dictionary():
libstdcxx_printer.add_version('std::', 'locale', StdLocalePrinter)
if hasattr(gdb.Value, 'dynamic_type'):
- libstdcxx_printer.add_version('std::', 'error_code',
- StdErrorCodePrinter)
- libstdcxx_printer.add_version('std::', 'error_condition',
- StdErrorCodePrinter)
+ libstdcxx_printer.add_version(
+ 'std::', 'error_code', StdErrorCodePrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::', 'error_condition', StdErrorCodePrinter
+ )
# Printer registrations for classes compiled with -D_GLIBCXX_DEBUG.
libstdcxx_printer.add('std::__debug::bitset', StdBitsetPrinter)
@@ -2808,119 +3000,173 @@ def build_libstdcxx_dictionary():
# For array - the default GDB pretty-printer seems reasonable.
libstdcxx_printer.add_version('std::', 'shared_ptr', SharedPointerPrinter)
libstdcxx_printer.add_version('std::', 'weak_ptr', SharedPointerPrinter)
- libstdcxx_printer.add_container('std::', 'unordered_map',
- Tr1UnorderedMapPrinter)
- libstdcxx_printer.add_container('std::', 'unordered_set',
- Tr1UnorderedSetPrinter)
- libstdcxx_printer.add_container('std::', 'unordered_multimap',
- Tr1UnorderedMapPrinter)
- libstdcxx_printer.add_container('std::', 'unordered_multiset',
- Tr1UnorderedSetPrinter)
- libstdcxx_printer.add_container('std::', 'forward_list',
- StdForwardListPrinter)
+ libstdcxx_printer.add_container(
+ 'std::', 'unordered_map', Tr1UnorderedMapPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', 'unordered_set', Tr1UnorderedSetPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', 'unordered_multimap', Tr1UnorderedMapPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', 'unordered_multiset', Tr1UnorderedSetPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', 'forward_list', StdForwardListPrinter
+ )
libstdcxx_printer.add_version(
- 'std::tr1::', 'shared_ptr', SharedPointerPrinter)
+ 'std::tr1::', 'shared_ptr', SharedPointerPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::tr1::', 'weak_ptr', SharedPointerPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::tr1::', 'unordered_map', Tr1UnorderedMapPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::tr1::', 'unordered_set', Tr1UnorderedSetPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::tr1::', 'unordered_multimap', Tr1UnorderedMapPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::tr1::', 'unordered_multiset', Tr1UnorderedSetPrinter
+ )
+
libstdcxx_printer.add_version(
- 'std::tr1::', 'weak_ptr', SharedPointerPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_map',
- Tr1UnorderedMapPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_set',
- Tr1UnorderedSetPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_multimap',
- Tr1UnorderedMapPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_multiset',
- Tr1UnorderedSetPrinter)
-
- libstdcxx_printer.add_version('std::', 'initializer_list',
- StdInitializerListPrinter)
+ 'std::', 'initializer_list', StdInitializerListPrinter
+ )
libstdcxx_printer.add_version('std::', 'atomic', StdAtomicPrinter)
libstdcxx_printer.add_version(
- 'std::', 'basic_stringbuf', StdStringBufPrinter)
+ 'std::', 'basic_stringbuf', StdStringBufPrinter
+ )
libstdcxx_printer.add_version(
- 'std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter)
+ 'std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter
+ )
for sstream in ('istringstream', 'ostringstream', 'stringstream'):
libstdcxx_printer.add_version(
- 'std::', 'basic_' + sstream, StdStringStreamPrinter)
+ 'std::', 'basic_' + sstream, StdStringStreamPrinter
+ )
libstdcxx_printer.add_version(
- 'std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter)
+ 'std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter
+ )
- libstdcxx_printer.add_version('std::chrono::', 'duration',
- StdChronoDurationPrinter)
- libstdcxx_printer.add_version('std::chrono::', 'time_point',
- StdChronoTimePointPrinter)
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'duration', StdChronoDurationPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'time_point', StdChronoTimePointPrinter
+ )
# std::regex components
- libstdcxx_printer.add_version('std::__detail::', '_State',
- StdRegexStatePrinter)
+ libstdcxx_printer.add_version(
+ 'std::__detail::', '_State', StdRegexStatePrinter
+ )
# These are the C++11 printer registrations for -D_GLIBCXX_DEBUG cases.
# The tr1 namespace containers do not have any debug equivalents,
# so do not register printers for them.
- libstdcxx_printer.add('std::__debug::unordered_map',
- Tr1UnorderedMapPrinter)
- libstdcxx_printer.add('std::__debug::unordered_set',
- Tr1UnorderedSetPrinter)
- libstdcxx_printer.add('std::__debug::unordered_multimap',
- Tr1UnorderedMapPrinter)
- libstdcxx_printer.add('std::__debug::unordered_multiset',
- Tr1UnorderedSetPrinter)
- libstdcxx_printer.add('std::__debug::forward_list',
- StdForwardListPrinter)
+ libstdcxx_printer.add(
+ 'std::__debug::unordered_map', Tr1UnorderedMapPrinter
+ )
+ libstdcxx_printer.add(
+ 'std::__debug::unordered_set', Tr1UnorderedSetPrinter
+ )
+ libstdcxx_printer.add(
+ 'std::__debug::unordered_multimap', Tr1UnorderedMapPrinter
+ )
+ libstdcxx_printer.add(
+ 'std::__debug::unordered_multiset', Tr1UnorderedSetPrinter
+ )
+ libstdcxx_printer.add('std::__debug::forward_list', StdForwardListPrinter)
# Library Fundamentals TS components
- libstdcxx_printer.add_version('std::experimental::fundamentals_v1::',
- 'any', StdExpAnyPrinter)
- libstdcxx_printer.add_version('std::experimental::fundamentals_v1::',
- 'optional', StdExpOptionalPrinter)
- libstdcxx_printer.add_version('std::experimental::fundamentals_v1::',
- 'basic_string_view', StdExpStringViewPrinter)
+ libstdcxx_printer.add_version(
+ 'std::experimental::fundamentals_v1::', 'any', StdExpAnyPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::experimental::fundamentals_v1::',
+ 'optional',
+ StdExpOptionalPrinter,
+ )
+ libstdcxx_printer.add_version(
+ 'std::experimental::fundamentals_v1::',
+ 'basic_string_view',
+ StdExpStringViewPrinter,
+ )
# Filesystem TS components
- libstdcxx_printer.add_version('std::experimental::filesystem::v1::',
- 'path', StdExpPathPrinter)
- libstdcxx_printer.add_version('std::experimental::filesystem::v1::__cxx11::',
- 'path', StdExpPathPrinter)
- libstdcxx_printer.add_version('std::filesystem::',
- 'path', StdPathPrinter)
- libstdcxx_printer.add_version('std::filesystem::__cxx11::',
- 'path', StdPathPrinter)
+ libstdcxx_printer.add_version(
+ 'std::experimental::filesystem::v1::', 'path', StdExpPathPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::experimental::filesystem::v1::__cxx11::',
+ 'path',
+ StdExpPathPrinter,
+ )
+ libstdcxx_printer.add_version('std::filesystem::', 'path', StdPathPrinter)
+ libstdcxx_printer.add_version(
+ 'std::filesystem::__cxx11::', 'path', StdPathPrinter
+ )
# C++17 components
- libstdcxx_printer.add_version('std::',
- 'any', StdExpAnyPrinter)
- libstdcxx_printer.add_version('std::',
- 'optional', StdExpOptionalPrinter)
- libstdcxx_printer.add_version('std::',
- 'basic_string_view', StdExpStringViewPrinter)
- libstdcxx_printer.add_version('std::',
- 'variant', StdVariantPrinter)
- libstdcxx_printer.add_version('std::',
- '_Node_handle', StdNodeHandlePrinter)
+ libstdcxx_printer.add_version('std::', 'any', StdExpAnyPrinter)
+ libstdcxx_printer.add_version('std::', 'optional', StdExpOptionalPrinter)
+ libstdcxx_printer.add_version(
+ 'std::', 'basic_string_view', StdExpStringViewPrinter
+ )
+ libstdcxx_printer.add_version('std::', 'variant', StdVariantPrinter)
+ libstdcxx_printer.add_version(
+ 'std::', '_Node_handle', StdNodeHandlePrinter
+ )
# C++20 components
libstdcxx_printer.add_version(
- 'std::', 'partial_ordering', StdCmpCatPrinter)
+ 'std::', 'partial_ordering', StdCmpCatPrinter
+ )
libstdcxx_printer.add_version('std::', 'weak_ordering', StdCmpCatPrinter)
libstdcxx_printer.add_version('std::', 'strong_ordering', StdCmpCatPrinter)
libstdcxx_printer.add_version('std::', 'span', StdSpanPrinter)
- libstdcxx_printer.add_version('std::', 'basic_format_args',
- StdFormatArgsPrinter)
- for c in ['day', 'month', 'year', 'weekday', 'weekday_indexed', 'weekday_last',
- 'month_day', 'month_day_last', 'month_weekday', 'month_weekday_last',
- 'year_month', 'year_month_day', 'year_month_day_last',
- 'year_month_weekday', 'year_month_weekday_last', 'hh_mm_ss']:
- libstdcxx_printer.add_version('std::chrono::', c,
- StdChronoCalendarPrinter)
- libstdcxx_printer.add_version('std::chrono::', 'time_zone',
- StdChronoTimeZonePrinter)
- libstdcxx_printer.add_version('std::chrono::', 'time_zone_link',
- StdChronoTimeZonePrinter)
- libstdcxx_printer.add_version('std::chrono::', 'zoned_time',
- StdChronoZonedTimePrinter)
- libstdcxx_printer.add_version('std::chrono::', 'leap_second',
- StdChronoLeapSecondPrinter)
libstdcxx_printer.add_version(
- 'std::chrono::', 'tzdb', StdChronoTzdbPrinter)
+ 'std::', 'basic_format_args', StdFormatArgsPrinter
+ )
+ for c in [
+ 'day',
+ 'month',
+ 'year',
+ 'weekday',
+ 'weekday_indexed',
+ 'weekday_last',
+ 'month_day',
+ 'month_day_last',
+ 'month_weekday',
+ 'month_weekday_last',
+ 'year_month',
+ 'year_month_day',
+ 'year_month_day_last',
+ 'year_month_weekday',
+ 'year_month_weekday_last',
+ 'hh_mm_ss',
+ ]:
+ libstdcxx_printer.add_version(
+ 'std::chrono::', c, StdChronoCalendarPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'time_zone', StdChronoTimeZonePrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'time_zone_link', StdChronoTimeZonePrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'zoned_time', StdChronoZonedTimePrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'leap_second', StdChronoLeapSecondPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::chrono::', 'tzdb', StdChronoTzdbPrinter
+ )
# libstdcxx_printer.add_version('std::chrono::(anonymous namespace)', 'Rule',
# StdChronoTimeZoneRulePrinter)
@@ -2930,37 +3176,51 @@ def build_libstdcxx_dictionary():
if True:
# These shouldn't be necessary, if GDB "print *i" worked.
# But it often doesn't, so here they are.
- libstdcxx_printer.add_container('std::', '_List_iterator',
- StdListIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_List_const_iterator',
- StdListIteratorPrinter)
- libstdcxx_printer.add_version('std::', '_Rb_tree_iterator',
- StdRbtreeIteratorPrinter)
- libstdcxx_printer.add_version('std::', '_Rb_tree_const_iterator',
- StdRbtreeIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Deque_iterator',
- StdDequeIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Deque_const_iterator',
- StdDequeIteratorPrinter)
- libstdcxx_printer.add_version('__gnu_cxx::', '__normal_iterator',
- StdVectorIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Bit_iterator',
- StdBitIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Bit_const_iterator',
- StdBitIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Bit_reference',
- StdBitReferencePrinter)
- libstdcxx_printer.add_version('__gnu_cxx::', '_Slist_iterator',
- StdSlistIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Fwd_list_iterator',
- StdFwdListIteratorPrinter)
- libstdcxx_printer.add_container('std::', '_Fwd_list_const_iterator',
- StdFwdListIteratorPrinter)
+ libstdcxx_printer.add_container(
+ 'std::', '_List_iterator', StdListIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_List_const_iterator', StdListIteratorPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::', '_Rb_tree_iterator', StdRbtreeIteratorPrinter
+ )
+ libstdcxx_printer.add_version(
+ 'std::', '_Rb_tree_const_iterator', StdRbtreeIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Deque_iterator', StdDequeIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Deque_const_iterator', StdDequeIteratorPrinter
+ )
+ libstdcxx_printer.add_version(
+ '__gnu_cxx::', '__normal_iterator', StdVectorIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Bit_iterator', StdBitIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Bit_const_iterator', StdBitIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Bit_reference', StdBitReferencePrinter
+ )
+ libstdcxx_printer.add_version(
+ '__gnu_cxx::', '_Slist_iterator', StdSlistIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Fwd_list_iterator', StdFwdListIteratorPrinter
+ )
+ libstdcxx_printer.add_container(
+ 'std::', '_Fwd_list_const_iterator', StdFwdListIteratorPrinter
+ )
# Debug (compiled with -D_GLIBCXX_DEBUG) printer
# registrations.
- libstdcxx_printer.add('__gnu_debug::_Safe_iterator',
- StdDebugIteratorPrinter)
+ libstdcxx_printer.add(
+ '__gnu_debug::_Safe_iterator', StdDebugIteratorPrinter
+ )
build_libstdcxx_dictionary()
@@ -15,9 +15,10 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
+import re
+
import gdb
import gdb.xmethod
-import re
matcher_name_prefix = 'libstdc++::'
@@ -25,11 +26,14 @@ matcher_name_prefix = 'libstdc++::'
def get_bool_type():
return gdb.lookup_type('bool')
+
def get_std_size_type():
return gdb.lookup_type('std::size_t')
+
_versioned_namespace = '__8::'
+
def is_specialization_of(x, template_name):
"""
Test whether a type is a specialization of the named class template.
@@ -42,11 +46,13 @@ def is_specialization_of(x, template_name):
template_name = '(%s)?%s' % (_versioned_namespace, template_name)
return re.match(r'^std::(__\d::)?%s<.*>$' % template_name, x) is not None
+
class LibStdCxxXMethod(gdb.xmethod.XMethod):
def __init__(self, name, worker_class):
gdb.xmethod.XMethod.__init__(self, name)
self.worker_class = worker_class
+
# Xmethods for std::array
@@ -85,7 +91,7 @@ class ArrayEmptyWorker(ArrayWorkerBase):
return get_bool_type()
def __call__(self, obj):
- return (int(self._size) == 0)
+ return int(self._size) == 0
class ArrayFrontWorker(ArrayWorkerBase):
@@ -134,8 +140,10 @@ class ArrayAtWorker(ArrayWorkerBase):
def __call__(self, obj, index):
if int(index) >= int(self._size):
- raise IndexError('Array index "%d" should not be >= %d.' %
- ((int(index), self._size)))
+ raise IndexError(
+ 'Array index "%d" should not be >= %d.'
+ % ((int(index), self._size))
+ )
return obj['_M_elems'][index]
@@ -158,8 +166,9 @@ class ArraySubscriptWorker(ArrayWorkerBase):
class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + 'array')
+ gdb.xmethod.XMethodMatcher.__init__(
+ self, matcher_name_prefix + 'array'
+ )
self._method_dict = {
'size': LibStdCxxXMethod('size', ArraySizeWorker),
'empty': LibStdCxxXMethod('empty', ArrayEmptyWorker),
@@ -213,8 +222,10 @@ class DequeEmptyWorker(DequeWorkerBase):
return get_bool_type()
def __call__(self, obj):
- return (obj['_M_impl']['_M_start']['_M_cur'] ==
- obj['_M_impl']['_M_finish']['_M_cur'])
+ return (
+ obj['_M_impl']['_M_start']['_M_cur']
+ == obj['_M_impl']['_M_finish']['_M_cur']
+ )
class DequeSizeWorker(DequeWorkerBase):
@@ -247,8 +258,10 @@ class DequeBackWorker(DequeWorkerBase):
return self._val_type
def __call__(self, obj):
- if (obj['_M_impl']['_M_finish']['_M_cur'] ==
- obj['_M_impl']['_M_finish']['_M_first']):
+ if (
+ obj['_M_impl']['_M_finish']['_M_cur']
+ == obj['_M_impl']['_M_finish']['_M_first']
+ ):
prev_node = obj['_M_impl']['_M_finish']['_M_node'] - 1
return prev_node[0][self._bufsize - 1]
else:
@@ -276,23 +289,26 @@ class DequeAtWorker(DequeWorkerBase):
def __call__(self, obj, index):
deque_size = int(self.size(obj))
if int(index) >= deque_size:
- raise IndexError('Deque index "%d" should not be >= %d.' %
- (int(index), deque_size))
+ raise IndexError(
+ 'Deque index "%d" should not be >= %d.'
+ % (int(index), deque_size)
+ )
else:
return self.index(obj, index)
class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + 'deque')
+ gdb.xmethod.XMethodMatcher.__init__(
+ self, matcher_name_prefix + 'deque'
+ )
self._method_dict = {
'empty': LibStdCxxXMethod('empty', DequeEmptyWorker),
'size': LibStdCxxXMethod('size', DequeSizeWorker),
'front': LibStdCxxXMethod('front', DequeFrontWorker),
'back': LibStdCxxXMethod('back', DequeBackWorker),
'operator[]': LibStdCxxXMethod('operator[]', DequeSubscriptWorker),
- 'at': LibStdCxxXMethod('at', DequeAtWorker)
+ 'at': LibStdCxxXMethod('at', DequeAtWorker),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -304,6 +320,7 @@ class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher):
return None
return method.worker_class(class_type.template_argument(0))
+
# Xmethods for std::forward_list
@@ -340,7 +357,7 @@ class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher):
gdb.xmethod.XMethodMatcher.__init__(self, matcher_name)
self._method_dict = {
'empty': LibStdCxxXMethod('empty', ForwardListEmptyWorker),
- 'front': LibStdCxxXMethod('front', ForwardListFrontWorker)
+ 'front': LibStdCxxXMethod('front', ForwardListFrontWorker),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -354,6 +371,7 @@ class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher):
node_type = gdb.lookup_type(str(class_type) + '::_Node').pointer()
return method.worker_class(val_type, node_type)
+
# Xmethods for std::list
@@ -421,13 +439,12 @@ class ListBackWorker(ListWorkerBase):
class ListMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + 'list')
+ gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'list')
self._method_dict = {
'empty': LibStdCxxXMethod('empty', ListEmptyWorker),
'size': LibStdCxxXMethod('size', ListSizeWorker),
'front': LibStdCxxXMethod('front', ListFrontWorker),
- 'back': LibStdCxxXMethod('back', ListBackWorker)
+ 'back': LibStdCxxXMethod('back', ListBackWorker),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -441,6 +458,7 @@ class ListMethodsMatcher(gdb.xmethod.XMethodMatcher):
node_type = gdb.lookup_type(str(class_type) + '::_Node').pointer()
return method.worker_class(val_type, node_type)
+
# Xmethods for std::vector
@@ -523,8 +541,9 @@ class VectorAtWorker(VectorWorkerBase):
def __call__(self, obj, index):
size = int(self.size(obj))
if int(index) >= size:
- raise IndexError('Vector index "%d" should not be >= %d.' %
- ((int(index), size)))
+ raise IndexError(
+ 'Vector index "%d" should not be >= %d.' % ((int(index), size))
+ )
return self.get(obj, int(index))
@@ -541,16 +560,18 @@ class VectorSubscriptWorker(VectorWorkerBase):
class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + 'vector')
+ gdb.xmethod.XMethodMatcher.__init__(
+ self, matcher_name_prefix + 'vector'
+ )
self._method_dict = {
'size': LibStdCxxXMethod('size', VectorSizeWorker),
'empty': LibStdCxxXMethod('empty', VectorEmptyWorker),
'front': LibStdCxxXMethod('front', VectorFrontWorker),
'back': LibStdCxxXMethod('back', VectorBackWorker),
'at': LibStdCxxXMethod('at', VectorAtWorker),
- 'operator[]': LibStdCxxXMethod('operator[]',
- VectorSubscriptWorker),
+ 'operator[]': LibStdCxxXMethod(
+ 'operator[]', VectorSubscriptWorker
+ ),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -562,6 +583,7 @@ class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher):
return None
return method.worker_class(class_type.template_argument(0))
+
# Xmethods for associative containers
@@ -597,13 +619,13 @@ class AssociativeContainerSizeWorker(AssociativeContainerWorkerBase):
class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self, name):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + name)
+ gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + name)
self._name = name
self._method_dict = {
'size': LibStdCxxXMethod('size', AssociativeContainerSizeWorker),
- 'empty': LibStdCxxXMethod('empty',
- AssociativeContainerEmptyWorker),
+ 'empty': LibStdCxxXMethod(
+ 'empty', AssociativeContainerEmptyWorker
+ ),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -616,6 +638,7 @@ class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher):
unordered = 'unordered' in self._name
return method.worker_class(unordered)
+
# Xmethods for std::unique_ptr
@@ -651,7 +674,7 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker):
else:
return None
tuple_impl_type = tuple_member.type.fields()[0].type # _Tuple_impl
- tuple_head_type = tuple_impl_type.fields()[1].type # _Head_base
+ tuple_head_type = tuple_impl_type.fields()[1].type # _Head_base
head_field = tuple_head_type.fields()[0]
if head_field.name == '_M_head_impl':
return tuple_member.cast(tuple_head_type)['_M_head_impl']
@@ -700,13 +723,16 @@ class UniquePtrSubscriptWorker(UniquePtrGetWorker):
class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + 'unique_ptr')
+ gdb.xmethod.XMethodMatcher.__init__(
+ self, matcher_name_prefix + 'unique_ptr'
+ )
self._method_dict = {
'get': LibStdCxxXMethod('get', UniquePtrGetWorker),
'operator->': LibStdCxxXMethod('operator->', UniquePtrGetWorker),
'operator*': LibStdCxxXMethod('operator*', UniquePtrDerefWorker),
- 'operator[]': LibStdCxxXMethod('operator[]', UniquePtrSubscriptWorker),
+ 'operator[]': LibStdCxxXMethod(
+ 'operator[]', UniquePtrSubscriptWorker
+ ),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -721,6 +747,7 @@ class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
return worker
return None
+
# Xmethods for std::shared_ptr
@@ -787,8 +814,10 @@ class SharedPtrSubscriptWorker(SharedPtrGetWorker):
# Check bounds if _elem_type is an array of known bound
m = re.match(r'.*\[(\d+)]$', str(self._elem_type))
if m and index >= int(m.group(1)):
- raise IndexError('shared_ptr<%s> index "%d" should not be >= %d.' %
- (self._elem_type, int(index), int(m.group(1))))
+ raise IndexError(
+ 'shared_ptr<%s> index "%d" should not be >= %d.'
+ % (self._elem_type, int(index), int(m.group(1)))
+ )
return SharedPtrGetWorker.__call__(self, obj)[index]
@@ -827,14 +856,19 @@ class SharedPtrUniqueWorker(SharedPtrUseCountWorker):
class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
def __init__(self):
- gdb.xmethod.XMethodMatcher.__init__(self,
- matcher_name_prefix + 'shared_ptr')
+ gdb.xmethod.XMethodMatcher.__init__(
+ self, matcher_name_prefix + 'shared_ptr'
+ )
self._method_dict = {
'get': LibStdCxxXMethod('get', SharedPtrGetWorker),
'operator->': LibStdCxxXMethod('operator->', SharedPtrGetWorker),
'operator*': LibStdCxxXMethod('operator*', SharedPtrDerefWorker),
- 'operator[]': LibStdCxxXMethod('operator[]', SharedPtrSubscriptWorker),
- 'use_count': LibStdCxxXMethod('use_count', SharedPtrUseCountWorker),
+ 'operator[]': LibStdCxxXMethod(
+ 'operator[]', SharedPtrSubscriptWorker
+ ),
+ 'use_count': LibStdCxxXMethod(
+ 'use_count', SharedPtrUseCountWorker
+ ),
'unique': LibStdCxxXMethod('unique', SharedPtrUniqueWorker),
}
self.methods = [self._method_dict[m] for m in self._method_dict]
@@ -849,7 +883,7 @@ class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
if worker._supports(method_name):
return worker
return None
-
+
def register_libstdcxx_xmethods(locus):
gdb.xmethod.register_xmethod_matcher(locus, ArrayMethodsMatcher())
@@ -858,20 +892,28 @@ def register_libstdcxx_xmethods(locus):
gdb.xmethod.register_xmethod_matcher(locus, ListMethodsMatcher())
gdb.xmethod.register_xmethod_matcher(locus, VectorMethodsMatcher())
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('set'))
+ locus, AssociativeContainerMethodsMatcher('set')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('map'))
+ locus, AssociativeContainerMethodsMatcher('map')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('multiset'))
+ locus, AssociativeContainerMethodsMatcher('multiset')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('multimap'))
+ locus, AssociativeContainerMethodsMatcher('multimap')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('unordered_set'))
+ locus, AssociativeContainerMethodsMatcher('unordered_set')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('unordered_map'))
+ locus, AssociativeContainerMethodsMatcher('unordered_map')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('unordered_multiset'))
+ locus, AssociativeContainerMethodsMatcher('unordered_multiset')
+ )
gdb.xmethod.register_xmethod_matcher(
- locus, AssociativeContainerMethodsMatcher('unordered_multimap'))
+ locus, AssociativeContainerMethodsMatcher('unordered_multimap')
+ )
gdb.xmethod.register_xmethod_matcher(locus, UniquePtrMethodsMatcher())
gdb.xmethod.register_xmethod_matcher(locus, SharedPtrMethodsMatcher())
new file mode 100644
@@ -0,0 +1,6 @@
+[tool.black]
+line-length = 79
+skip-string-normalization = true
+
+[tool.isort]
+profile = "black"