1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-97, 1998 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file is the lexical analyzer for GNU C++. */
25 /* Cause the `yydebug' variable to be defined. */
41 /* MULTIBYTE_CHARS support only works for native compilers.
42 ??? Ideally what we want is to model widechar support after
43 the current floating point support. */
45 #undef MULTIBYTE_CHARS
48 #ifdef MULTIBYTE_CHARS
52 #define obstack_chunk_alloc xmalloc
53 #define obstack_chunk_free free
56 #define DIR_SEPARATOR '/'
59 extern struct obstack permanent_obstack
;
60 extern struct obstack
*current_obstack
, *saveable_obstack
;
62 extern void yyprint
PROTO((FILE *, int, YYSTYPE
));
63 extern void set_float_handler
PROTO((jmp_buf));
64 extern void compiler_error
PROTO((char *, HOST_WIDE_INT
,
67 static tree get_time_identifier
PROTO((char *));
68 static int check_newline
PROTO((void));
69 static int skip_white_space
PROTO((int));
70 static void finish_defarg
PROTO((void));
71 static int my_get_run_time
PROTO((void));
72 static int get_last_nonwhite_on_line
PROTO((void));
73 static int interface_strcmp
PROTO((char *));
74 static int readescape
PROTO((int *));
75 static char *extend_token_buffer
PROTO((char *));
76 static void consume_string
PROTO((struct obstack
*, int));
77 static void set_typedecl_interface_info
PROTO((tree
, tree
));
78 static void feed_defarg
PROTO((tree
, tree
));
79 static int set_vardecl_interface_info
PROTO((tree
, tree
));
80 static void store_pending_inline
PROTO((tree
, struct pending_inline
*));
81 static void reinit_parse_for_expr
PROTO((struct obstack
*));
82 static int *init_cpp_parse
PROTO((void));
83 static int handle_cp_pragma
PROTO((char *));
84 #ifdef HANDLE_SYSV_PRAGMA
85 static int handle_sysv_pragma
PROTO((FILE *, int));
87 #ifdef GATHER_STATISTICS
89 static int reduce_cmp
PROTO((int *, int *));
90 static int token_cmp
PROTO((int *, int *));
94 /* Given a file name X, return the nondirectory portion.
95 Keep in mind that X can be computed more than once. */
97 file_name_nondirectory (x
)
100 char *tmp
= (char *) rindex (x
, '/');
101 if (DIR_SEPARATOR
!= '/' && ! tmp
)
102 tmp
= (char *) rindex (x
, DIR_SEPARATOR
);
104 return (char *) (tmp
+ 1);
109 /* This obstack is needed to hold text. It is not safe to use
110 TOKEN_BUFFER because `check_newline' calls `yylex'. */
111 struct obstack inline_text_obstack
;
112 char *inline_text_firstobj
;
119 /* Pending language change.
120 Positive is push count, negative is pop count. */
121 int pending_lang_change
= 0;
123 /* Wrap the current header file in extern "C". */
124 static int c_header_level
= 0;
126 extern int first_token
;
127 extern struct obstack token_obstack
;
129 /* ??? Don't really know where this goes yet. */
133 extern void put_back (/* int */);
134 extern int input_redirected ();
135 extern void feed_input (/* char *, int */);
138 /* Holds translations from TREE_CODEs to operator name strings,
139 i.e., opname_tab[PLUS_EXPR] == "+". */
143 extern int yychar
; /* the lookahead symbol */
144 extern YYSTYPE yylval
; /* the semantic value of the */
145 /* lookahead symbol */
148 YYLTYPE yylloc
; /* location data for the lookahead */
153 /* the declaration found for the last IDENTIFIER token read in.
154 yylex must look this up to detect typedefs, which get token type TYPENAME,
155 so it is left around in case the identifier is not a typedef but is
156 used in a context which makes it a reference to a variable. */
159 /* The elements of `ridpointers' are identifier nodes
160 for the reserved type names and storage classes.
161 It is indexed by a RID_... value. */
162 tree ridpointers
[(int) RID_MAX
];
164 /* We may keep statistics about how long which files took to compile. */
165 static int header_time
, body_time
;
166 static tree filename_times
;
167 static tree this_filename_time
;
169 /* Array for holding counts of the numbers of tokens seen. */
170 extern int *token_count
;
172 /* Return something to represent absolute declarators containing a *.
173 TARGET is the absolute declarator that the * contains.
174 CV_QUALIFIERS is a list of modifiers such as const or volatile
175 to apply to the pointer type, represented as identifiers.
177 We return an INDIRECT_REF whose "contents" are TARGET
178 and whose type is the modifier list. */
181 make_pointer_declarator (cv_qualifiers
, target
)
182 tree cv_qualifiers
, target
;
184 if (target
&& TREE_CODE (target
) == IDENTIFIER_NODE
185 && ANON_AGGRNAME_P (target
))
186 error ("type name expected before `*'");
187 target
= build_parse_node (INDIRECT_REF
, target
);
188 TREE_TYPE (target
) = cv_qualifiers
;
192 /* Return something to represent absolute declarators containing a &.
193 TARGET is the absolute declarator that the & contains.
194 CV_QUALIFIERS is a list of modifiers such as const or volatile
195 to apply to the reference type, represented as identifiers.
197 We return an ADDR_EXPR whose "contents" are TARGET
198 and whose type is the modifier list. */
201 make_reference_declarator (cv_qualifiers
, target
)
202 tree cv_qualifiers
, target
;
206 if (TREE_CODE (target
) == ADDR_EXPR
)
208 error ("cannot declare references to references");
211 if (TREE_CODE (target
) == INDIRECT_REF
)
213 error ("cannot declare pointers to references");
216 if (TREE_CODE (target
) == IDENTIFIER_NODE
&& ANON_AGGRNAME_P (target
))
217 error ("type name expected before `&'");
219 target
= build_parse_node (ADDR_EXPR
, target
);
220 TREE_TYPE (target
) = cv_qualifiers
;
225 make_call_declarator (target
, parms
, cv_qualifiers
, exception_specification
)
226 tree target
, parms
, cv_qualifiers
, exception_specification
;
228 target
= build_parse_node (CALL_EXPR
, target
, parms
, cv_qualifiers
);
229 TREE_TYPE (target
) = exception_specification
;
234 set_quals_and_spec (call_declarator
, cv_qualifiers
, exception_specification
)
235 tree call_declarator
, cv_qualifiers
, exception_specification
;
237 TREE_OPERAND (call_declarator
, 2) = cv_qualifiers
;
238 TREE_TYPE (call_declarator
) = exception_specification
;
241 /* Build names and nodes for overloaded operators. */
243 tree ansi_opname
[LAST_CPLUS_TREE_CODE
];
244 tree ansi_assopname
[LAST_CPLUS_TREE_CODE
];
247 operator_name_string (name
)
250 char *opname
= IDENTIFIER_POINTER (name
) + 2;
254 /* Works for builtin and user defined types. */
255 if (IDENTIFIER_GLOBAL_VALUE (name
)
256 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name
)) == TYPE_DECL
)
257 return IDENTIFIER_POINTER (name
);
259 if (opname
[0] == 'a' && opname
[2] != '\0' && opname
[2] != '_')
263 opname_table
= ansi_assopname
;
268 opname_table
= ansi_opname
;
271 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
273 if (opname
[0] == IDENTIFIER_POINTER (opname_table
[i
])[2+assign
]
274 && opname
[1] == IDENTIFIER_POINTER (opname_table
[i
])[3+assign
])
278 if (i
== LAST_CPLUS_TREE_CODE
)
279 return "<invalid operator>";
282 return assignop_tab
[i
];
284 return opname_tab
[i
];
287 int interface_only
; /* whether or not current file is only for
288 interface definitions. */
289 int interface_unknown
; /* whether or not we know this class
290 to behave according to #pragma interface. */
292 /* lexical analyzer */
294 /* File used for outputting assembler code. */
295 extern FILE *asm_out_file
;
297 #ifndef WCHAR_TYPE_SIZE
299 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
301 #define WCHAR_TYPE_SIZE BITS_PER_WORD
305 /* Number of bytes in a wide character. */
306 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
308 static int maxtoken
; /* Current nominal length of token buffer. */
309 char *token_buffer
; /* Pointer to token buffer.
310 Actual allocated length is maxtoken + 2. */
315 /* Nonzero tells yylex to ignore \ in string constants. */
316 static int ignore_escape_flag
= 0;
319 get_time_identifier (name
)
322 tree time_identifier
;
323 int len
= strlen (name
);
324 char *buf
= (char *) alloca (len
+ 6);
325 strcpy (buf
, "file ");
326 bcopy (name
, buf
+5, len
);
328 time_identifier
= get_identifier (buf
);
329 if (IDENTIFIER_LOCAL_VALUE (time_identifier
) == NULL_TREE
)
331 push_obstacks_nochange ();
332 end_temporary_allocation ();
333 IDENTIFIER_LOCAL_VALUE (time_identifier
) = build_int_2 (0, 0);
334 IDENTIFIER_CLASS_VALUE (time_identifier
) = build_int_2 (0, 1);
335 SET_IDENTIFIER_GLOBAL_VALUE (time_identifier
, filename_times
);
336 filename_times
= time_identifier
;
339 return time_identifier
;
348 int old_quiet_flag
= quiet_flag
;
351 this_time
= get_run_time ();
352 quiet_flag
= old_quiet_flag
;
356 /* Table indexed by tree code giving a string containing a character
357 classifying the tree code. Possibilities are
358 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
360 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
362 char cplus_tree_code_type
[] = {
364 #include "cp-tree.def"
368 /* Table indexed by tree code giving number of expression
369 operands beyond the fixed part of the node structure.
370 Not used for types or decls. */
372 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
374 int cplus_tree_code_length
[] = {
376 #include "cp-tree.def"
380 /* Names of tree components.
381 Used for printing out the tree and error messages. */
382 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
384 char *cplus_tree_code_name
[] = {
386 #include "cp-tree.def"
390 /* toplev.c needs to call these. */
395 /* the beginning of the file is a new line; check for # */
396 /* With luck, we discover the real source file's name from that
397 and put it in input_filename. */
398 put_back (check_newline ());
399 if (flag_gnu_xref
) GNU_xref_begin (input_filename
);
400 init_repo (input_filename
);
402 /* See comments in toplev.c before the call to lang_init. */
403 if (flag_exceptions
== 2)
410 extern int errorcount
, sorrycount
;
411 if (flag_gnu_xref
) GNU_xref_end (errorcount
+sorrycount
);
421 init_filename_times ()
423 this_filename_time
= get_time_identifier ("<top level>");
424 if (flag_detailed_statistics
)
427 body_time
= my_get_run_time ();
428 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
)) = body_time
;
432 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
433 Stuck this hack in to get the files open correctly; this is called
434 in place of init_parse if we are an unexec'd binary. */
438 reinit_lang_specific ()
440 init_filename_times ();
441 reinit_search_statistics ();
448 #ifdef GATHER_STATISTICS
450 reduce_count
= (int *)malloc (sizeof (int) * (REDUCE_LENGTH
+ 1));
451 bzero (reduce_count
, sizeof (int) * (REDUCE_LENGTH
+ 1));
453 token_count
= (int *)malloc (sizeof (int) * (TOKEN_LENGTH
+ 1));
454 bzero (token_count
, sizeof (int) * (TOKEN_LENGTH
+ 1));
462 init_parse (filename
)
465 extern int flag_no_gnu_keywords
;
466 extern int flag_operator_names
;
471 /* Open input file. */
472 if (filename
== 0 || !strcmp (filename
, "-"))
478 finput
= fopen (filename
, "r");
480 pfatal_with_name (filename
);
482 #ifdef IO_BUFFER_SIZE
483 setvbuf (finput
, (char *) xmalloc (IO_BUFFER_SIZE
), _IOFBF
, IO_BUFFER_SIZE
);
485 #endif /* !USE_CPPLIB */
487 /* Initialize the lookahead machinery. */
490 /* Make identifier nodes long enough for the language-specific slots. */
491 set_identifier_size (sizeof (struct lang_identifier
));
492 decl_printable_name
= lang_printable_name
;
494 init_cplus_expand ();
496 bcopy (cplus_tree_code_type
,
497 tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
498 (int)LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
);
499 bcopy ((char *)cplus_tree_code_length
,
500 (char *)(tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
),
501 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
502 bcopy ((char *)cplus_tree_code_name
,
503 (char *)(tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
),
504 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
506 opname_tab
= (char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
507 bzero ((char *)opname_tab
, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
508 assignop_tab
= (char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
509 bzero ((char *)assignop_tab
, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
511 ansi_opname
[0] = get_identifier ("<invalid operator>");
512 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
514 ansi_opname
[i
] = ansi_opname
[0];
515 ansi_assopname
[i
] = ansi_opname
[0];
518 ansi_opname
[(int) MULT_EXPR
] = get_identifier ("__ml");
519 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MULT_EXPR
]) = 1;
520 ansi_opname
[(int) INDIRECT_REF
] = ansi_opname
[(int) MULT_EXPR
];
521 ansi_assopname
[(int) MULT_EXPR
] = get_identifier ("__aml");
522 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MULT_EXPR
]) = 1;
523 ansi_assopname
[(int) INDIRECT_REF
] = ansi_assopname
[(int) MULT_EXPR
];
524 ansi_opname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__md");
525 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUNC_MOD_EXPR
]) = 1;
526 ansi_assopname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__amd");
527 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) TRUNC_MOD_EXPR
]) = 1;
528 ansi_opname
[(int) CEIL_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
529 ansi_opname
[(int) FLOOR_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
530 ansi_opname
[(int) ROUND_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
531 ansi_opname
[(int) MINUS_EXPR
] = get_identifier ("__mi");
532 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MINUS_EXPR
]) = 1;
533 ansi_opname
[(int) NEGATE_EXPR
] = ansi_opname
[(int) MINUS_EXPR
];
534 ansi_assopname
[(int) MINUS_EXPR
] = get_identifier ("__ami");
535 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MINUS_EXPR
]) = 1;
536 ansi_assopname
[(int) NEGATE_EXPR
] = ansi_assopname
[(int) MINUS_EXPR
];
537 ansi_opname
[(int) RSHIFT_EXPR
] = get_identifier ("__rs");
538 IDENTIFIER_OPNAME_P (ansi_opname
[(int) RSHIFT_EXPR
]) = 1;
539 ansi_assopname
[(int) RSHIFT_EXPR
] = get_identifier ("__ars");
540 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) RSHIFT_EXPR
]) = 1;
541 ansi_opname
[(int) NE_EXPR
] = get_identifier ("__ne");
542 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NE_EXPR
]) = 1;
543 ansi_opname
[(int) GT_EXPR
] = get_identifier ("__gt");
544 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GT_EXPR
]) = 1;
545 ansi_opname
[(int) GE_EXPR
] = get_identifier ("__ge");
546 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GE_EXPR
]) = 1;
547 ansi_opname
[(int) BIT_IOR_EXPR
] = get_identifier ("__or");
548 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_IOR_EXPR
]) = 1;
549 ansi_assopname
[(int) BIT_IOR_EXPR
] = get_identifier ("__aor");
550 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_IOR_EXPR
]) = 1;
551 ansi_opname
[(int) TRUTH_ANDIF_EXPR
] = get_identifier ("__aa");
552 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ANDIF_EXPR
]) = 1;
553 ansi_opname
[(int) TRUTH_NOT_EXPR
] = get_identifier ("__nt");
554 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_NOT_EXPR
]) = 1;
555 ansi_opname
[(int) PREINCREMENT_EXPR
] = get_identifier ("__pp");
556 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREINCREMENT_EXPR
]) = 1;
557 ansi_opname
[(int) POSTINCREMENT_EXPR
] = ansi_opname
[(int) PREINCREMENT_EXPR
];
558 ansi_opname
[(int) MODIFY_EXPR
] = get_identifier ("__as");
559 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MODIFY_EXPR
]) = 1;
560 ansi_assopname
[(int) NOP_EXPR
] = ansi_opname
[(int) MODIFY_EXPR
];
561 ansi_opname
[(int) COMPOUND_EXPR
] = get_identifier ("__cm");
562 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPOUND_EXPR
]) = 1;
563 ansi_opname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__dv");
564 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EXACT_DIV_EXPR
]) = 1;
565 ansi_assopname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__adv");
566 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) EXACT_DIV_EXPR
]) = 1;
567 ansi_opname
[(int) TRUNC_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
568 ansi_opname
[(int) CEIL_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
569 ansi_opname
[(int) FLOOR_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
570 ansi_opname
[(int) ROUND_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
571 ansi_opname
[(int) PLUS_EXPR
] = get_identifier ("__pl");
572 ansi_assopname
[(int) TRUNC_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
573 ansi_assopname
[(int) CEIL_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
574 ansi_assopname
[(int) FLOOR_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
575 ansi_assopname
[(int) ROUND_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
576 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PLUS_EXPR
]) = 1;
577 ansi_assopname
[(int) PLUS_EXPR
] = get_identifier ("__apl");
578 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) PLUS_EXPR
]) = 1;
579 ansi_opname
[(int) CONVERT_EXPR
] = ansi_opname
[(int) PLUS_EXPR
];
580 ansi_assopname
[(int) CONVERT_EXPR
] = ansi_assopname
[(int) PLUS_EXPR
];
581 ansi_opname
[(int) LSHIFT_EXPR
] = get_identifier ("__ls");
582 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LSHIFT_EXPR
]) = 1;
583 ansi_assopname
[(int) LSHIFT_EXPR
] = get_identifier ("__als");
584 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) LSHIFT_EXPR
]) = 1;
585 ansi_opname
[(int) EQ_EXPR
] = get_identifier ("__eq");
586 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EQ_EXPR
]) = 1;
587 ansi_opname
[(int) LT_EXPR
] = get_identifier ("__lt");
588 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LT_EXPR
]) = 1;
589 ansi_opname
[(int) LE_EXPR
] = get_identifier ("__le");
590 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LE_EXPR
]) = 1;
591 ansi_opname
[(int) BIT_AND_EXPR
] = get_identifier ("__ad");
592 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_AND_EXPR
]) = 1;
593 ansi_assopname
[(int) BIT_AND_EXPR
] = get_identifier ("__aad");
594 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_AND_EXPR
]) = 1;
595 ansi_opname
[(int) ADDR_EXPR
] = ansi_opname
[(int) BIT_AND_EXPR
];
596 ansi_assopname
[(int) ADDR_EXPR
] = ansi_assopname
[(int) BIT_AND_EXPR
];
597 ansi_opname
[(int) BIT_XOR_EXPR
] = get_identifier ("__er");
598 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_XOR_EXPR
]) = 1;
599 ansi_assopname
[(int) BIT_XOR_EXPR
] = get_identifier ("__aer");
600 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_XOR_EXPR
]) = 1;
601 ansi_opname
[(int) TRUTH_ORIF_EXPR
] = get_identifier ("__oo");
602 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ORIF_EXPR
]) = 1;
603 ansi_opname
[(int) BIT_NOT_EXPR
] = get_identifier ("__co");
604 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_NOT_EXPR
]) = 1;
605 ansi_opname
[(int) PREDECREMENT_EXPR
] = get_identifier ("__mm");
606 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREDECREMENT_EXPR
]) = 1;
607 ansi_opname
[(int) POSTDECREMENT_EXPR
] = ansi_opname
[(int) PREDECREMENT_EXPR
];
608 ansi_opname
[(int) COMPONENT_REF
] = get_identifier ("__rf");
609 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPONENT_REF
]) = 1;
610 ansi_opname
[(int) MEMBER_REF
] = get_identifier ("__rm");
611 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MEMBER_REF
]) = 1;
612 ansi_opname
[(int) CALL_EXPR
] = get_identifier ("__cl");
613 IDENTIFIER_OPNAME_P (ansi_opname
[(int) CALL_EXPR
]) = 1;
614 ansi_opname
[(int) ARRAY_REF
] = get_identifier ("__vc");
615 IDENTIFIER_OPNAME_P (ansi_opname
[(int) ARRAY_REF
]) = 1;
616 ansi_opname
[(int) NEW_EXPR
] = get_identifier ("__nw");
617 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NEW_EXPR
]) = 1;
618 ansi_opname
[(int) DELETE_EXPR
] = get_identifier ("__dl");
619 IDENTIFIER_OPNAME_P (ansi_opname
[(int) DELETE_EXPR
]) = 1;
620 ansi_opname
[(int) VEC_NEW_EXPR
] = get_identifier ("__vn");
621 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_NEW_EXPR
]) = 1;
622 ansi_opname
[(int) VEC_DELETE_EXPR
] = get_identifier ("__vd");
623 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_DELETE_EXPR
]) = 1;
624 ansi_opname
[(int) TYPE_EXPR
] = get_identifier ("__op");
625 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TYPE_EXPR
]) = 1;
627 /* This is not true: these operators are not defined in ANSI,
628 but we need them anyway. */
629 ansi_opname
[(int) MIN_EXPR
] = get_identifier ("__mn");
630 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MIN_EXPR
]) = 1;
631 ansi_opname
[(int) MAX_EXPR
] = get_identifier ("__mx");
632 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MAX_EXPR
]) = 1;
633 ansi_opname
[(int) COND_EXPR
] = get_identifier ("__cn");
634 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COND_EXPR
]) = 1;
635 ansi_opname
[(int) SIZEOF_EXPR
] = get_identifier ("__sz");
636 IDENTIFIER_OPNAME_P (ansi_opname
[(int) SIZEOF_EXPR
]) = 1;
640 gcc_obstack_init (&inline_text_obstack
);
641 inline_text_firstobj
= (char *) obstack_alloc (&inline_text_obstack
, 0);
643 /* Start it at 0, because check_newline is called at the very beginning
644 and will increment it to 1. */
646 input_filename
= "<internal>";
647 current_function_decl
= NULL
;
650 token_buffer
= (char *) xmalloc (maxtoken
+ 2);
652 ridpointers
[(int) RID_INT
] = get_identifier ("int");
653 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_INT
],
654 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]));
655 ridpointers
[(int) RID_BOOL
] = get_identifier ("bool");
656 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_BOOL
],
657 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_BOOL
]));
658 ridpointers
[(int) RID_CHAR
] = get_identifier ("char");
659 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_CHAR
],
660 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]));
661 ridpointers
[(int) RID_VOID
] = get_identifier ("void");
662 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VOID
],
663 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOID
]));
664 ridpointers
[(int) RID_FLOAT
] = get_identifier ("float");
665 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_FLOAT
],
666 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_FLOAT
]));
667 ridpointers
[(int) RID_DOUBLE
] = get_identifier ("double");
668 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_DOUBLE
],
669 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_DOUBLE
]));
670 ridpointers
[(int) RID_SHORT
] = get_identifier ("short");
671 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_SHORT
],
672 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_SHORT
]));
673 ridpointers
[(int) RID_LONG
] = get_identifier ("long");
674 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_LONG
],
675 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]));
676 ridpointers
[(int) RID_UNSIGNED
] = get_identifier ("unsigned");
677 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_UNSIGNED
],
678 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_UNSIGNED
]));
679 ridpointers
[(int) RID_SIGNED
] = get_identifier ("signed");
680 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_SIGNED
],
681 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_SIGNED
]));
682 ridpointers
[(int) RID_INLINE
] = get_identifier ("inline");
683 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_INLINE
],
684 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INLINE
]));
685 ridpointers
[(int) RID_CONST
] = get_identifier ("const");
686 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_CONST
],
687 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CONST
]));
688 ridpointers
[(int) RID_VOLATILE
] = get_identifier ("volatile");
689 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VOLATILE
],
690 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOLATILE
]));
691 ridpointers
[(int) RID_AUTO
] = get_identifier ("auto");
692 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_AUTO
],
693 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_AUTO
]));
694 ridpointers
[(int) RID_STATIC
] = get_identifier ("static");
695 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_STATIC
],
696 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]));
697 ridpointers
[(int) RID_EXTERN
] = get_identifier ("extern");
698 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_EXTERN
],
699 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXTERN
]));
700 ridpointers
[(int) RID_TYPEDEF
] = get_identifier ("typedef");
701 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_TYPEDEF
],
702 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_TYPEDEF
]));
703 ridpointers
[(int) RID_REGISTER
] = get_identifier ("register");
704 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_REGISTER
],
705 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_REGISTER
]));
706 ridpointers
[(int) RID_COMPLEX
] = get_identifier ("__complex");
707 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_COMPLEX
],
708 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_COMPLEX
]));
710 /* C++ extensions. These are probably not correctly named. */
711 ridpointers
[(int) RID_WCHAR
] = get_identifier ("__wchar_t");
712 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_WCHAR
],
713 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_WCHAR
]));
714 class_type_node
= build_int_2 (class_type
, 0);
715 TREE_TYPE (class_type_node
) = class_type_node
;
716 ridpointers
[(int) RID_CLASS
] = class_type_node
;
718 record_type_node
= build_int_2 (record_type
, 0);
719 TREE_TYPE (record_type_node
) = record_type_node
;
720 ridpointers
[(int) RID_RECORD
] = record_type_node
;
722 union_type_node
= build_int_2 (union_type
, 0);
723 TREE_TYPE (union_type_node
) = union_type_node
;
724 ridpointers
[(int) RID_UNION
] = union_type_node
;
726 enum_type_node
= build_int_2 (enum_type
, 0);
727 TREE_TYPE (enum_type_node
) = enum_type_node
;
728 ridpointers
[(int) RID_ENUM
] = enum_type_node
;
730 ridpointers
[(int) RID_VIRTUAL
] = get_identifier ("virtual");
731 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VIRTUAL
],
732 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]));
733 ridpointers
[(int) RID_EXPLICIT
] = get_identifier ("explicit");
734 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_EXPLICIT
],
735 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXPLICIT
]));
736 ridpointers
[(int) RID_FRIEND
] = get_identifier ("friend");
737 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_FRIEND
],
738 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_FRIEND
]));
740 ridpointers
[(int) RID_PUBLIC
] = get_identifier ("public");
741 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PUBLIC
],
742 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PUBLIC
]));
743 ridpointers
[(int) RID_PRIVATE
] = get_identifier ("private");
744 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PRIVATE
],
745 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PRIVATE
]));
746 ridpointers
[(int) RID_PROTECTED
] = get_identifier ("protected");
747 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PROTECTED
],
748 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PROTECTED
]));
749 ridpointers
[(int) RID_TEMPLATE
] = get_identifier ("template");
750 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_TEMPLATE
],
751 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_TEMPLATE
]));
752 /* This is for ANSI C++. */
753 ridpointers
[(int) RID_MUTABLE
] = get_identifier ("mutable");
754 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_MUTABLE
],
755 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_MUTABLE
]));
757 /* Signature handling extensions. */
758 signature_type_node
= build_int_2 (signature_type
, 0);
759 TREE_TYPE (signature_type_node
) = signature_type_node
;
760 ridpointers
[(int) RID_SIGNATURE
] = signature_type_node
;
762 null_node
= build_int_2 (0, 0);
763 ridpointers
[RID_NULL
] = null_node
;
765 opname_tab
[(int) COMPONENT_REF
] = "->";
766 opname_tab
[(int) MEMBER_REF
] = "->*";
767 opname_tab
[(int) INDIRECT_REF
] = "*";
768 opname_tab
[(int) ARRAY_REF
] = "[]";
769 opname_tab
[(int) MODIFY_EXPR
] = "=";
770 opname_tab
[(int) NEW_EXPR
] = "new";
771 opname_tab
[(int) DELETE_EXPR
] = "delete";
772 opname_tab
[(int) VEC_NEW_EXPR
] = "new []";
773 opname_tab
[(int) VEC_DELETE_EXPR
] = "delete []";
774 opname_tab
[(int) COND_EXPR
] = "?:";
775 opname_tab
[(int) CALL_EXPR
] = "()";
776 opname_tab
[(int) PLUS_EXPR
] = "+";
777 opname_tab
[(int) MINUS_EXPR
] = "-";
778 opname_tab
[(int) MULT_EXPR
] = "*";
779 opname_tab
[(int) TRUNC_DIV_EXPR
] = "/";
780 opname_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /)";
781 opname_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /)";
782 opname_tab
[(int) ROUND_DIV_EXPR
] = "(round /)";
783 opname_tab
[(int) TRUNC_MOD_EXPR
] = "%";
784 opname_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %)";
785 opname_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %)";
786 opname_tab
[(int) ROUND_MOD_EXPR
] = "(round %)";
787 opname_tab
[(int) NEGATE_EXPR
] = "-";
788 opname_tab
[(int) MIN_EXPR
] = "<?";
789 opname_tab
[(int) MAX_EXPR
] = ">?";
790 opname_tab
[(int) ABS_EXPR
] = "abs";
791 opname_tab
[(int) FFS_EXPR
] = "ffs";
792 opname_tab
[(int) LSHIFT_EXPR
] = "<<";
793 opname_tab
[(int) RSHIFT_EXPR
] = ">>";
794 opname_tab
[(int) BIT_IOR_EXPR
] = "|";
795 opname_tab
[(int) BIT_XOR_EXPR
] = "^";
796 opname_tab
[(int) BIT_AND_EXPR
] = "&";
797 opname_tab
[(int) BIT_ANDTC_EXPR
] = "&~";
798 opname_tab
[(int) BIT_NOT_EXPR
] = "~";
799 opname_tab
[(int) TRUTH_ANDIF_EXPR
] = "&&";
800 opname_tab
[(int) TRUTH_ORIF_EXPR
] = "||";
801 opname_tab
[(int) TRUTH_AND_EXPR
] = "strict &&";
802 opname_tab
[(int) TRUTH_OR_EXPR
] = "strict ||";
803 opname_tab
[(int) TRUTH_NOT_EXPR
] = "!";
804 opname_tab
[(int) LT_EXPR
] = "<";
805 opname_tab
[(int) LE_EXPR
] = "<=";
806 opname_tab
[(int) GT_EXPR
] = ">";
807 opname_tab
[(int) GE_EXPR
] = ">=";
808 opname_tab
[(int) EQ_EXPR
] = "==";
809 opname_tab
[(int) NE_EXPR
] = "!=";
810 opname_tab
[(int) IN_EXPR
] = "in";
811 opname_tab
[(int) RANGE_EXPR
] = "...";
812 opname_tab
[(int) CONVERT_EXPR
] = "+";
813 opname_tab
[(int) ADDR_EXPR
] = "&";
814 opname_tab
[(int) PREDECREMENT_EXPR
] = "--";
815 opname_tab
[(int) PREINCREMENT_EXPR
] = "++";
816 opname_tab
[(int) POSTDECREMENT_EXPR
] = "--";
817 opname_tab
[(int) POSTINCREMENT_EXPR
] = "++";
818 opname_tab
[(int) COMPOUND_EXPR
] = ",";
820 assignop_tab
[(int) NOP_EXPR
] = "=";
821 assignop_tab
[(int) PLUS_EXPR
] = "+=";
822 assignop_tab
[(int) CONVERT_EXPR
] = "+=";
823 assignop_tab
[(int) MINUS_EXPR
] = "-=";
824 assignop_tab
[(int) NEGATE_EXPR
] = "-=";
825 assignop_tab
[(int) MULT_EXPR
] = "*=";
826 assignop_tab
[(int) INDIRECT_REF
] = "*=";
827 assignop_tab
[(int) TRUNC_DIV_EXPR
] = "/=";
828 assignop_tab
[(int) EXACT_DIV_EXPR
] = "(exact /=)";
829 assignop_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /=)";
830 assignop_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /=)";
831 assignop_tab
[(int) ROUND_DIV_EXPR
] = "(round /=)";
832 assignop_tab
[(int) TRUNC_MOD_EXPR
] = "%=";
833 assignop_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %=)";
834 assignop_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %=)";
835 assignop_tab
[(int) ROUND_MOD_EXPR
] = "(round %=)";
836 assignop_tab
[(int) MIN_EXPR
] = "<?=";
837 assignop_tab
[(int) MAX_EXPR
] = ">?=";
838 assignop_tab
[(int) LSHIFT_EXPR
] = "<<=";
839 assignop_tab
[(int) RSHIFT_EXPR
] = ">>=";
840 assignop_tab
[(int) BIT_IOR_EXPR
] = "|=";
841 assignop_tab
[(int) BIT_XOR_EXPR
] = "^=";
842 assignop_tab
[(int) BIT_AND_EXPR
] = "&=";
843 assignop_tab
[(int) ADDR_EXPR
] = "&=";
845 init_filename_times ();
847 /* Some options inhibit certain reserved words.
848 Clear those words out of the hash table so they won't be recognized. */
849 #define UNSET_RESERVED_WORD(STRING) \
850 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
851 if (s) s->name = ""; } while (0)
854 /* let's parse things, and if they use it, then give them an error. */
855 if (!flag_exceptions
)
857 UNSET_RESERVED_WORD ("throw");
858 UNSET_RESERVED_WORD ("try");
859 UNSET_RESERVED_WORD ("catch");
863 if (!flag_rtti
|| flag_no_gnu_keywords
)
865 UNSET_RESERVED_WORD ("classof");
866 UNSET_RESERVED_WORD ("headof");
869 if (! flag_handle_signatures
|| flag_no_gnu_keywords
)
871 /* Easiest way to not recognize signature
872 handling extensions... */
873 UNSET_RESERVED_WORD ("signature");
874 UNSET_RESERVED_WORD ("sigof");
876 if (flag_no_asm
|| flag_no_gnu_keywords
)
877 UNSET_RESERVED_WORD ("typeof");
878 if (! flag_operator_names
)
880 /* These are new ANSI keywords that may break code. */
881 UNSET_RESERVED_WORD ("and");
882 UNSET_RESERVED_WORD ("and_eq");
883 UNSET_RESERVED_WORD ("bitand");
884 UNSET_RESERVED_WORD ("bitor");
885 UNSET_RESERVED_WORD ("compl");
886 UNSET_RESERVED_WORD ("not");
887 UNSET_RESERVED_WORD ("not_eq");
888 UNSET_RESERVED_WORD ("or");
889 UNSET_RESERVED_WORD ("or_eq");
890 UNSET_RESERVED_WORD ("xor");
891 UNSET_RESERVED_WORD ("xor_eq");
894 token_count
= init_cpp_parse ();
895 interface_unknown
= 1;
904 cpp_finish (&parse_in
);
911 reinit_parse_for_function ()
913 current_base_init_list
= NULL_TREE
;
914 current_member_init_list
= NULL_TREE
;
921 yyprint (file
, yychar
, yylval
)
933 case IDENTIFIER_DEFN
:
937 case PRE_PARSED_CLASS_DECL
:
939 if (TREE_CODE (t
) == TYPE_DECL
|| TREE_CODE (t
) == TEMPLATE_DECL
)
941 fprintf (file
, " `%s'", IDENTIFIER_POINTER (DECL_NAME (t
)));
944 my_friendly_assert (TREE_CODE (t
) == IDENTIFIER_NODE
, 224);
945 if (IDENTIFIER_POINTER (t
))
946 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
949 if (yylval
.ttype
== class_type_node
)
950 fprintf (file
, " `class'");
951 else if (yylval
.ttype
== record_type_node
)
952 fprintf (file
, " `struct'");
953 else if (yylval
.ttype
== union_type_node
)
954 fprintf (file
, " `union'");
955 else if (yylval
.ttype
== enum_type_node
)
956 fprintf (file
, " `enum'");
957 else if (yylval
.ttype
== signature_type_node
)
958 fprintf (file
, " `signature'");
960 my_friendly_abort (80);
965 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
966 static int *reduce_count
;
972 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
973 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
976 #ifdef GATHER_STATISTICS
982 reduce_count
[yyn
] += 1;
989 return reduce_count
[*q
] - reduce_count
[*p
];
996 return token_count
[*q
] - token_count
[*p
];
1002 print_parse_statistics ()
1004 #ifdef GATHER_STATISTICS
1005 #ifdef REDUCE_LENGTH
1008 int maxlen
= REDUCE_LENGTH
;
1011 if (reduce_count
[-1] == 0)
1014 if (TOKEN_LENGTH
> REDUCE_LENGTH
)
1015 maxlen
= TOKEN_LENGTH
;
1016 sorted
= (unsigned *) alloca (sizeof (int) * maxlen
);
1018 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1020 qsort (sorted
, TOKEN_LENGTH
, sizeof (int), token_cmp
);
1021 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1023 int idx
= sorted
[i
];
1024 if (token_count
[idx
] == 0)
1026 if (token_count
[idx
] < token_count
[-1])
1028 fprintf (stderr
, "token %d, `%s', count = %d\n",
1029 idx
, yytname
[YYTRANSLATE (idx
)], token_count
[idx
]);
1031 fprintf (stderr
, "\n");
1032 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1034 qsort (sorted
, REDUCE_LENGTH
, sizeof (int), reduce_cmp
);
1035 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1037 int idx
= sorted
[i
];
1038 if (reduce_count
[idx
] == 0)
1040 if (reduce_count
[idx
] < reduce_count
[-1])
1042 fprintf (stderr
, "rule %d, line %d, count = %d\n",
1043 idx
, yyrline
[idx
], reduce_count
[idx
]);
1045 fprintf (stderr
, "\n");
1051 /* Sets the value of the 'yydebug' variable to VALUE.
1052 This is a function so we don't have to have YYDEBUG defined
1053 in order to build the compiler. */
1063 warning ("YYDEBUG not defined.");
1068 /* Functions and data structures for #pragma interface.
1070 `#pragma implementation' means that the main file being compiled
1071 is considered to implement (provide) the classes that appear in
1072 its main body. I.e., if this is file "foo.cc", and class `bar'
1073 is defined in "foo.cc", then we say that "foo.cc implements bar".
1075 All main input files "implement" themselves automagically.
1077 `#pragma interface' means that unless this file (of the form "foo.h"
1078 is not presently being included by file "foo.cc", the
1079 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1080 of the vtables nor any of the inline functions defined in foo.h
1081 will ever be output.
1083 There are cases when we want to link files such as "defs.h" and
1084 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1085 and "main.cc" has `#pragma implementation "defs.h"'. */
1090 struct impl_files
*next
;
1093 static struct impl_files
*impl_file_chain
;
1095 /* Helper function to load global variables with interface
1099 extract_interface_info ()
1103 if (flag_alt_external_templates
)
1105 struct tinst_level
*til
= tinst_for_decl ();
1108 fileinfo
= get_time_identifier (til
->file
);
1111 fileinfo
= get_time_identifier (input_filename
);
1112 fileinfo
= IDENTIFIER_CLASS_VALUE (fileinfo
);
1113 interface_only
= TREE_INT_CST_LOW (fileinfo
);
1114 interface_unknown
= TREE_INT_CST_HIGH (fileinfo
);
1117 /* Return nonzero if S is not considered part of an
1118 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1121 interface_strcmp (s
)
1124 /* Set the interface/implementation bits for this scope. */
1125 struct impl_files
*ifiles
;
1128 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
1130 char *t1
= ifiles
->filename
;
1133 if (*s1
!= *t1
|| *s1
== 0)
1136 while (*s1
== *t1
&& *s1
!= 0)
1143 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1144 if (index (s1
, '.') || index (t1
, '.'))
1147 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
1159 set_typedecl_interface_info (prev
, vars
)
1162 tree id
= get_time_identifier (DECL_SOURCE_FILE (vars
));
1163 tree fileinfo
= IDENTIFIER_CLASS_VALUE (id
);
1164 tree type
= TREE_TYPE (vars
);
1166 CLASSTYPE_INTERFACE_ONLY (type
) = TREE_INT_CST_LOW (fileinfo
)
1167 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars
)));
1171 set_vardecl_interface_info (prev
, vars
)
1174 tree type
= DECL_CONTEXT (vars
);
1176 if (CLASSTYPE_INTERFACE_KNOWN (type
))
1178 if (CLASSTYPE_INTERFACE_ONLY (type
))
1179 set_typedecl_interface_info (prev
, TYPE_MAIN_DECL (type
));
1181 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
1182 DECL_EXTERNAL (vars
) = CLASSTYPE_INTERFACE_ONLY (type
);
1183 TREE_PUBLIC (vars
) = 1;
1189 /* Called from the top level: if there are any pending inlines to
1190 do, set up to process them now. This function sets up the first function
1191 to be parsed; after it has been, the rule for fndef in parse.y will
1192 call process_next_inline to start working on the next one. */
1195 do_pending_inlines ()
1197 struct pending_inline
*t
;
1200 /* Oops, we're still dealing with the last batch. */
1201 if (yychar
== PRE_PARSED_FUNCTION_DECL
)
1204 /* Reverse the pending inline functions, since
1205 they were cons'd instead of appended. */
1207 struct pending_inline
*prev
= 0, *tail
;
1208 t
= pending_inlines
;
1209 pending_inlines
= 0;
1224 /* Now start processing the first inline function. */
1225 context
= hack_decl_function_context (t
->fndecl
);
1227 push_cp_function_context (context
);
1228 maybe_begin_member_template_processing (t
->fndecl
);
1231 feed_input (t
->buf
, t
->len
);
1234 if (input_filename
!= t
->filename
)
1236 input_filename
= t
->filename
;
1237 /* Get interface/implementation back in sync. */
1238 extract_interface_info ();
1241 input_filename
= t
->filename
;
1242 interface_unknown
= t
->interface
== 1;
1243 interface_only
= t
->interface
== 0;
1245 yychar
= PRE_PARSED_FUNCTION_DECL
;
1247 /* Pass back a handle on the rest of the inline functions, so that they
1248 can be processed later. */
1249 yylval
.ttype
= build_tree_list ((tree
) t
, t
->fndecl
);
1250 DECL_PENDING_INLINE_INFO (t
->fndecl
) = 0;
1253 static int nextchar
= -1;
1255 /* Called from the fndecl rule in the parser when the function just parsed
1256 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1257 do_pending_inlines). */
1260 process_next_inline (t
)
1264 struct pending_inline
*i
= (struct pending_inline
*) TREE_PURPOSE (t
);
1265 context
= hack_decl_function_context (i
->fndecl
);
1266 maybe_end_member_template_processing (i
->fndecl
);
1268 pop_cp_function_context (context
);
1270 if (yychar
== YYEMPTY
)
1272 if (yychar
!= END_OF_SAVED_INPUT
)
1274 error ("parse error at end of saved function text");
1276 /* restore_pending_input will abort unless yychar is either
1277 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1278 hosed, feed back YYEMPTY. We also need to discard nextchar,
1279 since that may have gotten set as well. */
1284 if (i
&& i
->fndecl
!= NULL_TREE
)
1286 context
= hack_decl_function_context (i
->fndecl
);
1288 push_cp_function_context (context
);
1289 maybe_begin_member_template_processing (i
->fndecl
);
1290 feed_input (i
->buf
, i
->len
);
1292 input_filename
= i
->filename
;
1293 yychar
= PRE_PARSED_FUNCTION_DECL
;
1294 yylval
.ttype
= build_tree_list ((tree
) i
, i
->fndecl
);
1295 DECL_PENDING_INLINE_INFO (i
->fndecl
) = 0;
1299 interface_unknown
= i
->interface
== 1;
1300 interface_only
= i
->interface
== 0;
1303 extract_interface_info ();
1306 /* Since inline methods can refer to text which has not yet been seen,
1307 we store the text of the method in a structure which is placed in the
1308 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1309 After parsing the body of the class definition, the FUNCTION_DECL's are
1310 scanned to see which ones have this field set. Those are then digested
1313 This function's FUNCTION_DECL will have a bit set in its common so
1314 that we know to watch out for it. */
1317 consume_string (this_obstack
, matching_char
)
1318 register struct obstack
*this_obstack
;
1322 int starting_lineno
= lineno
;
1328 int save_lineno
= lineno
;
1329 lineno
= starting_lineno
;
1330 if (matching_char
== '"')
1331 error ("end of file encountered inside string constant");
1333 error ("end of file encountered inside character constant");
1334 lineno
= save_lineno
;
1339 obstack_1grow (this_obstack
, c
);
1341 obstack_1grow (this_obstack
, c
);
1343 /* Make sure we continue the loop */
1350 pedwarn ("ANSI C++ forbids newline in string constant");
1353 obstack_1grow (this_obstack
, c
);
1355 while (c
!= matching_char
);
1358 static int nextyychar
= YYEMPTY
;
1359 static YYSTYPE nextyylval
;
1361 struct pending_input
{
1362 int nextchar
, yychar
, nextyychar
, eof
;
1363 YYSTYPE yylval
, nextyylval
;
1364 struct obstack token_obstack
;
1368 struct pending_input
*
1369 save_pending_input ()
1371 struct pending_input
*p
;
1372 p
= (struct pending_input
*) xmalloc (sizeof (struct pending_input
));
1373 p
->nextchar
= nextchar
;
1375 p
->nextyychar
= nextyychar
;
1377 p
->nextyylval
= nextyylval
;
1378 p
->eof
= end_of_file
;
1379 yychar
= nextyychar
= YYEMPTY
;
1381 p
->first_token
= first_token
;
1382 p
->token_obstack
= token_obstack
;
1385 gcc_obstack_init (&token_obstack
);
1391 restore_pending_input (p
)
1392 struct pending_input
*p
;
1394 my_friendly_assert (nextchar
== -1, 229);
1395 nextchar
= p
->nextchar
;
1396 my_friendly_assert (yychar
== YYEMPTY
|| yychar
== END_OF_SAVED_INPUT
, 230);
1398 my_friendly_assert (nextyychar
== YYEMPTY
, 231);
1399 nextyychar
= p
->nextyychar
;
1401 nextyylval
= p
->nextyylval
;
1402 first_token
= p
->first_token
;
1403 obstack_free (&token_obstack
, (char *) 0);
1404 token_obstack
= p
->token_obstack
;
1405 end_of_file
= p
->eof
;
1409 /* Unget character CH from the input stream.
1410 If RESCAN is non-zero, then we want to `see' this
1411 character as the next input token. */
1414 yyungetc (ch
, rescan
)
1418 /* Unget a character from the input stream. */
1419 if (yychar
== YYEMPTY
|| rescan
== 0)
1422 put_back (nextchar
);
1427 my_friendly_assert (nextyychar
== YYEMPTY
, 232);
1428 nextyychar
= yychar
;
1429 nextyylval
= yylval
;
1435 clear_inline_text_obstack ()
1437 obstack_free (&inline_text_obstack
, inline_text_firstobj
);
1440 /* This function stores away the text for an inline function that should
1441 be processed later. It decides how much later, and may need to move
1442 the info between obstacks; therefore, the caller should not refer to
1443 the T parameter after calling this function. */
1446 store_pending_inline (decl
, t
)
1448 struct pending_inline
*t
;
1451 DECL_PENDING_INLINE_INFO (decl
) = t
;
1453 /* Because we use obstacks, we must process these in precise order. */
1454 t
->next
= pending_inlines
;
1455 pending_inlines
= t
;
1459 reinit_parse_for_method (yychar
, decl
)
1464 int starting_lineno
= lineno
;
1465 char *starting_filename
= input_filename
;
1467 reinit_parse_for_block (yychar
, &inline_text_obstack
);
1469 len
= obstack_object_size (&inline_text_obstack
);
1470 current_base_init_list
= NULL_TREE
;
1471 current_member_init_list
= NULL_TREE
;
1472 if (decl
== void_type_node
1473 || (current_class_type
&& TYPE_REDEFINED (current_class_type
)))
1475 /* Happens when we get two declarations of the same
1476 function in the same scope. */
1477 char *buf
= obstack_finish (&inline_text_obstack
);
1478 obstack_free (&inline_text_obstack
, buf
);
1483 struct pending_inline
*t
;
1484 char *buf
= obstack_finish (&inline_text_obstack
);
1486 t
= (struct pending_inline
*) obstack_alloc (&inline_text_obstack
,
1487 sizeof (struct pending_inline
));
1488 t
->lineno
= starting_lineno
;
1489 t
->filename
= starting_filename
;
1496 if (interface_unknown
&& processing_template_defn
&& flag_external_templates
&& ! DECL_IN_SYSTEM_HEADER (decl
))
1497 warn_if_unknown_interface (decl
);
1499 t
->interface
= (interface_unknown
? 1 : (interface_only
? 0 : 2));
1500 store_pending_inline (decl
, t
);
1504 /* Consume a block -- actually, a method beginning
1505 with `:' or `{' -- and save it away on the specified obstack. */
1508 reinit_parse_for_block (pyychar
, obstackp
)
1510 struct obstack
*obstackp
;
1514 int starting_lineno
= lineno
;
1515 char *starting_filename
= input_filename
;
1517 int look_for_semicolon
= 0;
1518 int look_for_lbrac
= 0;
1521 obstack_1grow (obstackp
, '{');
1522 else if (pyychar
== '=')
1523 look_for_semicolon
= 1;
1524 else if (pyychar
== ':')
1526 obstack_1grow (obstackp
, pyychar
);
1530 else if (pyychar
== RETURN
)
1532 obstack_grow (obstackp
, "return", 6);
1536 else if (pyychar
== TRY
)
1538 obstack_grow (obstackp
, "try", 3);
1544 yyerror ("parse error in method specification");
1545 obstack_1grow (obstackp
, '{');
1548 if (nextchar
!= EOF
)
1558 int this_lineno
= lineno
;
1560 c
= skip_white_space (c
);
1562 /* Don't lose our cool if there are lots of comments. */
1563 if (lineno
== this_lineno
+ 1)
1564 obstack_1grow (obstackp
, '\n');
1565 else if (lineno
== this_lineno
)
1567 else if (lineno
- this_lineno
< 10)
1570 for (i
= lineno
- this_lineno
; i
> 0; i
--)
1571 obstack_1grow (obstackp
, '\n');
1576 sprintf (buf
, "\n# %d \"", lineno
);
1578 obstack_grow (obstackp
, buf
, len
);
1580 len
= strlen (input_filename
);
1581 obstack_grow (obstackp
, input_filename
, len
);
1582 obstack_1grow (obstackp
, '\"');
1583 obstack_1grow (obstackp
, '\n');
1586 while (c
> ' ') /* ASCII dependent... */
1588 obstack_1grow (obstackp
, c
);
1597 if (blev
== 0 && !look_for_semicolon
)
1601 if (peekyylex () == CATCH
)
1604 obstack_grow (obstackp
, " catch ", 7);
1621 /* Don't act on the next character...e.g, doing an escaped
1626 error_with_file_and_line (starting_filename
,
1628 "end of file read inside definition");
1631 obstack_1grow (obstackp
, c
);
1634 consume_string (obstackp
, c
);
1636 consume_string (obstackp
, c
);
1641 error ("function body for constructor missing");
1642 obstack_1grow (obstackp
, '{');
1643 obstack_1grow (obstackp
, '}');
1647 else if (look_for_semicolon
&& blev
== 0)
1655 error_with_file_and_line (starting_filename
,
1657 "end of file read inside definition");
1662 obstack_1grow (obstackp
, c
);
1667 obstack_1grow (obstackp
, '\0');
1670 /* Consume a no-commas expression -- actually, a default argument -- and
1671 save it away on the specified obstack. */
1674 reinit_parse_for_expr (obstackp
)
1675 struct obstack
*obstackp
;
1678 int starting_lineno
= lineno
;
1679 char *starting_filename
= input_filename
;
1683 if (nextchar
!= EOF
)
1693 int this_lineno
= lineno
;
1695 c
= skip_white_space (c
);
1697 /* Don't lose our cool if there are lots of comments. */
1698 if (lineno
== this_lineno
+ 1)
1699 obstack_1grow (obstackp
, '\n');
1700 else if (lineno
== this_lineno
)
1702 else if (lineno
- this_lineno
< 10)
1705 for (i
= lineno
- this_lineno
; i
> 0; --i
)
1706 obstack_1grow (obstackp
, '\n');
1711 sprintf (buf
, "\n# %d \"", lineno
);
1713 obstack_grow (obstackp
, buf
, len
);
1715 len
= strlen (input_filename
);
1716 obstack_grow (obstackp
, input_filename
, len
);
1717 obstack_1grow (obstackp
, '\"');
1718 obstack_1grow (obstackp
, '\n');
1721 while (c
> ' ') /* ASCII dependent... */
1723 if (plev
<= 0 && (c
== ')' || c
== ','))
1728 obstack_1grow (obstackp
, c
);
1729 if (c
== '(' || c
== '[')
1731 else if (c
== ']' || c
== ')')
1735 /* Don't act on the next character...e.g, doing an escaped
1740 error_with_file_and_line (starting_filename
,
1742 "end of file read inside definition");
1745 obstack_1grow (obstackp
, c
);
1748 consume_string (obstackp
, c
);
1750 consume_string (obstackp
, c
);
1756 error_with_file_and_line (starting_filename
,
1758 "end of file read inside definition");
1763 obstack_1grow (obstackp
, c
);
1768 obstack_1grow (obstackp
, '\0');
1771 int do_snarf_defarg
;
1773 /* Decide whether the default argument we are about to see should be
1774 gobbled up as text for later parsing. */
1777 maybe_snarf_defarg ()
1779 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
1780 do_snarf_defarg
= 1;
1783 /* When we see a default argument in a method declaration, we snarf it as
1784 text using snarf_defarg. When we get up to namespace scope, we then go
1785 through and parse all of them using do_pending_defargs. Since yacc
1786 parsers are not reentrant, we retain defargs state in these two
1787 variables so that subsequent calls to do_pending_defargs can resume
1788 where the previous call left off. */
1800 reinit_parse_for_expr (&inline_text_obstack
);
1801 len
= obstack_object_size (&inline_text_obstack
);
1802 buf
= obstack_finish (&inline_text_obstack
);
1804 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1805 arg
= make_node (DEFAULT_ARG
);
1806 DEFARG_LENGTH (arg
) = len
- 1;
1807 DEFARG_POINTER (arg
) = buf
;
1813 /* Called from grokfndecl to note a function decl with unparsed default
1814 arguments for later processing. Also called from grokdeclarator
1815 for function types with unparsed defargs; the call from grokfndecl
1816 will always come second, so we can overwrite the entry from the type. */
1819 add_defarg_fn (decl
)
1822 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1823 TREE_VALUE (defarg_fns
) = decl
;
1826 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1827 defarg_fns
= tree_cons (current_class_type
, decl
, defarg_fns
);
1832 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1838 tree d
= TREE_PURPOSE (p
);
1839 feed_input (DEFARG_POINTER (d
), DEFARG_LENGTH (d
));
1840 if (TREE_CODE (f
) == FUNCTION_DECL
)
1842 lineno
= DECL_SOURCE_LINE (f
);
1843 input_filename
= DECL_SOURCE_FILE (f
);
1845 yychar
= DEFARG_MARKER
;
1849 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1854 if (yychar
== YYEMPTY
)
1856 if (yychar
!= END_OF_SAVED_INPUT
)
1858 error ("parse error at end of saved function text");
1860 /* restore_pending_input will abort unless yychar is either
1861 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1862 hosed, feed back YYEMPTY. We also need to discard nextchar,
1863 since that may have gotten set as well. */
1870 /* Main function for deferred parsing of default arguments. Called from
1874 do_pending_defargs ()
1879 for (; defarg_fns
; defarg_fns
= TREE_CHAIN (defarg_fns
))
1881 tree defarg_fn
= TREE_VALUE (defarg_fns
);
1882 if (defarg_parm
== NULL_TREE
)
1884 push_nested_class (TREE_PURPOSE (defarg_fns
), 1);
1886 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1887 maybe_begin_member_template_processing (defarg_fn
);
1889 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1893 for (p
= DECL_ARGUMENTS (defarg_fn
); p
; p
= TREE_CHAIN (p
))
1894 pushdecl (copy_node (p
));
1896 defarg_parm
= TYPE_ARG_TYPES (TREE_TYPE (defarg_fn
));
1899 defarg_parm
= TYPE_ARG_TYPES (defarg_fn
);
1902 defarg_parm
= TREE_CHAIN (defarg_parm
);
1904 for (; defarg_parm
; defarg_parm
= TREE_CHAIN (defarg_parm
))
1905 if (TREE_PURPOSE (defarg_parm
)
1906 && TREE_CODE (TREE_PURPOSE (defarg_parm
)) == DEFAULT_ARG
)
1908 feed_defarg (defarg_fn
, defarg_parm
);
1910 /* Return to the parser, which will process this defarg
1911 and call us again. */
1915 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1916 maybe_end_member_template_processing (defarg_fn
);
1918 pop_nested_class (1);
1922 /* Build a default function named NAME for type TYPE.
1923 KIND says what to build.
1925 When KIND == 0, build default destructor.
1926 When KIND == 1, build virtual destructor.
1927 When KIND == 2, build default constructor.
1928 When KIND == 3, build default X(const X&) constructor.
1929 When KIND == 4, build default X(X&) constructor.
1930 When KIND == 5, build default operator = (const X&).
1931 When KIND == 6, build default operator = (X&). */
1934 cons_up_default_function (type
, full_name
, kind
)
1935 tree type
, full_name
;
1938 extern tree void_list_node
;
1939 tree declspecs
= NULL_TREE
;
1940 tree fn
, args
= NULL_TREE
;
1943 tree name
= constructor_name (full_name
);
1949 declspecs
= build_decl_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]);
1950 /* Fall through... */
1952 name
= build_parse_node (BIT_NOT_EXPR
, name
);
1953 args
= void_list_node
;
1957 /* Default constructor. */
1958 args
= void_list_node
;
1962 type
= build_type_variant (type
, 1, 0);
1963 /* Fall through... */
1965 /* According to ARM $12.8, the default copy ctor will be declared, but
1966 not defined, unless it's needed. */
1967 argtype
= build_reference_type (type
);
1968 args
= tree_cons (NULL_TREE
,
1969 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1970 get_identifier ("_ctor_arg")),
1977 declspecs
= build_decl_list (NULL_TREE
, type
);
1980 type
= build_type_variant (type
, 1, 0);
1982 name
= ansi_opname
[(int) MODIFY_EXPR
];
1984 argtype
= build_reference_type (type
);
1985 args
= tree_cons (NULL_TREE
,
1986 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1987 get_identifier ("_ctor_arg")),
1992 my_friendly_abort (59);
1995 declspecs
= decl_tree_cons (NULL_TREE
, ridpointers
[(int) RID_INLINE
],
1998 TREE_PARMLIST (args
) = 1;
2001 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, NULL_TREE
);
2003 declarator
= build_parse_node (ADDR_EXPR
, declarator
);
2005 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
2008 if (fn
== void_type_node
)
2012 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn
)));
2015 if (processing_template_defn
)
2017 SET_DECL_IMPLICIT_INSTANTIATION (fn
);
2018 repo_template_used (fn
);
2023 if (CLASSTYPE_INTERFACE_KNOWN (type
))
2025 DECL_INTERFACE_KNOWN (fn
) = 1;
2026 DECL_NOT_REALLY_EXTERN (fn
) = (!CLASSTYPE_INTERFACE_ONLY (type
)
2027 && flag_implement_inlines
);
2031 DECL_NOT_REALLY_EXTERN (fn
) = 1;
2033 mark_inline_for_output (fn
);
2035 #ifdef DEBUG_DEFAULT_FUNCTIONS
2036 { char *fn_type
= NULL
;
2040 case 0: fn_type
= "default destructor"; break;
2041 case 1: fn_type
= "virtual destructor"; break;
2042 case 2: fn_type
= "default constructor"; break;
2043 case 3: fn_type
= "default X(const X&)"; break;
2044 case 4: fn_type
= "default X(X&)"; break;
2048 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2049 t
= TREE_OPERAND (name
, 0);
2050 fprintf (stderr
, "[[[[ %s for %s:\n%s]]]]\n", fn_type
,
2051 IDENTIFIER_POINTER (t
), func_buf
);
2054 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2056 /* Show that this function was generated by the compiler. */
2057 SET_DECL_ARTIFICIAL (fn
);
2062 /* Heuristic to tell whether the user is missing a semicolon
2063 after a struct or enum declaration. Emit an error message
2064 if we know the user has blown it. */
2067 check_for_missing_semicolon (type
)
2075 && yychar
!= IDENTIFIER
2076 && yychar
!= TYPENAME
2077 && yychar
!= CV_QUALIFIER
2078 && yychar
!= SELFNAME
)
2081 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
2082 error ("semicolon missing after %s declaration",
2083 TREE_CODE (type
) == ENUMERAL_TYPE
? "enum" : "struct");
2085 cp_error ("semicolon missing after declaration of `%T'", type
);
2086 shadow_tag (build_tree_list (0, type
));
2088 /* Could probably also hack cases where class { ... } f (); appears. */
2093 note_got_semicolon (type
)
2096 if (TREE_CODE_CLASS (TREE_CODE (type
)) != 't')
2097 my_friendly_abort (60);
2098 if (IS_AGGR_TYPE (type
))
2099 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
2103 note_list_got_semicolon (declspecs
)
2108 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
2110 tree type
= TREE_VALUE (link
);
2111 if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't')
2112 note_got_semicolon (type
);
2117 /* If C is not whitespace, return C.
2118 Otherwise skip whitespace and return first nonwhite char read. */
2121 skip_white_space (c
)
2129 c
= check_newline ();
2140 while (c
== ' ' || c
== '\t');
2148 error ("stray '\\' in program");
2160 /* Make the token buffer longer, preserving the data in it.
2161 P should point to just beyond the last valid character in the old buffer.
2162 The value we return is a pointer to the new buffer
2163 at a place corresponding to P. */
2166 extend_token_buffer (p
)
2169 int offset
= p
- token_buffer
;
2171 maxtoken
= maxtoken
* 2 + 10;
2172 token_buffer
= (char *) xrealloc (token_buffer
, maxtoken
+ 2);
2174 return token_buffer
+ offset
;
2178 get_last_nonwhite_on_line ()
2182 /* Is this the last nonwhite stuff on the line? */
2184 c
= nextchar
, nextchar
= -1;
2188 while (c
== ' ' || c
== '\t')
2193 /* At the beginning of a line, increment the line number
2194 and process any #-directive on this line.
2195 If the line is a #-directive, read the entire line and return a newline.
2196 Otherwise, return the line's first non-whitespace character. */
2200 #ifdef HANDLE_SYSV_PRAGMA
2201 static int handle_sysv_pragma
PROTO((FILE *, int));
2203 static int handle_cp_pragma
PROTO((char *));
2211 /* Read first nonwhite char on the line. Do this before incrementing the
2212 line number, in case we're at the end of saved text. */
2216 while (c
== ' ' || c
== '\t');
2222 /* If not #, return it so caller will use it. */
2226 /* Don't read beyond this line. */
2229 /* Read first nonwhite char after the `#'. */
2233 while (c
== ' ' || c
== '\t');
2235 /* If a letter follows, then if the word here is `line', skip
2236 it and ignore it; otherwise, ignore the line, with an error
2237 if the word isn't `pragma'. */
2239 if ((c
>= 'a' && c
<= 'z') || (c
>= 'A' && c
<= 'Z'))
2249 token
= real_yylex ();
2250 if (token
== IDENTIFIER
2251 && TREE_CODE (yylval
.ttype
) == IDENTIFIER_NODE
)
2253 /* If this is 1, we handled it; if it's -1, it was one we
2254 wanted but had something wrong with it. Only if it's
2255 0 was it not handled. */
2256 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval
.ttype
)))
2259 else if (token
== END_OF_LINE
)
2262 #ifdef HANDLE_SYSV_PRAGMA
2263 if (handle_sysv_pragma (finput
, token
))
2266 #ifdef HANDLE_PRAGMA
2267 if (HANDLE_PRAGMA (finput
, yylval
.ttype
))
2281 && ((c
= getch ()) == ' ' || c
== '\t'))
2283 debug_define (lineno
, get_directive_line (finput
));
2293 && ((c
= getch ()) == ' ' || c
== '\t'))
2295 debug_undef (lineno
, get_directive_line (finput
));
2304 && ((c
= getch ()) == ' ' || c
== '\t'))
2313 && ((c
= getch ()) == ' ' || c
== '\t'))
2315 #ifdef ASM_OUTPUT_IDENT
2316 extern FILE *asm_out_file
;
2318 /* #ident. The pedantic warning is now in cccp.c. */
2320 /* Here we have just seen `#ident '.
2321 A string constant should follow. */
2323 token
= real_yylex ();
2324 if (token
== END_OF_LINE
)
2327 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
2329 error ("invalid #ident");
2333 if (! flag_no_ident
)
2335 #ifdef ASM_OUTPUT_IDENT
2336 ASM_OUTPUT_IDENT (asm_out_file
,
2337 TREE_STRING_POINTER (yylval
.ttype
));
2341 /* Skip the rest of this line. */
2354 && ((c
= getch ()) == ' ' || c
== '\t'))
2356 /* Used to test incremental compilation. */
2357 sorry ("#pragma newworld");
2361 error ("undefined or invalid # directive");
2366 /* Here we have either `#line' or `# <nonletter>'.
2367 In either case, it should be a line number; a digit should follow. */
2369 while (c
== ' ' || c
== '\t')
2372 /* If the # is the only nonwhite char on the line,
2373 just ignore it. Check the new newline. */
2377 /* Something follows the #; read a token. */
2380 token
= real_yylex ();
2382 if (token
== CONSTANT
2383 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2385 int old_lineno
= lineno
;
2386 enum { act_none
, act_push
, act_pop
} action
= act_none
;
2387 int entering_system_header
= 0;
2388 int entering_c_header
= 0;
2390 /* subtract one, because it is the following line that
2391 gets the specified number */
2393 int l
= TREE_INT_CST_LOW (yylval
.ttype
) - 1;
2394 c
= get_last_nonwhite_on_line ();
2397 /* No more: store the line number and check following line. */
2403 /* More follows: it must be a string constant (filename). */
2405 /* Read the string constant, but don't treat \ as special. */
2406 ignore_escape_flag
= 1;
2407 token
= real_yylex ();
2408 ignore_escape_flag
= 0;
2410 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
2412 error ("invalid #line");
2416 /* Changing files again. This means currently collected time
2417 is charged against header time, and body time starts back
2419 if (flag_detailed_statistics
)
2421 int this_time
= my_get_run_time ();
2422 tree time_identifier
= get_time_identifier (TREE_STRING_POINTER (yylval
.ttype
));
2423 header_time
+= this_time
- body_time
;
2424 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
))
2425 += this_time
- body_time
;
2426 this_filename_time
= time_identifier
;
2427 body_time
= this_time
;
2431 = (char *) permalloc (TREE_STRING_LENGTH (yylval
.ttype
) + 1);
2432 strcpy (input_filename
, TREE_STRING_POINTER (yylval
.ttype
));
2434 GNU_xref_file (input_filename
);
2436 if (main_input_filename
== 0)
2438 struct impl_files
*ifiles
= impl_file_chain
;
2442 while (ifiles
->next
)
2443 ifiles
= ifiles
->next
;
2444 ifiles
->filename
= file_name_nondirectory (input_filename
);
2447 main_input_filename
= input_filename
;
2448 if (write_virtuals
== 3)
2449 walk_vtables (set_typedecl_interface_info
, set_vardecl_interface_info
);
2452 extract_interface_info ();
2454 c
= get_last_nonwhite_on_line ();
2457 /* Update the name in the top element of input_file_stack. */
2458 if (input_file_stack
)
2459 input_file_stack
->name
= input_filename
;
2465 token
= real_yylex ();
2467 /* `1' after file name means entering new file.
2468 `2' after file name means just left a file. */
2470 if (token
== CONSTANT
2471 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2473 if (TREE_INT_CST_LOW (yylval
.ttype
) == 1)
2475 else if (TREE_INT_CST_LOW (yylval
.ttype
) == 2)
2480 c
= get_last_nonwhite_on_line ();
2484 token
= real_yylex ();
2489 /* `3' after file name means this is a system header file. */
2491 if (token
== CONSTANT
2492 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
2493 && TREE_INT_CST_LOW (yylval
.ttype
) == 3)
2495 entering_system_header
= 1;
2497 c
= get_last_nonwhite_on_line ();
2501 token
= real_yylex ();
2505 /* `4' after file name means this is a C header file. */
2507 if (token
== CONSTANT
2508 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
2509 && TREE_INT_CST_LOW (yylval
.ttype
) == 4)
2511 entering_c_header
= 1;
2513 c
= get_last_nonwhite_on_line ();
2517 token
= real_yylex ();
2521 /* Do the actions implied by the preceding numbers. */
2523 if (action
== act_push
)
2525 /* Pushing to a new file. */
2526 struct file_stack
*p
;
2528 p
= (struct file_stack
*) xmalloc (sizeof (struct file_stack
));
2529 input_file_stack
->line
= old_lineno
;
2530 p
->next
= input_file_stack
;
2531 p
->name
= input_filename
;
2532 input_file_stack
= p
;
2533 input_file_stack_tick
++;
2534 debug_start_source_file (input_filename
);
2535 in_system_header
= entering_system_header
;
2538 else if (entering_c_header
)
2541 ++pending_lang_change
;
2544 else if (action
== act_pop
)
2546 /* Popping out of a file. */
2547 if (input_file_stack
->next
)
2549 struct file_stack
*p
;
2551 if (c_header_level
&& --c_header_level
== 0)
2553 if (entering_c_header
)
2554 warning ("badly nested C headers from preprocessor");
2555 --pending_lang_change
;
2557 in_system_header
= entering_system_header
;
2559 p
= input_file_stack
;
2560 input_file_stack
= p
->next
;
2562 input_file_stack_tick
++;
2563 debug_end_source_file (input_file_stack
->line
);
2566 error ("#-lines for entering and leaving files don't match");
2569 in_system_header
= entering_system_header
;
2572 /* If NEXTCHAR is not end of line, we don't care what it is. */
2573 if (nextchar
== EOF
)
2577 error ("invalid #-line");
2579 /* skip the rest of this line. */
2584 while ((c
= getch ()) != EOF
&& c
!= '\n');
2589 do_pending_lang_change ()
2591 for (; pending_lang_change
> 0; --pending_lang_change
)
2592 push_lang_context (lang_name_c
);
2593 for (; pending_lang_change
< 0; ++pending_lang_change
)
2594 pop_lang_context ();
2597 #define ENDFILE -1 /* token that represents end-of-file */
2599 /* Read an escape sequence, returning its equivalent as a character,
2600 or store 1 in *ignore_ptr if it is backslash-newline. */
2603 readescape (ignore_ptr
)
2606 register int c
= getch ();
2608 register unsigned count
;
2609 unsigned firstdig
= 0;
2627 if (c
>= 'a' && c
<= 'f')
2628 code
+= c
- 'a' + 10;
2629 if (c
>= 'A' && c
<= 'F')
2630 code
+= c
- 'A' + 10;
2631 if (c
>= '0' && c
<= '9')
2633 if (code
!= 0 || count
!= 0)
2642 error ("\\x used with no following hex digits");
2643 else if (count
== 0)
2644 /* Digits are all 0's. Ok. */
2646 else if ((count
- 1) * 4 >= TYPE_PRECISION (integer_type_node
)
2648 && ((1 << (TYPE_PRECISION (integer_type_node
) - (count
- 1) * 4))
2650 pedwarn ("hex escape out of range");
2653 case '0': case '1': case '2': case '3': case '4':
2654 case '5': case '6': case '7':
2657 while ((c
<= '7') && (c
>= '0') && (count
++ < 3))
2659 code
= (code
* 8) + (c
- '0');
2665 case '\\': case '\'': case '"':
2674 return TARGET_NEWLINE
;
2697 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c
);
2703 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2707 /* `\%' is used to prevent SCCS from getting confused. */
2710 pedwarn ("unknown escape sequence `\\%c'", c
);
2713 if (c
>= 040 && c
< 0177)
2714 pedwarn ("unknown escape sequence `\\%c'", c
);
2716 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c
);
2720 /* Value is 1 (or 2) if we should try to make the next identifier look like
2721 a typename (when it may be a local variable or a class variable).
2722 Value is 0 if we treat this name in a default fashion. */
2723 int looking_for_typename
= 0;
2729 identifier_type (decl
)
2732 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2734 if (TREE_CODE (DECL_RESULT (decl
)) == TYPE_DECL
)
2736 else if (looking_for_template
)
2739 if (looking_for_template
&& really_overloaded_fn (decl
))
2742 for (t
= decl
; t
!= NULL_TREE
; t
= OVL_CHAIN (t
))
2743 if (DECL_FUNCTION_TEMPLATE_P (OVL_FUNCTION (t
)))
2746 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2748 if (TREE_CODE (decl
) != TYPE_DECL
)
2750 if (((got_scope
&& TREE_TYPE (decl
) == got_scope
)
2751 || TREE_TYPE (decl
) == current_class_type
)
2752 && DECL_ARTIFICIAL (decl
))
2760 /* Only types expected, not even namespaces. */
2761 looking_for_typename
= 2;
2763 if ((yychar
= yylex ()) < 0) yychar
= 0;
2764 looking_for_typename
= 0;
2765 if (yychar
== IDENTIFIER
)
2767 lastiddecl
= lookup_name (yylval
.ttype
, -2);
2768 if (lastiddecl
== 0)
2771 lastiddecl
= IDENTIFIER_LABEL_VALUE (yylval
.ttype
);
2774 yychar
= identifier_type (lastiddecl
);
2779 do_identifier (token
, parsing
)
2780 register tree token
;
2785 if (! parsing
|| IDENTIFIER_OPNAME_P (token
))
2786 id
= lookup_name (token
, 0);
2790 if (parsing
&& yychar
== YYEMPTY
)
2792 /* Scope class declarations before global
2794 if (id
== IDENTIFIER_NAMESPACE_VALUE (token
)
2795 && current_class_type
!= 0
2796 && TYPE_SIZE (current_class_type
) == 0)
2798 /* Could be from one of the base classes. */
2799 tree field
= lookup_field (current_class_type
, token
, 1, 0);
2802 else if (field
== error_mark_node
)
2803 /* We have already generated the error message.
2804 But we still want to return this value. */
2805 id
= lookup_field (current_class_type
, token
, 0, 0);
2806 else if (TREE_CODE (field
) == VAR_DECL
2807 || TREE_CODE (field
) == CONST_DECL
2808 || TREE_CODE (field
) == TEMPLATE_DECL
)
2810 else if (TREE_CODE (field
) != FIELD_DECL
)
2811 my_friendly_abort (61);
2814 cp_error ("invalid use of member `%D' from base class `%T'", field
,
2815 DECL_FIELD_CONTEXT (field
));
2816 id
= error_mark_node
;
2821 /* Remember that this name has been used in the class definition, as per
2823 if (id
&& current_class_type
&& parsing
2824 && TYPE_BEING_DEFINED (current_class_type
)
2825 && ! IDENTIFIER_CLASS_VALUE (token
)
2826 /* Avoid breaking if we get called for a default argument that
2827 refers to an overloaded method. Eventually this will not be
2828 necessary, since default arguments shouldn't be parsed until
2829 after the class is complete. (jason 3/12/97) */
2830 && TREE_CODE (id
) != OVERLOAD
)
2831 pushdecl_class_level (id
);
2833 if (!id
|| id
== error_mark_node
)
2835 if (id
== error_mark_node
&& current_class_type
!= NULL_TREE
)
2837 id
= lookup_nested_field (token
, 1);
2838 /* In lookup_nested_field(), we marked this so we can gracefully
2839 leave this whole mess. */
2840 if (id
&& id
!= error_mark_node
&& TREE_TYPE (id
) == error_mark_node
)
2844 if (current_template_parms
)
2845 return build_min_nt (LOOKUP_EXPR
, token
, NULL_TREE
);
2846 else if (IDENTIFIER_OPNAME_P (token
))
2848 if (token
!= ansi_opname
[ERROR_MARK
])
2849 cp_error ("`%D' not defined", token
);
2850 id
= error_mark_node
;
2852 else if (parsing
&& (yychar
== '(' || yychar
== LEFT_RIGHT
))
2854 id
= implicitly_declare (token
);
2856 else if (current_function_decl
== 0)
2858 cp_error ("`%D' was not declared in this scope", token
);
2859 id
= error_mark_node
;
2863 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
2864 || IDENTIFIER_ERROR_LOCUS (token
) != current_function_decl
)
2866 static int undeclared_variable_notice
;
2868 cp_error ("`%D' undeclared (first use this function)", token
);
2870 if (! undeclared_variable_notice
)
2872 error ("(Each undeclared identifier is reported only once");
2873 error ("for each function it appears in.)");
2874 undeclared_variable_notice
= 1;
2877 id
= error_mark_node
;
2878 /* Prevent repeated error messages. */
2879 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
2880 SET_IDENTIFIER_ERROR_LOCUS (token
, current_function_decl
);
2884 if (TREE_CODE (id
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (id
))
2886 tree shadowed
= DECL_SHADOWED_FOR_VAR (id
);
2887 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
2888 && DECL_DEAD_FOR_LOCAL (shadowed
))
2889 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
2891 shadowed
= IDENTIFIER_NAMESPACE_VALUE (DECL_NAME (id
));
2894 if (!DECL_ERROR_REPORTED (id
))
2896 warning ("name lookup of `%s' changed",
2897 IDENTIFIER_POINTER (token
));
2898 cp_warning_at (" matches this `%D' under current ANSI rules",
2900 cp_warning_at (" matches this `%D' under old rules", id
);
2901 DECL_ERROR_REPORTED (id
) = 1;
2905 else if (!DECL_ERROR_REPORTED (id
))
2908 = "name lookup of `%s' changed for new ANSI `for' scoping";
2909 DECL_ERROR_REPORTED (id
) = 1;
2910 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id
)))
2912 error (msg
, IDENTIFIER_POINTER (token
));
2913 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id
);
2914 id
= error_mark_node
;
2918 pedwarn (msg
, IDENTIFIER_POINTER (token
));
2919 cp_pedwarn_at (" using obsolete binding at `%D'", id
);
2923 /* TREE_USED is set in `hack_identifier'. */
2924 if (TREE_CODE (id
) == CONST_DECL
)
2926 if (IDENTIFIER_CLASS_VALUE (token
) == id
)
2929 tree access
= compute_access (TYPE_BINFO (current_class_type
), id
);
2930 if (access
== access_private_node
)
2931 cp_error ("enum `%D' is private", id
);
2932 /* protected is OK, since it's an enum of `this'. */
2934 if (! processing_template_decl
2935 || (DECL_INITIAL (id
)
2936 && TREE_CODE (DECL_INITIAL (id
)) == TEMPLATE_PARM_INDEX
))
2937 id
= DECL_INITIAL (id
);
2940 id
= hack_identifier (id
, token
);
2942 if (current_template_parms
)
2944 if (is_overloaded_fn (id
))
2946 tree t
= build_min (LOOKUP_EXPR
, unknown_type_node
,
2947 token
, get_first_fn (id
));
2948 if (id
!= IDENTIFIER_NAMESPACE_VALUE (token
))
2949 TREE_OPERAND (t
, 1) = error_mark_node
;
2952 else if (! TREE_PERMANENT (id
) || TREE_CODE (id
) == PARM_DECL
2953 || TREE_CODE (id
) == USING_DECL
)
2954 id
= build_min (LOOKUP_EXPR
, TREE_TYPE (id
), token
, error_mark_node
);
2955 /* else just use the decl */
2962 do_scoped_id (token
, parsing
)
2967 /* during parsing, this is ::name. Otherwise, it is black magic. */
2970 struct tree_binding _b
;
2971 id
= binding_init (&_b
);
2972 if (!qualified_lookup_using_namespace (token
, global_namespace
, id
))
2975 id
= BINDING_VALUE (id
);
2978 id
= IDENTIFIER_GLOBAL_VALUE (token
);
2979 if (parsing
&& yychar
== YYEMPTY
)
2983 if (processing_template_decl
)
2985 id
= build_min_nt (LOOKUP_EXPR
, token
, NULL_TREE
);
2986 LOOKUP_EXPR_GLOBAL (id
) = 1;
2989 if (parsing
&& (yychar
== '(' || yychar
== LEFT_RIGHT
))
2990 id
= implicitly_declare (token
);
2993 if (IDENTIFIER_NAMESPACE_VALUE (token
) != error_mark_node
)
2994 error ("undeclared variable `%s' (first use here)",
2995 IDENTIFIER_POINTER (token
));
2996 id
= error_mark_node
;
2997 /* Prevent repeated error messages. */
2998 SET_IDENTIFIER_NAMESPACE_VALUE (token
, error_mark_node
);
3003 if (TREE_CODE (id
) == ADDR_EXPR
)
3004 mark_used (TREE_OPERAND (id
, 0));
3005 else if (TREE_CODE (id
) != OVERLOAD
)
3008 if (TREE_CODE (id
) == CONST_DECL
&& ! processing_template_decl
)
3010 /* XXX CHS - should we set TREE_USED of the constant? */
3011 id
= DECL_INITIAL (id
);
3012 /* This is to prevent an enum whose value is 0
3013 from being considered a null pointer constant. */
3014 id
= build1 (NOP_EXPR
, TREE_TYPE (id
), id
);
3015 TREE_CONSTANT (id
) = 1;
3018 if (processing_template_decl
)
3020 if (is_overloaded_fn (id
))
3022 id
= build_min (LOOKUP_EXPR
, unknown_type_node
,
3023 token
, get_first_fn (id
));
3024 LOOKUP_EXPR_GLOBAL (id
) = 1;
3026 /* else just use the decl */
3028 return convert_from_reference (id
);
3032 identifier_typedecl_value (node
)
3036 type
= IDENTIFIER_TYPE_VALUE (node
);
3037 if (type
== NULL_TREE
)
3042 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3045 do (IDENTIFIER_LOCAL_VALUE (node
));
3046 do (IDENTIFIER_CLASS_VALUE (node
));
3047 do (IDENTIFIER_NAMESPACE_VALUE (node
));
3049 /* Will this one ever happen? */
3050 if (TYPE_MAIN_DECL (type
))
3051 return TYPE_MAIN_DECL (type
);
3053 /* We used to do an internal error of 62 here, but instead we will
3054 handle the return of a null appropriately in the callers. */
3064 int dollar_seen
= 0;
3068 c
= nextchar
, nextchar
= -1;
3072 /* Effectively do c = skip_white_space (c)
3073 but do it faster in the usual cases. */
3086 /* Call skip_white_space so we can warn if appropriate. */
3091 c
= skip_white_space (c
);
3093 goto found_nonwhite
;
3097 token_buffer
[0] = c
;
3098 token_buffer
[1] = 0;
3100 /* yylloc.first_line = lineno; */
3105 token_buffer
[0] = '\0';
3107 if (input_redirected ())
3108 value
= END_OF_SAVED_INPUT
;
3110 value
= END_OF_LINE
;
3116 if (! dollars_in_ident
)
3117 error ("`$' in identifier");
3119 pedwarn ("`$' in identifier");
3124 /* Capital L may start a wide-string or wide-character constant. */
3126 register int c
= getch ();
3135 goto string_constant
;
3140 case 'A': case 'B': case 'C': case 'D': case 'E':
3141 case 'F': case 'G': case 'H': case 'I': case 'J':
3142 case 'K': case 'M': case 'N': case 'O':
3143 case 'P': case 'Q': case 'R': case 'S': case 'T':
3144 case 'U': case 'V': case 'W': case 'X': case 'Y':
3146 case 'a': case 'b': case 'c': case 'd': case 'e':
3147 case 'f': case 'g': case 'h': case 'i': case 'j':
3148 case 'k': case 'l': case 'm': case 'n': case 'o':
3149 case 'p': case 'q': case 'r': case 's': case 't':
3150 case 'u': case 'v': case 'w': case 'x': case 'y':
3160 /* We know that `token_buffer' can hold at least on char,
3161 so we install C immediately.
3162 We may have to read the value in `putback_char', so call
3167 /* Make this run fast. We know that we are reading straight
3168 from FINPUT in this case (since identifiers cannot straddle
3170 while (ISALNUM (c
) || (c
== '_') || c
== '$')
3174 if (! dollars_in_ident
)
3175 error ("`$' in identifier");
3177 pedwarn ("`$' in identifier");
3180 if (p
>= token_buffer
+ maxtoken
)
3181 p
= extend_token_buffer (p
);
3187 if (linemode
&& c
== '\n')
3195 /* We know that `token_buffer' can hold at least on char,
3196 so we install C immediately. */
3200 while (ISALNUM (c
) || (c
== '_') || c
== '$')
3204 if (! dollars_in_ident
)
3205 error ("`$' in identifier");
3207 pedwarn ("`$' in identifier");
3210 if (p
>= token_buffer
+ maxtoken
)
3211 p
= extend_token_buffer (p
);
3224 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3227 register struct resword
*ptr
;
3229 if ((ptr
= is_reserved_word (token_buffer
, p
- token_buffer
)))
3233 tree old_ttype
= ridpointers
[(int) ptr
->rid
];
3235 /* If this provides a type for us, then revert lexical
3236 state to standard state. */
3237 if (TREE_CODE (old_ttype
) == IDENTIFIER_NODE
3238 && IDENTIFIER_GLOBAL_VALUE (old_ttype
) != 0
3239 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype
)) == TYPE_DECL
)
3240 looking_for_typename
= 0;
3241 else if (ptr
->token
== AGGR
|| ptr
->token
== ENUM
)
3242 looking_for_typename
= 2;
3244 /* Check if this is a language-type declaration.
3245 Just glimpse the next non-white character. */
3246 nextchar
= skip_white_space (nextchar
);
3247 if (nextchar
== '"')
3249 /* We are looking at a string. Complain
3250 if the token before the string is no `extern'.
3252 Could cheat some memory by placing this string
3253 on the temporary_, instead of the saveable_
3256 if (ptr
->rid
!= RID_EXTERN
)
3257 error ("invalid modifier `%s' for language string",
3260 value
= EXTERN_LANG_STRING
;
3261 yylval
.ttype
= get_identifier (TREE_STRING_POINTER (yylval
.ttype
));
3264 if (ptr
->token
== VISSPEC
)
3269 yylval
.ttype
= access_public_node
;
3272 yylval
.ttype
= access_private_node
;
3275 yylval
.ttype
= access_protected_node
;
3278 my_friendly_abort (63);
3282 yylval
.ttype
= old_ttype
;
3284 else if (ptr
->token
== EQCOMPARE
)
3286 yylval
.code
= NE_EXPR
;
3287 token_buffer
[0] = '!';
3288 token_buffer
[1] = '=';
3289 token_buffer
[2] = 0;
3291 else if (ptr
->token
== ASSIGN
)
3293 if (strcmp ("and_eq", token_buffer
) == 0)
3295 yylval
.code
= BIT_AND_EXPR
;
3296 token_buffer
[0] = '&';
3298 else if (strcmp ("or_eq", token_buffer
) == 0)
3300 yylval
.code
= BIT_IOR_EXPR
;
3301 token_buffer
[0] = '|';
3303 else if (strcmp ("xor_eq", token_buffer
) == 0)
3305 yylval
.code
= BIT_XOR_EXPR
;
3306 token_buffer
[0] = '^';
3308 token_buffer
[1] = '=';
3309 token_buffer
[2] = 0;
3311 else if (ptr
->token
== '&')
3313 yylval
.code
= BIT_AND_EXPR
;
3314 token_buffer
[0] = '&';
3315 token_buffer
[1] = 0;
3317 else if (ptr
->token
== '|')
3319 yylval
.code
= BIT_IOR_EXPR
;
3320 token_buffer
[0] = '|';
3321 token_buffer
[1] = 0;
3323 else if (ptr
->token
== '^')
3325 yylval
.code
= BIT_XOR_EXPR
;
3326 token_buffer
[0] = '^';
3327 token_buffer
[1] = 0;
3330 value
= (int) ptr
->token
;
3334 /* If we did not find a keyword, look for an identifier
3337 if (value
== IDENTIFIER
|| value
== TYPESPEC
)
3338 GNU_xref_ref (current_function_decl
, token_buffer
);
3340 if (value
== IDENTIFIER
)
3342 register tree tmp
= get_identifier (token_buffer
);
3344 #if !defined(VMS) && defined(JOINER)
3345 /* Make sure that user does not collide with our internal
3349 && (THIS_NAME_P (tmp
)
3350 || VPTR_NAME_P (tmp
)
3351 || DESTRUCTOR_NAME_P (tmp
)
3352 || VTABLE_NAME_P (tmp
)
3353 || TEMP_NAME_P (tmp
)
3354 || ANON_AGGRNAME_P (tmp
)
3355 || ANON_PARMNAME_P (tmp
)))
3356 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3362 if (value
== NEW
&& ! global_bindings_p ())
3372 register int c1
= getch ();
3373 token_buffer
[0] = c
;
3374 token_buffer
[1] = c1
;
3378 token_buffer
[2] = 0;
3386 token_buffer
[2] = c1
;
3387 token_buffer
[3] = 0;
3391 error ("parse error at `..'");
3396 goto resume_numerical_scan
;
3400 token_buffer
[1] = 0;
3404 /* Optimize for most frequent case. */
3406 register int c1
= getch ();
3407 if (! ISALNUM (c1
) && c1
!= '.')
3409 /* Terminate string. */
3410 token_buffer
[0] = c
;
3411 token_buffer
[1] = 0;
3413 yylval
.ttype
= integer_zero_node
;
3415 yylval
.ttype
= integer_one_node
;
3422 /* fall through... */
3423 case '2': case '3': case '4':
3424 case '5': case '6': case '7': case '8': case '9':
3425 resume_numerical_scan
:
3430 int largest_digit
= 0;
3432 /* for multi-precision arithmetic,
3433 we actually store only HOST_BITS_PER_CHAR bits in each part.
3434 The number of parts is chosen so as to be sufficient to hold
3435 the enough bits to fit into the two HOST_WIDE_INTs that contain
3436 the integer value (this is always at least as many bits as are
3437 in a target `long long' value, but may be wider). */
3438 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3439 int parts
[TOTAL_PARTS
];
3442 enum anon1
{ NOT_FLOAT
, AFTER_POINT
, TOO_MANY_POINTS
} floatflag
3445 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3453 *p
++ = (c
= getch ());
3454 if ((c
== 'x') || (c
== 'X'))
3457 *p
++ = (c
= getch ());
3459 /* Leading 0 forces octal unless the 0 is the only digit. */
3460 else if (c
>= '0' && c
<= '9')
3469 /* Read all the digits-and-decimal-points. */
3472 || (ISALNUM (c
) && (c
!= 'l') && (c
!= 'L')
3473 && (c
!= 'u') && (c
!= 'U')
3474 && c
!= 'i' && c
!= 'I' && c
!= 'j' && c
!= 'J'
3475 && (floatflag
== NOT_FLOAT
|| ((c
!= 'f') && (c
!= 'F')))))
3480 error ("floating constant may not be in radix 16");
3481 if (floatflag
== TOO_MANY_POINTS
)
3482 /* We have already emitted an error. Don't need another. */
3484 else if (floatflag
== AFTER_POINT
)
3486 error ("malformed floating constant");
3487 floatflag
= TOO_MANY_POINTS
;
3488 /* Avoid another error from atof by forcing all characters
3489 from here on to be ignored. */
3493 floatflag
= AFTER_POINT
;
3496 *p
++ = c
= getch ();
3497 /* Accept '.' as the start of a floating-point number
3498 only when it is followed by a digit.
3499 Otherwise, unread the following non-digit
3500 and use the '.' as a structural token. */
3501 if (p
== token_buffer
+ 2 && !ISDIGIT (c
))
3513 error ("parse error at `..'");
3516 token_buffer
[1] = '\0';
3523 /* It is not a decimal point.
3524 It should be a digit (perhaps a hex digit). */
3530 else if (base
<= 10)
3532 if (c
== 'e' || c
== 'E')
3535 floatflag
= AFTER_POINT
;
3536 break; /* start of exponent */
3538 error ("nondigits in number and not hexadecimal");
3549 if (c
>= largest_digit
)
3553 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3555 parts
[count
] *= base
;
3559 += (parts
[count
-1] >> HOST_BITS_PER_CHAR
);
3561 &= (1 << HOST_BITS_PER_CHAR
) - 1;
3567 /* If the extra highest-order part ever gets anything in it,
3568 the number is certainly too big. */
3569 if (parts
[TOTAL_PARTS
- 1] != 0)
3572 if (p
>= token_buffer
+ maxtoken
- 3)
3573 p
= extend_token_buffer (p
);
3574 *p
++ = (c
= getch ());
3579 error ("numeric constant with no digits");
3581 if (largest_digit
>= base
)
3582 error ("numeric constant contains digits beyond the radix");
3584 /* Remove terminating char from the token buffer and delimit the string */
3587 if (floatflag
!= NOT_FLOAT
)
3589 tree type
= double_type_node
;
3590 int exceeds_double
= 0;
3592 REAL_VALUE_TYPE value
;
3595 /* Read explicit exponent if any, and put it in tokenbuf. */
3597 if ((c
== 'e') || (c
== 'E'))
3599 if (p
>= token_buffer
+ maxtoken
- 3)
3600 p
= extend_token_buffer (p
);
3603 if ((c
== '+') || (c
== '-'))
3609 error ("floating constant exponent has no digits");
3612 if (p
>= token_buffer
+ maxtoken
- 3)
3613 p
= extend_token_buffer (p
);
3622 /* Convert string to a double, checking for overflow. */
3623 if (setjmp (handler
))
3625 error ("floating constant out of range");
3630 int fflag
= 0, lflag
= 0;
3631 /* Copy token_buffer now, while it has just the number
3632 and not the suffixes; once we add `f' or `i',
3633 REAL_VALUE_ATOF may not work any more. */
3634 char *copy
= (char *) alloca (p
- token_buffer
+ 1);
3635 bcopy (token_buffer
, copy
, p
- token_buffer
+ 1);
3637 set_float_handler (handler
);
3643 /* Read the suffixes to choose a data type. */
3648 error ("more than one `f' in numeric constant");
3654 error ("more than one `l' in numeric constant");
3660 error ("more than one `i' or `j' in numeric constant");
3662 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3673 if (p
>= token_buffer
+ maxtoken
- 3)
3674 p
= extend_token_buffer (p
);
3680 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3681 tells the desired precision of the binary result
3682 of decimal-to-binary conversion. */
3687 error ("both `f' and `l' in floating constant");
3689 type
= float_type_node
;
3690 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3691 /* A diagnostic is required here by some ANSI C testsuites.
3692 This is not pedwarn, become some people don't want
3693 an error for this. */
3694 if (REAL_VALUE_ISINF (value
) && pedantic
)
3695 warning ("floating point number exceeds range of `float'");
3699 type
= long_double_type_node
;
3700 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3701 if (REAL_VALUE_ISINF (value
) && pedantic
)
3702 warning ("floating point number exceeds range of `long double'");
3706 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3707 if (REAL_VALUE_ISINF (value
) && pedantic
)
3708 warning ("floating point number exceeds range of `double'");
3711 set_float_handler (NULL_PTR
);
3714 if (errno
== ERANGE
&& pedantic
)
3716 /* ERANGE is also reported for underflow,
3717 so test the value to distinguish overflow from that. */
3718 if (REAL_VALUES_LESS (dconst1
, value
)
3719 || REAL_VALUES_LESS (value
, dconstm1
))
3721 pedwarn ("floating point number exceeds range of `%s'",
3722 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type
)));
3728 /* If the result is not a number, assume it must have been
3729 due to some error message above, so silently convert
3731 if (REAL_VALUE_ISNAN (value
))
3734 /* Create a node with determined type and value. */
3736 yylval
.ttype
= build_complex (NULL_TREE
,
3737 cp_convert (type
, integer_zero_node
),
3738 build_real (type
, value
));
3740 yylval
.ttype
= build_real (type
, value
);
3745 HOST_WIDE_INT high
, low
;
3746 int spec_unsigned
= 0;
3748 int spec_long_long
= 0;
3754 if (c
== 'u' || c
== 'U')
3757 error ("two `u's in integer constant");
3760 else if (c
== 'l' || c
== 'L')
3765 error ("three `l's in integer constant");
3767 pedwarn ("ANSI C++ forbids long long integer constants");
3772 else if (c
== 'i' || c
== 'j' || c
== 'I' || c
== 'J')
3775 error ("more than one `i' or `j' in numeric constant");
3777 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3782 if (p
>= token_buffer
+ maxtoken
- 3)
3783 p
= extend_token_buffer (p
);
3788 /* If the constant is not long long and it won't fit in an
3789 unsigned long, or if the constant is long long and won't fit
3790 in an unsigned long long, then warn that the constant is out
3793 /* ??? This assumes that long long and long integer types are
3794 a multiple of 8 bits. This better than the original code
3795 though which assumed that long was exactly 32 bits and long
3796 long was exactly 64 bits. */
3799 bytes
= TYPE_PRECISION (long_long_integer_type_node
) / 8;
3801 bytes
= TYPE_PRECISION (long_integer_type_node
) / 8;
3804 for (i
= bytes
; i
< TOTAL_PARTS
; i
++)
3808 pedwarn ("integer constant out of range");
3810 /* This is simplified by the fact that our constant
3811 is always positive. */
3814 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
; i
++)
3816 high
|= ((HOST_WIDE_INT
) parts
[i
+ (HOST_BITS_PER_WIDE_INT
3817 / HOST_BITS_PER_CHAR
)]
3818 << (i
* HOST_BITS_PER_CHAR
));
3819 low
|= (HOST_WIDE_INT
) parts
[i
] << (i
* HOST_BITS_PER_CHAR
);
3823 yylval
.ttype
= build_int_2 (low
, high
);
3824 TREE_TYPE (yylval
.ttype
) = long_long_unsigned_type_node
;
3826 /* Calculate the ANSI type. */
3827 if (!spec_long
&& !spec_unsigned
3828 && int_fits_type_p (yylval
.ttype
, integer_type_node
))
3829 type
= integer_type_node
;
3830 else if (!spec_long
&& (base
!= 10 || spec_unsigned
)
3831 && int_fits_type_p (yylval
.ttype
, unsigned_type_node
))
3832 /* Nondecimal constants try unsigned even in traditional C. */
3833 type
= unsigned_type_node
;
3834 else if (!spec_unsigned
&& !spec_long_long
3835 && int_fits_type_p (yylval
.ttype
, long_integer_type_node
))
3836 type
= long_integer_type_node
;
3837 else if (! spec_long_long
)
3838 type
= long_unsigned_type_node
;
3839 else if (! spec_unsigned
3840 /* Verify value does not overflow into sign bit. */
3841 && TREE_INT_CST_HIGH (yylval
.ttype
) >= 0
3842 && int_fits_type_p (yylval
.ttype
,
3843 long_long_integer_type_node
))
3844 type
= long_long_integer_type_node
;
3846 type
= long_long_unsigned_type_node
;
3848 if (!int_fits_type_p (yylval
.ttype
, type
) && !warn
)
3849 pedwarn ("integer constant out of range");
3851 if (base
== 10 && ! spec_unsigned
&& TREE_UNSIGNED (type
))
3852 warning ("decimal integer constant is so large that it is unsigned");
3856 if (TYPE_PRECISION (type
)
3857 <= TYPE_PRECISION (integer_type_node
))
3859 = build_complex (NULL_TREE
, integer_zero_node
,
3860 cp_convert (integer_type_node
,
3863 error ("complex integer constant is too wide for `__complex int'");
3866 TREE_TYPE (yylval
.ttype
) = type
;
3872 value
= CONSTANT
; break;
3878 register int result
= 0;
3879 register int num_chars
= 0;
3880 unsigned width
= TYPE_PRECISION (char_type_node
);
3885 width
= WCHAR_TYPE_SIZE
;
3886 #ifdef MULTIBYTE_CHARS
3887 max_chars
= MB_CUR_MAX
;
3893 max_chars
= TYPE_PRECISION (integer_type_node
) / width
;
3901 if (c
== '\'' || c
== EOF
)
3907 c
= readescape (&ignore
);
3910 if (width
< HOST_BITS_PER_INT
3911 && (unsigned) c
>= (1 << width
))
3912 warning ("escape sequence out of range for character");
3913 #ifdef MAP_CHARACTER
3915 c
= MAP_CHARACTER (c
);
3921 pedwarn ("ANSI C++ forbids newline in character constant");
3924 #ifdef MAP_CHARACTER
3926 c
= MAP_CHARACTER (c
);
3930 if (num_chars
> maxtoken
- 4)
3931 extend_token_buffer (token_buffer
);
3933 token_buffer
[num_chars
] = c
;
3935 /* Merge character into result; ignore excess chars. */
3936 if (num_chars
< max_chars
+ 1)
3938 if (width
< HOST_BITS_PER_INT
)
3939 result
= (result
<< width
) | (c
& ((1 << width
) - 1));
3945 token_buffer
[num_chars
+ 1] = '\'';
3946 token_buffer
[num_chars
+ 2] = 0;
3949 error ("malformatted character constant");
3950 else if (num_chars
== 0)
3951 error ("empty character constant");
3952 else if (num_chars
> max_chars
)
3954 num_chars
= max_chars
;
3955 error ("character constant too long");
3957 else if (num_chars
!= 1)
3958 warning ("multi-character character constant");
3960 /* If char type is signed, sign-extend the constant. */
3963 int num_bits
= num_chars
* width
;
3965 /* We already got an error; avoid invalid shift. */
3966 yylval
.ttype
= build_int_2 (0, 0);
3967 else if (TREE_UNSIGNED (char_type_node
)
3968 || ((result
>> (num_bits
- 1)) & 1) == 0)
3970 = build_int_2 (result
& ((unsigned HOST_WIDE_INT
) ~0
3971 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
3975 = build_int_2 (result
| ~((unsigned HOST_WIDE_INT
) ~0
3976 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
3979 TREE_TYPE (yylval
.ttype
) = char_type_node
;
3981 TREE_TYPE (yylval
.ttype
) = integer_type_node
;
3985 #ifdef MULTIBYTE_CHARS
3986 /* Set the initial shift state and convert the next sequence. */
3988 /* In all locales L'\0' is zero and mbtowc will return zero,
3991 || (num_chars
== 1 && token_buffer
[1] != '\0'))
3994 (void) mbtowc (NULL
, NULL
, 0);
3995 if (mbtowc (& wc
, token_buffer
+ 1, num_chars
) == num_chars
)
3998 warning ("Ignoring invalid multibyte character");
4001 yylval
.ttype
= build_int_2 (result
, 0);
4002 TREE_TYPE (yylval
.ttype
) = wchar_type_node
;
4015 p
= token_buffer
+ 1;
4017 while (c
!= '"' && c
>= 0)
4019 /* ignore_escape_flag is set for reading the filename in #line. */
4020 if (!ignore_escape_flag
&& c
== '\\')
4023 c
= readescape (&ignore
);
4027 && TYPE_PRECISION (char_type_node
) < HOST_BITS_PER_INT
4028 && c
>= ((unsigned) 1 << TYPE_PRECISION (char_type_node
)))
4029 warning ("escape sequence out of range for character");
4034 pedwarn ("ANSI C++ forbids newline in string constant");
4038 if (p
== token_buffer
+ maxtoken
)
4039 p
= extend_token_buffer (p
);
4045 error ("Unterminated string");
4051 /* We have read the entire constant.
4052 Construct a STRING_CST for the result. */
4056 /* If this is a L"..." wide-string, convert the multibyte string
4057 to a wide character string. */
4058 char *widep
= (char *) alloca ((p
- token_buffer
) * WCHAR_BYTES
);
4061 #ifdef MULTIBYTE_CHARS
4062 len
= mbstowcs ((wchar_t *) widep
, token_buffer
+ 1, p
- token_buffer
);
4063 if (len
< 0 || len
>= (p
- token_buffer
))
4065 warning ("Ignoring invalid multibyte string");
4068 bzero (widep
+ (len
* WCHAR_BYTES
), WCHAR_BYTES
);
4073 wp
= widep
+ (BYTES_BIG_ENDIAN
? WCHAR_BYTES
- 1 : 0);
4074 bzero (widep
, (p
- token_buffer
) * WCHAR_BYTES
);
4075 for (cp
= token_buffer
+ 1; cp
< p
; cp
++)
4076 *wp
= *cp
, wp
+= WCHAR_BYTES
;
4077 len
= p
- token_buffer
- 1;
4080 if (processing_template_decl
)
4081 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4082 yylval
.ttype
= build_string ((len
+ 1) * WCHAR_BYTES
, widep
);
4083 if (processing_template_decl
)
4085 TREE_TYPE (yylval
.ttype
) = wchar_array_type_node
;
4089 if (processing_template_decl
)
4090 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4091 yylval
.ttype
= build_string (p
- token_buffer
, token_buffer
+ 1);
4092 if (processing_template_decl
)
4094 TREE_TYPE (yylval
.ttype
) = char_array_type_node
;
4100 value
= STRING
; break;
4123 yylval
.code
= PLUS_EXPR
; break;
4125 yylval
.code
= MINUS_EXPR
; break;
4127 yylval
.code
= BIT_AND_EXPR
; break;
4129 yylval
.code
= BIT_IOR_EXPR
; break;
4131 yylval
.code
= MULT_EXPR
; break;
4133 yylval
.code
= TRUNC_DIV_EXPR
; break;
4135 yylval
.code
= TRUNC_MOD_EXPR
; break;
4137 yylval
.code
= BIT_XOR_EXPR
; break;
4139 yylval
.code
= LSHIFT_EXPR
; break;
4141 yylval
.code
= RSHIFT_EXPR
; break;
4143 yylval
.code
= LT_EXPR
; break;
4145 yylval
.code
= GT_EXPR
; break;
4148 token_buffer
[1] = c1
= getch ();
4149 token_buffer
[2] = 0;
4156 value
= ARITHCOMPARE
; yylval
.code
= LE_EXPR
; goto done
;
4158 value
= ARITHCOMPARE
; yylval
.code
= GE_EXPR
; goto done
;
4160 value
= EQCOMPARE
; yylval
.code
= NE_EXPR
; goto done
;
4162 value
= EQCOMPARE
; yylval
.code
= EQ_EXPR
; goto done
;
4164 value
= ASSIGN
; goto done
;
4170 value
= PLUSPLUS
; goto done
;
4172 value
= MINUSMINUS
; goto done
;
4174 value
= ANDAND
; goto done
;
4176 value
= OROR
; goto done
;
4184 else if ((c
== '-') && (c1
== '>'))
4186 nextchar
= getch ();
4187 if (nextchar
== '*')
4190 value
= POINTSAT_STAR
;
4196 else if (c1
== '?' && (c
== '<' || c
== '>'))
4198 token_buffer
[3] = 0;
4201 yylval
.code
= (c
== '<' ? MIN_EXPR
: MAX_EXPR
);
4204 /* <?= or >?= expression. */
4205 token_buffer
[2] = c1
;
4214 pedwarn ("use of `operator %s' is not standard C++",
4219 else if (c
== '<' && c1
== '%')
4220 { value
= '{'; goto done
; }
4221 else if (c
== '<' && c1
== ':')
4222 { value
= '['; goto done
; }
4223 else if (c
== '%' && c1
== '>')
4224 { value
= '}'; goto done
; }
4225 else if (c
== '%' && c1
== ':')
4226 { value
= '#'; goto done
; }
4229 token_buffer
[1] = 0;
4239 token_buffer
[1] = ':';
4240 token_buffer
[2] = '\0';
4257 /* Don't make yyparse think this is eof. */
4262 /* try, weakly, to handle casts to pointers to functions. */
4263 nextchar
= skip_white_space (getch ());
4264 if (nextchar
== '*')
4266 int next_c
= skip_white_space (getch ());
4270 yylval
.ttype
= build1 (INDIRECT_REF
, 0, 0);
4271 value
= PAREN_STAR_PAREN
;
4279 else if (nextchar
== ')')
4282 yylval
.ttype
= NULL_TREE
;
4293 /* yylloc.last_line = lineno; */
4294 #ifdef GATHER_STATISTICS
4295 #ifdef REDUCE_LENGTH
4296 token_count
[value
] += 1;
4307 return !!is_reserved_word (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
4310 #ifdef GATHER_STATISTICS
4311 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4312 need to be brought into here, unless this were actually put into a header
4314 /* Statistics-gathering stuff. */
4335 extern int tree_node_counts
[];
4336 extern int tree_node_sizes
[];
4339 /* Place to save freed lang_decls which were allocated on the
4340 permanent_obstack. @@ Not currently used. */
4341 tree free_lang_decl_chain
;
4344 build_lang_decl (code
, name
, type
)
4345 enum tree_code code
;
4349 register tree t
= build_decl (code
, name
, type
);
4350 struct obstack
*obstack
= current_obstack
;
4351 register int i
= sizeof (struct lang_decl
) / sizeof (int);
4354 if (! TREE_PERMANENT (t
))
4355 obstack
= saveable_obstack
;
4357 /* Could be that saveable is permanent and current is not. */
4358 obstack
= &permanent_obstack
;
4360 if (free_lang_decl_chain
&& obstack
== &permanent_obstack
)
4362 pi
= (int *)free_lang_decl_chain
;
4363 free_lang_decl_chain
= TREE_CHAIN (free_lang_decl_chain
);
4366 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_decl
));
4371 DECL_LANG_SPECIFIC (t
) = (struct lang_decl
*) pi
;
4372 LANG_DECL_PERMANENT ((struct lang_decl
*) pi
)
4373 = obstack
== &permanent_obstack
;
4374 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl
*) pi
)
4375 == TREE_PERMANENT (t
), 234);
4376 DECL_MAIN_VARIANT (t
) = t
;
4377 if (current_lang_name
== lang_name_cplusplus
)
4378 DECL_LANGUAGE (t
) = lang_cplusplus
;
4379 else if (current_lang_name
== lang_name_c
)
4380 DECL_LANGUAGE (t
) = lang_c
;
4381 else if (current_lang_name
== lang_name_java
)
4382 DECL_LANGUAGE (t
) = lang_java
;
4383 else my_friendly_abort (64);
4385 #if 0 /* not yet, should get fixed properly later */
4386 if (code
== TYPE_DECL
)
4389 id
= get_identifier (build_overload_name (type
, 1, 1));
4390 DECL_ASSEMBLER_NAME (t
) = id
;
4394 #ifdef GATHER_STATISTICS
4395 tree_node_counts
[(int)lang_decl
] += 1;
4396 tree_node_sizes
[(int)lang_decl
] += sizeof (struct lang_decl
);
4403 build_lang_field_decl (code
, name
, type
)
4404 enum tree_code code
;
4408 extern struct obstack
*current_obstack
, *saveable_obstack
;
4409 register tree t
= build_decl (code
, name
, type
);
4410 struct obstack
*obstack
= current_obstack
;
4411 register int i
= sizeof (struct lang_decl_flags
) / sizeof (int);
4413 #if 0 /* not yet, should get fixed properly later */
4415 if (code
== TYPE_DECL
)
4418 id
= get_identifier (build_overload_name (type
, 1, 1));
4419 DECL_ASSEMBLER_NAME (t
) = id
;
4423 if (! TREE_PERMANENT (t
))
4424 obstack
= saveable_obstack
;
4426 my_friendly_assert (obstack
== &permanent_obstack
, 235);
4428 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_decl_flags
));
4432 DECL_LANG_SPECIFIC (t
) = (struct lang_decl
*) pi
;
4437 copy_lang_decl (node
)
4443 if (! DECL_LANG_SPECIFIC (node
))
4446 if (TREE_CODE (node
) == FIELD_DECL
)
4447 size
= sizeof (struct lang_decl_flags
);
4449 size
= sizeof (struct lang_decl
);
4450 pi
= (int *)obstack_alloc (&permanent_obstack
, size
);
4451 bcopy ((char *)DECL_LANG_SPECIFIC (node
), (char *)pi
, size
);
4452 DECL_LANG_SPECIFIC (node
) = (struct lang_decl
*)pi
;
4456 make_lang_type (code
)
4457 enum tree_code code
;
4459 extern struct obstack
*current_obstack
, *saveable_obstack
;
4460 register tree t
= make_node (code
);
4461 struct obstack
*obstack
= current_obstack
;
4462 register int i
= sizeof (struct lang_type
) / sizeof (int);
4465 /* Set up some flags that give proper default behavior. */
4466 IS_AGGR_TYPE (t
) = 1;
4468 if (! TREE_PERMANENT (t
))
4469 obstack
= saveable_obstack
;
4471 my_friendly_assert (obstack
== &permanent_obstack
, 236);
4473 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_type
));
4477 TYPE_LANG_SPECIFIC (t
) = (struct lang_type
*) pi
;
4478 CLASSTYPE_AS_LIST (t
) = build_expr_list (NULL_TREE
, t
);
4479 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, interface_unknown
);
4480 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
4481 TYPE_BINFO (t
) = make_binfo (integer_zero_node
, t
, NULL_TREE
, NULL_TREE
,
4483 CLASSTYPE_BINFO_AS_LIST (t
) = build_tree_list (NULL_TREE
, TYPE_BINFO (t
));
4485 /* Make sure this is laid out, for ease of use later.
4486 In the presence of parse errors, the normal was of assuring
4487 this might not ever get executed, so we lay it out *immediately*. */
4488 build_pointer_type (t
);
4490 #ifdef GATHER_STATISTICS
4491 tree_node_counts
[(int)lang_type
] += 1;
4492 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
4499 dump_time_statistics ()
4501 register tree prev
= 0, decl
, next
;
4502 int this_time
= my_get_run_time ();
4503 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
))
4504 += this_time
- body_time
;
4506 fprintf (stderr
, "\n******\n");
4507 print_time ("header files (total)", header_time
);
4508 print_time ("main file (total)", this_time
- body_time
);
4509 fprintf (stderr
, "ratio = %g : 1\n",
4510 (double)header_time
/ (double)(this_time
- body_time
));
4511 fprintf (stderr
, "\n******\n");
4513 for (decl
= filename_times
; decl
; decl
= next
)
4515 next
= IDENTIFIER_GLOBAL_VALUE (decl
);
4516 SET_IDENTIFIER_GLOBAL_VALUE (decl
, prev
);
4520 for (decl
= prev
; decl
; decl
= IDENTIFIER_GLOBAL_VALUE (decl
))
4521 print_time (IDENTIFIER_POINTER (decl
),
4522 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl
)));
4526 compiler_error (s
, v
, v2
)
4528 HOST_WIDE_INT v
, v2
; /* @@also used as pointer */
4531 sprintf (buf
, s
, v
, v2
);
4532 error_with_file_and_line (input_filename
, lineno
, "%s (compiler error)", buf
);
4539 extern int end_of_file
;
4542 strcpy (buf
, string
);
4544 /* We can't print string and character constants well
4545 because the token_buffer contains the result of processing escapes. */
4547 strcat (buf
, input_redirected ()
4548 ? " at end of saved text"
4549 : " at end of input");
4550 else if (token_buffer
[0] == 0)
4551 strcat (buf
, " at null character");
4552 else if (token_buffer
[0] == '"')
4553 strcat (buf
, " before string constant");
4554 else if (token_buffer
[0] == '\'')
4555 strcat (buf
, " before character constant");
4556 else if (token_buffer
[0] < 040 || (unsigned char) token_buffer
[0] >= 0177)
4557 sprintf (buf
+ strlen (buf
), " before character 0%o",
4558 (unsigned char) token_buffer
[0]);
4560 strcat (buf
, " before `%s'");
4562 error (buf
, token_buffer
);
4566 handle_cp_pragma (pname
)
4571 if (! strcmp (pname
, "vtable"))
4573 extern tree pending_vtables
;
4575 /* More follows: it must be a string constant (class name). */
4576 token
= real_yylex ();
4577 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
4579 error ("invalid #pragma vtable");
4583 if (write_virtuals
!= 2)
4585 warning ("use `+e2' option to enable #pragma vtable");
4589 = perm_tree_cons (NULL_TREE
,
4590 get_identifier (TREE_STRING_POINTER (yylval
.ttype
)),
4592 token
= real_yylex ();
4593 if (token
!= END_OF_LINE
)
4594 warning ("trailing characters ignored");
4597 else if (! strcmp (pname
, "unit"))
4599 /* More follows: it must be a string constant (unit name). */
4600 token
= real_yylex ();
4601 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
4603 error ("invalid #pragma unit");
4606 token
= real_yylex ();
4607 if (token
!= END_OF_LINE
)
4608 warning ("trailing characters ignored");
4611 else if (! strcmp (pname
, "interface"))
4613 tree fileinfo
= IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename
));
4614 char *main_filename
= input_filename
;
4616 main_filename
= file_name_nondirectory (main_filename
);
4618 token
= real_yylex ();
4620 if (token
!= END_OF_LINE
)
4623 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
4625 error ("invalid `#pragma interface'");
4628 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
4629 token
= real_yylex ();
4632 if (token
!= END_OF_LINE
)
4633 warning ("garbage after `#pragma interface' ignored");
4635 #ifndef NO_LINKAGE_HEURISTICS
4638 if (impl_file_chain
== 0)
4640 /* If this is zero at this point, then we are
4641 auto-implementing. */
4642 if (main_input_filename
== 0)
4643 main_input_filename
= input_filename
;
4645 #ifdef AUTO_IMPLEMENT
4646 filename
= file_name_nondirectory (main_input_filename
);
4647 fi
= get_time_identifier (filename
);
4648 fi
= IDENTIFIER_CLASS_VALUE (fi
);
4649 TREE_INT_CST_LOW (fi
) = 0;
4650 TREE_INT_CST_HIGH (fi
) = 1;
4652 impl_file_chain
= (struct impl_files
*)permalloc (sizeof (struct impl_files
));
4653 impl_file_chain
->filename
= filename
;
4654 impl_file_chain
->next
= 0;
4658 interface_only
= interface_strcmp (main_filename
);
4659 interface_unknown
= 0;
4660 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
4661 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
4662 #endif /* NO_LINKAGE_HEURISTICS */
4666 else if (! strcmp (pname
, "implementation"))
4668 tree fileinfo
= IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename
));
4669 char *main_filename
= main_input_filename
? main_input_filename
: input_filename
;
4671 main_filename
= file_name_nondirectory (main_filename
);
4672 token
= real_yylex ();
4673 if (token
!= END_OF_LINE
)
4676 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
4678 error ("invalid `#pragma implementation'");
4681 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
4682 token
= real_yylex ();
4685 if (token
!= END_OF_LINE
)
4686 warning ("garbage after `#pragma implementation' ignored");
4688 #ifndef NO_LINKAGE_HEURISTICS
4689 if (write_virtuals
== 3)
4691 struct impl_files
*ifiles
= impl_file_chain
;
4694 if (! strcmp (ifiles
->filename
, main_filename
))
4696 ifiles
= ifiles
->next
;
4700 ifiles
= (struct impl_files
*) permalloc (sizeof (struct impl_files
));
4701 ifiles
->filename
= main_filename
;
4702 ifiles
->next
= impl_file_chain
;
4703 impl_file_chain
= ifiles
;
4706 else if ((main_input_filename
!= 0
4707 && ! strcmp (main_input_filename
, input_filename
))
4708 || ! strcmp (input_filename
, main_filename
))
4711 if (impl_file_chain
== 0)
4713 impl_file_chain
= (struct impl_files
*) permalloc (sizeof (struct impl_files
));
4714 impl_file_chain
->filename
= main_filename
;
4715 impl_file_chain
->next
= 0;
4719 error ("`#pragma implementation' can only appear at top-level");
4722 /* We make this non-zero so that we infer decl linkage
4723 in the impl file only for variables first declared
4724 in the interface file. */
4725 interface_unknown
= 1;
4727 /* We make this zero so that templates in the impl
4728 file will be emitted properly. */
4729 interface_unknown
= 0;
4731 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
4732 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
4733 #endif /* NO_LINKAGE_HEURISTICS */
4741 #ifdef HANDLE_SYSV_PRAGMA
4743 /* Handle a #pragma directive. INPUT is the current input stream,
4744 and C is a character to reread. Processes the entire input line
4745 and returns a character for the caller to reread: either \n or EOF. */
4747 /* This function has to be in this file, in order to get at
4751 handle_sysv_pragma (finput
, token
)
4763 handle_pragma_token ("ignored", yylval
.ttype
);
4766 handle_pragma_token ("(", NULL_TREE
);
4769 handle_pragma_token (")", NULL_TREE
);
4772 handle_pragma_token (",", NULL_TREE
);
4775 handle_pragma_token ("=", NULL_TREE
);
4778 handle_pragma_token ("(", NULL_TREE
);
4779 handle_pragma_token (")", NULL_TREE
);
4783 handle_pragma_token (NULL_PTR
, NULL_TREE
);
4786 token
= real_yylex ();
4789 #endif /* HANDLE_SYSV_PRAGMA */