1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
41 #include "splay-tree.h"
44 /* We may keep statistics about how long which files took to compile. */
45 static int header_time
, body_time
;
46 static splay_tree file_info_tree
;
48 #undef WCHAR_TYPE_SIZE
49 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
51 /* Number of bytes in a wide character. */
52 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
54 int pending_lang_change
; /* If we need to switch languages - C++ only */
55 int c_header_level
; /* depth in C headers - C++ only */
56 bool c_lex_string_translate
= true; /* If we need to translate characters received. */
58 static tree
interpret_integer (const cpp_token
*, unsigned int);
59 static tree
interpret_float (const cpp_token
*, unsigned int);
60 static enum integer_type_kind
61 narrowest_unsigned_type (tree
, unsigned int);
62 static enum integer_type_kind
63 narrowest_signed_type (tree
, unsigned int);
64 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool);
65 static tree
lex_charconst (const cpp_token
*);
66 static void update_header_times (const char *);
67 static int dump_one_header (splay_tree_node
, void *);
68 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
69 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
70 static void cb_def_pragma (cpp_reader
*, unsigned int);
71 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
72 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
77 struct cpp_callbacks
*cb
;
78 struct c_fileinfo
*toplevel
;
80 /* Set up filename timing. Must happen before cpp_read_main_file. */
81 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
)strcmp
,
83 (splay_tree_delete_value_fn
)free
);
84 toplevel
= get_fileinfo ("<top level>");
85 if (flag_detailed_statistics
)
88 body_time
= get_run_time ();
89 toplevel
->time
= body_time
;
92 cb
= cpp_get_callbacks (parse_in
);
94 cb
->line_change
= cb_line_change
;
96 cb
->def_pragma
= cb_def_pragma
;
97 cb
->valid_pch
= c_common_valid_pch
;
98 cb
->read_pch
= c_common_read_pch
;
100 /* Set the debug callbacks if we can use them. */
101 if (debug_info_level
== DINFO_LEVEL_VERBOSE
102 && (write_symbols
== DWARF_DEBUG
|| write_symbols
== DWARF2_DEBUG
103 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
105 cb
->define
= cb_define
;
106 cb
->undef
= cb_undef
;
111 get_fileinfo (const char *name
)
114 struct c_fileinfo
*fi
;
116 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
118 return (struct c_fileinfo
*) n
->value
;
120 fi
= xmalloc (sizeof (struct c_fileinfo
));
122 fi
->interface_only
= 0;
123 fi
->interface_unknown
= 1;
124 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
125 (splay_tree_value
) fi
);
130 update_header_times (const char *name
)
132 /* Changing files again. This means currently collected time
133 is charged against header time, and body time starts back at 0. */
134 if (flag_detailed_statistics
)
136 int this_time
= get_run_time ();
137 struct c_fileinfo
*file
= get_fileinfo (name
);
138 header_time
+= this_time
- body_time
;
139 file
->time
+= this_time
- body_time
;
140 body_time
= this_time
;
145 dump_one_header (splay_tree_node n
, void *dummy ATTRIBUTE_UNUSED
)
147 print_time ((const char *) n
->key
,
148 ((struct c_fileinfo
*) n
->value
)->time
);
153 dump_time_statistics (void)
155 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
156 int this_time
= get_run_time ();
157 file
->time
+= this_time
- body_time
;
159 fprintf (stderr
, "\n******\n");
160 print_time ("header files (total)", header_time
);
161 print_time ("main file (total)", this_time
- body_time
);
162 fprintf (stderr
, "ratio = %g : 1\n",
163 (double)header_time
/ (double)(this_time
- body_time
));
164 fprintf (stderr
, "\n******\n");
166 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
170 cb_ident (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
171 unsigned int line ATTRIBUTE_UNUSED
,
172 const cpp_string
*str ATTRIBUTE_UNUSED
)
174 #ifdef ASM_OUTPUT_IDENT
177 /* Convert escapes in the string. */
178 cpp_string cstr
= { 0, 0 };
179 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, false))
181 ASM_OUTPUT_IDENT (asm_out_file
, (const char *) cstr
.text
);
182 free ((void *)cstr
.text
);
188 /* Called at the start of every non-empty line. TOKEN is the first
189 lexed token on the line. Used for diagnostic line numbers. */
191 cb_line_change (cpp_reader
*pfile ATTRIBUTE_UNUSED
, const cpp_token
*token
,
194 if (token
->type
!= CPP_EOF
&& !parsing_args
)
196 source_location loc
= token
->src_loc
;
197 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
198 input_line
= SOURCE_LINE (map
, loc
);
203 fe_file_change (const struct line_map
*new_map
)
208 if (new_map
->reason
== LC_ENTER
)
210 /* Don't stack the main buffer on the input stack;
211 we already did in compile_file. */
212 if (! MAIN_FILE_P (new_map
))
214 int included_at
= LAST_SOURCE_LINE (new_map
- 1);
216 input_line
= included_at
;
217 push_srcloc (new_map
->to_file
, 1);
218 (*debug_hooks
->start_source_file
) (included_at
, new_map
->to_file
);
219 #ifndef NO_IMPLICIT_EXTERN_C
222 else if (new_map
->sysp
== 2)
225 ++pending_lang_change
;
230 else if (new_map
->reason
== LC_LEAVE
)
232 #ifndef NO_IMPLICIT_EXTERN_C
233 if (c_header_level
&& --c_header_level
== 0)
235 if (new_map
->sysp
== 2)
236 warning ("badly nested C headers from preprocessor");
237 --pending_lang_change
;
242 (*debug_hooks
->end_source_file
) (new_map
->to_line
);
245 update_header_times (new_map
->to_file
);
246 in_system_header
= new_map
->sysp
!= 0;
247 input_filename
= new_map
->to_file
;
248 input_line
= new_map
->to_line
;
251 extract_interface_info ();
255 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
257 /* Issue a warning message if we have been asked to do so. Ignore
258 unknown pragmas in system headers unless an explicit
259 -Wunknown-pragmas has been given. */
260 if (warn_unknown_pragmas
> in_system_header
)
262 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
263 const unsigned char *space
, *name
;
266 space
= name
= (const unsigned char *) "";
267 s
= cpp_get_token (pfile
);
268 if (s
->type
!= CPP_EOF
)
270 space
= cpp_token_as_text (pfile
, s
);
271 s
= cpp_get_token (pfile
);
272 if (s
->type
== CPP_NAME
)
273 name
= cpp_token_as_text (pfile
, s
);
276 input_line
= SOURCE_LINE (map
, loc
);
277 warning ("ignoring #pragma %s %s", space
, name
);
281 /* #define callback for DWARF and DWARF2 debug info. */
283 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
285 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
286 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
287 (const char *) cpp_macro_definition (pfile
, node
));
290 /* #undef callback for DWARF and DWARF2 debug info. */
292 cb_undef (cpp_reader
*pfile ATTRIBUTE_UNUSED
, source_location loc
,
295 const struct line_map
*map
= linemap_lookup (&line_table
, loc
);
296 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
297 (const char *) NODE_NAME (node
));
300 static inline const cpp_token
*
301 get_nonpadding_token (void)
303 const cpp_token
*tok
;
304 timevar_push (TV_CPP
);
306 tok
= cpp_get_token (parse_in
);
307 while (tok
->type
== CPP_PADDING
);
308 timevar_pop (TV_CPP
);
314 c_lex_with_flags (tree
*value
, unsigned char *cpp_flags
)
316 const cpp_token
*tok
;
318 static bool no_more_pch
;
321 tok
= get_nonpadding_token ();
327 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
332 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
334 switch (flags
& CPP_N_CATEGORY
)
337 /* cpplib has issued an error. */
338 *value
= error_mark_node
;
342 *value
= interpret_integer (tok
, flags
);
346 *value
= interpret_float (tok
, flags
);
356 /* An @ may give the next token special significance in Objective-C. */
357 atloc
= input_location
;
358 tok
= get_nonpadding_token ();
359 if (c_dialect_objc ())
365 val
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
366 if (C_IS_RESERVED_WORD (val
)
367 && OBJC_IS_AT_KEYWORD (C_RID_CODE (val
)))
376 return lex_string (tok
, value
, true);
383 error ("%Hstray '@' in program", &atloc
);
388 cppchar_t c
= tok
->val
.str
.text
[0];
390 if (c
== '"' || c
== '\'')
391 error ("missing terminating %c character", (int) c
);
392 else if (ISGRAPH (c
))
393 error ("stray '%c' in program", (int) c
);
395 error ("stray '\\%o' in program", (int) c
);
401 *value
= lex_charconst (tok
);
406 return lex_string (tok
, value
, false);
409 /* These tokens should not be visible outside cpplib. */
410 case CPP_HEADER_NAME
:
423 c_common_no_more_pch ();
427 *cpp_flags
= tok
->flags
;
434 return c_lex_with_flags (value
, NULL
);
437 /* Returns the narrowest C-visible unsigned type, starting with the
438 minimum specified by FLAGS, that can fit VALUE, or itk_none if
440 static enum integer_type_kind
441 narrowest_unsigned_type (tree value
, unsigned int flags
)
443 enum integer_type_kind itk
;
445 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
446 itk
= itk_unsigned_int
;
447 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
448 itk
= itk_unsigned_long
;
450 itk
= itk_unsigned_long_long
;
452 /* int_fits_type_p must think the type of its first argument is
453 wider than its second argument, or it won't do the proper check. */
454 TREE_TYPE (value
) = widest_unsigned_literal_type_node
;
456 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
457 if (int_fits_type_p (value
, integer_types
[itk
]))
463 /* Ditto, but narrowest signed type. */
464 static enum integer_type_kind
465 narrowest_signed_type (tree value
, unsigned int flags
)
467 enum integer_type_kind itk
;
469 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
471 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
476 /* int_fits_type_p must think the type of its first argument is
477 wider than its second argument, or it won't do the proper check. */
478 TREE_TYPE (value
) = widest_unsigned_literal_type_node
;
480 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
481 if (int_fits_type_p (value
, integer_types
[itk
]))
487 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
489 interpret_integer (const cpp_token
*token
, unsigned int flags
)
492 enum integer_type_kind itk
;
494 cpp_options
*options
= cpp_get_options (parse_in
);
496 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
497 integer
= cpp_num_sign_extend (integer
, options
->precision
);
498 value
= build_int_2_wide (integer
.low
, integer
.high
);
500 /* The type of a constant with a U suffix is straightforward. */
501 if (flags
& CPP_N_UNSIGNED
)
502 itk
= narrowest_unsigned_type (value
, flags
);
505 /* The type of a potentially-signed integer constant varies
506 depending on the base it's in, the standard in use, and the
508 enum integer_type_kind itk_u
= narrowest_unsigned_type (value
, flags
);
509 enum integer_type_kind itk_s
= narrowest_signed_type (value
, flags
);
511 /* In both C89 and C99, octal and hex constants may be signed or
512 unsigned, whichever fits tighter. We do not warn about this
513 choice differing from the traditional choice, as the constant
514 is probably a bit pattern and either way will work. */
515 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
516 itk
= MIN (itk_u
, itk_s
);
519 /* In C99, decimal constants are always signed.
520 In C89, decimal constants that don't fit in long have
521 undefined behavior; we try to make them unsigned long.
522 In GCC's extended C89, that last is true of decimal
523 constants that don't fit in long long, too. */
526 if (itk_s
> itk_u
&& itk_s
> itk_long
)
530 if (itk_u
< itk_unsigned_long
)
531 itk_u
= itk_unsigned_long
;
533 warning ("this decimal constant is unsigned only in ISO C90");
535 else if (warn_traditional
)
536 warning ("this decimal constant would be unsigned in ISO C90");
542 /* cpplib has already issued a warning for overflow. */
543 type
= ((flags
& CPP_N_UNSIGNED
)
544 ? widest_unsigned_literal_type_node
545 : widest_integer_literal_type_node
);
547 type
= integer_types
[itk
];
549 if (itk
> itk_unsigned_long
550 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
551 && ! in_system_header
&& ! flag_isoc99
)
552 pedwarn ("integer constant is too large for \"%s\" type",
553 (flags
& CPP_N_UNSIGNED
) ? "unsigned long" : "long");
555 TREE_TYPE (value
) = type
;
557 /* Convert imaginary to a complex type. */
558 if (flags
& CPP_N_IMAGINARY
)
559 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
564 /* Interpret TOKEN, a floating point number with FLAGS as classified
567 interpret_float (const cpp_token
*token
, unsigned int flags
)
571 REAL_VALUE_TYPE real
;
574 const char *typename
;
576 /* FIXME: make %T work in error/warning, then we don't need typename. */
577 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
579 type
= long_double_type_node
;
580 typename
= "long double";
582 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
583 || flag_single_precision_constant
)
585 type
= float_type_node
;
590 type
= double_type_node
;
594 /* Copy the constant to a nul-terminated buffer. If the constant
595 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
596 can't handle them. */
597 copylen
= token
->val
.str
.len
;
598 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
599 /* Must be an F or L suffix. */
601 if (flags
& CPP_N_IMAGINARY
)
605 copy
= alloca (copylen
+ 1);
606 memcpy (copy
, token
->val
.str
.text
, copylen
);
607 copy
[copylen
] = '\0';
609 real_from_string (&real
, copy
);
610 real_convert (&real
, TYPE_MODE (type
), &real
);
612 /* A diagnostic is required for "soft" overflow by some ISO C
613 testsuites. This is not pedwarn, because some people don't want
615 ??? That's a dubious reason... is this a mandatory diagnostic or
616 isn't it? -- zw, 2001-08-21. */
617 if (REAL_VALUE_ISINF (real
) && pedantic
)
618 warning ("floating constant exceeds range of \"%s\"", typename
);
620 /* Create a node with determined type and value. */
621 value
= build_real (type
, real
);
622 if (flags
& CPP_N_IMAGINARY
)
623 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
628 /* Convert a series of STRING and/or WSTRING tokens into a tree,
629 performing string constant concatenation. TOK is the first of
630 these. VALP is the location to write the string into. OBJC_STRING
631 indicates whether an '@' token preceded the incoming token.
632 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
635 This is unfortunately more work than it should be. If any of the
636 strings in the series has an L prefix, the result is a wide string
637 (6.4.5p4). Whether or not the result is a wide string affects the
638 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
639 sequences do not continue across the boundary between two strings in
640 a series (6.4.5p7), so we must not lose the boundaries. Therefore
641 cpp_interpret_string takes a vector of cpp_string structures, which
642 we must arrange to provide. */
644 static enum cpp_ttype
645 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
)
650 struct obstack str_ob
;
653 /* Try to avoid the overhead of creating and destroying an obstack
654 for the common case of just one string. */
655 cpp_string str
= tok
->val
.str
;
656 cpp_string
*strs
= &str
;
658 if (tok
->type
== CPP_WSTRING
)
661 tok
= get_nonpadding_token ();
662 if (c_dialect_objc () && tok
->type
== CPP_ATSIGN
)
665 tok
= get_nonpadding_token ();
667 if (tok
->type
== CPP_STRING
|| tok
->type
== CPP_WSTRING
)
669 gcc_obstack_init (&str_ob
);
670 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
675 if (tok
->type
== CPP_WSTRING
)
677 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
679 tok
= get_nonpadding_token ();
680 if (c_dialect_objc () && tok
->type
== CPP_ATSIGN
)
683 tok
= get_nonpadding_token ();
686 while (tok
->type
== CPP_STRING
|| tok
->type
== CPP_WSTRING
);
687 strs
= obstack_finish (&str_ob
);
690 /* We have read one more token than we want. */
691 _cpp_backup_tokens (parse_in
, 1);
693 if (count
> 1 && !objc_string
&& warn_traditional
&& !in_system_header
)
694 warning ("traditional C rejects string constant concatenation");
696 if ((c_lex_string_translate
697 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
698 (parse_in
, strs
, count
, &istr
, wide
))
700 value
= build_string (istr
.len
, (char *)istr
.text
);
701 free ((void *)istr
.text
);
705 /* Callers cannot generally handle error_mark_node in this context,
706 so return the empty string instead. cpp_interpret_string has
709 value
= build_string (TYPE_PRECISION (wchar_type_node
)
710 / TYPE_PRECISION (char_type_node
),
711 "\0\0\0"); /* widest supported wchar_t
714 value
= build_string (1, "");
717 TREE_TYPE (value
) = wide
? wchar_array_type_node
: char_array_type_node
;
718 *valp
= fix_string_type (value
);
721 obstack_free (&str_ob
, 0);
723 return objc_string
? CPP_OBJC_STRING
: wide
? CPP_WSTRING
: CPP_STRING
;
726 /* Converts a (possibly wide) character constant token into a tree. */
728 lex_charconst (const cpp_token
*token
)
732 unsigned int chars_seen
;
735 result
= cpp_interpret_charconst (parse_in
, token
,
736 &chars_seen
, &unsignedp
);
738 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
739 before possibly widening to HOST_WIDE_INT for build_int_2. */
740 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
741 value
= build_int_2 (result
, 0);
743 value
= build_int_2 ((cppchar_signed_t
) result
, -1);
745 if (token
->type
== CPP_WCHAR
)
746 type
= wchar_type_node
;
747 /* In C, a character constant has type 'int'.
748 In C++ 'char', but multi-char charconsts have type 'int'. */
749 else if (!c_dialect_cxx () || chars_seen
> 1)
750 type
= integer_type_node
;
752 type
= char_type_node
;
754 TREE_TYPE (value
) = type
;