nienor

• Wrote additional gui test,
• Fixed typechecker again,
• Added embed macro, that embeds files as bytes,
• Finally fixed macro generator for binary operators,
• All roms now get metadata,
• Vendored a font in res/ with some minor changes
• Wrote a blog post on macro expansion https://krzysckh.org/b/Dead-simple-macroexpansion-for-ni%C3%ABnor.html

i used quite a lot of brain power on this
- added deeper typechecking (more on that later)
- added -M to test macroexpand/optimize combo

consider this:
```
(define (g x)
(string-append x x))

(define (f x)
(g x))

(define (main)
(f 1))
```

the typechecker is now able to throw an error at compile time saying it is impossible to call string-append at 1, as the type is Number, while String is required (see the screenshot)

• removed nigeb, the hack that implemented begin. it's now a builtin handled by the compiler,
• automatically add type declarations to some functions based on their arity (this is rather stupid, it always assumes a type to be Any. it might also sometimes be wrong, for example if a function would return nothing, it still assumes it's an Any -- fixable)
• added CI builds for windows
• fix typechecking for tailcalls and fast tailcalls
• add with-gensym for macros that need gensyms
• change macros that use pus! to functions, so stack following will later be easier in the type checker
• rewrite loopn so it doesn't use the stack explicitly, rather being a thread-unsafe mess
• fir LTH in threaded test
• fix constant folders for < and > as i changed them to functions

Added more type checking, it now accepts type signatures and will yield errors on invalid args passed to functions. Still a lot of work needs to be done on that, as right now it only can detect types if they are known in the exact place a function call takes place, so for example:

(define-signature f Number -> Number)
(f abc) ; <- this will error out
(let ((v abc))
(f v)) ; <- this will not error out, yet it should

Started experimenting with type checking. As of right now i can declare a functions' type and make sure that - when called as an argument - it will always return a value, as void functions as arguments cause ub (possibly stack underflows).

• added multiple scheme functions: append, map, reverse
• added memory freeing counterparts: append/, map/, reverse/
• documented manual memory allocation, i don't think i'm going to add gc anymore. this is out of the scope of this project

added command line arg support, which was tricky, so it works via a callback called by (call-with-command-line ...) which accepts a lambda of 1 arg which is a list of strings. i've fallen into many traps set out by myself from the past which included a shitty allocator that can be un-stable-d by writing a byte out of bounds. but hey, wcyd, at least it was fun---ish

• added failure reporting to the test runner
• fixed defvar syntax

(defvar foo 0 1) → (defvar foo 1), it still maps to alloc!, but with extra steps to en-sugar-ify the syntax

• added lists
• added named let-loops
• started implementing very experimental GC

• Add support to the console vector in the prelude
• After some local time spent with `act' add working CI on github that tests every commit against t/
• Add configurable uxnemu in the test runner

demo:
* added uxn5 as an emulator
* sent patches to uxn5 mailing list regarding invalid obj references
compiler:
* string=?
* cond
* arity checking
* include libraries at compile-time
* 'symbols
* structs, packed structs
* fix malloc (of course; again)
* fix lambda rewriting
* show perf data when compiler is called with -V
* add bunnymark & tests to the web demo
* add thread test (https://krzysckh.org/b/Implementing-greener-threads-by-putting-uxn-in-your-uxn.html)
* add TCE on top of TCO (delete function frame on tail non-recursive calls -- _tailcall! & _tailcall-fast!)
* generate symbol tables for debuggers with -s
* add constant folding for more operations

after fighting with clang --target=wasm32 for literal hours, writing lots of js simulating a real environment i was finally able to create a ghetto demo website demonstrating how the compiler works. i might refine it later. for now it can compile / disassemble files. It's just a web wasm frontend. If you can, please use the normal compiler.

Also i have spent a lot of time going through a weird bug just to realize my js bump malloc is not aligning pointers. big oops

https://pub.krzysckh.org/nienor-web-demo/

added call-with-lines, uf2 font drawing routines, realloc, memcpy, strlen, varvara file IO (read-file, write-file), {key,button}-pressed, keypress vector, the compiler now alloc!s inline strings (there's no need to do that manually now), fixed dead code elimination for alloc! (it no longer deletes functions that are referenced only in _alloc! expressions). started working on a web demo

well i've worked much more than the counter shows here, just on a machine without hackatime. i've re-written the allocator because i found a fatal flaw that literally made it go boom on certain allocation sequences. i've added some utility functions, signed 16bit arithmetic emulation.
I also got heavily hackernews'd - my blog post was on the main page for some time, and my web server really struggled, as it's a tiny vps with like 300 megs of ram. in 3 hours i got twice as many requests as in the entirety of last year (only from stats from people without adblockers). feels kind of surreal.

what has been up to now:
- basic compilation phases & code generation
- some peephole optimizations
- tail call optimization
- closure generation (https://krzysckh.org/b/Homegrown-closures-for-uxn.html)
- runtime memory allocation (implemented malloc+free)
- variables as 1st class citizens (the compiler can recognise multiple label types)