Python Dot.write方法代码示例

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def save(self, cfg, filename, print_ir=False, format='dot', options=None):
        """Save basic block graph into a file.
        """
        if options is None:
            options = {}

        try:
            dot_graph = Dot(**self.graph_format)

            # Add nodes.
            nodes = {}
            for bb in cfg.basic_blocks:
                nodes[bb.address] = self._create_node(bb, cfg.name, print_ir, options)

                dot_graph.add_node(nodes[bb.address])

            # Add edges.
            for bb_src in cfg.basic_blocks:
                for bb_dst_addr, branch_type in bb_src.branches:
                    edge = self._create_edge(nodes[bb_src.address], nodes[bb_dst_addr], branch_type)

                    dot_graph.add_edge(edge)

            # Save graph.
            dot_graph.write("{}.{}".format(filename, format), format=format)
        except Exception:
            logger.error("Failed to save basic block graph: %s (%s)", filename, format, exc_info=True)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def draw(self, name, dname, draw_branches=True):
        """
        Writes the current graph as a PNG file

        :param str name: filename (without .png)
        :param str dname: directory of the output png
        :param draw_branches:
        :return:
        """
        from pydot import Dot, Edge
        import os

        g = Dot()
        g.set_node_defaults(color='lightgray',
                            style='filled',
                            shape='box',
                            fontname='Courier',
                            fontsize='10')
        for node in sorted(self.nodes, key=lambda x: x.num):
            if draw_branches and node.type.is_cond:
                g.add_edge(Edge(str(node), str(node.true), color='green'))
                g.add_edge(Edge(str(node), str(node.false), color='red'))
            else:
                for suc in self.sucs(node):
                    g.add_edge(Edge(str(node), str(suc), color='blue'))
            for except_node in self.catch_edges.get(node, []):
                g.add_edge(Edge(str(node),
                                str(except_node),
                                color='black',
                                style='dashed'))

        g.write(os.path.join(dname, '%s.png' % name), format='png')

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def write(self, filename, format="png", append_ext=False, prog="dot"):
        "Builds a pydot graph and writes to file"
        from pydot import Dot, Edge, Node

        dot = Dot(graph_type='digraph', **self.graph_attributes)
        if format not in dot.formats:
            raise GraphException("invalid format '%s'" % format)
        node_cache = {}

        def get_node(s):
            try:
                return node_cache[s]
            except KeyError:
                node = Node(s, **self.node_attributes.get(s, {}))
                dot.add_node(node)
                node_cache[s] = node
                return node

        for (s0, s1), attr in self.edge_attributes.iteritems():
            dot.add_edge(Edge(get_node(s0), get_node(s1),
                            **self.edge_attributes.get((s0, s1), {})))

        for node in self.get_orphaned_nodes():
            get_node(node)

        if append_ext:
            filename = "%s.%s" % (filename, format)
        dot.write(filename, format=format, prog=prog)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def save(self, filename, print_ir=False, format='dot'):
        """Save basic block graph into a file.
        """
        node_format = {
            'shape' : 'Mrecord',
            'rankdir' : 'LR',
            'fontname' : 'monospace',
            'fontsize' : '9.0'
        }

        edge_format = {
            'fontname' : 'monospace',
            'fontsize' : '8.0'
        }

        edge_colors = {
            'taken' : 'green',
            'not-taken' : 'red',
            'direct' : 'blue'
        }

        try:
            # for each conneted component
            for idx, gr in enumerate(networkx.connected_component_subgraphs(self._graph.to_undirected())):
                graph = Dot(graph_type="digraph", rankdir="TB")

                # add nodes
                nodes = {}
                for bb_addr in gr.node.keys():
                    dump = self._dump_bb(self._bb_by_addr[bb_addr], print_ir)

                    # html-encode colon character
                    dump = dump.replace("!", "!")
                    dump = dump.replace("#", "#")
                    dump = dump.replace(":", ":")
                    dump = dump.replace("{", "{")
                    dump = dump.replace("}", "}")

                    label = "{<f0> 0x%08x | %s}" % (bb_addr, dump)

                    nodes[bb_addr] = Node(bb_addr, label=label, **node_format)

                    graph.add_node(nodes[bb_addr])

                # add edges
                for bb_src_addr in gr.node.keys():
                    for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches:
                        graph.add_edge(Edge(nodes[bb_src_addr],
                            nodes[bb_dst_addr], label=branch_type, \
                            color=edge_colors[branch_type], **edge_format))

                graph.write("%s_%03d.%s" % (filename, idx, format), format=format)
        except Exception as err:
            import traceback
            import sys
            print("[E] Error loading BARF (%s:%d) : '%s'" %
                (__name__, sys.exc_traceback.tb_lineno, str(err)))
            print("")
            print(traceback.format_exc())

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def write(self, f_name):
        """write the DOT file to *fName*

        """
        for node in self.node_list:
            node.sync()
        Dot.write(self, f_name)
        # FixQuoteBug(fName, float(self.net_desc['link_attr']['delay']))
        FixQuoteBug(f_name)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
