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 "options.h"
  31 #include "params.h"
  32 #include "tree-inline.h"
  33 #include "gfortran.h"
  34 #include "target.h"
  35 #include "cpp.h"
  36 #include "toplev.h"
  37 #include "tm.h"
  38
  39 gfc_option_t gfc_option;
  40
  41
  42 /* Set flags that control warnings and errors for different
  43    Fortran standards to their default values.  Keep in sync with
  44    libgfortran/runtime/compile_options.c (init_compile_options).  */
  45
  46 static void
  47 set_default_std_flags (void)
  48 {
  49   gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
  50     | GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
  51     | GFC_STD_GNU | GFC_STD_LEGACY;
  52   gfc_option.warn_std = GFC_STD_F95_DEL | GFC_STD_LEGACY;
  53 }
  54
  55
  56 /* Get ready for options handling. Keep in sync with
  57    libgfortran/runtime/compile_options.c (init_compile_options). */
  58
  59 unsigned int
  60 gfc_init_options (unsigned int argc, const char **argv)
  61 {
  62   gfc_source_file = NULL;
  63   gfc_option.module_dir = NULL;
  64   gfc_option.source_form = FORM_UNKNOWN;
  65   gfc_option.fixed_line_length = 72;
  66   gfc_option.free_line_length = 132;
  67   gfc_option.max_continue_fixed = 255;
  68   gfc_option.max_continue_free = 255;
  69   gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
  70   gfc_option.max_subrecord_length = 0;
  71   gfc_option.flag_max_array_constructor = 65535;
  72   gfc_option.convert = GFC_CONVERT_NATIVE;
  73   gfc_option.record_marker = 0;
  74   gfc_option.dump_parse_tree = 0;
  75
  76   gfc_option.warn_aliasing = 0;
  77   gfc_option.warn_ampersand = 0;
  78   gfc_option.warn_character_truncation = 0;
  79   gfc_option.warn_array_temp = 0;
  80   gfc_option.warn_conversion = 0;
  81   gfc_option.warn_implicit_interface = 0;
  82   gfc_option.warn_line_truncation = 0;
  83   gfc_option.warn_surprising = 0;
  84   gfc_option.warn_tabs = 1;
  85   gfc_option.warn_underflow = 1;
  86   gfc_option.warn_intrinsic_shadow = 0;
  87   gfc_option.warn_intrinsics_std = 0;
  88   gfc_option.warn_align_commons = 1;
  89   gfc_option.max_errors = 25;
  90
  91   gfc_option.flag_all_intrinsics = 0;
  92   gfc_option.flag_default_double = 0;
  93   gfc_option.flag_default_integer = 0;
  94   gfc_option.flag_default_real = 0;
  95   gfc_option.flag_dollar_ok = 0;
  96   gfc_option.flag_underscoring = 1;
  97   gfc_option.flag_whole_file = 0;
  98   gfc_option.flag_f2c = 0;
  99   gfc_option.flag_second_underscore = -1;
 100   gfc_option.flag_implicit_none = 0;
 101
 102   /* Default value of flag_max_stack_var_size is set in gfc_post_options.  */
 103   gfc_option.flag_max_stack_var_size = -2;
 104
 105   gfc_option.flag_range_check = 1;
 106   gfc_option.flag_pack_derived = 0;
 107   gfc_option.flag_repack_arrays = 0;
 108   gfc_option.flag_preprocessed = 0;
 109   gfc_option.flag_automatic = 1;
 110   gfc_option.flag_backslash = 0;
 111   gfc_option.flag_module_private = 0;
 112   gfc_option.flag_backtrace = 0;
 113   gfc_option.flag_allow_leading_underscore = 0;
 114   gfc_option.flag_dump_core = 0;
 115   gfc_option.flag_external_blas = 0;
 116   gfc_option.blas_matmul_limit = 30;
 117   gfc_option.flag_cray_pointer = 0;
 118   gfc_option.flag_d_lines = -1;
 119   gfc_option.flag_openmp = 0;
 120   gfc_option.flag_sign_zero = 1;
 121   gfc_option.flag_recursive = 0;
 122   gfc_option.flag_init_integer = GFC_INIT_INTEGER_OFF;
 123   gfc_option.flag_init_integer_value = 0;
 124   gfc_option.flag_init_real = GFC_INIT_REAL_OFF;
 125   gfc_option.flag_init_logical = GFC_INIT_LOGICAL_OFF;
 126   gfc_option.flag_init_character = GFC_INIT_CHARACTER_OFF;
 127   gfc_option.flag_init_character_value = (char)0;
 128   gfc_option.flag_align_commons = 1;
 129   gfc_option.flag_protect_parens = 1;
 130
 131   gfc_option.fpe = 0;
 132   gfc_option.rtcheck = 0;
 133   gfc_option.coarray = GFC_FCOARRAY_NONE;
 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   /* Implement -frecursive as -fmax-stack-var-size=-1.  */
 357   if (gfc_option.flag_recursive)
 358     gfc_option.flag_max_stack_var_size = -1;
 359
 360   /* Implied -frecursive; implemented as -fmax-stack-var-size=-1.  */
 361   if (gfc_option.flag_max_stack_var_size == -2 && gfc_option.flag_openmp
 362       && gfc_option.flag_automatic)
 363     {
 364       gfc_option.flag_recursive = 1;
 365       gfc_option.flag_max_stack_var_size = -1;
 366     }
 367
 368   /* Set default.  */
 369   if (gfc_option.flag_max_stack_var_size == -2)
 370     gfc_option.flag_max_stack_var_size = 32768;
 371
 372   /* Implement -fno-automatic as -fmax-stack-var-size=0.  */
 373   if (!gfc_option.flag_automatic)
 374     gfc_option.flag_max_stack_var_size = 0;
 375
 376   if (pedantic)
 377     {
 378       gfc_option.warn_ampersand = 1;
 379       gfc_option.warn_tabs = 0;
 380     }
 381
 382   if (pedantic && gfc_option.flag_whole_file)
 383     gfc_option.flag_whole_file = 2;
 384
 385   gfc_cpp_post_options ();
 386
 387 /* FIXME: return gfc_cpp_preprocess_only ();
 388
 389    The return value of this function indicates whether the
 390    backend needs to be initialized. On -E, we don't need
 391    the backend. However, if we return 'true' here, an
 392    ICE occurs. Initializing the backend doesn't hurt much,
 393    hence, for now we can live with it as is.  */
 394   return false;
 395 }
 396
 397
 398 /* Set the options for -Wall.  */
 399
 400 static void
 401 set_Wall (int setting)
 402 {
 403   gfc_option.warn_aliasing = setting;
 404   gfc_option.warn_ampersand = setting;
 405   gfc_option.warn_line_truncation = setting;
 406   gfc_option.warn_surprising = setting;
 407   gfc_option.warn_tabs = !setting;
 408   gfc_option.warn_underflow = setting;
 409   gfc_option.warn_intrinsic_shadow = setting;
 410   gfc_option.warn_intrinsics_std = setting;
 411   gfc_option.warn_character_truncation = setting;
 412
 413   warn_unused = setting;
 414   warn_return_type = setting;
 415   warn_switch = setting;
 416
 417   /* We save the value of warn_uninitialized, since if they put
 418      -Wuninitialized on the command line, we need to generate a
 419      warning about not using it without also specifying -O.  */
 420   if (setting == 0)
 421     warn_uninitialized = 0;
 422   else if (warn_uninitialized != 1)
 423     warn_uninitialized = 2;
 424 }
 425
 426
 427 static void
 428 gfc_handle_module_path_options (const char *arg)
 429 {
 430
 431   if (gfc_option.module_dir != NULL)
 432     gfc_fatal_error ("gfortran: Only one -J option allowed");
 433
 434   gfc_option.module_dir = (char *) gfc_getmem (strlen (arg) + 2);
 435   strcpy (gfc_option.module_dir, arg);
 436   strcat (gfc_option.module_dir, "/");
 437
 438   gfc_add_include_path (gfc_option.module_dir, true, false);
 439 }
 440
 441
 442 static void
 443 gfc_handle_fpe_trap_option (const char *arg)
 444 {
 445   int result, pos = 0, n;
 446   static const char * const exception[] = { "invalid", "denormal", "zero",
 447                                             "overflow", "underflow",
 448                                             "precision", NULL };
 449   static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
 450                                        GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
 451                                        GFC_FPE_UNDERFLOW, GFC_FPE_PRECISION,
 452                                        0 };
 453
 454   while (*arg)
 455     {
 456       while (*arg == ',')
 457         arg++;
 458
 459       while (arg[pos] && arg[pos] != ',')
 460         pos++;
 461
 462       result = 0;
 463       for (n = 0; exception[n] != NULL; n++)
 464         {
 465           if (exception[n] && strncmp (exception[n], arg, pos) == 0)
 466             {
 467               gfc_option.fpe |= opt_exception[n];
 468               arg += pos;
 469               pos = 0;
 470               result = 1;
 471               break;
 472             }
 473         }
 474       if (!result)
 475         gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
 476     }
 477 }
 478
 479
 480 static void
 481 gfc_handle_coarray_option (const char *arg)
 482 {
 483   if (strcmp (arg, "none") == 0)
 484     gfc_option.coarray = GFC_FCOARRAY_NONE;
 485   else if (strcmp (arg, "single") == 0)
 486     gfc_option.coarray = GFC_FCOARRAY_SINGLE;
 487   else
 488     gfc_fatal_error ("Argument to -fcoarray is not valid: %s", arg);
 489 }
 490
 491
 492 static void
 493 gfc_handle_runtime_check_option (const char *arg)
 494 {
 495   int result, pos = 0, n;
 496   static const char * const optname[] = { "all", "bounds", "array-temps",
 497                                           "recursion", "do", "pointer",
 498                                           "mem", NULL };
 499   static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,
 500                                  GFC_RTCHECK_ARRAY_TEMPS,
 501                                  GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,
 502                                  GFC_RTCHECK_POINTER, GFC_RTCHECK_MEM,
 503                                  0 };
 504
 505   while (*arg)
 506     {
 507       while (*arg == ',')
 508         arg++;
 509
 510       while (arg[pos] && arg[pos] != ',')
 511         pos++;
 512
 513       result = 0;
 514       for (n = 0; optname[n] != NULL; n++)
 515         {
 516           if (optname[n] && strncmp (optname[n], arg, pos) == 0)
 517             {
 518               gfc_option.rtcheck |= optmask[n];
 519               arg += pos;
 520               pos = 0;
 521               result = 1;
 522               break;
 523             }
 524         }
 525       if (!result)
 526         gfc_fatal_error ("Argument to -fcheck is not valid: %s", arg);
 527     }
 528 }
 529
 530
 531 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
 532    recognized and handled.  */
 533
 534 int
 535 gfc_handle_option (size_t scode, const char *arg, int value)
 536 {
 537   int result = 1;
 538   enum opt_code code = (enum opt_code) scode;
 539
 540   /* Ignore file names.  */
 541   if (code == N_OPTS)
 542     return 1;
 543
 544   if (gfc_cpp_handle_option (scode, arg, value) == 1)
 545     return 1;
 546
 547   switch (code)
 548     {
 549     default:
 550       result = 0;
 551       break;
 552
 553     case OPT_Wall:
 554       set_Wall (value);
 555       break;
 556
 557     case OPT_Waliasing:
 558       gfc_option.warn_aliasing = value;
 559       break;
 560
 561     case OPT_Wampersand:
 562       gfc_option.warn_ampersand = value;
 563       break;
 564
 565     case OPT_Warray_temporaries:
 566       gfc_option.warn_array_temp = value;
 567       break;
 568
 569     case OPT_Wcharacter_truncation:
 570       gfc_option.warn_character_truncation = value;
 571       break;
 572
 573     case OPT_Wconversion:
 574       gfc_option.warn_conversion = value;
 575       break;
 576
 577     case OPT_Wimplicit_interface:
 578       gfc_option.warn_implicit_interface = value;
 579       break;
 580
 581     case OPT_Wimplicit_procedure:
 582       gfc_option.warn_implicit_procedure = value;
 583       break;
 584
 585     case OPT_Wline_truncation:
 586       gfc_option.warn_line_truncation = value;
 587       break;
 588
 589     case OPT_Wreturn_type:
 590       warn_return_type = value;
 591       break;
 592
 593     case OPT_Wsurprising:
 594       gfc_option.warn_surprising = value;
 595       break;
 596
 597     case OPT_Wtabs:
 598       gfc_option.warn_tabs = value;
 599       break;
 600
 601     case OPT_Wunderflow:
 602       gfc_option.warn_underflow = value;
 603       break;
 604
 605     case OPT_Wintrinsic_shadow:
 606       gfc_option.warn_intrinsic_shadow = value;
 607       break;
 608
 609     case OPT_Walign_commons:
 610       gfc_option.warn_align_commons = value;
 611       break;
 612
 613     case OPT_fall_intrinsics:
 614       gfc_option.flag_all_intrinsics = 1;
 615       break;
 616
 617     case OPT_fautomatic:
 618       gfc_option.flag_automatic = value;
 619       break;
 620
 621     case OPT_fallow_leading_underscore:
 622       gfc_option.flag_allow_leading_underscore = value;
 623       break;
 624
 625     case OPT_fbackslash:
 626       gfc_option.flag_backslash = value;
 627       break;
 628
 629     case OPT_fbacktrace:
 630       gfc_option.flag_backtrace = value;
 631       break;
 632
 633     case OPT_fcheck_array_temporaries:
 634       gfc_option.rtcheck |= GFC_RTCHECK_ARRAY_TEMPS;
 635       break;
 636
 637     case OPT_fdump_core:
 638       gfc_option.flag_dump_core = value;
 639       break;
 640
 641     case OPT_fcray_pointer:
 642       gfc_option.flag_cray_pointer = value;
 643       break;
 644
 645     case OPT_ff2c:
 646       gfc_option.flag_f2c = value;
 647       break;
 648
 649     case OPT_fdollar_ok:
 650       gfc_option.flag_dollar_ok = value;
 651       break;
 652
 653     case OPT_fexternal_blas:
 654       gfc_option.flag_external_blas = value;
 655       break;
 656
 657     case OPT_fblas_matmul_limit_:
 658       gfc_option.blas_matmul_limit = value;
 659       break;
 660
 661     case OPT_fd_lines_as_code:
 662       gfc_option.flag_d_lines = 1;
 663       break;
 664
 665     case OPT_fd_lines_as_comments:
 666       gfc_option.flag_d_lines = 0;
 667       break;
 668
 669     case OPT_fdump_parse_tree:
 670       gfc_option.dump_parse_tree = value;
 671       break;
 672
 673     case OPT_ffixed_form:
 674       gfc_option.source_form = FORM_FIXED;
 675       break;
 676
 677     case OPT_ffixed_line_length_none:
 678       gfc_option.fixed_line_length = 0;
 679       break;
 680
 681     case OPT_ffixed_line_length_:
 682       if (value != 0 && value < 7)
 683         gfc_fatal_error ("Fixed line length must be at least seven.");
 684       gfc_option.fixed_line_length = value;
 685       break;
 686
 687     case OPT_ffree_form:
 688       gfc_option.source_form = FORM_FREE;
 689       break;
 690
 691     case OPT_fopenmp:
 692       gfc_option.flag_openmp = value;
 693       break;
 694
 695     case OPT_ffree_line_length_none:
 696       gfc_option.free_line_length = 0;
 697       break;
 698
 699     case OPT_ffree_line_length_:
 700       if (value != 0 && value < 4)
 701         gfc_fatal_error ("Free line length must be at least three.");
 702       gfc_option.free_line_length = value;
 703       break;
 704
 705     case OPT_funderscoring:
 706       gfc_option.flag_underscoring = value;
 707       break;
 708
 709     case OPT_fwhole_file:
 710       gfc_option.flag_whole_file = 1;
 711       break;
 712
 713     case OPT_fsecond_underscore:
 714       gfc_option.flag_second_underscore = value;
 715       break;
 716
 717     case OPT_static_libgfortran:
 718 #ifndef HAVE_LD_STATIC_DYNAMIC
 719       gfc_fatal_error ("-static-libgfortran is not supported in this "
 720                        "configuration");
 721 #endif
 722       break;
 723
 724     case OPT_fimplicit_none:
 725       gfc_option.flag_implicit_none = value;
 726       break;
 727
 728     case OPT_fintrinsic_modules_path:
 729       gfc_add_include_path (arg, false, false);
 730       gfc_add_intrinsic_modules_path (arg);
 731       break;
 732
 733     case OPT_fmax_array_constructor_:
 734       gfc_option.flag_max_array_constructor = value > 65535 ? value : 65535;
 735       break;
 736
 737     case OPT_fmax_errors_:
 738       gfc_option.max_errors = value;
 739       break;
 740
 741     case OPT_fmax_stack_var_size_:
 742       gfc_option.flag_max_stack_var_size = value;
 743       break;
 744
 745     case OPT_fmodule_private:
 746       gfc_option.flag_module_private = value;
 747       break;
 748
 749     case OPT_frange_check:
 750       gfc_option.flag_range_check = value;
 751       break;
 752
 753     case OPT_fpack_derived:
 754       gfc_option.flag_pack_derived = value;
 755       break;
 756
 757     case OPT_frepack_arrays:
 758       gfc_option.flag_repack_arrays = value;
 759       break;
 760
 761     case OPT_fpreprocessed:
 762       gfc_option.flag_preprocessed = value;
 763       break;
 764
 765     case OPT_fmax_identifier_length_:
 766       if (value > GFC_MAX_SYMBOL_LEN)
 767         gfc_fatal_error ("Maximum supported identifier length is %d",
 768                          GFC_MAX_SYMBOL_LEN);
 769       gfc_option.max_identifier_length = value;
 770       break;
 771
 772     case OPT_fdefault_integer_8:
 773       gfc_option.flag_default_integer = value;
 774       break;
 775
 776     case OPT_fdefault_real_8:
 777       gfc_option.flag_default_real = value;
 778       break;
 779
 780     case OPT_fdefault_double_8:
 781       gfc_option.flag_default_double = value;
 782       break;
 783
 784     case OPT_finit_local_zero:
 785       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 786       gfc_option.flag_init_integer_value = 0;
 787       gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 788       gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 789       gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 790       gfc_option.flag_init_character_value = (char)0;
 791       break;
 792
 793     case OPT_finit_logical_:
 794       if (!strcasecmp (arg, "false"))
 795         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 796       else if (!strcasecmp (arg, "true"))
 797         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
 798       else
 799         gfc_fatal_error ("Unrecognized option to -finit-logical: %s",
 800                          arg);
 801       break;
 802
 803     case OPT_finit_real_:
 804       if (!strcasecmp (arg, "zero"))
 805         gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 806       else if (!strcasecmp (arg, "nan"))
 807         gfc_option.flag_init_real = GFC_INIT_REAL_NAN;
 808       else if (!strcasecmp (arg, "snan"))
 809         gfc_option.flag_init_real = GFC_INIT_REAL_SNAN;
 810       else if (!strcasecmp (arg, "inf"))
 811         gfc_option.flag_init_real = GFC_INIT_REAL_INF;
 812       else if (!strcasecmp (arg, "-inf"))
 813         gfc_option.flag_init_real = GFC_INIT_REAL_NEG_INF;
 814       else
 815         gfc_fatal_error ("Unrecognized option to -finit-real: %s",
 816                          arg);
 817       break;
 818
 819     case OPT_finit_integer_:
 820       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 821       gfc_option.flag_init_integer_value = atoi (arg);
 822       break;
 823
 824     case OPT_finit_character_:
 825       if (value >= 0 && value <= 127)
 826         {
 827           gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 828           gfc_option.flag_init_character_value = (char)value;
 829         }
 830       else
 831         gfc_fatal_error ("The value of n in -finit-character=n must be "
 832                          "between 0 and 127");
 833       break;
 834
 835     case OPT_I:
 836       gfc_add_include_path (arg, true, false);
 837       break;
 838
 839     case OPT_J:
 840       gfc_handle_module_path_options (arg);
 841       break;
 842
 843     case OPT_fsign_zero:
 844       gfc_option.flag_sign_zero = value;
 845       break;
 846
 847     case OPT_ffpe_trap_:
 848       gfc_handle_fpe_trap_option (arg);
 849       break;
 850
 851     case OPT_std_f95:
 852       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77;
 853       gfc_option.warn_std = GFC_STD_F95_OBS;
 854       gfc_option.max_continue_fixed = 19;
 855       gfc_option.max_continue_free = 39;
 856       gfc_option.max_identifier_length = 31;
 857       gfc_option.warn_ampersand = 1;
 858       gfc_option.warn_tabs = 0;
 859       break;
 860
 861     case OPT_std_f2003:
 862       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 863         | GFC_STD_F2003 | GFC_STD_F95;
 864       gfc_option.warn_std = GFC_STD_F95_OBS;
 865       gfc_option.max_identifier_length = 63;
 866       gfc_option.warn_ampersand = 1;
 867       gfc_option.warn_tabs = 0;
 868       break;
 869
 870     case OPT_std_f2008:
 871       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 872         | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008;
 873       gfc_option.warn_std = GFC_STD_F95_OBS;
 874       gfc_option.max_identifier_length = 63;
 875       gfc_option.warn_ampersand = 1;
 876       gfc_option.warn_tabs = 0;
 877       break;
 878
 879     case OPT_std_gnu:
 880       set_default_std_flags ();
 881       break;
 882
 883     case OPT_std_legacy:
 884       set_default_std_flags ();
 885       gfc_option.warn_std = 0;
 886       break;
 887
 888     case OPT_Wintrinsics_std:
 889       gfc_option.warn_intrinsics_std = value;
 890       break;
 891
 892     case OPT_fshort_enums:
 893       flag_short_enums = 1;
 894       break;
 895
 896     case OPT_fconvert_little_endian:
 897       gfc_option.convert = GFC_CONVERT_LITTLE;
 898       break;
 899
 900     case OPT_fconvert_big_endian:
 901       gfc_option.convert = GFC_CONVERT_BIG;
 902       break;
 903
 904     case OPT_fconvert_native:
 905       gfc_option.convert = GFC_CONVERT_NATIVE;
 906       break;
 907
 908     case OPT_fconvert_swap:
 909       gfc_option.convert = GFC_CONVERT_SWAP;
 910       break;
 911
 912     case OPT_frecord_marker_4:
 913       gfc_option.record_marker = 4;
 914       break;
 915
 916     case OPT_frecord_marker_8:
 917       gfc_option.record_marker = 8;
 918       break;
 919
 920     case OPT_fmax_subrecord_length_:
 921       if (value > MAX_SUBRECORD_LENGTH)
 922         gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
 923                          MAX_SUBRECORD_LENGTH);
 924
 925       gfc_option.max_subrecord_length = value;
 926       break;
 927
 928     case OPT_frecursive:
 929       gfc_option.flag_recursive = 1;
 930       break;
 931
 932     case OPT_falign_commons:
 933       gfc_option.flag_align_commons = value;
 934       break;
 935
 936     case OPT_fprotect_parens:
 937       gfc_option.flag_protect_parens = value;
 938       break;
 939
 940     case OPT_fcheck_:
 941       gfc_handle_runtime_check_option (arg);
 942       break;
 943
 944     case OPT_fcoarray_:
 945       gfc_handle_coarray_option (arg);
 946       break;
 947     }
 948
 949   return result;
 950 }