1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is the lexical analyzer for GNU C++. */
25 /* Cause the `yydebug' variable to be defined. */
42 #ifdef MULTIBYTE_CHARS
46 #ifndef GET_ENVIRONMENT
47 #define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
51 #define obstack_chunk_alloc xmalloc
52 #define obstack_chunk_free free
55 #define DIR_SEPARATOR '/'
58 extern struct obstack permanent_obstack;
59 extern struct obstack *current_obstack, *saveable_obstack;
61 extern void yyprint PROTO((FILE *, int, YYSTYPE));
62 extern void compiler_error PROTO((char *, HOST_WIDE_INT,
65 static tree get_time_identifier PROTO((char *));
66 static int check_newline PROTO((void));
67 static int skip_white_space PROTO((int));
68 static void finish_defarg PROTO((void));
69 static int my_get_run_time PROTO((void));
70 static int get_last_nonwhite_on_line PROTO((void));
71 static int interface_strcmp PROTO((char *));
72 static int readescape PROTO((int *));
73 static char *extend_token_buffer PROTO((char *));
74 static void consume_string PROTO((struct obstack *, int));
75 static void set_typedecl_interface_info PROTO((tree, tree));
76 static void feed_defarg PROTO((tree, tree));
77 static int set_vardecl_interface_info PROTO((tree, tree));
78 static void store_pending_inline PROTO((tree, struct pending_inline *));
79 static void reinit_parse_for_expr PROTO((struct obstack *));
80 static int *init_cpp_parse PROTO((void));
81 static int handle_cp_pragma PROTO((char *));
82 #ifdef HANDLE_SYSV_PRAGMA
83 static int handle_sysv_pragma PROTO((int));
85 #ifdef GATHER_STATISTICS
87 static int reduce_cmp PROTO((int *, int *));
88 static int token_cmp PROTO((int *, int *));
92 /* Given a file name X, return the nondirectory portion.
93 Keep in mind that X can be computed more than once. */
95 file_name_nondirectory (x)
98 char *tmp = (char *) rindex (x, '/');
99 if (DIR_SEPARATOR != '/' && ! tmp)
100 tmp = (char *) rindex (x, DIR_SEPARATOR);
102 return (char *) (tmp + 1);
107 /* This obstack is needed to hold text. It is not safe to use
108 TOKEN_BUFFER because `check_newline' calls `yylex'. */
109 struct obstack inline_text_obstack;
110 char *inline_text_firstobj;
114 extern cpp_reader parse_in;
115 extern cpp_options parse_options;
116 extern unsigned char *yy_cur, *yy_lim;
122 /* Pending language change.
123 Positive is push count, negative is pop count. */
124 int pending_lang_change = 0;
126 /* Wrap the current header file in extern "C". */
127 static int c_header_level = 0;
129 extern int first_token;
130 extern struct obstack token_obstack;
132 /* ??? Don't really know where this goes yet. */
136 extern void put_back (/* int */);
137 extern int input_redirected ();
138 extern void feed_input (/* char *, int */);
141 /* Holds translations from TREE_CODEs to operator name strings,
142 i.e., opname_tab[PLUS_EXPR] == "+". */
146 extern int yychar; /* the lookahead symbol */
147 extern YYSTYPE yylval; /* the semantic value of the */
148 /* lookahead symbol */
151 YYLTYPE yylloc; /* location data for the lookahead */
156 /* the declaration found for the last IDENTIFIER token read in.
157 yylex must look this up to detect typedefs, which get token type TYPENAME,
158 so it is left around in case the identifier is not a typedef but is
159 used in a context which makes it a reference to a variable. */
162 /* The elements of `ridpointers' are identifier nodes
163 for the reserved type names and storage classes.
164 It is indexed by a RID_... value. */
165 tree ridpointers[(int) RID_MAX];
167 /* We may keep statistics about how long which files took to compile. */
168 static int header_time, body_time;
169 static tree filename_times;
170 static tree this_filename_time;
172 /* Array for holding counts of the numbers of tokens seen. */
173 extern int *token_count;
175 /* Return something to represent absolute declarators containing a *.
176 TARGET is the absolute declarator that the * contains.
177 CV_QUALIFIERS is a list of modifiers such as const or volatile
178 to apply to the pointer type, represented as identifiers.
180 We return an INDIRECT_REF whose "contents" are TARGET
181 and whose type is the modifier list. */
184 make_pointer_declarator (cv_qualifiers, target)
185 tree cv_qualifiers, target;
187 if (target && TREE_CODE (target) == IDENTIFIER_NODE
188 && ANON_AGGRNAME_P (target))
189 error ("type name expected before `*'");
190 target = build_parse_node (INDIRECT_REF, target);
191 TREE_TYPE (target) = cv_qualifiers;
195 /* Return something to represent absolute declarators containing a &.
196 TARGET is the absolute declarator that the & contains.
197 CV_QUALIFIERS is a list of modifiers such as const or volatile
198 to apply to the reference type, represented as identifiers.
200 We return an ADDR_EXPR whose "contents" are TARGET
201 and whose type is the modifier list. */
204 make_reference_declarator (cv_qualifiers, target)
205 tree cv_qualifiers, target;
209 if (TREE_CODE (target) == ADDR_EXPR)
211 error ("cannot declare references to references");
214 if (TREE_CODE (target) == INDIRECT_REF)
216 error ("cannot declare pointers to references");
219 if (TREE_CODE (target) == IDENTIFIER_NODE && ANON_AGGRNAME_P (target))
220 error ("type name expected before `&'");
222 target = build_parse_node (ADDR_EXPR, target);
223 TREE_TYPE (target) = cv_qualifiers;
228 make_call_declarator (target, parms, cv_qualifiers, exception_specification)
229 tree target, parms, cv_qualifiers, exception_specification;
231 target = build_parse_node (CALL_EXPR, target, parms, cv_qualifiers);
232 TREE_TYPE (target) = exception_specification;
237 set_quals_and_spec (call_declarator, cv_qualifiers, exception_specification)
238 tree call_declarator, cv_qualifiers, exception_specification;
240 TREE_OPERAND (call_declarator, 2) = cv_qualifiers;
241 TREE_TYPE (call_declarator) = exception_specification;
244 /* Build names and nodes for overloaded operators. */
246 tree ansi_opname[LAST_CPLUS_TREE_CODE];
247 tree ansi_assopname[LAST_CPLUS_TREE_CODE];
250 operator_name_string (name)
253 char *opname = IDENTIFIER_POINTER (name) + 2;
257 /* Works for builtin and user defined types. */
258 if (IDENTIFIER_GLOBAL_VALUE (name)
259 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name)) == TYPE_DECL)
260 return IDENTIFIER_POINTER (name);
262 if (opname[0] == 'a' && opname[2] != '\0' && opname[2] != '_')
266 opname_table = ansi_assopname;
271 opname_table = ansi_opname;
274 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
276 if (opname[0] == IDENTIFIER_POINTER (opname_table[i])[2+assign]
277 && opname[1] == IDENTIFIER_POINTER (opname_table[i])[3+assign])
281 if (i == LAST_CPLUS_TREE_CODE)
282 return "<invalid operator>";
285 return assignop_tab[i];
287 return opname_tab[i];
290 int interface_only; /* whether or not current file is only for
291 interface definitions. */
292 int interface_unknown; /* whether or not we know this class
293 to behave according to #pragma interface. */
295 /* lexical analyzer */
297 #ifndef WCHAR_TYPE_SIZE
299 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
301 #define WCHAR_TYPE_SIZE BITS_PER_WORD
305 /* Number of bytes in a wide character. */
306 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
308 static int maxtoken; /* Current nominal length of token buffer. */
309 char *token_buffer; /* Pointer to token buffer.
310 Actual allocated length is maxtoken + 2. */
315 /* Nonzero tells yylex to ignore \ in string constants. */
316 static int ignore_escape_flag = 0;
319 get_time_identifier (name)
322 tree time_identifier;
323 int len = strlen (name);
324 char *buf = (char *) alloca (len + 6);
325 strcpy (buf, "file ");
326 bcopy (name, buf+5, len);
328 time_identifier = get_identifier (buf);
329 if (IDENTIFIER_LOCAL_VALUE (time_identifier) == NULL_TREE)
331 push_obstacks_nochange ();
332 end_temporary_allocation ();
333 IDENTIFIER_LOCAL_VALUE (time_identifier) = build_int_2 (0, 0);
334 IDENTIFIER_CLASS_VALUE (time_identifier) = build_int_2 (0, 1);
335 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier, filename_times);
336 filename_times = time_identifier;
339 return time_identifier;
348 int old_quiet_flag = quiet_flag;
351 this_time = get_run_time ();
352 quiet_flag = old_quiet_flag;
356 /* Table indexed by tree code giving a string containing a character
357 classifying the tree code. Possibilities are
358 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
360 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
362 char cplus_tree_code_type[] = {
364 #include "cp-tree.def"
368 /* Table indexed by tree code giving number of expression
369 operands beyond the fixed part of the node structure.
370 Not used for types or decls. */
372 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
374 int cplus_tree_code_length[] = {
376 #include "cp-tree.def"
380 /* Names of tree components.
381 Used for printing out the tree and error messages. */
382 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
384 char *cplus_tree_code_name[] = {
386 #include "cp-tree.def"
390 /* toplev.c needs to call these. */
395 /* Default exceptions on. */
403 /* the beginning of the file is a new line; check for # */
404 /* With luck, we discover the real source file's name from that
405 and put it in input_filename. */
406 put_back (check_newline ());
408 if (flag_gnu_xref) GNU_xref_begin (input_filename);
409 init_repo (input_filename);
415 extern int errorcount, sorrycount;
416 if (flag_gnu_xref) GNU_xref_end (errorcount+sorrycount);
426 init_filename_times ()
428 this_filename_time = get_time_identifier ("<top level>");
429 if (flag_detailed_statistics)
432 body_time = my_get_run_time ();
433 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time)) = body_time;
437 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
438 Stuck this hack in to get the files open correctly; this is called
439 in place of init_parse if we are an unexec'd binary. */
443 reinit_lang_specific ()
445 init_filename_times ();
446 reinit_search_statistics ();
453 #ifdef GATHER_STATISTICS
455 reduce_count = (int *)malloc (sizeof (int) * (REDUCE_LENGTH + 1));
456 bzero (reduce_count, sizeof (int) * (REDUCE_LENGTH + 1));
458 token_count = (int *)malloc (sizeof (int) * (TOKEN_LENGTH + 1));
459 bzero (token_count, sizeof (int) * (TOKEN_LENGTH + 1));
467 init_parse (filename)
470 extern int flag_no_gnu_keywords;
471 extern int flag_operator_names;
475 #ifdef MULTIBYTE_CHARS
476 /* Change to the native locale for multibyte conversions. */
477 setlocale (LC_CTYPE, "");
478 GET_ENVIRONMENT (literal_codeset, "LANG");
485 parse_in.show_column = 1;
486 if (! cpp_start_read (&parse_in, filename))
489 /* Open input file. */
490 if (filename == 0 || !strcmp (filename, "-"))
496 finput = fopen (filename, "r");
498 pfatal_with_name (filename);
500 #ifdef IO_BUFFER_SIZE
501 setvbuf (finput, (char *) xmalloc (IO_BUFFER_SIZE), _IOFBF, IO_BUFFER_SIZE);
503 #endif /* !USE_CPPLIB */
505 /* Initialize the lookahead machinery. */
508 /* Make identifier nodes long enough for the language-specific slots. */
509 set_identifier_size (sizeof (struct lang_identifier));
510 decl_printable_name = lang_printable_name;
512 init_cplus_expand ();
514 bcopy (cplus_tree_code_type,
515 tree_code_type + (int) LAST_AND_UNUSED_TREE_CODE,
516 (int)LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE);
517 bcopy ((char *)cplus_tree_code_length,
518 (char *)(tree_code_length + (int) LAST_AND_UNUSED_TREE_CODE),
519 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (int));
520 bcopy ((char *)cplus_tree_code_name,
521 (char *)(tree_code_name + (int) LAST_AND_UNUSED_TREE_CODE),
522 (LAST_CPLUS_TREE_CODE - (int)LAST_AND_UNUSED_TREE_CODE) * sizeof (char *));
524 opname_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
525 bzero ((char *)opname_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
526 assignop_tab = (char **)oballoc ((int)LAST_CPLUS_TREE_CODE * sizeof (char *));
527 bzero ((char *)assignop_tab, (int)LAST_CPLUS_TREE_CODE * sizeof (char *));
529 ansi_opname[0] = get_identifier ("<invalid operator>");
530 for (i = 0; i < (int) LAST_CPLUS_TREE_CODE; i++)
532 ansi_opname[i] = ansi_opname[0];
533 ansi_assopname[i] = ansi_opname[0];
536 ansi_opname[(int) MULT_EXPR] = get_identifier ("__ml");
537 IDENTIFIER_OPNAME_P (ansi_opname[(int) MULT_EXPR]) = 1;
538 ansi_opname[(int) INDIRECT_REF] = ansi_opname[(int) MULT_EXPR];
539 ansi_assopname[(int) MULT_EXPR] = get_identifier ("__aml");
540 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MULT_EXPR]) = 1;
541 ansi_assopname[(int) INDIRECT_REF] = ansi_assopname[(int) MULT_EXPR];
542 ansi_opname[(int) TRUNC_MOD_EXPR] = get_identifier ("__md");
543 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUNC_MOD_EXPR]) = 1;
544 ansi_assopname[(int) TRUNC_MOD_EXPR] = get_identifier ("__amd");
545 IDENTIFIER_OPNAME_P (ansi_assopname[(int) TRUNC_MOD_EXPR]) = 1;
546 ansi_opname[(int) CEIL_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
547 ansi_opname[(int) FLOOR_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
548 ansi_opname[(int) ROUND_MOD_EXPR] = ansi_opname[(int) TRUNC_MOD_EXPR];
549 ansi_opname[(int) MINUS_EXPR] = get_identifier ("__mi");
550 IDENTIFIER_OPNAME_P (ansi_opname[(int) MINUS_EXPR]) = 1;
551 ansi_opname[(int) NEGATE_EXPR] = ansi_opname[(int) MINUS_EXPR];
552 ansi_assopname[(int) MINUS_EXPR] = get_identifier ("__ami");
553 IDENTIFIER_OPNAME_P (ansi_assopname[(int) MINUS_EXPR]) = 1;
554 ansi_assopname[(int) NEGATE_EXPR] = ansi_assopname[(int) MINUS_EXPR];
555 ansi_opname[(int) RSHIFT_EXPR] = get_identifier ("__rs");
556 IDENTIFIER_OPNAME_P (ansi_opname[(int) RSHIFT_EXPR]) = 1;
557 ansi_assopname[(int) RSHIFT_EXPR] = get_identifier ("__ars");
558 IDENTIFIER_OPNAME_P (ansi_assopname[(int) RSHIFT_EXPR]) = 1;
559 ansi_opname[(int) NE_EXPR] = get_identifier ("__ne");
560 IDENTIFIER_OPNAME_P (ansi_opname[(int) NE_EXPR]) = 1;
561 ansi_opname[(int) GT_EXPR] = get_identifier ("__gt");
562 IDENTIFIER_OPNAME_P (ansi_opname[(int) GT_EXPR]) = 1;
563 ansi_opname[(int) GE_EXPR] = get_identifier ("__ge");
564 IDENTIFIER_OPNAME_P (ansi_opname[(int) GE_EXPR]) = 1;
565 ansi_opname[(int) BIT_IOR_EXPR] = get_identifier ("__or");
566 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_IOR_EXPR]) = 1;
567 ansi_assopname[(int) BIT_IOR_EXPR] = get_identifier ("__aor");
568 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_IOR_EXPR]) = 1;
569 ansi_opname[(int) TRUTH_ANDIF_EXPR] = get_identifier ("__aa");
570 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ANDIF_EXPR]) = 1;
571 ansi_opname[(int) TRUTH_NOT_EXPR] = get_identifier ("__nt");
572 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_NOT_EXPR]) = 1;
573 ansi_opname[(int) PREINCREMENT_EXPR] = get_identifier ("__pp");
574 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREINCREMENT_EXPR]) = 1;
575 ansi_opname[(int) POSTINCREMENT_EXPR] = ansi_opname[(int) PREINCREMENT_EXPR];
576 ansi_opname[(int) MODIFY_EXPR] = get_identifier ("__as");
577 IDENTIFIER_OPNAME_P (ansi_opname[(int) MODIFY_EXPR]) = 1;
578 ansi_assopname[(int) NOP_EXPR] = ansi_opname[(int) MODIFY_EXPR];
579 ansi_opname[(int) COMPOUND_EXPR] = get_identifier ("__cm");
580 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPOUND_EXPR]) = 1;
581 ansi_opname[(int) EXACT_DIV_EXPR] = get_identifier ("__dv");
582 IDENTIFIER_OPNAME_P (ansi_opname[(int) EXACT_DIV_EXPR]) = 1;
583 ansi_assopname[(int) EXACT_DIV_EXPR] = get_identifier ("__adv");
584 IDENTIFIER_OPNAME_P (ansi_assopname[(int) EXACT_DIV_EXPR]) = 1;
585 ansi_opname[(int) TRUNC_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
586 ansi_opname[(int) CEIL_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
587 ansi_opname[(int) FLOOR_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
588 ansi_opname[(int) ROUND_DIV_EXPR] = ansi_opname[(int) EXACT_DIV_EXPR];
589 ansi_opname[(int) PLUS_EXPR] = get_identifier ("__pl");
590 ansi_assopname[(int) TRUNC_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
591 ansi_assopname[(int) CEIL_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
592 ansi_assopname[(int) FLOOR_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
593 ansi_assopname[(int) ROUND_DIV_EXPR] = ansi_assopname[(int) EXACT_DIV_EXPR];
594 IDENTIFIER_OPNAME_P (ansi_opname[(int) PLUS_EXPR]) = 1;
595 ansi_assopname[(int) PLUS_EXPR] = get_identifier ("__apl");
596 IDENTIFIER_OPNAME_P (ansi_assopname[(int) PLUS_EXPR]) = 1;
597 ansi_opname[(int) CONVERT_EXPR] = ansi_opname[(int) PLUS_EXPR];
598 ansi_assopname[(int) CONVERT_EXPR] = ansi_assopname[(int) PLUS_EXPR];
599 ansi_opname[(int) LSHIFT_EXPR] = get_identifier ("__ls");
600 IDENTIFIER_OPNAME_P (ansi_opname[(int) LSHIFT_EXPR]) = 1;
601 ansi_assopname[(int) LSHIFT_EXPR] = get_identifier ("__als");
602 IDENTIFIER_OPNAME_P (ansi_assopname[(int) LSHIFT_EXPR]) = 1;
603 ansi_opname[(int) EQ_EXPR] = get_identifier ("__eq");
604 IDENTIFIER_OPNAME_P (ansi_opname[(int) EQ_EXPR]) = 1;
605 ansi_opname[(int) LT_EXPR] = get_identifier ("__lt");
606 IDENTIFIER_OPNAME_P (ansi_opname[(int) LT_EXPR]) = 1;
607 ansi_opname[(int) LE_EXPR] = get_identifier ("__le");
608 IDENTIFIER_OPNAME_P (ansi_opname[(int) LE_EXPR]) = 1;
609 ansi_opname[(int) BIT_AND_EXPR] = get_identifier ("__ad");
610 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_AND_EXPR]) = 1;
611 ansi_assopname[(int) BIT_AND_EXPR] = get_identifier ("__aad");
612 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_AND_EXPR]) = 1;
613 ansi_opname[(int) ADDR_EXPR] = ansi_opname[(int) BIT_AND_EXPR];
614 ansi_assopname[(int) ADDR_EXPR] = ansi_assopname[(int) BIT_AND_EXPR];
615 ansi_opname[(int) BIT_XOR_EXPR] = get_identifier ("__er");
616 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_XOR_EXPR]) = 1;
617 ansi_assopname[(int) BIT_XOR_EXPR] = get_identifier ("__aer");
618 IDENTIFIER_OPNAME_P (ansi_assopname[(int) BIT_XOR_EXPR]) = 1;
619 ansi_opname[(int) TRUTH_ORIF_EXPR] = get_identifier ("__oo");
620 IDENTIFIER_OPNAME_P (ansi_opname[(int) TRUTH_ORIF_EXPR]) = 1;
621 ansi_opname[(int) BIT_NOT_EXPR] = get_identifier ("__co");
622 IDENTIFIER_OPNAME_P (ansi_opname[(int) BIT_NOT_EXPR]) = 1;
623 ansi_opname[(int) PREDECREMENT_EXPR] = get_identifier ("__mm");
624 IDENTIFIER_OPNAME_P (ansi_opname[(int) PREDECREMENT_EXPR]) = 1;
625 ansi_opname[(int) POSTDECREMENT_EXPR] = ansi_opname[(int) PREDECREMENT_EXPR];
626 ansi_opname[(int) COMPONENT_REF] = get_identifier ("__rf");
627 IDENTIFIER_OPNAME_P (ansi_opname[(int) COMPONENT_REF]) = 1;
628 ansi_opname[(int) MEMBER_REF] = get_identifier ("__rm");
629 IDENTIFIER_OPNAME_P (ansi_opname[(int) MEMBER_REF]) = 1;
630 ansi_opname[(int) CALL_EXPR] = get_identifier ("__cl");
631 IDENTIFIER_OPNAME_P (ansi_opname[(int) CALL_EXPR]) = 1;
632 ansi_opname[(int) ARRAY_REF] = get_identifier ("__vc");
633 IDENTIFIER_OPNAME_P (ansi_opname[(int) ARRAY_REF]) = 1;
634 ansi_opname[(int) NEW_EXPR] = get_identifier ("__nw");
635 IDENTIFIER_OPNAME_P (ansi_opname[(int) NEW_EXPR]) = 1;
636 ansi_opname[(int) DELETE_EXPR] = get_identifier ("__dl");
637 IDENTIFIER_OPNAME_P (ansi_opname[(int) DELETE_EXPR]) = 1;
638 ansi_opname[(int) VEC_NEW_EXPR] = get_identifier ("__vn");
639 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_NEW_EXPR]) = 1;
640 ansi_opname[(int) VEC_DELETE_EXPR] = get_identifier ("__vd");
641 IDENTIFIER_OPNAME_P (ansi_opname[(int) VEC_DELETE_EXPR]) = 1;
642 ansi_opname[(int) TYPE_EXPR] = get_identifier ("__op");
643 IDENTIFIER_OPNAME_P (ansi_opname[(int) TYPE_EXPR]) = 1;
645 /* This is not true: these operators are not defined in ANSI,
646 but we need them anyway. */
647 ansi_opname[(int) MIN_EXPR] = get_identifier ("__mn");
648 IDENTIFIER_OPNAME_P (ansi_opname[(int) MIN_EXPR]) = 1;
649 ansi_opname[(int) MAX_EXPR] = get_identifier ("__mx");
650 IDENTIFIER_OPNAME_P (ansi_opname[(int) MAX_EXPR]) = 1;
651 ansi_opname[(int) COND_EXPR] = get_identifier ("__cn");
652 IDENTIFIER_OPNAME_P (ansi_opname[(int) COND_EXPR]) = 1;
653 ansi_opname[(int) SIZEOF_EXPR] = get_identifier ("__sz");
654 IDENTIFIER_OPNAME_P (ansi_opname[(int) SIZEOF_EXPR]) = 1;
658 gcc_obstack_init (&inline_text_obstack);
659 inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0);
661 /* Start it at 0, because check_newline is called at the very beginning
662 and will increment it to 1. */
664 input_filename = "<internal>";
665 current_function_decl = NULL;
668 token_buffer = (char *) xmalloc (maxtoken + 2);
670 ridpointers[(int) RID_INT] = get_identifier ("int");
671 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INT],
672 build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]));
673 ridpointers[(int) RID_BOOL] = get_identifier ("bool");
674 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_BOOL],
675 build_tree_list (NULL_TREE, ridpointers[(int) RID_BOOL]));
676 ridpointers[(int) RID_CHAR] = get_identifier ("char");
677 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CHAR],
678 build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]));
679 ridpointers[(int) RID_VOID] = get_identifier ("void");
680 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOID],
681 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]));
682 ridpointers[(int) RID_FLOAT] = get_identifier ("float");
683 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FLOAT],
684 build_tree_list (NULL_TREE, ridpointers[(int) RID_FLOAT]));
685 ridpointers[(int) RID_DOUBLE] = get_identifier ("double");
686 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_DOUBLE],
687 build_tree_list (NULL_TREE, ridpointers[(int) RID_DOUBLE]));
688 ridpointers[(int) RID_SHORT] = get_identifier ("short");
689 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SHORT],
690 build_tree_list (NULL_TREE, ridpointers[(int) RID_SHORT]));
691 ridpointers[(int) RID_LONG] = get_identifier ("long");
692 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_LONG],
693 build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]));
694 ridpointers[(int) RID_UNSIGNED] = get_identifier ("unsigned");
695 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_UNSIGNED],
696 build_tree_list (NULL_TREE, ridpointers[(int) RID_UNSIGNED]));
697 ridpointers[(int) RID_SIGNED] = get_identifier ("signed");
698 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_SIGNED],
699 build_tree_list (NULL_TREE, ridpointers[(int) RID_SIGNED]));
700 ridpointers[(int) RID_INLINE] = get_identifier ("inline");
701 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_INLINE],
702 build_tree_list (NULL_TREE, ridpointers[(int) RID_INLINE]));
703 ridpointers[(int) RID_CONST] = get_identifier ("const");
704 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_CONST],
705 build_tree_list (NULL_TREE, ridpointers[(int) RID_CONST]));
706 ridpointers[(int) RID_VOLATILE] = get_identifier ("volatile");
707 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VOLATILE],
708 build_tree_list (NULL_TREE, ridpointers[(int) RID_VOLATILE]));
709 ridpointers[(int) RID_AUTO] = get_identifier ("auto");
710 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_AUTO],
711 build_tree_list (NULL_TREE, ridpointers[(int) RID_AUTO]));
712 ridpointers[(int) RID_STATIC] = get_identifier ("static");
713 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_STATIC],
714 build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]));
715 ridpointers[(int) RID_EXTERN] = get_identifier ("extern");
716 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXTERN],
717 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]));
718 ridpointers[(int) RID_TYPEDEF] = get_identifier ("typedef");
719 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TYPEDEF],
720 build_tree_list (NULL_TREE, ridpointers[(int) RID_TYPEDEF]));
721 ridpointers[(int) RID_REGISTER] = get_identifier ("register");
722 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_REGISTER],
723 build_tree_list (NULL_TREE, ridpointers[(int) RID_REGISTER]));
724 ridpointers[(int) RID_COMPLEX] = get_identifier ("__complex");
725 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_COMPLEX],
726 build_tree_list (NULL_TREE, ridpointers[(int) RID_COMPLEX]));
728 /* C++ extensions. These are probably not correctly named. */
729 ridpointers[(int) RID_WCHAR] = get_identifier ("__wchar_t");
730 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_WCHAR],
731 build_tree_list (NULL_TREE, ridpointers[(int) RID_WCHAR]));
732 class_type_node = build_int_2 (class_type, 0);
733 TREE_TYPE (class_type_node) = class_type_node;
734 ridpointers[(int) RID_CLASS] = class_type_node;
736 record_type_node = build_int_2 (record_type, 0);
737 TREE_TYPE (record_type_node) = record_type_node;
738 ridpointers[(int) RID_RECORD] = record_type_node;
740 union_type_node = build_int_2 (union_type, 0);
741 TREE_TYPE (union_type_node) = union_type_node;
742 ridpointers[(int) RID_UNION] = union_type_node;
744 enum_type_node = build_int_2 (enum_type, 0);
745 TREE_TYPE (enum_type_node) = enum_type_node;
746 ridpointers[(int) RID_ENUM] = enum_type_node;
748 ridpointers[(int) RID_VIRTUAL] = get_identifier ("virtual");
749 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_VIRTUAL],
750 build_tree_list (NULL_TREE, ridpointers[(int) RID_VIRTUAL]));
751 ridpointers[(int) RID_EXPLICIT] = get_identifier ("explicit");
752 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_EXPLICIT],
753 build_tree_list (NULL_TREE, ridpointers[(int) RID_EXPLICIT]));
754 ridpointers[(int) RID_FRIEND] = get_identifier ("friend");
755 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_FRIEND],
756 build_tree_list (NULL_TREE, ridpointers[(int) RID_FRIEND]));
758 ridpointers[(int) RID_PUBLIC] = get_identifier ("public");
759 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PUBLIC],
760 build_tree_list (NULL_TREE, ridpointers[(int) RID_PUBLIC]));
761 ridpointers[(int) RID_PRIVATE] = get_identifier ("private");
762 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PRIVATE],
763 build_tree_list (NULL_TREE, ridpointers[(int) RID_PRIVATE]));
764 ridpointers[(int) RID_PROTECTED] = get_identifier ("protected");
765 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_PROTECTED],
766 build_tree_list (NULL_TREE, ridpointers[(int) RID_PROTECTED]));
767 ridpointers[(int) RID_TEMPLATE] = get_identifier ("template");
768 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_TEMPLATE],
769 build_tree_list (NULL_TREE, ridpointers[(int) RID_TEMPLATE]));
770 /* This is for ANSI C++. */
771 ridpointers[(int) RID_MUTABLE] = get_identifier ("mutable");
772 SET_IDENTIFIER_AS_LIST (ridpointers[(int) RID_MUTABLE],
773 build_tree_list (NULL_TREE, ridpointers[(int) RID_MUTABLE]));
775 /* Signature handling extensions. */
776 signature_type_node = build_int_2 (signature_type, 0);
777 TREE_TYPE (signature_type_node) = signature_type_node;
778 ridpointers[(int) RID_SIGNATURE] = signature_type_node;
780 null_node = build_int_2 (0, 0);
781 ridpointers[RID_NULL] = null_node;
783 opname_tab[(int) COMPONENT_REF] = "->";
784 opname_tab[(int) MEMBER_REF] = "->*";
785 opname_tab[(int) INDIRECT_REF] = "*";
786 opname_tab[(int) ARRAY_REF] = "[]";
787 opname_tab[(int) MODIFY_EXPR] = "=";
788 opname_tab[(int) NEW_EXPR] = "new";
789 opname_tab[(int) DELETE_EXPR] = "delete";
790 opname_tab[(int) VEC_NEW_EXPR] = "new []";
791 opname_tab[(int) VEC_DELETE_EXPR] = "delete []";
792 opname_tab[(int) COND_EXPR] = "?:";
793 opname_tab[(int) CALL_EXPR] = "()";
794 opname_tab[(int) PLUS_EXPR] = "+";
795 opname_tab[(int) MINUS_EXPR] = "-";
796 opname_tab[(int) MULT_EXPR] = "*";
797 opname_tab[(int) TRUNC_DIV_EXPR] = "/";
798 opname_tab[(int) CEIL_DIV_EXPR] = "(ceiling /)";
799 opname_tab[(int) FLOOR_DIV_EXPR] = "(floor /)";
800 opname_tab[(int) ROUND_DIV_EXPR] = "(round /)";
801 opname_tab[(int) TRUNC_MOD_EXPR] = "%";
802 opname_tab[(int) CEIL_MOD_EXPR] = "(ceiling %)";
803 opname_tab[(int) FLOOR_MOD_EXPR] = "(floor %)";
804 opname_tab[(int) ROUND_MOD_EXPR] = "(round %)";
805 opname_tab[(int) NEGATE_EXPR] = "-";
806 opname_tab[(int) MIN_EXPR] = "<?";
807 opname_tab[(int) MAX_EXPR] = ">?";
808 opname_tab[(int) ABS_EXPR] = "abs";
809 opname_tab[(int) FFS_EXPR] = "ffs";
810 opname_tab[(int) LSHIFT_EXPR] = "<<";
811 opname_tab[(int) RSHIFT_EXPR] = ">>";
812 opname_tab[(int) BIT_IOR_EXPR] = "|";
813 opname_tab[(int) BIT_XOR_EXPR] = "^";
814 opname_tab[(int) BIT_AND_EXPR] = "&";
815 opname_tab[(int) BIT_ANDTC_EXPR] = "&~";
816 opname_tab[(int) BIT_NOT_EXPR] = "~";
817 opname_tab[(int) TRUTH_ANDIF_EXPR] = "&&";
818 opname_tab[(int) TRUTH_ORIF_EXPR] = "||";
819 opname_tab[(int) TRUTH_AND_EXPR] = "strict &&";
820 opname_tab[(int) TRUTH_OR_EXPR] = "strict ||";
821 opname_tab[(int) TRUTH_NOT_EXPR] = "!";
822 opname_tab[(int) LT_EXPR] = "<";
823 opname_tab[(int) LE_EXPR] = "<=";
824 opname_tab[(int) GT_EXPR] = ">";
825 opname_tab[(int) GE_EXPR] = ">=";
826 opname_tab[(int) EQ_EXPR] = "==";
827 opname_tab[(int) NE_EXPR] = "!=";
828 opname_tab[(int) IN_EXPR] = "in";
829 opname_tab[(int) RANGE_EXPR] = "...";
830 opname_tab[(int) CONVERT_EXPR] = "+";
831 opname_tab[(int) ADDR_EXPR] = "&";
832 opname_tab[(int) PREDECREMENT_EXPR] = "--";
833 opname_tab[(int) PREINCREMENT_EXPR] = "++";
834 opname_tab[(int) POSTDECREMENT_EXPR] = "--";
835 opname_tab[(int) POSTINCREMENT_EXPR] = "++";
836 opname_tab[(int) COMPOUND_EXPR] = ",";
838 assignop_tab[(int) NOP_EXPR] = "=";
839 assignop_tab[(int) PLUS_EXPR] = "+=";
840 assignop_tab[(int) CONVERT_EXPR] = "+=";
841 assignop_tab[(int) MINUS_EXPR] = "-=";
842 assignop_tab[(int) NEGATE_EXPR] = "-=";
843 assignop_tab[(int) MULT_EXPR] = "*=";
844 assignop_tab[(int) INDIRECT_REF] = "*=";
845 assignop_tab[(int) TRUNC_DIV_EXPR] = "/=";
846 assignop_tab[(int) EXACT_DIV_EXPR] = "(exact /=)";
847 assignop_tab[(int) CEIL_DIV_EXPR] = "(ceiling /=)";
848 assignop_tab[(int) FLOOR_DIV_EXPR] = "(floor /=)";
849 assignop_tab[(int) ROUND_DIV_EXPR] = "(round /=)";
850 assignop_tab[(int) TRUNC_MOD_EXPR] = "%=";
851 assignop_tab[(int) CEIL_MOD_EXPR] = "(ceiling %=)";
852 assignop_tab[(int) FLOOR_MOD_EXPR] = "(floor %=)";
853 assignop_tab[(int) ROUND_MOD_EXPR] = "(round %=)";
854 assignop_tab[(int) MIN_EXPR] = "<?=";
855 assignop_tab[(int) MAX_EXPR] = ">?=";
856 assignop_tab[(int) LSHIFT_EXPR] = "<<=";
857 assignop_tab[(int) RSHIFT_EXPR] = ">>=";
858 assignop_tab[(int) BIT_IOR_EXPR] = "|=";
859 assignop_tab[(int) BIT_XOR_EXPR] = "^=";
860 assignop_tab[(int) BIT_AND_EXPR] = "&=";
861 assignop_tab[(int) ADDR_EXPR] = "&=";
863 init_filename_times ();
865 /* Some options inhibit certain reserved words.
866 Clear those words out of the hash table so they won't be recognized. */
867 #define UNSET_RESERVED_WORD(STRING) \
868 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
869 if (s) s->name = ""; } while (0)
872 /* let's parse things, and if they use it, then give them an error. */
873 if (!flag_exceptions)
875 UNSET_RESERVED_WORD ("throw");
876 UNSET_RESERVED_WORD ("try");
877 UNSET_RESERVED_WORD ("catch");
881 if (!flag_rtti || flag_no_gnu_keywords)
883 UNSET_RESERVED_WORD ("classof");
884 UNSET_RESERVED_WORD ("headof");
887 if (! flag_handle_signatures || flag_no_gnu_keywords)
889 /* Easiest way to not recognize signature
890 handling extensions... */
891 UNSET_RESERVED_WORD ("signature");
892 UNSET_RESERVED_WORD ("sigof");
894 if (flag_no_asm || flag_no_gnu_keywords)
895 UNSET_RESERVED_WORD ("typeof");
896 if (! flag_operator_names)
898 /* These are new ANSI keywords that may break code. */
899 UNSET_RESERVED_WORD ("and");
900 UNSET_RESERVED_WORD ("and_eq");
901 UNSET_RESERVED_WORD ("bitand");
902 UNSET_RESERVED_WORD ("bitor");
903 UNSET_RESERVED_WORD ("compl");
904 UNSET_RESERVED_WORD ("not");
905 UNSET_RESERVED_WORD ("not_eq");
906 UNSET_RESERVED_WORD ("or");
907 UNSET_RESERVED_WORD ("or_eq");
908 UNSET_RESERVED_WORD ("xor");
909 UNSET_RESERVED_WORD ("xor_eq");
912 token_count = init_cpp_parse ();
913 interface_unknown = 1;
922 cpp_finish (&parse_in);
929 reinit_parse_for_function ()
931 current_base_init_list = NULL_TREE;
932 current_member_init_list = NULL_TREE;
939 yyprint (file, yychar, yylval)
951 case IDENTIFIER_DEFN:
955 case PRE_PARSED_CLASS_DECL:
957 if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (t) == TEMPLATE_DECL)
959 fprintf (file, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t)));
962 my_friendly_assert (TREE_CODE (t) == IDENTIFIER_NODE, 224);
963 if (IDENTIFIER_POINTER (t))
964 fprintf (file, " `%s'", IDENTIFIER_POINTER (t));
967 if (yylval.ttype == class_type_node)
968 fprintf (file, " `class'");
969 else if (yylval.ttype == record_type_node)
970 fprintf (file, " `struct'");
971 else if (yylval.ttype == union_type_node)
972 fprintf (file, " `union'");
973 else if (yylval.ttype == enum_type_node)
974 fprintf (file, " `enum'");
975 else if (yylval.ttype == signature_type_node)
976 fprintf (file, " `signature'");
978 my_friendly_abort (80);
983 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
984 static int *reduce_count;
990 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
991 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
994 #ifdef GATHER_STATISTICS
1000 reduce_count[yyn] += 1;
1007 return reduce_count[*q] - reduce_count[*p];
1014 return token_count[*q] - token_count[*p];
1020 print_parse_statistics ()
1022 #ifdef GATHER_STATISTICS
1023 #ifdef REDUCE_LENGTH
1026 int maxlen = REDUCE_LENGTH;
1029 if (reduce_count[-1] == 0)
1032 if (TOKEN_LENGTH > REDUCE_LENGTH)
1033 maxlen = TOKEN_LENGTH;
1034 sorted = (unsigned *) alloca (sizeof (int) * maxlen);
1036 for (i = 0; i < TOKEN_LENGTH; i++)
1038 qsort (sorted, TOKEN_LENGTH, sizeof (int), token_cmp);
1039 for (i = 0; i < TOKEN_LENGTH; i++)
1041 int idx = sorted[i];
1042 if (token_count[idx] == 0)
1044 if (token_count[idx] < token_count[-1])
1046 fprintf (stderr, "token %d, `%s', count = %d\n",
1047 idx, yytname[YYTRANSLATE (idx)], token_count[idx]);
1049 fprintf (stderr, "\n");
1050 for (i = 0; i < REDUCE_LENGTH; i++)
1052 qsort (sorted, REDUCE_LENGTH, sizeof (int), reduce_cmp);
1053 for (i = 0; i < REDUCE_LENGTH; i++)
1055 int idx = sorted[i];
1056 if (reduce_count[idx] == 0)
1058 if (reduce_count[idx] < reduce_count[-1])
1060 fprintf (stderr, "rule %d, line %d, count = %d\n",
1061 idx, yyrline[idx], reduce_count[idx]);
1063 fprintf (stderr, "\n");
1069 /* Sets the value of the 'yydebug' variable to VALUE.
1070 This is a function so we don't have to have YYDEBUG defined
1071 in order to build the compiler. */
1081 warning ("YYDEBUG not defined.");
1086 /* Functions and data structures for #pragma interface.
1088 `#pragma implementation' means that the main file being compiled
1089 is considered to implement (provide) the classes that appear in
1090 its main body. I.e., if this is file "foo.cc", and class `bar'
1091 is defined in "foo.cc", then we say that "foo.cc implements bar".
1093 All main input files "implement" themselves automagically.
1095 `#pragma interface' means that unless this file (of the form "foo.h"
1096 is not presently being included by file "foo.cc", the
1097 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1098 of the vtables nor any of the inline functions defined in foo.h
1099 will ever be output.
1101 There are cases when we want to link files such as "defs.h" and
1102 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1103 and "main.cc" has `#pragma implementation "defs.h"'. */
1108 struct impl_files *next;
1111 static struct impl_files *impl_file_chain;
1113 /* Helper function to load global variables with interface
1117 extract_interface_info ()
1121 if (flag_alt_external_templates)
1123 struct tinst_level *til = tinst_for_decl ();
1126 fileinfo = get_time_identifier (til->file);
1129 fileinfo = get_time_identifier (input_filename);
1130 fileinfo = IDENTIFIER_CLASS_VALUE (fileinfo);
1131 interface_only = TREE_INT_CST_LOW (fileinfo);
1132 interface_unknown = TREE_INT_CST_HIGH (fileinfo);
1135 /* Return nonzero if S is not considered part of an
1136 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1139 interface_strcmp (s)
1142 /* Set the interface/implementation bits for this scope. */
1143 struct impl_files *ifiles;
1146 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
1148 char *t1 = ifiles->filename;
1151 if (*s1 != *t1 || *s1 == 0)
1154 while (*s1 == *t1 && *s1 != 0)
1161 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1162 if (index (s1, '.') || index (t1, '.'))
1165 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
1177 set_typedecl_interface_info (prev, vars)
1180 tree id = get_time_identifier (DECL_SOURCE_FILE (vars));
1181 tree fileinfo = IDENTIFIER_CLASS_VALUE (id);
1182 tree type = TREE_TYPE (vars);
1184 CLASSTYPE_INTERFACE_ONLY (type) = TREE_INT_CST_LOW (fileinfo)
1185 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars)));
1189 set_vardecl_interface_info (prev, vars)
1192 tree type = DECL_CONTEXT (vars);
1194 if (CLASSTYPE_INTERFACE_KNOWN (type))
1196 if (CLASSTYPE_INTERFACE_ONLY (type))
1197 set_typedecl_interface_info (prev, TYPE_MAIN_DECL (type));
1199 CLASSTYPE_VTABLE_NEEDS_WRITING (type) = 1;
1200 DECL_EXTERNAL (vars) = CLASSTYPE_INTERFACE_ONLY (type);
1201 TREE_PUBLIC (vars) = 1;
1207 /* Called from the top level: if there are any pending inlines to
1208 do, set up to process them now. This function sets up the first function
1209 to be parsed; after it has been, the rule for fndef in parse.y will
1210 call process_next_inline to start working on the next one. */
1213 do_pending_inlines ()
1215 struct pending_inline *t;
1218 /* Oops, we're still dealing with the last batch. */
1219 if (yychar == PRE_PARSED_FUNCTION_DECL)
1222 /* Reverse the pending inline functions, since
1223 they were cons'd instead of appended. */
1225 struct pending_inline *prev = 0, *tail;
1226 t = pending_inlines;
1227 pending_inlines = 0;
1242 /* Now start processing the first inline function. */
1243 context = hack_decl_function_context (t->fndecl);
1245 push_cp_function_context (context);
1246 maybe_begin_member_template_processing (t->fndecl);
1249 feed_input (t->buf, t->len);
1252 if (input_filename != t->filename)
1254 input_filename = t->filename;
1255 /* Get interface/implementation back in sync. */
1256 extract_interface_info ();
1259 input_filename = t->filename;
1260 interface_unknown = t->interface == 1;
1261 interface_only = t->interface == 0;
1263 yychar = PRE_PARSED_FUNCTION_DECL;
1265 /* Pass back a handle on the rest of the inline functions, so that they
1266 can be processed later. */
1267 yylval.ttype = build_tree_list ((tree) t, t->fndecl);
1268 DECL_PENDING_INLINE_INFO (t->fndecl) = 0;
1271 static int nextchar = -1;
1273 /* Called from the fndecl rule in the parser when the function just parsed
1274 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1275 do_pending_inlines). */
1278 process_next_inline (t)
1282 struct pending_inline *i = (struct pending_inline *) TREE_PURPOSE (t);
1283 context = hack_decl_function_context (i->fndecl);
1284 maybe_end_member_template_processing (i->fndecl);
1286 pop_cp_function_context (context);
1288 if (yychar == YYEMPTY)
1290 if (yychar != END_OF_SAVED_INPUT)
1292 error ("parse error at end of saved function text");
1294 /* restore_pending_input will abort unless yychar is either
1295 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1296 hosed, feed back YYEMPTY. We also need to discard nextchar,
1297 since that may have gotten set as well. */
1302 if (i && i->fndecl != NULL_TREE)
1304 context = hack_decl_function_context (i->fndecl);
1306 push_cp_function_context (context);
1307 maybe_begin_member_template_processing (i->fndecl);
1308 feed_input (i->buf, i->len);
1310 input_filename = i->filename;
1311 yychar = PRE_PARSED_FUNCTION_DECL;
1312 yylval.ttype = build_tree_list ((tree) i, i->fndecl);
1313 DECL_PENDING_INLINE_INFO (i->fndecl) = 0;
1317 interface_unknown = i->interface == 1;
1318 interface_only = i->interface == 0;
1321 extract_interface_info ();
1324 /* Since inline methods can refer to text which has not yet been seen,
1325 we store the text of the method in a structure which is placed in the
1326 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1327 After parsing the body of the class definition, the FUNCTION_DECL's are
1328 scanned to see which ones have this field set. Those are then digested
1331 This function's FUNCTION_DECL will have a bit set in its common so
1332 that we know to watch out for it. */
1335 consume_string (this_obstack, matching_char)
1336 register struct obstack *this_obstack;
1340 int starting_lineno = lineno;
1346 int save_lineno = lineno;
1347 lineno = starting_lineno;
1348 if (matching_char == '"')
1349 error ("end of file encountered inside string constant");
1351 error ("end of file encountered inside character constant");
1352 lineno = save_lineno;
1357 obstack_1grow (this_obstack, c);
1359 obstack_1grow (this_obstack, c);
1361 /* Make sure we continue the loop */
1368 pedwarn ("ANSI C++ forbids newline in string constant");
1371 obstack_1grow (this_obstack, c);
1373 while (c != matching_char);
1376 static int nextyychar = YYEMPTY;
1377 static YYSTYPE nextyylval;
1379 struct pending_input {
1380 int nextchar, yychar, nextyychar, eof;
1381 YYSTYPE yylval, nextyylval;
1382 struct obstack token_obstack;
1386 struct pending_input *
1387 save_pending_input ()
1389 struct pending_input *p;
1390 p = (struct pending_input *) xmalloc (sizeof (struct pending_input));
1391 p->nextchar = nextchar;
1393 p->nextyychar = nextyychar;
1395 p->nextyylval = nextyylval;
1396 p->eof = end_of_file;
1397 yychar = nextyychar = YYEMPTY;
1399 p->first_token = first_token;
1400 p->token_obstack = token_obstack;
1403 gcc_obstack_init (&token_obstack);
1409 restore_pending_input (p)
1410 struct pending_input *p;
1412 my_friendly_assert (nextchar == -1, 229);
1413 nextchar = p->nextchar;
1414 my_friendly_assert (yychar == YYEMPTY || yychar == END_OF_SAVED_INPUT, 230);
1416 my_friendly_assert (nextyychar == YYEMPTY, 231);
1417 nextyychar = p->nextyychar;
1419 nextyylval = p->nextyylval;
1420 first_token = p->first_token;
1421 obstack_free (&token_obstack, (char *) 0);
1422 token_obstack = p->token_obstack;
1423 end_of_file = p->eof;
1427 /* Unget character CH from the input stream.
1428 If RESCAN is non-zero, then we want to `see' this
1429 character as the next input token. */
1432 yyungetc (ch, rescan)
1436 /* Unget a character from the input stream. */
1437 if (yychar == YYEMPTY || rescan == 0)
1440 put_back (nextchar);
1445 my_friendly_assert (nextyychar == YYEMPTY, 232);
1446 nextyychar = yychar;
1447 nextyylval = yylval;
1453 clear_inline_text_obstack ()
1455 obstack_free (&inline_text_obstack, inline_text_firstobj);
1458 /* This function stores away the text for an inline function that should
1459 be processed later. It decides how much later, and may need to move
1460 the info between obstacks; therefore, the caller should not refer to
1461 the T parameter after calling this function. */
1464 store_pending_inline (decl, t)
1466 struct pending_inline *t;
1469 DECL_PENDING_INLINE_INFO (decl) = t;
1471 /* Because we use obstacks, we must process these in precise order. */
1472 t->next = pending_inlines;
1473 pending_inlines = t;
1477 reinit_parse_for_method (yychar, decl)
1482 int starting_lineno = lineno;
1483 char *starting_filename = input_filename;
1485 reinit_parse_for_block (yychar, &inline_text_obstack);
1487 len = obstack_object_size (&inline_text_obstack);
1488 current_base_init_list = NULL_TREE;
1489 current_member_init_list = NULL_TREE;
1490 if (decl == void_type_node
1491 || (current_class_type && TYPE_REDEFINED (current_class_type)))
1493 /* Happens when we get two declarations of the same
1494 function in the same scope. */
1495 char *buf = obstack_finish (&inline_text_obstack);
1496 obstack_free (&inline_text_obstack, buf);
1501 struct pending_inline *t;
1502 char *buf = obstack_finish (&inline_text_obstack);
1504 t = (struct pending_inline *) obstack_alloc (&inline_text_obstack,
1505 sizeof (struct pending_inline));
1506 t->lineno = starting_lineno;
1507 t->filename = starting_filename;
1514 if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (decl))
1515 warn_if_unknown_interface (decl);
1517 t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2));
1518 store_pending_inline (decl, t);
1522 /* Consume a block -- actually, a method beginning
1523 with `:' or `{' -- and save it away on the specified obstack. */
1526 reinit_parse_for_block (pyychar, obstackp)
1528 struct obstack *obstackp;
1532 int starting_lineno = lineno;
1533 char *starting_filename = input_filename;
1535 int look_for_semicolon = 0;
1536 int look_for_lbrac = 0;
1539 obstack_1grow (obstackp, '{');
1540 else if (pyychar == '=')
1541 look_for_semicolon = 1;
1542 else if (pyychar == ':')
1544 obstack_1grow (obstackp, pyychar);
1548 else if (pyychar == RETURN)
1550 obstack_grow (obstackp, "return", 6);
1554 else if (pyychar == TRY)
1556 obstack_grow (obstackp, "try", 3);
1562 yyerror ("parse error in method specification");
1563 obstack_1grow (obstackp, '{');
1566 if (nextchar != EOF)
1576 int this_lineno = lineno;
1578 c = skip_white_space (c);
1580 /* Don't lose our cool if there are lots of comments. */
1581 if (lineno == this_lineno + 1)
1582 obstack_1grow (obstackp, '\n');
1583 else if (lineno == this_lineno)
1585 else if (lineno - this_lineno < 10)
1588 for (i = lineno - this_lineno; i > 0; i--)
1589 obstack_1grow (obstackp, '\n');
1594 sprintf (buf, "\n# %d \"", lineno);
1596 obstack_grow (obstackp, buf, len);
1598 len = strlen (input_filename);
1599 obstack_grow (obstackp, input_filename, len);
1600 obstack_1grow (obstackp, '\"');
1601 obstack_1grow (obstackp, '\n');
1604 while (c > ' ') /* ASCII dependent... */
1606 obstack_1grow (obstackp, c);
1615 if (blev == 0 && !look_for_semicolon)
1619 if (peekyylex () == CATCH)
1622 obstack_grow (obstackp, " catch ", 7);
1639 /* Don't act on the next character...e.g, doing an escaped
1644 error_with_file_and_line (starting_filename,
1646 "end of file read inside definition");
1649 obstack_1grow (obstackp, c);
1652 consume_string (obstackp, c);
1654 consume_string (obstackp, c);
1659 error ("function body for constructor missing");
1660 obstack_1grow (obstackp, '{');
1661 obstack_1grow (obstackp, '}');
1665 else if (look_for_semicolon && blev == 0)
1673 error_with_file_and_line (starting_filename,
1675 "end of file read inside definition");
1680 obstack_1grow (obstackp, c);
1685 obstack_1grow (obstackp, '\0');
1688 /* Consume a no-commas expression -- actually, a default argument -- and
1689 save it away on the specified obstack. */
1692 reinit_parse_for_expr (obstackp)
1693 struct obstack *obstackp;
1696 int starting_lineno = lineno;
1697 char *starting_filename = input_filename;
1701 if (nextchar != EOF)
1711 int this_lineno = lineno;
1713 c = skip_white_space (c);
1715 /* Don't lose our cool if there are lots of comments. */
1716 if (lineno == this_lineno + 1)
1717 obstack_1grow (obstackp, '\n');
1718 else if (lineno == this_lineno)
1720 else if (lineno - this_lineno < 10)
1723 for (i = lineno - this_lineno; i > 0; --i)
1724 obstack_1grow (obstackp, '\n');
1729 sprintf (buf, "\n# %d \"", lineno);
1731 obstack_grow (obstackp, buf, len);
1733 len = strlen (input_filename);
1734 obstack_grow (obstackp, input_filename, len);
1735 obstack_1grow (obstackp, '\"');
1736 obstack_1grow (obstackp, '\n');
1739 while (c > ' ') /* ASCII dependent... */
1741 if (plev <= 0 && (c == ')' || c == ','))
1746 obstack_1grow (obstackp, c);
1747 if (c == '(' || c == '[')
1749 else if (c == ']' || c == ')')
1753 /* Don't act on the next character...e.g, doing an escaped
1758 error_with_file_and_line (starting_filename,
1760 "end of file read inside definition");
1763 obstack_1grow (obstackp, c);
1766 consume_string (obstackp, c);
1768 consume_string (obstackp, c);
1774 error_with_file_and_line (starting_filename,
1776 "end of file read inside definition");
1781 obstack_1grow (obstackp, c);
1786 obstack_1grow (obstackp, '\0');
1789 int do_snarf_defarg;
1791 /* Decide whether the default argument we are about to see should be
1792 gobbled up as text for later parsing. */
1795 maybe_snarf_defarg ()
1797 if (current_class_type && TYPE_BEING_DEFINED (current_class_type))
1798 do_snarf_defarg = 1;
1801 /* When we see a default argument in a method declaration, we snarf it as
1802 text using snarf_defarg. When we get up to namespace scope, we then go
1803 through and parse all of them using do_pending_defargs. Since yacc
1804 parsers are not reentrant, we retain defargs state in these two
1805 variables so that subsequent calls to do_pending_defargs can resume
1806 where the previous call left off. */
1818 reinit_parse_for_expr (&inline_text_obstack);
1819 len = obstack_object_size (&inline_text_obstack);
1820 buf = obstack_finish (&inline_text_obstack);
1822 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1823 arg = make_node (DEFAULT_ARG);
1824 DEFARG_LENGTH (arg) = len - 1;
1825 DEFARG_POINTER (arg) = buf;
1831 /* Called from grokfndecl to note a function decl with unparsed default
1832 arguments for later processing. Also called from grokdeclarator
1833 for function types with unparsed defargs; the call from grokfndecl
1834 will always come second, so we can overwrite the entry from the type. */
1837 add_defarg_fn (decl)
1840 if (TREE_CODE (decl) == FUNCTION_DECL)
1841 TREE_VALUE (defarg_fns) = decl;
1844 push_obstacks (&inline_text_obstack, &inline_text_obstack);
1845 defarg_fns = tree_cons (current_class_type, decl, defarg_fns);
1850 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1856 tree d = TREE_PURPOSE (p);
1857 feed_input (DEFARG_POINTER (d), DEFARG_LENGTH (d));
1858 if (TREE_CODE (f) == FUNCTION_DECL)
1860 lineno = DECL_SOURCE_LINE (f);
1861 input_filename = DECL_SOURCE_FILE (f);
1863 yychar = DEFARG_MARKER;
1867 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1872 if (yychar == YYEMPTY)
1874 if (yychar != END_OF_SAVED_INPUT)
1876 error ("parse error at end of saved function text");
1878 /* restore_pending_input will abort unless yychar is either
1879 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1880 hosed, feed back YYEMPTY. We also need to discard nextchar,
1881 since that may have gotten set as well. */
1888 /* Main function for deferred parsing of default arguments. Called from
1892 do_pending_defargs ()
1897 for (; defarg_fns; defarg_fns = TREE_CHAIN (defarg_fns))
1899 tree defarg_fn = TREE_VALUE (defarg_fns);
1900 if (defarg_parm == NULL_TREE)
1902 push_nested_class (TREE_PURPOSE (defarg_fns), 1);
1904 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1905 maybe_begin_member_template_processing (defarg_fn);
1907 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1911 for (p = DECL_ARGUMENTS (defarg_fn); p; p = TREE_CHAIN (p))
1912 pushdecl (copy_node (p));
1914 defarg_parm = TYPE_ARG_TYPES (TREE_TYPE (defarg_fn));
1917 defarg_parm = TYPE_ARG_TYPES (defarg_fn);
1920 defarg_parm = TREE_CHAIN (defarg_parm);
1922 for (; defarg_parm; defarg_parm = TREE_CHAIN (defarg_parm))
1923 if (TREE_PURPOSE (defarg_parm)
1924 && TREE_CODE (TREE_PURPOSE (defarg_parm)) == DEFAULT_ARG)
1926 feed_defarg (defarg_fn, defarg_parm);
1928 /* Return to the parser, which will process this defarg
1929 and call us again. */
1933 if (TREE_CODE (defarg_fn) == FUNCTION_DECL)
1935 maybe_end_member_template_processing (defarg_fn);
1936 check_default_args (defarg_fn);
1940 pop_nested_class (1);
1944 /* Build a default function named NAME for type TYPE.
1945 KIND says what to build.
1947 When KIND == 0, build default destructor.
1948 When KIND == 1, build virtual destructor.
1949 When KIND == 2, build default constructor.
1950 When KIND == 3, build default X(const X&) constructor.
1951 When KIND == 4, build default X(X&) constructor.
1952 When KIND == 5, build default operator = (const X&).
1953 When KIND == 6, build default operator = (X&). */
1956 cons_up_default_function (type, full_name, kind)
1957 tree type, full_name;
1960 extern tree void_list_node;
1961 tree declspecs = NULL_TREE;
1962 tree fn, args = NULL_TREE;
1965 tree name = constructor_name (full_name);
1971 declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_VIRTUAL]);
1972 /* Fall through... */
1974 name = build_parse_node (BIT_NOT_EXPR, name);
1975 args = void_list_node;
1979 /* Default constructor. */
1980 args = void_list_node;
1984 type = build_type_variant (type, 1, 0);
1985 /* Fall through... */
1987 /* According to ARM $12.8, the default copy ctor will be declared, but
1988 not defined, unless it's needed. */
1989 argtype = build_reference_type (type);
1990 args = tree_cons (NULL_TREE,
1991 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
1992 get_identifier ("_ctor_arg")),
1999 declspecs = build_decl_list (NULL_TREE, type);
2002 type = build_type_variant (type, 1, 0);
2004 name = ansi_opname [(int) MODIFY_EXPR];
2006 argtype = build_reference_type (type);
2007 args = tree_cons (NULL_TREE,
2008 build_tree_list (hash_tree_chain (argtype, NULL_TREE),
2009 get_identifier ("_ctor_arg")),
2014 my_friendly_abort (59);
2017 declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE],
2020 TREE_PARMLIST (args) = 1;
2023 tree declarator = make_call_declarator (name, args, NULL_TREE, NULL_TREE);
2025 declarator = build_parse_node (ADDR_EXPR, declarator);
2027 fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE);
2030 if (fn == void_type_node)
2034 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn)));
2037 if (processing_template_defn)
2039 SET_DECL_IMPLICIT_INSTANTIATION (fn);
2040 repo_template_used (fn);
2045 if (CLASSTYPE_INTERFACE_KNOWN (type))
2047 DECL_INTERFACE_KNOWN (fn) = 1;
2048 DECL_NOT_REALLY_EXTERN (fn) = (!CLASSTYPE_INTERFACE_ONLY (type)
2049 && flag_implement_inlines);
2053 DECL_NOT_REALLY_EXTERN (fn) = 1;
2055 mark_inline_for_output (fn);
2057 #ifdef DEBUG_DEFAULT_FUNCTIONS
2058 { char *fn_type = NULL;
2062 case 0: fn_type = "default destructor"; break;
2063 case 1: fn_type = "virtual destructor"; break;
2064 case 2: fn_type = "default constructor"; break;
2065 case 3: fn_type = "default X(const X&)"; break;
2066 case 4: fn_type = "default X(X&)"; break;
2070 if (TREE_CODE (name) == BIT_NOT_EXPR)
2071 t = TREE_OPERAND (name, 0);
2072 fprintf (stderr, "[[[[ %s for %s:\n%s]]]]\n", fn_type,
2073 IDENTIFIER_POINTER (t), func_buf);
2076 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2078 /* Show that this function was generated by the compiler. */
2079 SET_DECL_ARTIFICIAL (fn);
2084 /* Heuristic to tell whether the user is missing a semicolon
2085 after a struct or enum declaration. Emit an error message
2086 if we know the user has blown it. */
2089 check_for_missing_semicolon (type)
2097 && yychar != IDENTIFIER
2098 && yychar != TYPENAME
2099 && yychar != CV_QUALIFIER
2100 && yychar != SELFNAME)
2103 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type)))
2104 error ("semicolon missing after %s declaration",
2105 TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct");
2107 cp_error ("semicolon missing after declaration of `%T'", type);
2108 shadow_tag (build_tree_list (0, type));
2110 /* Could probably also hack cases where class { ... } f (); appears. */
2115 note_got_semicolon (type)
2118 if (TREE_CODE_CLASS (TREE_CODE (type)) != 't')
2119 my_friendly_abort (60);
2120 if (IS_AGGR_TYPE (type))
2121 CLASSTYPE_GOT_SEMICOLON (type) = 1;
2125 note_list_got_semicolon (declspecs)
2130 for (link = declspecs; link; link = TREE_CHAIN (link))
2132 tree type = TREE_VALUE (link);
2133 if (TREE_CODE_CLASS (TREE_CODE (type)) == 't')
2134 note_got_semicolon (type);
2139 /* If C is not whitespace, return C.
2140 Otherwise skip whitespace and return first nonwhite char read. */
2143 skip_white_space (c)
2151 c = check_newline ();
2162 while (c == ' ' || c == '\t');
2170 error ("stray '\\' in program");
2182 /* Make the token buffer longer, preserving the data in it.
2183 P should point to just beyond the last valid character in the old buffer.
2184 The value we return is a pointer to the new buffer
2185 at a place corresponding to P. */
2188 extend_token_buffer (p)
2191 int offset = p - token_buffer;
2193 maxtoken = maxtoken * 2 + 10;
2194 token_buffer = (char *) xrealloc (token_buffer, maxtoken + 2);
2196 return token_buffer + offset;
2200 get_last_nonwhite_on_line ()
2204 /* Is this the last nonwhite stuff on the line? */
2206 c = nextchar, nextchar = -1;
2210 while (c == ' ' || c == '\t')
2215 /* At the beginning of a line, increment the line number
2216 and process any #-directive on this line.
2217 If the line is a #-directive, read the entire line and return a newline.
2218 Otherwise, return the line's first non-whitespace character. */
2222 static int handle_cp_pragma PROTO((char *));
2230 /* Read first nonwhite char on the line. Do this before incrementing the
2231 line number, in case we're at the end of saved text. */
2235 while (c == ' ' || c == '\t');
2241 /* If not #, return it so caller will use it. */
2245 /* Don't read beyond this line. */
2248 /* Read first nonwhite char after the `#'. */
2252 while (c == ' ' || c == '\t');
2254 /* If a letter follows, then if the word here is `line', skip
2255 it and ignore it; otherwise, ignore the line, with an error
2256 if the word isn't `pragma'. */
2258 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
2268 token = real_yylex ();
2269 if (token == IDENTIFIER
2270 && TREE_CODE (yylval.ttype) == IDENTIFIER_NODE)
2272 /* If this is 1, we handled it; if it's -1, it was one we
2273 wanted but had something wrong with it. Only if it's
2274 0 was it not handled. */
2275 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval.ttype)))
2278 else if (token == END_OF_LINE)
2281 #ifdef HANDLE_SYSV_PRAGMA
2282 if (handle_sysv_pragma (token))
2285 #ifdef HANDLE_PRAGMA
2290 if (HANDLE_PRAGMA (finput, yylval.ttype))
2292 #endif /* !USE_CPPLIB */
2305 && ((c = getch ()) == ' ' || c == '\t'))
2307 debug_define (lineno, GET_DIRECTIVE_LINE ());
2317 && ((c = getch ()) == ' ' || c == '\t'))
2319 debug_undef (lineno, GET_DIRECTIVE_LINE ());
2328 && ((c = getch ()) == ' ' || c == '\t'))
2337 && ((c = getch ()) == ' ' || c == '\t'))
2339 /* #ident. The pedantic warning is now in cccp.c. */
2341 /* Here we have just seen `#ident '.
2342 A string constant should follow. */
2344 token = real_yylex ();
2345 if (token == END_OF_LINE)
2348 || TREE_CODE (yylval.ttype) != STRING_CST)
2350 error ("invalid #ident");
2354 if (! flag_no_ident)
2356 #ifdef ASM_OUTPUT_IDENT
2357 ASM_OUTPUT_IDENT (asm_out_file,
2358 TREE_STRING_POINTER (yylval.ttype));
2362 /* Skip the rest of this line. */
2375 && ((c = getch ()) == ' ' || c == '\t'))
2377 /* Used to test incremental compilation. */
2378 sorry ("#pragma newworld");
2382 error ("undefined or invalid # directive");
2387 /* Here we have either `#line' or `# <nonletter>'.
2388 In either case, it should be a line number; a digit should follow. */
2390 while (c == ' ' || c == '\t')
2393 /* If the # is the only nonwhite char on the line,
2394 just ignore it. Check the new newline. */
2398 /* Something follows the #; read a token. */
2401 token = real_yylex ();
2403 if (token == CONSTANT
2404 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2406 int old_lineno = lineno;
2407 enum { act_none, act_push, act_pop } action = act_none;
2408 int entering_system_header = 0;
2409 int entering_c_header = 0;
2411 /* subtract one, because it is the following line that
2412 gets the specified number */
2414 int l = TREE_INT_CST_LOW (yylval.ttype) - 1;
2415 c = get_last_nonwhite_on_line ();
2418 /* No more: store the line number and check following line. */
2424 /* More follows: it must be a string constant (filename). */
2426 /* Read the string constant, but don't treat \ as special. */
2427 ignore_escape_flag = 1;
2428 token = real_yylex ();
2429 ignore_escape_flag = 0;
2431 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
2433 error ("invalid #line");
2437 /* Changing files again. This means currently collected time
2438 is charged against header time, and body time starts back
2440 if (flag_detailed_statistics)
2442 int this_time = my_get_run_time ();
2443 tree time_identifier = get_time_identifier (TREE_STRING_POINTER (yylval.ttype));
2444 header_time += this_time - body_time;
2445 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
2446 += this_time - body_time;
2447 this_filename_time = time_identifier;
2448 body_time = this_time;
2452 = (char *) permalloc (TREE_STRING_LENGTH (yylval.ttype) + 1);
2453 strcpy (input_filename, TREE_STRING_POINTER (yylval.ttype));
2455 GNU_xref_file (input_filename);
2457 if (main_input_filename == 0)
2459 struct impl_files *ifiles = impl_file_chain;
2463 while (ifiles->next)
2464 ifiles = ifiles->next;
2465 ifiles->filename = file_name_nondirectory (input_filename);
2468 main_input_filename = input_filename;
2469 if (write_virtuals == 3)
2470 walk_vtables (set_typedecl_interface_info, set_vardecl_interface_info);
2473 extract_interface_info ();
2475 c = get_last_nonwhite_on_line ();
2478 /* Update the name in the top element of input_file_stack. */
2479 if (input_file_stack)
2480 input_file_stack->name = input_filename;
2486 token = real_yylex ();
2488 /* `1' after file name means entering new file.
2489 `2' after file name means just left a file. */
2491 if (token == CONSTANT
2492 && TREE_CODE (yylval.ttype) == INTEGER_CST)
2494 if (TREE_INT_CST_LOW (yylval.ttype) == 1)
2496 else if (TREE_INT_CST_LOW (yylval.ttype) == 2)
2501 c = get_last_nonwhite_on_line ();
2505 token = real_yylex ();
2510 /* `3' after file name means this is a system header file. */
2512 if (token == CONSTANT
2513 && TREE_CODE (yylval.ttype) == INTEGER_CST
2514 && TREE_INT_CST_LOW (yylval.ttype) == 3)
2516 entering_system_header = 1;
2518 c = get_last_nonwhite_on_line ();
2522 token = real_yylex ();
2526 /* `4' after file name means this is a C header file. */
2528 if (token == CONSTANT
2529 && TREE_CODE (yylval.ttype) == INTEGER_CST
2530 && TREE_INT_CST_LOW (yylval.ttype) == 4)
2532 entering_c_header = 1;
2534 c = get_last_nonwhite_on_line ();
2538 token = real_yylex ();
2542 /* Do the actions implied by the preceding numbers. */
2544 if (action == act_push)
2546 /* Pushing to a new file. */
2547 struct file_stack *p;
2549 p = (struct file_stack *) xmalloc (sizeof (struct file_stack));
2550 input_file_stack->line = old_lineno;
2551 p->next = input_file_stack;
2552 p->name = input_filename;
2553 input_file_stack = p;
2554 input_file_stack_tick++;
2555 debug_start_source_file (input_filename);
2556 in_system_header = entering_system_header;
2559 else if (entering_c_header)
2562 ++pending_lang_change;
2565 else if (action == act_pop)
2567 /* Popping out of a file. */
2568 if (input_file_stack->next)
2570 struct file_stack *p;
2572 if (c_header_level && --c_header_level == 0)
2574 if (entering_c_header)
2575 warning ("badly nested C headers from preprocessor");
2576 --pending_lang_change;
2578 in_system_header = entering_system_header;
2580 p = input_file_stack;
2581 input_file_stack = p->next;
2583 input_file_stack_tick++;
2584 debug_end_source_file (input_file_stack->line);
2587 error ("#-lines for entering and leaving files don't match");
2590 in_system_header = entering_system_header;
2593 /* If NEXTCHAR is not end of line, we don't care what it is. */
2594 if (nextchar == EOF)
2598 error ("invalid #-line");
2600 /* skip the rest of this line. */
2605 while ((c = getch ()) != EOF && c != '\n');
2610 do_pending_lang_change ()
2612 for (; pending_lang_change > 0; --pending_lang_change)
2613 push_lang_context (lang_name_c);
2614 for (; pending_lang_change < 0; ++pending_lang_change)
2615 pop_lang_context ();
2618 #define ENDFILE -1 /* token that represents end-of-file */
2620 /* Read an escape sequence, returning its equivalent as a character,
2621 or store 1 in *ignore_ptr if it is backslash-newline. */
2624 readescape (ignore_ptr)
2627 register int c = getch ();
2629 register unsigned count;
2630 unsigned firstdig = 0;
2648 if (c >= 'a' && c <= 'f')
2649 code += c - 'a' + 10;
2650 if (c >= 'A' && c <= 'F')
2651 code += c - 'A' + 10;
2652 if (c >= '0' && c <= '9')
2654 if (code != 0 || count != 0)
2663 error ("\\x used with no following hex digits");
2664 else if (count == 0)
2665 /* Digits are all 0's. Ok. */
2667 else if ((count - 1) * 4 >= TYPE_PRECISION (integer_type_node)
2669 && ((1 << (TYPE_PRECISION (integer_type_node) - (count - 1) * 4))
2671 pedwarn ("hex escape out of range");
2674 case '0': case '1': case '2': case '3': case '4':
2675 case '5': case '6': case '7':
2678 while ((c <= '7') && (c >= '0') && (count++ < 3))
2680 code = (code * 8) + (c - '0');
2686 case '\\': case '\'': case '"':
2695 return TARGET_NEWLINE;
2718 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c);
2724 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2728 /* `\%' is used to prevent SCCS from getting confused. */
2731 pedwarn ("unknown escape sequence `\\%c'", c);
2734 if (c >= 040 && c < 0177)
2735 pedwarn ("unknown escape sequence `\\%c'", c);
2737 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c);
2741 /* Value is 1 (or 2) if we should try to make the next identifier look like
2742 a typename (when it may be a local variable or a class variable).
2743 Value is 0 if we treat this name in a default fashion. */
2744 int looking_for_typename;
2750 identifier_type (decl)
2753 if (TREE_CODE (decl) == TEMPLATE_DECL)
2755 if (TREE_CODE (DECL_RESULT (decl)) == TYPE_DECL)
2757 else if (looking_for_template)
2760 if (looking_for_template && really_overloaded_fn (decl))
2763 for (t = decl; t != NULL_TREE; t = OVL_CHAIN (t))
2764 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t)))
2767 if (TREE_CODE (decl) == NAMESPACE_DECL)
2769 if (TREE_CODE (decl) != TYPE_DECL)
2771 if (((got_scope && TREE_TYPE (decl) == got_scope)
2772 || TREE_TYPE (decl) == current_class_type)
2773 && DECL_ARTIFICIAL (decl))
2781 /* Only types expected, not even namespaces. */
2782 looking_for_typename = 2;
2784 if ((yychar = yylex ()) < 0) yychar = 0;
2785 looking_for_typename = 0;
2786 if (yychar == IDENTIFIER)
2788 lastiddecl = lookup_name (yylval.ttype, -2);
2789 if (lastiddecl == 0)
2792 lastiddecl = IDENTIFIER_LABEL_VALUE (yylval.ttype);
2795 yychar = identifier_type (lastiddecl);
2799 /* Return true if d is in a global scope. */
2806 switch (TREE_CODE (d))
2808 case OVERLOAD: d = OVL_FUNCTION (d); continue;
2809 case TREE_LIST: d = TREE_VALUE (d); continue;
2811 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (d)) == 'd', 980629);
2812 d = CP_DECL_CONTEXT (d);
2813 return TREE_CODE (d) == NAMESPACE_DECL;
2818 do_identifier (token, parsing, args)
2819 register tree token;
2824 int lexing = (parsing == 1);
2825 int in_call = (parsing == 2);
2827 if (! lexing || IDENTIFIER_OPNAME_P (token))
2828 id = lookup_name (token, 0);
2832 /* Scope class declarations before global
2834 if ((!id || is_global (id))
2835 && current_class_type != 0
2836 && TYPE_SIZE (current_class_type) == 0)
2838 /* Could be from one of the base classes. */
2839 tree field = lookup_field (current_class_type, token, 1, 0);
2842 else if (field == error_mark_node)
2843 /* We have already generated the error message.
2844 But we still want to return this value. */
2845 id = lookup_field (current_class_type, token, 0, 0);
2846 else if (TREE_CODE (field) == VAR_DECL
2847 || TREE_CODE (field) == CONST_DECL
2848 || TREE_CODE (field) == TEMPLATE_DECL)
2850 else if (TREE_CODE (field) != FIELD_DECL)
2851 my_friendly_abort (61);
2854 cp_error ("invalid use of member `%D' from base class `%T'", field,
2855 DECL_FIELD_CONTEXT (field));
2856 id = error_mark_node;
2861 /* Do Koenig lookup if appropriate (inside templates we build lookup
2862 expressions instead). */
2863 if (args && !current_template_parms && (!id || is_global (id)))
2865 /* If we have arguments and we only found global names,
2866 do Koenig lookup. */
2867 id = lookup_arg_dependent (token, id, args);
2870 /* Remember that this name has been used in the class definition, as per
2872 if (id && current_class_type && parsing
2873 && TYPE_BEING_DEFINED (current_class_type)
2874 && ! IDENTIFIER_CLASS_VALUE (token)
2875 /* Avoid breaking if we get called for a default argument that
2876 refers to an overloaded method. Eventually this will not be
2877 necessary, since default arguments shouldn't be parsed until
2878 after the class is complete. (jason 3/12/97) */
2879 && TREE_CODE (id) != OVERLOAD)
2880 pushdecl_class_level (id);
2882 if (!id || id == error_mark_node)
2884 if (id == error_mark_node && current_class_type != NULL_TREE)
2886 id = lookup_nested_field (token, 1);
2887 /* In lookup_nested_field(), we marked this so we can gracefully
2888 leave this whole mess. */
2889 if (id && id != error_mark_node && TREE_TYPE (id) == error_mark_node)
2893 if (current_template_parms)
2894 return build_min_nt (LOOKUP_EXPR, token);
2895 else if (IDENTIFIER_OPNAME_P (token))
2897 if (token != ansi_opname[ERROR_MARK])
2898 cp_error ("`%D' not defined", token);
2899 id = error_mark_node;
2903 id = implicitly_declare (token);
2905 else if (current_function_decl == 0)
2907 cp_error ("`%D' was not declared in this scope", token);
2908 id = error_mark_node;
2912 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node
2913 || IDENTIFIER_ERROR_LOCUS (token) != current_function_decl)
2915 static int undeclared_variable_notice;
2917 cp_error ("`%D' undeclared (first use this function)", token);
2919 if (! undeclared_variable_notice)
2921 error ("(Each undeclared identifier is reported only once");
2922 error ("for each function it appears in.)");
2923 undeclared_variable_notice = 1;
2926 id = error_mark_node;
2927 /* Prevent repeated error messages. */
2928 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
2929 SET_IDENTIFIER_ERROR_LOCUS (token, current_function_decl);
2933 if (TREE_CODE (id) == VAR_DECL && DECL_DEAD_FOR_LOCAL (id))
2935 tree shadowed = DECL_SHADOWED_FOR_VAR (id);
2936 while (shadowed != NULL_TREE && TREE_CODE (shadowed) == VAR_DECL
2937 && DECL_DEAD_FOR_LOCAL (shadowed))
2938 shadowed = DECL_SHADOWED_FOR_VAR (shadowed);
2940 shadowed = IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id));
2943 if (!DECL_ERROR_REPORTED (id))
2945 warning ("name lookup of `%s' changed",
2946 IDENTIFIER_POINTER (token));
2947 cp_warning_at (" matches this `%D' under current ANSI rules",
2949 cp_warning_at (" matches this `%D' under old rules", id);
2950 DECL_ERROR_REPORTED (id) = 1;
2954 else if (!DECL_ERROR_REPORTED (id))
2957 = "name lookup of `%s' changed for new ANSI `for' scoping";
2958 DECL_ERROR_REPORTED (id) = 1;
2959 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id)))
2961 error (msg, IDENTIFIER_POINTER (token));
2962 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id);
2963 id = error_mark_node;
2967 pedwarn (msg, IDENTIFIER_POINTER (token));
2968 cp_pedwarn_at (" using obsolete binding at `%D'", id);
2972 /* TREE_USED is set in `hack_identifier'. */
2973 if (TREE_CODE (id) == CONST_DECL)
2975 if (IDENTIFIER_CLASS_VALUE (token) == id)
2978 tree access = compute_access (TYPE_BINFO (current_class_type), id);
2979 if (access == access_private_node)
2980 cp_error ("enum `%D' is private", id);
2981 /* protected is OK, since it's an enum of `this'. */
2983 if (! processing_template_decl
2984 || (DECL_INITIAL (id)
2985 && TREE_CODE (DECL_INITIAL (id)) == TEMPLATE_PARM_INDEX))
2986 id = DECL_INITIAL (id);
2989 id = hack_identifier (id, token);
2991 /* We must look up dependent names when the template is
2992 instantiated, not while parsing it. For now, we don't
2993 distinguish between dependent and independent names. So, for
2994 example, we look up all overloaded functions at
2995 instantiation-time, even though in some cases we should just use
2996 the DECL we have here. We also use LOOKUP_EXPRs to find things
2997 like local variables, rather than created TEMPLATE_DECLs for the
2998 local variables and then finding matching instantiations. */
2999 if (current_template_parms
3000 && (is_overloaded_fn (id)
3001 /* If it's not going to be around at instantiation time, we
3002 look it up then. This is a hack, and should go when we
3003 really get dependent/independent name lookup right. */
3004 || !TREE_PERMANENT (id)
3005 /* Some local VAR_DECLs (such as those for local variables
3006 in member functions of local classes) are built on the
3007 permanent obstack. */
3008 || (TREE_CODE (id) == VAR_DECL
3009 && CP_DECL_CONTEXT (id)
3010 && TREE_CODE (CP_DECL_CONTEXT (id)) == FUNCTION_DECL)
3011 || TREE_CODE (id) == PARM_DECL
3012 || TREE_CODE (id) == USING_DECL))
3013 id = build_min_nt (LOOKUP_EXPR, token);
3019 do_scoped_id (token, parsing)
3024 /* during parsing, this is ::name. Otherwise, it is black magic. */
3027 struct tree_binding _b;
3028 id = binding_init (&_b);
3029 if (!qualified_lookup_using_namespace (token, global_namespace, id, 0))
3032 id = BINDING_VALUE (id);
3035 id = IDENTIFIER_GLOBAL_VALUE (token);
3036 if (parsing && yychar == YYEMPTY)
3040 if (processing_template_decl)
3042 id = build_min_nt (LOOKUP_EXPR, token);
3043 LOOKUP_EXPR_GLOBAL (id) = 1;
3046 if (parsing && (yychar == '(' || yychar == LEFT_RIGHT))
3047 id = implicitly_declare (token);
3050 if (IDENTIFIER_NAMESPACE_VALUE (token) != error_mark_node)
3051 cp_error ("`::%D' undeclared (first use here)", token);
3052 id = error_mark_node;
3053 /* Prevent repeated error messages. */
3054 SET_IDENTIFIER_NAMESPACE_VALUE (token, error_mark_node);
3059 if (TREE_CODE (id) == ADDR_EXPR)
3060 mark_used (TREE_OPERAND (id, 0));
3061 else if (TREE_CODE (id) != OVERLOAD)
3064 if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
3066 /* XXX CHS - should we set TREE_USED of the constant? */
3067 id = DECL_INITIAL (id);
3068 /* This is to prevent an enum whose value is 0
3069 from being considered a null pointer constant. */
3070 id = build1 (NOP_EXPR, TREE_TYPE (id), id);
3071 TREE_CONSTANT (id) = 1;
3074 if (processing_template_decl)
3076 if (is_overloaded_fn (id))
3078 id = build_min_nt (LOOKUP_EXPR, token);
3079 LOOKUP_EXPR_GLOBAL (id) = 1;
3082 /* else just use the decl */
3084 return convert_from_reference (id);
3088 identifier_typedecl_value (node)
3092 type = IDENTIFIER_TYPE_VALUE (node);
3093 if (type == NULL_TREE)
3098 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3101 do (IDENTIFIER_LOCAL_VALUE (node));
3102 do (IDENTIFIER_CLASS_VALUE (node));
3103 do (IDENTIFIER_NAMESPACE_VALUE (node));
3105 /* Will this one ever happen? */
3106 if (TYPE_MAIN_DECL (type))
3107 return TYPE_MAIN_DECL (type);
3109 /* We used to do an internal error of 62 here, but instead we will
3110 handle the return of a null appropriately in the callers. */
3120 int dollar_seen = 0;
3124 c = nextchar, nextchar = -1;
3128 /* Effectively do c = skip_white_space (c)
3129 but do it faster in the usual cases. */
3142 /* Call skip_white_space so we can warn if appropriate. */
3147 c = skip_white_space (c);
3149 goto found_nonwhite;
3153 token_buffer[0] = c;
3154 token_buffer[1] = 0;
3156 /* yylloc.first_line = lineno; */
3161 token_buffer[0] = '\0';
3163 if (input_redirected ())
3164 value = END_OF_SAVED_INPUT;
3166 value = END_OF_LINE;
3172 if (! dollars_in_ident)
3173 error ("`$' in identifier");
3175 pedwarn ("`$' in identifier");
3180 /* Capital L may start a wide-string or wide-character constant. */
3182 register int c = getch ();
3191 goto string_constant;
3196 case 'A': case 'B': case 'C': case 'D': case 'E':
3197 case 'F': case 'G': case 'H': case 'I': case 'J':
3198 case 'K': case 'M': case 'N': case 'O':
3199 case 'P': case 'Q': case 'R': case 'S': case 'T':
3200 case 'U': case 'V': case 'W': case 'X': case 'Y':
3202 case 'a': case 'b': case 'c': case 'd': case 'e':
3203 case 'f': case 'g': case 'h': case 'i': case 'j':
3204 case 'k': case 'l': case 'm': case 'n': case 'o':
3205 case 'p': case 'q': case 'r': case 's': case 't':
3206 case 'u': case 'v': case 'w': case 'x': case 'y':
3216 /* We know that `token_buffer' can hold at least on char,
3217 so we install C immediately.
3218 We may have to read the value in `putback_char', so call
3223 /* Make this run fast. We know that we are reading straight
3224 from FINPUT in this case (since identifiers cannot straddle
3226 while (ISALNUM (c) || (c == '_') || c == '$')
3230 if (! dollars_in_ident)
3231 error ("`$' in identifier");
3233 pedwarn ("`$' in identifier");
3236 if (p >= token_buffer + maxtoken)
3237 p = extend_token_buffer (p);
3243 if (linemode && c == '\n')
3251 /* We know that `token_buffer' can hold at least on char,
3252 so we install C immediately. */
3256 while (ISALNUM (c) || (c == '_') || c == '$')
3260 if (! dollars_in_ident)
3261 error ("`$' in identifier");
3263 pedwarn ("`$' in identifier");
3266 if (p >= token_buffer + maxtoken)
3267 p = extend_token_buffer (p);
3280 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3283 register struct resword *ptr;
3285 if ((ptr = is_reserved_word (token_buffer, p - token_buffer)))
3289 tree old_ttype = ridpointers[(int) ptr->rid];
3291 /* If this provides a type for us, then revert lexical
3292 state to standard state. */
3293 if (TREE_CODE (old_ttype) == IDENTIFIER_NODE
3294 && IDENTIFIER_GLOBAL_VALUE (old_ttype) != 0
3295 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype)) == TYPE_DECL)
3296 looking_for_typename = 0;
3297 else if (ptr->token == AGGR || ptr->token == ENUM)
3298 looking_for_typename = 2;
3300 /* Check if this is a language-type declaration.
3301 Just glimpse the next non-white character. */
3302 nextchar = skip_white_space (nextchar);
3303 if (nextchar == '"')
3305 /* We are looking at a string. Complain
3306 if the token before the string is no `extern'.
3308 Could cheat some memory by placing this string
3309 on the temporary_, instead of the saveable_
3312 if (ptr->rid != RID_EXTERN)
3313 error ("invalid modifier `%s' for language string",
3316 value = EXTERN_LANG_STRING;
3317 yylval.ttype = get_identifier (TREE_STRING_POINTER (yylval.ttype));
3320 if (ptr->token == VISSPEC)
3325 yylval.ttype = access_public_node;
3328 yylval.ttype = access_private_node;
3331 yylval.ttype = access_protected_node;
3334 my_friendly_abort (63);
3338 yylval.ttype = old_ttype;
3340 else if (ptr->token == EQCOMPARE)
3342 yylval.code = NE_EXPR;
3343 token_buffer[0] = '!';
3344 token_buffer[1] = '=';
3345 token_buffer[2] = 0;
3347 else if (ptr->token == ASSIGN)
3349 if (strcmp ("and_eq", token_buffer) == 0)
3351 yylval.code = BIT_AND_EXPR;
3352 token_buffer[0] = '&';
3354 else if (strcmp ("or_eq", token_buffer) == 0)
3356 yylval.code = BIT_IOR_EXPR;
3357 token_buffer[0] = '|';
3359 else if (strcmp ("xor_eq", token_buffer) == 0)
3361 yylval.code = BIT_XOR_EXPR;
3362 token_buffer[0] = '^';
3364 token_buffer[1] = '=';
3365 token_buffer[2] = 0;
3367 else if (ptr->token == '&')
3369 yylval.code = BIT_AND_EXPR;
3370 token_buffer[0] = '&';
3371 token_buffer[1] = 0;
3373 else if (ptr->token == '|')
3375 yylval.code = BIT_IOR_EXPR;
3376 token_buffer[0] = '|';
3377 token_buffer[1] = 0;
3379 else if (ptr->token == '^')
3381 yylval.code = BIT_XOR_EXPR;
3382 token_buffer[0] = '^';
3383 token_buffer[1] = 0;
3386 value = (int) ptr->token;
3390 /* If we did not find a keyword, look for an identifier
3393 if (value == IDENTIFIER || value == TYPESPEC)
3394 GNU_xref_ref (current_function_decl, token_buffer);
3396 if (value == IDENTIFIER)
3398 register tree tmp = get_identifier (token_buffer);
3400 #if !defined(VMS) && defined(JOINER)
3401 /* Make sure that user does not collide with our internal
3405 && (THIS_NAME_P (tmp)
3406 || VPTR_NAME_P (tmp)
3407 || DESTRUCTOR_NAME_P (tmp)
3408 || VTABLE_NAME_P (tmp)
3409 || TEMP_NAME_P (tmp)
3410 || ANON_AGGRNAME_P (tmp)
3411 || ANON_PARMNAME_P (tmp)))
3412 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3418 if (value == NEW && ! global_bindings_p ())
3428 register int c1 = getch ();
3429 token_buffer[0] = c;
3430 token_buffer[1] = c1;
3434 token_buffer[2] = 0;
3442 token_buffer[2] = c1;
3443 token_buffer[3] = 0;
3447 error ("parse error at `..'");
3452 goto resume_numerical_scan;
3456 token_buffer[1] = 0;
3460 /* Optimize for most frequent case. */
3462 register int c1 = getch ();
3463 if (! ISALNUM (c1) && c1 != '.')
3465 /* Terminate string. */
3466 token_buffer[0] = c;
3467 token_buffer[1] = 0;
3469 yylval.ttype = integer_zero_node;
3471 yylval.ttype = integer_one_node;
3478 /* fall through... */
3479 case '2': case '3': case '4':
3480 case '5': case '6': case '7': case '8': case '9':
3481 resume_numerical_scan:
3486 int largest_digit = 0;
3488 /* for multi-precision arithmetic,
3489 we actually store only HOST_BITS_PER_CHAR bits in each part.
3490 The number of parts is chosen so as to be sufficient to hold
3491 the enough bits to fit into the two HOST_WIDE_INTs that contain
3492 the integer value (this is always at least as many bits as are
3493 in a target `long long' value, but may be wider). */
3494 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3495 int parts[TOTAL_PARTS];
3498 enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS} floatflag
3501 for (count = 0; count < TOTAL_PARTS; count++)
3509 *p++ = (c = getch ());
3510 if ((c == 'x') || (c == 'X'))
3513 *p++ = (c = getch ());
3515 /* Leading 0 forces octal unless the 0 is the only digit. */
3516 else if (c >= '0' && c <= '9')
3525 /* Read all the digits-and-decimal-points. */
3528 || (ISALNUM (c) && (c != 'l') && (c != 'L')
3529 && (c != 'u') && (c != 'U')
3530 && c != 'i' && c != 'I' && c != 'j' && c != 'J'
3531 && (floatflag == NOT_FLOAT || ((c != 'f') && (c != 'F')))))
3536 error ("floating constant may not be in radix 16");
3537 if (floatflag == TOO_MANY_POINTS)
3538 /* We have already emitted an error. Don't need another. */
3540 else if (floatflag == AFTER_POINT)
3542 error ("malformed floating constant");
3543 floatflag = TOO_MANY_POINTS;
3544 /* Avoid another error from atof by forcing all characters
3545 from here on to be ignored. */
3549 floatflag = AFTER_POINT;
3552 *p++ = c = getch ();
3553 /* Accept '.' as the start of a floating-point number
3554 only when it is followed by a digit.
3555 Otherwise, unread the following non-digit
3556 and use the '.' as a structural token. */
3557 if (p == token_buffer + 2 && !ISDIGIT (c))
3569 error ("parse error at `..'");
3572 token_buffer[1] = '\0';
3579 /* It is not a decimal point.
3580 It should be a digit (perhaps a hex digit). */
3586 else if (base <= 10)
3588 if (c == 'e' || c == 'E')
3591 floatflag = AFTER_POINT;
3592 break; /* start of exponent */
3594 error ("nondigits in number and not hexadecimal");
3605 if (c >= largest_digit)
3609 for (count = 0; count < TOTAL_PARTS; count++)
3611 parts[count] *= base;
3615 += (parts[count-1] >> HOST_BITS_PER_CHAR);
3617 &= (1 << HOST_BITS_PER_CHAR) - 1;
3623 /* If the extra highest-order part ever gets anything in it,
3624 the number is certainly too big. */
3625 if (parts[TOTAL_PARTS - 1] != 0)
3628 if (p >= token_buffer + maxtoken - 3)
3629 p = extend_token_buffer (p);
3630 *p++ = (c = getch ());
3635 error ("numeric constant with no digits");
3637 if (largest_digit >= base)
3638 error ("numeric constant contains digits beyond the radix");
3640 /* Remove terminating char from the token buffer and delimit the string */
3643 if (floatflag != NOT_FLOAT)
3645 tree type = double_type_node;
3646 int exceeds_double = 0;
3648 REAL_VALUE_TYPE value;
3651 /* Read explicit exponent if any, and put it in tokenbuf. */
3653 if ((c == 'e') || (c == 'E'))
3655 if (p >= token_buffer + maxtoken - 3)
3656 p = extend_token_buffer (p);
3659 if ((c == '+') || (c == '-'))
3665 error ("floating constant exponent has no digits");
3668 if (p >= token_buffer + maxtoken - 3)
3669 p = extend_token_buffer (p);
3678 /* Convert string to a double, checking for overflow. */
3679 if (setjmp (handler))
3681 error ("floating constant out of range");
3686 int fflag = 0, lflag = 0;
3687 /* Copy token_buffer now, while it has just the number
3688 and not the suffixes; once we add `f' or `i',
3689 REAL_VALUE_ATOF may not work any more. */
3690 char *copy = (char *) alloca (p - token_buffer + 1);
3691 bcopy (token_buffer, copy, p - token_buffer + 1);
3693 set_float_handler (handler);
3699 /* Read the suffixes to choose a data type. */
3704 error ("more than one `f' in numeric constant");
3710 error ("more than one `l' in numeric constant");
3716 error ("more than one `i' or `j' in numeric constant");
3718 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3729 if (p >= token_buffer + maxtoken - 3)
3730 p = extend_token_buffer (p);
3736 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3737 tells the desired precision of the binary result
3738 of decimal-to-binary conversion. */
3743 error ("both `f' and `l' in floating constant");
3745 type = float_type_node;
3746 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3747 /* A diagnostic is required here by some ANSI C testsuites.
3748 This is not pedwarn, become some people don't want
3749 an error for this. */
3750 if (REAL_VALUE_ISINF (value) && pedantic)
3751 warning ("floating point number exceeds range of `float'");
3755 type = long_double_type_node;
3756 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3757 if (REAL_VALUE_ISINF (value) && pedantic)
3758 warning ("floating point number exceeds range of `long double'");
3762 value = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
3763 if (REAL_VALUE_ISINF (value) && pedantic)
3764 warning ("floating point number exceeds range of `double'");
3767 set_float_handler (NULL_PTR);
3770 if (errno == ERANGE && pedantic)
3772 /* ERANGE is also reported for underflow,
3773 so test the value to distinguish overflow from that. */
3774 if (REAL_VALUES_LESS (dconst1, value)
3775 || REAL_VALUES_LESS (value, dconstm1))
3777 pedwarn ("floating point number exceeds range of `%s'",
3778 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type)));
3784 /* If the result is not a number, assume it must have been
3785 due to some error message above, so silently convert
3787 if (REAL_VALUE_ISNAN (value))
3790 /* Create a node with determined type and value. */
3792 yylval.ttype = build_complex (NULL_TREE,
3793 cp_convert (type, integer_zero_node),
3794 build_real (type, value));
3796 yylval.ttype = build_real (type, value);
3801 HOST_WIDE_INT high, low;
3802 int spec_unsigned = 0;
3804 int spec_long_long = 0;
3810 if (c == 'u' || c == 'U')
3813 error ("two `u's in integer constant");
3816 else if (c == 'l' || c == 'L')
3821 error ("three `l's in integer constant");
3823 pedwarn ("ANSI C++ forbids long long integer constants");
3828 else if (c == 'i' || c == 'j' || c == 'I' || c == 'J')
3831 error ("more than one `i' or `j' in numeric constant");
3833 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3838 if (p >= token_buffer + maxtoken - 3)
3839 p = extend_token_buffer (p);
3844 /* If the constant is not long long and it won't fit in an
3845 unsigned long, or if the constant is long long and won't fit
3846 in an unsigned long long, then warn that the constant is out
3849 /* ??? This assumes that long long and long integer types are
3850 a multiple of 8 bits. This better than the original code
3851 though which assumed that long was exactly 32 bits and long
3852 long was exactly 64 bits. */
3855 bytes = TYPE_PRECISION (long_long_integer_type_node) / 8;
3857 bytes = TYPE_PRECISION (long_integer_type_node) / 8;
3860 for (i = bytes; i < TOTAL_PARTS; i++)
3864 pedwarn ("integer constant out of range");
3866 /* This is simplified by the fact that our constant
3867 is always positive. */
3870 for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR; i++)
3872 high |= ((HOST_WIDE_INT) parts[i + (HOST_BITS_PER_WIDE_INT
3873 / HOST_BITS_PER_CHAR)]
3874 << (i * HOST_BITS_PER_CHAR));
3875 low |= (HOST_WIDE_INT) parts[i] << (i * HOST_BITS_PER_CHAR);
3879 yylval.ttype = build_int_2 (low, high);
3880 TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
3882 /* Calculate the ANSI type. */
3883 if (!spec_long && !spec_unsigned
3884 && int_fits_type_p (yylval.ttype, integer_type_node))
3885 type = integer_type_node;
3886 else if (!spec_long && (base != 10 || spec_unsigned)
3887 && int_fits_type_p (yylval.ttype, unsigned_type_node))
3888 /* Nondecimal constants try unsigned even in traditional C. */
3889 type = unsigned_type_node;
3890 else if (!spec_unsigned && !spec_long_long
3891 && int_fits_type_p (yylval.ttype, long_integer_type_node))
3892 type = long_integer_type_node;
3893 else if (! spec_long_long)
3894 type = long_unsigned_type_node;
3895 else if (! spec_unsigned
3896 /* Verify value does not overflow into sign bit. */
3897 && TREE_INT_CST_HIGH (yylval.ttype) >= 0
3898 && int_fits_type_p (yylval.ttype,
3899 long_long_integer_type_node))
3900 type = long_long_integer_type_node;
3902 type = long_long_unsigned_type_node;
3904 if (!int_fits_type_p (yylval.ttype, type) && !warn)
3905 pedwarn ("integer constant out of range");
3907 if (base == 10 && ! spec_unsigned && TREE_UNSIGNED (type))
3908 warning ("decimal integer constant is so large that it is unsigned");
3912 if (TYPE_PRECISION (type)
3913 <= TYPE_PRECISION (integer_type_node))
3915 = build_complex (NULL_TREE, integer_zero_node,
3916 cp_convert (integer_type_node,
3919 error ("complex integer constant is too wide for `__complex int'");
3922 TREE_TYPE (yylval.ttype) = type;
3928 value = CONSTANT; break;
3934 register int result = 0;
3935 register int num_chars = 0;
3937 unsigned width = TYPE_PRECISION (char_type_node);
3939 #ifdef MULTIBYTE_CHARS
3940 int longest_char = local_mb_cur_max ();
3941 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
3944 max_chars = TYPE_PRECISION (integer_type_node) / width;
3946 width = WCHAR_TYPE_SIZE;
3953 if (c == '\'' || c == EOF)
3960 c = readescape (&ignore);
3963 if (width < HOST_BITS_PER_INT
3964 && (unsigned) c >= (1 << width))
3965 pedwarn ("escape sequence out of range for character");
3966 #ifdef MAP_CHARACTER
3968 c = MAP_CHARACTER (c);
3974 pedwarn ("ANSI C forbids newline in character constant");
3979 #ifdef MULTIBYTE_CHARS
3983 for (i = 1; i <= longest_char; ++i)
3985 if (i > maxtoken - 4)
3986 extend_token_buffer (token_buffer);
3988 token_buffer[i] = c;
3989 char_len = local_mbtowc (& wc,
3998 /* mbtowc sometimes needs an extra char before accepting */
4003 /* Merge character into result; ignore excess chars. */
4004 for (i = 1; i <= char_len; ++i)
4008 if (width < HOST_BITS_PER_INT)
4009 result = (result << width)
4011 & ((1 << width) - 1));
4013 result = token_buffer[i];
4015 num_chars += char_len;
4023 warning ("Ignoring invalid multibyte character");
4026 #ifdef MAP_CHARACTER
4028 c = MAP_CHARACTER (c);
4031 #else /* ! MULTIBYTE_CHARS */
4032 #ifdef MAP_CHARACTER
4033 c = MAP_CHARACTER (c);
4035 #endif /* ! MULTIBYTE_CHARS */
4040 if (chars_seen == 1) /* only keep the first one */
4045 /* Merge character into result; ignore excess chars. */
4047 if (num_chars < max_chars + 1)
4049 if (width < HOST_BITS_PER_INT)
4050 result = (result << width) | (c & ((1 << width) - 1));
4057 error ("malformatted character constant");
4058 else if (chars_seen == 0)
4059 error ("empty character constant");
4060 else if (num_chars > max_chars)
4062 num_chars = max_chars;
4063 error ("character constant too long");
4065 else if (chars_seen != 1 && warn_multichar)
4066 warning ("multi-character character constant");
4068 /* If char type is signed, sign-extend the constant. */
4071 int num_bits = num_chars * width;
4073 /* We already got an error; avoid invalid shift. */
4074 yylval.ttype = build_int_2 (0, 0);
4075 else if (TREE_UNSIGNED (char_type_node)
4076 || ((result >> (num_bits - 1)) & 1) == 0)
4078 = build_int_2 (result & (~(unsigned HOST_WIDE_INT) 0
4079 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4083 = build_int_2 (result | ~(~(unsigned HOST_WIDE_INT) 0
4084 >> (HOST_BITS_PER_WIDE_INT - num_bits)),
4086 if (chars_seen <= 1)
4087 TREE_TYPE (yylval.ttype) = char_type_node;
4089 TREE_TYPE (yylval.ttype) = integer_type_node;
4093 yylval.ttype = build_int_2 (result, 0);
4094 TREE_TYPE (yylval.ttype) = wchar_type_node;
4105 unsigned width = wide_flag ? WCHAR_TYPE_SIZE
4106 : TYPE_PRECISION (char_type_node);
4107 #ifdef MULTIBYTE_CHARS
4108 int longest_char = local_mb_cur_max ();
4109 (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
4113 p = token_buffer + 1;
4115 while (c != '"' && c >= 0)
4117 /* ignore_escape_flag is set for reading the filename in #line. */
4118 if (!ignore_escape_flag && c == '\\')
4121 c = readescape (&ignore);
4124 if (width < HOST_BITS_PER_INT
4125 && (unsigned) c >= (1 << width))
4126 warning ("escape sequence out of range for character");
4131 pedwarn ("ANSI C++ forbids newline in string constant");
4136 #ifdef MULTIBYTE_CHARS
4140 for (i = 0; i < longest_char; ++i)
4142 if (p + i >= token_buffer + maxtoken)
4143 p = extend_token_buffer (p);
4146 char_len = local_mbtowc (& wc, p, i + 1);
4152 warning ("Ignoring invalid multibyte character");
4155 /* mbtowc sometimes needs an extra char before accepting */
4168 #endif /* MULTIBYTE_CHARS */
4171 /* Add this single character into the buffer either as a wchar_t
4172 or as a single byte. */
4175 unsigned width = TYPE_PRECISION (char_type_node);
4176 unsigned bytemask = (1 << width) - 1;
4179 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4180 p = extend_token_buffer (p);
4182 for (byte = 0; byte < WCHAR_BYTES; ++byte)
4185 if (byte >= sizeof (c))
4188 value = (c >> (byte * width)) & bytemask;
4189 if (BYTES_BIG_ENDIAN)
4190 p[WCHAR_BYTES - byte - 1] = value;
4198 if (p >= token_buffer + maxtoken)
4199 p = extend_token_buffer (p);
4206 error ("Unterminated string");
4211 /* Terminate the string value, either with a single byte zero
4212 or with a wide zero. */
4215 if (p + WCHAR_BYTES > token_buffer + maxtoken)
4216 p = extend_token_buffer (p);
4217 bzero (p, WCHAR_BYTES);
4222 if (p >= token_buffer + maxtoken)
4223 p = extend_token_buffer (p);
4227 /* We have read the entire constant.
4228 Construct a STRING_CST for the result. */
4230 if (processing_template_decl)
4231 push_obstacks (&permanent_obstack, &permanent_obstack);
4232 yylval.ttype = build_string (p - (token_buffer + 1), token_buffer + 1);
4233 if (processing_template_decl)
4237 TREE_TYPE (yylval.ttype) = wchar_array_type_node;
4239 TREE_TYPE (yylval.ttype) = char_array_type_node;
4241 value = STRING; break;
4264 yylval.code = PLUS_EXPR; break;
4266 yylval.code = MINUS_EXPR; break;
4268 yylval.code = BIT_AND_EXPR; break;
4270 yylval.code = BIT_IOR_EXPR; break;
4272 yylval.code = MULT_EXPR; break;
4274 yylval.code = TRUNC_DIV_EXPR; break;
4276 yylval.code = TRUNC_MOD_EXPR; break;
4278 yylval.code = BIT_XOR_EXPR; break;
4280 yylval.code = LSHIFT_EXPR; break;
4282 yylval.code = RSHIFT_EXPR; break;
4284 yylval.code = LT_EXPR; break;
4286 yylval.code = GT_EXPR; break;
4289 token_buffer[1] = c1 = getch ();
4290 token_buffer[2] = 0;
4297 value = ARITHCOMPARE; yylval.code = LE_EXPR; goto done;
4299 value = ARITHCOMPARE; yylval.code = GE_EXPR; goto done;
4301 value = EQCOMPARE; yylval.code = NE_EXPR; goto done;
4303 value = EQCOMPARE; yylval.code = EQ_EXPR; goto done;
4305 value = ASSIGN; goto done;
4311 value = PLUSPLUS; goto done;
4313 value = MINUSMINUS; goto done;
4315 value = ANDAND; goto done;
4317 value = OROR; goto done;
4325 else if ((c == '-') && (c1 == '>'))
4327 nextchar = getch ();
4328 if (nextchar == '*')
4331 value = POINTSAT_STAR;
4337 else if (c1 == '?' && (c == '<' || c == '>'))
4339 token_buffer[3] = 0;
4342 yylval.code = (c == '<' ? MIN_EXPR : MAX_EXPR);
4345 /* <?= or >?= expression. */
4346 token_buffer[2] = c1;
4355 pedwarn ("use of `operator %s' is not standard C++",
4360 else if (c == '<' && c1 == '%')
4361 { value = '{'; goto done; }
4362 else if (c == '<' && c1 == ':')
4363 { value = '['; goto done; }
4364 else if (c == '%' && c1 == '>')
4365 { value = '}'; goto done; }
4366 else if (c == '%' && c1 == ':')
4367 { value = '#'; goto done; }
4370 token_buffer[1] = 0;
4380 token_buffer[1] = ':';
4381 token_buffer[2] = '\0';
4398 /* Don't make yyparse think this is eof. */
4403 /* try, weakly, to handle casts to pointers to functions. */
4404 nextchar = skip_white_space (getch ());
4405 if (nextchar == '*')
4407 int next_c = skip_white_space (getch ());
4411 yylval.ttype = build1 (INDIRECT_REF, 0, 0);
4412 value = PAREN_STAR_PAREN;
4420 else if (nextchar == ')')
4423 yylval.ttype = NULL_TREE;
4434 /* yylloc.last_line = lineno; */
4435 #ifdef GATHER_STATISTICS
4436 #ifdef REDUCE_LENGTH
4437 token_count[value] += 1;
4448 return !!is_reserved_word (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));
4451 #ifdef GATHER_STATISTICS
4452 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4453 need to be brought into here, unless this were actually put into a header
4455 /* Statistics-gathering stuff. */
4476 extern int tree_node_counts[];
4477 extern int tree_node_sizes[];
4480 /* Place to save freed lang_decls which were allocated on the
4481 permanent_obstack. @@ Not currently used. */
4482 tree free_lang_decl_chain;
4485 build_lang_decl (code, name, type)
4486 enum tree_code code;
4490 register tree t = build_decl (code, name, type);
4491 struct obstack *obstack = current_obstack;
4492 register int i = sizeof (struct lang_decl) / sizeof (int);
4495 if (! TREE_PERMANENT (t))
4496 obstack = saveable_obstack;
4498 /* Could be that saveable is permanent and current is not. */
4499 obstack = &permanent_obstack;
4501 if (free_lang_decl_chain && obstack == &permanent_obstack)
4503 pi = (int *)free_lang_decl_chain;
4504 free_lang_decl_chain = TREE_CHAIN (free_lang_decl_chain);
4507 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl));
4512 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4513 LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4514 = obstack == &permanent_obstack;
4515 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl *) pi)
4516 == TREE_PERMANENT (t), 234);
4517 DECL_MAIN_VARIANT (t) = t;
4518 if (current_lang_name == lang_name_cplusplus)
4519 DECL_LANGUAGE (t) = lang_cplusplus;
4520 else if (current_lang_name == lang_name_c)
4521 DECL_LANGUAGE (t) = lang_c;
4522 else if (current_lang_name == lang_name_java)
4523 DECL_LANGUAGE (t) = lang_java;
4524 else my_friendly_abort (64);
4526 #if 0 /* not yet, should get fixed properly later */
4527 if (code == TYPE_DECL)
4530 id = get_identifier (build_overload_name (type, 1, 1));
4531 DECL_ASSEMBLER_NAME (t) = id;
4535 #ifdef GATHER_STATISTICS
4536 tree_node_counts[(int)lang_decl] += 1;
4537 tree_node_sizes[(int)lang_decl] += sizeof (struct lang_decl);
4544 build_lang_field_decl (code, name, type)
4545 enum tree_code code;
4549 extern struct obstack *current_obstack, *saveable_obstack;
4550 register tree t = build_decl (code, name, type);
4551 struct obstack *obstack = current_obstack;
4552 register int i = sizeof (struct lang_decl_flags) / sizeof (int);
4554 #if 0 /* not yet, should get fixed properly later */
4556 if (code == TYPE_DECL)
4559 id = get_identifier (build_overload_name (type, 1, 1));
4560 DECL_ASSEMBLER_NAME (t) = id;
4564 if (! TREE_PERMANENT (t))
4565 obstack = saveable_obstack;
4567 my_friendly_assert (obstack == &permanent_obstack, 235);
4569 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_decl_flags));
4573 DECL_LANG_SPECIFIC (t) = (struct lang_decl *) pi;
4578 copy_lang_decl (node)
4584 if (! DECL_LANG_SPECIFIC (node))
4587 if (TREE_CODE (node) == FIELD_DECL)
4588 size = sizeof (struct lang_decl_flags);
4590 size = sizeof (struct lang_decl);
4591 pi = (int *)obstack_alloc (&permanent_obstack, size);
4592 bcopy ((char *)DECL_LANG_SPECIFIC (node), (char *)pi, size);
4593 DECL_LANG_SPECIFIC (node) = (struct lang_decl *)pi;
4597 make_lang_type (code)
4598 enum tree_code code;
4600 extern struct obstack *current_obstack, *saveable_obstack;
4601 register tree t = make_node (code);
4602 struct obstack *obstack = current_obstack;
4603 register int i = sizeof (struct lang_type) / sizeof (int);
4606 /* Set up some flags that give proper default behavior. */
4607 IS_AGGR_TYPE (t) = 1;
4609 if (! TREE_PERMANENT (t))
4610 obstack = saveable_obstack;
4612 my_friendly_assert (obstack == &permanent_obstack, 236);
4614 pi = (int *) obstack_alloc (obstack, sizeof (struct lang_type));
4618 TYPE_LANG_SPECIFIC (t) = (struct lang_type *) pi;
4619 CLASSTYPE_AS_LIST (t) = build_expr_list (NULL_TREE, t);
4620 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown);
4621 CLASSTYPE_INTERFACE_ONLY (t) = interface_only;
4622 TYPE_BINFO (t) = make_binfo (integer_zero_node, t, NULL_TREE, NULL_TREE,
4624 CLASSTYPE_BINFO_AS_LIST (t) = build_tree_list (NULL_TREE, TYPE_BINFO (t));
4626 /* Make sure this is laid out, for ease of use later.
4627 In the presence of parse errors, the normal was of assuring
4628 this might not ever get executed, so we lay it out *immediately*. */
4629 build_pointer_type (t);
4631 #ifdef GATHER_STATISTICS
4632 tree_node_counts[(int)lang_type] += 1;
4633 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
4640 dump_time_statistics ()
4642 register tree prev = 0, decl, next;
4643 int this_time = my_get_run_time ();
4644 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time))
4645 += this_time - body_time;
4647 fprintf (stderr, "\n******\n");
4648 print_time ("header files (total)", header_time);
4649 print_time ("main file (total)", this_time - body_time);
4650 fprintf (stderr, "ratio = %g : 1\n",
4651 (double)header_time / (double)(this_time - body_time));
4652 fprintf (stderr, "\n******\n");
4654 for (decl = filename_times; decl; decl = next)
4656 next = IDENTIFIER_GLOBAL_VALUE (decl);
4657 SET_IDENTIFIER_GLOBAL_VALUE (decl, prev);
4661 for (decl = prev; decl; decl = IDENTIFIER_GLOBAL_VALUE (decl))
4662 print_time (IDENTIFIER_POINTER (decl),
4663 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl)));
4667 compiler_error (s, v, v2)
4669 HOST_WIDE_INT v, v2; /* @@also used as pointer */
4672 sprintf (buf, s, v, v2);
4673 error_with_file_and_line (input_filename, lineno, "%s (compiler error)", buf);
4680 extern int end_of_file;
4683 strcpy (buf, string);
4685 /* We can't print string and character constants well
4686 because the token_buffer contains the result of processing escapes. */
4688 strcat (buf, input_redirected ()
4689 ? " at end of saved text"
4690 : " at end of input");
4691 else if (token_buffer[0] == 0)
4692 strcat (buf, " at null character");
4693 else if (token_buffer[0] == '"')
4694 strcat (buf, " before string constant");
4695 else if (token_buffer[0] == '\'')
4696 strcat (buf, " before character constant");
4697 else if (token_buffer[0] < 040 || (unsigned char) token_buffer[0] >= 0177)
4698 sprintf (buf + strlen (buf), " before character 0%o",
4699 (unsigned char) token_buffer[0]);
4701 strcat (buf, " before `%s'");
4703 error (buf, token_buffer);
4707 handle_cp_pragma (pname)
4712 if (! strcmp (pname, "vtable"))
4714 extern tree pending_vtables;
4716 /* More follows: it must be a string constant (class name). */
4717 token = real_yylex ();
4718 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4720 error ("invalid #pragma vtable");
4724 if (write_virtuals != 2)
4726 warning ("use `+e2' option to enable #pragma vtable");
4730 = perm_tree_cons (NULL_TREE,
4731 get_identifier (TREE_STRING_POINTER (yylval.ttype)),
4733 token = real_yylex ();
4734 if (token != END_OF_LINE)
4735 warning ("trailing characters ignored");
4738 else if (! strcmp (pname, "unit"))
4740 /* More follows: it must be a string constant (unit name). */
4741 token = real_yylex ();
4742 if (token != STRING || TREE_CODE (yylval.ttype) != STRING_CST)
4744 error ("invalid #pragma unit");
4747 token = real_yylex ();
4748 if (token != END_OF_LINE)
4749 warning ("trailing characters ignored");
4752 else if (! strcmp (pname, "interface"))
4754 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4755 char *main_filename = input_filename;
4757 main_filename = file_name_nondirectory (main_filename);
4759 token = real_yylex ();
4761 if (token != END_OF_LINE)
4764 || TREE_CODE (yylval.ttype) != STRING_CST)
4766 error ("invalid `#pragma interface'");
4769 main_filename = TREE_STRING_POINTER (yylval.ttype);
4770 token = real_yylex ();
4773 if (token != END_OF_LINE)
4774 warning ("garbage after `#pragma interface' ignored");
4776 #ifndef NO_LINKAGE_HEURISTICS
4779 if (impl_file_chain == 0)
4781 /* If this is zero at this point, then we are
4782 auto-implementing. */
4783 if (main_input_filename == 0)
4784 main_input_filename = input_filename;
4786 #ifdef AUTO_IMPLEMENT
4787 filename = file_name_nondirectory (main_input_filename);
4788 fi = get_time_identifier (filename);
4789 fi = IDENTIFIER_CLASS_VALUE (fi);
4790 TREE_INT_CST_LOW (fi) = 0;
4791 TREE_INT_CST_HIGH (fi) = 1;
4793 impl_file_chain = (struct impl_files *)permalloc (sizeof (struct impl_files));
4794 impl_file_chain->filename = filename;
4795 impl_file_chain->next = 0;
4799 interface_only = interface_strcmp (main_filename);
4800 interface_unknown = 0;
4801 TREE_INT_CST_LOW (fileinfo) = interface_only;
4802 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4803 #endif /* NO_LINKAGE_HEURISTICS */
4807 else if (! strcmp (pname, "implementation"))
4809 tree fileinfo = IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename));
4810 char *main_filename = main_input_filename ? main_input_filename : input_filename;
4812 main_filename = file_name_nondirectory (main_filename);
4813 token = real_yylex ();
4814 if (token != END_OF_LINE)
4817 || TREE_CODE (yylval.ttype) != STRING_CST)
4819 error ("invalid `#pragma implementation'");
4822 main_filename = TREE_STRING_POINTER (yylval.ttype);
4823 token = real_yylex ();
4826 if (token != END_OF_LINE)
4827 warning ("garbage after `#pragma implementation' ignored");
4829 #ifndef NO_LINKAGE_HEURISTICS
4830 if (write_virtuals == 3)
4832 struct impl_files *ifiles = impl_file_chain;
4835 if (! strcmp (ifiles->filename, main_filename))
4837 ifiles = ifiles->next;
4841 ifiles = (struct impl_files*) permalloc (sizeof (struct impl_files));
4842 ifiles->filename = main_filename;
4843 ifiles->next = impl_file_chain;
4844 impl_file_chain = ifiles;
4847 else if ((main_input_filename != 0
4848 && ! strcmp (main_input_filename, input_filename))
4849 || ! strcmp (input_filename, main_filename))
4852 if (impl_file_chain == 0)
4854 impl_file_chain = (struct impl_files*) permalloc (sizeof (struct impl_files));
4855 impl_file_chain->filename = main_filename;
4856 impl_file_chain->next = 0;
4860 error ("`#pragma implementation' can only appear at top-level");
4863 /* We make this non-zero so that we infer decl linkage
4864 in the impl file only for variables first declared
4865 in the interface file. */
4866 interface_unknown = 1;
4868 /* We make this zero so that templates in the impl
4869 file will be emitted properly. */
4870 interface_unknown = 0;
4872 TREE_INT_CST_LOW (fileinfo) = interface_only;
4873 TREE_INT_CST_HIGH (fileinfo) = interface_unknown;
4874 #endif /* NO_LINKAGE_HEURISTICS */
4882 #ifdef HANDLE_SYSV_PRAGMA
4884 /* Handle a #pragma directive. INPUT is the current input stream,
4885 and C is a character to reread. Processes the entire input line
4886 and returns a character for the caller to reread: either \n or EOF. */
4888 /* This function has to be in this file, in order to get at
4892 handle_sysv_pragma (token)
4903 handle_pragma_token ("ignored", yylval.ttype);
4906 handle_pragma_token ("(", NULL_TREE);
4909 handle_pragma_token (")", NULL_TREE);
4912 handle_pragma_token (",", NULL_TREE);
4915 handle_pragma_token ("=", NULL_TREE);
4918 handle_pragma_token ("(", NULL_TREE);
4919 handle_pragma_token (")", NULL_TREE);
4923 handle_pragma_token (NULL_PTR, NULL_TREE);
4926 token = real_yylex ();
4929 #endif /* HANDLE_SYSV_PRAGMA */