CodeSonar Front-end Options

--add_named_address_space=name[,parent_name]

When using the Renesas SuperH RISC engine family compiler model with DSP-C enabled, define a named address space called name (optionally, that lies within the space named parent_name).

--aligned_new
--no_aligned_new

[C++17 only] Enable or disable calling special allocation and deallocation functions for types with more stringent alignment requirements than the basic types.

--alternative_tokens
--no_alternative_tokens

Enable or disable recognition of alternative tokens. This controls recognition of the digraph tokens in C and C++.

--arm_asm

Enables the ARM assembly code extension.

--asm_functions
--no_asm_functions

Control whether ASM functions are allowed. Examples of ASM functions are

asm void f(int a, int b) { }
__asm void g(int a, int b) { }

ASM functions are parsed but ignored. Their bodies are represented by a single program point of kind unavailable. The scope of an ASM function is local to the file. By default, ASM functions are not allowed.

--auto_type
--no_auto_type

[C++ only] Enable or disable auto as a type specifier. Enabling auto as a type specifier will disable it as a storage class specifier.

--bool
--no_bool

[C++ only] Enable or disable recognition of bool.

--brief_diagnostics
--no_brief_diagnostics

Enable or disable a mode in which a shorter form of the diagnostic output is used. When enabled, the original source line is not displayed and the error message text is not wrapped when too long to fit on a single line. The mode is disabled by default.

--c++03

Explicitly disable all C++11 features (although individual features can be enabled on the command line). Enable C++ mode.

--c++0x
--c++11
--no_c++0x
--no_c++11

Enable or disable C++11 extensions.

--c++11_sfinae
--no_c++11_sfinae

Enable or disable template deduction in the style dictated by the C++11 standard. (SFINAE: Substitution Failure Is Not An Error)

--c++11_sfinae_ignore_access
--no_c++11_sfinae_ignore_access

When front end option --c++11 or --c++11_sfinae is specified, controls the handling of access errors.

--c++11_sfinae_ignore_access: access errors cannot cause deduction failure.
--no_c++11_sfinae_ignore_access: access errors cause deduction failure.

If neither --c++11 nor --c++11_sfinae is specified, these options have no effect.

--c++14

Enable C++14 extensions. Cannot be used with options enabling/requiring a C mode.

--c++17

Enable C++17 extensions. Cannot be used with options enabling/requiring a C mode.

--c++20

Enable C++20 extensions. Cannot be used with options enabling/requiring a C mode.

--c++cli
--ccppcli
--clr

[Microsoft C++ only] Enable compilation of C++/CLI source.

--c
-m

Enable compilation of C rather than C++.

--c89

Enable compilation of C rather than C++, specify the C89 version of C.

--c99

Enable compilation of C rather than C++, specify the C99 version of C.

--c11

Enable C11 extensions. Cannot be used with options enabling/requiring a C++ mode.

--c18
--c17

Enable C18 extensions. Cannot be used with options enabling/requiring a C++ mode.

--cfront3.0

[C++ only] Enable compatibility with the AT&T C++ Language System (cfront) release 3.0; also enable acceptance of anachronisms.

--clang
--no_clang

Enable/disable Clang C or C++ language compatibility features (including GNU language compatiblility features).

--clang_version ver

Specifies the Clang compiler version to emulate. Version x.y.z of the Clang compiler is encoded as x*10000+y*100+z.

--comments
-C

Keep comments in preprocessed code.

--compound_literals
--no_compound_literals

Enable or disable support for compound literals.

--const_string_literals
--no_const_string_literals

Control whether C++ string literals and wide string literals are const (as required by the standard) or non-const (as was true in earlier versions of the C++ language).

--context_limit number

Set the context limit to number. The context limit is the maximum number of template instantiation context entries to be displayed as part of a diagnostic message. If the number of context entries exceeds the limit, the first and last N context entries are displayed, where N is half of the context limit. A value of zero is used to indicate that there is no limit.

--cs_allow_empty_braced_init

Allow empty braced initializers {}.

--cs_allow_feature_test_macros

Allow Clang-style feature-test macros.

--cs_allow_flexible_array_init

Allow braced initializers {...} for flexible array members. Zero-length arrays are permitted.

--cs_allow_gnu_vector_conversion

Specifies that certain implicit conversions between incompatible vector types should be accepted.

--cs_allow_nonstandard_anonymous_unions

Specifies that anonymous structs and unions should be accepted.

--cs_alignas
--cs_no_alignas

[C++ only] Enable/disable the use of the alignas specifier.

--cs_apple_clang

Enable/disable Apple-specific Clang C or C++ language compatibility features.

--cs_armclang

Enable Arm Compiler C or C++ language compatibility features.

--cs_builtin_va_list

Enable the builtin type __builtin_va_list.

--cs_c11_atomic_keyword

Enable recognition of the C11 _Atomic keyword.

--cs_capture_star_this

[C++ only] Allow capture of *this in lambda expressions.

--cs_case_range

Enable GNU case ranges.

--cs_char_t_keywords
--cs_no_char_t_keywords

Enable/disable recognition of the char16_t and char32_t keywords.

--cs_constexpr
--cs_no_constexpr

[C++ only] Enable/disable the use of the constexpr specifier.

--cs_constexpr_if

[C++ only] Allow the use of if constexpr(condition) to create if statements whose condition is evaluated as a compile-time constant.

--cs_constexpr_lambdas

[C++ only] Allow the use of lambdas inside constexpr declarations.

--cs_create_pch

[For use with Microsoft Visual Studio only] Specifies that one of the results of the compilation will be a precompiled header (PCH).

The generated PCH file will contain information about the compilation from the start of the top level source file up to and including header stop location, which is determined as follows.

If --cs_create_pch_hdrstop stopfilename is specified, the header stop location is the (end of the) first inclusion of stopfilename with #include stopfilename (even if occurrences of #pragma hdrstop are encountered).
Otherwise, if there are one or more occurrences of #pragma hdrstop in the compilation, the header stop location is the end of the first such occurrence encountered.
Otherwise, the generated PCH file will contain information about the entire compilation.

The name of the precompiled header file will be determined as follows.

If --cs_pch_name pfilepath is specified, the PCH file will be written to pfilepath. If pfilepath does not include a path specification, the PCH file will be a sibling of the top level file in the compilation
Otherwise, if precompilation encounters #pragma hdrstop(pragmafpath) directive, the PCH file will be written to pragmafpath. If pragmafpath does not include a path specification, the PCH file will be a sibling of the top level file in the compilation.
Note that if --cs_create_pch_hdrstop is specified, precompilation will proceed past the pragma.
Otherwise, the PCH file will be written to tlfname.pch, where tlfname.ext is the top-level file in the compilation, and will be a sibling of tlfname.ext.

--cs_create_pch_hdrstop stopfilename

[For use with Microsoft Visual Studio only] When --cs_create_pch is specified, specifies the name of the header file location at which precompilation stops. Precompilation proceeds from the start of the top level source file up to and including the (first) inclusion of stopfilename, even if occurrences of #pragma hdrstop are encountered.

When --cs_create_pch is not specified this option has no effect.

--cs_darwin_system_framework dir

Adds framework directory dir to the list of system include directories.

--cs_darwin_user_framework dir

Adds framework directory dir to the list of include directories.

--cs_declspec
--cs_no_declspec

Enable/Disable the use of the __declspec attribute.

--cs_decltype
--cs_no_decltype

[C++ only] Enable/disable the use of the decltype specifier.

--cs_decltype_auto

[C++ only] Allow the use of decltype(auto) as a placeholder type specifier. The deduced type will be decltype(expr) where expr is the initializer. For example:

auto c0 = a;             // type of c0 is int, holding a copy of a
decltype(auto) c1 = a;   // type of c1 is int, holding a copy of a
decltype(auto) c2 = (a); // type of c2 is int&, an alias of a

--cs_define_edg_macros

Defines macros __EDG__ and __EDG_VERSION__.

--cs_deleted_functions

[C++ only] Allow disabling of member functions via the use of the delete operator.

--cs_enum_qualifiers

[C++ only] Allow the use of scoped enumeration types (enum classes).

--cs_explicit_enum_base

[C++ only] Allow the specification of a base type for enums. For example:

enum E: signed char { e1 = -1, e2 = 1 };

--cs_explicit_conversion_functions

[C++ only] Allow the explicit specifier to be applied to user-defined conversion functions.

--cs_ext_anonymous_variables

Allows struct variables to be declared without names and their fields accessed directly.

struct {
   int field;
};
void test(void) {
   field = 7;
}

--cs_ext_asm_endasm

Allows code that includes the #asm...#endasm construct, as in the following example.

#asm
    movl %esp, %ebp
#endasm

--cs_ext_at_address

Allows code to specify the address at which a variable is to be stored using @.

int x @ 0x1234;

Note: A variable that is declared with both an at-addresses and an initialization will cause a parse error.

--cs_ext_binary_number

Allows code that specifies numbers in binary notation using 0b or 0B.

int x = 0b101; /* x == 5 */

--cs_ext_c99_for_init

[C90] Permits variable declarations in the first ("initialization") clause of a for loop header, as in C99 and C++.

for( int i = 0; i < 15; ++i ) 
    /* ... */

--cs_ext_conv_incompat_pointer

Conversions between incompatible pointer types will cause warnings rather than errors.

void foo(int *ip);
void bar() {
    double d;
    foo(&d); /* compiler warning (not error) here */
}

--cs_ext_declaration_after_statement

Allows code to contain a declaration after a statement in a block (forbidden in ANSI/ISO C before C99).

int i;        /* declaration */
i = myint();  /* statement */
int j;        /* declaration after a statement */

--cs_ext_header_map A=B

Instructs the preprocessor to treat all directives of the form

#include "A"
/* or */
#include <A>

as if they read

#include "B"
/* or */
#include <B>
/* (respectively) */

--cs_ext_incomplete_enum_type

Allows code that uses enum types that have been declared but not defined, as in the following example.

typedef enum A A_t;
A_t a;

enum X;
enum X y;

int main() {
    a = 0;
    y = 7;
    return 0;
}

--cs_ext_openmp

Enable support for OpenMP pragmas, such as #pragma omp parallel.

--cs_ext_pragma_asm_endasm

Allows code that contains assembly statements delimited by #pragma asm ... #pragma endasm

int main() {
#pragma asm
    movl %esp, %ebp
#pragma endasm
    return 0;
}

