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);
  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         unsigned int flags = cpp_classify_number (parse_in, tok);
 318
 319         switch (flags & CPP_N_CATEGORY)
 320           {
 321           case CPP_N_INVALID:
 322             /* cpplib has issued an error.  */
 323             *value = error_mark_node;
 324             break;
 325
 326           case CPP_N_INTEGER:
 327             /* C++ uses '0' to mark virtual functions as pure.
 328                Set PURE_ZERO to pass this information to the C++ parser.  */
 329             if (tok->val.str.len == 1 && *tok->val.str.text == '0')
 330               add_flags = PURE_ZERO;
 331             *value = interpret_integer (tok, flags);
 332             break;
 333
 334           case CPP_N_FLOATING:
 335             *value = interpret_float (tok, flags);
 336             break;
 337
 338           default:
 339             gcc_unreachable ();
 340           }
 341       }
 342       break;
 343
 344     case CPP_ATSIGN:
 345       /* An @ may give the next token special significance in Objective-C.  */
 346       if (c_dialect_objc ())
 347         {
 348           location_t atloc = *loc;
 349           location_t newloc;
 350
 351         retry_at:
 352           tok = cpp_get_token_with_location (parse_in, &newloc);
 353           type = tok->type;
 354           switch (type)
 355             {
 356             case CPP_PADDING:
 357               goto retry_at;
 358
 359             case CPP_STRING:
 360             case CPP_WSTRING:
 361             case CPP_STRING16:
 362             case CPP_STRING32:
 363             case CPP_UTF8STRING:
 364               type = lex_string (tok, value, true, true);
 365               break;
 366
 367             case CPP_NAME:
 368               *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
 369               if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
 370                   || OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
 371                 {
 372                   type = CPP_AT_NAME;
 373                   /* Note the complication: if we found an OBJC_CXX
 374                      keyword, for example, 'class', we will be
 375                      returning a token of type CPP_AT_NAME and rid
 376                      code RID_CLASS (not RID_AT_CLASS).  The language
 377                      parser needs to convert that to RID_AT_CLASS.
 378                   */
 379                   break;
 380                 }
 381               /* FALLTHROUGH */
 382
 383             default:
 384               /* ... or not.  */
 385               error_at (atloc, "stray %<@%> in program");
 386               *loc = newloc;
 387               goto retry_after_at;
 388             }
 389           break;
 390         }
 391
 392       /* FALLTHROUGH */
 393     case CPP_HASH:
 394     case CPP_PASTE:
 395       {
 396         unsigned char name[8];
 397
 398         *cpp_spell_token (parse_in, tok, name, true) = 0;
 399
 400         error ("stray %qs in program", name);
 401       }
 402
 403       goto retry;
 404
 405     case CPP_OTHER:
 406       {
 407         cppchar_t c = tok->val.str.text[0];
 408
 409         if (c == '"' || c == '\'')
 410           error ("missing terminating %c character", (int) c);
 411         else if (ISGRAPH (c))
 412           error ("stray %qc in program", (int) c);
 413         else
 414           error ("stray %<\\%o%> in program", (int) c);
 415       }
 416       goto retry;
 417
 418     case CPP_CHAR:
 419     case CPP_WCHAR:
 420     case CPP_CHAR16:
 421     case CPP_CHAR32:
 422       *value = lex_charconst (tok);
 423       break;
 424
 425     case CPP_STRING:
 426     case CPP_WSTRING:
 427     case CPP_STRING16:
 428     case CPP_STRING32:
 429     case CPP_UTF8STRING:
 430       if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
 431         {
 432           type = lex_string (tok, value, false,
 433                              (lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
 434           break;
 435         }
 436       *value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
 437       break;
 438
 439     case CPP_PRAGMA:
 440       *value = build_int_cst (integer_type_node, tok->val.pragma);
 441       break;
 442
 443       /* These tokens should not be visible outside cpplib.  */
 444     case CPP_HEADER_NAME:
 445     case CPP_MACRO_ARG:
 446       gcc_unreachable ();
 447
 448     /* CPP_COMMENT will appear when compiling with -C and should be
 449        ignored.  */
 450      case CPP_COMMENT:
 451        goto retry;
 452
 453     default:
 454       *value = NULL_TREE;
 455       break;
 456     }
 457
 458   if (cpp_flags)
 459     *cpp_flags = tok->flags | add_flags;
 460
 461   if (!no_more_pch)
 462     {
 463       no_more_pch = true;
 464       c_common_no_more_pch ();
 465     }
 466
 467   timevar_pop (TV_CPP);
 468
 469   return type;
 470 }
 471
 472 /* Returns the narrowest C-visible unsigned type, starting with the
 473    minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
 474    there isn't one.  */
 475
 476 static enum integer_type_kind
 477 narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
 478                          unsigned HOST_WIDE_INT high,
 479                          unsigned int flags)
 480 {
 481   int itk;
 482
 483   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 484     itk = itk_unsigned_int;
 485   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 486     itk = itk_unsigned_long;
 487   else
 488     itk = itk_unsigned_long_long;
 489
 490   for (; itk < itk_none; itk += 2 /* skip unsigned types */)
 491     {
 492       tree upper;
 493
 494       if (integer_types[itk] == NULL_TREE)
 495         continue;
 496       upper = TYPE_MAX_VALUE (integer_types[itk]);
 497
 498       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 499           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 500               && TREE_INT_CST_LOW (upper) >= low))
 501         return (enum integer_type_kind) itk;
 502     }
 503
 504   return itk_none;
 505 }
 506
 507 /* Ditto, but narrowest signed type.  */
 508 static enum integer_type_kind
 509 narrowest_signed_type (unsigned HOST_WIDE_INT low,
 510                        unsigned HOST_WIDE_INT high, unsigned int flags)
 511 {
 512   int itk;
 513
 514   if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 515     itk = itk_int;
 516   else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 517     itk = itk_long;
 518   else
 519     itk = itk_long_long;
 520
 521
 522   for (; itk < itk_none; itk += 2 /* skip signed types */)
 523     {
 524       tree upper;
 525
 526       if (integer_types[itk] == NULL_TREE)
 527         continue;
 528       upper = TYPE_MAX_VALUE (integer_types[itk]);
 529
 530       if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
 531           || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
 532               && TREE_INT_CST_LOW (upper) >= low))
 533         return (enum integer_type_kind) itk;
 534     }
 535
 536   return itk_none;
 537 }
 538
 539 /* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
 540 static tree
 541 interpret_integer (const cpp_token *token, unsigned int flags)
 542 {
 543   tree value, type;
 544   enum integer_type_kind itk;
 545   cpp_num integer;
 546   cpp_options *options = cpp_get_options (parse_in);
 547
 548   integer = cpp_interpret_integer (parse_in, token, flags);
 549   integer = cpp_num_sign_extend (integer, options->precision);
 550
 551   /* The type of a constant with a U suffix is straightforward.  */
 552   if (flags & CPP_N_UNSIGNED)
 553     itk = narrowest_unsigned_type (integer.low, integer.high, flags);
 554   else
 555     {
 556       /* The type of a potentially-signed integer constant varies
 557          depending on the base it's in, the standard in use, and the
 558          length suffixes.  */
 559       enum integer_type_kind itk_u
 560         = narrowest_unsigned_type (integer.low, integer.high, flags);
 561       enum integer_type_kind itk_s
 562         = narrowest_signed_type (integer.low, integer.high, flags);
 563
 564       /* In both C89 and C99, octal and hex constants may be signed or
 565          unsigned, whichever fits tighter.  We do not warn about this
 566          choice differing from the traditional choice, as the constant
 567          is probably a bit pattern and either way will work.  */
 568       if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
 569         itk = MIN (itk_u, itk_s);
 570       else
 571         {
 572           /* In C99, decimal constants are always signed.
 573              In C89, decimal constants that don't fit in long have
 574              undefined behavior; we try to make them unsigned long.
 575              In GCC's extended C89, that last is true of decimal
 576              constants that don't fit in long long, too.  */
 577
 578           itk = itk_s;
 579           if (itk_s > itk_u && itk_s > itk_long)
 580             {
 581               if (!flag_isoc99)
 582                 {
 583                   if (itk_u < itk_unsigned_long)
 584                     itk_u = itk_unsigned_long;
 585                   itk = itk_u;
 586                   warning (0, "this decimal constant is unsigned only in ISO C90");
 587                 }
 588               else
 589                 warning (OPT_Wtraditional,
 590                          "this decimal constant would be unsigned in ISO C90");
 591             }
 592         }
 593     }
 594
 595   if (itk == itk_none)
 596     /* cpplib has already issued a warning for overflow.  */
 597     type = ((flags & CPP_N_UNSIGNED)
 598             ? widest_unsigned_literal_type_node
 599             : widest_integer_literal_type_node);
 600   else
 601     {
 602       type = integer_types[itk];
 603       if (itk > itk_unsigned_long
 604           && (flags & CPP_N_WIDTH) != CPP_N_LARGE)
 605         emit_diagnostic
 606           ((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
 607            ? DK_PEDWARN : DK_WARNING,
 608            input_location, OPT_Wlong_long,
 609            (flags & CPP_N_UNSIGNED)
 610            ? "integer constant is too large for %<unsigned long%> type"
 611            : "integer constant is too large for %<long%> type");
 612     }
 613
 614   value = build_int_cst_wide (type, integer.low, integer.high);
 615
 616   /* Convert imaginary to a complex type.  */
 617   if (flags & CPP_N_IMAGINARY)
 618     value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
 619
 620   return value;
 621 }
 622
 623 /* Interpret TOKEN, a floating point number with FLAGS as classified
 624    by cpplib.  */
 625 static tree
 626 interpret_float (const cpp_token *token, unsigned int flags)
 627 {
 628   tree type;
 629   tree const_type;
 630   tree value;
 631   REAL_VALUE_TYPE real;
 632   REAL_VALUE_TYPE real_trunc;
 633   char *copy;
 634   size_t copylen;
 635
 636   /* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
 637      pragma has been used and is either double or _Decimal64.  Types
 638      that are not allowed with decimal float default to double.  */
 639   if (flags & CPP_N_DEFAULT)
 640     {
 641       flags ^= CPP_N_DEFAULT;
 642       flags |= CPP_N_MEDIUM;
 643
 644       if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
 645         {
 646           warning (OPT_Wunsuffixed_float_constants,
 647                    "unsuffixed float constant");
 648           if (float_const_decimal64_p ())
 649             flags |= CPP_N_DFLOAT;
 650         }
 651     }
 652
 653   /* Decode _Fract and _Accum.  */
 654   if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
 655     return interpret_fixed (token, flags);
 656
 657   /* Decode type based on width and properties. */
 658   if (flags & CPP_N_DFLOAT)
 659     if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 660       type = dfloat128_type_node;
 661     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 662       type = dfloat32_type_node;
 663     else
 664       type = dfloat64_type_node;
 665   else
 666     if (flags & CPP_N_WIDTH_MD)
 667       {
 668         char suffix;
 669         enum machine_mode mode;
 670
 671         if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
 672           suffix = 'w';
 673         else
 674           suffix = 'q';
 675
 676         mode = targetm.c.mode_for_suffix (suffix);
 677         if (mode == VOIDmode)
 678           {
 679             error ("unsupported non-standard suffix on floating constant");
 680
 681             return error_mark_node;
 682           }
 683         else
 684           pedwarn (input_location, OPT_pedantic, "non-standard suffix on floating constant");
 685
 686         type = c_common_type_for_mode (mode, 0);
 687         gcc_assert (type);
 688       }
 689     else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 690       type = long_double_type_node;
 691     else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
 692              || flag_single_precision_constant)
 693       type = float_type_node;
 694     else
 695       type = double_type_node;
 696
 697   const_type = excess_precision_type (type);
 698   if (!const_type)
 699     const_type = type;
 700
 701   /* Copy the constant to a nul-terminated buffer.  If the constant
 702      has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
 703      can't handle them.  */
 704   copylen = token->val.str.len;
 705   if (flags & CPP_N_DFLOAT)
 706     copylen -= 2;
 707   else
 708     {
 709       if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
 710         /* Must be an F or L or machine defined suffix.  */
 711         copylen--;
 712       if (flags & CPP_N_IMAGINARY)
 713         /* I or J suffix.  */
 714         copylen--;
 715     }
 716
 717   copy = (char *) alloca (copylen + 1);
 718   memcpy (copy, token->val.str.text, copylen);
 719   copy[copylen] = '\0';
 720
 721   real_from_string3 (&real, copy, TYPE_MODE (const_type));
 722   if (const_type != type)
 723     /* Diagnosing if the result of converting the value with excess
 724        precision to the semantic type would overflow (with associated
 725        double rounding) is more appropriate than diagnosing if the
 726        result of converting the string directly to the semantic type
 727        would overflow.  */
 728     real_convert (&real_trunc, TYPE_MODE (type), &real);
 729
 730   /* Both C and C++ require a diagnostic for a floating constant
 731      outside the range of representable values of its type.  Since we
 732      have __builtin_inf* to produce an infinity, this is now a
 733      mandatory pedwarn if the target does not support infinities.  */
 734   if (REAL_VALUE_ISINF (real)
 735       || (const_type != type && REAL_VALUE_ISINF (real_trunc)))
 736     {
 737       if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
 738         pedwarn (input_location, 0, "floating constant exceeds range of %qT", type);
 739       else
 740         warning (OPT_Woverflow, "floating constant exceeds range of %qT", type);
 741     }
 742   /* We also give a warning if the value underflows.  */
 743   else if (REAL_VALUES_EQUAL (real, dconst0)
 744            || (const_type != type && REAL_VALUES_EQUAL (real_trunc, dconst0)))
 745     {
 746       REAL_VALUE_TYPE realvoidmode;
 747       int overflow = real_from_string (&realvoidmode, copy);
 748       if (overflow < 0 || !REAL_VALUES_EQUAL (realvoidmode, dconst0))
 749         warning (OPT_Woverflow, "floating constant truncated to zero");
 750     }
 751
 752   /* Create a node with determined type and value.  */
 753   value = build_real (const_type, real);
 754   if (flags & CPP_N_IMAGINARY)
 755     {
 756       value = build_complex (NULL_TREE, convert (const_type,
 757                                                  integer_zero_node), value);
 758       if (type != const_type)
 759         {
 760           const_type = TREE_TYPE (value);
 761           type = build_complex_type (type);
 762         }
 763     }
 764
 765   if (type != const_type)
 766     value = build1 (EXCESS_PRECISION_EXPR, type, value);
 767
 768   return value;
 769 }
 770
 771 /* Interpret TOKEN, a fixed-point number with FLAGS as classified
 772    by cpplib.  */
 773
 774 static tree
 775 interpret_fixed (const cpp_token *token, unsigned int flags)
 776 {
 777   tree type;
 778   tree value;
 779   FIXED_VALUE_TYPE fixed;
 780   char *copy;
 781   size_t copylen;
 782
 783   copylen = token->val.str.len;
 784
 785   if (flags & CPP_N_FRACT) /* _Fract.  */
 786     {
 787       if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract.  */
 788         {
 789           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 790             {
 791               type = unsigned_long_long_fract_type_node;
 792               copylen -= 4;
 793             }
 794           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 795             {
 796               type = unsigned_long_fract_type_node;
 797               copylen -= 3;
 798             }
 799           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 800             {
 801               type = unsigned_short_fract_type_node;
 802               copylen -= 3;
 803             }
 804           else
 805             {
 806               type = unsigned_fract_type_node;
 807               copylen -= 2;
 808             }
 809         }
 810       else /* Signed _Fract.  */
 811         {
 812           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 813             {
 814               type = long_long_fract_type_node;
 815               copylen -= 3;
 816             }
 817           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 818             {
 819               type = long_fract_type_node;
 820               copylen -= 2;
 821             }
 822           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 823             {
 824               type = short_fract_type_node;
 825               copylen -= 2;
 826             }
 827           else
 828             {
 829               type = fract_type_node;
 830               copylen --;
 831             }
 832           }
 833     }
 834   else /* _Accum.  */
 835     {
 836       if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum.  */
 837         {
 838           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 839             {
 840               type = unsigned_long_long_accum_type_node;
 841               copylen -= 4;
 842             }
 843           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 844             {
 845               type = unsigned_long_accum_type_node;
 846               copylen -= 3;
 847             }
 848           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 849             {
 850               type = unsigned_short_accum_type_node;
 851               copylen -= 3;
 852              }
 853           else
 854             {
 855               type = unsigned_accum_type_node;
 856               copylen -= 2;
 857             }
 858         }
 859       else /* Signed _Accum.  */
 860         {
 861           if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
 862             {
 863               type = long_long_accum_type_node;
 864               copylen -= 3;
 865             }
 866           else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
 867             {
 868               type = long_accum_type_node;
 869               copylen -= 2;
 870             }
 871           else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
 872             {
 873               type = short_accum_type_node;
 874               copylen -= 2;
 875             }
 876           else
 877             {
 878               type = accum_type_node;
 879               copylen --;
 880             }
 881         }
 882     }
 883
 884   copy = (char *) alloca (copylen + 1);
 885   memcpy (copy, token->val.str.text, copylen);
 886   copy[copylen] = '\0';
 887
 888   fixed_from_string (&fixed, copy, TYPE_MODE (type));
 889
 890   /* Create a node with determined type and value.  */
 891   value = build_fixed (type, fixed);
 892
 893   return value;
 894 }
 895
 896 /* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
 897    UTF8STRING tokens into a tree, performing string constant
 898    concatenation.  TOK is the first of these.  VALP is the location to
 899    write the string into.  OBJC_STRING indicates whether an '@' token
 900    preceded the incoming token (in that case, the strings can either
 901    be ObjC strings, preceded by a single '@', or normal strings, not
 902    preceded by '@'.  The result will be a CPP_OBJC_STRING).  Returns
 903    the CPP token type of the result (CPP_STRING, CPP_WSTRING,
 904    CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
 905
 906    This is unfortunately more work than it should be.  If any of the
 907    strings in the series has an L prefix, the result is a wide string
 908    (6.4.5p4).  Whether or not the result is a wide string affects the
 909    meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
 910    sequences do not continue across the boundary between two strings in
 911    a series (6.4.5p7), so we must not lose the boundaries.  Therefore
 912    cpp_interpret_string takes a vector of cpp_string structures, which
 913    we must arrange to provide.  */
 914
 915 static enum cpp_ttype
 916 lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
 917 {
 918   tree value;
 919   size_t concats = 0;
 920   struct obstack str_ob;
 921   cpp_string istr;
 922   enum cpp_ttype type = tok->type;
 923
 924   /* Try to avoid the overhead of creating and destroying an obstack
 925      for the common case of just one string.  */
 926   cpp_string str = tok->val.str;
 927   cpp_string *strs = &str;
 928
 929   /* objc_at_sign_was_seen is only used when doing Objective-C string
 930      concatenation.  It is 'true' if we have seen an '@' before the
 931      current string, and 'false' if not.  We must see exactly one or
 932      zero '@' before each string.  */
 933   bool objc_at_sign_was_seen = false;
 934
 935  retry:
 936   tok = cpp_get_token (parse_in);
 937   switch (tok->type)
 938     {
 939     case CPP_PADDING:
 940       goto retry;
 941     case CPP_ATSIGN:
 942       if (objc_string)
 943         {
 944           if (objc_at_sign_was_seen)
 945             error ("repeated %<@%> before Objective-C string");
 946
 947           objc_at_sign_was_seen = true;
 948           goto retry;
 949         }
 950       /* FALLTHROUGH */
 951
 952     default:
 953       break;
 954
 955     case CPP_WSTRING:
 956     case CPP_STRING16:
 957     case CPP_STRING32:
 958     case CPP_UTF8STRING:
 959       if (type != tok->type)
 960         {
 961           if (type == CPP_STRING)
 962             type = tok->type;
 963           else
 964             error ("unsupported non-standard concatenation of string literals");
 965         }
 966
 967     case CPP_STRING:
 968       if (!concats)
 969         {
 970           gcc_obstack_init (&str_ob);
 971           obstack_grow (&str_ob, &str, sizeof (cpp_string));
 972         }
 973
 974       concats++;
 975       obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
 976       if (objc_string)
 977         objc_at_sign_was_seen = false;
 978       goto retry;
 979     }
 980
 981   /* It is an error if we saw a '@' with no following string.  */
 982   if (objc_at_sign_was_seen)
 983     error ("stray %<@%> in program");
 984
 985   /* We have read one more token than we want.  */
 986   _cpp_backup_tokens (parse_in, 1);
 987   if (concats)
 988     strs = XOBFINISH (&str_ob, cpp_string *);
 989
 990   if (concats && !objc_string && !in_system_header)
 991     warning (OPT_Wtraditional,
 992              "traditional C rejects string constant concatenation");
 993
 994   if ((translate
 995        ? cpp_interpret_string : cpp_interpret_string_notranslate)
 996       (parse_in, strs, concats + 1, &istr, type))
 997     {
 998       value = build_string (istr.len, (const char *) istr.text);
 999       free (CONST_CAST (unsigned char *, istr.text));
1000     }
1001   else
1002     {
1003       /* Callers cannot generally handle error_mark_node in this context,
1004          so return the empty string instead.  cpp_interpret_string has
1005          issued an error.  */
1006       switch (type)
1007         {
1008         default:
1009         case CPP_STRING:
1010         case CPP_UTF8STRING:
1011           value = build_string (1, "");
1012           break;
1013         case CPP_STRING16:
1014           value = build_string (TYPE_PRECISION (char16_type_node)
1015                                 / TYPE_PRECISION (char_type_node),
1016                                 "\0");  /* char16_t is 16 bits */
1017           break;
1018         case CPP_STRING32:
1019           value = build_string (TYPE_PRECISION (char32_type_node)
1020                                 / TYPE_PRECISION (char_type_node),
1021                                 "\0\0\0");  /* char32_t is 32 bits */
1022           break;
1023         case CPP_WSTRING:
1024           value = build_string (TYPE_PRECISION (wchar_type_node)
1025                                 / TYPE_PRECISION (char_type_node),
1026                                 "\0\0\0");  /* widest supported wchar_t
1027                                                is 32 bits */
1028           break;
1029         }
1030     }
1031
1032   switch (type)
1033     {
1034     default:
1035     case CPP_STRING:
1036     case CPP_UTF8STRING:
1037       TREE_TYPE (value) = char_array_type_node;
1038       break;
1039     case CPP_STRING16:
1040       TREE_TYPE (value) = char16_array_type_node;
1041       break;
1042     case CPP_STRING32:
1043       TREE_TYPE (value) = char32_array_type_node;
1044       break;
1045     case CPP_WSTRING:
1046       TREE_TYPE (value) = wchar_array_type_node;
1047     }
1048   *valp = fix_string_type (value);
1049
1050   if (concats)
1051     obstack_free (&str_ob, 0);
1052
1053   return objc_string ? CPP_OBJC_STRING : type;
1054 }
1055
1056 /* Converts a (possibly wide) character constant token into a tree.  */
1057 static tree
1058 lex_charconst (const cpp_token *token)
1059 {
1060   cppchar_t result;
1061   tree type, value;
1062   unsigned int chars_seen;
1063   int unsignedp = 0;
1064
1065   result = cpp_interpret_charconst (parse_in, token,
1066                                     &chars_seen, &unsignedp);
1067
1068   if (token->type == CPP_WCHAR)
1069     type = wchar_type_node;
1070   else if (token->type == CPP_CHAR32)
1071     type = char32_type_node;
1072   else if (token->type == CPP_CHAR16)
1073     type = char16_type_node;
1074   /* In C, a character constant has type 'int'.
1075      In C++ 'char', but multi-char charconsts have type 'int'.  */
1076   else if (!c_dialect_cxx () || chars_seen > 1)
1077     type = integer_type_node;
1078   else
1079     type = char_type_node;
1080
1081   /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1082      before possibly widening to HOST_WIDE_INT for build_int_cst.  */
1083   if (unsignedp || (cppchar_signed_t) result >= 0)
1084     value = build_int_cst_wide (type, result, 0);
1085   else
1086     value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
1087
1088   return value;
1089 }