<OriansJ`>xentrac: well the only class of build systems that don't map to that paradigm are the snarfing build systems but those I classify as bootstrapping toxic waste. As the human reviewed source may be nothing like the source that is ultimately built. <OriansJ`>xentrac: think lisp macro expansion applied to a source file, just prior to it being sent to the compiler. It allows for things such as squeezing mes.c in under 500 lines of C code; despite the fact it was impossible for GCC to compile such code (and the resulting work required to get it able to be built with GCC directly ballooned the code to about 4Kloc) <OriansJ`>It is a siren song for programmers in languages with proper macros. <OriansJ`>I believe it took janneke nearly a month to convert the snarfing mes.c to something that GCC could even compile <OriansJ`>honestly the first time I ever saw such a system was when I was trying to figure out how to compile Mes.c with M2-Planet <OriansJ`>Turns out it required a boatload of work just to get GCC to compile mes.c <OriansJ`>Then it took me 2 months just to remove the compile warnings and errors <xentrac>where did the build system enter into this? <OriansJ`>it was part of the mes.c build process for a long time before I got janneke to switch to a much simpler build <OriansJ`>It took 1.5-2 Months to clear out all of the C macros (as M2-Planet doesn't support any C macros) <xentrac>the problem with the build system was that it needed to compile the C source using a C compiler that included a C preprocessor? <OriansJ`>xentrac: the problem with the build system was it that it was not possible to compile the source code without the build system. <xentrac>you said it was snarfing but I don't know what that means <OriansJ`>xentrac: think lisp macro expansion upon the files but the compiler only sees the expanded files and the user only has the non-expanded files <xentrac>janneke implemented Lisp macros in the build system? How does that help generate C for the compiler? <xentrac>I feel embarrassed because I feel like I must be asking a really stupid question so maybe I should stop <xentrac>I must be misunderstanding something basic <OriansJ`>xentrac: mes.c is a lisp interpreter, not a Compiler <OriansJ`>the build system used guile to manipulate the contents of the source file to generate the C code that ultimately was built into the binary mes <xentrac>oh, it used a compiler written in Guile to compile mes.c from whatever it was written in into actual C? <xentrac>and you're categorizing that compiler as part of the build system <OriansJ`>xentrac: it was part of the build system <OriansJ`>which is what made it a snarfing build system <OriansJ`>thus they as a class are considerably difficult to remove/replace in a build chain; even with considerable help. <OriansJ`>janneke wrote both the snarfing and the source code but it still took him a month to unwind it into buildable source code. <OriansJ`>it is partly why I created kaem, so that bootstrappers didn't have an excuse in regards to doing sane builds. (737 bytes with lots of room for shrinking the binary) <OriansJ`>funny thing is scheme would be so much easier to bootstrap if it wasn't for this syntax-case monster (which will probably end up being bigger to implement than the rest of the language put together) <OriansJ`>although knowing my luck, odds are I am probably just making this all harder on myself then necessary and someone with a different set of eyes just needs to rewrite mes_macro.c and the bootstrap to GCC would be done. <xentrac>yes, I think syntax-case or syntax-rules is notoriously annoying to implement, and probably a language that provided just bare syntactic closures would be much simpler <OriansJ`>xentrac: but it needs to be compatible with common scheme macros as it appears impossible to seperate scheme users from macros <OriansJ`>and running MesCC and guix would be required to finish the guix bootstrap. <OriansJ`>(bootstrapping guile on the other hand would require full support of syntax-case) <xentrac>I mean you could have a syntax-case implementation written in Scheme with syntactic closures ***ChanServ sets mode: +o rekado_
***rekado_ is now known as rekado