External Exception EEFFACE

1. Einführung
2. Woher kommt diese Fehlermeldung?
3. Was passiert, wenn die Exception geworfen wurde?
4. Warum kann Delphi C++-Exceptions nicht behandeln?
5. Delphi-Exceptions in C++Builder
6. C++-Exceptions in Delphi - Der Ansatz von Early Ehlinger
7. C++-Exceptions in Delphi - mein Ansatz
8. Advanced Exception Dispatching
9. Und warum hat Borland das nicht von Anfang an so implementiert?
10. Windows Error Reporting
11. Zusammenfassung
12. Referenzen
13. Kommentare

Einführung

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

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

Woher kommt diese Fehlermeldung?

// 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");
		}

Was passiert, wenn die Exception geworfen wurde?

// 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 }

Warum kann Delphi C++-Exceptions nicht behandeln?

Delphi-Exceptions in C++Builder

void __fastcall TFrmMain::BtnThrowDelphiExceptionClick(TObject* Sender)
{
    try
    {     // Wir können Delphi-Excepions per Wert werfen...
        throw ERangeError ("You are one off!");
    }
    catch (Exception& e) // ...per Referenz fangen...
    {
        OutputDebugString ((String (e.ClassName ()) + ": " + e.Message).c_str ());
        throw; // ...und bei Bedarf weiterwerfen.
    }
}

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

C++-Exceptions in Delphi - Der Ansatz von Early Ehlinger

// 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

• Beim Start der Anwendung wird install_exception_object_handler() aufgerufen und installiert einen Exception-Filter in Delphis Exception-System.
  
• Wird der Filter vom Exception-System in der Delphi-RTL aufgerufen und ist der Exception-Code 0x0EEFFACE, so wird get_std_exception aufgerufen, um den Objektzeiger nach std::exception zu casten.
  
• get_std_exception behandelt den Zeiger als Zeiger auf einen polymorphen Typ und benutzt dynamic_cast<>, um ihn nach std::exception zu casten. Schlägt das fehl, wird 0 zurückgegeben.
  
• Wenn get_std_exception erfolgreich war, wird eine Meldung wie oben zu sehen aus dem Typ der Exception und dem Ergebnis eines Aufrufs von std::exception::what() zusammengestellt, andernfalls wird die Meldung gezwungenermaßen etwas allgemeiner gehalten.

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

• Earlys Unit übersetzt die grundlegenden Standard-Exceptions, soweit sie vom Standard vorgegeben werden, in äquivalente Delphi-Wrapperklassen:
  
  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

  
  Das ist ein pragmatischer Weg, um das einfache Dispatching dieser grundlegenden Typen zu ermöglichen, aber es führt zu viel Redundanz und ist andererseits nicht sehr einfach erweiterbar.
  
• Das Exception-Objekt wird nicht freigegeben; es bleibt ein Speicherleck.
  
• Auch hilft dieser Ansatz nichts, wenn es eine Delphi-Anwendung in die Lage zu versetzen gilt, C++-Exceptions behandeln zu können. Ein gutes Beispiel für eine solche Anwendung wäre C++Builder selbst. (Und es ist keine Lösung, das Unit zu allen C++Builder-Packages hinzuzufügen, da Packages zur Laufzeit wieder entladen werden können; für eine Beschreibung des sich dabei ergebenden Problems lese man das "Homework assignment about window subclassing" von Raymond Chen.)
  
• Außerdem entwickeln die meisten C++Builder-Benutzer kommerzielle Anwendungen und können GPL- und LGPL-lizenzierten Quellcode nicht verwenden.

C++-Exceptions in Delphi - mein Ansatz

• ECppException::TypeName resultiert in typeid (<C++-Exception-Objekt>).name().
  
• ECppException::CppExceptionObject gibt einen Zeiger auf das C++-Exception-Objekt zurück.
  
• Mit ECppException::IsCppClass kann festgestellt werden, ob es sich bei dem Exception-Objekt um eine Klasse handelt, und mit ECppException::AsCppClass() kann der Objektzeiger zu einer beliebigen Basisklasse (auch zu Interfaces, von denen der Objekttyp ableitet) gecastet werden. (Das Klassentemplate CppExceptionWrapper vereinfacht das Dispatching auf diesem Wege etwas.)

