fix thinko

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@15719 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 94 insertions, 84 deletions

diff --git a/gcc/cp/NEWS b/gcc/cp/NEWS
index fb3ac05b84b..38fd5289d86 100644
--- a/gcc/cp/NEWS
+++ b/gcc/cp/NEWS
@@ -1,22 +1,107 @@
 *** Changes since G++ version 2.7.2:
 
-* A public review copy of the December 1996 Draft of the ANSI C++
+* A public review copy of the December 1996 Draft of the ANSI/ISO C++
   proto-standard is now available. See
 
 	http://www.cygnus.com/misc/wp/
 
   for more information.
 
-* Member function templates are now supported.
+* g++ now uses a new implementation of templates. The basic idea is that
+  now templates are minimally parsed when seen and then expanded later.
+  This allows conformant early name binding and instantiation controls,
+  since instantiations no longer have to go through the parser.
+
+  What you get:
+
+     + Inlining of template functions works without any extra effort or
+       modifications.
+
+     + Instantiations of class templates and methods defined in the class
+       body are deferred until they are actually needed (unless
+       -fexternal-templates is specified).
+
+     + Nested types in class templates work.
+
+     + Static data member templates work.
+
+     + Member function templates are now supported.
+
+     + Partial specialization of class templates is now supported.
+
+     + The new 'template <>' specialization syntax is now accepted and
+       ignored.
+
+     + Explicit instantiation of template constructors and destructors is
+       now supported. Use the following source code, as an example.
+
+       template A<int>::A(const A&);
+
+  Possible problems (caused by complying with the ANSI/ISO draft):
+
+     + Types and class templates used in templates must be declared
+       first, or the compiler will assume they are not types, and fail.
+
+     + Similarly, nested types of template type parameters must be tagged
+       with the 'typename' keyword.  In many cases, the compiler will tell
+       you where you need to add 'typename'.
+
+     + Syntax errors in templates that are never instantiated will now be
+       diagnosed.
+
+  Other features:
+
+     + Default function arguments in templates will not be evaluated (or
+       checked for semantic validity) unless they are needed.  Default
+       arguments in class bodies will not be parsed until the class
+       definition is complete.
+
+     + The -ftemplate-depth-NN flag can be used to increase the maximum
+       recursive template instantiation depth, defaulting to 17. If you need
+       to use this flag, the compiler will tell you.
+
+  Still not supported:
+
+     + Template template parameters.
+
+* Exception handling support has been significantly improved and is on by
+  default.  This can result in significant runtime overhead.  You can turn
+  it off with -fno-exceptions.
+
+* Synthesized methods are now emitted in any translation units that need
+  an out-of-line copy. They are no longer affected by #pragma interface
+  or #pragma implementation.
+
+* On ELF systems, duplicate copies of symbols with 'initialized common'
+  linkage (such as template instantiations, vtables, and extern inlines)
+  will now be discarded by the GNU linker, so you don't need to use -frepo.
+  This support requires GNU ld from binutils 2.8 or later.
 
 * __FUNCTION__ and __PRETTY_FUNCTION__ are now treated as variables by the
   parser; previously they were treated as string constants.  So code like
   `printf (__FUNCTION__ ": foo")' must be rewritten to 
   `printf ("%s: foo", __FUNCTION__)'.  This is necessary for templates.
 
-* New flags -Wsign-promo (warn about potentially confusing promotions in
-  overload resolution), -Wno-pmf-conversion (don't warn about converting
-  from a bound member function pointer to function pointer).
+* New flags:
+
+     + New flags -Wsign-promo (warn about potentially confusing promotions
+       in overload resolution), -Wno-pmf-conversion (don't warn about
+       converting from a bound member function pointer to function pointer).
+
+     + A flag -Weffc++ has been added for violations of some of the style 
+       guidelines in Scott Meyers' _Effective C++_ books.
+
+     + -Woverloaded-virtual now warns if a virtual function in a base
+       class is hidden in a derived class, rather than warning about
+       virtual functions being overloaded (even if all of the inherited
+       signatures are overridden) as it did before.
+
+     + -Wall no longer implies -W.  The new warning flag, -Wsign-compare,
+        included in -Wall, warns about dangerous comparisons of signed and
+        unsigned values. Only the flag is new; it was previously part of
+        -W.
+
+     + The new flag, -fno-weak, disables the use of weak symbols.
 
 * local static variables in extern inline functions will be shared between
   translation units.
@@ -25,15 +110,11 @@
   as an alias for global scope.  General namespaces are still not supported.
 
 * -fvtable-thunks is supported for all targets, and is the default for 
-  Linux with glibc (libc 6 on x86).
+  Linux with glibc 2.x (also called libc 6.x).
 
