386b8a85a6
Sat Sep 27 16:22:48 1997 Jason Merrill <jason@yorick.cygnus.com>
* friend.c (do_friend): Disable injection for all template-derived
decls.
* decl2.c (lang_decode_option): Handle -fguiding-decls.
* parse.y (notype_template_declarator): New nonterminal.
(direct_notype_declarator): Use it.
(complex_direct_notype_declarator): Likewise.
(object_template_id): Accept any kind of identifier after TEMPLATE.
(notype_qualified_id): Don't add template declarators here.
Sat Sep 27 16:21:58 1997 Mark Mitchell <mmitchell@usa.net>
* call.c (add_template_candidate): Add explicit_targs parameter.
(build_scoped_method_call): Use it.
(build_overload_call_real): Likewise.
(build_user_type_conversion_1): Likewise.
(build_new_function_call): Likewise.
(build_object_call): Likewise.
(build_new_op): Likewise.
(build_new_method_call): Likewise.
(build_new_function_call): Handle TEMPLATE_ID_EXPR.
(build_new_method_call): Likewise.
* class.c (finish_struct_methods): Add specialization pass to
determine which methods were specializing which other methods.
(instantiate_type): Handle TEMPLATE_ID_EXPR.
* cp-tree.def (TEMPLATE_ID_EXPR): New tree code.
* cp-tree.h (name_mangling_version): New variable.
(flag_guiding_decls): Likewise.
(build_template_decl_overload): New function.
(begin_specialization): Likewise.
(reset_specialization): Likewise.
(end_specialization): Likewise.
(determine_explicit_specialization): Likewise.
(check_explicit_specialization): Likewise.
(lookup_template_function): Likewise.
(fn_type_unification): Add explicit_targs parameter.
(type_unification): Likewise.
* decl.c (duplicate_decls): Add smarts for explicit
specializations.
(grokdeclarator): Handle TEMPLATE_ID_EXPR, and function
specializations.
(grokfndecl): Call check_explicit_specialization.
* decl2.c (lang_decode_option): Handle -fname-mangling-version.
(build_expr_from_tree): Handle TEMPLATE_ID_EXPR.
(check_classfn): Handle specializations.
* error.c (dump_function_name): Print specialization arguments.
* friend.c (do_friend): Don't call pushdecl for template
instantiations.
* init.c (build_member_call): Handle TEMPLATE_ID_EXPR.
* lang-options.h: Add -fname-mangling-version, -fguiding-decls,
and -fno-guiding-decls.
* lex.c (identifier_type): Return PFUNCNAME for template function
names.
* method.c (build_decl_overload_real): New function.
(build_template_parm_names): New function.
(build_overload_identifier): Use it.
(build_underscore_int): New function.
(build_overload_int): Use it. Add levels for template
parameters.
(build_overload_name): Likewise. Also, handle TYPENAME_TYPEs.
(build_overload_nested_names): Handle template type parameters.
(build_template_decl_overload): New function.
* parse.y (YYSTYPE): New ntype member.
(nested_name_specifier): Use it.
(nested_name_specifier_1): Likewise.
(PFUNCNAME): New token.
(template_id, object_template_id): New non-terminals.
(template_parm_list): Note specializations.
(template_def): Likewise.
(structsp): Likewise.
(fn.def2): Handle member template specializations.
(component_decl_1): Likewise.
(direct_notype_declarator): Handle template-ids.
(component_decl_1): Likewise.
(direct_notype_declarator): Handle template-ids.
(primary): Handle TEMPLATE_ID_EXPR, and template-ids.
* pt.c (processing_specializations): New variable.
(template_header_count): Likewise.
(type_unification_real): New function.
(processing_explicit_specialization): Likewise.
(note_template_header): Likewise.
(is_member_template): Handle specializations.
(end_template_decl): Call reset_specialization.
(push_template_decl): Handle member template specializations.
(tsubst): Likewise.
(tsubst_copy): Handle TEMPLATE_ID_EXPR.
(instantiate_template): Handle specializations.
(instantiate_decl): Likewise.
(fn_type_unification): Handle explicit_targs.
(type_unification): Likewise. Allow incomplete unification
without an error message, if allow_incomplete.
(get_bindings): Use new calling sequence for fn_type_unification.
* spew.c (yylex): Handle PFUNCNAME.
* tree.c (is_overloaded_fn): Handle TEMPLATE_ID_EXPR.
(really_overloaded_fn): Likewise.
(get_first_fn): Handle function templates.
* typeck.c (build_x_function_call): Use really_overloaded_fn.
Handle TEMPLATE_ID_EXPR.
(build_x_unary_op): Likewise.
(build_unary_op): Likewise.
(mark_addressable): Templates whose address is taken are marked
as used.
From-SVN: r15774
181 lines
7.4 KiB
Plaintext
181 lines
7.4 KiB
Plaintext
*** Changes since G++ version 2.7.2:
|
|
|
|
* 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.
|
|
|
|
* 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.
|
|
+ Explicit specification of template parameters to function templates
|
|
is now supported.
|
|
|
|
Things you may need to fix in your code:
|
|
|
|
+ Syntax errors in templates that are never instantiated will now be
|
|
diagnosed.
|
|
+ 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, except in base lists. In many cases,
|
|
but not all, the compiler will tell you where you need to add
|
|
'typename'. For more information, see
|
|
|
|
http://www.cygnus.com/misc/wp/dec96pub/template.html#temp.res
|
|
|
|
+ Guiding declarations are no longer supported. Function declarations,
|
|
including friend declarations, do not refer to template instantiations.
|
|
You can restore the old behavior with -fguiding-decls until you fix
|
|
your code.
|
|
|
|
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, which defaults to 17. If you
|
|
need to use this flag, the compiler will tell you.
|
|
+ Explicit instantiation of template constructors and destructors is
|
|
now supported. For instance:
|
|
|
|
template A<int>::A(const A&);
|
|
|
|
Still not supported:
|
|
|
|
+ Member class templates.
|
|
+ Template template parameters.
|
|
+ Template friends.
|
|
|
|
* 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.
|
|
|
|
* 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.
|
|
|
|
* 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.
|
|
|
|
* 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
|
|
the more specialized template, and handles base classes in type deduction
|
|
and guiding declarations properly. In this release the old code can
|
|
still be selected with -fno-ansi-overloading, although this is not
|
|
supported and will be removed in a future release.
|
|
|
|
* Standard usage syntax for the std namespace is supported; std is treated
|
|
as an alias for global scope. General namespaces are still not supported.
|
|
|
|
* 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.
|
|
|
|
* 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.
|
|
|
|
* __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.
|
|
|
|
* local static variables in extern inline functions will be shared between
|
|
translation units.
|
|
|
|
* -fvtable-thunks is supported for all targets, and is the default for
|
|
Linux with glibc 2.x (also called libc 6.x).
|
|
|
|
* bool is now always the same size as another built-in type. Previously,
|
|
a 64-bit RISC target using a 32-bit ABI would have 32-bit pointers and a
|
|
64-bit bool. This should only affect Irix 6, which was not supported in
|
|
2.7.2.
|
|
|
|
* new (nothrow) is now supported.
|
|
|
|
* 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.
|
|
|
|
* The g++ driver now only links against libstdc++, not libg++; it is
|
|
functionally identical to the c++ driver.
|
|
|
|
* (void *)0 is no longer considered a null pointer constant; NULL in
|
|
<stddef.h> is now defined as __null, a magic constant of type (void *)
|
|
normally, or (size_t) with -ansi.
|
|
|
|
* The name of a class is now implicitly declared in its own scope; A::A
|
|
refers to A.
|
|
|
|
* Local classes are now supported.
|
|
|
|
* __attribute__ can now be attached to types as well as declarations.
|
|
|
|
* The compiler no longer emits a warning if an ellipsis is used as a
|
|
function's argument list.
|
|
|
|
* Definition of nested types outside of their containing class is now
|
|
supported. For instance:
|
|
|
|
struct A {
|
|
struct B;
|
|
B* bp;
|
|
};
|
|
|
|
struct A::B {
|
|
int member;
|
|
};
|
|
|
|
* 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.
|
|
|
|
*** The g++ team thanks everyone that contributed to this release,
|
|
but especially:
|
|
|
|
* Joe Buck <jbuck@synopsys.com>, the maintainer of the g++ FAQ.
|
|
* Brendan Kehoe <brendan@cygnus.com>, who coordinates testing of g++.
|
|
* Jason Merrill <jason@cygnus.com>, the g++ maintainer.
|
|
* Mark Mitchell <mmitchell@usa.net>, who implemented member function
|
|
templates and explicit qualification of function templates.
|
|
* Mike Stump <mrs@wrs.com>, the previous g++ maintainer, who did most of
|
|
the exception handling work.
|