--/**
-- * <copyright>
-- *
-- * Copyright (c) 2006-2008 Borland Inc.
-- * All rights reserved.   This program and the accompanying materials
-- * are made available under the terms of the Eclipse Public License v2.0
-- * which accompanies this distribution, and is available at
-- * http://www.eclipse.org/legal/epl-v20.html
-- *
-- * Contributors:
-- *   See Notice Declaration below
-- *
-- * </copyright>
-- *
-- * $Id: QVTOParser.gi,v 1.9 2010/02/03 18:18:51 sboyko Exp $ 
-- */
--
-- The QVTo Parser
--

%options escape=$
%options la=2
%options fp=QVTOParser,prefix=TK_
%options noserialize
%options import_terminals=QVTOLexer.gi
%options ast_type=CSTNode
%options template=btParserTemplateF.gi
%options include_directory=".;../lpg"


%Import
	ImperativeOCL.gi
%End

%Globals
	/.	
	import org.eclipse.m2m.internal.qvt.oml.cst.CompleteSignatureCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.DictLiteralPartCS;	
	import org.eclipse.m2m.internal.qvt.oml.cst.DirectionKindCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.DirectionKindEnum;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingBodyCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingDeclarationCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingEndCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingInitCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingExtensionCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingModuleCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingRuleCS;	
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingQueryCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ConstructorCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MappingSectionsCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ModuleUsageCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ObjectExpCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ModelTypeCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.SimpleSignatureCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ResolveOpArgsExpCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ModuleKindEnum;
	import org.eclipse.m2m.internal.qvt.oml.cst.ModuleKindCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ModuleRefCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.ImportKindEnum;
	import org.eclipse.m2m.internal.qvt.oml.cst.ParameterDeclarationCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.TransformationRefineCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.TransformationHeaderCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.TypeSpecCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.MultiplicityDefCS;
	import org.eclipse.m2m.internal.qvt.oml.cst.OppositePropertyCS;
	import org.eclipse.ocl.cst.PrimitiveLiteralExpCS;
	import org.eclipse.ocl.cst.LiteralExpCS;	
	import org.eclipse.ocl.cst.DotOrArrowEnum;
	import org.eclipse.ocl.util.OCLStandardLibraryUtil;
	import org.eclipse.ocl.utilities.PredefinedType;
	import org.eclipse.ocl.Environment;
	./
%End

%Notice
	/./**
 * <copyright>
 *
 * Copyright (c) 2006, 2007 Borland Inc.
 * All rights reserved.   This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *   Borland - Initial API and implementation
 *   Adolfo Sanchez-Barbudo Herrera (Open Canarias) - LPG v 2.0.17 adoption (297966)
 *
 * </copyright>
 *
 */
	./
%End

%KeyWords
	init
	static
	end
	out
	object
	transformation
	import
	library
	metamodel
	mapping
	query
	helper
	inout
	when
	configuration
	intermediate
	property
	opposites
	class
	population
	map
	xmap
	late
	resolve
	resolveone
	resolveIn
	resolveoneIn
	invresolve
	invresolveone
	invresolveIn
	invresolveoneIn
	modeltype
	uses
	where
	refines
	access
	extends
	blackbox
	abstract
	result
	main
	this
	rename
	disjuncts
	merges
	inherits
	composes
	constructor
	datatype
	default
	derived
	do
	elif
	enum
	except
	exception
	from
	literal
	ordered
	primitive
	raise
	readonly
	references
	tag
	try
	typedef
	unlimited

%End

%Terminals
	STEREOTYPE_QUALIFIER_OPEN  ::= '<<'
	STEREOTYPE_QUALIFIER_CLOSE ::= '>>'
	MULTIPLICITY_RANGE         ::= '...'
	TILDE_SIGN                 ::= '~'
	NOT_EQUAL_EXEQ             ::= '!='
	AT_SIGN                    ::= '@'

%End

%Start
	topLevel
%End

