Apply agreed naming conventions

Implement atoi
Parse strings to integer (binary, octal, decimal, or hexadecimal)
2026-09-04 23:53:46 +02:00 · 2026-09-04 23:47:01 +02:00
15 changed files with 17 additions and 1452 deletions
@@ -16,22 +16,10 @@ All functions in the standard library should follow the following outline:
 ; Arguments: <which register contains what argument>
 ; Result: <what is the result, and where is it stored>
 ; Clobbers: <list of registers that are clobbered>
-; Globals: <list of globals are accessed. OPTIONAL>
-; Errors: <list of any status codes returned in flags. OPTIONAL>
 <label>: <;SHOULD BE INLINED>
    <CODE>

 ```

 Functions should be in the appropriate asm file, if you are unsure where functionality fits make a seperate file and ask in the pull request
-Functions that are provided for convenience/reference but should be inlined in production code should be marked with `;SHOULD BE INLINED` after their label.
-
-If the function returns a status code in flags, the preamble should list all it might return.
-
-## Globals
-
-Any function that uses global variables should document this in the preamble comment, see above.
-
-A file/module should check on intialisation that the address `globals.MAGIC_ADDRESS` contains the 16 bit value `globals.MAGIC_VALUE`, to ensure that the user has properly included [[src/start.asm]] and reservered the global variable area.
-
-No opinion is offered on whether modules can assume globals variables are initialised to zero.
+Functions that are provided for convenience/reference but should be inlined in production code should be marked with `;SHOULD BE INLINED` after their label
@@ -3,7 +3,7 @@
 This is a standard library for symphony.
 It is both intended as a practical toolkit to develop more complex software as well as a teaching resource.

-If you just want to use the standard library [[src/stdlib.asm]] is your main header, include it after your code. Some modules also require [[src/start.asm]] at the very start of the program.
+If you just want to use the standard library [[src/stdlib.asm]] is your main header, include it after your code.

 If you are using it as a learning resource have a look at the [teaching folder](teaching).

@@ -20,7 +20,7 @@ If you are intersted in contributing have a look at [[CONTRIBUTING.md]]
 | preserved | sp, r8 - r12 |
 | scratch | flags, r1 - r7 |
 | arguments | r1 - r7 |
-| result | flags, r1 - r7 |
+| result | r1-r7 |
 | return address | r13 |

 Arguments not fitting into the 7 registers should be passed on the top of the stack, meaning they should be the last values pushed before the function call.
@@ -32,14 +32,9 @@ Should a function return more values than fit into the 7 registers, the caller h
 This reduces the amount of argument registers to 6 and all arguments above that shall go on the stack, the pointer to the result stack shall **always** be passed in an argument register.
 This register points at the highest available address for results, with the 8th result being stored there, the 9th below it and so on.

-Some functions return a success/failure status code in flags. A set low bit will indicate some error condition, the function may return more than one possible value to report different errors. A flags value of 0 is set on success. No other even values are used. This can be checked with `je` or `jne` immediatly on return to the caller. All other functions clobber flags.
-
 ### Stack
 Grows downwards from 0xXXFE_0000 (so top of memory -0x1_0000).

-### Globals
-Global variables are stored near the bottom of RAM in the address range 0x0010..0x0100. Programs should `include src/start` as the first line before their own code and before other includes, or otherwise reserve this space, the first instruction should be a jump to user code.
-
 ### Types

 #### String
@@ -1,43 +0,0 @@
-Symphony ISA specs for use in stdlib
-
-# `default.isa`
-The stock game ISA. Production code must comply to this. Taken from `symphony_11_functions` in game version 2.1.330A
-
-# `test.isa`
-ISA with additional instructions. These additional instructions may be used in
-the tests directory only. Some of these instructions require hardware changes.
-
-## Labels in more instructions
-
-`cmp`, `load`, and `store` instructions (but not `pload` and `pstore`) now also accept labels.
-
-## `qcall %a(label)`
-Performs a jump-and-link function call, with label size up to 32 bits.
-
-_HARDWARE:_ Store PC+4 in the result register when in jump mode.
-
-## `li %a(register) %b:U32(immediate | label)`
-Loads an immediate up to 32 bits long
-
-_HARDWARE:_ No requirements
-
-## `halt%c(condition)`
-Halts if `flags` matches the condition.
-
-_HARDWARE:_ Halt if instruction bit 31 is set AND the condition block is true.
-
-```
-condition
-""     1000
-".all" 1000
-".e"   0001
-".ne"  1001
-".b"   0010
-".ae"  1010
-".be"  0011
-".a"   1011
-".l"   0100
-".ge"  1100
-".le"  0101
-".g"   1101
-```
@@ -1,316 +0,0 @@
-[settings]
-name = "Symphony"
-
-[fields]
-
-register
-zr 0000
-r1 0001
-r2 0010
-r3 0011
-r4 0100
-r5 0101
-r6 0110
-r7 0111
-r8 1000
-r9 1001
-r10 1010
-r11 1011
-r12 1100
-r13 1101
-sp 1110
-flags 1111
-
-[instructions]
-
-nop
-00000000 00000000 00000000 00000000
-# (31337_88272577071256, `Does nothing.`)
-
-in %a(register)
-00000001 aaaa0000 00000000 00000000
-# (31337_44524771082050, `Loads an input and stores it in %a.`)
-
-out %b(register)
-00000010 00000000 0000bbbb 00000000
-# (31337_18254089726214, `Sends %b to output.`)
-
-out %a:U16(immediate)
-00010010 00000000 aaaaaaaa aaaaaaaa
-# (31337_15915531259935, `Sends %a to output.`)
-
-keyboard %a(register)
-00000011 aaaa0000 00000000 00000000
-# (31337_27868418224252, `Loads keyboard input and stores it to %a.`)
-
-screen %a(register), %b(register)
-00000100 0000aaaa 0000bbbb 00000000
-# (31337_39857449355186, `Stores the value of %b in screen setting %a.`)
-
-screen %a(register), %b:U16(immediate)
-00010100 0000aaaa bbbbbbbb bbbbbbbb
-# (31337_12835125621741, `Stores the value of %b in screen setting %a.`)
-
-time_0 %a(register)
-00000101 aaaa0000 00000000 00000000
-# (31337_72551400437977, `Loads the lower four bytes of the time value and stores it to %a.`)
-
-time_1 %a(register)
-00000110 aaaa0000 00000000 00000000
-# (31337_68219187873304, `Loads the upper four bytes of the time value and stores it to %a.`)
-
-counter %a(register)
-00000111 aaaa0000 00000000 00000000
-# (31337_67376584796076, `Loads the counter value and stores it to %a.`)
-
-
-
-nand %a(register), %b(register), %c(register)
-00100000 aaaabbbb 0000cccc 00000000
-# (31337_86705346481666, `NAND %b and %c and stores the result in %a.`)
-
-or %a(register), %b(register), %c(register)
-00100001 aaaabbbb 0000cccc 00000000
-# (31337_40732211165530, `OR %b and %c and stores the result in %a.`)
-
-and %a(register), %b(register), %c(register)
-00100010 aaaabbbb 0000cccc 00000000
-# (31337_85679146831122, `AND %b and %c and stores the result in %a.`)
-
-nor %a(register), %b(register), %c(register)
-00100011 aaaabbbb 0000cccc 00000000
-# (31337_37333076617857, `NOR %b and %c and stores the result in %a.`)
-
-add %a(register), %b(register), %c(register)
-00100100 aaaabbbb 0000cccc 00000000
-# (31337_51030225266712, `ADD %b and %c and stores the result in %a.`)
-
-sub %a(register), %b(register), %c(register)
-00100101 aaaabbbb 0000cccc 00000000
-# (31337_28652904157569, `SUB %b and %c and stores the result in %a.`)
-
-xor %a(register), %b(register), %c(register)
-00100110 aaaabbbb 0000cccc 00000000
-# (31337_46967848572964, `XOR %b and %c and stores the result in %a.`)
-
-lsl %a(register), %b(register), %c(register)
-00100111 aaaabbbb 0000cccc 00000000
-# (31337_13576771671264, `Logical shifts left %b by %c and stores the result in %a.`)
-
-lsr %a(register), %b(register), %c(register)
-00101000 aaaabbbb 0000cccc 00000000
-# (31337_67019902294705, `Logical shifts right %b by %c and stores the result in %a.`)
-
-asr %a(register), %b(register), %c(register)
-00101001 aaaabbbb 0000cccc 00000000
-# (31337_42626144645228, `Arithmetic shift right %b by %c and stores the result in %a.`)
-
-cmp %a(register), %b(register)
-00101010 1111aaaa 0000bbbb 00000000
-# (31337_54565380946620, `Compares %a and %b and stores the result in the 'flags' register.`)
-
-
-nand %a(register), %b(register), %c:U16(immediate | label)
-00110000 aaaabbbb cccccccc cccccccc
-# (31337_75302656449127, `NAND %b and %c and stores the result in %a.`)
-
-or %a(register), %b(register), %c:U16(immediate | label)
-00110001 aaaabbbb cccccccc cccccccc
-# (31337_30574433901064, `OR %b and %c and stores the result in %a.`)
-
-nor %a(register), %b(register), %c:U16(immediate | label)
-00110011 aaaabbbb cccccccc cccccccc
-# (31337_46087142860391, `NOR %b and %c and stores the result in %a.`)
-
-and %a(register), %b(register), %c:U16(immediate | label)
-00110010 aaaabbbb cccccccc cccccccc
-# (31337_86713121915282, `AND %b and %c and stores the result in %a.`)
-
-add %a(register), %b(register), %c:U16(immediate | label)
-00110100 aaaabbbb cccccccc cccccccc
-# (31337_23349431010010, `ADD %b and %c and stores the result in %a.`)
-
-sub %a(register), %b(register), %c:U16(immediate | label)
-00110101 aaaabbbb cccccccc cccccccc
-# (31337_67495552371225, `SUB %b and %c and stores the result in %a.`)
-
-xor %a(register), %b(register), %c:U16(immediate | label)
-00110110 aaaabbbb cccccccc cccccccc
-# (31337_66785854415645, `XOR %b and %c and stores the result in %a.`)
-
-lsl %a(register), %b(register), %c:U16(immediate | label)
-00110111 aaaabbbb cccccccc cccccccc
-# (31337_54577249258785, `Logical shifts left %b by %c and stores the result in %a.`)
-
-lsr %a(register), %b(register), %c:U16(immediate | label)
-00111000 aaaabbbb cccccccc cccccccc
-# (31337_16685334571248, `Logical shifts right %b by %c and stores the result in %a.`)
-
-asr %a(register), %b(register), %c:U16(immediate | label)
-00111001 aaaabbbb cccccccc cccccccc
-# (31337_55551510150818, `Arithmetic shifts right %b and %c and stores the result in %a.`)
-
-cmp %a(register), %b:U16(immediate)
-00111010 1111aaaa bbbbbbbb bbbbbbbb
-# (31337_37102964808364, `Compares %a and %b and stores the result in the 'flags' register.`)
-
-
-jmp %a(register)
-01001000 00001111 0000aaaa 00000000
-# (31337_74148826866592, `Jumps to %a.`)
-
-
-jmp %a:U16(immediate | label)
-01011000 00001111 aaaaaaaa aaaaaaaa
-# (31337_90876214388280, `Jumps to %a.`)
-
-je %a:U16(immediate | label)
-01010001 00001111 aaaaaaaa aaaaaaaa
-# (31337_88180305667389, `Jumps to %a if the values were equal (reading results from 'flags').`)
-
-jne %a:U16(immediate | label)
-01011001 00001111 aaaaaaaa aaaaaaaa
-# (31337_67178948469318, `Jumps to %a if the values were not equal (reading results from 'flags').`)
-
-
-jb %a:U16(immediate | label)
-01010010 00001111 aaaaaaaa aaaaaaaa
-# (31337_31763492459833, `Jumps to %a if the first value was below (unsigned) the second (reading results from 'flags').`)
-
-jae %a:U16(immediate | label)
-01011010 00001111 aaaaaaaa aaaaaaaa
-# (31337_82087388048746, `Jumps to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').`)
-
-jbe %a:U16(immediate | label)
-01010011 00001111 aaaaaaaa aaaaaaaa
-# (31337_26183125927881, `Jumps to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').`)
-
-ja %a:U16(immediate | label)
-01011011 00001111 aaaaaaaa aaaaaaaa
-# (31337_11626177279992, `Jumps to %a if the first value was above (unsigned) the second (reading results from 'flags').`)
-
-
-jl %a:U16(immediate | label)
-01010100 00001111 aaaaaaaa aaaaaaaa
-# (31337_71637103729391, `Jumps to %a if the first value was less (signed) than the second (reading results from 'flags').`)
-
-jge %a:U16(immediate | label)
-01011100 00001111 aaaaaaaa aaaaaaaa
-# (31337_53499765587663, `Jumps to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').`)
-
-jle %a:U16(immediate | label)
-01010101 00001111 aaaaaaaa aaaaaaaa
-# (31337_77040234358389, `Jumps to %a if the first value was less (signed) or equal to the second (reading results from 'flags').`)
-
-jg %a:U16(immediate | label)
-01011101 00001111 aaaaaaaa aaaaaaaa
-# (31337_71317192057126, `Jumps to %a if the first value was greater (signed) than the second (reading results from 'flags').`)
-
-
-
-load_8 %dest(register), [%adr(register)]
-01100000 dddd0000 0000aaaa 00000000
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_8 %dest(register), [%adr:U16(immediate)]
-01110000 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_16 %dest(register), [%adr(register)]
-01100001 dddd0000 0000aaaa 00000000
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_16 %dest(register), [%adr:U16(immediate)]
-01110001 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_32 %dest(register), [%adr(register)]
-01100010 dddd0000 0000aaaa 00000000
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_32 %dest(register), [%adr:U16(immediate)]
-01110010 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-pload %dest(register), [%adr(register)]
-01100011 dddd0000 0000aaaa 00000000
-# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
-
-pload %dest(register), [%adr:U16(immediate)]
-01110011 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
-
-store_8 [%adr(register)], %value(register)
-01100100 0000vvvv 0000aaaa 00000000
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_8 [%adr:U16(immediate)], %value(register)
-01110100 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_16 [%adr(register)], %value(register)
-01100101 0000vvvv 0000aaaa 00000000
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_16 [%adr:U16(immediate)], %value(register)
-01110101 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_32 [%adr(register)], %value(register)
-01100110 0000vvvv 0000aaaa 00000000
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_32 [%adr:U16(immediate)], %value(register)
-01110110 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-pstore [%adr(register)], %value(register)
-01100111 0000vvvv 0000aaaa 00000000
-# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
-
-pstore [%adr:U16(immediate)], %value(register)
-01110111 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
-
-
-mov %a(register), %b(register)
-00100001 aaaa0000 0000bbbb 00000000
-# (31337_53941960758392, `Moves a value to %a from %b.`)
-
-mov %a(register), %b:U16(immediate | label)
-00110001 aaaa0000 bbbbbbbb bbbbbbbb
-# (31337_34859363394334, `Moves a value to %a.`)
-
-neg %a(register), %b(register)
-00100101 aaaa0000 0000bbbb 00000000
-# (31337_72894099288447, `Negates a %b and stores it in %a.`)
-
-neg %a(register), %b:U16(immediate | label)
-00110101 aaaa0000 bbbbbbbb bbbbbbbb
-# (31337_57504570243305, `Negates a value and stores it in %a.`)
-
-not %a(register), %b(register)
-00100011 aaaa0000 0000bbbb 00000000
-# (31337_55357258069734, `Toggles the bits of %b and stores it in %a.`)
-
-not %a(register), %b:U16(immediate | label)
-00110011 aaaa0000 bbbbbbbb bbbbbbbb
-# (31337_40508048121543, `Toggles the bits of a value and stores it in %a.`)
-
-
-push %a(register)
-00110101 11101110 00000000 00000100   01100110 0000aaaa 00001110 00000000
-# (31337_28545157055801, `Pushes %a onto the stack. This instruction is a synonym for:   sub sp, sp, 4   store_32 [sp], %a`)
-
-pop %a(register)
-01100010 aaaa0000 00001110 00000000   00110100 11101110 00000000 00000100
-# (31337_54469754973269, `Pops %a off the stack. This instruction is a synonym for:   load_32 %a, [sp]   add sp, sp, 4`)
-
-call %a(label)
-00000111 11110000 00000000 00000000   00110100 11111111 00000000 00010100   00110101 11101110 00000000 00000100   01100110 00001111 00001110 00000000   01011000 00001111 aaaaaaaa aaaaaaaa
-# (31337_57788320241950, `Calls %a. Overwrites the flag register. This instruction is a synonym for:   counter flags   add flags, flags, 20   sub sp, sp, 4   store_32 [sp], flags   jmp %a`)
-
-ret
-01100010 11110000 00001110 00000000   00110100 11101110 00000000 00000100   01001000 00001111 00001111 00000000
-# (31337_48332460366102, `Returns from the last function call. Overwrites the flag register. This instruction is a synonym for:   load_32 flags, [sp]   add sp, sp, 4   jmp flags`)
-
@@ -1,361 +0,0 @@
-[settings]
-name = "Symphony"
-
-[fields]
-
-register
-zr 0000
-r1 0001
-r2 0010
-r3 0011
-r4 0100
-r5 0101
-r6 0110
-r7 0111
-r8 1000
-r9 1001
-r10 1010
-r11 1011
-r12 1100
-r13 1101
-sp 1110
-flags 1111
-
-condition
-""     1000
-".all" 1000
-".e"   0001
-".ne"  1001
-".b"   0010
-".ae"  1010
-".be"  0011
-".a"   1011
-".l"   0100
-".ge"  1100
-".le"  0101
-".g"   1101
-
-[instructions]
-
-nop
-00000000 00000000 00000000 00000000
-# (31337_88272577071256, `Does nothing.`)
-
-in %a(register)
-00000001 aaaa0000 00000000 00000000
-# (31337_44524771082050, `Loads an input and stores it in %a.`)
-
-out %b(register)
-00000010 00000000 0000bbbb 00000000
-# (31337_18254089726214, `Sends %b to output.`)
-
-out %a:U16(immediate)
-00010010 00000000 aaaaaaaa aaaaaaaa
-# (31337_15915531259935, `Sends %a to output.`)
-
-keyboard %a(register)
-00000011 aaaa0000 00000000 00000000
-# (31337_27868418224252, `Loads keyboard input and stores it to %a.`)
-
-screen %a(register), %b(register)
-00000100 0000aaaa 0000bbbb 00000000
-# (31337_39857449355186, `Stores the value of %b in screen setting %a.`)
-
-screen %a(register), %b:U16(immediate)
-00010100 0000aaaa bbbbbbbb bbbbbbbb
-# (31337_12835125621741, `Stores the value of %b in screen setting %a.`)
-
-time_0 %a(register)
-00000101 aaaa0000 00000000 00000000
-# (31337_72551400437977, `Loads the lower four bytes of the time value and stores it to %a.`)
-
-time_1 %a(register)
-00000110 aaaa0000 00000000 00000000
-# (31337_68219187873304, `Loads the upper four bytes of the time value and stores it to %a.`)
-
-counter %a(register)
-00000111 aaaa0000 00000000 00000000
-# (31337_67376584796076, `Loads the counter value and stores it to %a.`)
-
-
-
-nand %a(register), %b(register), %c(register)
-00100000 aaaabbbb 0000cccc 00000000
-# (31337_86705346481666, `NAND %b and %c and stores the result in %a.`)
-
-or %a(register), %b(register), %c(register)
-00100001 aaaabbbb 0000cccc 00000000
-# (31337_40732211165530, `OR %b and %c and stores the result in %a.`)
-
-and %a(register), %b(register), %c(register)
-00100010 aaaabbbb 0000cccc 00000000
-# (31337_85679146831122, `AND %b and %c and stores the result in %a.`)
-
-nor %a(register), %b(register), %c(register)
-00100011 aaaabbbb 0000cccc 00000000
-# (31337_37333076617857, `NOR %b and %c and stores the result in %a.`)
-
-add %a(register), %b(register), %c(register)
-00100100 aaaabbbb 0000cccc 00000000
-# (31337_51030225266712, `ADD %b and %c and stores the result in %a.`)
-
-sub %a(register), %b(register), %c(register)
-00100101 aaaabbbb 0000cccc 00000000
-# (31337_28652904157569, `SUB %b and %c and stores the result in %a.`)
-
-xor %a(register), %b(register), %c(register)
-00100110 aaaabbbb 0000cccc 00000000
-# (31337_46967848572964, `XOR %b and %c and stores the result in %a.`)
-
-lsl %a(register), %b(register), %c(register)
-00100111 aaaabbbb 0000cccc 00000000
-# (31337_13576771671264, `Logical shifts left %b by %c and stores the result in %a.`)
-
-lsr %a(register), %b(register), %c(register)
-00101000 aaaabbbb 0000cccc 00000000
-# (31337_67019902294705, `Logical shifts right %b by %c and stores the result in %a.`)
-
-asr %a(register), %b(register), %c(register)
-00101001 aaaabbbb 0000cccc 00000000
-# (31337_42626144645228, `Arithmetic shift right %b by %c and stores the result in %a.`)
-
-cmp %a(register), %b(register)
-00101010 1111aaaa 0000bbbb 00000000
-# (31337_54565380946620, `Compares %a and %b and stores the result in the 'flags' register.`)
-
-
-nand %a(register), %b(register), %c:U16(immediate | label)
-00110000 aaaabbbb cccccccc cccccccc
-# (31337_75302656449127, `NAND %b and %c and stores the result in %a.`)
-
-or %a(register), %b(register), %c:U16(immediate | label)
-00110001 aaaabbbb cccccccc cccccccc
-# (31337_30574433901064, `OR %b and %c and stores the result in %a.`)
-
-nor %a(register), %b(register), %c:U16(immediate | label)
-00110011 aaaabbbb cccccccc cccccccc
-# (31337_46087142860391, `NOR %b and %c and stores the result in %a.`)
-
-and %a(register), %b(register), %c:U16(immediate | label)
-00110010 aaaabbbb cccccccc cccccccc
-# (31337_86713121915282, `AND %b and %c and stores the result in %a.`)
-
-add %a(register), %b(register), %c:U16(immediate | label)
-00110100 aaaabbbb cccccccc cccccccc
-# (31337_23349431010010, `ADD %b and %c and stores the result in %a.`)
-
-sub %a(register), %b(register), %c:U16(immediate | label)
-00110101 aaaabbbb cccccccc cccccccc
-# (31337_67495552371225, `SUB %b and %c and stores the result in %a.`)
-
-xor %a(register), %b(register), %c:U16(immediate | label)
-00110110 aaaabbbb cccccccc cccccccc
-# (31337_66785854415645, `XOR %b and %c and stores the result in %a.`)
-
-lsl %a(register), %b(register), %c:U16(immediate | label)
-00110111 aaaabbbb cccccccc cccccccc
-# (31337_54577249258785, `Logical shifts left %b by %c and stores the result in %a.`)
-
-lsr %a(register), %b(register), %c:U16(immediate | label)
-00111000 aaaabbbb cccccccc cccccccc
-# (31337_16685334571248, `Logical shifts right %b by %c and stores the result in %a.`)
-
-asr %a(register), %b(register), %c:U16(immediate | label)
-00111001 aaaabbbb cccccccc cccccccc
-# (31337_55551510150818, `Arithmetic shifts right %b and %c and stores the result in %a.`)
-
-cmp %a(register), %b:U16(immediate | label)
-00111010 1111aaaa bbbbbbbb bbbbbbbb
-# (31337_37102964808364, `Compares %a and %b and stores the result in the 'flags' register.`)
-
-
-jmp %a(register)
-01001000 00001111 0000aaaa 00000000
-# (31337_74148826866592, `Jumps to %a.`)
-
-
-jmp %a:U16(immediate | label)
-01011000 00001111 aaaaaaaa aaaaaaaa
-# (31337_90876214388280, `Jumps to %a.`)
-
-je %a:U16(immediate | label)
-01010001 00001111 aaaaaaaa aaaaaaaa
-# (31337_88180305667389, `Jumps to %a if the values were equal (reading results from 'flags').`)
-
-jne %a:U16(immediate | label)
-01011001 00001111 aaaaaaaa aaaaaaaa
-# (31337_67178948469318, `Jumps to %a if the values were not equal (reading results from 'flags').`)
-
-
-jb %a:U16(immediate | label)
-01010010 00001111 aaaaaaaa aaaaaaaa
-# (31337_31763492459833, `Jumps to %a if the first value was below (unsigned) the second (reading results from 'flags').`)
-
-jae %a:U16(immediate | label)
-01011010 00001111 aaaaaaaa aaaaaaaa
-# (31337_82087388048746, `Jumps to %a if the first value was above (unsigned) or equal to the second (reading results from 'flags').`)
-
-jbe %a:U16(immediate | label)
-01010011 00001111 aaaaaaaa aaaaaaaa
-# (31337_26183125927881, `Jumps to %a if the First value was below (unsigned) or equal to the second (reading results from 'flags').`)
-
-ja %a:U16(immediate | label)
-01011011 00001111 aaaaaaaa aaaaaaaa
-# (31337_11626177279992, `Jumps to %a if the first value was above (unsigned) the second (reading results from 'flags').`)
-
-
-jl %a:U16(immediate | label)
-01010100 00001111 aaaaaaaa aaaaaaaa
-# (31337_71637103729391, `Jumps to %a if the first value was less (signed) than the second (reading results from 'flags').`)
-
-jge %a:U16(immediate | label)
-01011100 00001111 aaaaaaaa aaaaaaaa
-# (31337_53499765587663, `Jumps to %a if the first value was greater (signed) or equal to the second (reading results from 'flags').`)
-
-jle %a:U16(immediate | label)
-01010101 00001111 aaaaaaaa aaaaaaaa
-# (31337_77040234358389, `Jumps to %a if the first value was less (signed) or equal to the second (reading results from 'flags').`)
-
-jg %a:U16(immediate | label)
-01011101 00001111 aaaaaaaa aaaaaaaa
-# (31337_71317192057126, `Jumps to %a if the first value was greater (signed) than the second (reading results from 'flags').`)
-
-
-
-load_8 %dest(register), [%adr(register)]
-01100000 dddd0000 0000aaaa 00000000
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_8 %dest(register), [%adr:U16(immediate | label)]
-01110000 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_16 %dest(register), [%adr(register)]
-01100001 dddd0000 0000aaaa 00000000
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_16 %dest(register), [%adr:U16(immediate | label)]
-01110001 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_32 %dest(register), [%adr(register)]
-01100010 dddd0000 0000aaaa 00000000
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-load_32 %dest(register), [%adr:U16(immediate | label)]
-01110010 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_57200935026773, `Loads address %adr from main memory and stores it to %dest.`)
-
-pload %dest(register), [%adr(register)]
-01100011 dddd0000 0000aaaa 00000000
-# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
-
-pload %dest(register), [%adr:U16(immediate)]
-01110011 dddd0000 aaaaaaaa aaaaaaaa
-# (31337_89257021109854, `Loads address %adr from persistent memory and stores it to %dest.`)
-
-store_8 [%adr(register)], %value(register)
-01100100 0000vvvv 0000aaaa 00000000
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_8 [%adr:U16(immediate | label)], %value(register)
-01110100 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_16 [%adr(register)], %value(register)
-01100101 0000vvvv 0000aaaa 00000000
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_16 [%adr:U16(immediate | label)], %value(register)
-01110101 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_32 [%adr(register)], %value(register)
-01100110 0000vvvv 0000aaaa 00000000
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-store_32 [%adr:U16(immediate | label)], %value(register)
-01110110 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_61040780958703, `Stores %value to address %adr in main memory.`)
-
-pstore [%adr(register)], %value(register)
-01100111 0000vvvv 0000aaaa 00000000
-# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
-
-pstore [%adr:U16(immediate)], %value(register)
-01110111 0000vvvv aaaaaaaa aaaaaaaa
-# (31337_13110303123442, `Stores %value to address %adr in persistent memory.`)
-
-
-mov %a(register), %b(register)
-00100001 aaaa0000 0000bbbb 00000000
-# (31337_53941960758392, `Moves a value to %a from %b.`)
-
-mov %a(register), %b:U16(immediate | label)
-00110001 aaaa0000 bbbbbbbb bbbbbbbb
-# (31337_34859363394334, `Moves a value to %a.`)
-
-neg %a(register), %b(register)
-00100101 aaaa0000 0000bbbb 00000000
-# (31337_72894099288447, `Negates a %b and stores it in %a.`)
-
-neg %a(register), %b:U16(immediate | label)
-00110101 aaaa0000 bbbbbbbb bbbbbbbb
-# (31337_57504570243305, `Negates a value and stores it in %a.`)
-
-not %a(register), %b(register)
-00100011 aaaa0000 0000bbbb 00000000
-# (31337_55357258069734, `Toggles the bits of %b and stores it in %a.`)
-
-not %a(register), %b:U16(immediate | label)
-00110011 aaaa0000 bbbbbbbb bbbbbbbb
-# (31337_40508048121543, `Toggles the bits of a value and stores it in %a.`)
-
-
-push %a(register)
-00110101 11101110 00000000 00000100   01100110 0000aaaa 00001110 00000000
-# (31337_28545157055801, `Pushes %a onto the stack. This instruction is a synonym for:   sub sp, sp, 4   store_32 [sp], %a`)
-
-pop %a(register)
-01100010 aaaa0000 00001110 00000000   00110100 11101110 00000000 00000100
-# (31337_54469754973269, `Pops %a off the stack. This instruction is a synonym for:   load_32 %a, [sp]   add sp, sp, 4`)
-
-call %a(label)
-00000111 11110000 00000000 00000000   00110100 11111111 00000000 00010100   00110101 11101110 00000000 00000100   01100110 00001111 00001110 00000000   01011000 00001111 aaaaaaaa aaaaaaaa
-# (31337_57788320241950, `Calls %a. Overwrites the flag register. This instruction is a synonym for:   counter flags   add flags, flags, 20   sub sp, sp, 4   store_32 [sp], flags   jmp %a`)
-
-ret
-01100010 11110000 00001110 00000000   00110100 11101110 00000000 00000100   01001000 00001111 00001111 00000000
-# (31337_48332460366102, `Returns from the last function call. Overwrites the flag register. This instruction is a synonym for:   load_32 flags, [sp]   add sp, sp, 4   jmp flags`)
-
-
-li %r(register), %a:S33(immediate | label)
-; assert(0 - 0x80000000 <= %a, "%a is too low")
-; assert(%a <= 0xffffffff, "%a is too high")
-%s = trailing_zeros(%a)
-%sa = %a >> %s
-%nota = %a ^ 0xffffffff
-when %a <=u 0xffff   : 00110001 %r[3:0]0000 %a[15:0]                                                 ; First 64k
-when %nota <=u 0xffff: 00110001 %r[3:0]0000 %nota[15:0]    00100011 %r[3:0]0000 0000%r[3:0] 00000000 ; Last 64k
-when %sa <=u 0xffff  : 00110001 %r[3:0]0000 %sa[15:0]      00110111 %r[3:0]%r[3:0] 00000000 %s[7:0]  ; Aligned
-00110001 %r[3:0]0000 %a[31:16]   00110111 %r[3:0]%r[3:0] 00000000 00010000   00110001 %r[3:0]%r[3:0] %a[15:0]          ; Any 32-bit
-# Load 32-bit immediate %a into %r
-
-qcall %a:U32(label)
-; assert(0 - 0x80000000 <= %a, "%a is too low")
-; assert(%a <= 0xffffffff, "%a is too high")
-%r = 13
-%f = 15
-%s = trailing_zeros(%a)
-%sa = %a >> %s
-%nota = %a ^ 0xffffffff
-when %a <=u 0xffff   : 01011000 %r[3:0]ffff %a[15:0]                                                                                              ; First 64k
-when %nota <=u 0xffff: 00110001 %r[3:0]0000 %nota[15:0]    00100011 %r[3:0]0000 0000%r[3:0] 00000000    01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Last 64k
-when %sa <=u 0xffff  : 00110001 %r[3:0]0000 %sa[15:0]      00110111 %r[3:0]%r[3:0] 00000000 %s[7:0]     01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Aligned
-00110001 %r[3:0]0000 %a[31:16]   00110111 %r[3:0]%r[3:0] 00000000 00010000   00110001 %r[3:0]%r[3:0] %a[15:0]    01001000 %r[3:0]ffff 0000%r[3:0] 00000000 ; Any 32-bit
-# Jump and link to 32-bit label
-
-halt%c(condition)
-1000cccc 00001111 00000000 00000000
-# Halt on condition %c
-
@@ -1,30 +0,0 @@
-; Error numbers should be 16 bit ODD numbers, so they can be loaded as immediates
-; and can be checked with:
-;
-;   qcall falible_function
-;   jne falible_ok ; Jump no error
-;       ; handle error
-;   falible_ok:
-;   ; Happy path
-;   ; ...
-; OR
-;   qcall falible_function
-;   je handle_error ; Jump if error
-;   ; Happy path
-;   ; ...
-;   handle_error:
-;       ; handle error
-
-pub const OK                   = 0x0000
-pub const SCREEN_INVALID_MODE  = 0x0001
-pub const SCREEN_INVALID_WIDTH = 0x0003
-pub const SCREEN_FB_TOO_SMALL  = 0x0005
-pub const SCREEN_OUTSIDE_FB    = 0x0007
-
-pub const INTTOSTR_BAD_BASE    = 0x0101
-pub const INTTOSTR_BAD_BUFFER  = 0x0103
-
-pub const MAGIC_BAD            = 0x8001
-
-; Extended error codes, these would require loading a 32 bit value.
-pub const EXT_OK              = 0x00000000
@@ -1,30 +0,0 @@
-; Addresses of global variables
-
-pub const MAGIC_ADDRESS_LONG = 0x0c       ; U32 Location of the magic value
-pub const MAGIC_VALUE_LONG   = 0xb301534c ; U32 Full 32 bits of the magic value
-pub const MAGIC_ADDRESS      = 0x0e       ; U16 Location of the low 16 bits of magic value
-pub const MAGIC_VALUE        = 0x534c     ; U16 Low 16 bits of the magic value
-
-; If not double buffering these point to the same buffer
-; If double buffering they must the same size
-pub const FB_DISPLAY_PTR     = 0x10       ; U32 Currently displayed buffer
-pub const FB_DISPLAY_STRIDE  = 0x14       ; U16 Bytes in each row of the displayed buffer
-pub const FB_DISPLAY_DEPTH   = 0x16       ; U16 Bits per pixel of the display buffer
-pub const FB_DRAW_PTR        = 0x18       ; U32 Draw to this buffer
-pub const FB_DRAW_STRIDE     = 0x1c       ; U16 Bytes in each row of the draw buffer == FB_DISPLAY_STRIDE
-pub const FB_DRAW_DEPTH      = 0x1e       ; U16 Bits per pixel of the draw buffer == FB_DISPLAY_DEPTH
-pub const FB_SIZE_BYTE       = 0x20       ; U32 In bytes
-pub const FB_WIDTH_PX        = 0x24       ; U16 Width of screen in pixels
-pub const FB_HEIGHT_PX       = 0x26       ; U16 Height of screen in pixels
-
-; Log2 of width in pixels, e.g.
-; * 10 => 1024 * 768
-; *  8 =>  256 * 192
-pub const FB_LOG_WIDTH       = 0x28       ; U8
-pub const FB_LOG_STRIDE      = 0x29       ; U8 Log2 of FB_xxx_STRIDE in bytes
-
-pub const FB_BYTES_PER_PIXEL = 0x2a       ; U8 Specialisations should hardcode this
-; Log2 of bytes per pixel
-; * 0 => 8 bits per pixel
-; * 2 => 32 bits per pixel
-pub const FB_LOG_BPP         = 0x2b       ; U8 Specialisations should hardcode this
@@ -4,53 +4,22 @@
 ; r2 - The second value
 ; Result:
 ; r1 - The lower 32 bits of the result
