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, 2005 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC 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 GCC 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 GCC; see the file COPYING. If not, write to
20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, 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 "flags.h"
35 #include "c-pragma.h"
36 #include "toplev.h"
37 #include "output.h"
38 #include "tm_p.h"
39 #include "timevar.h"
40
41 static int interface_strcmp (const char *);
42 static void init_cp_pragma (void);
43
44 static tree parse_strconst_pragma (const char *, int);
45 static void handle_pragma_vtable (cpp_reader *);
46 static void handle_pragma_unit (cpp_reader *);
47 static void handle_pragma_interface (cpp_reader *);
48 static void handle_pragma_implementation (cpp_reader *);
49 static void handle_pragma_java_exceptions (cpp_reader *);
50
51 static void init_operators (void);
52 static void copy_lang_type (tree);
53
54 /* A constraint that can be tested at compile time. */
55 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
56
57 /* Functions and data structures for #pragma interface.
58
59 `#pragma implementation' means that the main file being compiled
60 is considered to implement (provide) the classes that appear in
61 its main body. I.e., if this is file "foo.cc", and class `bar'
62 is defined in "foo.cc", then we say that "foo.cc implements bar".
63
64 All main input files "implement" themselves automagically.
65
66 `#pragma interface' means that unless this file (of the form "foo.h"
67 is not presently being included by file "foo.cc", the
68 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
69 of the vtables nor any of the inline functions defined in foo.h
70 will ever be output.
71
72 There are cases when we want to link files such as "defs.h" and
73 "main.cc". In this case, we give "defs.h" a `#pragma interface',
74 and "main.cc" has `#pragma implementation "defs.h"'. */
75
76 struct impl_files
77 {
78 const char *filename;
79 struct impl_files *next;
80 };
81
82 static struct impl_files *impl_file_chain;
83
84
85 void
cxx_finish(void)86 cxx_finish (void)
87 {
88 c_common_finish ();
89 }
90
91 /* A mapping from tree codes to operator name information. */
92 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
93 /* Similar, but for assignment operators. */
94 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
95
96 /* Initialize data structures that keep track of operator names. */
97
98 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
99 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
100 #include "operators.def"
101 #undef DEF_OPERATOR
102
103 static void
init_operators(void)104 init_operators (void)
105 {
106 tree identifier;
107 char buffer[256];
108 struct operator_name_info_t *oni;
109
110 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
111 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
112 identifier = get_identifier (buffer); \
113 IDENTIFIER_OPNAME_P (identifier) = 1; \
114 \
115 oni = (ASSN_P \
116 ? &assignment_operator_name_info[(int) CODE] \
117 : &operator_name_info[(int) CODE]); \
118 oni->identifier = identifier; \
119 oni->name = NAME; \
120 oni->mangled_name = MANGLING; \
121 oni->arity = ARITY;
122
123 #include "operators.def"
124 #undef DEF_OPERATOR
125
126 operator_name_info[(int) ERROR_MARK].identifier
127 = get_identifier ("<invalid operator>");
128
129 /* Handle some special cases. These operators are not defined in
130 the language, but can be produced internally. We may need them
131 for error-reporting. (Eventually, we should ensure that this
132 does not happen. Error messages involving these operators will
133 be confusing to users.) */
134
135 operator_name_info [(int) INIT_EXPR].name
136 = operator_name_info [(int) MODIFY_EXPR].name;
137 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
138 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
139 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
140 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
141 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
142 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
143 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
144 operator_name_info [(int) ABS_EXPR].name = "abs";
145 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
146 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
147 operator_name_info [(int) RANGE_EXPR].name = "...";
148 operator_name_info [(int) UNARY_PLUS_EXPR].name = "+";
149
150 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
151 = "(exact /=)";
152 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
153 = "(ceiling /=)";
154 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
155 = "(floor /=)";
156 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
157 = "(round /=)";
158 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
159 = "(ceiling %=)";
160 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
161 = "(floor %=)";
162 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
163 = "(round %=)";
164 }
165
166 /* The reserved keyword table. */
167 struct resword
168 {
169 const char *const word;
170 ENUM_BITFIELD(rid) const rid : 16;
171 const unsigned int disable : 16;
172 };
173
174 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
175 _true_. */
176 #define D_EXT 0x01 /* GCC extension */
177 #define D_ASM 0x02 /* in C99, but has a switch to turn it off */
178 #define D_OBJC 0x04 /* Objective C++ only */
179
180 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
181
182 static const struct resword reswords[] =
183 {
184 { "_Complex", RID_COMPLEX, 0 },
185 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
186 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
187 { "__alignof", RID_ALIGNOF, 0 },
188 { "__alignof__", RID_ALIGNOF, 0 },
189 { "__asm", RID_ASM, 0 },
190 { "__asm__", RID_ASM, 0 },
191 { "__attribute", RID_ATTRIBUTE, 0 },
192 { "__attribute__", RID_ATTRIBUTE, 0 },
193 { "__builtin_offsetof", RID_OFFSETOF, 0 },
194 { "__builtin_va_arg", RID_VA_ARG, 0 },
195 { "__complex", RID_COMPLEX, 0 },
196 { "__complex__", RID_COMPLEX, 0 },
197 { "__const", RID_CONST, 0 },
198 { "__const__", RID_CONST, 0 },
199 { "__extension__", RID_EXTENSION, 0 },
200 { "__func__", RID_C99_FUNCTION_NAME, 0 },
201 { "__imag", RID_IMAGPART, 0 },
202 { "__imag__", RID_IMAGPART, 0 },
203 { "__inline", RID_INLINE, 0 },
204 { "__inline__", RID_INLINE, 0 },
205 { "__label__", RID_LABEL, 0 },
206 { "__null", RID_NULL, 0 },
207 { "__real", RID_REALPART, 0 },
208 { "__real__", RID_REALPART, 0 },
209 { "__restrict", RID_RESTRICT, 0 },
210 { "__restrict__", RID_RESTRICT, 0 },
211 { "__signed", RID_SIGNED, 0 },
212 { "__signed__", RID_SIGNED, 0 },
213 { "__thread", RID_THREAD, 0 },
214 { "__typeof", RID_TYPEOF, 0 },
215 { "__typeof__", RID_TYPEOF, 0 },
216 { "__volatile", RID_VOLATILE, 0 },
217 { "__volatile__", RID_VOLATILE, 0 },
218 { "asm", RID_ASM, D_ASM },
219 { "auto", RID_AUTO, 0 },
220 { "bool", RID_BOOL, 0 },
221 { "break", RID_BREAK, 0 },
222 { "case", RID_CASE, 0 },
223 { "catch", RID_CATCH, 0 },
224 { "char", RID_CHAR, 0 },
225 { "class", RID_CLASS, 0 },
226 { "const", RID_CONST, 0 },
227 { "const_cast", RID_CONSTCAST, 0 },
228 { "continue", RID_CONTINUE, 0 },
229 { "default", RID_DEFAULT, 0 },
230 { "delete", RID_DELETE, 0 },
231 { "do", RID_DO, 0 },
232 { "double", RID_DOUBLE, 0 },
233 { "dynamic_cast", RID_DYNCAST, 0 },
234 { "else", RID_ELSE, 0 },
235 { "enum", RID_ENUM, 0 },
236 { "explicit", RID_EXPLICIT, 0 },
237 { "export", RID_EXPORT, 0 },
238 { "extern", RID_EXTERN, 0 },
239 { "false", RID_FALSE, 0 },
240 { "float", RID_FLOAT, 0 },
241 { "for", RID_FOR, 0 },
242 { "friend", RID_FRIEND, 0 },
243 { "goto", RID_GOTO, 0 },
244 { "if", RID_IF, 0 },
245 { "inline", RID_INLINE, 0 },
246 { "int", RID_INT, 0 },
247 { "long", RID_LONG, 0 },
248 { "mutable", RID_MUTABLE, 0 },
249 { "namespace", RID_NAMESPACE, 0 },
250 { "new", RID_NEW, 0 },
251 { "operator", RID_OPERATOR, 0 },
252 { "private", RID_PRIVATE, 0 },
253 { "protected", RID_PROTECTED, 0 },
254 { "public", RID_PUBLIC, 0 },
255 { "register", RID_REGISTER, 0 },
256 { "reinterpret_cast", RID_REINTCAST, 0 },
257 { "return", RID_RETURN, 0 },
258 { "short", RID_SHORT, 0 },
259 { "signed", RID_SIGNED, 0 },
260 { "sizeof", RID_SIZEOF, 0 },
261 { "static", RID_STATIC, 0 },
262 { "static_cast", RID_STATCAST, 0 },
263 { "struct", RID_STRUCT, 0 },
264 { "switch", RID_SWITCH, 0 },
265 { "template", RID_TEMPLATE, 0 },
266 { "this", RID_THIS, 0 },
267 { "throw", RID_THROW, 0 },
268 { "true", RID_TRUE, 0 },
269 { "try", RID_TRY, 0 },
270 { "typedef", RID_TYPEDEF, 0 },
271 { "typename", RID_TYPENAME, 0 },
272 { "typeid", RID_TYPEID, 0 },
273 { "typeof", RID_TYPEOF, D_ASM|D_EXT },
274 { "union", RID_UNION, 0 },
275 { "unsigned", RID_UNSIGNED, 0 },
276 { "using", RID_USING, 0 },
277 { "virtual", RID_VIRTUAL, 0 },
278 { "void", RID_VOID, 0 },
279 { "volatile", RID_VOLATILE, 0 },
280 { "wchar_t", RID_WCHAR, 0 },
281 { "while", RID_WHILE, 0 },
282
283 /* The remaining keywords are specific to Objective-C++. NB:
284 All of them will remain _disabled_, since they are context-
285 sensitive. */
286
287 /* These ObjC keywords are recognized only immediately after
288 an '@'. NB: The following C++ keywords double as
289 ObjC keywords in this context: RID_CLASS, RID_PRIVATE,
290 RID_PROTECTED, RID_PUBLIC, RID_THROW, RID_TRY and RID_CATCH. */
291 { "compatibility_alias", RID_AT_ALIAS, D_OBJC },
292 { "defs", RID_AT_DEFS, D_OBJC },
293 { "encode", RID_AT_ENCODE, D_OBJC },
294 { "end", RID_AT_END, D_OBJC },
295 { "implementation", RID_AT_IMPLEMENTATION, D_OBJC },
296 { "interface", RID_AT_INTERFACE, D_OBJC },
297 { "protocol", RID_AT_PROTOCOL, D_OBJC },
298 { "selector", RID_AT_SELECTOR, D_OBJC },
299 { "finally", RID_AT_FINALLY, D_OBJC },
300 { "synchronized", RID_AT_SYNCHRONIZED, D_OBJC },
301 /* These are recognized only in protocol-qualifier context. */
302 { "bycopy", RID_BYCOPY, D_OBJC },
303 { "byref", RID_BYREF, D_OBJC },
304 { "in", RID_IN, D_OBJC },
305 { "inout", RID_INOUT, D_OBJC },
306 { "oneway", RID_ONEWAY, D_OBJC },
307 { "out", RID_OUT, D_OBJC },
308 };
309
310 void
init_reswords(void)311 init_reswords (void)
312 {
313 unsigned int i;
314 tree id;
315 int mask = ((flag_no_asm ? D_ASM : 0)
316 | D_OBJC
317 | (flag_no_gnu_keywords ? D_EXT : 0));
318
319 ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX);
320 for (i = 0; i < ARRAY_SIZE (reswords); i++)
321 {
322 id = get_identifier (reswords[i].word);
323 C_RID_CODE (id) = reswords[i].rid;
324 ridpointers [(int) reswords[i].rid] = id;
325 if (! (reswords[i].disable & mask))
326 C_IS_RESERVED_WORD (id) = 1;
327 }
328 }
329
330 static void
init_cp_pragma(void)331 init_cp_pragma (void)
332 {
333 c_register_pragma (0, "vtable", handle_pragma_vtable);
334 c_register_pragma (0, "unit", handle_pragma_unit);
335 c_register_pragma (0, "interface", handle_pragma_interface);
336 c_register_pragma (0, "implementation", handle_pragma_implementation);
337 c_register_pragma ("GCC", "interface", handle_pragma_interface);
338 c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
339 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions);
340 }
341
342 /* TRUE if a code represents a statement. */
343
344 bool statement_code_p[MAX_TREE_CODES];
345
346 /* Initialize the C++ front end. This function is very sensitive to
347 the exact order that things are done here. It would be nice if the
348 initialization done by this routine were moved to its subroutines,
349 and the ordering dependencies clarified and reduced. */
350 bool
cxx_init(void)351 cxx_init (void)
352 {
353 unsigned int i;
354 static const enum tree_code stmt_codes[] = {
355 CTOR_INITIALIZER, TRY_BLOCK, HANDLER,
356 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN,
357 IF_STMT, CLEANUP_STMT, FOR_STMT,
358 WHILE_STMT, DO_STMT, BREAK_STMT,
359 CONTINUE_STMT, SWITCH_STMT, EXPR_STMT
360 };
361
362 memset (&statement_code_p, 0, sizeof (statement_code_p));
363 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
364 statement_code_p[stmt_codes[i]] = true;
365
366 /* We cannot just assign to input_filename because it has already
367 been initialized and will be used later as an N_BINCL for stabs+
368 debugging. */
369 #ifdef USE_MAPPED_LOCATION
370 push_srcloc (BUILTINS_LOCATION);
371 #else
372 push_srcloc ("<built-in>", 0);
373 #endif
374
375 init_reswords ();
376 init_tree ();
377 init_cp_semantics ();
378 init_operators ();
379 init_method ();
380 init_error ();
381
382 current_function_decl = NULL;
383
384 class_type_node = ridpointers[(int) RID_CLASS];
385
386 cxx_init_decl_processing ();
387
388 /* The fact that G++ uses COMDAT for many entities (inline
389 functions, template instantiations, virtual tables, etc.) mean
390 that it is fundamentally unreliable to try to make decisions
391 about whether or not to output a particular entity until the end
392 of the compilation. However, the inliner requires that functions
393 be provided to the back end if they are to be inlined.
394 Therefore, we always use unit-at-a-time mode; in that mode, we
395 can provide entities to the back end and it will decide what to
396 emit based on what is actually needed. */
397 flag_unit_at_a_time = 1;
398
399 if (c_common_init () == false)
400 {
401 pop_srcloc();
402 return false;
403 }
404
405 init_cp_pragma ();
406
407 init_repo ();
408
409 pop_srcloc();
410 return true;
411 }
412
413 /* Return nonzero if S is not considered part of an
414 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
415
416 static int
interface_strcmp(const char * s)417 interface_strcmp (const char* s)
418 {
419 /* Set the interface/implementation bits for this scope. */
420 struct impl_files *ifiles;
421 const char *s1;
422
423 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
424 {
425 const char *t1 = ifiles->filename;
426 s1 = s;
427
428 if (*s1 != *t1 || *s1 == 0)
429 continue;
430
431 while (*s1 == *t1 && *s1 != 0)
432 s1++, t1++;
433
434 /* A match. */
435 if (*s1 == *t1)
436 return 0;
437
438 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
439 if (strchr (s1, '.') || strchr (t1, '.'))
440 continue;
441
442 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
443 continue;
444
445 /* A match. */
446 return 0;
447 }
448
449 /* No matches. */
450 return 1;
451 }
452
453
454
455 /* Parse a #pragma whose sole argument is a string constant.
456 If OPT is true, the argument is optional. */
457 static tree
parse_strconst_pragma(const char * name,int opt)458 parse_strconst_pragma (const char* name, int opt)
459 {
460 tree result, x;
461 enum cpp_ttype t;
462
463 t = pragma_lex (&result);
464 if (t == CPP_STRING)
465 {
466 if (pragma_lex (&x) != CPP_EOF)
467 warning (0, "junk at end of #pragma %s", name);
468 return result;
469 }
470
471 if (t == CPP_EOF && opt)
472 return NULL_TREE;
473
474 error ("invalid #pragma %s", name);
475 return error_mark_node;
476 }
477
478 static void
handle_pragma_vtable(cpp_reader * dfile ATTRIBUTE_UNUSED)479 handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED )
480 {
481 parse_strconst_pragma ("vtable", 0);
482 sorry ("#pragma vtable no longer supported");
483 }
484
485 static void
handle_pragma_unit(cpp_reader * dfile ATTRIBUTE_UNUSED)486 handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED )
487 {
488 /* Validate syntax, but don't do anything. */
489 parse_strconst_pragma ("unit", 0);
490 }
491
492 static void
handle_pragma_interface(cpp_reader * dfile ATTRIBUTE_UNUSED)493 handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED )
494 {
495 tree fname = parse_strconst_pragma ("interface", 1);
496 struct c_fileinfo *finfo;
497 const char *filename;
498
499 if (fname == error_mark_node)
500 return;
501 else if (fname == 0)
502 filename = lbasename (input_filename);
503 else
504 filename = ggc_strdup (TREE_STRING_POINTER (fname));
505
506 finfo = get_fileinfo (input_filename);
507
508 if (impl_file_chain == 0)
509 {
510 /* If this is zero at this point, then we are
511 auto-implementing. */
512 if (main_input_filename == 0)
513 main_input_filename = input_filename;
514 }
515
516 finfo->interface_only = interface_strcmp (filename);
517 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
518 a definition in another file. */
519 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
520 finfo->interface_unknown = 0;
521 }
522
523 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
524 We used to only allow this at toplevel, but that restriction was buggy
525 in older compilers and it seems reasonable to allow it in the headers
526 themselves, too. It only needs to precede the matching #p interface.
527
528 We don't touch finfo->interface_only or finfo->interface_unknown;
529 the user must specify a matching #p interface for this to have
530 any effect. */
531
532 static void
handle_pragma_implementation(cpp_reader * dfile ATTRIBUTE_UNUSED)533 handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED )
534 {
535 tree fname = parse_strconst_pragma ("implementation", 1);
536 const char *filename;
537 struct impl_files *ifiles = impl_file_chain;
538
539 if (fname == error_mark_node)
540 return;
541
542 if (fname == 0)
543 {
544 if (main_input_filename)
545 filename = main_input_filename;
546 else
547 filename = input_filename;
548 filename = lbasename (filename);
549 }
550 else
551 {
552 filename = ggc_strdup (TREE_STRING_POINTER (fname));
553 #if 0
554 /* We currently cannot give this diagnostic, as we reach this point
555 only after cpplib has scanned the entire translation unit, so
556 cpp_included always returns true. A plausible fix is to compare
557 the current source-location cookie with the first source-location
558 cookie (if any) of the filename, but this requires completing the
559 --enable-mapped-location project first. See PR 17577. */
560 if (cpp_included (parse_in, filename))
561 warning (0, "#pragma implementation for %qs appears after "
562 "file is included", filename);
563 #endif
564 }
565
566 for (; ifiles; ifiles = ifiles->next)
567 {
568 if (! strcmp (ifiles->filename, filename))
569 break;
570 }
571 if (ifiles == 0)
572 {
573 ifiles = XNEW (struct impl_files);
574 ifiles->filename = filename;
575 ifiles->next = impl_file_chain;
576 impl_file_chain = ifiles;
577 }
578 }
579
580 /* Indicate that this file uses Java-personality exception handling. */
581 static void
handle_pragma_java_exceptions(cpp_reader * dfile ATTRIBUTE_UNUSED)582 handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED)
583 {
584 tree x;
585 if (pragma_lex (&x) != CPP_EOF)
586 warning (0, "junk at end of #pragma GCC java_exceptions");
587
588 choose_personality_routine (lang_java);
589 }
590
591 /* Issue an error message indicating that the lookup of NAME (an
592 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
593
594 tree
unqualified_name_lookup_error(tree name)595 unqualified_name_lookup_error (tree name)
596 {
597 if (IDENTIFIER_OPNAME_P (name))
598 {
599 if (name != ansi_opname (ERROR_MARK))
600 error ("%qD not defined", name);
601 }
602 else
603 {
604 error ("%qD was not declared in this scope", name);
605 /* Prevent repeated error messages by creating a VAR_DECL with
606 this NAME in the innermost block scope. */
607 if (current_function_decl)
608 {
609 tree decl;
610 decl = build_decl (VAR_DECL, name, error_mark_node);
611 DECL_CONTEXT (decl) = current_function_decl;
612 push_local_binding (name, decl, 0);
613 /* Mark the variable as used so that we do not get warnings
614 about it being unused later. */
615 TREE_USED (decl) = 1;
616 }
617 }
618
619 return error_mark_node;
620 }
621
622 /* Like unqualified_name_lookup_error, but NAME is an unqualified-id
623 used as a function. Returns an appropriate expression for
624 NAME. */
625
626 tree
unqualified_fn_lookup_error(tree name)627 unqualified_fn_lookup_error (tree name)
628 {
629 if (processing_template_decl)
630 {
631 /* In a template, it is invalid to write "f()" or "f(3)" if no
632 declaration of "f" is available. Historically, G++ and most
633 other compilers accepted that usage since they deferred all name
634 lookup until instantiation time rather than doing unqualified
635 name lookup at template definition time; explain to the user what
636 is going wrong.
637
638 Note that we have the exact wording of the following message in
639 the manual (trouble.texi, node "Name lookup"), so they need to
640 be kept in synch. */
641 pedwarn ("there are no arguments to %qD that depend on a template "
642 "parameter, so a declaration of %qD must be available",
643 name, name);
644
645 if (!flag_permissive)
646 {
647 static bool hint;
648 if (!hint)
649 {
650 error ("(if you use %<-fpermissive%>, G++ will accept your "
651 "code, but allowing the use of an undeclared name is "
652 "deprecated)");
653 hint = true;
654 }
655 }
656 return name;
657 }
658
659 return unqualified_name_lookup_error (name);
660 }
661
662 tree
build_lang_decl(enum tree_code code,tree name,tree type)663 build_lang_decl (enum tree_code code, tree name, tree type)
664 {
665 tree t;
666
667 t = build_decl (code, name, type);
668 retrofit_lang_decl (t);
669
670 /* All nesting of C++ functions is lexical; there is never a "static
671 chain" in the sense of GNU C nested functions. */
672 if (code == FUNCTION_DECL)
673 DECL_NO_STATIC_CHAIN (t) = 1;
674
675 return t;
676 }
677
678 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
679 and pushdecl (for functions generated by the backend). */
680
681 void
retrofit_lang_decl(tree t)682 retrofit_lang_decl (tree t)
683 {
684 struct lang_decl *ld;
685 size_t size;
686
687 if (CAN_HAVE_FULL_LANG_DECL_P (t))
688 size = sizeof (struct lang_decl);
689 else
690 size = sizeof (struct lang_decl_flags);
691
692 ld = GGC_CNEWVAR (struct lang_decl, size);
693
694 ld->decl_flags.can_be_full = CAN_HAVE_FULL_LANG_DECL_P (t) ? 1 : 0;
695 ld->decl_flags.u1sel = TREE_CODE (t) == NAMESPACE_DECL ? 1 : 0;
696 ld->decl_flags.u2sel = 0;
697 if (ld->decl_flags.can_be_full)
698 ld->u.f.u3sel = TREE_CODE (t) == FUNCTION_DECL ? 1 : 0;
699
700 DECL_LANG_SPECIFIC (t) = ld;
701 if (current_lang_name == lang_name_cplusplus
702 || decl_linkage (t) == lk_none)
703 SET_DECL_LANGUAGE (t, lang_cplusplus);
704 else if (current_lang_name == lang_name_c)
705 SET_DECL_LANGUAGE (t, lang_c);
706 else if (current_lang_name == lang_name_java)
707 SET_DECL_LANGUAGE (t, lang_java);
708 else
709 gcc_unreachable ();
710
711 #ifdef GATHER_STATISTICS
712 tree_node_counts[(int)lang_decl] += 1;
713 tree_node_sizes[(int)lang_decl] += size;
714 #endif
715 }
716
717 void
cxx_dup_lang_specific_decl(tree node)718 cxx_dup_lang_specific_decl (tree node)
719 {
720 int size;
721 struct lang_decl *ld;
722
723 if (! DECL_LANG_SPECIFIC (node))
724 return;
725
726 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
727 size = sizeof (struct lang_decl_flags);
728 else
729 size = sizeof (struct lang_decl);
730 ld = GGC_NEWVAR (struct lang_decl, size);
731 memcpy (ld, DECL_LANG_SPECIFIC (node), size);
732 DECL_LANG_SPECIFIC (node) = ld;
733
734 #ifdef GATHER_STATISTICS
735 tree_node_counts[(int)lang_decl] += 1;
736 tree_node_sizes[(int)lang_decl] += size;
737 #endif
738 }
739
740 /* Copy DECL, including any language-specific parts. */
741
742 tree
copy_decl(tree decl)743 copy_decl (tree decl)
744 {
745 tree copy;
746
747 copy = copy_node (decl);
748 cxx_dup_lang_specific_decl (copy);
749 return copy;
750 }
751
752 /* Replace the shared language-specific parts of NODE with a new copy. */
753
754 static void
copy_lang_type(tree node)755 copy_lang_type (tree node)
756 {
757 int size;
758 struct lang_type *lt;
759
760 if (! TYPE_LANG_SPECIFIC (node))
761 return;
762
763 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class)
764 size = sizeof (struct lang_type);
765 else
766 size = sizeof (struct lang_type_ptrmem);
767 lt = GGC_NEWVAR (struct lang_type, size);
768 memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
769 TYPE_LANG_SPECIFIC (node) = lt;
770
771 #ifdef GATHER_STATISTICS
772 tree_node_counts[(int)lang_type] += 1;
773 tree_node_sizes[(int)lang_type] += size;
774 #endif
775 }
776
777 /* Copy TYPE, including any language-specific parts. */
778
779 tree
copy_type(tree type)780 copy_type (tree type)
781 {
782 tree copy;
783
784 copy = copy_node (type);
785 copy_lang_type (copy);
786 return copy;
787 }
788
789 tree
cxx_make_type(enum tree_code code)790 cxx_make_type (enum tree_code code)
791 {
792 tree t = make_node (code);
793
794 /* Create lang_type structure. */
795 if (IS_AGGR_TYPE_CODE (code)
796 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
797 {
798 struct lang_type *pi = GGC_CNEW (struct lang_type);
799
800 TYPE_LANG_SPECIFIC (t) = pi;
801 pi->u.c.h.is_lang_type_class = 1;
802
803 #ifdef GATHER_STATISTICS
804 tree_node_counts[(int)lang_type] += 1;
805 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
806 #endif
807 }
808
809 /* Set up some flags that give proper default behavior. */
810 if (IS_AGGR_TYPE_CODE (code))
811 {
812 struct c_fileinfo *finfo = get_fileinfo (input_filename);
813 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
814 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
815 }
816
817 return t;
818 }
819
820 tree
make_aggr_type(enum tree_code code)821 make_aggr_type (enum tree_code code)
822 {
823 tree t = cxx_make_type (code);
824
825 if (IS_AGGR_TYPE_CODE (code))
826 SET_IS_AGGR_TYPE (t, 1);
827
828 return t;
829 }
830