Rework www to use langs package.

Author: dvanhorn

www/assignments/3.scrbl

@@ -2,8 +2,6 @@
 @title[#:tag "Assignment 3" #:style 'unnumbered]{Assignment 3: Primitives, Conditionals, and Dispatch}
 
 @(require (for-label a86 (except-in racket ...)))
-@(require "../../langs/con-plus/semantics.rkt")
-@(require redex/pict)
 
 @bold{Due: Thursday, October 3, 11:59PM}
 

www/notes/1/ocaml-to-racket.scrbl

@@ -26,7 +26,7 @@
     (apply fancyverbatim "ocaml" s)))
 
 @(define (shellbox . s)
-   (parameterize ([current-directory (build-path notes "intro")])
+   (parameterize ([current-directory (build-path langs "intro")])
      (filebox (emph "shell")
               (fancyverbatim "fish" (apply shell s)))))
 
@@ -1260,7 +1260,8 @@ Putting it all together, we can write the following code and save it
 in a file called @tt{bt.rkt}.  (You can right-click the file name and
 save the code to try it out.)
 
-@codeblock-include["intro/bt.rkt"]
+@;{FIXME: Fix this!}
+@;codeblock-include["intro/bt.rkt"]
 
 This code follows a coding style that we will use in this course:
 @itemlist[
@@ -1275,11 +1276,11 @@ This code follows a coding style that we will use in this course:
 From the command line, you can run a module's tests using the Racket
 command line testing tool @tt{raco test}:
 
-@shellbox["raco test bt.rkt"]
+@tt{raco test bt.rkt}  @;{FIXME: make this a shellbox}
 
 Or simply give a directory name and test everything within that directory:
 
-@shellbox["raco test ."]
+@tt{raco test .} @;{FIXME: make this a shellbox}
 
 
 

www/notes/a86.scrbl

@@ -15,10 +15,10 @@
 
 @(ev '(require rackunit a86))
 
-@(ev `(current-directory ,(path->string (build-path notes "a86"))))
+@(ev `(current-directory ,(path->string a86)))
 
 @(define (shellbox . s)
-   (parameterize ([current-directory (build-path notes "a86")])
+   (parameterize ([current-directory a86])
      (filebox (emph "shell")
               (fancyverbatim "fish" (apply shell s)))))
 
@@ -68,7 +68,7 @@ int gcd(int n1, int n2) {
 HERE
      )
 
-   (parameterize ([current-directory (build-path notes "a86")])
+   (parameterize ([current-directory a86])
      (save-file "tri.s" (asm-string (tri 36)))
      (save-file "main.c" main.c)
      (save-file "gcd.c" gcd.c)))
@@ -147,7 +147,7 @@ This example is shown using the @(if (eq? (system-type 'os) 'macosx)
 "MacOS" "Linux") naming convention, because that's what operating
 system was used when this web page was built.}
 
-@filebox-include[fancy-nasm "a86/tri.s"]
+@filebox-include[fancy-nasm a86 "tri.s"]
 
 The @math{n}th triangular number is the sum of the integers
 from 0 to @math{n}, so the @math{36}th triangular number is
@@ -258,7 +258,7 @@ To run the object file, we will need to link with a small C program
 that can call the @tt{entry} label of our assembly code and then
 print the result:
 
-@filebox-include[fancy-c "a86/main.c"]
+@filebox-include[fancy-c a86 "main.c"]
 
 Notice that from the C program's perspective, the assembly
 code defines what looks like a C function called @tt{entry}
@@ -1982,7 +1982,7 @@ assembly code when running @racket[asm-interp].
 
 For example, let's implement a GCD function in C:
 
-@filebox-include[fancy-c "a86/gcd.c"]
+@filebox-include[fancy-c a86 "gcd.c"]
 
 First, compile the program to an object file:
 

www/notes/abscond.scrbl

@@ -14,19 +14,19 @@
 @(define codeblock-include (make-codeblock-include #'here))
 
 @(ev '(require rackunit a86))
-@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "abscond" f))))))
+@(for-each (λ (f) (ev `(require (file ,(path->string (build-path langs "abscond" f))))))
 	   '("interp.rkt" "ast.rkt" "compile.rkt"))
 
 @(define (shellbox . s)
-   (parameterize ([current-directory (build-path notes "abscond")])
+   (parameterize ([current-directory (build-path langs "abscond")])
      (filebox (emph "shell")
               (fancyverbatim "fish" (apply shell s)))))
 
 @(require (for-syntax "../utils.rkt" racket/base "utils.rkt"))
 @(define-syntax (shell-expand stx)
    (syntax-case stx ()
      [(_ s ...)
-      (parameterize ([current-directory (build-path notes "abscond")])
+      (parameterize ([current-directory (build-path langs "abscond")])
         (begin (apply shell (syntax->datum #'(s ...)))
 	       #'(void)))]))
 
@@ -292,14 +292,14 @@ So our compiler will emit x86 assembly code.  To make our lives a bit
 easier, we will write the run-time system in C.  Let's start with the
 Abscond runtime:
 
-@filebox-include[fancy-c "abscond/main.c"]
+@filebox-include[fancy-c abscond "main.c"]
 
 This C program provides the main entry point for running an Abscond
 program.  It relies upon a function @tt{print_result} which is defined
 as follows:
 
-@filebox-include[fancy-c "abscond/print.h"]
-@filebox-include[fancy-c "abscond/print.c"]
+@filebox-include[fancy-c abscond "print.h"]
+@filebox-include[fancy-c abscond "print.c"]
 
 Separating out @tt{print_result}, which at this point is just a simple
 @tt{printf} statement, seems like overkill, but it will be useful in
@@ -334,7 +334,7 @@ example.  Let's say the Abscond program is @racket[42].  What should
 the assembly code for this program look like?  Here we have to learn a
 bit about the x86-64 assembly language.
 
-@filebox-include[fancy-nasm "abscond/42.s"]
+@filebox-include[fancy-nasm abscond "42.s"]
 
 @margin-note{Note: on macOS, labels must be prepended with @tt{_},
 while on Linux they are not; e.g. @tt{_entry} vs @tt{entry}.}
@@ -449,7 +449,7 @@ Using a Makefile, we can capture the whole compilation dependencies as:
 @margin-note{Note: the appropriate object file format is detected
 based on the operating system.}
 
-@filebox-include[fancy-make "abscond/Makefile"]
+@filebox-include[fancy-make abscond "Makefile"]
 
 And now compiling Abscond programs is easy-peasy:
 

www/notes/blackmail.scrbl

@@ -5,26 +5,26 @@
           redex/pict
 	  "../fancyverb.rkt"
 	  "../utils.rkt"
-	  "../../langs/blackmail/semantics.rkt"
+	  blackmail/semantics
 	  "utils.rkt"
 	  "ev.rkt")
 
 @(define codeblock-include (make-codeblock-include #'here))
 
 @(ev '(require rackunit a86))
-@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "blackmail" f))))))
+@(for-each (λ (f) (ev `(require (file ,(path->string (build-path langs "blackmail" f))))))
 	   '("interp.rkt" "compile.rkt" "random.rkt" "ast.rkt"))
 
 @(define (shellbox . s)
-   (parameterize ([current-directory (build-path notes "blackmail")])
+   (parameterize ([current-directory (build-path langs "blackmail")])
      (filebox (emph "shell")
               (fancyverbatim "fish" (apply shell s)))))
 
 @(require (for-syntax "../utils.rkt" racket/base "utils.rkt"))
 @(define-syntax (shell-expand stx)
    (syntax-case stx ()
      [(_ s ...)
-      (parameterize ([current-directory (build-path notes "blackmail")])
+      (parameterize ([current-directory (build-path langs "blackmail")])
         (begin (apply shell (syntax->datum #'(s ...)))
 	       #'(void)))]))
 
@@ -208,7 +208,7 @@ increments the contents of a register by some given amount.
 
 Concretely, the program that adds 1 twice to 40 looks like:
 
-@filebox-include[fancy-nasm "blackmail/add1-add1-40.s"]
+@filebox-include[fancy-nasm blackmail "add1-add1-40.s"]
 
 The runtime stays exactly the same as before.
 

www/notes/bt/bt.rkt

@@ -0,0 +1,40 @@
+#lang racket
+(provide (all-defined-out))
+
+(module+ test
+  (require rackunit))
+
+;; type Bt =
+;; | (leaf)
+;; | (node Integer Bt Bt)
+(struct leaf () #:prefab)
+(struct node (v l r) #:prefab)
+
+;; Bt -> Boolean
+;; Is the binary tree empty?
+(define (bt-empty? bt)
+  (match bt
+    [(leaf) #t]
+    [_ #f]))
+
+(module+ test
+  (check-equal? (bt-empty? (leaf)) #t)
+  (check-equal? (bt-empty? (node 3
+                                 (node 7 (leaf) (leaf))
+                                 (node 9 (leaf) (leaf))))
+                #f))
+
+;; Bt -> Natural
+;; Compute the height of a binary tree
+(define (bt-height bt)
+  (match bt
+    [(leaf) 0]
+    [(node _ left right)
+     (+ 1 (max (bt-height left)
+               (bt-height right)))]))
+
+(module+ test
+  (check-equal? (bt-height (leaf)) 0)
+  (check-equal? (bt-height (node 3 (leaf) (leaf))) 1)
+  (check-equal? (bt-height (node 2 (leaf) (node 1 (leaf) (leaf))))
+                2))

www/notes/con.scrbl

@@ -8,7 +8,7 @@
 	  #;(prefix-in sem: (only-in "con/semantics.rkt" ext lookup))
 	  "utils.rkt"
 	  "ev.rkt"
-	  "../../langs/con/semantics.rkt"
+	  con/semantics
 	  "../utils.rkt")
 
 
@@ -17,7 +17,7 @@
 
 
 @(ev '(require rackunit a86))
-@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "con" f))))))
+@(for-each (λ (f) (ev `(require (file ,(path->string (build-path langs "con" f))))))
 	   '("interp.rkt" "compile.rkt" "parse.rkt" "ast.rkt" "random.rkt"))
 
 

www/notes/dodger.scrbl

@@ -14,7 +14,7 @@
 @(define codeblock-include (make-codeblock-include #'h))
 
 @(ev '(require rackunit a86))
-@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "dodger" f))))))
+@(for-each (λ (f) (ev `(require (file ,(path->string (build-path langs "dodger" f))))))
 	   '("interp.rkt" "compile.rkt" "ast.rkt" "parse.rkt" "types.rkt"))
 
 
@@ -198,17 +198,17 @@ need to add run-time support for printing character literals.
 We extend the bit-encoding of values following the pattern we've
 already seen:
 
-@filebox-include[fancy-c "dodger/types.h"]
+@filebox-include[fancy-c dodger "types.h"]
 
 And update the interface for values in the runtime system:
 
-@filebox-include[fancy-c "dodger/values.h"]
-@filebox-include[fancy-c "dodger/values.c"]
+@filebox-include[fancy-c dodger "values.h"]
+@filebox-include[fancy-c dodger "values.c"]
 
 The only other change is that @tt{print_result} is updated to handle
 the case of printing characters:
 
-@filebox-include[fancy-c "dodger/print.c"]
+@filebox-include[fancy-c dodger "print.c"]
 
 Will these pieces in place, we can try out some examples:
 

www/notes/dupe.scrbl

@@ -8,16 +8,16 @@
           "../fancyverb.rkt"
 	  "utils.rkt"
 	  "ev.rkt"
-	  "../../langs/dupe/semantics.rkt"
-          "../../langs/dupe/types.rkt"
+	  dupe/semantics
+          dupe/types
 	  "../utils.rkt")
 
 
 
 @(define codeblock-include (make-codeblock-include #'h))
 
 @(ev '(require rackunit a86))
-@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "dupe" f))))))
+@(for-each (λ (f) (ev `(require (file ,(path->string (build-path langs "dupe" f))))))
 	   '("interp.rkt" "interp-prim.rkt" "compile.rkt" "ast.rkt" "parse.rkt" "random.rkt" "types.rkt"))
 
 
@@ -934,7 +934,7 @@ what is being represented and prints it appropriately.
 For the run-time system, we define the bit representations in a header
 file corresponding to the definitions given in @tt{types.rkt}:
 
-@filebox-include[fancy-c "dupe/types.h"]
+@filebox-include[fancy-c dupe "types.h"]
 
 It uses an idiom of ``masking'' in order to examine on
 particular bits of a value. So for example if we want to
@@ -950,18 +950,18 @@ true.
 
 We use the following interface for values in the runtime system:
 
-@filebox-include[fancy-c "dupe/values.h"]
-@filebox-include[fancy-c "dupe/values.c"]
+@filebox-include[fancy-c dupe "values.h"]
+@filebox-include[fancy-c dupe "values.c"]
 
 The @tt{main} function remains largely the same although now we use
 @tt{val_t} in place of @tt{int64_t}:
 
-@filebox-include[fancy-c "dupe/main.c"]
+@filebox-include[fancy-c dupe "main.c"]
 
 And finally, @tt{print_result} is updated to do a case analysis on the
 type of the result and print accordingly:
 
-@filebox-include[fancy-c "dupe/print.c"]
+@filebox-include[fancy-c dupe "print.c"]
 
 @section{Correctness and testing}