Actually, determining if
VIRTUAL has to be done at link time
since I do not know if a class is a superclass of one.
Invocation of methods will be handling cached stack values.
So I have basic stack caching right now since the
this in a constructor call
has been cached.
Forgot about removing stack entries.
And return values.
So as I planned before, method linking will have a source method and a target method, which are both method references along with their linkage type. This would reduce the amount of space required.
One thing I can do for speed is have prelinking of the JVM namespace.
I actually need a bulk pop. It will be performed before a method call and
will return all of the cached registers that should be used. That will be used
to access the cache system. The reason I need to do this is because there can
be cached values which are additionally cached on the stack (in the case of
DUP), and as such if any previous entry refers to one that is popped it must
be copied before it is lost completely.
I should make the build system truly determinstic along with the binary output
system also being deterministic. This means having no hash cookie that depends
on the time. One issue with that though is that the output ZIP file would have
the current time associated with it when I do support such things. Then the
build order given to by the builder can be sorted also. I would suppose I can
write a simple red-black tree. Although I will need a
Map and a
can layer one upon the other. In general though a
Map is layered on a
It would likely be best if the red-black tree were left leaning, since based on a paper such a tree is much simpler to implement and would be more sane in the long run.
Actually it might be best to reverse course and have the Set implemented on top of the map, although it really does not matter. Likely using the set might be a bit cleaner.
It is interesting that Robert Sedgewick revisited his own algorithm after so many years, that is dedication.
Actually it might be best to swap it and have it use the map as the base so I
Although it really does not matter at all.
Tree iteration is just going right. If there is no right then go up until the next right is found and then go down all the way left. This is how it is done without a queue.