de.uni_hildesheim.sse.vil.expressions.translation

Class ExpressionTranslator<I extends VariableDeclaration,R extends Resolver<I>,E extends ExpressionStatement>

java.lang.Object

net.ssehub.easy.dslCore.translation.MessageReceiver

net.ssehub.easy.dslCore.translation.ExpressionTranslator

de.uni_hildesheim.sse.vil.expressions.translation.ExpressionTranslator<I,R,E>

All Implemented Interfaces:

IMessageReceiver, ResolutionListener, StringResolver.IExpressionTranslator<I,R>

Direct Known Subclasses:

ExpressionTranslator, ExpressionTranslator

public abstract class ExpressionTranslator<I extends VariableDeclaration,R extends Resolver<I>,E extends ExpressionStatement>
extends ExpressionTranslator
implements ResolutionListener, StringResolver.IExpressionTranslator<I,R>

Implements the translation from the expression DSL to the expression model in the instantiator core.

Author:

Holger Eichelberger

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected static class	ExpressionTranslator.CallType Defines basic VIL call types.

Field Summary

Fields

Modifier and Type	Field and Description
private java.util.Map<VarModelIdentifierExpression,org.eclipse.emf.ecore.EObject>	ivmlWarnings
private VarModelIdentifierExpression	lastVarModelIdentifierEx

Constructor Summary

Constructors

Constructor and Description
ExpressionTranslator() Creates an expression translator (to be used within this package only).

Method Summary

