var x1 = "asfasdasdf"; // comment
x2.bla = 'dfasdf"asdfsd" asds';

x = y.z = t ? a : 0x23 * 7 + 1;
; //empty statement !
function Foo(
    a1 /* a1 arg*/ ,
    b,
    c) {
  var s = t ? true : false ? h ? 7 : 8++ : g ? 3 + bar(1, 2).f : 4;
  var tmp = this.xxx(/* no args! */)(a1, /* passing b*/ b, c /*and c*/).result;
  return function(k, t) { return ++0x45ff+++1; };
}

var x1 = "asfasdasdf";
x2.bla = 'dfasdf"asdfsd" asds';
x = y.z = (t ? a : (0x23 * (7 + 1)));;
function Foo(a1, b, c)
{
    var s = (t ? true : (false ? (h ? 7 : (8++)) : (g ? (3 + bar(1, 2).f) : 4)));
    var tmp = this.xxx()(a1, b, c).result;
    return function (k, t)
    {
        return ((++(0x45ff++)) + 1);
    };
}

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

    parenthesesExpr       : int = '(' spaces sumOrSub ')' spaces;
    parenthesesExprError  : int = '(' spaces sumOrSub (any / !any);
    simplExpr             : int = num / parenthesesExpr / unaryMinus / parenthesesExprError / simplExprError;
    simplExprError        : int = any;
...
    private parenthesesExprError(first : NToken, _ : NToken, _ : VToken[int], _ : NToken) : int
    {
      throw ParserFatalError("Не закрытая скобка", first.EndPos);
    }
    
    private simplExprError(tok : NToken) : int
    {
      throw ParserFatalError("Ожидается число или выражение в скобках", tok.StartPos);
    }

    parenthesesExpr       : int = '(' spaces sumOrSub ')' spaces;
    simplExpr             : int = num / parenthesesExpr / unaryMinus / '(' Error("Не закрытая скобка") / Error("Ожидается число или выражение в скобках");

    parenthesesExpr       : int = '(' spaces sumOrSub ')' spaces;
    simplExpr             : int = num / parenthesesExpr / unaryMinus / parenthesesExprError / simplExprError;
    parenthesesExprError  : int = '(' Error("Не закрытая скобка");
    simplExprError        : int = Error("Ожидается число или выражение в скобках");

selectKwd = ('S' / 's') ('E' / 'e') ('L' / 'l') ('E' / 'e') ('C' / 'c') ('T' / 't');

i"select"

H>>x = y.z = t ? a : 0x23 * 7 + 1;
H>>

H>>x = y.z = (t ? a : (0x23 * (7 + 1)));;
H>>

infixOperator           : string    = ('+' / '-' / '*' / '/') spaces;

    mulOrDiv              : int = simplExpr (('*' / '/') spaces simplExpr)*;
    sumOrSub              : int = mulOrDiv  (('+' / '-') spaces mulOrDiv )*;

options =
(
  ignore case,
  ignore '\t' '\r' '\n',
  что-то еще
)

