Ada Compilers

Ada Compilers

[David Rasmussen]

What is the best free Ada compiler available?

I know that question is probably silly and will get me redirected to the 
faq. Still, I would like to hear _people's_ opinion, instead of the 
usual "we can't say what's best, that's relative".

More importantly, what do the free compilers lack in contrast to the 
commercial ones?

Also, how portable is typical Ada, and how good is code generation 
compared to C++ on the same platform (typically)?

/David

Re: Ada Compilers

[Marin David Condic]

"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE2AF22.2060208@gmx.spam.egg.sausage.and.spam.net...
> What is the best free Ada compiler available?

AFAIK, there are only two that are free. ObjectAda (which comes in a limited
version as a kind of "trial" size) and GNAT. Of the two, GNAT is generally
used more because it is not limited - its the full-up production quality
compiler.

There are also some that could be considered "cheap" (money-wise). RR
Software and ObjectAda have versions that are priced within the reach of an
average hobbyist.

>
> I know that question is probably silly and will get me redirected to the
> faq.

See: http://www.adapower.com/ for more info. (Including the FAQ)

Look under "Links" for Ada compilers and vendors. Also under Resources.


Still, I would like to hear _people's_ opinion, instead of the
> usual "we can't say what's best, that's relative".
>
For the record: "we can't say what's best, that's relative". :-) It truly
is, because it depends on what you want to do with it. If you want a
recommendation about what is "best" for a hobbyist with a PC and Windows who
just wants to learn Ada for general purpose software development, I'd say
that GNAT is probably best. You can't beat its price/performance ratio! But
the issue can become immediately sticky the moment you start introducing
other variables - type of application, host/target hardware,
embedded/realtime, required level of support, etc.


> More importantly, what do the free compilers lack in contrast to the
> commercial ones?
>
The free compilers generally won't supply you with any support for the money
you aren't paying. However, if you need support, there are ways to get it -
you just have to open up your wallet. You also won't have the kinds of
selection of targets and such that for-money compilers typically can
provide. You also won't get all of the available tools or the
latest/greatest versions of things either. You get what you pay for - should
be pretty obvious, eh?


> Also, how portable is typical Ada, and how good is code generation
> compared to C++ on the same platform (typically)?
>
Ada is extremely portable. You have to know something about how to make code
portable since you can always hook yourself into platform dependencies no
matter what language you're given. Ada is generally more portable than C++
because compilers have to run a validation suite & AFAIK, most C++ compilers
aren't being validated against the latest standard. (Lots of known variance
between the different compilers and the standard.) I have ported large apps
a number of times between Alpha/VMS, Sun/Unix and PC/Windows & had
surprisingly few problems - often requiring nothing more than a recompile.
But then again, I *knew* I'd have to port so I wasn't hooked into platform
dependencies - or had them isolated where the problems would be minimized.

Quality of code generation? You can't compare this. Its been discussed here
many times. The *language* doesn't determine the quality of code generation.
The *implementation* does. Some compilers are better than others - and
that's all you can hope to compare. (For example: "How good is this version
of the GNAT Ada compiler on a PC versus that version of the MSVC++ compiler
for the PC given this specific collection of algorithms/code?")

That said, there is nothing inherent in Ada that would make it less
efficient than C/C++. Many implementations of Ada generate code that is as
good or better than many implementations of C/C++ for equivalent programs.
So don't worry that Ada is going to somehow or other be "slow". You have to
pick a quality compiler that produces good code for the types of algorithms
you usually write and you have to know the language/implementation well so
that you can get the most out of it.

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

Re: Ada Compilers

[Jacob Sparre Andersen]

David Rasmussen wrote:

> What is the best free Ada compiler available?

I don't know, but GCC appears to be the most popular one.

> More importantly, what do the free compilers lack in contrast to the
> commercial ones?

Cost. ;-)

> Also, how portable is typical Ada,

Very portable. When I make data processing programs they can
usually work on OS/2 and at least a few different Unix'es
without any changes. For big projects (>100,000 lines of
code) it is my impression that less than 0.1% of the code
lines will have to be changed.

> and how good is code generation
> compared to C++ on the same platform (typically)?

It is kind of hard to say, but on thing to be aware of right
now is that GCC/Ada still primarily is distributed as GCC
2.8, whereas GCC/C++ primarily is distributed as GCC 3.0,
i.e. with a newer and supposedly better code generator. Once
GCC/Ada is also distributed based on the official GNU CVS
this difference will disappear.

Jacob
-- 
Growing older is compulsory. Growing up isn't.

Re: Ada Compilers

[Marin David Condic]

"Jacob Sparre Andersen" <sparre@nbi.dk> wrote in message
news:3CE2C8FD.CDD0E75B@nbi.dk...
> David Rasmussen wrote:
>
> > More importantly, what do the free compilers lack in contrast to the
> > commercial ones?
>
> Cost. ;-)
>

It occurs to me that the OP may have been wondering if the free compilers
don't implement as much of the language as do the commercial ones. If that's
the question, then it is important to observe that GNAT does implement the
whole language. ObjectAda implements the full language as well, but I have
not examined the free version to know if part of the limitations are lack of
some features. I'd suspect the limits are not with respect to supported
language features.

Otherwise, its going to come down to add-on tools, support, updates, etc.
What do you want/need beyond the ability to translate Ada source into
executable programs?

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

Re: Ada Compilers

[Pascal Obry]

Jacob Sparre Andersen <sparre@nbi.dk> writes:

> David Rasmussen wrote:
> 
> > What is the best free Ada compiler available?
> 
> I don't know, but GCC appears to be the most popular one.

Well the Ada compiler part of GCC is named GNAT (GNU/Ada).

> > More importantly, what do the free compilers lack in contrast to the
> > commercial ones?
> 
> Cost. ;-)

Note that there is only one free (speech) Ada compiler, and it is the single
Ada compiler to implement all Ada annexes.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Kai Schuelke]

----- Original Message -----
From: "Pascal Obry" <p.obry@wanadoo.fr>
Newsgroups: comp.lang.ada
Sent: Wednesday, May 15, 2002 11:38 PM
Subject: Re: Ada Compilers


