gcc-4_8-branch/gcc/fortran/cpp.c

   1 /* Copyright (C) 2008-2013 Free Software Foundation, Inc.
   2
   3 This file is part of GCC.
   4
   5 GCC is free software; you can redistribute it and/or modify it under
   6 the terms of the GNU General Public License as published by the Free
   7 Software Foundation; either version 3, or (at your option) any later
   8 version.
   9
  10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GCC; see the file COPYING3.  If not see
  17 <http://www.gnu.org/licenses/>.  */
  18
  19 #include "config.h"
  20 #include "system.h"
  21 #include "coretypes.h"
  22 #include "tm.h"
  23 #include "tree.h"
  24 #include "version.h"
  25 #include "flags.h"
  26
  27
  28 #include "options.h"
  29 #include "gfortran.h"
  30 #include "tm_p.h"               /* Target prototypes.  */
  31 #include "target.h"
  32 #include "toplev.h"
  33 #include "diagnostic.h"
  34
  35 #include "../../libcpp/internal.h"
  36 #include "cpp.h"
  37 #include "incpath.h"
  38 #include "cppbuiltin.h"
  39 #include "mkdeps.h"
  40
  41 #ifndef TARGET_SYSTEM_ROOT
  42 # define TARGET_SYSTEM_ROOT NULL
  43 #endif
  44
  45 #ifndef TARGET_CPU_CPP_BUILTINS
  46 # define TARGET_CPU_CPP_BUILTINS()
  47 #endif
  48
  49 #ifndef TARGET_OS_CPP_BUILTINS
  50 # define TARGET_OS_CPP_BUILTINS()
  51 #endif
  52
  53 #ifndef TARGET_OBJFMT_CPP_BUILTINS
  54 # define TARGET_OBJFMT_CPP_BUILTINS()
  55 #endif
  56
  57
  58 /* Holds switches parsed by gfc_cpp_handle_option (), but whose
  59    handling is deferred to gfc_cpp_init ().  */
  60 typedef struct
  61 {
  62     enum opt_code code;
  63     const char *arg;
  64 }
  65 gfc_cpp_deferred_opt_t;
  66
  67
  68 /* Defined and undefined macros being queued for output with -dU at
  69    the next newline.  */
  70 typedef struct gfc_cpp_macro_queue
  71 {
  72   struct gfc_cpp_macro_queue *next;     /* Next macro in the list.  */
  73   char *macro;                          /* The name of the macro if not
  74                                            defined, the full definition if
  75                                            defined.  */
  76 } gfc_cpp_macro_queue;
  77 static gfc_cpp_macro_queue *cpp_define_queue, *cpp_undefine_queue;
  78
  79 struct gfc_cpp_option_data
  80 {
  81   /* Argument of -cpp, implied by SPEC;
  82      if NULL, preprocessing disabled.  */
  83   const char *temporary_filename;
  84
  85   const char *output_filename;          /* -o <arg>  */
  86   int preprocess_only;                  /* -E  */
  87   int discard_comments;                 /* -C  */
  88   int discard_comments_in_macro_exp;    /* -CC  */
  89   int print_include_names;              /* -H  */
  90   int no_line_commands;                 /* -P  */
  91   char dump_macros;                     /* -d[DMNU]  */
  92   int dump_includes;                    /* -dI  */
  93   int working_directory;                /* -fworking-directory  */
  94   int no_predefined;                    /* -undef */
  95   int standard_include_paths;           /* -nostdinc */
  96   int verbose;                          /* -v */
  97   int deps;                             /* -M */
  98   int deps_skip_system;                 /* -MM */
  99   const char *deps_filename;            /* -M[M]D */
 100   const char *deps_filename_user;       /* -MF <arg> */
 101   int deps_missing_are_generated;       /* -MG */
 102   int deps_phony;                       /* -MP */
 103
 104   const char *multilib;                 /* -imultilib <dir>  */
 105   const char *prefix;                   /* -iprefix <dir>  */
 106   const char *sysroot;                  /* -isysroot <dir>  */
 107
 108   /* Options whose handling needs to be deferred until the
 109      appropriate cpp-objects are created:
 110       -A predicate=answer
 111       -D <macro>[=<val>]
 112       -U <macro>  */
 113   gfc_cpp_deferred_opt_t *deferred_opt;
 114   int deferred_opt_count;
 115 }
 116 gfc_cpp_option;
 117
 118 /* Structures used with libcpp:  */
 119 static cpp_options *cpp_option = NULL;
 120 static cpp_reader *cpp_in = NULL;
 121
 122 /* Encapsulates state used to convert a stream of cpp-tokens into
 123    a text file.  */
 124 static struct
 125 {
 126   FILE *outf;                   /* Stream to write to.  */
 127   const cpp_token *prev;        /* Previous token.  */
 128   const cpp_token *source;      /* Source token for spacing.  */
 129   int src_line;                 /* Line number currently being written.  */
 130   unsigned char printed;        /* Nonzero if something output at line.  */
 131   bool first_time;              /* cb_file_change hasn't been called yet.  */
 132 } print;
 133
 134 /* General output routines.  */
 135 static void scan_translation_unit (cpp_reader *);
 136 static void scan_translation_unit_trad (cpp_reader *);
 137
 138 /* Callback routines for the parser. Most of these are active only
 139    in specific modes.  */
 140 static void cb_file_change (cpp_reader *, const struct line_map *);
 141 static void cb_line_change (cpp_reader *, const cpp_token *, int);
 142 static void cb_define (cpp_reader *, source_location, cpp_hashnode *);
 143 static void cb_undef (cpp_reader *, source_location, cpp_hashnode *);
 144 static void cb_def_pragma (cpp_reader *, source_location);
 145 static void cb_include (cpp_reader *, source_location, const unsigned char *,
 146                         const char *, int, const cpp_token **);
 147 static void cb_ident (cpp_reader *, source_location, const cpp_string *);
 148 static void cb_used_define (cpp_reader *, source_location, cpp_hashnode *);
 149 static void cb_used_undef (cpp_reader *, source_location, cpp_hashnode *);
 150 static bool cb_cpp_error (cpp_reader *, int, int, location_t, unsigned int,
 151                           const char *, va_list *)
 152      ATTRIBUTE_GCC_DIAG(6,0);
 153 void pp_dir_change (cpp_reader *, const char *);
 154
 155 static int dump_macro (cpp_reader *, cpp_hashnode *, void *);
 156 static void dump_queued_macros (cpp_reader *);
 157
 158
 159 static void
 160 cpp_define_builtins (cpp_reader *pfile)
 161 {
 162   /* Initialize CPP built-ins; '1' corresponds to 'flag_hosted'
 163      in C, defines __STDC_HOSTED__?!  */
 164   cpp_init_builtins (pfile, 0);
 165
 166   /* Initialize GFORTRAN specific builtins.
 167      These are documented.  */
 168   define_language_independent_builtin_macros (pfile);
 169   cpp_define (pfile, "__GFORTRAN__=1");
 170   cpp_define (pfile, "_LANGUAGE_FORTRAN=1");
 171
 172   if (gfc_option.gfc_flag_openmp)
 173     cpp_define (pfile, "_OPENMP=201107");
 174
 175   /* The defines below are necessary for the TARGET_* macros.
 176
 177      FIXME:  Note that builtin_define_std() actually is a function
 178      in c-cppbuiltin.c which uses flags undefined for Fortran.
 179      Let's skip this for now. If needed, one needs to look into it
 180      once more.  */
 181
 182 # define builtin_define(TXT) cpp_define (pfile, TXT)
 183 # define builtin_define_std(TXT)
 184 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
 185
 186   /* FIXME: Pandora's Box
 187     Using the macros below results in multiple breakages:
 188      - mingw will fail to compile this file as dependent macros
 189        assume to be used in c-cppbuiltin.c only. Further, they use
 190        flags only valid/defined in C (same as noted above).
 191        [config/i386/mingw32.h, config/i386/cygming.h]
 192      - other platforms (not as popular) break similarly
 193        [grep for 'builtin_define_with_int_value' in gcc/config/]
 194
 195   TARGET_CPU_CPP_BUILTINS ();
 196   TARGET_OS_CPP_BUILTINS ();
 197   TARGET_OBJFMT_CPP_BUILTINS (); */
 198
 199 #undef builtin_define
 200 #undef builtin_define_std
 201 #undef builtin_assert
 202 }
 203
 204 bool
 205 gfc_cpp_enabled (void)
 206 {
 207   return gfc_cpp_option.temporary_filename != NULL;
 208 }
 209
 210 bool
 211 gfc_cpp_preprocess_only (void)
 212 {
 213   return gfc_cpp_option.preprocess_only;
 214 }
 215
 216 bool
 217 gfc_cpp_makedep (void)
 218 {
 219   return gfc_cpp_option.deps;
 220 }
 221
 222 void
 223 gfc_cpp_add_dep (const char *name, bool system)
 224 {
 225   if (!gfc_cpp_option.deps_skip_system || !system)
 226     deps_add_dep (cpp_get_deps (cpp_in), name);
 227 }
 228
 229 void
 230 gfc_cpp_add_target (const char *name)
 231 {
 232   deps_add_target (cpp_get_deps (cpp_in), name, 0);
 233 }
 234
 235
 236 const char *
 237 gfc_cpp_temporary_file (void)
 238 {
 239   return gfc_cpp_option.temporary_filename;
 240 }
 241
 242 void
 243 gfc_cpp_init_options (unsigned int decoded_options_count,
 244                       struct cl_decoded_option *decoded_options ATTRIBUTE_UNUSED)
 245 {
 246   /* Do not create any objects from libcpp here. If no
 247      preprocessing is requested, this would be wasted
 248      time and effort.
 249
 250      See gfc_cpp_post_options() instead.  */
 251
 252   gfc_cpp_option.temporary_filename = NULL;
 253   gfc_cpp_option.output_filename = NULL;
 254   gfc_cpp_option.preprocess_only = 0;
 255   gfc_cpp_option.discard_comments = 1;
 256   gfc_cpp_option.discard_comments_in_macro_exp = 1;
 257   gfc_cpp_option.print_include_names = 0;
 258   gfc_cpp_option.no_line_commands = 0;
 259   gfc_cpp_option.dump_macros = '\0';
 260   gfc_cpp_option.dump_includes = 0;
 261   gfc_cpp_option.working_directory = -1;
 262   gfc_cpp_option.no_predefined = 0;
 263   gfc_cpp_option.standard_include_paths = 1;
 264   gfc_cpp_option.verbose = 0;
 265   gfc_cpp_option.deps = 0;
 266   gfc_cpp_option.deps_skip_system = 0;
 267   gfc_cpp_option.deps_phony = 0;
 268   gfc_cpp_option.deps_missing_are_generated = 0;
 269   gfc_cpp_option.deps_filename = NULL;
 270   gfc_cpp_option.deps_filename_user = NULL;
 271
 272   gfc_cpp_option.multilib = NULL;
 273   gfc_cpp_option.prefix = NULL;
 274   gfc_cpp_option.sysroot = TARGET_SYSTEM_ROOT;
 275
 276   gfc_cpp_option.deferred_opt = XNEWVEC (gfc_cpp_deferred_opt_t,
 277                                          decoded_options_count);
 278   gfc_cpp_option.deferred_opt_count = 0;
 279 }
 280
 281 int
 282 gfc_cpp_handle_option (size_t scode, const char *arg, int value ATTRIBUTE_UNUSED)
 283 {
 284   int result = 1;
 285   enum opt_code code = (enum opt_code) scode;
 286
 287   switch (code)
 288   {
 289     default:
 290       result = 0;
 291       break;
 292
 293     case OPT_cpp_:
 294       gfc_cpp_option.temporary_filename = arg;
 295       break;
 296
 297     case OPT_nocpp:
 298       gfc_cpp_option.temporary_filename = 0L;
 299       break;
 300
 301     case OPT_d:
 302       for ( ; *arg; ++arg)
 303         switch (*arg)
 304         {
 305           case 'D':
 306           case 'M':
 307           case 'N':
 308           case 'U':
 309             gfc_cpp_option.dump_macros = *arg;
 310             break;
 311
 312           case 'I':
 313             gfc_cpp_option.dump_includes = 1;
 314             break;
 315         }
 316       break;
 317
 318     case OPT_fworking_directory:
 319       gfc_cpp_option.working_directory = value;
 320       break;
 321
 322     case OPT_idirafter:
 323       gfc_cpp_add_include_path_after (xstrdup(arg), true);
 324       break;
 325
 326     case OPT_imultilib:
 327       gfc_cpp_option.multilib = arg;
 328       break;
 329
 330     case OPT_iprefix:
 331       gfc_cpp_option.prefix = arg;
 332       break;
 333
 334     case OPT_isysroot:
 335       gfc_cpp_option.sysroot = arg;
 336       break;
 337
 338     case OPT_iquote:
 339     case OPT_isystem:
 340       gfc_cpp_add_include_path (xstrdup(arg), true);
 341       break;
 342
 343     case OPT_nostdinc:
 344       gfc_cpp_option.standard_include_paths = value;
 345       break;
 346
 347     case OPT_o:
 348       if (!gfc_cpp_option.output_filename)
 349         gfc_cpp_option.output_filename = arg;
 350       else
 351         gfc_fatal_error ("output filename specified twice");
 352       break;
 353
 354     case OPT_undef:
 355       gfc_cpp_option.no_predefined = value;
 356       break;
 357
 358     case OPT_v:
 359       gfc_cpp_option.verbose = value;
 360       break;
 361
 362     case OPT_A:
 363     case OPT_D:
 364     case OPT_U:
 365       gfc_cpp_option.deferred_opt[gfc_cpp_option.deferred_opt_count].code = code;
 366       gfc_cpp_option.deferred_opt[gfc_cpp_option.deferred_opt_count].arg = arg;
 367       gfc_cpp_option.deferred_opt_count++;
 368       break;
 369
 370     case OPT_C:
 371       gfc_cpp_option.discard_comments = 0;
 372       break;
 373
 374     case OPT_CC:
 375       gfc_cpp_option.discard_comments = 0;
 376       gfc_cpp_option.discard_comments_in_macro_exp = 0;
 377       break;
 378
 379     case OPT_E:
 380       gfc_cpp_option.preprocess_only = 1;
 381       break;
 382
 383     case OPT_H:
 384       gfc_cpp_option.print_include_names = 1;
 385       break;
 386
 387     case OPT_MM:
 388       gfc_cpp_option.deps_skip_system = 1;
 389       /* fall through */
 390
 391     case OPT_M:
 392       gfc_cpp_option.deps = 1;
 393       break;
 394
 395     case OPT_MMD:
 396       gfc_cpp_option.deps_skip_system = 1;
 397       /* fall through */
 398
 399     case OPT_MD:
 400       gfc_cpp_option.deps = 1;
 401       gfc_cpp_option.deps_filename = arg;
 402       break;
 403
 404     case OPT_MF:
 405       /* If specified multiple times, last one wins.  */
 406       gfc_cpp_option.deps_filename_user = arg;
 407       break;
 408
 409     case OPT_MG:
 410       gfc_cpp_option.deps_missing_are_generated = 1;
 411       break;
 412
 413     case OPT_MP:
 414       gfc_cpp_option.deps_phony = 1;
 415       break;
 416
 417     case OPT_MQ:
 418     case OPT_MT:
 419       gfc_cpp_option.deferred_opt[gfc_cpp_option.deferred_opt_count].code = code;
 420       gfc_cpp_option.deferred_opt[gfc_cpp_option.deferred_opt_count].arg = arg;
 421       gfc_cpp_option.deferred_opt_count++;
 422       break;
 423
 424     case OPT_P:
 425       gfc_cpp_option.no_line_commands = 1;
 426       break;
 427   }
 428
 429   return result;
 430 }
 431
 432
 433 void
 434 gfc_cpp_post_options (void)
 435 {
 436   /* Any preprocessing-related option without '-cpp' is considered
 437      an error.  */
 438   if (!gfc_cpp_enabled ()
 439       && (gfc_cpp_preprocess_only ()
 440           || gfc_cpp_makedep ()
 441           || !gfc_cpp_option.discard_comments
 442           || !gfc_cpp_option.discard_comments_in_macro_exp
 443           || gfc_cpp_option.print_include_names
 444           || gfc_cpp_option.no_line_commands
 445           || gfc_cpp_option.dump_macros
 446           || gfc_cpp_option.dump_includes))
 447     gfc_fatal_error("To enable preprocessing, use -cpp");
 448
 449   if (!gfc_cpp_enabled ())
 450     return;
 451
 452   cpp_in = cpp_create_reader (CLK_GNUC89, NULL, line_table);
 453   gcc_assert (cpp_in);
 454
 455   /* The cpp_options-structure defines far more flags than those set here.
 456      If any other is implemented, see c-opt.c (sanitize_cpp_opts) for
 457      inter-option dependencies that may need to be enforced.  */
 458   cpp_option = cpp_get_options (cpp_in);
 459   gcc_assert (cpp_option);
 460
 461   /* TODO: allow non-traditional modes, e.g. by -cpp-std=...?  */
 462   cpp_option->traditional = 1;
 463   cpp_option->cplusplus_comments = 0;
 464
 465   cpp_option->cpp_pedantic = pedantic;
 466
 467   cpp_option->dollars_in_ident = gfc_option.flag_dollar_ok;
 468   cpp_option->discard_comments = gfc_cpp_option.discard_comments;
 469   cpp_option->discard_comments_in_macro_exp = gfc_cpp_option.discard_comments_in_macro_exp;
 470   cpp_option->print_include_names = gfc_cpp_option.print_include_names;
 471   cpp_option->preprocessed = gfc_option.flag_preprocessed;
 472
 473   if (gfc_cpp_makedep ())
 474     {
 475       cpp_option->deps.style = DEPS_USER;
 476       cpp_option->deps.phony_targets = gfc_cpp_option.deps_phony;
 477       cpp_option->deps.missing_files = gfc_cpp_option.deps_missing_are_generated;
 478
 479       /* -MF <arg> overrides -M[M]D.  */
 480       if (gfc_cpp_option.deps_filename_user)
 481         gfc_cpp_option.deps_filename = gfc_cpp_option.deps_filename_user;
 482   }
 483
 484   if (gfc_cpp_option.working_directory == -1)
 485     gfc_cpp_option.working_directory = (debug_info_level != DINFO_LEVEL_NONE);
 486
 487   cpp_post_options (cpp_in);
 488
 489   gfc_cpp_register_include_paths ();
 490 }
 491
 492
 493 void
 494 gfc_cpp_init_0 (void)
 495 {
 496   struct cpp_callbacks *cb;
 497
 498   cb = cpp_get_callbacks (cpp_in);
 499   cb->file_change = cb_file_change;
 500   cb->line_change = cb_line_change;
 501   cb->ident = cb_ident;
 502   cb->def_pragma = cb_def_pragma;
 503   cb->error = cb_cpp_error;
 504
 505   if (gfc_cpp_option.dump_includes)
 506     cb->include = cb_include;
 507
 508   if ((gfc_cpp_option.dump_macros == 'D')
 509       || (gfc_cpp_option.dump_macros == 'N'))
 510     {
 511       cb->define = cb_define;
 512       cb->undef  = cb_undef;
 513     }
 514
 515   if (gfc_cpp_option.dump_macros == 'U')
 516     {
 517       cb->before_define = dump_queued_macros;
 518       cb->used_define = cb_used_define;
 519       cb->used_undef = cb_used_undef;
 520     }
 521
 522   /* Initialize the print structure.  Setting print.src_line to -1 here is
 523      a trick to guarantee that the first token of the file will cause
 524      a linemarker to be output by maybe_print_line.  */
 525   print.src_line = -1;
 526   print.printed = 0;
 527   print.prev = 0;
 528   print.first_time = 1;
 529
 530   if (gfc_cpp_preprocess_only ())
 531     {
 532       if (gfc_cpp_option.output_filename)
 533         {
 534           /* This needs cheating: with "-E -o <file>", the user wants the
 535              preprocessed output in <file>. However, if nothing is done
 536              about it <file> is also used for assembler output. Hence, it
 537              is necessary to redirect assembler output (actually nothing
 538              as -E implies -fsyntax-only) to another file, otherwise the
 539              output from preprocessing is lost.  */
 540           asm_file_name = gfc_cpp_option.temporary_filename;
 541
 542           print.outf = fopen (gfc_cpp_option.output_filename, "w");
 543           if (print.outf == NULL)
 544             gfc_fatal_error ("opening output file %s: %s",
 545                              gfc_cpp_option.output_filename,
 546                              xstrerror (errno));
 547         }
 548       else
 549         print.outf = stdout;
 550     }
 551   else
 552     {
 553       print.outf = fopen (gfc_cpp_option.temporary_filename, "w");
 554       if (print.outf == NULL)
 555         gfc_fatal_error ("opening output file %s: %s",
 556                          gfc_cpp_option.temporary_filename, xstrerror (errno));
 557     }
 558
 559   gcc_assert(cpp_in);
 560   if (!cpp_read_main_file (cpp_in, gfc_source_file))
 561     errorcount++;
 562 }
 563
 564 void
 565 gfc_cpp_init (void)
 566 {
 567   int i;
 568
 569   if (gfc_option.flag_preprocessed)
 570     return;
 571
 572   cpp_change_file (cpp_in, LC_RENAME, _("<built-in>"));
 573   if (!gfc_cpp_option.no_predefined)
 574     {
 575       /* Make sure all of the builtins about to be declared have
 576         BUILTINS_LOCATION has their source_location.  */
 577       source_location builtins_loc = BUILTINS_LOCATION;
 578       cpp_force_token_locations (cpp_in, &builtins_loc);
 579
 580       cpp_define_builtins (cpp_in);
 581
 582       cpp_stop_forcing_token_locations (cpp_in);
 583     }
 584
 585   /* Handle deferred options from command-line.  */
 586   cpp_change_file (cpp_in, LC_RENAME, _("<command-line>"));
 587
 588   for (i = 0; i < gfc_cpp_option.deferred_opt_count; i++)
 589     {
 590       gfc_cpp_deferred_opt_t *opt = &gfc_cpp_option.deferred_opt[i];
 591
 592       if (opt->code == OPT_D)
 593         cpp_define (cpp_in, opt->arg);
 594       else if (opt->code == OPT_U)
 595         cpp_undef (cpp_in, opt->arg);
 596       else if (opt->code == OPT_A)
 597         {
 598           if (opt->arg[0] == '-')
 599             cpp_unassert (cpp_in, opt->arg + 1);
 600           else
 601             cpp_assert (cpp_in, opt->arg);
 602         }
 603       else if (opt->code == OPT_MT || opt->code == OPT_MQ)
 604         deps_add_target (cpp_get_deps (cpp_in),
 605                          opt->arg, opt->code == OPT_MQ);
 606     }
 607
 608   if (gfc_cpp_option.working_directory
 609       && gfc_cpp_option.preprocess_only && !gfc_cpp_option.no_line_commands)
 610     pp_dir_change (cpp_in, get_src_pwd ());
 611 }
 612
 613 gfc_try
 614 gfc_cpp_preprocess (const char *source_file)
 615 {
 616   if (!gfc_cpp_enabled ())
 617     return FAILURE;
 618
 619   cpp_change_file (cpp_in, LC_RENAME, source_file);
 620
 621   if (cpp_option->traditional)
 622     scan_translation_unit_trad (cpp_in);
 623   else
 624     scan_translation_unit (cpp_in);
 625
 626   /* -dM command line option.  */
 627   if (gfc_cpp_preprocess_only () &&
 628       gfc_cpp_option.dump_macros == 'M')
 629     {
 630       putc ('\n', print.outf);
 631       cpp_forall_identifiers (cpp_in, dump_macro, NULL);
 632     }
 633
 634   putc ('\n', print.outf);
 635
 636   if (!gfc_cpp_preprocess_only ()
 637       || (gfc_cpp_preprocess_only () && gfc_cpp_option.output_filename))
 638     fclose (print.outf);
 639
 640   return SUCCESS;
 641 }
 642
 643 void
 644 gfc_cpp_done (void)
 645 {
 646   if (!gfc_cpp_enabled ())
 647     return;
 648
 649   gcc_assert (cpp_in);
 650
 651   if (gfc_cpp_makedep ())
 652     {
 653       if (gfc_cpp_option.deps_filename)
 654         {
 655           FILE *f = fopen (gfc_cpp_option.deps_filename, "w");
 656           if (f)
 657             {
 658               cpp_finish (cpp_in, f);
 659               fclose (f);
 660             }
 661           else
 662             gfc_fatal_error ("opening output file %s: %s",
 663                              gfc_cpp_option.deps_filename,
 664                              xstrerror (errno));
 665         }
 666       else
 667         cpp_finish (cpp_in, stdout);
 668     }
 669
 670   cpp_undef_all (cpp_in);
 671   cpp_clear_file_cache (cpp_in);
 672 }
 673
 674 /* PATH must be malloc-ed and NULL-terminated.  */
 675 void
 676 gfc_cpp_add_include_path (char *path, bool user_supplied)
 677 {
 678   /* CHAIN sets cpp_dir->sysp which differs from 0 if PATH is a system
 679      include path. Fortran does not define any system include paths.  */
 680   int cxx_aware = 0;
 681
 682   add_path (path, BRACKET, cxx_aware, user_supplied);
 683 }
 684
 685 void
 686 gfc_cpp_add_include_path_after (char *path, bool user_supplied)
 687 {
 688   int cxx_aware = 0;
 689   add_path (path, AFTER, cxx_aware, user_supplied);
 690 }
 691
 692 void
 693 gfc_cpp_register_include_paths (void)
 694 {
 695   int cxx_stdinc = 0;
 696   register_include_chains (cpp_in, gfc_cpp_option.sysroot,
 697                            gfc_cpp_option.prefix, gfc_cpp_option.multilib,
 698                            gfc_cpp_option.standard_include_paths, cxx_stdinc,
 699                            gfc_cpp_option.verbose);
 700 }
 701
 702
 703
 704 static void scan_translation_unit_trad (cpp_reader *);
 705 static void account_for_newlines (const unsigned char *, size_t);
 706 static int dump_macro (cpp_reader *, cpp_hashnode *, void *);
 707
 708 static void print_line (source_location, const char *);
 709 static void maybe_print_line (source_location);
 710
 711
 712 /* Writes out the preprocessed file, handling spacing and paste
 713    avoidance issues.  */
 714 static void
 715 scan_translation_unit (cpp_reader *pfile)
 716 {
 717   bool avoid_paste = false;
 718
 719   print.source = NULL;
 720   for (;;)
 721     {
 722       const cpp_token *token = cpp_get_token (pfile);
 723
 724       if (token->type == CPP_PADDING)
 725         {
 726           avoid_paste = true;
 727           if (print.source == NULL
 728               || (!(print.source->flags & PREV_WHITE)
 729                   && token->val.source == NULL))
 730             print.source = token->val.source;
 731           continue;
 732         }
 733
 734       if (token->type == CPP_EOF)
 735         break;
 736
 737       /* Subtle logic to output a space if and only if necessary.  */
 738       if (avoid_paste)
 739         {
 740           if (print.source == NULL)
 741             print.source = token;
 742           if (print.source->flags & PREV_WHITE
 743               || (print.prev
 744                   && cpp_avoid_paste (pfile, print.prev, token))
 745               || (print.prev == NULL && token->type == CPP_HASH))
 746             putc (' ', print.outf);
 747         }
 748       else if (token->flags & PREV_WHITE)
 749         putc (' ', print.outf);
 750
 751       avoid_paste = false;
 752       print.source = NULL;
 753       print.prev = token;
 754       cpp_output_token (token, print.outf);
 755
 756       if (token->type == CPP_COMMENT)
 757         account_for_newlines (token->val.str.text, token->val.str.len);
 758     }
 759 }
 760
 761 /* Adjust print.src_line for newlines embedded in output.  */
 762 static void
 763 account_for_newlines (const unsigned char *str, size_t len)
 764 {
 765   while (len--)
 766     if (*str++ == '\n')
 767       print.src_line++;
 768 }
 769
 770 /* Writes out a traditionally preprocessed file.  */
 771 static void
 772 scan_translation_unit_trad (cpp_reader *pfile)
 773 {
 774   while (_cpp_read_logical_line_trad (pfile))
 775     {
 776       size_t len = pfile->out.cur - pfile->out.base;
 777       maybe_print_line (pfile->out.first_line);
 778       fwrite (pfile->out.base, 1, len, print.outf);
 779       print.printed = 1;
 780       if (!CPP_OPTION (pfile, discard_comments))
 781         account_for_newlines (pfile->out.base, len);
 782     }
 783 }
 784
 785 /* If the token read on logical line LINE needs to be output on a
 786    different line to the current one, output the required newlines or
 787    a line marker.  */
 788 static void
 789 maybe_print_line (source_location src_loc)
 790 {
 791   const struct line_map *map = linemap_lookup (line_table, src_loc);
 792   int src_line = SOURCE_LINE (map, src_loc);
 793
 794   /* End the previous line of text.  */
 795   if (print.printed)
 796     {
 797       putc ('\n', print.outf);
 798       print.src_line++;
 799       print.printed = 0;
 800     }
 801
 802   if (src_line >= print.src_line && src_line < print.src_line + 8)
 803     {
 804       while (src_line > print.src_line)
 805         {
 806           putc ('\n', print.outf);
 807           print.src_line++;
 808         }
 809     }
 810   else
 811     print_line (src_loc, "");
 812 }
 813
 814 /* Output a line marker for logical line LINE.  Special flags are "1"
 815    or "2" indicating entering or leaving a file.  */
 816 static void
 817 print_line (source_location src_loc, const char *special_flags)
 818 {
 819   /* End any previous line of text.  */
 820   if (print.printed)
 821     putc ('\n', print.outf);
 822   print.printed = 0;
 823
 824   if (!gfc_cpp_option.no_line_commands)
 825     {
 826       expanded_location loc;
 827       size_t to_file_len;
 828       unsigned char *to_file_quoted;
 829       unsigned char *p;
 830       int sysp;
 831
 832       loc = expand_location (src_loc);
 833       to_file_len = strlen (loc.file);
 834       to_file_quoted = (unsigned char *) alloca (to_file_len * 4 + 1);
 835
 836       print.src_line = loc.line;
 837
 838       /* cpp_quote_string does not nul-terminate, so we have to do it
 839          ourselves.  */
 840       p = cpp_quote_string (to_file_quoted,
 841                             (const unsigned char *) loc.file, to_file_len);
 842       *p = '\0';
 843       fprintf (print.outf, "# %u \"%s\"%s",
 844                print.src_line == 0 ? 1 : print.src_line,
 845                to_file_quoted, special_flags);
 846
 847       sysp = in_system_header_at (src_loc);
 848       if (sysp == 2)
 849         fputs (" 3 4", print.outf);
 850       else if (sysp == 1)
 851         fputs (" 3", print.outf);
 852
 853       putc ('\n', print.outf);
 854     }
 855 }
 856
 857 static void
 858 cb_file_change (cpp_reader * ARG_UNUSED (pfile), const struct line_map *map)
 859 {
 860   const char *flags = "";
 861
 862   if (gfc_cpp_option.no_line_commands)
 863     return;
 864
 865   if (!map)
 866     return;
 867
 868       if (print.first_time)
 869         {
 870           /* Avoid printing foo.i when the main file is foo.c.  */
 871           if (!cpp_get_options (cpp_in)->preprocessed)
 872             print_line (map->start_location, flags);
 873           print.first_time = 0;
 874         }
 875       else
 876         {
 877           /* Bring current file to correct line when entering a new file.  */
 878           if (map->reason == LC_ENTER)
 879             {
 880               const struct line_map *from = INCLUDED_FROM (line_table, map);
 881               maybe_print_line (LAST_SOURCE_LINE_LOCATION (from));
 882             }
 883           if (map->reason == LC_ENTER)
 884             flags = " 1";
 885           else if (map->reason == LC_LEAVE)
 886             flags = " 2";
 887           print_line (map->start_location, flags);
 888         }
 889
 890 }
 891
 892 /* Called when a line of output is started.  TOKEN is the first token
 893    of the line, and at end of file will be CPP_EOF.  */
 894 static void
 895 cb_line_change (cpp_reader *pfile, const cpp_token *token,
 896                 int parsing_args)
 897 {
 898   source_location src_loc = token->src_loc;
 899
 900   if (token->type == CPP_EOF || parsing_args)
 901     return;
 902
 903   maybe_print_line (src_loc);
 904   print.prev = 0;
 905   print.source = 0;
 906
 907   /* Supply enough spaces to put this token in its original column,
 908      one space per column greater than 2, since scan_translation_unit
 909      will provide a space if PREV_WHITE.  Don't bother trying to
 910      reconstruct tabs; we can't get it right in general, and nothing
 911      ought to care.  Some things do care; the fault lies with them.  */
 912   if (!CPP_OPTION (pfile, traditional))
 913     {
 914       const struct line_map *map = linemap_lookup (line_table, src_loc);
 915       int spaces = SOURCE_COLUMN (map, src_loc) - 2;
 916       print.printed = 1;
 917
 918       while (-- spaces >= 0)
 919         putc (' ', print.outf);
 920     }
 921 }
 922
 923 static void
 924 cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 925           const cpp_string *str)
 926 {
 927   maybe_print_line (line);
 928   fprintf (print.outf, "#ident %s\n", str->text);
 929   print.src_line++;
 930 }
 931
 932 static void
 933 cb_define (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 934            cpp_hashnode *node ATTRIBUTE_UNUSED)
 935 {
 936   maybe_print_line (line);
 937   fputs ("#define ", print.outf);
 938
 939   /* 'D' is whole definition; 'N' is name only.  */
 940   if (gfc_cpp_option.dump_macros == 'D')
 941     fputs ((const char *) cpp_macro_definition (pfile, node),
 942            print.outf);
 943   else
 944     fputs ((const char *) NODE_NAME (node), print.outf);
 945
 946   putc ('\n', print.outf);
 947   if (LOCATION_LINE (line) != 0)
 948     print.src_line++;
 949 }
 950
 951 static void
 952 cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 953           cpp_hashnode *node)
 954 {
 955   maybe_print_line (line);
 956   fprintf (print.outf, "#undef %s\n", NODE_NAME (node));
 957   print.src_line++;
 958 }
 959
 960 static void
 961 cb_include (cpp_reader *pfile ATTRIBUTE_UNUSED, source_location line,
 962             const unsigned char *dir, const char *header, int angle_brackets,
 963             const cpp_token **comments)
 964 {
 965   maybe_print_line (line);
 966   if (angle_brackets)
 967     fprintf (print.outf, "#%s <%s>", dir, header);
 968   else
 969     fprintf (print.outf, "#%s \"%s\"", dir, header);
 970
 971   if (comments != NULL)
 972     {
 973       while (*comments != NULL)
 974         {
 975           if ((*comments)->flags & PREV_WHITE)
 976             putc (' ', print.outf);
 977           cpp_output_token (*comments, print.outf);
 978           ++comments;
 979         }
 980     }
 981
 982   putc ('\n', print.outf);
 983   print.src_line++;
 984 }
 985
 986 /* Dump out the hash table.  */
 987 static int
 988 dump_macro (cpp_reader *pfile, cpp_hashnode *node, void *v ATTRIBUTE_UNUSED)
 989 {
 990   if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))
 991     {
 992       fputs ("#define ", print.outf);
 993       fputs ((const char *) cpp_macro_definition (pfile, node),
 994              print.outf);
 995       putc ('\n', print.outf);
 996       print.src_line++;
 997     }
 998
 999   return 1;
