aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--AST.cpp7
-rw-r--r--AST.h24
-rw-r--r--ASTForward.h1
-rw-r--r--ASTPrinter.cpp12
-rw-r--r--ASTPrinter.h2
-rw-r--r--ASTVisitor.h4
-rw-r--r--AST_accept.h24
-rw-r--r--Compiler.cpp7
-rw-r--r--Compiler.h1
-rw-r--r--Parser.cpp54
-rw-r--r--Parser.h6
-rw-r--r--grammar.txt1
12 files changed, 134 insertions, 9 deletions
diff --git a/AST.cpp b/AST.cpp
index 5e344ead..c286c412 100644
--- a/AST.cpp
+++ b/AST.cpp
@@ -130,6 +130,13 @@ void WhileStatement::checkTypeRequirements()
m_body->checkTypeRequirements();
}
+void ForStatement::checkTypeRequirements()
+{
+ // LTODO
+ m_condExpression->expectType(BoolType());
+ m_body->checkTypeRequirements();
+}
+
void Return::checkTypeRequirements()
{
if (!m_expression)
diff --git a/AST.h b/AST.h
index 4bb623b4..297b7f4e 100644
--- a/AST.h
+++ b/AST.h
@@ -509,6 +509,30 @@ private:
ASTPointer<Statement> m_body;
};
+class ForStatement: public BreakableStatement
+{
+public:
+ ForStatement(Location const& _location,
+ ASTPointer<ASTNode> const& _initExpression,
+ ASTPointer<Expression> const& _conditionExpression,
+ ASTPointer<ExpressionStatement> const& _loopExpression,
+ ASTPointer<Statement> const& _body):
+ BreakableStatement(_location),
+ m_initExpression(_initExpression),
+ m_condExpression(_conditionExpression),
+ m_loopExpression(_loopExpression),
+ m_body(_body) {}
+ virtual void accept(ASTVisitor& _visitor) override;
+ virtual void accept(ASTConstVisitor& _visitor) const override;
+ virtual void checkTypeRequirements() override;
+
+private:
+ ASTPointer<ASTNode> m_initExpression;
+ ASTPointer<Expression> m_condExpression;
+ ASTPointer<ExpressionStatement> m_loopExpression;
+ ASTPointer<Statement> m_body;
+};
+
class Continue: public Statement
{
public:
diff --git a/ASTForward.h b/ASTForward.h
index d6c4c9f4..c960fc8f 100644
--- a/ASTForward.h
+++ b/ASTForward.h
@@ -52,6 +52,7 @@ class Block;
class IfStatement;
class BreakableStatement;
class WhileStatement;
+class ForStatement;
class Continue;
class Break;
class Return;
diff --git a/ASTPrinter.cpp b/ASTPrinter.cpp
index 970822a9..916fca1e 100644
--- a/ASTPrinter.cpp
+++ b/ASTPrinter.cpp
@@ -150,6 +150,13 @@ bool ASTPrinter::visit(WhileStatement const& _node)
return goDeeper();
}
+bool ASTPrinter::visit(ForStatement const& _node)
+{
+ writeLine("ForStatement");
+ printSourcePart(_node);
+ return goDeeper();
+}
+
bool ASTPrinter::visit(Continue const& _node)
{
writeLine("Continue");
@@ -360,6 +367,11 @@ void ASTPrinter::endVisit(WhileStatement const&)
m_indentation--;
}
+void ASTPrinter::endVisit(ForStatement const&)
+{
+ m_indentation--;
+}
+
void ASTPrinter::endVisit(Continue const&)
{
m_indentation--;
diff --git a/ASTPrinter.h b/ASTPrinter.h
index 15b65e3f..fc5fb4ac 100644
--- a/ASTPrinter.h
+++ b/ASTPrinter.h
@@ -57,6 +57,7 @@ public:
bool visit(IfStatement const& _node) override;
bool visit(BreakableStatement const& _node) override;
bool visit(WhileStatement const& _node) override;
+ bool visit(ForStatement const& _node) override;
bool visit(Continue const& _node) override;
bool visit(Break const& _node) override;
bool visit(Return const& _node) override;
@@ -90,6 +91,7 @@ public:
void endVisit(IfStatement const&) override;
void endVisit(BreakableStatement const&) override;
void endVisit(WhileStatement const&) override;
+ void endVisit(ForStatement const&) override;
void endVisit(Continue const&) override;
void endVisit(Break const&) override;
void endVisit(Return const&) override;
diff --git a/ASTVisitor.h b/ASTVisitor.h
index 5728cd3d..33a8a338 100644
--- a/ASTVisitor.h
+++ b/ASTVisitor.h
@@ -58,6 +58,7 @@ public:
virtual bool visit(IfStatement&) { return true; }
virtual bool visit(BreakableStatement&) { return true; }
virtual bool visit(WhileStatement&) { return true; }
+ virtual bool visit(ForStatement&) { return true; }
virtual bool visit(Continue&) { return true; }
virtual bool visit(Break&) { return true; }
virtual bool visit(Return&) { return true; }
@@ -93,6 +94,7 @@ public:
virtual void endVisit(IfStatement&) { }
virtual void endVisit(BreakableStatement&) { }
virtual void endVisit(WhileStatement&) { }
+ virtual void endVisit(ForStatement&) { }
virtual void endVisit(Continue&) { }
virtual void endVisit(Break&) { }
virtual void endVisit(Return&) { }
@@ -132,6 +134,7 @@ public:
virtual bool visit(IfStatement const&) { return true; }
virtual bool visit(BreakableStatement const&) { return true; }
virtual bool visit(WhileStatement const&) { return true; }
+ virtual bool visit(ForStatement const&) { return true; }
virtual bool visit(Continue const&) { return true; }
virtual bool visit(Break const&) { return true; }
virtual bool visit(Return const&) { return true; }
@@ -167,6 +170,7 @@ public:
virtual void endVisit(IfStatement const&) { }
virtual void endVisit(BreakableStatement const&) { }
virtual void endVisit(WhileStatement const&) { }
+ virtual void endVisit(ForStatement const&) { }
virtual void endVisit(Continue const&) { }
virtual void endVisit(Break const&) { }
virtual void endVisit(Return const&) { }
diff --git a/AST_accept.h b/AST_accept.h
index e0454d33..ffef6f8b 100644
--- a/AST_accept.h
+++ b/AST_accept.h
@@ -267,6 +267,30 @@ void WhileStatement::accept(ASTConstVisitor& _visitor) const
_visitor.endVisit(*this);
}
+void ForStatement::accept(ASTVisitor& _visitor)
+{
+ if (_visitor.visit(*this))
+ {
+ m_initExpression->accept(_visitor);
+ m_condExpression->accept(_visitor);
+ m_loopExpression->accept(_visitor);
+ m_body->accept(_visitor);
+ }
+ _visitor.endVisit(*this);
+}
+
+void ForStatement::accept(ASTConstVisitor& _visitor) const
+{
+ if (_visitor.visit(*this))
+ {
+ m_initExpression->accept(_visitor);
+ m_condExpression->accept(_visitor);
+ m_loopExpression->accept(_visitor);
+ m_body->accept(_visitor);
+ }
+ _visitor.endVisit(*this);
+}
+
void Continue::accept(ASTVisitor& _visitor)
{
_visitor.visit(*this);
diff --git a/Compiler.cpp b/Compiler.cpp
index f2877c1c..a0cad537 100644
--- a/Compiler.cpp
+++ b/Compiler.cpp
@@ -287,6 +287,13 @@ bool Compiler::visit(WhileStatement const& _whileStatement)
return false;
}
+bool Compiler::visit(ForStatement const& _forStatement)
+{
+ // LTODO
+ (void) _forStatement;
+ return false;
+}
+
bool Compiler::visit(Continue const&)
{
if (!m_continueTags.empty())
diff --git a/Compiler.h b/Compiler.h
index 57e40cda..c4f46d10 100644
--- a/Compiler.h
+++ b/Compiler.h
@@ -53,6 +53,7 @@ private:
virtual bool visit(FunctionDefinition const& _function) override;
virtual bool visit(IfStatement const& _ifStatement) override;
virtual bool visit(WhileStatement const& _whileStatement) override;
+ virtual bool visit(ForStatement const& _forStatement) override;
virtual bool visit(Continue const& _continue) override;
virtual bool visit(Break const& _break) override;
virtual bool visit(Return const& _return) override;
diff --git a/Parser.cpp b/Parser.cpp
index 21651eb1..9941fbf4 100644
--- a/Parser.cpp
+++ b/Parser.cpp
@@ -304,6 +304,8 @@ ASTPointer<Statement> Parser::parseStatement()
return parseIfStatement();
case Token::WHILE:
return parseWhileStatement();
+ case Token::FOR:
+ return parseForStatement();
case Token::LBRACE:
return parseBlock();
// starting from here, all statements must be terminated by a semicolon
@@ -328,15 +330,7 @@ ASTPointer<Statement> Parser::parseStatement()
}
break;
default:
- // distinguish between variable definition (and potentially assignment) and expression statement
- // (which include assignments to other expressions and pre-declared variables)
- // We have a variable definition if we get a keyword that specifies a type name, or
- // in the case of a user-defined type, we have two identifiers following each other.
- if (m_scanner->getCurrentToken() == Token::MAPPING ||
- m_scanner->getCurrentToken() == Token::VAR ||
- ((Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
- m_scanner->getCurrentToken() == Token::IDENTIFIER) &&
- m_scanner->peekNextToken() == Token::IDENTIFIER))
+ if (peekVariableDefinition())
statement = parseVariableDefinition();
else // "ordinary" expression statement
statement = parseExpressionStatement();
@@ -377,6 +371,34 @@ ASTPointer<WhileStatement> Parser::parseWhileStatement()
return nodeFactory.createNode<WhileStatement>(condition, body);
}
+ASTPointer<ForStatement> Parser::parseForStatement()
+{
+ ASTNodeFactory nodeFactory(*this);
+ expectToken(Token::FOR);
+ expectToken(Token::LPAREN);
+ ASTPointer<ASTNode> initExpression = parseVardefOrExprstatement();
+ expectToken(Token::SEMICOLON);
+ ASTPointer<Expression> conditionExpression = parseExpression();
+ expectToken(Token::SEMICOLON);
+ ASTPointer<ExpressionStatement> loopExpression = parseExpressionStatement();
+ expectToken(Token::SEMICOLON);
+ expectToken(Token::RPAREN);
+ ASTPointer<Statement> body = parseStatement();
+ nodeFactory.setEndPositionFromNode(body);
+ return nodeFactory.createNode<ForStatement>(initExpression,
+ conditionExpression,
+ loopExpression,
+ body);
+}
+
+ASTPointer<ASTNode> Parser::parseVardefOrExprstatement()
+{
+ if (peekVariableDefinition())
+ return parseVariableDefinition();
+ else
+ return parseExpressionStatement();
+}
+
ASTPointer<VariableDefinition> Parser::parseVariableDefinition()
{
ASTNodeFactory nodeFactory(*this);
@@ -566,6 +588,20 @@ vector<ASTPointer<Expression>> Parser::parseFunctionCallArguments()
return arguments;
}
+
+// distinguish between variable definition (and potentially assignment) and expression statement
+// (which include assignments to other expressions and pre-declared variables)
+// We have a variable definition if we get a keyword that specifies a type name, or
+// in the case of a user-defined type, we have two identifiers following each other.
+bool Parser::peekVariableDefinition()
+{
+ return (m_scanner->getCurrentToken() == Token::MAPPING ||
+ m_scanner->getCurrentToken() == Token::VAR ||
+ ((Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
+ m_scanner->getCurrentToken() == Token::IDENTIFIER) &&
+ m_scanner->peekNextToken() == Token::IDENTIFIER));
+}
+
void Parser::expectToken(Token::Value _value)
{
if (m_scanner->getCurrentToken() != _value)
diff --git a/Parser.h b/Parser.h
index 52a374e0..343a85c0 100644
--- a/Parser.h
+++ b/Parser.h
@@ -59,6 +59,8 @@ private:
ASTPointer<Statement> parseStatement();
ASTPointer<IfStatement> parseIfStatement();
ASTPointer<WhileStatement> parseWhileStatement();
+ ASTPointer<ForStatement> parseForStatement();
+ ASTPointer<ASTNode> parseVardefOrExprstatement();
ASTPointer<VariableDefinition> parseVariableDefinition();
ASTPointer<ExpressionStatement> parseExpressionStatement();
ASTPointer<Expression> parseExpression();
@@ -72,6 +74,10 @@ private:
///@{
///@name Helper functions
+ /// Peeks ahead in the scanner to determine if an expression statement
+ /// could be a variable definition
+ bool peekVariableDefinition();
+
/// If current token value is not _value, throw exception otherwise advance token.
void expectToken(Token::Value _value);
Token::Value expectAssignmentOperator();
diff --git a/grammar.txt b/grammar.txt
index a26f717a..99a59001 100644
--- a/grammar.txt
+++ b/grammar.txt
@@ -20,6 +20,7 @@ Statement = IfStatement | WhileStatement | Block |
IfStatement = 'if' '(' Expression ')' Statement ( 'else' Statement )?
WhileStatement = 'while' '(' Expression ')' Statement
+ForStatement = 'for' '(' Expressionstatement Expression Expressionstatement ')' Statement
Continue = 'continue' ';'
Break = 'break' ';'
Return = 'return' Expression? ';'
generated by cgit (git 2.34.1) at 2024-09-25 09:33:15 +0800