"Jim Barry" <jim.barry@bigfoot.com> writes:

>Thanks for the insight. I imagine that the compiler vendors would also
>have been quite nervous at the prospect of a public domain compiler
>that was 100% conformant!

Quite the contrary. As a compiler implementor, I'd be delighted
to get a pefect compiler for free. It would make available the
programmers who are now working on an imperfect compiler to add
value to the free compiler. I'd have a better overall product
suite at lower cost.

--
Steve Clamage, stephen.clamage@sun.com


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Bjarne Stroustrup:
>
>The committee didn't test the standard on a real compiler because
none could
>exist before the standard that defined it. Most features were tested
on a
>variety of compilers. However, the C++ compiler vendors were not
willing
>to commit resources for a complete implementation until a standard
existed.
>This is a classic chicken and egg problem (with added economic
twists).

Thanks for the insight. I imagine that the compiler vendors would also
have been quite nervous at the prospect of a public domain compiler
that was 100% conformant!

--
Jim Barry, Thermoteknix Systems Ltd., Cambridge, UK.
http://www.thermoteknix.co.uk - Queen's Award for Export 1998
http://www.geocities.com/SiliconValley/2060
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

James Kanze:
>Jim Barry:
>> What were the committee's thoughts on creating a reference
>> implementation?
>
>Probably that it wouldn't be of much use.  The fact that a given
program
>has one result on a reference implementation and another on another
>implementation doesn't tell you anything either about the program or
>about the other implementation.

The reason I asked was that I wondered about the dangers of having an
inventive committee lacking the proper means with which to test their
creation.

--
Jim Barry, Thermoteknix Systems Ltd., Cambridge, UK.
http://www.thermoteknix.co.uk - Queen's Award for Export 1998
http://www.geocities.com/SiliconValley/2060
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <newscache$ew30bf$oqe$1@firewall.thermoteknix.co.uk> "Jim Barry" <jim.barry@bigfoot.com> writes:
>Francis Glassborow wrote
>>Ryszard Kabatek writes
>>>Did the ANSI/ISO comitee not test the standard on a real compiler?
>>
>>No :)

Parts were definitely "tested" on various real compilers first.
All of it could not possibly have been done so though.
This is practical and reasonable.

>What were the committee's thoughts on creating a reference
>implementation?

In short, the thoughts were that if we could we should.  And in short,
we couldn't.  Do realize that the committee functions ONLY through (unpaid)
volunteers.

- Greg
--
       Comeau Computing, 91-34 120th Street, Richmond Hill, NY, 11418-3214
     Producers of Comeau C/C++ 4.2.38 -- New Release!  We now do Windows too.
    Email: comeau@comeaucomputing.com / Voice:718-945-0009 / Fax:718-441-2310
                *** WEB: http://www.comeaucomputing.com ***


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <7gmq0l$30v$1@news3.Belgium.EU.net>,
  "Piet Van Vlierberghe" <pieter.vanvlierberghe@@.lms.be.notrash> wrote:
>
> James.Kanze@dresdner-bank.com wrote in message
> >More interesting might have been a reference test suite: if an
> >implementation passes, of course, it doesn't tell you anything, but if
> >it fails, at least you know that the implementation is either
> >non-conforming, or has some pretty low implementation limits.  Of
> >course, a reasonable test suite is probably ten times more work that a
> >compiler -- I haven't heard of any volontiers yet.
>
> The discussion about compliance winds in odd directions:
>
> - Is no validation better than incomplete validation? Probably not.
>
> - Does a mediocre test suite require 10 times the effort to write a
> compiler? Probably not.
>
> So maybe we will never have a test suite that guarantees that a compiler
> passing the test is in fact conforming, since proof by example is impossible
> in this context. As has been stated over and over again in this thread, we
> will never have a conforming compiler either. So why even argue about it?
>
> A test suite that would point out that certain compilers are non-compliant,
> is the best we can ever hope for.

We can't even hope for that.  It is trivial to write a program which is
strictly conforming, but no compiler will compile.  (I'd guess that a
nesting of a couple of million (...) would do the trick.)

The question (as I understand it) is about an "official" validation
suite. Because of things like environment limits, I don't believe that
ISO, as such, can produce one; a test suite will never prove a compiler
compliant, nor non-compliant, from a legalistic (standards) point of
view.

Of course, we really don't care about such a strictly legalistic point
of view.  The typical examples we want to test are small enough that if
they violate any resources limit of the compiler, the compiler is
useless (even though conforming) anyway.  Such validation suites cannot
come from ISO, but commercial enterprises can, and do provide them.  As
such, they are extremely valuable.

--
James Kanze                         mailto: James.Kanze@dresdner-bank.com
Conseils en informatique orient   e objet/
                        Beratung in objekt orientierter Datenverarbeitung