-* Default function arguments in templates will not be evaluated (or
-  checked for semantic validity) unless they are needed.  Default arguments
-  in class bodies will not be parsed until the class definition is complete.
-
-* The -ftemplate-depth-NN flag can be used to increase the maximum
-  recursive template instantiation depth, defaulting to 17. If you need
-  to use this flag, the compiler will tell you.
+* RTTI support has been rewritten to work properly and is now on by default.
+  This means code that uses virtual functions will have a modest space
+  overhead.  You can use the -fno-rtti flag to disable RTTI support.
 
 * The internal interface between RTTI-using code and the RTTI support
   library has changed, so code that uses dynamic_cast should be
@@ -48,16 +129,6 @@
 
 * new (nothrow) is now supported.
 
-* A flag -Weffc++ has been added for violations of some of the style 
-  guidelines in Scott Meyers' _Effective C++_ books.
-
-* On ELF systems, duplicate copies of symbols with 'initialized common'
-  linkage (such as template instantiations, vtables, and extern inlines)
-  will now be discarded by the GNU linker, so you don't need to use -frepo.
-  This support requires GNU ld from binutils 2.8 or later.
-
-* Partial specialization of class templates is now supported.
-
 * The overload resolution code has been rewritten to conform to the latest
   C++ Working Paper.  Built-in operators are now considered as candidates
   in operator overload resolution.  Function template overloading chooses
@@ -66,10 +137,6 @@
   still be selected with -fno-ansi-overloading, although this is not
   supported and will be removed in a future release.
 
-* RTTI support has been rewritten to work properly and is now on by default.
-  This means code that uses virtual functions will have a modest space
-  overhead.  You can use the -fno-rtti flag to disable RTTI support.
-
 * Synthesized destructors are no longer made virtual just because the class
   already has virtual functions, only if they override a virtual destructor
   in a base class.  The compiler will warn if this affects your code.
@@ -81,68 +148,16 @@
   <stddef.h> is now defined as __null, a magic constant of type (void *)
   normally, or (size_t) with -ansi.
 
-* The new 'template <>' specialization syntax is now accepted and ignored.
-
 * The name of a class is now implicitly declared in its own scope; A::A
   refers to A.
 
-* g++ now uses a new implementation of templates. The basic idea is that
-  now templates are minimally parsed when seen and then expanded later.
-  This allows conformant early name binding and instantiation controls,
-  since instantiations no longer have to go through the parser.
-
-  What you get:
-
-     + Inlining of template functions works without any extra effort or
-       modifications.
-     + Instantiations of class templates and methods defined in the class
-       body are deferred until they are actually needed (unless
-       -fexternal-templates is specified).
-     + Nested types in class templates work.
-     + Static data member templates work.
-
-  Possible problems:
-
-     + Types and class templates used in templates must be declared
-       first, or the compiler will assume they are not types, and fail.
-     + Similarly, nested types of template type parameters must be tagged
-       with the 'typename' keyword.  In many cases, the compiler will tell
-       you where you need to add 'typename'.
-     + Syntax errors in templates that are never instantiated will now be
-       diagnosed.
-
-  Still not supported:
-
-     + Member class templates.
-     + Template template parameters.
-
-* Synthesized methods are now emitted in any translation units that need
-  an out-of-line copy. They are no longer affected by #pragma interface
-  or #pragma implementation.
-
 * Local classes are now supported.
 
-* -Wall no longer implies -W.
-  The new warning flag, -Wsign-compare, included in -Wall, warns about
-  dangerous comparisons of signed and unsigned values. Only the flag is
-  new; it was previously part of -W.
-
-* The new flag, -fno-weak, disables the use of weak symbols.
-
 * __attribute__ can now be attached to types as well as declarations.
 
-* -Woverloaded-virtual now warns if a virtual function in a base class is
-  hidden in a derived class, rather than warning about virtual functions
-  being overloaded (even if all of the inherited signatures are
-  overridden) as it did before.
-
 * The compiler no longer emits a warning if an ellipsis is used as a
   function's argument list.
 
-* Exception handling support has been significantly improved and is on by
-  default.  This can result in significant runtime overhead.  You can turn
-  it off with -fno-exceptions.
-
 * Definition of nested types outside of their containing class is now
   supported. Use the following source code, as an example.
 
@@ -155,11 +170,6 @@
               int member;
        };
 
-* Explicit instantiation of template constructors and destructors is now
-  supported. Use the following source code, as an example.
-
-       template A<int>::A(const A&);
-
 * On the HPPA, some classes that do not define a copy constructor
   will be passed and returned in memory again so that functions
   returning those types can be inlined.