Re: Looping over a tagged record?

[Charles Hixson <charleshixson@earthling.net>]

"DuckE" <nospam_steved94@home.com> wrote in
news:JVxY6.222013$p33.4452203@news1.sttls1.wa.home.com: 

> 
> "Charles Hixson" <charleshixson@earthling.net> wrote in
> message 
>  [snip]
>>...
>> out how I can do this in a way that doesn't make me rewrite
>> everything whenever a new class is described ... 
> 
> "...inheritance in C"
> 
>   Say what?
> 
> Perhaps you're thinking of C++ or Objective C.  The last I
> know C didn't have inheritance.
> 
> SteveD
> 
> 
Sorry.  I was talking about mixing languages.  Ada and C (and 
not C++).  Not that I have many objections to using C++ as a 
small superset of C.  It's when the templates, etc. start 
showing up that I get upset.

No.  One of the things that C is really good at is replicating 
the utility of the PL/I based variables.  One of the things that 
it's really bad at is the horrendous amount of casting one must 
do.  And preprocessor code and pointer manipulation can make it 
actually less readable than either APL or Forth.

But for small routines, that are basically self contained 
modules, it is even easier than Ada, and if one needs to map the 
same area of memory with several arbitrary structures it appears 
to me to be much better.  (Well, my Ada experience is quite 
limited.)

What I was proposing was that the Ada classes would descend from 
a root, say, persistent, and that they would all implement a 
method to pass type & data information to a C routine that would 
manage the storage/retrieval from a disk file.  This would work, 
but appears a bit clumsy.  (Like LOTS clumsy!).

Ada.Streams_IO, however, seems to be a built in method for doing 
most of what I need.  The only problem is that when I'm reading 
the stuff back in I won't be able to use the file tags to tell 
Ada what kind of data I'm reading.  That won't be known at 
compile time.  So I'll need to build the kind of case switch 
that Tagged object types try to make obsolete.  It will be more 
the way that Ada83 handled tagged records.  What comes out will 
need to be a descendant of Persistant, Persistant will need to 
know about what methods all of it's sub-types can handle, unless 
I find that I need to do a full-fledged Meta Object Protocol 
(MOP), in which case I'll probably decide to use some language 
that has one already built into it.  Those things are beastly to  
implement.  And in that case, I'll want to call Ada routines 
from the overlying layer.  This will probably mean that they 
need to be compiled with C linking conventions. (Which is 
another reason to avoid C++ ... it's way of name munging is not 
portable.)

-- 
Charles Hixson

Copy software legally, the GNU way!
Use GNU software, and legally make and share copies of software.
See http://www.gnu.org
    http://www.redhat.com
    http://www.linux-mandrake.com
    http://www.calderasystems.com/
    http://www.linuxapps.com/