Helpers

  all = [0 .. 0xFFFF];
  sp = ' ';
  newline = 0x000a;
  cr = 0x000d;
  ff = 0x000c;
  ht = 0x0009;
  line_terminator = newline | cr | cr newline;
  white_space = (sp | ht | ff | line_terminator)*;

  //newline = 10;
  //cr = 13;
  //space = ' ';
  //tab = 9;
  //all = [0 .. 0xFFFF];
  eol = cr newline | cr | newline;
  not_cr_lf = [all - [cr + newline]];

  and = 'and';
  if = 'if';
  char = 'char';
  div = 'div';
  do = 'do';
  else = 'else';
  fun = 'fun';
  int = 'int';
  mod = 'mod';
  not = 'not';
  nothing = 'nothing';
  or = 'or';
  ref = 'ref';
  return = 'return';
  then = 'then';
  var = 'var';
  while = 'while';
  andor = and | or;

  plus   = '+';
  minus  = '-';
  times  = '*';
  over   = '/';
  backs = '\';
  semicolon = ';';
  lparen = '(';
  rparen = ')';
  aut =  ''';
  daut = '"';
  ques = '?';
  excl = '!';
  hashtag = '#';
  equal = '=';
  sm = '<';
  big = '>';
  sme = '<=';
  bige = '>=';
  lsbr = '[';
  rsbr = ']';
  lbr = '{';
  rbr = '}';
  com = ',';
  colon = ':';
  ass = '<-';
  dollar = '$';

  letter = ['a'..'z'] | ['A'..'Z'];
  num = ['0'..'9'];
  alnum = letter | num | '_';
  hex_num = num | ['a'..'f'] | ['A'..'F'] ;
  stat = aut aut | ''' letter ''' | ''' num ''' | aut '\''n' aut | aut '\''t' aut | aut '\''r' aut |
  aut '\''0' aut | aut '\''\' aut | aut '\'''' aut | aut '\''"' aut | aut '\''x'hex_num hex_num aut ;

  escape_sequencies = '\''n' | '\''t' | '\''r' | '\''0' | '\''\' | '\'''' | '\''"' | '\''x'hex_num hex_num ;
  char_str = [all - '"'];
  char_str1 = [char_str - '+'];
  char_str2 = [char_str - '='];
  string_literal = '"' (letter | num | escape_sequencies | white_space | char_str2 )+ '"';
  comment1 = dollar not_cr_lf* eol;
  t1 = [all - '$'];
  comment2 = (dollar dollar ( all? t1 )* dollar dollar) |
             (dollar dollar string_literal* dollar dollar);
  double_dollar = dollar dollar;

Tokens

  and = and;
  if = if;
  char = char;
  div = div;
  do = do;
  else = else;
  fun = fun;
  int = int;
  mod = mod;
  not = not;
  nothing = nothing;
  or = or;
  ref = ref;
  return = return;
  then = then;
  var = var;
  while = while;

  plus   = plus;
  minus  = minus;
  times  = times;
  over   = over;
  backs = backs;
  semicolon = semicolon;
  lparen = lparen;
  rparen = rparen;
  aut = aut;
  daut = daut;
  ques = ques;
  excl = excl;
  hashtag = hashtag;
  equal = equal;
  sm = sm;
  big = big;
  sme = sme;
  bige = bige;
  lsbr = lsbr;
  rsbr = rsbr;
  lbr = lbr;
  rbr = rbr;
  com = com;
  colon = colon;
  ass = ass;
  dollar = dollar;

  //letter = letter;
  id = letter alnum*;
  int_const = num+;
  erroneous_number = (num)+ (letter|'_')+;
  char_const = stat;
  string_literal = string_literal;
  compsymbols = equal | hashtag | sm | big | sme | bige;
  calc = plus | minus | times | div | mod | over;

  andor = andor;
  plusminus = plus | minus;

  white_space = white_space;
  comment1 = comment1;
  comment2 = comment2;

  plus_or_minus = (plus | minus)+ ;

Ignored Tokens

  white_space, comment2, comment1;

Productions

  program {-> program}     = {fundef} func_def  {->New program(func_def)} ;

  func_def {-> func_def}   = {header} header local_def* block {->New func_def(header, [local_def], block)};

  sempar {-> sempar}       = {sempar} semicolon fpar_def {->New sempar(semicolon, fpar_def.fpar_def)};

  param {-> param}        = {param1} fpar_def? {->New param.param1(fpar_def)} |
                            {param2} fpar_def sempar* {->New param.param2(fpar_def, [sempar])};

  header {-> header}       = {fun} fun id lparen param rparen colon ret_type {->New header(fun, id, lparen, param, rparen, colon, ret_type)};

  comid {-> comid}         = {comi} com id {->New comid(com, id)};

  fpar_def {-> fpar_def}   = {ref} ref? id comid* colon fpar_type {->New fpar_def(ref, id, [comid], colon, fpar_type)};

  data_type {-> data_type} = {int} int {->New data_type.int(int)} |
                             {char} char {->New data_type.char(char)} ;

  intcon {-> intcon}       = {intcon} lsbr int_const rsbr {->New intcon(lsbr, int_const, rsbr)};

  type {-> type}           = data_type intcon* {->New type(data_type, [intcon])};

  ret_type {-> ret_type}   = {data_type} data_type {->New ret_type.data_type(data_type)} |
                             {nothing} nothing {->New ret_type.nothing(nothing)};

  sqbrac {-> sqbrac}       = {brac} lsbr rsbr {->New sqbrac(lsbr, rsbr)};

  fpar_type {-> fpar_type} = data_type sqbrac? intcon* {->New fpar_type(data_type, sqbrac, [intcon])};

  local_def {-> local_def} = {func_def} func_def {->New local_def.func_def(func_def)} |
                             {func_decl} func_decl {->New local_def.func_decl(func_decl)} |
                             {var_def} var_def {->New local_def.var_def(var_def)};

  var_def {-> var_def}     = {var} var id  comid* colon type semicolon {->New var_def(var, id, [comid], colon, type, semicolon)};

  func_decl {-> func_decl} = header semicolon {->New func_decl(header, semicolon)};

  //elstmt {-> stmt*}  = {elstmt} else stmt {->New stmt.elstmt([stmt.stmt])};

  stmt_list {-> stmt}  = {stmt_list} stmt* {->New stmt.stmt_list([stmt])};

  stmt {-> stmt}       = {statement} statement {->New stmt.statement(statement.stmt)};

  statement {-> stmt}  = {semi} semicolon {->New stmt.semi()} |
                         {l_value} l_value ass expr semicolon {->New stmt.l_value(l_value, expr)} |
                         {block} block {->New stmt.block(block)} |
                         {func} func_call semicolon {->New stmt.func(func_call)} |
                         {if} if_stmt {->New stmt.if(if_stmt.stmt)} |
                         {block1} lparen stmt_list rparen {->New stmt.block1(stmt_list.stmt)} |
                         {while} while cond do stmt {->New stmt.while(cond, stmt)} |
                         {return} return expr? semicolon {->New stmt.return(expr)};

  if_stmt {-> stmt}   = {no_else} if cond then [then_stmt]:stmt {->New stmt.no_else(cond, then_stmt.stmt)} |
                        {witha_else} if cond then [then_stmt]:stmt_with_else else [else_stmt]:stmt {->New stmt.witha_else(cond, then_stmt.stmt, else_stmt.stmt)};

  stmt_with_else {-> stmt} = {noop} semicolon {->New stmt.semi()} |
                             {assignment} l_value ass expr semicolon {->New stmt.assignment(l_value, expr)} |
                             {f_call} func_call semicolon {->New stmt.f_call(func_call)} |
                             {return1} return expr? semicolon {->New stmt.return1(expr)} |
                             {ifasas} if_else_stmt {->New stmt.ifasas(if_else_stmt.stmt)} |
                             {block2} lparen stmt_list rparen {->New stmt.block2(stmt_list.stmt)} |
                             {block3} block {->New stmt.block3(block)};

  if_else_stmt {-> stmt}   = {if_else_stmt} if cond then [then_stmt]:stmt_with_else else [else_stmt]:stmt_with_else
                             {->New stmt.if_else_stmt(cond, then_stmt.stmt, else_stmt.stmt)};

  block {-> block}         = {block} lbr stmt* rbr {->New block.block([stmt])};

  comexpr {-> comexpr}     = {comexp} com expr {->New comexpr(com, expr)};

  expcom {-> expcom}       = {expcom} expr comexpr* {->New expcom(expr, [comexpr])};

  func_call {-> func_call} = id lparen expcom? rparen {->New func_call(id, lparen, expcom, rparen)};

  l_value {-> l_value}     = {id} id {->New l_value.id(id)} |
                             {string_literal} string_literal {->New l_value.string_literal(string_literal)} |
                             {l_value1} l_value lsbr expr rsbr {->New l_value.l_value1(l_value, lsbr, expr, rsbr)};

  expr5 {-> expr}  = {expr5a} int_const {->New expr.expr5a(int_const)} |
                     {expr5b} char_const {->New expr.expr5b(char_const)} |
                     {expr5c} l_value {->New expr.expr5c(l_value)} |
                     {expr5d} func_call {->New expr.expr5d(func_call)};

  expr2 {-> expr}  = {expr2a} plus_or_minus expr5 {->New expr.expr2a(expr5.expr)} |
                     {expr2_minus} minus expr5 {->New expr.expr2_minus(expr5.expr)} |
                     {expr2_plus} plus expr5 {->New expr.expr2_plus(expr5.expr)} |
                     {expr2c} times expr5 {->New expr.expr2c(expr5.expr)} |
                     {expr2d} over expr5 {-> New expr.expr2d(expr5.expr)} |
                     {expr2e} mod expr5 {->New expr.expr2e(expr5.expr)} |
                     {expr2f} div expr5 {->New expr.expr2f(expr5.expr)};

  expr3 {-> expr}  = {expr3a} plus_or_minus lparen expr rparen {->New expr.expr3a(expr)} |
                     {expr3_minus} minus lparen expr rparen {->New expr.expr3_minus(expr)} |
                     {expr3_plus} plus lparen expr rparen {->New expr.expr3_plus(expr)} |
                     {expr3c} times lparen expr rparen {->New expr.expr3c(expr)} |
                     {expr3d} over lparen expr rparen {->New expr.expr3d(expr)} |
                     {expr4e} mod lparen expr rparen {->New expr.expr4e(expr)} |
                     {expr5f} div lparen expr rparen {->New expr.expr5f(expr)};

  expr4 {-> expr}  = {expr4a} lparen expr rparen expr3* {->New expr.expr4a(expr, [expr3.expr])} |
                     {expr4b} lparen expr rparen expr2* {->New expr.expr4b(expr, [expr2.expr])};

  expr1 {-> expr}  = {expr1a} expr5 expr2* {->New expr.expr1a(expr5.expr, [expr2.expr])} |
                     {expr1b} expr4 {->New expr.expr1b(expr4.expr)} |
                     {expr1c} expr5 expr3* {->New expr.expr1c(expr5.expr, [expr3.expr])} |
                     {expr1d} plus_or_minus expr5 expr2* {->New expr.expr1d(expr5.expr, [expr2.expr])} |
                     {expr1e} plus expr5 expr2* {->New expr.expr1e(expr5.expr, [expr2.expr])} |
                     {expr1f} minus expr5 expr2* {->New expr.expr1f(expr5.expr, [expr2.expr])};

  expr {-> expr}   = {calc} expr1 {->New expr.calc(expr1.expr)};

  simple_cond {-> cond} = {comp1} [left]:expr equal [right]:expr {->New cond.comp1(left.expr, right.expr)} |
                          {comp2} [left]:expr hashtag [right]:expr {->New cond.comp2(left.expr, right.expr)} |
                          {comp3} [left]:expr sm [right]:expr {->New cond.comp3(left.expr, right.expr)} |
                          {comp4} [left]:expr big [right]:expr {->New cond.comp4(left.expr, right.expr)} |
                          {comp5} [left]:expr sme [right]:expr {->New cond.comp5(left.expr, right.expr)} |
                          {comp6} [left]:expr bige [right]:expr {->New cond.comp6(left.expr, right.expr)};

  mul_cond {-> cond} = {mul_cond1} [left]:simple_cond and [right]:simple_cond {->New cond.mul_cond1(left.cond, right.cond)} |
                       {mul_cond2} [left]:simple_cond or [right]:simple_cond {->New cond.mul_cond2(left.cond, right.cond)};

  not_c {-> cond} =  {notc} not condit {->New cond.notc(condit.cond)};

  cond {-> cond}  =  {cond} condit {->New cond.cond(condit.cond)};

  con  {-> cond}  =  {simple} simple_cond {->New cond.simple(simple_cond.cond)} |
                     {mul} mul_cond {->New cond.mul(mul_cond.cond)};

  condit {-> cond}  =  {condit1} lparen condit rparen {->New cond.condit1(condit.cond)} |
                       {not} not_c {->New cond.not(not_c.cond)} |
                       {mul_cond}  mul_cond {->New cond.mul_cond(mul_cond.cond)} |
                       {cond1} [left]:expr equal [right]:expr {->New cond.cond1(left.expr, right.expr)} |
                       {cond2} [left]:expr hashtag [right]:expr {->New cond.cond2(left.expr, right.expr)}|
                       {cond3} [left]:expr sm [right]:expr {->New cond.cond3(left.expr, right.expr)}|
                       {cond4} [left]:expr big [right]:expr {->New cond.cond4(left.expr, right.expr)}|
                       {cond5} [left]:expr sme [right]:expr {->New cond.cond5(left.expr, right.expr)}|
                       {cond6} [left]:expr bige [right]:expr {->New cond.cond6(left.expr, right.expr)}|
                       {m_cond_and} [left]:con and [right]:con {->New cond.m_cond_and(left.cond, right.cond)}|
                       {m_cond_or} [left]:con or [right]:con {->New cond.m_cond_or(left.cond, right.cond)};


Abstract Syntax Tree
  program  = func_def;

  func_def = header local_def* block;

  sempar   = semicolon fpar_def ;

  param ={param1} fpar_def?  |
         {param2} fpar_def sempar* ;

  header = fun id lparen param rparen colon ret_type ;

  comid = com id ;

  fpar_def = ref? id comid* colon fpar_type;

  data_type  = {int} int |
               {char} char ;

  intcon = lsbr int_const rsbr;

  type = data_type intcon*;

  ret_type = {data_type} data_type |
             {nothing} nothing;

  sqbrac = lsbr rsbr ;

  fpar_type = data_type sqbrac? intcon* ;

  local_def = {func_def} func_def |
              {func_decl} func_decl |
              {var_def} var_def ;

  var_def = var id  comid* colon type semicolon ;

  func_decl = header semicolon ;
/*
  elstmt = else stmt ;

  stmt_list = stmt* ;
*/
  stmt = {statement} stmt |
         {stmt_list} stmt* |
         {semi} |
         {l_value} l_value expr |
         {block} block |
         {func} func_call |
         {if} stmt |
         {block1} stmt |
         {while} cond stmt |
         {return} expr? |
         {no_else} cond [then_stmt]:stmt |
         {witha_else} cond [then_stmt]:stmt [else_stmt]:stmt |
         {noop} |
         {assignment} l_value expr  |
         {f_call} func_call |
         {return1}  expr? |
         {ifasas} stmt |
         {block2} stmt |
         {block3} block |
         {if_else_stmt} cond [then_stmt]:stmt [else_stmt]:stmt;

//  if_el = {witha_else} | {if_else_stmt};
/*
  statement = {semicolon} semicolon |
              {l_value} l_value ass expr semicolon |
              {block} block |
              {func} func_call semicolon |
              {if} if_stmt |
              {block1} lparen stmt_list rparen |
              {while} while cond do stmt |
              {return} return expr? semicolon;

  if_stmt  = {no_else} if cond then [then_stmt]:stmt |
             {witha_else} if cond then [then_stmt]:stmt_with_else else [else_stmt]:stmt;

  stmt_with_else = {noop} semicolon |
                   {assignment} l_value ass expr semicolon |
                   {f_call} func_call semicolon |
                   {return} return expr? semicolon |
                   {ifasas} if_else_stmt |
                   {block} lparen stmt_list rparen |
                   {block1} block;

  if_else_stmt = if cond then [then_stmt]:stmt_with_else else [else_stmt]:stmt_with_else;
*/
  block = {block} stmt* ;

  comexpr = com expr;

  expcom = expr comexpr*;

  func_call = id lparen expcom? rparen;

  l_value = {id} id |
            {string_literal} string_literal |
            {l_value1} l_value lsbr expr rsbr;

//  expr5 = {expr5a} int_const |
//          {expr5b} char_const |
//          {expr5c} l_value |
//          {expr5d} func_call;

//  expr2 = {expr2a} plus_or_minus expr5 |
//          {expr2c} times expr5 |
//          {expr2d} over expr5 |
//          {expr2e} mod expr5 |
//          {expr2f} div expr5;

//  expr3 =  {expr3a} plus_or_minus lparen expr rparen |
//           {expr3c} times lparen expr rparen |
//           {expr3d} over lparen expr rparen |
//           {expr4e} mod lparen expr rparen |
//           {expr5f} div lparen expr rparen;

//  expr4 = {expr4a} lparen expr rparen expr3* |
//          {expr4b} lparen expr rparen expr2*;

//  expr1 = {expr1a} expr5 expr2* |
//          {expr1b} expr4 |
//          {expr1c} expr5 expr3* |
//          {expr1d} plus_or_minus expr5 expr2*;

  expr = {expr5a} int_const |
         {expr5b} char_const |
         {expr5c} l_value |
         {expr5d} func_call |
         {expr2a} expr |
         {expr2_minus} expr|
         {expr2_plus} expr |
         {expr2c} expr |
         {expr2d} expr |
         {expr2e} expr |
         {expr2f} expr |
         {expr3a} expr |
         {expr3_minus} expr |
         {expr3_plus} expr |
         {expr3c} expr |
         {expr3d} expr |
         {expr4e} expr |
         {expr5f} expr |
         {expr4a} [left]:expr [right]:expr* |
         {expr4b} [left]:expr [right]:expr* |
         {expr1a} [left]:expr [right]:expr* |
         {expr1b} expr |
         {expr1c} [left]:expr [right]:expr* |
         {expr1d} [left]:expr [right]:expr* |
         {expr1e} [left]:expr [right]:expr* |
         {expr1f} [left]:expr [right]:expr* |
         {calc}   expr;
/*
  simple_cond = {comp1} [left]:expr equal [right]:expr |
                {comp2} [left]:expr hashtag [right]:expr |
                {comp3} [left]:expr sm [right]:expr |
                {comp4} [left]:expr big [right]:expr |
                {comp5} [left]:expr sme [right]:expr |
                {comp6} [left]:expr bige [right]:expr;

  mul_cond = {mul_cond1} [left]:simple_cond and [right]:simple_cond |
             {mul_cond2} [left]:simple_cond or [right]:simple_cond;

  not_c  = not condit;
*/
  cond  = {cond} cond |
          {comp1} [left]:expr [right]:expr |
          {comp2} [left]:expr [right]:expr |
          {comp3} [left]:expr [right]:expr |
          {comp4} [left]:expr [right]:expr |
          {comp5} [left]:expr [right]:expr |
          {comp6} [left]:expr [right]:expr |
          {mul_cond1} [left]:cond [right]:cond |
          {mul_cond2} [left]:cond [right]:cond |
          {notc} cond |
          {simple} cond |
          {mul} cond |
          {condit1} cond  |
          {not} cond |
          {mul_cond} cond |
          {cond1} [left]:expr [right]:expr |
          {cond2} [left]:expr [right]:expr |
          {cond3} [left]:expr [right]:expr |
          {cond4} [left]:expr [right]:expr |
          {cond5} [left]:expr [right]:expr |
          {cond6} [left]:expr [right]:expr |
          {m_cond_and} [left]:cond [right]:cond |
          {m_cond_or} [left]:cond [right]:cond;
/*
  con  = {simple} simple_cond |
         {mul} mul_cond;

  condit = {condit1} lparen condit rparen |
           {not} not_c |
           {mul_cond}  mul_cond |
           {cond1} [left]:expr equal [right]:expr |
           {cond2} [left]:expr hashtag [right]:expr |
           {cond3} [left]:expr sm [right]:expr |
           {cond4} [left]:expr big [right]:expr |
           {cond5} [left]:expr sme [right]:expr |
           {cond6} [left]:expr bige [right]:expr |
           {m_cond_and} [left]:con and [right]:con |
           {m_cond_or} [left]:con or [right]:con;
*/