Expandability allows us to continually add new features and new classes of bugs to Insure++. You can expect us to continue to follow this path in the future. We are excited about adding more and more complicated errors to Insure++'s growing list of bugs detected.

Object-level technologies are very limited and are only applicable to certain classes of memory corruption errors. One particular object-level technology, object transformation, suffers from severe limitations, the most prominent of which is that it can only check dynamic memory. This means that many common memory reference errors would be ignored by an object transformation based debugger. For example, the code below would pass with no error found.

foo() {
  char tmp[12];

  strcpy(tmp, "This string is too long!");
  return;
}

The other technology, library replacement, is even worse, since it checks references only when a function is called.

Object-level runtime debuggers suffer further from a more serious limitation. They cannot go beyond even this limited memory reference checking to detect other, more complicated classes of errors. Since our main focus was to detect as many bugs as possible, we chose source instrumentation for Insure++. This technology was particularly appropriate as we made the move to a complicated language like C++.

Despite their limitations, object-level technologies can be of some use when the source code is not available. That is why Insure++ also incorporates object-level technologies to enhance its error detection ability.

This is particularly useful in checking third-party libraries. Insure++, using library replacement, can help you find errors in third-party libraries by establishing whether the error was caused by the programmer or is inside the library code itself, even if the source code is not available. This is done by checking the validity of the parameters of every library function call at the time of the call as well as the return code from the function. If the parameters are the correct types in valid ranges and Insure++ reports an error in the library, the function returns an error, or the library crashes, then you know that there is a bug in the library.

Because of it's utilization of source level technology, Insure is *unique* in it's functionality; NO OTHER TOOL CAN MATCH INSURE'S ERROR DETECTION CAPABILITIES!