Add fixed graphviz notes

Author: jmct

www/notes/graphviz.scrbl

@@ -10,9 +10,6 @@
 
 @(define codeblock-include (make-codeblock-include #'h))
 
-@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "knock" f))))))
-	   '("interp.rkt" "compile.rkt" "ast.rkt" "syntax.rkt" "asm/interp.rkt" "asm/printer.rkt"))
-
 @title[#:tag "Graphviz"]{Using Graphviz/dot to visualize our AST}
 
 @table-of-contents[]
@@ -23,16 +20,15 @@ Abstract Syntax Trees (ASTs) are a useful abstraction when dealing with
 programming languages as an object for analysis or manipulation (e.g.
 compilation). At the same time, these structures can quickly become
 too large reason about just by looking at it. For example, in Knock,
-our AST for @racket[(if (zero? x) (add1 (add1 x)) (sub1 x))] looks
+our AST for @tt{(if (zero? x) (add1 (add1 x)) (sub1 x))} looks
 like the following:
 
 @#reader scribble/comment-reader
 (racketblock
  (if-e
   (prim-e 'zero? (list (var-e 'x)))
   (prim-e 'add1 (list (prim-e 'add1 (list (int-e 1)))))
-  (prim-e 'sub1 (list (var-e 'x))))
-)
+  (prim-e 'sub1 (list (var-e 'x)))))
 
 This has all the information necessary for manipulating our program (and more),
 it's a bit unwieldy to look at. Particularly when debugging, it can
@@ -46,11 +42,11 @@ the following AST:
 @#reader scribble/comment-reader
 (racketblock
  (if-e
-  (prim-e 'zero? (list (var-e 'x)
+  (prim-e 'zero? (list (var-e 'x)))
   (let-e
-   (list (binding 'g387 (prim-e 'add1 (list (int-e 1))))
-   (prim-e 'add1 (list (var-e 'g387))
-  (prim-e 'sub1 (list (var-e 'x)))
+   (list (binding 'g387 (prim-e 'add1 (list (int-e 1)))))
+   (prim-e 'add1 (list (var-e 'g387)))
+  (prim-e 'sub1 (list (var-e 'x))))))
 
 Was the program transformation done correctly? If you study the AST
 carefully, you can determine that it was. However, it would be easier
@@ -89,28 +85,28 @@ for visualizing graphs.
 Graphviz has many components, but we will focus on @tt{dot}, which is
 the tool for laying out directed graphs. The full manual for @tt{dot}
 can be found on the graphviz website:
-@link["https://www.graphviz.org/pdf/dotguide.pdf"]{https://www.graphviz.org/pdf/dotguide.pdf}.
+@link["https://www.graphviz.org/pdf/dotguide.pdf"]{The Dot Guide}.
 
 Instructions for downloading Graphviz (and therefore @tt{dot}) can be found on
 their website as well:
-@link["https://www.graphviz.org/download/"]{https://www.graphviz.org/download/}
+@link["https://www.graphviz.org/download/"]{Download Graphviz}
 
 The syntax for @tt{dot} files is fairly straightforward, you first declare the
 type of graph, and give it a name. For our purposes the type will always be
 @tt{digraph} (i.e. directed-graph), and the name can be whatever you choose
 (though it will likely not matter much). For example:
 
-@verbatim|
+@verbatim|{
 digraph CMSC430 {
   ...
 }
-|
+}|
 
 The ellipses are where you describe the graph you'd like to visualize. The
 designers of Graphviz provide a grammar describing the language accepted by
 their tools (I wish all system designers provided a grammar!). This can be
 found on the Graphviz website:
-@link["https://graphviz.org/doc/info/lang.html"]{https://graphviz.org/doc/info/lang.html}
+@link["https://graphviz.org/doc/info/lang.html"]{The DOT language}.
 
 Most of the time you will not need to consult the grammar, as most of the
 simple rules are straightforward for those that have programmed in C or Java.
@@ -132,13 +128,13 @@ course), you can basically just use the following three types of statements:
 Node statements are just an ASCII string (representing a Node ID) and an
 optional list of attributes for that node. For example:
 
-@verbatim|
+@verbatim|{
 digraph CMSC430 {
   lexer;
   parser [shape=box];
   code_gen [color=red];
 }
-|
+}|
 
 Using the @tt{dot} tool on a file with the above as its contents produces the
 following diagram:
@@ -147,13 +143,13 @@ following diagram:
 
 Edge statements connect nodes in our graph, for example:
 
-@verbatim|
+@verbatim|{
 digraph CMSC430 {
   lexer -> parser -> code_gen;
   parser [shape=box];
   code_gen [color=red];
 }
-|
+}|
 
 This produces the following diagram:
 
@@ -163,13 +159,13 @@ You may wonder if the order matters here. While the @emph{horizontal} order
 matters when specifying the edges in an edge statement, the @emph{vertical}
 order does not matter in this case. The following produces the same diagram:
 
-@verbatim|
+@verbatim|{
 digraph CMSC430 {
   parser [shape=box];
   code_gen [color=red];
   lexer -> parser -> code_gen;
 }
-|
+}|
 
 Notice that @tt{lexer} does not have its own `declaration' this is because it
 is unnecessary unless you want to attach attributes to a node (as we do
@@ -179,13 +175,13 @@ Edge statements also support an optional list of attributes, the following
 produces a similar diagram except that both edges are shaded ``deeppink2'' (for
 the full list of supported colors, see the official documentation).
 
-@verbatim|
+@verbatim|{
 digraph CMSC430 {
   lexer -> parser -> code_gen [color=deeppink2];
   parser [shape=box];
   code_gen [color=red];
 }
-|
+}|
 
 Attribute nodes describe a set of attributes that apply to all subsequent
 statements (which means that vertical order @emph{does} matter here!). Unless
@@ -196,7 +192,7 @@ Here we added three attribute statements. Take a minute to study the example
 below and see how each attribute statement affects the output.
 
 
-@verbatim|
+@verbatim|{
 digraph CMSC430 {
   edge [color=blue];
   lexer -> parser
@@ -207,7 +203,7 @@ digraph CMSC430 {
   code_gen [color=red];
   optimizer -> code_gen;
 }
-|
+}|
 
 @image{img/edges3.png}
 
@@ -224,7 +220,7 @@ an @tt{if} node).
 Here is an example of a @tt{dot} description make using our library on the program
 @racket[(if (zero? x) 1 2)]:
 
-@verbatim|
+@verbatim|{
 digraph prog {
   g850 [ label=" x " ];
   g849 [ color=red,label=" (zero? ...) " ];
@@ -236,7 +232,7 @@ digraph prog {
   g848 -> g851 ;
   g848 -> g852 ;
 }
-|
+}|
 
 Not super nice to read, but we had a program write it for us!
 
@@ -246,3 +242,5 @@ The complete library (three files):
 @codeblock-include["knock/dot.rkt"]
 @codeblock-include["knock/render-ast.rkt"]
 @codeblock-include["knock/pretty-printer.rkt"]
+
+