Announcement

**Hagen Reddmann** · 07.06.2003, 17:08

Vielleicht will ja jemand noch ein kleines Delphi IDE Plugin coden. z.B. den Compileroptions-Dialog patchen und eine ComboBox reinsetzen in der man das Verhalten des Asserthandlers noch einstellen kann. W�re ja echt toll.

Gru� Hagen

PS: rede ich nur mir mir selbst, oder scheint die Sonne draussen ? :

**Ulrich Gerhardt** · 10.06.2003, 08:13

PS: rede ich nur mir mir selbst, oder scheint die Sonne draussen ?

Sorry, aber meine heimische Internetanbindung hat den Geist aufgegeben. Und das rechtzeitig vor einem langen WE. :-( / :-) 
Soeben bin ich wieder ins Internet gekommen und sehe als erstes neues Posting Nummer 13 von 27! Offenbar habe ich deine Neugier/Spieltrieb/... geweckt. :-)
Ich werd mir das Ganze baldm�glichst mal reinziehen. 
Ciao, Uli.
PS: Die Idee mit dem Plugin klingt gut. Bin grad eh aufm ToolsApi-Trip

**Hagen Reddmann** · 10.06.2003, 12:37

Hi Ulrich,

habe den Source gerade unter D6-D7 getestet, wie zu erwarten funktionierte er da nicht

Aber, mit einigen kleineren �nderungen l�uft er nun auch unter D6-D7. 
Falls du ihn haben willst dann mail mir an [email protected], ich habe n�mlich keine Lust hier wieder 4 Einzelpostings zu posten nur weil die maximale Messagel�nge so gering gehalten wird. 

�brigens, wenn der Code an der Assert() stoppt, kann nur mit F8 weitergesteppt werden. Bei F7,Strg+F7 springt er in den Code der �ber-�bergeordneten Funktion

( 
Mir pers�nlich reicht aber F8.
 
Zus�tzlich habe ich am neuen Source noch eiige Vereinfachungen im Interface vorgenommen. 
Wie gesagt, schick mir ne mail.

Gru� Hagen

PS: bezugnehmend auf eine meiner letzten Diskussionen hier im Forum. Der Grund warum der D5 Source nicht auf D6-D7 sofort funktionierte waren �nderungen in der RTL um diese Kylix kompatibel zu machen. 
&#10

**Ulrich Gerhardt** · 10.06.2003, 14:15

Hallo Hagen, 
Mail kommt -- danke im Voraus. Ich benutze zwar D5, aber ich will ja nichts verpassen. :-)
 Ciao, Uli

**Ulrich Gerhardt** · 10.06.2003, 17:12

Hi Hagen! 
So, jetzt hab ich alles mal aus den diversen Postings zusammenklabustert
und ausprobiert -- funktioniert, aber keine Ahnung wie.
Grob versteh ich ja noch, was du machst (am Stack rumbasteln,
Returnadressen verbuchseln, ...) und in der Assemblerversion von ChoiceAssertErrorHandler
glaube ich die �berbleibsel meines schnuckeligen Pascalcodes zu erkennen --
dank einiger Konstanten als Orientierunhgspunkte. Aber einigerma�en im Detail...

Jetzt hab ich mir gedacht: kein Thema, debuggst du halt mal durch, dann
wird's schon heller, aber nix da -- Debuggen is' nich'.
Sobald ich auf CALL AssertErrorProc in _Assert stehe und F7 dr�cke,
f�ngt's an, lustig zu werden. Ich komme zum Beispiel einfach nicht in
die Implementation von ChoiceAssertErrorHandler hinein, sondern nur in
z.B. das Format, das du in Debug aufrufst. In Debug selber wiederum komme
ich auch nicht. Usw.ufs. Ich probiere sp�ter noch weiter, jetzt ist erstmal
Feierabend. :-)
 Ciao, Uli

**Hagen Reddmann** · 10.06.2003, 18:11

Hi Uli

Als erstes musst du unbedingt die Compilerswitches hinter dem "Unit Asserts" ausklammern, ersetze einfach das "$" durch einen Punkt, oder setze ihn einfach davor. Dann wird alles mit einem Build und Debuginfos neu compliliert. 
Im CPU Windows dann mit F7 debuggen. 

