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. */
33 static void add_friend
PROTO((tree
, tree
));
34 static void add_friends
PROTO((tree
, tree
, tree
));
36 /* Friend data structures:
38 Lists of friend functions come from TYPE_DECL nodes. Since all
39 aggregate types are automatically typedef'd, these nodes are guaranteed
42 The TREE_PURPOSE of a friend list is the name of the friend,
43 and its TREE_VALUE is another list.
45 For each element of that list, either the TREE_VALUE or the TREE_PURPOSE
46 will be filled in, but not both. The TREE_VALUE of that list is an
47 individual function which is a friend. The TREE_PURPOSE of that list
48 indicates a type in which all functions by that name are friends.
50 Lists of friend classes come from _TYPE nodes. Love that consistency
54 is_friend (type
, supplicant
)
55 tree type
, supplicant
;
60 if (supplicant
== NULL_TREE
|| type
== NULL_TREE
)
63 declp
= (TREE_CODE_CLASS (TREE_CODE (supplicant
)) == 'd');
66 /* It's a function decl. */
68 tree list
= DECL_FRIENDLIST (TYPE_MAIN_DECL (type
));
69 tree name
= DECL_NAME (supplicant
);
72 if (DECL_FUNCTION_MEMBER_P (supplicant
))
73 ctype
= DECL_CLASS_CONTEXT (supplicant
);
77 for (; list
; list
= TREE_CHAIN (list
))
79 if (name
== TREE_PURPOSE (list
))
81 tree friends
= TREE_VALUE (list
);
82 for (; friends
; friends
= TREE_CHAIN (friends
))
84 if (ctype
== TREE_PURPOSE (friends
))
86 if (comptypes (TREE_TYPE (supplicant
),
87 TREE_TYPE (TREE_VALUE (friends
)), 1))
97 if (type
== supplicant
)
100 list
= CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type
)));
101 for (; list
; list
= TREE_CHAIN (list
))
102 if (supplicant
== TREE_VALUE (list
))
111 /* Are we a nested or local class? If so, we aren't friends
113 if (IS_AGGR_TYPE (supplicant
))
116 context
= DECL_CONTEXT (TYPE_MAIN_DECL (supplicant
));
118 else if (DECL_FUNCTION_MEMBER_P (supplicant
))
119 context
= DECL_CLASS_CONTEXT (supplicant
);
124 return is_friend (type
, context
);
130 /* Add a new friend to the friends of the aggregate type TYPE.
131 DECL is the FUNCTION_DECL of the friend being added. */
134 add_friend (type
, decl
)
137 tree typedecl
= TYPE_MAIN_DECL (type
);
138 tree list
= DECL_FRIENDLIST (typedecl
);
139 tree name
= DECL_NAME (decl
);
143 if (name
== TREE_PURPOSE (list
))
145 tree friends
= TREE_VALUE (list
);
146 for (; friends
; friends
= TREE_CHAIN (friends
))
148 if (decl
== TREE_VALUE (friends
))
150 cp_warning ("`%D' is already a friend of class `%T'",
152 cp_warning_at ("previous friend declaration of `%D'",
153 TREE_VALUE (friends
));
157 TREE_VALUE (list
) = tree_cons (error_mark_node
, decl
,
161 list
= TREE_CHAIN (list
);
163 DECL_FRIENDLIST (typedecl
)
164 = tree_cons (DECL_NAME (decl
), build_tree_list (error_mark_node
, decl
),
165 DECL_FRIENDLIST (typedecl
));
166 if (DECL_NAME (decl
) == ansi_opname
[(int) MODIFY_EXPR
])
168 tree parmtypes
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
169 TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl
)) = 1;
170 if (parmtypes
&& TREE_CHAIN (parmtypes
))
172 tree parmtype
= TREE_VALUE (TREE_CHAIN (parmtypes
));
173 if (TREE_CODE (parmtype
) == REFERENCE_TYPE
174 && TREE_TYPE (parmtypes
) == TREE_TYPE (typedecl
))
175 TYPE_HAS_ASSIGN_REF (TREE_TYPE (typedecl
)) = 1;
180 /* Declare that every member function NAME in FRIEND_TYPE
181 (which may be NULL_TREE) is a friend of type TYPE. */
184 add_friends (type
, name
, friend_type
)
185 tree type
, name
, friend_type
;
187 tree typedecl
= TYPE_MAIN_DECL (type
);
188 tree list
= DECL_FRIENDLIST (typedecl
);
192 if (name
== TREE_PURPOSE (list
))
194 tree friends
= TREE_VALUE (list
);
195 while (friends
&& TREE_PURPOSE (friends
) != friend_type
)
196 friends
= TREE_CHAIN (friends
);
199 warning ("method `%s::%s' is already a friend of class",
200 TYPE_NAME_STRING (friend_type
),
201 IDENTIFIER_POINTER (name
));
203 warning ("function `%s' is already a friend of class `%s'",
204 IDENTIFIER_POINTER (name
),
205 IDENTIFIER_POINTER (DECL_NAME (typedecl
)));
207 TREE_VALUE (list
) = tree_cons (friend_type
, NULL_TREE
,
211 list
= TREE_CHAIN (list
);
213 DECL_FRIENDLIST (typedecl
)
215 build_tree_list (friend_type
, NULL_TREE
),
216 DECL_FRIENDLIST (typedecl
));
217 if (! strncmp (IDENTIFIER_POINTER (name
),
218 IDENTIFIER_POINTER (ansi_opname
[(int) MODIFY_EXPR
]),
219 strlen (IDENTIFIER_POINTER (ansi_opname
[(int) MODIFY_EXPR
]))))
221 TYPE_HAS_ASSIGNMENT (TREE_TYPE (typedecl
)) = 1;
222 sorry ("declaring \"friend operator =\" will not find \"operator = (X&)\" if it exists");
226 /* Make FRIEND_TYPE a friend class to TYPE. If FRIEND_TYPE has already
227 been defined, we make all of its member functions friends of
228 TYPE. If not, we make it a pending friend, which can later be added
229 when its definition is seen. If a type is defined, then its TYPE_DECL's
230 DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
231 classes that are not defined. If a type has not yet been defined,
232 then the DECL_WAITING_FRIENDS contains a list of types
233 waiting to make it their friend. Note that these two can both
234 be in use at the same time! */
237 make_friend_class (type
, friend_type
)
238 tree type
, friend_type
;
242 if (IS_SIGNATURE (type
))
244 error ("`friend' declaration in signature definition");
247 if (IS_SIGNATURE (friend_type
))
249 error ("signature type `%s' declared `friend'",
250 IDENTIFIER_POINTER (TYPE_IDENTIFIER (friend_type
)));
253 if (type
== friend_type
)
255 pedwarn ("class `%s' is implicitly friends with itself",
256 TYPE_NAME_STRING (type
));
260 GNU_xref_hier (TYPE_NAME_STRING (type
),
261 TYPE_NAME_STRING (friend_type
), 0, 0, 1);
263 classes
= CLASSTYPE_FRIEND_CLASSES (type
);
264 while (classes
&& TREE_VALUE (classes
) != friend_type
)
265 classes
= TREE_CHAIN (classes
);
267 warning ("class `%s' is already friends with class `%s'",
268 TYPE_NAME_STRING (TREE_VALUE (classes
)), TYPE_NAME_STRING (type
));
271 CLASSTYPE_FRIEND_CLASSES (type
)
272 = tree_cons (NULL_TREE
, friend_type
, CLASSTYPE_FRIEND_CLASSES (type
));
276 /* Main friend processor. This is large, and for modularity purposes,
277 has been removed from grokdeclarator. It returns `void_type_node'
278 to indicate that something happened, though a FIELD_DECL is
281 CTYPE is the class this friend belongs to.
283 DECLARATOR is the name of the friend.
285 DECL is the FUNCTION_DECL that the friend is.
287 In case we are parsing a friend which is part of an inline
288 definition, we will need to store PARM_DECL chain that comes
289 with it into the DECL_ARGUMENTS slot of the FUNCTION_DECL.
291 FLAGS is just used for `grokclassfn'.
293 QUALS say what special qualifies should apply to the object
294 pointed to by `this'. */
297 do_friend (ctype
, declarator
, decl
, parmdecls
, flags
, quals
, funcdef_flag
)
298 tree ctype
, declarator
, decl
, parmdecls
;
299 enum overload_flags flags
;
303 /* Every decl that gets here is a friend of something. */
304 DECL_FRIEND_P (decl
) = 1;
308 tree cname
= TYPE_NAME (ctype
);
309 if (TREE_CODE (cname
) == TYPE_DECL
)
310 cname
= DECL_NAME (cname
);
312 /* A method friend. */
313 if (TREE_CODE (decl
) == FUNCTION_DECL
)
315 if (flags
== NO_SPECIAL
&& ctype
&& declarator
== cname
)
316 DECL_CONSTRUCTOR_P (decl
) = 1;
318 /* This will set up DECL_ARGUMENTS for us. */
319 grokclassfn (ctype
, cname
, decl
, flags
, quals
);
320 if (TYPE_SIZE (ctype
) != 0)
321 decl
= check_classfn (ctype
, decl
);
323 if (TREE_TYPE (decl
) != error_mark_node
)
325 if (TYPE_SIZE (ctype
))
326 add_friend (current_class_type
, decl
);
329 cp_error ("member `%D' declared as friend before type `%T' defined",
336 /* Possibly a bunch of method friends. */
338 /* Get the class they belong to. */
339 tree ctype
= IDENTIFIER_TYPE_VALUE (cname
);
340 tree fields
= lookup_fnfields (TYPE_BINFO (ctype
), declarator
, 0);
343 add_friends (current_class_type
, declarator
, ctype
);
345 error ("method `%s' is not a member of class `%s'",
346 IDENTIFIER_POINTER (declarator
),
347 IDENTIFIER_POINTER (cname
));
348 decl
= void_type_node
;
351 else if (TREE_CODE (decl
) == FUNCTION_DECL
352 && ((IDENTIFIER_LENGTH (declarator
) == 4
353 && IDENTIFIER_POINTER (declarator
)[0] == 'm'
354 && ! strcmp (IDENTIFIER_POINTER (declarator
), "main"))
355 || (IDENTIFIER_LENGTH (declarator
) > 10
356 && IDENTIFIER_POINTER (declarator
)[0] == '_'
357 && IDENTIFIER_POINTER (declarator
)[1] == '_'
358 && strncmp (IDENTIFIER_POINTER (declarator
)+2,
359 "builtin_", 8) == 0)))
361 /* raw "main", and builtin functions never gets overloaded,
362 but they can become friends. */
363 add_friend (current_class_type
, decl
);
364 DECL_FRIEND_P (decl
) = 1;
365 decl
= void_type_node
;
368 @@ or possibly a friend from a base class ?!? */
369 else if (TREE_CODE (decl
) == FUNCTION_DECL
)
371 /* Friends must all go through the overload machinery,
372 even though they may not technically be overloaded.
374 Note that because classes all wind up being top-level
375 in their scope, their friend wind up in top-level scope as well. */
376 DECL_ASSEMBLER_NAME (decl
)
377 = build_decl_overload (declarator
, TYPE_ARG_TYPES (TREE_TYPE (decl
)),
378 TREE_CODE (TREE_TYPE (decl
)) == METHOD_TYPE
);
379 DECL_ARGUMENTS (decl
) = parmdecls
;
381 DECL_CLASS_CONTEXT (decl
) = current_class_type
;
383 if (! DECL_USE_TEMPLATE (decl
))
385 /* We can call pushdecl here, because the TREE_CHAIN of this
386 FUNCTION_DECL is not needed for other purposes. Don't do this
387 for a template instantiation. */
388 decl
= pushdecl (decl
);
390 if (! funcdef_flag
&& ! flag_guiding_decls
391 && current_template_parms
&& uses_template_parms (decl
))
393 static int explained
;
394 cp_warning ("friend declaration `%#D'", decl
);
395 warning (" will not be treated as a template instantiation");
398 warning (" unless you compile with -fguiding-decls");
399 warning (" or add <> after the function name");
405 make_decl_rtl (decl
, NULL_PTR
, 1);
406 add_friend (current_class_type
, decl
);
408 DECL_FRIEND_P (decl
) = 1;
412 /* @@ Should be able to ingest later definitions of this function
414 tree decl
= lookup_name_nonclass (declarator
);
415 if (decl
== NULL_TREE
)
417 warning ("implicitly declaring `%s' as struct",
418 IDENTIFIER_POINTER (declarator
));
419 decl
= xref_tag (record_type_node
, declarator
, NULL_TREE
, 1);
420 decl
= TYPE_MAIN_DECL (decl
);
423 /* Allow abbreviated declarations of overloaded functions,
424 but not if those functions are really class names. */
425 if (TREE_CODE (decl
) == TREE_LIST
&& TREE_TYPE (TREE_PURPOSE (decl
)))
427 warning ("`friend %s' archaic, use `friend class %s' instead",
428 IDENTIFIER_POINTER (declarator
),
429 IDENTIFIER_POINTER (declarator
));
430 decl
= TREE_TYPE (TREE_PURPOSE (decl
));
433 if (TREE_CODE (decl
) == TREE_LIST
)
434 add_friends (current_class_type
, TREE_PURPOSE (decl
), NULL_TREE
);
436 make_friend_class (current_class_type
, TREE_TYPE (decl
));
437 decl
= void_type_node
;