Golang SubGraph.Exit方法代碼示例

// isPotential returns true if the graph node g is a potential candidate for the
// sub node s, and false otherwise.
func isPotential(g, s *dot.Node, sub *graphs.SubGraph) bool {
	// Verify predecessors.
	if s.Name != sub.Entry() && len(g.Preds) != len(s.Preds) {
		return false
	}
	// Verify successors.
	if s.Name != sub.Exit() && len(g.Succs) != len(s.Succs) {
		return false
	}
	return true
}

// Merge merges the nodes of the isomorphism of sub in graph into a single node.
// If successful it returns the name of the new node.
func Merge(graph *dot.Graph, m map[string]string, sub *graphs.SubGraph) (name string, err error) {
	var nodes []*dot.Node
	for _, gname := range m {
		node, ok := graph.Nodes.Lookup[gname]
		if !ok {
			return "", errutil.Newf("unable to locate mapping for node %q", gname)
		}
		nodes = append(nodes, node)
	}
	name = uniqName(graph, sub.Name)
	entry, ok := graph.Nodes.Lookup[m[sub.Entry()]]
	if !ok {
		return "", errutil.Newf("unable to locate mapping for entry node %q", sub.Entry())
	}
	exit, ok := graph.Nodes.Lookup[m[sub.Exit()]]
	if !ok {
		return "", errutil.Newf("unable to locate mapping for exit node %q", sub.Exit())
	}
	err = graph.Replace(nodes, name, entry, exit)
	if err != nil {
		return "", errutil.Err(err)
	}
	return name, nil
}

// isValid returns true if m is a valid mapping, from sub node name to graph
// node name, for an isomorphism of sub in graph considering all nodes and edges
// except predecessors of entry and successors of exit.
func (eq *equation) isValid(graph *dot.Graph, sub *graphs.SubGraph) bool {
	if len(eq.m) != len(sub.Nodes.Nodes) {
		return false
	}

	// Check for duplicate values.
	if hasDup(eq.m) {
		return false
	}

	// Verify that the entry node dominates the exit node.
	entry, ok := graph.Nodes.Lookup[eq.m[sub.Entry()]]
	if !ok {
		return false
	}
	exit, ok := graph.Nodes.Lookup[eq.m[sub.Exit()]]
	if !ok {
		return false
	}
	// TODO: Figure out how to handle find the if-statement in the following graph:
	//    digraph bar {
	//       E -> F
	//       E -> J
	//       F -> G
	//       F -> E
	//       G -> I
	//       I -> E
	//       E [label="entry"]
	//       F
	//       G
	//       I
	//       J [label="exit"]
	//    }
	//
	// ref: https://github.com/decomp/decompilation/issues/172
	if !entry.Dominates(exit) {
		return false
	}

	// Sort keys to make the algorithm deterministic.
	var snames []string
	for sname := range eq.m {
		snames = append(snames, sname)
	}
	sort.Strings(snames)

	for _, sname := range snames {
		gname := eq.m[sname]
		s, ok := sub.Nodes.Lookup[sname]
		if !ok {
			panic(fmt.Sprintf("unable to locate node %q in sub", sname))
		}
		g, ok := graph.Nodes.Lookup[gname]
		if !ok {
			panic(fmt.Sprintf("unable to locate node %q in graph", gname))
		}

		// Verify predecessors.
		if s.Name != sub.Entry() {
			if len(s.Preds) != len(g.Preds) {
				return false
			}
			for _, spred := range s.Preds {
				found := false
				for _, gpred := range g.Preds {
					if gpred.Name == eq.m[spred.Name] {
						found = true
						break
					}
				}
				if !found {
					return false
				}
			}
		}

		// Verify successors.
		if s.Name != sub.Exit() {
			if len(s.Succs) != len(g.Succs) {
				return false
			}
			for _, ssucc := range s.Succs {
				found := false
				for _, gsucc := range g.Succs {
					if gsucc.Name == eq.m[ssucc.Name] {
						found = true
						break
					}
				}
				if !found {
					return false
				}
			}
		}
	}

	// Isomorphism found!
//.........這裏部分代碼省略.........