Re: calenday (was Re: IBM Acquires Rational Ada

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

Robert A Duff <bobduff@shell01.TheWorld.com> wrote in message
news:wcc4r9b40ka.fsf@shell01.TheWorld.com...
>
> Hahah!  So you *do* care about portability!  (To newer versions of the
> same compiler, at least.)  In any case, I think the RM should tell you
> which rep clauses are legal, rather than tripping over
> implementation-dependent compiler error messages.  I think you agree
> with that...
>
Nahhh. There comes a point in some really serious embedded projects where
you freeze the version of the compiler because you can't invalidate all your
verification effort by switching to a new one. Its more like the case where
some bozo at the other end of the hose says "You know that message we used
to agree was going to look like this? I've got a problem at this end which
means I've got to change it to look like that....." and now the message you
used to have coaxed the compiler into accepting needs to be redone as the
bit-twiddling variety. Better to pick an answer that is going to work 100%
of the time than get stuck with major rework later.

Now all other things being equal, I'd rather have 100% portability and 100%
guarantees about what *must* work on all compilers rather than dealing with
two compilers dancing to the beat of their own drummers. It would be nice to
have rep clauses that gave you 100% of everything you ever asked for in a
record layout. If I can't have any of the above, I'll settle for
implementation dependent behavior that gets me the layouts I want. (Like I
said, for a given project, you often know you're never going to change
compilers - and if you did, you'd have much bigger fish to fry than settling
out a few rep clauses.)

If none of that is practical, then lets go invent some new kind of data
structure similar to a record that is used strictly for pulling the bits
apart in an arbitrary byte stream.  Usually, when you're dealing with this,
you're pulling data together from a variety of places where it is used
computationally and packing it up to ship it off somewhere, so all you care
about is packing and unpacking it. Since I (with my limited intellect) can
figure out how to write a bunch of procedures and functions with hard-coded
bit/byte positions in them to pick apart what I want from a byte array, I'd
think the compiler could do the same and give me a little help getting the
job done. If that requires some special pragmas or modified data structure
with different rules, I can live with that.

MDC
--
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jast.mil/

Send Replies To: m c o n d i c @ a c m . o r g

    "I'd trade it all for just a little more"
        --  Charles Montgomery Burns, [4F10]
======================================================================