Preprocesser requires one function to use: preprocess. Takes Tokens
and gives back Units.
A unit is a tree of tokens, where each unit is a node in that tree. A
unit has a "root" token (value of node) and an "expansion" (children
of node) where the root is some preprocesser token (such as a
reference or USE call) and the expansion is the tokens it yields. In
the case of a USE call this is the tokens of the file it includes, in
the case of a reference it's the tokens of the constant it refers to.
This means that the leaves of the tree of units are the completely
preprocessed/expanded form of the source code.
The function has many working components, which may need to be
extracted. In particular, the function ensures we don't include a
source twice through a hash map and that constants are not redefined
in inner include scopes if they're already defined in outer
scopes (i.e. if compiling a.asm which defines constant N, then include
b.asm which defines constant N, then N uses the definition of a.asm
rather than b.asm).
I need to make a spec for this.
So instead of the previous weird format, we have the format
<source_name>:<line>:<column>: <TYPE> which also allows me to quickly
go to that token via Emacs' (compile).
This is because we just OR the bits into the specific byte of the
word. This means the previous state may leave artefacts as the OR
doesn't clear the bits away.
To do so, we apply a bit mask to clear the specified byte(s) of the
word, then perform the OR.
This is simply a program with an embedded set of instructions which
indefinitely computes and prints fibonacci numbers, computing them in
pairs.
Does it completely through the virtual machine rather than just hard C
instructions.
Also amended the Makefile to compile it. Required moving the main.c
object file into the dependencies of $(DIST)/$(OUT).
I should track the dependencies for fib.c and main.c as well.
Here is where we may have differing interpretations of what the bits
in the data pile may actually mean. This in particular refers to
printing the signed or unsigned versions of the bits given. Also,
interpreting some byte as a character or just a raw number.
Only happens when vm_print_program(STDERR), as STDERR occurs before
STDOUT on Emacs. So while the lines would print, no instructions
would follow. This fixes that by using fp.
Was only used for OP_PUSH data types anyway, so is essentially
useless. Only OP_PUSH has operands after it that directly relate to
it: the rest either have a fixed type (a byte for registers, for
example) or NIL (because they have no operand).
Routines that use the stack for their operands i.e. aren't supplied
operands directly all have the same signature. We may as well stick
them all together in one array and one conditional, just reduces the
number of branches. Also looks nicer.
Implemented OP_PLUS_*. Pretty simple to implement.
Deleted vm_peek as it was only necessary to update the `ret` register.
Every vm routine now returns an err_t, which is an enumeration of
possible error states. ERR_OK represents the good state and is 0 so
error checking seems very natural in terms of language `if (err) ...`.
Errors bubble up the runtime, with any callers forced to check if an
error occurred.
This does mean that routines that call other routines cannot provide
an accurate trace of the subcaller (based on the fact that an error is
generated for the current instruction), but this should be a non issue
as no instruction should be complex enough to need proper traces.
Uses the stack and register, respectively, to jump to an absolute
address. The stack based jump pops a word off the stack to perform a
jump, while the register based one uses the operand to figure out
which register to use.
For each cycle, print the cycle and any changes. We track changes on
the stack by remembering the previous stack pointer. For registers, I
remember the previous array of registers and do a byte level compare
of the current registers and the remembered ones.
Produces pretty log messages and an easy way to track execution.