> Note that there is only one free (speech) Ada compiler, and it is the
single
> Ada compiler to implement all Ada annexes.

Hello,

could you please explain whats the difference to the Aonix compiler? Or
which annexes the other compilers didn't implement? I am just a beginner but
my first impression was that Aonix produced more "reliable" results. But
thats just a feeling.

Good night

Kai Schuelke

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 00:35:35 +0200, Kai Schuelke wrote:
> could you please explain whats the difference to the Aonix compiler? Or
> which annexes the other compilers didn't implement? I am just a beginner but
> my first impression was that Aonix produced more "reliable" results. But
                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Why do you think that?

> thats just a feeling.

Preben

Re: Ada Compilers

[Dmitry A. Kazakov]

On Thu, 16 May 2002 00:35:35 +0200, "Kai Schuelke"
<kai.schuelke@gmx.net> wrote:

>could you please explain whats the difference to the Aonix compiler? Or
>which annexes the other compilers didn't implement?

I believe it just limits the number of compilation units to 30.

>I am just a beginner but
>my first impression was that Aonix produced more "reliable" results. But
>thats just a feeling.

It does some things better and some worse than GNAT. It is nice to
have both, because in case of a compilation error messages from GNAT
and from Aonix nicely complement each other. (:-))

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Ada Compilers

[Martin Dowie]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
news:jg17eu40v2r1vbnep19bd9i97e4qg5cfco@4ax.com...
> On Thu, 16 May 2002 00:35:35 +0200, "Kai Schuelke"
> <kai.schuelke@gmx.net> wrote:
>
> >could you please explain whats the difference to the Aonix compiler? Or
> >which annexes the other compilers didn't implement?
>
> I believe it just limits the number of compilation units to 30.

v7.2.1 SE is:

<= 35 units
<= 20 tasks
<= 2000 lines per 'compilation' (I think they actually mean compilation
unit)
<= 550 lines per 'Java compilation'

non-commercial use only, not validated.

Re: Ada Compilers

[Ted Dennison]

"Kai Schuelke" <kai.schuelke@gmx.net> wrote in message news:<3ce2e29f.0@news.unibw-muenchen.de>...
> ----- Original Message -----
> From: "Pascal Obry" <p.obry@wanadoo.fr>
> Newsgroups: comp.lang.ada
> Sent: Wednesday, May 15, 2002 11:38 PM
> Subject: Re: Ada Compilers
> 
> 
> > Note that there is only one free (speech) Ada compiler, and it is the
>  single
> > Ada compiler to implement all Ada annexes.

> could you please explain whats the difference to the Aonix compiler? Or
> which annexes the other compilers didn't implement? I am just a beginner but
> my first impression was that Aonix produced more "reliable" results. But
> thats just a feeling.

Well, I certianly can't explain why you'd think its results are more
"reliable", unless this is some new meaning to the word of which I am
unaccustomed. :-)

The free (no cost) downloadable Aonix compiler doesn't support the
distributed system annex. There might be some more annexes it doesn't
have either, but nothing that would impair a beginner's ability to
program on Windows. It main drawback is that it is crippleware. Once
your program gets past a certian size, the compiler will refuse to
compile it. If you are just playing around with little programs, you
aren't likely to hit that limit though. If you do, you can fix that by
going out and purchasing the full version, which I understand is not
too much more expensive than VisualC++. Not a bad deal at all really.

The Gnu Ada compiler is free in terms of freedom; it, and thus its
users, are not in thrall to any one vendor or person. (See
http://www.gnu.org/philosophy/free-sw.html for more about what "Free
Software" is all about). It is not crippled in any real way, and I
believe implements *all* the annexes. Its main drawback for some is
that its IDE doesn't resemble the VisualC++ IDE, which a lot of newbie
programmers get lost without. If you are comfortable (or want to learn
to become comfortable) with Emacs, then this is probably the free
compiler for you. Apparently a VC++ style IDE is on the way too.


-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html (down)

Re: Ada Compilers

[Robert Dewar]

dennison@telepath.com (Ted Dennison) wrote in message news:<4519e058.0205160706.52667440@posting.google.com>...
> If you are comfortable (or want to learn
> to become comfortable) with Emacs, then this is probably 
> the free compiler for you. Apparently a VC++ style IDE is 
> on the way too.

I think that Ted is giving dubious advice here. I would not
advise a beginner to plunge into EMACS. Instead the obvious
IDE to use is AdaGIDE which is specifically intended for
use by beginners learning Ada (but is sufficiently powerful
to support large projects).

Re: Ada Compilers

[Ted Dennison]

dewar@gnat.com (Robert Dewar) wrote in message news:<5ee5b646.0205161722.18eacc4b@posting.google.com>...
> dennison@telepath.com (Ted Dennison) wrote in message news:<4519e058.0205160706.52667440@posting.google.com>...
> > If you are comfortable (or want to learn
> > to become comfortable) with Emacs, then this is probably 
> > the free compiler for you. Apparently a VC++ style IDE is 
> > on the way too.
> 
> I think that Ted is giving dubious advice here. I would not
> advise a beginner to plunge into EMACS. Instead the obvious

Two things here:

1) I was advising nothing of the sort, which should have been quite
clear from the text you quoted. I was only giving an option
conditioned on whether the poster wants to use Emacs or not. There is
no text in my message on whether that's advisable or not. There's a
good reason for that, which is...

2) The poster never claimed to be a beginner with programming in
general, just with Ada. You could be right when you assume the former,
but that information was not presented for our consideration.


-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html (down)

Re: Ada Compilers

[Robert Dewar]

dennison@telepath.com (Ted Dennison) wrote in message news:<4519e058.0205160706.52667440@posting.google.com>...
> Apparently a VC++ style IDE is on the way too.

Not sure what Ted is talking about here. If you are talking
about the GNAT Programming System (GPS), please be assured that
copying Microsoft was *not* a design criterion :-)

Re: Ada Compilers

[Pascal Obry]

"Kai Schuelke" <kai.schuelke@gmx.net> writes:

