Lint attempts to detect features of the named C program files that are
likely to be bugs, to be non-portable, or to be wasteful. It also
performs stricter type checking than does the C compiler. Lint runs
the C preprocessor as its first phase, with the preprocessor symbol
lint defined to allow certain questionable code to be altered
or skipped by lint. Therefore, this symbol should be thought of as a
reserved word for all code that is to be checked by lint.
Among the possible problems that are currently noted are unreachable
statements, loops not entered at the top, automatic variables declared
and not used, and logical expressions with constant values. Function
calls are checked for inconsistencies, such as calls to functions that
return values in some places and not in others, functions called with
varying numbers of arguments, function calls that pass arguments of a
type other than the type the function expects to receive, functions
whose values are not used, and calls to functions not returning values
that use the non-existent return value of the function.
However, Lint is extremely noisy - it generates many bogus warnings
and it can only detect a fraction of the errors detected by
Insure++ finds a wide variety of programming and memory access errors
Insure++ finds all memory reference errors. It does not use a
"statistical" approach to trap memory reference errors, but
rather checks each memory reference for validity when that reference
is executed. Insure++ checks all types of memory references, including
those to static(global), and stack, as well as dynamically allocated
memory. When Insure++ finds a problem, it provides a complete
diagnosis, including the name of related variables, the line of source
code containing the error, a description of the error, and a stack
- Memory corruption due to reading or writing beyond the valid
areas of global, local, shared, and dynamically allocated objects.
- Operations on uninitialized, NULL, or "wild" pointers.
- Memory leaks.
- Errors allocating and freeing dynamic memory.
- String manipulation errors.
- Operations on pointers to unrelated data blocks.
- Invalid pointer operations.
- Incompatible variable declarations.
- Mismatched variable types in printf and scanf argument lists.
Just as it does with memory reference errors, Insure++ finds all
library interface errors.
- Mismatched argument types or function declarations.
- Out of range, or otherwise invalid arguments in library calls.
- Errors returned by library calls.
Insure++ knows about every standard UNIX system call, the X Window
System, Motif, and many other popular libraries. On each library call,
Insure++ checks that every variable is of the correct type and is
within its valid range. Insure++ is the only tool with the
intelligence which assures that these libraries are called correctly,
Insure++ has perfect knowledge of all data, pointer, and memory
operations, because it studies the source code. So Insure++ captures
EVERY memory error, for EVERY type of memory - global (static), local
(stack), dynamically allocated (heap) and even shared.
Insure++, with its access to the source code, not only exposes every
memory leak, but also pinpoints the exact statement which caused the
leak, immediately when the leak occurs.
Insure++ has perfect knowledge of memory and variable usage, and
perfect recall of all memory operations. So it captures EVERY error,
no matter how many times malloc and free are called.
Insure++ has a built-in library with thousands of interfaces to common
libraries, allowing full checking on parameters and return
values. Using Insure++'s innovative Total Quality Software(tm) (TQS)
technology, you have complete control over what checks are done, and
can even perform complicated parameter checking on your own libraries
The bottom line is: INSURE++ FINDS MORE BUGS THAN ANY OTHER DEBUGGING TOOL.