[committed] libstdc++: Format Python code according to PEP8

Jonathan Wakely jwakely@redhat.com
Tue Sep 12 11:45:08 GMT 2023


Tested x86_64-linux. Pushed to trunk.

-- >8 --

These files were filtered through autopep8 to reformat them more
conventionally.

libstdc++-v3/ChangeLog:

	* python/libstdcxx/v6/printers.py: Reformat.
	* python/libstdcxx/v6/xmethods.py: Likewise.
---
 libstdc++-v3/python/libstdcxx/v6/printers.py | 651 +++++++++++--------
 libstdc++-v3/python/libstdcxx/v6/xmethods.py |  58 +-
 2 files changed, 446 insertions(+), 263 deletions(-)

diff --git a/libstdc++-v3/python/libstdcxx/v6/printers.py b/libstdc++-v3/python/libstdcxx/v6/printers.py
index 37a447b514b..c0056de2565 100644
--- a/libstdc++-v3/python/libstdcxx/v6/printers.py
+++ b/libstdc++-v3/python/libstdcxx/v6/printers.py
@@ -18,10 +18,12 @@
 import gdb
 import itertools
 import re
-import sys, os, errno
+import sys
+import os
+import errno
 import datetime
 
-### Python 2 + Python 3 compatibility code
+# Python 2 + Python 3 compatibility code
 
 # Resources about compatibility:
 #
@@ -38,7 +40,7 @@ import datetime
 # <https://sourceware.org/bugzilla/show_bug.cgi?id=17138>
 
 if sys.version_info[0] > 2:
-    ### Python 3 stuff
+    # Python 3 stuff
     Iterator = object
     # Python 3 folds these into the normal functions.
     imap = map
@@ -47,7 +49,7 @@ if sys.version_info[0] > 2:
     long = int
     _utc_timezone = datetime.timezone.utc
 else:
-    ### Python 2 stuff
+    # Python 2 stuff
     class Iterator:
         """Compatibility mixin for iterators
 
@@ -98,6 +100,8 @@ except ImportError:
 # Starting with the type ORIG, search for the member type NAME.  This
 # handles searching upward through superclasses.  This is needed to
 # work around http://sourceware.org/bugzilla/show_bug.cgi?id=13615.
+
+
 def find_type(orig, name):
     typ = orig.strip_typedefs()
     while True:
@@ -116,8 +120,10 @@ def find_type(orig, name):
         else:
             raise ValueError("Cannot find type %s::%s" % (str(orig), name))
 
+
 _versioned_namespace = '__8::'
 
+
 def lookup_templ_spec(templ, *args):
     """
     Lookup template specialization templ<args...>
@@ -139,6 +145,8 @@ def lookup_templ_spec(templ, *args):
 
 # 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):
     """
     Lookup specialization of template NODENAME corresponding to CONTAINERTYPE.
@@ -168,6 +176,7 @@ def lookup_node_type(nodename, containertype):
                     pass
         return None
 
+
 def is_member_of_namespace(typ, *namespaces):
     """
     Test whether a type is a member of one of the specified namespaces.
@@ -181,6 +190,7 @@ def is_member_of_namespace(typ, *namespaces):
             return True
     return False
 
