126

1 files changed, 59 insertions, 59 deletions

diff --git a/mu.arc.t b/mu.arc.t
index 7f7f8a14..5439619f 100644
--- a/mu.arc.t
+++ b/mu.arc.t
@@ -200,9 +200,9 @@
 (reset)
 (new-trace "sub-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- sub (1 literal) (3 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 -2)
   (prn "F - 'sub' subtracts the second arg from the first"))
@@ -210,9 +210,9 @@
 (reset)
 (new-trace "mul-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- mul (2 literal) (3 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 6)
   (prn "F - 'mul' multiplies like 'add' adds"))
@@ -220,9 +220,9 @@
 (reset)
 (new-trace "div-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- div (8 literal) (3 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 (/ real.8 3))
   (prn "F - 'div' divides like 'sub' subtracts"))
@@ -230,12 +230,12 @@
 (reset)
 (new-trace "idiv-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) (2 integer) <- idiv (8 literal) (3 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 2))
-  (prn "F - 'idiv' performs integer division, returning quotient and remainder"))
+  (prn "F - 'idiv' performs integer division, returning quotient and retest1der"))
 
 ; Basic boolean operations: and, or, not
 ; There are easy ways to encode booleans in binary, but we'll skip past those
@@ -244,9 +244,9 @@
 (reset)
 (new-trace "and-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 boolean) <- and (t literal) (nil literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 nil)
   (prn "F - logical 'and' for booleans"))
@@ -256,9 +256,9 @@
 (reset)
 (new-trace "lt-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 boolean) <- lt (4 literal) (3 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 nil)
   (prn "F - 'lt' is the less-than inequality operator"))
@@ -266,9 +266,9 @@
 (reset)
 (new-trace "le-literal-false")
 (add-fns
-  '((main
+  '((test1
       ((1 boolean) <- le (4 literal) (3 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 nil)
   (prn "F - 'le' is the <= inequality operator"))
@@ -276,9 +276,9 @@
 (reset)
 (new-trace "le-literal-true")
 (add-fns
-  '((main
+  '((test1
       ((1 boolean) <- le (4 literal) (4 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 t)
   (prn "F - 'le' returns true for equal operands"))
@@ -286,9 +286,9 @@
 (reset)
 (new-trace "le-literal-true-2")
 (add-fns
-  '((main
+  '((test1
       ((1 boolean) <- le (4 literal) (5 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 t)
   (prn "F - le is the <= inequality operator - 2"))
@@ -300,12 +300,12 @@
 (reset)
 (new-trace "jmp-skip")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (8 literal))
       (jmp (1 offset))
       ((2 integer) <- copy (3 literal))  ; should be skipped
       (reply))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 8))
   (prn "F - 'jmp' skips some instructions"))
@@ -313,13 +313,13 @@
 (reset)
 (new-trace "jmp-target")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (8 literal))
       (jmp (1 offset))
       ((2 integer) <- copy (3 literal))  ; should be skipped
       (reply)
       ((3 integer) <- copy (34 literal)))))  ; never reached
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 8))
   (prn "F - 'jmp' doesn't skip too many instructions"))
@@ -328,14 +328,14 @@
 (reset)
 (new-trace "jif-skip")
 (add-fns
-  '((main
+  '((test1
       ((2 integer) <- copy (1 literal))
       ((1 boolean) <- eq (1 literal) (2 integer))
       (jif (1 boolean) (1 offset))
       ((2 integer) <- copy (3 literal))
       (reply)
       ((3 integer) <- copy (34 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 t  2 1))
   (prn "F - 'jif' is a conditional 'jmp'"))
@@ -343,13 +343,13 @@
 (reset)
 (new-trace "jif-fallthrough")
 (add-fns
-  '((main
+  '((test1
       ((1 boolean) <- eq (1 literal) (2 literal))
       (jif (3 boolean) (1 offset))
       ((2 integer) <- copy (3 literal))
       (reply)
       ((3 integer) <- copy (34 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 nil  2 3))
   (prn "F - if 'jif's first arg is false, it doesn't skip any instructions"))
@@ -357,7 +357,7 @@
 (reset)
 (new-trace "jif-backward")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (2 literal))
       ((2 integer) <- copy (1 literal))
       ; loop
@@ -367,7 +367,7 @@
       ((4 integer) <- copy (3 literal))
       (reply)
       ((3 integer) <- copy (34 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 4  3 nil  4 3))
   (prn "F - 'jif' can take a negative offset to make backward jumps"))
@@ -379,10 +379,10 @@
 (reset)
 (new-trace "direct-addressing")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 integer) <- copy (1 integer)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 34))
   (prn "F - 'copy' performs direct addressing"))
@@ -395,11 +395,11 @@
 (reset)
 (new-trace "indirect-addressing")
 (add-fns
-  '((main
+  '((test1
       ((1 integer-address) <- copy (2 literal))
       ((2 integer) <- copy (34 literal))
       ((3 integer) <- copy (1 integer-address deref)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 34  3 34))
   (prn "F - 'copy' performs indirect addressing"))
@@ -410,11 +410,11 @@
 (reset)
 (new-trace "indirect-addressing-oarg")
 (add-fns
-  '((main
+  '((test1
       ((1 integer-address) <- copy (2 literal))
       ((2 integer) <- copy (34 literal))
       ((1 integer-address deref) <- add (2 integer) (2 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 36))
   (prn "F - instructions can perform indirect addressing on output arg"))
