File indexing completed on 2024-04-14 05:35:05

 # Copyright 2014 Alex Merry <alex.merry@kde.org>
 #
 # Permission to use, copy, modify, and distribute this software
 # and its documentation for any purpose and without fee is hereby
 # granted, provided that the above copyright notice appear in all
 # copies and that both that the copyright notice and this
 # permission notice and warranty disclaimer appear in supporting
 # documentation, and that the name of the author not be used in
 # advertising or publicity pertaining to distribution of the
 # software without specific, written prior permission.
 #
 # The author disclaims all warranties with regard to this
 # software, including all implied warranties of merchantability
 # and fitness.  In no event shall the author be liable for any
 # special, indirect or consequential damages or any damages
 # whatsoever resulting from loss of use, data or profits, whether
 # in an action of contract, negligence or other tortious action,
 # arising out of or in connection with the use or performance of
 # this software.
 
 import gdb.printing
 import itertools
 from qt5printers import typeinfo
 try:
     import urlparse
 except ImportError:
     # Python 3
     import urllib.parse as urlparse
 
 """Qt5Core pretty printer for GDB."""
 
 # NB: no QPair printer: the default should be fine
 
 def _format_jd(jd):
     """Format a Julian Day in YYYY-MM-DD format."""
     # maths from https://www.tondering.dk/claus/cal/julperiod.php
     a = jd + 32044
     b = (4 * a + 3) // 146097
     c = a - ( (146097 * b) // 4 )
     d = (4 * c + 3) // 1461
     e = c - ( (1461 * d) // 4 )
     m = (5 * e + 2) // 153
     day = e - ( (153 * m + 2) // 5 ) + 1
     month = m + 3 - 12 * ( m // 10 )
     year = 100 * b + d - 4800 + ( m // 10 )
     return '{:0=4}-{:0=2}-{:0=2}'.format(year, month, day)
 
 def _jd_is_valid(jd):
     """Return whether QDate would consider a given Julian Day valid."""
     return jd >= -784350574879 and jd <= 784354017364
 
 def _format_time_ms(msecs):
     """Format a number of milliseconds since midnight in HH:MM:SS.ssss format."""
     secs = msecs // 1000
     mins = secs // 60
     hours = mins // 60
     return '{:0=2}:{:0=2}:{:0=2}.{:0=3}'.format(
             hours % 24, mins % 60, secs % 60, msecs % 1000)
 
 def _ms_is_valid(msecs):
     """Return whether QTime would consider a ms since midnight valid."""
     return msecs >= 0 and msecs <= 86400000
 
 class ArrayIter:
     """Iterates over a fixed-size array."""
     def __init__(self, array, size):
         self.array = array
         self.i = -1
         self.size = size
 
     def __iter__(self):
         return self
 
     def __next__(self):
         if self.i + 1 >= self.size:
             raise StopIteration
         self.i += 1
         return ('[%d]' % self.i, self.array[self.i])
 
     def next(self):
         return self.__next__()
 
 class StructReader:
     """Reads entries from a struct."""
     def __init__(self, data):
         self.data = data.reinterpret_cast(gdb.lookup_type('char').pointer())
         self.ptr_t = gdb.lookup_type('void').pointer()
 
     def next_aligned_val(self, typ):
         ptr_val = int(str(self.data.reinterpret_cast(self.ptr_t)), 16)
         misalignment = ptr_val % self.ptr_t.sizeof
         if misalignment > 0:
             self.data += self.ptr_t.sizeof - misalignment
         val = self.data.reinterpret_cast(typ.pointer())
         self.data += typ.sizeof
         return val.referenced_value()
 
     def next_val(self, typ):
         val = self.data.reinterpret_cast(typ.pointer())
         self.data += typ.sizeof
         return val.referenced_value()
 
 class QBitArrayPrinter:
     """Print a Qt5 QBitArray"""
 
     class Iter:
         def __init__(self, data, size):
             self.data = data
             self.i = -1
             self.size = size
 
         def __iter__(self):
             return self
 
         def __next__(self):
             if self.i + 1 >= self.size:
                 raise StopIteration
             self.i += 1
             if self.data[1 + (self.i >> 3)] & (1 << (self.i&7)):
                 return (str(self.i), 1)
             else:
                 return (str(self.i), 0)
 
         def next(self):
             return self.__next__()
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']['d']
         data = d.reinterpret_cast(gdb.lookup_type('char').pointer()) + d['offset']
         size = (int(d['size']) << 3) - int(data[0])
 
         return self.Iter(data, size)
 
     def to_string(self):
         d = self.val['d']['d']
         data = d.reinterpret_cast(gdb.lookup_type('char').pointer()) + d['offset']
         size = (int(d['size']) << 3) - int(data[0])
         if size == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'array'
 
 class QByteArrayPrinter:
     """Print a Qt5 QByteArray"""
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']
         data = d.reinterpret_cast(gdb.lookup_type('char').pointer()) + d['offset']
         return ArrayIter(data, d['size'])
 
     def to_string(self):
         d = self.val['d']
         data = d.reinterpret_cast(gdb.lookup_type('char').pointer()) + d['offset']
         return data.string('', 'replace', d['size'])
 
     def display_hint(self):
         return 'string'
 
 class QCharPrinter:
     """Print a Qt5 QChar"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         ucs = self.val['ucs']
         data = ucs.address.reinterpret_cast(gdb.lookup_type('char').pointer())
         unicode_str = data.string('utf-16', 'replace', 2)
         uch = unicode_str[0]
         if uch == unichr(0x27):
             return "'\\''"
         # this actually gives us Python escapes, but they should all be
         # valid C escapes as well
         return "'" + uch.encode('unicode_escape') + "'"
 
     def display_hint(self):
         # this is not recognized by gdb, hence the manual escaping and quoting
         # we do above
         return 'char'
 
 class QDatePrinter:
     """Print a Qt5 QDate"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         jd = int(self.val['jd'])
         if not _jd_is_valid(jd):
             return '<invalid>'
         return _format_jd(jd)
 
     def display_hint(self):
         return 'date'
 
 class QDateTimePrinter:
     """Print a Qt5 QDateTime"""
 
     def __init__(self, val):
         self.val = val
 
     _unix_epoch_jd = 2440588
     _ms_per_day = 86400000
 
     # status field
     _validDate = 0x04
     _validTime = 0x08
     _validDateTime = 0x10
     _timeZoneCached = 0x20
 
     # time spec
     _localTime = 0
     _UTC = 1
     _offsetFromUTC = 2
     _timeZone = 3
 
     def to_string(self):
         d = self.val['d']['d']
         if not d:
             return '<invalid>'
 
         try:
             qshareddata_t = gdb.lookup_type('QSharedData')
         except gdb.error:
             try:
                 # well, it only has a QAtomicInt in it
                 qshareddata_t = gdb.lookup_type('QAtomicInt')
             except gdb.error:
                 # let's hope it's the same size as an int
                 qshareddata_t = gdb.lookup_type('int')
         try:
             timespec_t = gdb.lookup_type('Qt::TimeSpec')
         except gdb.error:
             # probably an int
             timespec_t = gdb.lookup_type('int')
 
         reader = StructReader(d)
         reader.next_val(qshareddata_t)
         m_msecs = reader.next_aligned_val(gdb.lookup_type('qint64'))
         spec = int(reader.next_val(timespec_t))
         m_offsetFromUtc = reader.next_val(gdb.lookup_type('int'))
         m_timeZone = reader.next_val(gdb.lookup_type('QTimeZone'))
         status = int(reader.next_val(gdb.lookup_type('int')))
 
         if spec == self._timeZone:
             timeZoneStr = QTimeZonePrinter(m_timeZone).to_string()
             if timeZoneStr == '':
                 return '<invalid>'
 
         if spec == self._localTime or (spec == self._timeZone and
                 not status & self._timeZoneCached):
             # Because QDateTime delays timezone calculations as far as
             # possible, the ValidDateTime flag may not be set even if
             # it is a valid DateTime.
             if not status & self._validDate or not status & self._validTime:
                 return '<invalid>'
         elif not (status & self._validDateTime):
             return '<invalid>'
 
         # actually fetch:
         m_msecs = int(m_msecs)
 
         jd = self._unix_epoch_jd # UNIX epoch
         jd += m_msecs // self._ms_per_day
         msecs = m_msecs % self._ms_per_day
         if msecs < 0:
             # need to adjust back to the previous day
             jd -= 1
             msecs += self._ms_per_day
 
         result = _format_jd(jd) + ' ' + _format_time_ms(msecs)
 
         if spec == self._localTime:
             result += ' (Local)'
         elif spec == self._UTC:
             result += ' (UTC)'
         elif spec == self._offsetFromUTC:
             offset = int(m_offsetFromUtc)
             if offset == 0:
                 diffstr = ''
             else:
                 hours = abs(offset // 3600)
                 mins = abs((offset % 3600) // 60)
                 secs = abs(offset % 60)
                 sign = '+' if offset > 0 else '-'
                 diffstr = '{:}{:0=2d}:{:0=2d}'.format(sign, hours, mins)
                 if secs > 0:
                     diffstr += ':{:0=2d}'.format(secs)
             result += ' (UTC{:})'.format(diffstr)
         elif spec == self._timeZone:
             result += ' ({:})'.format(timeZoneStr)
 
         return result
 
     def display_hint(self):
         return 'datetime'
 
 class QHashPrinter:
     """Print a Qt5 QHash"""
 
     class Iter:
         def __init__(self, d, e):
             self.buckets_left = d['numBuckets']
             self.node_type = e.type
             # set us up at the end of a "dummy bucket"
             self.current_bucket = d['buckets'] - 1
             self.current_node = None
             self.i = -1
             self.waiting_for_value = False
 
         def __iter__(self):
             return self
 
         def __next__(self):
             if self.waiting_for_value:
                 self.waiting_for_value = False
                 node = self.current_node.reinterpret_cast(self.node_type)
                 return ('value' + str(self.i), node['value'])
 
             if self.current_node:
                 self.current_node = self.current_node['next']
 
             # the dummy node that terminates a bucket is distinguishable
             # by not having its 'next' value set
             if not self.current_node or not self.current_node['next']:
                 while self.buckets_left:
                     self.current_bucket += 1
                     self.buckets_left -= 1
                     self.current_node = self.current_bucket.referenced_value()
                     if self.current_node['next']:
                         break
                 else:
                     raise StopIteration
 
             self.i += 1
             self.waiting_for_value = True
             node = self.current_node.reinterpret_cast(self.node_type)
             return ('key' + str(self.i), node['key'])
 
         def next(self):
             return self.__next__()
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']
 
         if d['size'] == 0:
             return []
 
         return self.Iter(d, self.val['e'])
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['d']['size'] == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'map'
 
 class QLatin1StringPrinter:
     """Print a Qt5 QLatin1String"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         return self.val['m_data'].string('', 'replace', self.val['m_size'])
 
     def display_hint(self):
         return 'string'
 
 class QLinkedListPrinter:
     """Print a Qt5 QLinkedList"""
 
     class Iter:
         def __init__(self, tail, size):
             self.current = tail
             self.i = -1
             self.size = size
 
         def __iter__(self):
             return self
 
         def __next__(self):
             if self.i + 1 >= self.size:
                 raise StopIteration
             self.i += 1
             self.current = self.current['n']
             return (str(self.i), self.current['t'])
 
         def next(self):
             return self.__next__()
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         size = int(self.val['d']['size'])
 
         if size == 0:
             return []
 
         return self.Iter(self.val['e'], size)
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['d']['size'] == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'array'
 
 class QListPrinter:
     """Print a Qt5 QList"""
 
     class Iter:
         def __init__(self, array, begin, end, typ):
             self.array = array
             self.end = end
             self.begin = begin
             self.offset = 0
             if typ.name == 'QStringList':
                 self.el_type = gdb.lookup_type('QString')
             else:
                 self.el_type = typ.template_argument(0)
 
             if ((self.el_type.sizeof > gdb.lookup_type('void').pointer().sizeof)
                     or typeinfo.type_is_known_static(self.el_type)):
                 self.is_pointer = True
             elif (typeinfo.type_is_known_movable(self.el_type) or
                     typeinfo.type_is_known_primitive(self.el_type)):
                 self.is_pointer = False
             else:
                 raise ValueError("Could not determine whether QList stores " +
                         self.el_type.name + " directly or as a pointer: to fix " +
                         "this, add it to one of the variables in the "+
                         "qt5printers.typeinfo module")
             self.node_type = gdb.lookup_type(typ.name + '::Node').pointer()
 
         def __iter__(self):
             return self
 
         def __next__(self):
             if self.begin + self.offset >= self.end:
                 raise StopIteration
             node = self.array[self.begin + self.offset].reinterpret_cast(self.node_type)
             if self.is_pointer:
                 p = node['v']
             else:
                 p = node
             self.offset += 1
             return ((str(self.offset), p.cast(self.el_type)))
 
         def next(self):
             return self.__next__()
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']
         begin = int(d['begin'])
         end = int(d['end'])
 
         if begin == end:
             return []
 
         return self.Iter(d['array'], begin, end, self.val.type.strip_typedefs())
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['d']['begin'] == self.val['d']['end']:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'array'
 
 class QMapPrinter:
     """Print a Qt5 QMap"""
 
     class Iter:
         def __init__(self, root, node_p_type):
             self.root = root
             self.current = None
             self.node_p_type = node_p_type
             self.next_is_key = True
             self.i = -1
             # we store the path here to avoid keeping re-fetching
             # values from the inferior (also, skips the pointer
             # arithmetic involved in using the parent pointer)
             self.path = []
 
         def __iter__(self):
             return self
 
         def moveToNextNode(self):
             if self.current is None:
                 # find the leftmost node
                 if not self.root['left']:
                     return False
                 self.current = self.root
                 while self.current['left']:
                     self.path.append(self.current)
                     self.current = self.current['left']
             elif self.current['right']:
                 self.path.append(self.current)
                 self.current = self.current['right']
                 while self.current['left']:
                     self.path.append(self.current)
                     self.current = self.current['left']
             else:
                 last = self.current
                 self.current = self.path.pop()
                 while self.current['right'] == last:
                     last = self.current
                     self.current = self.path.pop()
                 # if there are no more parents, we are at the root
                 if len(self.path) == 0:
                     return False
             return True
 
         def __next__(self):
             if self.next_is_key:
                 if not self.moveToNextNode():
                     raise StopIteration
                 self.current_typed = self.current.reinterpret_cast(self.node_p_type)
                 self.next_is_key = False
                 self.i += 1
                 return ('key' + str(self.i), self.current_typed['key'])
             else:
                 self.next_is_key = True
                 return ('value' + str(self.i), self.current_typed['value'])
 
         def next(self):
             return self.__next__()
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']
         size = int(d['size'])
 
         if size == 0:
             return []
 
         realtype = self.val.type.strip_typedefs()
         keytype = realtype.template_argument(0)
         valtype = realtype.template_argument(1)
         node_type = gdb.lookup_type('QMapData<' + keytype.name + ',' + valtype.name + '>::Node')
 
         return self.Iter(d['header'], node_type.pointer())
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['d']['size'] == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'map'
 
 class QSetPrinter:
     """Print a Qt5 QSet"""
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         hashPrinter = QHashPrinter(self.val['q_hash'])
         # the keys of the hash are the elements of the set, so select
         # every other item (starting with the first)
         return itertools.islice(hashPrinter.children(), 0, None, 2)
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['q_hash']['d']['size'] == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'array'
 
 class QStringPrinter:
     """Print a Qt5 QString"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         d = self.val['d']
         data = d.reinterpret_cast(gdb.lookup_type('char').pointer()) + d['offset']
         data_len = d['size'] * gdb.lookup_type('unsigned short').sizeof
         return data.string('utf-16', 'replace', data_len)
 
     def display_hint(self):
         return 'string'
 
 class QTimePrinter:
     """Print a Qt5 QTime"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         msecs = int(self.val['mds'])
         if not _ms_is_valid(msecs):
             return '<invalid>'
         return _format_time_ms(msecs)
 
     def display_hint(self):
         return 'time'
 
 class QTimeZonePrinter:
     """Print a Qt5 QTimeZone"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         d = self.val['d']['d']
         if not d:
             return ''
 
         try:
             # Accessing the private data is error-prone,
             # so try just calling the id() method.
             # This should be reasonably safe, as all it will
             # do is create a QByteArray that references the
             # same internal data as the stored one. However,
             # it will only work with an attached process.
             m_id = gdb.parse_and_eval('((QTimeZone*){:})->id()'.format(self.val.address))
         except:
             ptr_size = gdb.lookup_type('void').pointer().sizeof
             try:
                 qshareddata_t = gdb.lookup_type('QSharedData')
             except gdb.error:
                 try:
                     # well, it only has a QAtomicInt in it
                     qshareddata_t = gdb.lookup_type('QAtomicInt')
                 except gdb.error:
                     # let's hope it's the same size as an int
                     qshareddata_t = gdb.lookup_type('int')
 
             reader = StructReader(d)
             reader.next_val(gdb.lookup_type('void').pointer()) # vtable
             reader.next_val(qshareddata_t)
             m_id = reader.next_aligned_val(gdb.lookup_type('QByteArray'))
 
         return QByteArrayPrinter(m_id).to_string()
 
     def display_hint(self):
         return 'string'
 
 class QVariantPrinter:
     """Print a Qt5 QVariant"""
 
     _varmap = {
         'char': 'c',
         'uchar': 'uc',
         'short': 's',
         'signed char': 'sc',
         'ushort': 'us',
         'int': 'i',
         'uint': 'u',
         'long': 'l',
         'ulong': 'ul',
         'bool': 'b',
         'double': 'd',
         'float': 'f',
         'qreal': 'real',
         'qlonglong': 'll',
         'qulonglong': 'ull',
         'QObject*': 'o',
         'void*': 'ptr'
     }
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']
         typ = int(d['type'])
         if typ == typeinfo.meta_type_unknown:
             return [('type', 'invalid')]
 
         data = d['data']
 
         if typ in typeinfo.meta_type_names:
             typename = typeinfo.meta_type_names[typ]
             if typename in self._varmap:
                 field = self._varmap[typename]
                 return [('type', typename), ('data', data[field])]
 
             try:
                 if typename.endswith('*'):
                     gdb_type = gdb.lookup_type(typename[0:-1]).pointer()
                 else:
                     gdb_type = gdb.lookup_type(typename)
             except gdb.error:
                 # couldn't find any type information
                 return [('type', typename), ('data', data)]
 
             if gdb_type.sizeof > data.type.sizeof:
                 is_pointer = True
             elif (typeinfo.type_is_known_movable(gdb_type) or
                     typeinfo.type_is_known_primitive(gdb_type)):
                 is_pointer = False
             elif gdb_type.tag == 'enum':
                 is_pointer = False
             else:
                 # couldn't figure out how the type is stored
                 return [('type', typename), ('data', data)]
 
             if is_pointer:
                 value = data['shared']['ptr'].reinterpret_cast(gdb_type.pointer())
             else:
                 void_star = gdb.lookup_type('void').pointer()
                 data_void = data['c'].address.reinterpret_cast(void_star)
                 value = data_void.reinterpret_cast(gdb_type.pointer())
 
             return [('type', typename), ('data', value.referenced_value())]
         else:
             # custom type?
             return [('type', typ), ('data', data)]
 
     def to_string(self):
         return None
 
 class QVarLengthArrayPrinter:
     """Print a Qt5 QVarLengthArray"""
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         size = int(self.val['s'])
 
         if size == 0:
             return []
 
         return ArrayIter(self.val['ptr'], size)
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['s'] == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'array'
 
 class QVectorPrinter:
     """Print a Qt5 QVector"""
 
     def __init__(self, val):
         self.val = val
 
     def children(self):
         d = self.val['d']
         el_type = self.val.type.template_argument(0)
         data_len = int(d['size'])
 
         if data_len == 0:
             return []
 
         data_char = d.reinterpret_cast(gdb.lookup_type('char').pointer()) + d['offset']
         data = data_char.reinterpret_cast(el_type.pointer())
 
         return ArrayIter(data, data_len)
 
     def to_string(self):
         # if we return an empty list from children, gdb doesn't print anything
         if self.val['d']['size'] == 0:
             return '<empty>'
         return None
 
     def display_hint(self):
         return 'array'
 
 class QUrlPrinter:
     """Print a Qt5 QUrl"""
 
     def __init__(self, val):
         self.val = val
 
     def to_string(self):
         d = self.val['d']
         if not d:
             return '<empty>'
 
         int_t = gdb.lookup_type('int')
         try:
             atomicint_t = gdb.lookup_type('QAtomicInt')
         except gdb.error:
             # let's hope it's the same size as an int
             atomicint_t = int_t
         qstring_t = gdb.lookup_type('QString')
         uchar_t = gdb.lookup_type('uchar')
 
         reader = StructReader(d)
 
         # These fields (including order) are unstable, and
         # may change between even patch-level Qt releases
         reader.next_val(atomicint_t)
         port = int(reader.next_val(int_t))
         scheme = reader.next_val(qstring_t)
         userName = reader.next_val(qstring_t)
         password = reader.next_val(qstring_t)
         host = reader.next_val(qstring_t)
         path = reader.next_val(qstring_t)
         query = reader.next_val(qstring_t)
         fragment = reader.next_val(qstring_t)
         reader.next_val(gdb.lookup_type('void').pointer())
         sections = int(reader.next_val(uchar_t))
         flags = int(reader.next_val(uchar_t))
 
         # isLocalFile and no query and no fragment
         if flags & 0x01 and not (sections & 0x40) and not (sections & 0x80):
             # local file
             return path
 
         def qs_to_s(qstring):
             return QStringPrinter(qstring).to_string()
 
         # QUrl::toString() is way more complicated than what we do here,
         # but this is good enough for debugging
         result = ''
         if sections & 0x01:
             result += qs_to_s(scheme) + ':'
         if sections & (0x02 | 0x04 | 0x08 | 0x10) or flags & 0x01:
             result += '//'
         if sections & 0x02 or sections & 0x04:
             result += qs_to_s(userName)
             if sections & 0x04:
                 # this may appear in backtraces that will be sent to other
                 # people
                 result += ':<omitted>'
             result += '@'
         if sections & 0x08:
             result += qs_to_s(host)
         if port != -1:
             result += ':' + str(port)
         result += qs_to_s(path)
         if sections & 0x40:
             result += '?' + qs_to_s(query)
         if sections & 0x80:
             result += '#' + qs_to_s(fragment)
         return result
 
     def display_hint(self):
         return 'string'
 
 
 def build_pretty_printer():
     """Builds the pretty printer for Qt5Core."""
     pp = gdb.printing.RegexpCollectionPrettyPrinter("Qt5Core")
     pp.add_printer('QBitArray', '^QBitArray$', QBitArrayPrinter)
     pp.add_printer('QByteArray', '^QByteArray$', QByteArrayPrinter)
     pp.add_printer('QChar', '^QChar$', QCharPrinter)
     pp.add_printer('QDate', '^QDate$', QDatePrinter)
     pp.add_printer('QDateTime', '^QDateTime$', QDateTimePrinter)
     pp.add_printer('QLatin1String', '^QLatin1String$', QLatin1StringPrinter)
     pp.add_printer('QLinkedList', '^QLinkedList<.*>$', QLinkedListPrinter)
     pp.add_printer('QList', '^QList<.*>$', QListPrinter)
     pp.add_printer('QMap', '^QMap<.*>$', QMapPrinter)
     pp.add_printer('QHash', '^QHash<.*>$', QHashPrinter)
     pp.add_printer('QQueue', '^QQueue<.*>$', QListPrinter)
     pp.add_printer('QSet', '^QSet<.*>$', QSetPrinter)
     pp.add_printer('QStack', '^QStack<.*>$', QVectorPrinter)
     pp.add_printer('QString', '^QString$', QStringPrinter)
     pp.add_printer('QStringList', '^QStringList$', QListPrinter)
     pp.add_printer('QTime', '^QTime$', QTimePrinter)
     pp.add_printer('QTimeZone', '^QTimeZone$', QTimeZonePrinter)
     pp.add_printer('QVariant', '^QVariant$', QVariantPrinter)
     pp.add_printer('QVariantList', '^QVariantList$', QListPrinter)
     pp.add_printer('QVariantMap', '^QVariantMap$', QMapPrinter)
     pp.add_printer('QVector', '^QVector<.*>$', QVectorPrinter)
     pp.add_printer('QVarLengthArray', '^QVarLengthArray<.*>$', QVarLengthArrayPrinter)
     pp.add_printer('QUrl', '^QUrl$', QUrlPrinter)
     return pp
 
 printer = build_pretty_printer()
 """The pretty printer for Qt5Core.
 
 This can be registered using gdb.printing.register_pretty_printer().
 """