Writing a managed compiler framework, suggestions/feedback?

I'm writing a managed compiler framework primarily focused on the .NET
Common Language Infrastructure, and I wanted some insight. I'm mostly
looking for what would be favorable/functionally acceptable when it
came to the various pre-compilation functions of a language's compiler.


It resides within a managed framework, and the entire infrastructure,
that defines and modifies code, provides a meta-model to
describe/manipulate the process. This is purely due to the
infrastructure on which it sits. The 'how' on the modification lies
within how malleable I make the framework's description of abstract
high-level code.


I'm curious to get feedback from other developers on what would be
desirable were you to use such a framework to write a compiler. So
far I've come up with the following: A series of pre-compiler tasks
for data acquisition, identity resolution and code generation. Within
these there would be task aggregators in instances where a task has
been extended by a user of any given language. These individual tasks
would be prioritized to ensure proper function. I'm thinking this
might stray a touch from tradition, in symbol table construction for
identity resolution, because I want it to be as open-ended as possible,
though I'm not sure of what would be feasible, which is why I bring
this topic here.


I'm nontraditionally trained in this field in that I've done all my own
research, I'll likely utilize this framework to build the first compiler
for a few language(s) I want to construct, one of which will later
boot-strap itself (and then the other domain specific languages.) Due
to my educational background (or lack thereof), I would be best served
to insight that doesn't require higher level math, lest you give a
supplemental link pertaining to descriptions of the symbols used. My
approach is largely experimental, so to give an example of what doesn't
make sense to me (due to not knowing what math to research), refer to:
http://en.wikipedia.org/wiki/Context_Free_Grammar#Formal_definitions


As for the rest of it, I've done plenty of research by reverse
engineering my own code to get a general idea as to how the individual
aspects of languages operate, from language integrated query to
lambdas to iterator state-machines generators, I just thought it would
be worth asking someone with more experience before finalizing the
design behind the compiler itself (versus the data-phase which is
simple to figure out if you've written a code translator, interpreter
or done any fixed-function IL generation).


Thanks in advance,


-Alexander Morou

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