Re: OOD in Ada?

["Marin David Condic" <dont.bother.mcondic.auntie.spam@[acm.org>]

There's more than one way to do just about anything. :-) I'm not sure I
understand where you're going with this. I'm not clear if you are in favor
of deriving some sort of syntax elements from a base class or not. What do
you mean by: "use the Ada type system to encode particular syntax rules"?
From my limited experience with parsing things, I can see how one might say
"I've got some sort of tokens or syntax elements that are on the one hand,
all the same kind of thing conceptually in that I want to build a tree of
them, but on the other hand, they're all different in that they may contain
substantially different data..."

One way I've done it and seen it done is with discriminated records. They're
all the same type so you can build linked data structures with them. Another
method is to use tagged records where the base class handles anything common
to the tree nodes and you derive new classes to add the variant parts. The
new classes are good models of each syntactic element and may need to make
reference to each other via a sort of generic pointer. (You want to be able
to chase down the parse tree and it will contain heterogeneous data...) The
only problem here is that since you're using a single pointer type to point
to a variety of different types, you do circumvent some of the type safety
you might otherwise get on the pointers. (Its somewhat worse than using a
discriminated record since some unrelated classes could be built from the
same base type & you risk having pointers that can reference something
outside of the controlled subset.)

The thing is that when you need to build two classes that might need to
reference each other, deriving from a common base type is a good way to do
that. Deciding if it is A Good Thing to have mutually referential classes is
another matter.

MDC
--
Marin David Condic
Senior Software Engineer
Pace Micro Technology Americas    www.pacemicro.com
Enabling the digital revolution
e-Mail:    marin.condic@pacemicro.com


<tmoran@acm.org> wrote in message
news:UxnS8.606$ci5.107953341@newssvr13.news.prodigy.com...
>   I can't phrase it well, but this bother me.  In parsing, you have a
> bunch of terminals and non-terminals and a base non-terminal (something
> like "program").  So make a base class of Non_Terminal with children like
> "Declarative_Part", "Expression", "Term", etc.  That's the general
> paradigm for a parser.
>   Then you have a particular grammar that says that an Expression can have
> a Statement as a constituent (in the OP's case), or that a Term can be
> followed by an Adding_Operator, and so forth.  It seems to me overdoing
> things to try to use the Ada type system to encode particular syntax
> rules, especially when you consider that a particular grammar may change
> due to changes in the language, or to arrange to call semantic routines at
> more convenient times, or whatever.