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

Make parsed statements constant during binding

Browse Source
This commit is contained in:
Deukhoofd
2019-06-13 18:14:59 +02:00
parent 601c4a3f89
commit 5910cbbfa9
8 changed files with 238 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,3 +1,5 @@
#include <utility>
#ifndef PORYGONLANG_PARSEDEXPRESSION_HPP
#define PORYGONLANG_PARSEDEXPRESSION_HPP
@@ -28,26 +30,28 @@ enum class ParsedExpressionKind{
};
class ParsedExpression {
unsigned int _position;
unsigned int _length;
const unsigned int _position;
const unsigned int _length;
public:
ParsedExpression(unsigned int position, unsigned int length){
_position = position;
_length = length;
ParsedExpression(unsigned int position, unsigned int length)
: _position(position),
_length(length)
{
}
virtual ~ParsedExpression() = default;
virtual ParsedExpressionKind GetKind() = 0;
virtual const ParsedExpressionKind GetKind() const = 0;
unsigned int GetStartPosition(){
const unsigned int GetStartPosition() const{
return _position;
}
unsigned int GetEndPosition(){
const unsigned int GetEndPosition() const{
return _position + _length - 1;
}
unsigned int GetLength(){
const unsigned int GetLength() const{
return _length;
}
};
@@ -56,75 +60,83 @@ class BadExpression : public ParsedExpression{
public:
BadExpression(unsigned int position, unsigned int length) : ParsedExpression(position, length){}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Bad;
}
};
class LiteralIntegerExpression : public ParsedExpression{
long _value;
const long _value;
public:
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::LiteralInteger;
}
explicit LiteralIntegerExpression(IntegerToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength()){
_value = token->Value;
explicit LiteralIntegerExpression(IntegerToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
_value(token -> Value)
{
}
long GetValue(){
const long GetValue() const{
return _value;
}
};
class LiteralFloatExpression : public ParsedExpression{
double _value;
const double _value;
public:
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::LiteralFloat;
}
explicit LiteralFloatExpression(FloatToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength()){
_value = token->Value;
explicit LiteralFloatExpression(FloatToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
_value(token -> Value)
{
}
double GetValue(){
const double GetValue() const{
return _value;
}
};
class LiteralStringExpression : public ParsedExpression{
string _value;
const string _value;
public:
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::LiteralString;
}
explicit LiteralStringExpression(StringToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength()){
_value = std::move(token->Value);
explicit LiteralStringExpression(StringToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
_value(std::move(token -> Value))
{
}
string GetValue(){
const string& GetValue() const{
return _value;
}
};
class LiteralBoolExpression : public ParsedExpression{
bool _value;
const bool _value;
public:
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::LiteralBool;
}
explicit LiteralBoolExpression(IToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength()){
_value = token -> GetKind() == TokenKind::TrueKeyword;
explicit LiteralBoolExpression(IToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()),
_value(token -> GetKind() == TokenKind::TrueKeyword)
{
}
bool GetValue(){
const bool GetValue() const{
return _value;
}
};
class VariableExpression : public ParsedExpression{
HashedString _value;
const HashedString _value;
public:
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::Variable;
}
explicit VariableExpression(IdentifierToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength())
@@ -132,150 +144,153 @@ public:
{
}
HashedString GetValue(){
const HashedString GetValue() const{
return _value;
}
};
class ParenthesizedExpression : public ParsedExpression{
ParsedExpression* _expression;
const ParsedExpression* _expression;
public:
~ParenthesizedExpression() override {
delete _expression;
}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::Parenthesized;
}
explicit ParenthesizedExpression(ParsedExpression* innerExpression, unsigned int start, unsigned int length)
: ParsedExpression(start, length){
_expression = innerExpression;
: ParsedExpression(start, length), _expression(innerExpression){
}
ParsedExpression* GetInnerExpression(){
const ParsedExpression* GetInnerExpression() const{
return _expression;
}
};
class UnaryExpression : public ParsedExpression{
UnaryOperatorKind _kind;
ParsedExpression* _operand;
const UnaryOperatorKind _kind;
const ParsedExpression* _operand;
public:
~UnaryExpression() override {
delete _operand;
}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::Unary;
}
UnaryExpression(UnaryOperatorKind kind, ParsedExpression* operand, unsigned int start, unsigned int length)
: ParsedExpression(start, length){
_kind = kind;
_operand = operand;
: ParsedExpression(start, length),
_kind(kind), _operand(operand)
{
}
UnaryOperatorKind GetOperatorKind(){
const UnaryOperatorKind GetOperatorKind() const{
return _kind;
}
ParsedExpression* GetOperand(){
const ParsedExpression* GetOperand() const{
return _operand;
}
};
class BinaryExpression : public ParsedExpression{
BinaryOperatorKind _kind;
ParsedExpression* _left;
ParsedExpression* _right;
const BinaryOperatorKind _kind;
const ParsedExpression* _left;
const ParsedExpression* _right;
public:
~BinaryExpression() override {
delete _left;
delete _right;
}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::Binary;
}
BinaryExpression(BinaryOperatorKind kind, ParsedExpression* left, ParsedExpression* right, unsigned int start,
unsigned int length)
: ParsedExpression(start, length){
_kind = kind;
_left = left;
_right = right;
: ParsedExpression(start, length),
_kind(kind), _left(left), _right(right)
{
}
BinaryOperatorKind GetOperatorKind(){
const BinaryOperatorKind GetOperatorKind() const{
return _kind;
}
ParsedExpression* GetLeft() {
const ParsedExpression* GetLeft() const{
return _left;
}
ParsedExpression* GetRight() {
const ParsedExpression* GetRight() const{
return _right;
}
};
class FunctionCallExpression : public ParsedExpression{
std::unique_ptr<ParsedExpression> _function;
vector<std::unique_ptr<ParsedExpression>> _parameters;
const std::unique_ptr<ParsedExpression> _function;
const vector<const ParsedExpression*> _parameters;
public:
FunctionCallExpression(ParsedExpression* function, vector<ParsedExpression*> parameters,
unsigned int start, unsigned int length) : ParsedExpression(start, length){
_function = std::unique_ptr<ParsedExpression>(function);
for (int i = 0; i < parameters.size(); i++){
_parameters.push_back(std::unique_ptr<ParsedExpression>(parameters[i]));
FunctionCallExpression(ParsedExpression* function, vector<const ParsedExpression*> parameters, unsigned int start, unsigned int length)
: ParsedExpression(start, length),
_function(function), _parameters(std::move(parameters))
{
}
~FunctionCallExpression() final{
for (auto p : _parameters){
delete p;
}
}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::FunctionCall;
}
ParsedExpression* GetFunction(){
const ParsedExpression* GetFunction() const{
return _function.get();
}
vector<ParsedExpression*> GetParameters(){
auto par = vector<ParsedExpression*>(_parameters.size(), nullptr);
for (int i = 0; i < _parameters.size(); i++){
par[i] = _parameters[i].get();
}
return par;
const vector<const ParsedExpression*>* GetParameters() const{
return &_parameters;
}
};
class IndexExpression : public ParsedExpression{
std::unique_ptr<ParsedExpression> _indexerExpression;
std::unique_ptr<ParsedExpression> _indexExpression;
const ParsedExpression* _indexerExpression;
const ParsedExpression* _indexExpression;
public:
IndexExpression(ParsedExpression* indexer, ParsedExpression* index, unsigned int start, unsigned int length)
:ParsedExpression(start, length){
_indexerExpression = std::unique_ptr<ParsedExpression>(indexer);
_indexExpression = std::unique_ptr<ParsedExpression>(index);
:ParsedExpression(start, length),
_indexerExpression(indexer), _indexExpression(index)
{
}
ParsedExpressionKind GetKind() final{
~IndexExpression() final{
delete _indexerExpression;
delete _indexExpression;
}
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::Indexer;
}
ParsedExpression* GetIndexer(){
return _indexerExpression.get();
const ParsedExpression* GetIndexer() const{
return _indexerExpression;
}
ParsedExpression* GetIndex(){
return _indexExpression.get();
const ParsedExpression* GetIndex() const{
return _indexExpression;
}
};
class ParsedNumericalTableExpression : public ParsedExpression{
vector<ParsedExpression*> _expressions;
vector<const ParsedExpression*> _expressions;
public:
ParsedNumericalTableExpression(vector<ParsedExpression*> expressions, unsigned int start, unsigned int length)
ParsedNumericalTableExpression(vector<const ParsedExpression*> expressions, unsigned int start, unsigned int length)
: ParsedExpression(start, length){
_expressions = std::move(expressions);
}
@@ -286,11 +301,11 @@ public:
}
}
vector<ParsedExpression*> GetExpressions(){
return _expressions;
const vector<const ParsedExpression*>* GetExpressions() const{
return &_expressions;
}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::NumericalTable;
}
};

10
src/Parser/ParsedExpressions/ParsedTableExpression.hpp
View File

@@ -6,22 +6,22 @@
#include "../ParsedStatements/ParsedStatement.hpp"
class ParsedTableExpression : public ParsedExpression{
ParsedBlockStatement* _block;
const ParsedBlockStatement* _block;
public:
ParsedTableExpression(ParsedBlockStatement* block, unsigned int start, unsigned int length)
: ParsedExpression(start, length){
_block = block;
: ParsedExpression(start, length), _block(block)
{
}
~ParsedTableExpression() final{
delete _block;
}
ParsedBlockStatement* GetBlock(){
const ParsedBlockStatement* GetBlock() const{
return _block;
}
ParsedExpressionKind GetKind() final{
const ParsedExpressionKind GetKind() const final{
return ParsedExpressionKind::Table;
}
};

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

@@ -1,5 +1,7 @@
#include <utility>
#include <utility>
#ifndef PORYGONLANG_PARSEDSTATEMENT_HPP
#define PORYGONLANG_PARSEDSTATEMENT_HPP
@@ -23,25 +25,25 @@ enum class ParsedStatementKind{
};
class ParsedStatement {
unsigned int _start;
unsigned int _length;
const unsigned int _start;
const unsigned int _length;
public:
ParsedStatement(unsigned int start, unsigned int length){
_start = start;
_length = length;
ParsedStatement(unsigned int start, unsigned int length)
:_start(start), _length(length)
{
}
virtual ~ParsedStatement() = default;
virtual ParsedStatementKind GetKind() = 0;
virtual const ParsedStatementKind GetKind() const = 0;
unsigned int GetStartPosition(){
const unsigned int GetStartPosition() const {
return _start;
}
unsigned int GetLength(){
const unsigned int GetLength() const {
return _length;
}
unsigned int GetEndPosition(){
const unsigned int GetEndPosition() const {
return _start + _length - 1;
}
};
@@ -49,20 +51,22 @@ public:
class ParsedBadStatement : public ParsedStatement{
public:
ParsedBadStatement(unsigned int start, unsigned int length) : ParsedStatement(start, length){};
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Bad;
}
};
class ParsedBlockStatement : public ParsedStatement{
std::vector<ParsedStatement*> _statements;
const std::vector<const ParsedStatement*> _statements;
public:
explicit ParsedBlockStatement(std::vector<ParsedStatement*> statements)
: ParsedStatement(statements.front()->GetStartPosition(), statements.back()->GetEndPosition() - statements.front()->GetStartPosition()){
_statements = std::move(statements);
}
ParsedBlockStatement(std::vector<ParsedStatement*> statements, unsigned int start) : ParsedStatement(start, 0){
_statements = std::move(statements);
explicit ParsedBlockStatement(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))
{
}
@@ -70,50 +74,52 @@ public:
for (auto s: _statements){
delete s;
}
_statements.clear();
}
ParsedStatementKind GetKind() override{
const ParsedStatementKind GetKind() const override {
return ParsedStatementKind ::Block;
}
std::vector<ParsedStatement*>* GetStatements(){
const std::vector<const ParsedStatement*>* GetStatements() const{
return &_statements;
}
};
class ParsedScriptStatement : public ParsedBlockStatement{
public:
explicit ParsedScriptStatement(vector<ParsedStatement*> statements) : ParsedBlockStatement(move(statements)){}
explicit ParsedScriptStatement(vector<const ParsedStatement*> statements) : ParsedBlockStatement(move(statements)){}
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Script;
}
};
class ParsedExpressionStatement : public ParsedStatement{
ParsedExpression* _expression;
const ParsedExpression* _expression;
public:
explicit ParsedExpressionStatement(ParsedExpression* expression) : ParsedStatement(expression->GetStartPosition(), expression->GetLength()){
_expression = expression;
explicit ParsedExpressionStatement(ParsedExpression* expression)
: ParsedStatement(expression->GetStartPosition(), expression->GetLength()),
_expression(expression)
{
}
~ParsedExpressionStatement() override {
delete _expression;
}
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Expression;
}
ParsedExpression* GetExpression(){
const ParsedExpression* GetExpression() const{
return _expression;
}
};
class ParsedFunctionDeclarationStatement : public ParsedStatement{
HashedString _identifier;
vector<TypedVariableIdentifier*> _parameters;
ParsedBlockStatement* _block;
const HashedString _identifier;
const vector<TypedVariableIdentifier*> _parameters;
const ParsedBlockStatement* _block;
public:
ParsedFunctionDeclarationStatement(HashedString identifier, vector<TypedVariableIdentifier*> parameters, ParsedBlockStatement* block,
unsigned int start, unsigned int length)
@@ -126,90 +132,90 @@ public:
delete _block;
}
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::FunctionDeclaration;
}
HashedString GetIdentifier(){
const HashedString GetIdentifier() const{
return _identifier;
}
vector<TypedVariableIdentifier*> GetParameters(){
return _parameters;
const vector<TypedVariableIdentifier*>* GetParameters() const{
return &_parameters;
}
ParsedBlockStatement* GetBlock(){
const ParsedBlockStatement* GetBlock() const{
return _block;
}
};
class ParsedAssignmentStatement : public ParsedStatement{
bool _local;
HashedString _identifier;
ParsedExpression* _expression;
const bool _local;
const HashedString _identifier;
const ParsedExpression* _expression;
public:
ParsedAssignmentStatement(bool local, std::string identifier, ParsedExpression* expression, unsigned int start, unsigned int length)
: ParsedStatement(start, length), _identifier(HashedString(std::move(identifier)))
ParsedAssignmentStatement(bool local, const std::string& identifier, ParsedExpression* expression, unsigned int start, unsigned int length)
: ParsedStatement(start, length), _local(local), _identifier(HashedString(identifier)), _expression(expression)
{
_local = local;
_expression = expression;
}
~ParsedAssignmentStatement() final{
delete _expression;
}
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Assignment;
}
bool IsLocal(){
const bool IsLocal() const{
return _local;
}
HashedString GetIdentifier(){
const HashedString GetIdentifier() const{
return _identifier;
}
ParsedExpression* GetExpression(){
const ParsedExpression* GetExpression() const{
return _expression;
}
};
class ParsedReturnStatement : public ParsedStatement{
ParsedExpression* _expression;
const ParsedExpression* _expression;
public:
ParsedReturnStatement(ParsedExpression* expression, unsigned int start, unsigned int length) : ParsedStatement(start, length){
_expression = expression;
ParsedReturnStatement(ParsedExpression* expression, unsigned int start, unsigned int length)
: ParsedStatement(start, length),
_expression(expression)
{
}
~ParsedReturnStatement() final{
delete _expression;
}
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Return;
}
ParsedExpression* GetExpression(){
const ParsedExpression* GetExpression() const{
return _expression;
}
};
class ParsedConditionalStatement : public ParsedStatement{
ParsedExpression* _condition;
ParsedStatement* _block;
const ParsedExpression* _condition;
const ParsedStatement* _block;
// This can be either else if or else
ParsedStatement* _elseStatement;
const ParsedStatement* _elseStatement;
public:
ParsedConditionalStatement(ParsedExpression* condition, ParsedStatement* block, unsigned int start, unsigned int length)
: ParsedStatement(start, length){
_condition = condition;
_block = block;
_elseStatement = nullptr;
: ParsedStatement(start, length), _condition(condition), _block(block), _elseStatement(nullptr)
{
}
ParsedConditionalStatement(ParsedExpression* condition, ParsedStatement* block, ParsedStatement* nextStatement, unsigned int start, unsigned int length)
: ParsedStatement(start, length){
: ParsedStatement(start, length), _condition(condition), _block(block), _elseStatement(nextStatement)
{
_condition = condition;
_block = block;
_elseStatement = nextStatement;
@@ -221,19 +227,19 @@ public:
delete _elseStatement;
}
ParsedStatementKind GetKind() final{
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Conditional;
}
ParsedExpression* GetCondition(){
const ParsedExpression* GetCondition() const {
return _condition;
}
ParsedStatement* GetBlock(){
const ParsedStatement* GetBlock() const {
return _block;
}
ParsedStatement* GetElseStatement(){
const ParsedStatement* GetElseStatement() const {
return _elseStatement;
}
};

16
src/Parser/Parser.cpp
View File

@@ -1,3 +1,5 @@
#include <utility>
#include <algorithm>
#include "Parser.hpp"
@@ -9,7 +11,7 @@
ParsedScriptStatement* Parser::Parse() {
vector<ParsedStatement*> statements;
vector<const ParsedStatement*> statements;
while (this->_position < this->_tokens.size()){
auto next = this -> Next();
if (next->GetKind() == TokenKind::EndOfFile){
@@ -73,8 +75,8 @@ ParsedStatement *Parser::ParseAssignment(IToken *current) {
return new ParsedAssignmentStatement(isLocal, ((IdentifierToken*)identifier) -> Value, expression, start, expression->GetEndPosition() - start);
}
ParsedStatement *Parser::ParseBlock(const vector<TokenKind>& endTokens) {
vector<ParsedStatement*> statements;
ParsedStatement *Parser::ParseBlock(const vector<TokenKind>& endTokens, const vector<const ParsedStatement*>& openStatements) {
auto statements = openStatements;
auto start = this->_position;
while (this->_position < this->_tokens.size()){
auto next = this -> Next();
@@ -331,7 +333,7 @@ ParsedExpression *Parser::ParseParenthesizedExpression(IToken *current) {
ParsedExpression *Parser::ParseFunctionCallExpression(ParsedExpression* functionExpression) {
this -> Next(); // consume the open parenthesis
vector<ParsedExpression*> parameters;
vector<const ParsedExpression*> parameters;
auto peeked = this -> Peek();
auto peekedKind = peeked->GetKind();
if (peekedKind == TokenKind::CloseParenthesis){
@@ -379,7 +381,7 @@ ParsedExpression* Parser::ParseTableExpression(IToken* current){
if (firstItem->GetKind() == ParsedStatementKind::Expression &&
(this->Peek()->GetKind() == TokenKind::CommaToken )){
auto expr = ((ParsedExpressionStatement*)firstItem)->GetExpression();
auto expressions = vector<ParsedExpression*>{expr};
auto expressions = vector<const ParsedExpression*>{expr};
auto n = this -> Next(); // consume the comma
bool hasErrors = false;
while (n->GetKind() != TokenKind::CloseCurlyBracket){
@@ -398,9 +400,7 @@ ParsedExpression* Parser::ParseTableExpression(IToken* current){
}
// Otherwise we have a more complex table, which can be defined by a block
else {
auto block = (ParsedBlockStatement*)this -> ParseBlock({TokenKind ::CloseCurlyBracket});
auto statements = block->GetStatements();
statements->insert(statements->begin(), firstItem);
auto block = (ParsedBlockStatement*)this -> ParseBlock({TokenKind ::CloseCurlyBracket}, {firstItem});
auto closeToken = this -> PeekAt(-1);
return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start);
}

6
src/Parser/Parser.hpp
View File

@@ -27,7 +27,7 @@ class Parser {
ParsedStatement* ParseStatement(IToken* current);
ParsedStatement* ParseAssignment(IToken* current);
ParsedStatement *ParseBlock(const vector<TokenKind>& endTokens);
ParsedStatement *ParseBlock(const vector<TokenKind>& endTokens, const vector<const ParsedStatement*>& openStatements = {});
ParsedStatement* ParseFunctionDeclaration(IToken* current);
ParsedStatement *ParseReturnStatement(IToken *current);
ParsedStatement *ParseIfStatement(IToken *current);
@@ -41,8 +41,8 @@ class Parser {
ParsedExpression *ParseIndexExpression(ParsedExpression *indexingExpression);
public:
ParsedScriptStatement* Parse();
explicit Parser(vector<IToken*> tokens, Script* scriptData){
_tokens = std::move(tokens);
explicit Parser(const vector<IToken*>& tokens, Script* scriptData){
_tokens = tokens;
_position = 0;
ScriptData = scriptData;
}