solenv/gdb/boost/ptr_container.py

   1 # -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
   2 # GDB pretty printers for Boost.Pointer Container.
   3 #
   4 # Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
   5 #
   6 # This file is part of boost-gdb-printers.
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 3 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful,
  14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 # GNU General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22 import gdb
  23
  24 from boost.lib.unordered import Map, Set
  25
  26 import boost.util.printing as printing
  27
  28 std = None
  29
  30 class PtrStdPrinterBase(object):
  31
  32     def __init__(self, typename, value, seq_tag):
  33         self._import_std()
  34         self.typename = typename
  35         self.value = value
  36
  37         # (try to) init printer of underlying std sequence and get elements
  38         printer = self._get_sequence_printer(seq_tag)
  39         if printer:
  40             seq = value['c_']
  41             if str(seq.type.strip_typedefs()).startswith('std::__debug::'):
  42                 seq_typename = 'std::__debug::%s' % seq_tag
  43             else:
  44                 seq_typename = 'std::%s' % seq_tag
  45             self.sequence = list(printer(seq_typename, seq).children())
  46         else:
  47             self.sequence = None
  48
  49     def to_string(self):
  50         if self.sequence != None:
  51             length = len(self.sequence)
  52             if length:
  53                 return "%s %s" % (self.typename, self.print_size(length))
  54             else:
  55                 return "empty %s" % self.typename
  56         else:
  57             return "opaque %s" % self.typename
  58
  59     def children(self):
  60         return self._iterator(self.sequence, self.value.type.template_argument(0))
  61
  62     class _iterator(object):
  63
  64         def __init__(self, sequence, type):
  65             self.impl = iter(sequence)
  66             self.type = type.pointer()
  67
  68         def __iter__(self):
  69             return self
  70
  71         def next(self):
  72             (index, value) = self.impl.next()
  73             return (index, value.cast(self.type).dereference())
  74
  75     def _import_std(self):
  76         global std
  77         if not std:
  78             try:
  79                 import libstdcxx.v6.printers
  80                 std = libstdcxx.v6.printers
  81             except:
  82                 pass
  83
  84     def _get_sequence_printer(self, typename):
  85         if typename == "deque":
  86             return std.StdDequePrinter
  87         if typename == "list":
  88             return std.StdListPrinter
  89         if typename == "map":
  90             return std.StdMapPrinter
  91         if typename == "set":
  92             return std.StdSetPrinter
  93         if typename == "vector":
  94             return std.StdVectorPrinter
  95
  96 class PtrSequencePrinter(PtrStdPrinterBase):
  97
  98     def __init__(self, typename, value, seq_tag):
  99         super(PtrSequencePrinter, self).__init__(typename, value, seq_tag)
 100
 101     def print_size(self, size):
 102         return "of length %s" % size
 103
 104     def display_hint(self):
 105         return 'array'
 106
 107 class PtrSetPrinter(PtrStdPrinterBase):
 108
 109     def __init__(self, typename, value):
 110         super(PtrSetPrinter, self).__init__(typename, value, 'set')
 111
 112     def print_size(self, size):
 113         return "with %s elements" % size
 114
 115     def display_hint(self):
 116         return 'array'
 117
 118 class PtrMapPrinter(PtrStdPrinterBase):
 119
 120     def __init__(self, typename, value):
 121         super(PtrMapPrinter, self).__init__(typename, value, 'map')
 122
 123     def children(self):
 124         type = self.value.type
 125         return self._iterator(self.sequence, type.template_argument(0), type.template_argument(1))
 126
 127     class _iterator(object):
 128
 129         def __init__(self, sequence, key_type, value_type):
 130             self.impl = iter(sequence)
 131             self.key_type = key_type
 132             self.value_type = value_type.pointer()
 133             self.key = True
 134
 135         def __iter__(self):
 136             return self
 137
 138         def next(self):
 139             (index, value) = self.impl.next()
 140             if self.key:
 141                 value = value.cast(self.key_type)
 142             else:
 143                 value = value.cast(self.value_type).dereference()
 144             self.key = not self.key
 145             return (index, value)
 146
 147     def display_hint(self):
 148         return 'map'
 149
 150     def print_size(self, size):
 151         return "with %s elements" % (size / 2)
 152
 153 class PtrBoostPrinterBase(object):
 154
 155     def __init__(self, typename, value, container, iterator, value_type):
 156         self.typename = typename
 157         self.impl = container(value['c_'])
 158         self.iterator = iterator
 159         self.value_type = value_type.pointer()
 160
 161     def to_string(self):
 162         if self.impl.empty():
 163             return "empty " + self.typename
 164         else:
 165             return "%s with %s elements" % (self.typename, len(self.impl))
 166
 167     def children(self):
 168         return self.iterator(iter(self.impl), self.value_type)
 169
 170 class PtrUnorderedMapPrinter(PtrBoostPrinterBase):
 171
 172     def __init__(self, typename, value):
 173         super(PtrUnorderedMapPrinter, self).__init__(typename, value, Map, self._iterator,
 174                 value.type.template_argument(1))
 175
 176     def display_hint(self):
 177         return 'map'
 178
 179     class _iterator(object):
 180
 181         def __init__(self, impl, value_type):
 182             self.impl = impl
 183             self.step = True
 184             self.value = None
 185             self.value_type = value_type
 186
 187         def __iter__(self):
 188             return self
 189
 190         def next(self):
 191             if self.step:
 192                 self.value = self.impl.next()
 193                 value = self.value[0]
 194             else:
 195                 value = self.value[1].cast(self.value_type).dereference()
 196             self.step = not self.step
 197             return ("", value)
 198
 199 class PtrUnorderedSetPrinter(PtrBoostPrinterBase):
 200
 201     def __init__(self, typename, value):
 202         super(PtrUnorderedSetPrinter, self).__init__(typename, value, Set, self._iterator,
 203                 value.type.template_argument(0))
 204
 205     def display_hint(self):
 206         return 'array'
 207
 208     class _iterator(object):
 209
 210         def __init__(self, impl, value_type):
 211             self.impl = impl
 212             self.value_type = value_type
 213
 214         def __iter__(self):
 215             return self
 216
 217         def next(self):
 218             return ("", self.impl.next()[1].cast(self.value_type).dereference())
 219
 220 printer = None
 221
 222 def build_pretty_printers():
 223     global printer
 224
 225     if printer != None:
 226         return
 227
 228     printer = printing.Printer("boost.ptr_container")
 229
 230     printer.add('boost::ptr_deque', (lambda t, v: PtrSequencePrinter(t, v, "deque")))
 231     printer.add('boost::ptr_list', (lambda t, v: PtrSequencePrinter(t, v, "list")))
 232     printer.add('boost::ptr_map', PtrMapPrinter)
 233     printer.add('boost::ptr_multimap', PtrMapPrinter)
 234     printer.add('boost::ptr_multiset', PtrSetPrinter)
 235     printer.add('boost::ptr_set', PtrSetPrinter)
 236     printer.add('boost::ptr_unordered_map', PtrUnorderedMapPrinter)
 237     printer.add('boost::ptr_unordered_multimap', PtrUnorderedMapPrinter)
 238     printer.add('boost::ptr_unordered_multiset', PtrUnorderedSetPrinter)
 239     printer.add('boost::ptr_unordered_set', PtrUnorderedSetPrinter)
 240     printer.add('boost::ptr_vector', (lambda t, v: PtrSequencePrinter(t, v, "vector")))
 241
 242 def register_pretty_printers(obj):
 243     printing.register_pretty_printer(printer, obj)
 244
 245 build_pretty_printers()
 246
 247 # vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab: