## org.eclipse.ocl.parser
Class AbstractOCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>

    java.lang.Object
      org.eclipse.ocl.lpg.AbstractAnalyzer
          org.eclipse.ocl.parser.AbstractOCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>

Direct Known Subclasses:
  OCLAnalyzer

    public abstract class AbstractOCLAnalyzer<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>

extends AbstractAnalyzer

The `AbstractOCLAnalyzer` supports semantic analysis of a CST produced by an `AbstractOCLParser` to create the Essential OCL AST. It is necessary that syntactic parsing and semantic analysis are performed in two steps because LPG is a bottom up parser and cannot provide enough contextual information to create the AST on the first pass. Derived classes should extend the abstract support for EssentialOCL to full support for whatever language in which EssentialOCL is embedded.

Since:
  1.2

Field Summary
`protected EnvironmentFactory<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `environmentFactory`
`protected OCLFactory` `oclFactory`
`protected UMLReflection<PK,C,O,P,EL,PM,S,COA,SSA,CT>` `uml`

Constructor Summary
`AbstractOCLAnalyzer(AbstractOCLParser parser)`

Method Summary
`protected BooleanLiteralExp<C>` `booleanLiteralExpCS(BooleanLiteralExpCS booleanLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` BooleanLiteralExpCS
`protected void` `checkNotReflexive(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String rule, AssociationClassCallExp<C,P> acc)` Asserts that the specified association class is not a reflexive association.
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `classifierContextDeclCS(ClassifierContextDeclCS classifierContextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)` ClassifierContextDeclCS
`protected CollectionLiteralExp<C>` `collectionLiteralExpCS(CollectionLiteralExpCS collectionLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` CollectionLiteralExpCS
`protected CollectionLiteralPart<C>` `collectionLiteralPartCS(CollectionLiteralPartCS collectionLiteralPartCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` CollectionLiteralPartCS
`protected C` `collectionTypeCS(CollectionTypeCS collectionTypeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` CollectionTypeCS
`protected CollectionKind` `collectionTypeIdentifierCS(CollectionTypeIdentifierEnum collectionTypeIdentifier)` CollectionTypeIdentifierCS
`protected void` `contextDeclCS(ContextDeclCS contextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)` ContextDeclCS
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, ClassifierContextDeclCS classifierContextDeclCS, C classifier)`
`protected CT` `createConstraint()` Creates an `Constraint` instance.
`protected InvalidLiteralExp<C>` `createDummyInvalidLiteralExp()` Deprecated. Use the `createDummyInvalidLiteralExp(Environment, CSTNode)` method, instead
`protected InvalidLiteralExp<C>` `createDummyInvalidLiteralExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cstNode)` Creates a dummy expression of invalid-literal type to be a placeholder for a (sub)expression that could not be parsed.
`protected C` `createDummyInvalidType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cstNode, String message)` Return the type used to terminate the AST reference from cstNode that failed to be resolved due to message.
`protected Object` `createDummyPackage(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PackageDeclarationCS packageDeclarationCS)` Return the package used to terminate the AST reference from an implicit PackageDeclarationCS.
`protected ExpressionInOCL<C,PM>` `createExpressionInOCL()` Creates an `ExpressionInOcl` instance.
`protected IteratorExp<C,PM>` `createImplicitCollect(OCLExpression<C> source, FeatureCallExp<C> propertyCall, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cstNode)` Creates an implicit `collect` iterator expression for a property call on a collection-type source expression.
`protected OCLFactory` `createOCLFactory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` Creates/obtains the `OCLFactory` that I use to create OCL AST elements.
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OperationContextDeclCS operationContextCS, O operation)`
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent, List<String> packageName)`
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `createPropertyContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PropertyContextCS propertyContextCS, P property)`
`protected VariableExp<C,PM>` `createVariableExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CSTNode cst, Variable<C,PM> var)` Creates a variable expression with the variable that it references.
`protected CT` `defCS(DefCS defCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` DefCS
`protected void` `documentCS(OCLDocumentCS documentCS, List<CT> constraints)` Analyzes a top-level document CS.
`protected OCLExpression<C>` `enumLiteralExpCS(EnumLiteralExpCS enumLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` EnumLiteralExpCS
`static boolean` `equalName(String name, String elementName)` Checks whether the names are equal, accounting for possibility of underscore-escaped names.
`protected OperationCallExp<C,O>` `genOperationCallExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OperationCallExpCS operationCallExpCS, String rule, String operName, OCLExpression<C> source, C ownerType, List<OCLExpression<C>> args)` Generate an OperationCallExp node. operName is the input name of the operation, which must be matched against the datatype of the operation source.
`protected Variable<C,PM>` `genVariableDeclaration(CSTNode cstNode, String rule, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String name, C type, OCLExpression<C> initExp, boolean explicitFlag, boolean addToEnvironment, boolean isSelf)` Generate a VariableDeclaration AST node, and add it to the environment.
`AbstractOCLParser` `getAbstractParser()` Obtains the parser that I use to transform the OCL text into the Concrete Syntax Model.
`protected C` `getBagType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)`
`protected C` `getBoolean()`
`protected CollectionKind` `getCollectionKind(C possibleCollectionType)`
`protected OCLExpression<C>` `getCollectionSourceExpression(OCLExpressionCS oclExpressionCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` OCLExpressionCS
`protected C` `getCollectionType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CollectionKind kind, C elementType)` Obtains the current environment's representation of the collection type of the specified kind on the given element type.
`protected C` `getCollectionType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, CollectionKind kind, C elementType)` Deprecated. Since 1.3, use the `getCollectionType(CSTNode, Environment, CollectionKind, Object)` method, instead.
`protected C` `getCommonSuperType(CSTNode cstNode, String rule, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type1, C type2)`
`protected C` `getElementType(C possibleCollectionType)`
`protected OCLExpression<C>` `getLoopBody(OCLExpression<C> expr)`
`Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `getOCLEnvironment()`
`protected C` `getOCLType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object metaElement)`
`protected C` `getOclVoid()`
`protected C` `getOperationMessageType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, O operation)`
`protected C` `getOrderedSetType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)`
`AbstractOCLParser` `getParser()` Obtains my parser.
`protected C` `getPropertyType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, P property)` Obtains the type, in the current environment, of the specified property.
`protected C` `getSequenceType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)`
`protected C` `getSetType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C elementType)`
`protected C` `getSignalMessageType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C signal)`
`protected OCLStandardLibrary<C>` `getStandardLibrary()`
`protected C` `getTupleType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, EList<? extends TypedElement<C>> parts)`
`protected C` `getTypeType(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)`
`protected IfExp<C>` `ifExpCS(IfExpCS ifExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` IfExpCS
`protected void` `initASTMapping(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object astNode, CSTNode cstNode)` Initialize the symmetric mapping of an object (typically an astNode) to its originating cstNode, so that AST-based analysis may report error messages exploiting the CST context, or to support incremental AST/CST update.

`protected void`

`initASTMapping(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, Object fromAstNode, CSTNode cstNode, Object toAstNode)`
Initialize the asymmetric mapping of an object (typically an astNode) to its originating cstNode, and of a cstNode to its consequent object (typically an astNode) so that AST-based analysis may report error messages exploiting the CST context, or to support incremental AST/CST update.

`protected CT` `initOrDerValueCS(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, InitOrDerValueCS initOrDerValueCS)` InitOrDerValueCS
`protected IntegerLiteralExp<C>` `integerLiteralExpCS(IntegerLiteralExpCS integerLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` IntegerLiteralExpCS
`protected InvalidLiteralExp<C>` `invalidLiteralExpCS(InvalidLiteralExpCS invalidLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` InvalidLiteralExpCS
`protected CT` `invCS(InvCS invCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` InvCS
`protected CT` `invOrDefCS(InvOrDefCS invOrDefCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` InvOrDefCS
`protected boolean` `isAtPre(FeatureCallExpCS callExp)` Queries whether the specified call expression is adorned with `@pre`.
`protected boolean` `isAtPre(VariableExpCS callExp)` Queries whether the specified variable expression is adorned with `@pre`.
`protected boolean` `isErrorNode(TypedElement<C> expr)` Queries whether the specified expression is a placeholder that was created for an expression that failed to parse.
`static boolean` `isEscaped(String name)` Queries whether the specified name is escaped with an initial underscore (`'_'`) character.
`static boolean` `isIdentifierOrKeyword(int tokenKind)` Returns true if the token kind is an identifier or keyword, otherwise false.
`protected IterateExp<C,PM>` `iterateExpCS(IterateExpCS iterateExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` IterateExpCS
`protected IteratorExp<C,PM>` `iteratorExpCS(IteratorExpCS iteratorExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` IteratorExpCS
`protected OCLExpression<C>` `letExp(LetExpCS letExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` LetExpCS
`protected LetExp<C,PM>` `letExpCS(LetExpCS letExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` Deprecated. Since 1.3, use `letExp(LetExpCS, Environment)`, instead.
`protected OCLExpression<C>` `letExpCSRecursive(LetExpCS letExpCS, int index, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` Constructs the LetExp
`protected OCLExpression<C>` `literalExpCS(LiteralExpCS literalExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` LiteralExpCS
`protected C` `lookupAssociationClassReference(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name)`
`protected C` `lookupClassifier(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<String> className)`
`protected Variable<C,PM>` `lookupImplicitSourceForOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<OCLExpression<C>> args, String operationName)`
`protected O` `lookupOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name, List<? extends TypedElement<C>> args)`
`protected P` `lookupProperty(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name)`
`protected C` `lookupSignal(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, String name, List<? extends TypedElement<C>> args)`
`protected S` `lookupState(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C sourceType, List<String> statePath)`
`protected LoopExp<C,PM>` `loopExpCS(LoopExpCS loopExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` LoopExpCS
`protected void` `markAsErrorNode(TypedElement<C> expr)` Marks the specified (sub)expression as a placeholder for an expression that could not be parsed.
`protected OCLExpression<C>` `messageExpCS(MessageExpCS messageExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` MessageExpCS
`protected OCLExpression<C>` `modelPropertyCallExpCS(FeatureCallExpCS modelPropertyCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` ModelPropertyCallExpCS
`protected NullLiteralExp<C>` `nullLiteralExpCS(NullLiteralExpCS nullLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` NullLiteralExpCS
`protected OCLExpression<C>` `oclExpressionCS(OCLExpressionCS oclExpressionCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` OCLExpressionCS
`protected OCLExpression<C>` `operationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` OperationCallExpCS
`protected void` `operationContextDeclCS(OperationContextDeclCS operationContextDeclCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)` OperationContextDeclCS
`protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E>` `operationCS(OperationCS operationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` OperationCS
`protected String` `operationString(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String operName, List<? extends TypedElement<C>> args)` Constructs the string representation of an operation call.
`protected void` `packageDeclarationCS(PackageDeclarationCS packageDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)` Analyzes a package declaration in the context of the environment created for an `OCLDocumentCS`.
`protected void` `packageDeclarationCS(PackageDeclarationCS packageDeclarationCS, List<CT> constraints)` Parses a top-level package declaration that is not nested in an `OCLDocumentCS`.
`protected List<Variable<C,PM>>` `parametersCS(List<VariableCS> parameters, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` ParametersCS
`protected CT` `prePostOrBodyDeclCS(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, PrePostOrBodyDeclCS prePostOrBodyDeclCS)` PrePostOrBodyDeclCS
`protected LiteralExp<C>` `primitiveLiteralExpCS(PrimitiveLiteralExpCS primitiveLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` PrimitiveLiteralExpCS
`protected C` `primitiveTypeCS(SimpleTypeEnum simpleType, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` PrimitiveTypeCS
`protected OCLExpression<C>` `propertyCallExpCS(CallExpCS propertyCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` PropertyCallExpCS
`protected P` `propertyContextCS(PropertyContextCS propertyContextCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, List<CT> constraints)` PropertyContextCS
`protected List<OCLExpression<C>>` `qualifiersCS(List<OCLExpressionCS> arguments, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> navigation)` QualifiersCS
`protected RealLiteralExp<C>` `realLiteralExpCS(RealLiteralExpCS realLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` RealLiteralExpCS
`protected void` `resolveIteratorOperation(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` Ovverridden by subclasses to assign the AST Operation target for an iterator reference from the CST.
`protected void` `setQualifiers(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, String rule, NavigationCallExp<C,P> nc, List<OCLExpression<C>> qualifiers)` Sets the specified navigation call's qualifiers, if they are compatible with the navigated association end or association class.
`protected AssociationClassCallExp<C,P>` `simpleAssociationClassName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C owner, String simpleName)` Attempts to parse a `simpleNameCS` as an association-class call expression.
`protected OCLExpression<C>` `simpleNameCS(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source)` Parses a `simpleNameCS` token.
`protected PropertyCallExp<C,P>` `simplePropertyName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C owner, String simpleName)` Attempts to parse a `simpleNameCS` as a property call expression.
`protected TypeExp<C>` `simpleTypeName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C classifier, String simpleName)` Attempts to parse a `simpleNameCS` as a type expression.
`protected OCLExpression<C>` `simpleUndefinedName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, String simpleName)` The error case for `simpleNameCS`, which is called when the name cannot be resolved to any suitable expression.
`protected VariableExp<C,PM>` `simpleVariableName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, String simpleName)` Attempts to parse a `simpleNameCS` as a variable expression.
`protected StateExp<C,S>` `stateExpCS(OCLExpression<C> source, StateExpCS stateExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` stateExpCS
`protected StringLiteralExp<C>` `stringLiteralExpCS(StringLiteralExpCS stringLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` StringLiteralExpCS
`protected TupleLiteralExp<C,P>` `tupleLiteralExpCS(TupleLiteralExpCS tupleLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` TupleLiteralExpCS
`protected TupleLiteralPart<C,P>` `tupleLiteralPartCS(VariableCS variableDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` tupleLiteralPartCS
`protected EList<TupleLiteralPart<C,P>>` `tupleLiteralPartListCS(List<VariableCS> variableDeclarations, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` tupleLiteralPartListCS
`protected C` `tupleTypeCS(TupleTypeCS tupleTypeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` TupleTypeCS
`protected TypeExp<C>` `typeCS(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)`
`protected C` `typeCS(TypeCS typeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` TypeCS
`static String` `unescape(String name)` Obtains the unescaped name (assuming that it is escaped) for another attempt to look it up.
`protected UnlimitedNaturalLiteralExp<C>` `unlimitedNaturalLiteralExpCS(UnlimitedNaturalLiteralExpCS unlimitedNaturalLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` UnlimitedNaturalLiteralExpCS
`protected Variable<C,PM>` `variableDeclarationCS(VariableCS variableDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, boolean addToEnvironment)` VariableDeclarationCS
`protected List<Variable<C,PM>>` `variableDeclarationListCS(List<VariableCS> variableDeclarationCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, boolean addToEnvironment)` VariableDeclarationListCS
`protected OCLExpression<C>` `variableExpCS(VariableExpCS variableExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)` VariableExpCS

Methods inherited from class org.eclipse.ocl.lpg.AbstractAnalyzer

`computeInputString, dumpTokens, ERROR, ERROR, ERROR, formatClass, formatEClassName, formatName, formatPath, formatPath, formatQualifiedName, formatString, formatType, getCharOffset, getEnvironment, getFormatter, getLexer, getTraceFlag, initialize, initialize, initPropertyPositions, initStartEndPositions, initTypePositions, makeName, makeString, setCharacterOffset, setFileName, setTab, setTraceFlag, TRACE, TRACE`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### oclFactory

    protected OCLFactory oclFactory

### uml

    protected UMLReflection<PK,C,O,P,EL,PM,S,COA,SSA,CT> uml

### environmentFactory

    protected final EnvironmentFactory<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> environmentFactory

Constructor Detail

### AbstractOCLAnalyzer

    public AbstractOCLAnalyzer(AbstractOCLParser parser)

Method Detail

### createOCLFactory

    protected OCLFactory createOCLFactory(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  Creates/obtains the `OCLFactory` that I use to create OCL AST elements.

  Parameters:
    `env` - my OCL environment
  Returns:
    an appropriate factory

### getOCLEnvironment

    public Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> getOCLEnvironment()

### getAbstractParser

    public AbstractOCLParser getAbstractParser()

  Description copied from class: `AbstractAnalyzer`
  Obtains the parser that I use to transform the OCL text into the Concrete Syntax Model.

  Overrides:
    `getAbstractParser` in class `AbstractAnalyzer`
  Since:
    1.3

### getParser

    public AbstractOCLParser getParser()

  Description copied from class: `AbstractAnalyzer`
  Obtains my parser.

  Overrides:
    `getParser` in class `AbstractAnalyzer`
  Returns:
    my parser

### getBoolean

    protected C getBoolean()

### getOclVoid

    protected C getOclVoid()

### getStandardLibrary

    protected OCLStandardLibrary<C> getStandardLibrary()

### isIdentifierOrKeyword

    public static boolean isIdentifierOrKeyword(int tokenKind)

  Returns true if the token kind is an identifier or keyword, otherwise false.

  Parameters:
    `tokenKind` - the token kind to compare
  Returns:
    true if the token kind is an identifier or keyword, otherwise false

### operationString

    protected String operationString(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                     String operName,
                                     List<? extends TypedElement<C>> args)

  Constructs the string representation of an operation call.

  Parameters:
    `operName` - the operation name
    `args` - the arguments in the operation call
  Returns:
    the string representation

### setQualifiers

    protected void setQualifiers(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                 String rule,
                                 NavigationCallExp<C,P> nc,
                                 List<OCLExpression<C>> qualifiers)

  Sets the specified navigation call's qualifiers, if they are compatible with the navigated association end or association class.

  Parameters:
    `rule` - the rule name that parsed the qualifiers
    `nc` - the navigation call expression
    `qualifiers` - the qualifiers to set

### checkNotReflexive

    protected void checkNotReflexive(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                     String rule,
                                     AssociationClassCallExp<C,P> acc)

  Asserts that the specified association class is not a reflexive association.

  Parameters:
    `env` - the current environment
    `rule` - the rule that we are matching
    `acc` - the association class call expression
    `cstNode` - context of the call

### genVariableDeclaration

    protected Variable<C,PM> genVariableDeclaration(CSTNode cstNode,
                                                    String rule,
                                                    Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                    String name,
                                                    C type,
                                                    OCLExpression<C> initExp,
                                                    boolean explicitFlag,
                                                    boolean addToEnvironment,
                                                    boolean isSelf)

  Generate a VariableDeclaration AST node, and add it to the environment. Variable declarations are generated for "self", let expression variables, and iterator and iterate variables, both implicit and explicit. For implicit variables, the name is generated by the Environment.

### genOperationCallExp

    protected OperationCallExp<C,O> genOperationCallExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                        OperationCallExpCS operationCallExpCS,
                                                        String rule,
                                                        String operName,
                                                        OCLExpression<C> source,
                                                        C ownerType,
                                                        List<OCLExpression<C>> args)

  Generate an OperationCallExp node. operName is the input name of the operation, which must be matched against the datatype of the operation source.

  Parameters:
    `env` - the current environment
    `operationCallExpCS` - the operation call CST node
    `rule` - the name of the concrete syntax rule that we are processing
    `operName` - the operation name
    `source` - the operation's source expression
    `ownerType` - the type that defines the operation, in which we will look it up. This can differ from the type of the source expression in the case of an implicit collect iterator
    `args` - the operation arguments

### documentCS

    protected void documentCS(OCLDocumentCS documentCS,
                              List<CT> constraints)

  Analyzes a top-level document CS.

  Parameters:
    `documentCS` - the document
    `constraints` - the constraints list to populate
  Since:
    1.3

### packageDeclarationCS

    protected void packageDeclarationCS(PackageDeclarationCS packageDeclarationCS,
                                        Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                        List<CT> constraints)

  Analyzes a package declaration in the context of the environment created for an `OCLDocumentCS`.

  Parameters:
    `packageDeclarationCS` - the package declaration to analyze
    `env` - the OCL document environment in which to analyze it
    `constraints` - the constraints list to populate
  Since:
    1.3

### packageDeclarationCS

    protected void packageDeclarationCS(PackageDeclarationCS packageDeclarationCS,
                                        List<CT> constraints)

  Parses a top-level package declaration that is not nested in an `OCLDocumentCS`.

  Parameters:
    `packageDeclarationCS` - the package declaration
    `constraints` - the constraints list to populate

### contextDeclCS

    protected void contextDeclCS(ContextDeclCS contextDeclCS,
                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                 List<CT> constraints)

  ContextDeclCS

  Parameters:
    `contextDeclCS` - the `ContextDeclCS` `CSTNode`
    `env` - the package environment
    `constraints` - the constraints list to populate

### operationContextDeclCS

    protected void operationContextDeclCS(OperationContextDeclCS operationContextDeclCS,
                                          Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                          List<CT> constraints)

  OperationContextDeclCS

  Parameters:
    `operationContextDeclCS` - the `OperationContextDeclCS` `CSTNode`
    `env` - the package environment
    `constraints` - the constraints list to populate

### operationCS

    protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> operationCS(OperationCS operationCS,
                                                                         Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  OperationCS

  Parameters:
    `operationCS` - the `OperationCS` `CSTNode`
    `env` - the classifier context environment
  Returns:
    the operation context environment, or `null` if the operation could not be resolved

### createOperationContext

    protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> createOperationContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                                    OperationContextDeclCS operationContextCS,
                                                                                    O operation)

### parametersCS

    protected List<Variable<C,PM>> parametersCS(List<VariableCS> parameters,
                                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  ParametersCS

  Parameters:
    `parameters` - the list of parameters as `VariableDeclarationCS` objects
    `env` - the OCL expression
  Returns:
    a list of `VariableDeclaration`s

### prePostOrBodyDeclCS

    protected CT prePostOrBodyDeclCS(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                     PrePostOrBodyDeclCS prePostOrBodyDeclCS)

  PrePostOrBodyDeclCS

  Parameters:
    `prePostOrBodyDeclCS` - the `PrePostOrBodyDeclCS` `CSTNode`
    `env` - the OCL environment
    `operation` - the context `EOperation`
  Returns:
    the parsed `Constraint`

### propertyContextCS

    protected P propertyContextCS(PropertyContextCS propertyContextCS,
                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                  List<CT> constraints)

  PropertyContextCS

  Parameters:
    `propertyContextCS` - the `PropertyContextCS` `CSTNode`
    `env` - the package environment
    `constraints` - the constraints list to populate
  Returns:
    the context property, or `null` if it could not be resolved

### createPropertyContext

    protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> createPropertyContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                                   PropertyContextCS propertyContextCS,
                                                                                   P property)

### initOrDerValueCS

    protected CT initOrDerValueCS(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                  InitOrDerValueCS initOrDerValueCS)

  InitOrDerValueCS

  Parameters:
    `initOrDerValueCS` - the `InitOrDerValueCS` `CSTNode`
    `env` - the OCL environment
    `property` - the context `EStructuralFeature`
  Returns:
    the parsed `Constraint`

### classifierContextDeclCS

    protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> classifierContextDeclCS(ClassifierContextDeclCS classifierContextDeclCS,
                                                                                     Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                                     List<CT> constraints)

  ClassifierContextDeclCS

  Parameters:
    `classifierContextDeclCS` - the `ClassifierContextDeclCS` `CSTNode`
    `env` - the package environment
    `constraints` - the constraints list to populate
    `the` - classifier context environment, or `null` of the classifier could not be resolved

### createClassifierContext

    protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> createClassifierContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                                     ClassifierContextDeclCS classifierContextDeclCS,
                                                                                     C classifier)

### invOrDefCS

    protected CT invOrDefCS(InvOrDefCS invOrDefCS,
                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  InvOrDefCS

  Parameters:
    `invOrDefCS` - the `InvOrDefCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `Constraint`

### invCS

    protected CT invCS(InvCS invCS,
                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  InvCS

  Parameters:
    `invCS` - the `InvCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `Constraint`

### defCS

    protected CT defCS(DefCS defCS,
                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  DefCS

  Parameters:
    `defCS` - the `DefCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `Constraint`

### variableDeclarationCS

    protected Variable<C,PM> variableDeclarationCS(VariableCS variableDeclarationCS,
                                                   Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                   boolean addToEnvironment)

  VariableDeclarationCS

  Parameters:
    `variableDeclarationCS` - the `VariableDeclarationCS` `CSTNode`
    `env` - the OCL environment
    `addToEnvironment` - boolean whether or not to add the the parsed variable to the environment
  Returns:
    the parsed `VariableDeclaration`

### variableDeclarationListCS

    protected List<Variable<C,PM>> variableDeclarationListCS(List<VariableCS> variableDeclarationCS,
                                                             Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                             boolean addToEnvironment)

  VariableDeclarationListCS

  Parameters:
    `variableDeclarationCS` - list of `VariableDeclarationCS`s
    `env` - the OCL environment
    `addToEnvironment` - boolean whether or not to add the the parsed variable to the environment
  Returns:
    list of `VariableDeclaration`s

### typeCS

    protected C typeCS(TypeCS typeCS,
                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  TypeCS

  Parameters:
    `typeCS` - the `TypeCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    an `EClassifier` representing the type

### stateExpCS

    protected StateExp<C,S> stateExpCS(OCLExpression<C> source,
                                       StateExpCS stateExpCS,
                                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  stateExpCS

  Parameters:
    `source` - the source expression of the oclIsInState operation
    `stateExpCS` - the `StateExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    a `StateExp` representing the state

### collectionTypeCS

    protected C collectionTypeCS(CollectionTypeCS collectionTypeCS,
                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  CollectionTypeCS

  Parameters:
    `collectionTypeCS` - the `CollectionTypeCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    an `EClassifier` representing the collection type

### collectionTypeIdentifierCS

    protected CollectionKind collectionTypeIdentifierCS(CollectionTypeIdentifierEnum collectionTypeIdentifier)

  CollectionTypeIdentifierCS

  Parameters:
    `collectionTypeIdentifier` - the `CollectionTypeIdentifierEnum` representing the collection type
  Returns:
    the parsed `CollectionType`

### tupleTypeCS

    protected C tupleTypeCS(TupleTypeCS tupleTypeCS,
                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  TupleTypeCS

  Parameters:
    `tupleTypeCS` - the `TupleTypeCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `TupleTypeCS`

### oclExpressionCS

    protected OCLExpression<C> oclExpressionCS(OCLExpressionCS oclExpressionCS,
                                               Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  OCLExpressionCS

  Parameters:
    `oclExpressionCS` - the `OCLExpressionCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### variableExpCS

    protected OCLExpression<C> variableExpCS(VariableExpCS variableExpCS,
                                             Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  VariableExpCS

  Parameters:
    `variableExpCS` - the `VariableExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### isAtPre

    protected boolean isAtPre(FeatureCallExpCS callExp)

  Queries whether the specified call expression is adorned with `@pre`.

  Parameters:
    `callExp` - a call expression
  Returns:
    whether the expression is marked pre
  Since:
    1.3

### isAtPre

    protected boolean isAtPre(VariableExpCS callExp)

  Queries whether the specified variable expression is adorned with `@pre`.

  Parameters:
    `variableExp` - a variable expression
  Returns:
    whether the expression is marked pre
  Since:
    1.3

### createVariableExp

    protected VariableExp<C,PM> createVariableExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                  CSTNode cst,
                                                  Variable<C,PM> var)

  Creates a variable expression with the variable that it references.

  Parameters:
    `env` - the current parsing environment
    `cst` - the concrete syntax that produces the variable expression
    `var` - the referred variable
  Returns:
    the variable expression
  Since:
    1.3

### qualifiersCS

    protected List<OCLExpression<C>> qualifiersCS(List<OCLExpressionCS> arguments,
                                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                  OCLExpression<C> navigation)

  QualifiersCS

  Parameters:
    `arguments` - the `OCLExpressionCS` arguments list
    `env` - the OCL environment
    `navigation` -
  Returns:
    the parsed `OCLExpression`s list

### ifExpCS

    protected IfExp<C> ifExpCS(IfExpCS ifExpCS,
                               Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  IfExpCS

  Parameters:
    `ifExpCS` - the `IfExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `IfExpCS`

### letExpCS

    @Deprecated
    protected LetExp<C,PM> letExpCS(LetExpCS letExpCS,
                                               Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  Deprecated. Since 1.3, use `letExp(LetExpCS, Environment)`, instead.

  LetExpCS

  Parameters:
    `letExpCS` - the `LetExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `LetExpCS`

### letExp

    protected OCLExpression<C> letExp(LetExpCS letExpCS,
                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  LetExpCS

  Parameters:
    `letExpCS` - the `LetExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `LetExpCS`
  Since:
    1.3

### letExpCSRecursive

    protected OCLExpression<C> letExpCSRecursive(LetExpCS letExpCS,
                                                 int index,
                                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  Constructs the LetExp

  Parameters:
    `letExpCS` - the `LetExpCS` `CSTNode`
    `index` - the index of the VariableDeclarationCS to parse
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### simpleNameCS

    protected OCLExpression<C> simpleNameCS(SimpleNameCS simpleNameCS,
                                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                            OCLExpression<C> source)

  Parses a `simpleNameCS` token. This method is largely a template, delegating to helpers that may be separately overridden to resolve simple names to various kinds of expression.

  Parameters:
    `simpleNameCS` - the `simpleNameCS` `CSTNode`
    `env` - the OCL environment
    `source` - the source of the `simpleNameCS`
  Returns:
    the parsed `OCLExpression`
  See Also:
    `simpleAssociationClassName(SimpleNameCS, Environment, OCLExpression, Object, String)`, `simplePropertyName(SimpleNameCS, Environment, OCLExpression, Object, String)`, `simpleTypeName(SimpleNameCS, Environment, OCLExpression, Object, String)`, `simpleVariableName(SimpleNameCS, Environment, OCLExpression, String)`, `simpleUndefinedName(SimpleNameCS, Environment, OCLExpression, String)`

### simpleAssociationClassName

    protected AssociationClassCallExp<C,P> simpleAssociationClassName(SimpleNameCS simpleNameCS,
                                                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                      OCLExpression<C> source,
                                                                      C owner,
                                                                      String simpleName)

  Attempts to parse a `simpleNameCS` as an association-class call expression.

  Parameters:
    `simpleNameCS` - the simple name
    `env` - the current environment
    `source` - the navigation source expression, or `null` if the source is implicit
    `owner` - the owner of the association-class end to be navigated, or `null` if the source is implicit
    `simpleName` - the simple name, as a string
  Returns:
    the parsed association-class call, or `null` if the simple name does not resolve to a related association class
  Since:
    1.3
  See Also:
    `simpleNameCS(SimpleNameCS, Environment, OCLExpression)`

### simplePropertyName

    protected PropertyCallExp<C,P> simplePropertyName(SimpleNameCS simpleNameCS,
                                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                      OCLExpression<C> source,
                                                      C owner,
                                                      String simpleName)

  Attempts to parse a `simpleNameCS` as a property call expression.

  Parameters:
    `simpleNameCS` - the simple name
    `env` - the current environment
    `source` - the navigation source expression, or `null` if the source is implicit
    `owner` - the owner of the property to be navigated, or `null` if the source is implicit
    `simpleName` - the simple name, as a string
  Returns:
    the parsed property call, or `null` if the simple name does not resolve to an available property
  Since:
    1.3
  See Also:
    `simpleNameCS(SimpleNameCS, Environment, OCLExpression)`

### simpleTypeName

    protected TypeExp<C> simpleTypeName(SimpleNameCS simpleNameCS,
                                        Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                        OCLExpression<C> source,
                                        C classifier,
                                        String simpleName)

  Attempts to parse a `simpleNameCS` as a type expression. For the sake of completeness and generality, information about a navigation `source` is provided, if any. In such cases, it is usually inappropriate to attempt to resolve the simple name as a type expression. Also, the referenced `classifier` may already be determined to be a member of the OCL Standard Library.

  Parameters:
    `simpleNameCS` - the simple name
    `env` - the current environment
    `source` - the navigation source expression, if any, in which case this would not be a type expression in OCL
    `classifier` - the referenced classifier, if it is already known to be one of the OCL Standard Library types
    `simpleName` - the simple name, as a string
  Returns:
    the parsed type expression, or `null` if the simple name does not resolve to an accessible type
  Since:
    1.3
  See Also:
    `simpleNameCS(SimpleNameCS, Environment, OCLExpression)`

### simpleVariableName

    protected VariableExp<C,PM> simpleVariableName(SimpleNameCS simpleNameCS,
                                                   Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                   OCLExpression<C> source,
                                                   String simpleName)

  Attempts to parse a `simpleNameCS` as a variable expression. The navigation `source`, if any, is provided for completeness and generality. If there is a navigation source, then it is not usually appropriate to attempt to resolve the simple name as a variable.

  Parameters:
    `simpleNameCS` - the simple name
    `env` - the current environment
    `source` - the navigation source expression, if any, in which case this would not be a variable expression in OCL
    `simpleName` - the simple name, as a string
  Returns:
    the parsed variable call, or `null` if the simple name does not resolve to an accessible variable
  Since:
    1.3
  See Also:
    `simpleNameCS(SimpleNameCS, Environment, OCLExpression)`

### simpleUndefinedName

    protected OCLExpression<C> simpleUndefinedName(SimpleNameCS simpleNameCS,
                                                   Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                   OCLExpression<C> source,
                                                   String simpleName)

  The error case for `simpleNameCS`, which is called when the name cannot be resolved to any suitable expression. The result is a dummy expression.

  Parameters:
    `simpleNameCS` - the simple name
    `env` - the current environment
    `source` - the navigation source expression, or `null` if the source is implicit
    `simpleName` - the simple name, as a string
  Returns:
    the dummy expression that is a placeholder for the unresolved reference
  Since:
    1.3
  See Also:
    `simpleNameCS(SimpleNameCS, Environment, OCLExpression)`

### createImplicitCollect

    protected IteratorExp<C,PM> createImplicitCollect(OCLExpression<C> source,
                                                      FeatureCallExp<C> propertyCall,
                                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                      CSTNode cstNode)

  Creates an implicit `collect` iterator expression for a property call on a collection-type source expression.

  Parameters:
    `source` - the property call source expression
    `propertyCall` - the property call expression
    `env` - the current environment
  Returns:
    the collect expression

### primitiveTypeCS

    protected C primitiveTypeCS(SimpleTypeEnum simpleType,
                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  PrimitiveTypeCS

  Parameters:
    `simpleType` - the `SimpleTypeEnum` representing the primitive type
  Returns:
    an `EClassifie` representing the primitive type

### primitiveLiteralExpCS

    protected LiteralExp<C> primitiveLiteralExpCS(PrimitiveLiteralExpCS primitiveLiteralExpCS,
                                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  PrimitiveLiteralExpCS

  Parameters:
    `primitiveLiteralExpCS` - the `PrimitiveLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `LiteralExp`

### integerLiteralExpCS

    protected IntegerLiteralExp<C> integerLiteralExpCS(IntegerLiteralExpCS integerLiteralExpCS,
                                                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  IntegerLiteralExpCS

  Parameters:
    `integerLiteralExpCS` - the `IntegerLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `IntegerLiteralExp`

### unlimitedNaturalLiteralExpCS

    protected UnlimitedNaturalLiteralExp<C> unlimitedNaturalLiteralExpCS(UnlimitedNaturalLiteralExpCS unlimitedNaturalLiteralExpCS,
                                                                         Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  UnlimitedNaturalLiteralExpCS

  Parameters:
    `unlimitedNaturalLiteralExpCS` - the `UnlimitedNaturalLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `UnlimitedNaturalLiteralExp`

### realLiteralExpCS

    protected RealLiteralExp<C> realLiteralExpCS(RealLiteralExpCS realLiteralExpCS,
                                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  RealLiteralExpCS

  Parameters:
    `realLiteralExpCS` - the `RealLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `RealLiteralExp`

### stringLiteralExpCS

    protected StringLiteralExp<C> stringLiteralExpCS(StringLiteralExpCS stringLiteralExpCS,
                                                     Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  StringLiteralExpCS

  Parameters:
    `stringLiteralExpCS` - the `StringLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `StringLiteralExp`

### booleanLiteralExpCS

    protected BooleanLiteralExp<C> booleanLiteralExpCS(BooleanLiteralExpCS booleanLiteralExpCS,
                                                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  BooleanLiteralExpCS

  Parameters:
    `booleanLiteralExpCS` - the `BooleanLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `BooleanLiteralExp`

### nullLiteralExpCS

    protected NullLiteralExp<C> nullLiteralExpCS(NullLiteralExpCS nullLiteralExpCS,
                                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  NullLiteralExpCS

  Parameters:
    `nullLiteralExpCS` - the `NullLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `NullLiteralExp`

### invalidLiteralExpCS

    protected InvalidLiteralExp<C> invalidLiteralExpCS(InvalidLiteralExpCS invalidLiteralExpCS,
                                                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  InvalidLiteralExpCS

  Parameters:
    `invalidLiteralExpCS` - the `InvalidLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `InvalidLiteralExp`

### literalExpCS

    protected OCLExpression<C> literalExpCS(LiteralExpCS literalExpCS,
                                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  LiteralExpCS

  Parameters:
    `literalExpCS` - the `LiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `LiteralExp`

### tupleLiteralExpCS

    protected TupleLiteralExp<C,P> tupleLiteralExpCS(TupleLiteralExpCS tupleLiteralExpCS,
                                                     Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  TupleLiteralExpCS

  Parameters:
    `tupleLiteralExpCS` - the `TupleLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `TupleLiteralExp`

### tupleLiteralPartListCS

    protected EList<TupleLiteralPart<C,P>> tupleLiteralPartListCS(List<VariableCS> variableDeclarations,
                                                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  tupleLiteralPartListCS

  Parameters:
    `variableDeclarations` - list of `VariableDeclarationCS`es
    `env` - the OCL environment
  Returns:
    list of `TupleLiteralPart`s

### tupleLiteralPartCS

    protected TupleLiteralPart<C,P> tupleLiteralPartCS(VariableCS variableDeclarationCS,
                                                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  tupleLiteralPartCS

  Parameters:
    `variableDeclarationCS` - the `VariableDeclarationCS` `CSTNode`
    `env` - the OCL environment
    `addToEnvironment` - boolean whether or not to add the the parsed variable to the environment
  Returns:
    the parsed `VariableDeclaration`

### enumLiteralExpCS

    protected OCLExpression<C> enumLiteralExpCS(EnumLiteralExpCS enumLiteralExpCS,
                                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  EnumLiteralExpCS

  Parameters:
    `enumLiteralExpCS` - the `EnumLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `EnumLiteralExp`

### typeCS

    protected TypeExp<C> typeCS(CSTNode cstNode,
                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                C type)

### collectionLiteralExpCS

    protected CollectionLiteralExp<C> collectionLiteralExpCS(CollectionLiteralExpCS collectionLiteralExpCS,
                                                             Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  CollectionLiteralExpCS

  Parameters:
    `collectionLiteralExpCS` - the `CollectionLiteralExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `CollectionLiteralExp`

### collectionLiteralPartCS

    protected CollectionLiteralPart<C> collectionLiteralPartCS(CollectionLiteralPartCS collectionLiteralPartCS,
                                                               Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  CollectionLiteralPartCS

  Parameters:
    `collectionLiteralPartCS` - the `CollectionLiteralPartCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `CollectionLiteralPart`

### propertyCallExpCS

    protected OCLExpression<C> propertyCallExpCS(CallExpCS propertyCallExpCS,
                                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  PropertyCallExpCS

  Parameters:
    `propertyCallExpCS` - the `PropertyCallExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### loopExpCS

    protected LoopExp<C,PM> loopExpCS(LoopExpCS loopExpCS,
                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  LoopExpCS

  Parameters:
    `loopExpCS` - the `LoopExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `LoopExp`

### getCollectionSourceExpression

    protected OCLExpression<C> getCollectionSourceExpression(OCLExpressionCS oclExpressionCS,
                                                             Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  OCLExpressionCS

  Parameters:
    `oclExpressionCS` - the `OCLExpressionCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### iteratorExpCS

    protected IteratorExp<C,PM> iteratorExpCS(IteratorExpCS iteratorExpCS,
                                              Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  IteratorExpCS

  Parameters:
    `iteratorExpCS` - the `IteratorExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `IteratorExp`

### resolveIteratorOperation

    protected void resolveIteratorOperation(SimpleNameCS simpleNameCS,
                                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  Ovverridden by subclasses to assign the AST Operation target for an iterator reference from the CST. The default implementation does nothing.

  Parameters:
    `simpleNameCS` - the iterator name
    `env` - the current OCL environment
  Since:
    1.3

### iterateExpCS

    protected IterateExp<C,PM> iterateExpCS(IterateExpCS iterateExpCS,
                                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  IterateExpCS

  Parameters:
    `iterateExpCS` - the `IterateExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `IterateExp`

### modelPropertyCallExpCS

    protected OCLExpression<C> modelPropertyCallExpCS(FeatureCallExpCS modelPropertyCallExpCS,
                                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  ModelPropertyCallExpCS

  Parameters:
    `modelPropertyCallExpCS` - the `ModelPropertyCallExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### getLoopBody

    protected OCLExpression<C> getLoopBody(OCLExpression<C> expr)

### operationCallExpCS

    protected OCLExpression<C> operationCallExpCS(OperationCallExpCS operationCallExpCS,
                                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  OperationCallExpCS

  Parameters:
    `operationCallExpCS` - the `OperationCallExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### messageExpCS

    protected OCLExpression<C> messageExpCS(MessageExpCS messageExpCS,
                                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)

  MessageExpCS

  Parameters:
    `messageExpCS` - the `MessageExpCS` `CSTNode`
    `env` - the OCL environment
  Returns:
    the parsed `OCLExpression`

### getCommonSuperType

    protected C getCommonSuperType(CSTNode cstNode,
                                   String rule,
                                   Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                   C type1,
                                   C type2)

### getOCLType

    protected C getOCLType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                           Object metaElement)

### getSetType

    protected C getSetType(CSTNode cstNode,
                           Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                           C elementType)

### getOrderedSetType

    protected C getOrderedSetType(CSTNode cstNode,
                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                  C elementType)

### getBagType

    protected C getBagType(CSTNode cstNode,
                           Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                           C elementType)

### getSequenceType

    protected C getSequenceType(CSTNode cstNode,
                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                C elementType)

### getCollectionType

    protected C getCollectionType(CSTNode cstNode,
                                  Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                  CollectionKind kind,
                                  C elementType)

  Obtains the current environment's representation of the collection type of the specified kind on the given element type. As a side-effect, the specified CST note is linked to the result, as its AST node mapping.

  Parameters:
    `cstNode` - the concrete syntax of a collection-type reference
    `env` - the current environment
    `kind` - the collection kind to retrieve
    `elementType` - the collection type's element type
  Returns:
    the current environment's matching collection type
  Since:
    1.3

### getCollectionType

    @Deprecated
    protected C getCollectionType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                             CollectionKind kind,
                                             C elementType)

  Deprecated. Since 1.3, use the `getCollectionType(CSTNode, Environment, CollectionKind, Object)` method, instead.

  Obtains the current environment's representation of the collection type of the specified kind on the given element type.

  Parameters:
    `env` - the current environment
    `kind` - the collection kind to retrieve
    `elementType` - the collection type's element type
  Returns:
    the current environment's matching collection type

### getTupleType

    protected C getTupleType(CSTNode cstNode,
                             Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                             EList<? extends TypedElement<C>> parts)

### getTypeType

    protected C getTypeType(CSTNode cstNode,
                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                            C type)

### getOperationMessageType

    protected C getOperationMessageType(CSTNode cstNode,
                                        Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                        O operation)

### getSignalMessageType

    protected C getSignalMessageType(CSTNode cstNode,
                                     Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                     C signal)

### getPropertyType

    protected C getPropertyType(CSTNode cstNode,
                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                C owner,
                                P property)

  Obtains the type, in the current environment, of the specified property. As a side-effect, the CST node is configured with traceability to the resulting type and the referenced property.

  Parameters:
    `cstNode` - a property-call or property-context concrete syntax
    `env` - the current OCL parsing environment
    `owner` - the contextual classifier of the property reference
    `property` - the referenced property
  Returns:
    the property's type
  Since:
    1.3

### getElementType

    protected C getElementType(C possibleCollectionType)

### getCollectionKind

    protected CollectionKind getCollectionKind(C possibleCollectionType)

### createDummyInvalidLiteralExp

    @Deprecated
    protected InvalidLiteralExp<C> createDummyInvalidLiteralExp()

  Deprecated. Use the `createDummyInvalidLiteralExp(Environment, CSTNode)` method, instead

  Creates a dummy expression of invalid-literal type to be a placeholder for a (sub)expression that could not be parsed. The resulting expression is marked as an error place-holder expression.

  Returns:
    the dummy invalid-literal expression
  See Also:
    `#markAsErrorNode(OCLExpression)`

### createDummyInvalidLiteralExp

    protected InvalidLiteralExp<C> createDummyInvalidLiteralExp(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                CSTNode cstNode)

  Creates a dummy expression of invalid-literal type to be a placeholder for a (sub)expression that could not be parsed. The resulting expression is marked as an error place-holder expression.

  Parameters:
    `env` - the contextual parsing environment
    `cstNode` - the concrete-syntax node that could not be analyzed
  Returns:
    the dummy invalid-literal expression
  Since:
    1.3
  See Also:
    `#markAsErrorNode(OCLExpression)`, `createDummyInvalidLiteralExp()`

### createDummyInvalidType

    protected C createDummyInvalidType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                       CSTNode cstNode,
                                       String message)

  Return the type used to terminate the AST reference from cstNode that failed to be resolved due to message.

  Parameters:
    `env` - the current OCL parsing environment
    `cstNode` - a concrete syntax node that could not be resolved
    `message` - the reason for the failure to resolve. Subclasses may choose to log this message in some way
  Returns:
    the dummy Invalid type
  Since:
    1.3

### createDummyPackage

    protected Object createDummyPackage(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                        PackageDeclarationCS packageDeclarationCS)

  Return the package used to terminate the AST reference from an implicit PackageDeclarationCS. This default implementation simply returns `null`. Subclasses may override to create a more interesting package.

  Parameters:
    `env` - the current OCL parsing environment
    `packageDeclarationCS` - the concrete syntax of the package declaration
  Returns:
    the dumy package, or `null` if non is required
  Since:
    1.3

### isErrorNode

    protected boolean isErrorNode(TypedElement<C> expr)

  Queries whether the specified expression is a placeholder that was created for an expression that failed to parse. An example is the expression returned by `createDummyInvalidLiteralExp()`.

  The default implementation simply returns `false`; subclasses should override if necessary, in conjunction with the `markAsErrorNode(TypedElement)` method.

  Parameters:
    `expr` - a (sub)expression
  Returns:
    whether the `expr` is a placeholder for an unparseable (sub)expression
  Since:
    1.2
  See Also:
    `markAsErrorNode(TypedElement)`

### markAsErrorNode

    protected void markAsErrorNode(TypedElement<C> expr)

  Marks the specified (sub)expression as a placeholder for an expression that could not be parsed. A subsequent invocation of the `isErrorNode(TypedElement)` method should recognize an expression thus marked. Subsequent attempts to mark an expression that is already marked have no effect.

  The default implementation does nothing; subclasses should override if necessary, in conjunction with the `isErrorPlaceholder` method.

  Parameters:
    `expr` - an expression that takes the place of a (sub)expression that could not be parsed
  Since:
    1.2
  See Also:
    `isErrorNode(TypedElement)`

### createPackageContext

    protected Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> createPackageContext(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> parent,
                                                                                  List<String> packageName)
                                                                           throws LookupException

  Throws:
    `LookupException`

### lookupClassifier

    protected C lookupClassifier(CSTNode cstNode,
                                 Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                 List<String> className)

### lookupImplicitSourceForOperation

    protected Variable<C,PM> lookupImplicitSourceForOperation(CSTNode cstNode,
                                                              Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                              List<OCLExpression<C>> args,
                                                              String operationName)

### lookupOperation

    protected O lookupOperation(CSTNode cstNode,
                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                C owner,
                                String name,
                                List<? extends TypedElement<C>> args)

### lookupProperty

    protected P lookupProperty(CSTNode cstNode,
                               Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                               C owner,
                               String name)

### lookupAssociationClassReference

    protected C lookupAssociationClassReference(CSTNode cstNode,
                                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                C owner,
                                                String name)

### lookupSignal

    protected C lookupSignal(CSTNode cstNode,
                             Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                             C owner,
                             String name,
                             List<? extends TypedElement<C>> args)

### lookupState

    protected S lookupState(CSTNode cstNode,
                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                            C sourceType,
                            List<String> statePath)

### createExpressionInOCL

    protected ExpressionInOCL<C,PM> createExpressionInOCL()

  Creates an `ExpressionInOcl` instance. Subclasses may override.

  Returns:
    an new expression-in-OCL

### createConstraint

    protected CT createConstraint()

  Creates an `Constraint` instance. Subclasses may override.

  Returns:
    an new constraint

### initASTMapping

    protected void initASTMapping(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                  Object astNode,
                                  CSTNode cstNode)

  Initialize the symmetric mapping of an object (typically an astNode) to its originating cstNode, so that AST-based analysis may report error messages exploiting the CST context, or to support incremental AST/CST update. Any pre-existing mapping is preserved. Mappings involving a null object are ignored.

  Parameters:
    `env` - the current OCL parsing environment
    `astNode` - the abstract syntax node
    `cstNode` - the concrete syntax node that generated it

### initASTMapping

    protected void initASTMapping(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                  Object fromAstNode,
                                  CSTNode cstNode,
                                  Object toAstNode)

  Initialize the asymmetric mapping of an object (typically an astNode) to its originating cstNode, and of a cstNode to its consequent object (typically an astNode) so that AST-based analysis may report error messages exploiting the CST context, or to support incremental AST/CST update. Any pre-existing mapping is preserved. Each mapping involving a null object is ignored, so that for instance the toAstNode may be set null to establish only the fromAstNode to cstNode mapping.

  Parameters:
    `env` - the current OCL parsing environment
    `fromAstNode` - the source of an AST-to-CST mapping
    `cstNode` - the target of the AST-to-CST mapping and the source of a CST-to-AST mapping
    `toAstNode` - the target of the CST-to-AST mapping
  Since:
    1.3

### isEscaped

    public static boolean isEscaped(String name)

  Queries whether the specified name is escaped with an initial underscore (`'_'`) character.

  Parameters:
    `name` - a name
  Returns:
    whether it begins with the underscore escape prefix

### unescape

    public static String unescape(String name)

  Obtains the unescaped name (assuming that it is escaped) for another attempt to look it up.

  Parameters:
    `name` - an OCL-escaped name
  Returns:
    the unescaped name

### equalName

    public static boolean equalName(String name,
                                    String elementName)

  Checks whether the names are equal, accounting for possibility of underscore-escaped names.

  Parameters:
    `name` - a possibly underscore-escaped name
    `elementName` - name of an element in the model
  Returns:
    whether the element name is equivalent to this name

Copyright 2002, 2007 IBM Corporation and others. All Rights Reserved.