1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-98, 1999 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is the lexical analyzer for GNU C++. */
25 /* Cause the `yydebug' variable to be defined. */
41 #ifdef MULTIBYTE_CHARS
46 #define obstack_chunk_alloc xmalloc
47 #define obstack_chunk_free free
50 #define DIR_SEPARATOR '/'
53 extern struct obstack permanent_obstack;
54 extern struct obstack *current_obstack, *saveable_obstack;
56 extern void yyprint PROTO((FILE *, int, YYSTYPE));
58 static tree get_time_identifier PROTO((const char *));
59 static int check_newline PROTO((void));
60 static int whitespace_cr PROTO((int));
61 static int skip_white_space PROTO((int));
62 static void finish_defarg PROTO((void));
63 static int my_get_run_time PROTO((void));
64 static int interface_strcmp PROTO((const char *));
65 static int readescape PROTO((int *));
66 static char *extend_token_buffer PROTO((const char *));
67 static void consume_string PROTO((struct obstack *, int));
68 static void feed_defarg PROTO((tree, tree));
69 static void store_pending_inline PROTO((tree, struct pending_inline *));
70 static void reinit_parse_for_expr PROTO((struct obstack *));
71 static int *init_cpp_parse PROTO((void));
72 static void cp_pragma_interface PROTO((char *));
73 static void cp_pragma_implementation PROTO ((char *));
74 static int handle_cp_pragma PROTO((const char *));
75 #ifdef HANDLE_GENERIC_PRAGMAS
76 static int handle_generic_pragma PROTO((int));
78 #ifdef GATHER_STATISTICS
80 static int reduce_cmp PROTO((int *, int *));
81 static int token_cmp PROTO((int *, int *));
84 static void begin_definition_of_inclass_inline PROTO((struct pending_inline*));
85 static void parse_float PROTO((PTR));
86 static int is_global PROTO((tree));
87 static void init_filename_times PROTO((void));
89 /* Given a file name X, return the nondirectory portion.
90 Keep in mind that X can be computed more than once. */
92 file_name_nondirectory (x)
95 char *tmp = (char *) rindex (x, '/');
96 if (DIR_SEPARATOR != '/' && ! tmp)
97 tmp = (char *) rindex (x, DIR_SEPARATOR);
99 return (char *) (tmp + 1);
104 /* This obstack is needed to hold text. It is not safe to use
105 TOKEN_BUFFER because `check_newline' calls `yylex'. */
106 struct obstack inline_text_obstack;
107 char *inline_text_firstobj;
111 extern cpp_reader parse_in;
112 extern cpp_options parse_options;
113 extern unsigned char *yy_cur, *yy_lim;
114 extern enum cpp_token cpp_token;
122 /* Pending language change.
123 Positive is push count, negative is pop count. */
124 int pending_lang_change = 0;
126 /* Wrap the current header file in extern "C". */
127 static int c_header_level = 0;
129 extern int first_token;
130 extern struct obstack token_obstack;
132 /* ??? Don't really know where this goes yet. */
135 /* Holds translations from TREE_CODEs to operator name strings,
136 i.e., opname_tab[PLUS_EXPR] == "+". */
140 extern int yychar; /* the lookahead symbol */
141 extern YYSTYPE yylval; /* the semantic value of the */
142 /* lookahead symbol */
145 YYLTYPE yylloc; /* location data for the lookahead */
150 /* the declaration found for the last IDENTIFIER token read in.
151 yylex must look this up to detect typedefs, which get token type TYPENAME,
152 so it is left around in case the identifier is not a typedef but is
153 used in a context which makes it a reference to a variable. */
156 /* The elements of `ridpointers' are identifier nodes
157 for the reserved type names and storage classes.
158 It is indexed by a RID_... value. */
159 tree ridpointers[(int) RID_MAX];
161 /* We may keep statistics about how long which files took to compile. */
162 static int header_time, body_time;
163 static tree filename_times;
164 static tree this_filename_time;
166 /* Array for holding counts of the numbers of tokens seen. */
167 extern int *token_count;
169 /* Return something to represent absolute declarators containing a *.
170 TARGET is the absolute declarator that the * contains.
171 CV_QUALIFIERS is a list of modifiers such as const or volatile
172 to apply to the pointer type, represented as identifiers.
174 We return an INDIRECT_REF whose "contents" are TARGET
175 and whose type is the modifier list. */
178 make_pointer_declarator (cv_qualifiers, target)
179 tree cv_qualifiers, target;
181 if (target && TREE_CODE (target) == IDENTIFIER_NODE
182 && ANON_AGGRNAME_P (target))
183 error ("type name expected before `*'");
184 target = build_parse_node (INDIRECT_REF, target);
185 TREE_TYPE (target) = cv_qualifiers;
189 /* Return something to represent absolute declarators containing a &.
190 TARGET is the absolute declarator that the & contains.
191 CV_QUALIFIERS is a list of modifiers such as const or volatile
192 to apply to the reference type, represented as identifiers.
194 We return an ADDR_EXPR whose "contents" are TARGET
195 and whose type is the modifier list. */
198 make_reference_declarator (cv_qualifiers, target)
199 tree cv_qualifiers, target;
203 if (TREE_CODE (target) == ADDR_EXPR)
205 error ("cannot declare references to references");
208 if (TREE_CODE (target) == INDIRECT_REF)
210 error ("cannot declare pointers to references");
213 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
214 error ("type name expected before `&'");
216 target = build_parse_node (ADDR_EXPR, target);
217 TREE_TYPE (target) = cv_qualifiers;
222 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
223 tree target, parms, cv_qualifiers, exception_specification;
225 target = build_parse_node (CALL_EXPR, target, parms, cv_qualifiers);
226 TREE_TYPE (target) = exception_specification;
231 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
232 tree call_declarator, cv_qualifiers, exception_specification;
234 TREE_OPERAND (call_declarator, 2) = cv_qualifiers;
235 TREE_TYPE (call_declarator) = exception_specification;
238 /* Build names and nodes for overloaded operators. */
240 tree ansi_opname[LAST_CPLUS_TREE_CODE];
241 tree ansi_assopname[LAST_CPLUS_TREE_CODE];
244 operator_name_string (name)
247 char *opname = IDENTIFIER_POINTER (name) + 2;
251 /* Works for builtin and user defined types. */
252 if (IDENTIFIER_GLOBAL_VALUE (name)
253 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
254 return IDENTIFIER_POINTER (name);
256 if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
260 opname_table = ansi_assopname;
265 opname_table = ansi_opname;
268 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
270 if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
271 && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
275 if (i == LAST_CPLUS_TREE_CODE)
276 return "<invalid operator>";
279 return assignop_tab[i];
281 return opname_tab[i];
284 int interface_only; /* whether or not current file is only for
285 interface definitions. */
286 int interface_unknown; /* whether or not we know this class
287 to behave according to #pragma interface. */
289 /* lexical analyzer */
291 #ifndef WCHAR_TYPE_SIZE
293 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
295 #define WCHAR_TYPE_SIZE BITS_PER_WORD
299 /* Number of bytes in a wide character. */
300 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
302 static int maxtoken; /* Current nominal length of token buffer. */
303 char *token_buffer; /* Pointer to token buffer.
304 Actual allocated length is maxtoken + 2. */
306 static int indent_level; /* Number of { minus number of }. */
311 /* Nonzero tells yylex to ignore \ in string constants. */
312 static int ignore_escape_flag;
315 get_time_identifier (name)
318 tree time_identifier;
319 int len = strlen (name);
320 char *buf = (char *) alloca (len + 6);
321 strcpy (buf, "file ");
322 bcopy (name, buf+5, len);
324 time_identifier = get_identifier (buf);
325 if (TIME_IDENTIFIER_TIME (time_identifier) == NULL_TREE)
327 push_obstacks_nochange ();
328 end_temporary_allocation ();
329 TIME_IDENTIFIER_TIME (time_identifier) = build_int_2 (0, 0);
330 TIME_IDENTIFIER_FILEINFO (time_identifier)
331 = build_int_2 (0, 1);
332 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier, filename_times);
333 filename_times = time_identifier;
336 return time_identifier;
345 int old_quiet_flag = quiet_flag;
348 this_time = get_run_time ();
349 quiet_flag = old_quiet_flag;
353 /* Table indexed by tree code giving a string containing a character
354 classifying the tree code. Possibilities are
355 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
357 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
359 char cplus_tree_code_type[] = {
361 #include "cp-tree.def"
365 /* Table indexed by tree code giving number of expression
366 operands beyond the fixed part of the node structure.
367 Not used for types or decls. */
369 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
371 int cplus_tree_code_length[] = {
373 #include "cp-tree.def"
377 /* Names of tree components.
378 Used for printing out the tree and error messages. */
379 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
381 const char *cplus_tree_code_name[] = {
383 #include "cp-tree.def"
387 /* toplev.c needs to call these. */
393 cpp_reader_init (&parse_in);
394 parse_in.opts = &parse_options;
395 cpp_options_init (&parse_options);
396 parse_options.cplusplus = 1;
399 /* Default exceptions on. */
406 /* the beginning of the file is a new line; check for # */
407 /* With luck, we discover the real source file's name from that
408 and put it in input_filename. */
409 put_back (check_newline ());
410 if (flag_gnu_xref) GNU_xref_begin (input_filename);
411 init_repo (input_filename);
417 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
427 init_filename_times ()
429 this_filename_time = get_time_identifier ("<top level>");
430 if (flag_detailed_statistics)
433 body_time = my_get_run_time ();
434 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time))
439 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
440 Stuck this hack in to get the files open correctly; this is called
441 in place of init_parse if we are an unexec'd binary. */
445 reinit_lang_specific ()
447 init_filename_times ();
448 reinit_search_statistics ();
455 #ifdef GATHER_STATISTICS
457 reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
458 bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
460 token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
461 bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
469 init_parse (filename)
472 extern int flag_no_gnu_keywords;
473 extern int flag_operator_names;
477 #ifdef MULTIBYTE_CHARS
478 /* Change to the native locale for multibyte conversions. */
479 setlocale (LC_CTYPE, "");
480 literal_codeset = getenv ("LANG");
484 /* Open input file. */
485 if (filename == 0 || !strcmp (filename, "-"))
491 finput = fopen (filename, "r");
493 pfatal_with_name (filename);
495 #ifdef IO_BUFFER_SIZE
496 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
498 #else /* !USE_CPPLIB */
499 parse_in.show_column = 1;
500 if (! cpp_start_read (&parse_in, filename))
503 if (filename == 0 || !strcmp (filename, "-"))
506 /* cpp_start_read always puts at least one line directive into the
507 token buffer. We must arrange to read it out here. */
508 yy_cur = parse_in.token_buffer;
509 yy_lim = CPP_PWRITTEN (&parse_in);
510 cpp_token = CPP_DIRECTIVE;
512 #endif /* !USE_CPPLIB */
514 /* Initialize the lookahead machinery. */
517 /* Make identifier nodes long enough for the language-specific slots. */
518 set_identifier_size (sizeof (struct lang_identifier));
519 decl_printable_name = lang_printable_name;
521 init_cplus_expand ();
523 bcopy (cplus_tree_code_type,
524 tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
525 (int)LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
526 bcopy ((char *)cplus_tree_code_length,
527 (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
528 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
529 bcopy ((char *)cplus_tree_code_name,
530 (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
531 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
533 opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
534 bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
535 assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
536 bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
538 ansi_opname[0] = get_identifier ("<invalid operator>");
539 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
541 ansi_opname[i] = ansi_opname[0];
542 ansi_assopname[i] = ansi_opname[0];
545 ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
546 IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
547 ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
548 ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
549 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
550 ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
551 ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
552 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
553 ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
554 IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
555 ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
556 ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
557 ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
558 ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
559 IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
560 ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
561 ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
562 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
563 ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
564 ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
565 IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
566 ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
567 IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
568 ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
569 IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
570 ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
571 IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
572 ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
573 IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
574 ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
575 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
576 ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
577 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
578 ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
579 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
580 ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
581 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
582 ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
583 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
584 ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
585 ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
586 IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
587 ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
588 ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
589 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
590 ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
591 IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
592 ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
593 IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
594 ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
595 ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
596 ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
597 ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
598 ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
599 ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
600 ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
601 ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
602 ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
603 IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
604 ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
605 IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
606 ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
607 ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
608 ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
609 IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
610 ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
611 IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
612 ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
613 IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
614 ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
615 IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
616 ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
617 IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
618 ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
619 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
620 ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
621 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
622 ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
623 ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
624 ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
625 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
626 ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
627 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
628 ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
629 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
630 ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
631 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
632 ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
633 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
634 ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
635 ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
636 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
637 ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
638 IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
639 ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
640 IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
641 ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
642 IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
643 ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
644 IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
645 ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
646 IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
647 ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
648 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
649 ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
650 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
651 ansi_opname[(int) TYPE_EXPR] = get_identifier (OPERATOR_TYPENAME_FORMAT);
652 IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
654 /* This is not true: these operators are not defined in ANSI,
655 but we need them anyway. */
656 ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
657 IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
658 ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
659 IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
660 ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
661 IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
662 ansi_opname[(int) SIZEOF_EXPR] = get_identifier ("__sz");
663 IDENTIFIER_OPNAME_P (ansi_opname[(int) SIZEOF_EXPR]) = 1;
667 gcc_obstack_init (&inline_text_obstack);
668 inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
670 /* Start it at 0, because check_newline is called at the very beginning
671 and will increment it to 1. */
673 input_filename = "<internal>";
674 current_function_decl = NULL;
677 token_buffer = (char *) xmalloc (maxtoken + 2);
679 ridpointers[(int) RID_INT] = get_identifier ("int");
680 ridpointers[(int) RID_BOOL] = get_identifier ("bool");
681 ridpointers[(int) RID_CHAR] = get_identifier ("char");
682 ridpointers[(int) RID_VOID] = get_identifier ("void");
683 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
684 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
685 ridpointers[(int) RID_SHORT] = get_identifier ("short");
686 ridpointers[(int) RID_LONG] = get_identifier ("long");
687 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
688 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
689 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
690 ridpointers[(int) RID_CONST] = get_identifier ("const");
691 ridpointers[(int) RID_RESTRICT] = get_identifier ("__restrict");
692 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
693 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
694 ridpointers[(int) RID_STATIC] = get_identifier ("static");
695 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
696 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
697 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
698 ridpointers[(int) RID_COMPLEX] = get_identifier ("__complex");
700 /* C++ extensions. These are probably not correctly named. */
701 ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
702 class_type_node = build_int_2 (class_type, 0);
703 TREE_TYPE (class_type_node) = class_type_node;
704 ridpointers[(int) RID_CLASS] = class_type_node;
706 record_type_node = build_int_2 (record_type, 0);
707 TREE_TYPE (record_type_node) = record_type_node;
708 ridpointers[(int) RID_RECORD] = record_type_node;
710 union_type_node = build_int_2 (union_type, 0);
711 TREE_TYPE (union_type_node) = union_type_node;
712 ridpointers[(int) RID_UNION] = union_type_node;
714 enum_type_node = build_int_2 (enum_type, 0);
715 TREE_TYPE (enum_type_node) = enum_type_node;
716 ridpointers[(int) RID_ENUM] = enum_type_node;
718 ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
719 ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
720 ridpointers[(int) RID_EXPORT] = get_identifier ("export");
721 ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
723 ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
724 ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
725 ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
726 ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
727 /* This is for ANSI C++. */
728 ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
730 /* Signature handling extensions. */
731 signature_type_node = build_int_2 (signature_type, 0);
732 TREE_TYPE (signature_type_node) = signature_type_node;
733 ridpointers[(int) RID_SIGNATURE] = signature_type_node;
735 /* Create the built-in __null node. Note that we can't yet call for
736 type_for_size here because integer_type_node and so forth are not
737 set up. Therefore, we don't set the type of these nodes until
738 init_decl_processing. */
739 null_node = build_int_2 (0, 0);
740 ridpointers[RID_NULL] = null_node;
742 opname_tab[(int) COMPONENT_REF] = "->";
743 opname_tab[(int) MEMBER_REF] = "->*";
744 opname_tab[(int) INDIRECT_REF] = "*";
745 opname_tab[(int) ARRAY_REF] = "[]";
746 opname_tab[(int) MODIFY_EXPR] = "=";
747 opname_tab[(int) NEW_EXPR] = "new";
748 opname_tab[(int) DELETE_EXPR] = "delete";
749 opname_tab[(int) VEC_NEW_EXPR] = "new []";
750 opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
751 opname_tab[(int) COND_EXPR] = "?:";
752 opname_tab[(int) CALL_EXPR] = "()";
753 opname_tab[(int) PLUS_EXPR] = "+";
754 opname_tab[(int) MINUS_EXPR] = "-";
755 opname_tab[(int) MULT_EXPR] = "*";
756 opname_tab[(int) TRUNC_DIV_EXPR] = "/";
757 opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
758 opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
759 opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
760 opname_tab[(int) TRUNC_MOD_EXPR] = "%";
761 opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
762 opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
763 opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
764 opname_tab[(int) EXACT_DIV_EXPR] = "/";
765 opname_tab[(int) NEGATE_EXPR] = "-";
766 opname_tab[(int) MIN_EXPR] = "<?";
767 opname_tab[(int) MAX_EXPR] = ">?";
768 opname_tab[(int) ABS_EXPR] = "abs";
769 opname_tab[(int) FFS_EXPR] = "ffs";
770 opname_tab[(int) LSHIFT_EXPR] = "<<";
771 opname_tab[(int) RSHIFT_EXPR] = ">>";
772 opname_tab[(int) BIT_IOR_EXPR] = "|";
773 opname_tab[(int) BIT_XOR_EXPR] = "^";
774 opname_tab[(int) BIT_AND_EXPR] = "&";
775 opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
776 opname_tab[(int) BIT_NOT_EXPR] = "~";
777 opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
778 opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
779 opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
780 opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
781 opname_tab[(int) TRUTH_NOT_EXPR] = "!";
782 opname_tab[(int) LT_EXPR] = "<";
783 opname_tab[(int) LE_EXPR] = "<=";
784 opname_tab[(int) GT_EXPR] = ">";
785 opname_tab[(int) GE_EXPR] = ">=";
786 opname_tab[(int) EQ_EXPR] = "==";
787 opname_tab[(int) NE_EXPR] = "!=";
788 opname_tab[(int) IN_EXPR] = "in";
789 opname_tab[(int) RANGE_EXPR] = "...";
790 opname_tab[(int) CONVERT_EXPR] = "+";
791 opname_tab[(int) ADDR_EXPR] = "&";
792 opname_tab[(int) PREDECREMENT_EXPR] = "--";
793 opname_tab[(int) PREINCREMENT_EXPR] = "++";
794 opname_tab[(int) POSTDECREMENT_EXPR] = "--";
795 opname_tab[(int) POSTINCREMENT_EXPR] = "++";
796 opname_tab[(int) COMPOUND_EXPR] = ",";
798 assignop_tab[(int) NOP_EXPR] = "=";
799 assignop_tab[(int) PLUS_EXPR] = "+=";
800 assignop_tab[(int) CONVERT_EXPR] = "+=";
801 assignop_tab[(int) MINUS_EXPR] = "-=";
802 assignop_tab[(int) NEGATE_EXPR] = "-=";
803 assignop_tab[(int) MULT_EXPR] = "*=";
804 assignop_tab[(int) INDIRECT_REF] = "*=";
805 assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
806 assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
807 assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
808 assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
809 assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
810 assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
811 assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
812 assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
813 assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
814 assignop_tab[(int) MIN_EXPR] = "<?=";
815 assignop_tab[(int) MAX_EXPR] = ">?=";
816 assignop_tab[(int) LSHIFT_EXPR] = "<<=";
817 assignop_tab[(int) RSHIFT_EXPR] = ">>=";
818 assignop_tab[(int) BIT_IOR_EXPR] = "|=";
819 assignop_tab[(int) BIT_XOR_EXPR] = "^=";
820 assignop_tab[(int) BIT_AND_EXPR] = "&=";
821 assignop_tab[(int) ADDR_EXPR] = "&=";
823 init_filename_times ();
825 /* Some options inhibit certain reserved words.
826 Clear those words out of the hash table so they won't be recognized. */
827 #define UNSET_RESERVED_WORD(STRING) \
828 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
829 if (s) s->name = ""; } while (0)
832 /* let's parse things, and if they use it, then give them an error. */
833 if (!flag_exceptions)
835 UNSET_RESERVED_WORD ("throw");
836 UNSET_RESERVED_WORD ("try");
837 UNSET_RESERVED_WORD ("catch");
841 if (!flag_rtti || flag_no_gnu_keywords)
843 UNSET_RESERVED_WORD ("classof");
844 UNSET_RESERVED_WORD ("headof");
847 if (! flag_handle_signatures || flag_no_gnu_keywords)
849 /* Easiest way to not recognize signature
850 handling extensions... */
851 UNSET_RESERVED_WORD ("signature");
852 UNSET_RESERVED_WORD ("sigof");
854 if (flag_no_asm || flag_no_gnu_keywords)
855 UNSET_RESERVED_WORD ("typeof");
856 if (! flag_operator_names)
858 /* These are new ANSI keywords that may break code. */
859 UNSET_RESERVED_WORD ("and");
860 UNSET_RESERVED_WORD ("and_eq");
861 UNSET_RESERVED_WORD ("bitand");
862 UNSET_RESERVED_WORD ("bitor");
863 UNSET_RESERVED_WORD ("compl");
864 UNSET_RESERVED_WORD ("not");
865 UNSET_RESERVED_WORD ("not_eq");
866 UNSET_RESERVED_WORD ("or");
867 UNSET_RESERVED_WORD ("or_eq");
868 UNSET_RESERVED_WORD ("xor");
869 UNSET_RESERVED_WORD ("xor_eq");
872 token_count = init_cpp_parse ();
873 interface_unknown = 1;
882 cpp_finish (&parse_in);
883 errorcount += parse_in.errors;
890 reinit_parse_for_function ()
892 current_base_init_list = NULL_TREE;
893 current_member_init_list = NULL_TREE;
900 yyprint (file, yychar, yylval)
913 case IDENTIFIER_DEFN:
917 case PRE_PARSED_CLASS_DECL:
919 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
921 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
924 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
925 if (IDENTIFIER_POINTER (t))
926 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
930 if (yylval.ttype == class_type_node)
931 fprintf (file, " `class'");
932 else if (yylval.ttype == record_type_node)
933 fprintf (file, " `struct'");
934 else if (yylval.ttype == union_type_node)
935 fprintf (file, " `union'");
936 else if (yylval.ttype == enum_type_node)
937 fprintf (file, " `enum'");
938 else if (yylval.ttype == signature_type_node)
939 fprintf (file, " `signature'");
941 my_friendly_abort (80);
946 if (TREE_CODE (t) == INTEGER_CST)
948 #if HOST_BITS_PER_WIDE_INT == 64
949 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
952 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
959 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
965 TREE_INT_CST_HIGH (t), TREE_INT_CST_LOW (t));
970 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
971 static int *reduce_count;
977 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
978 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
981 #ifdef GATHER_STATISTICS
987 reduce_count[yyn] += 1;
994 return reduce_count[*q] - reduce_count[*p];
1001 return token_count[*q] - token_count[*p];
1007 print_parse_statistics ()
1009 #ifdef GATHER_STATISTICS
1010 #ifdef REDUCE_LENGTH
1013 int maxlen = REDUCE_LENGTH;
1016 if (reduce_count[-1] == 0)
1019 if (TOKEN_LENGTH > REDUCE_LENGTH)
1020 maxlen = TOKEN_LENGTH;
1021 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1023 for (i = 0; i < TOKEN_LENGTH; i++)
1025 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1026 for (i = 0; i < TOKEN_LENGTH; i++)
1028 int idx = sorted[i];
1029 if (token_count[idx] == 0)
1031 if (token_count[idx] < token_count[-1])
1033 fprintf (stderr, "token %d, `%s', count = %d\n",
1034 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
1036 fprintf (stderr, "\n");
1037 for (i = 0; i < REDUCE_LENGTH; i++)
1039 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1040 for (i = 0; i < REDUCE_LENGTH; i++)
1042 int idx = sorted[i];
1043 if (reduce_count[idx] == 0)
1045 if (reduce_count[idx] < reduce_count[-1])
1047 fprintf (stderr, "rule %d, line %d, count = %d\n",
1048 idx, yyrline[idx], reduce_count[idx]);
1050 fprintf (stderr, "\n");
1056 /* Sets the value of the 'yydebug' variable to VALUE.
1057 This is a function so we don't have to have YYDEBUG defined
1058 in order to build the compiler. */
1068 warning ("YYDEBUG not defined.");
1073 /* Functions and data structures for #pragma interface.
1075 `#pragma implementation' means that the main file being compiled
1076 is considered to implement (provide) the classes that appear in
1077 its main body. I.e., if this is file "foo.cc", and class `bar'
1078 is defined in "foo.cc", then we say that "foo.cc implements bar".
1080 All main input files "implement" themselves automagically.
1082 `#pragma interface' means that unless this file (of the form "foo.h"
1083 is not presently being included by file "foo.cc", the
1084 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1085 of the vtables nor any of the inline functions defined in foo.h
1086 will ever be output.
1088 There are cases when we want to link files such as "defs.h" and
1089 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1090 and "main.cc" has `#pragma implementation "defs.h"'. */
1095 struct impl_files *next;
1098 static struct impl_files *impl_file_chain;
1100 /* Helper function to load global variables with interface
1104 extract_interface_info ()
1108 if (flag_alt_external_templates)
1110 struct tinst_level *til = tinst_for_decl ();
1113 fileinfo = get_time_identifier (til->file);
1116 fileinfo = get_time_identifier (input_filename);
1117 fileinfo = TIME_IDENTIFIER_FILEINFO (fileinfo);
1118 interface_only = TREE_INT_CST_LOW (fileinfo);
1119 interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1122 /* Return nonzero if S is not considered part of an
1123 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1126 interface_strcmp (s)
1129 /* Set the interface/implementation bits for this scope. */
1130 struct impl_files *ifiles;
1133 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1135 const char *t1 = ifiles->filename;
1138 if (*s1 != *t1 || *s1 == 0)
1141 while (*s1 == *t1 && *s1 != 0)
1148 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1149 if (index (s1, '.') || index (t1, '.'))
1152 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1164 cp_pragma_interface (main_filename)
1165 char *main_filename;
1168 = TIME_IDENTIFIER_FILEINFO (get_time_identifier (input_filename));
1170 if (impl_file_chain == 0)
1172 /* If this is zero at this point, then we are
1173 auto-implementing. */
1174 if (main_input_filename == 0)
1175 main_input_filename = input_filename;
1177 #ifdef AUTO_IMPLEMENT
1178 filename = file_name_nondirectory (main_input_filename);
1179 fi = get_time_identifier (filename);
1180 fi = TIME_IDENTIFIER_FILEINFO (fi);
1181 TREE_INT_CST_LOW (fi) = 0;
1182 TREE_INT_CST_HIGH (fi) = 1;
1184 impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
1185 impl_file_chain->filename = filename;
1186 impl_file_chain->next = 0;
1190 interface_only = interface_strcmp (main_filename);
1191 #ifdef MULTIPLE_SYMBOL_SPACES
1192 if (! interface_only)
1193 interface_unknown = 0;
1194 #else /* MULTIPLE_SYMBOL_SPACES */
1195 interface_unknown = 0;
1196 #endif /* MULTIPLE_SYMBOL_SPACES */
1197 TREE_INT_CST_LOW (fileinfo) = interface_only;
1198 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
1202 cp_pragma_implementation (main_filename)
1203 char *main_filename;
1206 = TIME_IDENTIFIER_FILEINFO (get_time_identifier (input_filename));
1208 if (impl_file_chain)
1210 struct impl_files *ifiles = impl_file_chain;
1213 if (! strcmp (ifiles->filename, main_filename))
1215 ifiles = ifiles->next;
1219 ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
1220 ifiles->filename = main_filename;
1221 ifiles->next = impl_file_chain;
1222 impl_file_chain = ifiles;
1225 else if ((main_input_filename != 0
1226 && ! strcmp (main_input_filename, input_filename))
1227 || ! strcmp (main_filename, input_filename))
1229 impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
1230 impl_file_chain->filename = main_filename;
1231 impl_file_chain->next = 0;
1234 error ("`#pragma implementation' can only appear at top-level");
1237 /* We make this non-zero so that we infer decl linkage
1238 in the impl file only for variables first declared
1239 in the interface file. */
1240 interface_unknown = 1;
1242 /* We make this zero so that templates in the impl
1243 file will be emitted properly. */
1244 interface_unknown = 0;
1246 TREE_INT_CST_LOW (fileinfo) = interface_only;
1247 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
1250 /* Set up the state required to correctly handle the definition of the
1251 inline function whose preparsed state has been saved in PI. */
1254 begin_definition_of_inclass_inline (pi)
1255 struct pending_inline* pi;
1262 /* If this is an inline function in a local class, we must make sure
1263 that we save all pertinent information about the function
1264 surrounding the local class. */
1265 context = hack_decl_function_context (pi->fndecl);
1267 push_cp_function_context (context);
1269 feed_input (pi->buf, pi->len, pi->filename, pi->lineno);
1270 yychar = PRE_PARSED_FUNCTION_DECL;
1271 yylval.ttype = build_tree_list ((tree) pi, pi->fndecl);
1272 /* Pass back a handle to the rest of the inline functions, so that they
1273 can be processed later. */
1274 DECL_PENDING_INLINE_INFO (pi->fndecl) = 0;
1275 interface_unknown = pi->interface == 1;
1276 interface_only = pi->interface == 0;
1279 /* Called from the top level: if there are any pending inlines to
1280 do, set up to process them now. This function sets up the first function
1281 to be parsed; after it has been, the rule for fndef in parse.y will
1282 call process_next_inline to start working on the next one. */
1285 do_pending_inlines ()
1287 struct pending_inline *t;
1289 /* Oops, we're still dealing with the last batch. */
1290 if (yychar == PRE_PARSED_FUNCTION_DECL)
1293 /* Reverse the pending inline functions, since
1294 they were cons'd instead of appended. */
1296 struct pending_inline *prev = 0, *tail;
1297 t = pending_inlines;
1298 pending_inlines = 0;
1313 /* Now start processing the first inline function. */
1314 begin_definition_of_inclass_inline (t);
1317 /* Called from the fndecl rule in the parser when the function just parsed
1318 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1319 do_pending_inlines). */
1322 process_next_inline (t)
1326 struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
1327 context = hack_decl_function_context (i->fndecl);
1329 pop_cp_function_context (context);
1331 if (yychar == YYEMPTY)
1333 if (yychar != END_OF_SAVED_INPUT)
1335 error ("parse error at end of saved function text");
1337 /* restore_pending_input will abort unless yychar is either
1338 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1339 hosed, feed back YYEMPTY. */
1344 begin_definition_of_inclass_inline (i);
1346 extract_interface_info ();
1349 /* Since inline methods can refer to text which has not yet been seen,
1350 we store the text of the method in a structure which is placed in the
1351 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1352 After parsing the body of the class definition, the FUNCTION_DECL's are
1353 scanned to see which ones have this field set. Those are then digested
1356 This function's FUNCTION_DECL will have a bit set in its common so
1357 that we know to watch out for it. */
1360 consume_string (this_obstack, matching_char)
1361 register struct obstack *this_obstack;
1365 int starting_lineno;
1368 if (cpp_token == CPP_STRING)
1370 /* The C preprocessor will warn about newlines in strings. */
1371 obstack_grow (this_obstack, yy_cur, (yy_lim - yy_cur));
1373 lineno = parse_in.lineno;
1378 starting_lineno = lineno;
1384 int save_lineno = lineno;
1385 lineno = starting_lineno;
1386 if (matching_char == '"')
1387 error ("end of file encountered inside string constant");
1389 error ("end of file encountered inside character constant");
1390 lineno = save_lineno;
1395 obstack_1grow (this_obstack, c);
1397 obstack_1grow (this_obstack, c);
1399 /* Make sure we continue the loop */
1406 pedwarn ("ANSI C++ forbids newline in string constant");
1409 obstack_1grow (this_obstack, c);
1411 while (c != matching_char);
1414 struct pending_input {
1417 struct obstack token_obstack;
1421 struct pending_input *
1422 save_pending_input ()
1424 struct pending_input *p;
1425 p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1428 p->eof = end_of_file;
1430 p->first_token = first_token;
1431 p->token_obstack = token_obstack;
1434 gcc_obstack_init (&token_obstack);
1440 restore_pending_input (p)
1441 struct pending_input *p;
1443 my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1446 first_token = p->first_token;
1447 obstack_free (&token_obstack, (char *) 0);
1448 token_obstack = p->token_obstack;
1449 end_of_file = p->eof;
1453 /* Unget character CH from the input stream.
1454 If RESCAN is non-zero, then we want to `see' this
1455 character as the next input token. */
1458 yyungetc (ch, rescan)
1462 /* Unget a character from the input stream. */
1463 if (yychar == YYEMPTY || rescan == 0)
1465 /* If we're putting back a brace, undo the change in indent_level
1466 from the first time we saw it. */
1481 clear_inline_text_obstack ()
1483 obstack_free (&inline_text_obstack, inline_text_firstobj);
1486 /* This function stores away the text for an inline function that should
1487 be processed later. It decides how much later, and may need to move
1488 the info between obstacks; therefore, the caller should not refer to
1489 the T parameter after calling this function. */
1492 store_pending_inline (decl, t)
1494 struct pending_inline *t;
1497 DECL_PENDING_INLINE_INFO (decl) = t;
1499 /* Because we use obstacks, we must process these in precise order. */
1500 t->next = pending_inlines;
1501 pending_inlines = t;
1505 reinit_parse_for_method (yychar, decl)
1510 int starting_lineno = lineno;
1511 char *starting_filename = input_filename;
1513 reinit_parse_for_block (yychar, &inline_text_obstack);
1515 len = obstack_object_size (&inline_text_obstack);
1516 current_base_init_list = NULL_TREE;
1517 current_member_init_list = NULL_TREE;
1518 if (decl == void_type_node
1519 || (current_class_type && TYPE_REDEFINED (current_class_type)))
1521 /* Happens when we get two declarations of the same
1522 function in the same scope. */
1523 char *buf = obstack_finish (&inline_text_obstack);
1524 obstack_free (&inline_text_obstack, buf);
1529 struct pending_inline *t;
1530 char *buf = obstack_finish (&inline_text_obstack);
1532 t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1533 sizeof (struct pending_inline));
1534 t->lineno = starting_lineno;
1535 t->filename = starting_filename;
1542 if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
1543 warn_if_unknown_interface (decl);
1545 t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1546 store_pending_inline (decl, t);
1550 /* Consume a block -- actually, a method beginning
1551 with `:' or `{' -- and save it away on the specified obstack. */
1554 reinit_parse_for_block (pyychar, obstackp)
1556 struct obstack *obstackp;
1560 int starting_lineno = lineno;
1561 char *starting_filename = input_filename;
1563 int look_for_semicolon = 0;
1564 int look_for_lbrac = 0;
1568 obstack_1grow (obstackp, '{');
1569 /* We incremented indent_level in yylex; undo that. */
1572 else if (pyychar == '=')
1573 look_for_semicolon = 1;
1574 else if (pyychar == ':')
1576 obstack_1grow (obstackp, pyychar);
1577 /* Add a space so we don't get confused by ': ::A(20)'. */
1578 obstack_1grow (obstackp, ' ');
1582 else if (pyychar == RETURN_KEYWORD)
1584 obstack_grow (obstackp, "return", 6);
1588 else if (pyychar == TRY)
1590 obstack_grow (obstackp, "try", 3);
1596 yyerror ("parse error in method specification");
1597 obstack_1grow (obstackp, '{');
1604 int this_lineno = lineno;
1606 c = skip_white_space (c);
1608 /* Don't lose our cool if there are lots of comments. */
1609 if (lineno == this_lineno + 1)
1610 obstack_1grow (obstackp, '\n');
1611 else if (lineno == this_lineno)
1613 else if (lineno - this_lineno < 10)
1616 for (i = lineno - this_lineno; i > 0; i--)
1617 obstack_1grow (obstackp, '\n');
1622 sprintf (buf, "\n# %d \"", lineno);
1624 obstack_grow (obstackp, buf, len);
1626 len = strlen (input_filename);
1627 obstack_grow (obstackp, input_filename, len);
1628 obstack_1grow (obstackp, '\"');
1629 obstack_1grow (obstackp, '\n');
1632 while (c > ' ') /* ASCII dependent... */
1634 obstack_1grow (obstackp, c);
1643 if (blev == 0 && !look_for_semicolon)
1647 if (peekyylex () == CATCH)
1650 obstack_grow (obstackp, " catch ", 7);
1667 /* Don't act on the next character...e.g, doing an escaped
1672 error_with_file_and_line (starting_filename,
1674 "end of file read inside definition");
1677 obstack_1grow (obstackp, c);
1680 consume_string (obstackp, c);
1682 consume_string (obstackp, c);
1687 error ("function body for constructor missing");
1688 obstack_1grow (obstackp, '{');
1689 obstack_1grow (obstackp, '}');
1693 else if (look_for_semicolon && blev == 0)
1701 error_with_file_and_line (starting_filename,
1703 "end of file read inside definition");
1708 obstack_1grow (obstackp, c);
1713 obstack_1grow (obstackp, '\0');
1716 /* Consume a no-commas expression -- actually, a default argument -- and
1717 save it away on the specified obstack. */
1720 reinit_parse_for_expr (obstackp)
1721 struct obstack *obstackp;
1724 int starting_lineno = lineno;
1725 char *starting_filename = input_filename;
1733 int this_lineno = lineno;
1735 c = skip_white_space (c);
1737 /* Don't lose our cool if there are lots of comments. */
1738 if (lineno == this_lineno + 1)
1739 obstack_1grow (obstackp, '\n');
1740 else if (lineno == this_lineno)
1742 else if (lineno - this_lineno < 10)
1745 for (i = lineno - this_lineno; i > 0; --i)
1746 obstack_1grow (obstackp, '\n');
1751 sprintf (buf, "\n# %d \"", lineno);
1753 obstack_grow (obstackp, buf, len);
1755 len = strlen (input_filename);
1756 obstack_grow (obstackp, input_filename, len);
1757 obstack_1grow (obstackp, '\"');
1758 obstack_1grow (obstackp, '\n');
1761 while (c > ' ') /* ASCII dependent... */
1763 if (plev <= 0 && (c == ')' || c == ','))
1768 obstack_1grow (obstackp, c);
1769 if (c == '(' || c == '[')
1771 else if (c == ']' || c == ')')
1775 /* Don't act on the next character...e.g, doing an escaped
1780 error_with_file_and_line (starting_filename,
1782 "end of file read inside definition");
1785 obstack_1grow (obstackp, c);
1788 consume_string (obstackp, c);
1790 consume_string (obstackp, c);
1796 error_with_file_and_line (starting_filename,
1798 "end of file read inside definition");
1803 obstack_1grow (obstackp, c);
1808 obstack_1grow (obstackp, '\0');
1811 int do_snarf_defarg;
1813 /* Decide whether the default argument we are about to see should be
1814 gobbled up as text for later parsing. */
1817 maybe_snarf_defarg ()
1819 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
1820 do_snarf_defarg = 1;
1823 /* When we see a default argument in a method declaration, we snarf it as
1824 text using snarf_defarg. When we get up to namespace scope, we then go
1825 through and parse all of them using do_pending_defargs. Since yacc
1826 parsers are not reentrant, we retain defargs state in these two
1827 variables so that subsequent calls to do_pending_defargs can resume
1828 where the previous call left off. */
1840 reinit_parse_for_expr (&inline_text_obstack);
1841 len = obstack_object_size (&inline_text_obstack);
1842 buf = obstack_finish (&inline_text_obstack);
1844 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1845 arg = make_node (DEFAULT_ARG);
1846 DEFARG_LENGTH (arg) = len - 1;
1847 DEFARG_POINTER (arg) = buf;
1853 /* Called from grokfndecl to note a function decl with unparsed default
1854 arguments for later processing. Also called from grokdeclarator
1855 for function types with unparsed defargs; the call from grokfndecl
1856 will always come second, so we can overwrite the entry from the type. */
1859 add_defarg_fn (decl)
1862 if (TREE_CODE (decl) == FUNCTION_DECL)
1863 TREE_VALUE (defarg_fns) = decl;
1866 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1867 defarg_fns = tree_cons (current_class_type, decl, defarg_fns);
1872 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1878 tree d = TREE_PURPOSE (p);
1881 if (TREE_CODE (f) == FUNCTION_DECL)
1883 line = DECL_SOURCE_LINE (f);
1884 file = DECL_SOURCE_FILE (f);
1889 file = input_filename;
1892 feed_input (DEFARG_POINTER (d), DEFARG_LENGTH (d), file, line);
1893 yychar = DEFARG_MARKER;
1897 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1902 if (yychar == YYEMPTY)
1904 if (yychar != END_OF_SAVED_INPUT)
1906 error ("parse error at end of saved function text");
1908 /* restore_pending_input will abort unless yychar is either
1909 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1910 hosed, feed back YYEMPTY. */
1916 /* Main function for deferred parsing of default arguments. Called from
1920 do_pending_defargs ()
1925 for (; defarg_fns; defarg_fns = TREE_CHAIN (defarg_fns))
1927 tree defarg_fn = TREE_VALUE (defarg_fns);
1928 if (defarg_parm == NULL_TREE)
1930 push_nested_class (TREE_PURPOSE (defarg_fns), 1);
1932 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1933 maybe_begin_member_template_processing (defarg_fn);
1935 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1939 for (p = DECL_ARGUMENTS (defarg_fn); p; p = TREE_CHAIN (p))
1940 pushdecl (copy_node (p));
1942 defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
1945 defarg_parm = TYPE_ARG_TYPES (defarg_fn);
1948 defarg_parm = TREE_CHAIN (defarg_parm);
1950 for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
1951 if (TREE_PURPOSE (defarg_parm)
1952 && TREE_CODE (TREE_PURPOSE (defarg_parm)) == DEFAULT_ARG)
1954 feed_defarg (defarg_fn, defarg_parm);
1956 /* Return to the parser, which will process this defarg
1957 and call us again. */
1961 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1963 maybe_end_member_template_processing ();
1964 check_default_args (defarg_fn);
1968 pop_nested_class ();
1972 /* Build a default function named NAME for type TYPE.
1973 KIND says what to build.
1975 When KIND == 0, build default destructor.
1976 When KIND == 1, build virtual destructor.
1977 When KIND == 2, build default constructor.
1978 When KIND == 3, build default X(const X&) constructor.
1979 When KIND == 4, build default X(X&) constructor.
1980 When KIND == 5, build default operator = (const X&).
1981 When KIND == 6, build default operator = (X&). */
1984 cons_up_default_function (type, full_name, kind)
1985 tree type, full_name;
1988 tree declspecs = NULL_TREE;
1989 tree fn, args = NULL_TREE;
1992 tree name = constructor_name (full_name);
1998 declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
1999 /* Fall through... */
2001 name = build_parse_node (BIT_NOT_EXPR, name);
2002 args = void_list_node;
2006 /* Default constructor. */
2007 args = void_list_node;
2011 type = build_qualified_type (type, TYPE_QUAL_CONST);
2012 /* Fall through... */
2014 /* According to ARM $12.8, the default copy ctor will be declared, but
2015 not defined, unless it's needed. */
2016 argtype = build_reference_type (type);
2017 args = tree_cons (NULL_TREE,
2018 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
2019 get_identifier ("_ctor_arg")),
2026 declspecs = build_decl_list (NULL_TREE, type);
2029 type = build_qualified_type (type, TYPE_QUAL_CONST);
2031 name = ansi_opname [(int) MODIFY_EXPR];
2033 argtype = build_reference_type (type);
2034 args = tree_cons (NULL_TREE,
2035 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
2036 get_identifier ("_ctor_arg")),
2041 my_friendly_abort (59);
2044 declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE],
2047 TREE_PARMLIST (args) = 1;
2050 tree declarator = make_call_declarator (name, args, NULL_TREE, NULL_TREE);
2052 declarator = build_parse_node (ADDR_EXPR, declarator);
2054 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
2057 if (fn == void_type_node)
2061 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn)));
2064 if (processing_template_defn)
2066 SET_DECL_IMPLICIT_INSTANTIATION (fn);
2067 repo_template_used (fn);
2072 if (CLASSTYPE_INTERFACE_KNOWN (type))
2074 DECL_INTERFACE_KNOWN (fn) = 1;
2075 DECL_NOT_REALLY_EXTERN (fn) = (!CLASSTYPE_INTERFACE_ONLY (type)
2076 && flag_implement_inlines);
2080 DECL_NOT_REALLY_EXTERN (fn) = 1;
2082 mark_inline_for_output (fn);
2084 #ifdef DEBUG_DEFAULT_FUNCTIONS
2085 { char *fn_type = NULL;
2089 case 0: fn_type = "default destructor"; break;
2090 case 1: fn_type = "virtual destructor"; break;
2091 case 2: fn_type = "default constructor"; break;
2092 case 3: fn_type = "default X(const X&)"; break;
2093 case 4: fn_type = "default X(X&)"; break;
2097 if (TREE_CODE (name) == BIT_NOT_EXPR)
2098 t = TREE_OPERAND (name, 0);
2099 fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
2100 IDENTIFIER_POINTER (t), func_buf);
2103 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2105 /* Show that this function was generated by the compiler. */
2106 SET_DECL_ARTIFICIAL (fn);
2111 /* Heuristic to tell whether the user is missing a semicolon
2112 after a struct or enum declaration. Emit an error message
2113 if we know the user has blown it. */
2116 check_for_missing_semicolon (type)
2124 && yychar != IDENTIFIER
2125 && yychar != TYPENAME
2126 && yychar != CV_QUALIFIER
2127 && yychar != SELFNAME)
2130 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2131 error ("semicolon missing after %s declaration",
2132 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2134 cp_error ("semicolon missing after declaration of `%T'", type);
2135 shadow_tag (build_tree_list (0, type));
2137 /* Could probably also hack cases where class { ... } f (); appears. */
2142 note_got_semicolon (type)
2145 if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
2146 my_friendly_abort (60);
2147 if (CLASS_TYPE_P (type))
2148 CLASSTYPE_GOT_SEMICOLON (type) = 1;
2152 note_list_got_semicolon (declspecs)
2157 for (link = declspecs; link; link = TREE_CHAIN (link))
2159 tree type = TREE_VALUE (link);
2160 if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
2161 note_got_semicolon (type);
2166 /* Iff C is a carriage return, warn about it - if appropriate -
2167 and return nonzero. */
2172 static int newline_warning = 0;
2176 /* ANSI C says the effects of a carriage return in a source file
2178 if (pedantic && !newline_warning)
2180 warning ("carriage return in source file");
2181 warning ("(we only warn about the first carriage return)");
2182 newline_warning = 1;
2189 /* If C is not whitespace, return C.
2190 Otherwise skip whitespace and return first nonwhite char read. */
2193 skip_white_space (c)
2200 /* We don't recognize comments here, because
2201 cpp output can include / and * consecutively as operators.
2202 Also, there's no need, since cpp removes all comments. */
2210 c = check_newline ();
2219 /* While processing a # directive we don't get CPP_HSPACE
2220 tokens, so we also need to handle whitespace the normal way. */
2221 if (cpp_token == CPP_HSPACE)
2222 c = yy_get_token ();
2238 error ("stray '\\' in program");
2248 /* Make the token buffer longer, preserving the data in it.
2249 P should point to just beyond the last valid character in the old buffer.
2250 The value we return is a pointer to the new buffer
2251 at a place corresponding to P. */
2254 extend_token_buffer_to (size)
2258 maxtoken = maxtoken * 2 + 10;
2259 while (maxtoken < size);
2260 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2264 extend_token_buffer (p)
2267 int offset = p - token_buffer;
2268 extend_token_buffer_to (offset);
2269 return token_buffer + offset;
2272 #if defined HANDLE_PRAGMA
2273 /* Local versions of these macros, that can be passed as function pointers. */
2289 read_line_number (num)
2292 register int token = real_yylex ();
2294 if (token == CONSTANT
2295 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2297 *num = TREE_INT_CST_LOW (yylval.ttype);
2302 if (token != END_OF_LINE)
2303 error ("invalid #-line");
2308 /* At the beginning of a line, increment the line number
2309 and process any #-directive on this line.
2310 If the line is a #-directive, read the entire line and return a newline.
2311 Otherwise, return the line's first non-whitespace character.
2313 Note that in the case of USE_CPPLIB, we get the whole line as one
2314 CPP_DIRECTIVE token. */
2322 enum { act_none, act_push, act_pop } action;
2323 int old_lineno, action_number, l;
2324 int entering_c_header;
2327 /* Read first nonwhite char on the line. Do this before incrementing the
2328 line number, in case we're at the end of saved text. */
2332 /* In some cases where we're leaving an include file, we can get multiple
2333 CPP_HSPACE tokens in a row, so we need to loop. */
2334 while (cpp_token == CPP_HSPACE)
2335 c = yy_get_token ();
2339 while (c == ' ' || c == '\t');
2346 /* Sequences of multiple newlines are very common; optimize them. */
2350 /* If not #, return it so caller will use it. */
2354 /* Don't read beyond this line. */
2359 if (cpp_token == CPP_VSPACE)
2361 /* Format is "<space> <line number> <filename> <newline>".
2362 Only the line number is interesting, and even that
2363 we can get more efficiently than scanning the line. */
2364 yy_cur = yy_lim - 1;
2365 lineno = parse_in.lineno - 1;
2370 token = real_yylex ();
2372 if (token == IDENTIFIER)
2374 /* If a letter follows, then if the word here is `line', skip
2375 it and ignore it; otherwise, ignore the line, with an error
2376 if the word isn't `pragma'. */
2378 const char *name = IDENTIFIER_POINTER (yylval.ttype);
2380 if (!strcmp (name, "pragma"))
2382 token = real_yylex ();
2383 if (token != IDENTIFIER
2384 || TREE_CODE (yylval.ttype) != IDENTIFIER_NODE)
2387 /* If this is 1, we handled it; if it's -1, it was one we
2388 wanted but had something wrong with it. Only if it's
2389 0 was it not handled. */
2390 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval.ttype)))
2393 #ifdef HANDLE_PRAGMA
2394 /* We invoke HANDLE_PRAGMA before HANDLE_GENERIC_PRAGMAS
2395 (if both are defined), in order to give the back
2396 end a chance to override the interpretation of
2397 SYSV style pragmas. */
2398 if (HANDLE_PRAGMA (pragma_getc, pragma_ungetc,
2399 IDENTIFIER_POINTER (yylval.ttype)))
2401 #endif /* HANDLE_PRAGMA */
2403 #ifdef HANDLE_GENERIC_PRAGMAS
2404 if (handle_generic_pragma (token))
2406 #endif /* HANDLE_GENERIC_PRAGMAS */
2408 /* Issue a warning message if we have been asked to do so.
2409 Ignoring unknown pragmas in system header file unless
2410 an explcit -Wunknown-pragmas has been given. */
2411 if (warn_unknown_pragmas > 1
2412 || (warn_unknown_pragmas && ! in_system_header))
2413 warning ("ignoring pragma: %s", token_buffer);
2417 else if (!strcmp (name, "define"))
2419 debug_define (lineno, GET_DIRECTIVE_LINE ());
2422 else if (!strcmp (name, "undef"))
2424 debug_undef (lineno, GET_DIRECTIVE_LINE ());
2427 else if (!strcmp (name, "line"))
2430 token = real_yylex ();
2433 else if (!strcmp (name, "ident"))
2435 /* #ident. The pedantic warning is now in cccp.c. */
2437 /* Here we have just seen `#ident '.
2438 A string constant should follow. */
2440 token = real_yylex ();
2441 if (token == END_OF_LINE)
2444 || TREE_CODE (yylval.ttype) != STRING_CST)
2446 error ("invalid #ident");
2450 if (! flag_no_ident)
2452 #ifdef ASM_OUTPUT_IDENT
2453 ASM_OUTPUT_IDENT (asm_out_file,
2454 TREE_STRING_POINTER (yylval.ttype));
2458 /* Skip the rest of this line. */
2462 error ("undefined or invalid # directive `%s'", name);
2466 /* If the # is the only nonwhite char on the line,
2467 just ignore it. Check the new newline. */
2468 if (token == END_OF_LINE)
2472 /* Here we have either `#line' or `# <nonletter>'.
2473 In either case, it should be a line number; a digit should follow. */
2475 if (token != CONSTANT
2476 || TREE_CODE (yylval.ttype) != INTEGER_CST)
2478 error ("invalid #-line");
2482 /* subtract one, because it is the following line that
2483 gets the specified number */
2485 l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2487 /* More follows: it must be a string constant (filename).
2488 It would be neat to use cpplib to quickly process the string, but
2489 (1) we don't have a handy tokenization of the string, and
2490 (2) I don't know how well that would work in the presense
2491 of filenames that contain wide characters. */
2495 /* Don't treat \ as special if we are processing #line 1 "...".
2496 If you want it to be treated specially, use # 1 "...". */
2497 ignore_escape_flag = 1;
2500 /* Read the string constant. */
2501 token = real_yylex ();
2503 ignore_escape_flag = 0;
2505 if (token == END_OF_LINE)
2507 /* No more: store the line number and check following line. */
2512 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2514 error ("invalid #line");
2518 /* Changing files again. This means currently collected time
2519 is charged against header time, and body time starts back at 0. */
2520 if (flag_detailed_statistics)
2522 int this_time = my_get_run_time ();
2523 tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2524 header_time += this_time - body_time;
2525 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time))
2526 += this_time - body_time;
2527 this_filename_time = time_identifier;
2528 body_time = this_time;
2531 if (!TREE_PERMANENT (yylval.ttype))
2534 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
2535 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
2538 input_filename = TREE_STRING_POINTER (yylval.ttype);
2540 GNU_xref_file (input_filename);
2542 if (main_input_filename == 0)
2544 struct impl_files *ifiles = impl_file_chain;
2548 while (ifiles->next)
2549 ifiles = ifiles->next;
2550 ifiles->filename = file_name_nondirectory (input_filename);
2553 main_input_filename = input_filename;
2556 extract_interface_info ();
2558 old_lineno = lineno;
2563 /* Each change of file name
2564 reinitializes whether we are now in a system header. */
2565 in_system_header = 0;
2566 entering_c_header = 0;
2568 if (!read_line_number (&action_number))
2570 /* Update the name in the top element of input_file_stack. */
2571 if (input_file_stack)
2572 input_file_stack->name = input_filename;
2575 /* `1' after file name means entering new file.
2576 `2' after file name means just left a file. */
2578 if (action_number == 1)
2581 read_line_number (&action_number);
2583 else if (action_number == 2)
2586 read_line_number (&action_number);
2588 if (action_number == 3)
2590 /* `3' after file name means this is a system header file. */
2591 in_system_header = 1;
2592 read_line_number (&action_number);
2594 if (action_number == 4)
2596 /* `4' after file name means this is a C header file. */
2597 entering_c_header = 1;
2598 read_line_number (&action_number);
2601 /* Do the actions implied by the preceding numbers. */
2603 if (action == act_push)
2605 /* Pushing to a new file. */
2606 struct file_stack *p
2607 = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2608 input_file_stack->line = old_lineno;
2609 p->next = input_file_stack;
2610 p->name = input_filename;
2611 p->indent_level = indent_level;
2612 input_file_stack = p;
2613 input_file_stack_tick++;
2614 debug_start_source_file (input_filename);
2617 else if (entering_c_header)
2620 ++pending_lang_change;
2623 else if (action == act_pop)
2625 /* Popping out of a file. */
2626 if (input_file_stack->next)
2628 struct file_stack *p = input_file_stack;
2630 if (c_header_level && --c_header_level == 0)
2632 if (entering_c_header)
2633 warning ("badly nested C headers from preprocessor");
2634 --pending_lang_change;
2637 if (indent_level != p->indent_level)
2639 warning_with_file_and_line
2640 (p->name, old_lineno,
2641 "This file contains more `%c's than `%c's.",
2642 indent_level > p->indent_level ? '{' : '}',
2643 indent_level > p->indent_level ? '}' : '{');
2645 input_file_stack = p->next;
2647 input_file_stack_tick++;
2648 debug_end_source_file (input_file_stack->line);
2651 error ("#-lines for entering and leaving files don't match");
2654 /* Now that we've pushed or popped the input stack,
2655 update the name in the top element. */
2656 if (input_file_stack)
2657 input_file_stack->name = input_filename;
2659 /* skip the rest of this line. */
2666 while (c != '\n' && c != EOF);
2670 #ifdef HANDLE_GENERIC_PRAGMAS
2672 /* Handle a #pragma directive.
2673 TOKEN is the token we read after `#pragma'. Processes the entire input
2674 line and return non-zero iff the pragma has been successfully parsed. */
2676 /* This function has to be in this file, in order to get at
2680 handle_generic_pragma (token)
2691 handle_pragma_token (token_buffer, yylval.ttype);
2695 handle_pragma_token ("(", NULL_TREE);
2696 handle_pragma_token (")", NULL_TREE);
2700 return handle_pragma_token (NULL_PTR, NULL_TREE);
2703 handle_pragma_token (token_buffer, NULL_TREE);
2706 token = real_yylex ();
2709 #endif /* HANDLE_GENERIC_PRAGMAS */
2712 handle_cp_pragma (pname)
2717 if (! strcmp (pname, "vtable"))
2719 extern tree pending_vtables;
2721 /* More follows: it must be a string constant (class name). */
2722 token = real_yylex ();
2723 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2725 error ("invalid #pragma vtable");
2730 = perm_tree_cons (NULL_TREE,
2731 get_identifier (TREE_STRING_POINTER (yylval.ttype)),
2733 token = real_yylex ();
2734 if (token != END_OF_LINE)
2735 warning ("trailing characters ignored");
2738 else if (! strcmp (pname, "unit"))
2740 /* More follows: it must be a string constant (unit name). */
2741 token = real_yylex ();
2742 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2744 error ("invalid #pragma unit");
2747 token = real_yylex ();
2748 if (token != END_OF_LINE)
2749 warning ("trailing characters ignored");
2752 else if (! strcmp (pname, "interface"))
2754 char *main_filename = input_filename;
2756 main_filename = file_name_nondirectory (main_filename);
2758 token = real_yylex ();
2760 if (token != END_OF_LINE)
2763 || TREE_CODE (yylval.ttype) != STRING_CST)
2765 error ("invalid `#pragma interface'");
2768 main_filename = TREE_STRING_POINTER (yylval.ttype);
2769 token = real_yylex ();
2772 if (token != END_OF_LINE)
2773 warning ("garbage after `#pragma interface' ignored");
2775 cp_pragma_interface (main_filename);
2779 else if (! strcmp (pname, "implementation"))
2781 char *main_filename = main_input_filename ? main_input_filename : input_filename;
2783 main_filename = file_name_nondirectory (main_filename);
2785 token = real_yylex ();
2787 if (token != END_OF_LINE)
2790 || TREE_CODE (yylval.ttype) != STRING_CST)
2792 error ("invalid `#pragma implementation'");
2795 main_filename = TREE_STRING_POINTER (yylval.ttype);
2796 token = real_yylex ();
2799 if (token != END_OF_LINE)
2800 warning ("garbage after `#pragma implementation' ignored");
2802 cp_pragma_implementation (main_filename);
2811 do_pending_lang_change ()
2813 for (; pending_lang_change > 0; --pending_lang_change)
2814 push_lang_context (lang_name_c);
2815 for (; pending_lang_change < 0; ++pending_lang_change)
2816 pop_lang_context ();
2819 #define ENDFILE -1 /* token that represents end-of-file */
2821 /* Read an escape sequence, returning its equivalent as a character,
2822 or store 1 in *ignore_ptr if it is backslash-newline. */
2825 readescape (ignore_ptr)
2828 register int c = getch ();
2830 register unsigned count;
2831 unsigned firstdig = 0;
2849 if (c >= 'a' && c <= 'f')
2850 code += c - 'a' + 10;
2851 if (c >= 'A' && c <= 'F')
2852 code += c - 'A' + 10;
2853 if (c >= '0' && c <= '9')
2855 if (code != 0 || count != 0)
2864 error ("\\x used with no following hex digits");
2865 else if (count == 0)
2866 /* Digits are all 0's. Ok. */
2868 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
2871 << (TYPE_PRECISION (integer_type_node)
2874 pedwarn ("hex escape out of range");
2877 case '0': case '1': case '2': case '3': case '4':
2878 case '5': case '6': case '7':
2881 while ((c <= '7') && (c >= '0') && (count++ < 3))
2883 code = (code * 8) + (c - '0');
2889 case '\\': case '\'': case '"':
2898 return TARGET_NEWLINE;
2921 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
2927 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2931 /* `\%' is used to prevent SCCS from getting confused. */
2934 pedwarn ("unknown escape sequence `\\%c'", c);
2938 pedwarn ("unknown escape sequence `\\%c'", c);
2940 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
2948 extern int end_of_file;
2951 strcpy (buf, string);
2953 /* We can't print string and character constants well
2954 because the token_buffer contains the result of processing escapes. */
2956 strcat (buf, input_redirected ()
2957 ? " at end of saved text"
2958 : " at end of input");
2959 else if (token_buffer[0] == 0)
2960 strcat (buf, " at null character");
2961 else if (token_buffer[0] == '"')
2962 strcat (buf, " before string constant");
2963 else if (token_buffer[0] == '\'')
2964 strcat (buf, " before character constant");
2965 else if (!ISGRAPH ((unsigned char)token_buffer[0]))
2966 sprintf (buf + strlen (buf), " before character 0%o",
2967 (unsigned char) token_buffer[0]);
2969 strcat (buf, " before `%s'");
2971 error (buf, token_buffer);
2974 /* Value is 1 (or 2) if we should try to make the next identifier look like
2975 a typename (when it may be a local variable or a class variable).
2976 Value is 0 if we treat this name in a default fashion. */
2977 int looking_for_typename;
2983 identifier_type (decl)
2987 if (TREE_CODE (decl) == TEMPLATE_DECL)
2989 if (TREE_CODE (DECL_RESULT (decl)) == TYPE_DECL)
2991 else if (looking_for_template)
2994 if (looking_for_template && really_overloaded_fn (decl))
2996 /* See through a baselink. */
2997 if (TREE_CODE (decl) == TREE_LIST)
2998 decl = TREE_VALUE (decl);
3000 for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
3001 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
3004 if (TREE_CODE (decl) == NAMESPACE_DECL)
3006 if (TREE_CODE (decl) != TYPE_DECL)
3008 if (DECL_ARTIFICIAL (decl) && TREE_TYPE (decl) == current_class_type)
3011 /* A constructor declarator for a template type will get here as an
3012 implicit typename, a TYPENAME_TYPE with a type. */
3014 if (t && TREE_CODE (t) == TYPENAME_TYPE)
3016 decl = TREE_TYPE (decl);
3017 if (TREE_CODE (decl) == TYPENAME_TYPE)
3018 decl = TREE_TYPE (decl);
3028 /* Only types expected, not even namespaces. */
3029 looking_for_typename = 2;
3031 if ((yychar = yylex ()) < 0) yychar = 0;
3032 looking_for_typename = 0;
3033 if (yychar == IDENTIFIER)
3035 lastiddecl = lookup_name (yylval.ttype, -2);
3036 if (lastiddecl == 0)
3039 lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
3042 yychar = identifier_type (lastiddecl);
3046 /* Return true if d is in a global scope. */
3053 switch (TREE_CODE (d))
3058 case OVERLOAD: d = OVL_FUNCTION (d); continue;
3059 case TREE_LIST: d = TREE_VALUE (d); continue;
3061 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (d)) == 'd', 980629);
3063 /* A template parameter is not really global, even though it
3064 has no enclosing scope. */
3065 if (DECL_TEMPLATE_PARM_P (d))
3068 d = CP_DECL_CONTEXT (d);
3069 return TREE_CODE (d) == NAMESPACE_DECL;
3074 do_identifier (token, parsing, args)
3075 register tree token;
3080 int lexing = (parsing == 1);
3081 int in_call = (parsing == 2);
3083 if (! lexing || IDENTIFIER_OPNAME_P (token))
3084 id = lookup_name (token, 0);
3088 /* Scope class declarations before global
3090 if ((!id || is_global (id))
3091 && current_class_type != 0
3092 && TYPE_SIZE (current_class_type) == 0)
3094 /* Could be from one of the base classes. */
3095 tree field = lookup_field (current_class_type, token, 1, 0);
3098 else if (field == error_mark_node)
3099 /* We have already generated the error message.
3100 But we still want to return this value. */
3101 id = lookup_field (current_class_type, token, 0, 0);
3102 else if (TREE_CODE (field) == VAR_DECL
3103 || TREE_CODE (field) == CONST_DECL
3104 || TREE_CODE (field) == TEMPLATE_DECL)
3106 else if (TREE_CODE (field) != FIELD_DECL)
3107 my_friendly_abort (61);
3110 cp_error ("invalid use of member `%D'", field);
3111 id = error_mark_node;
3116 /* Do Koenig lookup if appropriate (inside templates we build lookup
3117 expressions instead). */
3118 if (args && !current_template_parms && (!id || is_global (id)))
3119 /* If we have arguments and we only found global names, do Koenig
3121 id = lookup_arg_dependent (token, id, args);
3123 /* Remember that this name has been used in the class definition, as per
3126 /* Avoid breaking if we get called for a default argument that
3127 refers to an overloaded method. Eventually this will not be
3128 necessary, since default arguments shouldn't be parsed until
3129 after the class is complete. (jason 3/12/97) */
3130 && TREE_CODE (id) != OVERLOAD)
3131 maybe_note_name_used_in_class (token, id);
3133 if (id == error_mark_node)
3135 /* lookup_name quietly returns error_mark_node if we're parsing,
3136 as we don't want to complain about an identifier that ends up
3137 being used as a declarator. So we call it again to get the error
3139 id = lookup_name (token, 0);
3140 return error_mark_node;
3145 if (current_template_parms)
3146 return build_min_nt (LOOKUP_EXPR, token);
3147 else if (IDENTIFIER_OPNAME_P (token))
3149 if (token != ansi_opname[ERROR_MARK])
3150 cp_error ("`%D' not defined", token);
3151 id = error_mark_node;
3153 else if (in_call && ! flag_strict_prototype)
3155 id = implicitly_declare (token);
3157 else if (current_function_decl == 0)
3159 cp_error ("`%D' was not declared in this scope", token);
3160 id = error_mark_node;
3164 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
3165 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
3167 static int undeclared_variable_notice;
3169 cp_error ("`%D' undeclared (first use this function)", token);
3171 if (! undeclared_variable_notice)
3173 error ("(Each undeclared identifier is reported only once");
3174 error ("for each function it appears in.)");
3175 undeclared_variable_notice = 1;
3178 id = error_mark_node;
3179 /* Prevent repeated error messages. */
3180 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3181 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
3185 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
3187 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
3188 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
3189 && DECL_DEAD_FOR_LOCAL (shadowed))
3190 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
3192 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
3195 if (!DECL_ERROR_REPORTED (id))
3197 warning ("name lookup of `%s' changed",
3198 IDENTIFIER_POINTER (token));
3199 cp_warning_at (" matches this `%D' under current ANSI rules",
3201 cp_warning_at (" matches this `%D' under old rules", id);
3202 DECL_ERROR_REPORTED (id) = 1;
3206 else if (!DECL_ERROR_REPORTED (id))
3209 = "name lookup of `%s' changed for new ANSI `for' scoping";
3210 DECL_ERROR_REPORTED (id) = 1;
3211 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id)))
3213 error (msg, IDENTIFIER_POINTER (token));
3214 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
3215 id = error_mark_node;
3219 pedwarn (msg, IDENTIFIER_POINTER (token));
3220 cp_pedwarn_at (" using obsolete binding at `%D'", id);
3224 /* TREE_USED is set in `hack_identifier'. */
3225 if (TREE_CODE (id) == CONST_DECL)
3228 if (IDENTIFIER_CLASS_VALUE (token) == id)
3229 enforce_access (DECL_REAL_CONTEXT(id), id);
3230 if (!processing_template_decl || DECL_TEMPLATE_PARM_P (id))
3231 id = DECL_INITIAL (id);
3234 id = hack_identifier (id, token);
3236 /* We must look up dependent names when the template is
3237 instantiated, not while parsing it. For now, we don't
3238 distinguish between dependent and independent names. So, for
3239 example, we look up all overloaded functions at
3240 instantiation-time, even though in some cases we should just use
3241 the DECL we have here. We also use LOOKUP_EXPRs to find things
3242 like local variables, rather than creating TEMPLATE_DECLs for the
3243 local variables and then finding matching instantiations. */
3244 if (current_template_parms
3245 && (is_overloaded_fn (id)
3246 /* If it's not going to be around at instantiation time, we
3247 look it up then. This is a hack, and should go when we
3248 really get dependent/independent name lookup right. */
3249 || !TREE_PERMANENT (id)
3250 /* Some local VAR_DECLs (such as those for local variables
3251 in member functions of local classes) are built on the
3252 permanent obstack. */
3253 || (TREE_CODE (id) == VAR_DECL
3254 && CP_DECL_CONTEXT (id)
3255 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
3256 || TREE_CODE (id) == PARM_DECL
3257 || TREE_CODE (id) == RESULT_DECL
3258 || TREE_CODE (id) == USING_DECL))
3259 id = build_min_nt (LOOKUP_EXPR, token);
3265 do_scoped_id (token, parsing)
3270 /* during parsing, this is ::name. Otherwise, it is black magic. */
3273 struct tree_binding _b;
3274 id = binding_init (&_b);
3275 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
3278 id = BINDING_VALUE (id);
3281 id = IDENTIFIER_GLOBAL_VALUE (token);
3282 if (parsing && yychar == YYEMPTY)
3286 if (processing_template_decl)
3288 id = build_min_nt (LOOKUP_EXPR, token);
3289 LOOKUP_EXPR_GLOBAL (id) = 1;
3292 if (parsing && (yychar == '(' || yychar == LEFT_RIGHT)
3293 && ! flag_strict_prototype)
3294 id = implicitly_declare (token);
3297 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
3298 cp_error ("`::%D' undeclared (first use here)", token);
3299 id = error_mark_node;
3300 /* Prevent repeated error messages. */
3301 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3306 if (TREE_CODE (id) == ADDR_EXPR)
3307 mark_used (TREE_OPERAND (id, 0));
3308 else if (TREE_CODE (id) != OVERLOAD)
3311 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
3313 /* XXX CHS - should we set TREE_USED of the constant? */
3314 id = DECL_INITIAL (id);
3315 /* This is to prevent an enum whose value is 0
3316 from being considered a null pointer constant. */
3317 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
3318 TREE_CONSTANT (id) = 1;
3321 if (processing_template_decl)
3323 if (is_overloaded_fn (id))
3325 id = build_min_nt (LOOKUP_EXPR, token);
3326 LOOKUP_EXPR_GLOBAL (id) = 1;
3329 /* else just use the decl */
3331 return convert_from_reference (id);
3335 identifier_typedecl_value (node)
3339 type = IDENTIFIER_TYPE_VALUE (node);
3340 if (type == NULL_TREE)
3343 if (IDENTIFIER_BINDING (node))
3345 t = IDENTIFIER_VALUE (node);
3346 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
3349 if (IDENTIFIER_NAMESPACE_VALUE (node))
3351 t = IDENTIFIER_NAMESPACE_VALUE (node);
3352 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type)
3356 /* Will this one ever happen? */
3357 if (TYPE_MAIN_DECL (type))
3358 return TYPE_MAIN_DECL (type);
3360 /* We used to do an internal error of 62 here, but instead we will
3361 handle the return of a null appropriately in the callers. */
3375 int conversion_errno;
3376 REAL_VALUE_TYPE value;
3383 struct pf_args * args = (struct pf_args *) data;
3384 int fflag = 0, lflag = 0;
3385 /* Copy token_buffer now, while it has just the number
3386 and not the suffixes; once we add `f' or `i',
3387 REAL_VALUE_ATOF may not work any more. */
3388 char *copy = (char *) alloca (args->p - token_buffer + 1);
3389 bcopy (token_buffer, copy, args->p - token_buffer + 1);
3391 args->conversion_errno = 0;
3392 args->type = double_type_node;
3398 /* Read the suffixes to choose a data type. */
3403 error ("more than one `f' in numeric constant");
3409 error ("more than one `l' in numeric constant");
3415 error ("more than one `i' or `j' in numeric constant");
3417 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3428 if (args->p >= token_buffer + maxtoken - 3)
3429 args->p = extend_token_buffer (args->p);
3430 *(args->p++) = args->c;
3435 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3436 tells the desired precision of the binary result
3437 of decimal-to-binary conversion. */
3442 error ("both `f' and `l' in floating constant");
3444 args->type = float_type_node;
3446 if (args->base == 16)
3447 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
3449 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
3450 args->conversion_errno = errno;
3451 /* A diagnostic is required here by some ANSI C testsuites.
3452 This is not pedwarn, because some people don't want
3453 an error for this. */
3454 if (REAL_VALUE_ISINF (args->value) && pedantic)
3455 warning ("floating point number exceeds range of `float'");
3459 args->type = long_double_type_node;
3461 if (args->base == 16)
3462 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
3464 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
3465 args->conversion_errno = errno;
3466 if (REAL_VALUE_ISINF (args->value) && pedantic)
3467 warning ("floating point number exceeds range of `long double'");
3472 if (args->base == 16)
3473 args->value = REAL_VALUE_HTOF (copy, TYPE_MODE (args->type));
3475 args->value = REAL_VALUE_ATOF (copy, TYPE_MODE (args->type));
3476 args->conversion_errno = errno;
3477 if (REAL_VALUE_ISINF (args->value) && pedantic)
3478 warning ("floating point number exceeds range of `double'");
3482 /* Get the next character, staying within the current token if possible.
3483 If we're lexing a token, we don't want to look beyond the end of the
3484 token cpplib has prepared for us; otherwise, we end up reading in the
3485 next token, which screws up feed_input. So just return a null
3492 if (yy_cur == yy_lim)
3509 /* Read a single token from the input stream, and assign it lexical
3512 Note: We used to do token pasting here, to produce compound tokens like
3513 LEFT_RIGHT and EXTERN_LANG_STRING. That's now handled in spew.c, along
3514 with symbol table interaction and other context-sensitivity. */
3526 /* Effectively do c = skip_white_space (c)
3527 but do it faster in the usual cases. */
3537 if (cpp_token == CPP_HSPACE)
3538 c = yy_get_token ();
3545 /* Call skip_white_space so we can warn if appropriate. */
3550 c = skip_white_space (c);
3552 goto found_nonwhite;
3556 token_buffer[0] = c;
3557 token_buffer[1] = 0;
3559 /* yylloc.first_line = lineno; */
3565 token_buffer[0] = 0;
3567 value = END_OF_LINE;
3568 else if (input_redirected ())
3569 value = END_OF_SAVED_INPUT;
3576 if (cpp_token == CPP_NAME)
3579 /* Capital L may start a wide-string or wide-character constant. */
3581 register int c = token_getch ();
3590 goto string_constant;
3595 case 'A': case 'B': case 'C': case 'D': case 'E':
3596 case 'F': case 'G': case 'H': case 'I': case 'J':
3597 case 'K': case 'M': case 'N': case 'O':
3598 case 'P': case 'Q': case 'R': case 'S': case 'T':
3599 case 'U': case 'V': case 'W': case 'X': case 'Y':
3601 case 'a': case 'b': case 'c': case 'd': case 'e':
3602 case 'f': case 'g': case 'h': case 'i': case 'j':
3603 case 'k': case 'l': case 'm': case 'n': case 'o':
3604 case 'p': case 'q': case 'r': case 's': case 't':
3605 case 'u': case 'v': case 'w': case 'x': case 'y':
3611 if (cpp_token == CPP_NAME)
3613 /* Note that one character has already been read from
3614 yy_cur into token_buffer. Also, cpplib complains about
3615 $ in identifiers, so we don't have to. */
3617 int len = yy_lim - yy_cur + 1;
3618 if (len >= maxtoken)
3619 extend_token_buffer_to (len + 1);
3620 memcpy (token_buffer + 1, yy_cur, len);
3621 p = token_buffer + len;
3628 while (ISALNUM (c) || (c == '_') || c == '$')
3630 /* Make sure this char really belongs in an identifier. */
3633 if (! dollars_in_ident)
3634 error ("`$' in identifier");
3636 pedwarn ("`$' in identifier");
3639 if (p >= token_buffer + maxtoken)
3640 p = extend_token_buffer (p);
3653 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3656 register struct resword *ptr;
3658 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
3662 if (ptr->token == VISSPEC)
3667 yylval.ttype = access_public_node;
3670 yylval.ttype = access_private_node;
3673 yylval.ttype = access_protected_node;
3676 my_friendly_abort (63);
3680 yylval.ttype = ridpointers[(int) ptr->rid];
3682 else switch (ptr->token)
3685 yylval.code = NE_EXPR;
3686 token_buffer[0] = '!';
3687 token_buffer[1] = '=';
3688 token_buffer[2] = 0;
3692 if (strcmp ("and_eq", token_buffer) == 0)
3694 yylval.code = BIT_AND_EXPR;
3695 token_buffer[0] = '&';
3697 else if (strcmp ("or_eq", token_buffer) == 0)
3699 yylval.code = BIT_IOR_EXPR;
3700 token_buffer[0] = '|';
3702 else if (strcmp ("xor_eq", token_buffer) == 0)
3704 yylval.code = BIT_XOR_EXPR;
3705 token_buffer[0] = '^';
3707 token_buffer[1] = '=';
3708 token_buffer[2] = 0;
3712 yylval.code = BIT_AND_EXPR;
3713 token_buffer[0] = '&';
3714 token_buffer[1] = 0;
3718 yylval.code = BIT_IOR_EXPR;
3719 token_buffer[0] = '|';
3720 token_buffer[1] = 0;
3724 yylval.code = BIT_XOR_EXPR;
3725 token_buffer[0] = '^';
3726 token_buffer[1] = 0;
3730 value = (int) ptr->token;
3734 /* If we did not find a keyword, look for an identifier
3737 if (value == IDENTIFIER || value == TYPESPEC)
3738 GNU_xref_ref (current_function_decl, token_buffer);
3740 if (value == IDENTIFIER)
3742 register tree tmp = get_identifier (token_buffer);
3744 #if !defined(VMS) && defined(JOINER)
3745 /* Make sure that user does not collide with our internal
3748 && (THIS_NAME_P (tmp)
3749 || VPTR_NAME_P (tmp)
3750 || DESTRUCTOR_NAME_P (tmp)
3751 || VTABLE_NAME_P (tmp)
3752 || TEMP_NAME_P (tmp)
3753 || ANON_AGGRNAME_P (tmp)
3754 || ANON_PARMNAME_P (tmp)))
3755 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3761 if (value == NEW && ! global_bindings_p ())
3770 if (yy_cur < yy_lim)
3773 /* It's hard to preserve tokenization on '.' because
3774 it could be a symbol by itself, or it could be the
3775 start of a floating point number and cpp won't tell us. */
3776 register int c1 = token_getch ();
3777 token_buffer[1] = c1;
3781 token_buffer[2] = 0;
3786 c1 = token_getch ();
3789 token_buffer[2] = c1;
3790 token_buffer[3] = 0;
3794 error ("parse error at `..'");
3798 token_put_back (c1);
3801 token_put_back (c1);
3804 token_buffer[1] = 0;
3808 /* Optimize for most frequent case. */
3813 cond = (yy_cur == yy_lim);
3815 register int c1 = token_getch ();
3816 token_put_back (c1);
3817 cond = (! ISALNUM (c1) && c1 != '.');
3821 yylval.ttype = (c == '0') ? integer_zero_node : integer_one_node;
3827 case '2': case '3': case '4':
3828 case '5': case '6': case '7': case '8': case '9':
3833 int largest_digit = 0;
3837 /* We actually store only HOST_BITS_PER_CHAR bits in each part.
3838 The code below which fills the parts array assumes that a host
3839 int is at least twice as wide as a host char, and that
3840 HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
3841 Two HOST_WIDE_INTs is the largest int literal we can store.
3842 In order to detect overflow below, the number of parts (TOTAL_PARTS)
3843 must be exactly the number of parts needed to hold the bits
3844 of two HOST_WIDE_INTs. */
3845 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
3846 unsigned int parts[TOTAL_PARTS];
3848 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON }
3849 floatflag = NOT_FLOAT;
3851 for (count = 0; count < TOTAL_PARTS; count++)
3859 *p++ = (c = token_getch ());
3860 if ((c == 'x') || (c == 'X'))
3863 *p++ = (c = token_getch ());
3865 /* Leading 0 forces octal unless the 0 is the only digit. */
3866 else if (c >= '0' && c <= '9')
3875 /* Read all the digits-and-decimal-points. */
3878 || (ISALNUM (c) && c != 'l' && c != 'L'
3879 && c != 'u' && c != 'U'
3880 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
3881 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
3885 if (base == 16 && pedantic)
3886 pedwarn ("floating constant may not be in radix 16");
3887 if (floatflag == TOO_MANY_POINTS)
3888 /* We have already emitted an error. Don't need another. */
3890 else if (floatflag == AFTER_POINT || floatflag == AFTER_EXPON)
3892 error ("malformed floating constant");
3893 floatflag = TOO_MANY_POINTS;
3894 /* Avoid another error from atof by forcing all characters
3895 from here on to be ignored. */
3899 floatflag = AFTER_POINT;
3903 *p++ = c = token_getch ();
3904 /* Accept '.' as the start of a floating-point number
3905 only when it is followed by a digit. */
3906 if (p == token_buffer + 2 && !ISDIGIT (c))
3907 my_friendly_abort (990710);
3911 /* It is not a decimal point.
3912 It should be a digit (perhaps a hex digit). */
3918 else if (base <= 10)
3920 if (c == 'e' || c == 'E')
3923 floatflag = AFTER_EXPON;
3924 break; /* start of exponent */
3926 error ("nondigits in number and not hexadecimal");
3929 else if (base == 16 && (c == 'p' || c == 'P'))
3931 floatflag = AFTER_EXPON;
3932 break; /* start of exponent */
3942 if (c >= largest_digit)
3946 for (count = 0; count < TOTAL_PARTS; count++)
3948 parts[count] *= base;
3952 += (parts[count-1] >> HOST_BITS_PER_CHAR);
3954 &= (1 << HOST_BITS_PER_CHAR) - 1;
3960 /* If the highest-order part overflows (gets larger than
3961 a host char will hold) then the whole number has
3962 overflowed. Record this and truncate the highest-order
3964 if (parts[TOTAL_PARTS - 1] >> HOST_BITS_PER_CHAR)
3967 parts[TOTAL_PARTS - 1] &= (1 << HOST_BITS_PER_CHAR) - 1;
3970 if (p >= token_buffer + maxtoken - 3)
3971 p = extend_token_buffer (p);
3972 *p++ = (c = token_getch ());
3976 /* This can happen on input like `int i = 0x;' */
3978 error ("numeric constant with no digits");
3980 if (largest_digit >= base)
3981 error ("numeric constant contains digits beyond the radix");
3983 /* Remove terminating char from the token buffer and delimit the
3987 if (floatflag != NOT_FLOAT)
3990 int imag, conversion_errno;
3991 REAL_VALUE_TYPE value;
3992 struct pf_args args;
3994 /* Read explicit exponent if any, and put it in tokenbuf. */
3996 if ((base == 10 && ((c == 'e') || (c == 'E')))
3997 || (base == 16 && (c == 'p' || c == 'P')))
3999 if (p >= token_buffer + maxtoken - 3)
4000 p = extend_token_buffer (p);
4003 if ((c == '+') || (c == '-'))
4008 /* Exponent is decimal, even if string is a hex float. */
4010 error ("floating constant exponent has no digits");
4013 if (p >= token_buffer + maxtoken - 3)
4014 p = extend_token_buffer (p);
4019 if (base == 16 && floatflag != AFTER_EXPON)
4020 error ("hexadecimal floating constant has no exponent");
4024 /* Setup input for parse_float() */
4029 /* Convert string to a double, checking for overflow. */
4030 if (do_float_handler (parse_float, (PTR) &args))
4032 /* Receive output from parse_float() */
4037 /* We got an exception from parse_float() */
4038 error ("floating constant out of range");
4042 /* Receive output from parse_float() */
4046 conversion_errno = args.conversion_errno;
4049 /* ERANGE is also reported for underflow,
4050 so test the value to distinguish overflow from that. */
4051 if (conversion_errno == ERANGE && pedantic
4052 && (REAL_VALUES_LESS (dconst1, value)
4053 || REAL_VALUES_LESS (value, dconstm1)))
4054 warning ("floating point number exceeds range of `double'");
4057 /* If the result is not a number, assume it must have been
4058 due to some error message above, so silently convert
4060 if (REAL_VALUE_ISNAN (value))
4063 /* Create a node with determined type and value. */
4065 yylval.ttype = build_complex (NULL_TREE,
4066 convert (type, integer_zero_node),
4067 build_real (type, value));
4069 yylval.ttype = build_real (type, value);
4074 HOST_WIDE_INT high, low;
4075 int spec_unsigned = 0;
4077 int spec_long_long = 0;
4084 if (c == 'u' || c == 'U')
4087 error ("two `u's in integer constant");
4090 else if (c == 'l' || c == 'L')
4095 error ("three `l's in integer constant");
4096 else if (pedantic && ! in_system_header && warn_long_long)
4097 pedwarn ("ANSI C++ forbids long long integer constants");
4102 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
4105 error ("more than one `i' or `j' in numeric constant");
4107 pedwarn ("ANSI C++ forbids imaginary numeric constants");
4112 if (p >= token_buffer + maxtoken - 3)
4113 p = extend_token_buffer (p);
4118 /* If the literal overflowed, pedwarn about it now. */
4122 pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT * 2);
4125 /* This is simplified by the fact that our constant
4126 is always positive. */
4130 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
4132 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
4133 / HOST_BITS_PER_CHAR)]
4134 << (i * HOST_BITS_PER_CHAR));
4135 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
4138 yylval.ttype = build_int_2 (low, high);
4139 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
4141 /* Calculate the ANSI type. */
4142 if (! spec_long && ! spec_unsigned
4143 && int_fits_type_p (yylval.ttype, integer_type_node))
4144 type = integer_type_node;
4145 else if (! spec_long && (base != 10 || spec_unsigned)
4146 && int_fits_type_p (yylval.ttype, unsigned_type_node))
4147 type = unsigned_type_node;
4148 else if (! spec_unsigned && !spec_long_long
4149 && int_fits_type_p (yylval.ttype, long_integer_type_node))
4150 type = long_integer_type_node;
4151 else if (! spec_long_long
4152 && int_fits_type_p (yylval.ttype,
4153 long_unsigned_type_node))
4154 type = long_unsigned_type_node;
4155 else if (! spec_unsigned
4156 && int_fits_type_p (yylval.ttype,
4157 long_long_integer_type_node))
4158 type = long_long_integer_type_node;
4159 else if (int_fits_type_p (yylval.ttype,
4160 long_long_unsigned_type_node))
4161 type = long_long_unsigned_type_node;
4162 else if (! spec_unsigned
4163 && int_fits_type_p (yylval.ttype,
4164 widest_integer_literal_type_node))
4165 type = widest_integer_literal_type_node;
4167 type = widest_unsigned_literal_type_node;
4169 if (pedantic && !spec_long_long && !warn
4170 && (TYPE_PRECISION (long_integer_type_node)
4171 < TYPE_PRECISION (type)))
4174 pedwarn ("integer constant larger than the maximum value of an unsigned long int");
4177 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
4178 warning ("decimal constant is so large that it is unsigned");
4182 if (TYPE_PRECISION (type)
4183 <= TYPE_PRECISION (integer_type_node))
4185 = build_complex (NULL_TREE, integer_zero_node,
4186 convert (integer_type_node,
4189 error ("complex integer constant is too wide for `__complex int'");
4192 TREE_TYPE (yylval.ttype) = type;
4195 /* If it's still an integer (not a complex), and it doesn't
4196 fit in the type we choose for it, then pedwarn. */
4199 && TREE_CODE (TREE_TYPE (yylval.ttype)) == INTEGER_TYPE
4200 && ! int_fits_type_p (yylval.ttype, TREE_TYPE (yylval.ttype)))
4201 pedwarn ("integer constant is larger than the maximum value for its type");
4207 if (ISALNUM (c) || c == '.' || c == '_' || c == '$'
4208 || ((c == '-' || c == '+')
4209 && (p[-1] == 'e' || p[-1] == 'E')))
4210 error ("missing white space after number `%s'", token_buffer);
4212 value = CONSTANT; break;
4218 register int result = 0;
4219 register int num_chars = 0;
4221 unsigned width = TYPE_PRECISION (char_type_node);
4223 #ifdef MULTIBYTE_CHARS
4224 int longest_char = local_mb_cur_max ();
4225 local_mbtowc (NULL_PTR, NULL_PTR, 0);
4228 max_chars = TYPE_PRECISION (integer_type_node) / width;
4230 width = WCHAR_TYPE_SIZE;
4237 if (c == '\'' || c == EOF)
4244 c = readescape (&ignore);
4247 if (width < HOST_BITS_PER_INT
4248 && (unsigned) c >= ((unsigned)1 << width))
4249 pedwarn ("escape sequence out of range for character");
4250 #ifdef MAP_CHARACTER
4252 c = MAP_CHARACTER (c);
4258 pedwarn ("ANSI C forbids newline in character constant");
4263 #ifdef MULTIBYTE_CHARS
4267 for (i = 1; i <= longest_char; ++i)
4269 if (i > maxtoken - 4)
4270 extend_token_buffer (token_buffer);
4272 token_buffer[i] = c;
4273 char_len = local_mbtowc (& wc,
4282 /* mbtowc sometimes needs an extra char before accepting */
4287 /* Merge character into result; ignore excess chars. */
4288 for (i = 1; i <= char_len; ++i)
4292 if (width < HOST_BITS_PER_INT)
4293 result = (result << width)
4295 & ((1 << width) - 1));
4297 result = token_buffer[i];
4299 num_chars += char_len;
4308 warning ("Ignoring invalid multibyte character");
4309 /* Replace all but the first byte. */
4310 for (--i; i > 1; --i)
4311 token_put_back (token_buffer[i]);
4312 wc = token_buffer[1];
4314 #ifdef MAP_CHARACTER
4315 c = MAP_CHARACTER (wc);
4320 #else /* ! MULTIBYTE_CHARS */
4321 #ifdef MAP_CHARACTER
4322 c = MAP_CHARACTER (c);
4324 #endif /* ! MULTIBYTE_CHARS */
4329 if (chars_seen == 1) /* only keep the first one */
4334 /* Merge character into result; ignore excess chars. */
4335 num_chars += (width / TYPE_PRECISION (char_type_node));
4336 if (num_chars < max_chars + 1)
4338 if (width < HOST_BITS_PER_INT)
4339 result = (result << width) | (c & ((1 << width) - 1));
4346 error ("malformatted character constant");
4347 else if (chars_seen == 0)
4348 error ("empty character constant");
4349 else if (num_chars > max_chars)
4351 num_chars = max_chars;
4352 error ("character constant too long");
4354 else if (chars_seen != 1 && warn_multichar)
4355 warning ("multi-character character constant");
4357 /* If char type is signed, sign-extend the constant. */
4360 int num_bits = num_chars * width;
4362 /* We already got an error; avoid invalid shift. */
4363 yylval.ttype = build_int_2 (0, 0);
4364 else if (TREE_UNSIGNED (char_type_node)
4365 || ((result >> (num_bits - 1)) & 1) == 0)
4367 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
4368 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4372 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
4373 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4375 /* In C, a character constant has type 'int'; in C++, 'char'. */
4376 if (chars_seen <= 1)
4377 TREE_TYPE (yylval.ttype) = char_type_node;
4379 TREE_TYPE (yylval.ttype) = integer_type_node;
4383 yylval.ttype = build_int_2 (result, 0);
4384 TREE_TYPE (yylval.ttype) = wchar_type_node;
4394 unsigned width = wide_flag ? WCHAR_TYPE_SIZE
4395 : TYPE_PRECISION (char_type_node);
4396 #ifdef MULTIBYTE_CHARS
4397 int longest_char = local_mb_cur_max ();
4398 local_mbtowc (NULL_PTR, NULL_PTR, 0);
4402 p = token_buffer + 1;
4404 while (c != '"' && c != EOF)
4406 /* ignore_escape_flag is set for reading the filename in #line. */
4407 if (!ignore_escape_flag && c == '\\')
4410 c = readescape (&ignore);
4413 if (width < HOST_BITS_PER_INT
4414 && (unsigned) c >= ((unsigned)1 << width))
4415 pedwarn ("escape sequence out of range for character");
4420 pedwarn ("ANSI C++ forbids newline in string constant");
4425 #ifdef MULTIBYTE_CHARS
4429 for (i = 0; i < longest_char; ++i)
4431 if (p + i >= token_buffer + maxtoken)
4432 p = extend_token_buffer (p);
4435 char_len = local_mbtowc (& wc, p, i + 1);
4442 warning ("Ignoring invalid multibyte character");
4443 /* Replace all except the first byte. */
4445 for (--i; i > 0; --i)
4446 token_put_back (p[i]);
4449 /* mbtowc sometimes needs an extra char before accepting */
4459 #endif /* MULTIBYTE_CHARS */
4462 /* Add this single character into the buffer either as a wchar_t
4463 or as a single byte. */
4466 unsigned width = TYPE_PRECISION (char_type_node);
4467 unsigned bytemask = (1 << width) - 1;
4470 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4471 p = extend_token_buffer (p);
4473 for (byte = 0; byte < WCHAR_BYTES; ++byte)
4476 if (byte >= (int) sizeof (c))
4479 value = (c >> (byte * width)) & bytemask;
4480 if (BYTES_BIG_ENDIAN)
4481 p[WCHAR_BYTES - byte - 1] = value;
4489 if (p >= token_buffer + maxtoken)
4490 p = extend_token_buffer (p);
4498 /* Terminate the string value, either with a single byte zero
4499 or with a wide zero. */
4502 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4503 p = extend_token_buffer (p);
4504 bzero (p, WCHAR_BYTES);
4509 if (p >= token_buffer + maxtoken)
4510 p = extend_token_buffer (p);
4515 error ("Unterminated string constant");
4517 /* We have read the entire constant.
4518 Construct a STRING_CST for the result. */
4520 if (processing_template_decl)
4521 push_obstacks (&permanent_obstack, &permanent_obstack);
4522 yylval.ttype = build_string (p - (token_buffer + 1), token_buffer + 1);
4523 if (processing_template_decl)
4527 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4529 TREE_TYPE (yylval.ttype) = char_array_type_node;
4531 value = STRING; break;
4555 yylval.code = PLUS_EXPR; break;
4557 yylval.code = MINUS_EXPR; break;
4559 yylval.code = BIT_AND_EXPR; break;
4561 yylval.code = BIT_IOR_EXPR; break;
4563 yylval.code = MULT_EXPR; break;
4565 yylval.code = TRUNC_DIV_EXPR; break;
4567 yylval.code = TRUNC_MOD_EXPR; break;
4569 yylval.code = BIT_XOR_EXPR; break;
4571 yylval.code = LSHIFT_EXPR; break;
4573 yylval.code = RSHIFT_EXPR; break;
4575 yylval.code = LT_EXPR; break;
4577 yylval.code = GT_EXPR; break;
4580 token_buffer[1] = c1 = token_getch ();
4581 token_buffer[2] = 0;
4588 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4590 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4592 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4594 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4596 value = ASSIGN; goto done;
4602 value = PLUSPLUS; goto done;
4604 value = MINUSMINUS; goto done;
4606 value = ANDAND; goto done;
4608 value = OROR; goto done;
4620 else if (c1 == '?' && (c == '<' || c == '>'))
4622 token_buffer[3] = 0;
4624 c1 = token_getch ();
4625 yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4628 /* <?= or >?= expression. */
4629 token_buffer[2] = c1;
4635 token_put_back (c1);
4638 pedwarn ("use of `operator %s' is not standard C++",
4648 c1 = token_getch ();
4650 value = POINTSAT_STAR;
4653 token_put_back (c1);
4663 { value = ']'; goto done; }
4667 { value = '{'; indent_level++; goto done; }
4669 { value = '['; goto done; }
4673 { value = '}'; indent_level--; goto done; }
4677 token_put_back (c1);
4678 token_buffer[1] = 0;
4680 /* Here the C frontend changes < and > to ARITHCOMPARE. We don't
4681 do that because of templates. */
4688 /* Don't make yyparse think this is eof. */
4707 /* yylloc.last_line = lineno; */
4708 #ifdef GATHER_STATISTICS
4709 #ifdef REDUCE_LENGTH
4710 token_count[value] += 1;
4721 return !!is_reserved_word (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
4724 #ifdef GATHER_STATISTICS
4725 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4726 need to be brought into here, unless this were actually put into a header
4728 /* Statistics-gathering stuff. */
4749 extern int tree_node_counts[];
4750 extern int tree_node_sizes[];
4753 /* Place to save freed lang_decls which were allocated on the
4754 permanent_obstack. @@ Not currently used. */
4755 tree free_lang_decl_chain;
4758 build_lang_decl (code, name, type)
4759 enum tree_code code;
4763 register tree t = build_decl (code, name, type);
4764 retrofit_lang_decl (t);
4768 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
4769 and pushdecl (for functions generated by the backend). */
4772 retrofit_lang_decl (t)
4775 struct obstack *obstack = current_obstack;
4776 register int i = sizeof (struct lang_decl) / sizeof (int);
4779 if (! TREE_PERMANENT (t))
4780 obstack = saveable_obstack;
4782 /* Could be that saveable is permanent and current is not. */
4783 obstack = &permanent_obstack;
4785 if (free_lang_decl_chain && obstack == &permanent_obstack)
4787 pi = (int *)free_lang_decl_chain;
4788 free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
4791 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4796 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4797 LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4798 = obstack == &permanent_obstack;
4799 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4800 == TREE_PERMANENT (t), 234);
4801 DECL_MAIN_VARIANT (t) = t;
4802 if (current_lang_name == lang_name_cplusplus)
4803 DECL_LANGUAGE (t) = lang_cplusplus;
4804 else if (current_lang_name == lang_name_c)
4805 DECL_LANGUAGE (t) = lang_c;
4806 else if (current_lang_name == lang_name_java)
4807 DECL_LANGUAGE (t) = lang_java;
4808 else my_friendly_abort (64);
4810 #if 0 /* not yet, should get fixed properly later */
4811 if (code == TYPE_DECL)
4814 id = get_identifier (build_overload_name (type, 1, 1));
4815 DECL_ASSEMBLER_NAME (t) = id;
4819 #ifdef GATHER_STATISTICS
4820 tree_node_counts[(int)lang_decl] += 1;
4821 tree_node_sizes[(int)lang_decl] += sizeof (struct lang_decl);
4826 build_lang_field_decl (code, name, type)
4827 enum tree_code code;
4831 extern struct obstack *current_obstack, *saveable_obstack;
4832 register tree t = build_decl (code, name, type);
4833 struct obstack *obstack = current_obstack;
4834 register int i = sizeof (struct lang_decl_flags) / sizeof (int);
4836 #if 0 /* not yet, should get fixed properly later */
4838 if (code == TYPE_DECL)
4841 id = get_identifier (build_overload_name (type, 1, 1));
4842 DECL_ASSEMBLER_NAME (t) = id;
4846 if (! TREE_PERMANENT (t))
4847 obstack = saveable_obstack;
4849 my_friendly_assert (obstack == &permanent_obstack, 235);
4851 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
4855 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4860 copy_lang_decl (node)
4866 if (! DECL_LANG_SPECIFIC (node))
4869 if (TREE_CODE (node) == FIELD_DECL)
4870 size = sizeof (struct lang_decl_flags);
4872 size = sizeof (struct lang_decl);
4873 pi = (int *)obstack_alloc (&permanent_obstack, size);
4874 bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
4875 DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
4879 make_lang_type (code)
4880 enum tree_code code;
4882 extern struct obstack *current_obstack, *saveable_obstack;
4883 register tree t = make_node (code);
4885 /* Set up some flags that give proper default behavior. */
4886 if (IS_AGGR_TYPE_CODE (code))
4888 struct obstack *obstack = current_obstack;
4889 struct lang_type *pi;
4891 SET_IS_AGGR_TYPE (t, 1);
4893 if (! TREE_PERMANENT (t))
4894 obstack = saveable_obstack;
4896 my_friendly_assert (obstack == &permanent_obstack, 236);
4898 pi = (struct lang_type *) obstack_alloc (obstack, sizeof (struct lang_type));
4899 bzero ((char *) pi, (int) sizeof (struct lang_type));
4901 TYPE_LANG_SPECIFIC (t) = pi;
4902 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
4903 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
4905 /* Make sure this is laid out, for ease of use later. In the
4906 presence of parse errors, the normal was of assuring this
4907 might not ever get executed, so we lay it out *immediately*. */
4908 build_pointer_type (t);
4910 #ifdef GATHER_STATISTICS
4911 tree_node_counts[(int)lang_type] += 1;
4912 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
4916 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
4917 TYPE_ALIAS_SET is initialized to -1 by default, so we must
4919 TYPE_ALIAS_SET (t) = 0;
4921 /* We need to allocate a TYPE_BINFO even for TEMPALTE_TYPE_PARMs
4922 since they can be virtual base types, and we then need a
4923 canonical binfo for them. Ideally, this would be done lazily for
4925 if (IS_AGGR_TYPE_CODE (code) || code == TEMPLATE_TYPE_PARM)
4926 TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE);
4932 dump_time_statistics ()
4934 register tree prev = 0, decl, next;
4935 int this_time = my_get_run_time ();
4936 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time))
4937 += this_time - body_time;
4939 fprintf (stderr, "\n******\n");
4940 print_time ("header files (total)", header_time);
4941 print_time ("main file (total)", this_time - body_time);
4942 fprintf (stderr, "ratio = %g : 1\n",
4943 (double)header_time / (double)(this_time - body_time));
4944 fprintf (stderr, "\n******\n");
4946 for (decl = filename_times; decl; decl = next)
4948 next = IDENTIFIER_GLOBAL_VALUE (decl);
4949 SET_IDENTIFIER_GLOBAL_VALUE (decl, prev);
4953 for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
4954 print_time (IDENTIFIER_POINTER (decl),
4955 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (decl)));
4959 compiler_error VPROTO ((const char *msg, ...))
4961 #ifndef ANSI_PROTOTYPES
4969 #ifndef ANSI_PROTOTYPES
4970 msg = va_arg (ap, const char *);
4973 vsprintf (buf, msg, ap);
4974 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
4977 /* Return the type-qualifier corresponding to the identifier given by
4981 cp_type_qual_from_rid (rid)
4984 if (rid == ridpointers[(int) RID_CONST])
4985 return TYPE_QUAL_CONST;
4986 else if (rid == ridpointers[(int) RID_VOLATILE])
4987 return TYPE_QUAL_VOLATILE;
4988 else if (rid == ridpointers[(int) RID_RESTRICT])
4989 return TYPE_QUAL_RESTRICT;
4991 my_friendly_abort (0);
4992 return TYPE_UNQUALIFIED;