gcc/fortran/cpp.c

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