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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libcpp/] [init.c] - Blame information for rev 730

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 730 jeremybenn
/* CPP Library.
2
   Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
4
   2009, 2010, 2011 Free Software Foundation, Inc.
5
   Contributed by Per Bothner, 1994-95.
6
   Based on CCCP program by Paul Rubin, June 1986
7
   Adapted to ANSI C, Richard Stallman, Jan 1987
8
 
9
This program is free software; you can redistribute it and/or modify it
10
under the terms of the GNU General Public License as published by the
11
Free Software Foundation; either version 3, or (at your option) any
12
later version.
13
 
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with this program; see the file COPYING3.  If not see
21
<http://www.gnu.org/licenses/>.  */
22
 
23
#include "config.h"
24
#include "system.h"
25
#include "cpplib.h"
26
#include "internal.h"
27
#include "mkdeps.h"
28
#include "localedir.h"
29
#include "filenames.h"
30
 
31
static void init_library (void);
32
static void mark_named_operators (cpp_reader *, int);
33
static void read_original_filename (cpp_reader *);
34
static void read_original_directory (cpp_reader *);
35
static void post_options (cpp_reader *);
36
 
37
/* If we have designated initializers (GCC >2.7) these tables can be
38
   initialized, constant data.  Otherwise, they have to be filled in at
39
   runtime.  */
40
#if HAVE_DESIGNATED_INITIALIZERS
41
 
42
#define init_trigraph_map()  /* Nothing.  */
43
#define TRIGRAPH_MAP \
44
__extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
45
 
46
#define END };
47
#define s(p, v) [p] = v,
48
 
49
#else
50
 