• ECppStdException::StdException gibt einen Zeiger vom Typ std::exception* zurück, der auf das C++-Exception-Objekt zeigt. Der Zeiger kann zwecks Dispatching wie gewohnt mit dynamic_cast<> in speziellere Exception-Klassen gecastet werden.

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; // Gibt das tatsächliche Exception-
                                                  // Objekt zurück. Ein Cast ist
                                                  // nicht notwendig.

            // Stille Exceptions werden "geschluckt".
            // (Es mag diskutabel sein, ob der Einsatz stiller Exceptions
            // gutes Design ist, aber gleichviel: sie werden benutzt, und
            // sie bieten eine gute Gelegenheit für die Demonstration meines
            // Anliegens.)
        if (dynamic_cast <silent_exception*> (cse))
        {
            ApplicationEvents->CancelDispatch ();
            return;
        }

            // Als User Notification Exceptions bezeichnen wir diejenigen
            // Exceptions, die keine Programmfehler sind, sondern durch Fehl-
            // bedienung des Benutzers verursacht werden. Man stelle sich vor,
            // der Benutzer benennt im Projekt-Manager der IDE eine Datei mit
            // F2 um. Diese Operation kann eine ganze Reihe von Folgeoperationen
            // nach sich ziehen, und wenn in einer dieser Folgeoperationen eine
            // Mehrdeutigkeit auftritt - der Name ist bereits vergeben -, so
            // wird eine User Notification Exception geworfen, die den Abbruch
            // aller vom Vorgang des Umbenennens induzierten Operationen zur
            // Folge hat und den Benutzer über die Ursache des Abbruchs
            // benachrichtigt.
            // Aus diesem Grund sollte für diese Exceptions weder ein Bug-Report
            // noch ein Eintrag in die Log-Datei erstellt werden.
        if (dynamic_cast <user_notification_exception*> (cse))
        {
            Application->ShowException (E);
            ApplicationEvents->CancelDispatch ();
            return;
        }
    }
    else if ((cew = dynamic_cast <ECppException*> (E)) != 0)
    { // C++-Exception eines beliebigen Typs
    }
    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!");
}

Und warum hat Borland das nicht von Anfang an so implementiert?

• Der Ansatz, den ich wählte, erfordert den Nachbau einiger Funktionen aus der C++-RTL in Delphi. Code-Duplikation erschwert aber die Wartung des Quelltextes nicht unerheblich; jeder professionelle Programmierer vermeidet das, ganz besonders in derart empfindlichen Bereichen.
  
• Vom Standpunkt des Sprach- oder Bibliotheksdesigners ist der Ansatz, den ich wählte, möglicherweise nicht optimal. Mein Unit mag seinen Zweck erfüllen und die "External Exception EEFFACE"-Meldungen aus der Welt schaffen, aber man sollte nicht vergessen, auf welchem Wege das erreicht wird: jede unbehandelte C++-Exception wird mittels eines Wrappers zu einer Delphi-Exception umgewandelt. Dadurch wird die strikte Trennung von Delphi- und C++-Exceptions untergraben; daß C++-Exceptions eigentlich keine Delphi-Exceptions sind und auch nicht sein sollen, wird übergangen.
  Allerdings bin ich nicht sicher, ob die Entwickler von Delphi und C++Builder das als Problem gesehen hätten. Tatsächlich wrappt Delphi, wie oben erwähnt, auch Betriebssystem-Exceptions (z.B. STATUS_INTEGER_DIVIDE_BY_ZERO oder STATUS_ACCESS_VIOLATION) in Delphi-Exceptions (EDivByZero, EAccessViolation). Zwar vertritt Raymond Chen die Auffassung "In the Win32 programming model, exceptions are truly exceptional. As a general rule, you shouldn't try to catch them", doch die Eigenheit des VCL-Frameworks, auch Betriebssystem-Exceptions zu fangen, ist eines der Dinge, die gute VCL-Programme tendentiell stabiler machen als Programme, die herkömmliche Frameworks benutzen. Das Delphi-Team war auf die Umsetzung dieses Features stolz, wie aus dem Launch-Skript für Delphi 1 unmißverständlich hervorgeht:
  
  Anders Hejlsberg bei der Einführung von Delphi 1 am 14. Februar 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.
  
  
• "Das Einbauen neuer Features ist wichtiger als das Beheben alter Probleme." Das wäre eine typische Borland-Antwort (man denke an C++BuilderX, Delphi 8, Delphi 2005), und glücklicherweise gilt das für CodeGear nicht mehr.

Windows Error Reporting

Zusammenfassung

Referenzen

Kommentare