![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-method.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to cp-method.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Handle the hair of processing (but not expanding) inline functions.
2: Also manage function and variable name overloading.
3: Copyright (C) 1987, 1989, 1992, 1993 Free Software Foundation, Inc.
4: Contributed by Michael Tiemann ([email protected])
5:
6: This file is part of GNU CC.
7:
8: GNU CC is free software; you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation; either version 2, or (at your option)
11: any later version.
12:
13: GNU CC is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with GNU CC; see the file COPYING. If not, write to
20: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21:
22:
23: #ifndef PARM_CAN_BE_ARRAY_TYPE
24: #define PARM_CAN_BE_ARRAY_TYPE 1
25: #endif
26:
27: /* Handle method declarations. */
28: #include <stdio.h>
29: #include "config.h"
30: #include "tree.h"
31: #include "cp-tree.h"
32: #include "cp-class.h"
33: #include "obstack.h"
34: #include <ctype.h>
35:
36: /* TREE_LIST of the current inline functions that need to be
37: processed. */
38: struct pending_inline *pending_inlines;
39:
40: #define obstack_chunk_alloc xmalloc
41: #define obstack_chunk_free free
42:
43: /* Obstack where we build text strings for overloading, etc. */
44: static struct obstack scratch_obstack;
45: static char *scratch_firstobj;
46:
47: # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
48: # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
49: # define OB_PUTC2(C1,C2) \
50: (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
51: # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
52: # define OB_PUTID(ID) \
53: (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \
54: IDENTIFIER_LENGTH (ID)))
55: # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
56: # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
57:
58: #ifdef NO_AUTO_OVERLOAD
59: int is_overloaded ();
60: #endif
61:
62: void
63: init_method ()
64: {
65: gcc_obstack_init (&scratch_obstack);
66: scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
67: }
68:
69: /* This must be large enough to hold any printed integer or floating-point
70: value. */
71: static char digit_buffer[128];
72:
73: /* Move inline function definitions out of structure so that they
74: can be processed normally. CNAME is the name of the class
75: we are working from, METHOD_LIST is the list of method lists
76: of the structure. We delete friend methods here, after
77: saving away their inline function definitions (if any). */
78:
79: void
80: do_inline_function_hair (type, friend_list)
81: tree type, friend_list;
82: {
83: tree method = TYPE_METHODS (type);
84:
85: if (method && TREE_CODE (method) == TREE_VEC)
86: {
87: if (TREE_VEC_ELT (method, 0))
88: method = TREE_VEC_ELT (method, 0);
89: else
90: method = TREE_VEC_ELT (method, 1);
91: }
92:
93: while (method)
94: {
95: /* Do inline member functions. */
96: struct pending_inline *info = DECL_PENDING_INLINE_INFO (method);
97: if (info)
98: {
99: tree args;
100:
101: my_friendly_assert (info->fndecl == method, 238);
102: args = DECL_ARGUMENTS (method);
103: while (args)
104: {
105: DECL_CONTEXT (args) = method;
106: args = TREE_CHAIN (args);
107: }
108:
109: /* Allow this decl to be seen in global scope */
110: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method;
111: }
112: method = TREE_CHAIN (method);
113: }
114: while (friend_list)
115: {
116: tree fndecl = TREE_VALUE (friend_list);
117: struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl);
118: if (info)
119: {
120: tree args;
121:
122: my_friendly_assert (info->fndecl == fndecl, 239);
123: args = DECL_ARGUMENTS (fndecl);
124: while (args)
125: {
126: DECL_CONTEXT (args) = fndecl;
127: args = TREE_CHAIN (args);
128: }
129:
130: /* Allow this decl to be seen in global scope */
131: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl;
132: }
133:
134: friend_list = TREE_CHAIN (friend_list);
135: }
136: }
137:
138: /* Report an argument type mismatch between the best declared function
139: we could find and the current argument list that we have. */
140: void
141: report_type_mismatch (cp, parmtypes, name_kind, err_name)
142: struct candidate *cp;
143: tree parmtypes;
144: char *name_kind, *err_name;
145: {
146: int i = cp->u.bad_arg;
147: tree ttf, tta;
148: char *tmp_firstobj;
149:
150: switch (i)
151: {
152: case -4:
153: my_friendly_assert (TREE_CODE (cp->function) == TEMPLATE_DECL, 240);
154: error ("type unification failed for function template `%s'", err_name);
155: return;
156:
157: case -3:
158: if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
159: error ("call to const %s `%s' with non-const object", name_kind, err_name);
160: else
161: error ("call to non-const %s `%s' with const object", name_kind, err_name);
162: return;
163: case -2:
164: error ("too few arguments for %s `%s'", name_kind, err_name);
165: return;
166: case -1:
167: error ("too many arguments for %s `%s'", name_kind, err_name);
168: return;
169: case 0:
170: if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
171: {
172: /* Happens when we have an ambiguous base class. */
173: my_friendly_assert (get_binfo (DECL_CLASS_CONTEXT (cp->function),
174: TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node,
175: 241);
176: return;
177: }
178: }
179:
180: ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function));
181: tta = parmtypes;
182:
183: while (i-- > 0)
184: {
185: ttf = TREE_CHAIN (ttf);
186: tta = TREE_CHAIN (tta);
187: }
188:
189: OB_INIT ();
190: OB_PUTS ("bad argument ");
191: sprintf (digit_buffer, "%d", cp->u.bad_arg
192: - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
193: + 1);
194: OB_PUTCP (digit_buffer);
195:
196: OB_PUTS (" for function `");
197: OB_PUTCP (decl_as_string (cp->function, 1));
198: OB_PUTS ("' (type was ");
199:
200: /* Reset `i' so that type printing routines do the right thing. */
201: if (tta)
202: {
203: enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta)));
204: if (code == ERROR_MARK)
205: OB_PUTS ("(failed type instantiation)");
206: else
207: {
208: i = (code == FUNCTION_TYPE || code == METHOD_TYPE);
209: OB_PUTCP (type_as_string (TREE_TYPE (TREE_VALUE (tta)), 1));
210: }
211: }
212: else OB_PUTS ("void");
213: OB_PUTC (')');
214: OB_FINISH ();
215:
216: tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack));
217: bcopy (obstack_base (&scratch_obstack), tmp_firstobj,
218: obstack_object_size (&scratch_obstack));
219: error (tmp_firstobj);
220: }
221:
222: /* Here is where overload code starts. */
223:
224: /* Array of types seen so far in top-level call to `build_overload_name'.
225: Allocated and deallocated by caller. */
226: static tree *typevec;
227:
228: /* Number of types interned by `build_overload_name' so far. */
229: static int maxtype;
230:
231: /* Number of occurrences of last type seen. */
232: static int nrepeats;
233:
234: /* Nonzero if we should not try folding parameter types. */
235: static int nofold;
236:
237: #define ALLOCATE_TYPEVEC(PARMTYPES) \
238: do { maxtype = 0, nrepeats = 0; \
239: typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0)
240:
241: #define DEALLOCATE_TYPEVEC(PARMTYPES) \
242: do { tree t = (PARMTYPES); \
243: while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \
244: } while (0)
245:
246: /* Code to concatenate an asciified integer to a string. */
247: static
248: #ifdef __GNUC__
249: __inline
250: #endif
251: void
252: icat (i)
253: int i;
254: {
255: /* Handle this case first, to go really quickly. For many common values,
256: the result of i/10 below is 1. */
257: if (i == 1)
258: {
259: OB_PUTC ('1');
260: return;
261: }
262:
263: if (i < 0)
264: {
265: OB_PUTC ('m');
266: i = -i;
267: }
268: if (i < 10)
269: OB_PUTC ('0' + i);
270: else
271: {
272: icat (i / 10);
273: OB_PUTC ('0' + (i % 10));
274: }
275: }
276:
277: static
278: #ifdef __GNUC__
279: __inline
280: #endif
281: void
282: flush_repeats (type)
283: tree type;
284: {
285: int tindex = 0;
286:
287: while (typevec[tindex] != type)
288: tindex++;
289:
290: if (nrepeats > 1)
291: {
292: OB_PUTC ('N');
293: icat (nrepeats);
294: if (nrepeats > 9)
295: OB_PUTC ('_');
296: }
297: else
298: OB_PUTC ('T');
299: nrepeats = 0;
300: icat (tindex);
301: if (tindex > 9)
302: OB_PUTC ('_');
303: }
304:
305: static void build_overload_identifier ();
306:
307: static void
308: build_overload_nested_name (context)
309: tree context;
310: {
311: /* We use DECL_NAME here, because pushtag now sets the DECL_ASSEMBLER_NAME. */
312: tree name = DECL_NAME (context);
313: if (DECL_CONTEXT (context))
314: {
315: context = DECL_CONTEXT (context);
316: if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
317: context = TYPE_NAME (context);
318: build_overload_nested_name (context);
319: }
320: build_overload_identifier (name);
321: }
322:
323: static void
324: build_overload_value (type, value)
325: tree type, value;
326: {
327: while (TREE_CODE (value) == NON_LVALUE_EXPR
328: || TREE_CODE (value) == NOP_EXPR)
329: value = TREE_OPERAND (value, 0);
330: my_friendly_assert (TREE_CODE (type) == PARM_DECL, 242);
331: type = TREE_TYPE (type);
332: switch (TREE_CODE (type))
333: {
334: case INTEGER_TYPE:
335: case ENUMERAL_TYPE:
336: {
337: my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
338: if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
339: {
340: if (tree_int_cst_lt (value, integer_zero_node))
341: {
342: OB_PUTC ('m');
343: value = build_int_2 (~ TREE_INT_CST_LOW (value),
344: - TREE_INT_CST_HIGH (value));
345: }
346: if (TREE_INT_CST_HIGH (value)
347: != (TREE_INT_CST_LOW (value) >> (HOST_BITS_PER_WIDE_INT - 1)))
348: {
349: /* need to print a DImode value in decimal */
350: sorry ("conversion of long long as PT parameter");
351: }
352: /* else fall through to print in smaller mode */
353: }
354: /* Wordsize or smaller */
355: icat (TREE_INT_CST_LOW (value));
356: return;
357: }
358: #ifndef REAL_IS_NOT_DOUBLE
359: case REAL_TYPE:
360: {
361: REAL_VALUE_TYPE val;
362: char *bufp = digit_buffer;
363: extern char *index ();
364:
365: my_friendly_assert (TREE_CODE (value) == REAL_CST, 244);
366: val = TREE_REAL_CST (value);
367: if (val < 0)
368: {
369: val = -val;
370: *bufp++ = 'm';
371: }
372: sprintf (bufp, "%e", val);
373: bufp = (char *) index (bufp, 'e');
374: if (!bufp)
375: strcat (digit_buffer, "e0");
376: else
377: {
378: char *p;
379: bufp++;
380: if (*bufp == '-')
381: {
382: *bufp++ = 'm';
383: }
384: p = bufp;
385: if (*p == '+')
386: p++;
387: while (*p == '0')
388: p++;
389: if (*p == 0)
390: {
391: *bufp++ = '0';
392: *bufp = 0;
393: }
394: else if (p != bufp)
395: {
396: while (*p)
397: *bufp++ = *p++;
398: *bufp = 0;
399: }
400: }
401: OB_PUTCP (digit_buffer);
402: return;
403: }
404: #endif
405: case POINTER_TYPE:
406: value = TREE_OPERAND (value, 0);
407: if (TREE_CODE (value) == VAR_DECL)
408: {
409: my_friendly_assert (DECL_NAME (value) != 0, 245);
410: build_overload_identifier (DECL_NAME (value));
411: return;
412: }
413: else if (TREE_CODE (value) == FUNCTION_DECL)
414: {
415: my_friendly_assert (DECL_NAME (value) != 0, 246);
416: build_overload_identifier (DECL_NAME (value));
417: return;
418: }
419: else
420: my_friendly_abort (71);
421: break; /* not really needed */
422:
423: default:
424: sorry ("conversion of %s as template parameter",
425: tree_code_name [(int) TREE_CODE (type)]);
426: my_friendly_abort (72);
427: }
428: }
429:
430: static void
431: build_overload_identifier (name)
432: tree name;
433: {
434: if (IDENTIFIER_TEMPLATE (name))
435: {
436: tree template, parmlist, arglist, tname;
437: int i, nparms;
438: template = IDENTIFIER_TEMPLATE (name);
439: arglist = TREE_VALUE (template);
440: template = TREE_PURPOSE (template);
441: tname = DECL_NAME (template);
442: parmlist = DECL_ARGUMENTS (template);
443: nparms = TREE_VEC_LENGTH (parmlist);
444: OB_PUTC ('t');
445: icat (IDENTIFIER_LENGTH (tname));
446: OB_PUTID (tname);
447: icat (nparms);
448: for (i = 0; i < nparms; i++)
449: {
450: tree parm = TREE_VEC_ELT (parmlist, i);
451: tree arg = TREE_VEC_ELT (arglist, i);
452: if (TREE_CODE (parm) == IDENTIFIER_NODE)
453: {
454: /* This parameter is a type. */
455: OB_PUTC ('Z');
456: build_overload_name (arg, 0, 0);
457: }
458: else
459: {
460: /* It's a PARM_DECL. */
461: build_overload_name (TREE_TYPE (parm), 0, 0);
462: build_overload_value (parm, arg);
463: }
464: }
465: }
466: else
467: {
468: icat (IDENTIFIER_LENGTH (name));
469: OB_PUTID (name);
470: }
471: }
472:
473: /* Given a list of parameters in PARMTYPES, create an unambiguous
474: overload string. Should distinguish any type that C (or C++) can
475: distinguish. I.e., pointers to functions are treated correctly.
476:
477: Caller must deal with whether a final `e' goes on the end or not.
478:
479: Any default conversions must take place before this function
480: is called.
481:
482: BEGIN and END control initialization and finalization of the
483: obstack where we build the string. */
484:
485: char *
486: build_overload_name (parmtypes, begin, end)
487: tree parmtypes;
488: int begin, end;
489: {
490: int just_one;
491: tree parmtype;
492:
493: if (begin) OB_INIT ();
494:
495: if (just_one = (TREE_CODE (parmtypes) != TREE_LIST))
496: {
497: parmtype = parmtypes;
498: goto only_one;
499: }
500:
501: while (parmtypes)
502: {
503: parmtype = TREE_VALUE (parmtypes);
504:
505: only_one:
506:
507: if (! nofold)
508: {
509: if (! just_one)
510: /* Every argument gets counted. */
511: typevec[maxtype++] = parmtype;
512:
513: if (TREE_USED (parmtype))
514: {
515: if (! just_one && parmtype == typevec[maxtype-2])
516: nrepeats++;
517: else
518: {
519: if (nrepeats)
520: flush_repeats (parmtype);
521: if (! just_one && TREE_CHAIN (parmtypes)
522: && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
523: nrepeats++;
524: else
525: {
526: int tindex = 0;
527:
528: while (typevec[tindex] != parmtype)
529: tindex++;
530: OB_PUTC ('T');
531: icat (tindex);
532: if (tindex > 9)
533: OB_PUTC ('_');
534: }
535: }
536: goto next;
537: }
538: if (nrepeats)
539: flush_repeats (typevec[maxtype-2]);
540: if (! just_one
541: /* Only cache types which take more than one character. */
542: && (parmtype != TYPE_MAIN_VARIANT (parmtype)
543: || (TREE_CODE (parmtype) != INTEGER_TYPE
544: && TREE_CODE (parmtype) != REAL_TYPE)))
545: TREE_USED (parmtype) = 1;
546: }
547:
548: if (TYPE_PTRMEMFUNC_P (parmtype))
549: parmtype = TYPE_PTRMEMFUNC_FN_TYPE (parmtype);
550:
551: if (TREE_READONLY (parmtype))
552: OB_PUTC ('C');
553: if (TREE_CODE (parmtype) == INTEGER_TYPE
554: && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
555: OB_PUTC ('U');
556: if (TYPE_VOLATILE (parmtype))
557: OB_PUTC ('V');
558:
559: switch (TREE_CODE (parmtype))
560: {
561: case OFFSET_TYPE:
562: OB_PUTC ('O');
563: build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
564: OB_PUTC ('_');
565: build_overload_name (TREE_TYPE (parmtype), 0, 0);
566: break;
567:
568: case REFERENCE_TYPE:
569: OB_PUTC ('R');
570: goto more;
571:
572: case ARRAY_TYPE:
573: #if PARM_CAN_BE_ARRAY_TYPE
574: {
575: tree length;
576:
577: OB_PUTC ('A');
578: if (TYPE_DOMAIN (parmtype) == NULL_TREE)
579: {
580: error ("parameter type with unspecified array bounds invalid");
581: icat (1);
582: }
583: else
584: {
585: length = array_type_nelts (parmtype);
586: if (TREE_CODE (length) == INTEGER_CST)
587: icat (TREE_INT_CST_LOW (length) + 1);
588: }
589: OB_PUTC ('_');
590: goto more;
591: }
592: #else
593: OB_PUTC ('P');
594: goto more;
595: #endif
596:
597: case POINTER_TYPE:
598: OB_PUTC ('P');
599: more:
600: build_overload_name (TREE_TYPE (parmtype), 0, 0);
601: break;
602:
603: case FUNCTION_TYPE:
604: case METHOD_TYPE:
605: {
606: tree firstarg = TYPE_ARG_TYPES (parmtype);
607: /* Otherwise have to implement reentrant typevecs,
608: unmark and remark types, etc. */
609: int old_nofold = nofold;
610: nofold = 1;
611:
612: if (nrepeats)
613: flush_repeats (typevec[maxtype-1]);
614:
615: /* @@ It may be possible to pass a function type in
616: which is not preceded by a 'P'. */
617: if (TREE_CODE (parmtype) == FUNCTION_TYPE)
618: {
619: OB_PUTC ('F');
620: if (firstarg == NULL_TREE)
621: OB_PUTC ('e');
622: else if (firstarg == void_list_node)
623: OB_PUTC ('v');
624: else
625: build_overload_name (firstarg, 0, 0);
626: }
627: else
628: {
629: int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
630: int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
631: OB_PUTC ('M');
632: firstarg = TREE_CHAIN (firstarg);
633:
634: build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
635: if (constp)
636: OB_PUTC ('C');
637: if (volatilep)
638: OB_PUTC ('V');
639:
640: /* For cfront 2.0 compatibility. */
641: OB_PUTC ('F');
642:
643: if (firstarg == NULL_TREE)
644: OB_PUTC ('e');
645: else if (firstarg == void_list_node)
646: OB_PUTC ('v');
647: else
648: build_overload_name (firstarg, 0, 0);
649: }
650:
651: /* Separate args from return type. */
652: OB_PUTC ('_');
653: build_overload_name (TREE_TYPE (parmtype), 0, 0);
654: nofold = old_nofold;
655: break;
656: }
657:
658: case INTEGER_TYPE:
659: parmtype = TYPE_MAIN_VARIANT (parmtype);
660: if (parmtype == integer_type_node
661: || parmtype == unsigned_type_node)
662: OB_PUTC ('i');
663: else if (parmtype == long_integer_type_node
664: || parmtype == long_unsigned_type_node)
665: OB_PUTC ('l');
666: else if (parmtype == short_integer_type_node
667: || parmtype == short_unsigned_type_node)
668: OB_PUTC ('s');
669: else if (parmtype == signed_char_type_node)
670: {
671: OB_PUTC ('S');
672: OB_PUTC ('c');
673: }
674: else if (parmtype == char_type_node
675: || parmtype == unsigned_char_type_node)
676: OB_PUTC ('c');
677: else if (parmtype == wchar_type_node)
678: OB_PUTC ('w');
679: else if (parmtype == long_long_integer_type_node
680: || parmtype == long_long_unsigned_type_node)
681: OB_PUTC ('x');
682: #if 0
683: /* it would seem there is no way to enter these in source code,
684: yet. (mrs) */
685: else if (parmtype == long_long_long_integer_type_node
686: || parmtype == long_long_long_unsigned_type_node)
687: OB_PUTC ('q');
688: #endif
689: else
690: my_friendly_abort (73);
691: break;
692:
693: case REAL_TYPE:
694: parmtype = TYPE_MAIN_VARIANT (parmtype);
695: if (parmtype == long_double_type_node)
696: OB_PUTC ('r');
697: else if (parmtype == double_type_node)
698: OB_PUTC ('d');
699: else if (parmtype == float_type_node)
700: OB_PUTC ('f');
701: else my_friendly_abort (74);
702: break;
703:
704: case VOID_TYPE:
705: if (! just_one)
706: {
707: #if 0
708: extern tree void_list_node;
709:
710: /* See if anybody is wasting memory. */
711: my_friendly_assert (parmtypes == void_list_node, 247);
712: #endif
713: /* This is the end of a parameter list. */
714: if (end) OB_FINISH ();
715: return (char *)obstack_base (&scratch_obstack);
716: }
717: OB_PUTC ('v');
718: break;
719:
720: case ERROR_MARK: /* not right, but nothing is anyway */
721: break;
722:
723: /* have to do these */
724: case UNION_TYPE:
725: case RECORD_TYPE:
726: if (! just_one)
727: /* Make this type signature look incompatible
728: with AT&T. */
729: OB_PUTC ('G');
730: goto common;
731: case ENUMERAL_TYPE:
732: common:
733: {
734: tree name = TYPE_NAME (parmtype);
735: int i = 1;
736:
737: if (TREE_CODE (name) == TYPE_DECL)
738: {
739: tree context = name;
740: while (DECL_CONTEXT (context))
741: {
742: i += 1;
743: context = DECL_CONTEXT (context);
744: if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
745: context = TYPE_NAME (context);
746: }
747: name = DECL_NAME (name);
748: }
749: my_friendly_assert (TREE_CODE (name) == IDENTIFIER_NODE, 248);
750: if (i > 1)
751: {
752: OB_PUTC ('Q');
753: if (i > 9)
754: OB_PUTC ('_');
755: icat (i);
756: if (i > 9)
757: OB_PUTC ('_');
758: build_overload_nested_name (TYPE_NAME (parmtype));
759: }
760: else
761: build_overload_identifier (name);
762: break;
763: }
764:
765: case UNKNOWN_TYPE:
766: /* This will take some work. */
767: OB_PUTC ('?');
768: break;
769:
770: case TEMPLATE_TYPE_PARM:
771: case TEMPLATE_CONST_PARM:
772: case UNINSTANTIATED_P_TYPE:
773: /* We don't ever want this output, but it's inconvenient not to
774: be able to build the string. This should cause assembler
775: errors we'll notice. */
776: {
777: static int n;
778: sprintf (digit_buffer, " *%d", n++);
779: OB_PUTCP (digit_buffer);
780: }
781: break;
782:
783: default:
784: my_friendly_abort (75);
785: }
786:
787: next:
788: if (just_one) break;
789: parmtypes = TREE_CHAIN (parmtypes);
790: }
791: if (! just_one)
792: {
793: if (nrepeats)
794: flush_repeats (typevec[maxtype-1]);
795:
796: /* To get here, parms must end with `...'. */
797: OB_PUTC ('e');
798: }
799:
800: if (end) OB_FINISH ();
801: return (char *)obstack_base (&scratch_obstack);
802: }
803:
804: /* Generate an identifier that encodes the (ANSI) exception TYPE. */
805:
806: /* This should be part of `ansi_opname', or at least be defined by the std. */
807: #define EXCEPTION_NAME_PREFIX "__ex"
808: #define EXCEPTION_NAME_LENGTH 4
809:
810: tree
811: cplus_exception_name (type)
812: tree type;
813: {
814: OB_INIT ();
815: OB_PUTS (EXCEPTION_NAME_PREFIX);
816: return get_identifier (build_overload_name (type, 0, 1));
817: }
818:
819: /* Change the name of a function definition so that it may be
820: overloaded. NAME is the name of the function to overload,
821: PARMS is the parameter list (which determines what name the
822: final function obtains).
823:
824: FOR_METHOD is 1 if this overload is being performed
825: for a method, rather than a function type. It is 2 if
826: this overload is being performed for a constructor. */
827: tree
828: build_decl_overload (dname, parms, for_method)
829: tree dname;
830: tree parms;
831: int for_method;
832: {
833: char *name = IDENTIFIER_POINTER (dname);
834:
835: if (dname == ansi_opname[(int) NEW_EXPR]
836: && parms != NULL_TREE
837: && TREE_CODE (parms) == TREE_LIST
838: && TREE_VALUE (parms) == sizetype
839: && TREE_CHAIN (parms) == void_list_node)
840: return get_identifier ("__builtin_new");
841: else if (dname == ansi_opname[(int) DELETE_EXPR]
842: && parms != NULL_TREE
843: && TREE_CODE (parms) == TREE_LIST
844: && TREE_VALUE (parms) == ptr_type_node
845: && TREE_CHAIN (parms) == void_list_node)
846: return get_identifier ("__builtin_delete");
847: else if (dname == ansi_opname[(int) DELETE_EXPR]
848: && parms != NULL_TREE
849: && TREE_CODE (parms) == TREE_LIST
850: && TREE_VALUE (parms) == ptr_type_node
851: && TREE_CHAIN (parms) != NULL_TREE
852: && TREE_CODE (TREE_CHAIN (parms)) == TREE_LIST
853: && TREE_VALUE (TREE_CHAIN (parms)) == sizetype
854: && TREE_CHAIN (TREE_CHAIN (parms)) == void_list_node)
855: return get_identifier ("__builtin_delete");
856:
857: OB_INIT ();
858: if (for_method != 2)
859: OB_PUTCP (name);
860: /* Otherwise, we can divine that this is a constructor,
861: and figure out its name without any extra encoding. */
862:
863: OB_PUTC2 ('_', '_');
864: if (for_method)
865: {
866: #if 0
867: /* We can get away without doing this. */
868: OB_PUTC ('M');
869: #endif
870: parms = temp_tree_cons (NULL_TREE, TREE_TYPE (TREE_VALUE (parms)), TREE_CHAIN (parms));
871: }
872: else
873: OB_PUTC ('F');
874:
875: if (parms == NULL_TREE)
876: OB_PUTC2 ('e', '\0');
877: else if (parms == void_list_node)
878: OB_PUTC2 ('v', '\0');
879: else
880: {
881: ALLOCATE_TYPEVEC (parms);
882: nofold = 0;
883: if (for_method)
884: {
885: build_overload_name (TREE_VALUE (parms), 0, 0);
886:
887: typevec[maxtype++] = TREE_VALUE (parms);
888: TREE_USED (TREE_VALUE (parms)) = 1;
889:
890: if (TREE_CHAIN (parms))
891: build_overload_name (TREE_CHAIN (parms), 0, 1);
892: else
893: OB_PUTC2 ('e', '\0');
894: }
895: else
896: build_overload_name (parms, 0, 1);
897: DEALLOCATE_TYPEVEC (parms);
898: }
899: {
900: tree n = get_identifier (obstack_base (&scratch_obstack));
901: if (IDENTIFIER_OPNAME_P (dname))
902: IDENTIFIER_OPNAME_P (n) = 1;
903: return n;
904: }
905: }
906:
907: /* Build an overload name for the type expression TYPE. */
908: tree
909: build_typename_overload (type)
910: tree type;
911: {
912: tree id;
913:
914: OB_INIT ();
915: OB_PUTID (ansi_opname[(int) TYPE_EXPR]);
916: nofold = 1;
917: build_overload_name (type, 0, 1);
918: id = get_identifier (obstack_base (&scratch_obstack));
919: IDENTIFIER_OPNAME_P (id) = 1;
920: return id;
921: }
922:
923: #ifndef NO_DOLLAR_IN_LABEL
924: #define T_DESC_FORMAT "TD$"
925: #define I_DESC_FORMAT "ID$"
926: #define M_DESC_FORMAT "MD$"
927: #else
928: #if !defined(NO_DOT_IN_LABEL)
929: #define T_DESC_FORMAT "TD."
930: #define I_DESC_FORMAT "ID."
931: #define M_DESC_FORMAT "MD."
932: #else
933: #define T_DESC_FORMAT "__t_desc_"
934: #define I_DESC_FORMAT "__i_desc_"
935: #define M_DESC_FORMAT "__m_desc_"
936: #endif
937: #endif
938:
939: /* Build an overload name for the type expression TYPE. */
940: tree
941: build_t_desc_overload (type)
942: tree type;
943: {
944: OB_INIT ();
945: OB_PUTS (T_DESC_FORMAT);
946: nofold = 1;
947:
948: #if 0
949: /* Use a different format if the type isn't defined yet. */
950: if (TYPE_SIZE (type) == NULL_TREE)
951: {
952: char *p;
953: int changed;
954:
955: for (p = tname; *p; p++)
956: if (isupper (*p))
957: {
958: changed = 1;
959: *p = tolower (*p);
960: }
961: /* If there's no change, we have an inappropriate T_DESC_FORMAT. */
962: my_friendly_assert (changed != 0, 249);
963: }
964: #endif
965:
966: build_overload_name (type, 0, 1);
967: return get_identifier (obstack_base (&scratch_obstack));
968: }
969:
970: /* Top-level interface to explicit overload requests. Allow NAME
971: to be overloaded. Error if NAME is already declared for the current
972: scope. Warning if function is redundantly overloaded. */
973:
974: void
975: declare_overloaded (name)
976: tree name;
977: {
978: #ifdef NO_AUTO_OVERLOAD
979: if (is_overloaded (name))
980: warning ("function `%s' already declared overloaded",
981: IDENTIFIER_POINTER (name));
982: else if (IDENTIFIER_GLOBAL_VALUE (name))
983: error ("overloading function `%s' that is already defined",
984: IDENTIFIER_POINTER (name));
985: else
986: {
987: TREE_OVERLOADED (name) = 1;
988: IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
989: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
990: }
991: #else
992: if (current_lang_name == lang_name_cplusplus)
993: {
994: if (0)
995: warning ("functions are implicitly overloaded in C++");
996: }
997: else if (current_lang_name == lang_name_c)
998: error ("overloading function `%s' cannot be done in C language context");
999: else
1000: my_friendly_abort (76);
1001: #endif
1002: }
1003:
1004: #ifdef NO_AUTO_OVERLOAD
1005: /* Check to see if NAME is overloaded. For first approximation,
1006: check to see if its TREE_OVERLOADED is set. This is used on
1007: IDENTIFIER nodes. */
1008: int
1009: is_overloaded (name)
1010: tree name;
1011: {
1012: /* @@ */
1013: return (TREE_OVERLOADED (name)
1014: && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
1015: && ! IDENTIFIER_LOCAL_VALUE (name));
1016: }
1017: #endif
1018:
1019: /* Given a tree_code CODE, and some arguments (at least one),
1020: attempt to use an overloaded operator on the arguments.
1021:
1022: For unary operators, only the first argument need be checked.
1023: For binary operators, both arguments may need to be checked.
1024:
1025: Member functions can convert class references to class pointers,
1026: for one-level deep indirection. More than that is not supported.
1027: Operators [](), ()(), and ->() must be member functions.
1028:
1029: We call function call building calls with nonzero complain if
1030: they are our only hope. This is true when we see a vanilla operator
1031: applied to something of aggregate type. If this fails, we are free to
1032: return `error_mark_node', because we will have reported the error.
1033:
1034: Operators NEW and DELETE overload in funny ways: operator new takes
1035: a single `size' parameter, and operator delete takes a pointer to the
1036: storage being deleted. When overloading these operators, success is
1037: assumed. If there is a failure, report an error message and return
1038: `error_mark_node'. */
1039:
1040: /* NOSTRICT */
1041: tree
1042: build_opfncall (code, flags, xarg1, xarg2, arg3)
1043: enum tree_code code;
1044: int flags;
1045: tree xarg1, xarg2, arg3;
1046: {
1047: tree rval = 0;
1048: tree arg1, arg2;
1049: tree type1, type2, fnname;
1050: tree fields1 = 0, parms = 0;
1051: tree global_fn;
1052: int try_second;
1053: int binary_is_unary;
1054:
1055: if (xarg1 == error_mark_node)
1056: return error_mark_node;
1057:
1058: if (code == COND_EXPR)
1059: {
1060: if (TREE_CODE (xarg2) == ERROR_MARK
1061: || TREE_CODE (arg3) == ERROR_MARK)
1062: return error_mark_node;
1063: }
1064: if (code == COMPONENT_REF)
1065: if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
1066: return rval;
1067:
1068: /* First, see if we can work with the first argument */
1069: type1 = TREE_TYPE (xarg1);
1070:
1071: /* Some tree codes have length > 1, but we really only want to
1072: overload them if their first argument has a user defined type. */
1073: switch (code)
1074: {
1075: case PREINCREMENT_EXPR:
1076: case PREDECREMENT_EXPR:
1077: case POSTINCREMENT_EXPR:
1078: case POSTDECREMENT_EXPR:
1079: case COMPONENT_REF:
1080: binary_is_unary = 1;
1081: try_second = 0;
1082: break;
1083:
1084: /* ARRAY_REFs and CALL_EXPRs must overload successfully.
1085: If they do not, return error_mark_node instead of NULL_TREE. */
1086: case ARRAY_REF:
1087: if (xarg2 == error_mark_node)
1088: return error_mark_node;
1089: case CALL_EXPR:
1090: rval = error_mark_node;
1091: binary_is_unary = 0;
1092: try_second = 0;
1093: break;
1094:
1095: case NEW_EXPR:
1096: {
1097: /* For operators `new' (`delete'), only check visibility
1098: if we are in a constructor (destructor), and we are
1099: allocating for that constructor's (destructor's) type. */
1100:
1101: fnname = ansi_opname[(int) NEW_EXPR];
1102: if (flags & LOOKUP_GLOBAL)
1103: return build_overload_call (fnname, tree_cons (NULL_TREE, xarg2, arg3),
1104: flags & LOOKUP_COMPLAIN,
1105: (struct candidate *)0);
1106:
1107: if (current_function_decl == NULL_TREE
1108: || !DECL_CONSTRUCTOR_P (current_function_decl)
1109: || current_class_type != TYPE_MAIN_VARIANT (type1))
1110: flags = LOOKUP_COMPLAIN;
1111: rval = build_method_call (build1 (NOP_EXPR, xarg1, error_mark_node),
1112: fnname, tree_cons (NULL_TREE, xarg2, arg3),
1113: NULL_TREE, flags);
1114: if (rval == error_mark_node)
1115: /* User might declare fancy operator new, but invoke it
1116: like standard one. */
1117: return rval;
1118:
1119: TREE_TYPE (rval) = xarg1;
1120: TREE_CALLS_NEW (rval) = 1;
1121: return rval;
1122: }
1123: break;
1124:
1125: case DELETE_EXPR:
1126: {
1127: /* See comment above. */
1128:
1129: fnname = ansi_opname[(int) DELETE_EXPR];
1130: if (flags & LOOKUP_GLOBAL)
1131: return build_overload_call (fnname,
1132: tree_cons (NULL_TREE, xarg1,
1133: build_tree_list (NULL_TREE, xarg2)),
1134: flags & LOOKUP_COMPLAIN,
1135: (struct candidate *)0);
1136:
1137: if (current_function_decl == NULL_TREE
1138: || !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl))
1139: || current_class_type != TYPE_MAIN_VARIANT (type1))
1140: flags = LOOKUP_COMPLAIN;
1141: rval = build_method_call (build1 (NOP_EXPR, TREE_TYPE (xarg1),
1142: error_mark_node),
1143: fnname, tree_cons (NULL_TREE, xarg1,
1144: build_tree_list (NULL_TREE, xarg2)),
1145: NULL_TREE, flags);
1146: /* This happens when the user mis-declares `operator delete'.
1147: Should now be impossible. */
1148: my_friendly_assert (rval != error_mark_node, 250);
1149: TREE_TYPE (rval) = void_type_node;
1150: return rval;
1151: }
1152: break;
1153:
1154: default:
1155: binary_is_unary = 0;
1156: try_second = tree_code_length [(int) code] == 2;
1157: if (try_second && xarg2 == error_mark_node)
1158: return error_mark_node;
1159: break;
1160: }
1161:
1162: if (try_second && xarg2 == error_mark_node)
1163: return error_mark_node;
1164:
1165: /* What ever it was, we do not know how to deal with it. */
1166: if (type1 == NULL_TREE)
1167: return rval;
1168:
1169: if (TREE_CODE (type1) == OFFSET_TYPE)
1170: type1 = TREE_TYPE (type1);
1171:
1172: if (TREE_CODE (type1) == REFERENCE_TYPE)
1173: {
1174: arg1 = convert_from_reference (xarg1);
1175: type1 = TREE_TYPE (arg1);
1176: }
1177: else
1178: {
1179: arg1 = xarg1;
1180: }
1181:
1182: if (!IS_AGGR_TYPE (type1))
1183: {
1184: /* Try to fail. First, fail if unary */
1185: if (! try_second)
1186: return rval;
1187: /* Second, see if second argument is non-aggregate. */
1188: type2 = TREE_TYPE (xarg2);
1189: if (TREE_CODE (type2) == OFFSET_TYPE)
1190: type2 = TREE_TYPE (type2);
1191: if (TREE_CODE (type2) == REFERENCE_TYPE)
1192: {
1193: arg2 = convert_from_reference (xarg2);
1194: type2 = TREE_TYPE (arg2);
1195: }
1196: else
1197: {
1198: arg2 = xarg2;
1199: }
1200:
1201: if (!IS_AGGR_TYPE (type2))
1202: return rval;
1203: try_second = 0;
1204: }
1205:
1206: if (try_second)
1207: {
1208: /* First arg may succeed; see whether second should. */
1209: type2 = TREE_TYPE (xarg2);
1210: if (TREE_CODE (type2) == OFFSET_TYPE)
1211: type2 = TREE_TYPE (type2);
1212: if (TREE_CODE (type2) == REFERENCE_TYPE)
1213: {
1214: arg2 = convert_from_reference (xarg2);
1215: type2 = TREE_TYPE (arg2);
1216: }
1217: else
1218: {
1219: arg2 = xarg2;
1220: }
1221:
1222: if (! IS_AGGR_TYPE (type2))
1223: try_second = 0;
1224: }
1225:
1226: if (type1 == unknown_type_node
1227: || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
1228: {
1229: /* This will not be implemented in the foreseeable future. */
1230: return rval;
1231: }
1232:
1233: if (code == MODIFY_EXPR)
1234: fnname = ansi_assopname[(int) TREE_CODE (arg3)];
1235: else
1236: fnname = ansi_opname[(int) code];
1237:
1238: global_fn = IDENTIFIER_GLOBAL_VALUE (fnname);
1239:
1240: /* This is the last point where we will accept failure. This
1241: may be too eager if we wish an overloaded operator not to match,
1242: but would rather a normal operator be called on a type-converted
1243: argument. */
1244:
1245: if (IS_AGGR_TYPE (type1))
1246: {
1247: fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
1248: /* ARM $13.4.7, prefix/postfix ++/--. */
1249: if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1250: {
1251: xarg2 = integer_zero_node;
1252: binary_is_unary = 0;
1253:
1254: if (fields1)
1255: {
1256: tree t, t2;
1257: int have_postfix = 0;
1258:
1259: /* Look for an `operator++ (int)'. If they didn't have
1260: one, then we fall back to the old way of doing things. */
1261: for (t = TREE_VALUE (fields1); t ; t = TREE_CHAIN (t))
1262: {
1263: t2 = TYPE_ARG_TYPES (TREE_TYPE (t));
1264: if (TREE_CHAIN (t2) != NULL_TREE
1265: && TREE_VALUE (TREE_CHAIN (t2)) == integer_type_node)
1266: {
1267: have_postfix = 1;
1268: break;
1269: }
1270: }
1271:
1272: if (! have_postfix)
1273: {
1274: char *op = POSTINCREMENT_EXPR ? "++" : "--";
1275:
1276: /* There's probably a LOT of code in the world that
1277: relies upon this old behavior. So we'll only give this
1278: warning when we've been given -pedantic. A few
1279: releases after 2.4, we'll convert this to be a pedwarn
1280: or something else more appropriate. */
1281: if (pedantic)
1282: warning ("no `operator%s (int)' declared for postfix `%s'",
1283: op, op);
1284: xarg2 = NULL_TREE;
1285: binary_is_unary = 1;
1286: }
1287: }
1288: }
1289: }
1290:
1291: if (fields1 == NULL_TREE && global_fn == NULL_TREE)
1292: return rval;
1293:
1294: /* If RVAL winds up being `error_mark_node', we will return
1295: that... There is no way that normal semantics of these
1296: operators will succeed. */
1297:
1298: /* This argument may be an uncommitted OFFSET_REF. This is
1299: the case for example when dealing with static class members
1300: which are referenced from their class name rather than
1301: from a class instance. */
1302: if (TREE_CODE (xarg1) == OFFSET_REF
1303: && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
1304: xarg1 = TREE_OPERAND (xarg1, 1);
1305: if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
1306: && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
1307: xarg2 = TREE_OPERAND (xarg2, 1);
1308:
1309: if (global_fn)
1310: flags |= LOOKUP_GLOBAL;
1311:
1312: if (code == CALL_EXPR)
1313: {
1314: /* This can only be a member function. */
1315: return build_method_call (xarg1, fnname, xarg2,
1316: NULL_TREE, LOOKUP_NORMAL);
1317: }
1318: else if (tree_code_length[(int) code] == 1 || binary_is_unary)
1319: {
1320: parms = NULL_TREE;
1321: rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
1322: }
1323: else if (code == COND_EXPR)
1324: {
1325: parms = tree_cons (0, xarg2, build_tree_list (NULL_TREE, arg3));
1326: rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1327: }
1328: else if (code == METHOD_CALL_EXPR)
1329: {
1330: /* must be a member function. */
1331: parms = tree_cons (NULL_TREE, xarg2, arg3);
1332: return build_method_call (xarg1, fnname, parms, NULL_TREE, LOOKUP_NORMAL);
1333: }
1334: else if (fields1)
1335: {
1336: parms = build_tree_list (NULL_TREE, xarg2);
1337: rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
1338: }
1339: else
1340: {
1341: parms = tree_cons (NULL_TREE, xarg1,
1342: build_tree_list (NULL_TREE, xarg2));
1343: rval = build_overload_call (fnname, parms, flags & LOOKUP_COMPLAIN,
1344: (struct candidate *)0);
1345: }
1346:
1347: /* If we did not win, do not lose yet, since type conversion may work. */
1348: if (TREE_CODE (rval) == ERROR_MARK)
1349: {
1350: if (flags & LOOKUP_COMPLAIN)
1351: return rval;
1352: return 0;
1353: }
1354:
1355: return rval;
1356: }
1357:
1358: /* This function takes an identifier, ID, and attempts to figure out what
1359: it means. There are a number of possible scenarios, presented in increasing
1360: order of hair:
1361:
1362: 1) not in a class's scope
1363: 2) in class's scope, member name of the class's method
1364: 3) in class's scope, but not a member name of the class
1365: 4) in class's scope, member name of a class's variable
1366:
1367: NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
1368: VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
1369: yychar is the pending input character (suitably encoded :-).
1370:
1371: As a last ditch, try to look up the name as a label and return that
1372: address.
1373:
1374: Values which are declared as being of REFERENCE_TYPE are
1375: automatically dereferenced here (as a hack to make the
1376: compiler faster). */
1377:
1378: tree
1379: hack_identifier (value, name, yychar)
1380: tree value, name;
1381: int yychar;
1382: {
1383: tree type;
1384:
1385: if (TREE_CODE (value) == ERROR_MARK)
1386: {
1387: if (current_class_name)
1388: {
1389: tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 1);
1390: if (fields == error_mark_node)
1391: return error_mark_node;
1392: if (fields)
1393: {
1394: tree fndecl;
1395:
1396: fndecl = TREE_VALUE (fields);
1397: my_friendly_assert (TREE_CODE (fndecl) == FUNCTION_DECL, 251);
1398: if (DECL_CHAIN (fndecl) == NULL_TREE)
1399: {
1400: warning ("methods cannot be converted to function pointers");
1401: return fndecl;
1402: }
1403: else
1404: {
1405: error ("ambiguous request for method pointer `%s'",
1406: IDENTIFIER_POINTER (name));
1407: return error_mark_node;
1408: }
1409: }
1410: }
1411: if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
1412: {
1413: return IDENTIFIER_LABEL_VALUE (name);
1414: }
1415: return error_mark_node;
1416: }
1417:
1418: type = TREE_TYPE (value);
1419: if (TREE_CODE (value) == FIELD_DECL)
1420: {
1421: if (current_class_decl == NULL_TREE)
1422: {
1423: error ("request for member `%s' in static member function",
1424: IDENTIFIER_POINTER (DECL_NAME (value)));
1425: return error_mark_node;
1426: }
1427: TREE_USED (current_class_decl) = 1;
1428: if (yychar == '(')
1429: if (! ((TYPE_LANG_SPECIFIC (type)
1430: && TYPE_OVERLOADS_CALL_EXPR (type))
1431: || (TREE_CODE (type) == REFERENCE_TYPE
1432: && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
1433: && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
1434: && TREE_CODE (type) != FUNCTION_TYPE
1435: && TREE_CODE (type) != METHOD_TYPE
1436: && (TREE_CODE (type) != POINTER_TYPE
1437: || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
1438: && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
1439: {
1440: error ("component `%s' is not a method",
1441: IDENTIFIER_POINTER (name));
1442: return error_mark_node;
1443: }
1444: /* Mark so that if we are in a constructor, and then find that
1445: this field was initialized by a base initializer,
1446: we can emit an error message. */
1447: TREE_USED (value) = 1;
1448: return build_component_ref (C_C_D, name, 0, 1);
1449: }
1450:
1451: if (TREE_CODE (value) == TREE_LIST)
1452: {
1453: tree t = value;
1454: while (t && TREE_CODE (t) == TREE_LIST)
1455: {
1456: assemble_external (TREE_VALUE (t));
1457: TREE_USED (t) = 1;
1458: t = TREE_CHAIN (t);
1459: }
1460: }
1461: else
1462: {
1463: assemble_external (value);
1464: TREE_USED (value) = 1;
1465: }
1466:
1467: if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && DECL_NONLOCAL (value))
1468: {
1469: if (DECL_LANG_SPECIFIC (value)
1470: && DECL_CLASS_CONTEXT (value) != current_class_type)
1471: {
1472: tree path;
1473: enum visibility_type visibility;
1474: register tree context
1475: = (TREE_CODE (value) == FUNCTION_DECL && DECL_VIRTUAL_P (value))
1476: ? DECL_CLASS_CONTEXT (value)
1477: : DECL_CONTEXT (value);
1478:
1479: get_base_distance (context, current_class_type, 0, &path);
1480: if (path)
1481: {
1482: visibility = compute_visibility (path, value);
1483: if (visibility != visibility_public)
1484: {
1485: if (TREE_CODE (value) == VAR_DECL)
1486: error ("static member `%s' is from private base class",
1487: IDENTIFIER_POINTER (name));
1488: else
1489: error ("enum `%s' is from private base class",
1490: IDENTIFIER_POINTER (name));
1491: return error_mark_node;
1492: }
1493: }
1494: }
1495: return value;
1496: }
1497: if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
1498: {
1499: if (type == 0)
1500: {
1501: error ("request for member `%s' is ambiguous in multiple inheritance lattice",
1502: IDENTIFIER_POINTER (name));
1503: return error_mark_node;
1504: }
1505:
1506: return value;
1507: }
1508:
1509: if (TREE_CODE (type) == REFERENCE_TYPE)
1510: {
1511: my_friendly_assert (TREE_CODE (value) == VAR_DECL
1512: || TREE_CODE (value) == PARM_DECL
1513: || TREE_CODE (value) == RESULT_DECL, 252);
1514: if (DECL_REFERENCE_SLOT (value))
1515: return DECL_REFERENCE_SLOT (value);
1516: }
1517: return value;
1518: }
1519:
1520:
1521: /* Given an object OF, and a type conversion operator COMPONENT
1522: build a call to the conversion operator, if a call is requested,
1523: or return the address (as a pointer to member function) if one is not.
1524:
1525: OF can be a TYPE_DECL or any kind of datum that would normally
1526: be passed to `build_component_ref'. It may also be NULL_TREE,
1527: in which case `current_class_type' and `current_class_decl'
1528: provide default values.
1529:
1530: BASETYPE_PATH, if non-null, is the path of basetypes
1531: to go through before we get the the instance of interest.
1532:
1533: PROTECT says whether we apply C++ scoping rules or not. */
1534: tree
1535: build_component_type_expr (of, component, basetype_path, protect)
1536: tree of, component, basetype_path;
1537: int protect;
1538: {
1539: tree cname = NULL_TREE;
1540: tree tmp, last;
1541: tree name;
1542: int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
1543:
1544: if (of)
1545: my_friendly_assert (IS_AGGR_TYPE (TREE_TYPE (of)), 253);
1546: my_friendly_assert (TREE_CODE (component) == TYPE_EXPR, 254);
1547:
1548: tmp = TREE_OPERAND (component, 0);
1549: last = NULL_TREE;
1550:
1551: while (tmp)
1552: {
1553: switch (TREE_CODE (tmp))
1554: {
1555: case CALL_EXPR:
1556: if (last)
1557: TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
1558: else
1559: TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
1560:
1561: last = groktypename (build_tree_list (TREE_TYPE (component),
1562: TREE_OPERAND (component, 0)));
1563: name = build_typename_overload (last);
1564: TREE_TYPE (name) = last;
1565:
1566: if (TREE_OPERAND (tmp, 0)
1567: && TREE_OPERAND (tmp, 0) != void_list_node)
1568: {
1569: cp_error ("`operator %T' requires empty parameter list", last);
1570: TREE_OPERAND (tmp, 0) = NULL_TREE;
1571: }
1572:
1573: if (of && TREE_CODE (of) != TYPE_DECL)
1574: return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
1575: else if (of)
1576: {
1577: tree this_this;
1578:
1579: if (current_class_decl == NULL_TREE)
1580: {
1581: cp_error ("object required for `operator %T' call",
1582: TREE_TYPE (name));
1583: return error_mark_node;
1584: }
1585:
1586: this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1587: return build_method_call (this_this, name, NULL_TREE,
1588: NULL_TREE, flags | LOOKUP_NONVIRTUAL);
1589: }
1590: else if (current_class_decl)
1591: return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
1592:
1593: cp_error ("object required for `operator %T' call",
1594: TREE_TYPE (name));
1595: return error_mark_node;
1596:
1597: case INDIRECT_REF:
1598: case ADDR_EXPR:
1599: case ARRAY_REF:
1600: break;
1601:
1602: case SCOPE_REF:
1603: my_friendly_assert (cname == 0, 255);
1604: cname = TREE_OPERAND (tmp, 0);
1605: tmp = TREE_OPERAND (tmp, 1);
1606: break;
1607:
1608: default:
1609: my_friendly_abort (77);
1610: }
1611: last = tmp;
1612: tmp = TREE_OPERAND (tmp, 0);
1613: }
1614:
1615: last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
1616: name = build_typename_overload (last);
1617: TREE_TYPE (name) = last;
1618: if (of && TREE_CODE (of) == TYPE_DECL)
1619: {
1620: if (cname == NULL_TREE)
1621: {
1622: cname = DECL_NAME (of);
1623: of = NULL_TREE;
1624: }
1625: else my_friendly_assert (cname == DECL_NAME (of), 256);
1626: }
1627:
1628: if (of)
1629: {
1630: tree this_this;
1631:
1632: if (current_class_decl == NULL_TREE)
1633: {
1634: cp_error ("object required for `operator %T' call",
1635: TREE_TYPE (name));
1636: return error_mark_node;
1637: }
1638:
1639: this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
1640: return build_component_ref (this_this, name, 0, protect);
1641: }
1642: else if (cname)
1643: return build_offset_ref (cname, name);
1644: else if (current_class_name)
1645: return build_offset_ref (current_class_name, name);
1646:
1647: cp_error ("object required for `operator %T' member reference",
1648: TREE_TYPE (name));
1649: return error_mark_node;
1650: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.