solenv/gdb/libreoffice/sw.py

   1 # -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
   2 #
   3 # This file is part of the LibreOffice project.
   4 #
   5 # This Source Code Form is subject to the terms of the Mozilla Public
   6 # License, v. 2.0. If a copy of the MPL was not distributed with this
   7 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8 #
   9
  10 from libreoffice.util import printing
  11
  12 class SwPositionPrinter(object):
  13     '''Prints SwPosition.'''
  14
  15     def __init__(self, typename, value):
  16         self.typename = typename
  17         self.value = value
  18
  19     def to_string(self):
  20         node = self.value['nNode']['pNd'].dereference();
  21         offset = self.value['nContent']['m_nIndex']
  22         return "%s (node %d, offset %d)" % (self.typename, node['nOffset'], offset)
  23
  24 class SwNodeIndexPrinter(object):
  25     '''Prints SwNodeIndex.'''
  26
  27     def __init__(self, typename, value):
  28         self.typename = typename
  29         self.value = value
  30
  31     def to_string(self):
  32         node = self.value['pNd'].dereference();
  33         return "%s (node %d)" % (self.typename, node['nOffset'])
  34
  35 class SwIndexPrinter(object):
  36     '''Prints SwIndex.'''
  37
  38     def __init__(self, typename, value):
  39         self.typename = typename
  40         self.value = value
  41
  42     def to_string(self):
  43         offset = self.value['m_nIndex']
  44         return "%s (offset %d)" % (self.typename, offset)
  45
  46 class SwPaMPrinter(object):
  47     '''Prints SwPaM.'''
  48
  49     def __init__(self, typename, value):
  50         self.typename = typename
  51         self.value = value
  52
  53     def to_string(self):
  54         return "%s" % (self.typename)
  55
  56     def children(self):
  57         next_ = self.value['pNext']
  58         prev  = self.value['pPrev']
  59         point = self.value['m_pPoint'].dereference()
  60         mark = self.value['m_pMark'].dereference()
  61         children = [ ( 'point', point), ( 'mark', mark ) ]
  62         if next_ != self.value.address:
  63             children.append(("next", next_))
  64         if prev != self.value.address:
  65             children.append(("prev", prev))
  66         return children.__iter__()
  67
  68 class SwUnoCrsrPrinter(SwPaMPrinter):
  69     '''Prints SwUnoCrsr.'''
  70
  71 class SwRectPrinter(object):
  72     '''Prints SwRect.'''
  73
  74     def __init__(self, typename, value):
  75         self.typename = typename
  76         self.value = value
  77
  78     def to_string(self):
  79         return "%s" % (self.typename)
  80
  81     def children(self):
  82         point = self.value['m_Point']
  83         size = self.value['m_Size']
  84         children = [ ( 'point', point), ( 'size', size ) ]
  85         return children.__iter__()
  86
  87 class SwIMarkPrinter(object):
  88     '''Prints sw::mark::IMark.'''
  89
  90     def __init__(self, typename, value):
  91         self.typename = typename
  92         self.value = value
  93
  94     def to_string(self):
  95         return "%s" % (self.typename)
  96
  97     def children(self):
  98         if str(self.value.dynamic_type) == "sw::mark::UnoMark":
  99             unoMark = self.value.cast(self.value.dynamic_type)
 100             pos1 = unoMark['m_pPos1']
 101             pos2 = unoMark['m_pPos2']
 102             children = [ ( 'pos1', pos1), ( 'pos2', pos2 ) ]
 103             return children.__iter__()
 104         else:
 105             return self._iterator(self.value)
 106
 107 class SwModifyPrinter(object):
 108     '''Prints SwModify.'''
 109
 110     def __init__(self, typename, value):
 111         self.typename = typename
 112         self.value = value
 113
 114     def to_string(self):
 115         return "%s" % (self.typename)
 116
 117     def children(self):
 118         if str(self.value.dynamic_type) == "SwUnoCrsr":
 119             unoCrsr = self.value.cast(self.value.dynamic_type)
 120             return SwUnoCrsrPrinter(self.typename, unoCrsr).children()
 121         else:
 122             return self._iterator(self.value)
 123
 124 class SwXTextRangeImplPrinter(object):
 125     '''Prints SwXTextRange::Impl.'''
 126
 127     def __init__(self, typename, value):
 128         self.typename = typename
 129         self.value = value
 130
 131     def to_string(self):
 132         return "%s" % (self.typename)
 133
 134     def children(self):
 135         mark = self.value['m_pMark'].dereference()
 136         children = [('mark', mark)]
 137         return children.__iter__()
 138
 139 class SwXTextCursorImplPrinter(object):
 140     '''Prints SwXTextCursor::Impl.'''
 141
 142     def __init__(self, typename, value):
 143         self.typename = typename
 144         self.value = value
 145
 146     def to_string(self):
 147         return "%s" % (self.typename)
 148
 149     def children(self):
 150         registeredIn = self.value['pRegisteredIn'].dereference()
 151         children = [('registeredIn', registeredIn)]
 152         return children.__iter__()
 153
 154 class SwUnoImplPtrPrinter(object):
 155     """Prints sw::UnoImplPtr"""
 156
 157     def __init__(self, typename, value):
 158         self.typename = typename
 159         self.value = value
 160
 161     def to_string(self):
 162         if self.value['m_p']:
 163             return "%s %s" % (self.typename, self.value['m_p'].dereference())
 164         else:
 165             return "empty %s" % (self.typename,)
 166
 167 class SwXTextRangePrinter(object):
 168     '''Prints SwXTextRange.'''
 169
 170     def __init__(self, typename, value):
 171         self.typename = typename
 172         self.value = value
 173
 174     def to_string(self):
 175         return "%s %s" % (self.typename, self.value['m_pImpl'])
 176
 177 class SwXTextCursorPrinter(object):
 178     '''Prints SwXTextCursor.'''
 179
 180     def __init__(self, typename, value):
 181         self.typename = typename
 182         self.value = value
 183
 184     def to_string(self):
 185         return "%s %s" % (self.typename, self.value['m_pImpl'])
 186
 187 class BigPtrArrayPrinter(object):
 188     '''Prints BigPtrArray.'''
 189
 190     def __init__(self, typename, value):
 191         self.typename = typename
 192         self.value = value
 193
 194     def to_string(self):
 195         length = self.value['nSize']
 196         if length > 0:
 197             return "%s of length %d" % (self.typename, length)
 198         else:
 199             return "empty %s" % self.typename
 200
 201     def children(self):
 202         return self._iterator(self.value)
 203
 204     def display_hint(self):
 205         return 'array'
 206
 207
 208     class _iterator(object):
 209
 210         def __init__(self, array):
 211             self.blocks = array['ppInf']
 212             self.count = array['nSize']
 213             self.pos = 0
 214             self.block_count = array['nBlock']
 215             self.block_pos = 0
 216             self.block = None
 217             self.indent = ""
 218             self.max_indent = "        "
 219             self._next_block(False)
 220             self._check_invariant()
 221
 222         def __iter__(self):
 223             return self
 224
 225         def _node_value(self, node):
 226             cur_indent = self.indent
 227             if str(node.dynamic_type.target()) == "SwTxtNode":
 228                 # accessing this is completely non-obvious...
 229                 # also, node.dynamic_cast(node.dynamic_type) is null?
 230                 value = "    TextNode " + \
 231                   unicode(node.cast(node.dynamic_type).dereference()['m_Text'])
 232             elif str(node.dynamic_type.target()) == "SwOLENode":
 233                 value = "     OLENode "
 234             elif str(node.dynamic_type.target()) == "SwGrfNode":
 235                 value = "     GrfNode "
 236             elif str(node.dynamic_type.target()) == "SwSectionNode":
 237                 value = " SectionNode "
 238                 self.indent += " "
 239             elif str(node.dynamic_type.target()) == "SwTableNode":
 240                 value = "   TableNode "
 241                 self.indent += " "
 242             elif str(node.dynamic_type.target()) == "SwStartNode":
 243                 value = "   StartNode "
 244                 self.indent += " "
 245             elif str(node.dynamic_type.target()) == "SwEndNode":
 246                 value = "     EndNode "
 247                 self.indent = self.indent[:-1]
 248                 cur_indent = self.indent
 249             elif str(node.dynamic_type.target()) == "SwDummySectionNode":
 250                 value = "DummySctNode "
 251             else: # must be currently being deleted, so has some abstract type
 252                 value = "~DeletedNode "
 253 #            return "\n[%s%4d%s] %s %s" % (cur_indent, self.pos, \
 254 #                                self.max_indent[len(cur_indent):], node, value)
 255             return "\n[%4d] %s%s%s %s" % (self.pos, cur_indent, \
 256                                 node, self.max_indent[len(cur_indent):], value)
 257
 258         def next(self):
 259             if self.pos == self.count:
 260                 raise StopIteration()
 261
 262             name = str(self.pos)
 263             node = self.block['pData'][self.pos - self.block['nStart']]
 264             value =  self._node_value(node)
 265             if self.pos == self.block['nEnd']:
 266                 self._next_block()
 267             self.pos += 1
 268
 269             self._check_invariant()
 270             return (name, value)
 271
 272         def _next_block(self, advance = True):
 273             if advance:
 274                 self.block_pos += 1
 275
 276             if self.block_pos == self.block_count:
 277                 return
 278
 279             pblock = self.blocks[self.block_pos]
 280             assert pblock
 281             block = pblock.dereference()
 282             start = block['nStart']
 283             end = block['nEnd']
 284             assert end - start + 1 == block['nElem']
 285             if self.block:
 286                 assert start == self.block['nEnd'] + 1
 287                 assert end <= self.count
 288             else:
 289                 assert start == 0
 290             self.block = block
 291
 292         def _check_invariant(self):
 293             assert self.pos <= self.count
 294             assert self.block_pos <= self.block_count
 295             if self.pos == 0 and self.pos < self.count:
 296                 assert self.block != None
 297
 298 printer = None
 299
 300 def build_pretty_printers():
 301     global printer
 302
 303     printer = printing.Printer("libreoffice/sw")
 304     printer.add('BigPtrArray', BigPtrArrayPrinter)
 305     printer.add('SwPosition', SwPositionPrinter)
 306     printer.add('SwNodeIndex', SwNodeIndexPrinter)
 307     printer.add('SwIndex', SwIndexPrinter)
 308     printer.add('SwPaM', SwPaMPrinter)
 309     printer.add('SwUnoCrsr', SwUnoCrsrPrinter)
 310     printer.add('SwRect', SwRectPrinter)
 311     printer.add('sw::mark::IMark', SwIMarkPrinter)
 312     printer.add('SwXTextRange::Impl', SwXTextRangeImplPrinter)
 313     printer.add('sw::UnoImplPtr', SwUnoImplPtrPrinter)
 314     printer.add('SwXTextRange', SwXTextRangePrinter)
 315     printer.add('SwModify', SwModifyPrinter)
 316     printer.add('SwXTextCursor::Impl', SwXTextCursorImplPrinter)
 317     printer.add('SwXTextCursor', SwXTextCursorPrinter)
 318
 319 def register_pretty_printers(obj):
 320     printing.register_pretty_printer(printer, obj)
 321
 322 build_pretty_printers()
 323
 324 # vim:set shiftwidth=4 softtabstop=4 expandtab: