Ttcn3Parser.g4

parser grammar Ttcn3Parser;

/*
 ******************************************************************************
 * Copyright (c) 2000-2021 Ericsson Telecom AB
 * 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
 * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
 ******************************************************************************
*/

/*
NOTE:

 pr_(Bit|Hex|Octet)String(Match)? rules are for [BHO]STRING(MATCH)? to remove
 the beginning "'" and ending "'[BHO]" strings,
 as lexer cannot remove them as it was done in the ANTLR V2 Parser.
 Do NOT use [BHO]STRING(MATCH)? in any rule, use these instead.

 Rule pr_CString is for CSTRING to remove the beginning and ending '"' characters,
 as lexer cannot remove them as it was done in the ANTLR V2 Parser.
 Do NOT use CSTRING in any rule, use this instead.

--------------------------
Precedence of TTCN-3 operators with precedence levels (higher number is higher precedence)

15 ( ... )
14 +, - (unary)
13 *, /, mod, rem
12 +, -, &
11 not4b (unary)
10 and4b
 9 xor4b
 8 or4b
 7 <<, >>, <@, @>
 6 <, >, <=, >=
 5 ==, !=
 4 not (unary)
 3 and
 2 xor
 1 or

Simplified* expression rules using precedence climbing method:

E1 : E2 ( OR E2 )*
E2 : E3 ( XOR E3 )*
E3 : E4 ( AND E4 )*
E4 : NOT E4 | E5
E5 : E6 ( ( '==' | '!=' ) E6 )*
E6 : E7 ( ( '<' | '>' | '<=' | '>=' ) E7 )*
E7 : E8 ( ( '<<' | '>>' | '<@' | '@>' ) E8 )*
E8 : E9 ( OR4B E9 )*
E9 : E10 ( XOR4B E10 )*
E10: E11 ( AND4B E11 )*
E11: NOT4B E11 | E12
E12: E13 ( ( '+' | '-' | '&' ) E13 )*
E13: P ( ( '*' | '/' | MOD | REM ) P )*
P : NOT E4 | NOT4B E11 | ( '+' | '-' ) P | '(' E1 ')' | v

*: without java code, but the structure is identical to the used rules, where
  En: rule for the n-th precedence level
  E1: pr_SingleExpression in case of Ttcn3Parser.g4
  P: last rule with unary operations, pr_UnaryExpression in case of Ttcn3Parser.g4
  v: atomic expression without any operators, pr_Primary in case of Ttcn3Parser.g4

NOTE: unary operators, which are not on the highest priority level, are used twice, because they must be handled at their precedence level,
      and also at the last (highest precedence) level, if there is no match to other operators.
      If any of these unary operators was matched in the last rule, control must jump back to the rule of its precedence level ( NOT E4, NOT4B E11 ).
      Example case:
        not4b a & not4b b  <=>  not4b ( a & ( not4b b ) )
        1st not4b matches in rule E11, but the 2nd not4b matches in rule P.
*/

options {
tokenVocab=Ttcn3Lexer;
}

@header
{
import java.util.List;
import java.util.ArrayList;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;

import org.eclipse.titan.common.logging.ErrorReporter;
import org.eclipse.titan.common.parsers.CharstringExtractor;
import org.eclipse.titan.common.parsers.SyntacticErrorStorage;
import org.eclipse.titan.common.parsers.TITANMarker;
import org.eclipse.titan.common.parsers.TitanListener;

import org.eclipse.titan.designer.AST.*;
import org.eclipse.titan.designer.AST.Identifier.Identifier_type;
import org.eclipse.titan.designer.AST.Assignment.Assignment_type;
import org.eclipse.titan.designer.AST.ASN1.values.ASN1_Null_Value;
import org.eclipse.titan.designer.AST.TTCN3.*;
import org.eclipse.titan.designer.AST.TTCN3.attributes.*;
import org.eclipse.titan.designer.AST.TTCN3.attributes.SingleWithAttribute.Attribute_Modifier_type;
import org.eclipse.titan.designer.AST.TTCN3.attributes.SingleWithAttribute.Attribute_Type;
import org.eclipse.titan.designer.AST.TTCN3.attributes.ErroneousAttributeSpecification.Indicator_Type;
import org.eclipse.titan.designer.AST.TTCN3.definitions.*;
import org.eclipse.titan.designer.AST.TTCN3.definitions.FormalParameter.parameterEvaluationType;
import org.eclipse.titan.designer.AST.TTCN3.statements.*;
import org.eclipse.titan.designer.AST.TTCN3.types.*;
import org.eclipse.titan.designer.AST.TTCN3.types.PortTypeBody.OperationModes;
import org.eclipse.titan.designer.AST.TTCN3.types.SignatureFormalParameter.ParamaterDirection;
import org.eclipse.titan.designer.AST.TTCN3.types.subtypes.*;
import org.eclipse.titan.designer.AST.TTCN3.templates.*;
import org.eclipse.titan.designer.AST.TTCN3.templates.PatternString.PatternType;
import org.eclipse.titan.designer.AST.TTCN3.values.*;
import org.eclipse.titan.designer.AST.TTCN3.values.expressions.*;
import org.eclipse.titan.designer.parsers.ParserUtilities;

}

@members
{
protected boolean isOopEnabled = false;

public void enableOop(boolean isEnabled) {
	isOopEnabled = isEnabled;
}
/**
 * The currently parsed file object, or null if string is parsed
 */
private IFile actualFile = null;

/**
 * The line number of the first parsed character in the file.
 * Line number starts from 1, it is 1 if the whole file is parsed. 
 */
private int line = 1;

/**
 * The index of the first parsed character in the file. This is NOT the column index.
 * Offset number starts from 0, it is 0 if the whole file is parsed. 
 */
private int offset = 0;

/**
 * markers of syntactical warnings and errors
 */
private List<TITANMarker> warningsAndErrors = new ArrayList<TITANMarker>();

/**
 * Creates a marker.
 * Locations of input tokens are not moved by offset and line yet, this function does this conversion.
 * @param aMessage marker message
 * @param aStartToken the 1st token, its line and start position will be used for the location
 *                  NOTE: start position is the column index of the tokens 1st character.
 *                        Column index starts with 0.
 * @param aEndToken the last token, its end position will be used for the location.
 *                  NOTE: end position is the column index after the token's last character.
 * @param aSeverity severity (info/warning/error)
 * @param aPriority priority (low/normal/high)
 * @return new marker
 */
public TITANMarker createMarker( final String aMessage, final Token aStartToken, final Token aEndToken, final int aSeverity, final int aPriority ) {
	TITANMarker marker = new TITANMarker(
		aMessage,
		(aStartToken != null) ? line - 1 + aStartToken.getLine() : -1,
		(aStartToken != null) ? offset + aStartToken.getStartIndex() : -1,
		(aEndToken != null) ? offset + aEndToken.getStopIndex() + 1 : -1,
		aSeverity, aPriority );
	return marker;
}

/**
 * Adds a warning marker.
 * Locations of input tokens are not moved by offset and line yet, this function does this conversion.
 * @param aMessage marker message
 * @param aStartToken the 1st token, its line and start position will be used for the location
 *                  NOTE: start position is the column index of the tokens 1st character.
 *                        Column index starts with 0.
 * @param aEndToken the last token, its end position will be used for the location.
 *                  NOTE: end position is the column index after the token's last character.
 */
public void reportWarning( final String aMessage, final Token aStartToken, final Token aEndToken ) {
	TITANMarker marker = createMarker( aMessage, aStartToken, aEndToken, IMarker.SEVERITY_WARNING, IMarker.PRIORITY_NORMAL );
	warningsAndErrors.add(marker);
}

/**
 * Adds a warning marker, where the start and end token is the same.
 * Locations of input tokens are not moved by offset and line yet, this function does this conversion.
 * @param aMessage marker message
 * @param aToken the start and end token
 */
public void reportWarning( final String aMessage, final Token aToken ) {
	reportWarning( aMessage, aToken, aToken );
}

/**
 * @return markers of syntactical warnings and errors
 */
public List<TITANMarker> getWarningsAndErrors() {
	return warningsAndErrors;
}

/**
 * markers of unsupported constructs
 */
private List<TITANMarker> unsupportedConstructs = new ArrayList<TITANMarker>();

/**
 * Adds a marker for configurable unsupported constructs.
 * Locations of input tokens are not moved by offset and line yet, this function does this conversion.
 * @param aMessage marker message
 * @param aStartToken the 1st token, its line and start position will be used for the location
 *                  NOTE: start position is the column index of the tokens 1st character.
 *                        Column index starts with 0.
 * @param aEndToken the last token, its end position will be used for the location.
 *                  NOTE: end position is the column index after the token's last character.
 */
public void reportUnsupportedConstruct( final String aMessage, final Token aStartToken, final Token aEndToken ) {
	TITANMarker marker = createMarker( aMessage, aStartToken, aEndToken, IMarker.SEVERITY_ERROR, IMarker.PRIORITY_NORMAL );
	unsupportedConstructs.add(marker);
}

/**
 * @return markers of unsupported constructs
 */
public List<TITANMarker> getUnsupportedConstructs() {
	return unsupportedConstructs;
}

/**
 * Adds an error marker for unsupported constructs.
 * Locations of input tokens are not moved by offset and line yet, this function does this conversion.
 * @param aMessage marker message
 * @param aStartToken the 1st token, its line and start position will be used for the location
 *                  NOTE: start position is the column index of the tokens 1st character.
 *                        Column index starts with 0.
 * @param aEndToken the last token, its end position will be used for the location.
 *                  NOTE: end position is the column index after the token's last character.
 */
public void reportError( final String aMessage, final Token aStartToken, final Token aEndToken ) {
	TITANMarker marker = createMarker( aMessage, aStartToken, aEndToken, IMarker.SEVERITY_ERROR, IMarker.PRIORITY_NORMAL );
	warningsAndErrors.add(marker);
}

public void setActualFile(final IFile file) {
	actualFile = file;
}

public void setLine(final int line) {
	this.line = line;
}

public void setOffset(final int offset) {
	this.offset = offset;
}

private IProject project = null;

public void setProject(final IProject project) {
	this.project = project;
}

/**
 * The currently parsed TTCN-3 module 
 */
private TTCN3Module act_ttcn3_module;

public TTCN3Module getModule() {
	return act_ttcn3_module;
}

public void reset() {
	super.reset();
	if(warningsAndErrors != null) {
		warningsAndErrors.clear();
	}
	if(unsupportedConstructs != null) {
		unsupportedConstructs.clear();
	}
}

/**
 * Gets the documentation comment for the current context, or null if no doc comment found
 * The comment should end in the previous line
 *
 * Both single line and multiline doc comments are supported
 */
public DocumentComment getDocumentComment() {
	BufferedTokenStream stream = (BufferedTokenStream)_input;
	Token start = _ctx.getStart();
	Token first = null;
	Token last = null;
	List<Token> t = null;
	DocumentComment dc;

	if (start != null) {
		int pos = start.getTokenIndex();

		try {
			t = stream.getHiddenTokensToLeft(pos, 1);
		} catch (Exception e) {
			return null;
		}

		if (t == null) {
			return null;
		}
		int len = t.size();
		if (len < 2) {
			return null;
		}
		Token prev = t.get(len - 1);
		if (prev.getType() != ONENEWLINE) {
			return null;
		}
		prev = t.get(len - 2);
		if (prev.getType() == BLOCK_DOCUMENT) {
			dc = new DocumentComment(prev.getText(), prev, prev);
			dc.setLocation(getLocation(prev));
			return dc;
		}
		StringBuilder builder = new StringBuilder();
		boolean stop = false;
		last = prev;
		for (int i = len - 2; !stop && i >= 0; i--) {
			prev = t.get(i);
			switch (prev.getType()) {
			case ONENEWLINE:
			case WS:
				continue;
			case LINE_DOCUMENT:
				first = prev;
				builder.insert(0, prev.getText() + "\n");
				break;
			default:
				stop = true;
			}
		}
		if (builder.length() > 0) {
			dc = new DocumentComment(builder.toString(), first, last);
			dc.setLocation(getLocation(first, last));
			return dc;
		}
	}
	return null;
}

/**
 * Gets the last visible token of the current rule.
 *
 * This is used inside the rule, because \$stop is filled only
 * in the finally block in the generated java code, so it does
 * NOT have the correct value in @after and @finally actions.
 *
 * This method can be used in any part of the rule.
 *
 * Please note that visible means that the token is not on the hidden channel!
 *
 * @return last consumed token
 */
public Token getLastVisibleToken() {
	int index = _input.index() - 1;
	Token temp = _input.get( index );
	while (index >= 0 && temp.getChannel() == temp.HIDDEN_CHANNEL) {
		index--;
		temp = _input.get( index );
	}

	return temp;
}

/**
 * Create new location, which modified by the parser offset and line,
 * where the start and end token is the same
 * @param aToken the start and end token
 */
private Location getLocation(final Token aToken) {
	return getLocation(aToken, aToken);
}

/**
 * Create new location, which modified by the parser offset and line
 * @param aStartToken the 1st token, its line and start position will be used for the location
 *                  NOTE: start position is the column index of the tokens 1st character.
 *                        Column index starts with 0.
 * @param aEndToken the last token, its end position will be used for the location.
 *                  NOTE: end position is the column index after the token's last character.
 */
private Location getLocation(final Token aStartToken, final Token aEndToken) {
	final Token endToken = (aEndToken != null) ? aEndToken : aStartToken;
	return new Location(actualFile, line - 1 + aStartToken.getLine(), offset + aStartToken.getStartIndex(), offset + endToken.getStopIndex() + 1);
}

/**
 * Create new large location, which modified by the parser offset and line
 * @param aStartToken the 1st token, its line and start position will be used for the location
 *                  NOTE: start position is the column index of the tokens 1st character.
 *                        Column index starts with 0.
 * @param aEndToken the last token, its end position will be used for the location.
 *                  NOTE: end position is the column index after the token's last character.
 */
private LargeLocation getLargeLocation(final Token aStartToken, final Token aEndToken) {
	final Token endToken = (aEndToken != null) ? aEndToken : aStartToken;
	return new LargeLocation(actualFile, line - 1 + aStartToken.getLine(), line - 1 + endToken.getLine(), offset + aStartToken.getStartIndex(), offset + endToken.getStopIndex() + 1);
}

/**
 * Create new location, which modified by the parser offset and line
 * @param aBaseLocation location of the start token, location is already modified by offset and line
 * @param aEndToken end token, NOT null, not modified by offset and line yet
 */
private Location getLocation(final Location aBaseLocation, final Token aEndToken) {
	return new Location(actualFile, aBaseLocation.getLine(), aBaseLocation.getOffset(), offset + aEndToken.getStopIndex() + 1);
}

/**
 * Gets the location of the comments before a token.
 * Last comment location cannot be handled in the lexer, because lexer and parser are not always synchronized,
 * lexer reads more, than the parser, because  when the parser reaches a point, the tokens must be already tokenized
 * at least until that point.
 * @param aToken the token, this will NOT be printed
 * @return location, which contains all of the comments before the given token
 */
private Location getLastCommentLocation( final Token aToken ) {
	return ParserUtilities.getCommentsBefore( aToken, this, actualFile );
}

/**
 * @return list of errors, collected by the TitanListener
 *         or null if there is no TitanListener (this case should NOT happen)
 */
public List<SyntacticErrorStorage> getErrors() {
	TitanListener titanListener = null;
	for ( ParseTreeListener listener : this.getParseListeners() ) {
		// there should be only 1 listener, which is a TitanListener, but let's make it safe
		if ( listener instanceof TitanListener ) {
			titanListener = (TitanListener)listener;
			return titanListener.getErrorsStored();
		}
	}
	return null;
}

/**
 * @return true if error list is empty
 */
public boolean isErrorListEmpty() {
	for ( ParseTreeListener listener : this.getParseListeners() ) {
		if(listener instanceof TitanListener && !((TitanListener) listener).getErrorsStored().isEmpty()) {
			return false;
		}
	}
	for(ANTLRErrorListener listener : getErrorListeners()) {
		if(listener instanceof TitanListener && !((TitanListener) listener).getErrorsStored().isEmpty()) {
			return false;
		}
	}
	return true;
}
}

/**
 * @author Kristof Szabados
 * @author Arpad Lovassy
 * @author Miklos Magyari
 */

pr_TTCN3File:
	pr_TTCN3Module?
	EOF
;

//-----------------------------------------------------
// erroneous attribute specification syntax for negative testing
//-----------------------------------------------------

pr_ErroneousAttributeSpec returns [ErroneousAttributeSpecification errAttrSpec]
@init {
	$errAttrSpec = null;
	boolean isRaw = false;
	boolean hasAllKeyword = false;
}:
(	indicator = pr_ErroneousIndicator
	(	pr_LParen
		raw_id = pr_Identifier
//TODO: create token
		{	if ( $raw_id.identifier != null && "raw".equals( $raw_id.identifier.getName() ) ) {
				isRaw = true;
			} else {
				reportUnsupportedConstruct( "Invalid keyword, only the optional `raw' keyword can be used here.", $raw_id.start, $raw_id.stop );
			}
		}
		pr_RParen
	)?
	pr_AssignmentChar
	t = pr_TemplateInstance
	( pr_AllKeyword { hasAllKeyword = true; } )?
	z = EOF // end of string
)
{
	$errAttrSpec = new ErroneousAttributeSpecification($indicator.indicator, isRaw, $t.templateInstance, hasAllKeyword);
	$errAttrSpec.setLocation(getLocation( $indicator.start, $z));
};

pr_ErroneousIndicator returns [Indicator_Type indicator]
@init {
	$indicator = null;
}:
(	pr_ValueKeyword { $indicator = Indicator_Type.Value_Indicator; }
|	id = pr_Identifier
		{
//TODO: create token
			if ( $id.identifier !=null && "before".equals( $id.identifier.getName() ) ) {
				$indicator = Indicator_Type.Before_Indicator;
//TODO: create token
			} else if ( $id.identifier!=null && "after".equals( $id.identifier.getName() ) ) {
				$indicator = Indicator_Type.After_Indicator;
			} else {
				$indicator = Indicator_Type.Invalid_Indicator;
				reportUnsupportedConstruct( "Invalid indicator. Valid indicators are: `before', `value' and `after'", $id.start, $id.stop );
			}
		}
);

//-----------------------------------------------------
//                    TTCN Module  1.6.0
//-----------------------------------------------------

pr_TTCN3Module
@init {
	Token col = null;
	Token endcol = null;
	Token definitionsEnd = null;
	ControlPart controlpart = null;
	MultipleWithAttributes attributes = null;
	List<String> languageSpecifications = null;

	DocumentComment docComment = getDocumentComment();
}:
(	m = pr_TTCN3ModuleKeyword	{ col = $m.start; }
	i = pr_TTCN3ModuleId		{
		act_ttcn3_module = new TTCN3Module( $i.identifier, project );
		// Setting a temporary location
		// Otherwise, if the post rule codes are not executed, Location of TTCN3Module will be null and
		// null exceptions will occur for calls like 'module.getLocation().getFile()'
		act_ttcn3_module.setLocation( getLargeLocation( col, getLastVisibleToken() ) );
	}
	( l = pr_LanguageSpec 		{ languageSpecifications = $l.languageSpec; } )?
	begin = pr_BeginChar
	pr_ModuleDefinitionsList[null]
	( c = pr_ModuleControlPart	{ definitionsEnd = $c.stop; controlpart = $c.controlpart; } )?
	enda = pr_EndChar			{ endcol = $enda.stop; if ( definitionsEnd == null ) { definitionsEnd = $enda.stop; } }
	( a = pr_WithStatement		{ endcol = $a.stop; attributes = $a.attributes; } )?
	( endb = pr_SemiColon		{ endcol = $endb.stop; } )?
)
{
	act_ttcn3_module.setLanguageSpecifications(languageSpecifications);
	act_ttcn3_module.setLocation( getLargeLocation( col, endcol ) );
	act_ttcn3_module.setDefinitionsLocation( getLocation( $begin.start, definitionsEnd ) );
	act_ttcn3_module.setWithAttributes( attributes );
	act_ttcn3_module.setCommentLocation( getLastCommentLocation( $start ) );
	if ( controlpart != null ) {
		act_ttcn3_module.addControlpart( controlpart );
		controlpart.setAttributeParentPath( act_ttcn3_module.getAttributePath() );
	}
	// if (docComment != null) {
	// 	// act_ttcn3_module.setDocumentatComment(docComment);
	// }
};