Am Stack selber fummle ich sehr wenig rum. Und Recht haste, die Logik deines PASCAL Codes habe ich in die Assemblerroutine mit �bernommen. Die ersten zeile mit dem CMP's sind deine CASE Abfrage. Der Compiler w�rde �hnlchen Code generieren. Alles bis auf den abDebug-Part ist eigentlich so wie in deinem PASCAL Source identisch. 

Im abDebug Part, werden nun als erstes die parameter vom Stack geholt und der Stack so abger�umt das ein RET NICHT in die �bergeordnete _Assert() procedure zur�ckspringt sondern an die Adresse nach dem Assert() im Source. 

Wir haben auf dem Stack, topdown: 
PUSH AssertAddresse + 4 
PUSH ReturnAddresse zu _Assert 
PUSH ReturnAddresse zu Assert im Source = AssertAddress +4 

Uns interssiert nur die AssertAdresse, deshalb wird alle andere vom Stack entfernt. 

Bevor ich hier aber weiterposte, schicke ich dir erstmal die neueste Version, da sie wesentliche �nderungen enth�lt. 

Gru� Hage

**Hagen Reddmann** · 11.06.2003, 02:39

Hier mochmal die �berarbeitete Version. Sie benutzt nun einen anderen Trick und unterst�tzt auch die Keys F7,F8,F9 korrekt. 
Lauff�hig unter D5,D6,D7. 

<pre>

<code>unit Asserts;
{$A+,B-,C-,D-,E-,F-,G+,H+,I-,J+,K-,L-,M-,N+,O+,P+,Q-,R-,S-,T-,U+,V+,W-,X+,Y-,Z1}
 
interface
 
type
TAssertType = (atDelphi, atIgnore, atHalt, atDebug, atAsk, atSavedOption);
 
var
AssertType: TAssertType = atSavedOption;
 
implementation
 
// get complier
{$DEFINE VER_???}
 
{$IFDEF VER140} // D6
{$DEFINE VER_D6H}
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER150} // D7
{$DEFINE VER_D6H}
{$UNDEF VER_???}
{$ENDIF}
 
{$IFDEF VER90} // D2
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER100} // D3
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER120} // D4
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER130} // D5
{$UNDEF VER_???}
{$ENDIF}
 
{$IFDEF VER_???}
{$Error please verify code for compatibility}
{$ENDIF}
 
 
uses
Windows, SysConst, SysUtils, Registry, TypInfo;
 
