OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [cp/] [friend.c] - Blame information for rev 859

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 283 jeremybenn
/* Help friends in C++.
2
   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3
   2007, 2008  Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify
8
it under the terms of the GNU General Public License as published by
9
the Free Software Foundation; either version 3, or (at your option)
10
any later version.
11
 
12
GCC is distributed in the hope that it will be useful,
13
but WITHOUT ANY WARRANTY; without even the implied warranty of
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
GNU General Public License for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "coretypes.h"
24
#include "tm.h"
25
#include "tree.h"
26
#include "rtl.h"
27
#include "expr.h"
28
#include "cp-tree.h"
29
#include "flags.h"
30
#include "output.h"
31
#include "toplev.h"
32
 
33
/* Friend data structures are described in cp-tree.h.  */
34
 
35
/* Returns nonzero if SUPPLICANT is a friend of TYPE.  */
36
 
37
int
38
is_friend (tree type, tree supplicant)
39
{
40
  int declp;
41
  tree list;
42
  tree context;
43
 
44
  if (supplicant == NULL_TREE || type == NULL_TREE)
45
    return 0;
46
 
47
  declp = DECL_P (supplicant);
48
 
49
  if (declp)
50
    /* It's a function decl.  */
51
    {
52
      tree list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type));
53
      tree name = DECL_NAME (supplicant);
54
 
55
      for (; list ; list = TREE_CHAIN (list))
56
        {
57
          if (name == FRIEND_NAME (list))
58
            {
59
              tree friends = FRIEND_DECLS (list);
60
              for (; friends ; friends = TREE_CHAIN (friends))
61
                {
62
                  tree this_friend = TREE_VALUE (friends);
63
 
64
                  if (this_friend == NULL_TREE)
65
                    continue;
66
 
67
                  if (supplicant == this_friend)
68
                    return 1;
69
 
70
                  if (is_specialization_of_friend (supplicant, this_friend))
71
                    return 1;
72
                }
73
              break;
74
            }
75
        }
76
    }
77
  else
78
    /* It's a type.  */
79
    {
80
      if (same_type_p (supplicant, type))
81
        return 1;
82
 
83
      list = CLASSTYPE_FRIEND_CLASSES (TREE_TYPE (TYPE_MAIN_DECL (type)));
84
      for (; list ; list = TREE_CHAIN (list))
85
        {
86
          tree t = TREE_VALUE (list);
87
 
88
          if (TREE_CODE (t) == TEMPLATE_DECL ?
89
              is_specialization_of_friend (TYPE_MAIN_DECL (supplicant), t) :
90
              same_type_p (supplicant, t))
91
            return 1;
92
        }
93
    }
94
 
95
  if (declp)
96
    {
97
      if (DECL_FUNCTION_MEMBER_P (supplicant))
98
        context = DECL_CONTEXT (supplicant);
99
      else
100
        context = NULL_TREE;
101
    }
102
  else
103
    {
104
      if (TYPE_CLASS_SCOPE_P (supplicant))
105
        /* Nested classes get the same access as their enclosing types, as
106
           per DR 45 (this is a change from the standard).  */
107
        context = TYPE_CONTEXT (supplicant);
108
      else
109
        /* Local classes have the same access as the enclosing function.  */
110
        context = decl_function_context (TYPE_MAIN_DECL (supplicant));
111
    }
112
 
113
  /* A namespace is not friend to anybody.  */
114
  if (context && TREE_CODE (context) == NAMESPACE_DECL)
115
    context = NULL_TREE;
116
 
117
  if (context)
118
    return is_friend (type, context);
119
 
120
  return 0;
121
}
122
 
123
/* Add a new friend to the friends of the aggregate type TYPE.
124
   DECL is the FUNCTION_DECL of the friend being added.
125
 
126
   If COMPLAIN is true, warning about duplicate friend is issued.
127
   We want to have this diagnostics during parsing but not
128
   when a template is being instantiated.  */
129
 