51
#define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
52
 static void init_trigraph_map (void) { \
53
 unsigned char *x = _cpp_trigraph_map;
54
 
55
#define END }
56
#define s(p, v) x[p] = v;
57
 
58
#endif
59
 
60
TRIGRAPH_MAP
61
  s('=', '#')   s(')', ']')     s('!', '|')
62
  s('(', '[')   s('\'', '^')    s('>', '}')
63
  s('/', '\\')  s('<', '{')     s('-', '~')
64
END
65
 
66
#undef s
67
#undef END
68
#undef TRIGRAPH_MAP
69
 
70
/* A set of booleans indicating what CPP features each source language
71
   requires.  */
72
struct lang_flags
73
{
74
  char c99;
75
  char cplusplus;
76
  char extended_numbers;
77
  char extended_identifiers;
78
  char std;
79
  char cplusplus_comments;
80
  char digraphs;
81
  char uliterals;
82
  char rliterals;
83
  char user_literals;
84
};
85
 
86
static const struct lang_flags lang_defaults[] =
87
{ /*              c99 c++ xnum xid std  //   digr ulit rlit user_literals */
88
  /* GNUC89   */  { 0,  0,  1,   0,  0,   1,   1,   0,   0,    0 },
89
  /* GNUC99   */  { 1,  0,  1,   0,  0,   1,   1,   1,   1,    0 },
90
  /* GNUC11   */  { 1,  0,  1,   0,  0,   1,   1,   1,   1,    0 },
91
  /* STDC89   */  { 0,  0,  0,   0,  1,   0,   0,   0,   0,    0 },
92
  /* STDC94   */  { 0,  0,  0,   0,  1,   0,   1,   0,   0,    0 },
93
  /* STDC99   */  { 1,  0,  1,   0,  1,   1,   1,   0,   0,    0 },
94
  /* STDC11   */  { 1,  0,  1,   0,  1,   1,   1,   1,   0,    0 },
95
  /* GNUCXX   */  { 0,  1,  1,   0,  0,   1,   1,   0,   0,    0 },
96
  /* CXX98    */  { 0,  1,  1,   0,  1,   1,   1,   0,   0,    0 },
97
  /* GNUCXX11 */  { 1,  1,  1,   0,  0,   1,   1,   1,   1,    1 },
98
  /* CXX11    */  { 1,  1,  1,   0,  1,   1,   1,   1,   1,    1 },
99
  /* ASM      */  { 0,  0,  1,   0,  0,   1,   0,   0,   0,    0 }
100
  /* xid should be 1 for GNUC99, STDC99, GNUCXX, CXX98, GNUCXX11, and
101
     CXX11 when no longer experimental (when all uses of identifiers
102
     in the compiler have been audited for correct handling of
103
     extended identifiers).  */
104
};
105
 
106
/* Sets internal flags correctly for a given language.  */
107
void
108
cpp_set_lang (cpp_reader *pfile, enum c_lang lang)
109
{
110
  const struct lang_flags *l = &lang_defaults[(int) lang];
111
 
112
  CPP_OPTION (pfile, lang) = lang;
113
 
114
  CPP_OPTION (pfile, c99)                        = l->c99;
115
  CPP_OPTION (pfile, cplusplus)                  = l->cplusplus;
116
  CPP_OPTION (pfile, extended_numbers)           = l->extended_numbers;
117
  CPP_OPTION (pfile, extended_identifiers)       = l->extended_identifiers;
118
  CPP_OPTION (pfile, std)                        = l->std;
119
  CPP_OPTION (pfile, trigraphs)                  = l->std;
120
  CPP_OPTION (pfile, cplusplus_comments)         = l->cplusplus_comments;
121
  CPP_OPTION (pfile, digraphs)                   = l->digraphs;
122
  CPP_OPTION (pfile, uliterals)                  = l->uliterals;
123
  CPP_OPTION (pfile, rliterals)                  = l->rliterals;
124
  CPP_OPTION (pfile, user_literals)              = l->user_literals;
125
}
126
 
127
/* Initialize library global state.  */
128
static void
129
init_library (void)
130
{
131
  static int initialized = 0;
132
 
133
  if (! initialized)
134
    {
135
      initialized = 1;
136
 
137
      _cpp_init_lexer ();
138
 
139
      /* Set up the trigraph map.  This doesn't need to do anything if
140
         we were compiled with a compiler that supports C99 designated
141
         initializers.  */
142
      init_trigraph_map ();
143
 
144
#ifdef ENABLE_NLS
145
       (void) bindtextdomain (PACKAGE, LOCALEDIR);
146
#endif
147
    }
148
}
149
 
150
/* Initialize a cpp_reader structure.  */
151
cpp_reader *
152
cpp_create_reader (enum c_lang lang, hash_table *table,
153
                   struct line_maps *line_table)
154
{
155
  cpp_reader *pfile;
156
 
157
  /* Initialize this instance of the library if it hasn't been already.  */
158
  init_library ();
159
 
160
  pfile = XCNEW (cpp_reader);
161
  memset (&pfile->base_context, 0, sizeof (pfile->base_context));
162
 
163
  cpp_set_lang (pfile, lang);
164
  CPP_OPTION (pfile, warn_multichar) = 1;
165
  CPP_OPTION (pfile, discard_comments) = 1;
166
  CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
167
  CPP_OPTION (pfile, tabstop) = 8;
168
  CPP_OPTION (pfile, operator_names) = 1;
169
  CPP_OPTION (pfile, warn_trigraphs) = 2;
170
  CPP_OPTION (pfile, warn_endif_labels) = 1;
171
  CPP_OPTION (pfile, cpp_warn_deprecated) = 1;
172
  CPP_OPTION (pfile, cpp_warn_long_long) = 0;
173
  CPP_OPTION (pfile, dollars_in_ident) = 1;
174
  CPP_OPTION (pfile, warn_dollars) = 1;
175
  CPP_OPTION (pfile, warn_variadic_macros) = 1;
176
  CPP_OPTION (pfile, warn_builtin_macro_redefined) = 1;
177
  CPP_OPTION (pfile, warn_normalize) = normalized_C;
178
 
179
  /* Default CPP arithmetic to something sensible for the host for the
180
     benefit of dumb users like fix-header.  */
181
  CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
182
  CPP_OPTION (pfile, char_precision) = CHAR_BIT;
183
  CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
184
  CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
185
  CPP_OPTION (pfile, unsigned_char) = 0;
186
  CPP_OPTION (pfile, unsigned_wchar) = 1;
187
  CPP_OPTION (pfile, bytes_big_endian) = 1;  /* does not matter */
188
 
189
  /* Default to no charset conversion.  */
190
  CPP_OPTION (pfile, narrow_charset) = _cpp_default_encoding ();
191
  CPP_OPTION (pfile, wide_charset) = 0;
192
 
193
  /* Default the input character set to UTF-8.  */
194
  CPP_OPTION (pfile, input_charset) = _cpp_default_encoding ();
195
 
196
  /* A fake empty "directory" used as the starting point for files
197
     looked up without a search path.  Name cannot be '/' because we
198
     don't want to prepend anything at all to filenames using it.  All
199
     other entries are correct zero-initialized.  */
200
  pfile->no_search_path.name = (char *) "";
201
 
202
  /* Initialize the line map.  */
203
  pfile->line_table = line_table;
204
 
205
  /* Initialize lexer state.  */
206
  pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
207
 
208
  /* Set up static tokens.  */
209
  pfile->avoid_paste.type = CPP_PADDING;
210
  pfile->avoid_paste.val.source = NULL;
211
  pfile->eof.type = CPP_EOF;
212
  pfile->eof.flags = 0;
213
 
214
  /* Create a token buffer for the lexer.  */
215
  _cpp_init_tokenrun (&pfile->base_run, 250);
216
  pfile->cur_run = &pfile->base_run;
217
  pfile->cur_token = pfile->base_run.base;
218
 
219
  /* Initialize the base context.  */
220
  pfile->context = &pfile->base_context;
221
  pfile->base_context.c.macro = 0;
222
  pfile->base_context.prev = pfile->base_context.next = 0;
223
 
224
  /* Aligned and unaligned storage.  */
225
  pfile->a_buff = _cpp_get_buff (pfile, 0);
226
  pfile->u_buff = _cpp_get_buff (pfile, 0);
227
 
228
  /* Initialize table for push_macro/pop_macro.  */
229
  pfile->pushed_macros = 0;
230
 
231
  /* Do not force token locations by default.  */
232
  pfile->forced_token_location_p = NULL;
233
 
234
  /* The expression parser stack.  */
235
  _cpp_expand_op_stack (pfile);
236
 
237
  /* Initialize the buffer obstack.  */
238
  _obstack_begin (&pfile->buffer_ob, 0, 0,
239
                  (void *(*) (long)) xmalloc,
240
                  (void (*) (void *)) free);
241
 
242
  _cpp_init_files (pfile);
243
 
244
  _cpp_init_hashtable (pfile, table);
245
 
246
  return pfile;
247
}
248
 
249
/* Set the line_table entry in PFILE.  This is called after reading a
250
   PCH file, as the old line_table will be incorrect.  */
251
void
252
cpp_set_line_map (cpp_reader *pfile, struct line_maps *line_table)
253
{
254
  pfile->line_table = line_table;
255
}
256
 
257
/* Free resources used by PFILE.  Accessing PFILE after this function
258
   returns leads to undefined behavior.  Returns the error count.  */
259
void
260
cpp_destroy (cpp_reader *pfile)
261
{
262
  cpp_context *context, *contextn;
263
  struct def_pragma_macro *pmacro;
264
  tokenrun *run, *runn;
265
  int i;
266
 
267
  free (pfile->op_stack);
268
 
269
  while (CPP_BUFFER (pfile) != NULL)
270
    _cpp_pop_buffer (pfile);
271
 
272
  free (pfile->out.base);
273
 
274
  if (pfile->macro_buffer)
275
    {
276
      free (pfile->macro_buffer);
277
      pfile->macro_buffer = NULL;
278
      pfile->macro_buffer_len = 0;
279
    }
280
 
281
  if (pfile->deps)
282
    deps_free (pfile->deps);
283
  obstack_free (&pfile->buffer_ob, 0);
284
 
285
  _cpp_destroy_hashtable (pfile);
286
  _cpp_cleanup_files (pfile);
287
  _cpp_destroy_iconv (pfile);
288
 
289
  _cpp_free_buff (pfile->a_buff);
290
  _cpp_free_buff (pfile->u_buff);
291
  _cpp_free_buff (pfile->free_buffs);
292
 
293
  for (run = &pfile->base_run; run; run = runn)
294
    {
295
      runn = run->next;
296
      free (run->base);
297
      if (run != &pfile->base_run)
298
        free (run);
299
    }
300
 
301
  for (context = pfile->base_context.next; context; context = contextn)
302
    {
303
      contextn = context->next;
304
      free (context);
305
    }
306
 
307
  if (pfile->comments.entries)
308
    {
309
      for (i = 0; i < pfile->comments.count; i++)
310
        free (pfile->comments.entries[i].comment);
311
 
312
      free (pfile->comments.entries);
313
    }
314
  if (pfile->pushed_macros)
315
    {
316
      do
317
        {
318
          pmacro = pfile->pushed_macros;
319
          pfile->pushed_macros = pmacro->next;
320
          free (pmacro->name);
321
          free (pmacro);
322
        }
323
      while (pfile->pushed_macros);
324
    }
325
 
326
  free (pfile);
327
}
328
 
329
/* This structure defines one built-in identifier.  A node will be
330
   entered in the hash table under the name NAME, with value VALUE.
331
 
332
   There are two tables of these.  builtin_array holds all the
333
   "builtin" macros: these are handled by builtin_macro() in
334
   macro.c.  Builtin is somewhat of a misnomer -- the property of
335
   interest is that these macros require special code to compute their
336
   expansions.  The value is a "cpp_builtin_type" enumerator.
337
 
338
   operator_array holds the C++ named operators.  These are keywords
339
   which act as aliases for punctuators.  In C++, they cannot be
340
   altered through #define, and #if recognizes them as operators.  In
341
   C, these are not entered into the hash table at all (but see
342
   <iso646.h>).  The value is a token-type enumerator.  */
343
struct builtin_macro
344
{
345
  const uchar *const name;
346
  const unsigned short len;
347
  const unsigned short value;
348
  const bool always_warn_if_redefined;
349
};
350
 
351
#define B(n, t, f)    { DSC(n), t, f }
352
static const struct builtin_macro builtin_array[] =
353
{
354
  B("__TIMESTAMP__",     BT_TIMESTAMP,     false),
355
  B("__TIME__",          BT_TIME,          false),
356
  B("__DATE__",          BT_DATE,          false),
357
  B("__FILE__",          BT_FILE,          false),
358
  B("__BASE_FILE__",     BT_BASE_FILE,     false),
359
  B("__LINE__",          BT_SPECLINE,      true),
360
  B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL, true),
361
  B("__COUNTER__",       BT_COUNTER,       true),
362
  /* Keep builtins not used for -traditional-cpp at the end, and
363
     update init_builtins() if any more are added.  */
364
  B("_Pragma",           BT_PRAGMA,        true),
365
  B("__STDC__",          BT_STDC,          true),
366
};
367
#undef B
368
 
