gcc/fortran/cpp.c

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