6d7f7e0a63
2013-11-05 Tobias Burnus <burnus@net-b.de>
gcc/
* doc/invoke.texi (-fopenmp-simd): Document new option.
* gimplify.c (gimplify_body): Accept -fopenmp-simd.
* omp-low.c (execute_expand_omp, execute_lower_omp): Ditto.
* tree.c (attribute_value_equal): Ditto.
gcc/fortran/
* lang.opt (fopenmp-simd): New option.
* gfortran.h (gfc_option_t): Add gfc_flag_openmp_simd.
* options.c (gfc_handle_option): Handle it.
gcc/c-family/
* c.opt (fopenmp-simd): New option.
* c-pragma.c (omp_pragmas): Move pragmas which can contain simd
* to ...
(omp_pragmas): ... this new struct.
(c_pp_lookup_pragma): Also walk omp_pragmas.
(init_pragma): Init pragmas for -fopenmp-simd.
gcc/c
* c-parser.c (c_parser_omp_for, c_parser_omp_parallel,
c_parser_omp_distribute, c_parser_omp_teams,
c_parser_omp_target, c_parser_omp_declare): Handle
-fopenmp-simd.
gcc/cp
* parser.c (cp_parser_omp_for, cp_parser_omp_parallel,
cp_parser_omp_distribute, cp_parser_omp_teams,
cp_parser_omp_target,
cp_parser_omp_declare): Handle
-fopenmp-simd.
gcc/testsuite/
* g++.dg/gomp/openmp-simd-1.C: New.
* g++.dg/gomp/openmp-simd-2.C: New.
* gcc.dg/gomp/openmp-simd-1.c: New.
* gcc.dg/gomp/openmp-simd-2.c: New.
From-SVN: r204382
1243 lines
33 KiB
C
1243 lines
33 KiB
C
/* Parse and display command line options.
|
|
Copyright (C) 2000-2013 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 3, 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 COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#include "config.h"
|
|
#include "system.h"
|
|
#include "coretypes.h"
|
|
#include "tree.h"
|
|
#include "flags.h"
|
|
#include "intl.h"
|
|
#include "opts.h"
|
|
#include "toplev.h" /* For save_decoded_options. */
|
|
#include "options.h"
|
|
#include "params.h"
|
|
#include "tree-inline.h"
|
|
#include "gfortran.h"
|
|
#include "target.h"
|
|
#include "cpp.h"
|
|
#include "diagnostic.h" /* For global_dc. */
|
|
#include "tm.h"
|
|
|
|
gfc_option_t gfc_option;
|
|
|
|
|
|
/* Set flags that control warnings and errors for different
|
|
Fortran standards to their default values. Keep in sync with
|
|
libgfortran/runtime/compile_options.c (init_compile_options). */
|
|
|
|
static void
|
|
set_default_std_flags (void)
|
|
{
|
|
gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95_DEL
|
|
| GFC_STD_F2003 | GFC_STD_F2008 | GFC_STD_F95 | GFC_STD_F77
|
|
| GFC_STD_F2008_OBS | GFC_STD_F2008_TS | GFC_STD_GNU | GFC_STD_LEGACY;
|
|
gfc_option.warn_std = GFC_STD_F95_DEL | GFC_STD_LEGACY;
|
|
}
|
|
|
|
|
|
/* Return language mask for Fortran options. */
|
|
|
|
unsigned int
|
|
gfc_option_lang_mask (void)
|
|
{
|
|
return CL_Fortran;
|
|
}
|
|
|
|
/* Initialize options structure OPTS. */
|
|
|
|
void
|
|
gfc_init_options_struct (struct gcc_options *opts)
|
|
{
|
|
opts->x_flag_errno_math = 0;
|
|
opts->x_flag_associative_math = -1;
|
|
}
|
|
|
|
/* Get ready for options handling. Keep in sync with
|
|
libgfortran/runtime/compile_options.c (init_compile_options). */
|
|
|
|
void
|
|
gfc_init_options (unsigned int decoded_options_count,
|
|
struct cl_decoded_option *decoded_options)
|
|
{
|
|
gfc_source_file = NULL;
|
|
gfc_option.module_dir = NULL;
|
|
gfc_option.source_form = FORM_UNKNOWN;
|
|
gfc_option.fixed_line_length = 72;
|
|
gfc_option.free_line_length = 132;
|
|
gfc_option.max_continue_fixed = 255;
|
|
gfc_option.max_continue_free = 255;
|
|
gfc_option.max_identifier_length = GFC_MAX_SYMBOL_LEN;
|
|
gfc_option.max_subrecord_length = 0;
|
|
gfc_option.flag_max_array_constructor = 65535;
|
|
gfc_option.convert = GFC_CONVERT_NATIVE;
|
|
gfc_option.record_marker = 0;
|
|
gfc_option.dump_fortran_original = 0;
|
|
gfc_option.dump_fortran_optimized = 0;
|
|
|
|
gfc_option.warn_aliasing = 0;
|
|
gfc_option.warn_ampersand = 0;
|
|
gfc_option.warn_character_truncation = 0;
|
|
gfc_option.warn_array_temp = 0;
|
|
gfc_option.warn_c_binding_type = 0;
|
|
gfc_option.gfc_warn_conversion = 0;
|
|
gfc_option.warn_conversion_extra = 0;
|
|
gfc_option.warn_function_elimination = 0;
|
|
gfc_option.warn_implicit_interface = 0;
|
|
gfc_option.warn_line_truncation = 0;
|
|
gfc_option.warn_surprising = 0;
|
|
gfc_option.warn_tabs = 1;
|
|
gfc_option.warn_underflow = 1;
|
|
gfc_option.warn_intrinsic_shadow = 0;
|
|
gfc_option.warn_intrinsics_std = 0;
|
|
gfc_option.warn_align_commons = 1;
|
|
gfc_option.warn_real_q_constant = 0;
|
|
gfc_option.warn_unused_dummy_argument = 0;
|
|
gfc_option.warn_zerotrip = 0;
|
|
gfc_option.warn_realloc_lhs = 0;
|
|
gfc_option.warn_realloc_lhs_all = 0;
|
|
gfc_option.warn_compare_reals = 0;
|
|
gfc_option.warn_target_lifetime = 0;
|
|
gfc_option.max_errors = 25;
|
|
|
|
gfc_option.flag_all_intrinsics = 0;
|
|
gfc_option.flag_default_double = 0;
|
|
gfc_option.flag_default_integer = 0;
|
|
gfc_option.flag_default_real = 0;
|
|
gfc_option.flag_integer4_kind = 0;
|
|
gfc_option.flag_real4_kind = 0;
|
|
gfc_option.flag_real8_kind = 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;
|
|
|
|
/* Default value of flag_max_stack_var_size is set in gfc_post_options. */
|
|
gfc_option.flag_max_stack_var_size = -2;
|
|
gfc_option.flag_stack_arrays = -1;
|
|
|
|
gfc_option.flag_range_check = 1;
|
|
gfc_option.flag_pack_derived = 0;
|
|
gfc_option.flag_repack_arrays = 0;
|
|
gfc_option.flag_preprocessed = 0;
|
|
gfc_option.flag_automatic = 1;
|
|
gfc_option.flag_backslash = 0;
|
|
gfc_option.flag_module_private = 0;
|
|
gfc_option.flag_backtrace = 1;
|
|
gfc_option.flag_allow_leading_underscore = 0;
|
|
gfc_option.flag_external_blas = 0;
|
|
gfc_option.blas_matmul_limit = 30;
|
|
gfc_option.flag_cray_pointer = 0;
|
|
gfc_option.flag_d_lines = -1;
|
|
gfc_option.gfc_flag_openmp = 0;
|
|
gfc_option.flag_sign_zero = 1;
|
|
gfc_option.flag_recursive = 0;
|
|
gfc_option.flag_init_integer = GFC_INIT_INTEGER_OFF;
|
|
gfc_option.flag_init_integer_value = 0;
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_OFF;
|
|
gfc_option.flag_init_logical = GFC_INIT_LOGICAL_OFF;
|
|
gfc_option.flag_init_character = GFC_INIT_CHARACTER_OFF;
|
|
gfc_option.flag_init_character_value = (char)0;
|
|
gfc_option.flag_align_commons = 1;
|
|
gfc_option.flag_protect_parens = -1;
|
|
gfc_option.flag_realloc_lhs = -1;
|
|
gfc_option.flag_aggressive_function_elimination = 0;
|
|
gfc_option.flag_frontend_optimize = -1;
|
|
|
|
gfc_option.fpe = 0;
|
|
/* All except GFC_FPE_INEXACT. */
|
|
gfc_option.fpe_summary = GFC_FPE_INVALID | GFC_FPE_DENORMAL
|
|
| GFC_FPE_ZERO | GFC_FPE_OVERFLOW
|
|
| GFC_FPE_UNDERFLOW;
|
|
gfc_option.rtcheck = 0;
|
|
gfc_option.coarray = GFC_FCOARRAY_NONE;
|
|
|
|
set_default_std_flags ();
|
|
|
|
/* Initialize cpp-related options. */
|
|
gfc_cpp_init_options (decoded_options_count, decoded_options);
|
|
}
|
|
|
|
|
|
/* 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}
|
|
,
|
|
{
|
|
".f03", FORM_FREE}
|
|
,
|
|
{
|
|
".f08", FORM_FREE}
|
|
,
|
|
{
|
|
".f", FORM_FIXED}
|
|
,
|
|
{
|
|
".for", FORM_FIXED}
|
|
,
|
|
{
|
|
".ftn", 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, *canon_source_file = NULL;
|
|
char *source_path;
|
|
int i;
|
|
|
|
/* Excess precision other than "fast" requires front-end
|
|
support. */
|
|
if (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
|
|
&& TARGET_FLT_EVAL_METHOD_NON_DEFAULT)
|
|
sorry ("-fexcess-precision=standard for Fortran");
|
|
flag_excess_precision_cmdline = EXCESS_PRECISION_FAST;
|
|
|
|
/* Fortran allows associative math - but we cannot reassociate if
|
|
we want traps or signed zeros. Cf. also flag_protect_parens. */
|
|
if (flag_associative_math == -1)
|
|
flag_associative_math = (!flag_trapping_math && !flag_signed_zeros);
|
|
|
|
if (gfc_option.flag_protect_parens == -1)
|
|
gfc_option.flag_protect_parens = !optimize_fast;
|
|
|
|
if (gfc_option.flag_stack_arrays == -1)
|
|
gfc_option.flag_stack_arrays = optimize_fast;
|
|
|
|
/* By default, disable (re)allocation during assignment for -std=f95,
|
|
and enable it for F2003/F2008/GNU/Legacy. */
|
|
if (gfc_option.flag_realloc_lhs == -1)
|
|
{
|
|
if (gfc_option.allow_std & GFC_STD_F2003)
|
|
gfc_option.flag_realloc_lhs = 1;
|
|
else
|
|
gfc_option.flag_realloc_lhs = 0;
|
|
}
|
|
|
|
/* -fbounds-check is equivalent to -fcheck=bounds */
|
|
if (flag_bounds_check)
|
|
gfc_option.rtcheck |= GFC_RTCHECK_BOUNDS;
|
|
|
|
if (flag_compare_debug)
|
|
gfc_option.dump_fortran_original = 0;
|
|
|
|
/* Make -fmax-errors visible to gfortran's diagnostic machinery. */
|
|
if (global_options_set.x_flag_max_errors)
|
|
gfc_option.max_errors = flag_max_errors;
|
|
|
|
/* Verify the input file name. */
|
|
if (!filename || strcmp (filename, "-") == 0)
|
|
{
|
|
filename = "";
|
|
}
|
|
|
|
if (gfc_option.flag_preprocessed)
|
|
{
|
|
/* For preprocessed files, if the first tokens are of the form # NUM.
|
|
handle the directives so we know the original file name. */
|
|
gfc_source_file = gfc_read_orig_filename (filename, &canon_source_file);
|
|
if (gfc_source_file == NULL)
|
|
gfc_source_file = filename;
|
|
else
|
|
*pfilename = gfc_source_file;
|
|
}
|
|
else
|
|
gfc_source_file = filename;
|
|
|
|
if (canon_source_file == NULL)
|
|
canon_source_file = gfc_source_file;
|
|
|
|
/* Adds the path where the source file is to the list of include files. */
|
|
|
|
i = strlen (canon_source_file);
|
|
while (i > 0 && !IS_DIR_SEPARATOR (canon_source_file[i]))
|
|
i--;
|
|
|
|
if (i != 0)
|
|
{
|
|
source_path = (char *) alloca (i + 1);
|
|
memcpy (source_path, canon_source_file, i);
|
|
source_path[i] = 0;
|
|
gfc_add_include_path (source_path, true, true, true);
|
|
}
|
|
else
|
|
gfc_add_include_path (".", true, true, true);
|
|
|
|
if (canon_source_file != gfc_source_file)
|
|
free (CONST_CAST (char *, canon_source_file));
|
|
|
|
/* 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");
|
|
}
|
|
|
|
/* 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;
|
|
|
|
if (!gfc_option.flag_automatic && gfc_option.flag_max_stack_var_size != -2
|
|
&& gfc_option.flag_max_stack_var_size != 0)
|
|
gfc_warning_now ("Flag -fno-automatic overwrites -fmax-stack-var-size=%d",
|
|
gfc_option.flag_max_stack_var_size);
|
|
else if (!gfc_option.flag_automatic && gfc_option.flag_recursive)
|
|
gfc_warning_now ("Flag -fno-automatic overwrites -frecursive");
|
|
else if (!gfc_option.flag_automatic && gfc_option.gfc_flag_openmp)
|
|
gfc_warning_now ("Flag -fno-automatic overwrites -frecursive implied by "
|
|
"-fopenmp");
|
|
else if (gfc_option.flag_max_stack_var_size != -2
|
|
&& gfc_option.flag_recursive)
|
|
gfc_warning_now ("Flag -frecursive overwrites -fmax-stack-var-size=%d",
|
|
gfc_option.flag_max_stack_var_size);
|
|
else if (gfc_option.flag_max_stack_var_size != -2
|
|
&& gfc_option.gfc_flag_openmp)
|
|
gfc_warning_now ("Flag -fmax-stack-var-size=%d overwrites -frecursive "
|
|
"implied by -fopenmp",
|
|
gfc_option.flag_max_stack_var_size);
|
|
|
|
/* Implement -frecursive as -fmax-stack-var-size=-1. */
|
|
if (gfc_option.flag_recursive)
|
|
gfc_option.flag_max_stack_var_size = -1;
|
|
|
|
/* Implied -frecursive; implemented as -fmax-stack-var-size=-1. */
|
|
if (gfc_option.flag_max_stack_var_size == -2 && gfc_option.gfc_flag_openmp
|
|
&& gfc_option.flag_automatic)
|
|
{
|
|
gfc_option.flag_recursive = 1;
|
|
gfc_option.flag_max_stack_var_size = -1;
|
|
}
|
|
|
|
/* Set default. */
|
|
if (gfc_option.flag_max_stack_var_size == -2)
|
|
gfc_option.flag_max_stack_var_size = 32768;
|
|
|
|
/* Implement -fno-automatic as -fmax-stack-var-size=0. */
|
|
if (!gfc_option.flag_automatic)
|
|
gfc_option.flag_max_stack_var_size = 0;
|
|
|
|
if (pedantic)
|
|
{
|
|
gfc_option.warn_ampersand = 1;
|
|
gfc_option.warn_tabs = 0;
|
|
}
|
|
|
|
/* Optimization implies front end optimization, unless the user
|
|
specified it directly. */
|
|
|
|
if (gfc_option.flag_frontend_optimize == -1)
|
|
gfc_option.flag_frontend_optimize = optimize;
|
|
|
|
if (gfc_option.warn_realloc_lhs_all)
|
|
gfc_option.warn_realloc_lhs = 1;
|
|
|
|
gfc_cpp_post_options ();
|
|
|
|
/* FIXME: return gfc_cpp_preprocess_only ();
|
|
|
|
The return value of this function indicates whether the
|
|
backend needs to be initialized. On -E, we don't need
|
|
the backend. However, if we return 'true' here, an
|
|
ICE occurs. Initializing the backend doesn't hurt much,
|
|
hence, for now we can live with it as is. */
|
|
return false;
|
|
}
|
|
|
|
|
|
/* Set the options for -Wall. */
|
|
|
|
static void
|
|
set_Wall (int setting)
|
|
{
|
|
gfc_option.warn_aliasing = setting;
|
|
gfc_option.warn_ampersand = setting;
|
|
gfc_option.warn_c_binding_type = setting;
|
|
gfc_option.gfc_warn_conversion = setting;
|
|
gfc_option.warn_line_truncation = setting;
|
|
gfc_option.warn_surprising = setting;
|
|
gfc_option.warn_tabs = !setting;
|
|
gfc_option.warn_underflow = setting;
|
|
gfc_option.warn_intrinsic_shadow = setting;
|
|
gfc_option.warn_intrinsics_std = setting;
|
|
gfc_option.warn_character_truncation = setting;
|
|
gfc_option.warn_real_q_constant = setting;
|
|
gfc_option.warn_unused_dummy_argument = setting;
|
|
gfc_option.warn_target_lifetime = setting;
|
|
gfc_option.warn_zerotrip = setting;
|
|
|
|
warn_return_type = setting;
|
|
warn_uninitialized = setting;
|
|
warn_maybe_uninitialized = setting;
|
|
}
|
|
|
|
/* Set the options for -Wextra. */
|
|
|
|
static void
|
|
set_Wextra (int setting)
|
|
{
|
|
gfc_option.warn_compare_reals = setting;
|
|
}
|
|
|
|
static void
|
|
gfc_handle_module_path_options (const char *arg)
|
|
{
|
|
|
|
if (gfc_option.module_dir != NULL)
|
|
gfc_fatal_error ("gfortran: Only one -J option allowed");
|
|
|
|
gfc_option.module_dir = XCNEWVEC (char, strlen (arg) + 2);
|
|
strcpy (gfc_option.module_dir, arg);
|
|
|
|
gfc_add_include_path (gfc_option.module_dir, true, false, true);
|
|
|
|
strcat (gfc_option.module_dir, "/");
|
|
}
|
|
|
|
|
|
/* Handle options -ffpe-trap= and -ffpe-summary=. */
|
|
|
|
static void
|
|
gfc_handle_fpe_option (const char *arg, bool trap)
|
|
{
|
|
int result, pos = 0, n;
|
|
/* precision is a backwards compatibility alias for inexact. */
|
|
static const char * const exception[] = { "invalid", "denormal", "zero",
|
|
"overflow", "underflow",
|
|
"inexact", "precision", NULL };
|
|
static const int opt_exception[] = { GFC_FPE_INVALID, GFC_FPE_DENORMAL,
|
|
GFC_FPE_ZERO, GFC_FPE_OVERFLOW,
|
|
GFC_FPE_UNDERFLOW, GFC_FPE_INEXACT,
|
|
GFC_FPE_INEXACT,
|
|
0 };
|
|
|
|
/* As the default for -ffpe-summary= is nonzero, set it to 0. */
|
|
if (!trap)
|
|
gfc_option.fpe_summary = 0;
|
|
|
|
while (*arg)
|
|
{
|
|
while (*arg == ',')
|
|
arg++;
|
|
|
|
while (arg[pos] && arg[pos] != ',')
|
|
pos++;
|
|
|
|
result = 0;
|
|
if (!trap && strncmp ("none", arg, pos) == 0)
|
|
{
|
|
gfc_option.fpe_summary = 0;
|
|
arg += pos;
|
|
pos = 0;
|
|
continue;
|
|
}
|
|
else if (!trap && strncmp ("all", arg, pos) == 0)
|
|
{
|
|
gfc_option.fpe_summary = GFC_FPE_INVALID | GFC_FPE_DENORMAL
|
|
| GFC_FPE_ZERO | GFC_FPE_OVERFLOW
|
|
| GFC_FPE_UNDERFLOW | GFC_FPE_INEXACT;
|
|
arg += pos;
|
|
pos = 0;
|
|
continue;
|
|
}
|
|
else
|
|
for (n = 0; exception[n] != NULL; n++)
|
|
{
|
|
if (exception[n] && strncmp (exception[n], arg, pos) == 0)
|
|
{
|
|
if (trap)
|
|
gfc_option.fpe |= opt_exception[n];
|
|
else
|
|
gfc_option.fpe_summary |= opt_exception[n];
|
|
arg += pos;
|
|
pos = 0;
|
|
result = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!result && !trap)
|
|
gfc_fatal_error ("Argument to -ffpe-trap is not valid: %s", arg);
|
|
else if (!result)
|
|
gfc_fatal_error ("Argument to -ffpe-summary is not valid: %s", arg);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
gfc_handle_coarray_option (const char *arg)
|
|
{
|
|
if (strcmp (arg, "none") == 0)
|
|
gfc_option.coarray = GFC_FCOARRAY_NONE;
|
|
else if (strcmp (arg, "single") == 0)
|
|
gfc_option.coarray = GFC_FCOARRAY_SINGLE;
|
|
else if (strcmp (arg, "lib") == 0)
|
|
gfc_option.coarray = GFC_FCOARRAY_LIB;
|
|
else
|
|
gfc_fatal_error ("Argument to -fcoarray is not valid: %s", arg);
|
|
}
|
|
|
|
|
|
static void
|
|
gfc_handle_runtime_check_option (const char *arg)
|
|
{
|
|
int result, pos = 0, n;
|
|
static const char * const optname[] = { "all", "bounds", "array-temps",
|
|
"recursion", "do", "pointer",
|
|
"mem", NULL };
|
|
static const int optmask[] = { GFC_RTCHECK_ALL, GFC_RTCHECK_BOUNDS,
|
|
GFC_RTCHECK_ARRAY_TEMPS,
|
|
GFC_RTCHECK_RECURSION, GFC_RTCHECK_DO,
|
|
GFC_RTCHECK_POINTER, GFC_RTCHECK_MEM,
|
|
0 };
|
|
|
|
while (*arg)
|
|
{
|
|
while (*arg == ',')
|
|
arg++;
|
|
|
|
while (arg[pos] && arg[pos] != ',')
|
|
pos++;
|
|
|
|
result = 0;
|
|
for (n = 0; optname[n] != NULL; n++)
|
|
{
|
|
if (optname[n] && strncmp (optname[n], arg, pos) == 0)
|
|
{
|
|
gfc_option.rtcheck |= optmask[n];
|
|
arg += pos;
|
|
pos = 0;
|
|
result = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (!result)
|
|
gfc_fatal_error ("Argument to -fcheck is not valid: %s", arg);
|
|
}
|
|
}
|
|
|
|
|
|
/* Handle command-line options. Returns 0 if unrecognized, 1 if
|
|
recognized and handled. */
|
|
|
|
bool
|
|
gfc_handle_option (size_t scode, const char *arg, int value,
|
|
int kind ATTRIBUTE_UNUSED, location_t loc ATTRIBUTE_UNUSED,
|
|
const struct cl_option_handlers *handlers ATTRIBUTE_UNUSED)
|
|
{
|
|
bool result = true;
|
|
enum opt_code code = (enum opt_code) scode;
|
|
|
|
if (gfc_cpp_handle_option (scode, arg, value) == 1)
|
|
return true;
|
|
|
|
switch (code)
|
|
{
|
|
default:
|
|
result = false;
|
|
break;
|
|
|
|
case OPT_Wall:
|
|
handle_generated_option (&global_options, &global_options_set,
|
|
OPT_Wunused, NULL, value,
|
|
gfc_option_lang_mask (), kind, loc,
|
|
handlers, global_dc);
|
|
set_Wall (value);
|
|
break;
|
|
|
|
case OPT_Waliasing:
|
|
gfc_option.warn_aliasing = value;
|
|
break;
|
|
|
|
case OPT_Wampersand:
|
|
gfc_option.warn_ampersand = value;
|
|
break;
|
|
|
|
case OPT_Warray_temporaries:
|
|
gfc_option.warn_array_temp = value;
|
|
break;
|
|
|
|
case OPT_Wc_binding_type:
|
|
gfc_option.warn_c_binding_type = value;
|
|
break;
|
|
|
|
case OPT_Wcharacter_truncation:
|
|
gfc_option.warn_character_truncation = value;
|
|
break;
|
|
|
|
case OPT_Wcompare_reals:
|
|
gfc_option.warn_compare_reals = value;
|
|
break;
|
|
|
|
case OPT_Wconversion:
|
|
gfc_option.gfc_warn_conversion = value;
|
|
break;
|
|
|
|
case OPT_Wconversion_extra:
|
|
gfc_option.warn_conversion_extra = value;
|
|
break;
|
|
|
|
case OPT_Wextra:
|
|
handle_generated_option (&global_options, &global_options_set,
|
|
OPT_Wunused_parameter, NULL, value,
|
|
gfc_option_lang_mask (), kind, loc,
|
|
handlers, global_dc);
|
|
set_Wextra (value);
|
|
|
|
break;
|
|
|
|
case OPT_Wfunction_elimination:
|
|
gfc_option.warn_function_elimination = value;
|
|
break;
|
|
|
|
case OPT_Wimplicit_interface:
|
|
gfc_option.warn_implicit_interface = value;
|
|
break;
|
|
|
|
case OPT_Wimplicit_procedure:
|
|
gfc_option.warn_implicit_procedure = value;
|
|
break;
|
|
|
|
case OPT_Wline_truncation:
|
|
gfc_option.warn_line_truncation = value;
|
|
break;
|
|
|
|
case OPT_Wrealloc_lhs:
|
|
gfc_option.warn_realloc_lhs = value;
|
|
break;
|
|
|
|
case OPT_Wrealloc_lhs_all:
|
|
gfc_option.warn_realloc_lhs_all = value;
|
|
break;
|
|
|
|
case OPT_Wreturn_type:
|
|
warn_return_type = value;
|
|
break;
|
|
|
|
case OPT_Wsurprising:
|
|
gfc_option.warn_surprising = value;
|
|
break;
|
|
|
|
case OPT_Wtabs:
|
|
gfc_option.warn_tabs = value;
|
|
break;
|
|
|
|
case OPT_Wtarget_lifetime:
|
|
gfc_option.warn_target_lifetime = value;
|
|
break;
|
|
|
|
case OPT_Wunderflow:
|
|
gfc_option.warn_underflow = value;
|
|
break;
|
|
|
|
case OPT_Wintrinsic_shadow:
|
|
gfc_option.warn_intrinsic_shadow = value;
|
|
break;
|
|
|
|
case OPT_Walign_commons:
|
|
gfc_option.warn_align_commons = value;
|
|
break;
|
|
|
|
case OPT_Wreal_q_constant:
|
|
gfc_option.warn_real_q_constant = value;
|
|
break;
|
|
|
|
case OPT_Wunused_dummy_argument:
|
|
gfc_option.warn_unused_dummy_argument = value;
|
|
break;
|
|
|
|
case OPT_Wzerotrip:
|
|
gfc_option.warn_zerotrip = value;
|
|
break;
|
|
|
|
case OPT_fall_intrinsics:
|
|
gfc_option.flag_all_intrinsics = 1;
|
|
break;
|
|
|
|
case OPT_fautomatic:
|
|
gfc_option.flag_automatic = value;
|
|
break;
|
|
|
|
case OPT_fallow_leading_underscore:
|
|
gfc_option.flag_allow_leading_underscore = value;
|
|
break;
|
|
|
|
case OPT_fbackslash:
|
|
gfc_option.flag_backslash = value;
|
|
break;
|
|
|
|
case OPT_fbacktrace:
|
|
gfc_option.flag_backtrace = value;
|
|
break;
|
|
|
|
case OPT_fcheck_array_temporaries:
|
|
gfc_option.rtcheck |= GFC_RTCHECK_ARRAY_TEMPS;
|
|
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_fexternal_blas:
|
|
gfc_option.flag_external_blas = value;
|
|
break;
|
|
|
|
case OPT_fblas_matmul_limit_:
|
|
gfc_option.blas_matmul_limit = 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_fortran_original:
|
|
case OPT_fdump_parse_tree:
|
|
gfc_option.dump_fortran_original = value;
|
|
break;
|
|
|
|
case OPT_fdump_fortran_optimized:
|
|
gfc_option.dump_fortran_optimized = value;
|
|
break;
|
|
|
|
case OPT_ffixed_form:
|
|
gfc_option.source_form = FORM_FIXED;
|
|
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_ffree_form:
|
|
gfc_option.source_form = FORM_FREE;
|
|
break;
|
|
|
|
case OPT_fopenmp:
|
|
gfc_option.gfc_flag_openmp = value;
|
|
break;
|
|
|
|
case OPT_fopenmp_simd:
|
|
gfc_option.gfc_flag_openmp_simd = value;
|
|
break;
|
|
|
|
case OPT_ffree_line_length_none:
|
|
gfc_option.free_line_length = 0;
|
|
break;
|
|
|
|
case OPT_ffree_line_length_:
|
|
if (value != 0 && value < 4)
|
|
gfc_fatal_error ("Free line length must be at least three.");
|
|
gfc_option.free_line_length = value;
|
|
break;
|
|
|
|
case OPT_funderscoring:
|
|
gfc_option.flag_underscoring = value;
|
|
break;
|
|
|
|
case OPT_fsecond_underscore:
|
|
gfc_option.flag_second_underscore = value;
|
|
break;
|
|
|
|
case OPT_static_libgfortran:
|
|
#ifndef HAVE_LD_STATIC_DYNAMIC
|
|
gfc_fatal_error ("-static-libgfortran is not supported in this "
|
|
"configuration");
|
|
#endif
|
|
break;
|
|
|
|
case OPT_fimplicit_none:
|
|
gfc_option.flag_implicit_none = value;
|
|
break;
|
|
|
|
case OPT_fintrinsic_modules_path:
|
|
case OPT_fintrinsic_modules_path_:
|
|
|
|
/* This is needed because omp_lib.h is in a directory together
|
|
with intrinsic modules. Do no warn because during testing
|
|
without an installed compiler, we would get lots of bogus
|
|
warnings for a missing include directory. */
|
|
gfc_add_include_path (arg, false, false, false);
|
|
|
|
gfc_add_intrinsic_modules_path (arg);
|
|
break;
|
|
|
|
case OPT_fmax_array_constructor_:
|
|
gfc_option.flag_max_array_constructor = value > 65535 ? value : 65535;
|
|
break;
|
|
|
|
case OPT_fmax_stack_var_size_:
|
|
gfc_option.flag_max_stack_var_size = value;
|
|
break;
|
|
|
|
case OPT_fstack_arrays:
|
|
gfc_option.flag_stack_arrays = value;
|
|
break;
|
|
|
|
case OPT_fmodule_private:
|
|
gfc_option.flag_module_private = value;
|
|
break;
|
|
|
|
case OPT_frange_check:
|
|
gfc_option.flag_range_check = 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_fpreprocessed:
|
|
gfc_option.flag_preprocessed = value;
|
|
break;
|
|
|
|
case OPT_fmax_identifier_length_:
|
|
if (value > GFC_MAX_SYMBOL_LEN)
|
|
gfc_fatal_error ("Maximum supported identifier length is %d",
|
|
GFC_MAX_SYMBOL_LEN);
|
|
gfc_option.max_identifier_length = 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_finteger_4_integer_8:
|
|
gfc_option.flag_integer4_kind = 8;
|
|
break;
|
|
|
|
case OPT_freal_4_real_8:
|
|
gfc_option.flag_real4_kind = 8;
|
|
break;
|
|
|
|
case OPT_freal_4_real_10:
|
|
gfc_option.flag_real4_kind = 10;
|
|
break;
|
|
|
|
case OPT_freal_4_real_16:
|
|
gfc_option.flag_real4_kind = 16;
|
|
break;
|
|
|
|
case OPT_freal_8_real_4:
|
|
gfc_option.flag_real8_kind = 4;
|
|
break;
|
|
|
|
case OPT_freal_8_real_10:
|
|
gfc_option.flag_real8_kind = 10;
|
|
break;
|
|
|
|
case OPT_freal_8_real_16:
|
|
gfc_option.flag_real8_kind = 16;
|
|
break;
|
|
|
|
case OPT_finit_local_zero:
|
|
gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
|
|
gfc_option.flag_init_integer_value = 0;
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
|
|
gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
|
|
gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
|
|
gfc_option.flag_init_character_value = (char)0;
|
|
break;
|
|
|
|
case OPT_finit_logical_:
|
|
if (!strcasecmp (arg, "false"))
|
|
gfc_option.flag_init_logical = GFC_INIT_LOGICAL_FALSE;
|
|
else if (!strcasecmp (arg, "true"))
|
|
gfc_option.flag_init_logical = GFC_INIT_LOGICAL_TRUE;
|
|
else
|
|
gfc_fatal_error ("Unrecognized option to -finit-logical: %s",
|
|
arg);
|
|
break;
|
|
|
|
case OPT_finit_real_:
|
|
if (!strcasecmp (arg, "zero"))
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_ZERO;
|
|
else if (!strcasecmp (arg, "nan"))
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_NAN;
|
|
else if (!strcasecmp (arg, "snan"))
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_SNAN;
|
|
else if (!strcasecmp (arg, "inf"))
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_INF;
|
|
else if (!strcasecmp (arg, "-inf"))
|
|
gfc_option.flag_init_real = GFC_INIT_REAL_NEG_INF;
|
|
else
|
|
gfc_fatal_error ("Unrecognized option to -finit-real: %s",
|
|
arg);
|
|
break;
|
|
|
|
case OPT_finit_integer_:
|
|
gfc_option.flag_init_integer = GFC_INIT_INTEGER_ON;
|
|
gfc_option.flag_init_integer_value = atoi (arg);
|
|
break;
|
|
|
|
case OPT_finit_character_:
|
|
if (value >= 0 && value <= 127)
|
|
{
|
|
gfc_option.flag_init_character = GFC_INIT_CHARACTER_ON;
|
|
gfc_option.flag_init_character_value = (char)value;
|
|
}
|
|
else
|
|
gfc_fatal_error ("The value of n in -finit-character=n must be "
|
|
"between 0 and 127");
|
|
break;
|
|
|
|
case OPT_I:
|
|
gfc_add_include_path (arg, true, false, true);
|
|
break;
|
|
|
|
case OPT_J:
|
|
gfc_handle_module_path_options (arg);
|
|
break;
|
|
|
|
case OPT_fsign_zero:
|
|
gfc_option.flag_sign_zero = value;
|
|
break;
|
|
|
|
case OPT_ffpe_trap_:
|
|
gfc_handle_fpe_option (arg, true);
|
|
break;
|
|
|
|
case OPT_ffpe_summary_:
|
|
gfc_handle_fpe_option (arg, false);
|
|
break;
|
|
|
|
case OPT_std_f95:
|
|
gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F95 | GFC_STD_F77
|
|
| GFC_STD_F2008_OBS;
|
|
gfc_option.warn_std = GFC_STD_F95_OBS;
|
|
gfc_option.max_continue_fixed = 19;
|
|
gfc_option.max_continue_free = 39;
|
|
gfc_option.max_identifier_length = 31;
|
|
gfc_option.warn_ampersand = 1;
|
|
gfc_option.warn_tabs = 0;
|
|
break;
|
|
|
|
case OPT_std_f2003:
|
|
gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
|
|
| GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008_OBS;
|
|
gfc_option.warn_std = GFC_STD_F95_OBS;
|
|
gfc_option.max_identifier_length = 63;
|
|
gfc_option.warn_ampersand = 1;
|
|
gfc_option.warn_tabs = 0;
|
|
break;
|
|
|
|
case OPT_std_f2008:
|
|
gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
|
|
| GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008 | GFC_STD_F2008_OBS;
|
|
gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS;
|
|
gfc_option.max_identifier_length = 63;
|
|
gfc_option.warn_ampersand = 1;
|
|
gfc_option.warn_tabs = 0;
|
|
break;
|
|
|
|
case OPT_std_f2008ts:
|
|
gfc_option.allow_std = GFC_STD_F95_OBS | GFC_STD_F77
|
|
| GFC_STD_F2003 | GFC_STD_F95 | GFC_STD_F2008 | GFC_STD_F2008_OBS
|
|
| GFC_STD_F2008_TS;
|
|
gfc_option.warn_std = GFC_STD_F95_OBS | GFC_STD_F2008_OBS;
|
|
gfc_option.max_identifier_length = 63;
|
|
gfc_option.warn_ampersand = 1;
|
|
gfc_option.warn_tabs = 0;
|
|
break;
|
|
|
|
case OPT_std_gnu:
|
|
set_default_std_flags ();
|
|
break;
|
|
|
|
case OPT_std_legacy:
|
|
set_default_std_flags ();
|
|
gfc_option.warn_std = 0;
|
|
break;
|
|
|
|
case OPT_Wintrinsics_std:
|
|
gfc_option.warn_intrinsics_std = value;
|
|
break;
|
|
|
|
case OPT_fshort_enums:
|
|
/* Handled in language-independent code. */
|
|
break;
|
|
|
|
case OPT_fconvert_little_endian:
|
|
gfc_option.convert = GFC_CONVERT_LITTLE;
|
|
break;
|
|
|
|
case OPT_fconvert_big_endian:
|
|
gfc_option.convert = GFC_CONVERT_BIG;
|
|
break;
|
|
|
|
case OPT_fconvert_native:
|
|
gfc_option.convert = GFC_CONVERT_NATIVE;
|
|
break;
|
|
|
|
case OPT_fconvert_swap:
|
|
gfc_option.convert = GFC_CONVERT_SWAP;
|
|
break;
|
|
|
|
case OPT_frecord_marker_4:
|
|
gfc_option.record_marker = 4;
|
|
break;
|
|
|
|
case OPT_frecord_marker_8:
|
|
gfc_option.record_marker = 8;
|
|
break;
|
|
|
|
case OPT_fmax_subrecord_length_:
|
|
if (value > MAX_SUBRECORD_LENGTH)
|
|
gfc_fatal_error ("Maximum subrecord length cannot exceed %d",
|
|
MAX_SUBRECORD_LENGTH);
|
|
|
|
gfc_option.max_subrecord_length = value;
|
|
break;
|
|
|
|
case OPT_frecursive:
|
|
gfc_option.flag_recursive = value;
|
|
break;
|
|
|
|
case OPT_falign_commons:
|
|
gfc_option.flag_align_commons = value;
|
|
break;
|
|
|
|
case OPT_faggressive_function_elimination:
|
|
gfc_option.flag_aggressive_function_elimination = value;
|
|
break;
|
|
|
|
case OPT_ffrontend_optimize:
|
|
gfc_option.flag_frontend_optimize = value;
|
|
break;
|
|
|
|
case OPT_fprotect_parens:
|
|
gfc_option.flag_protect_parens = value;
|
|
break;
|
|
|
|
case OPT_frealloc_lhs:
|
|
gfc_option.flag_realloc_lhs = value;
|
|
break;
|
|
|
|
case OPT_fcheck_:
|
|
gfc_handle_runtime_check_option (arg);
|
|
break;
|
|
|
|
case OPT_fcoarray_:
|
|
gfc_handle_coarray_option (arg);
|
|
break;
|
|
}
|
|
|
|
Fortran_handle_option_auto (&global_options, &global_options_set,
|
|
scode, arg, value,
|
|
gfc_option_lang_mask (), kind,
|
|
loc, handlers, global_dc);
|
|
return result;
|
|
}
|
|
|
|
|
|
/* Return a string with the options passed to the compiler; used for
|
|
Fortran's compiler_options() intrinsic. */
|
|
|
|
char *
|
|
gfc_get_option_string (void)
|
|
{
|
|
unsigned j;
|
|
size_t len, pos;
|
|
char *result;
|
|
|
|
/* Allocate and return a one-character string with '\0'. */
|
|
if (!save_decoded_options_count)
|
|
return XCNEWVEC (char, 1);
|
|
|
|
/* Determine required string length. */
|
|
|
|
len = 0;
|
|
for (j = 1; j < save_decoded_options_count; j++)
|
|
{
|
|
switch (save_decoded_options[j].opt_index)
|
|
{
|
|
case OPT_o:
|
|
case OPT_d:
|
|
case OPT_dumpbase:
|
|
case OPT_dumpdir:
|
|
case OPT_auxbase:
|
|
case OPT_quiet:
|
|
case OPT_version:
|
|
case OPT_fintrinsic_modules_path:
|
|
case OPT_fintrinsic_modules_path_:
|
|
/* Ignore these. */
|
|
break;
|
|
default:
|
|
/* Ignore file names. */
|
|
if (save_decoded_options[j].orig_option_with_args_text[0] == '-')
|
|
len += 1
|
|
+ strlen (save_decoded_options[j].orig_option_with_args_text);
|
|
}
|
|
}
|
|
|
|
result = XCNEWVEC (char, len);
|
|
|
|
pos = 0;
|
|
for (j = 1; j < save_decoded_options_count; j++)
|
|
{
|
|
switch (save_decoded_options[j].opt_index)
|
|
{
|
|
case OPT_o:
|
|
case OPT_d:
|
|
case OPT_dumpbase:
|
|
case OPT_dumpdir:
|
|
case OPT_auxbase:
|
|
case OPT_quiet:
|
|
case OPT_version:
|
|
case OPT_fintrinsic_modules_path:
|
|
case OPT_fintrinsic_modules_path_:
|
|
/* Ignore these. */
|
|
continue;
|
|
|
|
case OPT_cpp_:
|
|
/* Use "-cpp" rather than "-cpp=<temporary file>". */
|
|
len = 4;
|
|
break;
|
|
|
|
default:
|
|
/* Ignore file names. */
|
|
if (save_decoded_options[j].orig_option_with_args_text[0] != '-')
|
|
continue;
|
|
|
|
len = strlen (save_decoded_options[j].orig_option_with_args_text);
|
|
}
|
|
|
|
memcpy (&result[pos], save_decoded_options[j].orig_option_with_args_text, len);
|
|
pos += len;
|
|
result[pos++] = ' ';
|
|
}
|
|
|
|
result[--pos] = '\0';
|
|
return result;
|
|
}
|