minipython_test.grammar

/*
* Test Comments
*/

Package minipython;

Helpers
	digit = ['0' .. '9'];
	letter = ['a' .. 'z']|['A' .. 'Z']; 
	cr = 13; 
	lf = 10;
	space = 32;
	all = [0..127]; 
	eol = lf | cr | cr lf ;
	not_eol = [all - [cr + lf]]; 

Tokens
	tab = 9;
	plus = '+';
	minus = '-';
	mult = '*';
	pow = '**';
	mineq = '-=';
	diveq = '/=';
	div = '/';
	dot = '.';
	eq = '=';
	deq = '==';
	exclam = '!';
	dictt = 'dict';
	def = 'def';
	logic_plus = '&&';
	l_par = '(';
	r_par = ')';
	l_br = '[';
	r_br = ']';
	comma=',';
	qmark = '?';
	gqmark = ';';
	if = 'if';
	elif = 'elif';
	else = 'else';
	while = 'while';
	for = 'for';
	from = 'from';
	imp = 'import';
	assert = 'assert';
	as = 'as';
	print = 'print';
	return = 'return';
	in = 'in';
	less = '<';
	great = '>';
	dif = '!=';
	true = 'true';
	semi = ':';
	false = 'false';
	quote = '"';
	blank = (' ' | lf | cr);
	line_comment = '#' not_eol* eol; 
	id = letter (letter | digit)*;
	float = digit* '.' digit+;
	integer = ([digit-'0'] digit* | '0');
	string = '"'(letter|space)*'"'|'''(letter|space)*''';
	
Ignored Tokens
	blank, line_comment;

Productions	
	goal = commands*{-> New goal([commands])};

	commands = {func}function{-> New commands.func(function) } |
			   {state}statement{-> New commands.state(statement) };
	
	iddot = id dot {-> New iddot(id)};
		
	eqvalue = eq value {-> New eqvalue(value)};
	
	commaid = comma id eqvalue? {-> New commaid(id, [eqvalue])};
	
	commaexp = comma expression {-> New commaexp(expression)};
	
	commavalue = comma value{-> New commavalue(value)};
	
	asid = as id{-> New asid(id)};
	
	commamoduleasid = comma module asid?{-> New commamoduleasid(module, [asid])};
	
	commaidasid = comma id asid?{-> New commaidasid(id, [asid])};
	
	sign = {negative} minus{-> New sign.negative()} | {possitive} plus{-> New  sign.possitive()};
	
	hp_expression{-> expression} = {power} power {-> power.expression}|
					{multiplication} hp_expression mult power {-> New expression.mult(hp_expression.expression, power.expression)}|
					{division} hp_expression div power{-> New expression.div(hp_expression.expression, power.expression)};
	
	power{-> expression} = {something} something {-> something.expression}| 
			{power} power pow something {-> New expression.pow(power.expression, something.expression)};
			
	/*morevalue = value commavalue* {-> New morevalue(value, [commavalue])};*/
	
	function = def id l_par argument? r_par semi statement {-> New function(id, [argument], statement)};
	
	argument = id eqvalue? commaid*{-> New argument(id, [eqvalue], [commaid])};	
	
	statement = {if} tab* if comparison semi statement {-> New statement.if(comparison, statement)}|
			  	{while} tab* while comparison semi statement {-> New statement.while(comparison, statement)}|
				{for} tab* for [left_id]:id in [right_id]:id semi statement {-> New statement.for(left_id, right_id, statement)}|
				{return} tab* return expression {-> New statement.return(expression)}|
				{print_simple} tab* print expression commaexp* {-> New statement.print_simple(expression, [commaexp])}|
				{equals} tab* id eq expression {-> New statement.equals(id, expression)}|
				{subeq} tab* id mineq expression {-> New statement.subeq(id, expression)}|
				{diveq} tab* id diveq expression {-> New statement.diveq(id, expression)}|
				{list} tab* id l_br [left]:expression r_br eq [right]:expression {-> New statement.list(id, left, right)}|
				{assert_exp} assert expression commaexp?{-> New statement.assert_exp(expression, [commaexp])}|
				{assert_comp} assert comparison commaexp? {-> New statement.assert_comp(comparison, [commaexp])}|
				{funccall} tab* functioncall {-> New statement.funccall(functioncall)}|
				{import} import {-> New statement.import(import)};
				
	expression = {multiplication} hp_expression {-> hp_expression.expression} |
				 {addition} expression plus hp_expression {-> New expression.add(expression, hp_expression.expression)}|
				 {subtraction} expression minus hp_expression {-> New expression.sub(expression, hp_expression.expression)}; 				 
					
	something{-> expression} = {id} id {-> New expression.id(id)}|
			  	{val} value {-> New expression.value(value)}|
				{func_call} functioncall {-> New expression.funccall(functioncall)}|
				{par_exp} l_par expression r_par {-> New expression.par_exp(expression)}|
				/*according to the BNF, we have at least one value here but we accept zero*/
				{br_exp} l_br value commavalue* r_br {-> New expression.val_comma_val(value, [commavalue])}|
				{id2} id l_br expression r_br {-> New expression.par_exp(expression)};
				
	import = {importas} imp module asid? commamoduleasid* {-> New import.importas(module, [asid], [commamoduleasid])}|
			 {fromimport} from module imp id asid? commaidasid*{-> New import.fromimport(module, id, [asid], [commaidasid])};
			 
	module = iddot* id {-> New module([iddot], id)};
	
	comparison = {great} [left_exp]:expression great [right_exp]:expression {-> New comparison.great(left_exp, right_exp)}|
				 {less} [left_exp]:expression less [right_exp]:expression {-> New comparison.less(left_exp, right_exp)}|
				 {dif} [left_exp]:expression dif [right_exp]:expression {-> New comparison.dif(left_exp, right_exp)}|
				 {eq} [left_exp]:expression deq [right_exp]:expression {-> New comparison.eq(left_exp, right_exp)}|
				 {true} true {-> New comparison.true()}|
				 {false} false{-> New comparison.false()};
	
	functioncall = id l_par arglist? r_par{-> New functioncall(id, [arglist])};
	
	arglist = expression commaexp*{-> New arglist(expression, [commaexp])};
			
	value = {funccall} id dot functioncall{-> New value.funccall(id, functioncall)} |
		    {number} number {-> New value.number(number)}| 
			{string} string{-> New value.string(string)};
	
	number = {integer} sign? integer{-> New number.integer(integer)} |
		   	 {float} sign? float{-> New number.float(float)};

