8 | 
9 |
10 |
11 | Cnerator is a C source code generation tool. It can be used to generate large amounts of
12 | [standard ANSI/ISO C source code](https://www.iso.org/standard/74528.html), ready to be compiled
13 | by any standard language implementation.
14 | Cnerator is highly customizable to generate all the syntactic constructs of the C language, necessary to build
15 | accurate predictive models with machine learning algorithms.
16 |
17 | ## Functionalities
18 |
19 | These are the main functionalities provided by Cnerator:
20 |
21 | 1. _ANSI/ISO standard C_. All the source code generated by Cnerator follows the ISO/IEC 9899:2018 (C17)
22 | standard specification.
23 |
24 | 2. _Probabilistic randomness_. C language constructs are randomly generated, following different probability
25 | distributions specified by the user. For example, it is possible to describe the probability of each statement
26 | and expression construct, the number of statements in a function, and the types of their arguments and return values.
27 | To this aim, the user can specify fixed probabilities of each element, or use different probability distributions,
28 | such as normal, uniform and direct and inverse proportional.
29 |
30 | 3. _Compilable code_. The generated code strictly follows the syntax grammar, type system and semantic
31 | rules of the C programming language. In this way, the generated code has been checked to be compilable
32 | by any standard compiler implementation.
33 |
34 | 4. _Highly customizable_. Many features of the programs to be generated are customizable.
35 | Some examples include the types of each language construct, array dimensions and sizes, struct fields,
36 | maximum depth of expression and statement trees, number of function parameters and statements,
37 | global and local variables, structures of control flow statements and type promotions,
38 | among others –see the detailed [documentation](user-manual.md).
39 |
40 | 5. _Large amounts of code_. Cnerator is designed to allow generating large amounts of C source code.
41 | A parameter indicates the number of independent compilation units to be created for the output application,
42 | so that each unit could be treated as an independently compilable module. This feature, together with the
43 | probabilistic randomness, make Cnerator an ideal tool to create predictive models of source code, because
44 | the input programs used to train such models comprise abundant and varied code patterns.
45 |
46 | ## Usage
47 |
48 | To run Cnerator, you need to install the `numpy` Python package:
49 |
50 |
51 | ``` text
52 | pip install numpy
53 | ```
54 |
55 | Then, you may just run Cnerator with no arguments to generate a random C program:
56 |
57 |
58 | ``` text
59 | python cnerator.py
60 | ```
61 |
62 | There are plenty of options to customize Cnerator. To specify the probability of a particular language
63 | construct, you can use the `-p` or `--probs` option.
64 | The following command sets to 20% the probability of
65 | generating a function invocation when a new expression is required:
66 |
67 | ``` text
68 | python cnerator.py -p "call_prob = {True: 0.2, False: 0.8}"
69 | ```
70 |
71 | If more sophisticated probabilities are required, you can specify them in a JSON file and pass it as
72 | a parameter (see the [documentation](user-manual.md#probability-specification-files) to know the JSON file format).
73 | The following line passes an example JSON file in the `json/probabilities` folder where
74 | different probability distributions are specified for some syntactic constructs:
75 |
76 | ``` text
77 | python cnerator.py -P json/probabilities/example_probs.json
78 | ```
79 |
80 | Cnerator also provides allows the user to control the number and characteristics of
81 | all the functions to be generated. A JSON file is used for that purpose
82 | (see the [documentation](user-manual.md#function-generation-files)).
83 | The following command makes Cnerator generate one function for each high-level return
84 | type in the C programming language:
85 |
86 |
87 | ``` text
88 | python cnerator.py -f json/functions/1-function-each-type.json
89 | ```
90 |
91 | Sometimes, the user needs the output program to fulfill some requirements not guaranteed by the
92 | stochastic generation process.
93 | To this aim, Cnerator allows the specification of an ordered collection of Python
94 | post-process specification files (see the [documentation](user-manual.md#post-processing-specification-files)).
95 | These post-processing files can modify the generated code to satisfy those requirements.
96 | The following execution generates a random program and then executes two visitors:
97 | one to rename `func` functions to `proc` (and their invocations) when they return `void`;
98 | and another one to add a `__RETURN__` label before each return statement:
99 |
100 | ``` text
101 | python cnerator.py -V visitors.func_to_proc:visitors.return_instrumentation
102 | ```
103 |
104 | To see all the options, just run the `-h` or `--help` options.
105 | For more information, please check the [documentation](user-manual.md).
106 | Developer documentation is also provided [here](https://computationalreflection.github.io/Cnerator).
107 |
108 |
109 | ## Documentation
110 |
111 | * Check out the [user manual](user-manual.md) about how to use Cnerator.
112 |
113 | * A [developer manual](https://computationalreflection.github.io/Cnerator) is also available
114 | if you want to modify the source code.
115 |
116 | ## License
117 |
118 | [BSD 3 clause license](LICENSE)
--------------------------------------------------------------------------------
/cnerator.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | This is the entry point to the Cnerator source code generation tool.
6 | The main function runs Cnerator.
7 | To see the different arguments provided, run Cnerator with either ``-h`` or ``--help`` command line arguments.
8 | """
9 |
10 | from __future__ import print_function
11 |
12 | import os
13 | import sys
14 |
15 | from debug import call_inspector, structure_inspector
16 | from params import parameters
17 | from params.parameters import parse_args, get_modules_to_import, get_probs_to_override
18 | from params.writter import write_in_files
19 | from params import json_probs
20 | import core
21 |
22 |
23 | def run(args):
24 | """
25 | This function runs Cnerator, receiving the command line arguments.
26 |
27 | :param args: The command line arguments returned by ``argparse.ArgumentParser.parse_args``.
28 | :return: None.
29 | """
30 | # Set the recursion limit
31 | sys.setrecursionlimit(args.recursion)
32 |
33 | # Get the probabilities from the command line arguments and modify the default ones
34 | core.probs.set_probabilities(get_probs_to_override(args.probs))
35 | if args.probsfile:
36 | from core import probs
37 | probabilities = json_probs.parse_probabilities_specification_json_file(args.probsfile)
38 | probs.set_probabilities(probabilities)
39 |
40 | # Process the json file to create functions, or generates a program using the probabilities defined
41 | if args.functions: # if a json file was passed, it defines the functions to be generated
42 | dictionary = parameters.parse_function_specification_json_file(args.functions)
43 | program = core.generators.generate_program_with_function_distribution(dictionary, args, remove_unwanted_functions=True)
44 | else: # otherwise, a random program is generated, considering the specified probabilities
45 | program = core.generators.generate_program()
46 |
47 | # Load all the visitor modules and run them, in the same order as specified by the user
48 | modules = get_modules_to_import(args.visitors)
49 | for module in modules:
50 | module.visit(program)
51 |
52 | # Create output directory
53 | if not os.path.isdir(args.output_dir):
54 | os.mkdir(args.output_dir)
55 |
56 | # Write code to files
57 | write_in_files(program, args)
58 |
59 | # Write debug graph information
60 | if args.debug:
61 | # Write structure graph
62 | structure_inspector.write_graph(program, os.path.join(args.output_dir, args.output + ".structure.dot"))
63 | # Write call graph
64 | call_inspector.write_graph(program, True, os.path.join(args.output_dir, args.output + ".call.dot"))
65 | call_inspector.write_graph(program, False, os.path.join(args.output_dir, args.output + ".call_light.dot"))
66 |
67 |
68 | def main():
69 | """Main function.
70 | To see the different arguments provided, run Cnerator with either ``-h`` or ``--help`` command line arguments.
71 | """
72 | exit(run(parse_args()))
73 |
74 |
75 | if __name__ == "__main__":
76 | main()
77 |
78 |
79 |
--------------------------------------------------------------------------------
/core/__init__.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | This is the most important package in Cnerator, which provides the core functionality.
6 | In this package, you can find the Abstract Syntax Tree (AST) program representation,
7 | the generators of each syntactic construct, type inference routines, probability specifications and
8 | different utilities provided by the system.
9 | """
10 |
11 | from core import generators
12 | from core import probs
--------------------------------------------------------------------------------
/core/probs_helper.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | These functions are used to define the probability of the different syntax constructs of the C language.
6 | Probabilities are defined as Dict[object, float], where the key are the different values to be generated and the
7 | content defines the probability for each one.
8 | All the probabilities (contents of the dictionary) must sum 0.0.
9 | """
10 |
11 | import random
12 | from typing import Dict, List
13 | import numpy as np
14 |
15 |
16 | FLOAT_PRECISION = 1e-8
17 |
18 |
19 | def random_value(probabilities: Dict[object, float]):
20 | """Returns one of the values in probabilities (key) given its probability (content)"""
21 | if abs(sum(probabilities.values()) - 1.0) > FLOAT_PRECISION:
22 | raise Exception("Probability must sum 1")
23 | rand = random.random()
24 | summation = 0
25 | for key, value in probabilities.items():
26 | if summation <= rand < summation + value:
27 | return key
28 | summation += value
29 | return probabilities[probabilities.keys()[-1]]
30 |
31 |
32 | def compute_equal_prob(keys: set, base: float = 1.0) -> Dict[object, float]:
33 | """Given a list of elements (keys) returns a dictionary with the equal probabilities for all the elements"""
34 | probabilities = {}
35 | for key in keys:
36 | probabilities[key] = base * (1.0 / len(keys))
37 | return probabilities
38 |
39 |
40 | def compute_proportional_prob(population: Dict[object, float], base: float = 1.0) -> Dict[object, float]:
41 | """Given a dictionary of elements and their proportional occurrence, returns a dictionary with its probability
42 | distribution. For example, {'a':1, 'b':2, c:'1'} returns {'a':0.25, 'b':0.5, c:'0.25'} """
43 | probabilities = {}
44 | total = float(sum(population.values()))
45 | for individual, amount in population.items():
46 | probabilities[individual] = base * (amount / total)
47 | assert abs(1.0 - sum(probabilities.values())) <= FLOAT_PRECISION
48 | return probabilities
49 |
50 |
51 | def compute_inverse_proportional_prob(population: Dict[object, float], base: float = 1.0) -> Dict[object, float]:
52 | """Given a dictionary of elements and their inverse proportional occurrence, returns a dictionary with its
53 | probability distribution. For example, {'a':1, 'b':2, c:'2'} returns {'a':0.5, 'b':0.25, 'c':0.25} """
54 | probabilities = {}
55 | total = 0
56 | for individual, amount in population.items():
57 | probabilities[individual] = 1.0 / amount
58 | total += probabilities[individual]
59 | for individual, prob in probabilities.items():
60 | probabilities[individual] = base * (prob / total)
61 | assert abs(1.0 - sum(probabilities.values())) <= FLOAT_PRECISION
62 | return probabilities
63 |
64 |
65 | def compute_normal_prob(mean: int, stdev: int, base: float = 1.0, number: int = 30) -> Dict[object, float]:
66 | """Given the mean and standard deviation, returns a dictionary a normal distribution"""
67 | float_values = np.random.normal(mean, stdev, size=number)
68 | int_values = [int(float_value) for float_value in float_values]
69 | frequencies = {int_value: int_values.count(int_value) for int_value in int_values}
70 | return compute_proportional_prob(frequencies, base)
71 |
72 |
73 |
--------------------------------------------------------------------------------
/core/type_inference.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | Different functions to infer the type of a syntax construct.
6 | This module heavily depends on the data provided in the ``operators_types`` module.
7 | """
8 |
9 | from functools import partial
10 |
11 | from core import probs, operators_types, probs_helper, generators, ast
12 |
13 |
14 | def infer_return_type(program, function, operator, *args_t):
15 | arity = len(args_t)
16 | _generate_type = partial(generators.generate_type, program, function)
17 |
18 | if operator == "*" and arity == 1:
19 | assert args_t[0].__class__ == ast.Pointer
20 | return [args_t[0].type]
21 |
22 | if operator == "&" and arity == 1:
23 | return _generate_type(ast.Pointer, args_t[0])
24 |
25 | if operator == "[]":
26 | assert arity == 2
27 | assert args_t[0].__class__ == ast.Array
28 | assert args_t[1].__class__ in [t for t in probs.primitive_types_prob.keys() if "Int" in t.__name__]
29 | return [args_t[0].type]
30 |
31 | if operator == ".":
32 | assert arity == 1
33 | assert args_t[0].__class__ == ast.Struct
34 | assert isinstance(args_t[1], str)
35 | return [args_t[0].get_field(args_t[1])]
36 |
37 | if operator == "->":
38 | assert arity == 1
39 | assert args_t[0].__class__ == ast.Pointer
40 | assert args_t[0].type.__class__ == ast.Struct
41 | assert isinstance(args_t[1], str)
42 | return [args_t[0].type.get_type_by_field(args_t[1])]
43 |
44 | if operator == "?:":
45 | assert arity == 3
46 | assert args_t[0].__class__ in [t for t in probs.primitive_types_prob.keys() if "Int" in t.__name__]
47 | assert args_t[1].__class__ == args_t[2].__class__
48 | return [args_t[1]]
49 |
50 | if operator == "=":
51 | assert arity == 1
52 | assert not isinstance(args_t[0], ast.Array)
53 | return [args_t[0]]
54 |
55 | return list(_infer_return_type(program, function, operator, *args_t))
56 |
57 |
58 | def _infer_return_type(program, function, operator, *args_t):
59 | arity = len(args_t)
60 | _generate_type = partial(generators.generate_type, program, function)
61 |
62 | # Otherwise search on the table
63 | try:
64 | selected_arity = operators_types.by_operands[arity]
65 | except KeyError:
66 | raise ValueError("Unknown arity '{}'".format(arity))
67 | try:
68 | selected_operator = selected_arity[operator]
69 | except KeyError:
70 | raise ValueError("Unknown operator '{}'".format(operator))
71 |
72 | last_selected_arg = selected_operator
73 | for pos, arg in enumerate(args_t):
74 | try:
75 | last_selected_arg = last_selected_arg[arg.__class__]
76 | except KeyError:
77 | raise ValueError("In arg '{}'. Unknown type in arg {} '{}'".format(
78 | arg, pos, arg.__class__.__name__))
79 | ret_ts_cls = last_selected_arg
80 |
81 | # And return one of the types
82 | for ret_t_cls in ret_ts_cls:
83 | if ret_t_cls is ast.Pointer:
84 | if arity == 1:
85 | assert args_t[0].__class__ is ast.Pointer
86 | yield _generate_type(ast.Pointer, args_t[0].type)
87 | elif arity == 2:
88 | if args_t[0].__class__ is ast.Pointer:
89 | yield _generate_type(ast.Pointer, args_t[0].type)
90 | elif args_t[1].__class__ is ast.Pointer:
91 | yield _generate_type(ast.Pointer, args_t[1].type)
92 | else:
93 | raise ValueError("Unknown operation with Pointers")
94 | else:
95 | yield ret_t_cls() # Direct call to constructor because are basic types
96 |
97 |
98 | def infer_operands_type(program, function, arity, operator, ret_t):
99 | _generate_type = partial(generators.generate_type, program, function)
100 |
101 | if operator == "*" and arity == 1:
102 | return [_generate_type(ast.Pointer, ret_t)]
103 |
104 | if operator == "&" and arity == 1:
105 | assert ret_t.__class__ == ast.Pointer
106 | # Pointer(T) <- & T
107 | return [ret_t.type]
108 |
109 | if operator == "[]":
110 | assert arity == 2
111 | array_obj = _generate_type(ast.Array, ret_t)
112 | return [(array_obj, t()) for t in probs.primitive_types_prob.keys() if "Int" in t.__name__]
113 |
114 | if operator == ".":
115 | assert arity == 1
116 | return [_generate_type(ast.Struct, ret_t)]
117 |
118 | if operator == "->":
119 | assert arity == 1
120 | struct_t = _generate_type(ast.Struct, ret_t)
121 | return [_generate_type(ast.Pointer, struct_t)]
122 |
123 | if operator == "?:":
124 | assert arity == 3
125 | return [(ast.SignedInt(), ret_t, ret_t)]
126 |
127 | if operator == "=":
128 | assert arity == 1
129 | assert not isinstance(ret_t, ast.Array)
130 | return [ret_t]
131 |
132 | return _infer_operands_type(program, function, arity, operator, ret_t)
133 |
134 |
135 | def _infer_operands_type(program, function, arity, operator, ret_t):
136 | _generate_type = partial(generators.generate_type, program, function)
137 |
138 | # Otherwise search on the table
139 | try:
140 | selected_arity = operators_types.by_return[arity]
141 | except KeyError:
142 | raise ValueError("Unknown arity '{}'".format(arity))
143 | try:
144 | selected_operator = selected_arity[operator]
145 | except KeyError:
146 | raise ValueError("Unknown operator '{}'".format(operator))
147 | try:
148 | args_t = selected_operator[ret_t.__class__]
149 | except KeyError:
150 | raise ValueError("There's no {} that use the operator '{}' and return '{}'".format(
151 | "type" if arity == 1 else "types", operator, ret_t.__class__.__name__))
152 |
153 | # And return one of the types
154 | if ret_t.__class__ in [ast.Pointer, ast.Array]:
155 | type_obj = ret_t.type
156 | else:
157 | type_cls = probs_helper.random_value(probs.primitive_types_prob)
158 | type_obj = type_cls()
159 | if arity == 1:
160 | return [_generate_type(arg_t, type_obj) for arg_t in args_t]
161 | if arity == 2:
162 | return [(_generate_type(arg1_t, type_obj), _generate_type(arg2_t, type_obj)) for arg1_t, arg2_t in args_t]
163 | raise AssertionError("Unknown arity")
164 |
--------------------------------------------------------------------------------
/core/utils.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | Different general-purpose functions used in the implementation of the core library.
6 | """
7 |
8 | import re
9 | import sys
10 |
11 | from params.parameters import get_app_args
12 |
13 |
14 | def camel_case_to_snake_case(name: str) -> str:
15 | """Converts a camel-case string into its snake-case representation"""
16 | s1 = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', name)
17 | return re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
18 |
19 |
20 | def print_to_std_error(*args, sep=' ', end='\n'):
21 | """This function wraps the print Python function to show something in the
22 | standard output error"""
23 | print(*args, sep=sep, end=end, file=sys.stderr)
24 |
25 |
26 | def print_if_verbose(*args, sep=' ', end='\n', file=None):
27 | """Prints a message if the verbose option has been passed to the application"""
28 | if get_app_args().verbose:
29 | print(*args, sep=sep, end=end, file=file)
30 |
--------------------------------------------------------------------------------
/debug/__init__.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | This package stores different program information (call graphs and struct representations)
6 | as graphs and saves them as .dot files.
7 | Such functionality only occurs when the ``-d`` or ``--debug`` options are passed from the command line.
8 | """
9 |
10 |
--------------------------------------------------------------------------------
/debug/call_inspector.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | A visitor implementation that stores a representation of the calling graph into a text stream.
6 | Its use is for debugging purposes, to check the structure of the generated program.
7 | """
8 |
9 | from __future__ import print_function
10 | from __future__ import unicode_literals
11 |
12 | import io
13 |
14 | from functools import singledispatch
15 |
16 | from core import ast
17 |
18 | global_visit_main = True
19 |
20 | def write_graph(program, visit_main, path):
21 | with io.open(path, mode="w", encoding="utf-8") as buffer:
22 | buffer.write("digraph G {\n")
23 | buffer.write('graph [rankdir = "LR", orientation = "landscape", ranksep = 3.0, nodesep= 2.0];\n')
24 | buffer.write('node [fontsize = "8", style = "filled", color = "blue"];\n')
25 | buffer.write('edge [fontsize = "8", weight = 0.1];\n')
26 | # buffer.write('main [style = "filled", color = "red"];\n')
27 | edges = []
28 | nodes = []
29 |
30 | global global_visit_main
31 | global_visit_main = visit_main
32 |
33 | callinsp_visit(program, nodes, edges)
34 | for e in edges:
35 | buffer.write(e + "\n")
36 | for n in nodes:
37 | buffer.write(n + "\n")
38 | buffer.write("}\n")
39 |
40 |
41 | @singledispatch
42 | def callinsp_visit(node, nodes, edges, *args, **kwargs):
43 | raise TypeError("Unknown node type: " + node.__class__.__name__)
44 |
45 |
46 | @callinsp_visit.register(ast.Program)
47 | def _(program, nodes, edges):
48 | for f in program.functions:
49 | callinsp_visit(f, nodes, edges)
50 | if global_visit_main:
51 | callinsp_visit(program.main, nodes, edges)
52 |
53 |
54 | @callinsp_visit.register(ast.Function)
55 | def _(function, nodes, edges):
56 | if function.name == "main":
57 | color = "tomato"
58 | elif function.name.startswith("func"):
59 | color = "steelblue1"
60 | elif function.name.startswith("proc"):
61 | color = "greenyellow"
62 | else:
63 | raise AssertionError("Unknown type of function")
64 |
65 | nodes.append('{} [color = "{}"];'.format(function.name, color))
66 | for s in function.stmts:
67 | callinsp_visit(s, nodes, edges, function.name, function)
68 |
69 |
70 | @callinsp_visit.register(ast.Invocation)
71 | def _(invocation, nodes, edges, func_name, parent):
72 | comment = " "
73 | if isinstance(parent, ast.Function):
74 | comment = " /* stmt invocation */"
75 | else:
76 | comment = " /* expr invocation */"
77 | edges.append("{} -> {}{}".format(func_name, invocation.func_name, comment))
78 |
79 | if invocation.arguments:
80 | for arg in invocation.arguments:
81 | if isinstance(arg, ast.ASTNode):
82 | callinsp_visit(arg, nodes, edges, func_name, invocation)
83 |
84 |
85 | @callinsp_visit.register(ast.BinaryExpression)
86 | @callinsp_visit.register(ast.Assignment)
87 | @callinsp_visit.register(ast.ArrayAccessExpression)
88 | @callinsp_visit.register(ast.Return)
89 | @callinsp_visit.register(ast.UnaryExpression)
90 | @callinsp_visit.register(ast.StructAccessExpression)
91 | @callinsp_visit.register(ast.TernaryExpression)
92 | def _(node, nodes, edges, func_name, parent):
93 | for exp in node.children:
94 | if isinstance(exp, ast.ASTNode):
95 | callinsp_visit(exp, nodes, edges, func_name, node)
96 |
97 | @callinsp_visit.register(ast.Literal)
98 | @callinsp_visit.register(ast.Variable)
99 | @callinsp_visit.register(ast.Label)
100 | def _(node, nodes, edges, func_name, parent):
101 | pass
102 |
--------------------------------------------------------------------------------
/debug/structure_inspector.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | # -*- coding: utf-8 -*-
3 |
4 | """
5 | Stores in a text stream the representation of the struct data types in the generated program.
6 | Its use is for debugging purposes, to check the structure of the struct types in the generated program.
7 | """
8 |
9 | from __future__ import print_function
10 | from __future__ import unicode_literals
11 |
12 | import io
13 | import core
14 |
15 |
16 | def get_struct_name(t):
17 | while True:
18 | if isinstance(t, core.ast.Struct):
19 | return t.name
20 | elif isinstance(t, (core.ast.Pointer, core.ast.Array)):
21 | t = t.type
22 | else:
23 | return None
24 |
25 |
26 | def write_graph(program, path):
27 |
28 | def get_color(t):
29 | if t.name.startswith("array"):
30 | return ' bgcolor="steelblue1"'
31 | if t.name.startswith("pointer"):
32 | return ' bgcolor="tomato"'
33 | if t.name.startswith("struct"):
34 | return ' bgcolor="greenyellow"'
35 | return ""
36 |
37 | with io.open(path, mode="w", encoding="utf-8") as buffer:
38 |
39 | buffer.write("digraph G {\n")
40 | buffer.write('graph [rankdir = "LR"];\n')
41 | buffer.write('node [fontsize = "8"];\n')
42 | buffer.write('edge [fontsize = "8"];\n')
43 |
44 | # Write nodes
45 | for s in program.structs:
46 | name = s.name
47 | label = """<| {} |