Modifier and Type	Method and Description
Expression	assertBooleanExpression(Expression expression, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature causingFeature) Asserts the given expression to be of Boolean type.
protected abstract java.lang.String	cannotAssignHint() A hint if an assignment is not allowed.
protected AbstractCallExpression	checkCallExpression(AbstractCallExpression callEx, ExpressionTranslator.CallType type, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call) Performs generic call expression checks after creation.
private void	checkOclEnumCompliance(java.lang.String name, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature causeFeature) Checks the given enumeration literal name for OCL compliance.
protected VilException	checkSemantics(Expression expr) Checks the semantics of a potential call candidate.
protected boolean	continueResolution(VilException semanticException) Returns whether resolution shall be continued in case of multiple similar call expressions.
private Expression	convertToVersion(java.lang.String text, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant arg, R resolver)
protected static Expression	createConstant(TypeDescriptor<?> type, java.lang.Object value, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature causingFeature, TypeRegistry registry) Creates a constant.
protected abstract E	createExpressionStatement(Expression expression, R resolver) Creates an expression statement.
protected abstract ExpressionVersionRestriction	createExpressionVersionRestriction(Expression expr, VariableDeclaration decl, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature feature) Creates an expression version restriction matching this class.
protected abstract I	createImplicitVariableDeclaration(java.lang.String name, TypeDescriptor<?> type, boolean isConstant, Expression expression, R resolver) Creates a new implicit variable declaration.
protected abstract I	createVariableDeclaration(java.lang.String name, TypeDescriptor<?> type, boolean isConstant, Expression expression, R resolver) Creates a new variable declaration.
void	enactIvmlWarnings() Enacts the IVML warnings not resolved by "function pointers" so far.
void	error(AbstractException exception, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature causeFeature) Turns a buildlang exception into a xText error.
private static java.lang.String	getName(org.eclipse.emf.ecore.EObject cause) Tries to obtain the name of cause.
private void	ivmlWarning(java.lang.String name, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature causingFeature) Creates a warning due to an unresolved IVML element.
private Expression	normalizeStringExpression(Expression ex, java.lang.String st) Normalizes a string expression, i.e., if ex (within a CompositeExpression is not a constant, a StringExpression containing the expression is inserted instead.
abstract Expression	parseExpression(java.lang.String expression, R resolver, java.lang.StringBuilder warnings) Parse the given expression.
private FieldAccessExpression	process(VariableDeclaration var, FieldAccessExpression last, java.lang.String name, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant elt)
protected Expression	processAdditiveExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.AdditiveExpression ex, R resolver) Processes an additive expression.
CallArgument[]	processArguments(de.uni_hildesheim.sse.vil.expressions.expressionDsl.ArgumentList arguments, R resolver) Processes an argument list and translates them into call arguments.
Expression	processAssignment(org.eclipse.emf.ecore.EObject cause, TypeDescriptor<?> type, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression ex, R resolver) Processes an assignment.
protected abstract Expression	processCall(Expression firstParam, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call, ExpressionTranslator.CallType type, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression arrayEx, R resolver) Processes a function call.
protected Expression	processConstant(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant arg, R resolver) Processes a constant argument.
private ContainerInitializerExpression	processContainerInitializer(de.uni_hildesheim.sse.vil.expressions.expressionDsl.ContainerInitializer initializer, R resolver) Processes a container initializer expression.
private java.util.ArrayList<I>	processDeclarators(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call, TypeDescriptor<?> implicitType, java.util.List<CallArgument> arguments, R resolver) Processes a declarator.
protected Expression	processEqualityExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.EqualityExpression ex, R resolver) Processes an equality expression.
Expression	processExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression ex, R resolver) Creates the expression tree for a given expression.
E	processExpressionStatement(de.uni_hildesheim.sse.vil.expressions.expressionDsl.ExpressionStatement expr, R resolver) Processes an expression statement.
Expression	processLogicalExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.LogicalExpression ex, R resolver) Processes a logical expression.
protected Expression	processMultiplicativeExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.MultiplicativeExpression ex, R resolver) Processes a multiplicative expression.
protected Expression	processPostfixExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.PostfixExpression ex, R resolver) Processes a postfix expression.
Expression	processPrimaryExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.PrimaryExpression ex, R resolver) Processes a primary expression.
protected Expression	processQualifiedValue(java.lang.String name, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant arg, org.eclipse.emf.ecore.EStructuralFeature feature, R resolver) Processes a qualified value and creates variable expressions.
protected Expression	processRelationalExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.RelationalExpression ex, R resolver) Processes a relational expression.
IVersionRestriction	processRestriction(java.lang.String name, de.uni_hildesheim.sse.vil.expressions.expressionDsl.VersionSpec spec, R resolver) Processes an import restriction.
protected Expression	processSubCalls(Expression firstParam, org.eclipse.emf.common.util.EList<de.uni_hildesheim.sse.vil.expressions.expressionDsl.SubCall> followups, R resolver) Processes sub calls, i.e., calls connected by ".".
TypeDescriptor<?>	processType(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Type type, R resolver) Processes the given type and tries to resolve it to a VIL type.
protected TypeDescriptor<?>[]	processTypeParameter(de.uni_hildesheim.sse.vil.expressions.expressionDsl.TypeParameters param, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Type type, R resolver) Processes the type parameter.
protected Expression	processUnaryExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.UnaryExpression ex, R resolver) Processes a unary expression.
I	processVariableDeclaration(de.uni_hildesheim.sse.vil.expressions.expressionDsl.VariableDeclaration decl, R resolver) Processes a variable declaration.
void	reProcessVariableDeclaration(I decl, R resolver) Re-processes a variable declaration in order to get rid of DeferredResolvableOperationExpression.
private Expression	resolveCallArgumentExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.NamedArgument param, int paramIndex, java.util.List<I> iterators, java.util.List<CallArgument> arguments, R resolver) Tries to resolve a call argument.
protected java.lang.String	resolveCallArguments(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call, java.util.List<I> iterators, java.util.List<CallArgument> arguments, de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression arrayEx, R resolver) Resolves call arguments.
void	resolved(VarModelIdentifierExpression ex) Is called if ex was resolved.
protected java.util.List<I>	resolveIteratorDeclarations(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call, ExpressionTranslator.CallType type, java.util.List<CallArgument> arguments, R resolver) Resolves the iterator declarations.
private TypeDescriptor<?>	resolveModelType(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Type type, java.lang.String typeName, R resolver) Resolves a model type.
private void	throwVariableCannotBeInitialized(org.eclipse.emf.ecore.EObject cause, java.lang.String name, TypeDescriptor<?> declType, TypeDescriptor<?> initType) Throws a TranslatorException that a variable cannot be initialized.
private ExpressionEvaluator	tryIteratorExpression(java.util.List<CallArgument> arguments, de.uni_hildesheim.sse.vil.expressions.expressionDsl.NamedArgument param, R resolver) Tries to compose an iterator expression (ExpressionEvaluator)
void	warning(AbstractException exception, org.eclipse.emf.ecore.EObject cause, org.eclipse.emf.ecore.EStructuralFeature causeFeature) Turns a buildlang exception into a xText warning.
void	warnVersionRestrictions(de.uni_hildesheim.sse.vil.expressions.expressionDsl.VersionSpec spec) Issues implementation warnings about version restrictions.

