We recently modified scm_c_read so that it temporarily swaps the
caller's buffer with the port's normal read buffer, in order to
improve performance in the case where the port is unbuffered (which
actually means having a single-byte buffer) - but we implemented the
swap in the buffered case too. The latter turns out to be a bad idea
- because it means that the C code of a custom port implementation
cannot rely on a port's buffer always being the same as when it was
first set up - and so this commit reverts that. The buffer swapping
trick now applies to unbuffered ports only.
* libguile/ports.c (scm_c_read): Only do swapping of port and caller
buffer for unbuffered ports.
* doc/ref/compiler.texi: A new empty section on the compiler.
* doc/ref/data-rep.texi: Made to be a section of a chapter instead of an
appendix. The beginnings of some revision, but not there yet.
* doc/ref/guile.texi: Put the "Data Representation" essay into the new
"History and Implementation Details" chapter.
* doc/ref/history.texi: New empty section on Guile history.
* doc/ref/libguile-concepts.texi:
* doc/ref/libguile-smobs.texi: Fix up some xrefs.
* doc/ref/vm.texi: New section documenting the VM. Not done yet.
* module/system/base/language.scm (<language>): Rework so that instead of
hardcoding passes in the language, we define compilers that translate
from one language to another. Add `parser' to the language fields, a
bit of a hack but useful for languages with s-expression external
representations but with record internal representations.
(define-language, *compilation-cache*, invalidate-compilation-cache!)
(compute-compilation-order, lookup-compilation-order): Add an algorithm
that does a depth-first search for a translation path from a source
language to a target language, caching the result in a lookup table.
* module/language/scheme/spec.scm:
* module/language/ghil/spec.scm: Update to the new language format.
* module/language/glil/spec.scm: Add a language specification for GLIL,
with a compiler to objcode. Also there are parsers and printers, for
repl usage, but for some reason this doesn't work yet.
* module/language/objcode/spec.scm: Define a language specification for
object code. There is some sleight of hand here, in the "compiler" to
values; but there is method behind the madness, because this way we
higher levels can pass environments (a module + externals pair) to
objcode->program.
* module/language/value/spec.scm: Define a language specification for
values. There is something intellectually dishonest about this, but it
does serve its purpose as a foundation for the language hierarchy.
* configure.in:
* module/language/Makefile.am
* module/language/ghil/Makefile.am
* module/language/glil/Makefile.am
* module/language/objcode/Makefile.am
* module/language/value/Makefile.am:
Autotomfoolery for the ghil, glil, objcode, and value languages.
* module/language/scheme/translate.scm (translate): Import the bits that
understand `compile-time-environment' here, and pass on the relevant
portions of the environment to the next compiler pass.
* module/system/base/compile.scm (current-language): New procedure, refs
the current language fluid, or lazily sets it to scheme.
(call-once, call-with-output-file/atomic): Refactor these bits to use
with-throw-handler. No functional change.
(compile-file, compile-and-load, compile-passes, compile-fold)
(compile): Refactor the public interface of the compiler to be generic
and simple. Uses `lookup-compilation-order' to find a path from the
source language to the target language.
* module/system/base/syntax.scm (define-type): Adapt to changes in
define-record.
(define-record): Instead of expecting all slots in the first form,
expect them in the body, and let the first form hold the options.
* module/system/il/compile.scm (compile): Adapt to the compilation pass
API (three in and two out).
* module/system/il/ghil.scm (<ghil-var>, <ghil-env>)
(<ghil-toplevel-env>): Adapt to define-record changes.
* module/system/il/glil.scm (<glil-vars>): Adapt to define-record
changes.
(<glil>, print-glil): Add a GLIL record printer that uses unparse.
(parse-glil, unparse-glil): Update unparse (formerly known as pprint),
and write a parse function.
* module/system/repl/common.scm (<repl>): Adapt to define-record changes.
(repl-parse): New function, parses the read form using the current
language. Something of a hack.
(repl-compile): Adapt to changes in `compile'.
(repl-eval): Fix up the does-the-language-have-a-compiler check for
changes in <language>.
* module/system/repl/repl.scm (start-repl): Parse the form before eval.
* module/system/repl/command.scm (describe): Parse.
(compile): Be more generic.
(compile-file): Adapt to changes in compile-file.
(disassemble, time, profile, trace): Parse.
* module/system/vm/debug.scm:
* module/system/vm/assemble.scm: Adapt to define-record changes.
* module/language/scheme/translate.scm (receive): Fix an important bug
that gave `receive' letrec semantics instead of let semantics. Whoops!
* NEWS: Update.
* libguile/threads.c (scm_i_init_thread_for_guile): When the thread is
already guilified, update `t->base' so that it corresponds to the new
stack base. Bug report and patch by Linas Vepstas <linasvepstas@gmail.com>.
* test-suite/standalone/Makefile.am (test_scm_with_guile_CFLAGS,
test_scm_with_guile_LDADD): New.
(check_PROGRAMS, TESTS): Add `test-scm-with-guile'.
* doc/guile.1: Remove reference to the version and date. Mention R5RS,
instead of R4RS. Explicitly say that the full documentation is in
Texinfo (as other GNU packages do).
* module/system/il/ghil.scm (parse-ghil): Fix a typo for values*
(unparse-ghil): Only output (quote foo) if the object is a symbol.
(unparse-ghil): Fix some missing ,@.
* libguile/eval.c (scm_debug_opts): Whereas, today's machines are larger
than yesterday's; GCC consumes more words per stack frame than it used
to; and you can get quite some recursion in a halfway-compiled system,
be it resolved: let's bump up the C stack limit to 40k words (160 kB /
320 kB, depending on word size).
* module/system/repl/common.scm (repl-print): Slightly refine the meaning
of "language-printer": a language printer prints an expression of a
language, not the result of evaluation. `write' prints values.
* module/language/ghil/spec.scm (ghil): Define a language printer, and a
translator for turning s-expressions (not scheme, mind you) into GHIL.
* module/language/scheme/translate.scm (quote, quasiquote): Add some
#:keyword action, so that we can (quote #:keywords).
* module/system/base/language.scm (<language>):
* module/system/base/compile.scm (read-file-in): Don't require that a
language have a read-file; instead error when read-file is called.
(compile-passes, compile-in): Refactor to call a helper method to turn
the language + set of options into a set of compiler passes.
* module/system/base/syntax.scm (define-type): Allow the type to be a
list, with the car being the name and the cdr being keyword options.
Interpret #:printer as a printer, and pass it down to...
(define-record): Here.
* module/system/il/ghil.scm (print-ghil, <ghil>): New printer for GHIL,
yay!
(parse-ghil, unparse-ghil): New lovely functions. Will document them in
the manual.
* gc-benchmarks/gc-profile.scm (*iteration-count*): New parameter.
(run-benchmark): Moved from `twobit-compat.scm'. Honor
`*iteration-count*'.
(%options): Add `--iterations'.
(show-help): Document it.
(main): Parameterize `*iteration-count*'.
* gc-benchmarks/gc-profile.scm: Load "twobit-compat.scm".
(save-directory-excursion, load-larceny-benchmark): New procedures.
(%options): New variable.
(show-help, parse-args): New procedures.
(main): Use `parse-args' and `load-larceny-benchmark'.
This reverts par of "Document the failure of `gc.test' wrt. unused modules."
(commit 328efeb9a6.)
* ice-9/boot-9.scm (set-module-eval-closure!): Don't set the `module' property
on CLOSURE.
* libguile/modules.c (scm_lookup_closure_module): Call `abort ()' to make it
clear that code that uses the `module' property no longer works. That code
is unused anyway.
* module/system/vm/disasm.scm (disassemble-program): Don't print the
nargs= nrest= etc line, it's redundant.
* module/system/vm/program.scm (program-bindings-as-lambda-list): If the
program bindings is null, then that's that.
* module/srfi/srfi-69.scm: Move the macros up before the functions that
use them, so that the compiler can do its job.
(hash-table-walk): While it is true about what I said about R5RS
before, it seems that for R6 this will have to change. Anyway. In the
meantime, since the test suite checks that hash-table-walk procedures'
return values and number of return values are ignored, call that
procedure within a call-with-values.
* libguile/vm-i-system.c (return/values): In the
multiple-values-to-a-single-value-continuation (or MV but where N=1),
null out the correct number of values from the stack. Fixes aborts on
(apply values '(1)).
* testsuite/t-values.scm (call-with-values): Add a test.
* libguile/vm-i-system.c (call, goto/args): Handle the case in which a
non-program (i.e. interpreted program or a subr) returns multiple
values.
* testsuite/t-values.scm: Add test case that exhibited this problem.
* libguile/procs.c (scm_make_procedure_with_setter): Patch through the
getter's procedure name to the procedure-with-setter. Fixes part of the
srfi-17 test, as the VM doesn't set procedure-name on define -- but
perhaps that is the bug that should be fixed. In any case this patching
is cheap.
* test-suite/tests/eval.test: Change so that (define name pws) is
initially passed an anonymous procedure-with-setter, as was the case
before the procs.c change.
* module/srfi/srfi-19.scm: Some parts of this code used a strange idiom,
`(values)', to indicate that a procedure did nothing. However, quoth
R5RS:
Except for continuations created by the `call-with-values'
procedure, all continuations take exactly one value.
Indeed the VM indicated this error. I reworked the code to avoid these
cases.
Moved ice-9/ and oop/ under module/, with the idea being that we have
only scheme under module/. Adjusted configure.in and Makefile.am
appropriately. Put oop/ at the end of the compilation order.
* libguile/smob.c (scm_smob_prehistory): When initializing
SMOB_GC_KIND, pass 1 as the CLEAR_NEW_OBJECTS argument to
`GC_new_kind ()'. Without this, an assertion failure is
triggered in libgc's `reclaim.c'.
* oop/goops.scm: Define compiler hooks for dealing with @slot-ref and
@slot-set!.
(make-bound-check-get, make-get, make-set): Compile these indexed
accessors instead of having them be closures. Probably slower for the
memoizer, but faster for the vm... not sure what the perfect solution
is.
* test-suite/tests/goops.test ("defining classes"): Add a test that
defining a class with accessors works (it didn't until I figured out
that (@ (system base compile) compile) thing).
* module/system/base/compile.scm (call-with-nonlocal-exit-protect): New
helper, like unwind-protect but only for nonlocal exits.
(call-with-output-file/atomic): Use call-with-nonlocal-exit-protect so
that we don't mess up backtraces by catching all and then rethrowing.
Should fix this more comprehensively somewhere, though.
* module/system/il/inline.scm (define-inline): Use @ when accessing
module vars so that other modules don't need to import all of our
modules. However case-lambda is still needed.
* module/language/scheme/translate.scm (*translate-table*)
(define-scheme-translator): Rework the translator to have the clauses
defined separately via the define-scheme-translator macro, so that
external modules can define their own translators. Should be no
functional change in this commit, though.
* libguile/goops.c (get_slot_value, set_slot_value): While keeping the
inlined getter/setter dispatch for closures, allow the getters and
setters to be any kind of procedure.
* oop/goops.scm (compute-getters-n-setters): Relax the checks on
getter/setter procedures, so that if a getter is a procedure but not a
closure, we don't try to poke its arity.
* oop/goops/Makefile.am (SOURCES): Compile all the goops submodules!
* oop/goops/old-define-method.scm: Removed, in an act of housekeeping.
* oop/goops/compile.scm:
* oop/goops/dispatch.scm: Break a circular module dependency by making
sure that (oop goops) is loaded when we go to compile submodules.
* oop/goops/compile.scm (compile-method/memoizer)
(compile-method/memoizer+next): Allow a procedure without source
through. This can happen with getter and setter lambdas that were
compiled, and in that case there is no next-method call anyway. Ideally
we should be able to specify compile-method for accessor methods...
* libguile/goops.c (scm_sys_initialize_object): Don't assume that an init
thunk is a closure; just go through scm_call_0 instead.
* oop/goops/compile.scm (make-make-next-method/memoizer): Allow for the
case that the next method is compiled.
