SquirrelJME/SquirrelJME

# 2016/06/13

## 13:37

I need an efficient way to describe the structure of classes and objects so
that they may be allocated by the structure manager.

## 13:43

The information of what a current class is and the identity hash code will not
be special outside details, they will just be standard fields within a class
that are initialized to values on allocation.

## 15:16

`String` has `valueOf` and `copyValueOf`.

## 15:25

In general, the representation of objects will be shared such as classes and
their sizes and field alignments.

## 15:28

The question is though, an effective way to represent code and data sections.
There would potentially need to be two object allocation schemes. One that is
in the data section while another is in the code section. There is no reason
that a Harvard architecture has to be unmodifiable. So I suppose what I need
then is a memory space which is given an allocator and an accessor and then
pass that to the `StructureManager`. Otherwise the structure manager will
only ever be capable of allocating structures in the data space which means
that Harvard architectures with separated code and data will never be able to
use a JIT.

## 15:35

It is a `MemoryManager` but does not manage pages, I suppose for that instead
there could be something called a `pmmu` for managing memory pages that extend
beyond the standard allocator and such.

## 15:43

However, having an extra class is rather ugly. The accessor may be tightly
bound to an allocator however. So do I have an allocator that is returned by
the accessor? Do I have the memory accessor perform primitive memory management
in chunks? I can do the later however, since it may actually work out better.
The accessor is very specific to a system anyway and there might be a system
specific means of allocating chunks of memory. However instead of it just being
allocation, it will be reserving for the most part or similar. The structure
manager can have a slightly better accessor which can manage memory better
anyway and the that can be used instead (ideally a new MemoryAccessor wrapper
would be used with the given logic).

## 20:39

When it comes to the structure manager, I will need a representation for
classes.

## 20:40

The structure manager is really a run-time assistance library for the most
part. The kernel and the interpreter would use the same structure manager for
the most part when it comes to objects. So I suppose it should be called as
such. Runtime objects perhaps.