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.max_errors = 25;
  80
  81   gfc_option.flag_all_intrinsics = 0;
  82   gfc_option.flag_default_double = 0;
  83   gfc_option.flag_default_integer = 0;
  84   gfc_option.flag_default_real = 0;
  85   gfc_option.flag_dollar_ok = 0;
  86   gfc_option.flag_underscoring = 1;
  87   gfc_option.flag_f2c = 0;
  88   gfc_option.flag_second_underscore = -1;
  89   gfc_option.flag_implicit_none = 0;
  90
  91   /* Default value of flag_max_stack_var_size is set in gfc_post_options.  */
  92   gfc_option.flag_max_stack_var_size = -2;
  93
  94   gfc_option.flag_range_check = 1;
  95   gfc_option.flag_pack_derived = 0;
  96   gfc_option.flag_repack_arrays = 0;
  97   gfc_option.flag_preprocessed = 0;
  98   gfc_option.flag_automatic = 1;
  99   gfc_option.flag_backslash = 0;
 100   gfc_option.flag_module_private = 0;
 101   gfc_option.flag_backtrace = 0;
 102   gfc_option.flag_allow_leading_underscore = 0;
 103   gfc_option.flag_dump_core = 0;
 104   gfc_option.flag_external_blas = 0;
 105   gfc_option.blas_matmul_limit = 30;
 106   gfc_option.flag_cray_pointer = 0;
 107   gfc_option.flag_d_lines = -1;
 108   gfc_option.flag_openmp = 0;
 109   gfc_option.flag_sign_zero = 1;
 110   gfc_option.flag_recursive = 0;
 111   gfc_option.flag_init_integer = GFC_INIT_INTEGER_OFF;
 112   gfc_option.flag_init_integer_value = 0;
 113   gfc_option.flag_init_real = GFC_INIT_REAL_OFF;
 114   gfc_option.flag_init_logical = GFC_INIT_LOGICAL_OFF;
 115   gfc_option.flag_init_character = GFC_INIT_CHARACTER_OFF;
 116   gfc_option.flag_init_character_value = (char)0;
 117
 118   gfc_option.fpe = 0;
 119
 120   /* Argument pointers cannot point to anything but their argument.  */
 121   flag_argument_noalias = 3;
 122
 123   flag_errno_math = 0;
 124
 125   set_default_std_flags ();
 126
 127   gfc_option.warn_nonstd_intrinsics = 0;
 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   flag_inline_trees = 1;
 297
 298   /* Use tree inlining.  */
 299   if (!flag_no_inline)
 300     flag_no_inline = 1;
 301   if (flag_inline_functions)
 302     flag_inline_trees = 2;
 303
 304   /* If -pedantic, warn about the use of GNU extensions.  */
 305   if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)
 306     gfc_option.warn_std |= GFC_STD_GNU;
 307   /* -std=legacy -pedantic is effectively -std=gnu.  */
 308   if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)
 309     gfc_option.warn_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_LEGACY;
 310
 311   /* If the user didn't explicitly specify -f(no)-second-underscore we
 312      use it if we're trying to be compatible with f2c, and not
 313      otherwise.  */
 314   if (gfc_option.flag_second_underscore == -1)
 315     gfc_option.flag_second_underscore = gfc_option.flag_f2c;
 316
 317   if (!gfc_option.flag_automatic && gfc_option.flag_max_stack_var_size != -2
 318       && gfc_option.flag_max_stack_var_size != 0)
 319     gfc_warning_now ("Flag -fno-automatic overwrites -fmax-stack-var-size=%d",
 320                      gfc_option.flag_max_stack_var_size);
 321   else if (!gfc_option.flag_automatic && gfc_option.flag_recursive)
 322     gfc_warning_now ("Flag -fno-automatic overwrites -frecursive");
 323   else if (!gfc_option.flag_automatic && gfc_option.flag_openmp)
 324     gfc_warning_now ("Flag -fno-automatic overwrites -frecursive implied by "
 325                      "-fopenmp");
 326   else if (gfc_option.flag_max_stack_var_size != -2
 327            && gfc_option.flag_recursive)
 328     gfc_warning_now ("Flag -frecursive overwrites -fmax-stack-var-size=%d",
 329                      gfc_option.flag_max_stack_var_size);
 330   else if (gfc_option.flag_max_stack_var_size != -2
 331            && gfc_option.flag_openmp)
 332     gfc_warning_now ("Flag -fmax-stack-var-size=%d overwrites -frecursive "
 333                      "implied by -fopenmp",
 334                      gfc_option.flag_max_stack_var_size);
 335
 336   /* Implied -frecursive; implemented as -fmax-stack-var-size=-1.  */
 337   if (gfc_option.flag_max_stack_var_size == -2 && gfc_option.flag_openmp)
 338     gfc_option.flag_max_stack_var_size = -1;
 339
 340   /* Set default.  */
 341   if (gfc_option.flag_max_stack_var_size == -2)
 342     gfc_option.flag_max_stack_var_size = 32768;
 343
 344   /* Implement -frecursive as -fmax-stack-var-size=-1.  */
 345   if (gfc_option.flag_recursive)
 346     gfc_option.flag_max_stack_var_size = -1;
 347
 348   /* Implement -fno-automatic as -fmax-stack-var-size=0.  */
 349   if (!gfc_option.flag_automatic)
 350     gfc_option.flag_max_stack_var_size = 0;
 351
 352   if (pedantic)
 353     {
 354       gfc_option.warn_ampersand = 1;
 355       gfc_option.warn_tabs = 0;
 356     }
 357
 358   if (gfc_option.flag_all_intrinsics)
 359     gfc_option.warn_nonstd_intrinsics = 0;
 360
 361   gfc_cpp_post_options ();
 362
 363 /* FIXME: return gfc_cpp_preprocess_only ();
 364
 365    The return value of this function indicates whether the
 366    backend needs to be initialized. On -E, we don't need
 367    the backend. However, if we return 'true' here, an
 368    ICE occurs. Initializing the backend doesn't hurt much,
 369    hence, for now we can live with it as is.  */
 370   return false;
 371 }
 372
 373
 374 /* Set the options for -Wall.  */
 375
 376 static void
 377 set_Wall (int setting)
 378 {
 379   gfc_option.warn_aliasing = setting;
 380   gfc_option.warn_ampersand = setting;
 381   gfc_option.warn_line_truncation = setting;
 382   gfc_option.warn_nonstd_intrinsics = setting;
 383   gfc_option.warn_surprising = setting;
 384   gfc_option.warn_tabs = !setting;
 385   gfc_option.warn_underflow = setting;
 386   gfc_option.warn_character_truncation = setting;
 387
 388   set_Wunused (setting);
 389   warn_return_type = setting;
 390   warn_switch = setting;
 391
 392   /* We save the value of warn_uninitialized, since if they put
 393      -Wuninitialized on the command line, we need to generate a
 394      warning about not using it without also specifying -O.  */
 395   if (setting == 0)
 396     warn_uninitialized = 0;
 397   else if (warn_uninitialized != 1)
 398     warn_uninitialized = 2;
 399 }
 400
 401
 402 static void
 403 gfc_handle_module_path_options (const char *arg)
 404 {
 405
 406   if (gfc_option.module_dir != NULL)
 407     gfc_fatal_error ("gfortran: Only one -J option allowed");
 408
 409   gfc_option.module_dir = (char *) gfc_getmem (strlen (arg) + 2);
 410   strcpy (gfc_option.module_dir, arg);
 411   strcat (gfc_option.module_dir, "/");
 412
 413   gfc_add_include_path (gfc_option.module_dir, true);
 414 }
 415
 416
 417 static void
 418 gfc_handle_fpe_trap_option (const char *arg)
 419 {
 420   int result, pos = 0, n;
 421   static const char * const exception[] = { "invalid", "denormal", "zero",
 422                                             "overflow", "underflow",
 423                                             "precision", NULL };
 424   static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
 425                                        GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
 426                                        GFC_FPE_UNDERFLOW, GFC_FPE_PRECISION,
 427                                        0 };
 428
 429   while (*arg)
 430     {
 431       while (*arg == ',')
 432         arg++;
 433
 434       while (arg[pos] && arg[pos] != ',')
 435         pos++;
 436
 437       result = 0;
 438       for (n = 0; exception[n] != NULL; n++)
 439         {
 440           if (exception[n] && strncmp (exception[n], arg, pos) == 0)
 441             {
 442               gfc_option.fpe |= opt_exception[n];
 443               arg += pos;
 444               pos = 0;
 445               result = 1;
 446               break;
 447             }
 448         }
 449       if (!result)
 450         gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
 451     }
 452 }
 453
 454
 455 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
 456    recognized and handled.  */
 457
 458 int
 459 gfc_handle_option (size_t scode, const char *arg, int value)
 460 {
 461   int result = 1;
 462   enum opt_code code = (enum opt_code) scode;
 463
 464   /* Ignore file names.  */
 465   if (code == N_OPTS)
 466     return 1;
 467
 468   if (gfc_cpp_handle_option (scode, arg, value) == 1)
 469     return 1;
 470
 471   switch (code)
 472     {
 473     default:
 474       result = 0;
 475       break;
 476
 477     case OPT_Wall:
 478       set_Wall (value);
 479       break;
 480
 481     case OPT_Waliasing:
 482       gfc_option.warn_aliasing = value;
 483       break;
 484
 485     case OPT_Wampersand:
 486       gfc_option.warn_ampersand = value;
 487       break;
 488
 489     case OPT_Warray_temporaries:
 490       gfc_option.warn_array_temp = value;
 491       break;
 492
 493     case OPT_Wcharacter_truncation:
 494       gfc_option.warn_character_truncation = value;
 495       break;
 496
 497     case OPT_Wconversion:
 498       gfc_option.warn_conversion = value;
 499       break;
 500
 501     case OPT_Wimplicit_interface:
 502       gfc_option.warn_implicit_interface = value;
 503       break;
 504
 505     case OPT_Wline_truncation:
 506       gfc_option.warn_line_truncation = value;
 507       break;
 508
 509     case OPT_Wreturn_type:
 510       warn_return_type = value;
 511       break;
 512
 513     case OPT_Wsurprising:
 514       gfc_option.warn_surprising = value;
 515       break;
 516
 517     case OPT_Wtabs:
 518       gfc_option.warn_tabs = value;
 519       break;
 520
 521     case OPT_Wunderflow:
 522       gfc_option.warn_underflow = value;
 523       break;
 524
 525     case OPT_fall_intrinsics:
 526       gfc_option.flag_all_intrinsics = 1;
 527       break;
 528
 529     case OPT_fautomatic:
 530       gfc_option.flag_automatic = value;
 531       break;
 532
 533     case OPT_fallow_leading_underscore:
 534       gfc_option.flag_allow_leading_underscore = value;
 535       break;
 536
 537     case OPT_fbackslash:
 538       gfc_option.flag_backslash = value;
 539       break;
 540
 541     case OPT_fbacktrace:
 542       gfc_option.flag_backtrace = value;
 543       break;
 544
 545     case OPT_fdump_core:
 546       gfc_option.flag_dump_core = value;
 547       break;
 548
 549     case OPT_fcray_pointer:
 550       gfc_option.flag_cray_pointer = value;
 551       break;
 552
 553     case OPT_ff2c:
 554       gfc_option.flag_f2c = value;
 555       break;
 556
 557     case OPT_fdollar_ok:
 558       gfc_option.flag_dollar_ok = value;
 559       break;
 560
 561     case OPT_fexternal_blas:
 562       gfc_option.flag_external_blas = value;
 563       break;
 564
 565     case OPT_fblas_matmul_limit_:
 566       gfc_option.blas_matmul_limit = value;
 567       break;
 568
 569     case OPT_fd_lines_as_code:
 570       gfc_option.flag_d_lines = 1;
 571       break;
 572
 573     case OPT_fd_lines_as_comments:
 574       gfc_option.flag_d_lines = 0;
 575       break;
 576
 577     case OPT_fdump_parse_tree:
 578       gfc_option.dump_parse_tree = value;
 579       break;
 580
 581     case OPT_ffixed_form:
 582       gfc_option.source_form = FORM_FIXED;
 583       break;
 584
 585     case OPT_ffixed_line_length_none:
 586       gfc_option.fixed_line_length = 0;
 587       break;
 588
 589     case OPT_ffixed_line_length_:
 590       if (value != 0 && value < 7)
 591         gfc_fatal_error ("Fixed line length must be at least seven.");
 592       gfc_option.fixed_line_length = value;
 593       break;
 594
 595     case OPT_ffree_form:
 596       gfc_option.source_form = FORM_FREE;
 597       break;
 598
 599     case OPT_fopenmp:
 600       gfc_option.flag_openmp = value;
 601       break;
 602
 603     case OPT_ffree_line_length_none:
 604       gfc_option.free_line_length = 0;
 605       break;
 606
 607     case OPT_ffree_line_length_:
 608       if (value != 0 && value < 4)
 609         gfc_fatal_error ("Free line length must be at least three.");
 610       gfc_option.free_line_length = value;
 611       break;
 612
 613     case OPT_funderscoring:
 614       gfc_option.flag_underscoring = value;
 615       break;
 616
 617     case OPT_fsecond_underscore:
 618       gfc_option.flag_second_underscore = value;
 619       break;
 620
 621     case OPT_static_libgfortran:
 622 #ifndef HAVE_LD_STATIC_DYNAMIC
 623       gfc_fatal_error ("-static-libgfortran is not supported in this "
 624                        "configuration");
 625 #endif
 626       break;
 627
 628     case OPT_fimplicit_none:
 629       gfc_option.flag_implicit_none = value;
 630       break;
 631
 632     case OPT_fintrinsic_modules_path:
 633       gfc_add_include_path (arg, false);
 634       gfc_add_intrinsic_modules_path (arg);
 635       break;
 636
 637     case OPT_fmax_errors_:
 638       gfc_option.max_errors = value;
 639       break;
 640
 641     case OPT_fmax_stack_var_size_:
 642       gfc_option.flag_max_stack_var_size = value;
 643       break;
 644
 645     case OPT_fmodule_private:
 646       gfc_option.flag_module_private = value;
 647       break;
 648
 649     case OPT_frange_check:
 650       gfc_option.flag_range_check = value;
 651       break;
 652
 653     case OPT_fpack_derived:
 654       gfc_option.flag_pack_derived = value;
 655       break;
 656
 657     case OPT_frepack_arrays:
 658       gfc_option.flag_repack_arrays = value;
 659       break;
 660
 661     case OPT_fpreprocessed:
 662       gfc_option.flag_preprocessed = value;
 663       break;
 664
 665     case OPT_fmax_identifier_length_:
 666       if (value > GFC_MAX_SYMBOL_LEN)
 667         gfc_fatal_error ("Maximum supported identifier length is %d",
 668                          GFC_MAX_SYMBOL_LEN);
 669       gfc_option.max_identifier_length = value;
 670       break;
 671
 672     case OPT_fdefault_integer_8:
 673       gfc_option.flag_default_integer = value;
 674       break;
 675
 676     case OPT_fdefault_real_8:
 677       gfc_option.flag_default_real = value;
 678       break;
 679
 680     case OPT_fdefault_double_8:
 681       gfc_option.flag_default_double = value;
 682       break;
 683
 684     case OPT_finit_local_zero:
 685       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 686       gfc_option.flag_init_integer_value = 0;
 687       gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 688       gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 689       gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 690       gfc_option.flag_init_character_value = (char)0;
 691       break;
 692
 693     case OPT_finit_logical_:
 694       if (!strcasecmp (arg, "false"))
 695         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
 696       else if (!strcasecmp (arg, "true"))
 697         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
 698       else
 699         gfc_fatal_error ("Unrecognized option to -finit-logical: %s",
 700                          arg);
 701       break;
 702
 703     case OPT_finit_real_:
 704       if (!strcasecmp (arg, "zero"))
 705         gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
 706       else if (!strcasecmp (arg, "nan"))
 707         gfc_option.flag_init_real = GFC_INIT_REAL_NAN;
 708       else if (!strcasecmp (arg, "inf"))
 709         gfc_option.flag_init_real = GFC_INIT_REAL_INF;
 710       else if (!strcasecmp (arg, "-inf"))
 711         gfc_option.flag_init_real = GFC_INIT_REAL_NEG_INF;
 712       else
 713         gfc_fatal_error ("Unrecognized option to -finit-real: %s",
 714                          arg);
 715       break;
 716
 717     case OPT_finit_integer_:
 718       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
 719       gfc_option.flag_init_integer_value = atoi (arg);
 720       break;
 721
 722     case OPT_finit_character_:
 723       if (value >= 0 && value <= 127)
 724         {
 725           gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
 726           gfc_option.flag_init_character_value = (char)value;
 727         }
 728       else
 729         gfc_fatal_error ("The value of n in -finit-character=n must be "
 730                          "between 0 and 127");
 731       break;
 732
 733     case OPT_I:
 734       gfc_add_include_path (arg, true);
 735       break;
 736
 737     case OPT_J:
 738       gfc_handle_module_path_options (arg);
 739       break;
 740
 741     case OPT_fsign_zero:
 742       gfc_option.flag_sign_zero = value;
 743       break;
 744
 745     case OPT_ffpe_trap_:
 746       gfc_handle_fpe_trap_option (arg);
 747       break;
 748
 749     case OPT_std_f95:
 750       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77;
 751       gfc_option.warn_std = GFC_STD_F95_OBS;
 752       gfc_option.max_continue_fixed = 19;
 753       gfc_option.max_continue_free = 39;
 754       gfc_option.max_identifier_length = 31;
 755       gfc_option.warn_ampersand = 1;
 756       gfc_option.warn_tabs = 0;
 757       break;
 758
 759     case OPT_std_f2003:
 760       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 761         | GFC_STD_F2003 | GFC_STD_F95;
 762       gfc_option.warn_std = GFC_STD_F95_OBS;
 763       gfc_option.max_identifier_length = 63;
 764       gfc_option.warn_ampersand = 1;
 765       gfc_option.warn_tabs = 0;
 766       break;
 767
 768     case OPT_std_f2008:
 769       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
 770         | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008;
 771       gfc_option.warn_std = GFC_STD_F95_OBS;
 772       gfc_option.max_identifier_length = 63;
 773       gfc_option.warn_ampersand = 1;
 774       gfc_option.warn_tabs = 0;
 775       break;
 776
 777     case OPT_std_gnu:
 778       set_default_std_flags ();
 779       break;
 780
 781     case OPT_std_legacy:
 782       set_default_std_flags ();
 783       gfc_option.warn_std = 0;
 784       break;
 785
 786     case OPT_Wnonstd_intrinsics:
 787       gfc_option.warn_nonstd_intrinsics = value;
 788       break;
 789
 790     case OPT_fshort_enums:
 791       gfc_option.fshort_enums = 1;
 792       break;
 793
 794     case OPT_fconvert_little_endian:
 795       gfc_option.convert = GFC_CONVERT_LITTLE;
 796       break;
 797
 798     case OPT_fconvert_big_endian:
 799       gfc_option.convert = GFC_CONVERT_BIG;
 800       break;
 801
 802     case OPT_fconvert_native:
 803       gfc_option.convert = GFC_CONVERT_NATIVE;
 804       break;
 805
 806     case OPT_fconvert_swap:
 807       gfc_option.convert = GFC_CONVERT_SWAP;
 808       break;
 809
 810     case OPT_frecord_marker_4:
 811       gfc_option.record_marker = 4;
 812       break;
 813
 814     case OPT_frecord_marker_8:
 815       gfc_option.record_marker = 8;
 816       break;
 817
 818     case OPT_fmax_subrecord_length_:
 819       if (value > MAX_SUBRECORD_LENGTH)
 820         gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
 821                          MAX_SUBRECORD_LENGTH);
 822
 823       gfc_option.max_subrecord_length = value;
 824       break;
 825
 826     case OPT_frecursive:
 827       gfc_option.flag_recursive = 1;
 828       break;
 829     }
 830
 831   return result;
 832 }