pr_TTCN3ModuleKeyword returns[String stringValue]:
	MODULE
{
	$stringValue = $MODULE.getText();
};

// ASN.1 with TTCN-3 BNF Extension Start

pr_ObjectIdentifierKeyword:
	OBJECTIDENTIFIERKEYWORD
;

pr_ObjectIdentifierValue returns [ObjectIdentifier_Value value]:
	OBJECTIDENTIFIERKEYWORD
	pr_BeginChar
	v = pr_ObjIdComponentList
	endcol = pr_EndChar
{
	$value = $v.value;
	$value.setLocation(getLocation( $OBJECTIDENTIFIERKEYWORD, $endcol.stop));
};

pr_ObjIdComponentList returns [ObjectIdentifier_Value value]
@init {
	$value = new ObjectIdentifier_Value();
}:
(	o = pr_ObjIdComponent	{if($o.objidComponent != null) { $value.addObjectIdComponent($o.objidComponent); } }
)+
;

pr_ObjIdComponent returns [ObjectIdentifierComponent objidComponent]
@init {
	$objidComponent = null;
}:
(	i = pr_Identifier
		{	if ($i.identifier != null) {
				$objidComponent = new ObjectIdentifierComponent($i.identifier, null);
				$objidComponent.setLocation(getLocation( $i.start, $i.stop));
			}
		}
|	v = pr_ReferencedValue
		{	if ($v.value != null) {
				$objidComponent = new ObjectIdentifierComponent($v.value);
				$objidComponent.setLocation(getLocation( $v.start, $v.stop));
			}
		}
|	o = pr_NumberForm { $objidComponent = $o.objidComponent;}
|	o2 = pr_NameAndNumberForm { $objidComponent = $o2.objidComponent;}
);

pr_NumberForm returns [ObjectIdentifierComponent objidComponent]
@init {
	$objidComponent = null;
}:
	NUMBER
{
	Value value = new Integer_Value($NUMBER.getText());
	value.setLocation(getLocation( $NUMBER));
	$objidComponent = new ObjectIdentifierComponent(null, value);
	$objidComponent.setLocation(getLocation( $NUMBER));
};

