Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

27 files changed, 3981 insertions, 0 deletions

diff --git a/solenv/gdb/autoload.template b/solenv/gdb/autoload.template
new file mode 100644
index 000000000..fdbcce200
--- /dev/null
+++ b/solenv/gdb/autoload.template
@@ -0,0 +1,32 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import importlib
+import os.path
+import sys
+
+import gdb
+
+PP_PATH = os.path.normpath('%PYTHONDIR%')
+
+if gdb.current_objfile():
+    if PP_PATH not in sys.path:
+        sys.path.insert(0, PP_PATH)
+
+for mod in '%MODULES%'.split():
+    module = importlib.import_module('libreoffice.' + mod)
+    module.register_pretty_printers(gdb.current_objfile())
+
+try:
+    import boost
+    boost.register_pretty_printers(gdb)
+except:
+    pass
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/__init__.py b/solenv/gdb/boost/__init__.py
new file mode 100644
index 000000000..353ee3b09
--- /dev/null
+++ b/solenv/gdb/boost/__init__.py
@@ -0,0 +1,32 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# GDB pretty printers for Boost.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import boost.optional
+import boost.ptr_container
+import boost.smart_ptr
+import boost.unordered
+
+def register_pretty_printers(obj):
+    boost.optional.register_pretty_printers(obj)
+    boost.ptr_container.register_pretty_printers(obj)
+    boost.smart_ptr.register_pretty_printers(obj)
+    boost.unordered.register_pretty_printers(obj)
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/lib/__init__.py b/solenv/gdb/boost/lib/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/solenv/gdb/boost/lib/__init__.py
diff --git a/solenv/gdb/boost/lib/unordered.py b/solenv/gdb/boost/lib/unordered.py
new file mode 100644
index 000000000..ee58d0481
--- /dev/null
+++ b/solenv/gdb/boost/lib/unordered.py
@@ -0,0 +1,129 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# Helper classes for working with Boost.Unordered.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import gdb
+import six
+
+class Unordered(object):
+    '''Common representation of Boost.Unordered types'''
+
+    def __init__(self, value, extractor):
+        self.value = value
+        self.extractor = extractor
+        self.node_type = self._node_type()
+
+    def __len__(self):
+        table = self.value['table_']
+        if table['buckets_']:
+            return int(table['size_'])
+        else:
+            return 0
+
+    def __iter__(self):
+        table = self.value['table_']
+        buckets = table['buckets_']
+        if buckets:
+            first = table['cached_begin_bucket_']
+            last = buckets + table['bucket_count_']
+        else:
+            first = last = None
+        return self._iterator(first, last, self.node_type, self.extractor)
+
+    def empty(self):
+        return not self.value['table_']['buckets_']
+
+    def _node_type(self):
+        hash_table = self.value['table_'].type.fields()[0]
+        assert hash_table.is_base_class
+        hash_buckets = hash_table.type.fields()[0]
+        assert hash_buckets.is_base_class
+        node_type = gdb.lookup_type("%s::node" % hash_buckets.type)
+        assert node_type != None
+        return node_type
+
+    class _iterator(six.Iterator):
+        '''Iterator for Boost.Unordered types'''
+
+        def __init__(self, first_bucket, last_bucket, node_type, extractor):
+            self.bucket = first_bucket
+            self.last_bucket = last_bucket
+            self.node = self.bucket
+            self.node_type = node_type
+            self.value_type = self._value_type()
+            self.extractor = extractor
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.node:
+                self.node = self.node.dereference()['next_']
+
+            # we finished the current bucket: go on to the next non-empty one
+            if not self.node:
+                while not self.node and self.bucket != self.last_bucket:
+                    self.bucket += 1
+                    self.node = self.bucket.dereference()['next_']
+
+            # sorry, no node available
+            if not self.node or self.node == self.bucket:
+                raise StopIteration()
+
+            mapped = self._value()
+            return (self.extractor.key(mapped), self.extractor.value(mapped))
+
+        def _value(self):
+            assert self.node != self.bucket # bucket node has no value
+            assert self.node != None
+            node = self.node.dereference().cast(self.node_type)
+            return node['data_'].cast(self.value_type)
+
+        def _value_type(self):
+            value_base = self.node_type.fields()[1]
+            assert value_base.is_base_class
+            return value_base.type.template_argument(0)
+
+class Map(Unordered):
+
+    def __init__(self, value):
+        super(Map, self).__init__(value, self._extractor())
+
+    class _extractor(object):
+
+        def key(self, node):
+            return node['first']
+
+        def value(self, node):
+            return node['second']
+
+class Set(Unordered):
+
+    def __init__(self, value):
+        super(Set, self).__init__(value, self._extractor())
+
+    class _extractor(object):
+
+        def key(self, node):
+            return None
+
+        def value(self, node):
+            return node
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/optional.py b/solenv/gdb/boost/optional.py
new file mode 100644
index 000000000..08297254e
--- /dev/null
+++ b/solenv/gdb/boost/optional.py
@@ -0,0 +1,56 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# GDB pretty printers for Boost.Optional.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import gdb
+
+import boost.util.printing as printing
+
+class OptionalPrinter:
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        if self.value['m_initialized']:
+            data = self.value['m_storage']['dummy_']['data']
+            ptr_type = self.value.type.template_argument(0).pointer()
+            return "%s %s" % (self.typename, data.cast(ptr_type).dereference())
+        else:
+            return "empty " + self.typename
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    if printer != None:
+        return
+
+    printer = printing.Printer("boost.optional")
+
+    printer.add('boost::optional', OptionalPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/ptr_container.py b/solenv/gdb/boost/ptr_container.py
new file mode 100644
index 000000000..425d812f5
--- /dev/null
+++ b/solenv/gdb/boost/ptr_container.py
@@ -0,0 +1,248 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# GDB pretty printers for Boost.Pointer Container.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import gdb
+import six
+
+from boost.lib.unordered import Map, Set
+
+import boost.util.printing as printing
+
+std = None
+
+class PtrStdPrinterBase(object):
+
+    def __init__(self, typename, value, seq_tag):
+        self._import_std()
+        self.typename = typename
+        self.value = value
+
+        # (try to) init printer of underlying std sequence and get elements
+        printer = self._get_sequence_printer(seq_tag)
+        if printer:
+            seq = value['c_']
+            if str(seq.type.strip_typedefs()).startswith('std::__debug::'):
+                seq_typename = 'std::__debug::%s' % seq_tag
+            else:
+                seq_typename = 'std::%s' % seq_tag
+            self.sequence = list(printer(seq_typename, seq).children())
+        else:
+            self.sequence = None
+
+    def to_string(self):
+        if self.sequence != None:
+            length = len(self.sequence)
+            if length:
+                return "%s %s" % (self.typename, self.print_size(length))
+            else:
+                return "empty %s" % self.typename
+        else:
+            return "opaque %s" % self.typename
+
+    def children(self):
+        return self._iterator(self.sequence, self.value.type.template_argument(0))
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, sequence, type):
+            self.impl = iter(sequence)
+            self.type = type.pointer()
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            (index, value) = six.advance_iterator(self.impl)
+            return (index, value.cast(self.type).dereference())
+
+    def _import_std(self):
+        global std
+        if not std:
+            try:
+                import libstdcxx.v6.printers
+                std = libstdcxx.v6.printers
+            except:
+                pass
+
+    def _get_sequence_printer(self, typename):
+        if typename == "deque":
+            return std.StdDequePrinter
+        if typename == "list":
+            return std.StdListPrinter
+        if typename == "map":
+            return std.StdMapPrinter
+        if typename == "set":
+            return std.StdSetPrinter
+        if typename == "vector":
+            return std.StdVectorPrinter
+
+class PtrSequencePrinter(PtrStdPrinterBase):
+
+    def __init__(self, typename, value, seq_tag):
+        super(PtrSequencePrinter, self).__init__(typename, value, seq_tag)
+
+    def print_size(self, size):
+        return "of length %s" % size
+
+    def display_hint(self):
+        return 'array'
+
+class PtrSetPrinter(PtrStdPrinterBase):
+
+    def __init__(self, typename, value):
+        super(PtrSetPrinter, self).__init__(typename, value, 'set')
+
+    def print_size(self, size):
+        return "with %s elements" % size
+
+    def display_hint(self):
+        return 'array'
+
+class PtrMapPrinter(PtrStdPrinterBase):
+
+    def __init__(self, typename, value):
+        super(PtrMapPrinter, self).__init__(typename, value, 'map')
+
+    def children(self):
+        type = self.value.type
+        return self._iterator(self.sequence, type.template_argument(0), type.template_argument(1))
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, sequence, key_type, value_type):
+            self.impl = iter(sequence)
+            self.key_type = key_type
+            self.value_type = value_type.pointer()
+            self.key = True
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            (index, value) = six.advance_iterator(self.impl)
+            if self.key:
+                value = value.cast(self.key_type)
+            else:
+                value = value.cast(self.value_type).dereference()
+            self.key = not self.key
+            return (index, value)
+
+    def display_hint(self):
+        return 'map'
+
+    def print_size(self, size):
+        return "with %s elements" % (size / 2)
+
+class PtrBoostPrinterBase(object):
+
+    def __init__(self, typename, value, container, iterator, value_type):
+        self.typename = typename
+        self.impl = container(value['c_'])
+        self.iterator = iterator
+        self.value_type = value_type.pointer()
+
+    def to_string(self):
+        if self.impl.empty():
+            return "empty " + self.typename
+        else:
+            return "%s with %s elements" % (self.typename, len(self.impl))
+
+    def children(self):
+        return self.iterator(iter(self.impl), self.value_type)
+
+class PtrUnorderedMapPrinter(PtrBoostPrinterBase):
+
+    def __init__(self, typename, value):
+        super(PtrUnorderedMapPrinter, self).__init__(typename, value, Map, self._iterator,
+                value.type.template_argument(1))
+
+    def display_hint(self):
+        return 'map'
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, impl, value_type):
+            self.impl = impl
+            self.step = True
+            self.value = None
+            self.value_type = value_type
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.step:
+                self.value = six.advance_iterator(self.impl)
+                value = self.value[0]
+            else:
+                value = self.value[1].cast(self.value_type).dereference()
+            self.step = not self.step
+            return ("", value)
+
+class PtrUnorderedSetPrinter(PtrBoostPrinterBase):
+
+    def __init__(self, typename, value):
+        super(PtrUnorderedSetPrinter, self).__init__(typename, value, Set, self._iterator,
+                value.type.template_argument(0))
+
+    def display_hint(self):
+        return 'array'
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, impl, value_type):
+            self.impl = impl
+            self.value_type = value_type
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            return ("", six.advance_iterator(self.impl)[1].cast(self.value_type).dereference())
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    if printer != None:
+        return
+
+    printer = printing.Printer("boost.ptr_container")
+
+    printer.add('boost::ptr_deque', (lambda t, v: PtrSequencePrinter(t, v, "deque")))
+    printer.add('boost::ptr_list', (lambda t, v: PtrSequencePrinter(t, v, "list")))
+    printer.add('boost::ptr_map', PtrMapPrinter)
+    printer.add('boost::ptr_multimap', PtrMapPrinter)
+    printer.add('boost::ptr_multiset', PtrSetPrinter)
+    printer.add('boost::ptr_set', PtrSetPrinter)
+    printer.add('boost::ptr_unordered_map', PtrUnorderedMapPrinter)
+    printer.add('boost::ptr_unordered_multimap', PtrUnorderedMapPrinter)
+    printer.add('boost::ptr_unordered_multiset', PtrUnorderedSetPrinter)
+    printer.add('boost::ptr_unordered_set', PtrUnorderedSetPrinter)
+    printer.add('boost::ptr_vector', (lambda t, v: PtrSequencePrinter(t, v, "vector")))
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/smart_ptr.py b/solenv/gdb/boost/smart_ptr.py
new file mode 100644
index 000000000..60d88278a
--- /dev/null
+++ b/solenv/gdb/boost/smart_ptr.py
@@ -0,0 +1,76 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# GDB pretty printers for Boost.Smart Ptr.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import gdb
+
+import boost.util.printing as printing
+
+
+class SmartPtrPrinter:
+    """Prints smart pointers based on Boost.SmartPtr"""
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        if self.value['px']:
+            print_object = gdb.parameter('print object')
+            value = self.value['px'].dereference()
+            if print_object:
+                dynamic_type = self.value['px'].dynamic_type
+                value = self.value['px'].cast(dynamic_type).dereference()
+            return "%s %s" % (self.typename, value)
+        else:
+            return "empty %s" % (self.typename)
+
+class WeakPtrPrinter:
+    """Prints boost::weak_ptr instances"""
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        value = self.value['px']
+        return "%s %s" % (self.typename, value)
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    if printer != None:
+        return
+
+    printer = printing.Printer("boost.smart_ptr")
+
+    printer.add('boost::shared_ptr', SmartPtrPrinter)
+    # printer.add('boost::shared_array', SmartPtrPrinter)
+    printer.add('boost::weak_ptr', WeakPtrPrinter)
+    printer.add('boost::scoped_ptr', SmartPtrPrinter)
+    # printer.add('boost::scoped_array', SmartPtrPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/unordered.py b/solenv/gdb/boost/unordered.py
new file mode 100644
index 000000000..2c5672185
--- /dev/null
+++ b/solenv/gdb/boost/unordered.py
@@ -0,0 +1,112 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# GDB pretty printers for Boost.Unordered.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import gdb
+import six
+
+from boost.lib.unordered import Map, Set
+
+import boost.util.printing as printing
+
+class PrinterBase(object):
+    '''Contains common functionality for printing Boost.Unordered types'''
+
+    def __init__(self, typename, value, container, iterator):
+        self.typename = typename
+        self.impl = container(value)
+        self.iterator = iterator
+
+    def to_string(self):
+        if self.impl.empty():
+            return "empty " + self.typename
+        else:
+            return "%s with %s elements" % (self.typename, len(self.impl))
+
+    def children(self):
+        return self.iterator(iter(self.impl))
+
+class UnorderedMapPrinter(PrinterBase):
+
+    def __init__(self, typename, value):
+        super(UnorderedMapPrinter, self).__init__(typename, value, Map, self._iterator)
+
+    def display_hint(self):
+        return 'map'
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, impl):
+            self.impl = impl
+            self.value = None
+            self.step = True
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.step:
+                self.value = six.advance_iterator(self.impl)
+                value = self.value[0]
+            else:
+                value = self.value[1]
+            self.step = not self.step
+            return ("", value)
+
+class UnorderedSetPrinter(PrinterBase):
+
+    def __init__(self, typename, value):
+        super(UnorderedSetPrinter, self).__init__(typename, value, Set, self._iterator)
+
+    def display_hint(self):
+        return 'array'
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, impl):
+            self.impl = impl
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            return ("", six.advance_iterator(self.impl)[1])
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    if printer != None:
+        return
+
+    printer = printing.Printer("boost.unordered")
+
+    printer.add('boost::unordered_map', UnorderedMapPrinter)
+    printer.add('boost::unordered_multimap', UnorderedMapPrinter)
+    printer.add('boost::unordered_multiset', UnorderedSetPrinter)
+    printer.add('boost::unordered_set', UnorderedSetPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/util/__init__.py b/solenv/gdb/boost/util/__init__.py
new file mode 100644
index 000000000..e7992304d
--- /dev/null
+++ b/solenv/gdb/boost/util/__init__.py
@@ -0,0 +1,3 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/util/compatibility.py b/solenv/gdb/boost/util/compatibility.py
new file mode 100644
index 000000000..e704b1992
--- /dev/null
+++ b/solenv/gdb/boost/util/compatibility.py
@@ -0,0 +1,32 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# Compatibility with older versions of GDB.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import gdb
+
+use_gdb_printing = True
+try:
+    import gdb.printing
+except ImportError:
+    use_gdb_printing = False
+
+use_lazy_string = hasattr(gdb.Value, 'lazy_string')
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/boost/util/printing.py b/solenv/gdb/boost/util/printing.py
new file mode 100644
index 000000000..22bf29f80
--- /dev/null
+++ b/solenv/gdb/boost/util/printing.py
@@ -0,0 +1,137 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+# Printer interface adaptor.
+#
+# Copyright (C) 2012 Red Hat, Inc., David Tardon <dtardon@redhat.com>
+#
+# This file is part of boost-gdb-printers.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+try:
+    from collections.abc import Mapping
+except:
+    from collections import Mapping
+import gdb
+import re
+import six
+
+from boost.util.compatibility import use_gdb_printing
+
+class SimplePrinter(object):
+
+    def __init__(self, name, function):
+        self.name = name
+        self.function = function
+        self.enabled = True
+
+    def invoke(self, val):
+        if not self.enabled:
+            return None
+        return self.function(self.name, val)
+
+class NameLookup(Mapping):
+
+    def __init__(self):
+        self.map = {}
+        self.name_regex = re.compile(r'^([\w:]+)(<.*>)?')
+
+    def add(self, name, printer):
+        self.map[name] = printer
+
+    def __len__(self):
+        return len(self.map)
+
+    def __getitem__(self, type):
+        typename = self._basic_type(type)
+        if typename and typename in self.map:
+            return self.map[typename]
+        return None
+
+    def __iter__(self):
+        return self.map
+
+    def _basic_type(self, type):
+        basic_type = self.basic_type(type)
+        if basic_type:
+            match = self.name_regex.match(basic_type)
+            if match:
+                return match.group(1)
+        return None
+
+    @staticmethod
+    def basic_type(type):
+        if type.code == gdb.TYPE_CODE_REF:
+            type = type.target()
+        type = type.unqualified().strip_typedefs()
+        return type.tag
+
+class FunctionLookup(Mapping):
+
+    def __init__(self):
+        self.map = {}
+
+    def add(self, test, printer):
+        self.map[test] = printer
+
+    def __len__(self):
+        return len(self.map)
+
+    def __getitem__(self, type):
+        for (test, printer) in six.iteritems(self.map):
+            if test(type):
+                return printer
+        return None
+
+    def __iter__(self):
+        return self.map
+
+class Printer(object):
+
+    def __init__(self, name):
+        self.name = name
+        self.subprinters = []
+        self.name_lookup = NameLookup()
+        self.func_lookup = FunctionLookup()
+        self.enabled = True
+
+    def add(self, name, function, lookup = None):
+        printer = SimplePrinter(name, function)
+        self.subprinters.append(printer)
+        if not lookup:
+            self.name_lookup.add(name, printer)
+        else:
+            self.func_lookup.add(lookup, printer)
+
+
+    def __call__(self, val):
+        printer = self.name_lookup[val.type]
+        if not printer:
+            printer = self.func_lookup[val.type]
+
+        if printer:
+            return printer.invoke(val)
+        return None
+
+def register_pretty_printer(printer, obj):
+    '''Registers printer with objfile'''
+
+    if use_gdb_printing:
+        gdb.printing.register_pretty_printer(obj, printer)
+    else:
+        if obj is None:
+            obj = gdb
+        obj.pretty_printers.append(printer)
+
+# vim:set filetype=python shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/__init__.py b/solenv/gdb/libreoffice/__init__.py
new file mode 100644
index 000000000..06b4ade34
--- /dev/null
+++ b/solenv/gdb/libreoffice/__init__.py
@@ -0,0 +1,10 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/basegfx.py b/solenv/gdb/libreoffice/basegfx.py
new file mode 100644
index 000000000..c14968c91
--- /dev/null
+++ b/solenv/gdb/libreoffice/basegfx.py
@@ -0,0 +1,196 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+import six
+
+from libreoffice.util import printing
+
+class B2DRangePrinter(object):
+    '''Prints a B2DRange object.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+        # inject children() func dynamically
+        if not self._isEmpty():
+            self.children = self._children
+
+    def to_string(self):
+        if self._isEmpty():
+            return "empty %s" % (self.typename)
+        else:
+            return "%s" % (self.typename)
+
+    def _isEmpty(self):
+        return (self.value['maRangeX']['mnMinimum'] > self.value['maRangeX']['mnMaximum']
+                or self.value['maRangeY']['mnMinimum'] > self.value['maRangeY']['mnMaximum'])
+
+    def _children(self):
+        left = self.value['maRangeX']['mnMinimum']
+        top = self.value['maRangeY']['mnMinimum']
+        right = self.value['maRangeX']['mnMaximum']
+        bottom = self.value['maRangeY']['mnMaximum']
+        children = [('left', left), ('top', top), ('right', right), ('bottom', bottom)]
+        return children.__iter__()
+
+class B2DPolygonPrinter(object):
+    '''Prints a B2DPolygon object.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+        # inject children() func dynamically
+        if not self._isEmpty():
+            self.children = self._children
+
+    def to_string(self):
+        if self._isEmpty():
+            return "empty %s" % (self.typename)
+        else:
+            return "%s %s" % ('bezier curve' if self._hasCurves() else 'straight line',
+                              self.typename)
+
+    def _count(self):
+        # It's a call into the inferior (being debugged) process.
+        # Will not work with core dumps and can cause a deadlock.
+        return int(gdb.parse_and_eval(
+                "(('basegfx::B2DPolygon' *) {})->count()".format(self.value.address)))
+
+    def _isEmpty(self):
+        return self._count() == 0
+
+    def _hasCurves(self):
+        # It's a call into the inferior (being debugged) process.
+        # Will not work with core dumps and can cause a deadlock.
+        return int(gdb.parse_and_eval(
+                "(('basegfx::B2DPolygon' *) {})->areControlPointsUsed()".format(self.value.address))) != 0
+
+    def _children(self):
+        if self._hasCurves():
+            return self._bezierIterator(self._count(), self.value)
+        else:
+            return self._plainIterator(self._count(), self.value)
+
+    class _plainIterator(six.Iterator):
+        def __init__(self, count, value):
+            self.count = count
+            self.value = value
+            self.index = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.index >= self.count:
+                raise StopIteration()
+            points = self.value['mpPolygon']['m_pimpl'].dereference()['m_value']['maPoints']['maVector']
+            currPoint = (points['_M_impl']['_M_start'] + self.index).dereference()
+            # doesn't work?
+            #currPoint = gdb.parse_and_eval(
+            #        '((basegfx::B2DPolygon*)%d)->getB2DPoint(%d)' % (
+            #          self.value.address, self.index))
+            self.index += 1
+            return ('point %d' % (self.index-1),
+                    '(%15f, %15f)' % (currPoint['mfX'], currPoint['mfY']))
+
+    class _bezierIterator(six.Iterator):
+        def __init__(self, count, value):
+            self.count = count
+            self.value = value
+            self.index = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.index >= self.count:
+                raise StopIteration()
+            points = self.value['mpPolygon']['m_pimpl'].dereference()['m_value']['maPoints']['maVector']
+            currPoint = (points['_M_impl']['_M_start'] + self.index).dereference()
+            #currPoint = gdb.parse_and_eval(
+            #        '((basegfx::B2DPolygon*)%d)->getB2DPoint(%d)' % (
+            #          self.value.address, self.index))
+
+            # It's a call into the inferior (being debugged) process.
+            # Will not work with core dumps and can cause a deadlock.
+            prevControl = gdb.parse_and_eval(
+                    "(('basegfx::B2DPolygon' *) {})->getPrevControlPoint({:d})".format(self.value.address, self.index))
+            # It's a call into the inferior (being debugged) process.
+            # Will not work with core dumps and can cause a deadlock.
+            nextControl = gdb.parse_and_eval(
+                    "(('basegfx::B2DPolygon' *) {})->getNextControlPoint({:d})".format(self.value.address, self.index))
+            self.index += 1
+            return ('point %d' % (self.index-1),
+                    'p: (%15f, %15f) c-1: (%15f, %15f) c1: (%15f, %15f)' %
+                    (currPoint['mfX'],   currPoint['mfY'],
+                     prevControl['mfX'], prevControl['mfY'],
+                     nextControl['mfX'], nextControl['mfY']))
+
+class B2DPolyPolygonPrinter(object):
+    '''Prints a B2DPolyPolygon object.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        if self._isEmpty():
+            return "empty %s" % (self.typename)
+        else:
+            return "%s %s with %d sub-polygon(s)" % ('closed' if self._isClosed() else 'open',
+                                                     self.typename,
+                                                     self._count())
+
+    def _count(self):
+        # It's a call into the inferior (being debugged) process.
+        # Will not work with core dumps and can cause a deadlock.
+        return int(gdb.parse_and_eval(
+                "(('basegfx::B2DPolyPolygon' *) {})->count()".format(self.value.address)))
+
+    def _isClosed(self):
+        # It's a call into the inferior (being debugged) process.
+        # Will not work with core dumps and can cause a deadlock.
+        return int(gdb.parse_and_eval(
+                "(('basegfx::B2DPolyPolygon' *) {})->isClosed()".format(self.value.address))) != 0
+
+    def _isEmpty(self):
+        return self._count() == 0
+
+    def children(self):
+        if self.value['mpPolyPolygon']['m_pimpl'].type.code in (gdb.TYPE_CODE_PTR, gdb.TYPE_CODE_MEMBERPTR):
+            if self.value['mpPolyPolygon']['m_pimpl']:
+                try:
+                    vector = self.value['mpPolyPolygon']['m_pimpl'].dereference()['m_value']['maPolygons']
+                    import libstdcxx.v6.printers as std
+                    return std.StdVectorPrinter("std::vector", vector).children()
+                except RuntimeError:
+                    gdb.write("Cannot access memory at address " + str(self.value['mpPolyPolygon']['m_pimpl'].address))
+
+        return None
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer('libreoffice/basegfx')
+
+    # basic types
+    printer.add('basegfx::B2DRange', B2DRangePrinter)
+    printer.add('basegfx::B2DPolygon', B2DPolygonPrinter)
+    printer.add('basegfx::B2DPolyPolygon', B2DPolyPolygonPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
+
diff --git a/solenv/gdb/libreoffice/cppu.py b/solenv/gdb/libreoffice/cppu.py
new file mode 100644
index 000000000..5114dbe12
--- /dev/null
+++ b/solenv/gdb/libreoffice/cppu.py
@@ -0,0 +1,156 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import six
+
+from libreoffice.util import printing
+from libreoffice.util.uno import TypeClass, make_uno_type, uno_cast
+
+class UnoAnyPrinter(object):
+    '''Prints UNO any'''
+
+    def __init__(self, typename, value):
+        self.value = value
+        self.typename = typename.replace('com::sun::star::', '')
+
+    def to_string(self):
+        type_desc = self.value['pType']
+        assert type_desc
+        type = make_uno_type(type_desc.dereference())
+        assert type
+        if type_desc.dereference()['eTypeClass'] == TypeClass.VOID:
+            return ('%s(%s)' % (self.typename, type.tag))
+        else:
+            ptr = self.value['pData']
+            assert ptr
+            return ('%s(%s: %s)' % (self.typename, type.tag, str(uno_cast(type, ptr).dereference())))
+
+class UnoReferencePrinter(object):
+    '''Prints reference to a UNO interface'''
+
+    def __init__(self, typename, value):
+        self.value = value
+        self.typename = typename.replace('com::sun::star::', '')
+
+    def to_string(self):
+        iface = self.value['_pInterface']
+        if iface:
+            try:
+                return '%s to (%s) %s' % (self.typename, str(iface.dynamic_type), str(iface))
+            except:
+                # fallback for potential problem:
+                # base class 'com::sun::star::uno::XInterface' is ambiguous
+                return '%s to (XInterface) %s' % (self.typename, str(iface))
+
+        else:
+            return "empty %s" % self.typename
+
+class UnoSequencePrinter(object):
+    '''Prints UNO Sequence'''
+
+    class iterator(six.Iterator):
+        '''Sequence iterator'''
+
+        def __init__(self, first, size):
+            self.item = first
+            self.size = size
+            self.count = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.count == self.size:
+                raise StopIteration
+            count = self.count
+            self.count = self.count + 1
+            elem = self.item.dereference()
+            self.item = self.item + 1
+            return ('[%d]' % count, elem)
+
+
+    def __init__(self, typename, value):
+        self.value = value
+        self.typename = typename.replace('com::sun::star::', '')
+
+    def to_string(self):
+        pimpl = self.value['_pSequence']
+        if pimpl:
+            impl = pimpl.dereference()
+            elems = impl['nElements']
+            if elems == 0:
+                return "empty %s" % self.typename
+            else:
+                return "%s of length %d" % (self.typename, elems)
+        else:
+            return "uninitialized %s" % self.typename
+
+    def children(self):
+        pimpl = self.value['_pSequence']
+        if pimpl:
+            impl = pimpl.dereference()
+            elemtype = self.value.type.template_argument(0)
+            elements = impl['elements'].cast(elemtype.pointer())
+            return self.iterator(elements, int(impl['nElements']))
+        else:
+            # TODO is that the best thing to do here?
+            return None
+
+    def display_hint(self):
+        if self.value['_pSequence']:
+            return 'array'
+        else:
+            return None
+
+class UnoTypePrinter(object):
+    '''Prints UNO Type'''
+
+    def __init__(self, typename, value):
+        self.value = value
+        self.typename = typename.replace('com::sun::star::', '')
+
+    def to_string(self):
+        uno = make_uno_type(self.value)
+        if uno:
+            return "%s %s" % (self.typename, uno.tag)
+            # return "%s %s" % (self.typename, uno.typename)
+        else:
+            return "invalid %s" % self.typename
+
+class CppuThreadpoolThreadPoolPrinter(object):
+    '''Prints cppu_threadpool::ThreadPool objects (a hack to avoid infinite recursion through sal.RtlReferencePrinter when printing an rtl::Reference<cppu_threadpool::ThreadPool> whose std::list<cppu_threadpool::WaitingThread*> m_lstThreads member, via rtl::Reference<cppu_threadpool::ORequestThread> thread member, via rtl::Reference<cppu_threadpool::ThreadPool> m_aThreadPool member, has a circular reference back)'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return '%s@%s' % (self.typename, self.value.address)
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer("libreoffice/cppu")
+
+    # basic UNO stuff
+    printer.add('_uno_Any', UnoAnyPrinter)
+    printer.add('com::sun::star::uno::Any', UnoAnyPrinter)
+    printer.add('com::sun::star::uno::Reference', UnoReferencePrinter)
+    printer.add('com::sun::star::uno::Sequence', UnoSequencePrinter)
+    printer.add('com::sun::star::uno::Type', UnoTypePrinter)
+    printer.add('cppu_threadpool::ThreadPool', CppuThreadpoolThreadPoolPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/sal.py b/solenv/gdb/libreoffice/sal.py
new file mode 100644
index 000000000..8dcfaebe6
--- /dev/null
+++ b/solenv/gdb/libreoffice/sal.py
@@ -0,0 +1,167 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+import gdb.types
+import six
+
+from libreoffice.util import printing
+from libreoffice.util.string import StringPrinterHelper
+
+class RtlStringPrinter(StringPrinterHelper):
+    '''Prints rtl_String or rtl_uString'''
+
+    def __init__(self, typename, val, encoding = None):
+        super(RtlStringPrinter, self).__init__(typename, val, encoding)
+
+    def data(self):
+        return self.val['buffer'].address
+
+    def length(self):
+        return self.val['length']
+
+class StringPrinter(StringPrinterHelper):
+    '''Prints rtl:: strings and string buffers'''
+
+    def __init__(self, typename, val, encoding = None):
+        super(StringPrinter, self).__init__(typename, val, encoding)
+
+    def valid(self):
+        return self.val['pData']
+
+    def data(self):
+        assert self.val['pData']
+        return self.val['pData'].dereference()['buffer'].address
+
+    def length(self):
+        assert self.val['pData']
+        return self.val['pData'].dereference()['length']
+
+class SalUnicodePrinter(StringPrinterHelper):
+    '''Prints a sal_Unicode*'''
+
+    def __init__(self, typename, val):
+        super(SalUnicodePrinter, self).__init__(typename, val, 'utf-16')
+
+    def data(self):
+        return self.val
+
+    @staticmethod
+    def query(type):
+        type = type.unqualified()
+        if type.code != gdb.TYPE_CODE_PTR:
+            return False
+        return str(type.target()) == 'sal_Unicode'
+
+class RtlReferencePrinter(object):
+    '''Prints rtl::Reference'''
+
+    def __init__(self, typename, val):
+        self.typename = typename
+        self.val = val
+
+    def to_string(self):
+        pointee = self.val['m_pBody']
+        if pointee:
+            return '%s to %s' % (self.typename, str(pointee))
+        else:
+            return "empty %s" % self.typename
+
+class OslFileStatusPrinter(object):
+    '''Prints oslFileStatus'''
+
+    def __init__(self, typename, val):
+        self.val = val
+
+    def to_string(self):
+        osl_file_type = gdb.lookup_type('oslFileType').strip_typedefs()
+        fields_to_enum_val = gdb.types.make_enum_dict(osl_file_type)
+
+        etype = self.field_val_if_valid('eType')
+        if etype is not None:
+            pretty_etype = '<unknown type>' # in case it's not one of the fields
+
+            for field_name, field_val in six.iteritems(fields_to_enum_val):
+                if etype == field_val:
+                    pretty_etype = self.pretty_file_type(field_name)
+        else:
+            pretty_etype = '<invalid type>'
+
+        file_url = self.field_val_if_valid('ustrFileURL')
+        if file_url is not None:
+            pretty_file_url = str(file_url.dereference())
+        else:
+            pretty_file_url = '<invalid file url>'
+
+        pretty_file_status = pretty_etype + ': ' + pretty_file_url
+
+        # for links append the link target if valid
+        if etype == fields_to_enum_val['osl_File_Type_Link']:
+            link_target = self.field_val_if_valid('ustrLinkTargetURL')
+            if link_target is None:
+                pretty_link_target = '<invalid link target>'
+            else:
+                pretty_link_target = str(link_target.dereference())
+
+            pretty_file_status += ' -> ' + pretty_link_target
+
+        return pretty_file_status
+
+    def pretty_file_type(self, file_type_name):
+        if file_type_name != 'osl_File_Type_Regular':
+            return file_type_name.replace('osl_File_Type_', '').lower()
+        else:
+            return 'file' # regular is not very descriptive, file is better
+
+    def field_val_if_valid(self, field):
+        mask_for_field = {'eType': 0x00000001,
+                          'uAttributes': 0x00000002,
+                          'aCreationTime': 0x00000010,
+                          'aAccessTime': 0x00000020,
+                          'aModifyTime': 0x00000040,
+                          'uFileSize': 0x00000080,
+                          'ustrFileName': 0x00000100,
+                          'ustrFileURL': 0x00000200,
+                          'ustrLinkTargetURL': 0x00000400}
+
+        valid_fields = self.val['uValidFields']
+        if valid_fields & mask_for_field[field]:
+            return self.val[field]
+        else:
+            return None
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer("libreoffice/sal")
+
+    # strings and string buffers
+    printer.add('_rtl_String', RtlStringPrinter)
+    printer.add('_rtl_uString', lambda name, val: RtlStringPrinter(name,
+        val, 'utf-16le'))
+    printer.add('rtl::OString', StringPrinter)
+    printer.add('rtl::OUString', lambda name, val: StringPrinter(name, val, 'utf-16'))
+    printer.add('rtl::OStringBuffer', StringPrinter)
+    printer.add('rtl::OUStringBuffer', lambda name, val: StringPrinter(name, val, 'utf-16'))
+    printer.add('sal_Unicode', SalUnicodePrinter, SalUnicodePrinter.query)
+
+    # other stuff
+    printer.add('rtl::Reference', RtlReferencePrinter)
+    printer.add('_oslFileStatus', OslFileStatusPrinter)
+
+    return printer
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/svl.py b/solenv/gdb/libreoffice/svl.py
new file mode 100644
index 000000000..f82b02a7b
--- /dev/null
+++ b/solenv/gdb/libreoffice/svl.py
@@ -0,0 +1,93 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+import six
+
+from libreoffice.util import printing
+
+class ItemSetPrinter(object):
+    '''Prints SfxItemSets'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        whichranges = self.which_ranges()
+        return "SfxItemSet of pool %s with parent %s and Which ranges: %s" \
+                % (self.value['m_pPool'], self.value['m_pParent'], whichranges)
+
+    def which_ranges(self):
+        whichranges = self.value['m_pWhichRanges']['m_pairs']
+        whichranges_cnt = self.value['m_pWhichRanges']['m_size']
+        whiches = []
+        for index in range(whichranges_cnt):
+            whiches.append((int(whichranges[index]['first']), int(whichranges[index]['second'])))
+        return whiches
+
+    def children(self):
+        whichranges = self.which_ranges()
+        size = 0
+        whichids = []
+        for (whichfrom, whichto) in whichranges:
+            size += whichto - whichfrom + 1
+            whichids += [which for which in range(whichfrom, whichto+1)]
+        return self._iterator(self.value['m_ppItems'], size, whichids)
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, data, count, whichids):
+            self.data = data
+            self.whichids = whichids
+            self.count = count
+            self.pos = 0
+            self._check_invariant()
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self.pos == self.count:
+                raise StopIteration()
+
+            which = self.whichids[self.pos]
+            elem = self.data[self.pos]
+            self.pos = self.pos + 1
+
+            self._check_invariant()
+            if (elem == -1):
+                elem = "(Invalid)"
+            elif (elem != 0):
+                # let's try how well that works...
+                elem = elem.cast(elem.dynamic_type).dereference()
+            return (str(which), elem)
+
+        def _check_invariant(self):
+            assert self.count >= 0
+            assert self.data
+            assert self.pos >= 0
+            assert self.pos <= self.count
+            assert len(self.whichids) == self.count
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer("libreoffice/svl")
+
+    printer.add('SfxItemSet', ItemSetPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/sw.py b/solenv/gdb/libreoffice/sw.py
new file mode 100644
index 000000000..707d0a425
--- /dev/null
+++ b/solenv/gdb/libreoffice/sw.py
@@ -0,0 +1,305 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import six
+import gdb
+from libreoffice.util import printing
+
+class SwPositionPrinter(object):
+    '''Prints SwPosition.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        node = self.value['nNode']['m_pNode'].dereference();
+        block = node['m_pBlock'].dereference();
+        nodeindex = block['nStart'] + node['m_nOffset']
+        offset = self.value['nContent']['m_nIndex']
+        return "%s (node %d, offset %d)" % (self.typename, nodeindex, offset)
+
+class SwNodeIndexPrinter(object):
+    '''Prints SwNodeIndex.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        node = self.value['m_pNode'].dereference();
+        block = node['m_pBlock'].dereference();
+        nodeindex = block['nStart'] + node['m_nOffset']
+        return "%s (node %d)" % (self.typename, nodeindex)
+
+class SwIndexPrinter(object):
+    '''Prints SwIndex.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        offset = self.value['m_nIndex']
+        return "%s (offset %d)" % (self.typename, offset)
+
+class SwPaMPrinter(object):
+    '''Prints SwPaM.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        next_ = self.value['m_pNext']
+        prev  = self.value['m_pPrev']
+        point = self.value['m_pPoint'].dereference()
+        mark = self.value['m_pMark'].dereference()
+        children = [ ( 'point', point), ( 'mark', mark ) ]
+        if next_ != self.value.address:
+            children.append(("next", next_))
+        if prev != self.value.address:
+            children.append(("prev", prev))
+        return children.__iter__()
+
+# apparently the purpose of this is to suppress printing all the extra members
+# that SwCursor and SwUnoCursor add
+class SwUnoCursorPrinter(SwPaMPrinter):
+    '''Prints SwUnoCursor.'''
+
+class SwRectPrinter(object):
+    '''Prints SwRect.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        point = self.value['m_Point']
+        size = self.value['m_Size']
+        children = [ ( 'point', point), ( 'size', size ) ]
+        return children.__iter__()
+
+class MarkBasePrinter(object):
+    '''Prints sw::mark::MarkBase.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        m = self.value.cast(self.value.dynamic_type)
+        return [ ( v, m[ v ] )
+            for v in ( 'm_aName', 'm_pPos1', 'm_pPos2' ) ].__iter__()
+
+class SwXTextRangeImplPrinter(object):
+    '''Prints SwXTextRange::Impl.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        mark = self.value['m_pMark'].dereference()
+        children = [('mark', mark)]
+        return children.__iter__()
+
+class SwXTextCursorPrinter(object):
+    '''Prints SwXTextCursor.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        cursor = self.value['m_pUnoCursor']["m_pCursor"]["_M_ptr"]
+        registeredIn = cursor.dereference()
+        children = [('m_pUnoCursor', registeredIn)]
+        return children.__iter__()
+
+class SwUnoImplPtrPrinter(object):
+    """Prints sw::UnoImplPtr"""
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        if self.value['m_p']:
+            return "%s %s" % (self.typename, self.value['m_p'].dereference())
+        else:
+            return "empty %s" % (self.typename,)
+
+class SwXTextRangePrinter(object):
+    '''Prints SwXTextRange.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s %s" % (self.typename, self.value['m_pImpl'])
+
+class BigPtrArrayPrinter(object):
+    '''Prints BigPtrArray.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        length = self.value['m_nSize']
+        if length > 0:
+            return "%s of length %d" % (self.typename, length)
+        else:
+            return "empty %s" % self.typename
+
+    def children(self):
+        return self._iterator(self.value)
+
+    def display_hint(self):
+        return 'array'
+
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, array):
+            # libstdc++ unique_ptr is a std::tuple which contains multiple
+            # _M_head_impl members and gdb may pick the wrong one by default
+            # so have to manually cast it to the one that contains the array
+            self.blocks = array['m_ppInf']['_M_t']['_M_t'].cast(gdb.lookup_type("std::_Head_base<0, BlockInfo**, false>"))['_M_head_impl']
+            self.count = array['m_nSize']
+            self.pos = 0
+            self.block_count = array['m_nBlock']
+            self.block_pos = 0
+            self.block = None
+            self.indent = ""
+            self.max_indent = "        "
+            self._next_block(False)
+            self._check_invariant()
+
+        def __iter__(self):
+            return self
+
+        def _node_value(self, node):
+            cur_indent = self.indent
+            if str(node.dynamic_type.target()) == "SwTextNode":
+                # accessing this is completely non-obvious...
+                # also, node.dynamic_cast(node.dynamic_type) is null?
+                value = "    TextNode " + \
+                  six.text_type(node.cast(node.dynamic_type).dereference()['m_Text'])
+            elif str(node.dynamic_type.target()) == "SwOLENode":
+                value = "     OLENode "
+            elif str(node.dynamic_type.target()) == "SwGrfNode":
+                value = "     GrfNode "
+            elif str(node.dynamic_type.target()) == "SwSectionNode":
+                value = " SectionNode "
+                self.indent += " "
+            elif str(node.dynamic_type.target()) == "SwTableNode":
+                value = "   TableNode "
+                self.indent += " "
+            elif str(node.dynamic_type.target()) == "SwStartNode":
+                value = "   StartNode "
+                self.indent += " "
+            elif str(node.dynamic_type.target()) == "SwEndNode":
+                value = "     EndNode "
+                self.indent = self.indent[:-1]
+                cur_indent = self.indent
+            elif str(node.dynamic_type.target()) == "SwDummySectionNode":
+                value = "DummySctNode "
+            else: # must be currently being deleted, so has some abstract type
+                value = "~DeletedNode "
+#            return "\n[%s%4d%s] %s %s" % (cur_indent, self.pos, \
+#                                self.max_indent[len(cur_indent):], node, value)
+            return "\n[%4d] %s%s%s %s" % (self.pos, cur_indent, \
+                                node, self.max_indent[len(cur_indent):], value)
+
+        def __next__(self):
+            if self.pos == self.count:
+                raise StopIteration()
+
+            name = str(self.pos)
+            node = self.block['mvData']['_M_elems'][self.pos - self.block['nStart']]
+            value =  self._node_value(node)
+            if self.pos == self.block['nEnd']:
+                self._next_block()
+            self.pos += 1
+
+            self._check_invariant()
+            return (name, value)
+
+        def _next_block(self, advance = True):
+            if advance:
+                self.block_pos += 1
+
+            if self.block_pos == self.block_count:
+                return
+
+            pblock = self.blocks[self.block_pos]
+            assert pblock
+            block = pblock.dereference()
+            start = block['nStart']
+            end = block['nEnd']
+            assert end - start + 1 == block['nElem']
+            if self.block:
+                assert start == self.block['nEnd'] + 1
+                assert end <= self.count
+            else:
+                assert start == 0
+            self.block = block
+
+        def _check_invariant(self):
+            assert self.pos <= self.count
+            assert self.block_pos <= self.block_count
+            if self.pos == 0 and self.pos < self.count:
+                assert self.block != None
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer("libreoffice/sw")
+    printer.add('BigPtrArray', BigPtrArrayPrinter)
+    printer.add('SwPosition', SwPositionPrinter)
+    printer.add('SwNodeIndex', SwNodeIndexPrinter)
+    printer.add('SwIndex', SwIndexPrinter)
+    printer.add('SwPaM', SwPaMPrinter)
+    printer.add('SwUnoCursor', SwUnoCursorPrinter)
+    printer.add('SwRect', SwRectPrinter)
+    printer.add('sw::mark::Bookmark', MarkBasePrinter)
+    printer.add('sw::mark::MarkBase', MarkBasePrinter)
+    printer.add('sw::mark::UnoMark', MarkBasePrinter)
+    printer.add('sw::mark::IMark', MarkBasePrinter)
+    printer.add('SwXTextRange::Impl', SwXTextRangeImplPrinter)
+    printer.add('sw::UnoImplPtr', SwUnoImplPtrPrinter)
+    printer.add('SwXTextRange', SwXTextRangePrinter)
+    printer.add('SwXTextCursor', SwXTextCursorPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/tl.py b/solenv/gdb/libreoffice/tl.py
new file mode 100644
index 000000000..8e15bfd47
--- /dev/null
+++ b/solenv/gdb/libreoffice/tl.py
@@ -0,0 +1,220 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+
+from libreoffice.util import printing
+
+class BigIntPrinter(object):
+    '''Prints big integer'''
+
+    def __init__(self, typename, val):
+        self.val = val
+
+    def to_string(self):
+        if self.val['bIsSet']:
+            if self.val['bIsBig']:
+                return self._value()
+            else:
+                return self.val['nVal']
+        else:
+            return "unset %s" % self.typename
+
+    def _value(self):
+        len = self.val['nLen']
+        digits = self.val['nNum']
+        dsize = digits.dereference().type.sizeof * 8
+        num = 0
+        # The least significant byte is on index 0
+        for i in reversed(range(0, len)):
+            num <<= dsize
+            num += digits[i]
+        return num
+
+class ColorPrinter(object):
+    '''Prints color as rgb(r, g, b) or rgba(r, g, b, a)'''
+
+    def __init__(self, typename, val):
+        self.val = val
+
+    def to_string(self):
+        r = self.val['R']
+        g = self.val['G']
+        b = self.val['B']
+        t = self.val['T']
+        if t:
+            return "rgba(%d, %d, %d, %d)" % (r, g, b, 255 - t)
+        else:
+            return "rgb(%d, %d, %d)" % (r, g, b)
+
+class DateTimeImpl(object):
+
+    def __init__(self, date, time):
+        self.date = date
+        self.time = time
+
+    def __str__(self):
+        result = ''
+        if self.date:
+            result += str(self.date)
+            if self.time:
+                result += ' '
+        if self.time:
+            result += str(self.time)
+        return result
+
+    @staticmethod
+    def parse(val):
+        return DateTimeImpl(DateImpl.parse(val), TimeImpl.parse(val))
+
+class DateTimePrinter(object):
+    '''Prints date and time'''
+
+    def __init__(self, typename, val):
+        self.val = val
+
+    def to_string(self):
+        return str(DateTimeImpl.parse(self.val))
+
+class DateImpl(DateTimeImpl):
+
+    def __init__(self, year, month, day):
+        super(DateImpl, self).__init__(self, None)
+        self.year = year
+        self.month = month
+        self.day = day
+
+    def __str__(self):
+        return "%d-%d-%d" % (self.year, self.month, self.day)
+
+    @staticmethod
+    def parse(val):
+        date = val['mnDate']
+        y = date / 10000
+        if date < 0:
+            date = -date
+        m = (date / 100) % 100
+        d = date % 100
+        return DateImpl(y, m, d)
+
+class DatePrinter(object):
+    '''Prints date'''
+
+    def __init__(self, typename, val):
+        self.val = val
+
+    def to_string(self):
+        return str(DateImpl.parse(self.val))
+
+class TimeImpl(DateTimeImpl):
+
+    def __init__(self, hour, minute, second, nanosecond = 0):
+        super(TimeImpl, self).__init__(None, self)
+        self.hour = hour
+        self.minute = minute
+        self.second = second
+        self.nanosecond = nanosecond
+
+    def __str__(self):
+        decimal = ''
+        if self.nanosecond != 0:
+            decimal = '.%09d' % self.nanosecond
+        return "%02d:%02d:%02d%s" % (self.hour, self.minute, self.second, decimal)
+
+    @staticmethod
+    def parse(val):
+        time = val['nTime']
+        h = time / 10000000000000
+        m = (time / 100000000000) % 100
+        s = (time / 1000000000) % 100
+        ns = time % 1000000000
+        return TimeImpl(h, m, s, ns)
+
+class TimePrinter(object):
+    '''Prints time'''
+
+    def __init__(self, typename, val):
+        self.val = val
+
+    def to_string(self):
+        return str(TimeImpl.parse(self.val))
+
+class PointPrinter(object):
+    '''Prints a Point.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        x = self.value['nA']
+        y = self.value['nB']
+        children = [('x', x), ('y', y)]
+        return children.__iter__()
+
+class SizePrinter(object):
+    '''Prints a Size.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        width = self.value['nA']
+        height = self.value['nB']
+        children = [('width', width), ('height', height)]
+        return children.__iter__()
+
+class RectanglePrinter(object):
+    '''Prints a Rectangle.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        left = self.value['nLeft']
+        top = self.value['nTop']
+        right = self.value['nRight']
+        bottom = self.value['nBottom']
+        children = [('left', left), ('top', top), ('right', right), ('bottom', bottom)]
+        return children.__iter__()
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer('libreoffice/tl')
+
+    # various types
+    printer.add('BigInt', BigIntPrinter)
+    printer.add('Color', ColorPrinter)
+    printer.add('DateTime', DateTimePrinter)
+    printer.add('Date', DatePrinter)
+    printer.add('Time', TimePrinter)
+    printer.add('Point', PointPrinter)
+    printer.add('Size', SizePrinter)
+    printer.add('Rectangle', RectanglePrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/util/__init__.py b/solenv/gdb/libreoffice/util/__init__.py
new file mode 100644
index 000000000..047763a18
--- /dev/null
+++ b/solenv/gdb/libreoffice/util/__init__.py
@@ -0,0 +1,11 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/util/compatibility.py b/solenv/gdb/libreoffice/util/compatibility.py
new file mode 100644
index 000000000..6d8070997
--- /dev/null
+++ b/solenv/gdb/libreoffice/util/compatibility.py
@@ -0,0 +1,20 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+
+use_gdb_printing = True
+try:
+    import gdb.printing
+except ImportError:
+    use_gdb_printing = False
+
+use_lazy_string = hasattr(gdb.Value, 'lazy_string')
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/util/printing.py b/solenv/gdb/libreoffice/util/printing.py
new file mode 100644
index 000000000..a31e353cf
--- /dev/null
+++ b/solenv/gdb/libreoffice/util/printing.py
@@ -0,0 +1,125 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+try:
+    from collections.abc import Mapping
+except:
+    from collections import Mapping
+import gdb
+import re
+import six
+
+from libreoffice.util.compatibility import use_gdb_printing
+
+class SimplePrinter(object):
+
+    def __init__(self, name, function):
+        self.name = name
+        self.function = function
+        self.enabled = True
+
+    def invoke(self, val):
+        if not self.enabled:
+            return None
+        return self.function(self.name, val)
+
+class NameLookup(Mapping):
+
+    def __init__(self):
+        self.map = {}
+        self.name_regex = re.compile(r'^([\w:]+)(<.*>)?')
+
+    def add(self, name, printer):
+        self.map[name] = printer
+
+    def __len__(self):
+        return len(self.map)
+
+    def __getitem__(self, type):
+        typename = self._basic_type(type)
+        if typename and typename in self.map:
+            return self.map[typename]
+        return None
+
+    def __iter__(self):
+        return self.map
+
+    def _basic_type(self, type):
+        basic_type = self.basic_type(type)
+        if basic_type:
+            match = self.name_regex.match(basic_type)
+            if match:
+                return match.group(1)
+        return None
+
+    @staticmethod
+    def basic_type(type):
+        if type.code == gdb.TYPE_CODE_REF:
+            type = type.target()
+        type = type.unqualified().strip_typedefs()
+        return type.tag
+
+class FunctionLookup(Mapping):
+
+    def __init__(self):
+        self.map = {}
+
+    def add(self, test, printer):
+        self.map[test] = printer
+
+    def __len__(self):
+        return len(self.map)
+
+    def __getitem__(self, type):
+        for (test, printer) in six.iteritems(self.map):
+            if test(type):
+                return printer
+        return None
+
+    def __iter__(self):
+        return self.map
+
+class Printer(object):
+
+    def __init__(self, name):
+        self.name = name
+        self.subprinters = []
+        self.name_lookup = NameLookup()
+        self.func_lookup = FunctionLookup()
+        self.enabled = True
+
+    def add(self, name, function, lookup = None):
+        printer = SimplePrinter(name, function)
+        self.subprinters.append(printer)
+        if not lookup:
+            self.name_lookup.add(name, printer)
+        else:
+            self.func_lookup.add(lookup, printer)
+
+
+    def __call__(self, val):
+        printer = self.name_lookup[val.type]
+        if not printer:
+            printer = self.func_lookup[val.type]
+
+        if printer:
+            return printer.invoke(val)
+        return None
+
+def register_pretty_printer(printer, obj):
+    '''Registers printer with objfile'''
+
+    if use_gdb_printing:
+        gdb.printing.register_pretty_printer(obj, printer)
+    else:
+        if obj is None:
+            obj = gdb
+        obj.pretty_printers.append(printer)
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/util/string.py b/solenv/gdb/libreoffice/util/string.py
new file mode 100644
index 000000000..742aabbac
--- /dev/null
+++ b/solenv/gdb/libreoffice/util/string.py
@@ -0,0 +1,75 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+
+from libreoffice.util.compatibility import use_lazy_string
+
+class StringPrinterHelper(object):
+    '''Base for all string pretty printers'''
+
+    class MustBeImplemented(Exception):
+        pass
+
+    def __init__(self, typename, val, encoding = None):
+        self.typename = typename
+        self.val = val
+        self.encoding = encoding
+
+    def to_string(self):
+        if self.valid():
+            data = self.data()
+            len = self.length()
+            return self.make_string(data, self.encoding, len)
+        else:
+            return "uninitialized %s" % self.typename
+
+    def display_hint(self):
+        if self.valid():
+            return 'string'
+        else:
+            return None
+
+    def valid(self):
+        return True
+
+    def data(self):
+        raise self.MustBeImplemented()
+
+    def length(self):
+        return -1
+
+    @staticmethod
+    def make_string(data, encoding = None, length = -1):
+        '''Creates a new string from memory'''
+
+        if not encoding:
+            encoding = ''
+
+        # we need to determine length, if not given (for sal_Unicode*)
+        if length < 0:
+            length = 0
+            while data[length] != 0 and length <= 512: # arbitrary limit
+                length += 1
+
+        if use_lazy_string:
+            return data.lazy_string(encoding, length)
+
+        # The gdb.Value.string() conversion works on array of bytes, but
+        # the length we have is the length of the string. So we must
+        # multiply it by width of character if the string is Unicode.
+        width = data[0].type.sizeof
+        if width > 1:
+            length = length * width
+
+        char = gdb.lookup_type('char')
+        bytes = data.cast(char.pointer())
+        return bytes.string(encoding, length = length)
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/util/uno.py b/solenv/gdb/libreoffice/util/uno.py
new file mode 100644
index 000000000..2f0d83a6b
--- /dev/null
+++ b/solenv/gdb/libreoffice/util/uno.py
@@ -0,0 +1,516 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+import re
+import six
+
+class UnsupportedType(Exception):
+    '''Represents exception thrown when an unsupported UNO type(like
+        array or union) is used.'''
+
+    def __init__(self, type):
+        self.type = type
+
+class UnknownType(Exception):
+    '''Represents exception thrown when an unknown UNO type is used.'''
+
+    def __init__(self, type):
+        self.type = type
+
+class TypeClass(object):
+    '''Represents type class of UNO type.'''
+
+    # type class of void
+    VOID = 0
+    # type class of char
+    CHAR = 1
+    # type class of boolean
+    BOOLEAN = 2
+    # type class of byte
+    BYTE = 3
+    # type class of short
+    SHORT = 4
+    # type class of unsigned short
+    UNSIGNED_SHORT = 5
+    # type class of long
+    LONG = 6
+    # type class of unsigned long
+    UNSIGNED_LONG = 7
+    # type class of hyper
+    HYPER = 8
+    # type class of unsigned hyper
+    UNSIGNED_HYPER = 9
+    # type class of float
+    FLOAT = 10
+    # type class of double
+    DOUBLE = 11
+    # type class of string
+    STRING = 12
+    # type class of type
+    TYPE = 13
+    # type class of any
+    ANY = 14
+    # type class of enum
+    ENUM = 15
+    # type class of typedef
+    TYPEDEF = 16
+    # type class of struct
+    STRUCT = 17
+
+    # type class of exception
+    EXCEPTION = 19
+    # type class of sequence
+    SEQUENCE = 20
+
+    # type class of interface
+    INTERFACE = 22
+    # type class of service (not implemented)
+    SERVICE = 23
+    # type class of module (not implemented)
+    MODULE = 24
+    # type class of interface method
+    INTERFACE_METHOD = 25
+    # type class of interface attribute
+    INTERFACE_ATTRIBUTE = 26
+    # type class of unknown type
+    UNKNOWN = 27
+    # type class of properties
+    PROPERTY = 28
+    # type class of constants
+    CONSTANT = 29
+    # type class of constants groups
+    CONSTANTS = 30
+    # type class of singletons
+    SINGLETON = 31
+
+class TemplateType(object):
+
+    def __init__(self, template, *args):
+        self.template = template
+        self.args = args
+
+    def __str__(self):
+        argtypes = [str(gdb.lookup_type(str(arg)).strip_typedefs()) for arg in self.args]
+        return self.template + '<' + ', '.join(argtypes) + '>'
+
+class Type(object):
+    '''Describes a UNO type.'''
+
+    def __init__(self, typeclass, tag):
+        '''Constructs a new Type.
+            @param[in] typeclass value of com::sun::star::uno::TypeClass
+            @param[in] tag UNO name of the type
+        '''
+        self.typeclass = typeclass
+        self.tag = tag
+        # C++ name of the type
+        self.typename = None
+
+    def type(self):
+        '''Gets gdb.Type for the type'''
+        if self.typename:
+            return gdb.lookup_type(str(self.typename))
+        return None
+
+    @staticmethod
+    def uno2cpp(typename):
+        return str(typename).replace('.', '::')[1:-1]
+
+    def strip_typedefs(self):
+        copy = self.copy()
+        copy.typename = self._strip_typedefs(self.typename)
+        return copy
+
+    def _strip_typedefs(self, typename):
+        template_args = re.compile('([^<]+)(<.*>)')
+        match = template_args.match(typename)
+        type = self._lookup_type(match.group(1))
+        types = []
+        if match.group(2):
+            list_delim = re.compile(', *')
+            # FIXME: this does not work with nested templates
+            for arg in match.group(2).split(list_delim):
+                types.append(self._lookup_type(arg))
+
+        typename = str(type)
+        if not types.empty():
+            typename += '<' + types.join(', ') + '>'
+
+        return typename
+
+    def _lookup_type(self, typename):
+        if typename != '':
+            type = gdb.lookup_type(typename)
+            if type:
+                type = type.strip_typedefs()
+        return type
+
+def make_uno_type(val):
+    '''Creates a UNO type from gdb.Value of type
+        com::sun::star::uno::Type, typelib_TypeDescription, or
+        typelib_TypeDescriptionReference
+    '''
+
+    cssu_type = 'com::sun::star::uno::Type'
+    type_desc = '_typelib_TypeDescription'
+    type_descs =(
+            type_desc,
+            '_typelib_CompoundTypeDescription',
+            '_typelib_StructTypeDescription',
+            '_typelib_IndirectTypeDescription',
+            '_typelib_EnumTypeDescription',
+            '_typelib_InterfaceMemberTypeDescription',
+            '_typelib_InterfaceMethodTypeDescription',
+            '_typelib_InterfaceAttributeTypeDescription',
+            '_typelib_InterfaceTypeDescription'
+    )
+    type_desc_ref = '_typelib_TypeDescriptionReference'
+
+    type = val.type.strip_typedefs()
+
+    if type.tag == cssu_type:
+        pvalue = val['_pType']
+        assert pvalue
+        val = pvalue.dereference()
+        type = val.type.strip_typedefs()
+
+    while type.tag == type_desc_ref:
+        pvalue = val['pType']
+        assert pvalue
+        val = pvalue.dereference()
+        type = val.type.strip_typedefs()
+
+    if type.tag not in type_descs:
+        return None
+
+    # determination of the UNO type
+    full_val = val
+    if type.tag != type_desc:
+        while 'aBase' in val:
+            val = val['aBase']
+    type_class = int(val['eTypeClass'])
+    name = val['pTypeName'].dereference()
+    uno_type = None
+    if type_class == TypeClass.VOID:
+        uno_type = VoidType()
+    elif type_class == TypeClass.CHAR:
+        uno_type = PrimitiveType(type_class, name, 'char')
+    elif type_class == TypeClass.BOOLEAN:
+        uno_type = PrimitiveType(type_class, name, 'sal_Bool')
+    elif type_class == TypeClass.BYTE:
+        uno_type = PrimitiveType(type_class, name, 'sal_Int8')
+    elif type_class == TypeClass.SHORT:
+        uno_type = PrimitiveType(type_class, name, 'sal_Int16')
+    elif type_class == TypeClass.UNSIGNED_SHORT:
+        uno_type = PrimitiveType(type_class, name, 'sal_uInt16')
+    elif type_class == TypeClass.LONG:
+        uno_type = PrimitiveType(type_class, name, 'sal_Int32')
+    elif type_class == TypeClass.UNSIGNED_LONG:
+        uno_type = PrimitiveType(type_class, name, 'sal_uInt32')
+    elif type_class == TypeClass.HYPER:
+        uno_type = PrimitiveType(type_class, name, 'sal_Int64')
+    elif type_class == TypeClass.UNSIGNED_HYPER:
+        uno_type = PrimitiveType(type_class, name, 'sal_uInt64')
+    elif type_class == TypeClass.FLOAT:
+        uno_type = PrimitiveType(type_class, name, 'float')
+    elif type_class == TypeClass.DOUBLE:
+        uno_type = PrimitiveType(type_class, name, 'double')
+    elif type_class == TypeClass.STRING:
+        uno_type = PrimitiveType(type_class, name, 'rtl::OUString')
+    elif type_class == TypeClass.TYPE:
+        uno_type = PrimitiveType(type_class, name, 'com::sun::star::uno::Type')
+    elif type_class == TypeClass.ANY:
+        uno_type = PrimitiveType(type_class, name, 'com::sun::star::uno::Any')
+    elif type_class == TypeClass.ENUM:
+        uno_type = EnumType(val, full_val)
+    elif type_class == TypeClass.TYPEDEF:
+        pass
+    elif type_class == TypeClass.STRUCT:
+        uno_type = StructType(val, full_val)
+    elif type_class == TypeClass.EXCEPTION:
+        uno_type = CompoundType(val, full_val)
+    elif type_class == TypeClass.SEQUENCE:
+        uno_type = IndirectType(val, full_val)
+    elif type_class == TypeClass.INTERFACE:
+        uno_type = InterfaceType(val, full_val)
+    elif type_class == TypeClass.SERVICE:
+        raise UnsupportedType('service')
+    elif type_class == TypeClass.MODULE:
+        raise UnsupportedType('module')
+    elif type_class == TypeClass.INTERFACE_METHOD:
+        uno_type = InterfaceMethodType(val, full_val)
+    elif type_class == TypeClass.INTERFACE_ATTRIBUTE:
+        uno_type = InterfaceAttributeType(val, full_val)
+    elif type_class == TypeClass.UNKNOWN:
+        raise UnknownType(type)
+    elif type_class == TypeClass.PROPERTY:
+        pass
+    elif type_class == TypeClass.CONSTANT:
+        pass
+    elif type_class == TypeClass.CONSTANTS:
+        pass
+    elif type_class == TypeClass.SINGLETON:
+        pass
+    else:
+        raise UnknownType(type)
+
+    assert uno_type
+    return uno_type
+
+def uno_cast(type, val):
+    '''Casts val or pointer to UNO type represented by type'''
+    if val.type.code == gdb.TYPE_CODE_PTR:
+        return val.cast(type.type().pointer())
+    else:
+        return val.cast(type.type())
+
+class VoidType(Type):
+
+    def __init__(self):
+        super(VoidType, self).__init__(TypeClass.VOID, "void")
+        self.typename = "void"
+
+class PrimitiveType(Type):
+
+    def __init__(self, typeclass, typename_uno, typename_cpp):
+        super(PrimitiveType, self).__init__(typeclass, typename_uno)
+        self.typename = str(typename_cpp)
+
+class CompoundType(Type):
+
+    def __init__(self, type, full_type):
+        super(CompoundType, self).__init__(type['eTypeClass'], type['pTypeName'].dereference())
+        self.typename = self.uno2cpp(self.tag)
+        self._type = full_type
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, count, types, names):
+            self.count = count
+            self.members = members
+            self.names = names
+            self.pos = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            assert self.pos >= 0 and self.pos <= self.count
+            if self.pos == self.count:
+                raise StopIteration
+
+            pmember = self.members[self.pos]
+            assert pmember
+            pname = self.names[self.i]
+            assert pname
+            self.pos = self.pos + 1
+            member = make_uno_type(pmember.dereference())
+            assert member
+            name = str(pname.dereference())
+            return (name, member)
+
+    def attributes(self):
+        return _iterator(self._type['nMembers'], self._type['ppTypeRefs'],
+                self._type['ppMemberNames'])
+
+class StructType(CompoundType):
+
+    def __init__(self, type, full_type):
+        full_type = full_type.cast(gdb.lookup_type('_typelib_StructTypeDescription'))
+        super(StructType, self).__init__(type, full_type['aBase'])
+
+class IndirectType(Type):
+
+    def __init__(self, type, full_type):
+        super(IndirectType, self).__init__(type['eTypeClass'], type['pTypeName'].dereference())
+        full_type = full_type.cast(gdb.lookup_type('_typelib_IndirectTypeDescription'))
+        pelem = full_type['pType']
+        assert pelem
+        self.element = make_uno_type(pelem.dereference())
+        assert self.element
+        self.typename = TemplateType('com::sun::star::uno::Sequence', self.element.typename)
+
+class EnumType(Type):
+
+    def __init__(self, type, full_type):
+        super(EnumType, self).__init__(TypeClass.ENUM, type['pTypeName'].dereference())
+        self.typename = self.uno2cpp(self.tag)
+        self._type = full_type.cast(gdb.lookup_type('_typelib_EnumTypeDescription'))
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, count, values, names):
+            self.count = count
+            self.values = values
+            self.names = names
+            self.pos = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            assert self.pos >= 0 and self.pos <= self.count
+            if self.pos == self.count:
+                raise StopIteration
+
+            pvalue = self.values[self.pos]
+            assert pvalue
+            pname = self.names[self.pos]
+            assert pname
+            self.pos = self.pos + 1
+            val = int(pvalue.dereference())
+            name = str(pname.dereference())
+            return (name, val)
+
+    def values(self):
+        return _iterator(self._type['nEnumValues'],
+                self._type['ppEnumNames'], self._type['pEnumValues'])
+
+    def default_value(self):
+        return self._type['nDefaultEnumValue']
+
+class InterfaceMemberType(Type):
+
+    def __init__(self, type, full_type):
+        super(InterfaceMemberType, self).__init__(type['eTypeClass'], type['pTypeName'].dereference())
+        (interface, delim, member) = self.tag.partition('::')
+        self.typename = self.uno2cpp(interface) + '::*' + member
+        full_type = full_type.cast(gdb.lookup_type('_typelib_InterfaceMemberTypeDescription'))
+        self.position = full_type['nPosition']
+        pname = full_type['pMemberName']
+        assert pname
+        self.name = pname.dereference()
+
+class InterfaceMethodType(InterfaceMemberType):
+
+    def __init__(self, type, full_type):
+        full_type = full_type.cast(gdb.lookup_type('_typelib_InterfaceMethodTypeDescription'))
+        super(InterfaceMethodType, self).__init__(type, full_type['aBase'])
+        pret = full_type['pReturnTypeRef']
+        assert pret
+        self.return_type = make_uno_type(pret.dereference())
+        assert self.return_type
+        self.oneway = full_type['bOneWay']
+        self._type = full_type
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, count, values):
+            self.count = count
+            self.values = values
+            self.pos = 0
+            assert values
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            assert self.pos >= 0 and self.pos <= self.count
+            if self.pos == self.count:
+                raise StopIteration
+
+            val = self.values[self.pos]
+            self.pos = self.pos + 1
+            return val
+
+    class parameter(tuple):
+
+        def __init__(self, type):
+            self.__init_tuple(type)
+            self.input = type['bIn']
+            self.output = type['bOut']
+
+        def _init_tuple(self, type):
+            pname = self['pName']
+            assert pname
+            ptype = self['pTypeRef']
+            assert ptype
+            name = str(pname.dereference())
+            type = make_uno_type(ptype.dereference())
+            assert type
+            super(parameter, self).__init__(name, type)
+
+    def parameters(self):
+        for param in _iterator(self._type['nParams'], self._type['pParams']):
+            yield parameter(param)
+
+    def exceptions(self):
+        def make_exception(self, pex):
+            assert pex
+            ex = make_uno_type(pex.dereference())
+            assert ex
+            return ex
+
+        for ex in _iterator(
+                self._type['nExceptions'], self._type['ppExceptions']):
+            yield make_exception(ex)
+
+class InterfaceAttributeType(InterfaceMemberType):
+
+    def __init__(self, type, full_type):
+        full_type = full_type.cast(gdb.lookup_type('_typelib_InterfaceAttributeTypeDescription'))
+        super(InterfaceAttributeType, self).__init__(type, full_type['aBase'])
+        self.readonly = full_type['bReadOnly']
+        ptype = full_type['pAttributeTypeRef']
+        assert ptype
+        self.type = make_uno_type(ptype.dereference())
+        assert self.type
+
+class MembersNotInitialized(Exception):
+    '''Represents exception raised when interface type' members haven't
+        been initialized(i.e. just level 1 initialization has been
+        performed)'''
+    pass
+
+class InterfaceType(Type):
+
+    def __init__(self, type, full_type):
+        super(InterfaceType, self).__init__(TypeClass.INTERFACE, type['pTypeName'].dereference())
+        assert int(type['eTypeClass']) == TypeClass.INTERFACE
+        self.typename = self.uno2cpp(self.tag)
+        full_type = full_type.cast(gdb.lookup_type('_typelib_InterfaceTypeDescription'))
+        self.uik = full_type['aUik']
+        self._type = full_type
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, count, values):
+            assert values
+            self.count = count
+            self.values = values
+            self.pos = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            assert self.pos >= 0 and self.pos <= self.count
+            pvalue = self.values[self.pos]
+            assert pvalue
+            self.pos = self.pos + 1
+            uno = make_uno_type(pvalue.dereference())
+            assert uno
+            return uno
+
+    def members(self):
+        return __members(self._type['nMembers'], self._type['ppMembers'])
+
+    def all_members(self):
+        return __members(self._type['nAllMembers'], self._type['ppAllMembers'])
+
+    def __members(count, values):
+        if values == 0:
+            raise MembersNotInitialized
+        return _iterator(count, values)
+
+    def bases(self):
+        return _iterator(self._type['nBaseTypes'], self._type['ppBaseTypes'])
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/utl.py b/solenv/gdb/libreoffice/utl.py
new file mode 100644
index 000000000..0e6de6ff9
--- /dev/null
+++ b/solenv/gdb/libreoffice/utl.py
@@ -0,0 +1,39 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import gdb
+
+from libreoffice.util import printing
+
+class TranslateIdPrinter(object):
+    '''Prints a TranslateId.'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return self.value['mpContext'].format_string(format='s') + " " + self.value['mpId'].format_string(format='s')
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer('libreoffice/utl')
+
+    # various types
+    printer.add('TranslateId', TranslateIdPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/vcl.py b/solenv/gdb/libreoffice/vcl.py
new file mode 100644
index 000000000..ce5957475
--- /dev/null
+++ b/solenv/gdb/libreoffice/vcl.py
@@ -0,0 +1,123 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+import six
+import gdb
+from libreoffice.util import printing
+
+class ImplSchedulerDataPrinter(object):
+    '''Prints the ImplSchedulerData linked list.
+
+       This can be used to dump the current state of the scheduler via:
+          p *ImplGetSVData()->maSchedCtx.mpFirstSchedulerData
+
+       This doesn't include currently invoked tasks AKA the stack.
+
+       To dump the scheduler stack of invoked tasks use:
+          p *ImplGetSVData()->maSchedCtx.mpSchedulerStack
+    '''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+        self.timer_type_ptr = gdb.lookup_type("Timer").pointer()
+        self.idle_type_ptr = gdb.lookup_type("Idle").pointer()
+
+    def as_string(self, gdbobj):
+        if gdbobj['mpTask']:
+            task  = gdbobj['mpTask'].dereference()
+            timer = gdbobj['mpTask'].dynamic_cast( self.timer_type_ptr )
+            idle  = gdbobj['mpTask'].dynamic_cast( self.idle_type_ptr )
+            if idle:
+                task_type = "Idle"
+            elif timer:
+                task_type = "Timer"
+            else:
+                task_type = "Task"
+            res = "{:7s}{:10s} active: {:6s}".format( task_type, str(task['mePriority']).replace('TaskPriority::',''), str(task['mbActive']) )
+            name = task['mpDebugName']
+            if not name:
+                res = res + "   (task debug name not set)"
+            else:
+                res = "{} '{}' ({})".format(res, str(name.string()), str(task.dynamic_type))
+            val_type = gdb.lookup_type(str( task.dynamic_type )).pointer()
+            timer = gdbobj['mpTask'].cast( val_type )
+            if task_type == "Timer":
+                res = "{}: {}ms".format(res, timer['mnTimeout'])
+            elif task_type == "Idle":
+                assert 0 == timer['mnTimeout'], "Idle with timeout == {}".format( timer['mnTimeout'] )
+            return res
+        else:
+            return "(no task)"
+
+    def to_string(self):
+        return self.typename
+
+    def children(self):
+        return self._iterator(self)
+
+    def display_hint(self):
+        return 'array'
+
+    class _iterator(six.Iterator):
+
+        def __init__(self, printer):
+            self.pos = 0
+            self.printer = printer
+            self.value = printer.value
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if not self.value:
+                raise StopIteration()
+
+            pos = str(self.pos)
+            name = "\n  " + self.printer.as_string(self.value)
+            self.value = self.value['mpNext']
+            self.pos += 1
+
+            return (pos, name)
+
+class ImplSchedulerContextPrinter(object):
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+        self.prio = gdb.lookup_type('TaskPriority')
+
+    def to_string(self):
+        res = "{\n"
+        if self.value['mnTimerPeriod']:
+            res = res + "mnTimerPeriod = " + str(self.value['mnTimerPeriod']) + "\n"
+        if self.value['mpSchedulerStack']:
+            res = res + "STACK, " + str(self.value['mpSchedulerStack'].dereference())
+        if self.value['mpFirstSchedulerData']:
+            for key, value in self.prio.items():
+                first = self.value['mpFirstSchedulerData'][value.enumval]
+                if first:
+                    res = res + key.replace('TaskPriority::', '') + ", " + str(first.dereference())
+        return res + "}"
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer("libreoffice/vcl")
+    printer.add('ImplSchedulerData', ImplSchedulerDataPrinter)
+    printer.add('ImplSchedulerContext', ImplSchedulerContextPrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/libreoffice/writerfilter.py b/solenv/gdb/libreoffice/writerfilter.py
new file mode 100644
index 000000000..487263e92
--- /dev/null
+++ b/solenv/gdb/libreoffice/writerfilter.py
@@ -0,0 +1,88 @@
+# -*- tab-width: 4; indent-tabs-mode: nil; py-indent-offset: 4 -*-
+#
+# This file is part of the LibreOffice project.
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+#
+
+from libreoffice.util import printing
+
+class OOXMLPropertySetPrinter(object):
+    '''Prints writerfilter::ooxml::OOXMLPropertySet'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        children = [ ( 'properties', self.value['mProperties'] ) ]
+        return children.__iter__()
+
+class OOXMLPropertyPrinter(object):
+    '''Prints writerfilter::ooxml::OOXMLProperty'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+    def children(self):
+        children = [ ( 'id', self.value['mId'] ),
+                     ( 'type', self.value['meType'] ),
+                     ( 'value', self.value['mpValue'] ) ]
+        return children.__iter__()
+
+class OOXMLPropertySetValuePrinter(object):
+    '''Prints writerfilter::ooxml::OOXMLPropertySetValue'''
+
+    def __init__(self, typename, value):
+        self.typename = typename
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.typename)
+
+class OOXMLStringValuePrinter(object):
+    '''Prints writerfilter::ooxml::OOXMLStringValue'''
+
+    def __init__(self, typename, value):
+        self.value = value
+
+    def to_string(self):
+        return "%s" % (self.value['mStr'])
+
+class OOXMLIntegerValuePrinter(object):
+    '''Prints writerfilter::ooxml::OOXMLIntegerValue'''
+
+    def __init__(self, typename, value):
+        self.value = value
+
+    def to_string(self):
+        return "%d" % (self.value['mnValue'])
+
+printer = None
+
+def build_pretty_printers():
+    global printer
+
+    printer = printing.Printer("libreoffice/writerfilter")
+    printer.add('writerfilter::ooxml::OOXMLProperty', OOXMLPropertyPrinter)
+    printer.add('writerfilter::ooxml::OOXMLPropertySet', OOXMLPropertySetPrinter)
+    printer.add('writerfilter::ooxml::OOXMLPropertySetValue', OOXMLPropertySetValuePrinter)
+    printer.add('writerfilter::ooxml::OOXMLStringValue', OOXMLStringValuePrinter)
+    printer.add('writerfilter::ooxml::OOXMLIntegerValue', OOXMLIntegerValuePrinter)
+    printer.add('writerfilter::ooxml::OOXMLHexValue', OOXMLIntegerValuePrinter)
+
+def register_pretty_printers(obj):
+    printing.register_pretty_printer(printer, obj)
+
+build_pretty_printers()
+
+# vim:set shiftwidth=4 softtabstop=4 expandtab:
diff --git a/solenv/gdb/six.py b/solenv/gdb/six.py
new file mode 100644
index 000000000..5fe9f8e14
--- /dev/null
+++ b/solenv/gdb/six.py
@@ -0,0 +1,980 @@
+# Copyright (c) 2010-2020 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.14.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("getoutput", "commands", "subprocess"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("splitvalue", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("URLopener", "urllib", "urllib.request"),
+    MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+    MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
+    MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
+]
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    del io
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+        _assertNotRegex = "assertNotRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+        _assertNotRegex = "assertNotRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+    _assertNotRegex = "assertNotRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+def assertNotRegex(self, *args, **kwargs):
+    return getattr(self, _assertNotRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        try:
+            if value is None:
+                value = tp()
+            if value.__traceback__ is not tb:
+                raise value.with_traceback(tb)
+            raise value
+        finally:
+            value = None
+            tb = None
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    try:
+        raise tp, value, tb
+    finally:
+        tb = None
+""")
+
+
+if sys.version_info[:2] > (3,):
+    exec_("""def raise_from(value, from_value):
+    try:
+        raise value from from_value
+    finally:
+        value = None
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    # This does exactly the same what the :func:`py3:functools.update_wrapper`
+    # function does on Python versions after 3.2. It sets the ``__wrapped__``
+    # attribute on ``wrapper`` object and it doesn't raise an error if any of
+    # the attributes mentioned in ``assigned`` and ``updated`` are missing on
+    # ``wrapped`` object.
+    def _update_wrapper(wrapper, wrapped,
+                        assigned=functools.WRAPPER_ASSIGNMENTS,
+                        updated=functools.WRAPPER_UPDATES):
+        for attr in assigned:
+            try:
+                value = getattr(wrapped, attr)
+            except AttributeError:
+                continue
+            else:
+                setattr(wrapper, attr, value)
+        for attr in updated:
+            getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+        wrapper.__wrapped__ = wrapped
+        return wrapper
+    _update_wrapper.__doc__ = functools.update_wrapper.__doc__
+
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        return functools.partial(_update_wrapper, wrapped=wrapped,
+                                 assigned=assigned, updated=updated)
+    wraps.__doc__ = functools.wraps.__doc__
+
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+
+        def __new__(cls, name, this_bases, d):
+            if sys.version_info[:2] >= (3, 7):
+                # This version introduced PEP 560 that requires a bit
+                # of extra care (we mimic what is done by __build_class__).
+                resolved_bases = types.resolve_bases(bases)
+                if resolved_bases is not bases:
+                    d['__orig_bases__'] = bases
+            else:
+                resolved_bases = bases
+            return meta(name, resolved_bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        if hasattr(cls, '__qualname__'):
+            orig_vars['__qualname__'] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def ensure_binary(s, encoding='utf-8', errors='strict'):
+    """Coerce **s** to six.binary_type.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> encoded to `bytes`
+      - `bytes` -> `bytes`
+    """
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    elif isinstance(s, binary_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def ensure_str(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to `str`.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if not isinstance(s, (text_type, binary_type)):
+        raise TypeError("not expecting type '%s'" % type(s))
+    if PY2 and isinstance(s, text_type):
+        s = s.encode(encoding, errors)
+    elif PY3 and isinstance(s, binary_type):
+        s = s.decode(encoding, errors)
+    return s
+
+
+def ensure_text(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to six.text_type.
+
+    For Python 2:
+      - `unicode` -> `unicode`
+      - `str` -> `unicode`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif isinstance(s, text_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A class decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)