-; Clobbers: r2, r3, r4, r5, r6
+; Clobbers: r2, r3, r4, r5
 pub mul_low:
-	cmp r1, r2
-	jbe mul_low_noswap
-	xor r1, r2, r1
-	xor r2, r1, r2
-	xor r1, r2, r1
-	; Passthrough
-
-; Multiplies r1 and r2, returning the lower part of the result
-; This method assumes r1 is smaller than r2, which results in faster execution
-; Arguments:
-; r1 - The first value
-; r2 - The second value
-; Result:
-; r1 - The lower 32 bits of the result
-; Clobbers: r2, r3, r4, r5, r6
-pub mul_low_noswap:
-	mov r4, 0 ; r4 has the result
-	mov r6, mul_loop_end
-	add r3, r2, r2
+	mov r3, 0 ; result
+	mov r4, 31 ; loop counter
+	
+	mul_low_loop:
+		asr r5, r2, 31
+		and r5, r5, r1
+		lsl r5, r5, r4
+		add r3, r3, r5
+		lsl r2, r2, 1
+		sub r4, r4, 1
+		cmp r4, 0
+		jge mul_low_loop
+	mov r1, r3
 	
-	mul_loop:
-		and r5, r1, 14 ; Taking the first four bits, discarding the odd
-		lsl r5, r5, 1 ; 0000 - 0, 0001 - 2, 0010 - 4, 0011 - 8, etc.
-		sub r5, r6, r5
-		jmp r5
-		
-		add r4, r4, r3
-		add r4, r4, r3
-		add r4, r4, r3
-		add r4, r4, r3
-		add r4, r4, r3
-		add r4, r4, r3
-		add r4, r4, r3
-		mul_loop_end:
-			mov flags, r1
-			jne mul_skip_one
-			add r4, r4, r2
-			mul_skip_one:
-			lsl r2, r2, 4
-			lsl r3, r3, 4
-			lsr r1, r1, 4
-			cmp r1, zr
-			jne mul_loop
-
-	mov r1, r4
 	jmp r13

 ; Calculates the absolute value of the value provided in the r1 register