+
 def is_specialization_of(x, template_name):
     """
     Test whether a type is a specialization of the named class template.
@@ -195,12 +205,14 @@ def is_specialization_of(x, template_name):
         return re.match('^std::(%s)?%s<.*>$' % (_versioned_namespace, template_name), x) is not None
     return re.match('^std::%s<.*>$' % template_name, x) is not None
 
+
 def strip_versioned_namespace(typename):
     global _versioned_namespace
     if _versioned_namespace:
         return typename.replace(_versioned_namespace, '')
     return typename
 
+
 def strip_inline_namespaces(type_str):
     "Remove known inline namespaces from the canonical name of a type."
     type_str = strip_versioned_namespace(type_str)
@@ -212,6 +224,7 @@ def strip_inline_namespaces(type_str):
     type_str = type_str.replace(fs_ns+'v1::', fs_ns)
     return type_str
 
+
 def get_template_arg_list(type_obj):
     "Return a type's template arguments as a list"
     n = 0
@@ -223,6 +236,7 @@ def get_template_arg_list(type_obj):
             return template_args
         n += 1
 
+
 class SmartPtrIterator(Iterator):
     "An iterator for smart pointer types with a single 'child' value"
 
@@ -238,28 +252,29 @@ class SmartPtrIterator(Iterator):
         self.val, val = None, self.val
         return ('get()', val)
 
+
 class SharedPointerPrinter:
     "Print a shared_ptr, weak_ptr, atomic<shared_ptr>, or atomic<weak_ptr>"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
         self.val = val
         self.pointer = val['_M_ptr']
 
-    def children (self):
+    def children(self):
         return SmartPtrIterator(self.pointer)
 
     # Return the _Sp_counted_base<>* that holds the refcounts.
-    def _get_refcounts (self):
+    def _get_refcounts(self):
         if self.typename == 'std::atomic':
             # A tagged pointer is stored as uintptr_t.
             ptr_val = self.val['_M_refcount']['_M_val']['_M_i']
-            ptr_val = ptr_val - (ptr_val % 2) # clear lock bit
+            ptr_val = ptr_val - (ptr_val % 2)  # clear lock bit
             ptr_type = find_type(self.val['_M_refcount'].type, 'pointer')
             return ptr_val.cast(ptr_type)
         return self.val['_M_refcount']['_M_pi']
 
-    def to_string (self):
+    def to_string(self):
         state = 'empty'
         refcounts = self._get_refcounts()
         targ = self.val.type.template_argument(0)
@@ -271,19 +286,23 @@ class SharedPointerPrinter:
             if usecount == 0:
                 state = 'expired, weak count %d' % weakcount
             else:
-                state = 'use count %d, weak count %d' % (usecount, weakcount - 1)
+                state = 'use count %d, weak count %d' % (
+                    usecount, weakcount - 1)
         return '%s<%s> (%s)' % (self.typename, targ, state)
 
+
 def _tuple_impl_get(val):
     "Return the tuple element stored in a _Tuple_impl<N, T> base class."
     bases = val.type.fields()
     if not bases[-1].is_base_class:
-        raise ValueError("Unsupported implementation for std::tuple: %s" % str(val.type))
+        raise ValueError(
+            "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))
+        raise ValueError(
+            "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']
@@ -292,7 +311,9 @@ def _tuple_impl_get(val):
         # Cast to that empty base class.
         return head_base.cast(fields[0].type)
     else:
-        raise ValueError("Unsupported implementation for std::tuple: %s" % str(val.type))
+        raise ValueError(
+            "Unsupported implementation for std::tuple: %s" % str(val.type))
+
 
 def tuple_get(n, val):
     "Return the result of std::get<n>(val) on a std::tuple"
@@ -307,6 +328,7 @@ def tuple_get(n, val):
         n -= 1
     return _tuple_impl_get(node)
 
+
 def unique_ptr_get(val):
     "Return the result of val.get() on a std::unique_ptr"
     # std::unique_ptr<T, D> contains a std::tuple<D::pointer, D>,
@@ -315,30 +337,34 @@ def unique_ptr_get(val):
     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'):
+            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))
+        raise ValueError(
+            "Unsupported implementation for unique_ptr: %s" % str(impl_type))
     return tuple_get(0, tuple_member)
 
+
 class UniquePointerPrinter:
     "Print a unique_ptr"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
 
-    def children (self):
+    def children(self):
         return SmartPtrIterator(unique_ptr_get(self.val))
 
-    def to_string (self):
+    def to_string(self):
         return ('std::unique_ptr<%s>' % (str(self.val.type.template_argument(0))))
 
+
 def get_value_from_aligned_membuf(buf, valtype):
     """Returns the value held in a __gnu_cxx::__aligned_membuf."""
     return buf['_M_storage'].address.cast(valtype.pointer()).dereference()
 
+
 def get_value_from_list_node(node):
     """Returns the value held in an _List_node<_Val>"""
     try:
@@ -354,6 +380,7 @@ def get_value_from_list_node(node):
         pass
     raise ValueError("Unsupported implementation for %s" % str(node.type))
 
+
 class StdListPrinter:
     "Print a std::list"
 
@@ -391,6 +418,7 @@ class StdListPrinter:
             return 'empty %s' % (self.typename)
         return '%s' % (self.typename)
 
+
 class NodeIteratorPrinter:
     def __init__(self, typename, val, contname, nodename):
         self.val = val
@@ -404,12 +432,14 @@ class NodeIteratorPrinter:
         node = self.val['_M_node'].cast(self.nodetype.pointer()).dereference()
         return str(get_value_from_list_node(node))
 
+
 class StdListIteratorPrinter(NodeIteratorPrinter):
     "Print std::list::iterator"
 
     def __init__(self, typename, val):
         NodeIteratorPrinter.__init__(self, typename, val, 'list', '_List_node')
 
+
 class StdFwdListIteratorPrinter(NodeIteratorPrinter):
     "Print std::forward_list::iterator"
 
@@ -417,6 +447,7 @@ class StdFwdListIteratorPrinter(NodeIteratorPrinter):
         NodeIteratorPrinter.__init__(self, typename, val, 'forward_list',
                                      '_Fwd_list_node')
 
+
 class StdSlistPrinter:
     "Print a __gnu_cxx::slist"
 
@@ -450,6 +481,7 @@ class StdSlistPrinter:
             return 'empty __gnu_cxx::slist'
         return '__gnu_cxx::slist'
 
+
 class StdSlistIteratorPrinter:
     "Print __gnu_cxx::slist::iterator"
 
@@ -459,20 +491,22 @@ class StdSlistIteratorPrinter:
     def to_string(self):
         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()
+        nodetype = lookup_node_type(
+            '__gnu_cxx::_Slist_node', self.val.type).pointer()
         return str(self.val['_M_node'].cast(nodetype).dereference()['_M_data'])
 
+
 class StdVectorPrinter:
     "Print a std::vector"
 
     class _iterator(Iterator):
-        def __init__ (self, start, finish, bitvec):
+        def __init__(self, start, finish, bitvec):
             self.bitvec = bitvec
             if bitvec:
-                self.item   = start['_M_p']
-                self.so     = 0
+                self.item = start['_M_p']
+                self.so = 0
                 self.finish = finish['_M_p']
-                self.fo     = finish['_M_offset']
+                self.fo = finish['_M_offset']
                 itype = self.item.dereference().type
                 self.isize = 8 * itype.sizeof
             else:
@@ -519,20 +553,21 @@ class StdVectorPrinter:
         if self.is_bool:
             start = self.val['_M_impl']['_M_start']['_M_p']
             finish = self.val['_M_impl']['_M_finish']['_M_p']
-            fo     = self.val['_M_impl']['_M_finish']['_M_offset']
+            fo = self.val['_M_impl']['_M_finish']['_M_offset']
             itype = start.dereference().type
             bl = 8 * itype.sizeof
-            length   = bl * (finish - start) + fo
+            length = bl * (finish - start) + fo
             capacity = bl * (end - start)
             return ('%s<bool> of length %d, capacity %d'
-                    % (self.typename, int (length), int (capacity)))
+                    % (self.typename, int(length), int(capacity)))
         else:
             return ('%s of length %d, capacity %d'
-                    % (self.typename, int (finish - start), int (end - start)))
+                    % (self.typename, int(finish - start), int(end - start)))
 
     def display_hint(self):
         return 'array'
 
+
 class StdVectorIteratorPrinter:
     "Print std::vector::iterator"
 
@@ -544,6 +579,7 @@ class StdVectorIteratorPrinter:
             return 'non-dereferenceable iterator for std::vector'
         return str(self.val['_M_current'].dereference())
 
+
 class StdBitIteratorPrinter:
     "Print std::vector<bool>'s _Bit_iterator and _Bit_const_iterator"
 
@@ -555,6 +591,7 @@ class StdBitIteratorPrinter:
             return 'non-dereferenceable iterator for std::vector<bool>'
         return bool(self.val['_M_p'].dereference() & (1 << self.val['_M_offset']))
 
+
 class StdBitReferencePrinter:
     "Print std::vector<bool>::reference"
 
@@ -566,51 +603,54 @@ class StdBitReferencePrinter:
             return 'invalid std::vector<bool>::reference'
         return bool(self.val['_M_p'].dereference() & (self.val['_M_mask']))
 
+
 class StdTuplePrinter:
     "Print a std::tuple"
 
     class _iterator(Iterator):
         @staticmethod
-        def _is_nonempty_tuple (nodes):
-            if len (nodes) == 2:
-                if is_specialization_of (nodes[1].type, '__tuple_base'):
+        def _is_nonempty_tuple(nodes):
+            if len(nodes) == 2:
+                if is_specialization_of(nodes[1].type, '__tuple_base'):
                     return True
-            elif len (nodes) == 1:
+            elif len(nodes) == 1:
                 return True
-            elif len (nodes) == 0:
+            elif len(nodes) == 0:
                 return False
-            raise ValueError("Top of tuple tree does not consist of a single node.")
+            raise ValueError(
+                "Top of tuple tree does not consist of a single node.")
 
-        def __init__ (self, head):
+        def __init__(self, head):
             self.head = head
 
             # Set the base class as the initial head of the
             # tuple.
-            nodes = self.head.type.fields ()
-            if self._is_nonempty_tuple (nodes):
+            nodes = self.head.type.fields()
+            if self._is_nonempty_tuple(nodes):
                 # Set the actual head to the first pair.
-                self.head  = self.head.cast (nodes[0].type)
+                self.head = self.head.cast(nodes[0].type)
             self.count = 0
 
-        def __iter__ (self):
+        def __iter__(self):
             return self
 
-        def __next__ (self):
+        def __next__(self):
             # Check for further recursions in the inheritance tree.
             # For a GCC 5+ tuple self.head is None after visiting all nodes:
             if not self.head:
                 raise StopIteration
-            nodes = self.head.type.fields ()
+            nodes = self.head.type.fields()
             # For a GCC 4.x tuple there is a final node with no fields:
-            if len (nodes) == 0:
+            if len(nodes) == 0:
                 raise StopIteration
             # Check that this iteration has an expected structure.
-            if len (nodes) > 2:
-                raise ValueError("Cannot parse more than 2 nodes in a tuple tree.")
+            if len(nodes) > 2:
+                raise ValueError(
+                    "Cannot parse more than 2 nodes in a tuple tree.")
 
-            if len (nodes) == 1:
+            if len(nodes) == 1:
                 # This is the last node of a GCC 5+ std::tuple.
-                impl = self.head.cast (nodes[0].type)
+                impl = self.head.cast(nodes[0].type)
                 self.head = None
             else:
                 # Either a node before the last node, or the last node of
@@ -620,53 +660,55 @@ class StdTuplePrinter:
                 # - Right node is the actual class contained in the tuple.
 
                 # Process right node.
-                impl = self.head.cast (nodes[1].type)
+                impl = self.head.cast(nodes[1].type)
 
                 # Process left node and set it as head.
-                self.head  = self.head.cast (nodes[0].type)
+                self.head = self.head.cast(nodes[0].type)
 
             self.count = self.count + 1
 
             # Finally, check the implementation.  If it is
             # wrapped in _M_head_impl return that, otherwise return
             # the value "as is".
-            fields = impl.type.fields ()
-            if len (fields) < 1 or fields[0].name != "_M_head_impl":
+            fields = impl.type.fields()
+            if len(fields) < 1 or fields[0].name != "_M_head_impl":
                 return ('[%d]' % (self.count - 1), impl)
             else:
                 return ('[%d]' % (self.count - 1), impl['_M_head_impl'])
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
-        self.val = val;
+        self.val = val
 
-    def children (self):
-        return self._iterator (self.val)
+    def children(self):
+        return self._iterator(self.val)
 
-    def to_string (self):
-        if len (self.val.type.fields ()) == 0:
+    def to_string(self):
+        if len(self.val.type.fields()) == 0:
             return 'empty %s' % (self.typename)
         return '%s containing' % (self.typename)
 
+
 class StdStackOrQueuePrinter:
     "Print a std::stack or std::queue"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
         self.visualizer = gdb.default_visualizer(val['c'])
 
-    def children (self):
+    def children(self):
         return self.visualizer.children()
 
-    def to_string (self):
+    def to_string(self):
         return '%s wrapping: %s' % (self.typename,
                                     self.visualizer.to_string())
 
-    def display_hint (self):
-        if hasattr (self.visualizer, 'display_hint'):
-            return self.visualizer.display_hint ()
+    def display_hint(self):
+        if hasattr(self.visualizer, 'display_hint'):
+            return self.visualizer.display_hint()
         return None
 
+
 class RbtreeIterator(Iterator):
     """
     Turn an RB-tree-based container (std::map, std::set etc.) into
@@ -682,7 +724,7 @@ class RbtreeIterator(Iterator):
         return self
 
     def __len__(self):
-        return int (self.size)
+        return int(self.size)
 
     def __next__(self):
         if self.count == self.size:
@@ -706,6 +748,7 @@ class RbtreeIterator(Iterator):
             self.node = node
         return result
 
+
 def get_value_from_Rb_tree_node(node):
     """Returns the value held in an _Rb_tree_node<_Val>"""
     try:
@@ -724,29 +767,32 @@ def get_value_from_Rb_tree_node(node):
 # 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.
+
+
 class StdRbtreeIteratorPrinter:
     "Print std::map::iterator, std::set::iterator, etc."
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
         nodetype = lookup_node_type('_Rb_tree_node', self.val.type)
         self.link_type = nodetype.pointer()
 
-    def to_string (self):
+    def to_string(self):
         if not self.val['_M_node']:
             return 'non-dereferenceable iterator for associative container'
         node = self.val['_M_node'].cast(self.link_type).dereference()
         return str(get_value_from_Rb_tree_node(node))
 
+
 class StdDebugIteratorPrinter:
     "Print a debug enabled version of an iterator"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
 
     # Just strip away the encapsulating __gnu_debug::_Safe_iterator
     # and return the wrapped iterator value.
