Uses of Class
gnu.expr.Expression

Packages that use Expression

Package	Description
gnu.ecmascript
gnu.expr	Supports Expression, and various related classes need to compile programming languages.
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.xquery.lang
gnu.xquery.util
kawa.lang
kawa.standard

Uses of Expression in gnu.ecmascript

Fields in gnu.ecmascript declared as Expression

Modifier and Type	Field	Description
static final Expression[]	Parser.emptyArgs
static Expression	Parser.eofExpr

Methods in gnu.ecmascript that return Expression

Modifier and Type	Method	Description
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(String message)

Methods in gnu.ecmascript with parameters of type Expression

Modifier and Type	Method	Description
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)

Uses of Expression in gnu.expr

Subclasses of Expression in gnu.expr

Modifier and Type	Class	Description
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	CaseExp	This class represents a case expression
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	An expression that evaluated to an instance of an anonymous class.
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

Modifier and Type	Field	Description
Expression	Declaration.ValueSource.base
Expression	LambdaExp.body
static final Expression[]	Expression.noExpressions
Expression	LambdaExp.returnContinuation	The unique call site that calls this lambda.
Expression[]	ClassExp.supers	List of base classes and implemented interfaces.
Expression	Declaration.typeExp

Fields in gnu.expr with type parameters of type Expression

Modifier and Type	Field	Description
Stack<Expression>	Compilation.exprStack	A help vector for building expressions.
HashMap<Expression,Expression>	FindTailCalls.savedReturnContinuations
HashMap<Expression,Expression>	FindTailCalls.savedReturnContinuations

Methods in gnu.expr that return Expression

