node.hpp

Go to the documentation of this file.

 
#ifndef PRISM_NODE_HPP
#define PRISM_NODE_HPP
 
#include "prism/compiler/cplusplus.hpp"
#include "prism/compiler/exceptions.hpp"
#include "prism/compiler/lifetimebound.hpp"
 
#include "prism/ast.hpp"
#include "prism/node.h"
#include "prism/node_type.hpp"
 
#include <cassert>
#include <cstddef>
#include <exception>
#include <functional>
#include <memory>
#include <type_traits>
 
namespace prism {
 
template <typename T> [[nodiscard]] bool
isa(const pm_node_t *node) noexcept {
    static_assert(is_node_v<T>, "isa<T> requires a node struct declared in ast.h");
    assert(node != nullptr);
    return node->type == node_type_v<T>;
}
 
template <typename T> [[nodiscard]] T *
cast(pm_node_t *node) noexcept {
    assert(isa<T>(node));
    return reinterpret_cast<T *>(node);
}
 
template <typename T> [[nodiscard]] const T *
cast(const pm_node_t *node) noexcept {
    assert(isa<T>(node));
    return reinterpret_cast<const T *>(node);
}
 
template <typename T> [[nodiscard]] T *
dyn_cast(pm_node_t *node) noexcept {
    return (node != nullptr && isa<T>(node)) ? reinterpret_cast<T *>(node) : nullptr;
}
 
template <typename T> [[nodiscard]] const T *
dyn_cast(const pm_node_t *node) noexcept {
    return (node != nullptr && isa<T>(node)) ? reinterpret_cast<const T *>(node) : nullptr;
}
 
template <typename T> [[nodiscard]] pm_node_t *
upcast(T *node) noexcept {
    static_assert(is_node_v<T>, "upcast requires a node struct declared in ast.h");
    return &node->base;
}
 
template <typename T> [[nodiscard]] const pm_node_t *
upcast(const T *node) noexcept {
    static_assert(is_node_v<T>, "upcast requires a node struct declared in ast.h");
    return &node->base;
}
 
class node_range {
public:
    explicit node_range(const pm_node_list_t &list PRISM_LIFETIMEBOUND) noexcept : list_(&list) {}
 
    pm_node_t *const *begin() const noexcept { return list_->nodes; }
 
    pm_node_t *const *end() const noexcept { return list_->nodes + list_->size; }
 
    std::size_t size() const noexcept { return list_->size; }
 
    [[nodiscard]] bool empty() const noexcept { return list_->size == 0; }
 
private:
    const pm_node_list_t *list_;
};
 
namespace detail {
 
template <typename F> struct visit_context {
    explicit visit_context(F *visitor) noexcept : callable(visitor) {}
 
    F *callable;
 
#ifdef PRISM_HAS_EXCEPTIONS
    std::exception_ptr exception;
#endif
};
 
template <typename F> pm_visit_result_t
visit_callback(const pm_node_t *node, void *data) noexcept {
    visit_context<F> *context = static_cast<visit_context<F> *>(data);
 
#ifdef PRISM_HAS_EXCEPTIONS
    try {
        return std::invoke(*context->callable, node);
    } catch (...) {
        context->exception = std::current_exception();
        return PM_VISIT_STOP;
    }
#else
    return std::invoke(*context->callable, node);
#endif
}
 
}
 
template <typename F> bool
visit_node(const pm_node_t *node, F &&visitor) {
    static_assert(std::is_invocable_r_v<pm_visit_result_t, F &, const pm_node_t *>, "visit_node requires a callable taking const pm_node_t * and returning pm_visit_result_t");
    detail::visit_context<std::remove_reference_t<F>> context(std::addressof(visitor));
    bool completed = pm_visit_node(node, detail::visit_callback<std::remove_reference_t<F>>, &context);
 
#ifdef PRISM_HAS_EXCEPTIONS
    if (context.exception) std::rethrow_exception(context.exception);
#endif
 
    return completed;
}
 
template <typename F> bool
visit_child_nodes(const pm_node_t *node, F &&visitor) {
    static_assert(std::is_invocable_r_v<pm_visit_result_t, F &, const pm_node_t *>, "visit_child_nodes requires a callable taking const pm_node_t * and returning pm_visit_result_t");
    detail::visit_context<std::remove_reference_t<F>> context(std::addressof(visitor));
    bool completed = pm_visit_child_nodes(node, detail::visit_callback<std::remove_reference_t<F>>, &context);
 
#ifdef PRISM_HAS_EXCEPTIONS
    if (context.exception) std::rethrow_exception(context.exception);
#endif
 
    return completed;
}
 
}
 
#endif