token 'first' '[]' 'bool' 'byte' 'char' 'int' 'long' 'word' 'ptr' 'ref' '+'
token '&' 'assert' '=' '@' '&&' '!' '||' 'break' 'case' 'cast' 'catch'
token 'class' '>' ')' ']' ':' ',' 'const'
token char-literal C-string-literal double-literal 'false' int-literal
token 'null' string-literal 'true' 'continue' 'default' '/' 'do' '.' 'elif'
token 'else' 'end' '}' ';' 'enum' end-of-file '==' 'esac' 'extends' 'fi' 'finally'
token 'for' 'foreach' '>=' 'get' '>' identifier 'if' 'import' 'is' '<=' '<' 'method' '%' '*'
token 'namespace' 'native' '!=' 'new' 'line-break' '~' '=~' '!~' 'od' 'of' '<'
token '(' '[' '|' 'pragma' 'private' 'protected' 'public' 'return' 'set'
token '<<' '>>' '{' 'static' 'struct' '-' 'super' 'then' 'this'
token 'thread' 'throw' 'try' 'unknown' 'until' 'use' 'var' 'vector' 'void' 'while' '^'
token 'yrt' 'do_while' 'implements' 'interface' 'proc'

ROOT:
		package 
		;

package:
		class_list 
		;

class_thing:
		class 
		| interface 
		| struct 
		| namespace 
		| use 
		| enumeration 
		| import 
		| pragma 
		;

pragma:
		'pragma' identifier_list ';' 
		;

class_list:
		class_thing 
		| class_list class_thing 
		;

namespace:
		'namespace' name 'is' 'end' 
		| 'namespace' name 'is' class_list 'end' 
		;

use:
		'use' name ';' 
		;

class_specifiers:
		access_specifiers 
		| (empty)
		;

import:
		'import' name ';' 
		| 'import' constant_string ';' 
		;

struct:
		class_specifiers 'struct' identifier class_body 
		;

class:
		class_specifiers 'class' identifier generic implements class_body 
		| class_specifiers 'class' identifier generic 'extends' name generic_super implements class_body 
		;

interface:
		class_specifiers 'interface' identifier generic class_body 
		| class_specifiers 'interface' identifier generic 'extends' name generic_super class_body 
		;

implements:
		'implements' type_list 
		| (empty)
		;

generic:
		'<' plain_identifier_list '>' 
		| (empty)
		;

generic_super:
		'<' type_list '>' 
		| (empty)
		;

enumeration:
		class_specifiers 'enum' identifier 'is' identifier_list 'end' 
		| class_specifiers 'enum' identifier 'is' 'end' 
		;

class_body:
		'is' 'end' 
		| 'is' class_body_declarations 'end' 
		;

class_body_declarations:
		class_body_declaration 
		| class_body_declarations class_body_declaration 
		;

class_body_declaration:
		field_declaration 
		| method_declaration 
		| native_declaration 
		| access_specifiers field_declaration 
		| access_specifiers method_declaration 
		| access_specifiers native_declaration 
		| enumeration 
		| pragma 
		;

field_declaration:
		type identifier_list ';' 
		;

native_declaration:
		'native' type identifier declare_arguments ';' 
		;

method_declaration:
		normal_method_declaration 
		| accessor_declaration 
		| indexer_declaration 
		| indexed_accessor_declaration 
		;

method_body:
		'is' block_statement 'end' 
		| ';' 
		;

accessor_declaration:
		'get' type identifier method_body 
		| 'set' type identifier '=' identifier method_body 
		;

indexer_declaration:
		'get' type '[' argument_declaration ']' method_body 
		| 'set' type '[' argument_declaration ']' '=' identifier method_body 
		;

indexed_accessor_declaration:
		'get' type identifier '[' argument_declaration ']' method_body 
		| 'set' type identifier '[' argument_declaration ']' '=' identifier method_body 
		;