> > Note that there is only one free (speech) Ada compiler, and it is the
> single
> > Ada compiler to implement all Ada annexes.
> 
> Hello,
> 
> could you please explain whats the difference to the Aonix compiler? Or

First ObjectAda has a free (beer) version but it is not a free (speech)
compiler. You can't access ObjectAda sources.

> which annexes the other compilers didn't implement? I am just a beginner but

For example Annexe E, but there is others. GNAT implements all of them. Check
Aonix web site for the list of annexes they implement.

> my first impression was that Aonix produced more "reliable" results. But
> thats just a feeling.

This is just feeling I would say. I think that all compilers have their set of
problems.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Kai Schuelke]

Hello,

what made me feel that Aonix is more "standard" was a combination of some
minor experiences we made at our Ada school and what the teachers said about
Aonix vs. Gnat (we used both). I can use the full license of Aonix, so that
I didn't see it's limitations.

What I really like about Aonix is the IDE (esp. the GUI-Builder) but thats
not really a compiler issue, but I have to admit that the Gnat error
messages were more helpful than the Aonix ones.

My feeling was intended to be a comment form a beginners point of view, but
no conclusion after years of experience.

ReadU

Kai Schuelke

Re: Ada Compilers

[Robert Dewar]

"Kai Schuelke" <kai.schuelke@gmx.net> wrote in message news:<3ce3ff73.0@news.unibw-muenchen.de>...

> what made me feel that Aonix is more "standard" was a
> combination of some minor experiences we made at our Ada > school

At this stage all the Ada 95 compilers that are available
are sufficiently conformant to the standard that it is
VERY unlikely that beginning students would run into any
discrepancies in any compiler, so these "minor experiences"
were probably misinterpreted.

Re: [off-topic] "free"

[Wes Groleau]

> First ObjectAda has a free (beer) version but it is not a free (speech)
> compiler. You can't access ObjectAda sources.

If the bartender gives you a key to the brewery, which kind of "free" is
that?  :-)

-- 
Wes Troll, Oh!
http://freepages.humor.rootsweb.com/~wgroleau

Re: [off-topic] "free"

[Preben Randhol]

On Fri, 17 May 2002 08:38:35 -0500, Wes Groleau wrote:
> 
>> First ObjectAda has a free (beer) version but it is not a free (speech)
>> compiler. You can't access ObjectAda sources.
> 
> If the bartender gives you a key to the brewery, which kind of "free" is
> that?  :-)

Open Source ;-)

Preben

Re: Ada Compilers

[Fraser Wilson]

Jacob Sparre Andersen <sparre@nbi.dk> writes:

> It is kind of hard to say, but on thing to be aware of right
> now is that GCC/Ada still primarily is distributed as GCC
> 2.8, whereas GCC/C++ primarily is distributed as GCC 3.0,
> i.e. with a newer and supposedly better code generator.

