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

Subversion Repositories openrisc_me

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

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* 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
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
 
44
/* We may keep statistics about how long which files took to compile.  */
45
static int header_time, body_time;
46
static splay_tree file_info_tree;
47
 
48
int pending_lang_change; /* If we need to switch languages - C++ only */
49
int c_header_level;      /* depth in C headers - C++ only */
50
 
51
/* If we need to translate characters received.  This is tri-state:
52
 
53
   the translated string; -1 means chain the translated string
54
   to the untranslated one.  */
55
int c_lex_string_translate = 1;
56
 
57
/* True if strings should be passed to the caller of c_lex completely
58
   unmolested (no concatenation, no translation).  */
59
bool c_lex_return_raw_strings = false;
60
 
61
static tree interpret_integer (const cpp_token *, unsigned int);
62
static tree interpret_float (const cpp_token *, unsigned int);
63
static enum integer_type_kind narrowest_unsigned_type
64
        (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
65
static enum integer_type_kind narrowest_signed_type
66
        (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int);
67
static enum cpp_ttype lex_string (const cpp_token *, tree *, bool);
68
static tree lex_charconst (const cpp_token *);
69
static void update_header_times (const char *);
70
static int dump_one_header (splay_tree_node, void *);
71
static void cb_line_change (cpp_reader *, const cpp_token *, int);
72
static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
73
static void cb_def_pragma (cpp_reader *, unsigned int);
74
static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
75
static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
76
 
77
void
78
init_c_lex (void)
79
{
80
  struct cpp_callbacks *cb;
81
  struct c_fileinfo *toplevel;
82
 
83
  /* The get_fileinfo data structure must be initialized before
84
     cpp_read_main_file is called.  */
85
  toplevel = get_fileinfo ("<top level>");
86
  if (flag_detailed_statistics)
87
    {
88
      header_time = 0;
89
      body_time = get_run_time ();
90
      toplevel->time = body_time;
91
    }
92
 
93
  cb = cpp_get_callbacks (parse_in);
94
 
95
  cb->line_change = cb_line_change;
96
  cb->ident = cb_ident;
97
  cb->def_pragma = cb_def_pragma;
98
  cb->valid_pch = c_common_valid_pch;
99
  cb->read_pch = c_common_read_pch;
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
    {
106
      cb->define = cb_define;
107
      cb->undef = cb_undef;
108
    }
109
}
110
 
111
struct c_fileinfo *
112
get_fileinfo (const char *name)
113
{
114
  splay_tree_node n;
115
  struct c_fileinfo *fi;
116
 
117
  if (!file_info_tree)
118
    file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp,
119
                                     0,
120
                                     (splay_tree_delete_value_fn) free);
121
 
122
  n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
123
  if (n)
124
    return (struct c_fileinfo *) n->value;
125
 
126
  fi = XNEW (struct c_fileinfo);
127
  fi->time = 0;
128
  fi->interface_only = 0;
129
  fi->interface_unknown = 1;
130
  splay_tree_insert (file_info_tree, (splay_tree_key) name,
131
                     (splay_tree_value) fi);
132
  return fi;
133
}
134
 
135
static void
136
update_header_times (const char *name)
137
{
138
  /* Changing files again.  This means currently collected time
139
     is charged against header time, and body time starts back at 0.  */
140
  if (flag_detailed_statistics)
141
    {
142
      int this_time = get_run_time ();
143
      struct c_fileinfo *file = get_fileinfo (name);
144
      header_time += this_time - body_time;
145
      file->time += this_time - body_time;
146
      body_time = this_time;
147
    }
148
}
149
 
150
static int
151
dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
152
{
153
  print_time ((const char *) n->key,
154
              ((struct c_fileinfo *) n->value)->time);
155
  return 0;
156
}
157
 
