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