[thirdparty/gcc.git] / gcc / fortran / options.c

/* Parse and display command line options.
   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation,
   Inc.
   Contributed by Andy Vaught

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING.  If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.  */


#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "flags.h"
#include "intl.h"
#include "opts.h"
#include "options.h"
#include "tree-inline.h"

#include "gfortran.h"

gfc_option_t gfc_option;


/* Get ready for options handling.  */

unsigned int
gfc_init_options (unsigned int argc ATTRIBUTE_UNUSED,
		  const char **argv ATTRIBUTE_UNUSED)
{
  gfc_source_file = NULL;
  gfc_option.module_dir = NULL;
  gfc_option.source_form = FORM_UNKNOWN;
  gfc_option.fixed_line_length = 72;
  gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
  gfc_option.verbose = 0;

  gfc_option.warn_aliasing = 0;
  gfc_option.warn_conversion = 0;
  gfc_option.warn_implicit_interface = 0;
  gfc_option.warn_line_truncation = 0;
  gfc_option.warn_underflow = 1;
  gfc_option.warn_surprising = 0;
  gfc_option.warn_unused_labels = 0;

  gfc_option.flag_default_double = 0;
  gfc_option.flag_default_integer = 0;
  gfc_option.flag_default_real = 0;
  gfc_option.flag_dollar_ok = 0;
  gfc_option.flag_underscoring = 1;
  gfc_option.flag_f2c = 0;
  gfc_option.flag_second_underscore = -1;
  gfc_option.flag_implicit_none = 0;
  gfc_option.flag_max_stack_var_size = 32768;
  gfc_option.flag_module_access_private = 0;
  gfc_option.flag_no_backend = 0;
  gfc_option.flag_pack_derived = 0;
  gfc_option.flag_repack_arrays = 0;
  gfc_option.flag_automatic = 1;
  gfc_option.flag_backslash = 1;
  gfc_option.flag_cray_pointer = 0;
  gfc_option.flag_d_lines = -1;

  gfc_option.q_kind = gfc_default_double_kind;

  gfc_option.fpe = 0;

  flag_argument_noalias = 2;
  flag_errno_math = 0;

  gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
    | GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F77 | GFC_STD_GNU
    | GFC_STD_LEGACY;
  gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
    | GFC_STD_F2003 | GFC_STD_LEGACY;

  gfc_option.warn_nonstd_intrinsics = 0;

  return CL_Fortran;
}


/* Determine the source form from the filename extension.  We assume
   case insensitivity.  */

static gfc_source_form
form_from_filename (const char *filename)
{

  static const struct
  {
    const char *extension;
    gfc_source_form form;
  }
  exttype[] =
  {
    {
    ".f90", FORM_FREE}
    ,
    {
    ".f95", FORM_FREE}
    ,
    {
    ".f", FORM_FIXED}
    ,
    {
    ".for", FORM_FIXED}
    ,
    {
    "", FORM_UNKNOWN}
  };		/* sentinel value */

  gfc_source_form f_form;
  const char *fileext;
  int i;

  /* Find end of file name.  Note, filename is either a NULL pointer or
     a NUL terminated string.  */
  i = 0;
  while (filename[i] != '\0')
    i++;

  /* Find last period.  */
  while (i >= 0 && (filename[i] != '.'))
    i--;

  /* Did we see a file extension?  */
  if (i < 0)
    return FORM_UNKNOWN; /* Nope  */

  /* Get file extension and compare it to others.  */
  fileext = &(filename[i]);

  i = -1;
  f_form = FORM_UNKNOWN;
  do
    {
      i++;
      if (strcasecmp (fileext, exttype[i].extension) == 0)
	{
	  f_form = exttype[i].form;
	  break;
	}
    }
  while (exttype[i].form != FORM_UNKNOWN);

  return f_form;
}


/* Finalize commandline options.  */

