core: Remove last_pair, list_ref, string_ref.
authorJan Nieuwenhuizen <janneke@gnu.org>
Fri, 23 Dec 2016 19:09:57 +0000 (20:09 +0100)
committerJan Nieuwenhuizen <janneke@gnu.org>
Fri, 23 Dec 2016 19:09:57 +0000 (20:09 +0100)
* lib.c (last_pair, list_ref): Remove.
* string.c (string_ref): Remove.
* module/mes/type-0.mes (string->list): New function.
* module/mes/scm.mes (string-ref): New function.

lib.c
mes.c
module/mes/scm.mes
module/mes/type-0.mes
string.c

diff --git a/lib.c b/lib.c
index 7bc77144a096fffa9c7074ce60ae575ce051b7d6..81da6e2a5af32c02094eb893157c028746e45529 100644 (file)
--- a/lib.c
+++ b/lib.c
@@ -43,42 +43,12 @@ length (SCM x)
   return MAKE_NUMBER (n);
 }
 
-SCM
-last_pair (SCM x)
-{
-  while (x != cell_nil && cdr (x) != cell_nil)
-    x = cdr (x);
-  return x;
-}
-
 SCM
 list (SCM x) ///((arity . n))
 {
   return x;
 }
 
-SCM
-list_ref (SCM x, SCM k)
-{
-  assert (TYPE (x) == PAIR);
-  assert (TYPE (k) == NUMBER);
-  int n = VALUE (k);
-  while (n-- && CDR (x) != cell_nil) x = CDR (x);
-  return x != cell_nil ? car (x) : cell_undefined;
-}
-
-SCM
-vector_to_list (SCM v)
-{
-  SCM x = cell_nil;
-  for (int i = 0; i < LENGTH (v); i++) {
-    SCM e = VECTOR (v)+i;
-    if (TYPE (e) == REF) e = g_cells[e].ref;
-    x = append2 (x, cons (e, cell_nil));
-  }
-  return x;
-}
-
 SCM
 builtin_exit (SCM x)
 {
diff --git a/mes.c b/mes.c
index 7754cff72b3998c00cb259105be34a27a122719b..e3c95e34cf6edd8113febf6bca9e5555f9c09829 100644 (file)
--- a/mes.c
+++ b/mes.c
@@ -807,6 +807,18 @@ list_to_vector (SCM x)
   return v;
 }
 
+SCM
+vector_to_list (SCM v)
+{
+  SCM x = cell_nil;
+  for (int i = 0; i < LENGTH (v); i++) {
+    SCM e = VECTOR (v)+i;
+    if (TYPE (e) == REF) e = g_cells[e].ref;
+    x = append2 (x, cons (e, cell_nil));
+  }
+  return x;
+}
+
 FILE *g_stdin;
 int
 getchar ()
index 328a569b26b19f8e3b8f55e648cbb9ee585b96a5..808120fced61262dad25258058febbd97abab1bc 100644 (file)
 
 (define (cadddr x) (car (cdddr x)))
 
-(define (list . rest) rest)
-
-(define (list-head x n)
-  (if (= 0 n) '()
-      (cons (car x) (list-head (cdr x) (- n 1)))))
-
-(define (list-tail x n)
-  (if (= 0 n) x
-      (list-tail (cdr x) (- n 1))))
-
-(define (string-prefix? prefix string)
-  (and
-   (>= (string-length string) (string-length prefix))
-   (equal? (substring string 0 (string-length prefix)) prefix)))
-
-(define (symbol-prefix? prefix symbol)
-  (string-prefix? (symbol->string prefix) (symbol->string symbol)))
-
-(define (symbol-append . rest)
-  (string->symbol (apply string-append (map symbol->string rest))))
-
 (define-macro (case val . args)
   (if (null? args) #f
       (let ((clause (car args)))
        ,@body
        (loop ,@(cddar init)))))
 
