Add VM Stack, OP_NEGATE

Author: vinayakdsci

Makefile

@@ -1,6 +1,6 @@
-CC = gcc-12
+CC = clang
 
-CFLAGS = -g -Wall -Wextra
+CFLAGS = -g -Wall
 
 TARGET = cpplox
 
@@ -10,5 +10,10 @@ $(TARGET):
 	$(CC) $(CFLAGS) -o $(TARGET).out src/*.c
 
 clean:
-	$(RM) -f *.out .DS_Store
+	$(RM) -f .DS_Store
 	$(RM) -rf *.dSYM/ 
+veryclean:
+	$(RM) -f *.out
+	$(RM) -f .DS_Store
+	$(RM) -rf *.dSYM/ 
+	

README.md

@@ -1,2 +1,7 @@
 # cpplox
 Lox Language implementation in C, code for the bytecode virtual machine
+
+## (TODO)
+
+*Mon 2023-03-06 23:29+0530*
+1. Implement a run-length encoding algorithm for line checking.

src/chunk.c

@@ -1,7 +1,9 @@
 #include <stdlib.h>
 #include "chunk.h"
 #include "memory.h"
+/* #include "value.h" */
 /* #include <stdio.h> */
+
 void initChunk(Chunk* chunk) {
     //Initialise chunk
     chunk->count = 0;

src/chunk.h

@@ -2,13 +2,14 @@
 #ifndef clox_chunk_h
 #define clox_chunk_h
 
-
 #include "common.h"
 #include "value.h"
+
 //Define opcode -> operation code
 //return the kind of opertion that the interpeter is dealing with -> add, subtract etc.
 typedef enum {
     OP_RETURN,
+    OP_NEGATE,
     OP_CONSTANT
 } OpCode;
 

src/common.h

@@ -4,5 +4,16 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+
+#ifdef DEBUG_TRACE_EXECUTION
+    printf("       ");
+    for (Val *slot = vm.stack; slot < vm.stack_top; slot++) {
+        printf("{ ");
+        print_val(*slot);
+        printf(" }");
+    }
+    printf("\n");
+    disassembleInstruction(vm.chunk, (int)(vm.ip - vm.chunk->code));
 //Use bool, size_t, uint8_t
 #endif
+#endif

src/debug.c

@@ -41,6 +41,8 @@ int disassembleInstruction(Chunk* chunk, int offset) {
             return simpleInstruction("OP_RETURN", offset);
         case OP_CONSTANT:
             return const_instruction("OP_CONSTANT", chunk, offset);
+        case OP_NEGATE:
+            return simpleInstruction("OP_NEGATE", offset);
         default:
             printf("Unknown opcode %d\n", instruction);
             return offset + 1;

src/debug.h

@@ -3,7 +3,8 @@
 
 #include "chunk.h"
 
-void disassembleChunk(Chunk* chunk, const char* name);
-int disassembleInstruction(Chunk* chunk, int offset);
+
+void disassembleChunk(Chunk *chunk, const char* name);
+int disassembleInstruction(Chunk *chunk, int offset);
 
 #endif

src/main.c

@@ -1,15 +1,26 @@
 #include "common.h"
 #include "chunk.h"
 #include "debug.h"
-int main (int argc, char *argv[]) {
+#include "vm.h"
+
+
+int main () {
+    init_vm();
     Chunk chunk;
     initChunk(&chunk);
     writeChunk(&chunk, OP_CONSTANT, 123);
+
     int constant = add_const(&chunk, 1.5);
+
     writeChunk(&chunk, constant, 123);
+    writeChunk(&chunk, OP_NEGATE, 123);
     writeChunk(&chunk, OP_RETURN, 123);
+    
     //Dissasemble the chunk!
     disassembleChunk(&chunk, "test chunk");
+
+    interpret(&chunk);
+    free_vm();
     freeChunk(&chunk);
     return 0;
 }

src/memory.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "memory.h"
 
-void* reallocate(void* pointer, size_t  oldSize, size_t newSize){
+void* reallocate(void* pointer, size_t oldSize, size_t newSize){
     if(newSize == 0) {
         free(pointer);
         return NULL;

src/vm.c

@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include "common.h"
+#include "debug.h"
+#include "vm.h"
+
+/* Global decl */
+VM vm;
+
+static void reset_stack() {
+    vm.stack_top = vm.stack;    //set stack_top to the beginning of the array to indecate it is empty
+}
+
+void push(Val value) {
+    *vm.stack_top = value;
+    vm.stack_top++;
+}
+
+Val pop() {
+    vm.stack_top--;
+    return *vm.stack_top;
+}
+
+/*
+ *The Run function is the core of the VM, the heart that pumps blood to the body
+ */
+
+void init_vm() {
+    reset_stack();
+}
+
+
+void free_vm() {
+
+}
+
+
+static interpreted_result run (void) {
+#define READ_BYTE() (*vm.ip++)
+#define READ_CONSTANT() (vm.chunk->constants.values[READ_BYTE()])
+
+    for (;;) {
+        uint8_t instruction;
+        switch(instruction = READ_BYTE()) {
+            case OP_CONSTANT: {
+                                  Val constant = READ_CONSTANT();
+                                  print_val(constant);
+                                  printf("\n");
+                                  push(constant);
+                                  break;
+                              }
+
+            case OP_NEGATE:    push(-pop()); break;
+
+            case OP_RETURN: { 
+                                print_val(pop()); 
+                                printf("\n");
+                                return INTERPRET_OK; 
+                            }
+        }
+    }
+#undef READ_BYTE
+#undef READ_CONSTANT
+}
+
+
+interpreted_result interpret(Chunk *chunk) {
+    vm.chunk = chunk;
+    vm.ip = vm.chunk->code;
+    return run();
+}
+

src/vm.h

@@ -0,0 +1,29 @@
+#ifndef clox_vm_h
+#define clox_vm_h
+
+#include "chunk.h"
+#include "value.h"
+
+#define STACK_MAX 256   //Are 8 bytes enough?
+
+typedef struct {
+    Chunk *chunk;
+    uint8_t *ip;
+    Val stack[STACK_MAX]; //My stack based proglang!
+    Val *stack_top;
+} VM;
+
+typedef enum {
+    INTERPRET_OK,
+    INTERPRET_COMPILE_ERROR,
+    INTERPRET_RUNTIME_ERROR
+} interpreted_result;
+
+void init_vm();
+void free_vm();
+interpreted_result interpret(Chunk *chunk);
+
+void push(Val value);
+Val pop();
+
+#endif