creeperlv/Sagittarius
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented using Antigravity and it actually works!

Browse Source
This commit is contained in:
Creeper Lv
2026-05-25 15:21:34 +10:00
parent 2365e0a329
commit bcff8b3859
7 changed files with 1858 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/VM/Sagittarius.c
+138 -9
View File
@@ -1,24 +1,153 @@
#include "../../Headers/Sagittarius.h"
#include "../../Headers/SagittariusInternal.h"
#include <stdlib.h>
#include <string.h>
SAGITTARIUS_API SagittariusVM* sagittarius_vm_new(uint64_t memory_size){
SagittariusVM* vm=malloc(sizeof(SagittariusVM));
vm->Memory.data=malloc(memory_size);
vm->Memory.size=memory_size;
SagittariusVM* vm = malloc(sizeof(SagittariusVM));
if (!vm) return NULL;
vm->Memory.data = malloc(memory_size);
vm->Memory.size = memory_size;
// Clear registers
memset(vm->core.reg.head, 0, sizeof(vm->core.reg.head));
// Link core
vm->core.memory = &vm->Memory;
vm->core.vm = vm;
vm->core.pc = 0;
// Initialize syscalls
vm->SagittariusSyscallEntries = NULL;
vm->SagittariusSyscallCount = 0;
vm->SagittariusSyscallCapacity = 0;
vm->panic_handler = NULL;
return vm;
}
SAGITTARIUS_API void sagittarius_vm_free(SagittariusVM* vm){
free(vm);
if (vm) {
if (vm->Memory.data) free(vm->Memory.data);
if (vm->SagittariusSyscallEntries) free(vm->SagittariusSyscallEntries);
free(vm);
}
}
SAGITTARIUS_API void sagittarius_step(SagittariusVM* vm){
SAGITTARIUS_API void sagittarius_register_syscall(SagittariusVM *vm, uint64_t id, SagittariusSyscall syscall) {
if (!vm) return;
if (vm->SagittariusSyscallCount >= vm->SagittariusSyscallCapacity) {
vm->SagittariusSyscallCapacity = vm->SagittariusSyscallCapacity == 0 ? 4 : vm->SagittariusSyscallCapacity * 2;
vm->SagittariusSyscallEntries = realloc(vm->SagittariusSyscallEntries, vm->SagittariusSyscallCapacity * sizeof(SagittariusSyscallEntry));
}
vm->SagittariusSyscallEntries[vm->SagittariusSyscallCount].id = id;
vm->SagittariusSyscallEntries[vm->SagittariusSyscallCount].syscall = syscall;
vm->SagittariusSyscallCount++;
}
SAGITTARIUS_API void sagittarius_mem_resize(SagittariusVM* vm, uint64_t new_size){
vm->Memory.data=realloc(vm->Memory.data,new_size);
vm->Memory.size=new_size;
if (vm) {
vm->Memory.data = realloc(vm->Memory.data, new_size);
vm->Memory.size = new_size;
}
}
SAGITTARIUS_API uint64_t sagittarius_mem_getsize(SagittariusVM* vm){
return vm->Memory.size;
return vm ? vm->Memory.size : 0;
}
SAGITTARIUS_API void sagittarius_load_program_to_mem(SagittariusVM *vm, SagittariusProgram *program, uint64_t offset) {
if (!vm || !program) return;
uint64_t required_size = offset + program->instCount * 8 + program->data_size;
if (required_size > vm->Memory.size) {
sagittarius_mem_resize(vm, required_size);
}
if (program->instCount > 0) {
memcpy(vm->Memory.data + offset, program->instructions, program->instCount * 8);
}
if (program->data_size > 0) {
memcpy(vm->Memory.data + offset + program->instCount * 8, program->data, program->data_size);
}
vm->core.pc = offset;
}
SAGITTARIUS_API SagittariusProgram *sagittarius_load_program_from_byte_array(uint8_t *data, uint64_t size) {
if (size < 28) return NULL;
if (memcmp(data, SAGITTARUIS_PROGRAM_HEAD, 7) != 0) return NULL;
uint32_t version;
memcpy(&version, data + 8, 4);
if (version != SAGITTARIUS_PROGRAM_FORMAT_VERSION) return NULL;
uint64_t instCount;
memcpy(&instCount, data + 12, 8);
uint64_t data_size;
memcpy(&data_size, data + 20, 8);
if (size < 28 + instCount * 8 + data_size) return NULL;
SagittariusProgram *prog = malloc(sizeof(SagittariusProgram));
prog->instCount = instCount;
if (instCount > 0) {
prog->instructions = malloc(instCount * sizeof(SagittariusInst));
memcpy(prog->instructions, data + 28, instCount * 8);
} else {
prog->instructions = NULL;
}
prog->data_size = data_size;
if (data_size > 0) {
prog->data = malloc(data_size);
memcpy(prog->data, data + 28 + instCount * 8, data_size);
} else {
prog->data = NULL;
}
return prog;
}
SAGITTARIUS_API void sagittarius_step(SagittariusVM *vm) {
if (!vm) return;
if (vm->core.pc >= vm->Memory.size) {
if (vm->panic_handler) vm->panic_handler(&vm->core, Sagittarius_Msg_OOB, "PC out of bounds");
return;
}
SagittariusInst inst;
memcpy(&inst, &vm->Memory.data[vm->core.pc], sizeof(SagittariusInst));
uint8_t opcode = inst.data & 0xFF;
bool success = false;
switch ((SagittariusInstDef)opcode) {
case math2: success = Math2Op(&vm->core, inst); break;
case math1: success = Math1Op(&vm->core, inst); break;
case cvt: success = SagCvt(&vm->core, inst); break;
case set: success = SagSet(&vm->core, inst); break;
case mv: success = SagMv(&vm->core, inst); break;
case cp: success = SagCp(&vm->core, inst); break;
case save: success = SagSave(&vm->core, inst); break;
case load: success = SagLoad(&vm->core, inst); break;
case jmp: success = SagJmp(&vm->core, inst); break;
case jmp_if: success = SagJmpIf(&vm->core, inst); break;
case call: success = SagCall(&vm->core, inst); break;
case ret: success = SagRet(&vm->core, inst); break;
case cmp: success = SagCmp(&vm->core, inst); break;
case mathv: success = SagMathV(&vm->core, inst); break;
case halt: success = SagHalt(&vm->core, inst); break;
case syscall: success = SagSyscall(&vm->core, inst); break;
case tsyscall: success = SagTSyscall(&vm->core, inst); break;
default: {
if (vm->panic_handler) vm->panic_handler(&vm->core, Sagittarius_Msg_Unknown, "Unknown opcode");
break;
}
}
(void)success;
}