/*
	vNVD

*/

tree grammar VnvdRewriteAstTest;

options
{
	ASTLabelType = TreeNode;
	tokenVocab = Vnvd;
	language = CSharp2;
	output = AST;
	rewrite = true;
}

@header
{
	using System.Collections.Generic;
	using Vnvd;
}

@namespace
{
	Vnvd.Antlr
}

program
	:	^(node=PROGRAM import_stat* namespace_decl*)
	;

import_stat
	:	^(node=USING qual=qualifier)
	;

namespace_decl
	:	^(node=NAMESPACE qual=qualifier (namespace_decl | class_decl | interface_decl)*)
	;

	
class_decl
	:	^(node=CLASS ^(mod=MODIFIERS modifier*) qual=qualifier (^(ext=EXTENDS qualifier))? (^(imp=IMPLEMENTS qualifier*))?
	 class_element*)
	;
	
interface_decl
	:	^(node=INTERFACE ^(mod=MODIFIERS modifier*) qual=qualifier (^(ext=EXTENDS qualifier))?
		 interface_method*)

	;

interface_method
	:	^(node=IMETHOD qual=type_qualifier id=IDENTIFIER ^(par=PARAMETER (qualifier IDENTIFIER)*))
	
	;

class_element
	:	method_decl
	|	constructor_decl
	|	destructor_decl
	|	field_decl
	;

literal_value
	:	node=NUMBER

	|	node=STRING

	|	node=FLOAT
	
	|	node=CHAR
	
	|	node=TRUE
	
	|	node=FALSE
	
	;
	
abstract_mod_list
	:	^(MODIFIERS access_modifier ABSTRACT)
	;

access_modifier
	:	PRIVATE | PUBLIC | PROTECTED | INTERNAL
	;
	
field_decl
	:	^(node=FIELD ^(mod=MODIFIERS modifier*) qual=qualifier id=IDENTIFIER)

	;
	
method_decl
	:	^(node=METHOD ^(mod=MODIFIERS modifier*) return_=type_qualifier id=IDENTIFIER ^(par=PARAMETER (qualifier IDENTIFIER)*)  block_expression?)

	;
	
constructor_decl
	:	^(node=CONSTRUCTOR ^(mod=MODIFIERS modifier*) id=IDENTIFIER ^(par=PARAMETER (qualifier IDENTIFIER)*) (^(bas=BASE argument*))? block_expression)
	
	;

destructor_decl
	:	^(node=DESTRUCTOR block_expression)
	
	;

statement
	:	expression
	|	declaration_statement
	|	const_decl_statement
	|	control_statement
	;
	
control_statement
	:	while_statement
	|	for_statement
	|	try_statement
	|	throw_statement
	;

throw_statement
	:	^(node=THROW expression)

	;
	
try_statement
	:	^(node=TRY block_expression catch_block* finally_block?)
	
	;
	
catch_block
	:	^(node=CATCH ^(node2=LOCAL qual=qualifier id=IDENTIFIER) block_expression)
		
	;

finally_block
	:	^(node=FINALLY block_expression)
	;
	
while_statement
	:	^(node=WHILE scope_expr block_expression)
	;
	
for_statement
	:	^(node=FOR ^(node2=LOCAL qual=qualifier id=IDENTIFIER) expression block_expression)
	
	;

scope_expr
	:	^(node=SCOPEEXPR statement+)

	;
	
declaration_statement
	:	^(node=LOCAL qual=qualifier id=IDENTIFIER)

	;

const_decl_statement
	:	^(node=CONST qual=qualifier id=IDENTIFIER literal_value)
	
	;

expression
	:	assignment_expression
	;

assignment_expression
	:	ternary_expression
	|	^(node=BECOMES assignment_expression assignment_expression)

	;

ternary_expression
	:
		^(node=IF scope_expr expression expression?)
	
	|	logicoroperator_expression
	;

logicoroperator_expression
	:	logicandoperator_expression
	|	^(node=OR logicoroperator_expression logicoroperator_expression)
	
	;

logicandoperator_expression
	:	logic_expression
	|	^(node=AND logicandoperator_expression logicandoperator_expression)
	
	;

logic_expression
	:	cast_as_expression
	|	^(node=LE primary_expression primary_expression)
	
	|	^(node=LEQ primary_expression primary_expression)
	
	|	^(node=GE primary_expression primary_expression)
	
	|	^(node=GEQ primary_expression primary_expression)
	
	|	^(node=EQ primary_expression primary_expression)

	|	^(node=NEQ primary_expression primary_expression)

	;

cast_as_expression
	:	^(node=AS cast_as_expression qual=qualifier)

		|	primary_expression
	;
	
primary_expression
	:	(^(PLUS primary_expression primary_expression)) => ^(node=PLUS primary_expression primary_expression)

	|	(^(MINUS primary_expression primary_expression)) => ^(node=MINUS primary_expression primary_expression)
	
	|	secundary_expression
	;
	
secundary_expression
	:	^(node=MULTIPLY secundary_expression secundary_expression)

	|	^(node=DIVISION secundary_expression secundary_expression)

	|	^(node=MOD secundary_expression secundary_expression)
	
	|	logicnotoperator_expression
	;

logicnotoperator_expression
	:	^(node=NOT logicnotoperator_expression)

	|	^(node=PLUS logicnotoperator_expression)

	|	^(node=MINUS logicnotoperator_expression)
	
	|	cast_expression
	;

cast_expression
	:	^(node=CAST qual=qualifier cast_expression)

	|	invocation_or_load_expression
	;
	
invocation_or_load_expression
	:	^(node=DCOLON invocation_or_load_expression id=IDENTIFIER argument*)

	|	^(node=LBRACKET invocation_or_load_expression expression)

	|	operand
	;

operand
	:	^(node=USAGE qual=qualifier)

	|	literal_value
	|	node=THIS

	|	node=NULL
	
	|	read_write_expression
	|	object_creation_expression
	|	array_creation_expression
	|	^(node=EXPRBLOCK expression)

	|	block_expression
	;

read_write_expression
	:	^(node=READ qual=IDENTIFIER)

	|	^(node=READVOID qual=IDENTIFIER)

	|	^(node=WRITE expression)

	|	^(node=WRITEVOID expression)

	;

array_creation_expression
	:	^(node=NEWARR qualifier expression)

	;

object_creation_expression
	:	^(node=NEW qual=qualifier (argument*))

	;
	
block_expression
	:	^(node=SLIST statement*)

	;

argument
	:	^(ARGUMENT expression)
	;

qualifier returns [List<string> ids]
	:	^(fqual=FQUALIFIER IDENTIFIER+ ARRAY?)
		{
			ids = new List<String>() { "System", "Void" };
		}
	;
	
type_qualifier returns [List<string> ids]
	:	v=VOID
		{
			ids = new List<String>() { "System", "Void" };
		}
	|	qual=qualifier
		{
			ids = qual;
		}
	;

modifier
	:	PRIVATE | PUBLIC | PROTECTED | INTERNAL | ABSTRACT | STATIC | VIRTUAL | OVERRIDE
	;