1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 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++. */
26 /* Cause the `yydebug' variable to be defined. */
45 #include "diagnostic.h"
47 #ifdef MULTIBYTE_CHARS
52 extern void yyprint
PARAMS ((FILE *, int, YYSTYPE
));
54 static int interface_strcmp
PARAMS ((const char *));
55 static int *init_cpp_parse
PARAMS ((void));
56 static void init_reswords
PARAMS ((void));
57 static void init_cp_pragma
PARAMS ((void));
58 static void mark_impl_file_chain
PARAMS ((PTR
));
60 static tree parse_strconst_pragma
PARAMS ((const char *, int));
61 static void handle_pragma_vtable
PARAMS ((cpp_reader
*));
62 static void handle_pragma_unit
PARAMS ((cpp_reader
*));
63 static void handle_pragma_interface
PARAMS ((cpp_reader
*));
64 static void handle_pragma_implementation
PARAMS ((cpp_reader
*));
66 #ifdef GATHER_STATISTICS
68 static int reduce_cmp
PARAMS ((int *, int *));
69 static int token_cmp
PARAMS ((int *, int *));
72 static int is_global
PARAMS ((tree
));
73 static void init_operators
PARAMS ((void));
75 /* A constraint that can be tested at compile time. */
77 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
79 #define CONSTRAINT(name, expr) extern int constraint_/**/name [(expr) ? 1 : -1]
84 extern cpp_reader parse_in
;
91 /* Pending language change.
92 Positive is push count, negative is pop count. */
93 int pending_lang_change
= 0;
95 extern int yychar
; /* the lookahead symbol */
96 extern YYSTYPE yylval
; /* the semantic value of the */
97 /* lookahead symbol */
99 /* These flags are used by c-lex.c. In C++, they're always off and on,
101 int warn_traditional
= 0;
102 int flag_digraphs
= 1;
104 /* the declaration found for the last IDENTIFIER token read in.
105 yylex must look this up to detect typedefs, which get token type TYPENAME,
106 so it is left around in case the identifier is not a typedef but is
107 used in a context which makes it a reference to a variable. */
110 /* Array for holding counts of the numbers of tokens seen. */
111 extern int *token_count
;
113 /* Functions and data structures for #pragma interface.
115 `#pragma implementation' means that the main file being compiled
116 is considered to implement (provide) the classes that appear in
117 its main body. I.e., if this is file "foo.cc", and class `bar'
118 is defined in "foo.cc", then we say that "foo.cc implements bar".
120 All main input files "implement" themselves automagically.
122 `#pragma interface' means that unless this file (of the form "foo.h"
123 is not presently being included by file "foo.cc", the
124 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
125 of the vtables nor any of the inline functions defined in foo.h
128 There are cases when we want to link files such as "defs.h" and
129 "main.cc". In this case, we give "defs.h" a `#pragma interface',
130 and "main.cc" has `#pragma implementation "defs.h"'. */
135 struct impl_files
*next
;
138 static struct impl_files
*impl_file_chain
;
140 /* The string used to represent the filename of internally generated
141 tree nodes. The variable, which is dynamically allocated, should
142 be used; the macro is only used to initialize it. */
143 static char *internal_filename
;
144 #define INTERNAL_FILENAME ("<internal>")
146 /* Return something to represent absolute declarators containing a *.
147 TARGET is the absolute declarator that the * contains.
148 CV_QUALIFIERS is a list of modifiers such as const or volatile
149 to apply to the pointer type, represented as identifiers.
151 We return an INDIRECT_REF whose "contents" are TARGET
152 and whose type is the modifier list. */
155 make_pointer_declarator (cv_qualifiers
, target
)
156 tree cv_qualifiers
, target
;
158 if (target
&& TREE_CODE (target
) == IDENTIFIER_NODE
159 && ANON_AGGRNAME_P (target
))
160 error ("type name expected before `*'");
161 target
= build_parse_node (INDIRECT_REF
, target
);
162 TREE_TYPE (target
) = cv_qualifiers
;
166 /* Return something to represent absolute declarators containing a &.
167 TARGET is the absolute declarator that the & contains.
168 CV_QUALIFIERS is a list of modifiers such as const or volatile
169 to apply to the reference type, represented as identifiers.
171 We return an ADDR_EXPR whose "contents" are TARGET
172 and whose type is the modifier list. */
175 make_reference_declarator (cv_qualifiers
, target
)
176 tree cv_qualifiers
, target
;
180 if (TREE_CODE (target
) == ADDR_EXPR
)
182 error ("cannot declare references to references");
185 if (TREE_CODE (target
) == INDIRECT_REF
)
187 error ("cannot declare pointers to references");
190 if (TREE_CODE (target
) == IDENTIFIER_NODE
&& ANON_AGGRNAME_P (target
))
191 error ("type name expected before `&'");
193 target
= build_parse_node (ADDR_EXPR
, target
);
194 TREE_TYPE (target
) = cv_qualifiers
;
199 make_call_declarator (target
, parms
, cv_qualifiers
, exception_specification
)
200 tree target
, parms
, cv_qualifiers
, exception_specification
;
202 target
= build_parse_node (CALL_EXPR
, target
,
203 decl_tree_cons (parms
, cv_qualifiers
, NULL_TREE
),
204 /* The third operand is really RTL. We
205 shouldn't put anything there. */
207 CALL_DECLARATOR_EXCEPTION_SPEC (target
) = exception_specification
;
212 set_quals_and_spec (call_declarator
, cv_qualifiers
, exception_specification
)
213 tree call_declarator
, cv_qualifiers
, exception_specification
;
215 CALL_DECLARATOR_QUALS (call_declarator
) = cv_qualifiers
;
216 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator
) = exception_specification
;
219 int interface_only
; /* whether or not current file is only for
220 interface definitions. */
221 int interface_unknown
; /* whether or not we know this class
222 to behave according to #pragma interface. */
224 /* Tree code classes. */
226 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
228 static char cplus_tree_code_type
[] = {
230 #include "cp-tree.def"
234 /* Table indexed by tree code giving number of expression
235 operands beyond the fixed part of the node structure.
236 Not used for types or decls. */
238 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
240 static int cplus_tree_code_length
[] = {
242 #include "cp-tree.def"
246 /* Names of tree components.
247 Used for printing out the tree and error messages. */
248 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
250 static const char *cplus_tree_code_name
[] = {
252 #include "cp-tree.def"
256 /* toplev.c needs to call these. */
263 cpp_reader_init (&parse_in
);
266 /* Default exceptions on. */
268 /* Mark as "unspecified". */
269 flag_bounds_check
= -1;
270 /* By default wrap lines at 80 characters. Is getenv ("COLUMNS")
272 diagnostic_message_length_per_line
= 80;
273 /* By default, emit location information once for every
274 diagnostic message. */
275 set_message_prefixing_rule (DIAGNOSTICS_SHOW_PREFIX_ONCE
);
281 /* If still "unspecified", make it match -fbounded-pointers. */
282 if (flag_bounds_check
< 0)
283 flag_bounds_check
= flag_bounded_pointers
;
286 /* the beginning of the file is a new line; check for # */
287 /* With luck, we discover the real source file's name from that
288 and put it in input_filename. */
289 ungetc (check_newline (), finput
);
292 if (flag_gnu_xref
) GNU_xref_begin (input_filename
);
293 init_repo (input_filename
);
299 if (flag_gnu_xref
) GNU_xref_end (errorcount
+sorrycount
);
311 #ifdef GATHER_STATISTICS
313 reduce_count
= (int *) xcalloc (sizeof (int), (REDUCE_LENGTH
+ 1));
315 token_count
= (int *) xcalloc (sizeof (int), (TOKEN_LENGTH
+ 1));
322 /* A mapping from tree codes to operator name information. */
323 operator_name_info_t operator_name_info
[(int) LAST_CPLUS_TREE_CODE
];
324 /* Similar, but for assignment operators. */
325 operator_name_info_t assignment_operator_name_info
[(int) LAST_CPLUS_TREE_CODE
];
327 /* Initialize data structures that keep track of operator names. */
329 #define DEF_OPERATOR(NAME, C, NM, OM, AR, AP) \
330 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256);
331 #include "operators.def"
339 struct operator_name_info_t
*oni
;
341 #define DEF_OPERATOR(NAME, CODE, NEW_MANGLING, OLD_MANGLING, ARITY, ASSN_P) \
342 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \
343 identifier = get_identifier (buffer); \
344 IDENTIFIER_OPNAME_P (identifier) = 1; \
347 ? &assignment_operator_name_info[(int) CODE] \
348 : &operator_name_info[(int) CODE]); \
349 oni->identifier = identifier; \
351 oni->mangled_name = flag_new_abi ? NEW_MANGLING : OLD_MANGLING;
353 #include "operators.def"
356 operator_name_info
[(int) ERROR_MARK
].identifier
357 = get_identifier ("<invalid operator>");
359 /* Handle some special cases. These operators are not defined in
360 the language, but can be produced internally. We may need them
361 for error-reporting. (Eventually, we should ensure that this
362 does not happen. Error messages involving these operators will
363 be confusing to users.) */
365 operator_name_info
[(int) INIT_EXPR
].name
366 = operator_name_info
[(int) MODIFY_EXPR
].name
;
367 operator_name_info
[(int) EXACT_DIV_EXPR
].name
= "(ceiling /)";
368 operator_name_info
[(int) CEIL_DIV_EXPR
].name
= "(ceiling /)";
369 operator_name_info
[(int) FLOOR_DIV_EXPR
].name
= "(floor /)";
370 operator_name_info
[(int) ROUND_DIV_EXPR
].name
= "(round /)";
371 operator_name_info
[(int) CEIL_MOD_EXPR
].name
= "(ceiling %)";
372 operator_name_info
[(int) FLOOR_MOD_EXPR
].name
= "(floor %)";
373 operator_name_info
[(int) ROUND_MOD_EXPR
].name
= "(round %)";
374 operator_name_info
[(int) ABS_EXPR
].name
= "abs";
375 operator_name_info
[(int) FFS_EXPR
].name
= "ffs";
376 operator_name_info
[(int) BIT_ANDTC_EXPR
].name
= "&~";
377 operator_name_info
[(int) TRUTH_AND_EXPR
].name
= "strict &&";
378 operator_name_info
[(int) TRUTH_OR_EXPR
].name
= "strict ||";
379 operator_name_info
[(int) IN_EXPR
].name
= "in";
380 operator_name_info
[(int) RANGE_EXPR
].name
= "...";
381 operator_name_info
[(int) CONVERT_EXPR
].name
= "+";
383 assignment_operator_name_info
[(int) EXACT_DIV_EXPR
].name
385 assignment_operator_name_info
[(int) CEIL_DIV_EXPR
].name
387 assignment_operator_name_info
[(int) FLOOR_DIV_EXPR
].name
389 assignment_operator_name_info
[(int) ROUND_DIV_EXPR
].name
391 assignment_operator_name_info
[(int) CEIL_MOD_EXPR
].name
393 assignment_operator_name_info
[(int) FLOOR_MOD_EXPR
].name
395 assignment_operator_name_info
[(int) ROUND_MOD_EXPR
].name
399 /* The reserved keyword table. */
403 ENUM_BITFIELD(rid
) rid
: 16;
404 unsigned int disable
: 16;
407 /* Disable mask. Keywords are disabled if (reswords[i].disable & mask) is
409 #define D_EXT 0x01 /* GCC extension */
410 #define D_ASM 0x02 /* in C99, but has a switch to turn it off */
411 #define D_OPNAME 0x04 /* operator names */
413 CONSTRAINT(ridbits_fit
, RID_LAST_MODIFIER
< sizeof(unsigned long) * CHAR_BIT
);
415 static const struct resword reswords
[] =
417 { "__alignof", RID_ALIGNOF
, 0 },
418 { "__alignof__", RID_ALIGNOF
, 0 },
419 { "__asm", RID_ASM
, 0 },
420 { "__asm__", RID_ASM
, 0 },
421 { "__attribute", RID_ATTRIBUTE
, 0 },
422 { "__attribute__", RID_ATTRIBUTE
, 0 },
423 { "__builtin_va_arg", RID_VA_ARG
, 0 },
424 { "__complex", RID_COMPLEX
, 0 },
425 { "__complex__", RID_COMPLEX
, 0 },
426 { "__const", RID_CONST
, 0 },
427 { "__const__", RID_CONST
, 0 },
428 { "__extension__", RID_EXTENSION
, 0 },
429 { "__imag", RID_IMAGPART
, 0 },
430 { "__imag__", RID_IMAGPART
, 0 },
431 { "__inline", RID_INLINE
, 0 },
432 { "__inline__", RID_INLINE
, 0 },
433 { "__label__", RID_LABEL
, 0 },
434 { "__null", RID_NULL
, 0 },
435 { "__real", RID_REALPART
, 0 },
436 { "__real__", RID_REALPART
, 0 },
437 { "__restrict", RID_RESTRICT
, 0 },
438 { "__restrict__", RID_RESTRICT
, 0 },
439 { "__signed", RID_SIGNED
, 0 },
440 { "__signed__", RID_SIGNED
, 0 },
441 { "__typeof", RID_TYPEOF
, 0 },
442 { "__typeof__", RID_TYPEOF
, 0 },
443 { "__volatile", RID_VOLATILE
, 0 },
444 { "__volatile__", RID_VOLATILE
, 0 },
445 { "__wchar_t", RID_WCHAR
, 0 },
446 { "asm", RID_ASM
, D_ASM
},
447 { "and", RID_AND
, D_OPNAME
},
448 { "and_eq", RID_AND_EQ
, D_OPNAME
},
449 { "auto", RID_AUTO
, 0 },
450 { "bitand", RID_BITAND
, D_OPNAME
},
451 { "bitor", RID_BITOR
, D_OPNAME
},
452 { "bool", RID_BOOL
, 0 },
453 { "break", RID_BREAK
, 0 },
454 { "case", RID_CASE
, 0 },
455 { "catch", RID_CATCH
, 0 },
456 { "char", RID_CHAR
, 0 },
457 { "class", RID_CLASS
, 0 },
458 { "compl", RID_COMPL
, D_OPNAME
},
459 { "const", RID_CONST
, 0 },
460 { "const_cast", RID_CONSTCAST
, 0 },
461 { "continue", RID_CONTINUE
, 0 },
462 { "default", RID_DEFAULT
, 0 },
463 { "delete", RID_DELETE
, 0 },
465 { "double", RID_DOUBLE
, 0 },
466 { "dynamic_cast", RID_DYNCAST
, 0 },
467 { "else", RID_ELSE
, 0 },
468 { "enum", RID_ENUM
, 0 },
469 { "explicit", RID_EXPLICIT
, 0 },
470 { "export", RID_EXPORT
, 0 },
471 { "extern", RID_EXTERN
, 0 },
472 { "false", RID_FALSE
, 0 },
473 { "float", RID_FLOAT
, 0 },
474 { "for", RID_FOR
, 0 },
475 { "friend", RID_FRIEND
, 0 },
476 { "goto", RID_GOTO
, 0 },
478 { "inline", RID_INLINE
, 0 },
479 { "int", RID_INT
, 0 },
480 { "long", RID_LONG
, 0 },
481 { "mutable", RID_MUTABLE
, 0 },
482 { "namespace", RID_NAMESPACE
, 0 },
483 { "new", RID_NEW
, 0 },
484 { "not", RID_NOT
, D_OPNAME
},
485 { "not_eq", RID_NOT_EQ
, D_OPNAME
},
486 { "operator", RID_OPERATOR
, 0 },
487 { "or", RID_OR
, D_OPNAME
},
488 { "or_eq", RID_OR_EQ
, D_OPNAME
},
489 { "private", RID_PRIVATE
, 0 },
490 { "protected", RID_PROTECTED
, 0 },
491 { "public", RID_PUBLIC
, 0 },
492 { "register", RID_REGISTER
, 0 },
493 { "reinterpret_cast", RID_REINTCAST
, 0 },
494 { "return", RID_RETURN
, 0 },
495 { "short", RID_SHORT
, 0 },
496 { "signed", RID_SIGNED
, 0 },
497 { "sizeof", RID_SIZEOF
, 0 },
498 { "static", RID_STATIC
, 0 },
499 { "static_cast", RID_STATCAST
, 0 },
500 { "struct", RID_STRUCT
, 0 },
501 { "switch", RID_SWITCH
, 0 },
502 { "template", RID_TEMPLATE
, 0 },
503 { "this", RID_THIS
, 0 },
504 { "throw", RID_THROW
, 0 },
505 { "true", RID_TRUE
, 0 },
506 { "try", RID_TRY
, 0 },
507 { "typedef", RID_TYPEDEF
, 0 },
508 { "typename", RID_TYPENAME
, 0 },
509 { "typeid", RID_TYPEID
, 0 },
510 { "typeof", RID_TYPEOF
, D_ASM
|D_EXT
},
511 { "union", RID_UNION
, 0 },
512 { "unsigned", RID_UNSIGNED
, 0 },
513 { "using", RID_USING
, 0 },
514 { "virtual", RID_VIRTUAL
, 0 },
515 { "void", RID_VOID
, 0 },
516 { "volatile", RID_VOLATILE
, 0 },
517 { "while", RID_WHILE
, 0 },
518 { "xor", RID_XOR
, D_OPNAME
},
519 { "xor_eq", RID_XOR_EQ
, D_OPNAME
},
522 #define N_reswords (sizeof reswords / sizeof (struct resword))
524 /* Table mapping from RID_* constants to yacc token numbers.
525 Unfortunately we have to have entries for all the keywords in all
527 const short rid_to_yy
[RID_MAX
] =
529 /* RID_STATIC */ SCSPEC
,
530 /* RID_UNSIGNED */ TYPESPEC
,
531 /* RID_LONG */ TYPESPEC
,
532 /* RID_CONST */ CV_QUALIFIER
,
533 /* RID_EXTERN */ SCSPEC
,
534 /* RID_REGISTER */ SCSPEC
,
535 /* RID_TYPEDEF */ SCSPEC
,
536 /* RID_SHORT */ TYPESPEC
,
537 /* RID_INLINE */ SCSPEC
,
538 /* RID_VOLATILE */ CV_QUALIFIER
,
539 /* RID_SIGNED */ TYPESPEC
,
540 /* RID_AUTO */ SCSPEC
,
541 /* RID_RESTRICT */ CV_QUALIFIER
,
543 /* C extensions. Bounded pointers are not yet in C++ */
545 /* RID_UNBOUNDED */ 0,
546 /* RID_COMPLEX */ TYPESPEC
,
549 /* RID_FRIEND */ SCSPEC
,
550 /* RID_VIRTUAL */ SCSPEC
,
551 /* RID_EXPLICIT */ SCSPEC
,
552 /* RID_EXPORT */ SCSPEC
,
553 /* RID_MUTABLE */ SCSPEC
,
564 /* RID_INT */ TYPESPEC
,
565 /* RID_CHAR */ TYPESPEC
,
566 /* RID_FLOAT */ TYPESPEC
,
567 /* RID_DOUBLE */ TYPESPEC
,
568 /* RID_VOID */ TYPESPEC
,
570 /* RID_STRUCT */ AGGR
,
571 /* RID_UNION */ AGGR
,
574 /* RID_WHILE */ WHILE
,
577 /* RID_SWITCH */ SWITCH
,
579 /* RID_DEFAULT */ DEFAULT
,
580 /* RID_BREAK */ BREAK
,
581 /* RID_CONTINUE */ CONTINUE
,
582 /* RID_RETURN */ RETURN_KEYWORD
,
584 /* RID_SIZEOF */ SIZEOF
,
587 /* RID_ASM */ ASM_KEYWORD
,
588 /* RID_TYPEOF */ TYPEOF
,
589 /* RID_ALIGNOF */ ALIGNOF
,
590 /* RID_ATTRIBUTE */ ATTRIBUTE
,
591 /* RID_VA_ARG */ VA_ARG
,
592 /* RID_EXTENSION */ EXTENSION
,
593 /* RID_IMAGPART */ IMAGPART
,
594 /* RID_REALPART */ REALPART
,
595 /* RID_LABEL */ LABEL
,
597 /* RID_PTREXTENT */ 0,
598 /* RID_PTRVALUE */ 0,
601 /* RID_BOOL */ TYPESPEC
,
602 /* RID_WCHAR */ TYPESPEC
,
603 /* RID_CLASS */ AGGR
,
604 /* RID_PUBLIC */ VISSPEC
,
605 /* RID_PRIVATE */ VISSPEC
,
606 /* RID_PROTECTED */ VISSPEC
,
607 /* RID_TEMPLATE */ TEMPLATE
,
608 /* RID_NULL */ CONSTANT
,
609 /* RID_CATCH */ CATCH
,
610 /* RID_DELETE */ DELETE
,
611 /* RID_FALSE */ CXX_FALSE
,
612 /* RID_NAMESPACE */ NAMESPACE
,
614 /* RID_OPERATOR */ OPERATOR
,
616 /* RID_THROW */ THROW
,
617 /* RID_TRUE */ CXX_TRUE
,
619 /* RID_TYPENAME */ TYPENAME_KEYWORD
,
620 /* RID_TYPEID */ TYPEID
,
621 /* RID_USING */ USING
,
624 /* RID_CONSTCAST */ CONST_CAST
,
625 /* RID_DYNCAST */ DYNAMIC_CAST
,
626 /* RID_REINTCAST */ REINTERPRET_CAST
,
627 /* RID_STATCAST */ STATIC_CAST
,
629 /* alternate spellings */
630 /* RID_AND */ ANDAND
,
631 /* RID_AND_EQ */ ASSIGN
,
633 /* RID_NOT_EQ */ EQCOMPARE
,
635 /* RID_OR_EQ */ ASSIGN
,
637 /* RID_XOR_EQ */ ASSIGN
,
638 /* RID_BITAND */ '&',
644 /* RID_AT_ENCODE */ 0,
646 /* RID_AT_CLASS */ 0,
647 /* RID_AT_ALIAS */ 0,
649 /* RID_AT_PRIVATE */ 0,
650 /* RID_AT_PROTECTED */ 0,
651 /* RID_AT_PUBLIC */ 0,
652 /* RID_AT_PROTOCOL */ 0,
653 /* RID_AT_SELECTOR */ 0,
654 /* RID_AT_INTERFACE */ 0,
655 /* RID_AT_IMPLEMENTATION */ 0
663 int mask
= ((flag_operator_names
? 0 : D_OPNAME
)
664 | (flag_no_asm
? D_ASM
: 0)
665 | (flag_no_gnu_keywords
? D_EXT
: 0));
667 /* It is not necessary to register ridpointers as a GC root, because
668 all the trees it points to are permanently interned in the
669 get_identifier hash anyway. */
670 ridpointers
= (tree
*) xcalloc ((int) RID_MAX
, sizeof (tree
));
671 for (i
= 0; i
< N_reswords
; i
++)
673 id
= get_identifier (reswords
[i
].word
);
674 C_RID_CODE (id
) = reswords
[i
].rid
;
675 ridpointers
[(int) reswords
[i
].rid
] = id
;
676 if (! (reswords
[i
].disable
& mask
))
677 C_IS_RESERVED_WORD (id
) = 1;
685 #define pfile &parse_in
689 cpp_register_pragma (pfile
, 0, "vtable", handle_pragma_vtable
);
690 cpp_register_pragma (pfile
, 0, "unit", handle_pragma_unit
);
692 cpp_register_pragma (pfile
, 0, "interface", handle_pragma_interface
);
693 cpp_register_pragma (pfile
, 0, "implementation",
694 handle_pragma_implementation
);
696 cpp_register_pragma_space (pfile
, "GCC");
697 cpp_register_pragma (pfile
, "GCC", "interface", handle_pragma_interface
);
698 cpp_register_pragma (pfile
, "GCC", "implementation",
699 handle_pragma_implementation
);
703 init_parse (filename
)
704 const char *filename
;
706 /* Make identifier nodes long enough for the language-specific slots. */
707 set_identifier_size (sizeof (struct lang_identifier
));
708 decl_printable_name
= lang_printable_name
;
710 internal_filename
= ggc_alloc_string (INTERNAL_FILENAME
,
711 sizeof (INTERNAL_FILENAME
));
712 input_filename
= internal_filename
;
720 init_cplus_expand ();
724 memcpy (tree_code_type
+ (int) LAST_C_TREE_CODE
,
725 cplus_tree_code_type
,
726 (int)LAST_CPLUS_TREE_CODE
- (int)LAST_C_TREE_CODE
);
727 memcpy (tree_code_length
+ (int) LAST_C_TREE_CODE
,
728 cplus_tree_code_length
,
729 (LAST_CPLUS_TREE_CODE
- (int)LAST_C_TREE_CODE
) * sizeof (int));
730 memcpy (tree_code_name
+ (int) LAST_C_TREE_CODE
,
731 cplus_tree_code_name
,
732 (LAST_CPLUS_TREE_CODE
- (int)LAST_C_TREE_CODE
) * sizeof (char *));
738 current_function_decl
= NULL
;
740 class_type_node
= build_int_2 (class_type
, 0);
741 TREE_TYPE (class_type_node
) = class_type_node
;
742 ridpointers
[(int) RID_CLASS
] = class_type_node
;
744 record_type_node
= build_int_2 (record_type
, 0);
745 TREE_TYPE (record_type_node
) = record_type_node
;
746 ridpointers
[(int) RID_STRUCT
] = record_type_node
;
748 union_type_node
= build_int_2 (union_type
, 0);
749 TREE_TYPE (union_type_node
) = union_type_node
;
750 ridpointers
[(int) RID_UNION
] = union_type_node
;
752 enum_type_node
= build_int_2 (enum_type
, 0);
753 TREE_TYPE (enum_type_node
) = enum_type_node
;
754 ridpointers
[(int) RID_ENUM
] = enum_type_node
;
756 /* Create the built-in __null node. Note that we can't yet call for
757 type_for_size here because integer_type_node and so forth are not
758 set up. Therefore, we don't set the type of these nodes until
759 init_decl_processing. */
760 null_node
= build_int_2 (0, 0);
761 ridpointers
[RID_NULL
] = null_node
;
763 token_count
= init_cpp_parse ();
764 interface_unknown
= 1;
766 ggc_add_string_root (&internal_filename
, 1);
767 ggc_add_root (&impl_file_chain
, 1, sizeof (impl_file_chain
),
768 mark_impl_file_chain
);
770 return init_c_lex (filename
);
777 cpp_finish (&parse_in
, 0 /* no printer */);
778 errorcount
+= parse_in
.errors
;
785 yyprint (file
, yychar
, yylval
)
798 case IDENTIFIER_DEFN
:
802 case PRE_PARSED_CLASS_DECL
:
804 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == TEMPLATE_DECL
)
806 fprintf (file
, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t
)));
809 my_friendly_assert (TREE_CODE (t
) == IDENTIFIER_NODE
, 224);
810 if (IDENTIFIER_POINTER (t
))
811 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
815 if (yylval
.ttype
== class_type_node
)
816 fprintf (file
, " `class'");
817 else if (yylval
.ttype
== record_type_node
)
818 fprintf (file
, " `struct'");
819 else if (yylval
.ttype
== union_type_node
)
820 fprintf (file
, " `union'");
821 else if (yylval
.ttype
== enum_type_node
)
822 fprintf (file
, " `enum'");
824 my_friendly_abort (80);
829 if (TREE_CODE (t
) == INTEGER_CST
)
831 #if HOST_BITS_PER_WIDE_INT == 64
832 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
835 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
842 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
848 TREE_INT_CST_HIGH (t
), TREE_INT_CST_LOW (t
));
853 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
854 static int *reduce_count
;
860 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
861 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
864 #ifdef GATHER_STATISTICS
870 reduce_count
[yyn
] += 1;
877 return reduce_count
[*q
] - reduce_count
[*p
];
884 return token_count
[*q
] - token_count
[*p
];
890 print_parse_statistics ()
892 #ifdef GATHER_STATISTICS
896 int maxlen
= REDUCE_LENGTH
;
899 if (reduce_count
[-1] == 0)
902 if (TOKEN_LENGTH
> REDUCE_LENGTH
)
903 maxlen
= TOKEN_LENGTH
;
904 sorted
= (unsigned *) alloca (sizeof (int) * maxlen
);
906 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
908 qsort (sorted
, TOKEN_LENGTH
, sizeof (int), token_cmp
);
909 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
912 if (token_count
[idx
] == 0)
914 if (token_count
[idx
] < token_count
[-1])
916 fprintf (stderr
, "token %d, `%s', count = %d\n",
917 idx
, yytname
[YYTRANSLATE (idx
)], token_count
[idx
]);
919 fprintf (stderr
, "\n");
920 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
922 qsort (sorted
, REDUCE_LENGTH
, sizeof (int), reduce_cmp
);
923 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
926 if (reduce_count
[idx
] == 0)
928 if (reduce_count
[idx
] < reduce_count
[-1])
930 fprintf (stderr
, "rule %d, line %d, count = %d\n",
931 idx
, yyrline
[idx
], reduce_count
[idx
]);
933 fprintf (stderr
, "\n");
939 /* Sets the value of the 'yydebug' variable to VALUE.
940 This is a function so we don't have to have YYDEBUG defined
941 in order to build the compiler. */
951 warning ("YYDEBUG not defined.");
956 /* Mark ARG (which is really a struct impl_files **) for GC. */
959 mark_impl_file_chain (arg
)
962 struct impl_files
*ifs
;
964 ifs
= *(struct impl_files
**) arg
;
967 ggc_mark_string (ifs
->filename
);
972 /* Helper function to load global variables with interface
976 extract_interface_info ()
978 struct c_fileinfo
*finfo
= 0;
980 if (flag_alt_external_templates
)
982 tree til
= tinst_for_decl ();
985 finfo
= get_fileinfo (TINST_FILE (til
));
988 finfo
= get_fileinfo (input_filename
);
990 interface_only
= finfo
->interface_only
;
991 interface_unknown
= finfo
->interface_unknown
;
993 /* This happens to be a convenient place to put this. */
994 if (flag_gnu_xref
) GNU_xref_file (input_filename
);
997 /* Return nonzero if S is not considered part of an
998 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1001 interface_strcmp (s
)
1004 /* Set the interface/implementation bits for this scope. */
1005 struct impl_files
*ifiles
;
1008 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
1010 const char *t1
= ifiles
->filename
;
1013 if (*s1
!= *t1
|| *s1
== 0)
1016 while (*s1
== *t1
&& *s1
!= 0)
1023 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1024 if (index (s1
, '.') || index (t1
, '.'))
1027 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
1038 /* Heuristic to tell whether the user is missing a semicolon
1039 after a struct or enum declaration. Emit an error message
1040 if we know the user has blown it. */
1043 check_for_missing_semicolon (type
)
1051 && yychar
!= IDENTIFIER
1052 && yychar
!= TYPENAME
1053 && yychar
!= CV_QUALIFIER
1054 && yychar
!= SELFNAME
)
1055 || yychar
== 0 /* EOF */)
1057 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
1058 error ("semicolon missing after %s declaration",
1059 TREE_CODE (type
) == ENUMERAL_TYPE
? "enum" : "struct");
1061 cp_error ("semicolon missing after declaration of `%T'", type
);
1062 shadow_tag (build_tree_list (0, type
));
1064 /* Could probably also hack cases where class { ... } f (); appears. */
1069 note_got_semicolon (type
)
1073 my_friendly_abort (60);
1074 if (CLASS_TYPE_P (type
))
1075 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
1079 note_list_got_semicolon (declspecs
)
1084 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
1086 tree type
= TREE_VALUE (link
);
1088 note_got_semicolon (type
);
1094 /* Parse a #pragma whose sole argument is a string constant.
1095 If OPT is true, the argument is optional. */
1097 parse_strconst_pragma (name
, opt
)
1105 if (t
== CPP_STRING
)
1108 if (c_lex (&x
) != CPP_EOF
)
1109 warning ("junk at end of #pragma %s", name
);
1113 if (t
== CPP_EOF
&& opt
)
1116 error ("invalid #pragma %s", name
);
1121 handle_pragma_vtable (dfile
)
1122 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
1124 tree vtbl
= parse_strconst_pragma ("vtable", 0);
1126 if (vtbl
&& vtbl
!= (tree
)-1)
1127 pending_vtables
= tree_cons (NULL_TREE
,
1128 get_identifier (TREE_STRING_POINTER (vtbl
)),
1133 handle_pragma_unit (dfile
)
1134 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
1136 /* Validate syntax, but don't do anything. */
1137 parse_strconst_pragma ("unit", 0);
1141 handle_pragma_interface (dfile
)
1142 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
1144 tree fname
= parse_strconst_pragma ("interface", 1);
1145 struct c_fileinfo
*finfo
;
1146 const char *main_filename
;
1148 if (fname
== (tree
)-1)
1150 else if (fname
== 0)
1151 main_filename
= file_name_nondirectory (input_filename
);
1153 main_filename
= TREE_STRING_POINTER (fname
);
1155 finfo
= get_fileinfo (input_filename
);
1157 if (impl_file_chain
== 0)
1159 /* If this is zero at this point, then we are
1160 auto-implementing. */
1161 if (main_input_filename
== 0)
1162 main_input_filename
= input_filename
;
1165 interface_only
= interface_strcmp (main_filename
);
1166 #ifdef MULTIPLE_SYMBOL_SPACES
1167 if (! interface_only
)
1169 interface_unknown
= 0;
1171 finfo
->interface_only
= interface_only
;
1172 finfo
->interface_unknown
= interface_unknown
;
1175 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1176 We used to only allow this at toplevel, but that restriction was buggy
1177 in older compilers and it seems reasonable to allow it in the headers
1178 themselves, too. It only needs to precede the matching #p interface.
1180 We don't touch interface_only or interface_unknown; the user must specify
1181 a matching #p interface for this to have any effect. */
1184 handle_pragma_implementation (dfile
)
1185 cpp_reader
*dfile ATTRIBUTE_UNUSED
;
1187 tree fname
= parse_strconst_pragma ("implementation", 1);
1188 const char *main_filename
;
1189 struct impl_files
*ifiles
= impl_file_chain
;
1191 if (fname
== (tree
)-1)
1196 if (main_input_filename
)
1197 main_filename
= main_input_filename
;
1199 main_filename
= input_filename
;
1200 main_filename
= file_name_nondirectory (main_filename
);
1204 main_filename
= TREE_STRING_POINTER (fname
);
1207 if (cpp_included (&parse_in
, main_filename
))
1208 warning ("#pragma implementation for %s appears after file is included",
1213 for (; ifiles
; ifiles
= ifiles
->next
)
1215 if (! strcmp (ifiles
->filename
, main_filename
))
1220 ifiles
= (struct impl_files
*) xmalloc (sizeof (struct impl_files
));
1221 ifiles
->filename
= ggc_alloc_string (main_filename
, -1);
1222 ifiles
->next
= impl_file_chain
;
1223 impl_file_chain
= ifiles
;
1228 do_pending_lang_change ()
1230 for (; pending_lang_change
> 0; --pending_lang_change
)
1231 push_lang_context (lang_name_c
);
1232 for (; pending_lang_change
< 0; ++pending_lang_change
)
1233 pop_lang_context ();
1236 /* Return true if d is in a global scope. */
1243 switch (TREE_CODE (d
))
1248 case OVERLOAD
: d
= OVL_FUNCTION (d
); continue;
1249 case TREE_LIST
: d
= TREE_VALUE (d
); continue;
1251 my_friendly_assert (DECL_P (d
), 980629);
1253 return DECL_NAMESPACE_SCOPE_P (d
);
1258 do_identifier (token
, parsing
, args
)
1259 register tree token
;
1264 int lexing
= (parsing
== 1);
1266 if (! lexing
|| IDENTIFIER_OPNAME_P (token
))
1267 id
= lookup_name (token
, 0);
1271 /* Do Koenig lookup if appropriate (inside templates we build lookup
1272 expressions instead).
1274 [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
1275 finds the declaration of a class member function, the associated
1276 namespaces and classes are not considered. */
1278 if (args
&& !current_template_parms
&& (!id
|| is_global (id
)))
1279 id
= lookup_arg_dependent (token
, id
, args
);
1281 /* Remember that this name has been used in the class definition, as per
1284 maybe_note_name_used_in_class (token
, id
);
1286 if (id
== error_mark_node
)
1288 /* lookup_name quietly returns error_mark_node if we're parsing,
1289 as we don't want to complain about an identifier that ends up
1290 being used as a declarator. So we call it again to get the error
1292 id
= lookup_name (token
, 0);
1293 return error_mark_node
;
1296 if (!id
|| (TREE_CODE (id
) == FUNCTION_DECL
1297 && DECL_ANTICIPATED (id
)))
1299 if (current_template_parms
)
1300 return build_min_nt (LOOKUP_EXPR
, token
);
1301 else if (IDENTIFIER_OPNAME_P (token
))
1303 if (token
!= ansi_opname (ERROR_MARK
))
1304 cp_error ("`%D' not defined", token
);
1305 id
= error_mark_node
;
1307 else if (current_function_decl
== 0)
1309 cp_error ("`%D' was not declared in this scope", token
);
1310 id
= error_mark_node
;
1314 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
1315 || IDENTIFIER_ERROR_LOCUS (token
) != current_function_decl
)
1317 static int undeclared_variable_notice
;
1319 cp_error ("`%D' undeclared (first use this function)", token
);
1321 if (! undeclared_variable_notice
)
1323 error ("(Each undeclared identifier is reported only once for each function it appears in.)");
1324 undeclared_variable_notice
= 1;
1327 id
= error_mark_node
;
1328 /* Prevent repeated error messages. */
1329 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
1330 SET_IDENTIFIER_ERROR_LOCUS (token
, current_function_decl
);
1334 if (TREE_CODE (id
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (id
))
1336 tree shadowed
= DECL_SHADOWED_FOR_VAR (id
);
1337 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
1338 && DECL_DEAD_FOR_LOCAL (shadowed
))
1339 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
1341 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id
));
1344 if (!DECL_ERROR_REPORTED (id
))
1346 warning ("name lookup of `%s' changed",
1347 IDENTIFIER_POINTER (token
));
1348 cp_warning_at (" matches this `%D' under ISO standard rules",
1350 cp_warning_at (" matches this `%D' under old rules", id
);
1351 DECL_ERROR_REPORTED (id
) = 1;
1355 else if (!DECL_ERROR_REPORTED (id
))
1357 DECL_ERROR_REPORTED (id
) = 1;
1358 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (id
)))
1360 error ("name lookup of `%s' changed for new ISO `for' scoping",
1361 IDENTIFIER_POINTER (token
));
1362 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id
);
1363 id
= error_mark_node
;
1367 pedwarn ("name lookup of `%s' changed for new ISO `for' scoping",
1368 IDENTIFIER_POINTER (token
));
1369 cp_pedwarn_at (" using obsolete binding at `%D'", id
);
1373 /* TREE_USED is set in `hack_identifier'. */
1374 if (TREE_CODE (id
) == CONST_DECL
)
1377 if (IDENTIFIER_CLASS_VALUE (token
) == id
)
1378 enforce_access (CP_DECL_CONTEXT(id
), id
);
1379 if (!processing_template_decl
|| DECL_TEMPLATE_PARM_P (id
))
1380 id
= DECL_INITIAL (id
);
1383 id
= hack_identifier (id
, token
);
1385 /* We must look up dependent names when the template is
1386 instantiated, not while parsing it. For now, we don't
1387 distinguish between dependent and independent names. So, for
1388 example, we look up all overloaded functions at
1389 instantiation-time, even though in some cases we should just use
1390 the DECL we have here. We also use LOOKUP_EXPRs to find things
1391 like local variables, rather than creating TEMPLATE_DECLs for the
1392 local variables and then finding matching instantiations. */
1393 if (current_template_parms
1394 && (is_overloaded_fn (id
)
1395 || (TREE_CODE (id
) == VAR_DECL
1396 && CP_DECL_CONTEXT (id
)
1397 && TREE_CODE (CP_DECL_CONTEXT (id
)) == FUNCTION_DECL
)
1398 || TREE_CODE (id
) == PARM_DECL
1399 || TREE_CODE (id
) == RESULT_DECL
1400 || TREE_CODE (id
) == USING_DECL
))
1401 id
= build_min_nt (LOOKUP_EXPR
, token
);
1407 do_scoped_id (token
, parsing
)
1412 /* during parsing, this is ::name. Otherwise, it is black magic. */
1415 id
= make_node (CPLUS_BINDING
);
1416 if (!qualified_lookup_using_namespace (token
, global_namespace
, id
, 0))
1419 id
= BINDING_VALUE (id
);
1422 id
= IDENTIFIER_GLOBAL_VALUE (token
);
1423 if (parsing
&& yychar
== YYEMPTY
)
1427 if (processing_template_decl
)
1429 id
= build_min_nt (LOOKUP_EXPR
, token
);
1430 LOOKUP_EXPR_GLOBAL (id
) = 1;
1433 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
)
1434 cp_error ("`::%D' undeclared (first use here)", token
);
1435 id
= error_mark_node
;
1436 /* Prevent repeated error messages. */
1437 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
1441 if (TREE_CODE (id
) == ADDR_EXPR
)
1442 mark_used (TREE_OPERAND (id
, 0));
1443 else if (TREE_CODE (id
) != OVERLOAD
)
1446 if (TREE_CODE (id
) == CONST_DECL
&& ! processing_template_decl
)
1448 /* XXX CHS - should we set TREE_USED of the constant? */
1449 id
= DECL_INITIAL (id
);
1450 /* This is to prevent an enum whose value is 0
1451 from being considered a null pointer constant. */
1452 id
= build1 (NOP_EXPR
, TREE_TYPE (id
), id
);
1453 TREE_CONSTANT (id
) = 1;
1456 if (processing_template_decl
)
1458 if (is_overloaded_fn (id
))
1460 id
= build_min_nt (LOOKUP_EXPR
, token
);
1461 LOOKUP_EXPR_GLOBAL (id
) = 1;
1464 /* else just use the decl */
1466 return convert_from_reference (id
);
1470 identifier_typedecl_value (node
)
1474 type
= IDENTIFIER_TYPE_VALUE (node
);
1475 if (type
== NULL_TREE
)
1478 if (IDENTIFIER_BINDING (node
))
1480 t
= IDENTIFIER_VALUE (node
);
1481 if (t
&& TREE_CODE (t
) == TYPE_DECL
&& TREE_TYPE (t
) == type
)
1484 if (IDENTIFIER_NAMESPACE_VALUE (node
))
1486 t
= IDENTIFIER_NAMESPACE_VALUE (node
);
1487 if (t
&& TREE_CODE (t
) == TYPE_DECL
&& TREE_TYPE (t
) == type
)
1491 /* Will this one ever happen? */
1492 if (TYPE_MAIN_DECL (type
))
1493 return TYPE_MAIN_DECL (type
);
1495 /* We used to do an internal error of 62 here, but instead we will
1496 handle the return of a null appropriately in the callers. */
1500 #ifdef GATHER_STATISTICS
1501 /* The original for tree_node_kind is in the toplevel tree.c; changes there
1502 need to be brought into here, unless this were actually put into a header
1504 /* Statistics-gathering stuff. */
1525 extern int tree_node_counts
[];
1526 extern int tree_node_sizes
[];
1530 build_lang_decl (code
, name
, type
)
1531 enum tree_code code
;
1537 t
= build_decl (code
, name
, type
);
1538 retrofit_lang_decl (t
);
1543 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
1544 and pushdecl (for functions generated by the backend). */
1547 retrofit_lang_decl (t
)
1550 struct lang_decl
*ld
;
1553 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
1554 size
= sizeof (struct lang_decl
);
1556 size
= sizeof (struct lang_decl_flags
);
1558 ld
= (struct lang_decl
*) ggc_alloc_cleared (size
);
1560 DECL_LANG_SPECIFIC (t
) = ld
;
1561 if (current_lang_name
== lang_name_cplusplus
)
1562 DECL_LANGUAGE (t
) = lang_cplusplus
;
1563 else if (current_lang_name
== lang_name_c
)
1564 DECL_LANGUAGE (t
) = lang_c
;
1565 else if (current_lang_name
== lang_name_java
)
1566 DECL_LANGUAGE (t
) = lang_java
;
1567 else my_friendly_abort (64);
1569 #ifdef GATHER_STATISTICS
1570 tree_node_counts
[(int)lang_decl
] += 1;
1571 tree_node_sizes
[(int)lang_decl
] += size
;
1576 copy_lang_decl (node
)
1580 struct lang_decl
*ld
;
1582 if (! DECL_LANG_SPECIFIC (node
))
1585 if (!CAN_HAVE_FULL_LANG_DECL_P (node
))
1586 size
= sizeof (struct lang_decl_flags
);
1588 size
= sizeof (struct lang_decl
);
1589 ld
= (struct lang_decl
*) ggc_alloc (size
);
1590 bcopy ((char *)DECL_LANG_SPECIFIC (node
), (char *)ld
, size
);
1591 DECL_LANG_SPECIFIC (node
) = ld
;
1594 /* Copy DECL, including any language-specific parts. */
1602 copy
= copy_node (decl
);
1603 copy_lang_decl (copy
);
1608 cp_make_lang_type (code
)
1609 enum tree_code code
;
1611 register tree t
= make_node (code
);
1613 /* Set up some flags that give proper default behavior. */
1614 if (IS_AGGR_TYPE_CODE (code
))
1616 struct lang_type
*pi
;
1618 pi
= (struct lang_type
*) ggc_alloc (sizeof (struct lang_type
));
1619 bzero ((char *) pi
, (int) sizeof (struct lang_type
));
1621 TYPE_LANG_SPECIFIC (t
) = pi
;
1622 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, interface_unknown
);
1623 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
1625 /* Make sure this is laid out, for ease of use later. In the
1626 presence of parse errors, the normal was of assuring this
1627 might not ever get executed, so we lay it out *immediately*. */
1628 build_pointer_type (t
);
1630 #ifdef GATHER_STATISTICS
1631 tree_node_counts
[(int)lang_type
] += 1;
1632 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
1636 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
1637 TYPE_ALIAS_SET is initialized to -1 by default, so we must
1639 TYPE_ALIAS_SET (t
) = 0;
1641 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
1642 since they can be virtual base types, and we then need a
1643 canonical binfo for them. Ideally, this would be done lazily for
1645 if (IS_AGGR_TYPE_CODE (code
) || code
== TEMPLATE_TYPE_PARM
)
1646 TYPE_BINFO (t
) = make_binfo (size_zero_node
, t
, NULL_TREE
, NULL_TREE
);
1652 make_aggr_type (code
)
1653 enum tree_code code
;
1655 tree t
= cp_make_lang_type (code
);
1657 if (IS_AGGR_TYPE_CODE (code
))
1658 SET_IS_AGGR_TYPE (t
, 1);
1664 compiler_error
VPARAMS ((const char *msg
, ...))
1666 #ifndef ANSI_PROTOTYPES
1674 #ifndef ANSI_PROTOTYPES
1675 msg
= va_arg (ap
, const char *);
1678 vsprintf (buf
, msg
, ap
);
1680 error_with_file_and_line (input_filename
, lineno
, "%s (compiler error)", buf
);
1683 /* Return the type-qualifier corresponding to the identifier given by
1687 cp_type_qual_from_rid (rid
)
1690 if (rid
== ridpointers
[(int) RID_CONST
])
1691 return TYPE_QUAL_CONST
;
1692 else if (rid
== ridpointers
[(int) RID_VOLATILE
])
1693 return TYPE_QUAL_VOLATILE
;
1694 else if (rid
== ridpointers
[(int) RID_RESTRICT
])
1695 return TYPE_QUAL_RESTRICT
;
1697 my_friendly_abort (0);
1698 return TYPE_UNQUALIFIED
;