c_as_cpp [on|off] (Windows) 

insure++.c_as_cpp [on|off] (Unix)

Specifies whether files with the .c extension should be treated as C++ source code. With this option off, Insure++ will treat files with the .c extension as C code only. If you use C++ code in .c files, you should turn this option on. Default is off.

checking_placement_new [on|off] (Windows)

insure++.checking_placement_new [on|off] (Unix)

Controls whether checks for placement new are used. See Troubleshooting for more information. Default is on.

checking_uninit [on|off] (Windows) 

insure++.checking_uninit [on|off] (Unix)

Specifies that the code to perform flow-analysis and check for uninitialized variables should not be inserted. Runtime uninitialized variable checking is then limited to uninitialized pointer variables. See checking_uninit [on|off] for the runtime effects of this option. Default is on.

checking_uninit_struct_copy [on|off] (Windows only)

Tells the code insert program for compiling with Insure++ (do_mpf) to perform uni-checking on struct assignments. Default is on.

insure++.compiler_acronym abbreviation (Unix only)

Specifies the short-hand alternative name of a compiler, such as gcc. This name is used to locate the appropriate .psrc files. It does not indicate which compiler will actually be called to compile source files (see the other compiler_* options).

This option must be placed after the active compiler option, for example:

compiler c89 compiler_acronym cc

compiler compiler_name (Windows)

Specifies the name of the default compiler. This option overrides all other compiler_* options:

• compiler_c
• compiler_cpp
• compiler_default

The indicated compiler will be called every time Insure++ is called during compilation/linking. The default is cl.

insure++.compiler compiler_name (Unix)

Specifies the name of an alternative compiler. The default is platform-dependent. The indicated compiler will be called every time insure++ is called.

compiler_c C_compiler_name (Windows)

insure++.compiler_c C_compiler_name (Unix)

Specifies the name of the default C compiler. The compiler will be called for any .c files.  

On Windows, the default is cl and is overridden by the compiler option. 

On Unix, the default is platform-dependent and is overridden by the compiler and compiler_acronym options.

compiler_cpp C++_compiler_name (Windows)

insure++.compiler_cpp C++_compiler_name (Unix)

Specifies the name of the default C++ compiler. The compiler will be called for any .cc, .cpp, and .cxx files. The default for Windows and Unix is platform-dependent.

On Windows, this option is overridden by the compiler option.

On Unix, this option is overridden by the compiler and compiler_acronym options.

compiler_default [c|cpp] (Windows)

insure++.compiler_default [c|cpp] (Unix)

Specifies whether the default C or C++ compiler should be called to link when there are no source files on the link line. Default is c.

On Windows, this option is overridden by the compiler option.

On Unix, this option is overridden by the compiler and compiler_acronym options.

compiler_deficient <argument(s)> (Windows)

insure++.compiler_deficient <argument(s)> (Unix)

Specifies which features are not supported by your compiler. The default is compiler-dependent. You can specify the following arguments:

• all (includes all affirmative arguments)
• address, no_address
• cast, no_cast
• enum, no_enum
• member_pointer, no_member_pointer
• scope_resolution, no_scope_resolution
• static_temps, no_static_temps
• struct_offset, no_struct_offset

• types, no_types
• none (compiler handles all cases)

Different compilers require different levels of this option. See the compiler-specific README files and in the <$PARASOFT>/lib.Win32/$compiler. or <$PARASOFT>>//$compiler (Unix) directory.

compiler_fault_recovery [off|on] (Windows)

insure++.compiler_fault_recovery [off|on] (Unix) 

This option controls how Insure++ recovers from errors during compilation and linking. When set to on and there is an error during linking, Insure++ will compile only and will not process the file. Insure++ will also attempt to take corrective action by using the -Zsl option. If this option is turned off, Insure++ will make only one attempt at each compile and link.

compiler_fault_recovery_banner [off|on] (Windows)

insure++.compiler_fault_recovery_banner [off|on] (Windows)

