src/VM/VM.c

@@ -6,30 +6,13 @@ void VM_init(VM* vm){
     vm->state = VMState_Initialized;
 }
 
-void _VM_setError(VM* vm, const char* context, const char* format, ...){
-    va_list argv;
-    char position_str[32];
-    sprintf(position_str, "[at 0x%x][", (u32)vm->current_pos);
-    char* real_format = strcat_malloc(position_str, context, "] ", format);
-    va_start(argv, format);
-    char* NULLABLE(buf) = vsprintf_malloc(256, real_format, argv);
-    va_end(argv);
-    free(real_format);
-    if(buf == NULL){
-        buf = malloc(16);
-        strcpy(buf, "SPRINTF FAILED");
-    }
-    vm->error_message = buf;
-    vm->state = VMState_InternalError;
-}
-
 bool VM_loadProgram(VM* vm, u8* data, size_t size){
     if(data == NULL){
-        VM_setError(vm, "data == NULL");
+        VM_setErrorMessage(vm, "[VM_loadProgram] can't load program because data == NULL");
         return false;
     }
     if(size == 0){
-        VM_setError(vm, "size == 0");
+        VM_setErrorMessage(vm, "[VM_loadProgram] can't load program because size == 0");
         return false;
     }
 
@@ -40,34 +23,30 @@ bool VM_loadProgram(VM* vm, u8* data, size_t size){
 
 i32 VM_executeProgram(VM* vm){
     if(vm->data == NULL){
-        VM_setError(vm, "data == null");
+        VM_setErrorMessage(vm, "[VM_executeProgram] data is null");
         return -1;
     }
 
-    vm->state = VMState_Executing;
+    size_t pos = 0;
-    vm->current_pos = 0;
+    while (pos < vm->data_size){
-    while (vm->current_pos < vm->data_size){
+        u8 opcode = vm->data[pos];
-        u8 opcode = vm->data[vm->current_pos];
 
         const Instruction* instr = Instruction_getFromOpcode(opcode);
-        // printfe("[at 0x%x] %02X %s\n", (u32)vm->current_pos, opcode, instr->name);
         if(instr == NULL){
-            VM_setError(vm, "unknown opcode %02X", opcode);
+            
             return -1;
         }
-        vm->current_pos++;
 
-        i32 bytes_read = instr->implementation(vm);
+        pos++;
-        // internal error occured
+        i32 bytes_read = instr->implementation(vm, pos);
         if(bytes_read < 0)
             return -1;
 
-        if(vm->state == VMState_Exited)
+        pos += bytes_read;
-            break;
     }
 
     if(vm->state != VMState_Exited){
-        VM_setError(vm, "unexpected end of the program");
+        VM_setErrorMessage(vm, "[%p] unexpected end of program", (void*)pos);
         return -1;
     }
 
@@ -77,8 +56,7 @@ i32 VM_executeProgram(VM* vm){
 
 bool VM_dataRead(VM* vm, void* dst, size_t pos, size_t size){
     if(pos + size >= vm->data_size){
-        VM_setError(vm, "can't read %lli bytes from 0x%x, because only %lli are avaliable",
+        VM_setErrorMessage(vm, "[%p] unexpected end of data", (void*)vm->data_size);
-            size, (u32)pos, vm->data_size - size);
         return false;
     }
 

src/VM/VM.h

@@ -31,7 +31,6 @@ typedef enum VMState {
     VMState_Initialized,
     VMState_Executing,
     VMState_Exited,
-    VMState_InternalError
 } VMState;
 
 typedef struct VM {
@@ -46,11 +45,10 @@ typedef struct VM {
     };
     
     VMState state;
-    char* NULLABLE(error_message); // not null on if state == VMState_InternalError
+    char* error_message;
 
     u8* data;
     size_t data_size;
-    size_t current_pos;
 } VM;
 
 void VM_init(VM* vm);
@@ -64,7 +62,10 @@ bool VM_loadProgram(VM* vm, u8* data, size_t size);
 /// @return program exit code or -1 on error (check vm.error_message)
 i32 VM_executeProgram(VM* vm);
 
-bool VM_dataRead(VM* vm, void* dst, size_t pos, size_t size);
+#define VM_setErrorMessage(V, FORMAT, ...) {\
+    char* buf = malloc(256);\
+    sprintf(buf, FORMAT, ##__VA_ARGS__);\
+    vm->error_message = buf;\
+}
 
-#define VM_setError(vm, format, ...) _VM_setError(vm, __func__, format ,##__VA_ARGS__)
+bool VM_dataRead(VM* vm, void* dst, size_t pos, size_t size);
-void _VM_setError(VM* vm, const char* context, const char* format, ...) __attribute__((__format__(__printf__, 3, 4)));

src/collections/Array.h

@@ -1,20 +0,0 @@
-#pragma once
-#include "../std.h"
-
-#define Array_declare(T)\
-    typedef struct Array_##T {\
-        T* data;\
-        u32 len;\
-    } Array_##T;\
-    \
-    static inline Array_##T Array_##T##_construct(T* data_ptr, u32 len) {\
-        return (Array_##T){ .data = data_ptr, .len = len };\
-    }\
-    \
-    static inline Array_##T Array_##T##_alloc(u32 len){\
-        return Array_##T##_construct(malloc(len * sizeof(T)), len);\
-    }\
-    static inline void Array_##T##_realloc(Array_##T* ptr, u32 new_len){\
-        ptr->data = realloc(ptr->data, new_len * sizeof(T));\
-        ptr->len = new_len;\
-    }

src/collections/List.h

@@ -1,41 +0,0 @@
-#pragma once
-#include "../std.h"
-
-#define List_declare(T)\
-    typedef struct List_##T {\
-        T* data;\
-        u32 len;\
-        u32 max_len;\
-    } List_##T;\
-    \
-    static inline List_##T List_##T##_construct(T* data_ptr, u32 len, u32 max_len) {\
-        return (List_##T){ .data = data_ptr, .len = len, .max_len = max_len };\
-    }\
-    \
-    static inline List_##T List_##T##_alloc(u32 len){\
-        return List_##T##_construct(len > 0 ? malloc(len * sizeof(T)) : NULL, 0, 0);\
-    }\
-    \
-    void List_##T##_push(List_##T* ptr, T value);
-
-
-#define List_define(T)\
-    void List_##T##_push(List_##T* ptr, T value){\
-        u32 max_len = ptr->max_len;\
-        if(ptr->len == max_len){\
-            max_len = max_len * 1.5;\
-            max_len += __List_padding_in_sizeof_T(T);\
-            /* branchless version of max(max_len, __List_min_size) */\
-            max_len += (max_len < __List_min_size) * (__List_min_size - max_len);\
-            ptr->data = realloc(ptr->data, max_len * sizeof(T));\
-            ptr->max_len = max_len;\
-        }\
-        ptr->data[ptr->len++] = value;\
-    }
-
-#define __List_min_size 16
-
-// sizeof(T) == 1  - padding is 7 of sizeof(T)
-// sizeof(T) == 2  - padding is 3 of sizeof(T)
-// sizeof(T) == 4  - padding is 1 of sizeof(T)
-#define __List_padding_in_sizeof_T(T) ((8 - sizeof(T) % 8) / sizeof(T) )

