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 ();
65 extern char *index ();
66 extern char *rindex ();
70 extern int errno
; /* needed for VAX. */
73 #define obstack_chunk_alloc xmalloc
74 #define obstack_chunk_free free
76 extern struct obstack permanent_obstack
;
77 extern struct obstack
*current_obstack
, *saveable_obstack
;
79 extern void yyprint
PROTO((FILE *, int, YYSTYPE
));
80 extern void set_float_handler
PROTO((jmp_buf));
81 extern void compiler_error
PROTO((char *, HOST_WIDE_INT
,
84 static tree get_time_identifier
PROTO((char *));
85 static int check_newline
PROTO((void));
86 static int skip_white_space
PROTO((int));
87 static int yynextch
PROTO((void));
88 static void finish_defarg
PROTO((void));
89 static int my_get_run_time
PROTO((void));
90 static int get_last_nonwhite_on_line
PROTO((void));
91 static int interface_strcmp
PROTO((char *));
92 static int readescape
PROTO((int *));
93 static char *extend_token_buffer
PROTO((char *));
94 static void consume_string
PROTO((struct obstack
*, int));
95 static void set_typedecl_interface_info
PROTO((tree
, tree
));
96 static void feed_defarg
PROTO((tree
, tree
));
97 static int set_vardecl_interface_info
PROTO((tree
, tree
));
98 static void store_pending_inline
PROTO((tree
, struct pending_inline
*));
99 static void reinit_parse_for_expr
PROTO((struct obstack
*));
101 /* Given a file name X, return the nondirectory portion.
102 Keep in mind that X can be computed more than once. */
104 file_name_nondirectory (x
)
107 char *tmp
= (char *) rindex (x
, '/');
109 return (char *) (tmp
+ 1);
114 /* This obstack is needed to hold text. It is not safe to use
115 TOKEN_BUFFER because `check_newline' calls `yylex'. */
116 struct obstack inline_text_obstack
;
117 char *inline_text_firstobj
;
121 /* Pending language change.
122 Positive is push count, negative is pop count. */
123 int pending_lang_change
= 0;
125 /* Wrap the current header file in extern "C". */
126 static int c_header_level
= 0;
128 extern int first_token
;
129 extern struct obstack token_obstack
;
131 /* ??? Don't really know where this goes yet. */
135 extern void put_back (/* int */);
136 extern int input_redirected ();
137 extern void feed_input (/* char *, int */);
140 /* Holds translations from TREE_CODEs to operator name strings,
141 i.e., opname_tab[PLUS_EXPR] == "+". */
145 extern int yychar
; /* the lookahead symbol */
146 extern YYSTYPE yylval
; /* the semantic value of the */
147 /* lookahead symbol */
150 YYLTYPE yylloc
; /* location data for the lookahead */
155 /* the declaration found for the last IDENTIFIER token read in.
156 yylex must look this up to detect typedefs, which get token type TYPENAME,
157 so it is left around in case the identifier is not a typedef but is
158 used in a context which makes it a reference to a variable. */
161 /* The elements of `ridpointers' are identifier nodes
162 for the reserved type names and storage classes.
163 It is indexed by a RID_... value. */
164 tree ridpointers
[(int) RID_MAX
];
166 /* We may keep statistics about how long which files took to compile. */
167 static int header_time
, body_time
;
168 static tree filename_times
;
169 static tree this_filename_time
;
171 /* Array for holding counts of the numbers of tokens seen. */
172 extern int *token_count
;
174 /* Return something to represent absolute declarators containing a *.
175 TARGET is the absolute declarator that the * contains.
176 CV_QUALIFIERS is a list of modifiers such as const or volatile
177 to apply to the pointer type, represented as identifiers.
179 We return an INDIRECT_REF whose "contents" are TARGET
180 and whose type is the modifier list. */
183 make_pointer_declarator (cv_qualifiers
, target
)
184 tree cv_qualifiers
, target
;
186 if (target
&& TREE_CODE (target
) == IDENTIFIER_NODE
187 && ANON_AGGRNAME_P (target
))
188 error ("type name expected before `*'");
189 target
= build_parse_node (INDIRECT_REF
, target
);
190 TREE_TYPE (target
) = cv_qualifiers
;
194 /* Return something to represent absolute declarators containing a &.
195 TARGET is the absolute declarator that the & contains.
196 CV_QUALIFIERS is a list of modifiers such as const or volatile
197 to apply to the reference type, represented as identifiers.
199 We return an ADDR_EXPR whose "contents" are TARGET
200 and whose type is the modifier list. */
203 make_reference_declarator (cv_qualifiers
, target
)
204 tree cv_qualifiers
, target
;
208 if (TREE_CODE (target
) == ADDR_EXPR
)
210 error ("cannot declare references to references");
213 if (TREE_CODE (target
) == INDIRECT_REF
)
215 error ("cannot declare pointers to references");
218 if (TREE_CODE (target
) == IDENTIFIER_NODE
&& ANON_AGGRNAME_P (target
))
219 error ("type name expected before `&'");
221 target
= build_parse_node (ADDR_EXPR
, target
);
222 TREE_TYPE (target
) = cv_qualifiers
;
227 make_call_declarator (target
, parms
, cv_qualifiers
, exception_specification
)
228 tree target
, parms
, cv_qualifiers
, exception_specification
;
230 target
= build_parse_node (CALL_EXPR
, target
, parms
, cv_qualifiers
);
231 TREE_TYPE (target
) = exception_specification
;
236 set_quals_and_spec (call_declarator
, cv_qualifiers
, exception_specification
)
237 tree call_declarator
, cv_qualifiers
, exception_specification
;
239 TREE_OPERAND (call_declarator
, 2) = cv_qualifiers
;
240 TREE_TYPE (call_declarator
) = exception_specification
;
243 /* Build names and nodes for overloaded operators. */
245 tree ansi_opname
[LAST_CPLUS_TREE_CODE
];
246 tree ansi_assopname
[LAST_CPLUS_TREE_CODE
];
249 operator_name_string (name
)
252 char *opname
= IDENTIFIER_POINTER (name
) + 2;
256 /* Works for builtin and user defined types. */
257 if (IDENTIFIER_GLOBAL_VALUE (name
)
258 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (name
)) == TYPE_DECL
)
259 return IDENTIFIER_POINTER (name
);
261 if (opname
[0] == 'a' && opname
[2] != '\0' && opname
[2] != '_')
265 opname_table
= ansi_assopname
;
270 opname_table
= ansi_opname
;
273 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
275 if (opname
[0] == IDENTIFIER_POINTER (opname_table
[i
])[2+assign
]
276 && opname
[1] == IDENTIFIER_POINTER (opname_table
[i
])[3+assign
])
280 if (i
== LAST_CPLUS_TREE_CODE
)
281 return "<invalid operator>";
284 return assignop_tab
[i
];
286 return opname_tab
[i
];
289 int interface_only
; /* whether or not current file is only for
290 interface definitions. */
291 int interface_unknown
; /* whether or not we know this class
292 to behave according to #pragma interface. */
294 /* lexical analyzer */
296 /* File used for outputting assembler code. */
297 extern FILE *asm_out_file
;
299 #ifndef WCHAR_TYPE_SIZE
301 #define WCHAR_TYPE_SIZE INT_TYPE_SIZE
303 #define WCHAR_TYPE_SIZE BITS_PER_WORD
307 /* Number of bytes in a wide character. */
308 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
310 static int maxtoken
; /* Current nominal length of token buffer. */
311 char *token_buffer
; /* Pointer to token buffer.
312 Actual allocated length is maxtoken + 2. */
317 /* Nonzero tells yylex to ignore \ in string constants. */
318 static int ignore_escape_flag
= 0;
321 get_time_identifier (name
)
324 tree time_identifier
;
325 int len
= strlen (name
);
326 char *buf
= (char *) alloca (len
+ 6);
327 strcpy (buf
, "file ");
328 bcopy (name
, buf
+5, len
);
330 time_identifier
= get_identifier (buf
);
331 if (IDENTIFIER_LOCAL_VALUE (time_identifier
) == NULL_TREE
)
333 push_obstacks_nochange ();
334 end_temporary_allocation ();
335 IDENTIFIER_LOCAL_VALUE (time_identifier
) = build_int_2 (0, 0);
336 IDENTIFIER_CLASS_VALUE (time_identifier
) = build_int_2 (0, 1);
337 IDENTIFIER_GLOBAL_VALUE (time_identifier
) = filename_times
;
338 filename_times
= time_identifier
;
341 return time_identifier
;
350 int old_quiet_flag
= quiet_flag
;
353 this_time
= get_run_time ();
354 quiet_flag
= old_quiet_flag
;
358 /* Table indexed by tree code giving a string containing a character
359 classifying the tree code. Possibilities are
360 t, d, s, c, r, <, 1 and 2. See cp/cp-tree.def for details. */
362 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
364 char *cplus_tree_code_type
[] = {
366 #include "cp-tree.def"
370 /* Table indexed by tree code giving number of expression
371 operands beyond the fixed part of the node structure.
372 Not used for types or decls. */
374 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
376 int cplus_tree_code_length
[] = {
378 #include "cp-tree.def"
382 /* Names of tree components.
383 Used for printing out the tree and error messages. */
384 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
386 char *cplus_tree_code_name
[] = {
388 #include "cp-tree.def"
392 /* toplev.c needs to call these. */
397 /* the beginning of the file is a new line; check for # */
398 /* With luck, we discover the real source file's name from that
399 and put it in input_filename. */
400 put_back (check_newline ());
401 if (flag_gnu_xref
) GNU_xref_begin (input_filename
);
402 init_repo (input_filename
);
404 /* See comments in toplev.c before the call to lang_init. */
405 if (flag_exceptions
== 2)
412 extern int errorcount
, sorrycount
;
413 if (flag_gnu_xref
) GNU_xref_end (errorcount
+sorrycount
);
423 init_filename_times ()
425 this_filename_time
= get_time_identifier ("<top level>");
426 if (flag_detailed_statistics
)
429 body_time
= my_get_run_time ();
430 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
)) = body_time
;
434 /* Change by Bryan Boreham, Kewill, Thu Jul 27 09:46:05 1989.
435 Stuck this hack in to get the files open correctly; this is called
436 in place of init_lex if we are an unexec'd binary. */
440 reinit_lang_specific ()
442 init_filename_times ();
443 reinit_search_statistics ();
450 extern int flag_no_gnu_keywords
;
451 extern int flag_operator_names
;
455 /* Initialize the lookahead machinery. */
458 /* Make identifier nodes long enough for the language-specific slots. */
459 set_identifier_size (sizeof (struct lang_identifier
));
460 decl_printable_name
= lang_printable_name
;
462 init_cplus_expand ();
465 = (char **) realloc (tree_code_type
,
466 sizeof (char *) * LAST_CPLUS_TREE_CODE
);
468 = (int *) realloc (tree_code_length
,
469 sizeof (int) * LAST_CPLUS_TREE_CODE
);
471 = (char **) realloc (tree_code_name
,
472 sizeof (char *) * LAST_CPLUS_TREE_CODE
);
473 bcopy ((char *)cplus_tree_code_type
,
474 (char *)(tree_code_type
+ (int) LAST_AND_UNUSED_TREE_CODE
),
475 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
476 bcopy ((char *)cplus_tree_code_length
,
477 (char *)(tree_code_length
+ (int) LAST_AND_UNUSED_TREE_CODE
),
478 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (int));
479 bcopy ((char *)cplus_tree_code_name
,
480 (char *)(tree_code_name
+ (int) LAST_AND_UNUSED_TREE_CODE
),
481 (LAST_CPLUS_TREE_CODE
- (int)LAST_AND_UNUSED_TREE_CODE
) * sizeof (char *));
483 opname_tab
= (char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
484 bzero ((char *)opname_tab
, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
485 assignop_tab
= (char **)oballoc ((int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
486 bzero ((char *)assignop_tab
, (int)LAST_CPLUS_TREE_CODE
* sizeof (char *));
488 ansi_opname
[0] = get_identifier ("<invalid operator>");
489 for (i
= 0; i
< (int) LAST_CPLUS_TREE_CODE
; i
++)
491 ansi_opname
[i
] = ansi_opname
[0];
492 ansi_assopname
[i
] = ansi_opname
[0];
495 ansi_opname
[(int) MULT_EXPR
] = get_identifier ("__ml");
496 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MULT_EXPR
]) = 1;
497 ansi_opname
[(int) INDIRECT_REF
] = ansi_opname
[(int) MULT_EXPR
];
498 ansi_assopname
[(int) MULT_EXPR
] = get_identifier ("__aml");
499 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MULT_EXPR
]) = 1;
500 ansi_assopname
[(int) INDIRECT_REF
] = ansi_assopname
[(int) MULT_EXPR
];
501 ansi_opname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__md");
502 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUNC_MOD_EXPR
]) = 1;
503 ansi_assopname
[(int) TRUNC_MOD_EXPR
] = get_identifier ("__amd");
504 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) TRUNC_MOD_EXPR
]) = 1;
505 ansi_opname
[(int) CEIL_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
506 ansi_opname
[(int) FLOOR_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
507 ansi_opname
[(int) ROUND_MOD_EXPR
] = ansi_opname
[(int) TRUNC_MOD_EXPR
];
508 ansi_opname
[(int) MINUS_EXPR
] = get_identifier ("__mi");
509 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MINUS_EXPR
]) = 1;
510 ansi_opname
[(int) NEGATE_EXPR
] = ansi_opname
[(int) MINUS_EXPR
];
511 ansi_assopname
[(int) MINUS_EXPR
] = get_identifier ("__ami");
512 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) MINUS_EXPR
]) = 1;
513 ansi_assopname
[(int) NEGATE_EXPR
] = ansi_assopname
[(int) MINUS_EXPR
];
514 ansi_opname
[(int) RSHIFT_EXPR
] = get_identifier ("__rs");
515 IDENTIFIER_OPNAME_P (ansi_opname
[(int) RSHIFT_EXPR
]) = 1;
516 ansi_assopname
[(int) RSHIFT_EXPR
] = get_identifier ("__ars");
517 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) RSHIFT_EXPR
]) = 1;
518 ansi_opname
[(int) NE_EXPR
] = get_identifier ("__ne");
519 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NE_EXPR
]) = 1;
520 ansi_opname
[(int) GT_EXPR
] = get_identifier ("__gt");
521 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GT_EXPR
]) = 1;
522 ansi_opname
[(int) GE_EXPR
] = get_identifier ("__ge");
523 IDENTIFIER_OPNAME_P (ansi_opname
[(int) GE_EXPR
]) = 1;
524 ansi_opname
[(int) BIT_IOR_EXPR
] = get_identifier ("__or");
525 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_IOR_EXPR
]) = 1;
526 ansi_assopname
[(int) BIT_IOR_EXPR
] = get_identifier ("__aor");
527 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_IOR_EXPR
]) = 1;
528 ansi_opname
[(int) TRUTH_ANDIF_EXPR
] = get_identifier ("__aa");
529 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ANDIF_EXPR
]) = 1;
530 ansi_opname
[(int) TRUTH_NOT_EXPR
] = get_identifier ("__nt");
531 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_NOT_EXPR
]) = 1;
532 ansi_opname
[(int) PREINCREMENT_EXPR
] = get_identifier ("__pp");
533 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREINCREMENT_EXPR
]) = 1;
534 ansi_opname
[(int) POSTINCREMENT_EXPR
] = ansi_opname
[(int) PREINCREMENT_EXPR
];
535 ansi_opname
[(int) MODIFY_EXPR
] = get_identifier ("__as");
536 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MODIFY_EXPR
]) = 1;
537 ansi_assopname
[(int) NOP_EXPR
] = ansi_opname
[(int) MODIFY_EXPR
];
538 ansi_opname
[(int) COMPOUND_EXPR
] = get_identifier ("__cm");
539 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPOUND_EXPR
]) = 1;
540 ansi_opname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__dv");
541 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EXACT_DIV_EXPR
]) = 1;
542 ansi_assopname
[(int) EXACT_DIV_EXPR
] = get_identifier ("__adv");
543 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) EXACT_DIV_EXPR
]) = 1;
544 ansi_opname
[(int) TRUNC_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
545 ansi_opname
[(int) CEIL_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
546 ansi_opname
[(int) FLOOR_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
547 ansi_opname
[(int) ROUND_DIV_EXPR
] = ansi_opname
[(int) EXACT_DIV_EXPR
];
548 ansi_opname
[(int) PLUS_EXPR
] = get_identifier ("__pl");
549 ansi_assopname
[(int) TRUNC_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
550 ansi_assopname
[(int) CEIL_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
551 ansi_assopname
[(int) FLOOR_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
552 ansi_assopname
[(int) ROUND_DIV_EXPR
] = ansi_assopname
[(int) EXACT_DIV_EXPR
];
553 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PLUS_EXPR
]) = 1;
554 ansi_assopname
[(int) PLUS_EXPR
] = get_identifier ("__apl");
555 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) PLUS_EXPR
]) = 1;
556 ansi_opname
[(int) CONVERT_EXPR
] = ansi_opname
[(int) PLUS_EXPR
];
557 ansi_assopname
[(int) CONVERT_EXPR
] = ansi_assopname
[(int) PLUS_EXPR
];
558 ansi_opname
[(int) LSHIFT_EXPR
] = get_identifier ("__ls");
559 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LSHIFT_EXPR
]) = 1;
560 ansi_assopname
[(int) LSHIFT_EXPR
] = get_identifier ("__als");
561 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) LSHIFT_EXPR
]) = 1;
562 ansi_opname
[(int) EQ_EXPR
] = get_identifier ("__eq");
563 IDENTIFIER_OPNAME_P (ansi_opname
[(int) EQ_EXPR
]) = 1;
564 ansi_opname
[(int) LT_EXPR
] = get_identifier ("__lt");
565 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LT_EXPR
]) = 1;
566 ansi_opname
[(int) LE_EXPR
] = get_identifier ("__le");
567 IDENTIFIER_OPNAME_P (ansi_opname
[(int) LE_EXPR
]) = 1;
568 ansi_opname
[(int) BIT_AND_EXPR
] = get_identifier ("__ad");
569 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_AND_EXPR
]) = 1;
570 ansi_assopname
[(int) BIT_AND_EXPR
] = get_identifier ("__aad");
571 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_AND_EXPR
]) = 1;
572 ansi_opname
[(int) ADDR_EXPR
] = ansi_opname
[(int) BIT_AND_EXPR
];
573 ansi_assopname
[(int) ADDR_EXPR
] = ansi_assopname
[(int) BIT_AND_EXPR
];
574 ansi_opname
[(int) BIT_XOR_EXPR
] = get_identifier ("__er");
575 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_XOR_EXPR
]) = 1;
576 ansi_assopname
[(int) BIT_XOR_EXPR
] = get_identifier ("__aer");
577 IDENTIFIER_OPNAME_P (ansi_assopname
[(int) BIT_XOR_EXPR
]) = 1;
578 ansi_opname
[(int) TRUTH_ORIF_EXPR
] = get_identifier ("__oo");
579 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TRUTH_ORIF_EXPR
]) = 1;
580 ansi_opname
[(int) BIT_NOT_EXPR
] = get_identifier ("__co");
581 IDENTIFIER_OPNAME_P (ansi_opname
[(int) BIT_NOT_EXPR
]) = 1;
582 ansi_opname
[(int) PREDECREMENT_EXPR
] = get_identifier ("__mm");
583 IDENTIFIER_OPNAME_P (ansi_opname
[(int) PREDECREMENT_EXPR
]) = 1;
584 ansi_opname
[(int) POSTDECREMENT_EXPR
] = ansi_opname
[(int) PREDECREMENT_EXPR
];
585 ansi_opname
[(int) COMPONENT_REF
] = get_identifier ("__rf");
586 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COMPONENT_REF
]) = 1;
587 ansi_opname
[(int) MEMBER_REF
] = get_identifier ("__rm");
588 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MEMBER_REF
]) = 1;
589 ansi_opname
[(int) CALL_EXPR
] = get_identifier ("__cl");
590 IDENTIFIER_OPNAME_P (ansi_opname
[(int) CALL_EXPR
]) = 1;
591 ansi_opname
[(int) ARRAY_REF
] = get_identifier ("__vc");
592 IDENTIFIER_OPNAME_P (ansi_opname
[(int) ARRAY_REF
]) = 1;
593 ansi_opname
[(int) NEW_EXPR
] = get_identifier ("__nw");
594 IDENTIFIER_OPNAME_P (ansi_opname
[(int) NEW_EXPR
]) = 1;
595 ansi_opname
[(int) DELETE_EXPR
] = get_identifier ("__dl");
596 IDENTIFIER_OPNAME_P (ansi_opname
[(int) DELETE_EXPR
]) = 1;
597 ansi_opname
[(int) VEC_NEW_EXPR
] = get_identifier ("__vn");
598 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_NEW_EXPR
]) = 1;
599 ansi_opname
[(int) VEC_DELETE_EXPR
] = get_identifier ("__vd");
600 IDENTIFIER_OPNAME_P (ansi_opname
[(int) VEC_DELETE_EXPR
]) = 1;
601 ansi_opname
[(int) TYPE_EXPR
] = get_identifier ("__op");
602 IDENTIFIER_OPNAME_P (ansi_opname
[(int) TYPE_EXPR
]) = 1;
604 /* This is not true: these operators are not defined in ANSI,
605 but we need them anyway. */
606 ansi_opname
[(int) MIN_EXPR
] = get_identifier ("__mn");
607 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MIN_EXPR
]) = 1;
608 ansi_opname
[(int) MAX_EXPR
] = get_identifier ("__mx");
609 IDENTIFIER_OPNAME_P (ansi_opname
[(int) MAX_EXPR
]) = 1;
610 ansi_opname
[(int) COND_EXPR
] = get_identifier ("__cn");
611 IDENTIFIER_OPNAME_P (ansi_opname
[(int) COND_EXPR
]) = 1;
612 ansi_opname
[(int) METHOD_CALL_EXPR
] = get_identifier ("__wr");
613 IDENTIFIER_OPNAME_P (ansi_opname
[(int) METHOD_CALL_EXPR
]) = 1;
617 gcc_obstack_init (&inline_text_obstack
);
618 inline_text_firstobj
= (char *) obstack_alloc (&inline_text_obstack
, 0);
620 /* Start it at 0, because check_newline is called at the very beginning
621 and will increment it to 1. */
623 input_filename
= "<internal>";
624 current_function_decl
= NULL
;
627 token_buffer
= (char *) xmalloc (maxtoken
+ 2);
629 ridpointers
[(int) RID_INT
] = get_identifier ("int");
630 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_INT
],
631 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]));
632 ridpointers
[(int) RID_BOOL
] = get_identifier ("bool");
633 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_BOOL
],
634 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_BOOL
]));
635 ridpointers
[(int) RID_CHAR
] = get_identifier ("char");
636 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_CHAR
],
637 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]));
638 ridpointers
[(int) RID_VOID
] = get_identifier ("void");
639 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VOID
],
640 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOID
]));
641 ridpointers
[(int) RID_FLOAT
] = get_identifier ("float");
642 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_FLOAT
],
643 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_FLOAT
]));
644 ridpointers
[(int) RID_DOUBLE
] = get_identifier ("double");
645 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_DOUBLE
],
646 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_DOUBLE
]));
647 ridpointers
[(int) RID_SHORT
] = get_identifier ("short");
648 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_SHORT
],
649 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_SHORT
]));
650 ridpointers
[(int) RID_LONG
] = get_identifier ("long");
651 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_LONG
],
652 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]));
653 ridpointers
[(int) RID_UNSIGNED
] = get_identifier ("unsigned");
654 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_UNSIGNED
],
655 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_UNSIGNED
]));
656 ridpointers
[(int) RID_SIGNED
] = get_identifier ("signed");
657 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_SIGNED
],
658 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_SIGNED
]));
659 ridpointers
[(int) RID_INLINE
] = get_identifier ("inline");
660 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_INLINE
],
661 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INLINE
]));
662 ridpointers
[(int) RID_CONST
] = get_identifier ("const");
663 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_CONST
],
664 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CONST
]));
665 ridpointers
[(int) RID_VOLATILE
] = get_identifier ("volatile");
666 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VOLATILE
],
667 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOLATILE
]));
668 ridpointers
[(int) RID_AUTO
] = get_identifier ("auto");
669 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_AUTO
],
670 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_AUTO
]));
671 ridpointers
[(int) RID_STATIC
] = get_identifier ("static");
672 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_STATIC
],
673 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]));
674 ridpointers
[(int) RID_EXTERN
] = get_identifier ("extern");
675 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_EXTERN
],
676 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXTERN
]));
677 ridpointers
[(int) RID_TYPEDEF
] = get_identifier ("typedef");
678 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_TYPEDEF
],
679 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_TYPEDEF
]));
680 ridpointers
[(int) RID_REGISTER
] = get_identifier ("register");
681 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_REGISTER
],
682 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_REGISTER
]));
683 ridpointers
[(int) RID_COMPLEX
] = get_identifier ("__complex");
684 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_COMPLEX
],
685 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_COMPLEX
]));
687 /* C++ extensions. These are probably not correctly named. */
688 ridpointers
[(int) RID_WCHAR
] = get_identifier ("__wchar_t");
689 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_WCHAR
],
690 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_WCHAR
]));
691 class_type_node
= build_int_2 (class_type
, 0);
692 TREE_TYPE (class_type_node
) = class_type_node
;
693 ridpointers
[(int) RID_CLASS
] = class_type_node
;
695 record_type_node
= build_int_2 (record_type
, 0);
696 TREE_TYPE (record_type_node
) = record_type_node
;
697 ridpointers
[(int) RID_RECORD
] = record_type_node
;
699 union_type_node
= build_int_2 (union_type
, 0);
700 TREE_TYPE (union_type_node
) = union_type_node
;
701 ridpointers
[(int) RID_UNION
] = union_type_node
;
703 enum_type_node
= build_int_2 (enum_type
, 0);
704 TREE_TYPE (enum_type_node
) = enum_type_node
;
705 ridpointers
[(int) RID_ENUM
] = enum_type_node
;
707 ridpointers
[(int) RID_VIRTUAL
] = get_identifier ("virtual");
708 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_VIRTUAL
],
709 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]));
710 ridpointers
[(int) RID_EXPLICIT
] = get_identifier ("explicit");
711 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_EXPLICIT
],
712 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXPLICIT
]));
713 ridpointers
[(int) RID_FRIEND
] = get_identifier ("friend");
714 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_FRIEND
],
715 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_FRIEND
]));
717 ridpointers
[(int) RID_PUBLIC
] = get_identifier ("public");
718 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PUBLIC
],
719 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PUBLIC
]));
720 ridpointers
[(int) RID_PRIVATE
] = get_identifier ("private");
721 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PRIVATE
],
722 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PRIVATE
]));
723 ridpointers
[(int) RID_PROTECTED
] = get_identifier ("protected");
724 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_PROTECTED
],
725 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_PROTECTED
]));
726 ridpointers
[(int) RID_TEMPLATE
] = get_identifier ("template");
727 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_TEMPLATE
],
728 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_TEMPLATE
]));
729 /* This is for ANSI C++. */
730 ridpointers
[(int) RID_MUTABLE
] = get_identifier ("mutable");
731 SET_IDENTIFIER_AS_LIST (ridpointers
[(int) RID_MUTABLE
],
732 build_tree_list (NULL_TREE
, ridpointers
[(int) RID_MUTABLE
]));
734 /* Signature handling extensions. */
735 signature_type_node
= build_int_2 (signature_type
, 0);
736 TREE_TYPE (signature_type_node
) = signature_type_node
;
737 ridpointers
[(int) RID_SIGNATURE
] = signature_type_node
;
739 null_node
= build_int_2 (0, 0);
740 ridpointers
[RID_NULL
] = null_node
;
742 opname_tab
[(int) COMPONENT_REF
] = "->";
743 opname_tab
[(int) MEMBER_REF
] = "->*";
744 opname_tab
[(int) METHOD_CALL_EXPR
] = "->()";
745 opname_tab
[(int) INDIRECT_REF
] = "*";
746 opname_tab
[(int) ARRAY_REF
] = "[]";
747 opname_tab
[(int) MODIFY_EXPR
] = "=";
748 opname_tab
[(int) NEW_EXPR
] = "new";
749 opname_tab
[(int) DELETE_EXPR
] = "delete";
750 opname_tab
[(int) VEC_NEW_EXPR
] = "new []";
751 opname_tab
[(int) VEC_DELETE_EXPR
] = "delete []";
752 opname_tab
[(int) COND_EXPR
] = "?:";
753 opname_tab
[(int) CALL_EXPR
] = "()";
754 opname_tab
[(int) PLUS_EXPR
] = "+";
755 opname_tab
[(int) MINUS_EXPR
] = "-";
756 opname_tab
[(int) MULT_EXPR
] = "*";
757 opname_tab
[(int) TRUNC_DIV_EXPR
] = "/";
758 opname_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /)";
759 opname_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /)";
760 opname_tab
[(int) ROUND_DIV_EXPR
] = "(round /)";
761 opname_tab
[(int) TRUNC_MOD_EXPR
] = "%";
762 opname_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %)";
763 opname_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %)";
764 opname_tab
[(int) ROUND_MOD_EXPR
] = "(round %)";
765 opname_tab
[(int) NEGATE_EXPR
] = "-";
766 opname_tab
[(int) MIN_EXPR
] = "<?";
767 opname_tab
[(int) MAX_EXPR
] = ">?";
768 opname_tab
[(int) ABS_EXPR
] = "abs";
769 opname_tab
[(int) FFS_EXPR
] = "ffs";
770 opname_tab
[(int) LSHIFT_EXPR
] = "<<";
771 opname_tab
[(int) RSHIFT_EXPR
] = ">>";
772 opname_tab
[(int) BIT_IOR_EXPR
] = "|";
773 opname_tab
[(int) BIT_XOR_EXPR
] = "^";
774 opname_tab
[(int) BIT_AND_EXPR
] = "&";
775 opname_tab
[(int) BIT_ANDTC_EXPR
] = "&~";
776 opname_tab
[(int) BIT_NOT_EXPR
] = "~";
777 opname_tab
[(int) TRUTH_ANDIF_EXPR
] = "&&";
778 opname_tab
[(int) TRUTH_ORIF_EXPR
] = "||";
779 opname_tab
[(int) TRUTH_AND_EXPR
] = "strict &&";
780 opname_tab
[(int) TRUTH_OR_EXPR
] = "strict ||";
781 opname_tab
[(int) TRUTH_NOT_EXPR
] = "!";
782 opname_tab
[(int) LT_EXPR
] = "<";
783 opname_tab
[(int) LE_EXPR
] = "<=";
784 opname_tab
[(int) GT_EXPR
] = ">";
785 opname_tab
[(int) GE_EXPR
] = ">=";
786 opname_tab
[(int) EQ_EXPR
] = "==";
787 opname_tab
[(int) NE_EXPR
] = "!=";
788 opname_tab
[(int) IN_EXPR
] = "in";
789 opname_tab
[(int) RANGE_EXPR
] = "...";
790 opname_tab
[(int) CONVERT_EXPR
] = "+";
791 opname_tab
[(int) ADDR_EXPR
] = "&";
792 opname_tab
[(int) PREDECREMENT_EXPR
] = "--";
793 opname_tab
[(int) PREINCREMENT_EXPR
] = "++";
794 opname_tab
[(int) POSTDECREMENT_EXPR
] = "--";
795 opname_tab
[(int) POSTINCREMENT_EXPR
] = "++";
796 opname_tab
[(int) COMPOUND_EXPR
] = ",";
798 assignop_tab
[(int) NOP_EXPR
] = "=";
799 assignop_tab
[(int) PLUS_EXPR
] = "+=";
800 assignop_tab
[(int) CONVERT_EXPR
] = "+=";
801 assignop_tab
[(int) MINUS_EXPR
] = "-=";
802 assignop_tab
[(int) NEGATE_EXPR
] = "-=";
803 assignop_tab
[(int) MULT_EXPR
] = "*=";
804 assignop_tab
[(int) INDIRECT_REF
] = "*=";
805 assignop_tab
[(int) TRUNC_DIV_EXPR
] = "/=";
806 assignop_tab
[(int) EXACT_DIV_EXPR
] = "(exact /=)";
807 assignop_tab
[(int) CEIL_DIV_EXPR
] = "(ceiling /=)";
808 assignop_tab
[(int) FLOOR_DIV_EXPR
] = "(floor /=)";
809 assignop_tab
[(int) ROUND_DIV_EXPR
] = "(round /=)";
810 assignop_tab
[(int) TRUNC_MOD_EXPR
] = "%=";
811 assignop_tab
[(int) CEIL_MOD_EXPR
] = "(ceiling %=)";
812 assignop_tab
[(int) FLOOR_MOD_EXPR
] = "(floor %=)";
813 assignop_tab
[(int) ROUND_MOD_EXPR
] = "(round %=)";
814 assignop_tab
[(int) MIN_EXPR
] = "<?=";
815 assignop_tab
[(int) MAX_EXPR
] = ">?=";
816 assignop_tab
[(int) LSHIFT_EXPR
] = "<<=";
817 assignop_tab
[(int) RSHIFT_EXPR
] = ">>=";
818 assignop_tab
[(int) BIT_IOR_EXPR
] = "|=";
819 assignop_tab
[(int) BIT_XOR_EXPR
] = "^=";
820 assignop_tab
[(int) BIT_AND_EXPR
] = "&=";
821 assignop_tab
[(int) ADDR_EXPR
] = "&=";
823 init_filename_times ();
825 /* Some options inhibit certain reserved words.
826 Clear those words out of the hash table so they won't be recognized. */
827 #define UNSET_RESERVED_WORD(STRING) \
828 do { struct resword *s = is_reserved_word (STRING, sizeof (STRING) - 1); \
829 if (s) s->name = ""; } while (0)
832 /* let's parse things, and if they use it, then give them an error. */
833 if (!flag_exceptions
)
835 UNSET_RESERVED_WORD ("throw");
836 UNSET_RESERVED_WORD ("try");
837 UNSET_RESERVED_WORD ("catch");
841 if (!flag_rtti
|| flag_no_gnu_keywords
)
843 UNSET_RESERVED_WORD ("classof");
844 UNSET_RESERVED_WORD ("headof");
846 if (! flag_handle_signatures
|| flag_no_gnu_keywords
)
848 /* Easiest way to not recognize signature
849 handling extensions... */
850 UNSET_RESERVED_WORD ("signature");
851 UNSET_RESERVED_WORD ("sigof");
853 if (flag_no_asm
|| flag_no_gnu_keywords
)
854 UNSET_RESERVED_WORD ("typeof");
855 if (! flag_operator_names
)
857 /* These are new ANSI keywords that may break code. */
858 UNSET_RESERVED_WORD ("and");
859 UNSET_RESERVED_WORD ("and_eq");
860 UNSET_RESERVED_WORD ("bitand");
861 UNSET_RESERVED_WORD ("bitor");
862 UNSET_RESERVED_WORD ("compl");
863 UNSET_RESERVED_WORD ("not");
864 UNSET_RESERVED_WORD ("not_eq");
865 UNSET_RESERVED_WORD ("or");
866 UNSET_RESERVED_WORD ("or_eq");
867 UNSET_RESERVED_WORD ("xor");
868 UNSET_RESERVED_WORD ("xor_eq");
871 token_count
= init_parse ();
872 interface_unknown
= 1;
876 reinit_parse_for_function ()
878 current_base_init_list
= NULL_TREE
;
879 current_member_init_list
= NULL_TREE
;
886 yyprint (file
, yychar
, yylval
)
898 case IDENTIFIER_DEFN
:
901 case TYPENAME_ELLIPSIS
:
903 case PRE_PARSED_CLASS_DECL
:
905 if (TREE_CODE (t
) == TYPE_DECL
)
907 fprintf (file
, " `%s'", DECL_NAME (t
));
910 my_friendly_assert (TREE_CODE (t
) == IDENTIFIER_NODE
, 224);
911 if (IDENTIFIER_POINTER (t
))
912 fprintf (file
, " `%s'", IDENTIFIER_POINTER (t
));
915 if (yylval
.ttype
== class_type_node
)
916 fprintf (file
, " `class'");
917 else if (yylval
.ttype
== record_type_node
)
918 fprintf (file
, " `struct'");
919 else if (yylval
.ttype
== union_type_node
)
920 fprintf (file
, " `union'");
921 else if (yylval
.ttype
== enum_type_node
)
922 fprintf (file
, " `enum'");
923 else if (yylval
.ttype
== signature_type_node
)
924 fprintf (file
, " `signature'");
926 my_friendly_abort (80);
931 #if defined(GATHER_STATISTICS) && defined(REDUCE_LENGTH)
932 static int *reduce_count
;
938 #define REDUCE_LENGTH (sizeof (yyr2) / sizeof (yyr2[0]))
939 #define TOKEN_LENGTH (256 + sizeof (yytname) / sizeof (yytname[0]))
945 #ifdef GATHER_STATISTICS
947 reduce_count
= (int *)malloc (sizeof (int) * (REDUCE_LENGTH
+ 1));
948 bzero (reduce_count
, sizeof (int) * (REDUCE_LENGTH
+ 1));
950 token_count
= (int *)malloc (sizeof (int) * (TOKEN_LENGTH
+ 1));
951 bzero (token_count
, sizeof (int) * (TOKEN_LENGTH
+ 1));
958 #ifdef GATHER_STATISTICS
964 reduce_count
[yyn
] += 1;
971 return reduce_count
[*q
] - reduce_count
[*p
];
978 return token_count
[*q
] - token_count
[*p
];
984 print_parse_statistics ()
986 #ifdef GATHER_STATISTICS
990 int maxlen
= REDUCE_LENGTH
;
993 if (reduce_count
[-1] == 0)
996 if (TOKEN_LENGTH
> REDUCE_LENGTH
)
997 maxlen
= TOKEN_LENGTH
;
998 sorted
= (unsigned *) alloca (sizeof (int) * maxlen
);
1000 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1002 qsort (sorted
, TOKEN_LENGTH
, sizeof (int), token_cmp
);
1003 for (i
= 0; i
< TOKEN_LENGTH
; i
++)
1005 int idx
= sorted
[i
];
1006 if (token_count
[idx
] == 0)
1008 if (token_count
[idx
] < token_count
[-1])
1010 fprintf (stderr
, "token %d, `%s', count = %d\n",
1011 idx
, yytname
[YYTRANSLATE (idx
)], token_count
[idx
]);
1013 fprintf (stderr
, "\n");
1014 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1016 qsort (sorted
, REDUCE_LENGTH
, sizeof (int), reduce_cmp
);
1017 for (i
= 0; i
< REDUCE_LENGTH
; i
++)
1019 int idx
= sorted
[i
];
1020 if (reduce_count
[idx
] == 0)
1022 if (reduce_count
[idx
] < reduce_count
[-1])
1024 fprintf (stderr
, "rule %d, line %d, count = %d\n",
1025 idx
, yyrline
[idx
], reduce_count
[idx
]);
1027 fprintf (stderr
, "\n");
1033 /* Sets the value of the 'yydebug' variable to VALUE.
1034 This is a function so we don't have to have YYDEBUG defined
1035 in order to build the compiler. */
1045 warning ("YYDEBUG not defined.");
1050 /* Functions and data structures for #pragma interface.
1052 `#pragma implementation' means that the main file being compiled
1053 is considered to implement (provide) the classes that appear in
1054 its main body. I.e., if this is file "foo.cc", and class `bar'
1055 is defined in "foo.cc", then we say that "foo.cc implements bar".
1057 All main input files "implement" themselves automagically.
1059 `#pragma interface' means that unless this file (of the form "foo.h"
1060 is not presently being included by file "foo.cc", the
1061 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
1062 of the vtables nor any of the inline functions defined in foo.h
1063 will ever be output.
1065 There are cases when we want to link files such as "defs.h" and
1066 "main.cc". In this case, we give "defs.h" a `#pragma interface',
1067 and "main.cc" has `#pragma implementation "defs.h"'. */
1072 struct impl_files
*next
;
1075 static struct impl_files
*impl_file_chain
;
1077 /* Helper function to load global variables with interface
1081 extract_interface_info ()
1085 if (flag_alt_external_templates
)
1087 struct tinst_level
*til
= tinst_for_decl ();
1090 fileinfo
= get_time_identifier (til
->file
);
1093 fileinfo
= get_time_identifier (input_filename
);
1094 fileinfo
= IDENTIFIER_CLASS_VALUE (fileinfo
);
1095 interface_only
= TREE_INT_CST_LOW (fileinfo
);
1096 interface_unknown
= TREE_INT_CST_HIGH (fileinfo
);
1099 /* Return nonzero if S is not considered part of an
1100 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
1103 interface_strcmp (s
)
1106 /* Set the interface/implementation bits for this scope. */
1107 struct impl_files
*ifiles
;
1110 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
1112 char *t1
= ifiles
->filename
;
1115 if (*s1
!= *t1
|| *s1
== 0)
1118 while (*s1
== *t1
&& *s1
!= 0)
1125 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
1126 if (index (s1
, '.') || index (t1
, '.'))
1129 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
1141 set_typedecl_interface_info (prev
, vars
)
1144 tree id
= get_time_identifier (DECL_SOURCE_FILE (vars
));
1145 tree fileinfo
= IDENTIFIER_CLASS_VALUE (id
);
1146 tree type
= TREE_TYPE (vars
);
1148 CLASSTYPE_INTERFACE_ONLY (type
) = TREE_INT_CST_LOW (fileinfo
)
1149 = interface_strcmp (file_name_nondirectory (DECL_SOURCE_FILE (vars
)));
1153 set_vardecl_interface_info (prev
, vars
)
1156 tree type
= DECL_CONTEXT (vars
);
1158 if (CLASSTYPE_INTERFACE_KNOWN (type
))
1160 if (CLASSTYPE_INTERFACE_ONLY (type
))
1161 set_typedecl_interface_info (prev
, TYPE_MAIN_DECL (type
));
1163 CLASSTYPE_VTABLE_NEEDS_WRITING (type
) = 1;
1164 DECL_EXTERNAL (vars
) = CLASSTYPE_INTERFACE_ONLY (type
);
1165 TREE_PUBLIC (vars
) = 1;
1171 /* Called from the top level: if there are any pending inlines to
1172 do, set up to process them now. This function sets up the first function
1173 to be parsed; after it has been, the rule for fndef in parse.y will
1174 call process_next_inline to start working on the next one. */
1177 do_pending_inlines ()
1179 struct pending_inline
*t
;
1182 /* Oops, we're still dealing with the last batch. */
1183 if (yychar
== PRE_PARSED_FUNCTION_DECL
)
1186 /* Reverse the pending inline functions, since
1187 they were cons'd instead of appended. */
1189 struct pending_inline
*prev
= 0, *tail
;
1190 t
= pending_inlines
;
1191 pending_inlines
= 0;
1206 /* Now start processing the first inline function. */
1207 context
= hack_decl_function_context (t
->fndecl
);
1209 push_cp_function_context (context
);
1210 if (is_member_template (t
->fndecl
))
1211 begin_member_template_processing (t
->fndecl
);
1214 feed_input (t
->buf
, t
->len
);
1217 if (input_filename
!= t
->filename
)
1219 input_filename
= t
->filename
;
1220 /* Get interface/implementation back in sync. */
1221 extract_interface_info ();
1224 input_filename
= t
->filename
;
1225 interface_unknown
= t
->interface
== 1;
1226 interface_only
= t
->interface
== 0;
1228 yychar
= PRE_PARSED_FUNCTION_DECL
;
1230 /* Pass back a handle on the rest of the inline functions, so that they
1231 can be processed later. */
1232 yylval
.ttype
= build_tree_list ((tree
) t
, t
->fndecl
);
1233 DECL_PENDING_INLINE_INFO (t
->fndecl
) = 0;
1236 static int nextchar
= -1;
1238 /* Called from the fndecl rule in the parser when the function just parsed
1239 was declared using a PRE_PARSED_FUNCTION_DECL (i.e. came from
1240 do_pending_inlines). */
1243 process_next_inline (t
)
1247 struct pending_inline
*i
= (struct pending_inline
*) TREE_PURPOSE (t
);
1248 context
= hack_decl_function_context (i
->fndecl
);
1249 if (is_member_template (i
->fndecl
))
1250 end_member_template_processing ();
1252 pop_cp_function_context (context
);
1254 if (yychar
== YYEMPTY
)
1256 if (yychar
!= END_OF_SAVED_INPUT
)
1258 error ("parse error at end of saved function text");
1260 /* restore_pending_input will abort unless yychar is either
1261 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1262 hosed, feed back YYEMPTY. We also need to discard nextchar,
1263 since that may have gotten set as well. */
1268 if (i
&& i
->fndecl
!= NULL_TREE
)
1270 context
= hack_decl_function_context (i
->fndecl
);
1272 push_cp_function_context (context
);
1273 if (is_member_template (i
->fndecl
))
1274 begin_member_template_processing (i
->fndecl
);
1275 feed_input (i
->buf
, i
->len
);
1277 input_filename
= i
->filename
;
1278 yychar
= PRE_PARSED_FUNCTION_DECL
;
1279 yylval
.ttype
= build_tree_list ((tree
) i
, i
->fndecl
);
1280 DECL_PENDING_INLINE_INFO (i
->fndecl
) = 0;
1284 interface_unknown
= i
->interface
== 1;
1285 interface_only
= i
->interface
== 0;
1288 extract_interface_info ();
1291 /* Since inline methods can refer to text which has not yet been seen,
1292 we store the text of the method in a structure which is placed in the
1293 DECL_PENDING_INLINE_INFO field of the FUNCTION_DECL.
1294 After parsing the body of the class definition, the FUNCTION_DECL's are
1295 scanned to see which ones have this field set. Those are then digested
1298 This function's FUNCTION_DECL will have a bit set in its common so
1299 that we know to watch out for it. */
1302 consume_string (this_obstack
, matching_char
)
1303 register struct obstack
*this_obstack
;
1307 int starting_lineno
= lineno
;
1313 int save_lineno
= lineno
;
1314 lineno
= starting_lineno
;
1315 if (matching_char
== '"')
1316 error ("end of file encountered inside string constant");
1318 error ("end of file encountered inside character constant");
1319 lineno
= save_lineno
;
1324 obstack_1grow (this_obstack
, c
);
1326 obstack_1grow (this_obstack
, c
);
1328 /* Make sure we continue the loop */
1335 pedwarn ("ANSI C++ forbids newline in string constant");
1338 obstack_1grow (this_obstack
, c
);
1340 while (c
!= matching_char
);
1343 static int nextyychar
= YYEMPTY
;
1344 static YYSTYPE nextyylval
;
1346 struct pending_input
{
1347 int nextchar
, yychar
, nextyychar
, eof
;
1348 YYSTYPE yylval
, nextyylval
;
1349 struct obstack token_obstack
;
1353 struct pending_input
*
1354 save_pending_input ()
1356 struct pending_input
*p
;
1357 p
= (struct pending_input
*) xmalloc (sizeof (struct pending_input
));
1358 p
->nextchar
= nextchar
;
1360 p
->nextyychar
= nextyychar
;
1362 p
->nextyylval
= nextyylval
;
1363 p
->eof
= end_of_file
;
1364 yychar
= nextyychar
= YYEMPTY
;
1366 p
->first_token
= first_token
;
1367 p
->token_obstack
= token_obstack
;
1370 gcc_obstack_init (&token_obstack
);
1376 restore_pending_input (p
)
1377 struct pending_input
*p
;
1379 my_friendly_assert (nextchar
== -1, 229);
1380 nextchar
= p
->nextchar
;
1381 my_friendly_assert (yychar
== YYEMPTY
|| yychar
== END_OF_SAVED_INPUT
, 230);
1383 my_friendly_assert (nextyychar
== YYEMPTY
, 231);
1384 nextyychar
= p
->nextyychar
;
1386 nextyylval
= p
->nextyylval
;
1387 first_token
= p
->first_token
;
1388 obstack_free (&token_obstack
, (char *) 0);
1389 token_obstack
= p
->token_obstack
;
1390 end_of_file
= p
->eof
;
1394 /* Return next non-whitespace input character, which may come
1395 from `finput', or from `nextchar'. */
1408 return skip_white_space (c
);
1411 /* Unget character CH from the input stream.
1412 If RESCAN is non-zero, then we want to `see' this
1413 character as the next input token. */
1416 yyungetc (ch
, rescan
)
1420 /* Unget a character from the input stream. */
1421 if (yychar
== YYEMPTY
|| rescan
== 0)
1424 put_back (nextchar
);
1429 my_friendly_assert (nextyychar
== YYEMPTY
, 232);
1430 nextyychar
= yychar
;
1431 nextyylval
= yylval
;
1437 clear_inline_text_obstack ()
1439 obstack_free (&inline_text_obstack
, inline_text_firstobj
);
1442 /* This function stores away the text for an inline function that should
1443 be processed later. It decides how much later, and may need to move
1444 the info between obstacks; therefore, the caller should not refer to
1445 the T parameter after calling this function. */
1448 store_pending_inline (decl
, t
)
1450 struct pending_inline
*t
;
1453 DECL_PENDING_INLINE_INFO (decl
) = t
;
1455 /* Because we use obstacks, we must process these in precise order. */
1456 t
->next
= pending_inlines
;
1457 pending_inlines
= t
;
1461 reinit_parse_for_method (yychar
, decl
)
1466 int starting_lineno
= lineno
;
1467 char *starting_filename
= input_filename
;
1469 reinit_parse_for_block (yychar
, &inline_text_obstack
);
1471 len
= obstack_object_size (&inline_text_obstack
);
1472 current_base_init_list
= NULL_TREE
;
1473 current_member_init_list
= NULL_TREE
;
1474 if (decl
== void_type_node
1475 || (current_class_type
&& TYPE_REDEFINED (current_class_type
)))
1477 /* Happens when we get two declarations of the same
1478 function in the same scope. */
1479 char *buf
= obstack_finish (&inline_text_obstack
);
1480 obstack_free (&inline_text_obstack
, buf
);
1485 struct pending_inline
*t
;
1486 char *buf
= obstack_finish (&inline_text_obstack
);
1488 t
= (struct pending_inline
*) obstack_alloc (&inline_text_obstack
,
1489 sizeof (struct pending_inline
));
1490 t
->lineno
= starting_lineno
;
1491 t
->filename
= starting_filename
;
1498 if (interface_unknown
&& processing_template_defn
&& flag_external_templates
&& ! DECL_IN_SYSTEM_HEADER (decl
))
1499 warn_if_unknown_interface (decl
);
1501 t
->interface
= (interface_unknown
? 1 : (interface_only
? 0 : 2));
1502 store_pending_inline (decl
, t
);
1506 /* Consume a block -- actually, a method beginning
1507 with `:' or `{' -- and save it away on the specified obstack. */
1510 reinit_parse_for_block (pyychar
, obstackp
)
1512 struct obstack
*obstackp
;
1516 int starting_lineno
= lineno
;
1517 char *starting_filename
= input_filename
;
1519 int look_for_semicolon
= 0;
1520 int look_for_lbrac
= 0;
1523 obstack_1grow (obstackp
, '{');
1524 else if (pyychar
== '=')
1525 look_for_semicolon
= 1;
1526 else if (pyychar
== ':')
1528 obstack_1grow (obstackp
, pyychar
);
1532 else if (pyychar
== RETURN
)
1534 obstack_grow (obstackp
, "return", 6);
1538 else if (pyychar
== TRY
)
1540 obstack_grow (obstackp
, "try", 3);
1546 yyerror ("parse error in method specification");
1547 obstack_1grow (obstackp
, '{');
1550 if (nextchar
!= EOF
)
1560 int this_lineno
= lineno
;
1562 c
= skip_white_space (c
);
1564 /* Don't lose our cool if there are lots of comments. */
1565 if (lineno
== this_lineno
+ 1)
1566 obstack_1grow (obstackp
, '\n');
1567 else if (lineno
== this_lineno
)
1569 else if (lineno
- this_lineno
< 10)
1572 for (i
= lineno
- this_lineno
; i
> 0; i
--)
1573 obstack_1grow (obstackp
, '\n');
1578 sprintf (buf
, "\n# %d \"", lineno
);
1580 obstack_grow (obstackp
, buf
, len
);
1582 len
= strlen (input_filename
);
1583 obstack_grow (obstackp
, input_filename
, len
);
1584 obstack_1grow (obstackp
, '\"');
1585 obstack_1grow (obstackp
, '\n');
1588 while (c
> ' ') /* ASCII dependent... */
1590 obstack_1grow (obstackp
, c
);
1599 if (blev
== 0 && !look_for_semicolon
)
1603 if (peekyylex () == CATCH
)
1606 obstack_grow (obstackp
, " catch ", 7);
1623 /* Don't act on the next character...e.g, doing an escaped
1628 error_with_file_and_line (starting_filename
,
1630 "end of file read inside definition");
1633 obstack_1grow (obstackp
, c
);
1636 consume_string (obstackp
, c
);
1638 consume_string (obstackp
, c
);
1643 error ("function body for constructor missing");
1644 obstack_1grow (obstackp
, '{');
1645 obstack_1grow (obstackp
, '}');
1649 else if (look_for_semicolon
&& blev
== 0)
1657 error_with_file_and_line (starting_filename
,
1659 "end of file read inside definition");
1664 obstack_1grow (obstackp
, c
);
1669 obstack_1grow (obstackp
, '\0');
1672 /* Consume a no-commas expression -- actually, a default argument -- and
1673 save it away on the specified obstack. */
1676 reinit_parse_for_expr (obstackp
)
1677 struct obstack
*obstackp
;
1680 int starting_lineno
= lineno
;
1681 char *starting_filename
= input_filename
;
1683 int look_for_semicolon
= 0;
1684 int look_for_lbrac
= 0;
1687 if (nextchar
!= EOF
)
1697 int this_lineno
= lineno
;
1699 c
= skip_white_space (c
);
1701 /* Don't lose our cool if there are lots of comments. */
1702 if (lineno
== this_lineno
+ 1)
1703 obstack_1grow (obstackp
, '\n');
1704 else if (lineno
== this_lineno
)
1706 else if (lineno
- this_lineno
< 10)
1709 for (i
= lineno
- this_lineno
; i
> 0; --i
)
1710 obstack_1grow (obstackp
, '\n');
1715 sprintf (buf
, "\n# %d \"", lineno
);
1717 obstack_grow (obstackp
, buf
, len
);
1719 len
= strlen (input_filename
);
1720 obstack_grow (obstackp
, input_filename
, len
);
1721 obstack_1grow (obstackp
, '\"');
1722 obstack_1grow (obstackp
, '\n');
1725 while (c
> ' ') /* ASCII dependent... */
1727 if (plev
<= 0 && (c
== ')' || c
== ','))
1732 obstack_1grow (obstackp
, c
);
1733 if (c
== '(' || c
== '[')
1735 else if (c
== ']' || c
== ')')
1739 /* Don't act on the next character...e.g, doing an escaped
1744 error_with_file_and_line (starting_filename
,
1746 "end of file read inside definition");
1749 obstack_1grow (obstackp
, c
);
1752 consume_string (obstackp
, c
);
1754 consume_string (obstackp
, c
);
1760 error_with_file_and_line (starting_filename
,
1762 "end of file read inside definition");
1767 obstack_1grow (obstackp
, c
);
1772 obstack_1grow (obstackp
, '\0');
1775 int do_snarf_defarg
;
1777 /* Decide whether the default argument we are about to see should be
1778 gobbled up as text for later parsing. */
1781 maybe_snarf_defarg ()
1783 if (current_class_type
&& TYPE_BEING_DEFINED (current_class_type
))
1784 do_snarf_defarg
= 1;
1787 /* When we see a default argument in a method declaration, we snarf it as
1788 text using snarf_defarg. When we get up to namespace scope, we then go
1789 through and parse all of them using do_pending_defargs. Since yacc
1790 parsers are not reentrant, we retain defargs state in these two
1791 variables so that subsequent calls to do_pending_defargs can resume
1792 where the previous call left off. */
1804 reinit_parse_for_expr (&inline_text_obstack
);
1805 len
= obstack_object_size (&inline_text_obstack
);
1806 buf
= obstack_finish (&inline_text_obstack
);
1808 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1809 arg
= make_node (DEFAULT_ARG
);
1810 DEFARG_LENGTH (arg
) = len
- 1;
1811 DEFARG_POINTER (arg
) = buf
;
1817 /* Called from grokfndecl to note a function decl with unparsed default
1818 arguments for later processing. Also called from grokdeclarator
1819 for function types with unparsed defargs; the call from grokfndecl
1820 will always come second, so we can overwrite the entry from the type. */
1823 add_defarg_fn (decl
)
1826 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1827 TREE_VALUE (defarg_fns
) = decl
;
1830 push_obstacks (&inline_text_obstack
, &inline_text_obstack
);
1831 defarg_fns
= tree_cons (current_class_type
, decl
, defarg_fns
);
1836 /* Helper for do_pending_defargs. Starts the parsing of a default arg. */
1842 tree d
= TREE_PURPOSE (p
);
1843 feed_input (DEFARG_POINTER (d
), DEFARG_LENGTH (d
));
1844 if (TREE_CODE (f
) == FUNCTION_DECL
)
1846 lineno
= DECL_SOURCE_LINE (f
);
1847 input_filename
= DECL_SOURCE_FILE (f
);
1849 yychar
= DEFARG_MARKER
;
1853 /* Helper for do_pending_defargs. Ends the parsing of a default arg. */
1858 if (yychar
== YYEMPTY
)
1860 if (yychar
!= END_OF_SAVED_INPUT
)
1862 error ("parse error at end of saved function text");
1864 /* restore_pending_input will abort unless yychar is either
1865 END_OF_SAVED_INPUT or YYEMPTY; since we already know we're
1866 hosed, feed back YYEMPTY. We also need to discard nextchar,
1867 since that may have gotten set as well. */
1874 /* Main function for deferred parsing of default arguments. Called from
1878 do_pending_defargs ()
1883 for (; defarg_fns
; defarg_fns
= TREE_CHAIN (defarg_fns
))
1885 tree defarg_fn
= TREE_VALUE (defarg_fns
);
1886 if (defarg_parm
== NULL_TREE
)
1888 push_nested_class (TREE_PURPOSE (defarg_fns
), 1);
1890 if (is_member_template (defarg_fn
))
1891 begin_member_template_processing (defarg_fn
);
1893 if (TREE_CODE (defarg_fn
) == FUNCTION_DECL
)
1897 for (p
= DECL_ARGUMENTS (defarg_fn
); p
; p
= TREE_CHAIN (p
))
1898 pushdecl (copy_node (p
));
1900 defarg_parm
= TYPE_ARG_TYPES (TREE_TYPE (defarg_fn
));
1903 defarg_parm
= TYPE_ARG_TYPES (defarg_fn
);
1906 defarg_parm
= TREE_CHAIN (defarg_parm
);
1908 for (; defarg_parm
; defarg_parm
= TREE_CHAIN (defarg_parm
))
1909 if (TREE_PURPOSE (defarg_parm
)
1910 && TREE_CODE (TREE_PURPOSE (defarg_parm
)) == DEFAULT_ARG
)
1912 feed_defarg (defarg_fn
, defarg_parm
);
1914 /* Return to the parser, which will process this defarg
1915 and call us again. */
1919 if (is_member_template (defarg_fn
))
1920 end_member_template_processing ();
1922 pop_nested_class (1);
1926 /* Build a default function named NAME for type TYPE.
1927 KIND says what to build.
1929 When KIND == 0, build default destructor.
1930 When KIND == 1, build virtual destructor.
1931 When KIND == 2, build default constructor.
1932 When KIND == 3, build default X(const X&) constructor.
1933 When KIND == 4, build default X(X&) constructor.
1934 When KIND == 5, build default operator = (const X&).
1935 When KIND == 6, build default operator = (X&). */
1938 cons_up_default_function (type
, full_name
, kind
)
1939 tree type
, full_name
;
1942 extern tree void_list_node
;
1943 tree declspecs
= NULL_TREE
;
1947 tree name
= constructor_name (full_name
);
1953 declspecs
= build_decl_list (NULL_TREE
, ridpointers
[(int) RID_VIRTUAL
]);
1954 /* Fall through... */
1956 name
= build_parse_node (BIT_NOT_EXPR
, name
);
1957 args
= void_list_node
;
1961 /* Default constructor. */
1962 args
= void_list_node
;
1966 type
= build_type_variant (type
, 1, 0);
1967 /* Fall through... */
1969 /* According to ARM $12.8, the default copy ctor will be declared, but
1970 not defined, unless it's needed. */
1971 argtype
= build_reference_type (type
);
1972 args
= tree_cons (NULL_TREE
,
1973 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1974 get_identifier ("_ctor_arg")),
1981 declspecs
= build_decl_list (NULL_TREE
, type
);
1984 type
= build_type_variant (type
, 1, 0);
1986 name
= ansi_opname
[(int) MODIFY_EXPR
];
1988 argtype
= build_reference_type (type
);
1989 args
= tree_cons (NULL_TREE
,
1990 build_tree_list (hash_tree_chain (argtype
, NULL_TREE
),
1991 get_identifier ("_ctor_arg")),
1996 my_friendly_abort (59);
1999 declspecs
= decl_tree_cons (NULL_TREE
, ridpointers
[(int) RID_INLINE
],
2002 TREE_PARMLIST (args
) = 1;
2005 tree declarator
= make_call_declarator (name
, args
, NULL_TREE
, NULL_TREE
);
2006 int saved_processing_specialization
;
2008 declarator
= build_parse_node (ADDR_EXPR
, declarator
);
2010 /* The following is in case we're generating the default
2011 implementation in the midst of handling a specialization. */
2012 saved_processing_specialization
= processing_specialization
;
2013 processing_specialization
= 0;
2014 fn
= grokfield (declarator
, declspecs
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
2015 processing_specialization
= saved_processing_specialization
;
2018 if (fn
== void_type_node
)
2022 SET_DECL_ARTIFICIAL (TREE_CHAIN (DECL_ARGUMENTS (fn
)));
2025 if (processing_template_defn
)
2027 SET_DECL_IMPLICIT_INSTANTIATION (fn
);
2028 repo_template_used (fn
);
2033 if (CLASSTYPE_INTERFACE_KNOWN (type
))
2035 DECL_INTERFACE_KNOWN (fn
) = 1;
2036 DECL_NOT_REALLY_EXTERN (fn
) = (!CLASSTYPE_INTERFACE_ONLY (type
)
2037 && flag_implement_inlines
);
2041 DECL_NOT_REALLY_EXTERN (fn
) = 1;
2043 mark_inline_for_output (fn
);
2045 #ifdef DEBUG_DEFAULT_FUNCTIONS
2046 { char *fn_type
= NULL
;
2050 case 0: fn_type
= "default destructor"; break;
2051 case 1: fn_type
= "virtual destructor"; break;
2052 case 2: fn_type
= "default constructor"; break;
2053 case 3: fn_type
= "default X(const X&)"; break;
2054 case 4: fn_type
= "default X(X&)"; break;
2058 if (TREE_CODE (name
) == BIT_NOT_EXPR
)
2059 t
= TREE_OPERAND (name
, 0);
2060 fprintf (stderr
, "[[[[ %s for %s:\n%s]]]]\n", fn_type
,
2061 IDENTIFIER_POINTER (t
), func_buf
);
2064 #endif /* DEBUG_DEFAULT_FUNCTIONS */
2066 /* Show that this function was generated by the compiler. */
2067 SET_DECL_ARTIFICIAL (fn
);
2072 /* Heuristic to tell whether the user is missing a semicolon
2073 after a struct or enum declaration. Emit an error message
2074 if we know the user has blown it. */
2077 check_for_missing_semicolon (type
)
2085 && yychar
!= IDENTIFIER
2086 && yychar
!= TYPENAME
2087 && yychar
!= CV_QUALIFIER
2088 && yychar
!= SELFNAME
)
2091 if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type
)))
2092 error ("semicolon missing after %s declaration",
2093 TREE_CODE (type
) == ENUMERAL_TYPE
? "enum" : "struct");
2095 cp_error ("semicolon missing after declaration of `%T'", type
);
2096 shadow_tag (build_tree_list (0, type
));
2098 /* Could probably also hack cases where class { ... } f (); appears. */
2103 note_got_semicolon (type
)
2106 if (TREE_CODE_CLASS (TREE_CODE (type
)) != 't')
2107 my_friendly_abort (60);
2108 if (IS_AGGR_TYPE (type
))
2109 CLASSTYPE_GOT_SEMICOLON (type
) = 1;
2113 note_list_got_semicolon (declspecs
)
2118 for (link
= declspecs
; link
; link
= TREE_CHAIN (link
))
2120 tree type
= TREE_VALUE (link
);
2121 if (TREE_CODE_CLASS (TREE_CODE (type
)) == 't')
2122 note_got_semicolon (type
);
2127 /* If C is not whitespace, return C.
2128 Otherwise skip whitespace and return first nonwhite char read. */
2131 skip_white_space (c
)
2139 c
= check_newline ();
2150 while (c
== ' ' || c
== '\t');
2158 error ("stray '\\' in program");
2170 /* Make the token buffer longer, preserving the data in it.
2171 P should point to just beyond the last valid character in the old buffer.
2172 The value we return is a pointer to the new buffer
2173 at a place corresponding to P. */
2176 extend_token_buffer (p
)
2179 int offset
= p
- token_buffer
;
2181 maxtoken
= maxtoken
* 2 + 10;
2182 token_buffer
= (char *) xrealloc (token_buffer
, maxtoken
+ 2);
2184 return token_buffer
+ offset
;
2188 get_last_nonwhite_on_line ()
2192 /* Is this the last nonwhite stuff on the line? */
2194 c
= nextchar
, nextchar
= -1;
2198 while (c
== ' ' || c
== '\t')
2203 /* At the beginning of a line, increment the line number
2204 and process any #-directive on this line.
2205 If the line is a #-directive, read the entire line and return a newline.
2206 Otherwise, return the line's first non-whitespace character. */
2210 #ifdef HANDLE_SYSV_PRAGMA
2211 static int handle_sysv_pragma
PROTO((FILE *, int));
2213 static int handle_cp_pragma
PROTO((char *));
2221 /* Read first nonwhite char on the line. Do this before incrementing the
2222 line number, in case we're at the end of saved text. */
2226 while (c
== ' ' || c
== '\t');
2232 /* If not #, return it so caller will use it. */
2236 /* Don't read beyond this line. */
2239 /* Read first nonwhite char after the `#'. */
2243 while (c
== ' ' || c
== '\t');
2245 /* If a letter follows, then if the word here is `line', skip
2246 it and ignore it; otherwise, ignore the line, with an error
2247 if the word isn't `pragma'. */
2249 if ((c
>= 'a' && c
<= 'z') || (c
>= 'A' && c
<= 'Z'))
2259 token
= real_yylex ();
2260 if (token
== IDENTIFIER
2261 && TREE_CODE (yylval
.ttype
) == IDENTIFIER_NODE
)
2263 /* If this is 1, we handled it; if it's -1, it was one we
2264 wanted but had something wrong with it. Only if it's
2265 0 was it not handled. */
2266 if (handle_cp_pragma (IDENTIFIER_POINTER (yylval
.ttype
)))
2269 else if (token
== END_OF_LINE
)
2272 #ifdef HANDLE_SYSV_PRAGMA
2273 if (handle_sysv_pragma (finput
, token
))
2276 #ifdef HANDLE_PRAGMA
2277 if (HANDLE_PRAGMA (finput
, yylval
.ttype
))
2291 && ((c
= getch ()) == ' ' || c
== '\t'))
2293 debug_define (lineno
, get_directive_line (finput
));
2303 && ((c
= getch ()) == ' ' || c
== '\t'))
2305 debug_undef (lineno
, get_directive_line (finput
));
2314 && ((c
= getch ()) == ' ' || c
== '\t'))
2323 && ((c
= getch ()) == ' ' || c
== '\t'))
2325 #ifdef ASM_OUTPUT_IDENT
2326 extern FILE *asm_out_file
;
2328 /* #ident. The pedantic warning is now in cccp.c. */
2330 /* Here we have just seen `#ident '.
2331 A string constant should follow. */
2333 token
= real_yylex ();
2334 if (token
== END_OF_LINE
)
2337 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
2339 error ("invalid #ident");
2343 if (! flag_no_ident
)
2345 #ifdef ASM_OUTPUT_IDENT
2346 ASM_OUTPUT_IDENT (asm_out_file
,
2347 TREE_STRING_POINTER (yylval
.ttype
));
2351 /* Skip the rest of this line. */
2364 && ((c
= getch ()) == ' ' || c
== '\t'))
2366 /* Used to test incremental compilation. */
2367 sorry ("#pragma newworld");
2371 error ("undefined or invalid # directive");
2376 /* Here we have either `#line' or `# <nonletter>'.
2377 In either case, it should be a line number; a digit should follow. */
2379 while (c
== ' ' || c
== '\t')
2382 /* If the # is the only nonwhite char on the line,
2383 just ignore it. Check the new newline. */
2387 /* Something follows the #; read a token. */
2390 token
= real_yylex ();
2392 if (token
== CONSTANT
2393 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2395 int old_lineno
= lineno
;
2396 enum { act_none
, act_push
, act_pop
} action
= act_none
;
2397 int entering_system_header
= 0;
2398 int entering_c_header
= 0;
2400 /* subtract one, because it is the following line that
2401 gets the specified number */
2403 int l
= TREE_INT_CST_LOW (yylval
.ttype
) - 1;
2404 c
= get_last_nonwhite_on_line ();
2407 /* No more: store the line number and check following line. */
2413 /* More follows: it must be a string constant (filename). */
2415 /* Read the string constant, but don't treat \ as special. */
2416 ignore_escape_flag
= 1;
2417 token
= real_yylex ();
2418 ignore_escape_flag
= 0;
2420 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
2422 error ("invalid #line");
2426 /* Changing files again. This means currently collected time
2427 is charged against header time, and body time starts back
2429 if (flag_detailed_statistics
)
2431 int this_time
= my_get_run_time ();
2432 tree time_identifier
= get_time_identifier (TREE_STRING_POINTER (yylval
.ttype
));
2433 header_time
+= this_time
- body_time
;
2434 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
))
2435 += this_time
- body_time
;
2436 this_filename_time
= time_identifier
;
2437 body_time
= this_time
;
2441 = (char *) permalloc (TREE_STRING_LENGTH (yylval
.ttype
) + 1);
2442 strcpy (input_filename
, TREE_STRING_POINTER (yylval
.ttype
));
2444 GNU_xref_file (input_filename
);
2446 if (main_input_filename
== 0)
2448 struct impl_files
*ifiles
= impl_file_chain
;
2452 while (ifiles
->next
)
2453 ifiles
= ifiles
->next
;
2454 ifiles
->filename
= file_name_nondirectory (input_filename
);
2457 main_input_filename
= input_filename
;
2458 if (write_virtuals
== 3)
2459 walk_vtables (set_typedecl_interface_info
, set_vardecl_interface_info
);
2462 extract_interface_info ();
2464 c
= get_last_nonwhite_on_line ();
2467 /* Update the name in the top element of input_file_stack. */
2468 if (input_file_stack
)
2469 input_file_stack
->name
= input_filename
;
2475 token
= real_yylex ();
2477 /* `1' after file name means entering new file.
2478 `2' after file name means just left a file. */
2480 if (token
== CONSTANT
2481 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
)
2483 if (TREE_INT_CST_LOW (yylval
.ttype
) == 1)
2485 else if (TREE_INT_CST_LOW (yylval
.ttype
) == 2)
2490 c
= get_last_nonwhite_on_line ();
2494 token
= real_yylex ();
2499 /* `3' after file name means this is a system header file. */
2501 if (token
== CONSTANT
2502 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
2503 && TREE_INT_CST_LOW (yylval
.ttype
) == 3)
2505 entering_system_header
= 1;
2507 c
= get_last_nonwhite_on_line ();
2511 token
= real_yylex ();
2515 /* `4' after file name means this is a C header file. */
2517 if (token
== CONSTANT
2518 && TREE_CODE (yylval
.ttype
) == INTEGER_CST
2519 && TREE_INT_CST_LOW (yylval
.ttype
) == 4)
2521 entering_c_header
= 1;
2523 c
= get_last_nonwhite_on_line ();
2527 token
= real_yylex ();
2531 /* Do the actions implied by the preceding numbers. */
2533 if (action
== act_push
)
2535 /* Pushing to a new file. */
2536 struct file_stack
*p
;
2538 p
= (struct file_stack
*) xmalloc (sizeof (struct file_stack
));
2539 input_file_stack
->line
= old_lineno
;
2540 p
->next
= input_file_stack
;
2541 p
->name
= input_filename
;
2542 input_file_stack
= p
;
2543 input_file_stack_tick
++;
2544 debug_start_source_file (input_filename
);
2545 in_system_header
= entering_system_header
;
2548 else if (entering_c_header
)
2551 ++pending_lang_change
;
2554 else if (action
== act_pop
)
2556 /* Popping out of a file. */
2557 if (input_file_stack
->next
)
2559 struct file_stack
*p
;
2561 if (c_header_level
&& --c_header_level
== 0)
2563 if (entering_c_header
)
2564 warning ("badly nested C headers from preprocessor");
2565 --pending_lang_change
;
2567 in_system_header
= entering_system_header
;
2569 p
= input_file_stack
;
2570 input_file_stack
= p
->next
;
2572 input_file_stack_tick
++;
2573 debug_end_source_file (input_file_stack
->line
);
2576 error ("#-lines for entering and leaving files don't match");
2579 in_system_header
= entering_system_header
;
2582 /* If NEXTCHAR is not end of line, we don't care what it is. */
2583 if (nextchar
== EOF
)
2587 error ("invalid #-line");
2589 /* skip the rest of this line. */
2594 while ((c
= getch ()) != EOF
&& c
!= '\n');
2599 do_pending_lang_change ()
2601 for (; pending_lang_change
> 0; --pending_lang_change
)
2602 push_lang_context (lang_name_c
);
2603 for (; pending_lang_change
< 0; ++pending_lang_change
)
2604 pop_lang_context ();
2608 #define isalnum(char) (char >= 'a' ? char <= 'z' : char >= '0' ? char <= '9' || (char >= 'A' && char <= 'Z') : 0)
2609 #define isdigit(char) (char >= '0' && char <= '9')
2614 #define ENDFILE -1 /* token that represents end-of-file */
2616 /* Read an escape sequence, returning its equivalent as a character,
2617 or store 1 in *ignore_ptr if it is backslash-newline. */
2620 readescape (ignore_ptr
)
2623 register int c
= getch ();
2625 register unsigned count
;
2644 if (c
>= 'a' && c
<= 'f')
2645 code
+= c
- 'a' + 10;
2646 if (c
>= 'A' && c
<= 'F')
2647 code
+= c
- 'A' + 10;
2648 if (c
>= '0' && c
<= '9')
2650 if (code
!= 0 || count
!= 0)
2659 error ("\\x used with no following hex digits");
2660 else if (count
== 0)
2661 /* Digits are all 0's. Ok. */
2663 else if ((count
- 1) * 4 >= TYPE_PRECISION (integer_type_node
)
2665 && ((1 << (TYPE_PRECISION (integer_type_node
) - (count
- 1) * 4))
2667 pedwarn ("hex escape out of range");
2670 case '0': case '1': case '2': case '3': case '4':
2671 case '5': case '6': case '7':
2674 while ((c
<= '7') && (c
>= '0') && (count
++ < 3))
2676 code
= (code
* 8) + (c
- '0');
2682 case '\\': case '\'': case '"':
2691 return TARGET_NEWLINE
;
2714 pedwarn ("non-ANSI-standard escape sequence, `\\%c'", c
);
2720 /* `\(', etc, are used at beginning of line to avoid confusing Emacs. */
2724 /* `\%' is used to prevent SCCS from getting confused. */
2727 pedwarn ("unknown escape sequence `\\%c'", c
);
2730 if (c
>= 040 && c
< 0177)
2731 pedwarn ("unknown escape sequence `\\%c'", c
);
2733 pedwarn ("unknown escape sequence: `\\' followed by char code 0x%x", c
);
2737 /* Value is 1 (or 2) if we should try to make the next identifier look like
2738 a typename (when it may be a local variable or a class variable).
2739 Value is 0 if we treat this name in a default fashion. */
2740 int looking_for_typename
= 0;
2746 identifier_type (decl
)
2749 if (TREE_CODE (decl
) == TEMPLATE_DECL
)
2751 if (TREE_CODE (DECL_RESULT (decl
)) == TYPE_DECL
)
2753 else if (looking_for_template
)
2756 if (looking_for_template
&& really_overloaded_fn (decl
))
2759 for (t
= TREE_VALUE (decl
); t
!= NULL_TREE
; t
= DECL_CHAIN (t
))
2760 if (DECL_FUNCTION_TEMPLATE_P (t
))
2763 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
2765 if (TREE_CODE (decl
) != TYPE_DECL
)
2767 if (((got_scope
&& TREE_TYPE (decl
) == got_scope
)
2768 || TREE_TYPE (decl
) == current_class_type
)
2769 && DECL_ARTIFICIAL (decl
))
2777 looking_for_typename
= 1;
2779 if ((yychar
= yylex ()) < 0) yychar
= 0;
2780 looking_for_typename
= 0;
2781 if (yychar
== IDENTIFIER
)
2783 lastiddecl
= lookup_name (yylval
.ttype
, -2);
2784 if (lastiddecl
== 0)
2787 lastiddecl
= IDENTIFIER_LABEL_VALUE (yylval
.ttype
);
2790 yychar
= identifier_type (lastiddecl
);
2795 do_identifier (token
, parsing
)
2796 register tree token
;
2801 if (! parsing
|| IDENTIFIER_OPNAME_P (token
))
2802 id
= lookup_name (token
, 0);
2806 if (parsing
&& yychar
== YYEMPTY
)
2808 /* Scope class declarations before global
2810 if (id
== IDENTIFIER_GLOBAL_VALUE (token
)
2811 && current_class_type
!= 0
2812 && TYPE_SIZE (current_class_type
) == 0)
2814 /* Could be from one of the base classes. */
2815 tree field
= lookup_field (current_class_type
, token
, 1, 0);
2818 else if (field
== error_mark_node
)
2819 /* We have already generated the error message.
2820 But we still want to return this value. */
2821 id
= lookup_field (current_class_type
, token
, 0, 0);
2822 else if (TREE_CODE (field
) == VAR_DECL
2823 || TREE_CODE (field
) == CONST_DECL
)
2825 else if (TREE_CODE (field
) != FIELD_DECL
)
2826 my_friendly_abort (61);
2829 cp_error ("invalid use of member `%D' from base class `%T'", field
,
2830 DECL_FIELD_CONTEXT (field
));
2831 id
= error_mark_node
;
2836 /* Remember that this name has been used in the class definition, as per
2838 if (id
&& current_class_type
&& parsing
2839 && TYPE_BEING_DEFINED (current_class_type
)
2840 && ! IDENTIFIER_CLASS_VALUE (token
)
2841 /* Avoid breaking if we get called for a default argument that
2842 refers to an overloaded method. Eventually this will not be
2843 necessary, since default arguments shouldn't be parsed until
2844 after the class is complete. (jason 3/12/97) */
2845 && TREE_CODE (id
) != TREE_LIST
)
2846 pushdecl_class_level (id
);
2848 if (!id
|| id
== error_mark_node
)
2850 if (id
== error_mark_node
&& current_class_type
!= NULL_TREE
)
2852 id
= lookup_nested_field (token
, 1);
2853 /* In lookup_nested_field(), we marked this so we can gracefully
2854 leave this whole mess. */
2855 if (id
&& id
!= error_mark_node
&& TREE_TYPE (id
) == error_mark_node
)
2859 if (current_template_parms
)
2860 return build_min_nt (LOOKUP_EXPR
, token
, NULL_TREE
);
2861 else if (IDENTIFIER_OPNAME_P (token
))
2863 if (token
!= ansi_opname
[ERROR_MARK
])
2864 cp_error ("`%D' not defined", token
);
2865 id
= error_mark_node
;
2867 else if (parsing
&& (yychar
== '(' || yychar
== LEFT_RIGHT
))
2869 id
= implicitly_declare (token
);
2871 else if (current_function_decl
== 0)
2873 cp_error ("`%D' was not declared in this scope", token
);
2874 id
= error_mark_node
;
2878 if (IDENTIFIER_GLOBAL_VALUE (token
) != error_mark_node
2879 || IDENTIFIER_ERROR_LOCUS (token
) != current_function_decl
)
2881 static int undeclared_variable_notice
;
2883 cp_error ("`%D' undeclared (first use this function)", token
);
2885 if (! undeclared_variable_notice
)
2887 error ("(Each undeclared identifier is reported only once");
2888 error ("for each function it appears in.)");
2889 undeclared_variable_notice
= 1;
2892 id
= error_mark_node
;
2893 /* Prevent repeated error messages. */
2894 IDENTIFIER_GLOBAL_VALUE (token
) = error_mark_node
;
2895 SET_IDENTIFIER_ERROR_LOCUS (token
, current_function_decl
);
2899 if (TREE_CODE (id
) == VAR_DECL
&& DECL_DEAD_FOR_LOCAL (id
))
2901 tree shadowed
= DECL_SHADOWED_FOR_VAR (id
);
2902 while (shadowed
!= NULL_TREE
&& TREE_CODE (shadowed
) == VAR_DECL
2903 && DECL_DEAD_FOR_LOCAL (shadowed
))
2904 shadowed
= DECL_SHADOWED_FOR_VAR (shadowed
);
2906 shadowed
= IDENTIFIER_GLOBAL_VALUE (DECL_NAME (id
));
2909 if (!DECL_ERROR_REPORTED (id
))
2911 warning ("name lookup of `%s' changed",
2912 IDENTIFIER_POINTER (token
));
2913 cp_warning_at (" matches this `%D' under current ANSI rules",
2915 cp_warning_at (" matches this `%D' under old rules", id
);
2916 DECL_ERROR_REPORTED (id
) = 1;
2920 else if (!DECL_ERROR_REPORTED (id
))
2923 = "name lookup of `%s' changed for new ANSI `for' scoping";
2924 DECL_ERROR_REPORTED (id
) = 1;
2925 if (TYPE_NEEDS_DESTRUCTOR (TREE_TYPE (id
)))
2927 error (msg
, IDENTIFIER_POINTER (token
));
2928 cp_error_at (" cannot use obsolete binding at `%D' because it has a destructor", id
);
2929 id
= error_mark_node
;
2933 pedwarn (msg
, IDENTIFIER_POINTER (token
));
2934 cp_pedwarn_at (" using obsolete binding at `%D'", id
);
2938 /* TREE_USED is set in `hack_identifier'. */
2939 if (TREE_CODE (id
) == CONST_DECL
)
2941 if (IDENTIFIER_CLASS_VALUE (token
) == id
)
2944 tree access
= compute_access (TYPE_BINFO (current_class_type
), id
);
2945 if (access
== access_private_node
)
2946 cp_error ("enum `%D' is private", id
);
2947 /* protected is OK, since it's an enum of `this'. */
2949 if (! processing_template_decl
2950 || (DECL_INITIAL (id
)
2951 && TREE_CODE (DECL_INITIAL (id
)) == TEMPLATE_CONST_PARM
))
2952 id
= DECL_INITIAL (id
);
2955 id
= hack_identifier (id
, token
);
2957 if (current_template_parms
)
2959 if (is_overloaded_fn (id
))
2961 tree t
= build_min (LOOKUP_EXPR
, unknown_type_node
,
2962 token
, get_first_fn (id
));
2963 if (id
!= IDENTIFIER_GLOBAL_VALUE (token
))
2964 TREE_OPERAND (t
, 1) = error_mark_node
;
2967 else if (! TREE_PERMANENT (id
) || TREE_CODE (id
) == PARM_DECL
2968 || TREE_CODE (id
) == USING_DECL
)
2969 id
= build_min (LOOKUP_EXPR
, TREE_TYPE (id
), token
, error_mark_node
);
2970 /* else just use the decl */
2977 do_scoped_id (token
, parsing
)
2981 tree id
= IDENTIFIER_GLOBAL_VALUE (token
);
2982 if (parsing
&& yychar
== YYEMPTY
)
2986 if (processing_template_decl
)
2988 id
= build_min_nt (LOOKUP_EXPR
, token
, NULL_TREE
);
2989 LOOKUP_EXPR_GLOBAL (id
) = 1;
2992 if (parsing
&& yychar
== '(' || yychar
== LEFT_RIGHT
)
2993 id
= implicitly_declare (token
);
2996 if (IDENTIFIER_GLOBAL_VALUE (token
) != error_mark_node
)
2997 error ("undeclared variable `%s' (first use here)",
2998 IDENTIFIER_POINTER (token
));
2999 id
= error_mark_node
;
3000 /* Prevent repeated error messages. */
3001 IDENTIFIER_GLOBAL_VALUE (token
) = error_mark_node
;
3006 if (TREE_CODE (id
) == ADDR_EXPR
)
3007 mark_used (TREE_OPERAND (id
, 0));
3008 else if (TREE_CODE (id
) != TREE_LIST
)
3011 if (TREE_CODE (id
) == CONST_DECL
&& ! processing_template_decl
)
3013 /* XXX CHS - should we set TREE_USED of the constant? */
3014 id
= DECL_INITIAL (id
);
3015 /* This is to prevent an enum whose value is 0
3016 from being considered a null pointer constant. */
3017 id
= build1 (NOP_EXPR
, TREE_TYPE (id
), id
);
3018 TREE_CONSTANT (id
) = 1;
3021 if (processing_template_decl
)
3023 if (is_overloaded_fn (id
))
3025 id
= build_min (LOOKUP_EXPR
, unknown_type_node
,
3026 token
, get_first_fn (id
));
3027 LOOKUP_EXPR_GLOBAL (id
) = 1;
3029 /* else just use the decl */
3031 return convert_from_reference (id
);
3035 identifier_typedecl_value (node
)
3039 type
= IDENTIFIER_TYPE_VALUE (node
);
3040 if (type
== NULL_TREE
)
3045 if (t && TREE_CODE (t) == TYPE_DECL && TREE_TYPE (t) == type) \
3048 do (IDENTIFIER_LOCAL_VALUE (node
));
3049 do (IDENTIFIER_CLASS_VALUE (node
));
3050 do (IDENTIFIER_GLOBAL_VALUE (node
));
3052 /* Will this one ever happen? */
3053 if (TYPE_MAIN_DECL (type
))
3054 return TYPE_MAIN_DECL (type
);
3056 /* We used to do an internal error of 62 here, but instead we will
3057 handle the return of a null appropriately in the callers. */
3067 int dollar_seen
= 0;
3071 c
= nextchar
, nextchar
= -1;
3075 /* Effectively do c = skip_white_space (c)
3076 but do it faster in the usual cases. */
3089 /* Call skip_white_space so we can warn if appropriate. */
3094 c
= skip_white_space (c
);
3096 goto found_nonwhite
;
3100 token_buffer
[0] = c
;
3101 token_buffer
[1] = 0;
3103 /* yylloc.first_line = lineno; */
3108 token_buffer
[0] = '\0';
3110 if (input_redirected ())
3111 value
= END_OF_SAVED_INPUT
;
3113 value
= END_OF_LINE
;
3119 if (! dollars_in_ident
)
3120 error ("`$' in identifier");
3122 pedwarn ("`$' in identifier");
3127 /* Capital L may start a wide-string or wide-character constant. */
3129 register int c
= getch ();
3138 goto string_constant
;
3143 case 'A': case 'B': case 'C': case 'D': case 'E':
3144 case 'F': case 'G': case 'H': case 'I': case 'J':
3145 case 'K': case 'M': case 'N': case 'O':
3146 case 'P': case 'Q': case 'R': case 'S': case 'T':
3147 case 'U': case 'V': case 'W': case 'X': case 'Y':
3149 case 'a': case 'b': case 'c': case 'd': case 'e':
3150 case 'f': case 'g': case 'h': case 'i': case 'j':
3151 case 'k': case 'l': case 'm': case 'n': case 'o':
3152 case 'p': case 'q': case 'r': case 's': case 't':
3153 case 'u': case 'v': case 'w': case 'x': case 'y':
3163 /* We know that `token_buffer' can hold at least on char,
3164 so we install C immediately.
3165 We may have to read the value in `putback_char', so call
3170 /* Make this run fast. We know that we are reading straight
3171 from FINPUT in this case (since identifiers cannot straddle
3173 while (isalnum (c
) || (c
== '_') || c
== '$')
3177 if (! dollars_in_ident
)
3178 error ("`$' in identifier");
3180 pedwarn ("`$' in identifier");
3183 if (p
>= token_buffer
+ maxtoken
)
3184 p
= extend_token_buffer (p
);
3190 if (linemode
&& c
== '\n')
3198 /* We know that `token_buffer' can hold at least on char,
3199 so we install C immediately. */
3203 while (isalnum (c
) || (c
== '_') || c
== '$')
3207 if (! dollars_in_ident
)
3208 error ("`$' in identifier");
3210 pedwarn ("`$' in identifier");
3213 if (p
>= token_buffer
+ maxtoken
)
3214 p
= extend_token_buffer (p
);
3227 /* Try to recognize a keyword. Uses minimum-perfect hash function */
3230 register struct resword
*ptr
;
3232 if (ptr
= is_reserved_word (token_buffer
, p
- token_buffer
))
3236 tree old_ttype
= ridpointers
[(int) ptr
->rid
];
3238 /* If this provides a type for us, then revert lexical
3239 state to standard state. */
3240 if (TREE_CODE (old_ttype
) == IDENTIFIER_NODE
3241 && IDENTIFIER_GLOBAL_VALUE (old_ttype
) != 0
3242 && TREE_CODE (IDENTIFIER_GLOBAL_VALUE (old_ttype
)) == TYPE_DECL
)
3243 looking_for_typename
= 0;
3244 else if (ptr
->token
== AGGR
|| ptr
->token
== ENUM
)
3245 looking_for_typename
= 1;
3247 /* Check if this is a language-type declaration.
3248 Just glimpse the next non-white character. */
3249 nextchar
= skip_white_space (nextchar
);
3250 if (nextchar
== '"')
3252 /* We are looking at a string. Complain
3253 if the token before the string is no `extern'.
3255 Could cheat some memory by placing this string
3256 on the temporary_, instead of the saveable_
3259 if (ptr
->rid
!= RID_EXTERN
)
3260 error ("invalid modifier `%s' for language string",
3263 value
= EXTERN_LANG_STRING
;
3264 yylval
.ttype
= get_identifier (TREE_STRING_POINTER (yylval
.ttype
));
3267 if (ptr
->token
== VISSPEC
)
3272 yylval
.ttype
= access_public_node
;
3275 yylval
.ttype
= access_private_node
;
3278 yylval
.ttype
= access_protected_node
;
3281 my_friendly_abort (63);
3285 yylval
.ttype
= old_ttype
;
3287 else if (ptr
->token
== EQCOMPARE
)
3289 yylval
.code
= NE_EXPR
;
3290 token_buffer
[0] = '!';
3291 token_buffer
[1] = '=';
3292 token_buffer
[2] = 0;
3294 else if (ptr
->token
== ASSIGN
)
3296 if (strcmp ("and_eq", token_buffer
) == 0)
3298 yylval
.code
= BIT_AND_EXPR
;
3299 token_buffer
[0] = '&';
3301 else if (strcmp ("or_eq", token_buffer
) == 0)
3303 yylval
.code
= BIT_IOR_EXPR
;
3304 token_buffer
[0] = '|';
3306 else if (strcmp ("xor_eq", token_buffer
) == 0)
3308 yylval
.code
= BIT_XOR_EXPR
;
3309 token_buffer
[0] = '^';
3311 token_buffer
[1] = '=';
3312 token_buffer
[2] = 0;
3314 else if (ptr
->token
== '&')
3316 yylval
.code
= BIT_AND_EXPR
;
3317 token_buffer
[0] = '&';
3318 token_buffer
[1] = 0;
3320 else if (ptr
->token
== '|')
3322 yylval
.code
= BIT_IOR_EXPR
;
3323 token_buffer
[0] = '|';
3324 token_buffer
[1] = 0;
3326 else if (ptr
->token
== '^')
3328 yylval
.code
= BIT_XOR_EXPR
;
3329 token_buffer
[0] = '^';
3330 token_buffer
[1] = 0;
3333 value
= (int) ptr
->token
;
3337 /* If we did not find a keyword, look for an identifier
3340 if (value
== IDENTIFIER
|| value
== TYPESPEC
)
3341 GNU_xref_ref (current_function_decl
, token_buffer
);
3343 if (value
== IDENTIFIER
)
3345 register tree tmp
= get_identifier (token_buffer
);
3347 #if !defined(VMS) && defined(JOINER)
3348 /* Make sure that user does not collide with our internal
3352 && (THIS_NAME_P (tmp
)
3353 || VPTR_NAME_P (tmp
)
3354 || DESTRUCTOR_NAME_P (tmp
)
3355 || VTABLE_NAME_P (tmp
)
3356 || TEMP_NAME_P (tmp
)
3357 || ANON_AGGRNAME_P (tmp
)
3358 || ANON_PARMNAME_P (tmp
)))
3359 warning ("identifier name `%s' conflicts with GNU C++ internal naming strategy",
3365 if (value
== NEW
&& ! global_bindings_p ())
3375 register int c1
= getch ();
3376 token_buffer
[0] = c
;
3377 token_buffer
[1] = c1
;
3381 token_buffer
[2] = 0;
3389 token_buffer
[2] = c1
;
3390 token_buffer
[3] = 0;
3394 error ("parse error at `..'");
3399 goto resume_numerical_scan
;
3403 token_buffer
[1] = 0;
3407 /* Optimize for most frequent case. */
3409 register int c1
= getch ();
3410 if (! isalnum (c1
) && c1
!= '.')
3412 /* Terminate string. */
3413 token_buffer
[0] = c
;
3414 token_buffer
[1] = 0;
3416 yylval
.ttype
= integer_zero_node
;
3418 yylval
.ttype
= integer_one_node
;
3425 /* fall through... */
3426 case '2': case '3': case '4':
3427 case '5': case '6': case '7': case '8': case '9':
3428 resume_numerical_scan
:
3433 int largest_digit
= 0;
3435 /* for multi-precision arithmetic,
3436 we actually store only HOST_BITS_PER_CHAR bits in each part.
3437 The number of parts is chosen so as to be sufficient to hold
3438 the enough bits to fit into the two HOST_WIDE_INTs that contain
3439 the integer value (this is always at least as many bits as are
3440 in a target `long long' value, but may be wider). */
3441 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2 + 2)
3442 int parts
[TOTAL_PARTS
];
3445 enum anon1
{ NOT_FLOAT
, AFTER_POINT
, TOO_MANY_POINTS
} floatflag
3448 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3456 *p
++ = (c
= getch ());
3457 if ((c
== 'x') || (c
== 'X'))
3460 *p
++ = (c
= getch ());
3462 /* Leading 0 forces octal unless the 0 is the only digit. */
3463 else if (c
>= '0' && c
<= '9')
3472 /* Read all the digits-and-decimal-points. */
3475 || (isalnum (c
) && (c
!= 'l') && (c
!= 'L')
3476 && (c
!= 'u') && (c
!= 'U')
3477 && c
!= 'i' && c
!= 'I' && c
!= 'j' && c
!= 'J'
3478 && (floatflag
== NOT_FLOAT
|| ((c
!= 'f') && (c
!= 'F')))))
3483 error ("floating constant may not be in radix 16");
3484 if (floatflag
== TOO_MANY_POINTS
)
3485 /* We have already emitted an error. Don't need another. */
3487 else if (floatflag
== AFTER_POINT
)
3489 error ("malformed floating constant");
3490 floatflag
= TOO_MANY_POINTS
;
3491 /* Avoid another error from atof by forcing all characters
3492 from here on to be ignored. */
3496 floatflag
= AFTER_POINT
;
3499 *p
++ = c
= getch ();
3500 /* Accept '.' as the start of a floating-point number
3501 only when it is followed by a digit.
3502 Otherwise, unread the following non-digit
3503 and use the '.' as a structural token. */
3504 if (p
== token_buffer
+ 2 && !isdigit (c
))
3516 error ("parse error at `..'");
3519 token_buffer
[1] = '\0';
3526 /* It is not a decimal point.
3527 It should be a digit (perhaps a hex digit). */
3533 else if (base
<= 10)
3535 if (c
== 'e' || c
== 'E')
3538 floatflag
= AFTER_POINT
;
3539 break; /* start of exponent */
3541 error ("nondigits in number and not hexadecimal");
3552 if (c
>= largest_digit
)
3556 for (count
= 0; count
< TOTAL_PARTS
; count
++)
3558 parts
[count
] *= base
;
3562 += (parts
[count
-1] >> HOST_BITS_PER_CHAR
);
3564 &= (1 << HOST_BITS_PER_CHAR
) - 1;
3570 /* If the extra highest-order part ever gets anything in it,
3571 the number is certainly too big. */
3572 if (parts
[TOTAL_PARTS
- 1] != 0)
3575 if (p
>= token_buffer
+ maxtoken
- 3)
3576 p
= extend_token_buffer (p
);
3577 *p
++ = (c
= getch ());
3582 error ("numeric constant with no digits");
3584 if (largest_digit
>= base
)
3585 error ("numeric constant contains digits beyond the radix");
3587 /* Remove terminating char from the token buffer and delimit the string */
3590 if (floatflag
!= NOT_FLOAT
)
3592 tree type
= double_type_node
;
3593 int exceeds_double
= 0;
3595 REAL_VALUE_TYPE value
;
3598 /* Read explicit exponent if any, and put it in tokenbuf. */
3600 if ((c
== 'e') || (c
== 'E'))
3602 if (p
>= token_buffer
+ maxtoken
- 3)
3603 p
= extend_token_buffer (p
);
3606 if ((c
== '+') || (c
== '-'))
3612 error ("floating constant exponent has no digits");
3615 if (p
>= token_buffer
+ maxtoken
- 3)
3616 p
= extend_token_buffer (p
);
3625 /* Convert string to a double, checking for overflow. */
3626 if (setjmp (handler
))
3628 error ("floating constant out of range");
3633 int fflag
= 0, lflag
= 0;
3634 /* Copy token_buffer now, while it has just the number
3635 and not the suffixes; once we add `f' or `i',
3636 REAL_VALUE_ATOF may not work any more. */
3637 char *copy
= (char *) alloca (p
- token_buffer
+ 1);
3638 bcopy (token_buffer
, copy
, p
- token_buffer
+ 1);
3640 set_float_handler (handler
);
3646 /* Read the suffixes to choose a data type. */
3651 error ("more than one `f' in numeric constant");
3657 error ("more than one `l' in numeric constant");
3663 error ("more than one `i' or `j' in numeric constant");
3665 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3676 if (p
>= token_buffer
+ maxtoken
- 3)
3677 p
= extend_token_buffer (p
);
3683 /* The second argument, machine_mode, of REAL_VALUE_ATOF
3684 tells the desired precision of the binary result
3685 of decimal-to-binary conversion. */
3690 error ("both `f' and `l' in floating constant");
3692 type
= float_type_node
;
3693 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3694 /* A diagnostic is required here by some ANSI C testsuites.
3695 This is not pedwarn, become some people don't want
3696 an error for this. */
3697 if (REAL_VALUE_ISINF (value
) && pedantic
)
3698 warning ("floating point number exceeds range of `float'");
3702 type
= long_double_type_node
;
3703 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3704 if (REAL_VALUE_ISINF (value
) && pedantic
)
3705 warning ("floating point number exceeds range of `long double'");
3709 value
= REAL_VALUE_ATOF (copy
, TYPE_MODE (type
));
3710 if (REAL_VALUE_ISINF (value
) && pedantic
)
3711 warning ("floating point number exceeds range of `double'");
3714 set_float_handler (NULL_PTR
);
3717 if (errno
== ERANGE
&& pedantic
)
3719 /* ERANGE is also reported for underflow,
3720 so test the value to distinguish overflow from that. */
3721 if (REAL_VALUES_LESS (dconst1
, value
)
3722 || REAL_VALUES_LESS (value
, dconstm1
))
3724 pedwarn ("floating point number exceeds range of `%s'",
3725 IDENTIFIER_POINTER (TYPE_IDENTIFIER (type
)));
3731 /* If the result is not a number, assume it must have been
3732 due to some error message above, so silently convert
3734 if (REAL_VALUE_ISNAN (value
))
3737 /* Create a node with determined type and value. */
3739 yylval
.ttype
= build_complex (NULL_TREE
,
3740 cp_convert (type
, integer_zero_node
),
3741 build_real (type
, value
));
3743 yylval
.ttype
= build_real (type
, value
);
3748 HOST_WIDE_INT high
, low
;
3749 int spec_unsigned
= 0;
3751 int spec_long_long
= 0;
3757 if (c
== 'u' || c
== 'U')
3760 error ("two `u's in integer constant");
3763 else if (c
== 'l' || c
== 'L')
3768 error ("three `l's in integer constant");
3770 pedwarn ("ANSI C++ forbids long long integer constants");
3775 else if (c
== 'i' || c
== 'j' || c
== 'I' || c
== 'J')
3778 error ("more than one `i' or `j' in numeric constant");
3780 pedwarn ("ANSI C++ forbids imaginary numeric constants");
3785 if (p
>= token_buffer
+ maxtoken
- 3)
3786 p
= extend_token_buffer (p
);
3791 /* If the constant is not long long and it won't fit in an
3792 unsigned long, or if the constant is long long and won't fit
3793 in an unsigned long long, then warn that the constant is out
3796 /* ??? This assumes that long long and long integer types are
3797 a multiple of 8 bits. This better than the original code
3798 though which assumed that long was exactly 32 bits and long
3799 long was exactly 64 bits. */
3802 bytes
= TYPE_PRECISION (long_long_integer_type_node
) / 8;
3804 bytes
= TYPE_PRECISION (long_integer_type_node
) / 8;
3807 for (i
= bytes
; i
< TOTAL_PARTS
; i
++)
3811 pedwarn ("integer constant out of range");
3813 /* This is simplified by the fact that our constant
3814 is always positive. */
3817 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
; i
++)
3819 high
|= ((HOST_WIDE_INT
) parts
[i
+ (HOST_BITS_PER_WIDE_INT
3820 / HOST_BITS_PER_CHAR
)]
3821 << (i
* HOST_BITS_PER_CHAR
));
3822 low
|= (HOST_WIDE_INT
) parts
[i
] << (i
* HOST_BITS_PER_CHAR
);
3826 yylval
.ttype
= build_int_2 (low
, high
);
3827 TREE_TYPE (yylval
.ttype
) = long_long_unsigned_type_node
;
3829 /* Calculate the ANSI type. */
3830 if (!spec_long
&& !spec_unsigned
3831 && int_fits_type_p (yylval
.ttype
, integer_type_node
))
3832 type
= integer_type_node
;
3833 else if (!spec_long
&& (base
!= 10 || spec_unsigned
)
3834 && int_fits_type_p (yylval
.ttype
, unsigned_type_node
))
3835 /* Nondecimal constants try unsigned even in traditional C. */
3836 type
= unsigned_type_node
;
3837 else if (!spec_unsigned
&& !spec_long_long
3838 && int_fits_type_p (yylval
.ttype
, long_integer_type_node
))
3839 type
= long_integer_type_node
;
3840 else if (! spec_long_long
)
3841 type
= long_unsigned_type_node
;
3842 else if (! spec_unsigned
3843 /* Verify value does not overflow into sign bit. */
3844 && TREE_INT_CST_HIGH (yylval
.ttype
) >= 0
3845 && int_fits_type_p (yylval
.ttype
,
3846 long_long_integer_type_node
))
3847 type
= long_long_integer_type_node
;
3849 type
= long_long_unsigned_type_node
;
3851 if (!int_fits_type_p (yylval
.ttype
, type
) && !warn
)
3852 pedwarn ("integer constant out of range");
3854 if (base
== 10 && ! spec_unsigned
&& TREE_UNSIGNED (type
))
3855 warning ("decimal integer constant is so large that it is unsigned");
3859 if (TYPE_PRECISION (type
)
3860 <= TYPE_PRECISION (integer_type_node
))
3862 = build_complex (NULL_TREE
, integer_zero_node
,
3863 cp_convert (integer_type_node
,
3866 error ("complex integer constant is too wide for `__complex int'");
3869 TREE_TYPE (yylval
.ttype
) = type
;
3875 value
= CONSTANT
; break;
3881 register int result
= 0;
3882 register int num_chars
= 0;
3883 unsigned width
= TYPE_PRECISION (char_type_node
);
3888 width
= WCHAR_TYPE_SIZE
;
3889 #ifdef MULTIBYTE_CHARS
3890 max_chars
= MB_CUR_MAX
;
3896 max_chars
= TYPE_PRECISION (integer_type_node
) / width
;
3904 if (c
== '\'' || c
== EOF
)
3910 c
= readescape (&ignore
);
3913 if (width
< HOST_BITS_PER_INT
3914 && (unsigned) c
>= (1 << width
))
3915 warning ("escape sequence out of range for character");
3916 #ifdef MAP_CHARACTER
3918 c
= MAP_CHARACTER (c
);
3924 pedwarn ("ANSI C++ forbids newline in character constant");
3927 #ifdef MAP_CHARACTER
3929 c
= MAP_CHARACTER (c
);
3933 if (num_chars
> maxtoken
- 4)
3934 extend_token_buffer (token_buffer
);
3936 token_buffer
[num_chars
] = c
;
3938 /* Merge character into result; ignore excess chars. */
3939 if (num_chars
< max_chars
+ 1)
3941 if (width
< HOST_BITS_PER_INT
)
3942 result
= (result
<< width
) | (c
& ((1 << width
) - 1));
3948 token_buffer
[num_chars
+ 1] = '\'';
3949 token_buffer
[num_chars
+ 2] = 0;
3952 error ("malformatted character constant");
3953 else if (num_chars
== 0)
3954 error ("empty character constant");
3955 else if (num_chars
> max_chars
)
3957 num_chars
= max_chars
;
3958 error ("character constant too long");
3960 else if (num_chars
!= 1)
3961 warning ("multi-character character constant");
3963 /* If char type is signed, sign-extend the constant. */
3966 int num_bits
= num_chars
* width
;
3968 /* We already got an error; avoid invalid shift. */
3969 yylval
.ttype
= build_int_2 (0, 0);
3970 else if (TREE_UNSIGNED (char_type_node
)
3971 || ((result
>> (num_bits
- 1)) & 1) == 0)
3973 = build_int_2 (result
& ((unsigned HOST_WIDE_INT
) ~0
3974 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
3978 = build_int_2 (result
| ~((unsigned HOST_WIDE_INT
) ~0
3979 >> (HOST_BITS_PER_WIDE_INT
- num_bits
)),
3982 TREE_TYPE (yylval
.ttype
) = char_type_node
;
3984 TREE_TYPE (yylval
.ttype
) = integer_type_node
;
3988 #ifdef MULTIBYTE_CHARS
3989 /* Set the initial shift state and convert the next sequence. */
3991 /* In all locales L'\0' is zero and mbtowc will return zero,
3994 || (num_chars
== 1 && token_buffer
[1] != '\0'))
3997 (void) mbtowc (NULL
, NULL
, 0);
3998 if (mbtowc (& wc
, token_buffer
+ 1, num_chars
) == num_chars
)
4001 warning ("Ignoring invalid multibyte character");
4004 yylval
.ttype
= build_int_2 (result
, 0);
4005 TREE_TYPE (yylval
.ttype
) = wchar_type_node
;
4018 p
= token_buffer
+ 1;
4020 while (c
!= '"' && c
>= 0)
4022 /* ignore_escape_flag is set for reading the filename in #line. */
4023 if (!ignore_escape_flag
&& c
== '\\')
4026 c
= readescape (&ignore
);
4030 && TYPE_PRECISION (char_type_node
) < HOST_BITS_PER_INT
4031 && c
>= ((unsigned) 1 << TYPE_PRECISION (char_type_node
)))
4032 warning ("escape sequence out of range for character");
4037 pedwarn ("ANSI C++ forbids newline in string constant");
4041 if (p
== token_buffer
+ maxtoken
)
4042 p
= extend_token_buffer (p
);
4048 error ("Unterminated string");
4054 /* We have read the entire constant.
4055 Construct a STRING_CST for the result. */
4059 /* If this is a L"..." wide-string, convert the multibyte string
4060 to a wide character string. */
4061 char *widep
= (char *) alloca ((p
- token_buffer
) * WCHAR_BYTES
);
4064 #ifdef MULTIBYTE_CHARS
4065 len
= mbstowcs ((wchar_t *) widep
, token_buffer
+ 1, p
- token_buffer
);
4066 if (len
< 0 || len
>= (p
- token_buffer
))
4068 warning ("Ignoring invalid multibyte string");
4071 bzero (widep
+ (len
* WCHAR_BYTES
), WCHAR_BYTES
);
4076 wp
= widep
+ (BYTES_BIG_ENDIAN
? WCHAR_BYTES
- 1 : 0);
4077 bzero (widep
, (p
- token_buffer
) * WCHAR_BYTES
);
4078 for (cp
= token_buffer
+ 1; cp
< p
; cp
++)
4079 *wp
= *cp
, wp
+= WCHAR_BYTES
;
4080 len
= p
- token_buffer
- 1;
4083 if (processing_template_decl
)
4084 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4085 yylval
.ttype
= build_string ((len
+ 1) * WCHAR_BYTES
, widep
);
4086 if (processing_template_decl
)
4088 TREE_TYPE (yylval
.ttype
) = wchar_array_type_node
;
4092 if (processing_template_decl
)
4093 push_obstacks (&permanent_obstack
, &permanent_obstack
);
4094 yylval
.ttype
= build_string (p
- token_buffer
, token_buffer
+ 1);
4095 if (processing_template_decl
)
4097 TREE_TYPE (yylval
.ttype
) = char_array_type_node
;
4103 value
= STRING
; break;
4126 yylval
.code
= PLUS_EXPR
; break;
4128 yylval
.code
= MINUS_EXPR
; break;
4130 yylval
.code
= BIT_AND_EXPR
; break;
4132 yylval
.code
= BIT_IOR_EXPR
; break;
4134 yylval
.code
= MULT_EXPR
; break;
4136 yylval
.code
= TRUNC_DIV_EXPR
; break;
4138 yylval
.code
= TRUNC_MOD_EXPR
; break;
4140 yylval
.code
= BIT_XOR_EXPR
; break;
4142 yylval
.code
= LSHIFT_EXPR
; break;
4144 yylval
.code
= RSHIFT_EXPR
; break;
4146 yylval
.code
= LT_EXPR
; break;
4148 yylval
.code
= GT_EXPR
; break;
4151 token_buffer
[1] = c1
= getch ();
4152 token_buffer
[2] = 0;
4159 value
= ARITHCOMPARE
; yylval
.code
= LE_EXPR
; goto done
;
4161 value
= ARITHCOMPARE
; yylval
.code
= GE_EXPR
; goto done
;
4163 value
= EQCOMPARE
; yylval
.code
= NE_EXPR
; goto done
;
4165 value
= EQCOMPARE
; yylval
.code
= EQ_EXPR
; goto done
;
4167 value
= ASSIGN
; goto done
;
4173 value
= PLUSPLUS
; goto done
;
4175 value
= MINUSMINUS
; goto done
;
4177 value
= ANDAND
; goto done
;
4179 value
= OROR
; goto done
;
4187 else if ((c
== '-') && (c1
== '>'))
4189 nextchar
= getch ();
4190 if (nextchar
== '*')
4193 value
= POINTSAT_STAR
;
4199 else if (c1
== '?' && (c
== '<' || c
== '>'))
4201 token_buffer
[3] = 0;
4204 yylval
.code
= (c
== '<' ? MIN_EXPR
: MAX_EXPR
);
4207 /* <?= or >?= expression. */
4208 token_buffer
[2] = c1
;
4217 pedwarn ("use of `operator %s' is not standard C++",
4222 else if (c
== '<' && c1
== '%')
4223 { value
= '{'; goto done
; }
4224 else if (c
== '<' && c1
== ':')
4225 { value
= '['; goto done
; }
4226 else if (c
== '%' && c1
== '>')
4227 { value
= '}'; goto done
; }
4228 else if (c
== '%' && c1
== ':')
4229 { value
= '#'; goto done
; }
4232 token_buffer
[1] = 0;
4242 token_buffer
[1] = ':';
4243 token_buffer
[2] = '\0';
4260 /* Don't make yyparse think this is eof. */
4265 /* try, weakly, to handle casts to pointers to functions. */
4266 nextchar
= skip_white_space (getch ());
4267 if (nextchar
== '*')
4269 int next_c
= skip_white_space (getch ());
4273 yylval
.ttype
= build1 (INDIRECT_REF
, 0, 0);
4274 value
= PAREN_STAR_PAREN
;
4282 else if (nextchar
== ')')
4285 yylval
.ttype
= NULL_TREE
;
4296 /* yylloc.last_line = lineno; */
4297 #ifdef GATHER_STATISTICS
4298 #ifdef REDUCE_LENGTH
4299 token_count
[value
] += 1;
4310 return !!is_reserved_word (IDENTIFIER_POINTER (t
), IDENTIFIER_LENGTH (t
));
4313 #ifdef GATHER_STATISTICS
4314 /* The original for tree_node_kind is in the toplevel tree.c; changes there
4315 need to be brought into here, unless this were actually put into a header
4317 /* Statistics-gathering stuff. */
4338 extern int tree_node_counts
[];
4339 extern int tree_node_sizes
[];
4342 /* Place to save freed lang_decls which were allocated on the
4343 permanent_obstack. @@ Not currently used. */
4344 tree free_lang_decl_chain
;
4347 build_lang_decl (code
, name
, type
)
4348 enum tree_code code
;
4352 register tree t
= build_decl (code
, name
, type
);
4353 struct obstack
*obstack
= current_obstack
;
4354 register int i
= sizeof (struct lang_decl
) / sizeof (int);
4357 if (! TREE_PERMANENT (t
))
4358 obstack
= saveable_obstack
;
4360 /* Could be that saveable is permanent and current is not. */
4361 obstack
= &permanent_obstack
;
4363 if (free_lang_decl_chain
&& obstack
== &permanent_obstack
)
4365 pi
= (int *)free_lang_decl_chain
;
4366 free_lang_decl_chain
= TREE_CHAIN (free_lang_decl_chain
);
4369 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_decl
));
4374 DECL_LANG_SPECIFIC (t
) = (struct lang_decl
*) pi
;
4375 LANG_DECL_PERMANENT ((struct lang_decl
*) pi
)
4376 = obstack
== &permanent_obstack
;
4377 my_friendly_assert (LANG_DECL_PERMANENT ((struct lang_decl
*) pi
)
4378 == TREE_PERMANENT (t
), 234);
4379 DECL_MAIN_VARIANT (t
) = t
;
4380 if (current_lang_name
== lang_name_cplusplus
)
4381 DECL_LANGUAGE (t
) = lang_cplusplus
;
4382 else if (current_lang_name
== lang_name_c
)
4383 DECL_LANGUAGE (t
) = lang_c
;
4384 else my_friendly_abort (64);
4386 #if 0 /* not yet, should get fixed properly later */
4387 if (code
== TYPE_DECL
)
4390 id
= get_identifier (build_overload_name (type
, 1, 1));
4391 DECL_ASSEMBLER_NAME (t
) = id
;
4395 #ifdef GATHER_STATISTICS
4396 tree_node_counts
[(int)lang_decl
] += 1;
4397 tree_node_sizes
[(int)lang_decl
] += sizeof (struct lang_decl
);
4404 build_lang_field_decl (code
, name
, type
)
4405 enum tree_code code
;
4409 extern struct obstack
*current_obstack
, *saveable_obstack
;
4410 register tree t
= build_decl (code
, name
, type
);
4411 struct obstack
*obstack
= current_obstack
;
4412 register int i
= sizeof (struct lang_decl_flags
) / sizeof (int);
4414 #if 0 /* not yet, should get fixed properly later */
4416 if (code
== TYPE_DECL
)
4419 id
= get_identifier (build_overload_name (type
, 1, 1));
4420 DECL_ASSEMBLER_NAME (t
) = id
;
4424 if (! TREE_PERMANENT (t
))
4425 obstack
= saveable_obstack
;
4427 my_friendly_assert (obstack
== &permanent_obstack
, 235);
4429 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_decl_flags
));
4433 DECL_LANG_SPECIFIC (t
) = (struct lang_decl
*) pi
;
4438 copy_lang_decl (node
)
4444 if (! DECL_LANG_SPECIFIC (node
))
4447 if (TREE_CODE (node
) == FIELD_DECL
)
4448 size
= sizeof (struct lang_decl_flags
);
4450 size
= sizeof (struct lang_decl
);
4451 pi
= (int *)obstack_alloc (&permanent_obstack
, size
);
4452 bcopy ((char *)DECL_LANG_SPECIFIC (node
), (char *)pi
, size
);
4453 DECL_LANG_SPECIFIC (node
) = (struct lang_decl
*)pi
;
4457 make_lang_type (code
)
4458 enum tree_code code
;
4460 extern struct obstack
*current_obstack
, *saveable_obstack
;
4461 register tree t
= make_node (code
);
4462 struct obstack
*obstack
= current_obstack
;
4463 register int i
= sizeof (struct lang_type
) / sizeof (int);
4466 /* Set up some flags that give proper default behavior. */
4467 IS_AGGR_TYPE (t
) = 1;
4469 if (! TREE_PERMANENT (t
))
4470 obstack
= saveable_obstack
;
4472 my_friendly_assert (obstack
== &permanent_obstack
, 236);
4474 pi
= (int *) obstack_alloc (obstack
, sizeof (struct lang_type
));
4478 TYPE_LANG_SPECIFIC (t
) = (struct lang_type
*) pi
;
4479 CLASSTYPE_AS_LIST (t
) = build_expr_list (NULL_TREE
, t
);
4480 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, interface_unknown
);
4481 CLASSTYPE_INTERFACE_ONLY (t
) = interface_only
;
4482 CLASSTYPE_VBASE_SIZE (t
) = integer_zero_node
;
4483 TYPE_BINFO (t
) = make_binfo (integer_zero_node
, t
, NULL_TREE
, NULL_TREE
,
4485 CLASSTYPE_BINFO_AS_LIST (t
) = build_tree_list (NULL_TREE
, TYPE_BINFO (t
));
4487 /* Make sure this is laid out, for ease of use later.
4488 In the presence of parse errors, the normal was of assuring
4489 this might not ever get executed, so we lay it out *immediately*. */
4490 build_pointer_type (t
);
4492 #ifdef GATHER_STATISTICS
4493 tree_node_counts
[(int)lang_type
] += 1;
4494 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
4501 dump_time_statistics ()
4503 register tree prev
= 0, decl
, next
;
4504 int this_time
= my_get_run_time ();
4505 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (this_filename_time
))
4506 += this_time
- body_time
;
4508 fprintf (stderr
, "\n******\n");
4509 print_time ("header files (total)", header_time
);
4510 print_time ("main file (total)", this_time
- body_time
);
4511 fprintf (stderr
, "ratio = %g : 1\n",
4512 (double)header_time
/ (double)(this_time
- body_time
));
4513 fprintf (stderr
, "\n******\n");
4515 for (decl
= filename_times
; decl
; decl
= next
)
4517 next
= IDENTIFIER_GLOBAL_VALUE (decl
);
4518 IDENTIFIER_GLOBAL_VALUE (decl
) = prev
;
4522 for (decl
= prev
; decl
; decl
= IDENTIFIER_GLOBAL_VALUE (decl
))
4523 print_time (IDENTIFIER_POINTER (decl
),
4524 TREE_INT_CST_LOW (IDENTIFIER_LOCAL_VALUE (decl
)));
4528 compiler_error (s
, v
, v2
)
4530 HOST_WIDE_INT v
, v2
; /* @@also used as pointer */
4533 sprintf (buf
, s
, v
, v2
);
4534 error_with_file_and_line (input_filename
, lineno
, "%s (compiler error)", buf
);
4541 extern int end_of_file
;
4544 strcpy (buf
, string
);
4546 /* We can't print string and character constants well
4547 because the token_buffer contains the result of processing escapes. */
4549 strcat (buf
, input_redirected ()
4550 ? " at end of saved text"
4551 : " at end of input");
4552 else if (token_buffer
[0] == 0)
4553 strcat (buf
, " at null character");
4554 else if (token_buffer
[0] == '"')
4555 strcat (buf
, " before string constant");
4556 else if (token_buffer
[0] == '\'')
4557 strcat (buf
, " before character constant");
4558 else if (token_buffer
[0] < 040 || (unsigned char) token_buffer
[0] >= 0177)
4559 sprintf (buf
+ strlen (buf
), " before character 0%o",
4560 (unsigned char) token_buffer
[0]);
4562 strcat (buf
, " before `%s'");
4564 error (buf
, token_buffer
);
4568 handle_cp_pragma (pname
)
4573 if (! strcmp (pname
, "vtable"))
4575 extern tree pending_vtables
;
4577 /* More follows: it must be a string constant (class name). */
4578 token
= real_yylex ();
4579 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
4581 error ("invalid #pragma vtable");
4585 if (write_virtuals
!= 2)
4587 warning ("use `+e2' option to enable #pragma vtable");
4591 = perm_tree_cons (NULL_TREE
,
4592 get_identifier (TREE_STRING_POINTER (yylval
.ttype
)),
4594 token
= real_yylex ();
4595 if (token
!= END_OF_LINE
)
4596 warning ("trailing characters ignored");
4599 else if (! strcmp (pname
, "unit"))
4601 /* More follows: it must be a string constant (unit name). */
4602 token
= real_yylex ();
4603 if (token
!= STRING
|| TREE_CODE (yylval
.ttype
) != STRING_CST
)
4605 error ("invalid #pragma unit");
4608 token
= real_yylex ();
4609 if (token
!= END_OF_LINE
)
4610 warning ("trailing characters ignored");
4613 else if (! strcmp (pname
, "interface"))
4615 tree fileinfo
= IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename
));
4616 char *main_filename
= input_filename
;
4618 main_filename
= file_name_nondirectory (main_filename
);
4620 token
= real_yylex ();
4622 if (token
!= END_OF_LINE
)
4625 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
4627 error ("invalid `#pragma interface'");
4630 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
4631 token
= real_yylex ();
4634 if (token
!= END_OF_LINE
)
4635 warning ("garbage after `#pragma interface' ignored");
4637 #ifndef NO_LINKAGE_HEURISTICS
4640 if (impl_file_chain
== 0)
4642 /* If this is zero at this point, then we are
4643 auto-implementing. */
4644 if (main_input_filename
== 0)
4645 main_input_filename
= input_filename
;
4647 #ifdef AUTO_IMPLEMENT
4648 filename
= file_name_nondirectory (main_input_filename
);
4649 fi
= get_time_identifier (filename
);
4650 fi
= IDENTIFIER_CLASS_VALUE (fi
);
4651 TREE_INT_CST_LOW (fi
) = 0;
4652 TREE_INT_CST_HIGH (fi
) = 1;
4654 impl_file_chain
= (struct impl_files
*)permalloc (sizeof (struct impl_files
));
4655 impl_file_chain
->filename
= filename
;
4656 impl_file_chain
->next
= 0;
4660 interface_only
= interface_strcmp (main_filename
);
4661 interface_unknown
= 0;
4662 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
4663 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
4664 #endif /* NO_LINKAGE_HEURISTICS */
4668 else if (! strcmp (pname
, "implementation"))
4670 tree fileinfo
= IDENTIFIER_CLASS_VALUE (get_time_identifier (input_filename
));
4671 char *main_filename
= main_input_filename
? main_input_filename
: input_filename
;
4673 main_filename
= file_name_nondirectory (main_filename
);
4674 token
= real_yylex ();
4675 if (token
!= END_OF_LINE
)
4678 || TREE_CODE (yylval
.ttype
) != STRING_CST
)
4680 error ("invalid `#pragma implementation'");
4683 main_filename
= TREE_STRING_POINTER (yylval
.ttype
);
4684 token
= real_yylex ();
4687 if (token
!= END_OF_LINE
)
4688 warning ("garbage after `#pragma implementation' ignored");
4690 #ifndef NO_LINKAGE_HEURISTICS
4691 if (write_virtuals
== 3)
4693 struct impl_files
*ifiles
= impl_file_chain
;
4696 if (! strcmp (ifiles
->filename
, main_filename
))
4698 ifiles
= ifiles
->next
;
4702 ifiles
= (struct impl_files
*) permalloc (sizeof (struct impl_files
));
4703 ifiles
->filename
= main_filename
;
4704 ifiles
->next
= impl_file_chain
;
4705 impl_file_chain
= ifiles
;
4708 else if ((main_input_filename
!= 0
4709 && ! strcmp (main_input_filename
, input_filename
))
4710 || ! strcmp (input_filename
, main_filename
))
4713 if (impl_file_chain
== 0)
4715 impl_file_chain
= (struct impl_files
*) permalloc (sizeof (struct impl_files
));
4716 impl_file_chain
->filename
= main_filename
;
4717 impl_file_chain
->next
= 0;
4721 error ("`#pragma implementation' can only appear at top-level");
4724 /* We make this non-zero so that we infer decl linkage
4725 in the impl file only for variables first declared
4726 in the interface file. */
4727 interface_unknown
= 1;
4729 /* We make this zero so that templates in the impl
4730 file will be emitted properly. */
4731 interface_unknown
= 0;
4733 TREE_INT_CST_LOW (fileinfo
) = interface_only
;
4734 TREE_INT_CST_HIGH (fileinfo
) = interface_unknown
;
4735 #endif /* NO_LINKAGE_HEURISTICS */
4743 #ifdef HANDLE_SYSV_PRAGMA
4745 /* Handle a #pragma directive. INPUT is the current input stream,
4746 and C is a character to reread. Processes the entire input line
4747 and returns a character for the caller to reread: either \n or EOF. */
4749 /* This function has to be in this file, in order to get at
4753 handle_sysv_pragma (finput
, token
)
4765 handle_pragma_token ("ignored", yylval
.ttype
);
4768 handle_pragma_token ("(", NULL_TREE
);
4771 handle_pragma_token (")", NULL_TREE
);
4774 handle_pragma_token (",", NULL_TREE
);
4777 handle_pragma_token ("=", NULL_TREE
);
4780 handle_pragma_token ("(", NULL_TREE
);
4781 handle_pragma_token (")", NULL_TREE
);
4785 handle_pragma_token (NULL_PTR
, NULL_TREE
);
4788 token
= real_yylex ();
4791 #endif /* HANDLE_SYSV_PRAGMA */