Methods inherited from class net.ssehub.easy.dslCore.translation.ExpressionTranslator

clearMessages, clearMessages, collect, error, error, getErrorCount, getMessage, getMessageCount, warning

Methods inherited from class net.ssehub.easy.dslCore.translation.MessageReceiver

error

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

ivmlWarnings

private java.util.Map<VarModelIdentifierExpression,org.eclipse.emf.ecore.EObject> ivmlWarnings

lastVarModelIdentifierEx

private VarModelIdentifierExpression lastVarModelIdentifierEx

Constructor Detail

ExpressionTranslator

public ExpressionTranslator()

Creates an expression translator (to be used within this package only).

Method Detail

processExpression

public Expression processExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression ex,
                                    R resolver)
                             throws TranslatorException

Creates the expression tree for a given expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression tree

Throws:

TranslatorException - in case that the translation fails for some reason

enactIvmlWarnings

public void enactIvmlWarnings()

Enacts the IVML warnings not resolved by "function pointers" so far.

ivmlWarning

private void ivmlWarning(java.lang.String name,
                         org.eclipse.emf.ecore.EObject cause,
                         org.eclipse.emf.ecore.EStructuralFeature causingFeature)

Creates a warning due to an unresolved IVML element.

Parameters:

name - the name of the element

cause - the causing ECore element

causingFeature - the causing ECore feature

processExpressionStatement

public E processExpressionStatement(de.uni_hildesheim.sse.vil.expressions.expressionDsl.ExpressionStatement expr,
                                    R resolver)
                             throws TranslatorException

Processes an expression statement.

Parameters:

expr - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the expression statement

Throws:

TranslatorException - in case that the translation fails due to semantic reasons

See Also:

cannotAssignHint()

cannotAssignHint

protected abstract java.lang.String cannotAssignHint()

A hint if an assignment is not allowed.

Returns:

the hint (must not be null)

createExpressionStatement

protected abstract E createExpressionStatement(Expression expression,
                                               R resolver)

Creates an expression statement.

Parameters:

expression - the expression

resolver - the resolver instance

Returns:

the expression statement

processLogicalExpression

public Expression processLogicalExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.LogicalExpression ex,
                                           R resolver)
                                    throws TranslatorException

Processes a logical expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processEqualityExpression

protected Expression processEqualityExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.EqualityExpression ex,
                                               R resolver)
                                        throws TranslatorException

Processes an equality expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processRelationalExpression

protected Expression processRelationalExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.RelationalExpression ex,
                                                 R resolver)
                                          throws TranslatorException

Processes a relational expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processAdditiveExpression

protected Expression processAdditiveExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.AdditiveExpression ex,
                                               R resolver)
                                        throws TranslatorException

Processes an additive expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processMultiplicativeExpression

protected Expression processMultiplicativeExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.MultiplicativeExpression ex,
                                                     R resolver)
                                              throws TranslatorException

Processes a multiplicative expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processUnaryExpression

protected Expression processUnaryExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.UnaryExpression ex,
                                            R resolver)
                                     throws TranslatorException

Processes a unary expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processPostfixExpression

protected Expression processPostfixExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.PostfixExpression ex,
                                              R resolver)
                                       throws TranslatorException

Processes a postfix expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

resolveIteratorDeclarations

