.github/workflows/c-cpp.yml

@@ -1,19 +0,0 @@
-name: Cee-lang CI
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: make
-      run: make
-    - name: example
-      run: make example

Makefile

@@ -1,36 +1,18 @@
 CC = gcc
 CFLAGS_EXTRA = 
 CFLAGS = -Wall -Wextra -Wpedantic -std=c17 -O3
-CLANG_FORMAT_STYLE = '{ BasedOnStyle: Google, IndentWidth: 4 }'
 
-.PHONY: clean hbas example format check-format
+.PHONY: clean
 
-hbas: build/hbas
+hbas: src/hbas.c
-example: build/example.hbf
-hello: build/hello.hbf
-
-format:
-	clang-format --style=${CLANG_FORMAT_STYLE} -i src/*
-
-check-format:
-	clang-format --style=${CLANG_FORMAT_STYLE} -i --dry-run -Werror src/*
-
-build:
-	mkdir -p build
-
-build/hbas: build $(wildcard src/*.h src/*.c)
 	${CC} ${CFLAGS} ${CFLAGS_EXTRA} src/hbas.c -o build/hbas
 
-build/example.hbf: build build/hbas examples/example.S
+example: hbas example.S
-	./build/hbas < examples/example.S > build/example.hbf
+	./hbas < example.S > example
-	xxd build/example.hbf
+	xxd example
-
-build/hello.hbf: build build/hbas examples/hello.S
-	./build/hbas < examples/hello.S > build/hello.hbf
-	xxd build/hello.hbf
 
 clean:
-	rm -rf build
+	rm -f example hbas
 
 all:
 	hbas

examples/example.S

@@ -2,25 +2,16 @@
 ; https://git.ablecorp.us/AbleOS/holey-bytes/src/branch/trunk/spec.md
 ; TODO:
 ; .origin 0x1000
-; 'c' char literals
+; .align 0x100
+; .db "hello"
 ; .struct
 start:
     jmp end
     un
+    ; .db "hello world\n"
     add16 r1, r2, r255
     addi8 r1, r2, -128
     lra r1, r0, start
     jmp start
 end:
     tx
-hello_string:
-    .db "Hello, w\x6frld\n", 0
-hello_string_end:
-    .db "hi"
-    ; TODO .db 'H', 'e', 'l', 'l', 'o', '\0'
-    .align 2
-    .dw 0x4546
-    .align 4
-    .dd 0x4748494a
-    .align 8
-    .dq 0x5051525354555657

examples/hello-name.S

@@ -1,103 +0,0 @@
-jmp entry
-
-puts:
-; Write string to console
-;  r2: [IN] *const u8  String pointer
-;  r3: [IN] usize      String length
-
-    li8     r1, 0x1         ; Write syscall
-    brc     r2, r3, 2       ; Copy parameters
-    li8     r2, 0x1         ; STDOUT
-    eca
-
-    jal     r0, r31, 0
-
-gets:
-; Read string until end of buffer or LF
-;  r2: [IN] *mut u8    Buffer
-;  r3: [IN] usize      Buffer length
-
-    ; Register allocations:
-    ;  r33: *mut u8    Buffer end
-    ;  r34: u8         Immediate char
-    ;  r35: u8         Const [0x0A = LF]
-
-    li8     r35, 0x0A
-    add64   r33, r2, r3
-
-    ; Setup syscall
-    li8     r2, 0x1         ; Stdin
-    cp      r3, r2
-    li8     r4, 0x1         ; Read one char
-
-    jeq     r3, r33, end
-    loop:
-        li8     r1, 0x1     ; Read syscall
-        eca
-        addi64  r3, r3, 1
-        ld      r34, r3, 0, 1
-        jeq     r34, r35, end
-        jne     r3, r33, loop
-    
-    end:
-        ; Set copied amount
-        sub64   r1, r33, r3
-        addi64  r1, r1, -1
-        jal     r0, r31, 0
-
-alloc_pages:
-; Allocate pages
-;  r1: [OUT] *mut u8   Pointer to page
-;  r2: [IN]  u16       Page count
-
-    muli16  r3, r2, 4096    ; page count
-    li8     r1, 0x9         ; mmap syscall
-    li8     r2, 0x0         ; no address set, kernel chosen
-    li8     r4, 0x2         ; PROT_WRITE
-    li8     r5, 0x20        ; MAP_ANONYMOUS
-    li64    r6, -1          ; Doesn't map file
-    li8     r7, 0x0         ; Doesn't map file
-    eca
-
-    jal     r0, r31, 0
-
-entry:
-; Program entrypoint
-
-    ; Register allocations:
-    ; r32: *mut u8     Buffer
-    ; r36: usize       Read buffer length
-
-    ; Allocate one page (4096 KiB)
-    li8     r2, 1
-    jal     r31, r0, alloc_pages
-    cp      r32, r1
-
-    ; Print message
-    lra16   r2, r0, enter_your_name
-    li8     r3, 17
-    jal     r31, r0, puts
-
-    ; Read name
-    cp      r2, r32
-    li16    r3, 4096
-    jal     r31, r0, gets
-    cp      r36, r1
-
-    ; Print your name is
-    lra16   r2, r0, your_name_is
-    li8     r3, 15
-    jal     r31, r0, puts
-
-    ; And now print the name
-    cp      r2, r32
-    cp      r3, r36
-    jal     r31, r0, puts
-
-    tx
-
-
-enter_your_name:
-    .db "Enter your name: "
-your_name_is:
-    .db "\nYour name is: "

examples/hello.S

@@ -1,8 +0,0 @@
-    li8 r1, 1     ; 1->sys::write
-    li8 r2, 1     ; fildes=stdout
-    lra16 r3, r0, hello_string ; buf=hello_string
-    li8 r4, 0x11  ; nbyte=0x11
-    eca ; sys::write(stdout, hello_string, 0x11)
-    tx
-hello_string:
-    .db "Hello, AbleCorp!\n"

src/args.c

@@ -55,8 +55,7 @@ const char *TYPE_STR[] = {
 };
 
 const size_t NARGS = sizeof(ARGS) / sizeof(ARGS[0]);
-
+ArgMeta arg_meta(char arg) {
-static ArgMeta arg_meta(char arg) {
   for (size_t ii = 0; ii < NARGS; ii += 1) {
     ArgMeta meta = ARGS[ii];
     if (meta.chr == arg) {

src/bytevec.c

@@ -6,7 +6,7 @@ typedef struct ByteVec_s {
   size_t len;
 } ByteVec;
 
-static AsmError ensure_push(ByteVec *vec, size_t el_size, size_t extra) {
+AsmError ensure_push(ByteVec *vec, size_t el_size, size_t extra) {
   if (vec->len + extra < vec->len) {
     return ErrOutOfMemory;
   }

src/directive.c

@@ -1,138 +0,0 @@
-AsmError push_string(char *buf, char *input, size_t len) {
-    size_t ndata = 0;
-    for (size_t pos = 0; pos < len; pos += 1) {
-        char chr = input[pos];
-        if (chr == '\\') {
-            if (pos + 1 >= len) {
-                return ErrDanglingEscape;
-            }
-            pos += 1;
-            chr = input[pos];
-            switch (chr) {
-                case '\\':
-                    chr = '\\';
-                    break;
-                case '"':
-                    chr = '"';
-                    break;
-                case 'r':
-                    chr = '\r';
-                    break;
-                case 'n':
-                    chr = '\n';
-                    break;
-                case '0':
-                    chr = '\0';
-                    break;
-                case 't':
-                    chr = '\t';
-                    break;
-                case 'x':
-                    if (pos + 2 >= len) {
-                        return ErrDanglingEscape;
-                    }
-                    char high = get_hex(input[pos + 1]);
-                    char low = get_hex(input[pos + 2]);
-                    if (high > 15 || low > 15) {
-                        return ErrStringBadHex;
-                    }
-                    pos += 2;
-                    chr = high << 4 | low;
-                    break;
-                default:
-                    return ErrBadStringEscape;
-            }
-        }
-        buf[ndata] = chr;
-        ndata += 1;
-    }
-    return ErrOk;
-}
-
-static AsmError push_data(char *input, size_t len, ByteVec *out, Token *tok,
-                          size_t word_size) {
-    while (1) {
-        *tok = token(input, len, tok->start + tok->len);
-        if (tok->kind == TokNumber) {
-            if (ensure_push(out, 1, word_size) != 0) {
-                return ErrOutOfMemory;
-            }
-            push_int_le(&out->buf[out->len], tok->num, word_size, 3);
-            out->len += word_size;
-        } else if (tok->kind == TokString) {
-            if (word_size != 1) {
-                return ErrStringDataNotByte;
-            }
-            if (ensure_push(out, 1, tok->num) != 0) {
-                return ErrOutOfMemory;
-            }
-
-            char *str = &input[tok->start + 1];
-            AsmError err = push_string(&out->buf[out->len], str, tok->len - 2);
-            if (err != ErrOk) {
-                return err;
-            }
-            out->len += tok->num;
-        } else {
-            return ErrNeedsDataLiteral;
-        }
-        *tok = token(input, len, tok->start + tok->len);
-        if (tok->kind == TokNewline || tok->kind == TokEOF) {
-            return ErrOk;
-        }
-        if (tok->kind == TokComma) {
-            continue;
-        }
-        return ErrNeedCommaOrNewline;
-    }
-}
-
-AsmError assemble_directive(char *input, size_t len, ByteVec *out, Token *tok) {
-    if (tok->len < 2) {
-        return ErrInvalidDirective;
-    }
-    size_t pos = tok->start;
-    char byte0 = input[pos];
-    char byte1 = input[pos + 1];
-    if (tok->len == 2 && byte0 == 'd') {
-        size_t word_size;
-        switch (byte1) {
-            case 'b':
-                word_size = 1;
-                break;
-            case 'w':
-                word_size = 2;
-                break;
-            case 'd':
-                word_size = 4;
-                break;
-            case 'q':
-                word_size = 8;
-                break;
-            default:
-                return ErrInvalidDirective;
-        }
-        return push_data(input, len, out, tok, word_size);
-    }
-    if (tok->len == 5 && strncmp("align", &input[pos], 5) == 0) {
-        *tok = token(input, len, tok->start + tok->len);
-        if (tok->kind != TokNumber) {
-            return ErrAlignNeedsNumber;
-        }
-        size_t mask = tok->num - 1;
-        if (tok->num == 0 || (tok->num & mask) != 0) {
-            return ErrAlignNeedsPow2;
-        }
-        if ((~(size_t)0) - mask < out->len) {
-            return ErrOutOfMemory;
-        }
-        size_t aligned = (out->len + mask) & ~mask;
-        if (ensure_push(out, 1, aligned - out->len) != 0) {
-            return ErrOutOfMemory;
-        }
-        // TODO: zero-fill?
-        out->len = aligned;
-        return ErrOk;
-    }
-    return ErrInvalidDirective;
-}

src/error.h

@@ -17,17 +17,6 @@ typedef enum AsmError_e {
   ErrNeedDirectiveAfterDot,
   ErrDirectiveNotImplemented,
   ErrUnexpectedToken,
-    ErrTriedNegateNonNumber,
-    ErrInvalidDirective,
-    ErrStringNewLine,
-    ErrDanglingEscape,
-    ErrStringBadHex,
-    ErrBadStringEscape,
-    ErrStringDataNotByte,
-    ErrAlignNeedsNumber,
-    ErrAlignNeedsPow2,
-    ErrNeedCommaOrNewline,
-    ErrNeedsDataLiteral,
 } AsmError;
 char *ERRORS[] = {
     "Success",
@@ -48,15 +37,4 @@ char *ERRORS[] = {
     "Expected directive after dot",
     "Directive is not implemented",
     "Unexpected token",
-    "Negation only works on numbers",
-    "Invalid directive",
-    "String contains a raw newline (did you forget to close the quote?)",
-    "Dangling escape in string literal",
-    "Bad hex in string literal",
-    "Bad escape sequence in string literal",
-    "String literals can be used only in .db directive",
-    ".align requires a number",
-    ".align requires a power of two as an argument",
-    "Need comma or newline after data literal",
-    "Data literal expects a number or a string",
 };

src/hash.c

@@ -5,7 +5,7 @@ typedef struct InstHtNode_s {
 } InstHtNode;
 typedef InstHtNode *InstHt;
 
-static uint32_t inst_hash(const char *s, size_t len) {
+uint32_t inst_hash(const char *s, size_t len) {
   uint32_t hash = 0;
   uint32_t mul = 75;
   for (size_t ii = 0; ii < len; ii += 1) {
@@ -15,7 +15,7 @@ static uint32_t inst_hash(const char *s, size_t len) {
   return hash;
 }
 
-static InstHt build_lookup(void) {
+InstHt build_lookup(void) {
   const size_t size = 256;
   InstHt table = (InstHt)malloc(size * sizeof(InstHtNode));
   if (table == NULL) {
@@ -40,7 +40,7 @@ static InstHt build_lookup(void) {
   return table;
 }
 
-static size_t inst_lookup(InstHt ht, const char *s, size_t len) {
+size_t inst_lookup(InstHt ht, const char *s, size_t len) {
   uint32_t hash = inst_hash(s, len);
   uint8_t *node = (uint8_t *)&ht[(size_t)(hash & 0xff)];
   for (size_t ii = 0; ii < 2; ii += 1) {

src/hbas.c

@@ -20,7 +20,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
-#include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -35,34 +34,24 @@ SOFTWARE.
 //
 #include "hash.c"
 //
-#include "push_int.c"
 #include "register.c"
 #include "token.c"
 //
-#include "directive.c"
 #include "einfo.h"
 
-// Print space-separated hex dump of each byte, 16 bytes per line.
+void hd(char *data, size_t len) {
-// Can be reversed with `xxd -p -r`.
-static void hex_dump(char *data, size_t len) {
-    char buf[48];
-    const char *alphabet = "0123456789abcdef";
   for (size_t ii = 0; ii < len; ii += 1) {
-        size_t val = (uint8_t)data[ii];
+    if (ii > 0 && (ii & 15) == 0) {
-        size_t pos = (ii & 0x0f) * 3;
+      printf("\n");
-        buf[pos] = alphabet[val >> 4];
-        buf[pos + 1] = alphabet[val & 0x0f];
-        buf[pos + 2] = ' ';
-        if (((ii & 0x0f) == 0x0f) || ii + 1 == len) {
-            buf[pos + 2] = '\n';
-            fwrite(&buf[0], 1, pos + 3, stdout);
     }
+    printf("%02x", (uint8_t)data[ii]);
   }
+  printf("\n");
 }
 
 #define MIN_SIZE 4096
 
-static int slurp(FILE *fd, ByteVec *out) {
+int slurp(FILE *fd, ByteVec *out) {
   ByteVec rv = {malloc(MIN_SIZE), MIN_SIZE, 0};
   size_t bread = 1;
   int err = 0;
@@ -109,7 +98,7 @@ typedef struct LabelVec_s {
   size_t len;
 } LabelVec;
 
-static size_t label_lookup(LabelVec *labels, char *name, size_t len) {
+size_t label_lookup(LabelVec *labels, char *name, size_t len) {
   size_t nlabels = labels->len;
   Label *buf = labels->buf;
   for (size_t ii = 0; ii < nlabels; ii += 1) {
@@ -121,7 +110,52 @@ static size_t label_lookup(LabelVec *labels, char *name, size_t len) {
   return INVALID;
 }
 
-static AsmError assemble_instr(InstHt ht, char *input, size_t len, Token *tok,
+// safety: assumes the buffer has enough place for specified integer size.
+// `sign` is a bitset, where bit `1` indicates that value accepts a signed int,
+// and bit `2` indicates that value accepts an unsigned int.
+AsmError push_int_le(char *buf, uint64_t val, size_t size, uint8_t sign) {
+  // Unsigned integers must have all upper bits set to zero. To check this,
+  // we shift the value right by the integer size and verify it equals zero.
+  int valid_uint = (val >> (size * 8)) == 0;
+
+  // For signed integers, the sign-extended high bits must match the sign bit.
+  // By shifting right by one less than the total bit size (size * 8 - 1),
+  // we isolate the sign bit and any sign-extended bits. For a value fitting
+  // in the signed range, this operation results in either 0 (for non-negative
+  // values) or -1 (for negative values due to sign extension).
+  int64_t int_shifted = ((int64_t)val) >> (size * 8 - 1);
+
+  // To unify the check for both positive and negative cases, we adjust
+  // non-zero values (-1) by incrementing by 1.  This turns -1 into 0,
+  // enabling a single check for 0 to validate both cases.  This adjustment
+  // simplifies the validation logic, allowing us to use a single condition to
+  // check for proper sign extension or zero extension in the original value.
+  int_shifted += int_shifted != 0;
+
+  // A valid signed integer will have `int_shifted` equal to 0
+  // after adjustment, indicating proper sign extension. 
+  int valid_int = int_shifted == 0;
+
+  // Validity bitmask to represents whether the value
+  // fits as signed, unsigned, or both.
+  int validity = valid_int | (valid_uint << 1);
+
+  // If the value's validity doesn't match the `sign` requirements,
+  // we report an overflow.
+  if ((validity & sign) == 0) {
+    return ErrImmediateOverflow;
+  }
+
+  // Write out the bytes of the integer to the buffer in little-endian order,
+  // starting with the lowest byte first.
+  for (size_t ii = 0; ii < size; ii += 1) {
+    buf[ii] = val & 0xff;
+    val >>= 8;
+  }
+  return ErrOk;
+}
+
+AsmError assemble_instr(InstHt ht, char *input, size_t len, Token *tok,
                         ByteVec *rv, HoleVec *holes) {
   const InstDesc *inst;
   const char *type_str;
@@ -207,11 +241,9 @@ static AsmError assemble_instr(InstHt ht, char *input, size_t len, Token *tok,
           return ErrBadNumOverflow;
         }
         num_to_write = (uint64_t)tmp;
-            } else if (meta.sign == 2 && (int64_t)num_to_write < 0) {
-                return ErrBadNumOverflow;
       }
-            AsmError err = push_int_le(&rv->buf[rv->len], num_to_write,
+      AsmError err =
-                                       meta.size, meta.sign);
+          push_int_le(&rv->buf[rv->len], num_to_write, meta.size, meta.sign);
       if (err != ErrOk) {
         return err;
       }
@@ -222,14 +254,10 @@ static AsmError assemble_instr(InstHt ht, char *input, size_t len, Token *tok,
   return ErrOk;
 }
 
-AsmError assemble(InstHt ht, char *input, size_t len, ByteVec *out,
+AsmError assemble(InstHt ht, char *input, size_t len, ByteVec *out, EInfo *einfo) {
-                  EInfo *einfo) {
   ByteVec rv = {malloc(MIN_SIZE), MIN_SIZE, 0};
   HoleVec holes = {malloc(MIN_SIZE * sizeof(Hole)), MIN_SIZE, 0};
   LabelVec labels = {malloc(MIN_SIZE * sizeof(Label)), MIN_SIZE, 0};
-    if (rv.buf == NULL || holes.buf == NULL || labels.buf == NULL) {
-        return ErrOutOfMemory;
-    }
   size_t line = 0;
   size_t line_start = 0;
   size_t pos = 0;
@@ -264,15 +292,11 @@ AsmError assemble(InstHt ht, char *input, size_t len, ByteVec *out,
     }
     if (tok.kind == TokDot) {
       Token next = token(input, len, pos);
-            einfo->token = next;
+      if (next.kind == TokIdent) {
-            if (next.kind != TokIdent) {
+        err = ErrDirectiveNotImplemented;
-                err = ErrNeedDirectiveAfterDot;
         goto end;
-            }
+      } else {
-            err = assemble_directive(input, len, &rv, &next);
+        err = ErrNeedDirectiveAfterDot;
-            pos = next.start + next.len;
-            einfo->token = next;
-            if (err != ErrOk) {
         goto end;
       }
       continue;
@@ -331,8 +355,7 @@ AsmError assemble(InstHt ht, char *input, size_t len, ByteVec *out,
       sign = 1;
       num_to_write -= hole->origin;
     }
-        err = push_int_le(&rv.buf[hole->location], num_to_write, hole->size,
+    err = push_int_le(&rv.buf[hole->location], num_to_write, hole->size, sign);
-                          sign);
     if (err != 0) {
       goto end;
     }
@@ -373,14 +396,13 @@ int main(int argc, char **argv) {
   err = assemble(ht, input.buf, input.len, &out, &einfo);
   if (err != 0) {
     size_t column = einfo.token.start - einfo.line_start + 1;
-        fprintf(stderr,
+    fprintf(stderr, "failed to assemble, %s, line=%zu, col=%zu token=%.*s\n",
-                "failed to assemble, %s, line=%zu, col=%zu token=%.*s\n",
             ERRORS[err], einfo.line, column, (int)einfo.token.len,
             &input.buf[einfo.token.start]);
     goto done;
   }
   if (hex_out) {
-        hex_dump(out.buf, out.len);
+    hd(out.buf, out.len);
   } else {
     fwrite(out.buf, 1, out.len, stdout);
   }

src/instructions.c

@@ -5,125 +5,65 @@ typedef struct InstDesc_s {
 } InstDesc;
 
 const InstDesc INST[] = {
-    {.opcode = 0x00, .mnemonic = "un", .type = Empty},
+    {"un", 0x00, Empty},       {"tx", 0x01, Empty},
-    {.opcode = 0x01, .mnemonic = "tx", .type = Empty},
+    {"nop", 0x02, Empty},      {"add8", 0x03, RRR},
-    {.opcode = 0x02, .mnemonic = "nop", .type = Empty},
+    {"add16", 0x04, RRR},      {"add32", 0x05, RRR},
-    {.opcode = 0x03, .mnemonic = "add8", .type = RRR},
+    {"add64", 0x06, RRR},      {"sub8", 0x07, RRR},
-    {.opcode = 0x04, .mnemonic = "add16", .type = RRR},
+    {"sub16", 0x08, RRR},      {"sub32", 0x09, RRR},
-    {.opcode = 0x05, .mnemonic = "add32", .type = RRR},
+    {"sub64", 0x0A, RRR},      {"mul8", 0x0B, RRR},
-    {.opcode = 0x06, .mnemonic = "add64", .type = RRR},
+    {"mul16", 0x0C, RRR},      {"mul32", 0x0D, RRR},
-    {.opcode = 0x07, .mnemonic = "sub8", .type = RRR},
+    {"mul64", 0x0E, RRR},      {"and", 0x0F, RRR},
-    {.opcode = 0x08, .mnemonic = "sub16", .type = RRR},
+    {"or", 0x10, RRR},         {"xor", 0x11, RRR},
-    {.opcode = 0x09, .mnemonic = "sub32", .type = RRR},
+    {"slu8", 0x12, RRR},       {"slu16", 0x13, RRR},
-    {.opcode = 0x0A, .mnemonic = "sub64", .type = RRR},
+    {"slu32", 0x14, RRR},      {"slu64", 0x15, RRR},
-    {.opcode = 0x0B, .mnemonic = "mul8", .type = RRR},
+    {"sru8", 0x16, RRR},       {"sru16", 0x17, RRR},
-    {.opcode = 0x0C, .mnemonic = "mul16", .type = RRR},
+    {"sru32", 0x18, RRR},      {"sru64", 0x19, RRR},
-    {.opcode = 0x0D, .mnemonic = "mul32", .type = RRR},
+    {"srs8", 0x1A, RRR},       {"srs16", 0x1B, RRR},
-    {.opcode = 0x0E, .mnemonic = "mul64", .type = RRR},
+    {"srs32", 0x1C, RRR},      {"srs64", 0x1D, RRR},
-    {.opcode = 0x0F, .mnemonic = "and", .type = RRR},
+    {"cmpu", 0x1E, RRR},       {"cmps", 0x1F, RRR},
-    {.opcode = 0x10, .mnemonic = "or", .type = RRR},
+    {"diru8", 0x20, RRRR},     {"diru16", 0x21, RRRR},
-    {.opcode = 0x11, .mnemonic = "xor", .type = RRR},
+    {"diru32", 0x22, RRRR},    {"diru64", 0x23, RRRR},
-    {.opcode = 0x12, .mnemonic = "slu8", .type = RRR},
+    {"dirs8", 0x24, RRRR},     {"dirs16", 0x25, RRRR},
-    {.opcode = 0x13, .mnemonic = "slu16", .type = RRR},
+    {"dirs32", 0x26, RRRR},    {"dirs64", 0x27, RRRR},
-    {.opcode = 0x14, .mnemonic = "slu32", .type = RRR},
+    {"neg", 0x28, RR},         {"not", 0x29, RR},
-    {.opcode = 0x15, .mnemonic = "slu64", .type = RRR},
+    {"sxt8", 0x2A, RR},        {"sxt16", 0x2B, RR},
-    {.opcode = 0x16, .mnemonic = "sru8", .type = RRR},
+    {"sxt32", 0x2C, RR},       {"addi8", 0x2D, RRx8},
-    {.opcode = 0x17, .mnemonic = "sru16", .type = RRR},
+    {"addi16", 0x2E, RRx16},   {"addi32", 0x2F, RRx32},
-    {.opcode = 0x18, .mnemonic = "sru32", .type = RRR},
+    {"addi64", 0x30, RRx64},   {"muli8", 0x31, RRx8},
-    {.opcode = 0x19, .mnemonic = "sru64", .type = RRR},
+    {"muli16", 0x32, RRx16},   {"muli32", 0x33, RRx32},
-    {.opcode = 0x1A, .mnemonic = "srs8", .type = RRR},
+    {"muli64", 0x34, RRx64},   {"andi", 0x35, RRx64},
-    {.opcode = 0x1B, .mnemonic = "srs16", .type = RRR},
+    {"ori", 0x36, RRx64},      {"xori", 0x37, RRx64},
-    {.opcode = 0x1C, .mnemonic = "srs32", .type = RRR},
+    {"slui8", 0x38, RRu8},     {"slui16", 0x39, RRu8},
-    {.opcode = 0x1D, .mnemonic = "srs64", .type = RRR},
+    {"slui32", 0x3A, RRu8},    {"slui64", 0x3B, RRu8},
-    {.opcode = 0x1E, .mnemonic = "cmpu", .type = RRR},
+    {"srui8", 0x3C, RRu8},     {"srui16", 0x3D, RRu8},
-    {.opcode = 0x1F, .mnemonic = "cmps", .type = RRR},
+    {"srui32", 0x3E, RRu8},    {"srui64", 0x3F, RRu8},
-    {.opcode = 0x20, .mnemonic = "diru8", .type = RRRR},
+    {"srsi8", 0x40, RRu8},     {"srsi16", 0x41, RRu8},
-    {.opcode = 0x21, .mnemonic = "diru16", .type = RRRR},
+    {"srsi32", 0x42, RRu8},    {"srsi64", 0x43, RRu8},
-    {.opcode = 0x22, .mnemonic = "diru32", .type = RRRR},
+    {"cmpui", 0x44, RRu64},    {"cmpsi", 0x45, RRs64},
-    {.opcode = 0x23, .mnemonic = "diru64", .type = RRRR},
+    {"cp", 0x46, RR},          {"swa", 0x47, RR},
-    {.opcode = 0x24, .mnemonic = "dirs8", .type = RRRR},
+    {"li8", 0x48, Rx8},        {"li16", 0x49, Rx16},
-    {.opcode = 0x25, .mnemonic = "dirs16", .type = RRRR},
+    {"li32", 0x4A, Rx32},      {"li64", 0x4B, Rx64},
-    {.opcode = 0x26, .mnemonic = "dirs32", .type = RRRR},
+    {"lra", 0x4C, RRr32},      {"ld", 0x4D, RRu64u16},
-    {.opcode = 0x27, .mnemonic = "dirs64", .type = RRRR},
+    {"st", 0x4E, RRu64u16},    {"ldr", 0x4F, RRr32u16},
-    {.opcode = 0x28, .mnemonic = "neg", .type = RR},
+    {"str", 0x50, RRr32u16},   {"bmc", 0x51, RRu16},
-    {.opcode = 0x29, .mnemonic = "not", .type = RR},
+    {"brc", 0x52, RRu8},       {"jmp", 0x53, r32},
-    {.opcode = 0x2A, .mnemonic = "sxt8", .type = RR},
+    {"jal", 0x54, RRr32},      {"jala", 0x55, RRu64},
-    {.opcode = 0x2B, .mnemonic = "sxt16", .type = RR},
+    {"jeq", 0x56, RRr16},      {"jne", 0x57, RRr16},
-    {.opcode = 0x2C, .mnemonic = "sxt32", .type = RR},
+    {"jltu", 0x58, RRr16},     {"jgtu", 0x59, RRr16},
-    {.opcode = 0x2D, .mnemonic = "addi8", .type = RRx8},
+    {"jlts", 0x5A, RRr16},     {"jgts", 0x5B, RRr16},
-    {.opcode = 0x2E, .mnemonic = "addi16", .type = RRx16},
+    {"eca", 0x5C, Empty},      {"ebp", 0x5D, Empty},
-    {.opcode = 0x2F, .mnemonic = "addi32", .type = RRx32},
+    {"fadd32", 0x5E, RRR},     {"fadd64", 0x5F, RRR},
-    {.opcode = 0x30, .mnemonic = "addi64", .type = RRx64},
+    {"fsub32", 0x60, RRR},     {"fsub64", 0x61, RRR},
-    {.opcode = 0x31, .mnemonic = "muli8", .type = RRx8},
+    {"fmul32", 0x62, RRR},     {"fmul64", 0x63, RRR},
-    {.opcode = 0x32, .mnemonic = "muli16", .type = RRx16},
+    {"fdiv32", 0x64, RRR},     {"fdiv64", 0x65, RRR},
-    {.opcode = 0x33, .mnemonic = "muli32", .type = RRx32},
+    {"fma32", 0x66, RRRR},     {"fma64", 0x67, RRRR},
-    {.opcode = 0x34, .mnemonic = "muli64", .type = RRx64},
+    {"fcmplt32", 0x6A, RRR},   {"fcmplt64", 0x6B, RRR},
-    {.opcode = 0x35, .mnemonic = "andi", .type = RRx64},
+    {"fcmpgt32", 0x6C, RRR},   {"fcmpgt64", 0x6D, RRR},
-    {.opcode = 0x36, .mnemonic = "ori", .type = RRx64},
+    {"itf32", 0x6E, RR},       {"itf64", 0x6F, RR},
-    {.opcode = 0x37, .mnemonic = "xori", .type = RRx64},
+    {"fti32", 0x70, RRu8},     {"fti64", 0x71, RRu8},
-    {.opcode = 0x38, .mnemonic = "slui8", .type = RRu8},
+    {"fc32t64", 0x72, RR},     {"fc64t32", 0x73, RR},
-    {.opcode = 0x39, .mnemonic = "slui16", .type = RRu8},
+    {"lra16", 0x74, RRr16},    {"ldr16", 0x75, RRr16u16},
-    {.opcode = 0x3A, .mnemonic = "slui32", .type = RRu8},
+    {"str16", 0x76, RRr16u16}, {"jmp16", 0x77, r16},
-    {.opcode = 0x3B, .mnemonic = "slui64", .type = RRu8},
-    {.opcode = 0x3C, .mnemonic = "srui8", .type = RRu8},
-    {.opcode = 0x3D, .mnemonic = "srui16", .type = RRu8},
-    {.opcode = 0x3E, .mnemonic = "srui32", .type = RRu8},
-    {.opcode = 0x3F, .mnemonic = "srui64", .type = RRu8},
-    {.opcode = 0x40, .mnemonic = "srsi8", .type = RRu8},
-    {.opcode = 0x41, .mnemonic = "srsi16", .type = RRu8},
-    {.opcode = 0x42, .mnemonic = "srsi32", .type = RRu8},
-    {.opcode = 0x43, .mnemonic = "srsi64", .type = RRu8},
-    {.opcode = 0x44, .mnemonic = "cmpui", .type = RRu64},
-    {.opcode = 0x45, .mnemonic = "cmpsi", .type = RRs64},
-    {.opcode = 0x46, .mnemonic = "cp", .type = RR},
-    {.opcode = 0x47, .mnemonic = "swa", .type = RR},
-    {.opcode = 0x48, .mnemonic = "li8", .type = Rx8},
-    {.opcode = 0x49, .mnemonic = "li16", .type = Rx16},
-    {.opcode = 0x4A, .mnemonic = "li32", .type = Rx32},
-    {.opcode = 0x4B, .mnemonic = "li64", .type = Rx64},
-    {.opcode = 0x4C, .mnemonic = "lra", .type = RRr32},
-    {.opcode = 0x4D, .mnemonic = "ld", .type = RRu64u16},
-    {.opcode = 0x4E, .mnemonic = "st", .type = RRu64u16},
-    {.opcode = 0x4F, .mnemonic = "ldr", .type = RRr32u16},
-    {.opcode = 0x50, .mnemonic = "str", .type = RRr32u16},
-    {.opcode = 0x51, .mnemonic = "bmc", .type = RRu16},
-    {.opcode = 0x52, .mnemonic = "brc", .type = RRu8},
-    {.opcode = 0x53, .mnemonic = "jmp", .type = r32},
-    {.opcode = 0x54, .mnemonic = "jal", .type = RRr32},
-    {.opcode = 0x55, .mnemonic = "jala", .type = RRu64},
-    {.opcode = 0x56, .mnemonic = "jeq", .type = RRr16},
-    {.opcode = 0x57, .mnemonic = "jne", .type = RRr16},
-    {.opcode = 0x58, .mnemonic = "jltu", .type = RRr16},
-    {.opcode = 0x59, .mnemonic = "jgtu", .type = RRr16},
-    {.opcode = 0x5A, .mnemonic = "jlts", .type = RRr16},
-    {.opcode = 0x5B, .mnemonic = "jgts", .type = RRr16},
-    {.opcode = 0x5C, .mnemonic = "eca", .type = Empty},
-    {.opcode = 0x5D, .mnemonic = "ebp", .type = Empty},
-    {.opcode = 0x5E, .mnemonic = "fadd32", .type = RRR},
-    {.opcode = 0x5F, .mnemonic = "fadd64", .type = RRR},
-    {.opcode = 0x60, .mnemonic = "fsub32", .type = RRR},
-    {.opcode = 0x61, .mnemonic = "fsub64", .type = RRR},
-    {.opcode = 0x62, .mnemonic = "fmul32", .type = RRR},
-    {.opcode = 0x63, .mnemonic = "fmul64", .type = RRR},
-    {.opcode = 0x64, .mnemonic = "fdiv32", .type = RRR},
-    {.opcode = 0x65, .mnemonic = "fdiv64", .type = RRR},
-    {.opcode = 0x66, .mnemonic = "fma32", .type = RRRR},
-    {.opcode = 0x67, .mnemonic = "fma64", .type = RRRR},
-    // 68, 69?
-    {.opcode = 0x6A, .mnemonic = "fcmplt32", .type = RRR},
-    {.opcode = 0x6B, .mnemonic = "fcmplt64", .type = RRR},
-    {.opcode = 0x6C, .mnemonic = "fcmpgt32", .type = RRR},
-    {.opcode = 0x6D, .mnemonic = "fcmpgt64", .type = RRR},
-    {.opcode = 0x6E, .mnemonic = "itf32", .type = RR},
-    {.opcode = 0x6F, .mnemonic = "itf64", .type = RR},
-    {.opcode = 0x70, .mnemonic = "fti32", .type = RRu8},
-    {.opcode = 0x71, .mnemonic = "fti64", .type = RRu8},
-    {.opcode = 0x72, .mnemonic = "fc32t64", .type = RR},
-    {.opcode = 0x73, .mnemonic = "fc64t32", .type = RR},
-    {.opcode = 0x74, .mnemonic = "lra16", .type = RRr16},
-    {.opcode = 0x75, .mnemonic = "ldr16", .type = RRr16u16},
-    {.opcode = 0x76, .mnemonic = "str16", .type = RRr16u16},
-    {.opcode = 0x77, .mnemonic = "jmp16", .type = r16},
 };
 
 const size_t INST_CNT = sizeof(INST) / sizeof(INST[0]);

src/push_int.c

@@ -1,55 +0,0 @@
-
-static bool check_valid_int(uint64_t val, size_t size, uint8_t sign) {
-    // All 64-bit values are considered valid.
-    if (size == 8) {
-        return true;
-    }
-    // Unsigned integers must have all upper bits set to zero. To check this,
-    // we shift the value right by the integer size and verify it equals zero.
-    int valid_uint = (val >> (size * 8)) == 0;
-
-    // For signed integers, the sign-extended high bits must match the sign bit.
-    // By shifting right by one less than the total bit size (size * 8 - 1),
-    // we isolate the sign bit and any sign-extended bits. For a value fitting
-    // in the signed range, this operation results in either 0 (for non-negative
-    // values) or -1 (for negative values due to sign extension).
-    int64_t int_shifted = ((int64_t)val) >> (size * 8 - 1);
-
-    // To unify the check for both positive and negative cases, we adjust
-    // non-zero values (-1) by incrementing by 1.  This turns -1 into 0,
-    // enabling a single check for 0 to validate both cases.  This adjustment
-    // simplifies the validation logic, allowing us to use a single condition to
-    // check for proper sign extension or zero extension in the original value.
-    int_shifted += int_shifted != 0;
-
-    // A valid signed integer will have `int_shifted` equal to 0
-    // after adjustment, indicating proper sign extension.
-    int valid_int = int_shifted == 0;
-
-    // Validity bitmask to represents whether the value
-    // fits as signed, unsigned, or both.
-    int validity = valid_int | (valid_uint << 1);
-
-    // If the value's validity doesn't match the `sign` requirements,
-    // we report an overflow.
-    return (validity & sign) != 0;
-}
-
-// safety: assumes the buffer has enough place for specified integer size.
-// `sign` is a bitset, where bit `1` indicates that value accepts a signed int,
-// and bit `2` indicates that value accepts an unsigned int.
-static AsmError push_int_le(char *buf, uint64_t val, size_t size,
-                            uint8_t sign) {
-    if (!check_valid_int(val, size, sign)) {
-        return ErrImmediateOverflow;
-    }
-
-    // Write out the bytes of the integer to the buffer in little-endian order,
-    // starting with the lowest byte first.
-    for (size_t ii = 0; ii < size; ii += 1) {
-        buf[ii] = val & 0xff;
-        val >>= 8;
-    }
-
-    return ErrOk;
-}

src/register.c

@@ -1,4 +1,4 @@
-static int parse_register(char *name, size_t len) {
+int parse_register(char *name, size_t len) {
   if (name[0] != 'r') {
     return 256;  // Register name should start with 'r'
   }

src/token.c

@@ -1,4 +1,5 @@
-typedef enum TokenKind_e {
+typedef enum TokenKind_e
+{
     TokInvalid = '!',
     TokEOF = '$',
     TokIdent = 'A',
@@ -10,23 +11,25 @@ typedef enum TokenKind_e {
     TokColon = ':',
     TokComment = ';',
     TokNewline = 'n',
-    TokString = 's',
 } TokenKind;
-typedef struct Token_s {
+typedef struct Token_s
+{
     TokenKind kind;
     size_t start;
     size_t len;
     uint64_t num;
 } Token;
 
-static Token token_ident(char *input, size_t len, size_t pos) {
+Token token_ident(char *input, size_t len, size_t pos)
+{
     size_t start = pos;
-    while (pos < len) {
+    while (pos < len)
+    {
         char chr = input[pos];
         char chru = chr & ~0x20;
-        int good = chr == '_' || (chr >= '0' && chr <= '9') ||
+        int good = chr == '_' || (chr >= '0' && chr <= '9') || (chru >= 'A' && chru <= 'Z');
-                   (chru >= 'A' && chru <= 'Z');
+        if (!good)
-        if (!good) {
+        {
             break;
         }
         pos += 1;
@@ -34,7 +37,8 @@ static Token token_ident(char *input, size_t len, size_t pos) {
     return (Token){TokIdent, start, pos - start, 0};
 }
 
-static Token token_number(char *input, size_t len, size_t pos) {
+Token token_number(char *input, size_t len, size_t pos)
+{
     char *ptr = &input[pos];
     char next = '\0';
     size_t start = pos;
@@ -44,21 +48,30 @@ static Token token_number(char *input, size_t len, size_t pos) {
     uint64_t pre_overflow;
     AsmError bad_num = ErrOk;
 
-    if (pos + 1 < len) {
+    if (pos + 1 < len)
+    {
         next = ptr[1] & ~0x20;
     }
 
-    if (input[pos] == '0') {
+    if (input[pos] == '0')
-        if (next == 'X') {
+    {
+        if (next == 'X')
+        {
             base = 16;
             pos += 2;
-        } else if (next == 'D') {
+        }
+        else if (next == 'D')
+        {
             base = 10;
             pos += 2;
-        } else if (next == 'O') {
+        }
+        else if (next == 'O')
+        {
             base = 8;
             pos += 2;
-        } else if (next == 'B') {
+        }
+        else if (next == 'B')
+        {
             base = 2;
             pos += 2;
         }
@@ -66,23 +79,30 @@ static Token token_number(char *input, size_t len, size_t pos) {
     pre_overflow = (~(size_t)0) / base;
     // valid: "0x_0", "0_"
     // invalid: "0x_"
-    while (pos < len) {
+    while (pos < len)
+    {
         uint64_t digit;
         uint64_t next;
         char chr = input[pos];
         char chru = chr & ~0x20;
-        if (chr == '_') {
+        if (chr == '_')
+        {
             pos += 1;
             continue;
         }
         digit = (uint64_t)chr - (uint64_t)'0';
-        if (digit >= 10) {
+        if (digit >= 10)
+        {
             digit = (uint64_t)chru - (uint64_t)('A' - 10);
         }
-        if (digit >= base) {
+        if (digit >= base)
-            if (chr >= '0' && chr <= '9') {
+        {
+            if (chr >= '0' && chr <= '9')
+            {
                 bad_num = ErrBadNumDigit;
-            } else if (chru >= 'A' && chru <= 'Z') {
+            }
+            else if (chru >= 'A' && chru <= 'Z')
+            {
                 bad_num = ErrBadNumDigit;
             }
             break;
@@ -92,120 +112,75 @@ static Token token_number(char *input, size_t len, size_t pos) {
         digits += 1;
 
         next = rv * base + digit;
-        if (rv > pre_overflow || next < rv) {
+        if (rv > pre_overflow || next < rv)
+        {
             bad_num = ErrBadNumOverflow;
             break;
         }
         rv = next;
     }
 
-    if (digits == 0) {
+    if (digits == 0)
+    {
         bad_num = ErrBadNumNoDigit;
     }
 
-    if (bad_num) {
+    if (bad_num)
+    {
         return (Token){TokBadNumber, start, pos - start, bad_num};
-    } else {
+    }
+    else
+    {
         return (Token){TokNumber, start, pos - start, rv};
     }
 }
 
-static char get_hex(char chr) {
+Token token(char *input, size_t len, size_t pos)
-    char chru = chr & ~0x20;
+{
-    if (chr >= '0' && chr <= '9') {
-        return chr - '0';
-    }
-    if (chru >= 'A' && chru <= 'F') {
-        return chru - ('A' - 10);
-    }
-    return 16;
-}
-
-static Token token_string(char *input, size_t len, size_t pos) {
-    size_t start = pos;
-    size_t ndata = 0;
-    for (pos += 1; pos < len; pos += 1) {
-        if (input[pos] == '"') {
-            return (Token){TokString, start, pos + 1 - start, ndata};
-        }
-        if (input[pos] == '\n' || input[pos] == '\r') {
-            return (Token){TokInvalid, start, pos + 1 - start,
-                           ErrStringNewLine};
-        }
-        if (input[pos] == '\\') {
-            if (pos + 1 >= len) {
-                return (Token){TokInvalid, start, pos - start,
-                               ErrDanglingEscape};
-            }
-            pos += 1;
-            switch (input[pos]) {
-                case '\\':
-                case '"':
-                case 'r':
-                case 'n':
-                case '0':
-                case 't':
-                    break;
-                case 'x':
-                    if (pos + 2 >= len) {
-                        return (Token){TokInvalid, start, pos - start,
-                                       ErrDanglingEscape};
-                    }
-                    if (get_hex(input[pos + 1]) > 15 ||
-                        get_hex(input[pos + 2]) > 15) {
-                        return (Token){TokInvalid, start, pos - start,
-                                       ErrStringBadHex};
-                    }
-                    pos += 2;
-                    break;
-                default:
-                    return (Token){TokInvalid, start, pos - start,
-                                   ErrBadStringEscape};
-            }
-        }
-        ndata += 1;
-    }
-    return (Token){TokString, start, pos - start, ndata};
-}
-
-static Token token(char *input, size_t len, size_t pos) {
     char chr, chru;
     char *ptr = &input[pos];
-    while (pos < len && (input[pos] == ' ' || input[pos] == '\t')) {
+    while (pos < len && (input[pos] == ' ' || input[pos] == '\t'))
+    {
         pos += 1;
     }
-    if (pos == len) {
+    if (pos == len)
+    {
         return (Token){TokEOF, pos, 0, 0};
     }
     ptr = &input[pos];
     chr = *ptr;
-    if (chr == ',' || chr == '-' || chr == '.' || chr == ':') {
+    if (chr == ',' || chr == '-' || chr == '.' || chr == ':')
+    {
         return (Token){(TokenKind)chr, pos, 1, 0};
     }
-    if (chr == '\n') {
+    if (chr == '\n')
+    {
         return (Token){TokNewline, pos, 1, 0};
     }
-    if (chr == '\r') {
+    if (chr == '\r')
-        if (pos + 1 < len && ptr[1] == '\n') {
+    {
+        if (pos + 1 < len && ptr[1] == '\n')
+        {
             return (Token){TokNewline, pos, 2, 0};
         }
         return (Token){TokNewline, pos, 1, 0};
     }
-    if (chr == ';') {
+    if (chr == ';')
+    {
         size_t clen = 1;
-        while (pos + clen < len && ptr[clen] != '\n' && ptr[clen] != '\r') {
+        while (pos + clen < len && ptr[clen] != '\n' && ptr[clen] != '\r')
+        {
             clen += 1;
         }
         return (Token){TokComment, pos, clen, 0};
     }
-    if (chr == '"') {
+    if (chr >= '0' && chr <= '9')
-        return token_string(input, len, pos);
+    {
-    }
-    if (chr >= '0' && chr <= '9') {
         return token_number(input, len, pos);
     }
     chru = chr & ~0x20;
-    if (chr == '_' || (chru >= 'A' && chru <= 'Z')) {
+    if (chr == '_' || (chru >= 'A' && chru <= 'Z'))
+    {
         return token_ident(input, len, pos);
     }
     return (Token){TokInvalid, pos, 1, 0};