public class ExpressionGrammar : Irony.Compiler.Grammar {
    public ExpressionGrammar() {
      // 1. Terminals
      Terminal n = new NumberTerminal("number");
      Terminal v = new IdentifierTerminal("variable");
 
      // 2. Non-terminals
      NonTerminal Expr = new NonTerminal("Expr");
      NonTerminal BinOp = new NonTerminal("BinOp");
      NonTerminal UnOp = new NonTerminal("UnOp");
      NonTerminal ExprLine = new NonTerminal("ExprLine");
 
      // 3. BNF rules
      Expr.Expression = n | v | Expr + BinOp + Expr | UnOp + Expr | 
                        "(" + Expr + ")";
      BinOp.Expression = Symbol("+") | "-" | "*" | "/" | "**";
      UnOp.Expression = "-";            //Irony provides default conversion here 
      ExprLine.Expression = Expr + Eof; //Eof is a predefined EOF terminal
      this.Root = ExprLine;             //Set grammar top element
 
      // 4. Set operators precedence and associativity
      RegisterOperators(1, "+", "-");
      RegisterOperators(2, "*", "/");
      RegisterOperators(3, Associativity.Right, "**");
 
      // 5. Register parenthesis as punctuation symbols
      //    so they will not appear in the syntax tree
      PunctuationSymbols.AddRange(new string[] { "(", ")" });

    }
    
     ExpressionGrammar grammar = new ExpressionGrammar();
  LanguageCompiler compiler = new LanguageCompiler(grammar);

