vm.c

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#include "common.h"
#include "object.h"
#include "memory.h"
#include "vm.h"
#include "compiler.h"
#include "debug.h"
#include "value.h"


/*
 * The virtual machine is a singleton.
 * At first glance, this will make it simpler to implement the language. It
 * would be a more mature idea to operate the vm as a pointer and pass it
 * around to functions. This can be a future improvement.
 */
vm_t vm;

static void reset_stack() {
  vm.stack_top = vm.stack;
}


static void runtime_error(const char* format, ...) {
  // Variadic functions take a varying number of arguments.
  // Thus we will use the variadic flavour of printf called vfprintf
  va_list args;
  va_start(args, format);
  vfprintf(stderr, format, args);
  va_end(args);
  fputs("\n", stderr);

  size_t instruction = vm.ip - vm.chunk->code -1;
  int line = get_line_num(&(vm.chunk->lines), instruction);
  fprintf(stderr, "[line %d] in script\n", line);
  reset_stack();
}


void init_vm() {
  reset_stack();
  vm.objects = NULL;
  init_table(&vm.strings);
}


void free_vm() {
  free_objects();
  free_table(&vm.strings);
}


void push(value_t value) {
  *vm.stack_top = value;
  vm.stack_top++;
}


value_t pop() {
  vm.stack_top--;
  return *vm.stack_top;
}


static value_t peek(int distance) {
  // `distance` is how far down from the top of the stack to look:
  // zero is the top, one is one slot down, etc.
  return vm.stack_top[-1 - distance];
}


static bool is_falsey(value_t value) {
  // Implementation of falseables.
  // `null` and `false` are falseables. Everything else is true.
  return IS_NULL(value) || (IS_BOOL(value) && !AS_BOOL(value));
}


static void concatenate() {
  obj_string_t* b = AS_STRING(pop());
  obj_string_t* a = AS_STRING(pop());

  int length = a->length + b->length;
  char* chars = ALLOCATE(char, length + 1);
  memcpy(chars, a->chars, a->length);
  memcpy(chars + a->length, b->chars, b->length);
  chars[length] = '\0';

  obj_string_t* result = take_string(chars, length);
  push(OBJ_VAL(result));
}


static interpret_result_t run() {
// returns the byte currently pointed by ip and then advances the
// instruction pointer to the next byte.
#define READ_BYTE() (*vm.ip++)
// calls READ_BYTE, treating the result number as an index for the constants
// array. Returns the constant value from the constant pool.
#define READ_CONSTANT() (vm.chunk->constants.values[READ_BYTE()])
// The following macro comes in a do/while block so that it can be used with
// trailing ";" without causing problems even if inside `if` conditionals.
#define BINARY_OP(value_type, op) \
    do { \
      if (!IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1))) { \
        runtime_error("Operands must be numbers."); \
        return INTERPRET_RUNTIME_ERROR; \
      } \
      double b = AS_NUMBER(pop()); \
      double a = AS_NUMBER(pop()); \
      push(value_type(a op b)); \
    } while (false)

  for (;;) {
#ifdef DEBUG_TRACE_EXECUTION
    printf("        ");
    for (value_t* slot = vm.stack; slot < vm.stack_top; slot++) {
      printf("[ ");
      print_value(*slot);
      printf(" ]");
    }
    printf("\n");
    // pointer math to convert ip back to a relative offset from the beginning
    // of the bytecode.
    disassemble_instruction(vm.chunk, (int)(vm.ip - vm.chunk->code));
#endif
    uint8_t instruction;
    switch (instruction = READ_BYTE()) {
      case OP_CONSTANT: {
        value_t constant = READ_CONSTANT();
        push(constant);
        break;
      };
      case OP_TRUE: {
        push(BOOL_VAL(true));
        break;
      }
      case OP_FALSE: {
        push(BOOL_VAL(false));
        break;
      }
      case OP_EQUAL: {
        value_t b = pop();
        value_t a = pop();
        push(BOOL_VAL(values_equal(a, b)));
        break;
      }
      case OP_GREATER: {
        BINARY_OP(BOOL_VAL, >);
        break;
      }
      case OP_LESS: {
        BINARY_OP(BOOL_VAL, <);
        break;
      }
      case OP_NULL: {
        push(NULL_VAL);
        break;
      }
      case OP_NEGATE:
        if (!IS_NUMBER(peek(0))) {
          runtime_error("Operant must be a number.");
          return INTERPRET_RUNTIME_ERROR;
        }
        push(NUMBER_VAL(-AS_NUMBER(pop())));
        break;
      case OP_ADD: {
        if (IS_STRING(peek(0)) && IS_STRING(peek(1))) {
          concatenate();
        } else if (IS_NUMBER(peek(0)) && IS_NUMBER(peek(1))) {
          double b = AS_NUMBER(pop());
          double a = AS_NUMBER(pop());
          push(NUMBER_VAL(a + b));
        } else {
          runtime_error(
              "Operands must be two numbers or two strings."
          );
          return INTERPRET_RUNTIME_ERROR;
        }
        break;
      }
      case OP_SUBTRACT: {
        BINARY_OP(NUMBER_VAL, -);
        break;
      }
      case OP_MULTIPLY: {
        BINARY_OP(NUMBER_VAL, *);
        break;
      }
      case OP_DIVIDE: {
        BINARY_OP(NUMBER_VAL, /);
        break;
      }
      case OP_NOT: {
        push(BOOL_VAL(is_falsey(pop())));
        break;
      }
      case OP_RETURN: {
        print_value(pop());
        printf("\n");
        return INTERPRET_OK;
      }
    }
  }
#undef BINARY_OP
#undef READ_BYTE
#undef READ_CONSTANT
}


interpret_result_t interpret(const char* source) {
  chunk_t chunk;
  init_chunk(&chunk);

  if (!compile(source, &chunk)) {
    free_chunk(&chunk);
    return INTERPRET_COMPILE_ERROR;
  }

  vm.chunk = &chunk;
  vm.ip = vm.chunk->code;

  interpret_result_t result = run();

  free_chunk(&chunk);
  return result;
}