feat: add logical operators (and, or) and while statements

Author: aymaneelmaini

src/chunk.h

@@ -28,6 +28,7 @@ typedef enum
     OP_PRINT,
     OP_JUMP,
     OP_JUMP_IF_FALSE,
+    OP_LOOP,
     OP_RETURN,
 } OpCode;
 

src/compiler.c

@@ -1,9 +1,7 @@
-#include <assert.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
 
 #include "chunk.h"
 #include "common.h"
@@ -153,6 +151,18 @@ static void emit_bytes(u8 byte_1, u8 byte_2)
     emit_byte(byte_2);
 }
 
+static void emit_loop(int loop_start)
+{
+    emit_byte(OP_LOOP);
+
+    int offset = current_chunk()->count - loop_start + 2;
+    if (offset > UINT16_MAX)
+        error("Loop body too large");
+
+    emit_byte((offset >> 8) & 0xff);
+    emit_byte(offset & 0xff);
+}
+
 static int emit_jump(u8 instruction)
 {
     emit_byte(instruction);
@@ -319,6 +329,16 @@ static void define_variable(u8 global, bool is_immutable)
     emit_bytes(OP_DEFINE_GLOBAL, global);
 }
 
+static void and_(bool can_assign)
+{
+    int end_jump = emit_jump(OP_JUMP_IF_FALSE);
+
+    emit_byte(OP_POP);
+    parse_precedence(PREC_AND);
+
+    patch_jump(end_jump);
+}
+
 static void binary(bool can_assign)
 {
     TokenType operator_type = parser.previous.type;
@@ -393,6 +413,18 @@ static void number(bool can_assign)
     emit_constant(NUMBER_VAL(value));
 }
 
+static void or_(bool can_assign)
+{
+    int else_jump = emit_jump(OP_JUMP_IF_FALSE);
+    int end_jump = emit_jump(OP_JUMP);
+
+    patch_jump(else_jump);
+    emit_byte(OP_POP);
+
+    parse_precedence(PREC_OR);
+    patch_jump(end_jump);
+}
+
 static void string(bool can_assign)
 {
     emit_constant(OBJ_VAL(
@@ -489,15 +521,15 @@ ParseRule rules[] = {
     [TOKEN_STRING]         =  { string,    NULL,    PREC_NONE        },
     [TOKEN_NUMBER]         =  { number,    NULL,    PREC_NONE        },
     [TOKEN_IDENTIFIER]     =  { variable,  NULL,    PREC_NONE        },
-    [TOKEN_AND]            =  { NULL,      NULL,    PREC_NONE        },
+    [TOKEN_AND]            =  { NULL,      and_,    PREC_AND        },
     [TOKEN_CLASS]          =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_ELSE]           =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_FALSE]          =  { literal,   NULL,    PREC_NONE        },
     [TOKEN_FOR]            =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_FUN]            =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_IF]             =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_NIL]            =  { literal,   NULL,    PREC_NONE        },
-    [TOKEN_OR]             =  { NULL,      NULL,    PREC_NONE        },
+    [TOKEN_OR]             =  { NULL,      or_,     PREC_OR        },
     [TOKEN_PRINT]          =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_RETURN]         =  { NULL,      NULL,    PREC_NONE        },
     [TOKEN_SUPER]          =  { NULL,      NULL,    PREC_NONE        },
@@ -610,6 +642,23 @@ static void print_statement()
     emit_byte(OP_PRINT);
 }
 
+static void while_statement()
+{
+    int loop_start = current_chunk()->count;
+    consume(TOKEN_LEFT_PAREN, "Expect '(' after while statement");
+    expression();
+    consume(TOKEN_RIGHT_PAREN, "Expect ')' after condition");
+
+    int exit_jump = emit_jump(OP_JUMP_IF_FALSE);
+
+    emit_byte(OP_POP);
+    statement();
+
+    emit_loop(loop_start);
+    patch_jump(exit_jump);
+    emit_byte(OP_POP);
+}
+
 static void synchronize()
 {
     parser.panic_mode = false;
@@ -660,6 +709,10 @@ static void statement()
     {
         if_statement();
     }
+    else if (match(TOKEN_WHILE))
+    {
+        while_statement();
+    }
     else if (match(TOKEN_LEFT_BRACE))
     {
         begin_scope();

src/debug.c

@@ -76,6 +76,8 @@ int disassemble_instruction(Chunk* chunk, int offset)
         return jump_instruction("OP_JUMP", 1, chunk, offset);
     case OP_JUMP_IF_FALSE:
         return jump_instruction("OP_JUMP_IF_FALSE", 1, chunk, offset);
+    case OP_LOOP:
+        return jump_instruction("OP_JUMP_IF_FALSE", -1, chunk, offset);
     case OP_RETURN:
         return simple_instruction("OP_RETURN", offset);
     default:
@@ -100,7 +102,7 @@ static int byte_instruction(const char* name, Chunk* chunk, int offset)
 static int jump_instruction(const char* name, int sign, Chunk* chunk,
                             int offset)
 {
-    u16 jump = (u16)(chunk->code[offset + 1] << 8);
+    u16 jump = (u16)(chunk->code[offset + 1] << 8);  // n << 8 -> n * 2^8
     jump |= chunk->code[offset];
     printf("%-16s %4d -> %d\n", name, offset, offset + 3 + sign * jump);
     return offset + 3;
@@ -141,7 +143,6 @@ static const char* token_type_to_string(TokenType type)
         return "SLASH";
     case TOKEN_STAR:
         return "STAR";
-
     case TOKEN_BANG:
         return "BANG";
     case TOKEN_BANG_EQUAL:
@@ -158,14 +159,12 @@ static const char* token_type_to_string(TokenType type)
         return "LESS";
     case TOKEN_LESS_EQUAL:
         return "LESS_EQUAL";
-
     case TOKEN_IDENTIFIER:
         return "IDENTIFIER";
     case TOKEN_STRING:
         return "STRING";
     case TOKEN_NUMBER:
         return "NUMBER";
-
     case TOKEN_AND:
         return "AND";
     case TOKEN_CLASS:
@@ -200,7 +199,6 @@ static const char* token_type_to_string(TokenType type)
         return "VAL";
     case TOKEN_WHILE:
         return "WHILE";
-
     case TOKEN_ERROR:
         return "ERROR";
     case TOKEN_EOF:

src/vm.c

@@ -251,6 +251,12 @@ static InterpretResult run()
                 vm.ip += offset;
             break;
         }
+        case OP_LOOP:
+        {
+            u16 offset = READ_SHORT();
+            vm.ip -= offset;
+            break;
+        }
         case OP_RETURN:
             return INTERPRET_OK;
         }