Uses of Class
gnu.expr.Expression

Packages that use Expression
gnu.commonlisp.lang   
gnu.ecmascript   
gnu.expr Supports Expression, and various related classes need to compile programming languages. 
gnu.jemacs.lang Contains classes to implement the Emacs Lisp language. 
gnu.kawa.brl   
gnu.kawa.functions   
gnu.kawa.lispexpr   
gnu.kawa.reflect Contains classes to use reflection. 
gnu.kawa.xml   
gnu.kawa.xslt   
gnu.mapping Supports Procedure, and various related classes needed at run-time by dynamically typed languages (such as Scheme and ECMAScript). 
gnu.q2.lang   
gnu.xquery.lang   
gnu.xquery.util   
kawa.lang   
kawa.standard   
 

Uses of Expression in gnu.commonlisp.lang
 

Fields in gnu.commonlisp.lang declared as Expression
static Expression Lisp2.nilExpr
           
 

Methods in gnu.commonlisp.lang that return Expression
 Expression UnwindProtect.rewrite(java.lang.Object obj, Translator tr)
           
 Expression prog1.rewrite(java.lang.Object obj, Translator tr)
           
 Expression setq.rewriteForm(Pair form, Translator tr)
           
 Expression defvar.rewriteForm(Pair form, Translator tr)
           
 Expression function.rewriteForm(Pair form, Translator tr)
           
 Expression defun.rewriteForm(Pair form, Translator tr)
           
 

Uses of Expression in gnu.ecmascript
 

Fields in gnu.ecmascript declared as Expression
static Expression[] Parser.emptyArgs
           
static Expression Parser.eofExpr
           
 

Methods in gnu.ecmascript that return Expression
 Expression Parser.buildLoop(Expression init, Expression test, Expression incr, Expression body)
           
 Expression Parser.makeCallExpression(Expression exp, Expression[] args)
           
 Expression Parser.makeNewExpression(Expression exp, Expression[] args)
           
 Expression Parser.makePropertyAccessor(Expression exp, Expression prop)
           
 Expression[] Parser.parseArguments()
           
 Expression Parser.parseAssignmentExpression()
           
 Expression Parser.parseBinaryExpression(int prio)
           
 Expression Parser.parseBlock()
           
 Expression Parser.parseConditionalExpression()
           
 Expression Parser.parseExpression()
           
 Expression Parser.parseFunctionDefinition()
           
 Expression Parser.parseIfStatement()
           
 Expression Parser.parseLeftHandSideExpression()
           
 Expression Parser.parsePostfixExpression()
           
 Expression Parser.parsePrimaryExpression()
           
 Expression Parser.parseStatement()
           
 Expression Parser.parseUnaryExpression()
           
 Expression Parser.parseWhileStatement()
           
 Expression Parser.syntaxError(java.lang.String message)
           
 

Methods in gnu.ecmascript with parameters of type Expression
 Expression Parser.buildLoop(Expression init, Expression test, Expression incr, Expression body)
           
 Expression Parser.makeCallExpression(Expression exp, Expression[] args)
           
 Expression Parser.makeCallExpression(Expression exp, Expression[] args)
           
 Expression Parser.makeNewExpression(Expression exp, Expression[] args)
           
 Expression Parser.makeNewExpression(Expression exp, Expression[] args)
           
 Expression Parser.makePropertyAccessor(Expression exp, Expression prop)
           
 

Uses of Expression in gnu.expr
 

Subclasses of Expression in gnu.expr
 class AccessExp
          A common super-type for ReferenceExpa and SetExp.
 class ApplyExp
          This class is used to represent "combination" or "application".
 class BeginExp
          This class represents a sequence of Expressions.
 class BlockExp
          Class used to implement a block that can be exited.
 class CatchClause
          A "catch" clause of a "try-catch" form.
 class ClassExp
           
 class ErrorExp
          Class used to mark an erroneous expression
 class ExitExp
          Expression to exit a lexically surrounding block.
 class FluidLetExp
          Class used to implement "fluid-let" for Scheme and "let" for Emacs.
 class IfExp
          This class represents a conditional.
 class LambdaExp
          Class used to implement Scheme lambda expressions.
 class LangExp
          A language-specific expression.
 class LetExp
          Class used to implement "let" syntax (and variants) for Scheme.
 class ModuleExp
          Class used to implement Scheme top-level environments.
 class ObjectExp
           
 class QuoteExp
          An Expression that evaluates to a constant value.
 class ReferenceExp
          This class represents a variable reference (an identifier).
 class ScopeExp
          Abstract class for expressions that add local variable bindings.
 class SetExp
          An Expression to set (bind) or define a new value to a named variable.
 class SynchronizedExp
           
 class ThisExp
          Evaluates to the "this" implicit variable.
 class TryExp
          This class represents try/catch/finally.
 

Fields in gnu.expr declared as Expression
 Expression LetExp.body
           
 Expression LambdaExp.body
           
 Expression[] LambdaExp.defaultArgs
           
 Expression[] LetExp.inits
           
static Expression[] Expression.noExpressions
           
 Expression LambdaExp.returnContinuation
          The unique call site that calls this lambda.
 Expression[] ClassExp.supers
          List of base classes and implemented interfaces.
protected  Expression Declaration.typeExp
           