When activated, this option prints out a message that fault recovery has begun when instrumenting a file or when linking.

compiler_keyword [*|const|inline|signed|volatile] keyword (Windows)

insure++.compiler_keyword [*|const|inline|signed|volatile] keyword (Unix)

Specifies a new compiler keyword (by using the *) or a different name for a standard keyword. For example, if your compiler uses __const as a keyword, use the following option:

compiler_keyword const __const (Windows)

insure++.compiler_keyword const _const (Unix)

coverage_boolean [on|off] (Windows)

insure++.coverage_boolean [on|off] (Unix)

If set to on, the only data that will be stored is whether or not each block was executed. If set to off, the number of times each block was executed is also recorded. Setting this option to on will cause your program to compile and run slightly faster.

coverage_map_data [on|off] (Windows)

insure++>coverage_map_data [on|off] (Unix)

Prompts Insure++ to generate coverage map data for TCA.

coverage_map_file [filename] (Windows)

insure++.coverage_map_file [filename] (Unix)

Specifies the full path to the directory where Insure++ writes the tca.map file.

coverage_only [on|off] (Windows)

insure++.coverage_only [on|off] (Unix)

Compiles and generates coverage information (tca.map). It also compiles and links source code for TCA.

error_format string (Windows)

insure++.error_format string (Unix)

Specifies the format for error message banners generated by Insure++. The string may contain standard C formatting characters, such as \n. For examples, see Customizing the Output Format.

The string arguments will be displayed as entered with the macro substitutions taking place:

• %c - Error category (and sub-category if required)
• %d - Date on which the error occurs (DD-MM-YYYY) 
• %f - Filename containing the error 
• %F - Full pathname of the file containing the error 
• %h - Name of the host on which the application is running 
• %l - Line number containing the error 
• %p - Process ID of the process incurring the error 
• %t - Time at which the error occurred (HH:MM:SS)

The error_format option only takes effect if the Insure++ errors are being reported to the console or a file. If the errors are being sent to Insra, the error format in Insra will stay the same. For details on how to change where errors are sent, see Reports (Windows) or Report File (Unix).

exit_on_error [0|1|2|3|...] (Windows)

insure++.exit_on_error [0|1|2|3|...] (Unix)

Causes Insure++ instrumentation to exit (with non-zero status) after reporting the given number of errors. The default is 0, which means that all errors will be reported and instrumentation will terminate normally.

exit_on_error_banner [on|off] (Windows)

insure++.exit_on_error_banner [on|off] (Unix)

When set to on, the following message prints when Insure++ instrumentation exits due to the exit_on_error option:

** User selected maximum error count reached: 1. Program exiting.**

file_ignore string (Windows)

insure++.file_ignore string (Unix)

Specifies that any file which matches the string will not be processed by Insure++, but will be passed straight through to the compiler. The string should be a glob-style regular expression. This option allows you to avoid processing files that you know are correct. This can significantly speed up execution and shrink your code.

function_ignore function_name (Windows)

insure++.function_ignore function_name (Unix)

This option tells Insure++ not to instrument the given function. This is equivalent to turning off the checking for that routine. If the function in question is a bottleneck, this may dramatically increase the runtime performance of the code processed with Insure++. 

For example, assume that your application includes the following code:

void foo(int)
	{
	}

void foo(double)
	{
	}

void foo(void*)
	{
	}

struct Zork
	{
		void foo(void*) {}
	};

int main()
	{
		foo(1);
		foo(1.0);
		foo((void*) 0);
		Zork z;
		z.foo((void*) 0);
		return 0;
	}

The function_ignore foo option turns off instrumentation for the foo(int), foo(double), foo(void*), and Zork::foo(void*) functions.

If you want to ignore a specific function, you must specify the function’s "mangled name," as determined by the IA64-ABI method (which the gcc-3.x compiler also uses). The IA64-ABI mangling specification is documented at http://www.codesourcery.com/cxx-abi/abi.html#mangling. The IA64-ABI mangling scheme is applied regardless of what platform you are working on. One way of getting the mangled name is to simply compile the file with the gcc 3.x compiler, and see what is produced in the .o file. Another way is to review the TCA output.

