Class Compilation

State code indicating the entire module has been parsed.

If non-null: a prefix for generateClassName to prepend to names.

Function results are written to the current CallContext's Consumer.

Support for full continuations. Not implemented.

Plain calling convention, using regular Java parameters and returns.

Like CALL_WITH_CONSUMER, but handle full on-stack-growing tail-calls.

State code indicating that bytecode has been written to its target.

State code indicating the bytecode has been generated.

State code that various compile-only data has been determined.

If true, print out expressions after parsing and before optimizations.

If true, print out final expressions after optimizations etc.

The default calling convention. One of the following CALL_WITHG_xxx values.

A help vector for building expressions.

If true, minimize the number of classes generated. Do this even if it makes things a little slower.

True if we should generate an Applet.

True if we should generate a main(String[]) method.

True if we should generate an Servlet.

True if the compiled result will be immediately loaded.

Current lexical scope - map name to Declaration.

The current method.

Generated class that extends ModuleBody. Normally same as mainClass.

If moduleStatic > 0, (module-static #t) is implied by default. If moduleStatic == 2, calls run. If moduleStatic < 0, (module-static #f) is implied by default.

True if the form is too complex to evaluate,and we must compile it. This is because it contains a construct we know how to compile, but not evaluate, and it it outside a function (which we always compile). This can be a let scope, or primitive procedure.

We have determined the module name and class, but not finished parsing.

State code for initial pre-parse looking for module name.

State code for lexical bindings having been resolved.

State code when various inlining and optimization passes are done.

Emit code to "evaluate" a compile-time constant. This is the normal external interface.

Parameters: value the value to be compiled

The same as getModule, until we allow nested modules.

Demangle a three-character mangling starting with '$'. UNFINISHED!

Search this Compilation for a ClassType with a given name.

Parameters: name the name of the class desired

Returns: the matching ClassType, or null if none is found

Generate ModuleBody's apply(CallContext) method Use the applyMethods vector, which contains methods that implement the (public, readable) methods of the current module.

Generate ModuleBody's apply0...applyN methods. Use the applyMethods vector, which contains methods that implement the (public, readable) methods of the current module.

Generate an unused class name.

Parameters: hint the requested name (or prefix)

Returns: a unique class name.

Get a named boolean option.

Get a named boolean option.

Generate a method to find a named Class without initializing it. Generate a static helper method "class$" like javac generates for 'CLASS.class', but does not initialize CLASS. Also, we don't bother catching exceptions, since the JVM doesn't require us to. I.e. generates: public static class $(String name) { return Class.forName(name, false, Class.forName(THISCLASSNAME).getClassLoader()); } Note that we want the result to use the same ClassLoader as the caller, which is why we generate a static helper method.

Returns a code indicating how far along we are in the parsing/compilation process.

Generate code to push the current CallContext on the JVM stack.

Generate code to load a named Class without initializing it.

Done handling loop variables, and pushes them into the lexical scope. Ready to parse the loop condition.

Start a new loop. (We could make this implied by the first loopVaribale call ???)

Convert a string to a safe Java identifier.

Parameters: reversible if we should use an invertible mapping.

Convert a string to a safe Java identifier.

Parameters: kind -1 - non-reversible; 0: reversible, except that '$' is not mapped; 1: reversible

Map a URI to a package/class name. Similar to the JAXB mangling, and that in the Java language spec.

Note that we have seen a construct that must be compiled, not evaluated. If we are not inside a lambda (which is always compiled), but only inside the outer-most ModuleExp, note that it must be compiled.

This may not make sense, except for Lisp-like languages. For those, 'input' an s-expression from the reader.

Parse/walk/compile this module as needed and requested. This method does not process any dependent modules (expect indirectly, such as may be done by a require form).

Parameters: wantedState the desired value of getState().

Set currentScope(). Also update the nesting object.

Call-back from compiled code to initialize literals in immediate mode. In non-immediate mode (i.e. generating class files) the compiler emits code to "re-construct" literal values. However, in immediate mode that would be wasteful, plus we would get values that are similar (equals) to but not necessarily identical (eq) to the compile-time literal. So we need to pass the literal values to the compiled code, by using reflection to initialize various static fields. This method does that. It is called at the start of the generated static initializer, which helps makes things more consistent between immediate and non-immediate mode.

Handle syntax errors (at rewrite time).

Parameters: message an error message to print out

Returns: an ErrorExp

Called for classes referenced in bytecode. Since this only does something when immediate, we only care about classes referenced in the bytecode when immediate. It is used to ensure that we can inherit from classes defines when in immediate mode (in Scheme using define-class or similar).

Shared processing for both compiling/eval.