1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000 Free Software Foundation, Inc.
4 Hacked by Michael Tiemann (tiemann@cygnus.com)
6 This file is part of GNU CC.
8 GNU CC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GNU CC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU CC; see the file COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
24 /* This file is the lexical analyzer for GNU C++. */
26 /* Cause the `yydebug' variable to be defined. */
44 #ifdef MULTIBYTE_CHARS
49 #define obstack_chunk_alloc xmalloc
50 #define obstack_chunk_free free
52 extern void yyprint PARAMS ((FILE *, int, YYSTYPE));
54 static tree get_time_identifier PARAMS ((const char *));
55 static int check_newline PARAMS ((void));
56 static int whitespace_cr PARAMS ((int));
57 static int skip_white_space PARAMS ((int));
58 static void finish_defarg PARAMS ((void));
59 static int my_get_run_time PARAMS ((void));
60 static int interface_strcmp PARAMS ((const char *));
61 static int readescape PARAMS ((int *));
62 static char *extend_token_buffer PARAMS ((const char *));
63 static void consume_string PARAMS ((struct obstack *, int));
64 static void feed_defarg PARAMS ((tree, tree));
65 static void store_pending_inline PARAMS ((tree, struct pending_inline *));
66 static void reinit_parse_for_expr PARAMS ((struct obstack *));
67 static int *init_cpp_parse PARAMS ((void));
68 static void cp_pragma_interface PARAMS ((char *));
69 static void cp_pragma_implementation PARAMS ((char *));
70 static int handle_cp_pragma PARAMS ((const char *));
71 #ifdef HANDLE_GENERIC_PRAGMAS
72 static int handle_generic_pragma PARAMS ((int));
74 #ifdef GATHER_STATISTICS
76 static int reduce_cmp PARAMS ((int *, int *));
77 static int token_cmp PARAMS ((int *, int *));
80 static void begin_definition_of_inclass_inline PARAMS ((struct pending_inline*));
81 static void parse_float PARAMS ((PTR));
82 static int is_global PARAMS ((tree));
83 static void init_filename_times PARAMS ((void));
84 static void extend_token_buffer_to PARAMS ((int));
86 static int pragma_getc PARAMS ((void));
87 static void pragma_ungetc PARAMS ((int));
89 static int read_line_number PARAMS ((int *));
90 static int token_getch PARAMS ((void));
91 static void token_put_back PARAMS ((int));
92 static void mark_impl_file_chain PARAMS ((void *));
93 static int read_ucs PARAMS ((int));
94 static int is_extended_char PARAMS ((int));
95 static int is_extended_char_1 PARAMS ((int));
97 /* Given a file name X, return the nondirectory portion.
98 Keep in mind that X can be computed more than once. */
100 file_name_nondirectory (x)
103 char *tmp = (char *) rindex (x, '/');
104 if (DIR_SEPARATOR != '/' && ! tmp)
105 tmp = (char *) rindex (x, DIR_SEPARATOR);
107 return (char *) (tmp + 1);
112 /* This obstack is needed to hold text. It is not safe to use
113 TOKEN_BUFFER because `check_newline' calls `yylex'. */
114 struct obstack inline_text_obstack;
115 char *inline_text_firstobj;
117 /* Nonzero if parse output is being saved to an obstack for later parsing. */
118 static int saving_parse_to_obstack = 0;
122 extern cpp_reader parse_in;
123 extern cpp_options parse_options;
124 extern unsigned char *yy_cur, *yy_lim;
125 extern enum cpp_token cpp_token;
133 /* Pending language change.
134 Positive is push count, negative is pop count. */
135 int pending_lang_change = 0;
137 /* Wrap the current header file in extern "C". */
138 static int c_header_level = 0;
140 extern int first_token;
141 extern struct obstack token_obstack;
143 /* ??? Don't really know where this goes yet. */
146 /* Holds translations from TREE_CODEs to operator name strings,
147 i.e., opname_tab[PLUS_EXPR] == "+". */
148 const char **opname_tab;
149 const char **assignop_tab;
151 extern int yychar; /* the lookahead symbol */
152 extern YYSTYPE yylval; /* the semantic value of the */
153 /* lookahead symbol */
156 YYLTYPE yylloc; /* location data for the lookahead */
161 /* the declaration found for the last IDENTIFIER token read in.
162 yylex must look this up to detect typedefs, which get token type TYPENAME,
163 so it is left around in case the identifier is not a typedef but is
164 used in a context which makes it a reference to a variable. */
167 /* The elements of `ridpointers' are identifier nodes
168 for the reserved type names and storage classes.
169 It is indexed by a RID_... value. */
170 tree ridpointers[(int) RID_MAX];
172 /* We may keep statistics about how long which files took to compile. */
173 static int header_time, body_time;
174 static tree filename_times;
175 static tree this_filename_time;
177 /* Array for holding counts of the numbers of tokens seen. */
178 extern int *token_count;
180 /* When we see a default argument in a method declaration, we snarf it as
181 text using snarf_defarg. When we get up to namespace scope, we then go
182 through and parse all of them using do_pending_defargs. Since yacc
183 parsers are not reentrant, we retain defargs state in these two
184 variables so that subsequent calls to do_pending_defargs can resume
185 where the previous call left off. */
187 static tree defarg_fns;
188 static tree defarg_parm;
190 /* Functions and data structures for #pragma interface.
192 `#pragma implementation' means that the main file being compiled
193 is considered to implement (provide) the classes that appear in
194 its main body. I.e., if this is file "foo.cc", and class `bar'
195 is defined in "foo.cc", then we say that "foo.cc implements bar".
197 All main input files "implement" themselves automagically.
199 `#pragma interface' means that unless this file (of the form "foo.h"
200 is not presently being included by file "foo.cc", the
201 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
202 of the vtables nor any of the inline functions defined in foo.h
205 There are cases when we want to link files such as "defs.h" and
206 "main.cc". In this case, we give "defs.h" a `#pragma interface',
207 and "main.cc" has `#pragma implementation "defs.h"'. */
212 struct impl_files *next;
215 static struct impl_files *impl_file_chain;
217 /* The string used to represent the filename of internally generated
218 tree nodes. The variable, which is dynamically allocated, should
219 be used; the macro is only used to initialize it. */
220 static char *internal_filename;
221 #define INTERNAL_FILENAME ("<internal>")
223 /* Return something to represent absolute declarators containing a *.
224 TARGET is the absolute declarator that the * contains.
225 CV_QUALIFIERS is a list of modifiers such as const or volatile
226 to apply to the pointer type, represented as identifiers.
228 We return an INDIRECT_REF whose "contents" are TARGET
229 and whose type is the modifier list. */
232 make_pointer_declarator (cv_qualifiers, target)
233 tree cv_qualifiers, target;
235 if (target && TREE_CODE (target) == IDENTIFIER_NODE
236 && ANON_AGGRNAME_P (target))
237 error ("type name expected before `*'");
238 target = build_parse_node (INDIRECT_REF, target);
239 TREE_TYPE (target) = cv_qualifiers;
243 /* Return something to represent absolute declarators containing a &.
244 TARGET is the absolute declarator that the & contains.
245 CV_QUALIFIERS is a list of modifiers such as const or volatile
246 to apply to the reference type, represented as identifiers.
248 We return an ADDR_EXPR whose "contents" are TARGET
249 and whose type is the modifier list. */
252 make_reference_declarator (cv_qualifiers, target)
253 tree cv_qualifiers, target;
257 if (TREE_CODE (target) == ADDR_EXPR)
259 error ("cannot declare references to references");
262 if (TREE_CODE (target) == INDIRECT_REF)
264 error ("cannot declare pointers to references");
267 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
268 error ("type name expected before `&'");
270 target = build_parse_node (ADDR_EXPR, target);
271 TREE_TYPE (target) = cv_qualifiers;
276 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
277 tree target, parms, cv_qualifiers, exception_specification;
279 target = build_parse_node (CALL_EXPR, target,
280 /* Both build_parse_node and
281 decl_tree_cons build on the
282 temp_decl_obstack. */
283 decl_tree_cons (parms, cv_qualifiers, NULL_TREE),
284 /* The third operand is really RTL. We
285 shouldn't put anything there. */
287 CALL_DECLARATOR_EXCEPTION_SPEC (target) = exception_specification;
292 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
293 tree call_declarator, cv_qualifiers, exception_specification;
295 CALL_DECLARATOR_QUALS (call_declarator) = cv_qualifiers;
296 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator) = exception_specification;
299 /* Build names and nodes for overloaded operators. */
301 tree ansi_opname[LAST_CPLUS_TREE_CODE];
302 tree ansi_assopname[LAST_CPLUS_TREE_CODE];
305 operator_name_string (name)
308 char *opname = IDENTIFIER_POINTER (name) + 2;
312 /* Works for builtin and user defined types. */
313 if (IDENTIFIER_GLOBAL_VALUE (name)
314 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
315 return IDENTIFIER_POINTER (name);
317 if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
321 opname_table = ansi_assopname;
326 opname_table = ansi_opname;
329 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
331 if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
332 && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
336 if (i == LAST_CPLUS_TREE_CODE)
337 return "<invalid operator>";
340 return assignop_tab[i];
342 return opname_tab[i];
345 int interface_only; /* whether or not current file is only for
346 interface definitions. */
347 int interface_unknown; /* whether or not we know this class
348 to behave according to #pragma interface. */
350 /* lexical analyzer */
352 #undef WCHAR_TYPE_SIZE
353 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
355 /* Number of bytes in a wide character. */
356 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
358 static int maxtoken; /* Current nominal length of token buffer. */
359 char *token_buffer; /* Pointer to token buffer.
360 Actual allocated length is maxtoken + 2. */
362 static int indent_level; /* Number of { minus number of }. */
367 /* Nonzero tells yylex to ignore \ in string constants. */
368 static int ignore_escape_flag;
371 get_time_identifier (name)
374 tree time_identifier;
375 int len = strlen (name);
376 char *buf = (char *) alloca (len + 6);
377 strcpy (buf, "file ");
378 bcopy (name, buf+5, len);
380 time_identifier = get_identifier (buf);
381 if (TIME_IDENTIFIER_TIME (time_identifier) == NULL_TREE)
383 TIME_IDENTIFIER_TIME (time_identifier) = build_int_2 (0, 0);
384 TIME_IDENTIFIER_FILEINFO (time_identifier)
385 = build_int_2 (0, 1);
386 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier, filename_times);
387 filename_times = time_identifier;
389 return time_identifier;
395 int old_quiet_flag = quiet_flag;
398 this_time = get_run_time ();
399 quiet_flag = old_quiet_flag;
403 /* Table indexed by tree code giving a string containing a character
404 classifying the tree code. Possibilities are
405 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
407 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
409 static char cplus_tree_code_type[] = {
411 #include "cp-tree.def"
415 /* Table indexed by tree code giving number of expression
416 operands beyond the fixed part of the node structure.
417 Not used for types or decls. */
419 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
421 static int cplus_tree_code_length[] = {
423 #include "cp-tree.def"
427 /* Names of tree components.
428 Used for printing out the tree and error messages. */
429 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
431 static const char *cplus_tree_code_name[] = {
433 #include "cp-tree.def"
437 /* toplev.c needs to call these. */
443 cpp_reader_init (&parse_in);
444 parse_in.opts = &parse_options;
445 cpp_options_init (&parse_options);
446 parse_options.cplusplus = 1;
449 /* Default exceptions on. */
451 /* Mark as "unspecified". */
452 flag_bounds_check = -1;
453 /* By default wrap lines at 72 characters. */
454 set_message_length (72);
460 /* If still "unspecified", make it match -fbounded-pointers. */
461 if (flag_bounds_check < 0)
462 flag_bounds_check = flag_bounded_pointers;
464 /* the beginning of the file is a new line; check for # */
465 /* With luck, we discover the real source file's name from that
466 and put it in input_filename. */
467 put_back (check_newline ());
468 if (flag_gnu_xref) GNU_xref_begin (input_filename);
469 init_repo (input_filename);
475 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
485 init_filename_times ()
487 this_filename_time = get_time_identifier ("<top level>");
488 if (flag_detailed_statistics)
491 body_time = my_get_run_time ();
492 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time))
497 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
498 Stuck this hack in to get the files open correctly; this is called
499 in place of init_parse if we are an unexec'd binary. */
503 reinit_lang_specific ()
505 init_filename_times ();
506 reinit_search_statistics ();
513 #ifdef GATHER_STATISTICS
515 reduce_count = (int *) xcalloc (sizeof (int), (REDUCE_LENGTH + 1));
517 token_count = (int *) xcalloc (sizeof (int), (TOKEN_LENGTH + 1));
525 init_parse (filename)
528 extern int flag_no_gnu_keywords;
529 extern int flag_operator_names;
533 #ifdef MULTIBYTE_CHARS
534 /* Change to the native locale for multibyte conversions. */
535 setlocale (LC_CTYPE, "");
536 literal_codeset = getenv ("LANG");
540 /* Open input file. */
541 if (filename == 0 || !strcmp (filename, "-"))
547 finput = fopen (filename, "r");
549 pfatal_with_name (filename);
551 #ifdef IO_BUFFER_SIZE
552 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
554 #else /* !USE_CPPLIB */
555 parse_in.show_column = 1;
556 if (! cpp_start_read (&parse_in, filename))
559 if (filename == 0 || !strcmp (filename, "-"))
562 /* cpp_start_read always puts at least one line directive into the
563 token buffer. We must arrange to read it out here. */
564 yy_cur = parse_in.token_buffer;
565 yy_lim = CPP_PWRITTEN (&parse_in);
566 cpp_token = CPP_DIRECTIVE;
568 #endif /* !USE_CPPLIB */
570 /* Initialize the lookahead machinery. */
573 /* Make identifier nodes long enough for the language-specific slots. */
574 set_identifier_size (sizeof (struct lang_identifier));
575 decl_printable_name = lang_printable_name;
578 init_cplus_expand ();
580 memcpy (tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
581 cplus_tree_code_type,
582 (int)LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
583 memcpy (tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE,
584 cplus_tree_code_length,
585 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
586 memcpy (tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE,
587 cplus_tree_code_name,
588 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
590 opname_tab = (const char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
591 memset (opname_tab, 0, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
592 assignop_tab = (const char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
593 memset (assignop_tab, 0, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
595 ansi_opname[0] = get_identifier ("<invalid operator>");
596 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
598 ansi_opname[i] = ansi_opname[0];
599 ansi_assopname[i] = ansi_opname[0];
602 ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
603 IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
604 ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
605 ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
606 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
607 ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
608 ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
609 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
610 ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
611 IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
612 ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
613 ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
614 ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
615 ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
616 IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
617 ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
618 ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
619 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
620 ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
621 ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
622 IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
623 ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
624 IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
625 ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
626 IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
627 ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
628 IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
629 ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
630 IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
631 ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
632 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
633 ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
634 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
635 ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
636 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
637 ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
638 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
639 ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
640 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
641 ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
642 ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
643 IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
644 ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
645 ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
646 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
647 ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
648 IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
649 ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
650 IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
651 ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
652 ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
653 ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
654 ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
655 ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
656 ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
657 ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
658 ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
659 ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
660 IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
661 ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
662 IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
663 ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
664 ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
665 ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
666 IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
667 ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
668 IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
669 ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
670 IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
671 ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
672 IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
673 ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
674 IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
675 ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
676 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
677 ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
678 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
679 ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
680 ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
681 ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
682 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
683 ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
684 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
685 ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
686 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
687 ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
688 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
689 ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
690 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
691 ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
692 ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
693 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
694 ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
695 IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
696 ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
697 IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
698 ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
699 IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
700 ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
701 IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
702 ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
703 IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
704 ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
705 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
706 ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
707 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
708 ansi_opname[(int) TYPE_EXPR] = get_identifier (OPERATOR_TYPENAME_FORMAT);
709 IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
711 /* This is not true: these operators are not defined in ANSI,
712 but we need them anyway. */
713 ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
714 IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
715 ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
716 IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
717 ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
718 IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
719 ansi_opname[(int) SIZEOF_EXPR] = get_identifier ("__sz");
720 IDENTIFIER_OPNAME_P (ansi_opname[(int) SIZEOF_EXPR]) = 1;
724 gcc_obstack_init (&inline_text_obstack);
725 inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
727 internal_filename = ggc_alloc_string (INTERNAL_FILENAME,
728 sizeof (INTERNAL_FILENAME));
730 /* Start it at 0, because check_newline is called at the very beginning
731 and will increment it to 1. */
733 input_filename = internal_filename;
734 current_function_decl = NULL;
737 token_buffer = (char *) xmalloc (maxtoken + 2);
739 ridpointers[(int) RID_INT] = get_identifier ("int");
740 ridpointers[(int) RID_BOOL] = get_identifier ("bool");
741 ridpointers[(int) RID_CHAR] = get_identifier ("char");
742 ridpointers[(int) RID_VOID] = get_identifier ("void");
743 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
744 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
745 ridpointers[(int) RID_SHORT] = get_identifier ("short");
746 ridpointers[(int) RID_LONG] = get_identifier ("long");
747 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
748 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
749 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
750 ridpointers[(int) RID_CONST] = get_identifier ("const");
751 ridpointers[(int) RID_RESTRICT] = get_identifier ("__restrict");
752 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
753 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
754 ridpointers[(int) RID_STATIC] = get_identifier ("static");
755 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
756 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
757 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
758 ridpointers[(int) RID_COMPLEX] = get_identifier ("__complex");
760 /* C++ extensions. These are probably not correctly named. */
761 ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
762 class_type_node = build_int_2 (class_type, 0);
763 TREE_TYPE (class_type_node) = class_type_node;
764 ridpointers[(int) RID_CLASS] = class_type_node;
766 record_type_node = build_int_2 (record_type, 0);
767 TREE_TYPE (record_type_node) = record_type_node;
768 ridpointers[(int) RID_RECORD] = record_type_node;
770 union_type_node = build_int_2 (union_type, 0);
771 TREE_TYPE (union_type_node) = union_type_node;
772 ridpointers[(int) RID_UNION] = union_type_node;
774 enum_type_node = build_int_2 (enum_type, 0);
775 TREE_TYPE (enum_type_node) = enum_type_node;
776 ridpointers[(int) RID_ENUM] = enum_type_node;
778 ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
779 ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
780 ridpointers[(int) RID_EXPORT] = get_identifier ("export");
781 ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
783 ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
784 ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
785 ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
786 ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
787 /* This is for ANSI C++. */
788 ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
790 /* Create the built-in __null node. Note that we can't yet call for
791 type_for_size here because integer_type_node and so forth are not
792 set up. Therefore, we don't set the type of these nodes until
793 init_decl_processing. */
794 null_node = build_int_2 (0, 0);
795 ridpointers[RID_NULL] = null_node;
797 opname_tab[(int) COMPONENT_REF] = "->";
798 opname_tab[(int) MEMBER_REF] = "->*";
799 opname_tab[(int) INDIRECT_REF] = "*";
800 opname_tab[(int) ARRAY_REF] = "[]";
801 opname_tab[(int) MODIFY_EXPR] = "=";
802 opname_tab[(int) INIT_EXPR] = "=";
803 opname_tab[(int) NEW_EXPR] = "new";
804 opname_tab[(int) DELETE_EXPR] = "delete";
805 opname_tab[(int) VEC_NEW_EXPR] = "new []";
806 opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
807 opname_tab[(int) COND_EXPR] = "?:";
808 opname_tab[(int) CALL_EXPR] = "()";
809 opname_tab[(int) PLUS_EXPR] = "+";
810 opname_tab[(int) MINUS_EXPR] = "-";
811 opname_tab[(int) MULT_EXPR] = "*";
812 opname_tab[(int) TRUNC_DIV_EXPR] = "/";
813 opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
814 opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
815 opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
816 opname_tab[(int) TRUNC_MOD_EXPR] = "%";
817 opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
818 opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
819 opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
820 opname_tab[(int) EXACT_DIV_EXPR] = "/";
821 opname_tab[(int) NEGATE_EXPR] = "-";
822 opname_tab[(int) MIN_EXPR] = "<?";
823 opname_tab[(int) MAX_EXPR] = ">?";
824 opname_tab[(int) ABS_EXPR] = "abs";
825 opname_tab[(int) FFS_EXPR] = "ffs";
826 opname_tab[(int) LSHIFT_EXPR] = "<<";
827 opname_tab[(int) RSHIFT_EXPR] = ">>";
828 opname_tab[(int) BIT_IOR_EXPR] = "|";
829 opname_tab[(int) BIT_XOR_EXPR] = "^";
830 opname_tab[(int) BIT_AND_EXPR] = "&";
831 opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
832 opname_tab[(int) BIT_NOT_EXPR] = "~";
833 opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
834 opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
835 opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
836 opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
837 opname_tab[(int) TRUTH_NOT_EXPR] = "!";
838 opname_tab[(int) LT_EXPR] = "<";
839 opname_tab[(int) LE_EXPR] = "<=";
840 opname_tab[(int) GT_EXPR] = ">";
841 opname_tab[(int) GE_EXPR] = ">=";
842 opname_tab[(int) EQ_EXPR] = "==";
843 opname_tab[(int) NE_EXPR] = "!=";
844 opname_tab[(int) IN_EXPR] = "in";
845 opname_tab[(int) RANGE_EXPR] = "...";
846 opname_tab[(int) CONVERT_EXPR] = "+";
847 opname_tab[(int) ADDR_EXPR] = "&";
848 opname_tab[(int) PREDECREMENT_EXPR] = "--";
849 opname_tab[(int) PREINCREMENT_EXPR] = "++";
850 opname_tab[(int) POSTDECREMENT_EXPR] = "--";
851 opname_tab[(int) POSTINCREMENT_EXPR] = "++";
852 opname_tab[(int) COMPOUND_EXPR] = ",";
854 assignop_tab[(int) NOP_EXPR] = "=";
855 assignop_tab[(int) PLUS_EXPR] = "+=";
856 assignop_tab[(int) CONVERT_EXPR] = "+=";
857 assignop_tab[(int) MINUS_EXPR] = "-=";
858 assignop_tab[(int) NEGATE_EXPR] = "-=";
859 assignop_tab[(int) MULT_EXPR] = "*=";
860 assignop_tab[(int) INDIRECT_REF] = "*=";
861 assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
862 assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
863 assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
864 assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
865 assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
866 assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
867 assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
868 assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
869 assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
870 assignop_tab[(int) MIN_EXPR] = "<?=";
871 assignop_tab[(int) MAX_EXPR] = ">?=";
872 assignop_tab[(int) LSHIFT_EXPR] = "<<=";
873 assignop_tab[(int) RSHIFT_EXPR] = ">>=";
874 assignop_tab[(int) BIT_IOR_EXPR] = "|=";
875 assignop_tab[(int) BIT_XOR_EXPR] = "^=";
876 assignop_tab[(int) BIT_AND_EXPR] = "&=";
877 assignop_tab[(int) ADDR_EXPR] = "&=";
879 init_filename_times ();
881 /* Some options inhibit certain reserved words.
882 Clear those words out of the hash table so they won't be recognized. */
883 #define UNSET_RESERVED_WORD(STRING) \
884 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
885 if (s) s->name = ""; } while (0)
888 /* let's parse things, and if they use it, then give them an error. */
889 if (!flag_exceptions)
891 UNSET_RESERVED_WORD ("throw");
892 UNSET_RESERVED_WORD ("try");
893 UNSET_RESERVED_WORD ("catch");
897 if (!flag_rtti || flag_no_gnu_keywords)
899 UNSET_RESERVED_WORD ("classof");
900 UNSET_RESERVED_WORD ("headof");
903 if (flag_no_asm || flag_no_gnu_keywords)
904 UNSET_RESERVED_WORD ("typeof");
905 if (! flag_operator_names)
907 /* These are new ANSI keywords that may break code. */
908 UNSET_RESERVED_WORD ("and");
909 UNSET_RESERVED_WORD ("and_eq");
910 UNSET_RESERVED_WORD ("bitand");
911 UNSET_RESERVED_WORD ("bitor");
912 UNSET_RESERVED_WORD ("compl");
913 UNSET_RESERVED_WORD ("not");
914 UNSET_RESERVED_WORD ("not_eq");
915 UNSET_RESERVED_WORD ("or");
916 UNSET_RESERVED_WORD ("or_eq");
917 UNSET_RESERVED_WORD ("xor");
918 UNSET_RESERVED_WORD ("xor_eq");
921 token_count = init_cpp_parse ();
922 interface_unknown = 1;
924 ggc_add_tree_root (ansi_opname, LAST_CPLUS_TREE_CODE);
925 ggc_add_tree_root (ansi_assopname, LAST_CPLUS_TREE_CODE);
926 ggc_add_string_root (&internal_filename, 1);
927 ggc_add_tree_root (ridpointers, RID_MAX);
928 ggc_add_tree_root (&defarg_fns, 1);
929 ggc_add_tree_root (&defarg_parm, 1);
930 ggc_add_tree_root (&this_filename_time, 1);
931 ggc_add_tree_root (&filename_times, 1);
932 ggc_add_root (&impl_file_chain, 1, sizeof (impl_file_chain),
933 mark_impl_file_chain);
941 cpp_finish (&parse_in);
942 errorcount += parse_in.errors;
949 reinit_parse_for_function ()
951 current_base_init_list = NULL_TREE;
952 current_member_init_list = NULL_TREE;
956 yyprint (file, yychar, yylval)
969 case IDENTIFIER_DEFN:
973 case PRE_PARSED_CLASS_DECL:
975 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
977 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
980 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
981 if (IDENTIFIER_POINTER (t))
982 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
986 if (yylval.ttype == class_type_node)
987 fprintf (file, " `class'");
988 else if (yylval.ttype == record_type_node)
989 fprintf (file, " `struct'");
990 else if (yylval.ttype == union_type_node)
991 fprintf (file, " `union'");
992 else if (yylval.ttype == enum_type_node)
993 fprintf (file, " `enum'");
995 my_friendly_abort (80);
1000 if (TREE_CODE (t) == INTEGER_CST)
1002 #if HOST_BITS_PER_WIDE_INT == 64
1003 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1006 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1013 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
1019 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
1024 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
1025 static int *reduce_count;
1031 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
1032 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
1035 #ifdef GATHER_STATISTICS
1036 #ifdef REDUCE_LENGTH
1041 reduce_count[yyn] += 1;
1048 return reduce_count[*q] - reduce_count[*p];
1055 return token_count[*q] - token_count[*p];
1061 print_parse_statistics ()
1063 #ifdef GATHER_STATISTICS
1064 #ifdef REDUCE_LENGTH
1067 int maxlen = REDUCE_LENGTH;
1070 if (reduce_count[-1] == 0)
1073 if (TOKEN_LENGTH > REDUCE_LENGTH)
1074 maxlen = TOKEN_LENGTH;
1075 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1077 for (i = 0; i < TOKEN_LENGTH; i++)
1079 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1080 for (i = 0; i < TOKEN_LENGTH; i++)
1082 int idx = sorted[i];
1083 if (token_count[idx] == 0)
1085 if (token_count[idx] < token_count[-1])
1087 fprintf (stderr, "token %d, `%s', count = %d\n",
1088 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
1090 fprintf (stderr, "\n");
1091 for (i = 0; i < REDUCE_LENGTH; i++)
1093 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1094 for (i = 0; i < REDUCE_LENGTH; i++)
1096 int idx = sorted[i];
1097 if (reduce_count[idx] == 0)
1099 if (reduce_count[idx] < reduce_count[-1])
1101 fprintf (stderr, "rule %d, line %d, count = %d\n",
1102 idx, yyrline[idx], reduce_count[idx]);
1104 fprintf (stderr, "\n");
1110 /* Sets the value of the 'yydebug' variable to VALUE.
1111 This is a function so we don't have to have YYDEBUG defined
1112 in order to build the compiler. */
1122 warning ("YYDEBUG not defined.");
1127 /* Mark ARG (which is really a struct impl_files **) for GC. */
1130 mark_impl_file_chain (arg)
1133 struct impl_files *ifs;
1135 ifs = *(struct impl_files **) arg;
1138 ggc_mark_string (ifs->filename);
1143 /* Helper function to load global variables with interface
1147 extract_interface_info ()
1151 if (flag_alt_external_templates)
1153 struct tinst_level *til = tinst_for_decl ();
1156 fileinfo = get_time_identifier (til->file);
1159 fileinfo = get_time_identifier (input_filename);
1160 fileinfo = TIME_IDENTIFIER_FILEINFO (fileinfo);
1161 interface_only = TREE_INT_CST_LOW (fileinfo);
1162 interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1165 /* Return nonzero if S is not considered part of an
1166 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1169 interface_strcmp (s)
1172 /* Set the interface/implementation bits for this scope. */
1173 struct impl_files *ifiles;
1176 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1178 const char *t1 = ifiles->filename;
1181 if (*s1 != *t1 || *s1 == 0)
1184 while (*s1 == *t1 && *s1 != 0)
1191 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1192 if (index (s1, '.') || index (t1, '.'))
1195 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1207 cp_pragma_interface (main_filename)
1208 char *main_filename;
1211 = TIME_IDENTIFIER_FILEINFO (get_time_identifier (input_filename));
1213 if (impl_file_chain == 0)
1215 /* If this is zero at this point, then we are
1216 auto-implementing. */
1217 if (main_input_filename == 0)
1218 main_input_filename = input_filename;
1220 #ifdef AUTO_IMPLEMENT
1221 filename = file_name_nondirectory (main_input_filename);
1222 fi = get_time_identifier (filename);
1223 fi = TIME_IDENTIFIER_FILEINFO (fi);
1224 TREE_INT_CST_LOW (fi) = 0;
1225 TREE_INT_CST_HIGH (fi) = 1;
1228 = (struct impl_files *) xmalloc (sizeof (struct impl_files));
1229 impl_file_chain->filename = ggc_alloc_string (filename, -1);
1230 impl_file_chain->next = 0;
1234 interface_only = interface_strcmp (main_filename);
1235 #ifdef MULTIPLE_SYMBOL_SPACES
1236 if (! interface_only)
1237 interface_unknown = 0;
1238 #else /* MULTIPLE_SYMBOL_SPACES */
1239 interface_unknown = 0;
1240 #endif /* MULTIPLE_SYMBOL_SPACES */
1241 TREE_INT_CST_LOW (fileinfo) = interface_only;
1242 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
1245 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1246 We used to only allow this at toplevel, but that restriction was buggy
1247 in older compilers and it seems reasonable to allow it in the headers
1248 themselves, too. It only needs to precede the matching #p interface.
1250 We don't touch interface_only or interface_unknown; the user must specify
1251 a matching #p interface for this to have any effect. */
1254 cp_pragma_implementation (main_filename)
1255 char *main_filename;
1257 struct impl_files *ifiles = impl_file_chain;
1258 for (; ifiles; ifiles = ifiles->next)
1260 if (! strcmp (ifiles->filename, main_filename))
1265 ifiles = (struct impl_files*) xmalloc (sizeof (struct impl_files));
1266 ifiles->filename = ggc_alloc_string (main_filename, -1);
1267 ifiles->next = impl_file_chain;
1268 impl_file_chain = ifiles;
1272 /* Set up the state required to correctly handle the definition of the
1273 inline function whose preparsed state has been saved in PI. */
1276 begin_definition_of_inclass_inline (pi)
1277 struct pending_inline* pi;
1284 /* If this is an inline function in a local class, we must make sure
1285 that we save all pertinent information about the function
1286 surrounding the local class. */
1287 context = decl_function_context (pi->fndecl);
1289 push_function_context_to (context);
1291 feed_input (pi->buf, pi->len, pi->filename, pi->lineno);
1292 yychar = PRE_PARSED_FUNCTION_DECL;
1294 /* Pass back a handle to the rest of the inline functions, so that they
1295 can be processed later. */
1296 DECL_PENDING_INLINE_INFO (pi->fndecl) = 0;
1297 DECL_PENDING_INLINE_P (pi->fndecl) = 0;
1298 interface_unknown = pi->interface == 1;
1299 interface_only = pi->interface == 0;
1302 /* Called from the top level: if there are any pending inlines to
1303 do, set up to process them now. This function sets up the first function
1304 to be parsed; after it has been, the rule for fndef in parse.y will
1305 call process_next_inline to start working on the next one. */
1308 do_pending_inlines ()
1310 struct pending_inline *t;
1312 /* Oops, we're still dealing with the last batch. */
1313 if (yychar == PRE_PARSED_FUNCTION_DECL)
1316 /* Reverse the pending inline functions, since
1317 they were cons'd instead of appended. */
1319 struct pending_inline *prev = 0, *tail;
1320 t = pending_inlines;
1321 pending_inlines = 0;
1336 /* Now start processing the first inline function. */
1337 begin_definition_of_inclass_inline (t);
1340 /* Called from the fndecl rule in the parser when the function just parsed
1341 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1342 do_pending_inlines). */
1345 process_next_inline (i)
1346 struct pending_inline *i;
1349 context = decl_function_context (i->fndecl);
1351 pop_function_context_from (context);
1353 if (yychar == YYEMPTY)
1355 if (yychar != END_OF_SAVED_INPUT)
1357 error ("parse error at end of saved function text");
1359 /* restore_pending_input will abort unless yychar is either
1360 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1361 hosed, feed back YYEMPTY. */
1366 begin_definition_of_inclass_inline (i);
1368 extract_interface_info ();
1371 /* Since inline methods can refer to text which has not yet been seen,
1372 we store the text of the method in a structure which is placed in the
1373 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1374 After parsing the body of the class definition, the FUNCTION_DECL's are
1375 scanned to see which ones have this field set. Those are then digested
1378 This function's FUNCTION_DECL will have a bit set in its common so
1379 that we know to watch out for it. */
1382 consume_string (this_obstack, matching_char)
1383 register struct obstack *this_obstack;
1387 int starting_lineno;
1390 if (cpp_token == CPP_STRING)
1392 /* The C preprocessor will warn about newlines in strings. */
1393 obstack_grow (this_obstack, yy_cur, (yy_lim - yy_cur));
1395 lineno = parse_in.lineno;
1400 starting_lineno = lineno;
1406 int save_lineno = lineno;
1407 lineno = starting_lineno;
1408 if (matching_char == '"')
1409 error ("end of file encountered inside string constant");
1411 error ("end of file encountered inside character constant");
1412 lineno = save_lineno;
1417 obstack_1grow (this_obstack, c);
1419 obstack_1grow (this_obstack, c);
1421 /* Make sure we continue the loop */
1428 pedwarn ("ISO C++ forbids newline in string constant");
1431 obstack_1grow (this_obstack, c);
1433 while (c != matching_char);
1436 struct pending_input {
1439 struct obstack token_obstack;
1443 struct pending_input *
1444 save_pending_input ()
1446 struct pending_input *p;
1447 p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1450 p->eof = end_of_file;
1452 p->first_token = first_token;
1453 p->token_obstack = token_obstack;
1456 gcc_obstack_init (&token_obstack);
1462 restore_pending_input (p)
1463 struct pending_input *p;
1465 my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1468 first_token = p->first_token;
1469 obstack_free (&token_obstack, (char *) 0);
1470 token_obstack = p->token_obstack;
1471 end_of_file = p->eof;
1475 /* Unget character CH from the input stream.
1476 If RESCAN is non-zero, then we want to `see' this
1477 character as the next input token. */
1480 yyungetc (ch, rescan)
1484 /* Unget a character from the input stream. */
1485 if (yychar == YYEMPTY || rescan == 0)
1487 /* If we're putting back a brace, undo the change in indent_level
1488 from the first time we saw it. */
1503 clear_inline_text_obstack ()
1505 obstack_free (&inline_text_obstack, inline_text_firstobj);
1508 /* This function stores away the text for an inline function that should
1509 be processed later. It decides how much later, and may need to move
1510 the info between obstacks; therefore, the caller should not refer to
1511 the T parameter after calling this function. */
1514 store_pending_inline (decl, t)
1516 struct pending_inline *t;
1519 DECL_PENDING_INLINE_INFO (decl) = t;
1520 DECL_PENDING_INLINE_P (decl) = 1;
1522 /* Because we use obstacks, we must process these in precise order. */
1523 t->next = pending_inlines;
1524 pending_inlines = t;
1528 reinit_parse_for_method (yychar, decl)
1533 int starting_lineno = lineno;
1534 char *starting_filename = input_filename;
1536 reinit_parse_for_block (yychar, &inline_text_obstack);
1538 len = obstack_object_size (&inline_text_obstack);
1539 if (decl == void_type_node
1540 || (current_class_type && TYPE_REDEFINED (current_class_type)))
1542 /* Happens when we get two declarations of the same
1543 function in the same scope. */
1544 char *buf = obstack_finish (&inline_text_obstack);
1545 obstack_free (&inline_text_obstack, buf);
1550 struct pending_inline *t;
1551 char *buf = obstack_finish (&inline_text_obstack);
1553 t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1554 sizeof (struct pending_inline));
1555 t->lineno = starting_lineno;
1556 t->filename = starting_filename;
1563 if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
1564 warn_if_unknown_interface (decl);
1566 t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1567 store_pending_inline (decl, t);
1571 /* Consume a block -- actually, a method beginning
1572 with `:' or `{' -- and save it away on the specified obstack. */
1575 reinit_parse_for_block (pyychar, obstackp)
1577 struct obstack *obstackp;
1581 int starting_lineno = lineno;
1582 char *starting_filename = input_filename;
1584 int look_for_semicolon = 0;
1585 int look_for_lbrac = 0;
1589 obstack_1grow (obstackp, '{');
1590 /* We incremented indent_level in yylex; undo that. */
1593 else if (pyychar == '=')
1594 look_for_semicolon = 1;
1595 else if (pyychar == ':')
1597 obstack_1grow (obstackp, pyychar);
1598 /* Add a space so we don't get confused by ': ::A(20)'. */
1599 obstack_1grow (obstackp, ' ');
1603 else if (pyychar == RETURN_KEYWORD)
1605 obstack_grow (obstackp, "return", 6);
1609 else if (pyychar == TRY)
1611 obstack_grow (obstackp, "try", 3);
1617 yyerror ("parse error in method specification");
1618 obstack_1grow (obstackp, '{');
1625 int this_lineno = lineno;
1627 saving_parse_to_obstack = 1;
1628 c = skip_white_space (c);
1629 saving_parse_to_obstack = 0;
1631 /* Don't lose our cool if there are lots of comments. */
1632 if (lineno == this_lineno + 1)
1633 obstack_1grow (obstackp, '\n');
1634 else if (lineno == this_lineno)
1636 else if (lineno - this_lineno < 10)
1639 for (i = lineno - this_lineno; i > 0; i--)
1640 obstack_1grow (obstackp, '\n');
1645 sprintf (buf, "\n# %d \"", lineno);
1647 obstack_grow (obstackp, buf, len);
1649 len = strlen (input_filename);
1650 obstack_grow (obstackp, input_filename, len);
1651 obstack_1grow (obstackp, '\"');
1652 obstack_1grow (obstackp, '\n');
1655 while (c > ' ') /* ASCII dependent... */
1657 obstack_1grow (obstackp, c);
1666 if (blev == 0 && !look_for_semicolon)
1670 if (peekyylex () == CATCH)
1673 obstack_grow (obstackp, " catch ", 7);
1690 /* Don't act on the next character...e.g, doing an escaped
1695 error_with_file_and_line (starting_filename,
1697 "end of file read inside definition");
1700 obstack_1grow (obstackp, c);
1703 consume_string (obstackp, c);
1705 consume_string (obstackp, c);
1710 error ("function body for constructor missing");
1711 obstack_1grow (obstackp, '{');
1712 obstack_1grow (obstackp, '}');
1716 else if (look_for_semicolon && blev == 0)
1724 error_with_file_and_line (starting_filename,
1726 "end of file read inside definition");
1731 obstack_1grow (obstackp, c);
1736 obstack_1grow (obstackp, '\0');
1739 /* Consume a no-commas expression -- actually, a default argument -- and
1740 save it away on the specified obstack. */
1743 reinit_parse_for_expr (obstackp)
1744 struct obstack *obstackp;
1747 int starting_lineno = lineno;
1748 char *starting_filename = input_filename;
1756 int this_lineno = lineno;
1758 saving_parse_to_obstack = 1;
1759 c = skip_white_space (c);
1760 saving_parse_to_obstack = 0;
1762 /* Don't lose our cool if there are lots of comments. */
1763 if (lineno == this_lineno + 1)
1764 obstack_1grow (obstackp, '\n');
1765 else if (lineno == this_lineno)
1767 else if (lineno - this_lineno < 10)
1770 for (i = lineno - this_lineno; i > 0; --i)
1771 obstack_1grow (obstackp, '\n');
1776 sprintf (buf, "\n# %d \"", lineno);
1778 obstack_grow (obstackp, buf, len);
1780 len = strlen (input_filename);
1781 obstack_grow (obstackp, input_filename, len);
1782 obstack_1grow (obstackp, '\"');
1783 obstack_1grow (obstackp, '\n');
1786 while (c > ' ') /* ASCII dependent... */
1788 if (plev <= 0 && (c == ')' || c == ','))
1793 obstack_1grow (obstackp, c);
1794 if (c == '(' || c == '[')
1796 else if (c == ']' || c == ')')
1800 /* Don't act on the next character...e.g, doing an escaped
1805 error_with_file_and_line (starting_filename,
1807 "end of file read inside definition");
1810 obstack_1grow (obstackp, c);
1813 consume_string (obstackp, c);
1815 consume_string (obstackp, c);
1821 error_with_file_and_line (starting_filename,
1823 "end of file read inside definition");
1828 obstack_1grow (obstackp, c);
1833 obstack_1grow (obstackp, '\0');
1836 int do_snarf_defarg;
1838 /* Decide whether the default argument we are about to see should be
1839 gobbled up as text for later parsing. */
1842 maybe_snarf_defarg ()
1844 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
1845 do_snarf_defarg = 1;
1855 reinit_parse_for_expr (&inline_text_obstack);
1856 len = obstack_object_size (&inline_text_obstack);
1857 buf = obstack_finish (&inline_text_obstack);
1859 arg = make_node (DEFAULT_ARG);
1860 DEFARG_LENGTH (arg) = len - 1;
1861 DEFARG_POINTER (arg) = buf;
1866 /* Called from grokfndecl to note a function decl with unparsed default
1867 arguments for later processing. Also called from grokdeclarator
1868 for function types with unparsed defargs; the call from grokfndecl
1869 will always come second, so we can overwrite the entry from the type. */
1872 add_defarg_fn (decl)
1875 if (TREE_CODE (decl) == FUNCTION_DECL)
1876 TREE_VALUE (defarg_fns) = decl;
1878 defarg_fns = tree_cons (current_class_type, decl, defarg_fns);
1881 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1887 tree d = TREE_PURPOSE (p);
1890 if (TREE_CODE (f) == FUNCTION_DECL)
1892 line = DECL_SOURCE_LINE (f);
1893 file = DECL_SOURCE_FILE (f);
1898 file = input_filename;
1901 feed_input (DEFARG_POINTER (d), DEFARG_LENGTH (d), file, line);
1902 yychar = DEFARG_MARKER;
1906 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1911 if (yychar == YYEMPTY)
1913 if (yychar != END_OF_SAVED_INPUT)
1915 error ("parse error at end of saved function text");
1917 /* restore_pending_input will abort unless yychar is either
1918 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1919 hosed, feed back YYEMPTY. */
1925 /* Main function for deferred parsing of default arguments. Called from
1929 do_pending_defargs ()
1934 for (; defarg_fns; defarg_fns = TREE_CHAIN (defarg_fns))
1936 tree defarg_fn = TREE_VALUE (defarg_fns);
1937 if (defarg_parm == NULL_TREE)
1939 push_nested_class (TREE_PURPOSE (defarg_fns), 1);
1941 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1942 maybe_begin_member_template_processing (defarg_fn);
1944 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1948 for (p = DECL_ARGUMENTS (defarg_fn); p; p = TREE_CHAIN (p))
1949 pushdecl (copy_node (p));
1951 defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
1954 defarg_parm = TYPE_ARG_TYPES (defarg_fn);
1957 defarg_parm = TREE_CHAIN (defarg_parm);
1959 for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
1960 if (TREE_PURPOSE (defarg_parm)
1961 && TREE_CODE (TREE_PURPOSE (defarg_parm)) == DEFAULT_ARG)
1963 feed_defarg (defarg_fn, defarg_parm);
1965 /* Return to the parser, which will process this defarg
1966 and call us again. */
1970 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1972 maybe_end_member_template_processing ();
1973 check_default_args (defarg_fn);
1977 pop_nested_class ();
1981 /* Heuristic to tell whether the user is missing a semicolon
1982 after a struct or enum declaration. Emit an error message
1983 if we know the user has blown it. */
1986 check_for_missing_semicolon (type)
1994 && yychar != IDENTIFIER
1995 && yychar != TYPENAME
1996 && yychar != CV_QUALIFIER
1997 && yychar != SELFNAME)
2000 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2001 error ("semicolon missing after %s declaration",
2002 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2004 cp_error ("semicolon missing after declaration of `%T'", type);
2005 shadow_tag (build_tree_list (0, type));
2007 /* Could probably also hack cases where class { ... } f (); appears. */
2012 note_got_semicolon (type)
2016 my_friendly_abort (60);
2017 if (CLASS_TYPE_P (type))
2018 CLASSTYPE_GOT_SEMICOLON (type) = 1;
2022 note_list_got_semicolon (declspecs)
2027 for (link = declspecs; link; link = TREE_CHAIN (link))
2029 tree type = TREE_VALUE (link);
2031 note_got_semicolon (type);
2036 /* Iff C is a carriage return, warn about it - if appropriate -
2037 and return nonzero. */
2042 static int newline_warning = 0;
2046 /* ANSI C says the effects of a carriage return in a source file
2048 if (pedantic && !newline_warning)
2050 warning ("carriage return in source file (we only warn about the first carriage return)");
2051 newline_warning = 1;
2058 /* If C is not whitespace, return C.
2059 Otherwise skip whitespace and return first nonwhite char read. */
2062 skip_white_space (c)
2069 /* We don't recognize comments here, because
2070 cpp output can include / and * consecutively as operators.
2071 Also, there's no need, since cpp removes all comments. */
2079 c = check_newline ();
2088 /* While processing a # directive we don't get CPP_HSPACE
2089 tokens, so we also need to handle whitespace the normal way. */
2090 if (cpp_token == CPP_HSPACE)
2091 c = yy_get_token ();
2114 error ("stray '\\' in program");
2123 /* Make the token buffer longer, preserving the data in it.
2124 P should point to just beyond the last valid character in the old buffer.
2125 The value we return is a pointer to the new buffer
2126 at a place corresponding to P. */
2129 extend_token_buffer_to (size)
2133 maxtoken = maxtoken * 2 + 10;
2134 while (maxtoken < size);
2135 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2139 extend_token_buffer (p)
2142 int offset = p - token_buffer;
2143 extend_token_buffer_to (offset);
2144 return token_buffer + offset;
2147 #if defined HANDLE_PRAGMA
2148 /* Local versions of these macros, that can be passed as function pointers. */
2164 read_line_number (num)
2167 register int token = real_yylex ();
2169 if (token == CONSTANT
2170 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2172 *num = TREE_INT_CST_LOW (yylval.ttype);
2177 if (token != END_OF_LINE)
2178 error ("invalid #-line");
2183 /* At the beginning of a line, increment the line number
2184 and process any #-directive on this line.
2185 If the line is a #-directive, read the entire line and return a newline.
2186 Otherwise, return the line's first non-whitespace character.
2188 Note that in the case of USE_CPPLIB, we get the whole line as one
2189 CPP_DIRECTIVE token. */
2197 enum { act_none, act_push, act_pop } action;
2198 int action_number, l;
2199 int entering_c_header;
2203 /* Read first nonwhite char on the line. Do this before incrementing the
2204 line number, in case we're at the end of saved text. */
2208 /* In some cases where we're leaving an include file, we can get multiple
2209 CPP_HSPACE tokens in a row, so we need to loop. */
2210 while (cpp_token == CPP_HSPACE)
2211 c = yy_get_token ();
2215 while (c == ' ' || c == '\t');
2222 /* Sequences of multiple newlines are very common; optimize them. */
2226 /* If not #, return it so caller will use it. */
2230 /* Don't read beyond this line. */
2235 if (cpp_token == CPP_VSPACE)
2237 /* Format is "<space> <line number> <filename> <newline>".
2238 Only the line number is interesting, and even that
2239 we can get more efficiently than scanning the line. */
2240 yy_cur = yy_lim - 1;
2241 lineno = parse_in.lineno - 1;
2246 token = real_yylex ();
2248 if (token == IDENTIFIER)
2250 /* If a letter follows, then if the word here is `line', skip
2251 it and ignore it; otherwise, ignore the line, with an error
2252 if the word isn't `pragma'. */
2254 const char *name = IDENTIFIER_POINTER (yylval.ttype);
2256 if (!strcmp (name, "pragma"))
2258 token = real_yylex ();
2259 if (token != IDENTIFIER
2260 || TREE_CODE (yylval.ttype) != IDENTIFIER_NODE)
2263 /* If this is 1, we handled it; if it's -1, it was one we
2264 wanted but had something wrong with it. Only if it's
2265 0 was it not handled. */
2266 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval.ttype)))
2269 #ifdef HANDLE_PRAGMA
2270 /* We invoke HANDLE_PRAGMA before HANDLE_GENERIC_PRAGMAS
2271 (if both are defined), in order to give the back
2272 end a chance to override the interpretation of
2273 SYSV style pragmas. */
2274 if (HANDLE_PRAGMA (pragma_getc, pragma_ungetc,
2275 IDENTIFIER_POINTER (yylval.ttype)))
2277 #endif /* HANDLE_PRAGMA */
2279 #ifdef HANDLE_GENERIC_PRAGMAS
2280 if (handle_generic_pragma (token))
2282 #endif /* HANDLE_GENERIC_PRAGMAS */
2284 /* Issue a warning message if we have been asked to do so.
2285 Ignoring unknown pragmas in system header file unless
2286 an explcit -Wunknown-pragmas has been given. */
2287 if (warn_unknown_pragmas > 1
2288 || (warn_unknown_pragmas && ! in_system_header))
2289 warning ("ignoring pragma: %s", token_buffer);
2293 else if (!strcmp (name, "define"))
2295 debug_define (lineno, GET_DIRECTIVE_LINE ());
2298 else if (!strcmp (name, "undef"))
2300 debug_undef (lineno, GET_DIRECTIVE_LINE ());
2303 else if (!strcmp (name, "line"))
2306 token = real_yylex ();
2309 else if (!strcmp (name, "ident"))
2311 /* #ident. The pedantic warning is now in cccp.c. */
2313 /* Here we have just seen `#ident '.
2314 A string constant should follow. */
2316 token = real_yylex ();
2317 if (token == END_OF_LINE)
2320 || TREE_CODE (yylval.ttype) != STRING_CST)
2322 error ("invalid #ident");
2326 if (! flag_no_ident)
2328 #ifdef ASM_OUTPUT_IDENT
2329 ASM_OUTPUT_IDENT (asm_out_file,
2330 TREE_STRING_POINTER (yylval.ttype));
2334 /* Skip the rest of this line. */
2338 error ("undefined or invalid # directive `%s'", name);
2342 /* If the # is the only nonwhite char on the line,
2343 just ignore it. Check the new newline. */
2344 if (token == END_OF_LINE)
2348 /* Here we have either `#line' or `# <nonletter>'.
2349 In either case, it should be a line number; a digit should follow. */
2351 if (token != CONSTANT
2352 || TREE_CODE (yylval.ttype) != INTEGER_CST)
2354 error ("invalid #-line");
2358 /* subtract one, because it is the following line that
2359 gets the specified number */
2361 l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2363 /* More follows: it must be a string constant (filename).
2364 It would be neat to use cpplib to quickly process the string, but
2365 (1) we don't have a handy tokenization of the string, and
2366 (2) I don't know how well that would work in the presense
2367 of filenames that contain wide characters. */
2369 if (saw_line || saving_parse_to_obstack)
2371 /* Don't treat \ as special if we are processing #line 1 "...".
2372 If you want it to be treated specially, use # 1 "...". Also
2373 ignore these if saving to an obstack for later parsing. */
2374 ignore_escape_flag = 1;
2377 /* Read the string constant. */
2378 token = real_yylex ();
2380 ignore_escape_flag = 0;
2382 if (token == END_OF_LINE)
2384 /* No more: store the line number and check following line. */
2389 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2391 error ("invalid #line");
2395 /* Changing files again. This means currently collected time
2396 is charged against header time, and body time starts back at 0. */
2397 if (flag_detailed_statistics)
2399 int this_time = my_get_run_time ();
2400 tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2401 header_time += this_time - body_time;
2402 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time))
2403 += this_time - body_time;
2404 this_filename_time = time_identifier;
2405 body_time = this_time;
2408 new_file = TREE_STRING_POINTER (yylval.ttype);
2410 GNU_xref_file (new_file);
2412 if (main_input_filename == 0)
2414 struct impl_files *ifiles = impl_file_chain;
2418 while (ifiles->next)
2419 ifiles = ifiles->next;
2420 ifiles->filename = file_name_nondirectory (new_file);
2423 main_input_filename = new_file;
2429 /* Each change of file name
2430 reinitializes whether we are now in a system header. */
2431 in_system_header = 0;
2432 entering_c_header = 0;
2434 if (!read_line_number (&action_number) && input_file_stack)
2436 input_file_stack->name = input_filename = new_file;
2437 input_file_stack->line = lineno = l;
2440 /* `1' after file name means entering new file.
2441 `2' after file name means just left a file. */
2443 if (action_number == 1)
2446 read_line_number (&action_number);
2448 else if (action_number == 2)
2451 read_line_number (&action_number);
2453 if (action_number == 3)
2455 /* `3' after file name means this is a system header file. */
2456 in_system_header = 1;
2457 read_line_number (&action_number);
2459 if (action_number == 4)
2461 /* `4' after file name means this is a C header file. */
2462 entering_c_header = 1;
2463 read_line_number (&action_number);
2466 /* Do the actions implied by the preceding numbers. */
2468 if (action == act_push)
2470 /* Pushing to a new file. */
2471 push_srcloc (new_file, l);
2472 input_file_stack->indent_level = indent_level;
2473 debug_start_source_file (input_filename);
2476 else if (entering_c_header)
2479 ++pending_lang_change;
2482 else if (action == act_pop)
2484 /* Popping out of a file. */
2485 if (input_file_stack->next)
2487 if (c_header_level && --c_header_level == 0)
2489 if (entering_c_header)
2490 warning ("badly nested C headers from preprocessor");
2491 --pending_lang_change;
2494 if (indent_level != input_file_stack->indent_level)
2496 warning_with_file_and_line
2497 (input_filename, lineno,
2498 "This file contains more `%c's than `%c's.",
2499 indent_level > input_file_stack->indent_level ? '{' : '}',
2500 indent_level > input_file_stack->indent_level ? '}' : '{');
2504 input_file_stack->name = new_file;
2505 debug_end_source_file (input_file_stack->line);
2508 error ("#-lines for entering and leaving files don't match");
2511 input_filename = new_file;
2514 extract_interface_info ();
2516 /* skip the rest of this line. */
2523 while (c != '\n' && c != EOF);
2527 #ifdef HANDLE_GENERIC_PRAGMAS
2529 /* Handle a #pragma directive.
2530 TOKEN is the token we read after `#pragma'. Processes the entire input
2531 line and return non-zero iff the pragma has been successfully parsed. */
2533 /* This function has to be in this file, in order to get at
2537 handle_generic_pragma (token)
2548 handle_pragma_token (token_buffer, yylval.ttype);
2552 handle_pragma_token ("(", NULL_TREE);
2553 handle_pragma_token (")", NULL_TREE);
2557 return handle_pragma_token (NULL_PTR, NULL_TREE);
2560 handle_pragma_token (token_buffer, NULL_TREE);
2563 token = real_yylex ();
2566 #endif /* HANDLE_GENERIC_PRAGMAS */
2569 handle_cp_pragma (pname)
2574 if (! strcmp (pname, "vtable"))
2576 /* More follows: it must be a string constant (class name). */
2577 token = real_yylex ();
2578 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2580 error ("invalid #pragma vtable");
2585 = tree_cons (NULL_TREE,
2586 get_identifier (TREE_STRING_POINTER (yylval.ttype)),
2588 token = real_yylex ();
2589 if (token != END_OF_LINE)
2590 warning ("trailing characters ignored");
2593 else if (! strcmp (pname, "unit"))
2595 /* More follows: it must be a string constant (unit name). */
2596 token = real_yylex ();
2597 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2599 error ("invalid #pragma unit");
2602 token = real_yylex ();
2603 if (token != END_OF_LINE)
2604 warning ("trailing characters ignored");
2607 else if (! strcmp (pname, "interface"))
2609 char *main_filename = input_filename;
2611 main_filename = file_name_nondirectory (main_filename);
2613 token = real_yylex ();
2615 if (token != END_OF_LINE)
2618 || TREE_CODE (yylval.ttype) != STRING_CST)
2620 error ("invalid `#pragma interface'");
2623 main_filename = TREE_STRING_POINTER (yylval.ttype);
2624 token = real_yylex ();
2627 if (token != END_OF_LINE)
2628 warning ("garbage after `#pragma interface' ignored");
2630 cp_pragma_interface (main_filename);
2634 else if (! strcmp (pname, "implementation"))
2636 char *main_filename = main_input_filename ? main_input_filename : input_filename;
2638 main_filename = file_name_nondirectory (main_filename);
2640 token = real_yylex ();
2642 if (token != END_OF_LINE)
2645 || TREE_CODE (yylval.ttype) != STRING_CST)
2647 error ("invalid `#pragma implementation'");
2650 main_filename = TREE_STRING_POINTER (yylval.ttype);
2651 token = real_yylex ();
2654 if (token != END_OF_LINE)
2655 warning ("garbage after `#pragma implementation' ignored");
2657 cp_pragma_implementation (main_filename);
2666 do_pending_lang_change ()
2668 for (; pending_lang_change > 0; --pending_lang_change)
2669 push_lang_context (lang_name_c);
2670 for (; pending_lang_change < 0; ++pending_lang_change)
2671 pop_lang_context ();
2674 /* Parse a '\uNNNN' or '\UNNNNNNNN' sequence.
2676 [lex.charset]: The character designated by the universal-character-name
2677 \UNNNNNNNN is that character whose character short name in ISO/IEC 10646
2678 is NNNNNNNN; the character designated by the universal-character-name
2679 \uNNNN is that character whose character short name in ISO/IEC 10646 is
2680 0000NNNN. If the hexadecimal value for a universal character name is
2681 less than 0x20 or in the range 0x7F-0x9F (inclusive), or if the
2682 universal character name designates a character in the basic source
2683 character set, then the program is ill-formed.
2685 We assume that wchar_t is Unicode, so we don't need to do any
2686 mapping. Is this ever wrong? */
2692 unsigned int code = 0;
2695 for (; length; --length)
2700 error ("non hex digit '%c' in universal-character-name", c);
2705 if (c >= 'a' && c <= 'f')
2706 code += c - 'a' + 10;
2707 if (c >= 'A' && c <= 'F')
2708 code += c - 'A' + 10;
2709 if (c >= '0' && c <= '9')
2713 #ifdef TARGET_EBCDIC
2714 sorry ("universal-character-name on EBCDIC target");
2718 if (code > 0x9f && !(code & 0x80000000))
2719 /* True extended character, OK. */;
2720 else if (code >= 0x20 && code < 0x7f)
2722 /* ASCII printable character. The C character set consists of all of
2723 these except $, @ and `. We use hex escapes so that this also
2724 works with EBCDIC hosts. */
2725 if (code != 0x24 && code != 0x40 && code != 0x60)
2726 error ("universal-character-name designates `%c', part of the basic source character set", code);
2729 error ("invalid universal-character-name");
2733 /* Returns nonzero if C is a universal-character-name. Give an error if it
2734 is not one which may appear in an identifier, as per [extendid]. */
2737 is_extended_char (c)
2740 #ifdef TARGET_EBCDIC
2747 return is_extended_char_1 (c);
2752 is_extended_char_1 (c)
2755 /* None of the valid chars are outside the Basic Multilingual Plane (the
2759 error ("universal-character-name `\\U%08x' not valid in identifier", c);
2764 if ((c >= 0x00c0 && c <= 0x00d6)
2765 || (c >= 0x00d8 && c <= 0x00f6)
2766 || (c >= 0x00f8 && c <= 0x01f5)
2767 || (c >= 0x01fa && c <= 0x0217)
2768 || (c >= 0x0250 && c <= 0x02a8)
2769 || (c >= 0x1e00 && c <= 0x1e9a)
2770 || (c >= 0x1ea0 && c <= 0x1ef9))
2775 || (c >= 0x0388 && c <= 0x038a)
2777 || (c >= 0x038e && c <= 0x03a1)
2778 || (c >= 0x03a3 && c <= 0x03ce)
2779 || (c >= 0x03d0 && c <= 0x03d6)
2784 || (c >= 0x03e2 && c <= 0x03f3)
2785 || (c >= 0x1f00 && c <= 0x1f15)
2786 || (c >= 0x1f18 && c <= 0x1f1d)
2787 || (c >= 0x1f20 && c <= 0x1f45)
2788 || (c >= 0x1f48 && c <= 0x1f4d)
2789 || (c >= 0x1f50 && c <= 0x1f57)
2793 || (c >= 0x1f5f && c <= 0x1f7d)
2794 || (c >= 0x1f80 && c <= 0x1fb4)
2795 || (c >= 0x1fb6 && c <= 0x1fbc)
2796 || (c >= 0x1fc2 && c <= 0x1fc4)
2797 || (c >= 0x1fc6 && c <= 0x1fcc)
2798 || (c >= 0x1fd0 && c <= 0x1fd3)
2799 || (c >= 0x1fd6 && c <= 0x1fdb)
2800 || (c >= 0x1fe0 && c <= 0x1fec)
2801 || (c >= 0x1ff2 && c <= 0x1ff4)
2802 || (c >= 0x1ff6 && c <= 0x1ffc))
2806 if ((c >= 0x0401 && c <= 0x040d)
2807 || (c >= 0x040f && c <= 0x044f)
2808 || (c >= 0x0451 && c <= 0x045c)
2809 || (c >= 0x045e && c <= 0x0481)
2810 || (c >= 0x0490 && c <= 0x04c4)
2811 || (c >= 0x04c7 && c <= 0x04c8)
2812 || (c >= 0x04cb && c <= 0x04cc)
2813 || (c >= 0x04d0 && c <= 0x04eb)
2814 || (c >= 0x04ee && c <= 0x04f5)
2815 || (c >= 0x04f8 && c <= 0x04f9))
2819 if ((c >= 0x0531 && c <= 0x0556)
2820 || (c >= 0x0561 && c <= 0x0587))
2824 if ((c >= 0x05d0 && c <= 0x05ea)
2825 || (c >= 0x05f0 && c <= 0x05f4))
2829 if ((c >= 0x0621 && c <= 0x063a)
2830 || (c >= 0x0640 && c <= 0x0652)
2831 || (c >= 0x0670 && c <= 0x06b7)
2832 || (c >= 0x06ba && c <= 0x06be)
2833 || (c >= 0x06c0 && c <= 0x06ce)
2834 || (c >= 0x06e5 && c <= 0x06e7))
2838 if ((c >= 0x0905 && c <= 0x0939)
2839 || (c >= 0x0958 && c <= 0x0962))
2843 if ((c >= 0x0985 && c <= 0x098c)
2844 || (c >= 0x098f && c <= 0x0990)
2845 || (c >= 0x0993 && c <= 0x09a8)
2846 || (c >= 0x09aa && c <= 0x09b0)
2848 || (c >= 0x09b6 && c <= 0x09b9)
2849 || (c >= 0x09dc && c <= 0x09dd)
2850 || (c >= 0x09df && c <= 0x09e1)
2851 || (c >= 0x09f0 && c <= 0x09f1))
2855 if ((c >= 0x0a05 && c <= 0x0a0a)
2856 || (c >= 0x0a0f && c <= 0x0a10)
2857 || (c >= 0x0a13 && c <= 0x0a28)
2858 || (c >= 0x0a2a && c <= 0x0a30)
2859 || (c >= 0x0a32 && c <= 0x0a33)
2860 || (c >= 0x0a35 && c <= 0x0a36)
2861 || (c >= 0x0a38 && c <= 0x0a39)
2862 || (c >= 0x0a59 && c <= 0x0a5c)
2867 if ((c >= 0x0a85 && c <= 0x0a8b)
2869 || (c >= 0x0a8f && c <= 0x0a91)
2870 || (c >= 0x0a93 && c <= 0x0aa8)
2871 || (c >= 0x0aaa && c <= 0x0ab0)
2872 || (c >= 0x0ab2 && c <= 0x0ab3)
2873 || (c >= 0x0ab5 && c <= 0x0ab9)
2878 if ((c >= 0x0b05 && c <= 0x0b0c)
2879 || (c >= 0x0b0f && c <= 0x0b10)
2880 || (c >= 0x0b13 && c <= 0x0b28)
2881 || (c >= 0x0b2a && c <= 0x0b30)
2882 || (c >= 0x0b32 && c <= 0x0b33)
2883 || (c >= 0x0b36 && c <= 0x0b39)
2884 || (c >= 0x0b5c && c <= 0x0b5d)
2885 || (c >= 0x0b5f && c <= 0x0b61))
2889 if ((c >= 0x0b85 && c <= 0x0b8a)
2890 || (c >= 0x0b8e && c <= 0x0b90)
2891 || (c >= 0x0b92 && c <= 0x0b95)
2892 || (c >= 0x0b99 && c <= 0x0b9a)
2894 || (c >= 0x0b9e && c <= 0x0b9f)
2895 || (c >= 0x0ba3 && c <= 0x0ba4)
2896 || (c >= 0x0ba8 && c <= 0x0baa)
2897 || (c >= 0x0bae && c <= 0x0bb5)
2898 || (c >= 0x0bb7 && c <= 0x0bb9))
2902 if ((c >= 0x0c05 && c <= 0x0c0c)
2903 || (c >= 0x0c0e && c <= 0x0c10)
2904 || (c >= 0x0c12 && c <= 0x0c28)
2905 || (c >= 0x0c2a && c <= 0x0c33)
2906 || (c >= 0x0c35 && c <= 0x0c39)
2907 || (c >= 0x0c60 && c <= 0x0c61))
2911 if ((c >= 0x0c85 && c <= 0x0c8c)
2912 || (c >= 0x0c8e && c <= 0x0c90)
2913 || (c >= 0x0c92 && c <= 0x0ca8)
2914 || (c >= 0x0caa && c <= 0x0cb3)
2915 || (c >= 0x0cb5 && c <= 0x0cb9)
2916 || (c >= 0x0ce0 && c <= 0x0ce1))
2920 if ((c >= 0x0d05 && c <= 0x0d0c)
2921 || (c >= 0x0d0e && c <= 0x0d10)
2922 || (c >= 0x0d12 && c <= 0x0d28)
2923 || (c >= 0x0d2a && c <= 0x0d39)
2924 || (c >= 0x0d60 && c <= 0x0d61))
2928 if ((c >= 0x0e01 && c <= 0x0e30)
2929 || (c >= 0x0e32 && c <= 0x0e33)
2930 || (c >= 0x0e40 && c <= 0x0e46)
2931 || (c >= 0x0e4f && c <= 0x0e5b))
2935 if ((c >= 0x0e81 && c <= 0x0e82)
2941 || (c >= 0x0e94 && c <= 0x0e97)
2942 || (c >= 0x0e99 && c <= 0x0e9f)
2943 || (c >= 0x0ea1 && c <= 0x0ea3)
2948 || (c >= 0x0ead && c <= 0x0eb0)
2952 || (c >= 0x0ec0 && c <= 0x0ec4)
2957 if ((c >= 0x10a0 && c <= 0x10c5)
2958 || (c >= 0x10d0 && c <= 0x10f6))
2962 if ((c >= 0x3041 && c <= 0x3094)
2963 || (c >= 0x309b && c <= 0x309e))
2967 if ((c >= 0x30a1 && c <= 0x30fe))
2971 if ((c >= 0x3105 && c <= 0x312c))
2975 if ((c >= 0x1100 && c <= 0x1159)
2976 || (c >= 0x1161 && c <= 0x11a2)
2977 || (c >= 0x11a8 && c <= 0x11f9))
2980 /* CJK Unified Ideographs */
2981 if ((c >= 0xf900 && c <= 0xfa2d)
2982 || (c >= 0xfb1f && c <= 0xfb36)
2983 || (c >= 0xfb38 && c <= 0xfb3c)
2985 || (c >= 0xfb40 && c <= 0xfb41)
2986 || (c >= 0xfb42 && c <= 0xfb44)
2987 || (c >= 0xfb46 && c <= 0xfbb1)
2988 || (c >= 0xfbd3 && c <= 0xfd3f)
2989 || (c >= 0xfd50 && c <= 0xfd8f)
2990 || (c >= 0xfd92 && c <= 0xfdc7)
2991 || (c >= 0xfdf0 && c <= 0xfdfb)
2992 || (c >= 0xfe70 && c <= 0xfe72)
2994 || (c >= 0xfe76 && c <= 0xfefc)
2995 || (c >= 0xff21 && c <= 0xff3a)
2996 || (c >= 0xff41 && c <= 0xff5a)
2997 || (c >= 0xff66 && c <= 0xffbe)
2998 || (c >= 0xffc2 && c <= 0xffc7)
2999 || (c >= 0xffca && c <= 0xffcf)
3000 || (c >= 0xffd2 && c <= 0xffd7)
3001 || (c >= 0xffda && c <= 0xffdc)
3002 || (c >= 0x4e00 && c <= 0x9fa5))
3005 error ("universal-character-name `\\u%04x' not valid in identifier", c);
3010 /* Add the UTF-8 representation of C to the token_buffer. */
3013 utf8_extend_token (c)
3018 if (c <= 0x0000007f)
3023 else if (c <= 0x000007ff)
3024 shift = 6, mask = 0xc0;
3025 else if (c <= 0x0000ffff)
3026 shift = 12, mask = 0xe0;
3027 else if (c <= 0x001fffff)
3028 shift = 18, mask = 0xf0;
3029 else if (c <= 0x03ffffff)
3030 shift = 24, mask = 0xf8;
3032 shift = 30, mask = 0xfc;
3034 extend_token (mask | (c >> shift));
3038 extend_token ((unsigned char) (0x80 | (c >> shift)));
3044 #define ENDFILE -1 /* token that represents end-of-file */
3046 /* Read an escape sequence, returning its equivalent as a character,
3047 or store 1 in *ignore_ptr if it is backslash-newline. */
3050 readescape (ignore_ptr)
3053 register int c = getch ();
3055 register unsigned count;
3056 unsigned firstdig = 0;
3074 if (c >= 'a' && c <= 'f')
3075 code += c - 'a' + 10;
3076 if (c >= 'A' && c <= 'F')
3077 code += c - 'A' + 10;
3078 if (c >= '0' && c <= '9')
3080 if (code != 0 || count != 0)
3089 error ("\\x used with no following hex digits");
3090 else if (count == 0)
3091 /* Digits are all 0's. Ok. */
3093 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
3096 << (TYPE_PRECISION (integer_type_node)
3099 pedwarn ("hex escape out of range");
3102 case '0': case '1': case '2': case '3': case '4':
3103 case '5': case '6': case '7':
3106 while ((c <= '7') && (c >= '0') && (count++ < 3))
3108 code = (code * 8) + (c - '0');
3115 return read_ucs (8);
3117 return read_ucs (4);
3119 case '\\': case '\'': case '"':
3128 return TARGET_NEWLINE;
3151 pedwarn ("non-ISO-standard escape sequence, `\\%c'", c);
3157 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
3161 /* `\%' is used to prevent SCCS from getting confused. */
3164 pedwarn ("unknown escape sequence `\\%c'", c);
3168 pedwarn ("unknown escape sequence `\\%c'", c);
3170 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
3178 extern int end_of_file;
3180 /* We can't print string and character constants well
3181 because the token_buffer contains the result of processing escapes. */
3184 if (input_redirected ())
3185 error ("%s at end of saved text", string);
3187 error ("%s at end of input", string);
3189 else if (token_buffer[0] == 0)
3190 error ("%s at null character", string);
3191 else if (token_buffer[0] == '"')
3192 error ("%s before string constant", string);
3193 else if (token_buffer[0] == '\'')
3194 error ("%s before character constant", string);
3195 else if (!ISGRAPH ((unsigned char)token_buffer[0]))
3196 error ("%s before character 0%o", string, (unsigned char) token_buffer[0]);
3198 error ("%s before `%s'", string, token_buffer);
3201 /* Value is 1 (or 2) if we should try to make the next identifier look like
3202 a typename (when it may be a local variable or a class variable).
3203 Value is 0 if we treat this name in a default fashion. */
3204 int looking_for_typename;
3207 identifier_type (decl)
3212 if (TREE_CODE (decl) == TEMPLATE_DECL)
3214 if (TREE_CODE (DECL_TEMPLATE_RESULT (decl)) == TYPE_DECL)
3216 else if (looking_for_template)
3219 if (looking_for_template && really_overloaded_fn (decl))
3221 /* See through a baselink. */
3222 if (TREE_CODE (decl) == TREE_LIST)
3223 decl = TREE_VALUE (decl);
3225 for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
3226 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
3229 if (TREE_CODE (decl) == NAMESPACE_DECL)
3231 if (TREE_CODE (decl) != TYPE_DECL)
3233 if (DECL_ARTIFICIAL (decl) && TREE_TYPE (decl) == current_class_type)
3236 /* A constructor declarator for a template type will get here as an
3237 implicit typename, a TYPENAME_TYPE with a type. */
3239 if (t && TREE_CODE (t) == TYPENAME_TYPE)
3241 decl = TREE_TYPE (decl);
3242 if (TREE_CODE (decl) == TYPENAME_TYPE)
3243 decl = TREE_TYPE (decl);
3253 /* Only types expected, not even namespaces. */
3254 looking_for_typename = 2;
3256 if ((yychar = yylex ()) < 0) yychar = 0;
3257 looking_for_typename = 0;
3258 if (yychar == IDENTIFIER)
3260 lastiddecl = lookup_name (yylval.ttype, -2);
3261 if (lastiddecl == 0)
3264 lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
3267 yychar = identifier_type (lastiddecl);
3271 /* Return true if d is in a global scope. */
3278 switch (TREE_CODE (d))
3283 case OVERLOAD: d = OVL_FUNCTION (d); continue;
3284 case TREE_LIST: d = TREE_VALUE (d); continue;
3286 my_friendly_assert (DECL_P (d), 980629);
3288 return DECL_NAMESPACE_SCOPE_P (d);
3293 do_identifier (token, parsing, args)
3294 register tree token;
3299 int lexing = (parsing == 1);
3300 int in_call = (parsing == 2);
3302 if (! lexing || IDENTIFIER_OPNAME_P (token))
3303 id = lookup_name (token, 0);
3307 /* Do Koenig lookup if appropriate (inside templates we build lookup
3308 expressions instead).
3310 [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
3311 finds the declaration of a class member function, the associated
3312 namespaces and classes are not considered. */
3314 if (args && !current_template_parms && (!id || is_global (id)))
3315 id = lookup_arg_dependent (token, id, args);
3317 /* Remember that this name has been used in the class definition, as per
3320 maybe_note_name_used_in_class (token, id);
3322 if (id == error_mark_node)
3324 /* lookup_name quietly returns error_mark_node if we're parsing,
3325 as we don't want to complain about an identifier that ends up
3326 being used as a declarator. So we call it again to get the error
3328 id = lookup_name (token, 0);
3329 return error_mark_node;
3334 if (current_template_parms)
3335 return build_min_nt (LOOKUP_EXPR, token);
3336 else if (IDENTIFIER_OPNAME_P (token))
3338 if (token != ansi_opname[ERROR_MARK])
3339 cp_error ("`%D' not defined", token);
3340 id = error_mark_node;
3342 else if (in_call && ! flag_strict_prototype)
3344 id = implicitly_declare (token);
3346 else if (current_function_decl == 0)
3348 cp_error ("`%D' was not declared in this scope", token);
3349 id = error_mark_node;
3353 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
3354 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
3356 static int undeclared_variable_notice;
3358 cp_error ("`%D' undeclared (first use this function)", token);
3360 if (! undeclared_variable_notice)
3362 error ("(Each undeclared identifier is reported only once for each function it appears in.)");
3363 undeclared_variable_notice = 1;
3366 id = error_mark_node;
3367 /* Prevent repeated error messages. */
3368 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3369 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
3373 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
3375 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
3376 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
3377 && DECL_DEAD_FOR_LOCAL (shadowed))
3378 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
3380 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
3383 if (!DECL_ERROR_REPORTED (id))
3385 warning ("name lookup of `%s' changed",
3386 IDENTIFIER_POINTER (token));
3387 cp_warning_at (" matches this `%D' under ISO standard rules",
3389 cp_warning_at (" matches this `%D' under old rules", id);
3390 DECL_ERROR_REPORTED (id) = 1;
3394 else if (!DECL_ERROR_REPORTED (id))
3396 DECL_ERROR_REPORTED (id) = 1;
3397 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (id)))
3399 error ("name lookup of `%s' changed for new ISO `for' scoping",
3400 IDENTIFIER_POINTER (token));
3401 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
3402 id = error_mark_node;
3406 pedwarn ("name lookup of `%s' changed for new ISO `for' scoping",
3407 IDENTIFIER_POINTER (token));
3408 cp_pedwarn_at (" using obsolete binding at `%D'", id);
3412 /* TREE_USED is set in `hack_identifier'. */
3413 if (TREE_CODE (id) == CONST_DECL)
3416 if (IDENTIFIER_CLASS_VALUE (token) == id)
3417 enforce_access (CP_DECL_CONTEXT(id), id);
3418 if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
3419 id = DECL_INITIAL (id);
3422 id = hack_identifier (id, token);
3424 /* We must look up dependent names when the template is
3425 instantiated, not while parsing it. For now, we don't
3426 distinguish between dependent and independent names. So, for
3427 example, we look up all overloaded functions at
3428 instantiation-time, even though in some cases we should just use
3429 the DECL we have here. We also use LOOKUP_EXPRs to find things
3430 like local variables, rather than creating TEMPLATE_DECLs for the
3431 local variables and then finding matching instantiations. */
3432 if (current_template_parms
3433 && (is_overloaded_fn (id)
3434 /* Some local VAR_DECLs (such as those for local variables
3435 in member functions of local classes) are built on the
3436 permanent obstack. */
3437 || (TREE_CODE (id) == VAR_DECL
3438 && CP_DECL_CONTEXT (id)
3439 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
3440 || TREE_CODE (id) == PARM_DECL
3441 || TREE_CODE (id) == RESULT_DECL
3442 || TREE_CODE (id) == USING_DECL))
3443 id = build_min_nt (LOOKUP_EXPR, token);
3449 do_scoped_id (token, parsing)
3454 /* during parsing, this is ::name. Otherwise, it is black magic. */
3457 id = make_node (CPLUS_BINDING);
3458 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
3461 id = BINDING_VALUE (id);
3464 id = IDENTIFIER_GLOBAL_VALUE (token);
3465 if (parsing && yychar == YYEMPTY)
3469 if (processing_template_decl)
3471 id = build_min_nt (LOOKUP_EXPR, token);
3472 LOOKUP_EXPR_GLOBAL (id) = 1;
3475 if (parsing && (yychar == '(' || yychar == LEFT_RIGHT)
3476 && ! flag_strict_prototype)
3477 id = implicitly_declare (token);
3480 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
3481 cp_error ("`::%D' undeclared (first use here)", token);
3482 id = error_mark_node;
3483 /* Prevent repeated error messages. */
3484 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3489 if (TREE_CODE (id) == ADDR_EXPR)
3490 mark_used (TREE_OPERAND (id, 0));
3491 else if (TREE_CODE (id) != OVERLOAD)
3494 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
3496 /* XXX CHS - should we set TREE_USED of the constant? */
3497 id = DECL_INITIAL (id);
3498 /* This is to prevent an enum whose value is 0
3499 from being considered a null pointer constant. */
3500 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
3501 TREE_CONSTANT (id) = 1;
3504 if (processing_template_decl)
3506 if (is_overloaded_fn (id))
3508 id = build_min_nt (LOOKUP_EXPR, token);
3509 LOOKUP_EXPR_GLOBAL (id) = 1;
3512 /* else just use the decl */
3514 return convert_from_reference (id);
3518 identifier_typedecl_value (node)
3522 type = IDENTIFIER_TYPE_VALUE (node);
3523 if (type == NULL_TREE)
3526 if (IDENTIFIER_BINDING (node))
3528 t = IDENTIFIER_VALUE (node);
3529 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
3532 if (IDENTIFIER_NAMESPACE_VALUE (node))
3534 t = IDENTIFIER_NAMESPACE_VALUE (node);
3535 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
3539 /* Will this one ever happen? */
3540 if (TYPE_MAIN_DECL (type))
3541 return TYPE_MAIN_DECL (type);
3543 /* We used to do an internal error of 62 here, but instead we will
3544 handle the return of a null appropriately in the callers. */
3558 int conversion_errno;
3559 REAL_VALUE_TYPE value;
3566 struct pf_args * args = (struct pf_args *) data;
3567 int fflag = 0, lflag = 0;
3568 /* Copy token_buffer now, while it has just the number
3569 and not the suffixes; once we add `f' or `i',
3570 REAL_VALUE_ATOF may not work any more. */
3571 char *copy = (char *) alloca (args->p - token_buffer + 1);
3572 bcopy (token_buffer, copy, args->p - token_buffer + 1);
3574 args->conversion_errno = 0;
3575 args->type = double_type_node;
3581 /* Read the suffixes to choose a data type. */
3586 error ("more than one `f' in numeric constant");
3592 error ("more than one `l' in numeric constant");
3598 error ("more than one `i' or `j' in numeric constant");
3600 pedwarn ("ISO C++ forbids imaginary numeric constants");
3611 if (args->p >= token_buffer + maxtoken - 3)
3612 args->p = extend_token_buffer (args->p);
3613 *(args->p++) = args->c;
3618 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3619 tells the desired precision of the binary result
3620 of decimal-to-binary conversion. */
3625 error ("both `f' and `l' in floating constant");
3627 args->type = float_type_node;
3629 if (args->base == 16)
3630 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
3632 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
3633 args->conversion_errno = errno;
3634 /* A diagnostic is required here by some ANSI C testsuites.
3635 This is not pedwarn, because some people don't want
3636 an error for this. */
3637 if (REAL_VALUE_ISINF (args->value) && pedantic)
3638 warning ("floating point number exceeds range of `float'");
3642 args->type = long_double_type_node;
3644 if (args->base == 16)
3645 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
3647 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
3648 args->conversion_errno = errno;
3649 if (REAL_VALUE_ISINF (args->value) && pedantic)
3650 warning ("floating point number exceeds range of `long double'");
3655 if (args->base == 16)
3656 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
3658 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
3659 args->conversion_errno = errno;
3660 if (REAL_VALUE_ISINF (args->value) && pedantic)
3661 warning ("floating point number exceeds range of `double'");
3665 /* Get the next character, staying within the current token if possible.
3666 If we're lexing a token, we don't want to look beyond the end of the
3667 token cpplib has prepared for us; otherwise, we end up reading in the
3668 next token, which screws up feed_input. So just return a null
3675 if (yy_cur == yy_lim)
3692 /* Read a single token from the input stream, and assign it lexical
3695 Note: We used to do token pasting here, to produce compound tokens like
3696 LEFT_RIGHT and EXTERN_LANG_STRING. That's now handled in spew.c, along
3697 with symbol table interaction and other context-sensitivity. */
3709 /* Effectively do c = skip_white_space (c)
3710 but do it faster in the usual cases. */
3720 if (cpp_token == CPP_HSPACE)
3721 c = yy_get_token ();
3728 /* Call skip_white_space so we can warn if appropriate. */
3733 c = skip_white_space (c);
3735 goto found_nonwhite;
3739 token_buffer[0] = c;
3740 token_buffer[1] = 0;
3742 /* yylloc.first_line = lineno; */
3748 token_buffer[0] = 0;
3750 value = END_OF_LINE;
3751 else if (input_redirected ())
3752 value = END_OF_SAVED_INPUT;
3759 if (cpp_token == CPP_NAME)
3762 /* Capital L may start a wide-string or wide-character constant. */
3764 register int c = token_getch ();
3773 goto string_constant;
3778 case 'A': case 'B': case 'C': case 'D': case 'E':
3779 case 'F': case 'G': case 'H': case 'I': case 'J':
3780 case 'K': case 'M': case 'N': case 'O':
3781 case 'P': case 'Q': case 'R': case 'S': case 'T':
3782 case 'U': case 'V': case 'W': case 'X': case 'Y':
3784 case 'a': case 'b': case 'c': case 'd': case 'e':
3785 case 'f': case 'g': case 'h': case 'i': case 'j':
3786 case 'k': case 'l': case 'm': case 'n': case 'o':
3787 case 'p': case 'q': case 'r': case 's': case 't':
3788 case 'u': case 'v': case 'w': case 'x': case 'y':
3794 if (cpp_token == CPP_NAME)
3796 /* Note that one character has already been read from
3797 yy_cur into token_buffer. Also, cpplib complains about
3798 $ in identifiers, so we don't have to. */
3800 int len = yy_lim - yy_cur + 1;
3801 if (len >= maxtoken)
3802 extend_token_buffer_to (len + 1);
3803 memcpy (token_buffer + 1, yy_cur, len);
3804 p = token_buffer + len;
3813 /* Make sure this char really belongs in an identifier. */
3814 if (ISALNUM (c) || c == '_')
3818 if (! dollars_in_ident)
3819 error ("`$' in identifier");
3821 pedwarn ("`$' in identifier");
3823 /* FIXME we should use some sort of multibyte character
3824 encoding. Locale-dependent? Always UTF-8? */
3825 else if (is_extended_char (c))
3827 sorry ("universal characters in identifiers");
3833 if (p >= token_buffer + maxtoken)
3834 p = extend_token_buffer (p);
3844 c = readescape (&ignore);
3857 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3860 register struct resword *ptr;
3862 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
3866 if (ptr->token == VISSPEC)
3871 yylval.ttype = access_public_node;
3874 yylval.ttype = access_private_node;
3877 yylval.ttype = access_protected_node;
3880 my_friendly_abort (63);
3884 yylval.ttype = ridpointers[(int) ptr->rid];
3886 else switch (ptr->token)
3889 yylval.code = NE_EXPR;
3890 token_buffer[0] = '!';
3891 token_buffer[1] = '=';
3892 token_buffer[2] = 0;
3896 if (strcmp ("and_eq", token_buffer) == 0)
3898 yylval.code = BIT_AND_EXPR;
3899 token_buffer[0] = '&';
3901 else if (strcmp ("or_eq", token_buffer) == 0)
3903 yylval.code = BIT_IOR_EXPR;
3904 token_buffer[0] = '|';
3906 else if (strcmp ("xor_eq", token_buffer) == 0)
3908 yylval.code = BIT_XOR_EXPR;
3909 token_buffer[0] = '^';
3911 token_buffer[1] = '=';
3912 token_buffer[2] = 0;
3916 yylval.code = BIT_AND_EXPR;
3917 token_buffer[0] = '&';
3918 token_buffer[1] = 0;
3922 yylval.code = BIT_IOR_EXPR;
3923 token_buffer[0] = '|';
3924 token_buffer[1] = 0;
3928 yylval.code = BIT_XOR_EXPR;
3929 token_buffer[0] = '^';
3930 token_buffer[1] = 0;
3934 value = (int) ptr->token;
3938 /* If we did not find a keyword, look for an identifier
3941 if (value == IDENTIFIER || value == TYPESPEC)
3942 GNU_xref_ref (current_function_decl, token_buffer);
3944 if (value == IDENTIFIER)
3946 register tree tmp = get_identifier (token_buffer);
3948 #if !defined(VMS) && defined(JOINER)
3949 /* Make sure that user does not collide with our internal
3952 && (THIS_NAME_P (tmp)
3953 || VPTR_NAME_P (tmp)
3954 || DESTRUCTOR_NAME_P (tmp)
3955 || VTABLE_NAME_P (tmp)
3956 || TEMP_NAME_P (tmp)
3957 || ANON_AGGRNAME_P (tmp)
3958 || ANON_PARMNAME_P (tmp)))
3959 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3965 if (value == NEW && ! global_bindings_p ())
3974 if (yy_cur < yy_lim)
3977 /* It's hard to preserve tokenization on '.' because
3978 it could be a symbol by itself, or it could be the
3979 start of a floating point number and cpp won't tell us. */
3980 register int c1 = token_getch ();
3981 token_buffer[1] = c1;
3985 token_buffer[2] = 0;
3990 c1 = token_getch ();
3993 token_buffer[2] = c1;
3994 token_buffer[3] = 0;
3998 error ("parse error at `..'");
4002 token_put_back (c1);
4005 token_put_back (c1);
4008 token_buffer[1] = 0;
4012 /* Optimize for most frequent case. */
4017 cond = (yy_cur == yy_lim);
4019 register int c1 = token_getch ();
4020 token_put_back (c1);
4021 cond = (! ISALNUM (c1) && c1 != '.');
4025 yylval.ttype = (c == '0') ? integer_zero_node : integer_one_node;
4031 case '2': case '3': case '4':
4032 case '5': case '6': case '7': case '8': case '9':
4037 int largest_digit = 0;
4041 /* We actually store only HOST_BITS_PER_CHAR bits in each part.
4042 The code below which fills the parts array assumes that a host
4043 int is at least twice as wide as a host char, and that
4044 HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
4045 Two HOST_WIDE_INTs is the largest int literal we can store.
4046 In order to detect overflow below, the number of parts (TOTAL_PARTS)
4047 must be exactly the number of parts needed to hold the bits
4048 of two HOST_WIDE_INTs. */
4049 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
4050 unsigned int parts[TOTAL_PARTS];
4052 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON }
4053 floatflag = NOT_FLOAT;
4055 for (count = 0; count < TOTAL_PARTS; count++)
4063 *p++ = (c = token_getch ());
4064 if ((c == 'x') || (c == 'X'))
4067 *p++ = (c = token_getch ());
4069 /* Leading 0 forces octal unless the 0 is the only digit. */
4070 else if (c >= '0' && c <= '9')
4079 /* Read all the digits-and-decimal-points. */
4082 || (ISALNUM (c) && c != 'l' && c != 'L'
4083 && c != 'u' && c != 'U'
4084 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
4085 && (floatflag == NOT_FLOAT
4086 || ((base != 16) && (c != 'f') && (c != 'F'))
4091 if (base == 16 && pedantic)
4092 pedwarn ("floating constant may not be in radix 16");
4093 if (floatflag == TOO_MANY_POINTS)
4094 /* We have already emitted an error. Don't need another. */
4096 else if (floatflag == AFTER_POINT || floatflag == AFTER_EXPON)
4098 error ("malformed floating constant");
4099 floatflag = TOO_MANY_POINTS;
4100 /* Avoid another error from atof by forcing all characters
4101 from here on to be ignored. */
4105 floatflag = AFTER_POINT;
4109 *p++ = c = token_getch ();
4110 /* Accept '.' as the start of a floating-point number
4111 only when it is followed by a digit. */
4112 if (p == token_buffer + 2 && !ISDIGIT (c))
4113 my_friendly_abort (990710);
4117 /* It is not a decimal point.
4118 It should be a digit (perhaps a hex digit). */
4124 else if (base <= 10)
4126 if (c == 'e' || c == 'E')
4129 floatflag = AFTER_EXPON;
4130 break; /* start of exponent */
4132 error ("nondigits in number and not hexadecimal");
4135 else if (base == 16 && (c == 'p' || c == 'P'))
4137 floatflag = AFTER_EXPON;
4138 break; /* start of exponent */
4148 if (c >= largest_digit)
4152 for (count = 0; count < TOTAL_PARTS; count++)
4154 parts[count] *= base;
4158 += (parts[count-1] >> HOST_BITS_PER_CHAR);
4160 &= (1 << HOST_BITS_PER_CHAR) - 1;
4166 /* If the highest-order part overflows (gets larger than
4167 a host char will hold) then the whole number has
4168 overflowed. Record this and truncate the highest-order
4170 if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
4173 parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
4176 if (p >= token_buffer + maxtoken - 3)
4177 p = extend_token_buffer (p);
4178 *p++ = (c = token_getch ());
4182 /* This can happen on input like `int i = 0x;' */
4184 error ("numeric constant with no digits");
4186 if (largest_digit >= base)
4187 error ("numeric constant contains digits beyond the radix");
4189 /* Remove terminating char from the token buffer and delimit the
4193 if (floatflag != NOT_FLOAT)
4196 int imag, conversion_errno;
4197 REAL_VALUE_TYPE value;
4198 struct pf_args args;
4200 /* Read explicit exponent if any, and put it in tokenbuf. */
4202 if ((base == 10 && ((c == 'e') || (c == 'E')))
4203 || (base == 16 && (c == 'p' || c == 'P')))
4205 if (p >= token_buffer + maxtoken - 3)
4206 p = extend_token_buffer (p);
4209 if ((c == '+') || (c == '-'))
4214 /* Exponent is decimal, even if string is a hex float. */
4216 error ("floating constant exponent has no digits");
4219 if (p >= token_buffer + maxtoken - 3)
4220 p = extend_token_buffer (p);
4225 if (base == 16 && floatflag != AFTER_EXPON)
4226 error ("hexadecimal floating constant has no exponent");
4230 /* Setup input for parse_float() */
4235 /* Convert string to a double, checking for overflow. */
4236 if (do_float_handler (parse_float, (PTR) &args))
4238 /* Receive output from parse_float() */
4243 /* We got an exception from parse_float() */
4244 error ("floating constant out of range");
4248 /* Receive output from parse_float() */
4252 conversion_errno = args.conversion_errno;
4255 /* ERANGE is also reported for underflow,
4256 so test the value to distinguish overflow from that. */
4257 if (conversion_errno == ERANGE && pedantic
4258 && (REAL_VALUES_LESS (dconst1, value)
4259 || REAL_VALUES_LESS (value, dconstm1)))
4260 warning ("floating point number exceeds range of `double'");
4263 /* If the result is not a number, assume it must have been
4264 due to some error message above, so silently convert
4266 if (REAL_VALUE_ISNAN (value))
4269 /* Create a node with determined type and value. */
4271 yylval.ttype = build_complex (NULL_TREE,
4272 convert (type, integer_zero_node),
4273 build_real (type, value));
4275 yylval.ttype = build_real (type, value);
4280 HOST_WIDE_INT high, low;
4281 int spec_unsigned = 0;
4283 int spec_long_long = 0;
4290 if (c == 'u' || c == 'U')
4293 error ("two `u's in integer constant");
4296 else if (c == 'l' || c == 'L')
4301 error ("three `l's in integer constant");
4302 else if (pedantic && ! in_system_header && warn_long_long)
4303 pedwarn ("ISO C++ forbids long long integer constants");
4308 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
4311 error ("more than one `i' or `j' in numeric constant");
4313 pedwarn ("ISO C++ forbids imaginary numeric constants");
4318 if (p >= token_buffer + maxtoken - 3)
4319 p = extend_token_buffer (p);
4324 /* If the literal overflowed, pedwarn about it now. */
4328 pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
4331 /* This is simplified by the fact that our constant
4332 is always positive. */
4336 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
4338 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
4339 / HOST_BITS_PER_CHAR)]
4340 << (i * HOST_BITS_PER_CHAR));
4341 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
4344 yylval.ttype = build_int_2 (low, high);
4345 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
4347 /* Calculate the ANSI type. */
4348 if (! spec_long && ! spec_unsigned
4349 && int_fits_type_p (yylval.ttype, integer_type_node))
4350 type = integer_type_node;
4351 else if (! spec_long && (base != 10 || spec_unsigned)
4352 && int_fits_type_p (yylval.ttype, unsigned_type_node))
4353 type = unsigned_type_node;
4354 else if (! spec_unsigned && !spec_long_long
4355 && int_fits_type_p (yylval.ttype, long_integer_type_node))
4356 type = long_integer_type_node;
4357 else if (! spec_long_long
4358 && int_fits_type_p (yylval.ttype,
4359 long_unsigned_type_node))
4360 type = long_unsigned_type_node;
4361 else if (! spec_unsigned
4362 && int_fits_type_p (yylval.ttype,
4363 long_long_integer_type_node))
4364 type = long_long_integer_type_node;
4365 else if (int_fits_type_p (yylval.ttype,
4366 long_long_unsigned_type_node))
4367 type = long_long_unsigned_type_node;
4368 else if (! spec_unsigned
4369 && int_fits_type_p (yylval.ttype,
4370 widest_integer_literal_type_node))
4371 type = widest_integer_literal_type_node;
4373 type = widest_unsigned_literal_type_node;
4375 if (pedantic && !spec_long_long && !warn
4376 && (TYPE_PRECISION (long_integer_type_node)
4377 < TYPE_PRECISION (type)))
4380 pedwarn ("integer constant larger than the maximum value of an unsigned long int");
4383 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
4384 warning ("decimal constant is so large that it is unsigned");
4388 if (TYPE_PRECISION (type)
4389 <= TYPE_PRECISION (integer_type_node))
4391 = build_complex (NULL_TREE, integer_zero_node,
4392 convert (integer_type_node,
4395 error ("complex integer constant is too wide for `__complex int'");
4398 TREE_TYPE (yylval.ttype) = type;
4401 /* If it's still an integer (not a complex), and it doesn't
4402 fit in the type we choose for it, then pedwarn. */
4405 && TREE_CODE (TREE_TYPE (yylval.ttype)) == INTEGER_TYPE
4406 && ! int_fits_type_p (yylval.ttype, TREE_TYPE (yylval.ttype)))
4407 pedwarn ("integer constant is larger than the maximum value for its type");
4413 if (ISALNUM (c) || c == '.' || c == '_' || c == '$'
4414 || ((c == '-' || c == '+')
4415 && (p[-1] == 'e' || p[-1] == 'E')))
4416 error ("missing white space after number `%s'", token_buffer);
4418 value = CONSTANT; break;
4424 register int result = 0;
4425 register int num_chars = 0;
4427 unsigned width = TYPE_PRECISION (char_type_node);
4429 #ifdef MULTIBYTE_CHARS
4430 int longest_char = local_mb_cur_max ();
4431 local_mbtowc (NULL_PTR, NULL_PTR, 0);
4434 max_chars = TYPE_PRECISION (integer_type_node) / width;
4436 width = WCHAR_TYPE_SIZE;
4443 if (c == '\'' || c == EOF)
4450 c = readescape (&ignore);
4453 if (width < HOST_BITS_PER_INT
4454 && (unsigned) c >= ((unsigned)1 << width))
4455 pedwarn ("escape sequence out of range for character");
4456 #ifdef MAP_CHARACTER
4458 c = MAP_CHARACTER (c);
4464 pedwarn ("ISO C++ forbids newline in character constant");
4469 #ifdef MULTIBYTE_CHARS
4473 for (i = 1; i <= longest_char; ++i)
4475 if (i > maxtoken - 4)
4476 extend_token_buffer (token_buffer);
4478 token_buffer[i] = c;
4479 char_len = local_mbtowc (& wc,
4488 /* mbtowc sometimes needs an extra char before accepting */
4493 /* Merge character into result; ignore excess chars. */
4494 for (i = 1; i <= char_len; ++i)
4498 if (width < HOST_BITS_PER_INT)
4499 result = (result << width)
4501 & ((1 << width) - 1));
4503 result = token_buffer[i];
4505 num_chars += char_len;
4514 warning ("Ignoring invalid multibyte character");
4515 /* Replace all but the first byte. */
4516 for (--i; i > 1; --i)
4517 token_put_back (token_buffer[i]);
4518 wc = token_buffer[1];
4520 #ifdef MAP_CHARACTER
4521 c = MAP_CHARACTER (wc);
4526 #else /* ! MULTIBYTE_CHARS */
4527 #ifdef MAP_CHARACTER
4528 c = MAP_CHARACTER (c);
4530 #endif /* ! MULTIBYTE_CHARS */
4535 if (chars_seen == 1) /* only keep the first one */
4540 /* Merge character into result; ignore excess chars. */
4541 num_chars += (width / TYPE_PRECISION (char_type_node));
4542 if (num_chars < max_chars + 1)
4544 if (width < HOST_BITS_PER_INT)
4545 result = (result << width) | (c & ((1 << width) - 1));
4552 error ("malformatted character constant");
4553 else if (chars_seen == 0)
4554 error ("empty character constant");
4555 else if (num_chars > max_chars)
4557 num_chars = max_chars;
4558 error ("character constant too long");
4560 else if (chars_seen != 1 && warn_multichar)
4561 warning ("multi-character character constant");
4563 /* If char type is signed, sign-extend the constant. */
4566 int num_bits = num_chars * width;
4568 /* We already got an error; avoid invalid shift. */
4569 yylval.ttype = build_int_2 (0, 0);
4570 else if (TREE_UNSIGNED (char_type_node)
4571 || ((result >> (num_bits - 1)) & 1) == 0)
4573 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
4574 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4578 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
4579 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4581 /* In C, a character constant has type 'int'; in C++, 'char'. */
4582 if (chars_seen <= 1)
4583 TREE_TYPE (yylval.ttype) = char_type_node;
4585 TREE_TYPE (yylval.ttype) = integer_type_node;
4589 yylval.ttype = build_int_2 (result, 0);
4590 TREE_TYPE (yylval.ttype) = wchar_type_node;
4600 unsigned width = wide_flag ? WCHAR_TYPE_SIZE
4601 : TYPE_PRECISION (char_type_node);
4602 #ifdef MULTIBYTE_CHARS
4603 int longest_char = local_mb_cur_max ();
4604 local_mbtowc (NULL_PTR, NULL_PTR, 0);
4608 p = token_buffer + 1;
4610 while (c != '"' && c != EOF)
4612 /* ignore_escape_flag is set for reading the filename in #line. */
4613 if (!ignore_escape_flag && c == '\\')
4616 c = readescape (&ignore);
4619 if (width < HOST_BITS_PER_INT
4620 && (unsigned) c >= ((unsigned)1 << width))
4621 pedwarn ("escape sequence out of range for character");
4626 pedwarn ("ISO C++ forbids newline in string constant");
4631 #ifdef MULTIBYTE_CHARS
4635 for (i = 0; i < longest_char; ++i)
4637 if (p + i >= token_buffer + maxtoken)
4638 p = extend_token_buffer (p);
4641 char_len = local_mbtowc (& wc, p, i + 1);
4648 warning ("Ignoring invalid multibyte character");
4649 /* Replace all except the first byte. */
4651 for (--i; i > 0; --i)
4652 token_put_back (p[i]);
4655 /* mbtowc sometimes needs an extra char before accepting */
4665 #endif /* MULTIBYTE_CHARS */
4668 /* Add this single character into the buffer either as a wchar_t
4669 or as a single byte. */
4672 unsigned width = TYPE_PRECISION (char_type_node);
4673 unsigned bytemask = (1 << width) - 1;
4676 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4677 p = extend_token_buffer (p);
4679 for (byte = 0; byte < WCHAR_BYTES; ++byte)
4682 if (byte >= (int) sizeof (c))
4685 value = (c >> (byte * width)) & bytemask;
4686 if (BYTES_BIG_ENDIAN)
4687 p[WCHAR_BYTES - byte - 1] = value;
4695 if (p >= token_buffer + maxtoken)
4696 p = extend_token_buffer (p);
4704 /* Terminate the string value, either with a single byte zero
4705 or with a wide zero. */
4708 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4709 p = extend_token_buffer (p);
4710 bzero (p, WCHAR_BYTES);
4715 if (p >= token_buffer + maxtoken)
4716 p = extend_token_buffer (p);
4721 error ("Unterminated string constant");
4723 /* We have read the entire constant.
4724 Construct a STRING_CST for the result. */
4726 yylval.ttype = build_string (p - (token_buffer + 1), token_buffer + 1);
4729 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4731 TREE_TYPE (yylval.ttype) = char_array_type_node;
4733 value = STRING; break;
4757 yylval.code = PLUS_EXPR; break;
4759 yylval.code = MINUS_EXPR; break;
4761 yylval.code = BIT_AND_EXPR; break;
4763 yylval.code = BIT_IOR_EXPR; break;
4765 yylval.code = MULT_EXPR; break;
4767 yylval.code = TRUNC_DIV_EXPR; break;
4769 yylval.code = TRUNC_MOD_EXPR; break;
4771 yylval.code = BIT_XOR_EXPR; break;
4773 yylval.code = LSHIFT_EXPR; break;
4775 yylval.code = RSHIFT_EXPR; break;
4777 yylval.code = LT_EXPR; break;
4779 yylval.code = GT_EXPR; break;
4782 token_buffer[1] = c1 = token_getch ();
4783 token_buffer[2] = 0;
4790 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4792 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4794 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4796 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4798 value = ASSIGN; goto done;
4804 value = PLUSPLUS; goto done;
4806 value = MINUSMINUS; goto done;
4808 value = ANDAND; goto done;
4810 value = OROR; goto done;
4822 else if (c1 == '?' && (c == '<' || c == '>'))
4824 token_buffer[3] = 0;
4826 c1 = token_getch ();
4827 yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4830 /* <?= or >?= expression. */
4831 token_buffer[2] = c1;
4837 token_put_back (c1);
4840 pedwarn ("use of `operator %s' is not standard C++",
4850 c1 = token_getch ();
4852 value = POINTSAT_STAR;
4855 token_put_back (c1);
4865 { value = ']'; goto done; }
4869 { value = '{'; indent_level++; goto done; }
4871 { value = '['; goto done; }
4875 { value = '}'; indent_level--; goto done; }
4879 token_put_back (c1);
4880 token_buffer[1] = 0;
4882 /* Here the C frontend changes < and > to ARITHCOMPARE. We don't
4883 do that because of templates. */
4890 /* Don't make yyparse think this is eof. */
4905 if (is_extended_char (c))
4911 /* yylloc.last_line = lineno; */
4912 #ifdef GATHER_STATISTICS
4913 #ifdef REDUCE_LENGTH
4914 token_count[value] += 1;
4925 return !!is_reserved_word (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
4928 #ifdef GATHER_STATISTICS
4929 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4930 need to be brought into here, unless this were actually put into a header
4932 /* Statistics-gathering stuff. */
4953 extern int tree_node_counts[];
4954 extern int tree_node_sizes[];
4958 build_lang_decl (code, name, type)
4959 enum tree_code code;
4965 t = build_decl (code, name, type);
4966 retrofit_lang_decl (t);
4971 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
4972 and pushdecl (for functions generated by the backend). */
4975 retrofit_lang_decl (t)
4978 struct lang_decl *ld;
4981 if (CAN_HAVE_FULL_LANG_DECL_P (t))
4982 size = sizeof (struct lang_decl);
4984 size = sizeof (struct lang_decl_flags);
4986 ld = (struct lang_decl *) ggc_alloc (size);
4987 memset (ld, 0, size);
4989 DECL_LANG_SPECIFIC (t) = ld;
4990 if (current_lang_name == lang_name_cplusplus)
4991 DECL_LANGUAGE (t) = lang_cplusplus;
4992 else if (current_lang_name == lang_name_c)
4993 DECL_LANGUAGE (t) = lang_c;
4994 else if (current_lang_name == lang_name_java)
4995 DECL_LANGUAGE (t) = lang_java;
4996 else my_friendly_abort (64);
4998 if (CAN_HAVE_FULL_LANG_DECL_P (t))
4999 DECL_MAIN_VARIANT (t) = t;
5001 #ifdef GATHER_STATISTICS
5002 tree_node_counts[(int)lang_decl] += 1;
5003 tree_node_sizes[(int)lang_decl] += size;
5008 copy_lang_decl (node)
5012 struct lang_decl *ld;
5014 if (! DECL_LANG_SPECIFIC (node))
5017 if (!CAN_HAVE_FULL_LANG_DECL_P (node))
5018 size = sizeof (struct lang_decl_flags);
5020 size = sizeof (struct lang_decl);
5021 ld = (struct lang_decl *) ggc_alloc (size);
5022 bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)ld, size);
5023 DECL_LANG_SPECIFIC (node) = ld;
5027 cp_make_lang_type (code)
5028 enum tree_code code;
5030 register tree t = make_node (code);
5032 /* Set up some flags that give proper default behavior. */
5033 if (IS_AGGR_TYPE_CODE (code))
5035 struct lang_type *pi;
5037 pi = (struct lang_type *) ggc_alloc (sizeof (struct lang_type));
5038 bzero ((char *) pi, (int) sizeof (struct lang_type));
5040 TYPE_LANG_SPECIFIC (t) = pi;
5041 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
5042 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
5044 /* Make sure this is laid out, for ease of use later. In the
5045 presence of parse errors, the normal was of assuring this
5046 might not ever get executed, so we lay it out *immediately*. */
5047 build_pointer_type (t);
5049 #ifdef GATHER_STATISTICS
5050 tree_node_counts[(int)lang_type] += 1;
5051 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
5055 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
5056 TYPE_ALIAS_SET is initialized to -1 by default, so we must
5058 TYPE_ALIAS_SET (t) = 0;
5060 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
5061 since they can be virtual base types, and we then need a
5062 canonical binfo for them. Ideally, this would be done lazily for
5064 if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM)
5065 TYPE_BINFO (t) = make_binfo (size_zero_node, t, NULL_TREE, NULL_TREE);
5071 make_aggr_type (code)
5072 enum tree_code code;
5074 tree t = cp_make_lang_type (code);
5076 if (IS_AGGR_TYPE_CODE (code))
5077 SET_IS_AGGR_TYPE (t, 1);
5083 dump_time_statistics ()
5085 register tree prev = 0, decl, next;
5086 int this_time = my_get_run_time ();
5087 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time))
5088 += this_time - body_time;
5090 fprintf (stderr, "\n******\n");
5091 print_time ("header files (total)", header_time);
5092 print_time ("main file (total)", this_time - body_time);
5093 fprintf (stderr, "ratio = %g : 1\n",
5094 (double)header_time / (double)(this_time - body_time));
5095 fprintf (stderr, "\n******\n");
5097 for (decl = filename_times; decl; decl = next)
5099 next = IDENTIFIER_GLOBAL_VALUE (decl);
5100 SET_IDENTIFIER_GLOBAL_VALUE (decl, prev);
5104 for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
5105 print_time (IDENTIFIER_POINTER (decl),
5106 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (decl)));
5110 compiler_error VPARAMS ((const char *msg, ...))
5112 #ifndef ANSI_PROTOTYPES
5120 #ifndef ANSI_PROTOTYPES
5121 msg = va_arg (ap, const char *);
5124 vsprintf (buf, msg, ap);
5126 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
5129 /* Return the type-qualifier corresponding to the identifier given by
5133 cp_type_qual_from_rid (rid)
5136 if (rid == ridpointers[(int) RID_CONST])
5137 return TYPE_QUAL_CONST;
5138 else if (rid == ridpointers[(int) RID_VOLATILE])
5139 return TYPE_QUAL_VOLATILE;
5140 else if (rid == ridpointers[(int) RID_RESTRICT])
5141 return TYPE_QUAL_RESTRICT;
5143 my_friendly_abort (0);
5144 return TYPE_UNQUALIFIED;