Mon Feb 5 21:26:33 GMT 2007
two big problems remaining. the assembler and state storage. the
assembler is a bit nasty. lots of tiny rules to obey.. i wonder if i
can make something coherent out of this.
the state store is tightly coupled to the assembler. here i can
probably do another trick of accumulating the dictionaries using some
what are the tasks of the assembler?
-> creating instruction codes from symbolic rep
-> resolving all names to addresses (2 pass?)
-> making sure all jumps have the correct size
the result of assembly is a vector, and some updated symbol
tables. the input is optimized and idiomized forth code that can be
it would be nice to use nondeterministic programming for choosing jump
sizes, but that's probably overkill: moving code down is probably easier.
* if i only shrink jumps instead of expanding them, the effects are
always local: no bounds are violated, but the solution might be
sub-optimal. for backward jumps, the correct size is known, only
forward jumps need to be allocated.
* a proper topological representation which indicates where jumps go
and where they come from is a good thing to have: a single cell has:
- list of cells that go from here: max 2
- list of cells that come here
- instruction + arguments
* maybe that's overkill. since it can always be generated if analysis
is necessary.. what about this:
- assume incremental code: old code is not going to be jumping to
- within a code block under compilation, forward jumps are possible,
so they need to be allocated: use maximum size. however, they
should be rare: function definitions could be sorted before hand?
- recursively work down from the current compilation point, and
adjust all jumps. backtrack if necessary. this can be done in a list
* yep.. it's probably simplest to just perform the 2 ordinary steps of
backward then forward address resolution, and add as many passes as
necessary to resolve the shrinking.
* there are 2 x 2 x 2 types of jumps wrt. a single cell collapse
abs/rel x start:before/after x finish:before/after
-> relative : adj if they cross the border
-> absolute : adj if they end past border