rubyx/lib/virtual/README.md

55 lines
2.2 KiB
Markdown
Raw Normal View History

2014-08-28 18:12:46 +02:00
### Virtual OO Machine
This is really an OV (object value) not object oriented machine.
Integers and References are Values. We make them look like objects, sure, but they are not.
Symbols have similar properties and those are:
- eqality means identity
- no chhange over lifetime
It's like with Atoms: they used to be the smallest possible physical unit. Now we have electrons, proton and neutrons.
And so objects are made up of Values (not objects), integers, floats , references and possibly more.
Values have type in the same way objects have a class. We keep track of the type at runtime.
### Layers
*Ast* instances get created by the salama-reader gem from source. Here we add compile functions to ast classes and
comile the ast layer into Virtual:: objects
The main objects are BootSpace (lots of objects), BootClass (represents a class),
CompiledMethod (with Blocks and Instruction).
*Virtual* Instructions get further transformed into *register* instructions. This is done by an abstractly defined
Register Machine with basic Intructions. A concrete implementation (like Arm) derives and creates derived
Instructions.
The final transformation assigns Positions to all boot objects (Linker) and assembles them into a binary representation.
The data- part is then a representation of classes in the *parfait* runtime. And the instrucions make up the
funtions.
### Accessible Objects
Object oriented systems have data hiding. So we have access to the inner state of only four objects:
- Self
- Message (arguments, method name, self)
- Frame (local and tmp variables)
- NewMessage ( to build the next message sent)
A single instructions (Set) allows movement of data between these. There are compare, branch and call intructions too.
### Micro
The micro-kernel idea is well stated by: If you can leave it out, do.
As such we are aiming for integer and reference (type) support, and a minimal class system
(object/class/aray/hash/string).
*Parfait* is that part of the runtime that can be coded in ruby. It is parsed, like any other code and always included
in the resulting binary. Builtin is the part of the runtime that can not be coded in ruby (but is still needed). This
is coded y construction CompiledMethods in code and neccesarily machine dependant.