Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

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

java.lang.Object
  extended by org.eclipse.ocl.lpg.AbstractAnalyzer
      extended by 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
           
static java.lang.String IMPLICIT_SET_CONVERSION
          When a detail with this key is in an annotation with URI Environment.OCL_NAMESPACE_URI on a CollectionLiteralExp, this means that the collection literal was created by the analyzer implicitly for a -> set conversion.
static java.lang.String OCL_ANNOTATIONS_URI
           
protected  OCLFactory oclFactory
           
protected  UMLReflection<PK,C,O,P,EL,PM,S,COA,SSA,CT> uml
           
 
Constructor Summary
AbstractOCLAnalyzer(AbstractOCLParser parser)
           
 
Method Summary
protected  java.util.List<OCLExpression<C>> argumentsCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
           
protected  OCLExpression<C> arrowOperationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
          OperationCallExpCS for an ->
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, java.lang.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, java.util.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, java.util.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, java.lang.String message)
          Return the type used to terminate the AST reference from cstNode that failed to be resolved due to message.
protected  java.lang.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  OCLExpression<C> createImplicitSource(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.util.List<OCLExpression<C>> args)
           
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, java.util.List<java.lang.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)
           
static org.eclipse.emf.common.util.EList<java.lang.String> createSequenceOfNames(PathNameCS pathNameCS, SimpleNameCS simpleNameCS)
           
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, java.util.List<CT> constraints)
          Analyzes a top-level document CS.
static boolean equalName(java.lang.String name, java.lang.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, java.lang.String rule, java.lang.String operName, OCLExpression<C> source, C ownerType, java.util.List<OCLExpression<C>> args)
          Generate an OperationCallExp node.
protected  Variable<C,PM> genVariableDeclaration(CSTNode cstNode, java.lang.String rule, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.lang.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, java.lang.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, java.lang.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, org.eclipse.emf.common.util.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, java.lang.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, java.lang.Object fromAstNode, CSTNode cstNode, java.lang.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 variableExp)
          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(java.lang.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, java.lang.String name)
           
protected  C lookupClassifier(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.util.List<java.lang.String> className)
           
protected  Variable<C,PM> lookupImplicitSourceForOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.util.List<OCLExpression<C>> args, java.lang.String operationName)
           
protected  O lookupOperation(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, java.lang.String name, java.util.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, java.lang.String name)
           