158
void
159
dump_time_statistics (void)
160
{
161
  struct c_fileinfo *file = get_fileinfo (input_filename);
162
  int this_time = get_run_time ();
163
  file->time += this_time - body_time;
164
 
165
  fprintf (stderr, "\n******\n");
166
  print_time ("header files (total)", header_time);
167
  print_time ("main file (total)", this_time - body_time);
168
  fprintf (stderr, "ratio = %g : 1\n",
169
           (double) header_time / (double) (this_time - body_time));
170
  fprintf (stderr, "\n******\n");
171
 
172
  splay_tree_foreach (file_info_tree, dump_one_header, 0);
173
}
174
 
175
static void
176
cb_ident (cpp_reader * ARG_UNUSED (pfile),
177
          unsigned int ARG_UNUSED (line),
178
          const cpp_string * ARG_UNUSED (str))
179
{
180
#ifdef ASM_OUTPUT_IDENT
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, false))
186
        {
187
          ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text);
188
          free ((void *) cstr.text);
189
        }
190
    }
191
#endif
192
}
193
 
194
/* Called at the start of every non-empty line.  TOKEN is the first
195
   lexed token on the line.  Used for diagnostic line numbers.  */
196
static void
197
cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
198
                int parsing_args)
199
{
200
  if (token->type != CPP_EOF && !parsing_args)
201
#ifdef USE_MAPPED_LOCATION
202
    input_location = token->src_loc;
203
#else
204
    {
205
      source_location loc = token->src_loc;
206
      const struct line_map *map = linemap_lookup (&line_table, loc);
207
      input_line = SOURCE_LINE (map, loc);
208
    }
209
#endif
210
}
211
 
212
void
213
fe_file_change (const struct line_map *new_map)
214
{
215
  if (new_map == NULL)
216
    return;
217
 
218
  if (new_map->reason == LC_ENTER)
219
    {
220
      /* Don't stack the main buffer on the input stack;
221
         we already did in compile_file.  */
222
      if (!MAIN_FILE_P (new_map))
223
        {
224
#ifdef USE_MAPPED_LOCATION
225
          int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1);
226
 
227
          input_location = included_at;
228
          push_srcloc (new_map->start_location);
229
#else
230
          int included_at = LAST_SOURCE_LINE (new_map - 1);
231
 
232
          input_line = included_at;
233
          push_srcloc (new_map->to_file, 1);
234
#endif
235
          (*debug_hooks->start_source_file) (included_at, new_map->to_file);
236
#ifndef NO_IMPLICIT_EXTERN_C
237
          if (c_header_level)
238
            ++c_header_level;
239
          else if (new_map->sysp == 2)
240
            {
241
              c_header_level = 1;
242
              ++pending_lang_change;
243
            }
244
#endif
245
        }
246
    }
247
  else if (new_map->reason == LC_LEAVE)
248
    {
249
#ifndef NO_IMPLICIT_EXTERN_C
250
      if (c_header_level && --c_header_level == 0)
251
        {
252
          if (new_map->sysp == 2)
253
            warning (0, "badly nested C headers from preprocessor");
254
          --pending_lang_change;
255
        }
256
#endif
257
      pop_srcloc ();
258
 
259
      (*debug_hooks->end_source_file) (new_map->to_line);
260
    }
261
 
262
  update_header_times (new_map->to_file);
263
  in_system_header = new_map->sysp != 0;
264
#ifdef USE_MAPPED_LOCATION
265
  input_location = new_map->start_location;
266
#else
267
  input_filename = new_map->to_file;
268
  input_line = new_map->to_line;
269
#endif
270
}
271
 
