Lines Matching defs:class
229 function, two inside the body of a function in a local class, etc.) */
281 template <class T> template <> ...
284 specialization of a class member template if the enclosing
285 class templates are not explicitly specialized as well. */
306 template <class T> template void f(int);
318 template <class T> void R<T>::S<T>::f(int);
321 parameters for each class. */
325 be a member of a template class.) For example:
327 template <class T> void S<T>::f(int);
329 The `class T' maches the `S<T>', leaving no template headers
335 template <> template <class T> void f (T);
342 template <class T> template <class U> void S<T>::f(U);
880 a class that allows you to write `S::S'. We must distinguish
1353 /* The name of a class template may not be declared to refer to
1354 any other template, class, function, object, namespace, value,
1417 can occur if we instantiate a template class, and then
1564 class A;
1566 typedef class A A __attribute__ ((foo));
1803 /* Merge the storage class information. */
1873 If a template, a member template or the member of a class
2008 o A friend function was declared in a class template. The
2009 class template was instantiated.
2082 /* The NEWDECL will no longer be needed. Because every out-of-class
2134 return "%q#D not declared in class";
2339 /* The POD stuff is just pedantry; why should it matter if the class
2866 dependent base class of CONTEXT. So we cannot peek inside it,
2874 error ("%q#T is not a class", context);
2886 error (want_template ? "no class template named %q#T in %q#T"
2894 error ("%<typename %T::%D%> names %q#T, which is not a class template",
2954 error ("no class template named %q#T in %q#T", name, context);
3421 enum built_in_class class,
3426 DECL_BUILT_IN_CLASS (decl) = class;
3675 /* If a class, struct, or enum type is declared by the DECLSPECS
3676 (i.e, if a class-specifier, enum-specifier, or non-typename
3707 can be omitted only when declaring a class (clause 9) or
3709 either a class-specifier, an elaborated-type-specifier with
3710 a class-key (9.1), or an enum-specifier. In these cases and
3711 whenever a class-specifier or enum-specifier is present in the
3713 the names being declared by the declaration (as class-name,
3720 typedef class { }; // ill-formed
3745 error ("%<friend%> can only be specified inside a class");
3749 error ("a storage class can only be specified for objects "
3911 /* We are only interested in class contexts, later. */
3949 can be initialized in-class and dllimported) go through grokfield,
3989 "of explicitly specialized class");
3990 /* Static data member are tricky; an in-class initialization
3991 still doesn't provide a definition, so the in-class
4034 pedwarn ("declaration of %q#D outside of class is not definition",
4139 specialization of a class template it is not until after
4211 a given brace-enclosed initializer is for a class type or for an
4579 /* The initializer for a class is always a CONSTRUCTOR. */
4588 empty class shall have the form of an empty
4616 /* If we processed all the member of the class, we are done. */
4855 /* There is no way to make a variable-sized class type in GNU C++. */
5012 /* If we see a class member here, it should be a static data
5017 /* An in-class declaration of a static data member should be
5326 class-specifier, there can be an initializer even if DECL
5389 the class specifier. */
5408 static data members in uninstantiated class templates. */
5964 error ("destructor for alien class %qT cannot be a member", ctype);
5966 error ("constructor for alien class %qT cannot be a member", ctype);
6025 /* [class.mfct]
6028 class definition shall appear in a namespace scope enclosing
6029 the class definition.
6031 [class.static.data]
6034 namespace scope enclosing the member's class definition. */
6062 /* CTYPE is class type, or null if non-class.
6142 /* Something like `template <class T> friend void f<T>()'. */
6157 up an operator_name or PFUNCNAME within the current class
6158 (see template_id in parse.y). If the current class contains
6241 /* [basic.link]: A name with no linkage (notably, the name of a class
6389 error ("no %q#D member function declared in class %qT",
6417 local classes -- the only situation in which a class has
6430 If SCOPE is non-NULL, it is the class type or namespace containing
6488 /* This function is only called with out-of-class definitions. */
6519 /* [basic.link]: A name with no linkage (notably, the name of a class
6648 /* DECL is a VAR_DECL defined in-class, whose TYPE is also given.
6658 may appear either in the declaration (within the class), or in
6659 the definition, but not both. If it appears in the class, the
6664 error ("invalid in-class initialization of static data member "
6674 error ("ISO C++ forbids in-class initialization of non-const "
6914 abstract class type. */
6923 declaration, or the class type for a constructor/destructor.
7089 /* The class type, if any, in which this entity is located,
7091 the current class type; for example if an attempt is made to declare
7289 by not allowing C++ class definitions to specify their parameters
7292 Since we now wait to push a class scope until we are sure that
7462 /* [class.bit]
7592 error ("storage class specifiers invalid in parameter declarations");
7595 /* Give error if `virtual' is used outside of class declaration. */
7599 error ("virtual outside class declaration");
7637 /* C++ allows static class elements. */
7645 error ("storage class specified for %qs", name);
7649 error ("storage class specified for parameter %qs", name);
7651 error ("storage class specified for typename");
7691 error ("storage class specifiers invalid in friend function declarations");
7797 /* We are within a class's scope. If our declarator name
7798 is the same as the class name, and we are defining
7855 error ("friend declaration not in class definition");
7858 "class definition",
7966 qualified with a class-name, turn it into a METHOD_TYPE, unless
7969 explicitly declared to be class members. Note that if DECLARATOR
7984 template class, but you don't need one for a full
7987 template <class T> struct S{};
8010 pedwarn ("member functions are implicitly friends of their class");
8024 must be a class. */
8029 case) or the qualifying class is currently being
8104 declarations of constructors within a class definition. */
8154 particular class, but which is cv-qualified; for
8183 "as enclosing class",
8210 /* If this is a typedef within a template class, the nested
8293 /* Special case: "friend class foo" looks like a TYPENAME context. */
8298 error ("type qualifiers specified for friend class declaration");
8303 error ("%<inline%> specified for friend class declaration");
8309 /* Don't allow friend declaration without a class-key. */
8313 pedwarn ("friend declaration requires class-key, "
8314 "i.e. %<friend class %T::%D%>",
8317 pedwarn ("friend declaration requires class-key, "
8325 /* A friendly class? */
8330 error ("trying to make class %qT a friend of global scope",
8446 error ("can't make %qD into a method -- not in a class",
8518 /* [class.conv.ctor]
8523 parameter to the type of its class. Such a constructor
8627 member. But, from [class.mem]:
8659 /* C++ allows static class members. All other work
8663 /* Even if there is an in-class initialization, DECL
8664 is considered undefined until an out-of-class
8710 error ("storage class %<auto%> invalid for function %qs", name);
8712 error ("storage class %<register%> invalid for function %qs", name);
8714 error ("storage class %<__thread%> invalid for function %qs", name);
8736 error ("virtual non-class function %qs", name);
8763 /* Don't allow a static member function in a class, and forbid
8926 /* We get a DEFAULT_ARG when looking at an in-class declaration
8928 deal with it after the class is complete. */
9096 Let T be the class in which D is declared. Then, this function
9179 /* [class.copy]
9181 A non-template constructor for class X is a copy
9195 /* [class.copy]
9197 A non-template assignment operator for class X is a copy
9213 if the class has a constructor of the form X(X). */
9222 /* [class.copy]
9224 A declaration of a constructor for a class X is ill-formed if
9377 or have at least one parameter of a class, a reference to a class,
9417 error ("%qD must have an argument of class or "
9434 warn again about out-of-class definitions. */
9454 what = "a base class";
9643 return "class";
9659 If ALLOW_TEMPLATE_P is true, TYPE may be a class template. */
9722 /* If a class template appears as elaborated type specifier
9725 template <class T> class C {};
9726 void f(class C); // No template header here
9751 /* First try ordinary name lookup, ignoring hidden class name
9755 non-class, non-function-prototype scope according to 3.3.1/5.
9772 class C {
9773 class C {};
9777 error ("%qD has the same name as the class in which it is "
9783 /* Two cases we need to consider when deciding if a class
9785 1. It is a self reference to its own class.
9790 template <class T> class C {
9791 class C *c1; // DECL_SELF_REFERENCE_P is true
9792 class D;
9794 template <class U> class C; // template_header_p is true
9795 template <class T> class C<T>::D {
9796 class C *c2; // DECL_SELF_REFERENCE_P is true
9825 till the nearest non-class scope. Otherwise it is TS_GLOBAL.
9876 class, we must be very careful; consider:
9878 template <class X>
9881 template <class U>
9883 { template <class V>
9892 template <class V = U> friend struct S1;
9897 template <class T>
9899 template <class U>
9901 template <class U>
9947 /* Make injected friend class visible. */
9983 access_* node, and the TREE_VALUE is the type of the base-class.
10003 /* The base of a derived class is private by default, all others are
10063 error ("Java class %qT cannot have multiple bases", ref);
10074 error ("Java class %qT cannot have virtual bases", ref);
10095 error ("base type %qT fails to be a struct or class type",
10494 /* C++ associates enums with global, function, or class declarations. */
10513 /* This enum declaration is local to the class. We need the full
10518 a function could mean local to a class method. */
10583 indicating that the function is an inline defined in-class.
10589 For example, "class A local_a(1,2);" means that variable local_a
10620 /* ISO C++ 11.4/5. A friend function defined in a class is in
10621 the (lexical) scope of the class in which it is defined. */
10654 /* Set up current_class_type, and enter the scope of the class, if
10661 /* Now that we have entered the scope of the class, we must restore
10665 the class.) It is not until after this point that
10687 class scope, current_class_type will be NULL_TREE until set above
10836 destructor for a class in which no destructor
10852 /* This is a function in a local class in an extern inline
11022 at class level. */
11162 /* [class.dtor]
11166 be looked up in the scope of the destructor's class and if
11274 We just finished processing the body of an in-class inline
11276 after the class definition is complete.) */
11408 /* Remember that we were in class scope. */
11469 /* If this is an in-class inline definition, we may have to pop the
11476 /* Leave the scope of the class. */
11541 error ("%qD is already defined in class %qT", fndecl,
11579 We don't compile this method until after the whole class has
11666 /* Called when a class type (given by TYPE) is defined. If there are