For instance, if you compile the previous sample code with gcc, the .o file shows the following mangled names:

0000001a T _Z3fooPv
00000006 T _Z3food
00000000 T _Z3fooi
00000000 W _ZN4Zork3fooEPv
	U __gxx_personality_v0
00000020 T main

Use the following option to ignore foo(int): 

Insure++.function_ignore _Z3fooi

Use the following option to ignore foo(void*):

Insure++.function_ignore _Z3fooPv

Use the following option to ignore Zork::foo(void*):

Insure++.function_ignore _ZN4Zork3fooEPv

header_ignore string (Windows)

insure++.header_ignore string (Unix)

Specifies that any function in the filename specified by the string will not be instrumented by Insure++. The string should be a glob-style regular expression and should include the full path.

This option allows you to avoid doing runtime checking in header files that you know are correct. This can significantly speed up execution and shrink your code. Please note, however, that the file must still be parsed by Insure++, so this option will not eliminate compile time warnings and errors, only runtime checking.

init_extension [c|cc|C|cpp|cxx|c++] (Windows)

insure++.init_extension [c|cc|C|cpp|cxx|c++] (Unix)

This option tells Insure++ to use the given extension and language for the Insure++ initialization code source file. The extension can be any one of the Insure++-supported extensions: c for C code; or cc, cpp, cxx, or c++ for C++ code. This option only needs to be used to override the default, which is the extension used by any source files on the insure++ command line. If there are no source files on the command line (for example, a separate link command), Insure++ will use a c extension by default.

interface_ignore function_name (Windows)

insure++.interface_ignore function_name (Unix)

Disables print inline interface. This option uses wildcards in the same manner as function_ignore.

This option is intended for the use of Parasoft customer support and should only be utilized at the direction of a qualified Parasoft support agent.

linker linker_name (Windows)

insure++.linker linker_name (Unix)

This option specifies the name of an alternative linker. This only applies if you are using the inslink command.

linker_source source_code (Windows)

insure++.linker_source source_code (Unix)

This option tells Insure++ to add the given code to its initialization file. This can help eliminate unresolved symbols caused by linker bugs.

linker_stub symbol_name (Windows)

insure++.linker_stub symbol_name (Unix)

Tells Insure++ to create and link in a dummy function for the given symbol_name. This can help eliminate unresolved symbols caused by linker bugs.

logfile [filename|stderr|stdout|InsureLog.txt] (Windows)

insure++.logfile [filename|stderr|stdout|InsureLog.txt] (Unix)

Specifies the filename to use when creating the Insure++ Log file. See Troubleshooting for more information.

logfile_banner [on|off] (Windows)

insure++.logfile_banner [on|off] (Unix)

Controls whether or not the terminal displays a message reminding you that log messages have been redirected to a file.

lrtCacheDir (Windows)

insure++.lrtCacheDir (Unix)

Specifies the directory where Insure++ will store instrumented versions of system libraries. By default, this is set to the "LRT-cache" subdirectory of the Insure++ installation directory. You may wish to set this option if Insure++ is installed on a read-only file system, or on a file system with limited disk space. If you change this option, you should move or copy the existing LRT cache directory, together with its contents, to its new location.

multiByteChars [on|off] (Windows)

insure++.multiByteChars [on|off] (Unix)

If this option is set to on, then Insure++ will recognize multibyte, (wide or double-byte chars), in some locations. Parsing multibyte chars is inefficient, so if you have only ASCII chars in your source code, then this option should be set to off.

optionfile <file> (Windows)

insure++.optionfile <file> (Unix)

This option enables you to specify another file in which to direct Insure++ to read other .psrc file options. Examples: 

• optionfile $HOME/.psrc.$ARCH
• optionfile $HOME/myoptions.$MYPROJECT

