1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is the lexical analyzer for GNU C++. */
25 /* Cause the `yydebug' variable to be defined. */
42 #ifdef MULTIBYTE_CHARS
47 #define obstack_chunk_alloc xmalloc
48 #define obstack_chunk_free free
51 #define DIR_SEPARATOR '/'
54 extern struct obstack permanent_obstack;
55 extern struct obstack *current_obstack, *saveable_obstack;
57 extern void yyprint PROTO((FILE *, int, YYSTYPE));
58 extern void compiler_error PROTO((char *, HOST_WIDE_INT,
61 static tree get_time_identifier PROTO((char *));
62 static int check_newline PROTO((void));
63 static int skip_white_space PROTO((int));
64 static void finish_defarg PROTO((void));
65 static int my_get_run_time PROTO((void));
66 static int get_last_nonwhite_on_line PROTO((void));
67 static int interface_strcmp PROTO((char *));
68 static int readescape PROTO((int *));
69 static char *extend_token_buffer PROTO((char *));
70 static void consume_string PROTO((struct obstack *, int));
71 static void set_typedecl_interface_info PROTO((tree, tree));
72 static void feed_defarg PROTO((tree, tree));
73 static int set_vardecl_interface_info PROTO((tree, tree));
74 static void store_pending_inline PROTO((tree, struct pending_inline *));
75 static void reinit_parse_for_expr PROTO((struct obstack *));
76 static int *init_cpp_parse PROTO((void));
77 static int handle_cp_pragma PROTO((char *));
78 #ifdef HANDLE_GENERIC_PRAGMAS
79 static int handle_generic_pragma PROTO((int));
81 #ifdef GATHER_STATISTICS
83 static int reduce_cmp PROTO((int *, int *));
84 static int token_cmp PROTO((int *, int *));
88 /* Given a file name X, return the nondirectory portion.
89 Keep in mind that X can be computed more than once. */
91 file_name_nondirectory (x)
94 char *tmp = (char *) rindex (x, '/');
95 if (DIR_SEPARATOR != '/' && ! tmp)
96 tmp = (char *) rindex (x, DIR_SEPARATOR);
98 return (char *) (tmp + 1);
103 /* This obstack is needed to hold text. It is not safe to use
104 TOKEN_BUFFER because `check_newline' calls `yylex'. */
105 struct obstack inline_text_obstack;
106 char *inline_text_firstobj;
110 extern cpp_reader parse_in;
111 extern cpp_options parse_options;
112 extern unsigned char *yy_cur, *yy_lim;
118 /* Pending language change.
119 Positive is push count, negative is pop count. */
120 int pending_lang_change = 0;
122 /* Wrap the current header file in extern "C". */
123 static int c_header_level = 0;
125 extern int first_token;
126 extern struct obstack token_obstack;
128 /* ??? Don't really know where this goes yet. */
132 extern void put_back (/* int */);
133 extern int input_redirected ();
134 extern void feed_input (/* char *, int */);
137 /* Holds translations from TREE_CODEs to operator name strings,
138 i.e., opname_tab[PLUS_EXPR] == "+". */
142 extern int yychar; /* the lookahead symbol */
143 extern YYSTYPE yylval; /* the semantic value of the */
144 /* lookahead symbol */
147 YYLTYPE yylloc; /* location data for the lookahead */
152 /* the declaration found for the last IDENTIFIER token read in.
153 yylex must look this up to detect typedefs, which get token type TYPENAME,
154 so it is left around in case the identifier is not a typedef but is
155 used in a context which makes it a reference to a variable. */
158 /* The elements of `ridpointers' are identifier nodes
159 for the reserved type names and storage classes.
160 It is indexed by a RID_... value. */
161 tree ridpointers[(int) RID_MAX];
163 /* We may keep statistics about how long which files took to compile. */
164 static int header_time, body_time;
165 static tree filename_times;
166 static tree this_filename_time;
168 /* Array for holding counts of the numbers of tokens seen. */
169 extern int *token_count;
171 /* Return something to represent absolute declarators containing a *.
172 TARGET is the absolute declarator that the * contains.
173 CV_QUALIFIERS is a list of modifiers such as const or volatile
174 to apply to the pointer type, represented as identifiers.
176 We return an INDIRECT_REF whose "contents" are TARGET
177 and whose type is the modifier list. */
180 make_pointer_declarator (cv_qualifiers, target)
181 tree cv_qualifiers, target;
183 if (target && TREE_CODE (target) == IDENTIFIER_NODE
184 && ANON_AGGRNAME_P (target))
185 error ("type name expected before `*'");
186 target = build_parse_node (INDIRECT_REF, target);
187 TREE_TYPE (target) = cv_qualifiers;
191 /* Return something to represent absolute declarators containing a &.
192 TARGET is the absolute declarator that the & contains.
193 CV_QUALIFIERS is a list of modifiers such as const or volatile
194 to apply to the reference type, represented as identifiers.
196 We return an ADDR_EXPR whose "contents" are TARGET
197 and whose type is the modifier list. */
200 make_reference_declarator (cv_qualifiers, target)
201 tree cv_qualifiers, target;
205 if (TREE_CODE (target) == ADDR_EXPR)
207 error ("cannot declare references to references");
210 if (TREE_CODE (target) == INDIRECT_REF)
212 error ("cannot declare pointers to references");
215 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
216 error ("type name expected before `&'");
218 target = build_parse_node (ADDR_EXPR, target);
219 TREE_TYPE (target) = cv_qualifiers;
224 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
225 tree target, parms, cv_qualifiers, exception_specification;
227 target = build_parse_node (CALL_EXPR, target, parms, cv_qualifiers);
228 TREE_TYPE (target) = exception_specification;
233 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
234 tree call_declarator, cv_qualifiers, exception_specification;
236 TREE_OPERAND (call_declarator, 2) = cv_qualifiers;
237 TREE_TYPE (call_declarator) = exception_specification;
240 /* Build names and nodes for overloaded operators. */
242 tree ansi_opname[LAST_CPLUS_TREE_CODE];
243 tree ansi_assopname[LAST_CPLUS_TREE_CODE];
246 operator_name_string (name)
249 char *opname = IDENTIFIER_POINTER (name) + 2;
253 /* Works for builtin and user defined types. */
254 if (IDENTIFIER_GLOBAL_VALUE (name)
255 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
256 return IDENTIFIER_POINTER (name);
258 if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
262 opname_table = ansi_assopname;
267 opname_table = ansi_opname;
270 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
272 if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
273 && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
277 if (i == LAST_CPLUS_TREE_CODE)
278 return "<invalid operator>";
281 return assignop_tab[i];
283 return opname_tab[i];
286 int interface_only; /* whether or not current file is only for
287 interface definitions. */
288 int interface_unknown; /* whether or not we know this class
289 to behave according to #pragma interface. */
291 /* lexical analyzer */
293 #ifndef WCHAR_TYPE_SIZE
295 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
297 #define WCHAR_TYPE_SIZE BITS_PER_WORD
301 /* Number of bytes in a wide character. */
302 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
304 static int maxtoken; /* Current nominal length of token buffer. */
305 char *token_buffer; /* Pointer to token buffer.
306 Actual allocated length is maxtoken + 2. */
311 /* Nonzero tells yylex to ignore \ in string constants. */
312 static int ignore_escape_flag = 0;
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 (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
327 push_obstacks_nochange ();
328 end_temporary_allocation ();
329 IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
330 IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
331 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier, filename_times);
332 filename_times = time_identifier;
335 return time_identifier;
344 int old_quiet_flag = quiet_flag;
347 this_time = get_run_time ();
348 quiet_flag = old_quiet_flag;
352 /* Table indexed by tree code giving a string containing a character
353 classifying the tree code. Possibilities are
354 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
356 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
358 char cplus_tree_code_type[] = {
360 #include "cp-tree.def"
364 /* Table indexed by tree code giving number of expression
365 operands beyond the fixed part of the node structure.
366 Not used for types or decls. */
368 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
370 int cplus_tree_code_length[] = {
372 #include "cp-tree.def"
376 /* Names of tree components.
377 Used for printing out the tree and error messages. */
378 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
380 char *cplus_tree_code_name[] = {
382 #include "cp-tree.def"
386 /* toplev.c needs to call these. */
391 /* Default exceptions on. */
398 /* the beginning of the file is a new line; check for # */
399 /* With luck, we discover the real source file's name from that
400 and put it in input_filename. */
402 put_back (check_newline ());
407 if (flag_gnu_xref) GNU_xref_begin (input_filename);
408 init_repo (input_filename);
414 extern int errorcount, sorrycount;
415 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
425 init_filename_times ()
427 this_filename_time = get_time_identifier ("<top level>");
428 if (flag_detailed_statistics)
431 body_time = my_get_run_time ();
432 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
436 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
437 Stuck this hack in to get the files open correctly; this is called
438 in place of init_parse if we are an unexec'd binary. */
442 reinit_lang_specific ()
444 init_filename_times ();
445 reinit_search_statistics ();
452 #ifdef GATHER_STATISTICS
454 reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
455 bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
457 token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
458 bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
466 init_parse (filename)
469 extern int flag_no_gnu_keywords;
470 extern int flag_operator_names;
474 #ifdef MULTIBYTE_CHARS
475 /* Change to the native locale for multibyte conversions. */
476 setlocale (LC_CTYPE, "");
477 literal_codeset = getenv ("LANG");
481 parse_in.show_column = 1;
482 if (! cpp_start_read (&parse_in, filename))
485 /* cpp_start_read always puts at least one line directive into the
486 token buffer. We must arrange to read it out here. */
487 yy_cur = parse_in.token_buffer;
488 yy_lim = CPP_PWRITTEN (&parse_in);
491 /* Open input file. */
492 if (filename == 0 || !strcmp (filename, "-"))
498 finput = fopen (filename, "r");
500 pfatal_with_name (filename);
502 #ifdef IO_BUFFER_SIZE
503 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
505 #endif /* !USE_CPPLIB */
507 /* Initialize the lookahead machinery. */
510 /* Make identifier nodes long enough for the language-specific slots. */
511 set_identifier_size (sizeof (struct lang_identifier));
512 decl_printable_name = lang_printable_name;
514 init_cplus_expand ();
516 bcopy (cplus_tree_code_type,
517 tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
518 (int)LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
519 bcopy ((char *)cplus_tree_code_length,
520 (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
521 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
522 bcopy ((char *)cplus_tree_code_name,
523 (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
524 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
526 opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
527 bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
528 assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
529 bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
531 ansi_opname[0] = get_identifier ("<invalid operator>");
532 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
534 ansi_opname[i] = ansi_opname[0];
535 ansi_assopname[i] = ansi_opname[0];
538 ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
539 IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
540 ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
541 ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
542 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
543 ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
544 ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
545 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
546 ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
547 IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
548 ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
549 ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
550 ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
551 ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
552 IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
553 ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
554 ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
555 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
556 ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
557 ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
558 IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
559 ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
560 IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
561 ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
562 IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
563 ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
564 IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
565 ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
566 IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
567 ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
568 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
569 ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
570 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
571 ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
572 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
573 ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
574 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
575 ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
576 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
577 ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
578 ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
579 IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
580 ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
581 ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
582 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
583 ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
584 IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
585 ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
586 IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
587 ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
588 ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
589 ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
590 ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
591 ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
592 ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
593 ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
594 ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
595 ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
596 IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
597 ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
598 IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
599 ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
600 ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
601 ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
602 IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
603 ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
604 IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
605 ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
606 IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
607 ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
608 IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
609 ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
610 IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
611 ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
612 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
613 ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
614 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
615 ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
616 ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
617 ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
618 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
619 ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
620 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
621 ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
622 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
623 ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
624 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
625 ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
626 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
627 ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
628 ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
629 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
630 ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
631 IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
632 ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
633 IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
634 ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
635 IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
636 ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
637 IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
638 ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
639 IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
640 ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
641 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
642 ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
643 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
644 ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
645 IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
647 /* This is not true: these operators are not defined in ANSI,
648 but we need them anyway. */
649 ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
650 IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
651 ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
652 IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
653 ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
654 IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
655 ansi_opname[(int) SIZEOF_EXPR] = get_identifier ("__sz");
656 IDENTIFIER_OPNAME_P (ansi_opname[(int) SIZEOF_EXPR]) = 1;
660 gcc_obstack_init (&inline_text_obstack);
661 inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
663 /* Start it at 0, because check_newline is called at the very beginning
664 and will increment it to 1. */
666 input_filename = "<internal>";
667 current_function_decl = NULL;
670 token_buffer = (char *) xmalloc (maxtoken + 2);
672 ridpointers[(int) RID_INT] = get_identifier ("int");
673 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
674 build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
675 ridpointers[(int) RID_BOOL] = get_identifier ("bool");
676 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_BOOL],
677 build_tree_list (NULL_TREE, ridpointers[(int) RID_BOOL]));
678 ridpointers[(int) RID_CHAR] = get_identifier ("char");
679 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
680 build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
681 ridpointers[(int) RID_VOID] = get_identifier ("void");
682 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
683 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
684 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
685 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
686 build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
687 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
688 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
689 build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
690 ridpointers[(int) RID_SHORT] = get_identifier ("short");
691 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
692 build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
693 ridpointers[(int) RID_LONG] = get_identifier ("long");
694 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
695 build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
696 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
697 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
698 build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
699 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
700 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
701 build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
702 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
703 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
704 build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
705 ridpointers[(int) RID_CONST] = get_identifier ("const");
706 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
707 build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
708 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
709 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
710 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
711 ridpointers[(int) RID_RESTRICT] = get_identifier ("__restrict");
712 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_RESTRICT],
713 build_tree_list (NULL_TREE, ridpointers[(int) RID_RESTRICT]));
714 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
715 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
716 build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
717 ridpointers[(int) RID_STATIC] = get_identifier ("static");
718 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
719 build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
720 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
721 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
722 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
723 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
724 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
725 build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
726 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
727 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
728 build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
729 ridpointers[(int) RID_COMPLEX] = get_identifier ("__complex");
730 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_COMPLEX],
731 build_tree_list (NULL_TREE, ridpointers[(int) RID_COMPLEX]));
733 /* C++ extensions. These are probably not correctly named. */
734 ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
735 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
736 build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
737 class_type_node = build_int_2 (class_type, 0);
738 TREE_TYPE (class_type_node) = class_type_node;
739 ridpointers[(int) RID_CLASS] = class_type_node;
741 record_type_node = build_int_2 (record_type, 0);
742 TREE_TYPE (record_type_node) = record_type_node;
743 ridpointers[(int) RID_RECORD] = record_type_node;
745 union_type_node = build_int_2 (union_type, 0);
746 TREE_TYPE (union_type_node) = union_type_node;
747 ridpointers[(int) RID_UNION] = union_type_node;
749 enum_type_node = build_int_2 (enum_type, 0);
750 TREE_TYPE (enum_type_node) = enum_type_node;
751 ridpointers[(int) RID_ENUM] = enum_type_node;
753 ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
754 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
755 build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
756 ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
757 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPLICIT],
758 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPLICIT]));
759 ridpointers[(int) RID_EXPORT] = get_identifier ("export");
760 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPORT],
761 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPORT]));
762 ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
763 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
764 build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
766 ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
767 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
768 build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
769 ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
770 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
771 build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
772 ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
773 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
774 build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
775 ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
776 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TEMPLATE],
777 build_tree_list (NULL_TREE, ridpointers[(int) RID_TEMPLATE]));
778 /* This is for ANSI C++. */
779 ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
780 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
781 build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
783 /* Signature handling extensions. */
784 signature_type_node = build_int_2 (signature_type, 0);
785 TREE_TYPE (signature_type_node) = signature_type_node;
786 ridpointers[(int) RID_SIGNATURE] = signature_type_node;
788 /* Create the built-in __null node. Note that we can't yet call for
789 type_for_size here because integer_type_node and so forth are not
790 set up. Therefore, we don't set the type of these nodes until
791 init_decl_processing. */
792 null_node = build_int_2 (0, 0);
793 ridpointers[RID_NULL] = null_node;
795 opname_tab[(int) COMPONENT_REF] = "->";
796 opname_tab[(int) MEMBER_REF] = "->*";
797 opname_tab[(int) INDIRECT_REF] = "*";
798 opname_tab[(int) ARRAY_REF] = "[]";
799 opname_tab[(int) MODIFY_EXPR] = "=";
800 opname_tab[(int) NEW_EXPR] = "new";
801 opname_tab[(int) DELETE_EXPR] = "delete";
802 opname_tab[(int) VEC_NEW_EXPR] = "new []";
803 opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
804 opname_tab[(int) COND_EXPR] = "?:";
805 opname_tab[(int) CALL_EXPR] = "()";
806 opname_tab[(int) PLUS_EXPR] = "+";
807 opname_tab[(int) MINUS_EXPR] = "-";
808 opname_tab[(int) MULT_EXPR] = "*";
809 opname_tab[(int) TRUNC_DIV_EXPR] = "/";
810 opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
811 opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
812 opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
813 opname_tab[(int) TRUNC_MOD_EXPR] = "%";
814 opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
815 opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
816 opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
817 opname_tab[(int) NEGATE_EXPR] = "-";
818 opname_tab[(int) MIN_EXPR] = "<?";
819 opname_tab[(int) MAX_EXPR] = ">?";
820 opname_tab[(int) ABS_EXPR] = "abs";
821 opname_tab[(int) FFS_EXPR] = "ffs";
822 opname_tab[(int) LSHIFT_EXPR] = "<<";
823 opname_tab[(int) RSHIFT_EXPR] = ">>";
824 opname_tab[(int) BIT_IOR_EXPR] = "|";
825 opname_tab[(int) BIT_XOR_EXPR] = "^";
826 opname_tab[(int) BIT_AND_EXPR] = "&";
827 opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
828 opname_tab[(int) BIT_NOT_EXPR] = "~";
829 opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
830 opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
831 opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
832 opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
833 opname_tab[(int) TRUTH_NOT_EXPR] = "!";
834 opname_tab[(int) LT_EXPR] = "<";
835 opname_tab[(int) LE_EXPR] = "<=";
836 opname_tab[(int) GT_EXPR] = ">";
837 opname_tab[(int) GE_EXPR] = ">=";
838 opname_tab[(int) EQ_EXPR] = "==";
839 opname_tab[(int) NE_EXPR] = "!=";
840 opname_tab[(int) IN_EXPR] = "in";
841 opname_tab[(int) RANGE_EXPR] = "...";
842 opname_tab[(int) CONVERT_EXPR] = "+";
843 opname_tab[(int) ADDR_EXPR] = "&";
844 opname_tab[(int) PREDECREMENT_EXPR] = "--";
845 opname_tab[(int) PREINCREMENT_EXPR] = "++";
846 opname_tab[(int) POSTDECREMENT_EXPR] = "--";
847 opname_tab[(int) POSTINCREMENT_EXPR] = "++";
848 opname_tab[(int) COMPOUND_EXPR] = ",";
850 assignop_tab[(int) NOP_EXPR] = "=";
851 assignop_tab[(int) PLUS_EXPR] = "+=";
852 assignop_tab[(int) CONVERT_EXPR] = "+=";
853 assignop_tab[(int) MINUS_EXPR] = "-=";
854 assignop_tab[(int) NEGATE_EXPR] = "-=";
855 assignop_tab[(int) MULT_EXPR] = "*=";
856 assignop_tab[(int) INDIRECT_REF] = "*=";
857 assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
858 assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
859 assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
860 assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
861 assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
862 assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
863 assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
864 assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
865 assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
866 assignop_tab[(int) MIN_EXPR] = "<?=";
867 assignop_tab[(int) MAX_EXPR] = ">?=";
868 assignop_tab[(int) LSHIFT_EXPR] = "<<=";
869 assignop_tab[(int) RSHIFT_EXPR] = ">>=";
870 assignop_tab[(int) BIT_IOR_EXPR] = "|=";
871 assignop_tab[(int) BIT_XOR_EXPR] = "^=";
872 assignop_tab[(int) BIT_AND_EXPR] = "&=";
873 assignop_tab[(int) ADDR_EXPR] = "&=";
875 init_filename_times ();
877 /* Some options inhibit certain reserved words.
878 Clear those words out of the hash table so they won't be recognized. */
879 #define UNSET_RESERVED_WORD(STRING) \
880 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
881 if (s) s->name = ""; } while (0)
884 /* let's parse things, and if they use it, then give them an error. */
885 if (!flag_exceptions)
887 UNSET_RESERVED_WORD ("throw");
888 UNSET_RESERVED_WORD ("try");
889 UNSET_RESERVED_WORD ("catch");
893 if (!flag_rtti || flag_no_gnu_keywords)
895 UNSET_RESERVED_WORD ("classof");
896 UNSET_RESERVED_WORD ("headof");
899 if (! flag_handle_signatures || flag_no_gnu_keywords)
901 /* Easiest way to not recognize signature
902 handling extensions... */
903 UNSET_RESERVED_WORD ("signature");
904 UNSET_RESERVED_WORD ("sigof");
906 if (flag_no_asm || flag_no_gnu_keywords)
907 UNSET_RESERVED_WORD ("typeof");
908 if (! flag_operator_names)
910 /* These are new ANSI keywords that may break code. */
911 UNSET_RESERVED_WORD ("and");
912 UNSET_RESERVED_WORD ("and_eq");
913 UNSET_RESERVED_WORD ("bitand");
914 UNSET_RESERVED_WORD ("bitor");
915 UNSET_RESERVED_WORD ("compl");
916 UNSET_RESERVED_WORD ("not");
917 UNSET_RESERVED_WORD ("not_eq");
918 UNSET_RESERVED_WORD ("or");
919 UNSET_RESERVED_WORD ("or_eq");
920 UNSET_RESERVED_WORD ("xor");
921 UNSET_RESERVED_WORD ("xor_eq");
924 token_count = init_cpp_parse ();
925 interface_unknown = 1;
934 cpp_finish (&parse_in);
941 reinit_parse_for_function ()
943 current_base_init_list = NULL_TREE;
944 current_member_init_list = NULL_TREE;
951 yyprint (file, yychar, yylval)
963 case IDENTIFIER_DEFN:
967 case PRE_PARSED_CLASS_DECL:
969 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
971 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
974 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
975 if (IDENTIFIER_POINTER (t))
976 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
979 if (yylval.ttype == class_type_node)
980 fprintf (file, " `class'");
981 else if (yylval.ttype == record_type_node)
982 fprintf (file, " `struct'");
983 else if (yylval.ttype == union_type_node)
984 fprintf (file, " `union'");
985 else if (yylval.ttype == enum_type_node)
986 fprintf (file, " `enum'");
987 else if (yylval.ttype == signature_type_node)
988 fprintf (file, " `signature'");
990 my_friendly_abort (80);
995 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
996 static int *reduce_count;
1002 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
1003 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
1006 #ifdef GATHER_STATISTICS
1007 #ifdef REDUCE_LENGTH
1012 reduce_count[yyn] += 1;
1019 return reduce_count[*q] - reduce_count[*p];
1026 return token_count[*q] - token_count[*p];
1032 print_parse_statistics ()
1034 #ifdef GATHER_STATISTICS
1035 #ifdef REDUCE_LENGTH
1038 int maxlen = REDUCE_LENGTH;
1041 if (reduce_count[-1] == 0)
1044 if (TOKEN_LENGTH > REDUCE_LENGTH)
1045 maxlen = TOKEN_LENGTH;
1046 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1048 for (i = 0; i < TOKEN_LENGTH; i++)
1050 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1051 for (i = 0; i < TOKEN_LENGTH; i++)
1053 int idx = sorted[i];
1054 if (token_count[idx] == 0)
1056 if (token_count[idx] < token_count[-1])
1058 fprintf (stderr, "token %d, `%s', count = %d\n",
1059 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
1061 fprintf (stderr, "\n");
1062 for (i = 0; i < REDUCE_LENGTH; i++)
1064 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1065 for (i = 0; i < REDUCE_LENGTH; i++)
1067 int idx = sorted[i];
1068 if (reduce_count[idx] == 0)
1070 if (reduce_count[idx] < reduce_count[-1])
1072 fprintf (stderr, "rule %d, line %d, count = %d\n",
1073 idx, yyrline[idx], reduce_count[idx]);
1075 fprintf (stderr, "\n");
1081 /* Sets the value of the 'yydebug' variable to VALUE.
1082 This is a function so we don't have to have YYDEBUG defined
1083 in order to build the compiler. */
1093 warning ("YYDEBUG not defined.");
1098 /* Functions and data structures for #pragma interface.
1100 `#pragma implementation' means that the main file being compiled
1101 is considered to implement (provide) the classes that appear in
1102 its main body. I.e., if this is file "foo.cc", and class `bar'
1103 is defined in "foo.cc", then we say that "foo.cc implements bar".
1105 All main input files "implement" themselves automagically.
1107 `#pragma interface' means that unless this file (of the form "foo.h"
1108 is not presently being included by file "foo.cc", the
1109 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1110 of the vtables nor any of the inline functions defined in foo.h
1111 will ever be output.
1113 There are cases when we want to link files such as "defs.h" and
1114 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1115 and "main.cc" has `#pragma implementation "defs.h"'. */
1120 struct impl_files *next;
1123 static struct impl_files *impl_file_chain;
1125 /* Helper function to load global variables with interface
1129 extract_interface_info ()
1133 if (flag_alt_external_templates)
1135 struct tinst_level *til = tinst_for_decl ();
1138 fileinfo = get_time_identifier (til->file);
1141 fileinfo = get_time_identifier (input_filename);
1142 fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
1143 interface_only = TREE_INT_CST_LOW (fileinfo);
1144 interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1147 /* Return nonzero if S is not considered part of an
1148 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1151 interface_strcmp (s)
1154 /* Set the interface/implementation bits for this scope. */
1155 struct impl_files *ifiles;
1158 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1160 char *t1 = ifiles->filename;
1163 if (*s1 != *t1 || *s1 == 0)
1166 while (*s1 == *t1 && *s1 != 0)
1173 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1174 if (index (s1, '.') || index (t1, '.'))
1177 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1189 set_typedecl_interface_info (prev, vars)
1190 tree prev ATTRIBUTE_UNUSED, vars;
1192 tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
1193 tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
1194 tree type = TREE_TYPE (vars);
1196 CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
1197 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars)));
1201 set_vardecl_interface_info (prev, vars)
1204 tree type = DECL_CONTEXT (vars);
1206 if (CLASSTYPE_INTERFACE_KNOWN (type))
1208 if (CLASSTYPE_INTERFACE_ONLY (type))
1209 set_typedecl_interface_info (prev, TYPE_MAIN_DECL (type));
1211 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
1212 DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
1213 TREE_PUBLIC (vars) = 1;
1219 /* Called from the top level: if there are any pending inlines to
1220 do, set up to process them now. This function sets up the first function
1221 to be parsed; after it has been, the rule for fndef in parse.y will
1222 call process_next_inline to start working on the next one. */
1225 do_pending_inlines ()
1227 struct pending_inline *t;
1230 /* Oops, we're still dealing with the last batch. */
1231 if (yychar == PRE_PARSED_FUNCTION_DECL)
1234 /* Reverse the pending inline functions, since
1235 they were cons'd instead of appended. */
1237 struct pending_inline *prev = 0, *tail;
1238 t = pending_inlines;
1239 pending_inlines = 0;
1254 /* Now start processing the first inline function. */
1255 context = hack_decl_function_context (t->fndecl);
1257 push_cp_function_context (context);
1258 maybe_begin_member_template_processing (t->fndecl);
1261 feed_input (t->buf, t->len);
1264 if (input_filename != t->filename)
1266 input_filename = t->filename;
1267 /* Get interface/implementation back in sync. */
1268 extract_interface_info ();
1271 input_filename = t->filename;
1272 interface_unknown = t->interface == 1;
1273 interface_only = t->interface == 0;
1275 yychar = PRE_PARSED_FUNCTION_DECL;
1277 /* Pass back a handle on the rest of the inline functions, so that they
1278 can be processed later. */
1279 yylval.ttype = build_tree_list ((tree) t, t->fndecl);
1280 DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
1283 static int nextchar = -1;
1285 /* Called from the fndecl rule in the parser when the function just parsed
1286 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1287 do_pending_inlines). */
1290 process_next_inline (t)
1294 struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
1295 context = hack_decl_function_context (i->fndecl);
1296 maybe_end_member_template_processing ();
1298 pop_cp_function_context (context);
1300 if (yychar == YYEMPTY)
1302 if (yychar != END_OF_SAVED_INPUT)
1304 error ("parse error at end of saved function text");
1306 /* restore_pending_input will abort unless yychar is either
1307 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1308 hosed, feed back YYEMPTY. We also need to discard nextchar,
1309 since that may have gotten set as well. */
1314 if (i && i->fndecl != NULL_TREE)
1316 context = hack_decl_function_context (i->fndecl);
1318 push_cp_function_context (context);
1319 maybe_begin_member_template_processing (i->fndecl);
1320 feed_input (i->buf, i->len);
1322 input_filename = i->filename;
1323 yychar = PRE_PARSED_FUNCTION_DECL;
1324 yylval.ttype = build_tree_list ((tree) i, i->fndecl);
1325 DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
1329 interface_unknown = i->interface == 1;
1330 interface_only = i->interface == 0;
1333 extract_interface_info ();
1336 /* Since inline methods can refer to text which has not yet been seen,
1337 we store the text of the method in a structure which is placed in the
1338 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1339 After parsing the body of the class definition, the FUNCTION_DECL's are
1340 scanned to see which ones have this field set. Those are then digested
1343 This function's FUNCTION_DECL will have a bit set in its common so
1344 that we know to watch out for it. */
1347 consume_string (this_obstack, matching_char)
1348 register struct obstack *this_obstack;
1352 int starting_lineno = lineno;
1358 int save_lineno = lineno;
1359 lineno = starting_lineno;
1360 if (matching_char == '"')
1361 error ("end of file encountered inside string constant");
1363 error ("end of file encountered inside character constant");
1364 lineno = save_lineno;
1369 obstack_1grow (this_obstack, c);
1371 obstack_1grow (this_obstack, c);
1373 /* Make sure we continue the loop */
1380 pedwarn ("ANSI C++ forbids newline in string constant");
1383 obstack_1grow (this_obstack, c);
1385 while (c != matching_char);
1388 static int nextyychar = YYEMPTY;
1389 static YYSTYPE nextyylval;
1391 struct pending_input {
1392 int nextchar, yychar, nextyychar, eof;
1393 YYSTYPE yylval, nextyylval;
1394 struct obstack token_obstack;
1398 struct pending_input *
1399 save_pending_input ()
1401 struct pending_input *p;
1402 p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1403 p->nextchar = nextchar;
1405 p->nextyychar = nextyychar;
1407 p->nextyylval = nextyylval;
1408 p->eof = end_of_file;
1409 yychar = nextyychar = YYEMPTY;
1411 p->first_token = first_token;
1412 p->token_obstack = token_obstack;
1415 gcc_obstack_init (&token_obstack);
1421 restore_pending_input (p)
1422 struct pending_input *p;
1424 my_friendly_assert (nextchar == -1, 229);
1425 nextchar = p->nextchar;
1426 my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1428 my_friendly_assert (nextyychar == YYEMPTY, 231);
1429 nextyychar = p->nextyychar;
1431 nextyylval = p->nextyylval;
1432 first_token = p->first_token;
1433 obstack_free (&token_obstack, (char *) 0);
1434 token_obstack = p->token_obstack;
1435 end_of_file = p->eof;
1439 /* Unget character CH from the input stream.
1440 If RESCAN is non-zero, then we want to `see' this
1441 character as the next input token. */
1444 yyungetc (ch, rescan)
1448 /* Unget a character from the input stream. */
1449 if (yychar == YYEMPTY || rescan == 0)
1452 put_back (nextchar);
1457 my_friendly_assert (nextyychar == YYEMPTY, 232);
1458 nextyychar = yychar;
1459 nextyylval = yylval;
1465 clear_inline_text_obstack ()
1467 obstack_free (&inline_text_obstack, inline_text_firstobj);
1470 /* This function stores away the text for an inline function that should
1471 be processed later. It decides how much later, and may need to move
1472 the info between obstacks; therefore, the caller should not refer to
1473 the T parameter after calling this function. */
1476 store_pending_inline (decl, t)
1478 struct pending_inline *t;
1481 DECL_PENDING_INLINE_INFO (decl) = t;
1483 /* Because we use obstacks, we must process these in precise order. */
1484 t->next = pending_inlines;
1485 pending_inlines = t;
1489 reinit_parse_for_method (yychar, decl)
1494 int starting_lineno = lineno;
1495 char *starting_filename = input_filename;
1497 reinit_parse_for_block (yychar, &inline_text_obstack);
1499 len = obstack_object_size (&inline_text_obstack);
1500 current_base_init_list = NULL_TREE;
1501 current_member_init_list = NULL_TREE;
1502 if (decl == void_type_node
1503 || (current_class_type && TYPE_REDEFINED (current_class_type)))
1505 /* Happens when we get two declarations of the same
1506 function in the same scope. */
1507 char *buf = obstack_finish (&inline_text_obstack);
1508 obstack_free (&inline_text_obstack, buf);
1513 struct pending_inline *t;
1514 char *buf = obstack_finish (&inline_text_obstack);
1516 t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1517 sizeof (struct pending_inline));
1518 t->lineno = starting_lineno;
1519 t->filename = starting_filename;
1526 if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
1527 warn_if_unknown_interface (decl);
1529 t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1530 store_pending_inline (decl, t);
1534 /* Consume a block -- actually, a method beginning
1535 with `:' or `{' -- and save it away on the specified obstack. */
1538 reinit_parse_for_block (pyychar, obstackp)
1540 struct obstack *obstackp;
1544 int starting_lineno = lineno;
1545 char *starting_filename = input_filename;
1547 int look_for_semicolon = 0;
1548 int look_for_lbrac = 0;
1551 obstack_1grow (obstackp, '{');
1552 else if (pyychar == '=')
1553 look_for_semicolon = 1;
1554 else if (pyychar == ':')
1556 obstack_1grow (obstackp, pyychar);
1560 else if (pyychar == RETURN)
1562 obstack_grow (obstackp, "return", 6);
1566 else if (pyychar == TRY)
1568 obstack_grow (obstackp, "try", 3);
1574 yyerror ("parse error in method specification");
1575 obstack_1grow (obstackp, '{');
1578 if (nextchar != EOF)
1588 int this_lineno = lineno;
1590 c = skip_white_space (c);
1592 /* Don't lose our cool if there are lots of comments. */
1593 if (lineno == this_lineno + 1)
1594 obstack_1grow (obstackp, '\n');
1595 else if (lineno == this_lineno)
1597 else if (lineno - this_lineno < 10)
1600 for (i = lineno - this_lineno; i > 0; i--)
1601 obstack_1grow (obstackp, '\n');
1606 sprintf (buf, "\n# %d \"", lineno);
1608 obstack_grow (obstackp, buf, len);
1610 len = strlen (input_filename);
1611 obstack_grow (obstackp, input_filename, len);
1612 obstack_1grow (obstackp, '\"');
1613 obstack_1grow (obstackp, '\n');
1616 while (c > ' ') /* ASCII dependent... */
1618 obstack_1grow (obstackp, c);
1627 if (blev == 0 && !look_for_semicolon)
1631 if (peekyylex () == CATCH)
1634 obstack_grow (obstackp, " catch ", 7);
1651 /* Don't act on the next character...e.g, doing an escaped
1656 error_with_file_and_line (starting_filename,
1658 "end of file read inside definition");
1661 obstack_1grow (obstackp, c);
1664 consume_string (obstackp, c);
1666 consume_string (obstackp, c);
1671 error ("function body for constructor missing");
1672 obstack_1grow (obstackp, '{');
1673 obstack_1grow (obstackp, '}');
1677 else if (look_for_semicolon && blev == 0)
1685 error_with_file_and_line (starting_filename,
1687 "end of file read inside definition");
1692 obstack_1grow (obstackp, c);
1697 obstack_1grow (obstackp, '\0');
1700 /* Consume a no-commas expression -- actually, a default argument -- and
1701 save it away on the specified obstack. */
1704 reinit_parse_for_expr (obstackp)
1705 struct obstack *obstackp;
1708 int starting_lineno = lineno;
1709 char *starting_filename = input_filename;
1713 if (nextchar != EOF)
1723 int this_lineno = lineno;
1725 c = skip_white_space (c);
1727 /* Don't lose our cool if there are lots of comments. */
1728 if (lineno == this_lineno + 1)
1729 obstack_1grow (obstackp, '\n');
1730 else if (lineno == this_lineno)
1732 else if (lineno - this_lineno < 10)
1735 for (i = lineno - this_lineno; i > 0; --i)
1736 obstack_1grow (obstackp, '\n');
1741 sprintf (buf, "\n# %d \"", lineno);
1743 obstack_grow (obstackp, buf, len);
1745 len = strlen (input_filename);
1746 obstack_grow (obstackp, input_filename, len);
1747 obstack_1grow (obstackp, '\"');
1748 obstack_1grow (obstackp, '\n');
1751 while (c > ' ') /* ASCII dependent... */
1753 if (plev <= 0 && (c == ')' || c == ','))
1758 obstack_1grow (obstackp, c);
1759 if (c == '(' || c == '[')
1761 else if (c == ']' || c == ')')
1765 /* Don't act on the next character...e.g, doing an escaped
1770 error_with_file_and_line (starting_filename,
1772 "end of file read inside definition");
1775 obstack_1grow (obstackp, c);
1778 consume_string (obstackp, c);
1780 consume_string (obstackp, c);
1786 error_with_file_and_line (starting_filename,
1788 "end of file read inside definition");
1793 obstack_1grow (obstackp, c);
1798 obstack_1grow (obstackp, '\0');
1801 int do_snarf_defarg;
1803 /* Decide whether the default argument we are about to see should be
1804 gobbled up as text for later parsing. */
1807 maybe_snarf_defarg ()
1809 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
1810 do_snarf_defarg = 1;
1813 /* When we see a default argument in a method declaration, we snarf it as
1814 text using snarf_defarg. When we get up to namespace scope, we then go
1815 through and parse all of them using do_pending_defargs. Since yacc
1816 parsers are not reentrant, we retain defargs state in these two
1817 variables so that subsequent calls to do_pending_defargs can resume
1818 where the previous call left off. */
1830 reinit_parse_for_expr (&inline_text_obstack);
1831 len = obstack_object_size (&inline_text_obstack);
1832 buf = obstack_finish (&inline_text_obstack);
1834 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1835 arg = make_node (DEFAULT_ARG);
1836 DEFARG_LENGTH (arg) = len - 1;
1837 DEFARG_POINTER (arg) = buf;
1843 /* Called from grokfndecl to note a function decl with unparsed default
1844 arguments for later processing. Also called from grokdeclarator
1845 for function types with unparsed defargs; the call from grokfndecl
1846 will always come second, so we can overwrite the entry from the type. */
1849 add_defarg_fn (decl)
1852 if (TREE_CODE (decl) == FUNCTION_DECL)
1853 TREE_VALUE (defarg_fns) = decl;
1856 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1857 defarg_fns = tree_cons (current_class_type, decl, defarg_fns);
1862 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1868 tree d = TREE_PURPOSE (p);
1869 feed_input (DEFARG_POINTER (d), DEFARG_LENGTH (d));
1870 if (TREE_CODE (f) == FUNCTION_DECL)
1872 lineno = DECL_SOURCE_LINE (f);
1873 input_filename = DECL_SOURCE_FILE (f);
1875 yychar = DEFARG_MARKER;
1879 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1884 if (yychar == YYEMPTY)
1886 if (yychar != END_OF_SAVED_INPUT)
1888 error ("parse error at end of saved function text");
1890 /* restore_pending_input will abort unless yychar is either
1891 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1892 hosed, feed back YYEMPTY. We also need to discard nextchar,
1893 since that may have gotten set as well. */
1900 /* Main function for deferred parsing of default arguments. Called from
1904 do_pending_defargs ()
1909 for (; defarg_fns; defarg_fns = TREE_CHAIN (defarg_fns))
1911 tree defarg_fn = TREE_VALUE (defarg_fns);
1912 if (defarg_parm == NULL_TREE)
1914 push_nested_class (TREE_PURPOSE (defarg_fns), 1);
1916 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1917 maybe_begin_member_template_processing (defarg_fn);
1919 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1923 for (p = DECL_ARGUMENTS (defarg_fn); p; p = TREE_CHAIN (p))
1924 pushdecl (copy_node (p));
1926 defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
1929 defarg_parm = TYPE_ARG_TYPES (defarg_fn);
1932 defarg_parm = TREE_CHAIN (defarg_parm);
1934 for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
1935 if (TREE_PURPOSE (defarg_parm)
1936 && TREE_CODE (TREE_PURPOSE (defarg_parm)) == DEFAULT_ARG)
1938 feed_defarg (defarg_fn, defarg_parm);
1940 /* Return to the parser, which will process this defarg
1941 and call us again. */
1945 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1947 maybe_end_member_template_processing ();
1948 check_default_args (defarg_fn);
1952 pop_nested_class (1);
1956 /* Build a default function named NAME for type TYPE.
1957 KIND says what to build.
1959 When KIND == 0, build default destructor.
1960 When KIND == 1, build virtual destructor.
1961 When KIND == 2, build default constructor.
1962 When KIND == 3, build default X(const X&) constructor.
1963 When KIND == 4, build default X(X&) constructor.
1964 When KIND == 5, build default operator = (const X&).
1965 When KIND == 6, build default operator = (X&). */
1968 cons_up_default_function (type, full_name, kind)
1969 tree type, full_name;
1972 extern tree void_list_node;
1973 tree declspecs = NULL_TREE;
1974 tree fn, args = NULL_TREE;
1977 tree name = constructor_name (full_name);
1983 declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
1984 /* Fall through... */
1986 name = build_parse_node (BIT_NOT_EXPR, name);
1987 args = void_list_node;
1991 /* Default constructor. */
1992 args = void_list_node;
1996 type = build_qualified_type (type, TYPE_QUAL_CONST);
1997 /* Fall through... */
1999 /* According to ARM $12.8, the default copy ctor will be declared, but
2000 not defined, unless it's needed. */
2001 argtype = build_reference_type (type);
2002 args = tree_cons (NULL_TREE,
2003 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
2004 get_identifier ("_ctor_arg")),
2011 declspecs = build_decl_list (NULL_TREE, type);
2014 type = build_qualified_type (type, TYPE_QUAL_CONST);
2016 name = ansi_opname [(int) MODIFY_EXPR];
2018 argtype = build_reference_type (type);
2019 args = tree_cons (NULL_TREE,
2020 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
2021 get_identifier ("_ctor_arg")),
2026 my_friendly_abort (59);
2029 declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE],
2032 TREE_PARMLIST (args) = 1;
2035 tree declarator = make_call_declarator (name, args, NULL_TREE, NULL_TREE);
2037 declarator = build_parse_node (ADDR_EXPR, declarator);
2039 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
2042 if (fn == void_type_node)
2046 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn)));
2049 if (processing_template_defn)
2051 SET_DECL_IMPLICIT_INSTANTIATION (fn);
2052 repo_template_used (fn);
2057 if (CLASSTYPE_INTERFACE_KNOWN (type))
2059 DECL_INTERFACE_KNOWN (fn) = 1;
2060 DECL_NOT_REALLY_EXTERN (fn) = (!CLASSTYPE_INTERFACE_ONLY (type)
2061 && flag_implement_inlines);
2065 DECL_NOT_REALLY_EXTERN (fn) = 1;
2067 mark_inline_for_output (fn);
2069 #ifdef DEBUG_DEFAULT_FUNCTIONS
2070 { char *fn_type = NULL;
2074 case 0: fn_type = "default destructor"; break;
2075 case 1: fn_type = "virtual destructor"; break;
2076 case 2: fn_type = "default constructor"; break;
2077 case 3: fn_type = "default X(const X&)"; break;
2078 case 4: fn_type = "default X(X&)"; break;
2082 if (TREE_CODE (name) == BIT_NOT_EXPR)
2083 t = TREE_OPERAND (name, 0);
2084 fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
2085 IDENTIFIER_POINTER (t), func_buf);
2088 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2090 /* Show that this function was generated by the compiler. */
2091 SET_DECL_ARTIFICIAL (fn);
2096 /* Heuristic to tell whether the user is missing a semicolon
2097 after a struct or enum declaration. Emit an error message
2098 if we know the user has blown it. */
2101 check_for_missing_semicolon (type)
2109 && yychar != IDENTIFIER
2110 && yychar != TYPENAME
2111 && yychar != CV_QUALIFIER
2112 && yychar != SELFNAME)
2115 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2116 error ("semicolon missing after %s declaration",
2117 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2119 cp_error ("semicolon missing after declaration of `%T'", type);
2120 shadow_tag (build_tree_list (0, type));
2122 /* Could probably also hack cases where class { ... } f (); appears. */
2127 note_got_semicolon (type)
2130 if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
2131 my_friendly_abort (60);
2132 if (CLASS_TYPE_P (type))
2133 CLASSTYPE_GOT_SEMICOLON (type) = 1;
2137 note_list_got_semicolon (declspecs)
2142 for (link = declspecs; link; link = TREE_CHAIN (link))
2144 tree type = TREE_VALUE (link);
2145 if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
2146 note_got_semicolon (type);
2151 /* If C is not whitespace, return C.
2152 Otherwise skip whitespace and return first nonwhite char read. */
2155 skip_white_space (c)
2163 c = check_newline ();
2174 while (c == ' ' || c == '\t');
2182 error ("stray '\\' in program");
2194 /* Make the token buffer longer, preserving the data in it.
2195 P should point to just beyond the last valid character in the old buffer.
2196 The value we return is a pointer to the new buffer
2197 at a place corresponding to P. */
2200 extend_token_buffer (p)
2203 int offset = p - token_buffer;
2205 maxtoken = maxtoken * 2 + 10;
2206 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2208 return token_buffer + offset;
2212 get_last_nonwhite_on_line ()
2216 /* Is this the last nonwhite stuff on the line? */
2218 c = nextchar, nextchar = -1;
2222 while (c == ' ' || c == '\t')
2227 #if defined HANDLE_PRAGMA
2228 /* Local versions of these macros, that can be passed as function pointers. */
2234 if (nextchar != EOF)
2251 #endif /* HANDLE_PRAGMA */
2253 /* At the beginning of a line, increment the line number
2254 and process any #-directive on this line.
2255 If the line is a #-directive, read the entire line and return a newline.
2256 Otherwise, return the line's first non-whitespace character. */
2260 static int handle_cp_pragma PROTO((char *));
2268 /* Read first nonwhite char on the line. Do this before incrementing the
2269 line number, in case we're at the end of saved text. */
2273 while (c == ' ' || c == '\t');
2279 /* If not #, return it so caller will use it. */
2283 /* Don't read beyond this line. */
2286 /* Read first nonwhite char after the `#'. */
2290 while (c == ' ' || c == '\t');
2292 /* If a letter follows, then if the word here is `line', skip
2293 it and ignore it; otherwise, ignore the line, with an error
2294 if the word isn't `pragma'. */
2296 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
2306 token = real_yylex ();
2307 if (token == IDENTIFIER
2308 && TREE_CODE (yylval.ttype) == IDENTIFIER_NODE)
2310 /* If this is 1, we handled it; if it's -1, it was one we
2311 wanted but had something wrong with it. Only if it's
2312 0 was it not handled. */
2313 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval.ttype)))
2316 else if (token == END_OF_LINE)
2319 #ifdef HANDLE_PRAGMA
2320 /* We invoke HANDLE_PRAGMA before HANDLE_GENERIC_PRAGMAS
2321 (if both are defined), in order to give the back
2322 end a chance to override the interpretation of
2323 SYSV style pragmas. */
2324 if (HANDLE_PRAGMA (pragma_getc, pragma_ungetc,
2325 IDENTIFIER_POINTER (yylval.ttype)))
2327 #endif /* HANDLE_PRAGMA */
2329 #ifdef HANDLE_GENERIC_PRAGMAS
2330 if (handle_generic_pragma (token))
2332 #endif /* HANDLE_GENERIC_PRAGMAS */
2334 /* Issue a warning message if we have been asked to do so.
2335 Ignoring unknown pragmas in system header file unless
2336 an explcit -Wunknown-pragmas has been given. */
2337 if (warn_unknown_pragmas > 1
2338 || (warn_unknown_pragmas && ! in_system_header))
2339 warning ("ignoring pragma: %s", token_buffer);
2351 && ((c = getch ()) == ' ' || c == '\t'))
2353 debug_define (lineno, GET_DIRECTIVE_LINE ());
2363 && ((c = getch ()) == ' ' || c == '\t'))
2365 debug_undef (lineno, GET_DIRECTIVE_LINE ());
2374 && ((c = getch ()) == ' ' || c == '\t'))
2383 && ((c = getch ()) == ' ' || c == '\t'))
2385 /* #ident. The pedantic warning is now in cccp.c. */
2387 /* Here we have just seen `#ident '.
2388 A string constant should follow. */
2390 token = real_yylex ();
2391 if (token == END_OF_LINE)
2394 || TREE_CODE (yylval.ttype) != STRING_CST)
2396 error ("invalid #ident");
2400 if (! flag_no_ident)
2402 #ifdef ASM_OUTPUT_IDENT
2403 ASM_OUTPUT_IDENT (asm_out_file,
2404 TREE_STRING_POINTER (yylval.ttype));
2408 /* Skip the rest of this line. */
2421 && ((c = getch ()) == ' ' || c == '\t'))
2423 /* Used to test incremental compilation. */
2424 sorry ("#pragma newworld");
2428 error ("undefined or invalid # directive");
2433 /* Here we have either `#line' or `# <nonletter>'.
2434 In either case, it should be a line number; a digit should follow. */
2436 while (c == ' ' || c == '\t')
2439 /* If the # is the only nonwhite char on the line,
2440 just ignore it. Check the new newline. */
2444 /* Something follows the #; read a token. */
2447 token = real_yylex ();
2449 if (token == CONSTANT
2450 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2452 int old_lineno = lineno;
2453 enum { act_none, act_push, act_pop } action = act_none;
2454 int entering_system_header = 0;
2455 int entering_c_header = 0;
2457 /* subtract one, because it is the following line that
2458 gets the specified number */
2460 int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2461 c = get_last_nonwhite_on_line ();
2464 /* No more: store the line number and check following line. */
2470 /* More follows: it must be a string constant (filename). */
2472 /* Read the string constant, but don't treat \ as special. */
2473 ignore_escape_flag = 1;
2474 token = real_yylex ();
2475 ignore_escape_flag = 0;
2477 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2479 error ("invalid #line");
2483 /* Changing files again. This means currently collected time
2484 is charged against header time, and body time starts back
2486 if (flag_detailed_statistics)
2488 int this_time = my_get_run_time ();
2489 tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2490 header_time += this_time - body_time;
2491 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
2492 += this_time - body_time;
2493 this_filename_time = time_identifier;
2494 body_time = this_time;
2498 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
2499 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
2501 GNU_xref_file (input_filename);
2503 if (main_input_filename == 0)
2505 struct impl_files *ifiles = impl_file_chain;
2509 while (ifiles->next)
2510 ifiles = ifiles->next;
2511 ifiles->filename = file_name_nondirectory (input_filename);
2514 main_input_filename = input_filename;
2515 if (write_virtuals == 3)
2516 walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
2519 extract_interface_info ();
2521 c = get_last_nonwhite_on_line ();
2524 /* Update the name in the top element of input_file_stack. */
2525 if (input_file_stack)
2526 input_file_stack->name = input_filename;
2532 token = real_yylex ();
2534 /* `1' after file name means entering new file.
2535 `2' after file name means just left a file. */
2537 if (token == CONSTANT
2538 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2540 if (TREE_INT_CST_LOW (yylval.ttype) == 1)
2542 else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
2547 c = get_last_nonwhite_on_line ();
2551 token = real_yylex ();
2556 /* `3' after file name means this is a system header file. */
2558 if (token == CONSTANT
2559 && TREE_CODE (yylval.ttype) == INTEGER_CST
2560 && TREE_INT_CST_LOW (yylval.ttype) == 3)
2562 entering_system_header = 1;
2564 c = get_last_nonwhite_on_line ();
2568 token = real_yylex ();
2572 /* `4' after file name means this is a C header file. */
2574 if (token == CONSTANT
2575 && TREE_CODE (yylval.ttype) == INTEGER_CST
2576 && TREE_INT_CST_LOW (yylval.ttype) == 4)
2578 entering_c_header = 1;
2580 c = get_last_nonwhite_on_line ();
2584 token = real_yylex ();
2588 /* Do the actions implied by the preceding numbers. */
2590 if (action == act_push)
2592 /* Pushing to a new file. */
2593 struct file_stack *p;
2595 p = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2596 input_file_stack->line = old_lineno;
2597 p->next = input_file_stack;
2598 p->name = input_filename;
2599 input_file_stack = p;
2600 input_file_stack_tick++;
2601 debug_start_source_file (input_filename);
2602 in_system_header = entering_system_header;
2605 else if (entering_c_header)
2608 ++pending_lang_change;
2611 else if (action == act_pop)
2613 /* Popping out of a file. */
2614 if (input_file_stack->next)
2616 struct file_stack *p;
2618 if (c_header_level && --c_header_level == 0)
2620 if (entering_c_header)
2621 warning ("badly nested C headers from preprocessor");
2622 --pending_lang_change;
2624 in_system_header = entering_system_header;
2626 p = input_file_stack;
2627 input_file_stack = p->next;
2629 input_file_stack_tick++;
2630 debug_end_source_file (input_file_stack->line);
2633 error ("#-lines for entering and leaving files don't match");
2636 in_system_header = entering_system_header;
2639 /* If NEXTCHAR is not end of line, we don't care what it is. */
2640 if (nextchar == EOF)
2644 error ("invalid #-line");
2646 /* skip the rest of this line. */
2651 while ((c = getch ()) != EOF && c != '\n');
2656 do_pending_lang_change ()
2658 for (; pending_lang_change > 0; --pending_lang_change)
2659 push_lang_context (lang_name_c);
2660 for (; pending_lang_change < 0; ++pending_lang_change)
2661 pop_lang_context ();
2664 #define ENDFILE -1 /* token that represents end-of-file */
2666 /* Read an escape sequence, returning its equivalent as a character,
2667 or store 1 in *ignore_ptr if it is backslash-newline. */
2670 readescape (ignore_ptr)
2673 register int c = getch ();
2675 register unsigned count;
2676 unsigned firstdig = 0;
2694 if (c >= 'a' && c <= 'f')
2695 code += c - 'a' + 10;
2696 if (c >= 'A' && c <= 'F')
2697 code += c - 'A' + 10;
2698 if (c >= '0' && c <= '9')
2700 if (code != 0 || count != 0)
2709 error ("\\x used with no following hex digits");
2710 else if (count == 0)
2711 /* Digits are all 0's. Ok. */
2713 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
2716 (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
2718 pedwarn ("hex escape out of range");
2721 case '0': case '1': case '2': case '3': case '4':
2722 case '5': case '6': case '7':
2725 while ((c <= '7') && (c >= '0') && (count++ < 3))
2727 code = (code * 8) + (c - '0');
2733 case '\\': case '\'': case '"':
2742 return TARGET_NEWLINE;
2765 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
2771 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2775 /* `\%' is used to prevent SCCS from getting confused. */
2778 pedwarn ("unknown escape sequence `\\%c'", c);
2781 if (c >= 040 && c < 0177)
2782 pedwarn ("unknown escape sequence `\\%c'", c);
2784 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
2788 /* Value is 1 (or 2) if we should try to make the next identifier look like
2789 a typename (when it may be a local variable or a class variable).
2790 Value is 0 if we treat this name in a default fashion. */
2791 int looking_for_typename;
2797 identifier_type (decl)
2801 if (TREE_CODE (decl) == TEMPLATE_DECL)
2803 if (TREE_CODE (DECL_RESULT (decl)) == TYPE_DECL)
2805 else if (looking_for_template)
2808 if (looking_for_template && really_overloaded_fn (decl))
2810 for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
2811 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
2814 if (TREE_CODE (decl) == NAMESPACE_DECL)
2816 if (TREE_CODE (decl) != TYPE_DECL)
2818 if (DECL_ARTIFICIAL (decl) && TREE_TYPE (decl) == current_class_type)
2821 /* A constructor declarator for a template type will get here as an
2822 implicit typename, a TYPENAME_TYPE with a type. */
2824 if (t && TREE_CODE (t) == TYPENAME_TYPE)
2826 decl = TREE_TYPE (decl);
2827 if (TREE_CODE (decl) == TYPENAME_TYPE)
2828 decl = TREE_TYPE (decl);
2838 /* Only types expected, not even namespaces. */
2839 looking_for_typename = 2;
2841 if ((yychar = yylex ()) < 0) yychar = 0;
2842 looking_for_typename = 0;
2843 if (yychar == IDENTIFIER)
2845 lastiddecl = lookup_name (yylval.ttype, -2);
2846 if (lastiddecl == 0)
2849 lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
2852 yychar = identifier_type (lastiddecl);
2856 /* Return true if d is in a global scope. */
2863 switch (TREE_CODE (d))
2868 case OVERLOAD: d = OVL_FUNCTION (d); continue;
2869 case TREE_LIST: d = TREE_VALUE (d); continue;
2871 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (d)) == 'd', 980629);
2872 d = CP_DECL_CONTEXT (d);
2873 return TREE_CODE (d) == NAMESPACE_DECL;
2878 do_identifier (token, parsing, args)
2879 register tree token;
2884 int lexing = (parsing == 1);
2885 int in_call = (parsing == 2);
2887 if (! lexing || IDENTIFIER_OPNAME_P (token))
2888 id = lookup_name (token, 0);
2892 /* Scope class declarations before global
2894 if ((!id || is_global (id))
2895 && current_class_type != 0
2896 && TYPE_SIZE (current_class_type) == 0)
2898 /* Could be from one of the base classes. */
2899 tree field = lookup_field (current_class_type, token, 1, 0);
2902 else if (field == error_mark_node)
2903 /* We have already generated the error message.
2904 But we still want to return this value. */
2905 id = lookup_field (current_class_type, token, 0, 0);
2906 else if (TREE_CODE (field) == VAR_DECL
2907 || TREE_CODE (field) == CONST_DECL
2908 || TREE_CODE (field) == TEMPLATE_DECL)
2910 else if (TREE_CODE (field) != FIELD_DECL)
2911 my_friendly_abort (61);
2914 cp_error ("invalid use of member `%D' from base class `%T'", field,
2915 DECL_FIELD_CONTEXT (field));
2916 id = error_mark_node;
2921 /* Do Koenig lookup if appropriate (inside templates we build lookup
2922 expressions instead). */
2923 if (args && !current_template_parms && (!id || is_global (id)))
2925 /* If we have arguments and we only found global names,
2926 do Koenig lookup. */
2927 id = lookup_arg_dependent (token, id, args);
2930 /* Remember that this name has been used in the class definition, as per
2932 if (id && current_class_type && parsing
2933 && TYPE_BEING_DEFINED (current_class_type)
2934 && ! IDENTIFIER_CLASS_VALUE (token)
2935 /* Avoid breaking if we get called for a default argument that
2936 refers to an overloaded method. Eventually this will not be
2937 necessary, since default arguments shouldn't be parsed until
2938 after the class is complete. (jason 3/12/97) */
2939 && TREE_CODE (id) != OVERLOAD)
2940 pushdecl_class_level (id);
2942 if (!id || id == error_mark_node)
2944 if (id == error_mark_node && current_class_type != NULL_TREE)
2946 id = lookup_nested_field (token, 1);
2947 /* In lookup_nested_field(), we marked this so we can gracefully
2948 leave this whole mess. */
2949 if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
2953 if (current_template_parms)
2954 return build_min_nt (LOOKUP_EXPR, token);
2955 else if (IDENTIFIER_OPNAME_P (token))
2957 if (token != ansi_opname[ERROR_MARK])
2958 cp_error ("`%D' not defined", token);
2959 id = error_mark_node;
2961 else if (in_call && ! flag_strict_prototype)
2963 id = implicitly_declare (token);
2965 else if (current_function_decl == 0)
2967 cp_error ("`%D' was not declared in this scope", token);
2968 id = error_mark_node;
2972 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
2973 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
2975 static int undeclared_variable_notice;
2977 cp_error ("`%D' undeclared (first use this function)", token);
2979 if (! undeclared_variable_notice)
2981 error ("(Each undeclared identifier is reported only once");
2982 error ("for each function it appears in.)");
2983 undeclared_variable_notice = 1;
2986 id = error_mark_node;
2987 /* Prevent repeated error messages. */
2988 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
2989 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
2993 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
2995 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
2996 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
2997 && DECL_DEAD_FOR_LOCAL (shadowed))
2998 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
3000 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
3003 if (!DECL_ERROR_REPORTED (id))
3005 warning ("name lookup of `%s' changed",
3006 IDENTIFIER_POINTER (token));
3007 cp_warning_at (" matches this `%D' under current ANSI rules",
3009 cp_warning_at (" matches this `%D' under old rules", id);
3010 DECL_ERROR_REPORTED (id) = 1;
3014 else if (!DECL_ERROR_REPORTED (id))
3017 = "name lookup of `%s' changed for new ANSI `for' scoping";
3018 DECL_ERROR_REPORTED (id) = 1;
3019 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id)))
3021 error (msg, IDENTIFIER_POINTER (token));
3022 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
3023 id = error_mark_node;
3027 pedwarn (msg, IDENTIFIER_POINTER (token));
3028 cp_pedwarn_at (" using obsolete binding at `%D'", id);
3032 /* TREE_USED is set in `hack_identifier'. */
3033 if (TREE_CODE (id) == CONST_DECL)
3035 if (IDENTIFIER_CLASS_VALUE (token) == id)
3038 tree access = compute_access (TYPE_BINFO (current_class_type), id);
3039 if (access == access_private_node)
3040 cp_error ("enum `%D' is private", id);
3041 /* protected is OK, since it's an enum of `this'. */
3043 if (!processing_template_decl
3044 /* Really, if we're processing a template, we just want to
3045 resolve template parameters, and not enumeration
3046 constants. But, they're hard to tell apart. (Note that
3047 a non-type template parameter may have enumeration type.)
3048 Fortunately, there's no harm in resolving *global*
3049 enumeration constants, since they can't depend on
3050 template parameters. */
3051 || (TREE_CODE (CP_DECL_CONTEXT (id)) == NAMESPACE_DECL
3052 && TREE_CODE (DECL_INITIAL (id)) == TEMPLATE_PARM_INDEX))
3053 id = DECL_INITIAL (id);
3056 id = hack_identifier (id, token);
3058 /* We must look up dependent names when the template is
3059 instantiated, not while parsing it. For now, we don't
3060 distinguish between dependent and independent names. So, for
3061 example, we look up all overloaded functions at
3062 instantiation-time, even though in some cases we should just use
3063 the DECL we have here. We also use LOOKUP_EXPRs to find things
3064 like local variables, rather than creating TEMPLATE_DECLs for the
3065 local variables and then finding matching instantiations. */
3066 if (current_template_parms
3067 && (is_overloaded_fn (id)
3068 /* If it's not going to be around at instantiation time, we
3069 look it up then. This is a hack, and should go when we
3070 really get dependent/independent name lookup right. */
3071 || !TREE_PERMANENT (id)
3072 /* Some local VAR_DECLs (such as those for local variables
3073 in member functions of local classes) are built on the
3074 permanent obstack. */
3075 || (TREE_CODE (id) == VAR_DECL
3076 && CP_DECL_CONTEXT (id)
3077 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
3078 || TREE_CODE (id) == PARM_DECL
3079 || TREE_CODE (id) == RESULT_DECL
3080 || TREE_CODE (id) == USING_DECL))
3081 id = build_min_nt (LOOKUP_EXPR, token);
3087 do_scoped_id (token, parsing)
3092 /* during parsing, this is ::name. Otherwise, it is black magic. */
3095 struct tree_binding _b;
3096 id = binding_init (&_b);
3097 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
3100 id = BINDING_VALUE (id);
3103 id = IDENTIFIER_GLOBAL_VALUE (token);
3104 if (parsing && yychar == YYEMPTY)
3108 if (processing_template_decl)
3110 id = build_min_nt (LOOKUP_EXPR, token);
3111 LOOKUP_EXPR_GLOBAL (id) = 1;
3114 if (parsing && (yychar == '(' || yychar == LEFT_RIGHT)
3115 && ! flag_strict_prototype)
3116 id = implicitly_declare (token);
3119 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
3120 cp_error ("`::%D' undeclared (first use here)", token);
3121 id = error_mark_node;
3122 /* Prevent repeated error messages. */
3123 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3128 if (TREE_CODE (id) == ADDR_EXPR)
3129 mark_used (TREE_OPERAND (id, 0));
3130 else if (TREE_CODE (id) != OVERLOAD)
3133 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
3135 /* XXX CHS - should we set TREE_USED of the constant? */
3136 id = DECL_INITIAL (id);
3137 /* This is to prevent an enum whose value is 0
3138 from being considered a null pointer constant. */
3139 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
3140 TREE_CONSTANT (id) = 1;
3143 if (processing_template_decl)
3145 if (is_overloaded_fn (id))
3147 id = build_min_nt (LOOKUP_EXPR, token);
3148 LOOKUP_EXPR_GLOBAL (id) = 1;
3151 /* else just use the decl */
3153 return convert_from_reference (id);
3157 identifier_typedecl_value (node)
3161 type = IDENTIFIER_TYPE_VALUE (node);
3162 if (type == NULL_TREE)
3167 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3170 do (IDENTIFIER_LOCAL_VALUE (node));
3171 do (IDENTIFIER_CLASS_VALUE (node));
3172 do (IDENTIFIER_NAMESPACE_VALUE (node));
3174 /* Will this one ever happen? */
3175 if (TYPE_MAIN_DECL (type))
3176 return TYPE_MAIN_DECL (type);
3178 /* We used to do an internal error of 62 here, but instead we will
3179 handle the return of a null appropriately in the callers. */
3189 int dollar_seen = 0;
3193 c = nextchar, nextchar = -1;
3197 /* Effectively do c = skip_white_space (c)
3198 but do it faster in the usual cases. */
3211 /* Call skip_white_space so we can warn if appropriate. */
3216 c = skip_white_space (c);
3218 goto found_nonwhite;
3222 token_buffer[0] = c;
3223 token_buffer[1] = 0;
3225 /* yylloc.first_line = lineno; */
3230 token_buffer[0] = '\0';
3232 if (input_redirected ())
3233 value = END_OF_SAVED_INPUT;
3235 value = END_OF_LINE;
3241 if (! dollars_in_ident)
3242 error ("`$' in identifier");
3244 pedwarn ("`$' in identifier");
3249 /* Capital L may start a wide-string or wide-character constant. */
3251 register int c = getch ();
3260 goto string_constant;
3265 case 'A': case 'B': case 'C': case 'D': case 'E':
3266 case 'F': case 'G': case 'H': case 'I': case 'J':
3267 case 'K': case 'M': case 'N': case 'O':
3268 case 'P': case 'Q': case 'R': case 'S': case 'T':
3269 case 'U': case 'V': case 'W': case 'X': case 'Y':
3271 case 'a': case 'b': case 'c': case 'd': case 'e':
3272 case 'f': case 'g': case 'h': case 'i': case 'j':
3273 case 'k': case 'l': case 'm': case 'n': case 'o':
3274 case 'p': case 'q': case 'r': case 's': case 't':
3275 case 'u': case 'v': case 'w': case 'x': case 'y':
3285 /* We know that `token_buffer' can hold at least on char,
3286 so we install C immediately.
3287 We may have to read the value in `putback_char', so call
3292 /* Make this run fast. We know that we are reading straight
3293 from FINPUT in this case (since identifiers cannot straddle
3295 while (ISALNUM (c) || (c == '_') || c == '$')
3299 if (! dollars_in_ident)
3300 error ("`$' in identifier");
3302 pedwarn ("`$' in identifier");
3305 if (p >= token_buffer + maxtoken)
3306 p = extend_token_buffer (p);
3312 if (linemode && c == '\n')
3320 /* We know that `token_buffer' can hold at least on char,
3321 so we install C immediately. */
3325 while (ISALNUM (c) || (c == '_') || c == '$')
3329 if (! dollars_in_ident)
3330 error ("`$' in identifier");
3332 pedwarn ("`$' in identifier");
3335 if (p >= token_buffer + maxtoken)
3336 p = extend_token_buffer (p);
3349 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3352 register struct resword *ptr;
3354 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
3358 tree old_ttype = ridpointers[(int) ptr->rid];
3360 /* If this provides a type for us, then revert lexical
3361 state to standard state. */
3362 if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
3363 && IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
3364 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
3365 looking_for_typename = 0;
3366 else if (ptr->token == AGGR || ptr->token == ENUM)
3367 looking_for_typename = 2;
3369 /* Check if this is a language-type declaration.
3370 Just glimpse the next non-white character. */
3371 nextchar = skip_white_space (nextchar);
3372 if (nextchar == '"')
3374 /* We are looking at a string. Complain
3375 if the token before the string is no `extern'.
3377 Could cheat some memory by placing this string
3378 on the temporary_, instead of the saveable_
3381 if (ptr->rid != RID_EXTERN)
3382 error ("invalid modifier `%s' for language string",
3385 value = EXTERN_LANG_STRING;
3386 yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
3389 if (ptr->token == VISSPEC)
3394 yylval.ttype = access_public_node;
3397 yylval.ttype = access_private_node;
3400 yylval.ttype = access_protected_node;
3403 my_friendly_abort (63);
3407 yylval.ttype = old_ttype;
3409 else if (ptr->token == EQCOMPARE)
3411 yylval.code = NE_EXPR;
3412 token_buffer[0] = '!';
3413 token_buffer[1] = '=';
3414 token_buffer[2] = 0;
3416 else if (ptr->token == ASSIGN)
3418 if (strcmp ("and_eq", token_buffer) == 0)
3420 yylval.code = BIT_AND_EXPR;
3421 token_buffer[0] = '&';
3423 else if (strcmp ("or_eq", token_buffer) == 0)
3425 yylval.code = BIT_IOR_EXPR;
3426 token_buffer[0] = '|';
3428 else if (strcmp ("xor_eq", token_buffer) == 0)
3430 yylval.code = BIT_XOR_EXPR;
3431 token_buffer[0] = '^';
3433 token_buffer[1] = '=';
3434 token_buffer[2] = 0;
3436 else if (ptr->token == '&')
3438 yylval.code = BIT_AND_EXPR;
3439 token_buffer[0] = '&';
3440 token_buffer[1] = 0;
3442 else if (ptr->token == '|')
3444 yylval.code = BIT_IOR_EXPR;
3445 token_buffer[0] = '|';
3446 token_buffer[1] = 0;
3448 else if (ptr->token == '^')
3450 yylval.code = BIT_XOR_EXPR;
3451 token_buffer[0] = '^';
3452 token_buffer[1] = 0;
3455 value = (int) ptr->token;
3459 /* If we did not find a keyword, look for an identifier
3462 if (value == IDENTIFIER || value == TYPESPEC)
3463 GNU_xref_ref (current_function_decl, token_buffer);
3465 if (value == IDENTIFIER)
3467 register tree tmp = get_identifier (token_buffer);
3469 #if !defined(VMS) && defined(JOINER)
3470 /* Make sure that user does not collide with our internal
3474 && (THIS_NAME_P (tmp)
3475 || VPTR_NAME_P (tmp)
3476 || DESTRUCTOR_NAME_P (tmp)
3477 || VTABLE_NAME_P (tmp)
3478 || TEMP_NAME_P (tmp)
3479 || ANON_AGGRNAME_P (tmp)
3480 || ANON_PARMNAME_P (tmp)))
3481 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3487 if (value == NEW && ! global_bindings_p ())
3497 register int c1 = getch ();
3498 token_buffer[0] = c;
3499 token_buffer[1] = c1;
3503 token_buffer[2] = 0;
3511 token_buffer[2] = c1;
3512 token_buffer[3] = 0;
3516 error ("parse error at `..'");
3521 goto resume_numerical_scan;
3525 token_buffer[1] = 0;
3529 /* Optimize for most frequent case. */
3531 register int c1 = getch ();
3532 if (! ISALNUM (c1) && c1 != '.')
3534 /* Terminate string. */
3535 token_buffer[0] = c;
3536 token_buffer[1] = 0;
3538 yylval.ttype = integer_zero_node;
3540 yylval.ttype = integer_one_node;
3547 /* fall through... */
3548 case '2': case '3': case '4':
3549 case '5': case '6': case '7': case '8': case '9':
3550 resume_numerical_scan:
3555 int largest_digit = 0;
3557 /* for multi-precision arithmetic,
3558 we actually store only HOST_BITS_PER_CHAR bits in each part.
3559 The number of parts is chosen so as to be sufficient to hold
3560 the enough bits to fit into the two HOST_WIDE_INTs that contain
3561 the integer value (this is always at least as many bits as are
3562 in a target `long long' value, but may be wider). */
3563 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3564 int parts[TOTAL_PARTS];
3567 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
3570 for (count = 0; count < TOTAL_PARTS; count++)
3578 *p++ = (c = getch ());
3579 if ((c == 'x') || (c == 'X'))
3582 *p++ = (c = getch ());
3584 /* Leading 0 forces octal unless the 0 is the only digit. */
3585 else if (c >= '0' && c <= '9')
3594 /* Read all the digits-and-decimal-points. */
3597 || (ISALNUM (c) && (c != 'l') && (c != 'L')
3598 && (c != 'u') && (c != 'U')
3599 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
3600 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
3605 error ("floating constant may not be in radix 16");
3606 if (floatflag == TOO_MANY_POINTS)
3607 /* We have already emitted an error. Don't need another. */
3609 else if (floatflag == AFTER_POINT)
3611 error ("malformed floating constant");
3612 floatflag = TOO_MANY_POINTS;
3613 /* Avoid another error from atof by forcing all characters
3614 from here on to be ignored. */
3618 floatflag = AFTER_POINT;
3621 *p++ = c = getch ();
3622 /* Accept '.' as the start of a floating-point number
3623 only when it is followed by a digit.
3624 Otherwise, unread the following non-digit
3625 and use the '.' as a structural token. */
3626 if (p == token_buffer + 2 && !ISDIGIT (c))
3638 error ("parse error at `..'");
3641 token_buffer[1] = '\0';
3648 /* It is not a decimal point.
3649 It should be a digit (perhaps a hex digit). */
3655 else if (base <= 10)
3657 if (c == 'e' || c == 'E')
3660 floatflag = AFTER_POINT;
3661 break; /* start of exponent */
3663 error ("nondigits in number and not hexadecimal");
3674 if (c >= largest_digit)
3678 for (count = 0; count < TOTAL_PARTS; count++)
3680 parts[count] *= base;
3684 += (parts[count-1] >> HOST_BITS_PER_CHAR);
3686 &= (1 << HOST_BITS_PER_CHAR) - 1;
3692 /* If the extra highest-order part ever gets anything in it,
3693 the number is certainly too big. */
3694 if (parts[TOTAL_PARTS - 1] != 0)
3697 if (p >= token_buffer + maxtoken - 3)
3698 p = extend_token_buffer (p);
3699 *p++ = (c = getch ());
3704 error ("numeric constant with no digits");
3706 if (largest_digit >= base)
3707 error ("numeric constant contains digits beyond the radix");
3709 /* Remove terminating char from the token buffer and delimit the string */
3712 if (floatflag != NOT_FLOAT)
3714 tree type = double_type_node;
3715 int exceeds_double = 0;
3717 REAL_VALUE_TYPE value;
3720 /* Read explicit exponent if any, and put it in tokenbuf. */
3722 if ((c == 'e') || (c == 'E'))
3724 if (p >= token_buffer + maxtoken - 3)
3725 p = extend_token_buffer (p);
3728 if ((c == '+') || (c == '-'))
3734 error ("floating constant exponent has no digits");
3737 if (p >= token_buffer + maxtoken - 3)
3738 p = extend_token_buffer (p);
3747 /* Convert string to a double, checking for overflow. */
3748 if (setjmp (handler))
3750 error ("floating constant out of range");
3755 int fflag = 0, lflag = 0;
3756 /* Copy token_buffer now, while it has just the number
3757 and not the suffixes; once we add `f' or `i',
3758 REAL_VALUE_ATOF may not work any more. */
3759 char *copy = (char *) alloca (p - token_buffer + 1);
3760 bcopy (token_buffer, copy, p - token_buffer + 1);
3762 set_float_handler (handler);
3768 /* Read the suffixes to choose a data type. */
3773 error ("more than one `f' in numeric constant");
3779 error ("more than one `l' in numeric constant");
3785 error ("more than one `i' or `j' in numeric constant");
3787 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3798 if (p >= token_buffer + maxtoken - 3)
3799 p = extend_token_buffer (p);
3805 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3806 tells the desired precision of the binary result
3807 of decimal-to-binary conversion. */
3812 error ("both `f' and `l' in floating constant");
3814 type = float_type_node;
3815 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3816 /* A diagnostic is required here by some ANSI C testsuites.
3817 This is not pedwarn, become some people don't want
3818 an error for this. */
3819 if (REAL_VALUE_ISINF (value) && pedantic)
3820 warning ("floating point number exceeds range of `float'");
3824 type = long_double_type_node;
3825 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3826 if (REAL_VALUE_ISINF (value) && pedantic)
3827 warning ("floating point number exceeds range of `long double'");
3831 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3832 if (REAL_VALUE_ISINF (value) && pedantic)
3833 warning ("floating point number exceeds range of `double'");
3836 set_float_handler (NULL_PTR);
3839 if (errno == ERANGE && pedantic)
3841 /* ERANGE is also reported for underflow,
3842 so test the value to distinguish overflow from that. */
3843 if (REAL_VALUES_LESS (dconst1, value)
3844 || REAL_VALUES_LESS (value, dconstm1))
3846 pedwarn ("floating point number exceeds range of `%s'",
3847 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type)));
3853 /* If the result is not a number, assume it must have been
3854 due to some error message above, so silently convert
3856 if (REAL_VALUE_ISNAN (value))
3859 /* Create a node with determined type and value. */
3861 yylval.ttype = build_complex (NULL_TREE,
3862 cp_convert (type, integer_zero_node),
3863 build_real (type, value));
3865 yylval.ttype = build_real (type, value);
3870 HOST_WIDE_INT high, low;
3871 int spec_unsigned = 0;
3873 int spec_long_long = 0;
3879 if (c == 'u' || c == 'U')
3882 error ("two `u's in integer constant");
3885 else if (c == 'l' || c == 'L')
3890 error ("three `l's in integer constant");
3891 else if (pedantic && ! in_system_header && warn_long_long)
3892 pedwarn ("ANSI C++ forbids long long integer constants");
3897 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
3900 error ("more than one `i' or `j' in numeric constant");
3902 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3907 if (p >= token_buffer + maxtoken - 3)
3908 p = extend_token_buffer (p);
3913 /* If the constant is not long long and it won't fit in an
3914 unsigned long, or if the constant is long long and won't fit
3915 in an unsigned long long, then warn that the constant is out
3918 /* ??? This assumes that long long and long integer types are
3919 a multiple of 8 bits. This better than the original code
3920 though which assumed that long was exactly 32 bits and long
3921 long was exactly 64 bits. */
3924 bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
3926 bytes = TYPE_PRECISION (long_integer_type_node) / 8;
3929 for (i = bytes; i < TOTAL_PARTS; i++)
3933 pedwarn ("integer constant out of range");
3935 /* This is simplified by the fact that our constant
3936 is always positive. */
3939 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
3941 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
3942 / HOST_BITS_PER_CHAR)]
3943 << (i * HOST_BITS_PER_CHAR));
3944 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
3948 yylval.ttype = build_int_2 (low, high);
3949 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
3951 /* Calculate the ANSI type. */
3952 if (!spec_long && !spec_unsigned
3953 && int_fits_type_p (yylval.ttype, integer_type_node))
3954 type = integer_type_node;
3955 else if (!spec_long && (base != 10 || spec_unsigned)
3956 && int_fits_type_p (yylval.ttype, unsigned_type_node))
3957 /* Nondecimal constants try unsigned even in traditional C. */
3958 type = unsigned_type_node;
3959 else if (!spec_unsigned && !spec_long_long
3960 && int_fits_type_p (yylval.ttype, long_integer_type_node))
3961 type = long_integer_type_node;
3962 else if (! spec_long_long)
3963 type = long_unsigned_type_node;
3964 else if (! spec_unsigned
3965 /* Verify value does not overflow into sign bit. */
3966 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
3967 && int_fits_type_p (yylval.ttype,
3968 long_long_integer_type_node))
3969 type = long_long_integer_type_node;
3971 type = long_long_unsigned_type_node;
3973 if (!int_fits_type_p (yylval.ttype, type) && !warn)
3974 pedwarn ("integer constant out of range");
3976 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
3977 warning ("decimal integer constant is so large that it is unsigned");
3981 if (TYPE_PRECISION (type)
3982 <= TYPE_PRECISION (integer_type_node))
3984 = build_complex (NULL_TREE, integer_zero_node,
3985 cp_convert (integer_type_node,
3988 error ("complex integer constant is too wide for `__complex int'");
3991 TREE_TYPE (yylval.ttype) = type;
3997 value = CONSTANT; break;
4003 register int result = 0;
4004 register int num_chars = 0;
4006 unsigned width = TYPE_PRECISION (char_type_node);
4008 #ifdef MULTIBYTE_CHARS
4009 int longest_char = local_mb_cur_max ();
4010 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
4013 max_chars = TYPE_PRECISION (integer_type_node) / width;
4015 width = WCHAR_TYPE_SIZE;
4022 if (c == '\'' || c == EOF)
4029 c = readescape (&ignore);
4032 if (width < HOST_BITS_PER_INT
4033 && (unsigned) c >= ((unsigned)1 << width))
4034 pedwarn ("escape sequence out of range for character");
4035 #ifdef MAP_CHARACTER
4037 c = MAP_CHARACTER (c);
4043 pedwarn ("ANSI C forbids newline in character constant");
4048 #ifdef MULTIBYTE_CHARS
4052 for (i = 1; i <= longest_char; ++i)
4054 if (i > maxtoken - 4)
4055 extend_token_buffer (token_buffer);
4057 token_buffer[i] = c;
4058 char_len = local_mbtowc (& wc,
4067 /* mbtowc sometimes needs an extra char before accepting */
4072 /* Merge character into result; ignore excess chars. */
4073 for (i = 1; i <= char_len; ++i)
4077 if (width < HOST_BITS_PER_INT)
4078 result = (result << width)
4080 & ((1 << width) - 1));
4082 result = token_buffer[i];
4084 num_chars += char_len;
4092 warning ("Ignoring invalid multibyte character");
4095 #ifdef MAP_CHARACTER
4097 c = MAP_CHARACTER (c);
4100 #else /* ! MULTIBYTE_CHARS */
4101 #ifdef MAP_CHARACTER
4102 c = MAP_CHARACTER (c);
4104 #endif /* ! MULTIBYTE_CHARS */
4109 if (chars_seen == 1) /* only keep the first one */
4114 /* Merge character into result; ignore excess chars. */
4116 if (num_chars < max_chars + 1)
4118 if (width < HOST_BITS_PER_INT)
4119 result = (result << width) | (c & ((1 << width) - 1));
4126 error ("malformatted character constant");
4127 else if (chars_seen == 0)
4128 error ("empty character constant");
4129 else if (num_chars > max_chars)
4131 num_chars = max_chars;
4132 error ("character constant too long");
4134 else if (chars_seen != 1 && warn_multichar)
4135 warning ("multi-character character constant");
4137 /* If char type is signed, sign-extend the constant. */
4140 int num_bits = num_chars * width;
4142 /* We already got an error; avoid invalid shift. */
4143 yylval.ttype = build_int_2 (0, 0);
4144 else if (TREE_UNSIGNED (char_type_node)
4145 || ((result >> (num_bits - 1)) & 1) == 0)
4147 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
4148 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4152 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
4153 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4155 if (chars_seen <= 1)
4156 TREE_TYPE (yylval.ttype) = char_type_node;
4158 TREE_TYPE (yylval.ttype) = integer_type_node;
4162 yylval.ttype = build_int_2 (result, 0);
4163 TREE_TYPE (yylval.ttype) = wchar_type_node;
4174 unsigned width = wide_flag ? WCHAR_TYPE_SIZE
4175 : TYPE_PRECISION (char_type_node);
4176 #ifdef MULTIBYTE_CHARS
4177 int longest_char = local_mb_cur_max ();
4178 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
4182 p = token_buffer + 1;
4184 while (c != '"' && c >= 0)
4186 /* ignore_escape_flag is set for reading the filename in #line. */
4187 if (!ignore_escape_flag && c == '\\')
4190 c = readescape (&ignore);
4193 if (width < HOST_BITS_PER_INT
4194 && (unsigned) c >= ((unsigned)1 << width))
4195 warning ("escape sequence out of range for character");
4200 pedwarn ("ANSI C++ forbids newline in string constant");
4205 #ifdef MULTIBYTE_CHARS
4209 for (i = 0; i < longest_char; ++i)
4211 if (p + i >= token_buffer + maxtoken)
4212 p = extend_token_buffer (p);
4215 char_len = local_mbtowc (& wc, p, i + 1);
4221 warning ("Ignoring invalid multibyte character");
4224 /* mbtowc sometimes needs an extra char before accepting */
4235 #endif /* MULTIBYTE_CHARS */
4238 /* Add this single character into the buffer either as a wchar_t
4239 or as a single byte. */
4242 unsigned width = TYPE_PRECISION (char_type_node);
4243 unsigned bytemask = (1 << width) - 1;
4246 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4247 p = extend_token_buffer (p);
4249 for (byte = 0; byte < WCHAR_BYTES; ++byte)
4252 if (byte >= (int) sizeof(c))
4255 value = (c >> (byte * width)) & bytemask;
4256 if (BYTES_BIG_ENDIAN)
4257 p[WCHAR_BYTES - byte - 1] = value;
4265 if (p >= token_buffer + maxtoken)
4266 p = extend_token_buffer (p);
4273 error ("Unterminated string");
4278 /* Terminate the string value, either with a single byte zero
4279 or with a wide zero. */
4282 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4283 p = extend_token_buffer (p);
4284 bzero (p, WCHAR_BYTES);
4289 if (p >= token_buffer + maxtoken)
4290 p = extend_token_buffer (p);
4294 /* We have read the entire constant.
4295 Construct a STRING_CST for the result. */
4297 if (processing_template_decl)
4298 push_obstacks (&permanent_obstack, &permanent_obstack);
4299 yylval.ttype = build_string (p - (token_buffer + 1), token_buffer + 1);
4300 if (processing_template_decl)
4304 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4306 TREE_TYPE (yylval.ttype) = char_array_type_node;
4308 value = STRING; break;
4331 yylval.code = PLUS_EXPR; break;
4333 yylval.code = MINUS_EXPR; break;
4335 yylval.code = BIT_AND_EXPR; break;
4337 yylval.code = BIT_IOR_EXPR; break;
4339 yylval.code = MULT_EXPR; break;
4341 yylval.code = TRUNC_DIV_EXPR; break;
4343 yylval.code = TRUNC_MOD_EXPR; break;
4345 yylval.code = BIT_XOR_EXPR; break;
4347 yylval.code = LSHIFT_EXPR; break;
4349 yylval.code = RSHIFT_EXPR; break;
4351 yylval.code = LT_EXPR; break;
4353 yylval.code = GT_EXPR; break;
4356 token_buffer[1] = c1 = getch ();
4357 token_buffer[2] = 0;
4364 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4366 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4368 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4370 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4372 value = ASSIGN; goto done;
4378 value = PLUSPLUS; goto done;
4380 value = MINUSMINUS; goto done;
4382 value = ANDAND; goto done;
4384 value = OROR; goto done;
4392 else if ((c == '-') && (c1 == '>'))
4394 nextchar = getch ();
4395 if (nextchar == '*')
4398 value = POINTSAT_STAR;
4404 else if (c1 == '?' && (c == '<' || c == '>'))
4406 token_buffer[3] = 0;
4409 yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4412 /* <?= or >?= expression. */
4413 token_buffer[2] = c1;
4422 pedwarn ("use of `operator %s' is not standard C++",
4427 else if (c == '<' && c1 == '%')
4428 { value = '{'; goto done; }
4429 else if (c == '<' && c1 == ':')
4430 { value = '['; goto done; }
4431 else if (c == '%' && c1 == '>')
4432 { value = '}'; goto done; }
4433 else if (c == '%' && c1 == ':')
4434 { value = '#'; goto done; }
4437 token_buffer[1] = 0;
4447 token_buffer[1] = ':';
4448 token_buffer[2] = '\0';
4465 /* Don't make yyparse think this is eof. */
4470 /* try, weakly, to handle casts to pointers to functions. */
4471 nextchar = skip_white_space (getch ());
4472 if (nextchar == '*')
4474 int next_c = skip_white_space (getch ());
4478 yylval.ttype = build1 (INDIRECT_REF, 0, 0);
4479 value = PAREN_STAR_PAREN;
4487 else if (nextchar == ')')
4490 yylval.ttype = NULL_TREE;
4501 /* yylloc.last_line = lineno; */
4502 #ifdef GATHER_STATISTICS
4503 #ifdef REDUCE_LENGTH
4504 token_count[value] += 1;
4515 return !!is_reserved_word (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
4518 #ifdef GATHER_STATISTICS
4519 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4520 need to be brought into here, unless this were actually put into a header
4522 /* Statistics-gathering stuff. */
4543 extern int tree_node_counts[];
4544 extern int tree_node_sizes[];
4547 /* Place to save freed lang_decls which were allocated on the
4548 permanent_obstack. @@ Not currently used. */
4549 tree free_lang_decl_chain;
4552 build_lang_decl (code, name, type)
4553 enum tree_code code;
4557 register tree t = build_decl (code, name, type);
4558 struct obstack *obstack = current_obstack;
4559 register int i = sizeof (struct lang_decl) / sizeof (int);
4562 if (! TREE_PERMANENT (t))
4563 obstack = saveable_obstack;
4565 /* Could be that saveable is permanent and current is not. */
4566 obstack = &permanent_obstack;
4568 if (free_lang_decl_chain && obstack == &permanent_obstack)
4570 pi = (int *)free_lang_decl_chain;
4571 free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
4574 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4579 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4580 LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4581 = obstack == &permanent_obstack;
4582 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4583 == TREE_PERMANENT (t), 234);
4584 DECL_MAIN_VARIANT (t) = t;
4585 if (current_lang_name == lang_name_cplusplus)
4586 DECL_LANGUAGE (t) = lang_cplusplus;
4587 else if (current_lang_name == lang_name_c)
4588 DECL_LANGUAGE (t) = lang_c;
4589 else if (current_lang_name == lang_name_java)
4590 DECL_LANGUAGE (t) = lang_java;
4591 else my_friendly_abort (64);
4593 #if 0 /* not yet, should get fixed properly later */
4594 if (code == TYPE_DECL)
4597 id = get_identifier (build_overload_name (type, 1, 1));
4598 DECL_ASSEMBLER_NAME (t) = id;
4602 #ifdef GATHER_STATISTICS
4603 tree_node_counts[(int)lang_decl] += 1;
4604 tree_node_sizes[(int)lang_decl] += sizeof (struct lang_decl);
4611 build_lang_field_decl (code, name, type)
4612 enum tree_code code;
4616 extern struct obstack *current_obstack, *saveable_obstack;
4617 register tree t = build_decl (code, name, type);
4618 struct obstack *obstack = current_obstack;
4619 register int i = sizeof (struct lang_decl_flags) / sizeof (int);
4621 #if 0 /* not yet, should get fixed properly later */
4623 if (code == TYPE_DECL)
4626 id = get_identifier (build_overload_name (type, 1, 1));
4627 DECL_ASSEMBLER_NAME (t) = id;
4631 if (! TREE_PERMANENT (t))
4632 obstack = saveable_obstack;
4634 my_friendly_assert (obstack == &permanent_obstack, 235);
4636 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
4640 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4645 copy_lang_decl (node)
4651 if (! DECL_LANG_SPECIFIC (node))
4654 if (TREE_CODE (node) == FIELD_DECL)
4655 size = sizeof (struct lang_decl_flags);
4657 size = sizeof (struct lang_decl);
4658 pi = (int *)obstack_alloc (&permanent_obstack, size);
4659 bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
4660 DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
4664 make_lang_type (code)
4665 enum tree_code code;
4667 extern struct obstack *current_obstack, *saveable_obstack;
4668 register tree t = make_node (code);
4670 /* Set up some flags that give proper default behavior. */
4671 if (IS_AGGR_TYPE_CODE (code))
4673 struct obstack *obstack = current_obstack;
4674 register int i = sizeof (struct lang_type) / sizeof (int);
4677 SET_IS_AGGR_TYPE (t, 1);
4679 if (! TREE_PERMANENT (t))
4680 obstack = saveable_obstack;
4682 my_friendly_assert (obstack == &permanent_obstack, 236);
4684 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
4688 TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
4689 CLASSTYPE_AS_LIST (t) = build_expr_list (NULL_TREE, t);
4690 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
4691 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
4692 TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE);
4693 CLASSTYPE_BINFO_AS_LIST (t)
4694 = build_tree_list (NULL_TREE, TYPE_BINFO (t));
4696 /* Make sure this is laid out, for ease of use later. In the
4697 presence of parse errors, the normal was of assuring this
4698 might not ever get executed, so we lay it out *immediately*. */
4699 build_pointer_type (t);
4701 #ifdef GATHER_STATISTICS
4702 tree_node_counts[(int)lang_type] += 1;
4703 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
4707 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
4708 TYPE_ALIAS_SET is initialized to -1 by default, so we must
4710 TYPE_ALIAS_SET (t) = 0;
4716 dump_time_statistics ()
4718 register tree prev = 0, decl, next;
4719 int this_time = my_get_run_time ();
4720 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
4721 += this_time - body_time;
4723 fprintf (stderr, "\n******\n");
4724 print_time ("header files (total)", header_time);
4725 print_time ("main file (total)", this_time - body_time);
4726 fprintf (stderr, "ratio = %g : 1\n",
4727 (double)header_time / (double)(this_time - body_time));
4728 fprintf (stderr, "\n******\n");
4730 for (decl = filename_times; decl; decl = next)
4732 next = IDENTIFIER_GLOBAL_VALUE (decl);
4733 SET_IDENTIFIER_GLOBAL_VALUE (decl, prev);
4737 for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
4738 print_time (IDENTIFIER_POINTER (decl),
4739 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
4743 compiler_error (s, v, v2)
4745 HOST_WIDE_INT v, v2; /* @@also used as pointer */
4748 sprintf (buf, s, v, v2);
4749 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
4756 extern int end_of_file;
4759 strcpy (buf, string);
4761 /* We can't print string and character constants well
4762 because the token_buffer contains the result of processing escapes. */
4764 strcat (buf, input_redirected ()
4765 ? " at end of saved text"
4766 : " at end of input");
4767 else if (token_buffer[0] == 0)
4768 strcat (buf, " at null character");
4769 else if (token_buffer[0] == '"')
4770 strcat (buf, " before string constant");
4771 else if (token_buffer[0] == '\'')
4772 strcat (buf, " before character constant");
4773 else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
4774 sprintf (buf + strlen (buf), " before character 0%o",
4775 (unsigned char) token_buffer[0]);
4777 strcat (buf, " before `%s'");
4779 error (buf, token_buffer);
4783 handle_cp_pragma (pname)
4788 if (! strcmp (pname, "vtable"))
4790 extern tree pending_vtables;
4792 /* More follows: it must be a string constant (class name). */
4793 token = real_yylex ();
4794 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4796 error ("invalid #pragma vtable");
4800 if (write_virtuals != 2)
4802 warning ("use `+e2' option to enable #pragma vtable");
4806 = perm_tree_cons (NULL_TREE,
4807 get_identifier (TREE_STRING_POINTER (yylval.ttype)),
4809 token = real_yylex ();
4810 if (token != END_OF_LINE)
4811 warning ("trailing characters ignored");
4814 else if (! strcmp (pname, "unit"))
4816 /* More follows: it must be a string constant (unit name). */
4817 token = real_yylex ();
4818 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4820 error ("invalid #pragma unit");
4823 token = real_yylex ();
4824 if (token != END_OF_LINE)
4825 warning ("trailing characters ignored");
4828 else if (! strcmp (pname, "interface"))
4830 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4831 char *main_filename = input_filename;
4833 main_filename = file_name_nondirectory (main_filename);
4835 token = real_yylex ();
4837 if (token != END_OF_LINE)
4840 || TREE_CODE (yylval.ttype) != STRING_CST)
4842 error ("invalid `#pragma interface'");
4845 main_filename = TREE_STRING_POINTER (yylval.ttype);
4846 token = real_yylex ();
4849 if (token != END_OF_LINE)
4850 warning ("garbage after `#pragma interface' ignored");
4852 #ifndef NO_LINKAGE_HEURISTICS
4855 if (impl_file_chain == 0)
4857 /* If this is zero at this point, then we are
4858 auto-implementing. */
4859 if (main_input_filename == 0)
4860 main_input_filename = input_filename;
4862 #ifdef AUTO_IMPLEMENT
4863 filename = file_name_nondirectory (main_input_filename);
4864 fi = get_time_identifier (filename);
4865 fi = IDENTIFIER_CLASS_VALUE (fi);
4866 TREE_INT_CST_LOW (fi) = 0;
4867 TREE_INT_CST_HIGH (fi) = 1;
4869 impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
4870 impl_file_chain->filename = filename;
4871 impl_file_chain->next = 0;
4875 interface_only = interface_strcmp (main_filename);
4876 interface_unknown = 0;
4877 TREE_INT_CST_LOW (fileinfo) = interface_only;
4878 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4879 #endif /* NO_LINKAGE_HEURISTICS */
4883 else if (! strcmp (pname, "implementation"))
4885 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4886 char *main_filename = main_input_filename ? main_input_filename : input_filename;
4888 main_filename = file_name_nondirectory (main_filename);
4889 token = real_yylex ();
4890 if (token != END_OF_LINE)
4893 || TREE_CODE (yylval.ttype) != STRING_CST)
4895 error ("invalid `#pragma implementation'");
4898 main_filename = TREE_STRING_POINTER (yylval.ttype);
4899 token = real_yylex ();
4902 if (token != END_OF_LINE)
4903 warning ("garbage after `#pragma implementation' ignored");
4905 #ifndef NO_LINKAGE_HEURISTICS
4906 if (write_virtuals == 3)
4908 struct impl_files *ifiles = impl_file_chain;
4911 if (! strcmp (ifiles->filename, main_filename))
4913 ifiles = ifiles->next;
4917 ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
4918 ifiles->filename = main_filename;
4919 ifiles->next = impl_file_chain;
4920 impl_file_chain = ifiles;
4923 else if ((main_input_filename != 0
4924 && ! strcmp (main_input_filename, input_filename))
4925 || ! strcmp (input_filename, main_filename))
4928 if (impl_file_chain == 0)
4930 impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
4931 impl_file_chain->filename = main_filename;
4932 impl_file_chain->next = 0;
4936 error ("`#pragma implementation' can only appear at top-level");
4939 /* We make this non-zero so that we infer decl linkage
4940 in the impl file only for variables first declared
4941 in the interface file. */
4942 interface_unknown = 1;
4944 /* We make this zero so that templates in the impl
4945 file will be emitted properly. */
4946 interface_unknown = 0;
4948 TREE_INT_CST_LOW (fileinfo) = interface_only;
4949 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4950 #endif /* NO_LINKAGE_HEURISTICS */
4958 /* Return the type-qualifier corresponding to the identifier given by
4962 cp_type_qual_from_rid (rid)
4965 if (rid == ridpointers[(int) RID_CONST])
4966 return TYPE_QUAL_CONST;
4967 else if (rid == ridpointers[(int) RID_VOLATILE])
4968 return TYPE_QUAL_VOLATILE;
4969 else if (rid == ridpointers[(int) RID_RESTRICT])
4970 return TYPE_QUAL_RESTRICT;
4972 my_friendly_abort (0);
4973 return TYPE_UNQUALIFIED;
4977 #ifdef HANDLE_GENERIC_PRAGMAS
4979 /* Handle a #pragma directive. TOKEN is the type of the word following
4980 the #pragma directive on the line. Process the entire input line and
4981 return non-zero iff the directive successfully parsed. */
4983 /* This function has to be in this file, in order to get at
4987 handle_generic_pragma (token)
4998 handle_pragma_token (IDENTIFIER_POINTER(yylval.ttype), yylval.ttype);
5001 handle_pragma_token ("(", NULL_TREE);
5004 handle_pragma_token (")", NULL_TREE);
5007 handle_pragma_token (",", NULL_TREE);
5010 handle_pragma_token ("=", NULL_TREE);
5013 handle_pragma_token ("(", NULL_TREE);
5014 handle_pragma_token (")", NULL_TREE);
5018 return handle_pragma_token (NULL_PTR, NULL_TREE);
5021 token = real_yylex ();
5024 #endif /* HANDLE_GENERIC_PRAGMAS */