jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove gdb pretty printing.

Browse source 
This will be provided in a separate branch.
This commit is contained in:
Oliver Buchtala 2014-03-31 00:37:02 +02:00
commit f43741c3b7
2 changed files with 0 additions and 598 deletions
Download patch file Download diff file Expand all files Collapse all files

24
Tools/swigprinters.gdb
View file

@ -1,24 +0,0 @@
python
import sys
import os
try:
global SWIG_PRINTER_DIR
sys.path.insert(0, SWIG_PRINTER_DIR)
except NameError:
raise RuntimeError("""
---------------------------------------------------------
Change ~/.gdbinit to be able to use swig pretty printers:
> set python SWIG_PRINTER_DIR = <path/to/swig>/Tools
> source <path/to/swig>/Tools/swigprinters.gdb
---------------------------------------------------------
""")
from swigprinters import register_swig_printers, enableGdbPrintWorkaround, \
setChildrenRecursionLevel
#enableGdbPrintWorkaround()
#setChildrenRecursionLevel(2)
register_swig_printers (None)
end

574
Tools/swigprinters.py
View file

@ -1,574 +0,0 @@
import gdb
import gdb.types
import itertools
import re
log_file = None
GDB_FLATTENED_CHILDREN_WORKAROUND = False
CHILDREN_MAX_RECURSION_LEVEL = 0
# workaround: don't cast the following DOHs to it's actual type
# to avoid infinite pretty-print loops
cast_black_list = {
'Hash': set(['parentNode', 'symtab', 'csymtab', 'sym:symtab', 'inherit', 'nextSibling', 'previousSibling'])
}
def print_(msg):
global log_file;
if True:
if log_file == None:
log_file = open('swig_gdb.log', 'w')
log_file.write(msg)
print(msg)
class SwigStringPrinter:
"""
Pretty print Swig String* types.
"""
def __init__ (self, typename, val):
self.typename = typename
self.val = val
try:
self.t_swigstr_ptr = gdb.lookup_type("struct String").pointer()
self.t_doh_base_ptr = gdb.lookup_type("DohBase").pointer()
except Exception as err:
print_("SwigStringPrinter: Could not retrieve gdb types.\n %s.\n"%(str(err)))
def display_hint(self):
return 'string'
def to_string(self):
ret = "<invalid>"
# Conversion taken from Swig Internals manual:
# http://peregrine.hpc.uwm.edu/Head-node-docs/swig/2.0.4/Devel/internals.html#7
# (*(struct String *)(((DohBase *)s)->data)).str
dohbase = None;
str_data = None;
char_ptr = None;
try:
dohbase = self.val.reinterpret_cast(self.t_doh_base_ptr).dereference()
except Exception as err:
print_("SwigStringPrinter: Could not dereference DOHBase*\n");
return "<invalid>";
try:
str_data = dohbase['data'].reinterpret_cast(self.t_swigstr_ptr).dereference()
except Exception as err:
print_("SwigStringPrinter: Could not dereference struct String*\n");
return "<invalid>";
try:
char_ptr = str_data['str']
except Exception as err:
print_("SwigStringPrinter: Could not access field (struct String).str\n");
return "<invalid>";
if char_ptr.is_lazy is True:
char_ptr.fetch_lazy ()
try:
ret = char_ptr.string()
except Exception as err:
print_("SwigStringPrinter: Could not convert const char* to string\n");
return "<invalid>";
return ret
class SwigIterator:
def __init__(self):
self.t_doh_base_ptr = gdb.lookup_type("DohBase").pointer()
self.t_string_ptr = gdb.lookup_type("String").pointer()
self.t_node_ptr = gdb.lookup_type("Node").pointer()
self.t_hash_ptr = gdb.lookup_type("Hash").pointer()
self.t_file_ptr = gdb.lookup_type("File").pointer()
self.t_void_ptr = gdb.lookup_type("void").pointer()
def cast_doh(self, doh, name = None):
if doh == 0:
return doh
doh = doh.reinterpret_cast(self.t_doh_base_ptr);
val_base = doh.dereference()
val_type = val_base['type'].dereference()
val_typestr = val_type['objname'].string()
if not name == None and val_typestr in cast_black_list:
blacklist = cast_black_list[val_typestr]
if name in blacklist:
return doh
if "String" == val_typestr:
doh = doh.reinterpret_cast(self.t_string_ptr)
elif "File" == val_typestr:
doh = doh.reinterpret_cast(self.t_file_ptr)
# BUG: GDB Pyhton can not handle cyclic references yet
# so these casts are deactivated
elif "Hash" == val_typestr:
doh = doh.reinterpret_cast(self.t_hash_ptr)
elif "Node" == val_typestr:
doh = doh.reinterpret_cast(self.t_node_ptr)
return doh
class SwigListIterator(SwigIterator):
def __init__(self, val):
SwigIterator.__init__(self);
try:
self.valid = False
self.val = val.reinterpret_cast(self.t_doh_base_ptr)
val_base = self.val.dereference()
val_type = val_base['type'].dereference()
val_typestr = val_type['objname'].string()
#print_("SwigListIterator: constructing iterator for value of type %s"%val_typestr)
self.t_struct_list_ptr = gdb.lookup_type("struct List").pointer()
doh_base = self.val.dereference()
self.l = doh_base['data'].reinterpret_cast(self.t_struct_list_ptr).dereference()
self.address = 0
self._index = 0
self.key = 0
self.item = 0
self.address = self.val.dereference().address
self.is_first = True
self.valid = True
except Exception as err:
print_("SwigListIterator: Construction failed.\n %s.\n"%(str(err)))
def __iter__(self):
return self
def List_first(self):
self.object = None;
self._index = 0
self.key = 0
self.nitems = int(self.l['nitems'])
self.items = self.l['items']
if self.nitems > 0:
self.item = self.items[0]
else:
self.stop()
def List_next(self):
self._index = self._index + 1
if self._index >= self.nitems:
self.stop()
else:
self.item = self.items[self._index]
def next(self):
if not self.valid:
self.stop()
if self.is_first:
self.is_first = False
try:
self.List_first()
except StopIteration:
raise StopIteration
except Exception as err:
print_("Error during iteration to first node: \n %s \n" %(str(err)))
self.stop()
else:
try:
self.List_next()
except StopIteration:
raise StopIteration
except Exception as err:
print_("Error during iteration to first node: \n %s \n" %(str(err)))
self.stop()
key_str = "[%d]"%self._index
item = 0
try:
item = self.cast_doh(self.item)
except Exception as err:
print_("SwigListIterator(%s): Exception during casting of value doh:\n %s\n" % (str(self.address), str(err)) )
self.stop()
return (key_str, item)
def stop(self):
self.is_first = True
self.item = 0
self.key = 0
raise StopIteration
class SwigHashIterator(SwigIterator):
def __init__(self, val):
SwigIterator.__init__(self);
try:
self.valid = False
self.val = val.reinterpret_cast(self.t_doh_base_ptr)
self.t_struct_hash_ptr = gdb.lookup_type("struct Hash").pointer()
self.t_struct_hash_node_ptr = gdb.lookup_type("struct HashNode").pointer()
doh_base = self.val.dereference()
hash_ = doh_base['data'].reinterpret_cast(self.t_struct_hash_ptr).dereference()
self.hashtable = hash_['hashtable']
self.hashsize = int(hash_['hashsize'])
self.nitems = int(hash_['nitems'])
self.next_ = 0
self.address = 0
self.pos = 0;
self._current = 0
self.item = 0
self.key = 0
self._index = 0
self.address = self.val.dereference().address
self.is_first = True
self.valid = True
except Exception as err:
print_("SwigHashIterator: Construction failed.\n %s.\n"%(str(err)))
def __iter__(self):
return self
def Hash_firstiter(self):
self._current = 0;
self.item = 0;
self.key = 0;
self._index = 0;
while (self._index < self.hashsize) and (self.hashtable[self._index] == 0):
self._index = self._index+1;
if self._index >= self.hashsize:
self.stop();
self._current = self.hashtable[self._index]
self._current = self._current.reinterpret_cast(self.t_struct_hash_node_ptr);
self.item = self._current['object'];
self.key = self._current['key'];
self._current = self._current['next'];
def Hash_nextiter(self):
if self._current == 0:
self._index = self._index + 1
while (self._index < self.hashsize) and (self.hashtable[self._index] == 0):
self._index = self._index + 1
if self._index >= self.hashsize:
self.item = 0;
self.key = 0;
self._current = 0;
self.stop()
self._current = self.hashtable[self._index];
self._current = self._current.reinterpret_cast(self.t_struct_hash_node_ptr);
self.key = self._current['key'];
self.item = self._current['object'];
self._current = self._current['next'];
def next(self):
if not self.valid:
self.stop()
if self.is_first:
self.is_first = False
try:
self.Hash_firstiter()
except StopIteration:
raise StopIteration
except Exception as err:
print_("Error during iteration to first node: \n %s \n" %(str(err)))
self.stop()
else:
try:
self.Hash_nextiter()
except StopIteration:
raise StopIteration
except Exception as err:
print_("Error during iteration to first node: \n %s \n" %(str(err)))
self.stop()
key_str = "<err>"
item = 0
try:
string_printer = SwigStringPrinter("String *", self.key)
key_str = string_printer.to_string()
except Exception as err:
print_("SwigHashIterator(%s): Exception during extracting key string:\n %s\n" % (str(self.address), str(err)) )
self.stop()
try:
item = self.cast_doh(self.item, key_str)
except Exception as err:
print_("SwigHashIterator(%s): Exception during casting of value doh:\n %s\n" % (str(self.address), str(err)) )
self.stop()
return (key_str, item)
def stop(self):
self.is_first = True
raise StopIteration
class AlternateKeyValueIterator():
def __init__(self, iterable):
self.it = iterable.__iter__()
self._next = None
self.count = -1
def __iter__(self):
return self
def next(self):
if self._next == None:
key, value = self.it.next()
self._next = value
self.count = self.count + 1
return ("[%d]"%self.count, key)
else:
value = self._next
self._next = None
return ("[%d]"%self.count, value)
class NopIterator:
def __init__(self):
pass
def __iter__(self):
return self
def next(self):
raise StopIteration
class SwigListPrinter:
"""
Pretty print Swig List* types (also ParmList*).
"""
def __init__ (self, typename, val):
self.typename = typename
self.val = val
it = SwigListIterator(val)
self.valid = it.valid
self.address = it.address
def display_hint(self):
return 'array'
def to_string(self):
return "%s(%s)" % (str(self.typename), str(self.address))
def children(self):
if not self.valid:
print_("SwigListPrinter: Invalid state.\n")
return NopIterator()
try:
it = SwigListIterator(self.val)
return it
except Exception as err:
print_("SwigListPrinter: Error during creation of children iterator. \n %s \n" %(str(err)))
raise err
class SwigHashPrinter:
"""
Pretty print Swig Hash* types (also Node*).
"""
def __init__ (self, typename, val):
self.typename = typename
self.val = val
it = SwigHashIterator(val)
self.valid = it.valid
self.address = it.address
self.level = 0;
def display_hint(self):
return 'map'
def to_string(self):
return "%s(%s)" % (str(self.typename), str(self.address))
def children(self):
global GDB_FLATTENED_CHILDREN_WORKAROUND
global CHILDREN_MAX_RECURSION_LEVEL
if not self.valid:
print_("SwigHashPrinter: Invalid state.\n")
return NopIterator()
if self.level > CHILDREN_MAX_RECURSION_LEVEL:
return NopIterator()
try:
it = SwigHashIterator(self.val)
if GDB_FLATTENED_CHILDREN_WORKAROUND:
return AlternateKeyValueIterator(it)
return it
except Exception as err:
print_("SwigHashPrinter: Error during creation of children iterator. \n %s \n" %(str(err)))
raise err
class SwigSimplePrinter:
def __init__ (self, typename, val):
self.typename = typename
self.val = val
def display_hint(self):
return "string"
def to_string(self):
return "%s(%s)"%(self.typename, str(self.val.address))
class SwigDelegatingPrinter:
def __init__ (self, typename, val):
t_doh_base_ptr = gdb.lookup_type("DohBase").pointer()
val_base = val.reinterpret_cast(t_doh_base_ptr).dereference()
val_type = val_base['type'].dereference()
val_typestr = val_type['objname'].string()
self.has_children = False
if val_typestr == "Hash":
self.delegate = SwigHashPrinter(typename, val)
self.has_children = True
elif val_typestr == "List":
self.delegate = SwigListPrinter(typename, val)
self.has_children = True
elif val_typestr == "String":
self.delegate = SwigStringPrinter(typename, val)
else:
self.delegate = SwigSimplePrinter(typename, val)
def display_hint(self):
return self.delegate.display_hint()
def to_string(self):
return self.delegate.to_string()
def children(self):
if not self.has_children:
return NopIterator()
return self.delegate.children()
class RxPrinter(object):
def __init__(self, name, function):
super(RxPrinter, self).__init__()
self.name = name
self.function = function
self.enabled = True
def invoke(self, value):
if not self.enabled:
return None
return self.function(self.name, value)
# A pretty-printer that conforms to the "PrettyPrinter" protocol from
# gdb.printing. It can also be used directly as an old-style printer.
class Printer(object):
def __init__(self, name):
super(Printer, self).__init__()
self.name = name
self.subprinters = []
self.lookup = {}
self.enabled = True
self.compiled_rx = re.compile('^([a-zA-Z0-9_: *]+)$')
def add(self, name, function):
if not self.compiled_rx.match(name):
raise ValueError, 'error: "%s" does not match' % name
printer = RxPrinter(name, function)
self.subprinters.append(printer)
self.lookup[name] = printer
print('Added pretty printer for %s. ' % (name))
def __call__(self, val):
typename = str(val.type)
if typename in self.lookup:
ret = self.lookup[typename].invoke(val)
return ret
# Cannot find a pretty printer. Return None.
return None
swig_printer = None
def register_swig_printers(obj):
global swig_printer
if obj is None:
obj = gdb
obj.pretty_printers.append(swig_printer)
def build_swig_printer():
global swig_printer
swig_printer = Printer("swig")
swig_printer.add('String *', SwigStringPrinter)
swig_printer.add('const String *', SwigStringPrinter)
swig_printer.add('SwigType *', SwigStringPrinter)
swig_printer.add('Hash *', SwigHashPrinter)
swig_printer.add('const Hash *', SwigHashPrinter)
swig_printer.add('Node *', SwigHashPrinter)
swig_printer.add('const Node *', SwigHashPrinter)
swig_printer.add('Parm *', SwigHashPrinter)
swig_printer.add('const Parm *', SwigHashPrinter)
swig_printer.add('List *', SwigListPrinter)
swig_printer.add('const List *', SwigListPrinter)
swig_printer.add('ParmList *', SwigDelegatingPrinter)
swig_printer.add('const ParmList *', SwigDelegatingPrinter)
swig_printer.add('File *', SwigDelegatingPrinter)
#swig_printer.add('DOH *', SwigDelegatingPrinter)
#swig_printer.add('const DOH *', SwigDelegatingPrinter)
print_("Loaded swig printers\n");
def enableGdbPrintWorkaround():
global GDB_FLATTENED_CHILDREN_WORKAROUND
GDB_FLATTENED_CHILDREN_WORKAROUND = True
def setChildrenRecursionLevel(level):
global CHILDREN_MAX_RECURSION_LEVEL
CHILDREN_MAX_RECURSION_LEVEL = level
build_swig_printer()