add EXIT statement

Author: ghewgill

ast.h

@@ -923,9 +923,16 @@ class IfStatement: public Statement {
     IfStatement &operator=(const IfStatement &);
 };
 
-class WhileStatement: public CompoundStatement {
+class LoopStatement: public CompoundStatement {
 public:
-    WhileStatement(const Expression *condition, const std::vector<const Statement *> &statements): CompoundStatement(statements), condition(condition) {}
+    LoopStatement(unsigned int loop_id, const std::vector<const Statement *> &statements): CompoundStatement(statements), loop_id(loop_id) {}
+
+    const unsigned int loop_id;
+};
+
+class WhileStatement: public LoopStatement {
+public:
+    WhileStatement(unsigned int loop_id, const Expression *condition, const std::vector<const Statement *> &statements): LoopStatement(loop_id, statements), condition(condition) {}
 
     const Expression *condition;
 
@@ -939,9 +946,9 @@ class WhileStatement: public CompoundStatement {
     WhileStatement &operator=(const WhileStatement &);
 };
 
-class ForStatement: public CompoundStatement {
+class ForStatement: public LoopStatement {
 public:
-    ForStatement(const VariableReference *var, const Expression *start, const Expression *end, const std::vector<const Statement *> &statements): CompoundStatement(statements), var(var), start(start), end(end) {
+    ForStatement(unsigned int loop_id, const VariableReference *var, const Expression *start, const Expression *end, const std::vector<const Statement *> &statements): LoopStatement(loop_id, statements), var(var), start(start), end(end) {
     }
 
     const VariableReference *var;
@@ -1003,6 +1010,20 @@ class CaseStatement: public Statement {
     CaseStatement &operator=(const CaseStatement &);
 };
 
+class ExitStatement: public Statement {
+public:
+    ExitStatement(unsigned int loop_id): loop_id(loop_id) {}
+
+    const unsigned int loop_id;
+
+    virtual void generate(Emitter &emitter) const;
+
+    virtual std::string text() const { return "ExitStatement(...)"; }
+private:
+    ExitStatement(const ExitStatement &);
+    ExitStatement &operator=(const ExitStatement &);
+};
+
 class Function: public Variable {
 public:
     Function(const std::string &name, const Type *returntype, Scope *scope, const std::vector<FunctionParameter *> &params): Variable(name, makeFunctionType(returntype, params)), scope(scope), params(params), entry_label(-1), statements() {}

compiler.cpp

@@ -16,7 +16,7 @@ class Emitter {
         int target;
     };
 public:
-    Emitter(): code(), strings(), globals(), functions() {}
+    Emitter(): code(), strings(), globals(), functions(), exit_label() {}
     void emit(unsigned char b);
     void emit_int(int value);
     void emit(unsigned char b, int value);
@@ -29,11 +29,15 @@ class Emitter {
     Label create_label();
     void emit_jump(unsigned char b, Label &label);
     void jump_target(Label &label);
+    void add_exit_label(unsigned int loop_id, Label &label);
+    void remove_exit_label(unsigned int loop_id);
+    Label &get_exit_label(unsigned int loop_id);
 private:
     std::vector<unsigned char> code;
     std::vector<std::string> strings;
     std::vector<std::string> globals;
     std::vector<Label> functions;
+    std::map<size_t, Label *> exit_label;
 };
 
 void Emitter::emit(unsigned char b)
@@ -121,7 +125,7 @@ void Emitter::emit_jump(unsigned char b, Label &label)
         emit_int(label.target);
     } else {
         label.fixups.push_back(static_cast<int>(code.size()));
-        emit_int(0);
+        emit_int(-1);
     }
 }
 
@@ -137,6 +141,24 @@ void Emitter::jump_target(Label &label)
     }
 }
 
+void Emitter::add_exit_label(unsigned int loop_id, Label &label)
+{
+    exit_label[loop_id] = &label;
+}
+
+void Emitter::remove_exit_label(unsigned int loop_id)
+{
+    exit_label.erase(loop_id);
+}
+
+Emitter::Label &Emitter::get_exit_label(unsigned int loop_id)
+{
+    if (exit_label.find(loop_id) == exit_label.end()) {
+        internal_error("loop_id not found");
+    }
+    return *exit_label[loop_id];
+}
+
 void TypeBoolean::generate_load(Emitter &emitter) const
 {
     emitter.emit(LOADB);
@@ -664,12 +686,14 @@ void WhileStatement::generate(Emitter &emitter) const
     emitter.jump_target(top);
     condition->generate(emitter);
     auto skip = emitter.create_label();
+    emitter.add_exit_label(loop_id, skip);
     emitter.emit_jump(JF, skip);
     for (auto stmt: statements) {
         stmt->generate(emitter);
     }
     emitter.emit_jump(JUMP, top);
     emitter.jump_target(skip);
+    emitter.remove_exit_label(loop_id);
 }
 
 void CaseStatement::generate(Emitter &emitter) const
@@ -746,6 +770,7 @@ void CaseStatement::RangeWhenCondition::generate(Emitter &emitter) const
 void ForStatement::generate(Emitter &emitter) const
 {
     auto skip = emitter.create_label();
+    emitter.add_exit_label(loop_id, skip);
     auto loop = emitter.create_label();
 
     start->generate(emitter);
@@ -771,6 +796,12 @@ void ForStatement::generate(Emitter &emitter) const
     emitter.emit_jump(JUMP, loop);
 
     emitter.jump_target(skip);
+    emitter.remove_exit_label(loop_id);
+}
+
+void ExitStatement::generate(Emitter &emitter) const
+{
+    emitter.emit_jump(JUMP, emitter.get_exit_label(loop_id));
 }
 
 void Scope::predeclare(Emitter &emitter) const

lexer.cpp

@@ -71,6 +71,7 @@ std::string Token::tostring() const
         case WHEN:        s << "WHEN"; break;
         case DOTDOT:      s << "DOTDOT"; break;
         case EXTERNAL:    s << "EXTERNAL"; break;
+        case EXIT:        s << "EXIT"; break;
     }
     s << ">";
     return s.str();
@@ -190,6 +191,7 @@ std::vector<Token> tokenize(const std::string &source)
             else if (t.text == "CASE") t.type = CASE;
             else if (t.text == "WHEN") t.type = WHEN;
             else if (t.text == "EXTERNAL") t.type = EXTERNAL;
+            else if (t.text == "EXIT") t.type = EXIT;
         } else if (isdigit(c)) {
             t.type = NUMBER;
             if (c == '0' && (i+1 < source.length()) && source.at(i+1) != '.' && tolower(source.at(i+1)) != 'e' && not isdigit(source.at(i+1))) {

lexer.h

@@ -65,6 +65,7 @@ enum TokenType {
     WHEN,
     DOTDOT,
     EXTERNAL,
+    EXIT,
 };
 
 class Token {

parser.cpp

@@ -1,6 +1,7 @@
 #include "parser.h"
 
 #include <iso646.h>
+#include <list>
 
 #include "ast.h"
 #include "rtl.h"
@@ -14,6 +15,8 @@ class Parser {
     static Scope *global_scope; // TODO: static is a hack, used by StringReference constructor
     std::vector<Token>::size_type i;
 
+    std::stack<std::list<std::pair<TokenType, unsigned int>>> loops;
+
     typedef std::pair<std::vector<std::string>, const Type *> VariableInfo;
 
     const Type *parseArrayType(Scope *scope);
@@ -45,6 +48,7 @@ class Parser {
     const Statement *parseWhileStatement(Scope *scope);
     const Statement *parseCaseStatement(Scope *scope);
     const Statement *parseForStatement(Scope *scope);
+    const Statement *parseExitStatement(Scope *scope);
     const Statement *parseImport(Scope *scope);
     const Statement *parseStatement(Scope *scope);
     const Program *parse();
@@ -57,7 +61,8 @@ Scope *Parser::global_scope;
 
 Parser::Parser(const std::vector<Token> &tokens)
   : tokens(tokens),
-    i(0)
+    i(0),
+    loops()
 {
 }
 
@@ -841,6 +846,7 @@ const Statement *Parser::parseFunctionDefinition(Scope *scope)
     parseFunctionHeader(scope, name, returntype, newscope, args);
     Function *function = new Function(name, returntype, newscope, args);
     scope->addName(name, function);
+    loops.push(std::list<std::pair<TokenType, unsigned int>>());
     while (tokens[i].type != END) {
         const Statement *s = parseStatement(newscope);
         if (s != nullptr) {
@@ -852,6 +858,7 @@ const Statement *Parser::parseFunctionDefinition(Scope *scope)
         error(2102, tokens[i], "'FUNCTION' expected");
     }
     ++i;
+    loops.pop();
     return nullptr;
 }
 
@@ -1002,6 +1009,8 @@ const Statement *Parser::parseWhileStatement(Scope *scope)
         error(2082, tokens[i], "DO expected");
     }
     ++i;
+    auto loop_id = i;
+    loops.top().push_back(std::make_pair(WHILE, loop_id));
     std::vector<const Statement *> statements;
     while (tokens[i].type != END && tokens[i].type != END_OF_FILE) {
         const Statement *s = parseStatement(scope);
@@ -1017,7 +1026,8 @@ const Statement *Parser::parseWhileStatement(Scope *scope)
         error(2104, tokens[i], "WHILE expected");
     }
     ++i;
-    return new WhileStatement(cond, statements);
+    loops.top().pop_back();
+    return new WhileStatement(loop_id, cond, statements);
 }
 
 const Statement *Parser::parseCaseStatement(Scope *scope)
@@ -1277,6 +1287,8 @@ const Statement *Parser::parseForStatement(Scope *scope)
         error(2118, tokens[i], "'DO' expected");
     }
     ++i;
+    auto loop_id = i;
+    loops.top().push_back(std::make_pair(FOR, loop_id));
     std::vector<const Statement *> statements;
     while (tokens[i].type != END && tokens[i].type != END_OF_FILE) {
         const Statement *s = parseStatement(scope);
@@ -1292,7 +1304,27 @@ const Statement *Parser::parseForStatement(Scope *scope)
         error(2120, tokens[i], "'END FOR' expected");
     }
     ++i;
-    return new ForStatement(var, start, end, statements);
+    loops.top().pop_back();
+    return new ForStatement(loop_id, var, start, end, statements);
+}
+
+const Statement *Parser::parseExitStatement(Scope *)
+{
+    ++i;
+    if (tokens[i].type != WHILE
+     && tokens[i].type != FOR) {
+        error(2136, tokens[i], "loop type expected");
+    }
+    TokenType type = tokens[i].type;
+    ++i;
+    if (not loops.empty()) {
+        for (auto j = loops.top().rbegin(); j != loops.top().rend(); ++j) {
+            if (j->first == type) {
+                return new ExitStatement(j->second);
+            }
+        }
+    }
+    error(2137, tokens[i-1], "no matching loop found in current scope");
 }
 
 const Statement *Parser::parseImport(Scope *scope)
@@ -1330,6 +1362,8 @@ const Statement *Parser::parseStatement(Scope *scope)
         return parseCaseStatement(scope);
     } else if (tokens[i].type == FOR) {
         return parseForStatement(scope);
+    } else if (tokens[i].type == EXIT) {
+        return parseExitStatement(scope);
     } else if (tokens[i].type == IDENTIFIER) {
         const VariableReference *ref = parseVariableReference(scope);
         if (tokens[i].type == ASSIGN) {
@@ -1364,12 +1398,14 @@ const Program *Parser::parse()
 {
     Program *program = new Program();
     global_scope = program->scope;
+    loops.push(std::list<std::pair<TokenType, unsigned int>>());
     while (tokens[i].type != END_OF_FILE) {
         const Statement *s = parseStatement(program->scope);
         if (s != nullptr) {
             program->statements.push_back(s);
         }
     }
+    loops.pop();
     return program;
 }
 

t/exit-for.simple

@@ -0,0 +1,12 @@
+VAR a: Number
+FOR a IN 0 TO 5 DO
+    print(str(a))
+    IF a = 3 THEN
+        EXIT FOR
+    END IF
+END FOR
+
+%= 0
+%= 1
+%= 2
+%= 3

t/break.simple t/exit-while.simplet/break.simple renamed to t/exit-while.simple

@@ -1,12 +1,11 @@
-% TODO
-
 VAR a: Number
 a := 5
 WHILE a > 0 DO
     print(str(a))
     IF a = 3 THEN
-        BREAK
+        EXIT WHILE
     END IF
+    a := a - 1
 END WHILE
 
 %= 5