This option is advantageous if you have multiple architectures or projects for which you want to use different settings. In the examples above, you can have multiple .psrc files in your $HOME directory that would be unique to a particular platform, project, etc., such as: 

• .psrc.linux2
• .psrc.aix6
• .psrc.solaris
• myoptions.projectA
• myoptions.projectB

Both examples can also be specified by means of an environment variable.

pchcheck [on|off] (Windows only)

This option determines whether Insure++ performs strict checking for the valid use of precompiled headers. Insure++’s strict checking includes verifying whether header timestamps are those used when the pch was built, verifying whether the command-line options are the same as when the pch was built, and verifying whether the current directory is the same as when the pch was built. See Precompiled Headers for details on using Insure++ with precompiled headers.

pchdisable [on|off] (Windows only)

This option determines whether the application’s precompiled headers are used.  See Precompiled Headers for details on using Insure++ with precompiled headers.

pragma_ignore string (Windows)

insure++.pragma_ignore string (Unix)

Any pragma that matches string will be deleted by Insure++. The string should be a glob-style regular expression.

rename_files [on|off] (Windows)

insure++.rename_files [on|off] (Unix)

Insure++ normally creates and passes an intermediate to the compiler. In some cases, this may confuse debuggers. If this is the case, you can set this option to on and Insure++ will then rename the files during compilation so that they are the same. An original source file called foo.c would be renamed foo.c.ins_orig for the duration of the call to Insure++.

For example, the output to the screen would be:

***Renaming source file foo.c to foo.c.ins_orig***

or

***Restoring foo.c from foo.c.ins_orig***

report_banner [on|off] (Windows)

insure++.report_banner [on|off] (Unix)

Controls whether or not a message is displayed on your terminal, reminding you that error messages have been redirected to a file. See Report File (Windows) or Report File (Unix) for more information.

report_file [filename|insra|stderr] (Windows)

insure++.report_file [filename|insra|stderr] (Unix)

Specifies the name of the report file. Environment variables and various pattern generation keys may appear in filename. For more information, see Filenames. Use of the special filename insra tells Insure++ to send its output to Insra.

sizeof type value (Windows)

insure++.sizeof type value (Unix)

This option allows you to specify data type sizes that differ from the host machine. This is often necessary for cross compilation. value should be the number sizeof(type) would return on the target machine. The following arguments for type are allowed:

• char
• double
• float
• int
• long
• long double
• long long
• short
• void *

sizet <unsigned int|unsigned long> (Windows)

insure++.sizet <unsigned int|unsigned long> (Unix)

Specifies the data type returned by the sizeof operator.

skipAsmFunctions [true|false] (Windows)

insure++.skipAsmFunctions [true|false] (Unix)

Prompts Insure++ to ignore ASM functions during instrumentation. If the argument is empty, this option defaults to true.

skipSehFunctions [true|false] (Windows only)

Prompts Insure++ to ignore SEH (structured exception handling) functions during instrumentation. If the argument is empty, this option defaults to true.

stack_internal [on|off] (Windows)

insure++.stack_internal [on|off] (Unix)

If you are using the symbol_table off runtime option, you can set this option to on and recompile your program to get filenames and line numbers in stack traces without using the symbol table reader. See symbol_table [on|off] for more information.

insure++.stackpc [on|off] (Unix only)

Causes Insure++ to add the actual address of the instruction where an error has occurred to stack traces. The following partial error message is an example:

Memory leaked leaving scope: p
Lost block : 0x0804b710 thru 0x0804b719 (10 bytes)
	p, allocated at leakscop.c, 9
	malloc() pc: 0x40041719 (interface)
	gimme() pc: 0x08049916 leakscop.c, 9
	main() pc: 0x08049a59 leakscop.c, 15
Stack trace where the error occurred:
	gimme() pc: 0x080499b5 leakscop.c,10 
	main() pc: 0x08049a59 leakscop.c, 15

stdlib_replace [on|off] (Windows)

insure++.stdlib_replace [on|off] (Unix)