-    def to_string (self):
+    def to_string(self):
         base_type = gdb.lookup_type('__gnu_debug::_Safe_iterator_base')
         itype = self.val.type.template_argument(0)
         safe_seq = self.val.cast(base_type)['_M_sequence']
@@ -756,10 +802,12 @@ class StdDebugIteratorPrinter:
             return "invalid iterator"
         return str(self.val.cast(itype))
 
+
 def num_elements(num):
     """Return either "1 element" or "N elements" depending on the argument."""
     return '1 element' if num == 1 else '%d elements' % num
 
+
 class StdMapPrinter:
     "Print a std::map or std::multimap"
 
@@ -786,21 +834,22 @@ class StdMapPrinter:
             self.count = self.count + 1
             return result
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
         self.val = val
 
-    def to_string (self):
+    def to_string(self):
         return '%s with %s' % (self.typename,
-                               num_elements(len(RbtreeIterator (self.val))))
+                               num_elements(len(RbtreeIterator(self.val))))
 
-    def children (self):
+    def children(self):
         node = lookup_node_type('_Rb_tree_node', self.val.type).pointer()
-        return self._iter (RbtreeIterator (self.val), node)
+        return self._iter(RbtreeIterator(self.val), node)
 
-    def display_hint (self):
+    def display_hint(self):
         return 'map'
 
+
 class StdSetPrinter:
     "Print a std::set or std::multiset"
 
@@ -824,17 +873,18 @@ class StdSetPrinter:
             self.count = self.count + 1
             return result
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
         self.val = val
 
-    def to_string (self):
+    def to_string(self):
         return '%s with %s' % (self.typename,
-                               num_elements(len(RbtreeIterator (self.val))))
+                               num_elements(len(RbtreeIterator(self.val))))
 
-    def children (self):
+    def children(self):
         node = lookup_node_type('_Rb_tree_node', self.val.type).pointer()
-        return self._iter (RbtreeIterator (self.val), node)
+        return self._iter(RbtreeIterator(self.val), node)
+
 
 class StdBitsetPrinter:
     "Print a std::bitset"
@@ -843,12 +893,12 @@ class StdBitsetPrinter:
         self.typename = strip_versioned_namespace(typename)
         self.val = val
 
-    def to_string (self):
+    def to_string(self):
         # If template_argument handled values, we could print the
         # size.  Or we could use a regexp on the type.
         return '%s' % (self.typename)
 
-    def children (self):
+    def children(self):
         try:
             # An empty bitset may not have any members which will
             # result in an exception being thrown.
@@ -862,7 +912,7 @@ class StdBitsetPrinter:
         # array.  This depends on the template specialization used.
         # If it is a single long, convert to a single element list.
         if wtype.code == gdb.TYPE_CODE_ARRAY:
-            tsize = wtype.target ().sizeof
+            tsize = wtype.target().sizeof
         else:
             words = [words]
             tsize = wtype.sizeof
@@ -882,6 +932,7 @@ class StdBitsetPrinter:
             byte = byte + 1
         return result
 
+
 class StdDequePrinter:
     "Print a std::deque"
 
@@ -921,7 +972,7 @@ class StdDequePrinter:
         self.elttype = val.type.template_argument(0)
         size = self.elttype.sizeof
         if size < 512:
-            self.buffer_size = int (512 / size)
+            self.buffer_size = int(512 / size)
         else:
             self.buffer_size = 1
 
@@ -943,9 +994,10 @@ class StdDequePrinter:
         return self._iter(start['_M_node'], start['_M_cur'], start['_M_last'],
                           end['_M_cur'], self.buffer_size)
 
-    def display_hint (self):
+    def display_hint(self):
         return 'array'
 
+
 class StdDequeIteratorPrinter:
     "Print std::deque::iterator"
 
@@ -957,6 +1009,7 @@ class StdDequeIteratorPrinter:
             return 'non-dereferenceable iterator for std::deque'
         return str(self.val['_M_cur'].dereference())
 
+
 class StdStringPrinter:
     "Print a std::basic_string of some kind"
 
@@ -968,28 +1021,29 @@ class StdStringPrinter:
         # Make sure &string works, too.
         type = self.val.type
         if type.code == gdb.TYPE_CODE_REF:
-            type = type.target ()
+            type = type.target()
 
         # Calculate the length of the string so that to_string returns
         # the string according to length, not according to first null
         # encountered.
-        ptr = self.val ['_M_dataplus']['_M_p']
+        ptr = self.val['_M_dataplus']['_M_p']
         if self.new_string:
             length = self.val['_M_string_length']
             # https://sourceware.org/bugzilla/show_bug.cgi?id=17728
             ptr = ptr.cast(ptr.type.strip_typedefs())
         else:
-            realtype = type.unqualified ().strip_typedefs ()
-            reptype = gdb.lookup_type (str (realtype) + '::_Rep').pointer ()
+            realtype = type.unqualified().strip_typedefs()
+            reptype = gdb.lookup_type(str(realtype) + '::_Rep').pointer()
             header = ptr.cast(reptype) - 1
-            length = header.dereference ()['_M_length']
+            length = header.dereference()['_M_length']
         if hasattr(ptr, "lazy_string"):
-            return ptr.lazy_string (length = length)
-        return ptr.string (length = length)
+            return ptr.lazy_string(length=length)
+        return ptr.string(length=length)
 
-    def display_hint (self):
+    def display_hint(self):
         return 'string'
 
+
 def access_streambuf_ptrs(streambuf):
     "Access the streambuf put area pointers"
     pbase = streambuf['_M_out_beg']
@@ -997,6 +1051,7 @@ def access_streambuf_ptrs(streambuf):
     egptr = streambuf['_M_in_end']
     return pbase, pptr, egptr
 
+
 class StdStringBufPrinter:
     "Print a std::basic_stringbuf"
 
@@ -1008,14 +1063,15 @@ class StdStringBufPrinter:
         # Logic from basic_stringbuf::_M_high_mark()
         if pptr:
             if not egptr or pptr > egptr:
-                return pbase.string(length = pptr - pbase)
+                return pbase.string(length=pptr - pbase)
             else:
-                return pbase.string(length = egptr - pbase)
+                return pbase.string(length=egptr - pbase)
         return self.val['_M_string']
 
     def display_hint(self):
         return 'string'
 
+
 class StdStringStreamPrinter:
     "Print a std::basic_stringstream"
 
@@ -1041,8 +1097,9 @@ class StdStringStreamPrinter:
             return None
         return 'string'
 
+
 class Tr1HashtableIterator(Iterator):
-    def __init__ (self, hashtable):
+    def __init__(self, hashtable):
         self.buckets = hashtable['_M_buckets']
         self.bucket = 0
         self.bucket_count = hashtable['_M_bucket_count']
@@ -1054,15 +1111,15 @@ class Tr1HashtableIterator(Iterator):
                 break
             self.bucket = self.bucket + 1
 
-    def __iter__ (self):
+    def __iter__(self):
         return self
 
-    def __next__ (self):
+    def __next__(self):
         if self.node == 0:
             raise StopIteration
         node = self.node.cast(self.node_type)
         result = node.dereference()['_M_v']
-        self.node = node.dereference()['_M_next'];
+        self.node = node.dereference()['_M_next']
         if self.node == 0:
             self.bucket = self.bucket + 1
             while self.bucket != self.bucket_count:
@@ -1072,6 +1129,7 @@ class Tr1HashtableIterator(Iterator):
                 self.bucket = self.bucket + 1
         return result
 
+
 class StdHashtableIterator(Iterator):
     def __init__(self, hashtable):
         self.node = hashtable['_M_before_begin']['_M_nxt']
@@ -1093,76 +1151,81 @@ class StdHashtableIterator(Iterator):
         valptr = valptr.cast(elt.type.template_argument(0).pointer())
         return valptr.dereference()
 
+
 class Tr1UnorderedSetPrinter:
     "Print a std::unordered_set or tr1::unordered_set"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
         self.val = val
 
-    def hashtable (self):
+    def hashtable(self):
         if self.typename.startswith('std::tr1'):
             return self.val
         return self.val['_M_h']
 
-    def to_string (self):
+    def to_string(self):
         count = self.hashtable()['_M_element_count']
         return '%s with %s' % (self.typename, num_elements(count))
 
     @staticmethod
-    def format_count (i):
+    def format_count(i):
         return '[%d]' % i
 
-    def children (self):
-        counter = imap (self.format_count, itertools.count())
+    def children(self):
+        counter = imap(self.format_count, itertools.count())
         if self.typename.startswith('std::tr1'):
-            return izip (counter, Tr1HashtableIterator (self.hashtable()))
-        return izip (counter, StdHashtableIterator (self.hashtable()))
+            return izip(counter, Tr1HashtableIterator(self.hashtable()))
+        return izip(counter, StdHashtableIterator(self.hashtable()))
+
 
 class Tr1UnorderedMapPrinter:
     "Print a std::unordered_map or tr1::unordered_map"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
         self.val = val
 
-    def hashtable (self):
+    def hashtable(self):
         if self.typename.startswith('std::tr1'):
             return self.val
         return self.val['_M_h']
 
