Rewrite most of the compiler.

This represents a major step back in terms of functionality, and amount
of code. The latter I think constitutes a major win. Next steps are to
reimplement syntax-rules, call/cc, and call-with-values.

1 files changed, 0 insertions, 155 deletions

diff --git a/lib/csc/hash-map-test.csc b/lib/csc/hash-map-test.csc
deleted file mode 100644
index 6f83c30..0000000
--- a/lib/csc/hash-map-test.csc
+++ /dev/null
@@ -1,155 +0,0 @@
-(define-library (csc hash-map-test)
-  (import (scheme base)
-          (only (csc format)
-            sprintf)
-          (only (csc loop)
-            loop
-            return)
-          (only (csc sort) sort)
-          (only (csc testing)
-                assert-equal
-                assert-raises
-                test)
-          (csc hash-map))
-  (begin
-
-
-    (define transform-map
-      (list
-        (cons map? map->alist)
-        (cons list? (lambda (l) (sort (lambda (x y) (string<? (symbol->string (car x)) (symbol->string (car y)))) l)))))
-
-
-    (test alist->map-singleton
-      (assert-equal
-        '((a . 1))
-        (alist->map compare-symbols '((a . 1)))
-        transform-map))
-
-
-    (test alist->map-two
-      (assert-equal
-        '((a . 1) (b . 2))
-        (alist->map compare-symbols '((a . 1) (b . 2)))
-        transform-map))
-
-
-    (test alist->map-longer
-      (assert-equal
-        '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6))
-        (alist->map compare-symbols '((a . 1) (b . 2) (c . 3) (d . 4) (e . 5) (f . 6)))
-        transform-map))
-
-
-    (test alist->map-larger
-      (assert-equal
-        '((f . 5) (m . 1) (n . 7) (q . 3) (x . 8))
-        (alist->map compare-symbols '((m . 1) (n . 2) (q . 3) (f . 5) (n . 7) (x . 8)))
-        transform-map))
-
-
-    (test alist->map-in-order
-      (assert-equal
-        '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()))
-        (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
-        transform-map))
-
-
-    (test alist->map-reversed
-      (assert-equal
-        '((h . ()) (g . ()) (f . ()) (e . ()) (d . ()) (c . ()) (b . ()) (a . ()))
-        (alist->map compare-symbols '((a . ()) (b . ()) (c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ())))
-        transform-map))
-
-
-    (test alist->map-overwrite
-      (assert-equal
-        '((a . 2))
-        (alist->map compare-symbols '((a . 1) (a . 2)))
-        transform-map))
-
-
-    (test alist->map-alternating
-      (assert-equal
-        '((h . ()) (g . ()) (i . ()) (f . ()) (j . ()) (e . ()) (k . ()) (d . ()) (l . ()) (c . ()))
-        (alist->map compare-symbols '((c . ()) (d . ()) (e . ()) (f . ()) (g . ()) (h . ()) (i . ()) (j . ()) (k . ()) (l . ())))
-        transform-map))
-
-
-    (define (test-map . bindings)
-      (alist->map compare-symbols bindings))
-
-
-    (test lookup
-      (assert-equal
-        2
-        (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'b)))
-
-
-    (test lookup-notfound
-      (assert-raises key-not-found-error?
-        (lookup (test-map '(a . 1) '(b . 2) '(c . 3)) 'd)))
-
-
-    (test lookup-default
-      (assert-equal
-        #f
-        (lookup (test-map '(a . #t) '(b . #t)) 'c #f)))
-
-
-    (test merge
-      (assert-equal
-        '((a . 1) (b . 2) (c . 3) (d . 4))
-        (merge
-          (test-map '(a . 1) '(b . 2))
-          (test-map '(c . 3) '(d . 4)))
-        transform-map))
-
-
-    (test delete
-      (assert-equal
-        '((a . 1) (b . 2) (d . 4))
-        (delete
-          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
-          'c)
-        transform-map))
-
-
-    (test delete-only
-      (assert-equal
-        '()
-        (delete
-          (test-map '(a . 1))
-          'a)
-        transform-map))
-
-
-    (test delete-first
-      (assert-equal
-        '((b . 2) (c . 3) (d . 4))
-        (delete
-          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
-          'a)
-        transform-map))
-
-
-    (test delete-last
-      (assert-equal
-        '((a . 1) (b . 2) (c . 3))
-        (delete
-          (test-map '(a . 1) '(b . 2) '(c . 3) '(d . 4))
-          'd)
-        transform-map))
-
-
-    (test delete-many
-      (assert-equal
-        '()
-        (loop with m = (loop with m = (test-map)
-                             for i from 1 to 100
-                             do (set! m (insert m (string->symbol (sprintf "key{}" i)) i))
-                             finally (return m))
-              for i from 1 to 100
-              do (set! m (delete m (string->symbol (sprintf "key{}" i))))
-              finally (return m))
-        transform-map))))