70 lines
1.7 KiB
C++
70 lines
1.7 KiB
C++
#include "ast/ast.hpp"
|
|
#include "lexer/lexer.hpp"
|
|
#include "parser/parser.hpp"
|
|
|
|
#include <cxxabi.h>
|
|
#include <doctest.h>
|
|
#include <memory>
|
|
#include <sstream>
|
|
|
|
void check_parser_errors(const std::vector<ast::error::error*>&);
|
|
|
|
namespace {
|
|
|
|
std::string demangle(const char* name) {
|
|
int status = 0;
|
|
std::unique_ptr<char, decltype(&std::free)> demangled(
|
|
abi::__cxa_demangle(name, nullptr, nullptr, &status),
|
|
&std::free
|
|
);
|
|
return (status == 0 && demangled) ? demangled.get() : name;
|
|
}
|
|
|
|
template <typename T, typename Base>
|
|
T* cast_impl(Base* base) {
|
|
static_assert(
|
|
std::is_base_of_v<Base, T>,
|
|
"T must be derived from Base"
|
|
);
|
|
|
|
T* t;
|
|
REQUIRE_NOTHROW(t = dynamic_cast<T*>(base));
|
|
REQUIRE_MESSAGE(
|
|
t != nullptr,
|
|
"Couldn't cast " * demangle(typeid(*base).name()) * " (given as "
|
|
* demangle(typeid(Base).name()) * ")" * " to a "
|
|
* demangle(typeid(T).name())
|
|
);
|
|
return t;
|
|
}
|
|
} // namespace
|
|
|
|
// Overloads for your known base types
|
|
template <typename T>
|
|
T* cast(ast::expression* expr) {
|
|
return cast_impl<T, ast::expression>(expr);
|
|
}
|
|
|
|
template <typename T>
|
|
T* cast(ast::statement* stmt) {
|
|
return cast_impl<T, ast::statement>(stmt);
|
|
}
|
|
|
|
template <typename T>
|
|
T* cast(ast::error::error* err) {
|
|
return cast_impl<T, ast::error::error>(err);
|
|
}
|
|
|
|
struct ParserFixture {
|
|
std::stringstream input;
|
|
lexer::lexer* lexer = nullptr;
|
|
parser::parser* parser = nullptr;
|
|
ast::program* program = nullptr;
|
|
|
|
ParserFixture() = default;
|
|
|
|
void setup(std::string);
|
|
|
|
~ParserFixture();
|
|
};
|