-    def to_string (self):
+    def to_string(self):
         count = self.hashtable()['_M_element_count']
         return '%s with %s' % (self.typename, num_elements(count))
 
     @staticmethod
-    def flatten (list):
+    def flatten(list):
         for elt in list:
             for i in elt:
                 yield i
 
     @staticmethod
-    def format_one (elt):
+    def format_one(elt):
         return (elt['first'], elt['second'])
 
     @staticmethod
-    def format_count (i):
+    def format_count(i):
         return '[%d]' % i
 
-    def children (self):
-        counter = imap (self.format_count, itertools.count())
+    def children(self):
+        counter = imap(self.format_count, itertools.count())
         # 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())))
+            data = self.flatten(
+                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())))
+            return izip(counter, data)
+        data = self.flatten(
+            imap(self.format_one, StdHashtableIterator(self.hashtable())))
         # Zip the two iterators together.
-        return izip (counter, data)
+        return izip(counter, data)
 
-    def display_hint (self):
+    def display_hint(self):
         return 'map'
 
+
 class StdForwardListPrinter:
     "Print a std::forward_list"
 
@@ -1199,10 +1262,11 @@ class StdForwardListPrinter:
             return 'empty %s' % self.typename
         return '%s' % self.typename
 
+
 class SingleObjContainerPrinter(object):
     "Base class for printers of containers of single objects"
 
-    def __init__ (self, val, viz, hint = None):
+    def __init__(self, val, viz, hint=None):
         self.contained_value = val
         self.visualizer = viz
         self.hint = hint
@@ -1216,10 +1280,10 @@ class SingleObjContainerPrinter(object):
                                                 type) or str(type)
 
     class _contained(Iterator):
-        def __init__ (self, val):
+        def __init__(self, val):
             self.val = val
 
-        def __iter__ (self):
+        def __iter__(self):
             return self
 
         def __next__(self):
@@ -1229,19 +1293,20 @@ class SingleObjContainerPrinter(object):
             self.val = None
             return ('[contained value]', retval)
 
-    def children (self):
+    def children(self):
         if self.contained_value is None:
-            return self._contained (None)
-        if hasattr (self.visualizer, 'children'):
-            return self.visualizer.children ()
-        return self._contained (self.contained_value)
+            return self._contained(None)
+        if hasattr(self.visualizer, 'children'):
+            return self.visualizer.children()
+        return self._contained(self.contained_value)
 
-    def display_hint (self):
+    def display_hint(self):
         # if contained value is a map we want to display in the same way
-        if hasattr (self.visualizer, 'children') and hasattr (self.visualizer, 'display_hint'):
-            return self.visualizer.display_hint ()
+        if hasattr(self.visualizer, 'children') and hasattr(self.visualizer, 'display_hint'):
+            return self.visualizer.display_hint()
         return self.hint
 
+
 def function_pointer_to_name(f):
     "Find the name of the function referred to by the gdb.Value f, "
     " which should contain a function pointer from the program."
@@ -1265,12 +1330,14 @@ def function_pointer_to_name(f):
     except:
         return None
 
+
 class StdExpAnyPrinter(SingleObjContainerPrinter):
     "Print a std::any or std::experimental::any"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = strip_versioned_namespace(typename)
-        self.typename = re.sub('^std::experimental::fundamentals_v\d::', 'std::experimental::', self.typename, 1)
+        self.typename = re.sub(
+            '^std::experimental::fundamentals_v\d::', 'std::experimental::', self.typename, 1)
         self.val = val
         self.contained_type = None
         contained_value = None
@@ -1279,11 +1346,13 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
         if mgr != 0:
             func = function_pointer_to_name(mgr)
             if not func:
-                raise ValueError("Invalid function pointer in %s" % (self.typename))
+                raise ValueError(
+                    "Invalid function pointer in %s" % (self.typename))
             rx = r"""({0}::_Manager_\w+<.*>)::_S_manage\((enum )?{0}::_Op, (const {0}|{0} const) ?\*, (union )?{0}::_Arg ?\*\)""".format(typename)
             m = re.match(rx, func)
             if not m:
-                raise ValueError("Unknown manager function in %s" % self.typename)
+                raise ValueError(
+                    "Unknown manager function in %s" % self.typename)
 
             mgrname = m.group(1)
             # FIXME need to expand 'std::string' so that gdb.lookup_type works
@@ -1291,11 +1360,13 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
                 # This lookup for std::string might return the __cxx11 version,
                 # but that's not necessarily the one used by the std::any
                 # manager function we're trying to find.
-                strings = {str(gdb.lookup_type('std::string').strip_typedefs())}
+                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]
-                strings |= {q+s for q in quals} # set of unique strings
+                quals = ['std::', 'std::__cxx11::',
+                         'std::' + _versioned_namespace]
+                strings |= {q+s for q in quals}  # set of unique strings
                 mgrtypes = []
                 for s in strings:
                     try:
@@ -1312,7 +1383,8 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
                     # std::any in a single program. Can we do better?
                     # Maybe find the address of each type's _S_manage and
                     # compare to the address stored in _M_manager?
-                    raise ValueError('Cannot uniquely determine std::string type used in std::any')
+                    raise ValueError(
+                        'Cannot uniquely determine std::string type used in std::any')
                 mgrtype = mgrtypes[0]
             else:
                 mgrtype = gdb.lookup_type(mgrname)
@@ -1323,27 +1395,31 @@ class StdExpAnyPrinter(SingleObjContainerPrinter):
             elif '::_Manager_external' in mgrname:
                 valptr = self.val['_M_storage']['_M_ptr']
             else:
-                raise ValueError("Unknown manager function in %s" % self.typename)
-            contained_value = valptr.cast(self.contained_type.pointer()).dereference()
+                raise ValueError(
+                    "Unknown manager function in %s" % self.typename)
+            contained_value = valptr.cast(
+                self.contained_type.pointer()).dereference()
             visualizer = gdb.default_visualizer(contained_value)
-        super(StdExpAnyPrinter, self).__init__ (contained_value, visualizer)
+        super(StdExpAnyPrinter, self).__init__(contained_value, visualizer)
 
-    def to_string (self):
+    def to_string(self):
         if self.contained_type is None:
             return '%s [no contained value]' % self.typename
         desc = "%s containing " % self.typename
-        if hasattr (self.visualizer, 'children'):
-            return desc + self.visualizer.to_string ()
-        valtype = self._recognize (self.contained_type)
+        if hasattr(self.visualizer, 'children'):
+            return desc + self.visualizer.to_string()
+        valtype = self._recognize(self.contained_type)
         return desc + strip_versioned_namespace(str(valtype))
 
+
 class StdExpOptionalPrinter(SingleObjContainerPrinter):
     "Print a std::optional or std::experimental::optional"
 
-    def __init__ (self, typename, val):
-        valtype = self._recognize (val.type.template_argument(0))
+    def __init__(self, typename, val):
+        valtype = self._recognize(val.type.template_argument(0))
         typename = strip_versioned_namespace(typename)
-        self.typename = re.sub('^std::(experimental::|)(fundamentals_v\d::|)(.*)', r'std::\1\3', typename, 1)
+        self.typename = re.sub(
+            '^std::(experimental::|)(fundamentals_v\d::|)(.*)', r'std::\1\3', typename, 1)
         payload = val['_M_payload']
         if self.typename.startswith('std::experimental'):
             engaged = val['_M_engaged']
@@ -1356,19 +1432,21 @@ class StdExpOptionalPrinter(SingleObjContainerPrinter):
                 contained_value = contained_value['_M_value']
             except:
                 pass
-        visualizer = gdb.default_visualizer (contained_value)
+        visualizer = gdb.default_visualizer(contained_value)
         if not engaged:
             contained_value = None
-        super (StdExpOptionalPrinter, self).__init__ (contained_value, visualizer)
+        super(StdExpOptionalPrinter, self).__init__(
+            contained_value, visualizer)
 
-    def to_string (self):
+    def to_string(self):
         if self.contained_value is None:
             return "%s [no contained value]" % self.typename
-        if hasattr (self.visualizer, 'children'):
+        if hasattr(self.visualizer, 'children'):
             return "%s containing %s" % (self.typename,
                                          self.visualizer.to_string())
         return self.typename
 
+
 class StdVariantPrinter(SingleObjContainerPrinter):
     "Print a std::variant"
 
@@ -1383,9 +1461,11 @@ class StdVariantPrinter(SingleObjContainerPrinter):
         else:
             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()
+            contained_value = addr.cast(
+                self.contained_type.pointer()).dereference()
             visualizer = gdb.default_visualizer(contained_value)
-        super (StdVariantPrinter, self).__init__(contained_value, visualizer, 'array')
+        super(StdVariantPrinter, self).__init__(
+            contained_value, visualizer, 'array')
 
     def to_string(self):
         if self.contained_value is None:
@@ -1395,18 +1475,21 @@ class StdVariantPrinter(SingleObjContainerPrinter):
                                                     self.visualizer.to_string())
         return "%s [index %d]" % (self.typename, self.index)
 
+
 class StdNodeHandlePrinter(SingleObjContainerPrinter):
     "Print a container node handle"
 
     def __init__(self, typename, val):
         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')
