parse_tree_input.hpp

Go to the documentation of this file.

// Copyright (C) 2020-2024 Jonathan Müller and lexy contributors
// SPDX-License-Identifier: BSL-1.0
 
#ifndef LEXY_INPUT_PARSE_TREE_INPUT_HPP_INCLUDED
#define LEXY_INPUT_PARSE_TREE_INPUT_HPP_INCLUDED
 
#include <lexy/error.hpp>
#include <lexy/grammar.hpp>
#include <lexy/input/base.hpp>
#include <lexy/lexeme.hpp>
 
#if !LEXY_EXPERIMENTAL
#    error "lexy::parse_tree_input is experimental"
#endif
 
namespace lexy
{
template <typename Node>
struct parse_tree_input_traits;
 
struct _parse_tree_eof // not real EOF, just no more siblings
{
    template <typename Node>
    friend constexpr bool operator==(const Node& node, _parse_tree_eof) noexcept
    {
        return parse_tree_input_traits<Node>::is_null(node);
    }
    template <typename Node>
    friend constexpr bool operator==(_parse_tree_eof, const Node& node) noexcept
    {
        return parse_tree_input_traits<Node>::is_null(node);
    }
 
    template <typename Node>
    friend constexpr bool operator!=(const Node& node, _parse_tree_eof) noexcept
    {
        return !parse_tree_input_traits<Node>::is_null(node);
    }
    template <typename Node>
    friend constexpr bool operator!=(_parse_tree_eof, const Node& node) noexcept
    {
        return !parse_tree_input_traits<Node>::is_null(node);
    }
};
 
template <typename Node>
class parse_tree_encoding
{
    using _traits = parse_tree_input_traits<Node>;
 
public:
    using char_encoding = typename _traits::char_encoding;
    using char_type     = typename char_encoding::char_type;
    using value_type    = Node;
 
    static LEXY_CONSTEVAL auto eof()
    {
        return _parse_tree_eof{};
    }
 
    template <typename NodeKind>
    static bool match(const Node& node, const NodeKind& node_kind)
    {
        return _traits::has_kind(node, node_kind);
    }
};
template <typename Node>
constexpr auto is_node_encoding<parse_tree_encoding<Node>> = true;
 
template <typename Node>
class _ptr // parse tree reader
{
    using _traits = parse_tree_input_traits<Node>;
 
public:
    using encoding = parse_tree_encoding<Node>;
    using iterator = typename _traits::iterator;
 
    struct marker
    {
        Node _parent = _traits::null();
        Node _cur    = _traits::null();
 
        constexpr iterator position() const noexcept
        {
            return _cur == _parse_tree_eof{} ? _traits::position_end(_parent)
                                             : _traits::position_begin(_cur);
        }
    };
 
    constexpr explicit _ptr(const Node& root) noexcept
    : _parent(root), _cur(_traits::first_child(root))
    {}
 
    constexpr _ptr child_reader() const& noexcept
    {
        return _ptr(_cur);
    }
    constexpr auto lexeme_reader() const& noexcept
    {
        auto lexeme = _traits::lexeme(_cur);
        return _range_reader<typename encoding::char_encoding>(lexeme.begin(), lexeme.end());
    }
 
    constexpr const Node& peek() const noexcept
    {
        return _cur;
    }
 
    constexpr void bump() noexcept
    {
        LEXY_PRECONDITION(_cur != _parse_tree_eof{});
        _cur = _traits::sibling(_cur);
    }
 
    constexpr marker current() const noexcept
    {
        return {_parent, _cur};
    }
    constexpr void reset(marker m) noexcept
    {
        _cur = m._cur;
    }
 
    constexpr iterator position() const noexcept
    {
        return current().position();
    }
 
private:
    Node _parent;
    Node _cur;
};
 
template <typename Node>
class parse_tree_input
{
public:
    using encoding   = parse_tree_encoding<Node>;
    using value_type = Node;
 
    //=== constructors ===//
    constexpr parse_tree_input() noexcept : _root(nullptr) {}
 
    constexpr explicit parse_tree_input(Node root) noexcept : _root(LEXY_MOV(root)) {}
 
    template <typename ParseTree, typename = std::enable_if_t<std::is_same_v<
                                      Node, LEXY_DECAY_DECLTYPE(LEXY_DECLVAL(ParseTree).root())>>>
    constexpr explicit parse_tree_input(const ParseTree& tree) noexcept : _root(tree.root())
    {}
 
    //=== access ===//
    constexpr const Node& root() const noexcept
    {
        return _root;
    }
 
    //=== reader ===//
    constexpr auto reader() const& noexcept
    {
        return _ptr<Node>(_root);
    }
 
private:
    Node _root;
};
 
template <typename ParseTree>
parse_tree_input(const ParseTree&)
    -> parse_tree_input<LEXY_DECAY_DECLTYPE(LEXY_DECLVAL(ParseTree).root())>;
 
//=== convenience typedefs ===//
template <typename Node>
using parse_tree_lexeme = lexeme_for<parse_tree_input<Node>>;
 
template <typename Tag, typename Node>
using parse_tree_error = error_for<parse_tree_input<Node>, Tag>;
 
template <typename Node>
using parse_tree_error_context = error_context<parse_tree_input<Node>>;
} // namespace lexy
 
#endif // LEXY_INPUT_PARSE_TREE_INPUT_HPP_INCLUDED