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 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"
37 #include "splay-tree.h"
41 /* We may keep statistics about how long which files took to compile. */
42 static int header_time
, body_time
;
43 static splay_tree file_info_tree
;
45 int pending_lang_change
; /* If we need to switch languages - C++ only */
46 int c_header_level
; /* depth in C headers - C++ only */
48 static tree
interpret_integer (const cpp_token
*, unsigned int);
49 static tree
interpret_float (const cpp_token
*, unsigned int);
50 static tree
interpret_fixed (const cpp_token
*, unsigned int);
51 static enum integer_type_kind narrowest_unsigned_type
52 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
53 static enum integer_type_kind narrowest_signed_type
54 (unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
, unsigned int);
55 static enum cpp_ttype
lex_string (const cpp_token
*, tree
*, bool, bool);
56 static tree
lex_charconst (const cpp_token
*);
57 static void update_header_times (const char *);
58 static int dump_one_header (splay_tree_node
, void *);
59 static void cb_line_change (cpp_reader
*, const cpp_token
*, int);
60 static void cb_ident (cpp_reader
*, unsigned int, const cpp_string
*);
61 static void cb_def_pragma (cpp_reader
*, unsigned int);
62 static void cb_define (cpp_reader
*, unsigned int, cpp_hashnode
*);
63 static void cb_undef (cpp_reader
*, unsigned int, cpp_hashnode
*);
68 struct cpp_callbacks
*cb
;
69 struct c_fileinfo
*toplevel
;
71 /* The get_fileinfo data structure must be initialized before
72 cpp_read_main_file is called. */
73 toplevel
= get_fileinfo ("<top level>");
74 if (flag_detailed_statistics
)
77 body_time
= get_run_time ();
78 toplevel
->time
= body_time
;
81 cb
= cpp_get_callbacks (parse_in
);
83 cb
->line_change
= cb_line_change
;
85 cb
->def_pragma
= cb_def_pragma
;
86 cb
->valid_pch
= c_common_valid_pch
;
87 cb
->read_pch
= c_common_read_pch
;
89 /* Set the debug callbacks if we can use them. */
90 if (debug_info_level
== DINFO_LEVEL_VERBOSE
91 && (write_symbols
== DWARF2_DEBUG
92 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
94 cb
->define
= cb_define
;
100 get_fileinfo (const char *name
)
103 struct c_fileinfo
*fi
;
106 file_info_tree
= splay_tree_new ((splay_tree_compare_fn
) strcmp
,
108 (splay_tree_delete_value_fn
) free
);
110 n
= splay_tree_lookup (file_info_tree
, (splay_tree_key
) name
);
112 return (struct c_fileinfo
*) n
->value
;
114 fi
= XNEW (struct c_fileinfo
);
116 fi
->interface_only
= 0;
117 fi
->interface_unknown
= 1;
118 splay_tree_insert (file_info_tree
, (splay_tree_key
) name
,
119 (splay_tree_value
) fi
);
124 update_header_times (const char *name
)
126 /* Changing files again. This means currently collected time
127 is charged against header time, and body time starts back at 0. */
128 if (flag_detailed_statistics
)
130 int this_time
= get_run_time ();
131 struct c_fileinfo
*file
= get_fileinfo (name
);
132 header_time
+= this_time
- body_time
;
133 file
->time
+= this_time
- body_time
;
134 body_time
= this_time
;
139 dump_one_header (splay_tree_node n
, void * ARG_UNUSED (dummy
))
141 print_time ((const char *) n
->key
,
142 ((struct c_fileinfo
*) n
->value
)->time
);
147 dump_time_statistics (void)
149 struct c_fileinfo
*file
= get_fileinfo (input_filename
);
150 int this_time
= get_run_time ();
151 file
->time
+= this_time
- body_time
;
153 fprintf (stderr
, "\n******\n");
154 print_time ("header files (total)", header_time
);
155 print_time ("main file (total)", this_time
- body_time
);
156 fprintf (stderr
, "ratio = %g : 1\n",
157 (double) header_time
/ (double) (this_time
- body_time
));
158 fprintf (stderr
, "\n******\n");
160 splay_tree_foreach (file_info_tree
, dump_one_header
, 0);
164 cb_ident (cpp_reader
* ARG_UNUSED (pfile
),
165 unsigned int ARG_UNUSED (line
),
166 const cpp_string
* ARG_UNUSED (str
))
168 #ifdef ASM_OUTPUT_IDENT
171 /* Convert escapes in the string. */
172 cpp_string cstr
= { 0, 0 };
173 if (cpp_interpret_string (pfile
, str
, 1, &cstr
, CPP_STRING
))
175 ASM_OUTPUT_IDENT (asm_out_file
, (const char *) cstr
.text
);
176 free (CONST_CAST (unsigned char *, cstr
.text
));
182 /* Called at the start of every non-empty line. TOKEN is the first
183 lexed token on the line. Used for diagnostic line numbers. */
185 cb_line_change (cpp_reader
* ARG_UNUSED (pfile
), const cpp_token
*token
,
188 if (token
->type
!= CPP_EOF
&& !parsing_args
)
189 input_location
= token
->src_loc
;
193 fe_file_change (const struct line_map
*new_map
)
198 if (new_map
->reason
== LC_ENTER
)
200 /* Don't stack the main buffer on the input stack;
201 we already did in compile_file. */
202 if (!MAIN_FILE_P (new_map
))
204 unsigned int included_at
= LAST_SOURCE_LINE_LOCATION (new_map
- 1);
206 if (included_at
> BUILTINS_LOCATION
)
207 line
= SOURCE_LINE (new_map
- 1, included_at
);
209 input_location
= new_map
->start_location
;
210 (*debug_hooks
->start_source_file
) (line
, new_map
->to_file
);
211 #ifndef NO_IMPLICIT_EXTERN_C
214 else if (new_map
->sysp
== 2)
217 ++pending_lang_change
;
222 else if (new_map
->reason
== LC_LEAVE
)
224 #ifndef NO_IMPLICIT_EXTERN_C
225 if (c_header_level
&& --c_header_level
== 0)
227 if (new_map
->sysp
== 2)
228 warning (0, "badly nested C headers from preprocessor");
229 --pending_lang_change
;
232 input_location
= new_map
->start_location
;
234 (*debug_hooks
->end_source_file
) (new_map
->to_line
);
237 update_header_times (new_map
->to_file
);
238 input_location
= new_map
->start_location
;
242 cb_def_pragma (cpp_reader
*pfile
, source_location loc
)
244 /* Issue a warning message if we have been asked to do so. Ignore
245 unknown pragmas in system headers unless an explicit
246 -Wunknown-pragmas has been given. */
247 if (warn_unknown_pragmas
> in_system_header
)
249 const unsigned char *space
, *name
;
251 location_t fe_loc
= loc
;
253 space
= name
= (const unsigned char *) "";
254 s
= cpp_get_token (pfile
);
255 if (s
->type
!= CPP_EOF
)
257 space
= cpp_token_as_text (pfile
, s
);
258 s
= cpp_get_token (pfile
);
259 if (s
->type
== CPP_NAME
)
260 name
= cpp_token_as_text (pfile
, s
);
263 warning_at (fe_loc
, OPT_Wunknown_pragmas
, "ignoring #pragma %s %s",
268 /* #define callback for DWARF and DWARF2 debug info. */
270 cb_define (cpp_reader
*pfile
, source_location loc
, cpp_hashnode
*node
)
272 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
273 (*debug_hooks
->define
) (SOURCE_LINE (map
, loc
),
274 (const char *) cpp_macro_definition (pfile
, node
));
277 /* #undef callback for DWARF and DWARF2 debug info. */
279 cb_undef (cpp_reader
* ARG_UNUSED (pfile
), source_location loc
,
282 const struct line_map
*map
= linemap_lookup (line_table
, loc
);
283 (*debug_hooks
->undef
) (SOURCE_LINE (map
, loc
),
284 (const char *) NODE_NAME (node
));
287 /* Read a token and return its type. Fill *VALUE with its value, if
288 applicable. Fill *CPP_FLAGS with the token's flags, if it is
292 c_lex_with_flags (tree
*value
, location_t
*loc
, unsigned char *cpp_flags
,
295 static bool no_more_pch
;
296 const cpp_token
*tok
;
298 unsigned char add_flags
= 0;
300 timevar_push (TV_CPP
);
302 tok
= cpp_get_token_with_location (parse_in
, loc
);
312 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
317 unsigned int flags
= cpp_classify_number (parse_in
, tok
);
319 switch (flags
& CPP_N_CATEGORY
)
322 /* cpplib has issued an error. */
323 *value
= error_mark_node
;
327 /* C++ uses '0' to mark virtual functions as pure.
328 Set PURE_ZERO to pass this information to the C++ parser. */
329 if (tok
->val
.str
.len
== 1 && *tok
->val
.str
.text
== '0')
330 add_flags
= PURE_ZERO
;
331 *value
= interpret_integer (tok
, flags
);
335 *value
= interpret_float (tok
, flags
);
345 /* An @ may give the next token special significance in Objective-C. */
346 if (c_dialect_objc ())
348 location_t atloc
= *loc
;
352 tok
= cpp_get_token_with_location (parse_in
, &newloc
);
364 type
= lex_string (tok
, value
, true, true);
368 *value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
369 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value
))
370 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value
)))
373 /* Note the complication: if we found an OBJC_CXX
374 keyword, for example, 'class', we will be
375 returning a token of type CPP_AT_NAME and rid
376 code RID_CLASS (not RID_AT_CLASS). The language
377 parser needs to convert that to RID_AT_CLASS.
385 error_at (atloc
, "stray %<@%> in program");
396 unsigned char name
[8];
398 *cpp_spell_token (parse_in
, tok
, name
, true) = 0;
400 error ("stray %qs in program", name
);
407 cppchar_t c
= tok
->val
.str
.text
[0];
409 if (c
== '"' || c
== '\'')
410 error ("missing terminating %c character", (int) c
);
411 else if (ISGRAPH (c
))
412 error ("stray %qc in program", (int) c
);
414 error ("stray %<\\%o%> in program", (int) c
);
422 *value
= lex_charconst (tok
);
430 if ((lex_flags
& C_LEX_STRING_NO_JOIN
) == 0)
432 type
= lex_string (tok
, value
, false,
433 (lex_flags
& C_LEX_STRING_NO_TRANSLATE
) == 0);
436 *value
= build_string (tok
->val
.str
.len
, (const char *) tok
->val
.str
.text
);
440 *value
= build_int_cst (NULL
, tok
->val
.pragma
);
443 /* These tokens should not be visible outside cpplib. */
444 case CPP_HEADER_NAME
:
448 /* CPP_COMMENT will appear when compiling with -C and should be
459 *cpp_flags
= tok
->flags
| add_flags
;
464 c_common_no_more_pch ();
467 timevar_pop (TV_CPP
);
472 /* Returns the narrowest C-visible unsigned type, starting with the
473 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
476 static enum integer_type_kind
477 narrowest_unsigned_type (unsigned HOST_WIDE_INT low
,
478 unsigned HOST_WIDE_INT high
,
483 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
484 itk
= itk_unsigned_int
;
485 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
486 itk
= itk_unsigned_long
;
488 itk
= itk_unsigned_long_long
;
490 for (; itk
< itk_none
; itk
+= 2 /* skip unsigned types */)
494 if (integer_types
[itk
] == NULL_TREE
)
496 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
498 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
499 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
500 && TREE_INT_CST_LOW (upper
) >= low
))
501 return (enum integer_type_kind
) itk
;
507 /* Ditto, but narrowest signed type. */
508 static enum integer_type_kind
509 narrowest_signed_type (unsigned HOST_WIDE_INT low
,
510 unsigned HOST_WIDE_INT high
, unsigned int flags
)
514 if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
516 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
522 for (; itk
< itk_none
; itk
+= 2 /* skip signed types */)
526 if (integer_types
[itk
] == NULL_TREE
)
528 upper
= TYPE_MAX_VALUE (integer_types
[itk
]);
530 if ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) > high
531 || ((unsigned HOST_WIDE_INT
) TREE_INT_CST_HIGH (upper
) == high
532 && TREE_INT_CST_LOW (upper
) >= low
))
533 return (enum integer_type_kind
) itk
;
539 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
541 interpret_integer (const cpp_token
*token
, unsigned int flags
)
544 enum integer_type_kind itk
;
546 cpp_options
*options
= cpp_get_options (parse_in
);
548 integer
= cpp_interpret_integer (parse_in
, token
, flags
);
549 integer
= cpp_num_sign_extend (integer
, options
->precision
);
551 /* The type of a constant with a U suffix is straightforward. */
552 if (flags
& CPP_N_UNSIGNED
)
553 itk
= narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
556 /* The type of a potentially-signed integer constant varies
557 depending on the base it's in, the standard in use, and the
559 enum integer_type_kind itk_u
560 = narrowest_unsigned_type (integer
.low
, integer
.high
, flags
);
561 enum integer_type_kind itk_s
562 = narrowest_signed_type (integer
.low
, integer
.high
, flags
);
564 /* In both C89 and C99, octal and hex constants may be signed or
565 unsigned, whichever fits tighter. We do not warn about this
566 choice differing from the traditional choice, as the constant
567 is probably a bit pattern and either way will work. */
568 if ((flags
& CPP_N_RADIX
) != CPP_N_DECIMAL
)
569 itk
= MIN (itk_u
, itk_s
);
572 /* In C99, decimal constants are always signed.
573 In C89, decimal constants that don't fit in long have
574 undefined behavior; we try to make them unsigned long.
575 In GCC's extended C89, that last is true of decimal
576 constants that don't fit in long long, too. */
579 if (itk_s
> itk_u
&& itk_s
> itk_long
)
583 if (itk_u
< itk_unsigned_long
)
584 itk_u
= itk_unsigned_long
;
586 warning (0, "this decimal constant is unsigned only in ISO C90");
589 warning (OPT_Wtraditional
,
590 "this decimal constant would be unsigned in ISO C90");
596 /* cpplib has already issued a warning for overflow. */
597 type
= ((flags
& CPP_N_UNSIGNED
)
598 ? widest_unsigned_literal_type_node
599 : widest_integer_literal_type_node
);
602 type
= integer_types
[itk
];
603 if (itk
> itk_unsigned_long
604 && (flags
& CPP_N_WIDTH
) != CPP_N_LARGE
)
606 ((c_dialect_cxx () ? cxx_dialect
== cxx98
: !flag_isoc99
)
607 ? DK_PEDWARN
: DK_WARNING
,
608 input_location
, OPT_Wlong_long
,
609 (flags
& CPP_N_UNSIGNED
)
610 ? "integer constant is too large for %<unsigned long%> type"
611 : "integer constant is too large for %<long%> type");
614 value
= build_int_cst_wide (type
, integer
.low
, integer
.high
);
616 /* Convert imaginary to a complex type. */
617 if (flags
& CPP_N_IMAGINARY
)
618 value
= build_complex (NULL_TREE
, build_int_cst (type
, 0), value
);
623 /* Interpret TOKEN, a floating point number with FLAGS as classified
626 interpret_float (const cpp_token
*token
, unsigned int flags
)
631 REAL_VALUE_TYPE real
;
632 REAL_VALUE_TYPE real_trunc
;
636 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
637 pragma has been used and is either double or _Decimal64. Types
638 that are not allowed with decimal float default to double. */
639 if (flags
& CPP_N_DEFAULT
)
641 flags
^= CPP_N_DEFAULT
;
642 flags
|= CPP_N_MEDIUM
;
644 if (((flags
& CPP_N_HEX
) == 0) && ((flags
& CPP_N_IMAGINARY
) == 0))
646 warning (OPT_Wunsuffixed_float_constants
,
647 "unsuffixed float constant");
648 if (float_const_decimal64_p ())
649 flags
|= CPP_N_DFLOAT
;
653 /* Decode _Fract and _Accum. */
654 if (flags
& CPP_N_FRACT
|| flags
& CPP_N_ACCUM
)
655 return interpret_fixed (token
, flags
);
657 /* Decode type based on width and properties. */
658 if (flags
& CPP_N_DFLOAT
)
659 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
660 type
= dfloat128_type_node
;
661 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
662 type
= dfloat32_type_node
;
664 type
= dfloat64_type_node
;
666 if (flags
& CPP_N_WIDTH_MD
)
669 enum machine_mode mode
;
671 if ((flags
& CPP_N_WIDTH_MD
) == CPP_N_MD_W
)
676 mode
= targetm
.c
.mode_for_suffix (suffix
);
677 if (mode
== VOIDmode
)
679 error ("unsupported non-standard suffix on floating constant");
681 return error_mark_node
;
684 pedwarn (input_location
, OPT_pedantic
, "non-standard suffix on floating constant");
686 type
= c_common_type_for_mode (mode
, 0);
689 else if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
690 type
= long_double_type_node
;
691 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
692 || flag_single_precision_constant
)
693 type
= float_type_node
;
695 type
= double_type_node
;
697 const_type
= excess_precision_type (type
);
701 /* Copy the constant to a nul-terminated buffer. If the constant
702 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
703 can't handle them. */
704 copylen
= token
->val
.str
.len
;
705 if (flags
& CPP_N_DFLOAT
)
709 if ((flags
& CPP_N_WIDTH
) != CPP_N_MEDIUM
)
710 /* Must be an F or L or machine defined suffix. */
712 if (flags
& CPP_N_IMAGINARY
)
717 copy
= (char *) alloca (copylen
+ 1);
718 memcpy (copy
, token
->val
.str
.text
, copylen
);
719 copy
[copylen
] = '\0';
721 real_from_string3 (&real
, copy
, TYPE_MODE (const_type
));
722 if (const_type
!= type
)
723 /* Diagnosing if the result of converting the value with excess
724 precision to the semantic type would overflow (with associated
725 double rounding) is more appropriate than diagnosing if the
726 result of converting the string directly to the semantic type
728 real_convert (&real_trunc
, TYPE_MODE (type
), &real
);
730 /* Both C and C++ require a diagnostic for a floating constant
731 outside the range of representable values of its type. Since we
732 have __builtin_inf* to produce an infinity, this is now a
733 mandatory pedwarn if the target does not support infinities. */
734 if (REAL_VALUE_ISINF (real
)
735 || (const_type
!= type
&& REAL_VALUE_ISINF (real_trunc
)))
737 if (!MODE_HAS_INFINITIES (TYPE_MODE (type
)))
738 pedwarn (input_location
, 0, "floating constant exceeds range of %qT", type
);
740 warning (OPT_Woverflow
, "floating constant exceeds range of %qT", type
);
742 /* We also give a warning if the value underflows. */
743 else if (REAL_VALUES_EQUAL (real
, dconst0
)
744 || (const_type
!= type
&& REAL_VALUES_EQUAL (real_trunc
, dconst0
)))
746 REAL_VALUE_TYPE realvoidmode
;
747 int overflow
= real_from_string (&realvoidmode
, copy
);
748 if (overflow
< 0 || !REAL_VALUES_EQUAL (realvoidmode
, dconst0
))
749 warning (OPT_Woverflow
, "floating constant truncated to zero");
752 /* Create a node with determined type and value. */
753 value
= build_real (const_type
, real
);
754 if (flags
& CPP_N_IMAGINARY
)
755 value
= build_complex (NULL_TREE
, convert (const_type
, integer_zero_node
),
758 if (type
!= const_type
)
759 value
= build1 (EXCESS_PRECISION_EXPR
, type
, value
);
764 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
768 interpret_fixed (const cpp_token
*token
, unsigned int flags
)
772 FIXED_VALUE_TYPE fixed
;
776 copylen
= token
->val
.str
.len
;
778 if (flags
& CPP_N_FRACT
) /* _Fract. */
780 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Fract. */
782 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
784 type
= unsigned_long_long_fract_type_node
;
787 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
789 type
= unsigned_long_fract_type_node
;
792 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
794 type
= unsigned_short_fract_type_node
;
799 type
= unsigned_fract_type_node
;
803 else /* Signed _Fract. */
805 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
807 type
= long_long_fract_type_node
;
810 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
812 type
= long_fract_type_node
;
815 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
817 type
= short_fract_type_node
;
822 type
= fract_type_node
;
829 if (flags
& CPP_N_UNSIGNED
) /* Unsigned _Accum. */
831 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
833 type
= unsigned_long_long_accum_type_node
;
836 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
838 type
= unsigned_long_accum_type_node
;
841 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
843 type
= unsigned_short_accum_type_node
;
848 type
= unsigned_accum_type_node
;
852 else /* Signed _Accum. */
854 if ((flags
& CPP_N_WIDTH
) == CPP_N_LARGE
)
856 type
= long_long_accum_type_node
;
859 else if ((flags
& CPP_N_WIDTH
) == CPP_N_MEDIUM
)
861 type
= long_accum_type_node
;
864 else if ((flags
& CPP_N_WIDTH
) == CPP_N_SMALL
)
866 type
= short_accum_type_node
;
871 type
= accum_type_node
;
877 copy
= (char *) alloca (copylen
+ 1);
878 memcpy (copy
, token
->val
.str
.text
, copylen
);
879 copy
[copylen
] = '\0';
881 fixed_from_string (&fixed
, copy
, TYPE_MODE (type
));
883 /* Create a node with determined type and value. */
884 value
= build_fixed (type
, fixed
);
889 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
890 UTF8STRING tokens into a tree, performing string constant
891 concatenation. TOK is the first of these. VALP is the location
892 to write the string into. OBJC_STRING indicates whether an '@' token
893 preceded the incoming token.
894 Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
895 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
897 This is unfortunately more work than it should be. If any of the
898 strings in the series has an L prefix, the result is a wide string
899 (6.4.5p4). Whether or not the result is a wide string affects the
900 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
901 sequences do not continue across the boundary between two strings in
902 a series (6.4.5p7), so we must not lose the boundaries. Therefore
903 cpp_interpret_string takes a vector of cpp_string structures, which
904 we must arrange to provide. */
906 static enum cpp_ttype
907 lex_string (const cpp_token
*tok
, tree
*valp
, bool objc_string
, bool translate
)
911 struct obstack str_ob
;
913 enum cpp_ttype type
= tok
->type
;
915 /* Try to avoid the overhead of creating and destroying an obstack
916 for the common case of just one string. */
917 cpp_string str
= tok
->val
.str
;
918 cpp_string
*strs
= &str
;
921 tok
= cpp_get_token (parse_in
);
927 if (c_dialect_objc ())
941 if (type
!= tok
->type
)
943 if (type
== CPP_STRING
)
946 error ("unsupported non-standard concatenation of string literals");
952 gcc_obstack_init (&str_ob
);
953 obstack_grow (&str_ob
, &str
, sizeof (cpp_string
));
957 obstack_grow (&str_ob
, &tok
->val
.str
, sizeof (cpp_string
));
961 /* We have read one more token than we want. */
962 _cpp_backup_tokens (parse_in
, 1);
964 strs
= XOBFINISH (&str_ob
, cpp_string
*);
966 if (concats
&& !objc_string
&& !in_system_header
)
967 warning (OPT_Wtraditional
,
968 "traditional C rejects string constant concatenation");
971 ? cpp_interpret_string
: cpp_interpret_string_notranslate
)
972 (parse_in
, strs
, concats
+ 1, &istr
, type
))
974 value
= build_string (istr
.len
, (const char *) istr
.text
);
975 free (CONST_CAST (unsigned char *, istr
.text
));
979 /* Callers cannot generally handle error_mark_node in this context,
980 so return the empty string instead. cpp_interpret_string has
987 value
= build_string (1, "");
990 value
= build_string (TYPE_PRECISION (char16_type_node
)
991 / TYPE_PRECISION (char_type_node
),
992 "\0"); /* char16_t is 16 bits */
995 value
= build_string (TYPE_PRECISION (char32_type_node
)
996 / TYPE_PRECISION (char_type_node
),
997 "\0\0\0"); /* char32_t is 32 bits */
1000 value
= build_string (TYPE_PRECISION (wchar_type_node
)
1001 / TYPE_PRECISION (char_type_node
),
1002 "\0\0\0"); /* widest supported wchar_t
1012 case CPP_UTF8STRING
:
1013 TREE_TYPE (value
) = char_array_type_node
;
1016 TREE_TYPE (value
) = char16_array_type_node
;
1019 TREE_TYPE (value
) = char32_array_type_node
;
1022 TREE_TYPE (value
) = wchar_array_type_node
;
1024 *valp
= fix_string_type (value
);
1027 obstack_free (&str_ob
, 0);
1029 return objc_string
? CPP_OBJC_STRING
: type
;
1032 /* Converts a (possibly wide) character constant token into a tree. */
1034 lex_charconst (const cpp_token
*token
)
1038 unsigned int chars_seen
;
1041 result
= cpp_interpret_charconst (parse_in
, token
,
1042 &chars_seen
, &unsignedp
);
1044 if (token
->type
== CPP_WCHAR
)
1045 type
= wchar_type_node
;
1046 else if (token
->type
== CPP_CHAR32
)
1047 type
= char32_type_node
;
1048 else if (token
->type
== CPP_CHAR16
)
1049 type
= char16_type_node
;
1050 /* In C, a character constant has type 'int'.
1051 In C++ 'char', but multi-char charconsts have type 'int'. */
1052 else if (!c_dialect_cxx () || chars_seen
> 1)
1053 type
= integer_type_node
;
1055 type
= char_type_node
;
1057 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1058 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1059 if (unsignedp
|| (cppchar_signed_t
) result
>= 0)
1060 value
= build_int_cst_wide (type
, result
, 0);
1062 value
= build_int_cst_wide (type
, (cppchar_signed_t
) result
, -1);