Support for tracing the grammar.

src/networkprotocoldsl/lexer/token/identifier.hpp

@@ -7,6 +7,7 @@ namespace networkprotocoldsl::lexer::token {
 
 struct Identifier {
   std::string name;
+  std::string stringify() const { return name; }
 };
 
 } // namespace networkprotocoldsl::lexer::token

src/networkprotocoldsl/lexer/token/keyword.hpp

@@ -1,14 +1,28 @@
 #ifndef INCLUDED_NETWORKPROTOCOLDSL_LEXER_TOKEN_KEYWORD_HPP
 #define INCLUDED_NETWORKPROTOCOLDSL_LEXER_TOKEN_KEYWORD_HPP
 
+#include <string>
+
 namespace networkprotocoldsl::lexer::token::keyword {
 
-struct For {};
-struct In {};
-struct Message {};
-struct Parts {};
-struct Terminator {};
-struct Tokens {};
+struct For {
+  std::string stringify() const { return "for"; }
+};
+struct In {
+  std::string stringify() const { return "in"; }
+};
+struct Message {
+  std::string stringify() const { return "message"; }
+};
+struct Parts {
+  std::string stringify() const { return "parts"; }
+};
+struct Terminator {
+  std::string stringify() const { return "terminator"; }
+};
+struct Tokens {
+  std::string stringify() const { return "tokens"; }
+};
 
 } // namespace networkprotocoldsl::lexer::token::keyword
 

src/networkprotocoldsl/lexer/token/literal.hpp

@@ -1,18 +1,34 @@
 #ifndef INCLUDED_NETWORKPROTOCOLDSL_LEXER_TOKEN_LITERAL_HPP
 #define INCLUDED_NETWORKPROTOCOLDSL_LEXER_TOKEN_LITERAL_HPP
 
+#include <sstream>
 #include <string>
 
 namespace networkprotocoldsl::lexer::token::literal {
 
 struct Integer {
   int value;
+  std::string stringify() const {
+    std::stringstream ss = std::stringstream();
+    ss << value;
+    return ss.str();
+  }
 };
 struct String {
   std::string value;
+  std::string stringify() const {
+    std::stringstream ss = std::stringstream();
+    ss << "\"" << value << "\"";
+    return ss.str();
+  }
 };
 struct Boolean {
   bool value;
+  std::string stringify() const {
+    std::stringstream ss = std::stringstream();
+    ss << value;
+    return ss.str();
+  }
 };
 
 } // namespace networkprotocoldsl::lexer::token::literal

src/networkprotocoldsl/lexer/token/punctuation.hpp

@@ -1,17 +1,37 @@
 #ifndef INCLUDED_NETWORKPROTOCOLDSL_LEXER_TOKEN_PUNCTUATION_HPP
 #define INCLUDED_NETWORKPROTOCOLDSL_LEXER_TOKEN_PUNCTUATION_HPP
 
+#include <string>
+
 namespace networkprotocoldsl::lexer::token::punctuation {
 
-struct AngleBracketClose {};
-struct AngleBracketOpen {};
-struct Comma {};
-struct CurlyBraceClose {};
-struct CurlyBraceOpen {};
-struct Equal {};
-struct KeyValueSeparator {};
-struct StatementEnd {};
-struct Dot {};
+struct AngleBracketClose {
+  std::string stringify() const { return ">"; }
+};
+struct AngleBracketOpen {
+  std::string stringify() const { return "<"; }
+};
+struct Comma {
+  std::string stringify() const { return ","; }
+};
+struct CurlyBraceClose {
+  std::string stringify() const { return "}"; }
+};
+struct CurlyBraceOpen {
+  std::string stringify() const { return "{"; }
+};
+struct Equal {
+  std::string stringify() const { return "="; }
+};
+struct KeyValueSeparator {
+  std::string stringify() const { return ":"; }
+};
+struct StatementEnd {
+  std::string stringify() const { return ";"; }
+};
+struct Dot {
+  std::string stringify() const { return "."; }
+};
 
 } // namespace networkprotocoldsl::lexer::token::punctuation
 

src/networkprotocoldsl/parser/grammar/identifier.hpp

