1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987, 89, 92-96, 1997 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. */
29 #include <sys/types.h>
42 /* MULTIBYTE_CHARS support only works for native compilers.
43 ??? Ideally what we want is to model widechar support after
44 the current floating point support. */
46 #undef MULTIBYTE_CHARS
49 #ifdef MULTIBYTE_CHARS
55 #ifndef MULTIBYTE_CHARS
59 extern double atof ();
70 #ifdef NEED_DECLARATION_INDEX
71 extern char *index ();
74 #ifdef NEED_DECLARATION_RINDEX
75 extern char *rindex ();
79 extern int errno
; /* needed for VAX. */
82 #define obstack_chunk_alloc xmalloc
83 #define obstack_chunk_free free
86 #define DIR_SEPARATOR '/'
89 extern struct obstack permanent_obstack
;
90 extern struct obstack
*current_obstack
, *saveable_obstack
;
92 extern void yyprint
PROTO((FILE *, int, YYSTYPE
));
93 extern void set_float_handler
PROTO((jmp_buf));
94 extern void compiler_error
PROTO((char *, HOST_WIDE_INT
,
97 static tree get_time_identifier
PROTO((char *));
98 static int check_newline
PROTO((void));
99 static int skip_white_space
PROTO((int));
100 static int yynextch
PROTO((void));
101 static void finish_defarg
PROTO((void));
102 static int my_get_run_time
PROTO((void));
103 static int get_last_nonwhite_on_line
PROTO((void));
104 static int interface_strcmp
PROTO((char *));
105 static int readescape
PROTO((int *));
106 static char *extend_token_buffer
PROTO((char *));
107 static void consume_string
PROTO((struct obstack
*, int));
108 static void set_typedecl_interface_info
PROTO((tree
, tree
));
109 static void feed_defarg
PROTO((tree
, tree
));
110 static int set_vardecl_interface_info
PROTO((tree
, tree
));
111 static void store_pending_inline
PROTO((tree
, struct pending_inline
*));
112 static void reinit_parse_for_expr
PROTO((struct obstack
*));
114 /* Given a file name X, return the nondirectory portion.
115 Keep in mind that X can be computed more than once. */
117 file_name_nondirectory (x
)
120 char *tmp
= (char *) rindex (x
, DIR_SEPARATOR
);
122 return (char *) (tmp
+ 1);
127 /* This obstack is needed to hold text. It is not safe to use
128 TOKEN_BUFFER because `check_newline' calls `yylex'. */
129 struct obstack inline_text_obstack
;
130 char *inline_text_firstobj
;
134 /* Pending language change.
135 Positive is push count, negative is pop count. */
136 int pending_lang_change
= 0;
138 /* Wrap the current header file in extern "C". */
139 static int c_header_level
= 0;
141 extern int first_token
;
142 extern struct obstack token_obstack
;
144 /* ??? Don't really know where this goes yet. */
148 extern void put_back (/* int */);
149 extern int input_redirected ();
150 extern void feed_input (/* char *, int */);
153 /* Holds translations from TREE_CODEs to operator name strings,
154 i.e., opname_tab[PLUS_EXPR] == "+". */
158 extern int yychar
; /* the lookahead symbol */
159 extern YYSTYPE yylval
; /* the semantic value of the */
160 /* lookahead symbol */
163 YYLTYPE yylloc
; /* location data for the lookahead */
168 /* the declaration found for the last IDENTIFIER token read in.
169 yylex must look this up to detect typedefs, which get token type TYPENAME,
170 so it is left around in case the identifier is not a typedef but is
171 used in a context which makes it a reference to a variable. */
174 /* The elements of `ridpointers' are identifier nodes
175 for the reserved type names and storage classes.
176 It is indexed by a RID_... value. */
177 tree ridpointers
[(int) RID_MAX
];
179 /* We may keep statistics about how long which files took to compile. */
180 static int header_time
, body_time
;
181 static tree filename_times
;
182 static tree this_filename_time
;
184 /* Array for holding counts of the numbers of tokens seen. */
185 extern int *token_count
;
187 /* Return something to represent absolute declarators containing a *.
188 TARGET is the absolute declarator that the * contains.
189 CV_QUALIFIERS is a list of modifiers such as const or volatile
190 to apply to the pointer type, represented as identifiers.
192 We return an INDIRECT_REF whose "contents" are TARGET
193 and whose type is the modifier list. */
196 make_pointer_declarator (cv_qualifiers
, target
)
197 tree cv_qualifiers
, target
;
199 if (target
&& TREE_CODE (target
) == IDENTIFIER_NODE
200 && ANON_AGGRNAME_P (target
))
201 error ("type name expected before `*'");
202 target
= build_parse_node (INDIRECT_REF
, target
);
203 TREE_TYPE (target
) = cv_qualifiers
;
207 /* Return something to represent absolute declarators containing a &.
208 TARGET is the absolute declarator that the & contains.
209 CV_QUALIFIERS is a list of modifiers such as const or volatile
210 to apply to the reference type, represented as identifiers.
212 We return an ADDR_EXPR whose "contents" are TARGET
213 and whose type is the modifier list. */
216 make_reference_declarator (cv_qualifiers
, target
)
217 tree cv_qualifiers
, target
;
221 if (TREE_CODE (target
) == ADDR_EXPR
)
223 error ("cannot declare references to references");
226 if (TREE_CODE (target
) == INDIRECT_REF
)
228 error ("cannot declare pointers to references");
231 if (TREE_CODE (target
) == IDENTIFIER_NODE
&& ANON_AGGRNAME_P (target
))
232 error ("type name expected before `&'");
234 target
= build_parse_node (ADDR_EXPR
, target
);
235 TREE_TYPE (target
) = cv_qualifiers
;
240 make_call_declarator (target
, parms
, cv_qualifiers
, exception_specification
)
241 tree target
, parms
, cv_qualifiers
, exception_specification
;
243 target
= build_parse_node (CALL_EXPR
, target
, parms
, cv_qualifiers
);
244 TREE_TYPE (target
) = exception_specification
;
249 set_quals_and_spec (call_declarator
, cv_qualifiers
, exception_specification
)
250 tree call_declarator
, cv_qualifiers
, exception_specification
;
252 TREE_OPERAND (call_declarator
, 2) = cv_qualifiers
;
253 TREE_TYPE (call_declarator
) = exception_specification
;
256 /* Build names and nodes for overloaded operators. */
258 tree ansi_opname
[LAST_CPLUS_TREE_CODE
];
259 tree ansi_assopname
[LAST_CPLUS_TREE_CODE
];
262 operator_name_string (name
)
265 char *opname
= IDENTIFIER_POINTER (name
) + 2;
269 /* Works for builtin and user defined types. */
270 if (IDENTIFIER_GLOBAL_VALUE (name
)
271 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name
)) == TYPE_DECL
)
272 return IDENTIFIER_POINTER (name
);
274 if (opname
[0] == 'a' && opname
[2] != '\0' && opname
[2] != '_')
278 opname_table
= ansi_assopname
;
283 opname_table
= ansi_opname
;
286 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
288 if (opname
[0] == IDENTIFIER_POINTER (opname_table
[i
])[2+assign
]
289 && opname
[1] == IDENTIFIER_POINTER (opname_table
[i
])[3+assign
])
293 if (i
== LAST_CPLUS_TREE_CODE
)
294 return "<invalid operator>";
297 return assignop_tab
[i
];
299 return opname_tab
[i
];
302 int interface_only
; /* whether or not current file is only for
303 interface definitions. */
304 int interface_unknown
; /* whether or not we know this class
305 to behave according to #pragma interface. */
307 /* lexical analyzer */
309 /* File used for outputting assembler code. */
310 extern FILE *asm_out_file
;
312 #ifndef WCHAR_TYPE_SIZE
314 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
316 #define WCHAR_TYPE_SIZE BITS_PER_WORD
320 /* Number of bytes in a wide character. */
321 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
323 static int maxtoken
; /* Current nominal length of token buffer. */
324 char *token_buffer
; /* Pointer to token buffer.
325 Actual allocated length is maxtoken + 2. */
330 /* Nonzero tells yylex to ignore \ in string constants. */
331 static int ignore_escape_flag
= 0;
334 get_time_identifier (name
)
337 tree time_identifier
;
338 int len
= strlen (name
);
339 char *buf
= (char *) alloca (len
+ 6);
340 strcpy (buf
, "file ");
341 bcopy (name
, buf
+5, len
);
343 time_identifier
= get_identifier (buf
);
344 if (IDENTIFIER_LOCAL_VALUE (time_identifier
) == NULL_TREE
)
346 push_obstacks_nochange ();
347 end_temporary_allocation ();
348 IDENTIFIER_LOCAL_VALUE (time_identifier
) = build_int_2 (0, 0);
349 IDENTIFIER_CLASS_VALUE (time_identifier
) = build_int_2 (0, 1);
350 IDENTIFIER_GLOBAL_VALUE (time_identifier
) = filename_times
;
351 filename_times
= time_identifier
;
354 return time_identifier
;
363 int old_quiet_flag
= quiet_flag
;
366 this_time
= get_run_time ();
367 quiet_flag
= old_quiet_flag
;
371 /* Table indexed by tree code giving a string containing a character
372 classifying the tree code. Possibilities are
373 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
375 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
377 char cplus_tree_code_type
[] = {
379 #include "cp-tree.def"
383 /* Table indexed by tree code giving number of expression
384 operands beyond the fixed part of the node structure.
385 Not used for types or decls. */
387 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
389 int cplus_tree_code_length
[] = {
391 #include "cp-tree.def"
395 /* Names of tree components.
396 Used for printing out the tree and error messages. */
397 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
399 char *cplus_tree_code_name
[] = {
401 #include "cp-tree.def"
405 /* toplev.c needs to call these. */
410 /* the beginning of the file is a new line; check for # */
411 /* With luck, we discover the real source file's name from that
412 and put it in input_filename. */
413 put_back (check_newline ());
414 if (flag_gnu_xref
) GNU_xref_begin (input_filename
);
415 init_repo (input_filename
);
417 /* See comments in toplev.c before the call to lang_init. */
418 if (flag_exceptions
== 2)
425 extern int errorcount
, sorrycount
;
426 if (flag_gnu_xref
) GNU_xref_end (errorcount
+sorrycount
);
436 init_filename_times ()
438 this_filename_time
= get_time_identifier ("<top level>");
439 if (flag_detailed_statistics
)
442 body_time
= my_get_run_time ();
443 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
)) = body_time
;
447 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
448 Stuck this hack in to get the files open correctly; this is called
449 in place of init_lex if we are an unexec'd binary. */
453 reinit_lang_specific ()
455 init_filename_times ();
456 reinit_search_statistics ();
463 extern int flag_no_gnu_keywords
;
464 extern int flag_operator_names
;
468 /* Initialize the lookahead machinery. */
471 /* Make identifier nodes long enough for the language-specific slots. */
472 set_identifier_size (sizeof (struct lang_identifier
));
473 decl_printable_name
= lang_printable_name
;
475 init_cplus_expand ();
477 bcopy (cplus_tree_code_type
,
478 tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
,
479 (int)LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
);
480 bcopy ((char *)cplus_tree_code_length
,
481 (char *)(tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
),
482 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
483 bcopy ((char *)cplus_tree_code_name
,
484 (char *)(tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
),
485 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
487 opname_tab
= (char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
488 bzero ((char *)opname_tab
, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
489 assignop_tab
= (char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
490 bzero ((char *)assignop_tab
, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
492 ansi_opname
[0] = get_identifier ("<invalid operator>");
493 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
495 ansi_opname
[i
] = ansi_opname
[0];
496 ansi_assopname
[i
] = ansi_opname
[0];
499 ansi_opname
[(int) MULT_EXPR
] = get_identifier ("__ml");
500 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MULT_EXPR
]) = 1;
501 ansi_opname
[(int) INDIRECT_REF
] = ansi_opname
[(int) MULT_EXPR
];
502 ansi_assopname
[(int) MULT_EXPR
] = get_identifier ("__aml");
503 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MULT_EXPR
]) = 1;
504 ansi_assopname
[(int) INDIRECT_REF
] = ansi_assopname
[(int) MULT_EXPR
];
505 ansi_opname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__md");
506 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUNC_MOD_EXPR
]) = 1;
507 ansi_assopname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__amd");
508 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) TRUNC_MOD_EXPR
]) = 1;
509 ansi_opname
[(int) CEIL_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
510 ansi_opname
[(int) FLOOR_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
511 ansi_opname
[(int) ROUND_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
512 ansi_opname
[(int) MINUS_EXPR
] = get_identifier ("__mi");
513 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MINUS_EXPR
]) = 1;
514 ansi_opname
[(int) NEGATE_EXPR
] = ansi_opname
[(int) MINUS_EXPR
];
515 ansi_assopname
[(int) MINUS_EXPR
] = get_identifier ("__ami");
516 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MINUS_EXPR
]) = 1;
517 ansi_assopname
[(int) NEGATE_EXPR
] = ansi_assopname
[(int) MINUS_EXPR
];
518 ansi_opname
[(int) RSHIFT_EXPR
] = get_identifier ("__rs");
519 IDENTIFIER_OPNAME_P (ansi_opname
[(int) RSHIFT_EXPR
]) = 1;
520 ansi_assopname
[(int) RSHIFT_EXPR
] = get_identifier ("__ars");
521 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) RSHIFT_EXPR
]) = 1;
522 ansi_opname
[(int) NE_EXPR
] = get_identifier ("__ne");
523 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NE_EXPR
]) = 1;
524 ansi_opname
[(int) GT_EXPR
] = get_identifier ("__gt");
525 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GT_EXPR
]) = 1;
526 ansi_opname
[(int) GE_EXPR
] = get_identifier ("__ge");
527 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GE_EXPR
]) = 1;
528 ansi_opname
[(int) BIT_IOR_EXPR
] = get_identifier ("__or");
529 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_IOR_EXPR
]) = 1;
530 ansi_assopname
[(int) BIT_IOR_EXPR
] = get_identifier ("__aor");
531 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_IOR_EXPR
]) = 1;
532 ansi_opname
[(int) TRUTH_ANDIF_EXPR
] = get_identifier ("__aa");
533 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ANDIF_EXPR
]) = 1;
534 ansi_opname
[(int) TRUTH_NOT_EXPR
] = get_identifier ("__nt");
535 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_NOT_EXPR
]) = 1;
536 ansi_opname
[(int) PREINCREMENT_EXPR
] = get_identifier ("__pp");
537 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREINCREMENT_EXPR
]) = 1;
538 ansi_opname
[(int) POSTINCREMENT_EXPR
] = ansi_opname
[(int) PREINCREMENT_EXPR
];
539 ansi_opname
[(int) MODIFY_EXPR
] = get_identifier ("__as");
540 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MODIFY_EXPR
]) = 1;
541 ansi_assopname
[(int) NOP_EXPR
] = ansi_opname
[(int) MODIFY_EXPR
];
542 ansi_opname
[(int) COMPOUND_EXPR
] = get_identifier ("__cm");
543 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPOUND_EXPR
]) = 1;
544 ansi_opname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__dv");
545 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EXACT_DIV_EXPR
]) = 1;
546 ansi_assopname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__adv");
547 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) EXACT_DIV_EXPR
]) = 1;
548 ansi_opname
[(int) TRUNC_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
549 ansi_opname
[(int) CEIL_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
550 ansi_opname
[(int) FLOOR_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
551 ansi_opname
[(int) ROUND_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
552 ansi_opname
[(int) PLUS_EXPR
] = get_identifier ("__pl");
553 ansi_assopname
[(int) TRUNC_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
554 ansi_assopname
[(int) CEIL_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
555 ansi_assopname
[(int) FLOOR_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
556 ansi_assopname
[(int) ROUND_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
557 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PLUS_EXPR
]) = 1;
558 ansi_assopname
[(int) PLUS_EXPR
] = get_identifier ("__apl");
559 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) PLUS_EXPR
]) = 1;
560 ansi_opname
[(int) CONVERT_EXPR
] = ansi_opname
[(int) PLUS_EXPR
];
561 ansi_assopname
[(int) CONVERT_EXPR
] = ansi_assopname
[(int) PLUS_EXPR
];
562 ansi_opname
[(int) LSHIFT_EXPR
] = get_identifier ("__ls");
563 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LSHIFT_EXPR
]) = 1;
564 ansi_assopname
[(int) LSHIFT_EXPR
] = get_identifier ("__als");
565 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) LSHIFT_EXPR
]) = 1;
566 ansi_opname
[(int) EQ_EXPR
] = get_identifier ("__eq");
567 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EQ_EXPR
]) = 1;
568 ansi_opname
[(int) LT_EXPR
] = get_identifier ("__lt");
569 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LT_EXPR
]) = 1;
570 ansi_opname
[(int) LE_EXPR
] = get_identifier ("__le");
571 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LE_EXPR
]) = 1;
572 ansi_opname
[(int) BIT_AND_EXPR
] = get_identifier ("__ad");
573 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_AND_EXPR
]) = 1;
574 ansi_assopname
[(int) BIT_AND_EXPR
] = get_identifier ("__aad");
575 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_AND_EXPR
]) = 1;
576 ansi_opname
[(int) ADDR_EXPR
] = ansi_opname
[(int) BIT_AND_EXPR
];
577 ansi_assopname
[(int) ADDR_EXPR
] = ansi_assopname
[(int) BIT_AND_EXPR
];
578 ansi_opname
[(int) BIT_XOR_EXPR
] = get_identifier ("__er");
579 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_XOR_EXPR
]) = 1;
580 ansi_assopname
[(int) BIT_XOR_EXPR
] = get_identifier ("__aer");
581 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_XOR_EXPR
]) = 1;
582 ansi_opname
[(int) TRUTH_ORIF_EXPR
] = get_identifier ("__oo");
583 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ORIF_EXPR
]) = 1;
584 ansi_opname
[(int) BIT_NOT_EXPR
] = get_identifier ("__co");
585 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_NOT_EXPR
]) = 1;
586 ansi_opname
[(int) PREDECREMENT_EXPR
] = get_identifier ("__mm");
587 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREDECREMENT_EXPR
]) = 1;
588 ansi_opname
[(int) POSTDECREMENT_EXPR
] = ansi_opname
[(int) PREDECREMENT_EXPR
];
589 ansi_opname
[(int) COMPONENT_REF
] = get_identifier ("__rf");
590 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPONENT_REF
]) = 1;
591 ansi_opname
[(int) MEMBER_REF
] = get_identifier ("__rm");
592 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MEMBER_REF
]) = 1;
593 ansi_opname
[(int) CALL_EXPR
] = get_identifier ("__cl");
594 IDENTIFIER_OPNAME_P (ansi_opname
[(int) CALL_EXPR
]) = 1;
595 ansi_opname
[(int) ARRAY_REF
] = get_identifier ("__vc");
596 IDENTIFIER_OPNAME_P (ansi_opname
[(int) ARRAY_REF
]) = 1;
597 ansi_opname
[(int) NEW_EXPR
] = get_identifier ("__nw");
598 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NEW_EXPR
]) = 1;
599 ansi_opname
[(int) DELETE_EXPR
] = get_identifier ("__dl");
600 IDENTIFIER_OPNAME_P (ansi_opname
[(int) DELETE_EXPR
]) = 1;
601 ansi_opname
[(int) VEC_NEW_EXPR
] = get_identifier ("__vn");
602 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_NEW_EXPR
]) = 1;
603 ansi_opname
[(int) VEC_DELETE_EXPR
] = get_identifier ("__vd");
604 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_DELETE_EXPR
]) = 1;
605 ansi_opname
[(int) TYPE_EXPR
] = get_identifier ("__op");
606 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TYPE_EXPR
]) = 1;
608 /* This is not true: these operators are not defined in ANSI,
609 but we need them anyway. */
610 ansi_opname
[(int) MIN_EXPR
] = get_identifier ("__mn");
611 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MIN_EXPR
]) = 1;
612 ansi_opname
[(int) MAX_EXPR
] = get_identifier ("__mx");
613 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MAX_EXPR
]) = 1;
614 ansi_opname
[(int) COND_EXPR
] = get_identifier ("__cn");
615 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COND_EXPR
]) = 1;
616 ansi_opname
[(int) METHOD_CALL_EXPR
] = get_identifier ("__wr");
617 IDENTIFIER_OPNAME_P (ansi_opname
[(int) METHOD_CALL_EXPR
]) = 1;
621 gcc_obstack_init (&inline_text_obstack
);
622 inline_text_firstobj
= (char *) obstack_alloc (&inline_text_obstack
, 0);
624 /* Start it at 0, because check_newline is called at the very beginning
625 and will increment it to 1. */
627 input_filename
= "<internal>";
628 current_function_decl
= NULL
;
631 token_buffer
= (char *) xmalloc (maxtoken
+ 2);
633 ridpointers
[(int) RID_INT
] = get_identifier ("int");
634 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_INT
],
635 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]));
636 ridpointers
[(int) RID_BOOL
] = get_identifier ("bool");
637 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_BOOL
],
638 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_BOOL
]));
639 ridpointers
[(int) RID_CHAR
] = get_identifier ("char");
640 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_CHAR
],
641 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]));
642 ridpointers
[(int) RID_VOID
] = get_identifier ("void");
643 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VOID
],
644 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOID
]));
645 ridpointers
[(int) RID_FLOAT
] = get_identifier ("float");
646 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_FLOAT
],
647 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_FLOAT
]));
648 ridpointers
[(int) RID_DOUBLE
] = get_identifier ("double");
649 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_DOUBLE
],
650 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_DOUBLE
]));
651 ridpointers
[(int) RID_SHORT
] = get_identifier ("short");
652 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_SHORT
],
653 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_SHORT
]));
654 ridpointers
[(int) RID_LONG
] = get_identifier ("long");
655 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_LONG
],
656 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]));
657 ridpointers
[(int) RID_UNSIGNED
] = get_identifier ("unsigned");
658 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_UNSIGNED
],
659 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_UNSIGNED
]));
660 ridpointers
[(int) RID_SIGNED
] = get_identifier ("signed");
661 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_SIGNED
],
662 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_SIGNED
]));
663 ridpointers
[(int) RID_INLINE
] = get_identifier ("inline");
664 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_INLINE
],
665 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INLINE
]));
666 ridpointers
[(int) RID_CONST
] = get_identifier ("const");
667 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_CONST
],
668 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CONST
]));
669 ridpointers
[(int) RID_VOLATILE
] = get_identifier ("volatile");
670 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VOLATILE
],
671 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOLATILE
]));
672 ridpointers
[(int) RID_AUTO
] = get_identifier ("auto");
673 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_AUTO
],
674 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_AUTO
]));
675 ridpointers
[(int) RID_STATIC
] = get_identifier ("static");
676 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_STATIC
],
677 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]));
678 ridpointers
[(int) RID_EXTERN
] = get_identifier ("extern");
679 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_EXTERN
],
680 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXTERN
]));
681 ridpointers
[(int) RID_TYPEDEF
] = get_identifier ("typedef");
682 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_TYPEDEF
],
683 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_TYPEDEF
]));
684 ridpointers
[(int) RID_REGISTER
] = get_identifier ("register");
685 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_REGISTER
],
686 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_REGISTER
]));
687 ridpointers
[(int) RID_COMPLEX
] = get_identifier ("__complex");
688 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_COMPLEX
],
689 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_COMPLEX
]));
691 /* C++ extensions. These are probably not correctly named. */
692 ridpointers
[(int) RID_WCHAR
] = get_identifier ("__wchar_t");
693 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_WCHAR
],
694 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_WCHAR
]));
695 class_type_node
= build_int_2 (class_type
, 0);
696 TREE_TYPE (class_type_node
) = class_type_node
;
697 ridpointers
[(int) RID_CLASS
] = class_type_node
;
699 record_type_node
= build_int_2 (record_type
, 0);
700 TREE_TYPE (record_type_node
) = record_type_node
;
701 ridpointers
[(int) RID_RECORD
] = record_type_node
;
703 union_type_node
= build_int_2 (union_type
, 0);
704 TREE_TYPE (union_type_node
) = union_type_node
;
705 ridpointers
[(int) RID_UNION
] = union_type_node
;
707 enum_type_node
= build_int_2 (enum_type
, 0);
708 TREE_TYPE (enum_type_node
) = enum_type_node
;
709 ridpointers
[(int) RID_ENUM
] = enum_type_node
;
711 ridpointers
[(int) RID_VIRTUAL
] = get_identifier ("virtual");
712 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VIRTUAL
],
713 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]));
714 ridpointers
[(int) RID_EXPLICIT
] = get_identifier ("explicit");
715 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_EXPLICIT
],
716 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXPLICIT
]));
717 ridpointers
[(int) RID_FRIEND
] = get_identifier ("friend");
718 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_FRIEND
],
719 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_FRIEND
]));
721 ridpointers
[(int) RID_PUBLIC
] = get_identifier ("public");
722 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PUBLIC
],
723 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PUBLIC
]));
724 ridpointers
[(int) RID_PRIVATE
] = get_identifier ("private");
725 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PRIVATE
],
726 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PRIVATE
]));
727 ridpointers
[(int) RID_PROTECTED
] = get_identifier ("protected");
728 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PROTECTED
],
729 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PROTECTED
]));
730 ridpointers
[(int) RID_TEMPLATE
] = get_identifier ("template");
731 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_TEMPLATE
],
732 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_TEMPLATE
]));
733 /* This is for ANSI C++. */
734 ridpointers
[(int) RID_MUTABLE
] = get_identifier ("mutable");
735 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_MUTABLE
],
736 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_MUTABLE
]));
738 /* Signature handling extensions. */
739 signature_type_node
= build_int_2 (signature_type
, 0);
740 TREE_TYPE (signature_type_node
) = signature_type_node
;
741 ridpointers
[(int) RID_SIGNATURE
] = signature_type_node
;
743 null_node
= build_int_2 (0, 0);
744 ridpointers
[RID_NULL
] = null_node
;
746 opname_tab
[(int) COMPONENT_REF
] = "->";
747 opname_tab
[(int) MEMBER_REF
] = "->*";
748 opname_tab
[(int) METHOD_CALL_EXPR
] = "->()";
749 opname_tab
[(int) INDIRECT_REF
] = "*";
750 opname_tab
[(int) ARRAY_REF
] = "[]";
751 opname_tab
[(int) MODIFY_EXPR
] = "=";
752 opname_tab
[(int) NEW_EXPR
] = "new";
753 opname_tab
[(int) DELETE_EXPR
] = "delete";
754 opname_tab
[(int) VEC_NEW_EXPR
] = "new []";
755 opname_tab
[(int) VEC_DELETE_EXPR
] = "delete []";
756 opname_tab
[(int) COND_EXPR
] = "?:";
757 opname_tab
[(int) CALL_EXPR
] = "()";
758 opname_tab
[(int) PLUS_EXPR
] = "+";
759 opname_tab
[(int) MINUS_EXPR
] = "-";
760 opname_tab
[(int) MULT_EXPR
] = "*";
761 opname_tab
[(int) TRUNC_DIV_EXPR
] = "/";
762 opname_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /)";
763 opname_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /)";
764 opname_tab
[(int) ROUND_DIV_EXPR
] = "(round /)";
765 opname_tab
[(int) TRUNC_MOD_EXPR
] = "%";
766 opname_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %)";
767 opname_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %)";
768 opname_tab
[(int) ROUND_MOD_EXPR
] = "(round %)";
769 opname_tab
[(int) NEGATE_EXPR
] = "-";
770 opname_tab
[(int) MIN_EXPR
] = "<?";
771 opname_tab
[(int) MAX_EXPR
] = ">?";
772 opname_tab
[(int) ABS_EXPR
] = "abs";
773 opname_tab
[(int) FFS_EXPR
] = "ffs";
774 opname_tab
[(int) LSHIFT_EXPR
] = "<<";
775 opname_tab
[(int) RSHIFT_EXPR
] = ">>";
776 opname_tab
[(int) BIT_IOR_EXPR
] = "|";
777 opname_tab
[(int) BIT_XOR_EXPR
] = "^";
778 opname_tab
[(int) BIT_AND_EXPR
] = "&";
779 opname_tab
[(int) BIT_ANDTC_EXPR
] = "&~";
780 opname_tab
[(int) BIT_NOT_EXPR
] = "~";
781 opname_tab
[(int) TRUTH_ANDIF_EXPR
] = "&&";
782 opname_tab
[(int) TRUTH_ORIF_EXPR
] = "||";
783 opname_tab
[(int) TRUTH_AND_EXPR
] = "strict &&";
784 opname_tab
[(int) TRUTH_OR_EXPR
] = "strict ||";
785 opname_tab
[(int) TRUTH_NOT_EXPR
] = "!";
786 opname_tab
[(int) LT_EXPR
] = "<";
787 opname_tab
[(int) LE_EXPR
] = "<=";
788 opname_tab
[(int) GT_EXPR
] = ">";
789 opname_tab
[(int) GE_EXPR
] = ">=";
790 opname_tab
[(int) EQ_EXPR
] = "==";
791 opname_tab
[(int) NE_EXPR
] = "!=";
792 opname_tab
[(int) IN_EXPR
] = "in";
793 opname_tab
[(int) RANGE_EXPR
] = "...";
794 opname_tab
[(int) CONVERT_EXPR
] = "+";
795 opname_tab
[(int) ADDR_EXPR
] = "&";
796 opname_tab
[(int) PREDECREMENT_EXPR
] = "--";
797 opname_tab
[(int) PREINCREMENT_EXPR
] = "++";
798 opname_tab
[(int) POSTDECREMENT_EXPR
] = "--";
799 opname_tab
[(int) POSTINCREMENT_EXPR
] = "++";
800 opname_tab
[(int) COMPOUND_EXPR
] = ",";
802 assignop_tab
[(int) NOP_EXPR
] = "=";
803 assignop_tab
[(int) PLUS_EXPR
] = "+=";
804 assignop_tab
[(int) CONVERT_EXPR
] = "+=";
805 assignop_tab
[(int) MINUS_EXPR
] = "-=";
806 assignop_tab
[(int) NEGATE_EXPR
] = "-=";
807 assignop_tab
[(int) MULT_EXPR
] = "*=";
808 assignop_tab
[(int) INDIRECT_REF
] = "*=";
809 assignop_tab
[(int) TRUNC_DIV_EXPR
] = "/=";
810 assignop_tab
[(int) EXACT_DIV_EXPR
] = "(exact /=)";
811 assignop_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /=)";
812 assignop_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /=)";
813 assignop_tab
[(int) ROUND_DIV_EXPR
] = "(round /=)";
814 assignop_tab
[(int) TRUNC_MOD_EXPR
] = "%=";
815 assignop_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %=)";
816 assignop_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %=)";
817 assignop_tab
[(int) ROUND_MOD_EXPR
] = "(round %=)";
818 assignop_tab
[(int) MIN_EXPR
] = "<?=";
819 assignop_tab
[(int) MAX_EXPR
] = ">?=";
820 assignop_tab
[(int) LSHIFT_EXPR
] = "<<=";
821 assignop_tab
[(int) RSHIFT_EXPR
] = ">>=";
822 assignop_tab
[(int) BIT_IOR_EXPR
] = "|=";
823 assignop_tab
[(int) BIT_XOR_EXPR
] = "^=";
824 assignop_tab
[(int) BIT_AND_EXPR
] = "&=";
825 assignop_tab
[(int) ADDR_EXPR
] = "&=";
827 init_filename_times ();
829 /* Some options inhibit certain reserved words.
830 Clear those words out of the hash table so they won't be recognized. */
831 #define UNSET_RESERVED_WORD(STRING) \
832 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
833 if (s) s->name = ""; } while (0)
836 /* let's parse things, and if they use it, then give them an error. */
837 if (!flag_exceptions
)
839 UNSET_RESERVED_WORD ("throw");
840 UNSET_RESERVED_WORD ("try");
841 UNSET_RESERVED_WORD ("catch");
845 if (!flag_rtti
|| flag_no_gnu_keywords
)
847 UNSET_RESERVED_WORD ("classof");
848 UNSET_RESERVED_WORD ("headof");
850 if (! flag_handle_signatures
|| flag_no_gnu_keywords
)
852 /* Easiest way to not recognize signature
853 handling extensions... */
854 UNSET_RESERVED_WORD ("signature");
855 UNSET_RESERVED_WORD ("sigof");
857 if (flag_no_asm
|| flag_no_gnu_keywords
)
858 UNSET_RESERVED_WORD ("typeof");
859 if (! flag_operator_names
)
861 /* These are new ANSI keywords that may break code. */
862 UNSET_RESERVED_WORD ("and");
863 UNSET_RESERVED_WORD ("and_eq");
864 UNSET_RESERVED_WORD ("bitand");
865 UNSET_RESERVED_WORD ("bitor");
866 UNSET_RESERVED_WORD ("compl");
867 UNSET_RESERVED_WORD ("not");
868 UNSET_RESERVED_WORD ("not_eq");
869 UNSET_RESERVED_WORD ("or");
870 UNSET_RESERVED_WORD ("or_eq");
871 UNSET_RESERVED_WORD ("xor");
872 UNSET_RESERVED_WORD ("xor_eq");
875 token_count
= init_parse ();
876 interface_unknown
= 1;
880 reinit_parse_for_function ()
882 current_base_init_list
= NULL_TREE
;
883 current_member_init_list
= NULL_TREE
;
890 yyprint (file
, yychar
, yylval
)
902 case IDENTIFIER_DEFN
:
905 case TYPENAME_ELLIPSIS
:
907 case PRE_PARSED_CLASS_DECL
:
909 if (TREE_CODE (t
) == TYPE_DECL
)
911 fprintf (file
, " `%s'", DECL_NAME (t
));
914 my_friendly_assert (TREE_CODE (t
) == IDENTIFIER_NODE
, 224);
915 if (IDENTIFIER_POINTER (t
))
916 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
919 if (yylval
.ttype
== class_type_node
)
920 fprintf (file
, " `class'");
921 else if (yylval
.ttype
== record_type_node
)
922 fprintf (file
, " `struct'");
923 else if (yylval
.ttype
== union_type_node
)
924 fprintf (file
, " `union'");
925 else if (yylval
.ttype
== enum_type_node
)
926 fprintf (file
, " `enum'");
927 else if (yylval
.ttype
== signature_type_node
)
928 fprintf (file
, " `signature'");
930 my_friendly_abort (80);
935 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
936 static int *reduce_count
;
942 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
943 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
949 #ifdef GATHER_STATISTICS
951 reduce_count
= (int *)malloc (sizeof (int) * (REDUCE_LENGTH
+ 1));
952 bzero (reduce_count
, sizeof (int) * (REDUCE_LENGTH
+ 1));
954 token_count
= (int *)malloc (sizeof (int) * (TOKEN_LENGTH
+ 1));
955 bzero (token_count
, sizeof (int) * (TOKEN_LENGTH
+ 1));
962 #ifdef GATHER_STATISTICS
968 reduce_count
[yyn
] += 1;
975 return reduce_count
[*q
] - reduce_count
[*p
];
982 return token_count
[*q
] - token_count
[*p
];
988 print_parse_statistics ()
990 #ifdef GATHER_STATISTICS
994 int maxlen
= REDUCE_LENGTH
;
997 if (reduce_count
[-1] == 0)
1000 if (TOKEN_LENGTH
> REDUCE_LENGTH
)
1001 maxlen
= TOKEN_LENGTH
;
1002 sorted
= (unsigned *) alloca (sizeof (int) * maxlen
);
1004 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1006 qsort (sorted
, TOKEN_LENGTH
, sizeof (int), token_cmp
);
1007 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1009 int idx
= sorted
[i
];
1010 if (token_count
[idx
] == 0)
1012 if (token_count
[idx
] < token_count
[-1])
1014 fprintf (stderr
, "token %d, `%s', count = %d\n",
1015 idx
, yytname
[YYTRANSLATE (idx
)], token_count
[idx
]);
1017 fprintf (stderr
, "\n");
1018 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1020 qsort (sorted
, REDUCE_LENGTH
, sizeof (int), reduce_cmp
);
1021 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1023 int idx
= sorted
[i
];
1024 if (reduce_count
[idx
] == 0)
1026 if (reduce_count
[idx
] < reduce_count
[-1])
1028 fprintf (stderr
, "rule %d, line %d, count = %d\n",
1029 idx
, yyrline
[idx
], reduce_count
[idx
]);
1031 fprintf (stderr
, "\n");
1037 /* Sets the value of the 'yydebug' variable to VALUE.
1038 This is a function so we don't have to have YYDEBUG defined
1039 in order to build the compiler. */
1049 warning ("YYDEBUG not defined.");
1054 /* Functions and data structures for #pragma interface.
1056 `#pragma implementation' means that the main file being compiled
1057 is considered to implement (provide) the classes that appear in
1058 its main body. I.e., if this is file "foo.cc", and class `bar'
1059 is defined in "foo.cc", then we say that "foo.cc implements bar".
1061 All main input files "implement" themselves automagically.
1063 `#pragma interface' means that unless this file (of the form "foo.h"
1064 is not presently being included by file "foo.cc", the
1065 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1066 of the vtables nor any of the inline functions defined in foo.h
1067 will ever be output.
1069 There are cases when we want to link files such as "defs.h" and
1070 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1071 and "main.cc" has `#pragma implementation "defs.h"'. */
1076 struct impl_files
*next
;
1079 static struct impl_files
*impl_file_chain
;
1081 /* Helper function to load global variables with interface
1085 extract_interface_info ()
1089 if (flag_alt_external_templates
)
1091 struct tinst_level
*til
= tinst_for_decl ();
1094 fileinfo
= get_time_identifier (til
->file
);
1097 fileinfo
= get_time_identifier (input_filename
);
1098 fileinfo
= IDENTIFIER_CLASS_VALUE (fileinfo
);
1099 interface_only
= TREE_INT_CST_LOW (fileinfo
);
1100 interface_unknown
= TREE_INT_CST_HIGH (fileinfo
);
1103 /* Return nonzero if S is not considered part of an
1104 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1107 interface_strcmp (s
)
1110 /* Set the interface/implementation bits for this scope. */
1111 struct impl_files
*ifiles
;
1114 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
1116 char *t1
= ifiles
->filename
;
1119 if (*s1
!= *t1
|| *s1
== 0)
1122 while (*s1
== *t1
&& *s1
!= 0)
1129 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1130 if (index (s1
, '.') || index (t1
, '.'))
1133 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
1145 set_typedecl_interface_info (prev
, vars
)
1148 tree id
= get_time_identifier (DECL_SOURCE_FILE (vars
));
1149 tree fileinfo
= IDENTIFIER_CLASS_VALUE (id
);
1150 tree type
= TREE_TYPE (vars
);
1152 CLASSTYPE_INTERFACE_ONLY (type
) = TREE_INT_CST_LOW (fileinfo
)
1153 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars
)));
1157 set_vardecl_interface_info (prev
, vars
)
1160 tree type
= DECL_CONTEXT (vars
);
1162 if (CLASSTYPE_INTERFACE_KNOWN (type
))
1164 if (CLASSTYPE_INTERFACE_ONLY (type
))
1165 set_typedecl_interface_info (prev
, TYPE_MAIN_DECL (type
));
1167 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
1168 DECL_EXTERNAL (vars
) = CLASSTYPE_INTERFACE_ONLY (type
);
1169 TREE_PUBLIC (vars
) = 1;
1175 /* Called from the top level: if there are any pending inlines to
1176 do, set up to process them now. This function sets up the first function
1177 to be parsed; after it has been, the rule for fndef in parse.y will
1178 call process_next_inline to start working on the next one. */
1181 do_pending_inlines ()
1183 struct pending_inline
*t
;
1186 /* Oops, we're still dealing with the last batch. */
1187 if (yychar
== PRE_PARSED_FUNCTION_DECL
)
1190 /* Reverse the pending inline functions, since
1191 they were cons'd instead of appended. */
1193 struct pending_inline
*prev
= 0, *tail
;
1194 t
= pending_inlines
;
1195 pending_inlines
= 0;
1210 /* Now start processing the first inline function. */
1211 context
= hack_decl_function_context (t
->fndecl
);
1213 push_cp_function_context (context
);
1214 if (is_member_template (t
->fndecl
))
1215 begin_member_template_processing (t
->fndecl
);
1218 feed_input (t
->buf
, t
->len
);
1221 if (input_filename
!= t
->filename
)
1223 input_filename
= t
->filename
;
1224 /* Get interface/implementation back in sync. */
1225 extract_interface_info ();
1228 input_filename
= t
->filename
;
1229 interface_unknown
= t
->interface
== 1;
1230 interface_only
= t
->interface
== 0;
1232 yychar
= PRE_PARSED_FUNCTION_DECL
;
1234 /* Pass back a handle on the rest of the inline functions, so that they
1235 can be processed later. */
1236 yylval
.ttype
= build_tree_list ((tree
) t
, t
->fndecl
);
1237 DECL_PENDING_INLINE_INFO (t
->fndecl
) = 0;
1240 static int nextchar
= -1;
1242 /* Called from the fndecl rule in the parser when the function just parsed
1243 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1244 do_pending_inlines). */
1247 process_next_inline (t
)
1251 struct pending_inline
*i
= (struct pending_inline
*) TREE_PURPOSE (t
);
1252 context
= hack_decl_function_context (i
->fndecl
);
1253 if (is_member_template (i
->fndecl
))
1254 end_member_template_processing ();
1256 pop_cp_function_context (context
);
1258 if (yychar
== YYEMPTY
)
1260 if (yychar
!= END_OF_SAVED_INPUT
)
1262 error ("parse error at end of saved function text");
1264 /* restore_pending_input will abort unless yychar is either
1265 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1266 hosed, feed back YYEMPTY. We also need to discard nextchar,
1267 since that may have gotten set as well. */
1272 if (i
&& i
->fndecl
!= NULL_TREE
)
1274 context
= hack_decl_function_context (i
->fndecl
);
1276 push_cp_function_context (context
);
1277 if (is_member_template (i
->fndecl
))
1278 begin_member_template_processing (i
->fndecl
);
1279 feed_input (i
->buf
, i
->len
);
1281 input_filename
= i
->filename
;
1282 yychar
= PRE_PARSED_FUNCTION_DECL
;
1283 yylval
.ttype
= build_tree_list ((tree
) i
, i
->fndecl
);
1284 DECL_PENDING_INLINE_INFO (i
->fndecl
) = 0;
1288 interface_unknown
= i
->interface
== 1;
1289 interface_only
= i
->interface
== 0;
1292 extract_interface_info ();
1295 /* Since inline methods can refer to text which has not yet been seen,
1296 we store the text of the method in a structure which is placed in the
1297 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1298 After parsing the body of the class definition, the FUNCTION_DECL's are
1299 scanned to see which ones have this field set. Those are then digested
1302 This function's FUNCTION_DECL will have a bit set in its common so
1303 that we know to watch out for it. */
1306 consume_string (this_obstack
, matching_char
)
1307 register struct obstack
*this_obstack
;
1311 int starting_lineno
= lineno
;
1317 int save_lineno
= lineno
;
1318 lineno
= starting_lineno
;
1319 if (matching_char
== '"')
1320 error ("end of file encountered inside string constant");
1322 error ("end of file encountered inside character constant");
1323 lineno
= save_lineno
;
1328 obstack_1grow (this_obstack
, c
);
1330 obstack_1grow (this_obstack
, c
);
1332 /* Make sure we continue the loop */
1339 pedwarn ("ANSI C++ forbids newline in string constant");
1342 obstack_1grow (this_obstack
, c
);
1344 while (c
!= matching_char
);
1347 static int nextyychar
= YYEMPTY
;
1348 static YYSTYPE nextyylval
;
1350 struct pending_input
{
1351 int nextchar
, yychar
, nextyychar
, eof
;
1352 YYSTYPE yylval
, nextyylval
;
1353 struct obstack token_obstack
;
1357 struct pending_input
*
1358 save_pending_input ()
1360 struct pending_input
*p
;
1361 p
= (struct pending_input
*) xmalloc (sizeof (struct pending_input
));
1362 p
->nextchar
= nextchar
;
1364 p
->nextyychar
= nextyychar
;
1366 p
->nextyylval
= nextyylval
;
1367 p
->eof
= end_of_file
;
1368 yychar
= nextyychar
= YYEMPTY
;
1370 p
->first_token
= first_token
;
1371 p
->token_obstack
= token_obstack
;
1374 gcc_obstack_init (&token_obstack
);
1380 restore_pending_input (p
)
1381 struct pending_input
*p
;
1383 my_friendly_assert (nextchar
== -1, 229);
1384 nextchar
= p
->nextchar
;
1385 my_friendly_assert (yychar
== YYEMPTY
|| yychar
== END_OF_SAVED_INPUT
, 230);
1387 my_friendly_assert (nextyychar
== YYEMPTY
, 231);
1388 nextyychar
= p
->nextyychar
;
1390 nextyylval
= p
->nextyylval
;
1391 first_token
= p
->first_token
;
1392 obstack_free (&token_obstack
, (char *) 0);
1393 token_obstack
= p
->token_obstack
;
1394 end_of_file
= p
->eof
;
1398 /* Return next non-whitespace input character, which may come
1399 from `finput', or from `nextchar'. */
1412 return skip_white_space (c
);
1415 /* Unget character CH from the input stream.
1416 If RESCAN is non-zero, then we want to `see' this
1417 character as the next input token. */
1420 yyungetc (ch
, rescan
)
1424 /* Unget a character from the input stream. */
1425 if (yychar
== YYEMPTY
|| rescan
== 0)
1428 put_back (nextchar
);
1433 my_friendly_assert (nextyychar
== YYEMPTY
, 232);
1434 nextyychar
= yychar
;
1435 nextyylval
= yylval
;
1441 clear_inline_text_obstack ()
1443 obstack_free (&inline_text_obstack
, inline_text_firstobj
);
1446 /* This function stores away the text for an inline function that should
1447 be processed later. It decides how much later, and may need to move
1448 the info between obstacks; therefore, the caller should not refer to
1449 the T parameter after calling this function. */
1452 store_pending_inline (decl
, t
)
1454 struct pending_inline
*t
;
1457 DECL_PENDING_INLINE_INFO (decl
) = t
;
1459 /* Because we use obstacks, we must process these in precise order. */
1460 t
->next
= pending_inlines
;
1461 pending_inlines
= t
;
1465 reinit_parse_for_method (yychar
, decl
)
1470 int starting_lineno
= lineno
;
1471 char *starting_filename
= input_filename
;
1473 reinit_parse_for_block (yychar
, &inline_text_obstack
);
1475 len
= obstack_object_size (&inline_text_obstack
);
1476 current_base_init_list
= NULL_TREE
;
1477 current_member_init_list
= NULL_TREE
;
1478 if (decl
== void_type_node
1479 || (current_class_type
&& TYPE_REDEFINED (current_class_type
)))
1481 /* Happens when we get two declarations of the same
1482 function in the same scope. */
1483 char *buf
= obstack_finish (&inline_text_obstack
);
1484 obstack_free (&inline_text_obstack
, buf
);
1489 struct pending_inline
*t
;
1490 char *buf
= obstack_finish (&inline_text_obstack
);
1492 t
= (struct pending_inline
*) obstack_alloc (&inline_text_obstack
,
1493 sizeof (struct pending_inline
));
1494 t
->lineno
= starting_lineno
;
1495 t
->filename
= starting_filename
;
1502 if (interface_unknown
&& processing_template_defn
&& flag_external_templates
&& ! DECL_IN_SYSTEM_HEADER (decl
))
1503 warn_if_unknown_interface (decl
);
1505 t
->interface
= (interface_unknown
? 1 : (interface_only
? 0 : 2));
1506 store_pending_inline (decl
, t
);
1510 /* Consume a block -- actually, a method beginning
1511 with `:' or `{' -- and save it away on the specified obstack. */
1514 reinit_parse_for_block (pyychar
, obstackp
)
1516 struct obstack
*obstackp
;
1520 int starting_lineno
= lineno
;
1521 char *starting_filename
= input_filename
;
1523 int look_for_semicolon
= 0;
1524 int look_for_lbrac
= 0;
1527 obstack_1grow (obstackp
, '{');
1528 else if (pyychar
== '=')
1529 look_for_semicolon
= 1;
1530 else if (pyychar
== ':')
1532 obstack_1grow (obstackp
, pyychar
);
1536 else if (pyychar
== RETURN
)
1538 obstack_grow (obstackp
, "return", 6);
1542 else if (pyychar
== TRY
)
1544 obstack_grow (obstackp
, "try", 3);
1550 yyerror ("parse error in method specification");
1551 obstack_1grow (obstackp
, '{');
1554 if (nextchar
!= EOF
)
1564 int this_lineno
= lineno
;
1566 c
= skip_white_space (c
);
1568 /* Don't lose our cool if there are lots of comments. */
1569 if (lineno
== this_lineno
+ 1)
1570 obstack_1grow (obstackp
, '\n');
1571 else if (lineno
== this_lineno
)
1573 else if (lineno
- this_lineno
< 10)
1576 for (i
= lineno
- this_lineno
; i
> 0; i
--)
1577 obstack_1grow (obstackp
, '\n');
1582 sprintf (buf
, "\n# %d \"", lineno
);
1584 obstack_grow (obstackp
, buf
, len
);
1586 len
= strlen (input_filename
);
1587 obstack_grow (obstackp
, input_filename
, len
);
1588 obstack_1grow (obstackp
, '\"');
1589 obstack_1grow (obstackp
, '\n');
1592 while (c
> ' ') /* ASCII dependent... */
1594 obstack_1grow (obstackp
, c
);
1603 if (blev
== 0 && !look_for_semicolon
)
1607 if (peekyylex () == CATCH
)
1610 obstack_grow (obstackp
, " catch ", 7);
1627 /* Don't act on the next character...e.g, doing an escaped
1632 error_with_file_and_line (starting_filename
,
1634 "end of file read inside definition");
1637 obstack_1grow (obstackp
, c
);
1640 consume_string (obstackp
, c
);
1642 consume_string (obstackp
, c
);
1647 error ("function body for constructor missing");
1648 obstack_1grow (obstackp
, '{');
1649 obstack_1grow (obstackp
, '}');
1653 else if (look_for_semicolon
&& blev
== 0)
1661 error_with_file_and_line (starting_filename
,
1663 "end of file read inside definition");
1668 obstack_1grow (obstackp
, c
);
1673 obstack_1grow (obstackp
, '\0');
1676 /* Consume a no-commas expression -- actually, a default argument -- and
1677 save it away on the specified obstack. */
1680 reinit_parse_for_expr (obstackp
)
1681 struct obstack
*obstackp
;
1684 int starting_lineno
= lineno
;
1685 char *starting_filename
= input_filename
;
1689 if (nextchar
!= EOF
)
1699 int this_lineno
= lineno
;
1701 c
= skip_white_space (c
);
1703 /* Don't lose our cool if there are lots of comments. */
1704 if (lineno
== this_lineno
+ 1)
1705 obstack_1grow (obstackp
, '\n');
1706 else if (lineno
== this_lineno
)
1708 else if (lineno
- this_lineno
< 10)
1711 for (i
= lineno
- this_lineno
; i
> 0; --i
)
1712 obstack_1grow (obstackp
, '\n');
1717 sprintf (buf
, "\n# %d \"", lineno
);
1719 obstack_grow (obstackp
, buf
, len
);
1721 len
= strlen (input_filename
);
1722 obstack_grow (obstackp
, input_filename
, len
);
1723 obstack_1grow (obstackp
, '\"');
1724 obstack_1grow (obstackp
, '\n');
1727 while (c
> ' ') /* ASCII dependent... */
1729 if (plev
<= 0 && (c
== ')' || c
== ','))
1734 obstack_1grow (obstackp
, c
);
1735 if (c
== '(' || c
== '[')
1737 else if (c
== ']' || c
== ')')
1741 /* Don't act on the next character...e.g, doing an escaped
1746 error_with_file_and_line (starting_filename
,
1748 "end of file read inside definition");
1751 obstack_1grow (obstackp
, c
);
1754 consume_string (obstackp
, c
);
1756 consume_string (obstackp
, c
);
1762 error_with_file_and_line (starting_filename
,
1764 "end of file read inside definition");
1769 obstack_1grow (obstackp
, c
);
1774 obstack_1grow (obstackp
, '\0');
1777 int do_snarf_defarg
;
1779 /* Decide whether the default argument we are about to see should be
1780 gobbled up as text for later parsing. */
1783 maybe_snarf_defarg ()
1785 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
1786 do_snarf_defarg
= 1;
1789 /* When we see a default argument in a method declaration, we snarf it as
1790 text using snarf_defarg. When we get up to namespace scope, we then go
1791 through and parse all of them using do_pending_defargs. Since yacc
1792 parsers are not reentrant, we retain defargs state in these two
1793 variables so that subsequent calls to do_pending_defargs can resume
1794 where the previous call left off. */
1806 reinit_parse_for_expr (&inline_text_obstack
);
1807 len
= obstack_object_size (&inline_text_obstack
);
1808 buf
= obstack_finish (&inline_text_obstack
);
1810 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1811 arg
= make_node (DEFAULT_ARG
);
1812 DEFARG_LENGTH (arg
) = len
- 1;
1813 DEFARG_POINTER (arg
) = buf
;
1819 /* Called from grokfndecl to note a function decl with unparsed default
1820 arguments for later processing. Also called from grokdeclarator
1821 for function types with unparsed defargs; the call from grokfndecl
1822 will always come second, so we can overwrite the entry from the type. */
1825 add_defarg_fn (decl
)
1828 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1829 TREE_VALUE (defarg_fns
) = decl
;
1832 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1833 defarg_fns
= tree_cons (current_class_type
, decl
, defarg_fns
);
1838 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1844 tree d
= TREE_PURPOSE (p
);
1845 feed_input (DEFARG_POINTER (d
), DEFARG_LENGTH (d
));
1846 if (TREE_CODE (f
) == FUNCTION_DECL
)
1848 lineno
= DECL_SOURCE_LINE (f
);
1849 input_filename
= DECL_SOURCE_FILE (f
);
1851 yychar
= DEFARG_MARKER
;
1855 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1860 if (yychar
== YYEMPTY
)
1862 if (yychar
!= END_OF_SAVED_INPUT
)
1864 error ("parse error at end of saved function text");
1866 /* restore_pending_input will abort unless yychar is either
1867 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1868 hosed, feed back YYEMPTY. We also need to discard nextchar,
1869 since that may have gotten set as well. */
1876 /* Main function for deferred parsing of default arguments. Called from
1880 do_pending_defargs ()
1885 for (; defarg_fns
; defarg_fns
= TREE_CHAIN (defarg_fns
))
1887 tree defarg_fn
= TREE_VALUE (defarg_fns
);
1888 if (defarg_parm
== NULL_TREE
)
1890 push_nested_class (TREE_PURPOSE (defarg_fns
), 1);
1892 if (is_member_template (defarg_fn
))
1893 begin_member_template_processing (defarg_fn
);
1895 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1899 for (p
= DECL_ARGUMENTS (defarg_fn
); p
; p
= TREE_CHAIN (p
))
1900 pushdecl (copy_node (p
));
1902 defarg_parm
= TYPE_ARG_TYPES (TREE_TYPE (defarg_fn
));
1905 defarg_parm
= TYPE_ARG_TYPES (defarg_fn
);
1908 defarg_parm
= TREE_CHAIN (defarg_parm
);
1910 for (; defarg_parm
; defarg_parm
= TREE_CHAIN (defarg_parm
))
1911 if (TREE_PURPOSE (defarg_parm
)
1912 && TREE_CODE (TREE_PURPOSE (defarg_parm
)) == DEFAULT_ARG
)
1914 feed_defarg (defarg_fn
, defarg_parm
);
1916 /* Return to the parser, which will process this defarg
1917 and call us again. */
1921 if (is_member_template (defarg_fn
))
1922 end_member_template_processing ();
1924 pop_nested_class (1);
1928 /* Build a default function named NAME for type TYPE.
1929 KIND says what to build.
1931 When KIND == 0, build default destructor.
1932 When KIND == 1, build virtual destructor.
1933 When KIND == 2, build default constructor.
1934 When KIND == 3, build default X(const X&) constructor.
1935 When KIND == 4, build default X(X&) constructor.
1936 When KIND == 5, build default operator = (const X&).
1937 When KIND == 6, build default operator = (X&). */
1940 cons_up_default_function (type
, full_name
, kind
)
1941 tree type
, full_name
;
1944 extern tree void_list_node
;
1945 tree declspecs
= NULL_TREE
;
1946 tree fn
, args
= NULL_TREE
;
1949 tree name
= constructor_name (full_name
);
1955 declspecs
= build_decl_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]);
1956 /* Fall through... */
1958 name
= build_parse_node (BIT_NOT_EXPR
, name
);
1959 args
= void_list_node
;
1963 /* Default constructor. */
1964 args
= void_list_node
;
1968 type
= build_type_variant (type
, 1, 0);
1969 /* Fall through... */
1971 /* According to ARM $12.8, the default copy ctor will be declared, but
1972 not defined, unless it's needed. */
1973 argtype
= build_reference_type (type
);
1974 args
= tree_cons (NULL_TREE
,
1975 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1976 get_identifier ("_ctor_arg")),
1983 declspecs
= build_decl_list (NULL_TREE
, type
);
1986 type
= build_type_variant (type
, 1, 0);
1988 name
= ansi_opname
[(int) MODIFY_EXPR
];
1990 argtype
= build_reference_type (type
);
1991 args
= tree_cons (NULL_TREE
,
1992 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1993 get_identifier ("_ctor_arg")),
1998 my_friendly_abort (59);
2001 declspecs
= decl_tree_cons (NULL_TREE
, ridpointers
[(int) RID_INLINE
],
2004 TREE_PARMLIST (args
) = 1;
2007 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, NULL_TREE
);
2009 declarator
= build_parse_node (ADDR_EXPR
, declarator
);
2011 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
2014 if (fn
== void_type_node
)
2018 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn
)));
2021 if (processing_template_defn
)
2023 SET_DECL_IMPLICIT_INSTANTIATION (fn
);
2024 repo_template_used (fn
);
2029 if (CLASSTYPE_INTERFACE_KNOWN (type
))
2031 DECL_INTERFACE_KNOWN (fn
) = 1;
2032 DECL_NOT_REALLY_EXTERN (fn
) = (!CLASSTYPE_INTERFACE_ONLY (type
)
2033 && flag_implement_inlines
);
2037 DECL_NOT_REALLY_EXTERN (fn
) = 1;
2039 mark_inline_for_output (fn
);
2041 #ifdef DEBUG_DEFAULT_FUNCTIONS
2042 { char *fn_type
= NULL
;
2046 case 0: fn_type
= "default destructor"; break;
2047 case 1: fn_type
= "virtual destructor"; break;
2048 case 2: fn_type
= "default constructor"; break;
2049 case 3: fn_type
= "default X(const X&)"; break;
2050 case 4: fn_type
= "default X(X&)"; break;
2054 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2055 t
= TREE_OPERAND (name
, 0);
2056 fprintf (stderr
, "[[[[ %s for %s:\n%s]]]]\n", fn_type
,
2057 IDENTIFIER_POINTER (t
), func_buf
);
2060 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2062 /* Show that this function was generated by the compiler. */
2063 SET_DECL_ARTIFICIAL (fn
);
2068 /* Heuristic to tell whether the user is missing a semicolon
2069 after a struct or enum declaration. Emit an error message
2070 if we know the user has blown it. */
2073 check_for_missing_semicolon (type
)
2081 && yychar
!= IDENTIFIER
2082 && yychar
!= TYPENAME
2083 && yychar
!= CV_QUALIFIER
2084 && yychar
!= SELFNAME
)
2087 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
2088 error ("semicolon missing after %s declaration",
2089 TREE_CODE (type
) == ENUMERAL_TYPE
? "enum" : "struct");
2091 cp_error ("semicolon missing after declaration of `%T'", type
);
2092 shadow_tag (build_tree_list (0, type
));
2094 /* Could probably also hack cases where class { ... } f (); appears. */
2099 note_got_semicolon (type
)
2102 if (TREE_CODE_CLASS (TREE_CODE (type
)) != 't')
2103 my_friendly_abort (60);
2104 if (IS_AGGR_TYPE (type
))
2105 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
2109 note_list_got_semicolon (declspecs
)
2114 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
2116 tree type
= TREE_VALUE (link
);
2117 if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't')
2118 note_got_semicolon (type
);
2123 /* If C is not whitespace, return C.
2124 Otherwise skip whitespace and return first nonwhite char read. */
2127 skip_white_space (c
)
2135 c
= check_newline ();
2146 while (c
== ' ' || c
== '\t');
2154 error ("stray '\\' in program");
2166 /* Make the token buffer longer, preserving the data in it.
2167 P should point to just beyond the last valid character in the old buffer.
2168 The value we return is a pointer to the new buffer
2169 at a place corresponding to P. */
2172 extend_token_buffer (p
)
2175 int offset
= p
- token_buffer
;
2177 maxtoken
= maxtoken
* 2 + 10;
2178 token_buffer
= (char *) xrealloc (token_buffer
, maxtoken
+ 2);
2180 return token_buffer
+ offset
;
2184 get_last_nonwhite_on_line ()
2188 /* Is this the last nonwhite stuff on the line? */
2190 c
= nextchar
, nextchar
= -1;
2194 while (c
== ' ' || c
== '\t')
2199 /* At the beginning of a line, increment the line number
2200 and process any #-directive on this line.
2201 If the line is a #-directive, read the entire line and return a newline.
2202 Otherwise, return the line's first non-whitespace character. */
2206 #ifdef HANDLE_SYSV_PRAGMA
2207 static int handle_sysv_pragma
PROTO((FILE *, int));
2209 static int handle_cp_pragma
PROTO((char *));
2217 /* Read first nonwhite char on the line. Do this before incrementing the
2218 line number, in case we're at the end of saved text. */
2222 while (c
== ' ' || c
== '\t');
2228 /* If not #, return it so caller will use it. */
2232 /* Don't read beyond this line. */
2235 /* Read first nonwhite char after the `#'. */
2239 while (c
== ' ' || c
== '\t');
2241 /* If a letter follows, then if the word here is `line', skip
2242 it and ignore it; otherwise, ignore the line, with an error
2243 if the word isn't `pragma'. */
2245 if ((c
>= 'a' && c
<= 'z') || (c
>= 'A' && c
<= 'Z'))
2255 token
= real_yylex ();
2256 if (token
== IDENTIFIER
2257 && TREE_CODE (yylval
.ttype
) == IDENTIFIER_NODE
)
2259 /* If this is 1, we handled it; if it's -1, it was one we
2260 wanted but had something wrong with it. Only if it's
2261 0 was it not handled. */
2262 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval
.ttype
)))
2265 else if (token
== END_OF_LINE
)
2268 #ifdef HANDLE_SYSV_PRAGMA
2269 if (handle_sysv_pragma (finput
, token
))
2272 #ifdef HANDLE_PRAGMA
2273 if (HANDLE_PRAGMA (finput
, yylval
.ttype
))
2287 && ((c
= getch ()) == ' ' || c
== '\t'))
2289 debug_define (lineno
, get_directive_line (finput
));
2299 && ((c
= getch ()) == ' ' || c
== '\t'))
2301 debug_undef (lineno
, get_directive_line (finput
));
2310 && ((c
= getch ()) == ' ' || c
== '\t'))
2319 && ((c
= getch ()) == ' ' || c
== '\t'))
2321 #ifdef ASM_OUTPUT_IDENT
2322 extern FILE *asm_out_file
;
2324 /* #ident. The pedantic warning is now in cccp.c. */
2326 /* Here we have just seen `#ident '.
2327 A string constant should follow. */
2329 token
= real_yylex ();
2330 if (token
== END_OF_LINE
)
2333 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
2335 error ("invalid #ident");
2339 if (! flag_no_ident
)
2341 #ifdef ASM_OUTPUT_IDENT
2342 ASM_OUTPUT_IDENT (asm_out_file
,
2343 TREE_STRING_POINTER (yylval
.ttype
));
2347 /* Skip the rest of this line. */
2360 && ((c
= getch ()) == ' ' || c
== '\t'))
2362 /* Used to test incremental compilation. */
2363 sorry ("#pragma newworld");
2367 error ("undefined or invalid # directive");
2372 /* Here we have either `#line' or `# <nonletter>'.
2373 In either case, it should be a line number; a digit should follow. */
2375 while (c
== ' ' || c
== '\t')
2378 /* If the # is the only nonwhite char on the line,
2379 just ignore it. Check the new newline. */
2383 /* Something follows the #; read a token. */
2386 token
= real_yylex ();
2388 if (token
== CONSTANT
2389 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2391 int old_lineno
= lineno
;
2392 enum { act_none
, act_push
, act_pop
} action
= act_none
;
2393 int entering_system_header
= 0;
2394 int entering_c_header
= 0;
2396 /* subtract one, because it is the following line that
2397 gets the specified number */
2399 int l
= TREE_INT_CST_LOW (yylval
.ttype
) - 1;
2400 c
= get_last_nonwhite_on_line ();
2403 /* No more: store the line number and check following line. */
2409 /* More follows: it must be a string constant (filename). */
2411 /* Read the string constant, but don't treat \ as special. */
2412 ignore_escape_flag
= 1;
2413 token
= real_yylex ();
2414 ignore_escape_flag
= 0;
2416 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
2418 error ("invalid #line");
2422 /* Changing files again. This means currently collected time
2423 is charged against header time, and body time starts back
2425 if (flag_detailed_statistics
)
2427 int this_time
= my_get_run_time ();
2428 tree time_identifier
= get_time_identifier (TREE_STRING_POINTER (yylval
.ttype
));
2429 header_time
+= this_time
- body_time
;
2430 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
))
2431 += this_time
- body_time
;
2432 this_filename_time
= time_identifier
;
2433 body_time
= this_time
;
2437 = (char *) permalloc (TREE_STRING_LENGTH (yylval
.ttype
) + 1);
2438 strcpy (input_filename
, TREE_STRING_POINTER (yylval
.ttype
));
2440 GNU_xref_file (input_filename
);
2442 if (main_input_filename
== 0)
2444 struct impl_files
*ifiles
= impl_file_chain
;
2448 while (ifiles
->next
)
2449 ifiles
= ifiles
->next
;
2450 ifiles
->filename
= file_name_nondirectory (input_filename
);
2453 main_input_filename
= input_filename
;
2454 if (write_virtuals
== 3)
2455 walk_vtables (set_typedecl_interface_info
, set_vardecl_interface_info
);
2458 extract_interface_info ();
2460 c
= get_last_nonwhite_on_line ();
2463 /* Update the name in the top element of input_file_stack. */
2464 if (input_file_stack
)
2465 input_file_stack
->name
= input_filename
;
2471 token
= real_yylex ();
2473 /* `1' after file name means entering new file.
2474 `2' after file name means just left a file. */
2476 if (token
== CONSTANT
2477 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2479 if (TREE_INT_CST_LOW (yylval
.ttype
) == 1)
2481 else if (TREE_INT_CST_LOW (yylval
.ttype
) == 2)
2486 c
= get_last_nonwhite_on_line ();
2490 token
= real_yylex ();
2495 /* `3' after file name means this is a system header file. */
2497 if (token
== CONSTANT
2498 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
2499 && TREE_INT_CST_LOW (yylval
.ttype
) == 3)
2501 entering_system_header
= 1;
2503 c
= get_last_nonwhite_on_line ();
2507 token
= real_yylex ();
2511 /* `4' after file name means this is a C header file. */
2513 if (token
== CONSTANT
2514 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
2515 && TREE_INT_CST_LOW (yylval
.ttype
) == 4)
2517 entering_c_header
= 1;
2519 c
= get_last_nonwhite_on_line ();
2523 token
= real_yylex ();
2527 /* Do the actions implied by the preceding numbers. */
2529 if (action
== act_push
)
2531 /* Pushing to a new file. */
2532 struct file_stack
*p
;
2534 p
= (struct file_stack
*) xmalloc (sizeof (struct file_stack
));
2535 input_file_stack
->line
= old_lineno
;
2536 p
->next
= input_file_stack
;
2537 p
->name
= input_filename
;
2538 input_file_stack
= p
;
2539 input_file_stack_tick
++;
2540 debug_start_source_file (input_filename
);
2541 in_system_header
= entering_system_header
;
2544 else if (entering_c_header
)
2547 ++pending_lang_change
;
2550 else if (action
== act_pop
)
2552 /* Popping out of a file. */
2553 if (input_file_stack
->next
)
2555 struct file_stack
*p
;
2557 if (c_header_level
&& --c_header_level
== 0)
2559 if (entering_c_header
)
2560 warning ("badly nested C headers from preprocessor");
2561 --pending_lang_change
;
2563 in_system_header
= entering_system_header
;
2565 p
= input_file_stack
;
2566 input_file_stack
= p
->next
;
2568 input_file_stack_tick
++;
2569 debug_end_source_file (input_file_stack
->line
);
2572 error ("#-lines for entering and leaving files don't match");
2575 in_system_header
= entering_system_header
;
2578 /* If NEXTCHAR is not end of line, we don't care what it is. */
2579 if (nextchar
== EOF
)
2583 error ("invalid #-line");
2585 /* skip the rest of this line. */
2590 while ((c
= getch ()) != EOF
&& c
!= '\n');
2595 do_pending_lang_change ()
2597 for (; pending_lang_change
> 0; --pending_lang_change
)
2598 push_lang_context (lang_name_c
);
2599 for (; pending_lang_change
< 0; ++pending_lang_change
)
2600 pop_lang_context ();
2604 #define isalnum(char) (char >= 'a' ? char <= 'z' : char >= '0' ? char <= '9' || (char >= 'A' && char <= 'Z') : 0)
2605 #define isdigit(char) (char >= '0' && char <= '9')
2610 #define ENDFILE -1 /* token that represents end-of-file */
2612 /* Read an escape sequence, returning its equivalent as a character,
2613 or store 1 in *ignore_ptr if it is backslash-newline. */
2616 readescape (ignore_ptr
)
2619 register int c
= getch ();
2621 register unsigned count
;
2622 unsigned firstdig
= 0;
2640 if (c
>= 'a' && c
<= 'f')
2641 code
+= c
- 'a' + 10;
2642 if (c
>= 'A' && c
<= 'F')
2643 code
+= c
- 'A' + 10;
2644 if (c
>= '0' && c
<= '9')
2646 if (code
!= 0 || count
!= 0)
2655 error ("\\x used with no following hex digits");
2656 else if (count
== 0)
2657 /* Digits are all 0's. Ok. */
2659 else if ((count
- 1) * 4 >= TYPE_PRECISION (integer_type_node
)
2661 && ((1 << (TYPE_PRECISION (integer_type_node
) - (count
- 1) * 4))
2663 pedwarn ("hex escape out of range");
2666 case '0': case '1': case '2': case '3': case '4':
2667 case '5': case '6': case '7':
2670 while ((c
<= '7') && (c
>= '0') && (count
++ < 3))
2672 code
= (code
* 8) + (c
- '0');
2678 case '\\': case '\'': case '"':
2687 return TARGET_NEWLINE
;
2710 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c
);
2716 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2720 /* `\%' is used to prevent SCCS from getting confused. */
2723 pedwarn ("unknown escape sequence `\\%c'", c
);
2726 if (c
>= 040 && c
< 0177)
2727 pedwarn ("unknown escape sequence `\\%c'", c
);
2729 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c
);
2733 /* Value is 1 (or 2) if we should try to make the next identifier look like
2734 a typename (when it may be a local variable or a class variable).
2735 Value is 0 if we treat this name in a default fashion. */
2736 int looking_for_typename
= 0;
2742 identifier_type (decl
)
2745 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2747 if (TREE_CODE (DECL_RESULT (decl
)) == TYPE_DECL
)
2749 else if (looking_for_template
)
2752 if (looking_for_template
&& really_overloaded_fn (decl
))
2755 for (t
= TREE_VALUE (decl
); t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
2756 if (DECL_FUNCTION_TEMPLATE_P (t
))
2759 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2761 if (TREE_CODE (decl
) != TYPE_DECL
)
2763 if (((got_scope
&& TREE_TYPE (decl
) == got_scope
)
2764 || TREE_TYPE (decl
) == current_class_type
)
2765 && DECL_ARTIFICIAL (decl
))
2773 looking_for_typename
= 1;
2775 if ((yychar
= yylex ()) < 0) yychar
= 0;
2776 looking_for_typename
= 0;
2777 if (yychar
== IDENTIFIER
)
2779 lastiddecl
= lookup_name (yylval
.ttype
, -2);
2780 if (lastiddecl
== 0)
2783 lastiddecl
= IDENTIFIER_LABEL_VALUE (yylval
.ttype
);
2786 yychar
= identifier_type (lastiddecl
);
2791 do_identifier (token
, parsing
)
2792 register tree token
;
2797 if (! parsing
|| IDENTIFIER_OPNAME_P (token
))
2798 id
= lookup_name (token
, 0);
2802 if (parsing
&& yychar
== YYEMPTY
)
2804 /* Scope class declarations before global
2806 if (id
== IDENTIFIER_GLOBAL_VALUE (token
)
2807 && current_class_type
!= 0
2808 && TYPE_SIZE (current_class_type
) == 0)
2810 /* Could be from one of the base classes. */
2811 tree field
= lookup_field (current_class_type
, token
, 1, 0);
2814 else if (field
== error_mark_node
)
2815 /* We have already generated the error message.
2816 But we still want to return this value. */
2817 id
= lookup_field (current_class_type
, token
, 0, 0);
2818 else if (TREE_CODE (field
) == VAR_DECL
2819 || TREE_CODE (field
) == CONST_DECL
)
2821 else if (TREE_CODE (field
) != FIELD_DECL
)
2822 my_friendly_abort (61);
2825 cp_error ("invalid use of member `%D' from base class `%T'", field
,
2826 DECL_FIELD_CONTEXT (field
));
2827 id
= error_mark_node
;
2832 /* Remember that this name has been used in the class definition, as per
2834 if (id
&& current_class_type
&& parsing
2835 && TYPE_BEING_DEFINED (current_class_type
)
2836 && ! IDENTIFIER_CLASS_VALUE (token
)
2837 /* Avoid breaking if we get called for a default argument that
2838 refers to an overloaded method. Eventually this will not be
2839 necessary, since default arguments shouldn't be parsed until
2840 after the class is complete. (jason 3/12/97) */
2841 && TREE_CODE (id
) != TREE_LIST
)
2842 pushdecl_class_level (id
);
2844 if (!id
|| id
== error_mark_node
)
2846 if (id
== error_mark_node
&& current_class_type
!= NULL_TREE
)
2848 id
= lookup_nested_field (token
, 1);
2849 /* In lookup_nested_field(), we marked this so we can gracefully
2850 leave this whole mess. */
2851 if (id
&& id
!= error_mark_node
&& TREE_TYPE (id
) == error_mark_node
)
2855 if (current_template_parms
)
2856 return build_min_nt (LOOKUP_EXPR
, token
, NULL_TREE
);
2857 else if (IDENTIFIER_OPNAME_P (token
))
2859 if (token
!= ansi_opname
[ERROR_MARK
])
2860 cp_error ("`%D' not defined", token
);
2861 id
= error_mark_node
;
2863 else if (parsing
&& (yychar
== '(' || yychar
== LEFT_RIGHT
))
2865 id
= implicitly_declare (token
);
2867 else if (current_function_decl
== 0)
2869 cp_error ("`%D' was not declared in this scope", token
);
2870 id
= error_mark_node
;
2874 if (IDENTIFIER_GLOBAL_VALUE (token
) != error_mark_node
2875 || IDENTIFIER_ERROR_LOCUS (token
) != current_function_decl
)
2877 static int undeclared_variable_notice
;
2879 cp_error ("`%D' undeclared (first use this function)", token
);
2881 if (! undeclared_variable_notice
)
2883 error ("(Each undeclared identifier is reported only once");
2884 error ("for each function it appears in.)");
2885 undeclared_variable_notice
= 1;
2888 id
= error_mark_node
;
2889 /* Prevent repeated error messages. */
2890 IDENTIFIER_GLOBAL_VALUE (token
) = error_mark_node
;
2891 SET_IDENTIFIER_ERROR_LOCUS (token
, current_function_decl
);
2895 if (TREE_CODE (id
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (id
))
2897 tree shadowed
= DECL_SHADOWED_FOR_VAR (id
);
2898 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
2899 && DECL_DEAD_FOR_LOCAL (shadowed
))
2900 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
2902 shadowed
= IDENTIFIER_GLOBAL_VALUE (DECL_NAME (id
));
2905 if (!DECL_ERROR_REPORTED (id
))
2907 warning ("name lookup of `%s' changed",
2908 IDENTIFIER_POINTER (token
));
2909 cp_warning_at (" matches this `%D' under current ANSI rules",
2911 cp_warning_at (" matches this `%D' under old rules", id
);
2912 DECL_ERROR_REPORTED (id
) = 1;
2916 else if (!DECL_ERROR_REPORTED (id
))
2919 = "name lookup of `%s' changed for new ANSI `for' scoping";
2920 DECL_ERROR_REPORTED (id
) = 1;
2921 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id
)))
2923 error (msg
, IDENTIFIER_POINTER (token
));
2924 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id
);
2925 id
= error_mark_node
;
2929 pedwarn (msg
, IDENTIFIER_POINTER (token
));
2930 cp_pedwarn_at (" using obsolete binding at `%D'", id
);
2934 /* TREE_USED is set in `hack_identifier'. */
2935 if (TREE_CODE (id
) == CONST_DECL
)
2937 if (IDENTIFIER_CLASS_VALUE (token
) == id
)
2940 tree access
= compute_access (TYPE_BINFO (current_class_type
), id
);
2941 if (access
== access_private_node
)
2942 cp_error ("enum `%D' is private", id
);
2943 /* protected is OK, since it's an enum of `this'. */
2945 if (! processing_template_decl
2946 || (DECL_INITIAL (id
)
2947 && TREE_CODE (DECL_INITIAL (id
)) == TEMPLATE_CONST_PARM
))
2948 id
= DECL_INITIAL (id
);
2951 id
= hack_identifier (id
, token
);
2953 if (current_template_parms
)
2955 if (is_overloaded_fn (id
))
2957 tree t
= build_min (LOOKUP_EXPR
, unknown_type_node
,
2958 token
, get_first_fn (id
));
2959 if (id
!= IDENTIFIER_GLOBAL_VALUE (token
))
2960 TREE_OPERAND (t
, 1) = error_mark_node
;
2963 else if (! TREE_PERMANENT (id
) || TREE_CODE (id
) == PARM_DECL
2964 || TREE_CODE (id
) == USING_DECL
)
2965 id
= build_min (LOOKUP_EXPR
, TREE_TYPE (id
), token
, error_mark_node
);
2966 /* else just use the decl */
2973 do_scoped_id (token
, parsing
)
2977 tree id
= IDENTIFIER_GLOBAL_VALUE (token
);
2978 if (parsing
&& yychar
== YYEMPTY
)
2982 if (processing_template_decl
)
2984 id
= build_min_nt (LOOKUP_EXPR
, token
, NULL_TREE
);
2985 LOOKUP_EXPR_GLOBAL (id
) = 1;
2988 if (parsing
&& yychar
== '(' || yychar
== LEFT_RIGHT
)
2989 id
= implicitly_declare (token
);
2992 if (IDENTIFIER_GLOBAL_VALUE (token
) != error_mark_node
)
2993 error ("undeclared variable `%s' (first use here)",
2994 IDENTIFIER_POINTER (token
));
2995 id
= error_mark_node
;
2996 /* Prevent repeated error messages. */
2997 IDENTIFIER_GLOBAL_VALUE (token
) = error_mark_node
;
3002 if (TREE_CODE (id
) == ADDR_EXPR
)
3003 mark_used (TREE_OPERAND (id
, 0));
3004 else if (TREE_CODE (id
) != TREE_LIST
)
3007 if (TREE_CODE (id
) == CONST_DECL
&& ! processing_template_decl
)
3009 /* XXX CHS - should we set TREE_USED of the constant? */
3010 id
= DECL_INITIAL (id
);
3011 /* This is to prevent an enum whose value is 0
3012 from being considered a null pointer constant. */
3013 id
= build1 (NOP_EXPR
, TREE_TYPE (id
), id
);
3014 TREE_CONSTANT (id
) = 1;
3017 if (processing_template_decl
)
3019 if (is_overloaded_fn (id
))
3021 id
= build_min (LOOKUP_EXPR
, unknown_type_node
,
3022 token
, get_first_fn (id
));
3023 LOOKUP_EXPR_GLOBAL (id
) = 1;
3025 /* else just use the decl */
3027 return convert_from_reference (id
);
3031 identifier_typedecl_value (node
)
3035 type
= IDENTIFIER_TYPE_VALUE (node
);
3036 if (type
== NULL_TREE
)
3041 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3044 do (IDENTIFIER_LOCAL_VALUE (node
));
3045 do (IDENTIFIER_CLASS_VALUE (node
));
3046 do (IDENTIFIER_GLOBAL_VALUE (node
));
3048 /* Will this one ever happen? */
3049 if (TYPE_MAIN_DECL (type
))
3050 return TYPE_MAIN_DECL (type
);
3052 /* We used to do an internal error of 62 here, but instead we will
3053 handle the return of a null appropriately in the callers. */
3063 int dollar_seen
= 0;
3067 c
= nextchar
, nextchar
= -1;
3071 /* Effectively do c = skip_white_space (c)
3072 but do it faster in the usual cases. */
3085 /* Call skip_white_space so we can warn if appropriate. */
3090 c
= skip_white_space (c
);
3092 goto found_nonwhite
;
3096 token_buffer
[0] = c
;
3097 token_buffer
[1] = 0;
3099 /* yylloc.first_line = lineno; */
3104 token_buffer
[0] = '\0';
3106 if (input_redirected ())
3107 value
= END_OF_SAVED_INPUT
;
3109 value
= END_OF_LINE
;
3115 if (! dollars_in_ident
)
3116 error ("`$' in identifier");
3118 pedwarn ("`$' in identifier");
3123 /* Capital L may start a wide-string or wide-character constant. */
3125 register int c
= getch ();
3134 goto string_constant
;
3139 case 'A': case 'B': case 'C': case 'D': case 'E':
3140 case 'F': case 'G': case 'H': case 'I': case 'J':
3141 case 'K': case 'M': case 'N': case 'O':
3142 case 'P': case 'Q': case 'R': case 'S': case 'T':
3143 case 'U': case 'V': case 'W': case 'X': case 'Y':
3145 case 'a': case 'b': case 'c': case 'd': case 'e':
3146 case 'f': case 'g': case 'h': case 'i': case 'j':
3147 case 'k': case 'l': case 'm': case 'n': case 'o':
3148 case 'p': case 'q': case 'r': case 's': case 't':
3149 case 'u': case 'v': case 'w': case 'x': case 'y':
3159 /* We know that `token_buffer' can hold at least on char,
3160 so we install C immediately.
3161 We may have to read the value in `putback_char', so call
3166 /* Make this run fast. We know that we are reading straight
3167 from FINPUT in this case (since identifiers cannot straddle
3169 while (isalnum (c
) || (c
== '_') || c
== '$')
3173 if (! dollars_in_ident
)
3174 error ("`$' in identifier");
3176 pedwarn ("`$' in identifier");
3179 if (p
>= token_buffer
+ maxtoken
)
3180 p
= extend_token_buffer (p
);
3186 if (linemode
&& c
== '\n')
3194 /* We know that `token_buffer' can hold at least on char,
3195 so we install C immediately. */
3199 while (isalnum (c
) || (c
== '_') || c
== '$')
3203 if (! dollars_in_ident
)
3204 error ("`$' in identifier");
3206 pedwarn ("`$' in identifier");
3209 if (p
>= token_buffer
+ maxtoken
)
3210 p
= extend_token_buffer (p
);
3223 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3226 register struct resword
*ptr
;
3228 if ((ptr
= is_reserved_word (token_buffer
, p
- token_buffer
)))
3232 tree old_ttype
= ridpointers
[(int) ptr
->rid
];
3234 /* If this provides a type for us, then revert lexical
3235 state to standard state. */
3236 if (TREE_CODE (old_ttype
) == IDENTIFIER_NODE
3237 && IDENTIFIER_GLOBAL_VALUE (old_ttype
) != 0
3238 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype
)) == TYPE_DECL
)
3239 looking_for_typename
= 0;
3240 else if (ptr
->token
== AGGR
|| ptr
->token
== ENUM
)
3241 looking_for_typename
= 1;
3243 /* Check if this is a language-type declaration.
3244 Just glimpse the next non-white character. */
3245 nextchar
= skip_white_space (nextchar
);
3246 if (nextchar
== '"')
3248 /* We are looking at a string. Complain
3249 if the token before the string is no `extern'.
3251 Could cheat some memory by placing this string
3252 on the temporary_, instead of the saveable_
3255 if (ptr
->rid
!= RID_EXTERN
)
3256 error ("invalid modifier `%s' for language string",
3259 value
= EXTERN_LANG_STRING
;
3260 yylval
.ttype
= get_identifier (TREE_STRING_POINTER (yylval
.ttype
));
3263 if (ptr
->token
== VISSPEC
)
3268 yylval
.ttype
= access_public_node
;
3271 yylval
.ttype
= access_private_node
;
3274 yylval
.ttype
= access_protected_node
;
3277 my_friendly_abort (63);
3281 yylval
.ttype
= old_ttype
;
3283 else if (ptr
->token
== EQCOMPARE
)
3285 yylval
.code
= NE_EXPR
;
3286 token_buffer
[0] = '!';
3287 token_buffer
[1] = '=';
3288 token_buffer
[2] = 0;
3290 else if (ptr
->token
== ASSIGN
)
3292 if (strcmp ("and_eq", token_buffer
) == 0)
3294 yylval
.code
= BIT_AND_EXPR
;
3295 token_buffer
[0] = '&';
3297 else if (strcmp ("or_eq", token_buffer
) == 0)
3299 yylval
.code
= BIT_IOR_EXPR
;
3300 token_buffer
[0] = '|';
3302 else if (strcmp ("xor_eq", token_buffer
) == 0)
3304 yylval
.code
= BIT_XOR_EXPR
;
3305 token_buffer
[0] = '^';
3307 token_buffer
[1] = '=';
3308 token_buffer
[2] = 0;
3310 else if (ptr
->token
== '&')
3312 yylval
.code
= BIT_AND_EXPR
;
3313 token_buffer
[0] = '&';
3314 token_buffer
[1] = 0;
3316 else if (ptr
->token
== '|')
3318 yylval
.code
= BIT_IOR_EXPR
;
3319 token_buffer
[0] = '|';
3320 token_buffer
[1] = 0;
3322 else if (ptr
->token
== '^')
3324 yylval
.code
= BIT_XOR_EXPR
;
3325 token_buffer
[0] = '^';
3326 token_buffer
[1] = 0;
3329 value
= (int) ptr
->token
;
3333 /* If we did not find a keyword, look for an identifier
3336 if (value
== IDENTIFIER
|| value
== TYPESPEC
)
3337 GNU_xref_ref (current_function_decl
, token_buffer
);
3339 if (value
== IDENTIFIER
)
3341 register tree tmp
= get_identifier (token_buffer
);
3343 #if !defined(VMS) && defined(JOINER)
3344 /* Make sure that user does not collide with our internal
3348 && (THIS_NAME_P (tmp
)
3349 || VPTR_NAME_P (tmp
)
3350 || DESTRUCTOR_NAME_P (tmp
)
3351 || VTABLE_NAME_P (tmp
)
3352 || TEMP_NAME_P (tmp
)
3353 || ANON_AGGRNAME_P (tmp
)
3354 || ANON_PARMNAME_P (tmp
)))
3355 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3361 if (value
== NEW
&& ! global_bindings_p ())
3371 register int c1
= getch ();
3372 token_buffer
[0] = c
;
3373 token_buffer
[1] = c1
;
3377 token_buffer
[2] = 0;
3385 token_buffer
[2] = c1
;
3386 token_buffer
[3] = 0;
3390 error ("parse error at `..'");
3395 goto resume_numerical_scan
;
3399 token_buffer
[1] = 0;
3403 /* Optimize for most frequent case. */
3405 register int c1
= getch ();
3406 if (! isalnum (c1
) && c1
!= '.')
3408 /* Terminate string. */
3409 token_buffer
[0] = c
;
3410 token_buffer
[1] = 0;
3412 yylval
.ttype
= integer_zero_node
;
3414 yylval
.ttype
= integer_one_node
;
3421 /* fall through... */
3422 case '2': case '3': case '4':
3423 case '5': case '6': case '7': case '8': case '9':
3424 resume_numerical_scan
:
3429 int largest_digit
= 0;
3431 /* for multi-precision arithmetic,
3432 we actually store only HOST_BITS_PER_CHAR bits in each part.
3433 The number of parts is chosen so as to be sufficient to hold
3434 the enough bits to fit into the two HOST_WIDE_INTs that contain
3435 the integer value (this is always at least as many bits as are
3436 in a target `long long' value, but may be wider). */
3437 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3438 int parts
[TOTAL_PARTS
];
3441 enum anon1
{ NOT_FLOAT
, AFTER_POINT
, TOO_MANY_POINTS
} floatflag
3444 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3452 *p
++ = (c
= getch ());
3453 if ((c
== 'x') || (c
== 'X'))
3456 *p
++ = (c
= getch ());
3458 /* Leading 0 forces octal unless the 0 is the only digit. */
3459 else if (c
>= '0' && c
<= '9')
3468 /* Read all the digits-and-decimal-points. */
3471 || (isalnum (c
) && (c
!= 'l') && (c
!= 'L')
3472 && (c
!= 'u') && (c
!= 'U')
3473 && c
!= 'i' && c
!= 'I' && c
!= 'j' && c
!= 'J'
3474 && (floatflag
== NOT_FLOAT
|| ((c
!= 'f') && (c
!= 'F')))))
3479 error ("floating constant may not be in radix 16");
3480 if (floatflag
== TOO_MANY_POINTS
)
3481 /* We have already emitted an error. Don't need another. */
3483 else if (floatflag
== AFTER_POINT
)
3485 error ("malformed floating constant");
3486 floatflag
= TOO_MANY_POINTS
;
3487 /* Avoid another error from atof by forcing all characters
3488 from here on to be ignored. */
3492 floatflag
= AFTER_POINT
;
3495 *p
++ = c
= getch ();
3496 /* Accept '.' as the start of a floating-point number
3497 only when it is followed by a digit.
3498 Otherwise, unread the following non-digit
3499 and use the '.' as a structural token. */
3500 if (p
== token_buffer
+ 2 && !isdigit (c
))
3512 error ("parse error at `..'");
3515 token_buffer
[1] = '\0';
3522 /* It is not a decimal point.
3523 It should be a digit (perhaps a hex digit). */
3529 else if (base
<= 10)
3531 if (c
== 'e' || c
== 'E')
3534 floatflag
= AFTER_POINT
;
3535 break; /* start of exponent */
3537 error ("nondigits in number and not hexadecimal");
3548 if (c
>= largest_digit
)
3552 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3554 parts
[count
] *= base
;
3558 += (parts
[count
-1] >> HOST_BITS_PER_CHAR
);
3560 &= (1 << HOST_BITS_PER_CHAR
) - 1;
3566 /* If the extra highest-order part ever gets anything in it,
3567 the number is certainly too big. */
3568 if (parts
[TOTAL_PARTS
- 1] != 0)
3571 if (p
>= token_buffer
+ maxtoken
- 3)
3572 p
= extend_token_buffer (p
);
3573 *p
++ = (c
= getch ());
3578 error ("numeric constant with no digits");
3580 if (largest_digit
>= base
)
3581 error ("numeric constant contains digits beyond the radix");
3583 /* Remove terminating char from the token buffer and delimit the string */
3586 if (floatflag
!= NOT_FLOAT
)
3588 tree type
= double_type_node
;
3589 int exceeds_double
= 0;
3591 REAL_VALUE_TYPE value
;
3594 /* Read explicit exponent if any, and put it in tokenbuf. */
3596 if ((c
== 'e') || (c
== 'E'))
3598 if (p
>= token_buffer
+ maxtoken
- 3)
3599 p
= extend_token_buffer (p
);
3602 if ((c
== '+') || (c
== '-'))
3608 error ("floating constant exponent has no digits");
3611 if (p
>= token_buffer
+ maxtoken
- 3)
3612 p
= extend_token_buffer (p
);
3621 /* Convert string to a double, checking for overflow. */
3622 if (setjmp (handler
))
3624 error ("floating constant out of range");
3629 int fflag
= 0, lflag
= 0;
3630 /* Copy token_buffer now, while it has just the number
3631 and not the suffixes; once we add `f' or `i',
3632 REAL_VALUE_ATOF may not work any more. */
3633 char *copy
= (char *) alloca (p
- token_buffer
+ 1);
3634 bcopy (token_buffer
, copy
, p
- token_buffer
+ 1);
3636 set_float_handler (handler
);
3642 /* Read the suffixes to choose a data type. */
3647 error ("more than one `f' in numeric constant");
3653 error ("more than one `l' in numeric constant");
3659 error ("more than one `i' or `j' in numeric constant");
3661 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3672 if (p
>= token_buffer
+ maxtoken
- 3)
3673 p
= extend_token_buffer (p
);
3679 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3680 tells the desired precision of the binary result
3681 of decimal-to-binary conversion. */
3686 error ("both `f' and `l' in floating constant");
3688 type
= float_type_node
;
3689 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3690 /* A diagnostic is required here by some ANSI C testsuites.
3691 This is not pedwarn, become some people don't want
3692 an error for this. */
3693 if (REAL_VALUE_ISINF (value
) && pedantic
)
3694 warning ("floating point number exceeds range of `float'");
3698 type
= long_double_type_node
;
3699 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3700 if (REAL_VALUE_ISINF (value
) && pedantic
)
3701 warning ("floating point number exceeds range of `long double'");
3705 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3706 if (REAL_VALUE_ISINF (value
) && pedantic
)
3707 warning ("floating point number exceeds range of `double'");
3710 set_float_handler (NULL_PTR
);
3713 if (errno
== ERANGE
&& pedantic
)
3715 /* ERANGE is also reported for underflow,
3716 so test the value to distinguish overflow from that. */
3717 if (REAL_VALUES_LESS (dconst1
, value
)
3718 || REAL_VALUES_LESS (value
, dconstm1
))
3720 pedwarn ("floating point number exceeds range of `%s'",
3721 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type
)));
3727 /* If the result is not a number, assume it must have been
3728 due to some error message above, so silently convert
3730 if (REAL_VALUE_ISNAN (value
))
3733 /* Create a node with determined type and value. */
3735 yylval
.ttype
= build_complex (NULL_TREE
,
3736 cp_convert (type
, integer_zero_node
),
3737 build_real (type
, value
));
3739 yylval
.ttype
= build_real (type
, value
);
3744 HOST_WIDE_INT high
, low
;
3745 int spec_unsigned
= 0;
3747 int spec_long_long
= 0;
3753 if (c
== 'u' || c
== 'U')
3756 error ("two `u's in integer constant");
3759 else if (c
== 'l' || c
== 'L')
3764 error ("three `l's in integer constant");
3766 pedwarn ("ANSI C++ forbids long long integer constants");
3771 else if (c
== 'i' || c
== 'j' || c
== 'I' || c
== 'J')
3774 error ("more than one `i' or `j' in numeric constant");
3776 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3781 if (p
>= token_buffer
+ maxtoken
- 3)
3782 p
= extend_token_buffer (p
);
3787 /* If the constant is not long long and it won't fit in an
3788 unsigned long, or if the constant is long long and won't fit
3789 in an unsigned long long, then warn that the constant is out
3792 /* ??? This assumes that long long and long integer types are
3793 a multiple of 8 bits. This better than the original code
3794 though which assumed that long was exactly 32 bits and long
3795 long was exactly 64 bits. */
3798 bytes
= TYPE_PRECISION (long_long_integer_type_node
) / 8;
3800 bytes
= TYPE_PRECISION (long_integer_type_node
) / 8;
3803 for (i
= bytes
; i
< TOTAL_PARTS
; i
++)
3807 pedwarn ("integer constant out of range");
3809 /* This is simplified by the fact that our constant
3810 is always positive. */
3813 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
; i
++)
3815 high
|= ((HOST_WIDE_INT
) parts
[i
+ (HOST_BITS_PER_WIDE_INT
3816 / HOST_BITS_PER_CHAR
)]
3817 << (i
* HOST_BITS_PER_CHAR
));
3818 low
|= (HOST_WIDE_INT
) parts
[i
] << (i
* HOST_BITS_PER_CHAR
);
3822 yylval
.ttype
= build_int_2 (low
, high
);
3823 TREE_TYPE (yylval
.ttype
) = long_long_unsigned_type_node
;
3825 /* Calculate the ANSI type. */
3826 if (!spec_long
&& !spec_unsigned
3827 && int_fits_type_p (yylval
.ttype
, integer_type_node
))
3828 type
= integer_type_node
;
3829 else if (!spec_long
&& (base
!= 10 || spec_unsigned
)
3830 && int_fits_type_p (yylval
.ttype
, unsigned_type_node
))
3831 /* Nondecimal constants try unsigned even in traditional C. */
3832 type
= unsigned_type_node
;
3833 else if (!spec_unsigned
&& !spec_long_long
3834 && int_fits_type_p (yylval
.ttype
, long_integer_type_node
))
3835 type
= long_integer_type_node
;
3836 else if (! spec_long_long
)
3837 type
= long_unsigned_type_node
;
3838 else if (! spec_unsigned
3839 /* Verify value does not overflow into sign bit. */
3840 && TREE_INT_CST_HIGH (yylval
.ttype
) >= 0
3841 && int_fits_type_p (yylval
.ttype
,
3842 long_long_integer_type_node
))
3843 type
= long_long_integer_type_node
;
3845 type
= long_long_unsigned_type_node
;
3847 if (!int_fits_type_p (yylval
.ttype
, type
) && !warn
)
3848 pedwarn ("integer constant out of range");
3850 if (base
== 10 && ! spec_unsigned
&& TREE_UNSIGNED (type
))
3851 warning ("decimal integer constant is so large that it is unsigned");
3855 if (TYPE_PRECISION (type
)
3856 <= TYPE_PRECISION (integer_type_node
))
3858 = build_complex (NULL_TREE
, integer_zero_node
,
3859 cp_convert (integer_type_node
,
3862 error ("complex integer constant is too wide for `__complex int'");
3865 TREE_TYPE (yylval
.ttype
) = type
;
3871 value
= CONSTANT
; break;
3877 register int result
= 0;
3878 register int num_chars
= 0;
3879 unsigned width
= TYPE_PRECISION (char_type_node
);
3884 width
= WCHAR_TYPE_SIZE
;
3885 #ifdef MULTIBYTE_CHARS
3886 max_chars
= MB_CUR_MAX
;
3892 max_chars
= TYPE_PRECISION (integer_type_node
) / width
;
3900 if (c
== '\'' || c
== EOF
)
3906 c
= readescape (&ignore
);
3909 if (width
< HOST_BITS_PER_INT
3910 && (unsigned) c
>= (1 << width
))
3911 warning ("escape sequence out of range for character");
3912 #ifdef MAP_CHARACTER
3914 c
= MAP_CHARACTER (c
);
3920 pedwarn ("ANSI C++ forbids newline in character constant");
3923 #ifdef MAP_CHARACTER
3925 c
= MAP_CHARACTER (c
);
3929 if (num_chars
> maxtoken
- 4)
3930 extend_token_buffer (token_buffer
);
3932 token_buffer
[num_chars
] = c
;
3934 /* Merge character into result; ignore excess chars. */
3935 if (num_chars
< max_chars
+ 1)
3937 if (width
< HOST_BITS_PER_INT
)
3938 result
= (result
<< width
) | (c
& ((1 << width
) - 1));
3944 token_buffer
[num_chars
+ 1] = '\'';
3945 token_buffer
[num_chars
+ 2] = 0;
3948 error ("malformatted character constant");
3949 else if (num_chars
== 0)
3950 error ("empty character constant");
3951 else if (num_chars
> max_chars
)
3953 num_chars
= max_chars
;
3954 error ("character constant too long");
3956 else if (num_chars
!= 1)
3957 warning ("multi-character character constant");
3959 /* If char type is signed, sign-extend the constant. */
3962 int num_bits
= num_chars
* width
;
3964 /* We already got an error; avoid invalid shift. */
3965 yylval
.ttype
= build_int_2 (0, 0);
3966 else if (TREE_UNSIGNED (char_type_node
)
3967 || ((result
>> (num_bits
- 1)) & 1) == 0)
3969 = build_int_2 (result
& ((unsigned HOST_WIDE_INT
) ~0
3970 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
3974 = build_int_2 (result
| ~((unsigned HOST_WIDE_INT
) ~0
3975 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
3978 TREE_TYPE (yylval
.ttype
) = char_type_node
;
3980 TREE_TYPE (yylval
.ttype
) = integer_type_node
;
3984 #ifdef MULTIBYTE_CHARS
3985 /* Set the initial shift state and convert the next sequence. */
3987 /* In all locales L'\0' is zero and mbtowc will return zero,
3990 || (num_chars
== 1 && token_buffer
[1] != '\0'))
3993 (void) mbtowc (NULL
, NULL
, 0);
3994 if (mbtowc (& wc
, token_buffer
+ 1, num_chars
) == num_chars
)
3997 warning ("Ignoring invalid multibyte character");
4000 yylval
.ttype
= build_int_2 (result
, 0);
4001 TREE_TYPE (yylval
.ttype
) = wchar_type_node
;
4014 p
= token_buffer
+ 1;
4016 while (c
!= '"' && c
>= 0)
4018 /* ignore_escape_flag is set for reading the filename in #line. */
4019 if (!ignore_escape_flag
&& c
== '\\')
4022 c
= readescape (&ignore
);
4026 && TYPE_PRECISION (char_type_node
) < HOST_BITS_PER_INT
4027 && c
>= ((unsigned) 1 << TYPE_PRECISION (char_type_node
)))
4028 warning ("escape sequence out of range for character");
4033 pedwarn ("ANSI C++ forbids newline in string constant");
4037 if (p
== token_buffer
+ maxtoken
)
4038 p
= extend_token_buffer (p
);
4044 error ("Unterminated string");
4050 /* We have read the entire constant.
4051 Construct a STRING_CST for the result. */
4055 /* If this is a L"..." wide-string, convert the multibyte string
4056 to a wide character string. */
4057 char *widep
= (char *) alloca ((p
- token_buffer
) * WCHAR_BYTES
);
4060 #ifdef MULTIBYTE_CHARS
4061 len
= mbstowcs ((wchar_t *) widep
, token_buffer
+ 1, p
- token_buffer
);
4062 if (len
< 0 || len
>= (p
- token_buffer
))
4064 warning ("Ignoring invalid multibyte string");
4067 bzero (widep
+ (len
* WCHAR_BYTES
), WCHAR_BYTES
);
4072 wp
= widep
+ (BYTES_BIG_ENDIAN
? WCHAR_BYTES
- 1 : 0);
4073 bzero (widep
, (p
- token_buffer
) * WCHAR_BYTES
);
4074 for (cp
= token_buffer
+ 1; cp
< p
; cp
++)
4075 *wp
= *cp
, wp
+= WCHAR_BYTES
;
4076 len
= p
- token_buffer
- 1;
4079 if (processing_template_decl
)
4080 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4081 yylval
.ttype
= build_string ((len
+ 1) * WCHAR_BYTES
, widep
);
4082 if (processing_template_decl
)
4084 TREE_TYPE (yylval
.ttype
) = wchar_array_type_node
;
4088 if (processing_template_decl
)
4089 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4090 yylval
.ttype
= build_string (p
- token_buffer
, token_buffer
+ 1);
4091 if (processing_template_decl
)
4093 TREE_TYPE (yylval
.ttype
) = char_array_type_node
;
4099 value
= STRING
; break;
4122 yylval
.code
= PLUS_EXPR
; break;
4124 yylval
.code
= MINUS_EXPR
; break;
4126 yylval
.code
= BIT_AND_EXPR
; break;
4128 yylval
.code
= BIT_IOR_EXPR
; break;
4130 yylval
.code
= MULT_EXPR
; break;
4132 yylval
.code
= TRUNC_DIV_EXPR
; break;
4134 yylval
.code
= TRUNC_MOD_EXPR
; break;
4136 yylval
.code
= BIT_XOR_EXPR
; break;
4138 yylval
.code
= LSHIFT_EXPR
; break;
4140 yylval
.code
= RSHIFT_EXPR
; break;
4142 yylval
.code
= LT_EXPR
; break;
4144 yylval
.code
= GT_EXPR
; break;
4147 token_buffer
[1] = c1
= getch ();
4148 token_buffer
[2] = 0;
4155 value
= ARITHCOMPARE
; yylval
.code
= LE_EXPR
; goto done
;
4157 value
= ARITHCOMPARE
; yylval
.code
= GE_EXPR
; goto done
;
4159 value
= EQCOMPARE
; yylval
.code
= NE_EXPR
; goto done
;
4161 value
= EQCOMPARE
; yylval
.code
= EQ_EXPR
; goto done
;
4163 value
= ASSIGN
; goto done
;
4169 value
= PLUSPLUS
; goto done
;
4171 value
= MINUSMINUS
; goto done
;
4173 value
= ANDAND
; goto done
;
4175 value
= OROR
; goto done
;
4183 else if ((c
== '-') && (c1
== '>'))
4185 nextchar
= getch ();
4186 if (nextchar
== '*')
4189 value
= POINTSAT_STAR
;
4195 else if (c1
== '?' && (c
== '<' || c
== '>'))
4197 token_buffer
[3] = 0;
4200 yylval
.code
= (c
== '<' ? MIN_EXPR
: MAX_EXPR
);
4203 /* <?= or >?= expression. */
4204 token_buffer
[2] = c1
;
4213 pedwarn ("use of `operator %s' is not standard C++",
4218 else if (c
== '<' && c1
== '%')
4219 { value
= '{'; goto done
; }
4220 else if (c
== '<' && c1
== ':')
4221 { value
= '['; goto done
; }
4222 else if (c
== '%' && c1
== '>')
4223 { value
= '}'; goto done
; }
4224 else if (c
== '%' && c1
== ':')
4225 { value
= '#'; goto done
; }
4228 token_buffer
[1] = 0;
4238 token_buffer
[1] = ':';
4239 token_buffer
[2] = '\0';
4256 /* Don't make yyparse think this is eof. */
4261 /* try, weakly, to handle casts to pointers to functions. */
4262 nextchar
= skip_white_space (getch ());
4263 if (nextchar
== '*')
4265 int next_c
= skip_white_space (getch ());
4269 yylval
.ttype
= build1 (INDIRECT_REF
, 0, 0);
4270 value
= PAREN_STAR_PAREN
;
4278 else if (nextchar
== ')')
4281 yylval
.ttype
= NULL_TREE
;
4292 /* yylloc.last_line = lineno; */
4293 #ifdef GATHER_STATISTICS
4294 #ifdef REDUCE_LENGTH
4295 token_count
[value
] += 1;
4306 return !!is_reserved_word (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
4309 #ifdef GATHER_STATISTICS
4310 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4311 need to be brought into here, unless this were actually put into a header
4313 /* Statistics-gathering stuff. */
4334 extern int tree_node_counts
[];
4335 extern int tree_node_sizes
[];
4338 /* Place to save freed lang_decls which were allocated on the
4339 permanent_obstack. @@ Not currently used. */
4340 tree free_lang_decl_chain
;
4343 build_lang_decl (code
, name
, type
)
4344 enum tree_code code
;
4348 register tree t
= build_decl (code
, name
, type
);
4349 struct obstack
*obstack
= current_obstack
;
4350 register int i
= sizeof (struct lang_decl
) / sizeof (int);
4353 if (! TREE_PERMANENT (t
))
4354 obstack
= saveable_obstack
;
4356 /* Could be that saveable is permanent and current is not. */
4357 obstack
= &permanent_obstack
;
4359 if (free_lang_decl_chain
&& obstack
== &permanent_obstack
)
4361 pi
= (int *)free_lang_decl_chain
;
4362 free_lang_decl_chain
= TREE_CHAIN (free_lang_decl_chain
);
4365 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_decl
));
4370 DECL_LANG_SPECIFIC (t
) = (struct lang_decl
*) pi
;
4371 LANG_DECL_PERMANENT ((struct lang_decl
*) pi
)
4372 = obstack
== &permanent_obstack
;
4373 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl
*) pi
)
4374 == TREE_PERMANENT (t
), 234);
4375 DECL_MAIN_VARIANT (t
) = t
;
4376 if (current_lang_name
== lang_name_cplusplus
)
4377 DECL_LANGUAGE (t
) = lang_cplusplus
;
4378 else if (current_lang_name
== lang_name_c
)
4379 DECL_LANGUAGE (t
) = lang_c
;
4380 else my_friendly_abort (64);
4382 #if 0 /* not yet, should get fixed properly later */
4383 if (code
== TYPE_DECL
)
4386 id
= get_identifier (build_overload_name (type
, 1, 1));
4387 DECL_ASSEMBLER_NAME (t
) = id
;
4391 #ifdef GATHER_STATISTICS
4392 tree_node_counts
[(int)lang_decl
] += 1;
4393 tree_node_sizes
[(int)lang_decl
] += sizeof (struct lang_decl
);
4400 build_lang_field_decl (code
, name
, type
)
4401 enum tree_code code
;
4405 extern struct obstack
*current_obstack
, *saveable_obstack
;
4406 register tree t
= build_decl (code
, name
, type
);
4407 struct obstack
*obstack
= current_obstack
;
4408 register int i
= sizeof (struct lang_decl_flags
) / sizeof (int);
4410 #if 0 /* not yet, should get fixed properly later */
4412 if (code
== TYPE_DECL
)
4415 id
= get_identifier (build_overload_name (type
, 1, 1));
4416 DECL_ASSEMBLER_NAME (t
) = id
;
4420 if (! TREE_PERMANENT (t
))
4421 obstack
= saveable_obstack
;
4423 my_friendly_assert (obstack
== &permanent_obstack
, 235);
4425 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_decl_flags
));
4429 DECL_LANG_SPECIFIC (t
) = (struct lang_decl
*) pi
;
4434 copy_lang_decl (node
)
4440 if (! DECL_LANG_SPECIFIC (node
))
4443 if (TREE_CODE (node
) == FIELD_DECL
)
4444 size
= sizeof (struct lang_decl_flags
);
4446 size
= sizeof (struct lang_decl
);
4447 pi
= (int *)obstack_alloc (&permanent_obstack
, size
);
4448 bcopy ((char *)DECL_LANG_SPECIFIC (node
), (char *)pi
, size
);
4449 DECL_LANG_SPECIFIC (node
) = (struct lang_decl
*)pi
;
4453 make_lang_type (code
)
4454 enum tree_code code
;
4456 extern struct obstack
*current_obstack
, *saveable_obstack
;
4457 register tree t
= make_node (code
);
4458 struct obstack
*obstack
= current_obstack
;
4459 register int i
= sizeof (struct lang_type
) / sizeof (int);
4462 /* Set up some flags that give proper default behavior. */
4463 IS_AGGR_TYPE (t
) = 1;
4465 if (! TREE_PERMANENT (t
))
4466 obstack
= saveable_obstack
;
4468 my_friendly_assert (obstack
== &permanent_obstack
, 236);
4470 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_type
));
4474 TYPE_LANG_SPECIFIC (t
) = (struct lang_type
*) pi
;
4475 CLASSTYPE_AS_LIST (t
) = build_expr_list (NULL_TREE
, t
);
4476 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, interface_unknown
);
4477 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
4478 CLASSTYPE_VBASE_SIZE (t
) = integer_zero_node
;
4479 TYPE_BINFO (t
) = make_binfo (integer_zero_node
, t
, NULL_TREE
, NULL_TREE
,
4481 CLASSTYPE_BINFO_AS_LIST (t
) = build_tree_list (NULL_TREE
, TYPE_BINFO (t
));
4483 /* Make sure this is laid out, for ease of use later.
4484 In the presence of parse errors, the normal was of assuring
4485 this might not ever get executed, so we lay it out *immediately*. */
4486 build_pointer_type (t
);
4488 #ifdef GATHER_STATISTICS
4489 tree_node_counts
[(int)lang_type
] += 1;
4490 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
4497 dump_time_statistics ()
4499 register tree prev
= 0, decl
, next
;
4500 int this_time
= my_get_run_time ();
4501 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
))
4502 += this_time
- body_time
;
4504 fprintf (stderr
, "\n******\n");
4505 print_time ("header files (total)", header_time
);
4506 print_time ("main file (total)", this_time
- body_time
);
4507 fprintf (stderr
, "ratio = %g : 1\n",
4508 (double)header_time
/ (double)(this_time
- body_time
));
4509 fprintf (stderr
, "\n******\n");
4511 for (decl
= filename_times
; decl
; decl
= next
)
4513 next
= IDENTIFIER_GLOBAL_VALUE (decl
);
4514 IDENTIFIER_GLOBAL_VALUE (decl
) = prev
;
4518 for (decl
= prev
; decl
; decl
= IDENTIFIER_GLOBAL_VALUE (decl
))
4519 print_time (IDENTIFIER_POINTER (decl
),
4520 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl
)));
4524 compiler_error (s
, v
, v2
)
4526 HOST_WIDE_INT v
, v2
; /* @@also used as pointer */
4529 sprintf (buf
, s
, v
, v2
);
4530 error_with_file_and_line (input_filename
, lineno
, "%s (compiler error)", buf
);
4537 extern int end_of_file
;
4540 strcpy (buf
, string
);
4542 /* We can't print string and character constants well
4543 because the token_buffer contains the result of processing escapes. */
4545 strcat (buf
, input_redirected ()
4546 ? " at end of saved text"
4547 : " at end of input");
4548 else if (token_buffer
[0] == 0)
4549 strcat (buf
, " at null character");
4550 else if (token_buffer
[0] == '"')
4551 strcat (buf
, " before string constant");
4552 else if (token_buffer
[0] == '\'')
4553 strcat (buf
, " before character constant");
4554 else if (token_buffer
[0] < 040 || (unsigned char) token_buffer
[0] >= 0177)
4555 sprintf (buf
+ strlen (buf
), " before character 0%o",
4556 (unsigned char) token_buffer
[0]);
4558 strcat (buf
, " before `%s'");
4560 error (buf
, token_buffer
);
4564 handle_cp_pragma (pname
)
4569 if (! strcmp (pname
, "vtable"))
4571 extern tree pending_vtables
;
4573 /* More follows: it must be a string constant (class name). */
4574 token
= real_yylex ();
4575 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
4577 error ("invalid #pragma vtable");
4581 if (write_virtuals
!= 2)
4583 warning ("use `+e2' option to enable #pragma vtable");
4587 = perm_tree_cons (NULL_TREE
,
4588 get_identifier (TREE_STRING_POINTER (yylval
.ttype
)),
4590 token
= real_yylex ();
4591 if (token
!= END_OF_LINE
)
4592 warning ("trailing characters ignored");
4595 else if (! strcmp (pname
, "unit"))
4597 /* More follows: it must be a string constant (unit name). */
4598 token
= real_yylex ();
4599 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
4601 error ("invalid #pragma unit");
4604 token
= real_yylex ();
4605 if (token
!= END_OF_LINE
)
4606 warning ("trailing characters ignored");
4609 else if (! strcmp (pname
, "interface"))
4611 tree fileinfo
= IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename
));
4612 char *main_filename
= input_filename
;
4614 main_filename
= file_name_nondirectory (main_filename
);
4616 token
= real_yylex ();
4618 if (token
!= END_OF_LINE
)
4621 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
4623 error ("invalid `#pragma interface'");
4626 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
4627 token
= real_yylex ();
4630 if (token
!= END_OF_LINE
)
4631 warning ("garbage after `#pragma interface' ignored");
4633 #ifndef NO_LINKAGE_HEURISTICS
4636 if (impl_file_chain
== 0)
4638 /* If this is zero at this point, then we are
4639 auto-implementing. */
4640 if (main_input_filename
== 0)
4641 main_input_filename
= input_filename
;
4643 #ifdef AUTO_IMPLEMENT
4644 filename
= file_name_nondirectory (main_input_filename
);
4645 fi
= get_time_identifier (filename
);
4646 fi
= IDENTIFIER_CLASS_VALUE (fi
);
4647 TREE_INT_CST_LOW (fi
) = 0;
4648 TREE_INT_CST_HIGH (fi
) = 1;
4650 impl_file_chain
= (struct impl_files
*)permalloc (sizeof (struct impl_files
));
4651 impl_file_chain
->filename
= filename
;
4652 impl_file_chain
->next
= 0;
4656 interface_only
= interface_strcmp (main_filename
);
4657 interface_unknown
= 0;
4658 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
4659 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
4660 #endif /* NO_LINKAGE_HEURISTICS */
4664 else if (! strcmp (pname
, "implementation"))
4666 tree fileinfo
= IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename
));
4667 char *main_filename
= main_input_filename
? main_input_filename
: input_filename
;
4669 main_filename
= file_name_nondirectory (main_filename
);
4670 token
= real_yylex ();
4671 if (token
!= END_OF_LINE
)
4674 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
4676 error ("invalid `#pragma implementation'");
4679 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
4680 token
= real_yylex ();
4683 if (token
!= END_OF_LINE
)
4684 warning ("garbage after `#pragma implementation' ignored");
4686 #ifndef NO_LINKAGE_HEURISTICS
4687 if (write_virtuals
== 3)
4689 struct impl_files
*ifiles
= impl_file_chain
;
4692 if (! strcmp (ifiles
->filename
, main_filename
))
4694 ifiles
= ifiles
->next
;
4698 ifiles
= (struct impl_files
*) permalloc (sizeof (struct impl_files
));
4699 ifiles
->filename
= main_filename
;
4700 ifiles
->next
= impl_file_chain
;
4701 impl_file_chain
= ifiles
;
4704 else if ((main_input_filename
!= 0
4705 && ! strcmp (main_input_filename
, input_filename
))
4706 || ! strcmp (input_filename
, main_filename
))
4709 if (impl_file_chain
== 0)
4711 impl_file_chain
= (struct impl_files
*) permalloc (sizeof (struct impl_files
));
4712 impl_file_chain
->filename
= main_filename
;
4713 impl_file_chain
->next
= 0;
4717 error ("`#pragma implementation' can only appear at top-level");
4720 /* We make this non-zero so that we infer decl linkage
4721 in the impl file only for variables first declared
4722 in the interface file. */
4723 interface_unknown
= 1;
4725 /* We make this zero so that templates in the impl
4726 file will be emitted properly. */
4727 interface_unknown
= 0;
4729 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
4730 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
4731 #endif /* NO_LINKAGE_HEURISTICS */
4739 #ifdef HANDLE_SYSV_PRAGMA
4741 /* Handle a #pragma directive. INPUT is the current input stream,
4742 and C is a character to reread. Processes the entire input line
4743 and returns a character for the caller to reread: either \n or EOF. */
4745 /* This function has to be in this file, in order to get at
4749 handle_sysv_pragma (finput
, token
)
4761 handle_pragma_token ("ignored", yylval
.ttype
);
4764 handle_pragma_token ("(", NULL_TREE
);
4767 handle_pragma_token (")", NULL_TREE
);
4770 handle_pragma_token (",", NULL_TREE
);
4773 handle_pragma_token ("=", NULL_TREE
);
4776 handle_pragma_token ("(", NULL_TREE
);
4777 handle_pragma_token (")", NULL_TREE
);
4781 handle_pragma_token (NULL_PTR
, NULL_TREE
);
4784 token
= real_yylex ();
4787 #endif /* HANDLE_SYSV_PRAGMA */