g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_system.a

#include <Error.h>

static boolean handle(const SysString& cname, const SysString& mname, long ecode, char* file, long line, EXIT level = DEF_EXIT, SysString& extras = DEF_EXTRAS);
static boolean set(EXIT exit_level);
static boolean reset();

Error::debug(L"testing reset & warning");

// release the setting
//
Error::reset();

// set the mode to never exit, try a regular error
//
Error::set(Error::NONE);
Error::handle(Error::name(), L"error, still no exit", Error::TEST, __FILE__, __LINE__);

• This example shows how to do error handling:

  #include <Error.h>
  #include <Console.h>
  #include <SysString.h>
  
  int main(int argc, char** argv) {
  
    SysString str1(L"test");
    SysString str2(str1);
    
    if (!str1.eq(str2)) {
      str2.debug(str2);
      Error::handle(str1.name(), L"warning", Error::TEST,
                    __FILE__, __LINE__, Error::WARNING);
      }
    else {
      Console::put(L"str1 and str2 are equal");
    }
    
    // exit gracefully
    //
    Integral::exit();
  }

• The ISIP_FULL_CHECK macro now exists to allow for defensive programming even in cases where such checks would become a bottleneck. For example, the Vector class will have a test that the array index is within bounds inside of this construct. To use this, simply have the same error checking code that we have always used,

  if (arg < 0) {
      return Error::handle(name(), L"method", Error::ARG,
                           __FILE__, __LINE__);
  }
  

  But place the entire check inside of a ISIP_FULL_CHECK macro call, ie:

  ISIP_FULL_CHECK(
  if (arg < 0) {
      return Error::handle(name(), L"method", Error::ARG,
                           __FILE__, __LINE__);
  })
  

  During development, this code will be compiled in and hence the check will be made. However, when code is compiled with optimization (by specifying a -O flag), then this check will be removed.