feat: add support for until keyword (#122)

* feat

* add tests for until

Author: Sh0g0-1758

README.md

@@ -86,7 +86,7 @@ Scarlet currently supports the following architectures:
 - [x] Add support for compound operators (+=,-=,*=,/=,<<=,>>=,%=)
 - [x] Add support for goto statement
 - [x] Add support for compound statements
-- [x] Add support for Loops (for, while, do-while)
+- [x] Add support for Loops (for, while, do-while, until, do-until)
 - [x] Add support for switch-case
 - [x] Add support for Functions
 - [x] Add support for static keyword and global scope

expected_results.json

@@ -319,6 +319,8 @@ void lexer::tokenize() {
         tokens.emplace_back(token::TOKEN::DO);
       } else if (identifier == "while") {
         tokens.emplace_back(token::TOKEN::WHILE);
+      } else if (identifier == "until") {
+        tokens.emplace_back(token::TOKEN::UNTIL);
       } else if (identifier == "for") {
         tokens.emplace_back(token::TOKEN::FOR);
       } else if (identifier == "break") {

lexer/lexer.cc

@@ -90,16 +90,35 @@ void parser::parse_statement(
     block_stmt->set_type(ast::statementType::BLOCK);
     block_stmt->set_block(std::move(block_node));
     statement = std::static_pointer_cast<ast::AST_Statement_Node>(block_stmt);
-  } else if (tokens[0].get_token() == token::TOKEN::WHILE) {
+  } else if (tokens[0].get_token() == token::TOKEN::WHILE or
+             tokens[0].get_token() == token::TOKEN::UNTIL) {
     MAKE_SHARED(ast::AST_while_statement_Node, while_statement);
+    bool is_until = false;
+    if (tokens[0].get_token() == token::TOKEN::UNTIL)
+      is_until = true;
     while_statement->set_type(ast::statementType::WHILE);
     tokens.erase(tokens.begin());
     while_statement->set_labels(get_loop_labels());
 
     EXPECT(token::TOKEN::OPEN_PARANTHESES);
     MAKE_SHARED(ast::AST_exp_Node, exp);
     parse_exp(tokens, exp);
-    while_statement->set_exp(std::move(exp));
+    if (is_until) {
+      MAKE_SHARED(ast::AST_exp_Node, not_exp);
+      MAKE_SHARED(ast::AST_factor_Node, not_factor);
+      MAKE_SHARED(ast::AST_unop_Node, not_op);
+      MAKE_SHARED(ast::AST_factor_Node, child_factor);
+
+      child_factor->set_exp_node(std::move(exp));
+      not_op->set_op(unop::UNOP::NOT);
+      not_factor->set_unop_node(std::move(not_op));
+      not_factor->set_child(std::move(child_factor));
+      not_exp->set_factor_node(std::move(not_factor));
+
+      while_statement->set_exp(std::move(not_exp));
+    } else {
+      while_statement->set_exp(std::move(exp));
+    }
 
     EXPECT(token::TOKEN::CLOSE_PARANTHESES);
 
@@ -220,11 +239,32 @@ void parser::parse_statement(
     parse_statement(tokens, stmt);
     while_statement->set_stmt(std::move(stmt));
 
-    EXPECT(token::TOKEN::WHILE);
+    bool is_until = false;
+    if (tokens[0].get_token() == token::TOKEN::UNTIL) {
+      is_until = true;
+      tokens.erase(tokens.begin());
+    } else {
+      EXPECT(token::TOKEN::WHILE);
+    }
     EXPECT(token::TOKEN::OPEN_PARANTHESES);
     MAKE_SHARED(ast::AST_exp_Node, exp);
     parse_exp(tokens, exp);
-    while_statement->set_exp(std::move(exp));
+    if (is_until) {
+      MAKE_SHARED(ast::AST_exp_Node, not_exp);
+      MAKE_SHARED(ast::AST_factor_Node, not_factor);
+      MAKE_SHARED(ast::AST_unop_Node, not_op);
+      MAKE_SHARED(ast::AST_factor_Node, child_factor);
+
+      child_factor->set_exp_node(std::move(exp));
+      not_op->set_op(unop::UNOP::NOT);
+      not_factor->set_unop_node(std::move(not_op));
+      not_factor->set_child(std::move(child_factor));
+      not_exp->set_factor_node(std::move(not_factor));
+
+      while_statement->set_exp(std::move(not_exp));
+    } else
+      while_statement->set_exp(std::move(exp));
+
     EXPECT(token::TOKEN::CLOSE_PARANTHESES);
     EXPECT(token::TOKEN::SEMICOLON);
 

parser/parse_statement.cc

@@ -0,0 +1,9 @@
+int main(void) {
+  int a = 1;
+  do {
+    a = a * 2;
+  }
+  until(a >= 11);
+
+  return a;
+}

test_framework/__pycache__/basic.cpython-312.pyc

@@ -0,0 +1,7 @@
+int main(void) {
+  int count = 0;
+
+  until(count >= 5) { count = count + 1; }
+
+  return count;
+}

test_framework/__pycache__/regalloc.cpython-312.pyc

@@ -50,6 +50,9 @@ void print_token(TOKEN token) {
   case TOKEN::WHILE:
     std::cerr << "while ";
     break;
+  case TOKEN::UNTIL:
+    std::cerr << "until ";
+    break;
   case TOKEN::FOR:
     std::cerr << "for ";
     break;
@@ -289,6 +292,8 @@ std::string to_string(TOKEN token) {
     return "do";
   case TOKEN::WHILE:
     return "while";
+  case TOKEN::UNTIL:
+    return "until";
   case TOKEN::FOR:
     return "for";
   case TOKEN::BREAK:

test_framework/__pycache__/runner.cpython-312.pyc

@@ -29,6 +29,7 @@ enum class TOKEN {
   ELSE,
   DO,
   WHILE,
+  UNTIL,
   FOR,
   BREAK,
   CONTINUE,