gcc/fortran/options.c

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