Catalina: Now you can have your Cake and eat it too! - C89, C99, C11 or C23!
This is exciting! As well as C89, Catalina can now compile C99, C11 & C23 programs! And I didn't need to do a thing! How is that possible?
Well, the answer is that I just found out about cake - a transpiler for converting C23, C11 or C99 programs to pure C89. So now all these C variants can be compiled by Catalina^^. I had been working on my own utility to just add a few of the more useful C99 features (such as the ability to declare variables anywhere in the program, rather than just at the start of each block), but cake is already much more advanced and comprehensive, so I am going to adopt it instead.
While cake it is still experimental, everything I have tried so far seems to work. And its level of support for C99 (in particular) is far more complete than anything I would have attempted. For a summary, see here.
The main things currently missing from C99 support are things that I would have recommended avoiding in any case (e.g. Variable Length Arrays, which were eventually seen as a misfeature and made optional in C11) or things I would never use and would probably also not have bothered implementing (like complex numbers).
And the best thing is that on Linux, you can try it out right now! Just download cake, compile it and use it like a preprocessor - i.e. transpile your C99 program to C89 with cake, and then compile the C89 output with Catalina. For example, after setting it up, you might use commands like:
cake program.c -o cake.c catalina -p2 -lc cake.c -o program
Currently, this is easy on Linux because cake also uses gcc on that platform (but see NOTE below), but on Windows it does not. I intend fixing that in a version for Catalina. Also, while cake generates relatively pure C89, it assumes the results will be compiled with gcc, which has a different set of header files than Catalina does. This means that while many things will work "out of the box", some things that needs specific header files to be included may not. So I will be adding a cake back-end targeted specifically at Catalina, so that eventually everything will just work.
I wanted to start a new thread for this because I am interested in feedback while I work on it - in particular any C99 features that do not work, or which are not implemented but someone thinks would be essential. I hope to get involved in the cake project myself, once I am more familiar with it, because I think this idea has legs!
However, it is not something that I need to do all by myself. This project could be undertaken by anyone with a reasonable C knowledge, and I would be happy to take a back seat and let someone else take the lead. Anyone who may be interested, please let me know.
Ross.
^^ which also shows that these later variants of C are really just show ponies! The only truly truly necessary C is ANSI C! 
NOTE: I just noticed cake uses gcc's include files by default on Linux, which makes some things not work with Catalina. To make it use Catalina include files, modify src-main/src/cakeconfig.h to specify Catalina's include directory. For example, on my machine this file now says:
#pragma dir "/home/rossh/Catalina/include"
Comments
That is great news.
Was just looking at lvgl
https://github.com/lvgl/lvgl
Maybe this would help this to compile.
I’m assuming it’s not ansi c cause doesn’t say it anywhere that I see..
It appears lvgl is C99, so in theory yes.
Okay! Getting cake working on Windows turned out to be ... (wait for it) ... a piece of cake!
If you have gcc installed (I have the MinGW 64 bit version installed), then you just do the following:
Go to https://github.com/thradams/cake and download the source as a zip file. Extract the zip file to your home directory. This will create a folder called cake-main.
Open a Catalina command line window and go to the cake source you just unzipped ...
NOTE - this will generate some warnings, and the command ./cake -autoconfig will fail (because this is Windows, not Linux) so we will do it manually in the next step.
#include <stdio.h> void main() { for (int i = 0; i < 10; i++) { // requires C99! printf("hello %d from %s\n", i, __func__); // requires C99! } while(1); }Et voilà! Catalina now compiles C99 programs!
This is not the end of the story, of course - Catalina's libraries will need some updates and additions to be C99 compatible - but this already does everything I had intended to do myself when I got time, and with zero effort!
That is nice. Imagining that C23 is like a newer C++ but without classes.
Is that close?
C23 has #embed for binary data. That would be nice...
C23 is definitely not C++. But it is true that a few of the changes introduced in C23 were designed to align it more with C++ than for their own intrinsic utility. Whether you think this is a good thing or not depends on whether you think C++ is a good language or not.
The manual says #embed is 'partially implemented'. There is an example included of using it, so I'm not sure exactly what is missing. In general C23 is currently less fully implemented than C99 or C11.
I just added a NOTE to the first post in this thread about building cake on Linux - you need to manually adjust the include file directories to make it use Catalina's include files instead of gcc's. Otherwise some things won't work.
I will fix this in the version I will include with Catalina.
Ross.
Apologies for the delay. I had to have the Cake author fix a couple of minor issues, but now Cake is ready to work with Catalina.
I have just uploaded a version configured to suit Catalina 8.8 to SourceForge here. The zip file contains sources and Windows binaries. It should be unzipped in Catalina's source folder.
Once unzipped, on Windows you can just install it - i.e.
On Linux you have to build it from source (and you may need superuser privileges):
A simple demo program (hello_99.c) is included, and can be built and executed using commands like:
See the README.TXT file in the cake folder for more details.
Just a quick update. I now have Cake compiled with Catalina and running on a P2. There's still heaps of work (and testing) left to do, but already this has been a bigger effort than I expected.
Although Cake claims to generate "C89-compatible" code, what it actually generates is a mix of C89 code but with C99 library calls, plus some very Windows or Linux specific support code. I have had to identify all the places where the code generated (when applying Cake to itself) is not really pure C89 and either make it so, or add more C99 features to Catalina - which is what I had hoped Cake would do for me. I was perhaps being a little too optimistic!
Anyway, now that I have at least demonstrated the concept, the way this is going to work is that instead of Cake being just a separate stand-alone utility, Catalina will support multiple compilation modes (similar to what gcc does) - a C89 mode (which is currently Catalina's only mode) plus one or more C99+ modes, where Catalina's current preprocessor cpp is entirely replaced by cake. I didn't want to start going down this route until I had at least demonstrated that Cake could be compiled to run on a P2.
However, if you just want to use some C99, C11 or C23 language features, the stand-alone version of Cake works as advertised, and will also continue to be supported.
Ross.