130
void
131
add_friend (tree type, tree decl, bool complain)
132
{
133
  tree typedecl;
134
  tree list;
135
  tree name;
136
  tree ctx;
137
 
138
  if (decl == error_mark_node)
139
    return;
140
 
141
  typedecl = TYPE_MAIN_DECL (type);
142
  list = DECL_FRIENDLIST (typedecl);
143
  name = DECL_NAME (decl);
144
  type = TREE_TYPE (typedecl);
145
 
146
  while (list)
147
    {
148
      if (name == FRIEND_NAME (list))
149
        {
150
          tree friends = FRIEND_DECLS (list);
151
          for (; friends ; friends = TREE_CHAIN (friends))
152
            {
153
              if (decl == TREE_VALUE (friends))
154
                {
155
                  if (complain)
156
                    warning (0, "%qD is already a friend of class %qT",
157
                             decl, type);
158
                  return;
159
                }
160
            }
161
 
162
          maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
163
 
164
          TREE_VALUE (list) = tree_cons (NULL_TREE, decl,
165
                                         TREE_VALUE (list));
166
          return;
167
        }
168
      list = TREE_CHAIN (list);
169
    }
170
 
171
  ctx = DECL_CONTEXT (decl);
172
  if (ctx && CLASS_TYPE_P (ctx) && !uses_template_parms (ctx))
173
    perform_or_defer_access_check (TYPE_BINFO (ctx), decl, decl);
174
 
175
  maybe_add_class_template_decl_list (type, decl, /*friend_p=*/1);
176
 
177
  DECL_FRIENDLIST (typedecl)
178
    = tree_cons (DECL_NAME (decl), build_tree_list (NULL_TREE, decl),
179
                 DECL_FRIENDLIST (typedecl));
180
  if (!uses_template_parms (type))
181
    DECL_BEFRIENDING_CLASSES (decl)
182
      = tree_cons (NULL_TREE, type,
183
                   DECL_BEFRIENDING_CLASSES (decl));
184
}
185
 
186
/* Make FRIEND_TYPE a friend class to TYPE.  If FRIEND_TYPE has already
187
   been defined, we make all of its member functions friends of
188
   TYPE.  If not, we make it a pending friend, which can later be added
189
   when its definition is seen.  If a type is defined, then its TYPE_DECL's
190
   DECL_UNDEFINED_FRIENDS contains a (possibly empty) list of friend
191
   classes that are not defined.  If a type has not yet been defined,
192
   then the DECL_WAITING_FRIENDS contains a list of types
193
   waiting to make it their friend.  Note that these two can both
194
   be in use at the same time!
195
 
196
   If COMPLAIN is true, warning about duplicate friend is issued.
197
   We want to have this diagnostics during parsing but not
198
   when a template is being instantiated.  */
199
 
200
void
201
make_friend_class (tree type, tree friend_type, bool complain)
202
{
203
  tree classes;
204
 
205
  /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
206
     the enclosing class.  FRIEND_DEPTH counts the number of template
207
     headers used for this friend declaration.  TEMPLATE_MEMBER_P,
208
     defined inside the `if' block for TYPENAME_TYPE case, is true if
209
     a template header in FRIEND_DEPTH is intended for DECLARATOR.
210
     For example, the code
211
 
212
       template <class T> struct A {
213
         template <class U> struct B {
214
           template <class V> template <class W>
215
             friend class C<V>::D;
216
         };
217
       };
218
 
219
     will eventually give the following results
220
 
221
     1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
222
     2. FRIEND_DEPTH equals 2 (for `V' and `W').
