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