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