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"
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_ident (cpp_reader *, unsigned int, const cpp_string *);
73 static void cb_def_pragma (cpp_reader *, unsigned int);
74 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
75 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
80 struct cpp_callbacks *cb;
81 struct c_fileinfo *toplevel;
83 /* Set up filename timing. Must happen before cpp_read_main_file. */
84 file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
86 (splay_tree_delete_value_fn)free);
87 toplevel = get_fileinfo ("<top level>");
88 if (flag_detailed_statistics)
91 body_time = get_run_time ();
92 toplevel->time = body_time;
95 cb = cpp_get_callbacks (parse_in);
97 cb->line_change = cb_line_change;
99 cb->def_pragma = cb_def_pragma;
100 cb->valid_pch = c_common_valid_pch;
101 cb->read_pch = c_common_read_pch;
103 /* Set the debug callbacks if we can use them. */
104 if (debug_info_level == DINFO_LEVEL_VERBOSE
105 && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
106 || write_symbols == VMS_AND_DWARF2_DEBUG))
108 cb->define = cb_define;
109 cb->undef = cb_undef;
114 get_fileinfo (const char *name)
117 struct c_fileinfo *fi;
119 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
121 return (struct c_fileinfo *) n->value;
123 fi = xmalloc (sizeof (struct c_fileinfo));
125 fi->interface_only = 0;
126 fi->interface_unknown = 1;
127 splay_tree_insert (file_info_tree, (splay_tree_key) name,
128 (splay_tree_value) fi);
133 update_header_times (const char *name)
135 /* Changing files again. This means currently collected time
136 is charged against header time, and body time starts back at 0. */
137 if (flag_detailed_statistics)
139 int this_time = get_run_time ();
140 struct c_fileinfo *file = get_fileinfo (name);
141 header_time += this_time - body_time;
142 file->time += this_time - body_time;
143 body_time = this_time;
148 dump_one_header (splay_tree_node n, void *dummy ATTRIBUTE_UNUSED)
150 print_time ((const char *) n->key,
151 ((struct c_fileinfo *) n->value)->time);
156 dump_time_statistics (void)
158 struct c_fileinfo *file = get_fileinfo (input_filename);
159 int this_time = get_run_time ();
160 file->time += this_time - body_time;
162 fprintf (stderr, "\n******\n");
163 print_time ("header files (total)", header_time);
164 print_time ("main file (total)", this_time - body_time);
165 fprintf (stderr, "ratio = %g : 1\n",
166 (double)header_time / (double)(this_time - body_time));
167 fprintf (stderr, "\n******\n");
169 splay_tree_foreach (file_info_tree, dump_one_header, 0);
173 cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED,
174 unsigned int line ATTRIBUTE_UNUSED,
175 const cpp_string *str ATTRIBUTE_UNUSED)
177 #ifdef ASM_OUTPUT_IDENT
180 /* Convert escapes in the string. */
181 cpp_string cstr = { 0, 0 };
182 if (cpp_interpret_string (pfile, str, 1, &cstr, false))
184 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
185 free ((void *)cstr.text);
191 /* Called at the start of every non-empty line. TOKEN is the first
192 lexed token on the line. Used for diagnostic line numbers. */
194 cb_line_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const cpp_token *token,
197 if (token->type == CPP_EOF || parsing_args)
200 input_line = SOURCE_LINE (map, token->line);
204 fe_file_change (const struct line_map *new_map)
212 if (new_map->reason == LC_ENTER)
214 /* Don't stack the main buffer on the input stack;
215 we already did in compile_file. */
218 int included_at = SOURCE_LINE (new_map - 1, new_map->from_line - 1);
220 input_line = included_at;
221 push_srcloc (new_map->to_file, 1);
222 (*debug_hooks->start_source_file) (included_at, new_map->to_file);
223 #ifndef NO_IMPLICIT_EXTERN_C
226 else if (new_map->sysp == 2)
229 ++pending_lang_change;
234 else if (new_map->reason == LC_LEAVE)
236 #ifndef NO_IMPLICIT_EXTERN_C
237 if (c_header_level && --c_header_level == 0)
239 if (new_map->sysp == 2)
240 warning ("badly nested C headers from preprocessor");
241 --pending_lang_change;
246 (*debug_hooks->end_source_file) (new_map->to_line);
249 update_header_times (new_map->to_file);
250 in_system_header = new_map->sysp != 0;
251 input_filename = new_map->to_file;
252 input_line = new_map->to_line;
256 extract_interface_info ();
260 cb_def_pragma (cpp_reader *pfile, unsigned int line)
262 /* Issue a warning message if we have been asked to do so. Ignore
263 unknown pragmas in system headers unless an explicit
264 -Wunknown-pragmas has been given. */
265 if (warn_unknown_pragmas > in_system_header)
267 const unsigned char *space, *name;
270 space = name = (const unsigned char *) "";
271 s = cpp_get_token (pfile);
272 if (s->type != CPP_EOF)
274 space = cpp_token_as_text (pfile, s);
275 s = cpp_get_token (pfile);
276 if (s->type == CPP_NAME)
277 name = cpp_token_as_text (pfile, s);
280 input_line = SOURCE_LINE (map, line);
281 warning ("ignoring #pragma %s %s", space, name);
285 /* #define callback for DWARF and DWARF2 debug info. */
287 cb_define (cpp_reader *pfile, unsigned int line, cpp_hashnode *node)
289 (*debug_hooks->define) (SOURCE_LINE (map, line),
290 (const char *) cpp_macro_definition (pfile, node));
293 /* #undef callback for DWARF and DWARF2 debug info. */
295 cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line,
298 (*debug_hooks->undef) (SOURCE_LINE (map, line),
299 (const char *) NODE_NAME (node));
302 static inline const cpp_token *
303 get_nonpadding_token (void)
305 const cpp_token *tok;
306 timevar_push (TV_CPP);
308 tok = cpp_get_token (parse_in);
309 while (tok->type == CPP_PADDING);
310 timevar_pop (TV_CPP);
316 c_lex_with_flags (tree *value, unsigned char *cpp_flags)
318 const cpp_token *tok;
320 static bool no_more_pch;
323 tok = get_nonpadding_token ();
329 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
334 unsigned int flags = cpp_classify_number (parse_in, tok);
336 switch (flags & CPP_N_CATEGORY)
339 /* cpplib has issued an error. */
340 *value = error_mark_node;
344 *value = interpret_integer (tok, flags);
348 *value = interpret_float (tok, flags);
358 /* An @ may give the next token special significance in Objective-C. */
359 atloc = input_location;
360 tok = get_nonpadding_token ();
361 if (c_dialect_objc ())
367 val = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
368 if (C_IS_RESERVED_WORD (val)
369 && OBJC_IS_AT_KEYWORD (C_RID_CODE (val)))
378 return lex_string (tok, value, true);
385 error ("%Hstray '@' in program", &atloc);
390 cppchar_t c = tok->val.str.text[0];
392 if (c == '"' || c == '\'')
393 error ("missing terminating %c character", (int) c);
394 else if (ISGRAPH (c))
395 error ("stray '%c' in program", (int) c);
397 error ("stray '\\%o' in program", (int) c);
403 *value = lex_charconst (tok);
408 return lex_string (tok, value, false);
411 /* These tokens should not be visible outside cpplib. */
412 case CPP_HEADER_NAME:
425 c_common_no_more_pch ();
429 *cpp_flags = tok->flags;
436 return c_lex_with_flags (value, NULL);
439 /* Returns the narrowest C-visible unsigned type, starting with the
440 minimum specified by FLAGS, that can fit VALUE, or itk_none if
442 static enum integer_type_kind
443 narrowest_unsigned_type (tree value, unsigned int flags)
445 enum integer_type_kind itk;
447 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
448 itk = itk_unsigned_int;
449 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
450 itk = itk_unsigned_long;
452 itk = itk_unsigned_long_long;
454 /* int_fits_type_p must think the type of its first argument is
455 wider than its second argument, or it won't do the proper check. */
456 TREE_TYPE (value) = widest_unsigned_literal_type_node;
458 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
459 if (int_fits_type_p (value, integer_types[itk]))
465 /* Ditto, but narrowest signed type. */
466 static enum integer_type_kind
467 narrowest_signed_type (tree value, unsigned int flags)
469 enum integer_type_kind itk;
471 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
473 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
478 /* int_fits_type_p must think the type of its first argument is
479 wider than its second argument, or it won't do the proper check. */
480 TREE_TYPE (value) = widest_unsigned_literal_type_node;
482 for (; itk < itk_none; itk += 2 /* skip signed types */)
483 if (int_fits_type_p (value, integer_types[itk]))
489 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
491 interpret_integer (const cpp_token *token, unsigned int flags)
494 enum integer_type_kind itk;
496 cpp_options *options = cpp_get_options (parse_in);
498 integer = cpp_interpret_integer (parse_in, token, flags);
499 integer = cpp_num_sign_extend (integer, options->precision);
500 value = build_int_2_wide (integer.low, integer.high);
502 /* The type of a constant with a U suffix is straightforward. */
503 if (flags & CPP_N_UNSIGNED)
504 itk = narrowest_unsigned_type (value, flags);
507 /* The type of a potentially-signed integer constant varies
508 depending on the base it's in, the standard in use, and the
510 enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
511 enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
513 /* In both C89 and C99, octal and hex constants may be signed or
514 unsigned, whichever fits tighter. We do not warn about this
515 choice differing from the traditional choice, as the constant
516 is probably a bit pattern and either way will work. */
517 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
518 itk = MIN (itk_u, itk_s);
521 /* In C99, decimal constants are always signed.
522 In C89, decimal constants that don't fit in long have
523 undefined behavior; we try to make them unsigned long.
524 In GCC's extended C89, that last is true of decimal
525 constants that don't fit in long long, too. */
528 if (itk_s > itk_u && itk_s > itk_long)
532 if (itk_u < itk_unsigned_long)
533 itk_u = itk_unsigned_long;
535 warning ("this decimal constant is unsigned only in ISO C90");
537 else if (warn_traditional)
538 warning ("this decimal constant would be unsigned in ISO C90");
544 /* cpplib has already issued a warning for overflow. */
545 type = ((flags & CPP_N_UNSIGNED)
546 ? widest_unsigned_literal_type_node
547 : widest_integer_literal_type_node);
549 type = integer_types[itk];
551 if (itk > itk_unsigned_long
552 && (flags & CPP_N_WIDTH) != CPP_N_LARGE
553 && ! in_system_header && ! flag_isoc99)
554 pedwarn ("integer constant is too large for \"%s\" type",
555 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
557 TREE_TYPE (value) = type;
559 /* Convert imaginary to a complex type. */
560 if (flags & CPP_N_IMAGINARY)
561 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
566 /* Interpret TOKEN, a floating point number with FLAGS as classified
569 interpret_float (const cpp_token *token, unsigned int flags)
573 REAL_VALUE_TYPE real;
576 const char *typename;
578 /* FIXME: make %T work in error/warning, then we don't need typename. */
579 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
581 type = long_double_type_node;
582 typename = "long double";
584 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
585 || flag_single_precision_constant)
587 type = float_type_node;
592 type = double_type_node;
596 /* Copy the constant to a nul-terminated buffer. If the constant
597 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
598 can't handle them. */
599 copylen = token->val.str.len;
600 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
601 /* Must be an F or L suffix. */
603 if (flags & CPP_N_IMAGINARY)
607 copy = alloca (copylen + 1);
608 memcpy (copy, token->val.str.text, copylen);
609 copy[copylen] = '\0';
611 real_from_string (&real, copy);
612 real_convert (&real, TYPE_MODE (type), &real);
614 /* A diagnostic is required for "soft" overflow by some ISO C
615 testsuites. This is not pedwarn, because some people don't want
617 ??? That's a dubious reason... is this a mandatory diagnostic or
618 isn't it? -- zw, 2001-08-21. */
619 if (REAL_VALUE_ISINF (real) && pedantic)
620 warning ("floating constant exceeds range of \"%s\"", typename);
622 /* Create a node with determined type and value. */
623 value = build_real (type, real);
624 if (flags & CPP_N_IMAGINARY)
625 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
630 /* Convert a series of STRING and/or WSTRING tokens into a tree,
631 performing string constant concatenation. TOK is the first of
632 these. VALP is the location to write the string into. OBJC_STRING
633 indicates whether an '@' token preceded the incoming token.
634 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
637 This is unfortunately more work than it should be. If any of the
638 strings in the series has an L prefix, the result is a wide string
639 (6.4.5p4). Whether or not the result is a wide string affects the
640 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
641 sequences do not continue across the boundary between two strings in
642 a series (6.4.5p7), so we must not lose the boundaries. Therefore
643 cpp_interpret_string takes a vector of cpp_string structures, which
644 we must arrange to provide. */
646 static enum cpp_ttype
647 lex_string (const cpp_token *tok, tree *valp, bool objc_string)
652 struct obstack str_ob;
655 /* Try to avoid the overhead of creating and destroying an obstack
656 for the common case of just one string. */
657 cpp_string str = tok->val.str;
658 cpp_string *strs = &str;
660 if (tok->type == CPP_WSTRING)
663 tok = get_nonpadding_token ();
664 if (c_dialect_objc () && tok->type == CPP_ATSIGN)
667 tok = get_nonpadding_token ();
669 if (tok->type == CPP_STRING || tok->type == CPP_WSTRING)
671 gcc_obstack_init (&str_ob);
672 obstack_grow (&str_ob, &str, sizeof (cpp_string));
677 if (tok->type == CPP_WSTRING)
679 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
681 tok = get_nonpadding_token ();
682 if (c_dialect_objc () && tok->type == CPP_ATSIGN)
685 tok = get_nonpadding_token ();
688 while (tok->type == CPP_STRING || tok->type == CPP_WSTRING);
689 strs = obstack_finish (&str_ob);
692 /* We have read one more token than we want. */
693 _cpp_backup_tokens (parse_in, 1);
695 if (count > 1 && !objc_string && warn_traditional && !in_system_header)
696 warning ("traditional C rejects string constant concatenation");
698 if (cpp_interpret_string (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;