369
struct builtin_operator
370
{
371
  const uchar *const name;
372
  const unsigned short len;
373
  const unsigned short value;
374
};
375
 
376
#define B(n, t)    { DSC(n), t }
377
static const struct builtin_operator operator_array[] =
378
{
379
  B("and",      CPP_AND_AND),
380
  B("and_eq",   CPP_AND_EQ),
381
  B("bitand",   CPP_AND),
382
  B("bitor",    CPP_OR),
383
  B("compl",    CPP_COMPL),
384
  B("not",      CPP_NOT),
385
  B("not_eq",   CPP_NOT_EQ),
386
  B("or",       CPP_OR_OR),
387
  B("or_eq",    CPP_OR_EQ),
388
  B("xor",      CPP_XOR),
389
  B("xor_eq",   CPP_XOR_EQ)
390
};
391
#undef B
392
 
393
/* Mark the C++ named operators in the hash table.  */
394
static void
395
mark_named_operators (cpp_reader *pfile, int flags)
396
{
397
  const struct builtin_operator *b;
398
 
399
  for (b = operator_array;
400
       b < (operator_array + ARRAY_SIZE (operator_array));
401
       b++)
402
    {
403
      cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
404
      hp->flags |= flags;
405
      hp->is_directive = 0;
406
      hp->directive_index = b->value;
407
    }
408
}
409
 
