unit Exceptions;

interface

type
  { Exception : Einfache Exception }
  Exception = class(TObject)
  private
    { FMessage : Enthält die Fehlernachricht }
    FMessage: string;
    { FHelpContext : Enthält den Hilfekontext }
    FHelpContext : Integer;
  public
    { Create : Erstellt die Exception mit der Nachricht Msg }
    constructor Create(const Msg: String);
    { Message : Enthält die Nachricht }
    property Message: string read FMessage write FMessage;
    { HelpContext : Enthält den Hilfekontext }
    property HelpContext: Integer read FHelpContext write FHelpContext;
  end;

implementation

{ Exception.Create }
constructor Exception.Create(const Msg: String);
begin
  { Inherited }
  Inherited Create;
  { Speichern der Message }
  FMessage := Msg;
end;

{ ExceptHandler : Handle für Exceptions die auserhalb eines try..catch blocks aufsteigen }
procedure ExceptHandler(ExceptObject: TObject; ExceptAddr: Pointer);
var
  E : Exception;
begin
  { Wenn wir eine Exception haben }
  if ( ExceptObject is Exception ) then begin
    { ExceptObject als Exception behandlen }
    E := ExceptObject as Exception;
    { Nachricht ausgeben }
    WriteLn(E.Message);
  end;
end;

procedure ErrorHandler(ErrorCode: Byte; ErrorAddr: Pointer);
var
  E : Exception;
begin
  { Exception erstellen }
  E := Exception.Create('Runtime - Error');
  { Werfen }
  raise E;
end;

procedure AssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
var
  E : Exception;
begin
  { Exception erstellen }
  E := Exception.Create('Assert - Error');
  { Werfen }
  raise E;
end;

procedure AbstractErrorHandler;
var
  E : Exception;
begin
  { Exception erstellen }
  E := Exception.Create('Abstract - Error');
  { Werfen }
  raise E;
end;

initialization
  { ExceptProc setzen }
  System.ExceptProc := @ExceptHandler;
  System.ExceptionClass := Exception;
  { ErrorProc setzen }
  System.ErrorProc := @ErrorHandler;
  { AssertErrorProc setzen }
  AssertErrorProc := @AssertErrorHandler;
  { AbstractErrorProc setzen }
  AbstractErrorProc := @AbstractErrorHandler;
finalization
  { ExceptProc leeren }
  System.ExceptProc := nil;
  System.ExceptionClass := nil;
  { ErrorProc leeren }
  System.ErrorProc := nil;
  { AssertErrorProc leeren }
  AssertErrorProc := nil;
  { AbstractErrorProc leeren }
  AbstractErrorProc := nil;
end.