simple_csharp_grammar.scc

Package sablecc;

Helpers
	ascii = [0 .. 127];
	first_digit = ['1' .. '9'];
	digit = ['0' + first_digit ];
	dollar = '$';
	underscore = '_';
	letter = [['a' .. 'z'] + ['A' .. 'Z']] | dollar | underscore;
	white_space = ' ';
	tab = '	';
	string = '"';
	point = '.';
	star = '*';

	/*********/
    /* LINES */
    /*********/

    lf  = 0x000a;
    ff  = 0x000c;
    cr  = 0x000d;
    line_terminator = lf | cr | cr lf;
	line_character = [[[ cr + lf] + lf] + cr];

	/************/
    /* COMMENTS */
    /************/

    comment_s = '//';
	comment_l = '/*';
	comment_r = '*/';
	not_star = [ascii - '*'];
    not_slash = [ascii - '/'];
    not_star_not_slash = [ascii - ['*' + '/']];

    /**********/
    /* INPUTS */
    /**********/
	
	input = [ascii - line_character];
	inputs = input+;

    /***********/
    /* STRINGS */
    /***********/

	not_string = [ascii - '"'];

	/*************/
    /* CONSTANTS */
    /*************/

	int_const = digit+;
    double_const = (digit+ point digit+);
    true = 'true';
    false = 'false';
    bool_const = true | false;
    string_const = (string (not_string)* string);

Tokens
	/***********/
	/* SYMBOLS */
	/***********/
	
	using_symbol = 'using';
	namespace_symbol = 'namespace';
	class_symbol = 'class';
	public_symbol = 'public';
	static_symbol = 'static';
	return_symbol = 'return';
	main_symbol = 'Main';
	console_symbol = 'Console';
	write_line_symbol = 'WriteLine';
	args_symbol = 'args';
	void_symbol = 'void';
	int_symbol = 'int';
	double_symbol = 'double';
	string_symbol = 'string';
	bool_symbol = 'bool';
	if_symbol = 'if';
	else_symbol = 'else';
	while_symbol = 'while';

	/************/
	/* COMMENTS */
	/************/
	
	comment_single_line = comment_s (not_slash inputs?)?;
	comment_multiple_lines = comment_l not_star* ('*' (not_star_not_slash not_star*)?)* comment_r;

	/************/
    /* LITERALS */
    /************/

	int_literal = int_const;
	double_literal = double_const;
	string_literal = string_const;
	bool_literal = true | false;

	/**************/
    /* IDENTIFIER */
    /**************/

    identifier = letter (letter | digit)*;      // NOTE: also allows only '_' but as of Java 9 it is a reserved keyword

	/*********/
    /* LINES */
    /*********/
	
	line = line_terminator+;
	
	/*************/
	/* OPERATORS */
	/*************/
	
	/* ARITHMETIC */
	
    plus = '+';
	minus = '-';
    mult = '*';
	div = '/';
	mod = '%';
	equals = '=';
	
	/* COMPARE */
	
	cmp_equals = '==';
	cmp_smaller = '<';
	cmp_greater = '>';
	cmp_equals_smaller = '<=';
	cmp_equals_greater = '>=';
	cmp_not_equals = '!=';
	
	/* BOOLEAN */

	logical_or = '||';
	logical_and = '&&';
	logical_not = '!';
	
	/*********************/
	/* SPECIAL CHARACTER */
	/*********************/
	
	left_brace = '{';
	right_brace = '}';
	left_bracket = '[';
	right_bracket = ']';
	left_parenthesis = '(';
	right_parenthesis = ')';
	comma = ',';
	semicolon = ';';
	dot = point;
	white_spaces = white_space+;
	tabs = tab+;

Ignored Tokens
	white_spaces,
	line,
	comment_single_line,
	comment_multiple_lines,
	tabs;
	
Productions
    /********/
    /* FORM */
    /********/

    using { -> form } = using_symbol identifier semicolon namespace
                        { -> New form.using(namespace.form) } ;

    namespace { -> form } = namespace_symbol identifier left_brace class_c right_brace
                            { -> New form.namespace(class_c.form) } ;

    class_c { -> form } = class_symbol identifier left_brace main method* right_brace
                          { -> New form.class_c(main.form, [method]) };

    main { -> form } = static_symbol void_symbol main_symbol left_parenthesis
                       string_symbol left_bracket right_bracket args_symbol right_parenthesis left_brace
                       variable* statement* right_brace
                       { -> New form.main([variable], [statement]) };

    /************/
    /* LITERALS */
    /************/

    literal { -> literal } =
        {int}       int_literal        { -> New literal.int(int_literal) }  |
        {double}    double_literal     { -> New literal.double(double_literal) }  |
        {string}    string_literal     { -> New literal.string(string_literal) }  |
        {bool}      bool_literal       { -> New literal.bool(bool_literal) }  ;

    /*********/
    /* TYPES */
    /*********/

    type { -> type} =
        {int}       int_symbol      { -> New type.int() }  |
        {double}    double_symbol   { -> New type.double() }  |
        {string}    string_symbol   { -> New type.string() }  |
        {bool}      bool_symbol     { -> New type.bool() }  ;

    return_type { -> return_type} =
        {void}      void_symbol     { -> New return_type.void() } |
        {int}       int_symbol      { -> New return_type.int() } |
        {double}    double_symbol   { -> New return_type.double() } |
        {string}    string_symbol   { -> New return_type.string() } |
        {bool}      bool_symbol     { -> New return_type.bool() };

    /*************/
    /* VARIABLES */
    /*************/

    variable { -> variable } =
        {declaration}       type identifier semicolon
                            { -> New variable.declaration(type, identifier) } |
        {initialization}    type identifier equals logical_or_expression semicolon
                            { -> New variable.initialization(type, identifier, logical_or_expression.expression) };

    /***********/
    /* METHODS */
    /***********/

    // TODO: rename to functions because we are not in java.

    method { -> method } = static_symbol return_type identifier left_parenthesis parameters?
    right_parenthesis left_brace variable* statement* right_brace
    { -> New method(identifier, return_type, [parameters.parameter], [variable], [statement]) };

    /* PARAMETERS */

    parameter { -> parameter } = type identifier
                                 { -> New parameter(type, identifier) };

    parameters { -> parameter* } =  {single}    parameter
                                                { -> [parameter.parameter] } |
                                    {multiple}  parameters comma parameter
                                                { -> [parameters.parameter, parameter.parameter] };

    /***************/
    /* EXPRESSIONS */
    /***************/

    expression_arguments { -> expression* } =
        {single}               logical_or_expression
                               { -> [logical_or_expression.expression] } |
        {multiple}             expression_arguments comma logical_or_expression
                               { -> [expression_arguments.expression, logical_or_expression.expression] };

    primary_expression { -> expression } =
        {identifier}            identifier
                                { -> New expression.identifier(identifier) } |
        {literal}               literal
                                { -> New expression.literal(literal) } |

        {parenthesis}            left_parenthesis logical_or_expression right_parenthesis
        			            { -> New expression.parenthesis(logical_or_expression.expression) } ;

    function_expression { -> expression } =
        {primary}               primary_expression
                                { -> primary_expression.expression } |
        {function}              function_expression left_parenthesis expression_arguments? right_parenthesis  // NOTE: identifier should be allowed for function names, fix with FunctionChecker
                                { -> New expression.function(function_expression.expression, [expression_arguments.expression]) };

    unary_expression { -> expression } =
        {function}              function_expression
                                { -> function_expression.expression } |
        {plus}                  plus unary_expression
                                { -> New expression.plus(unary_expression.expression) } |
        {minus}                 minus unary_expression
                                { -> New expression.minus(unary_expression.expression) } |
        {not}                   logical_not unary_expression
                                { -> New expression.not(unary_expression.expression) };

    multiplicative_expression { -> expression } =
        {unary}                 unary_expression
                                { -> unary_expression.expression } |
        {mult}                  multiplicative_expression mult unary_expression
                                { -> New expression.mult(multiplicative_expression.expression,
                                                         unary_expression.expression) } |
        {div}                   multiplicative_expression div unary_expression
                                { -> New expression.div(multiplicative_expression.expression,
                                                        unary_expression.expression) } |
        {mod}                   multiplicative_expression mod unary_expression
                                { -> New expression.mod(multiplicative_expression.expression,
                                                        unary_expression.expression) };

    additive_expression { -> expression } =
        {multiplicative}        multiplicative_expression
                                { -> multiplicative_expression.expression } |
        {add}                   additive_expression plus multiplicative_expression
                                { -> New expression.add(additive_expression.expression,
                                                        multiplicative_expression.expression) } |
        {sub}                   additive_expression minus multiplicative_expression
                                { -> New expression.sub(additive_expression.expression,
                                                        multiplicative_expression.expression) };

    comparison_expression { -> expression } =
        {additive}              additive_expression
                                { -> additive_expression.expression } |
        {cmp_smaller}           comparison_expression cmp_smaller additive_expression
                                { -> New expression.cmp_smaller(comparison_expression.expression,
                                                                additive_expression.expression) } |
        {cmp_greater}           comparison_expression cmp_greater additive_expression
                                { -> New expression.cmp_greater(comparison_expression.expression,
                                                                additive_expression.expression) } |
        {cmp_equals_smaller}    comparison_expression cmp_equals_smaller additive_expression
                                { -> New expression.cmp_equals_smaller(comparison_expression.expression,
                                                                       additive_expression.expression) } |
        {cmp_equals_greater}    comparison_expression cmp_equals_greater additive_expression
                                { -> New expression.cmp_equals_greater(comparison_expression.expression,
                                                                       additive_expression.expression) };

    equality_expression { -> expression } =
        {comparison}            comparison_expression
                                { -> comparison_expression.expression } |
        {cmp_not_equals}        equality_expression cmp_not_equals comparison_expression
                                { -> New expression.cmp_not_equals(equality_expression.expression,
                                                                   comparison_expression.expression) } |
        {cmp_equals}            equality_expression cmp_equals comparison_expression
                                { -> New expression.cmp_equals(equality_expression.expression,
                                                               comparison_expression.expression) };

    logical_and_expression { -> expression } =
        {equality}              equality_expression
                                { -> equality_expression.expression } |
        {logical_and}           logical_and_expression logical_and equality_expression
                                { -> New expression.logical_and(logical_and_expression.expression,
                                                                equality_expression.expression) };

    logical_or_expression { -> expression } =
        {logical_and}           logical_and_expression
                                { -> logical_and_expression.expression } |
        {logical_or}            logical_or_expression logical_or logical_and_expression
                                { -> New expression.logical_or(logical_or_expression.expression,
                                				               logical_and_expression.expression) };

    /**************/
    /* STATEMENTS */
    /**************/

    write_line { -> statement } =
                    console_symbol dot write_line_symbol left_parenthesis logical_or_expression? right_parenthesis semicolon
                    { -> New statement.write_line(logical_or_expression.expression) };

    return { -> statement } =
        return_symbol logical_or_expression? semicolon
        { -> New statement.return(logical_or_expression.expression) };

    block { -> statement } = left_brace statement* right_brace
                             { -> New statement.block([statement]) };

    variable_assignment { -> statement } = identifier equals logical_or_expression semicolon
                                           { -> New statement.variable_assignment(identifier, logical_or_expression.expression) };

    expression_statement { -> statement } = logical_or_expression semicolon
                                            { -> New statement.call(logical_or_expression.expression) };

    other_statement { -> statement } =
        {empty}             semicolon
                            { -> New statement.empty() } |
        {assignment}        variable_assignment
                            { -> variable_assignment.statement } |
        {block}             block
                            { -> block.statement } |
        {call}              expression_statement
                            { -> expression_statement.statement } |
        {write_line}        write_line
                            { -> write_line.statement } |
        {return}            return
                            { -> return.statement };

    statement { -> statement } =
        {other_statement}   other_statement
                            { -> other_statement.statement } |
        {if}                if
                            { -> if.statement } |
        {if_else}           if_else
                            { -> if_else.statement } |
        {while}             while
                            { -> while.statement };

    embedded_statement_no_if { -> statement } =
        {other_statement} other_statement
                          { -> other_statement.statement } |
        {if_else}         if_else_no_if
                          { -> if_else_no_if.statement } |
        {while}           while_no_if
                          { -> while_no_if.statement };

    /**********************/
    /* CONTROL STRUCTURES */
    /**********************/

    if { -> statement } = if_symbol left_parenthesis logical_or_expression right_parenthesis statement
                          { -> New statement.if(logical_or_expression.expression, statement.statement) };

    if_else { -> statement } = if_symbol left_parenthesis logical_or_expression right_parenthesis embedded_statement_no_if
              else_symbol statement
              { -> New statement.if_else(logical_or_expression.expression, embedded_statement_no_if.statement, statement.statement) };

    if_else_no_if { -> statement } = if_symbol left_parenthesis logical_or_expression right_parenthesis [left]:embedded_statement_no_if
                    else_symbol [right]:embedded_statement_no_if
                    { -> New statement.if_else(logical_or_expression.expression, left.statement, right.statement) };

    while { -> statement } = while_symbol left_parenthesis logical_or_expression right_parenthesis statement
                             { -> New statement.while(logical_or_expression.expression, statement.statement) };

    while_no_if { -> statement } = while_symbol left_parenthesis logical_or_expression right_parenthesis embedded_statement_no_if
                                   { -> New statement.while(logical_or_expression.expression, embedded_statement_no_if.statement) };

