PuqiAR
e28921ae02
[Fix] 修复科学表达式数字解析的问题（Lexer引起） 由 Satklomi发现，感谢 [Feat] 增加Compiler相关定义，将开发BytecodeVM [Tip] Evaluator进入Bug fix阶段，新功能延缓开发。转向VM
313 lines
12 KiB
C++
313 lines
12 KiB
C++
#pragma once
|
||
|
||
#include "Ast/astBase.hpp"
|
||
#include <Ast/ast.hpp>
|
||
#include <Lexer/lexer.hpp>
|
||
#include <Core/fig_string.hpp>
|
||
#include <Error/error.hpp>
|
||
|
||
#include <print>
|
||
#include <source_location>
|
||
#include <unordered_map>
|
||
|
||
#include <stack>
|
||
|
||
namespace Fig
|
||
{
|
||
|
||
class Parser
|
||
{
|
||
private:
|
||
Lexer lexer;
|
||
std::vector<Ast::AstBase> output;
|
||
std::vector<Token> previousTokens;
|
||
|
||
size_t tokenPruduced = 0;
|
||
size_t currentTokenIndex = 0;
|
||
|
||
std::unique_ptr<AddressableError> error;
|
||
|
||
Ast::AstAddressInfo currentAAI;
|
||
|
||
std::stack<Ast::Expression> exprStack;
|
||
|
||
bool needSemicolon = true;
|
||
|
||
class SemicolonDisabler
|
||
{
|
||
Parser *p;
|
||
bool original;
|
||
|
||
public:
|
||
SemicolonDisabler(Parser *parser) : p(parser), original(p->needSemicolon) { p->needSemicolon = false; }
|
||
~SemicolonDisabler() { p->needSemicolon = original; }
|
||
// disable copy and assign
|
||
SemicolonDisabler(const SemicolonDisabler &) = delete;
|
||
SemicolonDisabler &operator=(const SemicolonDisabler &) = delete;
|
||
};
|
||
|
||
void pushNode(const Ast::AstBase &_node)
|
||
{
|
||
Ast::AstBase node = _node;
|
||
node->setAAI(currentAAI);
|
||
output.push_back(std::move(node));
|
||
}
|
||
void pushNode(const Ast::AstBase &_node, Ast::AstAddressInfo _aai)
|
||
{
|
||
Ast::AstBase node = _node;
|
||
node->setAAI(_aai);
|
||
output.push_back(node);
|
||
}
|
||
|
||
bool isTokenSymbol(Token tok) { return Lexer::symbol_map.contains(tok.getValue()); }
|
||
bool isTokenOp(Token tok) { return Ast::TokenToOp.contains(tok.getType()); }
|
||
bool isEOF()
|
||
{
|
||
if (tokenPruduced == 0) return false;
|
||
return currentToken() == EOFTok;
|
||
}
|
||
|
||
public:
|
||
using Precedence = uint32_t;
|
||
static const std::unordered_map<Ast::Operator, std::pair<Precedence, Precedence>> opPrecedence;
|
||
static const std::unordered_map<Ast::Operator, Precedence> unaryOpPrecedence;
|
||
|
||
Parser(const Lexer &_lexer) : lexer(_lexer) {}
|
||
|
||
AddressableError *getError() const { return error.get(); }
|
||
|
||
template <class _ErrT, typename = AddressableError>
|
||
void throwAddressableError(FString msg,
|
||
size_t line,
|
||
size_t column,
|
||
std::source_location loc = std::source_location::current())
|
||
{
|
||
static_assert(std::is_base_of_v<AddressableError, _ErrT>, "_ErrT must derive from AddressableError");
|
||
_ErrT spError(msg, line, column, loc);
|
||
error = std::make_unique<_ErrT>(spError);
|
||
throw spError;
|
||
}
|
||
template <class _ErrT, typename = AddressableError>
|
||
void throwAddressableError(FString msg, std::source_location loc = std::source_location::current())
|
||
{
|
||
static_assert(std::is_base_of_v<AddressableError, _ErrT>, "_ErrT must derive from AddressableError");
|
||
// line, column provide by `currentAAI`
|
||
_ErrT spError(msg, currentAAI.line, currentAAI.column, loc);
|
||
error = std::make_unique<_ErrT>(spError);
|
||
throw spError;
|
||
}
|
||
|
||
template <class _ErrT, typename = UnaddressableError>
|
||
void throwUnaddressableError(FString msg, std::source_location loc = std::source_location::current())
|
||
{
|
||
static_assert(std::is_base_of_v<AddressableError, _ErrT>, "_ErrT must derive from AddressableError");
|
||
_ErrT spError(msg, loc);
|
||
error = std::make_unique<_ErrT>(spError);
|
||
throw spError;
|
||
}
|
||
|
||
void setCurrentAAI(Ast::AstAddressInfo _aai) { currentAAI = std::move(_aai); }
|
||
|
||
Ast::AstAddressInfo getCurrentAAI() const { return currentAAI; }
|
||
|
||
inline const Token &nextToken()
|
||
{
|
||
// 没有Rollback时, 存在 currentTokenIndex = tokenPruduced - 1
|
||
next();
|
||
return currentToken();
|
||
}
|
||
inline void rollback()
|
||
{
|
||
if (int64_t(currentTokenIndex - 1) < int64_t(0))
|
||
// 同下 next注释
|
||
{
|
||
throw std::runtime_error(
|
||
"Internal Error in Parser::rollbackToken, trying to rollback but it's already on the begin");
|
||
}
|
||
currentTokenIndex--;
|
||
}
|
||
inline void next()
|
||
{
|
||
if (int64_t(currentTokenIndex) < (int64_t(tokenPruduced) - 1))
|
||
{
|
||
/*
|
||
必须两个都显示转换为int64_t.否则，负数时会超出范围，变成int64_t max, 并且
|
||
CTI也需要显示转换，否则转换完的pruduced又会被转回去，变为 int64_t max
|
||
*/
|
||
currentTokenIndex++;
|
||
setCurrentAAI(Ast::AstAddressInfo{.line = currentToken().line, .column = currentToken().column});
|
||
return;
|
||
}
|
||
if (isEOF()) return;
|
||
const Token &tok = lexer.nextToken();
|
||
tokenPruduced++;
|
||
if (tok == IllegalTok) throw lexer.getError();
|
||
currentTokenIndex = tokenPruduced - 1;
|
||
setCurrentAAI(Ast::AstAddressInfo{.line = tok.line, .column = tok.column});
|
||
previousTokens.push_back(tok);
|
||
}
|
||
inline const Token ¤tToken()
|
||
{
|
||
if (tokenPruduced == 0) return nextToken();
|
||
return previousTokens.at(currentTokenIndex);
|
||
}
|
||
inline Token rollbackToken()
|
||
{
|
||
rollback();
|
||
return previousTokens.at(currentTokenIndex);
|
||
}
|
||
|
||
inline Token peekToken()
|
||
{
|
||
Token tok = nextToken();
|
||
rollback();
|
||
return tok;
|
||
}
|
||
|
||
const std::pair<Precedence, Precedence> &getBindingPower(Ast::Operator op) const { return opPrecedence.at(op); }
|
||
Precedence getLeftBindingPower(Ast::Operator op) const { return getBindingPower(op).first; }
|
||
Precedence getRightBindingPower(Ast::Operator op) const { return getBindingPower(op).second; }
|
||
|
||
const Precedence &getUnaryBp(Ast::Operator op) const { return unaryOpPrecedence.at(op); }
|
||
|
||
// template <class _Tp, class... Args>
|
||
// std::shared_ptr<_Tp> makeAst(Args &&...args)
|
||
// {
|
||
// _Tp node(std::forward<Args>(args)...);
|
||
// node.setAAI(currentAAI);
|
||
// return std::shared_ptr<_Tp>(new _Tp(node));
|
||
// }
|
||
template <class _Tp, class... Args>
|
||
std::shared_ptr<_Tp> makeAst(Args &&...args)
|
||
{
|
||
std::shared_ptr<_Tp> ptr = std::make_shared<_Tp>(std::forward<Args>(args)...);
|
||
ptr->setAAI(currentAAI);
|
||
return ptr;
|
||
}
|
||
|
||
void expectPeek(TokenType type, std::source_location loc = std::source_location::current())
|
||
{
|
||
if (peekToken().getType() != type)
|
||
{
|
||
throwAddressableError<SyntaxError>(FString(std::format("Expected `{}`, but got `{}`",
|
||
magic_enum::enum_name(type),
|
||
magic_enum::enum_name(peekToken().getType()))),
|
||
loc);
|
||
}
|
||
}
|
||
|
||
void expect(TokenType type, std::source_location loc = std::source_location::current())
|
||
{
|
||
if (currentToken().getType() != type)
|
||
{
|
||
throwAddressableError<SyntaxError>(
|
||
FString(std::format("Expected `{}`, but got `{}`",
|
||
magic_enum::enum_name(type),
|
||
magic_enum::enum_name(currentToken().getType()))),
|
||
loc);
|
||
}
|
||
}
|
||
|
||
void expectPeek(TokenType type, FString expected, std::source_location loc = std::source_location::current())
|
||
{
|
||
if (peekToken().getType() != type)
|
||
{
|
||
throwAddressableError<SyntaxError>(FString(std::format("Expected `{}`, but got `{}`",
|
||
expected.toBasicString(),
|
||
magic_enum::enum_name(peekToken().getType()))),
|
||
loc);
|
||
}
|
||
}
|
||
|
||
void expect(TokenType type, FString expected, std::source_location loc = std::source_location::current())
|
||
{
|
||
if (currentToken().getType() != type)
|
||
{
|
||
throwAddressableError<SyntaxError>(
|
||
FString(std::format("Expected `{}`, but got `{}`",
|
||
expected.toBasicString(),
|
||
magic_enum::enum_name(currentToken().getType()))),
|
||
loc);
|
||
}
|
||
}
|
||
|
||
[[nodiscard]] SemicolonDisabler disableSemicolon() { return SemicolonDisabler(this); }
|
||
|
||
void expectSemicolon()
|
||
{
|
||
// if need semicolon and stream has `;`, consume it. if not need semicolon, do nothing
|
||
|
||
if (!needSemicolon)
|
||
{
|
||
// disabled semicolon check
|
||
if (currentToken().getType() == TokenType::Semicolon)
|
||
{
|
||
next(); // consume `;`
|
||
}
|
||
return;
|
||
}
|
||
|
||
// normal semicolon check
|
||
expectConsume(TokenType::Semicolon);
|
||
}
|
||
|
||
void expectConsume(TokenType type, FString expected)
|
||
{
|
||
expect(type, expected);
|
||
next();
|
||
}
|
||
|
||
void expectConsume(TokenType type)
|
||
{
|
||
expect(type);
|
||
next();
|
||
}
|
||
|
||
bool isNext(TokenType type) { return peekToken().getType() == type; }
|
||
bool isThis(TokenType type) { return currentToken().getType() == type; }
|
||
|
||
static constexpr FString varDefTypeFollowed = u8"(Followed)";
|
||
|
||
Ast::VarDef __parseVarDef(bool); // entry: current is keyword `var` or `const` (isConst: Bool)
|
||
ObjectPtr __parseValue();
|
||
Ast::ValueExpr __parseValueExpr();
|
||
Ast::FunctionParameters __parseFunctionParameters(); // entry: current is Token::LeftParen
|
||
Ast::BlockStatement __parseBlockStatement(); // entry: current is Token::LeftBrace
|
||
Ast::If __parseIf(); // entry: current is Token::If
|
||
Ast::While __parseWhile(); // entry: current is Token::While
|
||
Ast::Statement __parseIncrementStatement(); // only allowed in __parseFor function
|
||
Ast::For __parseFor(); // entry: current is Token::For
|
||
Ast::Return __parseReturn(); // entry: current is Token::Return
|
||
Ast::Break __parseBreak(); // entry: current is Token::Break
|
||
Ast::Continue __parseContinue(); // entry: current is Token::Continue
|
||
|
||
Ast::VarExpr __parseVarExpr(FString);
|
||
Ast::FunctionDef __parseFunctionDef(bool); // entry: current is Token::Identifier (isPublic: Bool)
|
||
Ast::StructDef __parseStructDef(bool); // entry: current is Token::Identifier (struct name) arg(isPublic: bool)
|
||
Ast::InterfaceDef
|
||
__parseInterfaceDef(bool); // entry: current is Token::Identifier (interface name) arg(isPublic: bool)
|
||
Ast::Implement __parseImplement(); // entry: current is `impl`
|
||
|
||
Ast::Throw __parseThrow(); // entry: current is `throw`
|
||
Ast::Try __parseTry(); // entry: current is `try`
|
||
|
||
Ast::BinaryExpr __parseInfix(Ast::Expression, Ast::Operator, Precedence);
|
||
Ast::UnaryExpr __parsePrefix(Ast::Operator, Precedence);
|
||
Ast::Expression __parseCall(Ast::Expression);
|
||
|
||
Ast::ListExpr __parseListExpr(); // entry: current is `[`
|
||
Ast::MapExpr __parseMapExpr(); // entry: current is `{`
|
||
|
||
Ast::InitExpr __parseInitExpr(
|
||
Ast::Expression); // entry: current is `{`, ahead is struct type exp.
|
||
Ast::Expression __parseTupleOrParenExpr(); // entry: current is `(`
|
||
|
||
Ast::FunctionLiteralExpr __parseFunctionLiteralExpr(); // entry: current is Token::LParen after Token::Function
|
||
|
||
Ast::Import __parseImport(); // entry: current is Token::Import
|
||
|
||
Ast::Statement __parseStatement(bool = true); // entry: (idk)
|
||
Ast::Expression parseExpression(Precedence, TokenType = TokenType::Semicolon, TokenType = TokenType::Semicolon);
|
||
std::vector<Ast::AstBase> parseAll();
|
||
};
|
||
}; // namespace Fig
|