272
static void
273
cb_def_pragma (cpp_reader *pfile, source_location loc)
274
{
275
  /* Issue a warning message if we have been asked to do so.  Ignore
276
     unknown pragmas in system headers unless an explicit
277
     -Wunknown-pragmas has been given.  */
278
  if (warn_unknown_pragmas > in_system_header)
279
    {
280
      const unsigned char *space, *name;
281
      const cpp_token *s;
282
#ifndef USE_MAPPED_LOCATION
283
      location_t fe_loc;
284
      const struct line_map *map = linemap_lookup (&line_table, loc);
285
      fe_loc.file = map->to_file;
286
      fe_loc.line = SOURCE_LINE (map, loc);
287
#else
288
      location_t fe_loc = loc;
289
#endif
290
 
291
      space = name = (const unsigned char *) "";
292
      s = cpp_get_token (pfile);
293
      if (s->type != CPP_EOF)
294
        {
295
          space = cpp_token_as_text (pfile, s);
296
          s = cpp_get_token (pfile);
297
          if (s->type == CPP_NAME)
298
            name = cpp_token_as_text (pfile, s);
299
        }
300
 
301
      warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s",
302
               &fe_loc, space, name);
303
    }
304
}
305
 
306
/* #define callback for DWARF and DWARF2 debug info.  */
307
static void
308
cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node)
309
{
310
  const struct line_map *map = linemap_lookup (&line_table, loc);
311
  (*debug_hooks->define) (SOURCE_LINE (map, loc),
312
                          (const char *) cpp_macro_definition (pfile, node));
313
}
314
 
315
/* #undef callback for DWARF and DWARF2 debug info.  */
316
static void
317
cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc,
318
          cpp_hashnode *node)
319
{
320
  const struct line_map *map = linemap_lookup (&line_table, loc);
321
  (*debug_hooks->undef) (SOURCE_LINE (map, loc),
322
                         (const char *) NODE_NAME (node));
323
}
324
 
325
/* Read a token and return its type.  Fill *VALUE with its value, if
326
   applicable.  Fill *CPP_FLAGS with the token's flags, if it is
327
   non-NULL.  */
328
 
