Eval and code interpretationThis chapter describes the Bigloo evaluator.
Eval complianceBigloo includes an interpreter. Unfortunately, the language accepted by the interpreter is a proper subset of that accepted by the compiler. The main differences are:
- No foreign objects can be handled by interpreter.
- Classes of the object system cannot be declared within interpreted code.
- The interpreter ignores modules, and has a unique global environment.
car) are immutable. Hence, it optimizes these operators's calls. This optimization can be disabled using the
bigloo-eval-strict-moduleparameter described in the chapter describing the parameters (see see Parameters).
Eval standard functions
eval exp [env]procedureThis form evaluates exp. The second argument is optional. It can be the evaluation of one of these three function forms:
(scheme-report-environment 5) (null-environment 5) (interaction-environment)
interaction-environment versionprocedureThese three procedures have the definitions given in the R5RS so see Eval, scheme-report-environment, 6.5 Eval,r5rs.info,R5RS, for more details.
byte-code-compile exp [env (default-environment)]bigloo procedure
byte-code-run byte-codebigloo procedureThe function
byte-code-compilecompiles a Scheme expression into a sequence of byte codes that is implemented as a string. The function
byte-code-runexecute such a sequence.
replbigloo procedureThis invokes the read-eval-print loop. Several
replcan be embedded. The
replfunction can be used to implement custom Bigloo interpreters. For instance, one may write:
(module repl) (repl)When compiled, this will deliver an executable containingthe sole Bigloo interpreter.
set-repl-error-notifier! notifierbigloo procedure
get-repl-error-notifierbigloo procedureSet or get the procedure used in the REPLs to display errors. The notifier is a procedure of one argument, the error or exception that has been raised. Example:
(set-repl-error-notifier! (lambda (e) (print "=== error ======) (exception-notify e)))
quit bigloo procedureThis exits from the currently running
repl. If the current
replis the first one then this function ends the interpreter.
set-prompter! procbigloo procedureThe argument proc has to be a procedure of one argument and invoking this function sets the
replprompter. That is, to display its prompt,
replinvokes proc giving it the nesting level of the current loop as its argument.
get-prompterbigloo procedureReturns the current
set-repl-printer! procbigloo procedureThe argument proc has to be a procedure accepting one or two arguments. This function sets the
repldisplay function. That is, to display the result of its evaluations,
replinvokes proc giving it the evaluated expression as first argument and the current output port (or a file in case of transcript) as second argument.
Set-repl-printer!returns the former
repldisplay function. For instance, one may write:
1:=> (define x (cons 1 2)) ⇥ X 1:=> (define y (cons x x)) ⇥ Y 1:=> y ⇥ (#0=(1 . 2) . ) 1:=> (set-repl-printer! display) ⇥ #<procedure:83b8c70.-2> 1:=> y ⇥ ((1 . 2) 1 . 2)
native-repl-printerbigloo procedureReturns the native (default)
expand expbigloo procedureReturns the value of exp after all macro expansions have been performed.
expand-once expbigloo procedureReturns the value of exp after one macro expansion has been performed.
.keepIt is possible to specify files which have to be loaded when the interpreter is invoked. For this, see section see Compiler Description. If a Bigloo file starts with the line:
#! bigloo-command-nameand if this file is executable (in the meaning of the system) and if the user tries to execute it, Bigloo will evaluate it. Note also that SRFI-22 support enables to run any Unix interpreter (see SRFIs).
load filenamebigloo procedure
loadq filenamebigloo procedureFilename should be a string naming an existing file which contains Bigloo source code. This file is searched in the current directory and in all the directories mentioned in the variable
loadprocedure reads expressions and definitions from the file, evaluating them sequentially. If the file loaded is a module (i.e. if it begins with a regular module clause), load behaves as module initialization. Otherwise, this function returns the result of the last evaluation. The function
loadqdiffers from the function
loadin the sense that
loadqdoes not print any intermediate evaluations. Both functions return the full path of the loaded file.
loada filenamebigloo procedureLoads an ``access file'', which allows the interpreter to find the modules imported by a loaded module. It returns the full path of the loaded file.
*load-path*bigloo variableA list of search paths for the
dynamic-load filename #!optional (init init-point)bigloo procedureLoads a shared library named
filename. Returns the value of the last top-level expression. Important note: The function
dynamic-loadcan only be used from compiled modules linked against dynamic libraries. In particular, the
dynamic-loadfunction can be issued from the
bigloocommand if and only if the option
--sharedcompiler=yeshas been used when configuring Bigloo. If the
bigloocommand is not linked against dynamic libraries and if
dynamic-loadis required inside a read-eval-print loop (REPL) it exists a simple workaround. It consists in implementing a new REPL and linking it against dynamic libraries. This can be done as:
$ cat > new-repl.scm <<EOF (module new-repl) (repl) EOF $ bigloo new-repl.scm -o new-repl $ new-repl 1:=> (dynamic-load ...)1 If init-point is specified and if it is a string and if the library defines a function named
init-point, this function is called when the library is loaded. Init-point is a C identifier, not a Scheme identifier. In order to set the C name a Scheme function, use the extern
exportclause (see Section see C Interface). If the init-point is provided and is not a string, no initialization function is called after the library is loaded. If the init-point value is not provided, once the library is loaded,
dynamic-loaduses the Bigloo default entry point. Normally you should not provide an init-point to
dynamic-loadunless you known what you are doing. When producing C code, to force the Bigloo compiler to emit such a default entry point, use the
-dload-symcompilation option (see Section see Compiler Description). This option is useless when using the JVM code generator. Let's assume a Linux system and two Bigloo modules. The first:
(module mod1 (eval (export foo)) (export (foo x))) (define (foo x) (print "foo: " x)) (foo 4)The second:
(module mod2 (import (mod1 "mod1.scm")) (eval (export bar)) (export (bar x))) (define (bar x) (print "bar: " x)) (bar 5)If these modules are compiled as:
$ bigloo mod1.scm -c -o mod1.o $ bigloo mod2.scm -c -o mod2.o -dload-symThen, if a shared library is built using these two modules (note that on non Linux systems, a different command line is required):
$ ld -G -o lib.so mod1.o mod2.oThen,
lib.socant be dynamically loaded and the variables it defines used such as :
$ bigloo -i (dynamic-load "lib.so") ⇥ foo: 4 bar: 5 1:=> (foo 6) ⇥ foo: 7As the example illustrates, when Bigloo modules are dynamically loaded, they are initialized. This initialization is ensure only if
dynamic-loadis called with exactly one parameter. If
dynamic-loadis called with two parameters, it is of the responsibility of the program to initialize the dynamically loaded module before using any Scheme reference. Note: In order to let the loaded module accesses the variables defined by the loader application, special compilation flags must be used (e.g.,
-rdynamicunder the Linux operating system).
Dynamic-loadis implemented on the top of the
dlopenfacility. For more information read the
dynamic-unload filenamebigloo procedureOn the operating system that supports this facility, unloads a shared library. Returns
#ton success. Returns
*dynamic-load-path*bigloo variableA list of search paths for the
dynamic-load-symbol filename name #!optional modulebigloo-procedure
dynamic-load-symbol-set dlsym valbigloo-procedureThe function
dynamic-load-symbollooks up for a variable in the dynamic library filename. If found, it returns a
customBigloo object denoting that variable. Otherwise it returns
#f. This function assumes that filename has previously been successfully loaded with
dynamic-load. If not, an error is raised. The argument filename must be equal (in the sense of
string=?to the argument used to load the library. The C name of the looked up variable is name is module is not provided. Otherwise, it is the result of calling
bigloo-module-manglewith name and module as arguments. The function
dynamic-load-symbol-getreturns the value of a dynamically loaded variable. The function
dynamic-load-symbol-setsets the value of a dynamic loaded variable. It assumes that the variable is writable, i.e., that it has not been compiled as a C constant.
Eval command line optionsThis section presents the Bigloo compiler options that impact the interaction between compiled and interpreted code. The whole list of the Bigloo compiler options can be found in Compiler Description, , The Bigloo command line.
-iDon't compile a module, interpret it!
-export-allMake all the bindings defined by the compiled module available from the interpreter.
-export-exportMake all the bindings exported by the compiled module available from the interpreter.
-export-mutableMake all the bindings exported by the compiled module mutable from outside the module. This option is
dangerous! Either all the modules composing the application
must be compiled with or without
-export-mutable. It is impossible to mix
-export-mutableenabled and disabled compilations.