Modifier and Type	Method	Description
Expression	Compilation.applyFunction(Expression func)	A language-dependent "apply" function for generic application.
static final Expression	BeginExp.canonicalize(Expression exp)	Simplifies BeginExp.
static final Expression	BeginExp.canonicalize(Expression[] exps)
Expression	InlineCalls.checkType(Expression exp, Type required)
Expression	TypeValue.convertValue(Expression value)	Return converted expression or null.
Expression	ApplyExp.deepCopy(IdentityHashTable mapper)
protected Expression	ExitExp.deepCopy(IdentityHashTable mapper)
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 Expression	Expression.deepCopy(IdentityHashTable mapper)
Expression	QuoteExp.deepCopy(IdentityHashTable mapper)
protected Expression	ReferenceExp.deepCopy(IdentityHashTable mapper)
protected Expression	ExpExpVisitor.defaultValue(Expression r, D d)
protected Expression	PushApply.defaultValue(Expression r, Void ignored)
Expression	Declaration.getAnnotation(int i)	Indexed get of one of the annotations associated with this declaration.
Expression	ApplyExp.getArg(int i)
final Expression[]	ApplyExp.getArgs()
final Expression	CatchClause.getBody()
Expression	LetExp.getBody()
Expression	LambdaExp.getBodyFirstExpression()	Get the first expression/statement in the body.
Expression	IfExp.getElseClause()
final Expression[]	BeginExp.getExpressions()
final Expression	TryExp.getFinallyClause()
final Expression	ApplyExp.getFunction()
Expression	Declaration.getInitValue()	Get the "initial value" expression.
final Expression	SetExp.getNewValue()	Get the Expression for calculating the new ("right-hand") value.
Expression	IfExp.getTest()
Expression	IfExp.getThenClause()
final Expression	Declaration.getTypeExp()
Expression	Declaration.getTypeExpRaw()
final Expression	Declaration.getValue()	The value of this Declaration, if known.
Expression	Declaration.getValueRaw()
static Expression	InlineCalls.inlineCall(LambdaExp lexp, ApplyExp aexp, boolean makeCopy)	Attempt to inline a function call.
static Expression	InlineCalls.inlineCalls(Expression exp, Compilation comp)
final Expression	ApplyExp.inlineIfConstant(Procedure proc, InlineCalls visitor)
final Expression	ApplyExp.inlineIfConstant(Procedure proc, SourceMessages messages)	Inline this ApplyExp if parameters are constant.
Expression	Compilation.loopDone(Expression body)	Finish building a loop and return resulting expression.
Expression	Compilation.loopRepeat(LambdaExp loop, Expression... exps)	Recurse to next iteration of specified loop.
Expression	Compilation.loopRepeatDone(Expression... exps)	Combine loopRepeat and loopDone.
static Expression	Expression.makeWhile(Object cond, Object body, Compilation parser)	Helper method to create a `while' statement.
Expression	InlineCalls.maybeInline(ApplyExp exp, Type required, Procedure proc)
final Expression	Expression.maybeSetLine(Expression old)
protected Expression	ANormalize.normalizeName(Expression exp, gnu.expr.ANormalize.Context context)	Performs the bind operation, introducing a new let expression to capture the result of non-trivial expressions, which is bound to a new let variable.
protected Expression	ANormalize.normalizeNames(Expression[] exps, int index, gnu.expr.ANormalize.MultiContext context)	Deals with the normalization of multiple expressions.
protected Expression	ANormalize.normalizeTerm(Expression exp)	Starts the normalization of expression exp.
Expression	ExpVisitor.noteError(String message)
Expression	Compilation.parse(Object input)	This may not make sense, except for Lisp-like languages.
Expression	CaseExp.selectCase(Object keyValue)	Search for a clause containing the specified key.
final Expression	Expression.setLine(Expression old)
protected Expression	ExpExpVisitor.update(Expression exp, Expression r)
protected Expression	ExpVisitor.update(Expression exp, R r)
protected Expression	PushApply.update(Expression exp, Expression r)
Expression	Expression.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)	Apply inlining transformations on a given ApplyExp.
Expression	LambdaExp.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
Expression	QuoteExp.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
Expression	ReferenceExp.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	ANormalize.visitApplyExp(ApplyExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitApplyExp(ApplyExp exp, ScopeExp scope)
protected Expression	FindCapturedVars.visitApplyExp(ApplyExp exp, Void ignored)
protected Expression	FindTailCalls.visitApplyExp(ApplyExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitApplyExp(ApplyExp exp, Type required)
protected Expression	PushApply.visitApplyExp(ApplyExp exp, Void ignored)
final Expression	InlineCalls.visitApplyOnly(ApplyExp exp, Type required)	Visit an ApplyExp assuming function and arguments have been visited.
protected Expression	ANormalize.visitBeginExp(BeginExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitBeginExp(BeginExp exp, ScopeExp scope)
protected Expression	FindTailCalls.visitBeginExp(BeginExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitBeginExp(BeginExp exp, Type required)
protected Expression	ANormalize.visitBlockExp(BlockExp exp, gnu.expr.ANormalize.Context context)
protected Expression	FindTailCalls.visitBlockExp(BlockExp exp, Expression returnContinuation)
protected Expression	PushApply.visitBlockExp(BlockExp exp, Void ignored)
protected Expression	ANormalize.visitCaseExp(CaseExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitCaseExp(CaseExp exp, ScopeExp scope)
protected Expression	FindCapturedVars.visitCaseExp(CaseExp exp, Void ignored)
protected Expression	FindTailCalls.visitCaseExp(CaseExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitCaseExp(CaseExp exp, Type required)
protected Expression	PushApply.visitCaseExp(CaseExp exp, Void ignored)
protected Expression	ANormalize.visitClassExp(ClassExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitClassExp(ClassExp exp, ScopeExp scope)
protected Expression	FindCapturedVars.visitClassExp(ClassExp exp, Void ignored)
protected Expression	FindTailCalls.visitClassExp(ClassExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitClassExp(ClassExp exp, Type required)
protected Expression	PushApply.visitClassExp(ClassExp exp, Void ignored)
protected Expression	ANormalize.visitExitExp(ExitExp exp, gnu.expr.ANormalize.Context context)
protected Expression	FindTailCalls.visitExitExp(ExitExp exp, Expression returnContinuation)
protected Expression	PushApply.visitExitExp(ExitExp exp, Void ignored)
protected Expression	FindTailCalls.visitExpression(Expression exp, Expression returnContinuation)
Expression[]	ExpVisitor.visitExps(Expression[] exps, int n, D d)	Call visit on the Expressions in an array.
Expression[]	ExpVisitor.visitExps(Expression[] exps, D d)
Expression[]	FindTailCalls.visitExps(Expression[] exps)
protected Expression	FindCapturedVars.visitFluidLetExp(FluidLetExp exp, Void ignored)
protected Expression	FindTailCalls.visitFluidLetExp(FluidLetExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitFluidLetExp(FluidLetExp exp, Type required)
protected Expression	ANormalize.visitIfExp(IfExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitIfExp(IfExp exp, ScopeExp scope)
protected Expression	FindTailCalls.visitIfExp(IfExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitIfExp(IfExp exp, Type required)
protected Expression	PushApply.visitIfExp(IfExp exp, Void ignored)
protected Expression	ANormalize.visitLambdaExp(LambdaExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitLambdaExp(LambdaExp exp, ScopeExp scope)
protected Expression	FindCapturedVars.visitLambdaExp(LambdaExp exp, Void ignored)
protected Expression	FindTailCalls.visitLambdaExp(LambdaExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitLambdaExp(LambdaExp exp, Type required)
protected Expression	PushApply.visitLambdaExp(LambdaExp exp, Void ignored)
protected Expression	ANormalize.visitLetExp(LetExp exp, gnu.expr.ANormalize.Context context)	Besides handling "let" and "fluidlet" normalization, it flattens the nesting of let expressions.
protected Expression	ChainLambdas.visitLetExp(LetExp exp, ScopeExp scope)
protected Expression	FindCapturedVars.visitLetExp(LetExp exp, Void ignored)
protected Expression	FindTailCalls.visitLetExp(LetExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitLetExp(LetExp exp, Type required)
protected Expression	ResolveNames.visitLetExp(LetExp exp, Void ignored)
protected Expression	ANormalize.visitModuleExp(ModuleExp exp, gnu.expr.ANormalize.Context context)
protected Expression	FindCapturedVars.visitModuleExp(ModuleExp exp, Void ignored)
protected Expression	FindTailCalls.visitModuleExp(ModuleExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitModuleExp(ModuleExp exp, Type required)
protected Expression	ANormalize.visitQuoteExp(QuoteExp exp, gnu.expr.ANormalize.Context context)
protected Expression	InlineCalls.visitQuoteExp(QuoteExp exp, Type required)
protected Expression	ANormalize.visitReferenceExp(ReferenceExp exp, gnu.expr.ANormalize.Context context)
protected Expression	FindCapturedVars.visitReferenceExp(ReferenceExp exp, Void ignored)
protected Expression	InlineCalls.visitReferenceExp(ReferenceExp exp, Type required)
protected Expression	PushApply.visitReferenceExp(ReferenceExp exp, Void ignored)
protected Expression	ResolveNames.visitReferenceExp(ReferenceExp exp, Void ignored)
protected Expression	ChainLambdas.visitScopeExp(ScopeExp exp, ScopeExp scope)
protected Expression	InlineCalls.visitScopeExp(ScopeExp exp, Type required)
protected Expression	ResolveNames.visitScopeExp(ScopeExp exp, Void ignored)
protected Expression	ANormalize.visitSetExp(SetExp exp, gnu.expr.ANormalize.Context context)
protected Expression	ChainLambdas.visitSetExp(SetExp sexp, ScopeExp scope)
protected Expression	FindCapturedVars.visitSetExp(SetExp exp, Void ignored)
protected Expression	FindTailCalls.visitSetExp(SetExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitSetExp(SetExp exp, Type required)
protected Expression	ResolveNames.visitSetExp(SetExp exp, Void ignored)
protected Expression	ANormalize.visitSynchronizedExp(SynchronizedExp exp, gnu.expr.ANormalize.Context context)
protected Expression	FindTailCalls.visitSynchronizedExp(SynchronizedExp exp, Expression returnContinuation)
protected Expression	FindCapturedVars.visitThisExp(ThisExp exp, Void ignored)
protected Expression	ANormalize.visitTryExp(TryExp exp, gnu.expr.ANormalize.Context context)
protected Expression	FindTailCalls.visitTryExp(TryExp exp, Expression returnContinuation)
protected Expression	InlineCalls.visitTryExp(TryExp exp, Type required)
protected Expression	PushApply.visitTryExp(TryExp exp, Void ignored)

Methods in gnu.expr with parameters of type Expression

Modifier and Type	Method	Description
final void	BeginExp.add(Expression exp)
void	Declaration.addAnnotation(Expression exp)	Add an annotation to the set of our annotations.
void	TryExp.addCatchClause(Declaration decl, Expression body)
static void	ANormalize.aNormalize(Expression exp, Compilation comp)
Expression	Compilation.applyFunction(Expression func)	A language-dependent "apply" function for generic application.
protected Object	CaseExp.calculateDatumValue(Expression datum)	Given the expression generated from a datum returns the value of the datum as an Object.
static final Expression	BeginExp.canonicalize(Expression exp)	Simplifies BeginExp.
static final Expression	BeginExp.canonicalize(Expression[] exps)
static int	SetExp.canUseInc(Expression rhs, Declaration target)
static void	ChainLambdas.chainLambdas(Expression exp, Compilation comp)
ClassType	LambdaExp.checkForInitCall(Expression bodyFirst)	Check if argument is a this(...) or super(...) initializtion.
static Integer	InlineCalls.checkIntValue(Expression exp)
static 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	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)
static void	ConsumerTarget.compileUsingValues(Expression exp, Compilation comp, Target target)
final 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 initializer 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 Expression	ExpExpVisitor.defaultValue(Expression r, D d)
protected R	ExpVisitor.defaultValue(Expression r, D d)
protected Expression	PushApply.defaultValue(Expression r, Void ignored)
protected boolean	InlineCalls.deferableInit(Expression init)
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(ClassType procClass, 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)
static PrimProcedure	PrimProcedure.getMethodFor(Class procClass, String name, Declaration decl, Expression[] args, Language language)	Get PrimProcedure for matching method in given class.
Type	PrimProcedure.getReturnType(Expression[] args)
final Type	Language.getTypeFor(Expression exp)
Type	Language.getTypeFor(Expression exp, boolean lenient)	Interpreting exp as a type specifier, get the actual type.
static Expression	InlineCalls.inlineCalls(Expression exp, Compilation comp)
boolean	Compilation.inlineOk(Expression proc)
boolean	Compilation.isApplyFunction(Expression exp)
protected static boolean	ANormalize.isAtomic(Expression exp)	Determines if an Expression is atomic, that is if it needs to be normalized or not.
boolean	Compilation.isSimpleApplyFunction(Expression exp)	A simple apply function maps actual arguments to formals directly.
LetExp	Compilation.letDone(Expression body)
void	Compilation.letVariable(Declaration decl, Expression init)
Declaration	Compilation.letVariable(Object name, Type type, Expression init)
Declaration	ResolveNames.lookup(Expression exp, Object symbol, boolean function)
void	Compilation.loopBody(Expression body)	Deprecated.
void	Compilation.loopCond(Expression cond)	Deprecated.
Expression	Compilation.loopDone(Expression body)	Finish building a loop and return resulting expression.
Expression	Compilation.loopRepeat(LambdaExp loop, Expression... exps)	Recurse to next iteration of specified loop.
Expression	Compilation.loopRepeatDone(Expression... exps)	Combine loopRepeat and loopDone.
Declaration	Compilation.loopVariable(Object name, Type type, Expression init)	Add a new loop variable, with initializer.
static ApplyExp	Compilation.makeCoercion(Expression value, Type type)	Convenience method to make an Expression that coerces a value.
static ApplyExp	Compilation.makeCoercion(Expression value, Expression type)	Convenience method to make an Expression that coerces a value.
static SetExp	SetExp.makeDefinition(Declaration decl, Expression val)
static SetExp	SetExp.makeDefinition(Object symbol, Expression val)
void	Declaration.makeField(ClassType frameType, Compilation comp, Expression value)
void	Declaration.makeField(Compilation comp, Expression value)
final Expression	Expression.maybeSetLine(Expression old)
protected void	ChainLambdas.maybeWarnUnreachable(Expression exp)
protected Expression	ANormalize.normalizeName(Expression exp, gnu.expr.ANormalize.Context context)	Performs the bind operation, introducing a new let expression to capture the result of non-trivial expressions, which is bound to a new let variable.
protected Expression	ANormalize.normalizeNames(Expression[] exps, int index, gnu.expr.ANormalize.MultiContext context)	Deals with the normalization of multiple expressions.
protected Expression	ANormalize.normalizeTerm(Expression exp)	Starts the normalization of expression exp.
void	Declaration.noteValue(Expression value)
static void	PushApply.pushApply(Expression exp, Compilation comp)
void	Declaration.setAnnotation(int i, Expression ann)	Replace one of the annotations associated with this declaration.
void	ApplyExp.setArg(int i, Expression arg)
void	ApplyExp.setArgs(Expression[] args)
void	BlockExp.setBody(Expression body)
void	BlockExp.setBody(Expression body, Expression exitBody)
final void	CatchClause.setBody(Expression body)
void	LetExp.setBody(Expression body)
final void	LambdaExp.setCoercedReturnValue(Expression type, Language language)	Modify LambdaExp so result is coerced to given type.
void	LambdaExp.setExceptions(Expression[] exceptions)
final void	BeginExp.setExpressions(Expression[] exps)
ApplyExp	ApplyExp.setFuncArgs(Expression func, Expression[] args)
ApplyExp	ApplyExp.setFuncArgs(Procedure proc, Expression[] args)
void	ApplyExp.setFunction(Expression func)
void	Declaration.setInitValue(Expression init)
final void	LambdaExp.setInlineOnly(Expression returnContinuation, LambdaExp caller)	Note this function is inlined in a give context.
final void	Compilation.setLine(Expression position)
final Expression	Expression.setLine(Expression old)
void	SetExp.setNewValue(Expression newValue)
final void	Declaration.setType(Expression typeExp, Type type)
final void	Declaration.setTypeExp(Expression typeExp)
final void	Declaration.setValue(Expression value)	Set the value associated with this Declaration.
static Type	InlineCalls.typeForCalledFunction(Expression exp)	Return a required type for procedure application context.
protected Expression	ExpExpVisitor.update(Expression exp, Expression r)
protected Expression	ExpVisitor.update(Expression exp, R r)
protected Expression	PushApply.update(Expression exp, Expression r)
R	ExpVisitor.visit(Expression exp, D d)	Call the visit method of argument Expression.
static <R, D> R	ExpVisitor.visit(ExpVisitor<R,D> visitor, Expression exp, D d)
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.visitCaseExp(CaseExp exp, Expression returnContinuation)
protected Expression	FindTailCalls.visitClassExp(ClassExp exp, Expression returnContinuation)
void	FindTailCalls.visitDefaultArgs(LambdaExp exp, Expression d)
protected Expression	FindTailCalls.visitExitExp(ExitExp exp, Expression returnContinuation)
protected R	ExpVisitor.visitExpression(Expression exp, D d)
protected Expression	FindTailCalls.visitExpression(Expression exp, Expression returnContinuation)
Expression[]	ExpVisitor.visitExps(Expression[] exps, int n, D d)	Call visit on the Expressions in an array.
Expression[]	ExpVisitor.visitExps(Expression[] exps, D d)
Expression[]	FindTailCalls.visitExps(Expression[] exps)
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.visitModuleExp(ModuleExp exp, Expression returnContinuation)
protected Expression	FindTailCalls.visitSetExp(SetExp exp, Expression returnContinuation)
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

Modifier	Constructor	Description
	ApplyExp(Method m, Expression... a)
	ApplyExp(Expression f, Expression... a)
	ApplyExp(Procedure p, Expression... a)
	BeginExp(Expression[] ex)
	BeginExp(Expression exp0, Expression exp1)
	BindingInitializer(Declaration decl, Expression value)
	CaseClause(Expression exp)	Constructor for an else clause of the form (else expression+)
	CaseClause(Expression[] datums, Expression exp)	Constructor for a clause of the form ((datum*) expression+)
	CaseExp(Expression key, CaseExp.CaseClause[] clauses)	Constructor for a case expression with no else clause.
	CaseExp(Expression key, CaseExp.CaseClause[] clauses, CaseExp.CaseClause elseClause)	Constructor for a case expression with an else clause.
	CatchClause(Declaration decl, Expression body)
	CatchClause(Object name, Type type, Expression body)
	ExitExp(Expression result, BlockExp block)
	IfExp(Expression i, Expression t, Expression e)
	LambdaExp(Expression body)
	SetExp(Declaration decl, Expression val)
	SetExp(Object symbol, Expression val)
	SynchronizedExp(Expression object, Expression body)
	TryExp(Expression try_clause, Expression finally_clause)

Uses of Expression in gnu.kawa.functions

Subclasses of Expression in gnu.kawa.functions

Modifier and Type	Class	Description
class	CurryExp	A specialized ApplyExp class for curried function calls.

Methods in gnu.kawa.functions that return Expression

Modifier and Type	Method	Description
static Expression	MakeSplice.argIfSplice(Expression exp)
static Expression	GetModuleClass.getModuleClassExp()
static Expression	GetModuleClass.getModuleClassURI(Compilation comp)	Return an expression that evaluates to a module-relative URL.
static Expression	CompileNamedPart.makeExp(Type type, String member)
static Expression	CompileNamedPart.makeExp(Expression clas, Expression member)
static Expression	CompileNamedPart.makeExp(Expression clas, 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.
Expression	CurryExp.validateApply(ApplyExp exp, InlineCalls visitor, Type required, Declaration decl)
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.validateApplyMakeDynamic(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
static Expression	CompileMisc.validateApplyMakeProcedure(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
static Expression	CompileMisc.validateApplyMakePromise(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
static Expression	CompileArith.validateApplyNot(ApplyExp exp, int kind, InlineCalls visitor)
static Expression	CompileProcess.validateApplyRunProcess(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)	Type-check and optimize RunProcess (i.e.
static Expression	CompileMisc.validateApplySimpleBoolean(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	CompileMisc.validateApplyWithExceptionHandler(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
static Expression	CompileValues.validateApplyWithValues(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
static Expression	CompileValues.validateCallWithValues(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

Modifier and Type	Method	Description
static boolean	CompileArith.appropriateIntConstant(Expression[] args, int iarg, InlineCalls visitor)
static boolean	CompileArith.appropriateLongConstant(Expression[] args, int iarg, InlineCalls visitor)
static Expression	MakeSplice.argIfSplice(Expression exp)
static String	CompileNamedPart.combineName(Expression part1, Expression part2)
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	CallCC.getReturnType(Expression[] args)
Type	CompileArith.getReturnType(Expression[] args)
Type	GetModuleClass.getReturnType(Expression[] args)
Type	MakeList.getReturnType(Expression[] args)
Type	ValuesMap.getReturnType(Expression[] args)
static Expression	CompileNamedPart.makeExp(Expression clas, Expression member)
static Expression	CompileNamedPart.makeExp(Expression clas, String member)
static Expression	CompileNamedPart.makeGetNamedInstancePartExp(Expression member)
static boolean	CompilationHelpers.maybeLazy(Expression exp)
static Expression	CompileArith.pairwise(Procedure proc, Expression rproc, Expression[] args, InlineCalls visitor)	Convert (PROC A B C) to (PROC (PROC A B) C) etc.

Constructors in gnu.kawa.functions with parameters of type Expression

Modifier	Constructor	Description
	CurryExp(Procedure currier, Procedure actual, Expression... initial)

Uses of Expression in gnu.kawa.lispexpr

Methods in gnu.kawa.lispexpr that return Expression

Modifier and Type	Method	Description
Expression	LangObjType.SimpleVectorBuilder.buildAddChild(Declaration target, Expression child)
Expression	GenArrayType.convertValue(Expression value)
Expression	LangObjType.convertValue(Expression value)
Expression	LangPrimType.convertValue(Expression value)
Expression	BracketApply.rewrite(Object obj, Translator tr)
Expression	DefineNamespace.rewriteForm(Pair form, Translator tr)
Expression	MakeXmlElement.rewriteForm(Pair form, Translator tr)
Expression	ResolveNamespace.rewriteForm(Pair form, Translator tr)

Methods in gnu.kawa.lispexpr with parameters of type Expression

Modifier and Type	Method	Description
Expression	LangObjType.SimpleVectorBuilder.buildAddChild(Declaration target, Expression child)
Expression	GenArrayType.convertValue(Expression value)
Expression	LangObjType.convertValue(Expression value)
Expression	LangPrimType.convertValue(Expression value)

Uses of Expression in gnu.kawa.reflect

Methods in gnu.kawa.reflect that return Expression

Modifier and Type	Method	Description
Expression	CompileBuildObject.build()
Expression	CompileBuildObject.buildAddChild(Declaration target, Expression child)
Expression	CompileBuildObject.buildSetter(Declaration target, Member member, Expression value)
Expression	MappedArrayType.convertValue(Expression value)
Expression	OccurrenceType.convertValue(Expression value)
Expression	CompileBuildObject.getArg(int i)
static Expression	CompileReflect.makeSetterCall(Expression receiver, Object slot, Expression newValue)
static Expression	MakeAnnotation.validate(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)
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)
static Expression	CompileInvoke.validateNamedInvoke(ApplyExp exp, InlineCalls visitor, ObjectType type, String name, PrimProcedure[] methods, Invoke iproc, Type required)
static Expression	CompileReflect.validateThrow(ApplyExp exp, InlineCalls visitor, Type required, Procedure proc)

Methods in gnu.kawa.reflect with parameters of type Expression

Modifier and Type	Method	Description
Expression	CompileBuildObject.buildAddChild(Declaration target, Expression child)
Expression	CompileBuildObject.buildSetter(Declaration target, Member member, Expression value)
Expression	MappedArrayType.convertValue(Expression value)
Expression	OccurrenceType.convertValue(Expression value)
static void	CompileArrays.createArray(Type elementType, Compilation comp, Expression[] args, int start, int end)	Optimized code generation of array creation with splicing support.
Type	InstanceOf.getReturnType(Expression[] args)
Type	StaticGet.getReturnType(Expression[] args)
Type	StaticSet.getReturnType(Expression[] args)
Type	TypeSwitch.getReturnType(Expression[] args)
static PrimProcedure	CompileInvoke.getStaticMethod(ClassType type, String name, Expression[] args)
static PrimProcedure	Invoke.getStaticMethod(ClassType type, String name, Expression[] args)	Deprecated.
void	CompileBuildObject.insertArgument(int index, Expression arg)	Insert an expression into the argument list.
static ApplyExp	MakeAnnotation.makeAnnotationMaker(Expression classRef)
static ApplyExp	SlotGet.makeGetField(Expression value, String fieldName)	Convenience method to make an Expression that gets the value of a field.
static ApplyExp	Invoke.makeInvokeStatic(ClassType type, String name, Expression... args)	Return an ApplyExp that will call a method with given arguments.
static Expression	CompileReflect.makeSetterCall(Expression receiver, Object slot, Expression newValue)
void	CompileBuildObject.setArg(int i, Expression arg)

Uses of Expression in gnu.kawa.xml

Methods in gnu.kawa.xml that return Expression

Modifier and Type	Method	Description
Expression	NodeType.convertValue(Expression value)
Expression	XDataType.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

Modifier and Type	Method	Description
static void	NodeConstructor.compileChild(Expression arg, boolean stringIsText, Compilation comp, ConsumerTarget target)
static void	NodeConstructor.compileUsingNodeTree(Expression exp, Compilation comp, Target target)	Compile an expression using a fresh NodeTree.
Expression	NodeType.convertValue(Expression value)
Expression	XDataType.convertValue(Expression value)
Type	CoerceNodes.getReturnType(Expression[] args)
Type	MakeAttribute.getReturnType(Expression[] args)
Type	MakeElement.getReturnType(Expression[] args)
Type	NodeConstructor.getReturnType(Expression[] args)
Type	SortNodes.getReturnType(Expression[] args)
Type	UnionNodes.getReturnType(Expression[] args)

Uses of Expression in gnu.kawa.xslt

Methods in gnu.kawa.xslt that return Expression

Modifier and Type	Method	Description
Expression	XslTranslator.getExpression()

Uses of Expression in gnu.mapping

Methods in gnu.mapping with parameters of type Expression

Modifier and Type	Method	Description
Type	Procedure.getReturnType(Expression[] args)	Semi-deprecated - instead should be set at Inline time.

Uses of Expression in gnu.xquery.lang

Fields in gnu.xquery.lang declared as Expression

Modifier and Type	Field	Description
static Expression	XQParser.makeText

Methods in gnu.xquery.lang that return Expression

Modifier and Type	Method	Description
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(String message)
static Expression	XQParser.makeFunctionExp(String className, String name)
static Expression	XQParser.makeFunctionExp(String className, String fieldName, 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(String message)
Expression	XQParser.syntaxError(String message, String code)	Handle syntax errors (at rewrite time).
protected Expression	XQResolveNames.visitApplyExp(ApplyExp exp, Void ignored)
protected Expression	XQResolveNames.visitReferenceExp(ReferenceExp exp, ApplyExp call)
protected Expression	XQResolveNames.visitReferenceExp(ReferenceExp exp, Void ignored)
protected Expression	XQResolveNames.visitSetExp(SetExp exp, Void ignored)

Methods in gnu.xquery.lang with parameters of type Expression

Modifier and Type	Method	Description
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)
void	XQParser.maybeSetLine(Expression exp, int startLine, int startColumn, int endLine, int endColumn)

Uses of Expression in gnu.xquery.util

Methods in gnu.xquery.util that return Expression

Modifier and Type	Method	Description
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

Modifier and Type	Method	Description
static TreeScanner	RelativeStep.extractStep(Expression exp)
Type	OrderedMap.getReturnType(Expression[] args)
Type	RelativeStep.getReturnType(Expression[] args)
Type	ValuesFilter.getReturnType(Expression[] args)

Uses of Expression in kawa.lang

Subclasses of Expression in kawa.lang

Modifier and Type	Class	Description
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

Modifier and Type	Field	Description
Expression	Lambda.defaultDefault

Methods in kawa.lang that return Expression

Modifier and Type	Method	Description
Expression	Lambda.auxillaryRewrite(Object body, Translator tr)
Expression	Translator.checkDefaultBinding(Symbol symbol, Translator tr)	If a symbol is lexically unbound, look for a default binding.
protected Expression	Quote.coerceExpression(Object val, Translator tr)
Expression	BindDecls.compareLiteral(Declaration param, QuoteExp literal)
protected Expression	Quote.leaf(Object val, Translator tr)
Expression	Translator.makeBody(Expression[] exps)	Combine a 'body' consisting of a list of expression.
protected Expression	Translator.makeBody(Pair head, ScopeExp scope)	Combine a list of zero or more expression forms into a "body".
Expression	Translator.parse(Object input)
Expression	Lambda.rewrite(Object obj, Translator tr)
Expression	Quote.rewrite(Object obj, Translator tr)
Expression	Syntax.rewrite(Object obj, Translator tr)	Re-write an expression that is an "application" of this Syntax object.
static Expression	SyntaxForms.rewrite(Object x)
Expression	Translator.rewrite(Object exp)	Re-write a Scheme expression in S-expression format into internal form.
Expression	Translator.rewrite(Object exp, boolean function)	Re-write a Scheme expression in S-expression format into internal form.
Expression	Translator.rewrite(Object exp, char mode)	Re-write a Scheme expression in S-expression format into internal form.
Expression	Translator.rewrite_body(Object exp)	Re-write a Scheme 'body' in S-expression format into internal form.
final Expression	Translator.rewrite_car(Pair pair, boolean function)
final Expression	Translator.rewrite_car(Pair pair, ScopeExp templateScope)
final Expression	Translator.rewrite_car(Pair pair, SyntaxForm syntax)
final Expression	Translator.rewrite_car_for_lookup(Pair pair)	Similar to rewrite_car.
Expression	Translator.rewrite_lookup(Expression part1, Expression part2, boolean function)
Expression	Translator.rewrite_pair(Pair p, boolean function)
Expression	Translator.rewrite_with_position(Object exp, boolean function, PairWithPosition pair)
static Expression	SyntaxForms.rewriteBody(Object x)
static Expression	SyntaxForms.rewriteCar(Object x)
Expression	AutoloadSyntax.rewriteForm(Pair form, Translator tr)
Expression	Macro.rewriteForm(Pair form, Translator tr)
Expression	Syntax.rewriteForm(Pair form, Translator tr)

Methods in kawa.lang with parameters of type Expression

Modifier and Type	Method	Description
void	Translator.ScanContext.addSeqExpression(Expression scanExp)
Type	GetFieldProc.getReturnType(Expression[] args)
Type	SetFieldProc.getReturnType(Expression[] args)
Expression	Translator.makeBody(Expression[] exps)	Combine a 'body' consisting of a list of expression.
Symbol	Translator.namespaceResolve(Expression context, Expression member)
Symbol	Translator.namespaceResolve(Namespace ns, Expression member)
Namespace	Translator.namespaceResolvePrefix(Expression context)
Object[]	BindDecls.parsePatternCar(Pair patList, Expression init, TemplateScope templateScope, int scanNesting, ScopeExp scope, Translator comp)
Expression	Translator.rewrite_lookup(Expression part1, Expression part2, boolean function)
static void	BindDecls.setInitializer(Declaration decl, Expression init, ScopeExp scope, Translator comp)
static void	Translator.setLine(Expression exp, 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

Modifier and Type	Method	Description
Expression	SchemeCompilation.applyFunction(Expression func)
Expression	SchemeCompilation.checkDefaultBinding(Symbol symbol, Translator tr)	If a symbol is lexically unbound, look for a default binding.
static Expression	syntax_error.error(Object form, Object[] message)
protected Expression	syntax.leaf(Object val, Translator tr)
Expression	begin.rewrite(Object obj, Translator tr)
Expression	constant_fold.rewrite(Object obj, Translator tr)
Expression	fluid_let.rewrite(Object bindings, Object body, Translator tr)
Expression	fluid_let.rewrite(Object obj, Translator tr)
Expression	Include.rewrite(Object obj, Translator tr)
Expression	let_syntax.rewrite(Object obj, Translator tr)
Expression	let.rewrite(Object obj, Translator tr)
static Expression	location.rewrite(Expression arg, Translator tr)
Expression	location.rewrite(Object obj, Translator tr)
Expression	prim_method.rewrite(Object obj, Translator tr)
Expression	Scan.rewrite(Object obj, Translator tr)
Expression	syntax_error.rewrite(Object obj, Translator tr)
static Expression	try_catch.rewrite(Pair try_part_pair, Object clauses)
Expression	define_alias.rewriteForm(Pair form, Translator tr)
Expression	define_autoload.rewriteForm(Pair form, Translator tr)
Expression	define_class.rewriteForm(Pair form, Translator tr)
Expression	define_syntax.rewriteForm(Pair form, Translator tr)
Expression	define_unit.rewriteForm(Pair form, Translator tr)
Expression	define.rewriteForm(Pair form, Translator tr)
Expression	export.rewriteForm(Pair form, Translator tr)
Expression	IfFeature.rewriteForm(Pair form, Translator tr)
Expression	ImportFromLibrary.rewriteForm(Pair form, Translator tr)
Expression	MatchDef.rewriteForm(Pair form, Translator tr)
Expression	module_compile_options.rewriteForm(Pair form, Translator tr)
Expression	module_extends.rewriteForm(Pair form, Translator tr)
Expression	module_implements.rewriteForm(Pair form, Translator tr)
Expression	module_static.rewriteForm(Pair form, Translator tr)
Expression	object.rewriteForm(Pair form, Translator tr)
Expression	require.rewriteForm(Pair form, Translator tr)
Expression	set_b.rewriteForm(Pair form, Translator tr)
Expression	syntax_case.rewriteForm(Pair form, Translator tr)
Expression	syntax_rules.rewriteForm(Pair form, Translator tr)
Expression	syntax.rewriteForm(Pair form, Translator tr)
Expression	thisRef.rewriteForm(Pair form, Translator tr)
Expression	with_compile_options.rewriteForm(Pair form, Translator tr)

Methods in kawa.standard that return types with arguments of type Expression

Modifier and Type	Method	Description
Map<Symbol,Expression>	require.DeclSetMapper.map(Map<Symbol,Expression> decls, Compilation comp)

Methods in kawa.standard with parameters of type Expression

Modifier and Type	Method	Description
Expression	SchemeCompilation.applyFunction(Expression func)
static Type	Scheme.exp2Type(Expression exp)	Convert expression to a Type.
static Type	Scheme.getTypeValue(Expression exp)	If exp is a "constant" Type, return that type, otherwise return null.
boolean	SchemeCompilation.isApplyFunction(Expression exp)
boolean	SchemeCompilation.isSimpleApplyFunction(Expression exp)
static Expression	location.rewrite(Expression arg, Translator tr)

Method parameters in kawa.standard with type arguments of type Expression

Modifier and Type	Method	Description
Map<Symbol,Expression>	require.DeclSetMapper.map(Map<Symbol,Expression> decls, Compilation comp)

Constructors in kawa.standard with parameters of type Expression

Modifier	Constructor	Description
	fluid_let(boolean star, boolean warnIfUndefined, Expression defaultInit)