the-biergarten-app/tooling/pipeline/includes/services/xeger/xeger_internal.h

#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_XEGER_XEGER_INTERNAL_H_
#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_XEGER_XEGER_INTERNAL_H_
/**
 * @file services/xeger/xeger_internal.h
 * @brief Declarations shared by the xeger parser and generator.
 *
 *   1. Parser         Turns the pattern text into an AST (Literal, AnyChar,
 *                      CharClass, Concat, Alternation, Repeat nodes).
 *   2. Visitor         Double-dispatch contract -- each AST-walking
 *                      operation implements this.
 *   3. XegerGenerator  a Visitor that emits a random character wherever the
 *                      AST says a character belongs, respecting alternation
 *                      choices and repeat counts.
 */

#include <memory>
#include <optional>
#include <random>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

namespace xeger_internal {

// Regex syntax characters

constexpr char kAnchorStart = '^';
constexpr char kAnchorEnd = '$';
constexpr char kAlternation = '|';
constexpr char kGroupOpen = '(';
constexpr char kGroupClose = ')';
constexpr char kNonCapturingMarker = '?';
constexpr char kNonCapturingColon = ':';
constexpr char kClassOpen = '[';
constexpr char kClassClose = ']';
constexpr char kClassNegate = '^';
constexpr char kClassRange = '-';
constexpr char kAnyChar = '.';
constexpr char kEscape = '\\';
constexpr char kStar = '*';
constexpr char kPlus = '+';
constexpr char kOptional = '?';
constexpr char kBraceOpen = '{';
constexpr char kBraceClose = '}';
constexpr char kBraceComma = ',';

// AST

struct Literal;
struct AnyChar;
struct CharClass;
struct Concat;
struct Alternation;
struct Repeat;

struct Visitor {
   virtual void Visit(const Literal&) = 0;
   virtual void Visit(const AnyChar&) = 0;
   virtual void Visit(const CharClass&) = 0;
   virtual void Visit(const Concat&) = 0;
   virtual void Visit(const Alternation&) = 0;
   virtual void Visit(const Repeat&) = 0;
   virtual ~Visitor() = default;
};

struct Node {
   virtual void Accept(Visitor&) const = 0;
   virtual ~Node() = default;
};

using NodePtr = std::unique_ptr<Node>;

template <typename Derived>
struct Visitable : Node {
   void Accept(Visitor& visitor) const override {
      visitor.Visit(static_cast<const Derived&>(*this));
   }
};

// One fixed character, e.g. 'a'.
struct Literal : Visitable<Literal> {
   char ch;
   explicit Literal(const char c) : ch(c) {}
};

// The "." wildcard: any single printable character.
struct AnyChar : Visitable<AnyChar> {};

// A set of allowed characters, stored as inclusive ranges. A single
// character 'x' is the range {'x', 'x'}. `negated` flips the meaning to
// "any character NOT listed" (i.e. `[^...]`).
struct CharClass : Visitable<CharClass> {
   std::vector<std::pair<char, char>> ranges;
   bool negated = false;
};

// "Do these children one after another."
struct Concat : Visitable<Concat> {
   std::vector<NodePtr> parts;
};

// "Pick exactly one of these options at random" -- the `|` operator.
struct Alternation : Visitable<Alternation> {
   std::vector<NodePtr> options;
};

// "Repeat one child between min and max times."
//   a*     -> min 0, max infinite
//   a+     -> min 1, max infinite
//   a?     -> min 0, max 1
//   a{2,5} -> min 2, max 5
struct Repeat : Visitable<Repeat> {
   NodePtr child;
   unsigned int min = 0;
   std::optional<unsigned int> max;  // std::nullopt means "no upper bound"
};

// Parser (recursive descent)
//
// Precedence, loosest to tightest binding:
//   ParseAlternation  ::=  a|b|c
//     ParseConcat     ::=  abc
//       ParseRepeat   ::=  a*  a{2,5}
//         ParseAtom   ::=  a  .  [..]  (..)  \d

class Parser {
  public:
   explicit Parser(std::string_view pattern);

   NodePtr Parse();

  private:
   std::string src_;
   size_t pos_ = 0;

   // Strips anchors (leading '^' and trailing '$') as they are not needed for
   // generation.
   static std::string StripAnchors(std::string_view pattern);

   [[nodiscard]] bool AtEnd() const;
   [[nodiscard]] char Peek() const;
   char Advance();
   bool Match(char c);
   void Expect(char c);

   // Level 1: alternation -- ( concat | concat | concat )
   NodePtr ParseAlternation();

   // Level 2: concatenation -- a run of items back to back
   NodePtr ParseConcat();

   // Level 3: an atom plus an optional quantifier
   NodePtr ParseRepeat();

   // Curly-brace quantifiers: {n}, {n,}, {n,m}
   NodePtr ParseBrace(NodePtr atom);

   // Level 4: an atom -- the smallest standalone unit
   NodePtr ParseAtom();

   static NodePtr MakeClass(std::vector<std::pair<char, char>> ranges,
                            bool negated);

   NodePtr ParseEscape();

   NodePtr ParseCharClass();

   // Reads one character inside [ ], turning \] \n etc. into the real
   // character they represent.
   char ClassChar();
};

// Generator -- a Visitor that emits a random matching string

class XegerGenerator final : public Visitor {
  public:
   XegerGenerator(std::mt19937& rng, int unbounded_cap);

   std::string Run(const Node& root);

   void Visit(const Literal& node) override;
   void Visit(const AnyChar&) override;
   void Visit(const CharClass& node) override;
   void Visit(const Concat& node) override;
   void Visit(const Alternation& node) override;
   void Visit(const Repeat& node) override;

  private:
   std::mt19937& rng_;
   int unbounded_cap_;
   std::string out_;

   static bool InRanges(const CharClass& node, char c);

   char PickFromClass(const CharClass& node);
};

}  // namespace xeger_internal

#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_XEGER_XEGER_INTERNAL_H_