Ziegelh   ttenweg 17a, 60598 Frankfurt, Germany  Tel. +49 (069) 63 19 86 27

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

superdude <me@web1.ucar.edu> writes:

>I was a little bit hasty in my previous post stating that only exported
>templates is lacking in BCB4. Yesterday I found that "try" is not recognized
>in the initialization list, e.g.

The construct is called a "function try-block".

>SomeClass::SomeClass(/* whatever */)
>try
>:Var1(/*whatever*/) , ...
>{
>  ...
>}
>catch(/*whatever*/) { ... }
>But I haven't seen a compiler yet that does accept this syntax. Does anybody
>know one?

Sun C++ (Visual Workshop C++ 5.0).

--
Steve Clamage, stephen.clamage@sun.com
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <3727A620.B6A48D80@wizard.net>,
  James Kuyper <kuyper@wizard.net> wrote:
> gbush@my-dejanews.com wrote:
> ....
> > > generate warnings everytime I had a logical mistake in my program.
> >
> > No this is not a task of compiler, it's a task of programmer.
>
> Well-designed languages allow many (not all!) logical mistakes to be
> detected as syntax errors.

Even not so well designed languages allow a certain number of logical
mistakes to be detected, and no language prevents the compiler from
generating a warning.

But in this case, gbush is quoting out of context.  I specifically said
"An ideal compiler would ..."  An ideal compiler would find all of my
logical errors.  (But I also pointed out that such an ideal compiler
doesn't exist, and isn't likely to exist anytime soon.)

--
James Kanze                         mailto: James.Kanze@dresdner-bank.com
Conseils en informatique orient   e objet/
                        Beratung in objekt orientierter Datenverarbeitung
Ziegelh   ttenweg 17a, 60598 Frankfurt, Germany  Tel. +49 (069) 63 19 86 27

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <7g7kvg$ka6$1@nnrp1.dejanews.com>,
  gbush@my-dejanews.com wrote:
>
> In article <7g6rl7$sij$1@nnrp1.dejanews.com>,
>   James.Kanze@dresdner-bank.com wrote:
> > As Steve Clamage has pointed out, conformance is only one parameter.
>
> Yes, but it's one of (if not the) most important parameters.

Really.  In my book, the most important parameter (by far) is
correctness.  What's the point in carefully writing a program if the
compiler is going to generate random code for it.  (Note that my
customers often have "Konventionelstrafe" for program failures -- I
don't know the English word, but it is something like a fine if the
program fails to perform as specified.  IMHO, this should be standard
practice for all software -- if there is a bug in the compiler, you get
a rebate.)

After that, I guess I'd place backwards compatibility -- if I have to
spend a year rewriting my existing code, then that's a year that I can't
spend writing new code.  Not to mention that my customers (or rather my
customers' customers) aren't ready to pay for that kind of activity.

Performance is a relative parameter.  In my applications, 10% more or
less doesn't make a difference.  If the application runs 3 to 5 times
slower, however, it would.  At that level, even performance would be
more important than conformance.

--
James Kanze                         mailto: James.Kanze@dresdner-bank.com
Conseils en informatique orient   e objet/
                        Beratung in objekt orientierter Datenverarbeitung
Ziegelh   ttenweg 17a, 60598 Frankfurt, Germany  Tel. +49 (069) 63 19 86 27

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

> >But I haven't seen a compiler yet that does accept this syntax. Does anybody
> >know one?
>
> Sun C++ (Visual Workshop C++ 5.0).
>
I just tried SC 5.0 and it couldn't compile this code. Below is the error
message:
"test14.cpp", line 37: Error: "{" expected instead of "try".

Gene.

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <37258E90.7ACEFDFD@rumcajs.chemie.uni-halle.de>, Ryszard
Kabatek <rysio@rumcajs.chemie.uni-halle.de> writes
>Did the ANSI/ISO comitee not test the standard on a real compiler?

No :)