329
enum cpp_ttype
330
c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags)
331
{
332
  static bool no_more_pch;
333
  const cpp_token *tok;
334
  enum cpp_ttype type;
335
  unsigned char add_flags = 0;
336
 
337
  timevar_push (TV_CPP);
338
 retry:
339
  tok = cpp_get_token (parse_in);
340
  type = tok->type;
341
 
342
 retry_after_at:
343
#ifdef USE_MAPPED_LOCATION
344
  *loc = tok->src_loc;
345
#else
346
  *loc = input_location;
347
#endif
348
  switch (type)
349
    {
350
    case CPP_PADDING:
351
      goto retry;
352
 
353
    case CPP_NAME:
354
      *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
355
      break;
356
 
357
    case CPP_NUMBER:
358
      {
359
        unsigned int flags = cpp_classify_number (parse_in, tok);
360
 
361
        switch (flags & CPP_N_CATEGORY)
362
          {
363
          case CPP_N_INVALID:
364
            /* cpplib has issued an error.  */
365
            *value = error_mark_node;
366
            errorcount++;
367
            break;
368
 
369
          case CPP_N_INTEGER:
370
            /* C++ uses '0' to mark virtual functions as pure.
371
               Set PURE_ZERO to pass this information to the C++ parser.  */
372
            if (tok->val.str.len == 1 && *tok->val.str.text == '0')
373
              add_flags = PURE_ZERO;
374
            *value = interpret_integer (tok, flags);
375
            break;
376
 
377
          case CPP_N_FLOATING:
378
            *value = interpret_float (tok, flags);
379
            break;
380
 
381
          default:
382
            gcc_unreachable ();
383
          }
384
      }
385
      break;
386
 
387
    case CPP_ATSIGN:
388
      /* An @ may give the next token special significance in Objective-C.  */
389
      if (c_dialect_objc ())
390
        {
391
          location_t atloc = input_location;
392
 
393
        retry_at:
394
          tok = cpp_get_token (parse_in);
395
          type = tok->type;
396
          switch (type)
397
            {
398
            case CPP_PADDING:
399
              goto retry_at;
400
 
401
            case CPP_STRING:
402
            case CPP_WSTRING:
403
              type = lex_string (tok, value, true);
404
              break;
405
 
406
            case CPP_NAME:
407
              *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
408
              if (objc_is_reserved_word (*value))
409
                {
410
                  type = CPP_AT_NAME;
411
                  break;
412
                }
413
              /* FALLTHROUGH */
414
 
415
            default:
416
              /* ... or not.  */
417
              error ("%Hstray %<@%> in program", &atloc);
418
              goto retry_after_at;
419
            }
420
          break;
421
        }
422
 
423
      /* FALLTHROUGH */
424
    case CPP_HASH:
425
    case CPP_PASTE:
426
      {
427
        unsigned char name[4];
428
 
429
        *cpp_spell_token (parse_in, tok, name, true) = 0;
430
 
431
        error ("stray %qs in program", name);
432
      }
433
 
434
      goto retry;
435
 
436
    case CPP_OTHER:
437
      {
438
        cppchar_t c = tok->val.str.text[0];
439
 
440
        if (c == '"' || c == '\'')
441
          error ("missing terminating %c character", (int) c);
442
        else if (ISGRAPH (c))
443
          error ("stray %qc in program", (int) c);
444
        else
445
          error ("stray %<\\%o%> in program", (int) c);
446
      }
447
      goto retry;
448
 
449
    case CPP_CHAR:
450
    case CPP_WCHAR:
451
      *value = lex_charconst (tok);
452
      break;
453
 
454
    case CPP_STRING:
455
    case CPP_WSTRING:
456
      if (!c_lex_return_raw_strings)
457
        {
458
          type = lex_string (tok, value, false);
459
          break;
460
        }
461
      *value = build_string (tok->val.str.len, (char *) tok->val.str.text);
462
      break;
463
 
464
    case CPP_PRAGMA:
465
      *value = build_int_cst (NULL, tok->val.pragma);
466
      break;
467
 
468
      /* These tokens should not be visible outside cpplib.  */
469
    case CPP_HEADER_NAME:
470
    case CPP_COMMENT:
471
    case CPP_MACRO_ARG:
472
      gcc_unreachable ();
473
 
474
    default:
475
      *value = NULL_TREE;
476
      break;
477
    }
478
 
479
  if (cpp_flags)
480
    *cpp_flags = tok->flags | add_flags;
481
 
482
  if (!no_more_pch)
483
    {
484
      no_more_pch = true;
485
      c_common_no_more_pch ();
486
    }
487
 
488
  timevar_pop (TV_CPP);
489
 
490
  return type;
491
}
492
 
493
/* Returns the narrowest C-visible unsigned type, starting with the
494
   minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
495
   there isn't one.  */
496
 
497
static enum integer_type_kind
498
narrowest_unsigned_type (unsigned HOST_WIDE_INT low,
499
                         unsigned HOST_WIDE_INT high,
500
                         unsigned int flags)
501
{
502
  enum integer_type_kind itk;
503
 
504
  if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
505
    itk = itk_unsigned_int;
506
  else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
507
    itk = itk_unsigned_long;
508
  else
509
    itk = itk_unsigned_long_long;
510
 
511
  for (; itk < itk_none; itk += 2 /* skip unsigned types */)
512
    {
513
      tree upper = TYPE_MAX_VALUE (integer_types[itk]);
514
 
515
      if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
516
          || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
517
              && TREE_INT_CST_LOW (upper) >= low))
518
        return itk;
519
    }
520
 
521
  return itk_none;
522
}
523
 
524
/* Ditto, but narrowest signed type.  */
525
static enum integer_type_kind
526
narrowest_signed_type (unsigned HOST_WIDE_INT low,
527
                       unsigned HOST_WIDE_INT high, unsigned int flags)
