ikarus/scheme/ikarus.strings.ss

;;; Ikarus Scheme -- A compiler for R6RS Scheme.
;;; Copyright (C) 2006,2007,2008  Abdulaziz Ghuloum
;;; 
;;; This program is free software: you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License version 3 as
;;; published by the Free Software Foundation.
;;; 
;;; This program is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;;; General Public License for more details.
;;; 
;;; You should have received a copy of the GNU General Public License
;;; along with this program.  If not, see <http://www.gnu.org/licenses/>.


(library (ikarus strings)
  (export string-length string-ref string-set! make-string string->list
          string-append substring string list->string uuid
          string-copy string-for-each string-fill! 
          string=? string<? string<=? string>? string>=?
          string-copy!)
  (import 
    (ikarus system $strings)
    (ikarus system $fx)
    (ikarus system $chars)
    (ikarus system $bytevectors)
    (ikarus system $pairs)
    (except (ikarus) string-length string-ref string-set! make-string
            string->list string-append substring string
            list->string uuid string-copy string-for-each
            string=? string<? string<=? string>? string>=?
            string-fill! string-copy!))


  (define string-length
    (lambda (x)
      (unless (string? x)
        (die 'string-length "not a string" x))
      ($string-length x)))


  (define (string-ref s i)
    (unless (string? s) 
      (die 'string-ref "not a string" s))
    (unless (fixnum? i)
      (die 'string-ref "not a valid index" i))
    (unless (and ($fx< i ($string-length s))
                 ($fx<= 0 i))
      (die 'string-ref "index is out of range" i s))
    (let ([c ($string-ref s i)])
      (unless (char? c)
        (die 'string-ref "BUG: got a non-char"))
      c))
  

  (define string-set! 
    (lambda (s i c) 
      (unless (string? s) 
        (die 'string-set! "not a string" s))
      (unless (fixnum? i)
        (die 'string-set! "not a valid index" i))
      (unless (and ($fx< i ($string-length s))
                   ($fx>= i 0))
        (die 'string-set! "index is out of range" i s))
      (unless (char? c)
        (die 'string-set! "not a character" c))
      ($string-set! s i c)))
  
  (define make-string
    (let ()
      (define fill!
        (lambda (s i n c)
          (cond
            [($fx= i n) s]
            [else
             ($string-set! s i c)
             (fill! s ($fx+ i 1) n c)])))
      (define make-string
        (case-lambda
          [(n) 
           (unless (and (fixnum? n) (fx>= n 0))
             (die 'make-string "not a valid length" n))
           (fill! ($make-string n) 0 n (integer->char 0))]
          [(n c)
           (unless (and (fixnum? n) (fx>= n 0))
             (die 'make-string "not a valid length" n))
           (unless (char? c)
             (die 'make-string "not a character" c))
           (fill! ($make-string n) 0 n c)]))
        make-string))


  (define string
    ;;; FIXME: add case-lambda
    (letrec ([length
              (lambda (ls n)
                (cond
                 [(null? ls) n]
                 [(char? ($car ls)) (length ($cdr ls) ($fx+ n 1))]
                 [else (die 'string "not a character" ($car ls))]))]
             [loop 
              (lambda (s ls i n)
                (cond
                 [($fx= i n) s]
                 [else 
                  ($string-set! s i ($car ls))
                  (loop s ($cdr ls) ($fx+ i 1) n)]))])
       (lambda ls
         (let ([n (length ls 0)])
           (let ([s (make-string n)])
             (loop s ls 0 n))))))

  (module (substring)
    (define fill
      (lambda (s d si sj di)
        (cond
          [($fx= si sj) d]
          [else
           ($string-set! d di ($string-ref s si))
           (fill s d ($fxadd1 si) sj ($fxadd1 di))])))
    (define substring
       (lambda (s n m)
         (unless (string? s)
           (die 'substring "not a string" s))
         (let ([len ($string-length s)])
           (unless (and (fixnum? n)
                        ($fx>= n 0)
                        ($fx<= n len))
             (die 'substring "not a valid start index" n s))
           (unless (and (fixnum? m)
                        ($fx>= m 0)
                        ($fx<= m len))
             (die 'substring "not a valid end index" m s))
           (unless ($fx<= n m)
             (die 'substring "indices are in decreasing order" n m))
           (let ([len ($fx- m n)])
             (if ($fx> len 0)
                 (fill s ($make-string len) n m 0)
                 ""))))))

  (define string-copy 
    (lambda (s)
      (if (string? s)
          (substring s 0 (string-length s))
          (die 'string-copy "not a string" s))))
  
  (module (string=?)
    (define bstring=?
      (lambda (s1 s2 i j)
        (or ($fx= i j)
            (and ($char= ($string-ref s1 i) ($string-ref s2 i))
                 (bstring=? s1 s2 ($fxadd1 i) j)))))
    (define check-strings-and-return-false
      (lambda (s*)
        (cond
          [(null? s*) #f]
          [(string? ($car s*)) 
           (check-strings-and-return-false ($cdr s*))]
          [else (err ($car s*))])))
    (define strings=?
      (lambda (s s* n)
        (or (null? s*)
            (let ([a ($car s*)])
              (unless (string? a)
                (die 'string=? "not a string" a))
              (if ($fx= n ($string-length a))
                  (and (strings=? s ($cdr s*) n)
                       (bstring=? s a 0 n))
                  (check-strings-and-return-false ($cdr s*)))))))
    (define (err x)
      (die 'string=? "not a string" x))
    (define string=?
      (case-lambda
        [(s s1) 
         (if (string? s) 
             (if (string? s1)
                 (let ([n ($string-length s)])
                   (and ($fx= n ($string-length s1))
                        (bstring=? s s1 0 n)))
                 (err s1))
             (err s))]
        [(s . s*)
         (if (string? s)
             (strings=? s s* ($string-length s))
             (err s))])))


  (define string-cmp
    (lambda (who cmp s1 s*)
      (if (string? s1) 
          (let f ([s1 s1] [s* s*]) 
            (cond
              [(null? s*) #t]
              [else
               (let ([s2 (car s*)])
                 (if (string? s2) 
                     (if (cmp s1 s2) 
                         (f s2 (cdr s*))
                         (let f ([s* (cdr s*)])
                           (cond
                             [(null? s*) #f]
                             [(string? (car s*)) 
                              (f (cdr s*))]
                             [else 
                              (die who "not a string" 
                                (car s*))])))
                     (die who "not a string" s2)))]))
          (die who "not a string0" s1))))
  
  (define ($string<? s1 s2)
    (let ([n1 ($string-length s1)]
          [n2 ($string-length s2)])
      (if ($fx< n1 n2)
          (let f ([i 0] [n n1] [s1 s1] [s2 s2])
            (if ($fx= i n)
                #t
                (let ([c1 ($string-ref s1 i)]
                      [c2 ($string-ref s2 i)])
                  (if ($char< c1 c2) 
                      #t
                      (if ($char= c1 c2) 
                          (f ($fxadd1 i) n s1 s2)
                          #f)))))
          (let f ([i 0] [n n2] [s1 s1] [s2 s2])
            (if ($fx= i n)
                #f
                (let ([c1 ($string-ref s1 i)]
                      [c2 ($string-ref s2 i)])
                  (if ($char< c1 c2) 
                      #t
                      (if ($char= c1 c2) 
                          (f ($fxadd1 i) n s1 s2)
                          #f))))))))

  (define ($string<=? s1 s2)
    (let ([n1 ($string-length s1)]
          [n2 ($string-length s2)])
      (if ($fx<= n1 n2)
          (let f ([i 0] [n n1] [s1 s1] [s2 s2])
            (if ($fx= i n)
                #t
                (let ([c1 ($string-ref s1 i)]
                      [c2 ($string-ref s2 i)])
                  (if ($char< c1 c2)
                      #t
                      (if ($char= c1 c2) 
                          (f ($fxadd1 i) n s1 s2)
                          #f)))))
          (let f ([i 0] [n n2] [s1 s1] [s2 s2])
            (if ($fx= i n)
                #f
                (let ([c1 ($string-ref s1 i)]
                      [c2 ($string-ref s2 i)])
                  (if ($char< c1 c2) 
                      #t
                      (if ($char= c1 c2) 
                          (f ($fxadd1 i) n s1 s2)
                          #f))))))))

  (define ($string>? s1 s2) 
    ($string<? s2 s1))
  
  (define ($string>=? s1 s2) 
    ($string<=? s2 s1))

  (define string<?
    (case-lambda
      [(s1 s2) 
       (if (string? s1)
           (if (string? s2) 
               ($string<? s1 s2)
               (die 'string<? "not a string" s2))
           (die 'string<? "not a string" s2))]
      [(s . s*) 
       (string-cmp 'string<? $string<? s s*)]))

  (define string<=?
    (case-lambda
      [(s1 s2) 
       (if (string? s1)
           (if (string? s2) 
               ($string<=? s1 s2)
               (die 'string<=? "not a string" s2))
           (die 'string<=? "not a string" s2))]
      [(s . s*) 
       (string-cmp 'string<=? $string<=? s s*)]))

  (define string>?
    (case-lambda
      [(s1 s2) 
       (if (string? s1)
           (if (string? s2) 
               ($string>? s1 s2)
               (die 'string>? "not a string" s2))
           (die 'string>? "not a string" s2))]
      [(s . s*) 
       (string-cmp 'string>? $string>? s s*)]))

  (define string>=?
    (case-lambda
      [(s1 s2) 
       (if (string? s1)
           (if (string? s2) 
               ($string>=? s1 s2)
               (die 'string>=? "not a string" s2))
           (die 'string>=? "not a string" s2))]
      [(s . s*) 
       (string-cmp 'string>=? $string>=? s s*)]))

  (define string->list
    (lambda (x)
      (unless (string? x)
        (die 'string->list "not a string" x))
      (let f ([x x] [i ($string-length x)] [ac '()])
        (cond
          [($fxzero? i) ac]
          [else
           (let ([i ($fxsub1 i)])
             (f x i (cons ($string-ref x i) ac)))]))))


  (define list->string
    (letrec ([race
              (lambda (h t ls n)
               (if (pair? h)
                   (let ([h ($cdr h)])
                      (if (pair? h)
                          (if (not (eq? h t))
                              (race ($cdr h) ($cdr t) ls ($fx+ n 2))
                              (die 'reverse "circular list" ls))
                          (if (null? h)
                              ($fx+ n 1)
                              (die 'reverse "not a proper list" ls))))
                   (if (null? h)
                       n
                       (die 'reverse "not a proper list" ls))))]
              [fill
               (lambda (s i ls)
                 (cond
                   [(null? ls) s]
                   [else
                    (let ([c ($car ls)])
                      (unless (char? c)
                        (die 'list->string "not a character" c))
                      ($string-set! s i c)
                      (fill s ($fxadd1 i) (cdr ls)))]))])
       (lambda (ls)
         (let ([n (race ls ls ls 0)])
           (let ([s ($make-string n)])
             (fill s 0 ls))))))

  (module (string-append)
    ;; FIXME: make nonconsing on 0,1,2, and 3 args
    (define length*
      (lambda (s* n)
        (cond
          [(null? s*) n]
          [else
           (let ([a ($car s*)])
             (unless (string? a) 
               (die 'string-append "not a string" a))
             (length* ($cdr s*) ($fx+ n ($string-length a))))])))
    (define fill-string
      (lambda (s a si sj ai)
        (unless ($fx= si sj)
          ($string-set! s si ($string-ref a ai))
          (fill-string s a ($fxadd1 si) sj ($fxadd1 ai)))))
    (define fill-strings
      (lambda (s s* i)
        (cond
          [(null? s*) s]
          [else
           (let ([a ($car s*)])
             (let ([n ($string-length a)])
               (let ([j ($fx+ i n)])
                 (fill-string s a i j 0)
                 (fill-strings s ($cdr s*) j))))])))
    (define string-append
      (lambda s*
        (let ([n (length* s* 0)])
          (let ([s ($make-string n)])
            (fill-strings s s* 0))))))


  (module (string-for-each)
    (define who 'string-for-each)
    (define string-for-each
      (case-lambda
        [(p v) 
         (unless (procedure? p) 
           (die who "not a procedure" p))
         (unless (string? v) 
           (die who "not a string" v))
         (let f ([p p] [v v] [i 0] [n (string-length v)])
           (cond
             [($fx= i n) (void)]
             [else 
              (p (string-ref v i))
              (f p v ($fxadd1 i) n)]))]
        [(p v0 v1) 
         (unless (procedure? p) 
           (die who "not a procedure" p))
         (unless (string? v0) 
           (die who "not a string" v0))
         (unless (string? v1) 
           (die who "not a string" v1))
         (let ([n (string-length v0)])
           (unless ($fx= n ($string-length v1))
             (die who "length mismatch" v0 v1))
           (let f ([p p] [v0 v0] [v1 v1] [i 0] [n n])
             (cond
               [($fx= i n) (void)]
               [else 
                (p ($string-ref v0 i) ($string-ref v1 i))
                (f p v0 v1 ($fxadd1 i) n)])))]
        [(p v0 v1 . v*) 
         (unless (procedure? p) 
           (die who "not a procedure" p))
         (unless (string? v0) 
           (die who "not a string" v0))
         (unless (string? v1) 
           (die who "not a string" v1))
         (let ([n (string-length v0)])
           (unless ($fx= n ($string-length v1))
             (die who "length mismatch" v0 v1))
           (let f ([v* v*] [n n])
             (unless (null? v*) 
               (let ([a ($car v*)])
                 (unless (string? a) 
                   (die who "not a string" a))
                 (unless ($fx= ($string-length a) n) 
                   (die who "length mismatch")))
               (f ($cdr v*) n)))
           (let f ([p p] [v0 v0] [v1 v1] [v* v*] [i 0] [n n])
             (cond
               [($fx= i n) (void)] 
               [else 
                (apply p ($string-ref v0 i) ($string-ref v1 i)
                  (let f ([i i] [v* v*]) 
                    (if (null? v*) 
                        '()
                        (cons ($string-ref ($car v*) i) 
                              (f i ($cdr v*))))))
                (f p v0 v1 v* ($fxadd1 i) n)])))])))

  (define (string-fill! v fill)
    (unless (string? v) 
      (die 'string-fill! "not a vector" v))
    (unless (char? fill)
      (die 'string-fill! "not a character" fill))
    (let f ([v v] [i 0] [n ($string-length v)] [fill fill])
      (unless ($fx= i n) 
        ($string-set! v i fill)
        (f v ($fxadd1 i) n fill))))


  (define string-copy!
    (lambda (src src-start dst dst-start k) 
      (cond
        [(or (not (fixnum? src-start)) ($fx< src-start 0))
         (die 'string-copy! "not a valid starting index" src-start)]
        [(or (not (fixnum? dst-start)) ($fx< dst-start 0))
         (die 'string-copy! "not a valid starting index" dst-start)]
        [(or (not (fixnum? k)) ($fx< k 0))
         (die 'string-copy! "not a valid length" k)]
        [(not (string? src)) 
         (die 'string-copy! "not a string" src)]
        [(not (string? dst)) 
         (die 'string-copy! "not a string" dst)]
        [(let ([n ($fx+ src-start k)])
           (or ($fx< n 0) ($fx> n ($string-length src))))
         (die 'string-copy! "out of range" src-start k)]
        [(let ([n ($fx+ dst-start k)])
           (or ($fx< n 0) ($fx> n ($string-length dst))))
         (die 'string-copy! "out of range" dst-start k)]
        [(eq? src dst)
         (cond
           [($fx< dst-start src-start)
            (let f ([src src] [si src-start] [di dst-start] [sj ($fx+ src-start k)])
              (unless ($fx= si sj)
                ($string-set! src di ($string-ref src si))
                (f src ($fxadd1 si) ($fxadd1 di) sj)))]
           [($fx< src-start dst-start)
            (let f ([src src] [si ($fx+ src-start k)] [di ($fx+ dst-start k)] [sj src-start])
              (unless ($fx= si sj)
                (let ([si ($fxsub1 si)] [di ($fxsub1 di)])
                  ($string-set! src di ($string-ref src si))
                  (f src si di sj))))]
           [else (void)])]
        [else
         (let f ([src src] [si src-start] [dst dst] [di dst-start] [sj ($fx+ src-start k)])
           (unless ($fx= si sj)
             ($string-set! dst di ($string-ref src si))
             (f src ($fxadd1 si) dst ($fxadd1 di) sj)))])))

  (define uuid
    (lambda ()
      (let ([s ($make-bytevector 16)])
        (let ([r (foreign-call "ik_uuid" s)])
          (if (bytevector? r)
              (utf8->string r)
              (error 'uuid "cannot obtain unique id"))))))
  )