410
/* Helper function of cpp_type2name. Return the string associated with
411
   named operator TYPE.  */
412
const char *
413
cpp_named_operator2name (enum cpp_ttype type)
414
{
415
  const struct builtin_operator *b;
416
 
417
  for (b = operator_array;
418
       b < (operator_array + ARRAY_SIZE (operator_array));
419
       b++)
420
    {
421
      if (type == b->value)
422
        return (const char *) b->name;
423
    }
424
 
425
  return NULL;
426
}
427
 
428
void
429
cpp_init_special_builtins (cpp_reader *pfile)
430
{
431
  const struct builtin_macro *b;
432
  size_t n = ARRAY_SIZE (builtin_array);
433
 
434
  if (CPP_OPTION (pfile, traditional))
435
    n -= 2;
436
  else if (! CPP_OPTION (pfile, stdc_0_in_system_headers)
437
           || CPP_OPTION (pfile, std))
438
    n--;
439
 
440
  for (b = builtin_array; b < builtin_array + n; b++)
441
    {
442
      cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
443
      hp->type = NT_MACRO;
444
      hp->flags |= NODE_BUILTIN;
445
      if (b->always_warn_if_redefined
446
          || CPP_OPTION (pfile, warn_builtin_macro_redefined))
447
        hp->flags |= NODE_WARN;
448
      hp->value.builtin = (enum cpp_builtin_type) b->value;
449
    }
450
}
451
 
