* libguile/goops.c (scm_c_extend_primitive_generic): Use
`SCM_SET_SUBR_GENERIC ()' instead of using `SCM_SUBR_GENERIC ()' as an
lvalue.
* libguile/procs.c (scm_c_make_subr_with_generic): Use `SCM_SET_SUBR_GENERIC_LOC ()'.
* libguile/procs.h (SCM_SET_SUBR_GENERIC, SCM_SET_SUBR_GENERIC_LOC): New macros.
* libguile/procs.c (scm_c_make_subr): Remove comments about the number
of subrs, improve formatting.
* libguile/Makefile.am: Comment the generation of `snarf-gsubr.h'.
* module/language/ghil.scm: Whoops, export some unquote-splicing
accessors that we didn't have exported before.
* module/system/base/syntax.scm: Speed up record-case, by syntactically
determining the predicates and accessors. Nasty, in a way; but also
much faster.
* module/system/base/pmatch.scm (ppat): Match atoms with eq?, not equal?.
This speeds up compilation considerably, as we never match against
numbers or strings or what-have-you. Note, you can match against
literals with equal? via quoting the literal in the pattern.
* module/language/ghil/compile-glil.scm (codegen): Record source location
for offset 0 into a lambda, if we can.
* module/language/scheme/compile-ghil.scm (translate-1)
(define-scheme-translator): In the retrans procedures, propagate the
location information from the enclosing expression if the subexpression
has no location information. Gives source information to many more
expressions.
(location): Just propagate the source properties as they are, the
glil->assembly compiler will interpret them.
* module/language/glil.scm (<glil>): Change glil-source to take "props"
and not "loc", as it's the source properties that we're interested in.
* module/language/glil/compile-assembly.scm (limn-sources): New function,
takes a list of addr-source property pairs and "compresses" them for
serialization to disk.
(glil->assembly): Limn the sources before writing them to disk. Avoid
non-tail recursion when determining total byte length of code.
* module/system/vm/program.scm (source:file, source:line, source:column):
Update for new source representation.
(program-source): Export.
(write-program): Nicer pretty-printing of anonymous procedures.
* libguile/backtrace.c (display_backtrace_get_file_line): Update for the
new VM source representation.
* libguile/programs.h:
* libguile/programs.c (scm_program_sources): Update for the new
serialized source representation, where the filename is not in the
stream unless it changes.
(scm_program_source): New exported function, looks up the source for a
given ip offset.
(scm_c_program_source): Update to return the last source information
that was <= the given IP, because we only serialize source info when it
changes.
* module/language/scheme/compile-ghil.scm (lookup-transformer): Allow
macros to be unquoted into the car of any form that results from macro
expansion. This lets modules export defmacros built on other defmacros
that are not exported.
* libguile/stacks.c (scm_make_stack): Instead of aborting when we misread
the number of stack frames, just print a warning. I'd like to figure
out what these cases are, exactly.
* module/language/scheme/compile-ghil.scm (lambda): Reindent the lambda
transformer.
* module/system/base/compile.scm (call-with-compile-error-catch): Write
the expression instead of displaying it.
(call-with-output-file/atomic): Don't actually redirect output to this
port, as it's not necessary -- the language-printer should respect the
port that we pass.
(Reported by Panicz Maciej Godek.)
* test-suite/tests/syncase.test ("@ works with syncase"): New test.
* ice-9/syncase.scm (guile-macro): When a Guile macro transformer
produces a variable, don't pass it through sc-expand.
* libguile/frames.c (vm_frame_print): Add a frame printer.
* libguile/stacks.c (stack_depth, read_frames): Only switch the VM stack
for boot program dframes.
* libguile/vm-engine.c (VM_NAME): Push one debug frame per invocation,
unconditionally. (If we push them at all, of course.)
* libguile/programs.h (SCM_F_PROGRAM_IS_BOOT, SCM_PROGRAM_IS_BOOT): Flags
for determining if a program is a boot program. It turns out that our
heuristics e.g. in stacks.c would catch non-boot programs, like
programs that end with (goto/args 1), because the 1 is the same byte as
`halt'. That took a while to find...
* libguile/stacks.c (stack_depth, read_frames): Use the new boot prog
macros.
(scm_make_stack): Assert that we read the number of frames that we said
we would.
* libguile/vm.c (really_make_boot_program): Mark boot programs
appropriately.
* libguile/vm-engine.c (VM_PUSH_DEBUG_FRAMES): New knob, if true we much
with the scm_i_last_debug_frame when entering the VM, because sometimes
the evaluator doesn't do it for us.
(VM_ENGINE): Plug through debug frame fondling. Now, program exit comes
back to the main text. Rename err_args to finish_args, and reuse for
the return value.
* libguile/vm-engine.h (PUSH_LIST):
* libguile/vm-i-loader.c:
* libguile/vm-i-scheme.c:
* libguile/vm-i-system.c: Update for finish_args.
(halt): goto vm_done, now, instead of returning directly.
* libguile/eval.c (scm_call_0, scm_call_1, scm_call_2, scm_call_3)
(scm_call_4): Special-case compiled procedures here, to avoid consing.
* libguile/vm.h:
* libguile/vm.c (scm_c_vm_run): Take a SCM after all.
(scm_vm_apply, scm_load_compiled_with_vm): Adapt to vm_run change.
* libguile/programs.c (scm_make_program): Add a comment.
* libguile/vm-engine.h (INIT_ARGS): Add a couple of UNLIKELY notes.
* libguile/vm-i-system.c (make-closure): Inline the call to
scm_make_program, which avoids some redundant checks.
* libguile/vm-engine.c (VM_USE_HOOKS, VM_USE_CLOCK, VM_CHECK_EXTERNAL)
(VM_CHECK_OBJECT): Update to define these here, before including
vm-engine.h.
(vm_run): Change so that we can make different engines. Also, we take
an array of arguments, and the struct scm_vm directly, so as to avoid
any need to cons.
* libguile/vm-engine.h (CHECK_EXTERNAL, CHECK_OBJECT): Add some UNLIKELY
bits; don't seem to help.
* libguile/vm.c (vm_dispatch_hook): Change to not pass the VP. This needs
some love, and perhaps we revert to the old way.
(VM_ENGINE): Actually make two engines, vm_regular_engine and
vm_debug_engine. Probably there is room for improvement here. Actually
their speeds are the same at the moment.
(make_vm): Choose which engine to run; currently the debug engine by
default.
(scm_c_vm_run): A thin wrapper to invoke a VM without consing.
(scm_vm_apply): Use scm_c_vm_run.
(scm_load_compiled_with_vm): Use scm_c_vm_run.
* libguile/throw.c (scm_c_catch): Stash away the current vm's regs, and
restore them if there's a nonlocal exit. There is a terrible case we
have to handle if we catch from when the vm smob type isn't registered
but the throw has the vm registered, but I think we handle this fine.
* libguile/vm-engine.c (vm_run):
* libguile/vm-i-system.c (halt): Don't make a dynwind context, so that
entering the VM doesn't cons at all, except for the arg list. Maybe we
can fix that bit too.
* libguile/vm.c (vm_reset_stack): Remove, as there is no more dynwind.
(make_vm): Return #f if the tc16 hasn't yet been registered.
* libguile/instructions.c (fetch_instruction_table)
(scm_lookup_instruction_by_name): Rework so we lazily load instructions
into an array keyed by opcode, and a hash table keyed by symbolic name.
Much faster, in this hot spot of compilation.
* libguile/vm-engine.c (vm_run): Use malloc instead of scm_gc_malloc,
given that we aren't ever going to free this thing.
* libguile/vm-expand.h (VM_DEFINE_FUNCTION, VM_DEFINE_LOADER): Rework to
always be aliases to VM_DEFINE_INSTRUCTION.
(VM_DEFINE_INSTRUCTION): In the table case, update to work with
fetch_instruction_table().
* libguile/objects.c (scm_apply_generic): Inline the case when the
generic is a program.
* libguile/vm-i-system.c (return): Tick when functions return.
* module/oop/goops.scm (object-eqv?, object-equal?): Remove these
historical methods.
* libguile/goops.c (scm_port_class): Statically allocate it.
(create_port_classes): Don't use `scm_calloc ()'.
* libguile/goops.h (scm_port_class): Update declaration.
* libguile/ports.c (scm_make_port_type): When checking whether
GOOPS is initialized, check whether the first element of
SCM_PORT_CLASS is non-zero.
* libguile/goops.c (scm_smob_class): Statically allocate it.
(create_smob_classes): Don't malloc(3) `scm_smob_class'.
* libguile/goops.h (scm_smob_class): Update declaration.
* libguile/smob.c (scm_make_smob_type, scm_set_smob_apply): When
checking whether GOOPS is initialized, check whether the first element
of SCM_SMOB_CLASS is non-zero.
* libguile/goops.c (create_smob_classes): Refer to
`SCM_I_MAX_SMOB_TYPE_COUNT' rather than 255 (which is wrong) or 256.
* libguile/smob.c (MAX_SMOB_COUNT): Alias for `SCM_I_MAX_SMOB_TYPE_COUNT'.
* libguile/smob.h (SCM_I_MAX_SMOB_TYPE_COUNT): New macro.
* module/system/vm/program.scm:
* libguile/programs.h:
* libguile/programs.c (scm_program_bindings, scm_program_bindings)
(scm_program_properties, scm_program_name): Unfortunately, implement
more procs in C, so that C can use them more easily.
* libguile/debug.c (scm_procedure_name): Dispatch to scm_program_name as
appropriate.
* libguile/vm-i-system.c (call): Tick in a call.
* libguile/boehm-gc.h (SCM_I_IS_POINTER_TO_THE_HEAP): Use `GC_base ()'
instead of `GC_{least,greatest}_plausible_heap addr' since the GC does
not assume that the heap is contiguous (suggested by Ivan Maidanski
and Hans Boehm).
* libguile/vm-i-system.c (vector): Don't cons up a list just to make a
vector. Saves a couple percent in total cell allocation when loading
syncase. Probably not worth it, but foo!
* libguile/objcodes.c (scm_bytecode_to_objcode): Check that the length of
the vector matches the length embedded in the bytecode.
* libguile/programs.c (scm_program_meta): Call through to
scm_objcode_meta, instead of looking in the object table. Avoids
consing up a program+objcode slice for the meta until the meta is
actually called.
* libguile/vm-i-loader.c (load-program): Step past the metadata too.
* module/language/glil/compile-assembly.scm (make-meta): Just return the
load-program form, or #f.
(assoc-ref-or-acons, object-index-and-alist, make-object-table): Don't
write the meta into the object table.
(glil->assembly): Instead write the meta into the load-program form.
* libguile/objcodes.c (make_objcode_by_mmap, scm_c_make_objcode_slice):
Verify the lengths with the meta-length.
(scm_objcode_meta): New procedure, for getting at the meta-info of an
objcode.
(scm_objcode_to_bytecode):
(scm_write_objcode): Write bytecode with the metadata too.
* module/system/vm/objcode.scm: Export object-meta.
* module/language/assembly.scm (byte-length):
* module/language/assembly/compile-bytecode.scm (write-bytecode):
* module/language/assembly/decompile-bytecode.scm (decode-load-program):
* module/language/assembly/disassemble.scm (disassemble-load-program):
* module/language/glil/compile-assembly.scm (glil->assembly):
* test-suite/tests/asm-to-bytecode.test ("compiler"): Change to
load-program format to have meta-or-#f instead of meta-length, so that
we can serialize the meta as objcode without a load-program byte. Add a
test for writing out the meta.
* libguile/strings.c (SET_STRINGBUF_SHARED): Don't modify BUF if it's
already marked as shared since it might be a read-only stringbuf.
This error can be caught when linking with GNU ld with "-z relro".
* libguile/Makefile.am (snarf-gsubr.h): New target.
(BUILT_SOURCES, nodist_modinclude_HEADERS, MOSTLYCLEANFILES): Add
`snarf-gsubr.h'.
* libguile/procs.h (SCM_SUBR_ARITY_TO_TYPE): New macro.
* libguile/snarf.h (SCM_DEFINE): Rename to...
(SCM_DEFINE_GSUBR): this.
(SCM_DEFINE_SUBR)[SCM_SUPPORT_STATIC_ALLOCATION]: New macro.
(SCM_DEFINE_SUBR_reqX_optY_rstZ)[SCM_SUPPORT_STATIC_ALLOCATION]: New
set of macros.
(SCM_IMMUTABLE_SUBR): New macro.
* libguile/guile-snarf.in (modern_snarf): Allow several `SNARF_INIT ()'
per line. This makes it possible to write snarffing macros that
contain several `SNARF_INIT ()' invocations.
* module/system/vm/Makefile.am:
* module/system/vm/conv.scm:
* module/system/vm/disasm.scm: Remove these modules, as their
functionality is now in (language ...).
* libguile/objcodes.h:
* libguile/objcodes.c:
* module/system/vm/objcode.scm: Rename objcode->u8vector to
objcode->bytecode.
* module/system/vm/frame.scm:
* module/language/bytecode/spec.scm: Fix for objcode->bytecode.
* scripts/disassemble:
* testsuite/run-vm-tests.scm: Fix for (system vm disasm) removal.
* module/system/repl/command.scm: Use the right disassembler.
* module/language/assembly/Makefile.am:
* module/language/assembly/disassemble.scm: Add a disassembler, based on
the old one but fitting in with the decompiler tower.
* module/language/objcode/spec.scm (decompile-value): When decompiling
programs, shove all the metadata that we know about into the "env".
* module/system/base/compile.scm (decompile-fold, decompile): Return the
env from `decompile' as a second value. Not sure if `compile' should do
this too.
* module/language/assembly/Makefile.am:
* module/language/assembly/spec.scm:
* module/language/assembly/decompile-bytecode.scm: Add a bytecode
decompiler. Neat!
* module/language/bytecode/spec.scm (decompile-objcode):
* module/language/objcode/spec.scm (decompile-value): Add some
"decompilers" here too.
* module/system/base/compile.scm (current-language): Since we can refer
to languages by name, do so here -- removes the previous
anti-circularity hack.
(compile-file, compile): Refer to target languages by name.
(decompile): New public function. Neat!
* module/system/base/language.scm (lookup-decompilation-order): Fix so we
look for decompilers with the high-level language definition.
* module/system/base/language.scm (lookup-decompilation-order): New
function, like its compiling cousin, but backwards.
(compute-translation-order): Rework so that languages can be specified
either by name or by identity. Return a list of language - procedure
pairs, without the "to" language in the list, instead of a list of
languages.
(invalidate-compilation-cache!): Invalidate the decompilation cache
too.
(<language>): Add a decompiler field.
* module/system/base/compile.scm (compile-passes): Much simpler now that
lookup-compilation-order gives us the procedures directly.
* module/language/*/spec.scm: Specify compilers by name, so that we can
avoid unnecessary module loads, and so that when we specify
decompilers, we can avoid cycles.