protected java.util.List<I> resolveIteratorDeclarations(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call,
                                                        ExpressionTranslator.CallType type,
                                                        java.util.List<CallArgument> arguments,
                                                        R resolver)
                                                 throws TranslatorException

Resolves the iterator declarations. Existence of iterator declarations in call is already checked to be valid.

Parameters:

call - the call holding the iterator declarations

type - the type of the call (not the return type)

Returns:

the iterator declarations in terms of variable declarations (may be empty if there are none)

Throws:

TranslatorException - in case that the translation fails for some reason

processDeclarators

private java.util.ArrayList<I> processDeclarators(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call,
                                                  TypeDescriptor<?> implicitType,
                                                  java.util.List<CallArgument> arguments,
                                                  R resolver)
                                           throws TranslatorException

Processes a declarator.

Parameters:

call - the actual call

implicitType - the implicit type of the declarator to check against or to use if no explicit type is given, may be null if the underlying type declares the collection implicitly (see deleteJavaCall). In the latter case, the type must be explicitly given by the declarator.

resolver - the resolver

arguments - the call arguments (may be changed to enable implicit collection iterators)

Returns:

a list of resolved declarators (at the moment at maximum 1)

Throws:

TranslatorException - in case that the translation fails

resolveCallArguments

protected java.lang.String resolveCallArguments(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call,
                                                java.util.List<I> iterators,
                                                java.util.List<CallArgument> arguments,
                                                de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression arrayEx,
                                                R resolver)
                                         throws TranslatorException

Resolves call arguments.

Parameters:

call - the call to resolve the arguments for

iterators - the iterators (may be changed as a side effect)

arguments - the arguments created so far (may be the operator, list is modified as a side effect)

arrayEx - an array access expression (may be null, but then call is required)

resolver - a resolver instance for resolving variables etc.

Returns:

the operation name

Throws:

TranslatorException - in case that the translation fails for some reason

resolveCallArgumentExpression

private Expression resolveCallArgumentExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.NamedArgument param,
                                                 int paramIndex,
                                                 java.util.List<I> iterators,
                                                 java.util.List<CallArgument> arguments,
                                                 R resolver)
                                          throws TranslatorException

Tries to resolve a call argument. If it is the first argument of a container iteration and there is no iterator, implicitly try to create an iterator.

Parameters:

param - the parameter

paramIndex - the 0-based index of param in the call being processed

iterators - the iterators known so far (may be changed as a side effect)

arguments - the call arguments

resolver - the resolver instance

Returns:

the resolved expression

Throws:

TranslatorException - in case that resolution fails

tryIteratorExpression

private ExpressionEvaluator tryIteratorExpression(java.util.List<CallArgument> arguments,
                                                  de.uni_hildesheim.sse.vil.expressions.expressionDsl.NamedArgument param,
                                                  R resolver)
                                           throws TranslatorException

Tries to compose an iterator expression (ExpressionEvaluator)

Parameters:

arguments - the arguments to try to construct the expression from

param - the actual parameter to do the resolution for

resolver - a resolver instance for resolving variables etc.

Returns:

the iterator expression if successful

Throws:

TranslatorException - in case that the expression cannot be created

createVariableDeclaration

protected abstract I createVariableDeclaration(java.lang.String name,
                                               TypeDescriptor<?> type,
                                               boolean isConstant,
                                               Expression expression,
                                               R resolver)

Creates a new variable declaration.

Parameters:

name - the name of the variable

type - the type of the variable

isConstant - whether this variable is a constant

expression - an expression denoting the initial value (may be null)

resolver - the resolver instance

createImplicitVariableDeclaration

protected abstract I createImplicitVariableDeclaration(java.lang.String name,
                                                       TypeDescriptor<?> type,
                                                       boolean isConstant,
                                                       Expression expression,
                                                       R resolver)

Creates a new implicit variable declaration.

Parameters:

name - the name of the variable

type - the type of the variable

isConstant - whether this variable is a constant

expression - an expression denoting the initial value (may be null)

resolver - the resolver instance

processCall

