gcc/fortran/options.c

   1 /* Parse and display command line options.
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   3    2009, 2010
   4    Free Software Foundation, Inc.
   5    Contributed by Andy Vaught
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tree.h"
  27 #include "flags.h"
  28 #include "intl.h"
  29 #include "opts.h"
  30 #include "toplev.h"  /* For save_decoded_options.  */
  31 #include "options.h"
  32 #include "params.h"
  33 #include "tree-inline.h"
  34 #include "gfortran.h"
  35 #include "target.h"
  36 #include "cpp.h"
  37 #include "diagnostic-core.h"    /* For sorry.  */
  38 #include "tm.h"
  39
  40 gfc_option_t gfc_option;
  41
  42
  43 /* Set flags that control warnings and errors for different
  44    Fortran standards to their default values.  Keep in sync with
  45    libgfortran/runtime/compile_options.c (init_compile_options).  */
  46
  47 static void
  48 set_default_std_flags (void)
  49 {
  50   gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
  51     | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
  52     | GFC_STD_F2008_OBS | GFC_STD_GNU | GFC_STD_LEGACY;
  53   gfc_option.warn_std = GFC_STD_F95_DEL | GFC_STD_LEGACY;
  54 }
  55
  56
  57 /* Return language mask for Fortran options.  */
  58
  59 unsigned int
  60 gfc_option_lang_mask (void)
  61 {
  62   return CL_Fortran;
  63 }
  64
  65 /* Initialize options structure OPTS.  */
  66
  67 void
  68 gfc_init_options_struct (struct gcc_options *opts)
  69 {
  70   opts->x_flag_errno_math = 0;
  71   opts->x_flag_associative_math = -1;
  72 }
  73
  74 /* Get ready for options handling. Keep in sync with
  75    libgfortran/runtime/compile_options.c (init_compile_options). */
  76
  77 void
  78 gfc_init_options (unsigned int decoded_options_count,
  79                   struct cl_decoded_option *decoded_options)
  80 {
  81   gfc_source_file = NULL;
  82   gfc_option.module_dir = NULL;
  83   gfc_option.source_form = FORM_UNKNOWN;
  84   gfc_option.fixed_line_length = 72;
  85   gfc_option.free_line_length = 132;
  86   gfc_option.max_continue_fixed = 255;
  87   gfc_option.max_continue_free = 255;
  88   gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
  89   gfc_option.max_subrecord_length = 0;
  90   gfc_option.flag_max_array_constructor = 65535;
  91   gfc_option.convert = GFC_CONVERT_NATIVE;
  92   gfc_option.record_marker = 0;
  93   gfc_option.dump_fortran_original = 0;
  94   gfc_option.dump_fortran_optimized = 0;
  95
  96   gfc_option.warn_aliasing = 0;
  97   gfc_option.warn_ampersand = 0;
  98   gfc_option.warn_character_truncation = 0;
  99   gfc_option.warn_array_temp = 0;
 100   gfc_option.gfc_warn_conversion = 0;
 101   gfc_option.warn_conversion_extra = 0;
 102   gfc_option.warn_implicit_interface = 0;
 103   gfc_option.warn_line_truncation = 0;
 104   gfc_option.warn_surprising = 0;
 105   gfc_option.warn_tabs = 1;
 106   gfc_option.warn_underflow = 1;
 107   gfc_option.warn_intrinsic_shadow = 0;
 108   gfc_option.warn_intrinsics_std = 0;
 109   gfc_option.warn_align_commons = 1;
 110   gfc_option.warn_unused_dummy_argument = 0;
 111   gfc_option.max_errors = 25;
 112
 113   gfc_option.flag_all_intrinsics = 0;
 114   gfc_option.flag_default_double = 0;
 115   gfc_option.flag_default_integer = 0;
 116   gfc_option.flag_default_real = 0;
 117   gfc_option.flag_dollar_ok = 0;
 118   gfc_option.flag_underscoring = 1;
 119   gfc_option.flag_whole_file = 1;
 120   gfc_option.flag_f2c = 0;
 121   gfc_option.flag_second_underscore = -1;
 122   gfc_option.flag_implicit_none = 0;
 123
 124   /* Default value of flag_max_stack_var_size is set in gfc_post_options.  */
 125   gfc_option.flag_max_stack_var_size = -2;
 126
 127   gfc_option.flag_range_check = 1;
 128   gfc_option.flag_pack_derived = 0;
 129   gfc_option.flag_repack_arrays = 0;
 130   gfc_option.flag_preprocessed = 0;
 131   gfc_option.flag_automatic = 1;
 132   gfc_option.flag_backslash = 0;
 133   gfc_option.flag_module_private = 0;
 134   gfc_option.flag_backtrace = 0;
 135   gfc_option.flag_allow_leading_underscore = 0;
 136   gfc_option.flag_dump_core = 0;
 137   gfc_option.flag_external_blas = 0;
 138   gfc_option.blas_matmul_limit = 30;
 139   gfc_option.flag_cray_pointer = 0;
 140   gfc_option.flag_d_lines = -1;
 141   gfc_option.gfc_flag_openmp = 0;
 142   gfc_option.flag_sign_zero = 1;
 143   gfc_option.flag_recursive = 0;
 144   gfc_option.flag_init_integer = GFC_INIT_INTEGER_OFF;
 145   gfc_option.flag_init_integer_value = 0;
 146   gfc_option.flag_init_real = GFC_INIT_REAL_OFF;
 147   gfc_option.flag_init_logical = GFC_INIT_LOGICAL_OFF;
 148   gfc_option.flag_init_character = GFC_INIT_CHARACTER_OFF;
 149   gfc_option.flag_init_character_value = (char)0;
 150   gfc_option.flag_align_commons = 1;
 151   gfc_option.flag_protect_parens = 1;
 152
 153   gfc_option.fpe = 0;
 154   gfc_option.rtcheck = 0;
 155   gfc_option.coarray = GFC_FCOARRAY_NONE;
 156
 157   set_default_std_flags ();
 158
 159   /* Initialize cpp-related options.  */
 160   gfc_cpp_init_options (decoded_options_count, decoded_options);
 161 }
 162
 163
 164 /* Determine the source form from the filename extension.  We assume
 165    case insensitivity.  */
 166
 167 static gfc_source_form
 168 form_from_filename (const char *filename)
 169 {
 170   static const struct
 171   {
 172     const char *extension;
 173     gfc_source_form form;
 174   }
 175   exttype[] =
 176   {
 177     {
 178     ".f90", FORM_FREE}
 179     ,
 180     {
 181     ".f95", FORM_FREE}
 182     ,
 183     {
 184     ".f03", FORM_FREE}
 185     ,
 186     {
 187     ".f08", FORM_FREE}
 188     ,
 189     {
 190     ".f", FORM_FIXED}
 191     ,
 192     {
 193     ".for", FORM_FIXED}
 194     ,
 195     {
 196     ".ftn", FORM_FIXED}
 197     ,
 198     {
 199     "", FORM_UNKNOWN}
 200   };            /* sentinel value */
 201
 202   gfc_source_form f_form;
 203   const char *fileext;
 204   int i;
 205
 206   /* Find end of file name.  Note, filename is either a NULL pointer or
 207      a NUL terminated string.  */
 208   i = 0;
 209   while (filename[i] != '\0')
 210     i++;
 211
 212   /* Find last period.  */
 213   while (i >= 0 && (filename[i] != '.'))
 214     i--;
 215
 216   /* Did we see a file extension?  */
 217   if (i < 0)
 218     return FORM_UNKNOWN; /* Nope  */
 219
 220   /* Get file extension and compare it to others.  */
 221   fileext = &(filename[i]);
 222
 223   i = -1;
 224   f_form = FORM_UNKNOWN;
 225   do
 226     {
 227       i++;
 228       if (strcasecmp (fileext, exttype[i].extension) == 0)
 229         {
 230           f_form = exttype[i].form;
 231           break;
 232         }
 233     }
 234   while (exttype[i].form != FORM_UNKNOWN);
 235
 236   return f_form;
 237 }
 238
 239
 240 /* Finalize commandline options.  */
 241
 242 bool
 243 gfc_post_options (const char **pfilename)
 244 {
 245   const char *filename = *pfilename, *canon_source_file = NULL;
 246   char *source_path;
 247   int i;
 248
 249   /* Excess precision other than "fast" requires front-end
 250      support.  */
 251   if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
 252       && TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
 253     sorry ("-fexcess-precision=standard for Fortran");
 254   flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
 255
 256   /* Whole program needs whole file mode.  */
 257   if (flag_whole_program)
 258     gfc_option.flag_whole_file = 1;
 259
 260   /* Enable whole-file mode if LTO is in effect.  */
 261   if (flag_lto)
 262     gfc_option.flag_whole_file = 1;
 263
 264   /* Fortran allows associative math - but we cannot reassociate if
 265      we want traps or signed zeros. Cf. also flag_protect_parens.  */
 266   if (flag_associative_math == -1)
 267     flag_associative_math = (!flag_trapping_math && !flag_signed_zeros);
 268
 269   /* -fbounds-check is equivalent to -fcheck=bounds */
 270   if (flag_bounds_check)
 271     gfc_option.rtcheck |= GFC_RTCHECK_BOUNDS;
 272
 273   if (flag_compare_debug)
 274     gfc_option.dump_fortran_original = 0;
 275
 276   /* Verify the input file name.  */
 277   if (!filename || strcmp (filename, "-") == 0)
 278     {
 279       filename = "";
 280     }
 281
 282   if (gfc_option.flag_preprocessed)
 283     {
 284       /* For preprocessed files, if the first tokens are of the form # NUM.
 285          handle the directives so we know the original file name.  */
 286       gfc_source_file = gfc_read_orig_filename (filename, &canon_source_file);
 287       if (gfc_source_file == NULL)
 288         gfc_source_file = filename;
 289       else
 290         *pfilename = gfc_source_file;
 291     }
 292   else
 293     gfc_source_file = filename;
 294
 295   if (canon_source_file == NULL)
 296     canon_source_file = gfc_source_file;
 297
 298   /* Adds the path where the source file is to the list of include files.  */
 299
 300   i = strlen (canon_source_file);
 301   while (i > 0 && !IS_DIR_SEPARATOR (canon_source_file[i]))
 302     i--;
 303
 304   if (i != 0)
 305     {
 306       source_path = (char *) alloca (i + 1);
 307       memcpy (source_path, canon_source_file, i);
 308       source_path[i] = 0;
 309       gfc_add_include_path (source_path, true, true);
 310     }
 311   else
 312     gfc_add_include_path (".", true, true);
 313
 314   if (canon_source_file != gfc_source_file)
 315     gfc_free (CONST_CAST (char *, canon_source_file));
 316
 317   /* Decide which form the file will be read in as.  */
 318
 319   if (gfc_option.source_form != FORM_UNKNOWN)
 320     gfc_current_form = gfc_option.source_form;
 321   else
 322     {
 323       gfc_current_form = form_from_filename (filename);
 324
 325       if (gfc_current_form == FORM_UNKNOWN)
 326         {
 327           gfc_current_form = FORM_FREE;
 328           gfc_warning_now ("Reading file '%s' as free form",
 329                            (filename[0] == '\0') ? "<stdin>" : filename);
 330         }
 331     }
 332
 333   /* If the user specified -fd-lines-as-{code|comments} verify that we're
 334      in fixed form.  */
 335   if (gfc_current_form == FORM_FREE)
 336     {
 337       if (gfc_option.flag_d_lines == 0)
 338         gfc_warning_now ("'-fd-lines-as-comments' has no effect "
 339                          "in free form");
 340       else if (gfc_option.flag_d_lines == 1)
 341         gfc_warning_now ("'-fd-lines-as-code' has no effect in free form");
 342     }
 343
 344   /* If -pedantic, warn about the use of GNU extensions.  */
 345   if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)
 346     gfc_option.warn_std |= GFC_STD_GNU;
 347   /* -std=legacy -pedantic is effectively -std=gnu.  */
 348   if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)
 349     gfc_option.warn_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_LEGACY;
 350
 351   /* If the user didn't explicitly specify -f(no)-second-underscore we
 352      use it if we're trying to be compatible with f2c, and not
 353      otherwise.  */
 354   if (gfc_option.flag_second_underscore == -1)
 355     gfc_option.flag_second_underscore = gfc_option.flag_f2c;
 356
 357   if (!gfc_option.flag_automatic && gfc_option.flag_max_stack_var_size != -2
 358       && gfc_option.flag_max_stack_var_size != 0)
 359     gfc_warning_now ("Flag -fno-automatic overwrites -fmax-stack-var-size=%d",
 360                      gfc_option.flag_max_stack_var_size);
 361   else if (!gfc_option.flag_automatic && gfc_option.flag_recursive)
 362     gfc_warning_now ("Flag -fno-automatic overwrites -frecursive");
 363   else if (!gfc_option.flag_automatic && gfc_option.gfc_flag_openmp)
 364     gfc_warning_now ("Flag -fno-automatic overwrites -frecursive implied by "
 365                      "-fopenmp");
 366   else if (gfc_option.flag_max_stack_var_size != -2
 367            && gfc_option.flag_recursive)
 368     gfc_warning_now ("Flag -frecursive overwrites -fmax-stack-var-size=%d",
 369                      gfc_option.flag_max_stack_var_size);
 370   else if (gfc_option.flag_max_stack_var_size != -2
 371            && gfc_option.gfc_flag_openmp)
 372     gfc_warning_now ("Flag -fmax-stack-var-size=%d overwrites -frecursive "
 373                      "implied by -fopenmp",
 374                      gfc_option.flag_max_stack_var_size);
 375
 376   /* Implement -frecursive as -fmax-stack-var-size=-1.  */
 377   if (gfc_option.flag_recursive)
 378     gfc_option.flag_max_stack_var_size = -1;
 379
 380   /* Implied -frecursive; implemented as -fmax-stack-var-size=-1.  */
 381   if (gfc_option.flag_max_stack_var_size == -2 && gfc_option.gfc_flag_openmp
 382       && gfc_option.flag_automatic)
 383     {
 384       gfc_option.flag_recursive = 1;
 385       gfc_option.flag_max_stack_var_size = -1;
 386     }
 387
 388   /* Set default.  */
 389   if (gfc_option.flag_max_stack_var_size == -2)
 390     gfc_option.flag_max_stack_var_size = 32768;
 391
 392   /* Implement -fno-automatic as -fmax-stack-var-size=0.  */
 393   if (!gfc_option.flag_automatic)
 394     gfc_option.flag_max_stack_var_size = 0;
 395
 396   if (pedantic)
 397     {
 398       gfc_option.warn_ampersand = 1;
 399       gfc_option.warn_tabs = 0;
 400     }
 401
 402   if (pedantic && gfc_option.flag_whole_file)
 403     gfc_option.flag_whole_file = 2;
 404
 405   gfc_cpp_post_options ();
 406
 407 /* FIXME: return gfc_cpp_preprocess_only ();
 408
 409    The return value of this function indicates whether the
 410    backend needs to be initialized. On -E, we don't need
 411    the backend. However, if we return 'true' here, an
 412    ICE occurs. Initializing the backend doesn't hurt much,
 413    hence, for now we can live with it as is.  */
 414   return false;
 415 }
 416
 417
 418 /* Set the options for -Wall.  */
 419
 420 static void
 421 set_Wall (int setting)
 422 {
 423   gfc_option.warn_aliasing = setting;
 424   gfc_option.warn_ampersand = setting;
 425   gfc_option.gfc_warn_conversion = setting;
 426   gfc_option.warn_line_truncation = setting;
 427   gfc_option.warn_surprising = setting;
 428   gfc_option.warn_tabs = !setting;
 429   gfc_option.warn_underflow = setting;
 430   gfc_option.warn_intrinsic_shadow = setting;
 431   gfc_option.warn_intrinsics_std = setting;
 432   gfc_option.warn_character_truncation = setting;
 433   gfc_option.warn_unused_dummy_argument = setting;
 434
 435   warn_unused = setting;
 436   warn_return_type = setting;
 437   warn_switch = setting;
 438   warn_uninitialized = setting;
 439 }
 440
 441
 442 static void
 443 gfc_handle_module_path_options (const char *arg)
 444 {
 445
 446   if (gfc_option.module_dir != NULL)
 447     gfc_fatal_error ("gfortran: Only one -J option allowed");
 448
 449   gfc_option.module_dir = (char *) gfc_getmem (strlen (arg) + 2);
 450   strcpy (gfc_option.module_dir, arg);
 451   strcat (gfc_option.module_dir, "/");
 452
 453   gfc_add_include_path (gfc_option.module_dir, true, false);
 454 }
 455
 456
 457 static void
 458 gfc_handle_fpe_trap_option (const char *arg)
 459 {
 460   int result, pos = 0, n;
 461   static const char * const exception[] = { "invalid", "denormal", "zero",
 462                                             "overflow", "underflow",
 463                                             "precision", NULL };
 464   static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
 465                                        GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
 466                                        GFC_FPE_UNDERFLOW, GFC_FPE_PRECISION,
 467                                        0 };
 468
 469   while (*arg)
 470     {
 471       while (*arg == ',')
 472         arg++;
 473
 474       while (arg[pos] && arg[pos] != ',')
 475         pos++;
 476
 477       result = 0;
 478       for (n = 0; exception[n] != NULL; n++)
 479         {
 480           if (exception[n] && strncmp (exception[n], arg, pos) == 0)
 481             {
 482               gfc_option.fpe |= opt_exception[n];
 483               arg += pos;
 484               pos = 0;
 485               result = 1;
 486               break;
 487             }
 488         }
 489       if (!result)
 490         gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
 491     }
 492 }
 493
 494
 495 static void
 496 gfc_handle_coarray_option (const char *arg)
 497 {
 498   if (strcmp (arg, "none") == 0)
 499     gfc_option.coarray = GFC_FCOARRAY_NONE;
 500   else if (strcmp (arg, "single") == 0)
 501     gfc_option.coarray = GFC_FCOARRAY_SINGLE;
 502   else
 503     gfc_fatal_error ("Argument to -fcoarray is not valid: %s", arg);
 504 }
 505
 506
 507 static void
 508 gfc_handle_runtime_check_option (const char *arg)
 509 {
 510   int result, pos = 0, n;
 511   static const char * const optname[] = { "all", "bounds", "array-temps",
 512                                           "recursion", "do", "pointer",
 513                                           "mem", NULL };
 514   static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,
 515                                  GFC_RTCHECK_ARRAY_TEMPS,
 516                                  GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,
 517                                  GFC_RTCHECK_POINTER, GFC_RTCHECK_MEM,
 518                                  0 };
 519
 520   while (*arg)
 521     {
 522       while (*arg == ',')
 523         arg++;
 524
 525       while (arg[pos] && arg[pos] != ',')
 526         pos++;
 527
 528       result = 0;
 529       for (n = 0; optname[n] != NULL; n++)
 530         {
 531           if (optname[n] && strncmp (optname[n], arg, pos) == 0)
 532             {
 533               gfc_option.rtcheck |= optmask[n];
 534               arg += pos;
 535               pos = 0;
 536               result = 1;
 537               break;
 538             }
 539         }
 540       if (!result)
 541         gfc_fatal_error ("Argument to -fcheck is not valid: %s", arg);
 542     }
 543 }
 544
 545
 546 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
 547    recognized and handled.  */
 548
 549 bool
 550 gfc_handle_option (size_t scode, const char *arg, int value,
 551                    int kind ATTRIBUTE_UNUSED,
 552                    const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
 553 {
 554   bool result = true;
 555   enum opt_code code = (enum opt_code) scode;
 556
 557   if (gfc_cpp_handle_option (scode, arg, value) == 1)
 558     return true;
 559
 560   switch (code)
 561     {
 562     default:
 563       result = false;
 564       break;
 565
 566     case OPT_Wall:
 567       set_Wall (value);
 568       break;
 569
 570     case OPT_Waliasing:
 571       gfc_option.warn_aliasing = value;
 572       break;
 573
 574     case OPT_Wampersand:
 575       gfc_option.warn_ampersand = value;
 576       break;
 577
 578     case OPT_Warray_temporaries:
 579       gfc_option.warn_array_temp = value;
 580       break;
 581
 582     case OPT_Wcharacter_truncation:
 583       gfc_option.warn_character_truncation = value;
 584       break;
 585
 586     case OPT_Wconversion:
 587       gfc_option.gfc_warn_conversion = value;
 588       break;
 589
 590     case OPT_Wconversion_extra:
 591       gfc_option.warn_conversion_extra = value;
 592       break;
 593
 594     case OPT_Wimplicit_interface:
 595       gfc_option.warn_implicit_interface = value;
 596       break;
 597
 598     case OPT_Wimplicit_procedure:
 599       gfc_option.warn_implicit_procedure = value;
 600       break;
 601
 602     case OPT_Wline_truncation:
 603       gfc_option.warn_line_truncation = value;
 604       break;
 605
 606     case OPT_Wreturn_type:
 607       warn_return_type = value;
 608       break;
 609
 610     case OPT_Wsurprising:
 611       gfc_option.warn_surprising = value;
 612       break;
 613
 614     case OPT_Wtabs:
 615       gfc_option.warn_tabs = value;
 616       break;
 617
 618     case OPT_Wunderflow:
 619       gfc_option.warn_underflow = value;
 620       break;
 621
 622     case OPT_Wintrinsic_shadow:
 623       gfc_option.warn_intrinsic_shadow = value;
 624       break;
 625
 626     case OPT_Walign_commons:
 627       gfc_option.warn_align_commons = value;
 628       break;
 629
 630     case OPT_Wunused_dummy_argument:
 631       gfc_option.warn_unused_dummy_argument = value;
 632       break;
 633
 634     case OPT_fall_intrinsics:
 635       gfc_option.flag_all_intrinsics = 1;
 636       break;
 637
 638     case OPT_fautomatic:
 639       gfc_option.flag_automatic = value;
 640       break;
 641
 642     case OPT_fallow_leading_underscore:
 643       gfc_option.flag_allow_leading_underscore = value;
 644       break;
 645
 646     case OPT_fbackslash:
 647       gfc_option.flag_backslash = value;
 648       break;
 649
 650     case OPT_fbacktrace:
 651       gfc_option.flag_backtrace = value;
 652       break;
 653
 654     case OPT_fcheck_array_temporaries:
 655       gfc_option.rtcheck |= GFC_RTCHECK_ARRAY_TEMPS;
 656       break;
 657
 658     case OPT_fdump_core:
 659       gfc_option.flag_dump_core = value;
 660       break;
 661
 662     case OPT_fcray_pointer:
 663       gfc_option.flag_cray_pointer = value;
 664       break;
 665
 666     case OPT_ff2c:
 667       gfc_option.flag_f2c = value;
 668       break;
 669
 670     case OPT_fdollar_ok:
 671       gfc_option.flag_dollar_ok = value;
 672       break;
 673
 674     case OPT_fexternal_blas:
 675       gfc_option.flag_external_blas = value;
 676       break;
 677
 678     case OPT_fblas_matmul_limit_:
 679       gfc_option.blas_matmul_limit = value;
 680       break;
 681
 682     case OPT_fd_lines_as_code:
 683       gfc_option.flag_d_lines = 1;
 684       break;
 685
 686     case OPT_fd_lines_as_comments:
 687       gfc_option.flag_d_lines = 0;
 688       break;
 689
 690     case OPT_fdump_fortran_original:
 691     case OPT_fdump_parse_tree:
 692       gfc_option.dump_fortran_original = value;
 693       break;
 694
 695     case OPT_fdump_fortran_optimized:
 696       gfc_option.dump_fortran_optimized = value;
 697       break;
 698
 699     case OPT_ffixed_form:
 700       gfc_option.source_form = FORM_FIXED;
 701       break;
 702
 703     case OPT_ffixed_line_length_none:
 704       gfc_option.fixed_line_length = 0;
 705       break;
 706
 707     case OPT_ffixed_line_length_:
 708       if (value != 0 && value < 7)
 709         gfc_fatal_error ("Fixed line length must be at least seven.");
 710       gfc_option.fixed_line_length = value;
 711       break;
 712
 713     case OPT_ffree_form:
 714       gfc_option.source_form = FORM_FREE;
 715       break;
 716
 717     case OPT_fopenmp:
 718       gfc_option.gfc_flag_openmp = value;
 719       break;
 720
 721     case OPT_ffree_line_length_none:
 722       gfc_option.free_line_length = 0;
 723       break;
 724
 725     case OPT_ffree_line_length_:
 726       if (value != 0 && value < 4)
 727         gfc_fatal_error ("Free line length must be at least three.");
 728       gfc_option.free_line_length = value;
 729       break;
 730
 731     case OPT_funderscoring:
 732       gfc_option.flag_underscoring = value;
 733       break;
 734
 735     case OPT_fwhole_file:
 736       gfc_option.flag_whole_file = value;
 737       break;
 738
 739     case OPT_fsecond_underscore:
 740       gfc_option.flag_second_underscore = value;
 741       break;
 742
 743     case OPT_static_libgfortran:
 744 #ifndef HAVE_LD_STATIC_DYNAMIC
 745       gfc_fatal_error ("-static-libgfortran is not supported in this "
 746                        "configuration");
 747 #endif
 748       break;
 749
 750     case OPT_fimplicit_none:
 751       gfc_option.flag_implicit_none = value;
 752       break;
 753
 754     case OPT_fintrinsic_modules_path:
 755       gfc_add_include_path (arg, false, false);
 756       gfc_add_intrinsic_modules_path (arg);
 757       break;
 758
 759     case OPT_fmax_array_constructor_:
 760       gfc_option.flag_max_array_constructor = value > 65535 ? value : 65535;
 761       break;
 762
 763     case OPT_fmax_errors_:
 764       gfc_option.max_errors = value;
 765       break;
 766
 767     case OPT_fmax_stack_var_size_:
 768       gfc_option.flag_max_stack_var_size = value;
 769       break;
 770
 771     case OPT_fmodule_private:
 772       gfc_option.flag_module_private = value;
 773       break;
 774
 775     case OPT_frange_check:
 776       gfc_option.flag_range_check = value;
 777       break;
 778
 779     case OPT_fpack_derived:
 780       gfc_option.flag_pack_derived = value;
 781       break;
 782
 783     case OPT_frepack_arrays:
 784       gfc_option.flag_repack_arrays = value;
 785       break;
 786
 787     case OPT_fpreprocessed:
 788       gfc_option.flag_preprocessed = value;
 789       break;
 790
 791     case OPT_fmax_identifier_length_:
 792       if (value > GFC_MAX_SYMBOL_LEN)
 793         gfc_fatal_error ("Maximum supported identifier length is %d",
 794                          GFC_MAX_SYMBOL_LEN);
 795       gfc_option.max_identifier_length = value;
 796       break;
 797
 798     case OPT_fdefault_integer_8:
 799       gfc_option.flag_default_integer = value;
 800       break;
 801
 802     case OPT_fdefault_real_8:
 803       gfc_option.flag_default_real = value;
 804       break;
 805
 806     case OPT_fdefault_double_8:
 807       gfc_option.flag_default_double = value;
 808       break;
 809
 810     case OPT_finit_local_zero:
 811       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 812       gfc_option.flag_init_integer_value = 0;
 813       gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 814       gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 815       gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 816       gfc_option.flag_init_character_value = (char)0;
 817       break;
 818
 819     case OPT_finit_logical_:
 820       if (!strcasecmp (arg, "false"))
 821         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 822       else if (!strcasecmp (arg, "true"))
 823         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
 824       else
 825         gfc_fatal_error ("Unrecognized option to -finit-logical: %s",
 826                          arg);
 827       break;
 828
 829     case OPT_finit_real_:
 830       if (!strcasecmp (arg, "zero"))
 831         gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 832       else if (!strcasecmp (arg, "nan"))
 833         gfc_option.flag_init_real = GFC_INIT_REAL_NAN;
 834       else if (!strcasecmp (arg, "snan"))
 835         gfc_option.flag_init_real = GFC_INIT_REAL_SNAN;
 836       else if (!strcasecmp (arg, "inf"))
 837         gfc_option.flag_init_real = GFC_INIT_REAL_INF;
 838       else if (!strcasecmp (arg, "-inf"))
 839         gfc_option.flag_init_real = GFC_INIT_REAL_NEG_INF;
 840       else
 841         gfc_fatal_error ("Unrecognized option to -finit-real: %s",
 842                          arg);
 843       break;
 844
 845     case OPT_finit_integer_:
 846       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 847       gfc_option.flag_init_integer_value = atoi (arg);
 848       break;
 849
 850     case OPT_finit_character_:
 851       if (value >= 0 && value <= 127)
 852         {
 853           gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 854           gfc_option.flag_init_character_value = (char)value;
 855         }
 856       else
 857         gfc_fatal_error ("The value of n in -finit-character=n must be "
 858                          "between 0 and 127");
 859       break;
 860
 861     case OPT_I:
 862       gfc_add_include_path (arg, true, false);
 863       break;
 864
 865     case OPT_J:
 866       gfc_handle_module_path_options (arg);
 867       break;
 868
 869     case OPT_fsign_zero:
 870       gfc_option.flag_sign_zero = value;
 871       break;
 872
 873     case OPT_ffpe_trap_:
 874       gfc_handle_fpe_trap_option (arg);
 875       break;
 876
 877     case OPT_std_f95:
 878       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77
 879                              | GFC_STD_F2008_OBS;
 880       gfc_option.warn_std = GFC_STD_F95_OBS;
 881       gfc_option.max_continue_fixed = 19;
 882       gfc_option.max_continue_free = 39;
 883       gfc_option.max_identifier_length = 31;
 884       gfc_option.warn_ampersand = 1;
 885       gfc_option.warn_tabs = 0;
 886       break;
 887
 888     case OPT_std_f2003:
 889       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 890         | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008_OBS;
 891       gfc_option.warn_std = GFC_STD_F95_OBS;
 892       gfc_option.max_identifier_length = 63;
 893       gfc_option.warn_ampersand = 1;
 894       gfc_option.warn_tabs = 0;
 895       break;
 896
 897     case OPT_std_f2008:
 898       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 899         | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008 | GFC_STD_F2008_OBS;
 900       gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS;
 901       gfc_option.max_identifier_length = 63;
 902       gfc_option.warn_ampersand = 1;
 903       gfc_option.warn_tabs = 0;
 904       break;
 905
 906     case OPT_std_gnu:
 907       set_default_std_flags ();
 908       break;
 909
 910     case OPT_std_legacy:
 911       set_default_std_flags ();
 912       gfc_option.warn_std = 0;
 913       break;
 914
 915     case OPT_Wintrinsics_std:
 916       gfc_option.warn_intrinsics_std = value;
 917       break;
 918
 919     case OPT_fshort_enums:
 920       /* Handled in language-independent code.  */
 921       break;
 922
 923     case OPT_fconvert_little_endian:
 924       gfc_option.convert = GFC_CONVERT_LITTLE;
 925       break;
 926
 927     case OPT_fconvert_big_endian:
 928       gfc_option.convert = GFC_CONVERT_BIG;
 929       break;
 930
 931     case OPT_fconvert_native:
 932       gfc_option.convert = GFC_CONVERT_NATIVE;
 933       break;
 934
 935     case OPT_fconvert_swap:
 936       gfc_option.convert = GFC_CONVERT_SWAP;
 937       break;
 938
 939     case OPT_frecord_marker_4:
 940       gfc_option.record_marker = 4;
 941       break;
 942
 943     case OPT_frecord_marker_8:
 944       gfc_option.record_marker = 8;
 945       break;
 946
 947     case OPT_fmax_subrecord_length_:
 948       if (value > MAX_SUBRECORD_LENGTH)
 949         gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
 950                          MAX_SUBRECORD_LENGTH);
 951
 952       gfc_option.max_subrecord_length = value;
 953       break;
 954
 955     case OPT_frecursive:
 956       gfc_option.flag_recursive = value;
 957       break;
 958
 959     case OPT_falign_commons:
 960       gfc_option.flag_align_commons = value;
 961       break;
 962
 963     case OPT_fprotect_parens:
 964       gfc_option.flag_protect_parens = value;
 965       break;
 966
 967     case OPT_fcheck_:
 968       gfc_handle_runtime_check_option (arg);
 969       break;
 970
 971     case OPT_fcoarray_:
 972       gfc_handle_coarray_option (arg);
 973       break;
 974     }
 975
 976   return result;
 977 }
 978
 979
 980 /* Return a string with the options passed to the compiler; used for
 981    Fortran's compiler_options() intrinsic.  */
 982
 983 char *
 984 gfc_get_option_string (void)
 985 {
 986   unsigned j;
 987   size_t len, pos;
 988   char *result;
 989
 990   /* Determine required string length.  */
 991
 992   len = 0;
 993   for (j = 1; j < save_decoded_options_count; j++)
 994     {
 995       switch (save_decoded_options[j].opt_index)
 996         {
 997         case OPT_o:
 998         case OPT_d:
 999         case OPT_dumpbase:
1000         case OPT_dumpdir:
1001         case OPT_auxbase:
1002         case OPT_quiet:
1003         case OPT_version:
1004         case OPT_fintrinsic_modules_path:
1005           /* Ignore these.  */
1006           break;
1007         default:
1008           /* Ignore file names. */
1009           if (save_decoded_options[j].orig_option_with_args_text[0] == '-')
1010             len += 1
1011                  + strlen (save_decoded_options[j].orig_option_with_args_text);
1012         }
1013     }
1014
1015   result = (char *) gfc_getmem (len);
1016
1017   pos = 0;
1018   for (j = 1; j < save_decoded_options_count; j++)
1019     {
1020       switch (save_decoded_options[j].opt_index)
1021         {
1022         case OPT_o:
1023         case OPT_d:
1024         case OPT_dumpbase:
1025         case OPT_dumpdir:
1026         case OPT_auxbase:
1027         case OPT_quiet:
1028         case OPT_version:
1029         case OPT_fintrinsic_modules_path:
1030           /* Ignore these.  */
1031           continue;
1032
1033         case OPT_cpp_:
1034           /* Use "-cpp" rather than "-cpp=<temporary file>".  */
1035           len = 4;
1036           break;
1037
1038         default:
1039           /* Ignore file names. */
1040           if (save_decoded_options[j].orig_option_with_args_text[0] != '-')
1041             continue;
1042
1043           len = strlen (save_decoded_options[j].orig_option_with_args_text);
1044         }
1045
1046       memcpy (&result[pos], save_decoded_options[j].orig_option_with_args_text, len);
1047       pos += len;
1048       result[pos++] = ' ';
1049     }
1050
1051   result[--pos] = '\0';
1052   return result;
1053 }