1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This file is the lexical analyzer for GNU C++. */
42 #include "diagnostic.h"
44 #ifdef MULTIBYTE_CHARS
49 extern void yyprint PARAMS ((FILE *, int, YYSTYPE));
51 static int interface_strcmp PARAMS ((const char *));
52 static int *init_cpp_parse PARAMS ((void));
53 static void init_cp_pragma PARAMS ((void));
55 static tree parse_strconst_pragma PARAMS ((const char *, int));
56 static void handle_pragma_vtable PARAMS ((cpp_reader *));
57 static void handle_pragma_unit PARAMS ((cpp_reader *));
58 static void handle_pragma_interface PARAMS ((cpp_reader *));
59 static void handle_pragma_implementation PARAMS ((cpp_reader *));
60 static void handle_pragma_java_exceptions PARAMS ((cpp_reader *));
62 #ifdef GATHER_STATISTICS
64 static int reduce_cmp PARAMS ((int *, int *));
65 static int token_cmp PARAMS ((int *, int *));
68 static int is_global PARAMS ((tree));
69 static void init_operators PARAMS ((void));
70 static void copy_lang_type PARAMS ((tree));
72 /* A constraint that can be tested at compile time. */
74 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
76 #define CONSTRAINT(name, expr) extern int constraint_/**/name [(expr) ? 1 : -1]
81 extern int yychar; /* the lookahead symbol */
82 extern YYSTYPE yylval; /* the semantic value of the */
83 /* lookahead symbol */
85 /* These flags are used by c-lex.c. In C++, they're always off and on,
87 int warn_traditional = 0;
88 int flag_digraphs = 1;
90 /* the declaration found for the last IDENTIFIER token read in.
91 yylex must look this up to detect typedefs, which get token type TYPENAME,
92 so it is left around in case the identifier is not a typedef but is
93 used in a context which makes it a reference to a variable. */
96 /* Array for holding counts of the numbers of tokens seen. */
97 extern int *token_count;
99 /* Functions and data structures for #pragma interface.
101 `#pragma implementation' means that the main file being compiled
102 is considered to implement (provide) the classes that appear in
103 its main body. I.e., if this is file "foo.cc", and class `bar'
104 is defined in "foo.cc", then we say that "foo.cc implements bar".
106 All main input files "implement" themselves automagically.
108 `#pragma interface' means that unless this file (of the form "foo.h"
109 is not presently being included by file "foo.cc", the
110 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
111 of the vtables nor any of the inline functions defined in foo.h
114 There are cases when we want to link files such as "defs.h" and
115 "main.cc". In this case, we give "defs.h" a `#pragma interface',
116 and "main.cc" has `#pragma implementation "defs.h"'. */
120 const char *filename;
121 struct impl_files *next;
124 static struct impl_files *impl_file_chain;
127 /* Return something to represent absolute declarators containing a *.
128 TARGET is the absolute declarator that the * contains.
129 CV_QUALIFIERS is a list of modifiers such as const or volatile
130 to apply to the pointer type, represented as identifiers.
132 We return an INDIRECT_REF whose "contents" are TARGET
133 and whose type is the modifier list. */
136 make_pointer_declarator (cv_qualifiers, target)
137 tree cv_qualifiers, target;
139 if (target && TREE_CODE (target) == IDENTIFIER_NODE
140 && ANON_AGGRNAME_P (target))
141 error ("type name expected before `*'");
142 target = build_nt (INDIRECT_REF, target);
143 TREE_TYPE (target) = cv_qualifiers;
147 /* Return something to represent absolute declarators containing a &.
148 TARGET is the absolute declarator that the & contains.
149 CV_QUALIFIERS is a list of modifiers such as const or volatile
150 to apply to the reference type, represented as identifiers.
152 We return an ADDR_EXPR whose "contents" are TARGET
153 and whose type is the modifier list. */
156 make_reference_declarator (cv_qualifiers, target)
157 tree cv_qualifiers, target;
161 if (TREE_CODE (target) == ADDR_EXPR)
163 error ("cannot declare references to references");
166 if (TREE_CODE (target) == INDIRECT_REF)
168 error ("cannot declare pointers to references");
171 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
172 error ("type name expected before `&'");
174 target = build_nt (ADDR_EXPR, target);
175 TREE_TYPE (target) = cv_qualifiers;
180 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
181 tree target, parms, cv_qualifiers, exception_specification;
183 target = build_nt (CALL_EXPR, target,
184 tree_cons (parms, cv_qualifiers, NULL_TREE),
185 /* The third operand is really RTL. We
186 shouldn't put anything there. */
188 CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
193 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
194 tree call_declarator, cv_qualifiers, exception_specification;
196 CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
197 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
200 int interface_only; /* whether or not current file is only for
201 interface definitions. */
202 int interface_unknown; /* whether or not we know this class
203 to behave according to #pragma interface. */
206 /* Initialization before switch parsing. */
210 c_common_init_options (clk_cplusplus);
212 /* Default exceptions on. */
214 /* By default wrap lines at 80 characters. Is getenv ("COLUMNS")
216 diagnostic_line_cutoff (global_dc) = 80;
217 /* By default, emit location information once for every
218 diagnostic message. */
219 diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
231 #ifdef GATHER_STATISTICS
233 reduce_count = (int *) xcalloc (sizeof (int), (REDUCE_LENGTH + 1));
235 token_count = (int *) xcalloc (sizeof (int), (TOKEN_LENGTH + 1));
242 /* A mapping from tree codes to operator name information. */
243 operator_name_info_t operator_name_info[(int) LAST_CPLUS_TREE_CODE];
244 /* Similar, but for assignment operators. */
245 operator_name_info_t assignment_operator_name_info[(int) LAST_CPLUS_TREE_CODE];
247 /* Initialize data structures that keep track of operator names. */
249 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
250 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
251 #include "operators.def"
259 struct operator_name_info_t *oni;
261 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
262 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
263 identifier = get_identifier (buffer); \
264 IDENTIFIER_OPNAME_P (identifier) = 1; \
267 ? &assignment_operator_name_info[(int) CODE] \
268 : &operator_name_info[(int) CODE]); \
269 oni->identifier = identifier; \
271 oni->mangled_name = MANGLING;
273 #include "operators.def"
276 operator_name_info[(int) ERROR_MARK].identifier
277 = get_identifier ("<invalid operator>");
279 /* Handle some special cases. These operators are not defined in
280 the language, but can be produced internally. We may need them
281 for error-reporting. (Eventually, we should ensure that this
282 does not happen. Error messages involving these operators will
283 be confusing to users.) */
285 operator_name_info [(int) INIT_EXPR].name
286 = operator_name_info [(int) MODIFY_EXPR].name;
287 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)";
288 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)";
289 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)";
290 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)";
291 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)";
292 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)";
293 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)";
294 operator_name_info [(int) ABS_EXPR].name = "abs";
295 operator_name_info [(int) FFS_EXPR].name = "ffs";
296 operator_name_info [(int) BIT_ANDTC_EXPR].name = "&~";
297 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&";
298 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||";
299 operator_name_info [(int) IN_EXPR].name = "in";
300 operator_name_info [(int) RANGE_EXPR].name = "...";
301 operator_name_info [(int) CONVERT_EXPR].name = "+";
303 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name
305 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name
307 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name
309 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name
311 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name
313 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name
315 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name
319 /* The reserved keyword table. */
322 const char *const word;
323 const ENUM_BITFIELD(rid) rid : 16;
324 const unsigned int disable : 16;
327 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
329 #define D_EXT 0x01 /* GCC extension */
330 #define D_ASM 0x02 /* in C99, but has a switch to turn it off */
331 #define D_OPNAME 0x04 /* operator names */
333 CONSTRAINT(ridbits_fit, RID_LAST_MODIFIER < sizeof(unsigned long) * CHAR_BIT);
335 static const struct resword reswords[] =
337 { "_Complex", RID_COMPLEX, 0 },
338 { "__FUNCTION__", RID_FUNCTION_NAME, 0 },
339 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
340 { "__alignof", RID_ALIGNOF, 0 },
341 { "__alignof__", RID_ALIGNOF, 0 },
342 { "__asm", RID_ASM, 0 },
343 { "__asm__", RID_ASM, 0 },
344 { "__attribute", RID_ATTRIBUTE, 0 },
345 { "__attribute__", RID_ATTRIBUTE, 0 },
346 { "__builtin_va_arg", RID_VA_ARG, 0 },
347 { "__complex", RID_COMPLEX, 0 },
348 { "__complex__", RID_COMPLEX, 0 },
349 { "__const", RID_CONST, 0 },
350 { "__const__", RID_CONST, 0 },
351 { "__extension__", RID_EXTENSION, 0 },
352 { "__func__", RID_C99_FUNCTION_NAME, 0 },
353 { "__imag", RID_IMAGPART, 0 },
354 { "__imag__", RID_IMAGPART, 0 },
355 { "__inline", RID_INLINE, 0 },
356 { "__inline__", RID_INLINE, 0 },
357 { "__label__", RID_LABEL, 0 },
358 { "__null", RID_NULL, 0 },
359 { "__real", RID_REALPART, 0 },
360 { "__real__", RID_REALPART, 0 },
361 { "__restrict", RID_RESTRICT, 0 },
362 { "__restrict__", RID_RESTRICT, 0 },
363 { "__signed", RID_SIGNED, 0 },
364 { "__signed__", RID_SIGNED, 0 },
365 { "__thread", RID_THREAD, 0 },
366 { "__typeof", RID_TYPEOF, 0 },
367 { "__typeof__", RID_TYPEOF, 0 },
368 { "__volatile", RID_VOLATILE, 0 },
369 { "__volatile__", RID_VOLATILE, 0 },
370 { "asm", RID_ASM, D_ASM },
371 { "and", RID_AND, D_OPNAME },
372 { "and_eq", RID_AND_EQ, D_OPNAME },
373 { "auto", RID_AUTO, 0 },
374 { "bitand", RID_BITAND, D_OPNAME },
375 { "bitor", RID_BITOR, D_OPNAME },
376 { "bool", RID_BOOL, 0 },
377 { "break", RID_BREAK, 0 },
378 { "case", RID_CASE, 0 },
379 { "catch", RID_CATCH, 0 },
380 { "char", RID_CHAR, 0 },
381 { "class", RID_CLASS, 0 },
382 { "compl", RID_COMPL, D_OPNAME },
383 { "const", RID_CONST, 0 },
384 { "const_cast", RID_CONSTCAST, 0 },
385 { "continue", RID_CONTINUE, 0 },
386 { "default", RID_DEFAULT, 0 },
387 { "delete", RID_DELETE, 0 },
389 { "double", RID_DOUBLE, 0 },
390 { "dynamic_cast", RID_DYNCAST, 0 },
391 { "else", RID_ELSE, 0 },
392 { "enum", RID_ENUM, 0 },
393 { "explicit", RID_EXPLICIT, 0 },
394 { "export", RID_EXPORT, 0 },
395 { "extern", RID_EXTERN, 0 },
396 { "false", RID_FALSE, 0 },
397 { "float", RID_FLOAT, 0 },
398 { "for", RID_FOR, 0 },
399 { "friend", RID_FRIEND, 0 },
400 { "goto", RID_GOTO, 0 },
402 { "inline", RID_INLINE, 0 },
403 { "int", RID_INT, 0 },
404 { "long", RID_LONG, 0 },
405 { "mutable", RID_MUTABLE, 0 },
406 { "namespace", RID_NAMESPACE, 0 },
407 { "new", RID_NEW, 0 },
408 { "not", RID_NOT, D_OPNAME },
409 { "not_eq", RID_NOT_EQ, D_OPNAME },
410 { "operator", RID_OPERATOR, 0 },
411 { "or", RID_OR, D_OPNAME },
412 { "or_eq", RID_OR_EQ, D_OPNAME },
413 { "private", RID_PRIVATE, 0 },
414 { "protected", RID_PROTECTED, 0 },
415 { "public", RID_PUBLIC, 0 },
416 { "register", RID_REGISTER, 0 },
417 { "reinterpret_cast", RID_REINTCAST, 0 },
418 { "return", RID_RETURN, 0 },
419 { "short", RID_SHORT, 0 },
420 { "signed", RID_SIGNED, 0 },
421 { "sizeof", RID_SIZEOF, 0 },
422 { "static", RID_STATIC, 0 },
423 { "static_cast", RID_STATCAST, 0 },
424 { "struct", RID_STRUCT, 0 },
425 { "switch", RID_SWITCH, 0 },
426 { "template", RID_TEMPLATE, 0 },
427 { "this", RID_THIS, 0 },
428 { "throw", RID_THROW, 0 },
429 { "true", RID_TRUE, 0 },
430 { "try", RID_TRY, 0 },
431 { "typedef", RID_TYPEDEF, 0 },
432 { "typename", RID_TYPENAME, 0 },
433 { "typeid", RID_TYPEID, 0 },
434 { "typeof", RID_TYPEOF, D_ASM|D_EXT },
435 { "union", RID_UNION, 0 },
436 { "unsigned", RID_UNSIGNED, 0 },
437 { "using", RID_USING, 0 },
438 { "virtual", RID_VIRTUAL, 0 },
439 { "void", RID_VOID, 0 },
440 { "volatile", RID_VOLATILE, 0 },
441 { "wchar_t", RID_WCHAR, 0 },
442 { "while", RID_WHILE, 0 },
443 { "xor", RID_XOR, D_OPNAME },
444 { "xor_eq", RID_XOR_EQ, D_OPNAME },
448 /* Table mapping from RID_* constants to yacc token numbers.
449 Unfortunately we have to have entries for all the keywords in all
451 const short rid_to_yy[RID_MAX] =
453 /* RID_STATIC */ SCSPEC,
454 /* RID_UNSIGNED */ TYPESPEC,
455 /* RID_LONG */ TYPESPEC,
456 /* RID_CONST */ CV_QUALIFIER,
457 /* RID_EXTERN */ SCSPEC,
458 /* RID_REGISTER */ SCSPEC,
459 /* RID_TYPEDEF */ SCSPEC,
460 /* RID_SHORT */ TYPESPEC,
461 /* RID_INLINE */ SCSPEC,
462 /* RID_VOLATILE */ CV_QUALIFIER,
463 /* RID_SIGNED */ TYPESPEC,
464 /* RID_AUTO */ SCSPEC,
465 /* RID_RESTRICT */ CV_QUALIFIER,
467 /* C extensions. Bounded pointers are not yet in C++ */
469 /* RID_UNBOUNDED */ 0,
470 /* RID_COMPLEX */ TYPESPEC,
471 /* RID_THREAD */ SCSPEC,
474 /* RID_FRIEND */ SCSPEC,
475 /* RID_VIRTUAL */ SCSPEC,
476 /* RID_EXPLICIT */ SCSPEC,
477 /* RID_EXPORT */ EXPORT,
478 /* RID_MUTABLE */ SCSPEC,
489 /* RID_INT */ TYPESPEC,
490 /* RID_CHAR */ TYPESPEC,
491 /* RID_FLOAT */ TYPESPEC,
492 /* RID_DOUBLE */ TYPESPEC,
493 /* RID_VOID */ TYPESPEC,
495 /* RID_STRUCT */ AGGR,
496 /* RID_UNION */ AGGR,
499 /* RID_WHILE */ WHILE,
502 /* RID_SWITCH */ SWITCH,
504 /* RID_DEFAULT */ DEFAULT,
505 /* RID_BREAK */ BREAK,
506 /* RID_CONTINUE */ CONTINUE,
507 /* RID_RETURN */ RETURN_KEYWORD,
509 /* RID_SIZEOF */ SIZEOF,
512 /* RID_ASM */ ASM_KEYWORD,
513 /* RID_TYPEOF */ TYPEOF,
514 /* RID_ALIGNOF */ ALIGNOF,
515 /* RID_ATTRIBUTE */ ATTRIBUTE,
516 /* RID_VA_ARG */ VA_ARG,
517 /* RID_EXTENSION */ EXTENSION,
518 /* RID_IMAGPART */ IMAGPART,
519 /* RID_REALPART */ REALPART,
520 /* RID_LABEL */ LABEL,
522 /* RID_PTREXTENT */ 0,
523 /* RID_PTRVALUE */ 0,
524 /* RID_CHOOSE_EXPR */ 0,
525 /* RID_TYPES_COMPATIBLE_P */ 0,
527 /* RID_FUNCTION_NAME */ VAR_FUNC_NAME,
528 /* RID_PRETTY_FUNCTION_NAME */ VAR_FUNC_NAME,
529 /* RID_c99_FUNCTION_NAME */ VAR_FUNC_NAME,
532 /* RID_BOOL */ TYPESPEC,
533 /* RID_WCHAR */ TYPESPEC,
534 /* RID_CLASS */ AGGR,
535 /* RID_PUBLIC */ VISSPEC,
536 /* RID_PRIVATE */ VISSPEC,
537 /* RID_PROTECTED */ VISSPEC,
538 /* RID_TEMPLATE */ TEMPLATE,
539 /* RID_NULL */ CONSTANT,
540 /* RID_CATCH */ CATCH,
541 /* RID_DELETE */ DELETE,
542 /* RID_FALSE */ CXX_FALSE,
543 /* RID_NAMESPACE */ NAMESPACE,
545 /* RID_OPERATOR */ OPERATOR,
547 /* RID_THROW */ THROW,
548 /* RID_TRUE */ CXX_TRUE,
550 /* RID_TYPENAME */ TYPENAME_KEYWORD,
551 /* RID_TYPEID */ TYPEID,
552 /* RID_USING */ USING,
555 /* RID_CONSTCAST */ CONST_CAST,
556 /* RID_DYNCAST */ DYNAMIC_CAST,
557 /* RID_REINTCAST */ REINTERPRET_CAST,
558 /* RID_STATCAST */ STATIC_CAST,
560 /* alternate spellings */
561 /* RID_AND */ ANDAND,
562 /* RID_AND_EQ */ ASSIGN,
564 /* RID_NOT_EQ */ EQCOMPARE,
566 /* RID_OR_EQ */ ASSIGN,
568 /* RID_XOR_EQ */ ASSIGN,
569 /* RID_BITAND */ '&',
575 /* RID_AT_ENCODE */ 0,
577 /* RID_AT_CLASS */ 0,
578 /* RID_AT_ALIAS */ 0,
580 /* RID_AT_PRIVATE */ 0,
581 /* RID_AT_PROTECTED */ 0,
582 /* RID_AT_PUBLIC */ 0,
583 /* RID_AT_PROTOCOL */ 0,
584 /* RID_AT_SELECTOR */ 0,
585 /* RID_AT_INTERFACE */ 0,
586 /* RID_AT_IMPLEMENTATION */ 0
594 int mask = ((flag_operator_names ? 0 : D_OPNAME)
595 | (flag_no_asm ? D_ASM : 0)
596 | (flag_no_gnu_keywords ? D_EXT : 0));
598 /* It is not necessary to register ridpointers as a GC root, because
599 all the trees it points to are permanently interned in the
600 get_identifier hash anyway. */
601 ridpointers = (tree *) xcalloc ((int) RID_MAX, sizeof (tree));
602 for (i = 0; i < ARRAY_SIZE (reswords); i++)
604 id = get_identifier (reswords[i].word);
605 C_RID_CODE (id) = reswords[i].rid;
606 ridpointers [(int) reswords[i].rid] = id;
607 if (! (reswords[i].disable & mask))
608 C_IS_RESERVED_WORD (id) = 1;
615 cpp_register_pragma (parse_in, 0, "vtable", handle_pragma_vtable);
616 cpp_register_pragma (parse_in, 0, "unit", handle_pragma_unit);
618 cpp_register_pragma (parse_in, 0, "interface", handle_pragma_interface);
619 cpp_register_pragma (parse_in, 0, "implementation",
620 handle_pragma_implementation);
622 cpp_register_pragma (parse_in, "GCC", "interface", handle_pragma_interface);
623 cpp_register_pragma (parse_in, "GCC", "implementation",
624 handle_pragma_implementation);
625 cpp_register_pragma (parse_in, "GCC", "java_exceptions",
626 handle_pragma_java_exceptions);
629 /* Initialize the C++ front end. This function is very sensitive to
630 the exact order that things are done here. It would be nice if the
631 initialization done by this routine were moved to its subroutines,
632 and the ordering dependencies clarified and reduced. */
635 const char *filename;
637 input_filename = "<internal>";
642 init_cp_semantics ();
647 current_function_decl = NULL;
649 class_type_node = build_int_2 (class_type, 0);
650 TREE_TYPE (class_type_node) = class_type_node;
651 ridpointers[(int) RID_CLASS] = class_type_node;
653 record_type_node = build_int_2 (record_type, 0);
654 TREE_TYPE (record_type_node) = record_type_node;
655 ridpointers[(int) RID_STRUCT] = record_type_node;
657 union_type_node = build_int_2 (union_type, 0);
658 TREE_TYPE (union_type_node) = union_type_node;
659 ridpointers[(int) RID_UNION] = union_type_node;
661 enum_type_node = build_int_2 (enum_type, 0);
662 TREE_TYPE (enum_type_node) = enum_type_node;
663 ridpointers[(int) RID_ENUM] = enum_type_node;
665 cxx_init_decl_processing ();
667 /* Create the built-in __null node. */
668 null_node = build_int_2 (0, 0);
669 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
670 ridpointers[RID_NULL] = null_node;
672 token_count = init_cpp_parse ();
673 interface_unknown = 1;
675 filename = c_common_init (filename);
676 if (filename == NULL)
681 init_repo (filename);
687 yyprint (file, yychar, yylval)
700 case IDENTIFIER_DEFN:
704 case PRE_PARSED_CLASS_DECL:
706 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
708 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
711 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
712 if (IDENTIFIER_POINTER (t))
713 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
717 if (yylval.ttype == class_type_node)
718 fprintf (file, " `class'");
719 else if (yylval.ttype == record_type_node)
720 fprintf (file, " `struct'");
721 else if (yylval.ttype == union_type_node)
722 fprintf (file, " `union'");
723 else if (yylval.ttype == enum_type_node)
724 fprintf (file, " `enum'");
731 if (TREE_CODE (t) == INTEGER_CST)
733 #if HOST_BITS_PER_WIDE_INT == 64
734 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
737 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
744 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
750 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
755 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
756 static int *reduce_count;
762 #define REDUCE_LENGTH ARRAY_SIZE (yyr2)
763 #define TOKEN_LENGTH (256 + ARRAY_SIZE (yytname))
766 #ifdef GATHER_STATISTICS
772 reduce_count[yyn] += 1;
779 return reduce_count[*q] - reduce_count[*p];
786 return token_count[*q] - token_count[*p];
792 print_parse_statistics ()
794 #ifdef GATHER_STATISTICS
798 int maxlen = REDUCE_LENGTH;
801 if (reduce_count[-1] == 0)
804 if (TOKEN_LENGTH > REDUCE_LENGTH)
805 maxlen = TOKEN_LENGTH;
806 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
808 for (i = 0; i < TOKEN_LENGTH; i++)
810 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
811 for (i = 0; i < TOKEN_LENGTH; i++)
814 if (token_count[idx] == 0)
816 if (token_count[idx] < token_count[-1])
818 fprintf (stderr, "token %d, `%s', count = %d\n",
819 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
821 fprintf (stderr, "\n");
822 for (i = 0; i < REDUCE_LENGTH; i++)
824 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
825 for (i = 0; i < REDUCE_LENGTH; i++)
828 if (reduce_count[idx] == 0)
830 if (reduce_count[idx] < reduce_count[-1])
832 fprintf (stderr, "rule %d, line %d, count = %d\n",
833 idx, yyrline[idx], reduce_count[idx]);
835 fprintf (stderr, "\n");
841 /* Helper function to load global variables with interface
845 extract_interface_info ()
847 struct c_fileinfo *finfo = 0;
849 if (flag_alt_external_templates)
851 tree til = tinst_for_decl ();
854 finfo = get_fileinfo (TINST_FILE (til));
857 finfo = get_fileinfo (input_filename);
859 interface_only = finfo->interface_only;
860 interface_unknown = finfo->interface_unknown;
863 /* Return nonzero if S is not considered part of an
864 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
870 /* Set the interface/implementation bits for this scope. */
871 struct impl_files *ifiles;
874 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
876 const char *t1 = ifiles->filename;
879 if (*s1 != *t1 || *s1 == 0)
882 while (*s1 == *t1 && *s1 != 0)
889 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
890 if (strchr (s1, '.') || strchr (t1, '.'))
893 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
904 /* Heuristic to tell whether the user is missing a semicolon
905 after a struct or enum declaration. Emit an error message
906 if we know the user has blown it. */
909 check_for_missing_semicolon (type)
917 && yychar != IDENTIFIER
918 && yychar != TYPENAME
919 && yychar != CV_QUALIFIER
920 && yychar != SELFNAME)
921 || yychar == 0 /* EOF */)
923 if (TYPE_ANONYMOUS_P (type))
924 error ("semicolon missing after %s declaration",
925 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
927 error ("semicolon missing after declaration of `%T'", type);
928 shadow_tag (build_tree_list (0, type));
930 /* Could probably also hack cases where class { ... } f (); appears. */
935 note_got_semicolon (type)
940 if (CLASS_TYPE_P (type))
941 CLASSTYPE_GOT_SEMICOLON (type) = 1;
945 note_list_got_semicolon (declspecs)
950 for (link = declspecs; link; link = TREE_CHAIN (link))
952 tree type = TREE_VALUE (link);
953 if (type && TYPE_P (type))
954 note_got_semicolon (type);
960 /* Parse a #pragma whose sole argument is a string constant.
961 If OPT is true, the argument is optional. */
963 parse_strconst_pragma (name, opt)
974 if (c_lex (&x) != CPP_EOF)
975 warning ("junk at end of #pragma %s", name);
979 if (t == CPP_EOF && opt)
982 error ("invalid #pragma %s", name);
987 handle_pragma_vtable (dfile)
988 cpp_reader *dfile ATTRIBUTE_UNUSED;
990 parse_strconst_pragma ("vtable", 0);
991 sorry ("#pragma vtable no longer supported");
995 handle_pragma_unit (dfile)
996 cpp_reader *dfile ATTRIBUTE_UNUSED;
998 /* Validate syntax, but don't do anything. */
999 parse_strconst_pragma ("unit", 0);
1003 handle_pragma_interface (dfile)
1004 cpp_reader *dfile ATTRIBUTE_UNUSED;
1006 tree fname = parse_strconst_pragma ("interface", 1);
1007 struct c_fileinfo *finfo;
1008 const char *main_filename;
1010 if (fname == (tree)-1)
1012 else if (fname == 0)
1013 main_filename = lbasename (input_filename);
1015 main_filename = TREE_STRING_POINTER (fname);
1017 finfo = get_fileinfo (input_filename);
1019 if (impl_file_chain == 0)
1021 /* If this is zero at this point, then we are
1022 auto-implementing. */
1023 if (main_input_filename == 0)
1024 main_input_filename = input_filename;
1027 interface_only = interface_strcmp (main_filename);
1028 #ifdef MULTIPLE_SYMBOL_SPACES
1029 if (! interface_only)
1031 interface_unknown = 0;
1033 finfo->interface_only = interface_only;
1034 finfo->interface_unknown = interface_unknown;
1037 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1038 We used to only allow this at toplevel, but that restriction was buggy
1039 in older compilers and it seems reasonable to allow it in the headers
1040 themselves, too. It only needs to precede the matching #p interface.
1042 We don't touch interface_only or interface_unknown; the user must specify
1043 a matching #p interface for this to have any effect. */
1046 handle_pragma_implementation (dfile)
1047 cpp_reader *dfile ATTRIBUTE_UNUSED;
1049 tree fname = parse_strconst_pragma ("implementation", 1);
1050 const char *main_filename;
1051 struct impl_files *ifiles = impl_file_chain;
1053 if (fname == (tree)-1)
1058 if (main_input_filename)
1059 main_filename = main_input_filename;
1061 main_filename = input_filename;
1062 main_filename = lbasename (main_filename);
1066 main_filename = TREE_STRING_POINTER (fname);
1067 if (cpp_included (parse_in, main_filename))
1068 warning ("#pragma implementation for %s appears after file is included",
1072 for (; ifiles; ifiles = ifiles->next)
1074 if (! strcmp (ifiles->filename, main_filename))
1079 ifiles = (struct impl_files*) xmalloc (sizeof (struct impl_files));
1080 ifiles->filename = main_filename;
1081 ifiles->next = impl_file_chain;
1082 impl_file_chain = ifiles;
1086 /* Indicate that this file uses Java-personality exception handling. */
1088 handle_pragma_java_exceptions (dfile)
1089 cpp_reader *dfile ATTRIBUTE_UNUSED;
1092 if (c_lex (&x) != CPP_EOF)
1093 warning ("junk at end of #pragma GCC java_exceptions");
1095 choose_personality_routine (lang_java);
1099 do_pending_lang_change ()
1101 for (; pending_lang_change > 0; --pending_lang_change)
1102 push_lang_context (lang_name_c);
1103 for (; pending_lang_change < 0; ++pending_lang_change)
1104 pop_lang_context ();
1107 /* Return true if d is in a global scope. */
1114 switch (TREE_CODE (d))
1119 case OVERLOAD: d = OVL_FUNCTION (d); continue;
1120 case TREE_LIST: d = TREE_VALUE (d); continue;
1122 my_friendly_assert (DECL_P (d), 980629);
1124 return DECL_NAMESPACE_SCOPE_P (d);
1129 do_identifier (token, parsing, args)
1130 register tree token;
1135 int lexing = (parsing == 1);
1138 id = lookup_name (token, 0);
1142 if (lexing && id && TREE_DEPRECATED (id))
1143 warn_deprecated_use (id);
1145 /* Do Koenig lookup if appropriate (inside templates we build lookup
1146 expressions instead).
1148 [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
1149 finds the declaration of a class member function, the associated
1150 namespaces and classes are not considered. */
1152 if (args && !current_template_parms && (!id || is_global (id)))
1153 id = lookup_arg_dependent (token, id, args);
1155 /* Remember that this name has been used in the class definition, as per
1158 maybe_note_name_used_in_class (token, id);
1160 if (id == error_mark_node)
1162 /* lookup_name quietly returns error_mark_node if we're parsing,
1163 as we don't want to complain about an identifier that ends up
1164 being used as a declarator. So we call it again to get the error
1166 id = lookup_name (token, 0);
1167 return error_mark_node;
1170 if (!id || (TREE_CODE (id) == FUNCTION_DECL
1171 && DECL_ANTICIPATED (id)))
1173 if (current_template_parms)
1174 return build_min_nt (LOOKUP_EXPR, token);
1175 else if (IDENTIFIER_TYPENAME_P (token))
1176 /* A templated conversion operator might exist. */
1178 else if (IDENTIFIER_OPNAME_P (token))
1180 if (token != ansi_opname (ERROR_MARK))
1181 error ("`%D' not defined", token);
1182 id = error_mark_node;
1184 else if (current_function_decl == 0)
1186 error ("`%D' was not declared in this scope", token);
1187 id = error_mark_node;
1191 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
1192 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
1194 static int undeclared_variable_notice;
1196 error ("`%D' undeclared (first use this function)", token);
1198 if (! undeclared_variable_notice)
1200 error ("(Each undeclared identifier is reported only once for each function it appears in.)");
1201 undeclared_variable_notice = 1;
1204 id = error_mark_node;
1205 /* Prevent repeated error messages. */
1206 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
1207 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
1211 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
1213 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
1214 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
1215 && DECL_DEAD_FOR_LOCAL (shadowed))
1216 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
1218 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
1221 if (!DECL_ERROR_REPORTED (id))
1223 warning ("name lookup of `%s' changed",
1224 IDENTIFIER_POINTER (token));
1225 cp_warning_at (" matches this `%D' under ISO standard rules",
1227 cp_warning_at (" matches this `%D' under old rules", id);
1228 DECL_ERROR_REPORTED (id) = 1;
1232 else if (!DECL_ERROR_REPORTED (id))
1234 DECL_ERROR_REPORTED (id) = 1;
1235 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (id)))
1237 error ("name lookup of `%s' changed for new ISO `for' scoping",
1238 IDENTIFIER_POINTER (token));
1239 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
1240 id = error_mark_node;
1244 pedwarn ("name lookup of `%s' changed for new ISO `for' scoping",
1245 IDENTIFIER_POINTER (token));
1246 cp_pedwarn_at (" using obsolete binding at `%D'", id);
1250 /* TREE_USED is set in `hack_identifier'. */
1251 if (TREE_CODE (id) == CONST_DECL)
1254 if (IDENTIFIER_CLASS_VALUE (token) == id)
1255 enforce_access (CP_DECL_CONTEXT(id), id);
1256 if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
1257 id = DECL_INITIAL (id);
1260 id = hack_identifier (id, token);
1262 /* We must look up dependent names when the template is
1263 instantiated, not while parsing it. For now, we don't
1264 distinguish between dependent and independent names. So, for
1265 example, we look up all overloaded functions at
1266 instantiation-time, even though in some cases we should just use
1267 the DECL we have here. We also use LOOKUP_EXPRs to find things
1268 like local variables, rather than creating TEMPLATE_DECLs for the
1269 local variables and then finding matching instantiations. */
1270 if (current_template_parms
1271 && (is_overloaded_fn (id)
1272 || (TREE_CODE (id) == VAR_DECL
1273 && CP_DECL_CONTEXT (id)
1274 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
1275 || TREE_CODE (id) == PARM_DECL
1276 || TREE_CODE (id) == RESULT_DECL
1277 || TREE_CODE (id) == USING_DECL))
1278 id = build_min_nt (LOOKUP_EXPR, token);
1284 do_scoped_id (token, parsing)
1289 /* during parsing, this is ::name. Otherwise, it is black magic. */
1292 id = make_node (CPLUS_BINDING);
1293 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
1296 id = BINDING_VALUE (id);
1299 id = IDENTIFIER_GLOBAL_VALUE (token);
1300 if (parsing && yychar == YYEMPTY)
1302 if (!id || (TREE_CODE (id) == FUNCTION_DECL
1303 && DECL_ANTICIPATED (id)))
1305 if (processing_template_decl)
1307 id = build_min_nt (LOOKUP_EXPR, token);
1308 LOOKUP_EXPR_GLOBAL (id) = 1;
1311 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
1312 error ("`::%D' undeclared (first use here)", token);
1313 id = error_mark_node;
1314 /* Prevent repeated error messages. */
1315 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
1319 if (TREE_CODE (id) == ADDR_EXPR)
1320 mark_used (TREE_OPERAND (id, 0));
1321 else if (TREE_CODE (id) != OVERLOAD)
1324 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
1326 /* XXX CHS - should we set TREE_USED of the constant? */
1327 id = DECL_INITIAL (id);
1328 /* This is to prevent an enum whose value is 0
1329 from being considered a null pointer constant. */
1330 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
1331 TREE_CONSTANT (id) = 1;
1334 if (processing_template_decl)
1336 if (is_overloaded_fn (id))
1338 id = build_min_nt (LOOKUP_EXPR, token);
1339 LOOKUP_EXPR_GLOBAL (id) = 1;
1342 /* else just use the decl */
1344 return convert_from_reference (id);
1348 identifier_typedecl_value (node)
1352 type = IDENTIFIER_TYPE_VALUE (node);
1353 if (type == NULL_TREE)
1356 if (IDENTIFIER_BINDING (node))
1358 t = IDENTIFIER_VALUE (node);
1359 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
1362 if (IDENTIFIER_NAMESPACE_VALUE (node))
1364 t = IDENTIFIER_NAMESPACE_VALUE (node);
1365 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
1369 /* Will this one ever happen? */
1370 if (TYPE_MAIN_DECL (type))
1371 return TYPE_MAIN_DECL (type);
1373 /* We used to do an internal error of 62 here, but instead we will
1374 handle the return of a null appropriately in the callers. */
1378 #ifdef GATHER_STATISTICS
1379 /* The original for tree_node_kind is in the toplevel tree.c; changes there
1380 need to be brought into here, unless this were actually put into a header
1382 /* Statistics-gathering stuff. */
1403 extern int tree_node_counts[];
1404 extern int tree_node_sizes[];
1408 build_lang_decl (code, name, type)
1409 enum tree_code code;
1415 t = build_decl (code, name, type);
1416 retrofit_lang_decl (t);
1421 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
1422 and pushdecl (for functions generated by the backend). */
1425 retrofit_lang_decl (t)
1428 struct lang_decl *ld;
1431 if (CAN_HAVE_FULL_LANG_DECL_P (t))
1432 size = sizeof (struct lang_decl);
1434 size = sizeof (struct lang_decl_flags);
1436 ld = (struct lang_decl *) ggc_alloc_cleared (size);
1438 DECL_LANG_SPECIFIC (t) = ld;
1439 if (current_lang_name == lang_name_cplusplus)
1440 SET_DECL_LANGUAGE (t, lang_cplusplus);
1441 else if (current_lang_name == lang_name_c)
1442 SET_DECL_LANGUAGE (t, lang_c);
1443 else if (current_lang_name == lang_name_java)
1444 SET_DECL_LANGUAGE (t, lang_java);
1447 #ifdef GATHER_STATISTICS
1448 tree_node_counts[(int)lang_decl] += 1;
1449 tree_node_sizes[(int)lang_decl] += size;
1454 cxx_dup_lang_specific_decl (node)
1458 struct lang_decl *ld;
1460 if (! DECL_LANG_SPECIFIC (node))
1463 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
1464 size = sizeof (struct lang_decl_flags);
1466 size = sizeof (struct lang_decl);
1467 ld = (struct lang_decl *) ggc_alloc (size);
1468 memcpy (ld, DECL_LANG_SPECIFIC (node), size);
1469 DECL_LANG_SPECIFIC (node) = ld;
1471 #ifdef GATHER_STATISTICS
1472 tree_node_counts[(int)lang_decl] += 1;
1473 tree_node_sizes[(int)lang_decl] += size;
1477 /* Copy DECL, including any language-specific parts. */
1485 copy = copy_node (decl);
1486 cxx_dup_lang_specific_decl (copy);
1490 /* Replace the shared language-specific parts of NODE with a new copy. */
1493 copy_lang_type (node)
1497 struct lang_type *lt;
1499 if (! TYPE_LANG_SPECIFIC (node))
1502 size = sizeof (struct lang_type);
1503 lt = (struct lang_type *) ggc_alloc (size);
1504 memcpy (lt, TYPE_LANG_SPECIFIC (node), size);
1505 TYPE_LANG_SPECIFIC (node) = lt;
1507 #ifdef GATHER_STATISTICS
1508 tree_node_counts[(int)lang_type] += 1;
1509 tree_node_sizes[(int)lang_type] += size;
1513 /* Copy TYPE, including any language-specific parts. */
1521 copy = copy_node (type);
1522 copy_lang_type (copy);
1527 cxx_make_type (code)
1528 enum tree_code code;
1530 register tree t = make_node (code);
1532 /* Create lang_type structure. */
1533 if (IS_AGGR_TYPE_CODE (code)
1534 || code == BOUND_TEMPLATE_TEMPLATE_PARM)
1536 struct lang_type *pi;
1538 pi = ((struct lang_type *)
1539 ggc_alloc_cleared (sizeof (struct lang_type)));
1541 TYPE_LANG_SPECIFIC (t) = pi;
1543 #ifdef GATHER_STATISTICS
1544 tree_node_counts[(int)lang_type] += 1;
1545 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1549 /* Set up some flags that give proper default behavior. */
1550 if (IS_AGGR_TYPE_CODE (code))
1552 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
1553 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
1555 /* Make sure this is laid out, for ease of use later. In the
1556 presence of parse errors, the normal was of assuring this
1557 might not ever get executed, so we lay it out *immediately*. */
1558 build_pointer_type (t);
1561 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
1562 TYPE_ALIAS_SET is initialized to -1 by default, so we must
1564 TYPE_ALIAS_SET (t) = 0;
1566 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1567 since they can be virtual base types, and we then need a
1568 canonical binfo for them. Ideally, this would be done lazily for
1570 if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM
1571 || code == BOUND_TEMPLATE_TEMPLATE_PARM
1572 || code == TYPENAME_TYPE)
1573 TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
1579 make_aggr_type (code)
1580 enum tree_code code;
1582 tree t = cxx_make_type (code);
1584 if (IS_AGGR_TYPE_CODE (code))
1585 SET_IS_AGGR_TYPE (t, 1);
1591 compiler_error VPARAMS ((const char *msg, ...))
1596 VA_FIXEDARG (ap, const char *, msg);
1598 vsprintf (buf, msg, ap);
1601 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
1604 /* Return the type-qualifier corresponding to the identifier given by
1608 cp_type_qual_from_rid (rid)
1611 if (rid == ridpointers[(int) RID_CONST])
1612 return TYPE_QUAL_CONST;
1613 else if (rid == ridpointers[(int) RID_VOLATILE])
1614 return TYPE_QUAL_VOLATILE;
1615 else if (rid == ridpointers[(int) RID_RESTRICT])
1616 return TYPE_QUAL_RESTRICT;
1619 return TYPE_UNQUALIFIED;