Init, todo lexer and parser

Author: JohnAlexINL

.gitignore

@@ -0,0 +1,2 @@
+out/*
+include/*

LICENSE

@@ -0,0 +1,2 @@
+# bytes license LICENSE const/license.h
+gcc -o out/gasm gasm.c -static

build

@@ -0,0 +1,3 @@
+mkdir -p include
+wget -O ./include/libgyb.h https://raw.githubusercontent.com/Modula-dev/gyb/refs/heads/main/lib/libgyb.h
+wget -O ./include/libgyb.c https://raw.githubusercontent.com/Modula-dev/gyb/refs/heads/main/lib/libgyb.c

clone

@@ -0,0 +1,60 @@
+#define argtype_instruction 'I' // USED BY LEXER ONLY
+#define argtype_register    'R'
+#define argtype_label       'L'
+#define argtype_address     'A'
+#define argtype_constant    'C'
+#define argtype_any         '*'
+#define argtype_optional    '?'
+
+typedef struct {
+    unsigned char args[6]; // NULL terminated list
+    char name[10];
+} operation_t;
+
+const operation_t operations[255] = {
+    [0x80] = { "RRRR\0", "interrupt" },
+    [0x81] = { "****\0", "syscall" },
+    [0xA0] = { "RR\0", "compare" },
+    [0xA1] = { "RR\0", "add" },
+    [0xA2] = { "RR\0", "sub" },
+    [0xA3] = { "RR\0", "mul" },    // x86: mul cl
+    [0xA4] = { "RR\0", "div" },    // x86: div cl
+    [0xA5] = { "RR\0", "left" },   // x86: shl cl
+    [0xA6] = { "RR\0", "right" },  // x86: shr cl
+    [0xA7] = { "RR\0", "and" },
+    [0xA8] = { "RR\0", "or" },
+    [0xA9] = { "RR\0", "xor" },
+    [0xAA] = { "R\0", "flip" },
+    [0xA5] = { "R\0", "inc"},
+    [0xA6] = { "R\0", "dec"},
+    [0x50] = { "R\0", "push" },
+    [0x51] = { "R\0", "pop" },
+    [0xBF] = { "L\0", "goto" },
+    [0xB1] = { "L\0", "if" },
+    [0xB2] = { "L\0", "not" },
+    [0xB3] = { "L\0", "lt" },
+    [0xB4] = { "L\0", "gt" },
+    [0xB5] = { "L\0", "le" },
+    [0xB6] = { "L\0", "ge" },
+    [0xF8] = { "R\0", "fcast" },   // cvttss2si rax, xmm0
+    [0xF9] = { "R\0", "icast" },   // cvtsi2sd xmm0, rax
+    [0xFA] = { "R\0", "fmov" },
+    [0xFB] = { "R\0", "imov" },    // movd xmm0, rax
+    [0xF1] = { "RR\0", "fadd" },   // addsd
+    [0xF2] = { "RR\0", "fsub" },   // subsd
+    [0xF3] = { "RR\0", "fmul" },   // mulsd
+    [0xF4] = { "RR\0", "fdiv" },   // divsd
+    [0x90] = { "RR\0", "move"},    // mov
+    [0x91] = { "RA\0", "load"},    // mov
+    [0x92] = { "RA\0", "store"},   // mov
+    [0x93] = { "RC\0", "immediate"}// mov
+};
+
+const char registernames[][3] = {
+    "ar\0",
+    "br\0",
+    "cr\0",
+    "dr\0",
+    "sr\0", // stack pointer
+    "sb\0" // stack base pointer
+};

const/license.h

@@ -0,0 +1,48 @@
+#define GPLV3Link "https://www.gnu.org/licenses/gpl-3.0.en.html"
+#define copyright "Copyright (c) 2025 Modula.dev"
+#define version "gasm 0.0.0\n"
+
+const char contributors[] = "\
+John Alex (Modula) <Modula.dev>\n";
+
+const char notice[] = version copyright "\n\
+This program is free software: you can redistribute it and/or modify\n\
+it under the terms of the GNU General Public License as published by\n\
+the Free Software Foundation, only under version 3 of this license.\n\n\
+This program is distributed in the hope that it will be useful,\n\
+but WITHOUT ANY WARRANTY; without even the implied warranty of\n\
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n";
+
+const char help[] = version "\
+\e[0;34mSYNOPSIS\e[0m\n\
+\e[0;32m\
+    gasm <dest> [sources]\n\
+    gasm license\n\
+\e[0;34mDESCRIPTION\e[0m\n\
+\e[0;32m\
+    creates garter bytecode from garter assembly code\n\
+\e[0;34mLICENSE\e[0m\n\
+\e[0;32m\
+    GPLv3, \
+\e[0;35m" GPLV3Link "\n\
+\e[0m\
+    Put briefly; you may redistribute and/or modify this software\n\
+    under the terms of the GPLv3 License as published by \n\
+    the Free Software Foundation if and only if \n\
+    the license and our copyright notice is included:\n\
+    \e[0;31m\"" copyright "\"\
+\e[0m\n\0";
+
+#define ERROR "\e[0;31merror:\e[0m"
+#define HELPCMD "\e[0;32mgasm help\e[0m"
+
+const char cmd_help[] = "help";
+const char cmd_version[] = "version";
+const char cmd_license[] = "license";
+const char cmd_contributors[] = "contributors";
+const char badargs[] = ERROR " invalid arguments\nrunning " HELPCMD " will bring up the help dialog\n";
+void printLicense() { printf("%s%s\n", notice, license); }
+
+const char asm_expected_instruction[] = "expected an instruction\n";
+const char asm_wrong_type[] = "given argument of wrong type\n";
+

const/opcodes.h

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <sys/stat.h>
+#include "include/libgyb.h"
+#include "include/libgyb.c"
+#include "const/license.h"
+#include "const/strings.h"
+#include "const/opcodes.h"
+#include "src/gasm.h"
+#include "src/load.c"
+#include "src/assemble.c"
+#include "src/lexer.c"
+#include "src/parser.c"
+#include "src/emit.c"
+
+int main (int argc, char **argv) {
+    if (argc == 1) { printf(badargs); exit(1); }
+    if (argc == 2) {
+        if ( argv[1][0]=='-' ) {
+        switch(argv[1][1]) {
+            case 'h': printf(help); exit(0);
+            case 'v': printf(version); exit(0);
+            case 'l': printLicense(); exit(0);
+            case 'c': printf(contributors); exit(0);
+            default: printf(badargs); exit(1);
+        }}
+        if ( strncmp(argv[1], cmd_help, sizeof(cmd_help))==0 ) { printf(help); exit(0); }
+        if ( strncmp(argv[1], cmd_version, sizeof(cmd_version))==0 ) { printf(version); exit(0); }
+        if ( strncmp(argv[1], cmd_license, sizeof(cmd_license))==0 ) { printLicense(); exit(0); }
+        if ( strncmp(argv[1], cmd_contributors, sizeof(cmd_version))==0 ) { printf(contributors); exit(0); }
+        printf(badargs); exit(1);
+    }
+    assemble(argv[1], argc-2, argv + 2);
+}

const/strings.h

@@ -0,0 +1,14 @@
+void assembler_error(token_t token, parse_t *context, const char *error) {
+    printf("\e[0;31merror:\e[0;33m%s\e[0m, ln %d col %d\n%s",
+        context->source,
+        token.ln, token.col, error
+    ); exit(1);
+}
+
+int assemble(char *filename, int srcn, char **srcs){
+    gybfile_t object = bytecode_new();
+    int i; for (i=0; i<srcn; i++) {
+        parse_t local = gasm_load(srcs[i]);
+    }
+    return bytecode_save(filename, object);
+}

gasm.c

@@ -0,0 +1,27 @@
+#define register_t  unsigned char
+#define label_t     uint32_t        // symbol hash, must be in E section
+#define constant_t  uint32_t        // symbol hash, must be constant-type
+#define address_t   uint32_t        // symbol hash, any section allowed
+#define symbol_t    uint32_t        // symbol hash, any allowed
+
+typedef struct {
+    unsigned int ln; unsigned int col;
+    unsigned char type; unsigned int value; // symbol, const, whatever
+    char *string; // null terminated
+} token_t;
+
+typedef struct {
+    unsigned int size;
+    token_t *tokens;
+} lexicon_t;
+
+typedef struct {
+    char *source;
+    symboltable_t symtable;
+    lexicon_t lexicon;
+} parse_t;
+
+parse_t gasm_import(parse_t *parent, parse_t *child);
+parse_t gasm_load(char *filename);
+lexicon_t lexer(char *stream, unsigned int size);
+parse_t parser(lexicon_t lexicon);

src/assemble.c

@@ -0,0 +1,17 @@
+token_t lexer_consume(char *stream, int max){
+    // Data types, ex. bytes
+
+    // Keywords: registers, constants, et cetera
+
+    // Symbolic Names
+
+    // Instructions
+}
+
+lexicon_t lexer(char *stream, unsigned int size){
+    lexicon_t yield;
+    int cursor=0; while(cursor < size) {
+        token_t token = lexer_consume(stream + cursor, size - cursor);
+        cursor += strlen(token.string);
+    }   return yield;
+}

src/emit.c

@@ -0,0 +1,17 @@
+parse_t gasm_import(parse_t *parent, parse_t *child) {
+    // Clone in the symbols
+
+    // Clone in the lexicon
+}
+parse_t gasm_load(char *filename) {
+    // Read and perform lexical analysis
+    unsigned int source_length = file_size(filename);
+    char *buffer = malloc(sizeof(char)*source_length);
+    file_read(filename, buffer, source_length);
+    lexicon_t lexicon = lexer(buffer, source_length);
+    free(buffer);
+    // Then parse
+    parse_t yield = parser(lexicon);
+    yield.source = filename;
+    return yield;
+}

src/gasm.h

@@ -0,0 +1,17 @@
+int parser_consume(parse_t *state, token_t *stream, int depth){
+    // Sections and other high-level state commands
+
+    // Definitions; bytes, symbols, et
+
+    // System Call instructions
+
+    // Regular assembly instructions
+}
+
+parse_t parser(lexicon_t lexicon) {
+    parse_t yield; int cursor;
+    while(cursor < lexicon.size) {
+        int step = parser_consume(&yield, lexicon.tokens + cursor, lexicon.size-cursor);
+        cursor += step;
+    }   return yield;
+}