Notices by Leonard Ritter (lritter@mastodon.gamedev.place)

hating myself right now for having written so much code.

a lot of this was written with the assumption that "it's only bootstrapping, no need to be dilligent, all this will be replaced".

well guess what, dipshit. it's 10 years later and this is still the state of the art implementation.

in soviet russia, corner cuts you.

#devlog #scopes

sigh. i just have too much on my plate. i'm now just porting the Scope implementation almost as it is now and do this another day.

funny, "porting" feels more correct here than "refactoring".

#devlog #scopes

scope.cpp is ported, now we're moving on to a bunch of smaller types, until we're eventually arriving at value.cpp, which does a lot.

it's easy to tell how far i'm along because the generated makefile compiles sources in lexicographic order. 11 sources left. :)

#devlog #scopes

today i'm beginning translating Scopes' internal OOP based system to datalog/database/ECS layout, that is, all pointers become enum-typed indices and object attributes are mapped in arrays.

to begin, i'm writing a small DSL in Scopes to describe the datamodel, and then auto-translate it to C++

this is the type tree from which classes and enums will be generated:
https://paste.sr.ht/~duangle/31522a60cf978fe7483cfdd32f1fca7293daaffc

next, we need index attributes (aka struct fields), and auxiliary tables (options, maps)

#devlog #scopes

phew. five hours later, i've translated *all types* used by Scopes into this format, from which C++ definitions will be derived.

what i like particularly here is that all sub-enums like ICmpKind or TypeKind, and even all error codes, are flattened into the main ValueKind one, but can still be their own enumerator types.

many branch-dependent special cases are now unified this way.

https://hg.sr.ht/~duangle/scopes/browse/src/Value.sx?rev=based

#devlog #scopes

the parser for Value.sx now fully parses the definition file in 455 lines.

https://hg.sr.ht/~duangle/scopes/raw/lib/scopes/compiler/pilot/gencc.sc?rev=based

now we need to generate some actual C++ code.

#devlog #scopes

we have generated some code. instead of generating plain C++ expressions i employ the same technique i did with the scopes² prototype: generate macro expressions and let the preprocessor translate.

left is an impression of what the output looks like (header file). right is the file used to translate it to C definitions. most of it is stubs so the code compiles at all.

#devlog #scopes

in full refactoring flow now, as i replace explicit classes with generated types, turn methods into functions, figure out small extensions to the type generator, etc.

as a result, codebase's getting smaller, which is always a good sign.

#devlog #scopes

lots of refactoring today. codebase is completely shot. changes everywhere. many deletions. into the rabbit hole i go.

#devlog #scopes

voting this the least helpful error message in C++ (it's a bit verbose because i use heavily templated types, and C++ doesn't know when to quit describing nesting structures).

you get this when you use a type for STL hashmaps that's not supported by std::hash. it doesn't actually tell you where you made that mistake. it does in fact tell you nothing useful aside from the type used. you just have to know by experience.

#devlog #scopes

expander.cpp is the first big module to be fully updated, now i'm updating gen_llvm.cpp. it's the mother of all refactorings.

#devlog #scopes

gen_llvm.cpp is updated, next is globals.cpp. this one implements the C API wrapper around the C++ parts of the compiler and also exports all API symbols to the client context, which looks like below.

these 600+ lines of definitions are all manually maintained, but could be autogenerated from scopes.h alone, which i'll implement now.

#devlog #scopes

de-optimizing Scope objects to speed the refactor along (I have a much better optimization to apply later), and updating related API functions.

#devlog #scopes

and now it's time to eat my own dogfood

#devlog #scopes

refactoring is intensifying

#devlog #scopes

i'm going to remove all the internal "homebrew exception" stuff from our C++ codebase and use C++ exceptions instead, which drastically simplifies a lot of the error handling code. we're already converting exceptions at the boundaries, this would be no different.

honestly i no longer understand why i was so reluctant to use this in the first place. i guess i was afraid C++ exception support would leak into the scopes API but those worries were unfounded.

#devlog #scopes

wrote some great sugar for the boundary so there's virtually no sweat translating exceptions.

first pic is old way, second pic is new way

#devlog #scopes

more refactoring. this is the mother of all refactorings. i will probably never get done.

#devlog #scopes

getting to list.cpp. the existing implementation uses simple cons cells, and while i want to use something else in the future, i'll keep it as it is right now so we're going to get to working state sooner.

what i would like to try in the next list impl is "wide cons cells", conceptually immutable arrays broken into multiple singly-linked pieces.

#devlog #scopes

lists done, platform ABI done. now we get to prover.cpp which is the typechecker, and at 4500 lines a behemoth, compared to other files.

i wrote down a few regexes i used for replacement here, which save me a lot busy work.

#devlog #scopes