gcc/cppinit.c

   1 /* CPP Library.
   2    Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   4    Contributed by Per Bothner, 1994-95.
   5    Based on CCCP program by Paul Rubin, June 1986
   6    Adapted to ANSI C, Richard Stallman, Jan 1987
   7
   8 This program is free software; you can redistribute it and/or modify it
   9 under the terms of the GNU General Public License as published by the
  10 Free Software Foundation; either version 2, or (at your option) any
  11 later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "cpplib.h"
  27 #include "cpphash.h"
  28 #include "mkdeps.h"
  29
  30 static void init_library                PARAMS ((void));
  31 static void mark_named_operators        PARAMS ((cpp_reader *));
  32 static void read_original_filename      PARAMS ((cpp_reader *));
  33 static void post_options                PARAMS ((cpp_reader *));
  34
  35 /* If we have designated initializers (GCC >2.7) these tables can be
  36    initialized, constant data.  Otherwise, they have to be filled in at
  37    runtime.  */
  38 #if HAVE_DESIGNATED_INITIALIZERS
  39
  40 #define init_trigraph_map()  /* Nothing.  */
  41 #define TRIGRAPH_MAP \
  42 __extension__ const uchar _cpp_trigraph_map[UCHAR_MAX + 1] = {
  43
  44 #define END };
  45 #define s(p, v) [p] = v,
  46
  47 #else
  48
  49 #define TRIGRAPH_MAP uchar _cpp_trigraph_map[UCHAR_MAX + 1] = { 0 }; \
  50  static void init_trigraph_map PARAMS ((void)) { \
  51  unsigned char *x = _cpp_trigraph_map;
  52
  53 #define END }
  54 #define s(p, v) x[p] = v;
  55
  56 #endif
  57
  58 TRIGRAPH_MAP
  59   s('=', '#')   s(')', ']')     s('!', '|')
  60   s('(', '[')   s('\'', '^')    s('>', '}')
  61   s('/', '\\')  s('<', '{')     s('-', '~')
  62 END
  63
  64 #undef s
  65 #undef END
  66 #undef TRIGRAPH_MAP
  67
  68 /* A set of booleans indicating what CPP features each source language
  69    requires.  */
  70 struct lang_flags
  71 {
  72   char c99;
  73   char cplusplus;
  74   char extended_numbers;
  75   char std;
  76   char dollars_in_ident;
  77   char cplusplus_comments;
  78   char digraphs;
  79 };
  80
  81 /* ??? Enable $ in identifiers in assembly? */
  82 static const struct lang_flags lang_defaults[] =
  83 { /*              c99 c++ xnum std dollar c++comm digr  */
  84   /* GNUC89 */  { 0,  0,  1,   0,   1,     1,      1     },
  85   /* GNUC99 */  { 1,  0,  1,   0,   1,     1,      1     },
  86   /* STDC89 */  { 0,  0,  0,   1,   0,     0,      0     },
  87   /* STDC94 */  { 0,  0,  0,   1,   0,     0,      1     },
  88   /* STDC99 */  { 1,  0,  1,   1,   0,     1,      1     },
  89   /* GNUCXX */  { 0,  1,  1,   0,   1,     1,      1     },
  90   /* CXX98  */  { 0,  1,  1,   1,   0,     1,      1     },
  91   /* ASM    */  { 0,  0,  1,   0,   0,     1,      0     }
  92 };
  93
  94 /* Sets internal flags correctly for a given language.  */
  95 void
  96 cpp_set_lang (pfile, lang)
  97      cpp_reader *pfile;
  98      enum c_lang lang;
  99 {
 100   const struct lang_flags *l = &lang_defaults[(int) lang];
 101
 102   CPP_OPTION (pfile, lang) = lang;
 103
 104   CPP_OPTION (pfile, c99)                = l->c99;
 105   CPP_OPTION (pfile, cplusplus)          = l->cplusplus;
 106   CPP_OPTION (pfile, extended_numbers)   = l->extended_numbers;
 107   CPP_OPTION (pfile, std)                = l->std;
 108   CPP_OPTION (pfile, trigraphs)          = l->std;
 109   CPP_OPTION (pfile, dollars_in_ident)   = l->dollars_in_ident;
 110   CPP_OPTION (pfile, cplusplus_comments) = l->cplusplus_comments;
 111   CPP_OPTION (pfile, digraphs)           = l->digraphs;
 112 }
 113
 114 /* Initialize library global state.  */
 115 static void
 116 init_library ()
 117 {
 118   static int initialized = 0;
 119
 120   if (! initialized)
 121     {
 122       initialized = 1;
 123
 124       /* Set up the trigraph map.  This doesn't need to do anything if
 125          we were compiled with a compiler that supports C99 designated
 126          initializers.  */
 127       init_trigraph_map ();
 128
 129       _cpp_init_mbchar ();
 130     }
 131 }
 132
 133 /* Initialize a cpp_reader structure.  */
 134 cpp_reader *
 135 cpp_create_reader (lang, table)
 136      enum c_lang lang;
 137      hash_table *table;
 138 {
 139   cpp_reader *pfile;
 140
 141   /* Initialize this instance of the library if it hasn't been already.  */
 142   init_library ();
 143
 144   pfile = (cpp_reader *) xcalloc (1, sizeof (cpp_reader));
 145
 146   cpp_set_lang (pfile, lang);
 147   CPP_OPTION (pfile, warn_import) = 1;
 148   CPP_OPTION (pfile, warn_multichar) = 1;
 149   CPP_OPTION (pfile, discard_comments) = 1;
 150   CPP_OPTION (pfile, discard_comments_in_macro_exp) = 1;
 151   CPP_OPTION (pfile, show_column) = 1;
 152   CPP_OPTION (pfile, tabstop) = 8;
 153   CPP_OPTION (pfile, operator_names) = 1;
 154   CPP_OPTION (pfile, warn_endif_labels) = 1;
 155   CPP_OPTION (pfile, warn_deprecated) = 1;
 156   CPP_OPTION (pfile, warn_long_long) = !CPP_OPTION (pfile, c99);
 157
 158   /* Default CPP arithmetic to something sensible for the host for the
 159      benefit of dumb users like fix-header.  */
 160   CPP_OPTION (pfile, precision) = CHAR_BIT * sizeof (long);
 161   CPP_OPTION (pfile, char_precision) = CHAR_BIT;
 162   CPP_OPTION (pfile, wchar_precision) = CHAR_BIT * sizeof (int);
 163   CPP_OPTION (pfile, int_precision) = CHAR_BIT * sizeof (int);
 164   CPP_OPTION (pfile, unsigned_char) = 0;
 165   CPP_OPTION (pfile, unsigned_wchar) = 1;
 166
 167   /* Initialize the line map.  Start at logical line 1, so we can use
 168      a line number of zero for special states.  */
 169   init_line_maps (&pfile->line_maps);
 170   pfile->line = 1;
 171
 172   /* Initialize lexer state.  */
 173   pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
 174
 175   /* Set up static tokens.  */
 176   pfile->avoid_paste.type = CPP_PADDING;
 177   pfile->avoid_paste.val.source = NULL;
 178   pfile->eof.type = CPP_EOF;
 179   pfile->eof.flags = 0;
 180
 181   /* Create a token buffer for the lexer.  */
 182   _cpp_init_tokenrun (&pfile->base_run, 250);
 183   pfile->cur_run = &pfile->base_run;
 184   pfile->cur_token = pfile->base_run.base;
 185
 186   /* Initialize the base context.  */
 187   pfile->context = &pfile->base_context;
 188   pfile->base_context.macro = 0;
 189   pfile->base_context.prev = pfile->base_context.next = 0;
 190
 191   /* Aligned and unaligned storage.  */
 192   pfile->a_buff = _cpp_get_buff (pfile, 0);
 193   pfile->u_buff = _cpp_get_buff (pfile, 0);
 194
 195   /* The expression parser stack.  */
 196   _cpp_expand_op_stack (pfile);
 197
 198   /* Initialize the buffer obstack.  */
 199   gcc_obstack_init (&pfile->buffer_ob);
 200
 201   _cpp_init_includes (pfile);
 202
 203   _cpp_init_hashtable (pfile, table);
 204
 205   return pfile;
 206 }
 207
 208 /* Free resources used by PFILE.  Accessing PFILE after this function
 209    returns leads to undefined behavior.  Returns the error count.  */
 210 void
 211 cpp_destroy (pfile)
 212      cpp_reader *pfile;
 213 {
 214   cpp_context *context, *contextn;
 215   tokenrun *run, *runn;
 216
 217   free (pfile->op_stack);
 218
 219   while (CPP_BUFFER (pfile) != NULL)
 220     _cpp_pop_buffer (pfile);
 221
 222   if (pfile->out.base)
 223     free (pfile->out.base);
 224
 225   if (pfile->macro_buffer)
 226     {
 227       free ((PTR) pfile->macro_buffer);
 228       pfile->macro_buffer = NULL;
 229       pfile->macro_buffer_len = 0;
 230     }
 231
 232   if (pfile->deps)
 233     deps_free (pfile->deps);
 234   obstack_free (&pfile->buffer_ob, 0);
 235
 236   _cpp_destroy_hashtable (pfile);
 237   _cpp_cleanup_includes (pfile);
 238
 239   _cpp_free_buff (pfile->a_buff);
 240   _cpp_free_buff (pfile->u_buff);
 241   _cpp_free_buff (pfile->free_buffs);
 242
 243   for (run = &pfile->base_run; run; run = runn)
 244     {
 245       runn = run->next;
 246       free (run->base);
 247       if (run != &pfile->base_run)
 248         free (run);
 249     }
 250
 251   for (context = pfile->base_context.next; context; context = contextn)
 252     {
 253       contextn = context->next;
 254       free (context);
 255     }
 256
 257   free_line_maps (&pfile->line_maps);
 258   free (pfile);
 259 }
 260
 261 /* This structure defines one built-in identifier.  A node will be
 262    entered in the hash table under the name NAME, with value VALUE.
 263
 264    There are two tables of these.  builtin_array holds all the
 265    "builtin" macros: these are handled by builtin_macro() in
 266    cppmacro.c.  Builtin is somewhat of a misnomer -- the property of
 267    interest is that these macros require special code to compute their
 268    expansions.  The value is a "builtin_type" enumerator.
 269
 270    operator_array holds the C++ named operators.  These are keywords
 271    which act as aliases for punctuators.  In C++, they cannot be
 272    altered through #define, and #if recognizes them as operators.  In
 273    C, these are not entered into the hash table at all (but see
 274    <iso646.h>).  The value is a token-type enumerator.  */
 275 struct builtin
 276 {
 277   const uchar *name;
 278   unsigned short len;
 279   unsigned short value;
 280 };
 281
 282 #define B(n, t)    { DSC(n), t }
 283 static const struct builtin builtin_array[] =
 284 {
 285   B("__TIME__",          BT_TIME),
 286   B("__DATE__",          BT_DATE),
 287   B("__FILE__",          BT_FILE),
 288   B("__BASE_FILE__",     BT_BASE_FILE),
 289   B("__LINE__",          BT_SPECLINE),
 290   B("__INCLUDE_LEVEL__", BT_INCLUDE_LEVEL),
 291   /* Keep builtins not used for -traditional-cpp at the end, and
 292      update init_builtins() if any more are added.  */
 293   B("_Pragma",           BT_PRAGMA),
 294   B("__STDC__",          BT_STDC),
 295 };
 296
 297 static const struct builtin operator_array[] =
 298 {
 299   B("and",      CPP_AND_AND),
 300   B("and_eq",   CPP_AND_EQ),
 301   B("bitand",   CPP_AND),
 302   B("bitor",    CPP_OR),
 303   B("compl",    CPP_COMPL),
 304   B("not",      CPP_NOT),
 305   B("not_eq",   CPP_NOT_EQ),
 306   B("or",       CPP_OR_OR),
 307   B("or_eq",    CPP_OR_EQ),
 308   B("xor",      CPP_XOR),
 309   B("xor_eq",   CPP_XOR_EQ)
 310 };
 311 #undef B
 312
 313 /* Mark the C++ named operators in the hash table.  */
 314 static void
 315 mark_named_operators (pfile)
 316      cpp_reader *pfile;
 317 {
 318   const struct builtin *b;
 319
 320   for (b = operator_array;
 321        b < (operator_array + ARRAY_SIZE (operator_array));
 322        b++)
 323     {
 324       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 325       hp->flags |= NODE_OPERATOR;
 326       hp->is_directive = 0;
 327       hp->directive_index = b->value;
 328     }
 329 }
 330
 331 /* Read the builtins table above and enter them, and language-specific
 332    macros, into the hash table.  */
 333 void
 334 cpp_init_builtins (pfile)
 335      cpp_reader *pfile;
 336 {
 337   const struct builtin *b;
 338   size_t n = ARRAY_SIZE (builtin_array);
 339
 340   if (CPP_OPTION (pfile, traditional))
 341     n -= 2;
 342
 343   for(b = builtin_array; b < builtin_array + n; b++)
 344     {
 345       cpp_hashnode *hp = cpp_lookup (pfile, b->name, b->len);
 346       hp->type = NT_MACRO;
 347       hp->flags |= NODE_BUILTIN | NODE_WARN;
 348       hp->value.builtin = b->value;
 349     }
 350
 351   if (CPP_OPTION (pfile, cplusplus))
 352     _cpp_define_builtin (pfile, "__cplusplus 1");
 353   else if (CPP_OPTION (pfile, lang) == CLK_ASM)
 354     _cpp_define_builtin (pfile, "__ASSEMBLER__ 1");
 355   else if (CPP_OPTION (pfile, lang) == CLK_STDC94)
 356     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199409L");
 357   else if (CPP_OPTION (pfile, c99))
 358     _cpp_define_builtin (pfile, "__STDC_VERSION__ 199901L");
 359
 360   if (CPP_OPTION (pfile, objc))
 361     _cpp_define_builtin (pfile, "__OBJC__ 1");
 362 }
 363
 364 /* Sanity-checks are dependent on command-line options, so it is
 365    called as a subroutine of cpp_read_main_file ().  */
 366 #if ENABLE_CHECKING
 367 static void sanity_checks PARAMS ((cpp_reader *));
 368 static void sanity_checks (pfile)
 369      cpp_reader *pfile;
 370 {
 371   cppchar_t test = 0;
 372   size_t max_precision = 2 * CHAR_BIT * sizeof (cpp_num_part);
 373
 374   /* Sanity checks for assumptions about CPP arithmetic and target
 375      type precisions made by cpplib.  */
 376   test--;
 377   if (test < 1)
 378     cpp_error (pfile, DL_ICE, "cppchar_t must be an unsigned type");
 379
 380   if (CPP_OPTION (pfile, precision) > max_precision)
 381     cpp_error (pfile, DL_ICE,
 382                "preprocessor arithmetic has maximum precision of %lu bits; target requires %lu bits",
 383                (unsigned long) max_precision,
 384                (unsigned long) CPP_OPTION (pfile, precision));
 385
 386   if (CPP_OPTION (pfile, precision) < CPP_OPTION (pfile, int_precision))
 387     cpp_error (pfile, DL_ICE,
 388                "CPP arithmetic must be at least as precise as a target int");
 389
 390   if (CPP_OPTION (pfile, char_precision) < 8)
 391     cpp_error (pfile, DL_ICE, "target char is less than 8 bits wide");
 392
 393   if (CPP_OPTION (pfile, wchar_precision) < CPP_OPTION (pfile, char_precision))
 394     cpp_error (pfile, DL_ICE,
 395                "target wchar_t is narrower than target char");
 396
 397   if (CPP_OPTION (pfile, int_precision) < CPP_OPTION (pfile, char_precision))
 398     cpp_error (pfile, DL_ICE,
 399                "target int is narrower than target char");
 400
 401   /* This is assumed in eval_token() and could be fixed if necessary.  */
 402   if (sizeof (cppchar_t) > sizeof (cpp_num_part))
 403     cpp_error (pfile, DL_ICE, "CPP half-integer narrower than CPP character");
 404
 405   if (CPP_OPTION (pfile, wchar_precision) > BITS_PER_CPPCHAR_T)
 406     cpp_error (pfile, DL_ICE,
 407                "CPP on this host cannot handle wide character constants over %lu bits, but the target requires %lu bits",
 408                (unsigned long) BITS_PER_CPPCHAR_T,
 409                (unsigned long) CPP_OPTION (pfile, wchar_precision));
 410 }
 411 #else
 412 # define sanity_checks(PFILE)
 413 #endif
 414
 415 /* Add a dependency target.  Can be called any number of times before
 416    cpp_read_main_file().  If no targets have been added before
 417    cpp_read_main_file(), then the default target is used.  */
 418 void
 419 cpp_add_dependency_target (pfile, target, quote)
 420      cpp_reader *pfile;
 421      const char *target;
 422      int quote;
 423 {
 424   if (!pfile->deps)
 425     pfile->deps = deps_init ();
 426
 427   deps_add_target (pfile->deps, target, quote);
 428 }
 429
 430 /* This is called after options have been parsed, and partially
 431    processed.  Setup for processing input from the file named FNAME,
 432    or stdin if it is the empty string.  Return the original filename
 433    on success (e.g. foo.i->foo.c), or NULL on failure.  */
 434 const char *
 435 cpp_read_main_file (pfile, fname)
 436      cpp_reader *pfile;
 437      const char *fname;
 438 {
 439   sanity_checks (pfile);
 440
 441   post_options (pfile);
 442
 443   /* Mark named operators before handling command line macros.  */
 444   if (CPP_OPTION (pfile, cplusplus) && CPP_OPTION (pfile, operator_names))
 445     mark_named_operators (pfile);
 446
 447   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE)
 448     {
 449       if (!pfile->deps)
 450         pfile->deps = deps_init ();
 451
 452       /* Set the default target (if there is none already).  */
 453       deps_add_default_target (pfile->deps, fname);
 454     }
 455
 456   /* Open the main input file.  */
 457   if (!_cpp_read_file (pfile, fname))
 458     return NULL;
 459
 460   /* Set this here so the client can change the option if it wishes,
 461      and after stacking the main file so we don't trace the main
 462      file.  */
 463   pfile->line_maps.trace_includes = CPP_OPTION (pfile, print_include_names);
 464
 465   /* For foo.i, read the original filename foo.c now, for the benefit
 466      of the front ends.  */
 467   if (CPP_OPTION (pfile, preprocessed))
 468     read_original_filename (pfile);
 469
 470   return pfile->map->to_file;
 471 }
 472
 473 /* For preprocessed files, if the first tokens are of the form # NUM.
 474    handle the directive so we know the original file name.  This will
 475    generate file_change callbacks, which the front ends must handle
 476    appropriately given their state of initialization.  */
 477 static void
 478 read_original_filename (pfile)
 479      cpp_reader *pfile;
 480 {
 481   const cpp_token *token, *token1;
 482
 483   /* Lex ahead; if the first tokens are of the form # NUM, then
 484      process the directive, otherwise back up.  */
 485   token = _cpp_lex_direct (pfile);
 486   if (token->type == CPP_HASH)
 487     {
 488       token1 = _cpp_lex_direct (pfile);
 489       _cpp_backup_tokens (pfile, 1);
 490
 491       /* If it's a #line directive, handle it.  */
 492       if (token1->type == CPP_NUMBER)
 493         {
 494           _cpp_handle_directive (pfile, token->flags & PREV_WHITE);
 495           return;
 496         }
 497     }
 498
 499   /* Backup as if nothing happened.  */
 500   _cpp_backup_tokens (pfile, 1);
 501 }
 502
 503 /* This is called at the end of preprocessing.  It pops the last
 504    buffer and writes dependency output, and returns the number of
 505    errors.
 506
 507    Maybe it should also reset state, such that you could call
 508    cpp_start_read with a new filename to restart processing.  */
 509 int
 510 cpp_finish (pfile, deps_stream)
 511      cpp_reader *pfile;
 512      FILE *deps_stream;
 513 {
 514   /* Warn about unused macros before popping the final buffer.  */
 515   if (CPP_OPTION (pfile, warn_unused_macros))
 516     cpp_forall_identifiers (pfile, _cpp_warn_if_unused_macro, NULL);
 517
 518   /* cpplex.c leaves the final buffer on the stack.  This it so that
 519      it returns an unending stream of CPP_EOFs to the client.  If we
 520      popped the buffer, we'd dereference a NULL buffer pointer and
 521      segfault.  It's nice to allow the client to do worry-free excess
 522      cpp_get_token calls.  */
 523   while (pfile->buffer)
 524     _cpp_pop_buffer (pfile);
 525
 526   /* Don't write the deps file if there are errors.  */
 527   if (CPP_OPTION (pfile, deps.style) != DEPS_NONE
 528       && deps_stream && pfile->errors == 0)
 529     {
 530       deps_write (pfile->deps, deps_stream, 72);
 531
 532       if (CPP_OPTION (pfile, deps.phony_targets))
 533         deps_phony_targets (pfile->deps, deps_stream);
 534     }
 535
 536   /* Report on headers that could use multiple include guards.  */
 537   if (CPP_OPTION (pfile, print_include_names))
 538     _cpp_report_missing_guards (pfile);
 539
 540   return pfile->errors;
 541 }
 542
 543 static void
 544 post_options (pfile)
 545      cpp_reader *pfile;
 546 {
 547   /* -Wtraditional is not useful in C++ mode.  */
 548   if (CPP_OPTION (pfile, cplusplus))
 549     CPP_OPTION (pfile, warn_traditional) = 0;
 550
 551   /* Permanently disable macro expansion if we are rescanning
 552      preprocessed text.  Read preprocesed source in ISO mode.  */
 553   if (CPP_OPTION (pfile, preprocessed))
 554     {
 555       pfile->state.prevent_expansion = 1;
 556       CPP_OPTION (pfile, traditional) = 0;
 557     }
 558
 559   /* Traditional CPP does not accurately track column information.  */
 560   if (CPP_OPTION (pfile, traditional))
 561     CPP_OPTION (pfile, show_column) = 0;
 562 }