Producing the instruction implementations

[John Wood]

Few more comments..

I believe that the machine code file should just expose interfaces and their 
implementation - the utilisation of this should be defined elsewhere. This 
allows for different program-flow models to be deployed without any "hacky" 
gap-fillers like Windows' WinProc (which emulates an event driven system on a 
linear system). An implementation of a "Startup" interface can provided to the 
system to intitiate flow.

Of course this is independent of any OTs you have - the underlying structure 
of the bytecodes file has to be satisfied, even if it's satisfied indirectly 
(ie. if the format of the bytecode were JVM compatible, it would still have to 
supply objects and classes, and in the same way - even a C program would have 
all its code in a single class, and the "Startup" interface supplied by the 
VM).

Anyone had any thoughts on using existing compiler tools to create the 
in-linable code for the VM?  It's only the in-lining that causes the problem, 
we can't even use .OBJ files to provide extractable in-line code.  So that 
only leaves writing in machine code?!  Hmmm.. Unless someone wants to write a 
tool that extracts in-linable code from binaries given a map file or 
something?  It would be really cool if I could use even Java or Visual Basic 
to produce instruction implementations - and would really help get this VM 
implemented on loads of platforms (anybody would be able to port it).  I think 
the real thing stopping people porting at the moment is that lack of people 
who (a) know enough about the system at a system level (b) know machine code 
well enough and (c) have the time to write stuff in machine code effectively 
from scratch.  Having tools to let people re-use existing code to write a VM 
would *really* help.

John