  string expr = "a + b * 3.14 / (2.0 * x + y**z**2)";
  AstNode rootNode = compiler.Parse(expr);

singleLineComment  = "//" (!'\r' any)* newLine?; // newLine необезательный так как комментарий может находиться в конце файла
delimitedComment   = "/*" (!"*/" any)* "*/";
comment            = singleLineComment / delimitedComment;
regularString      = '"' (!('\"' / @"\\") any)* '"';
result             = comment / regularString;

class IntSum_C3 : PegCharParser
{
   public IntSum_C3(string s) : base(s) { }
   public bool Sum()//Sum:    S [0-9]+  (S [+-] S [0-9]+)* S ;
   {
      return 
         And(()=>

            S()
         && PlusRepeat(()=>In('0','9'))
         && OptRepeat(()=> S() && OneOfChars('+','-') && S() && PlusRepeat(()=>In('0','9')))
     && S());
   }
   public bool S()//S:     [ \n\r\t\v]*            ;
   {
      return OptRepeat(()=>OneOfChars(' ', '\n', '\r', '\t', '\v'));
   }
}

qr {
   (?(DEFINE)
     (?<address>         (?&mailbox) | (?&group))
     (?<mailbox>         (?&name_addr) | (?&addr_spec))
     (?<name_addr>       (?&display_name)? (?&angle_addr))
     (?<angle_addr>      (?&CFWS)? < (?&addr_spec) > (?&CFWS)?)
     (?<group>           (?&display_name) : (?:(?&mailbox_list) | (?&CFWS))? ;
                                            (?&CFWS)?)
     (?<display_name>    (?&phrase))
     (?<mailbox_list>    (?&mailbox) (?: , (?&mailbox))*)
     (?<address_list>    (?&address) (?: , (?&address))*)
     (?<addr_spec>       (?&local_part) \@ (?&domain))
     (?<local_part>      (?&dot_atom) | (?&quoted_string))
     (?<domain>          (?&dot_atom) | (?&domain_literal))
     (?<domain_literal>  (?&CFWS)? \[ (?: (?&FWS)? dcontent)* (?&FWS)?
                                   \] (?&CFWS)?)
     (?<dcontent>        (?&dtext) | (?&quoted_pair))
     (?<dtext>           (?&NO_WS_CTL) | [\x21-\x5a\x5e-\x7e])
     (?<atext>           (?&ALPHA) | (?&DIGIT) | [!#\$%&'*+-/=?^_`{|}~])
     (?<atom>            (?&CFWS)? (?&atext)+ (?&CFWS)?)
     (?<dot_atom>        (?&CFWS)? (?&dot_atom_text) (?&CFWS)?)
     (?<dot_atom_text>   (?&atext)+ (?: \. (?&atext)+)*)
     (?<text>            [\x01-\x09\x0b\x0c\x0e-\x7f])
     (?<quoted_pair>     \\ (?&text))
     (?<qtext>           (?&NO_WS_CTL) | [\x21\x23-\x5b\x5d-\x7e])
     (?<qcontent>        (?&qtext) | (?&quoted_pair))
     (?<quoted_string>   (?&CFWS)? (?&DQUOTE) (?:(?&FWS)? (?&qcontent))*
                          (?&FWS)? (?&DQUOTE) (?&CFWS)?)
     (?<word>            (?&atom) | (?&quoted_string))
     (?<phrase>          (?&word)+)
     # Folding white space
     (?<FWS>             (?: (?&WSP)* (?&CRLF))? (?&WSP)+)
     (?<ctext>           (?&NO_WS_CTL) | [\x21-\x27\x2a-\x5b\x5d-\x7e])
     (?<ccontent>        (?&ctext) | (?&quoted_pair) | (?&comment))
     (?<comment>         \( (?: (?&FWS)? (?&ccontent))* (?&FWS)? \) )
     (?<CFWS>            (?: (?&FWS)? (?&comment))*
                         (?: (?:(?&FWS)? (?&comment)) | (?&FWS)))
     # No whitespace control
     (?<NO_WS_CTL>       [\x01-\x08\x0b\x0c\x0e-\x1f\x7f])
     (?<ALPHA>           [A-Za-z])
     (?<DIGIT>           [0-9])
     (?<CRLF>            \x0d \x0a)
     (?<DQUOTE>          ")
     (?<WSP>             [\x20\x09])
   )
   (?&address)
}x;

NEW_LINE \n | \n\r
NON_LINE [^\n]

Comment // NON_LINE* NEW_LINE

Haskell / Parsec 2                              | 3.5 МБ/с 
                                                | 
Haskell / attoparsec                            | 8.2 МБ/с
                                                | 
Классические парсер-комбинаторы на OCaml,       | 6.6 МБ/с
если включать время на преобразование из        | 
строки в список символов.                       | 
                                                | 
Они же, если считать только парсинг списка      | 18.9 МБ/с
                                                | 
Эти же комбинаторы были реализованы в варианте, | 8.3 МБ/с
где вместо списка использовалась пара           | 
строка-позиция. Такой вариант не требовал       | 
перевода из строки в список.                    | 
                                                | 
                                                | 
Парсер, сгенерированный ocamlyacc и ocamllex    | 12.9 МБ/с
                                                | 
Вариант на С++ с использованием библиотеки      | 18.1 МБ/с <--
парсер-комбинаторов Boost Spirit 2.             | 
                                                | 
Lua / LPEG (на языке Lua описывается            | 20.2 МБ/с <--
грамматика, а разбор по ней осуществляет        | 
модуль LPEG на Си).                             | 
                                                | 
Оптимизирующие парсер-комбинаторы на OCaml,     | 42.6 МБ/с
включая время на построение графа,              | 
его оптимизацию, построение таблицы и т. д.     | 
                                                | 
Наконец, вариант C# с System.Xml                | 46.0 МБ/с

Size-of-input  LPEG  Lex/Yacc  leg

620k           33    23        40
2440k          130   110       147
3680k          187   173       227

Table 4: Time for Parsing a Simple Language

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")
@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

$re = "[a-zA-Z_][a-zA-Z0-9_]*,[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*";

$id = "[a-zA-Z_][a-zA-Z0-9_]*";
$re = "$id,$id:$id";

G>

G>(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")
G>@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])
G>

p = re.compile[[
  address        <- <mailbox> / <group>
  group          <- <phrase> ":" [#mailbox] ";"
  mailbox        <- <addr_spec> / <phrase> <route_addr>
  route_addr     <- "<" <route>? <addr_spec> ">"
  route          <- (("@" <domain>) (","+ "@" <domain>)*) ":"
  addr_spec      <- <local_part> "@" <domain>
  local_part     <- <word> ("." <word>)*
  domain         <- <sub_domain> ("." <sub_domain>)*
  sub_domain     <- <domain_ref> / <domain_literal>
  domain_ref     <- <atom>
  domain_literal <- "[" ([^][] / "\" .)* "]"
  phrase         <- <word> (","+ <word>)*
  word           <- <atom> / <quoted_string>
  atom           <- [^] %c()<>@,;:\".[]+
  quoted_string  <- '"' ([^"\%nl] / "\" .)* '"'
]]

J>>вот этот вот крокодил называется "гораздо проще"?

(?!...)
Matches if ... doesn’t match next. This is a negative lookahead assertion. For example, Isaac (?!Asimov) will match 'Isaac ' only if it’s not followed by 'Asimov'.

G>Я же говорю perl

Due largely to its expressive power, many other utilities and programming languages have adopted syntax similar to Perl's — for example, Java, JavaScript, PCRE, Python, Ruby, Microsoft's .NET Framework, and the W3C's XML Schema all use regular expression syntax similar to Perl's. Some languages and tools such as Boost and PHP support multiple regular expression flavors. Perl-derivative regular expression implementations are not identical, and many implement only a subset of Perl's features. With Perl 5.10, this process has come full circle with Perl incorporating syntax extensions originally from Python, PCRE, the .NET Framework, and Java.

The time to match an ordered choice is the sum of the times for each option (as the first one may fail):
T (p1 / p2) = T (p1) + T (p2)

>>> import re
>>> re.match( "...(.*)", "123456789" ).group(1)
['456789']

cmatch result;
if (regex_match( "123456789", result, regex( "...(.*)" )))
  std::cout << result[1] << std::endl;