Uses of Class
dk.rode.thesis.interpreter.ExpressionException

Packages that use ExpressionException

dk.rode.thesis.builder	Implementations and examples of the Builder design pattern [Gamma95, p.97].
dk.rode.thesis.interpreter	Implementations and examples of the Interpreter design pattern [Gamma95, p.243].

Uses of ExpressionException in dk.rode.thesis.builder

Methods in dk.rode.thesis.builder that throw ExpressionException

TypedFlowExpression<E>	TypedFlowExpression.add(Expression<? extends E> expression)
String	TypedFlowExpression.asSymbol(Context context)
<V> Expression<V>	ExpressionBuilder.buildConstantExpression(Class<V> type, V value) Builds a new CONSTANT expression.
<V> Expression<V>	CountingExpressionBuilder.buildConstantExpression(Class<V> type, V value)
<V> Expression<V>	AbstractExpressionBuilder.buildConstantExpression(Class<V> type, V value)
void	ExpressionBuilder.buildExpression(Expression<? extends E> expression) Adds the constructed expression supplied as expression to the root expression constructed by this builder.
void	AbstractExpressionBuilder.buildExpression(Expression<? extends E> expression)
TypedExpression<E>	TypedExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
Expression<E>	StandardExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
Expression<E>	ExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions) Builds a new initialised FLOW expression.
Expression<E>	CountingExpressionBuilder.buildInitialisedFlowExpression(Expression<? extends E>... expressions)
<V> VariableExpression<V>	ExpressionBuilder.buildVariableExpression(Class<V> type, String name) Builds a new VARIABLE expression.
<V> VariableExpression<V>	CountingExpressionBuilder.buildVariableExpression(Class<V> type, String name)
<V> VariableExpression<V>	AbstractExpressionBuilder.buildVariableExpression(Class<V> type, String name)
private <E extends Comparable<? super E>> Expression<E>	Main.create(ComparableExpressionBuilder<E> builder, Class<E> type, E value) Builds: next[20], y = current, (reverse[true] ?
E	TypedFlowExpression.evaluate(Context context)
Map<String,Integer>	CountingExpressionBuilder.getExpressionCount() Returns a map containing as values the number of times a given expression type has been created, excluding the count for the root expression.
Expression<E>	ExpressionBuilder.getRootExpression() Returns the root expression constructed by this builder.
Expression<E>	AbstractExpressionBuilder.getRootExpression()
TypedFlowExpression<E>	TypedFlowExpression.initialise()
protected static <V> Expression<V>	AbstractExpressionBuilder.initialiseExpressions(Expression<V> expression) Initialises all initialisable expressions reachable from the expression supplied as expression that has not already been initialised.

Uses of ExpressionException in dk.rode.thesis.interpreter

Subclasses of ExpressionException in dk.rode.thesis.interpreter

static class

BreakExpression.BreakException A break exception is thrown when an break expression is evaluated.

Methods in dk.rode.thesis.interpreter that throw ExpressionException

FlowExpression<E>	FlowExpression.add(Expression<? extends E> expression) Adds the expression supplied as expression to this flow expression.
<E> E	Context.assign(VariableExpression<E> expression, E value) Assigns the value supplied as value to the variable expression supplied as expression.
String	TypedExpressionDecorator.asSymbol(Context context) Returns x, where x is the symbolic representation of the decorated expression, or if type information is included, Type{x}, where Type is the simple name of the type.
String	SetExpression.asSymbol(Context context) Returns set[x], where x is the symbolic representation of the expression that will determine the value, or set#123[x], where 123 is the identity hash code of the manipulated sequence.
String	SequenceExpression.asSymbol(Context context) Returns name, where name is the actual name of this expression, or name#123, where 123 is the identity hash code of the manipulated sequence.
String	ReverseExpression.asSymbol(Context context) Returns reverse[x], where x is the symbolic representation of the expression used to determine if the sequence should be reversed, or reverse#123[x], where 123 is the identity hash code of the manipulated sequence.
String	OrExpression.asSymbol(Context context) Returns (x || y) if short-circuit, or (x | y), where x is the symbolic representation of the first expression operand and y of the second.
String	NotExpression.asSymbol(Context context) Returns {@code (!
String	NextExpression.asSymbol(Context context) Returns next[x], where x is the symbolic representation of the expression that will determine the number of times to invoke next(), or next#123[x], where 123 is the identity hash code of the manipulated sequence.
String	FlowExpression.asSymbol(Context context) Returns x, y, z, .., where x, y, z, .., are the symbol representations of the contained expressions.
String	Expression.asSymbol(Context context) Returns a short symbolic representation of this expression that describes it in a concise form.
String	EqualExpression.asSymbol(Context context) Returns x == y, where x is the symbolic representation of the first expression operand and y of the the second.
String	ConditionalExpression.asSymbol(Context context) Returns {@code (c ?
String	CompareExpression.asSymbol(Context context) Returns x operator y, where x is the symbolic representation of the first expression operand, y of the the second, and operator is the operator used for the comparison.
String	BreakExpression.asSymbol(Context context) Returns either exit or break[x], where x is the symbol representation of the target expression used, if any.
String	AssignmentExpression.asSymbol(Context context) Returns x = y, where x is the symbolic representation of the first expression operand and y of the the second.
String	AndExpression.asSymbol(Context context) Returns (x && y) if short-circuit, or (x & y), where x is the symbolic representation of the first expression operand and y of the second.
static StringBuilder	Expression.SymbolIdiom.asSymbol(Context context, Expression<?> parent, Expression<?> child) See Expression.asSymbol(Context).
static StringBuilder	Expression.SymbolIdiom.asSymbol(Context context, Expression<?> parent, Expression<?> child, StringBuilder sb) See Expression.asSymbol(Context).
protected String	BinaryExpression.asSymbol(Context context, String separator) Returns x separator y, where x is the symbolic representation of the first expression operand and y of the the second.
protected StringBuilder	BinaryExpression.asSymbol(Context context, String separator, StringBuilder sb) Returns x separator y, where x is the symbolic representation of the first expression operand and y of the the second.
private <E extends Comparable<? super E>> Expression<E>	Main.create1(Sequence<E> sequence, Class<E> type, E value, Context context) Creates: next[20], y = current, (reverse[true] ?
private <E extends Number & Comparable<? super E>> Expression<E>	Main.create2(Sequence<E> sequence, Class<E> type, E value, Context context) Creates: next[value], foo = Integer{next[(boo ?
private <E extends Comparable<? super E>> Expression<E>	Main.create3(Sequence<E> sequence, Class<E> type, E value, Context context) Creates a loop-structure by using cyclic expression references without intermediate variables: (current < value ?
private <E extends Number & Comparable<? super E>> Expression<E>	Main.create4(Sequence<E> sequence, Class<E> type, E value1, E value2, Context context) Generates the mother of all sequence expressions: (current < value1 ?
private Expression<Comparable<?>>	Main.create5(Context context, Sequence<String> string, Sequence<Integer> integer, String stringValue, Integer integerValue) Creates an expression with a loop having 15 iterations as well as different sequences and types: ((!
E	VariableExpression.evaluate(Context context)
E	TypedExpressionDecorator.evaluate(Context context)
E	SetExpression.evaluate(Context context)
Boolean	ReverseExpression.evaluate(Context context)
E	ResetExpression.evaluate(Context context)
Boolean	OrExpression.evaluate(Context context)
Boolean	NotExpression.evaluate(Context context)
E	NextExpression.evaluate(Context context)
E	FlowExpression.evaluate(Context context)
E	Expression.evaluate(Context context) Evaluates this expression and returns the result.
Boolean	EqualExpression.evaluate(Context context)
E	CurrentExpression.evaluate(Context context)
E	ConditionalExpression.evaluate(Context context)
Boolean	CompareExpression.evaluate(Context context)
E	BreakExpression.evaluate(Context context)
E	AssignmentExpression.evaluate(Context context)
Boolean	AndExpression.evaluate(Context context)
<E> VariableExpression<E>	Context.getVariable(Class<E> type, String name) Returns the variable or constant stored in this context associated with the type and name supplied as type and name, respectively.
TypedExpressionDecorator<E>	TypedExpressionDecorator.initialise()
InitialisableExpression<E>	InitialisableExpression.initialise() Initialises this expression before evaluation.
FlowExpression<E>	FlowExpression.initialise()
<E extends T> T	Interpreter.interpret(Context context, Expression<E> expression) Interpret the expression syntax tree having the root supplied as expression, and returns the result.
<E extends T> E	Interpreter.interpret(Context context, Expression<E> expression, Class<? super E> type) Interpret the expression syntax tree having the root supplied as expression, and returns the result.
Object	Context.lookup(String name) Returns the value currently associated with the variable expression identified by the variable name supplied as name.
<E> E	Context.lookup(VariableExpression<E> expression) Returns the value currently associated with the variable expression supplied as expression.
Class<?>	Context.lookupType(String name) Returns the type of the value associated with the variable expression identified by the variable name supplied as name, or throws an ExpressionException in case no such value exist.
void	Context.register(VariableExpression<?> expression) Registers the variable expression supplied as expression in this context with no associated value.