Due to my distaste for parser generation tools like YACC and Lex and being such a completely unreasonable guy, I decided to write my own recursive descent parser. I first did it in Delphi, then I did it in Heron. Now I just finished version 1.0 of the YARD parser for C++ and I've posted it to SourceForge.net.

The YARD parser is a data-type agnostic CFG parser tool written using template metaprogramming techniques in C++. The YARD parser was designed to be as compact and flexible as possible.

The YARD parser has a significantly different design than its closest cousin, the boost::spirit library, because the grammar productions are defined directly as meta-functions, and there is no funky operator overloading. Semantic actions are defined as template specializations. See my earlier post on Static versus Dynamic Event Handlers in C++.

The YARD parser source code comes with a XML parser as way of a demonstration, of the ease of use etc. There is also a very simple built-in tokenizer for those who might want to use YARD as a powerful lexical analyzer.

rule<> a_rule = *(a | b) & +(c | d | e);

struct a_rule = 
re_and
< 
  re_star<
    re_or<a, b> 
  >, 
  re_plus<
   re_or3<c, d, e>  
  > 
>;

struct StartRule {
  template<typename Elem_T>
  static bool Accept(ParserInputStream<Elem_T>& in) {
    switch (in.GetChar()) {
      case 'a' : return match<RuleA>(in);
      case 'b' : return match<RuleB>(in);
      case 'c' : return match<RuleC>(in);
      case 'd' : return match<RuleD>(in);
      default : return false;
    }
  }
}

#define BOOST_SPIRIT_SWITCH_CASE_LIMIT 10
#include "boost/spirit/switch.hpp"
rule<> rule_overall =
  switch_p
  [
    case_p<'a'>(parser_a),
    case_p<'b'>(parser_b),
    case_p<'c'>(parser_c),
    case_p<'d'>(parser_d),
    default_p(parser_default)
  ];