def main(infilename, outfilename):
    state_obj = yaml.load(open(infilename))
    assert(isinstance(state_obj, dict))
    assert(len(state_obj) == 1)
    state_obj = state_obj.values()[0]
    assert(isinstance(state_obj, list))
    graph = Dot("states", graph_type='digraph')

    # First, create all graph nodes
    nodes, nodemap = generate_nodes(graph, state_obj)
    # Then, generate our links
    generate_links(graph, state_obj, nodes, nodemap)
    graph.write(outfilename)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def draw(self, path: str, format: str = "raw") -> None:

        node_aggr = {}
        for node in self._nodes:
            level = node.get_level()
            label = node.get_label()
            identifier = node.get_id()
            if node_aggr.get(level) is None:
                node_aggr[level] = {}
            if level != 0:
                gv_cluster = GVCluster(identifier)
                gv_cluster.set("label", label)
                node_aggr[level][identifier] = gv_cluster
            else:
                gv_node = GVNode(identifier)
                gv_node.set("label", label)
                node_aggr[level][identifier] = gv_node

        gv_dot = GVDot()
        gv_dot.set("ranksep", "1.0 equally")

        if self._lable is not None:
            gv_dot.set("label", self._lable)

        for node in self._nodes:
            level = node.get_level()
            parent = node.get_parent()
            parent_level = node.get_parent_level()
            identifier = node.get_id()
            if level != 0:
                if parent is not None:
                    node_aggr[parent_level][parent].add_subgraph(node_aggr[level][identifier])
                else:
                    gv_dot.add_subgraph(node_aggr[level][identifier])
            else:
                if parent is not None:
                    node_aggr[parent_level][parent].add_node(node_aggr[level][identifier])
                else:
                    gv_dot.add_node(node_aggr[level][identifier])

        for edge in self._edges:
            label = edge.get_label()
            gv_edge = GVEdge(edge.get_src(), edge.get_dst())
            if label is not None:
                gv_edge.set("label", edge.get_label())
            gv_dot.add_edge(gv_edge)

        gv_dot.write(path, format=format)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