protected  C lookupSignal(CSTNode cstNode, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C owner, java.lang.String name, java.util.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, java.util.List<java.lang.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> oclIsInStateOperationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
          OperationCallExpCS for oclIsInState
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, java.util.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  java.lang.String operationString(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, java.lang.String operName, java.util.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, java.util.List<CT> constraints)
          Analyzes a package declaration in the context of the environment created for an OCLDocumentCS.
protected  void packageDeclarationCS(PackageDeclarationCS packageDeclarationCS, java.util.List<CT> constraints)
          Parses a top-level package declaration that is not nested in an OCLDocumentCS.
protected  java.util.List<Variable<C,PM>> parametersCS(java.util.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, java.util.List<CT> constraints)
          PropertyContextCS
protected  java.util.List<OCLExpression<C>> qualifiersCS(java.util.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, java.lang.String rule, NavigationCallExp<C,P> nc, java.util.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, java.lang.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  NavigationCallExp<C,P> simpleNavigationName(SimpleNameCS simpleNameCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, OCLExpression<C> source, C owner, java.lang.String simpleName)
          Allows subclasses to return calls that are not necessarily a PropertyCallExp but some other NavigationCallExp.
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, java.lang.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, java.lang.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, java.lang.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, java.lang.String simpleName)
          Attempts to parse a simpleNameCS as a variable expression.
protected  StateExp<C,S> stateExpCS(OCLExpression<C> source, CSTNode stateExpCS, org.eclipse.emf.common.util.EList<java.lang.String> statePath, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
          stateExpCS
protected  OCLExpression<C> staticOperationCallExpCS(OperationCallExpCS operationCallExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
           
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  org.eclipse.emf.common.util.EList<TupleLiteralPart<C,P>> tupleLiteralPartListCS(java.util.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 enumLiteralExpCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env, C type)
          EnumLiteralExpCS
protected  C typeCS(TypeCS typeCS, Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
          TypeCS
static java.lang.String unescape(java.lang.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  java.util.List<Variable<C,PM>> variableDeclarationListCS(java.util.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, reset, reset, 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

OCL_ANNOTATIONS_URI

public static final java.lang.String OCL_ANNOTATIONS_URI
Since:
3.1
See Also:
Constant Field Values

IMPLICIT_SET_CONVERSION

public static final java.lang.String IMPLICIT_SET_CONVERSION
When a detail with this key is in an annotation with URI Environment.OCL_NAMESPACE_URI on a CollectionLiteralExp, this means that the collection literal was created by the analyzer implicitly for a -> set conversion. In this case, if the single item evaluates to null it must not be added to the resulting collection by an evaluator.

Since:
3.1
See Also:
Constant Field Values

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 java.lang.String operationString(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                           java.lang.String operName,
                                           java.util.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,
                             java.lang.String rule,
                             NavigationCallExp<C,P> nc,
                             java.util.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,
                                 java.lang.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

genVariableDeclaration

protected Variable<C,PM> genVariableDeclaration(CSTNode cstNode,
                                                java.lang.String rule,
                                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                java.lang.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,
                                                    java.lang.String rule,
                                                    java.lang.String operName,
                                                    OCLExpression<C> source,
                                                    C ownerType,
                                                    java.util.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,
                          java.util.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,
                                    java.util.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,
                                    java.util.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,
                             java.util.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,
                                      java.util.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 java.util.List<Variable<C,PM>> parametersCS(java.util.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 VariableDeclarations

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
Returns:
the parsed Constraint

propertyContextCS

protected P propertyContextCS(PropertyContextCS propertyContextCS,
                              Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                              java.util.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
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,
                                                                                 java.util.List<CT> constraints)
ClassifierContextDeclCS

Parameters:
classifierContextDeclCS - the ClassifierContextDeclCS CSTNode
env - the package environment
constraints - the constraints list to populate

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 java.util.List<Variable<C,PM>> variableDeclarationListCS(java.util.List<VariableCS> variableDeclarationCS,
                                                                   Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                                   boolean addToEnvironment)
VariableDeclarationListCS

Parameters:
variableDeclarationCS - list of VariableDeclarationCSs
env - the OCL environment
addToEnvironment - boolean whether or not to add the the parsed variable to the environment
Returns:
list of VariableDeclarations

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,
                                   CSTNode stateExpCS,
                                   org.eclipse.emf.common.util.EList<java.lang.String> statePath,
                                   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
Since:
3.0

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 variableExp)
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 java.util.List<OCLExpression<C>> qualifiersCS(java.util.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 OCLExpressions 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,
                                                                  java.lang.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)

simpleNavigationName

protected NavigationCallExp<C,P> simpleNavigationName(SimpleNameCS simpleNameCS,
                                                      Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                      OCLExpression<C> source,
                                                      C owner,
                                                      java.lang.String simpleName)
Allows subclasses to return calls that are not necessarily a PropertyCallExp but some other NavigationCallExp.

Since:
3.1

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,
                                                  java.lang.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,
                                    java.lang.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,
                                               java.lang.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,
                                               java.lang.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 org.eclipse.emf.common.util.EList<TupleLiteralPart<C,P>> tupleLiteralPartListCS(java.util.List<VariableCS> variableDeclarations,
                                                                                          Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
tupleLiteralPartListCS

Parameters:
variableDeclarations - list of VariableDeclarationCSes
env - the OCL environment
Returns:
list of TupleLiteralParts

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
Returns:
the parsed VariableDeclaration

typeCS

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

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

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

createImplicitSource

protected OCLExpression<C> createImplicitSource(OperationCallExpCS operationCallExpCS,
                                                Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                                java.util.List<OCLExpression<C>> args)
Since:
3.0

arrowOperationCallExpCS

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

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

oclIsInStateOperationCallExpCS

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

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

staticOperationCallExpCS

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

argumentsCS

protected java.util.List<OCLExpression<C>> argumentsCS(OperationCallExpCS operationCallExpCS,
                                                       Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env)
Since:
3.0

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,
                               java.lang.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,
                       java.lang.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,
                         org.eclipse.emf.common.util.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(TypedElement)

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(TypedElement), createDummyInvalidLiteralExp()

createDummyInvalidType

protected C createDummyInvalidType(Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                                   CSTNode cstNode,
                                   java.lang.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 java.lang.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,
                                                                              java.util.List<java.lang.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,
                             java.util.List<java.lang.String> className)

lookupImplicitSourceForOperation

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

lookupOperation

protected O lookupOperation(CSTNode cstNode,
                            Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                            C owner,
                            java.lang.String name,
                            java.util.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,
                           java.lang.String name)

lookupAssociationClassReference

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

lookupSignal

protected C lookupSignal(CSTNode cstNode,
                         Environment<PK,C,O,P,EL,PM,S,COA,SSA,CT,CLS,E> env,
                         C owner,
                         java.lang.String name,
                         java.util.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,
                        java.util.List<java.lang.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,
                              java.lang.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,
                              java.lang.Object fromAstNode,
                              CSTNode cstNode,
                              java.lang.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

createSequenceOfNames

public static org.eclipse.emf.common.util.EList<java.lang.String> createSequenceOfNames(PathNameCS pathNameCS,
                                                                                        SimpleNameCS simpleNameCS)
Since:
3.0

isEscaped

public static boolean isEscaped(java.lang.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 java.lang.String unescape(java.lang.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(java.lang.String name,
                                java.lang.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
Overview  Package   Class  Use  Tree  Deprecated  Index  Help 
 PREV CLASS   NEXT CLASS FRAMES    NO FRAMES    
SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD