[PegGrammar(start,
  grammar
  {
    any            = ['\u0000'..'\uFFFF'];
    digit          = ['0'..'9'];
    spaces         = ' '*;
    num      : int = digit+ spaces;

    expr0          = opAdd / opSub / expr1;
    opAdd    : int = expr1 '+' spaces expr0;
    opSub    : int = expr1 '-' spaces expr0;

    expr1          = opDiv / opMul / expr2;
    opDiv    : int = expr2 '/' spaces expr1;
    opMul    : int = expr2 '*' spaces expr1;

    expr2    : int = num / brackets;

    brackets : int = ('(' spaces expr0 ')' spaces)

    start          = spaces expr0 spaces !any;
  })]
  class CalcGrammar
  {
    // этот обработчик вызывается после окончания разбора правила "num"
    num(digitsTok : TokenInfo, _spacesTok : TokenInfo) : int
    {
      int.Parse(digitsTok.GetString())
    }

    // этот обработчик вызывается после окончания разбора правила "brackets"
    brackets(_leftBracket : TokenInfo, _spaces1 : TokenInfo, expr0 : int, _rightBracket : TokenInfo, _spaces2 : TokenInfo) : int
    {
      expr0
    }

    // этот обработчик вызывается после окончания разбора правила "opAdd"
    opAdd(expr1 : int, _pluseTok : TokenInfo, _spaces : TokenInfo, expr0 : int) : int
    {
      expr1 + expr0
    }
  
    // Остальные правила опущены ...
  }

  internal variant Rule
  {
    | Choice         { rules : list[Rule]; }
    | Sequence       { rules : list[Rule]; }
    | Call           { name : string; }
    | RepeatMin      { minCount : int; rule : Rule; }
    | RepeatMinMax   { minCount : int; maxCount : int; rule : Rule; }
    | Chars          { chars : list[RangeSet]; }
    | Not            { rule : Rule; }
    | And            { rule : Rule; }
    | Capture        { name : string; argType : RuleType; retType : RuleType; rule : Rule; }
    | ExtensionPoint { name : string; }
...

macro operator @+ (expr1, expr2)
  associativity: left
  precedence:    less then: * great then: <<
{
  ...
}

public abstract class ParserBase
  {
    protected _text : string;
    protected _cache : System.Collections.Generic.Dictionary[int, int] = System.Collections.Generic.Dictionary();
    protected _captures : System.Collections.Generic.List[LRPEGCC.Capture] = System.Collections.Generic.List();        

    public Captures : System.Collections.Generic.List[LRPEGCC.Capture] 
    { 
      get { _captures } 
    }        

    public this(text : string)
    {
      _text = text;
    }    

    protected GetChar(pos : int) : char
    {
      _text[pos];
    }    

    protected CheckTextLength(pos : int) : bool
    {
      pos < _text.Length;
    }       

    public abstract Start() : int; 
  }

[PegGrammar(start,
  grammar
  {
    any       = ['\u0000'..'\uFFFF'];
    digit     = ['0'..'9'];
    spaces    = ' '*;
    num       = digit+ spaces;
    expr0     = opAdd / opSub / expr1;
    opAdd     = expr1 '+' spaces expr0;
    opSub     = expr1 '-' spaces expr0;
    expr1     = opDiv / opMul / expr2;
    opDiv     = expr2 '/' spaces expr1;
    opMul     = expr2 '*' spaces expr1;
    expr2     = num / ('(' spaces expr0 ')' spaces);
    start     = spaces (expr0 ";" spaces)+ !any;
  })]
  public class CalcParser : ParserBase
  {  
    public this(text : string)
    {
        base(text);
    }

    //обработчики...
  }

opAdd    : int = expr1 '+' spaces expr0;

mulOrDiv          = simplExpr (('*' / '/') simplExpr)*

any                    = ['\u0000'..'\uFFFF'];
digit                  = ['0'..'9'];
spaces                 = ' '*;
num             : Expr = digit+ spaces;
unaryMinus      : Expr = '-' simplExpr;
parenthesesExpr : Expr = '(' sumOrSub ')'
simplExpr       : Expr = num / parenthesesExpr / unaryMinus
mulOrDiv        : Expr = simplExpr (('*' / '/') simplExpr)*
sumOrSub        : Expr = mulOrDiv  (('+' / '-') mulOrDiv )*

num(digits : Token, _spaces : Token) : Expr
{
  Expr.Number(int.Parce(digits.GetString()))
}

unaryMinus(_minus : Token, simplExpr : Expr) : Expr
{
  Expr.UnaryMunus(simplExpr)
}

parenthesesExpr (_openBracket : Token, simplExpr : Expr, _closeBracket : Token) : Expr
{
  simplExpr
}

// !!! Для правила simplExpr нам не нужно писать обработчик, так как он может быть 
//     автоматически сформирован макросом (так как он просто возвращает результат
//     одного из своих подправил, которые обязаны иметь одинаковый тип возвращаемого значения)

mulOrDiv(simplExpr : Expr, addLoop : list[Token * Expr]) : Expr
{
  mutable expr = simplExpr;

  foreach ((token, secondExpr) in addLoop)
    if (token.GetChar() == '*') 
      expr = Expr.Mul(expr, secondExpr);
    else
      expr = Expr.Div(expr, secondExpr);
}

sumOrSub(simplExpr : Expr, addLoop : list[Token * Expr]) : Expr
{
  mutable expr = simplExpr;

  foreach ((token, secondExpr) in addLoop)
    if (token.GetChar() == '+') 
      expr = Expr.Add(expr, secondExpr);
    else
      expr = Expr.Sub(expr, secondExpr);
}

StartPos             : int      // смещение начала фрагмента от начала в символах
EndPos               : int      // смещение конца фрагмента от начала в символах
Location             : Location // местоположение в тексте в терминах строка/символ в строке (аналог Location из компилятора)
GetText()            : string   // возвращает текст распознанной области
GetChar()            : char     // возвращает первый символ распознанной области (или исключение)
GetChar(index : int) : char     // возвращает n-ый символ распознанной области (или исключение)

VD>any                    = ['\u0000'..'\uFFFF'];
VD>digit                  = ['0'..'9'];
VD>spaces                 = ' '*;
VD>num             : Expr = digit+ spaces;
VD>unaryMinus      : Expr = '-' simplExpr;
VD>parenthesesExpr : Expr = '(' sumOrSub ')'
VD>simplExpr       : Expr = num / parenthesesExpr / unaryMinus
VD>mulOrDiv        : Expr = simplExpr (('*' / '/') simplExpr)*
VD>sumOrSub        : Expr = mulOrDiv  (('+' / '-') mulOrDiv )*
VD>

digit                  = ['0'..'9'];
spaces                 = ' '*;
num             : Expr = digit+ spaces;
unaryMinus      : Expr = '-' spaces simplExpr;
parenthesesExpr : Expr = '(' spaces sumOrSub ')' spaces
simplExpr       : Expr = num / parenthesesExpr / unaryMinus
mulOrDiv        : Expr = simplExpr (('*' / '/') spaces simplExpr)*
sumOrSub        : Expr = mulOrDiv  (('+' / '-') spaces mulOrDiv )*

PegGramar(..., Ignore=spaces, ...)

    public Result : 'T
    {
      get
      {
        unless(_isParsed)
        {
            _parsedSymbolsCount = DoParse();
            _isParsed = true;
        }   
        _result
      }
      protected set
      {
        _result = value;
      }
    }

// TODO: Check is subclass of ParserBase

P>    protected CheckTextLength(pos : int) : bool
P>

P>    public this(text : string)
P>    {
P>        base(text);
P>    }
P>

[PegGrammar(start,
  grammar
  {    
    any            = ['\u0000'..'\uFFFF'];
    digit          = ['0'..'9'];
    spaces         = ' '*;
    num      : int = digit+ spaces;
    expr0          = opAdd / opSub / expr1;
    opAdd    : int = expr1 '+' spaces expr0;
    opSub    : int = expr1 '-' spaces expr0;
    expr1          = opDiv / opMul / expr2;
    opDiv    : int = expr2 '/' spaces expr1;
    opMul    : int = expr2 '*' spaces expr1;
    expr2    : int = num / brackets;
    brackets : int = ('(' spaces expr0 ')' spaces);
    start          = spaces expr0 spaces !any;
  })]
  public class CalcParser : ParserBase[int]
  {  
    public this(text : string)
    {
        base(text);
    }  
    protected override DoGenerateResult(symbols : list[int], ruleName : string) : int
    {
    | (_, "expr2") =>
         symbols.Nth(0)
    | (_, "brackets") =>
         symbols.Nth(0)
    | (_, "opMul") =>
         symbols.Nth(0) * symbols.Nth(1);
    | (_, "opDiv") =>
         symbols.Nth(0) / symbols.Nth(1);
    | (_, "opSub") =>
         symbols.Nth(0) - symbols.Nth(1);
    | (_, "opAdd") =>
         symbols.Nth(0) + symbols.Nth(1);
    |  _ =>
         throw Exception("sds");
    }  
    protected override DoGenerateResult(symbol : string, ruleName : string) : int
    {
      int.Parse(symbol)
    }
  }

mutable text = "1 - 2* 3 -4+5/(6- 7) ; ";

P>    protected override DoGenerateResult(symbols : list[int], ruleName : string) : int
P>    {
P>    | (_, "expr2") =>
P>         symbols.Nth(0)
P>...

any                    = ['\u0000'..'\uFFFF'];
digit                  = ['0'..'9'];
spaces                 = ' '*;
num             : Expr = digit+ spaces;
unaryMinus      : Expr = '-' spaces simplExpr;
parenthesesExpr : Expr = '(' spaces sumOrSub ')' spaces;
simplExpr       : Expr = num / parenthesesExpr / unaryMinus;
mulOrDiv        : Expr = simplExpr (('*' / '/') spaces simplExpr)*;
sumOrSub        : Expr = mulOrDiv  (('+' / '-') spaces mulOrDiv )*;
start           : Expr = spaces sumOrSub !any;