452
/* Read the builtins table above and enter them, and language-specific
453
   macros, into the hash table.  HOSTED is true if this is a hosted
454
   environment.  */
455
void
456
cpp_init_builtins (cpp_reader *pfile, int hosted)
457
{
458
  cpp_init_special_builtins (pfile);
459
 
460
  if (!CPP_OPTION (pfile, traditional)
461
      && (! CPP_OPTION (pfile, stdc_0_in_system_headers)
462
          || CPP_OPTION (pfile, std)))
463
    _cpp_define_builtin (pfile, "__STDC__ 1");
464
 
465
  if (CPP_OPTION (pfile, cplusplus))
466
    {
467
      if (CPP_OPTION (pfile, lang) == CLK_CXX11
468
           || CPP_OPTION (pfile, lang) == CLK_GNUCXX11)
469
        _cpp_define_builtin (pfile, "__cplusplus 201103L");
470
      else
471
        _cpp_define_builtin (pfile, "__cplusplus 199711L");
472
    }
473
  else if (CPP_OPTION (pfile, lang) == CLK_ASM)
474
    _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
475
  else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
476
    _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
477
  else if (CPP_OPTION (pfile, lang) == CLK_STDC11
478
           || CPP_OPTION (pfile, lang) == CLK_GNUC11)
479
    _cpp_define_builtin (pfile, "__STDC_VERSION__ 201112L");
480
  else if (CPP_OPTION (pfile, c99))
481
    _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
482
 
483
  if (CPP_OPTION (pfile, uliterals)
484
      && !CPP_OPTION (pfile, cplusplus))
485
    {
486
      _cpp_define_builtin (pfile, "__STDC_UTF_16__ 1");
487
      _cpp_define_builtin (pfile, "__STDC_UTF_32__ 1");
488
    }
489
 
490
  if (hosted)
491
    _cpp_define_builtin (pfile, "__STDC_HOSTED__ 1");
492
  else
493
    _cpp_define_builtin (pfile, "__STDC_HOSTED__ 0");
494
 
495
  if (CPP_OPTION (pfile, objc))
496
    _cpp_define_builtin (pfile, "__OBJC__ 1");
497
}
498
 
499
/* Sanity-checks are dependent on command-line options, so it is
500
   called as a subroutine of cpp_read_main_file ().  */
