Home >> All >> gnu >> [ expr Javadoc ]

• gnu.expr: Javadoc index of package gnu.expr.


Package Samples:

• gnu.expr

Classes:

• Declaration: The static information associated with a local variable binding. These are the kinds of Declaration we use: A local variable that is not captured by an inner lambda is stored in a Java local variables slot (register). The predicate isSimple () is true, and offset is the number of the local variable slot. If a local variable is captured by an inner lambda, the variable is stored in a field of the LambdaExp's heapFrame variable. (The latter declaration has isSimple and isArtificial true.) The Declaration's field specifies the Field used. If a function takes a fixed number of parameters, at most four, ...
• ModuleMethod: Call a specified method in in a ModuleBody. We use an extra level of indirection, but we save by having to create fewer classes than in the one-class-per-procedure scheme, without having to use (slow) reflection. ModuleMethod is redundant, since it could be replaced by ApplyMethodProc. However, ModuleMethod uses virtual method calls, while ApplyMethodProc uses the possibly much slower interface method calls.
• PushApply: Re-arranges ApplyExp where the function is a LetExp or BeginExp. Optimizes ((let (...) body) . args) to (let (...) (body . args)). Optimizes ((begin ... last) . args) to (begin ... (last . args)). This helps optimize Scheme "named let" (and some other forms) by making it more likely the application will be to a known procedure. This optimization has to be done after Declarations are bound.
• Interpreter: Contains various language-dependent methods. Also contains "global" state about the executation environment, such as the global Environment. There can be multiple Interpreters associated with different threads, representing mutiple top-levels. (However, this functionality is incomplete.)
• ModuleBody: Abstract class for the dummy top-level function of a module. This provides the functionality of gnu.mapping.ApplyMethodContainer, but it is class rather than an interface (thus ModuleMethod can use faster virtual method calls instead of slower interface calls).
• ChainLambdas: Sets up the firstChild/nextSibling links of each LambdaExp. Setup 'outer' links of ScopeExp and its sub-classes. Also generates a class name for each ClassExp and registers each class. Also, if lambda is bound to a unique declaration, make that its name.
• CheckedTarget: Same as StackTarget, but catch ClassCastException. Generate code so that if coercion fails, catch ClassCastException, and re-throw a WrongType. This gives better error messages.
• FindTailCalls: Does setTailCall on ApplyExp's that are tail-calls. Also setCanRead, setCanCall, setCanWrite on Declarations and setCanRead, setCanCall on LambdaExp when appropriate.
• LitTable: Manages the literals of a Compilation. Implements ObjectOutput, because we use externalization to determine how literals get compiled into code that re-creates the literal.
• Symbol: Utility class containing various routines to manipulate Scheme symbols. Note Scheme symbols are represented using java.lang.String objects, and there are no Symbol objects.
• ConditionalTarget: This is the Target of a boolean expression, in a conditional context. If the expression evaluates to, transfer to the ifTrue label; if false, tranfer to the ifFalse label.
• Package: A set of classes to generate as a java-like package. Extends expression to make it possible to walk the package. The walk is performed on each class of the package.
• BeginExp: This class represents a sequence of Expressions. The expressions are evaluated for their side-effects, and the value of the last Expression is the result.
• CopyArgument: Copy the value of a previous argument in the same function call. Used to implement optional arguments whose default value refers to another argument.
• ApplyExp: This class is used to represent "combination" or "application". A function and arguments are evaluated, and then the function applied.
• Expression: Abstract class for syntactic forms that evaluate to a value. Scheme S-expressions get re-written to these before evaluation.
• PairClassType: A class type implemented as a pair of an interface and a class. This is how true multiple inheritance can be implemented.
• CanInline: Inline an application, at the Expression level. In contrast, Inlineable is done at code generation time.
• ThisExp: Evaluates to the "this" implicit variable. This is currently neither robust nor general. FIXME!
• CheckContract: Check that a precondition holds, and that the body leads to the postcondition to hold.
• Parser: A very abstract "parser". Converts some input representation to Expression trees.
• SeriesTarget: The value in the result (as a sequence of values) is passed to a function.
• Initializer: A piece of code that needs to be added to , , or whatever.
• SetExp: An Expression to set (bind) or define a new value to a named variable.
• Target: This represents where a compiler can put the result of an expression.

Home | Contact Us | Privacy Policy | Terms of Service