updated tlibc

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "dependencies/tlibc"]
+	path = dependencies/tlibc
+	url = https://timerix.ddns.net/git/Timerix/tlibc.git

.vscode/c_cpp_properties.json

@@ -0,0 +1,15 @@
+{
+    "configurations": [
+        {
+            "name": "all",
+            "defines": [],
+            "includePath": [
+                "dependencies/tlibc/include",
+                "src",
+                "${default}"
+            ],
+            "cStandard": "c11"
+        }
+    ],
+    "version": 4
+}

.vscode/launch.json

@@ -2,16 +2,20 @@
     "version": "0.2.0",
     "configurations": [
         {
-            "name": "(gdb) Debug",
+            "name": "gdb_debug",
             "type": "cppdbg",
             "request": "launch",
             "program": "${workspaceFolder}/bin/tcpu",
             "windows": { "program": "${workspaceFolder}/bin/tcpu.exe" },
-            "args": [ "-c", "s.tasm", "o.bin" ],
+            "args": [ 
+                "-c", "../examples/video.tasm", "o.bin", 
+                "-i", "o.bin", "--debug", "--video" 
+            ],
             "cwd": "${workspaceFolder}/bin",
             "preLaunchTask": "build_exec_dbg",
             "stopAtEntry": false,
             "externalConsole": false,
+            "internalConsoleOptions": "neverOpen",
             "MIMode": "gdb",
             "miDebuggerPath": "gdb",
             "setupCommands": [
@@ -26,4 +30,4 @@
             ]
         }
     ]
-}
+}

README.md

@@ -2,37 +2,80 @@
 Machine code interpreter written in pure C. Can execute programs up to 1 MEGABYTE (1048576 bytes) in size!!!
 
 ## Building
