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 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"
42 #include "splay-tree.h"
45 /* The current line map. */
46 static const struct line_map
*map
;
48 /* We may keep statistics about how long which files took to compile. */
49 static int header_time
, body_time
;
50 static splay_tree file_info_tree
;
52 #undef WCHAR_TYPE_SIZE
53 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
55 /* Number of bytes in a wide character. */
56 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
58 int pending_lang_change
; /* If we need to switch languages - C++ only */
59 int c_header_level
; /* depth in C headers - C++ only */
61 static tree
interpret_integer (const cpp_token
*, unsigned int);
62 static tree
interpret_float (const cpp_token
*, unsigned int);
63 static enum integer_type_kind
64 narrowest_unsigned_type (tree
, unsigned int);
65 static enum integer_type_kind
66 narrowest_signed_type (tree
, unsigned int);
67 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool);
68 static tree
lex_charconst (const cpp_token
*);
69 static void update_header_times (const char *);
70 static int dump_one_header (splay_tree_node
, void *);
71 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
72 static void cb_dir_change (cpp_reader
*, const char *);
73 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
74 static void cb_def_pragma (cpp_reader
*, unsigned int);
75 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
76 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
81 struct cpp_callbacks
*cb
;
82 struct c_fileinfo
*toplevel
;
84 /* Set up filename timing. Must happen before cpp_read_main_file. */
85 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
)strcmp
,
87 (splay_tree_delete_value_fn
)free
);
88 toplevel
= get_fileinfo ("<top level>");
89 if (flag_detailed_statistics
)
92 body_time
= get_run_time ();
93 toplevel
->time
= body_time
;
96 cb
= cpp_get_callbacks (parse_in
);
98 cb
->line_change
= cb_line_change
;
99 cb
->dir_change
= cb_dir_change
;
100 cb
->ident
= cb_ident
;
101 cb
->def_pragma
= cb_def_pragma
;
102 cb
->valid_pch
= c_common_valid_pch
;
103 cb
->read_pch
= c_common_read_pch
;
105 /* Set the debug callbacks if we can use them. */
106 if (debug_info_level
== DINFO_LEVEL_VERBOSE
107 && (write_symbols
== DWARF_DEBUG
|| write_symbols
== DWARF2_DEBUG
108 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
110 cb
->define
= cb_define
;
111 cb
->undef
= cb_undef
;
116 get_fileinfo (const char *name
)
119 struct c_fileinfo
*fi
;
121 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
123 return (struct c_fileinfo
*) n
->value
;
125 fi
= xmalloc (sizeof (struct c_fileinfo
));
127 fi
->interface_only
= 0;
128 fi
->interface_unknown
= 1;
129 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
130 (splay_tree_value
) fi
);
135 update_header_times (const char *name
)
137 /* Changing files again. This means currently collected time
138 is charged against header time, and body time starts back at 0. */
139 if (flag_detailed_statistics
)
141 int this_time
= get_run_time ();
142 struct c_fileinfo
*file
= get_fileinfo (name
);
143 header_time
+= this_time
- body_time
;
144 file
->time
+= this_time
- body_time
;
145 body_time
= this_time
;
150 dump_one_header (splay_tree_node n
, void *dummy ATTRIBUTE_UNUSED
)
152 print_time ((const char *) n
->key
,
153 ((struct c_fileinfo
*) n
->value
)->time
);
158 dump_time_statistics (void)
160 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
161 int this_time
= get_run_time ();
162 file
->time
+= this_time
- body_time
;
164 fprintf (stderr
, "\n******\n");
165 print_time ("header files (total)", header_time
);
166 print_time ("main file (total)", this_time
- body_time
);
167 fprintf (stderr
, "ratio = %g : 1\n",
168 (double)header_time
/ (double)(this_time
- body_time
));
169 fprintf (stderr
, "\n******\n");
171 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
175 cb_ident (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
176 unsigned int line ATTRIBUTE_UNUSED
,
177 const cpp_string
*str ATTRIBUTE_UNUSED
)
179 #ifdef ASM_OUTPUT_IDENT
182 /* Convert escapes in the string. */
183 cpp_string cstr
= { 0, 0 };
184 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, false))
186 ASM_OUTPUT_IDENT (asm_out_file
, (const char *) cstr
.text
);
187 free ((void *)cstr
.text
);
193 /* Called at the start of every non-empty line. TOKEN is the first
194 lexed token on the line. Used for diagnostic line numbers. */
196 cb_line_change (cpp_reader
*pfile ATTRIBUTE_UNUSED
, const cpp_token
*token
,
199 if (token
->type
== CPP_EOF
|| parsing_args
)
202 input_line
= SOURCE_LINE (map
, token
->line
);
206 cb_dir_change (cpp_reader
*pfile ATTRIBUTE_UNUSED
, const char *dir
)
208 if (! set_src_pwd (dir
))
209 warning ("too late for # directive to set debug directory");
213 fe_file_change (const struct line_map
*new_map
)
221 if (new_map
->reason
== LC_ENTER
)
223 /* Don't stack the main buffer on the input stack;
224 we already did in compile_file. */
226 main_input_filename
= new_map
->to_file
;
229 int included_at
= SOURCE_LINE (new_map
- 1, new_map
->from_line
- 1);
231 input_line
= included_at
;
232 push_srcloc (new_map
->to_file
, 1);
233 (*debug_hooks
->start_source_file
) (included_at
, new_map
->to_file
);
234 #ifndef NO_IMPLICIT_EXTERN_C
237 else if (new_map
->sysp
== 2)
240 ++pending_lang_change
;
245 else if (new_map
->reason
== LC_LEAVE
)
247 #ifndef NO_IMPLICIT_EXTERN_C
248 if (c_header_level
&& --c_header_level
== 0)
250 if (new_map
->sysp
== 2)
251 warning ("badly nested C headers from preprocessor");
252 --pending_lang_change
;
257 (*debug_hooks
->end_source_file
) (new_map
->to_line
);
260 update_header_times (new_map
->to_file
);
261 in_system_header
= new_map
->sysp
!= 0;
262 input_filename
= new_map
->to_file
;
263 input_line
= new_map
->to_line
;
267 extract_interface_info ();
271 cb_def_pragma (cpp_reader
*pfile
, unsigned int line
)
273 /* Issue a warning message if we have been asked to do so. Ignore
274 unknown pragmas in system headers unless an explicit
275 -Wunknown-pragmas has been given. */
276 if (warn_unknown_pragmas
> in_system_header
)
278 const unsigned char *space
, *name
;
281 space
= name
= (const unsigned char *) "";
282 s
= cpp_get_token (pfile
);
283 if (s
->type
!= CPP_EOF
)
285 space
= cpp_token_as_text (pfile
, s
);
286 s
= cpp_get_token (pfile
);
287 if (s
->type
== CPP_NAME
)
288 name
= cpp_token_as_text (pfile
, s
);
291 input_line
= SOURCE_LINE (map
, line
);
292 warning ("ignoring #pragma %s %s", space
, name
);
296 /* #define callback for DWARF and DWARF2 debug info. */
298 cb_define (cpp_reader
*pfile
, unsigned int line
, cpp_hashnode
*node
)
300 (*debug_hooks
->define
) (SOURCE_LINE (map
, line
),
301 (const char *) cpp_macro_definition (pfile
, node
));
304 /* #undef callback for DWARF and DWARF2 debug info. */
306 cb_undef (cpp_reader
*pfile ATTRIBUTE_UNUSED
, unsigned int line
,
309 (*debug_hooks
->undef
) (SOURCE_LINE (map
, line
),
310 (const char *) NODE_NAME (node
));
313 static inline const cpp_token
*
314 get_nonpadding_token (void)
316 const cpp_token
*tok
;
317 timevar_push (TV_CPP
);
319 tok
= cpp_get_token (parse_in
);
320 while (tok
->type
== CPP_PADDING
);
321 timevar_pop (TV_CPP
);
329 const cpp_token
*tok
;
331 static bool no_more_pch
;
334 tok
= get_nonpadding_token ();
340 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
345 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
347 switch (flags
& CPP_N_CATEGORY
)
350 /* cpplib has issued an error. */
351 *value
= error_mark_node
;
355 *value
= interpret_integer (tok
, flags
);
359 *value
= interpret_float (tok
, flags
);
369 /* An @ may give the next token special significance in Objective-C. */
370 atloc
= input_location
;
371 tok
= get_nonpadding_token ();
372 if (c_dialect_objc ())
378 val
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
379 if (C_IS_RESERVED_WORD (val
)
380 && OBJC_IS_AT_KEYWORD (C_RID_CODE (val
)))
389 return lex_string (tok
, value
, true);
396 error ("%Hstray '@' in program", &atloc
);
401 cppchar_t c
= tok
->val
.str
.text
[0];
403 if (c
== '"' || c
== '\'')
404 error ("missing terminating %c character", (int) c
);
405 else if (ISGRAPH (c
))
406 error ("stray '%c' in program", (int) c
);
408 error ("stray '\\%o' in program", (int) c
);
414 *value
= lex_charconst (tok
);
419 return lex_string (tok
, value
, false);
422 /* These tokens should not be visible outside cpplib. */
423 case CPP_HEADER_NAME
:
436 c_common_no_more_pch ();
442 /* Returns the narrowest C-visible unsigned type, starting with the
443 minimum specified by FLAGS, that can fit VALUE, or itk_none if
445 static enum integer_type_kind
446 narrowest_unsigned_type (tree value
, unsigned int flags
)
448 enum integer_type_kind itk
;
450 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
451 itk
= itk_unsigned_int
;
452 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
453 itk
= itk_unsigned_long
;
455 itk
= itk_unsigned_long_long
;
457 /* int_fits_type_p must think the type of its first argument is
458 wider than its second argument, or it won't do the proper check. */
459 TREE_TYPE (value
) = widest_unsigned_literal_type_node
;
461 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
462 if (int_fits_type_p (value
, integer_types
[itk
]))
468 /* Ditto, but narrowest signed type. */
469 static enum integer_type_kind
470 narrowest_signed_type (tree value
, unsigned int flags
)
472 enum integer_type_kind itk
;
474 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
476 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
481 /* int_fits_type_p must think the type of its first argument is
482 wider than its second argument, or it won't do the proper check. */
483 TREE_TYPE (value
) = widest_unsigned_literal_type_node
;
485 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
486 if (int_fits_type_p (value
, integer_types
[itk
]))
492 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
494 interpret_integer (const cpp_token
*token
, unsigned int flags
)
497 enum integer_type_kind itk
;
499 cpp_options
*options
= cpp_get_options (parse_in
);
501 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
502 integer
= cpp_num_sign_extend (integer
, options
->precision
);
503 value
= build_int_2_wide (integer
.low
, integer
.high
);
505 /* The type of a constant with a U suffix is straightforward. */
506 if (flags
& CPP_N_UNSIGNED
)
507 itk
= narrowest_unsigned_type (value
, flags
);
510 /* The type of a potentially-signed integer constant varies
511 depending on the base it's in, the standard in use, and the
513 enum integer_type_kind itk_u
= narrowest_unsigned_type (value
, flags
);
514 enum integer_type_kind itk_s
= narrowest_signed_type (value
, flags
);
516 /* In both C89 and C99, octal and hex constants may be signed or
517 unsigned, whichever fits tighter. We do not warn about this
518 choice differing from the traditional choice, as the constant
519 is probably a bit pattern and either way will work. */
520 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
521 itk
= MIN (itk_u
, itk_s
);
524 /* In C99, decimal constants are always signed.
525 In C89, decimal constants that don't fit in long have
526 undefined behavior; we try to make them unsigned long.
527 In GCC's extended C89, that last is true of decimal
528 constants that don't fit in long long, too. */
531 if (itk_s
> itk_u
&& itk_s
> itk_long
)
535 if (itk_u
< itk_unsigned_long
)
536 itk_u
= itk_unsigned_long
;
538 warning ("this decimal constant is unsigned only in ISO C90");
540 else if (warn_traditional
)
541 warning ("this decimal constant would be unsigned in ISO C90");
547 /* cpplib has already issued a warning for overflow. */
548 type
= ((flags
& CPP_N_UNSIGNED
)
549 ? widest_unsigned_literal_type_node
550 : widest_integer_literal_type_node
);
552 type
= integer_types
[itk
];
554 if (itk
> itk_unsigned_long
555 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
556 && ! in_system_header
&& ! flag_isoc99
)
557 pedwarn ("integer constant is too large for \"%s\" type",
558 (flags
& CPP_N_UNSIGNED
) ? "unsigned long" : "long");
560 TREE_TYPE (value
) = type
;
562 /* Convert imaginary to a complex type. */
563 if (flags
& CPP_N_IMAGINARY
)
564 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
569 /* Interpret TOKEN, a floating point number with FLAGS as classified
572 interpret_float (const cpp_token
*token
, unsigned int flags
)
576 REAL_VALUE_TYPE real
;
579 const char *typename
;
581 /* FIXME: make %T work in error/warning, then we don't need typename. */
582 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
584 type
= long_double_type_node
;
585 typename
= "long double";
587 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
588 || flag_single_precision_constant
)
590 type
= float_type_node
;
595 type
= double_type_node
;
599 /* Copy the constant to a nul-terminated buffer. If the constant
600 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
601 can't handle them. */
602 copylen
= token
->val
.str
.len
;
603 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
604 /* Must be an F or L suffix. */
606 if (flags
& CPP_N_IMAGINARY
)
610 copy
= alloca (copylen
+ 1);
611 memcpy (copy
, token
->val
.str
.text
, copylen
);
612 copy
[copylen
] = '\0';
614 real_from_string (&real
, copy
);
615 real_convert (&real
, TYPE_MODE (type
), &real
);
617 /* A diagnostic is required for "soft" overflow by some ISO C
618 testsuites. This is not pedwarn, because some people don't want
620 ??? That's a dubious reason... is this a mandatory diagnostic or
621 isn't it? -- zw, 2001-08-21. */
622 if (REAL_VALUE_ISINF (real
) && pedantic
)
623 warning ("floating constant exceeds range of \"%s\"", typename
);
625 /* Create a node with determined type and value. */
626 value
= build_real (type
, real
);
627 if (flags
& CPP_N_IMAGINARY
)
628 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
633 /* Convert a series of STRING and/or WSTRING tokens into a tree,
634 performing string constant concatenation. TOK is the first of
635 these. VALP is the location to write the string into. OBJC_STRING
636 indicates whether an '@' token preceded the incoming token.
637 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
640 This is unfortunately more work than it should be. If any of the
641 strings in the series has an L prefix, the result is a wide string
642 (6.4.5p4). Whether or not the result is a wide string affects the
643 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
644 sequences do not continue across the boundary between two strings in
645 a series (6.4.5p7), so we must not lose the boundaries. Therefore
646 cpp_interpret_string takes a vector of cpp_string structures, which
647 we must arrange to provide. */
649 static enum cpp_ttype
650 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
)
655 struct obstack str_ob
;
658 /* Try to avoid the overhead of creating and destroying an obstack
659 for the common case of just one string. */
660 cpp_string str
= tok
->val
.str
;
661 cpp_string
*strs
= &str
;
663 if (tok
->type
== CPP_WSTRING
)
666 tok
= get_nonpadding_token ();
667 if (c_dialect_objc () && tok
->type
== CPP_ATSIGN
)
670 tok
= get_nonpadding_token ();
672 if (tok
->type
== CPP_STRING
|| tok
->type
== CPP_WSTRING
)
674 gcc_obstack_init (&str_ob
);
675 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
680 if (tok
->type
== CPP_WSTRING
)
682 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
684 tok
= get_nonpadding_token ();
685 if (c_dialect_objc () && tok
->type
== CPP_ATSIGN
)
688 tok
= get_nonpadding_token ();
691 while (tok
->type
== CPP_STRING
|| tok
->type
== CPP_WSTRING
);
692 strs
= obstack_finish (&str_ob
);
695 /* We have read one more token than we want. */
696 _cpp_backup_tokens (parse_in
, 1);
698 if (count
> 1 && !objc_string
&& warn_traditional
&& !in_system_header
)
699 warning ("traditional C rejects string constant concatenation");
701 if (cpp_interpret_string (parse_in
, strs
, count
, &istr
, wide
))
703 value
= build_string (istr
.len
, (char *)istr
.text
);
704 free ((void *)istr
.text
);
708 /* Callers cannot generally handle error_mark_node in this context,
709 so return the empty string instead. cpp_interpret_string has
712 value
= build_string (TYPE_PRECISION (wchar_type_node
)
713 / TYPE_PRECISION (char_type_node
),
714 "\0\0\0"); /* widest supported wchar_t
717 value
= build_string (1, "");
720 TREE_TYPE (value
) = wide
? wchar_array_type_node
: char_array_type_node
;
721 *valp
= fix_string_type (value
);
724 obstack_free (&str_ob
, 0);
726 return objc_string
? CPP_OBJC_STRING
: wide
? CPP_WSTRING
: CPP_STRING
;
729 /* Converts a (possibly wide) character constant token into a tree. */
731 lex_charconst (const cpp_token
*token
)
735 unsigned int chars_seen
;
738 result
= cpp_interpret_charconst (parse_in
, token
,
739 &chars_seen
, &unsignedp
);
741 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
742 before possibly widening to HOST_WIDE_INT for build_int_2. */
743 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
744 value
= build_int_2 (result
, 0);
746 value
= build_int_2 ((cppchar_signed_t
) result
, -1);
748 if (token
->type
== CPP_WCHAR
)
749 type
= wchar_type_node
;
750 /* In C, a character constant has type 'int'.
751 In C++ 'char', but multi-char charconsts have type 'int'. */
752 else if (!c_dialect_cxx () || chars_seen
> 1)
753 type
= integer_type_node
;
755 type
= char_type_node
;
757 TREE_TYPE (value
) = type
;