--cs_ext_zero_size_array

Allows code that declares arrays of size zero, as in the following example.

struct S {
    int field[0]; 
};

int var[0];

int main() {
    sizeof(struct S);  /* 4 */
    sizeof(var);       /* 0 */
}

--cs_extern_template_allowed

[C++ only] Allow explicit instantiation declarations of class templates (extern templates).

--cs_false_is_null_pointer_constant

Allow the use of false as a null pointer constant.

--cs_flexible_array_members

Allows the use of C99 flexible array members in structs. For example:

struct vectord {
   size_t len;
   double arr[]; // the flexible array member must be last
};

--cs_fold_expressions

Accept C++17 fold expressions.

--cs_gnu_asm

Accept the subset of GNU-style extended asm that does not include qualifiers volatile or goto.

--cs_gnu_attributes_enabled

Enables support for the GNU __attribute__ C extension.

--cs_iar

Enable IAR C or C++ language compatibility features.

--cs_in_class_specialization
--cs_no_in_class_specialization

Enable/disable in-class specializations.

--cs_import_directive

Enables the #import directive.

This option is available for the dcc (all versions) and gcc (version 3.0 and higher) compiler models. (Do not use with the cl model: the #import directive that this enables is different to the one in cl.)

--cs_inline_namespaces

[C++ only] Allow the use of C++11 inline namespaces.

--cs_inline_variables_allowed

[C++ only] Allow the inline specifier to be applied to variable declarations.

--cs_list_init

[C++ only] Allow the initialization of objects with a braced initializer list.

--cs_local_types_as_template_args

[C++ only] Allow local and unnamed types to be used as template arguments.

--cs_model_abi_key K

Informs CodeSonar that the compilation should be associated with ABI key K.

This option is provided for use by custom compiler models. If you want to specify an ABI key to the front end through EDG_FRONTEND_OPTIONS_APPEND or EDG_FRONTEND_OPTIONS_PREPEND, use --cs_user_abi_key.

Note that specifying --cs_model_abi_key K does not cause CodeSonar to generate or use a project-compiler configuration file whose name includes K. Only ABI keys specified with COMPILER_MODELS rules have this effect.

For more information, see Compiler Models: ABI Keys.

--cs_ms_asm

Enable Microsoft-style ASM syntax.

--cs_namespace_attributes

[C++ only] Allow the use of attributes for namespaces.

--cs_noexcept
--cs_no_noexcept

[C++ only] Enable/disable recognition of the noexcept keyword.

--cs_pch_name filepath

[For use with Microsoft Visual Studio only] Specifies the pathname of the precompiled header to use when --cs_create_pch or --cs_use_pch is specified.

filepath should be a path to a file (not a path to a directory).

--cs_range_based_for

[C++ only] Allow range-based for loops.

--cs_ref_qualifiers

[C++ only] Allow the use of rvalue references for *this.

--cs_relaxed_constexpr
--cs_no_relaxed_constexpr

[C++ only] Relax a number of restrictions on constexpr functions, as follows.

Allow declarations within constexpr functions, with the exception of static, thread_local, and uninitialized variable declarations which remain forbidden.
Allow if and switch statements.
Allow all loop statement types: for (including range-based for), while, and do-while
Allow mutation of objects whose lifetime began within the constant expression evaluation.

--cs_relaxed_range_based_for

[C++ only] Allow the beginning and end types of a range-based for loop to be different types.

--cs_rvalue_allowed_with_const_qual_memptr

[C++ only] Accept pointer-to-member expressions where the object is an rvalue and the pointer to member is const&-qualified. For example:

struct X { void myfunc() const&; };
(X{}.*&X::myfunc)();

--cs_selection_initializers

[C++ only] Accept if and switch statements with a separate initializer. For example:

status_code f() {
    if (status_code c = g(); c != SUCCESS) {
        return c;
    }
    // ...
}

--cs_sized_int

Enables support for sized integer types __int8, __int16, __int32, __int64.

--cs_static_assert
--cs_no_static_assert

[C++ only] Enable/disable the C++11 static_assert keyword.

--cs_struct_bindings

Accept C++17 structured bindings.

--cs_targ_alignof_double n

Specifies the default alignment of a double, in bytes. Equivalent to configuration parameter setting CS_TARG_ALIGNOF_DOUBLE=n.

If --cs_targ_alignof_double is specified and CS_TARG_ALIGNOF_DOUBLE is set, --cs_targ_alignof_double takes precedence.

--cs_targ_alignof_long_double n

Specifies the default alignment of a long double, in bytes. Equivalent to configuration parameter setting CS_TARG_ALIGNOF_LONG_DOUBLE=n.

If --cs_targ_alignof_long_double is specified and CS_TARG_ALIGNOF_LONG_DOUBLE is set, --cs_targ_alignof_long_double takes precedence.

--cs_targ_double_field_alignment n

Specifies the default alignment for fields of type double, in bytes. This could be different from the intrinsic alignment of double. Equivalent to configuration parameter setting CS_TARG_DOUBLE_FIELD_ALIGNMENT=n.

If --cs_targ_double_field_alignment is specified and CS_TARG_DOUBLE_FIELD_ALIGNMENT is set, --cs_targ_double_field_alignment takes precedence.

--cs_targ_long_double_field_alignment n

Specifies the default alignment for fields of type long double, in bytes. This could be different from the intrinsic alignment of long double. Equivalent to configuration parameter setting CS_TARG_DOUBLE_FIELD_ALIGNMENT=n.

If --cs_targ_long_double_field_alignment is specified and CS_TARG_LONG_DOUBLE_FIELD_ALIGNMENT is set, --cs_targ_long_double_field_alignment takes precedence.

--cs_targ_plain_int_bit_field_is_signed

Specifies that 'plain' int bit fields should be treated as signed. Equivalent to configuration parameter setting CS_TARG_PLAIN_INT_BIT_FIELD_IS_UNSIGNED=No.

If --cs_targ_plain_int_bit_field_is_signed is specified and CS_TARG_PLAIN_INT_BIT_FIELD_IS_UNSIGNED is set, --cs_targ_plain_int_bit_field_is_signed takes precedence.

--cs_targ_plain_int_bit_field_is_unsigned

Specifies that 'plain' int bit fields should be treated as unsigned. Equivalent to configuration parameter setting CS_TARG_PLAIN_INT_BIT_FIELD_IS_UNSIGNED=Yes.

If --cs_targ_plain_int_bit_field_is_unsigned is specified and CS_TARG_PLAIN_INT_BIT_FIELD_IS_UNSIGNED is set, --cs_targ_plain_int_bit_field_is_unsigned takes precedence.

--cs_targ_sizeof_double n

Specifies the size of a double, in bytes. Equivalent to configuration parameter setting CS_TARG_SIZEOF_DOUBLE=n.

If --cs_targ_sizeof_double is specified and CS_TARG_SIZEOF_DOUBLE is set, --cs_targ_sizeof_double takes precedence.

--cs_targ_sizeof_long_double n

Specifies the size of a long double, in bytes. Equivalent to configuration parameter setting CS_TARG_SIZEOF_LONG_DOUBLE=n.

If --cs_targ_sizeof_long_double is specified and CS_TARG_SIZEOF_LONG_DOUBLE is set, --cs_targ_sizeof_long_double takes precedence.

--cs_targ_wchar_t_int_kind=k

Specifies the integer kind associated with wchar_t. Equivalent to configuration parameter setting CS_TARG_WCHAR_T_INT_KIND=k. See the CS_TARG_WCHAR_T_INT_KIND documentation for the available values for k.

If --cs_targ_wchar_t_int_kind is specified and CS_TARG_WCHAR_T_INT_KIND is set, --cs_targ_wchar_t_int_kind takes precedence.

--cs_underscore_decltype_only

Enable the use of the decltype specifier using the alternate keyword __decltype.

--cs_universal_character_names_allowed

[C++ and C99 only] Allows universal character names \uNNNN and \UNNNNNNNN (for hexadecimal NNNN and NNNNNNNN).

--cs_use_pch

[For use with Microsoft Visual Studio only] Specifies that the compilation should use a precompiled header (PCH) file generated by --cs_create_pch.

Use of the precompiled data stops and typical compilation continues immediately after the header stop location, which is determined as follows.

If --cs_use_pch_hdrstop stopfilename is specified, the first occurrence of #include stopfilename
Otherwise, the first occurrence of #pragma hdrstop in the compilation.
Otherwise, the compilation will fail.

The PCH file to use is determined as follows.

If --cs_pch_name pfilepath is specified, the PCH file used will be pfilepath. If pfilepath does not include a path specification, the PCH file will be a sibling of the top level file in the compilation.
Otherwise, if compilation a encounters #pragma hdrstop(pragmafpath) before (or at) the header stop location, the PCH file used will be pragmafpath. If pragmafpath does not include a path specification, the PCH file will be a sibling of the top level file in the compilation.
Note that if --cs_use_pch_hdrstop is specified, it takes precedence over this pragma for the purpose of determining the header stop location.
Otherwise, the PCH file used will be the tlfname.pch sibling of tlfname.ext: the top-level file in the compilation.

--cs_use_pch_hdrstop filepath

[For use with Microsoft Visual Studio only] When --cs_use_pch is specified, specifies the name of the header file location at which use of the precompiled header stops. Use of the precompiled data stops and typical compilation continues immediately after the (first) inclusion of stopfilename, even if occurrences of #pragma hdrstop are encountered.

When --cs_use_pch is not specified this option has no effect.

--cs_user_abi_key K

Informs CodeSonar that the compilation should be associated with ABI key K. This takes precedence over the value specified by --cs_model_abi_key (if any).

This option is provided for use with the EDG_FRONTEND_OPTIONS_APPEND and EDG_FRONTEND_OPTIONS_PREPEND options. If you are writing a custom compiler model and want it to specify an ABI key to the front end, use --cs_model_abi_key.

Note that specifying --cs_user_abi_key K does not cause CodeSonar to generate or use a project-compiler configuration file whose name includes K. Only ABI keys specified with COMPILER_MODELS rules have this effect.

For more information, see Compiler Models: ABI Keys.

--cs_using_attribute_namespaces

[C++ only] Allow standard attribute lists to include the"using" prefix for a standard attribute list. For example:

[[ using gnu: noreturn, deprecated ]] void f() { while(1); }

--cs_variable_templates

[C++ only] Accept C++14 variable templates. For example:

template <typename T> T x = 1;
int main() {
    return x<int> + x<double>;
}

--cs_variadic_using_decls

Accept C++17 variadic using-declarations.

--define_macro name [ ( param-list) ] [ = def ]
-D name [ ( param-list) ] [ = def ]

Define macro name as def. If = def is omitted, define name as 1. Function-style macros can be defined by appending a macro parameter list to name. There are no macro names defined by default (except for __LINE__ and similar language-mandated macros).

If def contains spaces, enclose it in double quotes.

--default_common_tentative_definitions
--default_nocommon_tentative_definitions

Specifies whether or not tentative definitions will be placed in common storage.

--default_calling_convention conv

[Microsoft only] Specifies the calling convention to use for functions that are not explicitly declared with one.

--dependencies
-M

Do preprocessing only. Instead of the normal preprocessing output, generate on the preprocessing output file a list of dependency lines suitable for input to the make program.

--designators
--no_designators

Enable or disable support for designators.

--diag_suppress tag, tag,...
--diag_remark tag, tag,...
--diag_warning tag, tag,...
--diag_error tag, tag,...

Override the normal error severity of the specified diagnostic messages. The message(s) may be specified using a mnemonic error tag or using an error number (see --display_error_number).

--display_error_number

Display the error message number in any diagnostic messages that are generated. The option may be used to determine the error number to be used when overriding the severity of a diagnostic message.

--dollar
-$

Accept dollar signs in identifiers.

--embedded_c
--no_embedded_c

[C only] Enable/disable support for all Embedded C language extensions.

--embedded_c++

Enable the diagnosis of noncompliance with the “Embedded C++” subset.

--error_limit number
-e number

Set the error limit to number. The front end will abandon compilation after this number of errors (remarks and warnings are not counted toward the limit). By default, the limit is 100.

--error_output efile

Redirect the output that would normally go to stderr (i.e., diagnostic messages) to the file efile. This option is useful on systems where output redirection of files is not well supported. If used, this option should probably be specified first in the command line, since otherwise any command-line errors for options preceding --error_output would be written to stderr before redirection.

--exceptions
-x
--no_exceptions

[C++ only] Enable or disable support for exceptions. -x is equivalent to --exceptions.

--extended_designators
--no_extended_designators

Enable or disable support for extended designators, an extension to emulate the behavior of certain other C compilers when it comes to designators in aggregate initializers.

--extended_variadic_macros
--no_extended_variadic_macros

Enable or disable support for extended variadic macros, an extension that emulates the behavior of certain other C compilers when it comes to variadic macros.

--g++
--no_g++

Enable or disable GNU C++ language compatibility features. This option also specifies that the source language being compiled is C++.

--gcc
--no_gcc

Enable or disable GNU C language compatibility features. This option also specifies that the source language being compiled is C.

--gcc89_inlining

[C99 only] Use the GNU C89 semantics of inline.

--gnu_version ver

The version of the GNU compiler that should be emulated in any of the GNU (C or C++) modes. Version x.y.z of the GNU compiler is encoded as x*10000+y*100+z.

--hard_define_macro name[(parm-list)][=def]

Define macro name as def. If =def is omitted, define name as 1. Function-style macros can be defined by appending a macro parameter list to name. Once a macro name is hard defined, all its subsequent definitions or undefinitions are ignored. These are processed together with --define_macro.

If def contains spaces, enclose it in double quotes.

When warnings are enabled and option --warn_redef_after_hard_define is specified in the command line, a warning is issued each time a definition or undefinition is ignored.

--hard_undefine_macro name

Remove any initial definition of the macro name. Once a macro name is hard undefined, all its subsequent definitions or undefinitions are ignored. These are processed together with --undefine_macro, after all --define_macro options and --hard_define_macro options in the command line have been processed.

When warnings are enabled and the option --warn_redef_after_hard_define is specified in the command line, a warning is issued each time a definition or undefinition is ignored.

--hitech_disable_keyword kword

Instructs the Hi-Tech compiler model not to treat kword as a keyword. If this option is used with other compiler models, or if kword is not one of the keywords specific to the Hi-Tech compiler model, it will be ignored. (See the Hi-Tech compiler model additional keyword list)

This option is provided because the Hi-Tech compiler does not implement all additional keywords for all chips, and programmers in some environments might therefore use identifiers that in other environments would be interpreted as keywords.

--hitech_strict

Specifies "strict" mode for the Hi-Tech compiler model:

Keywords persistent and interrupt must be prefixed with __
Type bit is not available.

If this option is used with other compiler models it will be ignored.

--ignore_std

Enable a g++ compatibility feature that makes the std namespace a synonym for the global namespace.

This option is useful if you see the error namespace "std" has no member ...

--import_dir dir-name

Specify the directory in which the files to be included by #import directives are to be found. These files must have been generated previously by the Microsoft compiler. This option is valid only in Microsoft mode.

--incl_suffixes str

Specifies the list of suffixes to be used when searching for an include file whose name was specified without a suffix. The argument is a colon-separated list of suffixes (e.g., h:hpp:: ). If a null suffix is to be allowed, it must be included in the suffix list. The default value is :h:hpp:.

--include_directory dir
--sys_include dir
-Idir

Add dir to the list of directories searched for #include files.

--sys_include specifies a system include directory

--instantiate mode
-tmode

Control instantiation of external template entities. External template entities are external (i.e., noninline and nonstatic) template functions and template static data members. The instantiation mode determines the template entities for which code should be generated based on the template definition):

