auto_ptr<Rule> exstatik::CreateLexer_Simple() {
    auto_ptr<Rule> lexer(STAR("lexer"));
    Rule* or_ = lexer->AddChild(OR("or"));
    or_->AddChild(KEYWORD("new"));
    or_->AddChild(KEYWORD("del"));
    or_->AddChild(KEYWORD(";"));
    return lexer;
}

auto_ptr<Rule> exstatik::CreateLexer_JSON() {
  auto_ptr<Rule> lexer(STAR("lexer"));
  Rule* or_ = lexer->AddChild(OR("Or"));
  or_->AddChild(KEYWORD("="));
  or_->AddChild(KEYWORD("{"));
  or_->AddChild(KEYWORD("}"));
  or_->AddChild(KEYWORD(";"));
  or_->AddChild(REGEXP("ID", boost::regex("[A-Za-z_][0-9A-Za-z_]*")));
  or_->AddChild(REGEXP("INT", boost::regex("[0-9]+")));
  or_->AddChild(REGEXP("STR", boost::regex("(\'([^\'\\\\\\\\]|\\\\.)*\')|(\\\"([^\\\"\\\\\\\\]|\\\\.)*\\\")")));
  or_->AddChild(REGEXP("WS", boost::regex("[ \t\r]+")));
  return lexer;
}

// parser = ((new ;)|(del ;))*
auto_ptr<Rule> exstatik::CreateParser_Simple() {
  auto_ptr<Rule> parser(STAR("parser"));
  Rule* stmts_ = parser->AddChild(OR("Or (stmts)"))
    ->CapOutput("cmd");
  Rule* newstmt_ = stmts_->AddChild(SEQ("new stmt"));
  newstmt_->AddChild(META("new"));
  //newstmt_->AddChild(META("x"));
  newstmt_->AddChild(META(";"))
    ->SilenceOutput();
  Rule* delstmt_ = stmts_->AddChild(SEQ("del stmt"));
  delstmt_->AddChild(META("del"));
  //delstmt_->AddChild(META("x"));
  delstmt_->AddChild(META(";"))
    ->SilenceOutput();
  return parser;
}

// C parser
auto_ptr<Rule> exstatik::CreateParser_C() {

  auto_ptr<Rule> identifier_(META("identifier", "ID"));   // goto_statement_
  auto_ptr<Rule> integer_constant_(META("integer", "INT"));   // constant_
  auto_ptr<Rule> character_constant_(META("char", "CHAR"));   // constant_
  auto_ptr<Rule> floating_constant_(META("float", "FLOAT"));   // constant_
  auto_ptr<Rule> enumeration_constant_(META("enum", "ENUM"));   // constant_

  auto_ptr<Rule> constant_(OR("constant")); // FAKE constant_expression_
  constant_->AddChild(integer_constant_);
  constant_->AddChild(character_constant_);
  constant_->AddChild(floating_constant_);
  constant_->AddChild(enumeration_constant_);

  /*
    postfix-expression:
      primary-expression
      postfix-expression [ expression ]
      postfix-expression ( argument-expression-list_OPT )
      postfix-expression . identifier
      postfix-expression -> identifier
      postfix-expression ++
      postfix-expression --
    primary-expression:
      identifier
      constant
      string
      ( expression )
    argument-expression-list:
      assignment-expression
      argument-expression-list , assignment-expression
  */

  auto_ptr<Rule> unary_operator_(OR("unary-operator"));
  unary_operator_->AddChild(META("&", "&"));
  unary_operator_->AddChild(META("*", "*"));
  unary_operator_->AddChild(META("+", "+"));
  unary_operator_->AddChild(META("-", "-"));
  unary_operator_->AddChild(META("~", "~"));
  unary_operator_->AddChild(META("!", "!"));

  // FAKE
  auto_ptr<Rule> constant_expression_(constant_); // FAKE direct-declarator-suffix-1

  /*
    conditional-expression:
      logical-OR-expression
      logical-OR-expression ? expression : conditional-expression
    constant-expression:
      conditional-expression
    logical-OR-expression:
      logical-AND-expression
      logical-OR-expression || logical-AND-expression
    logical-AND-expression:
      inclusive-OR-expression
      logical-AND-expression && inclusive-OR-expression
    inclusive-OR-expression:
      exclusive-OR-expression
      inclusive-OR-expression | exclusive-OR-expression
    exclusive-OR-expression:
      AND-expression
      exclusive-OR-expression ^ AND-expression
    AND-expression:
      equality-expression
      AND-expression & equality-expression
    equality-expression:
      relational-expression
      equality-expression == relational-expression
      equality-expression != relational-expression
    relational-expression:
      shift-expression
      relational-expression < shift-expression
      relational-expression > shift-expression
      relational-expression <= shift-expression
      relational-expression >= shift-expression
    shift-expression:
      additive-expression
      shift-expression << additive-expression
      shift-expression >> additive-expression
    additive-expression:
      multiplicative-expression
      additive-expression + multiplicative-expression
      additive-expression - multiplicative-expression
    multiplicative-expression:
      cast-expression
      multiplicative-expression * cast-expression
      multiplicative-expression / cast-expression
      multiplicative-expression % cast-expression
    cast-expression:
      unary-expression
      ( type-name ) cast-expression
    unary-expression:
      postfix-expression
      ++ unary-expression
      -- unary-expression
      unary-operator cast-expression
      sizeof unary-expression
      sizeof ( type-name )
  */
//.........这里部分代码省略.........