1 /* Help friends in C++.
2 Copyright (C) 1997 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
28 /* Friend data structures:
30 Lists of friend functions come from TYPE_DECL nodes. Since all
31 aggregate types are automatically typedef'd, these nodes are guaranteed
34 The TREE_PURPOSE of a friend list is the name of the friend,
35 and its TREE_VALUE is another list.
37 For each element of that list, either the TREE_VALUE or the TREE_PURPOSE
38 will be filled in, but not both. The TREE_VALUE of that list is an
39 individual function which is a friend. The TREE_PURPOSE of that list
40 indicates a type in which all functions by that name are friends.
42 Lists of friend classes come from _TYPE nodes. Love that consistency
46 is_friend (type, supplicant)
47 tree type, supplicant;
52 if (supplicant == NULL_TREE || type == NULL_TREE)
55 declp = (TREE_CODE_CLASS (TREE_CODE (supplicant)) == 'd');
58 /* It's a function decl. */
60 tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
61 tree name = DECL_NAME (supplicant);
64 if (DECL_FUNCTION_MEMBER_P (supplicant))
65 ctype = DECL_CLASS_CONTEXT (supplicant);
69 for (; list ; list = TREE_CHAIN (list))
71 if (name == TREE_PURPOSE (list))
73 tree friends = TREE_VALUE (list);
74 for (; friends ; friends = TREE_CHAIN (friends))
76 if (ctype == TREE_PURPOSE (friends))
78 if (comptypes (TREE_TYPE (supplicant),
79 TREE_TYPE (TREE_VALUE (friends)), 1))
89 if (type == supplicant)
92 list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
93 for (; list ; list = TREE_CHAIN (list))
94 if (supplicant == TREE_VALUE (list))
103 /* Are we a nested or local class? If so, we aren't friends
105 if (IS_AGGR_TYPE (supplicant))
108 context = DECL_CONTEXT (TYPE_MAIN_DECL (supplicant));
110 else if (DECL_FUNCTION_MEMBER_P (supplicant))
111 context = DECL_CLASS_CONTEXT (supplicant);
116 return is_friend (type, context);
122 /* Add a new friend to the friends of the aggregate type TYPE.
123 DECL is the FUNCTION_DECL of the friend being added. */
126 add_friend (type, decl)
129 tree typedecl = TYPE_MAIN_DECL (type);
130 tree list = DECL_FRIENDLIST (typedecl);
131 tree name = DECL_NAME (decl);
135 if (name == TREE_PURPOSE (list))
137 tree friends = TREE_VALUE (list);
138 for (; friends ; friends = TREE_CHAIN (friends))
140 if (decl == TREE_VALUE (friends))
142 cp_warning ("`%D' is already a friend of class `%T'",
144 cp_warning_at ("previous friend declaration of `%D'",
145 TREE_VALUE (friends));
149 TREE_VALUE (list) = tree_cons (error_mark_node, decl,
153 list = TREE_CHAIN (list);
155 DECL_FRIENDLIST (typedecl)
156 = tree_cons (DECL_NAME (decl), build_tree_list (error_mark_node, decl),
157 DECL_FRIENDLIST (typedecl));
158 if (DECL_NAME (decl) == ansi_opname[(int) MODIFY_EXPR])
160 tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (decl));
161 TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
162 if (parmtypes && TREE_CHAIN (parmtypes))
164 tree parmtype = TREE_VALUE (TREE_CHAIN (parmtypes));
165 if (TREE_CODE (parmtype) == REFERENCE_TYPE
166 && TREE_TYPE (parmtypes) == TREE_TYPE (typedecl))
167 TYPE_HAS_ASSIGN_REF (TREE_TYPE (typedecl)) = 1;
172 /* Declare that every member function NAME in FRIEND_TYPE
173 (which may be NULL_TREE) is a friend of type TYPE. */
176 add_friends (type, name, friend_type)
177 tree type, name, friend_type;
179 tree typedecl = TYPE_MAIN_DECL (type);
180 tree list = DECL_FRIENDLIST (typedecl);
184 if (name == TREE_PURPOSE (list))
186 tree friends = TREE_VALUE (list);
187 while (friends && TREE_PURPOSE (friends) != friend_type)
188 friends = TREE_CHAIN (friends);
191 warning ("method `%s::%s' is already a friend of class",
192 TYPE_NAME_STRING (friend_type),
193 IDENTIFIER_POINTER (name));
195 warning ("function `%s' is already a friend of class `%s'",
196 IDENTIFIER_POINTER (name),
197 IDENTIFIER_POINTER (DECL_NAME (typedecl)));
199 TREE_VALUE (list) = tree_cons (friend_type, NULL_TREE,
203 list = TREE_CHAIN (list);
205 DECL_FRIENDLIST (typedecl)
207 build_tree_list (friend_type, NULL_TREE),
208 DECL_FRIENDLIST (typedecl));
209 if (! strncmp (IDENTIFIER_POINTER (name),
210 IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]),
211 strlen (IDENTIFIER_POINTER (ansi_opname[(int) MODIFY_EXPR]))))
213 TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl)) = 1;
214 sorry ("declaring \"friend operator =\" will not find \"operator = (X&)\" if it exists");
218 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
219 been defined, we make all of its member functions friends of
220 TYPE. If not, we make it a pending friend, which can later be added
221 when its definition is seen. If a type is defined, then its TYPE_DECL's
222 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
223 classes that are not defined. If a type has not yet been defined,
224 then the DECL_WAITING_FRIENDS contains a list of types
225 waiting to make it their friend. Note that these two can both
226 be in use at the same time! */
229 make_friend_class (type, friend_type)
230 tree type, friend_type;
234 if (IS_SIGNATURE (type))
236 error ("`friend' declaration in signature definition");
239 if (IS_SIGNATURE (friend_type))
241 error ("signature type `%s' declared `friend'",
242 IDENTIFIER_POINTER (TYPE_IDENTIFIER (friend_type)));
245 if (type == friend_type)
247 pedwarn ("class `%s' is implicitly friends with itself",
248 TYPE_NAME_STRING (type));
252 GNU_xref_hier (TYPE_NAME_STRING (type),
253 TYPE_NAME_STRING (friend_type), 0, 0, 1);
255 classes = CLASSTYPE_FRIEND_CLASSES (type);
256 while (classes && TREE_VALUE (classes) != friend_type)
257 classes = TREE_CHAIN (classes);
259 warning ("class `%s' is already friends with class `%s'",
260 TYPE_NAME_STRING (TREE_VALUE (classes)), TYPE_NAME_STRING (type));
263 CLASSTYPE_FRIEND_CLASSES (type)
264 = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
268 /* Main friend processor. This is large, and for modularity purposes,
269 has been removed from grokdeclarator. It returns `void_type_node'
270 to indicate that something happened, though a FIELD_DECL is
273 CTYPE is the class this friend belongs to.
275 DECLARATOR is the name of the friend.
277 DECL is the FUNCTION_DECL that the friend is.
279 In case we are parsing a friend which is part of an inline
280 definition, we will need to store PARM_DECL chain that comes
281 with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
283 FLAGS is just used for `grokclassfn'.
285 QUALS say what special qualifies should apply to the object
286 pointed to by `this'. */
289 do_friend (ctype, declarator, decl, parmdecls, flags, quals, funcdef_flag)
290 tree ctype, declarator, decl, parmdecls;
291 enum overload_flags flags;
295 /* Every decl that gets here is a friend of something. */
296 DECL_FRIEND_P (decl) = 1;
300 tree cname = TYPE_NAME (ctype);
301 if (TREE_CODE (cname) == TYPE_DECL)
302 cname = DECL_NAME (cname);
304 /* A method friend. */
305 if (TREE_CODE (decl) == FUNCTION_DECL)
307 if (flags == NO_SPECIAL && ctype && declarator == cname)
308 DECL_CONSTRUCTOR_P (decl) = 1;
310 /* This will set up DECL_ARGUMENTS for us. */
311 grokclassfn (ctype, cname, decl, flags, quals);
312 if (TYPE_SIZE (ctype) != 0)
313 decl = check_classfn (ctype, decl);
315 if (TREE_TYPE (decl) != error_mark_node)
317 if (TYPE_SIZE (ctype))
318 add_friend (current_class_type, decl);
321 cp_error ("member `%D' declared as friend before type `%T' defined",
328 /* Possibly a bunch of method friends. */
330 /* Get the class they belong to. */
331 tree ctype = IDENTIFIER_TYPE_VALUE (cname);
332 tree fields = lookup_fnfields (TYPE_BINFO (ctype), declarator, 0);
335 add_friends (current_class_type, declarator, ctype);
337 error ("method `%s' is not a member of class `%s'",
338 IDENTIFIER_POINTER (declarator),
339 IDENTIFIER_POINTER (cname));
340 decl = void_type_node;
343 else if (TREE_CODE (decl) == FUNCTION_DECL
344 && ((IDENTIFIER_LENGTH (declarator) == 4
345 && IDENTIFIER_POINTER (declarator)[0] == 'm'
346 && ! strcmp (IDENTIFIER_POINTER (declarator), "main"))
347 || (IDENTIFIER_LENGTH (declarator) > 10
348 && IDENTIFIER_POINTER (declarator)[0] == '_'
349 && IDENTIFIER_POINTER (declarator)[1] == '_'
350 && strncmp (IDENTIFIER_POINTER (declarator)+2,
351 "builtin_", 8) == 0)))
353 /* raw "main", and builtin functions never gets overloaded,
354 but they can become friends. */
355 add_friend (current_class_type, decl);
356 DECL_FRIEND_P (decl) = 1;
357 decl = void_type_node;
360 @@ or possibly a friend from a base class ?!? */
361 else if (TREE_CODE (decl) == FUNCTION_DECL)
363 /* Friends must all go through the overload machinery,
364 even though they may not technically be overloaded.
366 Note that because classes all wind up being top-level
367 in their scope, their friend wind up in top-level scope as well. */
368 DECL_ASSEMBLER_NAME (decl)
369 = build_decl_overload (declarator, TYPE_ARG_TYPES (TREE_TYPE (decl)),
370 TREE_CODE (TREE_TYPE (decl)) == METHOD_TYPE);
371 DECL_ARGUMENTS (decl) = parmdecls;
373 DECL_CLASS_CONTEXT (decl) = current_class_type;
375 /* We can call pushdecl here, because the TREE_CHAIN of this
376 FUNCTION_DECL is not needed for other purposes. */
377 decl = pushdecl (decl);
379 make_decl_rtl (decl, NULL_PTR, 1);
380 add_friend (current_class_type, decl);
382 DECL_FRIEND_P (decl) = 1;
386 /* @@ Should be able to ingest later definitions of this function
388 tree decl = lookup_name_nonclass (declarator);
389 if (decl == NULL_TREE)
391 warning ("implicitly declaring `%s' as struct",
392 IDENTIFIER_POINTER (declarator));
393 decl = xref_tag (record_type_node, declarator, NULL_TREE, 1);
394 decl = TYPE_MAIN_DECL (decl);
397 /* Allow abbreviated declarations of overloaded functions,
398 but not if those functions are really class names. */
399 if (TREE_CODE (decl) == TREE_LIST && TREE_TYPE (TREE_PURPOSE (decl)))
401 warning ("`friend %s' archaic, use `friend class %s' instead",
402 IDENTIFIER_POINTER (declarator),
403 IDENTIFIER_POINTER (declarator));
404 decl = TREE_TYPE (TREE_PURPOSE (decl));
407 if (TREE_CODE (decl) == TREE_LIST)
408 add_friends (current_class_type, TREE_PURPOSE (decl), NULL_TREE);
410 make_friend_class (current_class_type, TREE_TYPE (decl));
411 decl = void_type_node;