1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is the lexical analyzer for GNU C++. */
25 /* Cause the `yydebug' variable to be defined. */
42 #ifdef MULTIBYTE_CHARS
46 #ifndef GET_ENVIRONMENT
47 #define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
55 #define DIR_SEPARATOR '/'
58 extern struct obstack permanent_obstack;
59 extern struct obstack *current_obstack, *saveable_obstack;
61 extern void yyprint PROTO((FILE *, int, YYSTYPE));
62 extern void compiler_error PROTO((char *, HOST_WIDE_INT,
65 static tree get_time_identifier PROTO((char *));
66 static int check_newline PROTO((void));
67 static int skip_white_space PROTO((int));
68 static void finish_defarg PROTO((void));
69 static int my_get_run_time PROTO((void));
70 static int get_last_nonwhite_on_line PROTO((void));
71 static int interface_strcmp PROTO((char *));
72 static int readescape PROTO((int *));
73 static char *extend_token_buffer PROTO((char *));
74 static void consume_string PROTO((struct obstack *, int));
75 static void set_typedecl_interface_info PROTO((tree, tree));
76 static void feed_defarg PROTO((tree, tree));
77 static int set_vardecl_interface_info PROTO((tree, tree));
78 static void store_pending_inline PROTO((tree, struct pending_inline *));
79 static void reinit_parse_for_expr PROTO((struct obstack *));
80 static int *init_cpp_parse PROTO((void));
81 static int handle_cp_pragma PROTO((char *));
82 #ifdef HANDLE_SYSV_PRAGMA
83 static int handle_sysv_pragma PROTO((int));
85 #ifdef GATHER_STATISTICS
87 static int reduce_cmp PROTO((int *, int *));
88 static int token_cmp PROTO((int *, int *));
92 /* Given a file name X, return the nondirectory portion.
93 Keep in mind that X can be computed more than once. */
95 file_name_nondirectory (x)
98 char *tmp = (char *) rindex (x, '/');
99 if (DIR_SEPARATOR != '/' && ! tmp)
100 tmp = (char *) rindex (x, DIR_SEPARATOR);
102 return (char *) (tmp + 1);
107 /* This obstack is needed to hold text. It is not safe to use
108 TOKEN_BUFFER because `check_newline' calls `yylex'. */
109 struct obstack inline_text_obstack;
110 char *inline_text_firstobj;
114 extern cpp_reader parse_in;
115 extern cpp_options parse_options;
116 extern unsigned char *yy_cur, *yy_lim;
122 /* Pending language change.
123 Positive is push count, negative is pop count. */
124 int pending_lang_change = 0;
126 /* Wrap the current header file in extern "C". */
127 static int c_header_level = 0;
129 extern int first_token;
130 extern struct obstack token_obstack;
132 /* ??? Don't really know where this goes yet. */
136 extern void put_back (/* int */);
137 extern int input_redirected ();
138 extern void feed_input (/* char *, int */);
141 /* Holds translations from TREE_CODEs to operator name strings,
142 i.e., opname_tab[PLUS_EXPR] == "+". */
146 extern int yychar; /* the lookahead symbol */
147 extern YYSTYPE yylval; /* the semantic value of the */
148 /* lookahead symbol */
151 YYLTYPE yylloc; /* location data for the lookahead */
156 /* the declaration found for the last IDENTIFIER token read in.
157 yylex must look this up to detect typedefs, which get token type TYPENAME,
158 so it is left around in case the identifier is not a typedef but is
159 used in a context which makes it a reference to a variable. */
162 /* The elements of `ridpointers' are identifier nodes
163 for the reserved type names and storage classes.
164 It is indexed by a RID_... value. */
165 tree ridpointers[(int) RID_MAX];
167 /* We may keep statistics about how long which files took to compile. */
168 static int header_time, body_time;
169 static tree filename_times;
170 static tree this_filename_time;
172 /* Array for holding counts of the numbers of tokens seen. */
173 extern int *token_count;
175 /* Return something to represent absolute declarators containing a *.
176 TARGET is the absolute declarator that the * contains.
177 CV_QUALIFIERS is a list of modifiers such as const or volatile
178 to apply to the pointer type, represented as identifiers.
180 We return an INDIRECT_REF whose "contents" are TARGET
181 and whose type is the modifier list. */
184 make_pointer_declarator (cv_qualifiers, target)
185 tree cv_qualifiers, target;
187 if (target && TREE_CODE (target) == IDENTIFIER_NODE
188 && ANON_AGGRNAME_P (target))
189 error ("type name expected before `*'");
190 target = build_parse_node (INDIRECT_REF, target);
191 TREE_TYPE (target) = cv_qualifiers;
195 /* Return something to represent absolute declarators containing a &.
196 TARGET is the absolute declarator that the & contains.
197 CV_QUALIFIERS is a list of modifiers such as const or volatile
198 to apply to the reference type, represented as identifiers.
200 We return an ADDR_EXPR whose "contents" are TARGET
201 and whose type is the modifier list. */
204 make_reference_declarator (cv_qualifiers, target)
205 tree cv_qualifiers, target;
209 if (TREE_CODE (target) == ADDR_EXPR)
211 error ("cannot declare references to references");
214 if (TREE_CODE (target) == INDIRECT_REF)
216 error ("cannot declare pointers to references");
219 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
220 error ("type name expected before `&'");
222 target = build_parse_node (ADDR_EXPR, target);
223 TREE_TYPE (target) = cv_qualifiers;
228 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
229 tree target, parms, cv_qualifiers, exception_specification;
231 target = build_parse_node (CALL_EXPR, target, parms, cv_qualifiers);
232 TREE_TYPE (target) = exception_specification;
237 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
238 tree call_declarator, cv_qualifiers, exception_specification;
240 TREE_OPERAND (call_declarator, 2) = cv_qualifiers;
241 TREE_TYPE (call_declarator) = exception_specification;
244 /* Build names and nodes for overloaded operators. */
246 tree ansi_opname[LAST_CPLUS_TREE_CODE];
247 tree ansi_assopname[LAST_CPLUS_TREE_CODE];
250 operator_name_string (name)
253 char *opname = IDENTIFIER_POINTER (name) + 2;
257 /* Works for builtin and user defined types. */
258 if (IDENTIFIER_GLOBAL_VALUE (name)
259 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
260 return IDENTIFIER_POINTER (name);
262 if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
266 opname_table = ansi_assopname;
271 opname_table = ansi_opname;
274 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
276 if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
277 && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
281 if (i == LAST_CPLUS_TREE_CODE)
282 return "<invalid operator>";
285 return assignop_tab[i];
287 return opname_tab[i];
290 int interface_only; /* whether or not current file is only for
291 interface definitions. */
292 int interface_unknown; /* whether or not we know this class
293 to behave according to #pragma interface. */
295 /* lexical analyzer */
297 #ifndef WCHAR_TYPE_SIZE
299 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
301 #define WCHAR_TYPE_SIZE BITS_PER_WORD
305 /* Number of bytes in a wide character. */
306 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
308 static int maxtoken; /* Current nominal length of token buffer. */
309 char *token_buffer; /* Pointer to token buffer.
310 Actual allocated length is maxtoken + 2. */
315 /* Nonzero tells yylex to ignore \ in string constants. */
316 static int ignore_escape_flag = 0;
319 get_time_identifier (name)
322 tree time_identifier;
323 int len = strlen (name);
324 char *buf = (char *) alloca (len + 6);
325 strcpy (buf, "file ");
326 bcopy (name, buf+5, len);
328 time_identifier = get_identifier (buf);
329 if (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
331 push_obstacks_nochange ();
332 end_temporary_allocation ();
333 IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
334 IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
335 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier, filename_times);
336 filename_times = time_identifier;
339 return time_identifier;
348 int old_quiet_flag = quiet_flag;
351 this_time = get_run_time ();
352 quiet_flag = old_quiet_flag;
356 /* Table indexed by tree code giving a string containing a character
357 classifying the tree code. Possibilities are
358 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
360 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
362 char cplus_tree_code_type[] = {
364 #include "cp-tree.def"
368 /* Table indexed by tree code giving number of expression
369 operands beyond the fixed part of the node structure.
370 Not used for types or decls. */
372 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
374 int cplus_tree_code_length[] = {
376 #include "cp-tree.def"
380 /* Names of tree components.
381 Used for printing out the tree and error messages. */
382 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
384 char *cplus_tree_code_name[] = {
386 #include "cp-tree.def"
390 /* toplev.c needs to call these. */
395 /* Default exceptions on. */
403 /* the beginning of the file is a new line; check for # */
404 /* With luck, we discover the real source file's name from that
405 and put it in input_filename. */
406 put_back (check_newline ());
408 if (flag_gnu_xref) GNU_xref_begin (input_filename);
409 init_repo (input_filename);
415 extern int errorcount, sorrycount;
416 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
426 init_filename_times ()
428 this_filename_time = get_time_identifier ("<top level>");
429 if (flag_detailed_statistics)
432 body_time = my_get_run_time ();
433 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
437 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
438 Stuck this hack in to get the files open correctly; this is called
439 in place of init_parse if we are an unexec'd binary. */
443 reinit_lang_specific ()
445 init_filename_times ();
446 reinit_search_statistics ();
453 #ifdef GATHER_STATISTICS
455 reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
456 bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
458 token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
459 bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
467 init_parse (filename)
470 extern int flag_no_gnu_keywords;
471 extern int flag_operator_names;
475 #ifdef MULTIBYTE_CHARS
476 /* Change to the native locale for multibyte conversions. */
477 setlocale (LC_CTYPE, "");
478 GET_ENVIRONMENT (literal_codeset, "LANG");
485 parse_in.show_column = 1;
486 if (! cpp_start_read (&parse_in, filename))
489 /* Open input file. */
490 if (filename == 0 || !strcmp (filename, "-"))
496 finput = fopen (filename, "r");
498 pfatal_with_name (filename);
500 #ifdef IO_BUFFER_SIZE
501 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
503 #endif /* !USE_CPPLIB */
505 /* Initialize the lookahead machinery. */
508 /* Make identifier nodes long enough for the language-specific slots. */
509 set_identifier_size (sizeof (struct lang_identifier));
510 decl_printable_name = lang_printable_name;
512 init_cplus_expand ();
514 bcopy (cplus_tree_code_type,
515 tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
516 (int)LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
517 bcopy ((char *)cplus_tree_code_length,
518 (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
519 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
520 bcopy ((char *)cplus_tree_code_name,
521 (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
522 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
524 opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
525 bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
526 assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
527 bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
529 ansi_opname[0] = get_identifier ("<invalid operator>");
530 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
532 ansi_opname[i] = ansi_opname[0];
533 ansi_assopname[i] = ansi_opname[0];
536 ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
537 IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
538 ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
539 ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
540 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
541 ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
542 ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
543 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
544 ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
545 IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
546 ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
547 ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
548 ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
549 ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
550 IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
551 ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
552 ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
553 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
554 ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
555 ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
556 IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
557 ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
558 IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
559 ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
560 IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
561 ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
562 IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
563 ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
564 IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
565 ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
566 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
567 ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
568 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
569 ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
570 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
571 ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
572 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
573 ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
574 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
575 ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
576 ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
577 IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
578 ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
579 ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
580 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
581 ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
582 IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
583 ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
584 IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
585 ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
586 ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
587 ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
588 ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
589 ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
590 ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
591 ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
592 ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
593 ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
594 IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
595 ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
596 IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
597 ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
598 ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
599 ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
600 IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
601 ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
602 IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
603 ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
604 IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
605 ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
606 IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
607 ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
608 IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
609 ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
610 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
611 ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
612 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
613 ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
614 ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
615 ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
616 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
617 ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
618 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
619 ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
620 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
621 ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
622 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
623 ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
624 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
625 ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
626 ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
627 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
628 ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
629 IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
630 ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
631 IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
632 ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
633 IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
634 ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
635 IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
636 ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
637 IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
638 ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
639 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
640 ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
641 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
642 ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
643 IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
645 /* This is not true: these operators are not defined in ANSI,
646 but we need them anyway. */
647 ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
648 IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
649 ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
650 IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
651 ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
652 IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
653 ansi_opname[(int) SIZEOF_EXPR] = get_identifier ("__sz");
654 IDENTIFIER_OPNAME_P (ansi_opname[(int) SIZEOF_EXPR]) = 1;
658 gcc_obstack_init (&inline_text_obstack);
659 inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
661 /* Start it at 0, because check_newline is called at the very beginning
662 and will increment it to 1. */
664 input_filename = "<internal>";
665 current_function_decl = NULL;
668 token_buffer = (char *) xmalloc (maxtoken + 2);
670 ridpointers[(int) RID_INT] = get_identifier ("int");
671 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
672 build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
673 ridpointers[(int) RID_BOOL] = get_identifier ("bool");
674 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_BOOL],
675 build_tree_list (NULL_TREE, ridpointers[(int) RID_BOOL]));
676 ridpointers[(int) RID_CHAR] = get_identifier ("char");
677 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
678 build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
679 ridpointers[(int) RID_VOID] = get_identifier ("void");
680 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
681 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
682 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
683 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
684 build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
685 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
686 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
687 build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
688 ridpointers[(int) RID_SHORT] = get_identifier ("short");
689 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
690 build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
691 ridpointers[(int) RID_LONG] = get_identifier ("long");
692 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
693 build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
694 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
695 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
696 build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
697 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
698 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
699 build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
700 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
701 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
702 build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
703 ridpointers[(int) RID_CONST] = get_identifier ("const");
704 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
705 build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
706 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
707 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
708 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
709 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
710 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
711 build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
712 ridpointers[(int) RID_STATIC] = get_identifier ("static");
713 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
714 build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
715 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
716 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
717 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
718 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
719 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
720 build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
721 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
722 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
723 build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
724 ridpointers[(int) RID_COMPLEX] = get_identifier ("__complex");
725 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_COMPLEX],
726 build_tree_list (NULL_TREE, ridpointers[(int) RID_COMPLEX]));
728 /* C++ extensions. These are probably not correctly named. */
729 ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
730 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
731 build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
732 class_type_node = build_int_2 (class_type, 0);
733 TREE_TYPE (class_type_node) = class_type_node;
734 ridpointers[(int) RID_CLASS] = class_type_node;
736 record_type_node = build_int_2 (record_type, 0);
737 TREE_TYPE (record_type_node) = record_type_node;
738 ridpointers[(int) RID_RECORD] = record_type_node;
740 union_type_node = build_int_2 (union_type, 0);
741 TREE_TYPE (union_type_node) = union_type_node;
742 ridpointers[(int) RID_UNION] = union_type_node;
744 enum_type_node = build_int_2 (enum_type, 0);
745 TREE_TYPE (enum_type_node) = enum_type_node;
746 ridpointers[(int) RID_ENUM] = enum_type_node;
748 ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
749 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
750 build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
751 ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
752 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPLICIT],
753 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPLICIT]));
754 ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
755 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
756 build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
758 ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
759 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
760 build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
761 ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
762 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
763 build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
764 ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
765 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
766 build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
767 ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
768 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TEMPLATE],
769 build_tree_list (NULL_TREE, ridpointers[(int) RID_TEMPLATE]));
770 /* This is for ANSI C++. */
771 ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
772 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
773 build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
775 /* Signature handling extensions. */
776 signature_type_node = build_int_2 (signature_type, 0);
777 TREE_TYPE (signature_type_node) = signature_type_node;
778 ridpointers[(int) RID_SIGNATURE] = signature_type_node;
780 /* Create the built-in __null node. Note that we can't yet call for
781 type_for_size here because integer_type_node and so forth are not
782 set up. Therefore, we don't set the type of these nodes until
783 init_decl_processing. */
784 null_node = build_int_2 (0, 0);
785 ridpointers[RID_NULL] = null_node;
787 opname_tab[(int) COMPONENT_REF] = "->";
788 opname_tab[(int) MEMBER_REF] = "->*";
789 opname_tab[(int) INDIRECT_REF] = "*";
790 opname_tab[(int) ARRAY_REF] = "[]";
791 opname_tab[(int) MODIFY_EXPR] = "=";
792 opname_tab[(int) NEW_EXPR] = "new";
793 opname_tab[(int) DELETE_EXPR] = "delete";
794 opname_tab[(int) VEC_NEW_EXPR] = "new []";
795 opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
796 opname_tab[(int) COND_EXPR] = "?:";
797 opname_tab[(int) CALL_EXPR] = "()";
798 opname_tab[(int) PLUS_EXPR] = "+";
799 opname_tab[(int) MINUS_EXPR] = "-";
800 opname_tab[(int) MULT_EXPR] = "*";
801 opname_tab[(int) TRUNC_DIV_EXPR] = "/";
802 opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
803 opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
804 opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
805 opname_tab[(int) TRUNC_MOD_EXPR] = "%";
806 opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
807 opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
808 opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
809 opname_tab[(int) NEGATE_EXPR] = "-";
810 opname_tab[(int) MIN_EXPR] = "<?";
811 opname_tab[(int) MAX_EXPR] = ">?";
812 opname_tab[(int) ABS_EXPR] = "abs";
813 opname_tab[(int) FFS_EXPR] = "ffs";
814 opname_tab[(int) LSHIFT_EXPR] = "<<";
815 opname_tab[(int) RSHIFT_EXPR] = ">>";
816 opname_tab[(int) BIT_IOR_EXPR] = "|";
817 opname_tab[(int) BIT_XOR_EXPR] = "^";
818 opname_tab[(int) BIT_AND_EXPR] = "&";
819 opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
820 opname_tab[(int) BIT_NOT_EXPR] = "~";
821 opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
822 opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
823 opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
824 opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
825 opname_tab[(int) TRUTH_NOT_EXPR] = "!";
826 opname_tab[(int) LT_EXPR] = "<";
827 opname_tab[(int) LE_EXPR] = "<=";
828 opname_tab[(int) GT_EXPR] = ">";
829 opname_tab[(int) GE_EXPR] = ">=";
830 opname_tab[(int) EQ_EXPR] = "==";
831 opname_tab[(int) NE_EXPR] = "!=";
832 opname_tab[(int) IN_EXPR] = "in";
833 opname_tab[(int) RANGE_EXPR] = "...";
834 opname_tab[(int) CONVERT_EXPR] = "+";
835 opname_tab[(int) ADDR_EXPR] = "&";
836 opname_tab[(int) PREDECREMENT_EXPR] = "--";
837 opname_tab[(int) PREINCREMENT_EXPR] = "++";
838 opname_tab[(int) POSTDECREMENT_EXPR] = "--";
839 opname_tab[(int) POSTINCREMENT_EXPR] = "++";
840 opname_tab[(int) COMPOUND_EXPR] = ",";
842 assignop_tab[(int) NOP_EXPR] = "=";
843 assignop_tab[(int) PLUS_EXPR] = "+=";
844 assignop_tab[(int) CONVERT_EXPR] = "+=";
845 assignop_tab[(int) MINUS_EXPR] = "-=";
846 assignop_tab[(int) NEGATE_EXPR] = "-=";
847 assignop_tab[(int) MULT_EXPR] = "*=";
848 assignop_tab[(int) INDIRECT_REF] = "*=";
849 assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
850 assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
851 assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
852 assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
853 assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
854 assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
855 assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
856 assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
857 assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
858 assignop_tab[(int) MIN_EXPR] = "<?=";
859 assignop_tab[(int) MAX_EXPR] = ">?=";
860 assignop_tab[(int) LSHIFT_EXPR] = "<<=";
861 assignop_tab[(int) RSHIFT_EXPR] = ">>=";
862 assignop_tab[(int) BIT_IOR_EXPR] = "|=";
863 assignop_tab[(int) BIT_XOR_EXPR] = "^=";
864 assignop_tab[(int) BIT_AND_EXPR] = "&=";
865 assignop_tab[(int) ADDR_EXPR] = "&=";
867 init_filename_times ();
869 /* Some options inhibit certain reserved words.
870 Clear those words out of the hash table so they won't be recognized. */
871 #define UNSET_RESERVED_WORD(STRING) \
872 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
873 if (s) s->name = ""; } while (0)
876 /* let's parse things, and if they use it, then give them an error. */
877 if (!flag_exceptions)
879 UNSET_RESERVED_WORD ("throw");
880 UNSET_RESERVED_WORD ("try");
881 UNSET_RESERVED_WORD ("catch");
885 if (!flag_rtti || flag_no_gnu_keywords)
887 UNSET_RESERVED_WORD ("classof");
888 UNSET_RESERVED_WORD ("headof");
891 if (! flag_handle_signatures || flag_no_gnu_keywords)
893 /* Easiest way to not recognize signature
894 handling extensions... */
895 UNSET_RESERVED_WORD ("signature");
896 UNSET_RESERVED_WORD ("sigof");
898 if (flag_no_asm || flag_no_gnu_keywords)
899 UNSET_RESERVED_WORD ("typeof");
900 if (! flag_operator_names)
902 /* These are new ANSI keywords that may break code. */
903 UNSET_RESERVED_WORD ("and");
904 UNSET_RESERVED_WORD ("and_eq");
905 UNSET_RESERVED_WORD ("bitand");
906 UNSET_RESERVED_WORD ("bitor");
907 UNSET_RESERVED_WORD ("compl");
908 UNSET_RESERVED_WORD ("not");
909 UNSET_RESERVED_WORD ("not_eq");
910 UNSET_RESERVED_WORD ("or");
911 UNSET_RESERVED_WORD ("or_eq");
912 UNSET_RESERVED_WORD ("xor");
913 UNSET_RESERVED_WORD ("xor_eq");
916 token_count = init_cpp_parse ();
917 interface_unknown = 1;
926 cpp_finish (&parse_in);
933 reinit_parse_for_function ()
935 current_base_init_list = NULL_TREE;
936 current_member_init_list = NULL_TREE;
943 yyprint (file, yychar, yylval)
955 case IDENTIFIER_DEFN:
959 case PRE_PARSED_CLASS_DECL:
961 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
963 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
966 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
967 if (IDENTIFIER_POINTER (t))
968 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
971 if (yylval.ttype == class_type_node)
972 fprintf (file, " `class'");
973 else if (yylval.ttype == record_type_node)
974 fprintf (file, " `struct'");
975 else if (yylval.ttype == union_type_node)
976 fprintf (file, " `union'");
977 else if (yylval.ttype == enum_type_node)
978 fprintf (file, " `enum'");
979 else if (yylval.ttype == signature_type_node)
980 fprintf (file, " `signature'");
982 my_friendly_abort (80);
987 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
988 static int *reduce_count;
994 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
995 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
998 #ifdef GATHER_STATISTICS
1004 reduce_count[yyn] += 1;
1011 return reduce_count[*q] - reduce_count[*p];
1018 return token_count[*q] - token_count[*p];
1024 print_parse_statistics ()
1026 #ifdef GATHER_STATISTICS
1027 #ifdef REDUCE_LENGTH
1030 int maxlen = REDUCE_LENGTH;
1033 if (reduce_count[-1] == 0)
1036 if (TOKEN_LENGTH > REDUCE_LENGTH)
1037 maxlen = TOKEN_LENGTH;
1038 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1040 for (i = 0; i < TOKEN_LENGTH; i++)
1042 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1043 for (i = 0; i < TOKEN_LENGTH; i++)
1045 int idx = sorted[i];
1046 if (token_count[idx] == 0)
1048 if (token_count[idx] < token_count[-1])
1050 fprintf (stderr, "token %d, `%s', count = %d\n",
1051 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
1053 fprintf (stderr, "\n");
1054 for (i = 0; i < REDUCE_LENGTH; i++)
1056 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1057 for (i = 0; i < REDUCE_LENGTH; i++)
1059 int idx = sorted[i];
1060 if (reduce_count[idx] == 0)
1062 if (reduce_count[idx] < reduce_count[-1])
1064 fprintf (stderr, "rule %d, line %d, count = %d\n",
1065 idx, yyrline[idx], reduce_count[idx]);
1067 fprintf (stderr, "\n");
1073 /* Sets the value of the 'yydebug' variable to VALUE.
1074 This is a function so we don't have to have YYDEBUG defined
1075 in order to build the compiler. */
1085 warning ("YYDEBUG not defined.");
1090 /* Functions and data structures for #pragma interface.
1092 `#pragma implementation' means that the main file being compiled
1093 is considered to implement (provide) the classes that appear in
1094 its main body. I.e., if this is file "foo.cc", and class `bar'
1095 is defined in "foo.cc", then we say that "foo.cc implements bar".
1097 All main input files "implement" themselves automagically.
1099 `#pragma interface' means that unless this file (of the form "foo.h"
1100 is not presently being included by file "foo.cc", the
1101 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1102 of the vtables nor any of the inline functions defined in foo.h
1103 will ever be output.
1105 There are cases when we want to link files such as "defs.h" and
1106 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1107 and "main.cc" has `#pragma implementation "defs.h"'. */
1112 struct impl_files *next;
1115 static struct impl_files *impl_file_chain;
1117 /* Helper function to load global variables with interface
1121 extract_interface_info ()
1125 if (flag_alt_external_templates)
1127 struct tinst_level *til = tinst_for_decl ();
1130 fileinfo = get_time_identifier (til->file);
1133 fileinfo = get_time_identifier (input_filename);
1134 fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
1135 interface_only = TREE_INT_CST_LOW (fileinfo);
1136 interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1139 /* Return nonzero if S is not considered part of an
1140 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1143 interface_strcmp (s)
1146 /* Set the interface/implementation bits for this scope. */
1147 struct impl_files *ifiles;
1150 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1152 char *t1 = ifiles->filename;
1155 if (*s1 != *t1 || *s1 == 0)
1158 while (*s1 == *t1 && *s1 != 0)
1165 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1166 if (index (s1, '.') || index (t1, '.'))
1169 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1181 set_typedecl_interface_info (prev, vars)
1184 tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
1185 tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
1186 tree type = TREE_TYPE (vars);
1188 CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
1189 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars)));
1193 set_vardecl_interface_info (prev, vars)
1196 tree type = DECL_CONTEXT (vars);
1198 if (CLASSTYPE_INTERFACE_KNOWN (type))
1200 if (CLASSTYPE_INTERFACE_ONLY (type))
1201 set_typedecl_interface_info (prev, TYPE_MAIN_DECL (type));
1203 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
1204 DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
1205 TREE_PUBLIC (vars) = 1;
1211 /* Called from the top level: if there are any pending inlines to
1212 do, set up to process them now. This function sets up the first function
1213 to be parsed; after it has been, the rule for fndef in parse.y will
1214 call process_next_inline to start working on the next one. */
1217 do_pending_inlines ()
1219 struct pending_inline *t;
1222 /* Oops, we're still dealing with the last batch. */
1223 if (yychar == PRE_PARSED_FUNCTION_DECL)
1226 /* Reverse the pending inline functions, since
1227 they were cons'd instead of appended. */
1229 struct pending_inline *prev = 0, *tail;
1230 t = pending_inlines;
1231 pending_inlines = 0;
1246 /* Now start processing the first inline function. */
1247 context = hack_decl_function_context (t->fndecl);
1249 push_cp_function_context (context);
1250 maybe_begin_member_template_processing (t->fndecl);
1253 feed_input (t->buf, t->len);
1256 if (input_filename != t->filename)
1258 input_filename = t->filename;
1259 /* Get interface/implementation back in sync. */
1260 extract_interface_info ();
1263 input_filename = t->filename;
1264 interface_unknown = t->interface == 1;
1265 interface_only = t->interface == 0;
1267 yychar = PRE_PARSED_FUNCTION_DECL;
1269 /* Pass back a handle on the rest of the inline functions, so that they
1270 can be processed later. */
1271 yylval.ttype = build_tree_list ((tree) t, t->fndecl);
1272 DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
1275 static int nextchar = -1;
1277 /* Called from the fndecl rule in the parser when the function just parsed
1278 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1279 do_pending_inlines). */
1282 process_next_inline (t)
1286 struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
1287 context = hack_decl_function_context (i->fndecl);
1288 maybe_end_member_template_processing (i->fndecl);
1290 pop_cp_function_context (context);
1292 if (yychar == YYEMPTY)
1294 if (yychar != END_OF_SAVED_INPUT)
1296 error ("parse error at end of saved function text");
1298 /* restore_pending_input will abort unless yychar is either
1299 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1300 hosed, feed back YYEMPTY. We also need to discard nextchar,
1301 since that may have gotten set as well. */
1306 if (i && i->fndecl != NULL_TREE)
1308 context = hack_decl_function_context (i->fndecl);
1310 push_cp_function_context (context);
1311 maybe_begin_member_template_processing (i->fndecl);
1312 feed_input (i->buf, i->len);
1314 input_filename = i->filename;
1315 yychar = PRE_PARSED_FUNCTION_DECL;
1316 yylval.ttype = build_tree_list ((tree) i, i->fndecl);
1317 DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
1321 interface_unknown = i->interface == 1;
1322 interface_only = i->interface == 0;
1325 extract_interface_info ();
1328 /* Since inline methods can refer to text which has not yet been seen,
1329 we store the text of the method in a structure which is placed in the
1330 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1331 After parsing the body of the class definition, the FUNCTION_DECL's are
1332 scanned to see which ones have this field set. Those are then digested
1335 This function's FUNCTION_DECL will have a bit set in its common so
1336 that we know to watch out for it. */
1339 consume_string (this_obstack, matching_char)
1340 register struct obstack *this_obstack;
1344 int starting_lineno = lineno;
1350 int save_lineno = lineno;
1351 lineno = starting_lineno;
1352 if (matching_char == '"')
1353 error ("end of file encountered inside string constant");
1355 error ("end of file encountered inside character constant");
1356 lineno = save_lineno;
1361 obstack_1grow (this_obstack, c);
1363 obstack_1grow (this_obstack, c);
1365 /* Make sure we continue the loop */
1372 pedwarn ("ANSI C++ forbids newline in string constant");
1375 obstack_1grow (this_obstack, c);
1377 while (c != matching_char);
1380 static int nextyychar = YYEMPTY;
1381 static YYSTYPE nextyylval;
1383 struct pending_input {
1384 int nextchar, yychar, nextyychar, eof;
1385 YYSTYPE yylval, nextyylval;
1386 struct obstack token_obstack;
1390 struct pending_input *
1391 save_pending_input ()
1393 struct pending_input *p;
1394 p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1395 p->nextchar = nextchar;
1397 p->nextyychar = nextyychar;
1399 p->nextyylval = nextyylval;
1400 p->eof = end_of_file;
1401 yychar = nextyychar = YYEMPTY;
1403 p->first_token = first_token;
1404 p->token_obstack = token_obstack;
1407 gcc_obstack_init (&token_obstack);
1413 restore_pending_input (p)
1414 struct pending_input *p;
1416 my_friendly_assert (nextchar == -1, 229);
1417 nextchar = p->nextchar;
1418 my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1420 my_friendly_assert (nextyychar == YYEMPTY, 231);
1421 nextyychar = p->nextyychar;
1423 nextyylval = p->nextyylval;
1424 first_token = p->first_token;
1425 obstack_free (&token_obstack, (char *) 0);
1426 token_obstack = p->token_obstack;
1427 end_of_file = p->eof;
1431 /* Unget character CH from the input stream.
1432 If RESCAN is non-zero, then we want to `see' this
1433 character as the next input token. */
1436 yyungetc (ch, rescan)
1440 /* Unget a character from the input stream. */
1441 if (yychar == YYEMPTY || rescan == 0)
1444 put_back (nextchar);
1449 my_friendly_assert (nextyychar == YYEMPTY, 232);
1450 nextyychar = yychar;
1451 nextyylval = yylval;
1457 clear_inline_text_obstack ()
1459 obstack_free (&inline_text_obstack, inline_text_firstobj);
1462 /* This function stores away the text for an inline function that should
1463 be processed later. It decides how much later, and may need to move
1464 the info between obstacks; therefore, the caller should not refer to
1465 the T parameter after calling this function. */
1468 store_pending_inline (decl, t)
1470 struct pending_inline *t;
1473 DECL_PENDING_INLINE_INFO (decl) = t;
1475 /* Because we use obstacks, we must process these in precise order. */
1476 t->next = pending_inlines;
1477 pending_inlines = t;
1481 reinit_parse_for_method (yychar, decl)
1486 int starting_lineno = lineno;
1487 char *starting_filename = input_filename;
1489 reinit_parse_for_block (yychar, &inline_text_obstack);
1491 len = obstack_object_size (&inline_text_obstack);
1492 current_base_init_list = NULL_TREE;
1493 current_member_init_list = NULL_TREE;
1494 if (decl == void_type_node
1495 || (current_class_type && TYPE_REDEFINED (current_class_type)))
1497 /* Happens when we get two declarations of the same
1498 function in the same scope. */
1499 char *buf = obstack_finish (&inline_text_obstack);
1500 obstack_free (&inline_text_obstack, buf);
1505 struct pending_inline *t;
1506 char *buf = obstack_finish (&inline_text_obstack);
1508 t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1509 sizeof (struct pending_inline));
1510 t->lineno = starting_lineno;
1511 t->filename = starting_filename;
1518 if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
1519 warn_if_unknown_interface (decl);
1521 t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1522 store_pending_inline (decl, t);
1526 /* Consume a block -- actually, a method beginning
1527 with `:' or `{' -- and save it away on the specified obstack. */
1530 reinit_parse_for_block (pyychar, obstackp)
1532 struct obstack *obstackp;
1536 int starting_lineno = lineno;
1537 char *starting_filename = input_filename;
1539 int look_for_semicolon = 0;
1540 int look_for_lbrac = 0;
1543 obstack_1grow (obstackp, '{');
1544 else if (pyychar == '=')
1545 look_for_semicolon = 1;
1546 else if (pyychar == ':')
1548 obstack_1grow (obstackp, pyychar);
1552 else if (pyychar == RETURN)
1554 obstack_grow (obstackp, "return", 6);
1558 else if (pyychar == TRY)
1560 obstack_grow (obstackp, "try", 3);
1566 yyerror ("parse error in method specification");
1567 obstack_1grow (obstackp, '{');
1570 if (nextchar != EOF)
1580 int this_lineno = lineno;
1582 c = skip_white_space (c);
1584 /* Don't lose our cool if there are lots of comments. */
1585 if (lineno == this_lineno + 1)
1586 obstack_1grow (obstackp, '\n');
1587 else if (lineno == this_lineno)
1589 else if (lineno - this_lineno < 10)
1592 for (i = lineno - this_lineno; i > 0; i--)
1593 obstack_1grow (obstackp, '\n');
1598 sprintf (buf, "\n# %d \"", lineno);
1600 obstack_grow (obstackp, buf, len);
1602 len = strlen (input_filename);
1603 obstack_grow (obstackp, input_filename, len);
1604 obstack_1grow (obstackp, '\"');
1605 obstack_1grow (obstackp, '\n');
1608 while (c > ' ') /* ASCII dependent... */
1610 obstack_1grow (obstackp, c);
1619 if (blev == 0 && !look_for_semicolon)
1623 if (peekyylex () == CATCH)
1626 obstack_grow (obstackp, " catch ", 7);
1643 /* Don't act on the next character...e.g, doing an escaped
1648 error_with_file_and_line (starting_filename,
1650 "end of file read inside definition");
1653 obstack_1grow (obstackp, c);
1656 consume_string (obstackp, c);
1658 consume_string (obstackp, c);
1663 error ("function body for constructor missing");
1664 obstack_1grow (obstackp, '{');
1665 obstack_1grow (obstackp, '}');
1669 else if (look_for_semicolon && blev == 0)
1677 error_with_file_and_line (starting_filename,
1679 "end of file read inside definition");
1684 obstack_1grow (obstackp, c);
1689 obstack_1grow (obstackp, '\0');
1692 /* Consume a no-commas expression -- actually, a default argument -- and
1693 save it away on the specified obstack. */
1696 reinit_parse_for_expr (obstackp)
1697 struct obstack *obstackp;
1700 int starting_lineno = lineno;
1701 char *starting_filename = input_filename;
1705 if (nextchar != EOF)
1715 int this_lineno = lineno;
1717 c = skip_white_space (c);
1719 /* Don't lose our cool if there are lots of comments. */
1720 if (lineno == this_lineno + 1)
1721 obstack_1grow (obstackp, '\n');
1722 else if (lineno == this_lineno)
1724 else if (lineno - this_lineno < 10)
1727 for (i = lineno - this_lineno; i > 0; --i)
1728 obstack_1grow (obstackp, '\n');
1733 sprintf (buf, "\n# %d \"", lineno);
1735 obstack_grow (obstackp, buf, len);
1737 len = strlen (input_filename);
1738 obstack_grow (obstackp, input_filename, len);
1739 obstack_1grow (obstackp, '\"');
1740 obstack_1grow (obstackp, '\n');
1743 while (c > ' ') /* ASCII dependent... */
1745 if (plev <= 0 && (c == ')' || c == ','))
1750 obstack_1grow (obstackp, c);
1751 if (c == '(' || c == '[')
1753 else if (c == ']' || c == ')')
1757 /* Don't act on the next character...e.g, doing an escaped
1762 error_with_file_and_line (starting_filename,
1764 "end of file read inside definition");
1767 obstack_1grow (obstackp, c);
1770 consume_string (obstackp, c);
1772 consume_string (obstackp, c);
1778 error_with_file_and_line (starting_filename,
1780 "end of file read inside definition");
1785 obstack_1grow (obstackp, c);
1790 obstack_1grow (obstackp, '\0');
1793 int do_snarf_defarg;
1795 /* Decide whether the default argument we are about to see should be
1796 gobbled up as text for later parsing. */
1799 maybe_snarf_defarg ()
1801 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
1802 do_snarf_defarg = 1;
1805 /* When we see a default argument in a method declaration, we snarf it as
1806 text using snarf_defarg. When we get up to namespace scope, we then go
1807 through and parse all of them using do_pending_defargs. Since yacc
1808 parsers are not reentrant, we retain defargs state in these two
1809 variables so that subsequent calls to do_pending_defargs can resume
1810 where the previous call left off. */
1822 reinit_parse_for_expr (&inline_text_obstack);
1823 len = obstack_object_size (&inline_text_obstack);
1824 buf = obstack_finish (&inline_text_obstack);
1826 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1827 arg = make_node (DEFAULT_ARG);
1828 DEFARG_LENGTH (arg) = len - 1;
1829 DEFARG_POINTER (arg) = buf;
1835 /* Called from grokfndecl to note a function decl with unparsed default
1836 arguments for later processing. Also called from grokdeclarator
1837 for function types with unparsed defargs; the call from grokfndecl
1838 will always come second, so we can overwrite the entry from the type. */
1841 add_defarg_fn (decl)
1844 if (TREE_CODE (decl) == FUNCTION_DECL)
1845 TREE_VALUE (defarg_fns) = decl;
1848 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1849 defarg_fns = tree_cons (current_class_type, decl, defarg_fns);
1854 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1860 tree d = TREE_PURPOSE (p);
1861 feed_input (DEFARG_POINTER (d), DEFARG_LENGTH (d));
1862 if (TREE_CODE (f) == FUNCTION_DECL)
1864 lineno = DECL_SOURCE_LINE (f);
1865 input_filename = DECL_SOURCE_FILE (f);
1867 yychar = DEFARG_MARKER;
1871 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1876 if (yychar == YYEMPTY)
1878 if (yychar != END_OF_SAVED_INPUT)
1880 error ("parse error at end of saved function text");
1882 /* restore_pending_input will abort unless yychar is either
1883 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1884 hosed, feed back YYEMPTY. We also need to discard nextchar,
1885 since that may have gotten set as well. */
1892 /* Main function for deferred parsing of default arguments. Called from
1896 do_pending_defargs ()
1901 for (; defarg_fns; defarg_fns = TREE_CHAIN (defarg_fns))
1903 tree defarg_fn = TREE_VALUE (defarg_fns);
1904 if (defarg_parm == NULL_TREE)
1906 push_nested_class (TREE_PURPOSE (defarg_fns), 1);
1908 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1909 maybe_begin_member_template_processing (defarg_fn);
1911 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1915 for (p = DECL_ARGUMENTS (defarg_fn); p; p = TREE_CHAIN (p))
1916 pushdecl (copy_node (p));
1918 defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
1921 defarg_parm = TYPE_ARG_TYPES (defarg_fn);
1924 defarg_parm = TREE_CHAIN (defarg_parm);
1926 for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
1927 if (TREE_PURPOSE (defarg_parm)
1928 && TREE_CODE (TREE_PURPOSE (defarg_parm)) == DEFAULT_ARG)
1930 feed_defarg (defarg_fn, defarg_parm);
1932 /* Return to the parser, which will process this defarg
1933 and call us again. */
1937 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1939 maybe_end_member_template_processing (defarg_fn);
1940 check_default_args (defarg_fn);
1944 pop_nested_class (1);
1948 /* Build a default function named NAME for type TYPE.
1949 KIND says what to build.
1951 When KIND == 0, build default destructor.
1952 When KIND == 1, build virtual destructor.
1953 When KIND == 2, build default constructor.
1954 When KIND == 3, build default X(const X&) constructor.
1955 When KIND == 4, build default X(X&) constructor.
1956 When KIND == 5, build default operator = (const X&).
1957 When KIND == 6, build default operator = (X&). */
1960 cons_up_default_function (type, full_name, kind)
1961 tree type, full_name;
1964 extern tree void_list_node;
1965 tree declspecs = NULL_TREE;
1966 tree fn, args = NULL_TREE;
1969 tree name = constructor_name (full_name);
1975 declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
1976 /* Fall through... */
1978 name = build_parse_node (BIT_NOT_EXPR, name);
1979 args = void_list_node;
1983 /* Default constructor. */
1984 args = void_list_node;
1988 type = build_type_variant (type, 1, 0);
1989 /* Fall through... */
1991 /* According to ARM $12.8, the default copy ctor will be declared, but
1992 not defined, unless it's needed. */
1993 argtype = build_reference_type (type);
1994 args = tree_cons (NULL_TREE,
1995 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1996 get_identifier ("_ctor_arg")),
2003 declspecs = build_decl_list (NULL_TREE, type);
2006 type = build_type_variant (type, 1, 0);
2008 name = ansi_opname [(int) MODIFY_EXPR];
2010 argtype = build_reference_type (type);
2011 args = tree_cons (NULL_TREE,
2012 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
2013 get_identifier ("_ctor_arg")),
2018 my_friendly_abort (59);
2021 declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE],
2024 TREE_PARMLIST (args) = 1;
2027 tree declarator = make_call_declarator (name, args, NULL_TREE, NULL_TREE);
2029 declarator = build_parse_node (ADDR_EXPR, declarator);
2031 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
2034 if (fn == void_type_node)
2038 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn)));
2041 if (processing_template_defn)
2043 SET_DECL_IMPLICIT_INSTANTIATION (fn);
2044 repo_template_used (fn);
2049 if (CLASSTYPE_INTERFACE_KNOWN (type))
2051 DECL_INTERFACE_KNOWN (fn) = 1;
2052 DECL_NOT_REALLY_EXTERN (fn) = (!CLASSTYPE_INTERFACE_ONLY (type)
2053 && flag_implement_inlines);
2057 DECL_NOT_REALLY_EXTERN (fn) = 1;
2059 mark_inline_for_output (fn);
2061 #ifdef DEBUG_DEFAULT_FUNCTIONS
2062 { char *fn_type = NULL;
2066 case 0: fn_type = "default destructor"; break;
2067 case 1: fn_type = "virtual destructor"; break;
2068 case 2: fn_type = "default constructor"; break;
2069 case 3: fn_type = "default X(const X&)"; break;
2070 case 4: fn_type = "default X(X&)"; break;
2074 if (TREE_CODE (name) == BIT_NOT_EXPR)
2075 t = TREE_OPERAND (name, 0);
2076 fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
2077 IDENTIFIER_POINTER (t), func_buf);
2080 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2082 /* Show that this function was generated by the compiler. */
2083 SET_DECL_ARTIFICIAL (fn);
2088 /* Heuristic to tell whether the user is missing a semicolon
2089 after a struct or enum declaration. Emit an error message
2090 if we know the user has blown it. */
2093 check_for_missing_semicolon (type)
2101 && yychar != IDENTIFIER
2102 && yychar != TYPENAME
2103 && yychar != CV_QUALIFIER
2104 && yychar != SELFNAME)
2107 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2108 error ("semicolon missing after %s declaration",
2109 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2111 cp_error ("semicolon missing after declaration of `%T'", type);
2112 shadow_tag (build_tree_list (0, type));
2114 /* Could probably also hack cases where class { ... } f (); appears. */
2119 note_got_semicolon (type)
2122 if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
2123 my_friendly_abort (60);
2124 if (IS_AGGR_TYPE (type))
2125 CLASSTYPE_GOT_SEMICOLON (type) = 1;
2129 note_list_got_semicolon (declspecs)
2134 for (link = declspecs; link; link = TREE_CHAIN (link))
2136 tree type = TREE_VALUE (link);
2137 if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
2138 note_got_semicolon (type);
2143 /* If C is not whitespace, return C.
2144 Otherwise skip whitespace and return first nonwhite char read. */
2147 skip_white_space (c)
2155 c = check_newline ();
2166 while (c == ' ' || c == '\t');
2174 error ("stray '\\' in program");
2186 /* Make the token buffer longer, preserving the data in it.
2187 P should point to just beyond the last valid character in the old buffer.
2188 The value we return is a pointer to the new buffer
2189 at a place corresponding to P. */
2192 extend_token_buffer (p)
2195 int offset = p - token_buffer;
2197 maxtoken = maxtoken * 2 + 10;
2198 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2200 return token_buffer + offset;
2204 get_last_nonwhite_on_line ()
2208 /* Is this the last nonwhite stuff on the line? */
2210 c = nextchar, nextchar = -1;
2214 while (c == ' ' || c == '\t')
2219 /* At the beginning of a line, increment the line number
2220 and process any #-directive on this line.
2221 If the line is a #-directive, read the entire line and return a newline.
2222 Otherwise, return the line's first non-whitespace character. */
2226 static int handle_cp_pragma PROTO((char *));
2234 /* Read first nonwhite char on the line. Do this before incrementing the
2235 line number, in case we're at the end of saved text. */
2239 while (c == ' ' || c == '\t');
2245 /* If not #, return it so caller will use it. */
2249 /* Don't read beyond this line. */
2252 /* Read first nonwhite char after the `#'. */
2256 while (c == ' ' || c == '\t');
2258 /* If a letter follows, then if the word here is `line', skip
2259 it and ignore it; otherwise, ignore the line, with an error
2260 if the word isn't `pragma'. */
2262 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
2272 token = real_yylex ();
2273 if (token == IDENTIFIER
2274 && TREE_CODE (yylval.ttype) == IDENTIFIER_NODE)
2276 /* If this is 1, we handled it; if it's -1, it was one we
2277 wanted but had something wrong with it. Only if it's
2278 0 was it not handled. */
2279 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval.ttype)))
2282 else if (token == END_OF_LINE)
2285 #ifdef HANDLE_SYSV_PRAGMA
2286 if (handle_sysv_pragma (token))
2289 #ifdef HANDLE_PRAGMA
2294 if (HANDLE_PRAGMA (finput, yylval.ttype))
2296 #endif /* !USE_CPPLIB */
2309 && ((c = getch ()) == ' ' || c == '\t'))
2311 debug_define (lineno, GET_DIRECTIVE_LINE ());
2321 && ((c = getch ()) == ' ' || c == '\t'))
2323 debug_undef (lineno, GET_DIRECTIVE_LINE ());
2332 && ((c = getch ()) == ' ' || c == '\t'))
2341 && ((c = getch ()) == ' ' || c == '\t'))
2343 /* #ident. The pedantic warning is now in cccp.c. */
2345 /* Here we have just seen `#ident '.
2346 A string constant should follow. */
2348 token = real_yylex ();
2349 if (token == END_OF_LINE)
2352 || TREE_CODE (yylval.ttype) != STRING_CST)
2354 error ("invalid #ident");
2358 if (! flag_no_ident)
2360 #ifdef ASM_OUTPUT_IDENT
2361 ASM_OUTPUT_IDENT (asm_out_file,
2362 TREE_STRING_POINTER (yylval.ttype));
2366 /* Skip the rest of this line. */
2379 && ((c = getch ()) == ' ' || c == '\t'))
2381 /* Used to test incremental compilation. */
2382 sorry ("#pragma newworld");
2386 error ("undefined or invalid # directive");
2391 /* Here we have either `#line' or `# <nonletter>'.
2392 In either case, it should be a line number; a digit should follow. */
2394 while (c == ' ' || c == '\t')
2397 /* If the # is the only nonwhite char on the line,
2398 just ignore it. Check the new newline. */
2402 /* Something follows the #; read a token. */
2405 token = real_yylex ();
2407 if (token == CONSTANT
2408 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2410 int old_lineno = lineno;
2411 enum { act_none, act_push, act_pop } action = act_none;
2412 int entering_system_header = 0;
2413 int entering_c_header = 0;
2415 /* subtract one, because it is the following line that
2416 gets the specified number */
2418 int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2419 c = get_last_nonwhite_on_line ();
2422 /* No more: store the line number and check following line. */
2428 /* More follows: it must be a string constant (filename). */
2430 /* Read the string constant, but don't treat \ as special. */
2431 ignore_escape_flag = 1;
2432 token = real_yylex ();
2433 ignore_escape_flag = 0;
2435 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2437 error ("invalid #line");
2441 /* Changing files again. This means currently collected time
2442 is charged against header time, and body time starts back
2444 if (flag_detailed_statistics)
2446 int this_time = my_get_run_time ();
2447 tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2448 header_time += this_time - body_time;
2449 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
2450 += this_time - body_time;
2451 this_filename_time = time_identifier;
2452 body_time = this_time;
2456 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
2457 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
2459 GNU_xref_file (input_filename);
2461 if (main_input_filename == 0)
2463 struct impl_files *ifiles = impl_file_chain;
2467 while (ifiles->next)
2468 ifiles = ifiles->next;
2469 ifiles->filename = file_name_nondirectory (input_filename);
2472 main_input_filename = input_filename;
2473 if (write_virtuals == 3)
2474 walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
2477 extract_interface_info ();
2479 c = get_last_nonwhite_on_line ();
2482 /* Update the name in the top element of input_file_stack. */
2483 if (input_file_stack)
2484 input_file_stack->name = input_filename;
2490 token = real_yylex ();
2492 /* `1' after file name means entering new file.
2493 `2' after file name means just left a file. */
2495 if (token == CONSTANT
2496 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2498 if (TREE_INT_CST_LOW (yylval.ttype) == 1)
2500 else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
2505 c = get_last_nonwhite_on_line ();
2509 token = real_yylex ();
2514 /* `3' after file name means this is a system header file. */
2516 if (token == CONSTANT
2517 && TREE_CODE (yylval.ttype) == INTEGER_CST
2518 && TREE_INT_CST_LOW (yylval.ttype) == 3)
2520 entering_system_header = 1;
2522 c = get_last_nonwhite_on_line ();
2526 token = real_yylex ();
2530 /* `4' after file name means this is a C header file. */
2532 if (token == CONSTANT
2533 && TREE_CODE (yylval.ttype) == INTEGER_CST
2534 && TREE_INT_CST_LOW (yylval.ttype) == 4)
2536 entering_c_header = 1;
2538 c = get_last_nonwhite_on_line ();
2542 token = real_yylex ();
2546 /* Do the actions implied by the preceding numbers. */
2548 if (action == act_push)
2550 /* Pushing to a new file. */
2551 struct file_stack *p;
2553 p = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2554 input_file_stack->line = old_lineno;
2555 p->next = input_file_stack;
2556 p->name = input_filename;
2557 input_file_stack = p;
2558 input_file_stack_tick++;
2559 debug_start_source_file (input_filename);
2560 in_system_header = entering_system_header;
2563 else if (entering_c_header)
2566 ++pending_lang_change;
2569 else if (action == act_pop)
2571 /* Popping out of a file. */
2572 if (input_file_stack->next)
2574 struct file_stack *p;
2576 if (c_header_level && --c_header_level == 0)
2578 if (entering_c_header)
2579 warning ("badly nested C headers from preprocessor");
2580 --pending_lang_change;
2582 in_system_header = entering_system_header;
2584 p = input_file_stack;
2585 input_file_stack = p->next;
2587 input_file_stack_tick++;
2588 debug_end_source_file (input_file_stack->line);
2591 error ("#-lines for entering and leaving files don't match");
2594 in_system_header = entering_system_header;
2597 /* If NEXTCHAR is not end of line, we don't care what it is. */
2598 if (nextchar == EOF)
2602 error ("invalid #-line");
2604 /* skip the rest of this line. */
2609 while ((c = getch ()) != EOF && c != '\n');
2614 do_pending_lang_change ()
2616 for (; pending_lang_change > 0; --pending_lang_change)
2617 push_lang_context (lang_name_c);
2618 for (; pending_lang_change < 0; ++pending_lang_change)
2619 pop_lang_context ();
2622 #define ENDFILE -1 /* token that represents end-of-file */
2624 /* Read an escape sequence, returning its equivalent as a character,
2625 or store 1 in *ignore_ptr if it is backslash-newline. */
2628 readescape (ignore_ptr)
2631 register int c = getch ();
2633 register unsigned count;
2634 unsigned firstdig = 0;
2652 if (c >= 'a' && c <= 'f')
2653 code += c - 'a' + 10;
2654 if (c >= 'A' && c <= 'F')
2655 code += c - 'A' + 10;
2656 if (c >= '0' && c <= '9')
2658 if (code != 0 || count != 0)
2667 error ("\\x used with no following hex digits");
2668 else if (count == 0)
2669 /* Digits are all 0's. Ok. */
2671 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
2673 && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
2675 pedwarn ("hex escape out of range");
2678 case '0': case '1': case '2': case '3': case '4':
2679 case '5': case '6': case '7':
2682 while ((c <= '7') && (c >= '0') && (count++ < 3))
2684 code = (code * 8) + (c - '0');
2690 case '\\': case '\'': case '"':
2699 return TARGET_NEWLINE;
2722 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
2728 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2732 /* `\%' is used to prevent SCCS from getting confused. */
2735 pedwarn ("unknown escape sequence `\\%c'", c);
2738 if (c >= 040 && c < 0177)
2739 pedwarn ("unknown escape sequence `\\%c'", c);
2741 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
2745 /* Value is 1 (or 2) if we should try to make the next identifier look like
2746 a typename (when it may be a local variable or a class variable).
2747 Value is 0 if we treat this name in a default fashion. */
2748 int looking_for_typename;
2754 identifier_type (decl)
2757 if (TREE_CODE (decl) == TEMPLATE_DECL)
2759 if (TREE_CODE (DECL_RESULT (decl)) == TYPE_DECL)
2761 else if (looking_for_template)
2764 if (looking_for_template && really_overloaded_fn (decl))
2767 for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
2768 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
2771 if (TREE_CODE (decl) == NAMESPACE_DECL)
2773 if (TREE_CODE (decl) != TYPE_DECL)
2775 if (((got_scope && TREE_TYPE (decl) == got_scope)
2776 || TREE_TYPE (decl) == current_class_type)
2777 && DECL_ARTIFICIAL (decl))
2785 /* Only types expected, not even namespaces. */
2786 looking_for_typename = 2;
2788 if ((yychar = yylex ()) < 0) yychar = 0;
2789 looking_for_typename = 0;
2790 if (yychar == IDENTIFIER)
2792 lastiddecl = lookup_name (yylval.ttype, -2);
2793 if (lastiddecl == 0)
2796 lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
2799 yychar = identifier_type (lastiddecl);
2803 /* Return true if d is in a global scope. */
2810 switch (TREE_CODE (d))
2812 case OVERLOAD: d = OVL_FUNCTION (d); continue;
2813 case TREE_LIST: d = TREE_VALUE (d); continue;
2815 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (d)) == 'd', 980629);
2816 d = CP_DECL_CONTEXT (d);
2817 return TREE_CODE (d) == NAMESPACE_DECL;
2822 do_identifier (token, parsing, args)
2823 register tree token;
2828 int lexing = (parsing == 1);
2829 int in_call = (parsing == 2);
2831 if (! lexing || IDENTIFIER_OPNAME_P (token))
2832 id = lookup_name (token, 0);
2836 /* Scope class declarations before global
2838 if ((!id || is_global (id))
2839 && current_class_type != 0
2840 && TYPE_SIZE (current_class_type) == 0)
2842 /* Could be from one of the base classes. */
2843 tree field = lookup_field (current_class_type, token, 1, 0);
2846 else if (field == error_mark_node)
2847 /* We have already generated the error message.
2848 But we still want to return this value. */
2849 id = lookup_field (current_class_type, token, 0, 0);
2850 else if (TREE_CODE (field) == VAR_DECL
2851 || TREE_CODE (field) == CONST_DECL
2852 || TREE_CODE (field) == TEMPLATE_DECL)
2854 else if (TREE_CODE (field) != FIELD_DECL)
2855 my_friendly_abort (61);
2858 cp_error ("invalid use of member `%D' from base class `%T'", field,
2859 DECL_FIELD_CONTEXT (field));
2860 id = error_mark_node;
2865 /* Do Koenig lookup if appropriate (inside templates we build lookup
2866 expressions instead). */
2867 if (args && !current_template_parms && (!id || is_global (id)))
2869 /* If we have arguments and we only found global names,
2870 do Koenig lookup. */
2871 id = lookup_arg_dependent (token, id, args);
2874 /* Remember that this name has been used in the class definition, as per
2876 if (id && current_class_type && parsing
2877 && TYPE_BEING_DEFINED (current_class_type)
2878 && ! IDENTIFIER_CLASS_VALUE (token)
2879 /* Avoid breaking if we get called for a default argument that
2880 refers to an overloaded method. Eventually this will not be
2881 necessary, since default arguments shouldn't be parsed until
2882 after the class is complete. (jason 3/12/97) */
2883 && TREE_CODE (id) != OVERLOAD)
2884 pushdecl_class_level (id);
2886 if (!id || id == error_mark_node)
2888 if (id == error_mark_node && current_class_type != NULL_TREE)
2890 id = lookup_nested_field (token, 1);
2891 /* In lookup_nested_field(), we marked this so we can gracefully
2892 leave this whole mess. */
2893 if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
2897 if (current_template_parms)
2898 return build_min_nt (LOOKUP_EXPR, token);
2899 else if (IDENTIFIER_OPNAME_P (token))
2901 if (token != ansi_opname[ERROR_MARK])
2902 cp_error ("`%D' not defined", token);
2903 id = error_mark_node;
2907 id = implicitly_declare (token);
2909 else if (current_function_decl == 0)
2911 cp_error ("`%D' was not declared in this scope", token);
2912 id = error_mark_node;
2916 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
2917 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
2919 static int undeclared_variable_notice;
2921 cp_error ("`%D' undeclared (first use this function)", token);
2923 if (! undeclared_variable_notice)
2925 error ("(Each undeclared identifier is reported only once");
2926 error ("for each function it appears in.)");
2927 undeclared_variable_notice = 1;
2930 id = error_mark_node;
2931 /* Prevent repeated error messages. */
2932 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
2933 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
2937 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
2939 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
2940 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
2941 && DECL_DEAD_FOR_LOCAL (shadowed))
2942 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
2944 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
2947 if (!DECL_ERROR_REPORTED (id))
2949 warning ("name lookup of `%s' changed",
2950 IDENTIFIER_POINTER (token));
2951 cp_warning_at (" matches this `%D' under current ANSI rules",
2953 cp_warning_at (" matches this `%D' under old rules", id);
2954 DECL_ERROR_REPORTED (id) = 1;
2958 else if (!DECL_ERROR_REPORTED (id))
2961 = "name lookup of `%s' changed for new ANSI `for' scoping";
2962 DECL_ERROR_REPORTED (id) = 1;
2963 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id)))
2965 error (msg, IDENTIFIER_POINTER (token));
2966 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
2967 id = error_mark_node;
2971 pedwarn (msg, IDENTIFIER_POINTER (token));
2972 cp_pedwarn_at (" using obsolete binding at `%D'", id);
2976 /* TREE_USED is set in `hack_identifier'. */
2977 if (TREE_CODE (id) == CONST_DECL)
2979 if (IDENTIFIER_CLASS_VALUE (token) == id)
2982 tree access = compute_access (TYPE_BINFO (current_class_type), id);
2983 if (access == access_private_node)
2984 cp_error ("enum `%D' is private", id);
2985 /* protected is OK, since it's an enum of `this'. */
2987 if (! processing_template_decl
2988 || (DECL_INITIAL (id)
2989 && TREE_CODE (DECL_INITIAL (id)) == TEMPLATE_PARM_INDEX))
2990 id = DECL_INITIAL (id);
2993 id = hack_identifier (id, token);
2995 /* We must look up dependent names when the template is
2996 instantiated, not while parsing it. For now, we don't
2997 distinguish between dependent and independent names. So, for
2998 example, we look up all overloaded functions at
2999 instantiation-time, even though in some cases we should just use
3000 the DECL we have here. We also use LOOKUP_EXPRs to find things
3001 like local variables, rather than creating TEMPLATE_DECLs for the
3002 local variables and then finding matching instantiations. */
3003 if (current_template_parms
3004 && (is_overloaded_fn (id)
3005 /* If it's not going to be around at instantiation time, we
3006 look it up then. This is a hack, and should go when we
3007 really get dependent/independent name lookup right. */
3008 || !TREE_PERMANENT (id)
3009 /* Some local VAR_DECLs (such as those for local variables
3010 in member functions of local classes) are built on the
3011 permanent obstack. */
3012 || (TREE_CODE (id) == VAR_DECL
3013 && CP_DECL_CONTEXT (id)
3014 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
3015 || TREE_CODE (id) == PARM_DECL
3016 || TREE_CODE (id) == USING_DECL))
3017 id = build_min_nt (LOOKUP_EXPR, token);
3023 do_scoped_id (token, parsing)
3028 /* during parsing, this is ::name. Otherwise, it is black magic. */
3031 struct tree_binding _b;
3032 id = binding_init (&_b);
3033 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
3036 id = BINDING_VALUE (id);
3039 id = IDENTIFIER_GLOBAL_VALUE (token);
3040 if (parsing && yychar == YYEMPTY)
3044 if (processing_template_decl)
3046 id = build_min_nt (LOOKUP_EXPR, token);
3047 LOOKUP_EXPR_GLOBAL (id) = 1;
3050 if (parsing && (yychar == '(' || yychar == LEFT_RIGHT))
3051 id = implicitly_declare (token);
3054 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
3055 cp_error ("`::%D' undeclared (first use here)", token);
3056 id = error_mark_node;
3057 /* Prevent repeated error messages. */
3058 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3063 if (TREE_CODE (id) == ADDR_EXPR)
3064 mark_used (TREE_OPERAND (id, 0));
3065 else if (TREE_CODE (id) != OVERLOAD)
3068 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
3070 /* XXX CHS - should we set TREE_USED of the constant? */
3071 id = DECL_INITIAL (id);
3072 /* This is to prevent an enum whose value is 0
3073 from being considered a null pointer constant. */
3074 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
3075 TREE_CONSTANT (id) = 1;
3078 if (processing_template_decl)
3080 if (is_overloaded_fn (id))
3082 id = build_min_nt (LOOKUP_EXPR, token);
3083 LOOKUP_EXPR_GLOBAL (id) = 1;
3086 /* else just use the decl */
3088 return convert_from_reference (id);
3092 identifier_typedecl_value (node)
3096 type = IDENTIFIER_TYPE_VALUE (node);
3097 if (type == NULL_TREE)
3102 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3105 do (IDENTIFIER_LOCAL_VALUE (node));
3106 do (IDENTIFIER_CLASS_VALUE (node));
3107 do (IDENTIFIER_NAMESPACE_VALUE (node));
3109 /* Will this one ever happen? */
3110 if (TYPE_MAIN_DECL (type))
3111 return TYPE_MAIN_DECL (type);
3113 /* We used to do an internal error of 62 here, but instead we will
3114 handle the return of a null appropriately in the callers. */
3124 int dollar_seen = 0;
3128 c = nextchar, nextchar = -1;
3132 /* Effectively do c = skip_white_space (c)
3133 but do it faster in the usual cases. */
3146 /* Call skip_white_space so we can warn if appropriate. */
3151 c = skip_white_space (c);
3153 goto found_nonwhite;
3157 token_buffer[0] = c;
3158 token_buffer[1] = 0;
3160 /* yylloc.first_line = lineno; */
3165 token_buffer[0] = '\0';
3167 if (input_redirected ())
3168 value = END_OF_SAVED_INPUT;
3170 value = END_OF_LINE;
3176 if (! dollars_in_ident)
3177 error ("`$' in identifier");
3179 pedwarn ("`$' in identifier");
3184 /* Capital L may start a wide-string or wide-character constant. */
3186 register int c = getch ();
3195 goto string_constant;
3200 case 'A': case 'B': case 'C': case 'D': case 'E':
3201 case 'F': case 'G': case 'H': case 'I': case 'J':
3202 case 'K': case 'M': case 'N': case 'O':
3203 case 'P': case 'Q': case 'R': case 'S': case 'T':
3204 case 'U': case 'V': case 'W': case 'X': case 'Y':
3206 case 'a': case 'b': case 'c': case 'd': case 'e':
3207 case 'f': case 'g': case 'h': case 'i': case 'j':
3208 case 'k': case 'l': case 'm': case 'n': case 'o':
3209 case 'p': case 'q': case 'r': case 's': case 't':
3210 case 'u': case 'v': case 'w': case 'x': case 'y':
3220 /* We know that `token_buffer' can hold at least on char,
3221 so we install C immediately.
3222 We may have to read the value in `putback_char', so call
3227 /* Make this run fast. We know that we are reading straight
3228 from FINPUT in this case (since identifiers cannot straddle
3230 while (ISALNUM (c) || (c == '_') || c == '$')
3234 if (! dollars_in_ident)
3235 error ("`$' in identifier");
3237 pedwarn ("`$' in identifier");
3240 if (p >= token_buffer + maxtoken)
3241 p = extend_token_buffer (p);
3247 if (linemode && c == '\n')
3255 /* We know that `token_buffer' can hold at least on char,
3256 so we install C immediately. */
3260 while (ISALNUM (c) || (c == '_') || c == '$')
3264 if (! dollars_in_ident)
3265 error ("`$' in identifier");
3267 pedwarn ("`$' in identifier");
3270 if (p >= token_buffer + maxtoken)
3271 p = extend_token_buffer (p);
3284 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3287 register struct resword *ptr;
3289 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
3293 tree old_ttype = ridpointers[(int) ptr->rid];
3295 /* If this provides a type for us, then revert lexical
3296 state to standard state. */
3297 if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
3298 && IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
3299 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
3300 looking_for_typename = 0;
3301 else if (ptr->token == AGGR || ptr->token == ENUM)
3302 looking_for_typename = 2;
3304 /* Check if this is a language-type declaration.
3305 Just glimpse the next non-white character. */
3306 nextchar = skip_white_space (nextchar);
3307 if (nextchar == '"')
3309 /* We are looking at a string. Complain
3310 if the token before the string is no `extern'.
3312 Could cheat some memory by placing this string
3313 on the temporary_, instead of the saveable_
3316 if (ptr->rid != RID_EXTERN)
3317 error ("invalid modifier `%s' for language string",
3320 value = EXTERN_LANG_STRING;
3321 yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
3324 if (ptr->token == VISSPEC)
3329 yylval.ttype = access_public_node;
3332 yylval.ttype = access_private_node;
3335 yylval.ttype = access_protected_node;
3338 my_friendly_abort (63);
3342 yylval.ttype = old_ttype;
3344 else if (ptr->token == EQCOMPARE)
3346 yylval.code = NE_EXPR;
3347 token_buffer[0] = '!';
3348 token_buffer[1] = '=';
3349 token_buffer[2] = 0;
3351 else if (ptr->token == ASSIGN)
3353 if (strcmp ("and_eq", token_buffer) == 0)
3355 yylval.code = BIT_AND_EXPR;
3356 token_buffer[0] = '&';
3358 else if (strcmp ("or_eq", token_buffer) == 0)
3360 yylval.code = BIT_IOR_EXPR;
3361 token_buffer[0] = '|';
3363 else if (strcmp ("xor_eq", token_buffer) == 0)
3365 yylval.code = BIT_XOR_EXPR;
3366 token_buffer[0] = '^';
3368 token_buffer[1] = '=';
3369 token_buffer[2] = 0;
3371 else if (ptr->token == '&')
3373 yylval.code = BIT_AND_EXPR;
3374 token_buffer[0] = '&';
3375 token_buffer[1] = 0;
3377 else if (ptr->token == '|')
3379 yylval.code = BIT_IOR_EXPR;
3380 token_buffer[0] = '|';
3381 token_buffer[1] = 0;
3383 else if (ptr->token == '^')
3385 yylval.code = BIT_XOR_EXPR;
3386 token_buffer[0] = '^';
3387 token_buffer[1] = 0;
3390 value = (int) ptr->token;
3394 /* If we did not find a keyword, look for an identifier
3397 if (value == IDENTIFIER || value == TYPESPEC)
3398 GNU_xref_ref (current_function_decl, token_buffer);
3400 if (value == IDENTIFIER)
3402 register tree tmp = get_identifier (token_buffer);
3404 #if !defined(VMS) && defined(JOINER)
3405 /* Make sure that user does not collide with our internal
3409 && (THIS_NAME_P (tmp)
3410 || VPTR_NAME_P (tmp)
3411 || DESTRUCTOR_NAME_P (tmp)
3412 || VTABLE_NAME_P (tmp)
3413 || TEMP_NAME_P (tmp)
3414 || ANON_AGGRNAME_P (tmp)
3415 || ANON_PARMNAME_P (tmp)))
3416 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3422 if (value == NEW && ! global_bindings_p ())
3432 register int c1 = getch ();
3433 token_buffer[0] = c;
3434 token_buffer[1] = c1;
3438 token_buffer[2] = 0;
3446 token_buffer[2] = c1;
3447 token_buffer[3] = 0;
3451 error ("parse error at `..'");
3456 goto resume_numerical_scan;
3460 token_buffer[1] = 0;
3464 /* Optimize for most frequent case. */
3466 register int c1 = getch ();
3467 if (! ISALNUM (c1) && c1 != '.')
3469 /* Terminate string. */
3470 token_buffer[0] = c;
3471 token_buffer[1] = 0;
3473 yylval.ttype = integer_zero_node;
3475 yylval.ttype = integer_one_node;
3482 /* fall through... */
3483 case '2': case '3': case '4':
3484 case '5': case '6': case '7': case '8': case '9':
3485 resume_numerical_scan:
3490 int largest_digit = 0;
3492 /* for multi-precision arithmetic,
3493 we actually store only HOST_BITS_PER_CHAR bits in each part.
3494 The number of parts is chosen so as to be sufficient to hold
3495 the enough bits to fit into the two HOST_WIDE_INTs that contain
3496 the integer value (this is always at least as many bits as are
3497 in a target `long long' value, but may be wider). */
3498 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3499 int parts[TOTAL_PARTS];
3502 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
3505 for (count = 0; count < TOTAL_PARTS; count++)
3513 *p++ = (c = getch ());
3514 if ((c == 'x') || (c == 'X'))
3517 *p++ = (c = getch ());
3519 /* Leading 0 forces octal unless the 0 is the only digit. */
3520 else if (c >= '0' && c <= '9')
3529 /* Read all the digits-and-decimal-points. */
3532 || (ISALNUM (c) && (c != 'l') && (c != 'L')
3533 && (c != 'u') && (c != 'U')
3534 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
3535 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
3540 error ("floating constant may not be in radix 16");
3541 if (floatflag == TOO_MANY_POINTS)
3542 /* We have already emitted an error. Don't need another. */
3544 else if (floatflag == AFTER_POINT)
3546 error ("malformed floating constant");
3547 floatflag = TOO_MANY_POINTS;
3548 /* Avoid another error from atof by forcing all characters
3549 from here on to be ignored. */
3553 floatflag = AFTER_POINT;
3556 *p++ = c = getch ();
3557 /* Accept '.' as the start of a floating-point number
3558 only when it is followed by a digit.
3559 Otherwise, unread the following non-digit
3560 and use the '.' as a structural token. */
3561 if (p == token_buffer + 2 && !ISDIGIT (c))
3573 error ("parse error at `..'");
3576 token_buffer[1] = '\0';
3583 /* It is not a decimal point.
3584 It should be a digit (perhaps a hex digit). */
3590 else if (base <= 10)
3592 if (c == 'e' || c == 'E')
3595 floatflag = AFTER_POINT;
3596 break; /* start of exponent */
3598 error ("nondigits in number and not hexadecimal");
3609 if (c >= largest_digit)
3613 for (count = 0; count < TOTAL_PARTS; count++)
3615 parts[count] *= base;
3619 += (parts[count-1] >> HOST_BITS_PER_CHAR);
3621 &= (1 << HOST_BITS_PER_CHAR) - 1;
3627 /* If the extra highest-order part ever gets anything in it,
3628 the number is certainly too big. */
3629 if (parts[TOTAL_PARTS - 1] != 0)
3632 if (p >= token_buffer + maxtoken - 3)
3633 p = extend_token_buffer (p);
3634 *p++ = (c = getch ());
3639 error ("numeric constant with no digits");
3641 if (largest_digit >= base)
3642 error ("numeric constant contains digits beyond the radix");
3644 /* Remove terminating char from the token buffer and delimit the string */
3647 if (floatflag != NOT_FLOAT)
3649 tree type = double_type_node;
3650 int exceeds_double = 0;
3652 REAL_VALUE_TYPE value;
3655 /* Read explicit exponent if any, and put it in tokenbuf. */
3657 if ((c == 'e') || (c == 'E'))
3659 if (p >= token_buffer + maxtoken - 3)
3660 p = extend_token_buffer (p);
3663 if ((c == '+') || (c == '-'))
3669 error ("floating constant exponent has no digits");
3672 if (p >= token_buffer + maxtoken - 3)
3673 p = extend_token_buffer (p);
3682 /* Convert string to a double, checking for overflow. */
3683 if (setjmp (handler))
3685 error ("floating constant out of range");
3690 int fflag = 0, lflag = 0;
3691 /* Copy token_buffer now, while it has just the number
3692 and not the suffixes; once we add `f' or `i',
3693 REAL_VALUE_ATOF may not work any more. */
3694 char *copy = (char *) alloca (p - token_buffer + 1);
3695 bcopy (token_buffer, copy, p - token_buffer + 1);
3697 set_float_handler (handler);
3703 /* Read the suffixes to choose a data type. */
3708 error ("more than one `f' in numeric constant");
3714 error ("more than one `l' in numeric constant");
3720 error ("more than one `i' or `j' in numeric constant");
3722 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3733 if (p >= token_buffer + maxtoken - 3)
3734 p = extend_token_buffer (p);
3740 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3741 tells the desired precision of the binary result
3742 of decimal-to-binary conversion. */
3747 error ("both `f' and `l' in floating constant");
3749 type = float_type_node;
3750 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3751 /* A diagnostic is required here by some ANSI C testsuites.
3752 This is not pedwarn, become some people don't want
3753 an error for this. */
3754 if (REAL_VALUE_ISINF (value) && pedantic)
3755 warning ("floating point number exceeds range of `float'");
3759 type = long_double_type_node;
3760 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3761 if (REAL_VALUE_ISINF (value) && pedantic)
3762 warning ("floating point number exceeds range of `long double'");
3766 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3767 if (REAL_VALUE_ISINF (value) && pedantic)
3768 warning ("floating point number exceeds range of `double'");
3771 set_float_handler (NULL_PTR);
3774 if (errno == ERANGE && pedantic)
3776 /* ERANGE is also reported for underflow,
3777 so test the value to distinguish overflow from that. */
3778 if (REAL_VALUES_LESS (dconst1, value)
3779 || REAL_VALUES_LESS (value, dconstm1))
3781 pedwarn ("floating point number exceeds range of `%s'",
3782 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type)));
3788 /* If the result is not a number, assume it must have been
3789 due to some error message above, so silently convert
3791 if (REAL_VALUE_ISNAN (value))
3794 /* Create a node with determined type and value. */
3796 yylval.ttype = build_complex (NULL_TREE,
3797 cp_convert (type, integer_zero_node),
3798 build_real (type, value));
3800 yylval.ttype = build_real (type, value);
3805 HOST_WIDE_INT high, low;
3806 int spec_unsigned = 0;
3808 int spec_long_long = 0;
3814 if (c == 'u' || c == 'U')
3817 error ("two `u's in integer constant");
3820 else if (c == 'l' || c == 'L')
3825 error ("three `l's in integer constant");
3826 else if (pedantic && ! in_system_header && warn_long_long)
3827 pedwarn ("ANSI C++ forbids long long integer constants");
3832 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
3835 error ("more than one `i' or `j' in numeric constant");
3837 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3842 if (p >= token_buffer + maxtoken - 3)
3843 p = extend_token_buffer (p);
3848 /* If the constant is not long long and it won't fit in an
3849 unsigned long, or if the constant is long long and won't fit
3850 in an unsigned long long, then warn that the constant is out
3853 /* ??? This assumes that long long and long integer types are
3854 a multiple of 8 bits. This better than the original code
3855 though which assumed that long was exactly 32 bits and long
3856 long was exactly 64 bits. */
3859 bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
3861 bytes = TYPE_PRECISION (long_integer_type_node) / 8;
3864 for (i = bytes; i < TOTAL_PARTS; i++)
3868 pedwarn ("integer constant out of range");
3870 /* This is simplified by the fact that our constant
3871 is always positive. */
3874 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
3876 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
3877 / HOST_BITS_PER_CHAR)]
3878 << (i * HOST_BITS_PER_CHAR));
3879 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
3883 yylval.ttype = build_int_2 (low, high);
3884 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
3886 /* Calculate the ANSI type. */
3887 if (!spec_long && !spec_unsigned
3888 && int_fits_type_p (yylval.ttype, integer_type_node))
3889 type = integer_type_node;
3890 else if (!spec_long && (base != 10 || spec_unsigned)
3891 && int_fits_type_p (yylval.ttype, unsigned_type_node))
3892 /* Nondecimal constants try unsigned even in traditional C. */
3893 type = unsigned_type_node;
3894 else if (!spec_unsigned && !spec_long_long
3895 && int_fits_type_p (yylval.ttype, long_integer_type_node))
3896 type = long_integer_type_node;
3897 else if (! spec_long_long)
3898 type = long_unsigned_type_node;
3899 else if (! spec_unsigned
3900 /* Verify value does not overflow into sign bit. */
3901 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
3902 && int_fits_type_p (yylval.ttype,
3903 long_long_integer_type_node))
3904 type = long_long_integer_type_node;
3906 type = long_long_unsigned_type_node;
3908 if (!int_fits_type_p (yylval.ttype, type) && !warn)
3909 pedwarn ("integer constant out of range");
3911 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
3912 warning ("decimal integer constant is so large that it is unsigned");
3916 if (TYPE_PRECISION (type)
3917 <= TYPE_PRECISION (integer_type_node))
3919 = build_complex (NULL_TREE, integer_zero_node,
3920 cp_convert (integer_type_node,
3923 error ("complex integer constant is too wide for `__complex int'");
3926 TREE_TYPE (yylval.ttype) = type;
3932 value = CONSTANT; break;
3938 register int result = 0;
3939 register int num_chars = 0;
3941 unsigned width = TYPE_PRECISION (char_type_node);
3943 #ifdef MULTIBYTE_CHARS
3944 int longest_char = local_mb_cur_max ();
3945 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
3948 max_chars = TYPE_PRECISION (integer_type_node) / width;
3950 width = WCHAR_TYPE_SIZE;
3957 if (c == '\'' || c == EOF)
3964 c = readescape (&ignore);
3967 if (width < HOST_BITS_PER_INT
3968 && (unsigned) c >= (1 << width))
3969 pedwarn ("escape sequence out of range for character");
3970 #ifdef MAP_CHARACTER
3972 c = MAP_CHARACTER (c);
3978 pedwarn ("ANSI C forbids newline in character constant");
3983 #ifdef MULTIBYTE_CHARS
3987 for (i = 1; i <= longest_char; ++i)
3989 if (i > maxtoken - 4)
3990 extend_token_buffer (token_buffer);
3992 token_buffer[i] = c;
3993 char_len = local_mbtowc (& wc,
4002 /* mbtowc sometimes needs an extra char before accepting */
4007 /* Merge character into result; ignore excess chars. */
4008 for (i = 1; i <= char_len; ++i)
4012 if (width < HOST_BITS_PER_INT)
4013 result = (result << width)
4015 & ((1 << width) - 1));
4017 result = token_buffer[i];
4019 num_chars += char_len;
4027 warning ("Ignoring invalid multibyte character");
4030 #ifdef MAP_CHARACTER
4032 c = MAP_CHARACTER (c);
4035 #else /* ! MULTIBYTE_CHARS */
4036 #ifdef MAP_CHARACTER
4037 c = MAP_CHARACTER (c);
4039 #endif /* ! MULTIBYTE_CHARS */
4044 if (chars_seen == 1) /* only keep the first one */
4049 /* Merge character into result; ignore excess chars. */
4051 if (num_chars < max_chars + 1)
4053 if (width < HOST_BITS_PER_INT)
4054 result = (result << width) | (c & ((1 << width) - 1));
4061 error ("malformatted character constant");
4062 else if (chars_seen == 0)
4063 error ("empty character constant");
4064 else if (num_chars > max_chars)
4066 num_chars = max_chars;
4067 error ("character constant too long");
4069 else if (chars_seen != 1 && warn_multichar)
4070 warning ("multi-character character constant");
4072 /* If char type is signed, sign-extend the constant. */
4075 int num_bits = num_chars * width;
4077 /* We already got an error; avoid invalid shift. */
4078 yylval.ttype = build_int_2 (0, 0);
4079 else if (TREE_UNSIGNED (char_type_node)
4080 || ((result >> (num_bits - 1)) & 1) == 0)
4082 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
4083 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4087 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
4088 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4090 if (chars_seen <= 1)
4091 TREE_TYPE (yylval.ttype) = char_type_node;
4093 TREE_TYPE (yylval.ttype) = integer_type_node;
4097 yylval.ttype = build_int_2 (result, 0);
4098 TREE_TYPE (yylval.ttype) = wchar_type_node;
4109 unsigned width = wide_flag ? WCHAR_TYPE_SIZE
4110 : TYPE_PRECISION (char_type_node);
4111 #ifdef MULTIBYTE_CHARS
4112 int longest_char = local_mb_cur_max ();
4113 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
4117 p = token_buffer + 1;
4119 while (c != '"' && c >= 0)
4121 /* ignore_escape_flag is set for reading the filename in #line. */
4122 if (!ignore_escape_flag && c == '\\')
4125 c = readescape (&ignore);
4128 if (width < HOST_BITS_PER_INT
4129 && (unsigned) c >= (1 << width))
4130 warning ("escape sequence out of range for character");
4135 pedwarn ("ANSI C++ forbids newline in string constant");
4140 #ifdef MULTIBYTE_CHARS
4144 for (i = 0; i < longest_char; ++i)
4146 if (p + i >= token_buffer + maxtoken)
4147 p = extend_token_buffer (p);
4150 char_len = local_mbtowc (& wc, p, i + 1);
4156 warning ("Ignoring invalid multibyte character");
4159 /* mbtowc sometimes needs an extra char before accepting */
4172 #endif /* MULTIBYTE_CHARS */
4175 /* Add this single character into the buffer either as a wchar_t
4176 or as a single byte. */
4179 unsigned width = TYPE_PRECISION (char_type_node);
4180 unsigned bytemask = (1 << width) - 1;
4183 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4184 p = extend_token_buffer (p);
4186 for (byte = 0; byte < WCHAR_BYTES; ++byte)
4189 if (byte >= sizeof (c))
4192 value = (c >> (byte * width)) & bytemask;
4193 if (BYTES_BIG_ENDIAN)
4194 p[WCHAR_BYTES - byte - 1] = value;
4202 if (p >= token_buffer + maxtoken)
4203 p = extend_token_buffer (p);
4210 error ("Unterminated string");
4215 /* Terminate the string value, either with a single byte zero
4216 or with a wide zero. */
4219 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4220 p = extend_token_buffer (p);
4221 bzero (p, WCHAR_BYTES);
4226 if (p >= token_buffer + maxtoken)
4227 p = extend_token_buffer (p);
4231 /* We have read the entire constant.
4232 Construct a STRING_CST for the result. */
4234 if (processing_template_decl)
4235 push_obstacks (&permanent_obstack, &permanent_obstack);
4236 yylval.ttype = build_string (p - (token_buffer + 1), token_buffer + 1);
4237 if (processing_template_decl)
4241 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4243 TREE_TYPE (yylval.ttype) = char_array_type_node;
4245 value = STRING; break;
4268 yylval.code = PLUS_EXPR; break;
4270 yylval.code = MINUS_EXPR; break;
4272 yylval.code = BIT_AND_EXPR; break;
4274 yylval.code = BIT_IOR_EXPR; break;
4276 yylval.code = MULT_EXPR; break;
4278 yylval.code = TRUNC_DIV_EXPR; break;
4280 yylval.code = TRUNC_MOD_EXPR; break;
4282 yylval.code = BIT_XOR_EXPR; break;
4284 yylval.code = LSHIFT_EXPR; break;
4286 yylval.code = RSHIFT_EXPR; break;
4288 yylval.code = LT_EXPR; break;
4290 yylval.code = GT_EXPR; break;
4293 token_buffer[1] = c1 = getch ();
4294 token_buffer[2] = 0;
4301 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4303 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4305 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4307 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4309 value = ASSIGN; goto done;
4315 value = PLUSPLUS; goto done;
4317 value = MINUSMINUS; goto done;
4319 value = ANDAND; goto done;
4321 value = OROR; goto done;
4329 else if ((c == '-') && (c1 == '>'))
4331 nextchar = getch ();
4332 if (nextchar == '*')
4335 value = POINTSAT_STAR;
4341 else if (c1 == '?' && (c == '<' || c == '>'))
4343 token_buffer[3] = 0;
4346 yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4349 /* <?= or >?= expression. */
4350 token_buffer[2] = c1;
4359 pedwarn ("use of `operator %s' is not standard C++",
4364 else if (c == '<' && c1 == '%')
4365 { value = '{'; goto done; }
4366 else if (c == '<' && c1 == ':')
4367 { value = '['; goto done; }
4368 else if (c == '%' && c1 == '>')
4369 { value = '}'; goto done; }
4370 else if (c == '%' && c1 == ':')
4371 { value = '#'; goto done; }
4374 token_buffer[1] = 0;
4384 token_buffer[1] = ':';
4385 token_buffer[2] = '\0';
4402 /* Don't make yyparse think this is eof. */
4407 /* try, weakly, to handle casts to pointers to functions. */
4408 nextchar = skip_white_space (getch ());
4409 if (nextchar == '*')
4411 int next_c = skip_white_space (getch ());
4415 yylval.ttype = build1 (INDIRECT_REF, 0, 0);
4416 value = PAREN_STAR_PAREN;
4424 else if (nextchar == ')')
4427 yylval.ttype = NULL_TREE;
4438 /* yylloc.last_line = lineno; */
4439 #ifdef GATHER_STATISTICS
4440 #ifdef REDUCE_LENGTH
4441 token_count[value] += 1;
4452 return !!is_reserved_word (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
4455 #ifdef GATHER_STATISTICS
4456 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4457 need to be brought into here, unless this were actually put into a header
4459 /* Statistics-gathering stuff. */
4480 extern int tree_node_counts[];
4481 extern int tree_node_sizes[];
4484 /* Place to save freed lang_decls which were allocated on the
4485 permanent_obstack. @@ Not currently used. */
4486 tree free_lang_decl_chain;
4489 build_lang_decl (code, name, type)
4490 enum tree_code code;
4494 register tree t = build_decl (code, name, type);
4495 struct obstack *obstack = current_obstack;
4496 register int i = sizeof (struct lang_decl) / sizeof (int);
4499 if (! TREE_PERMANENT (t))
4500 obstack = saveable_obstack;
4502 /* Could be that saveable is permanent and current is not. */
4503 obstack = &permanent_obstack;
4505 if (free_lang_decl_chain && obstack == &permanent_obstack)
4507 pi = (int *)free_lang_decl_chain;
4508 free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
4511 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4516 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4517 LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4518 = obstack == &permanent_obstack;
4519 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4520 == TREE_PERMANENT (t), 234);
4521 DECL_MAIN_VARIANT (t) = t;
4522 if (current_lang_name == lang_name_cplusplus)
4523 DECL_LANGUAGE (t) = lang_cplusplus;
4524 else if (current_lang_name == lang_name_c)
4525 DECL_LANGUAGE (t) = lang_c;
4526 else if (current_lang_name == lang_name_java)
4527 DECL_LANGUAGE (t) = lang_java;
4528 else my_friendly_abort (64);
4530 #if 0 /* not yet, should get fixed properly later */
4531 if (code == TYPE_DECL)
4534 id = get_identifier (build_overload_name (type, 1, 1));
4535 DECL_ASSEMBLER_NAME (t) = id;
4539 #ifdef GATHER_STATISTICS
4540 tree_node_counts[(int)lang_decl] += 1;
4541 tree_node_sizes[(int)lang_decl] += sizeof (struct lang_decl);
4548 build_lang_field_decl (code, name, type)
4549 enum tree_code code;
4553 extern struct obstack *current_obstack, *saveable_obstack;
4554 register tree t = build_decl (code, name, type);
4555 struct obstack *obstack = current_obstack;
4556 register int i = sizeof (struct lang_decl_flags) / sizeof (int);
4558 #if 0 /* not yet, should get fixed properly later */
4560 if (code == TYPE_DECL)
4563 id = get_identifier (build_overload_name (type, 1, 1));
4564 DECL_ASSEMBLER_NAME (t) = id;
4568 if (! TREE_PERMANENT (t))
4569 obstack = saveable_obstack;
4571 my_friendly_assert (obstack == &permanent_obstack, 235);
4573 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
4577 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4582 copy_lang_decl (node)
4588 if (! DECL_LANG_SPECIFIC (node))
4591 if (TREE_CODE (node) == FIELD_DECL)
4592 size = sizeof (struct lang_decl_flags);
4594 size = sizeof (struct lang_decl);
4595 pi = (int *)obstack_alloc (&permanent_obstack, size);
4596 bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
4597 DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
4601 make_lang_type (code)
4602 enum tree_code code;
4604 extern struct obstack *current_obstack, *saveable_obstack;
4605 register tree t = make_node (code);
4606 struct obstack *obstack = current_obstack;
4607 register int i = sizeof (struct lang_type) / sizeof (int);
4610 /* Set up some flags that give proper default behavior. */
4611 IS_AGGR_TYPE (t) = 1;
4613 if (! TREE_PERMANENT (t))
4614 obstack = saveable_obstack;
4616 my_friendly_assert (obstack == &permanent_obstack, 236);
4618 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
4622 TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
4623 CLASSTYPE_AS_LIST (t) = build_expr_list (NULL_TREE, t);
4624 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
4625 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
4626 TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE,
4628 CLASSTYPE_BINFO_AS_LIST (t) = build_tree_list (NULL_TREE, TYPE_BINFO (t));
4630 /* Make sure this is laid out, for ease of use later.
4631 In the presence of parse errors, the normal was of assuring
4632 this might not ever get executed, so we lay it out *immediately*. */
4633 build_pointer_type (t);
4635 #ifdef GATHER_STATISTICS
4636 tree_node_counts[(int)lang_type] += 1;
4637 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
4644 dump_time_statistics ()
4646 register tree prev = 0, decl, next;
4647 int this_time = my_get_run_time ();
4648 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
4649 += this_time - body_time;
4651 fprintf (stderr, "\n******\n");
4652 print_time ("header files (total)", header_time);
4653 print_time ("main file (total)", this_time - body_time);
4654 fprintf (stderr, "ratio = %g : 1\n",
4655 (double)header_time / (double)(this_time - body_time));
4656 fprintf (stderr, "\n******\n");
4658 for (decl = filename_times; decl; decl = next)
4660 next = IDENTIFIER_GLOBAL_VALUE (decl);
4661 SET_IDENTIFIER_GLOBAL_VALUE (decl, prev);
4665 for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
4666 print_time (IDENTIFIER_POINTER (decl),
4667 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
4671 compiler_error (s, v, v2)
4673 HOST_WIDE_INT v, v2; /* @@also used as pointer */
4676 sprintf (buf, s, v, v2);
4677 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
4684 extern int end_of_file;
4687 strcpy (buf, string);
4689 /* We can't print string and character constants well
4690 because the token_buffer contains the result of processing escapes. */
4692 strcat (buf, input_redirected ()
4693 ? " at end of saved text"
4694 : " at end of input");
4695 else if (token_buffer[0] == 0)
4696 strcat (buf, " at null character");
4697 else if (token_buffer[0] == '"')
4698 strcat (buf, " before string constant");
4699 else if (token_buffer[0] == '\'')
4700 strcat (buf, " before character constant");
4701 else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
4702 sprintf (buf + strlen (buf), " before character 0%o",
4703 (unsigned char) token_buffer[0]);
4705 strcat (buf, " before `%s'");
4707 error (buf, token_buffer);
4711 handle_cp_pragma (pname)
4716 if (! strcmp (pname, "vtable"))
4718 extern tree pending_vtables;
4720 /* More follows: it must be a string constant (class name). */
4721 token = real_yylex ();
4722 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4724 error ("invalid #pragma vtable");
4728 if (write_virtuals != 2)
4730 warning ("use `+e2' option to enable #pragma vtable");
4734 = perm_tree_cons (NULL_TREE,
4735 get_identifier (TREE_STRING_POINTER (yylval.ttype)),
4737 token = real_yylex ();
4738 if (token != END_OF_LINE)
4739 warning ("trailing characters ignored");
4742 else if (! strcmp (pname, "unit"))
4744 /* More follows: it must be a string constant (unit name). */
4745 token = real_yylex ();
4746 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4748 error ("invalid #pragma unit");
4751 token = real_yylex ();
4752 if (token != END_OF_LINE)
4753 warning ("trailing characters ignored");
4756 else if (! strcmp (pname, "interface"))
4758 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4759 char *main_filename = input_filename;
4761 main_filename = file_name_nondirectory (main_filename);
4763 token = real_yylex ();
4765 if (token != END_OF_LINE)
4768 || TREE_CODE (yylval.ttype) != STRING_CST)
4770 error ("invalid `#pragma interface'");
4773 main_filename = TREE_STRING_POINTER (yylval.ttype);
4774 token = real_yylex ();
4777 if (token != END_OF_LINE)
4778 warning ("garbage after `#pragma interface' ignored");
4780 #ifndef NO_LINKAGE_HEURISTICS
4783 if (impl_file_chain == 0)
4785 /* If this is zero at this point, then we are
4786 auto-implementing. */
4787 if (main_input_filename == 0)
4788 main_input_filename = input_filename;
4790 #ifdef AUTO_IMPLEMENT
4791 filename = file_name_nondirectory (main_input_filename);
4792 fi = get_time_identifier (filename);
4793 fi = IDENTIFIER_CLASS_VALUE (fi);
4794 TREE_INT_CST_LOW (fi) = 0;
4795 TREE_INT_CST_HIGH (fi) = 1;
4797 impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
4798 impl_file_chain->filename = filename;
4799 impl_file_chain->next = 0;
4803 interface_only = interface_strcmp (main_filename);
4804 interface_unknown = 0;
4805 TREE_INT_CST_LOW (fileinfo) = interface_only;
4806 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4807 #endif /* NO_LINKAGE_HEURISTICS */
4811 else if (! strcmp (pname, "implementation"))
4813 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4814 char *main_filename = main_input_filename ? main_input_filename : input_filename;
4816 main_filename = file_name_nondirectory (main_filename);
4817 token = real_yylex ();
4818 if (token != END_OF_LINE)
4821 || TREE_CODE (yylval.ttype) != STRING_CST)
4823 error ("invalid `#pragma implementation'");
4826 main_filename = TREE_STRING_POINTER (yylval.ttype);
4827 token = real_yylex ();
4830 if (token != END_OF_LINE)
4831 warning ("garbage after `#pragma implementation' ignored");
4833 #ifndef NO_LINKAGE_HEURISTICS
4834 if (write_virtuals == 3)
4836 struct impl_files *ifiles = impl_file_chain;
4839 if (! strcmp (ifiles->filename, main_filename))
4841 ifiles = ifiles->next;
4845 ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
4846 ifiles->filename = main_filename;
4847 ifiles->next = impl_file_chain;
4848 impl_file_chain = ifiles;
4851 else if ((main_input_filename != 0
4852 && ! strcmp (main_input_filename, input_filename))
4853 || ! strcmp (input_filename, main_filename))
4856 if (impl_file_chain == 0)
4858 impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
4859 impl_file_chain->filename = main_filename;
4860 impl_file_chain->next = 0;
4864 error ("`#pragma implementation' can only appear at top-level");
4867 /* We make this non-zero so that we infer decl linkage
4868 in the impl file only for variables first declared
4869 in the interface file. */
4870 interface_unknown = 1;
4872 /* We make this zero so that templates in the impl
4873 file will be emitted properly. */
4874 interface_unknown = 0;
4876 TREE_INT_CST_LOW (fileinfo) = interface_only;
4877 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4878 #endif /* NO_LINKAGE_HEURISTICS */
4886 #ifdef HANDLE_SYSV_PRAGMA
4888 /* Handle a #pragma directive. INPUT is the current input stream,
4889 and C is a character to reread. Processes the entire input line
4890 and returns a character for the caller to reread: either \n or EOF. */
4892 /* This function has to be in this file, in order to get at
4896 handle_sysv_pragma (token)
4907 handle_pragma_token ("ignored", yylval.ttype);
4910 handle_pragma_token ("(", NULL_TREE);
4913 handle_pragma_token (")", NULL_TREE);
4916 handle_pragma_token (",", NULL_TREE);
4919 handle_pragma_token ("=", NULL_TREE);
4922 handle_pragma_token ("(", NULL_TREE);
4923 handle_pragma_token (")", NULL_TREE);
4927 handle_pragma_token (NULL_PTR, NULL_TREE);
4930 token = real_yylex ();
4933 #endif /* HANDLE_SYSV_PRAGMA */