protected abstract Expression processCall(Expression firstParam,
                                          de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call,
                                          ExpressionTranslator.CallType type,
                                          de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression arrayEx,
                                          R resolver)
                                   throws TranslatorException

Processes a function call.

Parameters:

firstParam - the first parameter (may be null)

call - the function all (may be null, but then arrayEx is required)

arrayEx - an array access expression (may be null, but then call is required)

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

checkCallExpression

protected AbstractCallExpression checkCallExpression(AbstractCallExpression callEx,
                                                     ExpressionTranslator.CallType type,
                                                     de.uni_hildesheim.sse.vil.expressions.expressionDsl.Call call)
                                              throws TranslatorException

Performs generic call expression checks after creation.

Parameters:

callEx - the call expression to be checked (may be null if not resolvable)

type - the call type

call - the originating ECore call element

Returns:

callEx

Throws:

TranslatorException - in case of serious problems, e.g., callEx is null

checkSemantics

protected VilException checkSemantics(Expression expr)

Checks the semantics of a potential call candidate.

Parameters:

expr - the expression to be checked

Returns:

the expr if ok or null

processSubCalls

protected Expression processSubCalls(Expression firstParam,
                                     org.eclipse.emf.common.util.EList<de.uni_hildesheim.sse.vil.expressions.expressionDsl.SubCall> followups,
                                     R resolver)
                              throws TranslatorException

Processes sub calls, i.e., calls connected by ".".

Parameters:

firstParam - the first parameter (the expression before the ".")

followups - the follow-up calls

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processPrimaryExpression

public Expression processPrimaryExpression(de.uni_hildesheim.sse.vil.expressions.expressionDsl.PrimaryExpression ex,
                                           R resolver)
                                    throws TranslatorException

Processes a primary expression.

Parameters:

ex - the expression to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

processArguments

public CallArgument[] processArguments(de.uni_hildesheim.sse.vil.expressions.expressionDsl.ArgumentList arguments,
                                       R resolver)
                                throws TranslatorException

Processes an argument list and translates them into call arguments.

Parameters:

arguments - the arguments to be translated

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

parseExpression

public abstract Expression parseExpression(java.lang.String expression,
                                           R resolver,
                                           java.lang.StringBuilder warnings)
                                    throws VilException

Parse the given expression.

Specified by:

parseExpression in interface StringResolver.IExpressionTranslator<I extends VariableDeclaration,R extends Resolver<I>>

Parameters:

expression - the expression as string

resolver - the resolver

warnings - a collector for warnings

Returns:

the resulting expression

Throws:

VilException - if problems occur while parsing / resolving

processConstant

protected Expression processConstant(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant arg,
                                     R resolver)
                              throws TranslatorException

Processes a constant argument.

Parameters:

arg - the constant to be processed

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason

normalizeStringExpression

private Expression normalizeStringExpression(Expression ex,
                                             java.lang.String st)
                                      throws VilException