Links with an extra Insure++ library that checks common function calls without requiring recompilation. This is useful for finding bugs in third-party libraries or for quickly checking your program without fully recompiling with Insure++. This option does not apply in LRT mode.

string_table [on|off] (Windows)

insure++.string_table [on|off] (Unix)

Moves the string table into a separate file.

suppress code (Windows)

insure++.suppress code (Unix)

Suppresses compile time messages matching the indicated error code. Context-sensitive suppression does not apply at compile time. 

suppressEDGWarning [on|off] (Windows)

insure++.suppressEDGWarning [on|off] (Unix)

This options quiets down the parser. Many compile-time warnings and bug-reports are suppressed as well. It may be beneficial to parse your code once with this option set to off, fix any problems found, and reset this option to on to compile with less noise. With this option set to on, warnings about DEAD_CODE, and UNUSED_VAR may be suppressed.

suppress_output string (Windows)

insure++.suppress_output string (Unix)

Suppresses compile time messages including the indicated error string. See Suppressing Other Warning Messages for more information. For example, to suppress the following warning:

{{[foo.c:5] Warning: bad conversion in assignment: char * = int * 
	>> ptr = iptr;}}

add the following string to this value:

bad conversion in assignment

temp_directory path (Windows)

insure++.temp_directory path (Unix)

Specifies the directory where Insure++ will write its temporary files, for example, C:\tmp on Windows. The default on Windows is the Windows temporary directory. Setting path to a directory local to your machine can dramatically improve compile time performance if you are compiling on a remotely mounted file system.

uninit_flow [1|2|3|...|100|...|1000] (Windows)

insure++.uninit_flow [1|2|3|...|100|...|1000] (Unix)

Insure++ can perform a lot of checks for uninitialized memory at compile time. This value specifies how hard Insure++ should try to analyze this at compile time. A high number will make Insure++ run slower at compile time, but will produce a faster executable. Values over 1000 are not significant except for very complicated functions.

uselockf [0|1|2|…] (WIndows)

insure++.uselockf [0|1|2|…] (Unix) 

Denotes the maximum number of retries Insure++ will attempt to obtain a lock on a file before giving up. This option is useful when building in parallel while using coverage. This option is automatically added when using /MP on Windows or -Zmp on Unix.

unsuppress code (Windows)

insure++.unsuppress code (Unix)

Enables compile time messages matching the indicated error code. Context sensitive suppression is not supported at compile time. See Enabling Error Messages for more information.

verbosity [0|1|2|3|4] (Windows)

insure++.verbosity [0|1|2|3|4] (Unix) 

Tells Insure++ to create an Insure++ log in the current working directory with verbosity level set to a value between 1 and 4. 4 is the most verbose. See Troubleshooting for more information.

checking_uninit [on|off] (Windows)

insure++.checking_uninit [on|off] (Unix)

If set to off, this option specifies that the code to perform flow analysis and checking for uninitialized variables should not be executed. Runtime uninitialized variable checking is then limited to uninitialized pointer variables.

checking_uninit_min_size [1|2|3|...] (Windows)

insure++.checking_uninit_min_size [1|2|3|...] (Unix)

Specifies the minimum size in bytes of data types on which Insure++ should perform full uninitialized memory checking. The default is 2, which means that chars will not be checked by default. Setting this option to 1 will check chars, but may result in false errors being reported. These can be eliminated by using the checking_uninit_pattern pattern (Windows) or insure++.checking_uninit_pattern pattern (Unix) option to change the pattern used.

checking_uninit_pattern pattern (Windows)

insure++.checking_uninit_pattern pattern (Unix)

Specifies the pattern to be used by the uninitialized memory checking algorithm. The default is deadbeef. The pattern must be a valid 8-digit hexadecimal value.

coverage_banner [on|off] (Windows)

insure++.coverage_banner [on|off] (Unix)

Prompts Insure++ to display a message about coverage information written to tca.log. Default is on.

coverage_log_file [filename] (Windows)

insure++.coverage_log_file [filename] (Unix)

