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 /* MULTIBYTE_CHARS support only works for native compilers.
43 ??? Ideally what we want is to model widechar support after
44 the current floating point support. */
46 #undef MULTIBYTE_CHARS
49 #ifdef MULTIBYTE_CHARS
53 #define obstack_chunk_alloc xmalloc
54 #define obstack_chunk_free free
57 #define DIR_SEPARATOR '/'
60 extern struct obstack permanent_obstack;
61 extern struct obstack *current_obstack, *saveable_obstack;
63 extern void yyprint PROTO((FILE *, int, YYSTYPE));
64 extern void set_float_handler PROTO((jmp_buf));
65 extern void compiler_error PROTO((char *, HOST_WIDE_INT,
68 static tree get_time_identifier PROTO((char *));
69 static int check_newline PROTO((void));
70 static int skip_white_space PROTO((int));
71 static void finish_defarg PROTO((void));
72 static int my_get_run_time PROTO((void));
73 static int get_last_nonwhite_on_line PROTO((void));
74 static int interface_strcmp PROTO((char *));
75 static int readescape PROTO((int *));
76 static char *extend_token_buffer PROTO((char *));
77 static void consume_string PROTO((struct obstack *, int));
78 static void set_typedecl_interface_info PROTO((tree, tree));
79 static void feed_defarg PROTO((tree, tree));
80 static int set_vardecl_interface_info PROTO((tree, tree));
81 static void store_pending_inline PROTO((tree, struct pending_inline *));
82 static void reinit_parse_for_expr PROTO((struct obstack *));
83 static int *init_cpp_parse PROTO((void));
84 static int handle_cp_pragma PROTO((char *));
85 #ifdef HANDLE_SYSV_PRAGMA
86 static int handle_sysv_pragma PROTO((int));
88 #ifdef GATHER_STATISTICS
90 static int reduce_cmp PROTO((int *, int *));
91 static int token_cmp PROTO((int *, int *));
95 /* Given a file name X, return the nondirectory portion.
96 Keep in mind that X can be computed more than once. */
98 file_name_nondirectory (x)
101 char *tmp = (char *) rindex (x, '/');
102 if (DIR_SEPARATOR != '/' && ! tmp)
103 tmp = (char *) rindex (x, DIR_SEPARATOR);
105 return (char *) (tmp + 1);
110 /* This obstack is needed to hold text. It is not safe to use
111 TOKEN_BUFFER because `check_newline' calls `yylex'. */
112 struct obstack inline_text_obstack;
113 char *inline_text_firstobj;
117 extern cpp_reader parse_in;
123 /* Pending language change.
124 Positive is push count, negative is pop count. */
125 int pending_lang_change = 0;
127 /* Wrap the current header file in extern "C". */
128 static int c_header_level = 0;
130 extern int first_token;
131 extern struct obstack token_obstack;
133 /* ??? Don't really know where this goes yet. */
137 extern void put_back (/* int */);
138 extern int input_redirected ();
139 extern void feed_input (/* char *, int */);
142 /* Holds translations from TREE_CODEs to operator name strings,
143 i.e., opname_tab[PLUS_EXPR] == "+". */
147 extern int yychar; /* the lookahead symbol */
148 extern YYSTYPE yylval; /* the semantic value of the */
149 /* lookahead symbol */
152 YYLTYPE yylloc; /* location data for the lookahead */
157 /* the declaration found for the last IDENTIFIER token read in.
158 yylex must look this up to detect typedefs, which get token type TYPENAME,
159 so it is left around in case the identifier is not a typedef but is
160 used in a context which makes it a reference to a variable. */
163 /* The elements of `ridpointers' are identifier nodes
164 for the reserved type names and storage classes.
165 It is indexed by a RID_... value. */
166 tree ridpointers[(int) RID_MAX];
168 /* We may keep statistics about how long which files took to compile. */
169 static int header_time, body_time;
170 static tree filename_times;
171 static tree this_filename_time;
173 /* Array for holding counts of the numbers of tokens seen. */
174 extern int *token_count;
176 /* Return something to represent absolute declarators containing a *.
177 TARGET is the absolute declarator that the * contains.
178 CV_QUALIFIERS is a list of modifiers such as const or volatile
179 to apply to the pointer type, represented as identifiers.
181 We return an INDIRECT_REF whose "contents" are TARGET
182 and whose type is the modifier list. */
185 make_pointer_declarator (cv_qualifiers, target)
186 tree cv_qualifiers, target;
188 if (target && TREE_CODE (target) == IDENTIFIER_NODE
189 && ANON_AGGRNAME_P (target))
190 error ("type name expected before `*'");
191 target = build_parse_node (INDIRECT_REF, target);
192 TREE_TYPE (target) = cv_qualifiers;
196 /* Return something to represent absolute declarators containing a &.
197 TARGET is the absolute declarator that the & contains.
198 CV_QUALIFIERS is a list of modifiers such as const or volatile
199 to apply to the reference type, represented as identifiers.
201 We return an ADDR_EXPR whose "contents" are TARGET
202 and whose type is the modifier list. */
205 make_reference_declarator (cv_qualifiers, target)
206 tree cv_qualifiers, target;
210 if (TREE_CODE (target) == ADDR_EXPR)
212 error ("cannot declare references to references");
215 if (TREE_CODE (target) == INDIRECT_REF)
217 error ("cannot declare pointers to references");
220 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
221 error ("type name expected before `&'");
223 target = build_parse_node (ADDR_EXPR, target);
224 TREE_TYPE (target) = cv_qualifiers;
229 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
230 tree target, parms, cv_qualifiers, exception_specification;
232 target = build_parse_node (CALL_EXPR, target, parms, cv_qualifiers);
233 TREE_TYPE (target) = exception_specification;
238 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
239 tree call_declarator, cv_qualifiers, exception_specification;
241 TREE_OPERAND (call_declarator, 2) = cv_qualifiers;
242 TREE_TYPE (call_declarator) = exception_specification;
245 /* Build names and nodes for overloaded operators. */
247 tree ansi_opname[LAST_CPLUS_TREE_CODE];
248 tree ansi_assopname[LAST_CPLUS_TREE_CODE];
251 operator_name_string (name)
254 char *opname = IDENTIFIER_POINTER (name) + 2;
258 /* Works for builtin and user defined types. */
259 if (IDENTIFIER_GLOBAL_VALUE (name)
260 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
261 return IDENTIFIER_POINTER (name);
263 if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
267 opname_table = ansi_assopname;
272 opname_table = ansi_opname;
275 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
277 if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
278 && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
282 if (i == LAST_CPLUS_TREE_CODE)
283 return "<invalid operator>";
286 return assignop_tab[i];
288 return opname_tab[i];
291 int interface_only; /* whether or not current file is only for
292 interface definitions. */
293 int interface_unknown; /* whether or not we know this class
294 to behave according to #pragma interface. */
296 /* lexical analyzer */
298 /* File used for outputting assembler code. */
299 extern FILE *asm_out_file;
301 #ifndef WCHAR_TYPE_SIZE
303 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
305 #define WCHAR_TYPE_SIZE BITS_PER_WORD
309 /* Number of bytes in a wide character. */
310 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
312 static int maxtoken; /* Current nominal length of token buffer. */
313 char *token_buffer; /* Pointer to token buffer.
314 Actual allocated length is maxtoken + 2. */
319 /* Nonzero tells yylex to ignore \ in string constants. */
320 static int ignore_escape_flag = 0;
323 get_time_identifier (name)
326 tree time_identifier;
327 int len = strlen (name);
328 char *buf = (char *) alloca (len + 6);
329 strcpy (buf, "file ");
330 bcopy (name, buf+5, len);
332 time_identifier = get_identifier (buf);
333 if (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
335 push_obstacks_nochange ();
336 end_temporary_allocation ();
337 IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
338 IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
339 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier, filename_times);
340 filename_times = time_identifier;
343 return time_identifier;
352 int old_quiet_flag = quiet_flag;
355 this_time = get_run_time ();
356 quiet_flag = old_quiet_flag;
360 /* Table indexed by tree code giving a string containing a character
361 classifying the tree code. Possibilities are
362 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
364 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
366 char cplus_tree_code_type[] = {
368 #include "cp-tree.def"
372 /* Table indexed by tree code giving number of expression
373 operands beyond the fixed part of the node structure.
374 Not used for types or decls. */
376 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
378 int cplus_tree_code_length[] = {
380 #include "cp-tree.def"
384 /* Names of tree components.
385 Used for printing out the tree and error messages. */
386 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
388 char *cplus_tree_code_name[] = {
390 #include "cp-tree.def"
394 /* toplev.c needs to call these. */
399 /* the beginning of the file is a new line; check for # */
400 /* With luck, we discover the real source file's name from that
401 and put it in input_filename. */
402 put_back (check_newline ());
403 if (flag_gnu_xref) GNU_xref_begin (input_filename);
404 init_repo (input_filename);
406 /* See comments in toplev.c before the call to lang_init. */
407 if (flag_exceptions == 2)
414 extern int errorcount, sorrycount;
415 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
425 init_filename_times ()
427 this_filename_time = get_time_identifier ("<top level>");
428 if (flag_detailed_statistics)
431 body_time = my_get_run_time ();
432 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
436 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
437 Stuck this hack in to get the files open correctly; this is called
438 in place of init_parse if we are an unexec'd binary. */
442 reinit_lang_specific ()
444 init_filename_times ();
445 reinit_search_statistics ();
452 #ifdef GATHER_STATISTICS
454 reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
455 bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
457 token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
458 bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
466 init_parse (filename)
469 extern int flag_no_gnu_keywords;
470 extern int flag_operator_names;
475 /* Open input file. */
476 if (filename == 0 || !strcmp (filename, "-"))
482 finput = fopen (filename, "r");
484 pfatal_with_name (filename);
486 #ifdef IO_BUFFER_SIZE
487 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
489 #endif /* !USE_CPPLIB */
491 /* Initialize the lookahead machinery. */
494 /* Make identifier nodes long enough for the language-specific slots. */
495 set_identifier_size (sizeof (struct lang_identifier));
496 decl_printable_name = lang_printable_name;
498 init_cplus_expand ();
500 bcopy (cplus_tree_code_type,
501 tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
502 (int)LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
503 bcopy ((char *)cplus_tree_code_length,
504 (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
505 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
506 bcopy ((char *)cplus_tree_code_name,
507 (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
508 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
510 opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
511 bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
512 assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
513 bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
515 ansi_opname[0] = get_identifier ("<invalid operator>");
516 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
518 ansi_opname[i] = ansi_opname[0];
519 ansi_assopname[i] = ansi_opname[0];
522 ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
523 IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
524 ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
525 ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
526 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
527 ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
528 ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
529 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
530 ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
531 IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
532 ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
533 ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
534 ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
535 ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
536 IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
537 ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
538 ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
539 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
540 ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
541 ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
542 IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
543 ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
544 IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
545 ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
546 IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
547 ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
548 IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
549 ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
550 IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
551 ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
552 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
553 ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
554 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
555 ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
556 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
557 ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
558 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
559 ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
560 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
561 ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
562 ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
563 IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
564 ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
565 ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
566 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
567 ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
568 IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
569 ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
570 IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
571 ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
572 ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
573 ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
574 ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
575 ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
576 ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
577 ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
578 ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
579 ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
580 IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
581 ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
582 IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
583 ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
584 ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
585 ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
586 IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
587 ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
588 IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
589 ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
590 IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
591 ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
592 IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
593 ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
594 IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
595 ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
596 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
597 ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
598 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
599 ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
600 ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
601 ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
602 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
603 ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
604 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
605 ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
606 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
607 ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
608 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
609 ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
610 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
611 ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
612 ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
613 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
614 ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
615 IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
616 ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
617 IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
618 ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
619 IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
620 ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
621 IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
622 ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
623 IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
624 ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
625 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
626 ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
627 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
628 ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
629 IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
631 /* This is not true: these operators are not defined in ANSI,
632 but we need them anyway. */
633 ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
634 IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
635 ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
636 IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
637 ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
638 IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
639 ansi_opname[(int) SIZEOF_EXPR] = get_identifier ("__sz");
640 IDENTIFIER_OPNAME_P (ansi_opname[(int) SIZEOF_EXPR]) = 1;
644 gcc_obstack_init (&inline_text_obstack);
645 inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
647 /* Start it at 0, because check_newline is called at the very beginning
648 and will increment it to 1. */
650 input_filename = "<internal>";
651 current_function_decl = NULL;
654 token_buffer = (char *) xmalloc (maxtoken + 2);
656 ridpointers[(int) RID_INT] = get_identifier ("int");
657 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
658 build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
659 ridpointers[(int) RID_BOOL] = get_identifier ("bool");
660 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_BOOL],
661 build_tree_list (NULL_TREE, ridpointers[(int) RID_BOOL]));
662 ridpointers[(int) RID_CHAR] = get_identifier ("char");
663 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
664 build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
665 ridpointers[(int) RID_VOID] = get_identifier ("void");
666 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
667 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
668 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
669 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
670 build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
671 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
672 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
673 build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
674 ridpointers[(int) RID_SHORT] = get_identifier ("short");
675 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
676 build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
677 ridpointers[(int) RID_LONG] = get_identifier ("long");
678 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
679 build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
680 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
681 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
682 build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
683 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
684 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
685 build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
686 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
687 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
688 build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
689 ridpointers[(int) RID_CONST] = get_identifier ("const");
690 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
691 build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
692 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
693 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
694 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
695 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
696 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
697 build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
698 ridpointers[(int) RID_STATIC] = get_identifier ("static");
699 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
700 build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
701 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
702 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
703 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
704 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
705 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
706 build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
707 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
708 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
709 build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
710 ridpointers[(int) RID_COMPLEX] = get_identifier ("__complex");
711 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_COMPLEX],
712 build_tree_list (NULL_TREE, ridpointers[(int) RID_COMPLEX]));
714 /* C++ extensions. These are probably not correctly named. */
715 ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
716 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
717 build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
718 class_type_node = build_int_2 (class_type, 0);
719 TREE_TYPE (class_type_node) = class_type_node;
720 ridpointers[(int) RID_CLASS] = class_type_node;
722 record_type_node = build_int_2 (record_type, 0);
723 TREE_TYPE (record_type_node) = record_type_node;
724 ridpointers[(int) RID_RECORD] = record_type_node;
726 union_type_node = build_int_2 (union_type, 0);
727 TREE_TYPE (union_type_node) = union_type_node;
728 ridpointers[(int) RID_UNION] = union_type_node;
730 enum_type_node = build_int_2 (enum_type, 0);
731 TREE_TYPE (enum_type_node) = enum_type_node;
732 ridpointers[(int) RID_ENUM] = enum_type_node;
734 ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
735 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
736 build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
737 ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
738 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPLICIT],
739 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPLICIT]));
740 ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
741 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
742 build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
744 ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
745 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
746 build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
747 ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
748 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
749 build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
750 ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
751 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
752 build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
753 ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
754 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TEMPLATE],
755 build_tree_list (NULL_TREE, ridpointers[(int) RID_TEMPLATE]));
756 /* This is for ANSI C++. */
757 ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
758 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
759 build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
761 /* Signature handling extensions. */
762 signature_type_node = build_int_2 (signature_type, 0);
763 TREE_TYPE (signature_type_node) = signature_type_node;
764 ridpointers[(int) RID_SIGNATURE] = signature_type_node;
766 null_node = build_int_2 (0, 0);
767 ridpointers[RID_NULL] = null_node;
769 opname_tab[(int) COMPONENT_REF] = "->";
770 opname_tab[(int) MEMBER_REF] = "->*";
771 opname_tab[(int) INDIRECT_REF] = "*";
772 opname_tab[(int) ARRAY_REF] = "[]";
773 opname_tab[(int) MODIFY_EXPR] = "=";
774 opname_tab[(int) NEW_EXPR] = "new";
775 opname_tab[(int) DELETE_EXPR] = "delete";
776 opname_tab[(int) VEC_NEW_EXPR] = "new []";
777 opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
778 opname_tab[(int) COND_EXPR] = "?:";
779 opname_tab[(int) CALL_EXPR] = "()";
780 opname_tab[(int) PLUS_EXPR] = "+";
781 opname_tab[(int) MINUS_EXPR] = "-";
782 opname_tab[(int) MULT_EXPR] = "*";
783 opname_tab[(int) TRUNC_DIV_EXPR] = "/";
784 opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
785 opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
786 opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
787 opname_tab[(int) TRUNC_MOD_EXPR] = "%";
788 opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
789 opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
790 opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
791 opname_tab[(int) NEGATE_EXPR] = "-";
792 opname_tab[(int) MIN_EXPR] = "<?";
793 opname_tab[(int) MAX_EXPR] = ">?";
794 opname_tab[(int) ABS_EXPR] = "abs";
795 opname_tab[(int) FFS_EXPR] = "ffs";
796 opname_tab[(int) LSHIFT_EXPR] = "<<";
797 opname_tab[(int) RSHIFT_EXPR] = ">>";
798 opname_tab[(int) BIT_IOR_EXPR] = "|";
799 opname_tab[(int) BIT_XOR_EXPR] = "^";
800 opname_tab[(int) BIT_AND_EXPR] = "&";
801 opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
802 opname_tab[(int) BIT_NOT_EXPR] = "~";
803 opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
804 opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
805 opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
806 opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
807 opname_tab[(int) TRUTH_NOT_EXPR] = "!";
808 opname_tab[(int) LT_EXPR] = "<";
809 opname_tab[(int) LE_EXPR] = "<=";
810 opname_tab[(int) GT_EXPR] = ">";
811 opname_tab[(int) GE_EXPR] = ">=";
812 opname_tab[(int) EQ_EXPR] = "==";
813 opname_tab[(int) NE_EXPR] = "!=";
814 opname_tab[(int) IN_EXPR] = "in";
815 opname_tab[(int) RANGE_EXPR] = "...";
816 opname_tab[(int) CONVERT_EXPR] = "+";
817 opname_tab[(int) ADDR_EXPR] = "&";
818 opname_tab[(int) PREDECREMENT_EXPR] = "--";
819 opname_tab[(int) PREINCREMENT_EXPR] = "++";
820 opname_tab[(int) POSTDECREMENT_EXPR] = "--";
821 opname_tab[(int) POSTINCREMENT_EXPR] = "++";
822 opname_tab[(int) COMPOUND_EXPR] = ",";
824 assignop_tab[(int) NOP_EXPR] = "=";
825 assignop_tab[(int) PLUS_EXPR] = "+=";
826 assignop_tab[(int) CONVERT_EXPR] = "+=";
827 assignop_tab[(int) MINUS_EXPR] = "-=";
828 assignop_tab[(int) NEGATE_EXPR] = "-=";
829 assignop_tab[(int) MULT_EXPR] = "*=";
830 assignop_tab[(int) INDIRECT_REF] = "*=";
831 assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
832 assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
833 assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
834 assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
835 assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
836 assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
837 assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
838 assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
839 assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
840 assignop_tab[(int) MIN_EXPR] = "<?=";
841 assignop_tab[(int) MAX_EXPR] = ">?=";
842 assignop_tab[(int) LSHIFT_EXPR] = "<<=";
843 assignop_tab[(int) RSHIFT_EXPR] = ">>=";
844 assignop_tab[(int) BIT_IOR_EXPR] = "|=";
845 assignop_tab[(int) BIT_XOR_EXPR] = "^=";
846 assignop_tab[(int) BIT_AND_EXPR] = "&=";
847 assignop_tab[(int) ADDR_EXPR] = "&=";
849 init_filename_times ();
851 /* Some options inhibit certain reserved words.
852 Clear those words out of the hash table so they won't be recognized. */
853 #define UNSET_RESERVED_WORD(STRING) \
854 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
855 if (s) s->name = ""; } while (0)
858 /* let's parse things, and if they use it, then give them an error. */
859 if (!flag_exceptions)
861 UNSET_RESERVED_WORD ("throw");
862 UNSET_RESERVED_WORD ("try");
863 UNSET_RESERVED_WORD ("catch");
867 if (!flag_rtti || flag_no_gnu_keywords)
869 UNSET_RESERVED_WORD ("classof");
870 UNSET_RESERVED_WORD ("headof");
873 if (! flag_handle_signatures || flag_no_gnu_keywords)
875 /* Easiest way to not recognize signature
876 handling extensions... */
877 UNSET_RESERVED_WORD ("signature");
878 UNSET_RESERVED_WORD ("sigof");
880 if (flag_no_asm || flag_no_gnu_keywords)
881 UNSET_RESERVED_WORD ("typeof");
882 if (! flag_operator_names)
884 /* These are new ANSI keywords that may break code. */
885 UNSET_RESERVED_WORD ("and");
886 UNSET_RESERVED_WORD ("and_eq");
887 UNSET_RESERVED_WORD ("bitand");
888 UNSET_RESERVED_WORD ("bitor");
889 UNSET_RESERVED_WORD ("compl");
890 UNSET_RESERVED_WORD ("not");
891 UNSET_RESERVED_WORD ("not_eq");
892 UNSET_RESERVED_WORD ("or");
893 UNSET_RESERVED_WORD ("or_eq");
894 UNSET_RESERVED_WORD ("xor");
895 UNSET_RESERVED_WORD ("xor_eq");
898 token_count = init_cpp_parse ();
899 interface_unknown = 1;
908 cpp_finish (&parse_in);
915 reinit_parse_for_function ()
917 current_base_init_list = NULL_TREE;
918 current_member_init_list = NULL_TREE;
925 yyprint (file, yychar, yylval)
937 case IDENTIFIER_DEFN:
941 case PRE_PARSED_CLASS_DECL:
943 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
945 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
948 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
949 if (IDENTIFIER_POINTER (t))
950 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
953 if (yylval.ttype == class_type_node)
954 fprintf (file, " `class'");
955 else if (yylval.ttype == record_type_node)
956 fprintf (file, " `struct'");
957 else if (yylval.ttype == union_type_node)
958 fprintf (file, " `union'");
959 else if (yylval.ttype == enum_type_node)
960 fprintf (file, " `enum'");
961 else if (yylval.ttype == signature_type_node)
962 fprintf (file, " `signature'");
964 my_friendly_abort (80);
969 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
970 static int *reduce_count;
976 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
977 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
980 #ifdef GATHER_STATISTICS
986 reduce_count[yyn] += 1;
993 return reduce_count[*q] - reduce_count[*p];
1000 return token_count[*q] - token_count[*p];
1006 print_parse_statistics ()
1008 #ifdef GATHER_STATISTICS
1009 #ifdef REDUCE_LENGTH
1012 int maxlen = REDUCE_LENGTH;
1015 if (reduce_count[-1] == 0)
1018 if (TOKEN_LENGTH > REDUCE_LENGTH)
1019 maxlen = TOKEN_LENGTH;
1020 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1022 for (i = 0; i < TOKEN_LENGTH; i++)
1024 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1025 for (i = 0; i < TOKEN_LENGTH; i++)
1027 int idx = sorted[i];
1028 if (token_count[idx] == 0)
1030 if (token_count[idx] < token_count[-1])
1032 fprintf (stderr, "token %d, `%s', count = %d\n",
1033 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
1035 fprintf (stderr, "\n");
1036 for (i = 0; i < REDUCE_LENGTH; i++)
1038 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1039 for (i = 0; i < REDUCE_LENGTH; i++)
1041 int idx = sorted[i];
1042 if (reduce_count[idx] == 0)
1044 if (reduce_count[idx] < reduce_count[-1])
1046 fprintf (stderr, "rule %d, line %d, count = %d\n",
1047 idx, yyrline[idx], reduce_count[idx]);
1049 fprintf (stderr, "\n");
1055 /* Sets the value of the 'yydebug' variable to VALUE.
1056 This is a function so we don't have to have YYDEBUG defined
1057 in order to build the compiler. */
1067 warning ("YYDEBUG not defined.");
1072 /* Functions and data structures for #pragma interface.
1074 `#pragma implementation' means that the main file being compiled
1075 is considered to implement (provide) the classes that appear in
1076 its main body. I.e., if this is file "foo.cc", and class `bar'
1077 is defined in "foo.cc", then we say that "foo.cc implements bar".
1079 All main input files "implement" themselves automagically.
1081 `#pragma interface' means that unless this file (of the form "foo.h"
1082 is not presently being included by file "foo.cc", the
1083 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1084 of the vtables nor any of the inline functions defined in foo.h
1085 will ever be output.
1087 There are cases when we want to link files such as "defs.h" and
1088 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1089 and "main.cc" has `#pragma implementation "defs.h"'. */
1094 struct impl_files *next;
1097 static struct impl_files *impl_file_chain;
1099 /* Helper function to load global variables with interface
1103 extract_interface_info ()
1107 if (flag_alt_external_templates)
1109 struct tinst_level *til = tinst_for_decl ();
1112 fileinfo = get_time_identifier (til->file);
1115 fileinfo = get_time_identifier (input_filename);
1116 fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
1117 interface_only = TREE_INT_CST_LOW (fileinfo);
1118 interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1121 /* Return nonzero if S is not considered part of an
1122 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1125 interface_strcmp (s)
1128 /* Set the interface/implementation bits for this scope. */
1129 struct impl_files *ifiles;
1132 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1134 char *t1 = ifiles->filename;
1137 if (*s1 != *t1 || *s1 == 0)
1140 while (*s1 == *t1 && *s1 != 0)
1147 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1148 if (index (s1, '.') || index (t1, '.'))
1151 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1163 set_typedecl_interface_info (prev, vars)
1166 tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
1167 tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
1168 tree type = TREE_TYPE (vars);
1170 CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
1171 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars)));
1175 set_vardecl_interface_info (prev, vars)
1178 tree type = DECL_CONTEXT (vars);
1180 if (CLASSTYPE_INTERFACE_KNOWN (type))
1182 if (CLASSTYPE_INTERFACE_ONLY (type))
1183 set_typedecl_interface_info (prev, TYPE_MAIN_DECL (type));
1185 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
1186 DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
1187 TREE_PUBLIC (vars) = 1;
1193 /* Called from the top level: if there are any pending inlines to
1194 do, set up to process them now. This function sets up the first function
1195 to be parsed; after it has been, the rule for fndef in parse.y will
1196 call process_next_inline to start working on the next one. */
1199 do_pending_inlines ()
1201 struct pending_inline *t;
1204 /* Oops, we're still dealing with the last batch. */
1205 if (yychar == PRE_PARSED_FUNCTION_DECL)
1208 /* Reverse the pending inline functions, since
1209 they were cons'd instead of appended. */
1211 struct pending_inline *prev = 0, *tail;
1212 t = pending_inlines;
1213 pending_inlines = 0;
1228 /* Now start processing the first inline function. */
1229 context = hack_decl_function_context (t->fndecl);
1231 push_cp_function_context (context);
1232 maybe_begin_member_template_processing (t->fndecl);
1235 feed_input (t->buf, t->len);
1238 if (input_filename != t->filename)
1240 input_filename = t->filename;
1241 /* Get interface/implementation back in sync. */
1242 extract_interface_info ();
1245 input_filename = t->filename;
1246 interface_unknown = t->interface == 1;
1247 interface_only = t->interface == 0;
1249 yychar = PRE_PARSED_FUNCTION_DECL;
1251 /* Pass back a handle on the rest of the inline functions, so that they
1252 can be processed later. */
1253 yylval.ttype = build_tree_list ((tree) t, t->fndecl);
1254 DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
1257 static int nextchar = -1;
1259 /* Called from the fndecl rule in the parser when the function just parsed
1260 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1261 do_pending_inlines). */
1264 process_next_inline (t)
1268 struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
1269 context = hack_decl_function_context (i->fndecl);
1270 maybe_end_member_template_processing (i->fndecl);
1272 pop_cp_function_context (context);
1274 if (yychar == YYEMPTY)
1276 if (yychar != END_OF_SAVED_INPUT)
1278 error ("parse error at end of saved function text");
1280 /* restore_pending_input will abort unless yychar is either
1281 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1282 hosed, feed back YYEMPTY. We also need to discard nextchar,
1283 since that may have gotten set as well. */
1288 if (i && i->fndecl != NULL_TREE)
1290 context = hack_decl_function_context (i->fndecl);
1292 push_cp_function_context (context);
1293 maybe_begin_member_template_processing (i->fndecl);
1294 feed_input (i->buf, i->len);
1296 input_filename = i->filename;
1297 yychar = PRE_PARSED_FUNCTION_DECL;
1298 yylval.ttype = build_tree_list ((tree) i, i->fndecl);
1299 DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
1303 interface_unknown = i->interface == 1;
1304 interface_only = i->interface == 0;
1307 extract_interface_info ();
1310 /* Since inline methods can refer to text which has not yet been seen,
1311 we store the text of the method in a structure which is placed in the
1312 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1313 After parsing the body of the class definition, the FUNCTION_DECL's are
1314 scanned to see which ones have this field set. Those are then digested
1317 This function's FUNCTION_DECL will have a bit set in its common so
1318 that we know to watch out for it. */
1321 consume_string (this_obstack, matching_char)
1322 register struct obstack *this_obstack;
1326 int starting_lineno = lineno;
1332 int save_lineno = lineno;
1333 lineno = starting_lineno;
1334 if (matching_char == '"')
1335 error ("end of file encountered inside string constant");
1337 error ("end of file encountered inside character constant");
1338 lineno = save_lineno;
1343 obstack_1grow (this_obstack, c);
1345 obstack_1grow (this_obstack, c);
1347 /* Make sure we continue the loop */
1354 pedwarn ("ANSI C++ forbids newline in string constant");
1357 obstack_1grow (this_obstack, c);
1359 while (c != matching_char);
1362 static int nextyychar = YYEMPTY;
1363 static YYSTYPE nextyylval;
1365 struct pending_input {
1366 int nextchar, yychar, nextyychar, eof;
1367 YYSTYPE yylval, nextyylval;
1368 struct obstack token_obstack;
1372 struct pending_input *
1373 save_pending_input ()
1375 struct pending_input *p;
1376 p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1377 p->nextchar = nextchar;
1379 p->nextyychar = nextyychar;
1381 p->nextyylval = nextyylval;
1382 p->eof = end_of_file;
1383 yychar = nextyychar = YYEMPTY;
1385 p->first_token = first_token;
1386 p->token_obstack = token_obstack;
1389 gcc_obstack_init (&token_obstack);
1395 restore_pending_input (p)
1396 struct pending_input *p;
1398 my_friendly_assert (nextchar == -1, 229);
1399 nextchar = p->nextchar;
1400 my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1402 my_friendly_assert (nextyychar == YYEMPTY, 231);
1403 nextyychar = p->nextyychar;
1405 nextyylval = p->nextyylval;
1406 first_token = p->first_token;
1407 obstack_free (&token_obstack, (char *) 0);
1408 token_obstack = p->token_obstack;
1409 end_of_file = p->eof;
1413 /* Unget character CH from the input stream.
1414 If RESCAN is non-zero, then we want to `see' this
1415 character as the next input token. */
1418 yyungetc (ch, rescan)
1422 /* Unget a character from the input stream. */
1423 if (yychar == YYEMPTY || rescan == 0)
1426 put_back (nextchar);
1431 my_friendly_assert (nextyychar == YYEMPTY, 232);
1432 nextyychar = yychar;
1433 nextyylval = yylval;
1439 clear_inline_text_obstack ()
1441 obstack_free (&inline_text_obstack, inline_text_firstobj);
1444 /* This function stores away the text for an inline function that should
1445 be processed later. It decides how much later, and may need to move
1446 the info between obstacks; therefore, the caller should not refer to
1447 the T parameter after calling this function. */
1450 store_pending_inline (decl, t)
1452 struct pending_inline *t;
1455 DECL_PENDING_INLINE_INFO (decl) = t;
1457 /* Because we use obstacks, we must process these in precise order. */
1458 t->next = pending_inlines;
1459 pending_inlines = t;
1463 reinit_parse_for_method (yychar, decl)
1468 int starting_lineno = lineno;
1469 char *starting_filename = input_filename;
1471 reinit_parse_for_block (yychar, &inline_text_obstack);
1473 len = obstack_object_size (&inline_text_obstack);
1474 current_base_init_list = NULL_TREE;
1475 current_member_init_list = NULL_TREE;
1476 if (decl == void_type_node
1477 || (current_class_type && TYPE_REDEFINED (current_class_type)))
1479 /* Happens when we get two declarations of the same
1480 function in the same scope. */
1481 char *buf = obstack_finish (&inline_text_obstack);
1482 obstack_free (&inline_text_obstack, buf);
1487 struct pending_inline *t;
1488 char *buf = obstack_finish (&inline_text_obstack);
1490 t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1491 sizeof (struct pending_inline));
1492 t->lineno = starting_lineno;
1493 t->filename = starting_filename;
1500 if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
1501 warn_if_unknown_interface (decl);
1503 t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1504 store_pending_inline (decl, t);
1508 /* Consume a block -- actually, a method beginning
1509 with `:' or `{' -- and save it away on the specified obstack. */
1512 reinit_parse_for_block (pyychar, obstackp)
1514 struct obstack *obstackp;
1518 int starting_lineno = lineno;
1519 char *starting_filename = input_filename;
1521 int look_for_semicolon = 0;
1522 int look_for_lbrac = 0;
1525 obstack_1grow (obstackp, '{');
1526 else if (pyychar == '=')
1527 look_for_semicolon = 1;
1528 else if (pyychar == ':')
1530 obstack_1grow (obstackp, pyychar);
1534 else if (pyychar == RETURN)
1536 obstack_grow (obstackp, "return", 6);
1540 else if (pyychar == TRY)
1542 obstack_grow (obstackp, "try", 3);
1548 yyerror ("parse error in method specification");
1549 obstack_1grow (obstackp, '{');
1552 if (nextchar != EOF)
1562 int this_lineno = lineno;
1564 c = skip_white_space (c);
1566 /* Don't lose our cool if there are lots of comments. */
1567 if (lineno == this_lineno + 1)
1568 obstack_1grow (obstackp, '\n');
1569 else if (lineno == this_lineno)
1571 else if (lineno - this_lineno < 10)
1574 for (i = lineno - this_lineno; i > 0; i--)
1575 obstack_1grow (obstackp, '\n');
1580 sprintf (buf, "\n# %d \"", lineno);
1582 obstack_grow (obstackp, buf, len);
1584 len = strlen (input_filename);
1585 obstack_grow (obstackp, input_filename, len);
1586 obstack_1grow (obstackp, '\"');
1587 obstack_1grow (obstackp, '\n');
1590 while (c > ' ') /* ASCII dependent... */
1592 obstack_1grow (obstackp, c);
1601 if (blev == 0 && !look_for_semicolon)
1605 if (peekyylex () == CATCH)
1608 obstack_grow (obstackp, " catch ", 7);
1625 /* Don't act on the next character...e.g, doing an escaped
1630 error_with_file_and_line (starting_filename,
1632 "end of file read inside definition");
1635 obstack_1grow (obstackp, c);
1638 consume_string (obstackp, c);
1640 consume_string (obstackp, c);
1645 error ("function body for constructor missing");
1646 obstack_1grow (obstackp, '{');
1647 obstack_1grow (obstackp, '}');
1651 else if (look_for_semicolon && blev == 0)
1659 error_with_file_and_line (starting_filename,
1661 "end of file read inside definition");
1666 obstack_1grow (obstackp, c);
1671 obstack_1grow (obstackp, '\0');
1674 /* Consume a no-commas expression -- actually, a default argument -- and
1675 save it away on the specified obstack. */
1678 reinit_parse_for_expr (obstackp)
1679 struct obstack *obstackp;
1682 int starting_lineno = lineno;
1683 char *starting_filename = input_filename;
1687 if (nextchar != EOF)
1697 int this_lineno = lineno;
1699 c = skip_white_space (c);
1701 /* Don't lose our cool if there are lots of comments. */
1702 if (lineno == this_lineno + 1)
1703 obstack_1grow (obstackp, '\n');
1704 else if (lineno == this_lineno)
1706 else if (lineno - this_lineno < 10)
1709 for (i = lineno - this_lineno; i > 0; --i)
1710 obstack_1grow (obstackp, '\n');
1715 sprintf (buf, "\n# %d \"", lineno);
1717 obstack_grow (obstackp, buf, len);
1719 len = strlen (input_filename);
1720 obstack_grow (obstackp, input_filename, len);
1721 obstack_1grow (obstackp, '\"');
1722 obstack_1grow (obstackp, '\n');
1725 while (c > ' ') /* ASCII dependent... */
1727 if (plev <= 0 && (c == ')' || c == ','))
1732 obstack_1grow (obstackp, c);
1733 if (c == '(' || c == '[')
1735 else if (c == ']' || c == ')')
1739 /* Don't act on the next character...e.g, doing an escaped
1744 error_with_file_and_line (starting_filename,
1746 "end of file read inside definition");
1749 obstack_1grow (obstackp, c);
1752 consume_string (obstackp, c);
1754 consume_string (obstackp, c);
1760 error_with_file_and_line (starting_filename,
1762 "end of file read inside definition");
1767 obstack_1grow (obstackp, c);
1772 obstack_1grow (obstackp, '\0');
1775 int do_snarf_defarg;
1777 /* Decide whether the default argument we are about to see should be
1778 gobbled up as text for later parsing. */
1781 maybe_snarf_defarg ()
1783 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
1784 do_snarf_defarg = 1;
1787 /* When we see a default argument in a method declaration, we snarf it as
1788 text using snarf_defarg. When we get up to namespace scope, we then go
1789 through and parse all of them using do_pending_defargs. Since yacc
1790 parsers are not reentrant, we retain defargs state in these two
1791 variables so that subsequent calls to do_pending_defargs can resume
1792 where the previous call left off. */
1804 reinit_parse_for_expr (&inline_text_obstack);
1805 len = obstack_object_size (&inline_text_obstack);
1806 buf = obstack_finish (&inline_text_obstack);
1808 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1809 arg = make_node (DEFAULT_ARG);
1810 DEFARG_LENGTH (arg) = len - 1;
1811 DEFARG_POINTER (arg) = buf;
1817 /* Called from grokfndecl to note a function decl with unparsed default
1818 arguments for later processing. Also called from grokdeclarator
1819 for function types with unparsed defargs; the call from grokfndecl
1820 will always come second, so we can overwrite the entry from the type. */
1823 add_defarg_fn (decl)
1826 if (TREE_CODE (decl) == FUNCTION_DECL)
1827 TREE_VALUE (defarg_fns) = decl;
1830 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1831 defarg_fns = tree_cons (current_class_type, decl, defarg_fns);
1836 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1842 tree d = TREE_PURPOSE (p);
1843 feed_input (DEFARG_POINTER (d), DEFARG_LENGTH (d));
1844 if (TREE_CODE (f) == FUNCTION_DECL)
1846 lineno = DECL_SOURCE_LINE (f);
1847 input_filename = DECL_SOURCE_FILE (f);
1849 yychar = DEFARG_MARKER;
1853 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1858 if (yychar == YYEMPTY)
1860 if (yychar != END_OF_SAVED_INPUT)
1862 error ("parse error at end of saved function text");
1864 /* restore_pending_input will abort unless yychar is either
1865 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1866 hosed, feed back YYEMPTY. We also need to discard nextchar,
1867 since that may have gotten set as well. */
1874 /* Main function for deferred parsing of default arguments. Called from
1878 do_pending_defargs ()
1883 for (; defarg_fns; defarg_fns = TREE_CHAIN (defarg_fns))
1885 tree defarg_fn = TREE_VALUE (defarg_fns);
1886 if (defarg_parm == NULL_TREE)
1888 push_nested_class (TREE_PURPOSE (defarg_fns), 1);
1890 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1891 maybe_begin_member_template_processing (defarg_fn);
1893 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1897 for (p = DECL_ARGUMENTS (defarg_fn); p; p = TREE_CHAIN (p))
1898 pushdecl (copy_node (p));
1900 defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
1903 defarg_parm = TYPE_ARG_TYPES (defarg_fn);
1906 defarg_parm = TREE_CHAIN (defarg_parm);
1908 for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
1909 if (TREE_PURPOSE (defarg_parm)
1910 && TREE_CODE (TREE_PURPOSE (defarg_parm)) == DEFAULT_ARG)
1912 feed_defarg (defarg_fn, defarg_parm);
1914 /* Return to the parser, which will process this defarg
1915 and call us again. */
1919 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1920 maybe_end_member_template_processing (defarg_fn);
1922 pop_nested_class (1);
1926 /* Build a default function named NAME for type TYPE.
1927 KIND says what to build.
1929 When KIND == 0, build default destructor.
1930 When KIND == 1, build virtual destructor.
1931 When KIND == 2, build default constructor.
1932 When KIND == 3, build default X(const X&) constructor.
1933 When KIND == 4, build default X(X&) constructor.
1934 When KIND == 5, build default operator = (const X&).
1935 When KIND == 6, build default operator = (X&). */
1938 cons_up_default_function (type, full_name, kind)
1939 tree type, full_name;
1942 extern tree void_list_node;
1943 tree declspecs = NULL_TREE;
1944 tree fn, args = NULL_TREE;
1947 tree name = constructor_name (full_name);
1953 declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
1954 /* Fall through... */
1956 name = build_parse_node (BIT_NOT_EXPR, name);
1957 args = void_list_node;
1961 /* Default constructor. */
1962 args = void_list_node;
1966 type = build_type_variant (type, 1, 0);
1967 /* Fall through... */
1969 /* According to ARM $12.8, the default copy ctor will be declared, but
1970 not defined, unless it's needed. */
1971 argtype = build_reference_type (type);
1972 args = tree_cons (NULL_TREE,
1973 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1974 get_identifier ("_ctor_arg")),
1981 declspecs = build_decl_list (NULL_TREE, type);
1984 type = build_type_variant (type, 1, 0);
1986 name = ansi_opname [(int) MODIFY_EXPR];
1988 argtype = build_reference_type (type);
1989 args = tree_cons (NULL_TREE,
1990 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1991 get_identifier ("_ctor_arg")),
1996 my_friendly_abort (59);
1999 declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE],
2002 TREE_PARMLIST (args) = 1;
2005 tree declarator = make_call_declarator (name, args, NULL_TREE, NULL_TREE);
2007 declarator = build_parse_node (ADDR_EXPR, declarator);
2009 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
2012 if (fn == void_type_node)
2016 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn)));
2019 if (processing_template_defn)
2021 SET_DECL_IMPLICIT_INSTANTIATION (fn);
2022 repo_template_used (fn);
2027 if (CLASSTYPE_INTERFACE_KNOWN (type))
2029 DECL_INTERFACE_KNOWN (fn) = 1;
2030 DECL_NOT_REALLY_EXTERN (fn) = (!CLASSTYPE_INTERFACE_ONLY (type)
2031 && flag_implement_inlines);
2035 DECL_NOT_REALLY_EXTERN (fn) = 1;
2037 mark_inline_for_output (fn);
2039 #ifdef DEBUG_DEFAULT_FUNCTIONS
2040 { char *fn_type = NULL;
2044 case 0: fn_type = "default destructor"; break;
2045 case 1: fn_type = "virtual destructor"; break;
2046 case 2: fn_type = "default constructor"; break;
2047 case 3: fn_type = "default X(const X&)"; break;
2048 case 4: fn_type = "default X(X&)"; break;
2052 if (TREE_CODE (name) == BIT_NOT_EXPR)
2053 t = TREE_OPERAND (name, 0);
2054 fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
2055 IDENTIFIER_POINTER (t), func_buf);
2058 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2060 /* Show that this function was generated by the compiler. */
2061 SET_DECL_ARTIFICIAL (fn);
2066 /* Heuristic to tell whether the user is missing a semicolon
2067 after a struct or enum declaration. Emit an error message
2068 if we know the user has blown it. */
2071 check_for_missing_semicolon (type)
2079 && yychar != IDENTIFIER
2080 && yychar != TYPENAME
2081 && yychar != CV_QUALIFIER
2082 && yychar != SELFNAME)
2085 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2086 error ("semicolon missing after %s declaration",
2087 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2089 cp_error ("semicolon missing after declaration of `%T'", type);
2090 shadow_tag (build_tree_list (0, type));
2092 /* Could probably also hack cases where class { ... } f (); appears. */
2097 note_got_semicolon (type)
2100 if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
2101 my_friendly_abort (60);
2102 if (IS_AGGR_TYPE (type))
2103 CLASSTYPE_GOT_SEMICOLON (type) = 1;
2107 note_list_got_semicolon (declspecs)
2112 for (link = declspecs; link; link = TREE_CHAIN (link))
2114 tree type = TREE_VALUE (link);
2115 if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
2116 note_got_semicolon (type);
2121 /* If C is not whitespace, return C.
2122 Otherwise skip whitespace and return first nonwhite char read. */
2125 skip_white_space (c)
2133 c = check_newline ();
2144 while (c == ' ' || c == '\t');
2152 error ("stray '\\' in program");
2164 /* Make the token buffer longer, preserving the data in it.
2165 P should point to just beyond the last valid character in the old buffer.
2166 The value we return is a pointer to the new buffer
2167 at a place corresponding to P. */
2170 extend_token_buffer (p)
2173 int offset = p - token_buffer;
2175 maxtoken = maxtoken * 2 + 10;
2176 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2178 return token_buffer + offset;
2182 get_last_nonwhite_on_line ()
2186 /* Is this the last nonwhite stuff on the line? */
2188 c = nextchar, nextchar = -1;
2192 while (c == ' ' || c == '\t')
2197 /* At the beginning of a line, increment the line number
2198 and process any #-directive on this line.
2199 If the line is a #-directive, read the entire line and return a newline.
2200 Otherwise, return the line's first non-whitespace character. */
2204 static int handle_cp_pragma PROTO((char *));
2212 /* Read first nonwhite char on the line. Do this before incrementing the
2213 line number, in case we're at the end of saved text. */
2217 while (c == ' ' || c == '\t');
2223 /* If not #, return it so caller will use it. */
2227 /* Don't read beyond this line. */
2230 /* Read first nonwhite char after the `#'. */
2234 while (c == ' ' || c == '\t');
2236 /* If a letter follows, then if the word here is `line', skip
2237 it and ignore it; otherwise, ignore the line, with an error
2238 if the word isn't `pragma'. */
2240 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
2250 token = real_yylex ();
2251 if (token == IDENTIFIER
2252 && TREE_CODE (yylval.ttype) == IDENTIFIER_NODE)
2254 /* If this is 1, we handled it; if it's -1, it was one we
2255 wanted but had something wrong with it. Only if it's
2256 0 was it not handled. */
2257 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval.ttype)))
2260 else if (token == END_OF_LINE)
2263 #ifdef HANDLE_SYSV_PRAGMA
2264 if (handle_sysv_pragma (token))
2267 #ifdef HANDLE_PRAGMA
2272 if (HANDLE_PRAGMA (finput, yylval.ttype))
2274 #endif /* !USE_CPPLIB */
2287 && ((c = getch ()) == ' ' || c == '\t'))
2289 debug_define (lineno, GET_DIRECTIVE_LINE ());
2299 && ((c = getch ()) == ' ' || c == '\t'))
2301 debug_undef (lineno, GET_DIRECTIVE_LINE ());
2310 && ((c = getch ()) == ' ' || c == '\t'))
2319 && ((c = getch ()) == ' ' || c == '\t'))
2321 #ifdef ASM_OUTPUT_IDENT
2322 extern FILE *asm_out_file;
2324 /* #ident. The pedantic warning is now in cccp.c. */
2326 /* Here we have just seen `#ident '.
2327 A string constant should follow. */
2329 token = real_yylex ();
2330 if (token == END_OF_LINE)
2333 || TREE_CODE (yylval.ttype) != STRING_CST)
2335 error ("invalid #ident");
2339 if (! flag_no_ident)
2341 #ifdef ASM_OUTPUT_IDENT
2342 ASM_OUTPUT_IDENT (asm_out_file,
2343 TREE_STRING_POINTER (yylval.ttype));
2347 /* Skip the rest of this line. */
2360 && ((c = getch ()) == ' ' || c == '\t'))
2362 /* Used to test incremental compilation. */
2363 sorry ("#pragma newworld");
2367 error ("undefined or invalid # directive");
2372 /* Here we have either `#line' or `# <nonletter>'.
2373 In either case, it should be a line number; a digit should follow. */
2375 while (c == ' ' || c == '\t')
2378 /* If the # is the only nonwhite char on the line,
2379 just ignore it. Check the new newline. */
2383 /* Something follows the #; read a token. */
2386 token = real_yylex ();
2388 if (token == CONSTANT
2389 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2391 int old_lineno = lineno;
2392 enum { act_none, act_push, act_pop } action = act_none;
2393 int entering_system_header = 0;
2394 int entering_c_header = 0;
2396 /* subtract one, because it is the following line that
2397 gets the specified number */
2399 int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2400 c = get_last_nonwhite_on_line ();
2403 /* No more: store the line number and check following line. */
2409 /* More follows: it must be a string constant (filename). */
2411 /* Read the string constant, but don't treat \ as special. */
2412 ignore_escape_flag = 1;
2413 token = real_yylex ();
2414 ignore_escape_flag = 0;
2416 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2418 error ("invalid #line");
2422 /* Changing files again. This means currently collected time
2423 is charged against header time, and body time starts back
2425 if (flag_detailed_statistics)
2427 int this_time = my_get_run_time ();
2428 tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2429 header_time += this_time - body_time;
2430 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
2431 += this_time - body_time;
2432 this_filename_time = time_identifier;
2433 body_time = this_time;
2437 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
2438 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
2440 GNU_xref_file (input_filename);
2442 if (main_input_filename == 0)
2444 struct impl_files *ifiles = impl_file_chain;
2448 while (ifiles->next)
2449 ifiles = ifiles->next;
2450 ifiles->filename = file_name_nondirectory (input_filename);
2453 main_input_filename = input_filename;
2454 if (write_virtuals == 3)
2455 walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
2458 extract_interface_info ();
2460 c = get_last_nonwhite_on_line ();
2463 /* Update the name in the top element of input_file_stack. */
2464 if (input_file_stack)
2465 input_file_stack->name = input_filename;
2471 token = real_yylex ();
2473 /* `1' after file name means entering new file.
2474 `2' after file name means just left a file. */
2476 if (token == CONSTANT
2477 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2479 if (TREE_INT_CST_LOW (yylval.ttype) == 1)
2481 else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
2486 c = get_last_nonwhite_on_line ();
2490 token = real_yylex ();
2495 /* `3' after file name means this is a system header file. */
2497 if (token == CONSTANT
2498 && TREE_CODE (yylval.ttype) == INTEGER_CST
2499 && TREE_INT_CST_LOW (yylval.ttype) == 3)
2501 entering_system_header = 1;
2503 c = get_last_nonwhite_on_line ();
2507 token = real_yylex ();
2511 /* `4' after file name means this is a C header file. */
2513 if (token == CONSTANT
2514 && TREE_CODE (yylval.ttype) == INTEGER_CST
2515 && TREE_INT_CST_LOW (yylval.ttype) == 4)
2517 entering_c_header = 1;
2519 c = get_last_nonwhite_on_line ();
2523 token = real_yylex ();
2527 /* Do the actions implied by the preceding numbers. */
2529 if (action == act_push)
2531 /* Pushing to a new file. */
2532 struct file_stack *p;
2534 p = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2535 input_file_stack->line = old_lineno;
2536 p->next = input_file_stack;
2537 p->name = input_filename;
2538 input_file_stack = p;
2539 input_file_stack_tick++;
2540 debug_start_source_file (input_filename);
2541 in_system_header = entering_system_header;
2544 else if (entering_c_header)
2547 ++pending_lang_change;
2550 else if (action == act_pop)
2552 /* Popping out of a file. */
2553 if (input_file_stack->next)
2555 struct file_stack *p;
2557 if (c_header_level && --c_header_level == 0)
2559 if (entering_c_header)
2560 warning ("badly nested C headers from preprocessor");
2561 --pending_lang_change;
2563 in_system_header = entering_system_header;
2565 p = input_file_stack;
2566 input_file_stack = p->next;
2568 input_file_stack_tick++;
2569 debug_end_source_file (input_file_stack->line);
2572 error ("#-lines for entering and leaving files don't match");
2575 in_system_header = entering_system_header;
2578 /* If NEXTCHAR is not end of line, we don't care what it is. */
2579 if (nextchar == EOF)
2583 error ("invalid #-line");
2585 /* skip the rest of this line. */
2590 while ((c = getch ()) != EOF && c != '\n');
2595 do_pending_lang_change ()
2597 for (; pending_lang_change > 0; --pending_lang_change)
2598 push_lang_context (lang_name_c);
2599 for (; pending_lang_change < 0; ++pending_lang_change)
2600 pop_lang_context ();
2603 #define ENDFILE -1 /* token that represents end-of-file */
2605 /* Read an escape sequence, returning its equivalent as a character,
2606 or store 1 in *ignore_ptr if it is backslash-newline. */
2609 readescape (ignore_ptr)
2612 register int c = getch ();
2614 register unsigned count;
2615 unsigned firstdig = 0;
2633 if (c >= 'a' && c <= 'f')
2634 code += c - 'a' + 10;
2635 if (c >= 'A' && c <= 'F')
2636 code += c - 'A' + 10;
2637 if (c >= '0' && c <= '9')
2639 if (code != 0 || count != 0)
2648 error ("\\x used with no following hex digits");
2649 else if (count == 0)
2650 /* Digits are all 0's. Ok. */
2652 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
2654 && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
2656 pedwarn ("hex escape out of range");
2659 case '0': case '1': case '2': case '3': case '4':
2660 case '5': case '6': case '7':
2663 while ((c <= '7') && (c >= '0') && (count++ < 3))
2665 code = (code * 8) + (c - '0');
2671 case '\\': case '\'': case '"':
2680 return TARGET_NEWLINE;
2703 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
2709 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2713 /* `\%' is used to prevent SCCS from getting confused. */
2716 pedwarn ("unknown escape sequence `\\%c'", c);
2719 if (c >= 040 && c < 0177)
2720 pedwarn ("unknown escape sequence `\\%c'", c);
2722 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
2726 /* Value is 1 (or 2) if we should try to make the next identifier look like
2727 a typename (when it may be a local variable or a class variable).
2728 Value is 0 if we treat this name in a default fashion. */
2729 int looking_for_typename = 0;
2735 identifier_type (decl)
2738 if (TREE_CODE (decl) == TEMPLATE_DECL)
2740 if (TREE_CODE (DECL_RESULT (decl)) == TYPE_DECL)
2742 else if (looking_for_template)
2745 if (looking_for_template && really_overloaded_fn (decl))
2748 for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
2749 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
2752 if (TREE_CODE (decl) == NAMESPACE_DECL)
2754 if (TREE_CODE (decl) != TYPE_DECL)
2756 if (((got_scope && TREE_TYPE (decl) == got_scope)
2757 || TREE_TYPE (decl) == current_class_type)
2758 && DECL_ARTIFICIAL (decl))
2766 /* Only types expected, not even namespaces. */
2767 looking_for_typename = 2;
2769 if ((yychar = yylex ()) < 0) yychar = 0;
2770 looking_for_typename = 0;
2771 if (yychar == IDENTIFIER)
2773 lastiddecl = lookup_name (yylval.ttype, -2);
2774 if (lastiddecl == 0)
2777 lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
2780 yychar = identifier_type (lastiddecl);
2785 do_identifier (token, parsing)
2786 register tree token;
2791 if (! parsing || IDENTIFIER_OPNAME_P (token))
2792 id = lookup_name (token, 0);
2796 if (parsing && yychar == YYEMPTY)
2798 /* Scope class declarations before global
2800 if (id == IDENTIFIER_NAMESPACE_VALUE (token)
2801 && current_class_type != 0
2802 && TYPE_SIZE (current_class_type) == 0)
2804 /* Could be from one of the base classes. */
2805 tree field = lookup_field (current_class_type, token, 1, 0);
2808 else if (field == error_mark_node)
2809 /* We have already generated the error message.
2810 But we still want to return this value. */
2811 id = lookup_field (current_class_type, token, 0, 0);
2812 else if (TREE_CODE (field) == VAR_DECL
2813 || TREE_CODE (field) == CONST_DECL
2814 || TREE_CODE (field) == TEMPLATE_DECL)
2816 else if (TREE_CODE (field) != FIELD_DECL)
2817 my_friendly_abort (61);
2820 cp_error ("invalid use of member `%D' from base class `%T'", field,
2821 DECL_FIELD_CONTEXT (field));
2822 id = error_mark_node;
2827 /* Remember that this name has been used in the class definition, as per
2829 if (id && current_class_type && parsing
2830 && TYPE_BEING_DEFINED (current_class_type)
2831 && ! IDENTIFIER_CLASS_VALUE (token)
2832 /* Avoid breaking if we get called for a default argument that
2833 refers to an overloaded method. Eventually this will not be
2834 necessary, since default arguments shouldn't be parsed until
2835 after the class is complete. (jason 3/12/97) */
2836 && TREE_CODE (id) != OVERLOAD)
2837 pushdecl_class_level (id);
2839 if (!id || id == error_mark_node)
2841 if (id == error_mark_node && current_class_type != NULL_TREE)
2843 id = lookup_nested_field (token, 1);
2844 /* In lookup_nested_field(), we marked this so we can gracefully
2845 leave this whole mess. */
2846 if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
2850 if (current_template_parms)
2851 return build_min_nt (LOOKUP_EXPR, token, NULL_TREE);
2852 else if (IDENTIFIER_OPNAME_P (token))
2854 if (token != ansi_opname[ERROR_MARK])
2855 cp_error ("`%D' not defined", token);
2856 id = error_mark_node;
2858 else if (parsing && (yychar == '(' || yychar == LEFT_RIGHT))
2860 id = implicitly_declare (token);
2862 else if (current_function_decl == 0)
2864 cp_error ("`%D' was not declared in this scope", token);
2865 id = error_mark_node;
2869 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
2870 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
2872 static int undeclared_variable_notice;
2874 cp_error ("`%D' undeclared (first use this function)", token);
2876 if (! undeclared_variable_notice)
2878 error ("(Each undeclared identifier is reported only once");
2879 error ("for each function it appears in.)");
2880 undeclared_variable_notice = 1;
2883 id = error_mark_node;
2884 /* Prevent repeated error messages. */
2885 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
2886 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
2890 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
2892 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
2893 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
2894 && DECL_DEAD_FOR_LOCAL (shadowed))
2895 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
2897 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
2900 if (!DECL_ERROR_REPORTED (id))
2902 warning ("name lookup of `%s' changed",
2903 IDENTIFIER_POINTER (token));
2904 cp_warning_at (" matches this `%D' under current ANSI rules",
2906 cp_warning_at (" matches this `%D' under old rules", id);
2907 DECL_ERROR_REPORTED (id) = 1;
2911 else if (!DECL_ERROR_REPORTED (id))
2914 = "name lookup of `%s' changed for new ANSI `for' scoping";
2915 DECL_ERROR_REPORTED (id) = 1;
2916 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id)))
2918 error (msg, IDENTIFIER_POINTER (token));
2919 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
2920 id = error_mark_node;
2924 pedwarn (msg, IDENTIFIER_POINTER (token));
2925 cp_pedwarn_at (" using obsolete binding at `%D'", id);
2929 /* TREE_USED is set in `hack_identifier'. */
2930 if (TREE_CODE (id) == CONST_DECL)
2932 if (IDENTIFIER_CLASS_VALUE (token) == id)
2935 tree access = compute_access (TYPE_BINFO (current_class_type), id);
2936 if (access == access_private_node)
2937 cp_error ("enum `%D' is private", id);
2938 /* protected is OK, since it's an enum of `this'. */
2940 if (! processing_template_decl
2941 || (DECL_INITIAL (id)
2942 && TREE_CODE (DECL_INITIAL (id)) == TEMPLATE_PARM_INDEX))
2943 id = DECL_INITIAL (id);
2946 id = hack_identifier (id, token);
2948 if (current_template_parms)
2950 if (is_overloaded_fn (id))
2952 tree t = build_min (LOOKUP_EXPR, unknown_type_node,
2953 token, get_first_fn (id));
2954 if (id != IDENTIFIER_NAMESPACE_VALUE (token))
2955 TREE_OPERAND (t, 1) = error_mark_node;
2958 else if (! TREE_PERMANENT (id) || TREE_CODE (id) == PARM_DECL
2959 || TREE_CODE (id) == USING_DECL)
2960 id = build_min (LOOKUP_EXPR, TREE_TYPE (id), token, error_mark_node);
2961 /* else just use the decl */
2968 do_scoped_id (token, parsing)
2973 /* during parsing, this is ::name. Otherwise, it is black magic. */
2976 struct tree_binding _b;
2977 id = binding_init (&_b);
2978 if (!qualified_lookup_using_namespace (token, global_namespace, id))
2981 id = BINDING_VALUE (id);
2984 id = IDENTIFIER_GLOBAL_VALUE (token);
2985 if (parsing && yychar == YYEMPTY)
2989 if (processing_template_decl)
2991 id = build_min_nt (LOOKUP_EXPR, token, NULL_TREE);
2992 LOOKUP_EXPR_GLOBAL (id) = 1;
2995 if (parsing && (yychar == '(' || yychar == LEFT_RIGHT))
2996 id = implicitly_declare (token);
2999 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
3000 error ("undeclared variable `%s' (first use here)",
3001 IDENTIFIER_POINTER (token));
3002 id = error_mark_node;
3003 /* Prevent repeated error messages. */
3004 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3009 if (TREE_CODE (id) == ADDR_EXPR)
3010 mark_used (TREE_OPERAND (id, 0));
3011 else if (TREE_CODE (id) != OVERLOAD)
3014 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
3016 /* XXX CHS - should we set TREE_USED of the constant? */
3017 id = DECL_INITIAL (id);
3018 /* This is to prevent an enum whose value is 0
3019 from being considered a null pointer constant. */
3020 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
3021 TREE_CONSTANT (id) = 1;
3024 if (processing_template_decl)
3026 if (is_overloaded_fn (id))
3028 id = build_min (LOOKUP_EXPR, unknown_type_node,
3029 token, get_first_fn (id));
3030 LOOKUP_EXPR_GLOBAL (id) = 1;
3032 /* else just use the decl */
3034 return convert_from_reference (id);
3038 identifier_typedecl_value (node)
3042 type = IDENTIFIER_TYPE_VALUE (node);
3043 if (type == NULL_TREE)
3048 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3051 do (IDENTIFIER_LOCAL_VALUE (node));
3052 do (IDENTIFIER_CLASS_VALUE (node));
3053 do (IDENTIFIER_NAMESPACE_VALUE (node));
3055 /* Will this one ever happen? */
3056 if (TYPE_MAIN_DECL (type))
3057 return TYPE_MAIN_DECL (type);
3059 /* We used to do an internal error of 62 here, but instead we will
3060 handle the return of a null appropriately in the callers. */
3070 int dollar_seen = 0;
3074 c = nextchar, nextchar = -1;
3078 /* Effectively do c = skip_white_space (c)
3079 but do it faster in the usual cases. */
3092 /* Call skip_white_space so we can warn if appropriate. */
3097 c = skip_white_space (c);
3099 goto found_nonwhite;
3103 token_buffer[0] = c;
3104 token_buffer[1] = 0;
3106 /* yylloc.first_line = lineno; */
3111 token_buffer[0] = '\0';
3113 if (input_redirected ())
3114 value = END_OF_SAVED_INPUT;
3116 value = END_OF_LINE;
3122 if (! dollars_in_ident)
3123 error ("`$' in identifier");
3125 pedwarn ("`$' in identifier");
3130 /* Capital L may start a wide-string or wide-character constant. */
3132 register int c = getch ();
3141 goto string_constant;
3146 case 'A': case 'B': case 'C': case 'D': case 'E':
3147 case 'F': case 'G': case 'H': case 'I': case 'J':
3148 case 'K': case 'M': case 'N': case 'O':
3149 case 'P': case 'Q': case 'R': case 'S': case 'T':
3150 case 'U': case 'V': case 'W': case 'X': case 'Y':
3152 case 'a': case 'b': case 'c': case 'd': case 'e':
3153 case 'f': case 'g': case 'h': case 'i': case 'j':
3154 case 'k': case 'l': case 'm': case 'n': case 'o':
3155 case 'p': case 'q': case 'r': case 's': case 't':
3156 case 'u': case 'v': case 'w': case 'x': case 'y':
3166 /* We know that `token_buffer' can hold at least on char,
3167 so we install C immediately.
3168 We may have to read the value in `putback_char', so call
3173 /* Make this run fast. We know that we are reading straight
3174 from FINPUT in this case (since identifiers cannot straddle
3176 while (ISALNUM (c) || (c == '_') || c == '$')
3180 if (! dollars_in_ident)
3181 error ("`$' in identifier");
3183 pedwarn ("`$' in identifier");
3186 if (p >= token_buffer + maxtoken)
3187 p = extend_token_buffer (p);
3193 if (linemode && c == '\n')
3201 /* We know that `token_buffer' can hold at least on char,
3202 so we install C immediately. */
3206 while (ISALNUM (c) || (c == '_') || c == '$')
3210 if (! dollars_in_ident)
3211 error ("`$' in identifier");
3213 pedwarn ("`$' in identifier");
3216 if (p >= token_buffer + maxtoken)
3217 p = extend_token_buffer (p);
3230 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3233 register struct resword *ptr;
3235 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
3239 tree old_ttype = ridpointers[(int) ptr->rid];
3241 /* If this provides a type for us, then revert lexical
3242 state to standard state. */
3243 if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
3244 && IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
3245 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
3246 looking_for_typename = 0;
3247 else if (ptr->token == AGGR || ptr->token == ENUM)
3248 looking_for_typename = 2;
3250 /* Check if this is a language-type declaration.
3251 Just glimpse the next non-white character. */
3252 nextchar = skip_white_space (nextchar);
3253 if (nextchar == '"')
3255 /* We are looking at a string. Complain
3256 if the token before the string is no `extern'.
3258 Could cheat some memory by placing this string
3259 on the temporary_, instead of the saveable_
3262 if (ptr->rid != RID_EXTERN)
3263 error ("invalid modifier `%s' for language string",
3266 value = EXTERN_LANG_STRING;
3267 yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
3270 if (ptr->token == VISSPEC)
3275 yylval.ttype = access_public_node;
3278 yylval.ttype = access_private_node;
3281 yylval.ttype = access_protected_node;
3284 my_friendly_abort (63);
3288 yylval.ttype = old_ttype;
3290 else if (ptr->token == EQCOMPARE)
3292 yylval.code = NE_EXPR;
3293 token_buffer[0] = '!';
3294 token_buffer[1] = '=';
3295 token_buffer[2] = 0;
3297 else if (ptr->token == ASSIGN)
3299 if (strcmp ("and_eq", token_buffer) == 0)
3301 yylval.code = BIT_AND_EXPR;
3302 token_buffer[0] = '&';
3304 else if (strcmp ("or_eq", token_buffer) == 0)
3306 yylval.code = BIT_IOR_EXPR;
3307 token_buffer[0] = '|';
3309 else if (strcmp ("xor_eq", token_buffer) == 0)
3311 yylval.code = BIT_XOR_EXPR;
3312 token_buffer[0] = '^';
3314 token_buffer[1] = '=';
3315 token_buffer[2] = 0;
3317 else if (ptr->token == '&')
3319 yylval.code = BIT_AND_EXPR;
3320 token_buffer[0] = '&';
3321 token_buffer[1] = 0;
3323 else if (ptr->token == '|')
3325 yylval.code = BIT_IOR_EXPR;
3326 token_buffer[0] = '|';
3327 token_buffer[1] = 0;
3329 else if (ptr->token == '^')
3331 yylval.code = BIT_XOR_EXPR;
3332 token_buffer[0] = '^';
3333 token_buffer[1] = 0;
3336 value = (int) ptr->token;
3340 /* If we did not find a keyword, look for an identifier
3343 if (value == IDENTIFIER || value == TYPESPEC)
3344 GNU_xref_ref (current_function_decl, token_buffer);
3346 if (value == IDENTIFIER)
3348 register tree tmp = get_identifier (token_buffer);
3350 #if !defined(VMS) && defined(JOINER)
3351 /* Make sure that user does not collide with our internal
3355 && (THIS_NAME_P (tmp)
3356 || VPTR_NAME_P (tmp)
3357 || DESTRUCTOR_NAME_P (tmp)
3358 || VTABLE_NAME_P (tmp)
3359 || TEMP_NAME_P (tmp)
3360 || ANON_AGGRNAME_P (tmp)
3361 || ANON_PARMNAME_P (tmp)))
3362 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3368 if (value == NEW && ! global_bindings_p ())
3378 register int c1 = getch ();
3379 token_buffer[0] = c;
3380 token_buffer[1] = c1;
3384 token_buffer[2] = 0;
3392 token_buffer[2] = c1;
3393 token_buffer[3] = 0;
3397 error ("parse error at `..'");
3402 goto resume_numerical_scan;
3406 token_buffer[1] = 0;
3410 /* Optimize for most frequent case. */
3412 register int c1 = getch ();
3413 if (! ISALNUM (c1) && c1 != '.')
3415 /* Terminate string. */
3416 token_buffer[0] = c;
3417 token_buffer[1] = 0;
3419 yylval.ttype = integer_zero_node;
3421 yylval.ttype = integer_one_node;
3428 /* fall through... */
3429 case '2': case '3': case '4':
3430 case '5': case '6': case '7': case '8': case '9':
3431 resume_numerical_scan:
3436 int largest_digit = 0;
3438 /* for multi-precision arithmetic,
3439 we actually store only HOST_BITS_PER_CHAR bits in each part.
3440 The number of parts is chosen so as to be sufficient to hold
3441 the enough bits to fit into the two HOST_WIDE_INTs that contain
3442 the integer value (this is always at least as many bits as are
3443 in a target `long long' value, but may be wider). */
3444 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3445 int parts[TOTAL_PARTS];
3448 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
3451 for (count = 0; count < TOTAL_PARTS; count++)
3459 *p++ = (c = getch ());
3460 if ((c == 'x') || (c == 'X'))
3463 *p++ = (c = getch ());
3465 /* Leading 0 forces octal unless the 0 is the only digit. */
3466 else if (c >= '0' && c <= '9')
3475 /* Read all the digits-and-decimal-points. */
3478 || (ISALNUM (c) && (c != 'l') && (c != 'L')
3479 && (c != 'u') && (c != 'U')
3480 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
3481 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
3486 error ("floating constant may not be in radix 16");
3487 if (floatflag == TOO_MANY_POINTS)
3488 /* We have already emitted an error. Don't need another. */
3490 else if (floatflag == AFTER_POINT)
3492 error ("malformed floating constant");
3493 floatflag = TOO_MANY_POINTS;
3494 /* Avoid another error from atof by forcing all characters
3495 from here on to be ignored. */
3499 floatflag = AFTER_POINT;
3502 *p++ = c = getch ();
3503 /* Accept '.' as the start of a floating-point number
3504 only when it is followed by a digit.
3505 Otherwise, unread the following non-digit
3506 and use the '.' as a structural token. */
3507 if (p == token_buffer + 2 && !ISDIGIT (c))
3519 error ("parse error at `..'");
3522 token_buffer[1] = '\0';
3529 /* It is not a decimal point.
3530 It should be a digit (perhaps a hex digit). */
3536 else if (base <= 10)
3538 if (c == 'e' || c == 'E')
3541 floatflag = AFTER_POINT;
3542 break; /* start of exponent */
3544 error ("nondigits in number and not hexadecimal");
3555 if (c >= largest_digit)
3559 for (count = 0; count < TOTAL_PARTS; count++)
3561 parts[count] *= base;
3565 += (parts[count-1] >> HOST_BITS_PER_CHAR);
3567 &= (1 << HOST_BITS_PER_CHAR) - 1;
3573 /* If the extra highest-order part ever gets anything in it,
3574 the number is certainly too big. */
3575 if (parts[TOTAL_PARTS - 1] != 0)
3578 if (p >= token_buffer + maxtoken - 3)
3579 p = extend_token_buffer (p);
3580 *p++ = (c = getch ());
3585 error ("numeric constant with no digits");
3587 if (largest_digit >= base)
3588 error ("numeric constant contains digits beyond the radix");
3590 /* Remove terminating char from the token buffer and delimit the string */
3593 if (floatflag != NOT_FLOAT)
3595 tree type = double_type_node;
3596 int exceeds_double = 0;
3598 REAL_VALUE_TYPE value;
3601 /* Read explicit exponent if any, and put it in tokenbuf. */
3603 if ((c == 'e') || (c == 'E'))
3605 if (p >= token_buffer + maxtoken - 3)
3606 p = extend_token_buffer (p);
3609 if ((c == '+') || (c == '-'))
3615 error ("floating constant exponent has no digits");
3618 if (p >= token_buffer + maxtoken - 3)
3619 p = extend_token_buffer (p);
3628 /* Convert string to a double, checking for overflow. */
3629 if (setjmp (handler))
3631 error ("floating constant out of range");
3636 int fflag = 0, lflag = 0;
3637 /* Copy token_buffer now, while it has just the number
3638 and not the suffixes; once we add `f' or `i',
3639 REAL_VALUE_ATOF may not work any more. */
3640 char *copy = (char *) alloca (p - token_buffer + 1);
3641 bcopy (token_buffer, copy, p - token_buffer + 1);
3643 set_float_handler (handler);
3649 /* Read the suffixes to choose a data type. */
3654 error ("more than one `f' in numeric constant");
3660 error ("more than one `l' in numeric constant");
3666 error ("more than one `i' or `j' in numeric constant");
3668 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3679 if (p >= token_buffer + maxtoken - 3)
3680 p = extend_token_buffer (p);
3686 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3687 tells the desired precision of the binary result
3688 of decimal-to-binary conversion. */
3693 error ("both `f' and `l' in floating constant");
3695 type = float_type_node;
3696 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3697 /* A diagnostic is required here by some ANSI C testsuites.
3698 This is not pedwarn, become some people don't want
3699 an error for this. */
3700 if (REAL_VALUE_ISINF (value) && pedantic)
3701 warning ("floating point number exceeds range of `float'");
3705 type = long_double_type_node;
3706 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3707 if (REAL_VALUE_ISINF (value) && pedantic)
3708 warning ("floating point number exceeds range of `long double'");
3712 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3713 if (REAL_VALUE_ISINF (value) && pedantic)
3714 warning ("floating point number exceeds range of `double'");
3717 set_float_handler (NULL_PTR);
3720 if (errno == ERANGE && pedantic)
3722 /* ERANGE is also reported for underflow,
3723 so test the value to distinguish overflow from that. */
3724 if (REAL_VALUES_LESS (dconst1, value)
3725 || REAL_VALUES_LESS (value, dconstm1))
3727 pedwarn ("floating point number exceeds range of `%s'",
3728 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type)));
3734 /* If the result is not a number, assume it must have been
3735 due to some error message above, so silently convert
3737 if (REAL_VALUE_ISNAN (value))
3740 /* Create a node with determined type and value. */
3742 yylval.ttype = build_complex (NULL_TREE,
3743 cp_convert (type, integer_zero_node),
3744 build_real (type, value));
3746 yylval.ttype = build_real (type, value);
3751 HOST_WIDE_INT high, low;
3752 int spec_unsigned = 0;
3754 int spec_long_long = 0;
3760 if (c == 'u' || c == 'U')
3763 error ("two `u's in integer constant");
3766 else if (c == 'l' || c == 'L')
3771 error ("three `l's in integer constant");
3773 pedwarn ("ANSI C++ forbids long long integer constants");
3778 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
3781 error ("more than one `i' or `j' in numeric constant");
3783 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3788 if (p >= token_buffer + maxtoken - 3)
3789 p = extend_token_buffer (p);
3794 /* If the constant is not long long and it won't fit in an
3795 unsigned long, or if the constant is long long and won't fit
3796 in an unsigned long long, then warn that the constant is out
3799 /* ??? This assumes that long long and long integer types are
3800 a multiple of 8 bits. This better than the original code
3801 though which assumed that long was exactly 32 bits and long
3802 long was exactly 64 bits. */
3805 bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
3807 bytes = TYPE_PRECISION (long_integer_type_node) / 8;
3810 for (i = bytes; i < TOTAL_PARTS; i++)
3814 pedwarn ("integer constant out of range");
3816 /* This is simplified by the fact that our constant
3817 is always positive. */
3820 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
3822 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
3823 / HOST_BITS_PER_CHAR)]
3824 << (i * HOST_BITS_PER_CHAR));
3825 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
3829 yylval.ttype = build_int_2 (low, high);
3830 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
3832 /* Calculate the ANSI type. */
3833 if (!spec_long && !spec_unsigned
3834 && int_fits_type_p (yylval.ttype, integer_type_node))
3835 type = integer_type_node;
3836 else if (!spec_long && (base != 10 || spec_unsigned)
3837 && int_fits_type_p (yylval.ttype, unsigned_type_node))
3838 /* Nondecimal constants try unsigned even in traditional C. */
3839 type = unsigned_type_node;
3840 else if (!spec_unsigned && !spec_long_long
3841 && int_fits_type_p (yylval.ttype, long_integer_type_node))
3842 type = long_integer_type_node;
3843 else if (! spec_long_long)
3844 type = long_unsigned_type_node;
3845 else if (! spec_unsigned
3846 /* Verify value does not overflow into sign bit. */
3847 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
3848 && int_fits_type_p (yylval.ttype,
3849 long_long_integer_type_node))
3850 type = long_long_integer_type_node;
3852 type = long_long_unsigned_type_node;
3854 if (!int_fits_type_p (yylval.ttype, type) && !warn)
3855 pedwarn ("integer constant out of range");
3857 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
3858 warning ("decimal integer constant is so large that it is unsigned");
3862 if (TYPE_PRECISION (type)
3863 <= TYPE_PRECISION (integer_type_node))
3865 = build_complex (NULL_TREE, integer_zero_node,
3866 cp_convert (integer_type_node,
3869 error ("complex integer constant is too wide for `__complex int'");
3872 TREE_TYPE (yylval.ttype) = type;
3878 value = CONSTANT; break;
3884 register int result = 0;
3885 register int num_chars = 0;
3886 unsigned width = TYPE_PRECISION (char_type_node);
3891 width = WCHAR_TYPE_SIZE;
3892 #ifdef MULTIBYTE_CHARS
3893 max_chars = MB_CUR_MAX;
3899 max_chars = TYPE_PRECISION (integer_type_node) / width;
3907 if (c == '\'' || c == EOF)
3913 c = readescape (&ignore);
3916 if (width < HOST_BITS_PER_INT
3917 && (unsigned) c >= (1 << width))
3918 warning ("escape sequence out of range for character");
3919 #ifdef MAP_CHARACTER
3921 c = MAP_CHARACTER (c);
3927 pedwarn ("ANSI C++ forbids newline in character constant");
3930 #ifdef MAP_CHARACTER
3932 c = MAP_CHARACTER (c);
3936 if (num_chars > maxtoken - 4)
3937 extend_token_buffer (token_buffer);
3939 token_buffer[num_chars] = c;
3941 /* Merge character into result; ignore excess chars. */
3942 if (num_chars < max_chars + 1)
3944 if (width < HOST_BITS_PER_INT)
3945 result = (result << width) | (c & ((1 << width) - 1));
3951 token_buffer[num_chars + 1] = '\'';
3952 token_buffer[num_chars + 2] = 0;
3955 error ("malformatted character constant");
3956 else if (num_chars == 0)
3957 error ("empty character constant");
3958 else if (num_chars > max_chars)
3960 num_chars = max_chars;
3961 error ("character constant too long");
3963 else if (num_chars != 1)
3964 warning ("multi-character character constant");
3966 /* If char type is signed, sign-extend the constant. */
3969 int num_bits = num_chars * width;
3971 /* We already got an error; avoid invalid shift. */
3972 yylval.ttype = build_int_2 (0, 0);
3973 else if (TREE_UNSIGNED (char_type_node)
3974 || ((result >> (num_bits - 1)) & 1) == 0)
3976 = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0
3977 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
3981 = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0
3982 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
3985 TREE_TYPE (yylval.ttype) = char_type_node;
3987 TREE_TYPE (yylval.ttype) = integer_type_node;
3991 #ifdef MULTIBYTE_CHARS
3992 /* Set the initial shift state and convert the next sequence. */
3994 /* In all locales L'\0' is zero and mbtowc will return zero,
3997 || (num_chars == 1 && token_buffer[1] != '\0'))
4000 (void) mbtowc (NULL, NULL, 0);
4001 if (mbtowc (& wc, token_buffer + 1, num_chars) == num_chars)
4004 warning ("Ignoring invalid multibyte character");
4007 yylval.ttype = build_int_2 (result, 0);
4008 TREE_TYPE (yylval.ttype) = wchar_type_node;
4021 p = token_buffer + 1;
4023 while (c != '"' && c >= 0)
4025 /* ignore_escape_flag is set for reading the filename in #line. */
4026 if (!ignore_escape_flag && c == '\\')
4029 c = readescape (&ignore);
4033 && TYPE_PRECISION (char_type_node) < HOST_BITS_PER_INT
4034 && c >= ((unsigned) 1 << TYPE_PRECISION (char_type_node)))
4035 warning ("escape sequence out of range for character");
4040 pedwarn ("ANSI C++ forbids newline in string constant");
4044 if (p == token_buffer + maxtoken)
4045 p = extend_token_buffer (p);
4051 error ("Unterminated string");
4057 /* We have read the entire constant.
4058 Construct a STRING_CST for the result. */
4062 /* If this is a L"..." wide-string, convert the multibyte string
4063 to a wide character string. */
4064 char *widep = (char *) alloca ((p - token_buffer) * WCHAR_BYTES);
4067 #ifdef MULTIBYTE_CHARS
4068 len = mbstowcs ((wchar_t *) widep, token_buffer + 1, p - token_buffer);
4069 if (len < 0 || len >= (p - token_buffer))
4071 warning ("Ignoring invalid multibyte string");
4074 bzero (widep + (len * WCHAR_BYTES), WCHAR_BYTES);
4079 wp = widep + (BYTES_BIG_ENDIAN ? WCHAR_BYTES - 1 : 0);
4080 bzero (widep, (p - token_buffer) * WCHAR_BYTES);
4081 for (cp = token_buffer + 1; cp < p; cp++)
4082 *wp = *cp, wp += WCHAR_BYTES;
4083 len = p - token_buffer - 1;
4086 if (processing_template_decl)
4087 push_obstacks (&permanent_obstack, &permanent_obstack);
4088 yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
4089 if (processing_template_decl)
4091 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4095 if (processing_template_decl)
4096 push_obstacks (&permanent_obstack, &permanent_obstack);
4097 yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
4098 if (processing_template_decl)
4100 TREE_TYPE (yylval.ttype) = char_array_type_node;
4106 value = STRING; break;
4129 yylval.code = PLUS_EXPR; break;
4131 yylval.code = MINUS_EXPR; break;
4133 yylval.code = BIT_AND_EXPR; break;
4135 yylval.code = BIT_IOR_EXPR; break;
4137 yylval.code = MULT_EXPR; break;
4139 yylval.code = TRUNC_DIV_EXPR; break;
4141 yylval.code = TRUNC_MOD_EXPR; break;
4143 yylval.code = BIT_XOR_EXPR; break;
4145 yylval.code = LSHIFT_EXPR; break;
4147 yylval.code = RSHIFT_EXPR; break;
4149 yylval.code = LT_EXPR; break;
4151 yylval.code = GT_EXPR; break;
4154 token_buffer[1] = c1 = getch ();
4155 token_buffer[2] = 0;
4162 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4164 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4166 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4168 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4170 value = ASSIGN; goto done;
4176 value = PLUSPLUS; goto done;
4178 value = MINUSMINUS; goto done;
4180 value = ANDAND; goto done;
4182 value = OROR; goto done;
4190 else if ((c == '-') && (c1 == '>'))
4192 nextchar = getch ();
4193 if (nextchar == '*')
4196 value = POINTSAT_STAR;
4202 else if (c1 == '?' && (c == '<' || c == '>'))
4204 token_buffer[3] = 0;
4207 yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4210 /* <?= or >?= expression. */
4211 token_buffer[2] = c1;
4220 pedwarn ("use of `operator %s' is not standard C++",
4225 else if (c == '<' && c1 == '%')
4226 { value = '{'; goto done; }
4227 else if (c == '<' && c1 == ':')
4228 { value = '['; goto done; }
4229 else if (c == '%' && c1 == '>')
4230 { value = '}'; goto done; }
4231 else if (c == '%' && c1 == ':')
4232 { value = '#'; goto done; }
4235 token_buffer[1] = 0;
4245 token_buffer[1] = ':';
4246 token_buffer[2] = '\0';
4263 /* Don't make yyparse think this is eof. */
4268 /* try, weakly, to handle casts to pointers to functions. */
4269 nextchar = skip_white_space (getch ());
4270 if (nextchar == '*')
4272 int next_c = skip_white_space (getch ());
4276 yylval.ttype = build1 (INDIRECT_REF, 0, 0);
4277 value = PAREN_STAR_PAREN;
4285 else if (nextchar == ')')
4288 yylval.ttype = NULL_TREE;
4299 /* yylloc.last_line = lineno; */
4300 #ifdef GATHER_STATISTICS
4301 #ifdef REDUCE_LENGTH
4302 token_count[value] += 1;
4313 return !!is_reserved_word (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
4316 #ifdef GATHER_STATISTICS
4317 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4318 need to be brought into here, unless this were actually put into a header
4320 /* Statistics-gathering stuff. */
4341 extern int tree_node_counts[];
4342 extern int tree_node_sizes[];
4345 /* Place to save freed lang_decls which were allocated on the
4346 permanent_obstack. @@ Not currently used. */
4347 tree free_lang_decl_chain;
4350 build_lang_decl (code, name, type)
4351 enum tree_code code;
4355 register tree t = build_decl (code, name, type);
4356 struct obstack *obstack = current_obstack;
4357 register int i = sizeof (struct lang_decl) / sizeof (int);
4360 if (! TREE_PERMANENT (t))
4361 obstack = saveable_obstack;
4363 /* Could be that saveable is permanent and current is not. */
4364 obstack = &permanent_obstack;
4366 if (free_lang_decl_chain && obstack == &permanent_obstack)
4368 pi = (int *)free_lang_decl_chain;
4369 free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
4372 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4377 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4378 LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4379 = obstack == &permanent_obstack;
4380 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4381 == TREE_PERMANENT (t), 234);
4382 DECL_MAIN_VARIANT (t) = t;
4383 if (current_lang_name == lang_name_cplusplus)
4384 DECL_LANGUAGE (t) = lang_cplusplus;
4385 else if (current_lang_name == lang_name_c)
4386 DECL_LANGUAGE (t) = lang_c;
4387 else if (current_lang_name == lang_name_java)
4388 DECL_LANGUAGE (t) = lang_java;
4389 else my_friendly_abort (64);
4391 #if 0 /* not yet, should get fixed properly later */
4392 if (code == TYPE_DECL)
4395 id = get_identifier (build_overload_name (type, 1, 1));
4396 DECL_ASSEMBLER_NAME (t) = id;
4400 #ifdef GATHER_STATISTICS
4401 tree_node_counts[(int)lang_decl] += 1;
4402 tree_node_sizes[(int)lang_decl] += sizeof (struct lang_decl);
4409 build_lang_field_decl (code, name, type)
4410 enum tree_code code;
4414 extern struct obstack *current_obstack, *saveable_obstack;
4415 register tree t = build_decl (code, name, type);
4416 struct obstack *obstack = current_obstack;
4417 register int i = sizeof (struct lang_decl_flags) / sizeof (int);
4419 #if 0 /* not yet, should get fixed properly later */
4421 if (code == TYPE_DECL)
4424 id = get_identifier (build_overload_name (type, 1, 1));
4425 DECL_ASSEMBLER_NAME (t) = id;
4429 if (! TREE_PERMANENT (t))
4430 obstack = saveable_obstack;
4432 my_friendly_assert (obstack == &permanent_obstack, 235);
4434 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
4438 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4443 copy_lang_decl (node)
4449 if (! DECL_LANG_SPECIFIC (node))
4452 if (TREE_CODE (node) == FIELD_DECL)
4453 size = sizeof (struct lang_decl_flags);
4455 size = sizeof (struct lang_decl);
4456 pi = (int *)obstack_alloc (&permanent_obstack, size);
4457 bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
4458 DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
4462 make_lang_type (code)
4463 enum tree_code code;
4465 extern struct obstack *current_obstack, *saveable_obstack;
4466 register tree t = make_node (code);
4467 struct obstack *obstack = current_obstack;
4468 register int i = sizeof (struct lang_type) / sizeof (int);
4471 /* Set up some flags that give proper default behavior. */
4472 IS_AGGR_TYPE (t) = 1;
4474 if (! TREE_PERMANENT (t))
4475 obstack = saveable_obstack;
4477 my_friendly_assert (obstack == &permanent_obstack, 236);
4479 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
4483 TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
4484 CLASSTYPE_AS_LIST (t) = build_expr_list (NULL_TREE, t);
4485 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
4486 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
4487 TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE,
4489 CLASSTYPE_BINFO_AS_LIST (t) = build_tree_list (NULL_TREE, TYPE_BINFO (t));
4491 /* Make sure this is laid out, for ease of use later.
4492 In the presence of parse errors, the normal was of assuring
4493 this might not ever get executed, so we lay it out *immediately*. */
4494 build_pointer_type (t);
4496 #ifdef GATHER_STATISTICS
4497 tree_node_counts[(int)lang_type] += 1;
4498 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
4505 dump_time_statistics ()
4507 register tree prev = 0, decl, next;
4508 int this_time = my_get_run_time ();
4509 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
4510 += this_time - body_time;
4512 fprintf (stderr, "\n******\n");
4513 print_time ("header files (total)", header_time);
4514 print_time ("main file (total)", this_time - body_time);
4515 fprintf (stderr, "ratio = %g : 1\n",
4516 (double)header_time / (double)(this_time - body_time));
4517 fprintf (stderr, "\n******\n");
4519 for (decl = filename_times; decl; decl = next)
4521 next = IDENTIFIER_GLOBAL_VALUE (decl);
4522 SET_IDENTIFIER_GLOBAL_VALUE (decl, prev);
4526 for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
4527 print_time (IDENTIFIER_POINTER (decl),
4528 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
4532 compiler_error (s, v, v2)
4534 HOST_WIDE_INT v, v2; /* @@also used as pointer */
4537 sprintf (buf, s, v, v2);
4538 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
4545 extern int end_of_file;
4548 strcpy (buf, string);
4550 /* We can't print string and character constants well
4551 because the token_buffer contains the result of processing escapes. */
4553 strcat (buf, input_redirected ()
4554 ? " at end of saved text"
4555 : " at end of input");
4556 else if (token_buffer[0] == 0)
4557 strcat (buf, " at null character");
4558 else if (token_buffer[0] == '"')
4559 strcat (buf, " before string constant");
4560 else if (token_buffer[0] == '\'')
4561 strcat (buf, " before character constant");
4562 else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
4563 sprintf (buf + strlen (buf), " before character 0%o",
4564 (unsigned char) token_buffer[0]);
4566 strcat (buf, " before `%s'");
4568 error (buf, token_buffer);
4572 handle_cp_pragma (pname)
4577 if (! strcmp (pname, "vtable"))
4579 extern tree pending_vtables;
4581 /* More follows: it must be a string constant (class name). */
4582 token = real_yylex ();
4583 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4585 error ("invalid #pragma vtable");
4589 if (write_virtuals != 2)
4591 warning ("use `+e2' option to enable #pragma vtable");
4595 = perm_tree_cons (NULL_TREE,
4596 get_identifier (TREE_STRING_POINTER (yylval.ttype)),
4598 token = real_yylex ();
4599 if (token != END_OF_LINE)
4600 warning ("trailing characters ignored");
4603 else if (! strcmp (pname, "unit"))
4605 /* More follows: it must be a string constant (unit name). */
4606 token = real_yylex ();
4607 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4609 error ("invalid #pragma unit");
4612 token = real_yylex ();
4613 if (token != END_OF_LINE)
4614 warning ("trailing characters ignored");
4617 else if (! strcmp (pname, "interface"))
4619 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4620 char *main_filename = input_filename;
4622 main_filename = file_name_nondirectory (main_filename);
4624 token = real_yylex ();
4626 if (token != END_OF_LINE)
4629 || TREE_CODE (yylval.ttype) != STRING_CST)
4631 error ("invalid `#pragma interface'");
4634 main_filename = TREE_STRING_POINTER (yylval.ttype);
4635 token = real_yylex ();
4638 if (token != END_OF_LINE)
4639 warning ("garbage after `#pragma interface' ignored");
4641 #ifndef NO_LINKAGE_HEURISTICS
4644 if (impl_file_chain == 0)
4646 /* If this is zero at this point, then we are
4647 auto-implementing. */
4648 if (main_input_filename == 0)
4649 main_input_filename = input_filename;
4651 #ifdef AUTO_IMPLEMENT
4652 filename = file_name_nondirectory (main_input_filename);
4653 fi = get_time_identifier (filename);
4654 fi = IDENTIFIER_CLASS_VALUE (fi);
4655 TREE_INT_CST_LOW (fi) = 0;
4656 TREE_INT_CST_HIGH (fi) = 1;
4658 impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
4659 impl_file_chain->filename = filename;
4660 impl_file_chain->next = 0;
4664 interface_only = interface_strcmp (main_filename);
4665 interface_unknown = 0;
4666 TREE_INT_CST_LOW (fileinfo) = interface_only;
4667 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4668 #endif /* NO_LINKAGE_HEURISTICS */
4672 else if (! strcmp (pname, "implementation"))
4674 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4675 char *main_filename = main_input_filename ? main_input_filename : input_filename;
4677 main_filename = file_name_nondirectory (main_filename);
4678 token = real_yylex ();
4679 if (token != END_OF_LINE)
4682 || TREE_CODE (yylval.ttype) != STRING_CST)
4684 error ("invalid `#pragma implementation'");
4687 main_filename = TREE_STRING_POINTER (yylval.ttype);
4688 token = real_yylex ();
4691 if (token != END_OF_LINE)
4692 warning ("garbage after `#pragma implementation' ignored");
4694 #ifndef NO_LINKAGE_HEURISTICS
4695 if (write_virtuals == 3)
4697 struct impl_files *ifiles = impl_file_chain;
4700 if (! strcmp (ifiles->filename, main_filename))
4702 ifiles = ifiles->next;
4706 ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
4707 ifiles->filename = main_filename;
4708 ifiles->next = impl_file_chain;
4709 impl_file_chain = ifiles;
4712 else if ((main_input_filename != 0
4713 && ! strcmp (main_input_filename, input_filename))
4714 || ! strcmp (input_filename, main_filename))
4717 if (impl_file_chain == 0)
4719 impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
4720 impl_file_chain->filename = main_filename;
4721 impl_file_chain->next = 0;
4725 error ("`#pragma implementation' can only appear at top-level");
4728 /* We make this non-zero so that we infer decl linkage
4729 in the impl file only for variables first declared
4730 in the interface file. */
4731 interface_unknown = 1;
4733 /* We make this zero so that templates in the impl
4734 file will be emitted properly. */
4735 interface_unknown = 0;
4737 TREE_INT_CST_LOW (fileinfo) = interface_only;
4738 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4739 #endif /* NO_LINKAGE_HEURISTICS */
4747 #ifdef HANDLE_SYSV_PRAGMA
4749 /* Handle a #pragma directive. INPUT is the current input stream,
4750 and C is a character to reread. Processes the entire input line
4751 and returns a character for the caller to reread: either \n or EOF. */
4753 /* This function has to be in this file, in order to get at
4757 handle_sysv_pragma (token)
4768 handle_pragma_token ("ignored", yylval.ttype);
4771 handle_pragma_token ("(", NULL_TREE);
4774 handle_pragma_token (")", NULL_TREE);
4777 handle_pragma_token (",", NULL_TREE);
4780 handle_pragma_token ("=", NULL_TREE);
4783 handle_pragma_token ("(", NULL_TREE);
4784 handle_pragma_token (")", NULL_TREE);
4788 handle_pragma_token (NULL_PTR, NULL_TREE);
4791 token = real_yylex ();
4794 #endif /* HANDLE_SYSV_PRAGMA */