Normalizes a string expression, i.e., if ex (within a CompositeExpression is not a constant, a StringExpression containing the expression is inserted instead. This allows recursive/nested variable/expression substitution without having the required string quotes being quoted within a string.

Parameters:

ex - the expression to check

Returns:

ex or a modified ex

Throws:

VilException - if creating the modified expression fails

convertToVersion

private Expression convertToVersion(java.lang.String text,
                                    de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant arg,
                                    R resolver)
                             throws TranslatorException

Throws:

TranslatorException

process

private FieldAccessExpression process(VariableDeclaration var,
                                      FieldAccessExpression last,
                                      java.lang.String name,
                                      de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant elt)
                               throws TranslatorException

Throws:

TranslatorException

processQualifiedValue

protected Expression processQualifiedValue(java.lang.String name,
                                           de.uni_hildesheim.sse.vil.expressions.expressionDsl.Constant arg,
                                           org.eclipse.emf.ecore.EStructuralFeature feature,
                                           R resolver)
                                    throws TranslatorException

Processes a qualified value and creates variable expressions.

Parameters:

name - the qualified name

arg - the constant to be processed

feature - the feature corresponding to arg

resolver - a resolver instance for resolving variables etc.

Returns:

the resulting expression node

Throws:

TranslatorException - in case that the translation fails for some reason, in particular if ITER cannot be resolved

checkOclEnumCompliance

private void checkOclEnumCompliance(java.lang.String name,
                                    org.eclipse.emf.ecore.EObject cause,
                                    org.eclipse.emf.ecore.EStructuralFeature causeFeature)

Checks the given enumeration literal name for OCL compliance.

Parameters:

name - the name

cause - the causing object

causeFeature - the causing feature

createConstant

protected static final Expression createConstant(TypeDescriptor<?> type,
                                                 java.lang.Object value,
                                                 org.eclipse.emf.ecore.EObject cause,
                                                 org.eclipse.emf.ecore.EStructuralFeature causingFeature,
                                                 TypeRegistry registry)
                                          throws TranslatorException

Creates a constant.

Parameters:

type - the type of the constant

value - the value of the constant

cause - the Ecore language model element for which the exception was caused

causingFeature - the specific language feature within cause which caused the exception

Returns:

the created constant expression

Throws:

TranslatorException - in case that type resolution fails

processType

public TypeDescriptor<?> processType(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Type type,
                                     R resolver)
                              throws TranslatorException

Processes the given type and tries to resolve it to a VIL type.

Parameters:

type - the type to be processed

resolver - the resolver instance

Returns:

the corresponding VIL type

Throws:

TranslatorException - in case that type resolution fails

resolveModelType

private TypeDescriptor<?> resolveModelType(de.uni_hildesheim.sse.vil.expressions.expressionDsl.Type type,
                                           java.lang.String typeName,
                                           R resolver)
                                    throws TranslatorException

Resolves a model type.

Parameters:

type - the type as ECore instance

typeName - the name of the type

resolver - the resolver

Returns:

the type or null if not resolved

Throws:

TranslatorException - in case of a serious resolution problem

processContainerInitializer

private ContainerInitializerExpression processContainerInitializer(de.uni_hildesheim.sse.vil.expressions.expressionDsl.ContainerInitializer initializer,
                                                                   R resolver)
                                                            throws TranslatorException

Processes a container initializer expression.

Parameters:

initializer - the container initializer expression as ECore instance

resolver - a resolver instance for resolving variables etc.

Returns:

the resolved container initializer expression

Throws:

TranslatorException - in case that type resolution fails

processTypeParameter

protected TypeDescriptor<?>[] processTypeParameter(de.uni_hildesheim.sse.vil.expressions.expressionDsl.TypeParameters param,
                                                   de.uni_hildesheim.sse.vil.expressions.expressionDsl.Type type,
                                                   R resolver)
                                            throws TranslatorException

Processes the type parameter.

Parameters:

param - the ECore instance containing the type parameter

type - the type the parameter are assigned to

resolver - the resolver instance

Returns:

the processed parameter in terms of VIL type descriptors

Throws:

TranslatorException - in case that type resolution fails

processAssignment

public Expression processAssignment(org.eclipse.emf.ecore.EObject cause,
                                    TypeDescriptor<?> type,
                                    de.uni_hildesheim.sse.vil.expressions.expressionDsl.Expression ex,
                                    R resolver)
                             throws TranslatorException

Processes an assignment.

Parameters:

decl - the variable declaration to assign to

type - the type of the variable

ex - the expression defining the right side of the assignment (may be null)

text - a text describing the left side in case of an error

resolver - the resolver instance

Returns:

the resolved initialization expression or null if ex was null

Throws:

TranslatorException - in case that type resolution / compliance fails

processVariableDeclaration

public I processVariableDeclaration(de.uni_hildesheim.sse.vil.expressions.expressionDsl.VariableDeclaration decl,
                                    R resolver)
                             throws TranslatorException

Processes a variable declaration.

Parameters:

decl - the declaration

resolver - a resolver instance for resolving variables etc.

Returns:

the created model instance

Throws:

TranslatorException - in case that the translation fails

reProcessVariableDeclaration

public void reProcessVariableDeclaration(I decl,
                                         R resolver)
                                  throws TranslatorException

Re-processes a variable declaration in order to get rid of DeferredResolvableOperationExpression.

Parameters:

decl - the declaration

resolver - the resolver

Throws:

TranslatorException - in case that re-processing fails for some reason

throwVariableCannotBeInitialized

private void throwVariableCannotBeInitialized(org.eclipse.emf.ecore.EObject cause,
                                              java.lang.String name,
                                              TypeDescriptor<?> declType,
                                              TypeDescriptor<?> initType)
                                       throws TranslatorException

Throws a TranslatorException that a variable cannot be initialized.

Parameters:

cause - the causing ECore object

name - the name of the object (inferred from cause if null if possible)

declType - the declaration VIL type

initType - the init expression VIL type

Throws:

TranslatorException - the created exception

getName

private static java.lang.String getName(org.eclipse.emf.ecore.EObject cause)

Tries to obtain the name of cause.

Parameters:

cause - the cause

Returns:

the name or "?"

continueResolution

protected boolean continueResolution(VilException semanticException)

Returns whether resolution shall be continued in case of multiple similar call expressions.

Parameters:

semanticException - the exception being thrown by the (partial) call resolution

Returns:

true if resolution shall be continued (there was an exception and it points to a resolution or a semantic problem), false else

error

public void error(AbstractException exception,
                  org.eclipse.emf.ecore.EObject cause,
                  org.eclipse.emf.ecore.EStructuralFeature causeFeature)

Turns a buildlang exception into a xText error.

Parameters:

exception - the exception to used

cause - the cause (as instance of the EMF grammar model)

causeFeature - the cause of the feature as an appropriate constant from IvmlPackage.Literals

warning

public void warning(AbstractException exception,
                    org.eclipse.emf.ecore.EObject cause,
                    org.eclipse.emf.ecore.EStructuralFeature causeFeature)

Turns a buildlang exception into a xText warning.

Parameters:

exception - the exception to used

cause - the cause (as instance of the EMF grammar model)

causeFeature - the cause of the feature as an appropriate constant from IvmlPackage.Literals

warnVersionRestrictions

public void warnVersionRestrictions(de.uni_hildesheim.sse.vil.expressions.expressionDsl.VersionSpec spec)

Issues implementation warnings about version restrictions.

Parameters:

spec - the version specification (may be null)

processRestriction

public IVersionRestriction processRestriction(java.lang.String name,
                                              de.uni_hildesheim.sse.vil.expressions.expressionDsl.VersionSpec spec,
                                              R resolver)
                                       throws TranslatorException

Processes an import restriction.

Parameters:

name - the name of the import

spec - the version specification to be processed

Returns:

the created restriction

Throws:

TranslatorException - in case of any translation problem

createExpressionVersionRestriction

protected abstract ExpressionVersionRestriction createExpressionVersionRestriction(Expression expr,
                                                                                   VariableDeclaration decl,
                                                                                   org.eclipse.emf.ecore.EObject cause,
                                                                                   org.eclipse.emf.ecore.EStructuralFeature feature)
                                                                            throws RestrictionEvaluationException

Creates an expression version restriction matching this class.

Parameters:

expr - the expression for the restriction

decl - the version variable

cause - the grammar cause for this call

feature - the causing feature

Returns:

the created instance

Throws:

RestrictionEvaluationException - in case of any type related problems

resolved

public void resolved(VarModelIdentifierExpression ex)

Description copied from interface: ResolutionListener

Is called if ex was resolved.

Specified by:

resolved in interface ResolutionListener

Parameters:

ex - the resolved expression

assertBooleanExpression

public Expression assertBooleanExpression(Expression expression,
                                          org.eclipse.emf.ecore.EObject cause,
                                          org.eclipse.emf.ecore.EStructuralFeature causingFeature)
                                   throws TranslatorException

Asserts the given expression to be of Boolean type.

Parameters:

expression - the expression to check

cause - the causing ECore AST object

causingFeature - the causing feature

Returns:

expression or a converted expression

Throws:

TranslatorException - thrown if the expression is not of type Boolean