-1. Install [cbuild](https://timerix.ddns.net:3322/Timerix/cbuild.git)
+1. Clone repo
-2.  ```sh
+    ```
+    git clone --recurse-submodules https://timerix.ddns.net/git/Timerix/tcpu.git
+    ```
+2. Install [cbuild](https://timerix.ddns.net/git/Timerix/cbuild.git)
+3. Install [SDL3](https://github.com/libsdl-org/SDL) and [SDL3_image](https://github.com/libsdl-org/SDL_image) from package manager or source.
+3.  ```sh
     cbuild build_exec_dbg
     ```
 
 ## Assembly language
-### Instructions
-| code | name | arguments | details |
-|------|------|-----------|---------|
-| 00 | NOP  |           | ignored instruction |
-| 01 | PUSH | `dst_register`, `value_size(bytes)`, `value` | push constant value into `dst_register` | 
-| 02 | MOV  | `dst_register`, `src_register` | copy value from `src_register` to `dst_register`
-| 03 | ADD  | `dst_register`, `src_register` | `dst` += `src` |
-| 04 | SUB  | `dst_register`, `src_register` | `dst` -= `src` |
-| 05 | MUL  | `dst_register`, `src_register` | `dst` *= `src` |
-| 06 | DIV  | `dst_register`, `src_register` | `dst` /= `src` |
-| 07 | MOD  | `dst_register`, `src_register` | `dst` %= `src` |
-| 08 | SYS  |           | call system function |
-| 09 | EXIT |           | stop the program with exit code in `ax` |
-
 ### Registers
-| code | name | size (bits) |
+| name | code | size (bits) |
-|------|------|-------------|
+|-----|------|----|
-| 00 | ax | 32 |
+| rax | 0x01 | 64 |
-| 01 | bx | 32 |
+| eax | 0x02 | 32 |
-| 02 | cx | 32 |
+| ax  | 0x04 | 16 |
-| 03 | dx | 32 |
+| al  | 0x07 | 8  |
+| ah  | 0x08 | 8  |
+|                 |
+| rbx | 0x11 | 64 |
+| ebx | 0x12 | 32 |
+| bx  | 0x14 | 16 |
+| bl  | 0x17 | 8  |
+| bh  | 0x18 | 8  |
+|                 |
+| rcx | 0x21 | 64 |
+| ecx | 0x22 | 32 |
+| cx  | 0x24 | 16 |
+| cl  | 0x27 | 8  |
+| ch  | 0x28 | 8  |
+|                 |
+| rdx | 0x31 | 64 |
+| edx | 0x32 | 32 |
+| dx  | 0x34 | 16 |
+| dl  | 0x37 | 8  |
+| dh  | 0x38 | 8  |
+
+### Instructions
+| name | arguments | details |
+|------|-----------|---------|
+| NOP  |           | ignored instruction |
+| EXIT |           | stop the program with exit code in `eax` |
+| SYS  |           | call system function |
+|                            |
+| MOVC | `dst_register`, `const_value` | push constant value into `dst_register` | 
+| MOVR | `dst_register`, `src_register` | copy value from `src_register` to `dst_register` |
+|                            |
+| ADD | `dst_register`, `src_register` | `dst += src` |
+| SUB | `dst_register`, `src_register` | `dst -= src` |
+| MUL | `dst_register`, `src_register` | `dst *= src` |
+| DIV | `dst_register`, `src_register` | `dst /= src` |
+| MOD | `dst_register`, `src_register` | `dst %= src` |
+|                            |
+| EQ | `dst_register`, `src_register` | `cmp_flag = dst == src` |
+| NE | `dst_register`, `src_register` | `cmp_flag = dst != src` |
+| LT | `dst_register`, `src_register` | `cmp_flag = dst <  src` |
+| LE | `dst_register`, `src_register` | `cmp_flag = dst <= src` |
+| GT | `dst_register`, `src_register` | `cmp_flag = dst >  src` |
+| GE | `dst_register`, `src_register` | `cmp_flag = dst >= src` |
+|                            |
+| NOT | `dst_register` | `dst = !dst` |
+| INV | `dst_register` | `dst = ~dst` |
+| OR  | `dst_register`, `src_register` | `dst = dst \| src` |
+| XOR | `dst_register`, `src_register` | `dst = dst ^ src` |
+| AND | `dst_register`, `src_register` | `dst = dst & src` |
+|                            |
+| JMP | `dst_address_const` | goto `dst` |
+| JNZ | `dst_address_const` | if (`cmp_flag` != 0) goto `dst` |
+| JZ  | `dst_address_const` | if (`cmp_flag` == 0) goto `dst` |
 
 ### System functions
 To call a system function you need to push values to registers and write `SYS` opcode. The return value of a function will will be avaliable in `ax` after call.
-| `ax` | name | `bx` | `cx` | `dx` | details |
+| name | `al` | `ah` | `rbx` | `ecx` | details |
-|-----------|------|----|----|----|---------|
+|------|------|------|-------|-------|---------|
-| 0 | read  | file number | buffer pointer | buffer size | read data from file |
+| read  | 0 | file number | buffer pointer | buffer size | read data from file |
-| 1 | write | file number | buffer pointer | buffer size | write data to file |
+| write | 1 | file number | buffer pointer | buffer size | write data to file |

TODO.md

@@ -0,0 +1,11 @@
+# TODO List
+- add negative number arguments support
+- add movc char support
+- add padding to compilation
+- VM debug log
+- add display syscalls
+- change section binary format:
+    1. code
+    2. exit instruction with code ERR_U_FORGOT_TO_CALL_EXIT
+    3. data
+- arguments validation for each instruction

dependencies/tlibc.config

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+# This is a dependency config.
+# You can copy it to another project to add tlibc dependency.
+
+DEP_WORKING_DIR="$DEPENDENCIES_DIR/tlibc"
+if [[ "$TASK" = *_dbg ]]; then
+    dep_build_target="build_static_lib_dbg"
+else
+    dep_build_target="build_static_lib"
+fi
+DEP_PRE_BUILD_COMMAND=""
+DEP_BUILD_COMMAND="cbuild $dep_build_target"
+DEP_POST_BUILD_COMMAND=""
+DEP_CLEAN_COMMAND="cbuild clean"
+DEP_DYNAMIC_OUT_FILES=""
+DEP_STATIC_OUT_FILES="bin/tlibc.a"
+DEP_OTHER_OUT_FILES=""
+PRESERVE_OUT_DIRECTORY_STRUCTURE=false

examples/conditional_jump.tasm

@@ -0,0 +1,32 @@
+/*
+Example of behavior change depending on some condition
+*/
+
+.main:
+movc ax 1
+movc bx 2
+gt ax bx
+jnz @true
+jz @false
+
+.true:
+const8 true.msg "true\n"
+movc rbx @true.msg
+movc ecx #true.msg
+jmp @print
+
+.false
+const8 false.msg "false\n"
+movc rbx @false.msg
+movc ecx #false.msg
+jmp @print
+
+.print:
+movc al 1
+movc ah 1
+sys
+jmp @end
+
+.end:
+movc ax 0
+exit

examples/loop.tasm

@@ -0,0 +1,22 @@
+/*
+Example of self-repeating code section
+*/
+
+.main:
+movc dx 0; // loop counter
+
+.loop
+const8 datum "ITERATION!!! "
+movc al 1
+movc ah 1
+movc rbx @datum
+movc ecx #datum
+sys
+
+movc cx 1
+add dx cx
+movc cx 8
+lt dx cx
+jnz @loop
+movc rax 0
+exit

examples/stdout.tasm

@@ -0,0 +1,16 @@
+/*
+"hello world" program in my assembly language
+*/
+
+.data:
+// named array of 8-bit values
+const8 msg "Hello, World!\n"
+
+.main:
+movc al 1; // sys_write
+movc ah 1; // stdout
+movc rbx @msg; // address of msg data
+movc ecx #msg; // size of msg data
+sys
+movc ax 0
+exit

examples/video.tasm

@@ -0,0 +1,7 @@
+/*
+Example of graphical application
+*/
+
+.main:
+//TODO: add a way to access Event struct's fields
+exit

project.config

@@ -1,22 +1,30 @@
 #!/usr/bin/env bash
-CBUILD_VERSION=2.1.4
+CBUILD_VERSION=2.3.2
-CONFIG_VERSION=1
 
 PROJECT="tcpu"
 CMP_C="gcc"
 CMP_CPP="g++"
-STD_C="c11"
+STD_C="c99"
 STD_CPP="c++11"
-WARN_C="-Wall -Wextra -Wno-unused-parameter"
+WARN_C="-Wall -Wextra
-WARN_CPP="-Wall -Wextra -Wno-unused-parameter"
+    -Wduplicated-branches
+    -Wduplicated-cond
+    -Wformat=2
+    -Wmissing-include-dirs
+    -Wshadow
+    -Werror=return-type
+    -Werror=pointer-arith
+    -Werror=init-self
+    -Werror=incompatible-pointer-types"
+WARN_CPP="$WARN_C"
 SRC_C="$(find src -name '*.c')"
 SRC_CPP="$(find src -name '*.cpp')"
 
 # Directory with dependency configs.
 # See cbuild/example_dependency_configs
-DEPENDENCY_CONFIGS_DIR='.'
+DEPENDENCY_CONFIGS_DIR='dependencies'
 # List of dependency config files in DEPENDENCY_CONFIGS_DIR separated by space.
-ENABLED_DEPENDENCIES=''
+ENABLED_DEPENDENCIES='tlibc'
 
 # OBJDIR structure:
 #  ├── objects/      - Compiled object files. Cleans on each call of build task
@@ -25,20 +33,21 @@ ENABLED_DEPENDENCIES=''
 #  └── profile/      - gcc *.gcda profiling info files
 OBJDIR="obj"
 OUTDIR="bin"
-STATIC_LIB_FILE="lib$PROJECT.a"
+STATIC_LIB_FILE="$PROJECT.a"
+
+INCLUDE="-Isrc -I$DEPENDENCIES_DIR/tlibc/include"
 
 # OS-specific options
 case "$OS" in
     WINDOWS)
         EXEC_FILE="$PROJECT.exe"
         SHARED_LIB_FILE="$PROJECT.dll"
-        # example: "-I./"
+        LINKER_LIBS="-lSDL3_image -lSDL3"
-        INCLUDE=""
         ;;
     LINUX)
         EXEC_FILE="$PROJECT"
         SHARED_LIB_FILE="$PROJECT.so"
-        INCLUDE=""
+        LINKER_LIBS="-lSDL3_image -lSDL3"
         ;;
     *)
         error "operating system $OS has no configuration variants"
@@ -57,62 +66,62 @@ case "$TASK" in
         # -fdata-sections -ffunction-sections -Wl,--gc-sections  removes unused code
         C_ARGS="-O2 -flto=auto -fuse-linker-plugin -fprofile-use -fprofile-prefix-path=$(realpath $OBJDIR)/objects -fdata-sections -ffunction-sections -Wl,--gc-sections"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
-        PRE_TASK_SCRIPT=
+        PRE_TASK_SCRIPT=""
-        TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        TASK_SCRIPT="@cbuild/default_tasks/build_exec.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT="@cbuild/default_tasks/strip_exec.sh"
         ;;
     # creates executable with debug info and no optimizations
     build_exec_dbg)
         C_ARGS="-O0 -g3"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
-        PRE_TASK_SCRIPT=
+        PRE_TASK_SCRIPT=""
-        TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        TASK_SCRIPT="@cbuild/default_tasks/build_exec.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # creates shared library
     build_shared_lib)
         C_ARGS="-O2 -fpic -flto -shared"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS -Wl,-soname,$SHARED_LIB_FILE"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS -Wl,-soname,$SHARED_LIB_FILE"
-        PRE_TASK_SCRIPT=
+        PRE_TASK_SCRIPT=""
-        TASK_SCRIPT=cbuild/default_tasks/build_shared_lib.sh
+        TASK_SCRIPT="@cbuild/default_tasks/build_shared_lib.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # creates shared library with debug symbols and no optimizations
     build_shared_lib_dbg)
         C_ARGS="-O0 -g3 -fpic -shared"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS -Wl,-soname,$SHARED_LIB_FILE"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS -Wl,-soname,$SHARED_LIB_FILE"
-        PRE_TASK_SCRIPT=
+        PRE_TASK_SCRIPT=""
-        TASK_SCRIPT=cbuild/default_tasks/build_shared_lib.sh
+        TASK_SCRIPT="@cbuild/default_tasks/build_shared_lib.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # creates static library
     build_static_lib)
         C_ARGS="-O2 -fpic -fdata-sections -ffunction-sections"
         CPP_ARGS="$C_ARGS"
-        PRE_TASK_SCRIPT=
+        PRE_TASK_SCRIPT=""
-        TASK_SCRIPT=cbuild/default_tasks/build_static_lib.sh
+        TASK_SCRIPT="@cbuild/default_tasks/build_static_lib.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # creates static library with debug symbols and no optimizations
     build_static_lib_dbg)
         C_ARGS="-O0 -g3"
         CPP_ARGS="$C_ARGS"
-        PRE_TASK_SCRIPT=
+        PRE_TASK_SCRIPT=""
-        TASK_SCRIPT=cbuild/default_tasks/build_static_lib.sh
+        TASK_SCRIPT="@cbuild/default_tasks/build_static_lib.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # executes $EXEC_FILE
     exec)
-        TASK_SCRIPT=cbuild/default_tasks/exec.sh
+        TASK_SCRIPT="@cbuild/default_tasks/exec.sh"
         ;;
     # executes $EXEC_FILE with valgrind memory checker
     valgrind)  
-        VALGRIND_ARGS="-s --read-var-info=yes --track-origins=yes --fullpath-after=$(pwd) --leak-check=full --show-leak-kinds=all" 
+        VALGRIND_ARGS="-s --read-var-info=yes --track-origins=yes --fullpath-after=$(pwd)/ --leak-check=full --show-leak-kinds=all" 
-        TASK_SCRIPT=cbuild/default_tasks/valgrind.sh
+        TASK_SCRIPT="@cbuild/default_tasks/valgrind.sh"
         ;;
     # generates profiling info
     profile)
@@ -125,23 +134,26 @@ case "$TASK" in
         # -fprofile-prefix-path sets path where profiling info about objects will be saved
         C_ARGS="-O2 -flto=auto -fuse-linker-plugin -fprofile-generate -fprofile-prefix-path=$(realpath $OBJDIR)/objects"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
-        PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        PRE_TASK_SCRIPT="@cbuild/default_tasks/build_exec.sh"
-        TASK_SCRIPT=cbuild/default_tasks/profile.sh
+        TASK_SCRIPT="@cbuild/default_tasks/profile.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # compiles program with -pg and runs it with gprof
     # uses gprof2dot python script to generate function call tree (pip install gprof2dot)
     # requires graphviz (https://www.graphviz.org/download/source/)
     gprof)
         OUTDIR="$OUTDIR/gprof"
-        # -pg adds code to executable, that generates file containing function call info (gmon.out)
+        # arguments that emit some call counter code and disable optimizations to see function names
-        C_ARGS="-O2 -flto=auto -fuse-linker-plugin -pg"
+        # https://github.com/msys2/MINGW-packages/issues/8503#issuecomment-1365475205
+        C_ARGS="-O0 -g -pg -no-pie -fno-omit-frame-pointer
+            -fno-inline-functions -fno-inline-functions-called-once 
+            -fno-optimize-sibling-calls -fopenmp"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
-        PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        PRE_TASK_SCRIPT="@cbuild/default_tasks/build_exec.sh"
-        TASK_SCRIPT=cbuild/default_tasks/gprof.sh
+        TASK_SCRIPT="@cbuild/default_tasks/gprof.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # compiles program and runs it with callgrind (part of valgrind)
     # uses gprof2dot python script to generate function call tree (pip install gprof2dot)
@@ -152,30 +164,30 @@ case "$TASK" in
         # -pg adds code to executable, that generates file containing function call info (gmon.out)
         C_ARGS="-O2 -flto=auto -fuse-linker-plugin"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
-        PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        PRE_TASK_SCRIPT="@cbuild/default_tasks/build_exec.sh"
-        TASK_SCRIPT=cbuild/default_tasks/callgrind.sh
+        TASK_SCRIPT="@cbuild/default_tasks/callgrind.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # compiles executable with sanitizers and executes it to find errors and warnings
     sanitize)
         OUTDIR="$OUTDIR/sanitize"
         C_ARGS="-O0 -g3 -fsanitize=undefined,address"
         CPP_ARGS="$C_ARGS"
-        LINKER_ARGS="$CPP_ARGS"
+        LINKER_ARGS="$CPP_ARGS $LINKER_LIBS"
-        PRE_TASK_SCRIPT=cbuild/default_tasks/build_exec.sh
+        PRE_TASK_SCRIPT="@cbuild/default_tasks/build_exec.sh"
-        TASK_SCRIPT=cbuild/default_tasks/exec.sh
+        TASK_SCRIPT="@cbuild/default_tasks/exec.sh"
-        POST_TASK_SCRIPT=
+        POST_TASK_SCRIPT=""
         ;;
     # rebuilds specified dependencies
     # EXAMPLE: `cbuild rebuild_dependencies=libexample1,fonts`
     # 'all' can be specified to rebuild all dependencies
     rebuild_dependencies)
-        TASK_SCRIPT=cbuild/default_tasks/rebuild_dependencies.sh
+        TASK_SCRIPT="@cbuild/default_tasks/rebuild_dependencies.sh"
         ;;
     # deletes generated files
     clean)
-        TASK_SCRIPT=cbuild/default_tasks/clean.sh
+        TASK_SCRIPT="@cbuild/default_tasks/clean.sh"
         ;;
     # nothing to do
     "" | no_task)

project.config.user.default

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# Project user config is ignored by git.
+# Here you can add variables that users might want to change
+# on their local machine, without commiting to the repository.
+
+# Directory where you install dependencies.
+# Do not confuse with DEPENDENCY_CONFIGS_DIR
+# Example:
+#    libexample source code is at `../libexample`, and dependency config
+#    that specifies how to build this lib is at `dependencies/libexample.config`
+DEPENDENCIES_DIR="dependencies"

src/VM/Display/Display.c

@@ -0,0 +1,87 @@
+#include <SDL3/SDL.h>
+#include <SDL3_image/SDL_image.h>
+#include "Display.h"
+#include "tcpu_version.h"
+
+typedef struct Display {
+    i32 width;
+    i32 height;
+    SDL_Window* window;
+    SDL_Renderer* renderer;
+} Display;
+
+static SDL_InitState _sdl_init_state = {0};
+static Display _d = {0};
+static cstr _title = "TCPU v" TCPU_VERSION_CSTR;
+
+bool Display_init(i32 w, i32 h, DisplayFlags flags){
+    (void)flags;
+    
+    _d.width = w;
+    _d.height = h;
+    _d.window = NULL;
+    _d.renderer = NULL;
+    
+    if (SDL_ShouldInit(&_sdl_init_state)) {
+        bool sdl_initialized = SDL_Init(SDL_INIT_VIDEO);
+        SDL_SetInitialized(&_sdl_init_state, sdl_initialized);
+        if(!sdl_initialized)
+            return false;
+    }
+
+    SDL_WindowFlags window_flags = SDL_WINDOW_ALWAYS_ON_TOP;
+    if(!SDL_CreateWindowAndRenderer(_title, _d.width, _d.height, window_flags, &_d.window, &_d.renderer)){
+        return false;
+    }
+
+    return true;
+}
+
+void Display_destroy(){
+    SDL_DestroyRenderer(_d.renderer);
+    SDL_DestroyWindow(_d.window);
+
+    // if (SDL_ShouldQuit(&_sdl_init_state)) {
+    //     SDL_Quit();
+    //     SDL_SetInitialized(&_sdl_init_state, false);
+    // }
+}
+
+NULLABLE(cstr) Display_getError(){
+    return SDL_GetError();
+}
+
+bool Display_setSize(u32 w, u32 h){
+    _d.width = w;
+    _d.height = h;
+    return SDL_SetWindowSize(_d.window, w, h);
+}
+
+bool Display_setFullScreenMode(bool value){
+    return SDL_SetWindowFullscreen(_d.window, value);
+}
+
+bool Display_setDrawingColor(ColorRGBA color){
+    return SDL_SetRenderDrawColor(_d.renderer, color.r, color.g, color.b, color.a);
+}
+
+bool Display_clear(){
+    return SDL_RenderClear(_d.renderer);
+}
+
+#define Rect_copy(DST, SRC) {\
+    DST.x = SRC.x;\
+    DST.y = SRC.y;\
+    DST.w = SRC.w;\
+    DST.h = SRC.h;\
+}
+
+bool Display_fillRect(Rect rect) {
+    SDL_FRect sdl_rect;
+    Rect_copy(sdl_rect, rect);
+    return SDL_RenderFillRect(_d.renderer, &sdl_rect);
+}
+
+bool Display_swapBuffers(){
+    return SDL_RenderPresent(_d.renderer);
+}

src/VM/Display/Display.h

@@ -0,0 +1,30 @@
+#pragma once
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+
+typedef struct Rect {
+    i32 x, y;
+    i32 w, h;
+} Rect;
+#define Rect_create(X, Y, W, H) ((Rect){ .x = X, .y = Y, .w = W, .h = H})
+
+typedef struct ColorRGBA {
+    u8 r, g, b, a;
+} ColorRGBA;
+#define ColorRGBA_create(R, G, B, A) ((ColorRGBA){ .r = R, .g = G, .b = B, .a = A })
+
+
+typedef enum DisplayFlags {
+    DisplayFlags_Default = 0
+} DisplayFlags;
+
+bool Display_init(i32 w, i32 h, DisplayFlags flags);
+void Display_destroy();
+NULLABLE(cstr) Display_getError();
+
+bool Display_setSize(u32 w, u32 h);
+bool Display_setFullScreenMode(bool value);
+bool Display_setDrawingColor(ColorRGBA color);
+bool Display_clear();
+bool Display_fillRect(Rect rect);
+bool Display_swapBuffers();

src/VM/VM.c

@@ -1,7 +1,7 @@
 #include "VM.h"
-#include "../instructions/instructions.h"
+#include "instructions/instructions.h"
 
-void VM_init(VM* vm){
+void VM_construct(VM* vm){
     memset(vm, 0, sizeof(VM));
     vm->state = VMState_Initialized;
 }
@@ -12,7 +12,7 @@ void _VM_setError(VM* vm, cstr context, cstr format, ...){
     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);
+    char* NULLABLE(buf) = vsprintf_malloc(real_format, argv);
     va_end(argv);
     free(real_format);
     if(buf == NULL){
@@ -49,8 +49,8 @@ i32 VM_boot(VM* vm){
     while (vm->current_pos < vm->data_size){
         u8 opcode = vm->data[vm->current_pos];
 
-        const Instruction* instr = Instruction_getFromOpcode(opcode);
+        const Instruction* instr = Instruction_getByOpcode(opcode);
-        // printfe("[at 0x%x] %02X %s\n", (u32)vm->current_pos, opcode, instr->name);
+        // printfe("[at 0x%x] %02X %s\n", (u32)vm->current_pos, opcode, instr->name.data);
         if(instr == NULL){
             VM_setError(vm, "unknown opcode %02X", opcode);
             return -1;
@@ -60,7 +60,7 @@ i32 VM_boot(VM* vm){
         i32 bytes_read = instr->implementation(vm);
         // internal error occured
         if(bytes_read < 0)
-            return -1;
+            return bytes_read;
         
         if(vm->state == VMState_Exited)
             break;
@@ -72,16 +72,37 @@ i32 VM_boot(VM* vm){
     }
 
     // exit code of the program should be in ax register
-    return vm->ax.i32v;
+    return vm->registers.a.ex;
 }
 
 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_setError(vm, 
+            "can't read " IFWIN("%lli", "%li") " bytes from 0x%x, because only "
+                IFWIN("%lli", "%li") " are avaliable",
             size, (u32)pos, vm->data_size - size);
         return false;
     }
 
-    memcpy(dst, vm->data + pos, size);
+    void* addr = vm->data + pos;
+    memcpy(dst, addr, size);
     return true;
 }
+
+void VM_registerRead(VM* vm, void* dst, RegisterCode code) {
+    u8 index = code / 0x10;
+    u8 part = code & 0xf;
+    u8 offset = part / 8;
+    u8 size = 8 / part;
+    void* addr = (u8*)(&vm->registers.array[index]) + offset;
+    memcpy(dst, addr, size);
+}
+
+void VM_registerWrite(VM* vm, void* src, RegisterCode code){
+    u8 index = code / 0x10;
+    u8 part = code & 0xf;
+    u8 offset = part / 8;
+    u8 size = 8 / part;
+    void* addr = (u8*)(&vm->registers.array[index]) + offset;
+    memcpy(addr, src, size);
+}

src/VM/VM.h

@@ -1,29 +1,15 @@
 #pragma once
-#include "../std.h"
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+#include "instructions/registers.h"
 
 typedef union Register {
-    u32 u32v;
+    u64 rx;
-    i32 i32v;
+    u32 ex;
-    f32 f32v;
+    u16 x;
     struct { 
-        u16 u16v0;
+        u8 l;
-        u16 u16v1;
+        u8 h;
-    };
-    struct {
-        i16 i16v0;
-        i16 i16v1;
-    };
-    struct { 
-        u8 u8v0;
-        u8 u8v1;
-        u8 u8v2;
-        u8 u8v3;
-    };
-    struct { 
-        i8 i8v0;
-        i8 i8v1;
-        i8 i8v2;
-        i8 i8v3;
     };
 } Register;
 
@@ -37,13 +23,17 @@ typedef enum VMState {
 typedef struct VM {
     union {
         struct {
-            Register ax;
+            Register a;
-            Register bx;
+            Register b;
-            Register cx;
+            Register c;
-            Register dx;
+            Register d;
         };
-        Register registers[4];
+        Register array[4];
-    };
+    } registers;
+
+    struct {
+        bool cmp; // result of comparison operation
+    } flags;
     
     VMState state;
     char* NULLABLE(error_message); // not null on if state == VMState_InternalError
@@ -53,7 +43,7 @@ typedef struct VM {
     size_t current_pos;
 } VM;
 
-void VM_init(VM* vm);
+void VM_construct(VM* vm);
 
 /// @brief Loads a program from the buffer.
 /// @param data buffer starting with machine code
@@ -65,6 +55,8 @@ bool VM_setMemory(VM* vm, u8* data, size_t size);
 i32 VM_boot(VM* vm);
 
 bool VM_dataRead(VM* vm, void* dst, size_t pos, size_t size);
+void VM_registerRead(VM* vm, void* dst, RegisterCode code);
+void VM_registerWrite(VM* vm, void* src, RegisterCode code);
 
 #define VM_setError(vm, format, ...) _VM_setError(vm, __func__, format ,##__VA_ARGS__)
 void _VM_setError(VM* vm, cstr context, cstr 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.c

@@ -1,5 +0,0 @@
-#include "List.h"
-
-List_define(cstr);
-List_define(u32);
-List_define(u8);

src/collections/List.h

@@ -1,45 +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) )
-
-List_declare(cstr);
-List_declare(u32);
-List_declare(u8);

src/compiler/AST.c

@@ -0,0 +1,51 @@
+#include "AST.h"
+
+Array_declare(str);
+
+static Array(str) _ArgumentType_str_array = ARRAY(str, {
+    STR("Unset"),
+    STR("Register"),
+    STR("ConstValue"),
+    STR("VarDataName"),
+    STR("ConstDataPointer"),
+    STR("ConstDataSize"),
+});
+
+str ArgumentType_toString(ArgumentType t){
+    if(t >= _ArgumentType_str_array.len)
+        return STR("!!ArgumentType INDEX_ERROR!!");
+    return _ArgumentType_str_array.data[t];
+}
+
+
+void Section_construct(Section* sec, str name){
+    sec->name = name;
+    sec->data_definitions_list = List_DataDefinition_alloc(256);
+    sec->operations_list = List_Operation_alloc(1024);
+}
+
+void Section_destroy(Section* sec){
+    for(u32 i = 0; i < sec->data_definitions_list.len; i++){
+        DataDefinition* dd = sec->data_definitions_list.data + i;
+        List_u8_destroy(&dd->data_bytes);
+    }
+    List_DataDefinition_destroy(&sec->data_definitions_list);
+
+    for(u32 i = 0; i < sec->operations_list.len; i++){
+        Operation* op = sec->operations_list.data + i;
+        List_Argument_destroy(&op->args);
+    }
+    List_Operation_destroy(&sec->operations_list);
+}
+
+
+void AST_construct(AST* ast){
+    ast->sections = List_Section_alloc(32);
+}
+
+void AST_destroy(AST* ast){
+    for(u32 i = 0; i != ast->sections.len; i++){
+        Section_destroy(ast->sections.data + i);
+    }
+    List_Section_destroy(&ast->sections);
+}

src/compiler/AST.h

@@ -0,0 +1,66 @@
+#pragma once
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+#include "instructions/instructions.h"
+#include "instructions/registers.h"
+#include "tlibc/collections/List.h"
+#include "tlibc/collections/List_impl/List_u8.h"
+
+typedef enum ArgumentType {
+    ArgumentType_Unset,
+    ArgumentType_Register,
+    ArgumentType_ConstValue,
+    ArgumentType_VarDataName,
+    ArgumentType_ConstDataPointer,
+    ArgumentType_ConstDataSize,
+} ArgumentType;
+
+str ArgumentType_toString(ArgumentType t);
+
+typedef struct Argument {
+    ArgumentType type;
+    union {
+        i64 i;
+        f64 f;
+        str data_name;
+        RegisterCode register_code;
+    } value;
+} Argument;
+
+List_declare(Argument);
+
+
+typedef struct Operation {
+    List(Argument) args;
+    Opcode opcode;
+} Operation;
+
+List_declare(Operation);
+
+
+typedef struct DataDefinition {
+    str name;
+    List(u8) data_bytes;
+    u32 element_size;
+} DataDefinition;
+
+List_declare(DataDefinition);
+
+
+typedef struct Section {
+    str name;
+    List(DataDefinition) data_definitions_list;
+    List(Operation) operations_list;
+} Section;
+
+List_declare(Section);
+
+void Section_construct(Section* Section, str name);
+void Section_destroy(Section* Section);
+
+typedef struct AST {
+    List(Section) sections;
+} AST;
+
+void AST_construct(AST* ast);
+void AST_destroy(AST* ast);

src/compiler/Binary.c

@@ -0,0 +1,36 @@
+#include "Binary.h"
+
+void CompiledSection_construct(CompiledSection* ptr, str name){
+    ptr->name = name;
+    ptr->next = NULL;
+    ptr->offset = 0;
+    ptr->const_data_props_list = List_ConstDataProps_construct(NULL, 0, 0);
+    ptr->named_refs = List_NamedRef_construct(NULL, 0, 0);
+    ptr->bytes = List_u8_alloc(128);
+}
+
+void CompiledSection_destroy(CompiledSection* ptr){
+    List_ConstDataProps_destroy(&ptr->const_data_props_list);
+    List_NamedRef_destroy(&ptr->named_refs);
+    List_u8_destroy(&ptr->bytes);
+}
+
+
+void BinaryObject_construct(BinaryObject* ptr){
+    ptr->comp_sec_list = List_CompiledSection_alloc(64);
+    HashMap_construct(&ptr->comp_sec_i_map, u32, NULL);
+    HashMap_construct(&ptr->const_data_props_map, ConstDataProps, NULL);
+    ptr->main_sec = NULL;
+    ptr->total_size = 0;
+}
+
+void BinaryObject_destroy(BinaryObject* ptr){
+    for(u32 i = 0; i < ptr->comp_sec_list.len; i++){
+        CompiledSection* sec_ptr = ptr->comp_sec_list.data + i;
+        CompiledSection_destroy(sec_ptr);
+    }
+    List_CompiledSection_destroy(&ptr->comp_sec_list);
+    
+    HashMap_destroy(&ptr->comp_sec_i_map);
+    HashMap_destroy(&ptr->const_data_props_map);
+}

src/compiler/Binary.h

@@ -0,0 +1,64 @@
+#pragma once
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+#include "instructions/instructions.h"
+#include "instructions/registers.h"
+#include "tlibc/collections/List.h"
+#include "tlibc/collections/List_impl/List_u8.h"
+#include "tlibc/collections/HashMap.h"
+#include "AST.h"
+
+typedef struct CompiledSection CompiledSection;
+typedef struct ConstDataProps {
+    str name;
+    u32 size;   // size in bytes
+    u32 offset; // offset in bytes from section start
+} ConstDataProps;
+
+List_declare(ConstDataProps)
+
+#define ConstDataProps_construct(NAME, SIZE, OFFSET) ((ConstDataProps){ .name = NAME, .size = SIZE, .offset = OFFSET})
+
+
+typedef enum NamedRefType {
+    NamedRefType_Unset,
+    NamedRefType_Ptr,
+    NamedRefType_Size,
+} NamedRefType;
+
+typedef struct NamedRef {
+    str name;
+    NamedRefType type;
+    u32 offset; // offset in bytes from section start
+} NamedRef;
+
+List_declare(NamedRef);
+
+#define NamedRef_construct(NAME, TYPE, OFFSET) ((NamedRef){ .name = NAME, .type = TYPE, .offset = OFFSET})
+
+
+typedef struct CompiledSection {
+    str name;
+    CompiledSection* next;
+    u32 offset;
+    List(ConstDataProps) const_data_props_list;
+    List(NamedRef) named_refs;
+    List(u8) bytes;
+} CompiledSection;
+
+List_declare(CompiledSection)
+
+void CompiledSection_construct(CompiledSection* ptr, str name);
+void CompiledSection_destroy(CompiledSection* ptr);
+
+
+typedef struct BinaryObject {
+    List(CompiledSection) comp_sec_list;
+    HashMap(u32) comp_sec_i_map;
+    NULLABLE(CompiledSection*) main_sec; 
+    HashMap(ConstDataProps) const_data_props_map;
+    u32 total_size;
+} BinaryObject;
+
+void BinaryObject_construct(BinaryObject* ptr);
+void BinaryObject_destroy(BinaryObject* ptr);

src/compiler/Compiler.c

@@ -0,0 +1,391 @@
+#include "Compiler_internal.h"
+
+void Compiler_construct(Compiler* cmp){
+    memset(cmp, 0, sizeof(Compiler));
+    cmp->state = CompilerState_Initial;
+    cmp->tokens = List_Token_alloc(4096);
+    cmp->line_lengths = List_u32_alloc(1024);
+    AST_construct(&cmp->ast);
+    BinaryObject_construct(&cmp->binary);
+}
+
+void Compiler_destroy(Compiler* cmp){
+    str_destroy(cmp->code);
+    List_Token_destroy(&cmp->tokens);
+    List_u32_destroy(&cmp->line_lengths);
+    AST_destroy(&cmp->ast);
+    BinaryObject_destroy(&cmp->binary);
+}
+
+CodePos Compiler_getLineAndColumn(Compiler* cmp, u32 pos){
+    u32 prev_lines_len = 0;
+    if(pos >= cmp->code.len)
+        return CodePos_create(0, 0);
+    
+    for(u32 i = 0; i < cmp->line_lengths.len; i++){
+        u32 line_len = cmp->line_lengths.data[i];
+        if(prev_lines_len + line_len > pos)
+            return CodePos_create(i + 1, pos + 1 - prev_lines_len);
+        prev_lines_len += line_len;
+    }
+
+    return CodePos_create(0, 0);
+}
+
+void _Compiler_setError(Compiler* cmp, cstr context, cstr format, ...){
+    // happens at the end of file
+    if(cmp->pos >= cmp->code.len)
+        cmp->pos = cmp->code.len - 1;
+    char position_str[32];
+    CodePos code_pos = Compiler_getLineAndColumn(cmp, cmp->pos);
+    sprintf(position_str, "[at %u:%u][", code_pos.line, code_pos.column);
+    char* real_format = strcat_malloc(position_str, context, "] ", format);
+    va_list argv;
+    va_start(argv, format);
+    char* NULLABLE(buf) = vsprintf_malloc(real_format, argv);
+    va_end(argv);
+    free(real_format);
+    if(buf == NULL){
+        buf = malloc(16);
+        strcpy(buf, "SPRINTF FAILED");
+    }
+    cmp->state = CompilerState_Error;
+    cmp->error_message = buf;
+}
+
+#define setError(FORMAT, ...) {\
+    Compiler_setError(cmp, FORMAT, ##__VA_ARGS__);\
+}
+
+str Compiler_constructTokenStr(Compiler* cmp, Token t){
+    str s = str_construct((char*)(cmp->code.data + t.begin), t.length, false);
+    return s;
+}
+
+#define List_u8_pushStruct(L_PTR, S_PTR) List_u8_pushMany((L_PTR), (void*)(S_PTR), sizeof(*(S_PTR)))
+
+static bool compileSection(Compiler* cmp, Section* sec){
+    u32 cs_index = cmp->binary.comp_sec_list.len;
+    CompiledSection* cs = List_CompiledSection_expand(&cmp->binary.comp_sec_list, 1);
+    CompiledSection_construct(cs, sec->name);
+    if(!HashMap_tryPush(&cmp->binary.comp_sec_i_map, cs->name, &cs_index)){
+        returnError("duplicate section '%s'", str_copy(sec->name).data);
+    }
+
+    // compile code
+    u8 zeroes_8[8];
+    memset(zeroes_8, 0, sizeof(zeroes_8));
+    for(u32 i = 0; i < sec->operations_list.len; i++){
+        Operation* op = sec->operations_list.data + i;
+        List_u8_pushStruct(&cs->bytes, &op->opcode);
+        for(u32 j = 0; j < op->args.len; j++){
+            Argument* arg = op->args.data + j;
+            switch(arg->type){
+                case ArgumentType_VarDataName:
+                    returnError("argument type 'VarDataName' is not supported yet");
+                case ArgumentType_Unset:
+                    returnError("ArgumentType is not set");
+                default:
+                    returnError("invalid ArgumentType %i", arg->type);
+                
+                case ArgumentType_Register:
+                    List_u8_push(&cs->bytes, arg->value.register_code);
+                    break;
+                case ArgumentType_ConstValue:
+                    List_u8_pushStruct(&cs->bytes, &arg->value.i);
+                    break;
+                case ArgumentType_ConstDataPointer:
+                    List_NamedRef_push(&cs->named_refs, 
+                        NamedRef_construct(
+                            arg->value.data_name, 
+                            NamedRefType_Ptr, 
+                            cs->bytes.len
+                        )
+                    );
+                    List_u8_pushStruct(&cs->bytes, zeroes_8);
+                    break;
+                case ArgumentType_ConstDataSize:
+                    List_NamedRef_push(&cs->named_refs, 
+                        NamedRef_construct(
+                            arg->value.data_name, 
+                            NamedRefType_Size, 
+                            cs->bytes.len
+                        )
+                    );
+                    List_u8_pushStruct(&cs->bytes, zeroes_8);
+                    break;
+            }
+        }
+    }
+
+    // compile data
+    for(u32 i = 0; i < sec->data_definitions_list.len; i++){
+        DataDefinition* dd = sec->data_definitions_list.data + i;
+        ConstDataProps cd_props = ConstDataProps_construct(dd->name, dd->data_bytes.len, cs->bytes.len);
+        List_ConstDataProps_push(&cs->const_data_props_list, cd_props);
+        List_u8_pushMany(&cs->bytes, dd->data_bytes.data, dd->data_bytes.len);
+    }
+
+    // TODO: push padding
+
+    return true;
+}
+
+static bool compileBinary(Compiler* cmp){
+    returnErrorIf_auto(cmp->state != CompilerState_Parsing);
+    cmp->state = CompilerState_Compiling;
+
+    for(u32 i = 0; i < cmp->ast.sections.len; i++){
+        Section* sec = cmp->ast.sections.data + i;
+        if(!compileSection(cmp, sec)){
+            return false;
+        }
+    }
+
+    // find main section
+    str main_sec_name = STR("main");
+    u32* main_sec_i_ptr = HashMap_tryGetPtr(&cmp->binary.comp_sec_i_map, main_sec_name);
+    if(main_sec_i_ptr == NULL){
+        returnError("no 'main' section was defined");
+    }
+    u32 main_sec_i = *main_sec_i_ptr;
+    cmp->binary.main_sec = cmp->binary.comp_sec_list.data + main_sec_i;
+
+    // create linked list of CompiledSection where main is the first    
+    CompiledSection* prev_sec = cmp->binary.main_sec;
+    u32 total_size = 0;
+    for(u32 i = 0; i < cmp->binary.comp_sec_list.len; i++){
+        CompiledSection* sec = cmp->binary.comp_sec_list.data + i;
+        total_size += sec->bytes.len;
+        bool is_main_sec = str_equals(sec->name, main_sec_name);
+        if(!is_main_sec){
+            sec->offset = prev_sec->offset + prev_sec->bytes.len;
+        }
+
+        ConstDataProps cd = ConstDataProps_construct(sec->name, sec->bytes.len, sec->offset);
+        if(!HashMap_tryPush(&cmp->binary.const_data_props_map, cd.name, &cd)){
+            returnError("duplicate named data '%s'", str_copy(cd.name).data);
+        }
+        for(u32 j = 0; j < sec->const_data_props_list.len; j++){
+            cd = sec->const_data_props_list.data[j];
+            cd.offset += sec->offset;
+            if(!HashMap_tryPush(&cmp->binary.const_data_props_map, cd.name, &cd)){
+                returnError("duplicate named data '%s'", str_copy(cd.name).data);
+            }
+        }
+
+        if(is_main_sec)
+           continue;
+        prev_sec->next = sec;
+        prev_sec = sec;
+    }
+
+    // insert calculated offsets into sections
+    for(u32 i = 0; i < cmp->binary.comp_sec_list.len; i++){
+        CompiledSection* sec = cmp->binary.comp_sec_list.data + i;
+        for(u32 j = 0; j < sec->named_refs.len; j++){
+            NamedRef* ref = sec->named_refs.data + j;
+            
+            ConstDataProps* target_data = HashMap_tryGetPtr(
+                        &cmp->binary.const_data_props_map, ref->name);
+            if(target_data == NULL){
+                returnError("can't find named data '%s'", str_copy(ref->name).data);
+            }
+
+            u64* ref_value_ptr = (void*)((u8*)sec->bytes.data + ref->offset);
+            switch(ref->type){
+                default:
+                    returnError("invalid NamedRefType %i", ref->type);
+                case NamedRefType_Size:
+                    *ref_value_ptr = target_data->size;
+                    break;
+                case NamedRefType_Ptr:
+                    *ref_value_ptr = target_data->offset;
+                    break;
+            }
+        } 
+    }
+
+    cmp->binary.total_size = total_size;
+    return true;
+}
+
+static bool writeBinaryFile(Compiler* cmp, FILE* f){
+    returnErrorIf_auto(cmp->state != CompilerState_Compiling);
+
+    CompiledSection* sec = cmp->binary.main_sec;
+    while(sec){
+        fwrite(sec->bytes.data, 1, sec->bytes.len, f);
+        fflush(f);
+        sec = sec->next;
+    }
+
+    //TODO: print warnings for unused sections
+    return true;
+}
+
+bool Compiler_compile(Compiler* cmp, cstr source_file_name, cstr out_file_name, bool debug_log){
+    FILE* f = fopen(source_file_name, "rb");
+    if(f == NULL)
+        returnError("ERROR: can't open file '%s'", source_file_name);
+    
+    StringBuilder sb = StringBuilder_alloc(64 * 1024);
+    int ret;
+    while((ret = fgetc(f)) != EOF) {
+        StringBuilder_append_char(&sb, ret);
+    }
+    if(ferror(f)){
+        StringBuilder_destroy(&sb);
+        fclose(f);
+        returnError("can't read file '%s'", source_file_name);
+    }
+    fclose(f);
+
+    if(sb.buffer.len == 0){
+        StringBuilder_destroy(&sb);
+        returnError("soucre file is empty");
+    }
+
+    cmp->code = str_copy(StringBuilder_getStr(&sb));
+    StringBuilder_destroy(&sb);
+
+    f = fopen(out_file_name, "wb");
+    if(f == NULL){
+        returnError("ERROR: can't open file '%s'", out_file_name);
+    }
+
+    if(debug_log){
+        printf("===========================[%s]===========================\n", source_file_name);
+        fputs(cmp->code.data, stdout);
+        fputc('\n', stdout);
+    }
+    
+    if(debug_log)
+        printf("===================================[lexing]===================================\n");
+    bool success = Compiler_lex(cmp);
+
+    if(debug_log){
+        printf("------------------------------------[lines]------------------------------------\n");
+        for(u32 i = 0; i < cmp->line_lengths.len; i++){
+            printf("[%u] length: %u\n", i+1, cmp->line_lengths.data[i]);
+        }
+
+        printf("------------------------------------[tokens]-----------------------------------\n");
+        for(u32 i = 0; i < cmp->tokens.len; i++){
+            Token t = cmp->tokens.data[i];
+            CodePos pos = Compiler_getLineAndColumn(cmp, t.begin);
+            char* tokstr = malloc(4096);
+            strncpy(tokstr, cmp->code.data + t.begin, t.length);
+            tokstr[t.length] = 0;
+            char* tokstr_stripped = tokstr;
+            while(*tokstr_stripped == '\r' || *tokstr_stripped == '\n'){
+                tokstr_stripped++;
+            }
+            printf("[l:%3u, c:%3u] %s '%s'\n", 
+                pos.line, pos.column, 
+                TokenType_toString(t.type).data, tokstr_stripped);
+            free(tokstr);
+        }
+    }
+
+    if(!success){
+        fclose(f);
+        return false;
+    }
+
+    if(debug_log)
+        printf("===================================[parsing]===================================\n");
+    success = Compiler_parse(cmp);
+
+    if (debug_log){
+        printf("-------------------------------------[AST]-------------------------------------\n");
+        for(u32 i = 0; i < cmp->ast.sections.len; i++){
+            Section* sec = cmp->ast.sections.data + i;
+            printf("section '"FMT_str"'\n", sec->name.len, sec->name.data);
+
+            for(u32 j = 0; j < sec->data_definitions_list.len; j++){
+                DataDefinition* dd = sec->data_definitions_list.data + j;
+                printf("    const%u "FMT_str" (len %u)\n", 
+                    dd->element_size * 8,
+                    dd->name.len, dd->name.data,
+                    dd->data_bytes.len/dd->element_size);
+            }
+
+            
+            for(u32 j = 0; j < sec->operations_list.len; j++){
+                Operation* op = sec->operations_list.data + j;
+                const Instruction* instr = Instruction_getByOpcode(op->opcode);
+                if(instr == NULL){
+                    fclose(f);
+                    returnError("unknown opcode: %i", op->opcode)
+                }
+
+                printf("    %s", instr->name.data);
+                for(u32 k = 0; k < op->args.len; k++){
+                    Argument* arg = op->args.data + k;
+                    printf(" %s(", ArgumentType_toString(arg->type).data);
+                    
+                    switch(arg->type){
+                        default:
+                            fclose(f);
+                            returnError("invalid argument type %i", arg->type);
+                        case ArgumentType_Register:;
+                            str register_name = RegisterCode_toString(arg->value.register_code);
+                            printf("%s 0x%x", register_name.data, arg->value.register_code);
+                            str_destroy(register_name);
+                            break;
+                        case ArgumentType_ConstValue:
+                            printf(IFWIN("%lli", "%li"), arg->value.i);
+                            break;
+                        case ArgumentType_ConstDataPointer:
+                            printf("@"FMT_str, arg->value.data_name.len, arg->value.data_name.data);
+                            break;
+                        case ArgumentType_ConstDataSize:
+                            printf("#"FMT_str, arg->value.data_name.len, arg->value.data_name.data);
+                            break;
+                        case ArgumentType_VarDataName:
+                            printf(FMT_str, arg->value.data_name.len, arg->value.data_name.data);
+                            break;
+                    }
+
+                    printf(")");
+                }
+
+                printf("\n");
+            }
+        }
+    }
+
+    if(!success){
+        fclose(f);
+        return false;
+    }
+
+    if(debug_log)
+        printf("==================================[compiling]==================================\n");
+    success = compileBinary(cmp);
+
+    if(debug_log){
+        for(u32 i = 0; i < cmp->binary.comp_sec_list.len; i++){
+            CompiledSection* sec = cmp->binary.comp_sec_list.data + i;
+            printf("compiled section '"FMT_str"' to %u bytes with offset 0x%x\n", 
+                sec->name.len, sec->name.data, sec->bytes.len, sec->offset);
+        }
+    }
+    
+    if(!success){
+        fclose(f);
+        return false;
+    }
+    
+    
+    if(debug_log)
+        printf("----------------------------[writing output to file]---------------------------\n");
+    success = writeBinaryFile(cmp, f);
+    fclose(f);
+    if(success){
+        cmp->state = CompilerState_Success;
+    }
+    
+    return success;
+}

src/compiler/Compiler.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+#include "tlibc/collections/List.h"
+#include "tlibc/collections/List_impl/List_u32.h"
+#include "tlibc/collections/HashMap.h"
+#include "Token.h"
+#include "Binary.h"
+
+typedef enum CompilerState {
+    CompilerState_Initial,
+    CompilerState_Lexing,
+    CompilerState_Parsing,
+    CompilerState_Compiling,
+    CompilerState_Error,
+    CompilerState_Success
+} CompilerState;
+
+
+typedef struct Compiler {
+    /* general fields */
+    str code;
+    u32 column;     // > 0 if code parsing started
+    u32 pos;
+    CompilerState state;
+    NULLABLE(char* error_message);
+    /* lexer fields */
+    List(Token) tokens;
+    List(u32) line_lengths;
+    /* parser fields */
+    AST ast;
+    u32 tok_i;
+    /* compiler fields */
+    BinaryObject binary;
+} Compiler;
+
+void Compiler_construct(Compiler* cmp);
+void Compiler_destroy(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_compile(Compiler* cmp, cstr source_file_name, cstr out_file_name, bool debug);

src/compiler/Compiler_internal.h

@@ -0,0 +1,30 @@
+#include "Compiler.h"
+#include "tlibc/string/StringBuilder.h"
+
+void _Compiler_setError(Compiler* cmp, cstr context, cstr format, ...) __attribute__((__format__(__printf__, 3, 4)));
+
+#define Compiler_setError(cmp, format, ...) _Compiler_setError(cmp, __func__, 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)
+
+typedef struct CodePos {
+    u32 line; // 0 on error
+    u32 column; // 0 on error
+} CodePos;
+
+#define CodePos_create(L, C) ((CodePos){ .line = L, .column = C })
+
+/// @param pos index in code buffer
+CodePos Compiler_getLineAndColumn(Compiler* cmp, u32 pos);
+
+str Compiler_constructTokenStr(Compiler* cmp, Token t);
+
+bool Compiler_lex(Compiler* cmp);
+bool Compiler_parse(Compiler* cmp);

src/compiler/Lexer.c

@@ -0,0 +1,269 @@
+#include "Compiler_internal.h"
+
+#define setError(FORMAT, ...) {\
+    completeLine(cmp);\
+    Compiler_setError(cmp, FORMAT, ##__VA_ARGS__);\
+}
+
+#define Error_unexpectedCharacter(C) "unexpected character '%c'", C
+#define Error_endOfFile "unexpected end of file"
+
+static void completeLine(Compiler* cmp){
+    List_u32_push(&cmp->line_lengths, cmp->column);
+    cmp->column = 0;
+}
+
+static void readCommentSingleLine(Compiler* cmp){
+    char c; // '/'
+    Token tok = Token_construct(TokenType_SingleLineComment, cmp->pos - 1, 0);
+    cmp->column++;
+    cmp->pos++;
+    
+    while(cmp->pos < cmp->code.len){
+        c = cmp->code.data[cmp->pos];
+        // end of line
+        if(c == '\r' || c == '\n'){
+            tok.length = cmp->pos - tok.begin;
+            List_Token_push(&cmp->tokens, tok);
+            // cmp->line will be increased in lex()
+            return;
+        }
+        
+        cmp->column++;
+        cmp->pos++;
+    }
+    
+    // end of file
+    tok.length = cmp->pos - tok.begin;
+    List_Token_push(&cmp->tokens, tok);
+}
+
+static void readCommentMultiLine(Compiler* cmp){
+    char c; // '*'
+    Token tok = Token_construct(TokenType_MultiLineComment, cmp->pos - 1, 0);
+    cmp->column++;
+    cmp->pos++;
+    
+    while(cmp->pos < cmp->code.len){
+        c = cmp->code.data[cmp->pos];
+        // closing comment
+        if(cmp->pos > tok.begin + 3 && c == '/' && cmp->code.data[cmp->pos - 1] == '*') {
+            tok.length = cmp->pos - tok.begin + 1;
+            List_Token_push(&cmp->tokens, tok);
+            return;
+        }
+
+        if(c == '\n')
+            completeLine(cmp);
+        cmp->column++;
+        cmp->pos++;
+    }
+    
+    // end of file
+    setError(Error_endOfFile);
+}
+
+static void readComment(Compiler* cmp){
+    char c; // '/'
+    if(cmp->pos + 1 == cmp->code.len){
+        setError(Error_endOfFile);
+        return;
+    }
+
+    c = cmp->code.data[cmp->pos + 1];
+    if(c == '\r' || c == '\n'){
+        setError(Error_unexpectedCharacter(cmp->code.data[--cmp->pos]));
+        return;
+    }
+
+    cmp->pos++;
+    cmp->column++;
+    if(c == '/')
+        readCommentSingleLine(cmp);
+    else if(c == '*')
+        readCommentMultiLine(cmp);
+    else setError(Error_unexpectedCharacter(c));
+}
+
+static void readLabel(Compiler* cmp){
+    char c; // '.'
+    cmp->pos++;
+    cmp->column++;
+    Token tok = Token_construct(TokenType_Label, cmp->pos, 0);
+    
+    while(cmp->pos < cmp->code.len){
+        c = cmp->code.data[cmp->pos];
+        // end of line
+        if(c == ':' || c == '\r' || c == '\n'){
+            tok.length = cmp->pos - tok.begin;
+            if(tok.length > 0)
+                List_Token_push(&cmp->tokens, tok);
+            else setError(Error_unexpectedCharacter(cmp->code.data[--cmp->pos]));
+            // cmp->line will be increased in lex()
+            return;
+        }
+
+        if(!char_isLatinLower(c) && !char_isLatinUpper(c) && !char_isDigit(c) &&
+            c != '_' && c != '.'){
+            setError(Error_unexpectedCharacter(c));
+            return;
+        }
+        
+        cmp->column++;
+        cmp->pos++;
+    }
+    
+    // end of file
+    tok.length = cmp->pos - tok.begin;
+    if(tok.length > 0)
+        List_Token_push(&cmp->tokens, tok);
+    else setError(Error_endOfFile);
+}
+
+static void readArguments(Compiler* cmp){
+    char c; // space
+    Token tok = Token_construct(TokenType_Unset, cmp->pos, 0);
+    char quot = '\0'; // quotation character of a string value
+
+    while(cmp->pos < cmp->code.len){
+        c = cmp->code.data[cmp->pos];
+
+        // string argument reading
+        if(quot != '\0'){
+            if(c == quot && (cmp->code.data[cmp->pos - 1] != '\\' || cmp->code.data[cmp->pos - 2] == '\\')){
+                quot = '\0';
+            }
+            else if(c == '\r' || c == '\n'){
+                setError("line end reached but string hasn't been closed yet");
+                return;
+            }
+        }
+
+        // end of operation
+        else if(c == '\r' || c == '\n' || c == ';'){
+            tok.length = cmp->pos - tok.begin;
+            if(tok.length > 0)
+                List_Token_push(&cmp->tokens, tok);
+            // cmp->line will be increased in lex()
+            return;
+        }
+
+        // new argument begins
+        else if(c == ' ' || c == '\t'){
+            tok.length = cmp->pos - tok.begin;
+            if(tok.length > 0)
+                List_Token_push(&cmp->tokens, tok);
+            tok = Token_construct(TokenType_Unset, cmp->pos + 1, 0);
+        }
+
+        else if(tok.type == TokenType_Unset){
+            if(c == '\''){
+                tok.type = TokenType_Char;
+                quot = c;
+            }
+            else if(c == '"'){
+                tok.type = TokenType_String;
+                quot = c;
+            }
+            else if(c == '@')
+                tok.type = TokenType_NamedDataPointer;
+            else if(c == '#')
+                tok.type = TokenType_NamedDataSize;
+            else if(char_isDigit(c))
+                tok.type = TokenType_Number;
+            else tok.type = TokenType_Name;
+        }
+
+        cmp->column++;
+        cmp->pos++;
+    }
+    
+    // end of file
+    tok.length = cmp->pos - tok.begin;
+    if(tok.length > 0)
+        List_Token_push(&cmp->tokens, tok);
+}
+
+static void readInstruction(Compiler* cmp){
+    Token tok = Token_construct(TokenType_Instruction, cmp->pos, 0);
+    cmp->pos++;
+    cmp->column++;
+    
+    while(cmp->pos < cmp->code.len){
+        char c = cmp->code.data[cmp->pos];
+        // end of line
+        if(c == '\r' || c == '\n' || c == ';'){
+            tok.length = cmp->pos - tok.begin;
+            List_Token_push(&cmp->tokens, tok);
+            tok = Token_construct(TokenType_OperationEnd, cmp->pos, 1);
+            List_Token_push(&cmp->tokens, tok);
+            // cmp->line will be increased in lex()
+            return;
+        }
+
+        // arguments begin
+        if(c == ' ' || c == '\t'){
+            tok.length = cmp->pos - tok.begin;
+            List_Token_push(&cmp->tokens, tok);
+            readArguments(cmp);
+            tok = Token_construct(TokenType_OperationEnd, cmp->pos, 1);
+            List_Token_push(&cmp->tokens, tok);
+            return;
+        }
+
+        if(!char_isLatinLower(c) && !char_isLatinUpper(c) && !char_isDigit(c)){
+            setError(Error_unexpectedCharacter(c));
+            return;
+        }
+
+        cmp->column++;
+        cmp->pos++;
+    }
+    
+    // end of file
+    tok.length = cmp->pos - tok.begin;
+    List_Token_push(&cmp->tokens, tok);
+    tok = Token_construct(TokenType_OperationEnd, cmp->pos, 1);
+    List_Token_push(&cmp->tokens, tok);
+}
+
+bool Compiler_lex(Compiler* cmp){
+    returnErrorIf_auto(cmp->state != CompilerState_Initial);
+    cmp->state = CompilerState_Lexing;
+    cmp->column = 1;
+
+    while(cmp->pos < cmp->code.len){
+        char c = cmp->code.data[cmp->pos];
+        switch(c){
+            // skip blank characters
+            case ' ': case '\t': case '\r': case '\n':
+                break;
+            // try read comment
+            case '/':
+                readComment(cmp);
+                break;
+            // try read label
+            case '.':
+                readLabel(cmp);
+                break;
+            default:
+                // try read instruction
+                if(char_isLatinLower(c) || char_isLatinUpper(c))
+                    readInstruction(cmp);
+                else returnError(Error_unexpectedCharacter(c));
+                break;
+        }
+
+        if(cmp->state == CompilerState_Error)
+            return false;
+        
+        c = cmp->code.data[cmp->pos];
+        if(c == '\n')
+            completeLine(cmp);
+        cmp->column++;
+        cmp->pos++;
+    }
+
+    completeLine(cmp);
+    return true;
+}

src/compiler/Parser.c

@@ -0,0 +1,285 @@
+#include "Compiler_internal.h"
+
+#define setError(FORMAT, ...) {\
+    cmp->pos = cmp->tokens.data[cmp->tok_i].begin;\
+    Compiler_setError(cmp, FORMAT, ##__VA_ARGS__);\
+}
+
+#define setError_unexpectedToken(T) {\
+    str tok_str_tmp = Compiler_constructTokenStr(cmp, T);\
+    cmp->pos = T.begin;\
+    Compiler_setError(cmp, "unexpected token '"FMT_str"'", tok_str_tmp.len, tok_str_tmp.data);\
+}
+
+#define setError_unexpectedTokenChar(T, I) {\
+    cmp->pos = T.begin + I;\
+    Compiler_setError(cmp, "unexpected character '%c'", cmp->code.data[cmp->pos]);\
+}
+
+#define setError_unexpectedInstruction(T) {\
+    str tok_str_tmp = Compiler_constructTokenStr(cmp, T);\
+    cmp->pos = T.begin;\
+    Compiler_setError(cmp, "unexpected instruction '"FMT_str"'", tok_str_tmp.len, tok_str_tmp.data);\
+}
+
+#define Error_TokenUnset "token of undefined type"
+#define Error_BitSize "invalid size in bits"
+
+static inline bool isVarSizeBits(u32 B) { return (B == 8 || B == 16 || B == 32 || B == 64); }
+
+static NULLABLE(str) resolveEscapeSequences(Compiler* cmp, str src){
+    StringBuilder sb = StringBuilder_alloc(src.len);
+    char c;
+    bool escaped = false;
+    for(u32 i = 0; i < src.len; i++){
+        c = src.data[i];
+        if(c == '\\'){
+            escaped = !escaped;
+            if(escaped)
+                continue;
+        }
+        
+        if(!escaped){
+            StringBuilder_append_char(&sb, c);
+            continue;
+        }
+
+        // escape codes
+        switch(c){
+            case '0':
+                StringBuilder_append_char(&sb, '\0');
+                break;
+            case 'n':
+                StringBuilder_append_char(&sb, '\n');
+                break;
+            case 'r':
+                StringBuilder_append_char(&sb, '\r');
+                break;
+            case 't':
+                StringBuilder_append_char(&sb, '\t');
+                break;
+            case 'e':
+                StringBuilder_append_char(&sb, '\e');
+                break;
+            case '"':
+            case '\'':
+                StringBuilder_append_char(&sb, c);
+                break;
+            default:
+                setError_unexpectedTokenChar(cmp->tokens.data[cmp->tok_i], i);
+                StringBuilder_destroy(&sb);
+                return str_null;
+        }
+
+        escaped = false;
+    }
+
+    return StringBuilder_getStr(&sb);
+}
+
+static void parseDataDefinition(Compiler* cmp, str instr_name, DataDefinition* ddf){
+    i32 _element_size_bits;
+    str _instr_name_zero_terminated = str_copy(instr_name);
+    if(sscanf(_instr_name_zero_terminated.data, "const%i", &_element_size_bits) != 1 || !isVarSizeBits(_element_size_bits)){
+        str_destroy(_instr_name_zero_terminated);
+        setError(Error_BitSize);
+        return;
+    }
+    str_destroy(_instr_name_zero_terminated);
+    ddf->element_size = _element_size_bits / 8;
+    ddf->data_bytes = List_u8_alloc(32);
+
+    Token tok = cmp->tokens.data[++cmp->tok_i];
+    if(tok.type != TokenType_Name){
+        setError_unexpectedToken(tok);
+        return;
+    }
+
+    str tok_str = Compiler_constructTokenStr(cmp, tok);
+    str processed_str = str_null;
+    ddf->name = tok_str;
+    
+    while(++cmp->tok_i < cmp->tokens.len){
+        tok = cmp->tokens.data[cmp->tok_i];
+        switch(tok.type){
+            case TokenType_SingleLineComment:
+            case TokenType_MultiLineComment:
+                // skip comments
+                break;
+            
+            case TokenType_OperationEnd:
+                return;
+            case TokenType_Unset:
+                setError(Error_TokenUnset);
+                return;
+            default:
+                setError_unexpectedToken(tok);
+                return;
+            
+            case TokenType_Number:
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                processed_str = str_copy(tok_str);
+                if(str_seekChar(tok_str, '.', 0) != -1){
+                    f64 f = atof(processed_str.data);
+                    // for numbers smaller than 64 bits
+                    u8* value_part = (u8*)&f + 8 - ddf->element_size;
+                    List_u8_pushMany(&ddf->data_bytes, value_part, ddf->element_size);
+                }
+                else {
+                    i64 i = atoll(processed_str.data);
+                    // for numbers smaller than 64 bits
+                    u8* value_part = (u8*)&i + 8 - ddf->element_size;
+                    List_u8_pushMany(&ddf->data_bytes, value_part, ddf->element_size);
+                }
+                str_destroy(processed_str);
+                break;
+            case TokenType_Char:
+                tok.begin += 1;
+                tok.length -= 2;
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                processed_str = resolveEscapeSequences(cmp, tok_str);
+                
+                if(processed_str.len != ddf->element_size){
+                    setError("can't fit char of size %i in %u bit variable", processed_str.len, _element_size_bits);
+                    return;
+                }
+                List_u8_pushMany(&ddf->data_bytes, (u8*)processed_str.data, processed_str.len);
+                str_destroy(processed_str);
+                break;
+            case TokenType_String:
+                tok.begin += 1;
+                tok.length -= 2;
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                processed_str = resolveEscapeSequences(cmp, tok_str);
+                List_u8_pushMany(&ddf->data_bytes, (u8*)processed_str.data, processed_str.len);
+                str_destroy(processed_str);
+                break;
+        }
+    }
+}
+
+
+static void parseOperation(Compiler* cmp, str instr_name, Operation* operPtr){
+    Token tok = cmp->tokens.data[cmp->tok_i];
+    const Instruction* instr = Instruction_getByName(instr_name);
+    if(instr == NULL){
+        setError_unexpectedInstruction(tok);
+        return;
+    }
+
+    operPtr->opcode = instr->opcode;
+    operPtr->args = List_Argument_alloc(4);
+    Argument arg = (Argument){ .type = ArgumentType_Unset, .value.i = 0 };
+    str tok_str = str_null;
+    str processed_str = str_null;
+    while(++cmp->tok_i < cmp->tokens.len){
+        tok = cmp->tokens.data[cmp->tok_i];
+        switch(tok.type){
+            case TokenType_SingleLineComment:
+            case TokenType_MultiLineComment:
+                // skip comments
+                break;
+            
+            case TokenType_OperationEnd:
+                return;
+            case TokenType_Unset:
+                setError(Error_TokenUnset);
+                return;
+            default:
+                setError_unexpectedToken(tok);
+                return;
+            
+            case TokenType_Number:
+                arg.type = ArgumentType_ConstValue;
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                processed_str = str_copy(tok_str);
+                if(str_seekChar(tok_str, '.', 0) != -1){
+                    arg.value.f = atof(processed_str.data);
+                }
+                else {
+                    arg.value.i = atoll(processed_str.data);
+                }
+                str_destroy(processed_str);
+                List_Argument_push(&operPtr->args, arg);
+                break;
+            case TokenType_Name:
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                arg.value.register_code = RegisterCode_parse(tok_str);
+                if(arg.value.register_code != RegisterCode_Unset){
+                    arg.type = ArgumentType_Register;
+                }
+                else {
+                    arg.type = ArgumentType_VarDataName;
+                    arg.value.data_name = tok_str;
+                }
+                List_Argument_push(&operPtr->args, arg);
+                break;
+            case TokenType_NamedDataPointer:
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                tok_str.data++;
+                tok_str.len--;
+                arg.type = ArgumentType_ConstDataPointer;
+                arg.value.data_name = tok_str;
+                List_Argument_push(&operPtr->args, arg);
+                break;
+            case TokenType_NamedDataSize:
+                tok_str = Compiler_constructTokenStr(cmp, tok);
+                tok_str.data++;
+                tok_str.len--;
+                arg.type = ArgumentType_ConstDataSize;
+                arg.value.data_name = tok_str;
+                List_Argument_push(&operPtr->args, arg);
+                break;
+        }
+    }
+}
+
+bool Compiler_parse(Compiler* cmp){
+    returnErrorIf_auto(cmp->state != CompilerState_Lexing);
+    cmp->state = CompilerState_Parsing;
+    Token tok;
+    Section* sec = NULL;
+    
+    while(cmp->tok_i < cmp->tokens.len){
+        tok = cmp->tokens.data[cmp->tok_i];
+        switch(tok.type){
+            case TokenType_Unset:
+                returnError(Error_TokenUnset);
+            case TokenType_SingleLineComment:
+            case TokenType_MultiLineComment:
+                // skip comments
+                break;
+            case TokenType_Label:
+                // create new section
+                sec = List_Section_expand(&cmp->ast.sections, 1);
+                Section_construct(sec, Compiler_constructTokenStr(cmp, tok));
+                break;
+            case TokenType_Instruction:
+                if(sec == NULL)
+                    returnError("no section");
+                str instr_name = Compiler_constructTokenStr(cmp, tok);
+                // data definition starts with const
+                if(str_startsWith(instr_name, STR("const"))){
+                    DataDefinition* dataDefPtr = List_DataDefinition_expand(&sec->data_definitions_list, 1);
+                    memset(dataDefPtr, 0, sizeof(DataDefinition));
+                    parseDataDefinition(cmp, instr_name, dataDefPtr);
+                }
+                else {
+                    Operation* operPtr = List_Operation_expand(&sec->operations_list, 1);
+                    memset(operPtr, 0, sizeof(Operation));
+                    parseOperation(cmp, instr_name, operPtr);
+                }
+                break;
+            default:
+                setError_unexpectedToken(tok);
+                return false;
+        }
+
+        if(cmp->state == CompilerState_Error)
+            return false;
+
+        cmp->tok_i++;
+    }
+
+    return true;
+}

src/compiler/Token.c

@@ -0,0 +1,24 @@
+#include "Token.h"
+
+Array_declare(str);
+
+static Array(str) _TokenType_str_array = ARRAY(str, {
+    STR("Unset"),
+    STR("SingleLineComment"),
+    STR("MultiLineComment"),
+    STR("Instruction"),
+    STR("Label"),
+    STR("Number"),
+    STR("Char"),
+    STR("String"),
+    STR("Name"),
+    STR("NamedDataPointer"),
+    STR("NamedDataSize"),
+    STR("OperationEnd"),
+});
+
+str TokenType_toString(TokenType t){
+    if(t >= _TokenType_str_array.len)
+        return STR("!!TokenType INDEX_ERROR!!");
+    return _TokenType_str_array.data[t];
+}

src/compiler/Token.h

@@ -0,0 +1,31 @@
+#pragma once
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+#include "tlibc/collections/List.h"
+
+typedef enum TokenType {
+    TokenType_Unset,                // initial value
+    TokenType_SingleLineComment,    // //comment
+    TokenType_MultiLineComment,     // /* comment */
+    TokenType_Instruction,          // abc
+    TokenType_Label,                // .abc:
+    TokenType_Number,               // 0123
+    TokenType_Char,                 // 'A'
+    TokenType_String,               // "aaaa"
+    TokenType_Name,                 // xyz
+    TokenType_NamedDataPointer,     // @xyz
+    TokenType_NamedDataSize,        // #xyz
+    TokenType_OperationEnd,         // EOL or EOF or ;
+} TokenType;
+
+str TokenType_toString(TokenType t);
+
+typedef struct Token {
+    u32 begin;          // some index in Compiler->code
+    u32 length : 24;    // length in characters (24 bits)
+    TokenType type : 8; // type of token (8 bits)
+} Token;
+
+List_declare(Token)
+
+#define Token_construct(TYPE, BEGIN, LEN) ((Token){ .type = TYPE, .begin = BEGIN, .length = LEN })

src/compiler/compiler.c

@@ -1,470 +0,0 @@
-#include "compiler.h"
-
-List_define(Token);
-
-CodePos Compiler_getLineAndColumn(Compiler* cmp, u32 pos){
-    u32 prev_lines_len = 0;
-    if(pos >= cmp->code_len)
-        return CodePos_create(0, 0);
-    
-    for(u32 i = 0; i < cmp->line_lengths.len; i++){
-        u32 line_len = cmp->line_lengths.data[i];
-        if(prev_lines_len + line_len > pos)
-            return CodePos_create(i + 1, pos + 1 - prev_lines_len);
-        prev_lines_len += line_len;
-    }
-
-    return CodePos_create(0, 0);
-}
-
-static void completeLine(Compiler* cmp){
-    List_u32_push(&cmp->line_lengths, cmp->column);
-    cmp->column = 0;
-}
-
-void _Compiler_setError(Compiler* cmp, cstr context, cstr format, ...){
-    completeLine(cmp);
-    // happens at the end of file
-    if(cmp->pos >= cmp->code_len)
-        cmp->pos = cmp->code_len - 1;
-    char position_str[32];
-    CodePos code_pos = Compiler_getLineAndColumn(cmp, cmp->pos);
-    sprintf(position_str, "[at %u:%u][", code_pos.line, code_pos.column);
-    char* real_format = strcat_malloc(position_str, context, "] ", format);
-    va_list argv;
-    va_start(argv, format);
-    char* NULLABLE(buf) = vsprintf_malloc(512, real_format, argv);
-    va_end(argv);
-    free(real_format);
-    if(buf == NULL){
-        buf = malloc(16);
-        strcpy(buf, "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(4096);
-    cmp->line_lengths = List_u32_alloc(1024);
-}
-
-void Compiler_free(Compiler* cmp){
-    free(cmp->code);
-    free(cmp->tokens.data);
-    free(cmp->line_lengths.data);
-}
-
-static void readCommentSingleLine(Compiler* cmp){
-    char c; // '/'
-    Token tok = Token_construct(TokenType_SingleLineComment, cmp->pos - 1, 0);
-    cmp->column++;
-    cmp->pos++;
-    
-    while(cmp->pos < cmp->code_len){
-        c = cmp->code[cmp->pos];
-        // end of line
-        if(c == '\r' || c == '\n'){
-            tok.length = cmp->pos - tok.begin;
-            List_Token_push(&cmp->tokens, tok);
-            // cmp->line will be increased in lex()
-            return;
-        }
-        
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    tok.length = cmp->pos - tok.begin;
-    List_Token_push(&cmp->tokens, tok);
-}
-
-static void readCommentMultiLine(Compiler* cmp){
-    char c; // '*'
-    Token tok = Token_construct(TokenType_MultiLineComment, cmp->pos - 1, 0);
-    cmp->column++;
-    cmp->pos++;
-    
-    while(cmp->pos < cmp->code_len){
-        c = cmp->code[cmp->pos];
-        // closing comment
-        if(cmp->pos > tok.begin + 3 && c == '/' && cmp->code[cmp->pos - 1] == '*') {
-            tok.length = cmp->pos - tok.begin + 1;
-            List_Token_push(&cmp->tokens, tok);
-            return;
-        }
-
-        if(c == '\n')
-            completeLine(cmp);
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    setError(Error_endOfFile);
-}
-
-static void readComment(Compiler* cmp){
-    char c; // '/'
-    if(cmp->pos + 1 == cmp->code_len){
-        setError(Error_endOfFile);
-        return;
-    }
-
-    c = cmp->code[cmp->pos + 1];
-    if(c == '\r' || c == '\n'){
-        setError(Error_unexpectedCharacter(cmp->code[--cmp->pos]));
-        return;
-    }
-
-    cmp->pos++;
-    cmp->column++;
-    if(c == '/')
-        readCommentSingleLine(cmp);
-    else if(c == '*')
-        readCommentMultiLine(cmp);
-    else setError(Error_unexpectedCharacter(c));
-}
-
-static void readLabel(Compiler* cmp){
-    char c; // '.'
-    cmp->pos++;
-    cmp->column++;
-    Token tok = Token_construct(TokenType_Label, cmp->pos, 0);
-    
-    while(cmp->pos < cmp->code_len){
-        c = cmp->code[cmp->pos];
-        // end of line
-        if(c == ':' || c == '\r' || c == '\n'){
-            tok.length = cmp->pos - tok.begin;
-            if(tok.length > 0)
-                List_Token_push(&cmp->tokens, tok);
-            else setError(Error_unexpectedCharacter(cmp->code[--cmp->pos]));
-            // cmp->line will be increased in lex()
-            return;
-        }
-
-        if(!isAlphabeticalLower(c) && !isAlphabeticalUpper(c) && !isDigit(c) &&
-            c != '_' && c != '.'){
-            setError(Error_unexpectedCharacter(c));
-            return;
-        }
-        
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    tok.length = cmp->pos - tok.begin;
-    if(tok.length > 0)
-        List_Token_push(&cmp->tokens, tok);
-    else setError(Error_endOfFile);
-}
-
-static void readArguments(Compiler* cmp){
-    char c; // space
-    cmp->pos++;
-    cmp->column++;
-    Token tok = Token_construct(TokenType_Argument, cmp->pos, 0);
-    
-    while(cmp->pos < cmp->code_len){
-        c = cmp->code[cmp->pos];
-        // end of line
-        if(c == '\r' || c == '\n' || c == ';'){
-            tok.length = cmp->pos - tok.begin;
-            if(tok.length > 0)
-                List_Token_push(&cmp->tokens, tok);
-            // cmp->line will be increased in lex()
-            return;
-        }
-
-        // new argument begins
-        if(c == ' ' || c == '\t'){
-            tok.length = cmp->pos - tok.begin;
-            if(tok.length > 0)
-                List_Token_push(&cmp->tokens, tok);
-            tok.begin = cmp->pos + 1;
-        }
-        
-
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    tok.length = cmp->pos - tok.begin;
-    if(tok.length > 0)
-        List_Token_push(&cmp->tokens, tok);
-}
-
-static void readInstruction(Compiler* cmp){
-    Token tok = Token_construct(TokenType_Instruction, cmp->pos, 0);
-    cmp->pos++;
-    cmp->column++;
-    
-    while(cmp->pos < cmp->code_len){
-        char c = cmp->code[cmp->pos];
-        // end of line
-        if(c == '\r' || c == '\n' || c == ';'){
-            tok.length = cmp->pos - tok.begin;
-            List_Token_push(&cmp->tokens, tok);
-            // cmp->line will be increased in lex()
-            return;
-        }
-
-        // arguments begin
-        if(c == ' ' || c == '\t'){
-            tok.length = cmp->pos - tok.begin;
-            List_Token_push(&cmp->tokens, tok);
-            readArguments(cmp);
-            return;
-        }
-
-        if(!isAlphabeticalLower(c) && !isAlphabeticalUpper(c) && !isDigit(c)){
-            setError(Error_unexpectedCharacter(c));
-            return;
-        }
-
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    tok.length = cmp->pos - tok.begin;
-    List_Token_push(&cmp->tokens, tok);
-}
-
-static void readChar(Compiler* cmp){
-    Token tok = Token_construct(TokenType_Char, cmp->pos, 0);
-    cmp->pos++;
-    cmp->column++;
-    
-    while(cmp->pos < cmp->code_len){
-        char c = cmp->code[cmp->pos];
-        // end of line
-        if(c == '\r' || c == '\n'){
-            setError(Error_unexpectedCharacter(cmp->code[--cmp->pos]));
-            return;
-        }
-
-        if(c == '\''){
-            tok.length = cmp->pos - tok.begin + 1;
-            List_Token_push(&cmp->tokens, tok);
-            return;
-        }
-
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    setError(Error_endOfFile);
-}
-
-static void readString(Compiler* cmp){
-    Token tok = Token_construct(TokenType_String, cmp->pos, 0);
-    cmp->pos++;
-    cmp->column++;
-    
-    while(cmp->pos < cmp->code_len){
-        char c = cmp->code[cmp->pos];
-        // end of line
-        if(c == '\r' || c == '\n'){
-            setError(Error_unexpectedCharacter(cmp->code[--cmp->pos]));
-            return;
-        }
-
-        if(c == '"'){
-            tok.length = cmp->pos - tok.begin + 1;
-            List_Token_push(&cmp->tokens, tok);
-            return;
-        }
-
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    setError(Error_endOfFile);
-}
-
-static void readNumber(Compiler* cmp){
-    Token tok = Token_construct(TokenType_Number, cmp->pos, 0);
-    cmp->pos++;
-    cmp->column++;
-    
-    while(cmp->pos < cmp->code_len){
-        char c = cmp->code[cmp->pos];
-
-        if(c == '\r' || c == '\n' || c == ' ' || c == '\t' || c == ',' || c == ';'){
-            tok.length = cmp->pos - tok.begin;
-            List_Token_push(&cmp->tokens, tok);
-            return;
-        }
-
-        cmp->column++;
-        cmp->pos++;
-    }
-    
-    // end of file
-    tok.length = cmp->pos - tok.begin;
-    List_Token_push(&cmp->tokens, tok);
-}
-
-static bool lex(Compiler* cmp){
-    returnErrorIf_auto(cmp->state != CompilerState_Initial);
-    cmp->state = CompilerState_Lexing;
-    cmp->column = 1;
-
-    while(cmp->pos < cmp->code_len){
-        char c = cmp->code[cmp->pos];
-        switch(c){
-            // skip blank characters
-            case ' ': case '\t': case '\r': case '\n':
-                break;
-            // try read comment
-            case '/':
-                readComment(cmp);
-                break;
-            // try read label
-            case '.':
-                readLabel(cmp);
-                break;
-            case '"':
-                readString(cmp);
-                break;
-            case '\'':
-                readChar(cmp);
-                break;
-            default:
-                // try read instruction
-                if(isAlphabeticalLower(c) || isAlphabeticalUpper(c))
-                    readInstruction(cmp);
-                else if(isDigit(c))
-                    readNumber(cmp);
-                else returnError(Error_unexpectedCharacter(c));
-                break;
-        }
-
-        if(cmp->state == CompilerState_Error)
-            return false;
-        
-        c = cmp->code[cmp->pos];
-        if(c == '\n')
-            completeLine(cmp);
-        cmp->column++;
-        cmp->pos++;
-    }
-
-    completeLine(cmp);
-    return true;
-}
-
-static bool parse(Compiler* cmp){
-    returnErrorIf_auto(cmp->state != CompilerState_Lexing);
-    cmp->state = CompilerState_Parsing;
-
-    return true;
-}
-static bool compile(Compiler* cmp, FILE* f){
-    returnErrorIf_auto(cmp->state != CompilerState_Parsing);
-    cmp->state = CompilerState_Compiling;
-
-    return true;
-}
-
-bool Compiler_compileTasm(Compiler* cmp, cstr source_file_name, cstr out_file_name, bool debug){
-    FILE* f = fopen(source_file_name, "rb");
-    if(f == NULL)
-        returnError("ERROR: can't open file '%s'", source_file_name);
-    
-    List_u8 buf = List_u8_alloc(64 * 1024);
-    int ret;
-    while((ret = fgetc(f)) != EOF) {
-        List_u8_push(&buf, ret);
-    }
-    if(ferror(f)){
-        free(buf.data);
-        fclose(f);
-        returnError("can't read file '%s'", source_file_name);
-    }
-    fclose(f);
-
-    if(buf.len == 0){
-        free(buf.data);
-        fclose(f);
-        returnError("soucre file is empty");
-    }
-
-    cmp->code = (char*)buf.data;
-    cmp->code_len = buf.len;
-    List_u8_push(&buf, 0);
-
-    f = fopen(out_file_name, "wb");
-    if(f == NULL){
-        free(buf.data);
-        returnError("ERROR: can't open file '%s'", out_file_name);
-    }
-
-    if(debug){
-        printf("----------------------------------[%s]---------------------------------\n", source_file_name);
-        fputs(cmp->code, stdout);
-        fputc('\n', stdout);
-    }
-    
-    bool success = lex(cmp);
-    if(debug){
-        printf("------------------------------------[lines]-----------------------------------\n");
-        for(u32 i = 0; i < cmp->line_lengths.len; i++){
-            printf("[%u] length: %u\n", i+1, cmp->line_lengths.data[i]);
-        }
-        printf("------------------------------------[tokens]-----------------------------------\n");
-        for(u32 i = 0; i < cmp->tokens.len; i++){
-            Token t = cmp->tokens.data[i];
-            CodePos pos = Compiler_getLineAndColumn(cmp, t.begin);
-            char* tokstr = malloc(4096);
-            strncpy(tokstr, cmp->code + t.begin, t.length);
-            tokstr[t.length] = 0;
-            printf("[l:%3u, c:%3u] %s '%s'\n", 
-                pos.line, pos.column,
-                TokenType_toString(t.type), tokstr);
-            free(tokstr);
-        }
-    }
-    if(!success){
-        fclose(f);
-        return false;
-    }
-
-    success = parse(cmp);
-    if(!success){
-        fclose(f);
-        return false;
-    }
-
-    success = compile(cmp, f);
-    fclose(f);
-    if(success){
-        cmp->state = CompilerState_Success;
-    }
-    
-    return success;
-}

src/compiler/compiler.h

@@ -1,47 +0,0 @@
-#pragma once
-#include "../std.h"
-#include "../collections/List.h"
-#include "token.h"
-
-List_declare(Token);
-
-typedef enum CompilerState {
-    CompilerState_Initial,
-    CompilerState_Lexing,
-    CompilerState_Parsing,
-    CompilerState_Compiling,
-    CompilerState_Error,
-    CompilerState_Success
-} CompilerState;
-
-typedef struct Compiler {
-    char* code;
-    u32 code_len;
-    u32 column;     // > 0 if code parsing started
-    u32 pos;
-    CompilerState state;
-    NULLABLE(char* error_message);
-    List_Token tokens;
-    List_u32 line_lengths;
-} 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, cstr source_file_name, cstr out_file_name, bool debug);
-
-#define Compiler_setError(cmp, format, ...) _Compiler_setError(cmp, __func__, format ,##__VA_ARGS__)
-void _Compiler_setError(Compiler* cmp, cstr context, cstr format, ...) __attribute__((__format__(__printf__, 3, 4)));
-
-typedef struct CodePos {
-    u32 line; // 0 on error
-    u32 column; // 0 on error
-} CodePos;
-
-#define CodePos_create(L, C) ((CodePos){ .line = L, .column = C })
-
-/// @param pos index in code buffer
-CodePos Compiler_getLineAndColumn(Compiler* cmp, u32 pos);
-

src/compiler/token.c

@@ -1,19 +0,0 @@
-#include "token.h"
-
-static cstr _TokenType_str[] = {
-    "Unset",
-    "SingleLineComment",
-    "MultiLineComment",
-    "Label",
-    "Instruction",
-    "Argument",
-    "Number",
-    "Char",
-    "String",
-};
-
-cstr TokenType_toString(TokenType t){
-    if(t >= sizeof(_TokenType_str) / sizeof(cstr))
-        return "!!INDEX_ERROR!!";
-    return _TokenType_str[t];
-}

src/compiler/token.h

@@ -1,24 +0,0 @@
-#pragma once
-#include "../std.h"
-
-typedef enum TokenType {
-    TokenType_Unset,
-    TokenType_SingleLineComment,
-    TokenType_MultiLineComment,
-    TokenType_Label,
-    TokenType_Instruction,
-    TokenType_Argument,
-    TokenType_Number,
-    TokenType_Char,
-    TokenType_String,
-} TokenType;
-
-cstr TokenType_toString(TokenType t);
-
-typedef struct Token {
-    u32 begin;          // some index in Compiler->code
-    u32 length : 24;    // length in characters (24 bits)
-    TokenType type : 8; // type of token (8 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/JMP.c

@@ -0,0 +1,36 @@
+#include "impl_macros.h"
+
+// JUMP [destination address]
+i32 JMP_impl(VM* vm){
+    u64 dst_addr = 0;
+    readVar(dst_addr);
+
+    vm->current_pos = dst_addr;
+
+    return sizeof(dst_addr);
+}
+
+
+// JNZ [destination address]
+i32 JNZ_impl(VM* vm){
+    u64 dst_addr = 0;
+    readVar(dst_addr);
+    
+    if(vm->flags.cmp != 0){
+        vm->current_pos = dst_addr;
+    }
+    
+    return sizeof(dst_addr);
+}
+
+// JZ [destination address]
+i32 JZ_impl(VM* vm){
+    u64 dst_addr = 0;
+    readVar(dst_addr);
+
+    if(vm->flags.cmp == 0){
+        vm->current_pos = dst_addr;
+    }
+    
+    return sizeof(dst_addr);
+}

src/instructions/impl/MOV.c

@@ -1,16 +0,0 @@
-#include "impl_macros.h"
-
-/// MOV [dst_register] [src_register]
-i32 MOV_impl(VM* vm){
-    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);
-        return -1;
-    }
-
-    vm->registers[dst_register_i].u32v = vm->registers[src_register_i].u32v;
-    return sizeof(dst_register_i) + sizeof(src_register_i);
-}

src/instructions/impl/MOVC.c

@@ -0,0 +1,12 @@
+#include "impl_macros.h"
+
+/// MOVC [dst_register] [value_size] [value]
+i32 MOVC_impl(VM* vm){
+    RegisterCode dst_reg_code = 0;
+    readRegisterCode(dst_reg_code);
+    u64 const_value = 0;
+    readVar(const_value);
+    
+    VM_registerWrite(vm, &const_value, dst_reg_code);
+    return sizeof(dst_reg_code) + sizeof(const_value);
+}

src/instructions/impl/MOVR.c

@@ -0,0 +1,17 @@
+#include "impl_macros.h"
+
+/// MOVR [dst_register] [src_register]
+i32 MOVR_impl(VM* vm){
+    RegisterCode dst_reg_code = 0, src_reg_code = 0;
+    readRegisterCode(dst_reg_code);
+    readRegisterCode(src_reg_code);
+    if(dst_reg_code == src_reg_code){
+        VM_setError(vm, "dst_reg_code == src_reg_code (%x) ", src_reg_code);
+        return -1;
+    }
+
+    u64 src_reg_value = 0;
+    VM_registerRead(vm, &src_reg_value, src_reg_code);
+    VM_registerWrite(vm, &src_reg_value, dst_reg_code);
+    return sizeof(dst_reg_code) + sizeof(src_reg_code);
+}

src/instructions/impl/NOP.c

@@ -2,5 +2,6 @@
 
 /// NOP
 i32 NOP_impl(VM* vm){
+    (void)vm;
     return 0;
 }

src/instructions/impl/PUSH.c

@@ -1,16 +0,0 @@
-#include "impl_macros.h"
-
-/// PUSH [dst_register] [value_size] [value]
-i32 PUSH_impl(VM* vm){
-    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))
-        return -1;
-    vm->current_pos += value_size;
-
-    return sizeof(dst_register_i) + sizeof(value_size) + value_size;
-}

src/instructions/impl/SYS.c

@@ -1,6 +1,6 @@
 #include "impl_macros.h"
 
-FILE* NULLABLE(fileFromN)(VM* vm, u32 file_n){
+FILE* NULLABLE(fileFromN)(VM* vm, u8 file_n){
     FILE* f = NULL;
     switch(file_n){
         case 0: f = stdin; break;
@@ -15,13 +15,13 @@ FILE* NULLABLE(fileFromN)(VM* vm, u32 file_n){
 }
 
 // sys_read
-// bx - file n
+// ah - file n
-// cx - buffer ptr
+// rbx - buffer ptr
-// dx - buffer size
+// ecx - buffer size
 i32 SYS_read(VM* vm){
-    const u32 file_n = vm->bx.u32v;
+    const u8 file_n = vm->registers.a.h;
-    u8* const buf = vm->data + vm->cx.u32v;
+    u8* const buf = vm->data + vm->registers.b.rx;
-    const u32 size = vm->dx.u32v;
+    const u32 size = vm->registers.c.ex;
 
     if(buf + size > vm->data + vm->data_size)
         return 40;
@@ -31,13 +31,13 @@ i32 SYS_read(VM* vm){
 }
 
 // sys_write
-// bx - file n
+// ah - file n
-// cx - buffer ptr
+// rbx - buffer ptr
-// dx - buffer size
+// ecx - buffer size
 i32 SYS_write(VM* vm){
-    const u32 file_n = vm->bx.u32v;
+    const u8 file_n = vm->registers.a.h;
-    u8* const buf = vm->data + vm->cx.u32v;
+    u8* const buf = vm->data + vm->registers.b.rx;
-    const u32 size = vm->dx.u32v;
+    const u32 size = vm->registers.c.ex;
 
     if(buf + size > vm->data + vm->data_size)
         return 41;
@@ -47,16 +47,16 @@ i32 SYS_write(VM* vm){
 }
 
 /// SYS
-/// before call: ax - func code
+/// before call: al - func code
-/// after  call: ax - result code
+/// after  call: eax - result code
 i32 SYS_impl(VM* vm){
-    u8 func_code = vm->ax.u8v0;
+    u8 func_code = vm->registers.a.l;
-    u32 result_code = 0;
+    i32 result_code = 0;
     switch(func_code){
         case 0:
             result_code = SYS_read(vm);
             break;
-        case 1:;
+        case 1:
             result_code = SYS_write(vm);
             break;
         default:
@@ -64,6 +64,6 @@ i32 SYS_impl(VM* vm){
             return -1;
     }
 
-    vm->ax.u32v = result_code;
+    vm->registers.a.ex = result_code;
     return 0;
 }

src/instructions/impl/impl_macros.h

@@ -1,5 +1,6 @@
 #pragma once
-#include "../instructions.h"
+#include "instructions/instructions.h"
+#include "instructions/registers.h"
 
 #define readVar(VAR) {\
     if(!VM_dataRead(vm, &VAR, vm->current_pos, sizeof(VAR))) \
@@ -7,26 +8,52 @@
     vm->current_pos += sizeof(VAR);\
 }
 
-#define validateRegisterIndex(VAR) {\
+#define validateRegisterCode(VAR) \
-    if(VAR > sizeof(vm->registers)){\
+    if(VAR == RegisterCode_Unset || VAR > RegisterCode_dh){\
         VM_setError(vm, "invalid register index (%x)", VAR);\
         return -1;\
-    }\
+    }
-}
 
-#define readRegisterVar(VAR) {\
+#define readRegisterCode(VAR) {\
     readVar(VAR);\
-    validateRegisterIndex(VAR);\
+    validateRegisterCode(VAR);\
 }
 
-#define validateValueSize(VAR) {\
+#define OPERATOR_IMPL_1(NAME, OPERATOR)\
-    if(VAR < 1 || VAR > 4){\
+i32 NAME##_impl (VM* vm) {\
-        VM_setError(vm, "invalid value_size (%x)", VAR);\
+    RegisterCode dst_reg_code = 0;\
-        return -1;\
+    readRegisterCode(dst_reg_code);\
-    }\
+    u64 dst_reg_value = 0;\
+    VM_registerRead(vm, &dst_reg_value, dst_reg_code);\
+    \
+    dst_reg_value = OPERATOR dst_reg_value;\
+    VM_registerWrite(vm, &dst_reg_value, dst_reg_code);\
+    return sizeof(dst_reg_code);\
 }
 
-#define readValueSizeVar(VAR) {\
+#define OPERATOR_IMPL_2(NAME, OPERATOR)\
-    readVar(VAR);\
+i32 NAME##_impl (VM* vm) {\
-    validateValueSize(VAR);\
+    RegisterCode dst_reg_code = 0, src_reg_code = 0;\
+    readRegisterCode(dst_reg_code);\
+    readRegisterCode(src_reg_code);\
+    u64 dst_reg_value = 0, src_reg_value = 0;\
+    VM_registerRead(vm, &dst_reg_value, dst_reg_code);\
+    VM_registerRead(vm, &src_reg_value, src_reg_code);\
+    \
+    dst_reg_value = dst_reg_value OPERATOR src_reg_value;\
+    VM_registerWrite(vm, &dst_reg_value, dst_reg_code);\
+    return sizeof(dst_reg_code) + sizeof(src_reg_code);\
+}
+
+#define OPERATOR_IMPL_CMP_FLAG(NAME, OPERATOR)\
+i32 NAME##_impl (VM* vm) {\
+    RegisterCode src0_reg_code = 0, src1_reg_code = 0;\
+    readRegisterCode(src0_reg_code);\
+    readRegisterCode(src1_reg_code);\
+    u64 src0_reg_value = 0, src1_reg_value = 0;\
+    VM_registerRead(vm, &src0_reg_value, src0_reg_code);\
+    VM_registerRead(vm, &src1_reg_value, src1_reg_code);\
+    \
+    vm->flags.cmp = src0_reg_value OPERATOR src1_reg_value;\
+    return sizeof(src0_reg_code) + sizeof(src1_reg_code);\
 }

src/instructions/impl/logical_operators.c

@@ -0,0 +1,36 @@
+#include "impl_macros.h"
+
+/// NOT [dst_register]
+OPERATOR_IMPL_1(NOT, !)
+
+/// INV [dst_register]
+OPERATOR_IMPL_1(INV, ~)
+
+
+/// OR [dst_register] [src_register]
+OPERATOR_IMPL_2(OR, |)
+
+/// XOR [dst_register] [src_register]
+OPERATOR_IMPL_2(XOR, ^)
+
+/// AND [dst_register] [src_register]
+OPERATOR_IMPL_2(AND, &)
+
+
+/// EQ [src0_register] [src1_register]
+OPERATOR_IMPL_CMP_FLAG(EQ, ==)
+
+/// NE [src0_register] [src1_register]
+OPERATOR_IMPL_CMP_FLAG(NE, !=)
+
+/// LT [src0_register] [src1_register]
+OPERATOR_IMPL_CMP_FLAG(LT, <)
+
+/// LE [src0_register] [src1_register]
+OPERATOR_IMPL_CMP_FLAG(LE, <=)
+
+/// GT [src0_register] [src1_register]
+OPERATOR_IMPL_CMP_FLAG(GT, >)
+
+/// GE [src0_register] [src1_register]
+OPERATOR_IMPL_CMP_FLAG(GE, >=)

src/instructions/impl/math_operators.c

@@ -1,47 +1,16 @@
 #include "impl_macros.h"
 
-#define mathOperatorImpl(OPERATOR){\
-    u8 dst_register_i = 0, src_register_i = 0;\
-    readRegisterVar(dst_register_i);\
-    readRegisterVar(src_register_i);\
-    u8 value_size = 0;\
-    readValueSizeVar(value_size);\
-    \
-    switch(value_size){\
-        case 1: \
-            vm->registers[dst_register_i].u8v0 OPERATOR##= vm->registers[src_register_i].u8v0;\
-            break;\
-        case 2: \
-            vm->registers[dst_register_i].u16v0 OPERATOR##= vm->registers[src_register_i].u16v0;\
-            break;\
-        case 4: \
-            vm->registers[dst_register_i].u32v OPERATOR##= vm->registers[src_register_i].u32v;\
-            break;\
-    }\
-    return sizeof(dst_register_i) + sizeof(src_register_i) + sizeof(value_size);\
-}
-
 /// ADD [dst_register] [src_register]
-i32 ADD_impl(VM* vm){
+OPERATOR_IMPL_2(ADD, +)
-    mathOperatorImpl(+);
-}
 
 /// SUB [dst_register] [src_register]
-i32 SUB_impl(VM* vm){
+OPERATOR_IMPL_2(SUB, -)
-    mathOperatorImpl(-);
-}
 
 /// MUL [dst_register] [src_register]
-i32 MUL_impl(VM* vm){
+OPERATOR_IMPL_2(MUL, *)
-    mathOperatorImpl(*)
-}
 
 /// DIV [dst_register] [src_register]
-i32 DIV_impl(VM* vm){
+OPERATOR_IMPL_2(DIV, /)
-    mathOperatorImpl(/)
-}
 
 /// MOD [dst_register] [src_register]
-i32 MOD_impl(VM* vm){
+OPERATOR_IMPL_2(MOD, %)
-    mathOperatorImpl(%)
-}

src/instructions/instructions.c

@@ -1,24 +1,102 @@
 #include "instructions.h"
+#include "tlibc/collections/HashMap.h"
 
-const Instruction instructions[] = {
+i32 NOP_impl(VM* vm);
+i32 EXIT_impl(VM* vm);
+i32 SYS_impl(VM* vm);
+
+i32 MOVC_impl(VM* vm);
+i32 MOVR_impl(VM* vm);
+
+i32 ADD_impl(VM* vm);
+i32 SUB_impl(VM* vm);
+i32 MUL_impl(VM* vm);
+i32 DIV_impl(VM* vm);
+i32 MOD_impl(VM* vm);
+
+i32 EQ_impl(VM* vm);
+i32 NE_impl(VM* vm);
+i32 LT_impl(VM* vm);
+i32 LE_impl(VM* vm);
+i32 GT_impl(VM* vm);
+i32 GE_impl(VM* vm);
+i32 NOT_impl(VM* vm);
+i32 INV_impl(VM* vm);
+i32 OR_impl(VM* vm);
+i32 XOR_impl(VM* vm);
+i32 AND_impl(VM* vm);
+
+i32 JMP_impl(VM* vm);
+i32 JNZ_impl(VM* vm);
+i32 JZ_impl(VM* vm);
+
+Array_declare(Instruction);
+
+static const Array(Instruction) instructions_array = ARRAY(Instruction, {
     Instruction_construct(NOP),
-    Instruction_construct(PUSH),
+    Instruction_construct(EXIT),
-    Instruction_construct(MOV),
+    Instruction_construct(SYS),
+
+    Instruction_construct(MOVC),
+    Instruction_construct(MOVR),
+    
     Instruction_construct(ADD),
     Instruction_construct(SUB),
     Instruction_construct(MUL),
     Instruction_construct(DIV),
     Instruction_construct(MOD),
-    Instruction_construct(SYS),
-    Instruction_construct(EXIT),
-    // Instruction_construct(JMP),
-    // Instruction_construct(CALL),
-};
-const size_t instructions_count = sizeof(instructions)/sizeof(instructions[0]);
 
-const Instruction* NULLABLE(Instruction_getFromOpcode)(u8 opcode){
+    Instruction_construct(EQ),
-    if(opcode >= instructions_count)
+    Instruction_construct(NE),
+    Instruction_construct(LT),
+    Instruction_construct(LE),
+    Instruction_construct(GT),
+    Instruction_construct(GE),
+    Instruction_construct(NOT),
+    Instruction_construct(INV),
+    Instruction_construct(OR),
+    Instruction_construct(XOR),
+    Instruction_construct(AND),
+    
+    Instruction_construct(JMP),
+    Instruction_construct(JNZ),
+    Instruction_construct(JZ),
+});
+
+const Instruction* Instruction_getByOpcode(Opcode opcode){
+    if((u32)opcode >= instructions_array.len)
         return NULL;
     
-    return instructions + opcode;
+    return (Instruction*)instructions_array.data + opcode;
+}
+
+
+static HashMap(Opcode)* opcode_map = NULL;
+
+static void _opcode_map_construct(){
+    opcode_map = malloc(sizeof(*opcode_map));
+    HashMap_construct(opcode_map, Opcode, NULL);
+    for(u32 i = 0; i < instructions_array.len; i++){
+        Instruction* instr_ptr = (Instruction*)instructions_array.data + i;
+        HashMap_tryPush(opcode_map, instr_ptr->name, &instr_ptr->opcode);
+    }
+}
+
+const Instruction* Instruction_getByName(str name){
+    if(opcode_map == NULL)
+        _opcode_map_construct();
+
+    str name_upper = str_toUpper(name);
+    Opcode* op_ptr = HashMap_tryGetPtr(opcode_map, name_upper);
+    str_destroy(name_upper);
+    if(op_ptr == NULL)
+        return NULL;
+    return Instruction_getByOpcode(*op_ptr);
+}
+
+void Instruction_destroySearchStructs(){
+    if(opcode_map != NULL){
+        HashMap_destroy(opcode_map);
+        free(opcode_map);
+    }
 }

src/instructions/instructions.h

@@ -1,34 +1,56 @@
 #pragma once
-#include "../VM/VM.h"
+#include "VM/VM.h"
 
 ///@param program_pos position in vm->program next afrer opcode
 ///@returns number of bytes read
 typedef i32 (*InstructionImplFunc_t)(VM* vm);
 
+typedef enum __attribute__((__packed__)) Opcode {
+    Opcode_NOP,
+    Opcode_EXIT,
+    Opcode_SYS,
+
+    Opcode_MOVC,
+    Opcode_MOVR,
+
+    Opcode_ADD,
+    Opcode_SUB,
+    Opcode_MUL,
+    Opcode_DIV,
+    Opcode_MOD,
+
+    Opcode_EQ,
+    Opcode_NE,
+    Opcode_LT,
+    Opcode_LE,
+    Opcode_GT,
+    Opcode_GE,
+    Opcode_NOT,
+    Opcode_INV,
+    Opcode_OR,
+    Opcode_XOR,
+    Opcode_AND,
+    
+    Opcode_JMP,
+    Opcode_JNZ,
+    Opcode_JZ,
+} Opcode;
+
 typedef struct Instruction {
-    cstr name;
+    str name;
     InstructionImplFunc_t implementation;
+    Opcode opcode;
 } Instruction;
 
 #define Instruction_construct(NAME) {\
-    .name = #NAME, \
+    .name = STR(#NAME), \
-    .implementation = NAME##_impl \
+    .implementation = NAME##_impl, \
+    .opcode = Opcode_##NAME\
 }
 
 /// @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* NULLABLE(Instruction_getByOpcode)(Opcode opcode);
-
+const Instruction* NULLABLE(Instruction_getByName)(str name);
-i32 NOP_impl(VM* vm);
+void Instruction_destroySearchStructs();
-i32 PUSH_impl(VM* vm);
-i32 MOV_impl(VM* vm);
-i32 ADD_impl(VM* vm);
-i32 SUB_impl(VM* vm);
-i32 MUL_impl(VM* vm);
-i32 DIV_impl(VM* vm);
-i32 MOD_impl(VM* vm);
-i32 SYS_impl(VM* vm);
-i32 EXIT_impl(VM* vm);
-i32 JMP_impl(VM* vm);
-i32 CALL_impl(VM* vm);

src/instructions/registers.c

@@ -0,0 +1,76 @@
+#include "registers.h"
+
+#define check_code(R) if(str_equals(lower, STR(#R))) code = RegisterCode_##R;
+
+RegisterCode RegisterCode_parse(str r){
+    str lower = str_toLower(r);
+    RegisterCode code = RegisterCode_Unset;
+    // a
+    check_code(rax)
+    else check_code(eax)
+    else check_code(ax)
+    else check_code(al)
+    else check_code(ah)
+    // b
+    else check_code(rbx)
+    else check_code(ebx)
+    else check_code(bx)
+    else check_code(bl)
+    else check_code(bh)
+    // c
+    else check_code(rcx)
+    else check_code(ecx)
+    else check_code(cx)
+    else check_code(cl)
+    else check_code(ch)
+    //d
+    else check_code(rdx)
+    else check_code(edx)
+    else check_code(dx)
+    else check_code(dl)
+    else check_code(dh)
+
+    str_destroy(lower);
+    return code;
+}
+
+str RegisterCode_toString(RegisterCode code){
+    char buf[3] = { '?', 'a', 'x' };
+    u8 index = code / 0x10;
+    switch(index){
+        default:
+            return str_copy(STR("!!! ERROR: invalid RegisterCode !!!"));
+        case 0:
+        case 1:
+        case 2:
+        case 3:
+            buf[1] += index;
+            break;
+    }
+
+    str buf_str = str_construct(buf, 3, false);
+    switch(code & 0xf){
+        default:
+            return str_copy(STR("!!! ERROR: invalid RegisterCode !!!"));
+        case 1:
+            buf_str.data[0] = 'r';
+            break;
+        case 2:
+            buf_str.data[0] = 'e';
+            break;
+        case 4:
+            buf_str.data += 1;
+            buf_str.len -= 1;
+            break;
+        case 7:
+            buf_str.data[0] = 'l';
+            buf_str.len -= 1;
+            break;
+        case 8:
+            buf_str.data[0] = 'h';
+            buf_str.len -= 1;
+            break;
+    }
+
+    return str_copy(buf_str);
+}

src/instructions/registers.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "tlibc/std.h"
+#include "tlibc/string/str.h"
+
+typedef enum RegisterCode {
+    RegisterCode_Unset = 0,
+
+    RegisterCode_rax = 0x01,
+    RegisterCode_eax = 0x02,
+    RegisterCode_ax = 0x04,
+    RegisterCode_al = 0x07,
+    RegisterCode_ah = 0x08,
+
+    RegisterCode_rbx = 0x11,
+    RegisterCode_ebx = 0x12,
+    RegisterCode_bx = 0x14,
+    RegisterCode_bl = 0x17,
+    RegisterCode_bh = 0x18,
+
+    RegisterCode_rcx = 0x21,
+    RegisterCode_ecx = 0x22,
+    RegisterCode_cx = 0x24,
+    RegisterCode_cl = 0x27,
+    RegisterCode_ch = 0x28,
+
+    RegisterCode_rdx = 0x31,
+    RegisterCode_edx = 0x32,
+    RegisterCode_dx = 0x34,
+    RegisterCode_dl = 0x37,
+    RegisterCode_dh = 0x38,
+} __attribute__((__packed__)) RegisterCode;
+
+RegisterCode RegisterCode_parse(str register_name);
+/// @return allocated string
+str RegisterCode_toString(RegisterCode code);

src/main.c

@@ -1,11 +1,13 @@
 #include "VM/VM.h"
 #include "instructions/instructions.h"
-#include "collections/List.h"
+#include "compiler/Compiler.h"
-#include "compiler/compiler.h"
+#include "VM/Display/Display.h"
+#include "tcpu_version.h"
+#include "tlibc/time.h"
 
-#define arg_is(STR) (strcmp(argv[argi], STR) == 0)
+#define arg_is(LITERAL) str_equals(arg_str, STR(LITERAL))
 
-i32 compileSources(cstr source_file, cstr out_file);
+i32 compileSources(cstr source_file, cstr out_file, bool debug_log);
 i32 bootFromImage(cstr image_file);
 
 i32 main(const i32 argc, cstr* argv){
@@ -21,21 +23,27 @@ i32 main(const i32 argc, cstr* argv){
     cstr NULLABLE(out_file) = NULL;
     cstr NULLABLE(source_file) = NULL;
 
+    bool debug_log = false;
+    bool video_enabled = false;
+
     for(i32 argi = 1; argi < argc; argi++){
+        str arg_str = str_from_cstr(argv[argi]);
         if(arg_is("-h") || arg_is("--help")){
             printf(
                 "-h, --help                                 Show this message.\n"
+                "-d, --debug                                Enable debug log.\n"
                 "-op, --opcodes                             Show list of all instructions.\n"
-                "-i, --image [FILE]                         Boot VM using image file.\n"
                 "-c, --compile [SOURCE_FILE] [OUT_FILE]     Compile assembly source files to machine code.\n"
+                "-i, --image [FILE]                         Boot VM using image file.\n"
+                "--video                                    Enable VM display.\n"
             );
             return 0;
         }
         else if(arg_is("-op") || arg_is("--opcodes")){
             for(u8 opcode = 0; opcode < 255; opcode++){
-                const Instruction* instr = Instruction_getFromOpcode(opcode);
+                const Instruction* instr = Instruction_getByOpcode(opcode);
                 if(instr != NULL){
-                    printf("%02X %s\n", opcode, instr->name);
+                    printf("%02X %s\n", opcode, instr->name.data);
                 }
             }
             return 0;
@@ -72,6 +80,13 @@ i32 main(const i32 argc, cstr* argv){
             }
             out_file = argv[argi];
         }
+        else if(arg_is("-d") || arg_is("--debug")){
+            debug_log = true;
+        }
+        else if(arg_is("--video")){
+            video_enabled = true;
+        }
+
         else {
             printfe("ERROR: unknown argument '%s'\n", argv[argi]);
             return 1;
@@ -80,12 +95,26 @@ i32 main(const i32 argc, cstr* argv){
 
     i32 exit_code = 0;
     if(compile){
-        exit_code = compileSources(source_file, out_file);
+        exit_code = compileSources(source_file, out_file, debug_log);
+        if(exit_code != 0)
+            goto main_exit;
     }
-    if(exit_code == 0 && boot){
+
+    if(boot){
+        printfe("TCPU version: " TCPU_VERSION_CSTR "\n");
+        if(video_enabled){
+            printfe("video enabled\n");
+            if(!Display_init(1600, 900, DisplayFlags_Default)){
+                printfe("DISPLAY ERROR: %s\n", Display_getError());
+                return 1;
+            }
+        }
         exit_code = bootFromImage(image_file);
     }
 
+    // frees global variables to supress valgrind memory leak errors
+main_exit:
+    Instruction_destroySearchStructs();
     return exit_code;
 }
 
@@ -109,11 +138,14 @@ i32 bootFromImage(cstr image_file){
     }
 
     VM vm;
-    VM_init(&vm);
+    VM_construct(&vm);
 
     i32 exit_code = 1;
     if(VM_setMemory(&vm, vm_memory, bytes_read)){
+        printf("===============================================================================\n");
         exit_code = VM_boot(&vm);
+        printf("===============================================================================\n");
+        printfe("VM stopped with code %i\n", exit_code);
     }
     if(vm.state == VMState_InternalError){
         if(vm.error_message){
@@ -123,27 +155,24 @@ i32 bootFromImage(cstr image_file){
         else printfe("VM ERROR: unknown (error_message is null)\n");
     }
     
-    if(exit_code != 0){
-        printfe("program exited with code %i\n", exit_code);
-    }
-
     free(vm_memory);
     return exit_code;
 }
 
-i32 compileSources(cstr source_file, cstr out_file){
+i32 compileSources(cstr source_file, cstr out_file, bool debug_log){
     Compiler cmp;
-    Compiler_init(&cmp);
+    Compiler_construct(&cmp);
-    bool success = Compiler_compileTasm(&cmp, source_file, out_file, true);
+    bool success = Compiler_compile(&cmp, source_file, out_file, debug_log);
-    Compiler_free(&cmp);
     if(!success){
         if(cmp.error_message){
             printfe("COMPILER ERROR: %s\n", cmp.error_message);
             free(cmp.error_message);
         }
         else printfe("COMPILER ERROR: unknown (error_message is null)\n");
+        Compiler_destroy(&cmp);
         return 111;
     }
-
+    
+    Compiler_destroy(&cmp);
     return 0;
 }

src/std.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <time.h>
-#include <math.h>
-#include <string.h>
-
-typedef int8_t i8;
-typedef uint8_t u8;
-typedef int16_t i16;
-typedef uint16_t u16;
-typedef int32_t i32;
-typedef uint32_t u32;
-typedef int64_t i64;
-typedef uint64_t u64;
-typedef float f32;
-typedef double f64;
-
-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, cstr str0, ...);
-char* _vstrcat_malloc(size_t n, cstr str0, va_list argv);
-
-char* NULLABLE(sprintf_malloc)(size_t buffer_size, cstr format, ...) __attribute__((__format__(__printf__, 2, 3)));
-char* NULLABLE(vsprintf_malloc)(size_t buffer_size, cstr format, va_list argv);
-
-static inline bool isAlphabeticalLower(char c) { return 'a' <= c && c <= 'z'; }
-static inline bool isAlphabeticalUpper(char c) { return 'A' <= c && c <= 'Z'; }
-static inline bool isDigit(char c) { return '0' <= c && c <= '9'; }

src/tcpu_version.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#define TCPU_VERSION_CSTR "1.0.0"