Francis Glassborow      Journal Editor, Association of C & C++ Users
64 Southfield Rd
Oxford OX4 1PA          +44(0)1865 246490
All opinions are mine and do not represent those of any organisation


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Ok, since there are many people replied to my previous post, I decided to
give a collective answer to save time. 1) "Old" code. This seems to be the
main argument in your posts. Now, do you mean that existing compilers will
always be non-conforming in order to support this "old" code? Of course, not.
It's only a matter of time when that code starts breaking. So fix it, as soon
as possible. My experience shows, that if one knows his/her product it's not
hard to make such changes. Unfortunately, I've seen too many programs, that
look like a lump of spaghetti. If they are expected to last long enough,
they'd better be re-designed rather than fixing errors in them, because it's
not a program with errors, it one big error. And as I said, you always can
use old compilers that your code was developed with. Finally, an short
excerpt from Bjarne Stroustrup's "The C++ Programming Language": "where
innovation is needed, senior technical people, analyst, designers,
programmers, etc., have a critical and difficult role to play in the
introduction of new techniques. These are the people who must learn the new
techniques and in many cases unlearn old habits... Naturally, there is often
a fear of change among such individuals. This can lead to an overestimation
of the problems involved in a change and a reluctance to acknowledge problems
with the old way of doing things..." 2) What do I do when some platforms do
not have a "good" compiler? In many cases I find gcc on such platforms to be
much better choice. I try to explain to customers that they may need to
re-evaluate their reasons of using that particular platform. For example,
this year we are dropping 2 platforms that I will leave unnamed and adding 2
others. And, yes, I basically have, 3 versions of my product, and not all
functionality available on all of them, with PC version being the most rich
in functionality. If we could completely drop the other platforms, the cost
of development could be reduced significantly. So as soon as producing code
for these "troublesome" platforms becomes economically unprofitable, they
will be gone, and my headaches also. I think compiler vendors need to think
whether they are killing their platforms by not providing good development
tools.

Gene.

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

gbush@my-dejanews.com writes:
>
> "Old" code. This seems to be the main argument in your posts. Now,
> do you mean that existing compilers will always be non-conforming in
> order to support this "old" code? Of course, not.  It's only a
> matter of time when that code starts breaking.

This is true, it is a matter of time. But it is more likely a matter
of years than a matter of months.

> if one knows his/her product it's not hard to make such changes.

This is probably where you are making an unwarranted
generalization. If ONE knows HIS product! This statement is a strong
indication that you have been exposed primarily to relatively small
projects, projects suitable for a single person, or perhaps a small
group of developers. But there are other systems.

> they'd better be re-designed rather than fixing errors in them,

Again, this indicates that you are not familiar with huge
mission-critical systems used at the enterpise-level. A major bank
simply doesn't redesign their banking system from scratch every
year. This is simply not in the cards. At that scale change must occur
evolutionary, step by step.

> because it's not a program with errors, it one big error.

We are talking about upgrading pre-ISO C++ code to ISO C++. We are NOT
talking about fixing errors here.

> And as I said, you always can use old compilers that your code was
> developed with.

In the case of large systems you want to convert gradually, one
subsystem at a time, starting with new modules. This requires at least
link-compatibility, in practise you want one compiler to compile the
whole system.

Joachim

--
joachim@kraut.bc.ca      (http://www.kraut.bc.ca)
joachim@mercury.bc.ca    (http://www.mercury.bc.ca)


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <JqdV2.37$ZU2.389@news1.online.no>,
  Roy Brokvam <roy.brokvam@conax.com> wrote:
>
> gcc 2.8.1 accepts it.
>

I tried gcc 2.8.1 and it also has problems. It will compile the code below
only if you comment "#define inlined". Plus many exceptions for some reason
escape catch block. Gene
------------------------example------------------------------------------
#ifdef __GNUG__ #include <iostream> #else #include <iostream.h> #endif

//#define inlined

class B
{
public:
  B(int k=0) { if(k) throw "hello";};
};


class A:B
{
  public:
  int i;
  A(int k=0)
#ifdef inlined
   try
   :i(k)
   {
       i=k;

   }
   catch(...)
   {
     std::cout<<"ERROR"<<endl;
   }
#endif
   ;
};
#ifndef inlined
  A::A(int k)
   try
   :B(k),i(1/k)
   {   }
   catch(...)
   {
     std::cout<<"ERROR"<<endl;
   }
#endif

int main(int argc, char* argv[])
{

  A a1(1);
  A a2; // gcc doesn't "catch" Arithmetic Exception
  return 0;
}

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Francis Glassborow wrote
>Ryszard Kabatek writes
>>Did the ANSI/ISO comitee not test the standard on a real compiler?
>
>No :)

What were the committee's thoughts on creating a reference
implementation?

--
Jim Barry, Thermoteknix Systems Ltd., Cambridge, UK.
http://www.thermoteknix.co.uk - Queen's Award for Export 1998
http://www.geocities.com/SiliconValley/2060
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Jim Barry wrote:
>
> Francis Glassborow wrote
> >Ryszard Kabatek writes
> >>Did the ANSI/ISO comitee not test the standard on a real compiler?
> >
> >No :)
>
> What were the committee's thoughts on creating a reference
> implementation?

I am sure you will give your time and work (and eventually pay a
fee to do that) to ISO in order to write such an implementation.

--

Valentin Bonnard
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <newscache$ew30bf$oqe$1@firewall.thermoteknix.co.uk>,
  "Jim Barry" <jim.barry@bigfoot.com> wrote:
