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 /* The line used to refresh the lineno global variable after each token. */
49 static unsigned int src_lineno
;
51 /* We may keep statistics about how long which files took to compile. */
52 static int header_time
, body_time
;
53 static splay_tree file_info_tree
;
55 #undef WCHAR_TYPE_SIZE
56 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
58 /* Number of bytes in a wide character. */
59 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
61 int pending_lang_change
; /* If we need to switch languages - C++ only */
62 int c_header_level
; /* depth in C headers - C++ only */
64 static tree
interpret_integer (const cpp_token
*, unsigned int);
65 static tree
interpret_float (const cpp_token
*, unsigned int);
66 static enum integer_type_kind
67 narrowest_unsigned_type (tree
, unsigned int);
68 static enum integer_type_kind
69 narrowest_signed_type (tree
, unsigned int);
70 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool);
71 static tree
lex_charconst (const cpp_token
*);
72 static void update_header_times (const char *);
73 static int dump_one_header (splay_tree_node
, void *);
74 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
75 static void cb_dir_change (cpp_reader
*, const char *);
76 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
77 static void cb_def_pragma (cpp_reader
*, unsigned int);
78 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
79 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
84 struct cpp_callbacks
*cb
;
85 struct c_fileinfo
*toplevel
;
87 /* Set up filename timing. Must happen before cpp_read_main_file. */
88 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
)strcmp
,
90 (splay_tree_delete_value_fn
)free
);
91 toplevel
= get_fileinfo ("<top level>");
92 if (flag_detailed_statistics
)
95 body_time
= get_run_time ();
96 toplevel
->time
= body_time
;
99 cb
= cpp_get_callbacks (parse_in
);
101 cb
->line_change
= cb_line_change
;
102 cb
->dir_change
= cb_dir_change
;
103 cb
->ident
= cb_ident
;
104 cb
->def_pragma
= cb_def_pragma
;
105 cb
->valid_pch
= c_common_valid_pch
;
106 cb
->read_pch
= c_common_read_pch
;
108 /* Set the debug callbacks if we can use them. */
109 if (debug_info_level
== DINFO_LEVEL_VERBOSE
110 && (write_symbols
== DWARF_DEBUG
|| write_symbols
== DWARF2_DEBUG
111 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
113 cb
->define
= cb_define
;
114 cb
->undef
= cb_undef
;
119 get_fileinfo (const char *name
)
122 struct c_fileinfo
*fi
;
124 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
126 return (struct c_fileinfo
*) n
->value
;
128 fi
= xmalloc (sizeof (struct c_fileinfo
));
130 fi
->interface_only
= 0;
131 fi
->interface_unknown
= 1;
132 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
133 (splay_tree_value
) fi
);
138 update_header_times (const char *name
)
140 /* Changing files again. This means currently collected time
141 is charged against header time, and body time starts back at 0. */
142 if (flag_detailed_statistics
)
144 int this_time
= get_run_time ();
145 struct c_fileinfo
*file
= get_fileinfo (name
);
146 header_time
+= this_time
- body_time
;
147 file
->time
+= this_time
- body_time
;
148 body_time
= this_time
;
153 dump_one_header (splay_tree_node n
, void *dummy ATTRIBUTE_UNUSED
)
155 print_time ((const char *) n
->key
,
156 ((struct c_fileinfo
*) n
->value
)->time
);
161 dump_time_statistics (void)
163 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
164 int this_time
= get_run_time ();
165 file
->time
+= this_time
- body_time
;
167 fprintf (stderr
, "\n******\n");
168 print_time ("header files (total)", header_time
);
169 print_time ("main file (total)", this_time
- body_time
);
170 fprintf (stderr
, "ratio = %g : 1\n",
171 (double)header_time
/ (double)(this_time
- body_time
));
172 fprintf (stderr
, "\n******\n");
174 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
178 cb_ident (cpp_reader
*pfile ATTRIBUTE_UNUSED
,
179 unsigned int line ATTRIBUTE_UNUSED
,
180 const cpp_string
*str ATTRIBUTE_UNUSED
)
182 #ifdef ASM_OUTPUT_IDENT
185 /* Convert escapes in the string. */
186 cpp_string cstr
= { 0, 0 };
187 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, false))
189 ASM_OUTPUT_IDENT (asm_out_file
, (const char *) cstr
.text
);
190 free ((void *)cstr
.text
);
196 /* Called at the start of every non-empty line. TOKEN is the first
197 lexed token on the line. Used for diagnostic line numbers. */
199 cb_line_change (cpp_reader
*pfile ATTRIBUTE_UNUSED
, const cpp_token
*token
,
200 int parsing_args ATTRIBUTE_UNUSED
)
202 src_lineno
= 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
)
215 unsigned int to_line
= SOURCE_LINE (new_map
, new_map
->to_line
);
217 if (new_map
->reason
== LC_ENTER
)
219 /* Don't stack the main buffer on the input stack;
220 we already did in compile_file. */
222 main_input_filename
= new_map
->to_file
;
225 int included_at
= SOURCE_LINE (new_map
- 1, new_map
->from_line
- 1);
227 input_line
= included_at
;
228 push_srcloc (new_map
->to_file
, 1);
229 (*debug_hooks
->start_source_file
) (included_at
, new_map
->to_file
);
230 #ifndef NO_IMPLICIT_EXTERN_C
233 else if (new_map
->sysp
== 2)
236 ++pending_lang_change
;
241 else if (new_map
->reason
== LC_LEAVE
)
243 #ifndef NO_IMPLICIT_EXTERN_C
244 if (c_header_level
&& --c_header_level
== 0)
246 if (new_map
->sysp
== 2)
247 warning ("badly nested C headers from preprocessor");
248 --pending_lang_change
;
253 (*debug_hooks
->end_source_file
) (to_line
);
256 update_header_times (new_map
->to_file
);
257 in_system_header
= new_map
->sysp
!= 0;
258 input_filename
= new_map
->to_file
;
259 input_line
= to_line
;
263 extract_interface_info ();
267 cb_def_pragma (cpp_reader
*pfile
, unsigned int line
)
269 /* Issue a warning message if we have been asked to do so. Ignore
270 unknown pragmas in system headers unless an explicit
271 -Wunknown-pragmas has been given. */
272 if (warn_unknown_pragmas
> in_system_header
)
274 const unsigned char *space
, *name
;
277 space
= name
= (const unsigned char *) "";
278 s
= cpp_get_token (pfile
);
279 if (s
->type
!= CPP_EOF
)
281 space
= cpp_token_as_text (pfile
, s
);
282 s
= cpp_get_token (pfile
);
283 if (s
->type
== CPP_NAME
)
284 name
= cpp_token_as_text (pfile
, s
);
287 input_line
= SOURCE_LINE (map
, line
);
288 warning ("ignoring #pragma %s %s", space
, name
);
292 /* #define callback for DWARF and DWARF2 debug info. */
294 cb_define (cpp_reader
*pfile
, unsigned int line
, cpp_hashnode
*node
)
296 (*debug_hooks
->define
) (SOURCE_LINE (map
, line
),
297 (const char *) cpp_macro_definition (pfile
, node
));
300 /* #undef callback for DWARF and DWARF2 debug info. */
302 cb_undef (cpp_reader
*pfile ATTRIBUTE_UNUSED
, unsigned int line
,
305 (*debug_hooks
->undef
) (SOURCE_LINE (map
, line
),
306 (const char *) NODE_NAME (node
));
309 static inline const cpp_token
*
310 get_nonpadding_token (void)
312 const cpp_token
*tok
;
313 timevar_push (TV_CPP
);
315 tok
= cpp_get_token (parse_in
);
316 while (tok
->type
== CPP_PADDING
);
317 timevar_pop (TV_CPP
);
319 /* The C++ front end does horrible things with the current line
320 number. To ensure an accurate line number, we must reset it
321 every time we advance a token. */
322 input_line
= src_lineno
;
330 const cpp_token
*tok
;
332 static bool no_more_pch
;
335 tok
= get_nonpadding_token ();
341 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
346 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
348 switch (flags
& CPP_N_CATEGORY
)
351 /* cpplib has issued an error. */
352 *value
= error_mark_node
;
356 *value
= interpret_integer (tok
, flags
);
360 *value
= interpret_float (tok
, flags
);
370 /* An @ may give the next token special significance in Objective-C. */
371 atloc
= input_location
;
372 tok
= get_nonpadding_token ();
373 if (c_dialect_objc ())
379 val
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
));
380 if (C_IS_RESERVED_WORD (val
)
381 && OBJC_IS_AT_KEYWORD (C_RID_CODE (val
)))
390 return lex_string (tok
, value
, true);
397 error ("%Hstray '@' in program", &atloc
);
402 cppchar_t c
= tok
->val
.str
.text
[0];
404 if (c
== '"' || c
== '\'')
405 error ("missing terminating %c character", (int) c
);
406 else if (ISGRAPH (c
))
407 error ("stray '%c' in program", (int) c
);
409 error ("stray '\\%o' in program", (int) c
);
415 *value
= lex_charconst (tok
);
420 return lex_string (tok
, value
, false);
423 /* These tokens should not be visible outside cpplib. */
424 case CPP_HEADER_NAME
:
437 c_common_no_more_pch ();
443 /* Returns the narrowest C-visible unsigned type, starting with the
444 minimum specified by FLAGS, that can fit VALUE, or itk_none if
446 static enum integer_type_kind
447 narrowest_unsigned_type (tree value
, unsigned int flags
)
449 enum integer_type_kind itk
;
451 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
452 itk
= itk_unsigned_int
;
453 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
454 itk
= itk_unsigned_long
;
456 itk
= itk_unsigned_long_long
;
458 /* int_fits_type_p must think the type of its first argument is
459 wider than its second argument, or it won't do the proper check. */
460 TREE_TYPE (value
) = widest_unsigned_literal_type_node
;
462 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
463 if (int_fits_type_p (value
, integer_types
[itk
]))
469 /* Ditto, but narrowest signed type. */
470 static enum integer_type_kind
471 narrowest_signed_type (tree value
, unsigned int flags
)
473 enum integer_type_kind itk
;
475 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
477 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
482 /* int_fits_type_p must think the type of its first argument is
483 wider than its second argument, or it won't do the proper check. */
484 TREE_TYPE (value
) = widest_unsigned_literal_type_node
;
486 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
487 if (int_fits_type_p (value
, integer_types
[itk
]))
493 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
495 interpret_integer (const cpp_token
*token
, unsigned int flags
)
498 enum integer_type_kind itk
;
500 cpp_options
*options
= cpp_get_options (parse_in
);
502 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
503 integer
= cpp_num_sign_extend (integer
, options
->precision
);
504 value
= build_int_2_wide (integer
.low
, integer
.high
);
506 /* The type of a constant with a U suffix is straightforward. */
507 if (flags
& CPP_N_UNSIGNED
)
508 itk
= narrowest_unsigned_type (value
, flags
);
511 /* The type of a potentially-signed integer constant varies
512 depending on the base it's in, the standard in use, and the
514 enum integer_type_kind itk_u
= narrowest_unsigned_type (value
, flags
);
515 enum integer_type_kind itk_s
= narrowest_signed_type (value
, flags
);
517 /* In both C89 and C99, octal and hex constants may be signed or
518 unsigned, whichever fits tighter. We do not warn about this
519 choice differing from the traditional choice, as the constant
520 is probably a bit pattern and either way will work. */
521 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
522 itk
= MIN (itk_u
, itk_s
);
525 /* In C99, decimal constants are always signed.
526 In C89, decimal constants that don't fit in long have
527 undefined behavior; we try to make them unsigned long.
528 In GCC's extended C89, that last is true of decimal
529 constants that don't fit in long long, too. */
532 if (itk_s
> itk_u
&& itk_s
> itk_long
)
536 if (itk_u
< itk_unsigned_long
)
537 itk_u
= itk_unsigned_long
;
539 warning ("this decimal constant is unsigned only in ISO C90");
541 else if (warn_traditional
)
542 warning ("this decimal constant would be unsigned in ISO C90");
548 /* cpplib has already issued a warning for overflow. */
549 type
= ((flags
& CPP_N_UNSIGNED
)
550 ? widest_unsigned_literal_type_node
551 : widest_integer_literal_type_node
);
553 type
= integer_types
[itk
];
555 if (itk
> itk_unsigned_long
556 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
557 && ! in_system_header
&& ! flag_isoc99
)
558 pedwarn ("integer constant is too large for \"%s\" type",
559 (flags
& CPP_N_UNSIGNED
) ? "unsigned long" : "long");
561 TREE_TYPE (value
) = type
;
563 /* Convert imaginary to a complex type. */
564 if (flags
& CPP_N_IMAGINARY
)
565 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
570 /* Interpret TOKEN, a floating point number with FLAGS as classified
573 interpret_float (const cpp_token
*token
, unsigned int flags
)
577 REAL_VALUE_TYPE real
;
580 const char *typename
;
582 /* FIXME: make %T work in error/warning, then we don't need typename. */
583 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
585 type
= long_double_type_node
;
586 typename
= "long double";
588 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
589 || flag_single_precision_constant
)
591 type
= float_type_node
;
596 type
= double_type_node
;
600 /* Copy the constant to a nul-terminated buffer. If the constant
601 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
602 can't handle them. */
603 copylen
= token
->val
.str
.len
;
604 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
605 /* Must be an F or L suffix. */
607 if (flags
& CPP_N_IMAGINARY
)
611 copy
= alloca (copylen
+ 1);
612 memcpy (copy
, token
->val
.str
.text
, copylen
);
613 copy
[copylen
] = '\0';
615 real_from_string (&real
, copy
);
616 real_convert (&real
, TYPE_MODE (type
), &real
);
618 /* A diagnostic is required for "soft" overflow by some ISO C
619 testsuites. This is not pedwarn, because some people don't want
621 ??? That's a dubious reason... is this a mandatory diagnostic or
622 isn't it? -- zw, 2001-08-21. */
623 if (REAL_VALUE_ISINF (real
) && pedantic
)
624 warning ("floating constant exceeds range of \"%s\"", typename
);
626 /* Create a node with determined type and value. */
627 value
= build_real (type
, real
);
628 if (flags
& CPP_N_IMAGINARY
)
629 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
), value
);
634 /* Convert a series of STRING and/or WSTRING tokens into a tree,
635 performing string constant concatenation. TOK is the first of
636 these. VALP is the location to write the string into. OBJC_STRING
637 indicates whether an '@' token preceded the incoming token.
638 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
641 This is unfortunately more work than it should be. If any of the
642 strings in the series has an L prefix, the result is a wide string
643 (6.4.5p4). Whether or not the result is a wide string affects the
644 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
645 sequences do not continue across the boundary between two strings in
646 a series (6.4.5p7), so we must not lose the boundaries. Therefore
647 cpp_interpret_string takes a vector of cpp_string structures, which
648 we must arrange to provide. */
650 static enum cpp_ttype
651 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
)
656 struct obstack str_ob
;
659 /* Try to avoid the overhead of creating and destroying an obstack
660 for the common case of just one string. */
661 cpp_string str
= tok
->val
.str
;
662 cpp_string
*strs
= &str
;
664 if (tok
->type
== CPP_WSTRING
)
667 tok
= get_nonpadding_token ();
668 if (c_dialect_objc () && tok
->type
== CPP_ATSIGN
)
671 tok
= get_nonpadding_token ();
673 if (tok
->type
== CPP_STRING
|| tok
->type
== CPP_WSTRING
)
675 gcc_obstack_init (&str_ob
);
676 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
681 if (tok
->type
== CPP_WSTRING
)
683 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
685 tok
= get_nonpadding_token ();
686 if (c_dialect_objc () && tok
->type
== CPP_ATSIGN
)
689 tok
= get_nonpadding_token ();
692 while (tok
->type
== CPP_STRING
|| tok
->type
== CPP_WSTRING
);
693 strs
= obstack_finish (&str_ob
);
696 /* We have read one more token than we want. */
697 _cpp_backup_tokens (parse_in
, 1);
699 if (count
> 1 && !objc_string
&& warn_traditional
&& !in_system_header
)
700 warning ("traditional C rejects string constant concatenation");
702 if (cpp_interpret_string (parse_in
, strs
, count
, &istr
, wide
))
704 value
= build_string (istr
.len
, (char *)istr
.text
);
705 free ((void *)istr
.text
);
709 /* Callers cannot generally handle error_mark_node in this context,
710 so return the empty string instead. cpp_interpret_string has
713 value
= build_string (TYPE_PRECISION (wchar_type_node
)
714 / TYPE_PRECISION (char_type_node
),
715 "\0\0\0"); /* widest supported wchar_t
718 value
= build_string (1, "");
721 TREE_TYPE (value
) = wide
? wchar_array_type_node
: char_array_type_node
;
722 *valp
= fix_string_type (value
);
725 obstack_free (&str_ob
, 0);
727 return objc_string
? CPP_OBJC_STRING
: wide
? CPP_WSTRING
: CPP_STRING
;
730 /* Converts a (possibly wide) character constant token into a tree. */
732 lex_charconst (const cpp_token
*token
)
736 unsigned int chars_seen
;
739 result
= cpp_interpret_charconst (parse_in
, token
,
740 &chars_seen
, &unsignedp
);
742 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
743 before possibly widening to HOST_WIDE_INT for build_int_2. */
744 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
745 value
= build_int_2 (result
, 0);
747 value
= build_int_2 ((cppchar_signed_t
) result
, -1);
749 if (token
->type
== CPP_WCHAR
)
750 type
= wchar_type_node
;
751 /* In C, a character constant has type 'int'.
752 In C++ 'char', but multi-char charconsts have type 'int'. */
753 else if (!c_dialect_cxx () || chars_seen
> 1)
754 type
= integer_type_node
;
756 type
= char_type_node
;
758 TREE_TYPE (value
) = type
;