src/compiler/compiler.c

@@ -1,169 +0,0 @@
-#include "compiler.h"
-
-List_define(Token);
-
-void _Compiler_setError(Compiler* cmp, const char* context, const char* format, ...){
-    va_list argv;
-    char position_str[32];
-    sprintf(position_str, "[at %u:%u][", cmp->line, cmp->column);
-    char* real_format = strcat_malloc(position_str, context, "] ", format);
-    va_start(argv, format);
-    char* NULLABLE(buf) = vsprintf_malloc(512, real_format, argv);
-    va_end(argv);
-    free(real_format);
-    if(cmp->error_message == NULL){
-        cmp->error_message = malloc(16);
-        strcpy(cmp->error_message, "SPRINTF FAILED");
-    }
-    cmp->state = CompilerState_Error;
-    cmp->error_message = buf;
-}
-
-
-#define setError(FORMAT, ...) Compiler_setError(cmp, FORMAT, ##__VA_ARGS__);
-
-#define returnError(FORMAT, ...) {\
-    setError(FORMAT, ##__VA_ARGS__);\
-    return false;\
-}
-
-#define returnErrorIf(STATEMENT, FORMAT, ...) if(STATEMENT) returnError(FORMAT, ##__VA_ARGS__)
-
-#define returnErrorIf_auto(STATEMENT) returnErrorIf(STATEMENT, #STATEMENT)
-
-#define Error_UnexpectedCharacter(C) "unexpected character '%c'", C
-
-#define Error_endOfFile() "unexpected end of file"
-
-void Compiler_init(Compiler* cmp){
-    memset(cmp, 0, sizeof(Compiler));
-    cmp->state = CompilerState_Initial;
-    cmp->tokens = List_Token_alloc(1024 * 8);
-}
-
-void Compiler_free(Compiler* cmp){
-    if(cmp->tokens.data)
-        free(cmp->tokens.data);
-}
-
-static void _recognizeLexema(Compiler* cmp, size_t pos, char c){
-    switch(c){
-        // skip blank characters
-        case ' ': case '\t': case '\r': case '\n':
-            break;
-        // try read comment
-        case '/':
-            cmp->state = CompilerState_ReadingComment;
-            break;
-        // try read label
-        case '.':
-            cmp->state = CompilerState_ReadingLabel;
-            break;
-        default:
-            // try read instruction
-            if(isAlphabeticalL(c) || isAlphabeticalR(c)){
-                cmp->state = CompilerState_ReadingInstruction;
-                break;
-            }
-            else setError(Error_UnexpectedCharacter(c));
-    }
-}
-
-static void _readCommentChar(Compiler* cmp, size_t pos, char c, Token* tok){
-    // begin comment
-    if(tok->type == TokenType_Unset){
-        if(c == '*')
-            tok->type = TokenType_MultiLineComment;
-        else if(c == '/')
-            tok->type = TokenType_SingleLineComment;
-        else {
-            setError(Error_UnexpectedCharacter(c));
-            return;
-        }
-        tok->begin = pos;
-        tok->length = 0;
-    }
-    // end multi-line comment
-    else if(c == '/' && tok->type == TokenType_SingleLineComment) {
-        if(cmp->code[pos - 1] == '*' && pos - 1 > tok->begin){
-            tok->length = pos - tok->begin - 2;
-        }
-    }
-    // end single-line comment
-    else if(c == '\n' && tok->type == TokenType_SingleLineComment) {
-        tok->length = pos - tok->begin - 1;
-        // remove trailing '\r'
-        if(cmp->code[pos - 1] == '\r')
-            tok->length--;
-        List_Token_push(&cmp->tokens, *tok);
-    }
-    // at the end of file
-    else if(pos == cmp->code_len - 1){
-        // end single-line comment
-        if(tok->type == TokenType_SingleLineComment){
-            tok->length = pos - tok->begin;
-        }
-        // error on unclosed multiline comment
-        else setError(Error_endOfFile());
-    }
-    // do nothing on comment content
-}
-
-
-
-bool _Compiler_lex(Compiler* cmp){
-    cmp->line = 1;
-    cmp->column = 1;
-    Token tok = Token_construct(TokenType_Unset, 0, 0);
-    for(size_t pos = 0; pos < cmp->code_len; pos++){
-        char c = cmp->code[pos];
-
-        switch(cmp->state){
-            case CompilerState_Error:
-                return false;
-            case CompilerState_LexemaRecognition:
-                _recognizeLexema(cmp, pos, c);
-                break;
-            case CompilerState_ReadingComment:
-                _readCommentChar(cmp, pos, c, &tok);
-                break;
-            default:
-                returnError("Unexpected compiler state %i", cmp->state);
-        }
-
-        if(c == '\n'){
-            cmp->column = 0;
-            cmp->line++;
-        }
-        cmp->column++;
-    }
-
-    return cmp->state != CompilerState_Error;
-}
-
-bool _Compiler_parse(Compiler* cmp){
-    return true;
-}
-bool _Compiler_compile(Compiler* cmp){
-    return true;
-}
-
-bool Compiler_compileTasm(Compiler* cmp, const char* restrict code, size_t code_len, char* restrict out_buffer, size_t out_len){
-    returnErrorIf_auto(code == NULL);
-    returnErrorIf_auto(code_len == 0);
-    returnErrorIf_auto(out_buffer == NULL);
-    returnErrorIf_auto(out_len == 0);
-    cmp->code = code;
-    cmp->code_len = code_len;
-    cmp->out_buffer = out_buffer;
-    cmp->out_len = out_len;
-
-    if(!_Compiler_lex(cmp))
-        return false;
-    if(!_Compiler_parse(cmp))
-        return false;
-    if(!_Compiler_compile(cmp))
-        return false;
-    
-    return true;
-}