bool
gfc_post_options (const char **pfilename)
{
  const char *filename = *pfilename;

  /* Verify the input file name.  */
  if (!filename || strcmp (filename, "-") == 0)
    {
      filename = "";
    }

  gfc_source_file = filename;

  /* Decide which form the file will be read in as.  */

  if (gfc_option.source_form != FORM_UNKNOWN)
    gfc_current_form = gfc_option.source_form;
  else
    {
      gfc_current_form = form_from_filename (filename);

      if (gfc_current_form == FORM_UNKNOWN)
	{
	  gfc_current_form = FORM_FREE;
	  gfc_warning_now ("Reading file '%s' as free form.", 
			   (filename[0] == '\0') ? "<stdin>" : filename); 
	}
    }

  /* If the user specified -fd-lines-as-{code|comments} verify that we're
     in fixed form.  */
  if (gfc_current_form == FORM_FREE)
    {
      if (gfc_option.flag_d_lines == 0)
	gfc_warning_now ("'-fd-lines-as-comments' has no effect "
			 "in free form.");
      else if (gfc_option.flag_d_lines == 1)
	gfc_warning_now ("'-fd-lines-as-code' has no effect "
			 "in free form.");
    }

  flag_inline_trees = 1;

  /* Use tree inlining.  */
  if (!flag_no_inline)
    flag_no_inline = 1;
  if (flag_inline_functions)
    flag_inline_trees = 2;

  /* If -pedantic, warn about the use of GNU extensions.  */
  if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)
    gfc_option.warn_std |= GFC_STD_GNU;
  /* -std=legacy -pedantic is effectively -std=gnu.  */
  if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)
    gfc_option.warn_std |= GFC_STD_F95_OBS | GFC_STD_F95_DEL | GFC_STD_LEGACY;

  /* If the user didn't explicitly specify -f(no)-second-underscore we
     use it if we're trying to be compatible with f2c, and not
     otherwise.  */
  if (gfc_option.flag_second_underscore == -1)
    gfc_option.flag_second_underscore = gfc_option.flag_f2c;

  /* Implement -fno-automatic as -fmax-stack-var-size=0.  */
  if (!gfc_option.flag_automatic)
    gfc_option.flag_max_stack_var_size = 0;

  return false;
}


/* Set the options for -Wall.  */

static void
set_Wall (void)
{

  gfc_option.warn_aliasing = 1;
  gfc_option.warn_line_truncation = 1;
  gfc_option.warn_underflow = 1;
  gfc_option.warn_surprising = 1;
  gfc_option.warn_unused_labels = 1;
  gfc_option.warn_nonstd_intrinsics = 1;

  set_Wunused (1);
  warn_return_type = 1;
  warn_switch = 1;

  /* We save the value of warn_uninitialized, since if they put
     -Wuninitialized on the command line, we need to generate a
     warning about not using it without also specifying -O.  */

  if (warn_uninitialized != 1)
    warn_uninitialized = 2;
}


static void
gfc_handle_module_path_options (const char *arg)
{

  if (gfc_option.module_dir != NULL)
    {
      gfc_status ("gfortran: Only one -M option allowed\n");
      exit (3);
    }

  if (arg == NULL)
    {
      gfc_status ("gfortran: Directory required after -M\n");
      exit (3);
    }

  gfc_option.module_dir = (char *) gfc_getmem (strlen (arg) + 2);
  strcpy (gfc_option.module_dir, arg);
  strcat (gfc_option.module_dir, "/");
}

static void
gfc_handle_fpe_trap_option (const char *arg)
{
  int result, pos = 0, n;
  static const char * const exception[] = { "invalid", "denormal", "zero",
                                            "overflow", "underflow",
					    "precision", NULL };
  static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
				       GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
				       GFC_FPE_UNDERFLOW, GFC_FPE_PRECISION,
				       0 };
 
  while (*arg)
    {
      while (*arg == ',')
	arg++;
      while (arg[pos] && arg[pos] != ',')
	pos++;
      result = 0;
      for (n = 0; exception[n] != NULL; n++)
	{
	  if (exception[n] && strncmp (exception[n], arg, pos) == 0)
	    {
	      gfc_option.fpe |= opt_exception[n];
	      arg += pos;
	      pos = 0;
	      result = 1;
	      break;
	    }
	}
      if (! result)
	gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
    }
}