none	Instantiate no template entities. This is the default.
used	Instantiate only the template entities that are used in this compilation.
all	Instantiate all template entities whether or not they are used.
local	Instantiate only the template entities that are used in this compilation, and force those entities to be local to this compilation.

--keep_restrict_in_signatures
--no_keep_restrict_in_signatures

Enable/disable reflecting the presence of top-levelrestrict parameter type qualifiers in mangled function names.

--late_tiebreaker
--early_tiebreaker

Select the way that tie-breakers (e.g., cv-qualifier differences) apply in overload resolution. In early tie-breaker processing, the tie-breakers are considered at the same time as other measures of the goodness of the match of an argument value and the corresponding parameter type (this is the standard approach). In late tiebreaker processing, tie-breakers are ignored during the initial comparison, and considered only if two functions are otherwise equally good on all arguments; the tie-breakers can then be used to choose one function over another.

--list lfile
-Llfile

Generate raw listing information in the file lfile. This information is likely to be used to generate a formatted listing. The raw listing file contains raw source lines, information on transitions into and out of include files, and diagnostics generated by the front end. Each line of the listing file begins with a key character that identifies the type of line, as follows:

N	a normal line of source; the rest of the line is the text of the line.
X	the expanded form of a normal line of source; the rest of the line is the text of the line. This line appears following the N line, and only if the line contains non-trivial modifications (comments are considered trivial modifications; macro expansions, line splices, and trigraphs are considered non-trivial modifications). Comments are replaced by a single space in the expanded-form line.
S	a line of source skipped by an #if or the like; the rest of the line is text. Note that the #else, #elif, or #endif that ends a skip is marked with an N.
L	an indication of a change in source position. The line has a format similar to the # line-identifying directive output by cpp, that is to say L line-number "file-name" key where key is 1 for entry into an include file, 2 for exit from an include file, and omitted otherwise. The first line in the raw listing file is always an L line identifying the primary input file. L lines are also output for #line directives (key is omitted). L lines indicate the source position of the following source line in the raw listing file.
R, W, E, or C	an indication of a diagnostic (R for remark, W for warning, E for error, and C for catastrophic error). The line has the form S "file-name" line-number column-number message-text where S is R, W, E, or C, as explained above. Errors at the end of file indicate the last line of the primary source file and a column number of zero. Command-line errors are catastrophes with an empty file name ("") and a line and column number of zero. Internal errors are catastrophes with position information as usual, and message-text beginning with (internal error). When a diagnostic displays a list (e.g., all the contending routines when there is ambiguity on an overloaded call), the initial diagnostic line is followed by one or more lines with the same overall format (code letter, file name, line number, column number, and message text), but in which the code letter is the lower case version of the code letter in the initial line. The source position in such lines is the same as that in the corresponding initial line.

