def _getCodePathsThru2(fgraph, tgtcbva, path, firstpath, loopcnt=0, pathcnt=0, maxpath=None):
tgtnode = fgraph.getNode(tgtcbva)
todo = [ (tgtnode,firstpath), ]
while todo:
node,cpath = todo.pop()
refsfrom = fgraph.getRefsFrom(node)
# This is a leaf node!
if not refsfrom:
path = vg_pathcore.getPathToNode(cpath)
yield path, pathcnt
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', toid)
if loops > loopcnt:
continue
npath = vg_pathcore.newPathNode(parent=cpath, nid=toid, eid=eid)
tonode = fgraph.getNode(toid)
todo.append((tonode,npath))
def _getCodePathsThru2(fgraph, tgtcbva, path, firstpath, loopcnt=0, pathcnt=0, maxpath=None):
tgtnode = fgraph.getNode(tgtcbva)
todo = [ (tgtnode,firstpath), ]
while todo:
node,cpath = todo.pop()
refsfrom = fgraph.getRefsFrom(node)
# This is a leaf node!
if not refsfrom:
path = vg_pathcore.getPathToNode(cpath)
yield path, pathcnt
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', toid)
if loops > loopcnt:
continue
npath = vg_pathcore.newPathNode(parent=cpath, nid=toid, eid=eid)
tonode = fgraph.getNode(toid)
todo.append((tonode,npath))
def getLoopPaths(fgraph):
'''
Similar to getCodePaths(), however, getLoopPaths() will return path lists
which loop. The last element in the (node,edge) list will be the first
"looped" block.
'''
for root in fgraph.getHierRootNodes():
proot = vg_pathcore.newPathNode(nid=root[0], eid=None)
todo = [ (root[0],proot,0), ]
while todo:
node,cpath,loopcnt = todo.pop()
count = 0
free = []
if loopcnt == 1:
yield [ _nodeedge(n) for n in vg_pathcore.getPathToNode(npath) ]
else:
for eid, fromid, toid, einfo in fgraph.getRefsFromByNid(node):
loopcnt = vg_pathcore.getPathLoopCount(cpath, 'nid', toid)
if loopcnt > 1:
continue
count += 1
npath = vg_pathcore.newPathNode(parent=cpath, nid=toid, eid=eid)
todo.append((toid,npath,loopcnt))
if not count:
vg_pathcore.trimPath(cpath)
def getLoopPaths(fgraph):
'''
Similar to getCodePaths(), however, getLoopPaths() will return path lists
which loop. The last element in the (node,edge) list will be the first
"looped" block.
'''
for root in fgraph.getHierRootNodes():
proot = vg_pathcore.newPathNode(nid=root[0], eid=None)
todo = [
(root[0], proot, 0),
]
while todo:
node, cpath, loopcnt = todo.pop()
count = 0
free = []
if loopcnt == 1:
yield [_nodeedge(n) for n in vg_pathcore.getPathToNode(npath)]
else:
for eid, fromid, toid, einfo in fgraph.getRefsFromByNid(node):
loopcnt = vg_pathcore.getPathLoopCount(cpath, 'nid', toid)
if loopcnt > 1:
continue
count += 1
npath = vg_pathcore.newPathNode(parent=cpath,
nid=toid,
eid=eid)
todo.append((toid, npath, loopcnt))
if not count:
vg_pathcore.trimPath(cpath)
def walkCodePaths(fgraph, callback, loopcnt=0, maxpath=None):
'''
walkCodePaths is a path generator which uses a callback function to determine the
viability of each particular path. This approach allows the calling function
(eg. walkSymbolikPaths) to do in-generator checks/processing and trim paths which
are simply not possible/desireable.
Callbacks will receive the current path, the current edge, and the new path node.
For root nodes, the current path and edge will be None types.
'''
pathcnt = 0
routed = fgraph.getMeta('Routed', False)
for root in fgraph.getHierRootNodes():
proot = vg_pathcore.newPathNode(nid=root[0], eid=None)
# Fire callback once to init the dest "path node"
callback(None, None, proot)
todo = [(root,proot), ]
while todo:
node,cpath = todo.pop()
refsfrom = fgraph.getRefsFrom(node)
# This is a leaf node!
if not refsfrom:
#path = vg_pathcore.getPathToNode(cpath)
#yield [ _nodeedge(n) for n in path ]
# let the callback know we've reached one...
#if callback(cpath, None, None):
yield cpath
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
# skip edges which are not marked "follow"
if routed and not einfo.get('follow', False):
continue
# Skip loops if they are "deeper" than we are allowed
if vg_pathcore.getPathLoopCount(cpath, 'nid', toid) > loopcnt:
continue
edge = (eid,fromid,toid,einfo)
npath = vg_pathcore.newPathNode(parent=cpath, nid=toid, eid=eid)
if not callback(cpath, edge, npath):
vg_pathcore.trimPath(npath)
continue
todo.append((fgraph.getNode(toid),npath))
def walkCodePaths(fgraph, callback, loopcnt=0, maxpath=None):
'''
walkCodePaths is a path generator which uses a callback function to determine the
viability of each particular path. This approach allows the calling function
(eg. walkSymbolikPaths) to do in-generator checks/processing and trim paths which
are simply not possible/desireable.
Callbacks will receive the current path, the current edge, and the new path node.
For root nodes, the current path and edge will be None types.
'''
pathcnt = 0
for root in fgraph.getHierRootNodes():
proot = vg_pathcore.newPathNode(nid=root[0], eid=None)
# Fire callback once to init the dest "path node"
callback(None, None, proot)
todo = [
(root, proot),
]
while todo:
node, cpath = todo.pop()
refsfrom = fgraph.getRefsFrom(node)
# This is a leaf node!
if not refsfrom:
#path = vg_pathcore.getPathToNode(cpath)
#yield [ _nodeedge(n) for n in path ]
# let the callback know we've reached one...
#if callback(cpath, None, None):
yield cpath
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
if vg_pathcore.getPathLoopCount(cpath, 'nid', toid) > loopcnt:
continue
edge = (eid, fromid, toid, einfo)
npath = vg_pathcore.newPathNode(parent=cpath,
nid=toid,
eid=eid)
if not callback(cpath, edge, npath):
vg_pathcore.trimPath(npath)
continue
todo.append((fgraph.getNode(toid), npath))
def getCodePathsThru(fgraph, tgtcbva, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph which pass through
the target codeblock "tgtcb". Each "root" node is traced to the target,
and all paths are traversed from there to the end. Specify a loopcnt
to allow loop paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsThru(fgraph, tgtcb):
for node,edge in path:
...etc...
'''
# this starts with the "To" side, finding a path back from tgtcbva to root
pathcnt = 0
looptrack = []
pnode = vg_pathcore.newPathNode(nid=tgtcbva, eid=None)
rootnodes = fgraph.getHierRootNodes()
tgtnode = fgraph.getNode(tgtcbva)
todo = [(tgtnode,pnode), ]
while todo:
node,cpath = todo.pop()
refsto = fgraph.getRefsTo(node)
# This is the root node!
if node in rootnodes:
path = vg_pathcore.getPathToNode(cpath)
path.reverse()
# build the path in the right direction
newcpath = None
lastnk = {'eid':None}
for np,nc,nk in path:
newcpath = vg_pathcore.newPathNode(parent=newcpath, nid=nk['nid'], eid=lastnk['eid'])
lastnk = nk
for fullpath, count in _getCodePathsThru2(fgraph, tgtcbva, path, newcpath, loopcnt=loopcnt, pathcnt=pathcnt, maxpath=maxpath):
yield [ _nodeedge(n) for n in fullpath ]
vg_pathcore.trimPath(cpath)
pathcnt += count
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsto:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', fromid)
if loops > loopcnt:
continue
#vg_pathcore.setNodeProp(cpath, 'eid', eid)
#print "-e: %d %x %x %s" % (eid, fromid, toid, repr(einfo))
npath = vg_pathcore.newPathNode(parent=cpath, nid=fromid, eid=eid)
fromnode = fgraph.getNode(fromid)
todo.append((fromnode,npath))
def getCodePathsThru(fgraph, tgtcbva, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph which pass through
the target codeblock "tgtcb". Each "root" node is traced to the target,
and all paths are traversed from there to the end. Specify a loopcnt
to allow loop paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsThru(fgraph, tgtcb):
for node,edge in path:
...etc...
'''
# this starts with the "To" side, finding a path back from tgtcbva to root
pathcnt = 0
looptrack = []
pnode = vg_pathcore.newPathNode(nid=tgtcbva, eid=None)
node = fgraph.getNode(tgtcbva)
todo = [(node,pnode), ]
while todo:
node,cpath = todo.pop()
refsto = fgraph.getRefsTo(node)
# This is the root node!
if node[1].get('rootnode'):
path = vg_pathcore.getPathToNode(cpath)
path.reverse()
# build the path in the right direction
newcpath = None
lastnk = {'eid':None}
for np,nc,nk in path:
newcpath = vg_pathcore.newPathNode(parent=newcpath, nid=nk['nid'], eid=lastnk['eid'])
lastnk = nk
for fullpath, count in _getCodePathsThru2(fgraph, tgtcbva, path, newcpath, loopcnt=loopcnt, pathcnt=pathcnt, maxpath=maxpath):
yield [ _nodeedge(n) for n in fullpath ]
vg_pathcore.trimPath(cpath)
pathcnt += count
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsto:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', fromid)
if loops > loopcnt:
continue
#vg_pathcore.setNodeProp(cpath, 'eid', eid)
#print "-e: %d %x %x %s" % (eid, fromid, toid, repr(einfo))
npath = vg_pathcore.newPathNode(parent=cpath, nid=fromid, eid=eid)
fromnode = fgraph.getNode(fromid)
todo.append((fromnode,npath))
def getCodePathsTo(fgraph, tocbva, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph starting at the
"root nodes" and ending at tocbva. Specify a loopcnt to allow loop
paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsTo(fgraph, tocbva):
for node,edge in path:
...etc...
'''
pathcnt = 0
looptrack = []
pnode = vg_pathcore.newPathNode(nid=tocbva, eid=None)
#rootnodes = fgraph.getHierRootNodes()
cbnode = fgraph.getNode(tocbva)
todo = [
(cbnode, pnode),
]
while todo:
node, cpath = todo.pop()
refsto = fgraph.getRefsTo(node)
# Is this is the root node?
if node[1].get('rootnode'):
path = vg_pathcore.getPathToNode(cpath)
path.reverse()
yield [_nodeedge(n) for n in path]
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, n1, n2, einfo in refsto:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', n1)
if loops > loopcnt:
continue
vg_pathcore.setNodeProp(cpath, 'eid', eid)
npath = vg_pathcore.newPathNode(parent=cpath, nid=n1, eid=None)
node1 = fgraph.getNode(n1)
todo.append((node1, npath))
def getCodePathsTo(fgraph, tocbva, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph starting at the
"root nodes" and ending at tocbva. Specify a loopcnt to allow loop
paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsTo(fgraph, tocbva):
for node,edge in path:
...etc...
'''
pathcnt = 0
looptrack = []
pnode = vg_pathcore.newPathNode(nid=tocbva, eid=None)
#rootnodes = fgraph.getHierRootNodes()
cbnode = fgraph.getNode(tocbva)
todo = [(cbnode,pnode), ]
while todo:
node,cpath = todo.pop()
refsto = fgraph.getRefsTo(node)
# Is this is the root node?
if node[1].get('rootnode'):
path = vg_pathcore.getPathToNode(cpath)
path.reverse()
yield [ _nodeedge(n) for n in path ]
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, n1, n2, einfo in refsto:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', n1)
if loops > loopcnt:
continue
vg_pathcore.setNodeProp(cpath, 'eid', eid)
npath = vg_pathcore.newPathNode(parent=cpath, nid=n1, eid=None)
node1 = fgraph.getNode(n1)
todo.append((node1,npath))
def getCodePaths(fgraph, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph. Each
"root" node is traced to all terminating points. Specify a loopcnt
to allow loop paths to be generated with the given "loop iteration count"
Example:
for path in getCodePaths(fgraph):
for node,edge in path:
...etc...
'''
pathcnt = 0
for root in fgraph.getHierRootNodes():
proot = vg_pathcore.newPathNode(nid=root[0], eid=None)
todo = [
(root, proot),
]
while todo:
node, cpath = todo.pop()
refsfrom = fgraph.getRefsFrom(node)
# This is a leaf node!
if not refsfrom:
path = vg_pathcore.getPathToNode(cpath)
yield [_nodeedge(n) for n in path]
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
if vg_pathcore.getPathLoopCount(cpath, 'nid', toid) > loopcnt:
continue
npath = vg_pathcore.newPathNode(parent=cpath,
nid=toid,
eid=eid)
tonode = fgraph.getNode(toid)
todo.append((tonode, npath))
def getCodePathsFrom(fgraph, fromcbva, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph beginning with
"fromcbva", which is traced to all terminating points. Specify a loopcnt
to allow loop paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsFrom(fgraph, fromcbva):
for node,edge in path:
...etc...
'''
pathcnt = 0
proot = vg_pathcore.newPathNode(nid=fromcbva, eid=None)
cbnid, cbnode = fgraph.getNode(fromcbva)
todo = [
(cbnid, proot),
]
while todo:
nid, cpath = todo.pop()
refsfrom = fgraph.getRefsFromByNid(nid)
# This is a leaf node!
if not refsfrom:
path = vg_pathcore.getPathToNode(cpath)
yield [_nodeedge(n) for n in path]
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, n2, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', n2)
if loops > loopcnt:
continue
npath = vg_pathcore.newPathNode(parent=cpath, nid=n2, eid=eid)
todo.append((n2, npath))
def getCodePathsFrom(fgraph, fromcbva, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph beginning with
"fromcbva", which is traced to all terminating points. Specify a loopcnt
to allow loop paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsFrom(fgraph, fromcbva):
for node,edge in path:
...etc...
'''
pathcnt = 0
proot = vg_pathcore.newPathNode(nid=fromcbva, eid=None)
cbnid,cbnode = fgraph.getNode(fromcbva)
todo = [(cbnid,proot), ]
while todo:
nid,cpath = todo.pop()
refsfrom = fgraph.getRefsFromByNid(nid)
# This is a leaf node!
if not refsfrom:
path = vg_pathcore.getPathToNode(cpath)
yield [ _nodeedge(n) for n in path ]
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, n2, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', n2)
if loops > loopcnt:
continue
npath = vg_pathcore.newPathNode(parent=cpath, nid=n2, eid=eid)
todo.append((n2,npath))
def getCodePaths(fgraph, loopcnt=0, maxpath=None):
'''
Yields all the paths through the hierarchical graph. Each
"root" node is traced to all terminating points. Specify a loopcnt
to allow loop paths to be generated with the given "loop iteration count"
Example:
for path in getCodePaths(fgraph):
for node,edge in path:
...etc...
'''
pathcnt = 0
for root in fgraph.getHierRootNodes():
proot = vg_pathcore.newPathNode(nid=root[0], eid=None)
todo = [(root,proot), ]
while todo:
node,cpath = todo.pop()
refsfrom = fgraph.getRefsFrom(node)
# This is a leaf node!
if not refsfrom:
path = vg_pathcore.getPathToNode(cpath)
yield [ _nodeedge(n) for n in path ]
vg_pathcore.trimPath(cpath)
pathcnt += 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
# Skip loops if they are "deeper" than we are allowed
if vg_pathcore.getPathLoopCount(cpath, 'nid', toid) > loopcnt:
continue
npath = vg_pathcore.newPathNode(parent=cpath, nid=toid, eid=eid)
tonode = fgraph.getNode(toid)
todo.append((tonode,npath))
def getFuncCbRoutedPaths(self, fromva, tova, loopcnt=0, maxpath=None, maxsec=None):
'''
Yields all the paths through the hierarchical graph starting at the
"root nodes" and ending at tocbva. Specify a loopcnt to allow loop
paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsTo(fgraph, tocbva):
for node,edge in path:
...etc...
'''
fgraph = self.graph
self.__update = 0
self.__go__ = True
pathcnt = 0
tocbva = getGraphNodeByVa(fgraph, tova)
frcbva = getGraphNodeByVa(fgraph, fromva)
preRouteGraph(fgraph, fromva, tova)
pnode = vg_pathcore.newPathNode(nid=frcbva, eid=None)
todo = [(frcbva, pnode), ]
if maxsec:
self.watchdog(maxsec)
while todo:
if not self.__go__:
raise PathForceQuitException()
nodeid,cpath = todo.pop()
refsfrom = fgraph.getRefsFrom((nodeid, None))
# This is the root node!
if nodeid == tocbva:
path = vg_pathcore.getPathToNode(cpath)
yield [ _nodeedge(n) for n in path ]
vg_pathcore.trimPath(cpath)
pathcnt += 1
self.__update = 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
if fgraph.getNodeProps(fromid).get('down') != True:
#sys.stderr.write('.')
# TODO: drop the bad edges from graph in preprocessing? instead of "if" here
continue
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', fromid)
if loops > loopcnt:
vg_pathcore.trimPath(cpath)
#sys.stderr.write('o')
# as long as we have at least one path, we count loops as paths, lest we die.
if pathcnt:
pathcnt += 1
continue
npath = vg_pathcore.newPathNode(parent=cpath, nid=toid, eid=eid)
todo.append((toid,npath))
vg_pathcore.trimPath(cpath)
def getFuncCbRoutedPaths_genback(self, fromva, tova, loopcnt=0, maxpath=None, maxsec=None):
'''
Yields all the paths through the hierarchical graph starting at the
"root nodes" and ending at tocbva. Specify a loopcnt to allow loop
paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsTo(fgraph, tocbva):
for node,edge in path:
...etc...
'''
fgraph = self.graph
self.__update = 0
self.__go__ = True
pathcnt = 0
tocbva = getGraphNodeByVa(fgraph, tova)
frcbva = getGraphNodeByVa(fgraph, fromva)
preRouteGraph(fgraph, fromva, tova)
pnode = vg_pathcore.newPathNode(nid=tocbva, eid=None)
todo = [(tocbva,pnode), ]
if maxsec:
self.watchdog(maxsec)
while todo:
if not self.__go__:
raise PathForceQuitException()
nodeid,cpath = todo.pop()
refsto = fgraph.getRefsTo((nodeid, None))
# This is the root node!
if nodeid == frcbva:
path = vg_pathcore.getPathToNode(cpath)
path.reverse()
self.__steplock.acquire()
yield [ viv_graph._nodeedge(n) for n in path ]
vg_pathcore.trimPath(cpath)
pathcnt += 1
self.__update = 1
self.__steplock.release()
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsto:
if fgraph.getNodeProps(fromid).get('up') != True:
# TODO: drop the bad edges from graph in preprocessing? instead of "if" here
vg_pathcore.trimPath(cpath)
continue
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', fromid)
if loops > loopcnt:
continue
vg_pathcore.setNodeProp(cpath, 'eid', eid)
npath = vg_pathcore.newPathNode(parent=cpath, nid=fromid, eid=None)
todo.append((fromid,npath))
def getFuncCbRoutedPaths(self,
fromva,
tova,
loopcnt=0,
maxpath=None,
timeout=None):
'''
Yields all the paths through the hierarchical graph starting at the
"root nodes" and ending at tocbva. Specify a loopcnt to allow loop
paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsTo(fgraph, tocbva):
for node,edge in path:
...etc...
'''
fgraph = self.graph
self.__update = 0
self.__go__ = True
pathcnt = 0
tocbva = getGraphNodeByVa(fgraph, tova)
frcbva = getGraphNodeByVa(fgraph, fromva)
preRouteGraph(fgraph, fromva, tova)
pnode = vg_pathcore.newPathNode(nid=frcbva, eid=None)
todo = [
(frcbva, pnode),
]
maxtime = None
if timeout:
maxtime = time.time() + timeout
while todo:
if maxtime and time.time() > maxtime:
raise PathForceQuitException()
if not self.__go__:
raise PathForceQuitException()
nodeid, cpath = todo.pop()
refsfrom = fgraph.getRefsFrom((nodeid, None))
# This is the root node!
if nodeid == tocbva:
path = vg_pathcore.getPathToNode(cpath)
yield [_nodeedge(n) for n in path]
vg_pathcore.trimPath(cpath)
pathcnt += 1
self.__update = 1
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsfrom:
if fgraph.getNodeProps(fromid).get('down') != True:
#sys.stderr.write('.')
# TODO: drop the bad edges from graph in preprocessing? instead of "if" here
continue
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', fromid)
if loops > loopcnt:
vg_pathcore.trimPath(cpath)
#sys.stderr.write('o')
# as long as we have at least one path, we count loops as paths, lest we die.
if pathcnt:
pathcnt += 1
continue
npath = vg_pathcore.newPathNode(parent=cpath,
nid=toid,
eid=eid)
todo.append((toid, npath))
vg_pathcore.trimPath(cpath)
self.__go__ = False
def getFuncCbRoutedPaths_genback(self,
fromva,
tova,
loopcnt=0,
maxpath=None,
timeout=None):
'''
Yields all the paths through the hierarchical graph starting at the
"root nodes" and ending at tocbva. Specify a loopcnt to allow loop
paths to be generated with the given "loop iteration count"
Example:
for path in getCodePathsTo(fgraph, tocbva):
for node,edge in path:
...etc...
'''
fgraph = self.graph
self.__update = 0
self.__go__ = True
pathcnt = 0
tocbva = getGraphNodeByVa(fgraph, tova)
frcbva = getGraphNodeByVa(fgraph, fromva)
preRouteGraph(fgraph, fromva, tova)
pnode = vg_pathcore.newPathNode(nid=tocbva, eid=None)
todo = [
(tocbva, pnode),
]
maxtime = None
if timeout:
maxtime = time.time() + timeout
while todo:
if maxtime and time.time() > maxtime:
raise PathForceQuitException()
if not self.__go__:
raise PathForceQuitException()
nodeid, cpath = todo.pop()
refsto = fgraph.getRefsTo((nodeid, None))
# This is the root node!
if nodeid == frcbva:
path = vg_pathcore.getPathToNode(cpath)
path.reverse()
self.__steplock.acquire()
yield [viv_graph._nodeedge(n) for n in path]
vg_pathcore.trimPath(cpath)
pathcnt += 1
self.__update = 1
self.__steplock.release()
if maxpath and pathcnt >= maxpath:
return
for eid, fromid, toid, einfo in refsto:
if fgraph.getNodeProps(fromid).get('up') != True:
# TODO: drop the bad edges from graph in preprocessing? instead of "if" here
vg_pathcore.trimPath(cpath)
continue
# Skip loops if they are "deeper" than we are allowed
loops = vg_pathcore.getPathLoopCount(cpath, 'nid', fromid)
if loops > loopcnt:
continue
vg_pathcore.setNodeProp(cpath, 'eid', eid)
npath = vg_pathcore.newPathNode(parent=cpath,
nid=fromid,
eid=None)
todo.append((fromid, npath))
self.__go__ = False
