-# Pretty-printers for libstc++.
+# Pretty-printers for libstdc++.
# Copyright (C) 2008-2014 Free Software Foundation, Inc.
import gdb
import itertools
import re
+import sys
+
+### Python 2 + Python 3 compatibility code
+
+# Resources about compatibility:
+#
+# * <http://pythonhosted.org/six/>: Documentation of the "six" module
+
+# FIXME: The handling of e.g. std::basic_string (at least on char)
+# probably needs updating to work with Python 3's new string rules.
+#
+# In particular, Python 3 has a separate type (called byte) for
+# bytestrings, and a special b"" syntax for the byte literals; the old
+# str() type has been redefined to always store Unicode text.
+#
+# We probably can't do much about this until this GDB PR is addressed:
+# <https://sourceware.org/bugzilla/show_bug.cgi?id=17138>
+
+if sys.version_info[0] > 2:
+ ### Python 3 stuff
+ Iterator = object
+ # Python 3 folds these into the normal functions.
+ imap = map
+ izip = zip
+ # Also, int subsumes long
+ long = int
+else:
+ ### Python 2 stuff
+ class Iterator:
+ """Compatibility mixin for iterators
+
+ Instead of writing next() methods for iterators, write
+ __next__() methods and use this mixin to make them work in
+ Python 2 as well as Python 3.
+
+ Idea stolen from the "six" documentation:
+ <http://pythonhosted.org/six/#six.Iterator>
+ """
+
+ def next(self):
+ return self.__next__()
+
+ # In Python 2, we still need these from itertools
+ from itertools import imap, izip
# Try to use the new-style pretty-printing if available.
_use_gdb_pp = True
class StdListPrinter:
"Print a std::list"
- class _iterator:
+ class _iterator(Iterator):
def __init__(self, nodetype, head):
self.nodetype = nodetype
self.base = head['_M_next']
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.base == self.head:
raise StopIteration
elt = self.base.cast(self.nodetype).dereference()
class StdSlistPrinter:
"Print a __gnu_cxx::slist"
- class _iterator:
+ class _iterator(Iterator):
def __init__(self, nodetype, head):
self.nodetype = nodetype
self.base = head['_M_head']['_M_next']
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.base == 0:
raise StopIteration
elt = self.base.cast(self.nodetype).dereference()
class StdVectorPrinter:
"Print a std::vector"
- class _iterator:
+ class _iterator(Iterator):
def __init__ (self, start, finish, bitvec):
self.bitvec = bitvec
if bitvec:
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
count = self.count
self.count = self.count + 1
if self.bitvec:
class StdTuplePrinter:
"Print a std::tuple"
- class _iterator:
+ class _iterator(Iterator):
def __init__ (self, head):
self.head = head
def __iter__ (self):
return self
- def next (self):
+ def __next__ (self):
nodes = self.head.type.fields ()
# Check for further recursions in the inheritance tree.
if len (nodes) == 0:
return self.visualizer.display_hint ()
return None
-class RbtreeIterator:
+class RbtreeIterator(Iterator):
def __init__(self, rbtree):
self.size = rbtree['_M_t']['_M_impl']['_M_node_count']
self.node = rbtree['_M_t']['_M_impl']['_M_header']['_M_left']
def __len__(self):
return int (self.size)
- def next(self):
+ def __next__(self):
if self.count == self.size:
raise StopIteration
result = self.node
"Print a std::map or std::multimap"
# Turn an RbtreeIterator into a pretty-print iterator.
- class _iter:
+ class _iter(Iterator):
def __init__(self, rbiter, type):
self.rbiter = rbiter
self.count = 0
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.count % 2 == 0:
- n = self.rbiter.next()
+ n = next(self.rbiter)
n = n.cast(self.type).dereference()
n = get_value_from_Rb_tree_node(n)
self.pair = n
"Print a std::set or std::multiset"
# Turn an RbtreeIterator into a pretty-print iterator.
- class _iter:
+ class _iter(Iterator):
def __init__(self, rbiter, type):
self.rbiter = rbiter
self.count = 0
def __iter__(self):
return self
- def next(self):
- item = self.rbiter.next()
+ def __next__(self):
+ item = next(self.rbiter)
item = item.cast(self.type).dereference()
item = get_value_from_Rb_tree_node(item)
# FIXME: this is weird ... what to do?
class StdDequePrinter:
"Print a std::deque"
- class _iter:
+ class _iter(Iterator):
def __init__(self, node, start, end, last, buffer_size):
self.node = node
self.p = start
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.p == self.last:
raise StopIteration
def display_hint (self):
return 'string'
-class Tr1HashtableIterator:
+class Tr1HashtableIterator(Iterator):
def __init__ (self, hash):
self.buckets = hash['_M_buckets']
self.bucket = 0
def __iter__ (self):
return self
- def next (self):
+ def __next__ (self):
if self.node == 0:
raise StopIteration
node = self.node.cast(self.node_type)
self.bucket = self.bucket + 1
return result
-class StdHashtableIterator:
+class StdHashtableIterator(Iterator):
def __init__(self, hash):
self.node = hash['_M_before_begin']['_M_nxt']
self.node_type = find_type(hash.type, '__node_type').pointer()
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.node == 0:
raise StopIteration
elt = self.node.cast(self.node_type).dereference()
return '[%d]' % i
def children (self):
- counter = itertools.imap (self.format_count, itertools.count())
+ counter = imap (self.format_count, itertools.count())
if self.typename.startswith('std::tr1'):
- return itertools.izip (counter, Tr1HashtableIterator (self.hashtable()))
- return itertools.izip (counter, StdHashtableIterator (self.hashtable()))
+ return izip (counter, Tr1HashtableIterator (self.hashtable()))
+ return izip (counter, StdHashtableIterator (self.hashtable()))
class Tr1UnorderedMapPrinter:
"Print a tr1::unordered_map"
return '[%d]' % i
def children (self):
- counter = itertools.imap (self.format_count, itertools.count())
+ 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 (itertools.imap (self.format_one, Tr1HashtableIterator (self.hashtable())))
+ data = self.flatten (imap (self.format_one, Tr1HashtableIterator (self.hashtable())))
# Zip the two iterators together.
- return itertools.izip (counter, data)
- data = self.flatten (itertools.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 itertools.izip (counter, data)
+ return izip (counter, data)
def display_hint (self):
class StdForwardListPrinter:
"Print a std::forward_list"
- class _iterator:
+ class _iterator(Iterator):
def __init__(self, nodetype, head):
self.nodetype = nodetype
self.base = head['_M_next']
def __iter__(self):
return self
- def next(self):
+ def __next__(self):
if self.base == 0:
raise StopIteration
elt = self.base.cast(self.nodetype).dereference()
projects / thirdparty / gcc.git / commitdiff
