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, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
35 #include "splay-tree.h"
39 /* We may keep statistics about how long which files took to compile. */
40 static int header_time
, body_time
;
41 static splay_tree file_info_tree
;
43 int pending_lang_change
; /* If we need to switch languages - C++ only */
44 int c_header_level
; /* depth in C headers - C++ only */
46 static tree
interpret_integer (const cpp_token
*, unsigned int);
47 static tree
interpret_float (const cpp_token
*, unsigned int, const char *);
48 static tree
interpret_fixed (const cpp_token
*, unsigned int);
49 static enum integer_type_kind narrowest_unsigned_type
50 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
51 static enum integer_type_kind narrowest_signed_type
52 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
53 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
54 static tree
lex_charconst (const cpp_token
*);
55 static void update_header_times (const char *);
56 static int dump_one_header (splay_tree_node
, void *);
57 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
58 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
59 static void cb_def_pragma (cpp_reader
*, unsigned int);
60 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
61 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
66 struct cpp_callbacks
*cb
;
67 struct c_fileinfo
*toplevel
;
69 /* The get_fileinfo data structure must be initialized before
70 cpp_read_main_file is called. */
71 toplevel
= get_fileinfo ("<top level>");
72 if (flag_detailed_statistics
)
75 body_time
= get_run_time ();
76 toplevel
->time
= body_time
;
79 cb
= cpp_get_callbacks (parse_in
);
81 cb
->line_change
= cb_line_change
;
83 cb
->def_pragma
= cb_def_pragma
;
84 cb
->valid_pch
= c_common_valid_pch
;
85 cb
->read_pch
= c_common_read_pch
;
87 /* Set the debug callbacks if we can use them. */
88 if ((debug_info_level
== DINFO_LEVEL_VERBOSE
89 && (write_symbols
== DWARF2_DEBUG
90 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
91 || flag_dump_go_spec
!= NULL
)
93 cb
->define
= cb_define
;
99 get_fileinfo (const char *name
)
102 struct c_fileinfo
*fi
;
105 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
107 (splay_tree_delete_value_fn
) free
);
109 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
111 return (struct c_fileinfo
*) n
->value
;
113 fi
= XNEW (struct c_fileinfo
);
115 fi
->interface_only
= 0;
116 fi
->interface_unknown
= 1;
117 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
118 (splay_tree_value
) fi
);
123 update_header_times (const char *name
)
125 /* Changing files again. This means currently collected time
126 is charged against header time, and body time starts back at 0. */
127 if (flag_detailed_statistics
)
129 int this_time
= get_run_time ();
130 struct c_fileinfo
*file
= get_fileinfo (name
);
131 header_time
+= this_time
- body_time
;
132 file
->time
+= this_time
- body_time
;
133 body_time
= this_time
;
138 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
140 print_time ((const char *) n
->key
,
141 ((struct c_fileinfo
*) n
->value
)->time
);
146 dump_time_statistics (void)
148 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
149 int this_time
= get_run_time ();
150 file
->time
+= this_time
- body_time
;
152 fprintf (stderr
, "\n******\n");
153 print_time ("header files (total)", header_time
);
154 print_time ("main file (total)", this_time
- body_time
);
155 fprintf (stderr
, "ratio = %g : 1\n",
156 (double) header_time
/ (double) (this_time
- body_time
));
157 fprintf (stderr
, "\n******\n");
159 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
163 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
164 unsigned int ARG_UNUSED (line
),
165 const cpp_string
* ARG_UNUSED (str
))
169 /* Convert escapes in the string. */
170 cpp_string cstr
= { 0, 0 };
171 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
173 targetm
.asm_out
.output_ident ((const char *) cstr
.text
);
174 free (CONST_CAST (unsigned char *, cstr
.text
));
179 /* Called at the start of every non-empty line. TOKEN is the first
180 lexed token on the line. Used for diagnostic line numbers. */
182 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
185 if (token
->type
!= CPP_EOF
&& !parsing_args
)
186 input_location
= token
->src_loc
;
190 fe_file_change (const struct line_map
*new_map
)
195 if (new_map
->reason
== LC_ENTER
)
197 /* Don't stack the main buffer on the input stack;
198 we already did in compile_file. */
199 if (!MAIN_FILE_P (new_map
))
201 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
203 if (included_at
> BUILTINS_LOCATION
)
204 line
= SOURCE_LINE (new_map
- 1, included_at
);
206 input_location
= new_map
->start_location
;
207 (*debug_hooks
->start_source_file
) (line
, LINEMAP_FILE (new_map
));
208 #ifndef NO_IMPLICIT_EXTERN_C
211 else if (LINEMAP_SYSP (new_map
) == 2)
214 ++pending_lang_change
;
219 else if (new_map
->reason
== LC_LEAVE
)
221 #ifndef NO_IMPLICIT_EXTERN_C
222 if (c_header_level
&& --c_header_level
== 0)
224 if (LINEMAP_SYSP (new_map
) == 2)
225 warning (0, "badly nested C headers from preprocessor");
226 --pending_lang_change
;
229 input_location
= new_map
->start_location
;
231 (*debug_hooks
->end_source_file
) (LINEMAP_LINE (new_map
));
234 update_header_times (LINEMAP_FILE (new_map
));
235 input_location
= new_map
->start_location
;
239 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
241 /* Issue a warning message if we have been asked to do so. Ignore
242 unknown pragmas in system headers unless an explicit
243 -Wunknown-pragmas has been given. */
244 if (warn_unknown_pragmas
> in_system_header
)
246 const unsigned char *space
, *name
;
248 location_t fe_loc
= loc
;
250 space
= name
= (const unsigned char *) "";
251 s
= cpp_get_token (pfile
);
252 if (s
->type
!= CPP_EOF
)
254 space
= cpp_token_as_text (pfile
, s
);
255 s
= cpp_get_token (pfile
);
256 if (s
->type
== CPP_NAME
)
257 name
= cpp_token_as_text (pfile
, s
);
260 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
265 /* #define callback for DWARF and DWARF2 debug info. */
267 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
269 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
270 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
271 (const char *) cpp_macro_definition (pfile
, node
));
274 /* #undef callback for DWARF and DWARF2 debug info. */
276 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
279 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
280 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
281 (const char *) NODE_NAME (node
));
284 /* Read a token and return its type. Fill *VALUE with its value, if
285 applicable. Fill *CPP_FLAGS with the token's flags, if it is
289 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
292 static bool no_more_pch
;
293 const cpp_token
*tok
;
295 unsigned char add_flags
= 0;
297 timevar_push (TV_CPP
);
299 tok
= cpp_get_token_with_location (parse_in
, loc
);
309 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
314 const char *suffix
= NULL
;
315 unsigned int flags
= cpp_classify_number (parse_in
, tok
, &suffix
, *loc
);
317 switch (flags
& CPP_N_CATEGORY
)
320 /* cpplib has issued an error. */
321 *value
= error_mark_node
;
325 /* C++ uses '0' to mark virtual functions as pure.
326 Set PURE_ZERO to pass this information to the C++ parser. */
327 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
328 add_flags
= PURE_ZERO
;
329 *value
= interpret_integer (tok
, flags
);
333 *value
= interpret_float (tok
, flags
, suffix
);
340 if (flags
& CPP_N_USERDEF
)
344 tree suffix_id
= get_identifier (suffix
);
345 int len
= tok
->val
.str
.len
- strlen (suffix
);
346 /* If this is going to be used as a C string to pass to a
347 raw literal operator, we need to add a trailing NUL. */
348 tree num_string
= build_string (len
+ 1,
349 (const char *) tok
->val
.str
.text
);
350 TREE_TYPE (num_string
) = char_array_type_node
;
351 num_string
= fix_string_type (num_string
);
352 str
= CONST_CAST (char *, TREE_STRING_POINTER (num_string
));
354 literal
= build_userdef_literal (suffix_id
, *value
,
362 /* An @ may give the next token special significance in Objective-C. */
363 if (c_dialect_objc ())
365 location_t atloc
= *loc
;
369 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
381 type
= lex_string (tok
, value
, true, true);
385 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
386 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
387 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
390 /* Note the complication: if we found an OBJC_CXX
391 keyword, for example, 'class', we will be
392 returning a token of type CPP_AT_NAME and rid
393 code RID_CLASS (not RID_AT_CLASS). The language
394 parser needs to convert that to RID_AT_CLASS.
402 error_at (atloc
, "stray %<@%> in program");
413 unsigned char name
[8];
415 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
417 error_at (*loc
, "stray %qs in program", name
);
424 cppchar_t c
= tok
->val
.str
.text
[0];
426 if (c
== '"' || c
== '\'')
427 error ("missing terminating %c character", (int) c
);
428 else if (ISGRAPH (c
))
429 error ("stray %qc in program", (int) c
);
431 error ("stray %<\\%o%> in program", (int) c
);
435 case CPP_CHAR_USERDEF
:
436 case CPP_WCHAR_USERDEF
:
437 case CPP_CHAR16_USERDEF
:
438 case CPP_CHAR32_USERDEF
:
441 cpp_token temp_tok
= *tok
;
442 const char *suffix
= cpp_get_userdef_suffix (tok
);
443 temp_tok
.val
.str
.len
-= strlen (suffix
);
444 temp_tok
.type
= cpp_userdef_char_remove_type (type
);
445 literal
= build_userdef_literal (get_identifier (suffix
),
446 lex_charconst (&temp_tok
), NULL_TREE
);
455 *value
= lex_charconst (tok
);
458 case CPP_STRING_USERDEF
:
459 case CPP_WSTRING_USERDEF
:
460 case CPP_STRING16_USERDEF
:
461 case CPP_STRING32_USERDEF
:
462 case CPP_UTF8STRING_USERDEF
:
464 tree literal
, string
;
465 const char *suffix
= cpp_get_userdef_suffix (tok
);
466 string
= build_string (tok
->val
.str
.len
- strlen (suffix
),
467 (const char *) tok
->val
.str
.text
);
468 literal
= build_userdef_literal (get_identifier (suffix
),
479 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
481 type
= lex_string (tok
, value
, false,
482 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
485 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
489 *value
= build_int_cst (integer_type_node
, tok
->val
.pragma
);
492 /* These tokens should not be visible outside cpplib. */
493 case CPP_HEADER_NAME
:
497 /* CPP_COMMENT will appear when compiling with -C and should be
508 *cpp_flags
= tok
->flags
| add_flags
;
513 c_common_no_more_pch ();
516 timevar_pop (TV_CPP
);
521 /* Returns the narrowest C-visible unsigned type, starting with the
522 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
525 static enum integer_type_kind
526 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
527 unsigned HOST_WIDE_INT high
,
532 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
533 itk
= itk_unsigned_int
;
534 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
535 itk
= itk_unsigned_long
;
537 itk
= itk_unsigned_long_long
;
539 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
543 if (integer_types
[itk
] == NULL_TREE
)
545 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
547 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
548 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
549 && TREE_INT_CST_LOW (upper
) >= low
))
550 return (enum integer_type_kind
) itk
;
556 /* Ditto, but narrowest signed type. */
557 static enum integer_type_kind
558 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
559 unsigned HOST_WIDE_INT high
, unsigned int flags
)
563 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
565 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
571 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
575 if (integer_types
[itk
] == NULL_TREE
)
577 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
579 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
580 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
581 && TREE_INT_CST_LOW (upper
) >= low
))
582 return (enum integer_type_kind
) itk
;
588 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
590 interpret_integer (const cpp_token
*token
, unsigned int flags
)
593 enum integer_type_kind itk
;
595 cpp_options
*options
= cpp_get_options (parse_in
);
597 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
598 integer
= cpp_num_sign_extend (integer
, options
->precision
);
600 /* The type of a constant with a U suffix is straightforward. */
601 if (flags
& CPP_N_UNSIGNED
)
602 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
605 /* The type of a potentially-signed integer constant varies
606 depending on the base it's in, the standard in use, and the
608 enum integer_type_kind itk_u
609 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
610 enum integer_type_kind itk_s
611 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
613 /* In both C89 and C99, octal and hex constants may be signed or
614 unsigned, whichever fits tighter. We do not warn about this
615 choice differing from the traditional choice, as the constant
616 is probably a bit pattern and either way will work. */
617 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
618 itk
= MIN (itk_u
, itk_s
);
621 /* In C99, decimal constants are always signed.
622 In C89, decimal constants that don't fit in long have
623 undefined behavior; we try to make them unsigned long.
624 In GCC's extended C89, that last is true of decimal
625 constants that don't fit in long long, too. */
628 if (itk_s
> itk_u
&& itk_s
> itk_long
)
632 if (itk_u
< itk_unsigned_long
)
633 itk_u
= itk_unsigned_long
;
635 warning (0, "this decimal constant is unsigned only in ISO C90");
638 warning (OPT_Wtraditional
,
639 "this decimal constant would be unsigned in ISO C90");
645 /* cpplib has already issued a warning for overflow. */
646 type
= ((flags
& CPP_N_UNSIGNED
)
647 ? widest_unsigned_literal_type_node
648 : widest_integer_literal_type_node
);
651 type
= integer_types
[itk
];
652 if (itk
> itk_unsigned_long
653 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
655 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
656 ? DK_PEDWARN
: DK_WARNING
,
657 input_location
, OPT_Wlong_long
,
658 (flags
& CPP_N_UNSIGNED
)
659 ? "integer constant is too large for %<unsigned long%> type"
660 : "integer constant is too large for %<long%> type");
663 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
665 /* Convert imaginary to a complex type. */
666 if (flags
& CPP_N_IMAGINARY
)
667 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
672 /* Interpret TOKEN, a floating point number with FLAGS as classified
673 by cpplib. For C++0X SUFFIX may contain a user-defined literal suffix. */
675 interpret_float (const cpp_token
*token
, unsigned int flags
,
681 REAL_VALUE_TYPE real
;
682 REAL_VALUE_TYPE real_trunc
;
686 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
687 pragma has been used and is either double or _Decimal64. Types
688 that are not allowed with decimal float default to double. */
689 if (flags
& CPP_N_DEFAULT
)
691 flags
^= CPP_N_DEFAULT
;
692 flags
|= CPP_N_MEDIUM
;
694 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
696 warning (OPT_Wunsuffixed_float_constants
,
697 "unsuffixed float constant");
698 if (float_const_decimal64_p ())
699 flags
|= CPP_N_DFLOAT
;
703 /* Decode _Fract and _Accum. */
704 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
705 return interpret_fixed (token
, flags
);
707 /* Decode type based on width and properties. */
708 if (flags
& CPP_N_DFLOAT
)
709 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
710 type
= dfloat128_type_node
;
711 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
712 type
= dfloat32_type_node
;
714 type
= dfloat64_type_node
;
716 if (flags
& CPP_N_WIDTH_MD
)
719 enum machine_mode mode
;
721 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
726 mode
= targetm
.c
.mode_for_suffix (suffix
);
727 if (mode
== VOIDmode
)
729 error ("unsupported non-standard suffix on floating constant");
731 return error_mark_node
;
734 pedwarn (input_location
, OPT_Wpedantic
, "non-standard suffix on floating constant");
736 type
= c_common_type_for_mode (mode
, 0);
739 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
740 type
= long_double_type_node
;
741 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
742 || flag_single_precision_constant
)
743 type
= float_type_node
;
745 type
= double_type_node
;
747 const_type
= excess_precision_type (type
);
751 /* Copy the constant to a nul-terminated buffer. If the constant
752 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
753 can't handle them. */
754 copylen
= token
->val
.str
.len
;
755 if (flags
& CPP_N_USERDEF
)
756 copylen
-= strlen (suffix
);
757 else if (flags
& CPP_N_DFLOAT
)
761 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
762 /* Must be an F or L or machine defined suffix. */
764 if (flags
& CPP_N_IMAGINARY
)
769 copy
= (char *) alloca (copylen
+ 1);
770 memcpy (copy
, token
->val
.str
.text
, copylen
);
771 copy
[copylen
] = '\0';
773 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
774 if (const_type
!= type
)
775 /* Diagnosing if the result of converting the value with excess
776 precision to the semantic type would overflow (with associated
777 double rounding) is more appropriate than diagnosing if the
778 result of converting the string directly to the semantic type
780 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
782 /* Both C and C++ require a diagnostic for a floating constant
783 outside the range of representable values of its type. Since we
784 have __builtin_inf* to produce an infinity, this is now a
785 mandatory pedwarn if the target does not support infinities. */
786 if (REAL_VALUE_ISINF (real
)
787 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
789 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
790 pedwarn (input_location
, 0, "floating constant exceeds range of %qT", type
);
792 warning (OPT_Woverflow
, "floating constant exceeds range of %qT", type
);
794 /* We also give a warning if the value underflows. */
795 else if (REAL_VALUES_EQUAL (real
, dconst0
)
796 || (const_type
!= type
&& REAL_VALUES_EQUAL (real_trunc
, dconst0
)))
798 REAL_VALUE_TYPE realvoidmode
;
799 int overflow
= real_from_string (&realvoidmode
, copy
);
800 if (overflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
801 warning (OPT_Woverflow
, "floating constant truncated to zero");
804 /* Create a node with determined type and value. */
805 value
= build_real (const_type
, real
);
806 if (flags
& CPP_N_IMAGINARY
)
808 value
= build_complex (NULL_TREE
, convert (const_type
,
809 integer_zero_node
), value
);
810 if (type
!= const_type
)
812 const_type
= TREE_TYPE (value
);
813 type
= build_complex_type (type
);
817 if (type
!= const_type
)
818 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
823 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
827 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
831 FIXED_VALUE_TYPE fixed
;
835 copylen
= token
->val
.str
.len
;
837 if (flags
& CPP_N_FRACT
) /* _Fract. */
839 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
841 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
843 type
= unsigned_long_long_fract_type_node
;
846 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
848 type
= unsigned_long_fract_type_node
;
851 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
853 type
= unsigned_short_fract_type_node
;
858 type
= unsigned_fract_type_node
;
862 else /* Signed _Fract. */
864 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
866 type
= long_long_fract_type_node
;
869 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
871 type
= long_fract_type_node
;
874 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
876 type
= short_fract_type_node
;
881 type
= fract_type_node
;
888 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
890 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
892 type
= unsigned_long_long_accum_type_node
;
895 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
897 type
= unsigned_long_accum_type_node
;
900 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
902 type
= unsigned_short_accum_type_node
;
907 type
= unsigned_accum_type_node
;
911 else /* Signed _Accum. */
913 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
915 type
= long_long_accum_type_node
;
918 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
920 type
= long_accum_type_node
;
923 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
925 type
= short_accum_type_node
;
930 type
= accum_type_node
;
936 copy
= (char *) alloca (copylen
+ 1);
937 memcpy (copy
, token
->val
.str
.text
, copylen
);
938 copy
[copylen
] = '\0';
940 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
942 /* Create a node with determined type and value. */
943 value
= build_fixed (type
, fixed
);
948 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
949 UTF8STRING tokens into a tree, performing string constant
950 concatenation. TOK is the first of these. VALP is the location to
951 write the string into. OBJC_STRING indicates whether an '@' token
952 preceded the incoming token (in that case, the strings can either
953 be ObjC strings, preceded by a single '@', or normal strings, not
954 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
955 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
956 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
958 This is unfortunately more work than it should be. If any of the
959 strings in the series has an L prefix, the result is a wide string
960 (6.4.5p4). Whether or not the result is a wide string affects the
961 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
962 sequences do not continue across the boundary between two strings in
963 a series (6.4.5p7), so we must not lose the boundaries. Therefore
964 cpp_interpret_string takes a vector of cpp_string structures, which
965 we must arrange to provide. */
967 static enum cpp_ttype
968 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
972 struct obstack str_ob
;
974 enum cpp_ttype type
= tok
->type
;
976 /* Try to avoid the overhead of creating and destroying an obstack
977 for the common case of just one string. */
978 cpp_string str
= tok
->val
.str
;
979 cpp_string
*strs
= &str
;
981 /* objc_at_sign_was_seen is only used when doing Objective-C string
982 concatenation. It is 'true' if we have seen an '@' before the
983 current string, and 'false' if not. We must see exactly one or
984 zero '@' before each string. */
985 bool objc_at_sign_was_seen
= false;
988 tok
= cpp_get_token (parse_in
);
996 if (objc_at_sign_was_seen
)
997 error ("repeated %<@%> before Objective-C string");
999 objc_at_sign_was_seen
= true;
1010 case CPP_UTF8STRING
:
1011 if (type
!= tok
->type
)
1013 if (type
== CPP_STRING
)
1016 error ("unsupported non-standard concatenation of string literals");
1022 gcc_obstack_init (&str_ob
);
1023 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
1027 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
1029 objc_at_sign_was_seen
= false;
1033 /* It is an error if we saw a '@' with no following string. */
1034 if (objc_at_sign_was_seen
)
1035 error ("stray %<@%> in program");
1037 /* We have read one more token than we want. */
1038 _cpp_backup_tokens (parse_in
, 1);
1040 strs
= XOBFINISH (&str_ob
, cpp_string
*);
1042 if (concats
&& !objc_string
&& !in_system_header
)
1043 warning (OPT_Wtraditional
,
1044 "traditional C rejects string constant concatenation");
1047 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
1048 (parse_in
, strs
, concats
+ 1, &istr
, type
))
1050 value
= build_string (istr
.len
, (const char *) istr
.text
);
1051 free (CONST_CAST (unsigned char *, istr
.text
));
1055 /* Callers cannot generally handle error_mark_node in this context,
1056 so return the empty string instead. cpp_interpret_string has
1062 case CPP_UTF8STRING
:
1063 value
= build_string (1, "");
1066 value
= build_string (TYPE_PRECISION (char16_type_node
)
1067 / TYPE_PRECISION (char_type_node
),
1068 "\0"); /* char16_t is 16 bits */
1071 value
= build_string (TYPE_PRECISION (char32_type_node
)
1072 / TYPE_PRECISION (char_type_node
),
1073 "\0\0\0"); /* char32_t is 32 bits */
1076 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1077 / TYPE_PRECISION (char_type_node
),
1078 "\0\0\0"); /* widest supported wchar_t
1088 case CPP_UTF8STRING
:
1089 TREE_TYPE (value
) = char_array_type_node
;
1092 TREE_TYPE (value
) = char16_array_type_node
;
1095 TREE_TYPE (value
) = char32_array_type_node
;
1098 TREE_TYPE (value
) = wchar_array_type_node
;
1100 *valp
= fix_string_type (value
);
1103 obstack_free (&str_ob
, 0);
1105 return objc_string
? CPP_OBJC_STRING
: type
;
1108 /* Converts a (possibly wide) character constant token into a tree. */
1110 lex_charconst (const cpp_token
*token
)
1114 unsigned int chars_seen
;
1117 result
= cpp_interpret_charconst (parse_in
, token
,
1118 &chars_seen
, &unsignedp
);
1120 if (token
->type
== CPP_WCHAR
)
1121 type
= wchar_type_node
;
1122 else if (token
->type
== CPP_CHAR32
)
1123 type
= char32_type_node
;
1124 else if (token
->type
== CPP_CHAR16
)
1125 type
= char16_type_node
;
1126 /* In C, a character constant has type 'int'.
1127 In C++ 'char', but multi-char charconsts have type 'int'. */
1128 else if (!c_dialect_cxx () || chars_seen
> 1)
1129 type
= integer_type_node
;
1131 type
= char_type_node
;
1133 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1134 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1135 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1136 value
= build_int_cst_wide (type
, result
, 0);
1138 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);