]>
Commit | Line | Data |
---|---|---|
8d08fdba | 1 | /* Separate lexical analyzer for GNU C++. |
d6a8bdff | 2 | Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, |
b39309c8 | 3 | 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. |
8d08fdba MS |
4 | Hacked by Michael Tiemann (tiemann@cygnus.com) |
5 | ||
f5adbb8d | 6 | This file is part of GCC. |
8d08fdba | 7 | |
f5adbb8d | 8 | GCC is free software; you can redistribute it and/or modify |
8d08fdba MS |
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 | ||
f5adbb8d | 13 | GCC is distributed in the hope that it will be useful, |
8d08fdba MS |
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 | |
f5adbb8d | 19 | along with GCC; see the file COPYING. If not, write to |
1788952f KC |
20 | the Free Software Foundation, 51 Franklin Street, Fifth Floor, |
21 | Boston, MA 02110-1301, USA. */ | |
8d08fdba MS |
22 | |
23 | ||
24 | /* This file is the lexical analyzer for GNU C++. */ | |
25 | ||
da20811c | 26 | #include "config.h" |
8d052bc7 | 27 | #include "system.h" |
4977bab6 ZW |
28 | #include "coretypes.h" |
29 | #include "tm.h" | |
8d08fdba MS |
30 | #include "input.h" |
31 | #include "tree.h" | |
8d08fdba | 32 | #include "cp-tree.h" |
0e5921e8 | 33 | #include "cpplib.h" |
8d08fdba | 34 | #include "flags.h" |
3d6f7931 | 35 | #include "c-pragma.h" |
54f92bfb | 36 | #include "toplev.h" |
7dee3f36 | 37 | #include "output.h" |
7bdb32b9 | 38 | #include "tm_p.h" |
2a9a326b | 39 | #include "timevar.h" |
8d08fdba | 40 | |
9e7d1164 NN |
41 | static int interface_strcmp (const char *); |
42 | static void init_cp_pragma (void); | |
0e5921e8 | 43 | |
9e7d1164 NN |
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 *); | |
0e5921e8 | 50 | |
9e7d1164 NN |
51 | static void init_operators (void); |
52 | static void copy_lang_type (tree); | |
8d08fdba | 53 | |
0e5921e8 | 54 | /* A constraint that can be tested at compile time. */ |
0e5921e8 | 55 | #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1] |
66a6250f | 56 | |
87e3dbc9 MM |
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 | { | |
520a57c8 | 78 | const char *filename; |
87e3dbc9 MM |
79 | struct impl_files *next; |
80 | }; | |
81 | ||
82 | static struct impl_files *impl_file_chain; | |
83 | ||
8d08fdba | 84 | \f |
19551f29 | 85 | void |
9e7d1164 | 86 | cxx_finish (void) |
8d08fdba | 87 | { |
22703ccc | 88 | c_common_finish (); |
8d08fdba MS |
89 | } |
90 | ||
596ea4e5 AS |
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]; | |
5362b086 | 95 | |
596ea4e5 AS |
96 | /* Initialize data structures that keep track of operator names. */ |
97 | ||
0c918ce5 | 98 | #define DEF_OPERATOR(NAME, C, M, AR, AP) \ |
0e5921e8 ZW |
99 | CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256); |
100 | #include "operators.def" | |
101 | #undef DEF_OPERATOR | |
102 | ||
596ea4e5 | 103 | static void |
9e7d1164 | 104 | init_operators (void) |
596ea4e5 AS |
105 | { |
106 | tree identifier; | |
107 | char buffer[256]; | |
108 | struct operator_name_info_t *oni; | |
5362b086 | 109 | |
0c918ce5 | 110 | #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ |
dba1acea | 111 | sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \ |
596ea4e5 AS |
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; \ | |
0cbd7506 | 120 | oni->mangled_name = MANGLING; \ |
3fa3c4bd | 121 | oni->arity = ARITY; |
596ea4e5 AS |
122 | |
123 | #include "operators.def" | |
124 | #undef DEF_OPERATOR | |
125 | ||
5362b086 | 126 | operator_name_info[(int) ERROR_MARK].identifier |
596ea4e5 AS |
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.) */ | |
5362b086 EC |
134 | |
135 | operator_name_info [(int) INIT_EXPR].name | |
596ea4e5 AS |
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"; | |
596ea4e5 AS |
145 | operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&"; |
146 | operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||"; | |
596ea4e5 | 147 | operator_name_info [(int) RANGE_EXPR].name = "..."; |
392e3d51 | 148 | operator_name_info [(int) UNARY_PLUS_EXPR].name = "+"; |
596ea4e5 | 149 | |
5362b086 | 150 | assignment_operator_name_info [(int) EXACT_DIV_EXPR].name |
596ea4e5 | 151 | = "(exact /=)"; |
5362b086 | 152 | assignment_operator_name_info [(int) CEIL_DIV_EXPR].name |
596ea4e5 | 153 | = "(ceiling /=)"; |
5362b086 | 154 | assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name |
596ea4e5 | 155 | = "(floor /=)"; |
5362b086 | 156 | assignment_operator_name_info [(int) ROUND_DIV_EXPR].name |
596ea4e5 | 157 | = "(round /=)"; |
5362b086 | 158 | assignment_operator_name_info [(int) CEIL_MOD_EXPR].name |
596ea4e5 | 159 | = "(ceiling %=)"; |
5362b086 | 160 | assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name |
596ea4e5 | 161 | = "(floor %=)"; |
5362b086 | 162 | assignment_operator_name_info [(int) ROUND_MOD_EXPR].name |
596ea4e5 AS |
163 | = "(round %=)"; |
164 | } | |
165 | ||
0e5921e8 ZW |
166 | /* The reserved keyword table. */ |
167 | struct resword | |
8d08fdba | 168 | { |
8b60264b | 169 | const char *const word; |
df2b750f | 170 | ENUM_BITFIELD(rid) const rid : 16; |
8b60264b | 171 | const unsigned int disable : 16; |
0e5921e8 | 172 | }; |
8d08fdba | 173 | |
0e5921e8 ZW |
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 */ | |
e58a9aa1 | 178 | #define D_OBJC 0x04 /* Objective C++ only */ |
0e5921e8 ZW |
179 | |
180 | CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT); | |
181 | ||
182 | static const struct resword reswords[] = | |
183 | { | |
d9dbd9b1 | 184 | { "_Complex", RID_COMPLEX, 0 }, |
0ba8a114 NS |
185 | { "__FUNCTION__", RID_FUNCTION_NAME, 0 }, |
186 | { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 }, | |
0cbd7506 | 187 | { "__alignof", RID_ALIGNOF, 0 }, |
0e5921e8 ZW |
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 }, | |
7a3ea201 | 193 | { "__builtin_offsetof", RID_OFFSETOF, 0 }, |
0e5921e8 ZW |
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 }, | |
0ba8a114 | 200 | { "__func__", RID_C99_FUNCTION_NAME, 0 }, |
0e5921e8 ZW |
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 }, | |
7a1f3f5f | 213 | { "__thread", RID_THREAD, 0 }, |
0e5921e8 ZW |
214 | { "__typeof", RID_TYPEOF, 0 }, |
215 | { "__typeof__", RID_TYPEOF, 0 }, | |
216 | { "__volatile", RID_VOLATILE, 0 }, | |
217 | { "__volatile__", RID_VOLATILE, 0 }, | |
0e5921e8 | 218 | { "asm", RID_ASM, D_ASM }, |
0e5921e8 | 219 | { "auto", RID_AUTO, 0 }, |
0e5921e8 ZW |
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 }, | |
0e5921e8 ZW |
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 }, | |
0e5921e8 | 251 | { "operator", RID_OPERATOR, 0 }, |
0e5921e8 ZW |
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 }, | |
0cbd7506 | 280 | { "wchar_t", RID_WCHAR, 0 }, |
0e5921e8 | 281 | { "while", RID_WHILE, 0 }, |
0d3ba739 | 282 | |
e58a9aa1 ZL |
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 }, | |
0e5921e8 | 308 | }; |
0e5921e8 | 309 | |
f5e99456 | 310 | void |
9e7d1164 | 311 | init_reswords (void) |
0e5921e8 ZW |
312 | { |
313 | unsigned int i; | |
314 | tree id; | |
c372b0fa | 315 | int mask = ((flag_no_asm ? D_ASM : 0) |
e58a9aa1 | 316 | | D_OBJC |
0e5921e8 ZW |
317 | | (flag_no_gnu_keywords ? D_EXT : 0)); |
318 | ||
67f5655f | 319 | ridpointers = GGC_CNEWVEC (tree, (int) RID_MAX); |
ca7558fc | 320 | for (i = 0; i < ARRAY_SIZE (reswords); i++) |
2b2a3531 | 321 | { |
0e5921e8 ZW |
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; | |
2b2a3531 | 327 | } |
0e5921e8 | 328 | } |
2b2a3531 | 329 | |
0e5921e8 | 330 | static void |
9e7d1164 | 331 | init_cp_pragma (void) |
0e5921e8 | 332 | { |
c58b209a NB |
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); | |
0e5921e8 | 340 | } |
009ed910 | 341 | \f |
feea5b18 ILT |
342 | /* TRUE if a code represents a statement. */ |
343 | ||
344 | bool statement_code_p[MAX_TREE_CODES]; | |
345 | ||
f5e99456 NB |
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. */ | |
4bfec483 NB |
350 | bool |
351 | cxx_init (void) | |
0e5921e8 | 352 | { |
feea5b18 | 353 | unsigned int i; |
009ed910 | 354 | static const enum tree_code stmt_codes[] = { |
feea5b18 ILT |
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 | |
009ed910 SB |
360 | }; |
361 | ||
feea5b18 ILT |
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; | |
009ed910 | 365 | |
267a0752 MC |
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. */ | |
93409b8c PB |
369 | #ifdef USE_MAPPED_LOCATION |
370 | push_srcloc (BUILTINS_LOCATION); | |
371 | #else | |
372 | push_srcloc ("<built-in>", 0); | |
373 | #endif | |
0e5921e8 ZW |
374 | |
375 | init_reswords (); | |
87e3dbc9 | 376 | init_tree (); |
54f7877c | 377 | init_cp_semantics (); |
596ea4e5 | 378 | init_operators (); |
669ec2b4 | 379 | init_method (); |
8d08fdba | 380 | init_error (); |
f3cdb9c6 | 381 | |
8d08fdba MS |
382 | current_function_decl = NULL; |
383 | ||
9e62871e | 384 | class_type_node = ridpointers[(int) RID_CLASS]; |
8d08fdba | 385 | |
f5e99456 NB |
386 | cxx_init_decl_processing (); |
387 | ||
4684cd27 MM |
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 | ||
4bfec483 | 399 | if (c_common_init () == false) |
267a0752 MC |
400 | { |
401 | pop_srcloc(); | |
402 | return false; | |
403 | } | |
f5e99456 NB |
404 | |
405 | init_cp_pragma (); | |
406 | ||
4684cd27 | 407 | init_repo (); |
f5e99456 | 408 | |
267a0752 | 409 | pop_srcloc(); |
4bfec483 | 410 | return true; |
8d08fdba | 411 | } |
8d08fdba | 412 | \f |
51c184be | 413 | /* Return nonzero if S is not considered part of an |
8d08fdba | 414 | INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */ |
e92cc029 | 415 | |
8d08fdba | 416 | static int |
9e7d1164 | 417 | interface_strcmp (const char* s) |
8d08fdba MS |
418 | { |
419 | /* Set the interface/implementation bits for this scope. */ | |
420 | struct impl_files *ifiles; | |
d8e178a0 | 421 | const char *s1; |
8d08fdba | 422 | |
8d08fdba MS |
423 | for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next) |
424 | { | |
d8e178a0 | 425 | const char *t1 = ifiles->filename; |
8d08fdba MS |
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. */ | |
9473c522 | 439 | if (strchr (s1, '.') || strchr (t1, '.')) |
8d08fdba MS |
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 | ||
0e5921e8 ZW |
453 | \f |
454 | ||
455 | /* Parse a #pragma whose sole argument is a string constant. | |
456 | If OPT is true, the argument is optional. */ | |
457 | static tree | |
9e7d1164 | 458 | parse_strconst_pragma (const char* name, int opt) |
0e5921e8 ZW |
459 | { |
460 | tree result, x; | |
461 | enum cpp_ttype t; | |
462 | ||
ebf0088a | 463 | t = pragma_lex (&result); |
0e5921e8 ZW |
464 | if (t == CPP_STRING) |
465 | { | |
75ce3d48 | 466 | if (pragma_lex (&x) != CPP_EOF) |
d4ee4d25 | 467 | warning (0, "junk at end of #pragma %s", name); |
0e5921e8 ZW |
468 | return result; |
469 | } | |
470 | ||
471 | if (t == CPP_EOF && opt) | |
ebf0088a | 472 | return NULL_TREE; |
0e5921e8 ZW |
473 | |
474 | error ("invalid #pragma %s", name); | |
ebf0088a | 475 | return error_mark_node; |
0e5921e8 | 476 | } |
5362b086 | 477 | |
0e5921e8 | 478 | static void |
9e7d1164 | 479 | handle_pragma_vtable (cpp_reader* dfile ATTRIBUTE_UNUSED ) |
0e5921e8 | 480 | { |
46ccf50a JM |
481 | parse_strconst_pragma ("vtable", 0); |
482 | sorry ("#pragma vtable no longer supported"); | |
0e5921e8 ZW |
483 | } |
484 | ||
1d02ac83 | 485 | static void |
9e7d1164 | 486 | handle_pragma_unit (cpp_reader* dfile ATTRIBUTE_UNUSED ) |
1d02ac83 | 487 | { |
0e5921e8 ZW |
488 | /* Validate syntax, but don't do anything. */ |
489 | parse_strconst_pragma ("unit", 0); | |
490 | } | |
491 | ||
492 | static void | |
9e7d1164 | 493 | handle_pragma_interface (cpp_reader* dfile ATTRIBUTE_UNUSED ) |
0e5921e8 ZW |
494 | { |
495 | tree fname = parse_strconst_pragma ("interface", 1); | |
496 | struct c_fileinfo *finfo; | |
c162c75e | 497 | const char *filename; |
0e5921e8 | 498 | |
ebf0088a | 499 | if (fname == error_mark_node) |
0e5921e8 ZW |
500 | return; |
501 | else if (fname == 0) | |
c162c75e | 502 | filename = lbasename (input_filename); |
0e5921e8 | 503 | else |
c162c75e | 504 | filename = ggc_strdup (TREE_STRING_POINTER (fname)); |
0e5921e8 | 505 | |
c162c75e | 506 | finfo = get_fileinfo (filename); |
1d02ac83 JM |
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; | |
1d02ac83 JM |
514 | } |
515 | ||
c162c75e | 516 | finfo->interface_only = interface_strcmp (filename); |
15072eb1 ZW |
517 | /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see |
518 | a definition in another file. */ | |
5d709b00 ZW |
519 | if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only) |
520 | finfo->interface_unknown = 0; | |
1d02ac83 JM |
521 | } |
522 | ||
777ffbda JM |
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 | ||
5d709b00 ZW |
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. */ | |
777ffbda | 531 | |
1d02ac83 | 532 | static void |
9e7d1164 | 533 | handle_pragma_implementation (cpp_reader* dfile ATTRIBUTE_UNUSED ) |
1d02ac83 | 534 | { |
0e5921e8 | 535 | tree fname = parse_strconst_pragma ("implementation", 1); |
c162c75e | 536 | const char *filename; |
777ffbda | 537 | struct impl_files *ifiles = impl_file_chain; |
0e5921e8 | 538 | |
ebf0088a | 539 | if (fname == error_mark_node) |
0e5921e8 ZW |
540 | return; |
541 | ||
542 | if (fname == 0) | |
543 | { | |
544 | if (main_input_filename) | |
c162c75e | 545 | filename = main_input_filename; |
0e5921e8 | 546 | else |
c162c75e MA |
547 | filename = input_filename; |
548 | filename = lbasename (filename); | |
0e5921e8 ZW |
549 | } |
550 | else | |
551 | { | |
c162c75e MA |
552 | filename = ggc_strdup (TREE_STRING_POINTER (fname)); |
553 | #if 0 | |
554 | /* We currently cannot give this diagnostic, as we reach this point | |
0cbd7506 | 555 | only after cpplib has scanned the entire translation unit, so |
c162c75e MA |
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)) | |
d4ee4d25 | 561 | warning (0, "#pragma implementation for %qs appears after " |
c162c75e MA |
562 | "file is included", filename); |
563 | #endif | |
0e5921e8 ZW |
564 | } |
565 | ||
777ffbda | 566 | for (; ifiles; ifiles = ifiles->next) |
1d02ac83 | 567 | { |
c162c75e | 568 | if (! strcmp (ifiles->filename, filename)) |
777ffbda | 569 | break; |
1d02ac83 | 570 | } |
777ffbda | 571 | if (ifiles == 0) |
1d02ac83 | 572 | { |
0ac1b889 | 573 | ifiles = XNEW (struct impl_files); |
c162c75e | 574 | ifiles->filename = filename; |
777ffbda JM |
575 | ifiles->next = impl_file_chain; |
576 | impl_file_chain = ifiles; | |
1d02ac83 | 577 | } |
1d02ac83 | 578 | } |
f181d4ae | 579 | |
1f730ff7 ZW |
580 | /* Indicate that this file uses Java-personality exception handling. */ |
581 | static void | |
bc4071dd | 582 | handle_pragma_java_exceptions (cpp_reader* dfile ATTRIBUTE_UNUSED) |
1f730ff7 ZW |
583 | { |
584 | tree x; | |
75ce3d48 | 585 | if (pragma_lex (&x) != CPP_EOF) |
d4ee4d25 | 586 | warning (0, "junk at end of #pragma GCC java_exceptions"); |
1f730ff7 ZW |
587 | |
588 | choose_personality_routine (lang_java); | |
589 | } | |
590 | ||
15c7fb9c | 591 | /* Issue an error message indicating that the lookup of NAME (an |
b3445994 | 592 | IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */ |
15c7fb9c | 593 | |
b3445994 | 594 | tree |
15c7fb9c MM |
595 | unqualified_name_lookup_error (tree name) |
596 | { | |
597 | if (IDENTIFIER_OPNAME_P (name)) | |
598 | { | |
599 | if (name != ansi_opname (ERROR_MARK)) | |
2a13a625 | 600 | error ("%qD not defined", name); |
15c7fb9c | 601 | } |
15c7fb9c MM |
602 | else |
603 | { | |
2a13a625 | 604 | error ("%qD was not declared in this scope", name); |
58ec3cc5 MM |
605 | /* Prevent repeated error messages by creating a VAR_DECL with |
606 | this NAME in the innermost block scope. */ | |
607 | if (current_function_decl) | |
15c7fb9c | 608 | { |
58ec3cc5 MM |
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); | |
996c2b52 MM |
613 | /* Mark the variable as used so that we do not get warnings |
614 | about it being unused later. */ | |
615 | TREE_USED (decl) = 1; | |
15c7fb9c | 616 | } |
15c7fb9c | 617 | } |
935d1834 | 618 | |
b3445994 | 619 | return error_mark_node; |
5566b478 MS |
620 | } |
621 | ||
b3445994 MM |
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 | ||
5566b478 | 626 | tree |
b3445994 | 627 | unqualified_fn_lookup_error (tree name) |
5566b478 | 628 | { |
5156628f | 629 | if (processing_template_decl) |
5566b478 | 630 | { |
b3445994 MM |
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 | |
c5785644 WB |
633 | other compilers accepted that usage since they deferred all name |
634 | lookup until instantiation time rather than doing unqualified | |
c8094d83 | 635 | name lookup at template definition time; explain to the user what |
c5785644 WB |
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. */ | |
2a13a625 | 641 | pedwarn ("there are no arguments to %qD that depend on a template " |
c8094d83 | 642 | "parameter, so a declaration of %qD must be available", |
10b1d5e7 | 643 | name, name); |
c8094d83 | 644 | |
b3445994 | 645 | if (!flag_permissive) |
5566b478 | 646 | { |
b3445994 MM |
647 | static bool hint; |
648 | if (!hint) | |
649 | { | |
597cdf4f JM |
650 | error ("(if you use %<-fpermissive%>, G++ will accept your " |
651 | "code, but allowing the use of an undeclared name is " | |
b3445994 MM |
652 | "deprecated)"); |
653 | hint = true; | |
654 | } | |
5566b478 | 655 | } |
10b1d5e7 | 656 | return name; |
5566b478 | 657 | } |
8d08fdba | 658 | |
b3445994 | 659 | return unqualified_name_lookup_error (name); |
8d08fdba MS |
660 | } |
661 | ||
8d08fdba | 662 | tree |
9e7d1164 | 663 | build_lang_decl (enum tree_code code, tree name, tree type) |
8d08fdba | 664 | { |
4ce3d537 MM |
665 | tree t; |
666 | ||
4ce3d537 | 667 | t = build_decl (code, name, type); |
fcfcdfc8 | 668 | retrofit_lang_decl (t); |
4ce3d537 | 669 | |
6dc36fed MM |
670 | /* All nesting of C++ functions is lexical; there is never a "static |
671 | chain" in the sense of GNU C nested functions. */ | |
c8094d83 | 672 | if (code == FUNCTION_DECL) |
6dc36fed MM |
673 | DECL_NO_STATIC_CHAIN (t) = 1; |
674 | ||
fcfcdfc8 JM |
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 | |
9e7d1164 | 682 | retrofit_lang_decl (tree t) |
fcfcdfc8 | 683 | { |
9188c363 | 684 | struct lang_decl *ld; |
4ce3d537 | 685 | size_t size; |
8d08fdba | 686 | |
4ce3d537 MM |
687 | if (CAN_HAVE_FULL_LANG_DECL_P (t)) |
688 | size = sizeof (struct lang_decl); | |
689 | else | |
690 | size = sizeof (struct lang_decl_flags); | |
b0d06515 | 691 | |
99dd239f | 692 | ld = GGC_CNEWVAR (struct lang_decl, size); |
8d08fdba | 693 | |
e2500fed GK |
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 | ||
9188c363 | 700 | DECL_LANG_SPECIFIC (t) = ld; |
ab73670a MM |
701 | if (current_lang_name == lang_name_cplusplus |
702 | || decl_linkage (t) == lk_none) | |
5d2ed28c | 703 | SET_DECL_LANGUAGE (t, lang_cplusplus); |
8d08fdba | 704 | else if (current_lang_name == lang_name_c) |
5d2ed28c | 705 | SET_DECL_LANGUAGE (t, lang_c); |
a1774733 | 706 | else if (current_lang_name == lang_name_java) |
5d2ed28c | 707 | SET_DECL_LANGUAGE (t, lang_java); |
8dc2b103 NS |
708 | else |
709 | gcc_unreachable (); | |
8d08fdba | 710 | |
8d08fdba MS |
711 | #ifdef GATHER_STATISTICS |
712 | tree_node_counts[(int)lang_decl] += 1; | |
4ce3d537 | 713 | tree_node_sizes[(int)lang_decl] += size; |
8d08fdba | 714 | #endif |
8d08fdba MS |
715 | } |
716 | ||
8d08fdba | 717 | void |
9e7d1164 | 718 | cxx_dup_lang_specific_decl (tree node) |
8d08fdba MS |
719 | { |
720 | int size; | |
d60f72ae | 721 | struct lang_decl *ld; |
8d08fdba | 722 | |
5566b478 MS |
723 | if (! DECL_LANG_SPECIFIC (node)) |
724 | return; | |
725 | ||
b0d06515 | 726 | if (!CAN_HAVE_FULL_LANG_DECL_P (node)) |
8d08fdba MS |
727 | size = sizeof (struct lang_decl_flags); |
728 | else | |
729 | size = sizeof (struct lang_decl); | |
99dd239f | 730 | ld = GGC_NEWVAR (struct lang_decl, size); |
4e135bdd | 731 | memcpy (ld, DECL_LANG_SPECIFIC (node), size); |
d60f72ae | 732 | DECL_LANG_SPECIFIC (node) = ld; |
11e74ea6 KL |
733 | |
734 | #ifdef GATHER_STATISTICS | |
735 | tree_node_counts[(int)lang_decl] += 1; | |
736 | tree_node_sizes[(int)lang_decl] += size; | |
737 | #endif | |
8d08fdba MS |
738 | } |
739 | ||
0acf7199 MM |
740 | /* Copy DECL, including any language-specific parts. */ |
741 | ||
742 | tree | |
9e7d1164 | 743 | copy_decl (tree decl) |
0acf7199 MM |
744 | { |
745 | tree copy; | |
746 | ||
747 | copy = copy_node (decl); | |
63e1b1c4 | 748 | cxx_dup_lang_specific_decl (copy); |
0acf7199 MM |
749 | return copy; |
750 | } | |
751 | ||
11e74ea6 KL |
752 | /* Replace the shared language-specific parts of NODE with a new copy. */ |
753 | ||
76648a8b | 754 | static void |
9e7d1164 | 755 | copy_lang_type (tree node) |
11e74ea6 KL |
756 | { |
757 | int size; | |
758 | struct lang_type *lt; | |
759 | ||
760 | if (! TYPE_LANG_SPECIFIC (node)) | |
761 | return; | |
762 | ||
e2500fed GK |
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); | |
99dd239f | 767 | lt = GGC_NEWVAR (struct lang_type, size); |
11e74ea6 KL |
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 | |
9e7d1164 | 780 | copy_type (tree type) |
11e74ea6 KL |
781 | { |
782 | tree copy; | |
783 | ||
784 | copy = copy_node (type); | |
785 | copy_lang_type (copy); | |
786 | return copy; | |
787 | } | |
788 | ||
8d08fdba | 789 | tree |
9e7d1164 | 790 | cxx_make_type (enum tree_code code) |
8d08fdba | 791 | { |
926ce8bd | 792 | tree t = make_node (code); |
8d08fdba | 793 | |
11e74ea6 KL |
794 | /* Create lang_type structure. */ |
795 | if (IS_AGGR_TYPE_CODE (code) | |
796 | || code == BOUND_TEMPLATE_TEMPLATE_PARM) | |
7ddedda4 | 797 | { |
99dd239f | 798 | struct lang_type *pi = GGC_CNEW (struct lang_type); |
8d08fdba | 799 | |
32201ce4 | 800 | TYPE_LANG_SPECIFIC (t) = pi; |
e2500fed | 801 | pi->u.c.h.is_lang_type_class = 1; |
11e74ea6 KL |
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 | { | |
c162c75e | 812 | struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename)); |
5d709b00 ZW |
813 | SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown); |
814 | CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only; | |
7ddedda4 | 815 | } |
8d08fdba MS |
816 | |
817 | return t; | |
818 | } | |
819 | ||
33848bb0 | 820 | tree |
9e7d1164 | 821 | make_aggr_type (enum tree_code code) |
33848bb0 | 822 | { |
f1e639b1 | 823 | tree t = cxx_make_type (code); |
33848bb0 RH |
824 | |
825 | if (IS_AGGR_TYPE_CODE (code)) | |
826 | SET_IS_AGGR_TYPE (t, 1); | |
827 | ||
828 | return t; | |
829 | } |