Do you mean it or was it sarcasm?
I absolutely sincerely meant it. Writing parsers is fun.
Except if you use (f)lex/bison/yacc; those are atrociously hard to use, full of obscure edge cases, and the output has the aesthetic appeal of elephant droppings.
I've written quite a bunch of parsers myself lately: a few iterations of a template engine in PHP (started out as a four-line function that went something like preg_match_all -> array_map -> str_replace, but by now, it's a fully-fledged template language with loops and includes and whatnot). A fast C parser for a custom network protocol. A few parsers (query strings, POST message bodies, HTTP requests, etc.) for an experimental web server framework. Another template engine, this time in Haskell (allowing for arbitrary Haskell expressions to be interpolated into the template while still providing HTML-encoding where needed). A parser for my custom sheet music language, also in Haskell.
So yes, writing parsers is fun.
I like the parser-combinator approach - build a generic parser interface, a bunch of atomic parsers, a bunch of combinator parsers, and then build your final parser from these blocks, following along a BNF representation of the grammar. Haskell's Parsec library takes this to the extreme, providing a native Haskell syntax that closely resembles BNF itself:
literal = stringLiteral
<|> charLiteral
<|> numberLiteral
But even in a language with less flexible syntax, a similar parser can be built. E.g., in (functional-style) C++, the above could look like this:
AST_Expression* parseLiteral(ParserState& p) {
AST_Expression* e;
if (e = parseStringLiteral(p)) return e;
if (e = parseCharLiteral(p)) return e;
if (e = parseNumberLiteral(p)) return e;
return 0; // fail, no parse.
}
Or you could do it OOP-style, which would yield something like:
#SelectExpand
1class LiteralParser : public BaseParser<AST_Expression> {
2 private:
3 AlternativesParser<AST_Expression>* subparser;
4 public:
5 LiteralParser() {
6 subparser = new AlternativesParser<AST_Expression>();
7 subparser->addAlternative(new StringLiteralParser());
8 subparser->addAlternative(new CharLiteralParser());
9 subparser->addAlternative(new NumberLiteralParser());
10 }
11 virtual ~LiteralParser() {
12 delete subparser;
13 }
14 virtual AST_Expression* parse(ParserState& p) {
15 return subparser->parse(p);
16 }
17}
18// implementing AlternativesParser left as an exercise to the reader...
I guess at this point it may be obvious why I like Haskell.
]]>
