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