OSDN Git Service

2010-02-20 Tobias Burnus <burnus@net-b.de>
[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, 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   /* 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_runtime_check_option (const char *arg)
482 {
483   int result, pos = 0, n;
484   static const char * const optname[] = { "all", "bounds", "array-temps",
485                                           "recursion", "do", "pointer",
486                                           "mem", NULL };
487   static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,
488                                  GFC_RTCHECK_ARRAY_TEMPS,
489                                  GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,
490                                  GFC_RTCHECK_POINTER, GFC_RTCHECK_MEM,
491                                  0 };
492  
493   while (*arg)
494     {
495       while (*arg == ',')
496         arg++;
497
498       while (arg[pos] && arg[pos] != ',')
499         pos++;
500
501       result = 0;
502       for (n = 0; optname[n] != NULL; n++)
503         {
504           if (optname[n] && strncmp (optname[n], arg, pos) == 0)
505             {
506               gfc_option.rtcheck |= optmask[n];
507               arg += pos;
508               pos = 0;
509               result = 1;
510               break;
511             }
512         }
513       if (!result)
514         gfc_fatal_error ("Argument to -fcheck is not valid: %s", arg);
515     }
516 }
517
518
519 /* Handle command-line options.  Returns 0 if unrecognized, 1 if
520    recognized and handled.  */
521
522 int
523 gfc_handle_option (size_t scode, const char *arg, int value)
524 {
525   int result = 1;
526   enum opt_code code = (enum opt_code) scode;
527
528   /* Ignore file names.  */
529   if (code == N_OPTS)
530     return 1;
531
532   if (gfc_cpp_handle_option (scode, arg, value) == 1)
533     return 1;
534
535   switch (code)
536     {
537     default:
538       result = 0;
539       break;
540
541     case OPT_Wall:
542       set_Wall (value);
543       break;
544
545     case OPT_Waliasing:
546       gfc_option.warn_aliasing = value;
547       break;
548
549     case OPT_Wampersand:
550       gfc_option.warn_ampersand = value;
551       break;
552
553     case OPT_Warray_temporaries:
554       gfc_option.warn_array_temp = value;
555       break;
556
557     case OPT_Wcharacter_truncation:
558       gfc_option.warn_character_truncation = value;
559       break;
560
561     case OPT_Wconversion:
562       gfc_option.warn_conversion = value;
563       break;
564
565     case OPT_Wimplicit_interface:
566       gfc_option.warn_implicit_interface = value;
567       break;
568
569     case OPT_Wimplicit_procedure:
570       gfc_option.warn_implicit_procedure = value;
571       break;
572
573     case OPT_Wline_truncation:
574       gfc_option.warn_line_truncation = value;
575       break;
576
577     case OPT_Wreturn_type:
578       warn_return_type = value;
579       break;
580
581     case OPT_Wsurprising:
582       gfc_option.warn_surprising = value;
583       break;
584
585     case OPT_Wtabs:
586       gfc_option.warn_tabs = value;
587       break;
588
589     case OPT_Wunderflow:
590       gfc_option.warn_underflow = value;
591       break;
592
593     case OPT_Wintrinsic_shadow:
594       gfc_option.warn_intrinsic_shadow = value;
595       break;
596
597     case OPT_Walign_commons:
598       gfc_option.warn_align_commons = value;
599       break;
600
601     case OPT_fall_intrinsics:
602       gfc_option.flag_all_intrinsics = 1;
603       break;
604
605     case OPT_fautomatic:
606       gfc_option.flag_automatic = value;
607       break;
608
609     case OPT_fallow_leading_underscore:
610       gfc_option.flag_allow_leading_underscore = value;
611       break;
612       
613     case OPT_fbackslash:
614       gfc_option.flag_backslash = value;
615       break;
616       
617     case OPT_fbacktrace:
618       gfc_option.flag_backtrace = value;
619       break;
620       
621     case OPT_fcheck_array_temporaries:
622       gfc_option.rtcheck |= GFC_RTCHECK_ARRAY_TEMPS;
623       break;
624       
625     case OPT_fdump_core:
626       gfc_option.flag_dump_core = value;
627       break;
628
629     case OPT_fcray_pointer:
630       gfc_option.flag_cray_pointer = value;
631       break;
632
633     case OPT_ff2c:
634       gfc_option.flag_f2c = value;
635       break;
636
637     case OPT_fdollar_ok:
638       gfc_option.flag_dollar_ok = value;
639       break;
640
641     case OPT_fexternal_blas:
642       gfc_option.flag_external_blas = value;
643       break;
644
645     case OPT_fblas_matmul_limit_:
646       gfc_option.blas_matmul_limit = value;
647       break;
648
649     case OPT_fd_lines_as_code:
650       gfc_option.flag_d_lines = 1;
651       break;
652
653     case OPT_fd_lines_as_comments:
654       gfc_option.flag_d_lines = 0;
655       break;
656
657     case OPT_fdump_parse_tree:
658       gfc_option.dump_parse_tree = value;
659       break;
660
661     case OPT_ffixed_form:
662       gfc_option.source_form = FORM_FIXED;
663       break;
664
665     case OPT_ffixed_line_length_none:
666       gfc_option.fixed_line_length = 0;
667       break;
668
669     case OPT_ffixed_line_length_:
670       if (value != 0 && value < 7)
671         gfc_fatal_error ("Fixed line length must be at least seven.");
672       gfc_option.fixed_line_length = value;
673       break;
674
675     case OPT_ffree_form:
676       gfc_option.source_form = FORM_FREE;
677       break;
678
679     case OPT_fopenmp:
680       gfc_option.flag_openmp = value;
681       break;
682
683     case OPT_ffree_line_length_none:
684       gfc_option.free_line_length = 0;
685       break;
686
687     case OPT_ffree_line_length_:
688       if (value != 0 && value < 4)
689         gfc_fatal_error ("Free line length must be at least three.");
690       gfc_option.free_line_length = value;
691       break;
692
693     case OPT_funderscoring:
694       gfc_option.flag_underscoring = value;
695       break;
696
697     case OPT_fwhole_file:
698       gfc_option.flag_whole_file = 1;
699       break;
700
701     case OPT_fsecond_underscore:
702       gfc_option.flag_second_underscore = value;
703       break;
704
705     case OPT_static_libgfortran:
706 #ifndef HAVE_LD_STATIC_DYNAMIC
707       gfc_fatal_error ("-static-libgfortran is not supported in this "
708                        "configuration");
709 #endif
710       break;
711
712     case OPT_fimplicit_none:
713       gfc_option.flag_implicit_none = value;
714       break;
715
716     case OPT_fintrinsic_modules_path:
717       gfc_add_include_path (arg, false, false);
718       gfc_add_intrinsic_modules_path (arg);
719       break;
720
721     case OPT_fmax_array_constructor_:
722       gfc_option.flag_max_array_constructor = value > 65535 ? value : 65535;
723       break;
724
725     case OPT_fmax_errors_:
726       gfc_option.max_errors = value;
727       break;
728
729     case OPT_fmax_stack_var_size_:
730       gfc_option.flag_max_stack_var_size = value;
731       break;
732
733     case OPT_fmodule_private:
734       gfc_option.flag_module_private = value;
735       break;
736       
737     case OPT_frange_check:
738       gfc_option.flag_range_check = value;
739       break;
740
741     case OPT_fpack_derived:
742       gfc_option.flag_pack_derived = value;
743       break;
744
745     case OPT_frepack_arrays:
746       gfc_option.flag_repack_arrays = value;
747       break;
748
749     case OPT_fpreprocessed:
750       gfc_option.flag_preprocessed = value;
751       break;
752
753     case OPT_fmax_identifier_length_:
754       if (value > GFC_MAX_SYMBOL_LEN)
755         gfc_fatal_error ("Maximum supported identifier length is %d",
756                          GFC_MAX_SYMBOL_LEN);
757       gfc_option.max_identifier_length = value;
758       break;
759
760     case OPT_fdefault_integer_8:
761       gfc_option.flag_default_integer = value;
762       break;
763
764     case OPT_fdefault_real_8:
765       gfc_option.flag_default_real = value;
766       break;
767
768     case OPT_fdefault_double_8:
769       gfc_option.flag_default_double = value;
770       break;
771
772     case OPT_finit_local_zero:
773       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
774       gfc_option.flag_init_integer_value = 0;
775       gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
776       gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
777       gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
778       gfc_option.flag_init_character_value = (char)0;
779       break;
780
781     case OPT_finit_logical_:
782       if (!strcasecmp (arg, "false"))
783         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
784       else if (!strcasecmp (arg, "true"))
785         gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
786       else
787         gfc_fatal_error ("Unrecognized option to -finit-logical: %s",
788                          arg);
789       break;
790
791     case OPT_finit_real_:
792       if (!strcasecmp (arg, "zero"))
793         gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
794       else if (!strcasecmp (arg, "nan"))
795         gfc_option.flag_init_real = GFC_INIT_REAL_NAN;
796       else if (!strcasecmp (arg, "snan"))
797         gfc_option.flag_init_real = GFC_INIT_REAL_SNAN;
798       else if (!strcasecmp (arg, "inf"))
799         gfc_option.flag_init_real = GFC_INIT_REAL_INF;
800       else if (!strcasecmp (arg, "-inf"))
801         gfc_option.flag_init_real = GFC_INIT_REAL_NEG_INF;
802       else
803         gfc_fatal_error ("Unrecognized option to -finit-real: %s",
804                          arg);
805       break;
806
807     case OPT_finit_integer_:
808       gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
809       gfc_option.flag_init_integer_value = atoi (arg);
810       break;
811
812     case OPT_finit_character_:
813       if (value >= 0 && value <= 127)
814         {
815           gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
816           gfc_option.flag_init_character_value = (char)value;
817         }
818       else
819         gfc_fatal_error ("The value of n in -finit-character=n must be "
820                          "between 0 and 127");
821       break;
822
823     case OPT_I:
824       gfc_add_include_path (arg, true, false);
825       break;
826
827     case OPT_J:
828       gfc_handle_module_path_options (arg);
829       break;
830
831     case OPT_fsign_zero:
832       gfc_option.flag_sign_zero = value;
833       break;
834
835     case OPT_ffpe_trap_:
836       gfc_handle_fpe_trap_option (arg);
837       break;
838
839     case OPT_std_f95:
840       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77;
841       gfc_option.warn_std = GFC_STD_F95_OBS;
842       gfc_option.max_continue_fixed = 19;
843       gfc_option.max_continue_free = 39;
844       gfc_option.max_identifier_length = 31;
845       gfc_option.warn_ampersand = 1;
846       gfc_option.warn_tabs = 0;
847       break;
848
849     case OPT_std_f2003:
850       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77 
851         | GFC_STD_F2003 | GFC_STD_F95;
852       gfc_option.warn_std = GFC_STD_F95_OBS;
853       gfc_option.max_identifier_length = 63;
854       gfc_option.warn_ampersand = 1;
855       gfc_option.warn_tabs = 0;
856       break;
857
858     case OPT_std_f2008:
859       gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77 
860         | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008;
861       gfc_option.warn_std = GFC_STD_F95_OBS;
862       gfc_option.max_identifier_length = 63;
863       gfc_option.warn_ampersand = 1;
864       gfc_option.warn_tabs = 0;
865       break;
866
867     case OPT_std_gnu:
868       set_default_std_flags ();
869       break;
870
871     case OPT_std_legacy:
872       set_default_std_flags ();
873       gfc_option.warn_std = 0;
874       break;
875
876     case OPT_Wintrinsics_std:
877       gfc_option.warn_intrinsics_std = value;
878       break;
879
880     case OPT_fshort_enums:
881       flag_short_enums = 1;
882       break;
883
884     case OPT_fconvert_little_endian:
885       gfc_option.convert = GFC_CONVERT_LITTLE;
886       break;
887
888     case OPT_fconvert_big_endian:
889       gfc_option.convert = GFC_CONVERT_BIG;
890       break;
891
892     case OPT_fconvert_native:
893       gfc_option.convert = GFC_CONVERT_NATIVE;
894       break;
895
896     case OPT_fconvert_swap:
897       gfc_option.convert = GFC_CONVERT_SWAP;
898       break;
899
900     case OPT_frecord_marker_4:
901       gfc_option.record_marker = 4;
902       break;
903
904     case OPT_frecord_marker_8:
905       gfc_option.record_marker = 8;
906       break;
907
908     case OPT_fmax_subrecord_length_:
909       if (value > MAX_SUBRECORD_LENGTH)
910         gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
911                          MAX_SUBRECORD_LENGTH);
912
913       gfc_option.max_subrecord_length = value;
914       break;
915
916     case OPT_frecursive:
917       gfc_option.flag_recursive = 1;
918       break;
919
920     case OPT_falign_commons:
921       gfc_option.flag_align_commons = value;
922       break;
923
924     case OPT_fcheck_:
925       gfc_handle_runtime_check_option (arg);
926       break;
927
928     }
929
930   return result;
931 }