Specifies the full path to the directory where Insure++ writes the tca.log file.

coverage_overwrite [on|off] (Windows)

insure++.coverage_overwrite [on|off] (Unix)

Determines if the tca.log file will be overwritten on each run.

demangle [off|on|types|full_types] (Windows)

insure++.demangle [off|on|types|full_types] (Unix)

Specifies the level of function name demangling in reports generated by Insure++. For example, the following table describes the results of each setting for the a function called void func(const int):

demangle_method [external <filtname>|CC|gcc] (Windows)

insure++.demangle_method [external <filtname>|CC|gcc] (Unix)

Specifies compiler-specific algorithm for demangling function names. Currently supported compiler algorithms are C-Front based C++ compilers (for example, CC). If you are using a different compiler, Insure++ understands most other demangling formats as well. The filter <filtname> option allows the use of the external demangler filtname. The default is compiler-dependent. See the compiler level .psrc file, which is in the directory lib.$ARCH/$COMPILER. This option is a compiled-in option, so you will need to prepend an exclamation mark (!) to the option in the .psrc file to change the setting at runtime.

error_format string (Windows)

insure++.error_format string (Unix)

Specifies the format for error message banners generated by Insure++. The string argument is displayed as it is entered with the macro substitutions as shown in the description of the compiler_deficient option. The string may also contain standard C formatting characters, such as \n. For examples, see Customizing the Output Format.

The error_format option only takes effect if the Insure++ errors are being reported to the console or a file. If the errors are being sent to Insra, the error format in Insra will stay the same. For details on how to change where errors are sent, see Report File (Windows) or Report File (Unix).

exit_hook [on|off] (Windows)

insure++.exit_hook [on|off] (Unix)

Insure++ uses the appropriate atexit, onexit, or on_exit function call to perform special handling at exit, but this option enables you to disable special handling at exit. Default is on.

exit_on_error [0|1|2|3|...] (Windows)

insure++.exit_on_error [0|1|2|3|...] (Unix)

Causes the user program to quit (with non-zero exit status) after reporting the given number of errors. The default is 0, which means that all errors will be reported and the program will terminate normally.

exit_on_error_banner [on|off] (Windows)

insure++.exit_on_error_banner [on|off] (Unix)

When Insure++ causes your program to quit because you enabled the exit_on_error option, it will print a brief message, for example:

** User selected maximum error count reached: 10. Program exiting.**

You can disable messages by setting this option to off. Default is on

free_delay [0|1|2|3|...|119|...] (Windows)

insure++.free_delay [0|1|2|3|...|119|...] (Unix)

This option controls how long the Insure++ runtime holds onto free’d blocks before allowing them to be reused. This is not necessary for error detection, but can be useful in modifying the behavior of your program for stress-testing. The number represents how many freed blocks are held back at a time. Large numbers limit memory reuse, whereas setting the value to 0 maximizes memory reuse.

free_pattern pattern (Windows)

insure++.free_pattern pattern (Unix)

Specifies a pattern that will be written on top of memory whenever it is freed. This pattern will be repeated for each byte in the freed region. The default is 0, which means no pattern will be written. This may cause your program to crash if your system libraries assume freed memory is still valid.

GusCacheDir (Windows)

insure++.GusCacheDir (Unix)

Specifies the directory where Insure++ will store its cache files containing symbolic debugging information. By default, this is set to the "GUS-cache" subdirectory of the Insure++ installation directory. You may wish to set this option if Insure++ is installed on a read-only file-system, or a on file-system with limited disk space. You may safely delete the contents of the GUS cache directory when you are not actively using Insure++. Its contents will be automatically regenerated the next time you use Insure++.

ignore_wild [on|off] (Windows)

insure++.ignore_wild [on|off] (Unix)

Specifies whether Insure++ will do checking for wild pointers. Turning this option on turns off wild pointer checking. Default is off.

interface_ignore function_name (Windows)

insure++.interface_ignore function_name (Unix)

This option disables linkable interfaces. This option uses wildcards in the same manner as the function_ignore option.