223
     3. TEMPLATE_MEMBER_P is true (for `W').
224
 
225
     The friend is a template friend iff FRIEND_DEPTH is nonzero.  */
226
 
227
  int class_template_depth = template_class_depth (type);
228
  int friend_depth = processing_template_decl - class_template_depth;
229
 
230
  if (! MAYBE_CLASS_TYPE_P (friend_type))
231
    {
232
      error ("invalid type %qT declared %<friend%>", friend_type);
233
      return;
234
    }
235
 
236
  if (friend_depth)
237
    /* If the TYPE is a template then it makes sense for it to be
238
       friends with itself; this means that each instantiation is
239
       friends with all other instantiations.  */
240
    {
241
      if (CLASS_TYPE_P (friend_type)
242
          && CLASSTYPE_TEMPLATE_SPECIALIZATION (friend_type)
243
          && uses_template_parms (friend_type))
244
        {
245
          /* [temp.friend]
246
             Friend declarations shall not declare partial
247
             specializations.  */
248
          error ("partial specialization %qT declared %<friend%>",
249
                 friend_type);
250
          return;
251
        }
252
    }
253
  else if (same_type_p (type, friend_type))
254
    {
255
      if (complain)
256
        warning (0, "class %qT is implicitly friends with itself",
257
                 type);
258
      return;
259
    }
260
 
261
  /* [temp.friend]
262
 
263
     A friend of a class or class template can be a function or
264
     class template, a specialization of a function template or
265
     class template, or an ordinary (nontemplate) function or
266
     class.  */
267
  if (!friend_depth)
268
    ;/* ok */
269
  else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
270
    {
271
      if (TREE_CODE (TYPENAME_TYPE_FULLNAME (friend_type))
272
          == TEMPLATE_ID_EXPR)
273
        {
274
          /* template <class U> friend class T::X<U>; */
275
          /* [temp.friend]
276
             Friend declarations shall not declare partial
277
             specializations.  */
278
          error ("partial specialization %qT declared %<friend%>",
279
                 friend_type);
280
          return;
281
        }
282
      else
283
        {
284
          /* We will figure this out later.  */
285
          bool template_member_p = false;
286
 
287
          tree ctype = TYPE_CONTEXT (friend_type);
288
          tree name = TYPE_IDENTIFIER (friend_type);
289
          tree decl;
290
 
291
          if (!uses_template_parms_level (ctype, class_template_depth
292
                                                 + friend_depth))
293
            template_member_p = true;
294
 
295
          if (class_template_depth)
296
            {
297
              /* We rely on tsubst_friend_class to check the
298
                 validity of the declaration later.  */
299
              if (template_member_p)
300
                friend_type
301
                  = make_unbound_class_template (ctype,
302
                                                 name,
303
                                                 current_template_parms,
304
                                                 tf_error);
305
              else
306
                friend_type
307
                  = make_typename_type (ctype, name, class_type, tf_error);
308
            }
309
          else
310
            {
311
              decl = lookup_member (ctype, name, 0, true);
312
              if (!decl)
313
                {
314
                  error ("%qT is not a member of %qT", name, ctype);
315
                  return;
316
                }
317
              if (template_member_p && !DECL_CLASS_TEMPLATE_P (decl))
318
                {
319
                  error ("%qT is not a member class template of %qT",
320
                         name, ctype);
321
                  error ("%q+D declared here", decl);
322
                  return;
323
                }
324
              if (!template_member_p && (TREE_CODE (decl) != TYPE_DECL
325
                                         || !CLASS_TYPE_P (TREE_TYPE (decl))))
326
                {
327
                  error ("%qT is not a nested class of %qT",
328
                         name, ctype);
329
                  error ("%q+D declared here", decl);
330
                  return;
331
                }
332
 
333
              friend_type = CLASSTYPE_TI_TEMPLATE (TREE_TYPE (decl));
334
            }
335
        }
336
    }
337
  else if (TREE_CODE (friend_type) == TEMPLATE_TYPE_PARM)
338
    {
339
      /* template <class T> friend class T; */
340
      error ("template parameter type %qT declared %<friend%>", friend_type);
341
      return;
342
    }
343
  else if (!CLASSTYPE_TEMPLATE_INFO (friend_type))
344
    {
345
      /* template <class T> friend class A; where A is not a template */
346
      error ("%q#T is not a template", friend_type);
347
      return;
348
    }
349
  else
350
    /* template <class T> friend class A; where A is a template */
351
    friend_type = CLASSTYPE_TI_TEMPLATE (friend_type);
352
 
353
  if (friend_type == error_mark_node)
354
    return;
355
 
356
  /* See if it is already a friend.  */
357
  for (classes = CLASSTYPE_FRIEND_CLASSES (type);
358
       classes;
359
       classes = TREE_CHAIN (classes))
360
    {
361
      tree probe = TREE_VALUE (classes);
362
 
363
      if (TREE_CODE (friend_type) == TEMPLATE_DECL)
364
        {
365
          if (friend_type == probe)
366
            {
367
              if (complain)
368
                warning (0, "%qD is already a friend of %qT", probe, type);
369
              break;
370
            }
371
        }
372
      else if (TREE_CODE (probe) != TEMPLATE_DECL)
373
        {
374
          if (same_type_p (probe, friend_type))
375
            {
376
              if (complain)
377
                warning (0, "%qT is already a friend of %qT", probe, type);
378
              break;
379
            }
380
        }
381
    }
382
 
383
  if (!classes)
384
    {
385
      maybe_add_class_template_decl_list (type, friend_type, /*friend_p=*/1);
386
 
387
      CLASSTYPE_FRIEND_CLASSES (type)
388
        = tree_cons (NULL_TREE, friend_type, CLASSTYPE_FRIEND_CLASSES (type));
389
      if (TREE_CODE (friend_type) == TEMPLATE_DECL)
390
        friend_type = TREE_TYPE (friend_type);
391
      if (!uses_template_parms (type))
392
        CLASSTYPE_BEFRIENDING_CLASSES (friend_type)
393
          = tree_cons (NULL_TREE, type,
394
                       CLASSTYPE_BEFRIENDING_CLASSES (friend_type));
395
    }
396
}
397
 
398
/* Record DECL (a FUNCTION_DECL) as a friend of the
399
   CURRENT_CLASS_TYPE.  If DECL is a member function, CTYPE is the
400
   class of which it is a member, as named in the friend declaration.
401
   DECLARATOR is the name of the friend.  FUNCDEF_FLAG is true if the
402
   friend declaration is a definition of the function.  FLAGS is as
403
   for grokclass fn.  */
404
 
405
tree
406
do_friend (tree ctype, tree declarator, tree decl,
407
           tree attrlist, enum overload_flags flags,
408
           bool funcdef_flag)
409
{
410
  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
411
  gcc_assert (!ctype || MAYBE_CLASS_TYPE_P (ctype));
412
 
413
  /* Every decl that gets here is a friend of something.  */
414
  DECL_FRIEND_P (decl) = 1;
415
 
416
  /* Unfortunately, we have to handle attributes here.  Normally we would
417
     handle them in start_decl_1, but since this is a friend decl start_decl_1
418
     never gets to see it.  */
419
 
420
  /* Set attributes here so if duplicate decl, will have proper attributes.  */
421
  cplus_decl_attributes (&decl, attrlist, 0);
422
 
423
  if (TREE_CODE (declarator) == TEMPLATE_ID_EXPR)
424
    {
425
      declarator = TREE_OPERAND (declarator, 0);
426
      if (is_overloaded_fn (declarator))
427
        declarator = DECL_NAME (get_first_fn (declarator));
428
    }
429
 
430
  if (ctype)
431
    {
432
      /* CLASS_TEMPLATE_DEPTH counts the number of template headers for
433
         the enclosing class.  FRIEND_DEPTH counts the number of template
434
         headers used for this friend declaration.  TEMPLATE_MEMBER_P is
435
         true if a template header in FRIEND_DEPTH is intended for
436
         DECLARATOR.  For example, the code
437
 
438
           template <class T> struct A {
439
             template <class U> struct B {
440
               template <class V> template <class W>
441
                 friend void C<V>::f(W);
442
             };
443
           };
444
 
445
         will eventually give the following results
446
 
447
         1. CLASS_TEMPLATE_DEPTH equals 2 (for `T' and `U').