def main(input):
    state_obj = yaml.load(input)
    graph = Dot("states", graph_type='digraph')

    rules = {
        'require': {'color': 'blue'},
        'require_in': {'color': 'blue', 'reverse': True},
        'watch': {'color': 'red'},
        'watch_in': {'color': 'red', 'reverse': True},
    }

    for top_key, props in state_obj.iteritems():
        # Add a node for each state type embedded in this state
        # keys starting with underscores are not candidates

        if top_key == '__extend__':
            # TODO - merge these into the main states and remove them
            sys.stderr.write(
                    "Removing __extend__ states:\n{0}\n".format(str(props)))
            continue

        for top_key_type, states in props.iteritems():
            if top_key_type[:2] == '__':
                continue

            node_name = make_node_name(top_key_type, top_key)
            graph.add_node(Node(node_name))

            for edge_type, ruleset in rules.iteritems():
                for relname in find_edges(states, edge_type):
                    if 'reverse' in ruleset and ruleset['reverse']:
                        graph.add_edge(Edge(
                            node_name, relname, color=ruleset['color']))
                    else:
                        graph.add_edge(Edge(
                            relname, node_name, color=ruleset['color']))

    graph.write('/dev/stdout')

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def save(self, cf, filename, format='dot'):
        """Save basic block graph into a file.
        """
        try:
            dot_graph = Dot(**self.graph_format)

            # add nodes
            nodes = {}
            for cfg_addr in cf._graph.node.keys():
                nodes[cfg_addr] = self._create_node(cfg_addr, cf)

                dot_graph.add_node(nodes[cfg_addr])

            # add edges
            for cfg_src_addr in cf._graph.node.keys():
                for cfg_dst_addr in cf._edges.get(cfg_src_addr, []):
                    edge = self._create_edge(nodes, cfg_src_addr, cfg_dst_addr)

                    dot_graph.add_edge(edge)

            dot_graph.write("{}.{}".format(filename, format), format=format)
        except Exception:
            logger.error("Failed to save call graph: %s (%s)", filename, format, exc_info=True)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
class Sitemap(object):
    URI_FAILURE = "failed to read URI '%s'"
    current_contents = None
    base_uri = None
    base_url = None
    current_uri = None
    current_url = None
    site_graph = None

    def __init__(self):
        self.site_dict = { 'pages': [],
                           'links': {},
                           'assets': { 'imgs': [],
                                       'scripts': [],
                                       'stylesheets': [] }
                         }

    def from_uri(self, uri, render_opts={}):
        """ sets the instance URI and renders a sitemap image
        """
        self.base_uri = uri
        self.base_url = urlparse(uri)
        if self.traverse_site( uri ):
            self.render_sitemap( render_opts )
        else:
            return self.URI_FAILURE % uri

    def build_site_graph(self):
        self.site_graph = Dot(graph_type='digraph')
        self.site_graph.set_label( 'Sitemap for "%s"' % self.base_uri )
        self.site_graph.set_simplify( True )
        # add nodes
        for page in self.site_dict['pages']:
            self.site_graph.add_node( page.to_node() )
        # add edges
        for page in self.site_dict['pages']:
            from_node = page.uri
            for link in page.attributes['links']:
              to_node = link
              self.site_graph.add_edge( Edge(from_node, to_node) )

    def render_sitemap(self, options={}):
        if self.site_graph is None:
            self.build_site_graph()
        file_fmt = 'png'
        if 'format' in options.keys() and options['format'] is not None:
            file_fmt = options['format']
        filename = 'sitemap.%s' % file_fmt
        if 'filename' in options.keys() and options['filename'] is not None:
            filename = options['filename']
        self.site_graph.write(filename, 'dot', file_fmt)
        # with open(filename, 'w') as sitemap_img:
        #     sitemap_img.write("TODO")


    def traverse_site(self, uri_str):
        if self.validate_uri( uri_str ):
          # populate site_dict
          print "%d traversing %s" % (int(time.time()), uri_str)
          page_dict = { 'assets': { 'imgs': [],
                                    'scripts': [],
                                    'stylesheets': []
                                  },
                        'links': []
                      }
          self.current_contents = urllib.urlopen( uri_str ).read()
          self.current_uri = uri_str
          self.current_url = urlparse( uri_str )
          self.base_url = self.base_url or self.current_url
          html_doc = BeautifulSoup( self.current_contents )
          # get all scripts, stylesheets and images
          for script in html_doc.find_all('script'):
              src = script.get('src')
              if src is not None:
                  page_dict['assets']['scripts'].append( src )
          sset = set(self.site_dict['assets']['scripts'])
          pset = set(page_dict['assets']['scripts'])
          # list of unique js sources for the site
          self.site_dict['assets']['scripts'] = list( sset | pset )

          for css in html_doc.select('link[rel="stylesheet"]'):
              href = css.get('href')
              if href is not None:
                  page_dict['assets']['stylesheets'].append( href )
          sset = set(self.site_dict['assets']['stylesheets'])
          pset = set(page_dict['assets']['stylesheets'])
          # list of unique stylesheets for the site
          self.site_dict['assets']['stylesheets'] = list( sset | pset )

          for img in html_doc.select('img'):
              src = img.get('src')
              if src is not None and src not in page_dict['assets']['imgs']:
                  page_dict['assets']['imgs'].append( src )
          sset = set(self.site_dict['assets']['imgs'])
          pset = set(page_dict['assets']['imgs'])
          # list of unique images for the site
          self.site_dict['assets']['imgs'] = list( sset | pset )

          # get all internal links on the page
          for link in html_doc.select('a'):