pr_NameAndNumberForm returns [ObjectIdentifierComponent objidComponent]
@init {
	$objidComponent = null;
}:
	i = pr_Identifier
	LPAREN
	NUMBER
	RPAREN
{
	Value value = new Integer_Value($NUMBER.getText());
	value.setLocation(getLocation( $NUMBER));
	$objidComponent = new ObjectIdentifierComponent($i.identifier, value);
	$objidComponent.setLocation(getLocation( $i.start, $RPAREN));
};

// ASN.1 with TTCN-3 BNF Extension End

pr_TTCN3ModuleId returns[Identifier identifier]
@init {
	$identifier = null;
}:
(	i = pr_OwnGlobalModuleId
)
{
	$identifier = $i.identifier;
};

pr_OwnGlobalModuleId returns [Identifier identifier]
@init {
	$identifier = null;
}:
(	id = pr_Identifier
	(	DOT
		pr_ObjectIdentifierValue
	)?
)
{
	$identifier = $id.identifier;
};


//------------------------------------------------------
//          Module Definitions Part      1.6.1  136
//------------------------------------------------------

pr_ModuleDefinitionsList [Group parent_group]:
(	(	col = pr_ModuleDefinition[parent_group]
	)*
);

pr_ModuleDefinition [Group parent_group]:
(	d = pr_ModuleDef
		{
			List<Definition> defs = $d.definitions;
			act_ttcn3_module.addDefinitions(defs);
			if(parent_group == null) {
				for(Definition def : defs) {
					def.setAttributeParentPath(act_ttcn3_module.getAttributePath());
				}
			} else {
				parent_group.addDefinitions(defs);
				for(Definition def : defs) {
					def.setAttributeParentPath(parent_group.getAttributePath());
				}
			}
		}
|	pr_ImportDef[parent_group]
|	pr_GroupDef[parent_group] pr_SemiColon?
|	pr_FriendModuleDef[parent_group] pr_SemiColon?
);

pr_ModuleDef returns [List<Definition> definitions]
@init {
	$definitions = new ArrayList<Definition>();
	VisibilityModifier modifier = null;
	MultipleWithAttributes attributes = null;
	boolean semicolon = false;
}:
(	(	m = pr_Visibility { modifier = $m.modifier; }	)?
	(	d1 = pr_TypeDef { if($d1.def_type != null) { $definitions.add($d1.def_type); } }
	|	d2 = pr_ConstDef { if($d2.array != null) { $definitions.addAll($d2.array); } }
	|	{	boolean isTemplateVar = false;	}
		(	pr_VarKeyword	{	isTemplateVar = true;	}	)?
		d3 = pr_TemplateDef
		{
			final Def_Template templateDef = $d3.def_template;
			if ( isTemplateVar ) {
				final String templateName = templateDef != null ? " `" + templateDef.getIdentifier() + "'" : "";
				reportError( "Code generation for global template variable" + templateName + " is not supported", $start, $d3.stop );
			}
			else if ( $d3.def_template != null ) {
				$definitions.add( $d3.def_template );
			}
		}
	|	d4 = pr_FunctionDef { if($d4.def_func != null) { $definitions.add($d4.def_func); } }
	|	d5 = pr_SignatureDef { if($d5.def_type != null) { $definitions.add($d5.def_type); } }
	|	d6 = pr_TestcaseDef { if($d6.def_testcase != null) { $definitions.add($d6.def_testcase); } }
	|	d7 = pr_AltstepDef { if($d7.def_altstep != null) { $definitions.add($d7.def_altstep); } }
	|	d8 = pr_ExtFunctionDef { if($d8.def_extfunction != null) { $definitions.add($d8.def_extfunction); } }
	|	d9 = pr_ExtConstDef { $definitions.addAll($d9.definitions); }
	|	d10 = pr_ModuleParDef { if($d10.parameters != null) { $definitions.addAll($d10.parameters); } }
	)
	(	a = pr_WithStatement { attributes = $a.attributes; }	)?
	(	pr_SemiColon {semicolon = true;}	)?
)
{
	for ( int i = 0; i < $definitions.size(); i++ ) {
		Definition definition = $definitions.get(i);
		if ( modifier != null ) {
			definition.setVisibility( modifier );
			Location loc = definition.getLocation();
			loc.setOffset( offset + $start.getStartIndex() );
		}
		if( attributes != null ) {
			definition.setWithAttributes( attributes );
			Location loc = definition.getLocation();
			loc.setEndOffset(offset + getLastVisibleToken().getStopIndex() + 1);
		}
		if(semicolon) {
			Location loc = definition.getLocation();
			loc.setEndOffset(offset + getLastVisibleToken().getStopIndex() + 1);
		}
		definition.setCumulativeDefinitionLocation(getLocation( $start, getLastVisibleToken()));
	}

	for ( Definition definition : $definitions ) {
		definition.setCommentLocation( getLastCommentLocation( $start ) );
	}
};

