interpreter pattern & p-code performance analysis

Hello.


I am writing a yacc++ based interpreter/compiler as part of a large
project. It is based on existing technology, which used a technique
similar to the interpreter pattern (re Gamma et al.) - the structure
of the interpreted code is represented with a parent-child class
hierarchy.


While this technique works ok, and the resulting c++ code is more
readable to a non-compiler writer, it is space and time
inefficient. The alternative is to generate some form of intermediate
code and execute this in a virtual machine when required.


At the moment I am doing performance analysis to compare the space and
execution efficiency of the two methods. Has anyone done similar
analysis before?


If I do have to go down the intermediate code route, is there code for
an intermediate language executor available? (p-code implementation
for example)


Thanks in advance,


Martin Jones.
mgjones@vegauk.co.uk
[There's always the JVM. -John]


--

Return to the comp.compilers page.
Search the comp.compilers archives again.