%Rules
	-- opt = optional
	-- m = multiple
	
	--=== // start rule (start) ===--
	-- to support legacy usage of imports after transformation header
	topLevel ::= unit_elementList
		/.$BeginCode
					EList<CSTNode> unitElements = (EList<CSTNode>)getRhsSym(1);
					setResult(setupTopLevel(unitElements));
		  $EndCode
		./

	unit_element -> _import

	_import ::= import unit ';'
		/.$BeginCode
					CSTNode result = createImportCS(
							(PathNameCS)getRhsSym(2)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(3));
					setResult(result);
		  $EndCode
		./

	importDeclaration -> qvtErrorToken

	_import ::= import importDeclaration
		/.$BeginCode
					CSTNode result = createLibraryImportCS(
							createPathNameCS()
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					setResult(result);
		  $EndCode
		./

	unit -> qualifiedNameCS
	--=== // start rule (end) ===--

	--=== // definitions in a compilation unit (start) ===--
	unit_elementList ::= unit_elementList unit_element
		/.$BeginCode
					EList list = (EList)getRhsSym(1);
					list.add(getRhsSym(2));
					setResult(list);
		  $EndCode
		./

	unit_elementList ::= %empty
		/.$EmptyListAction./

	unit_element -> _transformation
	unit_element -> _library
	unit_element -> _modeltype
	unit_element -> classifier
	unit_element -> _property
	unit_element -> _helper
	unit_element -> _constructor
	unit_element -> entry
	unit_element -> _mapping
	unit_element -> _tag ';'
	unit_element ::= qvtErrorToken
		/.$NullAction./
	--=== // definitions in a compilation unit (end) ===--

	--=== // Transformation and library definitions (start) ===--
	_transformation -> transformation_decl
	_transformation -> transformation_def 
	
	transformation_decl ::= transformation_h ';' 
		/.$BeginCode
					TransformationHeaderCS headerCS = (TransformationHeaderCS) getRhsSym(1);
					setOffsets(headerCS, headerCS, getRhsIToken(2));
					MappingModuleCS moduleCS = createMappingModuleCS(headerCS, $EMPTY_ELIST);
					setOffsets(moduleCS, headerCS);
					setResult(moduleCS);
		  $EndCode
		./

	transformation_def ::= transformation_h '{' module_elementList '}' semicolonOpt
		/.$BeginCode
					TransformationHeaderCS headerCS = (TransformationHeaderCS) getRhsSym(1);
					MappingModuleCS moduleCS = createMappingModuleCS(headerCS, (EList) getRhsSym(3));
					setOffsets(moduleCS, headerCS, getRhsIToken(4));
					setResult(moduleCS);
		  $EndCode
		./
	 
	_library -> library_decl
	_library -> library_def

	library_decl ::= library_h ';'
		/.$BeginCode
					TransformationHeaderCS headerCS = (TransformationHeaderCS) getRhsSym(1);
					setOffsets(headerCS, headerCS, getRhsIToken(2));
					MappingModuleCS moduleCS = createLibraryCS(headerCS, $EMPTY_ELIST);
					setOffsets(moduleCS, headerCS);
					setResult(moduleCS);
		  $EndCode
		./

	library_def ::= library_h '{' module_elementList '}' semicolonOpt
		/.$BeginCode
					TransformationHeaderCS headerCS = (TransformationHeaderCS) getRhsSym(1);
					MappingModuleCS moduleCS = createLibraryCS(headerCS, (EList) getRhsSym(3));
					setOffsets(moduleCS, headerCS, getRhsIToken(4));
					setResult(moduleCS);
		  $EndCode
		./
	--=== // Transformation and library definitions (end) ===--


	--=== // Transformation header (start) ===--
	transformation_h ::= qualifierList transformation qualifiedNameCS transformation_signature transformation_usage_refineOpt
		/.$BeginCode
					EList qualifierList = (EList) getRhsSym(1);
					EList transfUsages = $EMPTY_ELIST;
					TransformationRefineCS transfRefine = null;
					Object transformation_usage_refineOpt = getRhsSym(5);
					if (transformation_usage_refineOpt instanceof TransformationRefineCS) {
						transfRefine = (TransformationRefineCS) transformation_usage_refineOpt;
					} else if (transformation_usage_refineOpt instanceof EList) {
						transfUsages = (EList) transformation_usage_refineOpt;
					}
					CSTNode result = createTransformationHeaderCS(
							qualifierList,
							(PathNameCS)getRhsSym(3),
							(SimpleSignatureCS)getRhsSym(4),
							transfUsages,
							transfRefine
						);
					if (qualifierList.isEmpty()) {
						setOffsets(result, getRhsIToken(2));
					} else {
						setOffsets(result, (CSTNode) qualifierList.get(0));
					}
					if (transfRefine == null) {
						if (transfUsages.isEmpty()) {
							setOffsets(result, result, (SimpleSignatureCS)getRhsSym(4));
						}
						else {
							setOffsets(result, result, (CSTNode) transfUsages.get(transfUsages.size()-1));
						}
					} else {
						setOffsets(result, result, transfRefine);
					}
					setResult(result);
		  $EndCode
		./


	transformation_usage_refineOpt ::= %empty
		/.$NullAction./
	transformation_usage_refineOpt -> transformation_usage_refine

	transformation_usage_refine -> module_usageList
	transformation_usage_refine -> transformation_refine

	transformation_signature -> simple_signature

	transformation_refine ::= refines moduleref
		/.$BeginCode
					CSTNode result = createTransformationRefineCS(
							(ModuleRefCS)getRhsSym(2)
						);
					setOffsets(result, (ModuleRefCS)getRhsSym(2));
					setResult(result);
		  $EndCode
		./
	--=== // Transformation header (end) ===--


	--=== // Library header (start) ===--
	library_h ::= library qualifiedNameCS library_signatureOpt module_usageListOpt
		/.$BeginCode
					PathNameCS name = (PathNameCS)getRhsSym(2);
					SimpleSignatureCS signature = (getRhsSym(3) == null) ? createSimpleSignatureCS($EMPTY_ELIST) : (SimpleSignatureCS)getRhsSym(3);
					EList<ModuleUsageCS> moduleUsages = (EList<ModuleUsageCS>)getRhsSym(4);
					CSTNode result = createTransformationHeaderCS(
							$EMPTY_ELIST,
							name,
							signature,
							moduleUsages,
							null
						);
					CSTNode rightNode = name;
					if (!moduleUsages.isEmpty()) {
						rightNode = moduleUsages.get(moduleUsages.size() - 1);
					} else if (getRhsSym(3) != null) {
						rightNode = signature;
					}
					setOffsets(result, getRhsIToken(1), rightNode);
					setResult(result);
		  $EndCode
		./

	libraryDeclaration -> qvtErrorToken

	library_h ::= library libraryDeclaration
		/.$BeginCode
					CSTNode result = createTransformationHeaderCS(
							$EMPTY_ELIST,
							createPathNameCS(),
							createSimpleSignatureCS($EMPTY_ELIST),
							$EMPTY_ELIST,
							null
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					setResult(result);
		  $EndCode
		./

	library_signatureOpt ::= %empty
		/.$NullAction./
	library_signatureOpt -> library_signature

	library_signature -> simple_signature
	--=== // Library header (end) ===--
	
	--=== // import of transformation and library (start) ===--
	module_usageList ::= module_usage
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	module_usageList ::= module_usageList module_usage
		/.$BeginCode
					EList result = (EList) getRhsSym(1);
					result.add(getRhsSym(2));
					setResult(result);
		  $EndCode
		./

	module_usageListOpt ::= %empty
		/.$EmptyListAction./
	module_usageListOpt -> module_usageList

	module_usage -> access_usage
	module_usage -> extends_usage
	
	access_usage ::= access module_kindOpt moduleref_list
		/.$BeginCode
					EList moduleRefList = (EList)getRhsSym(3);
					CSTNode result = createModuleUsageCS(
							ImportKindEnum.ACCESS,
							(ModuleKindCS)getRhsSym(2),
							moduleRefList
						);
					setOffsets(result, getRhsIToken(1), (CSTNode)moduleRefList.get(moduleRefList.size()-1));
					setResult(result);
		  $EndCode
		./
	extends_usage ::= extends module_kindOpt moduleref_list
		/.$BeginCode
					EList moduleRefList = (EList)getRhsSym(3);
					CSTNode result = createModuleUsageCS(
							ImportKindEnum.EXTENSION,
							(ModuleKindCS)getRhsSym(2),
							moduleRefList
						);
					setOffsets(result, getRhsIToken(1), (CSTNode)moduleRefList.get(moduleRefList.size()-1));
					setResult(result);
		  $EndCode
		./
	
	module_kindOpt ::= %empty
		/.$NullAction./
	module_kindOpt -> module_kind
	
	module_kind ::= transformation
		/.$BeginCode
					CSTNode result = createModuleKindCS(
							ModuleKindEnum.TRANSFORMATION
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	module_kind ::= library
		/.$BeginCode
					CSTNode result = createModuleKindCS(
							ModuleKindEnum.LIBRARY
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	
	moduleref_list ::= moduleref
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	moduleref_list ::= moduleref_list ',' moduleref
		/.$BeginCode
					EList result = (EList) getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
	moduleref_list ::= moduleref_list qvtErrorToken
		/.$BeginCode
					EList result = (EList) getRhsSym(1);
					setResult(result);
		  $EndCode
		./
	
	moduleref ::= pathNameCS simple_signatureOpt
		/.$BeginCode
					SimpleSignatureCS signature = (SimpleSignatureCS)getRhsSym(2);
					CSTNode result = createModuleRefCS(
							(PathNameCS)getRhsSym(1),
							signature 
						);
					CSTNode rightNode = (signature == null) ? (CSTNode)getRhsSym(1) : signature;
					setOffsets(result, (CSTNode)getRhsSym(1), rightNode);
					setResult(result);
		  $EndCode
		./
	--=== // import of transformation and library (end) ===--
	
	--=== // module definitions (start) ===--
	module_elementList ::= module_elementList module_element
		/.$BeginCode
					EList list = (EList)getRhsSym(1);
					list.add(getRhsSym(2));
					setResult(list);
		  $EndCode
		./

	module_elementList ::= %empty
		/.$EmptyListAction./

	module_element -> classifier
	module_element -> _property
	module_element -> _helper
	module_element -> _constructor
	module_element -> entry
	module_element -> _mapping
	module_element -> _tag ';'
	module_element ::= qvtErrorToken
		/.$NullAction./
	--=== // module definitions (end) ===--
	
	--=== // model types compliance and metamodel declarations (start) ===--
	_modeltype ::= modeltype IDENTIFIER compliance_kindOpt uses packageref_list modeltype_whereOpt ';'
		/.$BeginCode
					EList whereList = (EList)getRhsSym(6);
					EList packageRefList = (EList)getRhsSym(5);
					ModelTypeCS result = createModelTypeCS(
							getRhsIToken(2),
							(StringLiteralExpCS)getRhsSym(3),
							packageRefList,
							whereList
						);
					if (whereList.isEmpty()) {
						setOffsets(result, getRhsIToken(1), getRhsIToken(7));
					}
					else {
						CSTNode lastPackageRefCS = (CSTNode)packageRefList.get(packageRefList.size()-1);
						setOffsets(result, getRhsIToken(1), lastPackageRefCS);
						setBodyOffsets(result, lastPackageRefCS, getRhsIToken(7));
					}
					setResult(result);
		  $EndCode
		./

	modeltypeDeclaration -> qvtErrorToken

	_modeltype ::= modeltype modeltypeDeclaration
		/.$BeginCode
					ModelTypeCS result = createModelTypeCS(
							new Token(0, 0, 0),
							null,
							$EMPTY_ELIST,
							$EMPTY_ELIST
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
		
	modeltype_whereOpt ::= %empty
		/.$EmptyListAction./
	modeltype_whereOpt -> modeltype_where

	modeltype_where ::= where expression_block
		/.$BeginCode
					BlockExpCS blockExpCS = (BlockExpCS) getRhsSym(2);
					setResult(blockExpCS.getBodyExpressions());
		  $EndCode
		./

	packageref_list ::= packageref
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	packageref_list ::= packageref_list ',' packageref
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
	packageref_list ::= packageref_list qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./

	packageref ::= pathNameCS
		/.$BeginCode
					CSTNode result = createPackageRefCS(
							(PathNameCS)getRhsSym(1),
							null
						);
					setOffsets(result, (CSTNode)getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	packageref ::= pathNameCS '(' uri ')'
		/.$BeginCode
					CSTNode result = createPackageRefCS(
							(PathNameCS)getRhsSym(1),
							(StringLiteralExpCS)getRhsSym(3)
						);
					setOffsets(result, (CSTNode)getRhsSym(1), getRhsIToken(4));
					setResult(result);
		  $EndCode
		./
	packageref ::= uri
		/.$BeginCode
					CSTNode result = createPackageRefCS(
							null,
							(StringLiteralExpCS)getRhsSym(1)
						);
					setOffsets(result, (CSTNode)getRhsSym(1));
					setResult(result);
		  $EndCode
		./

	compliance_kindOpt ::= %empty
		/.$NullAction./
	compliance_kindOpt -> StringLiteralExpCS
	--=== // model types compliance and metamodel declarations (end) ===--

	--=== // like: "strict" and "effective" (start) ===--
	uri -> StringLiteralExpCS
	--=== // like: "strict" and "effective" (end) ===--

	--=== // Syntax for defining explicitly metamodel contents (start) ===--
	classifier ->  classifierDefCS

	classifierDefCS ::= intermediate class qvtIdentifierCS classifierExtensionOpt '{' classifierFeatureListOpt '}' semicolonOpt 
		/.$BeginCode
					CSTNode result = createClassifierDefCS(
							getRhsIToken(3),
							(EList) getRhsSym(4),
							(EList) getRhsSym(6)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(7));
					setResult(result);
		  $EndCode
		./

	classifierExtensionOpt ::= %empty
		/.$EmptyListAction./
	classifierExtensionOpt ::= extends type_list
		/.$BeginCode
					EList result = (EList)getRhsSym(2);
					setResult(result);
		  $EndCode
		./	
	type_list ::= typeCS
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	type_list ::= type_list ',' typeCS
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
	type_list ::= type_list qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./
	
	classifierFeatureListOpt ::= %empty
		/.$EmptyListAction./
	classifierFeatureListOpt -> classifierFeatureList semicolonOpt
	
	classifierFeatureList ::= classifierFeatureCS
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	classifierFeatureList ::= classifierFeatureList ';' classifierFeatureCS
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
	classifierFeatureList ::= classifierFeatureList qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./

	classifierFeatureCS ::= stereotype_qualifier_list feature_key_list qvtIdentifierCS ':' typeCS multiplicityOpt ordered_prop opposite_propertyOpt init_partOpt
		/.$BeginCode
					EList stereotypeQualifiers = (EList) getRhsSym(1);
					EList featureKeys = (EList) getRhsSym(2);
					MultiplicityDefCS multiplicityDef = (MultiplicityDefCS) getRhsSym(6);
					OppositePropertyCS oppositeProperty = (OppositePropertyCS) getRhsSym(8);
					OCLExpressionCS initExpression = (OCLExpressionCS) getRhsSym(9);
					CSTNode result = createClassifierPropertyCS(
							stereotypeQualifiers,
							featureKeys,
							getRhsIToken(3),
							(TypeCS) getRhsSym(5),
							((BooleanLiteralExpCS) getRhsSym(7)).getBooleanSymbol().booleanValue(),
							initExpression,
							multiplicityDef,
							oppositeProperty
						);
					
					int startOffset = getRhsIToken(3).getStartOffset();
					if (!featureKeys.isEmpty()) {
						startOffset = ((CSTNode) featureKeys.get(0)).getStartOffset();
					}
					if (!stereotypeQualifiers.isEmpty()) {
						startOffset = ((IToken) stereotypeQualifiers.get(0)).getStartOffset();
					}
					
					CSTNode lastToken = (CSTNode) getRhsSym(5);
					if (initExpression != null) {
						lastToken = initExpression;
					}
					if (multiplicityDef != null) {
						lastToken = multiplicityDef;
					}
					if (oppositeProperty != null) {
						lastToken = oppositeProperty;
					}
					
					setOffsets(result, lastToken);
					result.setStartOffset(startOffset);
					setResult(result);
		  $EndCode
		./
	classifierFeatureCS -> _tag

	init_partOpt ::= %empty
		/.$NullAction./
	init_partOpt ::= '=' OclExpressionCS
		/.$BeginCode
					CSTNode result = (CSTNode) getRhsSym(2);
					setResult(result);
		  $EndCode
		./

	stereotype_qualifier_list ::= %empty
		/.$EmptyListAction./
	stereotype_qualifier_list ::= STEREOTYPE_QUALIFIER_OPEN identifier_list STEREOTYPE_QUALIFIER_CLOSE
		/.$BeginCode
					EList result = (EList)getRhsSym(2);
					setResult(result);
		  $EndCode
		./

	identifier_list ::= qvtIdentifierCS
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	identifier_list ::= identifier_list ',' qvtIdentifierCS
		/.$BeginCode
					EList result = (EList) getRhsSym(1);
					result.add(getRhsIToken(3));
					setResult(result);
		  $EndCode
		./
	identifier_list ::= identifier_list qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./

	feature_key_list ::= %empty
		/.$EmptyListAction./
	feature_key_list ::= feature_key_list feature_key
		/.$BeginCode
					EList result = (EList) getRhsSym(1);
					result.add(getRhsSym(2));
					setResult(result);
		  $EndCode
		./
	feature_key_list ::= feature_key_list qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./
		
	feature_key ::= composes
		/.$NewCase./
	feature_key ::= references
		/.$NewCase./
	feature_key ::= readonly
		/.$NewCase./
	feature_key ::= derived
		/.$NewCase./
	feature_key ::= static
		/.$BeginCode
					CSTNode result = createSimpleNameCS(SimpleTypeEnum.KEYWORD_LITERAL, getRhsIToken(1));
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
		
	multiplicityOpt ::= %empty
		/.$NullAction./
	multiplicityOpt ::= LBRACKET multiplicity_range RBRACKET
		/.$BeginCode
					CSTNode result = (CSTNode) getRhsSym(2);
					setResult(result);
		  $EndCode
		./
		
	multiplicity_range ::= IntegerLiteralExpCS
		/.$BeginCode
					CSTNode result = createMultiplicityDefCS(
							(PrimitiveLiteralExpCS) getRhsSym(1),
							(PrimitiveLiteralExpCS) getRhsSym(1)
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	multiplicity_range ::= UnlimitedNaturalLiteralExpCS
		/.$BeginCode
					PrimitiveLiteralExpCS lowerBound = createIntegerLiteralExpCS(Integer.toString(0));
					setOffsets(lowerBound, getRhsIToken(1));
					CSTNode result = createMultiplicityDefCS(
							lowerBound, 
							(PrimitiveLiteralExpCS) getRhsSym(1)
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	multiplicity_range ::= IntegerLiteralExpCS MULTIPLICITY_RANGE IntegerLiteralExpCS
		/.$NewCase./
	multiplicity_range ::= IntegerLiteralExpCS DOTDOT IntegerLiteralExpCS
		/.$NewCase./
	multiplicity_range ::= IntegerLiteralExpCS MULTIPLICITY_RANGE UnlimitedNaturalLiteralExpCS
		/.$NewCase./
	multiplicity_range ::= IntegerLiteralExpCS DOTDOT UnlimitedNaturalLiteralExpCS
		/.$BeginCode
					CSTNode result = createMultiplicityDefCS(
							(PrimitiveLiteralExpCS) getRhsSym(1),
							(PrimitiveLiteralExpCS) getRhsSym(3)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(3));
					setResult(result);
		  $EndCode
		./

	ordered_prop ::= ordered
		/.$BeginCode
					CSTNode result = createBooleanLiteralExpCS(Boolean.TRUE.toString());
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	ordered_prop ::= %empty
		/.$BeginCode
					CSTNode result = createBooleanLiteralExpCS(Boolean.FALSE.toString());
					setResult(result);
		  $EndCode
		./
		
	opposite_propertyOpt ::= %empty
		/.$NullAction./
	opposite_propertyOpt ::= opposites navigable_prop qvtIdentifierCS multiplicityOpt
		/.$BeginCode
					MultiplicityDefCS multiplicityDef = (MultiplicityDefCS) getRhsSym(4);
					CSTNode result = createOppositePropertyCS(
							getRhsIToken(3),
							((BooleanLiteralExpCS) getRhsSym(2)).getBooleanSymbol().booleanValue(),
							multiplicityDef
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(3));
					if (multiplicityDef != null) {
						result.setEndOffset(multiplicityDef.getEndOffset());
					}
					setResult(result);
		  $EndCode
		./

	navigable_prop ::= '~'
		/.$BeginCode
					CSTNode result = createBooleanLiteralExpCS(Boolean.FALSE.toString());
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	navigable_prop ::= %empty
		/.$BeginCode
					CSTNode result = createBooleanLiteralExpCS(Boolean.TRUE.toString());
					setResult(result);
		  $EndCode
		./
	--=== // Syntax for defining explicitly metamodel contents (end) ===--
		
	--=== // Properties in transformation (start) ===--
	_property ::= configuration property qvtIdentifierCS ':' typeCS ';' 
		/.$BeginCode
					CSTNode result = createConfigPropertyCS(
							getRhsIToken(3),
							(TypeCS)getRhsSym(5)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(6));
					setResult(result);
		  $EndCode
		./
	_property ::= configuration property qvtIdentifierCS ':' typeCS qvtErrorToken
		/.$BeginCode
					CSTNode result = createConfigPropertyCS(
							getRhsIToken(3),
							(TypeCS)getRhsSym(5)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(5));
					setResult(result);
		  $EndCode
		./
	_property ::= property qvtIdentifierCS ':' typeCS '=' OclExpressionCS ';' 
		/.$BeginCode
					CSTNode result = createLocalPropertyCS(
							getRhsIToken(2),
							(TypeCS)getRhsSym(4),
							(OCLExpressionCS)getRhsSym(6)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(7));
					setResult(result);
		  $EndCode
		./
	_property ::= property qvtIdentifierCS '=' OclExpressionCS ';' 
		/.$BeginCode
					CSTNode result = createLocalPropertyCS(
							getRhsIToken(2),
							null,
							(OCLExpressionCS)getRhsSym(4)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(5));
					setResult(result);
		  $EndCode
		./
	_property ::= intermediate property scoped_identifier : typeCS ';' 
		/.$BeginCode
					CSTNode result = createContextualPropertyCS(
							(ScopedNameCS)getRhsSym(3),
							(TypeCS)getRhsSym(5),
							null
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(6));
					setResult(result);
		  $EndCode
		./
	_property ::= intermediate property scoped_identifier : typeCS '=' OclExpressionCS ';' 
		/.$BeginCode
					CSTNode result = createContextualPropertyCS(
							(ScopedNameCS)getRhsSym(3),
							(TypeCS)getRhsSym(5),
							(OCLExpressionCS)getRhsSym(7)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(8));
					setResult(result);
		  $EndCode
		./
	--=== // Properties in transformation (end) ===--

	--=== // Syntax for helper operations (start) ===--
	_helper -> helper_decl
	_helper -> helper_simple_def
	_helper -> helper_compound_def

	helper_header ::= helper_info scoped_identifier complete_signature 
		/.$BeginCode
					CompleteSignatureCS completeSignature = (CompleteSignatureCS)getRhsSym(3);
					Object[] helperInfo = (Object[])getRhsSym(1);
					MappingDeclarationCS mappingDeclarationCS = createMappingDeclarationCS(
						null,
						(ScopedNameCS)getRhsSym(2),
						completeSignature.getSimpleSignature().getParams(),
						completeSignature.getResultParams()
					);
					setOffsets(mappingDeclarationCS, (CSTNode)getRhsSym(2), (CSTNode)getRhsSym(3));

					EList<SimpleNameCS> qualifiers = (EList<SimpleNameCS>) helperInfo[0];
					if(!qualifiers.isEmpty()) {
						mappingDeclarationCS.getQualifiers().addAll(createQualifiersListCS(qualifiers));
					}

					IToken helperKind = (IToken) helperInfo[1];
					mappingDeclarationCS.setIsQuery(helperKind.getKind() == $sym_type.TK_query);
					mappingDeclarationCS.setStartOffset(helperKind.getStartOffset());

					setResult(mappingDeclarationCS);
		  $EndCode
		./

	helper_header ::= helper_info qvtErrorToken
		/.$BeginCode
					Object[] helperInfo = (Object[])getRhsSym(1);
					MappingDeclarationCS mappingDeclarationCS = createMappingDeclarationCS(
						null,
						createScopedNameCS(null, ""),
						$EMPTY_ELIST,
						$EMPTY_ELIST
					);
					setOffsets(mappingDeclarationCS, (IToken) helperInfo[1]);
	
					EList<SimpleNameCS> qualifiers = (EList<SimpleNameCS>) helperInfo[0];
					if(!qualifiers.isEmpty()) {
						mappingDeclarationCS.getQualifiers().addAll(createQualifiersListCS(qualifiers));
					}
	
					IToken helperKind = (IToken) helperInfo[1];
					mappingDeclarationCS.setIsQuery(helperKind.getKind() == $sym_type.TK_query);
					mappingDeclarationCS.setStartOffset(helperKind.getStartOffset());
	
					setResult(mappingDeclarationCS);
		  $EndCode
		./

	helper_info ::= qualifierList helper_kind
		/.$BeginCode
					setResult(new Object[] {getRhsSym(1), getRhsIToken(2)});
		  $EndCode
		./

	helper_kind -> helper
	helper_kind -> query

	helper_decl ::= helper_header ';' 
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS)getRhsSym(1);
					MappingQueryCS result = createMappingQueryCS(
							false,
							mappingDecl,
							$EMPTY_ELIST
						);
					result.setBlackBox(true);
					setOffsets(result, mappingDecl, getRhsIToken(2));
					setResult(result);
		  $EndCode
		./

	helper_decl ::= helper_header qvtErrorToken 
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS)getRhsSym(1);
					MappingQueryCS result = createMappingQueryCS(
							false,
							mappingDecl,
							$EMPTY_ELIST
						);
					result.setBlackBox(true);
					setOffsets(result, mappingDecl);
					setResult(result);
		  $EndCode
		./

	helper_simple_def ::= helper_header '=' OclExpressionCS ';' 
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS)getRhsSym(1);
					OCLExpressionCS expression = (OCLExpressionCS)getRhsSym(3);
					EList<OCLExpressionCS> expressionList = new BasicEList();
					expressionList.add(expression);
					MappingQueryCS result = createMappingQueryCS(
							false,
							mappingDecl,
							expressionList
						);
					result.setIsSimpleDefinition(true);
					setOffsets(result, mappingDecl, getRhsIToken(4));
					setResult(result);
		  $EndCode
		./

	helper_compound_def ::= helper_header expression_block semicolonOpt
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS)getRhsSym(1);
					BlockExpCS blockExpCS = (BlockExpCS)getRhsSym(2);
					CSTNode result = createMappingQueryCS(
							false,
							mappingDecl,
							blockExpCS.getBodyExpressions()
						);
					setOffsets(result, mappingDecl, blockExpCS);
					setResult(result);
		  $EndCode
		./
	--=== // Syntax for helper operations (end) ===--

	--=== // Syntax for constructor operations (start) ===--
	_constructor -> constructor_decl
	_constructor -> constructor_def
	
	constructor_header ::= qualifierList constructor scoped_identifier simple_signature 
		/.$BeginCode
					SimpleSignatureCS signature = (SimpleSignatureCS) getRhsSym(4);					
					MappingDeclarationCS mappingDeclarationCS = createMappingDeclarationCS(
						null,
						(ScopedNameCS) getRhsSym(3),
						signature.getParams(),
						null
					);
					setOffsets(mappingDeclarationCS, getRhsIToken(2), signature);

					EList<SimpleNameCS> qualifiers = (EList<SimpleNameCS>) getRhsSym(1);
					if (!qualifiers.isEmpty()) {
						mappingDeclarationCS.getQualifiers().addAll(createQualifiersListCS(qualifiers));
					}

					setResult(mappingDeclarationCS);
		  $EndCode
		./

	constructor_decl ::= constructor_header ';' 
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS) getRhsSym(1);
					ConstructorCS result = createConstructorCS(
							mappingDecl,
							$EMPTY_ELIST
						);
					result.setBlackBox(true);
					setOffsets(result, mappingDecl, getRhsIToken(2));
					setResult(result);
		  $EndCode
		./

	constructor_decl ::= constructor_header qvtErrorToken 
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS) getRhsSym(1);
					ConstructorCS result = createConstructorCS(
							mappingDecl,
							$EMPTY_ELIST
						);
					result.setBlackBox(true);
					setOffsets(result, mappingDecl);
					setResult(result);
		  $EndCode
		./

	constructor_def ::= constructor_header expression_block semicolonOpt
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS) getRhsSym(1);
					BlockExpCS blockExpCS = (BlockExpCS) getRhsSym(2);
					ConstructorCS result = createConstructorCS(
							mappingDecl,
							blockExpCS.getBodyExpressions()
						);
					setOffsets(result, mappingDecl, blockExpCS);
					setResult(result);
		  $EndCode
		./

	--=== // Syntax for constructor operations (end) ===--

	--=== // Syntax for entries (start) ===--
	entry -> entry_decl
	entry -> entry_def

	entry_header ::= main simple_signature
		/.$BeginCode
					IToken nameToken = getRhsIToken(1);				
					ScopedNameCS nameCS = createScopedNameCS(null, getRhsTokenText(1));								
					nameCS.setStartOffset(nameToken.getStartOffset());
					nameCS.setEndOffset(nameToken.getEndOffset());
		
					SimpleSignatureCS signature = (SimpleSignatureCS)getRhsSym(2);
					CSTNode result = createMappingDeclarationCS(
							null,
							nameCS,
							signature.getParams(),
							null
						);
					setOffsets(result, getRhsIToken(1), signature);
					setResult(result);
		  $EndCode
		./

	entry_header ::= main qvtErrorToken
		/.$BeginCode
					CSTNode result = createMappingDeclarationCS(
							null,
							createScopedNameCS(null, getRhsTokenText(1)),
							$EMPTY_ELIST,
							null
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					setResult(result);
		  $EndCode
		./

	entry_decl ::= entry_header ';'
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS)getRhsSym(1);
					MappingQueryCS result = createMappingQueryCS(
							true,
							mappingDecl,
							$EMPTY_ELIST
						);
					result.setBlackBox(true);
					setOffsets(result, mappingDecl, getRhsIToken(2));
					setResult(result);
		  $EndCode
		./

	entry_def ::= entry_header expression_block semicolonOpt 
		/.$BeginCode
					MappingDeclarationCS mappingDecl = (MappingDeclarationCS)getRhsSym(1);
					BlockExpCS blockExpCS = (BlockExpCS)getRhsSym(2);
					CSTNode result = createMappingQueryCS(
							true,
							mappingDecl,
							blockExpCS.getBodyExpressions()
						);
					setOffsets(result, mappingDecl, blockExpCS);
					setResult(result);
		  $EndCode
		./
	--=== // Syntax for entries (end) ===--


	--=== // syntax for tag definition (start) ===--
	
	_tag ::= tag StringLiteralExpCS scoped_identifier tag_valueOpt
		/.$BeginCode
					OCLExpressionCS valueExpression = (OCLExpressionCS) getRhsSym(4);
					CSTNode result = createTagCS(
							(StringLiteralExpCS) getRhsSym(2),
							(ScopedNameCS) getRhsSym(3),
							valueExpression
						);
					setOffsets(result, getRhsIToken(1), valueExpression != null ? valueExpression : (CSTNode) getRhsSym(3));
					setResult(result);
		  $EndCode
		./

	tag_valueOpt ::= %empty
		/.$NullAction./
	tag_valueOpt ::= '=' OclExpressionCS
		/.$BeginCode
					setResult(getRhsSym(2));
		  $EndCode
		./

	--=== // syntax for tag definition (end) ===--


	--=== // syntax for mapping operations (start) ===--
	_mapping -> mapping_decl
	_mapping -> mapping_def

	mapping_decl ::= mapping_full_header ';'
		/.$BeginCode
		                        Object[] mappingFullHeader = (Object[])getRhsSym(1);
					MappingRuleCS result = createMappingRuleCS(
							(MappingDeclarationCS)mappingFullHeader[0],
							(OCLExpressionCS)mappingFullHeader[1],
							null
						);
					result.setBlackBox(true);
					setOffsets(result, (MappingDeclarationCS)mappingFullHeader[0], getRhsIToken(2));
					setResult(result);
		  $EndCode
		./

	mapping_def ::= mapping_full_header '{' mapping_body '}' semicolonOpt
		/.$BeginCode
					MappingSectionsCS mappingSections = (MappingSectionsCS)getRhsSym(3);
					setOffsets(mappingSections, getRhsIToken(2), getRhsIToken(4));

					MappingBodyCS mappingBodyCS = mappingSections.getMappingBodyCS();
					if (mappingBodyCS != null) {
						if (mappingBodyCS.getStartOffset() < 0) {
							mappingBodyCS.setStartOffset(mappingSections.getStartOffset());
						}
						if (mappingBodyCS.getEndOffset() < 0) {
							mappingBodyCS.setEndOffset(mappingSections.getEndOffset());
						}
					}

		                        Object[] mappingFullHeader = (Object[])getRhsSym(1);
					MappingRuleCS result = createMappingRuleCS(
							(MappingDeclarationCS)mappingFullHeader[0],
							(OCLExpressionCS)mappingFullHeader[1],
							mappingSections
						);
					result.setBlackBox(false);
					setOffsets(result, (MappingDeclarationCS)mappingFullHeader[0], getRhsIToken(4));
					setResult(result);
		  $EndCode
		./

	mapping_def ::= mapping_full_header '{' qvtErrorToken
		/.$BeginCode
		                        Object[] mappingFullHeader = (Object[])getRhsSym(1);
					MappingRuleCS result = createMappingRuleCS(
							(MappingDeclarationCS)mappingFullHeader[0],
							null,
							null
						);
					setOffsets(result, (MappingDeclarationCS)mappingFullHeader[0], getRhsIToken(2));
					setResult(result);
		  $EndCode
		./

	mapping_full_header ::= mapping_header _whenOpt
		/.$BeginCode
					setResult(new Object[] {getRhsSym(1), getRhsSym(2)});
		  $EndCode
		./

	mapping_header ::= qualifierList mapping param_directionOpt scoped_identifier complete_signature mapping_extraList
		/.$BeginCode
					DirectionKindCS directionKind = (DirectionKindCS)getRhsSym(3);
					CompleteSignatureCS completeSignature = (CompleteSignatureCS)getRhsSym(5);
					MappingDeclarationCS mappingDeclarationCS = createMappingDeclarationCS(
						directionKind,
						(ScopedNameCS)getRhsSym(4),
						completeSignature.getSimpleSignature().getParams(),
						completeSignature.getResultParams()
					);
					
					mappingDeclarationCS.setStartOffset(directionKind == null ? getRhsIToken(2).getStartOffset() : directionKind.getStartOffset());
					mappingDeclarationCS.setEndOffset(completeSignature.getEndOffset());

					EList<SimpleNameCS> qualifiers = (EList<SimpleNameCS>)getRhsSym(1);
					if(!qualifiers.isEmpty()) {
						mappingDeclarationCS.getQualifiers().addAll(createQualifiersListCS(qualifiers));
					}

					mappingDeclarationCS.getMappingExtension().addAll(((EList<MappingExtensionCS>)getRhsSym(6)));

					setResult(mappingDeclarationCS);
		  $EndCode
		./

	mapping_header ::= qualifierList mapping param_directionOpt scoped_identifier qvtErrorToken
		/.$BeginCode
					DirectionKindCS directionKind = (DirectionKindCS)getRhsSym(3);
					MappingDeclarationCS mappingDeclarationCS = createMappingDeclarationCS(
						directionKind,
						(ScopedNameCS)getRhsSym(4),
						$EMPTY_ELIST,
						$EMPTY_ELIST
					);

					mappingDeclarationCS.setStartOffset(directionKind == null ? getRhsIToken(2).getStartOffset() : directionKind.getStartOffset());
					mappingDeclarationCS.setEndOffset(((CSTNode)getRhsSym(4)).getEndOffset());

					EList<SimpleNameCS> qualifiers = (EList<SimpleNameCS>)getRhsSym(1);
					if(!qualifiers.isEmpty()) {
						mappingDeclarationCS.getQualifiers().addAll(createQualifiersListCS(qualifiers));
					}

					setResult(mappingDeclarationCS);
		  $EndCode
		./

	mapping_header ::= qualifierList mapping qvtErrorToken
		/.$BeginCode
					MappingDeclarationCS mappingDeclarationCS = createMappingDeclarationCS(
						null,
						createScopedNameCS(null, ""),
						$EMPTY_ELIST,
						$EMPTY_ELIST
					);
					
					setOffsets(mappingDeclarationCS, getRhsIToken(2), getRhsIToken(2));

					EList<SimpleNameCS> qualifiers = (EList<SimpleNameCS>)getRhsSym(1);
					if(!qualifiers.isEmpty()) {
						mappingDeclarationCS.getQualifiers().addAll(createQualifiersListCS(qualifiers));
					}

					setResult(mappingDeclarationCS);
		  $EndCode
		./


	mapping_extraList ::= mapping_extraList mapping_extra
		/.$BeginCode
					EList<MappingExtensionCS> extensionList = (EList<MappingExtensionCS>)getRhsSym(1);
					extensionList.add((MappingExtensionCS)getRhsSym(2));
					setResult(extensionList);
		  $EndCode
		./

	mapping_extraList ::= %empty
		/.$EmptyListAction./

	mapping_extra -> mapping_extension

	mapping_extension ::= mapping_extension_key scoped_identifier_list
		/.$BeginCode
					MappingExtensionCS result = createMappingExtension(getRhsTokenText(1), (EList<ScopedNameCS>)getRhsSym(2));

					result.setStartOffset(getRhsIToken(1).getStartOffset());
					result.setEndOffset(getEndOffset(getRhsIToken(1), (EList<ScopedNameCS>)getRhsSym(2)));
				
					setResult(result);
		  $EndCode
		./

	mapping_extension_key -> inherits
	mapping_extension_key -> merges
	mapping_extension_key -> disjuncts

	_whenOpt -> _when
	_whenOpt ::= %empty	 
		/.$NullAction./

	_when ::= when '{' OclExpressionCS semicolonOpt '}'
		/.$BeginCode
					OCLExpressionCS result = (OCLExpressionCS)getRhsSym(3);
					setResult(result);
		  $EndCode
		./
	_when ::= when qvtErrorToken
		/.$NullAction./

	mapping_body ::= init_sectionOpt population_sectionOpt end_sectionOpt
		/.$BeginCode
		                        MappingInitCS mappingInitCS = (MappingInitCS)getRhsSym(1);
					MappingBodyCS mappingBodyCS = (MappingBodyCS)getRhsSym(2);
					MappingEndCS mappingEndCS = (MappingEndCS)getRhsSym(3);

					if (mappingBodyCS != null) {
						if ((mappingBodyCS.getStartOffset() < 0) && (mappingInitCS != null)) {
							mappingBodyCS.setStartOffset(mappingInitCS.getEndOffset() + 1);
						}
						if ((mappingBodyCS.getEndOffset() < 0) && (mappingEndCS != null)) {
							mappingBodyCS.setEndOffset(mappingEndCS.getStartOffset() - 1);
						}
						if (mappingBodyCS.getStartOffset() > mappingBodyCS.getEndOffset()) {
							mappingBodyCS.setEndOffset(mappingBodyCS.getStartOffset());
						}
					}
					
					CSTNode result = createMappingSectionsCS(
							mappingInitCS,
							mappingBodyCS,
							mappingEndCS
						);
					setResult(result);
		  $EndCode
		./

	init_sectionOpt ::= %empty
		/.$NullAction./
	init_sectionOpt -> init_section

	init_section ::= init expression_block
		/.$BeginCode
					BlockExpCS blockExpCS = (BlockExpCS) getRhsSym(2);
					CSTNode result = createMappingInitCS(
							blockExpCS.getBodyExpressions(),
							blockExpCS.getStartOffset(),
							blockExpCS.getEndOffset()
						);
					setOffsets(result, getRhsIToken(1), blockExpCS);
					setResult(result);
		  $EndCode
		./

	init_section ::= init qvtErrorToken
		/.$BeginCode
					CSTNode result = createMappingInitCS(
							$EMPTY_ELIST,
							getRhsIToken(1).getEndOffset(),
							getRhsIToken(1).getStartOffset()
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					setResult(result);
		  $EndCode
		./

	
	population_sectionOpt ::= %empty
		/.$BeginCode
					MappingBodyCS result = createMappingBodyCS(
							$EMPTY_ELIST,
							false
						);
					// offsets will be updated further in parent non-terminals
					result.setStartOffset(-1); 
					result.setEndOffset(-1);
					setResult(result);
		  $EndCode
		./
	population_sectionOpt -> population_section

	population_section ::= expression_list 
		/.$BeginCode
					EList<OCLExpressionCS> expressionList = (EList<OCLExpressionCS>) getRhsSym(1);
					MappingBodyCS result = createMappingBodyCS(
							expressionList,
							false
						);
					if (expressionList.isEmpty()) {
						// offsets will be updated further in parent non-terminals
						result.setStartOffset(-1); 
						result.setEndOffset(-1);
					} else {
						CSTNode startExp = expressionList.get(0);
						CSTNode endExp = expressionList.get(expressionList.size() - 1);
						setOffsets(result, startExp, endExp);
					}
					setResult(result);
		  $EndCode
		./

	population_section ::= population expression_block 
		/.$BeginCode
					BlockExpCS blockExpCS = (BlockExpCS) getRhsSym(2);
					MappingBodyCS result = createMappingBodyCS(
							blockExpCS.getBodyExpressions(),
							true
						);
					setOffsets(result, getRhsIToken(1), blockExpCS);
					setResult(result);
		  $EndCode
		./
	
	population_section ::= population qvtErrorToken
		/.$BeginCode
					CSTNode result = createMappingBodyCS(
							$EMPTY_ELIST,
							true
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					setResult(result);
		  $EndCode
		./

	end_sectionOpt ::= %empty
		/.$NullAction./
	end_sectionOpt -> end_section

	end_section ::= end expression_block
		/.$BeginCode
					BlockExpCS blockExpCS = (BlockExpCS) getRhsSym(2);
					CSTNode result = createMappingEndCS(
							blockExpCS.getBodyExpressions(),
							blockExpCS.getStartOffset(),
							blockExpCS.getEndOffset()
						);
					setOffsets(result, getRhsIToken(1), blockExpCS);
					setResult(result);
		  $EndCode
		./

	end_section ::= end qvtErrorToken
		/.$BeginCode
					CSTNode result = createMappingEndCS(
							$EMPTY_ELIST,
							getRhsIToken(1).getEndOffset(),
							getRhsIToken(1).getStartOffset()
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	--=== // syntax for mapping operations (end) ===--

	--=== // Expressions (start) ===--
	typespecOpt ::= %empty
		/.$NullAction./
	typespecOpt -> typespec

	objectDeclCS ::= typespec
		/.$BeginCode
					CSTNode result = createOutExpCS(null, (TypeSpecCS)getRhsSym(1));
					setResult(result);
		  $EndCode
		./

	objectIdentifierCS -> result
	objectIdentifierCS -> self
	objectIdentifierCS -> IDENTIFIER	
	
	objectDeclCS ::= objectIdentifierCS ':' typespecOpt
		/.$BeginCode
				SimpleNameCS varName = createSimpleNameCS(SimpleTypeEnum.IDENTIFIER_LITERAL, getRhsIToken(1));
				setOffsets(varName, getRhsIToken(1));
				CSTNode result = createOutExpCS(varName,(TypeSpecCS)getRhsSym(3));					
				setResult(result);
		  $EndCode
		./
	
	outExpCS ::= object objectDeclCS expression_block
		/.$BeginCode
					BlockExpCS blockExpCS = (BlockExpCS) getRhsSym(3);
					CSTNode result = setupOutExpCS(
							(ObjectExpCS) getRhsSym(2),					
							blockExpCS.getBodyExpressions(),
							// passing body positions
							blockExpCS.getStartOffset(),
							blockExpCS.getEndOffset()
						); 
					setOffsets(result, getRhsIToken(1), blockExpCS);
					setResult(result);
		  $EndCode
		./
	outExpCS ::= object objectDeclCS qvtErrorToken
		/.$BeginCode
					ObjectExpCS objectDeclCS = ((ObjectExpCS) getRhsSym(2));  
					CSTNode result = createOutExpCS(
							objectDeclCS.getSimpleNameCS(),						
							objectDeclCS.getTypeSpecCS()
						);
					if (objectDeclCS  == null) {
					    setOffsets(result, getRhsIToken(1), getRhsIToken(1));
					} else {
					    setOffsets(result, getRhsIToken(1), objectDeclCS);
					}
					setResult(result);
		  $EndCode
		./
		
	featureMappingCallExpCS ::= map simpleNameCS '(' argumentsCSopt ')'
		/.$BeginCode
					CSTNode result = createFeatureMappingCallExpCS(
							null,
							(SimpleNameCS)getRhsSym(2),
							(EList)getRhsSym(4),
							false
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(5));
					setResult(result);
		  $EndCode
		./
	featureMappingCallExpCS ::= xmap simpleNameCS '(' argumentsCSopt ')'
		/.$BeginCode
					CSTNode result = createFeatureMappingCallExpCS(
							null,
							(SimpleNameCS)getRhsSym(2),
							(EList)getRhsSym(4),
							true
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(5));
					setResult(result);
		  $EndCode
		./

	featureMappingCallExpCS ::= map simpleNameCS '::' simpleNameCS '(' argumentsCSopt ')'
		/.$BeginCode
					CSTNode result = createFeatureMappingCallExpCS(
							(SimpleNameCS)getRhsSym(2),
							(SimpleNameCS)getRhsSym(4),
							(EList)getRhsSym(6),
							false
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(7));
					setResult(result);
		  $EndCode
		./
	featureMappingCallExpCS ::= xmap simpleNameCS '::' simpleNameCS '(' argumentsCSopt ')'
		/.$BeginCode
					CSTNode result = createFeatureMappingCallExpCS(
							(SimpleNameCS)getRhsSym(2),
							(SimpleNameCS)getRhsSym(4),
							(EList)getRhsSym(6),
							true
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(7));
					setResult(result);
		  $EndCode
		./

	mappingCallExpCS ::= map pathNameCS '(' argumentsCSopt ')'
		/.$BeginCode
					CSTNode result = createMappingCallExpCS(
							(PathNameCS)getRhsSym(2),
							(EList)getRhsSym(4),
							false
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(5));
					setResult(result);
		  $EndCode
		./
	mappingCallExpCS ::= xmap pathNameCS '(' argumentsCSopt ')'
		/.$BeginCode
					CSTNode result = createMappingCallExpCS(
							(PathNameCS)getRhsSym(2),
							(EList)getRhsSym(4),
							true
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(5));
					setResult(result);
		  $EndCode
		./

	-- Resolve family starts here

	resolveConditionOpt ::= %empty
	    /.$NullAction./
	    
	resolveConditionOpt ::= '|' OclExpressionCS
	    /.$BeginCode
	                setResult((OCLExpressionCS)getRhsSym(2));
	      $EndCode
	    ./
	
	resolveConditionOpt ::= '|' qvtErrorToken
	    /.$NullAction./
        
		IDENTIFIEROpt ::= %empty
            /.$NullAction./
	
		IDENTIFIEROpt ::= IDENTIFIER ':'
	    /.$BeginCode
	                setResult(getRhsIToken(1));
	      $EndCode
	    ./
	
	resolveOpArgsExpCSOpt ::= %empty
	    /.$NullAction./
            
	resolveOpArgsExpCSOpt -> resolveOpArgsExpCS
	    
	resolveOpArgsExpCS ::= IDENTIFIEROpt typeCS resolveConditionOpt
	    /.$BeginCode
	                CSTNode result = createResolveOpArgsExpCS(
	                        getRhsIToken(1),      // target_type_variable?
	                        (TypeCS)getRhsSym(2),           // type?
	                        (OCLExpressionCS)getRhsSym(3)); // condition?
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(3));
                        setResult(result);
	      $EndCode
	    ./
	
        resolveOp -> resolve
	resolveOp -> invresolve
	resolveOp -> resolveone
	resolveOp -> invresolveone
	
	lateOpt ::= %empty
	    /.$NullAction./
	lateOpt -> late
	
        resolveExpCS ::= lateOpt resolveOp '(' resolveOpArgsExpCSOpt ')'
	    /.$BeginCode
	                CSTNode result = createResolveExpCS(
                                getRhsIToken(1),
	                        getRhsIToken(2),
                                (ResolveOpArgsExpCS)getRhsSym(4));
                                setOffsets(result, getRhsIToken(1), getRhsIToken(5));
                        setResult(result);
              $EndCode
            ./
            
        resolveExpCS ::= lateOpt resolveOp '(' resolveOpArgsExpCSOpt qvtErrorToken
            /.$BeginCode
	                CSTNode result = createResolveExpCS(
                                getRhsIToken(1),
	                        getRhsIToken(2),
	                        (ResolveOpArgsExpCS)getRhsSym(4));
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(4));
	                setResult(result);
	      $EndCode
	    ./
	    
	resolveExpCS ::= lateOpt resolveOp qvtErrorToken
	    /.$BeginCode
	                CSTNode result = createResolveExpCS(
	                        getRhsIToken(1),
	                        getRhsIToken(2),
	                        null);
                                setOffsets(result, getRhsIToken(1), getRhsIToken(2));
	                setResult(result);
	      $EndCode
	    ./
	    
	resolveExpCS ::= late qvtErrorToken    
	    /.$BeginCode
	    			IToken lateToken = getRhsIToken(1);
	                CSTNode result = createResolveExpCS(
	                        lateToken,
	                        new Token(lateToken.getEndOffset(), lateToken.getEndOffset(), $sym_type.TK_resolve),
	                        null);
                                setOffsets(result, getRhsIToken(1));
	                setResult(result);
	      $EndCode
	    ./
	
	resolveInOp -> resolveIn
	resolveInOp -> invresolveIn
	resolveInOp -> resolveoneIn
	resolveInOp -> invresolveoneIn
	
        resolveInExpCS ::= lateOpt resolveInOp '(' scoped_identifier ',' resolveOpArgsExpCS ')'
	    /.$BeginCode
	                CSTNode result = createResolveInExpCS(
	                        getRhsIToken(1),
	                        getRhsIToken(2),
	                        (ScopedNameCS)getRhsSym(4),
	                        (ResolveOpArgsExpCS)getRhsSym(6));
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(7));
	                setResult(result);
              $EndCode
            ./
	    
        resolveInExpCS ::= lateOpt resolveInOp '(' scoped_identifier ')'
            /.$BeginCode
	                CSTNode result = createResolveInExpCS(
	                        getRhsIToken(1),
	                        getRhsIToken(2),
	                        (ScopedNameCS)getRhsSym(4),
	                        null);
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(5));
	                setResult(result);
	      $EndCode
	    ./
	    
	    
	resolveInExpCS ::= lateOpt resolveInOp '(' scoped_identifier ',' resolveOpArgsExpCSOpt qvtErrorToken
	    /.$BeginCode
	                CSTNode result = createResolveInExpCS(
	                        getRhsIToken(1),
	                        getRhsIToken(2),
	                        (ScopedNameCS)getRhsSym(4),
	                        (ResolveOpArgsExpCS)getRhsSym(6));
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(6));
	                setResult(result);
	      $EndCode
	    ./
	    
	resolveInExpCS ::= lateOpt resolveInOp '(' scoped_identifier qvtErrorToken
	    /.$BeginCode
	                CSTNode result = createResolveInExpCS(
	                        getRhsIToken(1),
	                        getRhsIToken(2),
	                        (ScopedNameCS)getRhsSym(4),
	                        null);
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(4));
	                setResult(result);
	      $EndCode
	    ./
	    
	resolveInExpCS ::= lateOpt resolveInOp '(' qvtErrorToken
	    /.$BeginCode
                        CSTNode result = createResolveInExpCS(
                                getRhsIToken(1),
	                        getRhsIToken(2),
								createScopedNameCS(null, ""), 
	                        null);
                                setOffsets(result, getRhsIToken(1), getRhsIToken(3));
	                setResult(result);
	      $EndCode
            ./
	    
        resolveInExpCS ::= lateOpt resolveInOp qvtErrorToken
	    /.$BeginCode
	                CSTNode result = createResolveInExpCS(
	                        getRhsIToken(1),
	                        getRhsIToken(2),
								createScopedNameCS(null, ""), 
	                        null);
	                        setOffsets(result, getRhsIToken(1), getRhsIToken(2));
	                setResult(result);
	      $EndCode
	    ./
            
        resolveResolveInExpCS -> resolveExpCS
	resolveResolveInExpCS -> resolveInExpCS
            
	-- commented out since the spec is not clear about the return type of this expression       
	OperationCallExpCS ::= primaryExpCS '->' resolveResolveInExpCS
		/.$BeginCode
					OCLExpressionCS source = (OCLExpressionCS)getRhsSym(1);
					CallExpCS result = (CallExpCS)getRhsSym(3);
					result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
					result.setSource(source);
					setResult(result);
		  $EndCode
		./
	OperationCallExpCS ::= primaryExpCS '.' resolveResolveInExpCS
		/.$BeginCode
					OCLExpressionCS source = (OCLExpressionCS)getRhsSym(1);
					CallExpCS result = (CallExpCS)getRhsSym(3);
					result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
					result.setSource(source);
					setResult(result);
		  $EndCode
		./
	        
	-- case with no source of resolveIn
	primaryNotNameCS -> resolveResolveInExpCS
    
	-- Resolve family ends here

	-- operation call and expression extension in QVT

	OperationCallExpCS ::= primaryExpCS '->' featureMappingCallExpCS
		/.$BeginCode
					OCLExpressionCS source = (OCLExpressionCS)getRhsSym(1);
					CallExpCS result = (CallExpCS)getRhsSym(3);
					result.setAccessor(DotOrArrowEnum.ARROW_LITERAL);
					result.setSource(source);
					setResult(result);
		  $EndCode
		./
	OperationCallExpCS ::= primaryExpCS '.' featureMappingCallExpCS
		/.$BeginCode
					OCLExpressionCS source = (OCLExpressionCS)getRhsSym(1);
					CallExpCS result = (CallExpCS)getRhsSym(3);
					result.setAccessor(DotOrArrowEnum.DOT_LITERAL);
					result.setSource(source);
					setResult(result);
		  $EndCode
		./

	primaryNotNameCS -> mappingCallExpCS
    
	primaryNotNameCS -> outExpCS 
			
	simpleNameCS ::= this
		/.$NewCase./
	simpleNameCS ::= result
		/.$BeginCode
					CSTNode result = createSimpleNameCS(
							SimpleTypeEnum.IDENTIFIER_LITERAL,
							getRhsIToken(1)
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./


	----- 'let' extension in QVT, in OCL variable has to define type

	letExpSubCS3 ::= untypedInitializedVariableCS
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	letExpSubCS3 ::= letExpSubCS3 ',' untypedInitializedVariableCS 
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
			
	LetExpCS ::= let letExpSubCS3 in OclExpressionCS
		/.$BeginCode
					EList variables = (EList)getRhsSym(2);
					CSTNode result = createLetExpCS(
							variables,
							(OCLExpressionCS)getRhsSym(4)
						);
					setOffsets(result, getRhsIToken(1), (CSTNode)getRhsSym(4));
					setResult(result);
		  $EndCode
		./
	LetExpCS ::= let letExpSubCS3 in qvtErrorToken
		/.$BeginCode
					EList variables = (EList)getRhsSym(2);
					CSTNode result = createLetExpCS(
							variables,
							createSimpleNameCS(SimpleTypeEnum.IDENTIFIER_LITERAL, (IToken) null)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(3));
					setResult(result);
		  $EndCode
		./


        ----- '!=' - a synonym of '<>'

	equalityNotNameNotLetCS ::= equalityNotLetCS '!=' relationalNotLetCS
		/.$NewCase./
	equalityWithLetCS ::= equalityNotLetCS '!=' relationalWithLetCS
		/.$BeginCode
					SimpleNameCS simpleNameCS = createSimpleNameCS(
								SimpleTypeEnum.STRING_LITERAL,
								OCLStandardLibraryUtil.getOperationName(PredefinedType.NOT_EQUAL)
							);
					setOffsets(simpleNameCS, getRhsIToken(2));
					EList args = new BasicEList();
					args.add(getRhsSym(3));
					CSTNode result = createOperationCallExpCS(
							(OCLExpressionCS)getRhsSym(1),
							simpleNameCS,
							args
						);
					setOffsets(result, (CSTNode)getRhsSym(1), (CSTNode)getRhsSym(3));
					setResult(result);
		  $EndCode
		./


	----- QVTo type extension for InstantiationExp

	newTypespecCS ::= pathNameCS '@' IDENTIFIER
		/.$BeginCode
					CSTNode result = createTypeSpecCS(
						(TypeCS)getRhsSym(1),
						getRhsIToken(3)
						);
					setResult(result);
		  $EndCode
		./

	--=== // Expressions (end) ===--


	--=== Non-standard extensions and legacy support (start) ===--
	_import ::= import library unit ';'
		/.$BeginCode
					CSTNode result = createLibraryImportCS(
							(PathNameCS)getRhsSym(3)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(4));
					setResult(result);
		  $EndCode
		./

	transformation_h ::= qualifierList transformation qualifiedNameCS
		/.$BeginCode
					EList qualifierList = (EList) getRhsSym(1);
					CSTNode result = createTransformationHeaderCS(
							qualifierList,
							(PathNameCS)getRhsSym(3),
							createSimpleSignatureCS($EMPTY_ELIST),
							$EMPTY_ELIST,
							null
						);
					if (qualifierList.isEmpty()) {
						setOffsets(result, getRhsIToken(2), (PathNameCS)getRhsSym(3));
					} else {
						setOffsets(result, (CSTNode) qualifierList.get(0), (PathNameCS)getRhsSym(3));
					}
					setResult(result);
		  $EndCode
		./

	unit_element -> renaming
	renaming ::= rename typeCS '.' qvtIdentifierCS '=' StringLiteralExpCS ';' 
		/.$BeginCode
					CSTNode result = createRenameCS(
							(TypeCS)getRhsSym(2),
							getRhsIToken(4),
							(StringLiteralExpCS)getRhsSym(6)
						);
					setOffsets(result, getRhsIToken(1), getRhsIToken(7));
					setResult(result);
		  $EndCode
		./

	--=== Non-standard extensions and legacy support (end) ===--



	--=== General purpose grammar rules (start) ===--

	qualifierList ::= %empty
		/.$EmptyListAction./
	qualifierList ::= qualifierList qualifier
		/.$BeginCode
					EList result = (EList) getRhsSym(1);
					result.add(getRhsSym(2));
					setResult(result);
		  $EndCode
		./		
		
	qualifier ::= blackbox
		/.$NewCase./
	qualifier ::= abstract
		/.$NewCase./
	qualifier ::= static
		/.$BeginCode
					CSTNode result = createSimpleNameCS(SimpleTypeEnum.KEYWORD_LITERAL, getRhsIToken(1));
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./


	colon_param_listOpt ::= %empty	 
		/.$EmptyListAction./
	colon_param_listOpt ::= ':' param_list
		/.$BeginCode
					setResult(getRhsSym(2));
		  $EndCode
		./

	complete_signature ::= simple_signature colon_param_listOpt
		/.$BeginCode
					SimpleSignatureCS simpleSignatureCS = (SimpleSignatureCS)getRhsSym(1);
					EList<ParameterDeclarationCS> resultList = (EList<ParameterDeclarationCS>)getRhsSym(2);
					CSTNode result = createCompleteSignatureCS(simpleSignatureCS, resultList);
					result.setStartOffset(simpleSignatureCS.getStartOffset());
					result.setEndOffset(getEndOffset(simpleSignatureCS.getEndOffset(), resultList));
					setResult(result);
		  $EndCode
		./

	simple_signatureOpt ::= %empty
		/.$NullAction./
	simple_signatureOpt -> simple_signature

	simple_signature ::= '(' param_listOpt ')' 
		/.$BeginCode
					CSTNode result = createSimpleSignatureCS((EList<ParameterDeclarationCS>)getRhsSym(2));
					setOffsets(result, getRhsIToken(1), getRhsIToken(3));
					setResult(result);
		  $EndCode
		./

	param_listOpt ::= %empty
		/.$EmptyListAction./
	param_listOpt -> param_list

	param_list ::= param_list ',' param
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
	param_list ::= param_list ',' qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./
	param_list ::= param
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	param_list ::= qvtErrorToken
		/.$BeginCode
					EList result = new BasicEList();
					setResult(result);
		  $EndCode
		./

	param ::= param_directionOpt IDENTIFIER ':' typespec
		/.$BeginCode
					DirectionKindCS paramDirectionCS = (DirectionKindCS) getRhsSym(1);
					CSTNode result = createParameterDeclarationCS(
							paramDirectionCS,
							getRhsIToken(2),
							(TypeSpecCS)getRhsSym(4)
						);
					
					result.setStartOffset(paramDirectionCS != null ? paramDirectionCS.getStartOffset() : getRhsIToken(2).getStartOffset());
					result.setEndOffset(((CSTNode)getRhsSym(4)).getEndOffset());
					
					setResult(result);
		  $EndCode
		./
		
	param ::= param_directionOpt typespec
		/.$BeginCode
					DirectionKindCS paramDirectionCS = (DirectionKindCS) getRhsSym(1);
					TypeSpecCS paramTypeCS = (TypeSpecCS) getRhsSym(2);
					CSTNode result = createParameterDeclarationCS(
							paramDirectionCS,
							null,
							paramTypeCS
						);

					result.setStartOffset(paramDirectionCS != null ? paramDirectionCS.getStartOffset() : paramTypeCS.getStartOffset());
					result.setEndOffset(paramTypeCS.getEndOffset());
					
					setResult(result);
		  $EndCode
		./

	param_directionOpt ::= %empty
		/.$NullAction./
	param_directionOpt -> param_direction
	
	param_direction ::= in
		/.$BeginCode
					CSTNode result = createDirectionKindCS(
							DirectionKindEnum.IN
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	param_direction ::= out
		/.$BeginCode
					CSTNode result = createDirectionKindCS(
							DirectionKindEnum.OUT
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	param_direction ::= inout
		/.$BeginCode
					CSTNode result = createDirectionKindCS(
							DirectionKindEnum.INOUT
						);
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./


	typespec ::= typeCS
		/.$BeginCode
					CSTNode result = createTypeSpecCS(
						(TypeCS)getRhsSym(1),
						null
						);
					setResult(result);
		  $EndCode
		./
	typespec ::= typeCS '@' IDENTIFIER
		/.$BeginCode
					CSTNode result = createTypeSpecCS(
						(TypeCS)getRhsSym(1),
						getRhsIToken(3)
						);
					setResult(result);
		  $EndCode
		./


	typeCS2 -> primitiveTypeCS
	typeCS2 -> tupleTypeCS
	typeCS2 -> collectionTypeCS
	
	scoped_identifier ::= typeCS2 '::' IDENTIFIER
		/.$BeginCode
					ScopedNameCS result = createScopedNameCS((TypeCS)getRhsSym(1), getRhsTokenText(3));		
					setOffsets(result, (CSTNode) getRhsSym(1), getRhsIToken(3));
					setResult(result);
		  $EndCode
		./
	scoped_identifier ::= typeCS2 '::' qvtErrorToken
		/.$BeginCode
					ScopedNameCS result = createScopedNameCS((TypeCS)getRhsSym(1), ""); 		
					setOffsets(result, (CSTNode) getRhsSym(1), getRhsIToken(2));
					setResult(result);
		  $EndCode
		./
	scoped_identifier ::= scoped_identifier2
		/.$BeginCode
					PathNameCS pathNameCS = (PathNameCS)getRhsSym(1);
					String name = pathNameCS.getSimpleNames().remove(pathNameCS.getSimpleNames().size() - 1).getValue();
					TypeCS typeCS = pathNameCS.getSimpleNames().isEmpty() ? null : pathNameCS;

					ScopedNameCS result = createScopedNameCS(typeCS, name);		

					setOffsets(result, pathNameCS);

                                        // reduce the region by the removed name element
					pathNameCS.setEndOffset(pathNameCS.getEndOffset() - (name != null ? name.length() : 0) - 2);
					
					setResult(result);
		  $EndCode
		./
	scoped_identifier2 ::= IDENTIFIER
		/.$BeginCode
					CSTNode result = createPathNameCS(getRhsIToken(1));
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	scoped_identifier2 ::= main
		/.$BeginCode
					CSTNode result = createPathNameCS(getRhsIToken(1));
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	scoped_identifier2 ::= scoped_identifier2 '::' IDENTIFIER
		/.$BeginCode
					PathNameCS result = (PathNameCS)getRhsSym(1);
					result = extendPathNameCS(result, getRhsIToken(3));
					setOffsets(result, result, getRhsIToken(3));
					setResult(result);
		  $EndCode
		./
	scoped_identifier2 ::= scoped_identifier2 '::' qvtErrorToken
		/.$BeginCode
					PathNameCS result = (PathNameCS)getRhsSym(1);
					result = extendPathNameCS(result, getRhsIToken(3));
					setOffsets(result, result, getRhsIToken(2));
					setResult(result);
		  $EndCode
		./
	scoped_identifier_list ::= scoped_identifier
		/.$BeginCode
					EList result = new BasicEList();
					result.add(getRhsSym(1));
					setResult(result);
		  $EndCode
		./
	scoped_identifier_list ::= scoped_identifier_list ',' scoped_identifier
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					result.add(getRhsSym(3));
					setResult(result);
		  $EndCode
		./
	scoped_identifier_list ::= scoped_identifier_list qvtErrorToken
		/.$BeginCode
					EList result = (EList)getRhsSym(1);
					setResult(result);
		  $EndCode
		./

	qualifiedNameCS ::= qvtIdentifierCS
		/.$BeginCode
					CSTNode result = createPathNameCS(getRhsIToken(1));
					setOffsets(result, getRhsIToken(1));
					setResult(result);
		  $EndCode
		./
	qualifiedNameCS ::= qualifiedNameCS '.' qvtIdentifierCS
		/.$BeginCode
					PathNameCS result = (PathNameCS)getRhsSym(1);
					result = extendPathNameCS(result, getRhsIToken(3));
					setOffsets(result, result, getRhsIToken(3));
					setResult(result);
		  $EndCode
		./
	qualifiedNameCS ::= qualifiedNameCS '.' qvtErrorToken
		/.$BeginCode
					PathNameCS result = (PathNameCS)getRhsSym(1);
					result = extendPathNameCS(result, getRhsIToken(3));
					setOffsets(result, result, getRhsIToken(2));
					setResult(result);
		  $EndCode
		./
	qualifiedNameCS ::= qualifiedNameCS qvtErrorToken
		/.$BeginCode
					PathNameCS result = (PathNameCS)getRhsSym(1);
					setResult(result);
		  $EndCode	
		./	

	qvtIdentifierCS -> simpleNameCS

	--=== General purpose grammar rules (end) ===--

%End