parser.hpp

Go to the documentation of this file.

 
#ifndef PRISM_PARSER_HPP
#define PRISM_PARSER_HPP
 
#include "prism/compiler/cplusplus.hpp"
#include "prism/compiler/lifetimebound.hpp"
 
#include "prism/arena.h"
#include "prism/constant_pool.h"
#include "prism/line_offset_list.h"
#include "prism/parser.h"
 
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <iterator>
#include <memory>
#include <string_view>
 
namespace prism {
 
struct parser_deleter {
    void operator()(pm_parser_t *parser) const noexcept { pm_parser_free(parser); }
};
 
using unique_parser = std::unique_ptr<pm_parser_t, parser_deleter>;
 
[[nodiscard]] inline unique_parser
make_parser(pm_arena_t *arena PRISM_LIFETIMEBOUND, std::string_view source PRISM_LIFETIMEBOUND, const pm_options_t *options PRISM_LIFETIMEBOUND = nullptr) noexcept {
    return unique_parser(pm_parser_new(arena, reinterpret_cast<const std::uint8_t *>(source.data()), source.size(), options));
}
 
[[nodiscard]] inline std::string_view
constant(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_constant_id_t constant_id) noexcept {
    assert(constant_id != 0);
    const pm_constant_t *entry = pm_parser_constant(parser, constant_id);
    return std::string_view(reinterpret_cast<const char *>(pm_constant_start(entry)), pm_constant_length(entry));
}
 
[[nodiscard]] inline std::string_view
slice(const pm_parser_t *parser PRISM_LIFETIMEBOUND, pm_location_t location) noexcept {
    return std::string_view(reinterpret_cast<const char *>(pm_parser_start(parser) + location.start), location.length);
}
 
[[nodiscard]] inline pm_line_column_t
line_column(const pm_parser_t *parser, std::uint32_t offset) noexcept {
    return pm_line_offset_list_line_column(pm_parser_line_offsets(parser), offset, pm_parser_start_line(parser));
}
 
namespace detail {
 
template <typename T, const T *(*Next)(const T *)> class next_range {
public:
    class iterator {
    public:
        using iterator_category = std::forward_iterator_tag;
 
        using value_type = const T *;
 
        using difference_type = std::ptrdiff_t;
 
        using pointer = const value_type *;
 
        using reference = const value_type &;
 
        iterator() noexcept = default;
 
        explicit iterator(const T *current) noexcept : current_(current) {}
 
        reference operator*() const noexcept { return current_; }
 
        iterator &
        operator++() noexcept {
            assert(current_ != nullptr);
            current_ = Next(current_);
            return *this;
        }
 
        iterator
        operator++(int) noexcept {
            iterator previous = *this;
            ++*this;
            return previous;
        }
 
        friend bool operator==(iterator left, iterator right) noexcept { return left.current_ == right.current_; }
 
        friend bool operator!=(iterator left, iterator right) noexcept { return left.current_ != right.current_; }
 
    private:
        const T *current_ = nullptr;
    };
 
    next_range(const T *first, std::size_t size) noexcept : first_(first), size_(size) {}
 
    iterator begin() const noexcept { return iterator(first_); }
 
    iterator end() const noexcept { return iterator(); }
 
    std::size_t size() const noexcept { return size_; }
 
    [[nodiscard]] bool empty() const noexcept { return size_ == 0; }
 
private:
    const T *first_;
    std::size_t size_;
};
 
}
 
using diagnostic_range = detail::next_range<pm_diagnostic_t, pm_diagnostic_next>;
 
using comment_range = detail::next_range<pm_comment_t, pm_comment_next>;
 
using magic_comment_range = detail::next_range<pm_magic_comment_t, pm_magic_comment_next>;
 
[[nodiscard]] inline diagnostic_range
errors(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
    return diagnostic_range(pm_parser_errors_first(parser), pm_parser_errors_size(parser));
}
 
[[nodiscard]] inline diagnostic_range
warnings(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
    return diagnostic_range(pm_parser_warnings_first(parser), pm_parser_warnings_size(parser));
}
 
[[nodiscard]] inline comment_range
comments(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
    return comment_range(pm_parser_comments_first(parser), pm_parser_comments_size(parser));
}
 
[[nodiscard]] inline magic_comment_range
magic_comments(const pm_parser_t *parser PRISM_LIFETIMEBOUND) noexcept {
    return magic_comment_range(pm_parser_magic_comments_first(parser), pm_parser_magic_comments_size(parser));
}
 
}
 
#endif