/* Handle command-line options.  Returns 0 if unrecognized, 1 if
   recognized and handled.  */
int
gfc_handle_option (size_t scode, const char *arg, int value)
{
  int result = 1;
  enum opt_code code = (enum opt_code) scode;

  /* Ignore file names.  */
  if (code == N_OPTS)
    return 1;

  switch (code)
    {
    default:
      result = 0;
      break;

    case OPT_Wall:
      set_Wall ();
      break;

    case OPT_Waliasing:
      gfc_option.warn_aliasing = value;
      break;

    case OPT_Wconversion:
      gfc_option.warn_conversion = value;
      break;

    case OPT_Wimplicit_interface:
      gfc_option.warn_implicit_interface = value;
      break;

    case OPT_Wline_truncation:
      gfc_option.warn_line_truncation = value;
      break;

    case OPT_Wunderflow:
      gfc_option.warn_underflow = value;
      break;

    case OPT_Wsurprising:
      gfc_option.warn_surprising = value;
      break;

    case OPT_Wunused_labels:
      gfc_option.warn_unused_labels = value;
      break;
      
    case OPT_fcray_pointer:
      gfc_option.flag_cray_pointer = value;
      break;

    case OPT_ff2c:
      gfc_option.flag_f2c = value;
      break;

    case OPT_fdollar_ok:
      gfc_option.flag_dollar_ok = value;
      break;

    case OPT_fautomatic:
      gfc_option.flag_automatic = value;
      break;

    case OPT_fbackslash:
      gfc_option.flag_backslash = value;
      break;

    case OPT_fd_lines_as_code:
      gfc_option.flag_d_lines = 1;
      break;

    case OPT_fd_lines_as_comments:
      gfc_option.flag_d_lines = 0;
      break;

    case OPT_fdump_parse_tree:
      gfc_option.verbose = value;
      break;

    case OPT_ffixed_form:
      gfc_option.source_form = FORM_FIXED;
      break;

    case OPT_ffree_form:
      gfc_option.source_form = FORM_FREE;
      break;

    case OPT_funderscoring:
      gfc_option.flag_underscoring = value;
      break;

    case OPT_fsecond_underscore:
      gfc_option.flag_second_underscore = value;
      break;

    case OPT_fimplicit_none:
      gfc_option.flag_implicit_none = value;
      break;

    case OPT_fmax_stack_var_size_:
      gfc_option.flag_max_stack_var_size = value;
      break;

    case OPT_fmodule_private:
      gfc_option.flag_module_access_private = value;
      break;

    case OPT_fno_backend:
      gfc_option.flag_no_backend = value;
      break;

    case OPT_fpack_derived:
      gfc_option.flag_pack_derived = value;
      break;

    case OPT_frepack_arrays:
      gfc_option.flag_repack_arrays = value;
      break;

    case OPT_ffixed_line_length_none:
      gfc_option.fixed_line_length = 0;
      break;

    case OPT_ffixed_line_length_:
      if (value != 0 && value < 7)
	gfc_fatal_error ("Fixed line length must be at least seven.");
      gfc_option.fixed_line_length = value;
      break;

    case OPT_fmax_identifier_length_:
      if (value > GFC_MAX_SYMBOL_LEN)
	gfc_fatal_error ("Maximum supported idenitifier length is %d",
			 GFC_MAX_SYMBOL_LEN);
      gfc_option.max_identifier_length = value;
      break;

    case OPT_qkind_:
      if (gfc_validate_kind (BT_REAL, value, true) < 0)
	gfc_fatal_error ("Argument to -fqkind isn't a valid real kind");
      gfc_option.q_kind = value;
      break;

    case OPT_fdefault_integer_8:
      gfc_option.flag_default_integer = value;
      break;

    case OPT_fdefault_real_8:
      gfc_option.flag_default_real = value;
      break;

    case OPT_fdefault_double_8:
      gfc_option.flag_default_double = value;
      break;

    case OPT_I:
      gfc_add_include_path (arg);
      break;

    case OPT_J:
    case OPT_M:
      gfc_handle_module_path_options (arg);
      break;
    
    case OPT_ffpe_trap_:
      gfc_handle_fpe_trap_option (arg);
      break;

    case OPT_std_f95:
      gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77;
      gfc_option.warn_std = GFC_STD_F95_OBS;
      gfc_option.max_identifier_length = 31;
      break;

    case OPT_std_f2003:
      gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77 
	| GFC_STD_F2003 | GFC_STD_F95;
      gfc_option.warn_std = GFC_STD_F95_OBS;
      gfc_option.max_identifier_length = 63;
      break;

    case OPT_std_gnu:
      gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
	| GFC_STD_F77 | GFC_STD_F95 | GFC_STD_F2003
	| GFC_STD_GNU | GFC_STD_LEGACY;
      gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
	| GFC_STD_LEGACY;
      break;

    case OPT_std_legacy:
      gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
	| GFC_STD_F77 | GFC_STD_F95 | GFC_STD_F2003
	| GFC_STD_GNU | GFC_STD_LEGACY;
      gfc_option.warn_std = 0;
      break;

    case OPT_Wnonstd_intrinsics:
      gfc_option.warn_nonstd_intrinsics = 1;
      break;
    }

  return result;
}
Commit	Line	Data
4ee9c684	1	/* Parse and display command line options.
0305ad9b	2	Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation,
c84b470d	3	Inc.
4ee9c684	4	Contributed by Andy Vaught
4ee9c684	5
c84b470d	6	This file is part of GCC.
4ee9c684	7
c84b470d	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 2, or (at your option) any later
	11	version.
4ee9c684	12
c84b470d	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.
4ee9c684	17
4ee9c684	18	You should have received a copy of the GNU General Public License
c84b470d	19	along with GCC; see the file COPYING. If not, write to the Free
30d4ffea	20	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
30d4ffea	21	02110-1301, USA. */
4ee9c684	22
4ee9c684	23
	24	#include "config.h"
	25	#include "system.h"
	26	#include "coretypes.h"
	27	#include "tree.h"
	28	#include "flags.h"
	29	#include "intl.h"
	30	#include "opts.h"
	31	#include "options.h"
	32	#include "tree-inline.h"
	33
	34	#include "gfortran.h"
	35
	36	gfc_option_t gfc_option;
	37
	38
	39	/* Get ready for options handling. */
	40
	41	unsigned int
	42	gfc_init_options (unsigned int argc ATTRIBUTE_UNUSED,
	43	const char **argv ATTRIBUTE_UNUSED)
	44	{
8594da07	45	gfc_source_file = NULL;
4ee9c684	46	gfc_option.module_dir = NULL;
	47	gfc_option.source_form = FORM_UNKNOWN;
	48	gfc_option.fixed_line_length = 72;
	49	gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
	50	gfc_option.verbose = 0;
	51
	52	gfc_option.warn_aliasing = 0;
	53	gfc_option.warn_conversion = 0;
	54	gfc_option.warn_implicit_interface = 0;
	55	gfc_option.warn_line_truncation = 0;
9857bf0d	56	gfc_option.warn_underflow = 1;
4ee9c684	57	gfc_option.warn_surprising = 0;
	58	gfc_option.warn_unused_labels = 0;
	59
d9c2d9a5	60	gfc_option.flag_default_double = 0;
	61	gfc_option.flag_default_integer = 0;
	62	gfc_option.flag_default_real = 0;
4ee9c684	63	gfc_option.flag_dollar_ok = 0;
4ee9c684	64	gfc_option.flag_underscoring = 1;
bdaed7d2	65	gfc_option.flag_f2c = 0;
bdaed7d2	66	gfc_option.flag_second_underscore = -1;
4ee9c684	67	gfc_option.flag_implicit_none = 0;
	68	gfc_option.flag_max_stack_var_size = 32768;
	69	gfc_option.flag_module_access_private = 0;
	70	gfc_option.flag_no_backend = 0;
	71	gfc_option.flag_pack_derived = 0;
	72	gfc_option.flag_repack_arrays = 0;
0fda8d07	73	gfc_option.flag_automatic = 1;
2467f78d	74	gfc_option.flag_backslash = 1;
b549d2a5	75	gfc_option.flag_cray_pointer = 0;
8594da07	76	gfc_option.flag_d_lines = -1;
4ee9c684	77
b8a891cb	78	gfc_option.q_kind = gfc_default_double_kind;
4ee9c684	79
8c84a5de	80	gfc_option.fpe = 0;
8c84a5de	81
4ee9c684	82	flag_argument_noalias = 2;
40441bde	83	flag_errno_math = 0;
4ee9c684	84
4ee9c684	85	gfc_option.allow_std = GFC_STD_F95_OBS \| GFC_STD_F95_DEL
c667e11d	86	\| GFC_STD_F2003 \| GFC_STD_F95 \| GFC_STD_F77 \| GFC_STD_GNU
c667e11d	87	\| GFC_STD_LEGACY;
4ee9c684	88	gfc_option.warn_std = GFC_STD_F95_OBS \| GFC_STD_F95_DEL
c667e11d	89	\| GFC_STD_F2003 \| GFC_STD_LEGACY;
4ee9c684	90
d6583a5f	91	gfc_option.warn_nonstd_intrinsics = 0;
d6583a5f	92
2c718da0	93	return CL_Fortran;
4ee9c684	94	}
	95
	96
