From 405a745b2e01783dd0e12bd80010cdf055747f73 Mon Sep 17 00:00:00 2001 From: Jason Merrill Date: Fri, 26 Sep 1997 07:24:48 +0000 Subject: [PATCH] parse.y (member_init): Also imply typename here. * parse.y (member_init): Also imply typename here. Remove ancient extension for initializing base members. From-SVN: r15720 --- gcc/cp/ChangeLog | 5 +++ gcc/cp/NEWS | 84 +++++++++++++++++++++--------------------------- gcc/cp/parse.y | 19 +++++------ 3 files changed, 50 insertions(+), 58 deletions(-) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index c5e34ac4b24..e83908ae61e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,8 @@ +Fri Sep 26 00:22:56 1997 Jason Merrill + + * parse.y (member_init): Also imply typename here. Remove ancient + extension for initializing base members. + Thu Sep 25 11:11:13 1997 Jason Merrill Handle multi-level typenames and implicit typename in base list. diff --git a/gcc/cp/NEWS b/gcc/cp/NEWS index 38fd5289d86..3d53e1c36bd 100644 --- a/gcc/cp/NEWS +++ b/gcc/cp/NEWS @@ -16,38 +16,32 @@ + 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. + now supported. For instance: - template A::A(const A&); + template A::A(const A&); - Possible problems (caused by complying with the ANSI/ISO draft): + 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. In many cases, the compiler will tell - you where you need to add 'typename'. + 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 - + Syntax errors in templates that are never instantiated will now be - diagnosed. + http://www.cygnus.com/misc/wp/dec96pub/template.html#temp.res Other features: @@ -55,32 +49,40 @@ 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. + recursive template instantiation depth, which defaults to 17. If you + need to use this flag, the compiler will tell you. Still not supported: + + Member class templates. + Template template parameters. + + Template friends. + + Explicit qualification of function templates. * 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. +* 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. -* __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. +* 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: @@ -103,25 +105,21 @@ + 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. -* Standard usage syntax for the std namespace is supported; std is treated - 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 2.x (also called libc 6.x). -* 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 - recompiled. The RTTI support library has moved from libstdc++ to - libgcc, so you no longer need to link against libstdc++ for a program - that doesn't use the "hosted" library. - * 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 @@ -129,14 +127,6 @@ * new (nothrow) 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 - 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. - * 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. @@ -159,7 +149,7 @@ function's argument list. * Definition of nested types outside of their containing class is now - supported. Use the following source code, as an example. + supported. For instance: struct A { struct B; diff --git a/gcc/cp/parse.y b/gcc/cp/parse.y index 37e61369c40..e11e1f10493 100644 --- a/gcc/cp/parse.y +++ b/gcc/cp/parse.y @@ -794,19 +794,16 @@ member_init: { expand_member_init (current_class_ref, $1, $3); } | notype_identifier LEFT_RIGHT { expand_member_init (current_class_ref, $1, void_type_node); } - | complete_type_name '(' nonnull_exprlist ')' + | nonnested_type '(' nonnull_exprlist ')' { expand_member_init (current_class_ref, $1, $3); } - | complete_type_name LEFT_RIGHT + | nonnested_type LEFT_RIGHT { expand_member_init (current_class_ref, $1, void_type_node); } - /* GNU extension */ - | notype_qualified_id '(' nonnull_exprlist ')' - { - do_member_init (OP0 ($1), OP1 ($1), $3); - } - | notype_qualified_id LEFT_RIGHT - { - do_member_init (OP0 ($1), OP1 ($1), void_type_node); - } + | typename_sub '(' nonnull_exprlist ')' + { expand_member_init (current_class_ref, TYPE_MAIN_DECL ($1), + $3); } + | typename_sub LEFT_RIGHT + { expand_member_init (current_class_ref, TYPE_MAIN_DECL ($1), + void_type_node); } ; identifier: -- 2.30.2