pkg://guile-core-19980806-2.src.rpm:754810/guile-core-19980806.tar.gz
info downloads
guile-core/ 755 521 17 0 6560306106 11431 5 ustar guile users guile-core/CVS/ 755 521 17 0 6560556523 12076 5 ustar guile users guile-core/CVS/Root 644 521 17 53 6560306021 12744 0 ustar guile users :ext:egcs.cygnus.com:/egcs/carton/cvsfiles
guile-core/CVS/Repository 644 521 17 47 6560306021 14203 0 ustar guile users /egcs/carton/cvsfiles/guile/guile-core
guile-core/CVS/Entries 644 521 17 2602 6560556523 13512 0 ustar guile users /.cvsignore/1.3/Fri Jul 31 09:19:13 1998//
/ANON-CVS/1.4/Fri Jul 31 09:19:13 1998//
/AUTHORS/1.13/Fri Jul 31 09:19:13 1998//
/COPYING/1.2/Fri Jul 31 09:19:13 1998//
/ChangeLog/1.105/Fri Jul 31 09:19:13 1998//
/GUILE-VERSION/1.9/Fri Jul 31 09:19:13 1998//
/HACKING/1.15/Fri Jul 31 09:19:13 1998//
/INSTALL/1.15/Fri Jul 31 09:19:14 1998//
/Makefile.am/1.9/Fri Jul 31 09:19:14 1998//
/Makefile.in/1.50/Fri Jul 31 09:19:14 1998//
/NEWS/1.71/Fri Jul 31 09:19:15 1998//
/NOTES/1.7/Fri Jul 31 09:19:16 1998//
/README/1.51/Fri Jul 31 09:19:16 1998//
/RELEASE/1.15/Fri Jul 31 09:19:16 1998//
/SNAPSHOTS/1.1/Fri Jul 31 09:19:16 1998//
/THANKS/1.31/Fri Jul 31 09:19:16 1998//
/TODO/1.6/Fri Jul 31 09:19:16 1998//
/acconfig.h/1.15/Fri Jul 31 09:19:16 1998//
/acinclude.m4/1.4/Fri Jul 31 09:19:16 1998//
/aclocal.m4/1.40/Fri Jul 31 09:19:16 1998//
/config.guess/1.9/Fri Jul 31 09:19:17 1998//
/config.sub/1.7/Fri Jul 31 09:19:17 1998//
/configure/1.78/Fri Jul 31 09:19:19 1998//
/configure.in/1.56/Fri Jul 31 09:19:19 1998//
/guile.m4/1.4/Fri Jul 31 09:19:19 1998//
/install-sh/1.2/Fri Jul 31 09:19:19 1998//
/ltconfig/1.12/Fri Jul 31 09:19:20 1998//
/ltmain.sh/1.15/Fri Jul 31 09:19:21 1998//
/mdate-sh/1.2/Fri Jul 31 09:19:21 1998//
/missing/1.2/Fri Jul 31 09:19:21 1998//
/mkinstalldirs/1.2/Fri Jul 31 09:19:21 1998//
/qthreads.m4/1.3/Fri Jul 31 09:19:21 1998//
D/build////
D/ice-9////
D/libguile////
D/qt////
D/www////
guile-core/build/ 755 521 17 0 6560306032 12526 5 ustar guile users guile-core/build/CVS/ 755 521 17 0 6560306032 13161 5 ustar guile users guile-core/build/CVS/Root 644 521 17 53 6560306031 14044 0 ustar guile users :ext:egcs.cygnus.com:/egcs/carton/cvsfiles
guile-core/build/CVS/Repository 644 521 17 55 6560306031 15302 0 ustar guile users /egcs/carton/cvsfiles/guile/guile-core/build
guile-core/build/CVS/Entries 644 521 17 337 6560306032 14560 0 ustar guile users /.cvsignore/1.1/Fri Jul 31 09:19:22 1998//
/ChangeLog/1.8/Fri Jul 31 09:19:22 1998//
/Makefile.am/1.1/Fri Jul 31 09:19:22 1998//
/Makefile.in/1.10/Fri Jul 31 09:19:22 1998//
/build-guile.in/1.3/Fri Jul 31 09:19:22 1998//
D
guile-core/build/.cvsignore 644 521 17 25 6560306032 14543 0 ustar guile users Makefile
build-guile
guile-core/build/ChangeLog 644 521 17 2112 6560306032 14354 0 ustar guile users 1998-07-29 Jim Blandy <jimb@zwingli.cygnus.com>
* Makefile.in: Regenerated using the last public version of
automake, not the hacked Cygnus version.
1998-07-28 Jim Blandy <jimb@zwingli.cygnus.com>
* Makefile.in: Regenerated, after removing Totoro kludge.
1998-07-26 Jim Blandy <jimb@zwingli.cygnus.com>
* Makefile.in: Rebuilt, for config changes in parent dir.
1998-01-05 Tim Pierce <twp@skepsis.com>
* .cvsignore: New file.
Mon Oct 6 11:45:59 1997 Jim Blandy <jimb@totoro.red-bean.com>
* build-guile.in: Try to return an appropriate exit status.
* build-guile.in: Rearranged to use a table of subcommands, and
include per-subcommand help.
* build-guile.in: New "info" subcommand, for easy access to Guile
build variables.
Mon Sep 29 23:53:14 1997 Jim Blandy <jimb@totoro.red-bean.com>
* Makefile.in: Regenerated with automake 1.2c.
Sat Sep 27 23:15:26 1997 Jim Blandy <jimb@totoro.red-bean.com>
* New directory --- the build-guile command, intended to help
people build Guile-based applications.
* Makefile.am, Makefile.in, build-guile.in: New files.
guile-core/build/Makefile.am 644 521 17 1157 6560306032 14646 0 ustar guile users #### Makefile.in template for guile-core/build.
#### Jim Blandy <jimb@red-bean.com> --- September 1997
bin_SCRIPTS=build-guile
CLEANFILES=build-guile
EXTRA_DIST=build-guile.in
## We use @-...-@ as the substitution brackets here, instead of the
## usual @...@, so autoconf doesn't go and substitute the values
## directly into the left-hand sides of the sed substitutions. *sigh*
build-guile: build-guile.in
rm -f build-guile.tmp
sed < ${srcdir}/build-guile.in > build-guile.tmp \
-e s:@-bindir-@:${bindir}: \
-e s:@-GUILE_VERSION-@:${GUILE_VERSION}:
chmod +x build-guile.tmp
mv build-guile.tmp build-guile
guile-core/build/Makefile.in 644 521 17 14000 6560306032 14666 0 ustar guile users # Makefile.in generated automatically by automake 1.3 from Makefile.am
# Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
#### Makefile.in template for guile-core/build.
#### Jim Blandy <jimb@red-bean.com> --- September 1997
SHELL = /bin/sh
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
sharedstatedir = @sharedstatedir@
localstatedir = @localstatedir@
libdir = @libdir@
infodir = @infodir@
mandir = @mandir@
includedir = @includedir@
oldincludedir = /usr/include
DISTDIR =
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
top_builddir = ..
ACLOCAL = @ACLOCAL@
AUTOCONF = @AUTOCONF@
AUTOMAKE = @AUTOMAKE@
AUTOHEADER = @AUTOHEADER@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
transform = @program_transform_name@
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
host_alias = @host_alias@
host_triplet = @host@
AWK = @AWK@
CC = @CC@
CPP = @CPP@
GUILE_LIBS = @GUILE_LIBS@
GUILE_MAJOR_VERSION = @GUILE_MAJOR_VERSION@
GUILE_MINOR_VERSION = @GUILE_MINOR_VERSION@
GUILE_STAMP = @GUILE_STAMP@
GUILE_VERSION = @GUILE_VERSION@
LD = @LD@
LIBLOBJS = @LIBLOBJS@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
NM = @NM@
PACKAGE = @PACKAGE@
QTHREAD_LTLIBS = @QTHREAD_LTLIBS@
RANLIB = @RANLIB@
THREAD_CPPFLAGS = @THREAD_CPPFLAGS@
THREAD_LIBS_INSTALLED = @THREAD_LIBS_INSTALLED@
THREAD_LIBS_LOCAL = @THREAD_LIBS_LOCAL@
THREAD_PACKAGE = @THREAD_PACKAGE@
VERSION = @VERSION@
qtdmdb_s = @qtdmdb_s@
qtmd_h = @qtmd_h@
qtmdc_c = @qtmdc_c@
qtmds_s = @qtmds_s@
bin_SCRIPTS=build-guile
CLEANFILES=build-guile
EXTRA_DIST=build-guile.in
mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
CONFIG_HEADER = ../libguile/scmconfig.h
CONFIG_CLEAN_FILES =
SCRIPTS = $(bin_SCRIPTS)
DIST_COMMON = ChangeLog Makefile.am Makefile.in
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = tar
GZIP = --best
all: Makefile $(SCRIPTS)
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINT@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
cd $(top_srcdir) && $(AUTOMAKE) --gnu build/Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES)
cd $(top_builddir) \
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
install-binSCRIPTS: $(bin_SCRIPTS)
@$(NORMAL_INSTALL)
$(mkinstalldirs) $(DESTDIR)$(bindir)
@list='$(bin_SCRIPTS)'; for p in $$list; do \
if test -f $$p; then \
echo " $(INSTALL_SCRIPT) $$p $(DESTDIR)$(bindir)/`echo $$p|sed '$(transform)'`"; \
$(INSTALL_SCRIPT) $$p $(DESTDIR)$(bindir)/`echo $$p|sed '$(transform)'`; \
else if test -f $(srcdir)/$$p; then \
echo " $(INSTALL_SCRIPT) $(srcdir)/$$p $(DESTDIR)$(bindir)/`echo $$p|sed '$(transform)'`"; \
$(INSTALL_SCRIPT) $(srcdir)/$$p $(DESTDIR)$(bindir)/`echo $$p|sed '$(transform)'`; \
else :; fi; fi; \
done
uninstall-binSCRIPTS:
@$(NORMAL_UNINSTALL)
list='$(bin_SCRIPTS)'; for p in $$list; do \
rm -f $(DESTDIR)$(bindir)/`echo $$p|sed '$(transform)'`; \
done
tags: TAGS
TAGS:
distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
subdir = build
distdir: $(DISTFILES)
here=`cd $(top_builddir) && pwd`; \
top_distdir=`cd $(top_distdir) && pwd`; \
distdir=`cd $(distdir) && pwd`; \
cd $(top_srcdir) \
&& $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --gnu build/Makefile
@for file in $(DISTFILES); do \
d=$(srcdir); \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|| cp -p $$d/$$file $(distdir)/$$file; \
done
info:
dvi:
check: all
$(MAKE)
installcheck:
install-exec: install-binSCRIPTS
@$(NORMAL_INSTALL)
install-data:
@$(NORMAL_INSTALL)
install: install-exec install-data all
@:
uninstall: uninstall-binSCRIPTS
install-strip:
$(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' INSTALL_SCRIPT='$(INSTALL_PROGRAM)' install
installdirs:
$(mkinstalldirs) $(DATADIR)$(bindir)
mostlyclean-generic:
-test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES)
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-rm -f Makefile $(DISTCLEANFILES)
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
-test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
mostlyclean: mostlyclean-generic
clean: clean-generic mostlyclean
distclean: distclean-generic clean
-rm -f config.status
-rm -f libtool
maintainer-clean: maintainer-clean-generic distclean
@echo "This command is intended for maintainers to use;"
@echo "it deletes files that may require special tools to rebuild."
.PHONY: uninstall-binSCRIPTS install-binSCRIPTS tags distdir info dvi \
installcheck install-exec install-data install uninstall all \
installdirs mostlyclean-generic distclean-generic clean-generic \
maintainer-clean-generic clean mostlyclean distclean maintainer-clean
build-guile: build-guile.in
rm -f build-guile.tmp
sed < ${srcdir}/build-guile.in > build-guile.tmp \
-e s:@-bindir-@:${bindir}: \
-e s:@-GUILE_VERSION-@:${GUILE_VERSION}:
chmod +x build-guile.tmp
mv build-guile.tmp build-guile
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
guile-core/build/build-guile.in 644 521 17 14337 6560306032 15370 0 ustar guile users #!@-bindir-@/guile \
-e main -s
!#
;;;; build-guile --- utility for linking programs with Guile
;;;; Jim Blandy <jim@red-bean.com> --- September 1997
;;; TODO:
;;; * Add some plausible structure for returning the right exit status,
;;; just something that encourages people to do the correct thing.
;;; * Implement the static library support. This requires that
;;; some portion of the module system be done.
(use-modules (ice-9 regex)
(ice-9 string-fun))
;;;; main function, command-line processing
;;; The script's entry point.
(define (main args)
(set-program-name! (car args))
(let ((args (cdr args)))
(cond
((null? args) (show-help '())
(quit 1))
((assoc (car args) command-table)
=> (lambda (row)
(set! subcommand-name (car args))
((cadr row) (cdr args))))
(else (show-help '())
(quit 1)))))
(define program-name #f)
(define subcommand-name #f)
(define program-version "@-GUILE_VERSION-@")
;;; Given an executable path PATH, set program-name to something
;;; appropriate f or use in error messages (i.e., with leading
;;; directory names stripped).
(define (set-program-name! path)
(set! program-name
(cond
((string-match "/([^/]+)$" path)
=> (lambda (match) (match:substring match 1)))
(else path))))
(define (show-help args)
(cond
((null? args) (show-help-overview))
((assoc (car args) command-table)
=> (lambda (row) ((caddr row))))
(else
(show-help-overview))))
(define (show-help-overview)
(let ((dl display-line-error))
(dl "Usage: ")
(dl " " program-name " link - print libraries to link with")
;; Not yet implemented.
;; (dl " " program-name " main - generate initialization code")
(dl " " program-name " info [VAR] - print Guile build directories")
(dl " " program-name " --help - show usage info (this message)")
(dl " " program-name " --help SUBCOMMAND - show help for SUBCOMMAND")
(dl " " program-name " --version - show running version")))
(define (show-version args)
(display-line program-name " - Guile version " program-version))
;;;; the "link" subcommand
;;; Write a set of linker flags to standard output to include the
;;; libraries that libguile needs to link against.
;;;
;;; In the long run, we want to derive these flags from Guile module
;;; declarations files that are installed along the load path. For
;;; now, we're just going to reach into Guile's configuration info and
;;; hack it out.
(define (build-link args)
(if (> (length args) 0)
(error
(string-append program-name
" link: arguments to subcommand not yet implemented")))
(let* ((flags
(let loop ((libs
;; Get the string of linker flags we used to build
;; Guile, and break it up into a list.
(separate-fields-discarding-char #\space
(get-build-info 'LIBS)
list)))
(cond
((null? libs) '())
;; Turn any "FOO/libBAR.a" elements into "-lBAR".
((string-match "^.*/lib([^./]+).a$" (car libs))
=> (lambda (match)
(cons (string-append "-l" (match:substring match 1))
(loop (cdr libs)))))
;; Remove any empty strings that may have seeped in there.
((string=? (car libs) "") (loop (cdr libs)))
(else (cons (car libs) (loop (cdr libs)))))))
;; Don't omit -lguile itself from the list of flags.
(flags (cons "-lguile" flags)))
;; Display the flags, separated by spaces.
(display-separated flags)
(newline)))
(define (help-link)
(let ((dle display-line-error))
(dle "Usage: " program-name " link")
(dle "Print linker flags for building the `guile' executable.")
(dle "Print the linker command-line flags necessary to link against the")
(dle "Guile library, and any other libraries it requires.")))
;;;; The "main" subcommand
;;; We haven't implemented this yet, because we don't have the
;;; mechanisms in place to discover the installed static link
;;; libraries. When we do implement this, remember to fix the message
;;; in show-help-overview.
(define (build-main args)
(display-line-error program-name ": `main' subcommand not yet implemented")
(quit 2))
(define (help-main)
(let ((dle display-line-error))
(dle "Usage: " program-name " main")
(dle "This subcommand is not yet implemented.")))
;;;; The "info" subcommand
(define (build-info args)
(cond
((null? args) (show-all-vars))
((null? (cdr args)) (show-var (car args)))
(else (display-line-error "Usage: " program-name " info [VAR]")
(quit 2))))
(define (show-all-vars)
(for-each (lambda (binding)
(display-line (car binding) " = " (cdr binding)))
%guile-build-info))
(define (show-var var)
(display (get-build-info (string->symbol var)))
(newline))
(define (help-info)
(let ((dle display-line-error))
(dle "Usage: " program-name " info [VAR]")
(dle "Display the value of the Makefile variable VAR used when Guile")
(dle "was built. If VAR is omitted, display all Makefile variables.")
(dle "Use this command to find out where Guile was installed,")
(dle "where it will look for Scheme code at run-time, and so on.")))
;;;; trivial utilities
(define (get-build-info name)
(let ((val (assq name %guile-build-info)))
(if (not (pair? val))
(begin
(display-line-error
program-name " " subcommand-name ": no such build-info: " name)
(quit 2)))
(cdr val)))
(define (display-line . args)
(apply display-line-port (current-output-port) args))
(define (display-line-error . args)
(apply display-line-port (current-error-port) args))
(define (display-line-port port . args)
(for-each (lambda (arg) (display arg port))
args)
(newline))
(define (display-separated args)
(let loop ((args args))
(cond ((null? args))
((null? (cdr args)) (display (car args)))
(else (display (car args))
(display " ")
(loop (cdr args))))))
;;;; the command table
;;; We define this down here, so Guile builds the list after all the
;;; functions have been defined.
(define command-table
(list
(list "--version" show-version show-help-overview)
(list "--help" show-help show-help-overview)
(list "link" build-link help-link)
(list "main" build-main help-main)
(list "info" build-info help-info)))
;;; Local Variables:
;;; mode: scheme
;;; End:
guile-core/.cvsignore 644 521 17 133 6560306021 13462 0 ustar guile users Makefile
config.cache
config.log
config.status
guile-*.tar.gz
config.build-subdirs
libtool
guile-core/ANON-CVS 644 521 17 7277 6560306021 12631 0 ustar guile users Anonymous CVS access to Guile ========================================
We make the current Guile sources available via anonymous CVS. Please
keep in mind that these sources are strictly experimental; they will
usually not be well-tested, and may not even compile on some systems.
They may contain interfaces which will change. They will usually not
be of sufficient quality for use by people not comfortable hacking the
innards of Guile. Caveat!
However, we're providing them anyway for several reasons. We'd like
to encourage people to get involved in developing Guile. People
willing to use the bleeding edge of development can get earlier access
to new, experimental features. Patches submitted relative to recent
sources will be easier for us to evaluate and install, since the
patch's original sources will be closer to what we're working with.
And it allows us to start testing features earlier.
To check out a CVS working directory:
1) Install CVS version 1.9 or later on your system.
2) Log into the CVS server:
$ cvs -d :pserver:anoncvs@egcs.cygnus.com:/egcs/carton/cvsfiles login
At the prompt for `CVS password:', type `anoncvs'.
Once you have logged in, your password is saved in ~/.cvspass, and you
will not need to enter it again.
3) Check out a module:
$ cvs -z 9 -d :pserver:anoncvs@egcs.cygnus.com:/egcs/carton/cvsfiles checkout guile-core
This should create a new directory `guile-core' in your current
directory, and populate it with the current Guile sources.
The modules available for checkout are:
guile-core --- The scheme interpreter itself.
guile-doc --- Guile documentation-in-progress.
guile-tcltk --- An interface between Guile and Tcl/Tk.
guile-scsh --- An incomplete port of SCSH 0.4.4 to Guile.
guile-rgx-ctax --- This has been discontinued; use Andrew Archibald's
distribution instead:
ftp://ftp.red-bean.com/pub/guile/contrib/misc/guile-lang-allover-0.1.tar.gz
Once you have a working directory, you can bring it up to date easily
and efficiently:
1) Go to the top directory of the source tree. That is, your current
directory should be the one containing `configure.in', `README',
and so on.
2) Do the update:
$ cvs update
This will incorporate any changes the developers have made to Guile
since your last update into your source tree.
The EGCS Project is kindly lending us space, time, and bandwidth on
their CVS server. Thanks, folks!
Questions ============================================================
(I don't know if they'll be "frequently asked" or not yet!)
- It takes forever to do an update; what can I do to speed it up?
CVS tries to be smart about what it sends; it will transmit and
install only those files that have changed, and will sometimes
transmit and apply patches instead, to save transmission time.
It is also possible to have CVS compress transmitted data, using zlib.
Put the following line in your ~/.cvsrc file:
cvs -z 9
See the CVS documentation for more details.
- What happens if I've changed files in my working directory, and then
I do an update?
If you have made local changes to your sources, the `cvs update'
command will not overwrite them; instead, CVS will try to merge its
changes with your changes, as if you had applied a patch. Rejects are
marked in the sources.
- Why does the build process try to run autoconf, aclocal, or automake?
It shouldn't; if it does, that's a bug, I think. Those are the
tools we use to generate `configure', `aclocal.m4', and the
`Makefile.in' files from their respective sources. Ideally, you
shouldn't need to have them installed, if you don't want to change
those sources. If you do, see the section in `README' called
`Hacking It Yourself'.
guile-core/AUTHORS 644 521 17 4353 6560306021 12562 0 ustar guile users To find out what should go in this file, see "Information For
Maintainers of GNU Software" (maintain.texi), the section called
"Recording Changes".
Aubrey Jaffer:
is the author of SCM, the Scheme interpreter upon which Guile is
based. Guile started from SCM version 4e1 in November -94 and is
still largely composed of the original SCM code.
George Carrette:
wrote files present in Siod version 2.3, released in December of 1989.
Siod was the starting point for SCM. The major innovations taken from
Siod are the evaluator's use of the C-stack and being able to garbage
collect off the C-stack
Radey Shouman:
In the subdirectory libguile, wrote:
gsubr.c ramap.c unif.c
gsubr.h ramap.h unif.h
Gary Houston: changes to many files in libguile.
wrote: libguile/socket.c, ice-9/expect.scm
Tom Lord: Many changes throughout.
In the subdirectory ice-9, wrote:
Makefile.in configure.in lineio.scm poe.scm
boot-9.scm hcons.scm mapping.scm
Anthony Green: wrote the following files in libguile:
coop-defs.h coop-threads.h fsu-pthreads.h mit-pthreads.h threads.h
coop-threads.c coop.c mit-pthreads.c threads.c
and ice-9/threads.scm.
Mikael Djurfeldt:
In the subdirectory libguile, wrote:
backtrace.c debug.c options.c root.c srcprop.c stacks.c
backtrace.h debug.h options.h root.h srcprop.h stacks.h
iselect.c gdbint.c objects.c objprop.c stackchk.c
iselect.h gdbint.h objects.h objprop.h stackchk.h
gdb_interface.h
In the subdirectory libguile, rewrote:
coop-threads.c coop.c mit-pthreads.c threads.c print.c
coop-threads.h fsu-pthreads.h mit-pthreads.h threads.h print.h
Many other changes throughout.
Mark Galassi:
Designed and implemented the high-level libguile API (the @code{gh_}
interface), based largely on the defunct @code{gscm_} interface. In the
subdirectory libguile, wrote:
gh.h gh_funcs.c gh_list.c gh_test_repl.c
gh_data.c gh_init.c gh_predicates.c
gh_eval.c gh_io.c gh_test_c.c
Marius Vollmer:
In the subdirectory libguile, wrote:
fluids.c
fluids.h
In the subdirectory libguile, rewrote:
dynl.c dynl-dl.c dynl-shl.c
dynl.h dynl-dld.c
guile-core/COPYING 644 521 17 43105 6560306021 12563 0 ustar guile users GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
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
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
guile-core/ChangeLog 644 521 17 55554 6560306021 13315 0 ustar guile users 1998-07-30 Jim Blandy <jimb@zwingli.cygnus.com>
* configure.in: Don't use -Wstrict-prototypes after all.
* configure: Regenerated.
1998-07-29 Jim Blandy <jimb@zwingli.cygnus.com>
* configure.in: Request more warnings.
* configure: Regenerated.
* HACKING: Ask people not to make changes that introduce those
warnings. Now I have to go through the code and actually bring it
up to standards... :(
* Makefile.in, aclocal.m4, configure: Regenerated using the last
public version of automake, not the hacked Cygnus version.
* config.guess, config.sub, ltconfig, ltmain.sh: New versions from
libtool.
* configure.in, qthreads.m4: Display a message about how the
threads configuration went.
* aclocal.m4, configure: Regenerated.
1998-07-28 Jim Blandy <jimb@zwingli.cygnus.com>
Remove the TOTORO kludge. We're not doing snapshots any more, so
totoro is completely uninvolved. (Poor Totoro!)
* configure.in: Remove code to check the hostname and #define
TOTORO.
* acconfig.h: Remove comments for TOTORO symbol.
* configure, Makefile.in: Regenerated.
* qthreads.m4 (QTHREADS_CONFIGURE): We *can* use AC_REQUIRE here
to get AC_PROG_LN_S.
* aclocal.m4, configure: Regenerated.
1998-07-26 Jim Blandy <jimb@zwingli.cygnus.com>
Clean up thread configuration.
* qthreads.m4: New file, which knows how to configure the qthreads
library.
* configure.in: Replace all thread package selection code. Do the
--with-threads argument processing here. Enable the appropriate
thread interface files in libguile. Remove all qthreads
configuration code; call QTHREADS_CONFIGURE instead. Set
GUILE_LIBS using the info provided by QTHREADS_CONFIGURE.
* threads.m4: Removed; not used any more.
* Makefile.am (aclocal_DATA): Mention qthreads.m4, not threads.m4.
* Makefile.in, aclocal.m4, configure: Rgnrtd. (Sv th vwls!)
Note that these were regenerated with the tools available from
Cygnus's source tree, which have patches not available to the
general public. I'm not sure this was a good idea; feel free to
revert them to the latest released versions of the tools.
Upgrade to the version of libtool available at Cygnus. See note
above.
* config.guess, config.sub, ltconfig, ltmain.sh: Upgraded.
1998-07-12 Mikael Djurfeldt <mdj@barbara.nada.kth.se>
* configure.in: Changed variable HOSTNAME --> PROG_HOSTNAME in
totoro kludge.
Sat Jul 11 21:54:29 1998 Mikael Djurfeldt <mdj@totoro.red-bean.com>
* acconfig.h, configure.in: Define TOTORO if configuring on
totoro.red-bean.com.
* configure.in: Check for strdup.
1998-05-19 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in: Check for rl_cleanup_after_signal.
1998-05-11 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in: Added test for rl_getc_function. Warn if
libreadline is found but not this function.
1998-05-06 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in: Replaced some AC_CHECK_FUNC --> AC_CHECK_FUNCS so
that suitable HAVE_<function name> symbols get defined.
1998-04-25 Mikael Djurfeldt <mdj@kenneth>
* configure.in: Define USLEEP_RETURNS_VOID on some systems.
(Thanks to Julian Satchell.)
1998-04-20 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in: Check for usleep; Define DECLARE_BZERO and
DECLARE_USLEEP on Solaris 2.5 since it supplies those functions
without declaring them.
* acconfig.h: Added DECLARE_BZERO, DECLARE_USLEEP
1998-04-19 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in: Define HAVE_DLOPEN also when HAVE_LIBDL is
defined.
1998-04-18 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in (GUILE_LIBS): New variable. Contains libraries
which libguile needs to be linked with. Substituted into
libpath.h.
* threads.m4 (threads_package): Don't add $LDFLAGS and $LIBS to
$cy_cv_threads_libs.
1998-04-11 Mikael Djurfeldt <mdj@kenneth>
New libtool: 1.2
* ltconfig, ltmain.sh, config.sub, config.guess: Updated.
New automake: 1.3
* Makefile.in, aclocal.m4, configure: Regenerated.
* README: Mention new version numbers on libtool and automake.
1997-12-11 Tim Pierce <twp@skepsis.com>
* HACKING: Note that SSH is mandatory for CVS access.
Sun Dec 7 06:11:24 1997 Gary Houston <ghouston@actrix.gen.nz>
* README: using Automake 1.2d
* configure.in: AC_CHECK_FUNCS: add "system".
1997-12-01 Tim Pierce <twp@skepsis.com>
* acconfig.h: Add USCORE.
1997-11-27 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* configure.in: Added code to enable GUILE_ISELECT on systems
which have the necessary functions (gettimeofday, select).
* acconfig.h: Added GUILE_ISELECT.
1997-11-24 Tim Pierce <twp@twp.tezcat.com>
* acinclude.m4: Assume dlsym does not add underscore if
cross-compiling.
* aclocal.m4, configure: Regenderated.
1997-11-21 Tim Pierce <twp@twp.tezcat.com>
* acinclude.m4 (GUILE_DLSYM_USCORE): New macro, thanks Dan Hagerty
<hag@ai.mit.edu>.
* configure.in: Use it.
* configure: Regenerated.
* acconfig.h (DLSYM_ADDS_USCORE): New #define.
1997-10-26 Mikael Djurfeldt <mdj@nada.kth.se>
* README (libtool): Tell people to use version 1.0e.
Sat Oct 25 02:50:43 1997 Jim Blandy <jimb@totoro.red-bean.com>
Call the QuickThreads library libqthreads.a, not libqt.a. The old
name conflicts with the Qt user interface toolkit.
* threads.m4 (CY_AC_WITH_THREADS): Use new library name.
* configure.in: Same.
* aclocal.m4, configure: Regenerated.
Thu Oct 23 00:58:06 1997 Jim Blandy <jimb@totoro.red-bean.com>
* configure.in: Check for the readline library, and the termcap
library (on which readline relies).
* configure: Regenerated.
Wed Oct 22 16:55:57 1997 Jim Blandy <jimb@totoro.red-bean.com>
New libtool: 1.0e
* ltconfig, ltmain.sh, config.sub, config.guess: Updated.
* configure, aclocal.m4: Regenerated.
1997-10-02 Marius Vollmer <mvo@zagadka.ping.de>
Make dynamic linking work on Dec Unix. (Thanks to Clark McGrew)
* configure.in: Check whether dlopen can be found without -ldl.
Mon Sep 29 23:52:52 1997 Jim Blandy <jimb@totoro.red-bean.com>
* Makefile.in: Regenerated with automake 1.2c.
Sat Sep 27 23:01:58 1997 Jim Blandy <jimb@totoro.red-bean.com>
* Makefile.am: Add new `build' subdirectory to SUBDIRS.
* configure.in: Add build/Makefile to AC_OUTPUT clause.
* Makefile.in, configure: Regenerated.
* Makefile.in, aclocal.m4: Regenerated with automake 1.2a.
Tue Sep 16 00:19:46 1997 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* README, ltconfig, ltmain.sh: New libtool: 1.0c.
Thu Sep 11 11:28:24 1997 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* ltmain.sh: Added a missing '\' before \n on line 32.
Thu Aug 28 23:40:43 1997 Jim Blandy <jimb@totoro.red-bean.com>
New libtool: 1.0b.
* ltconfig, ltmain.sh, config.guess: Freshly libtoolized.
* Makefile.in, aclocal.m4, configure: Regenerated, salamander-style.
Wed Aug 27 11:35:09 1997 Jim Blandy <jimb@totoro.red-bean.com>
* Makefile.in: Regenerated, so it uses "tar", not "gtar".
* configure.in: Use the QuickThreads assembler fragment with Irix
dynamic linking support for Irix 6 as well as Irix 5. Thanks to
Jesse Glick.
* configure: Regenerated.
Sun Aug 24 15:51:12 1997 Mikael Djurfeldt <mdj@kenneth>
* acinclude.m4 (GUILE_NAMED_CHECK_FUNC): New macro: Tagged test,
so that test for the same function can be performed multiple
times.
* configure.in (AC_CHECK_HEADERS): Test for rxposix.h,
rx/rxposix.h. Add library rx only if regcomp can't be found
without it.
* acconfig.h (HAVE_REGCOMP): Added it here since autoheader misses
it for some reason!
Fri Aug 22 21:21:49 1997 Jim Blandy <jimb@totoro.red-bean.com>
* THANKS: New file.
* Makefile.in, aclocal.m4, configure: Regenerated.
Wed Jul 23 20:24:27 1997 Mikael Djurfeldt <djurf@zafir.e.kth.se>
* configure.in: Added thread support for the alpha architecture.
configure: Regenerated.
Thu Jul 17 07:56:05 1997 Gary Houston <ghouston@actrix.gen.nz>
* configure.in: use AC_CHECK_FUNCS for sethostent etc.,
so scmconfig.h is updated with the test results. this may
disable one of the cygwin hacks.
Fri Jul 11 00:18:19 1997 Jim Blandy <jimb@floss.red-bean.com>
Changes to compile under gnu-win32, from Marcus Daniels:
* configure.in: When sys/un.h exists, define HAVE_UNIX_DOMAIN_SOCKETS
to indicate that Unix domain sockets will work.
Check for socketpair, getgroups, setwent, pause, and tzset
(cygwin currently lacks these them).
Check for sethostent endhostent getnetent setnetent endnetent
getprotoent endprotoent getservent endservent getnetbyaddr
getnetbyname inet_lnaof inet_makeaddr inet_netof (cygwin currently
lacks them). In the case of cygwin, temporarily prefix these
functions with "cygwin32_", the way that netdb.h does.
Don't define HAVE_REGCOMP unless both regcomp and regex.h are
available (cygwin b18 came distributed without a working regex.h
file).
* acconfig.h (HAVE_UNIX_DOMAIN_SOCKETS): Add this.
* configure: Regenerated.
Wed Jul 2 12:28:40 1997 Tim Pierce <twp@twp.tezcat.com>
* ltmain.sh: Remove any trailing colon on $shlibpath_var
(i.e. LD_LIBRARY_PATH) for braindamaged linkers that choke on it.
Patch sent to bug-libtool.
Sat Jun 28 16:13:43 1997 Tim Pierce <twp@twp.tezcat.com>
* configure.in: Add alloca.o explicitly to LIBOBJS (thanks Eric
Backus for reporting this problem and suggesting a fix).
* configure: Regenerated.
Thu Jun 26 20:43:31 1997 Jim Blandy <jimb@floss.red-bean.com>
* Guile 1.2 released.
* configure.in: Check for librx after libm; fundamentals need to
come first.
* configure: Regenerated.
Tue Jun 24 13:34:20 1997 Tim Pierce <twpierce@bio-5.bsd.uchicago.edu>
* aclocal.m4 (AM_PATH_PROG_LD): Change `ac_cv_path_LD' typo to
`am_cv_path_LD'.
* configure: Regenerated.
Sun Jun 22 15:43:07 1997 Jim Blandy <jimb@floss.red-bean.com>
Try to detect when people are using one version of libguile and a
different version of ice-9. People have been skewing things and
sending in bug reports.
* configure.in: Provide libguile its version information through a
separate header file generated by the Makefile, not through
scmconfig.h.
(GUILE_MAJOR_VERSION, GUILE_MINOR_VERSION, GUILE_VERSION):
AC_SUBST these, instead of AC_DEFINE'ing them.
(GUILE_STAMP): New AC_SUBST: the time we configured the tree.
(AC_OUTPUT): Create ice-9/version.scm.
* acconfig.h (GUILE_MAJOR_VERSION, GUILE_MINOR_VERSION,
GUILE_VERSION): Deleted.
* Makefile.in: Regenerated.
* aclocal.m4: Regenerated, using the libtool 0.9h m4 macros.
* Makefile.am (EXTRA_DIST): Include acconfig.h in the
distribution.
* Makefile.in: Regenerated.
Sat Jun 21 00:14:07 1997 Jim Blandy <jimb@floss.red-bean.com>
* ltmain.sh (line 1191): Don't forget 'test' in if statement.
* ltconfig, ltmain.sh: libtoolized, using libtool 0.9h.
Wed Jun 11 00:34:01 1997 Jim Blandy <jimb@floss.red-bean.com>
* ltconfig, ltmain.sh, config.guess: New files from libtool 0.9g.
* configure.in: By default, include functions in Guile to allow
linking with dynamic libraries at run-time. In other words,
--enable-dynamic-linking is now the default.
* configure: Rebuilt.
* configure.in: Remove space between AC_CHECK_LIB and opening
paren in check for Rx.
* configure: Regenerated.
* configure.in: Remove all mention of xtra_PLUGIN_guile_libs.
It's never used.
* configure, Makefile.in: Regenerated.
Tue Jun 10 23:37:12 1997 Jim Blandy <jimb@floss.red-bean.com>
* configure.in: Move checks for libraries (-lm, -lnsl, -lsocket,
-dl, -dld) before checks for functions.
* configure: Regenerated.
Mon Jun 9 02:35:46 1997 Tim Pierce <twp@twp.tezcat.com>
* config.guess: New copy from autoconf-2.12, which recognizes
OpenBSD.
Tue Jun 3 16:34:19 1997 Jim Blandy <jimb@totoro.cyclic.com>
* configure.in: Check for Rx, so we will use its routines (which I
pretty much trust) if it is installed.
* configure: Regenerated.
Sat May 31 03:48:45 1997 Gary Houston <ghouston@actrix.gen.nz>
* acconfig.h: mention HAVE_RESTARTS.
* configure.in: check for sigaction and restartable system calls.
Tue May 27 22:47:52 1997 Tim Pierce <twp@twp.tezcat.com>
* configure.in: Check for presence of regcomp.
* configure: Regenerated.
Mon May 26 12:14:20 1997 Jim Blandy <jimb@floss.cyclic.com>
* COPYING: New address for FSF.
* configure.in: We don't need to add fileblocks.o to LIBOBJS if
struct stat doesn't have the st_blocks field. We take care of
that case in the code. Replace AC_STRUCT_ST_BLOCKS with its
definition, edited appropriately. (Bernard URBAN)
* configure: Regenerated.
Sat May 17 13:49:28 1997 Jim Blandy <jimb@floss.cyclic.com>
* configure.in: Don't link against -lnsl or -lsocket unless we
actually need to. This causes trouble on Irix. (Thanks to Larry
Schwimmer.)
* config.sub: Get newer version, that recognizes the i686.
Fri May 16 17:26:10 1997 Jim Blandy <jimb@totoro.cyclic.com>
* README: Changed Mikael's threads work attribution in order
to sooth Anthony's enormous, but wounded, ego.
Fri May 16 17:26:53 1997 Jim Blandy <jimb@totoro.cyclic.com>
Just kidding!!!
Fri May 16 04:24:48 1997 Jim Blandy <jimb@floss.cyclic.com>
Guile 1.1 released.
* GUILE-VERSION: Bump to 1.1.
Tue May 13 16:34:40 1997 Jim Blandy <jimb@floss.cyclic.com>
Switch to automake-1.1p.
* Makefile.in, aclocal.m4, configure: Regenerated.
Mon May 12 18:29:45 1997 Jim Blandy <jimb@floss.cyclic.com>
* threads.m4: Copy Anthony's change here, so it'll actually
survive.
Thu May 8 11:48:40 1997 Anthony Green <green@hoser.cygnus.com>
* aclocal.m4: Fixes for building with coop threads in a
seperate compilation directory.
* configure: Rebuilt.
Fri May 2 16:24:15 1997 Jim Blandy <jimb@floss.cyclic.com>
Upgrade to libtool 0.9e.
* ltconfig, ltmain.sh, config.guess, config.sub: New versions,
supplied by libtool.
* configure.in: When configuring qt, sunos needs the underscore
files; Solaris and Linux both need the normal files.
* configure: Reebilt.
Thu May 1 15:35:49 1997 Jim Blandy <jimb@floss.cyclic.com>
* configure.in: Get the paths for qt's md files right, so it can
build correctly when using a separate compilation directory.
* configure: Regenerated.
Thu Apr 24 01:20:34 1997 Jim Blandy <jimb@floss.cyclic.com>
Get threads to work again.
* Makefile.am (SUBDIRS): List libguile last, so qt gets built
first.
* Makefile.in: Regenerated.
* aclocal.m4, configure: Regenerate, with modern definition of
CY_AC_WITH_THREADS. Where did the old text come from? Creepy...
Reduced Guile distribution: one configure script, no plugins.
* configure.in: Merged the old text from qt/configure.in and
libguile/configure.in; Tom Tromey says automake only wants one
configure.in script. This seems fishy, but...
* Makefile.am: List the subdirectories explicitly; no more PLUGIN
gubbish.
* acconfig.h, acinclude.m4: Moved here from libguile, since
libguile's configure script lives here now.
* AUTHORS, INSTALL, README: Updated.
* Makefile.in, aclocal.m4 configure: Regenerated. Just like
amputated amphibian limbs.
Tue Apr 22 16:57:38 1997 Jim Blandy <jimb@totoro.cyclic.com>
* newdoc/ref/Makefile.am (dist_texis): Distribute the index files.
* newdoc/ref/Makefile.in: Regenerated.
Mon Apr 14 18:51:25 1997 Jim Blandy <jimb@floss.cyclic.com>
* threads.m4 (CY_AC_WITH_THREADS): When using coop threads, no
need to link against libthreads; the files it used to contain
are now a part of libguile.
Sun Apr 13 22:14:10 1997 Jim Blandy <jimb@floss.cyclic.com>
* guile.m4: Revert change of Mar 15, and use the new 'no-define'
argument to the AM_INIT_AUTOMAKE macro.
Fri Apr 11 15:43:07 1997 Jim Blandy <jimb@totoro.cyclic.com>
* ltconfig, ltmain.sh: Upgraded libtool files to 0.9d.
* README: Say where to find libtool 0.9d.
Wed Apr 9 17:51:13 1997 Jim Blandy <jimb@floss.cyclic.com>
Changes to work with automake-1.1n, which has better libtool
support. Also use libtool 0.8.
* README: Note new version numbers for automake and libtool.
* missing: New file required by new automake.
* Makefile.in: Regenerated.
Sat Apr 5 16:48:38 1997 Jim Blandy <jimb@floss.cyclic.com>
* newdoc/ref/scheme.texi (set-object-property!): Fix function name.
* Makefile.am: Omit doc subtree.
* configure.in: Omit makefiles in doc subtree.
* Makefile.in, configure: Rebuilt.
Sat Mar 15 01:11:44 1997 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* guile.m4 (AM_INIT_GUILE_MODULE): Replaced AM_INIT_AUTOMAKE macro
with its definition and commented out definition of PACKAGE. This
changed seemed necessary after having removed PACKAGE from
libguile/acconfig.h.
Mon Feb 24 21:43:26 1997 Mikael Djurfeldt <mdj@mdj.nada.kth.se>
* ltconfig, ltmain.sh: New versions from libtool-0.9.
* configure.in: Added AM_MAINTAINER_MODE
Fri Feb 7 17:57:46 1997 Jim Blandy <jimb@floss.cyclic.com>
* config.sub, config.guess: New versions, that handle i686, etc.
Thu Jan 23 07:06:15 1997 Mark Galassi <rosalia@papageno.lanl.gov>
* newdoc/tutorial/guile-tut.texi: started checking in the Guile
tutorial rewrite, but have not merged much into it yet.
Tue Jan 21 17:28:40 1997 Mark Galassi <rosalia@sarastro.lanl.gov>
* newdoc/ref/guile-ref.texi: started checking in parts of the
reference manual re-write.
Sat Jan 11 14:40:17 1997 Marius Vollmer <mvo@zagadka.ping.de>
* ltconfig, ltmain.sh: New files for libtool support. libguile,
rx, gh and gtcltk-lib can now be build as shared libraries.
* Makefile.am (EXTRA_DIST): Added ltconfig and ltmain.sh
Sun Jan 5 16:57:10 1997 Jim Blandy <jimb@floss.cyclic.com>
* Guile 1.0 released. This is the first release by the Free
Software Foundation; Cygnus has also released earlier versions of
Guile.
* GUILE-VERSION: Updated version number.
* NEWS: Added comments for all the user-visible changes marked in
the ChangeLogs.
* README: Updated for release.
Thu Dec 12 00:14:32 1996 Gary Houston <ghouston@actrix.gen.nz>
* scsh: new directory.
Mon Dec 2 17:33:04 1996 Tom Tromey <tromey@cygnus.com>
* configure.in: Generate doc/guile-programmer/Makefile and
doc/guile-user/Makefile.
Sat Nov 30 23:45:54 1996 Tom Tromey <tromey@cygnus.com>
* aclocal.m4: Now automatically generated by aclocal.
* threads.m4: New file.
* guile.m4: New file.
* Makefile.am, doc/Makefile.am: New files.
* configure.in: Updated for Automake. Avoid excessively verbose
"greet" messages.
Wed Oct 16 07:32:14 1996 Mark Galassi <rosalia@sarastro.lanl.gov>
* lgh: directory renamed to gh, along with all prefixes of the
high level library procedures.
Thu Oct 10 14:37:43 1996 Jim Blandy <jimb@floss.cyclic.com>
* Makefile.in (TAGS tags): Find the source files in $srcdir.
Wed Oct 9 19:37:14 1996 Jim Blandy <jimb@floss.cyclic.com>
* Makefile.in (DISTFILES): Add AUTHORS and aclocal.m4.
Tue Oct 1 00:13:55 1996 Mikael Djurfeldt <mdj@woody.nada.kth.se>
* configure.in: Added some configuration magic from the Cygnus
distribution.
* aclocal.m4: New file. For now used for thread support
configuration.
Fri Sep 13 14:39:30 1996 Mark Galassi <rosalia@sarastro.lanl.gov>
* Makefile.in (DISTFILES): added mkinstalldirs to the DISTFILES
* PLUGIN: changed the PLUGIN/REQ files in the ice-9 and lgh
directories, to arrange for lgh to the last thing
configured/built.
Wed Sep 11 21:11:33 1996 Mark Galassi <rosalia@nis.lanl.gov>
* lgh/: added the directory in which I implement the high level
libguile library (lgh_) for this release of Guile. See the
ChangeLog in there for further details.
Wed Sep 11 16:12:53 1996 Mark Galassi <rosalia@sarastro.lanl.gov>
* doc/ (guile-user and guile-programmer): added the guile-user and
guile-programmer directories which contain the user and programmer
manuals. See the ChangeLog entries there for detail.
Wed Sep 11 14:33:49 1996 Jim Blandy <jimb@floss.cyclic.com>
* Makefile.in (distclean): Don't forget to delete doc/Makefile.
* Makefile.in (distclean): Don't forget to delete
config.build-subdirs.
Thu Sep 5 17:36:15 1996 Jim Blandy <jimb@floss.cyclic.com>
* Makefile.in (tags): New name for `TAGS' target, which will
always run the commands.
Thu Sep 5 09:56:50 1996 Jim Blandy <jimb@totoro.cyclic.com>
* README: Doc fixes.
Fri Aug 30 16:56:27 1996 Jim Blandy <jimb@floss.cyclic.com>
* Makefile.in (TAGS): Produce a single tags file for all of Guile.
Thu Aug 15 19:03:03 1996 Jim Blandy <jimb@floss.cyclic.com>
* configure.in: Check for -ldl, so the check for Tcl won't fail
spuriously.
Thu Aug 15 01:29:29 1996 Jim Blandy <jimb@totoro.cyclic.com>
Change the way we decide whether to build gtcltk-lib, so that it's
omitted from the build process when appropriate, but never from
the dist process.
* configure.in: Don't edit all_subdirs depending on the
availability of Tk; let that be the list of all PLUGIN
subdirectories present, as it used to be. Instead, edit a new
variable, build_subdirs; write its final value, the list of
subdirs we do want to compile in, to config.build-subdirs.
Substitute that into the top-level Makefile too.
* Makefile.in (subdirs): Set this to @build_subdirs@, so we only
recurse on the subdirectories we should build.
(distdirs): Set this to @existingdirs@, so it includes the subdirs
we decided not to build.
* doc/gtcltk.texi: File resurrected from old Guile releases.
* doc/Makefile.in (info): Build the gtcltk documentation.
(DIST_FILES): Include it in the distribution.
* configure.in: If we can find the library for tcl7.5, build
gtcltk-lib. Call AC_PROG_CC, to help run that test with the right
compiler (not sure this is necessary).
Mon Aug 12 15:09:37 1996 Jim Blandy <jimb@totoro.cyclic.com>
* NEWS: Fix bug reporting address.
Fri Aug 9 15:58:42 1996 Jim Blandy <jimb@totoro.cyclic.com>
* AUTHORS: New file, in accordance with the GNU maintainers'
standards.
Tue Aug 6 14:40:44 1996 Jim Blandy <jimb@totoro.cyclic.com>
* README: Renamed from ANNOUNCE; include bug report address,
description, and short tour.
* INSTALL: Renamed from BUILDING.
* NEWS: New file.
* Makefile.in (DISTFILES): Update appropriately.
Thu Aug 1 02:31:53 1996 Jim Blandy <jimb@totoro.cyclic.com>
* doc/Makefile.in: Added pattern targets for creating DVI and
PostScript files.
(%.ps, %.dvi, %.txt): New targets.
(DVIPS, TEXI2DVI): New variables.
* GUILE-VERSION: Updated to 1.0b3.
Rehashed distribution system, in preparation for nightly
snapshots. Other changes in subdirectories.
* Makefile.in (dist): Rewritten --- the old target was out of
date, dependent on files that we don't have, and relied on GNU
tar. The new target is simpler.
(VERSION, srcdir, dist_dirs): New variables.
(DISTFILES): Renamed from localfiles. Added GUILE-VERSION and
TODO.
(localtreats): Variable removed. We don't have this file.
(info): cd to doc and make info there; don't make info in every
${subdir}; those Makefiles don't know what to do.
(distname, distdir, treats, announcefile): Variables removed.
(manifest-file): Target removed.
(dist-dir): New target, responsible for distributable files in
this directory.
(GZIP, GZIP_EXT, TAR_VERBOSE, DIST_NAME): New variables,
controlling the 'dist' target.
* configure.in: Substitute GUILE-VERSION into the top-level
Makefile. Build doc/Makefile from doc/Makefile.in.
* doc/Makefile.in: New file.
guile-core/GUILE-VERSION 644 521 17 233 6560306021 13376 0 ustar guile users GUILE_MAJOR_VERSION=1
GUILE_MINOR_VERSION=3a
GUILE_VERSION=$GUILE_MAJOR_VERSION.$GUILE_MINOR_VERSION
# For automake.
VERSION=$GUILE_VERSION
PACKAGE=guile
guile-core/HACKING 644 521 17 13056 6560306021 12521 0 ustar guile users Here are some guidelines for members of the Guile developers team.
CVS conventions ======================================================
- We use CVS to manage the Guile sources. The repository lives on
egcs.cygnus.com, in /egcs/carton/cvsfiles; you will need an account on
that machine to access the repository. Also, for security reasons,
egcs presently only supports CVS connections via the SSH protocol, so
you must first install the SSH client. Then, you should set your
CVS_RSH environment variable to ssh, and use the following as your CVS
root:
:ext:USER@egcs.cygnus.com:/egcs/carton/cvsfiles
Either set your CVSROOT environment variable to that, or give it as
the value of the global -d option to CVS when you check out a working
directory.
For more information on SSH, see http://www.cs.hut.fi/ssh.
The Guile sources live in several modules:
- guile-core --- the interpreter, QuickThreads, and ice-9
- guile-doc --- documentation in progress. When complete, this will
be incorporated into guile-core.
- guile-tcltk --- the Guile/Tk interface
- guile-tk --- the new Guile/Tk interface, based on STk's modified Tk
- guile-rgx-ctax --- the Guile/Rx interface, and the ctax implementation
- guile-scsh --- the port of SCSH to guile, talk to Gary Houston
- guile-comp --- the Hobbit compiler (talk to mdj)
- guile-emacs --- Guile/Emacs interface (talk to mdj)
- guile-oops --- The Guile Object-Oriented Programming System (talk to mdj)
- guile-www --- A Guile module for making HTTP requests.
- We check Makefile.in and configure files into CVS, as well as the
files they are built from (Makefile.am, configure.in); we do not check
in Makefiles or header files generated by configuration scripts. The
general rule is that you should be able to check out a working
directory of Guile from CVS, and then type "configure" and "make",
without running any other tools.
- Make sure your changes compile and work, at least on your own
machine, before checking them into the main branch of the Guile
repository. If you really need to check in untested changes, make a
branch.
- Include each log entry in both the ChangeLog and in the CVS logs.
If you're using Emacs, the pcl-cvs interface to CVS has features to
make this easier; it checks the ChangeLog, and generates good default
CVS log entries from that.
Coding standards =====================================================
- As for any part of Project GNU, changes to Guile should follow the
GNU coding standards. The standards are available via anonymous FTP
from prep.ai.mit.edu, as /pub/gnu/standards/standards.texi and
make-stds.texi.
- The Guile tree should compile without warnings under the following
GCC switches, which are the default in the current configure script:
-Wall -Wpointer-arith -Wstrict-prototypes -Wmissing-prototypes
The only exceptions are the warnings about variables being clobbered
by longjmp/vfork in eval.c. (Tho' if you can figure out how to get
rid of those, too, I'd be happy.)
- When you make a user-visible change (i.e. one that should be
documented, and appear in NEWS, put an asterisk in column zero of the
start of the ChangeLog entry, like so:
Sat Aug 3 01:27:14 1996 Gary Houston <ghouston@actrix.gen.nz>
* * fports.c (scm_open_file): don't return #f, throw error.
When you've written a NEWS entry and updated the documentation, go
ahead and remove the asterisk. I will use the asterisks to find and
document changes that haven't been dealt with before a release.
- There's no need to keep a change log for documentation files. This
is because documentation is not susceptible to bugs that are hard to
fix. Documentation does not consist of parts that must interact in a
precisely engineered fashion; to correct an error, you need not know
the history of the erroneous passage. (This is copied from the GNU
coding standards.)
- Make sure you have papers from people before integrating their
changes or contributions. This is very frustrating, but very
important to do right. From maintain.texi, "Information for
Maintainers of GNU Software":
When incorporating changes from other people, make sure to follow the
correct procedures. Doing this ensures that the FSF has the legal
right to distribute and defend GNU software.
For the sake of registering the copyright on later versions ofthe
software you need to keep track of each person who makes significant
changes. A change of ten lines or so, or a few such changes, in a
large program is not significant.
*Before* incorporating significant changes, make sure that the person
has signed copyright papers, and that the Free Software Foundation has
received them.
If you receive contributions you want to use from someone, let me know
and I'll take care of the administrivia. Put the contributions aside
until we have the necessary papers.
- When you make substantial changes to a file, add the current year to
the list of years in the copyright notice at the top of the file.
Helpful hints ========================================================
- [From Mikael Djurfeldt] When working on the Guile internals, it is
quite often practical to implement a scheme-level procedure which
helps you examine the feature you're working on.
Examples of such procedures are: pt-size, debug-hand and
current-pstate.
I've now put #ifdef GUILE_DEBUG around all such procedures, so that
they are not compiled into the "normal" Guile library. Please do the
same when you add new procedures/C functions for debugging purpose.
You can define the GUILE_DEBUG flag by passing --enable-guile-debug to
the configure script.
Jim Blandy
guile-core/INSTALL 644 521 17 22224 6560306022 12561 0 ustar guile users Brief Installation Instructions ===========================================
To build Guile on unix, there are two basic steps:
1. Type "./configure", to configure the package for your system.
2. Type "make", to build the package.
Generic instructions for configuring and compiling GNU distributions
are included below.
Special Instructions For Some Systems =====================================
We would like Guile to build on all systems using the simple
instructions above, but it seems that a few systems still need special
treatment. If you can send us fixes for these problems, we'd be
grateful.
SunOS 4.1: Guile's shared library support seems to be confused, but
hey; shared libraries are confusing. You may need to configure
Guile with a command like:
./configure --disable-shared
For more information on `--disable-shared', see below, "Flags
Accepted by Configure".
HP/UX: GCC 2.7.2 (and maybe other versions) have trouble creating
shared libraries if they depend on any non-shared libraries. GCC
seems to have other problems as well. To work around this, we
suggest you configure Guile to use the system's C compiler:
CC=cc ./configure
What You Get ==============================================================
The `configure' script examines your system, and adapts Guile to
compile and run on it.
The `make' command builds several things:
- An executable file `guile/guile', which is an interactive shell for
talking with the Guile Scheme interpreter.
- An object library `libguile/.libs/libguile.a', containing the Guile Scheme
interpreter, ready to be linked into your programs.
To install Guile, type `make install'. This installs the executable
and libraries mentioned above, as well as Guile's header files and
Scheme libraries.
Make also builds shared libraries, on systems that support them.
Because of the nature of shared libraries, before linking against
them, you should probably install them; `make install' takes care of
this.
Flags Accepted by Configure ===============================================
If you run the configure script with no arguments, it should examine
your system and set things up appropriately. However, there are a few
switches specific to Guile you may find useful in some circumstances.
--enable-maintainer-mode --- If you have automake, autoconf, and
libtool installed on your system, this switch causes configure to
generate Makefiles which know how to automatically regenerate
configure scripts, makefiles, and headers, when they are out of date.
The README file says which versions of those tools you will need.
--with-threads --- Build a Guile executable and library that supports
cooperative threading. If you use this switch, Guile will also build
and install the QuickThreads non-preemptive threading library,
libqt.a, which you will need to link into your programs after
libguile.a. That is, you should pass the switches -lguile -qt to your
linker.
Coop threads are not yet thoroughly tested; once they are, they will
be enabled by default. The interaction with blocking I/O is pretty ad
hoc at the moment. In our experience, bugs in the thread support do
not affect you if you don't actually use threads.
At the moment, threads are known not to work with the NetBSD 1.2
assembler.
--enable-dynamic-linking --- Build a Guile executable and library
providing Scheme functions which can load a shared library and
initialize it, perhaps thereby adding new functions to Guile. This
feature is not yet thoroughly tested; once it is, it will be enabled
by default. This option has no effect on systems that do not support
shared libraries.
--disable-shared --- Do not build shared libraries. Normally, Guile
will build shared libraries if your system supports them. Guile
always builds static libraries.
Using Guile Without Installing It =========================================
If you want to run Guile without installing it, set the environment
variable `GUILE_LOAD_PATH' to a colon-separated list of directories,
including the directory containing this INSTALL file. If you used a
separate build directory, you'll need to include the build directory
in the path as well.
For example, suppose the Guile distribution unpacked into a directory
called `/home/jimb/guile-snap' (so the full name of this file would be
`/home/jimb/guile-snap/INSTALL'). Then you might say:
export GUILE_LOAD_PATH=/home/jimb/guile-snap
if you're using Bash or any other Bourne shell variant, or
setenv GUILE_LOAD_PATH /home/jimb/guile-snap
if you're using CSH or one of its variants.
If you built Guile in a separate directory from the source tree, then
you'll need to include your build directory in the GUILE_LOAD_PATH as
well. For example, if you built in a subdirectory of the source tree
called `pentium', you might say:
export GUILE_LOAD_PATH=/home/jimb/guile-snap:/home/jimb/guile-snap/pentium
Building a Statically Linked Guile ========================================
Sometimes it's useful to build a statically-linked version of the
Guile executable. It's helpful in debugging, and for producing
stand-alone executables for distribution to machines you don't
control.
To do this, set the LDFLAGS environment variable to `-static' before
you configure, or before you run the `make' command to build the
executable.
Generic Instructions for Building Auto-Configured Packages ================
To compile this package:
1. Configure the package for your system. In the directory that this
file is in, type `./configure'. If you're using `csh' on an old
version of System V, you might need to type `sh configure' instead to
prevent `csh' from trying to execute `configure' itself.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation, and
creates the Makefile(s) (one in each subdirectory of the source
directory). In some packages it creates a C header file containing
system-dependent definitions. It also creates a file `config.status'
that you can run in the future to recreate the current configuration.
Running `configure' takes a minute or two.
To compile the package in a different directory from the one
containing the source code, you must use GNU make. `cd' to the
directory where you want the object files and executables to go and
run `configure' with the option `--srcdir=DIR', where DIR is the
directory that contains the source code. Using this option is
actually unnecessary if the source code is in the parent directory of
the one in which you are compiling; `configure' automatically checks
for the source code in `..' if it does not find it in the current
directory.
By default, `make install' will install the package's files in
/usr/local/bin, /usr/local/lib, /usr/local/man, etc. You can specify
an installation prefix other than /usr/local by giving `configure' the
option `--prefix=PATH'. Alternately, you can do so by changing the
`prefix' variable in the Makefile that `configure' creates (the
Makefile in the top-level directory, if the package contains
subdirectories).
You can specify separate installation prefixes for machine-specific
files and machine-independent files. If you give `configure' the
option `--exec_prefix=PATH', the package will use PATH as the prefix
for installing programs and libraries. Normally, all files are
installed using the same prefix.
`configure' ignores any other arguments that you give it.
If your system requires unusual options for compilation or linking
that `configure' doesn't know about, you can give `configure' initial
values for some variables by setting them in the environment. In
Bourne-compatible shells, you can do that on the command line like
this:
CC='gcc -traditional' DEFS=-D_POSIX_SOURCE ./configure
The `make' variables that you might want to override with environment
variables when running `configure' are:
(For these variables, any value given in the environment overrides the
value that `configure' would choose:)
CC C compiler program.
Default is `cc', or `gcc' if `gcc' is in your PATH.
INSTALL Program to use to install files.
Default is `install' if you have it, `cp' otherwise.
INCLUDEDIR Directory for `configure' to search for include files.
Default is /usr/include.
(For these variables, any value given in the environment is added to
the value that `configure' chooses:)
DEFS Configuration options, in the form '-Dfoo -Dbar ...'
LIBS Libraries to link with, in the form '-lfoo -lbar ...'
If you need to do unusual things to compile the package, we encourage
you to teach `configure' how to do them and mail the diffs to the
address given in the README so we can include them in the next
release.
2. Type `make' to compile the package.
3. Type `make install' to install programs, data files, and
documentation.
4. You can remove the program binaries and object files from the
source directory by typing `make clean'. To also remove the
Makefile(s), the header file containing system-dependent definitions
(if the package uses one), and `config.status' (all the files that
`configure' created), type `make distclean'.
The file `configure.in' is used as a template to create `configure' by
a program called `autoconf'. You will only need it if you want to
regenerate `configure' using a newer version of `autoconf'.
guile-core/Makefile.am 644 521 17 552 6560306022 13524 0 ustar guile users ## Process this file with automake to produce Makefile.in.
SUBDIRS = ice-9 qt libguile build
## FIXME: in the future there will be direct automake support for
## doing this. When that happens, switch over.
aclocaldir = $(datadir)/aclocal
aclocal_DATA = guile.m4 qthreads.m4
EXTRA_DIST = $(aclocal_DATA) ltconfig ltmain.sh acconfig.h \
HACKING GUILE-VERSION
guile-core/Makefile.in 644 521 17 24770 6560306022 13605 0 ustar guile users # Makefile.in generated automatically by automake 1.3 from Makefile.am
# Copyright (C) 1994, 1995, 1996, 1997, 1998 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
SHELL = /bin/sh
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
sharedstatedir = @sharedstatedir@
localstatedir = @localstatedir@
libdir = @libdir@
infodir = @infodir@
mandir = @mandir@
includedir = @includedir@
oldincludedir = /usr/include
DISTDIR =
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
top_builddir = .
ACLOCAL = @ACLOCAL@
AUTOCONF = @AUTOCONF@
AUTOMAKE = @AUTOMAKE@
AUTOHEADER = @AUTOHEADER@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
transform = @program_transform_name@
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
host_alias = @host_alias@
host_triplet = @host@
AWK = @AWK@
CC = @CC@
CPP = @CPP@
GUILE_LIBS = @GUILE_LIBS@
GUILE_MAJOR_VERSION = @GUILE_MAJOR_VERSION@
GUILE_MINOR_VERSION = @GUILE_MINOR_VERSION@
GUILE_STAMP = @GUILE_STAMP@
GUILE_VERSION = @GUILE_VERSION@
LD = @LD@
LIBLOBJS = @LIBLOBJS@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@
MAINT = @MAINT@
MAKEINFO = @MAKEINFO@
NM = @NM@
PACKAGE = @PACKAGE@
QTHREAD_LTLIBS = @QTHREAD_LTLIBS@
RANLIB = @RANLIB@
THREAD_CPPFLAGS = @THREAD_CPPFLAGS@
THREAD_LIBS_INSTALLED = @THREAD_LIBS_INSTALLED@
THREAD_LIBS_LOCAL = @THREAD_LIBS_LOCAL@
THREAD_PACKAGE = @THREAD_PACKAGE@
VERSION = @VERSION@
qtdmdb_s = @qtdmdb_s@
qtmd_h = @qtmd_h@
qtmdc_c = @qtmdc_c@
qtmds_s = @qtmds_s@
SUBDIRS = ice-9 qt libguile build
aclocaldir = $(datadir)/aclocal
aclocal_DATA = guile.m4 qthreads.m4
EXTRA_DIST = $(aclocal_DATA) ltconfig ltmain.sh acconfig.h \
HACKING GUILE-VERSION
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
CONFIG_HEADER = ./libguile/scmconfig.h
CONFIG_CLEAN_FILES =
DATA = $(aclocal_DATA)
DIST_COMMON = README AUTHORS COPYING ChangeLog INSTALL Makefile.am \
Makefile.in NEWS THANKS TODO acinclude.m4 aclocal.m4 config.guess \
config.sub configure configure.in install-sh ltconfig ltmain.sh \
mdate-sh missing mkinstalldirs
DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = tar
GZIP = --best
all: all-recursive all-am
.SUFFIXES:
$(srcdir)/Makefile.in: @MAINT@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4)
cd $(top_srcdir) && $(AUTOMAKE) --gnu Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status $(BUILT_SOURCES)
cd $(top_builddir) \
&& CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status
$(ACLOCAL_M4): @MAINT@ configure.in acinclude.m4
cd $(srcdir) && $(ACLOCAL)
config.status: $(srcdir)/configure
$(SHELL) ./config.status --recheck
$(srcdir)/configure: @MAINT@$(srcdir)/configure.in $(ACLOCAL_M4) $(CONFIGURE_DEPENDENCIES)
cd $(srcdir) && $(AUTOCONF)
install-aclocalDATA: $(aclocal_DATA)
@$(NORMAL_INSTALL)
$(mkinstalldirs) $(DESTDIR)$(aclocaldir)
@list='$(aclocal_DATA)'; for p in $$list; do \
if test -f $(srcdir)/$$p; then \
echo " $(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(aclocaldir)/$$p"; \
$(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(aclocaldir)/$$p; \
else if test -f $$p; then \
echo " $(INSTALL_DATA) $$p $(DESTDIR)$(aclocaldir)/$$p"; \
$(INSTALL_DATA) $$p $(DESTDIR)$(aclocaldir)/$$p; \
fi; fi; \
done
uninstall-aclocalDATA:
@$(NORMAL_UNINSTALL)
list='$(aclocal_DATA)'; for p in $$list; do \
rm -f $(DESTDIR)$(aclocaldir)/$$p; \
done
# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
# (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
@SET_MAKE@
all-recursive install-data-recursive install-exec-recursive \
installdirs-recursive install-recursive uninstall-recursive \
check-recursive installcheck-recursive info-recursive dvi-recursive:
@set fnord $(MAKEFLAGS); amf=$$2; \
list='$(SUBDIRS)'; for subdir in $$list; do \
target=`echo $@ | sed s/-recursive//`; \
echo "Making $$target in $$subdir"; \
(cd $$subdir && $(MAKE) $$target) \
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
done && test -z "$$fail"
mostlyclean-recursive clean-recursive distclean-recursive \
maintainer-clean-recursive:
@set fnord $(MAKEFLAGS); amf=$$2; \
rev=''; list='$(SUBDIRS)'; for subdir in $$list; do \
rev="$$subdir $$rev"; \
done; \
for subdir in $$rev; do \
target=`echo $@ | sed s/-recursive//`; \
echo "Making $$target in $$subdir"; \
(cd $$subdir && $(MAKE) $$target) \
|| case "$$amf" in *=*) exit 1;; *k*) fail=yes;; *) exit 1;; esac; \
done && test -z "$$fail"
tags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
(cd $$subdir && $(MAKE) tags); \
done
tags: TAGS
ID: $(HEADERS) $(SOURCES) $(LISP)
here=`pwd` && cd $(srcdir) \
&& mkid -f$$here/ID $(SOURCES) $(HEADERS) $(LISP)
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
test -f $$subdir/TAGS && tags="$$tags -i $$here/$$subdir/TAGS"; \
done; \
list='$(SOURCES) $(HEADERS)'; \
unique=`for i in $$list; do echo $$i; done | \
awk ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
|| (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags $$unique $(LISP) -o $$here/TAGS)
mostlyclean-tags:
clean-tags:
distclean-tags:
-rm -f TAGS ID
maintainer-clean-tags:
distdir = $(PACKAGE)-$(VERSION)
top_distdir = $(distdir)
# This target untars the dist file and tries a VPATH configuration. Then
# it guarantees that the distribution is self-contained by making another
# tarfile.
distcheck: dist
-rm -rf $(distdir)
GZIP=$(GZIP) $(TAR) zxf $(distdir).tar.gz
mkdir $(distdir)/=build
mkdir $(distdir)/=inst
dc_install_base=`cd $(distdir)/=inst && pwd`; \
cd $(distdir)/=build \
&& ../configure --srcdir=.. --prefix=$$dc_install_base \
&& $(MAKE) \
&& $(MAKE) dvi \
&& $(MAKE) check \
&& $(MAKE) install \
&& $(MAKE) installcheck \
&& $(MAKE) dist
-rm -rf $(distdir)
@echo "========================"; \
echo "$(distdir).tar.gz is ready for distribution"; \
echo "========================"
dist: distdir
-chmod -R a+r $(distdir)
GZIP=$(GZIP) $(TAR) chozf $(distdir).tar.gz $(distdir)
-rm -rf $(distdir)
dist-all: distdir
-chmod -R a+r $(distdir)
GZIP=$(GZIP) $(TAR) chozf $(distdir).tar.gz $(distdir)
-rm -rf $(distdir)
distdir: $(DISTFILES)
-rm -rf $(distdir)
mkdir $(distdir)
-chmod 777 $(distdir)
here=`cd $(top_builddir) && pwd`; \
top_distdir=`cd $(distdir) && pwd`; \
distdir=`cd $(distdir) && pwd`; \
cd $(top_srcdir) \
&& $(AUTOMAKE) --include-deps --build-dir=$$here --srcdir-name=$(top_srcdir) --output-dir=$$top_distdir --gnu Makefile
@for file in $(DISTFILES); do \
d=$(srcdir); \
test -f $(distdir)/$$file \
|| ln $$d/$$file $(distdir)/$$file 2> /dev/null \
|| cp -p $$d/$$file $(distdir)/$$file; \
done
for subdir in $(SUBDIRS); do \
test -d $(distdir)/$$subdir \
|| mkdir $(distdir)/$$subdir \
|| exit 1; \
chmod 777 $(distdir)/$$subdir; \
(cd $$subdir && $(MAKE) top_distdir=../$(distdir) distdir=../$(distdir)/$$subdir distdir) \
|| exit 1; \
done
info: info-recursive
dvi: dvi-recursive
check: all-am
$(MAKE) check-recursive
installcheck: installcheck-recursive
all-am: Makefile $(DATA)
install-data-am: install-aclocalDATA
uninstall-am: uninstall-aclocalDATA
install-exec: install-exec-recursive
@$(NORMAL_INSTALL)
install-data: install-data-recursive install-data-am
@$(NORMAL_INSTALL)
install: install-recursive install-data-am
@:
uninstall: uninstall-recursive uninstall-am
install-strip:
$(MAKE) INSTALL_PROGRAM='$(INSTALL_PROGRAM) -s' INSTALL_SCRIPT='$(INSTALL_PROGRAM)' install
installdirs: installdirs-recursive
$(mkinstalldirs) $(DATADIR)$(aclocaldir)
mostlyclean-generic:
-test -z "$(MOSTLYCLEANFILES)" || rm -f $(MOSTLYCLEANFILES)
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-rm -f Makefile $(DISTCLEANFILES)
-rm -f config.cache config.log stamp-h stamp-h[0-9]*
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
-test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
mostlyclean-am: mostlyclean-tags mostlyclean-generic
clean-am: clean-tags clean-generic mostlyclean-am
distclean-am: distclean-tags distclean-generic clean-am
maintainer-clean-am: maintainer-clean-tags maintainer-clean-generic \
distclean-am
mostlyclean: mostlyclean-recursive mostlyclean-am
clean: clean-recursive clean-am
distclean: distclean-recursive distclean-am
-rm -f config.status
-rm -f libtool
maintainer-clean: maintainer-clean-recursive maintainer-clean-am
@echo "This command is intended for maintainers to use;"
@echo "it deletes files that may require special tools to rebuild."
-rm -f config.status
.PHONY: uninstall-aclocalDATA install-aclocalDATA install-data-recursive \
uninstall-data-recursive install-exec-recursive \
uninstall-exec-recursive installdirs-recursive uninstalldirs-recursive \
all-recursive check-recursive installcheck-recursive info-recursive \
dvi-recursive mostlyclean-recursive distclean-recursive clean-recursive \
maintainer-clean-recursive tags tags-recursive mostlyclean-tags \
distclean-tags clean-tags maintainer-clean-tags distdir info dvi \
installcheck all-am install-data-am uninstall-am install-exec \
install-data install uninstall all installdirs mostlyclean-generic \
distclean-generic clean-generic maintainer-clean-generic clean \
mostlyclean distclean maintainer-clean
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
guile-core/NEWS 644 521 17 253267 6560306023 12265 0 ustar guile users Guile NEWS --- history of user-visible changes. -*- text -*-
Copyright (C) 1996, 1997 Free Software Foundation, Inc.
See the end for copying conditions.
Please send Guile bug reports to bug-guile@gnu.org.
Changes since Guile 1.2:
* Changes to the distribution
** We renamed the SCHEME_LOAD_PATH environment variable to GUILE_LOAD_PATH.
To avoid conflicts, programs should name environment variables after
themselves, except when there's a common practice establishing some
other convention.
For now, Guile supports both GUILE_LOAD_PATH and SCHEME_LOAD_PATH,
giving the former precedence, and printing a warning message if the
latter is set. Guile 1.4 will not recognize SCHEME_LOAD_PATH at all.
** The header files related to multi-byte characters have been removed.
They were: libguile/extchrs.h and libguile/mbstrings.h. Any C code
which referred to these explicitly will probably need to be rewritten,
since the support for the variant string types has been removed; see
below.
** The header files append.h and sequences.h have been removed. These
files implemented non-R4RS operations which would encourage
non-portable programming style and less easy-to-read code.
* Changes to the stand-alone interpreter
** New procedures have been added to implement a "batch mode":
*** Function: batch-mode?
Returns a boolean indicating whether the interpreter is in batch
mode.
*** Function: set-batch-mode?! ARG
If ARG is true, switches the interpreter to batch mode. The `#f'
case has not been implemented.
** Guile now provides full command-line editing, when run interactively.
To use this feature, you must have the readline library installed.
The Guile build process will notice it, and automatically include
support for it.
The readline library is available via anonymous FTP from any GNU
mirror site; the canonical location is "ftp://prep.ai.mit.edu/pub/gnu".
** the-last-stack is now a fluid.
* Changes to the procedure for linking libguile with your programs
** You can now use the 'build-guile' utility to link against Guile.
Guile now includes a command-line utility called 'build-guile', which
writes to its standard output a list of flags which you must pass to
the linker to link against the Guile library. The flags include
'-lguile' itself, and any other libraries the Guile library depends
upon.
For example, here is a Makefile rule that builds a program named 'foo'
from the object files ${FOO_OBJECTS}, and links them against Guile:
foo: ${FOO_OBJECTS}
${CC} ${CFLAGS} ${FOO_OBJECTS} `build-guile link` -o foo
Previous Guile releases recommended that you use autoconf to detect
which of a predefined set of libraries were present on your system.
It is more robust to use build-guile, since it records exactly which
libraries the installed Guile library requires.
* Changes to Scheme functions and syntax
** Multi-byte strings have been removed, as have multi-byte and wide
ports. We felt that these were the wrong approach to
internationalization support.
** New function: readline [PROMPT]
Read a line from the terminal, and allow the user to edit it,
prompting with PROMPT. READLINE provides a large set of Emacs-like
editing commands, lets the user recall previously typed lines, and
works on almost every kind of terminal, including dumb terminals.
READLINE assumes that the cursor is at the beginning of the line when
it is invoked. Thus, you can't print a prompt yourself, and then call
READLINE; you need to package up your prompt as a string, pass it to
the function, and let READLINE print the prompt itself. This is
because READLINE needs to know the prompt's screen width.
For Guile to provide this function, you must have the readline library
installed on your system.
See also ADD-HISTORY function.
** New function: add-history STRING
Add STRING as the most recent line in the history used by the READLINE
command. READLINE does not add lines to the history itself; you must
call ADD-HISTORY to make previous input available to the user.
** New module (ice-9 getopt-gnu-style): Parse command-line arguments.
This module provides some simple argument parsing. It exports one
function:
Function: getopt-gnu-style ARG-LS
Parse a list of program arguments into an alist of option
descriptions.
Each item in the list of program arguments is examined to see if
it meets the syntax of a GNU long-named option. An argument like
`--MUMBLE' produces an element of the form (MUMBLE . #t) in the
returned alist, where MUMBLE is a keyword object with the same
name as the argument. An argument like `--MUMBLE=FROB' produces
an element of the form (MUMBLE . FROB), where FROB is a string.
As a special case, the returned alist also contains a pair whose
car is the symbol `rest'. The cdr of this pair is a list
containing all the items in the argument list that are not options
of the form mentioned above.
The argument `--' is treated specially: all items in the argument
list appearing after such an argument are not examined, and are
returned in the special `rest' list.
This function does not parse normal single-character switches.
You will need to parse them out of the `rest' list yourself.
** macro-eval! is removed. Use local-eval instead.
** Some magic has been added to the printer to better handle user
written printing routines (like record printers, closure printers).
The problem is that these user written routines must have access to
the current `print-state' to be able to handle fancy things like
detection of circular references. These print-states have to be
passed to the builtin printing routines (display, write, etc) to
properly continue the print chain.
We didn't want to change all existing print code so that it
explicitely passes thru a print state in addition to a port. Instead,
we extented the possible values that the builtin printing routines
accept as a `port'. In addition to a normal port, they now also take
a pair of a normal port and a print-state. Printing will go to the
port and the print-state will be used to control the detection of
circular references, etc. If the builtin function does not care for a
print-state, it is simply ignored.
User written callbacks are now called with such a pair as their
`port', but because every function now accepts this pair as a PORT
argument, you don't have to worry about that. In fact, it is probably
safest to not check for these pairs.
However, it is sometimes necessary to continue a print chain on a
different port, for example to get a intermediate string
representation of the printed value, mangle that string somehow, and
then to finally print the mangled string. Use the new function
inherit-print-state OLD-PORT NEW-PORT
for this. It constructs a new `port' that prints to NEW-PORT but
inherits the print-state of OLD-PORT.
** struct-vtable-offset renamed to vtable-offset-user
** New constants: vtable-index-layout, vtable-index-vtable, vtable-index-printer
** There is now a fourth (optional) argument to make-vtable-vtable and
make-struct when constructing new types (vtables). This argument
initializes field vtable-index-printer of the vtable.
** The detection of circular references has been extended to structs.
That is, a structure that -- in the process of being printed -- prints
itself does not lead to infinite recursion.
** There is now some basic support for fluids. Please read
"libguile/fluid.h" to find out more. It is accessible from Scheme with
the following functions and macros:
Function: make-fluid
Create a new fluid object. Fluids are not special variables or
some other extension to the semantics of Scheme, but rather
ordinary Scheme objects. You can store them into variables (that
are still lexically scoped, of course) or into any other place you
like. Every fluid has a initial value of `#f'.
Function: fluid? OBJ
Test whether OBJ is a fluid.
Function: fluid-ref FLUID
Function: fluid-set! FLUID VAL
Access/modify the fluid FLUID. Modifications are only visible
within the current dynamic root (that includes threads).
Function: with-fluids* FLUIDS VALUES THUNK
FLUIDS is a list of fluids and VALUES a corresponding list of
values for these fluids. Before THUNK gets called the values are
installed in the fluids and the old values of the fluids are
saved in the VALUES list. When the flow of control leaves THUNK
or reenters it, the values get swapped again. You might think of
this as a `safe-fluid-excursion'. Note that the VALUES list is
modified by `with-fluids*'.
Macro: with-fluids ((FLUID VALUE) ...) FORM ...
The same as `with-fluids*' but with a different syntax. It looks
just like `let', but both FLUID and VALUE are evaluated. Remember,
fluids are not special variables but ordinary objects. FLUID
should evaluate to a fluid.
** Changes to system call interfaces:
*** close-port, close-input-port and close-output-port now return a
boolean instead of an `unspecified' object. #t means that the port
was successfully closed, while #f means it was already closed. It is
also now possible for these procedures to raise an exception if an
error occurs (some errors from write can be delayed until close.)
*** the first argument to chmod, fcntl, ftell and fseek can now be a
file descriptor.
*** the third argument to fcntl is now optional.
*** the first argument to chown can now be a file descriptor or a port.
*** the argument to stat can now be a port.
*** The following new procedures have been added (most use scsh
interfaces):
*** procedure: close PORT/FD
Similar to close-port (*note close-port: Closing Ports.), but also
works on file descriptors. A side effect of closing a file
descriptor is that any ports using that file descriptor are moved
to a different file descriptor and have their revealed counts set
to zero.
*** procedure: port->fdes PORT
Returns the integer file descriptor underlying PORT. As a side
effect the revealed count of PORT is incremented.
*** procedure: fdes->ports FDES
Returns a list of existing ports which have FDES as an underlying
file descriptor, without changing their revealed counts.
*** procedure: fdes->inport FDES
Returns an existing input port which has FDES as its underlying
file descriptor, if one exists, and increments its revealed count.
Otherwise, returns a new input port with a revealed count of 1.
*** procedure: fdes->outport FDES
Returns an existing output port which has FDES as its underlying
file descriptor, if one exists, and increments its revealed count.
Otherwise, returns a new output port with a revealed count of 1.
The next group of procedures perform a `dup2' system call, if NEWFD
(an integer) is supplied, otherwise a `dup'. The file descriptor to be
duplicated can be supplied as an integer or contained in a port. The
type of value returned varies depending on which procedure is used.
All procedures also have the side effect when performing `dup2' that
any ports using NEWFD are moved to a different file descriptor and have
their revealed counts set to zero.
*** procedure: dup->fdes PORT/FD [NEWFD]
Returns an integer file descriptor.
*** procedure: dup->inport PORT/FD [NEWFD]
Returns a new input port using the new file descriptor.
*** procedure: dup->outport PORT/FD [NEWFD]
Returns a new output port using the new file descriptor.
*** procedure: dup PORT/FD [NEWFD]
Returns a new port if PORT/FD is a port, with the same mode as the
supplied port, otherwise returns an integer file descriptor.
*** procedure: dup->port PORT/FD MODE [NEWFD]
Returns a new port using the new file descriptor. MODE supplies a
mode string for the port (*note open-file: File Ports.).
*** procedure: setenv NAME VALUE
Modifies the environment of the current process, which is also the
default environment inherited by child processes.
If VALUE is `#f', then NAME is removed from the environment.
Otherwise, the string NAME=VALUE is added to the environment,
replacing any existing string with name matching NAME.
The return value is unspecified.
*** procedure: truncate-file OBJ SIZE
Truncates the file referred to by OBJ to at most SIZE bytes. OBJ
can be a string containing a file name or an integer file
descriptor or port open for output on the file. The underlying
system calls are `truncate' and `ftruncate'.
The return value is unspecified.
*** procedure: setvbuf PORT MODE [SIZE]
Set the buffering mode for PORT. MODE can be:
`_IONBF'
non-buffered
`_IOLBF'
line buffered
`_IOFBF'
block buffered, using a newly allocated buffer of SIZE bytes.
However if SIZE is zero or unspecified, the port will be made
non-buffered.
This procedure should not be used after I/O has been performed with
the port.
Ports are usually block buffered by default, with a default buffer
size. Procedures e.g., *Note open-file: File Ports, which accept a
mode string allow `0' to be added to request an unbuffered port.
*** procedure: fsync PORT/FD
Copies any unwritten data for the specified output file descriptor
to disk. If PORT/FD is a port, its buffer is flushed before the
underlying file descriptor is fsync'd. The return value is
unspecified.
*** procedure: open-fdes PATH FLAGS [MODES]
Similar to `open' but returns a file descriptor instead of a port.
*** procedure: execle PATH ENV [ARG] ...
Similar to `execl', but the environment of the new process is
specified by ENV, which must be a list of strings as returned by
the `environ' procedure.
This procedure is currently implemented using the `execve' system
call, but we call it `execle' because of its Scheme calling
interface.
*** procedure: strerror ERRNO
Returns the Unix error message corresponding to ERRNO, an integer.
*** procedure: primitive-exit [STATUS]
Terminate the current process without unwinding the Scheme stack.
This is would typically be useful after a fork. The exit status
is STATUS if supplied, otherwise zero.
*** procedure: times
Returns an object with information about real and processor time.
The following procedures accept such an object as an argument and
return a selected component:
`tms:clock'
The current real time, expressed as time units relative to an
arbitrary base.
`tms:utime'
The CPU time units used by the calling process.
`tms:stime'
The CPU time units used by the system on behalf of the
calling process.
`tms:cutime'
The CPU time units used by terminated child processes of the
calling process, whose status has been collected (e.g., using
`waitpid').
`tms:cstime'
Similarly, the CPU times units used by the system on behalf of
terminated child processes.
** Removed: list-length
** Removed: list-append, list-append!
** Removed: list-reverse, list-reverse!
** array-map renamed to array-map!
** serial-array-map renamed to serial-array-map!
** catch doesn't take #f as first argument any longer
Previously, it was possible to pass #f instead of a key to `catch'.
That would cause `catch' to pass a jump buffer object to the procedure
passed as second argument. The procedure could then use this jump
buffer objekt as an argument to throw.
This mechanism has been removed since its utility doesn't motivate the
extra complexity it introduces.
* Changes to the gh_ interface
** Function: void gh_write (SCM x)
Write the printed representation of the scheme object x to the current
output port. Corresponds to the scheme level `write'.
** gh_list_length renamed to gh_length.
** vector handling routines
Several major changes. In particular, gh_vector() now resembles
(vector ...) (with a caveat -- see manual), and gh_make_vector() now
exists and behaves like (make-vector ...). gh_vset() and gh_vref()
have been renamed gh_vector_set_x() and gh_vector_ref(). Some missing
vector-related gh_ functions have been implemented.
** pair and list routines
Implemented several of the R4RS pair and list functions that were
missing.
** gh_scm2doubles, gh_doubles2scm, gh_doubles2dvect
New function. Converts double arrays back and forth between Scheme
and C.
* Changes to the scm_ interface
** The semantics of smob marking have changed slightly.
The smob marking function (the `mark' member of the scm_smobfuns
structure) is no longer responsible for setting the mark bit on the
smob. The generic smob handling code in the garbage collector will
set this bit. The mark function need only ensure that any other
objects the smob refers to get marked.
Note that this change means that the smob's GC8MARK bit is typically
already set upon entry to the mark function. Thus, marking functions
which look like this:
{
if (SCM_GC8MARKP (ptr))
return SCM_BOOL_F;
SCM_SETGC8MARK (ptr);
... mark objects to which the smob refers ...
}
are now incorrect, since they will return early, and fail to mark any
other objects the smob refers to. Some code in the Guile library used
to work this way.
** Function: int scm_internal_select (int fds,
SELECT_TYPE *rfds,
SELECT_TYPE *wfds,
SELECT_TYPE *efds,
struct timeval *timeout);
This is a replacement for the `select' function provided by the OS.
It enables I/O blocking and sleeping to happen for one cooperative
thread without blocking other threads. It also avoids busy-loops in
these situations. It is intended that all I/O blocking and sleeping
will finally go through this function. Currently, this function is
only available on systems providing `gettimeofday' and `select'.
** Function: SCM scm_internal_stack_catch (SCM tag,
scm_catch_body_t body,
void *body_data,
scm_catch_handler_t handler,
void *handler_data)
A new sibling to the other two C level `catch' functions
scm_internal_catch and scm_internal_lazy_catch. Use it if you want
the stack to be saved automatically into the variable `the-last-stack'
(scm_the_last_stack_var) on error. This is necessary if you want to
use advanced error reporting, such as calling scm_display_error and
scm_display_backtrace. (They both take a stack object as argument.)
** Function: SCM scm_spawn_thread (scm_catch_body_t body,
void *body_data,
scm_catch_handler_t handler,
void *handler_data)
Spawns a new thread. It does a job similar to
scm_call_with_new_thread but takes arguments more suitable when
spawning threads from application C code.
** The hook scm_error_callback has been removed. It was originally
intended as a way for the user to install his own error handler. But
that method works badly since it intervenes between throw and catch,
thereby changing the semantics of expressions like (catch #t ...).
The correct way to do it is to use one of the C level catch functions
in throw.c: scm_internal_catch/lazy_catch/stack_catch.
** Removed functions:
scm_obj_length, scm_list_length, scm_list_append, scm_list_append_x,
scm_list_reverse, scm_list_reverse_x
** New macros: SCM_LISTn where n is one of the integers 0-9.
These can be used for pretty list creation from C. The idea is taken
from Erick Gallesio's STk.
** scm_array_map renamed to scm_array_map_x
** mbstrings are now removed
This means that the type codes scm_tc7_mb_string and
scm_tc7_mb_substring has been removed.
** The macros SCM_TYP7D and SCM_TYP7SD has been removed.
** The macro SCM_TYP7S has taken the role of the old SCM_TYP7D
SCM_TYP7S now masks away the bit which distinguishes substrings from
strings.
** All genio functions changed names and interfaces; new functions are
scm_putc, scm_puts, scm_lfwrite, scm_getc, scm_ungetc, and
scm_do_read_line.
** scm_catch_body_t: Backward incompatible change!
Body functions to scm_internal_catch and friends do not any longer
take a second argument. This is because it is no longer possible to
pass a #f arg to catch.
Changes in Guile 1.2 (released Tuesday, June 24 1997):
* Changes to the distribution
** Nightly snapshots are now available from ftp.red-bean.com.
The old server, ftp.cyclic.com, has been relinquished to its rightful
owner.
Nightly snapshots of the Guile development sources are now available via
anonymous FTP from ftp.red-bean.com, as /pub/guile/guile-snap.tar.gz.
Via the web, that's: ftp://ftp.red-bean.com/pub/guile/guile-snap.tar.gz
For getit, that's: ftp.red-bean.com:/pub/guile/guile-snap.tar.gz
** To run Guile without installing it, the procedure has changed a bit.
If you used a separate build directory to compile Guile, you'll need
to include the build directory in SCHEME_LOAD_PATH, as well as the
source directory. See the `INSTALL' file for examples.
* Changes to the procedure for linking libguile with your programs
** The standard Guile load path for Scheme code now includes
$(datadir)/guile (usually /usr/local/share/guile). This means that
you can install your own Scheme files there, and Guile will find them.
(Previous versions of Guile only checked a directory whose name
contained the Guile version number, so you had to re-install or move
your Scheme sources each time you installed a fresh version of Guile.)
The load path also includes $(datadir)/guile/site; we recommend
putting individual Scheme files there. If you want to install a
package with multiple source files, create a directory for them under
$(datadir)/guile.
** Guile 1.2 will now use the Rx regular expression library, if it is
installed on your system. When you are linking libguile into your own
programs, this means you will have to link against -lguile, -lqt (if
you configured Guile with thread support), and -lrx.
If you are using autoconf to generate configuration scripts for your
application, the following lines should suffice to add the appropriate
libraries to your link command:
### Find Rx, quickthreads and libguile.
AC_CHECK_LIB(rx, main)
AC_CHECK_LIB(qt, main)
AC_CHECK_LIB(guile, scm_shell)
The Guile 1.2 distribution does not contain sources for the Rx
library, as Guile 1.0 did. If you want to use Rx, you'll need to
retrieve it from a GNU FTP site and install it separately.
* Changes to Scheme functions and syntax
** The dynamic linking features of Guile are now enabled by default.
You can disable them by giving the `--disable-dynamic-linking' option
to configure.
(dynamic-link FILENAME)
Find the object file denoted by FILENAME (a string) and link it
into the running Guile application. When everything works out,
return a Scheme object suitable for representing the linked object
file. Otherwise an error is thrown. How object files are
searched is system dependent.
(dynamic-object? VAL)
Determine whether VAL represents a dynamically linked object file.
(dynamic-unlink DYNOBJ)
Unlink the indicated object file from the application. DYNOBJ
should be one of the values returned by `dynamic-link'.
(dynamic-func FUNCTION DYNOBJ)
Search the C function indicated by FUNCTION (a string or symbol)
in DYNOBJ and return some Scheme object that can later be used
with `dynamic-call' to actually call this function. Right now,
these Scheme objects are formed by casting the address of the
function to `long' and converting this number to its Scheme
representation.
(dynamic-call FUNCTION DYNOBJ)
Call the C function indicated by FUNCTION and DYNOBJ. The
function is passed no arguments and its return value is ignored.
When FUNCTION is something returned by `dynamic-func', call that
function and ignore DYNOBJ. When FUNCTION is a string (or symbol,
etc.), look it up in DYNOBJ; this is equivalent to
(dynamic-call (dynamic-func FUNCTION DYNOBJ) #f)
Interrupts are deferred while the C function is executing (with
SCM_DEFER_INTS/SCM_ALLOW_INTS).
(dynamic-args-call FUNCTION DYNOBJ ARGS)
Call the C function indicated by FUNCTION and DYNOBJ, but pass it
some arguments and return its return value. The C function is
expected to take two arguments and return an `int', just like
`main':
int c_func (int argc, char **argv);
ARGS must be a list of strings and is converted into an array of
`char *'. The array is passed in ARGV and its size in ARGC. The
return value is converted to a Scheme number and returned from the
call to `dynamic-args-call'.
When dynamic linking is disabled or not supported on your system,
the above functions throw errors, but they are still available.
Here is a small example that works on GNU/Linux:
(define libc-obj (dynamic-link "libc.so"))
(dynamic-args-call 'rand libc-obj '())
See the file `libguile/DYNAMIC-LINKING' for additional comments.
** The #/ syntax for module names is depreciated, and will be removed
in a future version of Guile. Instead of
#/foo/bar/baz
instead write
(foo bar baz)
The latter syntax is more consistent with existing Lisp practice.
** Guile now does fancier printing of structures. Structures are the
underlying implementation for records, which in turn are used to
implement modules, so all of these object now print differently and in
a more informative way.
The Scheme printer will examine the builtin variable *struct-printer*
whenever it needs to print a structure object. When this variable is
not `#f' it is deemed to be a procedure and will be applied to the
structure object and the output port. When *struct-printer* is `#f'
or the procedure return `#f' the structure object will be printed in
the boring #<struct 80458270> form.
This hook is used by some routines in ice-9/boot-9.scm to implement
type specific printing routines. Please read the comments there about
"printing structs".
One of the more specific uses of structs are records. The printing
procedure that could be passed to MAKE-RECORD-TYPE is now actually
called. It should behave like a *struct-printer* procedure (described
above).
** Guile now supports a new R4RS-compliant syntax for keywords. A
token of the form #:NAME, where NAME has the same syntax as a Scheme
symbol, is the external representation of the keyword named NAME.
Keyword objects print using this syntax as well, so values containing
keyword objects can be read back into Guile. When used in an
expression, keywords are self-quoting objects.
Guile suports this read syntax, and uses this print syntax, regardless
of the current setting of the `keyword' read option. The `keyword'
read option only controls whether Guile recognizes the `:NAME' syntax,
which is incompatible with R4RS. (R4RS says such token represent
symbols.)
** Guile has regular expression support again. Guile 1.0 included
functions for matching regular expressions, based on the Rx library.
In Guile 1.1, the Guile/Rx interface was removed to simplify the
distribution, and thus Guile had no regular expression support. Guile
1.2 again supports the most commonly used functions, and supports all
of SCSH's regular expression functions.
If your system does not include a POSIX regular expression library,
and you have not linked Guile with a third-party regexp library such as
Rx, these functions will not be available. You can tell whether your
Guile installation includes regular expression support by checking
whether the `*features*' list includes the `regex' symbol.
*** regexp functions
By default, Guile supports POSIX extended regular expressions. That
means that the characters `(', `)', `+' and `?' are special, and must
be escaped if you wish to match the literal characters.
This regular expression interface was modeled after that implemented
by SCSH, the Scheme Shell. It is intended to be upwardly compatible
with SCSH regular expressions.
**** Function: string-match PATTERN STR [START]
Compile the string PATTERN into a regular expression and compare
it with STR. The optional numeric argument START specifies the
position of STR at which to begin matching.
`string-match' returns a "match structure" which describes what,
if anything, was matched by the regular expression. *Note Match
Structures::. If STR does not match PATTERN at all,
`string-match' returns `#f'.
Each time `string-match' is called, it must compile its PATTERN
argument into a regular expression structure. This operation is
expensive, which makes `string-match' inefficient if the same regular
expression is used several times (for example, in a loop). For better
performance, you can compile a regular expression in advance and then
match strings against the compiled regexp.
**** Function: make-regexp STR [FLAGS]
Compile the regular expression described by STR, and return the
compiled regexp structure. If STR does not describe a legal
regular expression, `make-regexp' throws a
`regular-expression-syntax' error.
FLAGS may be the bitwise-or of one or more of the following:
**** Constant: regexp/extended
Use POSIX Extended Regular Expression syntax when interpreting
STR. If not set, POSIX Basic Regular Expression syntax is used.
If the FLAGS argument is omitted, we assume regexp/extended.
**** Constant: regexp/icase
Do not differentiate case. Subsequent searches using the
returned regular expression will be case insensitive.
**** Constant: regexp/newline
Match-any-character operators don't match a newline.
A non-matching list ([^...]) not containing a newline matches a
newline.
Match-beginning-of-line operator (^) matches the empty string
immediately after a newline, regardless of whether the FLAGS
passed to regexp-exec contain regexp/notbol.
Match-end-of-line operator ($) matches the empty string
immediately before a newline, regardless of whether the FLAGS
passed to regexp-exec contain regexp/noteol.
**** Function: regexp-exec REGEXP STR [START [FLAGS]]
Match the compiled regular expression REGEXP against `str'. If
the optional integer START argument is provided, begin matching
from that position in the string. Return a match structure
describing the results of the match, or `#f' if no match could be
found.
FLAGS may be the bitwise-or of one or more of the following:
**** Constant: regexp/notbol
The match-beginning-of-line operator always fails to match (but
see the compilation flag regexp/newline above) This flag may be
used when different portions of a string are passed to
regexp-exec and the beginning of the string should not be
interpreted as the beginning of the line.
**** Constant: regexp/noteol
The match-end-of-line operator always fails to match (but see the
compilation flag regexp/newline above)
**** Function: regexp? OBJ
Return `#t' if OBJ is a compiled regular expression, or `#f'
otherwise.
Regular expressions are commonly used to find patterns in one string
and replace them with the contents of another string.
**** Function: regexp-substitute PORT MATCH [ITEM...]
Write to the output port PORT selected contents of the match
structure MATCH. Each ITEM specifies what should be written, and
may be one of the following arguments:
* A string. String arguments are written out verbatim.
* An integer. The submatch with that number is written.
* The symbol `pre'. The portion of the matched string preceding
the regexp match is written.
* The symbol `post'. The portion of the matched string
following the regexp match is written.
PORT may be `#f', in which case nothing is written; instead,
`regexp-substitute' constructs a string from the specified ITEMs
and returns that.
**** Function: regexp-substitute/global PORT REGEXP TARGET [ITEM...]
Similar to `regexp-substitute', but can be used to perform global
substitutions on STR. Instead of taking a match structure as an
argument, `regexp-substitute/global' takes two string arguments: a
REGEXP string describing a regular expression, and a TARGET string
which should be matched against this regular expression.
Each ITEM behaves as in REGEXP-SUBSTITUTE, with the following
exceptions:
* A function may be supplied. When this function is called, it
will be passed one argument: a match structure for a given
regular expression match. It should return a string to be
written out to PORT.
* The `post' symbol causes `regexp-substitute/global' to recurse
on the unmatched portion of STR. This *must* be supplied in
order to perform global search-and-replace on STR; if it is
not present among the ITEMs, then `regexp-substitute/global'
will return after processing a single match.
*** Match Structures
A "match structure" is the object returned by `string-match' and
`regexp-exec'. It describes which portion of a string, if any, matched
the given regular expression. Match structures include: a reference to
the string that was checked for matches; the starting and ending
positions of the regexp match; and, if the regexp included any
parenthesized subexpressions, the starting and ending positions of each
submatch.
In each of the regexp match functions described below, the `match'
argument must be a match structure returned by a previous call to
`string-match' or `regexp-exec'. Most of these functions return some
information about the original target string that was matched against a
regular expression; we will call that string TARGET for easy reference.
**** Function: regexp-match? OBJ
Return `#t' if OBJ is a match structure returned by a previous
call to `regexp-exec', or `#f' otherwise.
**** Function: match:substring MATCH [N]
Return the portion of TARGET matched by subexpression number N.
Submatch 0 (the default) represents the entire regexp match. If
the regular expression as a whole matched, but the subexpression
number N did not match, return `#f'.
**** Function: match:start MATCH [N]
Return the starting position of submatch number N.
**** Function: match:end MATCH [N]
Return the ending position of submatch number N.
**** Function: match:prefix MATCH
Return the unmatched portion of TARGET preceding the regexp match.
**** Function: match:suffix MATCH
Return the unmatched portion of TARGET following the regexp match.
**** Function: match:count MATCH
Return the number of parenthesized subexpressions from MATCH.
Note that the entire regular expression match itself counts as a
subexpression, and failed submatches are included in the count.
**** Function: match:string MATCH
Return the original TARGET string.
*** Backslash Escapes
Sometimes you will want a regexp to match characters like `*' or `$'
exactly. For example, to check whether a particular string represents
a menu entry from an Info node, it would be useful to match it against
a regexp like `^* [^:]*::'. However, this won't work; because the
asterisk is a metacharacter, it won't match the `*' at the beginning of
the string. In this case, we want to make the first asterisk un-magic.
You can do this by preceding the metacharacter with a backslash
character `\'. (This is also called "quoting" the metacharacter, and
is known as a "backslash escape".) When Guile sees a backslash in a
regular expression, it considers the following glyph to be an ordinary
character, no matter what special meaning it would ordinarily have.
Therefore, we can make the above example work by changing the regexp to
`^\* [^:]*::'. The `\*' sequence tells the regular expression engine
to match only a single asterisk in the target string.
Since the backslash is itself a metacharacter, you may force a
regexp to match a backslash in the target string by preceding the
backslash with itself. For example, to find variable references in a
TeX program, you might want to find occurrences of the string `\let\'
followed by any number of alphabetic characters. The regular expression
`\\let\\[A-Za-z]*' would do this: the double backslashes in the regexp
each match a single backslash in the target string.
**** Function: regexp-quote STR
Quote each special character found in STR with a backslash, and
return the resulting string.
*Very important:* Using backslash escapes in Guile source code (as
in Emacs Lisp or C) can be tricky, because the backslash character has
special meaning for the Guile reader. For example, if Guile encounters
the character sequence `\n' in the middle of a string while processing
Scheme code, it replaces those characters with a newline character.
Similarly, the character sequence `\t' is replaced by a horizontal tab.
Several of these "escape sequences" are processed by the Guile reader
before your code is executed. Unrecognized escape sequences are
ignored: if the characters `\*' appear in a string, they will be
translated to the single character `*'.
This translation is obviously undesirable for regular expressions,
since we want to be able to include backslashes in a string in order to
escape regexp metacharacters. Therefore, to make sure that a backslash
is preserved in a string in your Guile program, you must use *two*
consecutive backslashes:
(define Info-menu-entry-pattern (make-regexp "^\\* [^:]*"))
The string in this example is preprocessed by the Guile reader before
any code is executed. The resulting argument to `make-regexp' is the
string `^\* [^:]*', which is what we really want.
This also means that in order to write a regular expression that
matches a single backslash character, the regular expression string in
the source code must include *four* backslashes. Each consecutive pair
of backslashes gets translated by the Guile reader to a single
backslash, and the resulting double-backslash is interpreted by the
regexp engine as matching a single backslash character. Hence:
(define tex-variable-pattern (make-regexp "\\\\let\\\\=[A-Za-z]*"))
The reason for the unwieldiness of this syntax is historical. Both
regular expression pattern matchers and Unix string processing systems
have traditionally used backslashes with the special meanings described
above. The POSIX regular expression specification and ANSI C standard
both require these semantics. Attempting to abandon either convention
would cause other kinds of compatibility problems, possibly more severe
ones. Therefore, without extending the Scheme reader to support
strings with different quoting conventions (an ungainly and confusing
extension when implemented in other languages), we must adhere to this
cumbersome escape syntax.
* Changes to the gh_ interface
* Changes to the scm_ interface
* Changes to system call interfaces:
** The value returned by `raise' is now unspecified. It throws an exception
if an error occurs.
*** A new procedure `sigaction' can be used to install signal handlers
(sigaction signum [action] [flags])
signum is the signal number, which can be specified using the value
of SIGINT etc.
If action is omitted, sigaction returns a pair: the CAR is the current
signal hander, which will be either an integer with the value SIG_DFL
(default action) or SIG_IGN (ignore), or the Scheme procedure which
handles the signal, or #f if a non-Scheme procedure handles the
signal. The CDR contains the current sigaction flags for the handler.
If action is provided, it is installed as the new handler for signum.
action can be a Scheme procedure taking one argument, or the value of
SIG_DFL (default action) or SIG_IGN (ignore), or #f to restore
whatever signal handler was installed before sigaction was first used.
Flags can optionally be specified for the new handler (SA_RESTART is
always used if the system provides it, so need not be specified.) The
return value is a pair with information about the old handler as
described above.
This interface does not provide access to the "signal blocking"
facility. Maybe this is not needed, since the thread support may
provide solutions to the problem of consistent access to data
structures.
*** A new procedure `flush-all-ports' is equivalent to running
`force-output' on every port open for output.
** Guile now provides information on how it was built, via the new
global variable, %guile-build-info. This variable records the values
of the standard GNU makefile directory variables as an assocation
list, mapping variable names (symbols) onto directory paths (strings).
For example, to find out where the Guile link libraries were
installed, you can say:
guile -c "(display (assq-ref %guile-build-info 'libdir)) (newline)"
* Changes to the scm_ interface
** The new function scm_handle_by_message_noexit is just like the
existing scm_handle_by_message function, except that it doesn't call
exit to terminate the process. Instead, it prints a message and just
returns #f. This might be a more appropriate catch-all handler for
new dynamic roots and threads.
Changes in Guile 1.1 (released Friday, May 16 1997):
* Changes to the distribution.
The Guile 1.0 distribution has been split up into several smaller
pieces:
guile-core --- the Guile interpreter itself.
guile-tcltk --- the interface between the Guile interpreter and
Tcl/Tk; Tcl is an interpreter for a stringy language, and Tk
is a toolkit for building graphical user interfaces.
guile-rgx-ctax --- the interface between Guile and the Rx regular
expression matcher, and the translator for the Ctax
programming language. These are packaged together because the
Ctax translator uses Rx to parse Ctax source code.
This NEWS file describes the changes made to guile-core since the 1.0
release.
We no longer distribute the documentation, since it was either out of
date, or incomplete. As soon as we have current documentation, we
will distribute it.
* Changes to the stand-alone interpreter
** guile now accepts command-line arguments compatible with SCSH, Olin
Shivers' Scheme Shell.
In general, arguments are evaluated from left to right, but there are
exceptions. The following switches stop argument processing, and
stash all remaining command-line arguments as the value returned by
the (command-line) function.
-s SCRIPT load Scheme source code from FILE, and exit
-c EXPR evalute Scheme expression EXPR, and exit
-- stop scanning arguments; run interactively
The switches below are processed as they are encountered.
-l FILE load Scheme source code from FILE
-e FUNCTION after reading script, apply FUNCTION to
command line arguments
-ds do -s script at this point
--emacs enable Emacs protocol (experimental)
-h, --help display this help and exit
-v, --version display version information and exit
\ read arguments from following script lines
So, for example, here is a Guile script named `ekko' (thanks, Olin)
which re-implements the traditional "echo" command:
#!/usr/local/bin/guile -s
!#
(define (main args)
(map (lambda (arg) (display arg) (display " "))
(cdr args))
(newline))
(main (command-line))
Suppose we invoke this script as follows:
ekko a speckled gecko
Through the magic of Unix script processing (triggered by the `#!'
token at the top of the file), /usr/local/bin/guile receives the
following list of command-line arguments:
("-s" "./ekko" "a" "speckled" "gecko")
Unix inserts the name of the script after the argument specified on
the first line of the file (in this case, "-s"), and then follows that
with the arguments given to the script. Guile loads the script, which
defines the `main' function, and then applies it to the list of
remaining command-line arguments, ("a" "speckled" "gecko").
In Unix, the first line of a script file must take the following form:
#!INTERPRETER ARGUMENT
where INTERPRETER is the absolute filename of the interpreter
executable, and ARGUMENT is a single command-line argument to pass to
the interpreter.
You may only pass one argument to the interpreter, and its length is
limited. These restrictions can be annoying to work around, so Guile
provides a general mechanism (borrowed from, and compatible with,
SCSH) for circumventing them.
If the ARGUMENT in a Guile script is a single backslash character,
`\', Guile will open the script file, parse arguments from its second
and subsequent lines, and replace the `\' with them. So, for example,
here is another implementation of the `ekko' script:
#!/usr/local/bin/guile \
-e main -s
!#
(define (main args)
(for-each (lambda (arg) (display arg) (display " "))
(cdr args))
(newline))
If the user invokes this script as follows:
ekko a speckled gecko
Unix expands this into
/usr/local/bin/guile \ ekko a speckled gecko
When Guile sees the `\' argument, it replaces it with the arguments
read from the second line of the script, producing:
/usr/local/bin/guile -e main -s ekko a speckled gecko
This tells Guile to load the `ekko' script, and apply the function
`main' to the argument list ("a" "speckled" "gecko").
Here is how Guile parses the command-line arguments:
- Each space character terminates an argument. This means that two
spaces in a row introduce an empty-string argument.
- The tab character is not permitted (unless you quote it with the
backslash character, as described below), to avoid confusion.
- The newline character terminates the sequence of arguments, and will
also terminate a final non-empty argument. (However, a newline
following a space will not introduce a final empty-string argument;
it only terminates the argument list.)
- The backslash character is the escape character. It escapes
backslash, space, tab, and newline. The ANSI C escape sequences
like \n and \t are also supported. These produce argument
constituents; the two-character combination \n doesn't act like a
terminating newline. The escape sequence \NNN for exactly three
octal digits reads as the character whose ASCII code is NNN. As
above, characters produced this way are argument constituents.
Backslash followed by other characters is not allowed.
* Changes to the procedure for linking libguile with your programs
** Guile now builds and installs a shared guile library, if your
system support shared libraries. (It still builds a static library on
all systems.) Guile automatically detects whether your system
supports shared libraries. To prevent Guile from buildisg shared
libraries, pass the `--disable-shared' flag to the configure script.
Guile takes longer to compile when it builds shared libraries, because
it must compile every file twice --- once to produce position-
independent object code, and once to produce normal object code.
** The libthreads library has been merged into libguile.
To link a program against Guile, you now need only link against
-lguile and -lqt; -lthreads is no longer needed. If you are using
autoconf to generate configuration scripts for your application, the
following lines should suffice to add the appropriate libraries to
your link command:
### Find quickthreads and libguile.
AC_CHECK_LIB(qt, main)
AC_CHECK_LIB(guile, scm_shell)
* Changes to Scheme functions
** Guile Scheme's special syntax for keyword objects is now optional,
and disabled by default.
The syntax variation from R4RS made it difficult to port some
interesting packages to Guile. The routines which accepted keyword
arguments (mostly in the module system) have been modified to also
accept symbols whose names begin with `:'.
To change the keyword syntax, you must first import the (ice-9 debug)
module:
(use-modules (ice-9 debug))
Then you can enable the keyword syntax as follows:
(read-set! keywords 'prefix)
To disable keyword syntax, do this:
(read-set! keywords #f)
** Many more primitive functions accept shared substrings as
arguments. In the past, these functions required normal, mutable
strings as arguments, although they never made use of this
restriction.
** The uniform array functions now operate on byte vectors. These
functions are `array-fill!', `serial-array-copy!', `array-copy!',
`serial-array-map', `array-map', `array-for-each', and
`array-index-map!'.
** The new functions `trace' and `untrace' implement simple debugging
support for Scheme functions.
The `trace' function accepts any number of procedures as arguments,
and tells the Guile interpreter to display each procedure's name and
arguments each time the procedure is invoked. When invoked with no
arguments, `trace' returns the list of procedures currently being
traced.
The `untrace' function accepts any number of procedures as arguments,
and tells the Guile interpreter not to trace them any more. When
invoked with no arguments, `untrace' untraces all curretly traced
procedures.
The tracing in Guile has an advantage over most other systems: we
don't create new procedure objects, but mark the procedure objects
themselves. This means that anonymous and internal procedures can be
traced.
** The function `assert-repl-prompt' has been renamed to
`set-repl-prompt!'. It takes one argument, PROMPT.
- If PROMPT is #f, the Guile read-eval-print loop will not prompt.
- If PROMPT is a string, we use it as a prompt.
- If PROMPT is a procedure accepting no arguments, we call it, and
display the result as a prompt.
- Otherwise, we display "> ".
** The new function `eval-string' reads Scheme expressions from a
string and evaluates them, returning the value of the last expression
in the string. If the string contains no expressions, it returns an
unspecified value.
** The new function `thunk?' returns true iff its argument is a
procedure of zero arguments.
** `defined?' is now a builtin function, instead of syntax. This
means that its argument should be quoted. It returns #t iff its
argument is bound in the current module.
** The new syntax `use-modules' allows you to add new modules to your
environment without re-typing a complete `define-module' form. It
accepts any number of module names as arguments, and imports their
public bindings into the current module.
** The new function (module-defined? NAME MODULE) returns true iff
NAME, a symbol, is defined in MODULE, a module object.
** The new function `builtin-bindings' creates and returns a hash
table containing copies of all the root module's bindings.
** The new function `builtin-weak-bindings' does the same as
`builtin-bindings', but creates a doubly-weak hash table.
** The `equal?' function now considers variable objects to be
equivalent if they have the same name and the same value.
** The new function `command-line' returns the command-line arguments
given to Guile, as a list of strings.
When using guile as a script interpreter, `command-line' returns the
script's arguments; those processed by the interpreter (like `-s' or
`-c') are omitted. (In other words, you get the normal, expected
behavior.) Any application that uses scm_shell to process its
command-line arguments gets this behavior as well.
** The new function `load-user-init' looks for a file called `.guile'
in the user's home directory, and loads it if it exists. This is
mostly for use by the code generated by scm_compile_shell_switches,
but we thought it might also be useful in other circumstances.
** The new function `log10' returns the base-10 logarithm of its
argument.
** Changes to I/O functions
*** The functions `read', `primitive-load', `read-and-eval!', and
`primitive-load-path' no longer take optional arguments controlling
case insensitivity and a `#' parser.
Case sensitivity is now controlled by a read option called
`case-insensitive'. The user can add new `#' syntaxes with the
`read-hash-extend' function (see below).
*** The new function `read-hash-extend' allows the user to change the
syntax of Guile Scheme in a somewhat controlled way.
(read-hash-extend CHAR PROC)
When parsing S-expressions, if we read a `#' character followed by
the character CHAR, use PROC to parse an object from the stream.
If PROC is #f, remove any parsing procedure registered for CHAR.
The reader applies PROC to two arguments: CHAR and an input port.
*** The new functions read-delimited and read-delimited! provide a
general mechanism for doing delimited input on streams.
(read-delimited DELIMS [PORT HANDLE-DELIM])
Read until we encounter one of the characters in DELIMS (a string),
or end-of-file. PORT is the input port to read from; it defaults to
the current input port. The HANDLE-DELIM parameter determines how
the terminating character is handled; it should be one of the
following symbols:
'trim omit delimiter from result
'peek leave delimiter character in input stream
'concat append delimiter character to returned value
'split return a pair: (RESULT . TERMINATOR)
HANDLE-DELIM defaults to 'peek.
(read-delimited! DELIMS BUF [PORT HANDLE-DELIM START END])
A side-effecting variant of `read-delimited'.
The data is written into the string BUF at the indices in the
half-open interval [START, END); the default interval is the whole
string: START = 0 and END = (string-length BUF). The values of
START and END must specify a well-defined interval in BUF, i.e.
0 <= START <= END <= (string-length BUF).
It returns NBYTES, the number of bytes read. If the buffer filled
up without a delimiter character being found, it returns #f. If the
port is at EOF when the read starts, it returns the EOF object.
If an integer is returned (i.e., the read is successfully terminated
by reading a delimiter character), then the HANDLE-DELIM parameter
determines how to handle the terminating character. It is described
above, and defaults to 'peek.
(The descriptions of these functions were borrowed from the SCSH
manual, by Olin Shivers and Brian Carlstrom.)
*** The `%read-delimited!' function is the primitive used to implement
`read-delimited' and `read-delimited!'.
(%read-delimited! DELIMS BUF GOBBLE? [PORT START END])
This returns a pair of values: (TERMINATOR . NUM-READ).
- TERMINATOR describes why the read was terminated. If it is a
character or the eof object, then that is the value that terminated
the read. If it is #f, the function filled the buffer without finding
a delimiting character.
- NUM-READ is the number of characters read into BUF.
If the read is successfully terminated by reading a delimiter
character, then the gobble? parameter determines what to do with the
terminating character. If true, the character is removed from the
input stream; if false, the character is left in the input stream
where a subsequent read operation will retrieve it. In either case,
the character is also the first value returned by the procedure call.
(The descriptions of this function was borrowed from the SCSH manual,
by Olin Shivers and Brian Carlstrom.)
*** The `read-line' and `read-line!' functions have changed; they now
trim the terminator by default; previously they appended it to the
returned string. For the old behavior, use (read-line PORT 'concat).
*** The functions `uniform-array-read!' and `uniform-array-write!' now
take new optional START and END arguments, specifying the region of
the array to read and write.
*** The `ungetc-char-ready?' function has been removed. We feel it's
inappropriate for an interface to expose implementation details this
way.
** Changes to the Unix library and system call interface
*** The new fcntl function provides access to the Unix `fcntl' system
call.
(fcntl PORT COMMAND VALUE)
Apply COMMAND to PORT
