OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [c-lex.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.