Translational Hierachy Framework

[Matthew Tuck]

I've increasingly become aware that translation can be considered in a
tree structure.  Let me explain this a bit better.  A tree might look
something like this.

GUI Creation Wizard			Other Wizards
        |                                |    |    |
        |                                |    |    |
GUI Resource Files -----------   --------/----/----/
                              \ /
                               |
                             USSID
                               |
                             UPPID
                               |
                           Native Code

This is not a fixed hierachy - you go skip the native code stage, skip
UPPID, skip USSID from the wizards, have different native code
generators etc.

The idea here is that you could generate your own translational
hierachy.  This supports things like code wizards, while at the same
time allowing you to easily see generated native or intermediate code. 
Furthermore, source legacy code in other languages could sit on top of
USSID.

You would have two different modes.  There would be a editable mode for
the leaves of the tree (the root here being native code), and a
read-only mode for everything else (since it is generated code).  The
only way you could edit this generated code would be to "detach" the
child nodes from it, so it is no longer generated, and what generated it
would be removed from the system.

One advantage of being able to see this code would be to be able to
tweak the translation process.

Essentially, the system would be language-independent, and there would
be three elements.

The first is a language.  Each node of the tree above would be a
language.  The second is a view.  There would be one or more views for
each language.  The last is a translator between two langauges (the
edges of the tree).  All three of these elements would be "plug-ins" and
possibly sandboxed.

Essentially the editor would be relegated to providing support to and
coordination between these three elements.

I know the Multiview project has an assembly language view, and they
generate language independent editors.  I'm not sure whether they have a
general tree like I'm proposing here.  It strikes me this would handle a
lot of things in a general way.  What does everyone else think?

-- 
     Matthew Tuck - Software Developer & All-Round Nice Guy
                              ***
       Check out the Ultra programming language project!
              http://www.box.net.au/~matty/ultra/