DiamondNether90/cground
1
0
Fork 0
forked from ground/cground
Code Pull Requests Activity

Merge pull request 'Add compiler' (#14) from unstable into master

Browse Source 
Reviewed-on: ground/cground#14
This commit is contained in:
Maxwell
2026-01-21 15:53:20 +11:00
parent 32d6a029dd 07474d4317
commit 063e85d24a
10 changed files with 724 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
README.md
View File

@@ -98,3 +98,25 @@ Commands:
* eval (code): Runs Ground code in the current scope * eval (code): Runs Ground code in the current scope
* help: Shows a help message * help: Shows a help message
## Compiler
CGround now includes an experimental Ground -> x86_64 Linux ASM compiler. You can try it by adding the `-c` flag when running Ground. This will print the generated ASM to the console.
At present only the `int` data type is supported.
Supported instructions so far:
* set
* add
* subtract
* multiply
* equal
* inequal
* greater
* lesser
* jump
* if
* @ (label creation)
* print
* println
* end

514
src/compiler.c Normal file
View File

@@ -0,0 +1,514 @@
#include "compiler.h"
#include "interpreter.h"
#include "types.h"
#include "include/estr.h"
#include <stdint.h>
#include <inttypes.h>
VariableTable createVariableTable() {
VariableTable vt;
vt.capacity = 16;
vt.count = 0;
vt.vars = malloc(sizeof(VariableInfo) * vt.capacity);
return vt;
}
void addVtVariable(VariableTable* vt, const char* name) {
// check if it already exists
for (size_t i = 0; i < vt->count; i++) {
if (strcmp(vt->vars[i].name, name) == 0) {
return;
}
}
// increase capacity
if (vt->count >= vt->capacity) {
vt->capacity *= 2;
vt->vars = realloc(vt->vars, sizeof(VariableInfo) * vt->capacity);
}
// add the variable
strcpy(vt->vars[vt->count].name, name);
vt->vars[vt->count].offset = vt->count * 8;
vt->count++;
}
int getVariablePos(VariableTable* vt, const char* name) {
for (size_t i = 0; i < vt->count; i++) {
if (strcmp(vt->vars[i].name, name) == 0) {
return vt->vars[i].offset;
}
}
return -1;
}
char* processValueString(GroundArg arg) {
if (arg.type == VALREF) {
char* buf = malloc(sizeof(char) * 260);
snprintf(buf, sizeof(char) * 260, "[%s]", arg.value.refName);
return buf;
}
if (arg.type == VALUE) {
if (arg.value.value.type != INT) {
printf("Only int is supported right now\n");
exit(1);
}
char* buf = malloc(sizeof(char) * 64);
snprintf(buf, sizeof(char) * 260, "%" PRId64, arg.value.value.data.intVal);
return buf;
}
return NULL;
}
char* compileGroundProgram(GroundProgram* program) {
Estr start = CREATE_ESTR("global _start\nsection .text\n_start:\n");
Estr data = CREATE_ESTR("section .bss\n");
Estr helpers = CREATE_ESTR("");
APPEND_ESTR(helpers, "\n; Helper: Print integer in rax\n");
APPEND_ESTR(helpers, "print_int:\n");
APPEND_ESTR(helpers, " push rbp\n");
APPEND_ESTR(helpers, " mov rbp, rsp\n");
APPEND_ESTR(helpers, " sub rsp, 32 ; Allocate buffer on stack\n");
APPEND_ESTR(helpers, " mov rdi, rsp ; RDI = buffer pointer\n");
APPEND_ESTR(helpers, " add rdi, 31 ; Point to end of buffer\n");
APPEND_ESTR(helpers, " mov byte [rdi], 0 ; Null terminator\n");
APPEND_ESTR(helpers, " dec rdi\n");
APPEND_ESTR(helpers, " mov rbx, 10 ; Divisor\n");
APPEND_ESTR(helpers, " test rax, rax\n");
APPEND_ESTR(helpers, " jns .positive\n");
APPEND_ESTR(helpers, " neg rax ; Make positive\n");
APPEND_ESTR(helpers, " push rax\n");
APPEND_ESTR(helpers, " mov byte [rdi], '-'\n");
APPEND_ESTR(helpers, " dec rdi\n");
APPEND_ESTR(helpers, " pop rax\n");
APPEND_ESTR(helpers, ".positive:\n");
APPEND_ESTR(helpers, " xor rcx, rcx ; Digit counter\n");
APPEND_ESTR(helpers, ".convert_loop:\n");
APPEND_ESTR(helpers, " xor rdx, rdx\n");
APPEND_ESTR(helpers, " div rbx ; rax = rax/10, rdx = remainder\n");
APPEND_ESTR(helpers, " add dl, '0' ; Convert to ASCII\n");
APPEND_ESTR(helpers, " mov [rdi], dl\n");
APPEND_ESTR(helpers, " dec rdi\n");
APPEND_ESTR(helpers, " inc rcx\n");
APPEND_ESTR(helpers, " test rax, rax\n");
APPEND_ESTR(helpers, " jnz .convert_loop\n");
APPEND_ESTR(helpers, " inc rdi ; Point back to first digit\n");
APPEND_ESTR(helpers, " ; Now print the string\n");
APPEND_ESTR(helpers, " mov rax, 1 ; sys_write\n");
APPEND_ESTR(helpers, " mov rsi, rdi ; Buffer\n");
APPEND_ESTR(helpers, " mov rdx, rcx ; Length\n");
APPEND_ESTR(helpers, " mov rdi, 1 ; stdout\n");
APPEND_ESTR(helpers, " syscall\n");
APPEND_ESTR(helpers, " mov rsp, rbp\n");
APPEND_ESTR(helpers, " pop rbp\n");
APPEND_ESTR(helpers, " ret\n");
APPEND_ESTR(helpers, "\n; Helper: Print string at address in rax, length in rbx\n");
APPEND_ESTR(helpers, "print_string:\n");
APPEND_ESTR(helpers, " push rax\n");
APPEND_ESTR(helpers, " push rbx\n");
APPEND_ESTR(helpers, " mov rdi, 1 ; stdout\n");
APPEND_ESTR(helpers, " mov rsi, rax ; String address\n");
APPEND_ESTR(helpers, " mov rdx, rbx ; Length\n");
APPEND_ESTR(helpers, " mov rax, 1 ; sys_write\n");
APPEND_ESTR(helpers, " syscall\n");
APPEND_ESTR(helpers, " pop rbx\n");
APPEND_ESTR(helpers, " pop rax\n");
APPEND_ESTR(helpers, " ret\n");
VariableTable varTable = createVariableTable();
// Allocate a spot for all direct references
for (size_t i = 0; i < program->size; i++) {
GroundInstruction gi = program->instructions[i];
for (size_t j = 0; j < gi.args.length; j++) {
if (gi.args.args[j].type == DIRREF) {
addVtVariable(&varTable, gi.args.args[j].value.refName);
}
}
}
// Create data section
for (size_t i = 0; i < varTable.count; i++) {
if (strcmp(varTable.vars[i].name, "") == 0) {
continue;
}
APPEND_ESTR(data, " ");
APPEND_ESTR(data, varTable.vars[i].name);
APPEND_ESTR(data, " resq 1\n");
}
// Generate assembly
for (size_t i = 0; i < program->size; i++) {
GroundInstruction gi = program->instructions[i];
switch (gi.type) {
case CREATELABEL: {
APPEND_ESTR(start, gi.args.args[0].value.refName);
APPEND_ESTR(start, ":\n");
break;
}
case SET: {
if (gi.args.length < 2) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args", &gi, i);
}
if (gi.args.length > 2) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args", &gi, i);
}
if (gi.args.args[0].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value for arg 2", &gi, i);
}
char* varName= gi.args.args[0].value.refName;
APPEND_ESTR(start, " ; set\n")
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case JUMP: {
if (gi.args.length < 1) {
runtimeError(TOO_FEW_ARGS, "Expecting 1 arg", &gi, i);
}
if (gi.args.length > 1) {
runtimeError(TOO_MANY_ARGS, "Expecting 1 arg", &gi, i);
}
if (gi.args.args[0].type != LINEREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a LineRef", &gi, i);
}
char* labelName = gi.args.args[0].value.refName;
APPEND_ESTR(start, " ; jump\n");
APPEND_ESTR(start, " jmp ");
APPEND_ESTR(start, labelName);
APPEND_ESTR(start, "\n");
break;
}
case IF: {
if (gi.args.length < 2) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args", &gi, i);
}
if (gi.args.length > 2) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int (for now) for arg 1", &gi, i);
}
if (gi.args.args[1].type != LINEREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a LineRef", &gi, i);
}
char* labelName = gi.args.args[1].value.refName;
APPEND_ESTR(start, " ; if\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " test rax, rax\n");
APPEND_ESTR(start, " jnz ");
APPEND_ESTR(start, labelName);
APPEND_ESTR(start, "\n");
break;
}
case ADD: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for add instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for add instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; add\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " add rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case SUBTRACT: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for subtract instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for subtract instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; subtract\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " sub rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case MULTIPLY: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for multiply instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for multiply instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; multiply\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " imul rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case EQUAL: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for equal instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for equal instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; equal\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " cmp rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " sete al\n");
APPEND_ESTR(start, " movzx rax, al\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case INEQUAL: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for inequal instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for inequal instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; inequal\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " cmp rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " setne al\n");
APPEND_ESTR(start, " movzx rax, al\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case GREATER: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for greater instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for greater instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; greater\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " cmp rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " setg al\n");
APPEND_ESTR(start, " movzx rax, al\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case LESSER: {
if (gi.args.length < 3) {
runtimeError(TOO_FEW_ARGS, "Expecting 2 args for lesser instruction", &gi, i);
}
if (gi.args.length > 3) {
runtimeError(TOO_MANY_ARGS, "Expecting 2 args for lesser instruction", &gi, i);
}
if (gi.args.args[0].type != VALUE && gi.args.args[0].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 1", &gi, i);
}
if (gi.args.args[1].type != VALUE && gi.args.args[1].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting an Int for arg 2", &gi, i);
}
if (gi.args.args[2].type != DIRREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a DirectRef for arg 3", &gi, i);
}
char* varName= gi.args.args[2].value.refName;
APPEND_ESTR(start, " ; lesser\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " cmp rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[1]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " setl al\n");
APPEND_ESTR(start, " movzx rax, al\n");
APPEND_ESTR(start, " mov [");
APPEND_ESTR(start, varName);
APPEND_ESTR(start, "], rax\n");
break;
}
case PRINT:
case PRINTLN: {
if (gi.args.length < 1) {
runtimeError(TOO_FEW_ARGS, "Expecting 1 or more args", &gi, i);
}
for (size_t j = 0; j < gi.args.length; j++) {
if (gi.args.args[j].type != VALUE && gi.args.args[j].type != VALREF) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", &gi, i);
}
if (j > 0) {
// Print space between arguments
APPEND_ESTR(start, " ; print space\n");
APPEND_ESTR(start, " mov rax, 1\n");
APPEND_ESTR(start, " mov rdi, 1\n");
APPEND_ESTR(start, " lea rsi, [rel space_char]\n");
APPEND_ESTR(start, " mov rdx, 1\n");
APPEND_ESTR(start, " syscall\n");
}
APPEND_ESTR(start, " ; print int\n");
APPEND_ESTR(start, " mov rax, ");
APPEND_ESTR(start, processValueString(gi.args.args[j]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " call print_int\n");
}
if (gi.type == PRINTLN) {
APPEND_ESTR(start, " ; print newline\n");
APPEND_ESTR(start, " mov rax, 1\n");
APPEND_ESTR(start, " mov rdi, 1\n");
APPEND_ESTR(start, " lea rsi, [rel newline_char]\n");
APPEND_ESTR(start, " mov rdx, 1\n");
APPEND_ESTR(start, " syscall\n");
}
break;
}
case END: {
if (gi.args.length < 1) {
runtimeError(TOO_FEW_ARGS, "Expecting 1 arg for end instruction", &gi, i);
}
if (gi.args.length > 1) {
runtimeError(TOO_MANY_ARGS, "Expecting 1 arg for end instruction", &gi, i);
}
APPEND_ESTR(start, " ; end\n");
APPEND_ESTR(start, " mov rax, 60\n");
APPEND_ESTR(start, " mov rdi, ");
APPEND_ESTR(start, processValueString(gi.args.args[0]));
APPEND_ESTR(start, "\n");
APPEND_ESTR(start, " syscall\n");
break;
}
case DROP: {
// Drop does nothing in ground->asm as we use the stack
break;
}
default: {
printf("no\n");
exit(1);
}
}
}
Estr complete = CREATE_ESTR("");
APPEND_ESTR(complete, start.str);
APPEND_ESTR(complete, " ; End of program\n mov rax, 60\n mov rdi, 0\n syscall\n");
APPEND_ESTR(complete, helpers.str);
APPEND_ESTR(complete, "\nsection .rodata\n");
APPEND_ESTR(complete, "newline_char: db 10\n");
APPEND_ESTR(complete, "space_char: db 32\n");
APPEND_ESTR(complete, data.str)
return complete.str;
}

