Import Debian changes 2c0-3debian/2c0-3

slib (2c0-3) unstable; urgency=low

  * New maintainer.
  * slibconfig script to automatically configure guile.
  * Fix type in description, closes: Bug#18996

slib (2c0-2) unstable; urgency=low

  * Minor fix for debian/rules targets

slib (2c0-1) unstable; urgency=low

  * New upstream source
  * New maintainer

1 files changed, 291 insertions, 162 deletions

diff --git a/chez.init b/chez.init
index a91cce3..b158304 100644
--- a/chez.init
+++ b/chez.init
@@ -1,6 +1,7 @@
-;"chez.init" Initialization file for SLIB for Chez Scheme	-*-scheme-*-
+;"chez.init" Initialization file for SLIB for Chez Scheme 5.0c	-*-scheme-*-
 ; Copyright (C) 1993 dorai@cs.rice.edu (Dorai Sitaram)
-; Copyright (C) 1991, 1992, 1993 Aubrey Jaffer.
+; Copyright (C) 1991, 1992, 1993, 1994, 1997 Aubrey Jaffer.
+; Adapted to version 5.0c by stone@math.grin.edu (John David Stone) 1997
 ;
 ;Permission to copy this software, to redistribute it, and to use it
 ;for any purpose is granted, subject to the following restrictions and
@@ -18,68 +19,180 @@
 ;promotional, or sales literature without prior written consent in
 ;each case.
 
-;;; (software-type) should be set to the generic operating system type.
-;;; UNIX, VMS, MACOS, AMIGA and MS-DOS are supported.
+;; The SOFTWARE-TYPE procedure returns a symbol indicating the generic
+;; operating system type.  UNIX, VMS, MACOS, AMIGA and MS-DOS are
+;; supported.
 