Ah, timing is everything.  Apparently GCC 3.1 has just been released
(http://gcc.gnu.org/gcc-3.1/), and GNAT is one of the official front
ends: http://gcc.gnu.org/frontends.html

I guess it contains GNAT 3.14p, but it's a bit hard to tell from the
web page.

Fraser.

Re: Ada Compilers

[Florian Weimer]

newsfraser@blancolioni.org (Fraser Wilson) writes:

[GCC 3.1]

> I guess it contains GNAT 3.14p,

No, it comes with a different version of the front end and the GNAT
tools.  There are quite a few additional features, AFAIK.

Re: Ada Compilers

[Florian Weimer]

David Rasmussen <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> writes:

> More importantly, what do the free compilers lack in contrast to the
> commercial ones?

GNAT lacks unimplemented annexes in contrast to proprietary compilers?
(GNAT is a commercial compiler, too, so you probably mean something 
else.)

> Also, how portable is typical Ada, and how good is code generation
> compared to C++ on the same platform (typically)?

That's easy in the case of GNAT: identical for equivalent programs.
Both GNU compilers share the same code generator.

Re: Ada Compilers

[Marin David Condic]

True, but misleading. GNAT and GNU C/C++ may all share the same back end &
hence produce similar code for similar input programs, but that in no way
says anything about how good the code is compared to some other compiler
that works for either Ada, C or C++. Its theoretically possible that the gcc
backend might generate really crappy code and hence Ada and C++ are equally
bad. What does that tell you about the relative efficiency of Ada or C++?

This is why its totally useless to ask the question "How does Ada compare
against C++ for efficiency...?" The best we can answer is that the Ada
standard doesn't impose anything that is inherently inefficient for the
semantic content delivered and the rest is a matter of comparing one
compiler against another. There are efficient implementations of both Ada
and C++. There are also bad implementations of both languages. We *really*
need to educate developers (who *should* know this by the time they leave
college!) that languages aren't "slow" - only implementations are.

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


"Florian Weimer" <fw@deneb.enyo.de> wrote in message
news:878z6kq4rr.fsf@deneb.enyo.de...
>
> That's easy in the case of GNAT: identical for equivalent programs.
> Both GNU compilers share the same code generator.

Re: Ada Compilers

[David Rasmussen]

Marin David Condic wrote:
> True, but misleading. GNAT and GNU C/C++ may all share the same back end &
> hence produce similar code for similar input programs, but that in no way
> says anything about how good the code is compared to some other compiler
> that works for either Ada, C or C++. Its theoretically possible that the gcc
> backend might generate really crappy code and hence Ada and C++ are equally
> bad. What does that tell you about the relative efficiency of Ada or C++?
> 
> This is why its totally useless to ask the question "How does Ada compare
> against C++ for efficiency...?" The best we can answer is that the Ada
> standard doesn't impose anything that is inherently inefficient for the
> semantic content delivered and the rest is a matter of comparing one
> compiler against another. There are efficient implementations of both Ada
> and C++. There are also bad implementations of both languages. We *really*
> need to educate developers (who *should* know this by the time they leave
> college!) that languages aren't "slow" - only implementations are.
> 

I know that, of course. My question was of a more pragmatic nature. Most 
languages (ML, Lisp, Java etc.) could have compilers that created as 
good code on a given platform (say x86), as the best C compilers for the 
same platform. But in real life, this is not at all the case. So my 
question was if, in practice, most Ada compilers generate code that is 
comparable to, say, C++ compilers. The question makes a lot of pragmatic 
sense.

/David

Re: Ada Compilers

[Jacob Sparre Andersen]

David Rasmussen wrote:

> So my
> question was if, in practice, most Ada compilers generate code that is
> comparable to, say, C++ compilers.

I haven't had time to compare the GCC 3.1 Ada and C++
compilers yet, but last time I compared the front-ends, the
Ada front-end was clearly better at optimising than the C++
one.

Jacob
-- 
Sk�ne Sj�lland Linux User Group - http://www.sslug.dk/
N�ste m�de: Foredragsaften p� Lunds Tekniske H�gskola.
Torsdag den 30. maj 2002 p�/i Lund, LTH, E:2116.

Re: Ada Compilers

[Marin David Condic]

Well, from a purely *practical* standpoint (realizing that we are talking
about existing implementations rather than either the language or any
particular compiler) we might say this: Most popular Ada implementations are
generating code that is pretty efficient in comparison to most other
compiled languages. You won't discover that your basic workstation/PC
application programmed in Ada is somehow bog-slow in comparison to the same
thing in some other language typically used for the same application.

Now a few caveats: If you truly have a time-critical application, you'd best
conduct a timing study with algorithms typical of the application at hand.
Compilers (even for the same language) can have a good deal of variance in
terms of the code they generate for different operations. Be sure that when
timing any Ada code, that you either *really* know what you're doing or that
you are working with the vendor to get the best possible optimization. (Its
easy to compile with all runtime checking in place and/or by using
constructs unwisely and discovering you have pretty slow code. Quite often
throwing a few compiler switches, or including a few pragmas or otherwise
tweaking things a bit, you get really nice code. But you need to know...)

There are some Ada implementations for some targets that are extremely
highly optimizing and will do a wonderful job of producing highly efficient
code. Remember that Ada was originally invented for embedded, real time
apps, so it is possible to find very efficient compilers. However, that
isn't saying there are highly efficient compilers for all platforms and
targets. It also isn't saying that they will be efficient for the algorithms
you intend to use. Compiler timing studies are *very* complex to get right.
(I've been through a couple of serious ones) But its the only way to get any
truly useful information.

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


"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE58053.2020809@gmx.spam.egg.sausage.and.spam.net...
>
> I know that, of course. My question was of a more pragmatic nature. Most
> languages (ML, Lisp, Java etc.) could have compilers that created as
> good code on a given platform (say x86), as the best C compilers for the
> same platform. But in real life, this is not at all the case. So my
> question was if, in practice, most Ada compilers generate code that is
> comparable to, say, C++ compilers. The question makes a lot of pragmatic
> sense.
>

Re: Ada Compilers

[Greg Bek]

As a compiler vendor I'd just like to echo MDC's comments.
Don't just use standard benchmarks, use your application or
portions of it for testing performance.  Benchmarks like
the PIWG's are not sufficiently sophisticated to properly
perform timing of null loops etc.

Ada compilers have many advantages over languages like C/C++
in that the compiler has greater visibility into the rest of
a user program.  An Ada compiler can automatically inline
code across multiple levels of subprogram call, C/C++ have
difficulty doing this as any called subprogram is usually
compiled into a different object module.  This means that
C/C++ must perform a call/return where the Ada code may
have the call/return (and associated prolog/epilog, stack
check) eliminated.

Our compiler (Rational Apex), performs this kind of inlining
as well as loop unrolling etc.  Another very useful technique
is "value propagation", this is where the compiler tracks the
range of values taken by an object.  Knowing the possible
range of values means that the compiler can eliminate 
constraint checks that are not needed.  This can have some
very disconcerting side affects for the unwary.

If the compiler determines that a section of code has no
side affects (ie: no exceptions can be raised), and that the
results of that section of code are not used, then it 
eliminates all of the code.   The PIWG henessey benchmark
is an example of code that suffers because of this. The
large matrix multiplication contained within the benchmark
is eliminated as the matracies are populated with small-ish
values, the compiler concludes that the range of the resulting
sum of products will never overflow.  It then discovers that
the resulting matrix is never used, so it throws out the entire 
matrix multiplication.  The surrounding timing loop is now 
timing a null operation.

Modern compilers are very good at producing optimized code
under most circumstances.

However there are some subtle issues with Ada that can 
prevent getting the best code possible.  The best example
of this is using controlled objects within your program.
Controlled types require the compiler to generate invisible
code that makes sure any objects are properly finalized when
a scope is exited.

When compiling a routine that uses a class wide type the
compiler may not know whether controlled types are used 
to extend the base type, so it must be pessimistic and 
generate finalization code that may never be called.

If you don't have controlled objects and your compiler has a 
mechanism for optimizing accordingly, then use that mechanism
(switch, library directive, configuration pragma).

As always your milage will vary.

Greg Bek
-------------------------------------------
Greg Bek  mailto:gab@rational.com
Product Manager, Rational Apex Family
Rational Software
-------------------------------------------

Re: Ada Compilers

[Robert Dewar]

gab@rational.com (Greg Bek) wrote in message news:<afb6d339.0205211331.30124c52@posting.google.com>...

> sum of products will never overflow.  It then discovers that
> the resulting matrix is never used, so it throws out the entire 
> matrix multiplication.  The surrounding timing loop is now 
> timing a null operation.

Right, in one case where GNAT was being compared with another
compiler on this test, both versions were testing the time for
this null loop, and because of an oddity, GNAT took longer. 
So we fixed it and then it took shorter. Wonderful, but nothing
at all to do with the intent of the test. The PIWG tests are
very poorly written from this point of view.

Re: Ada Compilers

[Marin David Condic]

"Greg Bek" <gab@rational.com> wrote in message
news:afb6d339.0205211331.30124c52@posting.google.com...
> As a compiler vendor I'd just like to echo MDC's comments.
> Don't just use standard benchmarks, use your application or
> portions of it for testing performance.  Benchmarks like
> the PIWG's are not sufficiently sophisticated to properly
> perform timing of null loops etc.
>
Thanks for the echo. Call me "Marin" - everyone else does. :-)

Artificial benchmarks may tell you something but it is *much* better to use
typical segments of your own apps to try to evaluate performance. Some apps
do lots of data motion, others do lots of comparisons, others do specific
kinds of math, etc. Any given compiler might, for example, generate *really*
tight code for linear equations, but generate slow code for data motion.
Vendors can't do everything, so they spend time optimizing particular
aspects of their products & you'll see as a result that perfectly fine
compilers will have considerable variance in what they come up with for
different applications.


> Ada compilers have many advantages over languages like C/C++
> in that the compiler has greater visibility into the rest of
> a user program.  An Ada compiler can automatically inline
> code across multiple levels of subprogram call, C/C++ have
> difficulty doing this as any called subprogram is usually
> compiled into a different object module.  This means that
> C/C++ must perform a call/return where the Ada code may
> have the call/return (and associated prolog/epilog, stack
> check) eliminated.
>
And of course, as every year goes by in the life of a compiler, more and
more optimizations are found. Every day, in every way, they're getting
better and better. :-) The Ada vendors certainly do have advantages over
some other more popular languages because of how well the language was
designed and the information content of the language being so high.