--long_long

Permit the use of long long in strict mode in dialects in which it is non-standard.

--long_preserving_rules
--no_long_preserving_rules

Enable or disable the K&R usual arithmetic conversion rules with respect to long. This means the rules of K&R I, Appendix A, 6.6, not the rules used by the pcc compiler. The significant difference is in the handling of long op unsigned int when int and long are the same size. The ANSI/ISO/pcc rules say the result is unsigned long, but K&R I says the result is long (unsigned long did not exist in K&R I).

--microsoft
--no_microsoft

Enable or disable recognition of Microsoft extensions. When Microsoft extensions are recognized, language features that are not recognized by the Microsoft compiler are disabled by default.

--microsoft_bugs
--no_microsoft_bugs

Enable or disable recognition of certain Microsoft bugs. These options also enable Microsoft mode. Microsoft bugs mode is disabled by default.

--microsoft_build_number bnum

The "build number" of the Microsoft compiler that should be emulated in Microsoft mode. This option also enables Microsoft mode.

--microsoft_version vnum

The version of the Microsoft compiler that should be emulated in Microsoft mode. This enables or disables particular Microsoft mode features when the acceptance of those features varies between versions of the Microsoft compiler. The value specified is the value of the predefined macro _MSC_VER supplied by the version of the Microsoft compiler to be emulated. For example, 1100 is the value that corresponds to Visual C++ version 5.0. This option also enables Microsoft mode.

