+2001-10-21 Mikael Djurfeldt <mdj@linnaeus>
+
+ * slib.scm (array-indexes): New procedure.
+ (*features*): Extend. (Probably some of these options should be
+ set elsewhere.) (Thanks to Aubrey Jaffer.)
+
+ * and-let-star-compat.scm, and-let-star.scm, calling.scm,
+ channel.scm, common-list.scm, debug.scm, debugger.scm,
+ expect.scm, hcons.scm, lineio.scm, ls.scm, mapping.scm,
+ null.scm, optargs.scm, poe.scm, popen.scm, pretty-print.scm,
+ q.scm, r5rs.scm, rdelim.scm, regex.scm, runq.scm, safe-r5rs.scm,
+ safe.scm, session.scm, slib.scm, streams.scm, string-fun.scm,
+ syncase.scm, threads.scm: Move module the system directives
+ `export', `export-syntax', `re-export' and `re-export-syntax'
+ into the `define-module' form. This is the recommended way of
+ exporting bindings.
+
2001-10-17 Mikael Djurfeldt <mdj@linnaeus>
* boot-9.scm (process-define-module): New options: :export-syntax,
;;;; whether to permit this exception to apply to your modifications.
;;;; If you do not wish that, delete this exception notice.
-(define-module (ice-9 and-let-star))
+(define-module (ice-9 and-let-star)
+ :export-syntax (and-let*))
(defmacro and-let* (vars . body)
(error "not a proper list" vars))))
(expand vars body))
-
-(export-syntax and-let*)
;;;; calling.scm --- Calling Conventions
;;;;
-;;;; Copyright (C) 1995, 1996, 1997, 2000 Free Software Foundation, Inc.
+;;;; Copyright (C) 1995, 1996, 1997, 2000, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; If you do not wish that, delete this exception notice.
;;;;
\f
-(define-module (ice-9 calling))
+(define-module (ice-9 calling)
+ :export-syntax (with-excursion-function
+ with-getter-and-setter
+ with-getter
+ with-delegating-getter-and-setter
+ with-excursion-getter-and-setter
+ with-configuration-getter-and-setter
+ with-delegating-configuration-getter-and-setter
+ let-with-configuration-getter-and-setter))
;;;;
;;;
;;; entering and leaving the call to proc non-locally, such as using
;;; call-with-current-continuation, error, or throw.
;;;
-(defmacro-public with-excursion-function (vars proc)
+(defmacro with-excursion-function (vars proc)
`(,proc ,(excursion-function-syntax vars)))
;;; ;; takes its arguments in a different order.
;;;
;;;
-(defmacro-public with-getter-and-setter (vars proc)
+(defmacro with-getter-and-setter (vars proc)
`(,proc ,@ (getter-and-setter-syntax vars)))
;;; with-getter vars proc
;;; The procedure is called:
;;; (proc getter)
;;;
-(defmacro-public with-getter (vars proc)
+(defmacro with-getter (vars proc)
`(,proc ,(car (getter-and-setter-syntax vars))))
;;; proc is a procedure that is called
;;; (proc getter setter)
;;;
-(defmacro-public with-delegating-getter-and-setter (vars get-delegate set-delegate proc)
+(defmacro with-delegating-getter-and-setter (vars get-delegate set-delegate proc)
`(,proc ,@ (delegating-getter-and-setter-syntax vars get-delegate set-delegate)))
;;; with-getter-and-setter
;;; with-excursion-function
;;;
-(defmacro-public with-excursion-getter-and-setter (vars proc)
+(defmacro with-excursion-getter-and-setter (vars proc)
`(,proc ,(excursion-function-syntax vars)
,@ (getter-and-setter-syntax vars)))
;;; for the corresponding variable. If omitted, the binding of <var>
;;; is simply set using set!.
;;;
-(defmacro-public with-configuration-getter-and-setter (vars-etc proc)
+(defmacro with-configuration-getter-and-setter (vars-etc proc)
`((lambda (simpler-get simpler-set body-proc)
(with-delegating-getter-and-setter ()
simpler-get simpler-set body-proc))
,proc))
-(defmacro-public with-delegating-configuration-getter-and-setter (vars-etc delegate-get delegate-set proc)
+(defmacro with-delegating-configuration-getter-and-setter (vars-etc delegate-get delegate-set proc)
`((lambda (simpler-get simpler-set body-proc)
(with-delegating-getter-and-setter ()
simpler-get simpler-set body-proc))
;;; ...)
;;; (with-configuration-getter-and-setter ((<var1> v1-get v1-set) ...) proc))
;;;
-(defmacro-public let-with-configuration-getter-and-setter (vars-etc proc)
+(defmacro let-with-configuration-getter-and-setter (vars-etc proc)
`(let ,(map (lambda (v) `(,(car v) ,(cadr v))) vars-etc)
(with-configuration-getter-and-setter ,(map (lambda (v) `(,(car v) ,(caddr v) ,(cadddr v))) vars-etc)
,proc)))
-
-
-
;;; Code:
-(define-module (ice-9 channel))
+(define-module (ice-9 channel)
+ :export (make-object-channel
+ channel-open
+ channel-print-value
+ channel-print-token))
;;;
;;; Channel type
(define make-channel (record-constructor channel-type))
-(define-public (make-object-channel printer)
+(define (make-object-channel printer)
(make-channel (current-input-port)
(current-output-port)
printer
;;; Channel
;;;
-(define-public (channel-open ch)
+(define (channel-open ch)
(let ((stdin (channel-stdin ch))
(stdout (channel-stdout ch))
(printer (channel-printer ch))
(list key (apply format #f (cadr args) (caddr args))))
(loop))))))))
-(define-public (channel-print-value ch val)
+(define (channel-print-value ch val)
(format (channel-stdout ch) "value = ~S\n" val))
-(define-public (channel-print-token ch val)
+(define (channel-print-token ch val)
(let* ((token (symbol-append (gensym "%%") '%%))
(pair (cons token (object->string val))))
(format (channel-stdout ch) "token = ~S\n" pair)
;;; Code:
\f
-(define-module (ice-9 common-list))
+(define-module (ice-9 common-list)
+ :export (adjoin union intersection set-difference reduce-init reduce
+ some every notany notevery count-if find-if member-if remove-if
+ remove-if-not delete-if! delete-if-not! butlast and? or?
+ has-duplicates? pick pick-mappings uniq))
;;"comlist.scm" Implementation of COMMON LISP list functions for Scheme
; Copyright (C) 1991, 1993, 1995 Aubrey Jaffer.
;promotional, or sales literature without prior written consent in
;each case.
-(define-public (adjoin e l)
+(define (adjoin e l)
"Return list L, possibly with element E added if it is not already in L."
(if (memq e l) l (cons e l)))
-(define-public (union l1 l2)
+(define (union l1 l2)
"Return a new list that is the union of L1 and L2.
Elements that occur in both lists occur only once in
the result list."
((null? l2) l1)
(else (union (cdr l1) (adjoin (car l1) l2)))))
-(define-public (intersection l1 l2)
+(define (intersection l1 l2)
"Return a new list that is the intersection of L1 and L2.
Only elements that occur in both lists occur in the result list."
(if (null? l2) l2
((memv (car l1) l2) (loop (cdr l1) (cons (car l1) result)))
(else (loop (cdr l1) result))))))
-(define-public (set-difference l1 l2)
+(define (set-difference l1 l2)
"Return elements from list L1 that are not in list L2."
(let loop ((l1 l1) (result '()))
(cond ((null? l1) (reverse! result))
((memv (car l1) l2) (loop (cdr l1) result))
(else (loop (cdr l1) (cons (car l1) result))))))
-(define-public (reduce-init p init l)
+(define (reduce-init p init l)
"Same as `reduce' except it implicitly inserts INIT at the start of L."
(if (null? l)
init
(reduce-init p (p init (car l)) (cdr l))))
-(define-public (reduce p l)
+(define (reduce p l)
"Combine all the elements of sequence L using a binary operation P.
The combination is left-associative. For example, using +, one can
add up all the elements. `reduce' allows you to apply a function which
((null? (cdr l)) (car l))
(else (reduce-init p (car l) (cdr l)))))
-(define-public (some pred l . rest)
+(define (some pred l . rest)
"PRED is a boolean function of as many arguments as there are list
arguments to `some', i.e., L plus any optional arguments. PRED is
applied to successive elements of the list arguments in order. As soon
(or (apply pred (car l) (map car rest))
(mapf (cdr l) (map cdr rest))))))))
-(define-public (every pred l . rest)
+(define (every pred l . rest)
"Return #t iff every application of PRED to L, etc., returns #t.
Analogous to `some' except it returns #t if every application of
PRED is #t and #f otherwise."
(and (apply pred (car l) (map car rest))
(mapf (cdr l) (map cdr rest))))))))
-(define-public (notany pred . ls)
+(define (notany pred . ls)
"Return #t iff every application of PRED to L, etc., returns #f.
Analogous to some but returns #t if no application of PRED returns a
true value or #f as soon as any one does."
(not (apply some pred ls)))
-(define-public (notevery pred . ls)
+(define (notevery pred . ls)
"Return #t iff there is an application of PRED to L, etc., that returns #f.
Analogous to some but returns #t as soon as an application of PRED returns #f,
or #f otherwise."
(not (apply every pred ls)))
-(define-public (count-if pred l)
+(define (count-if pred l)
"Return the number of elements in L for which (PRED element) returns true."
(let loop ((n 0) (l l))
(cond ((null? l) n)
((pred (car l)) (loop (+ n 1) (cdr l)))
(else (loop n (cdr l))))))
-(define-public (find-if pred l)
+(define (find-if pred l)
"Search for the first element in L for which (PRED element) returns true.
If found, return that element, otherwise return #f."
(cond ((null? l) #f)
((pred (car l)) (car l))
(else (find-if pred (cdr l)))))
-(define-public (member-if pred l)
+(define (member-if pred l)
"Return the first sublist of L for whose car PRED is true."
(cond ((null? l) #f)
((pred (car l)) l)
(else (member-if pred (cdr l)))))
-(define-public (remove-if pred l)
+(define (remove-if pred l)
"Remove all elements from L where (PRED element) is true.
Return everything that's left."
(let loop ((l l) (result '()))
((pred (car l)) (loop (cdr l) result))
(else (loop (cdr l) (cons (car l) result))))))
-(define-public (remove-if-not pred l)
+(define (remove-if-not pred l)
"Remove all elements from L where (PRED element) is #f.
Return everything that's left."
(let loop ((l l) (result '()))
((not (pred (car l))) (loop (cdr l) result))
(else (loop (cdr l) (cons (car l) result))))))
-(define-public (delete-if! pred l)
+(define (delete-if! pred l)
"Destructive version of `remove-if'."
(let delete-if ((l l))
(cond ((null? l) '())
(set-cdr! l (delete-if (cdr l)))
l))))
-(define-public (delete-if-not! pred l)
+(define (delete-if-not! pred l)
"Destructive version of `remove-if-not'."
(let delete-if-not ((l l))
(cond ((null? l) '())
(set-cdr! l (delete-if-not (cdr l)))
l))))
-(define-public (butlast lst n)
+(define (butlast lst n)
"Return all but the last N elements of LST."
(letrec ((l (- (length lst) n))
(bl (lambda (lst n)
(error "negative argument to butlast" n)
l))))
-(define-public (and? . args)
+(define (and? . args)
"Return #t iff all of ARGS are true."
(cond ((null? args) #t)
((car args) (apply and? (cdr args)))
(else #f)))
-(define-public (or? . args)
+(define (or? . args)
"Return #t iff any of ARGS is true."
(cond ((null? args) #f)
((car args) #t)
(else (apply or? (cdr args)))))
-(define-public (has-duplicates? lst)
+(define (has-duplicates? lst)
"Return #t iff 2 members of LST are equal?, else #f."
(cond ((null? lst) #f)
((member (car lst) (cdr lst)) #t)
(else (has-duplicates? (cdr lst)))))
-(define-public (pick p l)
+(define (pick p l)
"Apply P to each element of L, returning a list of elts
for which P returns a non-#f value."
(let loop ((s '())
((p (car l)) (loop (cons (car l) s) (cdr l)))
(else (loop s (cdr l))))))
-(define-public (pick-mappings p l)
+(define (pick-mappings p l)
"Apply P to each element of L, returning a list of the
non-#f return values of P."
(let loop ((s '())
((p (car l)) => (lambda (mapping) (loop (cons mapping s) (cdr l))))
(else (loop s (cdr l))))))
-(define-public (uniq l)
+(define (uniq l)
"Return a list containing elements of L, with duplicates removed."
(let loop ((acc '())
(l l))
;;;;
\f
-(define-module (ice-9 debug))
+(define-module (ice-9 debug)
+ :export (frame-number->index trace untrace trace-stack untrace-stack))
\f
;;; {Misc}
;;;
-(define-public (frame-number->index n . stack)
+(define (frame-number->index n . stack)
(let ((stack (if (null? stack)
(fluid-ref the-last-stack)
(car stack))))
;;;
(define traced-procedures '())
-(define-public (trace . args)
+(define (trace . args)
(if (null? args)
(nameify traced-procedures)
(begin
(debug-enable 'trace)
(nameify args))))
-(define-public (untrace . args)
+(define (untrace . args)
(if (and (null? args)
(not (null? traced-procedures)))
(apply untrace traced-procedures)
(define traced-stack-ids (list 'repl-stack))
(define trace-all-stacks? #f)
-(define-public (trace-stack id)
+(define (trace-stack id)
"Add ID to the set of stack ids for which tracing is active.
If `#t' is in this set, tracing is active regardless of stack context.
To remove ID again, use `untrace-stack'. If you add the same ID twice
(set! traced-stack-ids (cons id traced-stack-ids))
(set! trace-all-stacks? (memq #t traced-stack-ids)))
-(define-public (untrace-stack id)
+(define (untrace-stack id)
"Remove ID from the set of stack ids for which tracing is active."
(set! traced-stack-ids (delq1! id traced-stack-ids))
(set! trace-all-stacks? (memq #t traced-stack-ids)))
(define-module (ice-9 debugger)
:use-module (ice-9 debug)
:use-module (ice-9 format)
+ :export (debug)
:no-backtrace
)
\f
(define debugger-prompt "debug> ")
-(define-public (debug)
+(define (debug)
(let ((stack (fluid-ref the-last-stack)))
(if stack
(let ((state (make-state stack 0)))
;;; Code:
(define-module (ice-9 expect)
- :use-module (ice-9 regex))
+ :use-module (ice-9 regex)
+ :export-syntax (expect expect-strings)
+ :export (expect-port expect-timeout expect-timeout-proc
+ expect-eof-proc expect-char-proc expect-strings-compile-flags
+ expect-strings-exec-flags expect-select expect-regexec))
;;; Expect: a macro for selecting actions based on what it reads from a port.
;;; The idea is from Don Libes' expect based on Tcl.
;;; This version by Gary Houston incorporating ideas from Aubrey Jaffer.
\f
-(define-public expect-port #f)
-(define-public expect-timeout #f)
-(define-public expect-timeout-proc #f)
-(define-public expect-eof-proc #f)
-(define-public expect-char-proc #f)
+(define expect-port #f)
+(define expect-timeout #f)
+(define expect-timeout-proc #f)
+(define expect-eof-proc #f)
+(define expect-char-proc #f)
;;; expect: each test is a procedure which is applied to the accumulating
;;; string.
-(defmacro-public expect clauses
+(defmacro expect clauses
(let ((s (gensym))
(c (gensym))
(port (gensym))
(next-char)))))))))))
-(define-public expect-strings-compile-flags regexp/newline)
-(define-public expect-strings-exec-flags regexp/noteol)
+(define expect-strings-compile-flags regexp/newline)
+(define expect-strings-exec-flags regexp/noteol)
;;; the regexec front-end to expect:
;;; each test must evaluate to a regular expression.
-(defmacro-public expect-strings clauses
+(defmacro expect-strings clauses
`(let ,@(let next-test ((tests (map car clauses))
(exprs (map cdr clauses))
(defs '())
;;; simplified select: returns #t if input is waiting or #f if timed out or
;;; select was interrupted by a signal.
;;; timeout is an absolute time in floating point seconds.
-(define-public (expect-select port timeout)
+(define (expect-select port timeout)
(let* ((secs-usecs (gettimeofday))
(relative (- timeout
(car secs-usecs)
;;; match a string against a regexp, returning a list of strings (required
;;; by the => syntax) or #f. called once each time a character is added
;;; to s (eof? will be #f), and once when eof is reached (with eof? #t).
-(define-public (expect-regexec rx s eof?)
+(define (expect-regexec rx s eof?)
;; if expect-strings-exec-flags contains regexp/noteol,
;; remove it for the eof test.
(let* ((flags (if (and eof?
;;; installed-scm-file
-;;;; Copyright (C) 1995, 1996, 1998 Free Software Foundation, Inc.
+;;;; Copyright (C) 1995, 1996, 1998, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;;
\f
-(define-module (ice-9 hcons))
+(define-module (ice-9 hcons)
+ :export (hashq-cons-hash hashq-cons-assoc hashq-cons-get-handle
+ hashq-cons-create-handle! hashq-cons-ref hashq-cons-set! hashq-cons
+ hashq-conser make-gc-buffer))
\f
;;; {Eq? hash-consing}
;;; A hash conser does not contribute life to the pairs it returns.
;;;
-(define-public (hashq-cons-hash pair n)
+(define (hashq-cons-hash pair n)
(modulo (logxor (hashq (car pair) 4194303)
(hashq (cdr pair) 4194303))
n))
-(define-public (hashq-cons-assoc key l)
+(define (hashq-cons-assoc key l)
(and (not (null? l))
(or (and (pair? l) ; If not a pair, use its cdr?
(pair? (car l))
(car l))
(hashq-cons-assoc key (cdr l)))))
-(define-public (hashq-cons-get-handle table key)
+(define (hashq-cons-get-handle table key)
(hashx-get-handle hashq-cons-hash hashq-cons-assoc table key #f))
-(define-public (hashq-cons-create-handle! table key init)
+(define (hashq-cons-create-handle! table key init)
(hashx-create-handle! hashq-cons-hash hashq-cons-assoc table key init))
-(define-public (hashq-cons-ref table key)
+(define (hashq-cons-ref table key)
(hashx-ref hashq-cons-hash hashq-cons-assoc table key #f))
-(define-public (hashq-cons-set! table key val)
+(define (hashq-cons-set! table key val)
(hashx-set! hashq-cons-hash hashq-cons-assoc table key val))
-(define-public (hashq-cons table a d)
+(define (hashq-cons table a d)
(car (hashq-cons-create-handle! table (cons a d) #f)))
-(define-public (hashq-conser hash-tab-or-size)
+(define (hashq-conser hash-tab-or-size)
(let ((table (if (vector? hash-tab-or-size)
hash-tab-or-size
(make-doubly-weak-hash-table hash-tab-or-size))))
\f
-(define-public (make-gc-buffer n)
+(define (make-gc-buffer n)
(let ((ring (make-list n #f)))
(append! ring ring)
(lambda (next)
\f
(define-module (ice-9 lineio)
- :use-module (ice-9 readline))
+ :use-module (ice-9 readline)
+ :export (unread-string read-string lineio-port?
+ make-line-buffering-input-port))
\f
;;; {Line Buffering Input Ports}
;; 'unread-string and 'read-string properties, bound to hooks
;; implementing these functions.
;;
-(define-public (unread-string str line-buffering-input-port)
+(define (unread-string str line-buffering-input-port)
((object-property line-buffering-input-port 'unread-string) str))
;;
-(define-public (read-string line-buffering-input-port)
+(define (read-string line-buffering-input-port)
((object-property line-buffering-input-port 'read-string)))
-(define-public (lineio-port? port)
+(define (lineio-port? port)
(not (not (object-property port 'read-string))))
;; make-line-buffering-input-port port
;; to read-char, read-string, and unread-string.
;;
-(define-public (make-line-buffering-input-port underlying-port)
+(define (make-line-buffering-input-port underlying-port)
(let* (;; buffers - a list of strings put back by unread-string or cached
;; using read-line.
;;
;;;; ls.scm --- functions for browsing modules
;;;;
-;;;; Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
+;;;; Copyright (C) 1995, 1996, 1997, 1999, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;;
\f
(define-module (ice-9 ls)
- :use-module (ice-9 common-list))
+ :use-module (ice-9 common-list)
+ :export (local-definitions-in definitions-in ls lls
+ recursive-local-define))
;;;;
;;; local-definitions-in root name
;;;
;;; Analogous to `ls', but with local definitions only.
-(define-public (local-definitions-in root names)
+(define (local-definitions-in root names)
(let ((m (nested-ref root names))
(answer '()))
(if (not (module? m))
(module-for-each (lambda (k v) (set! answer (cons k answer))) m))
answer))
-(define-public (definitions-in root names)
+(define (definitions-in root names)
(let ((m (nested-ref root names)))
(if (not (module? m))
m
(map (lambda (m2) (definitions-in m2 '()))
(module-uses m)))))))
-(define-public (ls . various-refs)
+(define (ls . various-refs)
(if (pair? various-refs)
(if (cdr various-refs)
(map (lambda (ref)
(definitions-in (current-module) (car various-refs)))
(definitions-in (current-module) '())))
-(define-public (lls . various-refs)
+(define (lls . various-refs)
(if (pair? various-refs)
(if (cdr various-refs)
(map (lambda (ref)
(local-definitions-in (current-module) (car various-refs)))
(local-definitions-in (current-module) '())))
-(define-public (recursive-local-define name value)
+(define (recursive-local-define name value)
(let ((parent (reverse! (cdr (reverse name)))))
(and parent (make-modules-in (current-module) parent))
(local-define name value)))
;;; installed-scm-file
-;;;; Copyright (C) 1996 Free Software Foundation, Inc.
+;;;; Copyright (C) 1996, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
\f
(define-module (ice-9 mapping)
- :use-module (ice-9 poe))
-
-(define-public mapping-hooks-type (make-record-type 'mapping-hooks '(get-handle
- create-handle
- remove)))
-
-
-(define-public make-mapping-hooks (perfect-funcq 17 (record-constructor mapping-hooks-type)))
-(define-public mapping-hooks? (record-predicate mapping-hooks-type))
-(define-public mapping-hooks-get-handle (record-accessor mapping-hooks-type 'get-handle))
-(define-public mapping-hooks-create-handle (record-accessor mapping-hooks-type 'create-handle))
-(define-public mapping-hooks-remove (record-accessor mapping-hooks-type 'remove))
-
-(define-public mapping-type (make-record-type 'mapping '(hooks data)))
-(define-public make-mapping (record-constructor mapping-type))
-(define-public mapping? (record-predicate mapping-type))
-(define-public mapping-hooks (record-accessor mapping-type 'hooks))
-(define-public mapping-data (record-accessor mapping-type 'data))
-(define-public set-mapping-hooks! (record-modifier mapping-type 'hooks))
-(define-public set-mapping-data! (record-modifier mapping-type 'data))
-
-(define-public (mapping-get-handle map key)
+ :use-module (ice-9 poe)
+ :export (mapping-hooks-type make-mapping-hooks mapping-hooks?
+ mapping-hooks-get-handle mapping-hooks-create-handle
+ mapping-hooks-remove mapping-type make-mapping mapping?
+ mapping-hooks mapping-data set-mapping-hooks! set-mapping-data!
+ mapping-get-handle mapping-create-handle! mapping-remove!
+ mapping-ref mapping-set! hash-table-mapping-hooks
+ make-hash-table-mapping hash-table-mapping))
+
+(define mapping-hooks-type (make-record-type 'mapping-hooks '(get-handle
+ create-handle
+ remove)))
+
+
+(define make-mapping-hooks (perfect-funcq 17 (record-constructor mapping-hooks-type)))
+(define mapping-hooks? (record-predicate mapping-hooks-type))
+(define mapping-hooks-get-handle (record-accessor mapping-hooks-type 'get-handle))
+(define mapping-hooks-create-handle (record-accessor mapping-hooks-type 'create-handle))
+(define mapping-hooks-remove (record-accessor mapping-hooks-type 'remove))
+
+(define mapping-type (make-record-type 'mapping '(hooks data)))
+(define make-mapping (record-constructor mapping-type))
+(define mapping? (record-predicate mapping-type))
+(define mapping-hooks (record-accessor mapping-type 'hooks))
+(define mapping-data (record-accessor mapping-type 'data))
+(define set-mapping-hooks! (record-modifier mapping-type 'hooks))
+(define set-mapping-data! (record-modifier mapping-type 'data))
+
+(define (mapping-get-handle map key)
((mapping-hooks-get-handle (mapping-hooks map)) map key))
-(define-public (mapping-create-handle! map key . opts)
+(define (mapping-create-handle! map key . opts)
(apply (mapping-hooks-create-handle (mapping-hooks map)) map key opts))
-(define-public (mapping-remove! map key)
+(define (mapping-remove! map key)
((mapping-hooks-remove (mapping-hooks map)) map key))
-(define-public (mapping-ref map key . dflt)
+(define (mapping-ref map key . dflt)
(cond
((mapping-get-handle map key) => cdr)
(dflt => car)
(else #f)))
-(define-public (mapping-set! map key val)
+(define (mapping-set! map key val)
(set-cdr! (mapping-create-handle! map key #f) val))
\f
-(define-public hash-table-mapping-hooks
+(define hash-table-mapping-hooks
(let ((wrap (lambda (proc) (lambda (1st . rest) (apply proc (mapping-data 1st) rest)))))
(perfect-funcq 17
(lambda (table key)
(hashx-get-handle hash-proc assoc-proc delete-proc table key)))))))))))
-(define-public (make-hash-table-mapping table hash-proc assoc-proc delete-proc)
+(define (make-hash-table-mapping table hash-proc assoc-proc delete-proc)
(make-mapping (hash-table-mapping-hooks hash-proc assoc-proc delete-proc) table))
-(define-public (hash-table-mapping . options)
+(define (hash-table-mapping . options)
(let* ((size (or (and options (number? (car options)) (car options))
71))
(hash-proc (or (kw-arg-ref options :hash-proc) hash))
;;;; The null environment - only syntactic bindings
(define-module (ice-9 null)
- :use-module (ice-9 syncase))
-
-(re-export define quote lambda if set!
+ :use-module (ice-9 syncase)
+ :re-export-syntax (define quote lambda if set!
- cond case and or
-
- let let* letrec
+ cond case and or
+
+ let let* letrec
- begin do
+ begin do
- delay
+ delay
- quasiquote
+ quasiquote
- define-syntax
- let-syntax letrec-syntax)
+ define-syntax
+ let-syntax letrec-syntax))
;;; Code:
-(define-module (ice-9 optargs))
+(define-module (ice-9 optargs)
+ :export-syntax (let-optional
+ let-optional*
+ let-keywords
+ let-keywords*
+ define* lambda*
+ define*-public
+ defmacro*
+ defmacro*-public))
;; let-optional rest-arg (binding ...) . body
;; let-optional* rest-arg (binding ...) . body
;; bound to whatever may have been left of rest-arg.
;;
-(defmacro-public let-optional (REST-ARG BINDINGS . BODY)
+(defmacro let-optional (REST-ARG BINDINGS . BODY)
(let-optional-template REST-ARG BINDINGS BODY 'let))
-(defmacro-public let-optional* (REST-ARG BINDINGS . BODY)
+(defmacro let-optional* (REST-ARG BINDINGS . BODY)
(let-optional-template REST-ARG BINDINGS BODY 'let*))
;;
-(defmacro-public let-keywords (REST-ARG ALLOW-OTHER-KEYS? BINDINGS . BODY)
+(defmacro let-keywords (REST-ARG ALLOW-OTHER-KEYS? BINDINGS . BODY)
(let-keywords-template REST-ARG ALLOW-OTHER-KEYS? BINDINGS BODY 'let))
-(defmacro-public let-keywords* (REST-ARG ALLOW-OTHER-KEYS? BINDINGS . BODY)
+(defmacro let-keywords* (REST-ARG ALLOW-OTHER-KEYS? BINDINGS . BODY)
(let-keywords-template REST-ARG ALLOW-OTHER-KEYS? BINDINGS BODY 'let*))
;; Lisp dialects.
-(defmacro-public lambda* (ARGLIST . BODY)
+(defmacro lambda* (ARGLIST . BODY)
(parse-arglist
ARGLIST
(lambda (non-optional-args optionals keys aok? rest-arg)
;; Of course, define*[-public] also supports #:rest and #:allow-other-keys
;; in the same way as lambda*.
-(defmacro-public define* (ARGLIST . BODY)
+(defmacro define* (ARGLIST . BODY)
(define*-guts 'define ARGLIST BODY))
-(defmacro-public define*-public (ARGLIST . BODY)
+(defmacro define*-public (ARGLIST . BODY)
(define*-guts 'define-public ARGLIST BODY))
;; The guts of define* and define*-public.
;; semantics. Here is an example of a macro with an optional argument:
;; (defmacro* transmorgify (a #:optional b)
-(defmacro-public defmacro* (NAME ARGLIST . BODY)
+(defmacro defmacro* (NAME ARGLIST . BODY)
(defmacro*-guts 'define NAME ARGLIST BODY))
-(defmacro-public defmacro*-public (NAME ARGLIST . BODY)
+(defmacro defmacro*-public (NAME ARGLIST . BODY)
(defmacro*-guts 'define-public NAME ARGLIST BODY))
;; The guts of defmacro* and defmacro*-public
;;; installed-scm-file
-;;;; Copyright (C) 1996 Free Software Foundation, Inc.
+;;;; Copyright (C) 1996, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
\f
(define-module (ice-9 poe)
- :use-module (ice-9 hcons))
+ :use-module (ice-9 hcons)
+ :export (pure-funcq perfect-funcq))
\f
-(define-public (pure-funcq base-func)
+(define (pure-funcq base-func)
(lambda args
(let ((cached (hashx-get-handle funcq-hash funcq-assoc funcq-memo (cons base-func args))))
(if cached
;;; funcq never does.
;;;
-(define-public (perfect-funcq size base-func)
+(define (perfect-funcq size base-func)
(define funcq-memo (make-hash-table size))
(lambda args
;; popen emulation, for non-stdio based ports.
-;;;; Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+;;;; Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; If you do not wish that, delete this exception notice.
;;;;
-(define-module (ice-9 popen))
+(define-module (ice-9 popen)
+ :export (port/pid-table open-pipe close-pipe open-input-pipe
+ open-output-pipe))
;; (define-module (guile popen)
;; :use-module (guile posix))
(define pipe-guardian (make-guardian))
;; a weak hash-table to store the process ids.
-(define-public port/pid-table (make-weak-key-hash-table 31))
+(define port/pid-table (make-weak-key-hash-table 31))
(define (ensure-fdes port mode)
(or (false-if-exception (fileno port))
(cdr p))
pid))))))
-(define-public (open-pipe command mode)
+(define (open-pipe command mode)
"Executes the shell command @var{command} (a string) in a subprocess.
A pipe to the process is created and returned. @var{modes} specifies
whether an input or output pipe to the process is created: it should
(car port/pid) (cdr port/pid))))))
(lambda args #f)))
-(define-public (close-pipe p)
+(define (close-pipe p)
"Closes the pipe created by @code{open-pipe}, then waits for the process
to terminate and returns its status value, @xref{Processes, waitpid}, for
information on how to interpret this value."
(add-hook! after-gc-hook reap-pipes)
-(define-public (open-input-pipe command)
+(define (open-input-pipe command)
"Equivalent to @code{open-pipe} with mode @code{OPEN_READ}"
(open-pipe command OPEN_READ))
-(define-public (open-output-pipe command)
+(define (open-output-pipe command)
"Equivalent to @code{open-pipe} with mode @code{OPEN_WRITE}"
(open-pipe command OPEN_WRITE))
;;;; whether to permit this exception to apply to your modifications.
;;;; If you do not wish that, delete this exception notice.
;;;;
-(define-module (ice-9 pretty-print))
-
-(export pretty-print)
+(define-module (ice-9 pretty-print)
+ :export (pretty-print))
;; From SLIB.
;;; Code:
-(define-module (ice-9 q))
+(define-module (ice-9 q)
+ :export (sync-q! make-q q? q-empty? q-empty-check q-front q-rear
+ q-remove! q-push! enq! q-pop! deq! q-length))
;;; sync-q!
;;; The procedure
;;;
;;; recomputes and resets the <last-pair> component of a queue.
;;;
-(define-public (sync-q! q)
+(define (sync-q! q)
(set-cdr! q (if (pair? (car q)) (last-pair (car q))
#f))
q)
;;; make-q
;;; return a new q.
;;;
-(define-public (make-q) (cons '() #f))
+(define (make-q) (cons '() #f))
;;; q? obj
;;; Return true if obj is a Q.
;;; or it is a pair P with (list? (car P))
;;; and (eq? (cdr P) (last-pair (car P))).
;;;
-(define-public (q? obj)
+(define (q? obj)
(and (pair? obj)
(if (pair? (car obj))
(eq? (cdr obj) (last-pair (car obj)))
;;; q-empty? obj
;;;
-(define-public (q-empty? obj) (null? (car obj)))
+(define (q-empty? obj) (null? (car obj)))
;;; q-empty-check q
;;; Throw a q-empty exception if Q is empty.
-(define-public (q-empty-check q) (if (q-empty? q) (throw 'q-empty q)))
+(define (q-empty-check q) (if (q-empty? q) (throw 'q-empty q)))
;;; q-front q
;;; Return the first element of Q.
-(define-public (q-front q) (q-empty-check q) (caar q))
+(define (q-front q) (q-empty-check q) (caar q))
;;; q-rear q
;;; Return the last element of Q.
-(define-public (q-rear q) (q-empty-check q) (cadr q))
+(define (q-rear q) (q-empty-check q) (cadr q))
;;; q-remove! q obj
;;; Remove all occurences of obj from Q.
-(define-public (q-remove! q obj)
+(define (q-remove! q obj)
(set-car! q (delq! obj (car q)))
(sync-q! q))
;;; q-push! q obj
;;; Add obj to the front of Q
-(define-public (q-push! q obj)
+(define (q-push! q obj)
(let ((h (cons obj (car q))))
(set-car! q h)
(or (cdr q) (set-cdr! q h)))
;;; enq! q obj
;;; Add obj to the rear of Q
-(define-public (enq! q obj)
+(define (enq! q obj)
(let ((h (cons obj '())))
(if (null? (car q))
(set-car! q h)
;;; q-pop! q
;;; Take the front of Q and return it.
-(define-public (q-pop! q)
+(define (q-pop! q)
(q-empty-check q)
(let ((it (caar q))
(next (cdar q)))
;;; deq! q
;;; Take the front of Q and return it.
-(define-public deq! q-pop!)
+(define deq! q-pop!)
;;; q-length q
;;; Return the number of enqueued elements.
;;;
-(define-public (q-length q) (length (car q)))
+(define (q-length q) (length (car q)))
;;; q.scm ends here
\f
;;;; R5RS bindings
-(define-module (ice-9 r5rs))
-
-(module-use! %module-public-interface (resolve-interface '(ice-9 safe-r5rs)))
-
-(export scheme-report-environment
- ;;transcript-on
- ;;transcript-off
- )
+(define-module (ice-9 r5rs)
+ :export (scheme-report-environment
+ ;;transcript-on
+ ;;transcript-off
+ )
+ :re-export (interaction-environment
-(re-export interaction-environment
+ call-with-input-file call-with-output-file
+ with-input-from-file with-output-to-file
+ open-input-file open-output-file
+ close-input-port close-output-port
- call-with-input-file call-with-output-file
- with-input-from-file with-output-to-file
- open-input-file open-output-file
- close-input-port close-output-port
+ load))
- load
- )
+(module-use! %module-public-interface (resolve-interface '(ice-9 safe-r5rs)))
(define scheme-report-interface %module-public-interface)
;;; This is the Scheme part of the module for delimited I/O. It's
;;; similar to (scsh rdelim) but somewhat incompatible.
-(define-module (ice-9 rdelim))
+(define-module (ice-9 rdelim)
+ :export (read-line read-line! read-delimited read-delimited!
+ %read-delimited! %read-line write-line) ; C
+ )
(%init-rdelim-builtins)
-(export read-line read-line! read-delimited read-delimited!)
-(export %read-delimited! %read-line write-line) ; C
-
(define (read-line! string . maybe-port)
;; corresponds to SCM_LINE_INCREMENTORS in libguile.
(define scm-line-incrementors "\n")
-;;;; Copyright (C) 1997, 1999 Free Software Foundation, Inc.
+;;;; Copyright (C) 1997, 1999, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
\f
;;;; POSIX regex support functions.
-(define-module (ice-9 regex))
+(define-module (ice-9 regex)
+ :export (match:count match:string match:prefix match:suffix
+ regexp-match? regexp-quote match:start match:end match:substring
+ string-match regexp-substitute fold-matches list-matches
+ regexp-substitute/global))
;;; FIXME:
;;; It is not clear what should happen if a `match' function
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; These procedures are not defined in SCSH, but I found them useful.
-(define-public (match:count match)
+(define (match:count match)
(- (vector-length match) 1))
-(define-public (match:string match)
+(define (match:string match)
(vector-ref match 0))
-(define-public (match:prefix match)
+(define (match:prefix match)
(substring (match:string match) 0 (match:start match 0)))
-(define-public (match:suffix match)
+(define (match:suffix match)
(substring (match:string match) (match:end match 0)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;; SCSH compatibility routines.
-(define-public (regexp-match? match)
+(define (regexp-match? match)
(and (vector? match)
(string? (vector-ref match 0))
(let loop ((i 1))
(loop (+ 1 i)))
(else #f)))))
-(define-public (regexp-quote regexp)
+(define (regexp-quote regexp)
(call-with-output-string
(lambda (p)
(let loop ((i 0))
(write-char (string-ref regexp i) p)
(loop (1+ i))))))))
-(define-public (match:start match . args)
+(define (match:start match . args)
(let* ((matchnum (if (pair? args)
(+ 1 (car args))
1))
(start (car (vector-ref match matchnum))))
(if (= start -1) #f start)))
-(define-public (match:end match . args)
+(define (match:end match . args)
(let* ((matchnum (if (pair? args)
(+ 1 (car args))
1))
(end (cdr (vector-ref match matchnum))))
(if (= end -1) #f end)))
-(define-public (match:substring match . args)
+(define (match:substring match . args)
(let* ((matchnum (if (pair? args)
(car args)
0))
(end (match:end match matchnum)))
(and start end (substring (match:string match) start end))))
-(define-public (string-match pattern str . args)
+(define (string-match pattern str . args)
(let ((rx (make-regexp pattern))
(start (if (pair? args) (car args) 0)))
(regexp-exec rx str start)))
-(define-public (regexp-substitute port match . items)
+(define (regexp-substitute port match . items)
;; If `port' is #f, send output to a string.
(if (not port)
(call-with-output-string
;;; `b'. Around or within `xxx', only the match covering all three
;;; x's counts, because the rest are not maximal.
-(define-public (fold-matches regexp string init proc . flags)
+(define (fold-matches regexp string init proc . flags)
(let ((regexp (if (regexp? regexp) regexp (make-regexp regexp)))
(flags (if (null? flags) 0 flags)))
(let loop ((start 0)
(else
(loop (match:end m) (proc m value) #t)))))))
-(define-public (list-matches regexp string . flags)
+(define (list-matches regexp string . flags)
(reverse! (apply fold-matches regexp string '() cons flags)))
-(define-public (regexp-substitute/global port regexp string . items)
+(define (regexp-substitute/global port regexp string . items)
;; If `port' is #f, send output to a string.
(if (not port)
;;; Code:
(define-module (ice-9 runq)
- :use-module (ice-9 q))
+ :use-module (ice-9 q)
+ :export (runq-control make-void-runq make-fair-runq
+ make-exclusive-runq make-subordinate-runq-to strip-sequence
+ fair-strip-subtask))
;;;;
;;; (runq-control q msg . args)
;;; 'kill! ;; empty the queue
;;; else ;; throw 'not-understood
;;;
-(define-public (runq-control q msg . args)
+(define (runq-control q msg . args)
(case msg
((add!) (for-each (lambda (t) (enq! q t)) args) '*unspecified*)
((enqueue!) (for-each (lambda (t) (enq! q t)) args) '*unspecified*)
;;; Make a runq that discards all messages except "length", for which
;;; it returns 0.
;;;
-(define-public (make-void-runq)
+(define (make-void-runq)
(lambda opts
(and opts
(apply-to-args opts
;;; to the end of the queue, meaning it will be the last to execute
;;; of all the remaining procedures.
;;;
-(define-public (make-fair-runq)
+(define (make-fair-runq)
(letrec ((q (make-q))
(self
(lambda ctl
;;; of that (if the CDR is not nil). This way, the rest of the thunks
;;; in the list that contained W have priority over the return value of W.
;;;
-(define-public (make-exclusive-runq)
+(define (make-exclusive-runq)
(letrec ((q (make-q))
(self
(lambda ctl
;;; N is the length of the basic-inferior queue when the proxy
;;; strip is entered. [Countless scheduling variations are possible.]
;;;
-(define-public (make-subordinate-runq-to superior-runq basic-runq)
+(define (make-subordinate-runq-to superior-runq basic-runq)
(let ((runq-task (cons #f #f)))
(set-car! runq-task
(lambda ()
;;;
;;; Returns a new strip which is the concatenation of the argument strips.
;;;
-(define-public ((strip-sequence . strips))
+(define ((strip-sequence . strips))
(let loop ((st (let ((a strips)) (set! strips #f) a)))
(and (not (null? st))
(let ((then ((car st))))
;;;
;;;
;;;
-(define-public (fair-strip-subtask . initial-strips)
+(define (fair-strip-subtask . initial-strips)
(let ((st (make-fair-runq)))
(apply st 'add! initial-strips)
st))
\f
;;;; Safe subset of R5RS bindings
-(define-module (ice-9 safe-r5rs))
-
-(define null-interface (resolve-interface '(ice-9 null)))
-
-(module-use! %module-public-interface null-interface)
-
-(re-export eqv? eq? equal?
- number? complex? real? rational? integer?
- exact? inexact?
- = < > <= >=
- zero? positive? negative? odd? even?
- max min
- + * - /
- abs
- quotient remainder modulo
- gcd lcm
- ;;numerator denominator XXX
- ;;rationalize XXX
- floor ceiling truncate round
- exp log sin cos tan asin acos atan
- sqrt
- expt
- make-rectangular make-polar real-part imag-part magnitude angle
- exact->inexact inexact->exact
+(define-module (ice-9 safe-r5rs)
+ :re-export (eqv? eq? equal?
+ number? complex? real? rational? integer?
+ exact? inexact?
+ = < > <= >=
+ zero? positive? negative? odd? even?
+ max min
+ + * - /
+ abs
+ quotient remainder modulo
+ gcd lcm
+ ;;numerator denominator XXX
+ ;;rationalize XXX
+ floor ceiling truncate round
+ exp log sin cos tan asin acos atan
+ sqrt
+ expt
+ make-rectangular make-polar real-part imag-part magnitude angle
+ exact->inexact inexact->exact
+
+ number->string string->number
- number->string string->number
+ boolean?
+ not
- boolean?
- not
+ pair?
+ cons car cdr
+ set-car! set-cdr!
+ caar cadr cdar cddr
+ caaar caadr cadar caddr cdaar cdadr cddar cdddr
+ caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
+ cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
+ null?
+ list?
+ list
+ length
+ append
+ reverse
+ list-tail list-ref
+ memq memv member
+ assq assv assoc
- pair?
- cons car cdr
- set-car! set-cdr!
- caar cadr cdar cddr
- caaar caadr cadar caddr cdaar cdadr cddar cdddr
- caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
- cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
- null?
- list?
- list
- length
- append
- reverse
- list-tail list-ref
- memq memv member
- assq assv assoc
+ symbol?
+ symbol->string string->symbol
- symbol?
- symbol->string string->symbol
+ char?
+ char=? char<? char>? char<=? char>=?
+ char-ci=? char-ci<? char-ci>? char-ci<=? char-ci>=?
+ char-alphabetic? char-numeric? char-whitespace?
+ char-upper-case? char-lower-case?
+ char->integer integer->char
+ char-upcase
+ char-downcase
- char?
- char=? char<? char>? char<=? char>=?
- char-ci=? char-ci<? char-ci>? char-ci<=? char-ci>=?
- char-alphabetic? char-numeric? char-whitespace?
- char-upper-case? char-lower-case?
- char->integer integer->char
- char-upcase
- char-downcase
+ string?
+ make-string
+ string
+ string-length
+ string-ref string-set!
+ string=? string-ci=?
+ string<? string>? string<=? string>=?
+ string-ci<? string-ci>? string-ci<=? string-ci>=?
+ substring
+ string-length
+ string-append
+ string->list list->string
+ string-copy string-fill!
- string?
- make-string
- string
- string-length
- string-ref string-set!
- string=? string-ci=?
- string<? string>? string<=? string>=?
- string-ci<? string-ci>? string-ci<=? string-ci>=?
- substring
- string-length
- string-append
- string->list list->string
- string-copy string-fill!
+ vector?
+ make-vector
+ vector
+ vector-length
+ vector-ref vector-set!
+ vector->list list->vector
+ vector-fill!
- vector?
- make-vector
- vector
- vector-length
- vector-ref vector-set!
- vector->list list->vector
- vector-fill!
+ procedure?
+ apply
+ map
+ for-each
+ force
- procedure?
- apply
- map
- for-each
- force
+ call-with-current-continuation
- call-with-current-continuation
+ values
+ call-with-values
+ dynamic-wind
- values
- call-with-values
- dynamic-wind
-
- eval
+ eval
- input-port? output-port?
- current-input-port current-output-port
+ input-port? output-port?
+ current-input-port current-output-port
- read
- read-char
- peek-char
- eof-object?
- char-ready?
+ read
+ read-char
+ peek-char
+ eof-object?
+ char-ready?
- write
- display
- newline
- write-char
+ write
+ display
+ newline
+ write-char
+
+ ;;transcript-on
+ ;;transcript-off
+ )
- ;;transcript-on
- ;;transcript-off
- )
+ :export (null-environment))
-(export null-environment)
+(define null-interface (resolve-interface '(ice-9 null)))
+
+(module-use! %module-public-interface null-interface)
(define (null-environment n)
(if (not (= n 5))
-;;;; Copyright (C) 2000 Free Software Foundation, Inc.
+;;;; Copyright (C) 2000, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
\f
;;;; Safe subset of R5RS bindings
-(define-module (ice-9 safe))
+(define-module (ice-9 safe)
+ :export (safe-environment make-safe-module))
(define safe-r5rs-interface (resolve-interface '(ice-9 safe-r5rs)))
-(define-public (safe-environment n)
+(define (safe-environment n)
(if (not (= n 5))
(scm-error 'misc-error 'safe-environment
"~A is not a valid version"
'()))
safe-r5rs-interface)
-(define-public (make-safe-module)
+(define (make-safe-module)
(make-module 1021 (list safe-r5rs-interface)))
(define-module (ice-9 session)
:use-module (ice-9 documentation)
:use-module (ice-9 regex)
- :use-module (ice-9 rdelim))
+ :use-module (ice-9 rdelim)
+ :export (help apropos apropos-internal apropos-fold
+ apropos-fold-accessible apropos-fold-exported apropos-fold-all
+ source arity system-module))
\f
;;; Documentation
;;;
-(define-public help
+(define help
(procedure->syntax
(lambda (exp env)
"(help [NAME])
;;; Author: Roland Orre <orre@nada.kth.se>
;;;
-(define-public (apropos rgx . options)
+(define (apropos rgx . options)
"Search for bindings: apropos regexp {options= 'full 'shadow 'value}"
(if (zero? (string-length rgx))
"Empty string not allowed"
obarray)))
modules))))
-(define-public (apropos-internal rgx)
+(define (apropos-internal rgx)
"Return a list of accessible variable names."
(apropos-fold (lambda (module name var data)
(cons name data))
rgx
(apropos-fold-accessible (current-module))))
-(define-public (apropos-fold proc init rgx folder)
+(define (apropos-fold proc init rgx folder)
"Folds PROCEDURE over bindings matching third arg REGEXP.
Result is
data)))
((null? modules) data))))))
-(define-public (apropos-fold-accessible module)
+(define (apropos-fold-accessible module)
(make-fold-modules (lambda () (list module))
module-uses
identity))
'()
(module-obarray m)))
-(define-public apropos-fold-exported
+(define apropos-fold-exported
(make-fold-modules root-modules submodules module-public-interface))
-(define-public apropos-fold-all
+(define apropos-fold-all
(make-fold-modules root-modules submodules identity))
-(define-public (source obj)
+(define (source obj)
(cond ((procedure? obj) (procedure-source obj))
((macro? obj) (procedure-source (macro-transformer obj)))
(else #f)))
-(define-public (arity obj)
+(define (arity obj)
(define (display-arg-list arg-list)
(display #\`)
(display (car arg-list))
(display #\'))))))))
(display ".\n"))
-(define-public system-module
+(define system-module
(procedure->syntax
(lambda (exp env)
(let* ((m (nested-ref the-root-module
;;;; slib.scm --- definitions needed to get SLIB to work with Guile
;;;;
-;;;; Copyright (C) 1997, 1998, 2000 Free Software Foundation, Inc.
+;;;; Copyright (C) 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
;;;;
;;;; This file is part of GUILE.
;;;;
;;;; If you do not wish that, delete this exception notice.
;;;;
(define-module (ice-9 slib)
+ :export (slib:load slib:load-source defmacro:load
+ implementation-vicinity library-vicinity home-vicinity
+ scheme-implementation-type scheme-implementation-version
+ output-port-width output-port-height identity array-indexes
+ make-random-state require slib:error slib:exit slib:warn slib:eval
+ defmacro:eval logical:logand logical:logior logical:logxor
+ logical:lognot logical:ash logical:logcount logical:integer-length
+ logical:bit-extract logical:integer-expt logical:ipow-by-squaring
+ slib:eval-load slib:tab slib:form-feed difftime offset-time
+ software-type)
:no-backtrace)
-
+
\f
(define (eval-load <filename> evl)
(define (defined? symbol)
(module-defined? slib-module symbol))
-(define slib:features
- (append '(source
- eval
- abort
- alist
- defmacro
- delay
- dynamic-wind
- full-continuation
- hash
- hash-table
- line-i/o
- logical
- multiarg/and-
- multiarg-apply
- promise
- rev2-procedures
- rev4-optional-procedures
- string-port
- with-file)
-
- (if (defined? 'getenv)
- '(getenv)
- '())
-
- (if (defined? 'current-time)
- '(current-time)
- '())
-
- (if (defined? 'system)
- '(system)
- '())
-
- (if (defined? 'array?)
- '(array)
- '())
-
- (if (defined? 'char-ready?)
- '(char-ready?)
- '())
-
- (if (defined? 'array-for-each)
- '(array-for-each)
- '())
-
- (if (and (string->number "0.0") (inexact? (string->number "0.0")))
- '(inexact)
- '())
-
- (if (rational? (string->number "1/19"))
- '(rational)
- '())
-
- (if (real? (string->number "0.0"))
- '(real)
- ())
-
- (if (complex? (string->number "1+i"))
- '(complex)
- '())
-
- (let ((n (string->number "9999999999999999999999999999999")))
- (if (and n (exact? n))
- '(bignum)
- '()))))
+;;; *FEATURES* should be set to a list of symbols describing features
+;;; of this implementation. Suggestions for features are:
+(define *features*
+ (append
+ '(
+ source ;can load scheme source files
+ ;(slib:load-source "filename")
+; compiled ;can load compiled files
+ ;(slib:load-compiled "filename")
+
+ ;; Scheme report features
+
+; rev5-report ;conforms to
+ eval ;R5RS two-argument eval
+; values ;R5RS multiple values
+ dynamic-wind ;R5RS dynamic-wind
+; macro ;R5RS high level macros
+ delay ;has DELAY and FORCE
+ multiarg-apply ;APPLY can take more than 2 args.
+; rationalize
+ rev4-optional-procedures ;LIST-TAIL, STRING->LIST,
+ ;LIST->STRING, STRING-COPY,
+ ;STRING-FILL!, LIST->VECTOR,
+ ;VECTOR->LIST, and VECTOR-FILL!
+
+; rev4-report ;conforms to
+
+; ieee-p1178 ;conforms to
+
+; rev3-report ;conforms to
+
+ rev2-procedures ;SUBSTRING-MOVE-LEFT!,
+ ;SUBSTRING-MOVE-RIGHT!,
+ ;SUBSTRING-FILL!,
+ ;STRING-NULL?, APPEND!, 1+,
+ ;-1+, <?, <=?, =?, >?, >=?
+; object-hash ;has OBJECT-HASH
+
+ multiarg/and- ;/ and - can take more than 2 args.
+ with-file ;has WITH-INPUT-FROM-FILE and
+ ;WITH-OUTPUT-FROM-FILE
+; transcript ;TRANSCRIPT-ON and TRANSCRIPT-OFF
+; ieee-floating-point ;conforms to IEEE Standard 754-1985
+ ;IEEE Standard for Binary
+ ;Floating-Point Arithmetic.
+ full-continuation ;can return multiple times
+
+ ;; Other common features
+
+; srfi ;srfi-0, COND-EXPAND finds all srfi-*
+; sicp ;runs code from Structure and
+ ;Interpretation of Computer
+ ;Programs by Abelson and Sussman.
+ defmacro ;has Common Lisp DEFMACRO
+; record ;has user defined data structures
+ string-port ;has CALL-WITH-INPUT-STRING and
+ ;CALL-WITH-OUTPUT-STRING
+; sort
+; pretty-print
+; object->string
+; format ;Common-lisp output formatting
+; trace ;has macros: TRACE and UNTRACE
+; compiler ;has (COMPILER)
+; ed ;(ED) is editor
+ random
+ )
+
+ (if (defined? 'getenv)
+ '(getenv)
+ '())
+
+ (if (defined? 'current-time)
+ '(current-time)
+ '())
+
+ (if (defined? 'system)
+ '(system)
+ '())
+
+ (if (defined? 'array?)
+ '(array)
+ '())
+
+ (if (defined? 'char-ready?)
+ '(char-ready?)
+ '())
+
+ (if (defined? 'array-for-each)
+ '(array-for-each)
+ '())
+
+ *features*))
;;; FIXME: Because uers want require to search the path, this uses
;;; changing catalog:get in slib/require.scm, and I don't expect
;;; Aubrey will integrate such a change. So I'm just going to punt
;;; for the time being.
-(define-public (slib:load name)
+(define (slib:load name)
(save-module-excursion
(lambda ()
(set-current-module slib-module)
(substring path 0 (- (string-length path) 17))
(error "Could not find slib/require.scm in " %load-path))))
-(define-public (implementation-vicinity)
+(define (implementation-vicinity)
(string-append slib-parent-dir "/"))
-(define-public (library-vicinity)
+(define (library-vicinity)
(string-append (implementation-vicinity) "slib/"))
-(define-public home-vicinity
+(define home-vicinity
(let ((home-path (getenv "HOME")))
(lambda () home-path)))
-(define-public (scheme-implementation-type) 'guile)
-(define-public (scheme-implementation-version) "")
+(define (scheme-implementation-type) 'guile)
+(define scheme-implementation-version version)
+;;; (scheme-implementation-home-page) should return a (string) URI
+;;; (Uniform Resource Identifier) for this scheme implementation's home
+;;; page; or false if there isn't one.
+(define (scheme-implementation-home-page)
+ "http://www.gnu.org/software/guile/guile.html")
(define (output-port-width . arg) 80)
(define (output-port-height . arg) 24)
(define (identity x) x)
+;;; {array-for-each}
+(define (array-indexes ra)
+ (let ((ra0 (apply make-array '() (array-shape ra))))
+ (array-index-map! ra0 list)
+ ra0))
+
;;; {Random numbers}
;;;
-(define-public (make-random-state . args)
+(define (make-random-state . args)
(let ((seed (if (null? args) *random-state* (car args))))
(cond ((string? seed))
((number? seed) (set! seed (number->string seed)))
(slib:load (in-vicinity (library-vicinity) "require.scm"))
-(define-public require require:require)
+(define require require:require)
;; {Extensions to the require system so that the user can add new
;; require modules easily.}
;; (i.e. ripped off) Scheme48's `stream' package,
;; modulo stream-empty? -> stream-null? renaming.
-(define-module (ice-9 streams))
-
-(export make-stream
- stream-car stream-cdr stream-null?
- list->stream vector->stream port->stream
- stream->list stream->reversed-list
- stream->list&length stream->reversed-list&length
- stream->vector
- stream-fold stream-for-each stream-map)
+(define-module (ice-9 streams)
+ :export (make-stream
+ stream-car stream-cdr stream-null?
+ list->stream vector->stream port->stream
+ stream->list stream->reversed-list
+ stream->list&length stream->reversed-list&length
+ stream->vector
+ stream-fold stream-for-each stream-map))
;; Use:
;;
;;;; string-fun.scm --- string manipulation functions
;;;;
-;;;; Copyright (C) 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
+;;;; Copyright (C) 1995, 1996, 1997, 1999, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
;;;; If you do not wish that, delete this exception notice.
;;;;
\f
-(define-module (ice-9 string-fun))
+(define-module (ice-9 string-fun)
+ :export (split-after-char split-before-char split-discarding-char
+ split-after-char-last split-before-char-last
+ split-discarding-char-last split-before-predicate
+ split-after-predicate split-discarding-predicate
+ separate-fields-discarding-char separate-fields-after-char
+ separate-fields-before-char string-prefix-predicate string-prefix=?
+ sans-surrounding-whitespace sans-trailing-whitespace
+ sans-leading-whitespace sans-final-newline has-trailing-newline?))
;;;;
;;;
;;; complicated with these functions, consider using regular expressions.
;;;
-(define-public (split-after-char char str ret)
+(define (split-after-char char str ret)
(let ((end (cond
((string-index str char) => 1+)
(else (string-length str)))))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-before-char char str ret)
+(define (split-before-char char str ret)
(let ((end (or (string-index str char)
(string-length str))))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-discarding-char char str ret)
+(define (split-discarding-char char str ret)
(let ((end (string-index str char)))
(if (not end)
(ret str "")
(ret (substring str 0 end)
(substring str (1+ end))))))
-(define-public (split-after-char-last char str ret)
+(define (split-after-char-last char str ret)
(let ((end (cond
((string-rindex str char) => 1+)
(else 0))))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-before-char-last char str ret)
+(define (split-before-char-last char str ret)
(let ((end (or (string-rindex str char) 0)))
(ret (substring str 0 end)
(substring str end))))
-(define-public (split-discarding-char-last char str ret)
+(define (split-discarding-char-last char str ret)
(let ((end (string-rindex str char)))
(if (not end)
(ret str "")
(ret (substring str 0 end)
(substring str (1+ end))))))
-(define-public (split-before-predicate pred str ret)
+(define (split-before-predicate pred str ret)
(let loop ((n 0))
(cond
((= n (string-length str)) (ret str ""))
((not (pred (string-ref str n))) (loop (1+ n)))
(else (ret (substring str 0 n)
(substring str n))))))
-(define-public (split-after-predicate pred str ret)
+(define (split-after-predicate pred str ret)
(let loop ((n 0))
(cond
((= n (string-length str)) (ret str ""))
(else (ret (substring str 0 (1+ n))
(substring str (1+ n)))))))
-(define-public (split-discarding-predicate pred str ret)
+(define (split-discarding-predicate pred str ret)
(let loop ((n 0))
(cond
((= n (string-length str)) (ret str ""))
(else (ret (substring str 0 n)
(substring str (1+ n)))))))
-(define-public (separate-fields-discarding-char ch str ret)
+(define (separate-fields-discarding-char ch str ret)
(let loop ((fields '())
(str str))
(cond
(substring str 0 w))))
(else (apply ret str fields)))))
-(define-public (separate-fields-after-char ch str ret)
+(define (separate-fields-after-char ch str ret)
(reverse
(let loop ((fields '())
(str str))
(substring str (+ 1 w)))))
(else (apply ret str fields))))))
-(define-public (separate-fields-before-char ch str ret)
+(define (separate-fields-before-char ch str ret)
(let loop ((fields '())
(str str))
(cond
;;; (define-public string-prefix=? (string-prefix-predicate string=?))
;;;
-(define-public ((string-prefix-predicate pred?) prefix str)
+(define ((string-prefix-predicate pred?) prefix str)
(and (<= (string-length prefix) (string-length str))
(pred? prefix (substring str 0 (string-length prefix)))))
-(define-public string-prefix=? (string-prefix-predicate string=?))
+(define string-prefix=? (string-prefix-predicate string=?))
\f
;;; {String Fun: Strippers}
;;; | final-newline
;;;
-(define-public (sans-surrounding-whitespace s)
+(define (sans-surrounding-whitespace s)
(let ((st 0)
(end (string-length s)))
(while (and (< st (string-length s))
""
(substring s st end))))
-(define-public (sans-trailing-whitespace s)
+(define (sans-trailing-whitespace s)
(let ((st 0)
(end (string-length s)))
(while (and (< 0 end)
""
(substring s st end))))
-(define-public (sans-leading-whitespace s)
+(define (sans-leading-whitespace s)
(let ((st 0)
(end (string-length s)))
(while (and (< st (string-length s))
""
(substring s st end))))
-(define-public (sans-final-newline str)
+(define (sans-final-newline str)
(cond
((= 0 (string-length str))
str)
;;; {String Fun: has-trailing-newline?}
;;;
-(define-public (has-trailing-newline? str)
+(define (has-trailing-newline? str)
(and (< 0 (string-length str))
(char=? #\nl (string-ref str (1- (string-length str))))))
-;;;; Copyright (C) 1997, 2000 Free Software Foundation, Inc.
+;;;; Copyright (C) 1997, 2000, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
\f
(define-module (ice-9 syncase)
- :use-module (ice-9 debug))
+ :use-module (ice-9 debug)
+ :export-syntax (sc-macro define-syntax eval-when fluid-let-syntax
+ identifier-syntax let-syntax
+ letrec-syntax syntax syntax-case syntax-rules
+ with-syntax
+ include)
+ :export (sc-expand sc-expand3 install-global-transformer
+ syntax-dispatch syntax-error bound-identifier=?
+ datum->syntax-object free-identifier=?
+ generate-temporaries identifier? syntax-object->datum
+ void eval syncase))
\f
-(define-public sc-macro
+(define sc-macro
(procedure->memoizing-macro
(lambda (exp env)
(sc-expand exp))))
;;; Exported variables
-(define-public sc-expand #f)
-(define-public sc-expand3 #f)
-(define-public install-global-transformer #f)
-(define-public syntax-dispatch #f)
-(define-public syntax-error #f)
-
-(define-public bound-identifier=? #f)
-(define-public datum->syntax-object #f)
-(define-public define-syntax sc-macro)
-(define-public eval-when sc-macro)
-(define-public fluid-let-syntax sc-macro)
-(define-public free-identifier=? #f)
-(define-public generate-temporaries #f)
-(define-public identifier? #f)
-(define-public identifier-syntax sc-macro)
-(define-public let-syntax sc-macro)
-(define-public letrec-syntax sc-macro)
-(define-public syntax sc-macro)
-(define-public syntax-case sc-macro)
-(define-public syntax-object->datum #f)
-(define-public syntax-rules sc-macro)
-(define-public with-syntax sc-macro)
-(define-public include sc-macro)
+(define sc-expand #f)
+(define sc-expand3 #f)
+(define install-global-transformer #f)
+(define syntax-dispatch #f)
+(define syntax-error #f)
+
+(define bound-identifier=? #f)
+(define datum->syntax-object #f)
+(define define-syntax sc-macro)
+(define eval-when sc-macro)
+(define fluid-let-syntax sc-macro)
+(define free-identifier=? #f)
+(define generate-temporaries #f)
+(define identifier? #f)
+(define identifier-syntax sc-macro)
+(define let-syntax sc-macro)
+(define letrec-syntax sc-macro)
+(define syntax sc-macro)
+(define syntax-case sc-macro)
+(define syntax-object->datum #f)
+(define syntax-rules sc-macro)
+(define with-syntax sc-macro)
+(define include sc-macro)
(define primitive-syntax '(quote lambda letrec if set! begin define or
and let let* cond do quasiquote unquote
;;; Hooks needed by the syntax-case macro package
-(define-public (void) *unspecified*)
+(define (void) *unspecified*)
(define andmap
(lambda (f first . rest)
(define internal-eval (nested-ref the-scm-module '(app modules guile eval)))
-(define-public (eval x environment)
+(define (eval x environment)
(internal-eval (if (and (pair? x)
(equal? (car x) "noexpand"))
(cadr x)
'*sc-expander*
'(define))))
-(define-public syncase sc-expand)
+(define syncase sc-expand)
;;; Code:
-(define-module (ice-9 threads))
+(define-module (ice-9 threads)
+ :export-syntax (make-thread
+ begin-thread
+ with-mutex
+ monitor)
+ :export (%thread-handler))
\f
(begin
,first ,@rest)))
-;; export
-
-(export %thread-handler)
-
-(export-syntax make-thread
- begin-thread
- with-mutex
- monitor)
-
;;; threads.scm ends here
+2001-10-21 Mikael Djurfeldt <mdj@linnaeus>
+
+ * goops.scm, goops/active-slot.scm, goops/compile.scm,
+ goops/composite-slot.scm, goops/describe.scm, goops/dispatch.scm,
+ goops/old-define-method.scm, goops/save.scm, goops/util.scm: Move
+ module the system directives `export', `export-syntax',
+ `re-export' and `re-export-syntax' into the `define-module' form.
+ This is the recommended way of exporting bindings.
+
2001-08-25 Marius Vollmer <mvo@zagadka.ping.de>
* Makefile.am, goops/Makefile.am: (AUTOMAKE_OPTIONS): Change
;;;;
(define-module (oop goops)
+ :export-syntax (define-class class
+ define-generic define-accessor define-method
+ method)
+ :export (goops-version is-a?
+ ensure-metaclass ensure-metaclass-with-supers
+ make-class
+ make-generic ensure-generic
+ make-accessor ensure-accessor
+ make-method add-method!
+ object-eqv? object-equal?
+ class-slot-ref class-slot-set! slot-unbound slot-missing
+ slot-definition-name slot-definition-options
+ slot-definition-allocation
+ slot-definition-getter slot-definition-setter
+ slot-definition-accessor
+ slot-definition-init-value slot-definition-init-form
+ slot-definition-init-thunk slot-definition-init-keyword
+ slot-init-function class-slot-definition
+ method-source
+ compute-cpl compute-std-cpl compute-get-n-set compute-slots
+ compute-getter-method compute-setter-method
+ allocate-instance initialize make-instance make
+ no-next-method no-applicable-method no-method
+ change-class update-instance-for-different-class
+ shallow-clone deep-clone
+ class-redefinition
+ apply-generic apply-method apply-methods
+ compute-applicable-methods %compute-applicable-methods
+ method-more-specific? sort-applicable-methods
+ class-subclasses class-methods
+ goops-error
+ min-fixnum max-fixnum
+ ;;; *fixme* Should go into goops.c
+ instance? slot-ref-using-class
+ slot-set-using-class! slot-bound-using-class?
+ slot-exists-using-class? slot-ref slot-set! slot-bound?
+ class-name class-direct-supers class-direct-subclasses
+ class-direct-methods class-direct-slots class-precedence-list
+ class-slots class-environment
+ generic-function-name
+ generic-function-methods method-generic-function method-specializers
+ primitive-generic-generic enable-primitive-generic!
+ method-procedure accessor-method-slot-definition
+ slot-exists? make find-method get-keyword)
+ :re-export (class-of) ;; from (guile)
:no-backtrace)
;; First initialize the builtin part of GOOPS
(oop goops dispatch)
(oop goops compile))
-(export ; Define the exported symbols of this file
- goops-version is-a?
- ensure-metaclass ensure-metaclass-with-supers
- define-class class make-class
- define-generic make-generic ensure-generic
- define-accessor make-accessor ensure-accessor
- define-method make-method method add-method!
- object-eqv? object-equal?
- class-slot-ref class-slot-set! slot-unbound slot-missing
- slot-definition-name slot-definition-options slot-definition-allocation
- slot-definition-getter slot-definition-setter slot-definition-accessor
- slot-definition-init-value slot-definition-init-form
- slot-definition-init-thunk slot-definition-init-keyword
- slot-init-function class-slot-definition
- method-source
- compute-cpl compute-std-cpl compute-get-n-set compute-slots
- compute-getter-method compute-setter-method
- allocate-instance initialize make-instance make
- no-next-method no-applicable-method no-method
- change-class update-instance-for-different-class
- shallow-clone deep-clone
- class-redefinition
- apply-generic apply-method apply-methods
- compute-applicable-methods %compute-applicable-methods
- method-more-specific? sort-applicable-methods
- class-subclasses class-methods
- goops-error
- min-fixnum max-fixnum
-)
-
-;;; *fixme* Should go into goops.c
-
-(export
- instance? slot-ref-using-class
- slot-set-using-class! slot-bound-using-class?
- slot-exists-using-class? slot-ref slot-set! slot-bound?
- class-name class-direct-supers class-direct-subclasses
- class-direct-methods class-direct-slots class-precedence-list
- class-slots class-environment
- generic-function-name
- generic-function-methods method-generic-function method-specializers
- primitive-generic-generic enable-primitive-generic!
- method-procedure accessor-method-slot-definition
- slot-exists? make find-method get-keyword)
-
-(re-export class-of) ;; from (guile)
-
\f
(define min-fixnum (- (expt 2 29)))
;;;;
(define-module (oop goops active-slot)
- :use-module (oop goops internal))
-
-(export <active-class>)
+ :use-module (oop goops internal)
+ :export (<active-class>))
(define-class <active-class> (<class>))
(define-module (oop goops compile)
:use-module (oop goops)
:use-module (oop goops util)
+ :export (compute-cmethod compute-entry-with-cmethod
+ compile-method cmethod-code cmethod-environment)
:no-backtrace
)
-(export compute-cmethod compute-entry-with-cmethod
- compile-method cmethod-code cmethod-environment)
-
(define source-formals cadr)
(define source-body cddr)
;;;;
(define-module (oop goops composite-slot)
- :use-module (oop goops))
-
-(export <composite-class>)
+ :use-module (oop goops)
+ :export (<composite-class>))
;;;
;;; (define-class CLASS SUPERS
(define-module (oop goops describe)
:use-module (oop goops)
:use-module (ice-9 session)
- :use-module (ice-9 format))
-
-(export describe) ; Export the describe generic function
+ :use-module (ice-9 format)
+ :export (describe)) ; Export the describe generic function
;;;
;;; describe for simple objects
-;;;; Copyright (C) 1999, 2000 Free Software Foundation, Inc.
+;;;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
;;;;
;;;; This program is free software; you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License as published by
:use-module (oop goops)
:use-module (oop goops util)
:use-module (oop goops compile)
+ :export (memoize-method!)
:no-backtrace
)
-(export memoize-method!)
-
;;;
;;; This file implements method memoization. It will finally be
;;; implemented on C level in order to obtain fast generic function
(define-module (oop goops old-define-method)
:use-module (oop goops)
+ :export (define-method)
:no-backtrace
)
-(export define-method)
-
(define define-method
(procedure->memoizing-macro
(lambda (exp env)
(define-module (oop goops save)
:use-module (oop goops internal)
:use-module (oop goops util)
- )
-
-(re-export make-unbound)
-
-(export save-objects load-objects restore
- enumerate! enumerate-component!
- write-readably write-component write-component-procedure
- literal? readable make-readable)
+ :re-export (make-unbound)
+ :export (save-objects load-objects restore
+ enumerate! enumerate-component!
+ write-readably write-component write-component-procedure
+ literal? readable make-readable))
;;;
;;; save-objects ALIST PORT [EXCLUDED] [USES]
\f
(define-module (oop goops util)
+ :export (any every filter
+ mapappend find-duplicate top-level-env top-level-env?
+ map* for-each* length* improper->proper)
:no-backtrace
)
-(export any every filter
- mapappend find-duplicate top-level-env top-level-env?
- map* for-each* length* improper->proper
- )
;;;
;;; {Utilities}
+2001-10-21 Mikael Djurfeldt <mdj@linnaeus>
+
+ * srfi-2.scm, srfi-4.scm, srfi-8.scm, srfi-9.scm, srfi-10.scm,
+ srfi-11.scm, srfi-14.scm, srfi-16.scm: Move module the system
+ directives `export', `export-syntax', `re-export' and
+ `re-export-syntax' into the `define-module' form. This is the
+ recommended way of exporting bindings.
+
2001-09-22 Mikael Djurfeldt <mdj@linnaeus>
* srfi-19.scm (priv:split-real): Inserted missing call to
;;; Code:
(define-module (srfi srfi-10)
- #:use-module (ice-9 rdelim))
-
-(export define-reader-ctor)
+ :use-module (ice-9 rdelim)
+ :export (define-reader-ctor))
(cond-expand-provide (current-module) '(srfi-10))
;;; If you do not wish that, delete this exception notice.
(define-module (srfi srfi-11)
- :use-module (ice-9 syncase))
+ :use-module (ice-9 syncase)
+ :export-syntax (let-values let*-values))
(cond-expand-provide (current-module) '(srfi-11))
; (if (null? vars)
; `(begin ,@body)
; (let-values-helper vars body)))
-
-(export-syntax let-values
- let*-values)
;;;; whether to permit this exception to apply to your modifications.
;;;; If you do not wish that, delete this exception notice.
-(define-module (srfi srfi-14))
-
-(export
+(define-module (srfi srfi-14)
+ :export (
;;; General procedures
char-set?
char-set=
char-set:ascii
char-set:empty
char-set:full
- )
+ ))
(cond-expand-provide (current-module) '(srfi-14))
;;; Author: Martin Grabmueller
;;; Code:
-(define-module (srfi srfi-16))
-
-(export-syntax case-lambda)
+(define-module (srfi srfi-16)
+ :export-syntax (case-lambda))
(cond-expand-provide (current-module) '(srfi-16))
;;;; If you do not wish that, delete this exception notice.
(define-module (srfi srfi-2)
- :use-module (ice-9 and-let-star))
-
-(re-export-syntax and-let*)
+ :use-module (ice-9 and-let-star)
+ :re-export-syntax (and-let*))
(cond-expand-provide (current-module) '(srfi-2))
;;; Author: Martin Grabmueller <mgrabmue@cs.tu-berlin.de>
-(define-module (srfi srfi-4))
-
-(export
+(define-module (srfi srfi-4)
+ :export (
;;; Unsigned 8-bit vectors.
u8vector? make-u8vector u8vector u8vector-length u8vector-ref
u8vector-set! u8vector->list list->u8vector
;;; 64-bit floating point vectors.
f64vector? make-f64vector f64vector f64vector-length f64vector-ref
f64vector-set! f64vector->list list->f64vector
- )
+ ))
;; Make 'srfi-4 available as a feature identifiere to `cond-expand'.
;;; If you do not wish that, delete this exception notice.
(define-module (srfi srfi-8)
- :use-module (ice-9 receive))
-
-(re-export-syntax receive)
+ :use-module (ice-9 receive)
+ :re-export-syntax (receive))
(cond-expand-provide (current-module) '(srfi-8))
;;; Code:
-(define-module (srfi srfi-9))
-
-(export-syntax define-record-type)
+(define-module (srfi srfi-9)
+ :export-syntax (define-record-type))
(cond-expand-provide (current-module) '(srfi-9))
+2001-10-21 Mikael Djurfeldt <mdj@linnaeus>
+
+ * lib.scm: Move module the system directives `export',
+ `export-syntax', `re-export' and `re-export-syntax' into the
+ `define-module' form. This is the recommended way of exporting
+ bindings.
+
2001-10-18 Dirk Herrmann <D.Herrmann@tu-bs.de>
* tests/syntax.test: Added test cases for 'cond =>' syntax with
(define-module (test-suite lib)
:use-module (ice-9 stack-catch)
- :use-module (ice-9 regex))
-
-(export
+ :use-module (ice-9 regex)
+ :export (
;; Exceptions which are commonly being tested for.
exception:out-of-range exception:unbound-var
make-log-reporter
full-reporter
user-reporter
- format-test-name)
+ format-test-name))
;;;; If you're using Emacs's Scheme mode:
HCoop / bpt / guile.git / commitdiff