Touch up labels and registers in Abscond, Blackmail, and Con notes.

Author: dvanhorn

www/notes/abscond.scrbl

@@ -1,6 +1,6 @@
 #lang scribble/manual
 
-@(require (for-label (except-in racket compile) a86/ast a86/printer))
+@(require (for-label (except-in racket compile) a86/ast a86/printer a86/registers))
 @(require scribble/examples
 	  redex/reduction-semantics	  
           redex/pict
@@ -429,7 +429,7 @@ So the AST representation of our example is:
 
 @racketblock[
 (list (Label 'entry)
-      (Mov 'rax 42)
+      (Mov rax 42)
       (Ret))
 ]
 

www/notes/blackmail.scrbl

@@ -1,6 +1,6 @@
 #lang scribble/manual
 
-@(require (for-label (except-in racket compile ...) a86/ast a86/printer))
+@(require (for-label (except-in racket compile ...) a86/ast a86/printer a86/registers a86/interp))
 @(require scribble/examples
           redex/pict
 	  "../fancyverb.rkt"
@@ -238,7 +238,7 @@ Just as we did with Abscond, let's approach writing the compiler by
 first writing an example.
 
 Suppose we want to compile @racket[(add1 (add1 40))].  We already know
-how to compile the @racket[40]: @racket[(Mov 'rax 40)].  To do the
+how to compile the @racket[40]: @racket[(Mov rax 40)].  To do the
 increment (and decrement) we need to know a bit more a86.  In
 particular, the @racket[Add] instruction is relevant.  It increments
 the contents of a register by some given amount.
@@ -250,9 +250,9 @@ So, a program that adds 1 twice to 40 looks like:
 (asm-interp
   (prog (Global 'entry)
         (Label 'entry)
-        (Mov 'rax 40)
-        (Add 'rax 1)
-        (Add 'rax 1)
+        (Mov rax 40)
+        (Add rax 1)
+        (Add rax 1)
         (Ret)))]
 
 
@@ -275,7 +275,7 @@ recursion, much like the interpreter.
 In the case of a unary primitive @racket[(Prim1 p e)], the compiler
 first compiles the subexpression @racket[e] obtaining a list of
 instructions that, when executed, will place @racket[e]'s value in the
-@racket['rax] register.  After that sequence of instructions, the
+@racket[rax] register.  After that sequence of instructions, the
 compiler emits instructions for carrying out the operation @racket[p],
 defering to a helper function @racket[compile-op1]:
 

www/notes/con.scrbl

@@ -1,6 +1,6 @@
 #lang scribble/manual
 
-@(require (for-label (except-in racket compile ...) a86/printer a86/ast))
+@(require (for-label (except-in racket compile ...) a86/printer a86/ast a86/registers))
 @(require redex/pict
           racket/runtime-path
           scribble/examples
@@ -191,8 +191,8 @@ We already know how to compile the @racket[8], @racket[2], and
 What needs to happen?
 
 @itemlist[
-@item{Execute the code for @racket[8] leaving the result in @racket['rax],}
-@item{check whether @racket['rax] holds zero,}
+@item{Execute the code for @racket[8] leaving the result in @racket[rax],}
+@item{check whether @racket[rax] holds zero,}
 @item{if it does, execute the code for @racket[2],}
 @item{if it doesn't, execute the code for @racket[3].}
 ]
@@ -219,10 +219,10 @@ In total, the code for this example would look like:
 @racketblock[
 (let ((l0 (gensym))
       (l1 (gensym)))
-  (list (Mov 'rax 8)
-        (Cmp 'rax 0)
+  (list (Mov rax 8)
+        (Cmp rax 0)
         (Je l0)
-        (Mov 'rax 3)
+        (Mov rax 3)
         (Jmp l1)
         (Label l0)
         (Mov rax 2)
@@ -232,7 +232,7 @@ In total, the code for this example would look like:
 
 @section{A Compiler for Con}
 
-Notice that the @racket[(Mov 'rax 8)], @racket[(Mov rax 3)] and
+Notice that the @racket[(Mov rax 8)], @racket[(Mov rax 3)] and
 @racket[(Mov rax 2)] parts are just the instructions generated by
 compiling @racket[8], @racket[2] and @racket[3].  Generalizing from
 this, we arrive at the following code for the compiler:
@@ -241,7 +241,7 @@ this, we arrive at the following code for the compiler:
 (let ((l0 (gensym 'if))
       (l1 (gensym 'if)))
   (seq (compile-e e1)
-       (Cmp 'rax 0)
+       (Cmp rax 0)
        (Je l0)
        (compile-e e3)
        (Jmp l1)