CarGDev/bits-runner-builder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Moved things around

Browse Source
This commit is contained in:
Rafał Grodziński
2025-06-23 17:16:06 +09:00
parent 7960c7c198
commit a8a3b9f880
4 changed files with 114 additions and 116 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/Compiler/ModuleBuilder.cpp
View File

@@ -1,19 +1,18 @@
#include "ModuleBuilder.h"
#include "Parser/Expression/Expression.h"
#include "Parser/Expression/ExpressionLiteral.h"
#include "Parser/Expression/ExpressionIfElse.h"
#include "Parser/Expression/ExpressionGrouping.h"
#include "Parser/Expression/ExpressionBinary.h"
#include "Parser/Expression/ExpressionLiteral.h"
#include "Parser/Expression/ExpressionVariable.h"
#include "Parser/Expression/ExpressionCall.h"
#include "Parser/Expression/ExpressionIfElse.h"
#include "Parser/Expression/ExpressionBinary.h"
#include "Parser/Statement/StatementExpression.h"
#include "Parser/Statement/StatementBlock.h"
#include "Parser/Statement/StatementFunction.h"
#include "Parser/Statement/StatementVariable.h"
#include "Parser/Statement/StatementReturn.h"
#include "Parser/Statement/StatementExpression.h"
#include "Parser/Statement/StatementMetaExternFunction.h"
#include "Parser/Statement/StatementBlock.h"
ModuleBuilder::ModuleBuilder(string moduleName, string sourceFileName, vector<shared_ptr<Statement>> statements):
moduleName(moduleName), sourceFileName(sourceFileName), statements(statements) {

14
src/Compiler/ModuleBuilder.h
View File

@@ -13,21 +13,21 @@
#include "Types.h"
class Expression;
class ExpressionLiteral;
class ExpressionIfElse;
class ExpressionGrouping;
class ExpressionBinary;
enum class ExpressionBinaryOperation;
class ExpressionLiteral;
class ExpressionVariable;
class ExpressionCall;
class ExpressionIfElse;
class ExpressionBinary;
enum class ExpressionBinaryOperation;
class Statement;
class StatementBlock;
class StatementReturn;
class StatementFunction;
class StatementVariable;
class StatementMetaExternFunction;
class StatementReturn;
class StatementExpression;
class StatementMetaExternFunction;
class StatementBlock;
using namespace std;

193
src/Parser/Parser.cpp
View File

@@ -1,21 +1,20 @@
#include "Parser.h"
#include "Parser/Expression/Expression.h"
#include "Parser/Expression/ExpressionLiteral.h"
#include "Parser/Expression/ExpressionGrouping.h"
#include "Parser/Expression/ExpressionIfElse.h"
#include "Parser/Expression/ExpressionBlock.h"
#include "Parser/Expression/ExpressionBinary.h"
#include "Parser/Expression/ExpressionLiteral.h"
#include "Parser/Expression/ExpressionVariable.h"
#include "Parser/Expression/ExpressionCall.h"
#include "Parser/Expression/ExpressionIfElse.h"
#include "Parser/Expression/ExpressionBinary.h"
#include "Parser/Expression/ExpressionBlock.h"
#include "Parser/Expression/ExpressionInvalid.h"
#include "Parser/Statement/StatementExpression.h"
#include "Parser/Statement/StatementBlock.h"
#include "Parser/Statement/StatementReturn.h"
#include "Parser/Statement/StatementFunction.h"
#include "Parser/Statement/StatementVariable.h"
#include "Parser/Statement/StatementReturn.h"
#include "Parser/Statement/StatementExpression.h"
#include "Parser/Statement/StatementMetaExternFunction.h"
#include "Parser/Statement/StatementBlock.h"
#include "Parser/Statement/StatementInvalid.h"
Parser::Parser(vector<shared_ptr<Token>> tokens): tokens(tokens) {
@@ -43,7 +42,7 @@ vector<shared_ptr<Statement>> Parser::getStatements() {
shared_ptr<Statement> Parser::nextStatement() {
shared_ptr<Statement> statement;
statement = matchStatementFunctionDeclaration();
statement = matchStatementFunction();
if (statement != nullptr)
return statement;
@@ -66,7 +65,7 @@ shared_ptr<Statement> Parser::nextStatement() {
return matchStatementInvalid("Unexpected token");
}
shared_ptr<Statement> Parser::matchStatementFunctionDeclaration() {
shared_ptr<Statement> Parser::matchStatementFunction() {
if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::FUNCTION}, true, false))
return nullptr;
@@ -159,26 +158,6 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
return make_shared<StatementVariable>(identifierToken->getLexme(), valueType, expression);
}
shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalTokenKinds, bool shouldConsumeTerminal) {
vector<shared_ptr<Statement>> statements;
bool hasNewLineTerminal = find(terminalTokenKinds.begin(), terminalTokenKinds.end(), TokenKind::NEW_LINE) != terminalTokenKinds.end();
while (!tryMatchingTokenKinds(terminalTokenKinds, false, shouldConsumeTerminal)) {
shared_ptr<Statement> statement = nextStatement();
if (statement == nullptr)
return matchStatementInvalid();
else if (!statement->isValid())
return statement;
else
statements.push_back(statement);
if (hasNewLineTerminal && tokens.at(currentIndex-1)->getKind() == TokenKind::NEW_LINE)
currentIndex--;
}
return make_shared<StatementBlock>(statements);
}
shared_ptr<Statement> Parser::matchStatementReturn() {
if (!tryMatchingTokenKinds({TokenKind::RETURN}, true, true))
return nullptr;
@@ -259,6 +238,26 @@ shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
return make_shared<StatementMetaExternFunction>(identifierToken->getLexme(), arguments, returnType);
}
shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalTokenKinds, bool shouldConsumeTerminal) {
vector<shared_ptr<Statement>> statements;
bool hasNewLineTerminal = find(terminalTokenKinds.begin(), terminalTokenKinds.end(), TokenKind::NEW_LINE) != terminalTokenKinds.end();
while (!tryMatchingTokenKinds(terminalTokenKinds, false, shouldConsumeTerminal)) {
shared_ptr<Statement> statement = nextStatement();
if (statement == nullptr)
return matchStatementInvalid();
else if (!statement->isValid())
return statement;
else
statements.push_back(statement);
if (hasNewLineTerminal && tokens.at(currentIndex-1)->getKind() == TokenKind::NEW_LINE)
currentIndex--;
}
return make_shared<StatementBlock>(statements);
}
shared_ptr<StatementInvalid> Parser::matchStatementInvalid(string message) {
return make_shared<StatementInvalid>(tokens.at(currentIndex), message);
}
@@ -277,7 +276,7 @@ shared_ptr<Expression> Parser::nextExpression() {
if (expression != nullptr)
return expression;
expression = matchExpressionVar();
expression = matchExpressionVariable();
if (expression != nullptr)
return expression;
@@ -331,30 +330,21 @@ shared_ptr<Expression> Parser::matchFactor() {
shared_ptr<Expression> Parser::matchPrimary() {
shared_ptr<Expression> expression;
expression = matchExpressionLiteral();
if (expression != nullptr)
return expression;
expression = matchExpressionCall();
if (expression != nullptr)
return expression;
expression = matchExpressionVar();
if (expression != nullptr)
return expression;
expression = matchExpressionGrouping();
if (expression != nullptr)
return expression;
return nullptr;
}
expression = matchExpressionLiteral();
if (expression != nullptr)
return expression;
shared_ptr<Expression> Parser::matchExpressionLiteral() {
shared_ptr<Token> token = tokens.at(currentIndex);
if (tryMatchingTokenKinds(Token::tokensLiteral, false, true))
return make_shared<ExpressionLiteral>(token);
expression = matchExpressionVariable();
if (expression != nullptr)
return expression;
expression = matchExpressionCall();
if (expression != nullptr)
return expression;
return nullptr;
}
@@ -378,31 +368,49 @@ shared_ptr<Expression> Parser::matchExpressionGrouping() {
return nullptr;
}
shared_ptr<Expression> Parser::matchExpressionBinary(shared_ptr<Expression> left) {
shared_ptr<Expression> Parser::matchExpressionLiteral() {
shared_ptr<Token> token = tokens.at(currentIndex);
shared_ptr<Expression> right;
// What level of binary expression are we having?
if (tryMatchingTokenKinds(Token::tokensEquality, false, true)) {
right = matchComparison();
} else if (tryMatchingTokenKinds(Token::tokensComparison, false, true)) {
right = matchTerm();
} else if (tryMatchingTokenKinds(Token::tokensTerm, false, true)) {
right = matchFactor();
} else if (tryMatchingTokenKinds(Token::tokensFactor, false, true)) {
right = matchPrimary();
}
if (right == nullptr) {
return matchExpressionInvalid();
} else if (!right->isValid()) {
return right;
} else {
return make_shared<ExpressionBinary>(token, left, right);
}
if (tryMatchingTokenKinds(Token::tokensLiteral, false, true))
return make_shared<ExpressionLiteral>(token);
return nullptr;
}
shared_ptr<Expression> Parser::matchExpressionVariable() {
shared_ptr<Token> token = tokens.at(currentIndex);
if (tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, true))
return make_shared<ExpressionVariable>(token->getLexme());
return nullptr;
}
shared_ptr<Expression> Parser::matchExpressionCall() {
if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::LEFT_PAREN}, true, false))
return nullptr;
shared_ptr<Token> identifierToken = tokens.at(currentIndex);
currentIndex++; // identifier
currentIndex++; // left parenthesis
vector<shared_ptr<Expression>> argumentExpressions;
do {
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // optional new line
shared_ptr<Expression> argumentExpression = nextExpression();
if (argumentExpression == nullptr || !argumentExpression->isValid())
return argumentExpression;
argumentExpressions.push_back(argumentExpression);
} while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // optional new line
if (!tryMatchingTokenKinds({TokenKind::RIGHT_PAREN}, true, true))
return matchExpressionInvalid();
return make_shared<ExpressionCall>(identifierToken->getLexme(), argumentExpressions);
}
shared_ptr<Expression> Parser::matchExpressionIfElse() {
// Try maching '?'
shared_ptr<Token> token = tokens.at(currentIndex);
@@ -448,38 +456,29 @@ shared_ptr<Expression> Parser::matchExpressionIfElse() {
return make_shared<ExpressionIfElse>(condition, dynamic_pointer_cast<ExpressionBlock>(thenBlock), dynamic_pointer_cast<ExpressionBlock>(elseBlock));
}
shared_ptr<Expression> Parser::matchExpressionVar() {
shared_ptr<Expression> Parser::matchExpressionBinary(shared_ptr<Expression> left) {
shared_ptr<Token> token = tokens.at(currentIndex);
shared_ptr<Expression> right;
// What level of binary expression are we having?
if (tryMatchingTokenKinds(Token::tokensEquality, false, true)) {
right = matchComparison();
} else if (tryMatchingTokenKinds(Token::tokensComparison, false, true)) {
right = matchTerm();
} else if (tryMatchingTokenKinds(Token::tokensTerm, false, true)) {
right = matchFactor();
} else if (tryMatchingTokenKinds(Token::tokensFactor, false, true)) {
right = matchPrimary();
}
if (tryMatchingTokenKinds({TokenKind::IDENTIFIER}, true, true))
return make_shared<ExpressionVariable>(token->getLexme());
return nullptr;
}
shared_ptr<Expression> Parser::matchExpressionCall() {
if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::LEFT_PAREN}, true, false))
return nullptr;
shared_ptr<Token> identifierToken = tokens.at(currentIndex);
currentIndex++; // identifier
currentIndex++; // left parenthesis
vector<shared_ptr<Expression>> argumentExpressions;
do {
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // optional new line
shared_ptr<Expression> argumentExpression = nextExpression();
if (argumentExpression == nullptr || !argumentExpression->isValid())
return argumentExpression;
argumentExpressions.push_back(argumentExpression);
} while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // optional new line
if (!tryMatchingTokenKinds({TokenKind::RIGHT_PAREN}, true, true))
if (right == nullptr) {
return matchExpressionInvalid();
} else if (!right->isValid()) {
return right;
} else {
return make_shared<ExpressionBinary>(token, left, right);
}
return make_shared<ExpressionCall>(identifierToken->getLexme(), argumentExpressions);
return nullptr;
}
shared_ptr<Expression> Parser::matchExpressionBlock(vector<TokenKind> terminalTokenKinds, bool shouldConsumeTerminal) {

12
src/Parser/Parser.h
View File

@@ -19,12 +19,12 @@ private:
int currentIndex = 0;
shared_ptr<Statement> nextStatement();
shared_ptr<Statement> matchStatementFunctionDeclaration();
shared_ptr<Statement> matchStatementFunction();
shared_ptr<Statement> matchStatementVariable();
shared_ptr<Statement> matchStatementBlock(vector<TokenKind> terminalTokenKinds, bool shouldConsumeTerminal);
shared_ptr<Statement> matchStatementReturn();
shared_ptr<Statement> matchStatementExpression();
shared_ptr<Statement> matchStatementMetaExternFunction();
shared_ptr<Statement> matchStatementBlock(vector<TokenKind> terminalTokenKinds, bool shouldConsumeTerminal);
shared_ptr<StatementInvalid> matchStatementInvalid(string message = "");
shared_ptr<Expression> nextExpression();
@@ -34,12 +34,12 @@ private:
shared_ptr<Expression> matchFactor(); // *, /, %
shared_ptr<Expression> matchPrimary(); // integer, ()
shared_ptr<Expression> matchExpressionLiteral();
shared_ptr<Expression> matchExpressionGrouping();
shared_ptr<Expression> matchExpressionBinary(shared_ptr<Expression> left);
shared_ptr<Expression> matchExpressionIfElse();
shared_ptr<Expression> matchExpressionVar();
shared_ptr<Expression> matchExpressionLiteral();
shared_ptr<Expression> matchExpressionVariable();
shared_ptr<Expression> matchExpressionCall();
shared_ptr<Expression> matchExpressionIfElse();
shared_ptr<Expression> matchExpressionBinary(shared_ptr<Expression> left);
shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds, bool shouldConsumeTerminal);
shared_ptr<ExpressionInvalid> matchExpressionInvalid();