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 in Guile 1.1 (Sun 5 Jan 1997):
9 * Changes to the distribution.
11 The Guile 1.0 distribution has been split up into several smaller
13 guile-core --- the Guile interpreter itself.
14 guile-tcltk --- the interface between the Guile interpreter and
15 Tcl/Tk; Tcl is an interpreter for a stringy language, and Tk
16 is a toolkit for building graphical user interfaces.
17 guile-rgx-ctax --- the interface between Guile and the Rx regular
18 expression matcher, and the translator for the Ctax
19 programming language. These are packaged together because the
20 Ctax translator uses Rx to parse Ctax source code.
22 We no longer distribute the documentation, since it was either out of
23 date, or incomplete. As soon as we have current documentation, we
26 * Changes to the stand-alone interpreter
28 ** guile now accepts command-line arguments compatible with SCSH, Olin
29 Shivers' Scheme Shell.
31 In general, arguments are evaluated from left to right, but there are
32 exceptions. The following switches stop argument processing, and
33 stash all remaining command-line arguments as the value returned by
34 the (command-line) function.
35 -s SCRIPT load Scheme source code from FILE, and exit
36 -c EXPR evalute Scheme expression EXPR, and exit
37 -- stop scanning arguments; run interactively
39 The switches below are processed as they are encountered.
40 -l FILE load Scheme source code from FILE
41 -e FUNCTION after reading script, apply FUNCTION to
42 command line arguments
43 -ds do -s script at this point
44 --emacs enable Emacs protocol (experimental)
45 -h, --help display this help and exit
46 -v, --version display version information and exit
47 \ read arguments from following script lines
49 So, for example, here is a Guile script named `ekko' (thanks, Olin)
50 which re-implements the traditional "echo" command:
52 #!/usr/local/bin/guile -s
55 (map (lambda (arg) (display arg) (display " "))
61 Suppose we invoke this script as follows:
65 Through the magic of Unix script processing (triggered by the `#!'
66 token at the top of the file), /usr/local/bin/guile receives the
67 following list of command-line arguments:
69 ("-s" "./ekko" "a" "speckled" "gecko")
71 Unix inserts the name of the script after the argument specified on
72 the first line of the file (in this case, "-s"), and then follows that
73 with the arguments given to the script. Guile loads the script, which
74 defines the `main' function, and then applies it to the list of
75 remaining command-line arguments, ("a" "speckled" "gecko").
77 * Changes to the procedure for linking libguile with your programs
79 ** Guile now builds and installs a shared guile library, if your
80 system support shared libraries. (It still builds a static library on
81 all systems.) Guile automatically detects whether your system
82 supports shared libraries. To prevent Guile from buildisg shared
83 libraries, pass the `--disable-shared' flag to the configure script.
85 Guile takes longer to compile when it builds shared libraries, because
86 it must compile every file twice --- once to produce position-
87 independent object code, and once to produce normal object code.
89 ** The libthreads library has been merged into libguile.
91 To link a program against Guile, you now need only link against
92 -lguile and -lqt; -lthreads is no longer needed. If you are using
93 autoconf to generate configuration scripts for your application, the
94 following lines should suffice to add the appropriate libraries to
97 ### Find quickthreads and libguile.
98 AC_CHECK_LIB(qt, main)
99 AC_CHECK_LIB(guile, scm_shell)
101 * Changes to Scheme functions
103 ** There are new accessors and setters for the broken-out time vectors
104 returned by `localtime', `gmtime', and that ilk. They are:
106 Component Accessor Setter
107 ========================= ============ ============
108 seconds tm:sec set-tm:sec
109 minutes tm:min set-tm:min
110 hours tm:hour set-tm:hour
111 day of the month tm:mday set-tm:mday
112 month tm:mon set-tm:mon
113 year tm:year set-tm:year
114 day of the week tm:wday set-tm:wday
115 day in the year tm:yday set-tm:yday
116 daylight saving time tm:isdst set-tm:isdst
117 GMT offset, seconds tm:gmtoff set-tm:gmtoff
118 name of time zone tm:zone set-tm:zone
120 ** There are new accessors for the vectors returned by `uname'.
123 ============================================== ================
124 name of the operating system implementation utsname:sysname
125 network name of this machine utsname:nodename
126 release level of the operating system utsname:release
127 version level of the operating system utsname:version
128 machine hardware platform utsname:machine
130 ** There is now a complete set of accessors for the vectors returned
133 ** The new function `eval-string' reads Scheme expressions from a
134 string and evaluates them, returning the value of the last expression
135 in the string. If the string contains no expressions, it returns an
138 ** The new function `command-line' returns the command-line arguments
139 given to Guile, as a list of strings.
141 When using guile as a script interpreter, `command-line' returns the
142 script's arguments; those processed by the interpreter (like `-s' or
143 `-c') are omitted. (In other words, you get the normal, expected
144 behavior.) Any application that uses scm_shell to process its
145 command-line arguments gets this behavior as well.
147 ** The new function `load-user-init' looks for a file called `.guile'
148 in the user's home directory, and loads it if it exists. This is
149 mostly for use by the code generated by scm_compile_shell_switches,
150 but we thought it might also be useful in other circumstances.
152 ** The new function `log10' returns the base-10 logarithm of its
155 ** gethost, getproto, and getnet, and getserv now return more helpful
158 * Changes to the gh_ interface
160 ** gh_eval_str() now returns an SCM object which is the result of the
163 ** gh_scm2str() now copies the Scheme data to a caller-provided C
166 ** gh_scm2newstr() now makes a C array, copies the Scheme data to it,
167 and returns the array
169 ** gh_scm2str0() is gone: there is no need to distinguish
170 null-terminated from non-null-terminated, since gh_scm2newstr() allows
171 the user to interpret the data both ways.
173 * Changes to the scm_ interface
175 ** The new function scm_shell makes it easy for user applications to
176 process command-line arguments in a way that is compatible with the
177 stand-alone guile interpreter (which is in turn compatible with SCSH,
180 To use the scm_shell function, first initialize any guile modules
181 linked into your application, and then call scm_shell with the values
182 of ARGC and ARGV your `main' function received. scm_shell will adding
183 any SCSH-style meta-arguments from the top of the script file to the
184 argument vector, and then process the command-line arguments. This
185 generally means loading a script file or starting up an interactive
186 command interpreter. For details, see "Changes to the stand-alone
189 ** [[new: scm_usage_name, scm_shell_usage, scm_compile_shell_switches]]
191 ** scm_eval_0str now returns SCM_UNSPECIFIED if the string contains no
192 expressions. It used to return SCM_EOL.
194 * Changes to documentation
196 ** the $(srcdir)/newdoc hierarchy now contains a new approach to the
197 manuals. The approach, recommended by Jim Blandy, is to have: (*) a
198 tutorial with the pedagogical style of guile-user, and a non-dry
199 reference manual in the style of the most excellent GNU libc reference
200 manual: the reference manual should be complete, but at the same time
201 it should have an introductory screen for each major topic, which can
202 be referenced if the user goes "up" a level in the info documentation.
207 User-visible changes from Thursday, September 5, 1996 until Guile 1.0
210 * Changes to the 'guile' program:
212 ** Guile now loads some new files when it starts up. Guile first
213 searches the load path for init.scm, and loads it if found. Then, if
214 Guile is not being used to execute a script, and the user's home
215 directory contains a file named `.guile', Guile loads that.
217 ** You can now use Guile as a shell script interpreter.
219 To paraphrase the SCSH manual:
221 When Unix tries to execute an executable file whose first two
222 characters are the `#!', it treats the file not as machine code to
223 be directly executed by the native processor, but as source code
224 to be executed by some interpreter. The interpreter to use is
225 specified immediately after the #! sequence on the first line of
226 the source file. The kernel reads in the name of the interpreter,
227 and executes that instead. It passes the interpreter the source
228 filename as its first argument, with the original arguments
229 following. Consult the Unix man page for the `exec' system call
230 for more information.
232 Now you can use Guile as an interpreter, using a mechanism which is a
233 compatible subset of that provided by SCSH.
235 Guile now recognizes a '-s' command line switch, whose argument is the
236 name of a file of Scheme code to load. It also treats the two
237 characters `#!' as the start of a comment, terminated by `!#'. Thus,
238 to make a file of Scheme code directly executable by Unix, insert the
239 following two lines at the top of the file:
241 #!/usr/local/bin/guile -s
244 Guile treats the argument of the `-s' command-line switch as the name
245 of a file of Scheme code to load, and treats the sequence `#!' as the
246 start of a block comment, terminated by `!#'.
248 For example, here's a version of 'echo' written in Scheme:
250 #!/usr/local/bin/guile -s
252 (let loop ((args (cdr (program-arguments))))
256 (if (pair? (cdr args))
261 Why does `#!' start a block comment terminated by `!#', instead of the
262 end of the line? That is the notation SCSH uses, and although we
263 don't yet support the other SCSH features that motivate that choice,
264 we would like to be backward-compatible with any existing Guile
265 scripts once we do. Furthermore, if the path to Guile on your system
266 is too long for your kernel, you can start the script with this
270 exec /really/long/path/to/guile -s "$0" ${1+"$@"}
273 Note that some very old Unix systems don't support the `#!' syntax.
276 ** You can now run Guile without installing it.
278 Previous versions of the interactive Guile interpreter (`guile')
279 couldn't start up unless Guile's Scheme library had been installed;
280 they used the value of the environment variable `SCHEME_LOAD_PATH'
281 later on in the startup process, but not to find the startup code
282 itself. Now Guile uses `SCHEME_LOAD_PATH' in all searches for Scheme
285 To run Guile without installing it, build it in the normal way, and
286 then set the environment variable `SCHEME_LOAD_PATH' to a
287 colon-separated list of directories, including the top-level directory
288 of the Guile sources. For example, if you unpacked Guile so that the
289 full filename of this NEWS file is /home/jimb/guile-1.0b3/NEWS, then
292 export SCHEME_LOAD_PATH=/home/jimb/my-scheme:/home/jimb/guile-1.0b3
295 ** Guile's read-eval-print loop no longer prints #<unspecified>
296 results. If the user wants to see this, she can evaluate the
297 expression (assert-repl-print-unspecified #t), perhaps in her startup
300 ** Guile no longer shows backtraces by default when an error occurs;
301 however, it does display a message saying how to get one, and how to
302 request that they be displayed by default. After an error, evaluate
304 to see a backtrace, and
305 (debug-enable 'backtrace)
306 to see them by default.
310 * Changes to Guile Scheme:
312 ** Guile now distinguishes between #f and the empty list.
314 This is for compatibility with the IEEE standard, the (possibly)
315 upcoming Revised^5 Report on Scheme, and many extant Scheme
318 Guile used to have #f and '() denote the same object, to make Scheme's
319 type system more compatible with Emacs Lisp's. However, the change
320 caused too much trouble for Scheme programmers, and we found another
321 way to reconcile Emacs Lisp with Scheme that didn't require this.
324 ** Guile's delq, delv, delete functions, and their destructive
325 counterparts, delq!, delv!, and delete!, now remove all matching
326 elements from the list, not just the first. This matches the behavior
327 of the corresponding Emacs Lisp functions, and (I believe) the Maclisp
328 functions which inspired them.
330 I recognize that this change may break code in subtle ways, but it
331 seems best to make the change before the FSF's first Guile release,
335 ** The compiled-library-path function has been deleted from libguile.
337 ** The facilities for loading Scheme source files have changed.
339 *** The variable %load-path now tells Guile which directories to search
340 for Scheme code. Its value is a list of strings, each of which names
343 *** The variable %load-extensions now tells Guile which extensions to
344 try appending to a filename when searching the load path. Its value
345 is a list of strings. Its default value is ("" ".scm").
347 *** (%search-load-path FILENAME) searches the directories listed in the
348 value of the %load-path variable for a Scheme file named FILENAME,
349 with all the extensions listed in %load-extensions. If it finds a
350 match, then it returns its full filename. If FILENAME is absolute, it
351 returns it unchanged. Otherwise, it returns #f.
353 %search-load-path will not return matches that refer to directories.
355 *** (primitive-load FILENAME :optional CASE-INSENSITIVE-P SHARP)
356 uses %seach-load-path to find a file named FILENAME, and loads it if
357 it finds it. If it can't read FILENAME for any reason, it throws an
360 The arguments CASE-INSENSITIVE-P and SHARP are interpreted as by the
363 *** load uses the same searching semantics as primitive-load.
365 *** The functions %try-load, try-load-with-path, %load, load-with-path,
366 basic-try-load-with-path, basic-load-with-path, try-load-module-with-
367 path, and load-module-with-path have been deleted. The functions
368 above should serve their purposes.
370 *** If the value of the variable %load-hook is a procedure,
371 `primitive-load' applies its value to the name of the file being
372 loaded (without the load path directory name prepended). If its value
373 is #f, it is ignored. Otherwise, an error occurs.
375 This is mostly useful for printing load notification messages.
378 ** The function `eval!' is no longer accessible from the scheme level.
379 We can't allow operations which introduce glocs into the scheme level,
380 because Guile's type system can't handle these as data. Use `eval' or
381 `read-and-eval!' (see below) as replacement.
383 ** The new function read-and-eval! reads an expression from PORT,
384 evaluates it, and returns the result. This is more efficient than
385 simply calling `read' and `eval', since it is not necessary to make a
386 copy of the expression for the evaluator to munge.
388 Its optional arguments CASE_INSENSITIVE_P and SHARP are interpreted as
389 for the `read' function.
392 ** The function `int?' has been removed; its definition was identical
393 to that of `integer?'.
395 ** The functions `<?', `<?', `<=?', `=?', `>?', and `>=?'. Code should
396 use the R4RS names for these functions.
398 ** The function object-properties no longer returns the hash handle;
399 it simply returns the object's property list.
401 ** Many functions have been changed to throw errors, instead of
402 returning #f on failure. The point of providing exception handling in
403 the language is to simplify the logic of user code, but this is less
404 useful if Guile's primitives don't throw exceptions.
406 ** The function `fileno' has been renamed from `%fileno'.
408 ** The function primitive-mode->fdes returns #t or #f now, not 1 or 0.
411 * Changes to Guile's C interface:
413 ** The library's initialization procedure has been simplified.
414 scm_boot_guile now has the prototype:
416 void scm_boot_guile (int ARGC,
418 void (*main_func) (),
421 scm_boot_guile calls MAIN_FUNC, passing it CLOSURE, ARGC, and ARGV.
422 MAIN_FUNC should do all the work of the program (initializing other
423 packages, reading user input, etc.) before returning. When MAIN_FUNC
424 returns, call exit (0); this function never returns. If you want some
425 other exit value, MAIN_FUNC may call exit itself.
427 scm_boot_guile arranges for program-arguments to return the strings
428 given by ARGC and ARGV. If MAIN_FUNC modifies ARGC/ARGV, should call
429 scm_set_program_arguments with the final list, so Scheme code will
430 know which arguments have been processed.
432 scm_boot_guile establishes a catch-all catch handler which prints an
433 error message and exits the process. This means that Guile exits in a
434 coherent way when system errors occur and the user isn't prepared to
435 handle it. If the user doesn't like this behavior, they can establish
436 their own universal catcher in MAIN_FUNC to shadow this one.
438 Why must the caller do all the real work from MAIN_FUNC? The garbage
439 collector assumes that all local variables of type SCM will be above
440 scm_boot_guile's stack frame on the stack. If you try to manipulate
441 SCM values after this function returns, it's the luck of the draw
442 whether the GC will be able to find the objects you allocate. So,
443 scm_boot_guile function exits, rather than returning, to discourage
444 people from making that mistake.
446 The IN, OUT, and ERR arguments were removed; there are other
447 convenient ways to override these when desired.
449 The RESULT argument was deleted; this function should never return.
451 The BOOT_CMD argument was deleted; the MAIN_FUNC argument is more
455 ** Guile's header files should no longer conflict with your system's
458 In order to compile code which #included <libguile.h>, previous
459 versions of Guile required you to add a directory containing all the
460 Guile header files to your #include path. This was a problem, since
461 Guile's header files have names which conflict with many systems'
464 Now only <libguile.h> need appear in your #include path; you must
465 refer to all Guile's other header files as <libguile/mumble.h>.
466 Guile's installation procedure puts libguile.h in $(includedir), and
467 the rest in $(includedir)/libguile.
470 ** Two new C functions, scm_protect_object and scm_unprotect_object,
471 have been added to the Guile library.
473 scm_protect_object (OBJ) protects OBJ from the garbage collector.
474 OBJ will not be freed, even if all other references are dropped,
475 until someone does scm_unprotect_object (OBJ). Both functions
478 Note that calls to scm_protect_object do not nest. You can call
479 scm_protect_object any number of times on a given object, and the
480 next call to scm_unprotect_object will unprotect it completely.
482 Basically, scm_protect_object and scm_unprotect_object just
483 maintain a list of references to things. Since the GC knows about
484 this list, all objects it mentions stay alive. scm_protect_object
485 adds its argument to the list; scm_unprotect_object remove its
486 argument from the list.
489 ** scm_eval_0str now returns the value of the last expression
492 ** The new function scm_read_0str reads an s-expression from a
493 null-terminated string, and returns it.
495 ** The new function `scm_stdio_to_port' converts a STDIO file pointer
496 to a Scheme port object.
498 ** The new function `scm_set_program_arguments' allows C code to set
499 the value teruturned by the Scheme `program-arguments' function.
504 * Guile no longer includes sophisticated Tcl/Tk support.
506 The old Tcl/Tk support was unsatisfying to us, because it required the
507 user to link against the Tcl library, as well as Tk and Guile. The
508 interface was also un-lispy, in that it preserved Tcl/Tk's practice of
509 referring to widgets by names, rather than exporting widgets to Scheme
510 code as a special datatype.
512 In the Usenix Tk Developer's Workshop held in July 1996, the Tcl/Tk
513 maintainers described some very interesting changes in progress to the
514 Tcl/Tk internals, which would facilitate clean interfaces between lone
515 Tk and other interpreters --- even for garbage-collected languages
516 like Scheme. They expected the new Tk to be publicly available in the
519 Since it seems that Guile might soon have a new, cleaner interface to
520 lone Tk, and that the old Guile/Tk glue code would probably need to be
521 completely rewritten, we (Jim Blandy and Richard Stallman) have
522 decided not to support the old code. We'll spend the time instead on
523 a good interface to the newer Tk, as soon as it is available.
525 Until then, gtcltk-lib provides trivial, low-maintenance functionality.
528 Copyright information:
530 Copyright (C) 1996,1997 Free Software Foundation, Inc.
532 Permission is granted to anyone to make or distribute verbatim copies
533 of this document as received, in any medium, provided that the
534 copyright notice and this permission notice are preserved,
535 thus giving the recipient permission to redistribute in turn.
537 Permission is granted to distribute modified versions
538 of this document, or of portions of it,
539 under the above conditions, provided also that they
540 carry prominent notices stating who last changed them.
545 paragraph-separate: "[
\f]*$"