Self-hosting Compiler

[Ronsor]

As the title implies, make wax self-hosting by rewriting it in itself.

[ghost]

Bootstraped? @LingDong- Does wax have string functions? (Sorry for pinging you...)

[LingDong-]

Hi @Ronsor ,

Thanks for the suggestion!

Yes I've thought about the idea. It's a non-trivial undertaking given the many targets wax supports, and wax itself being a not particularly convenient language to write a compiler in. Of course it's super cool to be self-hosted from a philosophical / "because I can" perspective (indeed what language designer doesn't want their language to be self-hosted :), but it also has somewhat limited practical value from the user's standpoint.

So I'll probably work on it when I have spare time. Let's keep this issue open as a reminder to myself, and maybe for discussing implementation of such a compiler if people are interested/want to contribute.

Hi @Rabios , no worries, and yup, wax has all the basic string operations, please check out https://github.com/LingDong-/wax/blob/main/QUICKSTART.md#strings

Thanks

[jacoblister]

@LingDong- sounds like a challenge :)

I've made a start with the example program below - not much yet, but it can express a limited source tree and write it back out to output. Next steps:

• transpile output (to javascript initially, as it's easy to implement)
• tokenizer, source parser

Would that be something you'd be interested in taking a pull request for?

Context - I have a software synthesizer project implemented in Golang and with the signal processing and UI code transpilled to javascript, demo here: http://noisefloor.jacob.nz.net/ https://github.com/jacoblister/noisefloor

I've never quite been satisfied with the amount of control I have over the javascript output, so I have been looking for an implementation language which can target at least C (for native builds), and javascript - maybe wax could be it.

Really pleased to have found you project as this has to be the cleanest and smallest Lisp style dialect and implementation I've seen anywhere.

Thanks

--

(@define NODE_EXPR 0) (@define NODE_PARAM_INT 1) (struct node (let type int) (let expr str) (let p0 str) (let child (arr (struct node))) ) (func dumpnode (param depth int) (param node (struct node)) (result str) (let indent str (alloc str "")) (for i 0 (< i depth) 1 (do (<< indent " ") )) (let s str (alloc str "")) (<< s indent) (<< s "(") (<< s (get node expr)) (<< s " ") (<< s (get node p0)) (<< s "\n") (for i 0 (< i (# (get node child))) 1 (do (let childdump str (call dumpnode (+ depth 1) (get (get node child) i))) (<< s childdump) )) (<< s indent) (<< s ")") (<< s "\n") (return s) ) (func helloworld (result (struct node)) (let hello_main (struct node) (alloc (struct node))) (set hello_main type @NODE_EXPR) (set hello_main expr "func") (set hello_main p0 "main") (set hello_main child (alloc (arr (struct node)))) (let hello_print (struct node) (alloc (struct node))) (set hello_print expr "print") (set hello_print p0 "Hello World!") (set hello_print child (alloc (arr (struct node)))) (insert (get hello_main child) (# (get hello_main child)) hello_print) (let hello_return (struct node) (alloc (struct node))) (set hello_return expr "return") (set hello_return p0 "0") (set hello_return child (alloc (arr (struct node)))) (insert (get hello_main child) (# (get hello_main child)) hello_return) (return hello_main) ) (func main (result int) (let root (struct node) (call helloworld)) (let dump str (call dumpnode 0 root)) (print dump) (return 0) )