本文整理汇总了Python中networkx.classes.digraph.DiGraph.add_edge方法的典型用法代码示例。如果您正苦于以下问题:Python DiGraph.add_edge方法的具体用法?Python DiGraph.add_edge怎么用?Python DiGraph.add_edge使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类networkx.classes.digraph.DiGraph
的用法示例。
在下文中一共展示了DiGraph.add_edge方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _congruence_graph
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def _congruence_graph(self):
"""Form a graph whose vertex set is the QNF basis. The edges store the information which makes two vertices congruent."""
from networkx.classes.digraph import DiGraph
basis = self.quasinormal_basis
min_exp = basis.minimal_expansion_for(self)
terminal, initial = self.semi_infinite_end_points()
endpts = sorted(terminal + initial)
G = DiGraph()
orbit_generators = set(min_exp)
orbit_generators.update(endpts)
#1. Add an edge for every direct congruence relationship.
for gen in orbit_generators:
type, images, _ = self.orbit_type(gen, basis)
for power, img in images.items():
images[power] = basis.test_above(img)
congruent_pairs = permutations(images.items(), 2)
for (pow1, (head1, tail1)), (pow2, (head2, tail2)) in congruent_pairs:
if head1 == head2:
continue
data = dict(start_tail = tail1, power = pow2 - pow1, end_tail = tail2)
G.add_edge(head1, head2, data)
assert self.repeated_image(head1.extend(tail1), pow2 - pow1) == head2.extend(tail2)
return G
示例2: load_graph
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def load_graph(file_or_path:FileOrPath, ext:str=None) -> DiGraph:
graph = DiGraph()
for adj in load_jsonl(text_file_for(file_or_path)):
src = adj[0]
graph.add_node(src)
for dst in adj[1:]:
graph.add_edge(src, dst)
return graph
示例3: buchi_from_ltl
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def buchi_from_ltl(formula,Type):
promela_string = run_ltl2ba(formula)
symbols = find_symbols(formula)
edges = parse_ltl(promela_string)
(states, initials, accepts) = find_states(edges)
buchi = DiGraph(type=Type, initial=initials, accept=accepts, symbols=symbols)
for state in states:
buchi.add_node(state)
for (ef,et) in edges.keys():
guard_formula = edges[(ef,et)]
guard_expr = parse_guard(guard_formula)
buchi.add_edge(ef, et, guard=guard_expr, guard_formula=guard_formula)
return buchi
示例4: add_edge
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def add_edge(self, u, v=None):
if v is None: (u,v)=u # no v given, assume u is an edge tuple
if self.has_edge(u,v): return # no parallel edges
elif u in self and v in self:
raise NetworkXError, "adding edge %s-%s not allowed in tree"%(u,v)
elif u in self or v in self:
DiGraph.add_edge(self,u,v) # u->v
return
elif len(self.adj)==0: # first leaf
DiGraph.add_edge(self,u,v) # u->v
return
else:
raise NetworkXError("adding edge %s-%s not allowed in tree"%(u,v))
示例5: BoardGraph
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
class BoardGraph(object):
def walk(self, board, size_limit=maxint):
pending_nodes = []
self.graph = DiGraph()
self.start = board.display(cropped=True)
self.graph.add_node(self.start)
pending_nodes.append(self.start)
self.min_domino_count = len(board.dominoes)
while pending_nodes:
if len(self.graph) >= size_limit:
raise GraphLimitExceeded(size_limit)
state = pending_nodes.pop()
board = Board.create(state, border=1)
dominoes = set(board.dominoes)
self.min_domino_count = min(self.min_domino_count, len(dominoes))
for domino in dominoes:
dx, dy = domino.direction
self.try_move(state, domino, dx, dy, pending_nodes)
self.try_move(state, domino, -dx, -dy, pending_nodes)
self.last = state
return set(self.graph.nodes())
def try_move(self, old_state, domino, dx, dy, pending_states):
try:
new_state = self.move(domino, dx, dy)
move = domino.describe_move(dx, dy)
if not self.graph.has_node(new_state):
# new node
self.graph.add_node(new_state)
pending_states.append(new_state)
self.graph.add_edge(old_state, new_state, move=move)
except BoardError:
pass
def move(self, domino, dx, dy):
""" Move a domino and calculate the new board state.
Afterward, put the board back in its original state.
@return: the new board state
@raise BoardError: if the move is illegal
"""
domino.move(dx, dy)
try:
board = domino.head.board
if not board.isConnected():
raise BoardError('Board is not connected.')
if board.hasLoner():
raise BoardError('Board has a lonely domino.')
return board.display(cropped=True)
finally:
domino.move(-dx, -dy)
示例6: load_from_graphml
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def load_from_graphml(path):
"""
:type path: str
:rtype: networkx.classes.graph.Graph
"""
#: :type : networkx.classes.graph.Graph
g1 = nx.read_graphml(path)
#: :type graph: networkx.classes.digraph.DiGraph
g2 = DiGraph()
typetest = re.compile(r"([a-zA-z]+)(\d*)")
max_qualifiers = dict(crossing=0, poi=0, plcs=0)
node_mapping = dict()
for node, data in g1.nodes_iter(data=True):
m = typetest.match(data["label"])
if m is None:
raise(SALMAException("Wrong label format for node {}!".format(node)))
loctype = m.group(1)
if loctype in ["c"]:
loctype = "crossing"
elif loctype in ["p"]:
loctype = "poi"
elif loctype in ["pl"]:
loctype = "plcs"
if loctype not in ["poi", "plcs", "crossing"]:
raise(SALMAException("Wrong loctype for node {}: {}".format(node, loctype)))
qualifier = m.group(2)
if len(qualifier) == 0:
qualifier = max_qualifiers[loctype] + 1
nid = data["label"] + str(qualifier)
else:
nid = data["label"]
max_qualifiers[loctype] = max(max_qualifiers[loctype], qualifier)
pos = (round(float(data["x"])), round(float(data["y"])))
g2.add_node(nid, pos=pos, scaled_pos=pos, loctype=loctype)
node_mapping[node] = nid
for u, v in g1.edges_iter():
n1 = node_mapping[u]
n2 = node_mapping[v]
g2.add_edge(n1, n2)
g2.add_edge(n2, n1)
MapGenerator.__add_roadlengths(g2)
return g2
示例7: find_SCCs
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def find_SCCs(mdp, Sneg):
#----simply find strongly connected components----
print 'Remaining states size', len(Sneg)
SCC = set()
simple_digraph = DiGraph()
A = dict()
for s in mdp.nodes():
A[s] = mdp.node[s]['act'].copy()
for s_f in Sneg:
if s_f not in simple_digraph:
simple_digraph.add_node(s_f)
for s_t in mdp.successors_iter(s_f):
if s_t in Sneg:
simple_digraph.add_edge(s_f,s_t)
print "SubGraph of one Sf: %s states and %s edges" %(str(len(simple_digraph.nodes())), str(len(simple_digraph.edges())))
sccs = strongly_connected_component_subgraphs(simple_digraph)
for scc in sccs:
SCC.add(frozenset(scc.nodes()))
return SCC, A
示例8: __init__
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def __init__(self,data=None,**kwds):
DiGraph.__init__(self,**kwds)
if data is not None:
try: # build a rooted tree
D=DiGraph()
for (child,parent) in data.par.iteritems():
D.add_edge(parent,child)
except AttributeError:
D=DiGraph(data)
except: # else nothing we can do
raise NetworkXError, "Data %s is not a rooted tree:"%data
if D.order()==D.size()+1:
self.pred=D.pred.copy()
self.succ=D.succ.copy()
self.adj=self.succ
del D
else: # not a tree
raise NetworkXError, "Data %s is not a rooted tree:"%data
示例9: DuoBA_from_ltls
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def DuoBA_from_ltls(hard_spec, soft_spec):
hard_buchi = buchi_from_ltl(hard_spec, 'hard_buchi')
soft_buchi = buchi_from_ltl(soft_spec, 'soft_buchi')
hard_symbols = hard_buchi.graph['symbols']
soft_symbols = soft_buchi.graph['symbols']
symbols = set(hard_symbols).union(set(soft_symbols))
DuoBA = DiGraph(type='safe_buchi', hard=hard_buchi, soft=soft_buchi, symols=symbols)
initial = set()
accept = set()
for (h_node, s_node, l) in cartesian_product(hard_buchi.nodes(), soft_buchi.nodes(), [1, 2]):
DuoNode = (h_node, s_node, l)
DuoBA.add_node(DuoNode,hard=h_node, soft=s_node, level=l)
if (h_node in hard_buchi.graph['initial'] and
s_node in soft_buchi.graph['initial'] and l == 1):
initial.add(DuoNode)
if (h_node in hard_buchi.graph['accept'] and l == 1):
accept.add(DuoNode)
DuoBA.graph['accept'] = accept
DuoBA.graph['initial'] = initial
for f_duonode in DuoBA.nodes():
for t_duonode in DuoBA.nodes():
f_h_node, f_s_node, f_level = check_duo_attr(DuoBA, f_duonode)
t_h_node, t_s_node, t_level = check_duo_attr(DuoBA, t_duonode)
if (t_h_node not in DuoBA.graph['hard'].neighbors(f_h_node) or
t_s_node not in DuoBA.graph['soft'].neighbors(f_s_node)):
continue
# relaxed because no common input alphabets are enabled
hardguard = DuoBA.graph['hard'].edges[f_h_node,t_h_node]['guard']
softguard = DuoBA.graph['soft'].edges[f_s_node,t_s_node]['guard']
if ((f_h_node not in DuoBA.graph['hard'].graph['accept'] and
f_level == 1 and t_level == 1) or
(f_h_node in DuoBA.graph['hard'].graph['accept'] and
f_level == 1 and t_level == 2) or
(f_s_node not in DuoBA.graph['soft'].graph['accept'] and
f_level == 2 and t_level == 2) or
(f_s_node in DuoBA.graph['soft'].graph['accept'] and
f_level == 2 and t_level == 1)):
DuoBA.add_edge(f_duonode, t_duonode, hardguard=hardguard, softguard=softguard)
return DuoBA
示例10: _build_ast
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def _build_ast(cls, rpn_expression):
"""build an AST from an Excel formula
:param rpn_expression: a string formula or the result of parse_to_rpn()
:return: AST which can be used to generate code
"""
# use a directed graph to store the syntax tree
tree = DiGraph()
# production stack
stack = []
for node in rpn_expression:
# The graph does not maintain the order of adding nodes/edges, so
# add an attribute 'pos' so we can always sort to the correct order
node.ast = tree
if isinstance(node, OperatorNode):
if node.token.type == node.token.OP_IN:
try:
arg2 = stack.pop()
arg1 = stack.pop()
except IndexError:
raise FormulaParserError(
"'{}' operator missing operand".format(
node.token.value))
tree.add_node(arg1, pos=0)
tree.add_node(arg2, pos=1)
tree.add_edge(arg1, node)
tree.add_edge(arg2, node)
else:
try:
arg1 = stack.pop()
except IndexError:
raise FormulaParserError(
"'{}' operator missing operand".format(
node.token.value))
tree.add_node(arg1, pos=1)
tree.add_edge(arg1, node)
elif isinstance(node, FunctionNode):
if node.num_args:
args = stack[-node.num_args:]
del stack[-node.num_args:]
for i, a in enumerate(args):
tree.add_node(a, pos=i)
tree.add_edge(a, node)
else:
tree.add_node(node, pos=0)
stack.append(node)
assert 1 == len(stack)
return stack[0]
示例11: build_ast
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def build_ast(expression, debug = False):
"""build an AST from an Excel formula expression in reverse polish notation"""
#use a directed graph to store the tree
G = DiGraph()
stack = []
for n in expression:
# Since the graph does not maintain the order of adding nodes/edges
# add an extra attribute 'pos' so we can always sort to the correct order
if isinstance(n,OperatorNode):
if n.ttype == "operator-infix":
arg2 = stack.pop()
arg1 = stack.pop()
# Hack to write the name of sheet in 2argument address
if(n.tvalue == ':'):
if '!' in arg1.tvalue and arg2.ttype == 'operand' and '!' not in arg2.tvalue:
arg2.tvalue = arg1.tvalue.split('!')[0] + '!' + arg2.tvalue
G.add_node(arg1,{'pos':1})
G.add_node(arg2,{'pos':2})
G.add_edge(arg1, n)
G.add_edge(arg2, n)
else:
arg1 = stack.pop()
G.add_node(arg1,{'pos':1})
G.add_edge(arg1, n)
elif isinstance(n,FunctionNode):
args = []
for _ in range(n.num_args):
try:
args.append(stack.pop())
except:
raise Exception()
#try:
# args = [stack.pop() for _ in range(n.num_args)]
#except:
# print 'STACK', stack, type(n)
# raise Exception('prut')
args.reverse()
for i,a in enumerate(args):
G.add_node(a,{'pos':i})
G.add_edge(a,n)
else:
G.add_node(n,{'pos':0})
stack.append(n)
return G,stack.pop()
示例12: build_ast
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
def build_ast(expression):
"""build an AST from an Excel formula expression in reverse polish notation"""
#use a directed graph to store the tree
G = DiGraph()
stack = []
for n in expression:
# Since the graph does not maintain the order of adding nodes/edges
# add an extra attribute 'pos' so we can always sort to the correct order
if isinstance(n,OperatorNode):
if n.ttype == "operator-infix":
arg2 = stack.pop()
arg1 = stack.pop()
G.add_node(arg1,{'pos':1})
G.add_node(arg2,{'pos':2})
G.add_edge(arg1, n)
G.add_edge(arg2, n)
else:
arg1 = stack.pop()
G.add_node(arg1,{'pos':1})
G.add_edge(arg1, n)
elif isinstance(n,FunctionNode):
args = [stack.pop() for _ in range(n.num_args)]
args.reverse()
for i,a in enumerate(args):
G.add_node(a,{'pos':i})
G.add_edge(a,n)
#for i in range(n.num_args):
# G.add_edge(stack.pop(),n)
else:
G.add_node(n,{'pos':0})
stack.append(n)
return G,stack.pop()
示例13: dp_dag_general
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
#.........这里部分代码省略.........
BP[n] = defaultdict(list) # backpointer corresponding to A[u][i]
for n_i, n in enumerate(
topological_sort(G, reverse=True)): # leaves come first
if debug:
print("#nodes processed {}".format(n_i))
children = G.neighbors(n)
if debug:
print('{}\'s children={}'.format(n, children))
reward = G.node[n][node_reward_key]
if len(children) == 1:
child = children[0]
if debug:
print('child={}'.format(child))
for i in A[child]:
c = cost_func(n, D, G,
[(i, child)])
assert isinstance(c, int)
if c <= U:
A[n][c] = A[child][i] + reward
D[n][c] = D[child][i] | {n}
BP[n][c] = [(child, i)]
elif len(children) > 1:
assert len(children) == 2
lchild, rchild = children
for i in A[lchild]:
c = cost_func(n, D, G,
[(i, lchild)])
assert isinstance(c, int)
if debug:
print('n={}, D={}, cost_child_tuples={}'.format(
n, D, [(i, lchild)])
)
print('c={}'.format(c))
if c <= U:
if A[n].get(c) is None or A[lchild][i] + reward > A[n][c]:
A[n][c] = A[lchild][i] + reward
D[n][c] = D[lchild][i] | {n}
BP[n][c] = [(lchild, i)]
for i in A[rchild]:
c = cost_func(n, D, G,
[(i, rchild)])
assert isinstance(c, int)
if c <= U:
if A[n].get(c) is None or A[rchild][i] + reward > A[n][c]:
A[n][c] = A[rchild][i] + reward
D[n][c] = D[rchild][i] | {n}
BP[n][c] = [(rchild, i)]
for i in A[lchild]:
for j in A[rchild]:
c = cost_func(n, D, G,
[(i, lchild), (j, rchild)])
assert isinstance(c, int)
lset, rset = D[lchild][i], D[rchild][j]
if c <= U:
if (A[n].get(c) is None or
A[lchild][i] + A[rchild][j] + reward > A[n][c]) and \
len(lset & rset) == 0:
A[n][c] = A[lchild][i] + A[rchild][j] + reward
D[n][c] = D[lchild][i] | D[rchild][j] | {n}
BP[n][c] = [(lchild, i), (rchild, j)]
if n == r: # no need to continue once we processed root
break
best_cost = max(xrange(U + 1),
key=lambda i: A[r][i] if i in A[r] else float('-inf'))
tree = DiGraph()
tree.add_node(r)
stack = []
if debug and len(stack) == 0:
print('stack empty')
print(A)
for n, cost in BP[r][best_cost]:
stack.append((r, n, cost))
while len(stack) > 0:
if debug:
print('stack size: {}'.format(len(stack)))
print('stack: {}'.format(stack))
parent, child, cost = stack.pop(0)
tree.add_edge(parent, child)
# copy the attributes
tree[parent][child] = G[parent][child]
tree.node[parent] = G.node[parent]
tree.node[child] = G.node[child]
for grandchild, cost2 in BP[child][cost]:
if debug:
print(grandchild, cost2)
stack.append((child, grandchild, cost2))
return tree
示例14: lst_dag
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
#.........这里部分代码省略.........
print("total #nodes {}".format(len(ns)))
A, D, BP = {}, {}, {}
for n in ns:
A[n] = {} # maximum sum of node u at a cost i
A[n][0] = G.node[n][node_reward_key]
D[n] = {} # set of nodes included corresponding to A[u][i]
D[n][0] = {n}
BP[n] = defaultdict(list) # backpointer corresponding to A[u][i]
for n_i, n in enumerate(
topological_sort(G, reverse=True)): # leaves come first
if debug:
print("#nodes processed {}".format(n_i))
children = G.neighbors(n)
reward = G.node[n][node_reward_key]
if len(children) == 1:
child = children[0]
w = G[n][child][edge_cost_key]
for i in xrange(U, w - 1, -1):
if (i-w) in A[child]:
A[n][i] = A[child][i-w] + reward
D[n][i] = D[child][i-w] | {n}
BP[n][i] = [(child, i-w)]
elif len(children) > 1:
lchild, rchild = children
lw = G[n][lchild][edge_cost_key]
rw = G[n][rchild][edge_cost_key]
for i in A[lchild]:
c = lw + i
if debug:
print('n={}, D={}, cost_child_tuples={}'.format(
n, D, [(i, lchild)])
)
print('c={}'.format(c))
if c <= U:
if A[n].get(c) is None or A[lchild][i] + reward > A[n][c]:
A[n][c] = A[lchild][i] + reward
D[n][c] = D[lchild][i] | {n}
BP[n][c] = [(lchild, i)]
for i in A[rchild]:
c = rw + i
if c <= U:
if A[n].get(c) is None or A[rchild][i] + reward > A[n][c]:
A[n][c] = A[rchild][i] + reward
D[n][c] = D[rchild][i] | {n}
BP[n][c] = [(rchild, i)]
for i in A[lchild]:
for j in A[rchild]:
c = lw + rw + i + j
if c <= U:
if (A[n].get(c) is None or
A[lchild][i] + A[rchild][j] + reward > A[n][c]) and \
len(D[lchild][i] & D[rchild][j]) == 0:
A[n][c] = A[lchild][i] + A[rchild][j] + reward
D[n][c] = D[lchild][i] | D[rchild][j] | {n}
BP[n][c] = [(lchild, i), (rchild, j)]
# if n == r: # no need to continue once we processed root
# break
if debug:
print('A[r]', A[r])
best_cost = max(xrange(U + 1),
key=lambda i: A[r][i] if i in A[r] else float('-inf'))
if debug:
print("best_cost", best_cost)
tree = DiGraph()
tree.add_node(r)
stack = []
for n, cost in BP[r][best_cost]:
stack.append((r, n, cost))
while len(stack) > 0:
# if debug:
# print('stack size: {}'.format(len(stack)))
# print('stack: {}'.format(stack))
parent, child, cost = stack.pop(0)
tree.add_edge(parent, child)
# copy the attributes
tree[parent][child] = G[parent][child]
tree.node[parent] = G.node[parent]
tree.node[child] = G.node[child]
for grandchild, cost2 in BP[child][cost]:
# if debug:
# print(grandchild, cost2)
stack.append((child, grandchild, cost2))
return tree
示例15: __init__
# 需要导入模块: from networkx.classes.digraph import DiGraph [as 别名]
# 或者: from networkx.classes.digraph.DiGraph import add_edge [as 别名]
class StadynaMcgAnalysis:
def __init__(self):
self.androGuardObjects = []
self.nodes = {}
self.nodes_id = {}
self.entry_nodes = []
self.G = DiGraph()
# self.internal_methods = []
#self.GI = DiGraph()
def analyseFile(self, vmx, apk):
vm = vmx.get_vm()
self.androGuardObjects.append((apk, vm, vmx))
# self.internal_methods.extend(vm.get_methods())
#creating real internal nodes
internal_called_methods = vmx.get_tainted_packages().stadyna_get_internal_called_methods()
for method in internal_called_methods:
class_name, method_name, descriptor = method
nodeType = None
if method_name == "<clinit>":
nodeType = NODE_STATIC_INIT
elif method_name == "<init>":
nodeType = NODE_CONSTRUCTOR
else:
nodeType = NODE_METHOD
n = self._get_node(nodeType, (class_name, method_name, descriptor))
n.set_attribute(ATTR_CLASS_NAME, class_name)
n.set_attribute(ATTR_METHOD_NAME, method_name)
n.set_attribute(ATTR_DESCRIPTOR, descriptor)
self.G.add_node(n.id)
#creating real edges (nodes are already there)
#currently we are working only with internal packages.
for j in vmx.get_tainted_packages().get_internal_packages():
src_class_name, src_method_name, src_descriptor = j.get_src(vm.get_class_manager())
dst_class_name, dst_method_name, dst_descriptor = j.get_dst(vm.get_class_manager())
n1 = self._get_existed_node((src_class_name, src_method_name, src_descriptor))
# n1.set_attribute(ATTR_CLASS_NAME, src_class_name)
# n1.set_attribute(ATTR_METHOD_NAME, src_method_name)
# n1.set_attribute(ATTR_DESCRIPTOR, src_descriptor)
n2 = self._get_existed_node((dst_class_name, dst_method_name, dst_descriptor))
# n2.set_attribute(ATTR_CLASS_NAME, dst_class_name)
# n2.set_attribute(ATTR_METHOD_NAME, dst_method_name)
# n2.set_attribute(ATTR_DESCRIPTOR, dst_descriptor)
self.G.add_edge(n1.id, n2.id)
#adding fake class nodes
for method in internal_called_methods:
src_class_name, src_method_name, src_descriptor = method
if src_method_name == "<init>" or src_method_name == "<clinit>":
n1 = self._get_existed_node((src_class_name, src_method_name, src_descriptor))
n2 = self._get_node(NODE_FAKE_CLASS, src_class_name, None, False)
n2.set_attribute(ATTR_CLASS_NAME, src_class_name)
if src_method_name == "<clinit>":
self.G.add_edge(n1.id, n2.id)
elif src_method_name == "<init>":
self.G.add_edge(n2.id, n1.id)
#real (external) reflection invoke nodes
reflection_invoke_paths = analysis.seccon_get_invoke_method_paths(vmx)
for j in reflection_invoke_paths:
src_class_name, src_method_name, src_descriptor = j.get_src( vm.get_class_manager() )
dst_class_name, dst_method_name, dst_descriptor = j.get_dst( vm.get_class_manager() )
n1 = self._get_existed_node((src_class_name, src_method_name, src_descriptor))
if n1 == None:
logger.warning("Cannot find the node [%s], where reflection invoke is called!" % (src_class_name, src_method_name, src_descriptor))
continue
key = "%s %s %s %s %s %s %s" % (src_class_name, src_method_name, src_descriptor, dst_class_name, dst_method_name, dst_descriptor, POSTFIX_REFL_INVOKE)
n2 = self._get_node(NODE_REFL_INVOKE, key, LABEL_REFL_INVOKE, True)
n2.set_attribute(ATTR_CLASS_NAME, src_class_name)
n2.set_attribute(ATTR_METHOD_NAME, src_method_name)
n2.set_attribute(ATTR_DESCRIPTOR, src_descriptor)
self.G.add_edge( n1.id, n2.id )
#real (external) reflection new instance nodes
reflection_newInstance_paths = analysis.seccon_get_newInstance_method_paths(vmx)
for j in reflection_newInstance_paths:
src_class_name, src_method_name, src_descriptor = j.get_src( vm.get_class_manager() )
dst_class_name, dst_method_name, dst_descriptor = j.get_dst( vm.get_class_manager() )
n1 = self._get_existed_node((src_class_name, src_method_name, src_descriptor))
if n1 == None:
#.........这里部分代码省略.........