8594da07	97	/* Determine the source form from the filename extension. We assume
	98	case insensitivity. */
	99
	100	static gfc_source_form
	101	form_from_filename (const char *filename)
	102	{
	103
	104	static const struct
	105	{
	106	const char *extension;
	107	gfc_source_form form;
	108	}
	109	exttype[] =
	110	{
	111	{
	112	".f90", FORM_FREE}
	113	,
	114	{
	115	".f95", FORM_FREE}
	116	,
	117	{
	118	".f", FORM_FIXED}
	119	,
	120	{
	121	".for", FORM_FIXED}
	122	,
	123	{
	124	"", FORM_UNKNOWN}
	125	}; /* sentinel value */
	126
	127	gfc_source_form f_form;
	128	const char *fileext;
	129	int i;
	130
	131	/* Find end of file name. Note, filename is either a NULL pointer or
	132	a NUL terminated string. */
	133	i = 0;
	134	while (filename[i] != '\0')
	135	i++;
	136
	137	/* Find last period. */
	138	while (i >= 0 && (filename[i] != '.'))
	139	i--;
	140
	141	/* Did we see a file extension? */
	142	if (i < 0)
	143	return FORM_UNKNOWN; /* Nope */
	144
	145	/* Get file extension and compare it to others. */
	146	fileext = &(filename[i]);
	147
	148	i = -1;
	149	f_form = FORM_UNKNOWN;
	150	do
	151	{
	152	i++;
	153	if (strcasecmp (fileext, exttype[i].extension) == 0)
	154	{
	155	f_form = exttype[i].form;
	156	break;
	157	}
	158	}
	159	while (exttype[i].form != FORM_UNKNOWN);
	160
161	return f_form;
162	}
163
164
4ee9c684	165	/* Finalize commandline options. */
	166
	167	bool
	168	gfc_post_options (const char **pfilename)
	169	{
	170	const char filename = pfilename;
	171
	172	/* Verify the input file name. */
	173	if (!filename \|\| strcmp (filename, "-") == 0)
	174	{
	175	filename = "";
	176	}
	177
8594da07	178	gfc_source_file = filename;
	179
	180	/* Decide which form the file will be read in as. */
	181
	182	if (gfc_option.source_form != FORM_UNKNOWN)
	183	gfc_current_form = gfc_option.source_form;
	184	else
	185	{
	186	gfc_current_form = form_from_filename (filename);
	187
	188	if (gfc_current_form == FORM_UNKNOWN)
	189	{
	190	gfc_current_form = FORM_FREE;
	191	gfc_warning_now ("Reading file '%s' as free form.",
	192	(filename[0] == '\0') ? "<stdin>" : filename);
	193	}
	194	}
	195
	196	/* If the user specified -fd-lines-as-{code\|comments} verify that we're
	197	in fixed form. */
	198	if (gfc_current_form == FORM_FREE)
	199	{
	200	if (gfc_option.flag_d_lines == 0)
	201	gfc_warning_now ("'-fd-lines-as-comments' has no effect "
	202	"in free form.");
	203	else if (gfc_option.flag_d_lines == 1)
	204	gfc_warning_now ("'-fd-lines-as-code' has no effect "
	205	"in free form.");
	206	}
4ee9c684	207
	208	flag_inline_trees = 1;
	209
	210	/* Use tree inlining. */
	211	if (!flag_no_inline)
	212	flag_no_inline = 1;
	213	if (flag_inline_functions)
bf37ab98	214	flag_inline_trees = 2;
675e3934	215
	216	/* If -pedantic, warn about the use of GNU extensions. */
	217	if (pedantic && (gfc_option.allow_std & GFC_STD_GNU) != 0)
	218	gfc_option.warn_std \|= GFC_STD_GNU;
c667e11d	219	/* -std=legacy -pedantic is effectively -std=gnu. */
	220	if (pedantic && (gfc_option.allow_std & GFC_STD_LEGACY) != 0)
	221	gfc_option.warn_std \|= GFC_STD_F95_OBS \| GFC_STD_F95_DEL \| GFC_STD_LEGACY;
675e3934	222
bdaed7d2	223	/* If the user didn't explicitly specify -f(no)-second-underscore we
	224	use it if we're trying to be compatible with f2c, and not
	225	otherwise. */
	226	if (gfc_option.flag_second_underscore == -1)
	227	gfc_option.flag_second_underscore = gfc_option.flag_f2c;
	228
7f2e183b	229	/* Implement -fno-automatic as -fmax-stack-var-size=0. */
	230	if (!gfc_option.flag_automatic)
	231	gfc_option.flag_max_stack_var_size = 0;
	232
4ee9c684	233	return false;
	234	}
	235
	236
	237	/* Set the options for -Wall. */
	238
	239	static void
	240	set_Wall (void)
	241	{
	242
	243	gfc_option.warn_aliasing = 1;
	244	gfc_option.warn_line_truncation = 1;
9857bf0d	245	gfc_option.warn_underflow = 1;
4ee9c684	246	gfc_option.warn_surprising = 1;
4ee9c684	247	gfc_option.warn_unused_labels = 1;
d6583a5f	248	gfc_option.warn_nonstd_intrinsics = 1;
4ee9c684	249
	250	set_Wunused (1);
	251	warn_return_type = 1;
	252	warn_switch = 1;
	253
	254	/* We save the value of warn_uninitialized, since if they put
	255	-Wuninitialized on the command line, we need to generate a
	256	warning about not using it without also specifying -O. */
	257
	258	if (warn_uninitialized != 1)
	259	warn_uninitialized = 2;
	260	}
	261
	262
	263	static void
	264	gfc_handle_module_path_options (const char *arg)
	265	{
	266
	267	if (gfc_option.module_dir != NULL)
	268	{
	269	gfc_status ("gfortran: Only one -M option allowed\n");
	270	exit (3);
	271	}
	272
	273	if (arg == NULL)
	274	{
	275	gfc_status ("gfortran: Directory required after -M\n");
	276	exit (3);
	277	}
	278
3f1e4cec	279	gfc_option.module_dir = (char *) gfc_getmem (strlen (arg) + 2);
4ee9c684	280	strcpy (gfc_option.module_dir, arg);
	281	strcat (gfc_option.module_dir, "/");
	282	}
	283
