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 #ifdef MULTIBYTE_CHARS
48 #endif /* MULTIBYTE_CHARS */
50 /* The current line map. */
51 static const struct line_map *map;
53 /* The line used to refresh the lineno global variable after each token. */
54 static unsigned int src_lineno;
56 /* We may keep statistics about how long which files took to compile. */
57 static int header_time, body_time;
58 static splay_tree file_info_tree;
60 /* File used for outputting assembler code. */
61 extern FILE *asm_out_file;
63 #undef WCHAR_TYPE_SIZE
64 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
66 /* Number of bytes in a wide character. */
67 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
69 int pending_lang_change; /* If we need to switch languages - C++ only */
70 int c_header_level; /* depth in C headers - C++ only */
72 /* Nonzero tells yylex to ignore \ in string constants. */
73 static int ignore_escape_flag;
75 static tree interpret_integer PARAMS ((const cpp_token *, unsigned int));
76 static tree interpret_float PARAMS ((const cpp_token *, unsigned int));
77 static enum integer_type_kind
78 narrowest_unsigned_type PARAMS ((tree, unsigned int));
79 static enum integer_type_kind
80 narrowest_signed_type PARAMS ((tree, unsigned int));
81 static tree lex_string PARAMS ((const unsigned char *, unsigned int,
83 static tree lex_charconst PARAMS ((const cpp_token *));
84 static void update_header_times PARAMS ((const char *));
85 static int dump_one_header PARAMS ((splay_tree_node, void *));
86 static void cb_line_change PARAMS ((cpp_reader *, const cpp_token *, int));
87 static void cb_ident PARAMS ((cpp_reader *, unsigned int,
89 static void cb_file_change PARAMS ((cpp_reader *, const struct line_map *));
90 static void cb_def_pragma PARAMS ((cpp_reader *, unsigned int));
91 static void cb_define PARAMS ((cpp_reader *, unsigned int,
93 static void cb_undef PARAMS ((cpp_reader *, unsigned int,
99 struct cpp_callbacks *cb;
100 struct c_fileinfo *toplevel;
102 /* Set up filename timing. Must happen before cpp_read_main_file. */
103 file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp,
105 (splay_tree_delete_value_fn)free);
106 toplevel = get_fileinfo ("<top level>");
107 if (flag_detailed_statistics)
110 body_time = get_run_time ();
111 toplevel->time = body_time;
114 #ifdef MULTIBYTE_CHARS
115 /* Change to the native locale for multibyte conversions. */
116 setlocale (LC_CTYPE, "");
117 GET_ENVIRONMENT (literal_codeset, "LANG");
120 cb = cpp_get_callbacks (parse_in);
122 cb->line_change = cb_line_change;
123 cb->ident = cb_ident;
124 cb->file_change = cb_file_change;
125 cb->def_pragma = cb_def_pragma;
126 cb->valid_pch = c_common_valid_pch;
127 cb->read_pch = c_common_read_pch;
129 /* Set the debug callbacks if we can use them. */
130 if (debug_info_level == DINFO_LEVEL_VERBOSE
131 && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG
132 || write_symbols == VMS_AND_DWARF2_DEBUG))
134 cb->define = cb_define;
135 cb->undef = cb_undef;
139 /* A thin wrapper around the real parser that initializes the
140 integrated preprocessor after debug output has been initialized.
141 Also, make sure the start_source_file debug hook gets called for
142 the primary source file. */
145 c_common_parse_file (set_yydebug)
146 int set_yydebug ATTRIBUTE_UNUSED;
149 yydebug = set_yydebug;
151 warning ("YYDEBUG not defined");
154 (*debug_hooks->start_source_file) (lineno, input_filename);
155 cpp_finish_options (parse_in);
160 free_parser_stacks ();
168 struct c_fileinfo *fi;
170 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
172 return (struct c_fileinfo *) n->value;
174 fi = (struct c_fileinfo *) xmalloc (sizeof (struct c_fileinfo));
176 fi->interface_only = 0;
177 fi->interface_unknown = 1;
178 splay_tree_insert (file_info_tree, (splay_tree_key) name,
179 (splay_tree_value) fi);
184 update_header_times (name)
187 /* Changing files again. This means currently collected time
188 is charged against header time, and body time starts back at 0. */
189 if (flag_detailed_statistics)
191 int this_time = get_run_time ();
192 struct c_fileinfo *file = get_fileinfo (name);
193 header_time += this_time - body_time;
194 file->time += this_time - body_time;
195 body_time = this_time;
200 dump_one_header (n, dummy)
202 void *dummy ATTRIBUTE_UNUSED;
204 print_time ((const char *) n->key,
205 ((struct c_fileinfo *) n->value)->time);
210 dump_time_statistics ()
212 struct c_fileinfo *file = get_fileinfo (input_filename);
213 int this_time = get_run_time ();
214 file->time += this_time - body_time;
216 fprintf (stderr, "\n******\n");
217 print_time ("header files (total)", header_time);
218 print_time ("main file (total)", this_time - body_time);
219 fprintf (stderr, "ratio = %g : 1\n",
220 (double)header_time / (double)(this_time - body_time));
221 fprintf (stderr, "\n******\n");
223 splay_tree_foreach (file_info_tree, dump_one_header, 0);
227 cb_ident (pfile, line, str)
228 cpp_reader *pfile ATTRIBUTE_UNUSED;
229 unsigned int line ATTRIBUTE_UNUSED;
230 const cpp_string *str ATTRIBUTE_UNUSED;
232 #ifdef ASM_OUTPUT_IDENT
235 /* Convert escapes in the string. */
236 tree value ATTRIBUTE_UNUSED = lex_string (str->text, str->len, 0);
237 ASM_OUTPUT_IDENT (asm_out_file, TREE_STRING_POINTER (value));
242 /* Called at the start of every non-empty line. TOKEN is the first
243 lexed token on the line. Used for diagnostic line numbers. */
245 cb_line_change (pfile, token, parsing_args)
246 cpp_reader *pfile ATTRIBUTE_UNUSED;
247 const cpp_token *token;
248 int parsing_args ATTRIBUTE_UNUSED;
250 src_lineno = SOURCE_LINE (map, token->line);
254 cb_file_change (pfile, new_map)
255 cpp_reader *pfile ATTRIBUTE_UNUSED;
256 const struct line_map *new_map;
258 unsigned int to_line = SOURCE_LINE (new_map, new_map->to_line);
260 if (new_map->reason == LC_ENTER)
262 /* Don't stack the main buffer on the input stack;
263 we already did in compile_file. */
265 main_input_filename = new_map->to_file;
268 int included_at = SOURCE_LINE (new_map - 1, new_map->from_line - 1);
270 lineno = included_at;
271 push_srcloc (new_map->to_file, 1);
272 (*debug_hooks->start_source_file) (included_at, new_map->to_file);
273 #ifndef NO_IMPLICIT_EXTERN_C
276 else if (new_map->sysp == 2)
279 ++pending_lang_change;
284 else if (new_map->reason == LC_LEAVE)
286 #ifndef NO_IMPLICIT_EXTERN_C
287 if (c_header_level && --c_header_level == 0)
289 if (new_map->sysp == 2)
290 warning ("badly nested C headers from preprocessor");
291 --pending_lang_change;
296 (*debug_hooks->end_source_file) (to_line);
299 update_header_times (new_map->to_file);
300 in_system_header = new_map->sysp != 0;
301 input_filename = new_map->to_file;
306 extract_interface_info ();
310 cb_def_pragma (pfile, line)
314 /* Issue a warning message if we have been asked to do so. Ignore
315 unknown pragmas in system headers unless an explicit
316 -Wunknown-pragmas has been given. */
317 if (warn_unknown_pragmas > in_system_header)
319 const unsigned char *space, *name;
322 space = name = (const unsigned char *) "";
323 s = cpp_get_token (pfile);
324 if (s->type != CPP_EOF)
326 space = cpp_token_as_text (pfile, s);
327 s = cpp_get_token (pfile);
328 if (s->type == CPP_NAME)
329 name = cpp_token_as_text (pfile, s);
332 lineno = SOURCE_LINE (map, line);
333 warning ("ignoring #pragma %s %s", space, name);
337 /* #define callback for DWARF and DWARF2 debug info. */
339 cb_define (pfile, line, node)
344 (*debug_hooks->define) (SOURCE_LINE (map, line),
345 (const char *) cpp_macro_definition (pfile, node));
348 /* #undef callback for DWARF and DWARF2 debug info. */
350 cb_undef (pfile, line, node)
351 cpp_reader *pfile ATTRIBUTE_UNUSED;
355 (*debug_hooks->undef) (SOURCE_LINE (map, line),
356 (const char *) NODE_NAME (node));
360 /* Returns nonzero if C is a universal-character-name. Give an error if it
361 is not one which may appear in an identifier, as per [extendid].
363 Note that extended character support in identifiers has not yet been
364 implemented. It is my personal opinion that this is not a desirable
365 feature. Portable code cannot count on support for more than the basic
366 identifier character set. */
379 /* None of the valid chars are outside the Basic Multilingual Plane (the
383 error ("universal-character-name '\\U%08x' not valid in identifier", c);
388 if ((c >= 0x00c0 && c <= 0x00d6)
389 || (c >= 0x00d8 && c <= 0x00f6)
390 || (c >= 0x00f8 && c <= 0x01f5)
391 || (c >= 0x01fa && c <= 0x0217)
392 || (c >= 0x0250 && c <= 0x02a8)
393 || (c >= 0x1e00 && c <= 0x1e9a)
394 || (c >= 0x1ea0 && c <= 0x1ef9))
399 || (c >= 0x0388 && c <= 0x038a)
401 || (c >= 0x038e && c <= 0x03a1)
402 || (c >= 0x03a3 && c <= 0x03ce)
403 || (c >= 0x03d0 && c <= 0x03d6)
408 || (c >= 0x03e2 && c <= 0x03f3)
409 || (c >= 0x1f00 && c <= 0x1f15)
410 || (c >= 0x1f18 && c <= 0x1f1d)
411 || (c >= 0x1f20 && c <= 0x1f45)
412 || (c >= 0x1f48 && c <= 0x1f4d)
413 || (c >= 0x1f50 && c <= 0x1f57)
417 || (c >= 0x1f5f && c <= 0x1f7d)
418 || (c >= 0x1f80 && c <= 0x1fb4)
419 || (c >= 0x1fb6 && c <= 0x1fbc)
420 || (c >= 0x1fc2 && c <= 0x1fc4)
421 || (c >= 0x1fc6 && c <= 0x1fcc)
422 || (c >= 0x1fd0 && c <= 0x1fd3)
423 || (c >= 0x1fd6 && c <= 0x1fdb)
424 || (c >= 0x1fe0 && c <= 0x1fec)
425 || (c >= 0x1ff2 && c <= 0x1ff4)
426 || (c >= 0x1ff6 && c <= 0x1ffc))
430 if ((c >= 0x0401 && c <= 0x040d)
431 || (c >= 0x040f && c <= 0x044f)
432 || (c >= 0x0451 && c <= 0x045c)
433 || (c >= 0x045e && c <= 0x0481)
434 || (c >= 0x0490 && c <= 0x04c4)
435 || (c >= 0x04c7 && c <= 0x04c8)
436 || (c >= 0x04cb && c <= 0x04cc)
437 || (c >= 0x04d0 && c <= 0x04eb)
438 || (c >= 0x04ee && c <= 0x04f5)
439 || (c >= 0x04f8 && c <= 0x04f9))
443 if ((c >= 0x0531 && c <= 0x0556)
444 || (c >= 0x0561 && c <= 0x0587))
448 if ((c >= 0x05d0 && c <= 0x05ea)
449 || (c >= 0x05f0 && c <= 0x05f4))
453 if ((c >= 0x0621 && c <= 0x063a)
454 || (c >= 0x0640 && c <= 0x0652)
455 || (c >= 0x0670 && c <= 0x06b7)
456 || (c >= 0x06ba && c <= 0x06be)
457 || (c >= 0x06c0 && c <= 0x06ce)
458 || (c >= 0x06e5 && c <= 0x06e7))
462 if ((c >= 0x0905 && c <= 0x0939)
463 || (c >= 0x0958 && c <= 0x0962))
467 if ((c >= 0x0985 && c <= 0x098c)
468 || (c >= 0x098f && c <= 0x0990)
469 || (c >= 0x0993 && c <= 0x09a8)
470 || (c >= 0x09aa && c <= 0x09b0)
472 || (c >= 0x09b6 && c <= 0x09b9)
473 || (c >= 0x09dc && c <= 0x09dd)
474 || (c >= 0x09df && c <= 0x09e1)
475 || (c >= 0x09f0 && c <= 0x09f1))
479 if ((c >= 0x0a05 && c <= 0x0a0a)
480 || (c >= 0x0a0f && c <= 0x0a10)
481 || (c >= 0x0a13 && c <= 0x0a28)
482 || (c >= 0x0a2a && c <= 0x0a30)
483 || (c >= 0x0a32 && c <= 0x0a33)
484 || (c >= 0x0a35 && c <= 0x0a36)
485 || (c >= 0x0a38 && c <= 0x0a39)
486 || (c >= 0x0a59 && c <= 0x0a5c)
491 if ((c >= 0x0a85 && c <= 0x0a8b)
493 || (c >= 0x0a8f && c <= 0x0a91)
494 || (c >= 0x0a93 && c <= 0x0aa8)
495 || (c >= 0x0aaa && c <= 0x0ab0)
496 || (c >= 0x0ab2 && c <= 0x0ab3)
497 || (c >= 0x0ab5 && c <= 0x0ab9)
502 if ((c >= 0x0b05 && c <= 0x0b0c)
503 || (c >= 0x0b0f && c <= 0x0b10)
504 || (c >= 0x0b13 && c <= 0x0b28)
505 || (c >= 0x0b2a && c <= 0x0b30)
506 || (c >= 0x0b32 && c <= 0x0b33)
507 || (c >= 0x0b36 && c <= 0x0b39)
508 || (c >= 0x0b5c && c <= 0x0b5d)
509 || (c >= 0x0b5f && c <= 0x0b61))
513 if ((c >= 0x0b85 && c <= 0x0b8a)
514 || (c >= 0x0b8e && c <= 0x0b90)
515 || (c >= 0x0b92 && c <= 0x0b95)
516 || (c >= 0x0b99 && c <= 0x0b9a)
518 || (c >= 0x0b9e && c <= 0x0b9f)
519 || (c >= 0x0ba3 && c <= 0x0ba4)
520 || (c >= 0x0ba8 && c <= 0x0baa)
521 || (c >= 0x0bae && c <= 0x0bb5)
522 || (c >= 0x0bb7 && c <= 0x0bb9))
526 if ((c >= 0x0c05 && c <= 0x0c0c)
527 || (c >= 0x0c0e && c <= 0x0c10)
528 || (c >= 0x0c12 && c <= 0x0c28)
529 || (c >= 0x0c2a && c <= 0x0c33)
530 || (c >= 0x0c35 && c <= 0x0c39)
531 || (c >= 0x0c60 && c <= 0x0c61))
535 if ((c >= 0x0c85 && c <= 0x0c8c)
536 || (c >= 0x0c8e && c <= 0x0c90)
537 || (c >= 0x0c92 && c <= 0x0ca8)
538 || (c >= 0x0caa && c <= 0x0cb3)
539 || (c >= 0x0cb5 && c <= 0x0cb9)
540 || (c >= 0x0ce0 && c <= 0x0ce1))
544 if ((c >= 0x0d05 && c <= 0x0d0c)
545 || (c >= 0x0d0e && c <= 0x0d10)
546 || (c >= 0x0d12 && c <= 0x0d28)
547 || (c >= 0x0d2a && c <= 0x0d39)
548 || (c >= 0x0d60 && c <= 0x0d61))
552 if ((c >= 0x0e01 && c <= 0x0e30)
553 || (c >= 0x0e32 && c <= 0x0e33)
554 || (c >= 0x0e40 && c <= 0x0e46)
555 || (c >= 0x0e4f && c <= 0x0e5b))
559 if ((c >= 0x0e81 && c <= 0x0e82)
565 || (c >= 0x0e94 && c <= 0x0e97)
566 || (c >= 0x0e99 && c <= 0x0e9f)
567 || (c >= 0x0ea1 && c <= 0x0ea3)
572 || (c >= 0x0ead && c <= 0x0eb0)
576 || (c >= 0x0ec0 && c <= 0x0ec4)
581 if ((c >= 0x10a0 && c <= 0x10c5)
582 || (c >= 0x10d0 && c <= 0x10f6))
586 if ((c >= 0x3041 && c <= 0x3094)
587 || (c >= 0x309b && c <= 0x309e))
591 if ((c >= 0x30a1 && c <= 0x30fe))
595 if ((c >= 0x3105 && c <= 0x312c))
599 if ((c >= 0x1100 && c <= 0x1159)
600 || (c >= 0x1161 && c <= 0x11a2)
601 || (c >= 0x11a8 && c <= 0x11f9))
604 /* CJK Unified Ideographs */
605 if ((c >= 0xf900 && c <= 0xfa2d)
606 || (c >= 0xfb1f && c <= 0xfb36)
607 || (c >= 0xfb38 && c <= 0xfb3c)
609 || (c >= 0xfb40 && c <= 0xfb41)
610 || (c >= 0xfb42 && c <= 0xfb44)
611 || (c >= 0xfb46 && c <= 0xfbb1)
612 || (c >= 0xfbd3 && c <= 0xfd3f)
613 || (c >= 0xfd50 && c <= 0xfd8f)
614 || (c >= 0xfd92 && c <= 0xfdc7)
615 || (c >= 0xfdf0 && c <= 0xfdfb)
616 || (c >= 0xfe70 && c <= 0xfe72)
618 || (c >= 0xfe76 && c <= 0xfefc)
619 || (c >= 0xff21 && c <= 0xff3a)
620 || (c >= 0xff41 && c <= 0xff5a)
621 || (c >= 0xff66 && c <= 0xffbe)
622 || (c >= 0xffc2 && c <= 0xffc7)
623 || (c >= 0xffca && c <= 0xffcf)
624 || (c >= 0xffd2 && c <= 0xffd7)
625 || (c >= 0xffda && c <= 0xffdc)
626 || (c >= 0x4e00 && c <= 0x9fa5))
629 error ("universal-character-name '\\u%04x' not valid in identifier", c);
634 /* Add the UTF-8 representation of C to the token_buffer. */
637 utf8_extend_token (c)
647 else if (c <= 0x000007ff)
648 shift = 6, mask = 0xc0;
649 else if (c <= 0x0000ffff)
650 shift = 12, mask = 0xe0;
651 else if (c <= 0x001fffff)
652 shift = 18, mask = 0xf0;
653 else if (c <= 0x03ffffff)
654 shift = 24, mask = 0xf8;
656 shift = 30, mask = 0xfc;
658 extend_token (mask | (c >> shift));
662 extend_token ((unsigned char) (0x80 | (c >> shift)));
672 const cpp_token *tok;
675 timevar_push (TV_CPP);
677 tok = cpp_get_token (parse_in);
678 while (tok->type == CPP_PADDING);
679 timevar_pop (TV_CPP);
681 /* The C++ front end does horrible things with the current line
682 number. To ensure an accurate line number, we must reset it
683 every time we return a token. */
689 /* Issue this error here, where we can get at tok->val.c. */
691 if (ISGRAPH (tok->val.c))
692 error ("stray '%c' in program", tok->val.c);
694 error ("stray '\\%o' in program", tok->val.c);
698 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
703 unsigned int flags = cpp_classify_number (parse_in, tok);
705 switch (flags & CPP_N_CATEGORY)
708 /* cpplib has issued an error. */
709 *value = error_mark_node;
713 *value = interpret_integer (tok, flags);
717 *value = interpret_float (tok, flags);
728 *value = lex_charconst (tok);
733 *value = lex_string (tok->val.str.text, tok->val.str.len,
734 tok->type == CPP_WSTRING);
737 /* These tokens should not be visible outside cpplib. */
738 case CPP_HEADER_NAME:
749 /* Returns the narrowest C-visible unsigned type, starting with the
750 minimum specified by FLAGS, that can fit VALUE, or itk_none if
752 static enum integer_type_kind
753 narrowest_unsigned_type (value, flags)
757 enum integer_type_kind itk;
759 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
760 itk = itk_unsigned_int;
761 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
762 itk = itk_unsigned_long;
764 itk = itk_unsigned_long_long;
766 /* int_fits_type_p must think the type of its first argument is
767 wider than its second argument, or it won't do the proper check. */
768 TREE_TYPE (value) = widest_unsigned_literal_type_node;
770 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
771 if (int_fits_type_p (value, integer_types[itk]))
777 /* Ditto, but narrowest signed type. */
778 static enum integer_type_kind
779 narrowest_signed_type (value, flags)
783 enum integer_type_kind itk;
785 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
787 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
792 /* int_fits_type_p must think the type of its first argument is
793 wider than its second argument, or it won't do the proper check. */
794 TREE_TYPE (value) = widest_unsigned_literal_type_node;
796 for (; itk < itk_none; itk += 2 /* skip signed types */)
797 if (int_fits_type_p (value, integer_types[itk]))
803 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
805 interpret_integer (token, flags)
806 const cpp_token *token;
810 enum integer_type_kind itk;
812 cpp_options *options = cpp_get_options (parse_in);
814 integer = cpp_interpret_integer (parse_in, token, flags);
815 integer = cpp_num_sign_extend (integer, options->precision);
816 value = build_int_2_wide (integer.low, integer.high);
818 /* The type of a constant with a U suffix is straightforward. */
819 if (flags & CPP_N_UNSIGNED)
820 itk = narrowest_unsigned_type (value, flags);
823 /* The type of a potentially-signed integer constant varies
824 depending on the base it's in, the standard in use, and the
826 enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags);
827 enum integer_type_kind itk_s = narrowest_signed_type (value, flags);
829 /* In both C89 and C99, octal and hex constants may be signed or
830 unsigned, whichever fits tighter. We do not warn about this
831 choice differing from the traditional choice, as the constant
832 is probably a bit pattern and either way will work. */
833 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
834 itk = MIN (itk_u, itk_s);
837 /* In C99, decimal constants are always signed.
838 In C89, decimal constants that don't fit in long have
839 undefined behavior; we try to make them unsigned long.
840 In GCC's extended C89, that last is true of decimal
841 constants that don't fit in long long, too. */
844 if (itk_s > itk_u && itk_s > itk_long)
848 if (itk_u < itk_unsigned_long)
849 itk_u = itk_unsigned_long;
851 warning ("this decimal constant is unsigned only in ISO C90");
853 else if (warn_traditional)
854 warning ("this decimal constant would be unsigned in ISO C90");
860 /* cpplib has already issued a warning for overflow. */
861 type = ((flags & CPP_N_UNSIGNED)
862 ? widest_unsigned_literal_type_node
863 : widest_integer_literal_type_node);
865 type = integer_types[itk];
867 if (itk > itk_unsigned_long
868 && (flags & CPP_N_WIDTH) != CPP_N_LARGE
869 && ! in_system_header && ! flag_isoc99)
870 pedwarn ("integer constant is too large for \"%s\" type",
871 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
873 TREE_TYPE (value) = type;
875 /* Convert imaginary to a complex type. */
876 if (flags & CPP_N_IMAGINARY)
877 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
882 /* Interpret TOKEN, a floating point number with FLAGS as classified
885 interpret_float (token, flags)
886 const cpp_token *token;
891 REAL_VALUE_TYPE real;
894 const char *typename;
896 /* FIXME: make %T work in error/warning, then we don't need typename. */
897 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
899 type = long_double_type_node;
900 typename = "long double";
902 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
903 || flag_single_precision_constant)
905 type = float_type_node;
910 type = double_type_node;
914 /* Copy the constant to a nul-terminated buffer. If the constant
915 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
916 can't handle them. */
917 copylen = token->val.str.len;
918 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
919 /* Must be an F or L suffix. */
921 if (flags & CPP_N_IMAGINARY)
925 copy = alloca (copylen + 1);
926 memcpy (copy, token->val.str.text, copylen);
927 copy[copylen] = '\0';
929 real_from_string (&real, copy);
930 real_convert (&real, TYPE_MODE (type), &real);
932 /* A diagnostic is required for "soft" overflow by some ISO C
933 testsuites. This is not pedwarn, because some people don't want
935 ??? That's a dubious reason... is this a mandatory diagnostic or
936 isn't it? -- zw, 2001-08-21. */
937 if (REAL_VALUE_ISINF (real) && pedantic)
938 warning ("floating constant exceeds range of \"%s\"", typename);
940 /* Create a node with determined type and value. */
941 value = build_real (type, real);
942 if (flags & CPP_N_IMAGINARY)
943 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
949 lex_string (str, len, wide)
950 const unsigned char *str;
955 char *buf = alloca ((len + 1) * (wide ? WCHAR_BYTES : 1));
957 const unsigned char *p = str, *limit = str + len;
960 #ifdef MULTIBYTE_CHARS
961 /* Reset multibyte conversion state. */
962 (void) local_mbtowc (NULL, NULL, 0);
967 #ifdef MULTIBYTE_CHARS
971 char_len = local_mbtowc (&wc, (const char *) p, limit - p);
974 warning ("ignoring invalid multibyte character");
987 if (c == '\\' && !ignore_escape_flag)
988 c = cpp_parse_escape (parse_in, &p, limit, wide);
990 /* Add this single character into the buffer either as a wchar_t,
991 a multibyte sequence, or as a single byte. */
994 unsigned charwidth = TYPE_PRECISION (char_type_node);
995 unsigned bytemask = (1 << charwidth) - 1;
998 for (byte = 0; byte < WCHAR_BYTES; ++byte)
1001 if (byte >= (int) sizeof (c))
1004 n = (c >> (byte * charwidth)) & bytemask;
1005 if (BYTES_BIG_ENDIAN)
1006 q[WCHAR_BYTES - byte - 1] = n;
1012 #ifdef MULTIBYTE_CHARS
1013 else if (char_len > 1)
1015 /* We're dealing with a multibyte character. */
1016 for ( ; char_len >0; --char_len)
1018 *q++ = *(p - char_len);
1028 /* Terminate the string value, either with a single byte zero
1029 or with a wide zero. */
1033 memset (q, 0, WCHAR_BYTES);
1041 value = build_string (q - buf, buf);
1044 TREE_TYPE (value) = wchar_array_type_node;
1046 TREE_TYPE (value) = char_array_type_node;
1050 /* Converts a (possibly wide) character constant token into a tree. */
1052 lex_charconst (token)
1053 const cpp_token *token;
1057 unsigned int chars_seen;
1060 result = cpp_interpret_charconst (parse_in, token,
1061 &chars_seen, &unsignedp);
1063 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1064 before possibly widening to HOST_WIDE_INT for build_int_2. */
1065 if (unsignedp || (cppchar_signed_t) result >= 0)
1066 value = build_int_2 (result, 0);
1068 value = build_int_2 ((cppchar_signed_t) result, -1);
1070 if (token->type == CPP_WCHAR)
1071 type = wchar_type_node;
1072 /* In C, a character constant has type 'int'.
1073 In C++ 'char', but multi-char charconsts have type 'int'. */
1074 else if ((c_language == clk_c) || chars_seen > 1)
1075 type = integer_type_node;
1077 type = char_type_node;
1079 TREE_TYPE (value) = type;