def compute(self, graph):
self.links = {}
dotgen = DotGen(str(graph.no))
# split over debug_merge_points
counter = 0
lines = graph.content.split("\n")
lines_so_far = []
for line in lines:
line = re.sub('.\[.*\]', '', line)
boxes = re.findall('([pif]\d+)', line)
for box in boxes:
self.links[box] = box
if 'debug_merge_point' in line:
dotgen.emit_node('node%d' % counter,
shape="box",
label="\n".join(lines_so_far))
if counter != 0:
dotgen.emit_edge('node%d' % (counter - 1),
'node%d' % counter)
counter += 1
lines_so_far = []
lines_so_far.append(line)
dotgen.emit_node('node%d' % counter,
shape="box",
label="\n".join(lines_so_far))
dotgen.emit_edge('node%d' % (counter - 1), 'node%d' % counter)
self.source = dotgen.generate(target=None)
def compute(self, translator, *args, **kwds):
self.translator = translator
self.object_by_name = {}
self.name_by_object = {}
dotgen = DotGen(self.graph_name(*args))
dotgen.emit('mclimit=15.0')
self.do_compute(dotgen, *args, **kwds)
self.source = dotgen.generate(target=None)
# link the function names to the individual flow graphs
for name, obj in self.object_by_name.items():
if isinstance(obj, ClassDef):
data = repr(obj)
elif isinstance(obj, FunctionGraph):
graph = obj
data = graph.name
if hasattr(graph, 'func'):
data += ':%d' % graph.func.__code__.co_firstlineno
if hasattr(graph, 'source'):
data += '\n%s' % graph.source.split('\n', 1)[0]
else:
continue
self.links.setdefault(name, data)
def compute(self, graphs, counts):
dotgen = DotGen('trace')
self.loops = graphs
self.links = {}
self.cache = {}
for loop in self.loops:
loop.generate(dotgen, counts)
loop.getlinks(self.links)
self.cache["loop" + str(loop.no)] = loop
self.source = dotgen.generate(target=None)
def getsource(self):
self.find_starters()
self.pendingedges = []
self.dotgen = DotGen('resop')
self.dotgen.emit('clusterrank="local"')
self.generrmsg()
for i, graph in enumerate(self.graphs):
self.gengraph(graph, i)
# we generate the edges at the end of the file; otherwise, and edge
# could mention a node before it's declared, and this can cause the
# node declaration to occur too early -- in the wrong subgraph.
for frm, to, kwds in self.pendingedges:
self.dotgen.emit_edge(frm, to, **kwds)
return self.dotgen.generate(target=None)
def compute(self, translator, cdef):
self.translator = translator
dotgen = DotGen(cdef.shortname, rankdir="LR")
def writecdef(cdef):
lines = [cdef.name, '']
attrs = cdef.attrs.items()
attrs.sort()
def writeadefs(prefix, classattrs):
for name, attrdef in attrs:
if bool(attrdef.readonly) == bool(classattrs):
s_value = attrdef.s_value
linkname = name
info = s_value
if (classattrs and isinstance(s_value, SomePBC)
and s_value.getKind() == MethodDesc):
name += '()'
info = 'SomePBC(%s)' % ', '.join([
'method %s.%s' %
(desc.originclassdef.shortname, desc.name)
for desc in s_value.descriptions
], )
lines.append(name)
self.links[linkname] = '%s.%s: %s' % (prefix, name,
info)
prefix = cdef.shortname
writeadefs(prefix + '()', False)
lines.append('')
writeadefs(prefix, True)
dotgen.emit_node(nameof(cdef),
color="red",
shape="box",
label='\n'.join(lines))
prevcdef = None
while cdef is not None:
writecdef(cdef)
if prevcdef:
dotgen.emit_edge(nameof(cdef), nameof(prevcdef), color="red")
prevcdef = cdef
cdef = cdef.basedef
self.source = dotgen.generate(target=None)
def compute(self, translator, name, info, caused_by, history, func_names):
self.linkinfo = {}
self.translator = translator
self.func_names = func_names
dotgen = DotGen('binding')
label = "Most recent binding of %s\\n\\n%s" % (name, nottoowide(info))
if info.origin is not None:
label += "\\n" + self.createlink(info.origin, 'Originated at')
if caused_by is not None:
label += '\\n' + self.createlink(caused_by)
dotgen.emit_node('0', shape="box", color="red", label=label)
for n, (data, caused_by) in zip(range(len(history)), history):
label = nottoowide(data)
if data.origin is not None:
label += "\\n" + self.createlink(data.origin, 'Originated at')
if caused_by is not None:
label += '\\n' + self.createlink(caused_by)
dotgen.emit_node(str(n + 1), shape="box", label=label)
dotgen.emit_edge(str(n + 1), str(n))
self.source = dotgen.generate(target=None)