+        self.is_rb_tree_node = is_specialization_of(
+            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())
+                contained_value = get_value_from_Rb_tree_node(
+                    nodeptr.dereference())
             else:
                 contained_value = get_value_from_aligned_membuf(nodeptr['_M_storage'],
                                                                 self.value_type)
@@ -1424,9 +1507,9 @@ class StdNodeHandlePrinter(SingleObjContainerPrinter):
         if not self.is_rb_tree_node:
             desc += 'unordered '
         if self.is_map_node:
-            desc += 'map';
+            desc += 'map'
         else:
-            desc += 'set';
+            desc += 'set'
 
         if self.contained_value:
             desc += ' with element'
@@ -1436,31 +1519,33 @@ class StdNodeHandlePrinter(SingleObjContainerPrinter):
         else:
             return 'empty %s' % desc
 
+
 class StdExpStringViewPrinter:
     "Print a std::basic_string_view or std::experimental::basic_string_view"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
 
-    def to_string (self):
+    def to_string(self):
         ptr = self.val['_M_str']
         len = self.val['_M_len']
-        if hasattr (ptr, "lazy_string"):
-            return ptr.lazy_string (length = len)
-        return ptr.string (length = len)
+        if hasattr(ptr, "lazy_string"):
+            return ptr.lazy_string(length=len)
+        return ptr.string(length=len)
 
-    def display_hint (self):
+    def display_hint(self):
         return 'string'
 
+
 class StdExpPathPrinter:
     "Print a std::experimental::filesystem::path"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
         self.typename = typename
         start = self.val['_M_cmpts']['_M_impl']['_M_start']
         finish = self.val['_M_cmpts']['_M_impl']['_M_finish']
-        self.num_cmpts = int (finish - start)
+        self.num_cmpts = int(finish - start)
 
     def _path_type(self):
         t = str(self.val['_M_type'])
@@ -1470,8 +1555,8 @@ class StdExpPathPrinter:
             return "root-name"
         return None
 
-    def to_string (self):
-        path = "%s" % self.val ['_M_pathname']
+    def to_string(self):
+        path = "%s" % self.val['_M_pathname']
         if self.num_cmpts == 0:
             t = self._path_type()
             if t:
@@ -1504,10 +1589,11 @@ class StdExpPathPrinter:
     def children(self):
         return self._iterator(self.val['_M_cmpts'], self.typename)
 
+
 class StdPathPrinter:
     "Print a std::filesystem::path"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
         self.typename = typename
         impl = unique_ptr_get(self.val['_M_cmpts']['_M_impl'])
@@ -1525,8 +1611,8 @@ class StdPathPrinter:
             return "root-name"
         return None
 
-    def to_string (self):
-        path = "%s" % self.val ['_M_pathname']
+    def to_string(self):
+        path = "%s" % self.val['_M_pathname']
         if self.type != 0:
             t = self._path_type()
             if t:
@@ -1609,27 +1695,29 @@ class StdPairPrinter:
     def to_string(self):
         return None
 
+
 class StdCmpCatPrinter:
     "Print a comparison category object"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.typename = typename[typename.rfind(':')+1:]
         self.val = val['_M_value']
 
-    def to_string (self):
+    def to_string(self):
         if self.typename == 'strong_ordering' and self.val == 0:
             name = 'equal'
         else:
-            names = {2:'unordered', -1:'less', 0:'equivalent', 1:'greater'}
+            names = {2: 'unordered', -1: 'less', 0: 'equivalent', 1: 'greater'}
             name = names[int(self.val)]
         return 'std::{}::{}'.format(self.typename, name)
 
+
 class StdErrorCodePrinter:
     "Print a std::error_code or std::error_condition"
 
     _system_is_posix = None  # Whether std::system_category() use errno values.
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
         self.typename = strip_versioned_namespace(typename)
         # Do this only once ...
@@ -1718,15 +1806,15 @@ class StdErrorCodePrinter:
         "Strip any nested-name-specifier from NAME to give an unqualified name"
         return name.split('::')[-1]
 
-    def to_string (self):
+    def to_string(self):
         value = self.val['_M_value']
         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
+                return self.typename + ' = { }'  # default-constructed value
 
         strval = str(value)
         if is_errno and value != 0:
@@ -1747,24 +1835,24 @@ class StdErrorCodePrinter:
 class StdRegexStatePrinter:
     "Print a state node in the NFA for a std::regex"
 
-    def __init__ (self, typename, val):
+    def __init__(self, typename, val):
         self.val = val
         self.typename = typename
 
-    def to_string (self):
+    def to_string(self):
         opcode = str(self.val['_M_opcode'])
         if opcode:
             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)
@@ -1772,6 +1860,7 @@ class StdRegexStatePrinter:
             s = "{}, {}={}".format(s, v, self.val['_M_' + v])
         return "{%s}" % (s)
 
+
 class StdSpanPrinter:
     "Print a std::span"
 
@@ -1781,10 +1870,10 @@ class StdSpanPrinter:
             self.begin = begin
             self.size = size
 
-        def __iter__ (self):
+        def __iter__(self):
             return self
 
-        def __next__ (self):
+        def __next__(self):
             if self.count == self.size:
                 raise StopIteration
 
@@ -1809,6 +1898,7 @@ class StdSpanPrinter:
     def display_hint(self):
         return 'array'
 
+
 class StdInitializerListPrinter:
     "Print a std::initializer_list"
 
@@ -1826,6 +1916,7 @@ class StdInitializerListPrinter:
     def display_hint(self):
         return 'array'
 
+
 class StdAtomicPrinter:
     "Print a std:atomic"
 
@@ -1860,6 +1951,7 @@ class StdAtomicPrinter:
             val = self.val['_M_i']
         return '%s<%s> = { %s }' % (self.typename, str(self.value_type), val)
 
+
 class StdFormatArgsPrinter:
     "Print a std::basic_format_args"
     # TODO: add printer for basic_format_arg<Context> and print out children.
@@ -1886,6 +1978,7 @@ class StdFormatArgsPrinter:
             size = self.val['_M_unpacked_size']
         return "%s with %d arguments" % (typ, size)
 
+
 def std_ratio_t_tuple(ratio_type):
     # TODO use reduced period i.e. duration::period
     period = self.val.type.template_argument(1)
@@ -1893,6 +1986,7 @@ def std_ratio_t_tuple(ratio_type):
     den = period.template_argument(1)
     return (num, den)
 
+
 class StdChronoDurationPrinter:
     "Print a std::chrono::duration"
 
@@ -1950,18 +2044,18 @@ class StdChronoTimePointPrinter:
             return ('std::chrono::sys_time', 0)
         # XXX need to remove leap seconds from utc, gps, and tai
         if name == 'std::chrono::utc_clock':
-            return ('std::chrono::utc_time', None) # XXX
+            return ('std::chrono::utc_time', None)  # XXX
         if name == 'std::chrono::gps_clock':
-            return ('std::chrono::gps_time', None) # XXX 315964809
+            return ('std::chrono::gps_time', None)  # XXX 315964809
         if name == 'std::chrono::tai_clock':
-            return ('std::chrono::tai_time', None) # XXX -378691210
+            return ('std::chrono::tai_time', None)  # XXX -378691210
         if name == 'std::filesystem::__file_clock':
             return ('std::chrono::file_time', 6437664000)
         if name == 'std::chrono::local_t':
             return ('std::chrono::local_time', 0)
         return ('{} time_point'.format(name), None)
 
-    def to_string(self, abbrev = False):
+    def to_string(self, abbrev=False):
         clock, offset = self._clock()
         d = self.val['__d']
         r = d['__r']
@@ -1981,6 +2075,7 @@ class StdChronoTimePointPrinter:
             return s
         return '%s = { %s }' % (clock, s)
 
+
 class StdChronoZonedTimePrinter:
     "Print a std::chrono::zoned_time"
 
@@ -2002,6 +2097,7 @@ months = [None, 'January', 'February', 'March', 'April', 'May', 'June',
 weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday',
             'Saturday', 'Sunday']
 
+
 class StdChronoCalendarPrinter:
     "Print a std::chrono::day, std::chrono::month, std::chrono::year etc."
 
@@ -2064,6 +2160,7 @@ class StdChronoCalendarPrinter:
                 h = -h
             return '{:02}:{:02}:{:02}{}'.format(h, m, s, fract)
 
+
 class StdChronoTimeZonePrinter:
     "Print a chrono::time_zone or chrono::time_zone_link"
 
@@ -2077,6 +2174,7 @@ class StdChronoTimeZonePrinter:
             str += ' -> %s' % (self.val['_M_target'])
         return str
 
+
 class StdChronoLeapSecondPrinter:
     "Print a chrono::leap_second"
 
@@ -2089,6 +2187,7 @@ class StdChronoLeapSecondPrinter:
         neg = '+-'[date < 0]
         return '%s %d (%c)' % (self.typename, abs(date), neg)
 
+
 class StdChronoTzdbPrinter:
     "Print a chrono::tzdb"
 
@@ -2099,6 +2198,7 @@ class StdChronoTzdbPrinter:
     def to_string(self):
         return '%s %s' % (self.typename, self.val['version'])
 