#.........这里部分代码省略.........

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def create_graph(self, image_format, image_path):
        from pydot import Dot, Edge, Node

        graph = Dot(graph_type='digraph')

        graph_nodes = {}
        graph_edges = {}
        done = set()

        def add_node(node, expanded=False, chosen=False, in_fringe=False,
                     in_successors=False, solution=False):
            node_id = id(node)
            if node_id not in graph_nodes:
                label = node.state_representation()
                if hasattr(node, 'cost'):
                    label += '\nCost: %s' % node.cost
                if hasattr(node, 'heuristic'):
                    label += '\nHeuristic: %s' % node.heuristic
                if hasattr(node, 'value'):
                    label += '\nValue: %s' % node.value

                new_g_node = Node(node_id,
                                  label=label,
                                  style='filled',
                                  shape='circle',
                                  fillcolor='#ffffff',
                                  fontsize=self.font_size)

                graph_nodes[node_id] = new_g_node

            g_node =  graph_nodes[node_id]

            if expanded or chosen:
                g_node.set_fillcolor(self.fringe_color)
            if in_fringe:
                g_node.set_color(self.fringe_color)
                g_node.set_penwidth(3)
            if in_successors:
                g_node.set_color(self.successor_color)
                g_node.set_fontcolor(self.successor_color)
            if solution:
                g_node.set_fillcolor(self.solution_color)

            return g_node

        def add_edge_to_parent(node, is_successor=False, parent=None):
            if parent is None:
                parent = node.parent

            g_node = add_node(node, in_successors=is_successor)
            g_parent_node = add_node(parent)

            edge = Edge(g_parent_node,
                        g_node,
                        label=node.action_representation(),
                        fontsize=self.font_size)

            if is_successor:
                edge.set_color(self.successor_color)
                edge.set_labelfontcolor(self.successor_color)

            graph_edges[id(node), id(parent)] = edge

        if self.last_event.name == 'chosen_node':
            add_node(self.last_chosen, chosen=True)

        if self.last_event.name == 'finished':
            if self.solution_node:
                add_node(self.solution_node, solution=True)

        if self.last_event.name == 'expanded':
            for node, successors in zip(self.last_expandeds,
                                        self.last_successors):
                add_node(node, expanded=True)
                for successor_node in successors:
                    add_edge_to_parent(successor_node,
                                       is_successor=True,
                                       parent=node)

        for node in self.current_fringe:
            add_node(node, in_fringe=True)
            while node is not None and node not in done:
                if node.parent is not None:
                    add_edge_to_parent(node)
                else:
                    add_node(node)

                done.add(node)
                node = node.parent

        for node_id in sorted(graph_nodes.keys()):
            graph.add_node(graph_nodes[node_id])
        for node_id, parent_id in sorted(graph_edges.keys()):
            graph.add_edge(graph_edges[node_id, parent_id])

        graph.write(image_path, format=image_format)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]