protected  Expression Declaration.value
          If non-null, the single expression used to set this variable.
 

Fields in gnu.expr with type parameters of type Expression
 java.util.Stack<Expression> Compilation.exprStack
          A help vector for building expressions.
 

Methods in gnu.expr that return Expression
static Expression BeginExp.canonicalize(Expression exp)
          Simplifies BeginExp.
static Expression BeginExp.canonicalize(Expression[] exps)
           
 Expression InlineCalls.checkType(Expression exp, Type required)
           
 Expression TypeValue.convertValue(Expression value)
          Return converted expression or null.
protected static Expression Expression.deepCopy(Expression exp)
           
static Expression[] Expression.deepCopy(Expression[] exps, IdentityHashTable mapper)
           
static Expression Expression.deepCopy(Expression exp, IdentityHashTable mapper)
          Make a deep copy of this expression, if possible.
 Expression ApplyExp.deepCopy(IdentityHashTable mapper)
           
protected  Expression Expression.deepCopy(IdentityHashTable mapper)
           
 Expression QuoteExp.deepCopy(IdentityHashTable mapper)
           
protected  Expression ReferenceExp.deepCopy(IdentityHashTable mapper)
           
protected  Expression ExitExp.deepCopy(IdentityHashTable mapper)
           
protected  Expression ExpExpVisitor.defaultValue(Expression r, D d)
           
protected  Expression PushApply.defaultValue(Expression r, java.lang.Void ignored)
           
 Expression ApplyExp.getArg(int i)
           
 Expression[] ApplyExp.getArgs()
           
 Expression LetExp.getBody()
           
 Expression CatchClause.getBody()
           
 Expression IfExp.getElseClause()
           
 Expression[] BeginExp.getExpressions()
           
 Expression TryExp.getFinallyClause()
           
 Expression ApplyExp.getFunction()
           
 Expression SetExp.getNewValue()
          Get the Expression for calculating the new ("right-hand") value.
 Expression IfExp.getTest()
           
 Expression IfExp.getThenClause()
           
 Expression Declaration.getTypeExp()
           
 Expression Declaration.getValue()
          The value of this Declaration, if known.
static Expression InlineCalls.inlineCall(LambdaExp lexp, Expression[] args, boolean makeCopy)
          Attempt to inline a function call.
static Expression InlineCalls.inlineCalls(Expression exp, Compilation comp)
           
 Expression ApplyExp.inlineIfConstant(Procedure proc, InlineCalls visitor)
           
 Expression ApplyExp.inlineIfConstant(Procedure proc, SourceMessages messages)
          Inline this ApplyExp if parameters are constant.
 Expression Compilation.loopRepeat()
           
 Expression Compilation.loopRepeat(Expression exp)
           
 Expression Compilation.loopRepeat(Expression[] exps)
           
static Expression Compilation.makeCoercion(Expression value, Type type)
          Convenience method to make an Expression that coerces a value.