var
OldAssertErrorProc: procedure(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
 
function HasDebugger: Boolean;
asm
MOV EAX,FS:[018h]
MOV EAX,[EAX + 030h]
MOV AL,[EAX + 002h]
end;
 
function GetUserChoice(const Message, Filename: String; LineNumber: Integer; ErrorAddr: Pointer): TAssertType;
resourcestring
sAssertAsk = '%s'#13#10'(%s, Line %d, Address $%p)'#13#10#13#10 +
'Wollen Sie die Anwendung beenden ("Abbrechen&quot

, ' +
'debuggen ("Wiederholen&quot

oder die Assertion ignorieren?';
var
S: String;
begin
S := Format(sAssertAsk, [Message, Filename, LineNumber, ErrorAddr]);
case MessageBox(GetForegroundWindow, PChar(S), PChar(sAssertionFailed),
MB_ABORTRETRYIGNORE or MB_ICONERROR) of
IDABORT: Result := atHalt;
IDRETRY: if HasDebugger then Result := atDebug
else Result := atDelphi;
else
Result := atIgnore;
end;
end;
 
function GetSavedChoice: TAssertType;
begin
with TRegIniFile.Create('SOFTWARE\Borland') do
try
Result := TAssertType(ReadInteger('Assertion', 'Type', 0));
if not (Result in [atDelphi..atAsk]) then Result := atDelphi;
finally
Free;
end;
end;

</code></pre&gt

**Hagen Reddmann** · 11.06.2003, 02:39

<pre>

<code>function Patch(Addr: PChar): Boolean;
// patch at Addr to INT 3; MOV EDX,[EDX]
// if not possible the return FALSE, otherwise TRUE
type
PBreakpoint = ^TBreakpoint;
TBreakpoint = packed record
INT3: Byte;
MOV_EDX_EDX: Word;
end;
 
var
Protect: DWord;
begin
Result := VirtualProtect(Addr, SizeOf(TBreakpoint), PAGE_READWRITE, @Protect);
if Result then
try
PBreakpoint(Addr).INT3 := $CC;
PBreakpoint(Addr).MOV_EDX_EDX := $128B; // MOV EDX,[EDX] where EDX is 0
finally
VirtualProtect(Addr, SizeOf(TBreakpoint), Protect, nil);
FlushInstructionCache(GetCurrentProcess, Addr, SizeOf(TBreakpoint));
end;
end;
 
function AssertAddr: PChar;
// get address of _Assert in System.pas
asm
MOV EAX,OFFSET System.@Assert
end;
 
procedure Unpatch(Addr: PChar);
// patch at Addr CALL System._Assert, we restore so above patch
type
PCall = ^TCall;
TCall = packed record
OpCode: Byte;
Offset: Integer;
end;
 
var
Protect: DWord;
begin
if VirtualProtect(Addr, SizeOf(TCall), PAGE_READWRITE, @Protect) then
try
PCall(Addr).OpCode := $E8;
PCall(Addr).Offset := AssertAddr - Addr - SizeOf(TCall);
finally
VirtualProtect(Addr, SizeOf(TCall), Protect, nil);
FlushInstructionCache(GetCurrentProcess, Addr, SizeOf(TCall));
end;
end;
 
procedure Debug(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
resourcestring
sAssertDebug = 'Assert %s: %s at line %d on address $%p';
var
S: String;
begin
S := Format(sAssertDebug, [Message, FileName, LineNumber, ErrorAddr]);
OutputDebugString(PChar(S));
end;

</code></pre&gt

**Hagen Reddmann** · 11.06.2003, 02:40

<pre>

<code>procedure ChoiceAssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
type
PContext = ^TContext;
TContext = packed record
ContextFlags: DWord;
// Debug
RegDr0,RegDr1,RegDr2,RegDr3,RegDr6,RegDr7: DWord;
// Floating Point
ControlWord,StatusWord,TagWord,
ErrorOffset,ErrorSelector,
DataOffset,DataSelector: DWord;
Registers: array[0..79] of Byte;
Cr0NpxState: DWord;
// Segments
SegGS,SegFS,SegES,SegDS: DWord;
// Integers
RegEDI,RegESI,RegEBX,RegEDX,RegECX,RegEAX: DWord;
// Control
RegEBP,RegEIP,SegCS,EFlags,RegESP,SegSS: DWord;
end;
 
 
const
CONTEXT_i386 = $00010000;
CONTEXT_i486 = $00010000;
CONTEXT_CONTROL = CONTEXT_i386 or $00000001;
CONTEXT_INTEGER = CONTEXT_i386 or $00000002;
CONTEXT_SEGMENTS = CONTEXT_i386 or $00000004;
CONTEXT_FLOATING_POINT = CONTEXT_i386 or $00000008;
CONTEXT_DEBUG_REGISTERS = CONTEXT_i386 or $00000010;
 
CONTEXT_NORMAL = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_SEGMENTS;
CONTEXT_ALL = CONTEXT_CONTROL or CONTEXT_INTEGER or CONTEXT_SEGMENTS or
CONTEXT_FLOATING_POINT or CONTEXT_DEBUG_REGISTERS;
 
type
PExceptionRecord = ^TExceptionRecord;
TExceptionRecord = packed record
ExceptionCode: DWord;
ExceptionFlags: DWord;
NextExceptionRecord: PExceptionRecord;
ExceptionAddress: Pointer;
NumberParameters: Integer;
case Integer of
0: (ExceptAddr: Pointer; ExceptObject: Pointer);
1: (ExceptionInformation: array [0..14] of DWord);
end;
 
PExceptionFrame = ^TExceptionFrame;
TExceptionFrame = packed record
Next: PExceptionFrame;
Desc: Pointer;
RegEBP: DWord;
end;
 
PExceptionParams = ^TExceptionParams;
TExceptionParams = packed record
Caller: Pointer;
Exception: PExceptionRecord;
Frame: PExceptionFrame;
Context: PContext;
Dispatcher: PContext;
end;
 

</code></pre&gt

**Hagen Reddmann** · 11.06.2003, 02:40

<pre>

<code>asm
PUSH EAX // save params
PUSH EDX
PUSH ECX
 
PUSH ErrorAddr // some Debugoutput
CALL Debug // visible at eventlog
 
MOV AL,AssertType // set AL to default
CMP AL,atSavedOption
JNZ @@0
 
CALL GetSavedChoice
 
@@0: CMP AL,atAsk
JNZ @@1 // AssertiType <> atAsk ??
 
MOV ECX,[ESP + 0]
MOV EDX,[ESP + 4]
MOV EAX,[ESP + 8] // Message
PUSH ErrorAddr // NO, ask user
CALL GetUserChoice
 
@@1: POP ECX
POP EDX
 
CMP AL,atHalt
JNZ @@2 // AssertType <> atHalt ??
MOV EAX,666 // NO, then FatalExist(666)
CALL FatalExit
JMP @@9 // jmp to restore stack, but normaly never called
 
@@2: CMP AL,atDelphi // AssertType == atDelphi ??
JZ @@8
 
@@3: CMP AL,atDebug // AssertType <> atDebug ??
JNZ @@9
 
MOV EAX,ErrorAddr // patch in our INT3, MOV EDX,[EDX]
SUB EAX,3
CALL Patch
TEST AL,AL // successfully patched ??
JZ @@8 // NO, jump to @@8
MOV EBP,[ESP + 4] // first restore EBP
ADD ESP,16 // remove some stuff
{$IFDEF VER_D6H} // difference D6,D7 because of Kylix PIC changes
POP EBX // we cleanup here the stack from our caller, eg. _assert()
{$ENDIF} // because we don't want to return to it
 
MOV EAX,[ESP] // leave ErrorAddr on Stack as EBP of ExceptFrame
XOR EDX,EDX
SUB EAX,3 // address of our INT 3
 
PUSH OFFSET @@4 // install SEH
PUSH DWord Ptr FS:[EDX]
MOV DWord Ptr FS:[EDX],ESP
 
JMP EAX // jump to patch
 
{ here we have in our SEH = try except block follow executions
 
try -> above install SEH
JMP EAX
@EAX: INT 3 -> raise Exception if NO debuggee present
MOV EDX,[EDX] -> raise Exception anycase, because EDX=ZERO
except -> @@4: SEH Handler
end; -> RET SEH
 
}
 
@@4: MOV EDX,[ESP].TExceptionParams.Frame // our SEH Handler
MOV EAX,[EDX].TExceptionFrame.Next // remove SEH here
MOV FS:[0],EAX
MOV EAX,[EDX].TExceptionFrame.RegEBP // ErrorAddr
MOV EDX,[ESP].TExceptionParams.Context // Context
ADD [EDX].TContext.RegESP,12 // cleanup stack 3 DWords of SEH
MOV [EDX].TContext.RegEIP,EAX // new EIP right after call _Assert()
SUB EAX,5
MOV EDX,[EAX] // hm?, important access to codesegment,
// otherwise Debugger don't work with F8/F7
CALL Unpatch // remove INT3; MOV EDX,[EDX];
SUB EAX,EAX
RET

</code></pre>
&#10

**Hagen Reddmann** · 11.06.2003, 02:42

<pre>

<code> 
DB 'copyright 2003 by Hagen Reddmann, ' //

DB 'idea and basics by Ulrich Gerhardt'
 
@@8: MOV EAX,[ESP] // restore message
PUSH ErrorAddr // delphi's assert handling
CALL OldAssertErrorProc
 
@@9: POP EAX
 
{ How it work
We assign our ChoiceAssertErrorHandler as Assertion Handler.
If an assertion fails this procedure is called. We check here AssertType and if
set we ask the user trough a dialog what should happend.
If AssertType is atDebug the user want to stop the Debuger at the Assert() location
in the sources.
To get this working we patch the code on this Assert() call with INT 3 and MOV EDX,[EDX] and
after successfull patching we jump to this location. The INT 3 let the debugger stop.
If we trace or run (eg. keys F7,F8,F9) then the next instruction, MOV EDX,[EDX] is executed.
BUT, we have setup EDX to ZERO, this means MOV EDX,[EDX] raise an access violation.
Now, in this procedure here we have setup our own SEH=Structured Exception Handler to
grap all exceptions. Means, after execution of the INT 3 and next execution of MOV EDX,[EDX=0]
our SEH Handler is called. Above at label @@4. Then we uninstall our SEH, remove our
patched INT 3, MOV EDX,[EDX] and setup the new EIP=Instruction Pointer, where the OS
continue our Program, to the code right after our CALL to Assert(). Then all
code, stack and important registeres are such as before calling Assert().
With the exception that we have stopped the debuggee on the Assert() location.
But what's happend if we start our program without a Debuggee ??
Then the INT 3 would raise an Breakpoint Exception visible to our installed
Exceptionhandler. Means instead of an Exception raised from MOV EDX,[EDX] we get
an Exception raised by our INT 3. New our SEH is called on Label @@4, such as with
MOV EDX,[EDX=0]. In any case our SEH uninstalls it self, unpatch our INT 3 and
let continue our program right after the failed assertion.
 
One important consideration is the fact that we have to take care with our stack.
First we must cleanup the stack in such a way that the call from System._Assert to
our handler is removed. Means if we returned without our patch then we don't return
to System._Assert(), instead we return to the Assert() of the sourcecode.
 
After the jump to our INT 3 the stack and all important registers, except EAX,EDX,ECX
should be in state as before the call to Assert(). That's the case here.
This means we can fully work with Debugwatches.
}
end;
 
 
initialization
OldAssertErrorProc := AssertErrorProc;
AssertErrorProc := @ChoiceAssertErrorHandler;
finalization
AssertErrorProc := @OldAssertErrorProc;
end.

</code></pre&gt

**Hagen Reddmann** · 11.06.2003, 02:43

Nachfolgende Unit als Komponente ins User Package installieren. Unter Menu\Debugger Optionen\Allgemein kann man �ber die Delphi IDE das Assert-Verhalten einstellen. 

<pre>

<code>unit AssertsIDE;
 
interface
 
implementation
 
uses Windows, Messages, Classes, Controls, StdCtrls, SysUtils, Registry, Forms;
 
// get complier
{$DEFINE VER_???}
 
{$IFDEF VER140} // D6
{$DEFINE VER_D6H}
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER150} // D7
{$DEFINE VER_D6H}
{$UNDEF VER_???}
{$ENDIF}
 
{$IFDEF VER90} // D2
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER100} // D3
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER120} // D4
{$UNDEF VER_???}
{$ENDIF}
{$IFDEF VER130} // D5
{$UNDEF VER_???}
{$ENDIF}
 
 
type
TAssertion = class
class procedure OnClick(Sender: TObject);
class function GetType: Integer;
class procedure SetType(Value: Integer);
end;
 