>
> Modern compilers are very good at producing optimized code
> under most circumstances.
>
We should remember to keep this in perspective too. When I was building
avionics systems, extremely aggressive optimization and really compact, fast
code were life-and-death issues for the projects. I use Ada now mostly for
PC-ish applications and performance is not nearly so critical. What matters
then are other sorts of creature comforts. (development tools, libraries,
etc.) The caveat being that when shopping for a compiler, you need to ask
about what is important for the intended project and not necessarily buy an
avionics-quality compiler just because you are obsessed with speed.

Of course, if someone can give me *everything* for *nothing* I'd be really
thrilled. But I won't hold my breath. :-)


> However there are some subtle issues with Ada that can
> prevent getting the best code possible.  The best example
> of this is using controlled objects within your program.
> Controlled types require the compiler to generate invisible
> code that makes sure any objects are properly finalized when
> a scope is exited.
>
If high performance is an issue for your apps, you need to *really*
understand the language or you can generate inefficient code and be
wondering why. You often have to experiment with alternate ways of
accomplishing the same thing to find the one that fools the compiler into
generating the code you want. I recall once dealing with initialization of
some records where expressing it one way caused the compiler to go off
making a bunch of subroutine calls, but doing it another way we got a single
move of a constant in memory. Know the language and experiment!


>
> As always your milage will vary.
>

Absolutely. And don't besmirch compiler X because it doesn't optimize your
code as nicely as compiler Y. It may optimize someone else's code better
and/or there is a good chance you don't know what you're talking about. :-)

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

Re: Ada Compilers

[John R. Strohm]

I'd be VERY interested in seeing a fairly detailed example on this
particular item.

Part of the GLOBAL thrust of what I'm doing is gearing myself up on Ada95,
with the idea in the back of my head of tackling some things that are
typically done in C/C++, and seeing if I can learn enough along the way to
replicate your results in a different domain area: 2x productivity, 1/4x
defect density.

Gotta do something to pass the time between job interviews and mailing out
resumes and such.

(The argument is something like this:  "Now, we all know that there really
aren't any silver bullets, right?  There really aren't any magic wands you
can wave, that will just like magic give you 2x productivity improvement and
1/4x defect density, right?  We all know that, don't we?  Well, what if
there was one?  Suppose there WAS such a wand, such a super secret magic
bullet, that really would let you tackle your current project with half as
many cars in the parking lot, that would let you write only 1/4 as many bug
reports and bug fix reports and retest reports.  If such a wand really did
exist, would you ignore it, throw it away, bury it in a landfill and post
armed guards 24/7 around it, or would you grab it and wave it for all you
were worth?")

"Marin David Condic" <dont.bother.mcondic.auntie.spam@[acm.org> wrote in
message news:acg7rd$15g$1@nh.pace.co.uk...
> If high performance is an issue for your apps, you need to *really*
> understand the language or you can generate inefficient code and be
> wondering why. You often have to experiment with alternate ways of
> accomplishing the same thing to find the one that fools the compiler into
> generating the code you want. I recall once dealing with initialization of
> some records where expressing it one way caused the compiler to go off
> making a bunch of subroutine calls, but doing it another way we got a
single
> move of a constant in memory. Know the language and experiment!

Re: Ada Compilers

[Marin David Condic]

"John R. Strohm" <strohm@airmail.net> wrote in message
news:2AEB9D17A335FB6F.78506B6494B0AFF3.EE290620571FE224@lp.airnews.net...
> I'd be VERY interested in seeing a fairly detailed example on this
> particular item.
>
What item? The initialization thing? Its been a really long time so I don't
remember exactly what we did. We were using the XD-Ada compiler for the
Mil-Std-1750a. (Might also have been true of the MC680x0 target as well, but
I didn't test it on that path.) IIRC, we had a record type that was
initialized by default values. When you declared an object of that type, the
compiler generated subroutine calls for it to get it initialized. It was
causing speed problems, so we tinkered. Initializing it with an aggregate
instead (no default initial values for the type) got us down to the one-word
data move we wanted. Or maybe it was the other way around. :-) It *was* a
long time ago. But it illustrates that you can get very different code to
accomplish the same goal, so you really have to know your compiler, etc.


> Part of the GLOBAL thrust of what I'm doing is gearing myself up on Ada95,
> with the idea in the back of my head of tackling some things that are
> typically done in C/C++, and seeing if I can learn enough along the way to
> replicate your results in a different domain area: 2x productivity, 1/4x
> defect density.
>
You have to be real careful because there is always that all-important
caveat: YOUR MILEAGE MAY VARY!!! :-) In this particular realm, we had a very
specialized process and unlike most projects, we were frequently building
essentially the same thing over and over again. The kinds of errors we
encountered were really peculiar to the specific problem domain and wouldn't
necessarily apply across the board. Hence the productivity and defect rates
may not be anywhere near what someone else in another problem space would
realize. (You might even do better? Who knows?) Also, since we were
measuring a live process that was going on over maybe more than 10 years,
you didn't exactly have laboratory-grade isolation of just the language.
Other things were going on at the same time, so its hard to credit just Ada
for the improvements & have strong confidence that you could reproduce the
same result in another environment just by injecting a new language.


> Gotta do something to pass the time between job interviews and mailing out
> resumes and such.
>
I feel your pain. :-) Giving some thought to re-entering the fray once again
myself. Not a prospect I relish, but sometimes its the thing to do. Good
luck with it and I hope you find something where you can use & promote Ada.


