1 /* Lexical analyzer for C and Objective C.
2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997
3 1998, 1999, 2000 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
39 #include "splay-tree.h"
42 /* MULTIBYTE_CHARS support only works for native compilers.
43 ??? Ideally what we want is to model widechar support after
44 the current floating point support. */
46 #undef MULTIBYTE_CHARS
49 #ifdef MULTIBYTE_CHARS
52 #endif /* MULTIBYTE_CHARS */
53 #ifndef GET_ENVIRONMENT
54 #define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
57 /* The input filename as understood by CPP, where "" represents stdin. */
58 static const char *cpp_filename
;
60 /* We may keep statistics about how long which files took to compile. */
61 static int header_time
, body_time
;
62 static splay_tree file_info_tree
;
64 /* Cause the `yydebug' variable to be defined. */
67 /* File used for outputting assembler code. */
68 extern FILE *asm_out_file
;
70 #undef WCHAR_TYPE_SIZE
71 #define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node)
73 /* Number of bytes in a wide character. */
74 #define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT)
76 int indent_level
; /* Number of { minus number of }. */
77 int pending_lang_change
; /* If we need to switch languages - C++ only */
78 int c_header_level
; /* depth in C headers - C++ only */
80 /* Nonzero tells yylex to ignore \ in string constants. */
81 static int ignore_escape_flag
;
83 static void parse_float
PARAMS ((PTR
));
84 static tree lex_number
PARAMS ((const char *, unsigned int));
85 static tree lex_string
PARAMS ((const char *, unsigned int, int));
86 static tree lex_charconst
PARAMS ((const cpp_token
*));
87 static void update_header_times
PARAMS ((const char *));
88 static int dump_one_header
PARAMS ((splay_tree_node
, void *));
89 static void cb_ident
PARAMS ((cpp_reader
*, unsigned int,
91 static void cb_file_change
PARAMS ((cpp_reader
*, const cpp_file_change
*));
92 static void cb_def_pragma
PARAMS ((cpp_reader
*, unsigned int));
93 static void cb_define
PARAMS ((cpp_reader
*, unsigned int,
95 static void cb_undef
PARAMS ((cpp_reader
*, unsigned int,
100 const char *filename
;
102 struct cpp_callbacks
*cb
;
103 struct c_fileinfo
*toplevel
;
105 /* Set up filename timing. Must happen before cpp_start_read. */
106 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
)strcmp
,
108 (splay_tree_delete_value_fn
)free
);
109 toplevel
= get_fileinfo ("<top level>");
110 if (flag_detailed_statistics
)
113 body_time
= get_run_time ();
114 toplevel
->time
= body_time
;
117 #ifdef MULTIBYTE_CHARS
118 /* Change to the native locale for multibyte conversions. */
119 setlocale (LC_CTYPE
, "");
120 GET_ENVIRONMENT (literal_codeset
, "LANG");
123 cb
= cpp_get_callbacks (parse_in
);
125 cb
->ident
= cb_ident
;
126 cb
->file_change
= cb_file_change
;
127 cb
->def_pragma
= cb_def_pragma
;
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
))
133 cb
->define
= cb_define
;
134 cb
->undef
= cb_undef
;
138 if (filename
== 0 || !strcmp (filename
, "-"))
139 filename
= "stdin", cpp_filename
= "";
141 cpp_filename
= filename
;
149 /* A thin wrapper around the real parser that initializes the
150 integrated preprocessor after debug output has been initialized. */
155 if (! cpp_start_read (parse_in
, cpp_filename
))
156 return 1; /* cpplib has emitted an error. */
166 struct c_fileinfo
*fi
;
168 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
170 return (struct c_fileinfo
*) n
->value
;
172 fi
= (struct c_fileinfo
*) xmalloc (sizeof (struct c_fileinfo
));
174 fi
->interface_only
= 0;
175 fi
->interface_unknown
= 1;
176 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
177 (splay_tree_value
) fi
);
182 update_header_times (name
)
185 /* Changing files again. This means currently collected time
186 is charged against header time, and body time starts back at 0. */
187 if (flag_detailed_statistics
)
189 int this_time
= get_run_time ();
190 struct c_fileinfo
*file
= get_fileinfo (name
);
191 header_time
+= this_time
- body_time
;
192 file
->time
+= this_time
- body_time
;
193 body_time
= this_time
;
198 dump_one_header (n
, dummy
)
200 void *dummy ATTRIBUTE_UNUSED
;
202 print_time ((const char *) n
->key
,
203 ((struct c_fileinfo
*) n
->value
)->time
);
208 dump_time_statistics ()
210 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
211 int this_time
= get_run_time ();
212 file
->time
+= this_time
- body_time
;
214 fprintf (stderr
, "\n******\n");
215 print_time ("header files (total)", header_time
);
216 print_time ("main file (total)", this_time
- body_time
);
217 fprintf (stderr
, "ratio = %g : 1\n",
218 (double)header_time
/ (double)(this_time
- body_time
));
219 fprintf (stderr
, "\n******\n");
221 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
224 /* Not yet handled: #pragma, #define, #undef.
225 No need to deal with linemarkers under normal conditions. */
228 cb_ident (pfile
, line
, str
)
229 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
230 unsigned int line ATTRIBUTE_UNUSED
;
231 const cpp_string
*str ATTRIBUTE_UNUSED
;
233 #ifdef ASM_OUTPUT_IDENT
236 /* Convert escapes in the string. */
237 tree value
= lex_string ((const char *)str
->text
, str
->len
, 0);
238 ASM_OUTPUT_IDENT (asm_out_file
, TREE_STRING_POINTER (value
));
244 cb_file_change (pfile
, fc
)
245 cpp_reader
*pfile ATTRIBUTE_UNUSED
;
246 const cpp_file_change
*fc
;
248 unsigned int from_line
= SOURCE_LINE (fc
->map
- 1, fc
->line
- 1);
250 if (fc
->reason
== LC_ENTER
)
252 /* Don't stack the main buffer on the input stack;
253 we already did in compile_file. */
254 if (MAIN_FILE_P (fc
->map
))
255 main_input_filename
= fc
->map
->to_file
;
259 push_srcloc (fc
->map
->to_file
, 1);
260 input_file_stack
->indent_level
= indent_level
;
261 (*debug_hooks
->start_source_file
) (lineno
, fc
->map
->to_file
);
262 #ifndef NO_IMPLICIT_EXTERN_C
265 else if (fc
->externc
)
268 ++pending_lang_change
;
273 else if (fc
->reason
== LC_LEAVE
)
275 /* Popping out of a file. */
276 if (input_file_stack
->next
)
278 #ifndef NO_IMPLICIT_EXTERN_C
279 if (c_header_level
&& --c_header_level
== 0)
282 warning ("badly nested C headers from preprocessor");
283 --pending_lang_change
;
287 if (indent_level
!= input_file_stack
->indent_level
)
289 warning_with_file_and_line
290 (input_filename
, lineno
,
291 "This file contains more '%c's than '%c's.",
292 indent_level
> input_file_stack
->indent_level
? '{' : '}',
293 indent_level
> input_file_stack
->indent_level
? '}' : '{');
297 (*debug_hooks
->end_source_file
) (from_line
);
300 error ("leaving more files than we entered");
303 update_header_times (fc
->map
->to_file
);
304 in_system_header
= fc
->sysp
!= 0;
305 input_filename
= fc
->map
->to_file
;
306 lineno
= SOURCE_LINE (fc
->map
, fc
->line
); /* Do we need this? */
309 extract_interface_info ();
313 cb_def_pragma (pfile
, line
)
315 unsigned int line ATTRIBUTE_UNUSED
;
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
= 0;
325 cpp_get_token (pfile
, &s
);
326 space
= cpp_token_as_text (pfile
, &s
);
327 cpp_get_token (pfile
, &s
);
328 if (s
.type
== CPP_NAME
)
329 name
= cpp_token_as_text (pfile
, &s
);
331 lineno
= cpp_get_line (parse_in
)->line
;
333 warning ("ignoring #pragma %s %s", space
, name
);
335 warning ("ignoring #pragma %s", space
);
339 /* #define callback for DWARF and DWARF2 debug info. */
341 cb_define (pfile
, line
, node
)
343 unsigned int line ATTRIBUTE_UNUSED
;
346 (*debug_hooks
->define
) (cpp_get_line (pfile
)->line
,
347 (const char *) cpp_macro_definition (pfile
, node
));
350 /* #undef callback for DWARF and DWARF2 debug info. */
352 cb_undef (pfile
, line
, node
)
354 unsigned int line ATTRIBUTE_UNUSED
;
357 (*debug_hooks
->undef
) (cpp_get_line (pfile
)->line
,
358 (const char *) NODE_NAME (node
));
362 /* Returns nonzero if C is a universal-character-name. Give an error if it
363 is not one which may appear in an identifier, as per [extendid].
365 Note that extended character support in identifiers has not yet been
366 implemented. It is my personal opinion that this is not a desirable
367 feature. Portable code cannot count on support for more than the basic
368 identifier character set. */
381 /* None of the valid chars are outside the Basic Multilingual Plane (the
385 error ("universal-character-name '\\U%08x' not valid in identifier", c
);
390 if ((c
>= 0x00c0 && c
<= 0x00d6)
391 || (c
>= 0x00d8 && c
<= 0x00f6)
392 || (c
>= 0x00f8 && c
<= 0x01f5)
393 || (c
>= 0x01fa && c
<= 0x0217)
394 || (c
>= 0x0250 && c
<= 0x02a8)
395 || (c
>= 0x1e00 && c
<= 0x1e9a)
396 || (c
>= 0x1ea0 && c
<= 0x1ef9))
401 || (c
>= 0x0388 && c
<= 0x038a)
403 || (c
>= 0x038e && c
<= 0x03a1)
404 || (c
>= 0x03a3 && c
<= 0x03ce)
405 || (c
>= 0x03d0 && c
<= 0x03d6)
410 || (c
>= 0x03e2 && c
<= 0x03f3)
411 || (c
>= 0x1f00 && c
<= 0x1f15)
412 || (c
>= 0x1f18 && c
<= 0x1f1d)
413 || (c
>= 0x1f20 && c
<= 0x1f45)
414 || (c
>= 0x1f48 && c
<= 0x1f4d)
415 || (c
>= 0x1f50 && c
<= 0x1f57)
419 || (c
>= 0x1f5f && c
<= 0x1f7d)
420 || (c
>= 0x1f80 && c
<= 0x1fb4)
421 || (c
>= 0x1fb6 && c
<= 0x1fbc)
422 || (c
>= 0x1fc2 && c
<= 0x1fc4)
423 || (c
>= 0x1fc6 && c
<= 0x1fcc)
424 || (c
>= 0x1fd0 && c
<= 0x1fd3)
425 || (c
>= 0x1fd6 && c
<= 0x1fdb)
426 || (c
>= 0x1fe0 && c
<= 0x1fec)
427 || (c
>= 0x1ff2 && c
<= 0x1ff4)
428 || (c
>= 0x1ff6 && c
<= 0x1ffc))
432 if ((c
>= 0x0401 && c
<= 0x040d)
433 || (c
>= 0x040f && c
<= 0x044f)
434 || (c
>= 0x0451 && c
<= 0x045c)
435 || (c
>= 0x045e && c
<= 0x0481)
436 || (c
>= 0x0490 && c
<= 0x04c4)
437 || (c
>= 0x04c7 && c
<= 0x04c8)
438 || (c
>= 0x04cb && c
<= 0x04cc)
439 || (c
>= 0x04d0 && c
<= 0x04eb)
440 || (c
>= 0x04ee && c
<= 0x04f5)
441 || (c
>= 0x04f8 && c
<= 0x04f9))
445 if ((c
>= 0x0531 && c
<= 0x0556)
446 || (c
>= 0x0561 && c
<= 0x0587))
450 if ((c
>= 0x05d0 && c
<= 0x05ea)
451 || (c
>= 0x05f0 && c
<= 0x05f4))
455 if ((c
>= 0x0621 && c
<= 0x063a)
456 || (c
>= 0x0640 && c
<= 0x0652)
457 || (c
>= 0x0670 && c
<= 0x06b7)
458 || (c
>= 0x06ba && c
<= 0x06be)
459 || (c
>= 0x06c0 && c
<= 0x06ce)
460 || (c
>= 0x06e5 && c
<= 0x06e7))
464 if ((c
>= 0x0905 && c
<= 0x0939)
465 || (c
>= 0x0958 && c
<= 0x0962))
469 if ((c
>= 0x0985 && c
<= 0x098c)
470 || (c
>= 0x098f && c
<= 0x0990)
471 || (c
>= 0x0993 && c
<= 0x09a8)
472 || (c
>= 0x09aa && c
<= 0x09b0)
474 || (c
>= 0x09b6 && c
<= 0x09b9)
475 || (c
>= 0x09dc && c
<= 0x09dd)
476 || (c
>= 0x09df && c
<= 0x09e1)
477 || (c
>= 0x09f0 && c
<= 0x09f1))
481 if ((c
>= 0x0a05 && c
<= 0x0a0a)
482 || (c
>= 0x0a0f && c
<= 0x0a10)
483 || (c
>= 0x0a13 && c
<= 0x0a28)
484 || (c
>= 0x0a2a && c
<= 0x0a30)
485 || (c
>= 0x0a32 && c
<= 0x0a33)
486 || (c
>= 0x0a35 && c
<= 0x0a36)
487 || (c
>= 0x0a38 && c
<= 0x0a39)
488 || (c
>= 0x0a59 && c
<= 0x0a5c)
493 if ((c
>= 0x0a85 && c
<= 0x0a8b)
495 || (c
>= 0x0a8f && c
<= 0x0a91)
496 || (c
>= 0x0a93 && c
<= 0x0aa8)
497 || (c
>= 0x0aaa && c
<= 0x0ab0)
498 || (c
>= 0x0ab2 && c
<= 0x0ab3)
499 || (c
>= 0x0ab5 && c
<= 0x0ab9)
504 if ((c
>= 0x0b05 && c
<= 0x0b0c)
505 || (c
>= 0x0b0f && c
<= 0x0b10)
506 || (c
>= 0x0b13 && c
<= 0x0b28)
507 || (c
>= 0x0b2a && c
<= 0x0b30)
508 || (c
>= 0x0b32 && c
<= 0x0b33)
509 || (c
>= 0x0b36 && c
<= 0x0b39)
510 || (c
>= 0x0b5c && c
<= 0x0b5d)
511 || (c
>= 0x0b5f && c
<= 0x0b61))
515 if ((c
>= 0x0b85 && c
<= 0x0b8a)
516 || (c
>= 0x0b8e && c
<= 0x0b90)
517 || (c
>= 0x0b92 && c
<= 0x0b95)
518 || (c
>= 0x0b99 && c
<= 0x0b9a)
520 || (c
>= 0x0b9e && c
<= 0x0b9f)
521 || (c
>= 0x0ba3 && c
<= 0x0ba4)
522 || (c
>= 0x0ba8 && c
<= 0x0baa)
523 || (c
>= 0x0bae && c
<= 0x0bb5)
524 || (c
>= 0x0bb7 && c
<= 0x0bb9))
528 if ((c
>= 0x0c05 && c
<= 0x0c0c)
529 || (c
>= 0x0c0e && c
<= 0x0c10)
530 || (c
>= 0x0c12 && c
<= 0x0c28)
531 || (c
>= 0x0c2a && c
<= 0x0c33)
532 || (c
>= 0x0c35 && c
<= 0x0c39)
533 || (c
>= 0x0c60 && c
<= 0x0c61))
537 if ((c
>= 0x0c85 && c
<= 0x0c8c)
538 || (c
>= 0x0c8e && c
<= 0x0c90)
539 || (c
>= 0x0c92 && c
<= 0x0ca8)
540 || (c
>= 0x0caa && c
<= 0x0cb3)
541 || (c
>= 0x0cb5 && c
<= 0x0cb9)
542 || (c
>= 0x0ce0 && c
<= 0x0ce1))
546 if ((c
>= 0x0d05 && c
<= 0x0d0c)
547 || (c
>= 0x0d0e && c
<= 0x0d10)
548 || (c
>= 0x0d12 && c
<= 0x0d28)
549 || (c
>= 0x0d2a && c
<= 0x0d39)
550 || (c
>= 0x0d60 && c
<= 0x0d61))
554 if ((c
>= 0x0e01 && c
<= 0x0e30)
555 || (c
>= 0x0e32 && c
<= 0x0e33)
556 || (c
>= 0x0e40 && c
<= 0x0e46)
557 || (c
>= 0x0e4f && c
<= 0x0e5b))
561 if ((c
>= 0x0e81 && c
<= 0x0e82)
567 || (c
>= 0x0e94 && c
<= 0x0e97)
568 || (c
>= 0x0e99 && c
<= 0x0e9f)
569 || (c
>= 0x0ea1 && c
<= 0x0ea3)
574 || (c
>= 0x0ead && c
<= 0x0eb0)
578 || (c
>= 0x0ec0 && c
<= 0x0ec4)
583 if ((c
>= 0x10a0 && c
<= 0x10c5)
584 || (c
>= 0x10d0 && c
<= 0x10f6))
588 if ((c
>= 0x3041 && c
<= 0x3094)
589 || (c
>= 0x309b && c
<= 0x309e))
593 if ((c
>= 0x30a1 && c
<= 0x30fe))
597 if ((c
>= 0x3105 && c
<= 0x312c))
601 if ((c
>= 0x1100 && c
<= 0x1159)
602 || (c
>= 0x1161 && c
<= 0x11a2)
603 || (c
>= 0x11a8 && c
<= 0x11f9))
606 /* CJK Unified Ideographs */
607 if ((c
>= 0xf900 && c
<= 0xfa2d)
608 || (c
>= 0xfb1f && c
<= 0xfb36)
609 || (c
>= 0xfb38 && c
<= 0xfb3c)
611 || (c
>= 0xfb40 && c
<= 0xfb41)
612 || (c
>= 0xfb42 && c
<= 0xfb44)
613 || (c
>= 0xfb46 && c
<= 0xfbb1)
614 || (c
>= 0xfbd3 && c
<= 0xfd3f)
615 || (c
>= 0xfd50 && c
<= 0xfd8f)
616 || (c
>= 0xfd92 && c
<= 0xfdc7)
617 || (c
>= 0xfdf0 && c
<= 0xfdfb)
618 || (c
>= 0xfe70 && c
<= 0xfe72)
620 || (c
>= 0xfe76 && c
<= 0xfefc)
621 || (c
>= 0xff21 && c
<= 0xff3a)
622 || (c
>= 0xff41 && c
<= 0xff5a)
623 || (c
>= 0xff66 && c
<= 0xffbe)
624 || (c
>= 0xffc2 && c
<= 0xffc7)
625 || (c
>= 0xffca && c
<= 0xffcf)
626 || (c
>= 0xffd2 && c
<= 0xffd7)
627 || (c
>= 0xffda && c
<= 0xffdc)
628 || (c
>= 0x4e00 && c
<= 0x9fa5))
631 error ("universal-character-name '\\u%04x' not valid in identifier", c
);
636 /* Add the UTF-8 representation of C to the token_buffer. */
639 utf8_extend_token (c
)
649 else if (c
<= 0x000007ff)
650 shift
= 6, mask
= 0xc0;
651 else if (c
<= 0x0000ffff)
652 shift
= 12, mask
= 0xe0;
653 else if (c
<= 0x001fffff)
654 shift
= 18, mask
= 0xf0;
655 else if (c
<= 0x03ffffff)
656 shift
= 24, mask
= 0xf8;
658 shift
= 30, mask
= 0xfc;
660 extend_token (mask
| (c
>> shift
));
664 extend_token ((unsigned char) (0x80 | (c
>> shift
)));
679 struct try_type type_sequence
[] =
681 { &integer_type_node
, 0, 0, 0},
682 { &unsigned_type_node
, 1, 0, 0},
683 { &long_integer_type_node
, 0, 1, 0},
684 { &long_unsigned_type_node
, 1, 1, 0},
685 { &long_long_integer_type_node
, 0, 1, 1},
686 { &long_long_unsigned_type_node
, 1, 1, 1}
698 int conversion_errno
;
699 REAL_VALUE_TYPE value
;
707 struct pf_args
* args
= (struct pf_args
*) data
;
708 const char *typename
;
710 args
->conversion_errno
= 0;
711 args
->type
= double_type_node
;
714 /* The second argument, machine_mode, of REAL_VALUE_ATOF
715 tells the desired precision of the binary result
716 of decimal-to-binary conversion. */
721 error ("both 'f' and 'l' suffixes on floating constant");
723 args
->type
= float_type_node
;
726 else if (args
->lflag
)
728 args
->type
= long_double_type_node
;
729 typename
= "long double";
731 else if (flag_single_precision_constant
)
733 args
->type
= float_type_node
;
738 if (args
->base
== 16)
739 args
->value
= REAL_VALUE_HTOF (args
->str
, TYPE_MODE (args
->type
));
741 args
->value
= REAL_VALUE_ATOF (args
->str
, TYPE_MODE (args
->type
));
743 args
->conversion_errno
= errno
;
744 /* A diagnostic is required here by some ISO C testsuites.
745 This is not pedwarn, because some people don't want
746 an error for this. */
747 if (REAL_VALUE_ISINF (args
->value
) && pedantic
)
748 warning ("floating point number exceeds range of '%s'", typename
);
759 timevar_push (TV_CPP
);
760 cpp_get_token (parse_in
, &tok
);
761 timevar_pop (TV_CPP
);
763 /* The C++ front end does horrible things with the current line
764 number. To ensure an accurate line number, we must reset it
765 every time we return a token. */
766 lineno
= cpp_get_line (parse_in
)->line
;
772 case CPP_OPEN_BRACE
: indent_level
++; break;
773 case CPP_CLOSE_BRACE
: indent_level
--; break;
775 /* Issue this error here, where we can get at tok.val.c. */
777 if (ISGRAPH (tok
.val
.c
))
778 error ("stray '%c' in program", tok
.val
.c
);
780 error ("stray '\\%o' in program", tok
.val
.c
);
784 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
.val
.node
));
788 *value
= lex_number ((const char *)tok
.val
.str
.text
, tok
.val
.str
.len
);
793 *value
= lex_charconst (&tok
);
798 *value
= lex_string ((const char *)tok
.val
.str
.text
,
799 tok
.val
.str
.len
, tok
.type
== CPP_WSTRING
);
802 /* These tokens should not be visible outside cpplib. */
803 case CPP_HEADER_NAME
:
814 #define ERROR(msgid) do { error(msgid); goto syntax_error; } while(0)
817 lex_number (str
, len
)
823 int largest_digit
= 0;
829 enum anon1
{ NOT_FLOAT
= 0, AFTER_POINT
, AFTER_EXPON
} floatflag
= NOT_FLOAT
;
831 /* We actually store only HOST_BITS_PER_CHAR bits in each part.
832 The code below which fills the parts array assumes that a host
833 int is at least twice as wide as a host char, and that
834 HOST_BITS_PER_WIDE_INT is an even multiple of HOST_BITS_PER_CHAR.
835 Two HOST_WIDE_INTs is the largest int literal we can store.
836 In order to detect overflow below, the number of parts (TOTAL_PARTS)
837 must be exactly the number of parts needed to hold the bits
838 of two HOST_WIDE_INTs. */
839 #define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
840 unsigned int parts
[TOTAL_PARTS
];
842 /* Optimize for most frequent case. */
846 return integer_zero_node
;
847 else if (*str
== '1')
848 return integer_one_node
;
850 return build_int_2 (*str
- '0', 0);
853 for (count
= 0; count
< TOTAL_PARTS
; count
++)
856 /* len is known to be >1 at this point. */
859 if (len
> 2 && str
[0] == '0' && (str
[1] == 'x' || str
[1] == 'X'))
864 /* The ISDIGIT check is so we are not confused by a suffix on 0. */
865 else if (str
[0] == '0' && ISDIGIT (str
[1]))
877 if (floatflag
== AFTER_POINT
)
878 ERROR ("too many decimal points in floating constant");
879 else if (floatflag
== AFTER_EXPON
)
880 ERROR ("decimal point in exponent - impossible!");
882 floatflag
= AFTER_POINT
;
888 /* Possible future extension: silently ignore _ in numbers,
889 permitting cosmetic grouping - e.g. 0x8000_0000 == 0x80000000
890 but somewhat easier to read. Ada has this? */
891 ERROR ("underscore in number");
895 /* It is not a decimal point.
896 It should be a digit (perhaps a hex digit). */
902 else if (base
<= 10 && (c
== 'e' || c
== 'E'))
905 floatflag
= AFTER_EXPON
;
908 else if (base
== 16 && (c
== 'p' || c
== 'P'))
910 floatflag
= AFTER_EXPON
;
911 break; /* start of exponent */
913 else if (base
== 16 && c
>= 'a' && c
<= 'f')
917 else if (base
== 16 && c
>= 'A' && c
<= 'F')
924 break; /* start of suffix */
927 if (n
>= largest_digit
)
931 for (count
= 0; count
< TOTAL_PARTS
; count
++)
933 parts
[count
] *= base
;
937 += (parts
[count
-1] >> HOST_BITS_PER_CHAR
);
939 &= (1 << HOST_BITS_PER_CHAR
) - 1;
945 /* If the highest-order part overflows (gets larger than
946 a host char will hold) then the whole number has
947 overflowed. Record this and truncate the highest-order
949 if (parts
[TOTAL_PARTS
- 1] >> HOST_BITS_PER_CHAR
)
952 parts
[TOTAL_PARTS
- 1] &= (1 << HOST_BITS_PER_CHAR
) - 1;
956 while (p
< str
+ len
);
958 /* This can happen on input like `int i = 0x;' */
960 ERROR ("numeric constant with no digits");
962 if (largest_digit
>= base
)
963 ERROR ("numeric constant contains digits beyond the radix");
965 if (floatflag
!= NOT_FLOAT
)
968 int imag
, fflag
, lflag
, conversion_errno
;
969 REAL_VALUE_TYPE real
;
973 if (base
== 16 && pedantic
&& !flag_isoc99
)
974 pedwarn ("floating constant may not be in radix 16");
976 if (base
== 16 && floatflag
!= AFTER_EXPON
)
977 ERROR ("hexadecimal floating constant has no exponent");
979 /* Read explicit exponent if any, and put it in tokenbuf. */
980 if ((base
== 10 && ((c
== 'e') || (c
== 'E')))
981 || (base
== 16 && (c
== 'p' || c
== 'P')))
985 if (p
< str
+ len
&& (c
== '+' || c
== '-'))
987 /* Exponent is decimal, even if string is a hex float. */
989 ERROR ("floating constant exponent has no digits");
990 while (p
< str
+ len
&& ISDIGIT (c
))
996 /* Copy the float constant now; we don't want any suffixes in the
997 string passed to parse_float. */
998 copy
= alloca (p
- str
+ 1);
999 memcpy (copy
, str
, p
- str
);
1000 copy
[p
- str
] = '\0';
1002 /* Now parse suffixes. */
1003 fflag
= lflag
= imag
= 0;
1004 while (p
< str
+ len
)
1009 ERROR ("more than one 'f' suffix on floating constant");
1010 else if (warn_traditional
&& !in_system_header
1011 && ! cpp_sys_macro_p (parse_in
))
1012 warning ("traditional C rejects the 'f' suffix");
1019 ERROR ("more than one 'l' suffix on floating constant");
1020 else if (warn_traditional
&& !in_system_header
1021 && ! cpp_sys_macro_p (parse_in
))
1022 warning ("traditional C rejects the 'l' suffix");
1030 ERROR ("more than one 'i' or 'j' suffix on floating constant");
1032 pedwarn ("ISO C forbids imaginary numeric constants");
1037 ERROR ("invalid suffix on floating constant");
1040 /* Setup input for parse_float() */
1046 /* Convert string to a double, checking for overflow. */
1047 if (do_float_handler (parse_float
, (PTR
) &args
))
1049 /* Receive output from parse_float() */
1053 /* We got an exception from parse_float() */
1054 ERROR ("floating constant out of range");
1056 /* Receive output from parse_float() */
1057 conversion_errno
= args
.conversion_errno
;
1061 /* ERANGE is also reported for underflow,
1062 so test the value to distinguish overflow from that. */
1063 if (conversion_errno
== ERANGE
&& !flag_traditional
&& pedantic
1064 && (REAL_VALUES_LESS (dconst1
, real
)
1065 || REAL_VALUES_LESS (real
, dconstm1
)))
1066 warning ("floating point number exceeds range of 'double'");
1069 /* Create a node with determined type and value. */
1071 value
= build_complex (NULL_TREE
, convert (type
, integer_zero_node
),
1072 build_real (type
, real
));
1074 value
= build_real (type
, real
);
1078 tree trad_type
, ansi_type
, type
;
1079 HOST_WIDE_INT high
, low
;
1080 int spec_unsigned
= 0;
1082 int spec_long_long
= 0;
1087 trad_type
= ansi_type
= type
= NULL_TREE
;
1088 while (p
< str
+ len
)
1095 error ("two 'u' suffixes on integer constant");
1096 else if (warn_traditional
&& !in_system_header
1097 && ! cpp_sys_macro_p (parse_in
))
1098 warning ("traditional C rejects the 'u' suffix");
1109 error ("three 'l' suffixes on integer constant");
1111 error ("'lul' is not a valid integer suffix");
1112 else if (c
!= spec_long
)
1113 error ("'Ll' and 'lL' are not valid integer suffixes");
1114 else if (pedantic
&& ! flag_isoc99
1115 && ! in_system_header
&& warn_long_long
)
1116 pedwarn ("ISO C89 forbids long long integer constants");
1122 case 'i': case 'I': case 'j': case 'J':
1124 error ("more than one 'i' or 'j' suffix on integer constant");
1126 pedwarn ("ISO C forbids imaginary numeric constants");
1131 ERROR ("invalid suffix on integer constant");
1135 /* If the literal overflowed, pedwarn about it now. */
1139 pedwarn ("integer constant is too large for this configuration of the compiler - truncated to %d bits", HOST_BITS_PER_WIDE_INT
* 2);
1142 /* This is simplified by the fact that our constant
1143 is always positive. */
1147 for (i
= 0; i
< HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
; i
++)
1149 high
|= ((HOST_WIDE_INT
) parts
[i
+ (HOST_BITS_PER_WIDE_INT
1150 / HOST_BITS_PER_CHAR
)]
1151 << (i
* HOST_BITS_PER_CHAR
));
1152 low
|= (HOST_WIDE_INT
) parts
[i
] << (i
* HOST_BITS_PER_CHAR
);
1155 value
= build_int_2 (low
, high
);
1156 TREE_TYPE (value
) = long_long_unsigned_type_node
;
1158 /* If warn_traditional, calculate both the ISO type and the
1159 traditional type, then see if they disagree.
1160 Otherwise, calculate only the type for the dialect in use. */
1161 if (warn_traditional
|| flag_traditional
)
1163 /* Calculate the traditional type. */
1164 /* Traditionally, any constant is signed; but if unsigned is
1165 specified explicitly, obey that. Use the smallest size
1166 with the right number of bits, except for one special
1167 case with decimal constants. */
1168 if (! spec_long
&& base
!= 10
1169 && int_fits_type_p (value
, unsigned_type_node
))
1170 trad_type
= spec_unsigned
? unsigned_type_node
: integer_type_node
;
1171 /* A decimal constant must be long if it does not fit in
1172 type int. I think this is independent of whether the
1173 constant is signed. */
1174 else if (! spec_long
&& base
== 10
1175 && int_fits_type_p (value
, integer_type_node
))
1176 trad_type
= spec_unsigned
? unsigned_type_node
: integer_type_node
;
1177 else if (! spec_long_long
)
1178 trad_type
= (spec_unsigned
1179 ? long_unsigned_type_node
1180 : long_integer_type_node
);
1181 else if (int_fits_type_p (value
,
1183 ? long_long_unsigned_type_node
1184 : long_long_integer_type_node
))
1185 trad_type
= (spec_unsigned
1186 ? long_long_unsigned_type_node
1187 : long_long_integer_type_node
);
1189 trad_type
= (spec_unsigned
1190 ? widest_unsigned_literal_type_node
1191 : widest_integer_literal_type_node
);
1193 if (warn_traditional
|| ! flag_traditional
)
1195 /* Calculate the ISO type. */
1196 if (! spec_long
&& ! spec_unsigned
1197 && int_fits_type_p (value
, integer_type_node
))
1198 ansi_type
= integer_type_node
;
1199 else if (! spec_long
&& (base
!= 10 || spec_unsigned
)
1200 && int_fits_type_p (value
, unsigned_type_node
))
1201 ansi_type
= unsigned_type_node
;
1202 else if (! spec_unsigned
&& !spec_long_long
1203 && int_fits_type_p (value
, long_integer_type_node
))
1204 ansi_type
= long_integer_type_node
;
1205 else if (! spec_long_long
1206 && int_fits_type_p (value
, long_unsigned_type_node
))
1207 ansi_type
= long_unsigned_type_node
;
1208 else if (! spec_unsigned
1209 && int_fits_type_p (value
, long_long_integer_type_node
))
1210 ansi_type
= long_long_integer_type_node
;
1211 else if (int_fits_type_p (value
, long_long_unsigned_type_node
))
1212 ansi_type
= long_long_unsigned_type_node
;
1213 else if (! spec_unsigned
1214 && int_fits_type_p (value
, widest_integer_literal_type_node
))
1215 ansi_type
= widest_integer_literal_type_node
;
1217 ansi_type
= widest_unsigned_literal_type_node
;
1220 type
= flag_traditional
? trad_type
: ansi_type
;
1222 /* We assume that constants specified in a non-decimal
1223 base are bit patterns, and that the programmer really
1224 meant what they wrote. */
1225 if (warn_traditional
&& !in_system_header
1226 && base
== 10 && trad_type
!= ansi_type
)
1228 if (TYPE_PRECISION (trad_type
) != TYPE_PRECISION (ansi_type
))
1229 warning ("width of integer constant changes with -traditional");
1230 else if (TREE_UNSIGNED (trad_type
) != TREE_UNSIGNED (ansi_type
))
1231 warning ("integer constant is unsigned in ISO C, signed with -traditional");
1233 warning ("width of integer constant may change on other systems with -traditional");
1236 if (pedantic
&& !flag_traditional
&& (flag_isoc99
|| !spec_long_long
)
1239 ? TYPE_PRECISION (long_long_integer_type_node
)
1240 : TYPE_PRECISION (long_integer_type_node
)) < TYPE_PRECISION (type
)))
1243 pedwarn ("integer constant larger than the maximum value of %s",
1245 ? (TREE_UNSIGNED (type
)
1246 ? "an unsigned long long int"
1247 : "a long long int")
1248 : "an unsigned long int"));
1251 if (base
== 10 && ! spec_unsigned
&& TREE_UNSIGNED (type
))
1252 warning ("decimal constant is so large that it is unsigned");
1256 if (TYPE_PRECISION (type
)
1257 <= TYPE_PRECISION (integer_type_node
))
1258 value
= build_complex (NULL_TREE
, integer_zero_node
,
1259 convert (integer_type_node
, value
));
1261 ERROR ("complex integer constant is too wide for 'complex int'");
1263 else if (flag_traditional
&& !int_fits_type_p (value
, type
))
1264 /* The traditional constant 0x80000000 is signed
1265 but doesn't fit in the range of int.
1266 This will change it to -0x80000000, which does fit. */
1268 TREE_TYPE (value
) = unsigned_type (type
);
1269 value
= convert (type
, value
);
1270 TREE_OVERFLOW (value
) = TREE_CONSTANT_OVERFLOW (value
) = 0;
1273 TREE_TYPE (value
) = type
;
1275 /* If it's still an integer (not a complex), and it doesn't
1276 fit in the type we choose for it, then pedwarn. */
1279 && TREE_CODE (TREE_TYPE (value
)) == INTEGER_TYPE
1280 && ! int_fits_type_p (value
, TREE_TYPE (value
)))
1281 pedwarn ("integer constant is larger than the maximum value for its type");
1285 error ("missing white space after number '%.*s'", (int) (p
- str
), str
);
1290 return integer_zero_node
;
1294 lex_string (str
, len
, wide
)
1300 char *buf
= alloca ((len
+ 1) * (wide
? WCHAR_BYTES
: 1));
1302 const char *p
= str
, *limit
= str
+ len
;
1304 unsigned width
= wide
? WCHAR_TYPE_SIZE
1305 : TYPE_PRECISION (char_type_node
);
1307 #ifdef MULTIBYTE_CHARS
1308 /* Reset multibyte conversion state. */
1309 (void) local_mbtowc (NULL
, NULL
, 0);
1314 #ifdef MULTIBYTE_CHARS
1318 char_len
= local_mbtowc (&wc
, p
, limit
- p
);
1321 warning ("Ignoring invalid multibyte character");
1334 if (c
== '\\' && !ignore_escape_flag
)
1338 if (width
< HOST_BITS_PER_INT
)
1339 mask
= ((unsigned int) 1 << width
) - 1;
1342 c
= cpp_parse_escape (parse_in
, (const unsigned char **) &p
,
1343 (const unsigned char *) limit
,
1344 mask
, flag_traditional
);
1347 /* Add this single character into the buffer either as a wchar_t
1348 or as a single byte. */
1351 unsigned charwidth
= TYPE_PRECISION (char_type_node
);
1352 unsigned bytemask
= (1 << charwidth
) - 1;
1355 for (byte
= 0; byte
< WCHAR_BYTES
; ++byte
)
1358 if (byte
>= (int) sizeof (c
))
1361 n
= (c
>> (byte
* charwidth
)) & bytemask
;
1362 if (BYTES_BIG_ENDIAN
)
1363 q
[WCHAR_BYTES
- byte
- 1] = n
;
1375 /* Terminate the string value, either with a single byte zero
1376 or with a wide zero. */
1380 memset (q
, 0, WCHAR_BYTES
);
1388 value
= build_string (q
- buf
, buf
);
1391 TREE_TYPE (value
) = wchar_array_type_node
;
1393 TREE_TYPE (value
) = char_array_type_node
;
1397 /* Converts a (possibly wide) character constant token into a tree. */
1399 lex_charconst (token
)
1400 const cpp_token
*token
;
1402 HOST_WIDE_INT result
;
1404 unsigned int chars_seen
;
1406 result
= cpp_interpret_charconst (parse_in
, token
, warn_multichar
,
1407 flag_traditional
, &chars_seen
);
1408 if (token
->type
== CPP_WCHAR
)
1410 value
= build_int_2 (result
, 0);
1411 TREE_TYPE (value
) = wchar_type_node
;
1416 value
= build_int_2 (result
, -1);
1418 value
= build_int_2 (result
, 0);
1420 /* In C, a character constant has type 'int'.
1421 In C++ 'char', but multi-char charconsts have type 'int'. */
1422 if (c_language
== clk_cplusplus
&& chars_seen
<= 1)
1423 TREE_TYPE (value
) = char_type_node
;
1425 TREE_TYPE (value
) = integer_type_node
;