* ice-9/boot-9.scm (@, @@): Note that these don't work with the compiler.
Damn.
(top-repl): Run the VM repl. Whooo!
* module/system/repl/repl.scm (start-repl): Catch 'quit, as the
scm-style-repl does. Newline after input EOF's, so that we don't leave
the user's shell messed up.
* module/language/scheme/spec.scm (scheme): Specify an evaluator, `eval'.
* module/system/repl/common.scm (repl-default-options): Add option,
`interp', specifying that, if possible, the repl should interpret its
expressions rather than compile them. Defaults to #f.
* libguile/programs.h (struct scm_program):
* libguile/programs.c (scm_c_make_program): Record the current module
when making a program. This replaces the per-late binding recorded
module in the generated code, which should be more efficient, both in
terms of garbage, and in not calling resolve-module.
(program-module): New accessor.
* module/system/vm/program.scm: Add program-module to exports.
* libguile/vm-i-loader.c (link-later): Remove this instruction, since now
the entry in the object table is just a symbol, and can be loaded with
load-symbol.
* libguile/vm-i-system.c (late-variable-ref, late-variable-set): Rework
so as to look up in the module of the current program. The logic could
be condensed quite a bit if scm_module_lookup () knew what to do with
mod==#f.
* module/system/vm/assemble.scm (dump-object!): Dump <vlink-later> just
as load-symbol, as mentioned in the note on link-later.
* module/system/il/ghil.scm: Update comment to reflect the new reality.
* module/system/base/syntax.scm (keywords): Don't enable :keywords, it
breaks code that may assume that ':foo is a symbol, like boot-9.
* module/*.scm: Don't use :keywords, use #:keywords. The user can decide
if she wants #:keywords in their .guile, and :keywords might make us
compile modules differently.
* module/system/vm/assemble.scm (make-meta, codegen): Hide the "meta"
information -- the names of the bindings, source info, procedure
properties, etc -- behind a lambda. This way, loading up a program
conses less, because the metadata stays as mmap'd code until it is
needed.
* libguile/vm-i-loader.c (load-program): Adjust load-program to expect
the metadata to be a program.
* module/system/vm/program.scm (program-bindings, program-sources)
(program-properties): Adjust to new meta format.
* ice-9/Makefile.am (SOURCES, NOCOMP_SOURCES): Compile boot-9.scm.
Wooooo! This makes some things harder to debug, and program loading
needs to cons much less, but I think it makes sense to compile boot-9
by default if for no other reason than to catch bugs earlier.
* ice-9/boot-9.scm (defmacro:syntax-transformer, define-syntax-macro):
Removed these, as I could not see anywhere they were being used, and
they use the unnecessary procedure->syntax procedure.
* module/language/scheme/translate.scm (%forbidden-primitives): Take
procedure->memoizing-macro off probation; although it's not a good
idea, there is a fair amount of existing code that uses it that can be
compiled fine. So allow it in that case.
* ice-9/boot-9.scm: Postpone module system boot until (%app modules) is
defined, so that resolve-module will work. This might not actually be
necessary given the previous tomfoolery in resolve-module, but it
doesn't seem like a bad change.
* libguile/modules.c (module-variable): If module is #f, access the
pre-modules-array. This is so that nested-ref can work before the
module system is booted, I think.
Of course all of these dependency lines during bootstrap are just to
make sure the system can be booted properly, either interpreted or
compiled, so there's no one right way: there are many ways that could
work.
* ice-9/boot-9.scm (resolve-module): Change so that resolving '(guile)
does not require any module lookups. This is so that while within a
call to (resolve-module '(guile)), we don't recurse when looking up the
location for e.g. `append'. I can imagine other ways to get around
this, but this one seems OK.
* libguile/vm-i-system.c (late-variable-ref, late-variable-set): If the
module system isn't booted, do a simple scm_lookup. In the -ref case,
actually cache the variable location (doh!).
* module/system/il/compile.scm (constant?, codegen): Add some diagnostics
so that we can get decent error reporting if we accidentally unquote an
unreadable value into the compiled output.
* module/system/il/ghil.scm (<ghil-env>, <ghil-toplevel-env>): Refactor
so that all environments point (eventually) at one toplevel
environment. Instead of having potentially multiple toplevel
environments, each noting the module against which its bindings are
resolved, have each binding in the toplevel record what module it
should be resolved in. Should fix compilation units that define
multiple modules.
(ghil-lookup, ghil-define): Reworked to not be destructive. Module
variables now have the module name as their "env", and are keyed as
`(MODNAME . SYM)' in the var table.
(call-with-ghil-environment): Reindented.
* module/system/il/inline.scm (try-inline-with-env): Adapt to
env/toplevel changes.
* module/system/vm/assemble.scm (dump-object!): A vlink-later now holds
the module name, not the module itself.
* module/system/il/compile.scm (make-glil-var): The "env" of a "module"
var is now the module name, not the module.
* module/language/scheme/translate.scm (primitive-syntax-table): Update
the way we test for toplevel environments. Reindent the lambda
translator.
(lookup-transformer, trans): lookup-transformer now has 2 args, not 3.
(translate): Update the way we make toplevel environments.
* module/system/vm/frame.scm (frame-call-representation): Show more of
lists.
(program-name): Avoid a traceback if (frame-address link) is #f. Not
sure when this can happen, but it does, and since this is already in
the backtrace function, there be badness there.
* libguile/load.h: Update scm_search_path prototype.
* libguile/load.c: Include vm.h for load-compiled/vm. Not sure if this is
bad wrt modularity.
(scm_c_string_has_an_ext): New private helper.
(scm_search_path): Add an extra optional arg, `require_exts'; if true,
require that the returned file name have one of the given extensions.
Changes the C API, but not the scheme API.
(scm_sys_search_load_path): Adapt to scm_search_path API change.
(primitive-load-path): Here is the craziness: load a compiled file if
found and newer than the corresponding (or not) source file.
(scm_init_load): Define %load-compiled-extensions as the list of
extensions denoting compiled files; defaults to '(".go").
* libguile/vm.c: Move 'vm-run, 'vm-error, 'debug sym initialization up to
the bootstrap phase, so they are ready if load-compiled/vm is called
before (system vm vm) is loaded.
* module/language/scheme/translate.scm (primitive-syntax-table): Disable
semantics of start-stack in compiled code. I think start-stack
semantics aren't bad, but they don't have vm-based implementations at
this point.
* ice-9/boot-9.scm (the-environment, the-root-environment)
(environment-module): Remove these representation of the interpreter's
idea of the environment, because they are not valid in the compiled
case, and are not part of the scheme spec anyway.
* ice-9/boot-9.scm (record-constructor, record-accessor)
(record-modifier): Avoid local-eval when possible, because it uses the
interpreter's representation of environments; and when we need to eval,
use primitive-eval instead. Slight semantic change in that this
evaluates relative to the current module rather than the root module,
but not really a biggie. Should make this compilable in the future,
somehow.
* ice-9/boot-9.scm: Before doing very much, put us into the (guile)
module when compiling. This avoids some circularity in the module boot
process, whereby symbols are seen to resolve to the (guile-user)
module, whereas in fact they originally pertain to the (guile) module.
* libguile/vm-i-loader.c (load-program):
* module/system/vm/assemble.scm (dump-object!): There are cases in which
we use the 16-bit representation for program params (nargs, nexts,
etc), but the actual 16-bit number actually fits into 8 bits -- which
is then misinterpreted by the loader as the 8-bit form. So ditch the
8-bit form entirely (it was never much of an optimization), and just
use the 16-bit form. Make sure to clear out all your .go files before
recompiling this one!
* libguile/vm-i-loader.c: A combination of superstition and a bugfix:
make sure that we treat bits as being of a type as wide as we think it
is, and, more importantly, allow for programs with 8 <= nargs < 16.
* .gitignore: Some touchups.
* configure.in:
* src/.cvsignore:
* src/Makefile.am:
* Makefile.am: No more src/.
* scripts/compile:
* scripts/disassemble: Moved here from src/ and changed into guile-tools
scripts.
* scripts/Makefile.am: Add the new scriptes.
* guilec.mk: Adapt to new way of invoking the compiler.
* libguile/vm-i-scheme.c (FUNC1): Remove, cause it's not used.
(FUNC2): Don't assume an inum can fit into an int, use scm_bits_t
instead. In reality though we should probably do use different checks,
i.e. for multiplication probably we overflow. (That would be a bug.)
Based on a patch by C. K. Jester-Young <cky944 <at> gmail.com>.
* guile-tools.in: Suppress ``WARNING: $ac_file_inputs seems to ignore the
--datarootdir setting'' message.
Patch from C. K. Jester-Young <cky944 <at> gmail.com>
* ice-9/Makefile.am: Integrate with guilec.mk, and start compiling
sources. Have to figure out what to do with procedure->memoized-macro
though, to get boot-9.scm compiling.
Thanks to Dale Smith.
* guilec.mk: Rework to expect the includer to define $(modpath), then
make $(moddir) from that.
* module/language/Makefile.am:
* module/language/scheme/Makefile.am:
* module/system/base/Makefile.am:
* module/system/il/Makefile.am:
* module/system/repl/Makefile.am:
* module/system/vm/Makefile.am: Define modpath instead.
* src/guilec.in: Don't import (system vm bootstrap), it is no more.