[PegGrammar(start, IgnoreCase = true,
  grammar
  {

ВВ>Ну добавление приоритетов операторов просто-напросто упростит написание грамматики. В идеале бы, конечно, иметь некоторый механизм, который позволил бы вмешиваться в процесс парсинга и создавать специальные хелперы. И в числе таких хелперов был бы такой, который позволял бы указать приоритет. Но эта, сам понимаешь, идея из области "самолеты летят и падают"

  tagOpen(lt, identifier, attrs, gt) : XmlAst.TagOpen
    subrules:
      attrs = attr*;
      lt    = '<';
      gt    = '>';
  {
    код обработчика
  }

Sub = "SUB";

Sub = "Процедура";

    letter                    = (['A'..'Z', 'a' .. 'z', 'А' .. 'Я', 'а' .. 'я'] / '_');
    digit                     = ['0'..'9'];
    identifierValue           = '@'? letter (letter / digit)*;
    identifier   : string     = identifierValue spaces;

    identifierValue           = '@'? spaces letter spaces (letter spaces / digit spaces)* spaces;

identifierValue           = '@'? nopace letter nopace (letter nopace / digit nopace)* nopace;

H>Теперь компиляция проекта длится несколько долгих-долгих минут. Там полиномиальная сложность что ли с какой-то дикой степенью?

mayBeInfixExpression    : Expression = multiplicativeExpr (('+' / '-') multiplicativeExpr)*;
multiplicativeExpr      : Expression = expression (('*' / '/' / '%') expression)*

H>>Теперь компиляция проекта длится несколько долгих-долгих минут. Там полиномиальная сложность что ли с какой-то дикой степенью?

VD>mayBeInfixExpression    : Expression = multiplicativeExpr (('+' / '-') multiplicativeExpr)*;
VD>multiplicativeExpr      : Expression = expression (('*' / '/' / '%') expression)*
VD>

multiplicativeExpression    : Expression = prefixExpression (('*' / '/' / '%') spaces           prefixExpression)*;
additiveExpression          : Expression = multiplicativeExpression (('+' / '-' ) spaces        multiplicativeExpression)*;
shiftExpression             : Expression = additiveExpression ((">>>" / ">>" / "<<") spaces     additiveExpression)*;
relationalExpression        : Expression = shiftExpression (("<=" / ">=" / '<' / '>') spaces    shiftExpression)*;
equalityExpression          : Expression = relationalExpression (("===" / "==" / "!=") spaces   relationalExpression)*;
andExpression               : Expression = equalityExpression ('&' spaces                       equalityExpression)*;
exclusiveOrExpression       : Expression = andExpression ('^' spaces                            andExpression)*;
inclusiveOrExpression       : Expression = exclusiveOrExpression ('|' spaces                    exclusiveOrExpression)*;
conditionalAndExpression    : Expression = inclusiveOrExpression ("&&" spaces                   inclusiveOrExpression)*;
conditionalOrExpression     : Expression = conditionalAndExpression ("||" spaces                conditionalAndExpression)*;
conditionalExpression       : Expression = conditionalOrExpression (QUEST expression COLON conditionalExpression)?; //right assoc

H>И их тоже (да, у меня сегодня свободный денек подвернулся). Пожалуй с грамматикой закончил, можно приступать к AST.

      identifierStartCharacter  = letterCharacter / "_";
      identifierPartCharacters  = letterCharacter / decimalDigitCharacter / connectingCharacter / combiningCharacter / formattingCharacter;

H>И их тоже (да, у меня сегодня свободный денек подвернулся). Пожалуй с грамматикой закончил, можно приступать к AST.

      voidType = "void"s;
      booleanType = "bool"s;
      stringType = "string"s;
      dynamicType = "dynamic"s;
      objectType = "object"s;

      integralType = ("sbyte" / "byte" / "short" / "ushort" / "int" / "uint" / "long" / "ulong" / "char")s;
      floatingPointType = ("float" / "double")s;
      decimalType = "decimal"s;

H>>И их тоже (да, у меня сегодня свободный денек подвернулся). Пожалуй с грамматикой закончил, можно приступать к AST.

WH>      voidType = "void"s;
WH>      booleanType = "bool"s;
WH>      stringType = "string"s;
WH>      dynamicType = "dynamic"s;
WH>      objectType = "object"s;

WH>      integralType = ("sbyte" / "byte" / "short" / "ushort" / "int" / "uint" / "long" / "ulong" / "char")s;
WH>      floatingPointType = ("float" / "double")s;
WH>      decimalType = "decimal"s;
WH>

      s = space*;                           /* optional spacer          */
      S = !identifierPartCharacters space*; /* identifier break spacer  */

          public TryParse([Nemerle.Assertions.NotNull] source : Nemerle.Peg.SourceSnapshot) : int * $tyParam
          {
            _parsingSource = source;

            mutable result;
            def pos = $(compiler.DecorateRuleName(parsedGrammar.StartRuleName.Id) : dyn)(0, ref result, _parsingSource.Text);

            (pos, result)
          }