One thing I can have in the future is a kind of IDE which can compile this while running on SquirrelJME. Another feature I thought of having would be a retro-system or general system compiler which can take C and produce machine code from it. The native compiler under C could use the pre-existing JIT engine to generate binaries (since the JIT engine utilizes memory access and such). Then with a standard library, it would be possible to write some homebrew games for consoles on the console itself.
So now I must work on the JIT compiler for generating actual classes. I suppose I should start with the initial class details and such.
One thing to consider is the JIT compilation order, I should have an enumeration which is used so that the order can be more well known.
I have not checked if the build system compiles and works on Windows for the past 4 months, I suppose I should check it real quick. Technically it would be Wine though.
Well, it appears that it works just fine.
At least with C and the prototypes being in the header I do not need to worry about forward declarations and such.
Need to determine a good way for strings to exist without being too much of a hassle.
I should work on the code that runs after the JIT has successfully completed so that during initial development I can potentially have partial results potentially working together. Potentially if a cache creator is used I need to copy the output somewhere before it is worked on. Ideally at this point the cached forms would have to potentially be linked (if applicable). However that might not be needed at all, I just need a way to extract the actual created namespaces into some potentially executable form.
The JIT only works with a single class at a time and depending on what is creating the JIT is is rather undefined what happens after a class is completed.
I suppose the final work would be done by the
does create the JIT since it potentially knows everything. Then
can contain the needed classes which perform a final stage linking of all of
the code into a blob potentially from any created cache that exists. So
then the cache manager needs to have a way to iterate created caches then.
I am actually going to need some assets from the root such as the readme and the license. I suppose to reduce duplication that I can just use symlinks and create a special package for it. Personally I would like that the builder creates a ZIP file which contains the distribution as required. This way there is no need to worry about writing other scripts to package it manually for example. If the executable format is special, say an ISO then it would be very similar except the ZIP contains an ISO instead. Since now I can write actual ZIP files.
Appears my GPG expired, I must remember to not let it do so.
For the executable to be written, I will need to go through a ZIP as a stream so this means that I must support reading of streamed ZIPs.
So I am getting a bit closer to a JIT, although it was a couple of months that I could have had it earier. However, the older code was really bad and the current code is very workable. If I need to rewrite an output JIT I can just do that without worrying much about breaking other things.