Sun May 17 10:04:27 CEST 2009
removed front page stuff again..
I keep on doing this.. Why? Anyways, the new introduction says almost
the same as this, but with examples.
Metaprogramming is about manipulating programs as data. A key
element here is the representation of programs. Being a compiler,
Staapl has two languages to deal with: a high-level input language
and a low-level output language. Both languages are
<li> Output language programs are represented as lists of
<li> Input language programs are represented as output language
program transformer functions <code>[op]->[op]</code>.
<p> A meaning can be attached to high-level concatenative source
code using the following compilation algorithm:
<li> Read the tokens from the input program source, and
associate each of them with an <code>[op]->[op]</code>
<li> Compose all <code>[op]->[op]</code> transformers using
function composition, in the order their tokens appear in the
input program source.
<li> Apply this function to the empty program <code></code> to
obtain the final output program.
From this one could infer that each <code>[op]->[op]</code>
function appends a small machine code fragment to the code
accumulator, essentially behaving as
an <a href="http://en.wikipedia.org/wiki/Assembly_language#Macros">assembler
macro</a>. However, the function is free to modify the accumulated code in
its entirety, performing any optimization it sees fit.
<p> Using this representation the task of building code generators can
be split in these parts
<li> High level: Composing generators/transformers is expressed
using concatenation. I.e. the Scheme form <code>(macro: 123
+)</code> creates a composite code transformer, built from the
code transformers <code>123</code> and <code>+</code>.
The <code>macro:</code> form behaves as quasiquote, facilitating
template programming. I.e. the previous transformer is
equivalent to <code>(let ((x 123)) (macro: ',x +))</code>.
<li> Low level: Creating language primitives as
<code>[op]</code> processors, and possibly defining a machine
instruction set <code>op</code> that has the double function of
representing target semantics and serving as a representation of
compile time data.
<p> By interpreting the code list <code>[op]</code> as a stack and
adding an <code>op</code> instruction <code>(QW value)</code> that
represents loading of a literal value on the
stack</a> at run time, it is possible to implement Forth with eager
<p> I.e. the function associated to the token word <code>+</code>
would normally only compile machine code that pops 2 numbers from
the run-time stack, adds them and pushes the result to the stack.
Instead it could be made to inspect the code it is passed for any
instructions that load literal values on the runtime stack, remove
those, perform the addition at compile time, and generate code for a
<p> Note that the basic structure of <code>[op]</code> lists
and <code>[op]->[op]</code> transformers is more general than stack
languages. In fact, it could be used to implement partially
evaluating macro languages for any kind of state machine.