> (The argument is something like this:  "Now, we all know that there really
> aren't any silver bullets, right?  There really aren't any magic wands you
> can wave, that will just like magic give you 2x productivity improvement
and
> 1/4x defect density, right?  We all know that, don't we?  Well, what if
> there was one?  Suppose there WAS such a wand, such a super secret magic
> bullet, that really would let you tackle your current project with half as
> many cars in the parking lot, that would let you write only 1/4 as many
bug
> reports and bug fix reports and retest reports.  If such a wand really did
> exist, would you ignore it, throw it away, bury it in a landfill and post
> armed guards 24/7 around it, or would you grab it and wave it for all you
> were worth?")
>

I understand and possibly agree - to a point. Its just that a lot more is
going to go into productivity and defects than just the language. Its that
bind of "All Other Things Being Equal" - which is almost never the case.
Sure, Ada (in the abstract sense) is better for building reliable software
quickly than is C. But what if C decides to cheat? If C gives you some huge
library of stuff that gets you 75% of the way out the door right now and
that library has been used/debugged extensively, and there is no equivalent
for Ada, will not C win? Or if the project is fairly short term and the
staff already knows C++ extensively and knows nothing about Ada, can Ada
win?

I believe Ada is better based on the evidence I've seen over the years. Its
just that the competition is seldom on an even playing field. The way around
that is for Ada to create its own playing field where the other languages
are at a disadvantage. We don't have to be "fair" or "nice" about it either,
do we? :-)

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

Re: Ada Compilers

[Ted Dennison]

"John R. Strohm" <strohm@airmail.net> wrote in message news:<2AEB9D17A335FB6F.78506B6494B0AFF3.EE290620571FE224@lp.airnews.net>...
> (The argument is something like this:  "Now, we all know that there really
> aren't any silver bullets, right?  There really aren't any magic wands you
> can wave, that will just like magic give you 2x productivity improvement and
> 1/4x defect density, right?  We all know that, don't we?  Well, what if
> there was one?  Suppose there WAS such a wand, such a super secret magic

For the record, to qualify as Brooks' famous "Silver Bullet", you
would have to have something that would improve things by a factor of
10, not just 2 or 4. Ada provides a package that is pretty close to
what Brooks termed a "Brass Bullet" in his essay "No Silver Bullet,
Refired". He was talking about OO languages in general, but C++ and
Smalltalk were used as examples. I'd say Rational's numbers prove his
argument nicely.

Re: Ada Compilers

[Larry Kilgallen]

In article <2AEB9D17A335FB6F.78506B6494B0AFF3.EE290620571FE224@lp.airnews.net>, "John R. Strohm" <strohm@airmail.net> writes:

> (The argument is something like this:  "Now, we all know that there really
> aren't any silver bullets, right?  There really aren't any magic wands you
> can wave, that will just like magic give you 2x productivity improvement and
> 1/4x defect density, right?

Depending on your present circumstance, there may be a silver bullet
that will give you those benefits.

But there is no silver bullet that will give _everyone_ those benefits
(irrespective of present circumstance).

Re: Ada Compilers

[Steve Doiel]

"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE2AF22.2060208@gmx.spam.egg.sausage.and.spam.net...
> What is the best free Ada compiler available?

GNAT

> I know that question is probably silly and will get me redirected to the
> faq. Still, I would like to hear _people's_ opinion, instead of the
> usual "we can't say what's best, that's relative".
>
> More importantly, what do the free compilers lack in contrast to the
> commercial ones?

If you're just talking compiler, Gnat actually provides more than some of
the proprietary ones.

> Also, how portable is typical Ada, and how good is code generation
> compared to C++ on the same platform (typically)?

Portability: Excellent
Code generation: Very Good.  If you're comparing with free C++, Excellent.

>
> /David
>

Re: Ada Compilers

[Preben Randhol]

On Wed, 15 May 2002 20:55:30 +0200, David Rasmussen wrote:
> What is the best free Ada compiler available?

GNAT

available for Linux, Solaris, Windows, MacOS (there is a port worked on
by individuals)

GNAT will also be part of GCC.

> More importantly, what do the free compilers lack in contrast to the 
> commercial ones?

Nothing.

> Also, how portable is typical Ada, and how good is code generation 
> compared to C++ on the same platform (typically)?

Ada code is much more portible and if you use the libraries GNAT
supplies for interacting with the IO etc.. a recompile should be all you
need to do from one system to another. 

What do you mean how good is code generation?

More info is here why you should choose Ada over say C++:

   http://www.adapower.com/what.html

Preben Randhol ------------------- http://www.pvv.org/~randhol/ --
                 �For me, Ada95 puts back the joy in programming.�

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 10:33:34 +0000 (UTC), Preben Randhol wrote:
> On Wed, 15 May 2002 20:55:30 +0200, David Rasmussen wrote:
>> What is the best free Ada compiler available?
> 
> GNAT
> 
> available for Linux, Solaris, Windows, MacOS (there is a port worked on
> by individuals)

and many other systems.
-- 
Preben Randhol ------------------- http://www.pvv.org/~randhol/ --
                 �For me, Ada95 puts back the joy in programming.�

Re: Ada Compilers

[David Rasmussen]

Preben Randhol wrote:
> 
> What do you mean how good is code generation?
> 

I mean how good is the generated machine code on various CPU's (x86 for 
instance) with typical Ada compilers as compared with typical C++ compilers?

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 13:25:22 +0200, David Rasmussen wrote:
> Preben Randhol wrote:
>> 
>> What do you mean how good is code generation?
>> 
> 
> I mean how good is the generated machine code on various CPU's (x86 for 
> instance) with typical Ada compilers as compared with typical C++ compilers?
> 

