3de80ed52f
* ice-9/boot-9.scm (compile-time-environment): Remove definition from boot-9 -- instead, autoload it and `compile' from (system base compile). * libguile/objcodes.h: * libguile/objcodes.c (scm_objcode_to_program): Add an optional argument, `external', the external list to set on the returned program. * libguile/vm-i-system.c (externals): New instruction, returns the external list. Only used by (compile-time-environment). * libguile/vm.c (scm_load_compiled_with_vm): Adapt to scm_objcode_to_program change. * module/language/scheme/translate.scm (translate): Actually pay attention to the environment passed as an argument. (custom-transformer-table): Expand out (compile-time-environment) to something that can be passed to `compile'. * module/system/base/compile.scm (*current-language*): Instead of hard-coding `scheme' in various places, use a current language fluid, initialized to `scheme'. (compile-file, load-source-file): Adapt to *current-language*. (load-source-file): Ada (scheme-eval): Removed, no one used this. (compiled-file-name): Don't hard-code "scm" and "go"; instead use the %load-extensions and %load-compiled-extensions. (cenv-module, cenv-ghil-env, cenv-externals): Some accessors for compile-time environments. (compile-time-environment): Here we define (compile-time-environment) to something that will return #f; the compiler however produces different code as noted above. (compile): New function, compiles an expression into a thunk, then runs the thunk to get the value. Useful for procedures. The optional second argument can be either a module or a compile-time-environment; in the latter case, we can recompile even with lexical bindings. (compile-in): If the env specifies a module, set that module for the duration of the compilation. * module/system/base/syntax.scm (%compute-initargs): Fix a bug where the default value for a field would always replace a user-supplied value. Whoops. * module/system/il/ghil.scm (ghil-env-dereify): New function, takes the result of ghil-env-reify and turns it back into a GHIL environment. * scripts/compile (compile): Remove some of the tricky error handling, as the library procedures handle this for us. * test-suite/tests/compiler.test: Add a test for the dynamic compilation bits. |
||
|---|---|---|
| .. | ||
| api-diff | ||
| autofrisk | ||
| ChangeLog-2008 | ||
| compile | ||
| disassemble | ||
| display-commentary | ||
| doc-snarf | ||
| frisk | ||
| generate-autoload | ||
| lint | ||
| Makefile.am | ||
| PROGRAM | ||
| punify | ||
| read-rfc822 | ||
| read-scheme-source | ||
| read-text-outline | ||
| README | ||
| scan-api | ||
| snarf-check-and-output-texi | ||
| snarf-guile-m4-docs | ||
| summarize-guile-TODO | ||
| use2dot | ||
Overview and Usage
------------------
This directory contains Scheme programs, some useful in maintaining Guile.
On "make install", these programs are copied to PKGDATADIR/VERSION/scripts.
You can invoke a program from the shell, or alternatively, load its file
as a Guile Scheme module, and use its exported procedure(s) from Scheme code.
Typically for any PROGRAM:
(use-modules (scripts PROGRAM))
(PROGRAM ARG1 ARG2 ...)
For programs that write to stdout, you might try, instead:
(use-modules (scripts PROGRAM))
(with-output-to-string (lambda () (PROGRAM ARG1 ARG2 ...)))
Note that all args must be strings.
To see PROGRAM's commentary, which may or may not be helpful:
(help (scripts PROGRAM))
To see all commentaries and module dependencies, try: "make overview".
If you want to try the programs before installing Guile, you will probably
need to set environment variable GUILE_LOAD_PATH to be the parent directory.
This can be done in Bourne-compatible shells like so:
GUILE_LOAD_PATH=`(cd .. ; pwd)`
export GUILE_LOAD_PATH
[FIXME: Can someone supply the csh-compatible equivalent?]
How to Contribute
-----------------
See template file PROGRAM for a quick start.
Programs must follow the "executable module" convention, documented here:
- The file name must not end in ".scm".
- The file must be executable (chmod +x).
- The module name must be "(scripts PROGRAM)". A procedure named PROGRAM w/
signature "(PROGRAM . args)" must be exported. Basically, use some variant
of the form:
(define-module (scripts PROGRAM)
:export (PROGRAM))
Feel free to export other definitions useful in the module context.
- There must be the alias:
(define main PROGRAM)
However, `main' must NOT be exported.
- The beginning of the file must use the following invocation sequence:
#!/bin/sh
main='(module-ref (resolve-module '\''(scripts PROGRAM)) '\'main')'
exec ${GUILE-guile} -l $0 -c "(apply $main (cdr (command-line)))" "$@"
!#
Following these conventions allows the program file to be used as module
(scripts PROGRAM) in addition to as a standalone executable. Please also
include a helpful Commentary section w/ some usage info.
[README ends here]