Update to gcc-3.4.6
[dragonfly.git] / contrib / gcc-3.4 / gcc / cp / lex.c
CommitLineData
003757ed
MD
1/* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING. If not, write to
20the Free Software Foundation, 59 Temple Place - Suite 330,
21Boston, MA 02111-1307, USA. */
22
23
24/* This file is the lexical analyzer for GNU C++. */
25
26#include "config.h"
27#include "system.h"
28#include "coretypes.h"
29#include "tm.h"
30#include "input.h"
31#include "tree.h"
32#include "cp-tree.h"
33#include "cpplib.h"
34#include "lex.h"
35#include "flags.h"
36#include "c-pragma.h"
37#include "toplev.h"
38#include "output.h"
39#include "tm_p.h"
40#include "timevar.h"
41
42static int interface_strcmp (const char *);
43static void init_cp_pragma (void);
44
45static tree parse_strconst_pragma (const char *, int);
46static void handle_pragma_vtable (cpp_reader *);
47static void handle_pragma_unit (cpp_reader *);
48static void handle_pragma_interface (cpp_reader *);
49static void handle_pragma_implementation (cpp_reader *);
50static void handle_pragma_java_exceptions (cpp_reader *);
51
52static void init_operators (void);
53static void copy_lang_type (tree);
54
55/* A constraint that can be tested at compile time. */
56#define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
57
58/* Functions and data structures for #pragma interface.
59
60 `#pragma implementation' means that the main file being compiled
61 is considered to implement (provide) the classes that appear in
62 its main body. I.e., if this is file "foo.cc", and class `bar'
63 is defined in "foo.cc", then we say that "foo.cc implements bar".
64
65 All main input files "implement" themselves automagically.
66
67 `#pragma interface' means that unless this file (of the form "foo.h"
68 is not presently being included by file "foo.cc", the
69 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
70 of the vtables nor any of the inline functions defined in foo.h
71 will ever be output.
72
73 There are cases when we want to link files such as "defs.h" and
74 "main.cc". In this case, we give "defs.h" a `#pragma interface',
75 and "main.cc" has `#pragma implementation "defs.h"'. */
76
77struct impl_files
78{
79 const char *filename;
80 struct impl_files *next;
81};
82
83static struct impl_files *impl_file_chain;
84
85\f
86/* Return something to represent absolute declarators containing a *.
87 TARGET is the absolute declarator that the * contains.
88 CV_QUALIFIERS is a list of modifiers such as const or volatile
89 to apply to the pointer type, represented as identifiers.
90
91 We return an INDIRECT_REF whose "contents" are TARGET
92 and whose type is the modifier list. */
93
94tree
95make_pointer_declarator (tree cv_qualifiers, tree target)
96{
97 if (target && TREE_CODE (target) == IDENTIFIER_NODE
98 && ANON_AGGRNAME_P (target))
99 error ("type name expected before `*'");
100 target = build_nt (INDIRECT_REF, target);
101 TREE_TYPE (target) = cv_qualifiers;
102 return target;
103}
104
105/* Return something to represent absolute declarators containing a &.
106 TARGET is the absolute declarator that the & contains.
107 CV_QUALIFIERS is a list of modifiers such as const or volatile
108 to apply to the reference type, represented as identifiers.
109
110 We return an ADDR_EXPR whose "contents" are TARGET
111 and whose type is the modifier list. */
112
113tree
114make_reference_declarator (tree cv_qualifiers, tree target)
115{
116 target = build_nt (ADDR_EXPR, target);
117 TREE_TYPE (target) = cv_qualifiers;
118 return target;
119}
120
121tree
122make_call_declarator (tree target, tree parms, tree cv_qualifiers,
123 tree exception_specification)
124{
125 target = build_nt (CALL_EXPR, target,
126 tree_cons (parms, cv_qualifiers, NULL_TREE),
127 /* The third operand is really RTL. We
128 shouldn't put anything there. */
129 NULL_TREE);
130 CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
131 return target;
132}
133
134void
135set_quals_and_spec (tree call_declarator, tree cv_qualifiers,
136 tree exception_specification)
137{
138 CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
139 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
140}
141\f
142int interface_only; /* whether or not current file is only for
143 interface definitions. */
144int interface_unknown; /* whether or not we know this class
145 to behave according to #pragma interface. */
146
147\f
148void
149cxx_finish (void)
150{
151 c_common_finish ();
152}
153
154/* A mapping from tree codes to operator name information. */
155operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
156/* Similar, but for assignment operators. */
157operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
158
159/* Initialize data structures that keep track of operator names. */
160
161#define DEF_OPERATOR(NAME, C, M, AR, AP) \
162 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
163#include "operators.def"
164#undef DEF_OPERATOR
165
166static void
167init_operators (void)
168{
169 tree identifier;
170 char buffer[256];
171 struct operator_name_info_t *oni;
172
173#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
174 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
175 identifier = get_identifier (buffer); \
176 IDENTIFIER_OPNAME_P (identifier) = 1; \
177 \
178 oni = (ASSN_P \
179 ? &assignment_operator_name_info[(int) CODE] \
180 : &operator_name_info[(int) CODE]); \
181 oni->identifier = identifier; \
182 oni->name = NAME; \
183 oni->mangled_name = MANGLING; \
184 oni->arity = ARITY;
185
186#include "operators.def"
187#undef DEF_OPERATOR
188
189 operator_name_info[(int) ERROR_MARK].identifier
190 = get_identifier ("<invalid operator>");
191
192 /* Handle some special cases. These operators are not defined in
193 the language, but can be produced internally. We may need them
194 for error-reporting. (Eventually, we should ensure that this
195 does not happen. Error messages involving these operators will
196 be confusing to users.) */
197
198 operator_name_info [(int) INIT_EXPR].name
199 = operator_name_info [(int) MODIFY_EXPR].name;
200 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
201 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
202 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
203 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
204 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
205 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
206 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
207 operator_name_info [(int) ABS_EXPR].name = "abs";
208 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
209 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
210 operator_name_info [(int) IN_EXPR].name = "in";
211 operator_name_info [(int) RANGE_EXPR].name = "...";
212 operator_name_info [(int) CONVERT_EXPR].name = "+";
213
214 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
215 = "(exact /=)";
216 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
217 = "(ceiling /=)";
218 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
219 = "(floor /=)";
220 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
221 = "(round /=)";
222 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
223 = "(ceiling %=)";
224 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
225 = "(floor %=)";
226 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
227 = "(round %=)";
228}
229
230/* The reserved keyword table. */
231struct resword
232{
233 const char *const word;
234 ENUM_BITFIELD(rid) const rid : 16;
235 const unsigned int disable : 16;
236};
237
238/* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
239 _true_. */
240#define D_EXT 0x01 /* GCC extension */
241#define D_ASM 0x02 /* in C99, but has a switch to turn it off */
242
243CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
244
245static const struct resword reswords[] =
246{
247 { "_Complex", RID_COMPLEX, 0 },
248 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
249 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
250 { "__alignof", RID_ALIGNOF, 0 },
251 { "__alignof__", RID_ALIGNOF, 0 },
252 { "__asm", RID_ASM, 0 },
253 { "__asm__", RID_ASM, 0 },
254 { "__attribute", RID_ATTRIBUTE, 0 },
255 { "__attribute__", RID_ATTRIBUTE, 0 },
256 { "__builtin_va_arg", RID_VA_ARG, 0 },
257 { "__complex", RID_COMPLEX, 0 },
258 { "__complex__", RID_COMPLEX, 0 },
259 { "__const", RID_CONST, 0 },
260 { "__const__", RID_CONST, 0 },
261 { "__extension__", RID_EXTENSION, 0 },
262 { "__func__", RID_C99_FUNCTION_NAME, 0 },
263 { "__imag", RID_IMAGPART, 0 },
264 { "__imag__", RID_IMAGPART, 0 },
265 { "__inline", RID_INLINE, 0 },
266 { "__inline__", RID_INLINE, 0 },
267 { "__label__", RID_LABEL, 0 },
268 { "__null", RID_NULL, 0 },
269 { "__offsetof", RID_OFFSETOF, 0 },
270 { "__offsetof__", RID_OFFSETOF, 0 },
271 { "__real", RID_REALPART, 0 },
272 { "__real__", RID_REALPART, 0 },
273 { "__restrict", RID_RESTRICT, 0 },
274 { "__restrict__", RID_RESTRICT, 0 },
275 { "__signed", RID_SIGNED, 0 },
276 { "__signed__", RID_SIGNED, 0 },
277 { "__thread", RID_THREAD, 0 },
278 { "__typeof", RID_TYPEOF, 0 },
279 { "__typeof__", RID_TYPEOF, 0 },
280 { "__volatile", RID_VOLATILE, 0 },
281 { "__volatile__", RID_VOLATILE, 0 },
282 { "asm", RID_ASM, D_ASM },
283 { "auto", RID_AUTO, 0 },
284 { "bool", RID_BOOL, 0 },
285 { "break", RID_BREAK, 0 },
286 { "case", RID_CASE, 0 },
287 { "catch", RID_CATCH, 0 },
288 { "char", RID_CHAR, 0 },
289 { "class", RID_CLASS, 0 },
290 { "const", RID_CONST, 0 },
291 { "const_cast", RID_CONSTCAST, 0 },
292 { "continue", RID_CONTINUE, 0 },
293 { "default", RID_DEFAULT, 0 },
294 { "delete", RID_DELETE, 0 },
295 { "do", RID_DO, 0 },
296 { "double", RID_DOUBLE, 0 },
297 { "dynamic_cast", RID_DYNCAST, 0 },
298 { "else", RID_ELSE, 0 },
299 { "enum", RID_ENUM, 0 },
300 { "explicit", RID_EXPLICIT, 0 },
301 { "export", RID_EXPORT, 0 },
302 { "extern", RID_EXTERN, 0 },
303 { "false", RID_FALSE, 0 },
304 { "float", RID_FLOAT, 0 },
305 { "for", RID_FOR, 0 },
306 { "friend", RID_FRIEND, 0 },
307 { "goto", RID_GOTO, 0 },
308 { "if", RID_IF, 0 },
309 { "inline", RID_INLINE, 0 },
310 { "int", RID_INT, 0 },
311 { "long", RID_LONG, 0 },
312 { "mutable", RID_MUTABLE, 0 },
313 { "namespace", RID_NAMESPACE, 0 },
314 { "new", RID_NEW, 0 },
315 { "operator", RID_OPERATOR, 0 },
316 { "private", RID_PRIVATE, 0 },
317 { "protected", RID_PROTECTED, 0 },
318 { "public", RID_PUBLIC, 0 },
319 { "register", RID_REGISTER, 0 },
320 { "reinterpret_cast", RID_REINTCAST, 0 },
321 { "return", RID_RETURN, 0 },
322 { "short", RID_SHORT, 0 },
323 { "signed", RID_SIGNED, 0 },
324 { "sizeof", RID_SIZEOF, 0 },
325 { "static", RID_STATIC, 0 },
326 { "static_cast", RID_STATCAST, 0 },
327 { "struct", RID_STRUCT, 0 },
328 { "switch", RID_SWITCH, 0 },
329 { "template", RID_TEMPLATE, 0 },
330 { "this", RID_THIS, 0 },
331 { "throw", RID_THROW, 0 },
332 { "true", RID_TRUE, 0 },
333 { "try", RID_TRY, 0 },
334 { "typedef", RID_TYPEDEF, 0 },
335 { "typename", RID_TYPENAME, 0 },
336 { "typeid", RID_TYPEID, 0 },
337 { "typeof", RID_TYPEOF, D_ASM|D_EXT },
338 { "union", RID_UNION, 0 },
339 { "unsigned", RID_UNSIGNED, 0 },
340 { "using", RID_USING, 0 },
341 { "virtual", RID_VIRTUAL, 0 },
342 { "void", RID_VOID, 0 },
343 { "volatile", RID_VOLATILE, 0 },
344 { "wchar_t", RID_WCHAR, 0 },
345 { "while", RID_WHILE, 0 },
346
347};
348
349void
350init_reswords (void)
351{
352 unsigned int i;
353 tree id;
354 int mask = ((flag_no_asm ? D_ASM : 0)
355 | (flag_no_gnu_keywords ? D_EXT : 0));
356
357 ridpointers = ggc_calloc ((int) RID_MAX, sizeof (tree));
358 for (i = 0; i < ARRAY_SIZE (reswords); i++)
359 {
360 id = get_identifier (reswords[i].word);
361 C_RID_CODE (id) = reswords[i].rid;
362 ridpointers [(int) reswords[i].rid] = id;
363 if (! (reswords[i].disable & mask))
364 C_IS_RESERVED_WORD (id) = 1;
365 }
366}
367
368static void
369init_cp_pragma (void)
370{
371 c_register_pragma (0, "vtable", handle_pragma_vtable);
372 c_register_pragma (0, "unit", handle_pragma_unit);
373 c_register_pragma (0, "interface", handle_pragma_interface);
374 c_register_pragma (0, "implementation", handle_pragma_implementation);
375 c_register_pragma ("GCC", "interface", handle_pragma_interface);
376 c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
377 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
378}
379\f
380/* Initialize the C++ front end. This function is very sensitive to
381 the exact order that things are done here. It would be nice if the
382 initialization done by this routine were moved to its subroutines,
383 and the ordering dependencies clarified and reduced. */
384bool
385cxx_init (void)
386{
387 static const enum tree_code stmt_codes[] = {
388 c_common_stmt_codes,
389 cp_stmt_codes
390 };
391
392 INIT_STATEMENT_CODES (stmt_codes);
393
394 /* We cannot just assign to input_filename because it has already
395 been initialized and will be used later as an N_BINCL for stabs+
396 debugging. */
397 push_srcloc ("<internal>", 0);
398
399 init_reswords ();
400 init_tree ();
401 init_cp_semantics ();
402 init_operators ();
403 init_method ();
404 init_error ();
405
406 current_function_decl = NULL;
407
408 class_type_node = ridpointers[(int) RID_CLASS];
409
410 cxx_init_decl_processing ();
411
412 /* Create the built-in __null node. */
413 null_node = build_int_2 (0, 0);
414 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
415 ridpointers[RID_NULL] = null_node;
416
417 interface_unknown = 1;
418
419 if (c_common_init () == false)
420 {
421 pop_srcloc();
422 return false;
423 }
424
425 init_cp_pragma ();
426
427 init_repo (main_input_filename);
428
429 pop_srcloc();
430 return true;
431}
432\f
433/* Helper function to load global variables with interface
434 information. */
435
436void
437extract_interface_info (void)
438{
439 struct c_fileinfo *finfo;
440
441 finfo = get_fileinfo (input_filename);
442 interface_only = finfo->interface_only;
443 interface_unknown = finfo->interface_unknown;
444}
445
446/* Return nonzero if S is not considered part of an
447 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
448
449static int
450interface_strcmp (const char* s)
451{
452 /* Set the interface/implementation bits for this scope. */
453 struct impl_files *ifiles;
454 const char *s1;
455
456 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
457 {
458 const char *t1 = ifiles->filename;
459 s1 = s;
460
461 if (*s1 != *t1 || *s1 == 0)
462 continue;
463
464 while (*s1 == *t1 && *s1 != 0)
465 s1++, t1++;
466
467 /* A match. */
468 if (*s1 == *t1)
469 return 0;
470
471 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
472 if (strchr (s1, '.') || strchr (t1, '.'))
473 continue;
474
475 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
476 continue;
477
478 /* A match. */
479 return 0;
480 }
481
482 /* No matches. */
483 return 1;
484}
485
486\f
487
488/* Parse a #pragma whose sole argument is a string constant.
489 If OPT is true, the argument is optional. */
490static tree
491parse_strconst_pragma (const char* name, int opt)
492{
493 tree result, x;
494 enum cpp_ttype t;
495
496 t = c_lex (&x);
497 if (t == CPP_STRING)
498 {
499 result = x;
500 if (c_lex (&x) != CPP_EOF)
501 warning ("junk at end of #pragma %s", name);
502 return result;
503 }
504
505 if (t == CPP_EOF && opt)
506 return 0;
507
508 error ("invalid #pragma %s", name);
509 return (tree)-1;
510}
511
512static void
513handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
514{
515 parse_strconst_pragma ("vtable", 0);
516 sorry ("#pragma vtable no longer supported");
517}
518
519static void
520handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
521{
522 /* Validate syntax, but don't do anything. */
523 parse_strconst_pragma ("unit", 0);
524}
525
526static void
527handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
528{
529 tree fname = parse_strconst_pragma ("interface", 1);
530 struct c_fileinfo *finfo;
531 const char *main_filename;
532
533 if (fname == (tree)-1)
534 return;
535 else if (fname == 0)
536 main_filename = lbasename (input_filename);
537 else
538 main_filename = TREE_STRING_POINTER (fname);
539
540 finfo = get_fileinfo (input_filename);
541
542 if (impl_file_chain == 0)
543 {
544 /* If this is zero at this point, then we are
545 auto-implementing. */
546 if (main_input_filename == 0)
547 main_input_filename = input_filename;
548 }
549
550 interface_only = interface_strcmp (main_filename);
551#ifdef MULTIPLE_SYMBOL_SPACES
552 if (! interface_only)
553#endif
554 interface_unknown = 0;
555
556 finfo->interface_only = interface_only;
557 finfo->interface_unknown = interface_unknown;
558}
559
560/* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
561 We used to only allow this at toplevel, but that restriction was buggy
562 in older compilers and it seems reasonable to allow it in the headers
563 themselves, too. It only needs to precede the matching #p interface.
564
565 We don't touch interface_only or interface_unknown; the user must specify
566 a matching #p interface for this to have any effect. */
567
568static void
569handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
570{
571 tree fname = parse_strconst_pragma ("implementation", 1);
572 const char *main_filename;
573 struct impl_files *ifiles = impl_file_chain;
574
575 if (fname == (tree)-1)
576 return;
577
578 if (fname == 0)
579 {
580 if (main_input_filename)
581 main_filename = main_input_filename;
582 else
583 main_filename = input_filename;
584 main_filename = lbasename (main_filename);
585 }
586 else
587 {
588 main_filename = TREE_STRING_POINTER (fname);
589 if (cpp_included (parse_in, main_filename))
590 warning ("#pragma implementation for %s appears after file is included",
591 main_filename);
592 }
593
594 for (; ifiles; ifiles = ifiles->next)
595 {
596 if (! strcmp (ifiles->filename, main_filename))
597 break;
598 }
599 if (ifiles == 0)
600 {
601 ifiles = xmalloc (sizeof (struct impl_files));
602 ifiles->filename = main_filename;
603 ifiles->next = impl_file_chain;
604 impl_file_chain = ifiles;
605 }
606}
607
608/* Indicate that this file uses Java-personality exception handling. */
609static void
610handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED )
611{
612 tree x;
613 if (c_lex (&x) != CPP_EOF)
614 warning ("junk at end of #pragma GCC java_exceptions");
615
616 choose_personality_routine (lang_java);
617}
618
619/* Issue an error message indicating that the lookup of NAME (an
620 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
621
622tree
623unqualified_name_lookup_error (tree name)
624{
625 if (IDENTIFIER_OPNAME_P (name))
626 {
627 if (name != ansi_opname (ERROR_MARK))
628 error ("`%D' not defined", name);
629 }
003757ed
MD
630 else
631 {
1378ea41
SS
632 error ("`%D' was not declared in this scope", name);
633 /* Prevent repeated error messages by creating a VAR_DECL with
634 this NAME in the innermost block scope. */
635 if (current_function_decl)
003757ed 636 {
1378ea41
SS
637 tree decl;
638 decl = build_decl (VAR_DECL, name, error_mark_node);
639 DECL_CONTEXT (decl) = current_function_decl;
640 push_local_binding (name, decl, 0);
003757ed 641 }
003757ed
MD
642 }
643
644 return error_mark_node;
645}
646
647/* Like unqualified_name_lookup_error, but NAME is an unqualified-id
648 used as a function. Returns an appropriate expression for
649 NAME. */
650
651tree
652unqualified_fn_lookup_error (tree name)
653{
654 if (processing_template_decl)
655 {
656 /* In a template, it is invalid to write "f()" or "f(3)" if no
657 declaration of "f" is available. Historically, G++ and most
658 other compilers accepted that usage since they deferred all name
659 lookup until instantiation time rather than doing unqualified
660 name lookup at template definition time; explain to the user what
661 is going wrong.
662
663 Note that we have the exact wording of the following message in
664 the manual (trouble.texi, node "Name lookup"), so they need to
665 be kept in synch. */
666 pedwarn ("there are no arguments to `%D' that depend on a template "
667 "parameter, so a declaration of `%D' must be available",
668 name, name);
669
670 if (!flag_permissive)
671 {
672 static bool hint;
673 if (!hint)
674 {
675 error ("(if you use `-fpermissive', G++ will accept your code, "
676 "but allowing the use of an undeclared name is "
677 "deprecated)");
678 hint = true;
679 }
680 }
681 return name;
682 }
683
684 return unqualified_name_lookup_error (name);
685}
686
687tree
688build_lang_decl (enum tree_code code, tree name, tree type)
689{
690 tree t;
691
692 t = build_decl (code, name, type);
693 retrofit_lang_decl (t);
694
695 return t;
696}
697
698/* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
699 and pushdecl (for functions generated by the backend). */
700
701void
702retrofit_lang_decl (tree t)
703{
704 struct lang_decl *ld;
705 size_t size;
706
707 if (CAN_HAVE_FULL_LANG_DECL_P (t))
708 size = sizeof (struct lang_decl);
709 else
710 size = sizeof (struct lang_decl_flags);
711
712 ld = ggc_alloc_cleared (size);
713
714 ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
715 ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
716 ld->decl_flags.u2sel = 0;
717 if (ld->decl_flags.can_be_full)
718 ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
719
720 DECL_LANG_SPECIFIC (t) = ld;
721 if (current_lang_name == lang_name_cplusplus
722 || decl_linkage (t) == lk_none)
723 SET_DECL_LANGUAGE (t, lang_cplusplus);
724 else if (current_lang_name == lang_name_c)
725 SET_DECL_LANGUAGE (t, lang_c);
726 else if (current_lang_name == lang_name_java)
727 SET_DECL_LANGUAGE (t, lang_java);
728 else abort ();
729
730#ifdef GATHER_STATISTICS
731 tree_node_counts[(int)lang_decl] += 1;
732 tree_node_sizes[(int)lang_decl] += size;
733#endif
734}
735
736void
737cxx_dup_lang_specific_decl (tree node)
738{
739 int size;
740 struct lang_decl *ld;
741
742 if (! DECL_LANG_SPECIFIC (node))
743 return;
744
745 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
746 size = sizeof (struct lang_decl_flags);
747 else
748 size = sizeof (struct lang_decl);
749 ld = ggc_alloc (size);
750 memcpy (ld, DECL_LANG_SPECIFIC (node), size);
751 DECL_LANG_SPECIFIC (node) = ld;
752
753#ifdef GATHER_STATISTICS
754 tree_node_counts[(int)lang_decl] += 1;
755 tree_node_sizes[(int)lang_decl] += size;
756#endif
757}
758
759/* Copy DECL, including any language-specific parts. */
760
761tree
762copy_decl (tree decl)
763{
764 tree copy;
765
766 copy = copy_node (decl);
767 cxx_dup_lang_specific_decl (copy);
768 return copy;
769}
770
771/* Replace the shared language-specific parts of NODE with a new copy. */
772
773static void
774copy_lang_type (tree node)
775{
776 int size;
777 struct lang_type *lt;
778
779 if (! TYPE_LANG_SPECIFIC (node))
780 return;
781
782 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
783 size = sizeof (struct lang_type);
784 else
785 size = sizeof (struct lang_type_ptrmem);
786 lt = ggc_alloc (size);
787 memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
788 TYPE_LANG_SPECIFIC (node) = lt;
789
790#ifdef GATHER_STATISTICS
791 tree_node_counts[(int)lang_type] += 1;
792 tree_node_sizes[(int)lang_type] += size;
793#endif
794}
795
796/* Copy TYPE, including any language-specific parts. */
797
798tree
799copy_type (tree type)
800{
801 tree copy;
802
803 copy = copy_node (type);
804 copy_lang_type (copy);
805 return copy;
806}
807
808tree
809cxx_make_type (enum tree_code code)
810{
811 tree t = make_node (code);
812
813 /* Create lang_type structure. */
814 if (IS_AGGR_TYPE_CODE (code)
815 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
816 {
817 struct lang_type *pi;
818
819 pi = ggc_alloc_cleared (sizeof (struct lang_type));
820
821 TYPE_LANG_SPECIFIC (t) = pi;
822 pi->u.c.h.is_lang_type_class = 1;
823
824#ifdef GATHER_STATISTICS
825 tree_node_counts[(int)lang_type] += 1;
826 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
827#endif
828 }
829
830 /* Set up some flags that give proper default behavior. */
831 if (IS_AGGR_TYPE_CODE (code))
832 {
833 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
834 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
835
836 /* Make sure this is laid out, for ease of use later. In the
837 presence of parse errors, the normal was of assuring this
838 might not ever get executed, so we lay it out *immediately*. */
839 build_pointer_type (t);
840 }
841 else
842 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
843 TYPE_ALIAS_SET is initialized to -1 by default, so we must
844 clear it here. */
845 TYPE_ALIAS_SET (t) = 0;
846
847 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
848 since they can be virtual base types, and we then need a
849 canonical binfo for them. Ideally, this would be done lazily for
850 all types. */
851 if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM
852 || code == BOUND_TEMPLATE_TEMPLATE_PARM
853 || code == TYPENAME_TYPE)
854 TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
855
856 return t;
857}
858
859tree
860make_aggr_type (enum tree_code code)
861{
862 tree t = cxx_make_type (code);
863
864 if (IS_AGGR_TYPE_CODE (code))
865 SET_IS_AGGR_TYPE (t, 1);
866
867 return t;
868}
869
870/* Return the type-qualifier corresponding to the identifier given by
871 RID. */
872
873int
874cp_type_qual_from_rid (tree rid)
875{
876 if (rid == ridpointers[(int) RID_CONST])
877 return TYPE_QUAL_CONST;
878 else if (rid == ridpointers[(int) RID_VOLATILE])
879 return TYPE_QUAL_VOLATILE;
880 else if (rid == ridpointers[(int) RID_RESTRICT])
881 return TYPE_QUAL_RESTRICT;
882
883 abort ();
884 return TYPE_UNQUALIFIED;
885}