-(define integer? number?)
+(define (for-each f l . r)
+  (if (pair? l) (if (null? r) (begin (f (car l)) (for-each f (cdr l)))
+                    (if (null? (cdr r)) (begin (f (car l) (caar r)) (for-each f (cdr l) (cdar r)))))))
 
-(define (make-list n . x)
-  (let ((fill (if (pair? x) (car x) *unspecified*)))
-    (let loop ((n n))
-      (if (= 0 n) '()
-          (cons fill (loop (- n 1)))))))
+(define (error who . rest)
+  (display "error:" (current-error-port))
+  (display who (current-error-port))
+  (display ":" (current-error-port))
+  (display rest (current-error-port))
+  (newline (current-error-port))
+  (display "exiting...\n" (current-error-port))
+  (exit 1))
 
-(define (string->list s)
-  (let ((n (string-length s)))
-    (let loop ((i 0))
-      (if (= i n) '()
-          (cons (string-ref s i) (loop (+ i 1)))))))
+(define (syntax-error message . rest)
+  (display "syntax-error:" (current-error-port))
+  (display message (current-error-port))
+  (display ":" (current-error-port))
+  (display rest (current-error-port))
+  (newline (current-error-port)))
 
-(define (string->number s . radix)
-  (if (and (pair? radix) (not (= (car radix) 10))) '*STRING->NUMBER:RADIX-NOT-SUPPORTED
-      (let* ((lst (string->list s))
-             (sign (if (char=? (car lst) #\-) -1 1))
-             (lst (if (= sign -1) (cdr lst) lst)))
-        (let loop ((lst lst) (n 0))
-          (if (null? lst) (* sign n)
-              (loop (cdr lst) (+ (* n 10) (- (char->integer (car lst)) (char->integer #\0)))))))))
+\f
+(define integer? number?)
+
+(define (eof-object? x)
+  (or (and (number? x) (= x -1))
+      (and (char? x) (eof-object? (char->integer x)))))
 
 (define (peek-char)
   (integer->char (peek-byte)))
   (unread-byte (char->integer c))
   c)
 
-(define (char<? a b) (< (char->integer a) (char->integer b)))
-(define (char>? a b) (> (char->integer a) (char->integer b)))
-(define (char<=? a b) (<= (char->integer a) (char->integer b)))
-(define (char>=? a b) (>= (char->integer a) (char->integer b)))
-
-\f
-;; Vector
-(define (vector . rest) (list->vector rest))
-(define c:make-vector make-vector)
-(define (make-vector n . x)
-  (if (null? x) (c:make-vector n)
-      (list->vector (apply make-list (cons n x)))))
-
 (define (assq-set! alist key val)
   (let ((entry (assq key alist)))
     (cond (entry (set-cdr! entry val)
       (if (equal? x (car lst)) lst
           (member x (cdr lst)))))
 
-(define (for-each f l . r)
-  (if (pair? l) (if (null? r) (begin (f (car l)) (for-each f (cdr l)))
-                    (if (null? (cdr r)) (begin (f (car l) (caar r)) (for-each f (cdr l) (cdar r)))))))
+\f
+;;; Lists
+(define (list . rest) rest)
+
+(define (make-list n . x)
+  (let ((fill (if (pair? x) (car x) *unspecified*)))
+    (let loop ((n n))
+      (if (= 0 n) '()
+          (cons fill (loop (- n 1)))))))
+
+(define (list-ref lst k)
+  (let loop ((lst lst) (k k))
+    (if (= 0 k) (car lst)
+        (loop (cdr lst) (- k 1)))))
+
+(define (list-head x n)
+  (if (= 0 n) '()
+      (cons (car x) (list-head (cdr x) (- n 1)))))
+
+(define (list-tail x n)
+  (if (= 0 n) x
+      (list-tail (cdr x) (- n 1))))
+
+(define (last-pair lst)
+  (let loop ((lst lst))
+    (if (or (null? lst) (null? (cdr lst))) lst
+        (loop (cdr lst)))))
+
+(define (iota n)
+  (if (<= n 0) '()
+      (append2 (iota (- n 1)) (list (- n 1)))))
+
+(define (reverse lst)
+  (if (null? lst) '()
+      (append (reverse (cdr lst)) (cons (car lst) '()))))
+
+(define (filter pred lst)
+  (let loop ((lst lst))
+    (if (null? lst) '()
+        (if (pred (car lst))
+            (cons (car lst) (loop (cdr lst)))
+            (loop (cdr lst))))))
+
+(define (delete x lst)
+  (filter (lambda (e) (not (equal? e x))) lst))
+
+(define (delq x lst)
+  (filter (lambda (e) (not (eq? e x))) lst))
+
+\f
+;; Vector
+(define (vector . rest) (list->vector rest))
+(define c:make-vector make-vector)
+(define (make-vector n . x)
+  (if (null? x) (c:make-vector n)
+      (list->vector (apply make-list (cons n x)))))
+
+(define (vector-copy x)
+  (list->vector (vector->list x)))
+
+\f
+;;; Strings/srfi-13
+(define (string-ref s k)
+  (list-ref (string->list s) k))
+
+(define (string-prefix? prefix string)
+  (and
+   (>= (string-length string) (string-length prefix))
+   (equal? (substring string 0 (string-length prefix)) prefix)))
+
+(define (string->number s . radix)
+  (if (and (pair? radix) (not (= (car radix) 10))) '*STRING->NUMBER:RADIX-NOT-SUPPORTED
+      (let* ((lst (string->list s))
+             (sign (if (char=? (car lst) #\-) -1 1))
+             (lst (if (= sign -1) (cdr lst) lst)))
+        (let loop ((lst lst) (n 0))
+          (if (null? lst) (* sign n)
+              (loop (cdr lst) (+ (* n 10) (- (char->integer (car lst)) (char->integer #\0)))))))))
+
+\f
+;;; Symbols
+(define (symbol-prefix? prefix symbol)
+  (string-prefix? (symbol->string prefix) (symbol->string symbol)))
+
+(define (symbol-append . rest)
+  (string->symbol (apply string-append (map symbol->string rest))))
+
+(define gensym
+  (let ((counter 0))
+    (lambda (. rest)
+      (let ((value (number->string counter)))
+        (set! counter (+ counter 1))
+        (string->symbol (string-append "g" value))))))
+
+\f
+;;; Characters
+(define (char=? x y)
+  (and (char? x) (char? y)
+       (eq? x y)))
 
+(define (char<? a b) (< (char->integer a) (char->integer b)))
+(define (char>? a b) (> (char->integer a) (char->integer b)))
+(define (char<=? a b) (<= (char->integer a) (char->integer b)))
+(define (char>=? a b) (>= (char->integer a) (char->integer b)))
+
+(define (char-alphabetic? x)
+  (and (char? x)
+       (let ((i (char->integer x)))
+        (or (and (>= i (char->integer #\A)) (<= i (char->integer #\Z)))
+            (and (>= i (char->integer #\a)) (<= i (char->integer #\z)))))))
+
+(define (char-numeric? x)
+  (and (char? x)
+       (let ((i (char->integer x)))
+         (and (>= i (char->integer #\0)) (<= i (char->integer #\9))))))
+
+\f
+;;; Math
 (define (<= . rest)
   (or (apply < rest)
       (apply = rest)))
   (or (apply > rest)
       (apply = rest)))
 
-;; (define (>= . rest)
-;;   (if (apply > rest) #t
-;;       (if (apply = rest) #t
-;;           #f)))
-
 (define (remainder x y)
   (- x (* (quotient x y) y)))
 
       (let ((y (car rest)))
         (let ((z (if (< x y) x y)))
           (apply min (cons z (cdr rest)))))))
-
-(define gensym
-  (let ((counter 0))
-    (lambda (. rest)
-      (let ((value (number->string counter)))
-        (set! counter (+ counter 1))
-        (string->symbol (string-append "g" value))))))
-
-(define else #t)
-
-(define (error who . rest)
-  (display "error:" (current-error-port))
-  (display who (current-error-port))
-  (display ":" (current-error-port))
-  (display rest (current-error-port))
-  (newline (current-error-port))
-  (display "exiting...\n" (current-error-port))
-  (exit 1))
-
-(define (syntax-error message . rest)
-  (display "syntax-error:" (current-error-port))
-  (display message (current-error-port))
-  (display ":" (current-error-port))
-  (display rest (current-error-port))
-  (newline (current-error-port)))
-
-(define (list-ref lst k)
-  (let loop ((lst lst) (k k))
-    (if (= 0 k) (car lst)
-        (loop (cdr lst) (- k 1)))))
-
-(define (iota n)
-  (if (<= n 0) '()
-      (append2 (iota (- n 1)) (list (- n 1)))))
-
-;; srfi-1
-(define (last-pair lst)
-  (let loop ((lst lst))
-    (if (or (null? lst) (null? (cdr lst))) lst
-        (loop (cdr lst)))))
-
-(define (reverse lst)
-  (if (null? lst) '()
-      (append (reverse (cdr lst)) (cons (car lst) '()))))
-
-(define (filter pred lst)
-  (let loop ((lst lst))
-    (if (null? lst) '()
-        (if (pred (car lst))
-            (cons (car lst) (loop (cdr lst)))
-            (loop (cdr lst))))))
-
-(define (delete x lst)
-  (filter (lambda (e) (not (equal? e x))) lst))
-
-(define (delq x lst)
-  (filter (lambda (e) (not (eq? e x))) lst))
-
-(define (vector-copy x)
-  (list->vector (vector->list x)))
-
-(define (eof-object? x)
-  (or (and (number? x) (= x -1))
-      (and (char? x) (eof-object? (char->integer x)))))
-
-(define (char=? x y)
-  (and (char? x) (char? y)
-       (eq? x y)))
-
-(define (char-alphabetic? x)
-  (and (char? x)
-       (let ((i (char->integer x)))
-        (or (and (>= i (char->integer #\A)) (<= i (char->integer #\Z)))
-            (and (>= i (char->integer #\a)) (<= i (char->integer #\z)))))))
-
-(define (char-numeric? x)
-  (and (char? x)
-       (let ((i (char->integer x)))
-         (and (>= i (char->integer #\0)) (<= i (char->integer #\9))))))
index c0b15284e2be2e08633fac0198daae64e320a065..81b51288ba513335e07ad2091acc013798827f5c 100644 (file)
@@ -20,6 +20,9 @@
 
 ;;; Commentary:
 
+;;; Implement core functionality that depends on implementation
+;;; specifics of Mes cell types.
+
 ;;; Code:
 
 (define <cell:char> 0)
 
 (define (boolean? x)
   (or (eq? x #f) (eq? x #t)))
+
+\f
+;;; core: accessors
+(define (string->list s)
+  (core:car s))
index 1bc16298bf235584b0f3756e915afa0cb45c4089..19469f29d6ffe063dfbcd95e9eabd6f20764c134 100644 (file)
--- a/string.c
+++ b/string.c
@@ -51,15 +51,6 @@ string_length (SCM x)
   return MAKE_NUMBER (VALUE (length (STRING (x))));
 }
 
-SCM
-string_ref (SCM x, SCM k)
-{
-  assert (TYPE (x) == STRING);
-  assert (TYPE (k) == NUMBER);
-  VALUE (tmp_num) = VALUE (k);
-  return MAKE_CHAR (VALUE (list_ref (STRING (x), tmp_num)));
-}
-
 SCM
 substring (SCM x) ///((arity . n))
 {