this is a compiler for LANG/BGB.

where possible the lang remains similar to the interpreted version.

the compiled version is modular. each piece of compiled code is implicitly part of a "module". each module has its own namespace which is normally not directly accessible from other modules, however modules with matching names will (sort of) share the same namespace.

the idea is that there is a 1-to-1 correspondence between modules and files.
the module "main" will serve as the entry point, similarly this module will be responsible for "calling" other modules (causing them to init or such).
the vars within a module will not have valid values before the module is called.

some functions were added for this:
(module <modname>)
allows declaration of the current module name.

(import-vars <modname> <vars>)
allows one to import vars from another module.
vars is a list of vars to import, each consists of the name of the var.

(extern-fcn <localname> <cname> <args> [<ctype>])
declares an external function (making it callable).
cname is the name the function is called in c.

args is a list of arguments, each has either the form "<name>" or "(<name> <ctype>)".
when a type is not defined, a variable is assumed to be dynamically typed. when ctype is included, it indicates that the variable has a specific type (in terms of the relation between LANG/BGB and c).

ctype's:
	int: int/fixnum;
	bool: int/#t|#f;
	character: int/character;
	float: float/flonum;
	double: double/flonum;
	string: 'char *'/string;
	symbol: 'char *'/symbol.

(extern-var <localname> <cname>)
declares an external variable.
cname is the c name of the variable.


object system:
object system, changed since interpreter.

objects are now based on slots (as opposed to patterns). similarly, there are now more consistent delegation and constructor rules...

(object-new)
creates a new (empty) object.

(object-clone <obj>)
manually clones an object.

(<obj> '<slot>)
refers to a slot within an obj, unlike the old system this can't refer to a bound method.

(<obj> '<slot> <value>)
assigns a slot within an obj, unlike the old system this also can't refer to a bound method.

(<obj> <method>: <args*>)
pass a message to a method defined within obj. within the method "self" refers to obj.

methods are now just lambda's stuck in slots. as such, they can be easily added/assigned, or extracted/copied between objects.

direct reference and application will retain "self" from the caller, thus allowing some forms of manual delegation.

2003-11-11:
(defconst <name> <value> [<desc>])
defines a constant. this will be usable as a variable that inlines value.
unlike define this will save having to define new toplevel bindings...

'--mod-def'
create a module definition file.
these have the base of the modname with an extension of "mdef".

'--mod-dir=<moddir>'
define the directory to use to create/search for module definitions.

(import-module <modname>)
try to open module definition file and import all bindings.

(export <vars*>)
export vars from current module.
if no vars are exported then all the top level bindings will be implicitly exported.