class procedure TAssertion.OnClick(Sender: TObject);
begin
SetType((Sender as TComboBox).ItemIndex);
end;
 
class function TAssertion.GetType: Integer;
begin
with TRegIniFile.Create('SOFTWARE\Borland') do
try
Result := ReadInteger('Assertion', 'Type', 0);
finally
Free;
end;
end;
 
class procedure TAssertion.SetType(Value: Integer);
begin
with TRegIniFile.Create('SOFTWARE\Borland') do
try
WriteInteger('Assertion', 'Type', Value);
finally
Free;
end;
end;
 
var
Hook: hHook = 0;
 
function MyHook(Code,wParam,lParam: Integer): Integer; stdcall;
var
P,C: TWinControl;
B: TComboBox;
begin
if lParam <> 0 then
with PCWPStruct(lParam)^ do
if message = wm_Create then
begin
P := FindControl(hWnd);
if (P <> nil) and (P.ClassName = 'TDebuggerOptionsPage') then
begin
C := GetParentForm(P);
if (C <> nil) and (C.ClassName = 'TDebuggerOptDialog') then
begin
TComponent(B) := P.FindComponent('AssertionComboBox');
if B = nil then
begin
B := TComboBox.Create(P);
B.Parent := P;
{$IFDEF VER_D6H}
B.Left := 8;
B.Width := P.ClientWidth - 16;
B.Top := P.ClientHeight - 8;
{$ELSE}
B.Left := 4;
B.Width := P.ClientWidth - 8;
B.Top := P.ClientHeight - 25;
{$ENDIF}
B.Style := csDropDownList;
B.Items.Add('Assertionhandling by Delphi, raise EAssertError Exception');
B.Items.Add('ignore Assertion and execute code');
B.Items.Add('Halt on Assertion and stop Application');
B.Items.Add('Debug on Assertion and goto Sourcecode');
B.Items.Add('Ask User on Assertion');
B.ItemIndex := TAssertion.GetType;
B.OnClick := TAssertion.OnClick;
end;
end;
end;
end;
if Code < 0 then Result := 0
else Result := CallNextHookEx(Hook, Code, wParam, lParam);
end;
 
