crook

abscond/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (provide exec)
 
 ;; Expr -> Integer

abscond/main.rkt

@@ -4,10 +4,11 @@
 (require "interp.rkt")
 (require "compile.rkt")
 (require "run.rkt")
+(require "exec.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
 (provide (all-from-out "compile.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
 

blackmail/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (provide exec)
 
 ;; Expr -> Integer

blackmail/main.rkt

@@ -4,10 +4,11 @@
 (require "interp.rkt")
 (require "compile.rkt")
 (require "run.rkt")
+(require "exec.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
 (provide (all-from-out "compile.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
 

con/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (provide exec)
 
 ;; Expr -> Integer

con/main.rkt

@@ -4,10 +4,11 @@
 (require "interp.rkt")
 (require "compile.rkt")
 (require "run.rkt")
+(require "exec.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
 (provide (all-from-out "compile.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
 

dodger/compile-ops.rkt

@@ -30,8 +30,7 @@
           (Sal rax char-shift)
           (Xor rax type-char))]))
 
-
-;; -> Asm
+;; Asm
 ;; set rax to #t or #f if comparison flag is equal
 (define if-equal
   (seq (Mov rax (value->bits #f))

dodger/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (require "types.rkt")
 (provide exec)
 ;; Expr -> Value

dodger/main.rkt

@@ -3,11 +3,14 @@
 (require "parse.rkt")
 (require "interp.rkt")
 (require "compile.rkt")
+(require "types.rkt")
 (require "run.rkt")
+(require "exec.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
 (provide (all-from-out "compile.rkt"))
+(provide (all-from-out "types.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
 

dupe/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (require "types.rkt")
 (provide exec)
 ;; Expr -> Value

dupe/main.rkt

@@ -3,11 +3,14 @@
 (require "parse.rkt")
 (require "interp.rkt")
 (require "compile.rkt")
+(require "types.rkt")
 (require "run.rkt")
+(require "exec.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
 (provide (all-from-out "compile.rkt"))
+(provide (all-from-out "types.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
 

evildoer/compile-ops.rkt

@@ -45,8 +45,7 @@
           (Mov rdi rax)
           (Call 'write_byte))]))
 
-
-;; -> Asm
+;; Asm
 ;; set rax to #t or #f if comparison flag is equal
 (define if-equal
   (seq (Mov rax (value->bits #f))

evildoer/exec-io.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp-io.rkt")
 (require "types.rkt")
 (require "build-runtime.rkt")
 (provide exec/io)

evildoer/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (require "types.rkt")
 (require "build-runtime.rkt")
 (provide exec)

evildoer/main.rkt

@@ -2,12 +2,19 @@
 (require "ast.rkt")
 (require "parse.rkt")
 (require "interp.rkt")
+(require "interp-io.rkt")
 (require "compile.rkt")
+(require "types.rkt")
 (require "run.rkt")
+(require "exec.rkt")
+(require "exec-io.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
+(provide (all-from-out "interp-io.rkt"))
 (provide (all-from-out "compile.rkt"))
+(provide (all-from-out "types.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
+(provide (all-from-out "exec-io.rkt"))
 

extort/assert.rkt

@@ -0,0 +1,44 @@
+#lang racket
+(provide assert-integer assert-char assert-byte assert-codepoint)
+(require a86/ast)
+(require "types.rkt")
+
+(define r9 'r9)
+
+;; Register -> Asm
+(define (assert-integer r)
+  (seq (Mov r9 r)
+       (And r9 mask-int)
+       (Cmp r9 type-int)
+       (Jne 'err)))
+
+;; Register -> Asm
+(define (assert-char r)
+  (seq (Mov r9 r)
+       (And r9 mask-char)
+       (Cmp r9 type-char)
+       (Jne 'err)))
+
+;; Register -> Asm
+(define (assert-codepoint r)
+  (let ((ok (gensym)))
+    (seq (assert-integer r)
+         (Cmp r (value->bits 0))
+         (Jl 'err)
+         (Cmp r (value->bits 1114111))
+         (Jg 'err)
+         (Cmp r (value->bits 55295))
+         (Jl ok)
+         (Cmp r (value->bits 57344))
+         (Jg ok)
+         (Jmp 'err)
+         (Label ok))))
+
+;; Register -> Asm
+(define (assert-byte r)
+  (seq (assert-integer r)
+       (Cmp r (value->bits 0))
+       (Jl 'err)
+       (Cmp r (value->bits 255))
+       (Jg 'err)))
+

extort/compile-ops.rkt

@@ -2,6 +2,7 @@
 (provide compile-op0 compile-op1)
 (require "ast.rkt")
 (require "types.rkt")
+(require "assert.rkt")
 (require a86/ast)
 
 (define rax 'rax)
@@ -37,61 +38,22 @@
           (Sar rax char-shift)
           (Sal rax int-shift))]
     ['integer->char
-     (seq (assert-codepoint)
+     (seq (assert-codepoint rax)
           (Sar rax int-shift)
           (Sal rax char-shift)
           (Xor rax type-char))]
     ['eof-object?
      (seq (Cmp rax (value->bits eof))
           if-equal)]
     ['write-byte
-     (seq assert-byte
+     (seq (assert-byte rax)
           (Mov rdi rax)
           (Call 'write_byte))]))
 
-
-;; -> Asm
+;; Asm
 ;; set rax to #t or #f if comparison flag is equal
 (define if-equal
   (seq (Mov rax (value->bits #f))
        (Mov r9  (value->bits #t))
        (Cmove rax r9)))
 
-(define (assert-type mask type)
-  (λ (arg)
-    (seq (Mov r9 arg)
-         (And r9 mask)
-         (Cmp r9 type)
-         (Jne 'err))))
-
-(define (type-pred mask type)
-  (seq (And rax mask)
-       (Cmp rax type)
-       if-equal))
-
-(define assert-integer
-  (assert-type mask-int type-int))
-(define assert-char
-  (assert-type mask-char type-char))
-
-(define (assert-codepoint)
-  (let ((ok (gensym)))
-    (seq (assert-integer rax)
-         (Cmp rax (value->bits 0))
-         (Jl 'err)
-         (Cmp rax (value->bits 1114111))
-         (Jg 'err)
-         (Cmp rax (value->bits 55295))
-         (Jl ok)
-         (Cmp rax (value->bits 57344))
-         (Jg ok)
-         (Jmp 'err)
-         (Label ok))))
-
-(define assert-byte
-  (seq (assert-integer rax)
-       (Cmp rax (value->bits 0))
-       (Jl 'err)
-       (Cmp rax (value->bits 255))
-       (Jg 'err)))
-

extort/exec-io.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp-io.rkt")
 (require "types.rkt")
 (require "build-runtime.rkt")
 (provide exec/io)

extort/exec.rkt

@@ -1,7 +1,6 @@
 #lang racket
 (require a86/interp)
 (require "compile.rkt")
-(require "interp.rkt")
 (require "types.rkt")
 (require "build-runtime.rkt")
 (provide exec)

extort/interp-io.rkt

@@ -1,10 +1,9 @@
 #lang racket
 (provide interp/io)
 (require "interp.rkt")
-
-;; String Expr -> (Cons Value String)
+;; String Expr -> (Cons Answer String)
 ;; Interpret e with given string as input,
-;; return value and collected output as string
+;; return answer and collected output as string
 (define (interp/io e input)
   (define result (box #f))
   (define output

extort/interp.rkt

@@ -9,6 +9,8 @@
 ;; | Character
 ;; | Eof
 ;; | Void
+
+;; type Answer = Value | 'err
 ;; Expr -> Answer
 (define (interp e)
   (match e

extort/main.rkt

@@ -2,12 +2,19 @@
 (require "ast.rkt")
 (require "parse.rkt")
 (require "interp.rkt")
+(require "interp-io.rkt")
 (require "compile.rkt")
+(require "types.rkt")
 (require "run.rkt")
+(require "exec.rkt")
+(require "exec-io.rkt")
 (provide (all-from-out "ast.rkt"))
 (provide (all-from-out "parse.rkt"))
 (provide (all-from-out "interp.rkt"))
+(provide (all-from-out "interp-io.rkt"))
 (provide (all-from-out "compile.rkt"))
+(provide (all-from-out "types.rkt"))
 (provide (all-from-out "run.rkt"))
-
+(provide (all-from-out "exec.rkt"))
+(provide (all-from-out "exec-io.rkt"))
 

fraud/assert.rkt

@@ -0,0 +1,44 @@
+#lang racket
+(provide assert-integer assert-char assert-byte assert-codepoint)
+(require a86/ast)
+(require "types.rkt")
+
+(define r9 'r9)
+
+;; Register -> Asm
+(define (assert-integer r)
+  (seq (Mov r9 r)
+       (And r9 mask-int)
+       (Cmp r9 type-int)
+       (Jne 'err)))
+
+;; Register -> Asm
+(define (assert-char r)
+  (seq (Mov r9 r)
+       (And r9 mask-char)
+       (Cmp r9 type-char)
+       (Jne 'err)))
+
+;; Register -> Asm
+(define (assert-codepoint r)
+  (let ((ok (gensym)))
+    (seq (assert-integer r)
+         (Cmp r (value->bits 0))
+         (Jl 'err)
+         (Cmp r (value->bits 1114111))
+         (Jg 'err)
+         (Cmp r (value->bits 55295))
+         (Jl ok)
+         (Cmp r (value->bits 57344))
+         (Jg ok)
+         (Jmp 'err)
+         (Label ok))))
+
+;; Register -> Asm
+(define (assert-byte r)
+  (seq (assert-integer r)
+       (Cmp r (value->bits 0))
+       (Jl 'err)
+       (Cmp r (value->bits 255))
+       (Jg 'err)))
+