Branch data Line data Source code
1 : : /* Separate lexical analyzer for GNU C++.
2 : : Copyright (C) 1987-2024 Free Software Foundation, Inc.
3 : : Hacked by Michael Tiemann (tiemann@cygnus.com)
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful,
13 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : :
22 : : /* This file is the lexical analyzer for GNU C++. */
23 : :
24 : : #include "config.h"
25 : : /* For use with name_hint. */
26 : : #define INCLUDE_MEMORY
27 : : #include "system.h"
28 : : #include "coretypes.h"
29 : : #include "cp-tree.h"
30 : : #include "stringpool.h"
31 : : #include "c-family/c-pragma.h"
32 : : #include "c-family/c-objc.h"
33 : : #include "gcc-rich-location.h"
34 : : #include "cp-name-hint.h"
35 : : #include "langhooks.h"
36 : :
37 : : static int interface_strcmp (const char *);
38 : : static void init_cp_traits (void);
39 : : static void init_cp_pragma (void);
40 : :
41 : : static tree parse_strconst_pragma (const char *, int);
42 : : static void handle_pragma_vtable (cpp_reader *);
43 : : static void handle_pragma_unit (cpp_reader *);
44 : : static void handle_pragma_interface (cpp_reader *);
45 : : static void handle_pragma_implementation (cpp_reader *);
46 : :
47 : : static void init_operators (void);
48 : : static void copy_lang_type (tree);
49 : :
50 : : /* A constraint that can be tested at compile time. */
51 : : #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
52 : :
53 : : /* Functions and data structures for #pragma interface.
54 : :
55 : : `#pragma implementation' means that the main file being compiled
56 : : is considered to implement (provide) the classes that appear in
57 : : its main body. I.e., if this is file "foo.cc", and class `bar'
58 : : is defined in "foo.cc", then we say that "foo.cc implements bar".
59 : :
60 : : All main input files "implement" themselves automagically.
61 : :
62 : : `#pragma interface' means that unless this file (of the form "foo.h"
63 : : is not presently being included by file "foo.cc", the
64 : : CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
65 : : of the vtables nor any of the inline functions defined in foo.h
66 : : will ever be output.
67 : :
68 : : There are cases when we want to link files such as "defs.h" and
69 : : "main.cc". In this case, we give "defs.h" a `#pragma interface',
70 : : and "main.cc" has `#pragma implementation "defs.h"'. */
71 : :
72 : : struct impl_files
73 : : {
74 : : const char *filename;
75 : : struct impl_files *next;
76 : : };
77 : :
78 : : static struct impl_files *impl_file_chain;
79 : :
80 : : void
81 : 91896 : cxx_finish (void)
82 : : {
83 : 91896 : c_common_finish ();
84 : 91896 : }
85 : :
86 : : ovl_op_info_t ovl_op_info[2][OVL_OP_MAX] =
87 : : {
88 : : {
89 : : {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
90 : : {NULL_TREE, NULL, NULL, NOP_EXPR, OVL_OP_NOP_EXPR, 0},
91 : : #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) \
92 : : {NULL_TREE, NAME, MANGLING, CODE, OVL_OP_##CODE, FLAGS},
93 : : #define OPERATOR_TRANSITION }, { \
94 : : {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
95 : : #include "operators.def"
96 : : }
97 : : };
98 : : unsigned char ovl_op_mapping[MAX_TREE_CODES];
99 : : unsigned char ovl_op_alternate[OVL_OP_MAX];
100 : :
101 : : /* The trait table, declared in cp-tree.h. */
102 : : const cp_trait cp_traits[] =
103 : : {
104 : : #define DEFTRAIT(TCC, CODE, NAME, ARITY) \
105 : : { NAME, CPTK_##CODE, ARITY, (TCC == tcc_type) },
106 : : #include "cp-trait.def"
107 : : #undef DEFTRAIT
108 : : };
109 : : /* The trait table cannot have more than 255 (addr_space_t) entries since
110 : : the index is retrieved through IDENTIFIER_CP_INDEX. */
111 : : static_assert(ARRAY_SIZE (cp_traits) <= 255,
112 : : "cp_traits array cannot have more than 255 entries");
113 : :
114 : : /* Get the name of the kind of identifier T. */
115 : :
116 : : const char *
117 : 0 : get_identifier_kind_name (tree id)
118 : : {
119 : : /* Keep in sync with cp_id_kind enumeration. */
120 : 0 : static const char *const names[cik_max] = {
121 : : "normal", "keyword", "constructor", "destructor",
122 : : "simple-op", "assign-op", "conv-op", "<reserved>udlit-op"
123 : : };
124 : :
125 : 0 : unsigned kind = 0;
126 : 0 : kind |= IDENTIFIER_KIND_BIT_2 (id) << 2;
127 : 0 : kind |= IDENTIFIER_KIND_BIT_1 (id) << 1;
128 : 0 : kind |= IDENTIFIER_KIND_BIT_0 (id) << 0;
129 : :
130 : 0 : return names[kind];
131 : : }
132 : :
133 : : /* Set the identifier kind, which we expect to currently be zero. */
134 : :
135 : : void
136 : 23626973 : set_identifier_kind (tree id, cp_identifier_kind kind)
137 : : {
138 : 23626973 : gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id)
139 : : & !IDENTIFIER_KIND_BIT_1 (id)
140 : : & !IDENTIFIER_KIND_BIT_0 (id));
141 : 23626973 : IDENTIFIER_KIND_BIT_2 (id) |= (kind >> 2) & 1;
142 : 23626973 : IDENTIFIER_KIND_BIT_1 (id) |= (kind >> 1) & 1;
143 : 23626973 : IDENTIFIER_KIND_BIT_0 (id) |= (kind >> 0) & 1;
144 : 23626973 : }
145 : :
146 : : /* Create and tag the internal operator name for the overloaded
147 : : operator PTR describes. */
148 : :
149 : : static tree
150 : 5155864 : set_operator_ident (ovl_op_info_t *ptr)
151 : : {
152 : 5155864 : char buffer[32];
153 : 10311728 : size_t len = snprintf (buffer, sizeof (buffer), "operator%s%s",
154 : 5155864 : &" "[ptr->name[0] && ptr->name[0] != '_'
155 : 5155864 : && !ISALPHA (ptr->name[0])],
156 : 5155864 : ptr->name);
157 : 5155864 : gcc_checking_assert (len < sizeof (buffer));
158 : :
159 : 5155864 : tree ident = get_identifier_with_length (buffer, len);
160 : 5155864 : ptr->identifier = ident;
161 : :
162 : 5155864 : return ident;
163 : : }
164 : :
165 : : /* Initialize data structures that keep track of operator names. */
166 : :
167 : : static void
168 : 92069 : init_operators (void)
169 : : {
170 : : /* We rely on both these being zero. */
171 : 92069 : gcc_checking_assert (!OVL_OP_ERROR_MARK && !ERROR_MARK);
172 : :
173 : : /* This loop iterates backwards because we need to move the
174 : : assignment operators down to their correct slots. I.e. morally
175 : : equivalent to an overlapping memmove where dest > src. Slot
176 : : zero is for error_mark, so hae no operator. */
177 : 5340002 : for (unsigned ix = OVL_OP_MAX; --ix;)
178 : : {
179 : 5247933 : ovl_op_info_t *op_ptr = &ovl_op_info[false][ix];
180 : :
181 : 5247933 : if (op_ptr->name)
182 : : {
183 : 4143105 : tree ident = set_operator_ident (op_ptr);
184 : 4143105 : if (unsigned index = IDENTIFIER_CP_INDEX (ident))
185 : : {
186 : 552414 : ovl_op_info_t *bin_ptr = &ovl_op_info[false][index];
187 : :
188 : : /* They should only differ in unary/binary ness. */
189 : 552414 : gcc_checking_assert ((op_ptr->flags ^ bin_ptr->flags)
190 : : == OVL_OP_FLAG_AMBIARY);
191 : 552414 : bin_ptr->flags |= op_ptr->flags;
192 : 552414 : ovl_op_alternate[index] = ix;
193 : : }
194 : : else
195 : : {
196 : 3590691 : IDENTIFIER_CP_INDEX (ident) = ix;
197 : 3590691 : set_identifier_kind (ident, cik_simple_op);
198 : : }
199 : : }
200 : 5247933 : if (op_ptr->tree_code)
201 : : {
202 : 5247933 : gcc_checking_assert (op_ptr->ovl_op_code == ix
203 : : && !ovl_op_mapping[op_ptr->tree_code]);
204 : 5247933 : ovl_op_mapping[op_ptr->tree_code] = op_ptr->ovl_op_code;
205 : : }
206 : :
207 : 5247933 : ovl_op_info_t *as_ptr = &ovl_op_info[true][ix];
208 : 5247933 : if (as_ptr->name)
209 : : {
210 : : /* These will be placed at the start of the array, move to
211 : : the correct slot and initialize. */
212 : 1012759 : if (as_ptr->ovl_op_code != ix)
213 : : {
214 : 920690 : ovl_op_info_t *dst_ptr = &ovl_op_info[true][as_ptr->ovl_op_code];
215 : 920690 : gcc_assert (as_ptr->ovl_op_code > ix && !dst_ptr->tree_code);
216 : 920690 : memcpy (dst_ptr, as_ptr, sizeof (*dst_ptr));
217 : 920690 : memset (as_ptr, 0, sizeof (*as_ptr));
218 : 920690 : as_ptr = dst_ptr;
219 : : }
220 : :
221 : 1012759 : tree ident = set_operator_ident (as_ptr);
222 : 1012759 : gcc_checking_assert (!IDENTIFIER_CP_INDEX (ident));
223 : 1012759 : IDENTIFIER_CP_INDEX (ident) = as_ptr->ovl_op_code;
224 : 1012759 : set_identifier_kind (ident, cik_assign_op);
225 : :
226 : 1012759 : gcc_checking_assert (!ovl_op_mapping[as_ptr->tree_code]
227 : : || (ovl_op_mapping[as_ptr->tree_code]
228 : : == as_ptr->ovl_op_code));
229 : 1012759 : ovl_op_mapping[as_ptr->tree_code] = as_ptr->ovl_op_code;
230 : : }
231 : : }
232 : 92069 : }
233 : :
234 : : /* Initialize the reserved words. */
235 : :
236 : : void
237 : 92069 : init_reswords (void)
238 : : {
239 : 92069 : unsigned int i;
240 : 92069 : tree id;
241 : 92069 : int mask = 0;
242 : :
243 : 92069 : if (cxx_dialect < cxx11)
244 : 13589 : mask |= D_CXX11;
245 : 92069 : if (cxx_dialect < cxx20)
246 : 64310 : mask |= D_CXX20;
247 : 92069 : if (!flag_concepts)
248 : 64127 : mask |= D_CXX_CONCEPTS;
249 : 92069 : if (!flag_coroutines)
250 : 63380 : mask |= D_CXX_COROUTINES;
251 : 92069 : if (!flag_modules)
252 : 88465 : mask |= D_CXX_MODULES;
253 : 92069 : if (!flag_tm)
254 : 91728 : mask |= D_TRANSMEM;
255 : 92069 : if (!flag_char8_t)
256 : 64252 : mask |= D_CXX_CHAR8_T;
257 : 92069 : if (flag_no_asm)
258 : 3 : mask |= D_ASM | D_EXT | D_EXT11;
259 : 92069 : if (flag_no_gnu_keywords)
260 : 47533 : mask |= D_EXT | D_EXT11;
261 : :
262 : : /* The Objective-C keywords are all context-dependent. */
263 : 92069 : mask |= D_OBJC;
264 : :
265 : 92069 : ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
266 : 20347249 : for (i = 0; i < num_c_common_reswords; i++)
267 : : {
268 : 20255180 : if (c_common_reswords[i].disable & D_CONLY)
269 : 3958967 : continue;
270 : 16296213 : id = get_identifier (c_common_reswords[i].word);
271 : 16296213 : C_SET_RID_CODE (id, c_common_reswords[i].rid);
272 : 16296213 : ridpointers [(int) c_common_reswords[i].rid] = id;
273 : 16296213 : if (! (c_common_reswords[i].disable & mask))
274 : 11838865 : set_identifier_kind (id, cik_keyword);
275 : : }
276 : :
277 : 184138 : for (i = 0; i < NUM_INT_N_ENTS; i++)
278 : : {
279 : 92069 : char name[50];
280 : 92069 : sprintf (name, "__int%d", int_n_data[i].bitsize);
281 : 92069 : id = get_identifier (name);
282 : 92069 : C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
283 : 92069 : set_identifier_kind (id, cik_keyword);
284 : :
285 : 92069 : sprintf (name, "__int%d__", int_n_data[i].bitsize);
286 : 92069 : id = get_identifier (name);
287 : 92069 : C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
288 : 92069 : set_identifier_kind (id, cik_keyword);
289 : : }
290 : :
291 : 92069 : if (flag_openmp)
292 : : {
293 : 3276 : id = get_identifier ("omp_all_memory");
294 : 3276 : C_SET_RID_CODE (id, RID_OMP_ALL_MEMORY);
295 : 3276 : set_identifier_kind (id, cik_keyword);
296 : 3276 : ridpointers [RID_OMP_ALL_MEMORY] = id;
297 : : }
298 : 92069 : }
299 : :
300 : : /* Initialize the C++ traits. */
301 : : static void
302 : 92069 : init_cp_traits (void)
303 : : {
304 : 92069 : tree id;
305 : :
306 : 6260692 : for (unsigned int i = 0; i < ARRAY_SIZE (cp_traits); ++i)
307 : : {
308 : 6168623 : id = get_identifier (cp_traits[i].name);
309 : 6168623 : IDENTIFIER_CP_INDEX (id) = cp_traits[i].kind;
310 : 6168623 : set_identifier_kind (id, cik_trait);
311 : : }
312 : :
313 : : /* An alias for __is_same. */
314 : 92069 : id = get_identifier ("__is_same_as");
315 : 92069 : IDENTIFIER_CP_INDEX (id) = CPTK_IS_SAME;
316 : 92069 : set_identifier_kind (id, cik_trait);
317 : 92069 : }
318 : :
319 : : static void
320 : 90929 : init_cp_pragma (void)
321 : : {
322 : 90929 : c_register_pragma (0, "vtable", handle_pragma_vtable);
323 : 90929 : c_register_pragma (0, "unit", handle_pragma_unit);
324 : 90929 : c_register_pragma (0, "interface", handle_pragma_interface);
325 : 90929 : c_register_pragma (0, "implementation", handle_pragma_implementation);
326 : 90929 : c_register_pragma ("GCC", "interface", handle_pragma_interface);
327 : 90929 : c_register_pragma ("GCC", "implementation", handle_pragma_implementation);
328 : 90929 : }
329 : :
330 : : /* TRUE if a code represents a statement. */
331 : :
332 : : bool statement_code_p[MAX_TREE_CODES];
333 : :
334 : : /* Initialize the C++ front end. This function is very sensitive to
335 : : the exact order that things are done here. It would be nice if the
336 : : initialization done by this routine were moved to its subroutines,
337 : : and the ordering dependencies clarified and reduced. */
338 : : bool
339 : 92069 : cxx_init (void)
340 : : {
341 : 92069 : location_t saved_loc;
342 : 92069 : unsigned int i;
343 : 92069 : static const enum tree_code stmt_codes[] = {
344 : : CTOR_INITIALIZER, TRY_BLOCK, HANDLER,
345 : : EH_SPEC_BLOCK, USING_STMT, TAG_DEFN,
346 : : IF_STMT, CLEANUP_STMT, FOR_STMT,
347 : : RANGE_FOR_STMT, WHILE_STMT, DO_STMT,
348 : : BREAK_STMT, CONTINUE_STMT, SWITCH_STMT,
349 : : EXPR_STMT, OMP_DEPOBJ
350 : : };
351 : :
352 : 92069 : memset (&statement_code_p, 0, sizeof (statement_code_p));
353 : 1657242 : for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
354 : 1565173 : statement_code_p[stmt_codes[i]] = true;
355 : :
356 : 92069 : saved_loc = input_location;
357 : 92069 : input_location = BUILTINS_LOCATION;
358 : :
359 : 92069 : init_reswords ();
360 : 92069 : init_cp_traits ();
361 : 92069 : init_tree ();
362 : 92069 : init_cp_semantics ();
363 : 92069 : init_operators ();
364 : 92069 : init_method ();
365 : :
366 : 92069 : current_function_decl = NULL;
367 : :
368 : 92069 : class_type_node = ridpointers[(int) RID_CLASS];
369 : :
370 : 92069 : cxx_init_decl_processing ();
371 : :
372 : 92069 : if (c_common_init () == false)
373 : : {
374 : 1110 : input_location = saved_loc;
375 : 1110 : return false;
376 : : }
377 : :
378 : 90929 : init_cp_pragma ();
379 : :
380 : 90929 : input_location = saved_loc;
381 : 90929 : return true;
382 : : }
383 : :
384 : : /* Return nonzero if S is not considered part of an
385 : : INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
386 : :
387 : : static int
388 : 79 : interface_strcmp (const char* s)
389 : : {
390 : : /* Set the interface/implementation bits for this scope. */
391 : 79 : struct impl_files *ifiles;
392 : 79 : const char *s1;
393 : :
394 : 91 : for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
395 : : {
396 : 48 : const char *t1 = ifiles->filename;
397 : 48 : s1 = s;
398 : :
399 : 48 : if (*s1 == 0 || filename_ncmp (s1, t1, 1) != 0)
400 : 6 : continue;
401 : :
402 : 462 : while (*s1 != 0 && filename_ncmp (s1, t1, 1) == 0)
403 : 420 : s1++, t1++;
404 : :
405 : : /* A match. */
406 : 42 : if (*s1 == *t1)
407 : : return 0;
408 : :
409 : : /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
410 : 18 : if (strchr (s1, '.') || strchr (t1, '.'))
411 : 6 : continue;
412 : :
413 : 12 : if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
414 : 0 : continue;
415 : :
416 : : /* A match. */
417 : : return 0;
418 : : }
419 : :
420 : : /* No matches. */
421 : : return 1;
422 : : }
423 : :
424 : : /* We've just read a cpp-token, figure out our next state. Hey, this
425 : : is a hand-coded co-routine! */
426 : :
427 : : struct module_token_filter
428 : : {
429 : : enum state
430 : : {
431 : : idle,
432 : : module_first,
433 : : module_cont,
434 : : module_end,
435 : : };
436 : :
437 : : enum state state : 8;
438 : : bool is_import : 1;
439 : : bool got_export : 1;
440 : : bool got_colon : 1;
441 : : bool want_dot : 1;
442 : :
443 : : location_t token_loc;
444 : : cpp_reader *reader;
445 : : module_state *module;
446 : : module_state *import;
447 : :
448 : 3604 : module_token_filter (cpp_reader *reader)
449 : 3604 : : state (idle), is_import (false),
450 : 3604 : got_export (false), got_colon (false), want_dot (false),
451 : 3604 : token_loc (UNKNOWN_LOCATION),
452 : 3604 : reader (reader), module (NULL), import (NULL)
453 : : {
454 : : };
455 : :
456 : : /* Process the next token. Note we cannot see CPP_EOF inside a
457 : : pragma -- a CPP_PRAGMA_EOL always happens. */
458 : 36641801 : uintptr_t resume (int type, int keyword, tree value, location_t loc)
459 : : {
460 : 36641801 : unsigned res = 0;
461 : :
462 : 36641801 : switch (state)
463 : : {
464 : 36629089 : case idle:
465 : 36629089 : if (type == CPP_KEYWORD)
466 : 6277924 : switch (keyword)
467 : : {
468 : : default:
469 : : break;
470 : :
471 : 1561 : case RID__EXPORT:
472 : 1561 : got_export = true;
473 : 1561 : res = lang_hooks::PT_begin_pragma;
474 : 1561 : break;
475 : :
476 : 2004 : case RID__IMPORT:
477 : 2004 : is_import = true;
478 : : /* FALLTHRU */
479 : 3947 : case RID__MODULE:
480 : 3947 : state = module_first;
481 : 3947 : want_dot = false;
482 : 3947 : got_colon = false;
483 : 3947 : token_loc = loc;
484 : 3947 : import = NULL;
485 : 3947 : if (!got_export)
486 : 3947 : res = lang_hooks::PT_begin_pragma;
487 : : break;
488 : : }
489 : : break;
490 : :
491 : 3962 : case module_first:
492 : 3962 : if (is_import && type == CPP_HEADER_NAME)
493 : : {
494 : : /* A header name. The preprocessor will have already
495 : : done include searching and canonicalization. */
496 : 774 : state = module_end;
497 : 774 : goto header_unit;
498 : : }
499 : :
500 : 3188 : if (type == CPP_PADDING || type == CPP_COMMENT)
501 : : break;
502 : :
503 : 3173 : state = module_cont;
504 : 3173 : if (type == CPP_COLON && module)
505 : : {
506 : 175 : got_colon = true;
507 : 175 : import = module;
508 : 175 : break;
509 : : }
510 : : /* FALLTHROUGH */
511 : :
512 : 6762 : case module_cont:
513 : 6762 : switch (type)
514 : : {
515 : : case CPP_PADDING:
516 : : case CPP_COMMENT:
517 : : break;
518 : :
519 : 3161 : default:
520 : : /* If we ever need to pay attention to attributes for
521 : : header modules, more logic will be needed. */
522 : 3161 : state = module_end;
523 : 3161 : break;
524 : :
525 : 175 : case CPP_COLON:
526 : 175 : if (got_colon)
527 : 0 : state = module_end;
528 : 175 : got_colon = true;
529 : : /* FALLTHROUGH */
530 : 369 : case CPP_DOT:
531 : 369 : if (!want_dot)
532 : 9 : state = module_end;
533 : 369 : want_dot = false;
534 : 369 : break;
535 : :
536 : 3 : case CPP_PRAGMA_EOL:
537 : 3 : goto module_end;
538 : :
539 : 3229 : case CPP_NAME:
540 : 3229 : if (want_dot)
541 : : {
542 : : /* Got name instead of [.:]. */
543 : 0 : state = module_end;
544 : 0 : break;
545 : : }
546 : 3229 : header_unit:
547 : 4003 : import = get_module (value, import, got_colon);
548 : 4003 : want_dot = true;
549 : 4003 : break;
550 : : }
551 : : break;
552 : :
553 : 4986 : case module_end:
554 : 4986 : if (type == CPP_PRAGMA_EOL)
555 : : {
556 : 3944 : module_end:;
557 : : /* End of the directive, handle the name. */
558 : 3947 : if (import && (is_import || !flag_header_unit))
559 : 7304 : if (module_state *m
560 : 3652 : = preprocess_module (import, token_loc, module != NULL,
561 : 3652 : is_import, got_export, reader))
562 : 1639 : if (!module)
563 : 1624 : module = m;
564 : :
565 : 3947 : is_import = got_export = false;
566 : 3947 : state = idle;
567 : : }
568 : : break;
569 : : }
570 : :
571 : 36641801 : return res;
572 : : }
573 : : };
574 : :
575 : : /* Initialize or teardown. */
576 : :
577 : : uintptr_t
578 : 8288 : module_token_cdtor (cpp_reader *pfile, uintptr_t data_)
579 : : {
580 : 8288 : if (module_token_filter *filter = reinterpret_cast<module_token_filter *> (data_))
581 : : {
582 : 3604 : preprocessed_module (pfile);
583 : 3601 : delete filter;
584 : 3601 : data_ = 0;
585 : : }
586 : 4684 : else if (modules_p ())
587 : 3604 : data_ = reinterpret_cast<uintptr_t > (new module_token_filter (pfile));
588 : :
589 : 8285 : return data_;
590 : : }
591 : :
592 : : uintptr_t
593 : 36641801 : module_token_lang (int type, int keyword, tree value, location_t loc,
594 : : uintptr_t data_)
595 : : {
596 : 36641801 : module_token_filter *filter = reinterpret_cast<module_token_filter *> (data_);
597 : 36641801 : return filter->resume (type, keyword, value, loc);
598 : : }
599 : :
600 : : uintptr_t
601 : 734755 : module_token_pre (cpp_reader *pfile, const cpp_token *tok, uintptr_t data_)
602 : : {
603 : 734755 : if (!tok)
604 : 1194 : return module_token_cdtor (pfile, data_);
605 : :
606 : 733561 : int type = tok->type;
607 : 733561 : int keyword = RID_MAX;
608 : 733561 : tree value = NULL_TREE;
609 : :
610 : 733561 : if (tok->type == CPP_NAME)
611 : : {
612 : 319077 : value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
613 : 319077 : if (IDENTIFIER_KEYWORD_P (value))
614 : : {
615 : 122435 : keyword = C_RID_CODE (value);
616 : 122435 : type = CPP_KEYWORD;
617 : : }
618 : : }
619 : 414484 : else if (tok->type == CPP_HEADER_NAME)
620 : 36 : value = build_string (tok->val.str.len, (const char *)tok->val.str.text);
621 : :
622 : 733561 : return module_token_lang (type, keyword, value, tok->src_loc, data_);
623 : : }
624 : :
625 : : /* Parse a #pragma whose sole argument is a string constant.
626 : : If OPT is true, the argument is optional. */
627 : : static tree
628 : 121 : parse_strconst_pragma (const char* name, int opt)
629 : : {
630 : 121 : tree result, x;
631 : 121 : enum cpp_ttype t;
632 : :
633 : 121 : t = pragma_lex (&result);
634 : 121 : if (t == CPP_STRING)
635 : : {
636 : 48 : if (pragma_lex (&x) != CPP_EOF)
637 : 0 : warning (0, "junk at end of %<#pragma %s%>", name);
638 : 48 : return result;
639 : : }
640 : :
641 : 73 : if (t == CPP_EOF && opt)
642 : : return NULL_TREE;
643 : :
644 : 0 : error ("invalid %<#pragma %s%>", name);
645 : 0 : return error_mark_node;
646 : : }
647 : :
648 : : static void
649 : 0 : handle_pragma_vtable (cpp_reader* /*dfile*/)
650 : : {
651 : 0 : parse_strconst_pragma ("vtable", 0);
652 : 0 : sorry ("%<#pragma vtable%> no longer supported");
653 : 0 : }
654 : :
655 : : static void
656 : 0 : handle_pragma_unit (cpp_reader* /*dfile*/)
657 : : {
658 : : /* Validate syntax, but don't do anything. */
659 : 0 : parse_strconst_pragma ("unit", 0);
660 : 0 : }
661 : :
662 : : static void
663 : 79 : handle_pragma_interface (cpp_reader* /*dfile*/)
664 : : {
665 : 79 : tree fname = parse_strconst_pragma ("interface", 1);
666 : 79 : struct c_fileinfo *finfo;
667 : 79 : const char *filename;
668 : :
669 : 79 : if (fname == error_mark_node)
670 : : return;
671 : 79 : else if (fname == 0)
672 : 61 : filename = lbasename (LOCATION_FILE (input_location));
673 : : else
674 : 18 : filename = TREE_STRING_POINTER (fname);
675 : :
676 : 79 : finfo = get_fileinfo (LOCATION_FILE (input_location));
677 : :
678 : 79 : if (impl_file_chain == 0)
679 : : {
680 : : /* If this is zero at this point, then we are
681 : : auto-implementing. */
682 : 34 : if (main_input_filename == 0)
683 : 0 : main_input_filename = LOCATION_FILE (input_location);
684 : : }
685 : :
686 : 79 : finfo->interface_only = interface_strcmp (filename);
687 : : /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
688 : : a definition in another file. */
689 : 79 : if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
690 : 79 : finfo->interface_unknown = 0;
691 : : }
692 : :
693 : : /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
694 : : We used to only allow this at toplevel, but that restriction was buggy
695 : : in older compilers and it seems reasonable to allow it in the headers
696 : : themselves, too. It only needs to precede the matching #p interface.
697 : :
698 : : We don't touch finfo->interface_only or finfo->interface_unknown;
699 : : the user must specify a matching #p interface for this to have
700 : : any effect. */
701 : :
702 : : static void
703 : 42 : handle_pragma_implementation (cpp_reader* /*dfile*/)
704 : : {
705 : 42 : tree fname = parse_strconst_pragma ("implementation", 1);
706 : 42 : const char *filename;
707 : 42 : struct impl_files *ifiles = impl_file_chain;
708 : :
709 : 42 : if (fname == error_mark_node)
710 : : return;
711 : :
712 : 42 : if (fname == 0)
713 : : {
714 : 12 : if (main_input_filename)
715 : : filename = main_input_filename;
716 : : else
717 : 0 : filename = LOCATION_FILE (input_location);
718 : 12 : filename = lbasename (filename);
719 : : }
720 : : else
721 : : {
722 : 30 : filename = TREE_STRING_POINTER (fname);
723 : 30 : if (cpp_included_before (parse_in, filename, input_location))
724 : 3 : warning (0, "%<#pragma implementation%> for %qs appears after "
725 : : "file is included", filename);
726 : : }
727 : :
728 : 45 : for (; ifiles; ifiles = ifiles->next)
729 : : {
730 : 3 : if (! filename_cmp (ifiles->filename, filename))
731 : : break;
732 : : }
733 : 42 : if (ifiles == 0)
734 : : {
735 : 42 : ifiles = XNEW (struct impl_files);
736 : 42 : ifiles->filename = xstrdup (filename);
737 : 42 : ifiles->next = impl_file_chain;
738 : 42 : impl_file_chain = ifiles;
739 : : }
740 : : }
741 : :
742 : : /* Issue an error message indicating that the lookup of NAME (an
743 : : IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
744 : :
745 : : tree
746 : 1713 : unqualified_name_lookup_error (tree name, location_t loc)
747 : : {
748 : 1713 : if (loc == UNKNOWN_LOCATION)
749 : 1263 : loc = cp_expr_loc_or_input_loc (name);
750 : :
751 : 1713 : if (IDENTIFIER_ANY_OP_P (name))
752 : 9 : error_at (loc, "%qD not defined", name);
753 : : else
754 : : {
755 : 1704 : if (!objc_diagnose_private_ivar (name))
756 : : {
757 : 1704 : auto_diagnostic_group d;
758 : 1704 : name_hint hint = suggest_alternatives_for (loc, name, true);
759 : 1704 : if (const char *suggestion = hint.suggestion ())
760 : : {
761 : 241 : gcc_rich_location richloc (loc);
762 : 241 : richloc.add_fixit_replace (suggestion);
763 : 241 : error_at (&richloc,
764 : : "%qD was not declared in this scope; did you mean %qs?",
765 : : name, suggestion);
766 : 241 : }
767 : : else
768 : 1463 : error_at (loc, "%qD was not declared in this scope", name);
769 : 1704 : }
770 : : /* Prevent repeated error messages by creating a VAR_DECL with
771 : : this NAME in the innermost block scope. */
772 : 1704 : if (local_bindings_p ())
773 : : {
774 : 1329 : tree decl = build_decl (loc, VAR_DECL, name, error_mark_node);
775 : 1329 : TREE_USED (decl) = true;
776 : 1329 : pushdecl (decl);
777 : : }
778 : : }
779 : :
780 : 1713 : return error_mark_node;
781 : : }
782 : :
783 : : /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
784 : : NAME, encapsulated with its location in a CP_EXPR, used as a function.
785 : : Returns an appropriate expression for NAME. */
786 : :
787 : : tree
788 : 512 : unqualified_fn_lookup_error (cp_expr name_expr)
789 : : {
790 : 512 : tree name = name_expr.get_value ();
791 : 512 : location_t loc = name_expr.get_location ();
792 : 512 : if (loc == UNKNOWN_LOCATION)
793 : 51 : loc = input_location;
794 : :
795 : 512 : if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
796 : 1 : name = TREE_OPERAND (name, 0);
797 : :
798 : 512 : if (processing_template_decl)
799 : : {
800 : : /* In a template, it is invalid to write "f()" or "f(3)" if no
801 : : declaration of "f" is available. Historically, G++ and most
802 : : other compilers accepted that usage since they deferred all name
803 : : lookup until instantiation time rather than doing unqualified
804 : : name lookup at template definition time; explain to the user what
805 : : is going wrong.
806 : :
807 : : Note that we have the exact wording of the following message in
808 : : the manual (trouble.texi, node "Name lookup"), so they need to
809 : : be kept in synch. */
810 : 62 : auto_diagnostic_group d;
811 : 62 : permerror (loc, "there are no arguments to %qD that depend on a template "
812 : : "parameter, so a declaration of %qD must be available",
813 : : name, name);
814 : :
815 : 62 : if (!flag_permissive)
816 : : {
817 : 44 : static bool hint;
818 : 44 : if (!hint)
819 : : {
820 : 35 : inform (loc, "(if you use %<-fpermissive%>, G++ will accept your "
821 : : "code, but allowing the use of an undeclared name is "
822 : : "deprecated)");
823 : 35 : hint = true;
824 : : }
825 : : }
826 : 62 : return name;
827 : 62 : }
828 : :
829 : 450 : return unqualified_name_lookup_error (name, loc);
830 : : }
831 : :
832 : :
833 : : /* Hasher for the conversion operator name hash table. */
834 : : struct conv_type_hasher : ggc_ptr_hash<tree_node>
835 : : {
836 : : /* Hash NODE, an identifier node in the table. TYPE_UID is
837 : : suitable, as we're not concerned about matching canonicalness
838 : : here. */
839 : 11862730 : static hashval_t hash (tree node)
840 : : {
841 : 11862730 : return (hashval_t) TYPE_UID (TREE_TYPE (node));
842 : : }
843 : :
844 : : /* Compare NODE, an identifier node in the table, against TYPE, an
845 : : incoming TYPE being looked up. */
846 : 13854630 : static bool equal (tree node, tree type)
847 : : {
848 : 13854630 : return TREE_TYPE (node) == type;
849 : : }
850 : : };
851 : :
852 : : /* This hash table maps TYPEs to the IDENTIFIER for a conversion
853 : : operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
854 : : TYPE. */
855 : :
856 : : static GTY (()) hash_table<conv_type_hasher> *conv_type_names;
857 : :
858 : : /* Return an identifier for a conversion operator to TYPE. We can get
859 : : from the returned identifier to the type. We store TYPE, which is
860 : : not necessarily the canonical type, which allows us to report the
861 : : form the user used in error messages. All these identifiers are
862 : : not in the identifier hash table, and have the same string name.
863 : : These IDENTIFIERS are not in the identifier hash table, and all
864 : : have the same IDENTIFIER_STRING. */
865 : :
866 : : tree
867 : 2116617 : make_conv_op_name (tree type)
868 : : {
869 : 2116617 : if (type == error_mark_node)
870 : : return error_mark_node;
871 : :
872 : 2116614 : if (conv_type_names == NULL)
873 : 18580 : conv_type_names = hash_table<conv_type_hasher>::create_ggc (31);
874 : :
875 : 2116614 : tree *slot = conv_type_names->find_slot_with_hash
876 : 2116614 : (type, (hashval_t) TYPE_UID (type), INSERT);
877 : 2116614 : tree identifier = *slot;
878 : 2116614 : if (!identifier)
879 : : {
880 : : /* Create a raw IDENTIFIER outside of the identifier hash
881 : : table. */
882 : 864878 : identifier = copy_node (conv_op_identifier);
883 : :
884 : : /* Just in case something managed to bind. */
885 : 864878 : IDENTIFIER_BINDING (identifier) = NULL;
886 : :
887 : : /* Hang TYPE off the identifier so it can be found easily later
888 : : when performing conversions. */
889 : 864878 : TREE_TYPE (identifier) = type;
890 : :
891 : 864878 : *slot = identifier;
892 : : }
893 : :
894 : : return identifier;
895 : : }
896 : :
897 : : /* Wrapper around build_lang_decl_loc(). Should gradually move to
898 : : build_lang_decl_loc() and then rename build_lang_decl_loc() back to
899 : : build_lang_decl(). */
900 : :
901 : : tree
902 : 232083469 : build_lang_decl (enum tree_code code, tree name, tree type)
903 : : {
904 : 232083469 : return build_lang_decl_loc (input_location, code, name, type);
905 : : }
906 : :
907 : : /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
908 : : DECL_LANG_SPECIFIC info to the result. */
909 : :
910 : : tree
911 : 431099515 : build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type)
912 : : {
913 : 431099515 : tree t;
914 : :
915 : 431099515 : t = build_decl (loc, code, name, type);
916 : 431099515 : retrofit_lang_decl (t);
917 : :
918 : 431099515 : return t;
919 : : }
920 : :
921 : : /* Maybe add a raw lang_decl to T, a decl. Return true if it needed
922 : : one. */
923 : :
924 : : bool
925 : 911813965 : maybe_add_lang_decl_raw (tree t, bool decomp_p)
926 : : {
927 : 911813965 : size_t size;
928 : 911813965 : lang_decl_selector sel;
929 : :
930 : 911813965 : if (decomp_p)
931 : : sel = lds_decomp, size = sizeof (struct lang_decl_decomp);
932 : 911633506 : else if (TREE_CODE (t) == FUNCTION_DECL)
933 : : sel = lds_fn, size = sizeof (struct lang_decl_fn);
934 : : else if (TREE_CODE (t) == NAMESPACE_DECL)
935 : : sel = lds_ns, size = sizeof (struct lang_decl_ns);
936 : : else if (TREE_CODE (t) == PARM_DECL)
937 : : sel = lds_parm, size = sizeof (struct lang_decl_parm);
938 : : else if (LANG_DECL_HAS_MIN (t))
939 : : sel = lds_min, size = sizeof (struct lang_decl_min);
940 : : else
941 : : return false;
942 : :
943 : 911813965 : struct lang_decl *ld
944 : 911813965 : = (struct lang_decl *) ggc_internal_cleared_alloc (size);
945 : :
946 : 911813965 : ld->u.base.selector = sel;
947 : 911813965 : DECL_LANG_SPECIFIC (t) = ld;
948 : :
949 : 911813965 : if (sel == lds_ns)
950 : : /* Who'd create a namespace, only to put nothing in it? */
951 : 885186 : ld->u.ns.bindings = hash_table<named_decl_hash>::create_ggc (499);
952 : :
953 : : if (GATHER_STATISTICS)
954 : : {
955 : : tree_node_counts[(int)lang_decl] += 1;
956 : : tree_node_sizes[(int)lang_decl] += size;
957 : : }
958 : : return true;
959 : : }
960 : :
961 : : /* T has just had a decl_lang_specific added. Initialize its
962 : : linkage. */
963 : :
964 : : static void
965 : 908720876 : set_decl_linkage (tree t)
966 : : {
967 : 908720876 : if (current_lang_name == lang_name_cplusplus
968 : 908720876 : || decl_linkage (t) == lk_none)
969 : 631996528 : SET_DECL_LANGUAGE (t, lang_cplusplus);
970 : 276724348 : else if (current_lang_name == lang_name_c)
971 : 276724348 : SET_DECL_LANGUAGE (t, lang_c);
972 : : else
973 : 0 : gcc_unreachable ();
974 : 908720876 : }
975 : :
976 : : /* T is a VAR_DECL node that needs to be a decomposition of BASE. */
977 : :
978 : : void
979 : 379184 : fit_decomposition_lang_decl (tree t, tree base)
980 : : {
981 : 379184 : if (struct lang_decl *orig_ld = DECL_LANG_SPECIFIC (t))
982 : : {
983 : 200936 : if (orig_ld->u.base.selector == lds_min)
984 : : {
985 : 800 : maybe_add_lang_decl_raw (t, true);
986 : 800 : memcpy (DECL_LANG_SPECIFIC (t), orig_ld,
987 : : sizeof (struct lang_decl_min));
988 : : /* Reset selector, which will have been bashed by the
989 : : memcpy. */
990 : 800 : DECL_LANG_SPECIFIC (t)->u.base.selector = lds_decomp;
991 : : }
992 : : else
993 : 200136 : gcc_checking_assert (orig_ld->u.base.selector == lds_decomp);
994 : : }
995 : : else
996 : : {
997 : 178248 : maybe_add_lang_decl_raw (t, true);
998 : 178248 : set_decl_linkage (t);
999 : : }
1000 : :
1001 : 379184 : DECL_DECOMP_BASE (t) = base;
1002 : 379184 : }
1003 : :
1004 : : /* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally
1005 : : every C++ decl needs one, but C builtins etc do not. */
1006 : :
1007 : : void
1008 : 1109378021 : retrofit_lang_decl (tree t)
1009 : : {
1010 : 1109378021 : if (DECL_LANG_SPECIFIC (t))
1011 : : return;
1012 : :
1013 : 908542628 : if (maybe_add_lang_decl_raw (t, false))
1014 : 908542628 : set_decl_linkage (t);
1015 : : }
1016 : :
1017 : : void
1018 : 666298398 : cxx_dup_lang_specific_decl (tree node)
1019 : : {
1020 : 666298398 : int size;
1021 : :
1022 : 666298398 : if (! DECL_LANG_SPECIFIC (node))
1023 : : return;
1024 : :
1025 : 494051733 : switch (DECL_LANG_SPECIFIC (node)->u.base.selector)
1026 : : {
1027 : : case lds_min:
1028 : : size = sizeof (struct lang_decl_min);
1029 : : break;
1030 : : case lds_fn:
1031 : : size = sizeof (struct lang_decl_fn);
1032 : : break;
1033 : : case lds_ns:
1034 : : size = sizeof (struct lang_decl_ns);
1035 : : break;
1036 : : case lds_parm:
1037 : : size = sizeof (struct lang_decl_parm);
1038 : : break;
1039 : : case lds_decomp:
1040 : : size = sizeof (struct lang_decl_decomp);
1041 : : break;
1042 : 0 : default:
1043 : 0 : gcc_unreachable ();
1044 : : }
1045 : :
1046 : 494051733 : struct lang_decl *ld = (struct lang_decl *) ggc_internal_alloc (size);
1047 : 494051733 : memcpy (ld, DECL_LANG_SPECIFIC (node), size);
1048 : 494051733 : DECL_LANG_SPECIFIC (node) = ld;
1049 : :
1050 : : /* Directly clear some flags that do not apply to the copy
1051 : : (module_purview_p still does). */
1052 : 494051733 : ld->u.base.module_entity_p = false;
1053 : 494051733 : ld->u.base.module_import_p = false;
1054 : 494051733 : ld->u.base.module_keyed_decls_p = false;
1055 : :
1056 : 494051733 : if (GATHER_STATISTICS)
1057 : : {
1058 : : tree_node_counts[(int)lang_decl] += 1;
1059 : : tree_node_sizes[(int)lang_decl] += size;
1060 : : }
1061 : : }
1062 : :
1063 : : /* Copy DECL, including any language-specific parts. */
1064 : :
1065 : : tree
1066 : 395156236 : copy_decl (tree decl MEM_STAT_DECL)
1067 : : {
1068 : 395156236 : tree copy;
1069 : :
1070 : 395156236 : copy = copy_node (decl PASS_MEM_STAT);
1071 : 395156236 : cxx_dup_lang_specific_decl (copy);
1072 : 395156236 : return copy;
1073 : : }
1074 : :
1075 : : /* Replace the shared language-specific parts of NODE with a new copy. */
1076 : :
1077 : : static void
1078 : 11931776 : copy_lang_type (tree node)
1079 : : {
1080 : 11931776 : if (! TYPE_LANG_SPECIFIC (node))
1081 : : return;
1082 : :
1083 : 0 : auto *lt = (struct lang_type *) ggc_internal_alloc (sizeof (struct lang_type));
1084 : :
1085 : 0 : memcpy (lt, TYPE_LANG_SPECIFIC (node), (sizeof (struct lang_type)));
1086 : 0 : TYPE_LANG_SPECIFIC (node) = lt;
1087 : :
1088 : 0 : if (GATHER_STATISTICS)
1089 : : {
1090 : : tree_node_counts[(int)lang_type] += 1;
1091 : : tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1092 : : }
1093 : : }
1094 : :
1095 : : /* Copy TYPE, including any language-specific parts. */
1096 : :
1097 : : tree
1098 : 11931776 : copy_type (tree type MEM_STAT_DECL)
1099 : : {
1100 : 11931776 : tree copy;
1101 : :
1102 : 11931776 : copy = copy_node (type PASS_MEM_STAT);
1103 : 11931776 : copy_lang_type (copy);
1104 : 11931776 : return copy;
1105 : : }
1106 : :
1107 : : /* Add a raw lang_type to T, a type, should it need one. */
1108 : :
1109 : : bool
1110 : 635455002 : maybe_add_lang_type_raw (tree t)
1111 : : {
1112 : 635455002 : if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t)))
1113 : : return false;
1114 : :
1115 : 105811545 : auto *lt = (struct lang_type *) (ggc_internal_cleared_alloc
1116 : 105811545 : (sizeof (struct lang_type)));
1117 : 105811545 : TYPE_LANG_SPECIFIC (t) = lt;
1118 : :
1119 : 105811545 : if (GATHER_STATISTICS)
1120 : : {
1121 : : tree_node_counts[(int)lang_type] += 1;
1122 : : tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1123 : : }
1124 : :
1125 : 105811545 : return true;
1126 : : }
1127 : :
1128 : : tree
1129 : 635219286 : cxx_make_type (enum tree_code code MEM_STAT_DECL)
1130 : : {
1131 : 635219286 : tree t = make_node (code PASS_MEM_STAT);
1132 : :
1133 : 635219286 : if (maybe_add_lang_type_raw (t))
1134 : : {
1135 : : /* Set up some flags that give proper default behavior. */
1136 : 105575829 : struct c_fileinfo *finfo =
1137 : 105575829 : get_fileinfo (LOCATION_FILE (input_location));
1138 : 105575829 : SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
1139 : 105575829 : CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
1140 : : }
1141 : :
1142 : 635219286 : if (code == RECORD_TYPE || code == UNION_TYPE)
1143 : 105575829 : TYPE_CXX_ODR_P (t) = 1;
1144 : :
1145 : 635219286 : return t;
1146 : : }
1147 : :
1148 : : /* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE. */
1149 : :
1150 : : tree
1151 : 121714 : cxx_make_type_hook (enum tree_code code)
1152 : : {
1153 : 121714 : return cxx_make_type (code);
1154 : : }
1155 : :
1156 : : tree
1157 : 105454108 : make_class_type (enum tree_code code MEM_STAT_DECL)
1158 : : {
1159 : 105454108 : tree t = cxx_make_type (code PASS_MEM_STAT);
1160 : 105454108 : SET_CLASS_TYPE_P (t, 1);
1161 : 105454108 : return t;
1162 : : }
1163 : :
1164 : : /* Returns true if we are currently in the main source file, or in a
1165 : : template instantiation started from the main source file. */
1166 : :
1167 : : bool
1168 : 144 : in_main_input_context (void)
1169 : : {
1170 : 144 : struct tinst_level *tl = outermost_tinst_level();
1171 : :
1172 : 144 : if (tl)
1173 : 9 : return filename_cmp (main_input_filename,
1174 : 18 : LOCATION_FILE (tl->locus)) == 0;
1175 : : else
1176 : 135 : return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0;
1177 : : }
1178 : :
1179 : : #include "gt-cp-lex.h"
|
