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"
36 #include "splay-tree.h"
40 /* We may keep statistics about how long which files took to compile. */
41 static int header_time, body_time;
42 static splay_tree file_info_tree;
44 int pending_lang_change; /* If we need to switch languages - C++ only */
45 int c_header_level; /* depth in C headers - C++ only */
47 static tree interpret_integer (const cpp_token *, unsigned int);
48 static tree interpret_float (const cpp_token *, unsigned int, const char *);
49 static tree interpret_fixed (const cpp_token *, unsigned int);
50 static enum integer_type_kind narrowest_unsigned_type
51 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
52 static enum integer_type_kind narrowest_signed_type
53 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
54 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
55 static tree lex_charconst (const cpp_token *);
56 static void update_header_times (const char *);
57 static int dump_one_header (splay_tree_node, void *);
58 static void cb_line_change (cpp_reader *, const cpp_token *, int);
59 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
60 static void cb_def_pragma (cpp_reader *, unsigned int);
61 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
62 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
67 struct cpp_callbacks *cb;
68 struct c_fileinfo *toplevel;
70 /* The get_fileinfo data structure must be initialized before
71 cpp_read_main_file is called. */
72 toplevel = get_fileinfo ("<top level>");
73 if (flag_detailed_statistics)
76 body_time = get_run_time ();
77 toplevel->time = body_time;
80 cb = cpp_get_callbacks (parse_in);
82 cb->line_change = cb_line_change;
84 cb->def_pragma = cb_def_pragma;
85 cb->valid_pch = c_common_valid_pch;
86 cb->read_pch = c_common_read_pch;
88 /* Set the debug callbacks if we can use them. */
89 if ((debug_info_level == DINFO_LEVEL_VERBOSE
90 && (write_symbols == DWARF2_DEBUG
91 || write_symbols == VMS_AND_DWARF2_DEBUG))
92 || flag_dump_go_spec != NULL)
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, LINEMAP_FILE (new_map));
211 #ifndef NO_IMPLICIT_EXTERN_C
214 else if (LINEMAP_SYSP (new_map) == 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 (LINEMAP_SYSP (new_map) == 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) (LINEMAP_LINE (new_map));
237 update_header_times (LINEMAP_FILE (new_map));
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 const char *suffix = NULL;
318 unsigned int flags = cpp_classify_number (parse_in, tok, &suffix);
320 switch (flags & CPP_N_CATEGORY)
323 /* cpplib has issued an error. */
324 *value = error_mark_node;
328 /* C++ uses '0' to mark virtual functions as pure.
329 Set PURE_ZERO to pass this information to the C++ parser. */
330 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
331 add_flags = PURE_ZERO;
332 *value = interpret_integer (tok, flags);
336 *value = interpret_float (tok, flags, suffix);
343 if (flags & CPP_N_USERDEF)
347 tree suffix_id = get_identifier (suffix);
348 int len = tok->val.str.len - strlen (suffix);
349 /* If this is going to be used as a C string to pass to a
350 raw literal operator, we need to add a trailing NUL. */
351 tree num_string = build_string (len + 1,
352 (const char *) tok->val.str.text);
353 TREE_TYPE (num_string) = char_array_type_node;
354 num_string = fix_string_type (num_string);
355 str = CONST_CAST (char *, TREE_STRING_POINTER (num_string));
357 literal = build_userdef_literal (suffix_id, *value,
365 /* An @ may give the next token special significance in Objective-C. */
366 if (c_dialect_objc ())
368 location_t atloc = *loc;
372 tok = cpp_get_token_with_location (parse_in, &newloc);
384 type = lex_string (tok, value, true, true);
388 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
389 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
390 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
393 /* Note the complication: if we found an OBJC_CXX
394 keyword, for example, 'class', we will be
395 returning a token of type CPP_AT_NAME and rid
396 code RID_CLASS (not RID_AT_CLASS). The language
397 parser needs to convert that to RID_AT_CLASS.
405 error_at (atloc, "stray %<@%> in program");
416 unsigned char name[8];
418 *cpp_spell_token (parse_in, tok, name, true) = 0;
420 error ("stray %qs in program", name);
427 cppchar_t c = tok->val.str.text[0];
429 if (c == '"' || c == '\'')
430 error ("missing terminating %c character", (int) c);
431 else if (ISGRAPH (c))
432 error ("stray %qc in program", (int) c);
434 error ("stray %<\\%o%> in program", (int) c);
438 case CPP_CHAR_USERDEF:
439 case CPP_WCHAR_USERDEF:
440 case CPP_CHAR16_USERDEF:
441 case CPP_CHAR32_USERDEF:
444 cpp_token temp_tok = *tok;
445 const char *suffix = cpp_get_userdef_suffix (tok);
446 temp_tok.val.str.len -= strlen (suffix);
447 temp_tok.type = cpp_userdef_char_remove_type (type);
448 literal = build_userdef_literal (get_identifier (suffix),
449 lex_charconst (&temp_tok), NULL_TREE);
458 *value = lex_charconst (tok);
461 case CPP_STRING_USERDEF:
462 case CPP_WSTRING_USERDEF:
463 case CPP_STRING16_USERDEF:
464 case CPP_STRING32_USERDEF:
465 case CPP_UTF8STRING_USERDEF:
467 tree literal, string;
468 const char *suffix = cpp_get_userdef_suffix (tok);
469 string = build_string (tok->val.str.len - strlen (suffix),
470 (const char *) tok->val.str.text);
471 literal = build_userdef_literal (get_identifier (suffix),
482 if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
484 type = lex_string (tok, value, false,
485 (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
488 *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
492 *value = build_int_cst (integer_type_node, tok->val.pragma);
495 /* These tokens should not be visible outside cpplib. */
496 case CPP_HEADER_NAME:
500 /* CPP_COMMENT will appear when compiling with -C and should be
511 *cpp_flags = tok->flags | add_flags;
516 c_common_no_more_pch ();
519 timevar_pop (TV_CPP);
524 /* Returns the narrowest C-visible unsigned type, starting with the
525 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
528 static enum integer_type_kind
529 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
530 unsigned HOST_WIDE_INT high,
535 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
536 itk = itk_unsigned_int;
537 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
538 itk = itk_unsigned_long;
540 itk = itk_unsigned_long_long;
542 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
546 if (integer_types[itk] == NULL_TREE)
548 upper = TYPE_MAX_VALUE (integer_types[itk]);
550 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
551 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
552 && TREE_INT_CST_LOW (upper) >= low))
553 return (enum integer_type_kind) itk;
559 /* Ditto, but narrowest signed type. */
560 static enum integer_type_kind
561 narrowest_signed_type (unsigned HOST_WIDE_INT low,
562 unsigned HOST_WIDE_INT high, unsigned int flags)
566 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
568 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
574 for (; itk < itk_none; itk += 2 /* skip signed types */)
578 if (integer_types[itk] == NULL_TREE)
580 upper = TYPE_MAX_VALUE (integer_types[itk]);
582 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
583 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
584 && TREE_INT_CST_LOW (upper) >= low))
585 return (enum integer_type_kind) itk;
591 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
593 interpret_integer (const cpp_token *token, unsigned int flags)
596 enum integer_type_kind itk;
598 cpp_options *options = cpp_get_options (parse_in);
600 integer = cpp_interpret_integer (parse_in, token, flags);
601 integer = cpp_num_sign_extend (integer, options->precision);
603 /* The type of a constant with a U suffix is straightforward. */
604 if (flags & CPP_N_UNSIGNED)
605 itk = narrowest_unsigned_type (integer.low, integer.high, flags);
608 /* The type of a potentially-signed integer constant varies
609 depending on the base it's in, the standard in use, and the
611 enum integer_type_kind itk_u
612 = narrowest_unsigned_type (integer.low, integer.high, flags);
613 enum integer_type_kind itk_s
614 = narrowest_signed_type (integer.low, integer.high, flags);
616 /* In both C89 and C99, octal and hex constants may be signed or
617 unsigned, whichever fits tighter. We do not warn about this
618 choice differing from the traditional choice, as the constant
619 is probably a bit pattern and either way will work. */
620 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
621 itk = MIN (itk_u, itk_s);
624 /* In C99, decimal constants are always signed.
625 In C89, decimal constants that don't fit in long have
626 undefined behavior; we try to make them unsigned long.
627 In GCC's extended C89, that last is true of decimal
628 constants that don't fit in long long, too. */
631 if (itk_s > itk_u && itk_s > itk_long)
635 if (itk_u < itk_unsigned_long)
636 itk_u = itk_unsigned_long;
638 warning (0, "this decimal constant is unsigned only in ISO C90");
641 warning (OPT_Wtraditional,
642 "this decimal constant would be unsigned in ISO C90");
648 /* cpplib has already issued a warning for overflow. */
649 type = ((flags & CPP_N_UNSIGNED)
650 ? widest_unsigned_literal_type_node
651 : widest_integer_literal_type_node);
654 type = integer_types[itk];
655 if (itk > itk_unsigned_long
656 && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
658 ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
659 ? DK_PEDWARN : DK_WARNING,
660 input_location, OPT_Wlong_long,
661 (flags & CPP_N_UNSIGNED)
662 ? "integer constant is too large for %<unsigned long%> type"
663 : "integer constant is too large for %<long%> type");
666 value = build_int_cst_wide (type, integer.low, integer.high);
668 /* Convert imaginary to a complex type. */
669 if (flags & CPP_N_IMAGINARY)
670 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
675 /* Interpret TOKEN, a floating point number with FLAGS as classified
676 by cpplib. For C++0X SUFFIX may contain a user-defined literal suffix. */
678 interpret_float (const cpp_token *token, unsigned int flags,
684 REAL_VALUE_TYPE real;
685 REAL_VALUE_TYPE real_trunc;
689 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
690 pragma has been used and is either double or _Decimal64. Types
691 that are not allowed with decimal float default to double. */
692 if (flags & CPP_N_DEFAULT)
694 flags ^= CPP_N_DEFAULT;
695 flags |= CPP_N_MEDIUM;
697 if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
699 warning (OPT_Wunsuffixed_float_constants,
700 "unsuffixed float constant");
701 if (float_const_decimal64_p ())
702 flags |= CPP_N_DFLOAT;
706 /* Decode _Fract and _Accum. */
707 if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
708 return interpret_fixed (token, flags);
710 /* Decode type based on width and properties. */
711 if (flags & CPP_N_DFLOAT)
712 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
713 type = dfloat128_type_node;
714 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
715 type = dfloat32_type_node;
717 type = dfloat64_type_node;
719 if (flags & CPP_N_WIDTH_MD)
722 enum machine_mode mode;
724 if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
729 mode = targetm.c.mode_for_suffix (suffix);
730 if (mode == VOIDmode)
732 error ("unsupported non-standard suffix on floating constant");
734 return error_mark_node;
737 pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
739 type = c_common_type_for_mode (mode, 0);
742 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
743 type = long_double_type_node;
744 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
745 || flag_single_precision_constant)
746 type = float_type_node;
748 type = double_type_node;
750 const_type = excess_precision_type (type);
754 /* Copy the constant to a nul-terminated buffer. If the constant
755 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
756 can't handle them. */
757 copylen = token->val.str.len;
758 if (flags & CPP_N_USERDEF)
759 copylen -= strlen (suffix);
760 else if (flags & CPP_N_DFLOAT)
764 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
765 /* Must be an F or L or machine defined suffix. */
767 if (flags & CPP_N_IMAGINARY)
772 copy = (char *) alloca (copylen + 1);
773 memcpy (copy, token->val.str.text, copylen);
774 copy[copylen] = '\0';
776 real_from_string3 (&real, copy, TYPE_MODE (const_type));
777 if (const_type != type)
778 /* Diagnosing if the result of converting the value with excess
779 precision to the semantic type would overflow (with associated
780 double rounding) is more appropriate than diagnosing if the
781 result of converting the string directly to the semantic type
783 real_convert (&real_trunc, TYPE_MODE (type), &real);
785 /* Both C and C++ require a diagnostic for a floating constant
786 outside the range of representable values of its type. Since we
787 have __builtin_inf* to produce an infinity, this is now a
788 mandatory pedwarn if the target does not support infinities. */
789 if (REAL_VALUE_ISINF (real)
790 || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
792 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
793 pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
795 warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
797 /* We also give a warning if the value underflows. */
798 else if (REAL_VALUES_EQUAL (real, dconst0)
799 || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
801 REAL_VALUE_TYPE realvoidmode;
802 int overflow = real_from_string (&realvoidmode, copy);
803 if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
804 warning (OPT_Woverflow, "floating constant truncated to zero");
807 /* Create a node with determined type and value. */
808 value = build_real (const_type, real);
809 if (flags & CPP_N_IMAGINARY)
811 value = build_complex (NULL_TREE, convert (const_type,
812 integer_zero_node), value);
813 if (type != const_type)
815 const_type = TREE_TYPE (value);
816 type = build_complex_type (type);
820 if (type != const_type)
821 value = build1 (EXCESS_PRECISION_EXPR, type, value);
826 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
830 interpret_fixed (const cpp_token *token, unsigned int flags)
834 FIXED_VALUE_TYPE fixed;
838 copylen = token->val.str.len;
840 if (flags & CPP_N_FRACT) /* _Fract. */
842 if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
844 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
846 type = unsigned_long_long_fract_type_node;
849 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
851 type = unsigned_long_fract_type_node;
854 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
856 type = unsigned_short_fract_type_node;
861 type = unsigned_fract_type_node;
865 else /* Signed _Fract. */
867 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
869 type = long_long_fract_type_node;
872 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
874 type = long_fract_type_node;
877 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
879 type = short_fract_type_node;
884 type = fract_type_node;
891 if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
893 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
895 type = unsigned_long_long_accum_type_node;
898 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
900 type = unsigned_long_accum_type_node;
903 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
905 type = unsigned_short_accum_type_node;
910 type = unsigned_accum_type_node;
914 else /* Signed _Accum. */
916 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
918 type = long_long_accum_type_node;
921 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
923 type = long_accum_type_node;
926 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
928 type = short_accum_type_node;
933 type = accum_type_node;
939 copy = (char *) alloca (copylen + 1);
940 memcpy (copy, token->val.str.text, copylen);
941 copy[copylen] = '\0';
943 fixed_from_string (&fixed, copy, TYPE_MODE (type));
945 /* Create a node with determined type and value. */
946 value = build_fixed (type, fixed);
951 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
952 UTF8STRING tokens into a tree, performing string constant
953 concatenation. TOK is the first of these. VALP is the location to
954 write the string into. OBJC_STRING indicates whether an '@' token
955 preceded the incoming token (in that case, the strings can either
956 be ObjC strings, preceded by a single '@', or normal strings, not
957 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
958 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
959 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
961 This is unfortunately more work than it should be. If any of the
962 strings in the series has an L prefix, the result is a wide string
963 (6.4.5p4). Whether or not the result is a wide string affects the
964 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
965 sequences do not continue across the boundary between two strings in
966 a series (6.4.5p7), so we must not lose the boundaries. Therefore
967 cpp_interpret_string takes a vector of cpp_string structures, which
968 we must arrange to provide. */
970 static enum cpp_ttype
971 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
975 struct obstack str_ob;
977 enum cpp_ttype type = tok->type;
979 /* Try to avoid the overhead of creating and destroying an obstack
980 for the common case of just one string. */
981 cpp_string str = tok->val.str;
982 cpp_string *strs = &str;
984 /* objc_at_sign_was_seen is only used when doing Objective-C string
985 concatenation. It is 'true' if we have seen an '@' before the
986 current string, and 'false' if not. We must see exactly one or
987 zero '@' before each string. */
988 bool objc_at_sign_was_seen = false;
991 tok = cpp_get_token (parse_in);
999 if (objc_at_sign_was_seen)
1000 error ("repeated %<@%> before Objective-C string");
1002 objc_at_sign_was_seen = true;
1013 case CPP_UTF8STRING:
1014 if (type != tok->type)
1016 if (type == CPP_STRING)
1019 error ("unsupported non-standard concatenation of string literals");
1025 gcc_obstack_init (&str_ob);
1026 obstack_grow (&str_ob, &str, sizeof (cpp_string));
1030 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
1032 objc_at_sign_was_seen = false;
1036 /* It is an error if we saw a '@' with no following string. */
1037 if (objc_at_sign_was_seen)
1038 error ("stray %<@%> in program");
1040 /* We have read one more token than we want. */
1041 _cpp_backup_tokens (parse_in, 1);
1043 strs = XOBFINISH (&str_ob, cpp_string *);
1045 if (concats && !objc_string && !in_system_header)
1046 warning (OPT_Wtraditional,
1047 "traditional C rejects string constant concatenation");
1050 ? cpp_interpret_string : cpp_interpret_string_notranslate)
1051 (parse_in, strs, concats + 1, &istr, type))
1053 value = build_string (istr.len, (const char *) istr.text);
1054 free (CONST_CAST (unsigned char *, istr.text));
1058 /* Callers cannot generally handle error_mark_node in this context,
1059 so return the empty string instead. cpp_interpret_string has
1065 case CPP_UTF8STRING:
1066 value = build_string (1, "");
1069 value = build_string (TYPE_PRECISION (char16_type_node)
1070 / TYPE_PRECISION (char_type_node),
1071 "\0"); /* char16_t is 16 bits */
1074 value = build_string (TYPE_PRECISION (char32_type_node)
1075 / TYPE_PRECISION (char_type_node),
1076 "\0\0\0"); /* char32_t is 32 bits */
1079 value = build_string (TYPE_PRECISION (wchar_type_node)
1080 / TYPE_PRECISION (char_type_node),
1081 "\0\0\0"); /* widest supported wchar_t
1091 case CPP_UTF8STRING:
1092 TREE_TYPE (value) = char_array_type_node;
1095 TREE_TYPE (value) = char16_array_type_node;
1098 TREE_TYPE (value) = char32_array_type_node;
1101 TREE_TYPE (value) = wchar_array_type_node;
1103 *valp = fix_string_type (value);
1106 obstack_free (&str_ob, 0);
1108 return objc_string ? CPP_OBJC_STRING : type;
1111 /* Converts a (possibly wide) character constant token into a tree. */
1113 lex_charconst (const cpp_token *token)
1117 unsigned int chars_seen;
1120 result = cpp_interpret_charconst (parse_in, token,
1121 &chars_seen, &unsignedp);
1123 if (token->type == CPP_WCHAR)
1124 type = wchar_type_node;
1125 else if (token->type == CPP_CHAR32)
1126 type = char32_type_node;
1127 else if (token->type == CPP_CHAR16)
1128 type = char16_type_node;
1129 /* In C, a character constant has type 'int'.
1130 In C++ 'char', but multi-char charconsts have type 'int'. */
1131 else if (!c_dialect_cxx () || chars_seen > 1)
1132 type = integer_type_node;
1134 type = char_type_node;
1136 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1137 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1138 if (unsignedp || (cppchar_signed_t) result >= 0)
1139 value = build_int_cst_wide (type, result, 0);
1141 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);