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 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
40 #include "splay-tree.h"
43 #ifdef MULTIBYTE_CHARS
46 #endif /* MULTIBYTE_CHARS */
48 /* The current line map. */
49 static const struct line_map *map;
51 /* The line used to refresh the lineno global variable after each token. */
52 static unsigned int src_lineno;
54 /* We may keep statistics about how long which files took to compile. */
55 static int header_time, body_time;
56 static splay_tree file_info_tree;
58 /* File used for outputting assembler code. */
59 extern FILE *asm_out_file;
61 #undef WCHAR_TYPE_SIZE
62 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
64 /* Number of bytes in a wide character. */
65 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
67 int pending_lang_change; /* If we need to switch languages - C++ only */
68 int c_header_level; /* depth in C headers - C++ only */
70 /* Nonzero tells yylex to ignore \ in string constants. */
71 static int ignore_escape_flag;
73 static tree interpret_integer PARAMS ((const cpp_token *, unsigned int));
74 static tree interpret_float PARAMS ((const cpp_token *, unsigned int));
75 static enum integer_type_kind
76 narrowest_unsigned_type PARAMS ((tree, unsigned int));
77 static enum integer_type_kind
78 narrowest_signed_type PARAMS ((tree, unsigned int));
79 static tree lex_string PARAMS ((const unsigned char *, unsigned int,
81 static tree lex_charconst PARAMS ((const cpp_token *));
82 static void update_header_times PARAMS ((const char *));
83 static int dump_one_header PARAMS ((splay_tree_node, void *));
84 static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
85 static void cb_ident PARAMS ((cpp_reader *, unsigned int,
87 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
88 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
89 static void cb_define PARAMS ((cpp_reader *, unsigned int,
91 static void cb_undef PARAMS ((cpp_reader *, unsigned int,
98 struct cpp_callbacks *cb;
99 struct c_fileinfo *toplevel;
101 /* Set up filename timing. Must happen before cpp_read_main_file. */
102 file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
104 (splay_tree_delete_value_fn)free);
105 toplevel = get_fileinfo ("<top level>");
106 if (flag_detailed_statistics)
109 body_time = get_run_time ();
110 toplevel->time = body_time;
113 #ifdef MULTIBYTE_CHARS
114 /* Change to the native locale for multibyte conversions. */
115 setlocale (LC_CTYPE, "");
116 GET_ENVIRONMENT (literal_codeset, "LANG");
119 cb = cpp_get_callbacks (parse_in);
121 cb->line_change = cb_line_change;
122 cb->ident = cb_ident;
123 cb->file_change = cb_file_change;
124 cb->def_pragma = cb_def_pragma;
126 /* Set the debug callbacks if we can use them. */
127 if (debug_info_level == DINFO_LEVEL_VERBOSE
128 && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
129 || write_symbols == VMS_AND_DWARF2_DEBUG))
131 cb->define = cb_define;
132 cb->undef = cb_undef;
138 if (filename == NULL || !strcmp (filename, "-"))
141 return cpp_read_main_file (parse_in, filename, ident_hash);
144 /* A thin wrapper around the real parser that initializes the
145 integrated preprocessor after debug output has been initialized.
146 Also, make sure the start_source_file debug hook gets called for
147 the primary source file. */
150 c_common_parse_file (set_yydebug)
151 int set_yydebug ATTRIBUTE_UNUSED;
154 yydebug = set_yydebug;
156 warning ("YYDEBUG not defined");
159 (*debug_hooks->start_source_file) (lineno, input_filename);
160 cpp_finish_options (parse_in);
163 free_parser_stacks ();
171 struct c_fileinfo *fi;
173 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
175 return (struct c_fileinfo *) n->value;
177 fi = (struct c_fileinfo *) xmalloc (sizeof (struct c_fileinfo));
179 fi->interface_only = 0;
180 fi->interface_unknown = 1;
181 splay_tree_insert (file_info_tree, (splay_tree_key) name,
182 (splay_tree_value) fi);
187 update_header_times (name)
190 /* Changing files again. This means currently collected time
191 is charged against header time, and body time starts back at 0. */
192 if (flag_detailed_statistics)
194 int this_time = get_run_time ();
195 struct c_fileinfo *file = get_fileinfo (name);
196 header_time += this_time - body_time;
197 file->time += this_time - body_time;
198 body_time = this_time;
203 dump_one_header (n, dummy)
205 void *dummy ATTRIBUTE_UNUSED;
207 print_time ((const char *) n->key,
208 ((struct c_fileinfo *) n->value)->time);
213 dump_time_statistics ()
215 struct c_fileinfo *file = get_fileinfo (input_filename);
216 int this_time = get_run_time ();
217 file->time += this_time - body_time;
219 fprintf (stderr, "\n******\n");
220 print_time ("header files (total)", header_time);
221 print_time ("main file (total)", this_time - body_time);
222 fprintf (stderr, "ratio = %g : 1\n",
223 (double)header_time / (double)(this_time - body_time));
224 fprintf (stderr, "\n******\n");
226 splay_tree_foreach (file_info_tree, dump_one_header, 0);
230 cb_ident (pfile, line, str)
231 cpp_reader *pfile ATTRIBUTE_UNUSED;
232 unsigned int line ATTRIBUTE_UNUSED;
233 const cpp_string *str ATTRIBUTE_UNUSED;
235 #ifdef ASM_OUTPUT_IDENT
238 /* Convert escapes in the string. */
239 tree value = lex_string (str->text, str->len, 0);
240 ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (value));
245 /* Called at the start of every non-empty line. TOKEN is the first
246 lexed token on the line. Used for diagnostic line numbers. */
248 cb_line_change (pfile, token, parsing_args)
249 cpp_reader *pfile ATTRIBUTE_UNUSED;
250 const cpp_token *token;
251 int parsing_args ATTRIBUTE_UNUSED;
253 src_lineno = SOURCE_LINE (map, token->line);
257 cb_file_change (pfile, new_map)
258 cpp_reader *pfile ATTRIBUTE_UNUSED;
259 const struct line_map *new_map;
261 unsigned int to_line = SOURCE_LINE (new_map, new_map->to_line);
263 if (new_map->reason == LC_ENTER)
265 /* Don't stack the main buffer on the input stack;
266 we already did in compile_file. */
268 main_input_filename = new_map->to_file;
271 int included_at = SOURCE_LINE (new_map - 1, new_map->from_line - 1);
273 lineno = included_at;
274 push_srcloc (new_map->to_file, 1);
275 (*debug_hooks->start_source_file) (included_at, new_map->to_file);
276 #ifndef NO_IMPLICIT_EXTERN_C
279 else if (new_map->sysp == 2)
282 ++pending_lang_change;
287 else if (new_map->reason == LC_LEAVE)
289 #ifndef NO_IMPLICIT_EXTERN_C
290 if (c_header_level && --c_header_level == 0)
292 if (new_map->sysp == 2)
293 warning ("badly nested C headers from preprocessor");
294 --pending_lang_change;
299 (*debug_hooks->end_source_file) (to_line);
302 update_header_times (new_map->to_file);
303 in_system_header = new_map->sysp != 0;
304 input_filename = new_map->to_file;
309 extract_interface_info ();
313 cb_def_pragma (pfile, line)
317 /* Issue a warning message if we have been asked to do so. Ignore
318 unknown pragmas in system headers unless an explicit
319 -Wunknown-pragmas has been given. */
320 if (warn_unknown_pragmas > in_system_header)
322 const unsigned char *space, *name;
325 space = name = (const unsigned char *) "";
326 s = cpp_get_token (pfile);
327 if (s->type != CPP_EOF)
329 space = cpp_token_as_text (pfile, s);
330 s = cpp_get_token (pfile);
331 if (s->type == CPP_NAME)
332 name = cpp_token_as_text (pfile, s);
335 lineno = SOURCE_LINE (map, line);
336 warning ("ignoring #pragma %s %s", space, name);
340 /* #define callback for DWARF and DWARF2 debug info. */
342 cb_define (pfile, line, node)
347 (*debug_hooks->define) (SOURCE_LINE (map, line),
348 (const char *) cpp_macro_definition (pfile, node));
351 /* #undef callback for DWARF and DWARF2 debug info. */
353 cb_undef (pfile, line, node)
354 cpp_reader *pfile ATTRIBUTE_UNUSED;
358 (*debug_hooks->undef) (SOURCE_LINE (map, line),
359 (const char *) NODE_NAME (node));
363 /* Returns nonzero if C is a universal-character-name. Give an error if it
364 is not one which may appear in an identifier, as per [extendid].
366 Note that extended character support in identifiers has not yet been
367 implemented. It is my personal opinion that this is not a desirable
368 feature. Portable code cannot count on support for more than the basic
369 identifier character set. */
382 /* None of the valid chars are outside the Basic Multilingual Plane (the
386 error ("universal-character-name '\\U%08x' not valid in identifier", c);
391 if ((c >= 0x00c0 && c <= 0x00d6)
392 || (c >= 0x00d8 && c <= 0x00f6)
393 || (c >= 0x00f8 && c <= 0x01f5)
394 || (c >= 0x01fa && c <= 0x0217)
395 || (c >= 0x0250 && c <= 0x02a8)
396 || (c >= 0x1e00 && c <= 0x1e9a)
397 || (c >= 0x1ea0 && c <= 0x1ef9))
402 || (c >= 0x0388 && c <= 0x038a)
404 || (c >= 0x038e && c <= 0x03a1)
405 || (c >= 0x03a3 && c <= 0x03ce)
406 || (c >= 0x03d0 && c <= 0x03d6)
411 || (c >= 0x03e2 && c <= 0x03f3)
412 || (c >= 0x1f00 && c <= 0x1f15)
413 || (c >= 0x1f18 && c <= 0x1f1d)
414 || (c >= 0x1f20 && c <= 0x1f45)
415 || (c >= 0x1f48 && c <= 0x1f4d)
416 || (c >= 0x1f50 && c <= 0x1f57)
420 || (c >= 0x1f5f && c <= 0x1f7d)
421 || (c >= 0x1f80 && c <= 0x1fb4)
422 || (c >= 0x1fb6 && c <= 0x1fbc)
423 || (c >= 0x1fc2 && c <= 0x1fc4)
424 || (c >= 0x1fc6 && c <= 0x1fcc)
425 || (c >= 0x1fd0 && c <= 0x1fd3)
426 || (c >= 0x1fd6 && c <= 0x1fdb)
427 || (c >= 0x1fe0 && c <= 0x1fec)
428 || (c >= 0x1ff2 && c <= 0x1ff4)
429 || (c >= 0x1ff6 && c <= 0x1ffc))
433 if ((c >= 0x0401 && c <= 0x040d)
434 || (c >= 0x040f && c <= 0x044f)
435 || (c >= 0x0451 && c <= 0x045c)
436 || (c >= 0x045e && c <= 0x0481)
437 || (c >= 0x0490 && c <= 0x04c4)
438 || (c >= 0x04c7 && c <= 0x04c8)
439 || (c >= 0x04cb && c <= 0x04cc)
440 || (c >= 0x04d0 && c <= 0x04eb)
441 || (c >= 0x04ee && c <= 0x04f5)
442 || (c >= 0x04f8 && c <= 0x04f9))
446 if ((c >= 0x0531 && c <= 0x0556)
447 || (c >= 0x0561 && c <= 0x0587))
451 if ((c >= 0x05d0 && c <= 0x05ea)
452 || (c >= 0x05f0 && c <= 0x05f4))
456 if ((c >= 0x0621 && c <= 0x063a)
457 || (c >= 0x0640 && c <= 0x0652)
458 || (c >= 0x0670 && c <= 0x06b7)
459 || (c >= 0x06ba && c <= 0x06be)
460 || (c >= 0x06c0 && c <= 0x06ce)
461 || (c >= 0x06e5 && c <= 0x06e7))
465 if ((c >= 0x0905 && c <= 0x0939)
466 || (c >= 0x0958 && c <= 0x0962))
470 if ((c >= 0x0985 && c <= 0x098c)
471 || (c >= 0x098f && c <= 0x0990)
472 || (c >= 0x0993 && c <= 0x09a8)
473 || (c >= 0x09aa && c <= 0x09b0)
475 || (c >= 0x09b6 && c <= 0x09b9)
476 || (c >= 0x09dc && c <= 0x09dd)
477 || (c >= 0x09df && c <= 0x09e1)
478 || (c >= 0x09f0 && c <= 0x09f1))
482 if ((c >= 0x0a05 && c <= 0x0a0a)
483 || (c >= 0x0a0f && c <= 0x0a10)
484 || (c >= 0x0a13 && c <= 0x0a28)
485 || (c >= 0x0a2a && c <= 0x0a30)
486 || (c >= 0x0a32 && c <= 0x0a33)
487 || (c >= 0x0a35 && c <= 0x0a36)
488 || (c >= 0x0a38 && c <= 0x0a39)
489 || (c >= 0x0a59 && c <= 0x0a5c)
494 if ((c >= 0x0a85 && c <= 0x0a8b)
496 || (c >= 0x0a8f && c <= 0x0a91)
497 || (c >= 0x0a93 && c <= 0x0aa8)
498 || (c >= 0x0aaa && c <= 0x0ab0)
499 || (c >= 0x0ab2 && c <= 0x0ab3)
500 || (c >= 0x0ab5 && c <= 0x0ab9)
505 if ((c >= 0x0b05 && c <= 0x0b0c)
506 || (c >= 0x0b0f && c <= 0x0b10)
507 || (c >= 0x0b13 && c <= 0x0b28)
508 || (c >= 0x0b2a && c <= 0x0b30)
509 || (c >= 0x0b32 && c <= 0x0b33)
510 || (c >= 0x0b36 && c <= 0x0b39)
511 || (c >= 0x0b5c && c <= 0x0b5d)
512 || (c >= 0x0b5f && c <= 0x0b61))
516 if ((c >= 0x0b85 && c <= 0x0b8a)
517 || (c >= 0x0b8e && c <= 0x0b90)
518 || (c >= 0x0b92 && c <= 0x0b95)
519 || (c >= 0x0b99 && c <= 0x0b9a)
521 || (c >= 0x0b9e && c <= 0x0b9f)
522 || (c >= 0x0ba3 && c <= 0x0ba4)
523 || (c >= 0x0ba8 && c <= 0x0baa)
524 || (c >= 0x0bae && c <= 0x0bb5)
525 || (c >= 0x0bb7 && c <= 0x0bb9))
529 if ((c >= 0x0c05 && c <= 0x0c0c)
530 || (c >= 0x0c0e && c <= 0x0c10)
531 || (c >= 0x0c12 && c <= 0x0c28)
532 || (c >= 0x0c2a && c <= 0x0c33)
533 || (c >= 0x0c35 && c <= 0x0c39)
534 || (c >= 0x0c60 && c <= 0x0c61))
538 if ((c >= 0x0c85 && c <= 0x0c8c)
539 || (c >= 0x0c8e && c <= 0x0c90)
540 || (c >= 0x0c92 && c <= 0x0ca8)
541 || (c >= 0x0caa && c <= 0x0cb3)
542 || (c >= 0x0cb5 && c <= 0x0cb9)
543 || (c >= 0x0ce0 && c <= 0x0ce1))
547 if ((c >= 0x0d05 && c <= 0x0d0c)
548 || (c >= 0x0d0e && c <= 0x0d10)
549 || (c >= 0x0d12 && c <= 0x0d28)
550 || (c >= 0x0d2a && c <= 0x0d39)
551 || (c >= 0x0d60 && c <= 0x0d61))
555 if ((c >= 0x0e01 && c <= 0x0e30)
556 || (c >= 0x0e32 && c <= 0x0e33)
557 || (c >= 0x0e40 && c <= 0x0e46)
558 || (c >= 0x0e4f && c <= 0x0e5b))
562 if ((c >= 0x0e81 && c <= 0x0e82)
568 || (c >= 0x0e94 && c <= 0x0e97)
569 || (c >= 0x0e99 && c <= 0x0e9f)
570 || (c >= 0x0ea1 && c <= 0x0ea3)
575 || (c >= 0x0ead && c <= 0x0eb0)
579 || (c >= 0x0ec0 && c <= 0x0ec4)
584 if ((c >= 0x10a0 && c <= 0x10c5)
585 || (c >= 0x10d0 && c <= 0x10f6))
589 if ((c >= 0x3041 && c <= 0x3094)
590 || (c >= 0x309b && c <= 0x309e))
594 if ((c >= 0x30a1 && c <= 0x30fe))
598 if ((c >= 0x3105 && c <= 0x312c))
602 if ((c >= 0x1100 && c <= 0x1159)
603 || (c >= 0x1161 && c <= 0x11a2)
604 || (c >= 0x11a8 && c <= 0x11f9))
607 /* CJK Unified Ideographs */
608 if ((c >= 0xf900 && c <= 0xfa2d)
609 || (c >= 0xfb1f && c <= 0xfb36)
610 || (c >= 0xfb38 && c <= 0xfb3c)
612 || (c >= 0xfb40 && c <= 0xfb41)
613 || (c >= 0xfb42 && c <= 0xfb44)
614 || (c >= 0xfb46 && c <= 0xfbb1)
615 || (c >= 0xfbd3 && c <= 0xfd3f)
616 || (c >= 0xfd50 && c <= 0xfd8f)
617 || (c >= 0xfd92 && c <= 0xfdc7)
618 || (c >= 0xfdf0 && c <= 0xfdfb)
619 || (c >= 0xfe70 && c <= 0xfe72)
621 || (c >= 0xfe76 && c <= 0xfefc)
622 || (c >= 0xff21 && c <= 0xff3a)
623 || (c >= 0xff41 && c <= 0xff5a)
624 || (c >= 0xff66 && c <= 0xffbe)
625 || (c >= 0xffc2 && c <= 0xffc7)
626 || (c >= 0xffca && c <= 0xffcf)
627 || (c >= 0xffd2 && c <= 0xffd7)
628 || (c >= 0xffda && c <= 0xffdc)
629 || (c >= 0x4e00 && c <= 0x9fa5))
632 error ("universal-character-name '\\u%04x' not valid in identifier", c);
637 /* Add the UTF-8 representation of C to the token_buffer. */
640 utf8_extend_token (c)
650 else if (c <= 0x000007ff)
651 shift = 6, mask = 0xc0;
652 else if (c <= 0x0000ffff)
653 shift = 12, mask = 0xe0;
654 else if (c <= 0x001fffff)
655 shift = 18, mask = 0xf0;
656 else if (c <= 0x03ffffff)
657 shift = 24, mask = 0xf8;
659 shift = 30, mask = 0xfc;
661 extend_token (mask | (c >> shift));
665 extend_token ((unsigned char) (0x80 | (c >> shift)));
675 const cpp_token *tok;
678 timevar_push (TV_CPP);
680 tok = cpp_get_token (parse_in);
681 while (tok->type == CPP_PADDING);
682 timevar_pop (TV_CPP);
684 /* The C++ front end does horrible things with the current line
685 number. To ensure an accurate line number, we must reset it
686 every time we return a token. */
692 /* Issue this error here, where we can get at tok->val.c. */
694 if (ISGRAPH (tok->val.c))
695 error ("stray '%c' in program", tok->val.c);
697 error ("stray '\\%o' in program", tok->val.c);
701 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
706 unsigned int flags = cpp_classify_number (parse_in, tok);
708 switch (flags & CPP_N_CATEGORY)
711 /* cpplib has issued an error. */
715 *value = interpret_integer (tok, flags);
719 *value = interpret_float (tok, flags);
730 *value = lex_charconst (tok);
735 *value = lex_string (tok->val.str.text, tok->val.str.len,
736 tok->type == CPP_WSTRING);
739 /* These tokens should not be visible outside cpplib. */
740 case CPP_HEADER_NAME:
751 /* Returns the narrowest C-visible unsigned type, starting with the
752 minimum specified by FLAGS, that can fit VALUE, or itk_none if
754 static enum integer_type_kind
755 narrowest_unsigned_type (value, flags)
759 enum integer_type_kind itk;
761 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
762 itk = itk_unsigned_int;
763 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
764 itk = itk_unsigned_long;
766 itk = itk_unsigned_long_long;
768 /* int_fits_type_p must think the type of its first argument is
769 wider than its second argument, or it won't do the proper check. */
770 TREE_TYPE (value) = widest_unsigned_literal_type_node;
772 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
773 if (int_fits_type_p (value, integer_types[itk]))
779 /* Ditto, but narrowest signed type. */
780 static enum integer_type_kind
781 narrowest_signed_type (value, flags)
785 enum integer_type_kind itk;
787 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
789 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
794 /* int_fits_type_p must think the type of its first argument is
795 wider than its second argument, or it won't do the proper check. */
796 TREE_TYPE (value) = widest_unsigned_literal_type_node;
798 for (; itk < itk_none; itk += 2 /* skip signed types */)
799 if (int_fits_type_p (value, integer_types[itk]))
805 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
807 interpret_integer (token, flags)
808 const cpp_token *token;
812 enum integer_type_kind itk;
814 cpp_options *options = cpp_get_options (parse_in);
816 integer = cpp_interpret_integer (parse_in, token, flags);
817 integer = cpp_num_sign_extend (integer, options->precision);
818 value = build_int_2_wide (integer.low, integer.high);
820 /* The type of a constant with a U suffix is straightforward. */
821 if (flags & CPP_N_UNSIGNED)
822 itk = narrowest_unsigned_type (value, flags);
825 /* The type of a potentially-signed integer constant varies
826 depending on the base it's in, the standard in use, and the
828 enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
829 enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
831 /* In both C89 and C99, octal and hex constants may be signed or
832 unsigned, whichever fits tighter. We do not warn about this
833 choice differing from the traditional choice, as the constant
834 is probably a bit pattern and either way will work. */
835 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
836 itk = MIN (itk_u, itk_s);
839 /* In C99, decimal constants are always signed.
840 In C89, decimal constants that don't fit in long have
841 undefined behaviour; we try to make them unsigned long.
842 In GCC's extended C89, that last is true of decimal
843 constants that don't fit in long long, too. */
846 if (itk_s > itk_u && itk_s > itk_long)
850 if (itk_u < itk_unsigned_long)
851 itk_u = itk_unsigned_long;
853 warning ("this decimal constant is unsigned only in ISO C90");
855 else if (warn_traditional)
856 warning ("this decimal constant would be unsigned in ISO C90");
862 /* cpplib has already issued a warning for overflow. */
863 type = ((flags & CPP_N_UNSIGNED)
864 ? widest_unsigned_literal_type_node
865 : widest_integer_literal_type_node);
867 type = integer_types[itk];
869 if (itk > itk_unsigned_long
870 && (flags & CPP_N_WIDTH) != CPP_N_LARGE
871 && ! in_system_header && ! flag_isoc99)
872 pedwarn ("integer constant is too large for \"%s\" type",
873 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
875 TREE_TYPE (value) = type;
877 /* Convert imaginary to a complex type. */
878 if (flags & CPP_N_IMAGINARY)
879 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
884 /* Interpret TOKEN, a floating point number with FLAGS as classified
887 interpret_float (token, flags)
888 const cpp_token *token;
893 REAL_VALUE_TYPE real;
896 const char *typename;
898 /* FIXME: make %T work in error/warning, then we don't need typename. */
899 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
901 type = long_double_type_node;
902 typename = "long double";
904 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
905 || flag_single_precision_constant)
907 type = float_type_node;
912 type = double_type_node;
916 /* Copy the constant to a nul-terminated buffer. If the constant
917 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
918 can't handle them. */
919 copylen = token->val.str.len;
920 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
921 /* Must be an F or L suffix. */
923 if (flags & CPP_N_IMAGINARY)
927 copy = alloca (copylen + 1);
928 memcpy (copy, token->val.str.text, copylen);
929 copy[copylen] = '\0';
931 /* The second argument, machine_mode, of REAL_VALUE_ATOF tells the
932 desired precision of the binary result of decimal-to-binary
934 if (flags & CPP_N_HEX)
935 real = REAL_VALUE_HTOF (copy, TYPE_MODE (type));
937 real = REAL_VALUE_ATOF (copy, TYPE_MODE (type));
939 /* A diagnostic is required for "soft" overflow by some ISO C
940 testsuites. This is not pedwarn, because some people don't want
942 ??? That's a dubious reason... is this a mandatory diagnostic or
943 isn't it? -- zw, 2001-08-21. */
944 if (REAL_VALUE_ISINF (real) && pedantic)
945 warning ("floating constant exceeds range of \"%s\"", typename);
947 /* Create a node with determined type and value. */
948 value = build_real (type, real);
949 if (flags & CPP_N_IMAGINARY)
950 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
956 lex_string (str, len, wide)
957 const unsigned char *str;
962 char *buf = alloca ((len + 1) * (wide ? WCHAR_BYTES : 1));
964 const unsigned char *p = str, *limit = str + len;
967 #ifdef MULTIBYTE_CHARS
968 /* Reset multibyte conversion state. */
969 (void) local_mbtowc (NULL, NULL, 0);
974 #ifdef MULTIBYTE_CHARS
978 char_len = local_mbtowc (&wc, (const char *) p, limit - p);
981 warning ("ignoring invalid multibyte character");
994 if (c == '\\' && !ignore_escape_flag)
995 c = cpp_parse_escape (parse_in, &p, limit, wide);
997 /* Add this single character into the buffer either as a wchar_t,
998 a multibyte sequence, or as a single byte. */
1001 unsigned charwidth = TYPE_PRECISION (char_type_node);
1002 unsigned bytemask = (1 << charwidth) - 1;
1005 for (byte = 0; byte < WCHAR_BYTES; ++byte)
1008 if (byte >= (int) sizeof (c))
1011 n = (c >> (byte * charwidth)) & bytemask;
1012 if (BYTES_BIG_ENDIAN)
1013 q[WCHAR_BYTES - byte - 1] = n;
1019 #ifdef MULTIBYTE_CHARS
1020 else if (char_len > 1)
1022 /* We're dealing with a multibyte character. */
1023 for ( ; char_len >0; --char_len)
1025 *q++ = *(p - char_len);
1035 /* Terminate the string value, either with a single byte zero
1036 or with a wide zero. */
1040 memset (q, 0, WCHAR_BYTES);
1048 value = build_string (q - buf, buf);
1051 TREE_TYPE (value) = wchar_array_type_node;
1053 TREE_TYPE (value) = char_array_type_node;
1057 /* Converts a (possibly wide) character constant token into a tree. */
1059 lex_charconst (token)
1060 const cpp_token *token;
1064 unsigned int chars_seen;
1067 result = cpp_interpret_charconst (parse_in, token,
1068 &chars_seen, &unsignedp);
1070 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1071 before possibly widening to HOST_WIDE_INT for build_int_2. */
1072 if (unsignedp || (cppchar_signed_t) result >= 0)
1073 value = build_int_2 (result, 0);
1075 value = build_int_2 ((cppchar_signed_t) result, -1);
1077 if (token->type == CPP_WCHAR)
1078 type = wchar_type_node;
1079 /* In C, a character constant has type 'int'.
1080 In C++ 'char', but multi-char charconsts have type 'int'. */
1081 else if ((c_language == clk_c || c_language == clk_objective_c)
1083 type = integer_type_node;
1085 type = char_type_node;
1087 TREE_TYPE (value) = type;