Re: Object-oriented compiler construction: ideas?

In the LR parser generator and compiler skeleton system we added as few
features as possible in an attempt to avoid unnecessary complexity.


One feature was the ability to generate
sets and tests for set inclusion on AST node names.
This made it possible to easily define abstract sets of information
about specific node types.


In the grammar I'd write:


%set commutes
n_plus n_minus n_multiply;


Which generated a macro "is_commutes" that yielded true or false
on set inclusion.


The AST data structures, memory pool, debug, rewriting and
traversal primitives are generic.
However, specific attributes, such as the value of a node representing
a constant or symbolic attributes of an identifier node are
dynamically assigned to a 'decoration' field of the node.


This allows for construction of generic support functions
such as traverse, debug and iterator constructs.
It also allows for easy loading and unloading of phase specific
information. Consider, an expression operator node may have language
specific type information associated with it during semantic attribution
phases, later optimization phases may require (in addition) a global
expression dictionary entry, availability information, etc..
There really is no need for global knowledge of optimization
specific attributes and given space and complexity requirements, some
very good reasons for making such attributes phase, rather than class,
specific. The same follows for code generation and so on.


The generic debug routines need to know how to interpret
and print such dynamic attribute information, but given that, it is a very
easy system to work with.


Essentially, once the problem space is framed, the representation
of a specific set of language or phase attributes is a variation on a theme.
The system also has generic models of CFG data structures etc., again
using the same ideas of a generic framework, or skeleton.


This approach has made my job as a compiler writer much easier and has proven
to be very maintainable and understandable by others, including inexperienced
developers.














--

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