-(define (software-type) 'UNIX)
+(define software-type
+  (lambda () 'unix))
 
-(define (scheme-implementation-type) 'Chez)
+;; The SCHEME-IMPLEMENTATION-TYPE procedure returns a symbol denoting the
+;; Scheme implementation that loads this file.
 
-;;; (scheme-implementation-version) should return a string describing
-;;; the version the scheme implementation loading this file.
+(define scheme-implementation-type
+  (lambda () 'chez))
 
-(define (scheme-implementation-version) "?")
+;; The SCHEME-IMPLEMENTATION-VERSION procedure returns a string describing
+;; the version of the Scheme implementation that loads this file.
+
+(define scheme-implementation-version
+  (lambda () "5.0c"))
+
+;; The IMPLEMENTATION-VICINITY procedure returns a string giving the
+;; pathname of the directory that includes any auxiliary files used by this
+;; Scheme implementation.
 
 (define implementation-vicinity
-  (lambda () "/usr/local/lib/scheme/"))
+  (lambda () "/usr/local/chez/5.0c/"))
+
+;; The GETENV returns the value of a shell environment variable.
+
+;; In some implementations of Chez Scheme, this can be done with foreign
+;; procedures.  However, I [JDS] am using the HP version, which does not
+;; support them, so a different approach is needed.
+;;
+;; Here's the version that doesn't work on HPs:
+;;
+;; (provide-foreign-entries '("getenv"))
+;; 
+;; (define getenv
+;;   (foreign-procedure "getenv"
+;;     (string) string))
+;;
+;; And here's a version that parses the value out of the output of the
+;; /bin/env command:
+
+(define getenv
+  (lambda (env-var)
+    (let ((env-port (car (process "exec /bin/env")))
+          (read-line
+           (lambda (source)
+             (let ((next (peek-char source)))
+               (if (eof-object? next)
+                   next
+                   (let loop ((ch (read-char source))
+                              (so-far '()))
+                     (if (or (eof-object? ch)
+                             (char=? ch #\newline))
+                         (apply string (reverse so-far))
+                         (loop (read-char source) (cons ch so-far))))))))
+          (position-of-copula
+           (lambda (str)
+             (let ((len (string-length str)))
+               (do ((position 0 (+ position 1)))
+                   ((or (= position len)
+                        (char=? (string-ref str position) #\=))
+                    position))))))
+      (let loop ((equation (read-line env-port)))
+        (if (eof-object? equation)
+            #f
+            (let ((break (position-of-copula equation))
+                  (len (string-length equation)))
+              (if (string=? (substring equation 0 break) env-var)
+                  (if (= break len)
+                      ""
+                      (substring equation (+ break 1) len))
+                  (loop (read-line env-port)))))))))
+
+;; The LIBRARY-VICINITY procedure returns the pathname of the directory
+;; where Scheme library functions reside.
+
+(define library-vicinity
+  (let ((library-path (or (getenv "SCHEME_LIBRARY_PATH")
+			  "/usr/local/lib/slib/")))
+    (lambda () library-path)))
 
-;; library-vicinity is moved below the defination of getenv
+;;; (home-vicinity) should return the vicinity of the user's HOME
+;;; directory, the directory which typically contains files which
+;;; customize a computer environment for a user.
+
+(define home-vicinity
+  (let ((home-path (getenv "HOME")))
+    (lambda () home-path)))
+
+;; The OUTPUT-PORT-WIDTH procedure returns the number of graphic characters
+;; that can reliably be displayed on one line of the standard output port.
+
+(define output-port-width
+  (lambda arg
+    (let ((env-width-string (getenv "COLUMNS")))
+      (if (and env-width-string
+               (let loop ((remaining (string-length env-width-string)))
+                 (or (zero? remaining)
+                     (let ((next (- remaining 1)))
+                       (and (char-numeric? (string-ref env-width-string
+                                                       next))
+                            (loop next))))))
+          (- (string->number env-width-string) 1)
+          79))))
+
+;; The OUTPUT-PORT-HEIGHT procedure returns the number of lines of text
+;; that can reliably be displayed simultaneously in the standard output
+;; port.
+
+(define output-port-height
+  (lambda arg
+    (let ((env-height-string (getenv "LINES")))
+      (if (and env-height-string
+               (let loop ((remaining (string-length env-height-string)))
+                 (or (zero? remaining)
+                     (let ((next (- remaining 1)))
+                       (and (char-numeric? (string-ref env-height-string
+                                                       next))
+                            (loop next))))))
+          (string->number env-height-string)
+          24))))
+
+;; *FEATURES* is a list of symbols describing features of this
+;; implementation; SLIB procedures sometimes consult this list to figure
+;; out whether to attempt some incompletely standard operation.
 
 (define *features*
-  '(
-    source				;can load scheme source files
-					;(slib:load-source "filename")
-    compiled				;can load compiled files
-					;(slib:load-compiled "filename")
-    char-ready?
-    delay
-    dynamic-wind
-    fluid-let
-    format
-    full-continuation
-    getenv
-    ieee-p1178
-    macro
-    multiarg/and-
-    multiarg-apply
-    pretty-print
-    random
-    random-inexact
-    rationalize
-    rev3-procedures
-    rev3-report
-    rev4-optional-procedures
-    rev4-report
-    sort
-    system
-    transcript
-    with-file
-    string-port
-    ))
-
-;R4RS define-syntax in terms of Chez's extend-syntax.
-;Caveat: no let-syntax
-
-(extend-syntax (define-syntax syntax-rules)
-  ((define-syntax name (syntax-rules kwds . clauses))
-   (extend-syntax (name . kwds) . clauses)))
-
-;DEFINED?
-(define-syntax defined?
-  (syntax-rules ()
-    ((defined? x) (or (bound? 'x) (get 'x '*expander*)))))
-
-;Chez's sort routines have the opposite parameter order to Slib's
+  '(source    ; Chez Scheme can load Scheme source files, with the
+	      ;   command (slib:load-source "filename") -- see below.
+
+    compiled  ; Chez Scheme can also load compiled Scheme files, with the
+              ;   command (slib:load-compiled "filename") -- see below.
+
+    char-ready? delay dynamic-wind eval fluid-let format
+    full-continuation getenv ieee-p1178 macro multiarg/and-
+    multiarg-apply pretty-print random random-inexact rationalize
+    rev3-procedures rev3-report rev4-optional-procedures rev4-report
+    sort string-port system transcript values with-file))
+
+;; Version 5.0c has R4RS macros, but not defmacro.
+
+(define *defmacros*
+  (list (cons 'defmacro
+	      (lambda (name parms . body)
+		`(set! *defmacros* (cons (cons ',name (lambda ,parms ,@body))
+					 *defmacros*))))))
+(define (defmacro? m) (and (assq m *defmacros*) #t))
+
+(define (macroexpand-1 e)
+  (if (pair? e) (let ((a (car e)))
+		  (cond ((symbol? a) (set! a (assq a *defmacros*))
+				     (if a (apply (cdr a) (cdr e)) e))
+			(else e)))
+      e))
+
+(define (macroexpand e)
+  (if (pair? e) (let ((a (car e)))
+		  (cond ((symbol? a)
+			 (set! a (assq a *defmacros*))
+			 (if a (macroexpand (apply (cdr a) (cdr e))) e))
+			(else e)))
+      e))
+
+(define base:eval eval)
+(define (defmacro:eval x) (base:eval (defmacro:expand* x)))
+(define (defmacro:expand* x)
+  (require 'defmacroexpand) (apply defmacro:expand* x '()))
+
+;; Chez's sorting routines take parameters in the order opposite to SLIB's.
+;; The following definitions override the predefined procedures with the
+;; parameters-reversed versions.
+
 (define chez:sort sort)
 (define chez:sort! sort!)
 (define chez:merge merge)
@@ -98,82 +211,106 @@
   (lambda (s1 s2 p)
     (chez:merge! p s1 s2)))
 
-;RENAME-FILE
+;; Chez's (FORMAT F . A) corresponds to SLIB's (FORMAT #F F . A)
+
+(define chez:format format)
+
+(define format
+  (lambda (where how . args)
+    (let ((str (apply chez:format how args)))
+      (cond ((not where) str)
+	    ((eq? where #t) (display str))
+	    (else (display str where))))))
+
+;; Chez's NIL variable is bound to '(); SLIB's is bound to #F.
+
+(define nil #f)
+
+;; SLIB provides identifiers for the TAB (ASCII 9) and FORM-FEED (ASCII 12)
+;; characters.
+
+(define slib:tab #\tab)
+(define slib:form-feed #\page)
+
+;; The following definitions implement a few widely useful procedures that
+;; Chez Scheme does not provide or provides under a different name.
+
+;; The RENAME-FILE procedure constructs and executes a Unix mv command to
+;; change the name of a file.
+
 (define rename-file
   (lambda (src dst)
     (system (string-append "mv " src " " dst))))
 
-;OUTPUT-PORT-WIDTH
-(define output-port-width (lambda arg 79))
+;; The CURRENT-ERROR-PORT procedure returns a port to which error
+;; messages are to be displayed; this is the original standard output
+;; port (even if the program subsequently changes the current output port
+;; somehow).
 
-;;; (OUTPUT-PORT-HEIGHT <port>)
-(define (output-port-height . arg) 24)
-
-;;; (CURRENT-ERROR-PORT)
 (define current-error-port
   (let ((port (current-output-port)))
     (lambda () port)))
 
-;;; (TMPNAM) makes a temporary file name.
+;; SLIB provides its own version of the ERROR procedure.
+
+(define slib:error
+  (lambda args
+    (let ((port (current-error-port)))
+      (display "Error: " port)
+      (for-each (lambda (x) (display x port)) args)
+      (error #f ""))))
+
+;; The TMPNAM procedure constructs and returns a temporary file name,
+;; presumably unique and not a duplicate of one already existing.
+
 (define tmpnam
   (let ((cntr 100))
-    (lambda () (set! cntr (+ 1 cntr))
-	    (let ((tmp (string-append "slib_" (number->string cntr))))
-	      (if (file-exists? tmp) (tmpnam) tmp)))))
-
-;GETENV
-(provide-foreign-entries '("getenv"))
-(define getenv
-  (foreign-procedure "getenv"
-    (string) string))
+    (lambda ()
+      (set! cntr (+ 1 cntr))
+      (let ((tmp (string-append "slib_" (number->string cntr))))
+        (if (file-exists? tmp) (tmpnam) tmp)))))
 
-(define library-vicinity
-  (let ((library-path (or (getenv "SCHEME_LIBRARY_PATH")
-			  "/usr/local/lib/slib/")))
-    (lambda () library-path)))
+;; The FORCE-OUTPUT requires buffered output that has been written to a
+;; port to be transferred all the way out to its ultimate destination.
 
-;FORCE-OUTPUT
 (define force-output flush-output)
 
-;;; CALL-WITH-INPUT-STRING and CALL-WITH-OUTPUT-STRING are the string
-;;; port versions of CALL-WITH-*PUT-FILE.
-(define (call-with-output-string f)
-  (let ((outsp (open-output-string)))
-    (f outsp)
-    (let ((s (get-output-string outsp)))
-      (close-output-port outsp)
-      s)))
-
-(define (call-with-input-string s f)
-  (let* ((insp (open-input-string s))
-	 (res (f insp)))
-    (close-input-port insp)
-    res))
-
-;CHAR-CODE-LIMIT
-(define char-code-limit 256)
+;; CALL-WITH-INPUT-STRING and CALL-WITH-OUTPUT-STRING are the string
+;; port versions of CALL-WITH-INPUT-FILE and CALL-WITH-OUTPUT-FILE.
 
-;Chez's MOST-POSITIVE-FIXNUM is a thunk rather than a number
-(if (procedure? most-positive-fixnum)
-    (set! most-positive-fixnum (most-positive-fixnum)))
+(define call-with-output-string
+  (lambda (f)
+    (let ((outsp (open-output-string)))
+      (f outsp)
+      (let ((s (get-output-string outsp)))
+        (close-output-port outsp)
+        s))))
 
-;;; Return argument
-(define (identity x) x)
+(define call-with-input-string
+  (lambda (s f)
+    (let* ((insp (open-input-string s))
+           (res (f insp)))
+      (close-input-port insp)
+      res)))
 
-(define slib:eval eval)
+;; CHAR-CODE-LIMIT is the number of characters in the character set; only
+;; non-negative integers less than CHAR-CODE-LIMIT are eligible as
+;; arguments to INTEGER->CHAR.
+
+(define char-code-limit 256)
+
+;; Chez's MOST-POSITIVE-FIXNUM is a thunk rather than a number.
 
-(define-macro! defmacro z `(define-macro! ,@z))
+(if (procedure? most-positive-fixnum)
+    (set! most-positive-fixnum (most-positive-fixnum)))
 
-(define (defmacro? m) (get m '*expander*))
+;; The IDENTITY procedure returns its argument without change.
 
-(define macroexpand-1 eps-expand-once)
+(define identity 
+  (lambda (x) x))
 
-(define (macroexpand e)
-  (if (pair? e) (let ((a (car e)))
-		  (if (and (symbol? a) (getprop a '*expander*))
-		      (macroexpand (expand-once e))
-		      e))
-      e))
+;; The GENTEMP procedure generates unused symbols and marks them as
+;; belonging to the SLIB package.
 
 (define gentemp
   (let ((*gensym-counter* -1))
@@ -182,54 +319,45 @@
       (string->symbol
        (string-append "slib:G" (number->string *gensym-counter*))))))
 
-(define defmacro:eval slib:eval)
-(define macro:eval slib:eval)
-
-(define (slib:eval-load <pathname> evl)
-  (if (not (file-exists? <pathname>))
-      (set! <pathname> (string-append <pathname> (scheme-file-suffix))))
-  (call-with-input-file <pathname>
-    (lambda (port)
-      (let ((old-load-pathname *load-pathname*))
-	(set! *load-pathname* <pathname>)
-	(do ((o (read port) (read port)))
-	    ((eof-object? o))
-	  (evl o))
-	(set! *load-pathname* old-load-pathname)))))
-
-;Chez's (FORMAT f . a) corresponds to Slib's (FORMAT #f f . a)
+;; The IN-VICINITY procedure is simply STRING-APPEND, conventionally used
+;; to attach a directory pathname to the name of a file that is expected to
+;; be in that directory.
 
-(define chez:format format)
-(define format
-  (lambda (where how . args)
-    (let ((str (apply chez:format how args)))
-      (cond ((not where) str)
-	    ((eq? where #t) (display str))
-	    (else (display str where))))))
+(define in-vicinity string-append)
 
-(define slib:error
-  (lambda args
-    (let ((port (current-error-port)))
-      (display "Error: " port)
-      (for-each (lambda (x) (display x port)) args)
-      (error #f ""))))
+;; For backward compatability, the SCHEME-FILE-SUFFIX procedure is defined
+;; to return the string ".scm".  Note, however, that ".ss" is a common Chez
+;; file suffix.
 
-(define slib:tab #\tab)
-(define slib:form-feed #\page)
+(define scheme-file-suffix
+  (lambda () ".scm"))
 
-;Chez's nil variable is bound to '() rather than #f
+;; SLIB appropriates Chez Scheme's EVAL procedure.
 
-(define nil #f)
+(define slib:eval eval)
+(define macro:eval slib:eval)
 
-(define in-vicinity string-append)
+(define slib:eval-load
+  (lambda (<pathname> evl)
+    (if (not (file-exists? <pathname>))
+        (set! <pathname> (string-append <pathname> (scheme-file-suffix))))
+    (call-with-input-file <pathname>
+      (lambda (port)
+        (let ((old-load-pathname *load-pathname*))
+          (set! *load-pathname* <pathname>)
+          (do ((o (read port) (read port)))
+              ((eof-object? o))
+            (evl o))
+          (set! *load-pathname* old-load-pathname))))))
+
+;; SLIB:EXIT is the implementation procedure that exits, or returns
+;; if exiting is not supported.
 
-;;; Define SLIB:EXIT to be the implementation procedure to exit or
-;;; return if exitting not supported.
 (define slib:chez:quit
-  (let ([arg (call-with-current-continuation (lambda (x) x))])
-    (cond [(procedure? arg) arg]
-	  [arg (exit)]
-	  [else (exit 1)])))
+  (let ((arg (call-with-current-continuation identity)))
+    (cond ((procedure? arg) arg)
+	  (arg (exit))
+	  (else (exit 1)))))
 
 (define slib:exit
   (lambda args
@@ -239,28 +367,29 @@
 	  ((zero? (car args)) (slib:chez:quit #t))
 	  (else (slib:chez:quit #f)))))
 
-;;; Here for backward compatability
-;Note however that ".ss" is a common Chez file suffix
-(define (scheme-file-suffix) ".scm")
+;; The SLIB:LOAD-SOURCE procedure, given a string argument, should attach
+;; the appropriate file suffix to the string and load the file named
+;; by the resulting string.
 
-;;; (SLIB:LOAD-SOURCE "foo") should load "foo.scm" or with whatever
-;;; suffix all the module files in SLIB have.  See feature 'SOURCE.
+(define slib:load-source
+  (lambda (f)
+    (load (string-append f (scheme-file-suffix)))))
 
-(define (slib:load-source f) (load (string-append f (scheme-file-suffix))))
+;;; defmacro:load and macro:load also need the default suffix.
 
-;;; defmacro:load and macro:load also need the default suffix
-(define defmacro:load slib:load-source)
 (define macro:load slib:load-source)
 
-;;; (SLIB:LOAD-COMPILED "foo") should load the file that was produced
-;;; by compiling "foo.scm" if this implementation can compile files.
-;;; See feature 'COMPILED.
+;; The SLIB:LOAD-COMPILED procedure, given a string argument, finds and
+;; loads the file, assumed to have been compiled.
 
 (define slib:load-compiled load)
 
-;;; At this point SLIB:LOAD must be able to load SLIB files.
+;; SLIB:LOAD can now be defined to load SLIB files.
 
 (define slib:load slib:load-source)
 
+;; Load the REQUIRE package.
+
 (slib:load (in-vicinity (library-vicinity) "require"))
-;end chez.init
+
+;; end of chez.init