--ms_await

Emulate the Microsoft Visual Studio /await command-line switch that enables a pre-C++20 version of coroutines.

--ms_c11

Emulate the Microsoft Visual Studio /std:c11 command-line switch by enabling the same set of C11 options that are supported by the Visual Studio version that corresponds to the value of microsoft_version. If not specified explicitly with the --microsoft_version command-line option, microsoft_version is set to the value of the DEFAULT_MICROSOFT_VERSION. microsoft_version must have a value of at least 1927 for this option to have an effect.

--ms_c17

Emulate the Microsoft Visual Studio /std:c17 command-line switch by enabling the same set of C17 options that are supported by the Visual Studio version that corresponds to the value of microsoft_version. If not specified explicitly with the --microsoft_version command-line option, microsoft_version is set to the value of the DEFAULT_MICROSOFT_VERSION. microsoft_version must have a value of at least 1928 for this option to have an effect.

--ms_c++14

Enables the same set of C++14 options that are supported by the Visual Studio version that corresponds to the value specified by front end option --microsoft_version (including the case where a compiler model specifies --microsoft_version in response to a command line option or ABI key), or by the value of the DEFAULT_MICROSOFT_VERSION macro if --microsoft_version is not specified. microsoft_version must have a value of at least 1903 for this option to have an effect.