src/compiler/compiler.h

@@ -1,41 +0,0 @@
-#pragma once
-#include "../std.h"
-#include "../collections/List.h"
-#include "token.h"
-
-List_declare(Token);
-
-typedef enum CompilerState {
-    CompilerState_Initial,
-    CompilerState_LexemaRecognition,
-    CompilerState_ReadingComment,
-    CompilerState_ReadingLabel,
-    CompilerState_ReadingInstruction,
-    CompilerState_ReadingArguments,
-    CompilerState_ReadingData,
-    CompilerState_Error,
-    CompilerState_Success
-} CompilerState;
-
-typedef struct Compiler {
-    const char* code;
-    size_t code_len;
-    char* out_buffer;
-    size_t out_len;
-
-    u32 line;       // > 0 if code parsing started
-    u32 column;     // > 0 if code parsing started
-    NULLABLE(char* error_message);
-    CompilerState state;
-    List_Token tokens;
-} Compiler;
-
-void Compiler_init(Compiler* cmp);
-void Compiler_free(Compiler* cmp);
-
-/// @brief compile assembly language code to machine code
-/// @return true if no errors, false if any error occured (check cmp->error_message)
-bool Compiler_compileTasm(Compiler* cmp, const char* restrict code, size_t code_len, char* restrict out_buffer, size_t out_len);
-
-#define Compiler_setError(cmp, format, ...) _Compiler_setError(cmp, __func__, format ,##__VA_ARGS__)
-void _Compiler_setError(Compiler* cmp, const char* context, const char* format, ...) __attribute__((__format__(__printf__, 3, 4)));

