Delphi Clinic

C++Builder Gate

Training & Consultancy

Delphi Notes Weblog

Dr.Bob's Webshop

Integrating Structured Exception Handling See Also:  C++Builder Papers and Columns

Aside: letting the coprocessor generate exceptions
Per default, the runtime library of Borland C++ and Borland C++Builder, which are very alike if you compare Borland C++Builder and Borland C++ version 5.02, initialise the coprocessor in such a fashion that it will not generate an exception if you attempt to divide by zero. Actually, dividing a positive floating-point number by 0.0 will yield +INF, which means positive infinity. If that is behaviour we do not want, we can influence it by setting a bit in the coprocessor that tells it not to handle division by zero to yield +INF or -INF, but to generate a hardware exception. In fact, that might be a better way to handle such a border case than checking every time for infinity or checking the denominator of a division every time. If you instruct the coprocessor to generate an exception when you attempt to divide by zero, you actually let your hardware do the work for you instead of using software to check the results of the division.
The method to do that is to use the _control87 function to set the appropriate exception mask on the coprocessor. Have a look at for the exception mask values. To unmask every exception, you execute:

  #include <float.h>
  unsigned int oldx87mask = _control87(0, MCW_EM);

  _control87((_control87(0, 0) | ~EM_xxxx), MCW_EM);

  _control87(oldx87mask, MCW_EM);

Influencing the exception handler chain
You can influence the exception handler chain by inserting your own handler at the head of the chain. This is roughly the safest approach. Since we always have an object oriented approach, we use a class for it. The beauty of that is that we can integrate a structured exception into the exception hierarchy of the standard C++ library if you so desire:

  class XOS: public runtime_error
  {
  public:
    XOS(_EXCEPTIONREPORTRECORD* exRec, _CONTEXT* cxPtr);
    XOS(const XOS& that);
    const XOS& operator=(const XOS& that);
    ~XOS() throw();

    static void XOS::SetExceptionHandler();
    //  Set translator function to our static Translator method.
    //  Can be used only once. Any subsequent use does nothing.
    //  PRE:  oldtranslator == 0
    //  POST: oldtranslator points to previous translator routine
    //  EXC:  -
  
    static void XOS::RevertExceptionHandler();
    //  Revert translator function to old setting.
    //  Can be used only once. Any subsequent use does nothing.
    //  PRE:  oldtranslator != 0
    //  POST: oldtranslator = 0
    //  EXC:  -
  
    friend ostream& operator<<(ostream& ostr, const XOS& obj);
    //  Print contents of object on ostream. Use as for example
    //  cout << xosobject << endl; simply calls printon. no need
    //  to specialize in derived classes.
    //  pre:  -
    //  post: content of object output on ostr
    //  exc:  -
  
  protected:
    virtual void PrintOn(ostream& ostr) const;
    //  PRE:  -
    //  POST: content of object output on ostr (partial)
    //  EXC:  -
  
  private:
    XOS();

    _EXCEPTIONREPORTRECORD* er;
          _CONTEXT* cx;
  };

  unsigned long (*oldhandler)(_EXCEPTIONREPORTRECORD* p,
                              _EXCEPTIONREGISTRATIONRECORD* q,
                              _CONTEXT* r,
                              void* s) = 0;

  unsigned long ExceptionHandler
  (
    _EXCEPTIONREPORTRECORD* p,
    struct _EXCEPTIONREGISTRATIONRECORD* /*q*/,
    _CONTEXT* r,
    void* /*s*/
  )
  {
  #define CPP_EXCEPT_CODE 0x0EEFFACEL
  #define PAS_EXCEPT_CODE 0x0EEDFACEL
  unsigned long result = XCPT_CONTINUE_SEARCH;
  if ((p->ExceptionNum != CPP_EXCEPT_CODE) ||
      (p->ExceptionNum != PAS_EXCEPT_CODE))
    {
      result = XCPT_CONTINUE_EXECUTION;
      throw XOS(p, r);
    }
    return result;
  }

  // public
  XOS::XOS(_EXCEPTIONREPORTRECORD* exPtr, _CONTEXT* cxPtr): runtime_error(string("XOS: ")),
    er(exPtr),
    cx(cxPtr)
  {}

  XOS::XOS(const XOS& that): runtime_error(that),
    er(that.er),
    cx(that.cx)
  {}

   XOS& XOS::=(const XOS& that)
  {
    if (this != & that)
    {
      runtime_error::operator=(that);
      er = that.er;
      cx = that.cx;
    }
    return *this;
  }

  XOS::~XOS() throw()
  {}

  void XOS::SetExceptionHandler()
  {
    if (oldhandler == 0)
    {
      oldhandler = _SetUserHandler(ExceptionHandler);
    }
  }

  void XOS::RevertExceptionHandler()
  {
    if (oldhandler != 0)
    {
      _SetUserHandler(oldhandler);
      oldhandler = 0;
    }
  }

  ostream& operator<<(ostream& ostr, const XOS& obj)
  {
    obj.PrintOn(ostr);
    return ostr;
  }

  // protected
  void XOS::PrintOn(ostream& ostr) const
  {
    ostr  << runtime_error::what()
          << " error "
          << hex
          << er->ExceptionNum
          << "@"
          << er->ExceptionAddress
          << ", "
          << er->cParameters
          << " parameters."
          << endl;
  }

  // private
  XOS::XOS(): runtime_error(string("Private XOS::XOS() called!"))
  {}