Abstract Syntax Tree
    form =         {using} form |
                   {namespace} form |
                   {class_c} form [method_definitions]:method* |
                   {main} [variable_definitions]:variable* [statements]:statement*;

    parameter = type identifier;

    // TODO: rename to functions because we are not in java.

    method = identifier return_type [parameter_definitions]:parameter* [variable_definitions]:variable* [statements]:statement*;

    return_type =  {void} |
                   {int} |
                   {double} |
                   {string} |
                   {bool};

    type =         {int}    |
                   {double} |
                   {string} |
                   {bool};

    variable =     {declaration}     type identifier |
                   {initialization}  type identifier expression;

    literal = {int} int_literal | {double} double_literal | {string} string_literal | {bool} bool_literal;

    expression =   {logical_or}         [left]:expression [right]:expression |
                   {logical_and}        [left]:expression [right]:expression |
                   {cmp_not_equals}     [left]:expression [right]:expression |
                   {cmp_equals}         [left]:expression [right]:expression |
                   {cmp_smaller}        [left]:expression [right]:expression |
                   {cmp_greater}        [left]:expression [right]:expression |
                   {cmp_equals_smaller} [left]:expression [right]:expression |
                   {cmp_equals_greater} [left]:expression [right]:expression |
                   {sub}                [left]:expression [right]:expression |
                   {add}                [left]:expression [right]:expression |
                   {mod}                [left]:expression [right]:expression |
                   {div}                [left]:expression [right]:expression |
                   {mult}               [left]:expression [right]:expression |
                   {not}                expression |
                   {minus}              expression |
                   {plus}               expression |
                   {parenthesis}        expression |
                   {function}           [function]:expression [parameters]:expression* |
                   {identifier}         identifier |
                   {literal}            literal;

    statement =    {block}                  statement*  |
                   {write_line}             expression? |
                   {call}                   expression  | // NOTE: only function calls should be allowed, but grammar allows every expression, fix with StatementChecker
                   {return}                 expression? |
                   {variable_assignment}    identifier expression |
                   {if}                     expression statement |
                   {if_else}                expression [left]:statement [right]:statement |
                   {while}                  expression statement |
                   {empty};