> Francis Glassborow wrote
> >Ryszard Kabatek writes
> >>Did the ANSI/ISO comitee not test the standard on a real compiler?
> >
> >No :)
>
> What were the committee's thoughts on creating a reference
> implementation?

Probably that it wouldn't be of much use.  The fact that a given program
has one result on a reference implementation and another on another
implementation doesn't tell you anything either about the program or
about the other implementation.

More interesting might have been a reference test suite: if an
implementation passes, of course, it doesn't tell you anything, but if
it fails, at least you know that the implementation is either
non-conforming, or has some pretty low implementation limits.  Of
course, a reasonable test suite is probably ten times more work that a
compiler -- I haven't heard of any volontiers yet.

--
James Kanze                         mailto: James.Kanze@dresdner-bank.com
Conseils en informatique orientie objet/
                        Beratung in objekt orientierter Datenverarbeitung
Ziegelh|ttenweg 17a, 60598 Frankfurt, Germany  Tel. +49 (069) 63 19 86 27

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

James.Kanze@dresdner-bank.com wrote:
>
> In article <newscache$ew30bf$oqe$1@firewall.thermoteknix.co.uk>,
>   "Jim Barry" <jim.barry@bigfoot.com> wrote:

> > What were the committee's thoughts on creating a reference
> > implementation?
>
> Probably that it wouldn't be of much use.

In order to write an implementation you have to read
the standard better than what people usually do, and
many problems are found that way.

But then simple proof reading is probably way more
cost-effective than writing an implementation.

Anyway: compiler writers write compilers, it isn't
really the job of the committee. By producing (or not)
compiler which try to conform, compilers (and library)
writers can speed up standardization.

--

Valentin Bonnard
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <newscache$ew30bf$oqe$1@firewall.thermoteknix.co.uk>, Jim
Barry <jim.barry@bigfoot.com> writes
>Francis Glassborow wrote
>>Ryszard Kabatek writes
>>>Did the ANSI/ISO comitee not test the standard on a real compiler?
>>
>>No :)
>
>What were the committee's thoughts on creating a reference
>implementation?

I do not think we ever had time to even think of doing such a mammoth
task.

Francis Glassborow      Journal Editor, Association of C & C++ Users
64 Southfield Rd
Oxford OX4 1PA          +44(0)1865 246490
All opinions are mine and do not represent those of any organisation
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

James.Kanze@dresdner-bank.com wrote in message
>More interesting might have been a reference test suite: if an
>implementation passes, of course, it doesn't tell you anything, but if
>it fails, at least you know that the implementation is either
>non-conforming, or has some pretty low implementation limits.  Of
>course, a reasonable test suite is probably ten times more work that a
>compiler -- I haven't heard of any volontiers yet.

The discussion about compliance winds in odd directions:

- Is no validation better than incomplete validation? Probably not.

- Does a mediocre test suite require 10 times the effort to write a
compiler? Probably not.

So maybe we will never have a test suite that guarantees that a compiler
passing the test is in fact conforming, since proof by example is impossible
in this context. As has been stated over and over again in this thread, we
will never have a conforming compiler either. So why even argue about it?

A test suite that would point out that certain compilers are non-compliant,
is the best we can ever hope for.

In this newsgroup, I have seen lots of code samples that have known behavior
for a compliant compiler. If we would only bundle all examples from the
standard, together with the samples found in this newsgroup, we would
already have a test suite that would probably flunk all existing C++
compilers.

Here's a "bazaar" thought:
Obviously, to allow for continuous improvement, such a test suite should be
open. This way, any one can submit test cases to a committee (e.g. this
newsgroup 8^), and e.g. the moderator (sorry!) could add the sample to the
test suite.