Why? The important question is how good is the quality of the software
produced with Ada compared to C++.

Preben

Re: Ada Compilers

[David Rasmussen]

Preben Randhol wrote:
> On Thu, 16 May 2002 13:25:22 +0200, David Rasmussen wrote:
> 
>>Preben Randhol wrote:
>>
>>>What do you mean how good is code generation?
>>>
>>
>>I mean how good is the generated machine code on various CPU's (x86 for 
>>instance) with typical Ada compilers as compared with typical C++ compilers?
>>
> 
> 
> Why? The important question is how good is the quality of the software
> produced with Ada compared to C++.
> 
> Preben

No. For some applications, timewise performance is critical, and when 
you have chosen the design and improved the algorthms used as much as 
possible, you still want the fastest code possible. The quality of the 
software is of course paramount always, but if runtime performance is 
also an all-important criterion (but portability etc. also is, so you 
can't use assembler), it will be important to you how good the generated 
code is. It is for me, even if safety, correctness etc. is equally 
important.

/David

Re: Ada Compilers

[Steve Doiel]

"David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
in message news:3CE3B32D.9080309@gmx.spam.egg.sausage.and.spam.net...
[snip]
> For some applications, timewise performance is critical, and when
> you have chosen the design and improved the algorthms used as much as
> possible, you still want the fastest code possible. The quality of the
> software is of course paramount always, but if runtime performance is
> also an all-important criterion (but portability etc. also is, so you
> can't use assembler), it will be important to you how good the generated
> code is. It is for me, even if safety, correctness etc. is equally
> important.

I believe you will find that the performance of Ada matches or exceeds the
performance of C++ if you turn off runtime checks.  Since C++ does not have
these checks there is no compartive disadvantage to turning off the checks.
There is however the advantage that you can turn on the checks during
testing.  In many cases performance cost of runtime checks are low and they
are left enabled for delivered software.

> /David
>

Re: Ada Compilers

[David Rasmussen]

Steve Doiel wrote:
> "David Rasmussen" <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote
> in message news:3CE3B32D.9080309@gmx.spam.egg.sausage.and.spam.net...
> [snip]
> 
>>For some applications, timewise performance is critical, and when
>>you have chosen the design and improved the algorthms used as much as
>>possible, you still want the fastest code possible. The quality of the
>>software is of course paramount always, but if runtime performance is
>>also an all-important criterion (but portability etc. also is, so you
>>can't use assembler), it will be important to you how good the generated
>>code is. It is for me, even if safety, correctness etc. is equally
>>important.
> 
> 
> I believe you will find that the performance of Ada matches or exceeds the
> performance of C++ if you turn off runtime checks.  Since C++ does not have
> these checks there is no compartive disadvantage to turning off the checks.
> There is however the advantage that you can turn on the checks during
> testing.  In many cases performance cost of runtime checks are low and they
> are left enabled for delivered software.
> 

Cool. That was what I was looking for.

/David

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 15:25:01 +0200, David Rasmussen wrote:
> 
> No. For some applications, timewise performance is critical, and when 
> you have chosen the design and improved the algorthms used as much as 
> possible, you still want the fastest code possible. The quality of the 
> software is of course paramount always, but if runtime performance is 
> also an all-important criterion (but portability etc. also is, so you 
> can't use assembler), it will be important to you how good the generated 
> code is. It is for me, even if safety, correctness etc. is equally 
> important.

I agree with you. The reason I commented your question was that a lot of
people asking this question, but are not reflected as you seem to be.
People believe that the speed of the application is the most important
factor. This is generally not the case at all. At least when making
user applications. The user will loose far more time from program
crashes than that a program uses 2ms more to open a dialog.

Preben
-- 

Re: Ada Compilers

[Ted Dennison]

David Rasmussen <david.rasmussen@gmx.spam.egg.sausage.and.spam.net> wrote in message news:<3CE3B32D.9080309@gmx.spam.egg.sausage.and.spam.net>...
> No. For some applications, timewise performance is critical, and when 
> you have chosen the design and improved the algorthms used as much as 
> possible, you still want the fastest code possible. The quality of the 
> software is of course paramount always, but if runtime performance is 
> also an all-important criterion (but portability etc. also is, so you 
> can't use assembler), it will be important to you how good the generated 
> code is. It is for me, even if safety, correctness etc. is equally 
> important.


One thing I should mention here is that the Aonix compiler has *no*
compiler optimization options. Gnat and GCC have oodles of them. When
I asked Aonix about this, I was told that they do some optimization
(eg: peephole -type stuff) by default. But if you are into tweeking
optimization options on your compiler, I think you will be far happier
with Gnat.

-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Ada Compilers

[Marin David Condic]

Not entirely fair. It is perfectly fair to ask about the quality of code
generation for specific language implementations. Efficiency is a reasonable
concern - sometimes a *critical* concern such as when dealing with hard
realtime constraints.

The best answer is that there are very good, highly optimizing Ada compilers
that can produce code every bit as tight as the best C/C++ compilers for
similar programs. The caveat is that you can *only* talk about specific
compilers and targets - not about the language in general. For example, (as
observed elsewhere) the GNAT compiler and the GCC C/C++ compilers share the
same back end & generate pretty much identical code for identical programs
of different languages. Is GCC a "good" compiler for the x86 PC? Most people
think so. Hence, GNAT is going to be just as efficient - sometimes even
moreso - than C or C++ going through the GCC compiler. Are there *better*
compilers out there than GCC/GNAT? Maybe - for a given platform - and for
given algorithms/applications - and some of them will compile Ada while
other compile C or C++ or Fortran or who knows what. If efficiency is a
critical concern, the only hope is to conduct timing studies comparing
different implementations for the problems at hand. If efficiency is just a
casual concern, then rest asured that there are implementations of Ada that
are Good Enough.

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


"Preben Randhol" <randhol+abuse@pvv.org> wrote in message
news:slrnae79li.oe.randhol+abuse@kiuk0156.chembio.ntnu.no...
> On Thu, 16 May 2002 13:25:22 +0200, David Rasmussen wrote:
> >
> > I mean how good is the generated machine code on various CPU's (x86 for
> > instance) with typical Ada compilers as compared with typical C++
compilers?
> >
>
> Why? The important question is how good is the quality of the software
> produced with Ada compared to C++.
>

Re: Ada Compilers

[Preben Randhol]

On Thu, 16 May 2002 09:30:09 -0400, Marin David Condic wrote:
> Not entirely fair. It is perfectly fair to ask about the quality of code
> generation for specific language implementations. Efficiency is a reasonable
> concern - sometimes a *critical* concern such as when dealing with hard
> realtime constraints.

Yes, read my followup that explains why I asked.

Preben

Re: Ada Compilers

[Pascal Obry]

Preben Randhol <randhol+abuse@pvv.org> writes:

> On Wed, 15 May 2002 20:55:30 +0200, David Rasmussen wrote:
> > What is the best free Ada compiler available?
> 
> GNAT
> 
> available for Linux, Solaris, Windows, MacOS (there is a port worked on
> by individuals)
> 
> GNAT will also be part of GCC.
       ^^^^^^^^^^^^
       is 

GCC 3.1 has been released yesterday :)

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Ted Dennison]

Pascal Obry <p.obry@wanadoo.fr> wrote in message news:<uvg9ot481.fsf@wanadoo.fr>...
> Preben Randhol <randhol+abuse@pvv.org> writes:
> 
> GCC 3.1 has been released yesterday :)

Cool! Forget Morrowind, I know what I'll be playing with tonight. :-)

I forget...do we have a good official place to put precompiled binaries?

-- 
T.E.D. 
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Ada Compilers

[Pascal Obry]

dennison@telepath.com (Ted Dennison) writes:

> I forget...do we have a good official place to put precompiled binaries?

What about AdaPower (http://www.adapower.com/) ? We already have pages for
Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[Simon Wright]

Pascal Obry <p.obry@wanadoo.fr> writes:

> What about AdaPower (http://www.adapower.com/) ? We already have pages for
> Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?

I don't think 5.0 is right?, gnatls -v now says

  GNATLS 3.1 (20020501) Copyright 1997-2001 Free Software Foundation, Inc.

(don't know why the (c) date hasn't changed!)

I think the original 3.1 is so long ago that no one is going to care a
lot about the overloading. Or was it 3.01?!

Re: Ada Compilers

[Pascal Obry]

Simon Wright <simon@pushface.org> writes:

> Pascal Obry <p.obry@wanadoo.fr> writes:
> 
> > What about AdaPower (http://www.adapower.com/) ? We already have pages for
> > Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?
> 
> I don't think 5.0 is right?, gnatls -v now says
> 
>   GNATLS 3.1 (20020501) Copyright 1997-2001 Free Software Foundation, Inc.

Right, I was confused, this is GNAT 3.1 on the FSF GCC tree.

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|         http://perso.wanadoo.fr/pascal.obry
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver wwwkeys.pgp.net --recv-key C1082595

Re: Ada Compilers

[David Botton]

I would be happy to host any binaries. Please e-mail me directly when any
one is ready to upload and I will give them directions and make the page
available.

David Botton


"Pascal Obry" <p.obry@wanadoo.fr> wrote in message
news:ur8kau4gc.fsf@wanadoo.fr...
>
> dennison@telepath.com (Ted Dennison) writes:
>
> > I forget...do we have a good official place to put precompiled binaries?
>
> What about AdaPower (http://www.adapower.com/) ? We already have pages for
> Linux and Machintosh, what about a new section about GNAT 5.0 binaries ?
>
> Pascal.

Re: Ada Compilers

[Preben Randhol]

On 17 May 2002 08:11:53 -0700, Ted Dennison wrote:
> Pascal Obry <p.obry@wanadoo.fr> wrote in message news:<uvg9ot481.fsf@wanadoo.fr>...
>> Preben Randhol <randhol+abuse@pvv.org> writes:
>> 
>> GCC 3.1 has been released yesterday :)

Oh, I didn't say this. I didn't know this at all.

Preben

Re: Ada Compilers

[Jerry van Dijk]

dennison@telepath.com (Ted Dennison) writes:

> I forget...do we have a good official place to put precompiled binaries?

Yes, it's now part of the mingw project on sourceforge.

-- 
--  Jerry van Dijk   | email: jvandyk@attglobal.net
--  Leiden, Holland  | web:   users.ncrvnet.nl/gmvdijk

Re: Ada Compilers

[Ted Dennison]

Jerry van Dijk <jvandyk@attglobal.net> wrote in message news:<wk3cwpviph.fsf@attglobal.net>...
> dennison@telepath.com (Ted Dennison) writes:
> 
> > I forget...do we have a good official place to put precompiled binaries?
> 
> Yes, it's now part of the mingw project on sourceforge.

But that's only for Win32 precompiled binaries. Even if every platform
has its own official place for precompiled binaries, I'd think it
would be good for the Ada community to have one place where they are
all mirrored, no?

I know David has kindly offered his site up, so that's a good option.

To my mind, the most logical place would be on the GNUAda website
(http://www.gnuada.org/ ). Is that not the kind of thing it was
created for?


-- 
T.E.D.
Home     -  mailto:dennison@telepath.com (Yahoo: Ted_Dennison)
Homepage -  http://www.telepath.com/dennison/Ted/TED.html

Re: Ada Compilers

[Jerry van Dijk]

dennison@telepath.com (Ted Dennison) writes:

> > Yes, it's now part of the mingw project on sourceforge.
> 
> But that's only for Win32 precompiled binaries. Even if every platform
> has its own official place for precompiled binaries, I'd think it
> would be good for the Ada community to have one place where they are
> all mirrored, no?

The mingw project is the only place to get the properly patched native Win32
binaries. A link should be easy :-) As I said before, the real issue is the 
Win32 support (binding, tools) and things like the debugger and packaging.

-- 
--  Jerry van Dijk   | email: jvandyk@attglobal.net
--  Leiden, Holland  | web:   users.ncrvnet.nl/gmvdijk