1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-98, 1999 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is the lexical analyzer for GNU C++. */
25 /* Cause the `yydebug' variable to be defined. */
42 #ifdef MULTIBYTE_CHARS
47 #define obstack_chunk_alloc xmalloc
48 #define obstack_chunk_free free
51 #define DIR_SEPARATOR '/'
54 extern struct obstack permanent_obstack
;
55 extern struct obstack
*current_obstack
, *saveable_obstack
;
57 extern void yyprint
PROTO((FILE *, int, YYSTYPE
));
59 static tree get_time_identifier
PROTO((const char *));
60 static int check_newline
PROTO((void));
61 static int whitespace_cr
PROTO((int));
62 static int skip_white_space
PROTO((int));
63 static void finish_defarg
PROTO((void));
64 static int my_get_run_time
PROTO((void));
65 static int interface_strcmp
PROTO((const char *));
66 static int readescape
PROTO((int *));
67 static char *extend_token_buffer
PROTO((const char *));
68 static void consume_string
PROTO((struct obstack
*, int));
69 static void feed_defarg
PROTO((tree
, tree
));
70 static void store_pending_inline
PROTO((tree
, struct pending_inline
*));
71 static void reinit_parse_for_expr
PROTO((struct obstack
*));
72 static int *init_cpp_parse
PROTO((void));
73 static void cp_pragma_interface
PROTO((char *));
74 static void cp_pragma_implementation
PROTO ((char *));
75 static int handle_cp_pragma
PROTO((const char *));
76 #ifdef HANDLE_GENERIC_PRAGMAS
77 static int handle_generic_pragma
PROTO((int));
79 #ifdef GATHER_STATISTICS
81 static int reduce_cmp
PROTO((int *, int *));
82 static int token_cmp
PROTO((int *, int *));
85 static void begin_definition_of_inclass_inline
PROTO((struct pending_inline
*));
86 static void parse_float
PROTO((PTR
));
87 static int is_global
PROTO((tree
));
88 static void init_filename_times
PROTO((void));
89 static void extend_token_buffer_to
PROTO((int));
91 static int pragma_getc
PROTO((void));
92 static void pragma_ungetc
PROTO((int));
94 static int read_line_number
PROTO((int *));
95 static int token_getch
PROTO ((void));
96 static void token_put_back
PROTO ((int));
97 static void mark_impl_file_chain
PROTO ((void *));
99 /* Given a file name X, return the nondirectory portion.
100 Keep in mind that X can be computed more than once. */
102 file_name_nondirectory (x
)
105 char *tmp
= (char *) rindex (x
, '/');
106 if (DIR_SEPARATOR
!= '/' && ! tmp
)
107 tmp
= (char *) rindex (x
, DIR_SEPARATOR
);
109 return (char *) (tmp
+ 1);
114 /* This obstack is needed to hold text. It is not safe to use
115 TOKEN_BUFFER because `check_newline' calls `yylex'. */
116 struct obstack inline_text_obstack
;
117 char *inline_text_firstobj
;
121 extern cpp_reader parse_in
;
122 extern cpp_options parse_options
;
123 extern unsigned char *yy_cur
, *yy_lim
;
124 extern enum cpp_token cpp_token
;
132 /* Pending language change.
133 Positive is push count, negative is pop count. */
134 int pending_lang_change
= 0;
136 /* Wrap the current header file in extern "C". */
137 static int c_header_level
= 0;
139 extern int first_token
;
140 extern struct obstack token_obstack
;
142 /* ??? Don't really know where this goes yet. */
145 /* Holds translations from TREE_CODEs to operator name strings,
146 i.e., opname_tab[PLUS_EXPR] == "+". */
147 const char **opname_tab
;
148 const char **assignop_tab
;
150 extern int yychar
; /* the lookahead symbol */
151 extern YYSTYPE yylval
; /* the semantic value of the */
152 /* lookahead symbol */
155 YYLTYPE yylloc
; /* location data for the lookahead */
160 /* the declaration found for the last IDENTIFIER token read in.
161 yylex must look this up to detect typedefs, which get token type TYPENAME,
162 so it is left around in case the identifier is not a typedef but is
163 used in a context which makes it a reference to a variable. */
166 /* The elements of `ridpointers' are identifier nodes
167 for the reserved type names and storage classes.
168 It is indexed by a RID_... value. */
169 tree ridpointers
[(int) RID_MAX
];
171 /* We may keep statistics about how long which files took to compile. */
172 static int header_time
, body_time
;
173 static tree filename_times
;
174 static tree this_filename_time
;
176 /* Array for holding counts of the numbers of tokens seen. */
177 extern int *token_count
;
179 /* When we see a default argument in a method declaration, we snarf it as
180 text using snarf_defarg. When we get up to namespace scope, we then go
181 through and parse all of them using do_pending_defargs. Since yacc
182 parsers are not reentrant, we retain defargs state in these two
183 variables so that subsequent calls to do_pending_defargs can resume
184 where the previous call left off. */
186 static tree defarg_fns
;
187 static tree defarg_parm
;
189 /* Functions and data structures for #pragma interface.
191 `#pragma implementation' means that the main file being compiled
192 is considered to implement (provide) the classes that appear in
193 its main body. I.e., if this is file "foo.cc", and class `bar'
194 is defined in "foo.cc", then we say that "foo.cc implements bar".
196 All main input files "implement" themselves automagically.
198 `#pragma interface' means that unless this file (of the form "foo.h"
199 is not presently being included by file "foo.cc", the
200 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
201 of the vtables nor any of the inline functions defined in foo.h
204 There are cases when we want to link files such as "defs.h" and
205 "main.cc". In this case, we give "defs.h" a `#pragma interface',
206 and "main.cc" has `#pragma implementation "defs.h"'. */
211 struct impl_files
*next
;
214 static struct impl_files
*impl_file_chain
;
216 /* The string used to represent the filename of internally generated
217 tree nodes. The variable, which is dynamically allocated, should
218 be used; the macro is only used to initialize it. */
219 static char *internal_filename
;
220 #define INTERNAL_FILENAME ("<internal>")
222 /* Return something to represent absolute declarators containing a *.
223 TARGET is the absolute declarator that the * contains.
224 CV_QUALIFIERS is a list of modifiers such as const or volatile
225 to apply to the pointer type, represented as identifiers.
227 We return an INDIRECT_REF whose "contents" are TARGET
228 and whose type is the modifier list. */
231 make_pointer_declarator (cv_qualifiers
, target
)
232 tree cv_qualifiers
, target
;
234 if (target
&& TREE_CODE (target
) == IDENTIFIER_NODE
235 && ANON_AGGRNAME_P (target
))
236 error ("type name expected before `*'");
237 target
= build_parse_node (INDIRECT_REF
, target
);
238 TREE_TYPE (target
) = cv_qualifiers
;
242 /* Return something to represent absolute declarators containing a &.
243 TARGET is the absolute declarator that the & contains.
244 CV_QUALIFIERS is a list of modifiers such as const or volatile
245 to apply to the reference type, represented as identifiers.
247 We return an ADDR_EXPR whose "contents" are TARGET
248 and whose type is the modifier list. */
251 make_reference_declarator (cv_qualifiers
, target
)
252 tree cv_qualifiers
, target
;
256 if (TREE_CODE (target
) == ADDR_EXPR
)
258 error ("cannot declare references to references");
261 if (TREE_CODE (target
) == INDIRECT_REF
)
263 error ("cannot declare pointers to references");
266 if (TREE_CODE (target
) == IDENTIFIER_NODE
&& ANON_AGGRNAME_P (target
))
267 error ("type name expected before `&'");
269 target
= build_parse_node (ADDR_EXPR
, target
);
270 TREE_TYPE (target
) = cv_qualifiers
;
275 make_call_declarator (target
, parms
, cv_qualifiers
, exception_specification
)
276 tree target
, parms
, cv_qualifiers
, exception_specification
;
278 target
= build_parse_node (CALL_EXPR
, target
,
279 /* Both build_parse_node and
280 decl_tree_cons build on the
281 temp_decl_obstack. */
282 decl_tree_cons (parms
, cv_qualifiers
, NULL_TREE
),
283 /* The third operand is really RTL. We
284 shouldn't put anything there. */
286 CALL_DECLARATOR_EXCEPTION_SPEC (target
) = exception_specification
;
291 set_quals_and_spec (call_declarator
, cv_qualifiers
, exception_specification
)
292 tree call_declarator
, cv_qualifiers
, exception_specification
;
294 CALL_DECLARATOR_QUALS (call_declarator
) = cv_qualifiers
;
295 CALL_DECLARATOR_EXCEPTION_SPEC (call_declarator
) = exception_specification
;
298 /* Build names and nodes for overloaded operators. */
300 tree ansi_opname
[LAST_CPLUS_TREE_CODE
];
301 tree ansi_assopname
[LAST_CPLUS_TREE_CODE
];
304 operator_name_string (name
)
307 char *opname
= IDENTIFIER_POINTER (name
) + 2;
311 /* Works for builtin and user defined types. */
312 if (IDENTIFIER_GLOBAL_VALUE (name
)
313 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name
)) == TYPE_DECL
)
314 return IDENTIFIER_POINTER (name
);
316 if (opname
[0] == 'a' && opname
[2] != '\0' && opname
[2] != '_')
320 opname_table
= ansi_assopname
;
325 opname_table
= ansi_opname
;
328 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
330 if (opname
[0] == IDENTIFIER_POINTER (opname_table
[i
])[2+assign
]
331 && opname
[1] == IDENTIFIER_POINTER (opname_table
[i
])[3+assign
])
335 if (i
== LAST_CPLUS_TREE_CODE
)
336 return "<invalid operator>";
339 return assignop_tab
[i
];
341 return opname_tab
[i
];
344 int interface_only
; /* whether or not current file is only for
345 interface definitions. */
346 int interface_unknown
; /* whether or not we know this class
347 to behave according to #pragma interface. */
349 /* lexical analyzer */
351 #undef WCHAR_TYPE_SIZE
352 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
354 /* Number of bytes in a wide character. */
355 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
357 static int maxtoken
; /* Current nominal length of token buffer. */
358 char *token_buffer
; /* Pointer to token buffer.
359 Actual allocated length is maxtoken + 2. */
361 static int indent_level
; /* Number of { minus number of }. */
366 /* Nonzero tells yylex to ignore \ in string constants. */
367 static int ignore_escape_flag
;
370 get_time_identifier (name
)
373 tree time_identifier
;
374 int len
= strlen (name
);
375 char *buf
= (char *) alloca (len
+ 6);
376 strcpy (buf
, "file ");
377 bcopy (name
, buf
+5, len
);
379 time_identifier
= get_identifier (buf
);
380 if (TIME_IDENTIFIER_TIME (time_identifier
) == NULL_TREE
)
382 push_permanent_obstack ();
383 TIME_IDENTIFIER_TIME (time_identifier
) = build_int_2 (0, 0);
384 TIME_IDENTIFIER_FILEINFO (time_identifier
)
385 = build_int_2 (0, 1);
386 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier
, filename_times
);
387 filename_times
= time_identifier
;
390 return time_identifier
;
399 int old_quiet_flag
= quiet_flag
;
402 this_time
= get_run_time ();
403 quiet_flag
= old_quiet_flag
;
407 /* Table indexed by tree code giving a string containing a character
408 classifying the tree code. Possibilities are
409 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
411 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
413 char cplus_tree_code_type
[] = {
415 #include "cp-tree.def"
419 /* Table indexed by tree code giving number of expression
420 operands beyond the fixed part of the node structure.
421 Not used for types or decls. */
423 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
425 int cplus_tree_code_length
[] = {
427 #include "cp-tree.def"
431 /* Names of tree components.
432 Used for printing out the tree and error messages. */
433 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
435 const char *cplus_tree_code_name
[] = {
437 #include "cp-tree.def"
441 /* toplev.c needs to call these. */
447 cpp_reader_init (&parse_in
);
448 parse_in
.opts
= &parse_options
;
449 cpp_options_init (&parse_options
);
450 parse_options
.cplusplus
= 1;
453 /* Default exceptions on. */
460 /* the beginning of the file is a new line; check for # */
461 /* With luck, we discover the real source file's name from that
462 and put it in input_filename. */
463 put_back (check_newline ());
464 if (flag_gnu_xref
) GNU_xref_begin (input_filename
);
465 init_repo (input_filename
);
471 if (flag_gnu_xref
) GNU_xref_end (errorcount
+sorrycount
);
481 init_filename_times ()
483 this_filename_time
= get_time_identifier ("<top level>");
484 if (flag_detailed_statistics
)
487 body_time
= my_get_run_time ();
488 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time
))
493 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
494 Stuck this hack in to get the files open correctly; this is called
495 in place of init_parse if we are an unexec'd binary. */
499 reinit_lang_specific ()
501 init_filename_times ();
502 reinit_search_statistics ();
509 #ifdef GATHER_STATISTICS
511 reduce_count
= (int *) xcalloc (sizeof (int), (REDUCE_LENGTH
+ 1));
513 token_count
= (int *) xcalloc (sizeof (int), (TOKEN_LENGTH
+ 1));
521 init_parse (filename
)
524 extern int flag_no_gnu_keywords
;
525 extern int flag_operator_names
;
529 #ifdef MULTIBYTE_CHARS
530 /* Change to the native locale for multibyte conversions. */
531 setlocale (LC_CTYPE
, "");
532 literal_codeset
= getenv ("LANG");
536 /* Open input file. */
537 if (filename
== 0 || !strcmp (filename
, "-"))
543 finput
= fopen (filename
, "r");
545 pfatal_with_name (filename
);
547 #ifdef IO_BUFFER_SIZE
548 setvbuf (finput
, (char *) xmalloc (IO_BUFFER_SIZE
), _IOFBF
, IO_BUFFER_SIZE
);
550 #else /* !USE_CPPLIB */
551 parse_in
.show_column
= 1;
552 if (! cpp_start_read (&parse_in
, filename
))
555 if (filename
== 0 || !strcmp (filename
, "-"))
558 /* cpp_start_read always puts at least one line directive into the
559 token buffer. We must arrange to read it out here. */
560 yy_cur
= parse_in
.token_buffer
;
561 yy_lim
= CPP_PWRITTEN (&parse_in
);
562 cpp_token
= CPP_DIRECTIVE
;
564 #endif /* !USE_CPPLIB */
566 /* Initialize the lookahead machinery. */
569 /* Make identifier nodes long enough for the language-specific slots. */
570 set_identifier_size (sizeof (struct lang_identifier
));
571 decl_printable_name
= lang_printable_name
;
574 init_cplus_expand ();
576 memcpy (tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
577 cplus_tree_code_type
,
578 (int)LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
);
579 memcpy (tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
,
580 cplus_tree_code_length
,
581 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
582 memcpy (tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
,
583 cplus_tree_code_name
,
584 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
586 opname_tab
= (const char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
587 memset (opname_tab
, 0, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
588 assignop_tab
= (const char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
589 memset (assignop_tab
, 0, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
591 ansi_opname
[0] = get_identifier ("<invalid operator>");
592 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
594 ansi_opname
[i
] = ansi_opname
[0];
595 ansi_assopname
[i
] = ansi_opname
[0];
598 ansi_opname
[(int) MULT_EXPR
] = get_identifier ("__ml");
599 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MULT_EXPR
]) = 1;
600 ansi_opname
[(int) INDIRECT_REF
] = ansi_opname
[(int) MULT_EXPR
];
601 ansi_assopname
[(int) MULT_EXPR
] = get_identifier ("__aml");
602 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MULT_EXPR
]) = 1;
603 ansi_assopname
[(int) INDIRECT_REF
] = ansi_assopname
[(int) MULT_EXPR
];
604 ansi_opname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__md");
605 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUNC_MOD_EXPR
]) = 1;
606 ansi_assopname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__amd");
607 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) TRUNC_MOD_EXPR
]) = 1;
608 ansi_opname
[(int) CEIL_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
609 ansi_opname
[(int) FLOOR_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
610 ansi_opname
[(int) ROUND_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
611 ansi_opname
[(int) MINUS_EXPR
] = get_identifier ("__mi");
612 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MINUS_EXPR
]) = 1;
613 ansi_opname
[(int) NEGATE_EXPR
] = ansi_opname
[(int) MINUS_EXPR
];
614 ansi_assopname
[(int) MINUS_EXPR
] = get_identifier ("__ami");
615 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MINUS_EXPR
]) = 1;
616 ansi_assopname
[(int) NEGATE_EXPR
] = ansi_assopname
[(int) MINUS_EXPR
];
617 ansi_opname
[(int) RSHIFT_EXPR
] = get_identifier ("__rs");
618 IDENTIFIER_OPNAME_P (ansi_opname
[(int) RSHIFT_EXPR
]) = 1;
619 ansi_assopname
[(int) RSHIFT_EXPR
] = get_identifier ("__ars");
620 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) RSHIFT_EXPR
]) = 1;
621 ansi_opname
[(int) NE_EXPR
] = get_identifier ("__ne");
622 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NE_EXPR
]) = 1;
623 ansi_opname
[(int) GT_EXPR
] = get_identifier ("__gt");
624 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GT_EXPR
]) = 1;
625 ansi_opname
[(int) GE_EXPR
] = get_identifier ("__ge");
626 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GE_EXPR
]) = 1;
627 ansi_opname
[(int) BIT_IOR_EXPR
] = get_identifier ("__or");
628 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_IOR_EXPR
]) = 1;
629 ansi_assopname
[(int) BIT_IOR_EXPR
] = get_identifier ("__aor");
630 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_IOR_EXPR
]) = 1;
631 ansi_opname
[(int) TRUTH_ANDIF_EXPR
] = get_identifier ("__aa");
632 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ANDIF_EXPR
]) = 1;
633 ansi_opname
[(int) TRUTH_NOT_EXPR
] = get_identifier ("__nt");
634 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_NOT_EXPR
]) = 1;
635 ansi_opname
[(int) PREINCREMENT_EXPR
] = get_identifier ("__pp");
636 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREINCREMENT_EXPR
]) = 1;
637 ansi_opname
[(int) POSTINCREMENT_EXPR
] = ansi_opname
[(int) PREINCREMENT_EXPR
];
638 ansi_opname
[(int) MODIFY_EXPR
] = get_identifier ("__as");
639 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MODIFY_EXPR
]) = 1;
640 ansi_assopname
[(int) NOP_EXPR
] = ansi_opname
[(int) MODIFY_EXPR
];
641 ansi_opname
[(int) COMPOUND_EXPR
] = get_identifier ("__cm");
642 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPOUND_EXPR
]) = 1;
643 ansi_opname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__dv");
644 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EXACT_DIV_EXPR
]) = 1;
645 ansi_assopname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__adv");
646 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) EXACT_DIV_EXPR
]) = 1;
647 ansi_opname
[(int) TRUNC_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
648 ansi_opname
[(int) CEIL_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
649 ansi_opname
[(int) FLOOR_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
650 ansi_opname
[(int) ROUND_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
651 ansi_opname
[(int) PLUS_EXPR
] = get_identifier ("__pl");
652 ansi_assopname
[(int) TRUNC_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
653 ansi_assopname
[(int) CEIL_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
654 ansi_assopname
[(int) FLOOR_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
655 ansi_assopname
[(int) ROUND_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
656 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PLUS_EXPR
]) = 1;
657 ansi_assopname
[(int) PLUS_EXPR
] = get_identifier ("__apl");
658 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) PLUS_EXPR
]) = 1;
659 ansi_opname
[(int) CONVERT_EXPR
] = ansi_opname
[(int) PLUS_EXPR
];
660 ansi_assopname
[(int) CONVERT_EXPR
] = ansi_assopname
[(int) PLUS_EXPR
];
661 ansi_opname
[(int) LSHIFT_EXPR
] = get_identifier ("__ls");
662 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LSHIFT_EXPR
]) = 1;
663 ansi_assopname
[(int) LSHIFT_EXPR
] = get_identifier ("__als");
664 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) LSHIFT_EXPR
]) = 1;
665 ansi_opname
[(int) EQ_EXPR
] = get_identifier ("__eq");
666 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EQ_EXPR
]) = 1;
667 ansi_opname
[(int) LT_EXPR
] = get_identifier ("__lt");
668 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LT_EXPR
]) = 1;
669 ansi_opname
[(int) LE_EXPR
] = get_identifier ("__le");
670 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LE_EXPR
]) = 1;
671 ansi_opname
[(int) BIT_AND_EXPR
] = get_identifier ("__ad");
672 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_AND_EXPR
]) = 1;
673 ansi_assopname
[(int) BIT_AND_EXPR
] = get_identifier ("__aad");
674 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_AND_EXPR
]) = 1;
675 ansi_opname
[(int) ADDR_EXPR
] = ansi_opname
[(int) BIT_AND_EXPR
];
676 ansi_assopname
[(int) ADDR_EXPR
] = ansi_assopname
[(int) BIT_AND_EXPR
];
677 ansi_opname
[(int) BIT_XOR_EXPR
] = get_identifier ("__er");
678 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_XOR_EXPR
]) = 1;
679 ansi_assopname
[(int) BIT_XOR_EXPR
] = get_identifier ("__aer");
680 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_XOR_EXPR
]) = 1;
681 ansi_opname
[(int) TRUTH_ORIF_EXPR
] = get_identifier ("__oo");
682 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ORIF_EXPR
]) = 1;
683 ansi_opname
[(int) BIT_NOT_EXPR
] = get_identifier ("__co");
684 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_NOT_EXPR
]) = 1;
685 ansi_opname
[(int) PREDECREMENT_EXPR
] = get_identifier ("__mm");
686 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREDECREMENT_EXPR
]) = 1;
687 ansi_opname
[(int) POSTDECREMENT_EXPR
] = ansi_opname
[(int) PREDECREMENT_EXPR
];
688 ansi_opname
[(int) COMPONENT_REF
] = get_identifier ("__rf");
689 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPONENT_REF
]) = 1;
690 ansi_opname
[(int) MEMBER_REF
] = get_identifier ("__rm");
691 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MEMBER_REF
]) = 1;
692 ansi_opname
[(int) CALL_EXPR
] = get_identifier ("__cl");
693 IDENTIFIER_OPNAME_P (ansi_opname
[(int) CALL_EXPR
]) = 1;
694 ansi_opname
[(int) ARRAY_REF
] = get_identifier ("__vc");
695 IDENTIFIER_OPNAME_P (ansi_opname
[(int) ARRAY_REF
]) = 1;
696 ansi_opname
[(int) NEW_EXPR
] = get_identifier ("__nw");
697 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NEW_EXPR
]) = 1;
698 ansi_opname
[(int) DELETE_EXPR
] = get_identifier ("__dl");
699 IDENTIFIER_OPNAME_P (ansi_opname
[(int) DELETE_EXPR
]) = 1;
700 ansi_opname
[(int) VEC_NEW_EXPR
] = get_identifier ("__vn");
701 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_NEW_EXPR
]) = 1;
702 ansi_opname
[(int) VEC_DELETE_EXPR
] = get_identifier ("__vd");
703 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_DELETE_EXPR
]) = 1;
704 ansi_opname
[(int) TYPE_EXPR
] = get_identifier (OPERATOR_TYPENAME_FORMAT
);
705 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TYPE_EXPR
]) = 1;
707 /* This is not true: these operators are not defined in ANSI,
708 but we need them anyway. */
709 ansi_opname
[(int) MIN_EXPR
] = get_identifier ("__mn");
710 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MIN_EXPR
]) = 1;
711 ansi_opname
[(int) MAX_EXPR
] = get_identifier ("__mx");
712 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MAX_EXPR
]) = 1;
713 ansi_opname
[(int) COND_EXPR
] = get_identifier ("__cn");
714 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COND_EXPR
]) = 1;
715 ansi_opname
[(int) SIZEOF_EXPR
] = get_identifier ("__sz");
716 IDENTIFIER_OPNAME_P (ansi_opname
[(int) SIZEOF_EXPR
]) = 1;
720 gcc_obstack_init (&inline_text_obstack
);
721 inline_text_firstobj
= (char *) obstack_alloc (&inline_text_obstack
, 0);
723 internal_filename
= ggc_alloc_string (INTERNAL_FILENAME
,
724 sizeof (INTERNAL_FILENAME
));
726 /* Start it at 0, because check_newline is called at the very beginning
727 and will increment it to 1. */
729 input_filename
= internal_filename
;
730 current_function_decl
= NULL
;
733 token_buffer
= (char *) xmalloc (maxtoken
+ 2);
735 ridpointers
[(int) RID_INT
] = get_identifier ("int");
736 ridpointers
[(int) RID_BOOL
] = get_identifier ("bool");
737 ridpointers
[(int) RID_CHAR
] = get_identifier ("char");
738 ridpointers
[(int) RID_VOID
] = get_identifier ("void");
739 ridpointers
[(int) RID_FLOAT
] = get_identifier ("float");
740 ridpointers
[(int) RID_DOUBLE
] = get_identifier ("double");
741 ridpointers
[(int) RID_SHORT
] = get_identifier ("short");
742 ridpointers
[(int) RID_LONG
] = get_identifier ("long");
743 ridpointers
[(int) RID_UNSIGNED
] = get_identifier ("unsigned");
744 ridpointers
[(int) RID_SIGNED
] = get_identifier ("signed");
745 ridpointers
[(int) RID_INLINE
] = get_identifier ("inline");
746 ridpointers
[(int) RID_CONST
] = get_identifier ("const");
747 ridpointers
[(int) RID_RESTRICT
] = get_identifier ("__restrict");
748 ridpointers
[(int) RID_VOLATILE
] = get_identifier ("volatile");
749 ridpointers
[(int) RID_AUTO
] = get_identifier ("auto");
750 ridpointers
[(int) RID_STATIC
] = get_identifier ("static");
751 ridpointers
[(int) RID_EXTERN
] = get_identifier ("extern");
752 ridpointers
[(int) RID_TYPEDEF
] = get_identifier ("typedef");
753 ridpointers
[(int) RID_REGISTER
] = get_identifier ("register");
754 ridpointers
[(int) RID_COMPLEX
] = get_identifier ("__complex");
756 /* C++ extensions. These are probably not correctly named. */
757 ridpointers
[(int) RID_WCHAR
] = get_identifier ("__wchar_t");
758 class_type_node
= build_int_2 (class_type
, 0);
759 TREE_TYPE (class_type_node
) = class_type_node
;
760 ridpointers
[(int) RID_CLASS
] = class_type_node
;
762 record_type_node
= build_int_2 (record_type
, 0);
763 TREE_TYPE (record_type_node
) = record_type_node
;
764 ridpointers
[(int) RID_RECORD
] = record_type_node
;
766 union_type_node
= build_int_2 (union_type
, 0);
767 TREE_TYPE (union_type_node
) = union_type_node
;
768 ridpointers
[(int) RID_UNION
] = union_type_node
;
770 enum_type_node
= build_int_2 (enum_type
, 0);
771 TREE_TYPE (enum_type_node
) = enum_type_node
;
772 ridpointers
[(int) RID_ENUM
] = enum_type_node
;
774 ridpointers
[(int) RID_VIRTUAL
] = get_identifier ("virtual");
775 ridpointers
[(int) RID_EXPLICIT
] = get_identifier ("explicit");
776 ridpointers
[(int) RID_EXPORT
] = get_identifier ("export");
777 ridpointers
[(int) RID_FRIEND
] = get_identifier ("friend");
779 ridpointers
[(int) RID_PUBLIC
] = get_identifier ("public");
780 ridpointers
[(int) RID_PRIVATE
] = get_identifier ("private");
781 ridpointers
[(int) RID_PROTECTED
] = get_identifier ("protected");
782 ridpointers
[(int) RID_TEMPLATE
] = get_identifier ("template");
783 /* This is for ANSI C++. */
784 ridpointers
[(int) RID_MUTABLE
] = get_identifier ("mutable");
786 /* Create the built-in __null node. Note that we can't yet call for
787 type_for_size here because integer_type_node and so forth are not
788 set up. Therefore, we don't set the type of these nodes until
789 init_decl_processing. */
790 null_node
= build_int_2 (0, 0);
791 ridpointers
[RID_NULL
] = null_node
;
793 opname_tab
[(int) COMPONENT_REF
] = "->";
794 opname_tab
[(int) MEMBER_REF
] = "->*";
795 opname_tab
[(int) INDIRECT_REF
] = "*";
796 opname_tab
[(int) ARRAY_REF
] = "[]";
797 opname_tab
[(int) MODIFY_EXPR
] = "=";
798 opname_tab
[(int) INIT_EXPR
] = "=";
799 opname_tab
[(int) NEW_EXPR
] = "new";
800 opname_tab
[(int) DELETE_EXPR
] = "delete";
801 opname_tab
[(int) VEC_NEW_EXPR
] = "new []";
802 opname_tab
[(int) VEC_DELETE_EXPR
] = "delete []";
803 opname_tab
[(int) COND_EXPR
] = "?:";
804 opname_tab
[(int) CALL_EXPR
] = "()";
805 opname_tab
[(int) PLUS_EXPR
] = "+";
806 opname_tab
[(int) MINUS_EXPR
] = "-";
807 opname_tab
[(int) MULT_EXPR
] = "*";
808 opname_tab
[(int) TRUNC_DIV_EXPR
] = "/";
809 opname_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /)";
810 opname_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /)";
811 opname_tab
[(int) ROUND_DIV_EXPR
] = "(round /)";
812 opname_tab
[(int) TRUNC_MOD_EXPR
] = "%";
813 opname_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %)";
814 opname_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %)";
815 opname_tab
[(int) ROUND_MOD_EXPR
] = "(round %)";
816 opname_tab
[(int) EXACT_DIV_EXPR
] = "/";
817 opname_tab
[(int) NEGATE_EXPR
] = "-";
818 opname_tab
[(int) MIN_EXPR
] = "<?";
819 opname_tab
[(int) MAX_EXPR
] = ">?";
820 opname_tab
[(int) ABS_EXPR
] = "abs";
821 opname_tab
[(int) FFS_EXPR
] = "ffs";
822 opname_tab
[(int) LSHIFT_EXPR
] = "<<";
823 opname_tab
[(int) RSHIFT_EXPR
] = ">>";
824 opname_tab
[(int) BIT_IOR_EXPR
] = "|";
825 opname_tab
[(int) BIT_XOR_EXPR
] = "^";
826 opname_tab
[(int) BIT_AND_EXPR
] = "&";
827 opname_tab
[(int) BIT_ANDTC_EXPR
] = "&~";
828 opname_tab
[(int) BIT_NOT_EXPR
] = "~";
829 opname_tab
[(int) TRUTH_ANDIF_EXPR
] = "&&";
830 opname_tab
[(int) TRUTH_ORIF_EXPR
] = "||";
831 opname_tab
[(int) TRUTH_AND_EXPR
] = "strict &&";
832 opname_tab
[(int) TRUTH_OR_EXPR
] = "strict ||";
833 opname_tab
[(int) TRUTH_NOT_EXPR
] = "!";
834 opname_tab
[(int) LT_EXPR
] = "<";
835 opname_tab
[(int) LE_EXPR
] = "<=";
836 opname_tab
[(int) GT_EXPR
] = ">";
837 opname_tab
[(int) GE_EXPR
] = ">=";
838 opname_tab
[(int) EQ_EXPR
] = "==";
839 opname_tab
[(int) NE_EXPR
] = "!=";
840 opname_tab
[(int) IN_EXPR
] = "in";
841 opname_tab
[(int) RANGE_EXPR
] = "...";
842 opname_tab
[(int) CONVERT_EXPR
] = "+";
843 opname_tab
[(int) ADDR_EXPR
] = "&";
844 opname_tab
[(int) PREDECREMENT_EXPR
] = "--";
845 opname_tab
[(int) PREINCREMENT_EXPR
] = "++";
846 opname_tab
[(int) POSTDECREMENT_EXPR
] = "--";
847 opname_tab
[(int) POSTINCREMENT_EXPR
] = "++";
848 opname_tab
[(int) COMPOUND_EXPR
] = ",";
850 assignop_tab
[(int) NOP_EXPR
] = "=";
851 assignop_tab
[(int) PLUS_EXPR
] = "+=";
852 assignop_tab
[(int) CONVERT_EXPR
] = "+=";
853 assignop_tab
[(int) MINUS_EXPR
] = "-=";
854 assignop_tab
[(int) NEGATE_EXPR
] = "-=";
855 assignop_tab
[(int) MULT_EXPR
] = "*=";
856 assignop_tab
[(int) INDIRECT_REF
] = "*=";
857 assignop_tab
[(int) TRUNC_DIV_EXPR
] = "/=";
858 assignop_tab
[(int) EXACT_DIV_EXPR
] = "(exact /=)";
859 assignop_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /=)";
860 assignop_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /=)";
861 assignop_tab
[(int) ROUND_DIV_EXPR
] = "(round /=)";
862 assignop_tab
[(int) TRUNC_MOD_EXPR
] = "%=";
863 assignop_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %=)";
864 assignop_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %=)";
865 assignop_tab
[(int) ROUND_MOD_EXPR
] = "(round %=)";
866 assignop_tab
[(int) MIN_EXPR
] = "<?=";
867 assignop_tab
[(int) MAX_EXPR
] = ">?=";
868 assignop_tab
[(int) LSHIFT_EXPR
] = "<<=";
869 assignop_tab
[(int) RSHIFT_EXPR
] = ">>=";
870 assignop_tab
[(int) BIT_IOR_EXPR
] = "|=";
871 assignop_tab
[(int) BIT_XOR_EXPR
] = "^=";
872 assignop_tab
[(int) BIT_AND_EXPR
] = "&=";
873 assignop_tab
[(int) ADDR_EXPR
] = "&=";
875 init_filename_times ();
877 /* Some options inhibit certain reserved words.
878 Clear those words out of the hash table so they won't be recognized. */
879 #define UNSET_RESERVED_WORD(STRING) \
880 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
881 if (s) s->name = ""; } while (0)
884 /* let's parse things, and if they use it, then give them an error. */
885 if (!flag_exceptions
)
887 UNSET_RESERVED_WORD ("throw");
888 UNSET_RESERVED_WORD ("try");
889 UNSET_RESERVED_WORD ("catch");
893 if (!flag_rtti
|| flag_no_gnu_keywords
)
895 UNSET_RESERVED_WORD ("classof");
896 UNSET_RESERVED_WORD ("headof");
899 if (flag_no_asm
|| flag_no_gnu_keywords
)
900 UNSET_RESERVED_WORD ("typeof");
901 if (! flag_operator_names
)
903 /* These are new ANSI keywords that may break code. */
904 UNSET_RESERVED_WORD ("and");
905 UNSET_RESERVED_WORD ("and_eq");
906 UNSET_RESERVED_WORD ("bitand");
907 UNSET_RESERVED_WORD ("bitor");
908 UNSET_RESERVED_WORD ("compl");
909 UNSET_RESERVED_WORD ("not");
910 UNSET_RESERVED_WORD ("not_eq");
911 UNSET_RESERVED_WORD ("or");
912 UNSET_RESERVED_WORD ("or_eq");
913 UNSET_RESERVED_WORD ("xor");
914 UNSET_RESERVED_WORD ("xor_eq");
917 token_count
= init_cpp_parse ();
918 interface_unknown
= 1;
920 ggc_add_tree_root (ansi_opname
, LAST_CPLUS_TREE_CODE
);
921 ggc_add_tree_root (ansi_assopname
, LAST_CPLUS_TREE_CODE
);
922 ggc_add_string_root (&internal_filename
, 1);
923 ggc_add_tree_root (ridpointers
, RID_MAX
);
924 ggc_add_tree_root (&defarg_fns
, 1);
925 ggc_add_tree_root (&defarg_parm
, 1);
926 ggc_add_tree_root (&this_filename_time
, 1);
927 ggc_add_tree_root (&filename_times
, 1);
928 ggc_add_root (&impl_file_chain
, 1, sizeof (impl_file_chain
),
929 mark_impl_file_chain
);
937 cpp_finish (&parse_in
);
938 errorcount
+= parse_in
.errors
;
945 reinit_parse_for_function ()
947 current_base_init_list
= NULL_TREE
;
948 current_member_init_list
= NULL_TREE
;
955 yyprint (file
, yychar
, yylval
)
968 case IDENTIFIER_DEFN
:
972 case PRE_PARSED_CLASS_DECL
:
974 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == TEMPLATE_DECL
)
976 fprintf (file
, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t
)));
979 my_friendly_assert (TREE_CODE (t
) == IDENTIFIER_NODE
, 224);
980 if (IDENTIFIER_POINTER (t
))
981 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
985 if (yylval
.ttype
== class_type_node
)
986 fprintf (file
, " `class'");
987 else if (yylval
.ttype
== record_type_node
)
988 fprintf (file
, " `struct'");
989 else if (yylval
.ttype
== union_type_node
)
990 fprintf (file
, " `union'");
991 else if (yylval
.ttype
== enum_type_node
)
992 fprintf (file
, " `enum'");
994 my_friendly_abort (80);
999 if (TREE_CODE (t
) == INTEGER_CST
)
1001 #if HOST_BITS_PER_WIDE_INT == 64
1002 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT
1005 #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
1012 #if HOST_BITS_PER_WIDE_INT != HOST_BITS_PER_INT
1018 TREE_INT_CST_HIGH (t
), TREE_INT_CST_LOW (t
));
1023 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
1024 static int *reduce_count
;
1030 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
1031 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
1034 #ifdef GATHER_STATISTICS
1035 #ifdef REDUCE_LENGTH
1040 reduce_count
[yyn
] += 1;
1047 return reduce_count
[*q
] - reduce_count
[*p
];
1054 return token_count
[*q
] - token_count
[*p
];
1060 print_parse_statistics ()
1062 #ifdef GATHER_STATISTICS
1063 #ifdef REDUCE_LENGTH
1066 int maxlen
= REDUCE_LENGTH
;
1069 if (reduce_count
[-1] == 0)
1072 if (TOKEN_LENGTH
> REDUCE_LENGTH
)
1073 maxlen
= TOKEN_LENGTH
;
1074 sorted
= (unsigned *) alloca (sizeof (int) * maxlen
);
1076 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1078 qsort (sorted
, TOKEN_LENGTH
, sizeof (int), token_cmp
);
1079 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1081 int idx
= sorted
[i
];
1082 if (token_count
[idx
] == 0)
1084 if (token_count
[idx
] < token_count
[-1])
1086 fprintf (stderr
, "token %d, `%s', count = %d\n",
1087 idx
, yytname
[YYTRANSLATE (idx
)], token_count
[idx
]);
1089 fprintf (stderr
, "\n");
1090 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1092 qsort (sorted
, REDUCE_LENGTH
, sizeof (int), reduce_cmp
);
1093 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1095 int idx
= sorted
[i
];
1096 if (reduce_count
[idx
] == 0)
1098 if (reduce_count
[idx
] < reduce_count
[-1])
1100 fprintf (stderr
, "rule %d, line %d, count = %d\n",
1101 idx
, yyrline
[idx
], reduce_count
[idx
]);
1103 fprintf (stderr
, "\n");
1109 /* Sets the value of the 'yydebug' variable to VALUE.
1110 This is a function so we don't have to have YYDEBUG defined
1111 in order to build the compiler. */
1121 warning ("YYDEBUG not defined.");
1126 /* Mark ARG (which is really a struct impl_files **) for GC. */
1129 mark_impl_file_chain (arg
)
1132 struct impl_files
*ifs
;
1134 ifs
= *(struct impl_files
**) arg
;
1137 ggc_mark_string (ifs
->filename
);
1142 /* Helper function to load global variables with interface
1146 extract_interface_info ()
1150 if (flag_alt_external_templates
)
1152 struct tinst_level
*til
= tinst_for_decl ();
1155 fileinfo
= get_time_identifier (til
->file
);
1158 fileinfo
= get_time_identifier (input_filename
);
1159 fileinfo
= TIME_IDENTIFIER_FILEINFO (fileinfo
);
1160 interface_only
= TREE_INT_CST_LOW (fileinfo
);
1161 interface_unknown
= TREE_INT_CST_HIGH (fileinfo
);
1164 /* Return nonzero if S is not considered part of an
1165 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1168 interface_strcmp (s
)
1171 /* Set the interface/implementation bits for this scope. */
1172 struct impl_files
*ifiles
;
1175 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
1177 const char *t1
= ifiles
->filename
;
1180 if (*s1
!= *t1
|| *s1
== 0)
1183 while (*s1
== *t1
&& *s1
!= 0)
1190 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1191 if (index (s1
, '.') || index (t1
, '.'))
1194 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
1206 cp_pragma_interface (main_filename
)
1207 char *main_filename
;
1210 = TIME_IDENTIFIER_FILEINFO (get_time_identifier (input_filename
));
1212 if (impl_file_chain
== 0)
1214 /* If this is zero at this point, then we are
1215 auto-implementing. */
1216 if (main_input_filename
== 0)
1217 main_input_filename
= input_filename
;
1219 #ifdef AUTO_IMPLEMENT
1220 filename
= file_name_nondirectory (main_input_filename
);
1221 fi
= get_time_identifier (filename
);
1222 fi
= TIME_IDENTIFIER_FILEINFO (fi
);
1223 TREE_INT_CST_LOW (fi
) = 0;
1224 TREE_INT_CST_HIGH (fi
) = 1;
1227 = (struct impl_files
*) xmalloc (sizeof (struct impl_files
));
1228 impl_file_chain
->filename
= ggc_alloc_string (filename
, -1);
1229 impl_file_chain
->next
= 0;
1233 interface_only
= interface_strcmp (main_filename
);
1234 #ifdef MULTIPLE_SYMBOL_SPACES
1235 if (! interface_only
)
1236 interface_unknown
= 0;
1237 #else /* MULTIPLE_SYMBOL_SPACES */
1238 interface_unknown
= 0;
1239 #endif /* MULTIPLE_SYMBOL_SPACES */
1240 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
1241 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
1244 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
1245 We used to only allow this at toplevel, but that restriction was buggy
1246 in older compilers and it seems reasonable to allow it in the headers
1247 themselves, too. It only needs to precede the matching #p interface.
1249 We don't touch interface_only or interface_unknown; the user must specify
1250 a matching #p interface for this to have any effect. */
1253 cp_pragma_implementation (main_filename
)
1254 char *main_filename
;
1256 struct impl_files
*ifiles
= impl_file_chain
;
1257 for (; ifiles
; ifiles
= ifiles
->next
)
1259 if (! strcmp (ifiles
->filename
, main_filename
))
1264 ifiles
= (struct impl_files
*) xmalloc (sizeof (struct impl_files
));
1265 ifiles
->filename
= ggc_alloc_string (main_filename
, -1);
1266 ifiles
->next
= impl_file_chain
;
1267 impl_file_chain
= ifiles
;
1271 /* Set up the state required to correctly handle the definition of the
1272 inline function whose preparsed state has been saved in PI. */
1275 begin_definition_of_inclass_inline (pi
)
1276 struct pending_inline
* pi
;
1283 /* If this is an inline function in a local class, we must make sure
1284 that we save all pertinent information about the function
1285 surrounding the local class. */
1286 context
= hack_decl_function_context (pi
->fndecl
);
1288 push_function_context_to (context
);
1290 feed_input (pi
->buf
, pi
->len
, pi
->filename
, pi
->lineno
);
1291 yychar
= PRE_PARSED_FUNCTION_DECL
;
1293 /* Pass back a handle to the rest of the inline functions, so that they
1294 can be processed later. */
1295 DECL_PENDING_INLINE_INFO (pi
->fndecl
) = 0;
1296 DECL_PENDING_INLINE_P (pi
->fndecl
) = 0;
1297 interface_unknown
= pi
->interface
== 1;
1298 interface_only
= pi
->interface
== 0;
1301 /* Called from the top level: if there are any pending inlines to
1302 do, set up to process them now. This function sets up the first function
1303 to be parsed; after it has been, the rule for fndef in parse.y will
1304 call process_next_inline to start working on the next one. */
1307 do_pending_inlines ()
1309 struct pending_inline
*t
;
1311 /* Oops, we're still dealing with the last batch. */
1312 if (yychar
== PRE_PARSED_FUNCTION_DECL
)
1315 /* Reverse the pending inline functions, since
1316 they were cons'd instead of appended. */
1318 struct pending_inline
*prev
= 0, *tail
;
1319 t
= pending_inlines
;
1320 pending_inlines
= 0;
1335 /* Now start processing the first inline function. */
1336 begin_definition_of_inclass_inline (t
);
1339 /* Called from the fndecl rule in the parser when the function just parsed
1340 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1341 do_pending_inlines). */
1344 process_next_inline (i
)
1345 struct pending_inline
*i
;
1348 context
= hack_decl_function_context (i
->fndecl
);
1350 pop_function_context_from (context
);
1352 if (yychar
== YYEMPTY
)
1354 if (yychar
!= END_OF_SAVED_INPUT
)
1356 error ("parse error at end of saved function text");
1358 /* restore_pending_input will abort unless yychar is either
1359 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1360 hosed, feed back YYEMPTY. */
1365 begin_definition_of_inclass_inline (i
);
1367 extract_interface_info ();
1370 /* Since inline methods can refer to text which has not yet been seen,
1371 we store the text of the method in a structure which is placed in the
1372 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1373 After parsing the body of the class definition, the FUNCTION_DECL's are
1374 scanned to see which ones have this field set. Those are then digested
1377 This function's FUNCTION_DECL will have a bit set in its common so
1378 that we know to watch out for it. */
1381 consume_string (this_obstack
, matching_char
)
1382 register struct obstack
*this_obstack
;
1386 int starting_lineno
;
1389 if (cpp_token
== CPP_STRING
)
1391 /* The C preprocessor will warn about newlines in strings. */
1392 obstack_grow (this_obstack
, yy_cur
, (yy_lim
- yy_cur
));
1394 lineno
= parse_in
.lineno
;
1399 starting_lineno
= lineno
;
1405 int save_lineno
= lineno
;
1406 lineno
= starting_lineno
;
1407 if (matching_char
== '"')
1408 error ("end of file encountered inside string constant");
1410 error ("end of file encountered inside character constant");
1411 lineno
= save_lineno
;
1416 obstack_1grow (this_obstack
, c
);
1418 obstack_1grow (this_obstack
, c
);
1420 /* Make sure we continue the loop */
1427 pedwarn ("ANSI C++ forbids newline in string constant");
1430 obstack_1grow (this_obstack
, c
);
1432 while (c
!= matching_char
);
1435 struct pending_input
{
1438 struct obstack token_obstack
;
1442 struct pending_input
*
1443 save_pending_input ()
1445 struct pending_input
*p
;
1446 p
= (struct pending_input
*) xmalloc (sizeof (struct pending_input
));
1449 p
->eof
= end_of_file
;
1451 p
->first_token
= first_token
;
1452 p
->token_obstack
= token_obstack
;
1455 gcc_obstack_init (&token_obstack
);
1461 restore_pending_input (p
)
1462 struct pending_input
*p
;
1464 my_friendly_assert (yychar
== YYEMPTY
|| yychar
== END_OF_SAVED_INPUT
, 230);
1467 first_token
= p
->first_token
;
1468 obstack_free (&token_obstack
, (char *) 0);
1469 token_obstack
= p
->token_obstack
;
1470 end_of_file
= p
->eof
;
1474 /* Unget character CH from the input stream.
1475 If RESCAN is non-zero, then we want to `see' this
1476 character as the next input token. */
1479 yyungetc (ch
, rescan
)
1483 /* Unget a character from the input stream. */
1484 if (yychar
== YYEMPTY
|| rescan
== 0)
1486 /* If we're putting back a brace, undo the change in indent_level
1487 from the first time we saw it. */
1502 clear_inline_text_obstack ()
1504 obstack_free (&inline_text_obstack
, inline_text_firstobj
);
1507 /* This function stores away the text for an inline function that should
1508 be processed later. It decides how much later, and may need to move
1509 the info between obstacks; therefore, the caller should not refer to
1510 the T parameter after calling this function. */
1513 store_pending_inline (decl
, t
)
1515 struct pending_inline
*t
;
1518 DECL_PENDING_INLINE_INFO (decl
) = t
;
1519 DECL_PENDING_INLINE_P (decl
) = 1;
1521 /* Because we use obstacks, we must process these in precise order. */
1522 t
->next
= pending_inlines
;
1523 pending_inlines
= t
;
1527 reinit_parse_for_method (yychar
, decl
)
1532 int starting_lineno
= lineno
;
1533 char *starting_filename
= input_filename
;
1535 reinit_parse_for_block (yychar
, &inline_text_obstack
);
1537 len
= obstack_object_size (&inline_text_obstack
);
1538 if (decl
== void_type_node
1539 || (current_class_type
&& TYPE_REDEFINED (current_class_type
)))
1541 /* Happens when we get two declarations of the same
1542 function in the same scope. */
1543 char *buf
= obstack_finish (&inline_text_obstack
);
1544 obstack_free (&inline_text_obstack
, buf
);
1549 struct pending_inline
*t
;
1550 char *buf
= obstack_finish (&inline_text_obstack
);
1552 t
= (struct pending_inline
*) obstack_alloc (&inline_text_obstack
,
1553 sizeof (struct pending_inline
));
1554 t
->lineno
= starting_lineno
;
1555 t
->filename
= starting_filename
;
1562 if (interface_unknown
&& processing_template_defn
&& flag_external_templates
&& ! DECL_IN_SYSTEM_HEADER (decl
))
1563 warn_if_unknown_interface (decl
);
1565 t
->interface
= (interface_unknown
? 1 : (interface_only
? 0 : 2));
1566 store_pending_inline (decl
, t
);
1570 /* Consume a block -- actually, a method beginning
1571 with `:' or `{' -- and save it away on the specified obstack. */
1574 reinit_parse_for_block (pyychar
, obstackp
)
1576 struct obstack
*obstackp
;
1580 int starting_lineno
= lineno
;
1581 char *starting_filename
= input_filename
;
1583 int look_for_semicolon
= 0;
1584 int look_for_lbrac
= 0;
1588 obstack_1grow (obstackp
, '{');
1589 /* We incremented indent_level in yylex; undo that. */
1592 else if (pyychar
== '=')
1593 look_for_semicolon
= 1;
1594 else if (pyychar
== ':')
1596 obstack_1grow (obstackp
, pyychar
);
1597 /* Add a space so we don't get confused by ': ::A(20)'. */
1598 obstack_1grow (obstackp
, ' ');
1602 else if (pyychar
== RETURN_KEYWORD
)
1604 obstack_grow (obstackp
, "return", 6);
1608 else if (pyychar
== TRY
)
1610 obstack_grow (obstackp
, "try", 3);
1616 yyerror ("parse error in method specification");
1617 obstack_1grow (obstackp
, '{');
1624 int this_lineno
= lineno
;
1626 c
= skip_white_space (c
);
1628 /* Don't lose our cool if there are lots of comments. */
1629 if (lineno
== this_lineno
+ 1)
1630 obstack_1grow (obstackp
, '\n');
1631 else if (lineno
== this_lineno
)
1633 else if (lineno
- this_lineno
< 10)
1636 for (i
= lineno
- this_lineno
; i
> 0; i
--)
1637 obstack_1grow (obstackp
, '\n');
1642 sprintf (buf
, "\n# %d \"", lineno
);
1644 obstack_grow (obstackp
, buf
, len
);
1646 len
= strlen (input_filename
);
1647 obstack_grow (obstackp
, input_filename
, len
);
1648 obstack_1grow (obstackp
, '\"');
1649 obstack_1grow (obstackp
, '\n');
1652 while (c
> ' ') /* ASCII dependent... */
1654 obstack_1grow (obstackp
, c
);
1663 if (blev
== 0 && !look_for_semicolon
)
1667 if (peekyylex () == CATCH
)
1670 obstack_grow (obstackp
, " catch ", 7);
1687 /* Don't act on the next character...e.g, doing an escaped
1692 error_with_file_and_line (starting_filename
,
1694 "end of file read inside definition");
1697 obstack_1grow (obstackp
, c
);
1700 consume_string (obstackp
, c
);
1702 consume_string (obstackp
, c
);
1707 error ("function body for constructor missing");
1708 obstack_1grow (obstackp
, '{');
1709 obstack_1grow (obstackp
, '}');
1713 else if (look_for_semicolon
&& blev
== 0)
1721 error_with_file_and_line (starting_filename
,
1723 "end of file read inside definition");
1728 obstack_1grow (obstackp
, c
);
1733 obstack_1grow (obstackp
, '\0');
1736 /* Consume a no-commas expression -- actually, a default argument -- and
1737 save it away on the specified obstack. */
1740 reinit_parse_for_expr (obstackp
)
1741 struct obstack
*obstackp
;
1744 int starting_lineno
= lineno
;
1745 char *starting_filename
= input_filename
;
1753 int this_lineno
= lineno
;
1755 c
= skip_white_space (c
);
1757 /* Don't lose our cool if there are lots of comments. */
1758 if (lineno
== this_lineno
+ 1)
1759 obstack_1grow (obstackp
, '\n');
1760 else if (lineno
== this_lineno
)
1762 else if (lineno
- this_lineno
< 10)
1765 for (i
= lineno
- this_lineno
; i
> 0; --i
)
1766 obstack_1grow (obstackp
, '\n');
1771 sprintf (buf
, "\n# %d \"", lineno
);
1773 obstack_grow (obstackp
, buf
, len
);
1775 len
= strlen (input_filename
);
1776 obstack_grow (obstackp
, input_filename
, len
);
1777 obstack_1grow (obstackp
, '\"');
1778 obstack_1grow (obstackp
, '\n');
1781 while (c
> ' ') /* ASCII dependent... */
1783 if (plev
<= 0 && (c
== ')' || c
== ','))
1788 obstack_1grow (obstackp
, c
);
1789 if (c
== '(' || c
== '[')
1791 else if (c
== ']' || c
== ')')
1795 /* Don't act on the next character...e.g, doing an escaped
1800 error_with_file_and_line (starting_filename
,
1802 "end of file read inside definition");
1805 obstack_1grow (obstackp
, c
);
1808 consume_string (obstackp
, c
);
1810 consume_string (obstackp
, c
);
1816 error_with_file_and_line (starting_filename
,
1818 "end of file read inside definition");
1823 obstack_1grow (obstackp
, c
);
1828 obstack_1grow (obstackp
, '\0');
1831 int do_snarf_defarg
;
1833 /* Decide whether the default argument we are about to see should be
1834 gobbled up as text for later parsing. */
1837 maybe_snarf_defarg ()
1839 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
1840 do_snarf_defarg
= 1;
1850 reinit_parse_for_expr (&inline_text_obstack
);
1851 len
= obstack_object_size (&inline_text_obstack
);
1852 buf
= obstack_finish (&inline_text_obstack
);
1854 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1855 arg
= make_node (DEFAULT_ARG
);
1856 DEFARG_LENGTH (arg
) = len
- 1;
1857 DEFARG_POINTER (arg
) = buf
;
1863 /* Called from grokfndecl to note a function decl with unparsed default
1864 arguments for later processing. Also called from grokdeclarator
1865 for function types with unparsed defargs; the call from grokfndecl
1866 will always come second, so we can overwrite the entry from the type. */
1869 add_defarg_fn (decl
)
1872 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1873 TREE_VALUE (defarg_fns
) = decl
;
1876 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1877 defarg_fns
= tree_cons (current_class_type
, decl
, defarg_fns
);
1882 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1888 tree d
= TREE_PURPOSE (p
);
1891 if (TREE_CODE (f
) == FUNCTION_DECL
)
1893 line
= DECL_SOURCE_LINE (f
);
1894 file
= DECL_SOURCE_FILE (f
);
1899 file
= input_filename
;
1902 feed_input (DEFARG_POINTER (d
), DEFARG_LENGTH (d
), file
, line
);
1903 yychar
= DEFARG_MARKER
;
1907 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1912 if (yychar
== YYEMPTY
)
1914 if (yychar
!= END_OF_SAVED_INPUT
)
1916 error ("parse error at end of saved function text");
1918 /* restore_pending_input will abort unless yychar is either
1919 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1920 hosed, feed back YYEMPTY. */
1926 /* Main function for deferred parsing of default arguments. Called from
1930 do_pending_defargs ()
1935 for (; defarg_fns
; defarg_fns
= TREE_CHAIN (defarg_fns
))
1937 tree defarg_fn
= TREE_VALUE (defarg_fns
);
1938 if (defarg_parm
== NULL_TREE
)
1940 push_nested_class (TREE_PURPOSE (defarg_fns
), 1);
1942 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1943 maybe_begin_member_template_processing (defarg_fn
);
1945 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1949 for (p
= DECL_ARGUMENTS (defarg_fn
); p
; p
= TREE_CHAIN (p
))
1950 pushdecl (copy_node (p
));
1952 defarg_parm
= TYPE_ARG_TYPES (TREE_TYPE (defarg_fn
));
1955 defarg_parm
= TYPE_ARG_TYPES (defarg_fn
);
1958 defarg_parm
= TREE_CHAIN (defarg_parm
);
1960 for (; defarg_parm
; defarg_parm
= TREE_CHAIN (defarg_parm
))
1961 if (TREE_PURPOSE (defarg_parm
)
1962 && TREE_CODE (TREE_PURPOSE (defarg_parm
)) == DEFAULT_ARG
)
1964 feed_defarg (defarg_fn
, defarg_parm
);
1966 /* Return to the parser, which will process this defarg
1967 and call us again. */
1971 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1973 maybe_end_member_template_processing ();
1974 check_default_args (defarg_fn
);
1978 pop_nested_class ();
1982 /* Build a default function named NAME for type TYPE.
1983 KIND says what to build.
1985 When KIND == 0, build default destructor.
1986 When KIND == 1, build virtual destructor.
1987 When KIND == 2, build default constructor.
1988 When KIND == 3, build default X(const X&) constructor.
1989 When KIND == 4, build default X(X&) constructor.
1990 When KIND == 5, build default operator = (const X&).
1991 When KIND == 6, build default operator = (X&). */
1994 cons_up_default_function (type
, full_name
, kind
)
1995 tree type
, full_name
;
1998 tree declspecs
= NULL_TREE
;
1999 tree fn
, args
= NULL_TREE
;
2002 tree name
= constructor_name (full_name
);
2008 declspecs
= build_decl_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]);
2009 /* Fall through... */
2011 name
= build_parse_node (BIT_NOT_EXPR
, name
);
2012 args
= void_list_node
;
2016 /* Default constructor. */
2017 args
= void_list_node
;
2021 type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
2022 /* Fall through... */
2024 /* According to ARM $12.8, the default copy ctor will be declared, but
2025 not defined, unless it's needed. */
2026 argtype
= build_reference_type (type
);
2027 args
= tree_cons (NULL_TREE
,
2028 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
2029 get_identifier ("_ctor_arg")),
2036 declspecs
= build_decl_list (NULL_TREE
, type
);
2039 type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
2041 name
= ansi_opname
[(int) MODIFY_EXPR
];
2043 argtype
= build_reference_type (type
);
2044 args
= tree_cons (NULL_TREE
,
2045 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
2046 get_identifier ("_ctor_arg")),
2051 my_friendly_abort (59);
2054 declspecs
= decl_tree_cons (NULL_TREE
, ridpointers
[(int) RID_INLINE
],
2057 TREE_PARMLIST (args
) = 1;
2060 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, NULL_TREE
);
2062 declarator
= build_parse_node (ADDR_EXPR
, declarator
);
2064 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
2067 if (fn
== void_type_node
)
2071 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn
)));
2074 if (processing_template_defn
)
2076 SET_DECL_IMPLICIT_INSTANTIATION (fn
);
2077 repo_template_used (fn
);
2082 if (CLASSTYPE_INTERFACE_KNOWN (type
))
2084 DECL_INTERFACE_KNOWN (fn
) = 1;
2085 DECL_NOT_REALLY_EXTERN (fn
) = (!CLASSTYPE_INTERFACE_ONLY (type
)
2086 && flag_implement_inlines
);
2090 DECL_NOT_REALLY_EXTERN (fn
) = 1;
2092 mark_inline_for_output (fn
);
2094 #ifdef DEBUG_DEFAULT_FUNCTIONS
2095 { char *fn_type
= NULL
;
2099 case 0: fn_type
= "default destructor"; break;
2100 case 1: fn_type
= "virtual destructor"; break;
2101 case 2: fn_type
= "default constructor"; break;
2102 case 3: fn_type
= "default X(const X&)"; break;
2103 case 4: fn_type
= "default X(X&)"; break;
2107 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2108 t
= TREE_OPERAND (name
, 0);
2109 fprintf (stderr
, "[[[[ %s for %s:\n%s]]]]\n", fn_type
,
2110 IDENTIFIER_POINTER (t
), func_buf
);
2113 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2115 /* Show that this function was generated by the compiler. */
2116 SET_DECL_ARTIFICIAL (fn
);
2121 /* Heuristic to tell whether the user is missing a semicolon
2122 after a struct or enum declaration. Emit an error message
2123 if we know the user has blown it. */
2126 check_for_missing_semicolon (type
)
2134 && yychar
!= IDENTIFIER
2135 && yychar
!= TYPENAME
2136 && yychar
!= CV_QUALIFIER
2137 && yychar
!= SELFNAME
)
2140 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
2141 error ("semicolon missing after %s declaration",
2142 TREE_CODE (type
) == ENUMERAL_TYPE
? "enum" : "struct");
2144 cp_error ("semicolon missing after declaration of `%T'", type
);
2145 shadow_tag (build_tree_list (0, type
));
2147 /* Could probably also hack cases where class { ... } f (); appears. */
2152 note_got_semicolon (type
)
2155 if (TREE_CODE_CLASS (TREE_CODE (type
)) != 't')
2156 my_friendly_abort (60);
2157 if (CLASS_TYPE_P (type
))
2158 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
2162 note_list_got_semicolon (declspecs
)
2167 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
2169 tree type
= TREE_VALUE (link
);
2170 if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't')
2171 note_got_semicolon (type
);
2176 /* Iff C is a carriage return, warn about it - if appropriate -
2177 and return nonzero. */
2182 static int newline_warning
= 0;
2186 /* ANSI C says the effects of a carriage return in a source file
2188 if (pedantic
&& !newline_warning
)
2190 warning ("carriage return in source file");
2191 warning ("(we only warn about the first carriage return)");
2192 newline_warning
= 1;
2199 /* If C is not whitespace, return C.
2200 Otherwise skip whitespace and return first nonwhite char read. */
2203 skip_white_space (c
)
2210 /* We don't recognize comments here, because
2211 cpp output can include / and * consecutively as operators.
2212 Also, there's no need, since cpp removes all comments. */
2220 c
= check_newline ();
2229 /* While processing a # directive we don't get CPP_HSPACE
2230 tokens, so we also need to handle whitespace the normal way. */
2231 if (cpp_token
== CPP_HSPACE
)
2232 c
= yy_get_token ();
2248 error ("stray '\\' in program");
2258 /* Make the token buffer longer, preserving the data in it.
2259 P should point to just beyond the last valid character in the old buffer.
2260 The value we return is a pointer to the new buffer
2261 at a place corresponding to P. */
2264 extend_token_buffer_to (size
)
2268 maxtoken
= maxtoken
* 2 + 10;
2269 while (maxtoken
< size
);
2270 token_buffer
= (char *) xrealloc (token_buffer
, maxtoken
+ 2);
2274 extend_token_buffer (p
)
2277 int offset
= p
- token_buffer
;
2278 extend_token_buffer_to (offset
);
2279 return token_buffer
+ offset
;
2282 #if defined HANDLE_PRAGMA
2283 /* Local versions of these macros, that can be passed as function pointers. */
2299 read_line_number (num
)
2302 register int token
= real_yylex ();
2304 if (token
== CONSTANT
2305 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2307 *num
= TREE_INT_CST_LOW (yylval
.ttype
);
2312 if (token
!= END_OF_LINE
)
2313 error ("invalid #-line");
2318 /* At the beginning of a line, increment the line number
2319 and process any #-directive on this line.
2320 If the line is a #-directive, read the entire line and return a newline.
2321 Otherwise, return the line's first non-whitespace character.
2323 Note that in the case of USE_CPPLIB, we get the whole line as one
2324 CPP_DIRECTIVE token. */
2332 enum { act_none
, act_push
, act_pop
} action
;
2333 int old_lineno
, action_number
, l
;
2334 int entering_c_header
;
2337 /* Read first nonwhite char on the line. Do this before incrementing the
2338 line number, in case we're at the end of saved text. */
2342 /* In some cases where we're leaving an include file, we can get multiple
2343 CPP_HSPACE tokens in a row, so we need to loop. */
2344 while (cpp_token
== CPP_HSPACE
)
2345 c
= yy_get_token ();
2349 while (c
== ' ' || c
== '\t');
2356 /* Sequences of multiple newlines are very common; optimize them. */
2360 /* If not #, return it so caller will use it. */
2364 /* Don't read beyond this line. */
2369 if (cpp_token
== CPP_VSPACE
)
2371 /* Format is "<space> <line number> <filename> <newline>".
2372 Only the line number is interesting, and even that
2373 we can get more efficiently than scanning the line. */
2374 yy_cur
= yy_lim
- 1;
2375 lineno
= parse_in
.lineno
- 1;
2380 token
= real_yylex ();
2382 if (token
== IDENTIFIER
)
2384 /* If a letter follows, then if the word here is `line', skip
2385 it and ignore it; otherwise, ignore the line, with an error
2386 if the word isn't `pragma'. */
2388 const char *name
= IDENTIFIER_POINTER (yylval
.ttype
);
2390 if (!strcmp (name
, "pragma"))
2392 token
= real_yylex ();
2393 if (token
!= IDENTIFIER
2394 || TREE_CODE (yylval
.ttype
) != IDENTIFIER_NODE
)
2397 /* If this is 1, we handled it; if it's -1, it was one we
2398 wanted but had something wrong with it. Only if it's
2399 0 was it not handled. */
2400 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval
.ttype
)))
2403 #ifdef HANDLE_PRAGMA
2404 /* We invoke HANDLE_PRAGMA before HANDLE_GENERIC_PRAGMAS
2405 (if both are defined), in order to give the back
2406 end a chance to override the interpretation of
2407 SYSV style pragmas. */
2408 if (HANDLE_PRAGMA (pragma_getc
, pragma_ungetc
,
2409 IDENTIFIER_POINTER (yylval
.ttype
)))
2411 #endif /* HANDLE_PRAGMA */
2413 #ifdef HANDLE_GENERIC_PRAGMAS
2414 if (handle_generic_pragma (token
))
2416 #endif /* HANDLE_GENERIC_PRAGMAS */
2418 /* Issue a warning message if we have been asked to do so.
2419 Ignoring unknown pragmas in system header file unless
2420 an explcit -Wunknown-pragmas has been given. */
2421 if (warn_unknown_pragmas
> 1
2422 || (warn_unknown_pragmas
&& ! in_system_header
))
2423 warning ("ignoring pragma: %s", token_buffer
);
2427 else if (!strcmp (name
, "define"))
2429 debug_define (lineno
, GET_DIRECTIVE_LINE ());
2432 else if (!strcmp (name
, "undef"))
2434 debug_undef (lineno
, GET_DIRECTIVE_LINE ());
2437 else if (!strcmp (name
, "line"))
2440 token
= real_yylex ();
2443 else if (!strcmp (name
, "ident"))
2445 /* #ident. The pedantic warning is now in cccp.c. */
2447 /* Here we have just seen `#ident '.
2448 A string constant should follow. */
2450 token
= real_yylex ();
2451 if (token
== END_OF_LINE
)
2454 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
2456 error ("invalid #ident");
2460 if (! flag_no_ident
)
2462 #ifdef ASM_OUTPUT_IDENT
2463 ASM_OUTPUT_IDENT (asm_out_file
,
2464 TREE_STRING_POINTER (yylval
.ttype
));
2468 /* Skip the rest of this line. */
2472 error ("undefined or invalid # directive `%s'", name
);
2476 /* If the # is the only nonwhite char on the line,
2477 just ignore it. Check the new newline. */
2478 if (token
== END_OF_LINE
)
2482 /* Here we have either `#line' or `# <nonletter>'.
2483 In either case, it should be a line number; a digit should follow. */
2485 if (token
!= CONSTANT
2486 || TREE_CODE (yylval
.ttype
) != INTEGER_CST
)
2488 error ("invalid #-line");
2492 /* subtract one, because it is the following line that
2493 gets the specified number */
2495 l
= TREE_INT_CST_LOW (yylval
.ttype
) - 1;
2497 /* More follows: it must be a string constant (filename).
2498 It would be neat to use cpplib to quickly process the string, but
2499 (1) we don't have a handy tokenization of the string, and
2500 (2) I don't know how well that would work in the presense
2501 of filenames that contain wide characters. */
2505 /* Don't treat \ as special if we are processing #line 1 "...".
2506 If you want it to be treated specially, use # 1 "...". */
2507 ignore_escape_flag
= 1;
2510 /* Read the string constant. */
2511 token
= real_yylex ();
2513 ignore_escape_flag
= 0;
2515 if (token
== END_OF_LINE
)
2517 /* No more: store the line number and check following line. */
2522 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
2524 error ("invalid #line");
2528 /* Changing files again. This means currently collected time
2529 is charged against header time, and body time starts back at 0. */
2530 if (flag_detailed_statistics
)
2532 int this_time
= my_get_run_time ();
2533 tree time_identifier
= get_time_identifier (TREE_STRING_POINTER (yylval
.ttype
));
2534 header_time
+= this_time
- body_time
;
2535 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time
))
2536 += this_time
- body_time
;
2537 this_filename_time
= time_identifier
;
2538 body_time
= this_time
;
2541 input_filename
= TREE_STRING_POINTER (yylval
.ttype
);
2543 GNU_xref_file (input_filename
);
2545 if (main_input_filename
== 0)
2547 struct impl_files
*ifiles
= impl_file_chain
;
2551 while (ifiles
->next
)
2552 ifiles
= ifiles
->next
;
2553 ifiles
->filename
= file_name_nondirectory (input_filename
);
2556 main_input_filename
= input_filename
;
2559 extract_interface_info ();
2561 old_lineno
= lineno
;
2566 /* Each change of file name
2567 reinitializes whether we are now in a system header. */
2568 in_system_header
= 0;
2569 entering_c_header
= 0;
2571 if (!read_line_number (&action_number
))
2573 /* Update the name in the top element of input_file_stack. */
2574 if (input_file_stack
)
2575 input_file_stack
->name
= input_filename
;
2578 /* `1' after file name means entering new file.
2579 `2' after file name means just left a file. */
2581 if (action_number
== 1)
2584 read_line_number (&action_number
);
2586 else if (action_number
== 2)
2589 read_line_number (&action_number
);
2591 if (action_number
== 3)
2593 /* `3' after file name means this is a system header file. */
2594 in_system_header
= 1;
2595 read_line_number (&action_number
);
2597 if (action_number
== 4)
2599 /* `4' after file name means this is a C header file. */
2600 entering_c_header
= 1;
2601 read_line_number (&action_number
);
2604 /* Do the actions implied by the preceding numbers. */
2606 if (action
== act_push
)
2608 /* Pushing to a new file. */
2609 struct file_stack
*p
2610 = (struct file_stack
*) xmalloc (sizeof (struct file_stack
));
2611 input_file_stack
->line
= old_lineno
;
2612 p
->next
= input_file_stack
;
2613 p
->name
= input_filename
;
2614 p
->indent_level
= indent_level
;
2615 input_file_stack
= p
;
2616 input_file_stack_tick
++;
2617 debug_start_source_file (input_filename
);
2620 else if (entering_c_header
)
2623 ++pending_lang_change
;
2626 else if (action
== act_pop
)
2628 /* Popping out of a file. */
2629 if (input_file_stack
->next
)
2631 struct file_stack
*p
= input_file_stack
;
2633 if (c_header_level
&& --c_header_level
== 0)
2635 if (entering_c_header
)
2636 warning ("badly nested C headers from preprocessor");
2637 --pending_lang_change
;
2640 if (indent_level
!= p
->indent_level
)
2642 warning_with_file_and_line
2643 (p
->name
, old_lineno
,
2644 "This file contains more `%c's than `%c's.",
2645 indent_level
> p
->indent_level
? '{' : '}',
2646 indent_level
> p
->indent_level
? '}' : '{');
2648 input_file_stack
= p
->next
;
2650 input_file_stack_tick
++;
2651 debug_end_source_file (input_file_stack
->line
);
2654 error ("#-lines for entering and leaving files don't match");
2657 /* Now that we've pushed or popped the input stack,
2658 update the name in the top element. */
2659 if (input_file_stack
)
2660 input_file_stack
->name
= input_filename
;
2662 /* skip the rest of this line. */
2669 while (c
!= '\n' && c
!= EOF
);
2673 #ifdef HANDLE_GENERIC_PRAGMAS
2675 /* Handle a #pragma directive.
2676 TOKEN is the token we read after `#pragma'. Processes the entire input
2677 line and return non-zero iff the pragma has been successfully parsed. */
2679 /* This function has to be in this file, in order to get at
2683 handle_generic_pragma (token
)
2694 handle_pragma_token (token_buffer
, yylval
.ttype
);
2698 handle_pragma_token ("(", NULL_TREE
);
2699 handle_pragma_token (")", NULL_TREE
);
2703 return handle_pragma_token (NULL_PTR
, NULL_TREE
);
2706 handle_pragma_token (token_buffer
, NULL_TREE
);
2709 token
= real_yylex ();
2712 #endif /* HANDLE_GENERIC_PRAGMAS */
2715 handle_cp_pragma (pname
)
2720 if (! strcmp (pname
, "vtable"))
2722 /* More follows: it must be a string constant (class name). */
2723 token
= real_yylex ();
2724 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
2726 error ("invalid #pragma vtable");
2731 = tree_cons (NULL_TREE
,
2732 get_identifier (TREE_STRING_POINTER (yylval
.ttype
)),
2734 token
= real_yylex ();
2735 if (token
!= END_OF_LINE
)
2736 warning ("trailing characters ignored");
2739 else if (! strcmp (pname
, "unit"))
2741 /* More follows: it must be a string constant (unit name). */
2742 token
= real_yylex ();
2743 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
2745 error ("invalid #pragma unit");
2748 token
= real_yylex ();
2749 if (token
!= END_OF_LINE
)
2750 warning ("trailing characters ignored");
2753 else if (! strcmp (pname
, "interface"))
2755 char *main_filename
= input_filename
;
2757 main_filename
= file_name_nondirectory (main_filename
);
2759 token
= real_yylex ();
2761 if (token
!= END_OF_LINE
)
2764 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
2766 error ("invalid `#pragma interface'");
2769 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
2770 token
= real_yylex ();
2773 if (token
!= END_OF_LINE
)
2774 warning ("garbage after `#pragma interface' ignored");
2776 cp_pragma_interface (main_filename
);
2780 else if (! strcmp (pname
, "implementation"))
2782 char *main_filename
= main_input_filename
? main_input_filename
: input_filename
;
2784 main_filename
= file_name_nondirectory (main_filename
);
2786 token
= real_yylex ();
2788 if (token
!= END_OF_LINE
)
2791 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
2793 error ("invalid `#pragma implementation'");
2796 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
2797 token
= real_yylex ();
2800 if (token
!= END_OF_LINE
)
2801 warning ("garbage after `#pragma implementation' ignored");
2803 cp_pragma_implementation (main_filename
);
2812 do_pending_lang_change ()
2814 for (; pending_lang_change
> 0; --pending_lang_change
)
2815 push_lang_context (lang_name_c
);
2816 for (; pending_lang_change
< 0; ++pending_lang_change
)
2817 pop_lang_context ();
2820 #define ENDFILE -1 /* token that represents end-of-file */
2822 /* Read an escape sequence, returning its equivalent as a character,
2823 or store 1 in *ignore_ptr if it is backslash-newline. */
2826 readescape (ignore_ptr
)
2829 register int c
= getch ();
2831 register unsigned count
;
2832 unsigned firstdig
= 0;
2850 if (c
>= 'a' && c
<= 'f')
2851 code
+= c
- 'a' + 10;
2852 if (c
>= 'A' && c
<= 'F')
2853 code
+= c
- 'A' + 10;
2854 if (c
>= '0' && c
<= '9')
2856 if (code
!= 0 || count
!= 0)
2865 error ("\\x used with no following hex digits");
2866 else if (count
== 0)
2867 /* Digits are all 0's. Ok. */
2869 else if ((count
- 1) * 4 >= TYPE_PRECISION (integer_type_node
)
2872 << (TYPE_PRECISION (integer_type_node
)
2875 pedwarn ("hex escape out of range");
2878 case '0': case '1': case '2': case '3': case '4':
2879 case '5': case '6': case '7':
2882 while ((c
<= '7') && (c
>= '0') && (count
++ < 3))
2884 code
= (code
* 8) + (c
- '0');
2890 case '\\': case '\'': case '"':
2899 return TARGET_NEWLINE
;
2922 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c
);
2928 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2932 /* `\%' is used to prevent SCCS from getting confused. */
2935 pedwarn ("unknown escape sequence `\\%c'", c
);
2939 pedwarn ("unknown escape sequence `\\%c'", c
);
2941 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c
);
2949 extern int end_of_file
;
2952 strcpy (buf
, string
);
2954 /* We can't print string and character constants well
2955 because the token_buffer contains the result of processing escapes. */
2957 strcat (buf
, input_redirected ()
2958 ? " at end of saved text"
2959 : " at end of input");
2960 else if (token_buffer
[0] == 0)
2961 strcat (buf
, " at null character");
2962 else if (token_buffer
[0] == '"')
2963 strcat (buf
, " before string constant");
2964 else if (token_buffer
[0] == '\'')
2965 strcat (buf
, " before character constant");
2966 else if (!ISGRAPH ((unsigned char)token_buffer
[0]))
2967 sprintf (buf
+ strlen (buf
), " before character 0%o",
2968 (unsigned char) token_buffer
[0]);
2970 strcat (buf
, " before `%s'");
2972 error (buf
, token_buffer
);
2975 /* Value is 1 (or 2) if we should try to make the next identifier look like
2976 a typename (when it may be a local variable or a class variable).
2977 Value is 0 if we treat this name in a default fashion. */
2978 int looking_for_typename
;
2984 identifier_type (decl
)
2988 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2990 if (TREE_CODE (DECL_RESULT (decl
)) == TYPE_DECL
)
2992 else if (looking_for_template
)
2995 if (looking_for_template
&& really_overloaded_fn (decl
))
2997 /* See through a baselink. */
2998 if (TREE_CODE (decl
) == TREE_LIST
)
2999 decl
= TREE_VALUE (decl
);
3001 for (t
= decl
; t
!= NULL_TREE
; t
= OVL_CHAIN (t
))
3002 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t
)))
3005 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
3007 if (TREE_CODE (decl
) != TYPE_DECL
)
3009 if (DECL_ARTIFICIAL (decl
) && TREE_TYPE (decl
) == current_class_type
)
3012 /* A constructor declarator for a template type will get here as an
3013 implicit typename, a TYPENAME_TYPE with a type. */
3015 if (t
&& TREE_CODE (t
) == TYPENAME_TYPE
)
3017 decl
= TREE_TYPE (decl
);
3018 if (TREE_CODE (decl
) == TYPENAME_TYPE
)
3019 decl
= TREE_TYPE (decl
);
3029 /* Only types expected, not even namespaces. */
3030 looking_for_typename
= 2;
3032 if ((yychar
= yylex ()) < 0) yychar
= 0;
3033 looking_for_typename
= 0;
3034 if (yychar
== IDENTIFIER
)
3036 lastiddecl
= lookup_name (yylval
.ttype
, -2);
3037 if (lastiddecl
== 0)
3040 lastiddecl
= IDENTIFIER_LABEL_VALUE (yylval
.ttype
);
3043 yychar
= identifier_type (lastiddecl
);
3047 /* Return true if d is in a global scope. */
3054 switch (TREE_CODE (d
))
3059 case OVERLOAD
: d
= OVL_FUNCTION (d
); continue;
3060 case TREE_LIST
: d
= TREE_VALUE (d
); continue;
3062 my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (d
)) == 'd', 980629);
3064 /* A template parameter is not really global, even though it
3065 has no enclosing scope. */
3066 if (DECL_TEMPLATE_PARM_P (d
))
3069 d
= CP_DECL_CONTEXT (d
);
3070 return TREE_CODE (d
) == NAMESPACE_DECL
;
3075 do_identifier (token
, parsing
, args
)
3076 register tree token
;
3081 int lexing
= (parsing
== 1);
3082 int in_call
= (parsing
== 2);
3084 if (! lexing
|| IDENTIFIER_OPNAME_P (token
))
3085 id
= lookup_name (token
, 0);
3089 /* Do Koenig lookup if appropriate (inside templates we build lookup
3090 expressions instead).
3092 [basic.lookup.koenig]: If the ordinary unqualified lookup of the name
3093 finds the declaration of a class member function, the associated
3094 namespaces and classes are not considered. */
3096 if (args
&& !current_template_parms
&& (!id
|| is_global (id
)))
3097 id
= lookup_arg_dependent (token
, id
, args
);
3099 /* Remember that this name has been used in the class definition, as per
3102 /* Avoid breaking if we get called for a default argument that
3103 refers to an overloaded method. Eventually this will not be
3104 necessary, since default arguments shouldn't be parsed until
3105 after the class is complete. (jason 3/12/97) */
3106 && TREE_CODE (id
) != OVERLOAD
)
3107 maybe_note_name_used_in_class (token
, id
);
3109 if (id
== error_mark_node
)
3111 /* lookup_name quietly returns error_mark_node if we're parsing,
3112 as we don't want to complain about an identifier that ends up
3113 being used as a declarator. So we call it again to get the error
3115 id
= lookup_name (token
, 0);
3116 return error_mark_node
;
3121 if (current_template_parms
)
3122 return build_min_nt (LOOKUP_EXPR
, token
);
3123 else if (IDENTIFIER_OPNAME_P (token
))
3125 if (token
!= ansi_opname
[ERROR_MARK
])
3126 cp_error ("`%D' not defined", token
);
3127 id
= error_mark_node
;
3129 else if (in_call
&& ! flag_strict_prototype
)
3131 id
= implicitly_declare (token
);
3133 else if (current_function_decl
== 0)
3135 cp_error ("`%D' was not declared in this scope", token
);
3136 id
= error_mark_node
;
3140 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
3141 || IDENTIFIER_ERROR_LOCUS (token
) != current_function_decl
)
3143 static int undeclared_variable_notice
;
3145 cp_error ("`%D' undeclared (first use this function)", token
);
3147 if (! undeclared_variable_notice
)
3149 error ("(Each undeclared identifier is reported only once");
3150 error ("for each function it appears in.)");
3151 undeclared_variable_notice
= 1;
3154 id
= error_mark_node
;
3155 /* Prevent repeated error messages. */
3156 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
3157 SET_IDENTIFIER_ERROR_LOCUS (token
, current_function_decl
);
3161 if (TREE_CODE (id
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (id
))
3163 tree shadowed
= DECL_SHADOWED_FOR_VAR (id
);
3164 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
3165 && DECL_DEAD_FOR_LOCAL (shadowed
))
3166 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
3168 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id
));
3171 if (!DECL_ERROR_REPORTED (id
))
3173 warning ("name lookup of `%s' changed",
3174 IDENTIFIER_POINTER (token
));
3175 cp_warning_at (" matches this `%D' under current ANSI rules",
3177 cp_warning_at (" matches this `%D' under old rules", id
);
3178 DECL_ERROR_REPORTED (id
) = 1;
3182 else if (!DECL_ERROR_REPORTED (id
))
3185 = "name lookup of `%s' changed for new ANSI `for' scoping";
3186 DECL_ERROR_REPORTED (id
) = 1;
3187 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id
)))
3189 error (msg
, IDENTIFIER_POINTER (token
));
3190 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id
);
3191 id
= error_mark_node
;
3195 pedwarn (msg
, IDENTIFIER_POINTER (token
));
3196 cp_pedwarn_at (" using obsolete binding at `%D'", id
);
3200 /* TREE_USED is set in `hack_identifier'. */
3201 if (TREE_CODE (id
) == CONST_DECL
)
3204 if (IDENTIFIER_CLASS_VALUE (token
) == id
)
3205 enforce_access (DECL_REAL_CONTEXT(id
), id
);
3206 if (!processing_template_decl
|| DECL_TEMPLATE_PARM_P (id
))
3207 id
= DECL_INITIAL (id
);
3210 id
= hack_identifier (id
, token
);
3212 /* We must look up dependent names when the template is
3213 instantiated, not while parsing it. For now, we don't
3214 distinguish between dependent and independent names. So, for
3215 example, we look up all overloaded functions at
3216 instantiation-time, even though in some cases we should just use
3217 the DECL we have here. We also use LOOKUP_EXPRs to find things
3218 like local variables, rather than creating TEMPLATE_DECLs for the
3219 local variables and then finding matching instantiations. */
3220 if (current_template_parms
3221 && (is_overloaded_fn (id
)
3222 /* If it's not going to be around at instantiation time, we
3223 look it up then. This is a hack, and should go when we
3224 really get dependent/independent name lookup right. */
3225 || !TREE_PERMANENT (id
)
3226 /* Some local VAR_DECLs (such as those for local variables
3227 in member functions of local classes) are built on the
3228 permanent obstack. */
3229 || (TREE_CODE (id
) == VAR_DECL
3230 && CP_DECL_CONTEXT (id
)
3231 && TREE_CODE (CP_DECL_CONTEXT (id
)) == FUNCTION_DECL
)
3232 || TREE_CODE (id
) == PARM_DECL
3233 || TREE_CODE (id
) == RESULT_DECL
3234 || TREE_CODE (id
) == USING_DECL
))
3235 id
= build_min_nt (LOOKUP_EXPR
, token
);
3241 do_scoped_id (token
, parsing
)
3246 /* during parsing, this is ::name. Otherwise, it is black magic. */
3249 id
= make_node (CPLUS_BINDING
);
3250 if (!qualified_lookup_using_namespace (token
, global_namespace
, id
, 0))
3253 id
= BINDING_VALUE (id
);
3256 id
= IDENTIFIER_GLOBAL_VALUE (token
);
3257 if (parsing
&& yychar
== YYEMPTY
)
3261 if (processing_template_decl
)
3263 id
= build_min_nt (LOOKUP_EXPR
, token
);
3264 LOOKUP_EXPR_GLOBAL (id
) = 1;
3267 if (parsing
&& (yychar
== '(' || yychar
== LEFT_RIGHT
)
3268 && ! flag_strict_prototype
)
3269 id
= implicitly_declare (token
);
3272 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
)
3273 cp_error ("`::%D' undeclared (first use here)", token
);
3274 id
= error_mark_node
;
3275 /* Prevent repeated error messages. */
3276 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
3281 if (TREE_CODE (id
) == ADDR_EXPR
)
3282 mark_used (TREE_OPERAND (id
, 0));
3283 else if (TREE_CODE (id
) != OVERLOAD
)
3286 if (TREE_CODE (id
) == CONST_DECL
&& ! processing_template_decl
)
3288 /* XXX CHS - should we set TREE_USED of the constant? */
3289 id
= DECL_INITIAL (id
);
3290 /* This is to prevent an enum whose value is 0
3291 from being considered a null pointer constant. */
3292 id
= build1 (NOP_EXPR
, TREE_TYPE (id
), id
);
3293 TREE_CONSTANT (id
) = 1;
3296 if (processing_template_decl
)
3298 if (is_overloaded_fn (id
))
3300 id
= build_min_nt (LOOKUP_EXPR
, token
);
3301 LOOKUP_EXPR_GLOBAL (id
) = 1;
3304 /* else just use the decl */
3306 return convert_from_reference (id
);
3310 identifier_typedecl_value (node
)
3314 type
= IDENTIFIER_TYPE_VALUE (node
);
3315 if (type
== NULL_TREE
)
3318 if (IDENTIFIER_BINDING (node
))
3320 t
= IDENTIFIER_VALUE (node
);
3321 if (t
&& TREE_CODE (t
) == TYPE_DECL
&& TREE_TYPE (t
) == type
)
3324 if (IDENTIFIER_NAMESPACE_VALUE (node
))
3326 t
= IDENTIFIER_NAMESPACE_VALUE (node
);
3327 if (t
&& TREE_CODE (t
) == TYPE_DECL
&& TREE_TYPE (t
) == type
)
3331 /* Will this one ever happen? */
3332 if (TYPE_MAIN_DECL (type
))
3333 return TYPE_MAIN_DECL (type
);
3335 /* We used to do an internal error of 62 here, but instead we will
3336 handle the return of a null appropriately in the callers. */
3350 int conversion_errno
;
3351 REAL_VALUE_TYPE value
;
3358 struct pf_args
* args
= (struct pf_args
*) data
;
3359 int fflag
= 0, lflag
= 0;
3360 /* Copy token_buffer now, while it has just the number
3361 and not the suffixes; once we add `f' or `i',
3362 REAL_VALUE_ATOF may not work any more. */
3363 char *copy
= (char *) alloca (args
->p
- token_buffer
+ 1);
3364 bcopy (token_buffer
, copy
, args
->p
- token_buffer
+ 1);
3366 args
->conversion_errno
= 0;
3367 args
->type
= double_type_node
;
3373 /* Read the suffixes to choose a data type. */
3378 error ("more than one `f' in numeric constant");
3384 error ("more than one `l' in numeric constant");
3390 error ("more than one `i' or `j' in numeric constant");
3392 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3403 if (args
->p
>= token_buffer
+ maxtoken
- 3)
3404 args
->p
= extend_token_buffer (args
->p
);
3405 *(args
->p
++) = args
->c
;
3410 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3411 tells the desired precision of the binary result
3412 of decimal-to-binary conversion. */
3417 error ("both `f' and `l' in floating constant");
3419 args
->type
= float_type_node
;
3421 if (args
->base
== 16)
3422 args
->value
= REAL_VALUE_HTOF (copy
, TYPE_MODE (args
->type
));
3424 args
->value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (args
->type
));
3425 args
->conversion_errno
= errno
;
3426 /* A diagnostic is required here by some ANSI C testsuites.
3427 This is not pedwarn, because some people don't want
3428 an error for this. */
3429 if (REAL_VALUE_ISINF (args
->value
) && pedantic
)
3430 warning ("floating point number exceeds range of `float'");
3434 args
->type
= long_double_type_node
;
3436 if (args
->base
== 16)
3437 args
->value
= REAL_VALUE_HTOF (copy
, TYPE_MODE (args
->type
));
3439 args
->value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (args
->type
));
3440 args
->conversion_errno
= errno
;
3441 if (REAL_VALUE_ISINF (args
->value
) && pedantic
)
3442 warning ("floating point number exceeds range of `long double'");
3447 if (args
->base
== 16)
3448 args
->value
= REAL_VALUE_HTOF (copy
, TYPE_MODE (args
->type
));
3450 args
->value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (args
->type
));
3451 args
->conversion_errno
= errno
;
3452 if (REAL_VALUE_ISINF (args
->value
) && pedantic
)
3453 warning ("floating point number exceeds range of `double'");
3457 /* Get the next character, staying within the current token if possible.
3458 If we're lexing a token, we don't want to look beyond the end of the
3459 token cpplib has prepared for us; otherwise, we end up reading in the
3460 next token, which screws up feed_input. So just return a null
3467 if (yy_cur
== yy_lim
)
3484 /* Read a single token from the input stream, and assign it lexical
3487 Note: We used to do token pasting here, to produce compound tokens like
3488 LEFT_RIGHT and EXTERN_LANG_STRING. That's now handled in spew.c, along
3489 with symbol table interaction and other context-sensitivity. */
3501 /* Effectively do c = skip_white_space (c)
3502 but do it faster in the usual cases. */
3512 if (cpp_token
== CPP_HSPACE
)
3513 c
= yy_get_token ();
3520 /* Call skip_white_space so we can warn if appropriate. */
3525 c
= skip_white_space (c
);
3527 goto found_nonwhite
;
3531 token_buffer
[0] = c
;
3532 token_buffer
[1] = 0;
3534 /* yylloc.first_line = lineno; */
3540 token_buffer
[0] = 0;
3542 value
= END_OF_LINE
;
3543 else if (input_redirected ())
3544 value
= END_OF_SAVED_INPUT
;
3551 if (cpp_token
== CPP_NAME
)
3554 /* Capital L may start a wide-string or wide-character constant. */
3556 register int c
= token_getch ();
3565 goto string_constant
;
3570 case 'A': case 'B': case 'C': case 'D': case 'E':
3571 case 'F': case 'G': case 'H': case 'I': case 'J':
3572 case 'K': case 'M': case 'N': case 'O':
3573 case 'P': case 'Q': case 'R': case 'S': case 'T':
3574 case 'U': case 'V': case 'W': case 'X': case 'Y':
3576 case 'a': case 'b': case 'c': case 'd': case 'e':
3577 case 'f': case 'g': case 'h': case 'i': case 'j':
3578 case 'k': case 'l': case 'm': case 'n': case 'o':
3579 case 'p': case 'q': case 'r': case 's': case 't':
3580 case 'u': case 'v': case 'w': case 'x': case 'y':
3586 if (cpp_token
== CPP_NAME
)
3588 /* Note that one character has already been read from
3589 yy_cur into token_buffer. Also, cpplib complains about
3590 $ in identifiers, so we don't have to. */
3592 int len
= yy_lim
- yy_cur
+ 1;
3593 if (len
>= maxtoken
)
3594 extend_token_buffer_to (len
+ 1);
3595 memcpy (token_buffer
+ 1, yy_cur
, len
);
3596 p
= token_buffer
+ len
;
3603 while (ISALNUM (c
) || (c
== '_') || c
== '$')
3605 /* Make sure this char really belongs in an identifier. */
3608 if (! dollars_in_ident
)
3609 error ("`$' in identifier");
3611 pedwarn ("`$' in identifier");
3614 if (p
>= token_buffer
+ maxtoken
)
3615 p
= extend_token_buffer (p
);
3628 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3631 register struct resword
*ptr
;
3633 if ((ptr
= is_reserved_word (token_buffer
, p
- token_buffer
)))
3637 if (ptr
->token
== VISSPEC
)
3642 yylval
.ttype
= access_public_node
;
3645 yylval
.ttype
= access_private_node
;
3648 yylval
.ttype
= access_protected_node
;
3651 my_friendly_abort (63);
3655 yylval
.ttype
= ridpointers
[(int) ptr
->rid
];
3657 else switch (ptr
->token
)
3660 yylval
.code
= NE_EXPR
;
3661 token_buffer
[0] = '!';
3662 token_buffer
[1] = '=';
3663 token_buffer
[2] = 0;
3667 if (strcmp ("and_eq", token_buffer
) == 0)
3669 yylval
.code
= BIT_AND_EXPR
;
3670 token_buffer
[0] = '&';
3672 else if (strcmp ("or_eq", token_buffer
) == 0)
3674 yylval
.code
= BIT_IOR_EXPR
;
3675 token_buffer
[0] = '|';
3677 else if (strcmp ("xor_eq", token_buffer
) == 0)
3679 yylval
.code
= BIT_XOR_EXPR
;
3680 token_buffer
[0] = '^';
3682 token_buffer
[1] = '=';
3683 token_buffer
[2] = 0;
3687 yylval
.code
= BIT_AND_EXPR
;
3688 token_buffer
[0] = '&';
3689 token_buffer
[1] = 0;
3693 yylval
.code
= BIT_IOR_EXPR
;
3694 token_buffer
[0] = '|';
3695 token_buffer
[1] = 0;
3699 yylval
.code
= BIT_XOR_EXPR
;
3700 token_buffer
[0] = '^';
3701 token_buffer
[1] = 0;
3705 value
= (int) ptr
->token
;
3709 /* If we did not find a keyword, look for an identifier
3712 if (value
== IDENTIFIER
|| value
== TYPESPEC
)
3713 GNU_xref_ref (current_function_decl
, token_buffer
);
3715 if (value
== IDENTIFIER
)
3717 register tree tmp
= get_identifier (token_buffer
);
3719 #if !defined(VMS) && defined(JOINER)
3720 /* Make sure that user does not collide with our internal
3723 && (THIS_NAME_P (tmp
)
3724 || VPTR_NAME_P (tmp
)
3725 || DESTRUCTOR_NAME_P (tmp
)
3726 || VTABLE_NAME_P (tmp
)
3727 || TEMP_NAME_P (tmp
)
3728 || ANON_AGGRNAME_P (tmp
)
3729 || ANON_PARMNAME_P (tmp
)))
3730 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3736 if (value
== NEW
&& ! global_bindings_p ())
3745 if (yy_cur
< yy_lim
)
3748 /* It's hard to preserve tokenization on '.' because
3749 it could be a symbol by itself, or it could be the
3750 start of a floating point number and cpp won't tell us. */
3751 register int c1
= token_getch ();
3752 token_buffer
[1] = c1
;
3756 token_buffer
[2] = 0;
3761 c1
= token_getch ();
3764 token_buffer
[2] = c1
;
3765 token_buffer
[3] = 0;
3769 error ("parse error at `..'");
3773 token_put_back (c1
);
3776 token_put_back (c1
);
3779 token_buffer
[1] = 0;
3783 /* Optimize for most frequent case. */
3788 cond
= (yy_cur
== yy_lim
);
3790 register int c1
= token_getch ();
3791 token_put_back (c1
);
3792 cond
= (! ISALNUM (c1
) && c1
!= '.');
3796 yylval
.ttype
= (c
== '0') ? integer_zero_node
: integer_one_node
;
3802 case '2': case '3': case '4':
3803 case '5': case '6': case '7': case '8': case '9':
3808 int largest_digit
= 0;
3812 /* We actually store only HOST_BITS_PER_CHAR bits in each part.
3813 The code below which fills the parts array assumes that a host
3814 int is at least twice as wide as a host char, and that
3815 HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
3816 Two HOST_WIDE_INTs is the largest int literal we can store.
3817 In order to detect overflow below, the number of parts (TOTAL_PARTS)
3818 must be exactly the number of parts needed to hold the bits
3819 of two HOST_WIDE_INTs. */
3820 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
3821 unsigned int parts
[TOTAL_PARTS
];
3823 enum anon1
{ NOT_FLOAT
, AFTER_POINT
, TOO_MANY_POINTS
, AFTER_EXPON
}
3824 floatflag
= NOT_FLOAT
;
3826 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3834 *p
++ = (c
= token_getch ());
3835 if ((c
== 'x') || (c
== 'X'))
3838 *p
++ = (c
= token_getch ());
3840 /* Leading 0 forces octal unless the 0 is the only digit. */
3841 else if (c
>= '0' && c
<= '9')
3850 /* Read all the digits-and-decimal-points. */
3853 || (ISALNUM (c
) && c
!= 'l' && c
!= 'L'
3854 && c
!= 'u' && c
!= 'U'
3855 && c
!= 'i' && c
!= 'I' && c
!= 'j' && c
!= 'J'
3856 && (floatflag
== NOT_FLOAT
|| ((c
!= 'f') && (c
!= 'F')))))
3860 if (base
== 16 && pedantic
)
3861 pedwarn ("floating constant may not be in radix 16");
3862 if (floatflag
== TOO_MANY_POINTS
)
3863 /* We have already emitted an error. Don't need another. */
3865 else if (floatflag
== AFTER_POINT
|| floatflag
== AFTER_EXPON
)
3867 error ("malformed floating constant");
3868 floatflag
= TOO_MANY_POINTS
;
3869 /* Avoid another error from atof by forcing all characters
3870 from here on to be ignored. */
3874 floatflag
= AFTER_POINT
;
3878 *p
++ = c
= token_getch ();
3879 /* Accept '.' as the start of a floating-point number
3880 only when it is followed by a digit. */
3881 if (p
== token_buffer
+ 2 && !ISDIGIT (c
))
3882 my_friendly_abort (990710);
3886 /* It is not a decimal point.
3887 It should be a digit (perhaps a hex digit). */
3893 else if (base
<= 10)
3895 if (c
== 'e' || c
== 'E')
3898 floatflag
= AFTER_EXPON
;
3899 break; /* start of exponent */
3901 error ("nondigits in number and not hexadecimal");
3904 else if (base
== 16 && (c
== 'p' || c
== 'P'))
3906 floatflag
= AFTER_EXPON
;
3907 break; /* start of exponent */
3917 if (c
>= largest_digit
)
3921 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3923 parts
[count
] *= base
;
3927 += (parts
[count
-1] >> HOST_BITS_PER_CHAR
);
3929 &= (1 << HOST_BITS_PER_CHAR
) - 1;
3935 /* If the highest-order part overflows (gets larger than
3936 a host char will hold) then the whole number has
3937 overflowed. Record this and truncate the highest-order
3939 if (parts
[TOTAL_PARTS
- 1] >> HOST_BITS_PER_CHAR
)
3942 parts
[TOTAL_PARTS
- 1] &= (1 << HOST_BITS_PER_CHAR
) - 1;
3945 if (p
>= token_buffer
+ maxtoken
- 3)
3946 p
= extend_token_buffer (p
);
3947 *p
++ = (c
= token_getch ());
3951 /* This can happen on input like `int i = 0x;' */
3953 error ("numeric constant with no digits");
3955 if (largest_digit
>= base
)
3956 error ("numeric constant contains digits beyond the radix");
3958 /* Remove terminating char from the token buffer and delimit the
3962 if (floatflag
!= NOT_FLOAT
)
3965 int imag
, conversion_errno
;
3966 REAL_VALUE_TYPE value
;
3967 struct pf_args args
;
3969 /* Read explicit exponent if any, and put it in tokenbuf. */
3971 if ((base
== 10 && ((c
== 'e') || (c
== 'E')))
3972 || (base
== 16 && (c
== 'p' || c
== 'P')))
3974 if (p
>= token_buffer
+ maxtoken
- 3)
3975 p
= extend_token_buffer (p
);
3978 if ((c
== '+') || (c
== '-'))
3983 /* Exponent is decimal, even if string is a hex float. */
3985 error ("floating constant exponent has no digits");
3988 if (p
>= token_buffer
+ maxtoken
- 3)
3989 p
= extend_token_buffer (p
);
3994 if (base
== 16 && floatflag
!= AFTER_EXPON
)
3995 error ("hexadecimal floating constant has no exponent");
3999 /* Setup input for parse_float() */
4004 /* Convert string to a double, checking for overflow. */
4005 if (do_float_handler (parse_float
, (PTR
) &args
))
4007 /* Receive output from parse_float() */
4012 /* We got an exception from parse_float() */
4013 error ("floating constant out of range");
4017 /* Receive output from parse_float() */
4021 conversion_errno
= args
.conversion_errno
;
4024 /* ERANGE is also reported for underflow,
4025 so test the value to distinguish overflow from that. */
4026 if (conversion_errno
== ERANGE
&& pedantic
4027 && (REAL_VALUES_LESS (dconst1
, value
)
4028 || REAL_VALUES_LESS (value
, dconstm1
)))
4029 warning ("floating point number exceeds range of `double'");
4032 /* If the result is not a number, assume it must have been
4033 due to some error message above, so silently convert
4035 if (REAL_VALUE_ISNAN (value
))
4038 /* Create a node with determined type and value. */
4040 yylval
.ttype
= build_complex (NULL_TREE
,
4041 convert (type
, integer_zero_node
),
4042 build_real (type
, value
));
4044 yylval
.ttype
= build_real (type
, value
);
4049 HOST_WIDE_INT high
, low
;
4050 int spec_unsigned
= 0;
4052 int spec_long_long
= 0;
4059 if (c
== 'u' || c
== 'U')
4062 error ("two `u's in integer constant");
4065 else if (c
== 'l' || c
== 'L')
4070 error ("three `l's in integer constant");
4071 else if (pedantic
&& ! in_system_header
&& warn_long_long
)
4072 pedwarn ("ANSI C++ forbids long long integer constants");
4077 else if (c
== 'i' || c
== 'j' || c
== 'I' || c
== 'J')
4080 error ("more than one `i' or `j' in numeric constant");
4082 pedwarn ("ANSI C++ forbids imaginary numeric constants");
4087 if (p
>= token_buffer
+ maxtoken
- 3)
4088 p
= extend_token_buffer (p
);
4093 /* If the literal overflowed, pedwarn about it now. */
4097 pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT
* 2);
4100 /* This is simplified by the fact that our constant
4101 is always positive. */
4105 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
; i
++)
4107 high
|= ((HOST_WIDE_INT
) parts
[i
+ (HOST_BITS_PER_WIDE_INT
4108 / HOST_BITS_PER_CHAR
)]
4109 << (i
* HOST_BITS_PER_CHAR
));
4110 low
|= (HOST_WIDE_INT
) parts
[i
] << (i
* HOST_BITS_PER_CHAR
);
4113 yylval
.ttype
= build_int_2 (low
, high
);
4114 TREE_TYPE (yylval
.ttype
) = long_long_unsigned_type_node
;
4116 /* Calculate the ANSI type. */
4117 if (! spec_long
&& ! spec_unsigned
4118 && int_fits_type_p (yylval
.ttype
, integer_type_node
))
4119 type
= integer_type_node
;
4120 else if (! spec_long
&& (base
!= 10 || spec_unsigned
)
4121 && int_fits_type_p (yylval
.ttype
, unsigned_type_node
))
4122 type
= unsigned_type_node
;
4123 else if (! spec_unsigned
&& !spec_long_long
4124 && int_fits_type_p (yylval
.ttype
, long_integer_type_node
))
4125 type
= long_integer_type_node
;
4126 else if (! spec_long_long
4127 && int_fits_type_p (yylval
.ttype
,
4128 long_unsigned_type_node
))
4129 type
= long_unsigned_type_node
;
4130 else if (! spec_unsigned
4131 && int_fits_type_p (yylval
.ttype
,
4132 long_long_integer_type_node
))
4133 type
= long_long_integer_type_node
;
4134 else if (int_fits_type_p (yylval
.ttype
,
4135 long_long_unsigned_type_node
))
4136 type
= long_long_unsigned_type_node
;
4137 else if (! spec_unsigned
4138 && int_fits_type_p (yylval
.ttype
,
4139 widest_integer_literal_type_node
))
4140 type
= widest_integer_literal_type_node
;
4142 type
= widest_unsigned_literal_type_node
;
4144 if (pedantic
&& !spec_long_long
&& !warn
4145 && (TYPE_PRECISION (long_integer_type_node
)
4146 < TYPE_PRECISION (type
)))
4149 pedwarn ("integer constant larger than the maximum value of an unsigned long int");
4152 if (base
== 10 && ! spec_unsigned
&& TREE_UNSIGNED (type
))
4153 warning ("decimal constant is so large that it is unsigned");
4157 if (TYPE_PRECISION (type
)
4158 <= TYPE_PRECISION (integer_type_node
))
4160 = build_complex (NULL_TREE
, integer_zero_node
,
4161 convert (integer_type_node
,
4164 error ("complex integer constant is too wide for `__complex int'");
4167 TREE_TYPE (yylval
.ttype
) = type
;
4170 /* If it's still an integer (not a complex), and it doesn't
4171 fit in the type we choose for it, then pedwarn. */
4174 && TREE_CODE (TREE_TYPE (yylval
.ttype
)) == INTEGER_TYPE
4175 && ! int_fits_type_p (yylval
.ttype
, TREE_TYPE (yylval
.ttype
)))
4176 pedwarn ("integer constant is larger than the maximum value for its type");
4182 if (ISALNUM (c
) || c
== '.' || c
== '_' || c
== '$'
4183 || ((c
== '-' || c
== '+')
4184 && (p
[-1] == 'e' || p
[-1] == 'E')))
4185 error ("missing white space after number `%s'", token_buffer
);
4187 value
= CONSTANT
; break;
4193 register int result
= 0;
4194 register int num_chars
= 0;
4196 unsigned width
= TYPE_PRECISION (char_type_node
);
4198 #ifdef MULTIBYTE_CHARS
4199 int longest_char
= local_mb_cur_max ();
4200 local_mbtowc (NULL_PTR
, NULL_PTR
, 0);
4203 max_chars
= TYPE_PRECISION (integer_type_node
) / width
;
4205 width
= WCHAR_TYPE_SIZE
;
4212 if (c
== '\'' || c
== EOF
)
4219 c
= readescape (&ignore
);
4222 if (width
< HOST_BITS_PER_INT
4223 && (unsigned) c
>= ((unsigned)1 << width
))
4224 pedwarn ("escape sequence out of range for character");
4225 #ifdef MAP_CHARACTER
4227 c
= MAP_CHARACTER (c
);
4233 pedwarn ("ANSI C forbids newline in character constant");
4238 #ifdef MULTIBYTE_CHARS
4242 for (i
= 1; i
<= longest_char
; ++i
)
4244 if (i
> maxtoken
- 4)
4245 extend_token_buffer (token_buffer
);
4247 token_buffer
[i
] = c
;
4248 char_len
= local_mbtowc (& wc
,
4257 /* mbtowc sometimes needs an extra char before accepting */
4262 /* Merge character into result; ignore excess chars. */
4263 for (i
= 1; i
<= char_len
; ++i
)
4267 if (width
< HOST_BITS_PER_INT
)
4268 result
= (result
<< width
)
4270 & ((1 << width
) - 1));
4272 result
= token_buffer
[i
];
4274 num_chars
+= char_len
;
4283 warning ("Ignoring invalid multibyte character");
4284 /* Replace all but the first byte. */
4285 for (--i
; i
> 1; --i
)
4286 token_put_back (token_buffer
[i
]);
4287 wc
= token_buffer
[1];
4289 #ifdef MAP_CHARACTER
4290 c
= MAP_CHARACTER (wc
);
4295 #else /* ! MULTIBYTE_CHARS */
4296 #ifdef MAP_CHARACTER
4297 c
= MAP_CHARACTER (c
);
4299 #endif /* ! MULTIBYTE_CHARS */
4304 if (chars_seen
== 1) /* only keep the first one */
4309 /* Merge character into result; ignore excess chars. */
4310 num_chars
+= (width
/ TYPE_PRECISION (char_type_node
));
4311 if (num_chars
< max_chars
+ 1)
4313 if (width
< HOST_BITS_PER_INT
)
4314 result
= (result
<< width
) | (c
& ((1 << width
) - 1));
4321 error ("malformatted character constant");
4322 else if (chars_seen
== 0)
4323 error ("empty character constant");
4324 else if (num_chars
> max_chars
)
4326 num_chars
= max_chars
;
4327 error ("character constant too long");
4329 else if (chars_seen
!= 1 && warn_multichar
)
4330 warning ("multi-character character constant");
4332 /* If char type is signed, sign-extend the constant. */
4335 int num_bits
= num_chars
* width
;
4337 /* We already got an error; avoid invalid shift. */
4338 yylval
.ttype
= build_int_2 (0, 0);
4339 else if (TREE_UNSIGNED (char_type_node
)
4340 || ((result
>> (num_bits
- 1)) & 1) == 0)
4342 = build_int_2 (result
& (~(unsigned HOST_WIDE_INT
) 0
4343 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
4347 = build_int_2 (result
| ~(~(unsigned HOST_WIDE_INT
) 0
4348 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
4350 /* In C, a character constant has type 'int'; in C++, 'char'. */
4351 if (chars_seen
<= 1)
4352 TREE_TYPE (yylval
.ttype
) = char_type_node
;
4354 TREE_TYPE (yylval
.ttype
) = integer_type_node
;
4358 yylval
.ttype
= build_int_2 (result
, 0);
4359 TREE_TYPE (yylval
.ttype
) = wchar_type_node
;
4369 unsigned width
= wide_flag
? WCHAR_TYPE_SIZE
4370 : TYPE_PRECISION (char_type_node
);
4371 #ifdef MULTIBYTE_CHARS
4372 int longest_char
= local_mb_cur_max ();
4373 local_mbtowc (NULL_PTR
, NULL_PTR
, 0);
4377 p
= token_buffer
+ 1;
4379 while (c
!= '"' && c
!= EOF
)
4381 /* ignore_escape_flag is set for reading the filename in #line. */
4382 if (!ignore_escape_flag
&& c
== '\\')
4385 c
= readescape (&ignore
);
4388 if (width
< HOST_BITS_PER_INT
4389 && (unsigned) c
>= ((unsigned)1 << width
))
4390 pedwarn ("escape sequence out of range for character");
4395 pedwarn ("ANSI C++ forbids newline in string constant");
4400 #ifdef MULTIBYTE_CHARS
4404 for (i
= 0; i
< longest_char
; ++i
)
4406 if (p
+ i
>= token_buffer
+ maxtoken
)
4407 p
= extend_token_buffer (p
);
4410 char_len
= local_mbtowc (& wc
, p
, i
+ 1);
4417 warning ("Ignoring invalid multibyte character");
4418 /* Replace all except the first byte. */
4420 for (--i
; i
> 0; --i
)
4421 token_put_back (p
[i
]);
4424 /* mbtowc sometimes needs an extra char before accepting */
4434 #endif /* MULTIBYTE_CHARS */
4437 /* Add this single character into the buffer either as a wchar_t
4438 or as a single byte. */
4441 unsigned width
= TYPE_PRECISION (char_type_node
);
4442 unsigned bytemask
= (1 << width
) - 1;
4445 if (p
+ WCHAR_BYTES
> token_buffer
+ maxtoken
)
4446 p
= extend_token_buffer (p
);
4448 for (byte
= 0; byte
< WCHAR_BYTES
; ++byte
)
4451 if (byte
>= (int) sizeof (c
))
4454 value
= (c
>> (byte
* width
)) & bytemask
;
4455 if (BYTES_BIG_ENDIAN
)
4456 p
[WCHAR_BYTES
- byte
- 1] = value
;
4464 if (p
>= token_buffer
+ maxtoken
)
4465 p
= extend_token_buffer (p
);
4473 /* Terminate the string value, either with a single byte zero
4474 or with a wide zero. */
4477 if (p
+ WCHAR_BYTES
> token_buffer
+ maxtoken
)
4478 p
= extend_token_buffer (p
);
4479 bzero (p
, WCHAR_BYTES
);
4484 if (p
>= token_buffer
+ maxtoken
)
4485 p
= extend_token_buffer (p
);
4490 error ("Unterminated string constant");
4492 /* We have read the entire constant.
4493 Construct a STRING_CST for the result. */
4495 if (processing_template_decl
)
4496 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4497 yylval
.ttype
= build_string (p
- (token_buffer
+ 1), token_buffer
+ 1);
4498 if (processing_template_decl
)
4502 TREE_TYPE (yylval
.ttype
) = wchar_array_type_node
;
4504 TREE_TYPE (yylval
.ttype
) = char_array_type_node
;
4506 value
= STRING
; break;
4530 yylval
.code
= PLUS_EXPR
; break;
4532 yylval
.code
= MINUS_EXPR
; break;
4534 yylval
.code
= BIT_AND_EXPR
; break;
4536 yylval
.code
= BIT_IOR_EXPR
; break;
4538 yylval
.code
= MULT_EXPR
; break;
4540 yylval
.code
= TRUNC_DIV_EXPR
; break;
4542 yylval
.code
= TRUNC_MOD_EXPR
; break;
4544 yylval
.code
= BIT_XOR_EXPR
; break;
4546 yylval
.code
= LSHIFT_EXPR
; break;
4548 yylval
.code
= RSHIFT_EXPR
; break;
4550 yylval
.code
= LT_EXPR
; break;
4552 yylval
.code
= GT_EXPR
; break;
4555 token_buffer
[1] = c1
= token_getch ();
4556 token_buffer
[2] = 0;
4563 value
= ARITHCOMPARE
; yylval
.code
= LE_EXPR
; goto done
;
4565 value
= ARITHCOMPARE
; yylval
.code
= GE_EXPR
; goto done
;
4567 value
= EQCOMPARE
; yylval
.code
= NE_EXPR
; goto done
;
4569 value
= EQCOMPARE
; yylval
.code
= EQ_EXPR
; goto done
;
4571 value
= ASSIGN
; goto done
;
4577 value
= PLUSPLUS
; goto done
;
4579 value
= MINUSMINUS
; goto done
;
4581 value
= ANDAND
; goto done
;
4583 value
= OROR
; goto done
;
4595 else if (c1
== '?' && (c
== '<' || c
== '>'))
4597 token_buffer
[3] = 0;
4599 c1
= token_getch ();
4600 yylval
.code
= (c
== '<' ? MIN_EXPR
: MAX_EXPR
);
4603 /* <?= or >?= expression. */
4604 token_buffer
[2] = c1
;
4610 token_put_back (c1
);
4613 pedwarn ("use of `operator %s' is not standard C++",
4623 c1
= token_getch ();
4625 value
= POINTSAT_STAR
;
4628 token_put_back (c1
);
4638 { value
= ']'; goto done
; }
4642 { value
= '{'; indent_level
++; goto done
; }
4644 { value
= '['; goto done
; }
4648 { value
= '}'; indent_level
--; goto done
; }
4652 token_put_back (c1
);
4653 token_buffer
[1] = 0;
4655 /* Here the C frontend changes < and > to ARITHCOMPARE. We don't
4656 do that because of templates. */
4663 /* Don't make yyparse think this is eof. */
4682 /* yylloc.last_line = lineno; */
4683 #ifdef GATHER_STATISTICS
4684 #ifdef REDUCE_LENGTH
4685 token_count
[value
] += 1;
4696 return !!is_reserved_word (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
4699 #ifdef GATHER_STATISTICS
4700 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4701 need to be brought into here, unless this were actually put into a header
4703 /* Statistics-gathering stuff. */
4724 extern int tree_node_counts
[];
4725 extern int tree_node_sizes
[];
4729 build_lang_decl (code
, name
, type
)
4730 enum tree_code code
;
4736 t
= build_decl (code
, name
, type
);
4737 retrofit_lang_decl (t
);
4742 /* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
4743 and pushdecl (for functions generated by the backend). */
4746 retrofit_lang_decl (t
)
4749 struct lang_decl
*ld
;
4752 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
4753 size
= sizeof (struct lang_decl
);
4755 size
= sizeof (struct lang_decl_flags
);
4757 ld
= (struct lang_decl
*) ggc_alloc (size
);
4758 memset (ld
, 0, size
);
4760 DECL_LANG_SPECIFIC (t
) = ld
;
4761 if (current_lang_name
== lang_name_cplusplus
)
4762 DECL_LANGUAGE (t
) = lang_cplusplus
;
4763 else if (current_lang_name
== lang_name_c
)
4764 DECL_LANGUAGE (t
) = lang_c
;
4765 else if (current_lang_name
== lang_name_java
)
4766 DECL_LANGUAGE (t
) = lang_java
;
4767 else my_friendly_abort (64);
4769 if (CAN_HAVE_FULL_LANG_DECL_P (t
))
4770 DECL_MAIN_VARIANT (t
) = t
;
4772 #ifdef GATHER_STATISTICS
4773 tree_node_counts
[(int)lang_decl
] += 1;
4774 tree_node_sizes
[(int)lang_decl
] += size
;
4779 copy_lang_decl (node
)
4783 struct lang_decl
*ld
;
4785 if (! DECL_LANG_SPECIFIC (node
))
4788 if (!CAN_HAVE_FULL_LANG_DECL_P (node
))
4789 size
= sizeof (struct lang_decl_flags
);
4791 size
= sizeof (struct lang_decl
);
4792 ld
= (struct lang_decl
*) ggc_alloc (size
);
4793 bcopy ((char *)DECL_LANG_SPECIFIC (node
), (char *)ld
, size
);
4794 DECL_LANG_SPECIFIC (node
) = ld
;
4798 cp_make_lang_type (code
)
4799 enum tree_code code
;
4801 register tree t
= make_node (code
);
4803 /* Set up some flags that give proper default behavior. */
4804 if (IS_AGGR_TYPE_CODE (code
))
4806 struct lang_type
*pi
;
4808 SET_IS_AGGR_TYPE (t
, 1);
4810 pi
= (struct lang_type
*) ggc_alloc (sizeof (struct lang_type
));
4811 bzero ((char *) pi
, (int) sizeof (struct lang_type
));
4813 TYPE_LANG_SPECIFIC (t
) = pi
;
4814 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, interface_unknown
);
4815 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
4817 /* Make sure this is laid out, for ease of use later. In the
4818 presence of parse errors, the normal was of assuring this
4819 might not ever get executed, so we lay it out *immediately*. */
4820 build_pointer_type (t
);
4822 #ifdef GATHER_STATISTICS
4823 tree_node_counts
[(int)lang_type
] += 1;
4824 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
4828 /* We use TYPE_ALIAS_SET for the CLASSTYPE_MARKED bits. But,
4829 TYPE_ALIAS_SET is initialized to -1 by default, so we must
4831 TYPE_ALIAS_SET (t
) = 0;
4833 /* We need to allocate a TYPE_BINFO even for TEMPLATE_TYPE_PARMs
4834 since they can be virtual base types, and we then need a
4835 canonical binfo for them. Ideally, this would be done lazily for
4837 if (IS_AGGR_TYPE_CODE (code
) || code
== TEMPLATE_TYPE_PARM
)
4838 TYPE_BINFO (t
) = make_binfo (integer_zero_node
, t
, NULL_TREE
, NULL_TREE
);
4844 dump_time_statistics ()
4846 register tree prev
= 0, decl
, next
;
4847 int this_time
= my_get_run_time ();
4848 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (this_filename_time
))
4849 += this_time
- body_time
;
4851 fprintf (stderr
, "\n******\n");
4852 print_time ("header files (total)", header_time
);
4853 print_time ("main file (total)", this_time
- body_time
);
4854 fprintf (stderr
, "ratio = %g : 1\n",
4855 (double)header_time
/ (double)(this_time
- body_time
));
4856 fprintf (stderr
, "\n******\n");
4858 for (decl
= filename_times
; decl
; decl
= next
)
4860 next
= IDENTIFIER_GLOBAL_VALUE (decl
);
4861 SET_IDENTIFIER_GLOBAL_VALUE (decl
, prev
);
4865 for (decl
= prev
; decl
; decl
= IDENTIFIER_GLOBAL_VALUE (decl
))
4866 print_time (IDENTIFIER_POINTER (decl
),
4867 TREE_INT_CST_LOW (TIME_IDENTIFIER_TIME (decl
)));
4871 compiler_error
VPROTO ((const char *msg
, ...))
4873 #ifndef ANSI_PROTOTYPES
4881 #ifndef ANSI_PROTOTYPES
4882 msg
= va_arg (ap
, const char *);
4885 vsprintf (buf
, msg
, ap
);
4887 error_with_file_and_line (input_filename
, lineno
, "%s (compiler error)", buf
);
4890 /* Return the type-qualifier corresponding to the identifier given by
4894 cp_type_qual_from_rid (rid
)
4897 if (rid
== ridpointers
[(int) RID_CONST
])
4898 return TYPE_QUAL_CONST
;
4899 else if (rid
== ridpointers
[(int) RID_VOLATILE
])
4900 return TYPE_QUAL_VOLATILE
;
4901 else if (rid
== ridpointers
[(int) RID_RESTRICT
])
4902 return TYPE_QUAL_RESTRICT
;
4904 my_friendly_abort (0);
4905 return TYPE_UNQUALIFIED
;