parsers.h

 
 
#ifndef HERMES_HERMES_COMMON_PARSERS_H
#define HERMES_HERMES_COMMON_PARSERS_H
 
#include <string>
#include <utility>
#include <vector>
#include <unordered_map>
#include <hermes/common/result.h>
 
namespace hermes {
 
// *********************************************************************************************************************
//                                                                                                          ParseTree
// *********************************************************************************************************************
class ParseTree {
  friend class StringParser;
public:
  enum class NodeType {
    INPUT = 0, 
    TOKEN = 1, 
    BLOCK = 2  
  };
  // *******************************************************************************************************************
  //                                                                                                  ParseTree::Node
  // *******************************************************************************************************************
  struct Node {
    std::string name;
    std::string value;
    size_t start{};
    size_t size{};
    int block_id{}; 
    std::vector<Node> children;
    NodeType type{NodeType::INPUT};
  };
  // *******************************************************************************************************************
  //                                                                                                          METHODS
  // *******************************************************************************************************************
  void iterate(const std::function<bool(const Node &)> &callback) const;
  // *******************************************************************************************************************
  //                                                                                                            DEBUG
  // *******************************************************************************************************************
  friend std::ostream &operator<<(std::ostream &os, const ParseTree &parse_tree);
private:
  static std::string typeName(NodeType type) {
#define DATA_TYPE_NAME(Type) \
      if(NodeType::Type == type) \
    return #Type;
    DATA_TYPE_NAME(INPUT)
    DATA_TYPE_NAME(TOKEN)
    DATA_TYPE_NAME(BLOCK)
    return "INVALID NODE TYPE";
#undef DATA_TYPE_NAME
  }
  explicit ParseTree(Node node) {
    root_ = std::move(node);
  }
  Node root_;
};
 
// *********************************************************************************************************************
//                                                                                                       StringParser
// *********************************************************************************************************************
class StringParser {
public:
  // *******************************************************************************************************************
  //                                                                                                   STATIC METHODS
  // *******************************************************************************************************************
  //                                                                                                     construction
  static StringParser cLanguage();
  //                                                                                                          parsing
  static size_t matchPrefixWithAny(const std::string &characters, const std::string &s, size_t start = 0);
  static size_t matchPrefixWithAny(const std::vector<std::pair<std::string, std::string>> &block_delimiters,
                                   const std::string &s,
                                   size_t &block_content_start,
                                   size_t &block_content_size,
                                   size_t start = 0);
  static size_t matchPrefixWithAny(const std::vector<std::string> &block_openings,
                                   const std::string &s,
                                   int &match_id,
                                   size_t start = 0);
  static size_t startsWith(const std::vector<std::pair<std::string, std::string>> &block_delimiters,
                           const std::string &s,
                           size_t i = 0);
  // *******************************************************************************************************************
  //                                                                                                     CONSTRUCTORS
  // *******************************************************************************************************************
  StringParser();
  virtual ~StringParser();
  // *******************************************************************************************************************
  //                                                                                                            RULES
  // *******************************************************************************************************************
  //                                                                                         empty / blank characters
  void setBlankCharacters(const std::string &blank_characters);
  void pushBlankCharacter(char blank_character);
  void pushBlankDelimiters(const std::string &open_pattern, const std::string &close_pattern);
  //                                                                                                 enclosing blocks
  void pushBlockDelimiters(const std::string &open_pattern, const std::string &close_pattern);
  //                                                                                                           tokens
  void pushTokenPattern(const std::string &name, const std::string &regex_pattern);
  // *******************************************************************************************************************
  //                                                                                                          PARSING
  // *******************************************************************************************************************
  Result<ParseTree> parse(const std::string &text, bool copy_string = true);
private:
  [[nodiscard]] size_t consumeAllBlanks(const std::string &s, size_t start = 0) const;
  [[nodiscard]] size_t parseToken(const std::string &s, std::string &token_name, size_t start = 0) const;
 
  std::string blank_characters_ = " \t\n";
  std::unordered_map<std::string, std::string> token_patterns_;
  std::vector<std::string> blank_block_openings_;
  std::vector<std::string> blank_block_closings_;
  std::vector<std::string> block_openings_;
  std::vector<std::string> block_closings_;
};
 
}
 
#endif //HERMES_HERMES_COMMON_PARSERS_H