@@ -1,239 +0,0 @@
-include errno
-
-; Convert integer to string
-; Arguments:
-; r1 - Integer
-; r2 - Start of buffer
-; r3 - Buffer length
-; r4 - Base (2, 8, 10, or 16)
-; Result:
-; none
-; Clobbers:
-; Based on specialization
-pub auto:
-cmp r4, 2
-je bin
-cmp r4, 8
-je oct
-cmp r4, 16
-je hex
-cmp r4, 10
-jmp dec
-mov flags, errno.INTTOSTR_BAD_BASE
-jmp r13
-
-; The output buffer is too small for this integer
-badbuffer:
-mov flags, errno.INTTOSTR_BAD_BUFFER
-jmp r13
-
-; All digits have been output. Null terminate and exit.
-done:
-store_8 [r2], zr
-mov flags, errno.OK
-jmp r13
-
-; Convert integer to binary string
-; Arguments:
-; r1 - Integer
-; r2 - Start of buffer
-; r3 - Buffer length
-; Result:
-; none
-; Clobbers:
-; flags
-; r4 - counter
-; r5 - character
-pub bin:
-mov r4, 31
-cmp r2, 2
-jl badbuffer
-
-bin_find_one:
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 1
-sub r4, r4, 1
-
-cmp r4, zr              ; Start printing if last bit ...
-jl bin_print
-cmp r5, zr              ; .. or if nonzero
-je bin_find_one
-
-add flags, r4, 3        ; Check buffer size
-cmp flags, r3
-ja badbuffer
-
-bin_print:
-add r5, r5, 0x30 ; '0'  ; Add digit to buffer
-store_8 [r2], r5
-add r2, r2, 1
-cmp r4, zr              ; Done if last bit
-jl done
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 1
-sub r4, r4, 1
-jmp bin_print
-
-; Convert integer to octal string
-; Arguments:
-; r1 - Integer
-; r2 - Start of buffer
-; r3 - Buffer length
-; Result:
-; none
-; Clobbers:
-; flags
-; r4 - input counter
-; r5 - character
-; r6 - output size counter
-pub oct:
-mov r4, 30
-mov r6, 12
-
-oct_find_one:
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 7
-sub r4, r4, 3
-sub r6, r6, 1
-
-cmp r4, zr              ; Start printing if last bit ...
-jl oct_print
-cmp r5, zr              ; .. or if nonzero
-je oct_find_one
-
-cmp r6, r3              ; Check buffer size
-ja badbuffer
-
-oct_print:
-add r5, r5, 0x30 ; '0'  ; Add digit to buffer
-store_8 [r2], r5
-add r2, r2, 1
-cmp r4, zr              ; Done if last bit
-jl done
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 7
-sub r4, r4, 3
-jmp oct_print
-
-; Convert integer to hexadecimal string
-; Arguments:
-; r1 - Integer
-; r2 - Start of buffer
-; r3 - Buffer length
-; Result:
-; none
-; Clobbers:
-; flags
-; r4 - input counter
-; r5 - character
-pub hex:
-mov r4, 28
-
-hex_find_one:
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 0xF
-sub r4, r4, 4
-
-cmp r4, zr              ; Start printing if last bit ...
-jl hex_print
-cmp r5, zr              ; .. or if nonzero
-je hex_find_one
-
-lsr flags, r5, 2        ; Check buffer size
-add flags, flags, 3
-cmp flags, r3
-ja badbuffer
-
-hex_print:
-add r5, r5, 0x30 ; '0'  ; Add digit to buffer
-cmp r5, 0x39 ; '9'
-jle hex_no_letter
-add r5, r5, 0x07 ; 'A' - '0' - 10
-hex_no_letter:
-store_8 [r2], r5
-add r2, r2, 1
-cmp r4, zr              ; Done if last bit
-jl done
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 0xF
-sub r4, r4, 4
-jmp hex_print
-
-; Convert integer to decimal string
-; Arguments:
-; r1 - Integer
-; r2 - Start of buffer
-; r3 - Buffer length
-; Result:
-; none
-; Clobbers:
-; flags
-; r4, r5
-pub dec:
-mov r4, 0x5F5
-lsl r4, r4, 16
-add r4, r4, 0xE100 ; 100 million; 8 digits
-cmp r1, r4
-jl dec_small
-; TODO large
-
-
-; Small numbers have at least most 8 digits, thus their BCD form fits in
-; one register. Bit 26 is the highest which can be set.
-;
-; Utilizes double dabble
-; r4, r5 are loop counters
-;
-; for( r4 = 24 ; r4 > 0 ; r4-- )
-;   for( r5 = r4 ; r5 <= 28 ; r5+= 4 )
-;     if( ((r1 >> r5) & 0xF) >= 5 )
-;       r1 += 3 << r5
-dec_small:
-mov r4, 24
-dec_small_dabble_outer:
-mov r5, r4
-dec_small_dabble_inner:
-lsr flags, r1, r5
-and flags, flags, 0xF
-cmp flags, 5
-jl dec_small_dabble_noinc
-mov flags, 3
-lsl flags, flags, r5
-add r1, r1, flags
-dec_small_dabble_noinc:
-add r5, r5, 4
-cmp r5, 28
-jle dec_small_dabble_inner
-sub r4, r4, 1
-cmp r4, zr
-jg dec_small_dabble_outer
-
-; Print the BCD in r1
-; r4 is a counter
-; r5 is the output character
-mov r4, 28
-dec_find_one:
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 0xF
-sub r4, r4, 4
-
-cmp r4, zr               ; Start printing if last bit ...
-jl dec_print
-cmp r5, zr              ; .. or if nonzero
-je dec_find_one
-
-lsr flags, r5, 2        ; Check buffer size
-add flags, flags, 3
-cmp flags, r3
-ja badbuffer
-
-dec_print:
-add r5, r5, 0x30 ; '0'  ; Add digit to buffer
-store_8 [r2], r5
-add r2, r2, 1
-cmp r4, zr              ; Done if last bit
-jl done
-lsr r5, r1, r4          ; Select bit and advance counter
-and r5, r5, 0xF
-sub r4, r4, 4
-jmp dec_print
@@ -1,174 +0,0 @@
-; int compare(uint8_t* a, uint8_t* b, size_t count);
-;   Compares two memory segment of equal length lexicographically.
-;
-; Arguments:
-; - `r1`: A pointer to the first memory segment.
-; - `r2`: A pointer to the second memory segment.
-; - `r3`: The size of both memory segments.
-; Results:
-; - `r1`:
-;   -  `0` if both segments are equal.
-;   - `<0` if the first segment is less than the second segment.
-;   - `>0` if the first segment is greater than the second segment.
-;
-pub compare:
-    ; Exclusive end point of the first segment.
-    add r3, r3, r1
-    sub r3, r3, 4
-_compare__loop:
-    load_32 r4, [r1]
-    add r1, r1, 4
-    load_32 r5, [r2]
-    add r2, r2, 4
-    ; Comparing two sequences of 4 bytes lexicographically is equivalent to
-    ; comparing the corresponding big endian 32 bit words.
-    cmp r4, r5
-    jne _compare__break
-    ; Check if there are enough bytes left to continue with the vectorized loop.
-    cmp r1, r3
-    jbe _compare__loop
-    ; `r3 + 4 - r1 = <remaining byte count> = r3 - r1 mod 4`
-    sub flags, r3, r1
-    ; Check if one of the lowest 2 bits is non-zero
-    jbe _compare__rem
-    ; If not, we are done. Both segments are equal.
-    mov r1, 0
-    jmp r13
-_compare__break:
-    ; `flags` is the comparison result in the format of `cmp`. Convert it to the desired format.
-    ; 00 => 0x40000000 > 0
-    ; 01 => 0x00000000 = 0
-    ; 10 => 0xC0000000 < 0
-    xor r1, flags, 1
-    lsl r1, r1, 30
-    jmp r13
-_compare__rem:
-    ; Compute `S = 8*(4 - <remaining byte count>)` and
-    ; [r1] >> S, [r2] >> S
-    mov r3, 8
-    load_32 r4, [r1]
-    sub r3, r3, flags
-    load_32 r5, [r2]
-    lsl r3, r3, 3
-    lsr r4, r4, r3
-    lsr r5, r5, r3
-    ; Compare both values, now with garbage bytes removed.
-    cmp r4, r5
-    jmp _compare__break
-
-
-; void copy(void* src, void* dest, size_t count);
-;   Copies `count` bytes from `src` to `dest`. The two memory segments must not overlap.
-;
-; Arguments:
-; - `r1`: Pointer to the memory segment to be copied.
-; - `r2`: Pointer to the memory segment to be copied into.
-; - `r3`: Byte size of both the `src` and `dest` segments.
-;
-pub copy:
-    ; Exclusive end point of the source segment.
-    add r3, r1, r3
-    ; Last index from where we can safely copy 8 bytes per loop iteration.
-    sub r3, r3, 8
-    jmp _copy__loop_entry
-_copy__loop:
-    ; Copy 8 bytes from `src` to `dest`.
-    load_32 flags, [r1]
-    add r1, r1, 4
-    store_32 [r2], flags
-    add r2, r2, 4
-    load_32 flags, [r1]
-    add r1, r1, 4
-    store_32 [r2], flags
-    add r2, r2, 4
-_copy__loop_entry:
-    ; Check if we can process more data in the vectorized loop.
-    cmp r1, r3
-    jbe _copy__loop
-    ; The remaining amount of bytes `R` is `R = r3 + 8 - r1 = r3 - r1 mod 8`.
-    sub flags, r3, r1
-    ; Test if `R` is not a multiple of `4`, i.e. the lowest 2 bits are non-zero.
-    jbe _copy__rem
-    ; `R` is a multiple of `4`. Special case this.
-    ; Check if `R` is `0`, i.e. the third bit is also 0. In that case, we are already done.
-    ; There are no conditional indirect jumps, so we can't return immediately.
-    jge _copy__ret
-    ; `R = 4`. No need to update `r1` or `r2`, we don't need them anymore.
-    load_32 flags, [r1]
-    store_32 [r2], flags
-_copy__ret:
-    ; Return
-    jmp r13
-_copy__rem:
-    ; Optimize the remaining cases for code size.
-    ; End point of the source segment.
-    add r3, r3, 8
-    ; We already handled the case `R = 0` earlier,
-    ; so no bounds check needed for the first iteration.
-_copy__rem_loop:
-    ; Copy 1 byte.
-    load_8 flags, [r1]
-    add r1, r1, 1
-    store_8 [r2], flags
-    add r2, r2, 1
-    ; Check if we are still within the bounds.
-    cmp r1, r3
-    jb _copy__rem_loop
-    jmp r13
-    
-; void fill32(uint8_t* dest, size_t count, uint32_t value);
-;   Fills `count` bytes in `dest` with `value`. If `count` is not a multiple of 4, 
-;   the least significant bytes of `value` are cut off for the last entry.
-;
-; Arguments:
-; - `r1`: A pointer to the destination segment.
-; - `r2`: The size of the destination segment.
-; - `r3`: The 32 bit value that the segment is filled with.
-;
-pub fill32:
-    ; Exclusive end point of the destination segment.
-    add r2, r1, r2
-    ; Last index from where we can safely write 8 bytes per loop iteration.
-    sub r2, r2, 8
-    jmp _fill32__entry
-_fill32__loop:
-	; Set 8 bytes per loop iteraion.
-    store_32 [r1], r3
-    add r1, r1, 4
-    store_32 [r1], r3
-    add r1, r1, 4
-_fill32__entry:
-    ; Check if we can process more data in the vectorized loop.
-    cmp r1, r2
-    jbe _fill32__loop
-    ; The remaining amount of bytes `R` is `R = r2 + 8 - r1 = r2 - r1 mod 8`.
-    sub flags, r2, r1
-    ; Check if the third bit of the remainder is cleared.
-    jge _fill32__r4
-    ; Otherwise set 4 bytes.
-    store_32 [r1], r3
-    add r1, r1, 4
-_fill32__r4:
-    ; Check if the two least significant bits of the remainder are zero.
-    ja _fill32__ret
-    ; Handle the remaining bytes `R` individually, in reverse order.
-    add r2, r2, 4
-    ; `r1 + 4 - r2 = 4 - R`.
-    sub flags, r1, r2
-    ; Exclusive end point of the destination segment.
-    add r2, r2, 4
-    ; Shift out the least significant `8*(4 - R)` bits of the value.
-    lsl flags, flags, 3
-    lsr r3, r3, flags
-    jmp _fill32__loop2_entry
-_fill32__loop2:
-    sub r2, r2, 1
-    ; Write the least significant byte of the value...
-    store_8 [r2], r3
-    ; and then shift it out.
-    lsr r3, r3, 8
-_fill32__loop2_entry:
-    cmp r1, r2
-    jb _fill32__loop2
-_fill32__ret:
-    jmp r13
@@ -1,19 +0,0 @@
-;@0 ; Reserve space for globals
-
-; First initialise the stack pointer
-nor sp, zr, 0xffff
-; Jump over the globals to user code
-jmp 0x100
-
-U32 0 ; 4 bytes
-
-; MAGIC_VALUE
-;@0x0c
-U32 0xb301534c
-
-; Pad with zeroes since the @addr feature is currently broken.
-; * https://discord.com/channels/828292123936948244/1545010596246847568
-;
-U1920 0  ; 240 bytes
-
-;@0x100 ; start of user code
@@ -2,10 +2,7 @@ pub include bit
 pub include imath
 pub include array
 pub include console