448
         2. FRIEND_DEPTH equals 2 (for `V' and `W').
449
         3. TEMPLATE_MEMBER_P is true (for `W').  */
450
 
451
      int class_template_depth = template_class_depth (current_class_type);
452
      int friend_depth = processing_template_decl - class_template_depth;
453
      /* We will figure this out later.  */
454
      bool template_member_p = false;
455
 
456
      tree cname = TYPE_NAME (ctype);
457
      if (TREE_CODE (cname) == TYPE_DECL)
458
        cname = DECL_NAME (cname);
459
 
460
      /* A method friend.  */
461
      if (flags == NO_SPECIAL && declarator == cname)
462
        DECL_CONSTRUCTOR_P (decl) = 1;
463
 
464
      grokclassfn (ctype, decl, flags);
465
 
466
      if (friend_depth)
467
        {
468
          if (!uses_template_parms_level (ctype, class_template_depth
469
                                                 + friend_depth))
470
            template_member_p = true;
471
        }
472
 
473
      /* A nested class may declare a member of an enclosing class
474
         to be a friend, so we do lookup here even if CTYPE is in
475
         the process of being defined.  */
476
      if (class_template_depth
477
          || COMPLETE_TYPE_P (ctype)
478
          || (CLASS_TYPE_P (ctype) && TYPE_BEING_DEFINED (ctype)))
479
        {
480
          if (DECL_TEMPLATE_INFO (decl))
481
            /* DECL is a template specialization.  No need to
482
               build a new TEMPLATE_DECL.  */
483
            ;
484
          else if (class_template_depth)
485
            /* We rely on tsubst_friend_function to check the
486
               validity of the declaration later.  */
487
            decl = push_template_decl_real (decl, /*is_friend=*/true);
488
          else
489
            decl = check_classfn (ctype, decl,
490
                                  template_member_p
491
                                  ? current_template_parms
492
                                  : NULL_TREE);
493
 
494
          if (template_member_p && decl && TREE_CODE (decl) == FUNCTION_DECL)
495
            decl = DECL_TI_TEMPLATE (decl);
496
 
497
          if (decl)
498
            add_friend (current_class_type, decl, /*complain=*/true);
499
        }
500
      else
501
        error ("member %qD declared as friend before type %qT defined",
502
                  decl, ctype);
503
    }
504
  /* A global friend.
505
     @@ or possibly a friend from a base class ?!?  */
506
  else if (TREE_CODE (decl) == FUNCTION_DECL)
507
    {
508
      int is_friend_template = PROCESSING_REAL_TEMPLATE_DECL_P ();
509
 
510
      /* Friends must all go through the overload machinery,
511
         even though they may not technically be overloaded.
512
 
513
         Note that because classes all wind up being top-level
514
         in their scope, their friend wind up in top-level scope as well.  */
515
      if (funcdef_flag)
516
        SET_DECL_FRIEND_CONTEXT (decl, current_class_type);
517
 
518
      if (! DECL_USE_TEMPLATE (decl))
519
        {
520
          /* We must check whether the decl refers to template
521
             arguments before push_template_decl_real adds a
522
             reference to the containing template class.  */
523
          int warn = (warn_nontemplate_friend
524
                      && ! funcdef_flag && ! is_friend_template
525
                      && current_template_parms
526
                      && uses_template_parms (decl));
527
 
528
          if (is_friend_template
529
              || template_class_depth (current_class_type) != 0)
530
            /* We can't call pushdecl for a template class, since in
531
               general, such a declaration depends on template
532
               parameters.  Instead, we call pushdecl when the class
533
               is instantiated.  */
534
            decl = push_template_decl_real (decl, /*is_friend=*/true);
535
          else if (current_function_decl)
536
            {
537
              /* This must be a local class.  11.5p11:
538
 
539
                 If a friend declaration appears in a local class (9.8) and
540
                 the name specified is an unqualified name, a prior
541
                 declaration is looked up without considering scopes that
542
                 are outside the innermost enclosing non-class scope. For a
543
                 friend function declaration, if there is no prior
544
                 declaration, the program is ill-formed.  */
545
              tree t = lookup_name_innermost_nonclass_level (DECL_NAME (decl));
546
              if (t)
547
                decl = pushdecl_maybe_friend (decl, /*is_friend=*/true);
548
              else
549
                {
550
                  error ("friend declaration %qD in local class without "
551
                         "prior declaration", decl);
552
                  return error_mark_node;
553
                }
554
            }
555
          else
556
            {
557
              /* We can't use pushdecl, as we might be in a template
558
                 class specialization, and pushdecl will insert an
559
                 unqualified friend decl into the template parameter
560
                 scope, rather than the namespace containing it.  */
561
              tree ns = decl_namespace_context (decl);
562
 
563
              push_nested_namespace (ns);
564
              decl = pushdecl_namespace_level (decl, /*is_friend=*/true);
565
              pop_nested_namespace (ns);
566
            }
567
 
568
          if (warn)
569
            {
570
              static int explained;
571
              bool warned;
572
 
573
              warned = warning (OPT_Wnon_template_friend, "friend declaration "
574
                                "%q#D declares a non-template function", decl);
575
              if (! explained && warned)
576
                {
577
                  inform (input_location, "(if this is not what you intended, make sure "
578
                          "the function template has already been declared "
579
                          "and add <> after the function name here) ");
580
                  explained = 1;
581
                }
582
            }
583
        }
584
 
585
      if (decl == error_mark_node)
586
        return error_mark_node;
587
 
588
      add_friend (current_class_type,
589
                  is_friend_template ? DECL_TI_TEMPLATE (decl) : decl,
590
                  /*complain=*/true);
591
      DECL_FRIEND_P (decl) = 1;
592
    }
593
 
594
  return decl;
595
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.