1 /* Mainly the interface between cpplib and the C front ends.
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "target.h"
24 #include "c-common.h"
25 #include "timevar.h"
26 #include "stringpool.h"
27 #include "stor-layout.h"
28 #include "c-pragma.h"
29 #include "debug.h"
30 #include "file-prefix-map.h" /* remap_macro_filename() */
31 #include "langhooks.h"
32 #include "attribs.h"
33
34 /* We may keep statistics about how long which files took to compile. */
35 static int header_time, body_time;
36 static splay_tree file_info_tree;
37
38 int pending_lang_change; /* If we need to switch languages - C++ only */
39 int c_header_level; /* depth in C headers - C++ only */
40
41 static tree interpret_integer (const cpp_token *, unsigned int,
42 enum overflow_type *);
43 static tree interpret_float (const cpp_token *, unsigned int, const char *,
44 enum overflow_type *);
45 static tree interpret_fixed (const cpp_token *, unsigned int);
46 static enum integer_type_kind narrowest_unsigned_type
47 (const widest_int &, unsigned int);
48 static enum integer_type_kind narrowest_signed_type
49 (const widest_int &, unsigned int);
50 static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
51 static tree lex_charconst (const cpp_token *);
52 static void update_header_times (const char *);
53 static int dump_one_header (splay_tree_node, void *);
54 static void cb_line_change (cpp_reader *, const cpp_token *, int);
55 static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
56 static void cb_def_pragma (cpp_reader *, unsigned int);
57 static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
58 static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
59
60 void
init_c_lex(void)61 init_c_lex (void)
62 {
63 struct c_fileinfo *toplevel;
64
65 /* The get_fileinfo data structure must be initialized before
66 cpp_read_main_file is called. */
67 toplevel = get_fileinfo ("<top level>");
68 if (flag_detailed_statistics)
69 {
70 header_time = 0;
71 body_time = get_run_time ();
72 toplevel->time = body_time;
73 }
74
75 struct cpp_callbacks *cb = cpp_get_callbacks (parse_in);
76
77 cb->line_change = cb_line_change;
78 cb->ident = cb_ident;
79 cb->def_pragma = cb_def_pragma;
80 cb->valid_pch = c_common_valid_pch;
81 cb->read_pch = c_common_read_pch;
82 cb->has_attribute = c_common_has_attribute;
83 cb->has_builtin = c_common_has_builtin;
84 cb->get_source_date_epoch = cb_get_source_date_epoch;
85 cb->get_suggestion = cb_get_suggestion;
86 cb->remap_filename = remap_macro_filename;
87
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)
93 {
94 cb->define = cb_define;
95 cb->undef = cb_undef;
96 }
97 }
98
99 struct c_fileinfo *
get_fileinfo(const char * name)100 get_fileinfo (const char *name)
101 {
102 splay_tree_node n;
103 struct c_fileinfo *fi;
104
105 if (!file_info_tree)
106 file_info_tree = splay_tree_new (splay_tree_compare_strings,
107 0,
108 splay_tree_delete_pointers);
109
110 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
111 if (n)
112 return (struct c_fileinfo *) n->value;
113
114 fi = XNEW (struct c_fileinfo);
115 fi->time = 0;
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);
120 return fi;
121 }
122
123 static void
update_header_times(const char * name)124 update_header_times (const char *name)
125 {
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)
129 {
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;
135 }
136 }
137
138 static int
dump_one_header(splay_tree_node n,void * ARG_UNUSED (dummy))139 dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
140 {
141 print_time ((const char *) n->key,
142 ((struct c_fileinfo *) n->value)->time);
143 return 0;
144 }
145
146 void
dump_time_statistics(void)147 dump_time_statistics (void)
148 {
149 struct c_fileinfo *file = get_fileinfo (LOCATION_FILE (input_location));
150 int this_time = get_run_time ();
151 file->time += this_time - body_time;
152
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");
159
160 splay_tree_foreach (file_info_tree, dump_one_header, 0);
161 }
162
163 static void
cb_ident(cpp_reader * ARG_UNUSED (pfile),unsigned int ARG_UNUSED (line),const cpp_string * ARG_UNUSED (str))164 cb_ident (cpp_reader * ARG_UNUSED (pfile),
165 unsigned int ARG_UNUSED (line),
166 const cpp_string * ARG_UNUSED (str))
167 {
168 if (!flag_no_ident)
169 {
170 /* Convert escapes in the string. */
171 cpp_string cstr = { 0, 0 };
172 if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
173 {
174 targetm.asm_out.output_ident ((const char *) cstr.text);
175 free (CONST_CAST (unsigned char *, cstr.text));
176 }
177 }
178 }
179
180 /* Called at the start of every non-empty line. TOKEN is the first
181 lexed token on the line. Used for diagnostic line numbers. */
182 static void
cb_line_change(cpp_reader * ARG_UNUSED (pfile),const cpp_token * token,int parsing_args)183 cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
184 int parsing_args)
185 {
186 if (token->type != CPP_EOF && !parsing_args)
187 input_location = token->src_loc;
188 }
189
190 void
fe_file_change(const line_map_ordinary * new_map)191 fe_file_change (const line_map_ordinary *new_map)
192 {
193 if (new_map == NULL)
194 return;
195
196 if (new_map->reason == LC_ENTER)
197 {
198 /* Don't stack the main buffer on the input stack;
199 we already did in compile_file. */
200 if (!MAIN_FILE_P (new_map))
201 {
202 location_t included_at = linemap_included_from (new_map);
203 int line = 0;
204 if (included_at > BUILTINS_LOCATION)
205 line = SOURCE_LINE (new_map - 1, included_at);
206
207 input_location = new_map->start_location;
208 (*debug_hooks->start_source_file) (line, LINEMAP_FILE (new_map));
209 #ifdef SYSTEM_IMPLICIT_EXTERN_C
210 if (c_header_level)
211 ++c_header_level;
212 else if (LINEMAP_SYSP (new_map) == 2)
213 {
214 c_header_level = 1;
215 ++pending_lang_change;
216 }
217 #endif
218 }
219 }
220 else if (new_map->reason == LC_LEAVE)
221 {
222 #ifdef SYSTEM_IMPLICIT_EXTERN_C
223 if (c_header_level && --c_header_level == 0)
224 {
225 if (LINEMAP_SYSP (new_map) == 2)
226 warning (0, "badly nested C headers from preprocessor");
227 --pending_lang_change;
228 }
229 #endif
230 input_location = new_map->start_location;
231
232 (*debug_hooks->end_source_file) (LINEMAP_LINE (new_map));
233 }
234
235 update_header_times (LINEMAP_FILE (new_map));
236 input_location = new_map->start_location;
237 }
238
239 static void
cb_def_pragma(cpp_reader * pfile,location_t loc)240 cb_def_pragma (cpp_reader *pfile, location_t loc)
241 {
242 /* Issue a warning message if we have been asked to do so. Ignore
243 unknown pragmas in system headers unless an explicit
244 -Wunknown-pragmas has been given. */
245 if (warn_unknown_pragmas > in_system_header_at (input_location))
246 {
247 const unsigned char *space, *name;
248 const cpp_token *s;
249 location_t fe_loc = loc;
250
251 space = name = (const unsigned char *) "";
252 s = cpp_get_token (pfile);
253 if (s->type != CPP_EOF)
254 {
255 space = cpp_token_as_text (pfile, s);
256 s = cpp_get_token (pfile);
257 if (s->type == CPP_NAME)
258 name = cpp_token_as_text (pfile, s);
259 }
260
261 warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring %<#pragma %s %s%>",
262 space, name);
263 }
264 }
265
266 /* #define callback for DWARF and DWARF2 debug info. */
267 static void
cb_define(cpp_reader * pfile,location_t loc,cpp_hashnode * node)268 cb_define (cpp_reader *pfile, location_t loc, cpp_hashnode *node)
269 {
270 const struct line_map *map = linemap_lookup (line_table, loc);
271 (*debug_hooks->define) (SOURCE_LINE (linemap_check_ordinary (map), loc),
272 (const char *) cpp_macro_definition (pfile, node));
273 }
274
275 /* #undef callback for DWARF and DWARF2 debug info. */
276 static void
cb_undef(cpp_reader * pfile,location_t loc,cpp_hashnode * node)277 cb_undef (cpp_reader *pfile, location_t loc, cpp_hashnode *node)
278 {
279 if (lang_hooks.preprocess_undef)
280 lang_hooks.preprocess_undef (pfile, loc, node);
281
282 const struct line_map *map = linemap_lookup (line_table, loc);
283 (*debug_hooks->undef) (SOURCE_LINE (linemap_check_ordinary (map), loc),
284 (const char *) NODE_NAME (node));
285 }
286
287 /* Wrapper around cpp_get_token to skip CPP_PADDING tokens
288 and not consume CPP_EOF. */
289 static const cpp_token *
get_token_no_padding(cpp_reader * pfile)290 get_token_no_padding (cpp_reader *pfile)
291 {
292 for (;;)
293 {
294 const cpp_token *ret = cpp_peek_token (pfile, 0);
295 if (ret->type == CPP_EOF)
296 return ret;
297 ret = cpp_get_token (pfile);
298 if (ret->type != CPP_PADDING)
299 return ret;
300 }
301 }
302
303 /* Callback for has_attribute. */
304 int
c_common_has_attribute(cpp_reader * pfile,bool std_syntax)305 c_common_has_attribute (cpp_reader *pfile, bool std_syntax)
306 {
307 int result = 0;
308 tree attr_name = NULL_TREE;
309 const cpp_token *token;
310
311 token = get_token_no_padding (pfile);
312 if (token->type != CPP_OPEN_PAREN)
313 {
314 cpp_error (pfile, CPP_DL_ERROR,
315 "missing '(' after \"__has_attribute\"");
316 return 0;
317 }
318 token = get_token_no_padding (pfile);
319 if (token->type == CPP_NAME)
320 {
321 attr_name = get_identifier ((const char *)
322 cpp_token_as_text (pfile, token));
323 attr_name = canonicalize_attr_name (attr_name);
324 bool have_scope = false;
325 int idx = 0;
326 const cpp_token *nxt_token;
327 do
328 nxt_token = cpp_peek_token (pfile, idx++);
329 while (nxt_token->type == CPP_PADDING);
330 if (nxt_token->type == CPP_SCOPE)
331 {
332 have_scope = true;
333 get_token_no_padding (pfile); // Eat scope.
334 nxt_token = get_token_no_padding (pfile);
335 if (nxt_token->type == CPP_NAME)
336 {
337 tree attr_ns = attr_name;
338 tree attr_id
339 = get_identifier ((const char *)
340 cpp_token_as_text (pfile, nxt_token));
341 attr_name = build_tree_list (attr_ns, attr_id);
342 }
343 else
344 {
345 cpp_error (pfile, CPP_DL_ERROR,
346 "attribute identifier required after scope");
347 attr_name = NULL_TREE;
348 }
349 }
350 else
351 {
352 /* Some standard attributes need special handling. */
353 if (c_dialect_cxx ())
354 {
355 if (is_attribute_p ("noreturn", attr_name))
356 result = 200809;
357 else if (is_attribute_p ("deprecated", attr_name))
358 result = 201309;
359 else if (is_attribute_p ("maybe_unused", attr_name)
360 || is_attribute_p ("fallthrough", attr_name))
361 result = 201603;
362 else if (is_attribute_p ("no_unique_address", attr_name)
363 || is_attribute_p ("likely", attr_name)
364 || is_attribute_p ("unlikely", attr_name))
365 result = 201803;
366 else if (is_attribute_p ("nodiscard", attr_name))
367 result = 201907;
368 }
369 else
370 {
371 if (is_attribute_p ("deprecated", attr_name)
372 || is_attribute_p ("maybe_unused", attr_name)
373 || is_attribute_p ("fallthrough", attr_name))
374 result = 201904;
375 else if (is_attribute_p ("nodiscard", attr_name))
376 result = 202003;
377 }
378 if (result)
379 attr_name = NULL_TREE;
380 }
381 if (attr_name && (have_scope || !std_syntax))
382 {
383 init_attributes ();
384 const struct attribute_spec *attr = lookup_attribute_spec (attr_name);
385 if (attr)
386 result = 1;
387 }
388 }
389 else
390 {
391 cpp_error (pfile, CPP_DL_ERROR,
392 "macro \"__has_attribute\" requires an identifier");
393 return 0;
394 }
395
396 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
397 cpp_error (pfile, CPP_DL_ERROR,
398 "missing ')' after \"__has_attribute\"");
399
400 return result;
401 }
402
403 /* Callback for has_builtin. */
404
405 int
c_common_has_builtin(cpp_reader * pfile)406 c_common_has_builtin (cpp_reader *pfile)
407 {
408 const cpp_token *token = get_token_no_padding (pfile);
409 if (token->type != CPP_OPEN_PAREN)
410 {
411 cpp_error (pfile, CPP_DL_ERROR,
412 "missing '(' after \"__has_builtin\"");
413 return 0;
414 }
415
416 const char *name = "";
417 token = get_token_no_padding (pfile);
418 if (token->type == CPP_NAME)
419 {
420 name = (const char *) cpp_token_as_text (pfile, token);
421 token = get_token_no_padding (pfile);
422 if (token->type != CPP_CLOSE_PAREN)
423 {
424 cpp_error (pfile, CPP_DL_ERROR,
425 "expected ')' after \"%s\"", name);
426 name = "";
427 }
428 }
429 else
430 {
431 cpp_error (pfile, CPP_DL_ERROR,
432 "macro \"__has_builtin\" requires an identifier");
433 if (token->type == CPP_CLOSE_PAREN)
434 return 0;
435 }
436
437 /* Consume tokens up to the closing parenthesis, including any nested
438 pairs of parentheses, to avoid confusing redundant errors. */
439 for (unsigned nparen = 1; ; token = get_token_no_padding (pfile))
440 {
441 if (token->type == CPP_OPEN_PAREN)
442 ++nparen;
443 else if (token->type == CPP_CLOSE_PAREN)
444 --nparen;
445 else if (token->type == CPP_EOF)
446 break;
447 if (!nparen)
448 break;
449 }
450
451 return names_builtin_p (name);
452 }
453
454
455 /* Read a token and return its type. Fill *VALUE with its value, if
456 applicable. Fill *CPP_FLAGS with the token's flags, if it is
457 non-NULL. */
458
459 enum cpp_ttype
c_lex_with_flags(tree * value,location_t * loc,unsigned char * cpp_flags,int lex_flags)460 c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
461 int lex_flags)
462 {
463 const cpp_token *tok;
464 enum cpp_ttype type;
465 unsigned char add_flags = 0;
466 enum overflow_type overflow = OT_NONE;
467
468 timevar_push (TV_CPP);
469 retry:
470 tok = cpp_get_token_with_location (parse_in, loc);
471 type = tok->type;
472
473 retry_after_at:
474 switch (type)
475 {
476 case CPP_PADDING:
477 goto retry;
478
479 case CPP_NAME:
480 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
481 break;
482
483 case CPP_NUMBER:
484 {
485 const char *suffix = NULL;
486 unsigned int flags = cpp_classify_number (parse_in, tok, &suffix, *loc);
487
488 switch (flags & CPP_N_CATEGORY)
489 {
490 case CPP_N_INVALID:
491 /* cpplib has issued an error. */
492 *value = error_mark_node;
493 break;
494
495 case CPP_N_INTEGER:
496 /* C++ uses '0' to mark virtual functions as pure.
497 Set PURE_ZERO to pass this information to the C++ parser. */
498 if (tok->val.str.len == 1 && *tok->val.str.text == '0')
499 add_flags = PURE_ZERO;
500 *value = interpret_integer (tok, flags, &overflow);
501 break;
502
503 case CPP_N_FLOATING:
504 *value = interpret_float (tok, flags, suffix, &overflow);
505 break;
506
507 default:
508 gcc_unreachable ();
509 }
510
511 if (flags & CPP_N_USERDEF)
512 {
513 char *str;
514 tree literal;
515 tree suffix_id = get_identifier (suffix);
516 int len = tok->val.str.len - strlen (suffix);
517 /* If this is going to be used as a C string to pass to a
518 raw literal operator, we need to add a trailing NUL. */
519 tree num_string = build_string (len + 1,
520 (const char *) tok->val.str.text);
521 TREE_TYPE (num_string) = char_array_type_node;
522 num_string = fix_string_type (num_string);
523 str = CONST_CAST (char *, TREE_STRING_POINTER (num_string));
524 str[len] = '\0';
525 literal = build_userdef_literal (suffix_id, *value, overflow,
526 num_string);
527 *value = literal;
528 }
529 }
530 break;
531
532 case CPP_ATSIGN:
533 /* An @ may give the next token special significance in Objective-C. */
534 if (c_dialect_objc ())
535 {
536 location_t atloc = *loc;
537 location_t newloc;
538
539 retry_at:
540 tok = cpp_get_token_with_location (parse_in, &newloc);
541 type = tok->type;
542 switch (type)
543 {
544 case CPP_PADDING:
545 goto retry_at;
546
547 case CPP_STRING:
548 case CPP_WSTRING:
549 case CPP_STRING16:
550 case CPP_STRING32:
551 case CPP_UTF8STRING:
552 type = lex_string (tok, value, true, true);
553 break;
554
555 case CPP_NAME:
556 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
557 if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
558 || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
559 {
560 type = CPP_AT_NAME;
561 /* Note the complication: if we found an OBJC_CXX
562 keyword, for example, 'class', we will be
563 returning a token of type CPP_AT_NAME and rid
564 code RID_CLASS (not RID_AT_CLASS). The language
565 parser needs to convert that to RID_AT_CLASS.
566 However, we've now spliced the '@' together with the
567 keyword that follows; Adjust the location so that we
568 get a source range covering the composite.
569 */
570 *loc = make_location (atloc, atloc, newloc);
571 break;
572 }
573 /* FALLTHROUGH */
574
575 default:
576 /* ... or not. */
577 error_at (atloc, "stray %<@%> in program");
578 *loc = newloc;
579 goto retry_after_at;
580 }
581 break;
582 }
583
584 /* FALLTHROUGH */
585 case CPP_HASH:
586 case CPP_PASTE:
587 {
588 unsigned char name[8];
589
590 *cpp_spell_token (parse_in, tok, name, true) = 0;
591
592 error_at (*loc, "stray %qs in program", name);
593 }
594
595 goto retry;
596
597 case CPP_OTHER:
598 {
599 cppchar_t c = tok->val.str.text[0];
600
601 if (c == '"' || c == '\'')
602 error_at (*loc, "missing terminating %c character", (int) c);
603 else if (ISGRAPH (c))
604 error_at (*loc, "stray %qc in program", (int) c);
605 else
606 error_at (*loc, "stray %<\\%o%> in program", (int) c);
607 }
608 goto retry;
609
610 case CPP_CHAR_USERDEF:
611 case CPP_WCHAR_USERDEF:
612 case CPP_CHAR16_USERDEF:
613 case CPP_CHAR32_USERDEF:
614 case CPP_UTF8CHAR_USERDEF:
615 {
616 tree literal;
617 cpp_token temp_tok = *tok;
618 const char *suffix = cpp_get_userdef_suffix (tok);
619 temp_tok.val.str.len -= strlen (suffix);
620 temp_tok.type = cpp_userdef_char_remove_type (type);
621 literal = build_userdef_literal (get_identifier (suffix),
622 lex_charconst (&temp_tok),
623 OT_NONE, NULL_TREE);
624 *value = literal;
625 }
626 break;
627
628 case CPP_CHAR:
629 case CPP_WCHAR:
630 case CPP_CHAR16:
631 case CPP_CHAR32:
632 case CPP_UTF8CHAR:
633 *value = lex_charconst (tok);
634 break;
635
636 case CPP_STRING_USERDEF:
637 case CPP_WSTRING_USERDEF:
638 case CPP_STRING16_USERDEF:
639 case CPP_STRING32_USERDEF:
640 case CPP_UTF8STRING_USERDEF:
641 {
642 tree literal, string;
643 const char *suffix = cpp_get_userdef_suffix (tok);
644 string = build_string (tok->val.str.len - strlen (suffix),
645 (const char *) tok->val.str.text);
646 literal = build_userdef_literal (get_identifier (suffix),
647 string, OT_NONE, NULL_TREE);
648 *value = literal;
649 }
650 break;
651
652 case CPP_STRING:
653 case CPP_WSTRING:
654 case CPP_STRING16:
655 case CPP_STRING32:
656 case CPP_UTF8STRING:
657 if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
658 {
659 type = lex_string (tok, value, false,
660 (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
661 break;
662 }
663 *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
664 break;
665
666 case CPP_PRAGMA:
667 *value = build_int_cst (integer_type_node, tok->val.pragma);
668 break;
669
670 case CPP_HEADER_NAME:
671 *value = build_string (tok->val.str.len, (const char *)tok->val.str.text);
672 break;
673
674 /* This token should not be visible outside cpplib. */
675 case CPP_MACRO_ARG:
676 gcc_unreachable ();
677
678 /* CPP_COMMENT will appear when compiling with -C. Ignore, except
679 when it is a FALLTHROUGH comment, in that case set
680 PREV_FALLTHROUGH flag on the next non-comment token. */
681 case CPP_COMMENT:
682 if (tok->flags & PREV_FALLTHROUGH)
683 {
684 do
685 {
686 tok = cpp_get_token_with_location (parse_in, loc);
687 type = tok->type;
688 }
689 while (type == CPP_PADDING || type == CPP_COMMENT);
690 add_flags |= PREV_FALLTHROUGH;
691 goto retry_after_at;
692 }
693 goto retry;
694
695 default:
696 *value = NULL_TREE;
697 break;
698 }
699
700 if (cpp_flags)
701 *cpp_flags = tok->flags | add_flags;
702
703 timevar_pop (TV_CPP);
704
705 return type;
706 }
707
708 /* Returns the narrowest C-visible unsigned type, starting with the
709 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
710 there isn't one. */
711
712 static enum integer_type_kind
narrowest_unsigned_type(const widest_int & val,unsigned int flags)713 narrowest_unsigned_type (const widest_int &val, unsigned int flags)
714 {
715 int itk;
716
717 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
718 itk = itk_unsigned_int;
719 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
720 itk = itk_unsigned_long;
721 else
722 itk = itk_unsigned_long_long;
723
724 for (; itk < itk_none; itk += 2 /* skip unsigned types */)
725 {
726 tree upper;
727
728 if (integer_types[itk] == NULL_TREE)
729 continue;
730 upper = TYPE_MAX_VALUE (integer_types[itk]);
731
732 if (wi::geu_p (wi::to_widest (upper), val))
733 return (enum integer_type_kind) itk;
734 }
735
736 return itk_none;
737 }
738
739 /* Ditto, but narrowest signed type. */
740 static enum integer_type_kind
narrowest_signed_type(const widest_int & val,unsigned int flags)741 narrowest_signed_type (const widest_int &val, unsigned int flags)
742 {
743 int itk;
744
745 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
746 itk = itk_int;
747 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
748 itk = itk_long;
749 else
750 itk = itk_long_long;
751
752 for (; itk < itk_none; itk += 2 /* skip signed types */)
753 {
754 tree upper;
755
756 if (integer_types[itk] == NULL_TREE)
757 continue;
758 upper = TYPE_MAX_VALUE (integer_types[itk]);
759
760 if (wi::geu_p (wi::to_widest (upper), val))
761 return (enum integer_type_kind) itk;
762 }
763
764 return itk_none;
765 }
766
767 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
768 static tree
interpret_integer(const cpp_token * token,unsigned int flags,enum overflow_type * overflow)769 interpret_integer (const cpp_token *token, unsigned int flags,
770 enum overflow_type *overflow)
771 {
772 tree value, type;
773 enum integer_type_kind itk;
774 cpp_num integer;
775 HOST_WIDE_INT ival[3];
776
777 *overflow = OT_NONE;
778
779 integer = cpp_interpret_integer (parse_in, token, flags);
780 if (integer.overflow)
781 *overflow = OT_OVERFLOW;
782
783 ival[0] = integer.low;
784 ival[1] = integer.high;
785 ival[2] = 0;
786 widest_int wval = widest_int::from_array (ival, 3);
787
788 /* The type of a constant with a U suffix is straightforward. */
789 if (flags & CPP_N_UNSIGNED)
790 itk = narrowest_unsigned_type (wval, flags);
791 else
792 {
793 /* The type of a potentially-signed integer constant varies
794 depending on the base it's in, the standard in use, and the
795 length suffixes. */
796 enum integer_type_kind itk_u
797 = narrowest_unsigned_type (wval, flags);
798 enum integer_type_kind itk_s
799 = narrowest_signed_type (wval, flags);
800
801 /* In both C89 and C99, octal and hex constants may be signed or
802 unsigned, whichever fits tighter. We do not warn about this
803 choice differing from the traditional choice, as the constant
804 is probably a bit pattern and either way will work. */
805 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
806 itk = MIN (itk_u, itk_s);
807 else
808 {
809 /* In C99, decimal constants are always signed.
810 In C89, decimal constants that don't fit in long have
811 undefined behavior; we try to make them unsigned long.
812 In GCC's extended C89, that last is true of decimal
813 constants that don't fit in long long, too. */
814
815 itk = itk_s;
816 if (itk_s > itk_u && itk_s > itk_long)
817 {
818 if (!flag_isoc99)
819 {
820 if (itk_u < itk_unsigned_long)
821 itk_u = itk_unsigned_long;
822 itk = itk_u;
823 warning (0, "this decimal constant is unsigned only in ISO C90");
824 }
825 else
826 warning (OPT_Wtraditional,
827 "this decimal constant would be unsigned in ISO C90");
828 }
829 }
830 }
831
832 if (itk == itk_none)
833 /* cpplib has already issued a warning for overflow. */
834 type = ((flags & CPP_N_UNSIGNED)
835 ? widest_unsigned_literal_type_node
836 : widest_integer_literal_type_node);
837 else if (flags & CPP_N_SIZE_T)
838 {
839 /* itk refers to fundamental types not aliased size types. */
840 if (flags & CPP_N_UNSIGNED)
841 type = size_type_node;
842 else
843 type = signed_size_type_node;
844 }
845 else
846 {
847 type = integer_types[itk];
848 if (itk > itk_unsigned_long
849 && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
850 emit_diagnostic
851 ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
852 ? DK_PEDWARN : DK_WARNING,
853 input_location, OPT_Wlong_long,
854 (flags & CPP_N_UNSIGNED)
855 ? "integer constant is too large for %<unsigned long%> type"
856 : "integer constant is too large for %<long%> type");
857 }
858
859 value = wide_int_to_tree (type, wval);
860
861 /* Convert imaginary to a complex type. */
862 if (flags & CPP_N_IMAGINARY)
863 value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
864
865 return value;
866 }
867
868 /* Interpret TOKEN, a floating point number with FLAGS as classified
869 by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
870 static tree
interpret_float(const cpp_token * token,unsigned int flags,const char * suffix,enum overflow_type * overflow)871 interpret_float (const cpp_token *token, unsigned int flags,
872 const char *suffix, enum overflow_type *overflow)
873 {
874 tree type;
875 tree const_type;
876 tree value;
877 REAL_VALUE_TYPE real;
878 REAL_VALUE_TYPE real_trunc;
879 char *copy;
880 size_t copylen;
881
882 *overflow = OT_NONE;
883
884 /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
885 pragma has been used and is either double or _Decimal64. Types
886 that are not allowed with decimal float default to double. */
887 if (flags & CPP_N_DEFAULT)
888 {
889 flags ^= CPP_N_DEFAULT;
890 flags |= CPP_N_MEDIUM;
891
892 if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
893 {
894 warning (OPT_Wunsuffixed_float_constants,
895 "unsuffixed floating constant");
896 if (float_const_decimal64_p ())
897 flags |= CPP_N_DFLOAT;
898 }
899 }
900
901 /* Decode _Fract and _Accum. */
902 if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
903 return interpret_fixed (token, flags);
904
905 /* Decode type based on width and properties. */
906 if (flags & CPP_N_DFLOAT)
907 if (!targetm.decimal_float_supported_p ())
908 {
909 error ("decimal floating-point not supported for this target");
910 return error_mark_node;
911 }
912 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
913 type = dfloat128_type_node;
914 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
915 type = dfloat32_type_node;
916 else
917 type = dfloat64_type_node;
918 else
919 if (flags & CPP_N_WIDTH_MD)
920 {
921 char suffix;
922 machine_mode mode;
923
924 if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
925 suffix = 'w';
926 else
927 suffix = 'q';
928
929 mode = targetm.c.mode_for_suffix (suffix);
930 if (mode == VOIDmode)
931 {
932 error ("unsupported non-standard suffix on floating constant");
933
934 return error_mark_node;
935 }
936 else
937 pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
938
939 type = c_common_type_for_mode (mode, 0);
940 gcc_assert (type);
941 }
942 else if ((flags & (CPP_N_FLOATN | CPP_N_FLOATNX)) != 0)
943 {
944 unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
945 bool extended = (flags & CPP_N_FLOATNX) != 0;
946 type = NULL_TREE;
947 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
948 if (floatn_nx_types[i].n == (int) n
949 && floatn_nx_types[i].extended == extended)
950 {
951 type = FLOATN_NX_TYPE_NODE (i);
952 break;
953 }
954 if (type == NULL_TREE)
955 {
956 error ("unsupported non-standard suffix on floating constant");
957 return error_mark_node;
958 }
959 else
960 pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
961 }
962 else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
963 type = long_double_type_node;
964 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
965 || flag_single_precision_constant)
966 type = float_type_node;
967 else
968 type = double_type_node;
969
970 const_type = excess_precision_type (type);
971 if (!const_type)
972 const_type = type;
973
974 /* Copy the constant to a nul-terminated buffer. If the constant
975 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
976 can't handle them. */
977 copylen = token->val.str.len;
978 if (flags & CPP_N_USERDEF)
979 copylen -= strlen (suffix);
980 else if (flags & CPP_N_DFLOAT)
981 copylen -= 2;
982 else
983 {
984 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
985 /* Must be an F or L or machine defined suffix. */
986 copylen--;
987 if (flags & CPP_N_IMAGINARY)
988 /* I or J suffix. */
989 copylen--;
990 if (flags & CPP_N_FLOATNX)
991 copylen--;
992 if (flags & (CPP_N_FLOATN | CPP_N_FLOATNX))
993 {
994 unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
995 while (n > 0)
996 {
997 copylen--;
998 n /= 10;
999 }
1000 }
1001 }
1002
1003 copy = (char *) alloca (copylen + 1);
1004 if (cxx_dialect > cxx11)
1005 {
1006 size_t maxlen = 0;
1007 for (size_t i = 0; i < copylen; ++i)
1008 if (token->val.str.text[i] != '\'')
1009 copy[maxlen++] = token->val.str.text[i];
1010 copy[maxlen] = '\0';
1011 }
1012 else
1013 {
1014 memcpy (copy, token->val.str.text, copylen);
1015 copy[copylen] = '\0';
1016 }
1017
1018 real_from_string3 (&real, copy, TYPE_MODE (const_type));
1019 if (const_type != type)
1020 /* Diagnosing if the result of converting the value with excess
1021 precision to the semantic type would overflow (with associated
1022 double rounding) is more appropriate than diagnosing if the
1023 result of converting the string directly to the semantic type
1024 would overflow. */
1025 real_convert (&real_trunc, TYPE_MODE (type), &real);
1026
1027 /* Both C and C++ require a diagnostic for a floating constant
1028 outside the range of representable values of its type. Since we
1029 have __builtin_inf* to produce an infinity, this is now a
1030 mandatory pedwarn if the target does not support infinities. */
1031 if (REAL_VALUE_ISINF (real)
1032 || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
1033 {
1034 *overflow = OT_OVERFLOW;
1035 if (!(flags & CPP_N_USERDEF))
1036 {
1037 if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
1038 pedwarn (input_location, 0,
1039 "floating constant exceeds range of %qT", type);
1040 else
1041 warning (OPT_Woverflow,
1042 "floating constant exceeds range of %qT", type);
1043 }
1044 }
1045 /* We also give a warning if the value underflows. */
1046 else if (real_equal (&real, &dconst0)
1047 || (const_type != type
1048 && real_equal (&real_trunc, &dconst0)))
1049 {
1050 REAL_VALUE_TYPE realvoidmode;
1051 int oflow = real_from_string (&realvoidmode, copy);
1052 *overflow = (oflow == 0 ? OT_NONE
1053 : (oflow < 0 ? OT_UNDERFLOW : OT_OVERFLOW));
1054 if (!(flags & CPP_N_USERDEF))
1055 {
1056 if (oflow < 0 || !real_equal (&realvoidmode, &dconst0))
1057 warning (OPT_Woverflow, "floating constant truncated to zero");
1058 }
1059 }
1060
1061 /* Create a node with determined type and value. */
1062 value = build_real (const_type, real);
1063 if (flags & CPP_N_IMAGINARY)
1064 {
1065 value = build_complex (NULL_TREE,
1066 fold_convert (const_type,
1067 integer_zero_node), value);
1068 if (type != const_type)
1069 {
1070 const_type = TREE_TYPE (value);
1071 type = build_complex_type (type);
1072 }
1073 }
1074
1075 if (type != const_type)
1076 value = build1_loc (token->src_loc, EXCESS_PRECISION_EXPR, type, value);
1077
1078 return value;
1079 }
1080
1081 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
1082 by cpplib. */
1083
1084 static tree
interpret_fixed(const cpp_token * token,unsigned int flags)1085 interpret_fixed (const cpp_token *token, unsigned int flags)
1086 {
1087 tree type;
1088 tree value;
1089 FIXED_VALUE_TYPE fixed;
1090 char *copy;
1091 size_t copylen;
1092
1093 copylen = token->val.str.len;
1094
1095 if (flags & CPP_N_FRACT) /* _Fract. */
1096 {
1097 if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
1098 {
1099 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1100 {
1101 type = unsigned_long_long_fract_type_node;
1102 copylen -= 4;
1103 }
1104 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1105 {
1106 type = unsigned_long_fract_type_node;
1107 copylen -= 3;
1108 }
1109 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1110 {
1111 type = unsigned_short_fract_type_node;
1112 copylen -= 3;
1113 }
1114 else
1115 {
1116 type = unsigned_fract_type_node;
1117 copylen -= 2;
1118 }
1119 }
1120 else /* Signed _Fract. */
1121 {
1122 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1123 {
1124 type = long_long_fract_type_node;
1125 copylen -= 3;
1126 }
1127 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1128 {
1129 type = long_fract_type_node;
1130 copylen -= 2;
1131 }
1132 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1133 {
1134 type = short_fract_type_node;
1135 copylen -= 2;
1136 }
1137 else
1138 {
1139 type = fract_type_node;
1140 copylen --;
1141 }
1142 }
1143 }
1144 else /* _Accum. */
1145 {
1146 if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
1147 {
1148 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1149 {
1150 type = unsigned_long_long_accum_type_node;
1151 copylen -= 4;
1152 }
1153 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1154 {
1155 type = unsigned_long_accum_type_node;
1156 copylen -= 3;
1157 }
1158 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1159 {
1160 type = unsigned_short_accum_type_node;
1161 copylen -= 3;
1162 }
1163 else
1164 {
1165 type = unsigned_accum_type_node;
1166 copylen -= 2;
1167 }
1168 }
1169 else /* Signed _Accum. */
1170 {
1171 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1172 {
1173 type = long_long_accum_type_node;
1174 copylen -= 3;
1175 }
1176 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1177 {
1178 type = long_accum_type_node;
1179 copylen -= 2;
1180 }
1181 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1182 {
1183 type = short_accum_type_node;
1184 copylen -= 2;
1185 }
1186 else
1187 {
1188 type = accum_type_node;
1189 copylen --;
1190 }
1191 }
1192 }
1193
1194 copy = (char *) alloca (copylen + 1);
1195 memcpy (copy, token->val.str.text, copylen);
1196 copy[copylen] = '\0';
1197
1198 fixed_from_string (&fixed, copy, SCALAR_TYPE_MODE (type));
1199
1200 /* Create a node with determined type and value. */
1201 value = build_fixed (type, fixed);
1202
1203 return value;
1204 }
1205
1206 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1207 UTF8STRING tokens into a tree, performing string constant
1208 concatenation. TOK is the first of these. VALP is the location to
1209 write the string into. OBJC_STRING indicates whether an '@' token
1210 preceded the incoming token (in that case, the strings can either
1211 be ObjC strings, preceded by a single '@', or normal strings, not
1212 preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1213 the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1214 CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1215
1216 This is unfortunately more work than it should be. If any of the
1217 strings in the series has an L prefix, the result is a wide string
1218 (6.4.5p4). Whether or not the result is a wide string affects the
1219 meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1220 sequences do not continue across the boundary between two strings in
1221 a series (6.4.5p7), so we must not lose the boundaries. Therefore
1222 cpp_interpret_string takes a vector of cpp_string structures, which
1223 we must arrange to provide. */
1224
1225 static enum cpp_ttype
lex_string(const cpp_token * tok,tree * valp,bool objc_string,bool translate)1226 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
1227 {
1228 tree value;
1229 size_t concats = 0;
1230 struct obstack str_ob;
1231 struct obstack loc_ob;
1232 cpp_string istr;
1233 enum cpp_ttype type = tok->type;
1234
1235 /* Try to avoid the overhead of creating and destroying an obstack
1236 for the common case of just one string. */
1237 cpp_string str = tok->val.str;
1238 location_t init_loc = tok->src_loc;
1239 cpp_string *strs = &str;
1240 location_t *locs = NULL;
1241
1242 /* objc_at_sign_was_seen is only used when doing Objective-C string
1243 concatenation. It is 'true' if we have seen an '@' before the
1244 current string, and 'false' if not. We must see exactly one or
1245 zero '@' before each string. */
1246 bool objc_at_sign_was_seen = false;
1247
1248 retry:
1249 tok = cpp_get_token (parse_in);
1250 switch (tok->type)
1251 {
1252 case CPP_PADDING:
1253 goto retry;
1254 case CPP_ATSIGN:
1255 if (objc_string)
1256 {
1257 if (objc_at_sign_was_seen)
1258 error ("repeated %<@%> before Objective-C string");
1259
1260 objc_at_sign_was_seen = true;
1261 goto retry;
1262 }
1263 /* FALLTHROUGH */
1264
1265 default:
1266 break;
1267
1268 case CPP_WSTRING:
1269 case CPP_STRING16:
1270 case CPP_STRING32:
1271 case CPP_UTF8STRING:
1272 if (type != tok->type)
1273 {
1274 if (type == CPP_STRING)
1275 type = tok->type;
1276 else
1277 error ("unsupported non-standard concatenation of string literals");
1278 }
1279 /* FALLTHROUGH */
1280
1281 case CPP_STRING:
1282 if (!concats)
1283 {
1284 gcc_obstack_init (&str_ob);
1285 gcc_obstack_init (&loc_ob);
1286 obstack_grow (&str_ob, &str, sizeof (cpp_string));
1287 obstack_grow (&loc_ob, &init_loc, sizeof (location_t));
1288 }
1289
1290 concats++;
1291 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
1292 obstack_grow (&loc_ob, &tok->src_loc, sizeof (location_t));
1293
1294 if (objc_string)
1295 objc_at_sign_was_seen = false;
1296 goto retry;
1297 }
1298
1299 /* It is an error if we saw a '@' with no following string. */
1300 if (objc_at_sign_was_seen)
1301 error ("stray %<@%> in program");
1302
1303 /* We have read one more token than we want. */
1304 _cpp_backup_tokens (parse_in, 1);
1305 if (concats)
1306 {
1307 strs = XOBFINISH (&str_ob, cpp_string *);
1308 locs = XOBFINISH (&loc_ob, location_t *);
1309 }
1310
1311 if (concats && !objc_string && !in_system_header_at (input_location))
1312 warning (OPT_Wtraditional,
1313 "traditional C rejects string constant concatenation");
1314
1315 if ((translate
1316 ? cpp_interpret_string : cpp_interpret_string_notranslate)
1317 (parse_in, strs, concats + 1, &istr, type))
1318 {
1319 value = build_string (istr.len, (const char *) istr.text);
1320 free (CONST_CAST (unsigned char *, istr.text));
1321 if (concats)
1322 {
1323 gcc_assert (locs);
1324 gcc_assert (g_string_concat_db);
1325 g_string_concat_db->record_string_concatenation (concats + 1, locs);
1326 }
1327 }
1328 else
1329 {
1330 /* Callers cannot generally handle error_mark_node in this context,
1331 so return the empty string instead. cpp_interpret_string has
1332 issued an error. */
1333 switch (type)
1334 {
1335 default:
1336 case CPP_STRING:
1337 case CPP_UTF8STRING:
1338 value = build_string (1, "");
1339 break;
1340 case CPP_STRING16:
1341 value = build_string (TYPE_PRECISION (char16_type_node)
1342 / TYPE_PRECISION (char_type_node),
1343 "\0"); /* char16_t is 16 bits */
1344 break;
1345 case CPP_STRING32:
1346 value = build_string (TYPE_PRECISION (char32_type_node)
1347 / TYPE_PRECISION (char_type_node),
1348 "\0\0\0"); /* char32_t is 32 bits */
1349 break;
1350 case CPP_WSTRING:
1351 value = build_string (TYPE_PRECISION (wchar_type_node)
1352 / TYPE_PRECISION (char_type_node),
1353 "\0\0\0"); /* widest supported wchar_t
1354 is 32 bits */
1355 break;
1356 }
1357 }
1358
1359 switch (type)
1360 {
1361 default:
1362 case CPP_STRING:
1363 TREE_TYPE (value) = char_array_type_node;
1364 break;
1365 case CPP_UTF8STRING:
1366 if (flag_char8_t)
1367 TREE_TYPE (value) = char8_array_type_node;
1368 else
1369 TREE_TYPE (value) = char_array_type_node;
1370 break;
1371 case CPP_STRING16:
1372 TREE_TYPE (value) = char16_array_type_node;
1373 break;
1374 case CPP_STRING32:
1375 TREE_TYPE (value) = char32_array_type_node;
1376 break;
1377 case CPP_WSTRING:
1378 TREE_TYPE (value) = wchar_array_type_node;
1379 }
1380 *valp = fix_string_type (value);
1381
1382 if (concats)
1383 {
1384 obstack_free (&str_ob, 0);
1385 obstack_free (&loc_ob, 0);
1386 }
1387
1388 return objc_string ? CPP_OBJC_STRING : type;
1389 }
1390
1391 /* Converts a (possibly wide) character constant token into a tree. */
1392 static tree
lex_charconst(const cpp_token * token)1393 lex_charconst (const cpp_token *token)
1394 {
1395 cppchar_t result;
1396 tree type, value;
1397 unsigned int chars_seen;
1398 int unsignedp = 0;
1399
1400 result = cpp_interpret_charconst (parse_in, token,
1401 &chars_seen, &unsignedp);
1402
1403 if (token->type == CPP_WCHAR)
1404 type = wchar_type_node;
1405 else if (token->type == CPP_CHAR32)
1406 type = char32_type_node;
1407 else if (token->type == CPP_CHAR16)
1408 type = char16_type_node;
1409 else if (token->type == CPP_UTF8CHAR)
1410 {
1411 if (!c_dialect_cxx ())
1412 type = unsigned_char_type_node;
1413 else if (flag_char8_t)
1414 type = char8_type_node;
1415 else
1416 type = char_type_node;
1417 }
1418 /* In C, a character constant has type 'int'.
1419 In C++ 'char', but multi-char charconsts have type 'int'. */
1420 else if (!c_dialect_cxx () || chars_seen > 1)
1421 type = integer_type_node;
1422 else
1423 type = char_type_node;
1424
1425 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1426 before possibly widening to HOST_WIDE_INT for build_int_cst. */
1427 if (unsignedp || (cppchar_signed_t) result >= 0)
1428 value = build_int_cst (type, result);
1429 else
1430 value = build_int_cst (type, (cppchar_signed_t) result);
1431
1432 return value;
1433 }
1434
1435 /* Helper function for c_parser_peek_conflict_marker
1436 and cp_lexer_peek_conflict_marker.
1437 Given a possible conflict marker token of kind TOK1_KIND
1438 consisting of a pair of characters, get the token kind for the
1439 standalone final character. */
1440
1441 enum cpp_ttype
conflict_marker_get_final_tok_kind(enum cpp_ttype tok1_kind)1442 conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind)
1443 {
1444 switch (tok1_kind)
1445 {
1446 default: gcc_unreachable ();
1447 case CPP_LSHIFT:
1448 /* "<<" and '<' */
1449 return CPP_LESS;
1450
1451 case CPP_EQ_EQ:
1452 /* "==" and '=' */
1453 return CPP_EQ;
1454
1455 case CPP_RSHIFT:
1456 /* ">>" and '>' */
1457 return CPP_GREATER;
1458 }
1459 }
1460