normal_method_declaration:
		type identifier declare_arguments method_body 
		;

declare_arguments:
		'(' declare_argument_list ')' 
		| '(' ')' 
		;

declare_argument_list:
		argument_declaration 
		| declare_argument_list ',' argument_declaration 
		;

argument_declaration:
		type identifier 
		;

expression:
		expressionX 
		;

expressionX:
		expressionX '&&' expression0 
		| expressionX '||' expression0 
		| expression0 
		;

expression0:
		'!' expression0 
		| expressionA 
		;

expressionA:
		expressionA '==' expressionB 
		| expressionA '!=' expressionB 
		| expressionA '>' expressionB 
		| expressionA '<' expressionB 
		| expressionA '>=' expressionB 
		| expressionA '<=' expressionB 
		| expressionA '=~' expressionB 
		| expressionA '!~' expressionB 
		| expressionB 
		;

expressionB:
		expressionB '&' expressionC 
		| expressionB '|' expressionC 
		| expressionB '^' expressionC 
		| expressionC 
		;

expressionC:
		expressionC '<<' expression1 
		| expressionC '>>' expression1 
		| expression1 
		;

expression1:
		expression1 '+' expression2 
		| expression1 '-' expression2 
		| expression2 
		;

expression2:
		expression2 '*' expression3 
		| expression2 '/' expression3 
		| expression2 '%' expression3 
		| expression3 
		;

expression3:
		unary_expression 
		| '~' expression3 
		;

access_specifiers:
		access_specifiers access_specifier 
		| access_specifier 
		;

access_specifier:
		'public' 
		| 'private' 
		| 'protected' 
		| 'static' 
		| 'const' 
		;

ident_assign:
		identifier 
		| identifier '=' expression 
		;

plain_identifier_list:
		identifier 
		| plain_identifier_list ',' identifier 
		;

identifier_list:
		ident_assign 
		| identifier_list ',' ident_assign 
		;

empty_statement:
		';' 
		;

method_call_statement:
		method_call 
		;

labelled_statement:
		identifier ':' loop_statement 
		| loop_statement 
		;

loop_statement:
		foreach_statement 
		| for_statement 
		| do_statement 
		| while_statement 
		;

do_statement:
		'do' block_statement 'od' 
		| 'do' block_statement 'do_while' expression 'od' 
		;

foreach_statement:
		'foreach' type identifier ';' expression 'do' block_statement 'od' 
		| 'foreach' 'var' identifier ';' expression 'do' block_statement 'od' 
		;

for_statement:
		'for' within_for_statement expression ';' very_simple_statement 'do' block_statement 'od' 
		| 'for' within_for_statement ';' very_simple_statement 'do' block_statement 'od' 
		| 'for' within_for_statement expression ';' 'do' block_statement 'od' 
		| 'for' within_for_statement ';' 'do' block_statement 'od' 
		;

switch_statement:
		'case' expression case_list 'esac' 
		| 'case' expression 'esac' 
		;

case_list:
		case 
		| case_list case 
		| default 
		| case_list default 
		;

case:
		'is' expression_list ':' block_statement 
		;

default:
		'default' ':' block_statement 
		;

if_statement:
		'if' expression 'then' block_statement else_statement 'fi' 
		| 'if' expression 'then' block_statement 'fi' 
		;

else_statement:
		'else' block_statement 
		| 'elif' expression 'then' block_statement 
		| 'elif' expression 'then' block_statement else_statement 
		;

while_statement:
		'while' expression 'do' block_statement 'od' 
		;

return_statement:
		'return' ';' 
		| 'return' expression ';' 
		;

throw_statement:
		'throw' expression ';' 
		;

try_statement:
		'try' block_statement catches 'yrt' 
		| 'try' block_statement finally 'yrt' 
		| 'try' block_statement catches finally 'yrt' 
		;

catches:
		catch_clause 
		| catches catch_clause 
		;

catch_clause:
		'catch' argument_declaration block_statement 
		;

