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++. */
41 #include "diagnostic.h"
43 #ifdef MULTIBYTE_CHARS
48 extern void yyprint
PARAMS ((FILE *, int, YYSTYPE
));
50 static int interface_strcmp
PARAMS ((const char *));
51 static int *init_cpp_parse
PARAMS ((void));
52 static void init_cp_pragma
PARAMS ((void));
54 static tree parse_strconst_pragma
PARAMS ((const char *, int));
55 static void handle_pragma_vtable
PARAMS ((cpp_reader
*));
56 static void handle_pragma_unit
PARAMS ((cpp_reader
*));
57 static void handle_pragma_interface
PARAMS ((cpp_reader
*));
58 static void handle_pragma_implementation
PARAMS ((cpp_reader
*));
59 static void handle_pragma_java_exceptions
PARAMS ((cpp_reader
*));
61 #ifdef GATHER_STATISTICS
63 static int reduce_cmp
PARAMS ((int *, int *));
64 static int token_cmp
PARAMS ((int *, int *));
67 static int is_global
PARAMS ((tree
));
68 static void init_operators
PARAMS ((void));
69 static void copy_lang_type
PARAMS ((tree
));
71 /* A constraint that can be tested at compile time. */
73 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
75 #define CONSTRAINT(name, expr) extern int constraint_/**/name [(expr) ? 1 : -1]
80 extern int yychar
; /* the lookahead symbol */
81 extern YYSTYPE yylval
; /* the semantic value of the */
82 /* lookahead symbol */
84 /* the declaration found for the last IDENTIFIER token read in. yylex
85 must look this up to detect typedefs, which get token type
86 tTYPENAME, so it is left around in case the identifier is not a
87 typedef but is used in a context which makes it a reference to a
91 /* Array for holding counts of the numbers of tokens seen. */
92 extern int *token_count
;
94 /* Functions and data structures for #pragma interface.
96 `#pragma implementation' means that the main file being compiled
97 is considered to implement (provide) the classes that appear in
98 its main body. I.e., if this is file "foo.cc", and class `bar'
99 is defined in "foo.cc", then we say that "foo.cc implements bar".
101 All main input files "implement" themselves automagically.
103 `#pragma interface' means that unless this file (of the form "foo.h"
104 is not presently being included by file "foo.cc", the
105 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
106 of the vtables nor any of the inline functions defined in foo.h
109 There are cases when we want to link files such as "defs.h" and
110 "main.cc". In this case, we give "defs.h" a `#pragma interface',
111 and "main.cc" has `#pragma implementation "defs.h"'. */
115 const char *filename
;
116 struct impl_files
*next
;
119 static struct impl_files
*impl_file_chain
;
122 /* Return something to represent absolute declarators containing a *.
123 TARGET is the absolute declarator that the * contains.
124 CV_QUALIFIERS is a list of modifiers such as const or volatile
125 to apply to the pointer type, represented as identifiers.
127 We return an INDIRECT_REF whose "contents" are TARGET
128 and whose type is the modifier list. */
131 make_pointer_declarator (cv_qualifiers
, target
)
132 tree cv_qualifiers
, target
;
134 if (target
&& TREE_CODE (target
) == IDENTIFIER_NODE
135 && ANON_AGGRNAME_P (target
))
136 error ("type name expected before `*'");
137 target
= build_nt (INDIRECT_REF
, target
);
138 TREE_TYPE (target
) = cv_qualifiers
;
142 /* Return something to represent absolute declarators containing a &.
143 TARGET is the absolute declarator that the & contains.
144 CV_QUALIFIERS is a list of modifiers such as const or volatile
145 to apply to the reference type, represented as identifiers.
147 We return an ADDR_EXPR whose "contents" are TARGET
148 and whose type is the modifier list. */
151 make_reference_declarator (cv_qualifiers
, target
)
152 tree cv_qualifiers
, target
;
156 if (TREE_CODE (target
) == ADDR_EXPR
)
158 error ("cannot declare references to references");
161 if (TREE_CODE (target
) == INDIRECT_REF
)
163 error ("cannot declare pointers to references");
166 if (TREE_CODE (target
) == IDENTIFIER_NODE
&& ANON_AGGRNAME_P (target
))
167 error ("type name expected before `&'");
169 target
= build_nt (ADDR_EXPR
, target
);
170 TREE_TYPE (target
) = cv_qualifiers
;
175 make_call_declarator (target
, parms
, cv_qualifiers
, exception_specification
)
176 tree target
, parms
, cv_qualifiers
, exception_specification
;
178 target
= build_nt (CALL_EXPR
, target
,
179 tree_cons (parms
, cv_qualifiers
, NULL_TREE
),
180 /* The third operand is really RTL. We
181 shouldn't put anything there. */
183 CALL_DECLARATOR_EXCEPTION_SPEC (target
) = exception_specification
;
188 set_quals_and_spec (call_declarator
, cv_qualifiers
, exception_specification
)
189 tree call_declarator
, cv_qualifiers
, exception_specification
;
191 CALL_DECLARATOR_QUALS (call_declarator
) = cv_qualifiers
;
192 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator
) = exception_specification
;
195 int interface_only
; /* whether or not current file is only for
196 interface definitions. */
197 int interface_unknown
; /* whether or not we know this class
198 to behave according to #pragma interface. */
201 /* Initialization before switch parsing. */
205 c_common_init_options (clk_cplusplus
);
207 /* Default exceptions on. */
209 /* By default wrap lines at 80 characters. Is getenv ("COLUMNS")
211 diagnostic_line_cutoff (global_dc
) = 80;
212 /* By default, emit location information once for every
213 diagnostic message. */
214 diagnostic_prefixing_rule (global_dc
) = DIAGNOSTICS_SHOW_PREFIX_ONCE
;
226 #ifdef GATHER_STATISTICS
228 reduce_count
= (int *) xcalloc (sizeof (int), (REDUCE_LENGTH
+ 1));
230 token_count
= (int *) xcalloc (sizeof (int), (TOKEN_LENGTH
+ 1));
237 /* A mapping from tree codes to operator name information. */
238 operator_name_info_t operator_name_info
[(int) LAST_CPLUS_TREE_CODE
];
239 /* Similar, but for assignment operators. */
240 operator_name_info_t assignment_operator_name_info
[(int) LAST_CPLUS_TREE_CODE
];
242 /* Initialize data structures that keep track of operator names. */
244 #define DEF_OPERATOR(NAME, C, M, AR, AP) \
245 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
246 #include "operators.def"
254 struct operator_name_info_t
*oni
;
256 #define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \
257 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
258 identifier = get_identifier (buffer); \
259 IDENTIFIER_OPNAME_P (identifier) = 1; \
262 ? &assignment_operator_name_info[(int) CODE] \
263 : &operator_name_info[(int) CODE]); \
264 oni->identifier = identifier; \
266 oni->mangled_name = MANGLING; \
269 #include "operators.def"
272 operator_name_info
[(int) ERROR_MARK
].identifier
273 = get_identifier ("<invalid operator>");
275 /* Handle some special cases. These operators are not defined in
276 the language, but can be produced internally. We may need them
277 for error-reporting. (Eventually, we should ensure that this
278 does not happen. Error messages involving these operators will
279 be confusing to users.) */
281 operator_name_info
[(int) INIT_EXPR
].name
282 = operator_name_info
[(int) MODIFY_EXPR
].name
;
283 operator_name_info
[(int) EXACT_DIV_EXPR
].name
= "(ceiling /)";
284 operator_name_info
[(int) CEIL_DIV_EXPR
].name
= "(ceiling /)";
285 operator_name_info
[(int) FLOOR_DIV_EXPR
].name
= "(floor /)";
286 operator_name_info
[(int) ROUND_DIV_EXPR
].name
= "(round /)";
287 operator_name_info
[(int) CEIL_MOD_EXPR
].name
= "(ceiling %)";
288 operator_name_info
[(int) FLOOR_MOD_EXPR
].name
= "(floor %)";
289 operator_name_info
[(int) ROUND_MOD_EXPR
].name
= "(round %)";
290 operator_name_info
[(int) ABS_EXPR
].name
= "abs";
291 operator_name_info
[(int) FFS_EXPR
].name
= "ffs";
292 operator_name_info
[(int) BIT_ANDTC_EXPR
].name
= "&~";
293 operator_name_info
[(int) TRUTH_AND_EXPR
].name
= "strict &&";
294 operator_name_info
[(int) TRUTH_OR_EXPR
].name
= "strict ||";
295 operator_name_info
[(int) IN_EXPR
].name
= "in";
296 operator_name_info
[(int) RANGE_EXPR
].name
= "...";
297 operator_name_info
[(int) CONVERT_EXPR
].name
= "+";
299 assignment_operator_name_info
[(int) EXACT_DIV_EXPR
].name
301 assignment_operator_name_info
[(int) CEIL_DIV_EXPR
].name
303 assignment_operator_name_info
[(int) FLOOR_DIV_EXPR
].name
305 assignment_operator_name_info
[(int) ROUND_DIV_EXPR
].name
307 assignment_operator_name_info
[(int) CEIL_MOD_EXPR
].name
309 assignment_operator_name_info
[(int) FLOOR_MOD_EXPR
].name
311 assignment_operator_name_info
[(int) ROUND_MOD_EXPR
].name
315 /* The reserved keyword table. */
318 const char *const word
;
319 const ENUM_BITFIELD(rid
) rid
: 16;
320 const unsigned int disable
: 16;
323 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
325 #define D_EXT 0x01 /* GCC extension */
326 #define D_ASM 0x02 /* in C99, but has a switch to turn it off */
328 CONSTRAINT(ridbits_fit
, RID_LAST_MODIFIER
< sizeof(unsigned long) * CHAR_BIT
);
330 static const struct resword reswords
[] =
332 { "_Complex", RID_COMPLEX
, 0 },
333 { "__FUNCTION__", RID_FUNCTION_NAME
, 0 },
334 { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME
, 0 },
335 { "__alignof", RID_ALIGNOF
, 0 },
336 { "__alignof__", RID_ALIGNOF
, 0 },
337 { "__asm", RID_ASM
, 0 },
338 { "__asm__", RID_ASM
, 0 },
339 { "__attribute", RID_ATTRIBUTE
, 0 },
340 { "__attribute__", RID_ATTRIBUTE
, 0 },
341 { "__builtin_va_arg", RID_VA_ARG
, 0 },
342 { "__complex", RID_COMPLEX
, 0 },
343 { "__complex__", RID_COMPLEX
, 0 },
344 { "__const", RID_CONST
, 0 },
345 { "__const__", RID_CONST
, 0 },
346 { "__extension__", RID_EXTENSION
, 0 },
347 { "__func__", RID_C99_FUNCTION_NAME
, 0 },
348 { "__imag", RID_IMAGPART
, 0 },
349 { "__imag__", RID_IMAGPART
, 0 },
350 { "__inline", RID_INLINE
, 0 },
351 { "__inline__", RID_INLINE
, 0 },
352 { "__label__", RID_LABEL
, 0 },
353 { "__null", RID_NULL
, 0 },
354 { "__real", RID_REALPART
, 0 },
355 { "__real__", RID_REALPART
, 0 },
356 { "__restrict", RID_RESTRICT
, 0 },
357 { "__restrict__", RID_RESTRICT
, 0 },
358 { "__signed", RID_SIGNED
, 0 },
359 { "__signed__", RID_SIGNED
, 0 },
360 { "__thread", RID_THREAD
, 0 },
361 { "__typeof", RID_TYPEOF
, 0 },
362 { "__typeof__", RID_TYPEOF
, 0 },
363 { "__volatile", RID_VOLATILE
, 0 },
364 { "__volatile__", RID_VOLATILE
, 0 },
365 { "asm", RID_ASM
, D_ASM
},
366 { "auto", RID_AUTO
, 0 },
367 { "bool", RID_BOOL
, 0 },
368 { "break", RID_BREAK
, 0 },
369 { "case", RID_CASE
, 0 },
370 { "catch", RID_CATCH
, 0 },
371 { "char", RID_CHAR
, 0 },
372 { "class", RID_CLASS
, 0 },
373 { "const", RID_CONST
, 0 },
374 { "const_cast", RID_CONSTCAST
, 0 },
375 { "continue", RID_CONTINUE
, 0 },
376 { "default", RID_DEFAULT
, 0 },
377 { "delete", RID_DELETE
, 0 },
379 { "double", RID_DOUBLE
, 0 },
380 { "dynamic_cast", RID_DYNCAST
, 0 },
381 { "else", RID_ELSE
, 0 },
382 { "enum", RID_ENUM
, 0 },
383 { "explicit", RID_EXPLICIT
, 0 },
384 { "export", RID_EXPORT
, 0 },
385 { "extern", RID_EXTERN
, 0 },
386 { "false", RID_FALSE
, 0 },
387 { "float", RID_FLOAT
, 0 },
388 { "for", RID_FOR
, 0 },
389 { "friend", RID_FRIEND
, 0 },
390 { "goto", RID_GOTO
, 0 },
392 { "inline", RID_INLINE
, 0 },
393 { "int", RID_INT
, 0 },
394 { "long", RID_LONG
, 0 },
395 { "mutable", RID_MUTABLE
, 0 },
396 { "namespace", RID_NAMESPACE
, 0 },
397 { "new", RID_NEW
, 0 },
398 { "operator", RID_OPERATOR
, 0 },
399 { "private", RID_PRIVATE
, 0 },
400 { "protected", RID_PROTECTED
, 0 },
401 { "public", RID_PUBLIC
, 0 },
402 { "register", RID_REGISTER
, 0 },
403 { "reinterpret_cast", RID_REINTCAST
, 0 },
404 { "return", RID_RETURN
, 0 },
405 { "short", RID_SHORT
, 0 },
406 { "signed", RID_SIGNED
, 0 },
407 { "sizeof", RID_SIZEOF
, 0 },
408 { "static", RID_STATIC
, 0 },
409 { "static_cast", RID_STATCAST
, 0 },
410 { "struct", RID_STRUCT
, 0 },
411 { "switch", RID_SWITCH
, 0 },
412 { "template", RID_TEMPLATE
, 0 },
413 { "this", RID_THIS
, 0 },
414 { "throw", RID_THROW
, 0 },
415 { "true", RID_TRUE
, 0 },
416 { "try", RID_TRY
, 0 },
417 { "typedef", RID_TYPEDEF
, 0 },
418 { "typename", RID_TYPENAME
, 0 },
419 { "typeid", RID_TYPEID
, 0 },
420 { "typeof", RID_TYPEOF
, D_ASM
|D_EXT
},
421 { "union", RID_UNION
, 0 },
422 { "unsigned", RID_UNSIGNED
, 0 },
423 { "using", RID_USING
, 0 },
424 { "virtual", RID_VIRTUAL
, 0 },
425 { "void", RID_VOID
, 0 },
426 { "volatile", RID_VOLATILE
, 0 },
427 { "wchar_t", RID_WCHAR
, 0 },
428 { "while", RID_WHILE
, 0 },
432 /* Table mapping from RID_* constants to yacc token numbers.
433 Unfortunately we have to have entries for all the keywords in all
435 const short rid_to_yy
[RID_MAX
] =
437 /* RID_STATIC */ SCSPEC
,
438 /* RID_UNSIGNED */ TYPESPEC
,
439 /* RID_LONG */ TYPESPEC
,
440 /* RID_CONST */ CV_QUALIFIER
,
441 /* RID_EXTERN */ SCSPEC
,
442 /* RID_REGISTER */ SCSPEC
,
443 /* RID_TYPEDEF */ SCSPEC
,
444 /* RID_SHORT */ TYPESPEC
,
445 /* RID_INLINE */ SCSPEC
,
446 /* RID_VOLATILE */ CV_QUALIFIER
,
447 /* RID_SIGNED */ TYPESPEC
,
448 /* RID_AUTO */ SCSPEC
,
449 /* RID_RESTRICT */ CV_QUALIFIER
,
451 /* C extensions. Bounded pointers are not yet in C++ */
453 /* RID_UNBOUNDED */ 0,
454 /* RID_COMPLEX */ TYPESPEC
,
455 /* RID_THREAD */ SCSPEC
,
458 /* RID_FRIEND */ SCSPEC
,
459 /* RID_VIRTUAL */ SCSPEC
,
460 /* RID_EXPLICIT */ SCSPEC
,
461 /* RID_EXPORT */ EXPORT
,
462 /* RID_MUTABLE */ SCSPEC
,
473 /* RID_INT */ TYPESPEC
,
474 /* RID_CHAR */ TYPESPEC
,
475 /* RID_FLOAT */ TYPESPEC
,
476 /* RID_DOUBLE */ TYPESPEC
,
477 /* RID_VOID */ TYPESPEC
,
479 /* RID_STRUCT */ AGGR
,
480 /* RID_UNION */ AGGR
,
483 /* RID_WHILE */ WHILE
,
486 /* RID_SWITCH */ SWITCH
,
488 /* RID_DEFAULT */ DEFAULT
,
489 /* RID_BREAK */ BREAK
,
490 /* RID_CONTINUE */ CONTINUE
,
491 /* RID_RETURN */ RETURN_KEYWORD
,
493 /* RID_SIZEOF */ SIZEOF
,
496 /* RID_ASM */ ASM_KEYWORD
,
497 /* RID_TYPEOF */ TYPEOF
,
498 /* RID_ALIGNOF */ ALIGNOF
,
499 /* RID_ATTRIBUTE */ ATTRIBUTE
,
500 /* RID_VA_ARG */ VA_ARG
,
501 /* RID_EXTENSION */ EXTENSION
,
502 /* RID_IMAGPART */ IMAGPART
,
503 /* RID_REALPART */ REALPART
,
504 /* RID_LABEL */ LABEL
,
506 /* RID_PTREXTENT */ 0,
507 /* RID_PTRVALUE */ 0,
508 /* RID_CHOOSE_EXPR */ 0,
509 /* RID_TYPES_COMPATIBLE_P */ 0,
511 /* RID_FUNCTION_NAME */ VAR_FUNC_NAME
,
512 /* RID_PRETTY_FUNCTION_NAME */ VAR_FUNC_NAME
,
513 /* RID_c99_FUNCTION_NAME */ VAR_FUNC_NAME
,
516 /* RID_BOOL */ TYPESPEC
,
517 /* RID_WCHAR */ TYPESPEC
,
518 /* RID_CLASS */ AGGR
,
519 /* RID_PUBLIC */ VISSPEC
,
520 /* RID_PRIVATE */ VISSPEC
,
521 /* RID_PROTECTED */ VISSPEC
,
522 /* RID_TEMPLATE */ TEMPLATE
,
523 /* RID_NULL */ CONSTANT
,
524 /* RID_CATCH */ CATCH
,
525 /* RID_DELETE */ DELETE
,
526 /* RID_FALSE */ CXX_FALSE
,
527 /* RID_NAMESPACE */ NAMESPACE
,
529 /* RID_OPERATOR */ OPERATOR
,
531 /* RID_THROW */ THROW
,
532 /* RID_TRUE */ CXX_TRUE
,
534 /* RID_TYPENAME */ TYPENAME_KEYWORD
,
535 /* RID_TYPEID */ TYPEID
,
536 /* RID_USING */ USING
,
539 /* RID_CONSTCAST */ CONST_CAST
,
540 /* RID_DYNCAST */ DYNAMIC_CAST
,
541 /* RID_REINTCAST */ REINTERPRET_CAST
,
542 /* RID_STATCAST */ STATIC_CAST
,
546 /* RID_AT_ENCODE */ 0,
548 /* RID_AT_CLASS */ 0,
549 /* RID_AT_ALIAS */ 0,
551 /* RID_AT_PRIVATE */ 0,
552 /* RID_AT_PROTECTED */ 0,
553 /* RID_AT_PUBLIC */ 0,
554 /* RID_AT_PROTOCOL */ 0,
555 /* RID_AT_SELECTOR */ 0,
556 /* RID_AT_INTERFACE */ 0,
557 /* RID_AT_IMPLEMENTATION */ 0
565 int mask
= ((flag_no_asm
? D_ASM
: 0)
566 | (flag_no_gnu_keywords
? D_EXT
: 0));
568 /* It is not necessary to register ridpointers as a GC root, because
569 all the trees it points to are permanently interned in the
570 get_identifier hash anyway. */
571 ridpointers
= (tree
*) xcalloc ((int) RID_MAX
, sizeof (tree
));
572 for (i
= 0; i
< ARRAY_SIZE (reswords
); i
++)
574 id
= get_identifier (reswords
[i
].word
);
575 C_RID_CODE (id
) = reswords
[i
].rid
;
576 ridpointers
[(int) reswords
[i
].rid
] = id
;
577 if (! (reswords
[i
].disable
& mask
))
578 C_IS_RESERVED_WORD (id
) = 1;
585 cpp_register_pragma (parse_in
, 0, "vtable", handle_pragma_vtable
);
586 cpp_register_pragma (parse_in
, 0, "unit", handle_pragma_unit
);
588 cpp_register_pragma (parse_in
, 0, "interface", handle_pragma_interface
);
589 cpp_register_pragma (parse_in
, 0, "implementation",
590 handle_pragma_implementation
);
592 cpp_register_pragma (parse_in
, "GCC", "interface", handle_pragma_interface
);
593 cpp_register_pragma (parse_in
, "GCC", "implementation",
594 handle_pragma_implementation
);
595 cpp_register_pragma (parse_in
, "GCC", "java_exceptions",
596 handle_pragma_java_exceptions
);
599 /* Initialize the C++ front end. This function is very sensitive to
600 the exact order that things are done here. It would be nice if the
601 initialization done by this routine were moved to its subroutines,
602 and the ordering dependencies clarified and reduced. */
605 const char *filename
;
607 input_filename
= "<internal>";
612 init_cp_semantics ();
617 current_function_decl
= NULL
;
619 class_type_node
= build_int_2 (class_type
, 0);
620 TREE_TYPE (class_type_node
) = class_type_node
;
621 ridpointers
[(int) RID_CLASS
] = class_type_node
;
623 record_type_node
= build_int_2 (record_type
, 0);
624 TREE_TYPE (record_type_node
) = record_type_node
;
625 ridpointers
[(int) RID_STRUCT
] = record_type_node
;
627 union_type_node
= build_int_2 (union_type
, 0);
628 TREE_TYPE (union_type_node
) = union_type_node
;
629 ridpointers
[(int) RID_UNION
] = union_type_node
;
631 enum_type_node
= build_int_2 (enum_type
, 0);
632 TREE_TYPE (enum_type_node
) = enum_type_node
;
633 ridpointers
[(int) RID_ENUM
] = enum_type_node
;
635 cxx_init_decl_processing ();
637 /* Create the built-in __null node. */
638 null_node
= build_int_2 (0, 0);
639 TREE_TYPE (null_node
) = c_common_type_for_size (POINTER_SIZE
, 0);
640 ridpointers
[RID_NULL
] = null_node
;
642 token_count
= init_cpp_parse ();
643 interface_unknown
= 1;
645 filename
= c_common_init (filename
);
646 if (filename
== NULL
)
651 init_repo (filename
);
657 yyprint (file
, yychar
, yylval
)
670 case IDENTIFIER_DEFN
:
674 case PRE_PARSED_CLASS_DECL
:
676 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == TEMPLATE_DECL
)
678 fprintf (file
, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t
)));
681 my_friendly_assert (TREE_CODE (t
) == IDENTIFIER_NODE
, 224);
682 if (IDENTIFIER_POINTER (t
))
683 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
687 if (yylval
.ttype
== class_type_node
)
688 fprintf (file
, " `class'");
689 else if (yylval
.ttype
== record_type_node
)
690 fprintf (file
, " `struct'");
691 else if (yylval
.ttype
== union_type_node
)
692 fprintf (file
, " `union'");
693 else if (yylval
.ttype
== enum_type_node
)
694 fprintf (file
, " `enum'");
701 if (TREE_CODE (t
) == INTEGER_CST
)
703 #if HOST_BITS_PER_WIDE_INT == 64
704 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
707 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
714 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
720 TREE_INT_CST_HIGH (t
), TREE_INT_CST_LOW (t
));
725 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
726 static int *reduce_count
;
732 #define REDUCE_LENGTH ARRAY_SIZE (yyr2)
733 #define TOKEN_LENGTH (256 + ARRAY_SIZE (yytname))
736 #ifdef GATHER_STATISTICS
742 reduce_count
[yyn
] += 1;
749 return reduce_count
[*q
] - reduce_count
[*p
];
756 return token_count
[*q
] - token_count
[*p
];
762 print_parse_statistics ()
764 #ifdef GATHER_STATISTICS
768 int maxlen
= REDUCE_LENGTH
;
771 if (reduce_count
[-1] == 0)
774 if (TOKEN_LENGTH
> REDUCE_LENGTH
)
775 maxlen
= TOKEN_LENGTH
;
776 sorted
= (unsigned *) alloca (sizeof (int) * maxlen
);
778 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
780 qsort (sorted
, TOKEN_LENGTH
, sizeof (int), token_cmp
);
781 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
784 if (token_count
[idx
] == 0)
786 if (token_count
[idx
] < token_count
[-1])
788 fprintf (stderr
, "token %d, `%s', count = %d\n",
789 idx
, yytname
[YYTRANSLATE (idx
)], token_count
[idx
]);
791 fprintf (stderr
, "\n");
792 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
794 qsort (sorted
, REDUCE_LENGTH
, sizeof (int), reduce_cmp
);
795 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
798 if (reduce_count
[idx
] == 0)
800 if (reduce_count
[idx
] < reduce_count
[-1])
802 fprintf (stderr
, "rule %d, line %d, count = %d\n",
803 idx
, yyrline
[idx
], reduce_count
[idx
]);
805 fprintf (stderr
, "\n");
811 /* Helper function to load global variables with interface
815 extract_interface_info ()
817 struct c_fileinfo
*finfo
= 0;
819 if (flag_alt_external_templates
)
821 tree til
= tinst_for_decl ();
824 finfo
= get_fileinfo (TINST_FILE (til
));
827 finfo
= get_fileinfo (input_filename
);
829 interface_only
= finfo
->interface_only
;
830 interface_unknown
= finfo
->interface_unknown
;
833 /* Return nonzero if S is not considered part of an
834 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
840 /* Set the interface/implementation bits for this scope. */
841 struct impl_files
*ifiles
;
844 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
846 const char *t1
= ifiles
->filename
;
849 if (*s1
!= *t1
|| *s1
== 0)
852 while (*s1
== *t1
&& *s1
!= 0)
859 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
860 if (strchr (s1
, '.') || strchr (t1
, '.'))
863 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
874 /* Heuristic to tell whether the user is missing a semicolon
875 after a struct or enum declaration. Emit an error message
876 if we know the user has blown it. */
879 check_for_missing_semicolon (type
)
887 && yychar
!= IDENTIFIER
888 && yychar
!= tTYPENAME
889 && yychar
!= CV_QUALIFIER
890 && yychar
!= SELFNAME
)
891 || yychar
== 0 /* EOF */)
893 if (TYPE_ANONYMOUS_P (type
))
894 error ("semicolon missing after %s declaration",
895 TREE_CODE (type
) == ENUMERAL_TYPE
? "enum" : "struct");
897 error ("semicolon missing after declaration of `%T'", type
);
898 shadow_tag (build_tree_list (0, type
));
900 /* Could probably also hack cases where class { ... } f (); appears. */
905 note_got_semicolon (type
)
910 if (CLASS_TYPE_P (type
))
911 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
915 note_list_got_semicolon (declspecs
)
920 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
922 tree type
= TREE_VALUE (link
);
923 if (type
&& TYPE_P (type
))
924 note_got_semicolon (type
);
930 /* Parse a #pragma whose sole argument is a string constant.
931 If OPT is true, the argument is optional. */
933 parse_strconst_pragma (name
, opt
)
944 if (c_lex (&x
) != CPP_EOF
)
945 warning ("junk at end of #pragma %s", name
);
949 if (t
== CPP_EOF
&& opt
)
952 error ("invalid #pragma %s", name
);
957 handle_pragma_vtable (dfile
)
958 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
960 parse_strconst_pragma ("vtable", 0);
961 sorry ("#pragma vtable no longer supported");
965 handle_pragma_unit (dfile
)
966 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
968 /* Validate syntax, but don't do anything. */
969 parse_strconst_pragma ("unit", 0);
973 handle_pragma_interface (dfile
)
974 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
976 tree fname
= parse_strconst_pragma ("interface", 1);
977 struct c_fileinfo
*finfo
;
978 const char *main_filename
;
980 if (fname
== (tree
)-1)
983 main_filename
= lbasename (input_filename
);
985 main_filename
= TREE_STRING_POINTER (fname
);
987 finfo
= get_fileinfo (input_filename
);
989 if (impl_file_chain
== 0)
991 /* If this is zero at this point, then we are
992 auto-implementing. */
993 if (main_input_filename
== 0)
994 main_input_filename
= input_filename
;
997 interface_only
= interface_strcmp (main_filename
);
998 #ifdef MULTIPLE_SYMBOL_SPACES
999 if (! interface_only
)
1001 interface_unknown
= 0;
1003 finfo
->interface_only
= interface_only
;
1004 finfo
->interface_unknown
= interface_unknown
;
1007 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1008 We used to only allow this at toplevel, but that restriction was buggy
1009 in older compilers and it seems reasonable to allow it in the headers
1010 themselves, too. It only needs to precede the matching #p interface.
1012 We don't touch interface_only or interface_unknown; the user must specify
1013 a matching #p interface for this to have any effect. */
1016 handle_pragma_implementation (dfile
)
1017 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
1019 tree fname
= parse_strconst_pragma ("implementation", 1);
1020 const char *main_filename
;
1021 struct impl_files
*ifiles
= impl_file_chain
;
1023 if (fname
== (tree
)-1)
1028 if (main_input_filename
)
1029 main_filename
= main_input_filename
;
1031 main_filename
= input_filename
;
1032 main_filename
= lbasename (main_filename
);
1036 main_filename
= TREE_STRING_POINTER (fname
);
1037 if (cpp_included (parse_in
, main_filename
))
1038 warning ("#pragma implementation for %s appears after file is included",
1042 for (; ifiles
; ifiles
= ifiles
->next
)
1044 if (! strcmp (ifiles
->filename
, main_filename
))
1049 ifiles
= (struct impl_files
*) xmalloc (sizeof (struct impl_files
));
1050 ifiles
->filename
= main_filename
;
1051 ifiles
->next
= impl_file_chain
;
1052 impl_file_chain
= ifiles
;
1056 /* Indicate that this file uses Java-personality exception handling. */
1058 handle_pragma_java_exceptions (dfile
)
1059 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
1062 if (c_lex (&x
) != CPP_EOF
)
1063 warning ("junk at end of #pragma GCC java_exceptions");
1065 choose_personality_routine (lang_java
);
1069 do_pending_lang_change ()
1071 for (; pending_lang_change
> 0; --pending_lang_change
)
1072 push_lang_context (lang_name_c
);
1073 for (; pending_lang_change
< 0; ++pending_lang_change
)
1074 pop_lang_context ();
1077 /* Return true if d is in a global scope. */
1084 switch (TREE_CODE (d
))
1089 case OVERLOAD
: d
= OVL_FUNCTION (d
); continue;
1090 case TREE_LIST
: d
= TREE_VALUE (d
); continue;
1092 my_friendly_assert (DECL_P (d
), 980629);
1094 return DECL_NAMESPACE_SCOPE_P (d
);
1098 /* Issue an error message indicating that the lookup of NAME (an
1099 IDENTIFIER_NODE) failed. */
1102 unqualified_name_lookup_error (tree name
)
1104 if (IDENTIFIER_OPNAME_P (name
))
1106 if (name
!= ansi_opname (ERROR_MARK
))
1107 error ("`%D' not defined", name
);
1109 else if (current_function_decl
== 0)
1110 error ("`%D' was not declared in this scope", name
);
1113 if (IDENTIFIER_NAMESPACE_VALUE (name
) != error_mark_node
1114 || IDENTIFIER_ERROR_LOCUS (name
) != current_function_decl
)
1116 static int undeclared_variable_notice
;
1118 error ("`%D' undeclared (first use this function)", name
);
1120 if (! undeclared_variable_notice
)
1122 error ("(Each undeclared identifier is reported only once for each function it appears in.)");
1123 undeclared_variable_notice
= 1;
1126 /* Prevent repeated error messages. */
1127 SET_IDENTIFIER_NAMESPACE_VALUE (name
, error_mark_node
);
1128 SET_IDENTIFIER_ERROR_LOCUS (name
, current_function_decl
);
1133 do_identifier (token
, parsing
, args
)
1134 register tree token
;
1139 int lexing
= (parsing
== 1 || parsing
== 3);
1142 id
= lookup_name (token
, 0);
1146 if (lexing
&& id
&& TREE_DEPRECATED (id
))
1147 warn_deprecated_use (id
);
1149 /* Do Koenig lookup if appropriate (inside templates we build lookup
1150 expressions instead).
1152 [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
1153 finds the declaration of a class member function, the associated
1154 namespaces and classes are not considered. */
1156 if (args
&& !current_template_parms
&& (!id
|| is_global (id
)))
1157 id
= lookup_arg_dependent (token
, id
, args
);
1159 /* Remember that this name has been used in the class definition, as per
1161 if (id
&& parsing
&& parsing
!= 3)
1162 maybe_note_name_used_in_class (token
, id
);
1164 if (id
== error_mark_node
)
1166 /* lookup_name quietly returns error_mark_node if we're parsing,
1167 as we don't want to complain about an identifier that ends up
1168 being used as a declarator. So we call it again to get the error
1170 id
= lookup_name (token
, 0);
1171 return error_mark_node
;
1174 if (!id
|| (TREE_CODE (id
) == FUNCTION_DECL
1175 && DECL_ANTICIPATED (id
)))
1177 if (current_template_parms
)
1178 return build_min_nt (LOOKUP_EXPR
, token
);
1179 else if (IDENTIFIER_TYPENAME_P (token
))
1180 /* A templated conversion operator might exist. */
1184 unqualified_name_lookup_error (token
);
1185 return error_mark_node
;
1189 id
= check_for_out_of_scope_variable (id
);
1191 /* TREE_USED is set in `hack_identifier'. */
1192 if (TREE_CODE (id
) == CONST_DECL
)
1195 if (IDENTIFIER_CLASS_VALUE (token
) == id
)
1196 enforce_access (CP_DECL_CONTEXT(id
), id
);
1197 if (!processing_template_decl
|| DECL_TEMPLATE_PARM_P (id
))
1198 id
= DECL_INITIAL (id
);
1201 id
= hack_identifier (id
, token
);
1203 /* We must look up dependent names when the template is
1204 instantiated, not while parsing it. For now, we don't
1205 distinguish between dependent and independent names. So, for
1206 example, we look up all overloaded functions at
1207 instantiation-time, even though in some cases we should just use
1208 the DECL we have here. We also use LOOKUP_EXPRs to find things
1209 like local variables, rather than creating TEMPLATE_DECLs for the
1210 local variables and then finding matching instantiations. */
1211 if (current_template_parms
1212 && (is_overloaded_fn (id
)
1213 || (TREE_CODE (id
) == VAR_DECL
1214 && CP_DECL_CONTEXT (id
)
1215 && TREE_CODE (CP_DECL_CONTEXT (id
)) == FUNCTION_DECL
)
1216 || TREE_CODE (id
) == PARM_DECL
1217 || TREE_CODE (id
) == RESULT_DECL
1218 || TREE_CODE (id
) == USING_DECL
))
1219 id
= build_min_nt (LOOKUP_EXPR
, token
);
1225 do_scoped_id (token
, id
)
1229 if (!id
|| (TREE_CODE (id
) == FUNCTION_DECL
1230 && DECL_ANTICIPATED (id
)))
1232 if (processing_template_decl
)
1234 id
= build_min_nt (LOOKUP_EXPR
, token
);
1235 LOOKUP_EXPR_GLOBAL (id
) = 1;
1238 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
)
1239 error ("`::%D' undeclared (first use here)", token
);
1240 id
= error_mark_node
;
1241 /* Prevent repeated error messages. */
1242 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
1246 if (TREE_CODE (id
) == ADDR_EXPR
)
1247 mark_used (TREE_OPERAND (id
, 0));
1248 else if (TREE_CODE (id
) != OVERLOAD
)
1251 if (TREE_CODE (id
) == CONST_DECL
&& ! processing_template_decl
)
1253 /* XXX CHS - should we set TREE_USED of the constant? */
1254 id
= DECL_INITIAL (id
);
1255 /* This is to prevent an enum whose value is 0
1256 from being considered a null pointer constant. */
1257 id
= build1 (NOP_EXPR
, TREE_TYPE (id
), id
);
1258 TREE_CONSTANT (id
) = 1;
1261 if (processing_template_decl
)
1263 if (is_overloaded_fn (id
))
1265 id
= build_min_nt (LOOKUP_EXPR
, token
);
1266 LOOKUP_EXPR_GLOBAL (id
) = 1;
1269 /* else just use the decl */
1271 return convert_from_reference (id
);
1275 identifier_typedecl_value (node
)
1279 type
= IDENTIFIER_TYPE_VALUE (node
);
1280 if (type
== NULL_TREE
)
1283 if (IDENTIFIER_BINDING (node
))
1285 t
= IDENTIFIER_VALUE (node
);
1286 if (t
&& TREE_CODE (t
) == TYPE_DECL
&& TREE_TYPE (t
) == type
)
1289 if (IDENTIFIER_NAMESPACE_VALUE (node
))
1291 t
= IDENTIFIER_NAMESPACE_VALUE (node
);
1292 if (t
&& TREE_CODE (t
) == TYPE_DECL
&& TREE_TYPE (t
) == type
)
1296 /* Will this one ever happen? */
1297 if (TYPE_MAIN_DECL (type
))
1298 return TYPE_MAIN_DECL (type
);
1300 /* We used to do an internal error of 62 here, but instead we will
1301 handle the return of a null appropriately in the callers. */
1305 #ifdef GATHER_STATISTICS
1306 /* The original for tree_node_kind is in the toplevel tree.c; changes there
1307 need to be brought into here, unless this were actually put into a header
1309 /* Statistics-gathering stuff. */
1330 extern int tree_node_counts
[];
1331 extern int tree_node_sizes
[];
1335 build_lang_decl (code
, name
, type
)
1336 enum tree_code code
;
1342 t
= build_decl (code
, name
, type
);
1343 retrofit_lang_decl (t
);
1348 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
1349 and pushdecl (for functions generated by the backend). */
1352 retrofit_lang_decl (t
)
1355 struct lang_decl
*ld
;
1358 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
1359 size
= sizeof (struct lang_decl
);
1361 size
= sizeof (struct lang_decl_flags
);
1363 ld
= (struct lang_decl
*) ggc_alloc_cleared (size
);
1365 ld
->decl_flags
.can_be_full
= CAN_HAVE_FULL_LANG_DECL_P (t
) ? 1 : 0;
1366 ld
->decl_flags
.u1sel
= TREE_CODE (t
) == NAMESPACE_DECL
? 1 : 0;
1367 ld
->decl_flags
.u2sel
= 0;
1368 if (ld
->decl_flags
.can_be_full
)
1369 ld
->u
.f
.u3sel
= TREE_CODE (t
) == FUNCTION_DECL
? 1 : 0;
1371 DECL_LANG_SPECIFIC (t
) = ld
;
1372 if (current_lang_name
== lang_name_cplusplus
)
1373 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
1374 else if (current_lang_name
== lang_name_c
)
1375 SET_DECL_LANGUAGE (t
, lang_c
);
1376 else if (current_lang_name
== lang_name_java
)
1377 SET_DECL_LANGUAGE (t
, lang_java
);
1380 #ifdef GATHER_STATISTICS
1381 tree_node_counts
[(int)lang_decl
] += 1;
1382 tree_node_sizes
[(int)lang_decl
] += size
;
1387 cxx_dup_lang_specific_decl (node
)
1391 struct lang_decl
*ld
;
1393 if (! DECL_LANG_SPECIFIC (node
))
1396 if (!CAN_HAVE_FULL_LANG_DECL_P (node
))
1397 size
= sizeof (struct lang_decl_flags
);
1399 size
= sizeof (struct lang_decl
);
1400 ld
= (struct lang_decl
*) ggc_alloc (size
);
1401 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
1402 DECL_LANG_SPECIFIC (node
) = ld
;
1404 #ifdef GATHER_STATISTICS
1405 tree_node_counts
[(int)lang_decl
] += 1;
1406 tree_node_sizes
[(int)lang_decl
] += size
;
1410 /* Copy DECL, including any language-specific parts. */
1418 copy
= copy_node (decl
);
1419 cxx_dup_lang_specific_decl (copy
);
1423 /* Replace the shared language-specific parts of NODE with a new copy. */
1426 copy_lang_type (node
)
1430 struct lang_type
*lt
;
1432 if (! TYPE_LANG_SPECIFIC (node
))
1435 if (TYPE_LANG_SPECIFIC (node
)->u
.h
.is_lang_type_class
)
1436 size
= sizeof (struct lang_type
);
1438 size
= sizeof (struct lang_type_ptrmem
);
1439 lt
= (struct lang_type
*) ggc_alloc (size
);
1440 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), size
);
1441 TYPE_LANG_SPECIFIC (node
) = lt
;
1443 #ifdef GATHER_STATISTICS
1444 tree_node_counts
[(int)lang_type
] += 1;
1445 tree_node_sizes
[(int)lang_type
] += size
;
1449 /* Copy TYPE, including any language-specific parts. */
1457 copy
= copy_node (type
);
1458 copy_lang_type (copy
);
1463 cxx_make_type (code
)
1464 enum tree_code code
;
1466 register tree t
= make_node (code
);
1468 /* Create lang_type structure. */
1469 if (IS_AGGR_TYPE_CODE (code
)
1470 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
)
1472 struct lang_type
*pi
;
1474 pi
= ((struct lang_type
*)
1475 ggc_alloc_cleared (sizeof (struct lang_type
)));
1477 TYPE_LANG_SPECIFIC (t
) = pi
;
1478 pi
->u
.c
.h
.is_lang_type_class
= 1;
1480 #ifdef GATHER_STATISTICS
1481 tree_node_counts
[(int)lang_type
] += 1;
1482 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
1486 /* Set up some flags that give proper default behavior. */
1487 if (IS_AGGR_TYPE_CODE (code
))
1489 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, interface_unknown
);
1490 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
1492 /* Make sure this is laid out, for ease of use later. In the
1493 presence of parse errors, the normal was of assuring this
1494 might not ever get executed, so we lay it out *immediately*. */
1495 build_pointer_type (t
);
1498 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
1499 TYPE_ALIAS_SET is initialized to -1 by default, so we must
1501 TYPE_ALIAS_SET (t
) = 0;
1503 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1504 since they can be virtual base types, and we then need a
1505 canonical binfo for them. Ideally, this would be done lazily for
1507 if (IS_AGGR_TYPE_CODE (code
) || code
== TEMPLATE_TYPE_PARM
1508 || code
== BOUND_TEMPLATE_TEMPLATE_PARM
1509 || code
== TYPENAME_TYPE
)
1510 TYPE_BINFO (t
) = make_binfo (size_zero_node
, t
, NULL_TREE
, NULL_TREE
);
1516 make_aggr_type (code
)
1517 enum tree_code code
;
1519 tree t
= cxx_make_type (code
);
1521 if (IS_AGGR_TYPE_CODE (code
))
1522 SET_IS_AGGR_TYPE (t
, 1);
1527 /* Return the type-qualifier corresponding to the identifier given by
1531 cp_type_qual_from_rid (rid
)
1534 if (rid
== ridpointers
[(int) RID_CONST
])
1535 return TYPE_QUAL_CONST
;
1536 else if (rid
== ridpointers
[(int) RID_VOLATILE
])
1537 return TYPE_QUAL_VOLATILE
;
1538 else if (rid
== ridpointers
[(int) RID_RESTRICT
])
1539 return TYPE_QUAL_RESTRICT
;
1542 return TYPE_UNQUALIFIED
;