#.........这里部分代码省略.........
            'fontname'  : fontname,
            'fontsize'  : 9.0,
            'penwidth'  : 0.5,
            'rankdir'   : 'LR',
            'shape'     : 'plaintext',
        }

        node_format_entry = {
            'pencolor' : 'orange',
        }

        node_format_exit = {
            'pencolor' : 'gray',
        }

        node_format_entry_exit = {
            'pencolor' : 'gray',
        }

        edge_format = {
            'arrowhead' : 'vee',
            'arrowsize' : 0.6,
            'fontname'  : fontname,
            'fontsize'  : 8.0,
            'penwidth'  : 0.5,
        }

        edge_colors = {
            'direct'    : 'blue',
            'not-taken' : 'red',
            'taken'     : 'darkgreen',
        }

        try:
            dot_graph = Dot(**graph_format)

            # add nodes
            nodes = {}
            for bb_addr in self._graph.node.keys():
                # Skip jmp/jcc to sub routines.
                if not bb_addr in self._bb_by_addr:
                    continue

                bb_dump = self._dump_bb_ex(self._bb_by_addr[bb_addr], print_ir)

                if self._bb_by_addr[bb_addr].is_entry and not self._bb_by_addr[bb_addr].is_exit:
                    node_format = dict(node_format_base, **node_format_entry)
                elif self._bb_by_addr[bb_addr].is_exit and not self._bb_by_addr[bb_addr].is_entry:
                    node_format = dict(node_format_base, **node_format_exit)
                elif self._bb_by_addr[bb_addr].is_entry and self._bb_by_addr[bb_addr].is_exit:
                    node_format = dict(node_format_base, **node_format_entry_exit)
                else:
                    node_format = dict(node_format_base)

                if self._bb_by_addr[bb_addr].is_entry:
                    bb_label = "{} @ {:x}".format(self._name, bb_addr)
                else:
                    bb_label = "loc_{:x}".format(bb_addr)

                label  = '<'
                label += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">'
                label += '  <tr><td align="center" cellpadding="1" port="enter"></td></tr>'
                label += '  <tr><td align="left" cellspacing="1">{label}</td></tr>'
                label += '  {assembly}'
                label += '  <tr><td align="center" cellpadding="1" port="exit" ></td></tr>'
                label += '</table>'
                label += '>'

                label = label.format(label=bb_label, assembly=bb_dump)

                nodes[bb_addr] = Node(bb_addr, label=label, **node_format)

                dot_graph.add_node(nodes[bb_addr])

            # add edges
            for bb_src_addr in self._graph.node.keys():
                # Skip jmp/jcc to sub routines.
                if not bb_src_addr in self._bb_by_addr:
                    continue

                for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches:
                    # Skip jmp/jcc to sub routines.
                    if not bb_dst_addr in self._bb_by_addr:
                        continue

                    dot_graph.add_edge(
                        Edge(nodes[bb_src_addr],
                             nodes[bb_dst_addr],
                             color=edge_colors[branch_type],
                             **edge_format))

            # Save graph.
            dot_graph.write("{}.{}".format(filename, format), format=format)
        except Exception as err:
           logger.error(
                "Failed to save basic block graph: %s (%s)",
                filename,
                format,
                exc_info=True
            )

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def save(self, filename, print_ir=False, format='dot'):
        """Save basic block graph into a file.
        """
        node_format = {
            'shape'    : 'Mrecord',
            'rankdir'  : 'LR',
            'fontname' : 'monospace',
            'fontsize' : '9.0',
        }

        edge_format = {
            'fontname' : 'monospace',
            'fontsize' : '8.0',
        }

        edge_colors = {
            'taken'     : 'green',
            'not-taken' : 'red',
            'direct'    : 'blue',
        }

        html_entities = {
            "!" : "!",
            "#" : "#",
            ":" : ":",
            "{" : "{",
            "}" : "}",
        }

        try:
            dot_graph = Dot(graph_type="digraph", rankdir="TB")

            # Add nodes.
            nodes = {}
            for bb_addr in self._bb_by_addr:
                bb_dump = self._dump_bb(self._bb_by_addr[bb_addr], print_ir)

                # html-encode colon character
                for char, encoding in html_entities.items():
                    bb_dump = bb_dump.replace(char, encoding)

                label = "{{<f0> {:#010x} | {}}}".format(bb_addr, bb_dump)

                nodes[bb_addr] = Node(bb_addr, label=label, **node_format)

                dot_graph.add_node(nodes[bb_addr])

            # Add edges.
            for bb_src_addr in self._bb_by_addr:
                for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches:
                    # Skip jmp/jcc to sub routines.
                    if not bb_dst_addr in self._bb_by_addr:
                        continue

                    dot_graph.add_edge(
                        Edge(
                            nodes[bb_src_addr],
                            nodes[bb_dst_addr],
                            color=edge_colors[branch_type],
                            **edge_format))

            # Save graph.
            dot_graph.write("{}.{}".format(filename, format), format=format)
        except Exception:
            logger.error(
                "Failed to save basic block graph: %s (%s)",
                filename,
                format,
                exc_info=True
            )

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]
    def save_ex(self, filename, print_ir=False, format='dot'):
        """Save basic block graph into a file.
        """

        fontname = 'Ubuntu Mono'
        # fontname = 'DejaVu Sans Mono'
        # fontname = 'DejaVu Sans Condensed'
        # fontname = 'DejaVu Sans Light'
        # fontname = 'Liberation Mono'
        # fontname = 'DejaVu Serif Condensed'
        # fontname = 'Ubuntu Condensed'

        node_format = {
            'shape'     : 'plaintext',
            'rankdir'   : 'LR',
            'fontname'  : fontname,
            'fontsize'  : 9.0,
            'penwidth'  : 0.5,
            # 'style'     : 'filled',
            # 'fillcolor' : 'orange',
        }

        edge_format = {
            'fontname'  : fontname,
            'fontsize'  : 8.0,
            'penwidth'  : 0.5,
            'arrowsize' : 0.6,
            'arrowhead' : 'vee',
        }

        edge_colors = {
            'taken'     : 'darkgreen',
            'not-taken' : 'red',
            'direct'    : 'blue',
        }

        try:
            # for each conneted component
            for idx, gr in enumerate(networkx.connected_component_subgraphs(self._graph.to_undirected())):
                graph = Dot(graph_type="digraph", rankdir="TB", splines="ortho", nodesep=1.2)

                # add nodes
                nodes = {}
                for bb_addr in gr.node.keys():
                    # Skip jmp/jcc to sub routines.
                    if not bb_addr in self._bb_by_addr:
                        continue

                    dump = self._dump_bb_ex(self._bb_by_addr[bb_addr], print_ir)

                    label  = '<'
                    label += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">'
                    label += '  <tr><td align="center" cellpadding="1" port="enter"></td></tr>'
                    if self._bb_by_addr[bb_addr].label:
                        label += '  <tr><td align="left" cellspacing="1">{}</td></tr>'.format(self._bb_by_addr[bb_addr].label)
                    else:
                        label += '  <tr><td align="left" cellspacing="1">loc_{address:x}</td></tr>'
                    label += '  {assembly}'
                    label += '  <tr><td align="center" cellpadding="1" port="exit" ></td></tr>'
                    label += '</table>'
                    label += '>'

                    if self._bb_by_addr[bb_addr].is_entry:
                        node_format['style'] = 'filled'
                        node_format['fillcolor'] = 'orange'

                    label = label.format(address=bb_addr, assembly=dump)

                    nodes[bb_addr] = Node(bb_addr, label=label, **node_format)

                    graph.add_node(nodes[bb_addr])

                # add edges
                for bb_src_addr in gr.node.keys():
                    # Skip jmp/jcc to sub routines.
                    if not bb_src_addr in self._bb_by_addr:
                        continue

                    for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches:
                        # Skip jmp/jcc to sub routines.
                        if not bb_dst_addr in self._bb_by_addr:
                            continue

                        graph.add_edge(
                            Edge(nodes[bb_src_addr],
                            nodes[bb_dst_addr],
                            color=edge_colors[branch_type],
                            **edge_format))

                graph.write("%s_%03d.%s" % (filename, idx, format), format=format)
        except Exception as err:
           logger.error(
                "Failed to save basic block graph: %s (%s)",
                filename,
                format,
                exc_info=True
            )

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import write [as 别名]