src/compiler/token.h

@@ -1,21 +0,0 @@
-#pragma once
-#include "../std.h"
-
-typedef enum TokenType {
-    TokenType_Unset,
-    TokenType_SingleLineComment,
-    TokenType_MultiLineComment,
-    TokenType_Label,
-    TokenType_Instruction,
-    TokenType_Argument,
-    TokenType_Data,
-    /* there is a place for 2 values left (TokenType must occupy 4 bits) */
-} TokenType;
-
-typedef struct Token {
-    u32 begin;          // some index in Compiler->code
-    u32 length : 28;    // length in characters (28 bits)
-    TokenType type : 4; // type of token (4 bits)
-} Token;
-
-#define Token_construct(TYPE, BEGIN, END) ((Token){ .type = TYPE, .begin = BEGIN, .length = END })

src/cstr.c

@@ -1,52 +0,0 @@
-#include "std.h"
-
-char* _strcat_malloc(size_t n, cstr str0, ...){
-    va_list argv;
-    va_start(argv, str0);
-    char* heap_ptr = _vstrcat_malloc(n, str0, argv);
-    va_end(argv);
-    return heap_ptr;
-}
-
-char* _vstrcat_malloc(size_t n, cstr str0, va_list argv){
-    size_t str0_len = strlen(str0);
-    size_t total_len = str0_len;
-    cstr* const parts = malloc(sizeof(cstr) * n);
-    size_t* const part_lengths = malloc(sizeof(size_t) * n);
-    for(size_t i = 0; i < n; i++){
-        cstr part = va_arg(argv, cstr);
-        size_t length = strlen(part);
-        parts[i] = part;
-        part_lengths[i] = length;
-        total_len += length;
-    }
-    char* const buf = malloc(total_len + 1);
-    memcpy(buf, str0, str0_len);
-    char* walking_ptr = buf + str0_len;
-    for(size_t i = 0; i < n; i++){
-        memcpy(walking_ptr, parts[i], part_lengths[i]);
-        walking_ptr += part_lengths[i];
-    }
-    buf[total_len] = '\0';
-    free(parts);
-    free(part_lengths);
-    return buf;
-}
-
-char* NULLABLE(sprintf_malloc)(size_t buffer_size, cstr format, ...){
-    va_list argv;
-    va_start(argv, format);
-    char* NULLABLE(heap_ptr) = vsprintf_malloc(buffer_size, format, argv);
-    va_end(argv);
-    return heap_ptr;
-}
-
-char* NULLABLE(vsprintf_malloc)(size_t buffer_size, cstr format, va_list argv){
-    char* buf = malloc(buffer_size);
-    int r = vsprintf_s(buf, buffer_size, format, argv);
-    if(r < 0){
-        free(buf);
-        return NULL;
-    }
-    return buf;
-}