@@ -428,12 +428,12 @@
 (reset)
 (new-trace "get-record")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 boolean) <- copy (nil literal))
       ((3 boolean) <- get (1 integer-boolean-pair) (1 offset))
       ((4 integer) <- get (1 integer-boolean-pair) (0 offset)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 nil  3 nil  4 34))
   (prn "F - 'get' accesses fields of records"))
@@ -441,13 +441,13 @@
 (reset)
 (new-trace "get-indirect")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 boolean) <- copy (nil literal))
       ((3 integer-boolean-pair-address) <- copy (1 literal))
       ((4 boolean) <- get (3 integer-boolean-pair-address deref) (1 offset))
       ((5 integer) <- get (3 integer-boolean-pair-address deref) (0 offset)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 nil  3 1  4 nil  5 34))
   (prn "F - 'get' accesses fields of record address"))
@@ -455,12 +455,12 @@
 (reset)
 (new-trace "get-compound-field")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 integer) <- copy (35 literal))
       ((3 integer) <- copy (36 literal))
       ((4 integer-integer-pair) <- get (1 integer-point-pair) (1 offset)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 35  3 36  4 35  5 36))
   (prn "F - 'get' accesses fields spanning multiple locations"))
@@ -468,11 +468,11 @@
 (reset)
 (new-trace "get-address")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 integer) <- copy (t literal))
       ((3 boolean-address) <- get-address (1 integer-boolean-pair) (1 offset)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 t  3 2))
   (prn "F - 'get-address' returns address of fields of records"))
@@ -480,12 +480,12 @@
 (reset)
 (new-trace "get-address-indirect")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 integer) <- copy (t literal))
       ((3 integer-boolean-pair-address) <- copy (1 literal))
       ((4 boolean-address) <- get-address (3 integer-boolean-pair-address deref) (1 offset)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 t  3 1  4 2))
   (prn "F - 'get-address' accesses fields of record address"))
@@ -493,14 +493,14 @@
 (reset)
 (new-trace "index-array-literal")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (2 literal))
       ((2 integer) <- copy (23 literal))
       ((3 boolean) <- copy (nil literal))
       ((4 integer) <- copy (24 literal))
       ((5 boolean) <- copy (t literal))
       ((6 integer-boolean-pair) <- index (1 integer-boolean-pair-array) (1 literal)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 23 3 nil  4 24 5 t  6 24 7 t))
   (prn "F - 'index' accesses indices of arrays"))
@@ -508,7 +508,7 @@
 (reset)
 (new-trace "index-array-direct")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (2 literal))
       ((2 integer) <- copy (23 literal))
       ((3 boolean) <- copy (nil literal))
@@ -516,7 +516,7 @@
       ((5 boolean) <- copy (t literal))
       ((6 integer) <- copy (1 literal))
       ((7 integer-boolean-pair) <- index (1 integer-boolean-pair-array) (6 integer)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 23 3 nil  4 24 5 t  6 1  7 24 8 t))
   (prn "F - 'index' accesses indices of arrays"))
@@ -524,7 +524,7 @@
 (reset)
 (new-trace "index-address")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (2 literal))
       ((2 integer) <- copy (23 literal))
       ((3 boolean) <- copy (nil literal))
@@ -532,7 +532,7 @@
       ((5 boolean) <- copy (t literal))
       ((6 integer) <- copy (1 literal))
       ((7 integer-boolean-pair-address) <- index-address (1 integer-boolean-pair-array) (6 integer)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 23 3 nil  4 24 5 t  6 1  7 4))
   (prn "F - 'index-address' returns addresses of indices of arrays"))
@@ -544,14 +544,14 @@
 (reset)
 (new-trace "len-array")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (2 literal))
       ((2 integer) <- copy (23 literal))
       ((3 boolean) <- copy (nil literal))
       ((4 integer) <- copy (24 literal))
       ((5 boolean) <- copy (t literal))
       ((6 integer) <- len (1 integer-boolean-pair-array)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 2  2 23 3 nil  4 24 5 t  6 2))
   (prn "F - 'len' accesses length of array"))
@@ -561,9 +561,9 @@
 (reset)
 (new-trace "sizeof-record")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- sizeof (integer-boolean-pair type)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 2)
   (prn "F - 'sizeof' returns space required by arg"))
@@ -571,9 +571,9 @@
 (reset)
 (new-trace "sizeof-record-not-len")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- sizeof (integer-point-pair type)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~is memory*.1 3)
   (prn "F - 'sizeof' is different from number of elems"))
@@ -583,12 +583,12 @@
 (reset)
 (new-trace "compound-operand")
 (add-fns
-  '((main
+  '((test1
       ((1 integer) <- copy (34 literal))
       ((2 boolean) <- copy (nil literal))
       ((4 boolean) <- copy (t literal))
       ((3 integer-boolean-pair) <- copy (1 integer-boolean-pair)))))
-(run 'main)
+(run 'test1)
 ;? (prn memory*)
 (if (~iso memory* (obj 1 34  2 nil  3 34  4 nil))
   (prn "F - ops can operate on records spanning multiple locations"))