1 Guile NEWS --- history of user-visible changes. -*- text -*-
2 Copyright (C) 1996, 1997 Free Software Foundation, Inc.
3 See the end for copying conditions.
5 Please send Guile bug reports to bug-guile@prep.ai.mit.edu.
7 Changes since Guile 1.0 (Sun 5 Jan 1997):
12 User-visible changes from Thursday, September 5, 1996 until Guile 1.0:
14 * Changes to the 'guile' program:
16 ** Guile now loads some new files when it starts up. Guile first
17 searches the load path for init.scm, and loads it if found. Then, if
18 Guile is not being used to execute a script, and the user's home
19 directory contains a file named `.guile', Guile loads that.
21 ** You can now use Guile as a shell script interpreter.
23 To paraphrase the SCSH manual:
25 When Unix tries to execute an executable file whose first two
26 characters are the `#!', it treats the file not as machine code to
27 be directly executed by the native processor, but as source code
28 to be executed by some interpreter. The interpreter to use is
29 specified immediately after the #! sequence on the first line of
30 the source file. The kernel reads in the name of the interpreter,
31 and executes that instead. It passes the interpreter the source
32 filename as its first argument, with the original arguments
33 following. Consult the Unix man page for the `exec' system call
36 Now you can use Guile as an interpreter, using a mechanism which is a
37 compatible subset of that provided by SCSH.
39 Guile now recognizes a '-s' command line switch, whose argument is the
40 name of a file of Scheme code to load. It also treats the two
41 characters `#!' as the start of a comment, terminated by `!#'. Thus,
42 to make a file of Scheme code directly executable by Unix, insert the
43 following two lines at the top of the file:
45 #!/usr/local/bin/guile -s
48 Guile treats the argument of the `-s' command-line switch as the name
49 of a file of Scheme code to load, and treats the sequence `#!' as the
50 start of a block comment, terminated by `!#'.
52 For example, here's a version of 'echo' written in Scheme:
54 #!/usr/local/bin/guile -s
56 (let loop ((args (cdr (program-arguments))))
60 (if (pair? (cdr args))
65 Why does `#!' start a block comment terminated by `!#', instead of the
66 end of the line? That is the notation SCSH uses, and although we
67 don't yet support the other SCSH features that motivate that choice,
68 we would like to be backward-compatible with any existing Guile
69 scripts once we do. Furthermore, if the path to Guile on your system
70 is too long for your kernel, you can start the script with this
74 exec /really/long/path/to/guile -s "$0" ${1+"$@"}
77 Note that some very old Unix systems don't support the `#!' syntax.
80 ** You can now run Guile without installing it.
82 Previous versions of the interactive Guile interpreter (`guile')
83 couldn't start up unless Guile's Scheme library had been installed;
84 they used the value of the environment variable `SCHEME_LOAD_PATH'
85 later on in the startup process, but not to find the startup code
86 itself. Now Guile uses `SCHEME_LOAD_PATH' in all searches for Scheme
89 To run Guile without installing it, build it in the normal way, and
90 then set the environment variable `SCHEME_LOAD_PATH' to a
91 colon-separated list of directories, including the top-level directory
92 of the Guile sources. For example, if you unpacked Guile so that the
93 full filename of this NEWS file is /home/jimb/guile-1.0b3/NEWS, then
96 export SCHEME_LOAD_PATH=/home/jimb/my-scheme:/home/jimb/guile-1.0b3
99 ** Guile's read-eval-print loop no longer prints #<unspecified>
100 results. If the user wants to see this, she can evaluate the
101 expression (assert-repl-print-unspecified #t), perhaps in her startup
104 ** Guile no longer shows backtraces by default when an error occurs;
105 however, it does display a message saying how to get one, and how to
106 request that they be displayed by default. After an error, evaluate
108 to see a backtrace, and
109 (debug-enable 'backtrace)
110 to see them by default.
114 * Changes to Guile Scheme:
116 ** Guile now distinguishes between #f and the empty list.
118 This is for compatibility with the IEEE standard, the (possibly)
119 upcoming Revised^5 Report on Scheme, and many extant Scheme
122 Guile used to have #f and '() denote the same object, to make Scheme's
123 type system more compatible with Emacs Lisp's. However, the change
124 caused too much trouble for Scheme programmers, and we found another
125 way to reconcile Emacs Lisp with Scheme that didn't require this.
128 ** Guile's delq, delv, delete functions, and their destructive
129 counterparts, delq!, delv!, and delete!, now remove all matching
130 elements from the list, not just the first. This matches the behavior
131 of the corresponding Emacs Lisp functions, and (I believe) the Maclisp
132 functions which inspired them.
134 I recognize that this change may break code in subtle ways, but it
135 seems best to make the change before the FSF's first Guile release,
139 ** The compiled-library-path function has been deleted from libguile.
141 ** The facilities for loading Scheme source files have changed.
143 *** The variable %load-path now tells Guile which directories to search
144 for Scheme code. Its value is a list of strings, each of which names
147 *** The variable %load-extensions now tells Guile which extensions to
148 try appending to a filename when searching the load path. Its value
149 is a list of strings. Its default value is ("" ".scm").
151 *** (%search-load-path FILENAME) searches the directories listed in the
152 value of the %load-path variable for a Scheme file named FILENAME,
153 with all the extensions listed in %load-extensions. If it finds a
154 match, then it returns its full filename. If FILENAME is absolute, it
155 returns it unchanged. Otherwise, it returns #f.
157 %search-load-path will not return matches that refer to directories.
159 *** (primitive-load FILENAME :optional CASE-INSENSITIVE-P SHARP)
160 uses %seach-load-path to find a file named FILENAME, and loads it if
161 it finds it. If it can't read FILENAME for any reason, it throws an
164 The arguments CASE-INSENSITIVE-P and SHARP are interpreted as by the
167 *** load uses the same searching semantics as primitive-load.
169 *** The functions %try-load, try-load-with-path, %load, load-with-path,
170 basic-try-load-with-path, basic-load-with-path, try-load-module-with-
171 path, and load-module-with-path have been deleted. The functions
172 above should serve their purposes.
174 *** If the value of the variable %load-hook is a procedure,
175 `primitive-load' applies its value to the name of the file being
176 loaded (without the load path directory name prepended). If its value
177 is #f, it is ignored. Otherwise, an error occurs.
179 This is mostly useful for printing load notification messages.
182 ** The function `eval!' is no longer accessible from the scheme level.
183 We can't allow operations which introduce glocs into the scheme level,
184 because Guile's type system can't handle these as data. Use `eval' or
185 `read-and-eval!' (see below) as replacement.
187 ** The new function read-and-eval! reads an expression from PORT,
188 evaluates it, and returns the result. This is more efficient than
189 simply calling `read' and `eval', since it is not necessary to make a
190 copy of the expression for the evaluator to munge.
192 Its optional arguments CASE_INSENSITIVE_P and SHARP are interpreted as
193 for the `read' function.
196 ** The function `int?' has been removed; its definition was identical
197 to that of `integer?'.
199 ** The functions `<?', `<?', `<=?', `=?', `>?', and `>=?'. Code should
200 use the R4RS names for these functions.
202 ** The function object-properties no longer returns the hash handle;
203 it simply returns the object's property list.
205 ** Many functions have been changed to throw errors, instead of
206 returning #f on failure. The point of providing exception handling in
207 the language is to simplify the logic of user code, but this is less
208 useful if Guile's primitives don't throw exceptions.
210 ** The function `fileno' has been renamed from `%fileno'.
212 ** The function primitive-mode->fdes returns #t or #f now, not 1 or 0.
215 * Changes to Guile's C interface:
217 ** The library's initialization procedure has been simplified.
218 scm_boot_guile now has the prototype:
220 void scm_boot_guile (int ARGC,
222 void (*main_func) (),
225 scm_boot_guile calls MAIN_FUNC, passing it CLOSURE, ARGC, and ARGV.
226 MAIN_FUNC should do all the work of the program (initializing other
227 packages, reading user input, etc.) before returning. When MAIN_FUNC
228 returns, call exit (0); this function never returns. If you want some
229 other exit value, MAIN_FUNC may call exit itself.
231 scm_boot_guile arranges for program-arguments to return the strings
232 given by ARGC and ARGV. If MAIN_FUNC modifies ARGC/ARGV, should call
233 scm_set_program_arguments with the final list, so Scheme code will
234 know which arguments have been processed.
236 scm_boot_guile establishes a catch-all catch handler which prints an
237 error message and exits the process. This means that Guile exits in a
238 coherent way when system errors occur and the user isn't prepared to
239 handle it. If the user doesn't like this behavior, they can establish
240 their own universal catcher in MAIN_FUNC to shadow this one.
242 Why must the caller do all the real work from MAIN_FUNC? The garbage
243 collector assumes that all local variables of type SCM will be above
244 scm_boot_guile's stack frame on the stack. If you try to manipulate
245 SCM values after this function returns, it's the luck of the draw
246 whether the GC will be able to find the objects you allocate. So,
247 scm_boot_guile function exits, rather than returning, to discourage
248 people from making that mistake.
250 The IN, OUT, and ERR arguments were removed; there are other
251 convenient ways to override these when desired.
253 The RESULT argument was deleted; this function should never return.
255 The BOOT_CMD argument was deleted; the MAIN_FUNC argument is more
259 ** Guile's header files should no longer conflict with your system's
262 In order to compile code which #included <libguile.h>, previous
263 versions of Guile required you to add a directory containing all the
264 Guile header files to your #include path. This was a problem, since
265 Guile's header files have names which conflict with many systems'
268 Now only <libguile.h> need appear in your #include path; you must
269 refer to all Guile's other header files as <libguile/mumble.h>.
270 Guile's installation procedure puts libguile.h in $(includedir), and
271 the rest in $(includedir)/libguile.
274 ** Two new C functions, scm_protect_object and scm_unprotect_object,
275 have been added to the Guile library.
277 scm_protect_object (OBJ) protects OBJ from the garbage collector.
278 OBJ will not be freed, even if all other references are dropped,
279 until someone does scm_unprotect_object (OBJ). Both functions
282 Note that calls to scm_protect_object do not nest. You can call
283 scm_protect_object any number of times on a given object, and the
284 next call to scm_unprotect_object will unprotect it completely.
286 Basically, scm_protect_object and scm_unprotect_object just
287 maintain a list of references to things. Since the GC knows about
288 this list, all objects it mentions stay alive. scm_protect_object
289 adds its argument to the list; scm_unprotect_object remove its
290 argument from the list.
293 ** scm_eval_0str now returns the value of the last expression
296 ** The new function scm_read_0str reads an s-expression from a
297 null-terminated string, and returns it.
299 ** The new function `scm_stdio_to_port' converts a STDIO file pointer
300 to a Scheme port object.
302 ** The new function `scm_set_program_arguments' allows C code to set
303 the value teruturned by the Scheme `program-arguments' function.
308 * Guile no longer includes sophisticated Tcl/Tk support.
310 The old Tcl/Tk support was unsatisfying to us, because it required the
311 user to link against the Tcl library, as well as Tk and Guile. The
312 interface was also un-lispy, in that it preserved Tcl/Tk's practice of
313 referring to widgets by names, rather than exporting widgets to Scheme
314 code as a special datatype.
316 In the Usenix Tk Developer's Workshop held in July 1996, the Tcl/Tk
317 maintainers described some very interesting changes in progress to the
318 Tcl/Tk internals, which would facilitate clean interfaces between lone
319 Tk and other interpreters --- even for garbage-collected languages
320 like Scheme. They expected the new Tk to be publicly available in the
323 Since it seems that Guile might soon have a new, cleaner interface to
324 lone Tk, and that the old Guile/Tk glue code would probably need to be
325 completely rewritten, we (Jim Blandy and Richard Stallman) have
326 decided not to support the old code. We'll spend the time instead on
327 a good interface to the newer Tk, as soon as it is available.
329 Until then, gtcltk-lib provides trivial, low-maintenance functionality.
332 Copyright information:
334 Copyright (C) 1996 Free Software Foundation, Inc.
336 Permission is granted to anyone to make or distribute verbatim copies
337 of this document as received, in any medium, provided that the
338 copyright notice and this permission notice are preserved,
339 thus giving the recipient permission to redistribute in turn.
341 Permission is granted to distribute modified versions
342 of this document, or of portions of it,
343 under the above conditions, provided also that they
344 carry prominent notices stating who last changed them.