@@ -13,8 +13,10 @@ namespace networkprotocoldsl::parser::grammar {
 class IdentifierReference; // Forward declaration
 
 class IdentifierMemberAccess
-    : public support::RecursiveParser<IdentifierMemberAccess, ParseTraits> {
+    : public support::RecursiveParser<IdentifierMemberAccess, ParseTraits,
+                                      Tracer<IdentifierMemberAccess>> {
 public:
+  static constexpr const char *name = "IdentiferMemberAccess";
   static void partial_match() {}
   static IdentifierReference *recurse_one(lexer::token::punctuation::Dot) {
     return nullptr;
@@ -27,8 +29,10 @@ class IdentifierMemberAccess
 };
 
 class IdentifierReference
-    : public support::RecursiveParser<IdentifierReference, ParseTraits> {
+    : public support::RecursiveParser<IdentifierReference, ParseTraits,
+                                      Tracer<IdentifierReference>> {
 public:
+  static constexpr const char *name = "IdentiferReference";
   static void partial_match() {}
   static IdentifierMemberAccess *recurse_maybe(lexer::token::Identifier) {
     return nullptr;

src/networkprotocoldsl/parser/grammar/literals.hpp

@@ -10,8 +10,10 @@
 namespace networkprotocoldsl::parser::grammar {
 
 class BooleanLiteral
-    : public support::RecursiveParser<BooleanLiteral, ParseTraits> {
+    : public support::RecursiveParser<BooleanLiteral, ParseTraits,
+                                      Tracer<BooleanLiteral>> {
 public:
+  static constexpr const char *name = "BooleanLiteral";
   static void partial_match() {}
   static ParseStateReturn match(TokenIterator begin, TokenIterator end,
                                 lexer::token::literal::Boolean b) {
@@ -20,8 +22,10 @@ class BooleanLiteral
 };
 
 class IntegerLiteral
-    : public support::RecursiveParser<IntegerLiteral, ParseTraits> {
+    : public support::RecursiveParser<IntegerLiteral, ParseTraits,
+                                      Tracer<IntegerLiteral>> {
 public:
+  static constexpr const char *name = "IntegerLiteral";
   static void partial_match() {}
   static ParseStateReturn match(TokenIterator begin, TokenIterator end,
                                 lexer::token::literal::Integer i) {
@@ -30,8 +34,10 @@ class IntegerLiteral
 };
 
 class StringLiteral
-    : public support::RecursiveParser<StringLiteral, ParseTraits> {
+    : public support::RecursiveParser<StringLiteral, ParseTraits,
+                                      Tracer<StringLiteral>> {
 public:
+  static constexpr const char *name = "StringLiteral";
   static void partial_match() {}
   static ParseStateReturn match(TokenIterator begin, TokenIterator end,
                                 lexer::token::literal::String s) {

src/networkprotocoldsl/parser/grammar/messagedata.hpp

@@ -13,8 +13,10 @@
 namespace networkprotocoldsl::parser::grammar {
 
 class MessageDataPair
-    : public support::RecursiveParser<MessageDataPair, ParseTraits> {
+    : public support::RecursiveParser<MessageDataPair, ParseTraits,
+                                      Tracer<MessageDataPair>> {
 public:
+  static constexpr const char *name = "MessageDataPair";
   static void partial_match() {}
   static void partial_match(lexer::token::Identifier) {}
   static Type *recurse_one(lexer::token::Identifier,
@@ -35,8 +37,10 @@ class MessageDataPair
   }
 };
 
-class MessageData : public support::RecursiveParser<MessageData, ParseTraits> {
+class MessageData : public support::RecursiveParser<MessageData, ParseTraits,
+                                                    Tracer<MessageData>> {
 public:
+  static constexpr const char *name = "MessageData";
   static void partial_match() {}
   static bool conditional_partial_match(lexer::token::Identifier id) {
     if (id.name == "data") {

src/networkprotocoldsl/parser/grammar/tokenparts.hpp

@@ -13,8 +13,10 @@
 
 namespace networkprotocoldsl::parser::grammar {
 
-class TokenPart : public support::RecursiveParser<TokenPart, ParseTraits> {
+class TokenPart : public support::RecursiveParser<TokenPart, ParseTraits,
+                                                  Tracer<TokenPart>> {
 public:
+  static constexpr const char *name = "TokenPart";
   static std::tuple<StringLiteral, IdentifierReference> *recurse_any() {
     return nullptr;
   }
@@ -25,8 +27,10 @@ class TokenPart : public support::RecursiveParser<TokenPart, ParseTraits> {
 };
 
 class TokenSequence
-    : public support::RecursiveParser<TokenSequence, ParseTraits> {
+    : public support::RecursiveParser<TokenSequence, ParseTraits,
+                                      Tracer<TokenSequence>> {
 public:
+  static constexpr const char *name = "TokenSequence";
   static void partial_match() {}
   static void partial_match(lexer::token::keyword::Tokens) {}
   static TokenPart *recurse_many(lexer::token::keyword::Tokens,
@@ -46,8 +50,10 @@ class TokenSequence
   }
 };
 
-class Terminator : public support::RecursiveParser<Terminator, ParseTraits> {
+class Terminator : public support::RecursiveParser<Terminator, ParseTraits,
+                                                   Tracer<Terminator>> {
 public:
+  static constexpr const char *name = "Terminator";
   static void partial_match() {}
   static void partial_match(lexer::token::keyword::Terminator) {}
   static StringLiteral *recurse_one(lexer::token::keyword::Terminator,

src/networkprotocoldsl/parser/grammar/traits.hpp

@@ -50,8 +50,73 @@ using NodeVariant =
 
 using TokenIterator = std::vector<lexer::Token>::const_iterator;
 
+static int indent_level(int modify) {
+  static int indent = 0;
+  indent += modify;
+  for (int i = 0; i < indent; ++i) {
+    std::cerr << ' ';
+  }
+  std::cerr << '(' << indent << ") ";
+  return indent;
+}
+
+static bool trace_enabled() {
+  static bool r = getenv("GRAMMAR_TRACER") != nullptr;
+  return r;
+}
+
 } // namespace
 
+template <typename ParserContext> class Tracer {
+public:
+  static void output_tokens(const TokenIterator begin,
+                            const TokenIterator end) {
+    int max = 10;
+    TokenIterator b = begin;
+    while (max > 0 && b != end) {
+      std::cerr << " " << std::visit([&](auto t) { return t.stringify(); }, *b);
+      b++;
+      max--;
+    }
+    if (b != end) {
+      std::cerr << "...";
+    }
+  }
+
+  using TokenIterator = ParserContext::TokenIterator;
+  template <typename... Args>
+  static void trace_start(const char *attempt_type, const TokenIterator &begin,
+                          const TokenIterator &end, Args... args) {
+    if (!trace_enabled())
+      return;
+    indent_level(1);
+    std::cerr << "> " << attempt_type << " " << ParserContext::name << " ("
+              << sizeof...(args) << "):";
+    output_tokens(begin, end);
+    std::cerr << std::endl;
+  }
+  template <typename... Args>
+  static void trace_success(const TokenIterator &begin,
+                            const TokenIterator &end, Args... args) {
+    if (!trace_enabled())
+      return;
+    indent_level(-1);
+    std::cerr << "< " << ParserContext::name << " [SUCCESS]";
+    output_tokens(begin, end);
+    std::cerr << std::endl;
+  }
+  template <typename... Args>
+  static void trace_fail(const TokenIterator &begin, const TokenIterator &end,
+                         Args... args) {
+    if (!trace_enabled())
+      return;
+    indent_level(-1);
+    std::cerr << "< " << ParserContext::name << " [FAIL]";
+    output_tokens(begin, end);
+    std::cerr << std::endl;
+  }
+};
+
 using ParseTraits = support::ParseStateTraits<TokenIterator, NodeVariant>;
 
 } // namespace networkprotocoldsl::parser::grammar

src/networkprotocoldsl/parser/grammar/typeparameter.hpp

@@ -16,8 +16,10 @@ namespace networkprotocoldsl::parser::grammar {
 class Type; // Forward declaration
 
 class TypeParameterValue
-    : public support::RecursiveParser<TypeParameterValue, ParseTraits> {
+    : public support::RecursiveParser<TypeParameterValue, ParseTraits,
+                                      Tracer<TypeParameterValue>> {
 public:
+  static constexpr const char *name = "TypeParameterValue";
   static std::tuple<Type, BooleanLiteral, StringLiteral, IntegerLiteral> *
   recurse_any() {
     return nullptr;
@@ -33,8 +35,10 @@ class TypeParameterValue
 };
 
 class TypeParameter
-    : public support::RecursiveParser<TypeParameter, ParseTraits> {
+    : public support::RecursiveParser<TypeParameter, ParseTraits,
+                                      Tracer<TypeParameter>> {
 public:
+  static constexpr const char *name = "TypeParameter";
   static void partial_match() {}
   static void partial_match(lexer::token::Identifier) {}
   static TypeParameterValue *recurse_one(lexer::token::Identifier,
@@ -56,8 +60,10 @@ class TypeParameter
 };
 
 class TypeParameters
-    : public support::RecursiveParser<TypeParameters, ParseTraits> {
+    : public support::RecursiveParser<TypeParameters, ParseTraits,
+                                      Tracer<TypeParameters>> {
 public:
+  static constexpr const char *name = "TypeParameters";
   static void partial_match() {}
   static TypeParameter *
   recurse_many(lexer::token::punctuation::AngleBracketOpen) {
@@ -84,8 +90,9 @@ class TypeParameters
   }
 };
 
-class Type : public support::RecursiveParser<Type, ParseTraits> {
+class Type : public support::RecursiveParser<Type, ParseTraits, Tracer<Type>> {
 public:
+  static constexpr const char *name = "Type";
   static void partial_match() {}
   static TypeParameters *recurse_maybe(lexer::token::Identifier) {
     return nullptr;