Attachment #146308 for bug #242153

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.





%options escape=$
%options la=2
%options table=java
%options fp=QVTrParser,prefix=TK_
%options error-maps
%options scopes
%options margin=4
%options backtrack
%options noserialize
%options package=org.eclipse.qvt.declarative.parser.qvtrelation
%options import_terminals=QVTrLexer.gi
%options ast_type=CSTNode
%options ParseTable=lpg.runtime.ParseTable
%options template=../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg/dtParserTemplateF.gi
%options ParseTable=lpg.lpgjavaruntime.ParseTable
%options include_directory=".;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/parser;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/parser/backtracking"

%KeyWords
	checkonly
	default_values
	domain

	inv
	post
	pre
%End

%Terminals
	PLUS_PLUS     ::= '++'
%End

%Globals
/.
import org.eclipse.qvt.declarative.parser.qvt.cst.*;
import org.eclipse.qvt.declarative.parser.qvtrelation.cst.*;
import org.eclipse.qvt.declarative.parser.environment.ICSTFileEnvironment;
import org.eclipse.ocl.cst.CollectionTypeCS;
import org.eclipse.ocl.parser.$super_parser_class;
import org.eclipse.ocl.parser.backtracking.OCLParserErrors;

./
%End

%Start
	topLevelCS
%End

%Import
	EssentialOCL.gi
%End

%Import
	EssentialOCLErrors.gi
%End

%Define
	$prs_parser_class /.BacktrackingParser./
	$prs_parser_exception /.NotBacktrackParseTableException./
	$prs_parser_throw /.throw new RuntimeException("****Error: Regenerate $prs_type.java with -BACKTRACK option")./
	$prs_parse_args /.error_repair_count./
   $environment_class /.ICSTFileEnvironment./
	$lex_stream_class /.QVTrLexer./
   $LPGParsersym_class /.QVTrParserSymbols./
	$copyright_contributions /.*   E.D.Willink - Extended API and implementation for QVTr
*./
%End

%Headers
	/.			
		protected IdentifierCS createIdentifierCS(int token) {
			IdentifierCS result = QVTCSTFactory.eINSTANCE.createIdentifierCS();

			return result;
		}
	./
%End

%Rules
--<topLevel> ::= ('import' <unit> ';' )* <transformation>*
	topLevelCS_0_ ::= %empty
		/.$BeginCode
					TopLevelCS result = QVTrCSTFactory.eINSTANCE.createTopLevelCS();
					setOffsets(result, getIToken($getToken(1)));
					$setResult(result);
		  $EndCode
		./
	topLevelCS_0_ ::= topLevelCS_0_ import unitCS ';'
		/.$BeginCode
					TopLevelCS result = (TopLevelCS)$getSym(1);
					result.getImportClause().add((UnitCS)$getSym(3));
					setOffsets(result, result, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./
	topLevelCS_0_ ::= topLevelCS_0_ ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_TOPLEVEL);
		  $EndCode
		./	
	topLevelCS_1_ ::= topLevelCS transformationCS
		/.$BeginCode
					TransformationCS transformationCS = (TransformationCS)$getSym(2);
					TopLevelCS result = (TopLevelCS)$getSym(1);
					result.getTransformation().add(transformationCS);
					setOffsets(result, result, transformationCS);
					$setResult(result);
		  $EndCode
		./
	topLevelCS_1_ ::= topLevelCS_1_ ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_TRANSFORMATION);
		  $EndCode
		./	
	topLevelCS -> topLevelCS_0_
	topLevelCS -> topLevelCS_1_
		
--<unit> ::= <identifier> ('.' <identifier>)*
	unitCS ::= identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
					UnitCS result = QVTrCSTFactory.eINSTANCE.createUnitCS();
					result.getIdentifier().add(identifierCS);
					setOffsets(result, identifierCS);
					$setResult(result);
		  $EndCode
		./
	unitCS ::= unitCS '.' identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(3);
					UnitCS result = (UnitCS)$getSym(1);
					result.getIdentifier().add(identifierCS);
					setOffsets(result, result, identifierCS);
					$setResult(result);
		  $EndCode
		./
	
--<transformation> ::= 'transformation' <identifier> 