static Expression Expression.makeWhile(java.lang.Object cond, java.lang.Object body, Compilation parser)
          Helper method to create a `while' statement.
 Expression InlineCalls.maybeInline(ApplyExp exp, Type required, Procedure proc)
           
 Expression ExpVisitor.noteError(java.lang.String message)
           
 Expression Compilation.parse(java.lang.Object input)
          This may not make sense, except for Lisp-like languages.
 Expression Expression.setLine(Expression old)
           
 Expression Compilation.syntaxError(java.lang.String message)
          Handle syntax errors (at rewrite time).
protected  Expression ExpExpVisitor.update(Expression exp, Expression r)
           
protected  Expression PushApply.update(Expression exp, Expression r)
           
protected  Expression ExpVisitor.update(Expression exp, R r)
           
 Expression Expression.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
          Apply inlining transformations on a given ApplyExp.
 Expression QuoteExp.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
           
 Expression ReferenceExp.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
           
 Expression LambdaExp.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
           
 Expression InlineCalls.visit(Expression exp, Type required)
           
 Expression ExpVisitor.visitAndUpdate(Expression exp, D d)
           
protected  Expression FindTailCalls.visitApplyExp(ApplyExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitApplyExp(ApplyExp exp, Type required)
           
protected  Expression FindCapturedVars.visitApplyExp(ApplyExp exp, java.lang.Void ignored)
           
protected  Expression PushApply.visitApplyExp(ApplyExp exp, java.lang.Void ignored)
           
 Expression InlineCalls.visitApplyOnly(ApplyExp exp, Type required)
          Visit an ApplyExp assuming function and arguments have been visited.
protected  Expression FindTailCalls.visitBeginExp(BeginExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitBeginExp(BeginExp exp, Type required)
           
protected  Expression FindTailCalls.visitBlockExp(BlockExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitClassExp(ClassExp exp, Expression returnContinuation)
           
protected  Expression ChainLambdas.visitClassExp(ClassExp exp, ScopeExp scope)
           
protected  Expression FindCapturedVars.visitClassExp(ClassExp exp, java.lang.Void ignored)
           
protected  Expression FindTailCalls.visitExpression(Expression exp, Expression returnContinuation)
           
 Expression[] FindTailCalls.visitExps(Expression[] exps)
           
 Expression[] ExpVisitor.visitExps(Expression[] exps, D d)
           
 Expression[] ExpVisitor.visitExps(Expression[] exps, int n, D d)
          Call visit on the Expressions in an array.
protected  Expression FindTailCalls.visitFluidLetExp(FluidLetExp exp, Expression returnContinuation)
           
protected  Expression FindCapturedVars.visitFluidLetExp(FluidLetExp exp, java.lang.Void ignored)
           
protected  Expression FindTailCalls.visitIfExp(IfExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitIfExp(IfExp exp, Type required)
           
protected  Expression FindTailCalls.visitLambdaExp(LambdaExp exp, Expression returnContinuation)
           
protected  Expression ChainLambdas.visitLambdaExp(LambdaExp exp, ScopeExp scope)
           
protected  Expression InlineCalls.visitLambdaExp(LambdaExp exp, Type required)
           
protected  Expression FindCapturedVars.visitLambdaExp(LambdaExp exp, java.lang.Void ignored)
           
protected  Expression FindTailCalls.visitLetExp(LetExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitLetExp(LetExp exp, Type required)
           
protected  Expression FindCapturedVars.visitLetExp(LetExp exp, java.lang.Void ignored)
           
protected  Expression ResolveNames.visitLetExp(LetExp exp, java.lang.Void ignored)
           
protected  Expression FindCapturedVars.visitModuleExp(ModuleExp exp, java.lang.Void ignored)
           
protected  Expression InlineCalls.visitQuoteExp(QuoteExp exp, Type required)
           
protected  Expression FindTailCalls.visitReferenceExp(ReferenceExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitReferenceExp(ReferenceExp exp, Type required)
           
protected  Expression FindCapturedVars.visitReferenceExp(ReferenceExp exp, java.lang.Void ignored)
           
protected  Expression ResolveNames.visitReferenceExp(ReferenceExp exp, java.lang.Void ignored)
           
protected  Expression ChainLambdas.visitScopeExp(ScopeExp exp, ScopeExp scope)
           
protected  Expression InlineCalls.visitScopeExp(ScopeExp exp, Type required)
           
protected  Expression ResolveNames.visitScopeExp(ScopeExp exp, java.lang.Void ignored)
           
protected  Expression FindTailCalls.visitSetExp(SetExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitSetExp(SetExp exp, Type required)
           
protected  Expression FindCapturedVars.visitSetExp(SetExp exp, java.lang.Void ignored)
           
protected  Expression ResolveNames.visitSetExp(SetExp exp, java.lang.Void ignored)
           
protected  Expression ExpVisitor.visitSetExpValue(Expression new_value, D d, Declaration decl)
           
protected  Expression InlineCalls.visitSetExpValue(Expression new_value, Type required, Declaration decl)
           
protected  Expression FindTailCalls.visitSynchronizedExp(SynchronizedExp exp, Expression returnContinuation)
           
protected  Expression FindCapturedVars.visitThisExp(ThisExp exp, java.lang.Void ignored)
           
protected  Expression FindTailCalls.visitTryExp(TryExp exp, Expression returnContinuation)
           
protected  Expression InlineCalls.visitTryExp(TryExp exp, Type required)
           
 

Methods in gnu.expr with parameters of type Expression
 void BeginExp.add(Expression exp)
           
static Expression BeginExp.canonicalize(Expression exp)
          Simplifies BeginExp.
static Expression BeginExp.canonicalize(Expression[] exps)
           
static int SetExp.canUseInc(Expression rhs, Declaration target)
           
static void ChainLambdas.chainLambdas(Expression exp, Compilation comp)
           
static java.lang.Integer InlineCalls.checkIntValue(Expression exp)
           
static java.lang.Long InlineCalls.checkLongValue(Expression exp)
           
 Expression InlineCalls.checkType(Expression exp, Type required)
           
static void IfExp.compile(Expression test, Expression then_clause, Expression else_clause, Compilation comp, Target target)
           
static void Expression.compileButFirst(Expression exp, Compilation comp)
          Compile all but the first sub-"statement".
 void Expression.compileNotePosition(Compilation comp, Target target, Expression position)
          Compile, but take note of line number.
static void ApplyExp.compileToArray(Expression[] args, Compilation comp)
           
static void ConsumerTarget.compileUsingConsumer(Expression exp, Compilation comp, Target target)
          Compile an expression using a temporary Consumer, if needed.
static void ConsumerTarget.compileUsingConsumer(Expression exp, Compilation comp, Target target, Method makeMethod, Method resultMethod)
           
 void Expression.compileWithPosition(Compilation comp, Target target, Expression position)
          Same as 2-argument compileWithPosition, but use some other Expression's line number.
 boolean ConsumerTarget.compileWrite(Expression exp, Compilation comp)
           
 Expression TypeValue.convertValue(Expression value)
          Return converted expression or null.
static void BindingInitializer.create(Declaration decl, Expression value, Compilation comp)
          Create a BindingInitializer and link it into the correct intializer chain.
protected static Expression Expression.deepCopy(Expression exp)
           
static Expression[] Expression.deepCopy(Expression[] exps, IdentityHashTable mapper)
           
static Expression Expression.deepCopy(Expression exp, IdentityHashTable mapper)
          Make a deep copy of this expression, if possible.
protected  R ExpVisitor.defaultValue(Expression r, D d)
           
protected  Expression ExpExpVisitor.defaultValue(Expression r, D d)
           
protected  Expression PushApply.defaultValue(Expression r, java.lang.Void ignored)
           
static void FindCapturedVars.findCapturedVars(Expression exp, Compilation comp)
           
static void FindTailCalls.findTailCalls(Expression exp, Compilation comp)
           
 QuoteExp InlineCalls.fixIntValue(Expression exp)
           
 QuoteExp InlineCalls.fixLongValue(Expression exp)
           
static PrimProcedure PrimProcedure.getMethodFor(java.lang.Class procClass, java.lang.String name, Declaration decl, Expression[] args, Language language)
          Get PrimProcedure for matching method in given class.
static PrimProcedure PrimProcedure.getMethodFor(ClassType procClass, java.lang.String name, Declaration decl, Expression[] args, Language language)
           
static PrimProcedure PrimProcedure.getMethodFor(Procedure pproc, Declaration decl, Expression[] args, Language language)
          Search for a matching static method in a procedure's class.
static PrimProcedure PrimProcedure.getMethodFor(Procedure pproc, Expression[] args)
           
 Type PrimProcedure.getReturnType(Expression[] args)
           
 Type Language.getTypeFor(Expression exp)
           
 Type Language.getTypeFor(Expression exp, boolean lenient)
           
static Expression InlineCalls.inlineCall(LambdaExp lexp, Expression[] args, boolean makeCopy)
          Attempt to inline a function call.
static Expression InlineCalls.inlineCalls(Expression exp, Compilation comp)
           
 boolean Compilation.inlineOk(Expression proc)
           
 LetExp Compilation.letDone(Expression body)
           
 Declaration Compilation.letVariable(java.lang.Object name, Type type, Expression init)
           
 Declaration ResolveNames.lookup(Expression exp, java.lang.Object symbol, boolean function)
           
 void Compilation.loopBody(Expression body)
           
 void Compilation.loopCond(Expression cond)
           
 Expression Compilation.loopRepeat(Expression exp)
           
 Expression Compilation.loopRepeat(Expression[] exps)
           
 Declaration Compilation.loopVariable(java.lang.Object name, Type type, Expression init)
           
static ApplyExp Compilation.makeCoercion(Expression value, Expression type)
          Convenience method to make an Expression that coerces a value.
static Expression Compilation.makeCoercion(Expression value, Type type)
          Convenience method to make an Expression that coerces a value.
static SetExp SetExp.makeDefinition(Declaration decl, Expression val)
           
static SetExp SetExp.makeDefinition(java.lang.Object symbol, Expression val)
           
 void Declaration.makeField(ClassType frameType, Compilation comp, Expression value)
           
 void Declaration.makeField(Compilation comp, Expression value)
           
 void Declaration.noteValue(Expression value)
           
static void PushApply.pushApply(Expression exp)
           
 void ApplyExp.setArg(int i, Expression arg)
           
 void ApplyExp.setArgs(Expression[] args)
           
 void LetExp.setBody(Expression body)
           
 void CatchClause.setBody(Expression body)
           
 void BlockExp.setBody(Expression body)
           
 void BlockExp.setBody(Expression body, Expression exitBody)
           
 void LambdaExp.setCoercedReturnValue(Expression type, Language language)
          Modify LambdaExp so result is coerced to given type.
 void LambdaExp.setExceptions(Expression[] exceptions)
           
 void BeginExp.setExpressions(Expression[] exps)
           
 void ApplyExp.setFunction(Expression func)
           
 Expression Expression.setLine(Expression old)
           
 void Compilation.setLine(Expression position)
           
 void Declaration.setTypeExp(Expression typeExp)
           
 void Declaration.setValue(Expression value)
          Set the value associated with this Declaration.
protected  Expression ExpExpVisitor.update(Expression exp, Expression r)
           
protected  Expression PushApply.update(Expression exp, Expression r)
           
protected  Expression ExpVisitor.update(Expression exp, R r)
           
 R ExpVisitor.visit(Expression exp, D d)
          Call the visit method of argument Expression.
 Expression InlineCalls.visit(Expression exp, Type required)
           
 Expression ExpVisitor.visitAndUpdate(Expression exp, D d)
           
protected  Expression FindTailCalls.visitApplyExp(ApplyExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitBeginExp(BeginExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitBlockExp(BlockExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitClassExp(ClassExp exp, Expression returnContinuation)
           
protected  R ExpVisitor.visitExpression(Expression exp, D d)
           
protected  Expression FindTailCalls.visitExpression(Expression exp, Expression returnContinuation)
           
 Expression[] FindTailCalls.visitExps(Expression[] exps)
           
 Expression[] ExpVisitor.visitExps(Expression[] exps, D d)
           
 Expression[] ExpVisitor.visitExps(Expression[] exps, int n, D d)
          Call visit on the Expressions in an array.
protected  Expression FindTailCalls.visitFluidLetExp(FluidLetExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitIfExp(IfExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitLambdaExp(LambdaExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitLetExp(LetExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitReferenceExp(ReferenceExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitSetExp(SetExp exp, Expression returnContinuation)
           
protected  Expression ExpVisitor.visitSetExpValue(Expression new_value, D d, Declaration decl)
           
protected  Expression InlineCalls.visitSetExpValue(Expression new_value, Type required, Declaration decl)
           
protected  Expression FindTailCalls.visitSynchronizedExp(SynchronizedExp exp, Expression returnContinuation)
           
protected  Expression FindTailCalls.visitTryExp(TryExp exp, Expression returnContinuation)
           
 

Constructors in gnu.expr with parameters of type Expression
ApplyExp(Expression f, Expression[] a)
           
ApplyExp(Expression f, Expression[] a)
           
ApplyExp(Method m, Expression[] a)
           
ApplyExp(Procedure p, Expression[] a)
           
BeginExp(Expression[] ex)
           
BeginExp(Expression exp0, Expression exp1)
           
BindingInitializer(Declaration decl, Expression value)
           
ExitExp(Expression result, BlockExp block)
           
FluidLetExp(Expression[] i)
           
IfExp(Expression i, Expression t, Expression e)
           
LambdaExp(Expression body)
           
LetExp(Expression[] i)
           
SetExp(Declaration decl, Expression val)
           
SetExp(java.lang.Object symbol, Expression val)
           
SynchronizedExp(Expression object, Expression body)
           
TryExp(Expression try_clause, Expression finally_clause)
           
 

Uses of Expression in gnu.jemacs.lang
 

Methods in gnu.jemacs.lang that return Expression
 Expression SaveExcursion.rewrite(java.lang.Object obj, Translator tr)
           
 Expression While.rewriteForm(Pair form, Translator tr)
           
 Expression defgroup.rewriteForm(Pair form, Translator tr)
           
 Expression defcustom.rewriteForm(Pair form, Translator tr)
           
 

Uses of Expression in gnu.kawa.brl
 

Methods in gnu.kawa.brl that return Expression
 Expression BRL.makeBody(Expression[] exps)
           
 

Methods in gnu.kawa.brl with parameters of type Expression
 Expression BRL.makeBody(Expression[] exps)
           
 

Uses of Expression in gnu.kawa.functions
 

Methods in gnu.kawa.functions that return Expression
static Expression GetModuleClass.getModuleClassURI(Compilation comp)
          Return an expression that evaluates to a module-relative URL.
static Expression CompileNamedPart.makeExp(Expression clas, Expression member)
           
static Expression CompileNamedPart.makeExp(Expression clas, java.lang.String member)
           
static Expression CompileNamedPart.makeExp(Type type, java.lang.String member)
           
static Expression CompileNamedPart.makeGetNamedInstancePartExp(Expression member)
           
static Expression CompileArith.pairwise(Procedure proc, Expression rproc, Expression[] args, InlineCalls visitor)
          Convert (PROC A B C) to (PROC (PROC A B) C) etc.
static Expression CompileArith.validateApplyAdd(AddOp proc, ApplyExp exp, InlineCalls visitor)
           
static Expression CompileMisc.validateApplyAppendValues(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArith.validateApplyArithOp(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyCallCC(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyConstantFunction0(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyConvert(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArith.validateApplyDiv(DivideOp proc, ApplyExp exp, InlineCalls visitor)
           
static Expression CompileMisc.validateApplyFormat(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
          Validate-apply handling for "format".
static Expression CompileMisc.validateApplyMakeProcedure(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyMap(ApplyExp exp, InlineCalls visitor, Type required, Procedure xproc)
           
static Expression CompileMisc.validateApplyNot(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArith.validateApplyNot(ApplyExp exp, int kind, InlineCalls visitor)
           
static Expression CompileArith.validateApplyNumberCompare(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArith.validateApplyNumberPredicate(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompilationHelpers.validateApplyToArgs(ApplyExp exp, InlineCalls visitor, Type required, Procedure applyToArgs)
           
static Expression CompileMisc.validateApplyValuesMap(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileNamedPart.validateGetNamedInstancePart(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileNamedPart.validateGetNamedPart(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompilationHelpers.validateIsEqv(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileNamedPart.validateNamedPart(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileNamedPart.validateNamedPartSetter(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileNamedPart.validateSetNamedInstancePart(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileNamedPart.validateSetNamedPart(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompilationHelpers.validateSetter(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
 

Methods in gnu.kawa.functions with parameters of type Expression
static boolean CompileArith.appropriateIntConstant(Expression[] args, int iarg, InlineCalls visitor)
           
static boolean CompileArith.appropriateLongConstant(Expression[] args, int iarg, InlineCalls visitor)
           
static java.lang.String CompileNamedPart.combineName(Expression part1, Expression part2)
           
static void IsEq.compile(Expression[] args, Compilation comp, Target target, Language language)
           
static void MakeList.compile(Expression[] args, int offset, Compilation comp)
           
static void ValuesMap.compileInlined(LambdaExp lambda, Expression vals, int startCounter, Method matchesMethod, Compilation comp, Target target)
           
 boolean CompileArith.compileIntNum(Expression arg1, Expression arg2, int kind1, int kind2, Compilation comp)
           
 int CompileArith.getReturnKind(Expression[] args)
          This actually returns the "promoted argument type".
 Type CompileArith.getReturnType(Expression[] args)
           
 Type IsEq.getReturnType(Expression[] args)
           
 Type AppendValues.getReturnType(Expression[] args)
           
 Type CallCC.getReturnType(Expression[] args)
           
 Type ValuesMap.getReturnType(Expression[] args)
           
 Type MakeList.getReturnType(Expression[] args)
           
 Type NumberCompare.getReturnType(Expression[] args)
           
 Type GetModuleClass.getReturnType(Expression[] args)
           
static Expression CompileNamedPart.makeExp(Expression clas, Expression member)
           
static Expression CompileNamedPart.makeExp(Expression clas, java.lang.String member)
           
static Expression CompileNamedPart.makeGetNamedInstancePartExp(Expression member)
           
static Expression CompileArith.pairwise(Procedure proc, Expression rproc, Expression[] args, InlineCalls visitor)
          Convert (PROC A B C) to (PROC (PROC A B) C) etc.
static Expression CompileArith.pairwise(Procedure proc, Expression rproc, Expression[] args, InlineCalls visitor)
          Convert (PROC A B C) to (PROC (PROC A B) C) etc.
 

Uses of Expression in gnu.kawa.lispexpr
 

Methods in gnu.kawa.lispexpr that return Expression
 Expression LispLanguage.checkDefaultBinding(Symbol name, Translator tr)
          If a symbol is lexically unbound, look for a default binding.
 Expression LangObjType.convertValue(Expression value)
           
 Expression LangPrimType.convertValue(Expression value)
           
 Expression LispLanguage.makeApply(Expression func, Expression[] args)
           
 Expression LispLanguage.makeBody(Expression[] exps)
          Combine a consisting of a list of expression.
 Expression ResolveNamespace.rewriteForm(Pair form, Translator tr)
           
 Expression MakeXmlElement.rewriteForm(Pair form, Translator tr)
           
 Expression DefineNamespace.rewriteForm(Pair form, Translator tr)
           
 

Methods in gnu.kawa.lispexpr with parameters of type Expression
 Expression LangObjType.convertValue(Expression value)
           
 Expression LangPrimType.convertValue(Expression value)
           
 Expression LispLanguage.makeApply(Expression func, Expression[] args)
           
 Expression LispLanguage.makeApply(Expression func, Expression[] args)
           
 Expression LispLanguage.makeBody(Expression[] exps)
          Combine a consisting of a list of expression.
 

Uses of Expression in gnu.kawa.reflect
 

Methods in gnu.kawa.reflect that return Expression
 Expression OccurrenceType.convertValue(Expression value)
           
static Expression CompileReflect.validateApplyInstanceOf(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileInvoke.validateApplyInvoke(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileReflect.validateApplySlotGet(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileReflect.validateApplySlotSet(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileReflect.validateApplyTypeSwitch(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArrays.validateArrayGet(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArrays.validateArrayLength(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArrays.validateArrayNew(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileArrays.validateArraySet(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
 

Methods in gnu.kawa.reflect with parameters of type Expression
 Expression OccurrenceType.convertValue(Expression value)
           
 Type SlotGet.getReturnType(Expression[] args)
           
 Type InstanceOf.getReturnType(Expression[] args)
           
 Type StaticSet.getReturnType(Expression[] args)
           
 Type StaticGet.getReturnType(Expression[] args)
           
 Type TypeSwitch.getReturnType(Expression[] args)
           
static PrimProcedure Invoke.getStaticMethod(ClassType type, java.lang.String name, Expression[] args)
          Deprecated.  
static PrimProcedure CompileInvoke.getStaticMethod(ClassType type, java.lang.String name, Expression[] args)
           
static ApplyExp SlotGet.makeGetField(Expression value, java.lang.String fieldName)
          Convenience method to make an Expression that gets the value of a field.
static ApplyExp Invoke.makeInvokeStatic(ClassType type, java.lang.String name, Expression[] args)
          Return an ApplyExp that will call a method with given arguments.
 

Uses of Expression in gnu.kawa.xml
 

Methods in gnu.kawa.xml that return Expression
 Expression XDataType.convertValue(Expression value)
           
 Expression NodeType.convertValue(Expression value)
           
static Expression CompileXmlFunctions.validateApplyMakeUnescapedData(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileXmlFunctions.validateApplyTreeScanner(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
 

Methods in gnu.kawa.xml with parameters of type Expression
static void NodeConstructor.compileChild(Expression arg, Compilation comp, ConsumerTarget target)
           
static void NodeConstructor.compileUsingNodeTree(Expression exp, Compilation comp, Target target)
          Compile an expression using a fresh NodeTree.
 Expression XDataType.convertValue(Expression value)
           
 Expression NodeType.convertValue(Expression value)
           
 Type SortNodes.getReturnType(Expression[] args)
           
 Type NodeConstructor.getReturnType(Expression[] args)
           
 Type CoerceNodes.getReturnType(Expression[] args)
           
 Type MakeElement.getReturnType(Expression[] args)
           
 Type MakeAttribute.getReturnType(Expression[] args)
           
 Type UnionNodes.getReturnType(Expression[] args)
           
 

Uses of Expression in gnu.kawa.xslt
 

Methods in gnu.kawa.xslt that return Expression
 Expression XslTranslator.getExpression()
           
 

Uses of Expression in gnu.mapping
 

Methods in gnu.mapping with parameters of type Expression
 Type Procedure.getReturnType(Expression[] args)
          Semi-deprecated - instead should be set at Inline time.
 

Uses of Expression in gnu.q2.lang
 

Methods in gnu.q2.lang that return Expression
 Expression Q2.makeApply(Expression func, Expression[] args)
           
 Expression Q2.makeBody(Expression[] exps)
           
 

Methods in gnu.q2.lang with parameters of type Expression
 Expression Q2.makeApply(Expression func, Expression[] args)
           
 Expression Q2.makeApply(Expression func, Expression[] args)
           
 Expression Q2.makeBody(Expression[] exps)
           
 

Uses of Expression in gnu.xquery.lang
 

Fields in gnu.xquery.lang declared as Expression
static Expression XQParser.makeText
           
 

Methods in gnu.xquery.lang that return Expression
static Expression XQParser.booleanValue(Expression exp)
          Coerce the value of an expresison to a boolean value.
 Expression XQResolveNames.checkPragma(Symbol name, Expression contents)
           
 Expression XQParser.declError(java.lang.String message)
           
static Expression XQParser.makeFunctionExp(java.lang.String className, java.lang.String name)
           
static Expression XQParser.makeFunctionExp(java.lang.String className, java.lang.String fieldName, java.lang.String name)
           
 Expression XQParser.parse(Compilation comp)
          Parse an expression.
 Expression XQParser.parseDataType()
           
 Expression XQParser.parseFLWRExpression(boolean isFor)
           
 Expression XQParser.parseFLWRInner(boolean isFor)
          Parse a let- or a for-expression.
 Expression XQParser.parseFunctionDefinition(int declLine, int declColumn)
           
 Expression XQParser.parseIfExpr()
           
 Expression XQParser.parseItemType()
           
 Expression XQParser.parseMaybeKindTest()
           
 Expression XQParser.parseNamedNodeType(boolean attribute)
           
 Expression XQParser.parseOptionalTypeDeclaration()
          Parse: ["as" SequenceType]
 Expression XQParser.parseQuantifiedExpr(boolean isEvery)
          Parse a some- or an every-expression.
 Expression XQParser.syntaxError(java.lang.String message)
           
 Expression XQParser.syntaxError(java.lang.String message, java.lang.String code)
          Handle syntax errors (at rewrite time).
protected  Expression XQResolveNames.visitApplyExp(ApplyExp exp, java.lang.Void ignored)
           
protected  Expression XQResolveNames.visitReferenceExp(ReferenceExp exp, ApplyExp call)
           
protected  Expression XQResolveNames.visitReferenceExp(ReferenceExp exp, java.lang.Void ignored)
           
protected  Expression XQResolveNames.visitSetExp(SetExp exp, java.lang.Void ignored)
           
 

Methods in gnu.xquery.lang with parameters of type Expression
static Expression XQParser.booleanValue(Expression exp)
          Coerce the value of an expresison to a boolean value.
 Expression XQResolveNames.checkPragma(Symbol name, Expression contents)
           
 void XQParser.maybeSetLine(Expression exp, int line, int column)
           
 

Uses of Expression in gnu.xquery.util
 

Methods in gnu.xquery.util that return Expression
static Expression CompileMisc.validateApplyCastableAs(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyCastAs(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyOrderedMap(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyRelativeStep(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
           
static Expression CompileMisc.validateApplyValuesFilter(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
          Inliner for the ValuesFilter procedure.
static Expression CompileMisc.validateArithOp(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
          Inliner for the ArithOp procedure.
static Expression CompileMisc.validateBooleanValue(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
          Inliner for the BooleanValue procedure.
static Expression CompileMisc.validateCompare(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
          Inliner for the Compare procedure.
 

Methods in gnu.xquery.util with parameters of type Expression
static TreeScanner RelativeStep.extractStep(Expression exp)
           
 Type ArithOp.getReturnType(Expression[] args)
           
 Type RelativeStep.getReturnType(Expression[] args)
           
 Type OrderedMap.getReturnType(Expression[] args)
           
 Type ValuesFilter.getReturnType(Expression[] args)
           
 

Uses of Expression in kawa.lang
 

Subclasses of Expression in kawa.lang
 class PatternScope
          Bindings from a syntax-case/syntax-rules pattern.
 class TemplateScope
          A scope created when expanding a SyntaxTemplate.
 

Fields in kawa.lang declared as Expression
 Expression Lambda.defaultDefault
           
 

Methods in kawa.lang that return Expression
protected  Expression Quote.coerceExpression(java.lang.Object val, Translator tr)
           
protected  Expression Quote.leaf(java.lang.Object val, Translator tr)
           
 Expression Translator.parse(java.lang.Object input)
           
 Expression Translator.rewrite_body(java.lang.Object exp)
          Re-write a Scheme in S-expression format into internal form.
 Expression Translator.rewrite_car(Pair pair, boolean function)
           
 Expression Translator.rewrite_car(Pair pair, SyntaxForm syntax)
           
 Expression Translator.rewrite_pair(Pair p, boolean function)
           
 Expression Translator.rewrite_with_position(java.lang.Object exp, boolean function, PairWithPosition pair)
           
static Expression SyntaxForms.rewrite(java.lang.Object x)
           
 Expression Translator.rewrite(java.lang.Object exp)
          Re-write a Scheme expression in S-expression format into internal form.
 Expression Translator.rewrite(java.lang.Object exp, boolean function)
          Re-write a Scheme expression in S-expression format into internal form.
 Expression Lambda.rewrite(java.lang.Object obj, Translator tr)
           
 Expression Syntax.rewrite(java.lang.Object obj, Translator tr)
          Re-write an expression that is an "application" of this Syntax object.
 Expression Quote.rewrite(java.lang.Object obj, Translator tr)
           
static Expression SyntaxForms.rewriteBody(java.lang.Object x)
           
 Expression Macro.rewriteForm(java.lang.Object form, Translator tr)
           
 Expression Syntax.rewriteForm(java.lang.Object form, Translator tr)
           
 Expression Macro.rewriteForm(Pair form, Translator tr)
           
 Expression Lambda.rewriteForm(Pair form, Translator tr)
           
 Expression AutoloadSyntax.rewriteForm(Pair form, Translator tr)
           
 Expression Syntax.rewriteForm(Pair form, Translator tr)
           
 

Methods in kawa.lang with parameters of type Expression
 Type GetFieldProc.getReturnType(Expression[] args)
           
 Type SetFieldProc.getReturnType(Expression[] args)
           
 Symbol Translator.namespaceResolve(Expression context, Expression member)
           
 Symbol Translator.namespaceResolve(Namespace ns, Expression member)
           
 Namespace Translator.namespaceResolvePrefix(Expression context)
           
static void Translator.setLine(Expression exp, java.lang.Object location)
           
 void Translator.setLineOf(Expression exp)
          Set the line position of the argument to the current position.
 

Uses of Expression in kawa.standard
 

Methods in kawa.standard that return Expression
 Expression Scheme.checkDefaultBinding(Symbol symbol, Translator tr)
          If a symbol is lexically unbound, look for a default binding.
static Expression syntax_error.error(java.lang.Object form, java.lang.Object[] message)
           
protected  Expression syntax.leaf(java.lang.Object val, Translator tr)
           
 Expression Scheme.makeApply(Expression func, Expression[] args)
           
static Expression location.rewrite(Expression arg, Translator tr)
           
static Expression try_catch.rewrite(java.lang.Object try_part, java.lang.Object clauses)
           
 Expression fluid_let.rewrite(java.lang.Object bindings, java.lang.Object body, Translator tr)
           
 Expression location.rewrite(java.lang.Object obj, Translator tr)
           
 Expression fluid_let.rewrite(java.lang.Object obj, Translator tr)
           
 Expression prim_method.rewrite(java.lang.Object obj, Translator tr)
           
 Expression let_syntax.rewrite(java.lang.Object obj, Translator tr)
           
 Expression constant_fold.rewrite(java.lang.Object obj, Translator tr)
           
 Expression syntax_error.rewrite(java.lang.Object obj, Translator tr)
           
 Expression let.rewrite(java.lang.Object obj, Translator tr)
           
 Expression begin.rewrite(java.lang.Object obj, Translator tr)
           
 Expression define_alias.rewrite(java.lang.Object obj, Translator tr)
           
 Expression define_variable.rewriteForm(Pair form, Translator tr)
           
 Expression module_compile_options.rewriteForm(Pair form, Translator tr)
           
 Expression define_autoload.rewriteForm(Pair form, Translator tr)
           
 Expression set_b.rewriteForm(Pair form, Translator tr)
           
 Expression define_member_alias.rewriteForm(Pair form, Translator tr)
           
 Expression define_syntax.rewriteForm(Pair form, Translator tr)
           
 Expression object.rewriteForm(Pair form, Translator tr)
           
 Expression define.rewriteForm(Pair form, Translator tr)
           
 Expression syntax.rewriteForm(Pair form, Translator tr)
           
 Expression syntax_case.rewriteForm(Pair form, Translator tr)
           
 Expression require.rewriteForm(Pair form, Translator tr)
           
 Expression define_unit.rewriteForm(Pair form, Translator tr)
           
 Expression thisRef.rewriteForm(Pair form, Translator tr)
           
 Expression with_compile_options.rewriteForm(Pair form, Translator tr)
           
 Expression define_class.rewriteForm(Pair form, Translator tr)
           
 Expression export.rewriteForm(Pair form, Translator tr)
           
 Expression syntax_rules.rewriteForm(Pair form, Translator tr)
           
 Expression ImportFromLibrary.rewriteForm(Pair form, Translator tr)
           
 Expression module_static.rewriteForm(Pair form, Translator tr)
           
 

Methods in kawa.standard with parameters of type Expression
static Type Scheme.exp2Type(Expression exp)
          Convert expression to a Type.
 Type prim_throw.getReturnType(Expression[] args)
           
static Type Scheme.getTypeValue(Expression exp)
          If exp is a "constant" Type, return that type, otherwise return null.
 Expression Scheme.makeApply(Expression func, Expression[] args)
           
 Expression Scheme.makeApply(Expression func, Expression[] args)
           
static Expression location.rewrite(Expression arg, Translator tr)
           
 

Constructors in kawa.standard with parameters of type Expression
fluid_let(boolean star, Expression defaultInit)