contrib/gcc-5.0/gcc/c-family/c-lex.c

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