gcc/fortran/options.c

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