minipython.grammar

Package minipython;

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

Tokens
    tab = 9;
    plus = '+';
    minus = '-';
    mult = '*';
    div = '/';
    mod = '%';
    pow = '**';
    assign = '=';
    min_eq = '-=';
    div_eq = '/=';
    eq = '==';
    not_eq = '!=';
    l_par = '(';
    r_par = ')';
    l_br = '[';
    r_br = ']';
    comma = ',';
    dot = '.';
    if = 'if';
    print = 'print';
    less = '<';
    less_eq = '<=';
    great = '>';
    great_eq = '>=';
    and = 'and';
    or = 'or';
    not = 'not';
    while = 'while';
    for = 'for';
    in = 'in';
    def = 'def';
    return = 'return';
    assert = 'assert';
    import = 'import';
    len = 'len';
    ascii = 'ascii';
    max = 'max';
    min = 'min';
    as = 'as';
    from = 'from';
    semi = ':';
    true = 'true';
    false = 'false';
    else = 'else';
    none = 'None';
    quote = '"';
    blank = (' ' | lf | cr);
    line_comment = '#' not_eol* eol;
    number = '-'? digit+ ('.' digit+)?;
    string = '"' not_eol* '"' | '''not_eol* ''';
    id = letter (letter | digit)*;

Ignored Tokens
    blank, line_comment;

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

    commands = {function} function {-> New commands.function(function)} | {statement} statement {-> New commands.statement(statement)};

    function = def id l_par argument? r_par semi statement {-> New function(id,[argument],statement)};

    argument = id assign_value? comma_assign* {-> New argument(id,[assign_value],[comma_assign])};

    assign_value = assign value {-> New assign_value(value)};

    comma_assign = comma id assign_value? {-> New comma_assign(id,[assign_value])};

    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 [for_id]:id in [in_id]:id semi statement {-> New statement.for(for_id,in_id,statement)}
        | {return} tab* return expression {-> New statement.return(expression)}
        | {print} tab* print expression comma_expression* {-> New statement.print(expression,[comma_expression])}
        | {assign} tab* id assign expression {-> New statement.assign(id,expression)}
        | {assign_min} tab* id min_eq expression {-> New statement.assign_min(id,expression)}
        | {assign_div} tab* id div_eq expression {-> New statement.assign_div(id,expression)}
        | {list_assignment} tab* id l_br [br_expression]:expression r_br assign [eq_expression]:expression {-> New statement.list_assignment(id,br_expression,eq_expression)}
        | {assert} tab* assert expression comma_expression? {-> New statement.assert(expression,[comma_expression])}
        | {function_call} tab* function_call {-> New statement.function_call(function_call)}
        | {import} tab* import_statement {-> New statement.import(import_statement)};

    comparison = logical_or {-> New comparison(logical_or)};

    logical_or = {or} logical_or or logical_and {-> New logical_or.or(logical_or,logical_and.logical_or)}
        | {and} logical_and {->logical_and.logical_or};

    logical_and{->logical_or} = {and} logical_and and logical_not {-> New logical_or.and(logical_and.logical_or,logical_not.logical_or)}
        | {not} logical_not {->logical_not.logical_or};

    logical_not{->logical_or} = {not} not logical_not {-> New logical_or.not(logical_not.logical_or)}
        | {relational} relational_comparison {-> relational_comparison.logical_or};

    relational_comparison{->logical_or} = {great} [exp_l]:expression great [exp_r]:expression {-> New logical_or.great(exp_l,exp_r)}
        | {less} [exp_l]:expression less [exp_r]:expression {-> New logical_or.less(exp_l,exp_r)}
        | {great_eq} [exp_l]:expression great_eq [exp_r]:expression {-> New logical_or.great_eq(exp_l,exp_r)}
        | {less_eq} [exp_l]:expression less_eq [exp_r]:expression {-> New logical_or.less_eq(exp_l,exp_r)}
        | {not_eq} [exp_l]:expression not_eq [exp_r]:expression {-> New logical_or.not_eq(exp_l,exp_r)}
        | {eq} [exp_l]:expression eq [exp_r]:expression {-> New logical_or.eq(exp_l,exp_r)}
        | {true} true {-> New logical_or.true()}
        | {false} false {-> New logical_or.false()};



    expression = {plus} expression plus term {-> New expression.plus(expression,term.expression)}
        | {minus} expression minus term {-> New expression.minus(expression,term.expression)}
        | {term} term {-> term.expression};

    term{->expression} = {mult} term mult factor {-> New expression.mult(term.expression,factor.expression)}
        | {div} term div factor {-> New expression.div(term.expression, factor.expression)}
        | {mod} term mod factor {-> New expression.mod(term.expression,factor.expression)}
        | {factor} factor {-> factor.expression};

    factor{->expression} = {power} base pow factor {-> New expression.power(base.expression,factor.expression)}
        | {base} base {->base.expression};

    base{->expression} = {paren_exp} l_par expression r_par {-> New expression.paren_exp(expression)}
        | {value} value {-> New expression.value(value)}
        | {identifier} id {-> New expression.identifier(id)}
        | {function_call} function_call {-> New expression.function_call(function_call)}
        | {indexing} id l_br expression r_br {-> New expression.indexing(id,expression)}
        | {brackets_exp} l_br value comma_value* r_br {-> New expression.brackets_exp(value,[comma_value])}
        | {len} len l_par expression r_par {-> New expression.len(expression)}
        | {ascii} ascii l_par id r_par {-> New expression.ascii(id)}
        | {max} max l_par value comma_value* r_par {-> New expression.max(value,[comma_value])}
        | {min} min l_par value comma_value* r_par {-> New expression.min(value,[comma_value])};

    import_statement = {import_as} import module as_id? comma_module_as_id* {-> New import_statement.import_as(module,[as_id],[comma_module_as_id])}
        | {from_import_as} from module import id as_id? comma_id_as_id? {-> New import_statement.from_import_as(module,id,[as_id],[comma_id_as_id])};

    module = id_dot* id {-> New module([id_dot],id)};

    function_call= id l_par arglist? r_par {-> New function_call(id,[arglist])};

    arglist = expression comma_expression* {-> New arglist(expression,[comma_expression])};

    value = {function_call_value} id dot function_call {-> New value.function_call_value(id,function_call)}
    | {number_value} number {-> New value.number_value(number)}
    | {string_value} string {-> New value.string_value(string)}
    | {none_value} none {-> New value.none_value(none)};

    comma_expression = comma expression {-> New comma_expression(expression)};

    comma_value = comma value {-> New comma_value(value)};

    comma_module = comma module {-> New comma_module(module)};

    comma_module_as_id = comma module as id {-> New comma_module_as_id(module,id)};

    comma_id_as_id = comma [id1]:id as [id2]:id {-> New comma_id_as_id(id1,id2)};

    as_id = as id {-> New as_id(id)};

    id_dot = id dot {-> New id_dot(id)};

Abstract Syntax Tree
    goal = commands*;
    commands = {function} function | {statement} statement;
    function = id argument* statement;
    argument = id assign_value* comma_assign*;

    assign_value = value;
    comma_assign = id assign_value*;

    statement = {if} comparison statement
        | {while} comparison statement
        | {for} [for_id]:id [in_id]:id statement
        | {return} expression
        | {print} expression comma_expression*
        | {assign} id expression
        | {assign_min} id expression
        | {assign_div} id expression
        | {list_assignment} id [br_expression]:expression [eq_expression]:expression
        | {assert} expression comma_expression*
        | {function_call} function_call
        | {import} import_statement;

    comparison = logical_or;

    logical_or = {or} [l]:logical_or [r]:logical_or
        | {and} [l]:logical_or [r]:logical_or
        | {not} logical_or
        | {less} [exp_l]:expression [exp_r]:expression
        | {great} [exp_l]:expression [exp_r]:expression
        | {great_eq} [exp_l]:expression [exp_r]:expression
        | {less_eq} [exp_l]:expression [exp_r]:expression
        | {not_eq} [exp_l]:expression [exp_r]:expression
        | {eq} [exp_l]:expression [exp_r]:expression
        | {true}
        | {false};


    expression = {plus} [lpar]:expression [rpar]:expression
        | {minus} [lpar]:expression [rpar]:expression
        | {mult} [lpar]:expression [rpar]:expression
        | {div} [lpar]:expression [rpar]:expression
        | {mod} [lpar]:expression [rpar]:expression
        | {power} [lpar]:expression [rpar]:expression
        | {paren_exp} expression
        | {value} value
        | {identifier} id
        | {function_call} function_call
        | {indexing} id expression
        | {brackets_exp} value comma_value*
        | {len} expression
        | {ascii} id
        | {max} value comma_value*
        | {min} value comma_value*;

    import_statement = {import_as} module as_id* comma_module_as_id*
        | {from_import_as} module id as_id* comma_id_as_id*;

    module = id_dot* id;

    function_call = id arglist*;

    arglist = expression comma_expression*;

    value = {function_call_value} id function_call 
    | {number_value} number 
    | {string_value} string 
    | {none_value} none;

    comma_expression = expression;

    comma_value = value;

    comma_module = module;

    comma_module_as_id = module id;

    comma_id_as_id = [id1]:id [id2]:id;

    as_id = id;

    id_dot = id;