--                     ['extends' <identifier> (',' <identifier>)* ]
--                     '{' <keyDecl>* ( <relation> | <query> )* '}'
	transformationCS_0_ ::= transformation identifierCS '(' modelDeclCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(2);
					ModelDeclCS modelDeclCS = (ModelDeclCS)$getSym(4);
					TransformationCS result = QVTrCSTFactory.eINSTANCE.createTransformationCS();

					result.getModelDecl().add(modelDeclCS);
					setOffsets(result, getIToken($getToken(1)), modelDeclCS);
					$setResult(result);
		  $EndCode
		./
	transformationCS_0_ ::= transformationCS_0_ ',' modelDeclCS
		/.$BeginCode
					ModelDeclCS modelDeclCS = (ModelDeclCS)$getSym(3);
					TransformationCS result = (TransformationCS)$getSym(1);
					result.getModelDecl().add(modelDeclCS);
					setOffsets(result, result, modelDeclCS);
					$setResult(result);
		  $EndCode
		./
	transformationCS_0_ ::= transformationCS_0_ ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_MODELDECL);
		  $EndCode
		./	
	transformationCS_1_ ::= transformationCS_0_ ')'
		/.$BeginCode
					TransformationCS result = (TransformationCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	transformationCS_2_ -> transformationCS_1_
	transformationCS_2_ ::= transformationCS_1_ extends identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(3);
					TransformationCS result = (TransformationCS)$getSym(1);
					result.setExtends(identifierCS);
					setOffsets(result, result, identifierCS);
					$setResult(result);
		  $EndCode
		./
	transformationCS_3_ -> transformationCS_2_ '{'
	transformationCS_3_ ::= transformationCS_3_ keyDeclCS
		/.$BeginCode
					KeyDeclCS keyDeclCS = (KeyDeclCS)$getSym(2);
					TransformationCS result = (TransformationCS)$getSym(1);
					result.getKeyDecl().add(keyDeclCS);
					setOffsets(result, result, keyDeclCS);
					$setResult(result);
		  $EndCode
		./
	transformationCS_4_ -> transformationCS_3_
	transformationCS_4_ ::= transformationCS_4_ queryCS
		/.$BeginCode
					QueryCS queryCS =(QueryCS)$getSym(2);
					TransformationCS result = (TransformationCS)$getSym(1);
					result.getQuery().add(queryCS);
					setOffsets(result, result, queryCS);
					$setResult(result);
		  $EndCode
		./
	transformationCS_4_ ::= transformationCS_4_ relationCS
		/.$BeginCode
					RelationCS relationCS = (RelationCS)$getSym(2);
					TransformationCS result = (TransformationCS)$getSym(1);
					result.getRelation().add(relationCS);
					setOffsets(result, result, relationCS);
					$setResult(result);
		  $EndCode
		./
	transformationCS_4_ ::= transformationCS_4_ ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_TRANSFORMATION_ELEMENT);
		  $EndCode
		./	
	transformationCS ::= transformationCS_4_ '}'
		/.$BeginCode
					TransformationCS result = (TransformationCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
	
--<modelDecl> ::= <modelId> ':' <metaModelId>
--**<modelDecl> ::= <modelId> ':' '{' <metaModelId> (',' <metaModelId>)* '}'
	modelDeclCS_0_ ::= modelIdCS ':'
		/.$BeginCode
					IdentifierCS modelIdCS = (IdentifierCS)$getSym(1);
					ModelDeclCS result = QVTrCSTFactory.eINSTANCE.createModelDeclCS();
					result.setModelId(modelIdCS);
					setOffsets(result, modelIdCS, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
	modelDeclCS_1_ -> modelDeclCS_0_ '{'
	modelDeclCS_1_ -> modelDeclCS_2_ ','
	modelDeclCS_2_ ::= modelDeclCS_1_ metaModelIdCS
		/.$NewCase ./
	modelDeclCS ::= modelDeclCS_0_ metaModelIdCS
		/.$BeginCode
					IdentifierCS metaModelIdCS = (IdentifierCS)$getSym(2);
					ModelDeclCS result = (ModelDeclCS)$getSym(1);
					result.getMetaModelId().add(metaModelIdCS);
					setOffsets(result, result, metaModelIdCS);
					$setResult(result);
		  $EndCode
		./
	modelDeclCS_2_ ::= modelDeclCS_1_ ERROR_TOKEN
		/.$NewCase ./
	modelDeclCS ::= modelDeclCS_0_ ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_MODELDECL_ELEMENT);
		  $EndCode
		./	
	modelDeclCS ::= modelDeclCS_2_ '}'
		/.$BeginCode
					ModelDeclCS result = (ModelDeclCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
	
--<modelId> ::= <identifier>


--<keyDecl> ::= 'key' <classId> '{' <propertyId> (, <propertyId>)* '}' ';'
	keyDeclCS_0_ ::= key classIdCS '{'
		/.$BeginCode
					PathNameCS classIdCS = (PathNameCS)$getSym(2);
					KeyDeclCS result = QVTrCSTFactory.eINSTANCE.createKeyDeclCS();
					result.setClassId(classIdCS);
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	keyDeclCS_0_ -> keyDeclCS_1_ ','
	keyDeclCS_1_ ::= keyDeclCS_0_ propertyIdCS
		/.$BeginCode
					IdentifiedCS propertyIdCS = (IdentifiedCS)$getSym(2);
					KeyDeclCS result = (KeyDeclCS)$getSym(1);
					result.getPropertyId().add(propertyIdCS);
					setOffsets(result, result, propertyIdCS);
					$setResult(result);
		  $EndCode
		./
	keyDeclCS_1_ ::= keyDeclCS_0_ ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_KEYDECL_ELEMENT);
		  $EndCode
		./	
	keyDeclCS ::= keyDeclCS_1_ '}' ';'
		/.$BeginCode
					KeyDeclCS result = (KeyDeclCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	
--<classId> ::= <PathNameCS>


--<propertyId> ::= <identifier>
	propertyIdCS ::= identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
					IdentifiedCS result = QVTCSTFactory.eINSTANCE.createIdentifiedCS();
					result.setIdentifier(identifierCS);
					setOffsets(result, identifierCS);
					$setResult(result);
		  $EndCode
		./

--<relation> ::= ['top'] 'relation' <identifier>

--<when> ::= 'when' '{' (<OclExpressionCS> ';')* '}'
--<where> ::= 'where' '{' (<OclExpressionCS> ';')* '}'
			relationCS_0_ ::= relation identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(2);
					RelationCS result = QVTrCSTFactory.eINSTANCE.createRelationCS();
					result.setIdentifier(identifierCS);
					setOffsets(result, getIToken($getToken(1)), identifierCS);
					$setResult(result);
		  $EndCode
		./
	relationCS_1_ -> relationCS_0_
	relationCS_1_ ::= top relationCS_0_
		/.$BeginCode
					RelationCS result = (RelationCS)$getSym(2);
					result.setTop(true);
					setOffsets(result, getIToken($getToken(1)), result);
					$setResult(result);
		  $EndCode
		./
	relationCS_2_ -> relationCS_1_
	relationCS_2_ ::= relationCS_1_ overrides identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(3);
					RelationCS result = (RelationCS)$getSym(1);
					result.setOverrides(identifierCS);
					setOffsets(result, result, identifierCS);
					$setResult(result);
		  $EndCode
		./
	relationCS_3_ -> relationCS_2_ '{'
	relationCS_3_ ::= relationCS_3_ varDeclarationCS
		/.$BeginCode
					VarDeclarationCS varDeclarationCS = (VarDeclarationCS)$getSym(2);
					RelationCS result = (RelationCS)$getSym(1);
					result.getVarDeclaration().add(varDeclarationCS);
					setOffsets(result, result, varDeclarationCS);
					$setResult(result);
		  $EndCode
		./
	relationCS_preDomain -> relationCS_3_
	relationCS_preDomain -> relationCS_postDomain
	relationCS_postDomain ::= relationCS_preDomain domainCS
		/.$NewCase ./
	relationCS_postDomain ::= relationCS_preDomain primitiveTypeDomainCS
		/.$BeginCode
					AbstractDomainCS domainCS = (AbstractDomainCS)$getSym(2);
					RelationCS result = (RelationCS)$getSym(1);
					result.getDomain().add(domainCS);
					setOffsets(result, result, domainCS);
					$setResult(result);
		  $EndCode
		./
	relationCS_postWhen -> relationCS_postDomain
	relationCS_postWhen ::= relationCS_postDomain whenCS
		/.$BeginCode
					RelationCS result = (RelationCS)$getSym(1);
					WhenCS whenCS = (WhenCS)$getSym(2);
					result.setWhen(whenCS);
					setOffsets(result, result, whenCS);
					$setResult(result);
		  $EndCode
		./
	relationCS_postWhere -> relationCS_postWhen
	relationCS_postWhere ::= relationCS_postWhen whereCS
		/.$BeginCode
					RelationCS result = (RelationCS)$getSym(1);
					WhereCS whereCS = (WhereCS)$getSym(2);
					result.setWhere(whereCS);
					setOffsets(result, result, whereCS);
					$setResult(result);
		  $EndCode
		./
	relationCS ::= relationCS_postWhere '}'
		/.$BeginCode
					RelationCS result = (RelationCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./

	whenCS_0 ::= when '{'
		/.$BeginCode
					WhenCS result = QVTrCSTFactory.eINSTANCE.createWhenCS();
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
	whenCS_0 ::= when ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_WHEN);
		  $EndCode
		./	
	whenCS_1 -> whenCS_0
	whenCS_1 ::= whenCS_1 oclExpressionCS ';'
		/.$BeginCode
					WhenCS result = (WhenCS)$getSym(1);
					OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(2);
					result.getExpr().add(oclExpressionCS);
					setOffsets(result, result, getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	whenCS ::= whenCS_1 '}'
		/.$BeginCode
					WhenCS result = (WhenCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./


	whereCS_0 ::= where '{'
		/.$BeginCode
					WhereCS result = QVTrCSTFactory.eINSTANCE.createWhereCS();
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
	whereCS_0 ::= where ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_WHERE);
		  $EndCode
		./	
	whereCS_1 -> whereCS_0
	whereCS_1 ::= whereCS_1 oclExpressionCS ';'
		/.$BeginCode
					WhereCS result = (WhereCS)$getSym(1);
					OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(2);
					result.getExpr().add(oclExpressionCS);
					setOffsets(result, result, getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	whereCS ::= whereCS_1 '}'
		/.$BeginCode
					WhereCS result = (WhereCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./


--<varDeclaration> ::= <identifier> (, <identifier>)* ':' <TypeCS> ';'
	varDeclarationCS_0 ::= identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
					VarDeclarationCS result = QVTrCSTFactory.eINSTANCE.createVarDeclarationCS();
					result.getVarDeclarationId().add(identifierCS);
					setOffsets(result, identifierCS);
					$setResult(result);
		  $EndCode
		./
	varDeclarationCS_0 ::= varDeclarationCS_0 ',' identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(3);
					VarDeclarationCS result = (VarDeclarationCS)$getSym(1);
					result.getVarDeclarationId().add(identifierCS);
					setOffsets(result, result, identifierCS);
					$setResult(result);
		  $EndCode
		./		
	varDeclarationCS ::= varDeclarationCS_0 ':' typeCS ';'
		/.$BeginCode
					VarDeclarationCS result = (VarDeclarationCS)$getSym(1);
					result.setType((TypeCS)$getSym(3));
					setOffsets(result, result, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./
	
--<domain> ::= [<checkEnforceQualifier>] 'domain' <modelId> <template>

--             ';'
--<checkEnforceQualifier> ::= 'checkonly' | 'enforce'
	domainCS_0_ ::= domain modelIdCS templateCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(2);
					TemplateCS templateCS = (TemplateCS)$getSym(3);
					DomainCS result = QVTrCSTFactory.eINSTANCE.createDomainCS();

					result.setTemplate(templateCS);
					setOffsets(result, getIToken($getToken(1)), templateCS);
					$setResult(result);
		  $EndCode
		./
	domainCS_1_ -> domainCS_0_
	domainCS_1_ ::= checkonly domainCS_0_
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(2);
					result.setCheckonly(true);
					setOffsets(result, getIToken($getToken(1)), result);
					$setResult(result);
		  $EndCode
		./
	domainCS_1_ ::= enforce domainCS_0_
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(2);
					result.setEnforce(true);
					setOffsets(result, getIToken($getToken(1)), result);
					$setResult(result);
		  $EndCode
		./
	domainCS_1_ ::= replace domainCS_0_
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(2);
					result.setReplace(true);
					setOffsets(result, getIToken($getToken(1)), result);
					$setResult(result);
		  $EndCode
		./
	domainCS_postImplementedby -> domainCS_1_
	domainCS_postImplementedby ::= domainCS_1_ implementedby operationCallExpCS
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(1);
					OperationCallExpCS operationCallExpCS =(OperationCallExpCS)$getSym(3);
					result.setImplementedBy(operationCallExpCS);
					setOffsets(result, result, operationCallExpCS);
					$setResult(result);
		  $EndCode
		./
	domainCS_preDefaultValue -> domainCS_postImplementedby default_values '{'
	domainCS_preDefaultValue ::= domainCS_preDefaultValue defaultValueCS
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(1);
					DefaultValueCS defaultValueCS = (DefaultValueCS)$getSym(2);
					result.getDefaultValue().add(defaultValueCS);
					setOffsets(result, result, defaultValueCS);
					$setResult(result);
		  $EndCode
		./
	domainCS_postDefaultValues -> domainCS_postImplementedby
	domainCS_postDefaultValues ::= domainCS_preDefaultValue '}'
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
	domainCS ::= domainCS_postDefaultValues ';'
		/.$BeginCode
					DomainCS result = (DomainCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
		
--<primitiveTypeDomain> ::= 'primitive' 'domain' <identifier> ':' <TypeCS> ';'
	primitiveTypeDomainCS ::= primitive domain identifierCS ':' typeCS ';'
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(3);
					TypeCS typeCS = (TypeCS)$getSym(5);
					PrimitiveTypeDomainCS result = QVTrCSTFactory.eINSTANCE.createPrimitiveTypeDomainCS();

					result.setType(typeCS);
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(6)));
					$setResult(result);
		  $EndCode
		./



	templateCS_0_ -> collectionTemplateCS
	templateCS -> templateCS_0_
	templateCS ::= templateCS_0_ '{' oclExpressionCS '}'
		/.$BeginCode
					TemplateCS result = (TemplateCS)$getSym(1);
					OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(3);
					result.setGuardExpression(oclExpressionCS);
					setOffsets(result, result, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./
	
--<objectTemplate> ::= [<identifier>] ':' <pathNameCS> '{' [<propertyTemplateList>] '}'

	objectTemplateCS_prePropertyTemplates ::= relationIdentifier ':' pathNameCS '{'
		/.$NewCase./
	objectTemplateCS_prePropertyTemplates ::= self ':' pathNameCS '{'
		/.$BeginCode
					IdentifierCS identifierCS = createIdentifierCS($getToken(1));
					TypeCS typeCS = (TypeCS)$getSym(3);
					ObjectTemplateCS result = QVTrCSTFactory.eINSTANCE.createObjectTemplateCS();

					result.setIdentifier(identifierCS);
					setOffsets(result, identifierCS, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./	
	objectTemplateCS_prePropertyTemplates ::= ':' pathNameCS '{' 
		/.$BeginCode
					ObjectTemplateCS result = QVTrCSTFactory.eINSTANCE.createObjectTemplateCS();
					result.setIdentifier(createUniqueIdentifierCS($getToken(1)));
					result.setType((TypeCS)$getSym(2));
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./	
	objectTemplateCS_prePropertyTemplate -> objectTemplateCS_prePropertyTemplates
	objectTemplateCS_prePropertyTemplate -> objectTemplateCS_postPropertyTemplate ','
	objectTemplateCS_postPropertyTemplate ::= objectTemplateCS_prePropertyTemplate propertyTemplateCS 
		/.$BeginCode
					ObjectTemplateCS result = (ObjectTemplateCS)$getSym(1);
					PropertyTemplateCS propertyTemplateCS = (PropertyTemplateCS)$getSym(2);
					result.getPropertyTemplate().add(propertyTemplateCS);
					setOffsets(result, result, propertyTemplateCS);
					$setResult(result);
		  $EndCode
		./	
	objectTemplateCS ::= objectTemplateCS_prePropertyTemplates '}' 
		/.$NewCase./
	objectTemplateCS ::= objectTemplateCS_postPropertyTemplate '}' 
		/.$BeginCode
					ObjectTemplateCS result = (ObjectTemplateCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./

--<propertyTemplate> ::= <identifier> '=' <OclExpressionCS>
	propertyTemplateCS ::= propertyIdCS '=' oclExpressionCS
		/.$BeginCode
					IdentifiedCS propertyIdCS = (IdentifiedCS)$getSym(1);
					PropertyTemplateCS result = QVTrCSTFactory.eINSTANCE.createPropertyTemplateCS();
					OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(3);

					result.setOclExpression(oclExpressionCS);
					setOffsets(result, propertyIdCS, oclExpressionCS);
					$setResult(result);
		  $EndCode
		./
	
--<collectionTemplate> ::= [<identifier>] ':' <CollectionTypeIdentifierCS> '(' <TypeCS> ')'
--                         '{' [<memberSelection>] '}'
--<memberSelection> ::= (<identifier> | <template> | '_')




					result.setIdentifier(identifierCS);
					setOffsets(result, identifierCS, collectionTypeCS);
					$setResult(result);
		  $EndCode
		./	
	collectionTemplateCS_preMemberSelections -> collectionTemplateCS_1_ '{'
	collectionTemplateCS_preMemberSelection -> collectionTemplateCS_preMemberSelections
	collectionTemplateCS_preMemberSelection -> collectionTemplateCS_postMemberSelection ','
	collectionTemplateCS_postMemberSelection ::= collectionTemplateCS_preMemberSelection memberSelectorCS
		/.$BeginCode
					IdentifiedCS memberSelectorCS = (IdentifiedCS)$getSym(2);
					CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
					result.getMemberIdentifier().add(memberSelectorCS);
					setOffsets(result, result, memberSelectorCS);
					$setResult(result);
		  $EndCode
		./	
	collectionTemplateCS ::= collectionTemplateCS_postMemberSelection PLUS_PLUS identifierCS '}'
		/.$BeginCode
					IdentifierCS restIdentifier = (IdentifierCS)$getSym(3);
					CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
					result.setRestIdentifier(restIdentifier);
					setOffsets(result, result, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./
	collectionTemplateCS ::= collectionTemplateCS_postMemberSelection ERROR_TOKEN '}'
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_REST);
					IdentifierCS restIdentifier = createUniqueIdentifierCS($getToken(2));
					CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
					result.setRestIdentifier(restIdentifier);
					setOffsets(result, result, getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	collectionTemplateCS ::= collectionTemplateCS_preMemberSelections '}'
		/.$BeginCode
					CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(2)));
					$setResult(result);
		  $EndCode
		./
		
--<memberSelector> ::= (<identifier> | <template> | '_')
	memberSelectorCS ::= identifierCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
					IdentifiedCS result = QVTCSTFactory.eINSTANCE.createIdentifiedCS();
					result.setIdentifier(identifierCS);
					setOffsets(result, identifierCS);
					$setResult(result);
		  $EndCode
		./	
	memberSelectorCS -> templateCS
	
--<assignmentExp> ::= <identifier> '=' <OclExpressionCS> ';'
	defaultValueCS ::= identifierCS '=' oclExpressionCS ';'
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
					OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(3);
					DefaultValueCS result = QVTrCSTFactory.eINSTANCE.createDefaultValueCS();

					result.setInitialiser(oclExpressionCS);
					setOffsets(result, identifierCS, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./	
		
--<query> ::= 'query' <PathNameCS> 

--      	  ':' <TypeCS>
--            (';' | '{' <OclExpressionCS> '}')
	queryCS_preParamDeclaration ::= query pathNameCS '('
		/.$BeginCode
					QueryCS result = QVTrCSTFactory.eINSTANCE.createQueryCS();
					result.setPathName((PathNameCS)$getSym(2));
					setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	queryCS_preParamDeclaration -> queryCS_postParamDeclaration ','
	queryCS_postParamDeclaration ::= queryCS_preParamDeclaration paramDeclarationCS
		/.$BeginCode
					ParamDeclarationCS paramDeclarationCS = (ParamDeclarationCS)$getSym(2);
					QueryCS result = (QueryCS)$getSym(1);
					result.getInputParamDeclaration().add(paramDeclarationCS);
					setOffsets(result, result, paramDeclarationCS);
					$setResult(result);
		  $EndCode
		./
	queryCS_postType ::= queryCS_postParamDeclaration ')' ':' typeCS
		/.$BeginCode
					TypeCS typeCS = (TypeCS)$getSym(4);
					QueryCS result = (QueryCS)$getSym(1);
					result.setType(typeCS);
					setOffsets(result, result, typeCS);
					$setResult(result);
		  $EndCode
		./
	queryCS ::= queryCS_postType ';'
		/.$BeginCode
					QueryCS result = (QueryCS)$getSym(1);
					setOffsets(result, result, getIToken($getToken(3)));
					$setResult(result);
		  $EndCode
		./
	queryCS ::= queryCS_postType '{' oclExpressionCS '}'
		/.$BeginCode
					QueryCS result = (QueryCS)$getSym(1);
					result.setOclExpression((OCLExpressionCS)$getSym(3));
					setOffsets(result, result, getIToken($getToken(4)));
					$setResult(result);
		  $EndCode
		./
	
--<paramDeclaration> ::= <identifier> ':' <TypeCS>	
	paramDeclarationCS ::= identifierCS ':' typeCS
		/.$BeginCode
					IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
					TypeCS typeCS = (TypeCS)$getSym(3);
					ParamDeclarationCS result = QVTrCSTFactory.eINSTANCE.createParamDeclarationCS();

					result.setType(typeCS);
					setOffsets(result, identifierCS, typeCS);
					$setResult(result);
		  $EndCode
		./
	paramDeclarationCS ::= identifierCS ERROR_TOKEN
		/.$BeginCode
					reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_PARAM_DECLARATION);
		  $EndCode
		./	
		
--<OclExpressionCS> ::= <PropertyCallExpCS> 

	relationIdentifier -> pre
	
	pathNameCS ::= relationIdentifier
		/.$BeginCode
					PathNameCS result = createPathNameCS();
					result.getSequenceOfNames().add(getTokenText($getToken(1)));
					setOffsets(result, getIToken($getToken(1)));
					$setResult(result);
		  $EndCode
		./

	simpleNameCS ::= relationIdentifier
		/.$BeginCode
					SimpleNameCS result = createSimpleNameCS(
								SimpleTypeEnum.IDENTIFIER_LITERAL,
								getTokenText($getToken(1))
							);
					setOffsets(result, getIToken($getToken(1)));
					$setResult(result);
		  $EndCode
		./
	
	identifierCS ::= IDENTIFIER

	identifierCS ::= relationIdentifier
		/.$NewCase ./
	identifierCS ::= self
		/.$BeginCode
					IdentifierCS result = createIdentifierCS($getToken(1));
					$setResult(result);
		  $EndCode
		./
%End
	




import java.util.ArrayList;
import java.util.List;

import lpg.runtime.Monitor;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.TreeIterator;

		}
		try {
			Reader fileReader = new FileReader(file);
			QVTrLexer lexer = new QVTrLexer(env.getFileEnvironment(), fileReader, file.toString());			
			QVTrParser parser = new QVTrParser(lexer);
			lexer.lexer(parser.getIPrsStream());
			CSTNode cstNode = parser.parser();
			lexer.lexToTokens(parser);
			CSTNode cstNode = parser.parseTokensToCST();
			if (cstNode == null)
				return null;
			List<TransformationCS> importedTransformationCS = ((TopLevelCS) cstNode).getTransformation();

Lines 10-16 Link Here

(-)src/org/eclipse/qvt/declarative/parser/qvtrelation/QVTrAnalyzer.java (-3 / +6 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.qvt.declarative.parser.qvtrelation;	11	package org.eclipse.qvt.declarative.parser.qvtrelation;
12		12
13	import lpg.lpgjavaruntime.Monitor;	13	import java.io.IOException;
		14	import java.io.Reader;
		15
		16	import lpg.runtime.Monitor;
14		17
15	import org.eclipse.qvt.declarative.parser.environment.ICSTFileAnalyzer;	18	import org.eclipse.qvt.declarative.parser.environment.ICSTFileAnalyzer;
16	import org.eclipse.qvt.declarative.parser.qvtrelation.environment.QVTrFileEnvironment;	19	import org.eclipse.qvt.declarative.parser.qvtrelation.environment.QVTrFileEnvironment;
Lines 18-25 Link Here
18		21
19	public class QVTrAnalyzer extends AbstractQVTrAnalyzer implements ICSTFileAnalyzer<QVTrTopLevelEnvironment>	22	public class QVTrAnalyzer extends AbstractQVTrAnalyzer implements ICSTFileAnalyzer<QVTrTopLevelEnvironment>
20	{	23	{
21	public QVTrAnalyzer(QVTrFileEnvironment environment, Monitor monitor) {	24	public QVTrAnalyzer(QVTrFileEnvironment environment, Monitor monitor, Reader reader, String fileName) throws IOException {
22	super(new QVTrParser(new QVTrLexer(environment)), monitor);	25	super(new QVTrParser(new QVTrLexer(environment, reader, fileName)), monitor);
23	}	26	}
24		27
25	public boolean analyze(QVTrTopLevelEnvironment environment) {	28	public boolean analyze(QVTrTopLevelEnvironment environment) {

Lines 10-16 Link Here

(-)src/org/eclipse/qvt/declarative/parser/qvtrelation/environment/QVTrFileEnvironment.java (-3 / +7 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.qvt.declarative.parser.qvtrelation.environment;	11	package org.eclipse.qvt.declarative.parser.qvtrelation.environment;
12		12
13	import lpg.lpgjavaruntime.Monitor;	13	import java.io.IOException;
		14	import java.io.Reader;
		15
		16	import lpg.runtime.Monitor;
14		17
15	import org.eclipse.emf.ecore.resource.ResourceSet;	18	import org.eclipse.emf.ecore.resource.ResourceSet;
16	import org.eclipse.emf.ecore.xmi.XMIResource;	19	import org.eclipse.emf.ecore.xmi.XMIResource;
Lines 27-34 Link Here
27	}	30	}
28		31
29	@Override	32	@Override
30	public QVTrAnalyzer createAnalyzer(Monitor monitor) {	33	protected QVTrAnalyzer createAnalyzer(
31	return new QVTrAnalyzer(this, monitor);	34	Monitor monitor, Reader reader, String fileName) throws IOException {
		35	return new QVTrAnalyzer(this, monitor, reader, fileName);
32	}	36	}
33		37
34	@Override	38	@Override

Lines 29-35 Link Here

(-)src/org/eclipse/qvt/declarative/parser/qvtrelation/environment/PrintStreamProblemHandler.java (-1 / +1 lines)
29		29
30	@Override public void handleProblem(Severity problemSeverity, Phase processingPhase,	30	@Override public void handleProblem(Severity problemSeverity, Phase processingPhase,
31	String problemMessage, String processingContext, int startOffset, int endOffset) {	31	String problemMessage, String processingContext, int startOffset, int endOffset) {
32	int lineNumber = getParser().getTokenAtCharacter(startOffset).getLine();	32	int lineNumber = getParser().getIPrsStream().getTokenAtCharacter(startOffset).getLine();
33	stream.println(file.getName() + ":" + lineNumber + ": " + String.valueOf(processingPhase) + "-" + String.valueOf(problemSeverity) + ": " + problemMessage + ": " + getParser().computeInputString(startOffset, endOffset));	33	stream.println(file.getName() + ":" + lineNumber + ": " + String.valueOf(processingPhase) + "-" + String.valueOf(problemSeverity) + ": " + problemMessage + ": " + getParser().computeInputString(startOffset, endOffset));
34	}	34	}
35	}	35	}




--/**
-- * <copyright>
-- *
-- * Copyright (c) 2007,2008 E.D.Willink and others.
-- * All rights reserved.   This program and the accompanying materials
-- * are made available under the terms of the Eclipse Public License v1.0
-- * which accompanies this distribution, and is available at
-- * http://www.eclipse.org/legal/epl-v10.html
-- *
-- * Contributors:
-- *   E.D.Willink - Initial API and implementation
-- *
-- * </copyright>
-- */
--
-- The QVTr Lexer
--

%options escape=$
%options la=2
%options fp=QVTrLexer,prefix=Char_
%options single-productions
%options noserialize
%options package=org.eclipse.qvt.declarative.parser.qvtrelation
%options template=../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg/LexerTemplateF.gi
%options filter=QVTrKWLexer.gi
%options export_terminals=("QVTrParsersym.java", "TK_")
%options include_directory=".;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/parser"

%Import
	OCLLexer.gi
%End

%Define
	--
	-- Definition of macro used in the included file LexerBasicMap.g
	--
	$kw_lexer_class /.QVTrKWLexer./
    $environment_class /.ICSTFileEnvironment./
    $environment_import /.org.eclipse.qvt.declarative.parser.environment.ICSTFileEnvironment./
	$copyright_contributions /.*   E.D.Willink - Extended API and implementation for QVTr
*./
%End

%Export
	PLUS_PLUS
%End

%Rules

	Token ::= '+' '+'
		/.$BeginAction
					makeToken($_PLUS_PLUS);
		  $EndAction
		./
		
	SLC -> '/' '/'
%End




--/**
-- * Copyright (c) 2007,2008 E.D.Willink and others.
-- * All rights reserved.   This program and the accompanying materials
-- * are made available under the terms of the Eclipse Public License v1.0
-- * which accompanies this distribution, and is available at
-- * http://www.eclipse.org/legal/epl-v10.html
-- *
-- * Contributors:
-- *   E.D.Willink - Initial API and implementation
-- */
--
-- The QVTr KeyWord Lexer
--

%Options slr
%Options fp=QVTrKWLexer,prefix=Char_
%options noserialize
%options package=org.eclipse.qvt.declarative.parser.qvtrelation
%options template=../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg/KeywordTemplateF.gi
%options export_terminals=("QVTrParsersym.java", "TK_")
%options include_directory=".;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/parser"

%Import
	OCLKWLexer.gi
%End

%Define
	$copyright_contributions /.*   E.D.Willink - Extended API and implementation for QVTr
*./
%End

%Export
	checkonly
	default_values
	domain
	enforce
	extends
	implementedby
	import
	key
	overrides
	primitive
	query
	relation
	replace
	top
	transformation
	when
	where
%End

%Terminals
	_
%End

%Headers
    /.
        static
        {
            tokenKind['_'] = Char__;
        };
    ./
%End

%Rules

-- The Goal for the parser is a single Keyword

	KeyWord ::=
		  c h e c k o n l y
		/.$BeginAction
			$setResult($_checkonly);
		  $EndAction
		./
		
		| d e f a u l t _ v a l u e s
		/.$BeginAction
			$setResult($_default_values);
		  $EndAction
		./
		
		| d o m a i n
		/.$BeginAction
			$setResult($_domain);
		  $EndAction
		./
		
		| e n f o r c e
		/.$BeginAction
			$setResult($_enforce);
		  $EndAction
		./
		
		| e x t e n d s
		/.$BeginAction
			$setResult($_extends);
		  $EndAction
		./
		
		| i m p l e m e n t e d b y
		/.$BeginAction
			$setResult($_implementedby);
		  $EndAction
		./
		
		| i m p o r t
		/.$BeginAction
			$setResult($_import);
		  $EndAction
		./
		
		| k e y
		/.$BeginAction
			$setResult($_key);
		  $EndAction
		./
		
		| o v e r r i d e s
		/.$BeginAction
			$setResult($_overrides);
		  $EndAction
		./
		
		| p r i m i t i v e
		/.$BeginAction
			$setResult($_primitive);
		  $EndAction
		./
		
		| q u e r y
		/.$BeginAction
			$setResult($_query);
		  $EndAction
		./
		
		| r e l a t i o n
		/.$BeginAction
			$setResult($_relation);
		  $EndAction
		./
		
		| r e p l a c e
		/.$BeginAction
			$setResult($_replace);
		  $EndAction
		./
		
		| t o p
		/.$BeginAction
			$setResult($_top);
		  $EndAction
		./
		
		| t r a n s f o r m a t i o n
		/.$BeginAction
			$setResult($_transformation);
		  $EndAction
		./
		
		| w h e n
		/.$BeginAction
			$setResult($_when);
		  $EndAction
		./
		
		| w h e r e
		/.$BeginAction
			$setResult($_where);
		  $EndAction
		./
%End




package org.eclipse.qvt.declarative.editor.ocl.ui.imp;

import org.eclipse.ocl.cst.CSTPackage;
import org.eclipse.ocl.parser.backtracking.OCLBacktrackingParsersym;
import org.eclipse.qvt.declarative.editor.ocl.ui.OCLCreationFactory;
import org.eclipse.qvt.declarative.editor.ui.imp.CommonKeyword;
import org.eclipse.qvt.declarative.editor.ui.imp.CommonParseController;


	public TokenKind getTokenKind(int kind) {
		switch (kind) {
		case OCLBacktrackingParsersym.TK_EOF_TOKEN:
			return TokenKind.EOF;
		case OCLBacktrackingParsersym.TK_IDENTIFIER:
			return TokenKind.IDENTIFIER;
		case OCLBacktrackingParsersym.TK_INTEGER_LITERAL:
			return TokenKind.INTEGER;
		case OCLBacktrackingParsersym.TK_REAL_LITERAL:
			return TokenKind.REAL;
        case OCLBacktrackingParsersym.TK_STRING_LITERAL:
            return TokenKind.STRING;
        case OCLBacktrackingParsersym.TK_SINGLE_LINE_COMMENT:
            return TokenKind.LINE_COMMENT;
        case OCLBacktrackingParsersym.TK_MULTI_LINE_COMMENT:
            return TokenKind.PARAGRAPH_COMMENT;
		default:
			if (isKeyword(kind))

Lines 14-20 Link Here

(-)src/org/eclipse/qvt/declarative/parser/AbstractQVTAnalyzer.java (-1 / +1 lines)
14	import java.util.Comparator;	14	import java.util.Comparator;
15	import java.util.List;	15	import java.util.List;
16		16
17	import lpg.lpgjavaruntime.Monitor;	17	import lpg.runtime.Monitor;
18		18
19	import org.eclipse.emf.common.util.EList;	19	import org.eclipse.emf.common.util.EList;
20	import org.eclipse.emf.ecore.EClass;	20	import org.eclipse.emf.ecore.EClass;

Lines 266-272 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/CSTRootEnvironment.java (-1 / +1 lines)
266	}	266	}
267		267
268	public int getCSTErrorTokens() {	268	public int getCSTErrorTokens() {
269	return getParser().getErrorTokens();	269	return getParser().getIPrsStream().getErrorTokens();
270	}	270	}
271		271
272	public ICSTFileEnvironment getFileEnvironment() {	272	public ICSTFileEnvironment getFileEnvironment() {

Lines 20-26 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/ICSTFileEnvironment.java (-2 / +2 lines)
20	import java.io.Reader;	20	import java.io.Reader;
21	import java.util.Collection;	21	import java.util.Collection;
22		22
23	import lpg.lpgjavaruntime.Monitor;	23	import lpg.runtime.Monitor;
24		24
25	import org.eclipse.core.runtime.CoreException;	25	import org.eclipse.core.runtime.CoreException;
26	import org.eclipse.core.runtime.IProgressMonitor;	26	import org.eclipse.core.runtime.IProgressMonitor;
Lines 34-40 Link Here
34		34
35	public interface ICSTFileEnvironment extends ICSTEnvironment	35	public interface ICSTFileEnvironment extends ICSTEnvironment
36	{	36	{
37	public ICSTFileAnalyzer<?> createAnalyzer(Monitor monitor);	37	public ICSTFileAnalyzer<?> getAnalyzer(Monitor monitor, Reader reader, String fileName) throws IOException;
38		38
39	public XMIResource getASTResource();	39	public XMIResource getASTResource();
40		40

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/CSTFileEnvironment.java (-8 / +21 lines)
16	import java.util.ArrayList;	16	import java.util.ArrayList;
17	import java.util.List;	17	import java.util.List;
18		18
19	import lpg.lpgjavaruntime.Monitor;	19	import lpg.runtime.Monitor;
20		20
21	import org.eclipse.core.runtime.CoreException;	21	import org.eclipse.core.runtime.CoreException;
22	import org.eclipse.core.runtime.IProgressMonitor;	22	import org.eclipse.core.runtime.IProgressMonitor;
Lines 42-48 Link Here
42	{	42	{
43	protected final EPackage.Registry registryToo;	43	protected final EPackage.Registry registryToo;
44	protected final XMIResource ast;	44	protected final XMIResource ast;
45	protected final AbstractModelResolver resolver;	45	protected final AbstractModelResolver resolver;
		46
		47	private ICSTFileAnalyzer<R> analyzer;
		48
46	private TypeResolver<EClassifier, EOperation, EStructuralFeature> typeResolver; // FIXME Duplicated to support reset	49	private TypeResolver<EClassifier, EOperation, EStructuralFeature> typeResolver; // FIXME Duplicated to support reset
47	// inherited functionality should allow typeResolver to be in CSTRootEnvironment	50	// inherited functionality should allow typeResolver to be in CSTRootEnvironment
48		51
Lines 63-69 Link Here
63	this(new EPackageRegistryImpl(), file, resourceSet, astResource);	66	this(new EPackageRegistryImpl(), file, resourceSet, astResource);
64	}	67	}
65		68
66	public abstract ICSTFileAnalyzer<R> createAnalyzer(Monitor monitor);	69	public ICSTFileAnalyzer<R> getAnalyzer(Monitor monitor, Reader reader, String fileName) throws IOException {
		70
		71	if (analyzer == null) {
		72	analyzer = createAnalyzer(monitor, reader, fileName);
		73	} else {
		74	analyzer.reset(reader, null);
		75	}
		76	return analyzer;
		77	}
		78
		79	protected abstract ICSTFileAnalyzer<R> createAnalyzer(Monitor monitor, Reader reader, String fileName) throws IOException;
67		80
68	protected abstract R createRootEnvironment(XMIResource ast, CST cst);	81	protected abstract R createRootEnvironment(XMIResource ast, CST cst);
69		82
Lines 110-134 Link Here
110		123
111	public ICSTRootEnvironment parse(Reader reader, AbstractFileHandle file, IProgressMonitor monitor) throws IOException, CoreException {	124	public ICSTRootEnvironment parse(Reader reader, AbstractFileHandle file, IProgressMonitor monitor) throws IOException, CoreException {
112	Monitor lpgMonitor = new LPGProgressMonitor(monitor);	125	Monitor lpgMonitor = new LPGProgressMonitor(monitor);
113	ICSTFileAnalyzer<R> analyzer = createAnalyzer(lpgMonitor);
114	analyzer.setFileName(file.getName());
115	if (reader == null)	126	if (reader == null)
116	reader = new InputStreamReader(file.getContents());	127	reader = new InputStreamReader(file.getContents());
117	else if (!file.exists())	128	else if (!file.exists())
118	return null;	129	return null;
119	analyzer.initialize(reader);	130
		131	ICSTFileAnalyzer<R> analyzer = getAnalyzer(lpgMonitor, reader, file.getName());
120	AbstractParser parser = getParser();	132	AbstractParser parser = getParser();
121	if ((monitor != null) && monitor.isCanceled())	133	if ((monitor != null) && monitor.isCanceled())
122	return null;	134	return null;
123	parser.getLexer().lexToTokens(parser);	135	parser.getLexer().lexer(parser.getIPrsStream());
124	if ((monitor != null) && monitor.isCanceled())	136	if ((monitor != null) && monitor.isCanceled())
125	return null;	137	return null;
126	@SuppressWarnings("unchecked") // Maybe this should be a generic parameter	138	@SuppressWarnings("unchecked") // Maybe this should be a generic parameter
127	CST cst = (CST) parser.parseTokensToCST(lpgMonitor, -1);	139	CST cst = (CST) parser.parser(lpgMonitor, -1);
128	if (cst == null)	140	if (cst == null)
129	return null;	141	return null;
130	if ((monitor != null) && monitor.isCanceled())	142	if ((monitor != null) && monitor.isCanceled())
131	return null;	143	return null;
		144
132	R rootEnvironment;	145	R rootEnvironment;
133	try {	146	try {
134	reset();	147	reset();

Lines 31-37 Link Here

(-)src/org/eclipse/qvt/declarative/parser/environment/ICSTFileAnalyzer.java (+7 lines)
31		31
32	public AbstractParser getParser();	32	public AbstractParser getParser();
33		33
		34	/**
		35	* @param reader
		36	* @throws IOException
		37	* @deprecated clients should invoke {@link #reset(Reader, String)}
		38	*/
34	public void initialize(Reader reader) throws IOException;	39	public void initialize(Reader reader) throws IOException;
		40
		41	public void reset(Reader reader, String fileName) throws IOException;
35		42
36	public void setFileName(String name);	43	public void setFileName(String name);
37	}	44	}

Lines 10-16 Link Here

(-)src/org/eclipse/qvt/declarative/parser/qvt/environment/LPGProgressMonitor.java (-1 / +1 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.qvt.declarative.parser.qvt.environment;	11	package org.eclipse.qvt.declarative.parser.qvt.environment;
12		12
13	import lpg.lpgjavaruntime.Monitor;	13	import lpg.runtime.Monitor;
14		14
15	import org.eclipse.core.runtime.IProgressMonitor;	15	import org.eclipse.core.runtime.IProgressMonitor;
16		16




import java.util.Map;
import java.util.Set;

import lpg.runtime.IPrsStream;

import org.eclipse.ocl.lpg.AbstractProblemHandler;
import org.eclipse.ocl.lpg.ProblemHandler;
import org.eclipse.osgi.util.NLS;

						if (problem.endOffset >= 0) {
							s.append(" : ");
							s.append(problem.endOffset);
							IPrsStream stream = getParser().getIPrsStream();
							if (stream != null) {
								int token =stream.getTokenIndexAtCharacter(problem.startOffset);
								s.append(" ");
								try {
									s.append(stream.getLine(token));
								} catch (ArrayIndexOutOfBoundsException e) {
									s.append("???");
								}
								s.append(":");
								try {
									s.append(stream.getColumn(token));
								} catch (ArrayIndexOutOfBoundsException e) {
									s.append("???");
								}




import java.util.Iterator;
import java.util.List;

import lpg.runtime.ErrorToken;
import lpg.runtime.IPrsStream;
import lpg.runtime.IToken;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;


	static final class TokenIterator implements Iterator<IToken>
	{
		final IPrsStream stream;
		final int firstTokIdx;
		final int lastTokIdx;
		int curTokIdx; // skip bogus initial token

		private boolean finalTokenReturned;
		private boolean finalAdjunctsReturned;

		private TokenIterator(IPrsStream stream, int regionEnd, int regionOffset) {
			this.stream = stream;
			firstTokIdx = getTokenIndexAtCharacter(regionOffset);
			curTokIdx = Math.max(1, firstTokIdx);

	}

	public String getTextRange(int start, int length) {
		return new String(getLexer().getILexStream().getInputChars(), start, length);
	}

	protected int[] getKeywordKinds() {

        int regionOffset= region.getOffset();
        int regionLength= region.getLength();
    	int regionEnd = regionOffset + regionLength - 1;
		IPrsStream stream =  getParser().getIPrsStream();
		if (stream != null)
			return new TokenIterator(stream, regionEnd, regionOffset);
		else




import java.util.Map;
import java.util.Set;

import lpg.runtime.ErrorToken;
import lpg.runtime.IToken;

import org.eclipse.emf.common.util.TreeIterator;
import org.eclipse.emf.ecore.EClass;

import org.eclipse.ocl.cst.PathNameCS;
import org.eclipse.ocl.cst.SimpleNameCS;
import org.eclipse.ocl.expressions.StringLiteralExp;
import org.eclipse.ocl.lpg.OCLParserStream;
import org.eclipse.qvt.declarative.ecore.utils.EcoreUtils;
import org.eclipse.qvt.declarative.ecore.utils.TracingOption;
import org.eclipse.qvt.declarative.editor.ui.QVTEditorPlugin;

	}
	
	protected IToken getToken() {
		OCLParserStream stream = parseResult.getParser().getIPrsStream();
		IToken errorToken = stream.getErrorTokenAtCharacter(offset);
		if (errorToken != null)
			return errorToken;

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonTokenColorer.java (-1 / +7 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.editor.ui.imp;	17	package org.eclipse.qvt.declarative.editor.ui.imp;
18		18
19	import lpg.lpgjavaruntime.IToken;	19	import lpg.runtime.IToken;
20		20
21	import org.eclipse.imp.parser.IParseController;	21	import org.eclipse.imp.parser.IParseController;
22	import org.eclipse.imp.services.ITokenColorer;	22	import org.eclipse.imp.services.ITokenColorer;
Lines 73-76 Link Here
73	return super.getColoring(controller, token);	73	return super.getColoring(controller, token);
74	}	74	}
75	}	75	}
		76
		77	public TextAttribute getInterColoring(IParseController controller,
		78	Object prevToken, Object nextToken) {
		79	// TODO Auto-generated method stub
		80	return null;
		81	}
76	}	82	}

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonSourcePositionLocator.java (-1 / +1 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.editor.ui.imp;	17	package org.eclipse.qvt.declarative.editor.ui.imp;
18		18
19	import lpg.lpgjavaruntime.IToken;	19	import lpg.runtime.IToken;
20		20
21	import org.eclipse.core.runtime.IPath;	21	import org.eclipse.core.runtime.IPath;
22	import org.eclipse.core.runtime.Path;	22	import org.eclipse.core.runtime.Path;

Lines 33-39 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonParseController.java (-1 / +1 lines)
33	import java.util.Iterator;	33	import java.util.Iterator;
34	import java.util.List;	34	import java.util.List;
35		35
36	import lpg.lpgjavaruntime.IToken;	36	import lpg.runtime.IToken;
37		37
38	import org.eclipse.core.resources.IProject;	38	import org.eclipse.core.resources.IProject;
39	import org.eclipse.core.runtime.CoreException;	39	import org.eclipse.core.runtime.CoreException;




import java.util.HashMap;
import java.util.List;

import lpg.runtime.Adjunct;
import lpg.runtime.ILexStream;
import lpg.runtime.IPrsStream;
import lpg.runtime.IToken;

import org.eclipse.imp.services.base.FolderBase;
import org.eclipse.jface.text.Position;

		}
	};

	protected IPrsStream prsStream = null;

	protected abstract ICommonPlugin getPlugin();

	protected void makeAdjunctAnnotations(CSTNode theAST) {
		ILexStream lexStream = prsStream.getILexStream();
		if (lexStream == null)
			return;
		@SuppressWarnings("unchecked")

			IToken gate_token = adjuncts.length == 0 ? next_token : adjuncts[0];
			makeAnnotationWithOffsets(first_token.getStartOffset(), gate_token
					.getLine() > last_token.getEndLine() ? prsStream
					.getILexStream().getLineOffset(gate_token.getLine() - 1)
					: last_token.getEndOffset());
		}
	}

		if (theCST != null) {
			IToken startToken = theCST.getStartToken();
			if (startToken != null) {
				prsStream = startToken.getIPrsStream();
				FoldingCSTVisitor visitor = new FoldingCSTVisitor(getPlugin().getEditorDefinition());
				visitor.enter(theCST);
				makeAdjunctAnnotations(theCST);

Lines 39-45 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonParseHelper.java (-1 / +1 lines)
39	keywords = new ArrayList<ICommonKeyword>();	39	keywords = new ArrayList<ICommonKeyword>();
40	int[] keywordKinds= parser.getLexer().getKeywordKinds();	40	int[] keywordKinds= parser.getLexer().getKeywordKinds();
41	for(int i= 1; i < keywordKinds.length; i++) {	41	for(int i= 1; i < keywordKinds.length; i++) {
42	int index= parser.mapKind(keywordKinds[i]);	42	int index= parser.getIPrsStream().mapKind(keywordKinds[i]);
43	fIsKeyword[index]= true;	43	fIsKeyword[index]= true;
44	keywords.add(createKeyword(tokenKindNames[index]));	44	keywords.add(createKeyword(tokenKindNames[index]));
45	}	45	}

Lines 16-22 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonProblemHandler.java (-2 / +3 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.editor.ui.imp;	17	package org.eclipse.qvt.declarative.editor.ui.imp;
18		18
19	import lpg.lpgjavaruntime.IToken;	19	import lpg.runtime.IPrsStream;
		20	import lpg.runtime.IToken;
20		21
21	import org.eclipse.core.resources.IMarker;	22	import org.eclipse.core.resources.IMarker;
22	import org.eclipse.imp.parser.IMessageHandler;	23	import org.eclipse.imp.parser.IMessageHandler;
Lines 42-48 Link Here
42	}	43	}
43		44
44	public IToken getNearestTokenAtCharacter(int offset) { // FIXME Move to AbstractParser	45	public IToken getNearestTokenAtCharacter(int offset) { // FIXME Move to AbstractParser
45	AbstractParser parser = getParser();	46	IPrsStream parser = getParser().getIPrsStream();
46	int maxIndex = parser.getSize();	47	int maxIndex = parser.getSize();
47	if (maxIndex <= 0)	48	if (maxIndex <= 0)
48	return null;	49	return null;




 */
package org.eclipse.qvt.declarative.editor.ui.utils;

import lpg.runtime.ILexStream;
import lpg.runtime.IPrsStream;
import lpg.runtime.IToken;

import org.eclipse.ocl.cst.CSTNode;


		IToken token = cstNode.getStartToken();
		if (token == null)
			return null;
		IPrsStream prsStream = token.getIPrsStream();
		if (prsStream == null)
			return null;
		ILexStream lexStream = prsStream.getILexStream();
		if (lexStream == null)
			return null;
		return lexStream.getFileName();

Lines 22-27 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/builder/MarkerProblemHandler.java (-2 / +5 lines)
22	import java.util.Map;	22	import java.util.Map;
23	import java.util.Set;	23	import java.util.Set;
24		24
		25	import lpg.runtime.IPrsStream;
		26
25	import org.eclipse.core.resources.IMarker;	27	import org.eclipse.core.resources.IMarker;
26	import org.eclipse.core.resources.IResource;	28	import org.eclipse.core.resources.IResource;
27	import org.eclipse.core.resources.IWorkspace;	29	import org.eclipse.core.resources.IWorkspace;
Lines 172-180 Link Here
172	String problemMessage, String processingContext, int startOffset, int endOffset) {	174	String problemMessage, String processingContext, int startOffset, int endOffset) {
173	int line = -1;	175	int line = -1;
174	if (startOffset >= 0) {	176	if (startOffset >= 0) {
175	int leftToken = Math.abs(getParser().getTokenIndexAtCharacter(startOffset)); // abs to move non-token to predecessor	177	IPrsStream stream = getParser().getIPrsStream();
		178	int leftToken = Math.abs(stream.getTokenIndexAtCharacter(startOffset)); // abs to move non-token to predecessor
176	if (leftToken >= 0)	179	if (leftToken >= 0)
177	line = getParser().getLine(leftToken);	180	line = stream.getLine(leftToken);
178	}	181	}
179	Integer severity = severityMap.get(problemSeverity);	182	Integer severity = severityMap.get(problemSeverity);
180	addMarker(severity != null ? severity.intValue() : IMarker.SEVERITY_ERROR,	183	addMarker(severity != null ? severity.intValue() : IMarker.SEVERITY_ERROR,

Lines 16-25 Link Here

(-)src/org/eclipse/qvt/declarative/parser/ocl/OCLFileAnalyzer.java (-3 / +5 lines)
16	*/	16	*/
17	package org.eclipse.qvt.declarative.parser.ocl;	17	package org.eclipse.qvt.declarative.parser.ocl;
18		18
		19	import java.io.IOException;
		20	import java.io.Reader;
19	import java.util.ArrayList;	21	import java.util.ArrayList;
20	import java.util.List;	22	import java.util.List;
21		23
22	import lpg.lpgjavaruntime.Monitor;	24	import lpg.runtime.Monitor;
23		25
24	import org.eclipse.emf.ecore.EClass;	26	import org.eclipse.emf.ecore.EClass;
25	import org.eclipse.emf.ecore.EClassifier;	27	import org.eclipse.emf.ecore.EClassifier;
Lines 52-59 Link Here
52	private OCLTopLevelEnvironment topLevelEnvironment = null;	54	private OCLTopLevelEnvironment topLevelEnvironment = null;
53	private EClass iteratorsClass = null;	55	private EClass iteratorsClass = null;
54		56
55	public OCLFileAnalyzer(OCLFileEnvironment environment, Monitor monitor) {	57	public OCLFileAnalyzer(OCLFileEnvironment environment, Monitor monitor, Reader reader, String fileName) throws IOException {
56	super(new OCLBacktrackingParser(new OCLBacktrackingLexer(environment)));	58	super(new OCLBacktrackingParser(new OCLBacktrackingLexer(environment, reader, fileName)));
57	this.monitor = monitor;	59	this.monitor = monitor;
58	}	60	}
59		61




 */
package org.eclipse.qvt.declarative.parser.ocl.environment;

import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import lpg.runtime.IToken;
import lpg.runtime.Monitor;

import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EClass;

	}

	@Override
	protected OCLFileAnalyzer createAnalyzer(
			Monitor monitor, Reader reader, String fileName) throws IOException {
		return new OCLFileAnalyzer(this, monitor, reader, fileName);
	}

	@Override




import org.eclipse.qvt.declarative.editor.qvtrelation.ui.QVTrCreationFactory;
import org.eclipse.qvt.declarative.editor.ui.imp.CommonParseController;
import org.eclipse.qvt.declarative.editor.ui.imp.ICommonKeyword;
import org.eclipse.qvt.declarative.parser.qvtrelation.QVTrParsersym;
import org.eclipse.qvt.declarative.parser.qvtrelation.cst.QVTrCSTPackage;

public class QVTrParseController extends CommonParseController


	public TokenKind getTokenKind(int kind) {
		switch (kind) {
		case QVTrParsersym.TK_EOF_TOKEN:
			return TokenKind.EOF;
		case QVTrParsersym.TK_IDENTIFIER:
			return TokenKind.IDENTIFIER;
		case QVTrParsersym.TK_INTEGER_LITERAL:
			return TokenKind.INTEGER;
		case QVTrParsersym.TK_REAL_LITERAL:
			return TokenKind.REAL;
        case QVTrParsersym.TK_STRING_LITERAL:
             return TokenKind.STRING;
        case QVTrParsersym.TK_SINGLE_LINE_COMMENT:
            return TokenKind.LINE_COMMENT;
        case QVTrParsersym.TK_MULTI_LINE_COMMENT:
            return TokenKind.PARAGRAPH_COMMENT;
		default:
			if (isKeyword(kind))

Return to bug 242153

Lines 727-788 Link Here

(-)(, (<identifier> \| <template> \| '_'))* (-34 / +34 lines)
727	result.setIdentifier(identifierCS);	722	result.setIdentifier(identifierCS);
728	setOffsets(result, identifierCS, collectionTypeCS);	723	setOffsets(result, identifierCS, collectionTypeCS);
729	$setResult(result);	724	$setResult(result);
730	$EndJava	725	$EndCode
731	./	726	./
732	collectionTemplateCS_preMemberSelections -> collectionTemplateCS_1_ '{'	727	collectionTemplateCS_preMemberSelections -> collectionTemplateCS_1_ '{'
733	collectionTemplateCS_preMemberSelection -> collectionTemplateCS_preMemberSelections	728	collectionTemplateCS_preMemberSelection -> collectionTemplateCS_preMemberSelections
734	collectionTemplateCS_preMemberSelection -> collectionTemplateCS_postMemberSelection ','	729	collectionTemplateCS_preMemberSelection -> collectionTemplateCS_postMemberSelection ','
735	collectionTemplateCS_postMemberSelection ::= collectionTemplateCS_preMemberSelection memberSelectorCS	730	collectionTemplateCS_postMemberSelection ::= collectionTemplateCS_preMemberSelection memberSelectorCS
736	/.$BeginJava	731	/.$BeginCode
737	IdentifiedCS memberSelectorCS = (IdentifiedCS)$getSym(2);	732	IdentifiedCS memberSelectorCS = (IdentifiedCS)$getSym(2);
738	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);	733	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
739	result.getMemberIdentifier().add(memberSelectorCS);	734	result.getMemberIdentifier().add(memberSelectorCS);
740	setOffsets(result, result, memberSelectorCS);	735	setOffsets(result, result, memberSelectorCS);
741	$setResult(result);	736	$setResult(result);
742	$EndJava	737	$EndCode
743	./	738	./
744	collectionTemplateCS ::= collectionTemplateCS_postMemberSelection PLUS_PLUS identifierCS '}'	739	collectionTemplateCS ::= collectionTemplateCS_postMemberSelection PLUS_PLUS identifierCS '}'
745	/.$BeginJava	740	/.$BeginCode
746	IdentifierCS restIdentifier = (IdentifierCS)$getSym(3);	741	IdentifierCS restIdentifier = (IdentifierCS)$getSym(3);
747	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);	742	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
748	result.setRestIdentifier(restIdentifier);	743	result.setRestIdentifier(restIdentifier);
749	setOffsets(result, result, getIToken($getToken(4)));	744	setOffsets(result, result, getIToken($getToken(4)));
750	$setResult(result);	745	$setResult(result);
751	$EndJava	746	$EndCode
752	./	747	./
753	collectionTemplateCS ::= collectionTemplateCS_postMemberSelection ERROR_TOKEN '}'	748	collectionTemplateCS ::= collectionTemplateCS_postMemberSelection ERROR_TOKEN '}'
754	/.$BeginJava	749	/.$BeginCode
755	reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_REST);	750	reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_REST);
756	IdentifierCS restIdentifier = createUniqueIdentifierCS($getToken(2));	751	IdentifierCS restIdentifier = createUniqueIdentifierCS($getToken(2));
757	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);	752	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
758	result.setRestIdentifier(restIdentifier);	753	result.setRestIdentifier(restIdentifier);
759	setOffsets(result, result, getIToken($getToken(3)));	754	setOffsets(result, result, getIToken($getToken(3)));
760	$setResult(result);	755	$setResult(result);
761	$EndJava	756	$EndCode
762	./	757	./
763	collectionTemplateCS ::= collectionTemplateCS_preMemberSelections '}'	758	collectionTemplateCS ::= collectionTemplateCS_preMemberSelections '}'
764	/.$BeginJava	759	/.$BeginCode
765	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);	760	CollectionTemplateCS result = (CollectionTemplateCS)$getSym(1);
766	setOffsets(result, result, getIToken($getToken(2)));	761	setOffsets(result, result, getIToken($getToken(2)));
767	$setResult(result);	762	$setResult(result);
768	$EndJava	763	$EndCode
769	./	764	./
770		765
771	--<memberSelector> ::= (<identifier> \| <template> \| '_')	766	--<memberSelector> ::= (<identifier> \| <template> \| '_')
772	memberSelectorCS ::= identifierCS	767	memberSelectorCS ::= identifierCS
773	/.$BeginJava	768	/.$BeginCode
774	IdentifierCS identifierCS = (IdentifierCS)$getSym(1);	769	IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
775	IdentifiedCS result = QVTCSTFactory.eINSTANCE.createIdentifiedCS();	770	IdentifiedCS result = QVTCSTFactory.eINSTANCE.createIdentifiedCS();
776	result.setIdentifier(identifierCS);	771	result.setIdentifier(identifierCS);
777	setOffsets(result, identifierCS);	772	setOffsets(result, identifierCS);
778	$setResult(result);	773	$setResult(result);
779	$EndJava	774	$EndCode
780	./	775	./
781	memberSelectorCS -> templateCS	776	memberSelectorCS -> templateCS
782		777
783	--<assignmentExp> ::= <identifier> '=' <OclExpressionCS> ';'	778	--<assignmentExp> ::= <identifier> '=' <OclExpressionCS> ';'
784	defaultValueCS ::= identifierCS '=' oclExpressionCS ';'	779	defaultValueCS ::= identifierCS '=' oclExpressionCS ';'
785	/.$BeginJava	780	/.$BeginCode
786	IdentifierCS identifierCS = (IdentifierCS)$getSym(1);	781	IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
787	OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(3);	782	OCLExpressionCS oclExpressionCS = (OCLExpressionCS)$getSym(3);
788	DefaultValueCS result = QVTrCSTFactory.eINSTANCE.createDefaultValueCS();	783	DefaultValueCS result = QVTrCSTFactory.eINSTANCE.createDefaultValueCS();
Lines 790-796 Link Here
790	result.setInitialiser(oclExpressionCS);	785	result.setInitialiser(oclExpressionCS);
791	setOffsets(result, identifierCS, getIToken($getToken(4)));	786	setOffsets(result, identifierCS, getIToken($getToken(4)));
792	$setResult(result);	787	$setResult(result);
793	$EndJava	788	$EndCode
794	./	789	./
795		790
796	--<query> ::= 'query' <PathNameCS>	791	--<query> ::= 'query' <PathNameCS>
Lines 798-848 Link Here
798	-- ':' <TypeCS>	793	-- ':' <TypeCS>
799	-- (';' \| '{' <OclExpressionCS> '}')	794	-- (';' \| '{' <OclExpressionCS> '}')
800	queryCS_preParamDeclaration ::= query pathNameCS '('	795	queryCS_preParamDeclaration ::= query pathNameCS '('
801	/.$BeginJava	796	/.$BeginCode
802	QueryCS result = QVTrCSTFactory.eINSTANCE.createQueryCS();	797	QueryCS result = QVTrCSTFactory.eINSTANCE.createQueryCS();
803	result.setPathName((PathNameCS)$getSym(2));	798	result.setPathName((PathNameCS)$getSym(2));
804	setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));	799	setOffsets(result, getIToken($getToken(1)), getIToken($getToken(3)));
805	$setResult(result);	800	$setResult(result);
806	$EndJava	801	$EndCode
807	./	802	./
808	queryCS_preParamDeclaration -> queryCS_postParamDeclaration ','	803	queryCS_preParamDeclaration -> queryCS_postParamDeclaration ','
809	queryCS_postParamDeclaration ::= queryCS_preParamDeclaration paramDeclarationCS	804	queryCS_postParamDeclaration ::= queryCS_preParamDeclaration paramDeclarationCS
810	/.$BeginJava	805	/.$BeginCode
811	ParamDeclarationCS paramDeclarationCS = (ParamDeclarationCS)$getSym(2);	806	ParamDeclarationCS paramDeclarationCS = (ParamDeclarationCS)$getSym(2);
812	QueryCS result = (QueryCS)$getSym(1);	807	QueryCS result = (QueryCS)$getSym(1);
813	result.getInputParamDeclaration().add(paramDeclarationCS);	808	result.getInputParamDeclaration().add(paramDeclarationCS);
814	setOffsets(result, result, paramDeclarationCS);	809	setOffsets(result, result, paramDeclarationCS);
815	$setResult(result);	810	$setResult(result);
816	$EndJava	811	$EndCode
817	./	812	./
818	queryCS_postType ::= queryCS_postParamDeclaration ')' ':' typeCS	813	queryCS_postType ::= queryCS_postParamDeclaration ')' ':' typeCS
819	/.$BeginJava	814	/.$BeginCode
820	TypeCS typeCS = (TypeCS)$getSym(4);	815	TypeCS typeCS = (TypeCS)$getSym(4);
821	QueryCS result = (QueryCS)$getSym(1);	816	QueryCS result = (QueryCS)$getSym(1);
822	result.setType(typeCS);	817	result.setType(typeCS);
823	setOffsets(result, result, typeCS);	818	setOffsets(result, result, typeCS);
824	$setResult(result);	819	$setResult(result);
825	$EndJava	820	$EndCode
826	./	821	./
827	queryCS ::= queryCS_postType ';'	822	queryCS ::= queryCS_postType ';'
828	/.$BeginJava	823	/.$BeginCode
829	QueryCS result = (QueryCS)$getSym(1);	824	QueryCS result = (QueryCS)$getSym(1);
830	setOffsets(result, result, getIToken($getToken(3)));	825	setOffsets(result, result, getIToken($getToken(3)));
831	$setResult(result);	826	$setResult(result);
832	$EndJava	827	$EndCode
833	./	828	./
834	queryCS ::= queryCS_postType '{' oclExpressionCS '}'	829	queryCS ::= queryCS_postType '{' oclExpressionCS '}'
835	/.$BeginJava	830	/.$BeginCode
836	QueryCS result = (QueryCS)$getSym(1);	831	QueryCS result = (QueryCS)$getSym(1);
837	result.setOclExpression((OCLExpressionCS)$getSym(3));	832	result.setOclExpression((OCLExpressionCS)$getSym(3));
838	setOffsets(result, result, getIToken($getToken(4)));	833	setOffsets(result, result, getIToken($getToken(4)));
839	$setResult(result);	834	$setResult(result);
840	$EndJava	835	$EndCode
841	./	836	./
842		837
843	--<paramDeclaration> ::= <identifier> ':' <TypeCS>	838	--<paramDeclaration> ::= <identifier> ':' <TypeCS>
844	paramDeclarationCS ::= identifierCS ':' typeCS	839	paramDeclarationCS ::= identifierCS ':' typeCS
845	/.$BeginJava	840	/.$BeginCode
846	IdentifierCS identifierCS = (IdentifierCS)$getSym(1);	841	IdentifierCS identifierCS = (IdentifierCS)$getSym(1);
847	TypeCS typeCS = (TypeCS)$getSym(3);	842	TypeCS typeCS = (TypeCS)$getSym(3);
848	ParamDeclarationCS result = QVTrCSTFactory.eINSTANCE.createParamDeclarationCS();	843	ParamDeclarationCS result = QVTrCSTFactory.eINSTANCE.createParamDeclarationCS();
Lines 850-861 Link Here
850	result.setType(typeCS);	845	result.setType(typeCS);
851	setOffsets(result, identifierCS, typeCS);	846	setOffsets(result, identifierCS, typeCS);
852	$setResult(result);	847	$setResult(result);
853	$EndJava	848	$EndCode
854	./	849	./
855	paramDeclarationCS ::= identifierCS ERROR_TOKEN	850	paramDeclarationCS ::= identifierCS ERROR_TOKEN
856	/.$BeginJava	851	/.$BeginCode
857	reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_PARAM_DECLARATION);	852	reportErrorTokenMessage($getToken(2), QVTrParserErrors.INCOMPLETE_PARAM_DECLARATION);
858	$EndJava	853	$EndCode
859	./	854	./
860		855
861	--<OclExpressionCS> ::= <PropertyCallExpCS>	856	--<OclExpressionCS> ::= <PropertyCallExpCS>
Lines 892-914 Link Here
892	relationIdentifier -> pre	887	relationIdentifier -> pre
893		888
894	pathNameCS ::= relationIdentifier	889	pathNameCS ::= relationIdentifier
895	/.$BeginJava	890	/.$BeginCode
896	PathNameCS result = createPathNameCS();	891	PathNameCS result = createPathNameCS();
897	result.getSequenceOfNames().add(getTokenText($getToken(1)));	892	result.getSequenceOfNames().add(getTokenText($getToken(1)));
898	setOffsets(result, getIToken($getToken(1)));	893	setOffsets(result, getIToken($getToken(1)));
899	$setResult(result);	894	$setResult(result);
900	$EndJava	895	$EndCode
901	./	896	./
902		897
903	simpleNameCS ::= relationIdentifier	898	simpleNameCS ::= relationIdentifier
904	/.$BeginJava	899	/.$BeginCode
905	SimpleNameCS result = createSimpleNameCS(	900	SimpleNameCS result = createSimpleNameCS(
906	SimpleTypeEnum.IDENTIFIER_LITERAL,	901	SimpleTypeEnum.IDENTIFIER_LITERAL,
907	getTokenText($getToken(1))	902	getTokenText($getToken(1))
908	);	903	);
909	setOffsets(result, getIToken($getToken(1)));	904	setOffsets(result, getIToken($getToken(1)));
910	$setResult(result);	905	$setResult(result);
911	$EndJava	906	$EndCode
912	./	907	./
913		908
914	identifierCS ::= IDENTIFIER	909	identifierCS ::= IDENTIFIER
Lines 916-925 Link Here
916	identifierCS ::= relationIdentifier	911	identifierCS ::= relationIdentifier
917	/.$NewCase ./	912	/.$NewCase ./
918	identifierCS ::= self	913	identifierCS ::= self
919	/.$BeginJava	914	/.$BeginCode
920	IdentifierCS result = createIdentifierCS($getToken(1));	915	IdentifierCS result = createIdentifierCS($getToken(1));
921	$setResult(result);	916	$setResult(result);
922	$EndJava	917	$EndCode
923	./	918	./
924	$End	919	%End
925		920

Added Link Here

(-)src/org/eclipse/qvt/declarative/parser/qvtrelation/QVTrLexer.gi (+58 lines)
1	--/**
2	-- * <copyright>
3	-- *
4	-- * Copyright (c) 2007,2008 E.D.Willink and others.
5	-- * All rights reserved. This program and the accompanying materials
6	-- * are made available under the terms of the Eclipse Public License v1.0
7	-- * which accompanies this distribution, and is available at
8	-- * http://www.eclipse.org/legal/epl-v10.html
9	-- *
10	-- * Contributors:
11	-- * E.D.Willink - Initial API and implementation
12	-- *
13	-- * </copyright>
14	-- */
15	--
16	-- The QVTr Lexer
17	--
18
19	%options escape=$
20	%options la=2
21	%options fp=QVTrLexer,prefix=Char_
22	%options single-productions
23	%options noserialize
24	%options package=org.eclipse.qvt.declarative.parser.qvtrelation
25	%options template=../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg/LexerTemplateF.gi
26	%options filter=QVTrKWLexer.gi
27	%options export_terminals=("QVTrParsersym.java", "TK_")
28	%options include_directory=".;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/lpg;../../../../../../../../org.eclipse.ocl/src/org/eclipse/ocl/parser"
29
30	%Import
31	OCLLexer.gi
32	%End
33
34	%Define
35	--
36	-- Definition of macro used in the included file LexerBasicMap.g
37	--
38	$kw_lexer_class /.QVTrKWLexer./
39	$environment_class /.ICSTFileEnvironment./
40	$environment_import /.org.eclipse.qvt.declarative.parser.environment.ICSTFileEnvironment./
41	$copyright_contributions /.* E.D.Willink - Extended API and implementation for QVTr
42	*./
43	%End
44
45	%Export
46	PLUS_PLUS
47	%End
48
49	%Rules
50
51	Token ::= '+' '+'
52	/.$BeginAction
53	makeToken($_PLUS_PLUS);
54	$EndAction
55	./
56
57	SLC -> '/' '/'
58	%End

Lines 20-29 Link Here

(-)src/org/eclipse/qvt/declarative/editor/ui/imp/CommonFoldingUpdater.java (-8 / +8 lines)
20	import java.util.HashMap;	20	import java.util.HashMap;
21	import java.util.List;	21	import java.util.List;
22		22
23	import lpg.lpgjavaruntime.Adjunct;	23	import lpg.runtime.Adjunct;
24	import lpg.lpgjavaruntime.IToken;	24	import lpg.runtime.ILexStream;
25	import lpg.lpgjavaruntime.LexStream;	25	import lpg.runtime.IPrsStream;
26	import lpg.lpgjavaruntime.PrsStream;	26	import lpg.runtime.IToken;
27		27
28	import org.eclipse.imp.services.base.FolderBase;	28	import org.eclipse.imp.services.base.FolderBase;
29	import org.eclipse.jface.text.Position;	29	import org.eclipse.jface.text.Position;
Lines 62-73 Link Here
62	}	62	}
63	};	63	};
64		64
65	protected PrsStream prsStream = null;	65	protected IPrsStream prsStream = null;
66		66
67	protected abstract ICommonPlugin getPlugin();	67	protected abstract ICommonPlugin getPlugin();
68		68
69	protected void makeAdjunctAnnotations(CSTNode theAST) {	69	protected void makeAdjunctAnnotations(CSTNode theAST) {
70	LexStream lexStream = prsStream.getLexStream();	70	ILexStream lexStream = prsStream.getILexStream();
71	if (lexStream == null)	71	if (lexStream == null)
72	return;	72	return;
73	@SuppressWarnings("unchecked")	73	@SuppressWarnings("unchecked")
Lines 106-112 Link Here
106	IToken gate_token = adjuncts.length == 0 ? next_token : adjuncts[0];	106	IToken gate_token = adjuncts.length == 0 ? next_token : adjuncts[0];
107	makeAnnotationWithOffsets(first_token.getStartOffset(), gate_token	107	makeAnnotationWithOffsets(first_token.getStartOffset(), gate_token
108	.getLine() > last_token.getEndLine() ? prsStream	108	.getLine() > last_token.getEndLine() ? prsStream
109	.getLexStream().getLineOffset(gate_token.getLine() - 1)	109	.getILexStream().getLineOffset(gate_token.getLine() - 1)
110	: last_token.getEndOffset());	110	: last_token.getEndOffset());
111	}	111	}
112	}	112	}
Lines 127-133 Link Here
127	if (theCST != null) {	127	if (theCST != null) {
128	IToken startToken = theCST.getStartToken();	128	IToken startToken = theCST.getStartToken();
129	if (startToken != null) {	129	if (startToken != null) {
130	prsStream = startToken.getPrsStream();	130	prsStream = startToken.getIPrsStream();
131	FoldingCSTVisitor visitor = new FoldingCSTVisitor(getPlugin().getEditorDefinition());	131	FoldingCSTVisitor visitor = new FoldingCSTVisitor(getPlugin().getEditorDefinition());
132	visitor.enter(theCST);	132	visitor.enter(theCST);
133	makeAdjunctAnnotations(theCST);	133	makeAdjunctAnnotations(theCST);

Lines 20-26 Link Here

(-)src/org/eclipse/qvt/declarative/editor/qvtrelation/ui/imp/QVTrParseController.java (-8 / +8 lines)
20	import org.eclipse.qvt.declarative.editor.qvtrelation.ui.QVTrCreationFactory;	20	import org.eclipse.qvt.declarative.editor.qvtrelation.ui.QVTrCreationFactory;
21	import org.eclipse.qvt.declarative.editor.ui.imp.CommonParseController;	21	import org.eclipse.qvt.declarative.editor.ui.imp.CommonParseController;
22	import org.eclipse.qvt.declarative.editor.ui.imp.ICommonKeyword;	22	import org.eclipse.qvt.declarative.editor.ui.imp.ICommonKeyword;
23	import org.eclipse.qvt.declarative.parser.qvtrelation.QVTrLexer;	23	import org.eclipse.qvt.declarative.parser.qvtrelation.QVTrParsersym;
24	import org.eclipse.qvt.declarative.parser.qvtrelation.cst.QVTrCSTPackage;	24	import org.eclipse.qvt.declarative.parser.qvtrelation.cst.QVTrCSTPackage;
25		25
26	public class QVTrParseController extends CommonParseController	26	public class QVTrParseController extends CommonParseController
Lines 38-56 Link Here
38		38
39	public TokenKind getTokenKind(int kind) {	39	public TokenKind getTokenKind(int kind) {
40	switch (kind) {	40	switch (kind) {
41	case QVTrLexer.TK_EOF_TOKEN:	41	case QVTrParsersym.TK_EOF_TOKEN:
42	return TokenKind.EOF;	42	return TokenKind.EOF;
43	case QVTrLexer.TK_IDENTIFIER:	43	case QVTrParsersym.TK_IDENTIFIER:
44	return TokenKind.IDENTIFIER;	44	return TokenKind.IDENTIFIER;
45	case QVTrLexer.TK_INTEGER_LITERAL:	45	case QVTrParsersym.TK_INTEGER_LITERAL:
46	return TokenKind.INTEGER;	46	return TokenKind.INTEGER;
47	case QVTrLexer.TK_REAL_LITERAL:	47	case QVTrParsersym.TK_REAL_LITERAL:
48	return TokenKind.REAL;	48	return TokenKind.REAL;
49	case QVTrLexer.TK_STRING_LITERAL:	49	case QVTrParsersym.TK_STRING_LITERAL:
50	return TokenKind.STRING;	50	return TokenKind.STRING;
51	case QVTrLexer.TK_SINGLE_LINE_COMMENT:	51	case QVTrParsersym.TK_SINGLE_LINE_COMMENT:
52	return TokenKind.LINE_COMMENT;	52	return TokenKind.LINE_COMMENT;
53	case QVTrLexer.TK_MULTI_LINE_COMMENT:	53	case QVTrParsersym.TK_MULTI_LINE_COMMENT:
54	return TokenKind.PARAGRAPH_COMMENT;	54	return TokenKind.PARAGRAPH_COMMENT;
55	default:	55	default:
56	if (isKeyword(kind))	56	if (isKeyword(kind))