Eigenes Errorhandling

[Desmulator]

HalliHallo,
ich bin grade dabei den Exceptionteil der SysUtils Unit neu zu schreiben, allerdings gelingt es mir nicht ganz. ich erhalte immer einen RunTime Error 127 ( Strg+C ). Ich habe wirklich alles der SysUtils Unit nachgearmt aber irgendwie geht es nicht. Im Prinzip muss ich ja nur die Proceduren für das Errorhandling in die system variablen schreiben. Naja hier mal meine Unit:

Delphi-Quellcode:

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.

Atm läuft das alles nur auf einer Console , daher kann es an dem WriteLn nciht liegen ^^

Ich freue mich über hilfe

[Jelly]

Wieso muss denn die grundlegende Exception Klasse verändert werden. Ist es nicht eventuell sinnvoller, es so zu belassen, und stattdessen einen globalen Exceptionhandler in deine Applikation zu integrieren, in dem du weitere Dinge erledigen kannst. (cf. Application.OnException)

[Desmulator]

Nun eigendlich will ich nur aus Spaß den Exception teil neu schreiben, da ich mich praktisch von den Borland "Vorabreiten" unabhänig machen will. Also noch mehr als nur None-VCL, wenn ich das richtig verstanden habe. Deshalb erarbeite ich mir grade diese Exception Klasse, allerdring erhalte ich einen Software Fehler, wenn ich das Programm nicht im Debug Modus teste.
Im Testmodus allerdings erkennt der Debugger die Exception. In beiden Fällen läuft das Programm dannach richtig weiter und die Exception wir , wie im ErrorHandle vorgesehen behandelt und ausgegeben. Das einzige was mich stört ist halt diese "Unbekannte Softwarefehler"...

Edit : Vllt verstehe ich einige Dinge auch falsch:

• Eine Exception führt zum Programmabbruch
• Mehrfällt mir nicht ein^^