//------------------------------------------------------
//   Typdef Definitions  1.6.1.1  136
// -----------------------------------------------------

pr_TypeDef returns[Def_Type def_type]
@init {
	$def_type = null;
}:
(	pr_TypeDefKeyword
	(	d1 = pr_StructuredTypeDef { $def_type = $d1.def_type; }
	|	d2 = pr_SubTypeDef { $def_type = $d2.def_type; }
	)
)
{	if ( $def_type != null ) {
		$def_type.setLocation(getLocation( $start, getLastVisibleToken() ));
	}
};

pr_TypeDefKeyword:
	TYPE
;

pr_StructuredTypeDef returns[Def_Type def_type]
@init {
	$def_type = null;
}:
(	t1 = pr_RecordOfDef { $def_type = $t1.def_type; }
|	t2 = pr_RecordDef { $def_type = $t2.def_type; }
|	t3 = pr_UnionDef { $def_type = $t3.def_type; }
|	t4 = pr_SetOfDef { $def_type = $t4.def_type; }
|	t5 = pr_SetDef { $def_type = $t5.def_type; }
|	t6 = pr_EnumDef { $def_type = $t6.def_type; }
|	t7 = pr_PortDef { $def_type = $t7.def_type; }
|	t8 = pr_ComponentDef { $def_type = $t8.def_type; }
|	t9 = pr_FunctionTypeDef { $def_type = $t9.def_type; }
|	t10 = pr_AltstepTypeDef { $def_type = $t10.def_type; }
|	t11 = pr_TestcaseTypeDef { $def_type = $t11.def_type; }
|	t12 = pr_ClassTypeDef { $def_type = $t12.def_type; }
);

pr_RecordDef returns[Def_Type def_type]
@init {
	$def_type = null;
	CompFieldMap compFieldMap = new CompFieldMap();
}:
(	col = pr_RecordKeyword
	i = pr_StructDefBody[compFieldMap]
)
{
	if($i.identifier != null) {
		TTCN3_Sequence_Type type = new TTCN3_Sequence_Type(compFieldMap);
		type.setLocation(getLocation( $col.start, $i.stop));
		$def_type = new Def_Type($i.identifier, type);
	}
};

pr_RecordKeyword:
	RECORD
;

pr_StructDefBody[CompFieldMap compFieldMap] returns[Identifier identifier]
@init {
	$identifier = null;
}:
(	(	i = pr_Identifier { $identifier = $i.identifier; }
		pr_StructDefFormalParList?
	|	ADDRESS  { $identifier = new Identifier(Identifier_type.ID_TTCN, "address", getLocation( $ADDRESS)); }
	)
	begin = pr_BeginChar
	(	c = pr_StructFieldDef { compFieldMap.addComp($c.compField); }
		(	pr_Comma
			c = pr_StructFieldDef { compFieldMap.addComp($c.compField); }
		)*
	)?
	endcol = pr_EndChar
)
{
	if( $compFieldMap != null ) { $compFieldMap.setLocation(getLocation( $begin.start, $endcol.stop)); }
};

pr_StructDefFormalParList:
(	col = pr_LParen
	pr_StructDefFormalPar
	(	pr_Comma
		pr_StructDefFormalPar
	)*
	endcol = pr_RParen
)
{
	reportUnsupportedConstruct( "Type parameterization is not yet supported", $col.start, $endcol.stop );
};

pr_StructDefFormalPar:
	pr_FormalValuePar
;