initialization
Hook := SetWindowsHookEx(WH_CALLWNDPROC, MyHook, 0, GetCurrentThreadID);
finalization
UnhookWindowsHookEx(Hook);
end.

</code></pre&gt

**Hagen Reddmann** · 11.06.2003, 02:44

obiger Trick ist schmutzig aber effektiv

**Ulrich Gerhardt** · 11.06.2003, 08:55

Mails sind angekommen. Da hab ich wieder ein P�ckchen durchzuarbeiten. Wie ich sehe, hat sich mein ToolsAPI-Part erledigt, dank deiner Hookerei. Vielleicht bastel ich da trotzdem noch ein wenig, weil mir Hooks suspekt sind. :-) Aber in den Debuggeroptionsdialog krieg ich die Einstellm�glichkeit vermutlich nicht, soweit ein schneller Blick in die ToolsAPI.pas das hergibt.
 Uli.
PS: Wenn man das $D- aus'm Quellcode nimmt, geht das Debuggen um L�ngen besser. :-)
 PPS: Seh ich das richtig, dass du mit den hartcodierten Compileroptionen stabile Verh�ltnisse f�r die Asm-Teile schaffen willst

**Hagen Reddmann** · 11.06.2003, 14:22

Korrekt, es ist sogar notwendig da man ja zur Entwicklungszeit nicht will das man diesen Code per F7/F8 erreicht. Wozu sollte ich jedesmal diesen assembler part debuggern wollen ?? 