leak_combine [none|trace|location] (Windows)

insure++.leak_combine [none|trace|location] (Unix)

Specifies how to combine leaks for the memory leak summary report. Combining by trace means that all blocks allocated with identical stack traces will be combined into a single entry. Combining by location means that all allocations from the same file and line (independent of the rest of the stack trace) will be combined. Setting to none means each allocation will be listed separately.

leak_search [on|off] (Windows)

insure++.leak_search [on|off] (Unix)

Specifies additional leak checking at runtime before a leak is reported. Requires that the symbol table reader be turned on.

leak_sort [none|frequency|location|size] (Windows)

insure++.leak_sort [none|frequency|location|size] (Unix)

Specifies by what criterion the memory leak summary report is sorted. Setting this to none may provide better performance at exit if you have many leaks. Default is size.

leak_summary_filter (Windows)

insure++.leak_summary_filter (Unix)

Controls which blocks are reported in the “leaks detected at exit” and “outstanding” sections of the leak summary. The following setting, for example, restricts the leak summary to those blocks with stack traces ending in main:

leak_summary_filter *main

The following setting filters out the following leak summary entries:

leak_summary_filter -! * Tcl_Alloc* *

The following leak summary entries are filtered-out:

3607 bytes 3 chunks allocated
malloc()
Tcl_Alloc()
Tcl_NewStringObj()
Tcl_EvalTokens()
Tcl_EvalEx()
Tcl_EvalFile()
TclExecuteByteCode()
Tcl_EvalObjEx()
Tcl_UplevelObjCmd()

leak_sweep [on|off] (Windows)

insure++.leak_sweep [on|off] (Unix)

Specifies additional leak checking at the termination of the program. Requires that the symbol table reader be turned on. Default is on.

leak_trace [on|off] (Windows)

insure++.leak_trace [on|off] (Unix)

This option determines whether or not full stack traces will be shown in the memory leak summary report. Default is on.

logfile [filename|stderr|stdout|InsureLog.txt] (Windows)

insure++.logfile [filename|stderr|stdout|InsureLog.txt] (Unix)

Specifies the filename to use when creating the Insure++ Log file. See Troubleshooting for more information. Default is InsureLog.txt.

new_overhead [0|2|4|6|8|...] (Windows)

insure++.new_overhead [0|2|4|6|8|...] (Unix)

Specifies the number of bytes allocated as overhead each time new[] is called. The default is compiler- dependent, but is typically 0, 4, or 8.

pointer_slack [0|1|2] (Windows)

insure++.pointer_slack [0|1|2] (Unix)

This controls the heuristic in Insure++ that determines which block a pointer points to when it does not point to a valid block. The default should be changed only if Insure++ is not working correctly on your program. Default is 1. The following table describes the acceptable values:

report_banner [on|off] (Windows)

insure++.report_banner [on|off] (Unix)

Controls whether or not a message is displayed on your terminal, reminding you that error messages have been redirected to a file. Default is on. For more information, see Filenames.

report_file [filename|Insra|stderr] (Windows)

insure++.report_file [filename|Insra|stderr] (Unix)

Specifies the name of the report file. The file name may contain environment variables and various pattern generation keys if set to filename. For more information, see Filenames. Use of the special value Insra tells Insure++ to send its output to Insra. Default is stderr.

report_limit [-1|0|1|2|3|...] (Windows)

insure++.report_limit [-1|0|1|2|3|...] (Unix)

Displays only the first given number of errors of each type at any particular source line. Setting this option to -1 will show all errors. Setting it to 0 will only show errors in summary reports, and not at runtime. Default is 1. See Displaying Repeated Errors for more information.

report_overwrite [on|off] (Windows)

insure++>report_overwrite [on|off] (Unix)

If set to off, error messages are appended to the report file rather than overwriting it on each run.

runtime [on|off] (Windows)

insure++.runtime [on|off] (Unix)

If set to off, no runtime checking or profiling is performed. The program will run much faster this way. This option can be used to check if a particular fix has cured a problem without recompiling the application without Insure++.

