Start on iniquity notes.

Author: dvanhorn

www/notes/iniquity.scrbl

@@ -0,0 +1,92 @@
+#lang scribble/manual
+
+@(require (for-label (except-in racket ...)))
+@(require redex/pict
+          racket/runtime-path
+          scribble/examples
+	  "hustle/semantics.rkt"
+	  "utils.rkt"
+	  "ev.rkt"
+	  "../utils.rkt")
+
+@(define codeblock-include (make-codeblock-include #'h))
+
+@(for-each (λ (f) (ev `(require (file ,(path->string (build-path notes "iniquity" f))))))
+	   '() #;'("interp.rkt" "compile.rkt" "asm/interp.rkt" "asm/printer.rkt"))
+
+@title[#:tag "Iniquity"]{Iniquity: function definitions and calls}
+
+@table-of-contents[]
+
+@section[#:tag-prefix "iniquity"]{Functions}
+
+Our programming languages so far have been impoverished in the
+following sense: in order to process arbitrarily large data, the
+programs themselves must be proportionally as large.  Want to compute
+something over a billion element list?  You'll need a billion
+expressions.  Consequently, the expressiveness of our language is
+severely restricted.
+
+Let's now remove that restriction by incorporating @bold{functions},
+and in particular, @bold{recursive functions}, which will allow us to
+compute over arbitrarily large data with finite-sized programs.
+
+Let's call it @bold{Iniquity}.
+
+We will extend the syntax by introducing a new syntactic category of
+programs, which have the shape:
+
+@racketblock[
+(begin
+  (define (_f0 _x0 ...) _e0)
+  (define (_f1 _x1 ...) _e1)
+  ...
+  _e)]
+
+And the syntax of expressions will be extended to include function calls:
+
+@racketblock[
+(_fi _e0 ...)
+]
+
+where @racket[_fi] is one of the function names defined in the program.
+
+Note that functions can have any number of parameters and,
+symmetrically, calls can have any number of arguments.  A program
+consists of zero or more function definitions followed by an
+expression.
+
+
+@section[#:tag-prefix "iniquity"]{An Interpreter for Functions}
+
+Writing an interpreter for Inquity is not too hard.  The main idea is
+that the interpretation of expression is now parameterized by a set of
+function definitions from the program.  It serves as a second kind of
+environment that gets passed around and is used to resolve function
+definitions when interpreting function calls.
+
+The way a function call is interpreted is to first interpret all of
+the arguments, building up a list of results.  Then the definition of
+the function being called is looked up.  If the function has the same
+number of parameters as there are arguments in the call, the body of
+the function is interpreted in an enviorment that maps each parameter
+to to the corresponding argument.  That's it.
+
+@codeblock-include["iniquity/interp.rkt"]
+
+A couple of things to note:
+
+@itemlist[
+
+@item{since the function definition environment is passed along even
+when interpreting the body of function definitions, this
+interpretation supports recursion, and even mutual recursion.}
+
+@item{functions are @emph{not} values (yet).  We cannot bind a
+variable to a function.  We cannot make a list of functions.  We
+cannot compute a function.  The first position of a function call is a
+function @emph{name}, not an arbitrary expression.  Nevertheless, we
+have significantly increased the expressivity of our language.}
+
+]
+

www/notes/iniquity/Makefile

@@ -0,0 +1,31 @@
+UNAME := $(shell uname)
+.PHONY: test
+
+ifeq ($(UNAME), Darwin)
+  format=macho64
+else ifeq ($(UNAME), Linux)
+  format=elf64
+else
+  format=win64
+endif
+
+%.run: %.o main.o char.o
+	gcc main.o char.o $< -o $@
+
+main.o: main.c types.h
+	gcc -c main.c -o main.o
+
+char.o: char.c types.h
+	gcc -c char.c -o char.o
+
+%.o: %.s
+	nasm -f $(format) -o $@ $<
+
+%.s: %.rkt
+	racket -t compile-file.rkt -m $< > $@
+
+clean:
+	rm *.o *.s *.run
+
+test: 42.run
+	@test "$(shell ./42.run)" = "42"

www/notes/iniquity/asm/ast.rkt

@@ -0,0 +1,26 @@
+#lang racket
+
+;; type Asm = [Listof Instruction]
+ 
+;; type Instruction =
+;; | `ret
+;; | `(mov ,Arg ,Arg)
+;; | `(add ,Arg ,Arg)
+;; | `(sub ,Arg ,Arg)
+;; | `(cmp ,Arg ,Arg)
+;; | `(jmp ,Label)
+;; | `(je  ,Label)
+;; | `(jne ,Label)
+;; | `(neg ,Arg)
+;; | `(cmovl ,Arg Arg)
+;; | Label
+
+;; type Label = Symbol
+ 
+;; type Arg =
+;; | Reg
+;; | Integer
+ 
+;; type Reg =
+;; | `rax
+;; | `rbx

www/notes/iniquity/asm/interp.rkt

@@ -0,0 +1,23 @@
+#lang racket
+(provide (all-defined-out))
+(require "printer.rkt" racket/runtime-path)
+(define-runtime-path dir "..")
+
+;; Asm -> Integer
+;; Interpret (by assemblying, linking, and exec'ing) x86-64 code
+;; Assume: starts with entry point run-time expects
+(define (asm-interp a)
+  (let* ((t.s (make-temporary-file "nasm~a.s"))
+         (t.run (path-replace-extension t.s #".run")))
+    (with-output-to-file t.s
+      #:exists 'truncate
+      (λ ()
+        (asm-display a)))
+    (system (format "(cd ~a && make -s ~a) 2>&1 >/dev/null" dir t.run))
+    (delete-file t.s)
+    (with-input-from-string
+        (with-output-to-string
+          (λ ()
+            (system (path->string t.run))
+            (delete-file t.run)))
+      read)))

www/notes/iniquity/asm/printer.rkt

@@ -0,0 +1,79 @@
+#lang racket
+(provide (all-defined-out))
+
+;; Asm -> String
+(define (asm->string a)
+  (foldr (λ (i s) (string-append (instr->string i) s)) "" a))
+
+;; Instruction -> String
+(define (instr->string i)
+  (match i
+    [`(,(? opcode2? o) ,a1 ,a2)
+     (string-append "\t"
+                    (symbol->string o) " "
+                    (arg->string a1) ", "
+                    (arg->string a2) "\n")]    
+    [`(jmp ,l)
+     (string-append "\tjmp " (arg->string l) "\n")]
+    [`(je ,l)
+     (string-append "\tje " (label->string l) "\n")]
+    [`(jle ,l)
+     (string-append "\tjle " (label->string l) "\n")]
+    [`(jl ,l)
+     (string-append "\tjl " (label->string l) "\n")]
+    [`(jg ,l)
+     (string-append "\tjg " (label->string l) "\n")]
+    [`(jge ,l)
+     (string-append "\tjge " (label->string l) "\n")]
+    [`(jne ,l)
+     (string-append "\tjne " (label->string l) "\n")]
+    [`ret "\tret\n"]
+    [`(neg ,a1)
+     (string-append "\tneg " (arg->string a1) "\n")]
+    [`(call ,l)
+     (string-append "\tcall " (label->string l) "\n")]
+    [`(push ,r)
+     (string-append "\tpush " (reg->string r) "\n")]    
+    [l (string-append (label->string l) ":\n")]))
+
+(define (opcode2? x)
+  (memq x '(mov add sub cmp and cmovl xor or sal sar lea)))
+
+;; Arg -> String
+(define (arg->string a)
+  (match a
+    [(? reg?) (reg->string a)]
+    [`(offset ,r)
+     (string-append "[" (arg->string r) "]")]
+    [`(offset ,r ,i)
+     (string-append "[" (arg->string r) " + " (number->string (* i 8)) "]")]    
+    [(? integer?) (number->string a)]
+    [(? symbol?) (label->string a)]))
+
+;; Any -> Boolean
+(define (reg? x)
+  (and (symbol? x)
+       (memq x '(rax rbx rcx rsp rdi rip))))
+
+;; Reg -> String
+(define (reg->string r)
+  (symbol->string r))
+
+;; Label -> String
+;; prefix with _ for Mac
+(define label->string
+  (match (system-type 'os)
+    ['macosx
+     (λ (s) (string-append "_" (symbol->string s)))]
+    [_ symbol->string]))
+
+;; Asm -> Void
+(define (asm-display a)
+  ;; entry point will be first label
+  (let ((g (findf symbol? a)))
+    (display 
+     (string-append "\tglobal " (label->string g) "\n"
+                    "\tdefault rel\n"
+                    "\textern " (label->string 'error) "\n"                    
+                    "\tsection .text\n"
+                    (asm->string a)))))