501
#if ENABLE_CHECKING
502
static void sanity_checks (cpp_reader *);
503
static void sanity_checks (cpp_reader *pfile)
504
{
505
  cppchar_t test = 0;
506
  size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
507
 
508
  /* Sanity checks for assumptions about CPP arithmetic and target
509
     type precisions made by cpplib.  */
510
  test--;
511
  if (test < 1)
512
    cpp_error (pfile, CPP_DL_ICE, "cppchar_t must be an unsigned type");
513
 
514
  if (CPP_OPTION (pfile, precision) > max_precision)
515
    cpp_error (pfile, CPP_DL_ICE,
516
               "preprocessor arithmetic has maximum precision of %lu bits;"
517
               " target requires %lu bits",
518
               (unsigned long) max_precision,
519
               (unsigned long) CPP_OPTION (pfile, precision));
520
 
521
  if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
522
    cpp_error (pfile, CPP_DL_ICE,
523
               "CPP arithmetic must be at least as precise as a target int");
524
 
525
  if (CPP_OPTION (pfile, char_precision) < 8)
526
    cpp_error (pfile, CPP_DL_ICE, "target char is less than 8 bits wide");
527
 
528
  if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
529
    cpp_error (pfile, CPP_DL_ICE,
530
               "target wchar_t is narrower than target char");
531
 
532
  if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
533
    cpp_error (pfile, CPP_DL_ICE,
534
               "target int is narrower than target char");
535
 
536
  /* This is assumed in eval_token() and could be fixed if necessary.  */
537
  if (sizeof (cppchar_t) > sizeof (cpp_num_part))
538
    cpp_error (pfile, CPP_DL_ICE,
539
               "CPP half-integer narrower than CPP character");
540
 
541
  if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
542
    cpp_error (pfile, CPP_DL_ICE,
543
               "CPP on this host cannot handle wide character constants over"
544
               " %lu bits, but the target requires %lu bits",
545
               (unsigned long) BITS_PER_CPPCHAR_T,
546
               (unsigned long) CPP_OPTION (pfile, wchar_precision));
547
}
548
#else
549
# define sanity_checks(PFILE)
550
#endif
551
 
552
/* This is called after options have been parsed, and partially
553
   processed.  */
554
void
555
cpp_post_options (cpp_reader *pfile)
556
{
557
  int flags;
558
 
559
  sanity_checks (pfile);
560
 
561
  post_options (pfile);
562
 
563
  /* Mark named operators before handling command line macros.  */
564
  flags = 0;
565
  if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
566
    flags |= NODE_OPERATOR;
567
  if (CPP_OPTION (pfile, warn_cxx_operator_names))
568
    flags |= NODE_DIAGNOSTIC | NODE_WARN_OPERATOR;
569
  if (flags != 0)
570
    mark_named_operators (pfile, flags);
571
}
572
 
573
/* Setup for processing input from the file named FNAME, or stdin if
574
   it is the empty string.  Return the original filename
575
   on success (e.g. foo.i->foo.c), or NULL on failure.  */
576
const char *
577
cpp_read_main_file (cpp_reader *pfile, const char *fname)
578
{
579
  if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
580
    {
581
      if (!pfile->deps)
582
        pfile->deps = deps_init ();
583
 
584
      /* Set the default target (if there is none already).  */
585
      deps_add_default_target (pfile->deps, fname);
586
    }
587
 
588
  pfile->main_file
589
    = _cpp_find_file (pfile, fname, &pfile->no_search_path, false, 0);
590
  if (_cpp_find_failed (pfile->main_file))
591
    return NULL;
592
 
593
  _cpp_stack_file (pfile, pfile->main_file, false);
594
 
595
  /* For foo.i, read the original filename foo.c now, for the benefit
596
     of the front ends.  */
597
  if (CPP_OPTION (pfile, preprocessed))
598
    {
599
      read_original_filename (pfile);
600
      fname =
601
        ORDINARY_MAP_FILE_NAME
602
        ((LINEMAPS_LAST_ORDINARY_MAP (pfile->line_table)));
603
    }
604
  return fname;
605
}
606
 
607
/* For preprocessed files, if the first tokens are of the form # NUM.
608
   handle the directive so we know the original file name.  This will
609
   generate file_change callbacks, which the front ends must handle
610
   appropriately given their state of initialization.  */
611
static void
612
read_original_filename (cpp_reader *pfile)
613
{
614
  const cpp_token *token, *token1;
615
 
616
  /* Lex ahead; if the first tokens are of the form # NUM, then
617
     process the directive, otherwise back up.  */
618
  token = _cpp_lex_direct (pfile);
619
  if (token->type == CPP_HASH)
620
    {
621
      pfile->state.in_directive = 1;
622
      token1 = _cpp_lex_direct (pfile);
623
      _cpp_backup_tokens (pfile, 1);
624
      pfile->state.in_directive = 0;
625
 
626
      /* If it's a #line directive, handle it.  */
627
      if (token1->type == CPP_NUMBER
628
          && _cpp_handle_directive (pfile, token->flags & PREV_WHITE))
629
        {
630
          read_original_directory (pfile);
631
          return;
632
        }
633
    }
634
 
635
  /* Backup as if nothing happened.  */
636
  _cpp_backup_tokens (pfile, 1);
637
}
638
 