source_path dir1 dir2 dir3 (Windows)

insure++.source_path dir1 dir2 dir3 (Unix)

Takes a list of directories in which to search for source files See Searching For Source Code for more information. This will only be necessary if your source code has moved since it was compiled, as Insure++ remembers where all your source files are located.

spy_disable key (Windows only)

Tells Insure++ not to use the interface specified by the key value. The interfaces will then not be inserted during instrumentation at compile-time. For example:

spy_disable ole32.dll

spy_mini_dump (Windows only)

This option is capable of producing Windows MiniDumps from which register states and call stacks can be examined. This is especially useful when communicating with Insure++ support. Set one of the following options to specify when minidumps will be created:

[accessviolation|firstchance|none|nonotify|unhandled]

The default setting is none, which produces no minidumps.

You may be asked to set the option to unhandled when working with Parasoft support, which creates a minidump whenever an unhandled exception occurs.

summarize [bugs] [coverage] [leaks] [outstanding] (Windows)

insure++.summarize [bugs] [coverage] [leaks] [outstanding] (Unix)

Generates a summary report of errors. For more information, see the following sections:

• Report Summaries
• Bugs Summary
• Leak Summary
• Coverage Summary

For coverage summaries, the coverage_switches option is consulted to decide how to present coverage data. See Code Coverage for more information.

The Leaks and Outstanding reports are affected by the leak_combine, leak_sort, and leak_trace options. With no arguments, this option will summarize the bugs and leaks summaries.

summarize_on_error [0|1|2|3|...] (Windows)

insure++.summarize_on_error [0|1|2|3|...] (Unix)

Specifies how many errors must be generated before a summary (if requested) is printed. The default is 0, which means that summaries are always printed on demand. If the number is 1 or higher, summaries are only printed if at least the given number of bugs (or leaks) occurs. Suppressed errors do not count towards this number. If no argument is given with this option, a value of 1 is assumed.

suppress code [{context}] (Windows)

insure++.suppress code [{context}] (Unix)

Suppress error messages matching the given error code and occurring in the (optionally) specified context. See Suppressing Error Messages for more information.

symbol_banner [on|off] (Windows)

insure++.symbol_banner [on|off] (Unix)

If set to on, Insure++ displays a message indicating that the program’s symbol table is being processed whenever an application starts. Default is off.

symbol_table [on|off] (Windows)

insure++.symbol_table [on|off] (Unix)

If set to on, Insure++ will read the executable symbol table at startup. This enables Insure++ to generate full stack traces for third-party libraries, as well as for code compiled with Insure++. If this option is turned off, the stack traces will show only functions compiled with Insure++, but the application will use less dynamic memory and be faster on startup. To get filenames and line numbers in stack traces with this option set to off, you must compile your program with the stack_internal on option.

trace [on|off] (Windows)

insure++.trace [on|off] (Unix)

Turns program tracing on and off. In order to get file names and line numbers in the trace output, you must have the stack_internal on option set when compiling the program. Tracing Program Execution for more information about program tracing.

trace_banner [on|off] (Windows)

insure++.trace_banner [on|off] (Unix)

Specifies whether to print message at runtime showing file to which the trace output will be written. Default is on.

trace_file [filename|stderr] (Windows)

insure++.trace_file [filename|stderr] (Unix)

Specifies the name of the file to which the trace output will be written. The filename value may use the same special tokens shown on Filenames. Default is stderr.

unsuppress code [{context}] (Windows)

insure++.unsuppress code [{context}] (Unix)

Enables error messages matching the given error codes and occurring in the (optionally) specified context. See Suppressing Error Messages for more information.

verbosity [0|1|2|3|4] (Windows)

insure++.verbosity [0|1|2|3|4] (Unix)

Tells Insure++ to create an Insure++ log in the current working directory, with verbosity level n. Verbosity level ranges from 1 to 4, with 4 being the most verbose. See Troubleshooting for more information.