Deukhoofd/PorygonLang
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

General cleanup
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Deukhoofd
2019-07-04 18:24:49 +02:00
parent 0446c1098b
commit bb0a6aba19
20 changed files with 90 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/Parser/ParsedExpressions/ParsedExpression.hpp
View File

@@ -72,7 +72,7 @@ namespace Porygon::Parser {
return ParsedExpressionKind::LiteralInteger;
}
explicit LiteralIntegerExpression(IntegerToken *token)
explicit LiteralIntegerExpression(const IntegerToken *token)
: ParsedExpression(token->GetStartPosition(), token->GetLength()),
_value(token->GetValue()) {
}
@@ -89,7 +89,7 @@ namespace Porygon::Parser {
return ParsedExpressionKind::LiteralFloat;
}
explicit LiteralFloatExpression(FloatToken *token)
explicit LiteralFloatExpression(const FloatToken *token)
: ParsedExpression(token->GetStartPosition(), token->GetLength()),
_value(token->GetValue()) {
}
@@ -106,7 +106,7 @@ namespace Porygon::Parser {
return ParsedExpressionKind::LiteralString;
}
explicit LiteralStringExpression(StringToken *token)
explicit LiteralStringExpression(const StringToken *token)
: ParsedExpression(token->GetStartPosition(), token->GetLength()),
_value(std::move(token->GetValue())) {
}
@@ -140,7 +140,7 @@ namespace Porygon::Parser {
return ParsedExpressionKind::Variable;
}
explicit VariableExpression(IdentifierToken *token) : ParsedExpression(token->GetStartPosition(),
explicit VariableExpression(const IdentifierToken *token) : ParsedExpression(token->GetStartPosition(),
token->GetLength()),
_value(HashedString(token->GetValue())) {
}
@@ -314,12 +314,11 @@ namespace Porygon::Parser {
class ParsedNumericalTableExpression : public ParsedExpression {
vector<const ParsedExpression *> _expressions;
const vector<const ParsedExpression *> _expressions;
public:
ParsedNumericalTableExpression(vector<const ParsedExpression *> expressions, unsigned int start,
unsigned int length)
: ParsedExpression(start, length) {
_expressions = std::move(expressions);
: ParsedExpression(start, length), _expressions(std::move(expressions)) {
}
~ParsedNumericalTableExpression() final {

7
src/Parser/ParsedStatements/ParsedStatement.hpp
View File

@@ -73,16 +73,13 @@ namespace Porygon::Parser {
class ParsedBlockStatement : public ParsedStatement {
const std::vector<const ParsedStatement *> _statements;
public:
explicit ParsedBlockStatement(std::vector<const ParsedStatement *> statements)
explicit ParsedBlockStatement(const std::vector<const ParsedStatement *>& statements)
: ParsedStatement(statements.front()->GetStartPosition(),
statements.back()->GetEndPosition() - statements.front()->GetStartPosition()),
_statements(statements) {}
ParsedBlockStatement(std::vector<const ParsedStatement *> statements, unsigned int start) : ParsedStatement(
start, 0),
_statements(
std::move(
statements)) {
start, 0), _statements(std::move(statements)) {
}

34
src/Parser/Parser.cpp
View File

@@ -89,7 +89,7 @@ namespace Porygon::Parser {
}
auto start = current->GetStartPosition();
return new ParsedAssignmentStatement(isLocal, ((IdentifierToken *) identifier)->GetValue(), expression, start,
return new ParsedAssignmentStatement(isLocal, (dynamic_cast<const IdentifierToken*>(identifier))->GetValue(), expression, start,
expression->GetEndPosition() - start);
}
@@ -102,7 +102,7 @@ namespace Porygon::Parser {
}
ParsedStatement *
ParsedBlockStatement *
Parser::ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements) {
auto statements = openStatements;
auto start = this->_position;
@@ -168,8 +168,8 @@ namespace Porygon::Parser {
hasErrors = true;
continue;
}
auto typeToken = (IdentifierToken *) type;
auto identifierToken = (IdentifierToken *) identifier;
auto typeToken = dynamic_cast<const IdentifierToken*>(type);
auto identifierToken = dynamic_cast<const IdentifierToken*>(identifier);
parameters.push_back(new TypedVariableIdentifier(typeToken->GetValue(), identifierToken->GetValue()));
auto nextKind = next->GetKind();
@@ -190,9 +190,9 @@ namespace Porygon::Parser {
if (block->GetKind() == ParsedStatementKind::Bad) {
return new ParsedBadStatement(start, block->GetEndPosition() - start);
}
auto functionIdentifier = ((IdentifierToken *) functionIdentifierToken)->GetValue();
auto functionIdentifier = dynamic_cast<const IdentifierToken*>(functionIdentifierToken)->GetValue();
return new ParsedFunctionDeclarationStatement(HashedString(functionIdentifier), parameters,
(ParsedBlockStatement *) block, start,
block, start,
block->GetEndPosition() - start);
}
@@ -239,7 +239,7 @@ namespace Porygon::Parser {
}
ParsedStatement *Parser::ParseNumericForStatement(const IToken *current) {
auto identifier = (IdentifierToken*)current;
auto identifier = dynamic_cast<const IdentifierToken*>(current);
this->Next(); // consume assignment token
bool hasErrors = false;
auto start = this ->ParseExpression(this ->Next());
@@ -271,8 +271,8 @@ namespace Porygon::Parser {
}
ParsedStatement *Parser::ParseGenericForStatement(const IToken *current) {
auto keyIdentifier = ((IdentifierToken*) current)->GetValue();
IdentifierToken* valueIdentifierToken = nullptr;
auto keyIdentifier = dynamic_cast<const IdentifierToken*>(current)->GetValue();
const IdentifierToken* valueIdentifierToken = nullptr;
bool hasErrors = false;
auto next = this -> Next();
if (next -> GetKind() == TokenKind::CommaToken){
@@ -282,7 +282,7 @@ namespace Porygon::Parser {
this->ScriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
next->GetLength());
} else{
valueIdentifierToken = (IdentifierToken*) next;
valueIdentifierToken = dynamic_cast<const IdentifierToken*>(next);
next = this -> Next();
}
}
@@ -477,17 +477,17 @@ namespace Porygon::Parser {
ParsedExpression *Parser::ParsePrimaryExpression(const IToken *current) {
switch (current->GetKind()) {
case TokenKind::Integer:
return new LiteralIntegerExpression((IntegerToken *) current);
return new LiteralIntegerExpression(dynamic_cast<const IntegerToken*>(current));
case TokenKind::Float:
return new LiteralFloatExpression((FloatToken *) current);
return new LiteralFloatExpression(dynamic_cast<const FloatToken*>(current));
case TokenKind::String:
return new LiteralStringExpression((StringToken *) current);
return new LiteralStringExpression(dynamic_cast<const StringToken*>(current));
case TokenKind::TrueKeyword:
return new LiteralBoolExpression(current);
case TokenKind::FalseKeyword:
return new LiteralBoolExpression(current);
case TokenKind::Identifier:
return new VariableExpression((IdentifierToken *) current);
return new VariableExpression(dynamic_cast<const IdentifierToken*>(current));
case TokenKind::OpenParenthesis:
return this->ParseParenthesizedExpression(current);
case TokenKind::OpenCurlyBracket:
@@ -566,7 +566,7 @@ namespace Porygon::Parser {
identifier->GetEndPosition() - indexingExpression->GetStartPosition());
}
auto start = indexingExpression->GetStartPosition();
return new PeriodIndexExpression(indexingExpression, ((IdentifierToken *) identifier)->GetValue(), start,
return new PeriodIndexExpression(indexingExpression, dynamic_cast<const IdentifierToken*>(identifier)->GetValue(), start,
identifier->GetEndPosition() - start);
}
@@ -582,7 +582,7 @@ namespace Porygon::Parser {
// If the first item is an expression, and is followed by a comma, we're dealing with a simple {1, 2, 3} kind of array
if (firstItem->GetKind() == ParsedStatementKind::Expression &&
(this->Peek()->GetKind() == TokenKind::CommaToken)) {
auto statement = ((ParsedExpressionStatement *) firstItem);
auto statement = dynamic_cast<ParsedExpressionStatement*>(firstItem);
auto expr = statement->GetExpression();
statement->NullifyExpression();
delete statement;
@@ -607,7 +607,7 @@ namespace Porygon::Parser {
}
// Otherwise we have a more complex table, which can be defined by a block
else {
auto block = (ParsedBlockStatement *) this->ParseBlock({TokenKind::CloseCurlyBracket}, {firstItem});
auto block = this->ParseBlock({TokenKind::CloseCurlyBracket}, {firstItem});
auto closeToken = this->PeekAt(-1);
return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start);
}

8
src/Parser/Parser.hpp
View File

@@ -34,7 +34,7 @@ namespace Porygon::Parser {
ParsedStatement *ParseStatement(const IToken *current);
ParsedStatement *ParseVariableAssignment(const IToken *current);
ParsedStatement *ParseIndexAssignment(ParsedExpression *indexer);
ParsedStatement *ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements = {});
ParsedBlockStatement *ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements = {});
ParsedStatement *ParseFunctionDeclaration(const IToken *current);
ParsedStatement *ParseReturnStatement(const IToken *current);
ParsedStatement *ParseIfStatement(const IToken *current);
@@ -57,10 +57,8 @@ namespace Porygon::Parser {
public:
ParsedScriptStatement *Parse();
explicit Parser(const vector<const IToken *> &tokens, Porygon::Script *scriptData) {
_tokens = tokens;
_position = 0;
ScriptData = scriptData;
explicit Parser(const vector<const IToken *> &tokens, Porygon::Script *scriptData) : _tokens(tokens), _position(0),
ScriptData(scriptData){
}
};