src/instructions/impl/EXIT.c

@@ -2,7 +2,7 @@
 
 /// EXIT
 /// ax - exit code
-i32 EXIT_impl(VM* vm){
+i32 EXIT_impl(VM* vm, size_t pos){
     vm->state = VMState_Exited;
     return 0;
 }

src/instructions/impl/MOV.c

@@ -1,13 +1,13 @@
 #include "impl_macros.h"
 
 /// MOV [dst_register] [src_register]
-i32 MOV_impl(VM* vm){
+i32 MOV_impl(VM* vm, size_t pos){
     u8 dst_register_i = 0;
     readRegisterVar(dst_register_i);
     u8  src_register_i = 0;
     readRegisterVar(src_register_i);
     if(dst_register_i == src_register_i){
-        VM_setError(vm, "dst_register_i == src_register_i (%x) ", src_register_i);
+        VM_setErrorMessage(vm, "[%p] dst_register_i == src_register_i (%x) ", (void*)pos, src_register_i);
         return -1;
     }
 

src/instructions/impl/NOP.c

@@ -1,6 +1,6 @@
 #include "impl_macros.h"
 
 /// NOP
-i32 NOP_impl(VM* vm){
+i32 NOP_impl(VM* vm, size_t pos){
     return 0;
 }

src/instructions/impl/PUSH.c

@@ -1,16 +1,15 @@
 #include "impl_macros.h"
 
 /// PUSH [dst_register] [value_size] [value]
-i32 PUSH_impl(VM* vm){
+i32 PUSH_impl(VM* vm, size_t pos){
     u8 dst_register_i = 0;
     readRegisterVar(dst_register_i);
     u8 value_size = 0;
     readValueSizeVar(value_size);
     
     vm->registers[dst_register_i].u32v = 0;
-    if(!VM_dataRead(vm, &vm->registers[dst_register_i].u32v, vm->current_pos, value_size))
+    if(!VM_dataRead(vm, &vm->registers[dst_register_i].u32v, pos, value_size))
         return -1;
-    vm->current_pos += value_size;
 
     return sizeof(dst_register_i) + sizeof(value_size) + value_size;
 }

src/instructions/impl/SYS.c

@@ -1,66 +1,41 @@
 #include "impl_macros.h"
 
-FILE* NULLABLE(fileFromN)(VM* vm, u32 file_n){
+FILE* fileFromN(VM* vm, size_t pos, u32 file_n){
     FILE* f = NULL;
     switch(file_n){
         case 0: f = stdin; break;
         case 1: f = stdout; break;
         case 2: f = stderr; break;
         default:
-            VM_setError(vm, "invalid file_n (%x) ", file_n);
+            VM_setErrorMessage(vm, "[%p] invalid file_n (%x) ", (void*)pos, file_n);
             break;
     }
 
     return f;
 }
 
+/// SYS
+/// ax - func code
+i32 SYS_impl(VM* vm, size_t pos){
+    u8 func_code = vm->ax.u8v0;
+    size_t result_code = 0;
+    switch(func_code){
         // sys_read
         // bx - file n
         // cx - buffer ptr
         // dx - buffer size
-i32 SYS_read(VM* vm){
+        case 0:;
-    const u32 file_n = vm->bx.u32v;
+            result_code = fread(vm->data + vm->cx.u32v, 1, vm->dx.u32v, fileFromN(vm, pos, vm->bx.u32v));
-    u8* const buf = vm->data + vm->cx.u32v;
+            break;
-    const u32 size = vm->dx.u32v;
-
-    if(buf + size > vm->data + vm->data_size)
-        return 40;
-    
-    FILE* f = fileFromN(vm, file_n);
-    return fread(buf, 1, size, f);
-}
-
         // sys_write
         // bx - file n
         // cx - buffer ptr
         // dx - buffer size
-i32 SYS_write(VM* vm){
-    const u32 file_n = vm->bx.u32v;
-    u8* const buf = vm->data + vm->cx.u32v;
-    const u32 size = vm->dx.u32v;
-
-    if(buf + size > vm->data + vm->data_size)
-        return 41;
-    
-    FILE* f = fileFromN(vm, file_n);
-    return fwrite(buf, 1, size, f);
-}
-
-/// SYS
-/// before call: ax - func code
-/// after  call: ax - result code
-i32 SYS_impl(VM* vm){
-    u8 func_code = vm->ax.u8v0;
-    u32 result_code = 0;
-    switch(func_code){
-        case 0:
-            result_code = SYS_read(vm);
-            break;
         case 1:;
-            result_code = SYS_write(vm);
+            result_code = fwrite(vm->data + vm->cx.u32v, 1, vm->dx.u32v, fileFromN(vm, pos, vm->bx.u32v));
             break;
         default:
-            VM_setError(vm, "invalid system call (%x) ", func_code);
+            VM_setErrorMessage(vm, "[%p] invalid system call (%x) ", (void*)pos, func_code);
             return -1;
     }
 

src/instructions/impl/impl_macros.h

@@ -2,14 +2,14 @@
 #include "../instructions.h"
 
 #define readVar(VAR) {\
-    if(!VM_dataRead(vm, &VAR, vm->current_pos, sizeof(VAR))) \
+    if(!VM_dataRead(vm, &VAR, pos, sizeof(VAR))) \
         return -1;\
-    vm->current_pos += sizeof(VAR);\
+    pos += sizeof(VAR);\
 }
 
 #define validateRegisterIndex(VAR) {\
     if(VAR > sizeof(vm->registers)){\
-        VM_setError(vm, "invalid register index (%x)", VAR);\
+        VM_setErrorMessage(vm, "[%p] invalid register index (%x)", (void*)pos, VAR);\
         return -1;\
     }\
 }
@@ -21,7 +21,7 @@
 
 #define validateValueSize(VAR) {\
     if(VAR < 1 || VAR > 4){\
-        VM_setError(vm, "invalid value_size (%x)", VAR);\
+        VM_setErrorMessage(vm, "[%p] invalid value_size (%x)", (void*)pos, VAR);\
         return -1;\
     }\
 }

src/instructions/impl/math_operators.c

@@ -22,26 +22,26 @@
 }
 
 /// ADD [dst_register] [src_register]
-i32 ADD_impl(VM* vm){
+i32 ADD_impl(VM* vm, size_t pos){
     mathOperatorImpl(+);
 }
 
 /// SUB [dst_register] [src_register]
-i32 SUB_impl(VM* vm){
+i32 SUB_impl(VM* vm, size_t pos){
     mathOperatorImpl(-);
 }
 
 /// MUL [dst_register] [src_register]
-i32 MUL_impl(VM* vm){
+i32 MUL_impl(VM* vm, size_t pos){
     mathOperatorImpl(*)
 }
 
 /// DIV [dst_register] [src_register]
-i32 DIV_impl(VM* vm){
+i32 DIV_impl(VM* vm, size_t pos){
     mathOperatorImpl(/)
 }
 
 /// MOD [dst_register] [src_register]
-i32 MOD_impl(VM* vm){
+i32 MOD_impl(VM* vm, size_t pos){
     mathOperatorImpl(%)
 }

src/instructions/instructions.c

@@ -16,7 +16,7 @@ const Instruction instructions[] = {
 };
 const size_t instructions_count = sizeof(instructions)/sizeof(instructions[0]);
 
-const Instruction* NULLABLE(Instruction_getFromOpcode)(u8 opcode){
+const Instruction* Instruction_getFromOpcode(u8 opcode){
     if(opcode >= instructions_count)
         return NULL;
     

src/instructions/instructions.h

@@ -3,7 +3,7 @@
 
 ///@param program_pos position in vm->program next afrer opcode
 ///@returns number of bytes read
-typedef i32 (*InstructionImplFunc_t)(VM* vm);
+typedef i32 (*InstructionImplFunc_t)(VM* vm, size_t program_pos);
 
 typedef struct Instruction {
     const char* name;
@@ -18,17 +18,17 @@ typedef struct Instruction {
 /// @brief get instruction info from table
 /// @param opcode any byte
 /// @return ptr to struct or NULL
-const Instruction* NULLABLE(Instruction_getFromOpcode)(u8 opcode);
+const Instruction* Instruction_getFromOpcode(u8 opcode);
 
-i32 NOP_impl(VM* vm);
+i32 NOP_impl(VM* vm, size_t pos);
-i32 PUSH_impl(VM* vm);
+i32 PUSH_impl(VM* vm, size_t pos);
-i32 MOV_impl(VM* vm);
+i32 MOV_impl(VM* vm, size_t pos);
-i32 ADD_impl(VM* vm);
+i32 ADD_impl(VM* vm, size_t pos);
-i32 SUB_impl(VM* vm);
+i32 SUB_impl(VM* vm, size_t pos);
-i32 MUL_impl(VM* vm);
+i32 MUL_impl(VM* vm, size_t pos);
-i32 DIV_impl(VM* vm);
+i32 DIV_impl(VM* vm, size_t pos);
-i32 MOD_impl(VM* vm);
+i32 MOD_impl(VM* vm, size_t pos);
-i32 SYS_impl(VM* vm);
+i32 SYS_impl(VM* vm, size_t pos);
-i32 EXIT_impl(VM* vm);
+i32 EXIT_impl(VM* vm, size_t pos);
-i32 JMP_impl(VM* vm);
+i32 JMP_impl(VM* vm, size_t pos);
-i32 CALL_impl(VM* vm);
+i32 CALL_impl(VM* vm, size_t pos);

src/main.c

@@ -1,34 +1,17 @@
 #include "VM/VM.h"
 #include "instructions/instructions.h"
-#include "collections/List.h"
-
-List_declare(cstr);
-List_define(cstr);
 
 #define arg_is(STR) (strcmp(argv[argi], STR) == 0)
 
-i32 compileSources(cstr out_file, List_cstr* sources);
+i32 main(const i32 argc, const char** argv){
-i32 bootFromImage(cstr image_file);
+    const char* filename = NULL;
-
-i32 main(const i32 argc, cstr* argv){
-    if(argc < 2){
-        printfe("ERROR: no arguments provided. Use --help to know more.\n");
-        return 1;
-    }
-
-    bool boot = false;
-    cstr NULLABLE(image_file) = NULL;
-    bool compile = false;
-    cstr NULLABLE(out_file) = NULL;
-    List_cstr NULLABLE(sources) = List_cstr_construct(NULL, 0, 0);
 
     for(i32 argi = 1; argi < argc; argi++){
         if(arg_is("-h") || arg_is("--help")){
             printf(
-                "-h, --help                                 Show this message.\n"
+                "-h, --help               Show this message\n"
-                "-op, --opcodes                             Show list of all instructions.\n"
+                "-op, --opcodes           Shows list of all instructions.\n"
-                "-i, --image [FILE]                         Boot VM using image file.\n"
+                "-i, --image [FILE]       Boot VM using image file\n"
-                "-c, --compile [OUT_FILE] [SOURCES...]      Compile assembly source files to machine code.\n"
             );
             return 0;
         }
@@ -36,72 +19,44 @@ i32 main(const i32 argc, cstr* argv){
             for(u8 opcode = 0; opcode < 255; opcode++){
                 const Instruction* instr = Instruction_getFromOpcode(opcode);
                 if(instr != NULL){
-                    printf("%02X %s\n", opcode, instr->name);
+                    printf("%02x %s\n", opcode, instr->name);
                 }
             }
             return 0;
         }
         else if(arg_is("-i") || arg_is("--image")){
-            if(boot){
-                printfe("--image flag is set already\n");
-                return 1;
-            }
             if(++argi >= argc){
-                printfe("ERROR: no image file specified\n");
+                printfe("ERROR: no image file specified");
                 return 1;
             }
-            image_file = argv[argi];
+            filename = argv[argi];
-            boot = true;
-        }
-        else if(arg_is("-c") || arg_is("--compile")){
-            if(compile){
-                printfe("--compile flag is set already\n");
-                return 1;
-            }
-            if(++argi >= argc){
-                printfe("ERROR: no output file file specified\n");
-                return 1;
-            }
-            out_file = argv[argi];
-            sources = List_cstr_alloc(argc);
-            compile = true;
-        }
-        else if(compile){
-            List_cstr_push(&sources, argv[argi]);
         }
         else {
-            printfe("ERROR: unknown argument '%s'\n", argv[argi]);
+            printfe("ERROR: unknown argument '%s'", argv[argi]);
             return 1;
         }
     }
 
-    i32 exit_code = 0;
+    if(filename == NULL){
-    if(compile){
+        printfe("ERROR: no arguments provided. Use --help to know more.");
-        exit_code = compileSources(out_file, &sources);
+        return 1;
-    }
-    if(exit_code == 0 && boot){
-        exit_code = bootFromImage(image_file);
     }
 
-    return exit_code;
+    FILE* file = fopen(filename, "rb");
-}
-
-i32 bootFromImage(cstr image_file){
-    FILE* file = fopen(image_file, "rb");
     if(file == NULL){
-        printfe("ERROR: can't open file '%s'\n", image_file);
+        printfe("ERROR: can't open file '%s'", filename);
         return 1;
     }
 
     const size_t buffer_size = 1024*1024;
-    u8* vm_memory = malloc(buffer_size);
+    u8* buffer = malloc(buffer_size);
-    memset(vm_memory, 0, buffer_size);
+    memset(buffer, 0, buffer_size);
 
-    size_t bytes_read = fread(vm_memory, 1, buffer_size, file);
+    size_t bytes_read = fread(buffer, 1, buffer_size, file);
     fclose(file);
     if(bytes_read == (size_t)EOF){
-        printfe("ERROR: can't read file '%s'\n", image_file);
+        printfe("ERROR: can't read file '%s'", filename);
-        free(vm_memory);
+        free(buffer);
         return 1;
     }
 
@@ -109,25 +64,14 @@ i32 bootFromImage(cstr image_file){
     VM_init(&vm);
 
     i32 exit_code = 1;
-    if(VM_loadProgram(&vm, vm_memory, bytes_read)){
+    if(VM_loadProgram(&vm, buffer, bytes_read)){
         exit_code = VM_executeProgram(&vm);
     }
-    if(vm.state == VMState_InternalError){
+    if(vm.error_message != NULL){
-        if(vm.error_message){
+        printfe("VM ERROR: %s", vm.error_message);
-            printfe("VM ERROR: %s\n", vm.error_message);
         free(vm.error_message);
     }
-        else printfe("VM ERROR: unknown error (error_message is null)\n");
-    }
     
-    if(exit_code != 0){
+    free(buffer);
-        printfe("program exited with code %i\n", exit_code);
-    }
-
-    free(vm_memory);
     return exit_code;
 }
-
-i32 compileSources(cstr out_file, List_cstr* sources){
-    return -1;
-}

src/std.h

@@ -24,34 +24,4 @@ typedef u8 bool;
 #define true  1
 #define false 0
 
-typedef const char* cstr;
-
-#define __count_args( \
-    a0, a1, a2, a3, a4, a5, a6, a7 , a8, a9, a10,a11,a12,a13,a14,a15, \
-    a16,a17,a18,a19,a20,a21,a22,a23, a24,a25,a26,a27,a28,a29,a30,a31, \
-    a32,a33,a34,a35,a36,a37,a38,a39, a40,a41,a42,a43,a44,a45,a46,a47, \
-    a48,a49,a50,a51,a52,a53,a54,a55, a56,a57,a58,a59,a60,a61,a62,a63, \
-    a64,...) a64
-// Macro for counting variadic arguments (max 64)
-// (see usage in kprint.h)
-#define count_args(ARGS...) __count_args(ARGS, \
-    64,63,62,61,60,59,58,57, 56,55,54,53,52,51,50,49, \
-    48,47,46,45,44,43,42,41, 40,39,38,37,36,35,34,33, \
-    32,31,30,29,28,27,26,25, 24,23,22,21,20,19,18,17, \
-    16,15,14,13,12,11,10,9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
-
 #define printfe(FORMAT, ...) fprintf(stderr, FORMAT ,##__VA_ARGS__)
-
-/// @warning pointer can be null
-#define NULLABLE(NAME) NAME
-
-#define strcat_malloc(STR0, ...) _strcat_malloc(count_args(__VA_ARGS__), STR0, __VA_ARGS__)
-char* _strcat_malloc(size_t n, const char* str0, ...);
-char* _vstrcat_malloc(size_t n, const char* str0, va_list argv);
-
-char* NULLABLE(sprintf_malloc)(size_t buffer_size, const char* format, ...) __attribute__((__format__(__printf__, 2, 3)));
-char* NULLABLE(vsprintf_malloc)(size_t buffer_size, const char* format, va_list argv);
-
-static inline bool isAlphabeticalL(char c) { return c - 'a' <= 'z'; }
-static inline bool isAlphabeticalR(char c) { return c - 'A' <= 'Z'; }
-static inline bool isDigit(char c) { return c - '0' <= '9'; }