External Exception EEFFACE

1. Introduction
2. Where does the message come from?
3. What is happening after that exception is thrown?
4. Why is Delphi unable to handle C++ exceptions?
5. Delphi exceptions in C++Builder
6. C++ exceptions in Delphi - Early Ehlinger's approach
7. C++ exceptions in Delphi - my approach
8. Advanced Exception Dispatching
9. So why did Borland not implement this in the first place?
10. Windows Error Reporting
11. Summary
12. References
13. Comments

Introduction

#include <vector>
// ...
void __fastcall TFrmMain::BtnThrowExceptionClick(TObject* Sender)
{
    std::vector <String> myStrings;

    myStrings.push_back ("Some string");
    Caption = myStrings.at (1);
}

Where does the message come from?

// vector, l.640ff
	const_reference at(size_type _Pos) const
		{	// subscript nonmutable sequence with checking
		if (size() <= _Pos)
			_Xran();
		return (*(begin() + _Pos));
		}

// vector, l. 1231ff
	void _Xran() const
		{	// report an out_of_range error
		_THROW(out_of_range, "invalid vector<T> subscript");
		}

What is happening after that exception is thrown?

// Controls.pas, l. 9059ff
procedure TWinControl.MainWndProc(var Message: TMessage);
begin
  try
    try
      WindowProc(Message);
    finally
      FreeDeviceContexts;
      FreeMemoryContexts;
    end;
  except
    Application.HandleException(Self);
  end;
end;

const { copied from xx.h }
  cContinuable        = 0;
  cNonContinuable     = 1;
  cUnwinding          = 2;
  cUnwindingForExit   = 4;
  cUnwindInProgress   = cUnwinding or cUnwindingForExit;
  cDelphiException    = $0EEDFADE;
  cDelphiReRaise      = $0EEDFADF;
  cDelphiExcept       = $0EEDFAE0;
  cDelphiFinally      = $0EEDFAE1;
  cDelphiTerminate    = $0EEDFAE2;
  cDelphiUnhandled    = $0EEDFAE3;
  cNonDelphiException = $0EEDFAE4;
  cDelphiExitFinally  = $0EEDFAE5;
  cCppException       = $0EEFFACE; { used by BCB }

Why is Delphi unable to handle C++ exceptions?

Delphi exceptions in C++Builder

void __fastcall TFrmMain::BtnThrowDelphiExceptionClick(TObject* Sender)
{
    try
    {     // We can throw Delphi exceptions by value...
        throw ERangeError ("You are one off!");
    }
    catch (Exception& e) // ...catch them by reference...
    {
        OutputDebugString ((String (e.ClassName ()) + ": " + e.Message).c_str ());
        throw; // ...and re-throw them as we like.
    }
}

        throw new ERangeError ("You are one off!");

C++ exceptions in Delphi - Early Ehlinger's approach

// Copyright (c) 2003 Early Ehlinger
// GNU Lesser General Public License, v2.1
// http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html

typedef Exception* (__fastcall* ExceptObjProcType)( Sysutils::TExceptionRecord* P );
ExceptObjProcType pOldExceptObjProc = NULL;

class not_standard_exception
  {
  public:
    virtual void foo() = 0;
  };

std::exception const* get_std_exception( not_standard_exception const* p_exception )
  {
  std::exception const* p_std_exception = 0;
  __try
    {
    p_std_exception = dynamic_cast< std::exception const* >( p_exception );
    }
  __except( EXCEPTION_EXECUTE_HANDLER )
    { }
  return p_std_exception;
  }


Exception* __fastcall GetCppExceptionObject(Sysutils::TExceptionRecord* P)
{
  // ...
      if ( std::exception const* p_std_exception = get_std_exception( p_exception ) )
  // ...
}

void install_exception_object_handler( )
  {
  pOldExceptObjProc = reinterpret_cast< ExceptObjProcType >( ExceptObjProc );
  System::ExceptObjProc = GetCppExceptionObject;
  }
#pragma startup install_exception_object_handler

void uninstall_exception_object_handler( )
  {
  if ( pOldExceptObjProc )
    System::ExceptObjProc = pOldExceptObjProc; // System.pas
  }
#pragma exit uninstall_exception_object_handler

• At startup, install_exception_object_handler() is called and installs an exception filter into Delphi's exception system.
  
• When the exception filter is invoked by Delphi's exception system and the exception code equals 0x0EEFFACE, get_std_exception is called to cast the pointer to std::exception*.
  
• get_std_exception treats the pointer as a pointer to a polymorphic object and tries to cast it to std::exception with dynamic_cast<>. If this fails, it returns 0.
  
• If get_std_exception succeeded, the exception filter composes an error message from the exception type and the message returned by std::exception::what(). Otherwise, it generates a more general message.

  __try
    {
    p_std_exception = dynamic_cast< std::exception const* >( p_exception );
    }
  __except( EXCEPTION_EXECUTE_HANDLER )
    { }