#.........这里部分代码省略.........
                for n in nodes_at_addr:
                    if node_matches(n, trace[:i+1]):
                        node_path.append(n)
                        break
    
    active_nodes = set(node_path)
    active_edges = {}
    
    if len(node_path) > 0:
        for s,t in zip(node_path[:-1],node_path[1:]):
            if s not in active_edges:
                active_edges[s] = set()
            active_edges[s].add(t)


    for node in sorted(filter(lambda _: _ != None,ccfg_graph.nodes()), key=lambda _: _.addr):
    
        attributes=[]
        if node.is_simprocedure:
            attributes.append("SIMP")
        if node.is_syscall:
            attributes.append("SYSC")
        if node.no_ret:
            attributes.append("NORET")
        if len(attributes) == 0:
            blocks[node.addr] = cfg.project.factory.block(addr=node.addr, max_size=node.size)
        else:
            blocks[node.addr] = cfg.project.factory.block(addr=node.addr)
        
        nmap[node] = nidx
        nidx += 1
        label = "{{<f0> {:#08x} ({:#08x}) {} {}".format(node.addr, node.function_address, node.name, ' '.join(attributes))
        if not node.is_simprocedure:
            if asminst:
                label += "| " + print_asm(blocks[node.addr])
            if vexinst:
                label += "| " + print_vex(blocks[node.addr])
        if debug_info:
            label += "| " + node_debug_info(node)
        label += "}}"

        penwidth = '1'
        if node in active_nodes:
            penwidth = '3'

        if not node.is_simprocedure:
            nodes[nmap[node]] = Node(nmap[node], label=label, penwidth=penwidth, **default_node_attributes)
        else:
            if node.simprocedure_name == "PathTerminator":
                nodes[nmap[node]] = Node(nmap[node], label=label, penwidth=penwidth, style="filled", fillcolor="#dd5555", **default_node_attributes)
            else:
                nodes[nmap[node]] = Node(nmap[node], label=label, penwidth=penwidth, style="filled", fillcolor="#dddddd", **default_node_attributes)
        dot_graph.add_node(nodes[nmap[node]])

    #for n in ccfg.graph.nodes():
    #    nn = filter(lambda node: node in nmap, cfg.get_all_nodes(n.addr))
    #    if len(nn)>1:
    #        for n in nn[1:]:
    #            dot_graph.add_edge(Edge(nodes[nmap[nn[0]]],nodes[nmap[n]],style="invis"))

    edgeprop = {}    
    for source,target in ccfg_graph.edges():
        if source == None or target == None:
            continue
        key = (nmap[source], nmap[target])

        edge_style='solid'
        if not key in edgeprop:
            if blocks[source.addr].vex.jumpkind == 'Ijk_Boring':
                if len(blocks[source.addr].vex.constant_jump_targets) > 1:
                    if len (blocks[source.addr].vex.next.constants) == 1:
                        if target.addr == blocks[source.addr].vex.next.constants[0].value:
                            color=EDGECOLOR_CONDITIONAL_FALSE
                        else:
                            color=EDGECOLOR_CONDITIONAL_TRUE
                    else:
                        color=EDGECOLOR_UNKNOWN
                else:
                    color=EDGECOLOR_UNCONDITIONAL
            elif blocks[source.addr].vex.jumpkind == 'Ijk_Call':
                color=EDGECOLOR_CALL
                if len (blocks[source.addr].vex.next.constants) == 1 and blocks[source.addr].vex.next.constants[0].value != target.addr:
                    edge_style='dotted'
            elif blocks[source.addr].vex.jumpkind == 'Ijk_Ret':
                color=EDGECOLOR_RET
            else:
                color=EDGECOLOR_UNKNOWN
    
            penwidth='1'
            if source in active_edges and target in active_edges[source]:
                penwidth='3'
            
            edgeprop[key]= {
                "color" : color,
                "penwidth": penwidth,
            }
        
        dot_graph.add_edge(Edge(nodes[nmap[source]],nodes[nmap[target]],color=edgeprop[key]["color"], style=edge_style, penwidth=edgeprop[key]["penwidth"], **default_edge_attributes))
    
    dot_graph.write("{}.{}".format(fname, format), format=format)