![[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 [GCC 2.x] / gcc|
Return to cp-method.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Handle the hair of processing (but not expanding) inline functions.
2: Also manage function and varaible name overloading.
3: Copyright (C) 1987, 1989, 1992 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 <string.h>
30: #include "config.h"
31: #include "tree.h"
32: #include "cp-tree.h"
33: #include "cp-class.h"
34: #include "assert.h"
35: #include "obstack.h"
36:
37: #define obstack_chunk_alloc xmalloc
38: #define obstack_chunk_free free
39:
40: extern int xmalloc ();
41: extern void free ();
42:
43: /* TREE_LIST of the current inline functions that need to be
44: processed. */
45: struct pending_inline *pending_inlines;
46:
47: /* Obstack where we build text strings for overloading, etc. */
48: static struct obstack scratch_obstack;
49: static char *scratch_firstobj;
50:
51: # define OB_INIT() (scratch_firstobj ? (obstack_free (&scratch_obstack, scratch_firstobj), 0) : 0)
52: # define OB_PUTC(C) (obstack_1grow (&scratch_obstack, (C)))
53: # define OB_PUTC2(C1,C2) \
54: (obstack_1grow (&scratch_obstack, (C1)), obstack_1grow (&scratch_obstack, (C2)))
55: # define OB_PUTS(S) (obstack_grow (&scratch_obstack, (S), sizeof (S) - 1))
56: # define OB_PUTID(ID) \
57: (obstack_grow (&scratch_obstack, IDENTIFIER_POINTER (ID), \
58: IDENTIFIER_LENGTH (ID)))
59: # define OB_PUTCP(S) (obstack_grow (&scratch_obstack, (S), strlen (S)))
60: # define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
61:
62: /* Counter to help build parameter names in case they were omitted. */
63: static int dummy_name;
64: static int in_parmlist;
65:
66: /* This points to a safe place to resume processing in case an expression
67: generates an error while we're trying to format it. */
68: static int scratch_error_offset;
69:
70: static void dump_type (), dump_decl ();
71: static void dump_init (), dump_unary_op (), dump_binary_op ();
72:
73: tree wrapper_name, wrapper_pred_name, anti_wrapper_name;
74:
75: #ifdef NO_AUTO_OVERLOAD
76: int is_overloaded ();
77: #endif
78:
79: void
80: init_method ()
81: {
82: char buf[sizeof (ANTI_WRAPPER_NAME_FORMAT) + 8];
83: sprintf (buf, WRAPPER_NAME_FORMAT, "");
84: wrapper_name = get_identifier (buf);
85: sprintf (buf, WRAPPER_PRED_NAME_FORMAT, "");
86: wrapper_pred_name = get_identifier (buf);
87: sprintf (buf, ANTI_WRAPPER_NAME_FORMAT, "");
88: anti_wrapper_name = get_identifier (buf);
89: gcc_obstack_init (&scratch_obstack);
90: scratch_firstobj = (char *)obstack_alloc (&scratch_obstack, 0);
91: }
92:
93: /* Return a pointer to the end of the new text in INLINE_BUFFER.
94: We cannot use `fatal' or `error' in here because that
95: might cause an infinite loop. */
96: static char *
97: new_text_len (s)
98: char *s;
99: {
100: while (*s++) ;
101: return s - 1;
102: }
103:
104: tree
105: make_anon_parm_name ()
106: {
107: char buf[32];
108:
109: sprintf (buf, ANON_PARMNAME_FORMAT, dummy_name++);
110: return get_identifier (buf);
111: }
112:
113: void
114: clear_anon_parm_name ()
115: {
116: /* recycle these names. */
117: dummy_name = 0;
118: }
119:
120: static void
121: dump_readonly_or_volatile (t)
122: tree t;
123: {
124: if (TYPE_READONLY (t))
125: OB_PUTS ("const ");
126: if (TYPE_VOLATILE (t))
127: OB_PUTS ("volatile ");
128: }
129:
130: static void
131: dump_aggr_type (t)
132: tree t;
133: {
134: tree name;
135: char *aggr_string;
136: char *context_string = 0;
137:
138: if (TYPE_READONLY (t))
139: OB_PUTS ("const ");
140: if (TYPE_VOLATILE (t))
141: OB_PUTS ("volatile ");
142: if (TREE_CODE (t) == ENUMERAL_TYPE)
143: aggr_string = "enum";
144: else if (TREE_CODE (t) == UNION_TYPE)
145: aggr_string = "union";
146: else if (TYPE_LANG_SPECIFIC (t) && CLASSTYPE_DECLARED_CLASS (t))
147: aggr_string = "class";
148: else
149: aggr_string = "struct";
150:
151: name = TYPE_NAME (t);
152:
153: if (TREE_CODE (name) == TYPE_DECL)
154: {
155: if (DECL_LANG_SPECIFIC (name) && DECL_CLASS_CONTEXT (name))
156: context_string = TYPE_NAME_STRING (DECL_CLASS_CONTEXT (name));
157: name = DECL_NAME (name);
158: }
159:
160: obstack_grow (&scratch_obstack, aggr_string, strlen (aggr_string));
161: OB_PUTC (' ');
162: if (context_string)
163: {
164: obstack_grow (&scratch_obstack, context_string, strlen (context_string)-1);
165: OB_PUTC2 (':', ':');
166: }
167: OB_PUTID (name);
168: }
169:
170: /* This must be large enough to hold any anonymous parm name. */
171: static char anon_buffer[sizeof (ANON_PARMNAME_FORMAT) + 20];
172: /* This must be large enough to hold any printed integer or floatingpoint value. */
173: static char digit_buffer[128];
174:
175: static void
176: dump_type_prefix (t, p)
177: tree t;
178: int *p;
179: {
180: int old_p = 0;
181: int print_struct = 1;
182: tree name;
183:
184: if (t == NULL_TREE)
185: return;
186:
187: switch (TREE_CODE (t))
188: {
189: case ERROR_MARK:
190: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
191: OB_PUTCP (anon_buffer);
192: break;
193:
194: case UNKNOWN_TYPE:
195: OB_PUTS ("<unknown type>");
196: return;
197:
198: case TREE_LIST:
199: dump_type (TREE_VALUE (t), &old_p);
200: if (TREE_CHAIN (t))
201: {
202: if (TREE_CHAIN (t) != void_list_node)
203: {
204: OB_PUTC (',');
205: dump_type (TREE_CHAIN (t), &old_p);
206: }
207: }
208: else OB_PUTS ("...");
209: return;
210:
211: case POINTER_TYPE:
212: *p += 1;
213: dump_type_prefix (TREE_TYPE (t), p);
214: while (*p)
215: {
216: OB_PUTC ('*');
217: *p -= 1;
218: }
219: if (TYPE_READONLY (t))
220: OB_PUTS ("const ");
221: if (TYPE_VOLATILE (t))
222: OB_PUTS ("volatile ");
223: return;
224:
225: case OFFSET_TYPE:
226: {
227: tree type = TREE_TYPE (t);
228: if (TREE_CODE (type) == FUNCTION_TYPE)
229: {
230: type = TREE_TYPE (type);
231: if (in_parmlist)
232: OB_PUTS ("auto ");
233: }
234:
235: dump_type_prefix (type, &old_p);
236:
237: OB_PUTC ('(');
238: dump_type (TYPE_OFFSET_BASETYPE (t), &old_p);
239: OB_PUTC2 (':', ':');
240: while (*p)
241: {
242: OB_PUTC ('*');
243: *p -= 1;
244: }
245: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
246: dump_readonly_or_volatile (t);
247: return;
248: }
249:
250: case METHOD_TYPE:
251: {
252: tree type = TREE_TYPE (t);
253: if (in_parmlist)
254: OB_PUTS ("auto ");
255:
256: dump_type_prefix (type, &old_p);
257:
258: OB_PUTC ('(');
259: dump_type (TYPE_METHOD_BASETYPE (t), &old_p);
260: OB_PUTC2 (':', ':');
261: while (*p)
262: {
263: OB_PUTC ('*');
264: *p -= 1;
265: }
266: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
267: dump_readonly_or_volatile (t);
268: return;
269: }
270:
271: case REFERENCE_TYPE:
272: dump_type_prefix (TREE_TYPE (t), p);
273: OB_PUTC ('&');
274: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
275: dump_readonly_or_volatile (t);
276: return;
277:
278: case ARRAY_TYPE:
279: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
280: dump_readonly_or_volatile (t);
281: dump_type_prefix (TREE_TYPE (t), p);
282: return;
283:
284: case FUNCTION_TYPE:
285: if (in_parmlist)
286: OB_PUTS ("auto ");
287: dump_type_prefix (TREE_TYPE (t), &old_p);
288: OB_PUTC ('(');
289: while (*p)
290: {
291: OB_PUTC ('*');
292: *p -= 1;
293: }
294: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
295: dump_readonly_or_volatile (t);
296: return;
297:
298: case IDENTIFIER_NODE:
299: OB_PUTID (t);
300: OB_PUTC (' ');
301: break;
302:
303: case RECORD_TYPE:
304: case UNION_TYPE:
305: case ENUMERAL_TYPE:
306: dump_aggr_type (t);
307: break;
308:
309: case TYPE_DECL:
310: if (TYPE_READONLY (t))
311: OB_PUTS ("const ");
312: if (TYPE_VOLATILE (t))
313: OB_PUTS ("volatile ");
314: OB_PUTID (DECL_NAME (t));
315: OB_PUTC (' ');
316: break;
317:
318: case INTEGER_TYPE:
319: #if 0
320: /* Normally, `unsigned' is part of the deal. Not so if it comes
321: with `const' or `volatile'. */
322: if (TYPE_MAIN_VARIANT (t) == unsigned_type (TYPE_MAIN_VARIANT (t))
323: && (TYPE_READONLY (t) || TYPE_VOLATILE (t)))
324: OB_PUTS ("unsigned ");
325: #endif
326: /* fall through. */
327: case REAL_TYPE:
328: case VOID_TYPE:
329: if (TYPE_READONLY (t))
330: OB_PUTS ("const ");
331: if (TYPE_VOLATILE (t))
332: OB_PUTS ("volatile ");
333: OB_PUTID (DECL_NAME (TYPE_NAME (t)));
334: OB_PUTC (' ');
335: break;
336:
337: default:
338: abort ();
339: }
340: }
341:
342: static void
343: dump_type_suffix (t, p)
344: tree t;
345: int *p;
346: {
347: int old_p = 0;
348:
349: if (t == NULL_TREE)
350: return;
351:
352: switch (TREE_CODE (t))
353: {
354: case ERROR_MARK:
355: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
356: OB_PUTCP (anon_buffer);
357: break;
358:
359: case UNKNOWN_TYPE:
360: return;
361:
362: case POINTER_TYPE:
363: dump_type_suffix (TREE_TYPE (t), p);
364: return;
365:
366: case OFFSET_TYPE:
367: {
368: tree type = TREE_TYPE (t);
369:
370: OB_PUTC (')');
371: if (TREE_CODE (type) == FUNCTION_TYPE)
372: {
373: #if 0
374: tree next_arg = TREE_CHAIN (TYPE_ARG_TYPES (type));
375: OB_PUTC ('(');
376: if (next_arg)
377: {
378: if (next_arg != void_list_node)
379: {
380: in_parmlist++;
381: dump_type (next_arg, &old_p);
382: in_parmlist--;
383: }
384: }
385: else OB_PUTS ("...");
386: OB_PUTC (')');
387: dump_type_suffix (TREE_TYPE (type), p);
388: #else
389: abort ();
390: #endif
391: }
392: return;
393: }
394:
395: case METHOD_TYPE:
396: {
397: tree next_arg;
398: OB_PUTC (')');
399: next_arg = TREE_CHAIN (TYPE_ARG_TYPES (t));
400: OB_PUTC ('(');
401: if (next_arg)
402: {
403: if (next_arg != void_list_node)
404: {
405: in_parmlist++;
406: dump_type (next_arg, &old_p);
407: in_parmlist--;
408: }
409: }
410: else OB_PUTS ("...");
411: OB_PUTC (')');
412: dump_readonly_or_volatile (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (t))));
413: dump_type_suffix (TREE_TYPE (t), p);
414: return;
415: }
416:
417: case REFERENCE_TYPE:
418: dump_type_suffix (TREE_TYPE (t), p);
419: return;
420:
421: case ARRAY_TYPE:
422: dump_type_suffix (TREE_TYPE (t), p);
423: OB_PUTC2 ('[', ']');
424: return;
425:
426: case FUNCTION_TYPE:
427: OB_PUTC2 (')', '(');
428: if (TYPE_ARG_TYPES (t) && TYPE_ARG_TYPES (t) != void_list_node)
429: {
430: in_parmlist++;
431: dump_type (TYPE_ARG_TYPES (t), &old_p);
432: in_parmlist--;
433: }
434: OB_PUTC (')');
435: dump_type_suffix (TREE_TYPE (t), p);
436: return;
437:
438: case IDENTIFIER_NODE:
439: case RECORD_TYPE:
440: case UNION_TYPE:
441: case ENUMERAL_TYPE:
442: case TYPE_DECL:
443: case INTEGER_TYPE:
444: case REAL_TYPE:
445: case VOID_TYPE:
446: return;
447:
448: default:
449: abort ();
450: }
451: }
452:
453: static void
454: dump_type (t, p)
455: tree t;
456: int *p;
457: {
458: int old_p = 0;
459: int print_struct = 1;
460:
461: if (t == NULL_TREE)
462: return;
463:
464: switch (TREE_CODE (t))
465: {
466: case ERROR_MARK:
467: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
468: OB_PUTCP (anon_buffer);
469: break;
470:
471: case UNKNOWN_TYPE:
472: OB_PUTS ("<unknown type>");
473: return;
474:
475: case TREE_LIST:
476: dump_type (TREE_VALUE (t), &old_p);
477: if (TREE_CHAIN (t))
478: {
479: if (TREE_CHAIN (t) != void_list_node)
480: {
481: OB_PUTC (',');
482: dump_type (TREE_CHAIN (t), &old_p);
483: }
484: }
485: else OB_PUTS ("...");
486: return;
487:
488: case POINTER_TYPE:
489: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
490: dump_readonly_or_volatile (t);
491: *p += 1;
492: dump_type (TREE_TYPE (t), p);
493: while (*p)
494: {
495: OB_PUTC ('*');
496: *p -= 1;
497: }
498: return;
499:
500: case REFERENCE_TYPE:
501: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
502: dump_readonly_or_volatile (t);
503: dump_type (TREE_TYPE (t), p);
504: OB_PUTC ('&');
505: return;
506:
507: case ARRAY_TYPE:
508: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
509: dump_readonly_or_volatile (t);
510: dump_type (TREE_TYPE (t), p);
511: OB_PUTC2 ('[', ']');
512: return;
513:
514: case OFFSET_TYPE:
515: case METHOD_TYPE:
516: case FUNCTION_TYPE:
517: dump_type_prefix (t, p);
518: dump_type_suffix (t, p);
519: return;
520:
521: case IDENTIFIER_NODE:
522: OB_PUTID (t);
523: OB_PUTC (' ');
524: break;
525:
526: case RECORD_TYPE:
527: case UNION_TYPE:
528: case ENUMERAL_TYPE:
529: dump_aggr_type (t);
530: break;
531:
532: case TYPE_DECL:
533: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
534: dump_readonly_or_volatile (t);
535: OB_PUTID (DECL_NAME (t));
536: OB_PUTC (' ');
537: break;
538:
539: case INTEGER_TYPE:
540: /* Normally, `unsigned' is part of the deal. Not so if it comes
541: with `const' or `volatile'. */
542: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
543: dump_readonly_or_volatile (t);
544: #if 0
545: if (TYPE_MAIN_VARIANT (t) == unsigned_type (TYPE_MAIN_VARIANT (t))
546: && (TYPE_READONLY (t) | TYPE_VOLATILE (t)))
547: OB_PUTS ("unsigned ");
548: #endif
549: OB_PUTID (DECL_NAME (TYPE_NAME (t)));
550: OB_PUTC (' ');
551: break;
552:
553: case REAL_TYPE:
554: case VOID_TYPE:
555: if (TYPE_READONLY (t) | TYPE_VOLATILE (t))
556: dump_readonly_or_volatile (t);
557: OB_PUTID (DECL_NAME (TYPE_NAME (t)));
558: OB_PUTC (' ');
559: break;
560:
561: case TEMPLATE_TYPE_PARM:
562: OB_PUTS ("<template type parm ");
563: OB_PUTID (DECL_NAME (TYPE_NAME (t)));
564: OB_PUTC ('>');
565: break;
566:
567: case UNINSTANTIATED_P_TYPE:
568: OB_PUTID (DECL_NAME (UPT_TEMPLATE (t)));
569: OB_PUTS ("<...>");
570: break;
571:
572: default:
573: abort ();
574: }
575: }
576:
577: static void
578: dump_decl (t)
579: tree t;
580: {
581: int p = 0;
582:
583: if (t == NULL_TREE)
584: return;
585:
586: switch (TREE_CODE (t))
587: {
588: case ERROR_MARK:
589: OB_PUTS (" /* decl error */ ");
590: break;
591:
592: case PARM_DECL:
593: dump_type_prefix (TREE_TYPE (t), &p);
594: if (DECL_NAME (t))
595: dump_decl (DECL_NAME (t));
596: else
597: {
598: sprintf (anon_buffer, ANON_PARMNAME_FORMAT, dummy_name++);
599: OB_PUTCP (anon_buffer);
600: break;
601: }
602: dump_type_suffix (TREE_TYPE (t), &p);
603: return;
604:
605: case CALL_EXPR:
606: dump_decl (TREE_OPERAND (t, 0));
607: OB_PUTC ('(');
608: in_parmlist++;
609: dump_decl (TREE_OPERAND (t, 1));
610: in_parmlist--;
611: t = tree_last (TYPE_ARG_TYPES (TREE_TYPE (t)));
612: if (!t || t != void_list_node)
613: OB_PUTS ("...");
614: OB_PUTC (')');
615: return;
616:
617: case ARRAY_REF:
618: dump_decl (TREE_OPERAND (t, 0));
619: OB_PUTC ('[');
620: dump_decl (TREE_OPERAND (t, 1));
621: OB_PUTC (']');
622: return;
623:
624: case TYPE_DECL:
625: OB_PUTID (DECL_NAME (t));
626: OB_PUTC (' ');
627: break;
628:
629: case TYPE_EXPR:
630: abort ();
631: break;
632:
633: case IDENTIFIER_NODE:
634: if (t == ansi_opname[TYPE_EXPR])
635: {
636: OB_PUTS ("operator ");
637: /* Not exactly IDENTIFIER_TYPE_VALUE. */
638: dump_type (TREE_TYPE (t), &p);
639: return;
640: }
641: else if (IDENTIFIER_OPNAME_P (t))
642: {
643: char *name_string = operator_name_string (t);
644: OB_PUTS ("operator ");
645: OB_PUTCP (name_string);
646: OB_PUTC (' ');
647: }
648: else
649: {
650: OB_PUTID (t);
651: OB_PUTC (' ');
652: }
653: break;
654:
655: case BIT_NOT_EXPR:
656: OB_PUTC2 ('~', ' ');
657: dump_decl (TREE_OPERAND (t, 0));
658: return;
659:
660: case SCOPE_REF:
661: OB_PUTID (TREE_OPERAND (t, 0));
662: OB_PUTC2 (':', ':');
663: dump_decl (TREE_OPERAND (t, 1));
664: return;
665:
666: case INDIRECT_REF:
667: OB_PUTC ('*');
668: dump_decl (TREE_OPERAND (t, 0));
669: return;
670:
671: case ADDR_EXPR:
672: OB_PUTC ('&');
673: dump_decl (TREE_OPERAND (t, 0));
674: return;
675:
676: default:
677: abort ();
678: }
679: }
680:
681: static void
682: dump_init_list (l)
683: tree l;
684: {
685: while (l)
686: {
687: dump_init (TREE_VALUE (l));
688: if (TREE_CHAIN (l))
689: OB_PUTC (',');
690: l = TREE_CHAIN (l);
691: }
692: }
693:
694: static void
695: dump_init (t)
696: tree t;
697: {
698: int dummy;
699:
700: switch (TREE_CODE (t))
701: {
702: case VAR_DECL:
703: case PARM_DECL:
704: OB_PUTC (' ');
705: OB_PUTID (DECL_NAME (t));
706: OB_PUTC (' ');
707: break;
708:
709: case FUNCTION_DECL:
710: {
711: tree name = DECL_ASSEMBLER_NAME (t);
712:
713: if (DESTRUCTOR_NAME_P (name))
714: {
715: OB_PUTC2 (' ', '~');
716: OB_PUTID (DECL_NAME (t));
717: }
718: else if (IDENTIFIER_TYPENAME_P (name))
719: {
720: dummy = 0;
721: OB_PUTS ("operator ");
722: dump_type (TREE_TYPE (name), &dummy);
723: }
724: else if (IDENTIFIER_OPNAME_P (name))
725: {
726: char *name_string = operator_name_string (name);
727: OB_PUTS ("operator ");
728: OB_PUTCP (name_string);
729: OB_PUTC (' ');
730: }
731: #if 0
732: else if (WRAPPER_NAME_P (name))
733: sprintf (inline_bufp, " ()%s", IDENTIFIER_POINTER (DECL_NAME (t)));
734: else if (WRAPPER_PRED_NAME_P (name))
735: sprintf (inline_bufp, " ()?%s", IDENTIFIER_POINTER (DECL_NAME (t)));
736: else if (ANTI_WRAPPER_NAME_P (name))
737: sprintf (inline_bufp, " ~()%s", IDENTIFIER_POINTER (DECL_NAME (t)));
738: #endif
739: else
740: {
741: OB_PUTC (' ');
742: OB_PUTID (DECL_NAME (t));
743: }
744: OB_PUTC (' ');
745: }
746: break;
747:
748: case CONST_DECL:
749: dummy = 0;
750: OB_PUTC2 ('(', '(');
751: dump_type (TREE_TYPE (t), &dummy);
752: OB_PUTC (')');
753: dump_init (DECL_INITIAL (t));
754: OB_PUTC (')');
755: return;
756:
757: case INTEGER_CST:
758: sprintf (digit_buffer, " %d ", TREE_INT_CST_LOW (t));
759: OB_PUTCP (digit_buffer);
760: break;
761:
762: case REAL_CST:
763: sprintf (digit_buffer, " %g ", TREE_REAL_CST (t));
764: OB_PUTCP (digit_buffer);
765: break;
766:
767: case STRING_CST:
768: {
769: char *p = TREE_STRING_POINTER (t);
770: int len = TREE_STRING_LENGTH (t) - 1;
771: int i;
772:
773: OB_PUTC ('\"');
774: for (i = 0; i < len; i++)
775: {
776: register char c = p[i];
777: if (c == '\"' || c == '\\')
778: OB_PUTC ('\\');
779: if (c >= ' ' && c < 0177)
780: OB_PUTC (c);
781: else
782: {
783: sprintf (digit_buffer, "\\%03o", c);
784: OB_PUTCP (digit_buffer);
785: }
786: }
787: OB_PUTC ('\"');
788: }
789: return;
790:
791: case COMPOUND_EXPR:
792: dump_binary_op (",", t, 1);
793: break;
794:
795: case COND_EXPR:
796: OB_PUTC ('(');
797: dump_init (TREE_OPERAND (t, 0));
798: OB_PUTS (" ? ");
799: dump_init (TREE_OPERAND (t, 1));
800: OB_PUTS (" : ");
801: dump_init (TREE_OPERAND (t, 2));
802: OB_PUTC (')');
803: return;
804:
805: case SAVE_EXPR:
806: if (TREE_HAS_CONSTRUCTOR (t))
807: {
808: dummy = 0;
809: OB_PUTS ("new ");
810: dump_type (TREE_TYPE (TREE_TYPE (t)), &dummy);
811: PARM_DECL_EXPR (t) = 1;
812: }
813: else
814: {
815: sorry ("operand of SAVE_EXPR not understood");
816: scratch_obstack.next_free
817: = obstack_base (&scratch_obstack) + scratch_error_offset;
818: }
819: return;
820:
821: case NEW_EXPR:
822: OB_PUTID (DECL_NAME (TYPE_NAME (TREE_TYPE (t))));
823: OB_PUTC ('(');
824: dump_init_list (TREE_CHAIN (TREE_OPERAND (t, 1)));
825: OB_PUTC (')');
826: return;
827:
828: case CALL_EXPR:
829: OB_PUTC ('(');
830: dump_init (TREE_OPERAND (t, 0));
831: dump_init_list (TREE_OPERAND (t, 1));
832: OB_PUTC (')');
833: return;
834:
835: case WITH_CLEANUP_EXPR:
836: /* Note that this only works for G++ cleanups. If somebody
837: builds a general cleanup, there's no way to represent it. */
838: dump_init (TREE_OPERAND (t, 0));
839: return;
840:
841: case TARGET_EXPR:
842: /* Note that this only works for G++ target exprs. If somebody
843: builds a general TARGET_EXPR, there's no way to represent that
844: it initializes anything other that the parameter slot for the
845: default argument. */
846: dump_init (TREE_OPERAND (t, 1));
847: return;
848:
849: case MODIFY_EXPR:
850: case PLUS_EXPR:
851: case MINUS_EXPR:
852: case MULT_EXPR:
853: case TRUNC_DIV_EXPR:
854: case TRUNC_MOD_EXPR:
855: case MIN_EXPR:
856: case MAX_EXPR:
857: case LSHIFT_EXPR:
858: case RSHIFT_EXPR:
859: case BIT_IOR_EXPR:
860: case BIT_XOR_EXPR:
861: case BIT_AND_EXPR:
862: case BIT_ANDTC_EXPR:
863: case TRUTH_ANDIF_EXPR:
864: case TRUTH_ORIF_EXPR:
865: case LT_EXPR:
866: case LE_EXPR:
867: case GT_EXPR:
868: case GE_EXPR:
869: case EQ_EXPR:
870: case NE_EXPR:
871: dump_binary_op (opname_tab[(int) TREE_CODE (t)], t,
872: strlen (opname_tab[(int) TREE_CODE (t)]));
873: return;
874:
875: case CEIL_DIV_EXPR:
876: case FLOOR_DIV_EXPR:
877: case ROUND_DIV_EXPR:
878: dump_binary_op ("/", t, 1);
879: return;
880:
881: case CEIL_MOD_EXPR:
882: case FLOOR_MOD_EXPR:
883: case ROUND_MOD_EXPR:
884: dump_binary_op ("%", t, 1);
885: return;
886:
887: case COMPONENT_REF:
888: dump_binary_op (".", t, 1);
889: return;
890:
891: case CONVERT_EXPR:
892: dump_unary_op ("+", t, 1);
893: return;
894:
895: case ADDR_EXPR:
896: if (TREE_CODE (TREE_OPERAND (t, 0)) == FUNCTION_DECL
897: || TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST)
898: dump_init (TREE_OPERAND (t, 0));
899: else
900: dump_unary_op ("&", t, 1);
901: return;
902:
903: case INDIRECT_REF:
904: dump_unary_op ("*", t, 1);
905: return;
906:
907: case NEGATE_EXPR:
908: case BIT_NOT_EXPR:
909: case TRUTH_NOT_EXPR:
910: case PREDECREMENT_EXPR:
911: case PREINCREMENT_EXPR:
912: dump_unary_op (opname_tab [(int)TREE_CODE (t)], t,
913: strlen (opname_tab[(int) TREE_CODE (t)]));
914: return;
915:
916: case POSTDECREMENT_EXPR:
917: case POSTINCREMENT_EXPR:
918: OB_PUTC ('(');
919: dump_init (TREE_OPERAND (t, 0));
920: OB_PUTCP (opname_tab[(int)TREE_CODE (t)]);
921: OB_PUTC (')');
922: return;
923:
924: case NOP_EXPR:
925: dummy = 0;
926: OB_PUTC2 ('(', '(');
927: dump_type (TREE_TYPE (t), &dummy);
928: OB_PUTC (')');
929: dump_init (TREE_OPERAND (t, 0));
930: OB_PUTC (')');
931: return;
932:
933: case CONSTRUCTOR:
934: OB_PUTC ('{');
935: dump_init_list (CONSTRUCTOR_ELTS (t));
936: OB_PUTC ('}');
937: return;
938:
939: /* This list is incomplete, but should suffice for now.
940: It is very important that `sorry' does not call
941: `report_error_function'. That could cause an infinite loop. */
942: default:
943: sorry ("`%s' not supported for default parameters",
944: tree_code_name[(int) TREE_CODE (t)]);
945:
946: /* fall through to ERROR_MARK... */
947: case ERROR_MARK:
948: scratch_obstack.next_free
949: = obstack_base (&scratch_obstack) + scratch_error_offset;
950: return;
951: }
952: }
953:
954: static void
955: dump_binary_op (opstring, t, len)
956: char *opstring;
957: tree t;
958: int len;
959: {
960: OB_PUTC ('(');
961: dump_init (TREE_OPERAND (t, 0));
962: OB_PUTC (' ');
963: OB_PUTCP (opstring);
964: OB_PUTC (' ');
965: dump_init (TREE_OPERAND (t, 1));
966: OB_PUTC (')');
967: }
968:
969: static void
970: dump_unary_op (opstring, t, len)
971: char *opstring;
972: tree t;
973: int len;
974: {
975: OB_PUTC ('(');
976: OB_PUTC (' ');
977: OB_PUTCP (opstring);
978: OB_PUTC (' ');
979: dump_init (TREE_OPERAND (t, 0));
980: OB_PUTC (')');
981: }
982:
983: /* Pretty printing for announce_function. CNAME is the TYPE_DECL for
984: the class that FNDECL belongs to, if we could not figure that out
985: from FNDECL itself. FNDECL is the declaration of the function we
986: are interested in seeing. PRINT_RET_TYPE_P is non-zero if we
987: should print the type that this function returns. */
988:
989: char *
990: fndecl_as_string (cname, fndecl, print_ret_type_p)
991: tree cname, fndecl;
992: int print_ret_type_p;
993: {
994: tree name = DECL_ASSEMBLER_NAME (fndecl);
995: tree fntype = TREE_TYPE (fndecl);
996: tree parmtypes = TYPE_ARG_TYPES (fntype);
997: int p = 0;
998: int spaces = 0;
999:
1000: OB_INIT ();
1001:
1002: if (DECL_CLASS_CONTEXT (fndecl))
1003: cname = TYPE_NAME (DECL_CLASS_CONTEXT (fndecl));
1004:
1005: if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name))
1006: {
1007: dump_type_prefix (TREE_TYPE (fntype), &p);
1008: OB_PUTC (' ');
1009: }
1010: if (DECL_STATIC_FUNCTION_P (fndecl))
1011: OB_PUTS ("static ");
1012:
1013: if (cname)
1014: {
1015: dump_type (cname, &p);
1016: *((char *) obstack_next_free (&scratch_obstack) - 1) = ':';
1017: OB_PUTC (':');
1018: if (TREE_CODE (fntype) == METHOD_TYPE && parmtypes)
1019: parmtypes = TREE_CHAIN (parmtypes);
1020: if (DECL_CONSTRUCTOR_FOR_VBASE_P (fndecl))
1021: /* Skip past "in_charge" identifier. */
1022: parmtypes = TREE_CHAIN (parmtypes);
1023: }
1024:
1025: if (DESTRUCTOR_NAME_P (name))
1026: {
1027: OB_PUTC ('~');
1028: parmtypes = TREE_CHAIN (parmtypes);
1029: dump_decl (DECL_NAME (fndecl));
1030: }
1031: else if (IDENTIFIER_TYPENAME_P (name))
1032: {
1033: /* This cannot use the hack that the operator's return
1034: type is stashed off of its name because it may be
1035: used for error reporting. In the case of conflicting
1036: declarations, both will have the same name, yet
1037: the types will be different, hence the TREE_TYPE field
1038: of the first name will be clobbered by the second. */
1039: OB_PUTS ("operator ");
1040: dump_type (TREE_TYPE (TREE_TYPE (fndecl)), &p);
1041: }
1042: else if (IDENTIFIER_OPNAME_P (name))
1043: {
1044: char *name_string = operator_name_string (name);
1045: OB_PUTS ("operator ");
1046: OB_PUTCP (name_string);
1047: OB_PUTC (' ');
1048: }
1049: else if (DECL_CONSTRUCTOR_P (fndecl))
1050: {
1051: #ifdef SOS
1052: if (TYPE_DYNAMIC (IDENTIFIER_TYPE_VALUE (cname)))
1053: {
1054: OB_PUTS ("dynamic ");
1055: parmtypes = TREE_CHAIN (parmtypes);
1056: }
1057: #endif
1058: dump_decl (DECL_NAME (fndecl));
1059: }
1060: else
1061: {
1062: #if 0
1063: if (WRAPPER_NAME_P (name))
1064: OB_PUTC2 ('(', ')');
1065: if (WRAPPER_PRED_NAME_P (name))
1066: OB_PUTS ("()?");
1067: else if (ANTI_WRAPPER_NAME_P (name))
1068: OB_PUTS ("~()");
1069: #endif
1070: dump_decl (DECL_NAME (fndecl));
1071: }
1072:
1073: OB_PUTC ('(');
1074: if (parmtypes)
1075: {
1076: in_parmlist++;
1077: if (parmtypes != void_list_node)
1078: spaces = 2;
1079: while (parmtypes && parmtypes != void_list_node)
1080: {
1081: char *last_space;
1082: dump_type (TREE_VALUE (parmtypes), &p);
1083: last_space = (char *)obstack_next_free (&scratch_obstack);
1084: while (last_space[-1] == ' ')
1085: last_space--;
1086: scratch_obstack.next_free = last_space;
1087: if (TREE_PURPOSE (parmtypes))
1088: {
1089: scratch_error_offset = obstack_object_size (&scratch_obstack);
1090: OB_PUTS (" (= ");
1091: dump_init (TREE_PURPOSE (parmtypes));
1092: OB_PUTC (')');
1093: }
1094: OB_PUTC2 (',', ' ');
1095: parmtypes = TREE_CHAIN (parmtypes);
1096: }
1097: in_parmlist--;
1098: }
1099:
1100: if (parmtypes)
1101: {
1102: if (spaces)
1103: scratch_obstack.next_free = obstack_next_free (&scratch_obstack)-spaces;
1104: }
1105: else
1106: OB_PUTS ("...");
1107:
1108: OB_PUTC (')');
1109:
1110: if (print_ret_type_p && ! IDENTIFIER_TYPENAME_P (name))
1111: dump_type_suffix (TREE_TYPE (fntype), &p);
1112:
1113: if (TREE_CODE (fntype) == METHOD_TYPE)
1114: dump_readonly_or_volatile (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (fntype))));
1115:
1116: OB_FINISH ();
1117:
1118: return (char *)obstack_base (&scratch_obstack);
1119: }
1120:
1121: /* Same, but handtype a _TYPE. */
1122: char *
1123: type_as_string (buf, typ)
1124: char *buf;
1125: tree typ;
1126: {
1127: int p = 0;
1128: int spaces = 0;
1129:
1130: OB_INIT ();
1131:
1132: dump_type(typ,&p);
1133:
1134: OB_FINISH ();
1135:
1136: return (char *)obstack_base (&scratch_obstack);
1137: }
1138:
1139: /* Move inline function defintions out of structure so that they
1140: can be processed normally. CNAME is the name of the class
1141: we are working from, METHOD_LIST is the list of method lists
1142: of the structure. We delete friend methods here, after
1143: saving away their inline function definitions (if any). */
1144:
1145: void
1146: do_inline_function_hair (type, friend_list)
1147: tree type, friend_list;
1148: {
1149: tree cname = TYPE_IDENTIFIER (type);
1150: tree method = TYPE_METHODS (type);
1151:
1152: if (method && TREE_CODE (method) == TREE_VEC)
1153: {
1154: if (TREE_VEC_ELT (method, 0))
1155: method = TREE_VEC_ELT (method, 0);
1156: else
1157: method = TREE_VEC_ELT (method, 1);
1158: }
1159:
1160: while (method)
1161: {
1162: /* Do inline member functions. */
1163: struct pending_inline *info = DECL_PENDING_INLINE_INFO (method);
1164: if (info)
1165: {
1166: tree args;
1167:
1168: assert (info->fndecl == method);
1169: args = DECL_ARGUMENTS (method);
1170: while (args)
1171: {
1172: DECL_CONTEXT (args) = method;
1173: args = TREE_CHAIN (args);
1174: }
1175:
1176: /* Allow this decl to be seen in global scope */
1177: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (method)) = method;
1178: }
1179: method = TREE_CHAIN (method);
1180: }
1181: while (friend_list)
1182: {
1183: tree fndecl = TREE_VALUE (friend_list);
1184: struct pending_inline *info = DECL_PENDING_INLINE_INFO (fndecl);
1185: if (info)
1186: {
1187: tree args;
1188:
1189: assert (info->fndecl == fndecl);
1190: args = DECL_ARGUMENTS (fndecl);
1191: while (args)
1192: {
1193: DECL_CONTEXT (args) = fndecl;
1194: args = TREE_CHAIN (args);
1195: }
1196:
1197: /* Allow this decl to be seen in global scope */
1198: IDENTIFIER_GLOBAL_VALUE (DECL_ASSEMBLER_NAME (fndecl)) = fndecl;
1199: }
1200:
1201: friend_list = TREE_CHAIN (friend_list);
1202: }
1203: }
1204:
1205: /* Report a argument type mismatch between the best declared function
1206: we could find and the current argument list that we have. */
1207: void
1208: report_type_mismatch (cp, parmtypes, name_kind, err_name)
1209: struct candidate *cp;
1210: tree parmtypes;
1211: char *name_kind, *err_name;
1212: {
1213: int i = cp->u.bad_arg;
1214: tree ttf, tta;
1215: char *tmp_firstobj;
1216:
1217: switch (i)
1218: {
1219: case -4:
1220: assert (TREE_CODE (cp->function) == TEMPLATE_DECL);
1221: error ("type unification failed for function template `%s'", err_name);
1222: return;
1223:
1224: case -3:
1225: if (TYPE_READONLY (TREE_TYPE (TREE_VALUE (parmtypes))))
1226: error ("call to const %s `%s' with non-const object", name_kind, err_name);
1227: else
1228: error ("call to non-const %s `%s' with const object", name_kind, err_name);
1229: return;
1230: case -2:
1231: error ("too few arguments for %s `%s'", name_kind, err_name);
1232: return;
1233: case -1:
1234: error ("too many arguments for %s `%s'", name_kind, err_name);
1235: return;
1236: case 0:
1237: if (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE)
1238: {
1239: /* Happens when we have an ambiguous base class. */
1240: assert (get_binfo (DECL_CLASS_CONTEXT (cp->function),
1241: TREE_TYPE (TREE_TYPE (TREE_VALUE (parmtypes))), 1) == error_mark_node);
1242: return;
1243: }
1244: }
1245:
1246: ttf = TYPE_ARG_TYPES (TREE_TYPE (cp->function));
1247: tta = parmtypes;
1248:
1249: while (i-- > 0)
1250: {
1251: ttf = TREE_CHAIN (ttf);
1252: tta = TREE_CHAIN (tta);
1253: }
1254:
1255: OB_INIT ();
1256: OB_PUTS ("bad argument ");
1257: sprintf (digit_buffer, "%d",
1258: cp->u.bad_arg - (TREE_CODE (TREE_TYPE (cp->function)) == METHOD_TYPE));
1259: OB_PUTCP (digit_buffer);
1260: OB_PUTS (" for function `");
1261:
1262: tmp_firstobj = scratch_firstobj;
1263: scratch_firstobj = 0;
1264: fndecl_as_string (0, cp->function, 0);
1265: scratch_firstobj = tmp_firstobj;
1266:
1267: /* We know that the last char written is next_free-1. */
1268: ((char *) obstack_next_free (&scratch_obstack))[-1] = '\'';
1269: OB_PUTS (" (type was ");
1270:
1271: /* Reset `i' so that type printing routines do the right thing. */
1272: if (tta)
1273: {
1274: enum tree_code code = TREE_CODE (TREE_TYPE (TREE_VALUE (tta)));
1275: if (code == ERROR_MARK)
1276: OB_PUTS ("(failed type instatiation)");
1277: else
1278: {
1279: i = (code == FUNCTION_TYPE || code == METHOD_TYPE);
1280: dump_type (TREE_TYPE (TREE_VALUE (tta)), &i);
1281: }
1282: }
1283: else OB_PUTS ("void");
1284: OB_PUTC (')');
1285: OB_FINISH ();
1286:
1287: tmp_firstobj = (char *)alloca (obstack_object_size (&scratch_obstack));
1288: bcopy (obstack_base (&scratch_obstack), tmp_firstobj,
1289: obstack_object_size (&scratch_obstack));
1290: error (tmp_firstobj);
1291: }
1292:
1293: /* Here is where overload code starts. */
1294:
1295: /* Array of types seen so far in top-level call to `build_overload_name'.
1296: Allocated and deallocated by caller. */
1297: static tree *typevec;
1298:
1299: /* Number of types interned by `build_overload_name' so far. */
1300: static int maxtype;
1301:
1302: /* Number of occurances of last type seen. */
1303: static int nrepeats;
1304:
1305: /* Nonzero if we should not try folding parameter types. */
1306: static int nofold;
1307:
1308: #define ALLOCATE_TYPEVEC(PARMTYPES) \
1309: do { maxtype = 0, nrepeats = 0; \
1310: typevec = (tree *)alloca (list_length (PARMTYPES) * sizeof (tree)); } while (0)
1311:
1312: #define DEALLOCATE_TYPEVEC(PARMTYPES) \
1313: do { tree t = (PARMTYPES); \
1314: while (t) { TREE_USED (TREE_VALUE (t)) = 0; t = TREE_CHAIN (t); } \
1315: } while (0)
1316:
1317: /* Code to concatenate an asciified integer to a string,
1318: and return the end of the string. */
1319: static
1320: #ifdef __GNUC__
1321: __inline
1322: #endif
1323: char *
1324: icat (i)
1325: int i;
1326: {
1327: if (i < 0)
1328: {
1329: OB_PUTC ('m');
1330: i = -i;
1331: }
1332: if (i < 10)
1333: OB_PUTC ('0' + i);
1334: else
1335: {
1336: icat (i / 10);
1337: OB_PUTC ('0' + (i % 10));
1338: }
1339: }
1340:
1341: static
1342: #ifdef __GNUC__
1343: __inline
1344: #endif
1345: void
1346: flush_repeats (type)
1347: tree type;
1348: {
1349: int tindex = 0;
1350: char *rval;
1351:
1352: while (typevec[tindex] != type)
1353: tindex++;
1354:
1355: if (nrepeats > 1)
1356: {
1357: OB_PUTC ('N');
1358: icat (nrepeats);
1359: if (nrepeats > 9)
1360: OB_PUTC ('_');
1361: }
1362: else
1363: OB_PUTC ('T');
1364: nrepeats = 0;
1365: icat (tindex);
1366: if (tindex > 9)
1367: OB_PUTC ('_');
1368: }
1369:
1370: static void build_overload_identifier ();
1371:
1372: static void
1373: build_overload_nested_name (context)
1374: tree context;
1375: {
1376: tree name = DECL_ASSEMBLER_NAME (context);
1377: if (DECL_CONTEXT (context))
1378: {
1379: context = DECL_CONTEXT (context);
1380: if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
1381: context = TYPE_NAME (context);
1382: build_overload_nested_name (context);
1383: }
1384: build_overload_identifier (name);
1385: }
1386:
1387: static void
1388: build_overload_value (type, value)
1389: tree type, value;
1390: {
1391: char buf[40];
1392: while (TREE_CODE (value) == NON_LVALUE_EXPR)
1393: value = TREE_OPERAND (value, 0);
1394: assert (TREE_CODE (type) == PARM_DECL);
1395: type = TREE_TYPE (type);
1396: switch (TREE_CODE (type))
1397: {
1398: case INTEGER_TYPE:
1399: case ENUMERAL_TYPE:
1400: {
1401: assert (TREE_CODE (value) == INTEGER_CST);
1402: if (TYPE_MODE (value) == DImode)
1403: {
1404: if (tree_int_cst_lt (value, integer_zero_node))
1405: {
1406: OB_PUTC ('m');
1407: value = build_int_2 (~ TREE_INT_CST_LOW (value),
1408: - TREE_INT_CST_HIGH (value));
1409: }
1410: if (TREE_INT_CST_HIGH (value) != (TREE_INT_CST_LOW (value) >> 31))
1411: {
1412: /* need to print a DImode value in decimal */
1413: sorry ("conversion of long long as PT parameter");
1414: }
1415: /* else fall through to print in smaller mode */
1416: }
1417: /* SImode or smaller */
1418: icat (TREE_INT_CST_LOW (value));
1419: return;
1420: }
1421: #ifndef REAL_IS_NOT_DOUBLE
1422: case REAL_TYPE:
1423: {
1424: REAL_VALUE_TYPE val;
1425: char *bufp = digit_buffer;
1426:
1427: assert (TREE_CODE (value) == REAL_CST);
1428: val = TREE_REAL_CST (value);
1429: if (val < 0)
1430: {
1431: val = -val;
1432: *bufp++ = 'm';
1433: }
1434: sprintf (bufp, "%e", val);
1435: bufp = strchr (bufp, 'e');
1436: if (!bufp)
1437: strcat (buf, "e0");
1438: else
1439: {
1440: char *p;
1441: bufp++;
1442: if (*bufp == '-')
1443: {
1444: *bufp++ = 'm';
1445: }
1446: p = bufp;
1447: if (*p == '+')
1448: p++;
1449: while (*p == '0')
1450: p++;
1451: if (*p == 0)
1452: {
1453: *bufp++ = '0';
1454: *bufp = 0;
1455: }
1456: else if (p != bufp)
1457: {
1458: while (*p)
1459: *bufp++ = *p++;
1460: *bufp = 0;
1461: }
1462: }
1463: OB_PUTCP (buf);
1464: return;
1465: }
1466: #endif
1467: case POINTER_TYPE:
1468: value = TREE_OPERAND (value, 0);
1469: if (TREE_CODE (value) == VAR_DECL)
1470: {
1471: assert (DECL_NAME (value) != 0);
1472: build_overload_identifier (DECL_NAME (value));
1473: return;
1474: }
1475: else
1476: {
1477: debug_tree (type);
1478: debug_tree (value);
1479: abort ();
1480: }
1481: default:
1482: sorry ("conversion of %s as PT parameter",
1483: tree_code_name [(int) TREE_CODE (type)]);
1484: abort ();
1485: }
1486: }
1487:
1488: static void
1489: build_overload_identifier (name)
1490: tree name;
1491: {
1492: if (IDENTIFIER_TEMPLATE (name))
1493: {
1494: tree template, parmlist, arglist, tname;
1495: int i, nparms;
1496: template = IDENTIFIER_TEMPLATE (name);
1497: arglist = TREE_VALUE (template);
1498: template = TREE_PURPOSE (template);
1499: tname = DECL_NAME (template);
1500: parmlist = DECL_ARGUMENTS (template);
1501: nparms = TREE_VEC_LENGTH (parmlist);
1502: OB_PUTC ('t');
1503: icat (IDENTIFIER_LENGTH (tname));
1504: OB_PUTID (tname);
1505: icat (nparms);
1506: for (i = 0; i < nparms; i++)
1507: {
1508: tree parm = TREE_VEC_ELT (parmlist, i);
1509: tree arg = TREE_VEC_ELT (arglist, i);
1510: if (TREE_CODE (parm) == IDENTIFIER_NODE)
1511: {
1512: /* This parameter is a type. */
1513: OB_PUTC ('Z');
1514: build_overload_name (arg, 0, 0);
1515: }
1516: else
1517: {
1518: /* It's a PARM_DECL. */
1519: build_overload_name (TREE_TYPE (parm), 0, 0);
1520: build_overload_value (parm, arg);
1521: }
1522: }
1523: }
1524: else
1525: {
1526: icat (IDENTIFIER_LENGTH (name));
1527: OB_PUTID (name);
1528: }
1529: }
1530:
1531: /* Given a list of parameters in PARMTYPES, create an unambiguous
1532: overload string. Should distinguish any type that C (or C++) can
1533: distinguish. I.e., pointers to functions are treated correctly.
1534:
1535: Caller must deal with whether a final `e' goes on the end or not.
1536:
1537: Any default conversions must take place before this function
1538: is called.
1539:
1540: BEGIN and END control initialization and finalization of the
1541: obstack where we build the string. */
1542:
1543: char *
1544: build_overload_name (parmtypes, begin, end)
1545: tree parmtypes;
1546: int begin, end;
1547: {
1548: int just_one;
1549: tree parmtype;
1550:
1551: if (begin) OB_INIT ();
1552:
1553: if (just_one = (TREE_CODE (parmtypes) != TREE_LIST))
1554: {
1555: parmtype = parmtypes;
1556: goto only_one;
1557: }
1558:
1559: while (parmtypes)
1560: {
1561: parmtype = TREE_VALUE (parmtypes);
1562:
1563: only_one:
1564:
1565: if (! nofold)
1566: {
1567: if (! just_one)
1568: /* Every argument gets counted. */
1569: typevec[maxtype++] = parmtype;
1570:
1571: if (TREE_USED (parmtype))
1572: {
1573: if (! just_one && parmtype == typevec[maxtype-2])
1574: nrepeats++;
1575: else
1576: {
1577: if (nrepeats)
1578: flush_repeats (parmtype);
1579: if (! just_one && TREE_CHAIN (parmtypes)
1580: && parmtype == TREE_VALUE (TREE_CHAIN (parmtypes)))
1581: nrepeats++;
1582: else
1583: {
1584: int tindex = 0;
1585:
1586: while (typevec[tindex] != parmtype)
1587: tindex++;
1588: OB_PUTC ('T');
1589: icat (tindex);
1590: if (tindex > 9)
1591: OB_PUTC ('_');
1592: }
1593: }
1594: goto next;
1595: }
1596: if (nrepeats)
1597: flush_repeats (typevec[maxtype-2]);
1598: if (! just_one
1599: /* Only cache types which take more than one character. */
1600: && (parmtype != TYPE_MAIN_VARIANT (parmtype)
1601: || (TREE_CODE (parmtype) != INTEGER_TYPE
1602: && TREE_CODE (parmtype) != REAL_TYPE)))
1603: TREE_USED (parmtype) = 1;
1604: }
1605:
1606: if (TREE_READONLY (parmtype))
1607: OB_PUTC ('C');
1608: if (TREE_CODE (parmtype) == INTEGER_TYPE
1609: && TYPE_MAIN_VARIANT (parmtype) == unsigned_type (TYPE_MAIN_VARIANT (parmtype)))
1610: OB_PUTC ('U');
1611: if (TYPE_VOLATILE (parmtype))
1612: OB_PUTC ('V');
1613:
1614: switch (TREE_CODE (parmtype))
1615: {
1616: case OFFSET_TYPE:
1617: OB_PUTC ('O');
1618: build_overload_name (TYPE_OFFSET_BASETYPE (parmtype), 0, 0);
1619: OB_PUTC ('_');
1620: build_overload_name (TREE_TYPE (parmtype), 0, 0);
1621: break;
1622:
1623: case REFERENCE_TYPE:
1624: OB_PUTC ('R');
1625: goto more;
1626:
1627: case ARRAY_TYPE:
1628: #if PARM_CAN_BE_ARRAY_TYPE
1629: {
1630: tree length;
1631:
1632: OB_PUTC ('A');
1633: length = array_type_nelts (parmtype);
1634: if (TREE_CODE (length) == INTEGER_CST)
1635: icat (TREE_INT_CST_LOW (length) + 1);
1636: OB_PUTC ('_');
1637: goto more;
1638: }
1639: #else
1640: OB_PUTC ('P');
1641: goto more;
1642: #endif
1643:
1644: case POINTER_TYPE:
1645: OB_PUTC ('P');
1646: more:
1647: build_overload_name (TREE_TYPE (parmtype), 0, 0);
1648: break;
1649:
1650: case FUNCTION_TYPE:
1651: case METHOD_TYPE:
1652: {
1653: tree firstarg = TYPE_ARG_TYPES (parmtype);
1654: /* Otherwise have to implement reentrant typevecs,
1655: unmark and remark types, etc. */
1656: int old_nofold = nofold;
1657: nofold = 1;
1658:
1659: if (nrepeats)
1660: flush_repeats (typevec[maxtype-1]);
1661:
1662: /* @@ It may be possible to pass a function type in
1663: which is not preceded by a 'P'. */
1664: if (TREE_CODE (parmtype) == FUNCTION_TYPE)
1665: {
1666: OB_PUTC ('F');
1667: if (firstarg == NULL_TREE)
1668: OB_PUTC ('e');
1669: else if (firstarg == void_list_node)
1670: OB_PUTC ('v');
1671: else
1672: build_overload_name (firstarg, 0, 0);
1673: }
1674: else
1675: {
1676: int constp = TYPE_READONLY (TREE_TYPE (TREE_VALUE (firstarg)));
1677: int volatilep = TYPE_VOLATILE (TREE_TYPE (TREE_VALUE (firstarg)));
1678: OB_PUTC ('M');
1679: firstarg = TREE_CHAIN (firstarg);
1680:
1681: build_overload_name (TYPE_METHOD_BASETYPE (parmtype), 0, 0);
1682: if (constp)
1683: OB_PUTC ('C');
1684: if (volatilep)
1685: OB_PUTC ('V');
1686:
1687: /* For cfront 2.0 compatability. */
1688: OB_PUTC ('F');
1689:
1690: if (firstarg == NULL_TREE)
1691: OB_PUTC ('e');
1692: else if (firstarg == void_list_node)
1693: OB_PUTC ('v');
1694: else
1695: build_overload_name (firstarg, 0, 0);
1696: }
1697:
1698: /* Separate args from return type. */
1699: OB_PUTC ('_');
1700: build_overload_name (TREE_TYPE (parmtype), 0, 0);
1701: nofold = old_nofold;
1702: break;
1703: }
1704:
1705: case INTEGER_TYPE:
1706: parmtype = TYPE_MAIN_VARIANT (parmtype);
1707: switch (TYPE_MODE (parmtype))
1708: {
1709: case TImode:
1710: if (parmtype == long_integer_type_node
1711: || parmtype == long_unsigned_type_node)
1712: OB_PUTC ('l');
1713: else
1714: OB_PUTC ('q');
1715: break;
1716: case DImode:
1717: if (parmtype == long_integer_type_node
1718: || parmtype == long_unsigned_type_node)
1719: OB_PUTC ('l');
1720: else if (parmtype == integer_type_node
1721: || parmtype == unsigned_type_node)
1722: OB_PUTC ('i');
1723: else if (parmtype == short_integer_type_node
1724: || parmtype == short_unsigned_type_node)
1725: OB_PUTC ('s');
1726: else
1727: OB_PUTC ('x');
1728: break;
1729: case SImode:
1730: if (parmtype == long_integer_type_node
1731: || parmtype == long_unsigned_type_node)
1732: OB_PUTC ('l');
1733: else if (parmtype == short_integer_type_node
1734: || parmtype == short_unsigned_type_node)
1735: OB_PUTC ('s');
1736: else
1737: OB_PUTC ('i');
1738: break;
1739: case HImode:
1740: if (parmtype == integer_type_node
1741: || parmtype == unsigned_type_node)
1742: OB_PUTC ('i');
1743: else
1744: OB_PUTC ('s');
1745: break;
1746: case QImode:
1747: OB_PUTC ('c');
1748: break;
1749: default:
1750: abort ();
1751: }
1752: break;
1753:
1754: case REAL_TYPE:
1755: parmtype = TYPE_MAIN_VARIANT (parmtype);
1756: if (parmtype == long_double_type_node)
1757: OB_PUTC ('r');
1758: else if (parmtype == double_type_node)
1759: OB_PUTC ('d');
1760: else if (parmtype == float_type_node)
1761: OB_PUTC ('f');
1762: else abort ();
1763: break;
1764:
1765: case VOID_TYPE:
1766: if (! just_one)
1767: {
1768: #if 0
1769: extern tree void_list_node;
1770:
1771: /* See if anybody is wasting memory. */
1772: assert (parmtypes == void_list_node);
1773: #endif
1774: /* This is the end of a parameter list. */
1775: if (end) OB_FINISH ();
1776: return (char *)obstack_base (&scratch_obstack);
1777: }
1778: OB_PUTC ('v');
1779: break;
1780:
1781: case ERROR_MARK: /* not right, but nothing is anyway */
1782: break;
1783:
1784: /* have to do these */
1785: case UNION_TYPE:
1786: case RECORD_TYPE:
1787: if (! just_one)
1788: /* Make this type signature look incompatible
1789: with AT&T. */
1790: OB_PUTC ('G');
1791: goto common;
1792: case ENUMERAL_TYPE:
1793: common:
1794: {
1795: tree name = TYPE_NAME (parmtype);
1796: int i = 1;
1797:
1798: if (TREE_CODE (name) == TYPE_DECL)
1799: {
1800: tree context = name;
1801: while (DECL_CONTEXT (context))
1802: {
1803: i += 1;
1804: context = DECL_CONTEXT (context);
1805: if (TREE_CODE_CLASS (TREE_CODE (context)) == 't')
1806: context = TYPE_NAME (context);
1807: }
1808: name = DECL_NAME (name);
1809: }
1810: assert (TREE_CODE (name) == IDENTIFIER_NODE);
1811: if (i > 1)
1812: {
1813: OB_PUTC ('Q');
1814: icat (i);
1815: build_overload_nested_name (TYPE_NAME (parmtype));
1816: }
1817: else
1818: build_overload_identifier (name);
1819: break;
1820: }
1821:
1822: case UNKNOWN_TYPE:
1823: /* This will take some work. */
1824: OB_PUTC ('?');
1825: break;
1826:
1827: case TEMPLATE_TYPE_PARM:
1828: case TEMPLATE_CONST_PARM:
1829: case UNINSTANTIATED_P_TYPE:
1830: /* We don't ever want this output, but it's inconvenient not to
1831: be able to build the string. This should cause assembler
1832: errors we'll notice. */
1833: {
1834: static int n;
1835: sprintf (digit_buffer, " *%d", n++);
1836: OB_PUTCP (digit_buffer);
1837: }
1838: break;
1839:
1840: default:
1841: abort ();
1842: }
1843:
1844: next:
1845: if (just_one) break;
1846: parmtypes = TREE_CHAIN (parmtypes);
1847: }
1848: if (! just_one)
1849: {
1850: if (nrepeats)
1851: flush_repeats (typevec[maxtype-1]);
1852:
1853: /* To get here, parms must end with `...'. */
1854: OB_PUTC ('e');
1855: }
1856:
1857: if (end) OB_FINISH ();
1858: return (char *)obstack_base (&scratch_obstack);
1859: }
1860:
1861: /* Generate an identifier that encodes the (ANSI) exception TYPE. */
1862:
1863: /* This should be part of `ansi_opname', or at least be defined by the std. */
1864: #define EXCEPTION_NAME_PREFIX "__ex"
1865: #define EXCEPTION_NAME_LENGTH 4
1866:
1867: tree
1868: cplus_exception_name (type)
1869: tree type;
1870: {
1871: OB_INIT ();
1872: OB_PUTS (EXCEPTION_NAME_PREFIX);
1873: return get_identifier (build_overload_name (type, 0, 1));
1874: }
1875:
1876: /* Change the name of a function definition so that it may be
1877: overloaded. NAME is the name of the function to overload,
1878: PARMS is the parameter list (which determines what name the
1879: final function obtains).
1880:
1881: FOR_METHOD is 1 if this overload is being performed
1882: for a method, rather than a function type. It is 2 if
1883: this overload is being performed for a constructor. */
1884: tree
1885: build_decl_overload (name, parms, for_method)
1886: char *name;
1887: tree parms;
1888: int for_method;
1889: {
1890: OB_INIT ();
1891: if (for_method != 2)
1892: OB_PUTCP (name);
1893: /* Otherwise, we can divine that this is a constructor,
1894: and figure out its name without any extra encoding. */
1895:
1896: OB_PUTC2 ('_', '_');
1897: if (for_method)
1898: {
1899: #if 0
1900: /* We can get away without doing this. */
1901: OB_PUTC ('M');
1902: #endif
1903: parms = temp_tree_cons (NULL_TREE, TREE_TYPE (TREE_VALUE (parms)), TREE_CHAIN (parms));
1904: }
1905: else
1906: OB_PUTC ('F');
1907:
1908: if (parms == NULL_TREE)
1909: OB_PUTC2 ('e', '\0');
1910: else if (parms == void_list_node)
1911: OB_PUTC2 ('v', '\0');
1912: else
1913: {
1914: ALLOCATE_TYPEVEC (parms);
1915: nofold = 0;
1916: if (for_method)
1917: {
1918: build_overload_name (TREE_VALUE (parms), 0, 0);
1919:
1920: typevec[maxtype++] = TREE_VALUE (parms);
1921: TREE_USED (TREE_VALUE (parms)) = 1;
1922:
1923: if (TREE_CHAIN (parms))
1924: build_overload_name (TREE_CHAIN (parms), 0, 1);
1925: else
1926: OB_PUTC2 ('e', '\0');
1927: }
1928: else
1929: build_overload_name (parms, 0, 1);
1930: DEALLOCATE_TYPEVEC (parms);
1931: }
1932: return get_identifier (obstack_base (&scratch_obstack));
1933: }
1934:
1935: /* Build an overload name for the type expression TYPE. */
1936: tree
1937: build_typename_overload (type)
1938: tree type;
1939: {
1940: OB_INIT ();
1941: OB_PUTID (ansi_opname[TYPE_EXPR]);
1942:
1943: #if 0
1944: /* We can get away without doing this--it really gets
1945: overloaded later. */
1946: OB_PUTC2 ('_', '_');
1947: OB_PUTC ('M');
1948: #endif
1949: nofold = 1;
1950: build_overload_name (type, 0, 1);
1951: return get_identifier (obstack_base (&scratch_obstack));
1952: }
1953:
1954: #define T_DESC_FORMAT "TD$"
1955: #define I_DESC_FORMAT "ID$"
1956: #define M_DESC_FORMAT "MD$"
1957:
1958: /* Build an overload name for the type expression TYPE. */
1959: tree
1960: build_t_desc_overload (type)
1961: tree type;
1962: {
1963: int i = sizeof (T_DESC_FORMAT) - 1;
1964:
1965: OB_INIT ();
1966: OB_PUTS (T_DESC_FORMAT);
1967: nofold = 1;
1968:
1969: #if 0
1970: /* Use a different format if the type isn't defined yet. */
1971: if (TYPE_SIZE (type) == NULL_TREE)
1972: {
1973: char *p;
1974: int changed;
1975:
1976: for (p = tname; *p; p++)
1977: if (isupper (*p))
1978: {
1979: changed = 1;
1980: *p = tolower (*p);
1981: }
1982: /* If there's no change, we have an innappropriate T_DESC_FORMAT. */
1983: assert (changed != 0);
1984: }
1985: #endif
1986:
1987: build_overload_name (type, 0, 1);
1988: return get_identifier (obstack_base (&scratch_obstack));
1989: }
1990:
1991: /* Top-level interface to explicit overload requests. Allow NAME
1992: to be overloaded. Error if NAME is already declared for the current
1993: scope. Warning if function is redundanly overloaded. */
1994:
1995: void
1996: declare_overloaded (name)
1997: tree name;
1998: {
1999: #ifdef NO_AUTO_OVERLOAD
2000: if (is_overloaded (name))
2001: warning ("function `%s' already declared overloaded",
2002: IDENTIFIER_POINTER (name));
2003: else if (IDENTIFIER_GLOBAL_VALUE (name))
2004: error ("overloading function `%s' that is already defined",
2005: IDENTIFIER_POINTER (name));
2006: else
2007: {
2008: TREE_OVERLOADED (name) = 1;
2009: IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
2010: TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
2011: }
2012: #else
2013: if (current_lang_name == lang_name_cplusplus)
2014: {
2015: if (0)
2016: warning ("functions are implicitly overloaded in C++");
2017: }
2018: else if (current_lang_name == lang_name_c)
2019: error ("overloading function `%s' cannot be done in C language context");
2020: else
2021: abort ();
2022: #endif
2023: }
2024:
2025: #ifdef NO_AUTO_OVERLOAD
2026: /* Check to see if NAME is overloaded. For first approximation,
2027: check to see if its TREE_OVERLOADED is set. This is used on
2028: IDENTIFIER nodes. */
2029: int
2030: is_overloaded (name)
2031: tree name;
2032: {
2033: /* @@ */
2034: return (TREE_OVERLOADED (name)
2035: && (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
2036: && ! IDENTIFIER_LOCAL_VALUE (name));
2037: }
2038: #endif
2039:
2040: /* Given a tree_code CODE, and some arguments (at least one),
2041: attempt to use an overloaded operator on the arguments.
2042:
2043: For unary operators, only the first argument need be checked.
2044: For binary operators, both arguments may need to be checked.
2045:
2046: Member functions can convert class references to class pointers,
2047: for one-level deep indirection. More than that is not supported.
2048: Operators [](), ()(), and ->() must be member functions.
2049:
2050: We call function call building calls with nonzero complain if
2051: they are our only hope. This is true when we see a vanilla operator
2052: applied to something of aggregate type. If this fails, we are free to
2053: return `error_mark_node', because we will have reported the error.
2054:
2055: Operators NEW and DELETE overload in funny ways: operator new takes
2056: a single `size' parameter, and operator delete takes a pointer to the
2057: storage being deleted. When overloading these operators, success is
2058: assumed. If there is a failure, report an error message and return
2059: `error_mark_node'. */
2060:
2061: /* NOSTRICT */
2062: tree
2063: build_opfncall (code, flags, xarg1, xarg2, arg3)
2064: enum tree_code code;
2065: tree xarg1, xarg2;
2066: tree arg3;
2067: {
2068: tree rval = 0;
2069: tree arg1, arg2;
2070: tree type1, type2, fnname;
2071: tree fields1 = 0, parms = 0;
2072: tree global_fn;
2073: int try_second;
2074: int binary_is_unary;
2075:
2076: if (xarg1 == error_mark_node)
2077: return error_mark_node;
2078:
2079: if (code == COND_EXPR)
2080: {
2081: if (TREE_CODE (xarg2) == ERROR_MARK
2082: || TREE_CODE (arg3) == ERROR_MARK)
2083: return error_mark_node;
2084: }
2085: if (code == COMPONENT_REF)
2086: if (TREE_CODE (TREE_TYPE (xarg1)) == POINTER_TYPE)
2087: return rval;
2088:
2089: /* First, see if we can work with the first argument */
2090: type1 = TREE_TYPE (xarg1);
2091:
2092: /* Some tree codes have length > 1, but we really only want to
2093: overload them if their first argument has a user defined type. */
2094: switch (code)
2095: {
2096: case PREINCREMENT_EXPR:
2097: code = POSTINCREMENT_EXPR;
2098: binary_is_unary = 1;
2099: try_second = 0;
2100: break;
2101:
2102: case POSTDECREMENT_EXPR:
2103: code = PREDECREMENT_EXPR;
2104: binary_is_unary = 1;
2105: try_second = 0;
2106: break;
2107:
2108: case PREDECREMENT_EXPR:
2109: case POSTINCREMENT_EXPR:
2110: case COMPONENT_REF:
2111: binary_is_unary = 1;
2112: try_second = 0;
2113: break;
2114:
2115: /* ARRAY_REFs and CALL_EXPRs must overload successfully.
2116: If they do not, return error_mark_node instead of NULL_TREE. */
2117: case ARRAY_REF:
2118: if (xarg2 == error_mark_node)
2119: return error_mark_node;
2120: case CALL_EXPR:
2121: rval = error_mark_node;
2122: binary_is_unary = 0;
2123: try_second = 0;
2124: break;
2125:
2126: case NEW_EXPR:
2127: {
2128: /* For operators `new' (`delete'), only check visibility
2129: if we are in a constructor (destructor), and we are
2130: allocating for that constructor's (destructor's) type. */
2131:
2132: fnname = ansi_opname[NEW_EXPR];
2133: if (flags & LOOKUP_GLOBAL)
2134: return build_overload_call (fnname, tree_cons (NULL_TREE, xarg2, arg3),
2135: flags & LOOKUP_COMPLAIN, 0);
2136:
2137: if (current_function_decl == NULL_TREE
2138: || !DECL_CONSTRUCTOR_P (current_function_decl)
2139: || current_class_type != TYPE_MAIN_VARIANT (type1))
2140: flags = LOOKUP_COMPLAIN;
2141: rval = build_method_call (build1 (NOP_EXPR, xarg1, error_mark_node),
2142: fnname, tree_cons (NULL_TREE, xarg2, arg3),
2143: NULL_TREE, flags);
2144: if (rval == error_mark_node)
2145: /* User might declare fancy operator new, but invoke it
2146: like standard one. */
2147: return rval;
2148:
2149: TREE_TYPE (rval) = xarg1;
2150: TREE_CALLS_NEW (rval) = 1;
2151: return rval;
2152: }
2153: break;
2154:
2155: case DELETE_EXPR:
2156: {
2157: /* See comment above. */
2158:
2159: fnname = ansi_opname[DELETE_EXPR];
2160: if (flags & LOOKUP_GLOBAL)
2161: return build_overload_call (fnname, build_tree_list (NULL_TREE, xarg1),
2162: flags & LOOKUP_COMPLAIN, 0);
2163:
2164: if (current_function_decl == NULL_TREE
2165: || !DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (current_function_decl))
2166: || current_class_type != TYPE_MAIN_VARIANT (type1))
2167: flags = LOOKUP_COMPLAIN;
2168: rval = build_method_call (build1 (NOP_EXPR, TREE_TYPE (xarg1), error_mark_node),
2169: fnname, build_tree_list (NULL_TREE, xarg1),
2170: NULL_TREE, flags);
2171: /* This happens when the user mis-declares `operator delete'.
2172: Should now be impossible. */
2173: assert (rval != error_mark_node);
2174: TREE_TYPE (rval) = void_type_node;
2175: return rval;
2176: }
2177: break;
2178:
2179: default:
2180: binary_is_unary = 0;
2181: try_second = tree_code_length [(int) code] == 2;
2182: if (try_second && xarg2 == error_mark_node)
2183: return error_mark_node;
2184: break;
2185: }
2186:
2187: if (try_second && xarg2 == error_mark_node)
2188: return error_mark_node;
2189:
2190: /* What ever it was, we do not know how to deal with it. */
2191: if (type1 == NULL_TREE)
2192: return rval;
2193:
2194: if (TREE_CODE (type1) == OFFSET_TYPE)
2195: type1 = TREE_TYPE (type1);
2196:
2197: if (TREE_CODE (type1) == REFERENCE_TYPE)
2198: {
2199: arg1 = convert_from_reference (xarg1);
2200: type1 = TREE_TYPE (arg1);
2201: }
2202: else
2203: {
2204: arg1 = xarg1;
2205: }
2206:
2207: if (!IS_AGGR_TYPE (type1))
2208: {
2209: /* Try to fail. First, fail if unary */
2210: if (! try_second)
2211: return rval;
2212: /* Second, see if second argument is non-aggregate. */
2213: type2 = TREE_TYPE (xarg2);
2214: if (TREE_CODE (type2) == OFFSET_TYPE)
2215: type2 = TREE_TYPE (type2);
2216: if (TREE_CODE (type2) == REFERENCE_TYPE)
2217: {
2218: arg2 = convert_from_reference (xarg2);
2219: type2 = TREE_TYPE (arg2);
2220: }
2221: else
2222: {
2223: arg2 = xarg2;
2224: }
2225:
2226: if (!IS_AGGR_TYPE (type2))
2227: return rval;
2228: try_second = 0;
2229: }
2230:
2231: if (try_second)
2232: {
2233: /* First arg may succeed; see whether second should. */
2234: type2 = TREE_TYPE (xarg2);
2235: if (TREE_CODE (type2) == OFFSET_TYPE)
2236: type2 = TREE_TYPE (type2);
2237: if (TREE_CODE (type2) == REFERENCE_TYPE)
2238: {
2239: arg2 = convert_from_reference (xarg2);
2240: type2 = TREE_TYPE (arg2);
2241: }
2242: else
2243: {
2244: arg2 = xarg2;
2245: }
2246:
2247: if (! IS_AGGR_TYPE (type2))
2248: try_second = 0;
2249: }
2250:
2251: if (type1 == unknown_type_node
2252: || (try_second && TREE_TYPE (xarg2) == unknown_type_node))
2253: {
2254: /* This will not be implemented in the forseeable future. */
2255: return rval;
2256: }
2257:
2258: if (code == MODIFY_EXPR)
2259: fnname = ansi_assopname[(int)arg3];
2260: else
2261: fnname = ansi_opname[code];
2262:
2263: global_fn = IDENTIFIER_GLOBAL_VALUE (fnname);
2264:
2265: /* This is the last point where we will accept failure. This
2266: may be too eager if we wish an overloaded operator not to match,
2267: but would rather a normal operator be called on a type-converted
2268: argument. */
2269:
2270: if (IS_AGGR_TYPE (type1))
2271: fields1 = lookup_fnfields (TYPE_BINFO (type1), fnname, 0);
2272:
2273: if (fields1 == NULL_TREE && global_fn == NULL_TREE)
2274: return rval;
2275:
2276: /* If RVAL winds up being `error_mark_node', we will return
2277: that... There is no way that normal semantics of these
2278: operators will succeed. */
2279:
2280: /* This argument may be an uncommited OFFSET_REF. This is
2281: the case for example when dealing with static class members
2282: which are referenced from their class name rather than
2283: from a class instance. */
2284: if (TREE_CODE (xarg1) == OFFSET_REF
2285: && TREE_CODE (TREE_OPERAND (xarg1, 1)) == VAR_DECL)
2286: xarg1 = TREE_OPERAND (xarg1, 1);
2287: if (try_second && xarg2 && TREE_CODE (xarg2) == OFFSET_REF
2288: && TREE_CODE (TREE_OPERAND (xarg2, 1)) == VAR_DECL)
2289: xarg2 = TREE_OPERAND (xarg2, 1);
2290:
2291: if (global_fn)
2292: flags |= LOOKUP_GLOBAL;
2293:
2294: if (code == CALL_EXPR)
2295: {
2296: /* This can only be a member function. */
2297: return build_method_call (xarg1, fnname, xarg2,
2298: NULL_TREE, LOOKUP_NORMAL);
2299: }
2300: else if (tree_code_length[(int) code] == 1 || binary_is_unary)
2301: {
2302: parms = NULL_TREE;
2303: rval = build_method_call (xarg1, fnname, NULL_TREE, NULL_TREE, flags);
2304: }
2305: else if (code == COND_EXPR)
2306: {
2307: parms = tree_cons (0, xarg2, build_tree_list (0, arg3));
2308: rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
2309: }
2310: else if (code == METHOD_CALL_EXPR)
2311: {
2312: /* must be a member function. */
2313: parms = tree_cons (NULL_TREE, xarg2, arg3);
2314: return build_method_call (xarg1, fnname, parms, NULL_TREE, LOOKUP_NORMAL);
2315: }
2316: else if (fields1)
2317: {
2318: parms = build_tree_list (NULL_TREE, xarg2);
2319: rval = build_method_call (xarg1, fnname, parms, NULL_TREE, flags);
2320: }
2321: else
2322: {
2323: parms = tree_cons (NULL_TREE, xarg1,
2324: build_tree_list (NULL_TREE, xarg2));
2325: rval = build_overload_call (fnname, parms, flags & LOOKUP_COMPLAIN, 0);
2326: }
2327:
2328: /* If we did not win, do not lose yet, since type conversion may work. */
2329: if (TREE_CODE (rval) == ERROR_MARK)
2330: {
2331: if (flags & LOOKUP_COMPLAIN)
2332: return rval;
2333: return 0;
2334: }
2335:
2336: return rval;
2337: }
2338:
2339: /* This function takes an identifier, ID, and attempts to figure out what
2340: it means. There are a number of possible scenarios, presented in increasing
2341: order of hair:
2342:
2343: 1) not in a class's scope
2344: 2) in class's scope, member name of the class's method
2345: 3) in class's scope, but not a member name of the class
2346: 4) in class's scope, member name of a class's variable
2347:
2348: NAME is $1 from the bison rule. It is an IDENTIFIER_NODE.
2349: VALUE is $$ from the bison rule. It is the value returned by lookup_name ($1)
2350: yychar is the pending input character (suitably encoded :-).
2351:
2352: As a last ditch, try to look up the name as a label and return that
2353: address.
2354:
2355: Values which are declared as being of REFERENCE_TYPE are
2356: automatically dereferenced here (as a hack to make the
2357: compiler faster). */
2358:
2359: tree
2360: hack_identifier (value, name, yychar)
2361: tree value, name;
2362: {
2363: tree type;
2364:
2365: if (TREE_CODE (value) == ERROR_MARK)
2366: {
2367: if (current_class_name)
2368: {
2369: tree fields = lookup_fnfields (TYPE_BINFO (current_class_type), name, 0);
2370: if (fields)
2371: {
2372: tree fndecl;
2373:
2374: fndecl = TREE_VALUE (fields);
2375: assert (TREE_CODE (fndecl) == FUNCTION_DECL);
2376: if (DECL_CHAIN (fndecl) == NULL_TREE)
2377: {
2378: warning ("methods cannot be converted to function pointers");
2379: return fndecl;
2380: }
2381: else
2382: {
2383: error ("ambiguous request for method pointer `%s'",
2384: IDENTIFIER_POINTER (name));
2385: return error_mark_node;
2386: }
2387: }
2388: }
2389: if (flag_labels_ok && IDENTIFIER_LABEL_VALUE (name))
2390: {
2391: return IDENTIFIER_LABEL_VALUE (name);
2392: }
2393: return error_mark_node;
2394: }
2395:
2396: type = TREE_TYPE (value);
2397: if (TREE_CODE (value) == FIELD_DECL)
2398: {
2399: if (current_class_decl == NULL_TREE)
2400: {
2401: error ("request for member `%s' in static member function",
2402: IDENTIFIER_POINTER (DECL_NAME (value)));
2403: return error_mark_node;
2404: }
2405: TREE_USED (current_class_decl) = 1;
2406: if (yychar == '(')
2407: if (! ((TYPE_LANG_SPECIFIC (type)
2408: && TYPE_OVERLOADS_CALL_EXPR (type))
2409: || (TREE_CODE (type) == REFERENCE_TYPE
2410: && TYPE_LANG_SPECIFIC (TREE_TYPE (type))
2411: && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (type))))
2412: && TREE_CODE (type) != FUNCTION_TYPE
2413: && TREE_CODE (type) != METHOD_TYPE
2414: && (TREE_CODE (type) != POINTER_TYPE
2415: || (TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE
2416: && TREE_CODE (TREE_TYPE (type)) != METHOD_TYPE)))
2417: {
2418: error ("component `%s' is not a method",
2419: IDENTIFIER_POINTER (name));
2420: return error_mark_node;
2421: }
2422: /* Mark so that if we are in a constructor, and then find that
2423: this field was initialized by a base initializer,
2424: we can emit an error message. */
2425: TREE_USED (value) = 1;
2426: return build_component_ref (C_C_D, name, 0, 1);
2427: }
2428:
2429: if (TREE_CODE (value) == TREE_LIST)
2430: {
2431: tree t = value;
2432: while (t && TREE_CODE (t) == TREE_LIST)
2433: {
2434: assemble_external (TREE_VALUE (t));
2435: TREE_USED (t) = 1;
2436: t = TREE_CHAIN (t);
2437: }
2438: }
2439: else
2440: {
2441: assemble_external (value);
2442: TREE_USED (value) = 1;
2443: }
2444:
2445: if (TREE_CODE_CLASS (TREE_CODE (value)) == 'd' && TREE_NONLOCAL (value))
2446: {
2447: if (DECL_CLASS_CONTEXT (value) != current_class_type)
2448: {
2449: tree path;
2450: enum visibility_type visibility;
2451:
2452: get_base_distance (DECL_CLASS_CONTEXT (value),
2453: current_class_type, 0, &path);
2454: visibility = compute_visibility (path, value);
2455: if (visibility != visibility_public)
2456: {
2457: if (TREE_CODE (value) == VAR_DECL)
2458: error ("static member `%s' is from private base class",
2459: IDENTIFIER_POINTER (name));
2460: else
2461: error ("enum `%s' is from private base class",
2462: IDENTIFIER_POINTER (name));
2463: return error_mark_node;
2464: }
2465: }
2466: if (TREE_CODE (value) == VAR_DECL && ! TREE_USED (value))
2467: {
2468: if (TREE_EXTERNAL (value))
2469: assemble_external (value);
2470: TREE_USED (value) = 1;
2471: }
2472: return value;
2473: }
2474: if (TREE_CODE (value) == TREE_LIST && TREE_NONLOCAL_FLAG (value))
2475: {
2476: if (type == 0)
2477: {
2478: error ("request for member `%s' is ambiguous in multiple inheritance lattice",
2479: IDENTIFIER_POINTER (name));
2480: return error_mark_node;
2481: }
2482:
2483: return value;
2484: }
2485:
2486: if (TREE_CODE (type) == REFERENCE_TYPE)
2487: {
2488: assert (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == PARM_DECL);
2489: if (DECL_REFERENCE_SLOT (value))
2490: return DECL_REFERENCE_SLOT (value);
2491: }
2492: return value;
2493: }
2494:
2495: /* NONWRAPPER is nonzero if this call is not to be wrapped.
2496: TYPE is the type that the wrapper belongs to (in case
2497: it should be non-virtual).
2498: DECL is the function will will be (not be) wrapped. */
2499: tree
2500: hack_wrapper (nonwrapper, type, decl)
2501: int nonwrapper;
2502: tree type, decl;
2503: {
2504: if (type == NULL_TREE || is_aggr_typedef (type, 1))
2505: {
2506: if (type)
2507: type = TREE_TYPE (type);
2508:
2509: switch (nonwrapper)
2510: {
2511: case 0:
2512: return build_nt (WRAPPER_EXPR, type, decl);
2513: case 1:
2514: return build_nt (ANTI_WRAPPER_EXPR, type, decl);
2515: case 2:
2516: return build_nt (WRAPPER_EXPR, type,
2517: build_nt (COND_EXPR, decl, NULL_TREE, NULL_TREE));
2518: default:
2519: assert (0 <= nonwrapper && nonwrapper <= 2);
2520: }
2521: }
2522: return error_mark_node;
2523: }
2524:
2525: /* Given an object OF, and a type conversion operator COMPONENT
2526: build a call to the conversion operator, if a call is requested,
2527: or return the address (as a pointer to member function) if one is not.
2528:
2529: OF can be a TYPE_DECL or any kind of datum that would normally
2530: be passed to `build_component_ref'. It may also be NULL_TREE,
2531: in which case `current_class_type' and `current_class_decl'
2532: provide default values.
2533:
2534: BASETYPE_PATH, if non-null, is the path of basetypes
2535: to go through before we get the the instance of interest.
2536:
2537: PROTECT says whether we apply C++ scoping rules or not. */
2538: tree
2539: build_component_type_expr (of, component, basetype_path, protect)
2540: tree of, component, basetype_path;
2541: int protect;
2542: {
2543: tree cname = NULL_TREE;
2544: tree tmp, last;
2545: tree name;
2546: int flags = protect ? LOOKUP_NORMAL : LOOKUP_COMPLAIN;
2547:
2548: assert (IS_AGGR_TYPE (TREE_TYPE (of)));
2549: assert (TREE_CODE (component) == TYPE_EXPR);
2550:
2551: tmp = TREE_OPERAND (component, 0);
2552: last = NULL_TREE;
2553:
2554: while (tmp)
2555: {
2556: switch (TREE_CODE (tmp))
2557: {
2558: case CALL_EXPR:
2559: if (last)
2560: TREE_OPERAND (last, 0) = TREE_OPERAND (tmp, 0);
2561: else
2562: TREE_OPERAND (component, 0) = TREE_OPERAND (tmp, 0);
2563: if (TREE_OPERAND (tmp, 0)
2564: && TREE_OPERAND (tmp, 0) != void_list_node)
2565: {
2566: error ("operator <typename> requires empty parameter list");
2567: TREE_OPERAND (tmp, 0) = NULL_TREE;
2568: }
2569: last = groktypename (build_tree_list (TREE_TYPE (component),
2570: TREE_OPERAND (component, 0)));
2571: name = build_typename_overload (last);
2572: TREE_TYPE (name) = last;
2573:
2574: if (of && TREE_CODE (of) != TYPE_DECL)
2575: return build_method_call (of, name, NULL_TREE, NULL_TREE, flags);
2576: else if (of)
2577: {
2578: tree this_this;
2579:
2580: if (current_class_decl == NULL_TREE)
2581: {
2582: error ("object required for `operator <typename>' call");
2583: return error_mark_node;
2584: }
2585:
2586: this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
2587: return build_method_call (this_this, name, NULL_TREE,
2588: NULL_TREE, flags | LOOKUP_NONVIRTUAL);
2589: }
2590: else if (current_class_decl)
2591: return build_method_call (tmp, name, NULL_TREE, NULL_TREE, flags);
2592:
2593: error ("object required for `operator <typename>' call");
2594: return error_mark_node;
2595:
2596: case INDIRECT_REF:
2597: case ADDR_EXPR:
2598: case ARRAY_REF:
2599: break;
2600:
2601: case SCOPE_REF:
2602: assert (cname == 0);
2603: cname = TREE_OPERAND (tmp, 0);
2604: tmp = TREE_OPERAND (tmp, 1);
2605: break;
2606:
2607: default:
2608: abort ();
2609: }
2610: last = tmp;
2611: tmp = TREE_OPERAND (tmp, 0);
2612: }
2613:
2614: last = groktypename (build_tree_list (TREE_TYPE (component), TREE_OPERAND (component, 0)));
2615: name = build_typename_overload (last);
2616: TREE_TYPE (name) = last;
2617: if (of && TREE_CODE (of) == TYPE_DECL)
2618: {
2619: if (cname == NULL_TREE)
2620: {
2621: cname = DECL_NAME (of);
2622: of = NULL_TREE;
2623: }
2624: else assert (cname == DECL_NAME (of));
2625: }
2626:
2627: if (of)
2628: {
2629: tree this_this;
2630:
2631: if (current_class_decl == NULL_TREE)
2632: {
2633: error ("object required for `operator <typename>' call");
2634: return error_mark_node;
2635: }
2636:
2637: this_this = convert_pointer_to (TREE_TYPE (of), current_class_decl);
2638: return build_component_ref (this_this, name, 0, protect);
2639: }
2640: else if (cname)
2641: return build_offset_ref (cname, name);
2642: else if (current_class_name)
2643: return build_offset_ref (current_class_name, name);
2644:
2645: error ("object required for `operator <typename>' member reference");
2646: return error_mark_node;
2647: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.