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