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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libcpp/] [init.c] - Blame information for rev 304

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

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

powered by: WebSVN 2.1.0

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