pr_StructFieldDef returns[CompField compField]
@init {
	$compField = null;
	Type type = null;
	ArrayDimensions dimensions = null;
	List<ParsedSubType> parsedSubTypes = null;
	boolean optional = false;
}:
(	(	t = pr_Type { type = $t.type; }
	|	t2 = pr_NestedTypeDef { type = $t2.type; }
	)
	i = pr_Identifier
	( d = pr_ArrayDef { dimensions = $d.dimensions; } )?
	( p = pr_SubTypeSpec { parsedSubTypes = $p.parsedSubTypes; } )?
	( pr_OptionalKeyword { optional = true; } )?
)
{
	if($i.identifier != null && type != null) {
		if(parsedSubTypes != null) {
			IType t = type;
			boolean seof = true;
			while(seof) {
				seof = t instanceof AbstractOfType;
				if (seof) {
					t = ((AbstractOfType) t).getOfType();
				}
			}
			t.setParsedRestrictions(parsedSubTypes);
		}
		if( dimensions != null ) {
			for ( int i = dimensions.size() - 1; i >= 0; i-- ) {
				type = new Array_Type(type, dimensions.get(i), true);
				type.setLocation(getLocation( $d.start, $d.stop));
			}
		}
		$compField = new CompField($i.identifier, type, optional, null);
		$compField.setLocation(getLocation( $start, getLastVisibleToken()));
		$compField.setCommentLocation( getLastCommentLocation( $start ) );
	}
};

pr_NestedTypeDef returns[Type type]
@init {
	$type = null;
}:
(	t1 = pr_NestedRecordDef			{ $type = $t1.type; }
|	t2 = pr_NestedUnionDef			{ $type = $t2.type; }
|	t3 = pr_NestedSetDef			{ $type = $t3.type; }
|	t4 = pr_NestedRecordOfDef		{ $type = $t4.type; }
|	t5 = pr_NestedSetOfDef			{ $type = $t5.type; }
|	t6 = pr_NestedEnumDef			{ $type = $t6.type; }
|	t7 = pr_NestedFunctionTypeDef	{ $type = $t7.type; }
|	t8 = pr_NestedAltstepTypeDef	{ $type = $t8.type; }
|	t9 = pr_NestedTestcaseTypeDef	{ $type = $t9.type; }
);

pr_NestedRecordDef returns[Type type]
@init {
	$type = null;
	CompFieldMap compFieldMap = new CompFieldMap();
}:
(	col = pr_RecordKeyword
	begin = pr_BeginChar
	(	c = pr_StructFieldDef { compFieldMap.addComp($c.compField); }
		(	pr_Comma
			c = pr_StructFieldDef { compFieldMap.addComp($c.compField); }
		)*
	)?
	endcol = pr_EndChar
)
{
	compFieldMap.setLocation(getLocation( $begin.start, $endcol.stop));
	$type = new TTCN3_Sequence_Type(compFieldMap);
	$type.setLocation(getLocation( $col.start, $endcol.stop));
};

pr_NestedUnionDef returns[Type type]
@init {
	$type = null;
	CompFieldMap compFieldMap = new CompFieldMap();
}:
(	col = pr_UnionKeyword
	begin = pr_BeginChar
	(	c = pr_UnionFieldDef { compFieldMap.addComp($c.compField); }
		(	pr_Comma
			c = pr_UnionFieldDef { compFieldMap.addComp($c.compField); }
		)*
	)
	endcol = pr_EndChar
)
{
	compFieldMap.setLocation(getLocation( $begin.start, $endcol.stop));
	$type = new TTCN3_Choice_Type(compFieldMap);
	$type.setLocation(getLocation( $col.start, $endcol.stop));
};

pr_NestedSetDef returns[Type type]
@init {
	$type = null;
	CompFieldMap compFieldMap = new CompFieldMap();
}:
(	col = pr_SetKeyword
	begin = pr_BeginChar
	(	c = pr_StructFieldDef { compFieldMap.addComp($c.compField); }
		(	pr_Comma
			c = pr_StructFieldDef { compFieldMap.addComp($c.compField); }
		)*
	)?
	endcol = pr_EndChar
)
{
	compFieldMap.setLocation(getLocation( $begin.start, $endcol.stop));
	$type = new TTCN3_Set_Type(compFieldMap);
	$type.setLocation(getLocation( $col.start, $endcol.stop));
};

pr_NestedRecordOfDef returns[SequenceOf_Type type]
@init {
	$type = null;
	LengthRestriction restriction = null;
	Type ofType = null;
}:
(	col = pr_RecordKeyword
	( r = pr_StringLength { restriction = $r.restriction; } )?
	pr_OfKeyword
	(	t1 = pr_Type { ofType = $t1.type; }
	|	t2 = pr_NestedTypeDef { ofType = $t2.type; }
	)
)
{
	$type = new SequenceOf_Type(ofType);
	if(restriction != null) {
		List<ParsedSubType> parsedSubTypes = new ArrayList<ParsedSubType>();
		parsedSubTypes.add(new Length_ParsedSubType(restriction));
		$type.setParsedRestrictions(parsedSubTypes);
	}
	$type.setLocation(getLocation( $col.start, getLastVisibleToken()));
};

pr_NestedSetOfDef returns[SetOf_Type type]
@init {
	$type = null;
	LengthRestriction restriction = null;