OSDN Git Service

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