--ms_c++17

Enables the same set of C++17 options that are supported by the Visual Studio version that corresponds to the value specified by front end option --microsoft_version (including the case where a compiler model specifies --microsoft_version in response to a command line option or ABI key), or by the value of the DEFAULT_MICROSOFT_VERSION macro if --microsoft_version is not specified. microsoft_version must have a value of at least 1911 for this option to have an effect.

--ms_c++20

Enables the same set of C++20 options that are supported by the Visual Studio version that corresponds to the value specified by front end option --microsoft_version (including the case where a compiler model specifies --microsoft_version in response to a command line option or ABI key), or by the value of the DEFAULT_MICROSOFT_VERSION macro if --microsoft_version is not specified. microsoft_version must have a value of at least 1920 for this option to have an effect.

--ms_c++latest

Enables the same set of C++ options that are supported by the Visual Studio version that corresponds to the value specified by front end option --microsoft_version (including the case where a compiler model specifies --microsoft_version in response to a command line option or ABI key), or by the value of the DEFAULT_MICROSOFT_VERSION macro if --microsoft_version is not specified.

--ms_compatibility

Enable or disable the set of Microsoft extensions corresponding to the Clang -fms-compatibility option. Can be combined with non-Microsoft emulation modes. Microsoft version is set to the value specified by front end option --microsoft_version (including the case where a compiler model specifies --microsoft_version in response to a command line option or ABI key), or by the value of the DEFAULT_MICROSOFT_VERSION macro if --microsoft_version is not specified.

--ms_extensions
--no_ms_extensions

Enable or disable the set of Microsoft extensions corresponding to the Clang -fms-extensions option. Can be combined with non-Microsoft emulation modes. Microsoft version is set to the value specified by front end option --microsoft_version (including the case where a compiler model specifies --microsoft_version in response to a command line option or ABI key), or by the value of the DEFAULT_MICROSOFT_VERSION macro if --microsoft_version is not specified.

--ms_cplusplus_std_value
--no_ms_cplusplus_std_value

Emulate Microsoft Visual Studio command line options /Zc:__cplusplus and /Zc:__cplusplus-, respectively. Implicitly enables Microsoft emulation mode.

--ms_std_preprocessor

Enable or disable a mode in which the behavior of the preprocessor in Microsoft emulation mode conforms with the C and C++ Standards; when disabled, the preprocessor emulates the behavior of the traditional Microsoft preprocessor.

--ms_strict_ternary
--no_ms_strict_ternary

Enable or disable strict standard-conforming behavior of the conditional ternary operator (?:) in Microsoft mode.

--multibyte_chars
--no_multibyte_chars

Enable or disable processing for multibyte characters in comments, string literals, and character constants.

--new_for_init

[C++ only] Use "new" scoping rules for declarations in a for-init statement: the for statement has its own implicit scope.

--no_code_gen
-n

Do not run code-generation back end.

--no_use_before_set_warnings
-j

Suppress warnings on local automatic variables that are used before their values are set. The front end's algorithm for detecting such uses is conservative and is likely to miss some cases that an optimizer with sophisticated flow analysis could detect; thus, an implementation might choose to suppress the warnings from the front end when optimization has been requested but to permit them when the optimizer is not being run.

--no_warnings
-w

Suppress warnings. Errors are still issued.

--nullptr
--no_nullptr

[C++ only] Enable or disable support for the C++11 nullptr keyword.

--old_for_init

[C++ only] Use "old" scoping rules for declarations in a for-init statement: the declaration belongs to the scope to which the for statement belongs.

--old_c
-K

Enable K&R/pcc mode.

--optimize

If specified, functions declared with both extern and inline will be compiled on their own in addition to being used for inlining.

Otherwise, the function body will only be used to generate inlined code and no representation of the function itself will be compiled.

--output ofile
-o ofile

Specify the output file of the compilation, i.e., the preprocessing or intermediate language output file.

--pack_alignment n

Set the default alignment for packing classes and structs to n, a power-of-2 value within the range 1 to 16. The argument n is the default maximum alignment for nonstatic data members; it can be overridden by a #pragma pack directive.

--pending_instantiations n

Specify that at most n instantiations of a given template may be in process of being instantiated at a time. Set to 0 for no limit. The default value is 128.

--preinclude header-file

Act as if each compilation unit has #include <header-file> before its first line.

--preusing fname

[Microsoft C++ only] Act as if each compilation unit specifies #using fname.

--remarks
-r

Issue remarks, which are diagnostic messages even milder than warnings.

--restrict
--no_restrict

Enable or disable recognition of the restrict keyword.

--rtti
--no_rtti

[C++ only] Enable or disable support for runtime type information: the dynamic_cast and typeid operators.

--rvalue_refs
--no_rvalue_refs

[C++ only] Enable or disable support for rvalue references.

--short_enums
--no_short_enums