1000 }
1001
1002 static void
1003 cb_used_define (cpp_reader *pfile, source_location line ATTRIBUTE_UNUSED,
1004                 cpp_hashnode *node)
1005 {
1006   gfc_cpp_macro_queue *q;
1007   q = XNEW (gfc_cpp_macro_queue);
1008   q->macro = xstrdup ((const char *) cpp_macro_definition (pfile, node));
1009   q->next = cpp_define_queue;
1010   cpp_define_queue = q;
1011 }
1012
1013 /* Callback from cpp_error for PFILE to print diagnostics from the
1014    preprocessor.  The diagnostic is of type LEVEL, with REASON set
1015    to the reason code if LEVEL is represents a warning, at location
1016    LOCATION, with column number possibly overridden by COLUMN_OVERRIDE
1017    if not zero; MSG is the translated message and AP the arguments.
1018    Returns true if a diagnostic was emitted, false otherwise.  */
1019
1020 static bool
1021 cb_cpp_error (cpp_reader *pfile ATTRIBUTE_UNUSED, int level, int reason,
1022               location_t location, unsigned int column_override,
1023               const char *msg, va_list *ap)
1024 {
1025   diagnostic_info diagnostic;
1026   diagnostic_t dlevel;
1027   bool save_warn_system_headers = global_dc->dc_warn_system_headers;
1028   bool ret;
1029
1030   switch (level)
1031     {
1032     case CPP_DL_WARNING_SYSHDR:
1033       global_dc->dc_warn_system_headers = 1;
1034       /* Fall through.  */
1035     case CPP_DL_WARNING:
1036       dlevel = DK_WARNING;
1037       break;
1038     case CPP_DL_PEDWARN:
1039       dlevel = DK_PEDWARN;
1040       break;
1041     case CPP_DL_ERROR:
1042       dlevel = DK_ERROR;
1043       break;
1044     case CPP_DL_ICE:
1045       dlevel = DK_ICE;
1046       break;
1047     case CPP_DL_NOTE:
1048       dlevel = DK_NOTE;
1049       break;
1050     case CPP_DL_FATAL:
1051       dlevel = DK_FATAL;
1052       break;
1053     default:
1054       gcc_unreachable ();
1055     }
1056   diagnostic_set_info_translated (&diagnostic, msg, ap,
1057                                   location, dlevel);
1058   if (column_override)
1059     diagnostic_override_column (&diagnostic, column_override);
1060   if (reason == CPP_W_WARNING_DIRECTIVE)
1061     diagnostic_override_option_index (&diagnostic, OPT_Wcpp);
1062   ret = report_diagnostic (&diagnostic);
1063   if (level == CPP_DL_WARNING_SYSHDR)
1064     global_dc->dc_warn_system_headers = save_warn_system_headers;
1065   return ret;
1066 }
1067
1068 /* Callback called when -fworking-director and -E to emit working
1069    directory in cpp output file.  */
1070
1071 void
1072 pp_dir_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const char *dir)
1073 {
1074   size_t to_file_len = strlen (dir);
1075   unsigned char *to_file_quoted =
1076      (unsigned char *) alloca (to_file_len * 4 + 1);
1077   unsigned char *p;
1078
1079   /* cpp_quote_string does not nul-terminate, so we have to do it ourselves.  */
1080   p = cpp_quote_string (to_file_quoted, (const unsigned char *) dir, to_file_len);
1081   *p = '\0';
1082   fprintf (print.outf, "# 1 \"%s//\"\n", to_file_quoted);
1083 }
1084
1085 /* Copy a #pragma directive to the preprocessed output.  */
1086 static void
1087 cb_def_pragma (cpp_reader *pfile, source_location line)
1088 {
1089   maybe_print_line (line);
1090   fputs ("#pragma ", print.outf);
1091   cpp_output_line (pfile, print.outf);
1092   print.src_line++;
1093 }
1094
1095 static void
1096 cb_used_undef (cpp_reader *pfile ATTRIBUTE_UNUSED,
1097                source_location line ATTRIBUTE_UNUSED,
1098                cpp_hashnode *node)
1099 {
1100   gfc_cpp_macro_queue *q;
1101   q = XNEW (gfc_cpp_macro_queue);
1102   q->macro = xstrdup ((const char *) NODE_NAME (node));
1103   q->next = cpp_undefine_queue;
1104   cpp_undefine_queue = q;
1105 }
1106
1107 static void
1108 dump_queued_macros (cpp_reader *pfile ATTRIBUTE_UNUSED)
1109 {
1110   gfc_cpp_macro_queue *q;
1111
1112   /* End the previous line of text.  */
1113   if (print.printed)
1114     {
1115       putc ('\n', print.outf);
1116       print.src_line++;
1117       print.printed = 0;
1118     }
1119
1120   for (q = cpp_define_queue; q;)
1121     {
1122       gfc_cpp_macro_queue *oq;
1123       fputs ("#define ", print.outf);
1124       fputs (q->macro, print.outf);
1125       putc ('\n', print.outf);
1126       print.src_line++;
1127       oq = q;
1128       q = q->next;
1129       free (oq->macro);
1130       free (oq);
1131     }
1132   cpp_define_queue = NULL;
1133   for (q = cpp_undefine_queue; q;)
1134     {
1135       gfc_cpp_macro_queue *oq;
1136       fprintf (print.outf, "#undef %s\n", q->macro);
1137       print.src_line++;
1138       oq = q;
1139       q = q->next;
1140       free (oq->macro);
1141       free (oq);
1142     }
1143   cpp_undefine_queue = NULL;
1144 }