-pub include mem
-pub include string
 pub include string_to_int
-pub include int_to_string

 ; Needs to be last!
 pub include LUTs
@@ -1,33 +0,0 @@
-; Compare two strings
-; Arguments:
-; r1 - Pointer to string 1
-; r2 - Pointer to string 2
-; Result:
-; r1:
-;   -  `0` if both segments are equal.
-;   - `<0` if the first segment is less than the second segment.
-;   - `>0` if the first segment is greater than the second segment.
-; flags - Compare result
-; Clobbers:
-; r3 - last byte of r1 tested
-; r4 - last byte of r2 tested
-pub compare:
-load_8 r3, [r1]
-add r1, r1, 1
-load_8 r4, [r2]
-add r2, r2, 1
-cmp zr, r3              ; End of string 1
-je done
-cmp zr, r4              ; End of string 2
-je done
-cmp r3, r4
-je compare              ; Loop, tail recursion, what's the difference
-done:
-cmp r3, r4
-; `flags` is the comparison result in the format of `cmp`. Convert it to the desired format.
-; 00 => 0x40000000 > 0
-; 01 => 0x00000000 = 0
-; 10 => 0xC0000000 < 0
-xor r1, flags, 1
-lsl r1, r1, 30
-jmp r13
@@ -1,77 +0,0 @@
-; int compare(uint8_t* a, uint8_t* b, size_t count);
-;   Compares two memory segment of equal length lexicographically.
-;   Temporarily modifies the byte at address `a + count`.
-;
-; Arguments:
-; - `r1`: A pointer to the first memory segment.
-; - `r2`: A pointer to the second memory segment.
-; - `r3`: The size of both memory segments.
-; Results:
-; - `r1`:
-;   -  `0` if both segments are equal.
-;   - `<0` if the first segment is less than the second segment.
-;   - `>0` if the first segment is greater than the second segment.
-pub compare:
-    cmp r1, r2
-    je _compare__is_eq
-    ; Exclusive end point of the second segment.
-    add r4, r3, r2
-    ; Exclusive end point of the first segment.
-    add r3, r3, r1
-    load_8 r6, [r3]
-    load_8 flags, [r4]
-    ; Check if the first bytes behind the sequences are equal.
-    cmp flags, r6
-    jne _compare__loop
-    ; Change the byte directly behind the first segment.
-    xor r4, r6, 1
-    ; This would be problematic if someone calls compare with a first segment
-    ; whose end point overlaps the program memory of this function.
-    store_8 [r3], r4
-_compare__loop:
-    load_32 r4, [r1]
-    add r1, r1, 4
-    load_32 r5, [r2]
-    add r2, r2, 4
-    ; Comparing two sequences of 4 bytes lexicographically is equivalent to
-    ; comparing the corresponding big endian 32 bit words.
-    cmp r4, r5
-    je _compare__loop
-    ; We overshot in the loop; decrement r1 again. (Only by 2, we backtrack the rest if necessary later)
-    sub r1, r1, 2
-    ; Restore the byte we changed.
-    store_8 [r3], r6
-    ; We encountered two different words. Figure out what byte they differ on.
-    xor r4, r4, r5
-    ; Store the flags for later, to figure out the return value.
-    mov r5, flags
-    ; Check if at least one of the two most significant bytes is not 0.
-    cmp r4, 0xffff
-    jbe _compare__low2
-    ; If it is, backtrack the remaining 2 indices.
-    ; Shift the most significant bytes to the least significant ones.
-    sub r1, r1, 2
-    lsr r4, r4, 16
-_compare__low2:
-    ; r1 now points to a non-zero 16 bit value.
-    ; If the 16 bit value at r1-2 is in-bounds, then it is 0.
-    ; Check if the most significant byte of the 16 bit value is 0.
-    cmp r4, 0xff
-    ja _compare__low1
-    ; If it is, our target is the least significant byte.
-    add r1, r1, 1
-_compare__low1:
-    ; Otherwise, the target is that non-zero byte.
-    ; Check if the target is out of bounds, i.e. the loop terminated through the "bounds check".
-    cmp r1, r3
-    jae _compare__is_eq
-    ; r5 is the comparison result in the format of `cmp`. Convert it to the desired format.
-    ; 00 => 0x40000000 > 0
-    ; 01 => 0x00000000 = 0
-    ; 10 => 0xC0000000 < 0
-    xor r1, r5, 1
-    lsl r1, r1, 30
-    jmp r13
-_compare__is_eq:
-    mov r1, 0
-    jmp r13
@@ -1,62 +0,0 @@
-; test harness for int_to_string
-; Registers:
-; r8 - test address
-; r9 - test method
-; r12 - end of tests address
-li r8, tests
-li r12, end_of_tests
-next_test:
-; Set up arguments and run test
-load_32 r1, [r8]        ; Input value
-li r2, scratch          ; Output buffer
-mov r3, 64              ; Output buffer size
-add r4, r8, 4           ; Base
-load_8 r4, [r4]
-mov r13, itoa_test_ret  ; return address
-jmp stdlib.int_to_string.auto
-itoa_test_ret:
-nop                     ; For breakpoint after itoa but before r1 clobber
-
-; Strcmp to check results
-add r1, r8, 5           ; expected output
-li r2, scratch          ; actual output
-mov r13, itoa_strcmp_ret
-jmp stdlib.string.compare
-itoa_strcmp_ret:
-
-; Verify results
-halt.ne
-
-; Next test
-add r8, r8, 0x40
-cmp r8, r12
-jl next_test
-
-; Done
-halt
-
-
-include ../src/stdlib
-
-@0x20000
-tests:
-; inlen is the number of input bytes the function is expected to consume
-; addr   int            base  result
-@0x20000 U32 0b0        U8 2  "0\0"
-@0x20040 U32 0xFFFFFFFF U8 2  "11111111111111111111111111111111\0"
-@0x20080 U32 0b101010   U8 2  "101010\0"
-@0x200c0 U32 0o0        U8 8  "0\0"
-@0x20100 U32 0o640      U8 8  "640\0"
-@0x20140 U32 0xFFFFFFFF U8 8  "37777777777\0"
-@0x20180 U32 0x0        U8 16 "0\0"
-@0x201c0 U32 0x32fF6    U8 16 "32FF6\0"
-@0x20200 U32 0xdeadbeef U8 16 "DEADBEEF\0"
-@0x20240 U32 0xFFFFFFFF U8 16 "FFFFFFFF\0"
-@0x20280 U32 0          U8 10 "0\0"
-@0x202c0 U32 42069      U8 10 "42069\0"
-@0x20300 U32 12345678   U8 10 "12345678\0"
-@0x20340 U32 99999999   U8 10 "99999999\0"
-@0x20380
-end_of_tests:
-scratch: U1024 0
-
Author	SHA1	Message	Date
PleegWat	fbdcadfe9b	Apply agreed naming conventions	2026-09-04 23:53:46 +02:00
PleegWat	3cadaede57	Implement atoi Parse strings to integer (binary, octal, decimal, or hexadecimal)	2026-09-04 23:47:01 +02:00