528
{
529
  enum integer_type_kind itk;
530
 
531
  if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
532
    itk = itk_int;
533
  else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
534
    itk = itk_long;
535
  else
536
    itk = itk_long_long;
537
 
538
 
539
  for (; itk < itk_none; itk += 2 /* skip signed types */)
540
    {
541
      tree upper = TYPE_MAX_VALUE (integer_types[itk]);
542
 
543
      if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high
544
          || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high
545
              && TREE_INT_CST_LOW (upper) >= low))
546
        return itk;
547
    }
548
 
549
  return itk_none;
550
}
551
 
552
/* Interpret TOKEN, an integer with FLAGS as classified by cpplib.  */
553
static tree
554
interpret_integer (const cpp_token *token, unsigned int flags)
555
{
556
  tree value, type;
557
  enum integer_type_kind itk;
558
  cpp_num integer;
559
  cpp_options *options = cpp_get_options (parse_in);
560
 
561
  integer = cpp_interpret_integer (parse_in, token, flags);
562
  integer = cpp_num_sign_extend (integer, options->precision);
563
 
564
  /* The type of a constant with a U suffix is straightforward.  */
565
  if (flags & CPP_N_UNSIGNED)
566
    itk = narrowest_unsigned_type (integer.low, integer.high, flags);
567
  else
568
    {
569
      /* The type of a potentially-signed integer constant varies
570
         depending on the base it's in, the standard in use, and the
571
         length suffixes.  */
572
      enum integer_type_kind itk_u
573
        = narrowest_unsigned_type (integer.low, integer.high, flags);
574
      enum integer_type_kind itk_s
575
        = narrowest_signed_type (integer.low, integer.high, flags);
576
 
577
      /* In both C89 and C99, octal and hex constants may be signed or
578
         unsigned, whichever fits tighter.  We do not warn about this
579
         choice differing from the traditional choice, as the constant
580
         is probably a bit pattern and either way will work.  */
581
      if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
582
        itk = MIN (itk_u, itk_s);
583
      else
584
        {
585
          /* In C99, decimal constants are always signed.
586
             In C89, decimal constants that don't fit in long have
587
             undefined behavior; we try to make them unsigned long.
588
             In GCC's extended C89, that last is true of decimal
589
             constants that don't fit in long long, too.  */
590
 
591
          itk = itk_s;
592
          if (itk_s > itk_u && itk_s > itk_long)
593
            {
594
              if (!flag_isoc99)
595
                {
596
                  if (itk_u < itk_unsigned_long)
597
                    itk_u = itk_unsigned_long;
598
                  itk = itk_u;
599
                  warning (0, "this decimal constant is unsigned only in ISO C90");
600
                }
601
              else
602
                warning (OPT_Wtraditional,
603
                         "this decimal constant would be unsigned in ISO C90");
604
            }
605
        }
606
    }
607
 
608
  if (itk == itk_none)
609
    /* cpplib has already issued a warning for overflow.  */
610
    type = ((flags & CPP_N_UNSIGNED)
611
            ? widest_unsigned_literal_type_node
612
            : widest_integer_literal_type_node);
613
  else
614
    type = integer_types[itk];
615
 
616
  if (itk > itk_unsigned_long
617
      && (flags & CPP_N_WIDTH) != CPP_N_LARGE
618
      && !in_system_header && !flag_isoc99)
619
    pedwarn ("integer constant is too large for %qs type",
620
             (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long");
621
 
622
  value = build_int_cst_wide (type, integer.low, integer.high);
623
 
624
  /* Convert imaginary to a complex type.  */
625
  if (flags & CPP_N_IMAGINARY)
626
    value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
627
 
628
  return value;
629
}
630
 
631
/* Interpret TOKEN, a floating point number with FLAGS as classified
632
   by cpplib.  */
633
static tree
634
interpret_float (const cpp_token *token, unsigned int flags)
635
{
636
  tree type;
637
  tree value;
638
  REAL_VALUE_TYPE real;
639
  char *copy;
640
  size_t copylen;
641
 
642
  /* Decode type based on width and properties. */
643
  if (flags & CPP_N_DFLOAT)
644
    if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
645
      type = dfloat128_type_node;
646
    else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
647
      type = dfloat32_type_node;
648
    else
649
      type = dfloat64_type_node;
650
  else
651
    if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
652
      type = long_double_type_node;
653
    else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
654
             || flag_single_precision_constant)
655
      type = float_type_node;
656
    else
657
      type = double_type_node;
658
 
659
  /* Copy the constant to a nul-terminated buffer.  If the constant
660
     has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
661
     can't handle them.  */
662
  copylen = token->val.str.len;
663
  if (flags & CPP_N_DFLOAT)
664
    copylen -= 2;
665
  else
666
    {
667
      if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
668
        /* Must be an F or L suffix.  */
669
        copylen--;
670
      if (flags & CPP_N_IMAGINARY)
671
        /* I or J suffix.  */
672
        copylen--;
673
    }
674
 
675
  copy = (char *) alloca (copylen + 1);
676
  memcpy (copy, token->val.str.text, copylen);
677
  copy[copylen] = '\0';
678
 
679
  real_from_string3 (&real, copy, TYPE_MODE (type));
680
 
681
  /* Both C and C++ require a diagnostic for a floating constant
682
     outside the range of representable values of its type.  Since we
683
     have __builtin_inf* to produce an infinity, it might now be
684
     appropriate for this to be a mandatory pedwarn rather than
685
     conditioned on -pedantic.  */
686
  if (REAL_VALUE_ISINF (real) && pedantic)
687
    pedwarn ("floating constant exceeds range of %qT", type);
688
 
689
  /* Create a node with determined type and value.  */
690
  value = build_real (type, real);
691
  if (flags & CPP_N_IMAGINARY)
692
    value = build_complex (NULL_TREE, convert (type, integer_zero_node), value);
693
 
694
  return value;
695
}
696
 
697
/* Convert a series of STRING and/or WSTRING tokens into a tree,
698
   performing string constant concatenation.  TOK is the first of
699
   these.  VALP is the location to write the string into.  OBJC_STRING
700
   indicates whether an '@' token preceded the incoming token.
701
   Returns the CPP token type of the result (CPP_STRING, CPP_WSTRING,
702
   or CPP_OBJC_STRING).
703
 
704
   This is unfortunately more work than it should be.  If any of the
705
   strings in the series has an L prefix, the result is a wide string
706
   (6.4.5p4).  Whether or not the result is a wide string affects the
707
   meaning of octal and hexadecimal escapes (6.4.4.4p6,9).  But escape
708
   sequences do not continue across the boundary between two strings in
709
   a series (6.4.5p7), so we must not lose the boundaries.  Therefore
710
   cpp_interpret_string takes a vector of cpp_string structures, which
711
   we must arrange to provide.  */
712
 
713
static enum cpp_ttype
714
lex_string (const cpp_token *tok, tree *valp, bool objc_string)
715
{
716
  tree value;
717
  bool wide = false;
718
  size_t concats = 0;
719
  struct obstack str_ob;
720
  cpp_string istr;
721
 
722
  /* Try to avoid the overhead of creating and destroying an obstack
723
     for the common case of just one string.  */
724
  cpp_string str = tok->val.str;
725
  cpp_string *strs = &str;
726
 
727
  if (tok->type == CPP_WSTRING)
728
    wide = true;
729
 
730
 retry:
731
  tok = cpp_get_token (parse_in);
732
  switch (tok->type)
733
    {
734
    case CPP_PADDING:
735
      goto retry;
736
    case CPP_ATSIGN:
737
      if (c_dialect_objc ())
738
        {
739
          objc_string = true;
740
          goto retry;
741
        }
742
      /* FALLTHROUGH */
743
 
744
    default:
745
      break;
746
 
747
    case CPP_WSTRING:
748
      wide = true;
749
      /* FALLTHROUGH */
750
 
751
    case CPP_STRING:
752
      if (!concats)
753
        {
754
          gcc_obstack_init (&str_ob);
755
          obstack_grow (&str_ob, &str, sizeof (cpp_string));
756
        }
757
 
758
      concats++;
759
      obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
760
      goto retry;
761
    }
762
 
763
  /* We have read one more token than we want.  */
764
  _cpp_backup_tokens (parse_in, 1);
765
  if (concats)
766
    strs = XOBFINISH (&str_ob, cpp_string *);
767
 
768
  if (concats && !objc_string && !in_system_header)
769
    warning (OPT_Wtraditional,
770
             "traditional C rejects string constant concatenation");
771
 
772
  if ((c_lex_string_translate
773
       ? cpp_interpret_string : cpp_interpret_string_notranslate)
774
      (parse_in, strs, concats + 1, &istr, wide))
775
    {
776
      value = build_string (istr.len, (char *) istr.text);
777
      free ((void *) istr.text);
778
 
779
      if (c_lex_string_translate == -1)
780
        {
781
          int xlated = cpp_interpret_string_notranslate (parse_in, strs,
782
                                                         concats + 1,
783
                                                         &istr, wide);
784
          /* Assume that, if we managed to translate the string above,
785
             then the untranslated parsing will always succeed.  */
786
          gcc_assert (xlated);
787
 
788
          if (TREE_STRING_LENGTH (value) != (int) istr.len
789
              || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
790
                               istr.len))
791
            {
792
              /* Arrange for us to return the untranslated string in
793
                 *valp, but to set up the C type of the translated
794
                 one.  */
795
              *valp = build_string (istr.len, (char *) istr.text);
796
              valp = &TREE_CHAIN (*valp);
797
            }
798
          free ((void *) istr.text);
799
        }
800
    }
801
  else
802
    {
803
      /* Callers cannot generally handle error_mark_node in this context,
804
         so return the empty string instead.  cpp_interpret_string has
805
         issued an error.  */
806
      if (wide)
807
        value = build_string (TYPE_PRECISION (wchar_type_node)
808
                              / TYPE_PRECISION (char_type_node),
809
                              "\0\0\0");  /* widest supported wchar_t
810
                                             is 32 bits */
811
      else
812
        value = build_string (1, "");
813
    }
814
 
815
  TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
816
  *valp = fix_string_type (value);
817
 
818
  if (concats)
819
    obstack_free (&str_ob, 0);
820
 
821
  return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
822
}
823
 
824
/* Converts a (possibly wide) character constant token into a tree.  */
825
static tree
826
lex_charconst (const cpp_token *token)
827
{
828
  cppchar_t result;
829
  tree type, value;
830
  unsigned int chars_seen;
831
  int unsignedp;
832
 
833
  result = cpp_interpret_charconst (parse_in, token,
834
                                    &chars_seen, &unsignedp);
835
 
836
  if (token->type == CPP_WCHAR)
837
    type = wchar_type_node;
838
  /* In C, a character constant has type 'int'.
839
     In C++ 'char', but multi-char charconsts have type 'int'.  */
840
  else if (!c_dialect_cxx () || chars_seen > 1)
841
    type = integer_type_node;
842
  else
843
    type = char_type_node;
844
 
845
  /* Cast to cppchar_signed_t to get correct sign-extension of RESULT
846
     before possibly widening to HOST_WIDE_INT for build_int_cst.  */
847
  if (unsignedp || (cppchar_signed_t) result >= 0)
848
    value = build_int_cst_wide (type, result, 0);
849
  else
850
    value = build_int_cst_wide (type, (cppchar_signed_t) result, -1);
851
 
852
  return value;
853
}

powered by: WebSVN 2.1.0

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