[GNU C modes only] The default behavior in GNU C modes is not to support short enums.

--short_enums forces all enumeration types to be packed (meaning that the underlying type of the enumeration is chosen to be the smallest integer that will accommodate the enumerator constants).
--no_short_enums specifies that the default GNU C behavior should be applied.

--signed_chars
-s

Make plain char signed. When plain char is signed, the macro __SIGNED_CHARS__ is defined by the front end. On Windows, the default is for them to be signed.

--strict_gnu
--no_strict_gnu

--strict_gnu: emulate the -std=c* behavior of the compiler.
--no_strict_gnu: emulate the -std=gnu* behavior of the compiler.
neither: emulate the -std=c* behavior of the compiler if a --c* or --c++* option is specified, otherwise emulate the -std=gnu* behavior of the compiler.

--strict_warnings
-a
or
--strict
-A

Enable strict ANSI mode, which provides diagnostic messages when non-ANSI features are used, and disables features that conflict with ANSI C. ANSI violations can be issued as either warnings or errors depending on which command line option is used. The -A and --strict options cause errors to be issued whereas the -a and --strict_warnings options produce warnings. The error threshold is set so that the requested diagnostics will be listed.

--svr4
--no_svr4

Enable/disable recognition of SVR4 C compatibility features; specify that the source language is ANSI C.

--thread_local_storage
--no_thread_local_storage

Enable/disable the C++11 thread_local specifier (and if so configured, the __thread specifier) to indicate that variables should be stored in threadlocal storage. By default, the __thread specifier is enabled in Sun mode and in GNU mode when gnu_version >= 30400

--ti_relaxed_prototype

Allows redeclaration of parameter lists in function prototypes (in ANSI C, this could otherwise cause an error). For example:

int myfunc();
...
int myfunc(float a, float b);

--ti_relaxed_type

Relaxes type checking when pointers are combined in operations. For type T:

A pointer to signed T can be combined with a pointer to unsigned T.
A pointer to (non-const) T can be combined with a pointer to const T.

For example:

unsigned int *a;
int *b = a;
const int *c = b;

--timing
-#

Generate compilation timing information. This option causes the compiler to display the amount of CPU time and elapsed time used by each phase of the compilation and a total for the entire compilation.

--trace_includes
-H

Do preprocessing only. Instead of the normal preprocessing output, generate on the preprocessing output file a list of the names of files #included.

--trigraphs
--no_trigraphs

Enable or disable recognition of trigraphs.

--uliterals
--no_uliterals

Enable or disable recognition of the following.

String literals of the forms U"..." and u"...".
Character literals of the forms U'...' and u'...'.
[C++ only] Keywords char16_t and char32_t.

--undefine_macro name
-Uname

Remove any initial definition of the macro name. --undefine_macro options are processed after all --define_macro options in the command line have been processed.

--unicode_source_kind {UTF-8,UTF-16,UTF-16LE,UTF-16BE,none}

Source files that do not begin with a byte order mark are assumed to use the Unicode encoding specified (none indicates that the file is not Unicode)

--unsigned_chars
-u

Make plain char unsigned. On Windows, the default is for this type to be signed.

--upc
--no_upc

Enable/disable Unified Parallel C extensions.

--user_defined_literals
--no_user_defined_literals

Enable or disable C++-style "user-defined-literals".

--using_directory dir

[Microsoft C++ only] Add dir to the list of directories searched for #using files.

--variadic_macros
--no_variadic_macros

Enable or disable support for variadic macros.

--variadic_templates
--no_variadic_templates

[C++ only] Enable or disable support for variadic templates.

--vcmeta_directory dir

[Available only where CPPCX_ENABLING_POSSIBLE is TRUE] Specify the directory dir in which to look for the vcmeta.dll file. By default, searches for vcmeta.dll in the same directory as the module that contains the front end.

--version
-v

Display version numbers and copyright notices for CodeSonar.

--vla
--no_vla

Enable or disable support for variable length arrays, an extension that allows the declaration and use of arrays of automatic storage duration with dimensions that are fixed at run time.

--warn_exception_specification_difference

Downgrade to warnings errors about differences in exception specifications in declarations. This option is useful if you are getting the error omission of exception specification is incompatible with previous function for functions declared in system include files.

--warn_redef_after_hard_define

Issue a warning when a macro definition or a macro redefinition is ignored because of a previous hard define or hard undefine.

--wchar_t_keyword
--no_wchar_t_keyword

[C++ only] Enable or disable recognition of wchar_t as a keyword.

--wrap_diagnostics
--no_wrap_diagnostics

Enable or disable a mode in which the error message text is not wrapped when too long to fit on a single line. The mode is enabled by default.

--xref xfile
-Xxfile

Generate cross-reference information in the file xfile. For each reference to an identifier in the source program, a line of the form
symbol-id name ref-code file-name line-number column-number
is written, where

ref-code

is one of the following:

D	definition,
d	declaration (that is, a declaration that is not a definition),
M	modification,
A	address taken,
U	used,
C	changed (that is, used and modified in a single operation, such as an increment)
R	any other kind of reference,
E	an error in which the kind of reference is indeterminate.

symbol-id

is a unique decimal number for the symbol.

The fields of the line are separated by tab characters.

CodeSonar C and C++ Front-end Options

How to Use Front End Options

The Front End Options