22.2 Eval standard functions

procedure: eval exp [env]

This 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)

procedure: scheme-report-environment version

procedure: null-environment version

procedure: interaction-environment version

These three procedures have the definitions given in the R5RS so see 6.5 Eval in R5RS, for more details.

bigloo procedure: byte-code-compile exp [env (default-environment)]

bigloo procedure: byte-code-run byte-code

The function byte-code-compile compiles a Scheme expression into a sequence of byte codes that is implemented as a string. The function byte-code-run execute such a sequence.

bigloo procedure: repl

This invokes the read-eval-print loop. Several repl can be embedded.

The repl function can be used to implement custom Bigloo interpreters. For instance, one may write:

(module repl)
(repl)

When compiled, this will deliver an executable containing the sole Bigloo interpreter.

bigloo procedure: quit

This exits from the currently running repl. If the current repl is the first one then this function ends the interpreter.

bigloo procedure: set-prompter! proc

The argument proc has to be a procedure of one argument and invoking this function sets the repl prompter. That is, to display its prompt, repl invokes proc giving it the nesting level of the current loop as its argument.

bigloo procedure: get-prompter

Returns the current repl prompter.

bigloo procedure: set-repl-printer! proc

The argument proc has to be a procedure accepting one or two arguments. This function sets the repl display function. That is, to display the result of its evaluations, repl invokes 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 repl display 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) . #0#)
1:=> (set-repl-printer! display)   -| #<procedure:83b8c70.-2>
1:=> y                             -| ((1 . 2) 1 . 2)

bigloo procedure: native-repl-printer

Returns the native (default) repl display function.

bigloo procedure: expand exp

Returns the value of exp after all macro expansions have been performed.

bigloo procedure: expand-once exp

Returns the value of exp after one macro expansion has been performed.

It is possible to specify files which have to be loaded when the interpreter is invoked. For this, see section see section Compiler description.

If a Bigloo file starts with the line:

 #! bigloo-command-name

and 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 section SRFIs).

bigloo procedure: load filename

bigloo procedure: loadq filename

Filename 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 *load-path*. The load procedure 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 loadq differs from the function load in the sense that loadq does not print any intermediate evaluations.

Both functions return the full path of the loaded file.

bigloo procedure: loada filename

Loads 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.

bigloo variable: *load-path*

A list of search paths for the load functions.

bigloo procedure: dynamic-load filename #!optional (init init-point)

Loads a shared library named filename.

Important note: The function dynamic-load can only be used from interpreters linked against dynamic libraries. In particular, the dynamic-load function can be issued from the bigloo command if and only if the option --sharedcompiler=yes has been used when configuring Bigloo. If the bigloo command is not linked against dynamic libraries and if dynamic-load is 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 ...)

The function dynamic-load returns the name of the loaded library. 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 export clause (see Section see section The 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-load uses the Bigloo default entry point. Normally you should not provide an init-point to dynamic-load unless 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-sym compilation option (see Section see section 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-sym

Then, 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.o

Then, lib.so cant 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: 7

As the example illustrates, when Bigloo modules are dynamically loaded, they are initialized. This initialization is ensure only if dynamic-load is called with exactly one parameter. If dynamic-load is 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., -rdynamic under the Linux operating system). Dynamic-load is implemented on the top of the dlopen facility. For more information read the dlopen and ld manuals.

bigloo procedure: dynamic-unload filename

On the operating system that supports this facility, unloads a shared library. Returns #t on success. Returns #f otherwise.

bigloo variable: *dynamic-load-path*

A list of search paths for the dynamic-load functions.

procedure: transcript-on filename

procedure: transcript-off

This document was generated on October 23, 2011 using texi2html 5.0.