18
src/compiler.h Normal file
View File

@@ -0,0 +1,18 @@
#include "types.h"
#include "interpreter.h"
char* compileGroundProgram(GroundProgram* program);
[[noreturn]] void runtimeError(GroundRuntimeError error, char* what, GroundInstruction* where, int whereLine);
typedef struct VariableInfo {
char name[256];
int offset;
} VariableInfo;
typedef struct VariableTable {
VariableInfo* vars;
size_t count;
size_t capacity;
} VariableTable;

52
src/include/estr.h Normal file
View File

@@ -0,0 +1,52 @@
#include <stddef.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifndef ESTR_H
#define ESTR_H
/*
estr.h - Easy string manipulation
This library has macros to allow easier manipulation of strings. No longer shall
you have to malloc and realloc away to keep adding to your strings.
Usage:
Estr myString = CREATE_ESTR("my awesome string");
APPEND_ESTR(myString, " is so cool");
printf("%s\n", myString.str);
*/
#define CREATE_ESTR(instr) \
(Estr) { \
.str = instr,\
.size = strlen(instr),\
.shouldBeFreed = 0, \
.destroyed = 0 \
}
#define APPEND_ESTR(estr, instr) { \
estr.size = estr.size + strlen(instr); \
char* tmp_ptr = malloc(estr.size + 1); \
if (tmp_ptr == NULL) printf("WARNING: Could not realloc estr " #estr "\n"); \
else { \
snprintf(tmp_ptr, estr.size + 1, "%s%s", estr.str, instr); \
if (estr.shouldBeFreed > 0) free(estr.str); \
estr.shouldBeFreed = 1; \
estr.str = tmp_ptr; \
} \
}
#define DESTROY_ESTR(estr) if (estr.shouldBeFreed > 0 && estr.destroyed < 1) free(estr.str);
typedef struct Estr {
char* str;
size_t size;
int8_t shouldBeFreed;
int8_t destroyed;
} Estr;
#endif // ESTR_H

