External Exception EEFFACE

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

#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

        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.
  

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

• 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 Exception-Objekt wird nicht freigegeben; es bleibt ein Speicherleck.
  
• "Homework assignment about window subclassing" von Raymond Chen.)
  

C++-Exceptions in Delphi - mein Ansatz

• ECppException::TypeName resultiert in typeid (<C++-Exception-Objekt>).name().
  
• ECppException::CppExceptionObject
• 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

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

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?

• 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"
  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.
  
  
• .

Windows Error Reporting

Zusammenfassung

Referenzen

Kommentare