Package org.sablecc.sablecc.minijava;

Helpers
all = [0 .. 0xffff];
letter = [['a'..'z']+['A'..'Z']];
digit = ['0'..'9'];

cr = 13;
lf = 10;
not_cr_lf = [all - [cr + lf]];

line_comment = '//' not_cr_lf* (cr | lf | cr lf)?;
not_star = [all - '*'];
not_star_slash = [not_star - '/'];

string_char = [not_cr_lf - '"'];

Tokens

assign     = '=';
l_par      = '(';
r_par      = ')';
l_brace    = '{';
r_brace    = '}';
l_bracket  = '[';
r_bracket  = ']';
semi_colon = ';';
dot        = '.';
excl_mark  = '!';
plus       = '+';
minus      = '-';
star       = '*';
lt         = '<';
and        = '&&';
comma      = ',';

class              = 'class';
public             = 'public';
static             = 'static';
void               = 'void';
main               = 'main';
string             = 'String';
return             = 'return';
int                = 'int';
boolean            = 'boolean';
if                 = 'if';
else               = 'else';
while              = 'while';
systemoutprintln   = 'System.out.println';
length             = 'length';
true               = 'true';
false              = 'false';
this               = 'this';
new                = 'new';

comment = line_comment |
          '/*' not_star* '*'+ (not_star_slash not_star* '*'+)* '/';
blank = (' ' | cr | lf | 9)+;

id  = letter (letter | digit | '_')*;
integer_literal = digit+;


Ignored Tokens

comment, blank;


Productions

    program {->program} = main_class class_decl* {->New program(main_class, [class_decl.class_def])};

    main_class {->main_class} =
        {class_main} [class_main]:class [id_class]:id [l_brace1]:l_brace public static void main l_par string l_bracket r_bracket [id_arg]:id r_par [l_brace2]:l_brace statement [r_brace1]:r_brace [r_brace2]:r_brace {-> New main_class.class_main(id_class, id_arg, statement)};

    class_decl {->class_def} =
        {class_def}  [class_def]:class [var]:id l_brace var_decl_g* method_decl* r_brace {->New class_def(var, [var_decl_g], [method_decl])};

    var_decl_g {->var_decl_g} = type [var]:id semi_colon {->New var_decl_g(type, var)};

    method_decl {->method_decl} = public type [var]:id l_par formal_list r_par l_brace var_decl_l* statement* return exp semi_colon r_brace {->New method_decl(type, var, formal_list, [var_decl_l], [statement], exp)};

    var_decl_l {->var_decl_l} = type [var]:id semi_colon {->New var_decl_l(type, var)};

    formal_list {->formal_list} =
        {formal_rest}  type [var]:id formal_rests {->New formal_list.formal_rest(type, var, formal_rests)}|
        {empty}        {->New formal_list.empty()};

    formal_rests {->formal_rests} = 
        {formal_rests}  formal_rests formal_rest {->New formal_rests.formal_rests(formal_rests, formal_rest.formal)}|
        {empty}         {->New formal_rests.empty()};

    formal_rest {->formal} = comma type [var]:id {->New formal(type, var)};

    type {->type} =
        {boolean}   boolean {->New type.boolean(boolean)}|
        {int}       int {->New type.int(int)}|
        {id}        [var]:id {->New type.id(var)};

    statement {->statement} =
        {stmt}         l_brace statement* r_brace {->New statement.stmt([statement])}|
        {if}           if l_par exp r_par [statement_if]:statement else [statement_else]:statement {->New statement.if(exp, statement_if, statement_else)}|
        {while}        while l_par exp r_par statement {->New statement.while(exp, statement)}|
        {print}        systemoutprintln l_par exp r_par semi_colon {->New statement.print(exp)}|
        {assign_id}    [var]:id assign exp semi_colon {->New statement.assign_id(var, exp)};

    exp {->exp} =
        {and}        exp and cmp {->New exp.and(exp.exp, cmp.exp)} |
        {exp_list}   exp dot [var]:id l_par exp_list r_par {->New exp.exp_list(exp, var, exp_list)}|
        {new_id}     new [var]:id l_par r_par {->New exp.new_id(var)}|
        {cmp}        cmp {->cmp.exp};

    cmp {->exp} =
        {lt}         cmp lt arith {->New exp.lt(cmp.exp, arith.exp)} |
        {arith}      arith {->arith.exp};

    arith {->exp} =
        {plus}       arith plus facteur {->New exp.plus(arith.exp, facteur.exp)}|
        {minus}      arith minus facteur {->New exp.minus(arith.exp, facteur.exp)}|
        {facteur}    facteur {->facteur.exp};

    facteur {->exp} =
        {star}       facteur star bin_op {->New exp.star(facteur.exp, bin_op.exp)} |
        {bin_op}     bin_op {->bin_op.exp};

    bin_op {->exp} =
        {excl}       excl_mark bin_op {->New exp.excl(bin_op.exp)}|
        {base}       base_exp {->base_exp.exp};

    base_exp {->exp} =
        {integer}    integer_literal {->New exp.integer(integer_literal)}|
        {bool_true}  true {->New exp.bool_true(true)}|
        {bool_false} false {->New exp.bool_false(false)}|
        {id}         [var]:id {->New exp.id(var)}|
        {this}       this {->New exp.this(this)} |
        {par}        l_par exp r_par {-> exp.exp};

    exp_list {->exp_list} =
        {exp_rest}  exp exp_rests {->New exp_list.exp_rest(exp, exp_rests)}|
        {empty}     {->New exp_list.empty()};

    exp_rests {->exp_rests} = exp_rests exp_rest {->New exp_rests(exp_rests, exp_rest)};

    exp_rest {->exp_rest} = comma exp {->New exp_rest(exp)};

Abstract Syntax Tree

    program = main_class class_def*;

    main_class =
        {class_main} [id_class]:id [id_arg]:id statement ;

    class_def =  [var]:id var_decl_g* method_decl*;

    var_decl_g = type [var]:id;

    method_decl = type [var]:id formal_list var_decl_l* statement* exp ;

    var_decl_l = type [var]:id;

    formal_list =
        {formal_rest}  type [var]:id formal_rests |
        {empty}        ;

    formal_rests = 
        {formal_rests}  formal_rests formal |
        {empty}        ;

    formal = type [var]:id;

    type =
        {boolean}   boolean |
        {int}       int |
        {id}        [var]:id;

    statement =
        {stmt}         statement* |
        {if}           exp [statement_if]:statement [statement_else]:statement |
        {while}        exp statement |
        {print}        exp |
        {assign_id}    [var]:id exp ;

    exp =
        {plus}       [l]:exp [r]:exp |
        {minus}      [l]:exp [r]:exp |
        {exp_list}   exp [var]:id exp_list |
        {new_id}     [var]:id|
        {star}       [l]:exp [r]:exp |
        {integer}    integer_literal |
        {bool_true}  true |
        {bool_false} false |
        {id}         [var]:id |
        {this}       this |
        {excl}       exp |
        {and}        [l]:exp [r]:exp |
        {lt}         [l]:exp [r]:exp ;

    exp_list =
        {exp_rest}  exp exp_rests |
        {empty}     ;

    exp_rests = exp_rests exp_rest;

    exp_rest = exp;