Abstract Syntax Tree
   	
	goal = commands*;
	
	commands = {func}function | {state}statement;
	
	function = id argument* statement;	
	
	argument = id eqvalue* commaid*;
	
	eqvalue = value;	
	
	commaid = id eqvalue*;	
	
	statement = {if} comparison statement|
			  	{while} comparison statement|
				{for} [left_id]:id [right_id]:id statement|
				{return} expression|
				{print_simple} expression commaexp* |
				{equals} id expression|
				{subeq} id expression|
				{diveq} id expression|
				{list} id [left_id]:expression [right_id]:expression|
				{assert_exp} expression commaexp*|
				{assert_comp} comparison commaexp*|
				{funccall} functioncall|
				{import} import;

	expression = {add} [l]:expression [r]:expression |
			   	 {sub} [l]:expression [r]:expression |
				 {mult} [l]:expression [r]:expression|
				 {div} [l]:expression [r]:expression |
				 {pow} [l]:expression [r]:expression |
				 {funccall} functioncall |
				 {id_exp} id expression |
				 {value} value |
				 {id} id |
				 {par_exp} expression |
				 {val_comma_val} value commavalue*;

	import = {importas} module asid* commamoduleasid* |
			 {fromimport} module id asid* commaidasid*;
   
    module = iddot* id;

	comparison = {great} [left_exp]:expression [right_exp]:expression |
				 {less} [left_exp]:expression [right_exp]:expression |
				 {dif} [left_exp]:expression [right_exp]:expression |
				 {eq} [left_exp]:expression [right_exp]:expression |
				 {true}  |
				 {false} ;

	functioncall = id arglist*;
	
	arglist = expression commaexp*;
			
	value = {funccall} id functioncall | {number} number | {string} string;
	
	number = {integer} integer|{float} float;
	

	iddot = id;

	commaexp = expression;

	commavalue = value;

	asid = id;

	commamoduleasid = module asid*;

	commaidasid = id asid*;

	sign = {negative}  | {possitive};

	/*morevalue = value commavalue* ;*/