+
 class StdChronoTimeZoneRulePrinter:
     "Print a chrono::time_zone rule"
 
@@ -2110,17 +2210,18 @@ class StdChronoTimeZoneRulePrinter:
         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
-                start = '{} {}{}'.format(month, ordinal_day)
+        if kind == 0:  # DayOfMonth
+            start = '{} {}{}'.format(month, ordinal_day)
         else:
             weekday = weekdays[on['day_of_week']]
-            if kind == 1: # LastWeekDay
+            if kind == 1:  # LastWeekDay
                 start = 'last {} in {}'.format(weekday, month)
             else:
-                if kind == 2: # LessEq
+                if kind == 2:  # LessEq
                     direction = ('last', '<=')
                 else:
                     direction = ('first', '>=')
@@ -2129,7 +2230,8 @@ class StdChronoTimeZoneRulePrinter:
                                                 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:
     "Print a std::locale"
@@ -2146,7 +2248,7 @@ class StdLocalePrinter:
         else:
             cats = gdb.parse_and_eval(self.typename + '::_S_categories')
             ncat = gdb.parse_and_eval(self.typename + '::_S_categories_size')
-            n = names[0].string();
+            n = names[0].string()
             cat = cats[0].string()
             name = '{}={}'.format(cat, n)
             cat_names = {cat: n}
@@ -2171,7 +2273,7 @@ class StdLocalePrinter:
                     name = n1
                     other = n2
                 if other is not None:
-                    cat = next(c for c,n in cat_names.items() if n == other)
+                    cat = next(c for c, n in cat_names.items() if n == other)
                     mod = ' with "{}={}"'.format(cat, other)
         return 'std::locale = "{}"{}'.format(name, mod)
 
@@ -2190,13 +2292,15 @@ class RxPrinter(object):
             return None
 
         if value.type.code == gdb.TYPE_CODE_REF:
-            if hasattr(gdb.Value,"referenced_value"):
+            if hasattr(gdb.Value, "referenced_value"):
                 value = value.referenced_value()
 
         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.
+
+
 class Printer(object):
     def __init__(self, name):
         super(Printer, self).__init__()
@@ -2210,7 +2314,8 @@ class Printer(object):
         # A small sanity check.
         # FIXME
         if not self.compiled_rx.match(name):
-            raise ValueError('libstdc++ programming error: "%s" does not match' % name)
+            raise ValueError(
+                'libstdc++ programming error: "%s" does not match' % name)
         printer = RxPrinter(name, function)
         self.subprinters.append(printer)
         self.lookup[name] = printer
@@ -2219,7 +2324,8 @@ class Printer(object):
     def add_version(self, base, name, function):
         self.add(base + name, function)
         if _versioned_namespace and not '__cxx11' 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.
@@ -2231,10 +2337,10 @@ class Printer(object):
     def get_basic_type(type):
         # If it points to a reference, get the reference.
         if type.code == gdb.TYPE_CODE_REF:
-            type = type.target ()
+            type = type.target()
 
         # Get the unqualified type, stripped of typedefs.
-        type = type.unqualified ().strip_typedefs ()
+        type = type.unqualified().strip_typedefs()
 
         return type.tag
 
@@ -2252,7 +2358,7 @@ class Printer(object):
         basename = match.group(1)
 
         if val.type.code == gdb.TYPE_CODE_REF:
-            if hasattr(gdb.Value,"referenced_value"):
+            if hasattr(gdb.Value, "referenced_value"):
                 val = val.referenced_value()
 
         if basename in self.lookup:
@@ -2261,8 +2367,10 @@ class Printer(object):
         # Cannot find a pretty printer.  Return None.
         return None
 
+
 libstdcxx_printer = None
 
+
 class TemplateTypePrinter(object):
     r"""
     A type printer for class templates with default template arguments.
@@ -2345,7 +2453,7 @@ class TemplateTypePrinter(object):
             if type_obj.code == gdb.TYPE_CODE_ARRAY:
                 type_str = self._recognize_subtype(type_obj.target())
                 if str(type_obj.strip_typedefs()).endswith('[]'):
-                    return type_str + '[]' # array of unknown bound
+                    return type_str + '[]'  # array of unknown bound
                 return "%s[%d]" % (type_str, type_obj.range()[1] + 1)
             if type_obj.code == gdb.TYPE_CODE_REF:
                 return self._recognize_subtype(type_obj.target()) + '&'
@@ -2354,7 +2462,7 @@ 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)
@@ -2363,6 +2471,7 @@ class TemplateTypePrinter(object):
         "Return a recognizer object for this type printer."
         return self._recognizer(self.name, self.defargs)
 
+
 def add_one_template_type_printer(obj, name, defargs):
     r"""
     Add a type printer for a class template with default template arguments.
@@ -2391,7 +2500,8 @@ 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)
 
@@ -2399,6 +2509,7 @@ def add_one_template_type_printer(obj, name, defargs):
         printer = TemplateTypePrinter('std::__debug::'+name, defargs)
         gdb.types.register_type_printer(obj, printer)
 
+
 class FilteringTypePrinter(object):
     r"""
     A type printer that uses typedef names for common template specializations.
@@ -2421,7 +2532,7 @@ class FilteringTypePrinter(object):
     more quickly, without needing to do GDB type lookups.
     """
 
-    def __init__(self, template, name, targ1 = None):
+    def __init__(self, template, name, targ1=None):
         self.template = template
         self.name = name
         self.targ1 = targ1
@@ -2475,7 +2586,8 @@ class FilteringTypePrinter(object):
         "Return a recognizer object for this type printer."
         return self._recognizer(self.template, self.name, self.targ1)
 
-def add_one_type_printer(obj, template, name, targ1 = None):
+
+def add_one_type_printer(obj, template, name, targ1=None):
     printer = FilteringTypePrinter('std::' + template, 'std::' + name, targ1)
     gdb.types.register_type_printer(obj, printer)
     if _versioned_namespace and not '__cxx11' in template:
@@ -2483,6 +2595,7 @@ def add_one_type_printer(obj, template, name, targ1 = None):
         printer = FilteringTypePrinter(ns + template, ns + name, targ1)
         gdb.types.register_type_printer(obj, printer)
 
+
 def register_type_printers(obj):
     global _use_type_printing
 
