and modified the emit module to emit a Pop instruction after every top-level expression.
This change was required because the semantics of the language are pretty clear.
Every expression evaluates to something - meaning that, in the corresponding bytecode,
every expression must have exactly a +1 effect on the data stack. I.e. every expression,
when its corresponding bytecode is evaluated, has the effect of pushing something
to the stack. For values that are not used by another expression, this value
must be immediately popped.
Some optimizations could target this area. For example, for top-level expressions,
it is obvious to the compiler that their values will not be used - hence the compiler
can use optimized versions of some instructions (like StoreLocal and StoreGlobal)
to simply never leave the value on the stack, thus saving an extra Pop instruction
(good for performance and code size).
Same thing applies in function bodies, letrec/let/begin bodies, where expressions
whose values are never used may appear.
It may also make sense to introduce registers to the VM, for the purposes of
parameter passing (such that up to a predetermined number of parameters are
progressively passed through registers instead of pushed to the stack).
This would pair well with eliminating unnecessary currying in the byte code.
Compiler and VM are now working well enough to support larger programs.
A test program is included and executed immediately upon running
the executable.
A more feature complete read-eval-print loop is planned.
debug: added debug functions for the syntactic_ast module
Modified the compiler executable to test a little bit.
todo: Some nodes of the syntactic ast are not yet emitted,
haxala1r
