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   /* -fbounds-check is equivalent to -fcheck=bounds */
 246   if (flag_bounds_check)
 247     gfc_option.rtcheck |= GFC_RTCHECK_BOUNDS;
 248
 249   if (flag_compare_debug)
 250     gfc_option.dump_parse_tree = 0;
 251
 252   /* Verify the input file name.  */
 253   if (!filename || strcmp (filename, "-") == 0)
 254     {
 255       filename = "";
 256     }
 257
 258   if (gfc_option.flag_preprocessed)
 259     {
 260       /* For preprocessed files, if the first tokens are of the form # NUM.
 261          handle the directives so we know the original file name.  */
 262       gfc_source_file = gfc_read_orig_filename (filename, &canon_source_file);
 263       if (gfc_source_file == NULL)
 264         gfc_source_file = filename;
 265       else
 266         *pfilename = gfc_source_file;
 267     }
 268   else
 269     gfc_source_file = filename;
 270
 271   if (canon_source_file == NULL)
 272     canon_source_file = gfc_source_file;
 273
 274   /* Adds the path where the source file is to the list of include files.  */
 275
 276   i = strlen (canon_source_file);
 277   while (i > 0 && !IS_DIR_SEPARATOR (canon_source_file[i]))
 278     i--;
 279
 280   if (i != 0)
 281     {
 282       source_path = (char *) alloca (i + 1);
 283       memcpy (source_path, canon_source_file, i);
 284       source_path[i] = 0;
 285       gfc_add_include_path (source_path, true, true);
 286     }
 287   else
 288     gfc_add_include_path (".", true, true);
 289
 290   if (canon_source_file != gfc_source_file)
 291     gfc_free (CONST_CAST (char *, canon_source_file));
 292
 293   /* Decide which form the file will be read in as.  */
 294
 295   if (gfc_option.source_form != FORM_UNKNOWN)
 296     gfc_current_form = gfc_option.source_form;
 297   else
 298     {
 299       gfc_current_form = form_from_filename (filename);
 300
 301       if (gfc_current_form == FORM_UNKNOWN)
 302         {
 303           gfc_current_form = FORM_FREE;
 304           gfc_warning_now ("Reading file '%s' as free form",
 305                            (filename[0] == '\0') ? "<stdin>" : filename);
 306         }
 307     }
 308
 309   /* If the user specified -fd-lines-as-{code|comments} verify that we're
 310      in fixed form.  */
 311   if (gfc_current_form == FORM_FREE)
 312     {
 313       if (gfc_option.flag_d_lines == 0)
 314         gfc_warning_now ("'-fd-lines-as-comments' has no effect "
 315                          "in free form");
 316       else if (gfc_option.flag_d_lines == 1)
 317         gfc_warning_now ("'-fd-lines-as-code' has no effect in free form");
 318     }
 319
 320   /* If -pedantic, warn about the use of GNU extensions.  */
 321   if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)
 322     gfc_option.warn_std |= GFC_STD_GNU;
 323   /* -std=legacy -pedantic is effectively -std=gnu.  */
 324   if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)
 325     gfc_option.warn_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_LEGACY;
 326
 327   /* If the user didn't explicitly specify -f(no)-second-underscore we
 328      use it if we're trying to be compatible with f2c, and not
 329      otherwise.  */
 330   if (gfc_option.flag_second_underscore == -1)
 331     gfc_option.flag_second_underscore = gfc_option.flag_f2c;
 332
 333   if (!gfc_option.flag_automatic && gfc_option.flag_max_stack_var_size != -2
 334       && gfc_option.flag_max_stack_var_size != 0)
 335     gfc_warning_now ("Flag -fno-automatic overwrites -fmax-stack-var-size=%d",
 336                      gfc_option.flag_max_stack_var_size);
 337   else if (!gfc_option.flag_automatic && gfc_option.flag_recursive)
 338     gfc_warning_now ("Flag -fno-automatic overwrites -frecursive");
 339   else if (!gfc_option.flag_automatic && gfc_option.flag_openmp)
 340     gfc_warning_now ("Flag -fno-automatic overwrites -frecursive implied by "
 341                      "-fopenmp");
 342   else if (gfc_option.flag_max_stack_var_size != -2
 343            && gfc_option.flag_recursive)
 344     gfc_warning_now ("Flag -frecursive overwrites -fmax-stack-var-size=%d",
 345                      gfc_option.flag_max_stack_var_size);
 346   else if (gfc_option.flag_max_stack_var_size != -2
 347            && gfc_option.flag_openmp)
 348     gfc_warning_now ("Flag -fmax-stack-var-size=%d overwrites -frecursive "
 349                      "implied by -fopenmp",
 350                      gfc_option.flag_max_stack_var_size);
 351
 352   /* Implied -frecursive; implemented as -fmax-stack-var-size=-1.  */
 353   if (gfc_option.flag_max_stack_var_size == -2 && gfc_option.flag_openmp)
 354     gfc_option.flag_max_stack_var_size = -1;
 355
 356   /* Set default.  */
 357   if (gfc_option.flag_max_stack_var_size == -2)
 358     gfc_option.flag_max_stack_var_size = 32768;
 359
 360   /* Implement -frecursive as -fmax-stack-var-size=-1.  */
 361   if (gfc_option.flag_recursive)
 362     gfc_option.flag_max_stack_var_size = -1;
 363
 364   /* Implement -fno-automatic as -fmax-stack-var-size=0.  */
 365   if (!gfc_option.flag_automatic)
 366     gfc_option.flag_max_stack_var_size = 0;
 367
 368   if (pedantic)
 369     {
 370       gfc_option.warn_ampersand = 1;
 371       gfc_option.warn_tabs = 0;
 372     }
 373
 374   gfc_cpp_post_options ();
 375
 376 /* FIXME: return gfc_cpp_preprocess_only ();
 377
 378    The return value of this function indicates whether the
 379    backend needs to be initialized. On -E, we don't need
 380    the backend. However, if we return 'true' here, an
 381    ICE occurs. Initializing the backend doesn't hurt much,
 382    hence, for now we can live with it as is.  */
 383   return false;
 384 }
 385
 386
 387 /* Set the options for -Wall.  */
 388
 389 static void
 390 set_Wall (int setting)
 391 {
 392   gfc_option.warn_aliasing = setting;
 393   gfc_option.warn_ampersand = setting;
 394   gfc_option.warn_line_truncation = setting;
 395   gfc_option.warn_surprising = setting;
 396   gfc_option.warn_tabs = !setting;
 397   gfc_option.warn_underflow = setting;
 398   gfc_option.warn_intrinsic_shadow = setting;
 399   gfc_option.warn_intrinsics_std = setting;
 400   gfc_option.warn_character_truncation = setting;
 401
 402   warn_unused = setting;
 403   warn_return_type = setting;
 404   warn_switch = setting;
 405
 406   /* We save the value of warn_uninitialized, since if they put
 407      -Wuninitialized on the command line, we need to generate a
 408      warning about not using it without also specifying -O.  */
 409   if (setting == 0)
 410     warn_uninitialized = 0;
 411   else if (warn_uninitialized != 1)
 412     warn_uninitialized = 2;
 413 }
 414
 415
 416 static void
 417 gfc_handle_module_path_options (const char *arg)
 418 {
 419
 420   if (gfc_option.module_dir != NULL)
 421     gfc_fatal_error ("gfortran: Only one -J option allowed");
 422
 423   gfc_option.module_dir = (char *) gfc_getmem (strlen (arg) + 2);
 424   strcpy (gfc_option.module_dir, arg);
 425   strcat (gfc_option.module_dir, "/");
 426
 427   gfc_add_include_path (gfc_option.module_dir, true, false);
 428 }
 429
 430
 431 static void
 432 gfc_handle_fpe_trap_option (const char *arg)
 433 {
 434   int result, pos = 0, n;
 435   static const char * const exception[] = { "invalid", "denormal", "zero",
 436                                             "overflow", "underflow",
 437                                             "precision", NULL };
 438   static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
 439                                        GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
 440                                        GFC_FPE_UNDERFLOW, GFC_FPE_PRECISION,
 441                                        0 };
 442
 443   while (*arg)
 444     {
 445       while (*arg == ',')
 446         arg++;
 447
 448       while (arg[pos] && arg[pos] != ',')
 449         pos++;
 450
 451       result = 0;
 452       for (n = 0; exception[n] != NULL; n++)
 453         {
 454           if (exception[n] && strncmp (exception[n], arg, pos) == 0)
 455             {
 456               gfc_option.fpe |= opt_exception[n];
 457               arg += pos;
 458               pos = 0;
 459               result = 1;
 460               break;
 461             }
 462         }
 463       if (!result)
 464         gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
 465     }
 466 }
 467
 468
 469 static void
 470 gfc_handle_runtime_check_option (const char *arg)
 471 {
 472   int result, pos = 0, n;
 473   static const char * const optname[] = { "all", "bounds", "array-temps",
 474                                           "recursion", "do", NULL };
 475   static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,
 476                                  GFC_RTCHECK_ARRAY_TEMPS,
 477                                  GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,
 478                                  0 };
 479
 480   while (*arg)
 481     {
 482       while (*arg == ',')
 483         arg++;
 484
 485       while (arg[pos] && arg[pos] != ',')
 486         pos++;
 487
 488       result = 0;
 489       for (n = 0; optname[n] != NULL; n++)
 490         {
 491           if (optname[n] && strncmp (optname[n], arg, pos) == 0)
 492             {
 493               gfc_option.rtcheck |= optmask[n];
 494               arg += pos;
 495               pos = 0;
 496               result = 1;
 497               break;
 498             }
 499         }
 500       if (!result)
 501         gfc_fatal_error ("Argument to -fcheck is not valid: %s", arg);
 502     }
 503 }
 504
 505
 506 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
 507    recognized and handled.  */
 508
 509 int
 510 gfc_handle_option (size_t scode, const char *arg, int value)
 511 {
 512   int result = 1;
 513   enum opt_code code = (enum opt_code) scode;
 514
 515   /* Ignore file names.  */
 516   if (code == N_OPTS)
 517     return 1;
 518
 519   if (gfc_cpp_handle_option (scode, arg, value) == 1)
 520     return 1;
 521
 522   switch (code)
 523     {
 524     default:
 525       result = 0;
 526       break;
 527
 528     case OPT_Wall:
 529       set_Wall (value);
 530       break;
 531
 532     case OPT_Waliasing:
 533       gfc_option.warn_aliasing = value;
 534       break;
 535
 536     case OPT_Wampersand:
 537       gfc_option.warn_ampersand = value;
 538       break;
 539
 540     case OPT_Warray_temporaries:
 541       gfc_option.warn_array_temp = value;
 542       break;
 543
 544     case OPT_Wcharacter_truncation:
 545       gfc_option.warn_character_truncation = value;
 546       break;
 547
 548     case OPT_Wconversion:
 549       gfc_option.warn_conversion = value;
 550       break;
 551
 552     case OPT_Wimplicit_interface:
 553       gfc_option.warn_implicit_interface = value;
 554       break;
 555
 556     case OPT_Wline_truncation:
 557       gfc_option.warn_line_truncation = value;
 558       break;
 559
 560     case OPT_Wreturn_type:
 561       warn_return_type = value;
 562       break;
 563
 564     case OPT_Wsurprising:
 565       gfc_option.warn_surprising = value;
 566       break;
 567
 568     case OPT_Wtabs:
 569       gfc_option.warn_tabs = value;
 570       break;
 571
 572     case OPT_Wunderflow:
 573       gfc_option.warn_underflow = value;
 574       break;
 575
 576     case OPT_Wintrinsic_shadow:
 577       gfc_option.warn_intrinsic_shadow = value;
 578       break;
 579
 580     case OPT_Walign_commons:
 581       gfc_option.warn_align_commons = value;
 582       break;
 583
 584     case OPT_fall_intrinsics:
 585       gfc_option.flag_all_intrinsics = 1;
 586       break;
 587
 588     case OPT_fautomatic:
 589       gfc_option.flag_automatic = value;
 590       break;
 591
 592     case OPT_fallow_leading_underscore:
 593       gfc_option.flag_allow_leading_underscore = value;
 594       break;
 595
 596     case OPT_fbackslash:
 597       gfc_option.flag_backslash = value;
 598       break;
 599
 600     case OPT_fbacktrace:
 601       gfc_option.flag_backtrace = value;
 602       break;
 603
 604     case OPT_fcheck_array_temporaries:
 605       gfc_option.rtcheck |= GFC_RTCHECK_ARRAY_TEMPS;
 606       break;
 607
 608     case OPT_fdump_core:
 609       gfc_option.flag_dump_core = value;
 610       break;
 611
 612     case OPT_fcray_pointer:
 613       gfc_option.flag_cray_pointer = value;
 614       break;
 615
 616     case OPT_ff2c:
 617       gfc_option.flag_f2c = value;
 618       break;
 619
 620     case OPT_fdollar_ok:
 621       gfc_option.flag_dollar_ok = value;
 622       break;
 623
 624     case OPT_fexternal_blas:
 625       gfc_option.flag_external_blas = value;
 626       break;
 627
 628     case OPT_fblas_matmul_limit_:
 629       gfc_option.blas_matmul_limit = value;
 630       break;
 631
 632     case OPT_fd_lines_as_code:
 633       gfc_option.flag_d_lines = 1;
 634       break;
 635
 636     case OPT_fd_lines_as_comments:
 637       gfc_option.flag_d_lines = 0;
 638       break;
 639
 640     case OPT_fdump_parse_tree:
 641       gfc_option.dump_parse_tree = value;
 642       break;
 643
 644     case OPT_ffixed_form:
 645       gfc_option.source_form = FORM_FIXED;
 646       break;
 647
 648     case OPT_ffixed_line_length_none:
 649       gfc_option.fixed_line_length = 0;
 650       break;
 651
 652     case OPT_ffixed_line_length_:
 653       if (value != 0 && value < 7)
 654         gfc_fatal_error ("Fixed line length must be at least seven.");
 655       gfc_option.fixed_line_length = value;
 656       break;
 657
 658     case OPT_ffree_form:
 659       gfc_option.source_form = FORM_FREE;
 660       break;
 661
 662     case OPT_fopenmp:
 663       gfc_option.flag_openmp = value;
 664       break;
 665
 666     case OPT_ffree_line_length_none:
 667       gfc_option.free_line_length = 0;
 668       break;
 669
 670     case OPT_ffree_line_length_:
 671       if (value != 0 && value < 4)
 672         gfc_fatal_error ("Free line length must be at least three.");
 673       gfc_option.free_line_length = value;
 674       break;
 675
 676     case OPT_funderscoring:
 677       gfc_option.flag_underscoring = value;
 678       break;
 679
 680     case OPT_fwhole_file:
 681       gfc_option.flag_whole_file = 1;
 682       break;
 683
 684     case OPT_fsecond_underscore:
 685       gfc_option.flag_second_underscore = value;
 686       break;
 687
 688     case OPT_static_libgfortran:
 689 #ifndef HAVE_LD_STATIC_DYNAMIC
 690       gfc_fatal_error ("-static-libgfortran is not supported in this "
 691                        "configuration");
 692 #endif
 693       break;
 694
 695     case OPT_fimplicit_none:
 696       gfc_option.flag_implicit_none = value;
 697       break;
 698
 699     case OPT_fintrinsic_modules_path:
 700       gfc_add_include_path (arg, false, false);
 701       gfc_add_intrinsic_modules_path (arg);
 702       break;
 703
 704     case OPT_fmax_array_constructor_:
 705       gfc_option.flag_max_array_constructor = value > 65535 ? value : 65535;
 706       break;
 707
 708     case OPT_fmax_errors_:
 709       gfc_option.max_errors = value;
 710       break;
 711
 712     case OPT_fmax_stack_var_size_:
 713       gfc_option.flag_max_stack_var_size = value;
 714       break;
 715
 716     case OPT_fmodule_private:
 717       gfc_option.flag_module_private = value;
 718       break;
 719
 720     case OPT_frange_check:
 721       gfc_option.flag_range_check = value;
 722       break;
 723
 724     case OPT_fpack_derived:
 725       gfc_option.flag_pack_derived = value;
 726       break;
 727
 728     case OPT_frepack_arrays:
 729       gfc_option.flag_repack_arrays = value;
 730       break;
 731
 732     case OPT_fpreprocessed:
 733       gfc_option.flag_preprocessed = value;
 734       break;
 735
 736     case OPT_fmax_identifier_length_:
 737       if (value > GFC_MAX_SYMBOL_LEN)
 738         gfc_fatal_error ("Maximum supported identifier length is %d",
 739                          GFC_MAX_SYMBOL_LEN);
 740       gfc_option.max_identifier_length = value;
 741       break;
 742
 743     case OPT_fdefault_integer_8:
 744       gfc_option.flag_default_integer = value;
 745       break;
 746
 747     case OPT_fdefault_real_8:
 748       gfc_option.flag_default_real = value;
 749       break;
 750
 751     case OPT_fdefault_double_8:
 752       gfc_option.flag_default_double = value;
 753       break;
 754
 755     case OPT_finit_local_zero:
 756       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 757       gfc_option.flag_init_integer_value = 0;
 758       gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 759       gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 760       gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 761       gfc_option.flag_init_character_value = (char)0;
 762       break;
 763
 764     case OPT_finit_logical_:
 765       if (!strcasecmp (arg, "false"))
 766         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 767       else if (!strcasecmp (arg, "true"))
 768         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
 769       else
 770         gfc_fatal_error ("Unrecognized option to -finit-logical: %s",
 771                          arg);
 772       break;
 773
 774     case OPT_finit_real_:
 775       if (!strcasecmp (arg, "zero"))
 776         gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 777       else if (!strcasecmp (arg, "nan"))
 778         gfc_option.flag_init_real = GFC_INIT_REAL_NAN;
 779       else if (!strcasecmp (arg, "snan"))
 780         gfc_option.flag_init_real = GFC_INIT_REAL_SNAN;
 781       else if (!strcasecmp (arg, "inf"))
 782         gfc_option.flag_init_real = GFC_INIT_REAL_INF;
 783       else if (!strcasecmp (arg, "-inf"))
 784         gfc_option.flag_init_real = GFC_INIT_REAL_NEG_INF;
 785       else
 786         gfc_fatal_error ("Unrecognized option to -finit-real: %s",
 787                          arg);
 788       break;
 789
 790     case OPT_finit_integer_:
 791       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 792       gfc_option.flag_init_integer_value = atoi (arg);
 793       break;
 794
 795     case OPT_finit_character_:
 796       if (value >= 0 && value <= 127)
 797         {
 798           gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 799           gfc_option.flag_init_character_value = (char)value;
 800         }
 801       else
 802         gfc_fatal_error ("The value of n in -finit-character=n must be "
 803                          "between 0 and 127");
 804       break;
 805
 806     case OPT_I:
 807       gfc_add_include_path (arg, true, false);
 808       break;
 809
 810     case OPT_J:
 811       gfc_handle_module_path_options (arg);
 812       break;
 813
 814     case OPT_fsign_zero:
 815       gfc_option.flag_sign_zero = value;
 816       break;
 817
 818     case OPT_ffpe_trap_:
 819       gfc_handle_fpe_trap_option (arg);
 820       break;
 821
 822     case OPT_std_f95:
 823       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77;
 824       gfc_option.warn_std = GFC_STD_F95_OBS;
 825       gfc_option.max_continue_fixed = 19;
 826       gfc_option.max_continue_free = 39;
 827       gfc_option.max_identifier_length = 31;
 828       gfc_option.warn_ampersand = 1;
 829       gfc_option.warn_tabs = 0;
 830       break;
 831
 832     case OPT_std_f2003:
 833       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 834         | GFC_STD_F2003 | GFC_STD_F95;
 835       gfc_option.warn_std = GFC_STD_F95_OBS;
 836       gfc_option.max_identifier_length = 63;
 837       gfc_option.warn_ampersand = 1;
 838       gfc_option.warn_tabs = 0;
 839       break;
 840
 841     case OPT_std_f2008:
 842       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 843         | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008;
 844       gfc_option.warn_std = GFC_STD_F95_OBS;
 845       gfc_option.max_identifier_length = 63;
 846       gfc_option.warn_ampersand = 1;
 847       gfc_option.warn_tabs = 0;
 848       break;
 849
 850     case OPT_std_gnu:
 851       set_default_std_flags ();
 852       break;
 853
 854     case OPT_std_legacy:
 855       set_default_std_flags ();
 856       gfc_option.warn_std = 0;
 857       break;
 858
 859     case OPT_Wintrinsics_std:
 860       gfc_option.warn_intrinsics_std = value;
 861       break;
 862
 863     case OPT_fshort_enums:
 864       flag_short_enums = 1;
 865       break;
 866
 867     case OPT_fconvert_little_endian:
 868       gfc_option.convert = GFC_CONVERT_LITTLE;
 869       break;
 870
 871     case OPT_fconvert_big_endian:
 872       gfc_option.convert = GFC_CONVERT_BIG;
 873       break;
 874
 875     case OPT_fconvert_native:
 876       gfc_option.convert = GFC_CONVERT_NATIVE;
 877       break;
 878
 879     case OPT_fconvert_swap:
 880       gfc_option.convert = GFC_CONVERT_SWAP;
 881       break;
 882
 883     case OPT_frecord_marker_4:
 884       gfc_option.record_marker = 4;
 885       break;
 886
 887     case OPT_frecord_marker_8:
 888       gfc_option.record_marker = 8;
 889       break;
 890
 891     case OPT_fmax_subrecord_length_:
 892       if (value > MAX_SUBRECORD_LENGTH)
 893         gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
 894                          MAX_SUBRECORD_LENGTH);
 895
 896       gfc_option.max_subrecord_length = value;
 897       break;
 898
 899     case OPT_frecursive:
 900       gfc_option.flag_recursive = 1;
 901       break;
 902
 903     case OPT_falign_commons:
 904       gfc_option.flag_align_commons = value;
 905       break;
 906
 907     case OPT_fcheck_:
 908       gfc_handle_runtime_check_option (arg);
 909       break;
 910
 911     }
 912
 913   return result;
 914 }