639
/* For preprocessed files, if the tokens following the first filename
640
   line is of the form # <line> "/path/name//", handle the
641
   directive so we know the original current directory.  */
642
static void
643
read_original_directory (cpp_reader *pfile)
644
{
645
  const cpp_token *hash, *token;
646
 
647
  /* Lex ahead; if the first tokens are of the form # NUM, then
648
     process the directive, otherwise back up.  */
649
  hash = _cpp_lex_direct (pfile);
650
  if (hash->type != CPP_HASH)
651
    {
652
      _cpp_backup_tokens (pfile, 1);
653
      return;
654
    }
655
 
656
  token = _cpp_lex_direct (pfile);
657
 
658
  if (token->type != CPP_NUMBER)
659
    {
660
      _cpp_backup_tokens (pfile, 2);
661
      return;
662
    }
663
 
664
  token = _cpp_lex_direct (pfile);
665
 
666
  if (token->type != CPP_STRING
667
      || ! (token->val.str.len >= 5
668
            && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-2])
669
            && IS_DIR_SEPARATOR (token->val.str.text[token->val.str.len-3])))
670
    {
671
      _cpp_backup_tokens (pfile, 3);
672
      return;
673
    }
674
 
675
  if (pfile->cb.dir_change)
676
    {
677
      char *debugdir = (char *) alloca (token->val.str.len - 3);
678
 
679
      memcpy (debugdir, (const char *) token->val.str.text + 1,
680
              token->val.str.len - 4);
681
      debugdir[token->val.str.len - 4] = '\0';
682
 
683
      pfile->cb.dir_change (pfile, debugdir);
684
    }
685
}
686
 
687
/* This is called at the end of preprocessing.  It pops the last
688
   buffer and writes dependency output.
689
 
690
   Maybe it should also reset state, such that you could call
691
   cpp_start_read with a new filename to restart processing.  */
692
void
693
cpp_finish (cpp_reader *pfile, FILE *deps_stream)
694
{
695
  /* Warn about unused macros before popping the final buffer.  */
696
  if (CPP_OPTION (pfile, warn_unused_macros))
697
    cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
698
 
699
  /* lex.c leaves the final buffer on the stack.  This it so that
700
     it returns an unending stream of CPP_EOFs to the client.  If we
701
     popped the buffer, we'd dereference a NULL buffer pointer and
702
     segfault.  It's nice to allow the client to do worry-free excess
703
     cpp_get_token calls.  */
704
  while (pfile->buffer)
705
    _cpp_pop_buffer (pfile);
706
 
707
  if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
708
      && deps_stream)
709
    {
710
      deps_write (pfile->deps, deps_stream, 72);
711
 
712
      if (CPP_OPTION (pfile, deps.phony_targets))
713
        deps_phony_targets (pfile->deps, deps_stream);
714
    }
715
 
716
  /* Report on headers that could use multiple include guards.  */
717
  if (CPP_OPTION (pfile, print_include_names))
718
    _cpp_report_missing_guards (pfile);
719
}
720
 
721
static void
722
post_options (cpp_reader *pfile)
723
{
724
  /* -Wtraditional is not useful in C++ mode.  */
725
  if (CPP_OPTION (pfile, cplusplus))
726
    CPP_OPTION (pfile, cpp_warn_traditional) = 0;
727
 
728
  /* Permanently disable macro expansion if we are rescanning
729
     preprocessed text.  Read preprocesed source in ISO mode.  */
730
  if (CPP_OPTION (pfile, preprocessed))
731
    {
732
      if (!CPP_OPTION (pfile, directives_only))
733
        pfile->state.prevent_expansion = 1;
734
      CPP_OPTION (pfile, traditional) = 0;
735
    }
736
 
737
  if (CPP_OPTION (pfile, warn_trigraphs) == 2)
738
    CPP_OPTION (pfile, warn_trigraphs) = !CPP_OPTION (pfile, trigraphs);
739
 
740
  if (CPP_OPTION (pfile, traditional))
741
    {
742
      CPP_OPTION (pfile, cplusplus_comments) = 0;
743
 
744
      CPP_OPTION (pfile, trigraphs) = 0;
745
      CPP_OPTION (pfile, warn_trigraphs) = 0;
746
    }
747
}

powered by: WebSVN 2.1.0

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