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

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