Re: some questions re. Ada/GNAT from a C++/GCC user

[Ted Dennison <dennison@escmail.orl.mmc.com>]

Bill Newman wrote:
> 
> Does GNAT completely implement generics as defined in the standard?
> (I ask because I have heard that no compiler, G++ otherwise, has yet
> implemented C++ templates completely, and the G++ implementation
> caused me lots of hassles before 2.7.x, and still causes some hassles
> now.)

The environment in the Ada community is such that the community won't
accept an Ada compiler that doesn't match the standard, except in some
extreme circumstances (such as embedded programming). If it is in the
Ada standard, then you can pretty much count on an Ada compiler 
implementing it as specified (barring bugs of course).

> When I make two different instantiations of a generic package with the
> same arguments, I understand the compiler treats them formally as two
> different packages, which is OK with me.  However, I'd appreciate
> knowing the compiler wouldn't actually output two redundant copies of
> the corresponding (identical?) machine code, but instead share the
> code.  I saw somewhere that the compiler is given considerable freedom
> to share one instantiation between several arguments if it thinks it's
> appropriate, which is also OK with me.  However, I haven't seen any
> guarantee that the compiler won't output redundant copies for
> instantiations with identical arguments.  Is there such a guarantee?

If you want a guarantee, put the code you want shared in a non-generic
package or procedure, and call it from your generic package or
procedure.

> Why doesn't Ada 95 allow declarations to be interspersed with ordinary
> statements as C++ does?  (Or does it?  _Ada as a Second Language_ is a
> big book!)  It seems to me that the C++ approach is a small but
> definite win.  Does it interact very badly somehow with all those
> guarantees on elaboration order?

Not really. If you want to declare variables later in the code just 
use a declare block:
   declare
      Var1 : My_Type;
      ...
   begin
      Var1 := My_Value;
      ...
   end;

This has the added benefit of limiting the scope of Var1 to the
begin..end
block of code.

(paraphrase: where are macros?)

I hate macros!!! Anyone who has has ever tried to compile emacs from
sources should agree with me. Anyone who has ever tried to figure out
"portable" C code should agree with me. Practically all of the
functionality of macros can be implemented in Ada in other ways. Ways
that are much easier to understand and maintain.

And lastly, if you really like them, implement your own pre-processor.
You wouldn't be the first.

> Finally, I found it intriguing when someone (somewhere in the endless
> C++ vs. Ada thread) described a program which used exceptions to
> convert runtime errors to `graceful degradation' so successfully that
> the program (for fire control?!) continued operating more-or-less

If you are mostly doing command processing (and no human lives are at
stake), this makes perfect sense. Just because there is some kind of 
problem (or exceptional condition) with one command doesn't mean the 
others can't work perfectly. In this case, why core dump? Just log the 
problem and continue.


-- 
T.E.D.          
                |  Work - mailto:dennison@escmail.orl.mmc.com  |
                |  Home - mailto:dennison@iag.net              |
                |  URL  - http://www.iag.net/~dennison         |