Merge pull request #1069 from andrew-johnson-4/more-lm-to-lsts-3

More lm to lsts 3

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lambda_mountain"
-version = "1.20.4"
+version = "1.20.5"
 authors = ["Andrew <andrew@subarctic.org>"]
 license = "MIT"
 description = "Typed Macro Assembler (backed by Coq proofs-of-correctness)"

Makefile

@@ -1,6 +1,6 @@
 
 dev: install-production
-	lm tests/regress/eprint.lsts
+	lm tests/lib/tuple.lsts
 	cc -O3 tmp.c
 	./a.out
 

PLATFORM/C/LIB/cmp.lsts

@@ -19,3 +19,12 @@ let $"<"(l: x, r: x): U64  = cmp(l, r) <  Equal;
 let $"<="(l: x, r: x): U64 = cmp(l, r) <= Equal;
 let $">"(l: x, r: x): U64  = cmp(l, r) >  Equal;
 let $">="(l: x, r: x): U64 = cmp(l, r) >= Equal;
+
+let $"&&"(l: Ord, r: Ord): Ord = if l == Equal then r else l;
+
+#TODO print(IO::File, String)
+#let print(io: IO::File, o: Ord): Nil = (
+#   if o == GreaterThan then print(io, "GreaterThan") else
+#   if o == Equal then print(io, "Equal") else
+#   print(io, "LessThan");
+#);

PLATFORM/C/LIB/default.lm

@@ -31,7 +31,7 @@ import PLATFORM/C/LIB/string.lsts;
 import PLATFORM/C/LIB/smart-string.lm;
 import PLATFORM/C/LIB/smart-string.lsts;
 import PLATFORM/C/LIB/s.lm;
-import PLATFORM/C/LIB/tuple.lm;
+import PLATFORM/C/LIB/tuple.lsts;
 import PLATFORM/C/LIB/list.lm;
 import PLATFORM/C/LIB/list.lsts;
 import PLATFORM/C/LIB/vector.lsts;

PLATFORM/C/LIB/tuple.lsts

@@ -0,0 +1,42 @@
+
+type Tuple<x,y> = Tuple { first: x, second: y };
+
+let cmp(l: Tuple<x,y>, r: Tuple<x,y>): Ord = (
+   cmp(l.first, r.first) && cmp(l.second, r.second)
+);
+
+let deep-hash(l: Tuple<x,y>): U64 = (
+   deep-hash(l.first) + deep-hash(l.second)
+);
+
+let print(io: IO::File, l: Tuple<x,y>): Nil = (
+   print(io, "("); print(io, l.first); print(io, ","); print(io, l.second); print(io, ")");
+);
+
+let $"=="(l: Tuple<x,y>, r: Tuple<x,y>): U64 = (
+   l.first == r.first && l.second == r.second
+);
+
+let $"!="(l: Tuple<x,y>, r: Tuple<x,y>): U64 = (
+   l.first != r.first || l.second != r.second
+);
+
+let $"<"(l: Tuple<x,y>, r: Tuple<x,y>): U64 = (
+   l.first < r.first ||
+   (l.first == r.first && l.second < r.second)
+);
+
+let $"<="(l: Tuple<x,y>, r: Tuple<x,y>): U64 = (
+   l.first < r.first ||
+   (l.first == r.first && l.second <= r.second)
+);
+
+let $">"(l: Tuple<x,y>, r: Tuple<x,y>): U64 = (
+   l.first > r.first ||
+   (l.first == r.first && l.second > r.second)
+);
+
+let $">="(l: Tuple<x,y>, r: Tuple<x,y>): U64 = (
+   l.first > r.first ||
+   (l.first == r.first && l.second >= r.second)
+);

PLATFORM/C/LIB/u64.lsts

@@ -22,3 +22,5 @@ declare-binop( $">>", raw-type(U64), raw-type(U64+Constant), raw-type(U64), ( l"
 declare-unop( not, raw-type(U64), raw-type(U64), ( l"(!"; x; l")"; ) );
 
 declare-unop( into-branch-conditional, raw-type(U64), raw-type(BranchConditional), x );
+
+let cmp(l: U64, r: U64): Ord = if l==r then Equal else if l<r then LessThan else GreaterThan;

tests/lib/cmp.lsts

@@ -0,0 +1,36 @@
+
+import LIB/default.lm;
+
+assert( LessThan == LessThan );
+assert( LessThan != Equal );
+assert( LessThan != GreaterThan );
+assert( Equal != LessThan );
+assert( Equal == Equal );
+assert( Equal != GreaterThan );
+assert( GreaterThan != LessThan );
+assert( GreaterThan != Equal );
+assert( GreaterThan == GreaterThan );
+
+assert( LessThan < Equal );
+assert( LessThan < GreaterThan );
+assert( Equal < GreaterThan );
+
+assert( LessThan <= LessThan );
+assert( LessThan <= Equal );
+assert( LessThan <= GreaterThan );
+assert( Equal <= Equal );
+assert( Equal <= GreaterThan );
+assert( GreaterThan <= GreaterThan );
+
+assert( GreaterThan > LessThan );
+assert( GreaterThan > Equal );
+assert( Equal > LessThan );
+
+assert( GreaterThan >= LessThan );
+assert( GreaterThan >= Equal );
+assert( GreaterThan >= GreaterThan );
+assert( Equal >= LessThan );
+assert( Equal >= Equal );
+assert( LessThan >= LessThan );
+
+print("Success\n");

tests/lib/cmp.lsts.out

@@ -0,0 +1 @@
+Success

tests/lib/tuple.lsts

@@ -0,0 +1,8 @@
+
+import LIB/default.lm;
+
+assert( Tuple(1, 2) == Tuple(1, 2) );
+assert( Tuple(1, 2) != Tuple(1, 3) );
+assert( Tuple(1, 2) != Tuple(2, 2) );
+
+print("Success\n");

tests/lib/tuple.lsts.out

@@ -0,0 +1 @@
+Success

tests/regress.rs

@@ -126,6 +126,19 @@ fn regression_tests() {
          }
       }
    }
+   for entry in glob("tests/lib/*.lsts").unwrap() {
+      let path = entry.unwrap().display().to_string();
+      if !std::path::Path::new(&(path.clone() + ".skip")).exists() {
+         let expected = std::fs::read_to_string(path.clone() + ".out")
+                       .expect(&format!("Could not load expected output {}.out", path));
+         let expected = expected.trim().to_string();
+         let actual = run_bootstrap(&path);
+         let actual = actual.trim().to_string();
+         if expected != actual {
+            failures.push(( "--compile", path, expected, actual ));
+         }
+      }
+   }
    for (mode,path,expected,actual) in &failures {
       eprintln!("TEST {} {}", mode, path);
       eprintln!("Expected: '{}'", &expected[..std::cmp::min(4000,expected.len())] );