finally:
		'finally' block_statement 
		;

break_statement:
		'break' 
		| 'break' identifier 
		;

continue_statement:
		'continue' 
		| 'continue' identifier 
		;

statement:
		simple_statement 
		| if_statement 
		| labelled_statement 
		| switch_statement 
		;

within_for_statement:
		very_simple_statement ';' 
		| local_declaration 
		| ';' 
		;

very_simple_statement:
		assignment_statement 
		| method_call_statement 
		;

simple_statement:
		very_simple_statement ';' 
		| throw_statement 
		| return_statement 
		| try_statement 
		| break_statement ';' 
		| continue_statement ';' 
		| empty_statement 
		;

assignment_statement:
		assignment 
		;

local_declaration:
		untyped_declaration 
		| field_declaration 
		;

untyped_declaration:
		'var' identifier_list ';' 
		;

within_block_statement:
		local_declaration 
		| statement 
		;

left_value:
		name 
		| pointer_access 
		| field_access 
		| vector_access 
		;

assignment:
		left_value '=' expression 
		;

expression_list:
		expression 
		| expression_list ',' expression 
		;

block_statement:
		block_statement_list 
		| (empty)
		;

block_statement_list:
		within_block_statement 
		| block_statement_list within_block_statement 
		;

class_qualifier:
		'class' '<' type '>' 
		;

proc_ref:
		'proc' '(' type_list ')' '(' expression ')' 
		| 'proc' '(' ')' '(' expression ')' 
		;

field_access:
		primary '.' identifier 
		;

generic_type:
		type '<' type_list '>' 
		;

method_call:
		thing '(' ')' 
		| thing '(' expression_list ')' 
		| 'native' '.' identifier '(' ')' 
		| 'native' '.' identifier '(' expression_list ')' 
		;

name:
		simple_name 
		| qualified_name 
		;

simple_name:
		identifier 
		;

qualified_name:
		name '.' identifier 
		;

unary_expression:
		thing 
		| '-' unary_expression 
		;

thing:
		primary 
		| name 
		;

literal:
		constant_null 
		| constant_integer 
		| constant_string 
		| constant_cstring 
		| constant_char 
		| constant_double 
		| constant_boolean 
		;

primary:
		literal 
		| 'this' 
		| 'super' 
		| vector_list 
		| '(' expression ')' 
		| cast 
		| new 
		| proc_ref 
		| field_access 
		| method_call 
		| vector_access 
		| pointer_access 
		| class_qualifier 
		| generic_type 
		;

vector_list:
		type '{' expression_list '}' 
		| type '{' expression_list ',' '}' 
		| '{' expression_list '}' 
		| '{' expression_list ',' '}' 
		;

pointer_access:
		'[' expression ']' 
		;

vector_access:
		name '[' expression ']' 
		| primary '[' expression ']' 
		;

cast:
		'cast' type '(' expression ')' 
		;

new:
		'new' type '[' expression ']' 
		| 'new' type '(' expression_list ')' 
		| 'new' type '(' ')' 
		;

identifier:
		identifier 
		;

constant_null:
		'null' 
		;

constant_integer:
		int-literal 
		;

constant_string:
		string-literal 
		;

constant_cstring:
		C-string-literal 
		;

constant_char:
		char-literal 
		;

constant_double:
		double-literal 
		;

constant_boolean:
		'true' 
		| 'false' 
		;

type:
		name 
		| base_type 
		| complex_type 
		;

complex_type:
		type '[]' 
		| type 'ptr' 
		| type 'ref' 
		| type 'proc' '(' type_list ')' 
		| type 'proc' '(' ')' 
		| generic_type 
		| type '<' '>' 
		;

type_list:
		type 
		| type_list ',' type 
		;

base_type:
		'int' 
		| 'long' 
		| 'word' 
		| 'bool' 
		| 'char' 
		| 'byte' 
		| 'void' 
		;