@@ -2496,11 +2609,13 @@ def register_type_printers(obj):
                ('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, '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')):
@@ -2516,9 +2631,11 @@ 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')
+            add_one_type_printer(
+                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)
 
@@ -2554,40 +2671,43 @@ def register_type_printers(obj):
 
     # 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, 'deque', { 1: 'std::allocator<{0}>'})
-    add_one_template_type_printer(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}>'})
-    add_one_template_type_printer(obj, 'vector', { 1: 'std::allocator<{0}>'})
+                                  {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}>'})
+    add_one_template_type_printer(obj, 'list', {1: 'std::allocator<{0}>'})
+    add_one_template_type_printer(
+        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}>>' })
+                                  {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}>>' })
+                                  {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}>' })
+                                  {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'})
     add_one_template_type_printer(obj, 'multiset',
-            { 1: 'std::less<{0}>', 2: 'std::allocator<{0}>' })
+                                  {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}>>'})
+                                  {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}>>'})
+                                  {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}>'})
+                                  {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}>'})
+                                  {1: 'std::hash<{0}>',
+                                   2: 'std::equal_to<{0}>',
+                                   3: 'std::allocator<{0}>'})
 
-def register_libstdcxx_printers (obj):
+
+def register_libstdcxx_printers(obj):
     "Register libstdc++ pretty-printers with objfile Obj."
 
     global _use_gdb_pp
@@ -2602,7 +2722,8 @@ def register_libstdcxx_printers (obj):
 
     register_type_printers(obj)
 
-def build_libstdcxx_dictionary ():
+
+def build_libstdcxx_dictionary():
     global libstdcxx_printer
 
     libstdcxx_printer = Printer("libstdc++-v6")
@@ -2611,7 +2732,8 @@ def build_libstdcxx_dictionary ():
     # In order from:
     # 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)
+    libstdcxx_printer.add_version(
+        '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)
@@ -2662,8 +2784,10 @@ def build_libstdcxx_dictionary ():
     libstdcxx_printer.add_container('std::', 'forward_list',
                                     StdForwardListPrinter)
 
-    libstdcxx_printer.add_version('std::tr1::', 'shared_ptr', SharedPointerPrinter)
-    libstdcxx_printer.add_version('std::tr1::', 'weak_ptr', SharedPointerPrinter)
+    libstdcxx_printer.add_version(
+        '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',
@@ -2676,11 +2800,15 @@ def build_libstdcxx_dictionary ():
     libstdcxx_printer.add_version('std::', 'initializer_list',
                                   StdInitializerListPrinter)
     libstdcxx_printer.add_version('std::', 'atomic', StdAtomicPrinter)
-    libstdcxx_printer.add_version('std::', 'basic_stringbuf', StdStringBufPrinter)
-    libstdcxx_printer.add_version('std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter)
+    libstdcxx_printer.add_version(
+        'std::', 'basic_stringbuf', StdStringBufPrinter)
+    libstdcxx_printer.add_version(
+        'std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter)
     for sstream in ('istringstream', 'ostringstream', 'stringstream'):
-        libstdcxx_printer.add_version('std::', 'basic_' + sstream, StdStringStreamPrinter)
-        libstdcxx_printer.add_version('std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter)
+        libstdcxx_printer.add_version(
+            'std::', 'basic_' + sstream, StdStringStreamPrinter)
+        libstdcxx_printer.add_version(
+            'std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter)
 
     libstdcxx_printer.add_version('std::chrono::', 'duration',
                                   StdChronoDurationPrinter)
@@ -2735,16 +2863,17 @@ def build_libstdcxx_dictionary ():
                                   '_Node_handle', StdNodeHandlePrinter)
 
     # C++20 components
-    libstdcxx_printer.add_version('std::', 'partial_ordering', StdCmpCatPrinter)
+    libstdcxx_printer.add_version(
+        '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']:
+    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',
@@ -2755,8 +2884,9 @@ def build_libstdcxx_dictionary ():
                                   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',
+    libstdcxx_printer.add_version(
+        'std::chrono::', 'tzdb', StdChronoTzdbPrinter)
+    # libstdcxx_printer.add_version('std::chrono::(anonymous namespace)', 'Rule',
     #                              StdChronoTimeZoneRulePrinter)
 
     # Extensions.
@@ -2780,11 +2910,11 @@ def build_libstdcxx_dictionary ():
         libstdcxx_printer.add_version('__gnu_cxx::', '__normal_iterator',
                                       StdVectorIteratorPrinter)
         libstdcxx_printer.add_container('std::', '_Bit_iterator',
-                                      StdBitIteratorPrinter)
+                                        StdBitIteratorPrinter)
         libstdcxx_printer.add_container('std::', '_Bit_const_iterator',
-                                      StdBitIteratorPrinter)
+                                        StdBitIteratorPrinter)
         libstdcxx_printer.add_container('std::', '_Bit_reference',
-                                      StdBitReferencePrinter)
+                                        StdBitReferencePrinter)
         libstdcxx_printer.add_version('__gnu_cxx::', '_Slist_iterator',
                                       StdSlistIteratorPrinter)
         libstdcxx_printer.add_container('std::', '_Fwd_list_iterator',
@@ -2797,4 +2927,5 @@ def build_libstdcxx_dictionary ():
         libstdcxx_printer.add('__gnu_debug::_Safe_iterator',
                               StdDebugIteratorPrinter)
 
-build_libstdcxx_dictionary ()
+
+build_libstdcxx_dictionary()
diff --git a/libstdc++-v3/python/libstdcxx/v6/xmethods.py b/libstdc++-v3/python/libstdcxx/v6/xmethods.py
index 18a165f425e..025b1b86ed0 100644
--- a/libstdc++-v3/python/libstdcxx/v6/xmethods.py
+++ b/libstdc++-v3/python/libstdcxx/v6/xmethods.py
@@ -21,12 +21,15 @@ import re
 
 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')
 
+
 class LibStdCxxXMethod(gdb.xmethod.XMethod):
     def __init__(self, name, worker_class):
         gdb.xmethod.XMethod.__init__(self, name)
@@ -34,6 +37,7 @@ class LibStdCxxXMethod(gdb.xmethod.XMethod):
 
 # Xmethods for std::array
 
+
 class ArrayWorkerBase(gdb.xmethod.XMethodWorker):
     def __init__(self, val_type, size):
         self._val_type = val_type
@@ -43,6 +47,7 @@ class ArrayWorkerBase(gdb.xmethod.XMethodWorker):
         nullptr = gdb.parse_and_eval('(void *) 0')
         return nullptr.cast(self._val_type.pointer()).dereference()
 
+
 class ArraySizeWorker(ArrayWorkerBase):
     def __init__(self, val_type, size):
         ArrayWorkerBase.__init__(self, val_type, size)
@@ -56,6 +61,7 @@ class ArraySizeWorker(ArrayWorkerBase):
     def __call__(self, obj):
         return self._size
 
+
 class ArrayEmptyWorker(ArrayWorkerBase):
     def __init__(self, val_type, size):
         ArrayWorkerBase.__init__(self, val_type, size)
@@ -69,6 +75,7 @@ class ArrayEmptyWorker(ArrayWorkerBase):
     def __call__(self, obj):
         return (int(self._size) == 0)
 
+
 class ArrayFrontWorker(ArrayWorkerBase):
     def __init__(self, val_type, size):
         ArrayWorkerBase.__init__(self, val_type, size)
@@ -85,6 +92,7 @@ class ArrayFrontWorker(ArrayWorkerBase):
         else:
             return self.null_value()
 
+
 class ArrayBackWorker(ArrayWorkerBase):
     def __init__(self, val_type, size):
         ArrayWorkerBase.__init__(self, val_type, size)
@@ -101,6 +109,7 @@ class ArrayBackWorker(ArrayWorkerBase):
         else:
             return self.null_value()
 
+
 class ArrayAtWorker(ArrayWorkerBase):
     def __init__(self, val_type, size):
         ArrayWorkerBase.__init__(self, val_type, size)
@@ -117,6 +126,7 @@ class ArrayAtWorker(ArrayWorkerBase):
                              ((int(index), self._size)))
         return obj['_M_elems'][index]
 
+
 class ArraySubscriptWorker(ArrayWorkerBase):
     def __init__(self, val_type, size):
         ArrayWorkerBase.__init__(self, val_type, size)
@@ -133,6 +143,7 @@ class ArraySubscriptWorker(ArrayWorkerBase):
         else:
             return self.null_value()
 
+
 class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
         gdb.xmethod.XMethodMatcher.__init__(self,
@@ -162,6 +173,7 @@ class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for std::deque
 
+
 class DequeWorkerBase(gdb.xmethod.XMethodWorker):
     def __init__(self, val_type):
         self._val_type = val_type
@@ -179,6 +191,7 @@ class DequeWorkerBase(gdb.xmethod.XMethodWorker):
         index_node = first_node + int(idx) // self._bufsize
         return index_node[0][idx % self._bufsize]
 
+
 class DequeEmptyWorker(DequeWorkerBase):
     def get_arg_types(self):
         return None
@@ -190,6 +203,7 @@ class DequeEmptyWorker(DequeWorkerBase):
         return (obj['_M_impl']['_M_start']['_M_cur'] ==
                 obj['_M_impl']['_M_finish']['_M_cur'])
 
+
 class DequeSizeWorker(DequeWorkerBase):
     def get_arg_types(self):
         return None
@@ -200,6 +214,7 @@ class DequeSizeWorker(DequeWorkerBase):
     def __call__(self, obj):
         return self.size(obj)
 
+
 class DequeFrontWorker(DequeWorkerBase):
     def get_arg_types(self):
         return None
@@ -210,6 +225,7 @@ class DequeFrontWorker(DequeWorkerBase):
     def __call__(self, obj):
         return obj['_M_impl']['_M_start']['_M_cur'][0]
 
+
 class DequeBackWorker(DequeWorkerBase):
     def get_arg_types(self):
         return None
@@ -219,12 +235,13 @@ class DequeBackWorker(DequeWorkerBase):
 
     def __call__(self, obj):
         if (obj['_M_impl']['_M_finish']['_M_cur'] ==
-            obj['_M_impl']['_M_finish']['_M_first']):
+                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:
             return obj['_M_impl']['_M_finish']['_M_cur'][-1]
 
+
 class DequeSubscriptWorker(DequeWorkerBase):
     def get_arg_types(self):
         return get_std_size_type()
@@ -235,6 +252,7 @@ class DequeSubscriptWorker(DequeWorkerBase):
     def __call__(self, obj, subscript):
         return self.index(obj, subscript)
 
+
 class DequeAtWorker(DequeWorkerBase):
     def get_arg_types(self):
         return get_std_size_type()
@@ -248,7 +266,8 @@ class DequeAtWorker(DequeWorkerBase):
             raise IndexError('Deque index "%d" should not be >= %d.' %
                              (int(index), deque_size))
         else:
-           return self.index(obj, index)
+            return self.index(obj, index)
+
 
 class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
@@ -274,6 +293,7 @@ class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for std::forward_list
 
+
 class ForwardListWorkerBase(gdb.xmethod.XMethodMatcher):
     def __init__(self, val_type, node_type):
         self._val_type = val_type
@@ -282,6 +302,7 @@ class ForwardListWorkerBase(gdb.xmethod.XMethodMatcher):
     def get_arg_types(self):
         return None
 
+
 class ForwardListEmptyWorker(ForwardListWorkerBase):
     def get_result_type(self, obj):
         return get_bool_type()
@@ -289,6 +310,7 @@ class ForwardListEmptyWorker(ForwardListWorkerBase):
     def __call__(self, obj):
         return obj['_M_impl']['_M_head']['_M_next'] == 0
 
+
 class ForwardListFrontWorker(ForwardListWorkerBase):
     def get_result_type(self, obj):
         return self._val_type
@@ -298,6 +320,7 @@ class ForwardListFrontWorker(ForwardListWorkerBase):
         val_address = node['_M_storage']['_M_storage'].address
         return val_address.cast(self._val_type.pointer()).dereference()
 
+
 class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
         matcher_name = matcher_name_prefix + 'forward_list'
@@ -320,6 +343,7 @@ class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for std::list
 
+
 class ListWorkerBase(gdb.xmethod.XMethodWorker):
     def __init__(self, val_type, node_type):
         self._val_type = val_type
@@ -337,6 +361,7 @@ class ListWorkerBase(gdb.xmethod.XMethodWorker):
         addr = node['_M_storage'].address
         return addr.cast(self._val_type.pointer()).dereference()
 
+
 class ListEmptyWorker(ListWorkerBase):
     def get_result_type(self, obj):
         return get_bool_type()
@@ -348,6 +373,7 @@ class ListEmptyWorker(ListWorkerBase):
         else:
             return False
 
+
 class ListSizeWorker(ListWorkerBase):
     def get_result_type(self, obj):
         return get_std_size_type()
@@ -361,6 +387,7 @@ class ListSizeWorker(ListWorkerBase):
             size += 1
         return size
 
+
 class ListFrontWorker(ListWorkerBase):
     def get_result_type(self, obj):
         return self._val_type
@@ -369,6 +396,7 @@ class ListFrontWorker(ListWorkerBase):
         node = obj['_M_impl']['_M_node']['_M_next'].cast(self._node_type)
         return self.get_value_from_node(node)
 
+
 class ListBackWorker(ListWorkerBase):
     def get_result_type(self, obj):
         return self._val_type
@@ -377,6 +405,7 @@ class ListBackWorker(ListWorkerBase):
         prev_node = obj['_M_impl']['_M_node']['_M_prev'].cast(self._node_type)
         return self.get_value_from_node(prev_node)
 
+
 class ListMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
         gdb.xmethod.XMethodMatcher.__init__(self,
@@ -401,6 +430,7 @@ class ListMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for std::vector
 
+
 class VectorWorkerBase(gdb.xmethod.XMethodWorker):
     def __init__(self, val_type):
         self._val_type = val_type
@@ -425,6 +455,7 @@ class VectorWorkerBase(gdb.xmethod.XMethodWorker):
         else:
             return obj['_M_impl']['_M_start'][index]
 
+
 class VectorEmptyWorker(VectorWorkerBase):
     def get_arg_types(self):
         return None
@@ -435,6 +466,7 @@ class VectorEmptyWorker(VectorWorkerBase):
     def __call__(self, obj):
         return int(self.size(obj)) == 0
 
+
 class VectorSizeWorker(VectorWorkerBase):
     def get_arg_types(self):
         return None
@@ -445,6 +477,7 @@ class VectorSizeWorker(VectorWorkerBase):
     def __call__(self, obj):
         return self.size(obj)
 
+
 class VectorFrontWorker(VectorWorkerBase):
     def get_arg_types(self):
         return None
@@ -455,6 +488,7 @@ class VectorFrontWorker(VectorWorkerBase):
     def __call__(self, obj):
         return self.get(obj, 0)
 
+
 class VectorBackWorker(VectorWorkerBase):
     def get_arg_types(self):
         return None
@@ -465,6 +499,7 @@ class VectorBackWorker(VectorWorkerBase):
     def __call__(self, obj):
         return self.get(obj, int(self.size(obj)) - 1)
 
+
 class VectorAtWorker(VectorWorkerBase):
     def get_arg_types(self):
         return get_std_size_type()
@@ -479,6 +514,7 @@ class VectorAtWorker(VectorWorkerBase):
                              ((int(index), size)))
         return self.get(obj, int(index))
 
+
 class VectorSubscriptWorker(VectorWorkerBase):
     def get_arg_types(self):
         return get_std_size_type()
@@ -489,6 +525,7 @@ class VectorSubscriptWorker(VectorWorkerBase):
     def __call__(self, obj, subscript):
         return self.get(obj, int(subscript))
 
+
 class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
         gdb.xmethod.XMethodMatcher.__init__(self,
@@ -514,6 +551,7 @@ class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for associative containers
 
+
 class AssociativeContainerWorkerBase(gdb.xmethod.XMethodWorker):
     def __init__(self, unordered):
         self._unordered = unordered
@@ -527,6 +565,7 @@ class AssociativeContainerWorkerBase(gdb.xmethod.XMethodWorker):
     def get_arg_types(self):
         return None
 
+
 class AssociativeContainerEmptyWorker(AssociativeContainerWorkerBase):
     def get_result_type(self, obj):
         return get_bool_type()
@@ -534,6 +573,7 @@ class AssociativeContainerEmptyWorker(AssociativeContainerWorkerBase):
     def __call__(self, obj):
         return int(self.node_count(obj)) == 0
 
+
 class AssociativeContainerSizeWorker(AssociativeContainerWorkerBase):
     def get_result_type(self, obj):
         return get_std_size_type()
@@ -541,6 +581,7 @@ class AssociativeContainerSizeWorker(AssociativeContainerWorkerBase):
     def __call__(self, obj):
         return self.node_count(obj)
 
+
 class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self, name):
         gdb.xmethod.XMethodMatcher.__init__(self,
@@ -564,6 +605,7 @@ class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for std::unique_ptr
 
+
 class UniquePtrGetWorker(gdb.xmethod.XMethodWorker):
     "Implements std::unique_ptr<T>::get() and std::unique_ptr<T>::operator->()"
 
@@ -593,7 +635,7 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker):
             tuple_member = obj['_M_t']
         else:
             return None
-        tuple_impl_type = tuple_member.type.fields()[0].type # _Tuple_impl
+        tuple_impl_type = tuple_member.type.fields()[0].type  # _Tuple_impl
         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':
@@ -603,6 +645,7 @@ class UniquePtrGetWorker(gdb.xmethod.XMethodWorker):
         else:
             return None
 
+
 class UniquePtrDerefWorker(UniquePtrGetWorker):
     "Implements std::unique_ptr<T>::operator*()"
 
@@ -619,6 +662,7 @@ class UniquePtrDerefWorker(UniquePtrGetWorker):
     def __call__(self, obj):
         return UniquePtrGetWorker.__call__(self, obj).dereference()
 
+
 class UniquePtrSubscriptWorker(UniquePtrGetWorker):
     "Implements std::unique_ptr<T>::operator[](size_t)"
 
@@ -638,6 +682,7 @@ class UniquePtrSubscriptWorker(UniquePtrGetWorker):
     def __call__(self, obj, index):
         return UniquePtrGetWorker.__call__(self, obj)[index]
 
+
 class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
         gdb.xmethod.XMethodMatcher.__init__(self,
@@ -663,6 +708,7 @@ class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
 
 # Xmethods for std::shared_ptr
 
+
 class SharedPtrGetWorker(gdb.xmethod.XMethodWorker):
     "Implements std::shared_ptr<T>::get() and std::shared_ptr<T>::operator->()"
 
@@ -686,6 +732,7 @@ class SharedPtrGetWorker(gdb.xmethod.XMethodWorker):
     def __call__(self, obj):
         return obj['_M_ptr']
 
+
 class SharedPtrDerefWorker(SharedPtrGetWorker):
     "Implements std::shared_ptr<T>::operator*()"
 
@@ -702,6 +749,7 @@ class SharedPtrDerefWorker(SharedPtrGetWorker):
     def __call__(self, obj):
         return SharedPtrGetWorker.__call__(self, obj).dereference()
 
+
 class SharedPtrSubscriptWorker(SharedPtrGetWorker):
     "Implements std::shared_ptr<T>::operator[](size_t)"
 
@@ -726,6 +774,7 @@ class SharedPtrSubscriptWorker(SharedPtrGetWorker):
                              (self._elem_type, int(index), int(m.group(1))))
         return SharedPtrGetWorker.__call__(self, obj)[index]
 
+
 class SharedPtrUseCountWorker(gdb.xmethod.XMethodWorker):
     "Implements std::shared_ptr<T>::use_count()"
 
@@ -745,6 +794,7 @@ class SharedPtrUseCountWorker(gdb.xmethod.XMethodWorker):
         refcounts = obj['_M_refcount']['_M_pi']
         return refcounts['_M_use_count'] if refcounts else 0
 
+
 class SharedPtrUniqueWorker(SharedPtrUseCountWorker):
     "Implements std::shared_ptr<T>::unique()"
 
@@ -757,6 +807,7 @@ class SharedPtrUniqueWorker(SharedPtrUseCountWorker):
     def __call__(self, obj):
         return SharedPtrUseCountWorker.__call__(self, obj) == 1
 
+
 class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
     def __init__(self):
         gdb.xmethod.XMethodMatcher.__init__(self,
@@ -782,6 +833,7 @@ class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher):
             return worker
         return None
 
+
 def register_libstdcxx_xmethods(locus):
     gdb.xmethod.register_xmethod_matcher(locus, ArrayMethodsMatcher())
     gdb.xmethod.register_xmethod_matcher(locus, ForwardListMethodsMatcher())
-- 
2.41.0



More information about the Gcc-patches mailing list