8c84a5de	284	static void
	285	gfc_handle_fpe_trap_option (const char *arg)
	286	{
	287	int result, pos = 0, n;
	288	static const char * const exception[] = { "invalid", "denormal", "zero",
	289	"overflow", "underflow",
	290	"precision", NULL };
	291	static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
	292	GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
	293	GFC_FPE_UNDERFLOW, GFC_FPE_PRECISION,
	294	0 };
	295
	296	while (*arg)
	297	{
	298	while (*arg == ',')
	299	arg++;
	300	while (arg[pos] && arg[pos] != ',')
	301	pos++;
	302	result = 0;
	303	for (n = 0; exception[n] != NULL; n++)
	304	{
	305	if (exception[n] && strncmp (exception[n], arg, pos) == 0)
	306	{
	307	gfc_option.fpe \|= opt_exception[n];
	308	arg += pos;
	309	pos = 0;
	310	result = 1;
	311	break;
	312	}
	313	}
	314	if (! result)
	315	gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
	316	}
	317	}
	318
4ee9c684	319	/* Handle command-line options. Returns 0 if unrecognized, 1 if
	320	recognized and handled. */
	321	int
	322	gfc_handle_option (size_t scode, const char *arg, int value)
	323	{
	324	int result = 1;
	325	enum opt_code code = (enum opt_code) scode;
	326
	327	/* Ignore file names. */
	328	if (code == N_OPTS)
	329	return 1;
	330
	331	switch (code)
	332	{
	333	default:
	334	result = 0;
	335	break;
	336
	337	case OPT_Wall:
	338	set_Wall ();
	339	break;
	340
	341	case OPT_Waliasing:
	342	gfc_option.warn_aliasing = value;
	343	break;
	344
	345	case OPT_Wconversion:
	346	gfc_option.warn_conversion = value;
	347	break;
	348
	349	case OPT_Wimplicit_interface:
	350	gfc_option.warn_implicit_interface = value;
	351	break;
	352
	353	case OPT_Wline_truncation:
	354	gfc_option.warn_line_truncation = value;
	355	break;
	356
9857bf0d	357	case OPT_Wunderflow:
	358	gfc_option.warn_underflow = value;
	359	break;
	360
4ee9c684	361	case OPT_Wsurprising:
	362	gfc_option.warn_surprising = value;
	363	break;
	364
	365	case OPT_Wunused_labels:
	366	gfc_option.warn_unused_labels = value;
	367	break;
b549d2a5	368
	369	case OPT_fcray_pointer:
	370	gfc_option.flag_cray_pointer = value;
	371	break;
4ee9c684	372
bdaed7d2	373	case OPT_ff2c:
	374	gfc_option.flag_f2c = value;
	375	break;
	376
4ee9c684	377	case OPT_fdollar_ok:
	378	gfc_option.flag_dollar_ok = value;
	379	break;
	380
0fda8d07	381	case OPT_fautomatic:
	382	gfc_option.flag_automatic = value;
	383	break;
	384
2467f78d	385	case OPT_fbackslash:
	386	gfc_option.flag_backslash = value;
	387	break;
	388
8594da07	389	case OPT_fd_lines_as_code:
	390	gfc_option.flag_d_lines = 1;
	391	break;
	392
	393	case OPT_fd_lines_as_comments:
	394	gfc_option.flag_d_lines = 0;
	395	break;
	396
4ee9c684	397	case OPT_fdump_parse_tree:
	398	gfc_option.verbose = value;
	399	break;
	400
	401	case OPT_ffixed_form:
	402	gfc_option.source_form = FORM_FIXED;
	403	break;
	404
	405	case OPT_ffree_form:
	406	gfc_option.source_form = FORM_FREE;
	407	break;
	408
	409	case OPT_funderscoring:
	410	gfc_option.flag_underscoring = value;
	411	break;
	412
	413	case OPT_fsecond_underscore:
	414	gfc_option.flag_second_underscore = value;
	415	break;
	416
	417	case OPT_fimplicit_none:
	418	gfc_option.flag_implicit_none = value;
	419	break;
	420
	421	case OPT_fmax_stack_var_size_:
	422	gfc_option.flag_max_stack_var_size = value;
	423	break;
	424
	425	case OPT_fmodule_private:
	426	gfc_option.flag_module_access_private = value;
	427	break;
	428
	429	case OPT_fno_backend:
	430	gfc_option.flag_no_backend = value;
	431	break;
	432
	433	case OPT_fpack_derived:
	434	gfc_option.flag_pack_derived = value;
	435	break;
	436
	437	case OPT_frepack_arrays:
	438	gfc_option.flag_repack_arrays = value;
	439	break;
	440
f653e99b	441	case OPT_ffixed_line_length_none:
f653e99b	442	gfc_option.fixed_line_length = 0;
4ee9c684	443	break;
4ee9c684	444
f653e99b	445	case OPT_ffixed_line_length_:
	446	if (value != 0 && value < 7)
	447	gfc_fatal_error ("Fixed line length must be at least seven.");
	448	gfc_option.fixed_line_length = value;
4ee9c684	449	break;
	450
	451	case OPT_fmax_identifier_length_:
	452	if (value > GFC_MAX_SYMBOL_LEN)
	453	gfc_fatal_error ("Maximum supported idenitifier length is %d",
	454	GFC_MAX_SYMBOL_LEN);
	455	gfc_option.max_identifier_length = value;
	456	break;
	457
	458	case OPT_qkind_:
f2d4ef3b	459	if (gfc_validate_kind (BT_REAL, value, true) < 0)
4ee9c684	460	gfc_fatal_error ("Argument to -fqkind isn't a valid real kind");
	461	gfc_option.q_kind = value;
	462	break;
	463
d9c2d9a5	464	case OPT_fdefault_integer_8:
d9c2d9a5	465	gfc_option.flag_default_integer = value;
4ee9c684	466	break;
4ee9c684	467
d9c2d9a5	468	case OPT_fdefault_real_8:
d9c2d9a5	469	gfc_option.flag_default_real = value;
4ee9c684	470	break;
4ee9c684	471
d9c2d9a5	472	case OPT_fdefault_double_8:
d9c2d9a5	473	gfc_option.flag_default_double = value;
4ee9c684	474	break;
	475
	476	case OPT_I:
	477	gfc_add_include_path (arg);
	478	break;
	479
	480	case OPT_J:
	481	case OPT_M:
	482	gfc_handle_module_path_options (arg);
ca9ccc0d	483	break;
4ee9c684	484
8c84a5de	485	case OPT_ffpe_trap_:
	486	gfc_handle_fpe_trap_option (arg);
	487	break;
	488
4ee9c684	489	case OPT_std_f95:
d6583a5f	490	gfc_option.allow_std = GFC_STD_F95_OBS \| GFC_STD_F95 \| GFC_STD_F77;
4ee9c684	491	gfc_option.warn_std = GFC_STD_F95_OBS;
	492	gfc_option.max_identifier_length = 31;
	493	break;
	494
	495	case OPT_std_f2003:
d6583a5f	496	gfc_option.allow_std = GFC_STD_F95_OBS \| GFC_STD_F77
	497	\| GFC_STD_F2003 \| GFC_STD_F95;
	498	gfc_option.warn_std = GFC_STD_F95_OBS;
4ee9c684	499	gfc_option.max_identifier_length = 63;
	500	break;
	501
	502	case OPT_std_gnu:
	503	gfc_option.allow_std = GFC_STD_F95_OBS \| GFC_STD_F95_DEL
d6583a5f	504	\| GFC_STD_F77 \| GFC_STD_F95 \| GFC_STD_F2003
c667e11d	505	\| GFC_STD_GNU \| GFC_STD_LEGACY;
	506	gfc_option.warn_std = GFC_STD_F95_OBS \| GFC_STD_F95_DEL
	507	\| GFC_STD_LEGACY;
	508	break;
	509
	510	case OPT_std_legacy:
	511	gfc_option.allow_std = GFC_STD_F95_OBS \| GFC_STD_F95_DEL
	512	\| GFC_STD_F77 \| GFC_STD_F95 \| GFC_STD_F2003
	513	\| GFC_STD_GNU \| GFC_STD_LEGACY;
	514	gfc_option.warn_std = 0;
d6583a5f	515	break;
	516
	517	case OPT_Wnonstd_intrinsics:
	518	gfc_option.warn_nonstd_intrinsics = 1;
4ee9c684	519	break;
	520	}
	521
	522	return result;
	523	}