chore: flat out the file structure
This commit is contained in:
@@ -0,0 +1,346 @@
|
||||
#ifndef FURC_FRONT_AST_HPP
|
||||
#define FURC_FRONT_AST_HPP
|
||||
|
||||
#include <cstdint>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace furc {
|
||||
|
||||
struct comp_stmt_node;
|
||||
struct if_stmt_node;
|
||||
struct while_stmt_node;
|
||||
struct return_stmt_node;
|
||||
struct var_decl_node;
|
||||
struct func_decl_node;
|
||||
struct var_read_expr_node;
|
||||
struct func_call_expr_node;
|
||||
struct group_expr_node;
|
||||
struct binary_op_expr_node;
|
||||
struct unary_op_expr_node;
|
||||
struct if_expr_node;
|
||||
struct int_lit_node;
|
||||
struct char_lit_node;
|
||||
|
||||
struct ast_visitor {
|
||||
ast_visitor() = default;
|
||||
virtual ~ast_visitor() = default;
|
||||
|
||||
ast_visitor(ast_visitor&&) noexcept = default;
|
||||
ast_visitor& operator=(ast_visitor&&) noexcept = default;
|
||||
|
||||
ast_visitor(const ast_visitor&) = default;
|
||||
ast_visitor& operator=(const ast_visitor&) = default;
|
||||
|
||||
virtual void visit_comp_stmt_node(const comp_stmt_node& node) {}
|
||||
virtual void visit_if_stmt_node(const if_stmt_node& node) {}
|
||||
virtual void visit_while_stmt_node(const while_stmt_node& node) {}
|
||||
virtual void visit_return_stmt_node(const return_stmt_node& node) {}
|
||||
|
||||
virtual void visit_var_decl_node(const var_decl_node& node) {}
|
||||
virtual void visit_func_decl_node(const func_decl_node& node) {}
|
||||
|
||||
virtual void visit_var_read_expr_node(const var_read_expr_node& node) {}
|
||||
virtual void visit_func_call_expr_node(const func_call_expr_node& node) {}
|
||||
virtual void visit_group_expr_node(const group_expr_node& node) {}
|
||||
virtual void visit_binary_op_expr_node(const binary_op_expr_node& node) {}
|
||||
virtual void visit_unary_op_expr_node(const unary_op_expr_node& node) {}
|
||||
virtual void visit_if_expr_node(const if_expr_node& node) {}
|
||||
|
||||
virtual void visit_int_lit_node(const int_lit_node& node) {}
|
||||
virtual void visit_char_lit_node(const char_lit_node& node) {}
|
||||
};
|
||||
|
||||
struct ast_type {
|
||||
enum type_e {
|
||||
Void = 0,
|
||||
S8,
|
||||
U8,
|
||||
S16,
|
||||
U16,
|
||||
S32,
|
||||
U32,
|
||||
S64,
|
||||
U64,
|
||||
} type = Void;
|
||||
};
|
||||
|
||||
class ast_node {
|
||||
public:
|
||||
enum category_e {
|
||||
Statement,
|
||||
Declaration,
|
||||
Expression,
|
||||
Literal,
|
||||
};
|
||||
public:
|
||||
ast_node() = default;
|
||||
virtual ~ast_node() = default;
|
||||
|
||||
ast_node(ast_node&&) noexcept = default;
|
||||
ast_node& operator=(ast_node&&) noexcept = default;
|
||||
|
||||
ast_node(const ast_node&) = delete;
|
||||
ast_node& operator=(const ast_node&) = delete;
|
||||
public:
|
||||
virtual category_e category() const = 0;
|
||||
|
||||
virtual void accept(ast_visitor& visitor) const = 0;
|
||||
};
|
||||
|
||||
using ast_node_cat = ast_node::category_e;
|
||||
|
||||
class stmt_node : public ast_node {
|
||||
public:
|
||||
enum stmt_type_e {
|
||||
Declaration = 0,
|
||||
Expression,
|
||||
|
||||
Compound,
|
||||
If,
|
||||
While,
|
||||
Return,
|
||||
};
|
||||
public:
|
||||
category_e category() const override { return ast_node_cat::Statement; }
|
||||
|
||||
virtual stmt_type_e stmt_type() const = 0;
|
||||
};
|
||||
|
||||
struct comp_stmt_node final : public stmt_node {
|
||||
stmt_type_e stmt_type() const override { return Compound; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_comp_stmt_node(*this); }
|
||||
|
||||
std::vector<stmt_node*> stmts;
|
||||
};
|
||||
|
||||
class expr_node;
|
||||
|
||||
struct if_stmt_node final : public stmt_node {
|
||||
stmt_type_e stmt_type() const override { return If; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_if_stmt_node(*this); }
|
||||
|
||||
expr_node* cond = nullptr;
|
||||
stmt_node* thenBranch = nullptr;
|
||||
stmt_node* elseBranch = nullptr;
|
||||
};
|
||||
|
||||
struct while_stmt_node final : public stmt_node {
|
||||
stmt_type_e stmt_type() const override { return While; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_while_stmt_node(*this); }
|
||||
|
||||
expr_node* cond = nullptr;
|
||||
stmt_node* body = nullptr;
|
||||
};
|
||||
|
||||
struct return_stmt_node final : public stmt_node {
|
||||
stmt_type_e stmt_type() const override { return Return; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_return_stmt_node(*this); }
|
||||
|
||||
expr_node* value = nullptr;
|
||||
};
|
||||
|
||||
class decl_node : public stmt_node {
|
||||
public:
|
||||
enum decl_type_e {
|
||||
Variable,
|
||||
Function
|
||||
};
|
||||
public:
|
||||
category_e category() const override { return ast_node_cat::Declaration; }
|
||||
|
||||
stmt_type_e stmt_type() const override { return Declaration; }
|
||||
|
||||
virtual decl_type_e decl_type() const = 0;
|
||||
};
|
||||
|
||||
struct var_decl_node final : public decl_node {
|
||||
decl_type_e decl_type() const override { return Variable; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_var_decl_node(*this); }
|
||||
|
||||
std::string name;
|
||||
ast_type type;
|
||||
expr_node* init = nullptr;
|
||||
};
|
||||
|
||||
struct func_decl_node final : public decl_node {
|
||||
decl_type_e decl_type() const override { return Function; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_func_decl_node(*this); }
|
||||
|
||||
struct def_s {
|
||||
comp_stmt_node body;
|
||||
std::vector<expr_node*> preConds;
|
||||
std::vector<expr_node*> postConds;
|
||||
};
|
||||
|
||||
std::string name;
|
||||
ast_type type;
|
||||
std::vector<var_decl_node> params;
|
||||
std::optional<def_s> def;
|
||||
};
|
||||
|
||||
class expr_node : public stmt_node {
|
||||
public:
|
||||
enum expr_type_e {
|
||||
Literal,
|
||||
|
||||
VarRead,
|
||||
FunctionCall,
|
||||
Group,
|
||||
BinaryOp,
|
||||
UnaryOp,
|
||||
If,
|
||||
};
|
||||
public:
|
||||
category_e category() const override { return ast_node_cat::Expression; }
|
||||
|
||||
stmt_type_e stmt_type() const override { return Expression; }
|
||||
|
||||
virtual expr_type_e expr_type() const = 0;
|
||||
};
|
||||
|
||||
struct var_read_expr_node final : public expr_node {
|
||||
expr_type_e expr_type() const override { return VarRead; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_var_read_expr_node(*this); }
|
||||
|
||||
std::string name;
|
||||
|
||||
var_read_expr_node(std::string&& name)
|
||||
: name(std::move(name)) {}
|
||||
};
|
||||
|
||||
struct func_call_expr_node final : public expr_node {
|
||||
expr_type_e expr_type() const override { return FunctionCall; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_func_call_expr_node(*this); }
|
||||
|
||||
expr_node* lhs = nullptr;
|
||||
std::vector<expr_node*> args;
|
||||
};
|
||||
|
||||
struct group_expr_node final : public expr_node {
|
||||
expr_type_e expr_type() const override { return Group; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_group_expr_node(*this); }
|
||||
|
||||
expr_node* inner = nullptr;
|
||||
};
|
||||
|
||||
struct binary_op_expr_node final : public expr_node {
|
||||
enum binary_op_type {
|
||||
Add = 0,
|
||||
Sub,
|
||||
Mul,
|
||||
Div,
|
||||
Mod,
|
||||
|
||||
Shl,
|
||||
Shr,
|
||||
BinAnd,
|
||||
BinOr,
|
||||
BinXor,
|
||||
And,
|
||||
Or,
|
||||
|
||||
Equals,
|
||||
NotEquals,
|
||||
LessThan,
|
||||
LessEquals,
|
||||
GreaterThan,
|
||||
GreaterEquals,
|
||||
};
|
||||
|
||||
expr_type_e expr_type() const override { return BinaryOp; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_binary_op_expr_node(*this); }
|
||||
|
||||
expr_node* lhs = nullptr;
|
||||
expr_node* rhs = nullptr;
|
||||
binary_op_type type = Add;
|
||||
};
|
||||
|
||||
struct unary_op_expr_node final : public expr_node {
|
||||
enum unary_op_type {
|
||||
Positive = 0,
|
||||
Negative,
|
||||
PreInc,
|
||||
PreDec,
|
||||
PostInc,
|
||||
PostDec,
|
||||
BinNot,
|
||||
Not,
|
||||
|
||||
Sizeof,
|
||||
Pointerof,
|
||||
Lengthof,
|
||||
};
|
||||
|
||||
expr_type_e expr_type() const override { return UnaryOp; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_unary_op_expr_node(*this); }
|
||||
|
||||
expr_node* lhs = nullptr;
|
||||
unary_op_type type = Positive;
|
||||
};
|
||||
|
||||
struct if_expr_node final : public expr_node {
|
||||
expr_type_e expr_type() const override { return If; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_if_expr_node(*this); }
|
||||
|
||||
expr_node* cond = nullptr;
|
||||
expr_node* thenExpr = nullptr;
|
||||
expr_node* elseExpr = nullptr;
|
||||
};
|
||||
|
||||
class lit_node : public expr_node {
|
||||
public:
|
||||
enum lit_type_e {
|
||||
Integer,
|
||||
Char,
|
||||
};
|
||||
public:
|
||||
category_e category() const override { return ast_node_cat::Literal; }
|
||||
|
||||
expr_type_e expr_type() const override { return Literal; }
|
||||
|
||||
virtual lit_type_e lit_type() const = 0;
|
||||
};
|
||||
|
||||
struct int_lit_node final : public lit_node {
|
||||
int_lit_node(std::uint64_t value)
|
||||
: value(value) {}
|
||||
|
||||
lit_type_e lit_type() const override { return Integer; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_int_lit_node(*this); }
|
||||
|
||||
std::uint64_t value;
|
||||
};
|
||||
|
||||
struct char_lit_node final : public lit_node {
|
||||
char_lit_node(char value)
|
||||
: value(value) {}
|
||||
|
||||
lit_type_e lit_type() const override { return Char; }
|
||||
|
||||
void accept(ast_visitor& visitor) const override { visitor.visit_char_lit_node(*this); }
|
||||
|
||||
char value;
|
||||
};
|
||||
|
||||
struct ast {
|
||||
std::vector<decl_node*> decls;
|
||||
};
|
||||
|
||||
} // namespace furc
|
||||
|
||||
#endif // FURC_FRONT_AST_HPP
|
||||
@@ -0,0 +1,47 @@
|
||||
#ifndef FURC_FRONT_LEXER_HPP
|
||||
#define FURC_FRONT_LEXER_HPP
|
||||
|
||||
#include "furc/front/token.hpp"
|
||||
|
||||
#include <cstddef>
|
||||
#include <deque>
|
||||
#include <string_view>
|
||||
|
||||
namespace furc {
|
||||
|
||||
class lexer {
|
||||
public:
|
||||
lexer(std::string_view filepath, std::string_view content)
|
||||
: m_filepath(filepath), m_content(content) {}
|
||||
|
||||
~lexer() = default;
|
||||
|
||||
lexer(lexer&&) noexcept = default;
|
||||
lexer& operator=(lexer&&) noexcept = default;
|
||||
|
||||
lexer(const lexer&) = delete;
|
||||
lexer& operator=(const lexer&) = delete;
|
||||
public:
|
||||
token next_token();
|
||||
token peek_token(std::size_t offset = 0);
|
||||
private:
|
||||
token get_token();
|
||||
|
||||
void next();
|
||||
constexpr char get(std::size_t offset = 0) const;
|
||||
void skip_spaces();
|
||||
|
||||
constexpr token::location location() const;
|
||||
private:
|
||||
std::string_view m_filepath;
|
||||
std::string_view m_content;
|
||||
std::size_t m_cursor = 0;
|
||||
std::size_t m_row = 0;
|
||||
std::size_t m_lineStart = 0;
|
||||
|
||||
std::deque<token> m_peekToken;
|
||||
};
|
||||
|
||||
} // namespace furc
|
||||
|
||||
#endif // FURC_FRONT_LEXER_HPP
|
||||
@@ -0,0 +1,51 @@
|
||||
#ifndef FURC_FRONT_PARSER_HPP
|
||||
#define FURC_FRONT_PARSER_HPP
|
||||
|
||||
#include "furc/front/ast.hpp"
|
||||
#include "furc/front/lexer.hpp"
|
||||
#include "furlang/arena.hpp"
|
||||
|
||||
#include <stdexcept>
|
||||
|
||||
namespace furc {
|
||||
|
||||
class parser {
|
||||
public:
|
||||
parser(lexer&& lexer, furlang::arena& arena)
|
||||
: m_lexer(std::move(lexer)), m_arena(&arena) {}
|
||||
|
||||
~parser() = default;
|
||||
|
||||
parser(parser&&) noexcept = default;
|
||||
parser& operator=(parser&&) noexcept = default;
|
||||
|
||||
parser(const parser&) = delete;
|
||||
parser& operator=(const parser&) = delete;
|
||||
public:
|
||||
ast parse();
|
||||
private:
|
||||
stmt_node* parse_stmt();
|
||||
decl_node* parse_decl();
|
||||
expr_node* parse_expr();
|
||||
|
||||
ast_type parse_type();
|
||||
comp_stmt_node parse_comp();
|
||||
|
||||
expr_node* parse_expr_primary();
|
||||
expr_node* parse_expr_unary();
|
||||
expr_node* parse_expr_right(expr_node* lhs, std::uint32_t precedence = 15);
|
||||
private:
|
||||
template <typename... Types>
|
||||
token eat_token(Types... types) {
|
||||
auto token = m_lexer.next_token();
|
||||
if (((token.type == types) || ...)) return token;
|
||||
throw std::runtime_error("unexpected token");
|
||||
}
|
||||
private:
|
||||
lexer m_lexer;
|
||||
furlang::arena* m_arena;
|
||||
};
|
||||
|
||||
} // namespace furc
|
||||
|
||||
#endif // FURC_FRONT_PARSER_HPP
|
||||
@@ -0,0 +1,218 @@
|
||||
#ifndef FURC_FRONT_TOKEN_HPP
|
||||
#define FURC_FRONT_TOKEN_HPP
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <ostream>
|
||||
#include <string_view>
|
||||
|
||||
namespace furc {
|
||||
|
||||
struct token {
|
||||
enum type {
|
||||
Identifier = 0,
|
||||
Integer,
|
||||
String,
|
||||
Char,
|
||||
|
||||
LParen, /**< `(` */
|
||||
RParen, /**< `)` */
|
||||
LBrace, /**< `{` */
|
||||
RBrace, /**< `}` */
|
||||
LBracket, /**< `[` */
|
||||
RBracket, /**< `]` */
|
||||
Semicolon, /**< `;` */
|
||||
Colon, /**< `:` */
|
||||
Comma, /**< `,` */
|
||||
Dot, /**< `.` */
|
||||
|
||||
Plus, /**< `+` */
|
||||
Minus, /**< `-` */
|
||||
Star, /**< `*` */
|
||||
Slash, /**< `/` */
|
||||
Percent, /**< `%` */
|
||||
DblLT, /**< `<<` */
|
||||
DblGT, /**< `>>` */
|
||||
Ampersand, /**< `&` */
|
||||
Pipe, /**< `|` */
|
||||
Hat, /**< `^` */
|
||||
DblAmpersand, /**< `&&` */
|
||||
DblPipe, /**< `||` */
|
||||
|
||||
DblPlus, /**< `++` */
|
||||
DblMinus, /**< `--` */
|
||||
Tilde, /**< `~` */
|
||||
ExMark, /**< `!` */
|
||||
CatEars, /**< `^^` */
|
||||
|
||||
Equals, /**< `=` */
|
||||
PlusEquals, /**< `+=` */
|
||||
MinusEquals, /**< `-=` */
|
||||
StarEquals, /**< `*=` */
|
||||
SlashEquals, /**< `/=` */
|
||||
PercentEquals, /**< `%=` */
|
||||
AmpersandEquals, /**< `&=` */
|
||||
PipeEquals, /**< `|=` */
|
||||
HatEquals, /**< `^=` */
|
||||
|
||||
DblEquals, /**< `==` */
|
||||
ExEquals, /**< `!=` */
|
||||
LessThan, /**< `<` */
|
||||
LessEquals, /**< `<=` */
|
||||
GreaterThan, /**< `>` */
|
||||
GreaterEquals, /**< `>=` */
|
||||
|
||||
SlimArrow, /**< `->` */
|
||||
// My brother just another me
|
||||
FatArrow, /**< `=>` */
|
||||
|
||||
Monkey, /**< `@` */
|
||||
Sha256, /**< `#` */
|
||||
|
||||
Func, /**< `func` */
|
||||
Return, /**< `return` */
|
||||
If, /**< `if` */
|
||||
Else, /**< `else` */
|
||||
While, /**< `while` */
|
||||
Public, /**< `public` */
|
||||
Private, /**< `private` */
|
||||
Pre, /**< `pre` */
|
||||
Post, /**< `post` */
|
||||
|
||||
Pointerof, /**< `pointerof` */
|
||||
Sizeof, /**< `sizeof` */
|
||||
Lengthof, /**< `lengthof` */
|
||||
|
||||
S8, /**< `s8` */
|
||||
U8, /**< `u8` */
|
||||
S16, /**< `s16` */
|
||||
U16, /**< `u16` */
|
||||
S32, /**< `s32` */
|
||||
U32, /**< `u32` */
|
||||
S64, /**< `s64` */
|
||||
U64, /**< `u64` */
|
||||
|
||||
// Errors:
|
||||
UnexpectedCharacter,
|
||||
UnexpectedEOF,
|
||||
InvalidInteger,
|
||||
EndOfFile,
|
||||
} type;
|
||||
union value {
|
||||
std::nullptr_t null = nullptr;
|
||||
std::uint64_t integer;
|
||||
std::string_view string;
|
||||
char character;
|
||||
} value;
|
||||
|
||||
struct location {
|
||||
std::string_view filepath;
|
||||
std::size_t row = 0;
|
||||
std::size_t col = 0;
|
||||
} loc;
|
||||
|
||||
token(location loc, enum type type)
|
||||
: loc(loc), type(type) {}
|
||||
|
||||
token(location loc, std::uint64_t integer)
|
||||
: loc(loc), type(Integer) {
|
||||
value.integer = integer;
|
||||
}
|
||||
|
||||
token(location loc, enum type type, std::string_view string)
|
||||
: loc(loc), type(type) {
|
||||
value.string = string;
|
||||
}
|
||||
|
||||
token(location loc, enum type type, char character)
|
||||
: loc(loc), type(type) {
|
||||
value.character = character;
|
||||
}
|
||||
|
||||
friend std::ostream& operator<<(std::ostream& os, const token& token) {
|
||||
switch (token.type) {
|
||||
case token::Identifier: return os << token.value.string;
|
||||
case token::String: return os << '"' << token.value.string << '"';
|
||||
case token::Char: return os << '\'' << token.value.character << '\'';
|
||||
case token::Integer: return os << token.value.integer;
|
||||
case token::LParen: return os << "(";
|
||||
case token::RParen: return os << ")";
|
||||
case token::LBrace: return os << "{";
|
||||
case token::RBrace: return os << "}";
|
||||
case token::LBracket: return os << "[";
|
||||
case token::RBracket: return os << "]";
|
||||
case token::Semicolon: return os << ";";
|
||||
case token::Colon: return os << ":";
|
||||
case token::Comma: return os << ",";
|
||||
case token::Dot: return os << ".";
|
||||
case token::Plus: return os << "+";
|
||||
case token::Minus: return os << "-";
|
||||
case token::Star: return os << "*";
|
||||
case token::Slash: return os << "/";
|
||||
case token::Percent: return os << "%";
|
||||
case token::DblLT: return os << "<<";
|
||||
case token::DblGT: return os << ">>";
|
||||
case token::Ampersand: return os << "&";
|
||||
case token::Pipe: return os << "|";
|
||||
case token::Hat: return os << "^";
|
||||
case token::DblAmpersand: return os << "&&";
|
||||
case token::DblPipe: return os << "||";
|
||||
case token::DblPlus: return os << "++";
|
||||
case token::DblMinus: return os << "--";
|
||||
case token::Tilde: return os << "~";
|
||||
case token::ExMark: return os << "!";
|
||||
case token::CatEars: return os << "^^";
|
||||
case token::Equals: return os << "=";
|
||||
case token::PlusEquals: return os << "+=";
|
||||
case token::MinusEquals: return os << "-=";
|
||||
case token::StarEquals: return os << "*=";
|
||||
case token::SlashEquals: return os << "/=";
|
||||
case token::PercentEquals: return os << "%=";
|
||||
case token::AmpersandEquals: return os << "&=";
|
||||
case token::PipeEquals: return os << "|=";
|
||||
case token::HatEquals: return os << "^=";
|
||||
case token::DblEquals: return os << "==";
|
||||
case token::ExEquals: return os << "!=";
|
||||
case token::LessThan: return os << "<";
|
||||
case token::LessEquals: return os << "<=";
|
||||
case token::GreaterThan: return os << ">";
|
||||
case token::GreaterEquals: return os << ">=";
|
||||
case token::SlimArrow: return os << "->";
|
||||
case token::FatArrow: return os << "=>";
|
||||
case token::Monkey: return os << "@";
|
||||
case token::Sha256: return os << "#";
|
||||
case token::Func: return os << "func";
|
||||
case token::Return: return os << "return";
|
||||
case token::If: return os << "if";
|
||||
case token::Else: return os << "else";
|
||||
case token::While: return os << "while";
|
||||
case token::Public: return os << "public";
|
||||
case token::Private: return os << "private";
|
||||
case token::Pre: return os << "pre";
|
||||
case token::Post: return os << "post";
|
||||
case token::Pointerof: return os << "pointerof";
|
||||
case token::Sizeof: return os << "sizeof";
|
||||
case token::Lengthof: return os << "lengthof";
|
||||
case token::S8: return os << "s8";
|
||||
case token::U8: return os << "u8";
|
||||
case token::S16: return os << "s16";
|
||||
case token::U16: return os << "u16";
|
||||
case token::S32: return os << "s32";
|
||||
case token::U32: return os << "u32";
|
||||
case token::S64: return os << "s64";
|
||||
case token::U64: return os << "u64";
|
||||
case token::UnexpectedCharacter: return os << "Unexpected character `" << token.value.character << "`";
|
||||
case token::UnexpectedEOF: return os << "Unexpected End Of File";
|
||||
case token::InvalidInteger: return os << "Invalid Integer";
|
||||
case token::EndOfFile: return os << "End Of File";
|
||||
}
|
||||
|
||||
return os;
|
||||
}
|
||||
};
|
||||
|
||||
using token_t = enum token::type;
|
||||
|
||||
} // namespace furc
|
||||
|
||||
#endif // FURC_FRONT_TOKEN_HPP
|
||||
Reference in New Issue
Block a user