Klar, wenn man zur Entwicklungszweit diesen Source entwickeln will, also so wie jetzt, dann mu� man diese Switches ALLE deaktivieren. Besser so, da man dann auch die zus�tzlichen �berpr�fungen wieder aktiviert. 

About ToolsAPI: 
Ich wei� mein Weg ist schmutzig aber echt stabil und nach allen Regeln der Kunst. Es kann also nichts schiefgehen. 
Wie du schon festgestellt hast unterst�tzt das ToolsAPI keine M�glichkeit �hnliches ohne diese Tricks zu erreichen. Desweiteren verspreche ich dir das eine ad�quate ToolsAPI L�sung 5 mal mehr Sourcecode ben�tigt. Da sieht man mal wie eine ungl�ckliche Schnittstelle den Aufwand erh�ht statt zu reduzieren. 
Nat�rlich w�re eine saubere L�sung in jedem Fall vorzuiehen, aber noch mehr Zeit will ich eigentlich nicht in das Projekt investieren. 

Interssant w�re nun noch zu wissen ob der Source auch unter Win9x Systemen funktioniert. 

Gru� Hagen

PS: besser ist es Du besch�ftigst dich mehr mit dem Patchtrick und dem SEH. Dies verstanden zu haben er�ffnet einem enorme neue M�glichkeiten.
Z.b. eigene try except Implementationen die NICHT vom Debugger gesehen werden, sind manchmal sinnvoll. Es gibt n�mlich keine Wege per Programcode den Debuggerprozess zu beeinflussen. Unn�tige Exception k�nnen also damit f�r die Zukunft beseitigt werden OHNE das man auf das Exceptionhandling verzichten mu�. Oder so wie im Code gezeigt ist es m�glich ein Exceptionhandling aufzubauen das �ber proceduren hinweg funktioniert. Es mu� also NICHT immer hart und logisch strukturiert sein.
&#10

Announcement

DebugBreak und Delphi

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment