printers.py

Go to the documentation of this file.

import gdb
import math
import re
import sys

try:
    debug  # noqa F821
except Exception:
    debug = False

import optparse
argparse = None                         # we're using optparse


class GdbOptionParser(optparse.OptionParser):
    """A subclass of the standard optparse OptionParser for gdb

GdbOptionParser raises GdbError rather than exiting when asked for help, or
when given an illegal value. E.g.

parser = gdb.printing.GdbOptionParser("show image")
parser.add_option("-a", "--all", action="store_true",
                  help="Display the whole image")
parser.add_option("-w", "--width", type="int", default=8,
                  help="Field width for pixels")

opts, args =  parser.parse_args(args)
"""

    def __init__(self, prog, *args, **kwargs):
        """
Like optparse.OptionParser's API, but with an initial command name argument
"""
        # OptionParser is an old-style class, so no super
        if not kwargs.get("prog"):
            kwargs["prog"] = prog
        optparse.OptionParser.__init__(self, *args, **kwargs)

    def parse_args(self, args, values=None):
        """Call OptionParser.parse_args after running gdb.string_to_argv"""
        if args is None:            # defaults to sys.argv
            args = ""
        try:
            args = gdb.string_to_argv(args)
        except TypeError:
            pass

        help = ("-h" in args or "--help" in args)
        opts, args = optparse.OptionParser.parse_args(self, args, values)
        opts.help = help
        if help:
            args = []

        return opts, args

    def exit(self, status=0, msg=""):
        """Raise GdbError rather than exiting"""
        if status == 0:
            if msg:
                print(msg, file=sys.stderr)
        else:
            raise gdb.GdbError(msg)


try:
    import gdb.printing

    class SharedPtrPrinter:
        "Print a shared_ptr"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            if self.val["px"]:
                return "shared_ptr(%s)" % self.val["px"].dereference()
            else:
                return "NULL"

    class GilPixelPrinter:
        "Print a boost::gil pixel"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            import pdb
            pdb.set_trace()
            return self.val["_v0"]

    def getEigenMatrixDimensions(val):
        m_storage = val["m_storage"]
        try:
            nx, ny = m_storage["m_cols"], m_storage["m_rows"]
        except gdb.error:           # only available for dynamic Matrices
            try:
                nx, ny = val.type.template_argument(1), \
                    val.type.template_argument(2)
            except RuntimeError:
                # should get dimens from template, but that's gdb bug #11060
                size = m_storage["m_data"]["array"].type.sizeof
                size0 = m_storage["m_data"]["array"].dereference().type.sizeof
                # guess! Assume square
                nx = int(math.sqrt(size/size0))
                ny = size/(nx*size0)

        return nx, ny

    def getEigenValue(var, x, y=0):
        if re.search(r"Matrix", str(var.type)):
            if False:
                return var["operator()(int, int)"](x, y)

            NX, NY = getEigenMatrixDimensions(var)

            if x < 0 or x >= NX or y < 0 or y >= NY:
                raise gdb.GdbError("Element (%d, %d) is out of range 0:%d, 0:%d" %
                                   (x, y, NX - 1, NY - 1))

            m_data = var["m_storage"]["m_data"]
            if False:
                # convert to a pointer to the start of the array
                import pdb
                pdb.set_trace()
                m_data = m_data.address.cast(m_data.type)

            try:
                val = m_data[x + y*NX]
            except Exception:
                val = m_data["array"][x + y*NX]
        else:                       # Vector
            if False:
                return var["operator()(int)"](x)

            NX = getEigenMatrixDimensions(var)[0]

            if x < 0 or x >= NX:
                raise gdb.GdbError(
                    "Element (%d) is out of range 0:%d" % (x, NX - 1))

            m_data = var["m_storage"]["m_data"]

            if False:
                # convert to a pointer to the start of the array
                m_data = m_data.address.cast(m_data.type)

            try:
                val = m_data[x]
            except Exception:
                val = m_data["array"][x]

        if val.type.code == gdb.TYPE_CODE_INT:
            val = int(val)
        elif val.type.code == gdb.TYPE_CODE_FLT:
            val = float(val)

        return val

    class EigenMatrixPrinter:
        "Print an Eigen Matrix"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            nx, ny = getEigenMatrixDimensions(self.val)

            return "%s{%dx%d}" % (self.val.type, nx, ny)

    class EigenVectorPrinter:
        "Print an Eigen Vector"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            m_storage = self.val["m_storage"]

            try:
                n = m_storage["n"]
            except gdb.error:           # only available for dynamic Matrices
                try:
                    n = m_storage.type.template_argument(1)
                except RuntimeError:
                    # should get dimens from template, but that's gdb bug
                    # #11060
                    size = m_storage["m_data"]["array"].type.sizeof
                    size0 = m_storage["m_data"]["array"].dereference(
                    ).type.sizeof
                    n = math.sqrt(size/size0)

            return "{%d}" % (n)

    class PrintEigenCommand(gdb.Command):
        """Print an eigen Matrix or Vector
    Usage: show eigen <matrix> [x0 y0 [nx ny]]
           show eigen <vector> [x0 [nx]]
    """

        def __init__(self):
            super(PrintEigenCommand, self).__init__("show eigen",
                                                    gdb.COMMAND_DATA,
                                                    gdb.COMPLETE_SYMBOL)

        def _mget(self, var, x, y=0):
            return getEigenValue(var, x, y)

        def _vget(self, var, x):
            return getEigenValue(var, x)

        def invoke(self, args, fromTty):
            self.dont_repeat()

            parser = GdbOptionParser("show eigen")
            parser.add_option("-d", "--dataFmt", default="%.2f",
                              help="Format for values")
            parser.add_option("-f", "--formatWidth", type="int",
                              default=8, help="Field width for values")
            parser.add_option("-o", "--origin", type="str", nargs="+",
                              help="Origin of the part of the object to print")
            if False:
                parser.add_option(
                    "eigenObject", help="Expression giving Eigen::Matrix/Vector to show")
                parser.add_option(
                    "nx", help="Width of patch to print", type="int", default=0, nargs="?")
                parser.add_option(
                    "ny", help="Height of patch to print", type="int", default=0, nargs="?")

                opts = parser.parse_args(args)
                if opts.help:
                    return
            else:
                (opts, args) = parser.parse_args(args)
                if opts.help:
                    return

                if not args:
                    raise gdb.GdbError("Please specify an object")
                opts.eigenObject = args.pop(0)

                opts.nx, opts.ny = 0, 0
                if args:
                    opts.nx = int(args.pop(0))
                if args:
                    opts.ny = int(args.pop(0))

                if args:
                    raise gdb.GdbError(
                        "Unrecognised trailing arguments: %s" % " ".join(args))

            var = gdb.parse_and_eval(opts.eigenObject)

            if not re.search(r"(Eigen|LinearTransform)::(Matrix|Vector)", str(var.type)):
                raise gdb.GdbError(
                    "Please specify an eigen matrix or vector, not %s" % var.type)

            if re.search(r"shared_ptr<", str(var.type)):
                var = var["px"].dereference()

            if var.type.code == gdb.TYPE_CODE_PTR:
                var = var.dereference()     # be nice

            isMatrix = re.search(r"Matrix", str(var.type))
            if isMatrix:
                NX, NY = getEigenMatrixDimensions(var)

                if opts.origin:
                    if len(opts.origin) != 2:
                        raise gdb.GdbError("Please specify both x0 and y0")

                    x0 = gdb.parse_and_eval(opts.origin[0])
                    y0 = gdb.parse_and_eval(opts.origin[1])
                else:
                    x0, y0 = 0, 0

                nx = opts.nx
                ny = opts.ny
                if nx == 0:
                    nx = NX
                if ny == 0:
                    ny = NY

                if nx == 1 and ny == 1:
                    print("%g" % self._vget(var, x0))
                    return
            else:
                NX = 0, var["m_storage"]["n"]

                if opts.origin:
                    if len(opts.origin) != 1:
                        raise gdb.GdbError("Please only specify x0")

                    x0 = gdb.parse_and_eval(opts.origin[0])
                else:
                    x0 = 0

                nx = opts.nx
                if nx == 0:
                    nx = NX

                if nx == 1:
                    print("%g" % self._vget(var, x0))
                    return
            #
            # OK, finally time to print
            #
            if isMatrix:
                print("%-4s" % "", end=' ')
                for x in range(x0, min(NX, x0 + nx)):
                    print("%*d" % (opts.formatWidth, x), end=' ')
                print("")

                for y in range(y0, min(NY, y0 + ny)):
                    print("%-4d" % y, end=' ')
                    for x in range(x0, min(NX, x0 + nx)):
                        print("%*s" % (opts.formatWidth, (opts.dataFmt %
                                                          self._mget(var, x, y))), end=' ')
                    print("")
            else:
                for x in range(x0, min(NX, x0 + nx)):
                    print("%*s" % (opts.formatWidth, (opts.dataFmt %
                                                      self._vget(var, x))), end=' ')
                print("")

    PrintEigenCommand()

    class CitizenPrinter:
        "Print a Citizen"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            sentinel = int(self.val["_sentinel"].cast(
                gdb.lookup_type("unsigned int")))
            return "{%s %d 0x%x}" % (self.val.address, self.val["_CitizenId"], sentinel)

    class PrintCitizenCommand(gdb.Command):
        """Print a Citizen
    Usage: show citizen <obj>
    """

        def __init__(self):
            super(PrintCitizenCommand, self).__init__("show citizen",
                                                      gdb.COMMAND_DATA,
                                                      gdb.COMPLETE_SYMBOL)

        def invoke(self, args, fromTty):
            self.dont_repeat()

            parser = GdbOptionParser("show citizen")
            if False:
                parser.add_option("object", help="The object in question")

                opts = parser.parse_args(args)
                if opts.help:
                    return
            else:
                opts, args = parser.parse_args(args)
                if opts.help:
                    return

                if not args:
                    raise gdb.GdbError("Please specify an object")
                opts.object = args.pop(0)

                if args:
                    raise gdb.GdbError(
                        "Unrecognised trailing arguments: %s" % " ".join(args))

            var = gdb.parse_and_eval(opts.object)
            if re.search(r"shared_ptr<", str(var.type)):
                var = var["px"]

            if var.type.code != gdb.TYPE_CODE_PTR:
                var = var.address

            citizen = var.dynamic_cast(gdb.lookup_type(
                "lsst::daf::base::Citizen").pointer())

            if not citizen:
                raise gdb.GdbError(
                    "Failed to cast %s to Citizen -- is it a subclass?" % opts.object)

            citizen = citizen.dereference()

            print(citizen)

    PrintCitizenCommand()

    # afw

    class BaseSourceAttributesPrinter:
        "Print a BaseSourceAttributes"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            return "Base: {id=%d astrom=(%.3f, %.3f)}" % (self.val["_id"],
                                                          self.val["_xAstrom"],
                                                          self.val["_yAstrom"])

    class SourcePrinter:
        "Print a Source"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            return "Source{id=%d astrom=(%.3f, %.3f)}" % (self.val["_id"],
                                                          self.val["_xAstrom"],
                                                          self.val["_yAstrom"])

    class DetectorPrinter:
        "Print a cameraGeom::Detector"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            return "Detector{name: %s id: %s type: %s bbox: %s}" % (self.val["_name"], self.val["_id"],
                                                                    self.val["_type"], self.val["_bbox"])

    class FootprintPrinter:
        "Print a Footprint"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            if False:
                # Fails (as its type is METHOD, not CODE)
                nspan = self.val["_spans"]["size"]()
            else:
                vec_impl = self.val["_spans"]["_M_impl"]
                nspan = vec_impl["_M_finish"] - vec_impl["_M_start"]

            return "Footprint{id=%d, nspan=%d, area=%d; BBox %s}" % (self.val["_fid"], nspan,
                                                                     self.val["_area"], self.val["_bbox"])

    class FootprintSetPrinter:
        "Print a FootprintSet"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            return "FootprintSet{%s; %s}" % (self.val["_region"], self.val["_footprints"])

    class PeakPrinter:
        "Print a Peak"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            return "Peak{%d, (%.2f, %.2f)}" % (self.val["_id"], self.val["_fx"], self.val["_fy"])

    class PsfPrinter:
        "Print a Psf"

        def to_string(self):
            return "%s" % (self.typeName())

    class Box2Printer:
        "Print a Box2"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            # Make sure &foo works, too.
            type = self.val.type
            if type.code == gdb.TYPE_CODE_REF:
                type = type.target()

            llc = [getEigenValue(self.val["_minimum"]["_vector"], i)
                   for i in range(2)]
            dims = [getEigenValue(self.val["_dimensions"]["_vector"], i)
                    for i in range(2)]

            return "Box2{(%s,%s)--(%s,%s)}" % (llc[0], llc[1],
                                               llc[0] + dims[0] - 1, llc[1] + dims[1] - 1)

        def display_hint(self):
            return "array"

    class CoordinateBasePrinter:
        "Print a CoordinateBase"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            return self.val["_vector"]["m_storage"]["m_data"]["array"]

        def display_hint(self):
            return "array"

    class AxesPrinter:
        "Print an ellipse::Axes"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            vec = self.val["_vector"]
            return "[%g, %g, %g]" % (getEigenValue(vec, 0), getEigenValue(vec, 1), getEigenValue(vec, 2))

    class QuadrupolePrinter:
        "Print an ellipse::Quadrupole"

        def __init__(self, val):
            self.val = val

        def to_string(self):
            mat = self.val["_matrix"]

            if False:
                return mat
            else:
                return "[[%g, %g], [%g, %g]]" % (getEigenValue(mat, 0, 0), getEigenValue(mat, 0, 1),
                                                 getEigenValue(mat, 1, 0), getEigenValue(mat, 1, 1))

    class ImagePrinter:
        "Print an ImageBase or derived class"

        def dimenStr(self, val=None):
            if val is None:
                val = self.val

            # Make sure &foo works, too.
            type = val.type
            if type.code == gdb.TYPE_CODE_REF:
                type = type.target()

            gilView = val["_gilView"]
            arr = val["_origin"]["_vector"]["m_storage"]["m_data"]["array"]

            x0, y0 = arr[0], arr[1]
            return "%dx%d%s%d%s%d" % (
                # val["getWidth"](), val["getHeight"](),
                gilView["_dimensions"]["x"], gilView["_dimensions"]["y"],
                # i.e. "+" if x0 >= 0 else "" in python >= 2.5
                ["", "+"][x0 >= 0], x0,
                ["", "+"][y0 >= 0], y0)

        def typeName(self):
            return self.typename.split(":")[-1]

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            return "%s(%s)" % (self.typeName(), self.dimenStr())

    class MaskedImagePrinter(ImagePrinter):
        "Print a MaskedImage"

        def to_string(self):
            return "%s(%s)" % (self.typeName(), self.dimenStr(self.val["_image"]["px"].dereference()))

    class ExposurePrinter(ImagePrinter):
        "Print an Exposure"

        def to_string(self):
            return "%s(%s)" % (self.typeName(),
                               self.dimenStr(self.val["_maskedImage"]["_image"]["px"].dereference()))

    class PrintImageCommand(gdb.Command):
        """Print an Image"""

        def __init__(self):
            super(PrintImageCommand, self).__init__("show image",
                                                    gdb.COMMAND_DATA,
                                                    gdb.COMPLETE_SYMBOL)

        def get(self, var, x, y):
            if False:
                return var["operator()(int, int, bool)"](x, y, True)
            else:
                dimensions = var["_gilView"]["_dimensions"]
                if x < 0 or x >= dimensions["x"] or y < 0 or y >= dimensions["y"]:
                    raise gdb.GdbError("Pixel (%d, %d) is out of range 0:%d, 0:%d" %
                                       (x, y, dimensions["x"] - 1, dimensions["y"] - 1))

                pixels = var["_gilView"]["_pixels"]["_p"]
                step = pixels["_step_fn"]["_step"] / \
                    var.type.template_argument(0).sizeof

                return pixels["m_iterator"][x + y*step]["_v0"]

        def invoke(self, args, fromTty):
            self.dont_repeat()

            parser = GdbOptionParser(
                "show image" + ("" if argparse else " <image> [<nx> [<ny>]]"))
            parser.add_option("-a", "--all", action="store_true",
                              help="Display the whole image/mask")
            parser.add_option("-c", "--center", type="str", nargs=2, default=(None, None,),
                              help="Center the output at (x, y)")
            parser.add_option("-o", "--origin", type="str", nargs=2, default=(None, None,),
                              help="Print the region starting at (x, y)")
            parser.add_option("-x", "--xy0", action="store_true",
                              help="Obey the image's (x0, y0)")
            parser.add_option("-f", "--formatWidth", type="int",
                              default=8, help="Field width for values")
            parser.add_option("-d", "--dataFmt", default="%.2f",
                              help="Format for values")

            if argparse:
                parser.add_option(
                    "image", help="Expression giving image to show")
                parser.add_option(
                    "width", help="Width of patch to print", default=1, nargs="?")
                parser.add_option(
                    "height", help="Height of patch to print", default=1, nargs="?")

                opts = parser.parse_args(args)
                if opts.help:
                    return
            else:
                opts, args = parser.parse_args(args)
                if opts.help:
                    return

                if not args:
                    raise gdb.GdbError("Please specify an image")

                opts.image = args.pop(0)

                opts.width, opts.height = 1, 1
                if args:
                    opts.width = int(args.pop(0))
                if args:
                    opts.height = int(args.pop(0))

                if args:
                    raise gdb.GdbError(
                        "Unrecognised trailing arguments: %s" % " ".join(args))

            for i in range(2):
                val = "0"
                if opts.origin[i] is None:
                    if opts.center[i] is not None:
                        val = opts.center[i]
                else:
                    val = opts.origin[i]
                    if opts.center[i] is not None:
                        raise gdb.GdbError(
                            "You may not specify both --center and --origin")

                val = gdb.parse_and_eval(val)
                if i == 0:
                    x0 = val
                else:
                    y0 = val

            if opts.all:
                nx, ny = 0, 0
            else:
                nx, ny = opts.width, opts.height

            var = gdb.parse_and_eval(opts.image)

            if re.search(r"shared_ptr<", str(var.type)):
                var = var["px"].dereference()

            if not re.search(r"(lsst::afw::image::)?(Image|Mask|MaskedImage)", str(var.type.unqualified())):
                raise gdb.GdbError(
                    "Please specify an image, not %s" % var.type)

            if re.search(r"MaskedImage", str(var.type)) and \
                    not re.search(r"::Image(\s*&)?$", str(var.type)):
                print("N.b. %s is a MaskedImage; showing image" % (opts.image))
                var = var["_image"]

            if re.search(r"shared_ptr<", str(var.type)):
                var = var["px"].dereference()

            if var.type.code == gdb.TYPE_CODE_PTR:
                var = var.dereference()     # be nice

            pixelTypeName = str(var.type.template_argument(0))
            if opts.dataFmt:
                dataFmt = opts.dataFmt
            elif pixelTypeName in ["short", "unsigned short"]:
                dataFmt = "0x%x"
            elif pixelTypeName in ["int", "unsigned int"]:
                dataFmt = "%d"
            else:
                dataFmt = "%.2f"

            if nx == 0:
                nx = var["_gilView"]["_dimensions"]["x"]
            if ny == 0:
                ny = var["_gilView"]["_dimensions"]["y"]

            if opts.center[0]:
                x0 -= nx//2
                y0 -= ny//2

            if opts.xy0 and not opts.all:
                arr = var["_origin"]["_vector"]["m_storage"]["m_data"]["array"]

                x0 -= arr[0]
                y0 -= arr[1]
            #
            # OK, finally time to print
            #
            print("%-4s" % "", end=' ')
            for x in range(x0, x0 + nx):
                print("%*d" % (opts.formatWidth, x), end=' ')
            print("")

            for y in reversed(list(range(y0, y0 + ny))):
                print("%-4d" % y, end=' ')
                for x in range(x0, x0 + nx):
                    print("%*s" % (opts.formatWidth, dataFmt %
                                   self.get(var, x, y)), end=' ')
                print("")

    PrintImageCommand()

    class BackgroundPrinter:
        "Print a Background"

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            return "Background(%dx%d) %s %s" % (
                self.val["_imgWidth"], self.val["_imgHeight"],
                self.val["_bctrl"])

    class BackgroundControlPrinter:
        "Print a BackgroundControl"

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            return "{%s %s %s %s}" % (re.sub(r"lsst::afw::math::Interpolate::", "", str(self.val["_style"])),
                                      re.sub(r"lsst::afw::math::", "",
                                             str(self.val["_prop"])),
                                      re.sub(r"lsst::afw::math::", "", str(
                                          self.val["_undersampleStyle"])),
                                      self.val["_sctrl"]["px"].dereference())

    class KernelPrinter:
        "Print a Kernel"

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            return "%s(%dx%d)" % (self.typename,
                                  self.val["_width"], self.val["_height"])

    class StatisticsControlPrinter:
        "Print a StatisticsControl"

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            return "{nSigma=%g nIter=%d ignore=0x%x}" % (self.val["_numSigmaClip"],
                                                         self.val["_numIter"],
                                                         self.val["_andMask"])

    class TablePrinter:
        "Print a table::Table"

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            return "{schema = %s, md=%s}" % (self.val["_schema"], self.val["_metadata"])

    class TableSchemaPrinter:
        "Print a table::Schema"

        def __init__(self, val):
            self.typename = str(val.type)
            self.val = val

        def to_string(self):
            names = str(self.val["_impl"]["px"]["_names"])
            names = re.sub(r"^[^{]*{|}|[\[\]\"\"]|\s*=\s*[^,]*", "", names)

            return "%s" % (names)

    printers = []

    def register(obj=None):
        "Register my pretty-printers with objfile Obj."

        if obj is None:
            obj = gdb

        for p in printers:
            gdb.printing.register_pretty_printer(obj, p, replace=True)

    def build_boost_dictionary():
        """Surely this must be somewhere standard?"""

        printer = gdb.printing.RegexpCollectionPrettyPrinter("rhl-boost")

        printer.add_printer('boost::shared_ptr',
                            '^(boost|tr1|std)::shared_ptr', SharedPtrPrinter)
        printer.add_printer('boost::gil::pixel',
                            'boost::gil::.*pixel_t', GilPixelPrinter)

        return printer

    printers.append(build_boost_dictionary())

    def build_eigen_dictionary():
        """Surely this must be somewhere standard?"""

        printer = gdb.printing.RegexpCollectionPrettyPrinter("rhl-eigen")

        printer.add_printer('eigen::Matrix',
                            '^Eigen::Matrix', EigenMatrixPrinter)
        printer.add_printer('eigen::Vector',
                            '^Eigen::Vector', EigenVectorPrinter)

        return printer

    printers.append(build_eigen_dictionary())

    def build_afw_dictionary():
        printer = gdb.printing.RegexpCollectionPrettyPrinter("afw")

        printer.add_printer('lsst::afw::cameraGeom::Detector',
                            '^lsst::afw::cameraGeom::(Amp|Ccd|Detector|DetectorMosaic)$', DetectorPrinter)

        printer.add_printer('lsst::afw::detection::Footprint',
                            '^lsst::afw::detection::Footprint$', FootprintPrinter)
        printer.add_printer('lsst::afw::detection::FootprintSet',
                            '^lsst::afw::detection::FootprintSet', FootprintSetPrinter)
        printer.add_printer('lsst::afw::detection::Peak',
                            '^lsst::afw::detection::Peak$', PeakPrinter)
        printer.add_printer('lsst::afw::detection::Psf',
                            '^lsst::afw::detection::Psf$', PsfPrinter)
        printer.add_printer('lsst::afw::detection::Source',
                            '^lsst::afw::detection::Source$', SourcePrinter)
        printer.add_printer('lsst::afw::detection::BaseSourceAttributes',
                            '^lsst::afw::detection::BaseSourceAttributes$', BaseSourceAttributesPrinter)

        printer.add_printer('lsst::afw::geom::Box',
                            '^lsst::afw::geom::Box', Box2Printer)
        printer.add_printer('lsst::afw::geom::Extent',
                            '^lsst::afw::geom::Extent', CoordinateBasePrinter)
        printer.add_printer('lsst::afw::geom::Point',
                            '^lsst::afw::geom::Point', CoordinateBasePrinter)

        printer.add_printer('lsst::afw::geom::ellipses::Axes',
                            '^lsst::afw::geom::ellipses::Axes', AxesPrinter)
        printer.add_printer('lsst::afw::geom::ellipses::Quadrupole',
                            '^lsst::afw::geom::ellipses::Quadrupole', QuadrupolePrinter)

        printer.add_printer('lsst::afw::image::ImageBase',
                            'lsst::afw::image::ImageBase<[^>]+>$', ImagePrinter)
        printer.add_printer('lsst::afw::image::Image',
                            'lsst::afw::image::Image<[^>]+>$', ImagePrinter)
        printer.add_printer('lsst::afw::image::Mask',
                            '^lsst::afw::image::Mask<[^>]+>$', ImagePrinter)
        printer.add_printer('lsst::afw::image::MaskedImage',
                            '^lsst::afw::image::MaskedImage<[^>]+>$', MaskedImagePrinter)
        printer.add_printer('lsst::afw::image::Exposure',
                            '^lsst::afw::image::Exposure', ExposurePrinter)

        printer.add_printer('lsst::afw::math::Background',
                            '^lsst::afw::math::Background$', BackgroundPrinter)
        printer.add_printer('lsst::afw::math::BackgroundControl',
                            '^lsst::afw::math::BackgroundControl$', BackgroundControlPrinter)
        printer.add_printer('lsst::afw::math::Kernel',
                            '^lsst::afw::math::.*Kernel', KernelPrinter)
        printer.add_printer('lsst::afw::math::StatisticsControl',
                            '^lsst::afw::math::StatisticsControl', StatisticsControlPrinter)

        printer.add_printer('lsst::afw::table::Table',
                            '^lsst::afw::table::.*Table$', TablePrinter)
        printer.add_printer('lsst::afw::table::Schema',
                            '^lsst::afw::table::Schema$', TableSchemaPrinter)

        return printer

    printers.append(build_afw_dictionary())

    def build_daf_base_dictionary():
        printer = gdb.printing.RegexpCollectionPrettyPrinter("daf::base")

        printer.add_printer('lsst::daf::base::Citizen',
                            'lsst::daf::base::Citizen', CitizenPrinter)

        return printer

    printers.append(build_daf_base_dictionary())
except ImportError as e:
    print("RHL", e)
    from .printers_oldgdb import *  # noqa F403