[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <MPG.118f99b892d045ca98991e@news.mindspring.com>,
  brahms@mindspring.com (Stan Brown) wrote:
>
> Dixitque ark@research.att.com (Andrew Koenig) in comp.std.c++:
> >a major part of any true measure of
> >performance must include the vendor's attitude.  The main question
> >is whether the vendor considers deviations from the standard to be
> >bugs that the vendor is willing to fix.
>
> Exactly so! "The vendor's attitude" is critical, and I don't think I've
> seen it stated explicitly before.
>
> >By that measure, a compiler that has deliberately missing features
> >is not conforming, because the vendor does not intend to make it so.
>
> I would go further and say that one that has significant bugs in
> implemented features, extending over more than one major version, is also
> ample evidence that the vendor does not care about conformance (at least
> in that area).

As Steve Clamage has pointed out, conformance is only one parameter.
The ideal compiler would be perfectly conformant, contain no errors,
generate optimal code, compile all my old, pre-standard code, and
generate warnings everytime I had a logical mistake in my program.
Since the ideal compiler will not be available anytime soon, however,
the vendor has to compromize.

I'll settle for correction of bugs in features documented as fully
implemented and functional, and a commitment to try and implement all of
the features some time in the future.  On the condition, of course, that
I don't have to wait nearly as long as I would for the ideal compiler.

--
James Kanze                         mailto: James.Kanze@dresdner-bank.com
Conseils en informatique orient   e objet/
                        Beratung in objekt orientierter Datenverarbeitung
Ziegelh   ttenweg 17a, 60598 Frankfurt, Germany  Tel. +49 (069) 63 19 86 27

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <7g6rl7$sij$1@nnrp1.dejanews.com>,
  James.Kanze@dresdner-bank.com wrote:
> As Steve Clamage has pointed out, conformance is only one parameter.

Yes, but it's one of (if not the) most important parameters. I want to write
my programs once and be able to compile it on every platform I'm working, not
five programs for each platform and then support 5 products instead of one.
What can be worst than writing a piece of code that you know doesn't conform
to standard and inevitably will have to be changed. What can you do if you
need exception handling but some lousy compiler does it wrong, do you cripple
your program for other platforms or drop that platform? I have to perform
multiple compilations with every change I introduce into my product because
most compilers are so weak that you never know what to expect. I frankly,
don't care if a new version of compiler is 10% faster then a previous
version, this is just a noise, but I do care whether a new version is
conforming to the standard. And I see some vendors like Inprise are taking
this concerns seriously, while others don't really care.

> The ideal compiler would be perfectly conformant, contain no errors,
> generate optimal code, compile all my old, pre-standard code, and

No conforming compiler doesn't have to compile "old, pre-standard code." If
this "old" code is a violation of standard, conforming compiler must reject
it. You may have a need for that, and some vendors can address that need. Or
you may choose to use older compiler for legacy applications till you fix the
errors in them.

> generate warnings everytime I had a logical mistake in my program.

No this is not a task of compiler, it's a task of programmer.

Gene Bushuyev.

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Did the ANSI/ISO comitee not test the standard on a real compiler?

--
Ryszard Kabatek
Martin-Luther University Halle-Wittenberg, Department of Physical
Chemistry
Geusaer Str. 88, 06217 Merseburg, Germany
Tel. +49 3461 46 2487 Fax. +49 3461 46 2129
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

gbush@my-dejanews.com wrote:
....
> > generate warnings everytime I had a logical mistake in my program.
>
> No this is not a task of compiler, it's a task of programmer.

Well-designed languages allow many (not all!) logical mistakes to be
detected as syntax errors.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

gbush@my-dejanews.com writes:

>In article <7g6rl7$sij$1@nnrp1.dejanews.com>,
>  James.Kanze@dresdner-bank.com wrote:
>> As Steve Clamage has pointed out, conformance is only one parameter.

>Yes, but it's one of (if not the) most important parameters. I want to write
>my programs once and be able to compile it on every platform I'm working,

What do you do if a fully-conforming compiler is not available
for one of the platforms you need to support?

>What can be worst than writing a piece of code that you know doesn't conform
>to standard and inevitably will have to be changed.

Having standard-conforming code you can't compile because you don't
have a standard-conforming compiler.

>> The ideal compiler would be perfectly conformant, contain no errors,
>> generate optimal code, compile all my old, pre-standard code, and

>No conforming compiler doesn't have to compile "old, pre-standard code."

But what about the transition period? Consider huge applications,
many millions of lines of code, developed by large teams in
different locations, targeted to a variety of completely different
platforms. If on platform A you have only a fully standard-compliant
compiler that will not accept old code and on platform B you have
only a pre-standard compiler that does not recognize new syntax or
use new semantics, you cannot share code.

A vendor sensitive to the needs of such users will provide a
transition path: accept old code as an option, and provide warnings
about language changes.

At some point all compilers will be (nearly) standard-conforming.
Then you can bring your existing code up to the standard and
expect to compile it (nearly) everywhere. That is, after all,
the point of having a standard. You can pretty much do that with
C now, because the C standard has been around for 10 years, and
standard-conforming compilers are widely available. The C++
standard is too new, and wide availability of standard C++ compilers
is still a few years away.

--
Steve Clamage, stephen.clamage@sun.com
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

gbush@my-dejanews.com writes:
>
> James.Kanze@dresdner-bank.com wrote:
> > As Steve Clamage has pointed out, conformance is only one parameter.
>
> Yes, but it's one of (if not the) most important parameters.

One must be careful when generalizing from one's own needs and
requirements to those of others. If you are the compiler maintainer's
only customer, then given your stated preferences the maintainer would
be well advised to concentrate on conformance issues.

> > The ideal compiler would be perfectly conformant, contain no errors,
> > generate optimal code, compile all my old, pre-standard code, and
>
> No conforming compiler doesn't have to compile "old, pre-standard
> code." If this "old" code is a violation of standard, conforming
> compiler must reject it. You may have a need for that, and some
> vendors can address that need. Or you may choose to use older
> compiler for legacy applications till you fix the errors in them.

It is obvious from your statements that you are not dealing with a
large amount of existing source code, which is fine. Do understand,
however, that huge amounts of mission-critical older C++ code exist
and must be maintained. "Fixing the errors in them" as you put it
cannot be achieved overnight, and perhaps more importanly, it may not
be easy to find a budget for a major project whose only purpose is to
fix things that work.

Don't get me wrong, I want to use a conforming compiler too. But we
must realize that the people maintaining the compiler are faced with
many conflicting requirements, which are resolved taking into account
the needs of many users, not just you or me.

Joachim

--
joachim@kraut.bc.ca      (http://www.kraut.bc.ca)
joachim@mercury.bc.ca    (http://www.mercury.bc.ca)
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

superdude wrote in message <0e72a5256231949CPIMSSMTPU07@email.msn.com>...

[snip]

>... Yesterday I found that "try" is not recognized
>in the initialization list, e.g.
>SomeClass::SomeClass(/* whatever */)
>try
>:Var1(/*whatever*/) , ...
>{
>  ...
>}
>catch(/*whatever*/) { ... }
>But I haven't seen a compiler yet that does accept this syntax. Does
anybody
>know one?
>


gcc 2.8.1 accepts it.

[snip]


Regards,

Roy Brokvam
roy.brokvam@conax.com
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

> I noticed that you didn't mention Metrowerks CodeWarrior. :)
>
Simply because I didn't have a chance to look at it :(
I was a little bit hasty in my previous post stating that only exported
templates is lacking in BCB4. Yesterday I found that "try" is not recognized
in the initialization list, e.g.
SomeClass::SomeClass(/* whatever */)
try
:Var1(/*whatever*/) , ...
{
  ...
}
catch(/*whatever*/) { ... }
But I haven't seen a compiler yet that does accept this syntax. Does anybody
know one?

>Edison Design Group http://www.edg.com/cpp_ftrs.html lists the new
>features,  you may want to compare against that for compiler features.

Thanks, I will look  at that list. Some of the features listed there that I
could immediately recognize are implemented in BCB4. As I said before there
were some bugs in implementation. I hope they will be fixed in the next
patch, so I don't consider those features unimplemented.

Gene
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <0e72a5256231949CPIMSSMTPU07@email.msn.com>, superdude <"don't
even think about it"@chx400.switch.Ch> wrote:

> > I noticed that you didn't mention Metrowerks CodeWarrior. :)
> >
> Simply because I didn't have a chance to look at it :(
> I was a little bit hasty in my previous post stating that only exported
> templates is lacking in BCB4. Yesterday I found that "try" is not recognized
> in the initialization list, e.g.
> SomeClass::SomeClass(/* whatever */)
> try
> :Var1(/*whatever*/) , ...
> {
>   ...
> }
> catch(/*whatever*/) { ... }
> But I haven't seen a compiler yet that does accept this syntax. Does anybody
> know one?

Umm...  Metrowerks! :-)

-Howard
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Dixitque ark@research.att.com (Andrew Koenig) in comp.std.c++:
>a major part of any true measure of
>performance must include the vendor's attitude.  The main question
>is whether the vendor considers deviations from the standard to be
>bugs that the vendor is willing to fix.

Exactly so! "The vendor's attitude" is critical, and I don't think I've
seen it stated explicitly before.

>By that measure, a compiler that has deliberately missing features
>is not conforming, because the vendor does not intend to make it so.

I would go further and say that one that has significant bugs in
implemented features, extending over more than one major version, is also
ample evidence that the vendor does not care about conformance (at least
in that area).

I won't mention the _________ ______ C/C++ compiler.

--
Stan Brown, Oak Road Systems, Cleveland, Ohio, USA
                                    http://www.mindspring.com/~brahms/
My reply address is correct as is. The courtesy of providing a correct
reply address is more important to me than time spent deleting spam.


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

James.Kanze@dresdner-bank.com wrote:
...
> Strictly speaking, I doubt that there will ever be a 100% compliant
> compiler.  Given the complexity of a compiler, there will always be a
> bug in some odd corner.  (This is true even for relatively simple
> languages, like C.)
>
> So how compliant does a compiler have to be in order to be considered
> 100% compilant.  In the end, about the best you can hope for is that the
> vendor promesses to try and fix anything that proves non-compilant; that
> is, he treets non-compiance as an error.  But on one hand, almost all of
> the compiler vendors do this -- although they don't necessary give a

For most compilers, many of their failures to be fully conforming C++
implementations are due to design decisions, not to bugs. They felt that
the cost of implementating a given feature would be too high (at least
for now), and deliberately did not attempt to implement it (yet).

> time scale for the "bug fix".  And on the other, what happens if the
> compiler implementors interpretation of the standard is different from
> yours?

As a practical matter, there's a big difference between non-compliance
due to a compiler bug, and non-compliance because of a documented design
decision on the part of the vendor. Is there any implementation out
there that is making a competently implemented good-faith attempt to be
a fully conforming implementation of C++?
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

SunPro: Incorrect implementation for 6.7 in conjunction with 3.6.3:
Dependencies between global singleton instances may crash at termination.

Greetings, J   rg
--
BTW: It is normally better to answer to the group! For direct mail reply
exchange the ".A@T." by "@"





[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

After testing a number of compilers from HP, Sun, IBM, MS, g++, I came to
the conclusion that the most ANSI C++ complient compiler is new Borland C++
Builder 4. It has quite a number of bugs for sure, but except exported
templates it seemingly has all the features that are present in standard.
Having met with SUN compiler group I got an impression that they will be at
the same level only in May,2000 with Workshop 6. Others seem to be far
behind.
Gene

MW Ron <MWRon@metrowerks.com> wrote in message
news:MWRon-2104992127530001@dyn1-tnt1-195.kalamazoo.mi.ameritech.net...
> In article <7fimja$l73$1@birch.prod.itd.earthlink.net>, endh1b@right.now
> (Marcus Vinicius) wrote:
>
> >After searching through Dejanews, I was unable to find a list of
compliant
> >compilers. Does anyone know if such a list exists, particularly for the
PC?
>
> I don't think there are any 100% compliant compilers, and have doubts
> about there being any for a while but I feel Metrowerks CodeWarrior Pro 4
> is one of the most compliant compilers/libraries available.   If you'd
> like more information check CodeWarrior out at http://www.metrowerks.com
> or drop me a note if you are wondering about any specific issues.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <039851203041749CPIMSSMTPU07@email.msn.com>, "superdude"
<don't.even.think.about.it@rutgers.edu> wrote:

>After testing a number of compilers from HP, Sun, IBM, MS, g++, I came to
>the conclusion that the most ANSI C++ complient compiler is new Borland C++
>Builder 4.

I noticed that you didn't mention Metrowerks CodeWarrior. :)

Edison Design Group http://www.edg.com/cpp_ftrs.html lists the new
features,  you may want to compare against that for compiler features.

Ron

--
http://www.zdnet.com/pcweek/stories/news/0,4153,361176,00.html
Pro 4.0 C++ 30% edge in Tak benchmark over VC++ 6.0

METROWERKS                   Ron Liechty
"Software at Work"    MWRon@metrowerks.com
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

James Kuyper wrote:

> For most compilers, many of their failures to be fully conforming C++
> implementations are due to design decisions, not to bugs.

If it's not documented it's a bug, if it is, it's a feature.
Sorry I don't buy the "we decided we weren't going to implement
that" is just as bad as them saying "we found out we don't do
that right" and only slightly better that undisclosed bugs/non-
conformance.

My code is riddled with workarounds for "design decisions"
like this.  There's no excuse for it.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

>After testing a number of compilers from HP, Sun, IBM, MS, g++, I came to
>the conclusion that the most ANSI C++ complient compiler is new Borland C++
>Builder 4. It has quite a number of bugs for sure, but except exported
>templates it seemingly has all the features that are present in standard.
>Having met with SUN compiler group I got an impression that they will be at
>the same level only in May,2000 with Workshop 6. Others seem to be far
>behind.

Ditto,

Unfortunately, standard complient compilers tend to break existing
code - especially template code - previous Borland compilers were much
more permissive in what they would accept.  Not that this is
necessarily wrong, just that making the changes can be a real pain,
especailly if you need to maintain compatablity with things like VC6!

John Maddock
http://ourworld.compuserve.com/homepages/John_Maddock/


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Ron Natalie wrote:
>
> James Kuyper wrote:
>
> > For most compilers, many of their failures to be fully conforming C++
> > implementations are due to design decisions, not to bugs.
>
> If it's not documented it's a bug, if it is, it's a feature.

And if the documented feature doesn't conform to the standard, it isn't
a fully conforming implementation.

> Sorry I don't buy the "we decided we weren't going to implement
> that" is just as bad as them saying "we found out we don't do
> that right" and only slightly better that undisclosed bugs/non-
> conformance.

Nontheless, it is slightly better.

You missed my point - I was responding to a claim that we can never
expect 100% compliance, because any program as complex as a C++ compiler
will always have some bugs in it. By implication, we're supposed to be
willing to make do with a few deliberately missing features. Many of the
things I am most interested in doing revolve around precisely those
features that are most frequently left out, such as template member
functions, partial specialization of templates, and non-type template
parameters. I haven't figured out a need for template template
parameters yet, but I'm sure it will come up sooner or later.

I don't think it's unreasonable to hope for/put pressure on vendors for
an implementation which falls short of being fully conforming due solely
to a small number of unimportant bugs. All implementations I've heard of
so far have deliberately failed to implement several of the more
difficult features of the new standard.
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <7fimja$l73$1@birch.prod.itd.earthlink.net>, endh1b@right.now
(Marcus Vinicius) wrote:

>After searching through Dejanews, I was unable to find a list of compliant
>compilers. Does anyone know if such a list exists, particularly for the PC?

I don't think there are any 100% compliant compilers, and have doubts
about there being any for a while but I feel Metrowerks CodeWarrior Pro 4
is one of the most compliant compilers/libraries available.   If you'd
like more information check CodeWarrior out at http://www.metrowerks.com
or drop me a note if you are wondering about any specific issues.

Ron

--
http://www.zdnet.com/pcweek/stories/news/0,4153,361176,00.html
Pro 4.0 C++ 30% edge in Tak benchmark over VC++ 6.0

METROWERKS                   Ron Liechty
"Software at Work"    MWRon@metrowerks.com
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <MWRon-2104992127530001@dyn1-tnt1-195.kalamazoo.mi.ameritech.net>,
  MWRon@metrowerks.com (MW Ron) wrote:
> In article <7fimja$l73$1@birch.prod.itd.earthlink.net>, endh1b@right.now
> (Marcus Vinicius) wrote:
>
> >After searching through Dejanews, I was unable to find a list of compliant
> >compilers. Does anyone know if such a list exists, particularly for the PC?
>
> I don't think there are any 100% compliant compilers, and have doubts
> about there being any for a while [...]

Strictly speaking, I doubt that there will ever be a 100% compliant
compiler.  Given the complexity of a compiler, there will always be a
bug in some odd corner.  (This is true even for relatively simple
languages, like C.)

So how compliant does a compiler have to be in order to be considered
100% compilant.  In the end, about the best you can hope for is that the
vendor promesses to try and fix anything that proves non-compilant; that
is, he treets non-compiance as an error.  But on one hand, almost all of
the compiler vendors do this -- although they don't necessary give a
time scale for the "bug fix".  And on the other, what happens if the
compiler implementors interpretation of the standard is different from
yours?

--
James Kanze                         mailto: James.Kanze@dresdner-bank.com
Conseils en informatique orientie objet/
                        Beratung in objekt orientierter Datenverarbeitung
Ziegelh|ttenweg 17a, 60598 Frankfurt, Germany  Tel. +49 (069) 63 19 86 27

-----------== Posted via Deja News, The Discussion Network ==----------
http://www.dejanews.com/       Search, Read, Discuss, or Start Your Own
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

Francis Glassborow <francis@robinton.demon.co.uk> writes:

> To the best of my knowledge no such compilers currently exist (on any
> platform)

So what are the features missing in compilers that claim compliance
(i.e. IBM VisualAge and SunPro)? I'd guess (without having used the
compilers) that exported templates are rare. What else?

Martin
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

James.Kanze@dresdner-bank.com writes:

> So how compliant does a compiler have to be in order to be considered
> 100% compilant.

I like the approach that HP is taking. Originally, they announced
their compiler as ANSI C++ compiler. Now, they know that there are
missing features, and list what they are.

For me, a compiler is "compliant enough" when it compiles all my code
correctly and also lets me write the code in the way I want, as long
as it is compliant.

Unfortunately, I haven't seen such a compiler.

Regards,
Martin


[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

After searching through Dejanews, I was unable to find a list of compliant
compilers. Does anyone know if such a list exists, particularly for the PC?

John - N8086N
Wise man says "Never use a bank with the initials F. U."
-------------------------------------------
Are you interested in a professional society or
guild for programmers? Want to fight section 1706?


See www.programmersguild.org
Newsgroup: us.issues.occupations.computer-programmers


EMail Address:
_m-i-a-n-o_@_c_o_l_o_s_s_e_u_m_b_u_i_l_d_e_r_s._c_o_m_
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]

In article <7fimja$l73$1@birch.prod.itd.earthlink.net>, Marcus Vinicius
<endh1b@right.now> writes
>After searching through Dejanews, I was unable to find a list of compliant
>compilers. Does anyone know if such a list exists, particularly for the PC?

To the best of my knowledge no such compilers currently exist (on any
platform)

>

Francis Glassborow      Journal Editor, Association of C & C++ Users
64 Southfield Rd
Oxford OX4 1PA          +44(0)1865 246490
All opinions are mine and do not represent those of any organisation
---
[ comp.std.c++ is moderated.  To submit articles, try just posting with ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu    ]
[              --- Please see the FAQ before posting. ---               ]
[ FAQ: http://reality.sgi.com/austern_mti/std-c++/faq.html              ]