1152 lines
53 KiB
C++
1152 lines
53 KiB
C++
#include "Parser.hpp"
|
|
#include <iostream>
|
|
#include "../CoreData/PrimitiveTypes.hpp"
|
|
#include "../Diagnostics/DiagnosticTypeEN_US.hpp"
|
|
|
|
#define PROGRESS_TOKEN(token) \
|
|
token = (token)->GetNext().get(); \
|
|
while ((token)->GetKind() == LexTokenKind::Whitespace) { \
|
|
(token) = (token)->GetNext().get(); \
|
|
}
|
|
|
|
#define EXPECT_TOKEN(token, kind) \
|
|
if ((token)->GetKind() != LexTokenKind::kind) { \
|
|
logUnexpectedToken(kind, token); \
|
|
if ((token)->GetNext() != nullptr && (token)->GetNext()->GetNext() != nullptr && \
|
|
(token)->GetNext()->GetKind() == LexTokenKind::kind) { \
|
|
(token) = (token)->GetNext()->GetNext().get(); \
|
|
} \
|
|
} else { \
|
|
PROGRESS_TOKEN(token); \
|
|
}
|
|
|
|
#define logError(type, span, formats) log(DiagnosticLevel::Error, type, span, formats)
|
|
#define logUnexpectedToken(expected, found) \
|
|
log(DiagnosticLevel::Error, DiagnosticType::UnexpectedToken, (found)->GetSpan(), \
|
|
{LexTokenKindHelper::ToString(LexTokenKind::expected), (found)->ToString()});
|
|
#define logUnexpectedTokenWithAnyOf(found, ...) \
|
|
std::vector<LexTokenKind> vars = {__VA_ARGS__}; \
|
|
auto expectedTokens = std::vector<std::string>(vars.size() + 1); \
|
|
for (size_t i = 0; i < vars.size(); i++) { \
|
|
expectedTokens[i] = LexTokenKindHelper::ToString(vars[i]); \
|
|
} \
|
|
expectedTokens[expectedTokens.size() - 1] = (found)->ToString(); \
|
|
log(DiagnosticLevel::Error, DiagnosticType::UnexpectedToken, (found)->GetSpan(), expectedTokens);
|
|
#define logUnexpectedTokenWithoutExpected(found) \
|
|
log(DiagnosticLevel::Error, DiagnosticType::UnexpectedToken, (found)->GetSpan(), {(found)->ToString()});
|
|
|
|
namespace MalachScript::Parser {
|
|
using namespace Diagnostics;
|
|
|
|
const ParsedScriptStatement* Parser::Parse(const LexToken* firstToken, std::u8string_view scriptName,
|
|
Logger* diagnostics) {
|
|
const log_func& log = [diagnostics, scriptName](DiagnosticLevel level, DiagnosticType type,
|
|
const TextSpan& span, const std::vector<std::string>& formats) {
|
|
diagnostics->Log(level, type, scriptName, span, formats);
|
|
};
|
|
|
|
ScopedPtr<const ParsedStatement> s = nullptr;
|
|
ParseScript(s, firstToken, log);
|
|
return dynamic_cast<const ParsedScriptStatement*>(s.TakeOwnership());
|
|
}
|
|
|
|
bool Parser::ParseScript(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
std::vector<const ParsedStatement*> statements;
|
|
const size_t reservedScriptSize = 32;
|
|
statements.reserve(reservedScriptSize);
|
|
size_t currentAmount = 0;
|
|
const auto* current = currentToken;
|
|
while (true) {
|
|
while (current->GetKind() == LexTokenKind::Whitespace) {
|
|
current = current->GetNext().get();
|
|
}
|
|
if (current->GetKind() == LexTokenKind::EndOfFile) {
|
|
break;
|
|
}
|
|
if (current->GetKind() == LexTokenKind::SemicolonSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
continue;
|
|
}
|
|
// Deal with namespace
|
|
if (current->GetKind() == LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
break;
|
|
}
|
|
ScopedPtr<const ParsedStatement> statement;
|
|
// TODO: Sort by performance
|
|
auto result = ParseTypeDef(statement, current, log) || ParseClass(statement, current, log) ||
|
|
ParseFunc(statement, current, log) || ParseNamespace(statement, current, log);
|
|
if (!result) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
PROGRESS_TOKEN(current);
|
|
continue;
|
|
}
|
|
statements.push_back(statement.TakeOwnership());
|
|
currentAmount++;
|
|
}
|
|
statements.resize(currentAmount);
|
|
auto end = 0;
|
|
if (currentAmount > 0) {
|
|
end = statements.back()->GetSpan().GetEnd();
|
|
}
|
|
out = new ParsedScriptStatement(TextSpan(0, end), statements);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseClass(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken, const log_func& log) {
|
|
const auto* current = currentToken;
|
|
auto start = current->GetSpan().GetStart();
|
|
bool lookingForClass = true;
|
|
ClassAttr classAttr = ClassAttr::None;
|
|
while (lookingForClass) {
|
|
switch (current->GetKind()) {
|
|
case LexTokenKind::SharedKeyword: ClassAttrHelpers::Set(classAttr, ClassAttr::Shared); break;
|
|
case LexTokenKind::AbstractKeyword: ClassAttrHelpers::Set(classAttr, ClassAttr::Abstract); break;
|
|
case LexTokenKind::FinalKeyword: ClassAttrHelpers::Set(classAttr, ClassAttr::Final); break;
|
|
case LexTokenKind::ExternalKeyword: ClassAttrHelpers::Set(classAttr, ClassAttr::External); break;
|
|
case LexTokenKind::ClassKeyword: lookingForClass = false; break;
|
|
default: return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
// After class keyword, an identifier should always follow, if it doesn't, log an error.
|
|
Identifier identifier;
|
|
if (!ParseIdentifier(identifier, current)) {
|
|
logUnexpectedToken(Identifier, current);
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
std::vector<Identifier> inherits;
|
|
std::vector<const ParsedStatement*> body;
|
|
|
|
switch (current->GetKind()) {
|
|
case LexTokenKind::SemicolonSymbol: {
|
|
PROGRESS_TOKEN(current);
|
|
break;
|
|
}
|
|
case LexTokenKind::ColonSymbol: {
|
|
PROGRESS_TOKEN(current);
|
|
Identifier id;
|
|
if (!ParseIdentifier(id, current)) {
|
|
logUnexpectedToken(Identifier, current);
|
|
return false;
|
|
}
|
|
inherits.push_back(id);
|
|
while (current->GetKind() == LexTokenKind::CommaSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
if (!ParseIdentifier(id, current)) {
|
|
logUnexpectedToken(Identifier, current);
|
|
return false;
|
|
}
|
|
inherits.push_back(id);
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
if (current->GetKind() != LexTokenKind::OpenCurlyParenthesisSymbol) {
|
|
logUnexpectedToken(OpenCurlyParenthesisSymbol, current);
|
|
return false;
|
|
}
|
|
[[fallthrough]];
|
|
// Intentionally don't break so we continue into the inner body statement.
|
|
}
|
|
case LexTokenKind::OpenCurlyParenthesisSymbol: {
|
|
PROGRESS_TOKEN(current);
|
|
while (true) {
|
|
// Cheapest operation, check first
|
|
if (current->GetKind() == LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
break;
|
|
}
|
|
ScopedPtr<const ParsedStatement> statement = nullptr;
|
|
// TODO: Sort by complexity
|
|
if (!ParseVirtProp(statement, current, log) && !ParseFunc(statement, current, log) &&
|
|
!ParseVar(statement, current, log) && !ParseFuncDef(statement, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
break;
|
|
}
|
|
body.push_back(statement.TakeOwnership());
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
logUnexpectedTokenWithAnyOf(current, LexTokenKind::SemicolonSymbol, LexTokenKind::ColonSymbol,
|
|
LexTokenKind::OpenCurlyParenthesisSymbol);
|
|
}
|
|
out = new ParsedClassStatement(TextSpan(start, current->GetSpan().GetEnd()), classAttr, identifier, inherits,
|
|
body);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseTypeDef(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::TypedefKeyword) {
|
|
return false;
|
|
}
|
|
auto start = current->GetSpan().GetStart();
|
|
PROGRESS_TOKEN(current);
|
|
Identifier defineFrom;
|
|
if (!ParsePrimType(defineFrom, current, log) && !ParseIdentifier(defineFrom, current)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
|
|
PROGRESS_TOKEN(current);
|
|
Identifier defineTo;
|
|
if (!ParseIdentifier(defineTo, current)) {
|
|
logUnexpectedToken(Identifier, current);
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
EXPECT_TOKEN(current, SemicolonSymbol);
|
|
out = new ParsedTypeDefStatement(TextSpan(start, current->GetSpan().GetEnd()), defineFrom, defineTo);
|
|
return true;
|
|
}
|
|
bool Parser::ParseNamespace(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::NamespaceKeyword) {
|
|
return false;
|
|
}
|
|
auto start = current->GetSpan().GetStart();
|
|
PROGRESS_TOKEN(current);
|
|
Identifier identifier;
|
|
if (!ParseIdentifier(identifier, current)) {
|
|
logUnexpectedToken(Identifier, current);
|
|
} else {
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
EXPECT_TOKEN(current, OpenCurlyParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> script = nullptr;
|
|
if (!ParseScript(script, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
auto end = current->GetSpan().GetEnd();
|
|
EXPECT_TOKEN(current, CloseCurlyParenthesisSymbol);
|
|
out = new ParsedNamespaceStatement(TextSpan(start, end), identifier,
|
|
(const ParsedScriptStatement*)script.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseFunc(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken, const log_func& log) {
|
|
const auto* current = currentToken;
|
|
auto start = current->GetSpan().GetStart();
|
|
bool isShared = false;
|
|
bool isExternal = false;
|
|
bool modifiers = true;
|
|
while (modifiers) {
|
|
switch (current->GetKind()) {
|
|
case LexTokenKind::SharedKeyword:
|
|
isShared = true;
|
|
PROGRESS_TOKEN(current);
|
|
continue;
|
|
case LexTokenKind::ExternalKeyword:
|
|
isExternal = true;
|
|
PROGRESS_TOKEN(current);
|
|
continue;
|
|
default: modifiers = false; break;
|
|
}
|
|
}
|
|
AccessModifier accessModifier = AccessModifier::Public;
|
|
if (current->GetKind() == LexTokenKind::PrivateKeyword) {
|
|
accessModifier = AccessModifier::Private;
|
|
PROGRESS_TOKEN(current);
|
|
} else if (current->GetKind() == LexTokenKind::ProtectedKeyword) {
|
|
accessModifier = AccessModifier::Protected;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ScopedPtr<const ParsedStatement> typeStatement = nullptr;
|
|
bool returnsReference = false;
|
|
if (current->GetKind() == LexTokenKind::TildeSymbol) {
|
|
// TODO: Handle destructor
|
|
throw std::logic_error("not implemented");
|
|
} else if (ParseType(typeStatement, current, log)) {
|
|
if (current->GetKind() == LexTokenKind::AmpersandSymbol) {
|
|
returnsReference = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
}
|
|
Identifier identifier;
|
|
if (!ParseIdentifier(identifier, current)) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
ScopedPtr<const ParsedStatement> paramList = nullptr;
|
|
if (!ParseParamList(paramList, current, log)) {
|
|
return false;
|
|
}
|
|
bool isConst = false;
|
|
if (current->GetKind() == LexTokenKind::ConstKeyword) {
|
|
isConst = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
FuncAttr funcAttr = FuncAttr::None;
|
|
ParseFuncAttr(funcAttr, current, log);
|
|
ScopedPtr<const ParsedStatement> statblock = nullptr;
|
|
if (current->GetKind() != LexTokenKind::SemicolonSymbol) {
|
|
if (!ParseStatBlock(statblock, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
} else {
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
out = new ParsedFuncStatement(TextSpan(start, current->GetSpan().GetEnd()), isShared, isExternal,
|
|
accessModifier, typeStatement.TakeOwnership(), returnsReference, identifier,
|
|
paramList.TakeOwnership(), isConst, funcAttr, statblock.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseType(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken, const log_func& log) {
|
|
const auto* current = currentToken;
|
|
auto start = current->GetSpan().GetStart();
|
|
bool isConst = false;
|
|
bool isArray = false;
|
|
bool isHandle = false;
|
|
if (current->GetKind() == LexTokenKind::ConstKeyword) {
|
|
isConst = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ScopedIdentifier scopedIdentifier;
|
|
ParseScope(scopedIdentifier.GetScope(), current, log);
|
|
if (!ParseDataType(scopedIdentifier.GetIdentifier(), current, log)) {
|
|
return false;
|
|
}
|
|
// TODO: Generics.
|
|
if (current->GetKind() == LexTokenKind::OpenBlockParenthesisSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
if (current->GetKind() != LexTokenKind::CloseBlockParenthesisSymbol) {
|
|
logUnexpectedToken(CloseCurlyParenthesisSymbol, current);
|
|
} else {
|
|
PROGRESS_TOKEN(current);
|
|
isArray = true;
|
|
}
|
|
} else if (current->GetKind() == LexTokenKind::AtSymbol) {
|
|
isHandle = true;
|
|
PROGRESS_TOKEN(current);
|
|
if (current->GetKind() == LexTokenKind::ConstKeyword) {
|
|
isConst = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
}
|
|
auto end = current->GetSpan().GetEnd();
|
|
currentToken = current;
|
|
out = new ParsedTypeStatement(TextSpan(start, end), isConst, isArray, isHandle, scopedIdentifier);
|
|
return true;
|
|
}
|
|
bool Parser::ParseScope(std::vector<Identifier>& scope, const LexToken*& currentToken, const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() == LexTokenKind::ColonColonSymbol) {
|
|
scope.emplace_back();
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
|
|
Identifier identifier;
|
|
if (ParseIdentifier(identifier, current)) {
|
|
PROGRESS_TOKEN(current);
|
|
scope.push_back(identifier);
|
|
if (current->GetKind() != LexTokenKind::ColonColonSymbol) {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
while (current->GetKind() == LexTokenKind::ColonColonSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
const auto* n = current;
|
|
if (ParseIdentifier(identifier, n)) {
|
|
PROGRESS_TOKEN(n);
|
|
if (n->GetKind() == LexTokenKind::ColonColonSymbol) {
|
|
current = n;
|
|
scope.push_back(identifier);
|
|
} else {
|
|
break;
|
|
}
|
|
} else {
|
|
logUnexpectedToken(Identifier, current);
|
|
break;
|
|
}
|
|
}
|
|
// TODO: Handle generics in script class name.
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseFuncAttr(FuncAttr& out, const LexToken*& currentToken, [[maybe_unused]] const log_func& log) {
|
|
bool lookingForFuncAttr = true;
|
|
const auto* current = currentToken;
|
|
while (lookingForFuncAttr) {
|
|
switch (current->GetKind()) {
|
|
case LexTokenKind::OverrideKeyword:
|
|
PROGRESS_TOKEN(current);
|
|
out = FuncAttrHelpers::Set(out, FuncAttr::Override);
|
|
continue;
|
|
case LexTokenKind::FinalKeyword:
|
|
PROGRESS_TOKEN(current);
|
|
out = FuncAttrHelpers::Set(out, FuncAttr::Final);
|
|
continue;
|
|
case LexTokenKind::ExplicitKeyword:
|
|
PROGRESS_TOKEN(current);
|
|
out = FuncAttrHelpers::Set(out, FuncAttr::Explicit);
|
|
continue;
|
|
case LexTokenKind::PropertyKeyword:
|
|
PROGRESS_TOKEN(current);
|
|
out = FuncAttrHelpers::Set(out, FuncAttr::Property);
|
|
continue;
|
|
default: lookingForFuncAttr = false; break;
|
|
}
|
|
}
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseParamList(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
if (currentToken->GetKind() != LexTokenKind::OpenParenthesisSymbol) {
|
|
return false;
|
|
}
|
|
auto start = currentToken->GetSpan().GetStart();
|
|
PROGRESS_TOKEN(currentToken);
|
|
std::vector<const ParsedParamListStatement::ParsedParameter*> parameters;
|
|
|
|
if (currentToken->GetKind() == LexTokenKind::VoidKeyword) {
|
|
PROGRESS_TOKEN(currentToken);
|
|
EXPECT_TOKEN(currentToken, CloseParenthesisSymbol);
|
|
out = new ParsedParamListStatement(TextSpan(start, currentToken->GetSpan().GetEnd()), parameters);
|
|
return true;
|
|
}
|
|
if (currentToken->GetKind() == LexTokenKind::CloseParenthesisSymbol) {
|
|
out = new ParsedParamListStatement(TextSpan(start, currentToken->GetSpan().GetEnd()), parameters);
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
}
|
|
while (true) {
|
|
ScopedPtr<const ParsedStatement> typeStatement = nullptr;
|
|
TypeMod typeMod = TypeMod::None;
|
|
Identifier identifier;
|
|
const ParsedStatement* defaultExpression = nullptr;
|
|
|
|
if (!ParseType(typeStatement, currentToken, log)) {
|
|
logUnexpectedTokenWithoutExpected(currentToken);
|
|
}
|
|
ParseTypeMod(typeMod, currentToken, log);
|
|
if (!ParseIdentifier(identifier, currentToken)) {
|
|
logUnexpectedToken(Identifier, currentToken);
|
|
} else {
|
|
PROGRESS_TOKEN(currentToken);
|
|
}
|
|
// TODO: Default expression
|
|
|
|
parameters.push_back(new ParsedParamListStatement::ParsedParameter(
|
|
dynamic_cast<const ParsedTypeStatement*>(typeStatement.TakeOwnership()), typeMod, identifier,
|
|
defaultExpression));
|
|
|
|
if (currentToken->GetKind() != LexTokenKind::CommaSymbol) {
|
|
break;
|
|
}
|
|
PROGRESS_TOKEN(currentToken);
|
|
}
|
|
EXPECT_TOKEN(currentToken, CloseParenthesisSymbol);
|
|
out = new ParsedParamListStatement(TextSpan(start, currentToken->GetSpan().GetEnd()), parameters);
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseDataType(Identifier& out, const LexToken*& currentToken, [[maybe_unused]] const log_func& log) {
|
|
switch (currentToken->GetKind()) {
|
|
case LexTokenKind::Identifier:
|
|
out = static_cast<const IdentifierToken*>(currentToken)->GetValue();
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::AutoKeyword:
|
|
out = PrimitiveTypes::AutoName();
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
default:
|
|
if (ParsePrimType(out, currentToken, log)) {
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool Parser::ParseVirtProp([[maybe_unused]] ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
AccessModifier access = AccessModifier::Public;
|
|
if (current->GetKind() == LexTokenKind::PrivateKeyword) {
|
|
access = AccessModifier::Private;
|
|
PROGRESS_TOKEN(current);
|
|
} else if (current->GetKind() == LexTokenKind::ProtectedKeyword) {
|
|
access = AccessModifier::Protected;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ScopedPtr<const ParsedStatement> typeStatement = nullptr;
|
|
if (!ParseType(typeStatement, current, log)) {
|
|
return false;
|
|
}
|
|
bool ref = false;
|
|
if (current->GetKind() == LexTokenKind::AmpersandSymbol) {
|
|
ref = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
Identifier identifier;
|
|
if (!ParseIdentifier(identifier, current)) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
if (current->GetKind() != LexTokenKind::OpenCurlyParenthesisSymbol) {
|
|
return false;
|
|
}
|
|
bool hasGet = false;
|
|
bool getConst = false;
|
|
FuncAttr getAttr = FuncAttr::None;
|
|
ScopedPtr<const ParsedStatement> getStatement = nullptr;
|
|
bool hasSet = false;
|
|
bool setConst = false;
|
|
FuncAttr setAttr = FuncAttr::None;
|
|
ScopedPtr<const ParsedStatement> setStatement = nullptr;
|
|
PROGRESS_TOKEN(current);
|
|
while (true) {
|
|
auto start = current->GetSpan().GetStart();
|
|
if (current->GetKind() == LexTokenKind::GetKeyword) {
|
|
PROGRESS_TOKEN(current);
|
|
if (current->GetKind() == LexTokenKind::ConstKeyword) {
|
|
getConst = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ParseFuncAttr(getAttr, current, log);
|
|
if (current->GetKind() != LexTokenKind::SemicolonSymbol) {
|
|
if (!ParseStatBlock(getStatement, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
} else {
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
|
|
if (hasGet) {
|
|
logError(DiagnosticType::DoubleProperty, TextSpan(start, current->GetSpan().GetEnd()), {});
|
|
}
|
|
hasGet = true;
|
|
} else if (current->GetKind() == LexTokenKind::SetKeyword) {
|
|
PROGRESS_TOKEN(current);
|
|
if (current->GetKind() == LexTokenKind::ConstKeyword) {
|
|
setConst = true;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ParseFuncAttr(setAttr, current, log);
|
|
if (current->GetKind() != LexTokenKind::SemicolonSymbol) {
|
|
if (!ParseStatBlock(setStatement, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
} else {
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
|
|
if (hasSet) {
|
|
logError(DiagnosticType::DoubleProperty, TextSpan(start, current->GetSpan().GetEnd()), {});
|
|
}
|
|
hasSet = true;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (current->GetKind() != LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
logUnexpectedToken(CloseCurlyParenthesisSymbol, current);
|
|
} else {
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
|
|
out = new ParsedVirtPropStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
access, typeStatement.TakeOwnership(), ref, identifier, hasGet, getConst,
|
|
getAttr, getStatement.TakeOwnership(), hasSet, setConst, setAttr,
|
|
setStatement.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseIfStatement([[maybe_unused]] ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::IfKeyword) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
EXPECT_TOKEN(current, OpenParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> condition = nullptr;
|
|
if (!ParseAssign(condition, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
EXPECT_TOKEN(current, CloseParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> body = nullptr;
|
|
if (!ParseStatement(body, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
ScopedPtr<const ParsedStatement> elseStatement = nullptr;
|
|
if (current->GetKind() == LexTokenKind::ElseKeyword) {
|
|
PROGRESS_TOKEN(current);
|
|
if (!ParseStatement(elseStatement, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
}
|
|
out = new ParsedIfStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
condition.TakeOwnership(), body.TakeOwnership(), elseStatement.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
// TODO: All the other statements. (switch | try );
|
|
switch (currentToken->GetKind()) {
|
|
case LexTokenKind::IfKeyword: return ParseIfStatement(out, currentToken, log);
|
|
case LexTokenKind::ForKeyword: return ParseForStatement(out, currentToken, log);
|
|
case LexTokenKind::WhileKeyword: return ParseWhileStatement(out, currentToken, log);
|
|
case LexTokenKind::ReturnKeyword: return ParseReturn(out, currentToken, log);
|
|
case LexTokenKind::BreakKeyword: return ParseBreak(out, currentToken, log);
|
|
case LexTokenKind::ContinueKeyword: return ParseContinue(out, currentToken, log);
|
|
case LexTokenKind::DoKeyword: return ParseDoWhileStatement(out, currentToken, log);
|
|
case LexTokenKind::TryKeyword: return ParseTryStatement(out, currentToken, log);
|
|
case LexTokenKind::SwitchKeyword: return ParseSwitchStatement(out, currentToken, log);
|
|
default: return ParseStatBlock(out, currentToken, log) || ParseExprStat(out, currentToken, log);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool Parser::ParseVar([[maybe_unused]] ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
AccessModifier access = AccessModifier::Public;
|
|
if (current->GetKind() == LexTokenKind::PrivateKeyword) {
|
|
access = AccessModifier::Private;
|
|
PROGRESS_TOKEN(current);
|
|
} else if (current->GetKind() == LexTokenKind::ProtectedKeyword) {
|
|
access = AccessModifier::Protected;
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ScopedPtr<const ParsedStatement> typeStatement = nullptr;
|
|
if (!ParseType(typeStatement, current, log)) {
|
|
return false;
|
|
}
|
|
Identifier identifier;
|
|
if (!ParseIdentifier(identifier, current)) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
// TODO: Default values
|
|
// TODO: Creating multiple vars in a single line (int a, b, c)
|
|
EXPECT_TOKEN(current, SemicolonSymbol);
|
|
out = new ParsedVarStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()), access,
|
|
typeStatement.TakeOwnership(), identifier);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseStatBlock(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::OpenCurlyParenthesisSymbol) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
std::vector<const ParsedStatement*> statements;
|
|
while (true) {
|
|
if (current->GetKind() == LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
break;
|
|
}
|
|
ScopedPtr<const ParsedStatement> stat = nullptr;
|
|
if (ParseVar(stat, current, log) || ParseStatement(stat, current, log)) {
|
|
statements.push_back(stat.TakeOwnership());
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
if (current->GetKind() == LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
} else {
|
|
logUnexpectedToken(CloseCurlyParenthesisSymbol, current);
|
|
}
|
|
|
|
out = new ParsedStatBlockStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
statements);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseFuncDef([[maybe_unused]] ScopedPtr<const ParsedStatement>& out,
|
|
[[maybe_unused]] const LexToken*& currentToken, [[maybe_unused]] const log_func& log) {
|
|
// TODO
|
|
return false;
|
|
}
|
|
bool Parser::ParsePrimType(Identifier& out, const LexToken*& token, [[maybe_unused]] const log_func& log) {
|
|
switch (token->GetKind()) {
|
|
case LexTokenKind::VoidKeyword: out = PrimitiveTypes::VoidName(); return true;
|
|
case LexTokenKind::IntKeyword: out = PrimitiveTypes::IntName(); return true;
|
|
case LexTokenKind::Int8Keyword: out = PrimitiveTypes::Int8Name(); return true;
|
|
case LexTokenKind::Int16Keyword: out = PrimitiveTypes::Int16Name(); return true;
|
|
case LexTokenKind::Int32Keyword: out = PrimitiveTypes::Int32Name(); return true;
|
|
case LexTokenKind::Int64Keyword: out = PrimitiveTypes::Int64Name(); return true;
|
|
case LexTokenKind::UintKeyword: out = PrimitiveTypes::UintName(); return true;
|
|
case LexTokenKind::Uint8Keyword: out = PrimitiveTypes::Uint8Name(); return true;
|
|
case LexTokenKind::Uint16Keyword: out = PrimitiveTypes::Uint16Name(); return true;
|
|
case LexTokenKind::Uint32Keyword: out = PrimitiveTypes::Uint32Name(); return true;
|
|
case LexTokenKind::Uint64Keyword: out = PrimitiveTypes::Uint64Name(); return true;
|
|
case LexTokenKind::FloatKeyword: out = PrimitiveTypes::FloatName(); return true;
|
|
case LexTokenKind::DoubleKeyword: out = PrimitiveTypes::DoubleName(); return true;
|
|
case LexTokenKind::BoolKeyword: out = PrimitiveTypes::BoolName(); return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
bool Parser::ParseTypeMod(TypeMod& typeMod, const LexToken*& currentToken, [[maybe_unused]] const log_func& log) {
|
|
if (currentToken->GetKind() != LexTokenKind::AmpersandSymbol) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(currentToken);
|
|
switch (currentToken->GetKind()) {
|
|
case LexTokenKind::InKeyword:
|
|
typeMod = TypeMod::RefIn;
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::OutKeyword:
|
|
typeMod = TypeMod::RefOut;
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::InoutKeyword:
|
|
typeMod = TypeMod::RefInOut;
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
default: typeMod = TypeMod::RefInOut; return true;
|
|
}
|
|
}
|
|
bool Parser::ParseAssign(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
ScopedPtr<const ParsedStatement> leftHand = nullptr;
|
|
if (!ParseTernary(leftHand, current, log)) {
|
|
return false;
|
|
}
|
|
AssignmentOperator op;
|
|
if (!ParseAssignOp(op, current)) {
|
|
out = leftHand.TakeOwnership();
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
ScopedPtr<const ParsedStatement> rightHand = nullptr;
|
|
if (!ParseAssign(rightHand, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
out = leftHand.TakeOwnership();
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
out = new ParsedBinaryStatement<AssignmentOperator>(
|
|
TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()), leftHand.TakeOwnership(), op,
|
|
rightHand.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseTernary(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
// TODO: implement ternary.
|
|
return ParseExpr(out, currentToken, log);
|
|
}
|
|
|
|
#define EXPR_PARSER(operator, name, func) \
|
|
operator(name); \
|
|
if (func(name, current)) { \
|
|
PROGRESS_TOKEN(current); \
|
|
ScopedPtr<const ParsedStatement> rightHand = nullptr; \
|
|
if (!ParseExprTerm(rightHand, current, log)) { \
|
|
logUnexpectedTokenWithoutExpected(current); \
|
|
out = leftHand.TakeOwnership(); \
|
|
currentToken = current; \
|
|
return true; \
|
|
} \
|
|
out = new ParsedBinaryStatement < operator>(TextSpan(currentToken->GetSpan().GetStart(), \
|
|
current->GetSpan().GetEnd()), \
|
|
leftHand.TakeOwnership(), name, rightHand.TakeOwnership()); \
|
|
currentToken = current; \
|
|
return true; \
|
|
}
|
|
|
|
bool Parser::ParseExpr(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken, const log_func& log) {
|
|
const auto* current = currentToken;
|
|
ScopedPtr<const ParsedStatement> leftHand = nullptr;
|
|
if (!ParseExprTerm(leftHand, current, log)) {
|
|
return false;
|
|
}
|
|
EXPR_PARSER(MathOperator, mathOp, ParseMathOp);
|
|
EXPR_PARSER(ComparisonOperator, compOp, ParseCompOp);
|
|
EXPR_PARSER(LogicOperator, logicOp, ParseLogicOp);
|
|
EXPR_PARSER(BitOperator, bitOp, ParseBitOp);
|
|
|
|
out = leftHand.TakeOwnership();
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseExprTerm(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
// TODO ([type '='] initlist)
|
|
|
|
PreOperator preOperator;
|
|
bool hasPreOp = ParsePreOp(preOperator, currentToken, log);
|
|
if (hasPreOp) {
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
ScopedPtr<const ParsedStatement> operand = nullptr;
|
|
if (!ParseExprValue(operand, current, log)) {
|
|
return false;
|
|
}
|
|
|
|
// TODO: remainder of
|
|
if (current->GetKind() == LexTokenKind::PlusPlusSymbol) {
|
|
operand = new ParsedIncrementStatement(TextSpan(operand->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
operand.TakeOwnership());
|
|
PROGRESS_TOKEN(current);
|
|
} else if (current->GetKind() == LexTokenKind::MinusMinusSymbol) {
|
|
operand = new ParsedDecrementStatement(TextSpan(operand->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
operand.TakeOwnership());
|
|
PROGRESS_TOKEN(current);
|
|
}
|
|
|
|
if (hasPreOp) {
|
|
// TODO: integrate pre operator
|
|
}
|
|
out = operand.TakeOwnership();
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseExprValue(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() == LexTokenKind::VoidKeyword) {
|
|
PROGRESS_TOKEN(current);
|
|
|
|
out = new ParsedVoidStatement(currentToken->GetSpan());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
// TODO: constructcall
|
|
// TODO: funccall
|
|
if (ParseVarAccess(out, current, log)) {
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
// TODO: cast
|
|
if (ParseLiteral(out, current, log)) {
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
if (current->GetKind() == LexTokenKind::OpenParenthesisSymbol) {
|
|
PROGRESS_TOKEN(current);
|
|
if (!ParseAssign(out, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
}
|
|
EXPECT_TOKEN(current, CloseParenthesisSymbol);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
// TODO: lambda
|
|
|
|
return false;
|
|
}
|
|
bool Parser::ParseLiteral(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
[[maybe_unused]] const log_func& log) {
|
|
switch (currentToken->GetKind()) {
|
|
case LexTokenKind::IntegerLiteral:
|
|
out = new ParsedLiteralStatement<ParseInt>(
|
|
currentToken->GetSpan(), static_cast<const IntegerLiteral*>(currentToken)->GetValue());
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::FloatLiteral:
|
|
out = new ParsedLiteralStatement<ParseFloat>(
|
|
currentToken->GetSpan(), static_cast<const FloatLiteral*>(currentToken)->GetValue());
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::StringLiteral:
|
|
out = new ParsedLiteralStatement<ParseString>(
|
|
currentToken->GetSpan(), static_cast<const StringLiteral*>(currentToken)->GetValue());
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::TrueKeyword:
|
|
out = new ParsedLiteralStatement<bool>(currentToken->GetSpan(), true);
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::FalseKeyword:
|
|
out = new ParsedLiteralStatement<bool>(currentToken->GetSpan(), false);
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
case LexTokenKind::NullKeyword:
|
|
out = new ParsedLiteralStatement<void*>(currentToken->GetSpan(), nullptr);
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
default: return false;
|
|
}
|
|
}
|
|
bool Parser::ParseReturn(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
auto start = currentToken->GetSpan().GetStart();
|
|
if (currentToken->GetKind() != LexTokenKind::ReturnKeyword) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(currentToken);
|
|
ScopedPtr<const ParsedStatement> returnBody;
|
|
ParseAssign(returnBody, currentToken, log);
|
|
EXPECT_TOKEN(currentToken, SemicolonSymbol);
|
|
out = new ParsedReturnStatement(TextSpan(start, currentToken->GetSpan().GetEnd()), returnBody.TakeOwnership());
|
|
return true;
|
|
}
|
|
bool Parser::ParseExprStat(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
if (!ParseAssign(out, currentToken, log)) {
|
|
return false;
|
|
}
|
|
EXPECT_TOKEN(currentToken, SemicolonSymbol);
|
|
return true;
|
|
}
|
|
bool Parser::ParseVarAccess(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
std::vector<Identifier> scope;
|
|
auto start = currentToken->GetSpan().GetStart();
|
|
if (ParseScope(scope, currentToken, log)) {
|
|
out = new ParsedVarAccessStatement(TextSpan(start, currentToken->GetSpan().GetEnd()), scope);
|
|
return true;
|
|
}
|
|
Identifier identifier;
|
|
if (ParseIdentifier(identifier, currentToken)) {
|
|
scope.clear();
|
|
scope.push_back(identifier);
|
|
out = new ParsedVarAccessStatement(currentToken->GetSpan(), scope);
|
|
PROGRESS_TOKEN(currentToken);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
bool Parser::ParseContinue(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
[[maybe_unused]] const log_func& log) {
|
|
if (currentToken->GetKind() != LexTokenKind::ContinueKeyword) {
|
|
return false;
|
|
}
|
|
auto start = currentToken->GetSpan().GetStart();
|
|
PROGRESS_TOKEN(currentToken);
|
|
EXPECT_TOKEN(currentToken, SemicolonSymbol);
|
|
out = new ParsedContinueStatement(TextSpan(start, currentToken->GetSpan().GetEnd()));
|
|
return true;
|
|
}
|
|
bool Parser::ParseBreak(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
[[maybe_unused]] const log_func& log) {
|
|
if (currentToken->GetKind() != LexTokenKind::BreakKeyword) {
|
|
return false;
|
|
}
|
|
auto start = currentToken->GetSpan().GetStart();
|
|
PROGRESS_TOKEN(currentToken);
|
|
EXPECT_TOKEN(currentToken, SemicolonSymbol);
|
|
out = new ParsedBreakStatement(TextSpan(start, currentToken->GetSpan().GetEnd()));
|
|
return true;
|
|
}
|
|
bool Parser::ParseForStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
if (currentToken->GetKind() != LexTokenKind::ForKeyword) {
|
|
return false;
|
|
}
|
|
const auto* current = currentToken;
|
|
PROGRESS_TOKEN(current);
|
|
EXPECT_TOKEN(current, OpenParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> init;
|
|
if (!ParseVar(init, current, log) && !ParseExprStat(init, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
ScopedPtr<const ParsedStatement> condition;
|
|
if (!ParseExprStat(condition, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
std::vector<const ParsedStatement*> increment;
|
|
while (true) {
|
|
ScopedPtr<const ParsedStatement> element;
|
|
if (ParseAssign(element, current, log)) {
|
|
increment.push_back(element.TakeOwnership());
|
|
}
|
|
if (current->GetKind() != LexTokenKind::CommaSymbol) {
|
|
break;
|
|
}
|
|
}
|
|
EXPECT_TOKEN(current, CloseParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> statementBlock;
|
|
if (!ParseStatement(statementBlock, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
|
|
out = new ParsedForStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
init.TakeOwnership(), condition.TakeOwnership(), increment,
|
|
statementBlock.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseWhileStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::WhileKeyword) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
EXPECT_TOKEN(current, OpenParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> condition = nullptr;
|
|
if (!ParseAssign(condition, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
EXPECT_TOKEN(current, CloseParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> body = nullptr;
|
|
if (!ParseStatement(body, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
out = new ParsedWhileStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
condition.TakeOwnership(), body.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseDoWhileStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::DoKeyword) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
ScopedPtr<const ParsedStatement> body = nullptr;
|
|
if (!ParseStatement(body, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
EXPECT_TOKEN(current, WhileKeyword);
|
|
EXPECT_TOKEN(current, OpenParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> condition = nullptr;
|
|
if (!ParseAssign(condition, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
EXPECT_TOKEN(current, CloseParenthesisSymbol);
|
|
EXPECT_TOKEN(current, SemicolonSymbol);
|
|
out = new ParsedDoWhileStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
condition.TakeOwnership(), body.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseTryStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const Parser::log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::TryKeyword) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
|
|
ScopedPtr<const ParsedStatement> tryStatement = nullptr;
|
|
if (!ParseStatBlock(tryStatement, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
EXPECT_TOKEN(current, CatchKeyword);
|
|
ScopedPtr<const ParsedStatement> catchStatement = nullptr;
|
|
if (!ParseStatBlock(catchStatement, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
|
|
out = new ParsedTryStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
tryStatement.TakeOwnership(), catchStatement.TakeOwnership());
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
bool Parser::ParseSwitchStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const Parser::log_func& log) {
|
|
const auto* current = currentToken;
|
|
if (current->GetKind() != LexTokenKind::SwitchKeyword) {
|
|
return false;
|
|
}
|
|
PROGRESS_TOKEN(current);
|
|
EXPECT_TOKEN(currentToken, OpenParenthesisSymbol);
|
|
ScopedPtr<const ParsedStatement> expression = nullptr;
|
|
if (!ParseExpr(expression, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
EXPECT_TOKEN(currentToken, CloseParenthesisSymbol);
|
|
EXPECT_TOKEN(currentToken, OpenCurlyParenthesisSymbol);
|
|
std::vector<const ParsedStatement*> caseStatements;
|
|
while (true) {
|
|
if (current->GetKind() == LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
break;
|
|
}
|
|
if (current->GetKind() == LexTokenKind::CaseKeyword ||
|
|
currentToken->GetKind() == LexTokenKind::DefaultKeyword) {
|
|
ScopedPtr<const ParsedStatement> stat = nullptr;
|
|
if (!ParseCaseStatement(stat, current, log)) {
|
|
for (const auto* s : caseStatements) {
|
|
delete s;
|
|
}
|
|
return false;
|
|
}
|
|
caseStatements.push_back(stat.TakeOwnership());
|
|
} else {
|
|
logUnexpectedToken(CaseKeyword, current);
|
|
return false;
|
|
}
|
|
}
|
|
// Consume }
|
|
PROGRESS_TOKEN(current);
|
|
|
|
out = new ParsedSwitchStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
expression.TakeOwnership(), caseStatements);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
|
|
bool Parser::ParseCaseStatement(ScopedPtr<const ParsedStatement>& out, const LexToken*& currentToken,
|
|
const Parser::log_func& log) {
|
|
const auto* current = currentToken;
|
|
|
|
if (current->GetKind() != LexTokenKind::CaseKeyword && current->GetKind() != LexTokenKind::DefaultKeyword) {
|
|
return false;
|
|
}
|
|
bool isDefault = current->GetKind() == LexTokenKind::DefaultKeyword;
|
|
PROGRESS_TOKEN(current);
|
|
|
|
ScopedPtr<const ParsedStatement> expression = nullptr;
|
|
if (!isDefault) {
|
|
if (!ParseExpr(expression, current, log)) {
|
|
logUnexpectedTokenWithoutExpected(current);
|
|
return false;
|
|
}
|
|
}
|
|
EXPECT_TOKEN(current, ColonSymbol);
|
|
|
|
std::vector<const ParsedStatement*> statements;
|
|
while (true) {
|
|
// Minor optimization, if we encounter a case/default keyword we know the upcoming statement is another case
|
|
// so not part of the current case. Similarly, if we find a close curly parenthesis we know we're at the end
|
|
// of the current switch statement, so we don't need to continue parsing.
|
|
if (current->GetKind() == LexTokenKind::CaseKeyword || current->GetKind() == LexTokenKind::DefaultKeyword ||
|
|
current->GetKind() == LexTokenKind::CloseCurlyParenthesisSymbol) {
|
|
break;
|
|
}
|
|
|
|
ScopedPtr<const ParsedStatement> stat = nullptr;
|
|
if (ParseStatement(stat, current, log)) {
|
|
statements.push_back(stat.TakeOwnership());
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
out = new ParsedCaseStatement(TextSpan(currentToken->GetSpan().GetStart(), current->GetSpan().GetEnd()),
|
|
expression.TakeOwnership(), statements);
|
|
currentToken = current;
|
|
return true;
|
|
}
|
|
} |