• Early provides Delphi exception classes which resemble the basic standard exception types of C++:
  
  Early Ehlinger - Translate Standard Exceptions:

  C++ Exception	VCL Exception
  std::logic_error	CppStdLogicError
  std::domain_error	CppStdDomainError
  std::invalid_argument	CppStdInvalidArgument
  std::length_error	CppStdLengthError
  std::out_of_range	CppStdOutOfRange
  std::runtime_error	CppStdRuntimeError
  std::range_error	CppStdRangeError
  std::overflow_error	CppStdOverflowError
  any other exception derived from std::exception	CppStdException
  any c++ exception not derived from std::exception	CppException

  
  While this is a pragmatic approach that allows for dispatching of some basic exception types defined by the standard, it leads to code redundancy and is not extensible.
  
• The exception object is not freed, so we still have a leak.
  
• Also, the unit is not of much help if your application is written in Delphi and uses packages compiled with C++Builder - the best example for this scenario being the C++Builder IDE itself. In that case, the application should, although written in Delphi, be able to handle C++ exceptions, but it is currently not possible to add units written in C++ to a Delphi application. (Adding this unit to all C++Builder packages does not solve this problem but introduces a new one as packages can be unloaded at runtime; read Raymond Chen's "Homework assignment about window subclassing" for more details on this kind of problem.)
  
• And finally, many C++Builder programmers are writing commercial applications and cannot use source code that is licensed under GPL or LGPL.

C++ exceptions in Delphi - my approach

• ECppException::TypeName returns typeid (actualExceptionObject).name().
  
• ECppException::CppExceptionObject returns a raw pointer to the actual exception object.
  
• You can use the ECppException::IsCppClass property and the ECppException::AsCppClass() function to check whether the exception object is a class and to downcast it to a base class or interface, if possible. (The CppExceptionWrapper class template is helpful with dispatching such classes more easily.)

• ECppStdException::StdException returns a pointer of type std::exception* which points to the actual exception object. Use dynamic_cast<> to dispatch it.

unit SystemCppException;

interface

uses
  SysUtils;

type
  PCppStdException = type Pointer; { mapped to std::exception* via $HPPEMIT }
  {$EXTERNALSYM PCppStdException}

  { C++ exception of any type }
  ECppException = class (Exception)
    private
      FTypeName: AnsiString;
      FExcDesc:  Pointer;

      constructor CreateTypeNamed (_TypeName: PAnsiChar; ExcDesc: Pointer); overload;
      function GetCppExceptionObject: Pointer;
      function GetThrowLine: Integer;
      function GetThrowFile: AnsiString;

    public
      property CppExceptionObject: Pointer    read GetCppExceptionObject;
      property ThrowLine:          Integer    read GetThrowLine;
      property ThrowFile:          AnsiString read GetThrowFile;
      property TypeName:           AnsiString read FTypeName;

      function IsCppClass: Boolean;

      { ATTENTION: this function does perform downcasts only! }
      function AsCppClass (CppClassName: AnsiString): Pointer;

      destructor  Destroy; override;
  end;

  { C++ exception derived from std::exception }
  ECppStdException = class (ECppException)
    private
      FExcObj: PCppStdException;

      constructor Create (AExcObj: PCppStdException; Msg: String;
                          _TypeName: PAnsiChar; ExcDesc: Pointer); overload;
      function GetStdException: PCppStdException;

    public
      { This property returns a pointer to the wrapped exception. }
      property    StdException: PCppStdException read GetStdException;

      destructor  Destroy; override;
  end;

  (*$HPPEMIT '#include <typeinfo>'*)
  (*$HPPEMIT '#include <exception>'*)
  (*$HPPEMIT ''*)
  (*$HPPEMIT 'namespace Systemcppexception'*)
  (*$HPPEMIT '{'*)
  (*$HPPEMIT ''*)
  (*$HPPEMIT 'class DELPHICLASS ECppException;'*)
  (*$HPPEMIT ''*)
  (*$HPPEMIT 'template <class E>'*)
  (*$HPPEMIT '    class CppExceptionWrapper'*)
  (*$HPPEMIT '{'*)
  (*$HPPEMIT 'private:'*)
  (*$HPPEMIT '    E* internalClass;'*)
  (*$HPPEMIT '    struct _safebool_t;'*)
  (*$HPPEMIT ''*)
  (*$HPPEMIT 'public:'*)
  (*$HPPEMIT '    CppExceptionWrapper (ECppException* exception)'*)
  (*$HPPEMIT '     : internalClass (static_cast <E*> (exception->AsCppClass (typeid (E).name ())))'*)
  (*$HPPEMIT '    {}'*)
  (*$HPPEMIT '    operator _safebool_t* (void) const'*)
  (*$HPPEMIT '    { return (_safebool_t* ) internalClass; }'*)
  (*$HPPEMIT '    E& operator * (void)'*)
  (*$HPPEMIT '    { return *internalClass; }'*)
  (*$HPPEMIT '    E* operator -> (void)'*)
  (*$HPPEMIT '    { return internalClass; }'*)
  (*$HPPEMIT '};'*)
  (*$HPPEMIT ''*)
  (*$HPPEMIT 'typedef std::exception* PCppStdException;'*)
  (*$HPPEMIT ''*)
  (*$HPPEMIT '}	/* namespace Systemcppexception */'*)

Advanced Exception Dispatching

class silent_exception : public std::runtime_error
{
public:
    silent_exception (void)
     : std::runtime_error ("")
    {}
};

class user_notification_exception : public std::runtime_error
{
public:
    user_notification_exception (const char* arg)
     : std::runtime_error (arg)
    {}
};

bool displayExceptionDialog (HANDLE hParentWnd, Exception* E,
                             bool sendReport)
{
    ECppException* ce = dynamic_cast <ECppException*> (E);
    String typeName;
    String throwFile;
    int throwLine = 0;

    if (ce)
    {
        typeName = ce->TypeName;
        throwFile = ce->ThrowFile;
        throwLine = ce->ThrowLine;
    }
    else
        typeName = E->ClassName ();

    String Message = Format ("Unhandled exception of type %s:\n\n%s",
        ARRAYOFCONST ((typeName, E->Message)));
    DWORD questionstyle = 0;

    if (!throwFile.IsEmpty ())
    {
        Message += Format ("\n\nThrown in: %s\nLine: %d",
            ARRAYOFCONST ((throwFile, throwLine)));
    }
    if (sendReport)
    {
        questionstyle = MB_YESNO;
        Message += "\n\nSend report?";
    }
    return (MessageBox (hParentWnd, Message.c_str (), Application->Title.c_str (),
                        MB_ICONERROR | questionstyle) == IDYES);
}

void sendBugReport (Exception* E)
{
    // ...
}

void writeToLogFile (Exception* E)
{
    // ...
}


void __fastcall TFrmMain::ApplicationEventsException(TObject* Sender,
    Exception* E)
{
    ECppStdException* csew;
    ECppException* cew;

    if ((csew = dynamic_cast <ECppStdException*> (E)) != 0) // standard C++ exception
    {
        std::exception* cse = csew->StdException; // Get the inner exception.
                                                  // Note that no hard cast is
                                                  // required.

            // Swallow Silent Exceptions.
            // (Whether Silent Exceptions are good design is debatable, but
            // people use them, and it is a nice demonstration of dynamic
            // exception dispatching.)
        if (dynamic_cast <silent_exception*> (cse))
        {
            ApplicationEvents->CancelDispatch ();
            return;
        }

            // User Notification Exceptions are not errors but caused by
            // misbehavior of the user. Imagine the IDE's project manager
            // which allows to rename a file by pressing F2. If the user
            // enters a file name that is already used in the project,
            // the project manager would throw a user notification exception,
            // thus cancelling all pending renaming operations which would
            // have been induced.
            // Therefore, we don't want bug reports or logfile entries
            // for that kind of exception.
        if (dynamic_cast <user_notification_exception*> (cse))
        {
            Application->ShowException (E);
            ApplicationEvents->CancelDispatch ();
            return;
        }
    }
    else if ((cew = dynamic_cast <ECppException*> (E)) != 0)
    { // non-standard C++ exception
    }
    else
    { // Delphi or OS exception
    }

    if (displayExceptionDialog (Handle, E, true))
        sendBugReport (E);
    writeToLogFile (E);
}

void __fastcall TFrmMain::BtnUserNotificationExceptionClick(TObject* Sender)
{
    throw user_notification_exception ("Don't do that!");
}

So why did Borland not implement this in the first place?

• The approach taken by me duplicates some code from the C++ RTL. Code duplication implicates maintenance difficulties, and every professional programmer wishes to avoid that, particularly in delicate areas which moreover are subject to change.
  
• From the language/library designer viewpoint, my approach might be questionable. Sure, the net effect is an informative message for the user instead of "External Exception EEFFACE", but consider what my unit is doing to achieve this: it wraps every unhandled C++ exception into a Delphi exception. Thus it is bypassing the clear distinction between Delphi and C++ exceptions.
  I am however not sure whether the developers of Delphi and C++Builder saw a problem in this. In fact, Delphi wraps OS exceptions (such as STATUS_INTEGER_DIVIDE_BY_ZERO or STATUS_ACCESS_VIOLATION) into Delphi exceptions (EDivByZero, EAccessViolation). Although Raymond Chen says "In the Win32 programming model, exceptions are truly exceptional. As a general rule, you shouldn't try to catch them", this very feature is one of those which tend to make VCL programs more stable than other programs. The Delphi team has been proud of that feature, as the Delphi 1 launch script clearly points out:
  
  Anders Hejlsberg at the Delphi 1 launch on February 14, 1995:
  I'm sure you've heard something like this before: "Yeah, this app is great, but boy when something goes wrong you get GP faults all over the place".
  
  Well not with Delphi.
  
  In fact, speaking of GP faults, let me show you what happens in Delphi.
  
  [...]
  
  As you can see, a GP fault occurred, and Delphi's default exception handler caught it and is showing an error dialog.
  But notice that the app is still running.
  
  
• "Implementing new features was of higher priority than fixing old bugs." This would be a typical Borland answer (think C++BuilderX, Delphi 8, Delphi 2005), and I am happy that this can't be said for CodeGear anymore.

Windows Error Reporting

Summary

References

Comments