25
src/interface.c
View File

@@ -1,4 +1,3 @@
#include "lexer.h"
#include "parser.h" #include "parser.h"
#include "interpreter.h" #include "interpreter.h"
#include "types.h" #include "types.h"
@@ -75,9 +74,9 @@ GroundValue groundCreateValue(GroundValueType type, ...) {
case STRUCTVAL: { case STRUCTVAL: {
GroundValue gv; GroundValue gv;
gv.type = STRUCTVAL; gv.type = STRUCTVAL;
gv.data.structVal = va_arg(args, GroundStruct*); gv.data.structVal = malloc(sizeof(GroundStruct));
*gv.data.structVal = va_arg(args, GroundStruct);
return gv; return gv;
break;
} }
case NONE: { case NONE: {
return createNoneGroundValue(); return createNoneGroundValue();
@@ -88,11 +87,6 @@ GroundValue groundCreateValue(GroundValueType type, ...) {
// FIXME // FIXME
break; break;
} }
/*
default: {
return createNoneGroundValue();
}
*/
} }
return createNoneGroundValue(); return createNoneGroundValue();
@@ -114,3 +108,18 @@ void groundPrintProgram(GroundProgram* program) {
GroundProgram groundParseFile(const char* code) { GroundProgram groundParseFile(const char* code) {
return parseFile(code); return parseFile(code);
} }
GroundStruct groundCreateStruct() {
GroundStruct gs;
gs.size = 0;
gs.fields = malloc(sizeof(GroundStructField));
return gs;
}
void groundAddValueToScope(GroundScope* gs, const char* name, GroundValue value) {
addVariable(gs->variables, name, value);
}
void groundAddFieldToStruct(GroundStruct* gstruct, char* name, GroundValue field) {
addFieldToStruct(gstruct, name, field);
}

10
src/interpreter.c
View File

@@ -352,7 +352,7 @@ GroundStruct parseStruct(GroundProgram* in, GroundScope* scope, size_t errorOffs
GroundValue gv; GroundValue gv;
switch (stringToValueType(in->instructions[i].args.args[0].value.refName)) { switch (stringToValueType(in->instructions[i].args.args[1].value.refName)) {
case INT: { case INT: {
gv = createIntGroundValue(0); gv = createIntGroundValue(0);
break; break;
@@ -399,6 +399,7 @@ GroundStruct parseStruct(GroundProgram* in, GroundScope* scope, size_t errorOffs
gv.type = CUSTOM; gv.type = CUSTOM;
gv.data.customVal = malloc(sizeof(GroundObject)); gv.data.customVal = malloc(sizeof(GroundObject));
*gv.data.customVal = createObject(*gstruct); *gv.data.customVal = createObject(*gstruct);
gv.customType = gstruct;
break; break;
} }
case NONE: { case NONE: {
@@ -1782,7 +1783,8 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
if (in->args.args[i + 1].type != VALUE) { if (in->args.args[i + 1].type != VALUE) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction); runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction);
} }
if (in->args.args[i + 1].value.value.type != function->args[i].type) { //if (in->args.args[i + 1].value.value.type != function->args[i].type) {
if (!checkFnTypes(&in->args.args[i + 1].value.value, &function->args[i])) {
runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction); runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
} }
appendToList(&argsList, in->args.args[i + 1].value.value); appendToList(&argsList, in->args.args[i + 1].value.value);
@@ -1810,7 +1812,8 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
if (in->args.args[i + 1].type != VALUE) { if (in->args.args[i + 1].type != VALUE) {
runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction); runtimeError(ARG_TYPE_MISMATCH, "Expecting a Value", in, currentInstruction);
} }
if (in->args.args[i + 1].value.value.type != function->args[i].type) { //if (in->args.args[i + 1].value.value.type != function->args[i].type) {
if (!checkFnTypes(&in->args.args[i + 1].value.value, &function->args[i])) {
runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction); runtimeError(ARG_TYPE_MISMATCH, "Mismatched function argument types", in, currentInstruction);
} }
addVariable(newScope.variables, function->args[i].name, in->args.args[i + 1].value.value); addVariable(newScope.variables, function->args[i].name, in->args.args[i + 1].value.value);
@@ -2008,6 +2011,7 @@ GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scop
gv.type = CUSTOM; gv.type = CUSTOM;
gv.data.customVal = malloc(sizeof(GroundObject)); gv.data.customVal = malloc(sizeof(GroundObject));
*gv.data.customVal = createObject(*gstruct); *gv.data.customVal = createObject(*gstruct);
gv.customType = gstruct;
break; break;
} }
case NONE: { case NONE: {

1
src/interpreter.h
View File

@@ -42,6 +42,7 @@ GroundFunction* parseFunction(GroundProgram* in, size_t errorOffset);
GroundValue interpretGroundProgram(GroundProgram* in, GroundScope* inScope); GroundValue interpretGroundProgram(GroundProgram* in, GroundScope* inScope);
GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scope); GroundValue interpretGroundInstruction(GroundInstruction inst, GroundScope* scope);
void addVariable(GroundVariable **head, const char *id, GroundValue data);

46
src/main.c
View File

@@ -1,5 +1,6 @@
#include "parser.h" #include "parser.h"
#include "interpreter.h" #include "interpreter.h"
#include "compiler.h"
#include <stdio.h> #include <stdio.h>
char* getFileContents(const char* filename) { char* getFileContents(const char* filename) {
@@ -39,6 +40,7 @@ char* getFileContents(const char* filename) {
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
/*
if (argc < 2) { if (argc < 2) {
printf("Usage: ground [file]\n"); printf("Usage: ground [file]\n");
exit(1); exit(1);
@@ -46,5 +48,49 @@ int main(int argc, char** argv) {
char* file = getFileContents(argv[1]); char* file = getFileContents(argv[1]);
GroundProgram program = parseFile(file); GroundProgram program = parseFile(file);
free(file); free(file);
char* compiled = compileGroundProgram(&program);
printf("%s\n", compiled);
interpretGroundProgram(&program, NULL);
*/
if (argc < 2) {
printf("Usage: %s <file> [-c] [--compile] [-h] [--help]\n", argv[0]);
exit(1);
}
bool compile = false;
char* fileName = NULL;
for (int i = 1; i < argc; i++) {
if (strcmp("--compile", argv[i]) == 0 || strcmp("-c", argv[i]) == 0) {
compile = true;
}
else if (strcmp("--help", argv[i]) == 0 || strcmp("-h", argv[i]) == 0) {
printf("GroundVM help\n");
printf("Usage: %s <file> [-c] [--compile] [-h] [--help]\n", argv[0]);
printf("Options:\n");
printf(" -c or --compile: Outputs Linux x86_64 assembly instead of interpreting (WIP)\n");
printf(" -h or --help: Shows this help message\n");
exit(0);
} else {
fileName = argv[i];
}
}
if (fileName == NULL) {
printf("Usage: %s <file> [-c] [--compile] [-h] [--help]\n", argv[0]);
printf("Error: No file name provided\n");
exit(1);
}
char* file = getFileContents(fileName);
GroundProgram program = parseFile(file);
free(file);
if (compile) {
char* compiled = compileGroundProgram(&program);
printf("%s\n", compiled);
} else {
interpretGroundProgram(&program, NULL); interpretGroundProgram(&program, NULL);
} }
}

40
src/types.c
View File

@@ -585,3 +585,43 @@ GroundError createGroundError(char* what, char* type, GroundInstruction* where,
return ge; return ge;
} }
bool checkFnTypes(GroundValue* left, GroundFunctionArgs* right) {
if (left->type != right->type) {
return false;
}
if (left->type == CUSTOM) {
if (left->customType->size != right->customType->size) {
return false;
}
for (size_t i = 0; i < left->customType->size; i++) {
if (strcmp(left->customType->fields[i].id, right->customType->fields[i].id) != 0) {
return false;
}
if (!checkTypes(&left->customType->fields[i].value, &right->customType->fields[i].value)) {
return false;
}
}
}
return true;
}
bool checkTypes(GroundValue* left, GroundValue* right) {
if (left->type != right->type) {
return false;
}
if (left->type == CUSTOM) {
if (left->customType->size != right->customType->size) {
return false;
}
for (size_t i = 0; i < left->customType->size; i++) {
if (strcmp(left->customType->fields[i].id, right->customType->fields[i].id) != 0) {
return false;
}
if (!checkTypes(&left->customType->fields[i].value, &right->customType->fields[i].value)) {
return false;
}
}
}
return true;
}

7
src/types.h
View File

@@ -62,6 +62,7 @@ typedef struct GroundError {
*/ */
typedef struct GroundValue { typedef struct GroundValue {
GroundValueType type; GroundValueType type;
struct GroundStruct* customType;
union { union {
int64_t intVal; int64_t intVal;
double doubleVal; double doubleVal;
@@ -125,6 +126,7 @@ typedef struct GroundProgram {
*/ */
typedef struct GroundFunctionArgs { typedef struct GroundFunctionArgs {
GroundValueType type; GroundValueType type;
struct GroundStruct* customType;
char* name; char* name;
} GroundFunctionArgs; } GroundFunctionArgs;
@@ -276,6 +278,11 @@ void freeGroundObject(GroundObject* object);
// Creates a GroundError. // Creates a GroundError.
GroundError createGroundError(char* what, char* type, GroundInstruction* where, size_t* line); GroundError createGroundError(char* what, char* type, GroundInstruction* where, size_t* line);
// Compares types of a value and function args.
bool checkFnTypes(GroundValue* left, GroundFunctionArgs* arg);
// Compares types of two values.
bool checkTypes(GroundValue* left, GroundValue* right);
#endif #endif