Announcement

**Hagen Reddmann** · 07.06.2003, 14:06

<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
TAssertionBehaviour = (abIgnore, abHalt, abDebug, abUserChoice, abDelphi);
 
procedure InitChoiceAssert(Behaviour: TAssertionBehaviour);
procedure DoneChoiceAssert;
 
implementation
 
uses
Windows, SysConst, SysUtils;
 
type
TAssertErrorProc = procedure(const Message, FileName: String; LineNumber: Integer; ErrorAddr: Pointer);
 
var
AssertionBehaviour: TAssertionBehaviour;
OldAssertErrorProc: TAssertErrorProc;
 
function GetUserChoice(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer): TAssertionBehaviour;
const
cNewLine = #13#10;
cUserChoiceMsg = '%s' + cNewLine +
'(%s, Zeile %d, Adresse $%x)' + cNewLine +
cNewLine +
'Wollen Sie die Anwendung beenden ("Abbrechen&quot

,' + cNewLine +
'debuggen ("Wiederholen&quot

oder die Assertion ignorieren?';
var
Choice: Integer;
S: string;
begin
S := Format(cUserChoiceMsg,
[Message, Filename, LineNumber, Pred(Integer(ErrorAddr))]);
Choice := Windows.MessageBox(GetForegroundWindow, PChar(S), PChar(SAssertionFailed),
MB_ABORTRETRYIGNORE or MB_ICONERROR);
case Choice of
IDABORT:
Result := abHalt;
IDRETRY:
Result := abDebug;
else //IDIGNORE:
Result := abIgnore;
end;
end;
 
function AssertAddr: PChar;
asm // get address of _Assert in System.pas
MOV EAX,OFFSET System.@Assert
end;
 
procedure Patch(Addr: PChar);
type // patch at Addr to INT 3; CALL EDX
PBreakpoint = ^TBreakpoint;
TBreakpoint = packed record
INT3: Byte;
CALL_EDX: Word;
end;
var
Protect: DWord;
begin
if VirtualProtect(Addr, SizeOf(TBreakpoint), PAGE_READWRITE, @Protect) then
begin
PBreakpoint(Addr).INT3 := $CC;
PBreakpoint(Addr).CALL_EDX := $D2FF;
VirtualProtect(Addr, SizeOf(TBreakpoint), Protect, nil);
FlushInstructionCache(GetCurrentProcess, Addr, SizeOf(TBreakpoint));
end;
end;
 
procedure Unpatch(Addr: PChar);
type // patch at Addr CALL _Assert, we restore so above patch
PCall = ^TCall;
TCall = packed record
OpCode: Byte;
Offset: Integer;
end;
var
Protect: DWord;
begin
if VirtualProtect(Addr, SizeOf(TCall), PAGE_READWRITE, @Protect) then
begin
PCall(Addr).OpCode := $E8;
PCall(Addr).Offset := AssertAddr - Addr - SizeOf(TCall);
VirtualProtect(Addr, SizeOf(TCall), Protect, nil);
FlushInstructionCache(GetCurrentProcess, Addr, SizeOf(TCall));
end;
end;

</code></pre>
&#10

**Hagen Reddmann** · 07.06.2003, 14:07

<pre>

<code> 
procedure ChoiceAssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
asm
PUSH EBX // save EBX
CMP AssertionBehaviour,abUserChoice
MOV BL,AssertionBehaviour // set BL to default behavior
JNZ @@1 // AssertBehavior <> abUserChoice ??
 
PUSH ErrorAddr // NO, ask user
CALL GetUserChoice
MOV BL,AL // set BL to users choice behavior
 
@@1: CMP BL,abHalt
JNZ @@2 // behavior <> abHalt ??
MOV EAX,666 // NO, then FatalExist(666)
CALL FatalExit
JMP @@9 // jmp to restore stack, but never called normaly
 
@@2: CMP BL,abDelphi // behavior <> abDelphi ??
JNZ @@3
PUSH ErrorAddr // NO, delphi's assertion handling
CALL OldAssertErrorProc
JMP @@9
 
@@3: CMP AL,abDebug // behavior <> abDebug ??
JNZ @@9
POP EBX // NO, the take a breakpoint
POP EBP // first restore EBX and EBP
POP EAX // remove returnaddress to System._Assert
POP EAX // get two time address of our assertion in source
POP EAX // this address points right after CALL System._Assert
SUB EAX,3 // subtract 3 bytes where we patch in INT 3, CALL EDX
PUSH EAX // save EAX = patch address
CALL Patch // patch in INT 3, CALL EDX
POP EAX // restore address in EAX
MOV EDX,OFFSET @@8 // setup EDX to @@8
JMP EAX // jump to INT 3, CALL EDX right after out assertion in sourcecode
@@8: SUB EAX,2 // subtract 2 from patch address, we need 5 bytes space for restauration to CALL System._Assert
CALL Unpatch // restore original code
POP EAX // get returnaddress from our CALL EDX, points now after Assert() in Sourcecode
JMP EAX // jump to it
 
@@9: POP EBX // restore EBX, and let cleanup the compiler
 
{ Remarks:
To let the Delphi debugger do the work properly we MUST working with jumps to absolute addresses.
In such a way as above.
Tricks with RET or equals don't work properly, the debugger don't steps trough the following
sourcecode right after our assertion.
}
end;
 
procedure InitChoiceAssert(Behaviour: TAssertionBehaviour);
begin
AssertionBehaviour := Behaviour;
TAssertErrorProc(AssertErrorProc) := ChoiceAssertErrorHandler;
end;
 
procedure DoneChoiceAssert;
begin
TAssertErrorProc(AssertErrorProc) := OldAssertErrorProc;
end;
 
 
initialization
OldAssertErrorProc := AssertErrorProc;
finalization
DoneChoiceAssert;
end.

</code></pre&gt

**Hagen Reddmann** · 07.06.2003, 14:13

Hi Ulrich

Obiger Code arbeitet so wie du es dir vorstellst. Jetzt solltest Du ihn noch ausf�hrlich einem H�rtetest unterziehen. D.h. ob alle lokalen Variablen auch im Watch korrekt angezeigt werden, ob der Code auch mit verschachtelten Procedure funtioniert usw. usw. 

Der Code geht von Deiner Grundidee aus, h�lt aber wenn abDebug gew�hlt wird im Sourcecode genau �ber der fehlgeschlagenen Assertion() an. Mit F8,F7 usw. kann dann so als w�re ein Breakpoint im Source gesetzt weiterdebuggt werden. 

Der von mir benutzte Trick patch, also modifiziert den Code der Anwendung. So da� ein Breakpoint = INT3 an die Stelle wo der Aufruf zur Assert() Routine erfolgt, eingef�gt wird. Gleich nach diesem Breakpoint wird ein CALL zur�ck in unseren Code durchgef�hrt damit dieser Patch wieder entfernt wird. 
Beim Debugging per F7,F8 usw. merkt man davon nichts, selbst der CPU View, wenn einmal offen, zeigt unseren Patch nicht an. 
Die Compilerschalter gleich nach Unit Asserts sind wichtig. Ansonsten w�rdest du mit dem Debugger st�ndig in unseren Code springen.

Gru� Hagen

PS: achso, ich habe ihn nat�rlich NUR unter D5 entwickelt und getestet. Man mu� also unbedingt auch noch die anderen Delphi Versionen austesten

**Hagen Reddmann** · 07.06.2003, 14:27

Eines noch, falls der unwahrscheinliche Fall eintritt das VirtualProtect() in Patch() nicht funktionieren sollte, so sollte man eine Exception ausl�sen. Anderenfalls springt der Code an eine Codeadresse mitten in einen OpCode rein und l�sst eine Exception aus. Noch besser ist es sogar wenn Patch mit einem Resultat zur�ckkehrt, und falls nicht gepatcht werden konnte die procedure ChoiceAssertErrorHandler() eine Alternative w�hlt, zb. die EAssertitionError Exception ausl�sst. 

Gru� Hagen

PS: ich hoffe du verzeihst mir meine Tippfehler in den Remarks

**Hagen Reddmann** · 07.06.2003, 14:35

Oh mann, es nimmt kein Ende. 
Also, wenn man den Code startet OHNE integrierten Debugger dann und denoch den Breakpoint setzten l�sst, so kommt wie erwartet einen Externe Exception mit Fehlercode $80000003. Dies ist absolut korrekt da diese Exception die Breakpoint Exception ist. 
Aber, da diese Exception unbehandelt ist durch unserer Anwendung wir bei einem erneuten Test der gleichen Funktion der Anwendungsstack zerst�rt. Es entsteht eine Zugriffsverletzung. 

So, die m�gliche L�sung liegt auf der Hand. Entweder
<li>detektieren ob die Anwendung im Debugger gestartet wurde, oder
<li>eine Exceptionframe in ChoiceAssertErrorHandler() einrichten.

Bei der zweiten M�glichkeit f�ngt also die Anwendung selber diese Breakpointexception ab, falls KEIN Debugger dies tut. 

Ich mu� das mal testen.

Gru� Hage

**Hagen Reddmann** · 07.06.2003, 15:54

<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
TAssertionBehaviour = (abDelphi, abIgnore, abHalt, abDebug, abUserChoice);
 
procedure InitChoiceAssert(Behaviour: TAssertionBehaviour = abDelphi);
 
implementation
 
uses
Windows, SysConst, SysUtils;
 
type
TAssertErrorProc = procedure(const Message, FileName: String; LineNumber: Integer; ErrorAddr: Pointer);
 
var
AssertionBehaviour: TAssertionBehaviour;
OldAssertErrorProc: TAssertErrorProc;
 
function GetUserChoice(const Message, Filename: String; LineNumber: Integer; ErrorAddr: Pointer): TAssertionBehaviour;
const
cUserChoiceMsg = '%s'#13#10'(%s, Zeile %d, Adresse $%x)'#13#10#13#10 +
'Wollen Sie die Anwendung beenden ("Abbrechen&quot

, ' +
'debuggen ("Wiederholen&quot

oder die Assertion ignorieren?';
var
S: String;
begin
S := Format(cUserChoiceMsg, [Message, Filename, LineNumber, Pred(Integer(ErrorAddr))]);
case Windows.MessageBox(GetForegroundWindow, PChar(S), PChar(sAssertionFailed),
MB_ABORTRETRYIGNORE or MB_ICONERROR) of
IDABORT: Result := abHalt;
IDRETRY: Result := abDebug;
else
Result := abIgnore;
end;
end;
 
function Patch(Addr: PChar): Boolean;
// patch at Addr to INT 3; CALL EDX
// if not possible the return FALSE, otherwise TRUE
type
PBreakpoint = ^TBreakpoint;
TBreakpoint = packed record
INT3: Byte;
CALL_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).CALL_EDX := $D2FF;
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;

</code></pre&gt

**Hagen Reddmann** · 07.06.2003, 15:55

<pre>

<code>procedure RaiseAssert(Addr: Pointer);
// Called whenever we working without debugger and another exception
// instead of a breakpoint exception was raised.
// This procedure MUST raise a Exception to leave the actual assertion procedure.
// Addr points to our Assertition.
begin
OldAssertErrorProc('Asserthandler', 'Asserts.pas', 0, Addr);
end;
 
procedure ChoiceAssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
asm
PUSH EBX // save EBX
MOV BL,AssertionBehaviour // set BL to default behaviour
CMP BL,abUserChoice
JNZ @@1 // AssertionBehavior <> abUserChoice ??
 
PUSH ErrorAddr // NO, ask user
CALL GetUserChoice
MOV BL,AL // set BL to users choice
 
@@1: CMP BL,abHalt
JNZ @@2 // behaviour <> abHalt ??
MOV EAX,666 // NO, then FatalExist(666)
CALL FatalExit
JMP @@9 // jmp to restore stack, but never called normaly
 
@@2: CMP BL,abDelphi // behaviour == abDelphi ??
JZ @@8
 
@@3: CMP BL,abDebug // behaviour <> abDebug ??
JNZ @@9
 
PUSH EAX // save Message
MOV EAX,ErrorAddr // patch in our INT3, CALL EDX
SUB EAX,3
CALL Patch
TEST AL,AL // successfully patched ??
POP EAX
JZ @@8 // NO, jump to @@6
 
POP EBX // first restore EBX and EBP
POP EBP
POP EAX // remove returnaddress to System._Assert
POP EAX // pop two times address of our assertion in source
POP EAX // this address points right after CALL System._Assert
 
MOV EDX,OFFSET @@4 // setup EDX to @@8
SUB EAX,3 // subtract 3 bytes where we patch in INT 3, CALL EDX
 
PUSH OFFSET @@6 // install exceptionframe, to take care of
PUSH DWord Ptr FS:[0] // unhandled breakpoint exception
MOV DWord Ptr FS:[0],ESP
 
JMP EAX // jump to INT 3, CALL EDX right after out assertion in sourcecode
 
@@4: SUB EAX,2 // subtract 2 from patch address, we need 5 bytes space for restauration to CALL System._Assert
CALL Unpatch // restore original code
POP EAX // get returnaddress from our CALL EDX, points now after Assert() in Sourcecode
 
POP DWord Ptr FS:[0] // remove SEH
ADD ESP,4
 
JMP EAX // jump to following code address
 
@@5: SUB EAX,2 // called everytime where our exceptionframe has
CALL Unpatch // handled another exception instead of breakpoints
POP EAX
 
POP DWord Ptr FS:[0] // remove SEH
ADD ESP,4
 
JMP RaiseAssert // reraise specific exception
 
@@6: MOV EAX,[ESP + 004h]

**Hagen Reddmann** · 07.06.2003, 15:55

<pre>

<code>procedure RaiseAssert(Addr: Pointer);
// Called whenever we working without debugger and another exception
// instead of a breakpoint exception was raised.
// This procedure MUST raise a Exception to leave the actual assertion procedure.
// Addr points to our Assertition.
begin
OldAssertErrorProc('Asserthandler', 'Asserts.pas', 0, Addr);
end;
 
procedure ChoiceAssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
asm
PUSH EBX // save EBX
MOV BL,AssertionBehaviour // set BL to default behaviour
CMP BL,abUserChoice
JNZ @@1 // AssertionBehavior <> abUserChoice ??
 
PUSH ErrorAddr // NO, ask user
CALL GetUserChoice
MOV BL,AL // set BL to users choice
 
@@1: CMP BL,abHalt
JNZ @@2 // behaviour <> abHalt ??
MOV EAX,666 // NO, then FatalExist(666)
CALL FatalExit
JMP @@9 // jmp to restore stack, but never called normaly
 
@@2: CMP BL,abDelphi // behaviour == abDelphi ??
JZ @@8
 
@@3: CMP BL,abDebug // behaviour <> abDebug ??
JNZ @@9
 
PUSH EAX // save Message
MOV EAX,ErrorAddr // patch in our INT3, CALL EDX
SUB EAX,3
CALL Patch
TEST AL,AL // successfully patched ??
POP EAX
JZ @@8 // NO, jump to @@6
 
POP EBX // first restore EBX and EBP
POP EBP
POP EAX // remove returnaddress to System._Assert
POP EAX // pop two times address of our assertion in source
POP EAX // this address points right after CALL System._Assert
 
MOV EDX,OFFSET @@4 // setup EDX to @@8
SUB EAX,3 // subtract 3 bytes where we patch in INT 3, CALL EDX
 
PUSH OFFSET @@6 // install exceptionframe, to take care of
PUSH DWord Ptr FS:[0] // unhandled breakpoint exception
MOV DWord Ptr FS:[0],ESP
 
JMP EAX // jump to INT 3, CALL EDX right after out assertion in sourcecode
 
@@4: SUB EAX,2 // subtract 2 from patch address, we need 5 bytes space for restauration to CALL System._Assert
CALL Unpatch // restore original code
POP EAX // get returnaddress from our CALL EDX, points now after Assert() in Sourcecode
 
POP DWord Ptr FS:[0] // remove SEH
ADD ESP,4
 
JMP EAX // jump to following code address
 
@@5: SUB EAX,2 // called everytime where our exceptionframe has
CALL Unpatch // handled another exception instead of breakpoints
POP EAX
 
POP DWord Ptr FS:[0] // remove SEH
ADD ESP,4
 
JMP RaiseAssert // reraise specific exception
 
@@6: MOV EAX,[ESP + 004h]

**Hagen Reddmann** · 07.06.2003, 15:56

<pre>

<code>procedure RaiseAssert(Addr: Pointer);
// Called whenever we working without debugger and another exception
// instead of a breakpoint exception was raised.
// This procedure MUST raise a Exception to leave the actual assertion procedure.
// Addr points to our Assertition.
begin
OldAssertErrorProc('Asserthandler', 'Asserts.pas', 0, Addr);
end;
 

</code></pre&gt

**Hagen Reddmann** · 07.06.2003, 15:57

<pre>

<code>procedure RaiseAssert(Addr: Pointer);
// Called whenever we working without debugger and another exception
// instead of a breakpoint exception was raised.
// This procedure MUST raise a Exception to leave the actual assertion procedure.
// Addr points to our Assertition.
begin
OldAssertErrorProc('Asserthandler', 'Asserts.pas', 0, Addr);
end;
 

</code></pre&gt

**Hagen Reddmann** · 07.06.2003, 15:58

<pre>

<code>procedure ChoiceAssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
asm
PUSH EBX // save EBX
MOV BL,AssertionBehaviour // set BL to default behaviour
CMP BL,abUserChoice
JNZ @@1 // AssertionBehavior <> abUserChoice ??
 
PUSH ErrorAddr // NO, ask user
CALL GetUserChoice
MOV BL,AL // set BL to users choice
 
@@1: CMP BL,abHalt
JNZ @@2 // behaviour <> abHalt ??
MOV EAX,666 // NO, then FatalExist(666)
CALL FatalExit
JMP @@9 // jmp to restore stack, but never called normaly
 
@@2: CMP BL,abDelphi // behaviour == abDelphi ??
JZ @@8
 
@@3: CMP BL,abDebug // behaviour <> abDebug ??
JNZ @@9
 
PUSH EAX // save Message
MOV EAX,ErrorAddr // patch in our INT3, CALL EDX
SUB EAX,3
CALL Patch
TEST AL,AL // successfully patched ??
POP EAX
JZ @@8 // NO, jump to @@6
 
POP EBX // first restore EBX and EBP
POP EBP
POP EAX // remove returnaddress to System._Assert
POP EAX // pop two times address of our assertion in source
POP EAX // this address points right after CALL System._Assert
 
MOV EDX,OFFSET @@4 // setup EDX to @@8
SUB EAX,3 // subtract 3 bytes where we patch in INT 3, CALL EDX
 
PUSH OFFSET @@6 // install exceptionframe, to take care of
PUSH DWord Ptr FS:[0] // unhandled breakpoint exception
MOV DWord Ptr FS:[0],ESP
 
JMP EAX // jump to INT 3, CALL EDX right after out assertion in sourcecode
 
@@4: SUB EAX,2 // subtract 2 from patch address, we need 5 bytes space for restauration to CALL System._Assert
CALL Unpatch // restore original code
POP EAX // get returnaddress from our CALL EDX, points now after Assert() in Sourcecode
 
POP DWord Ptr FS:[0] // remove SEH
ADD ESP,4
 
JMP EAX // jump to following code address
 
@@5: SUB EAX,2 // called everytime where our exceptionframe has
CALL Unpatch // handled another exception instead of breakpoints
POP EAX
 
POP DWord Ptr FS:[0] // remove SEH
ADD ESP,4
 
JMP RaiseAssert // reraise specific exception

</code></pre>
&#10

**Hagen Reddmann** · 07.06.2003, 15:59

<pre>

<code> 
@@6: MOV EAX,[ESP + 004h] // our Exceptionhandler, we known now NO debugger is present (small hint to Antidebgging tricks

CMP DWord Ptr [EAX],080000003h // ExceptionCode = $80000003, eg. it is a Breakpoint ??
MOV EAX,[ESP + 00Ch] // load thread context
JZ @@7
MOV DWord Ptr [EAX + 0A8h],OFFSET @@5 // set EDX to @@5 because not a breakpoint exception was raised
@@7: INC DWord Ptr [EAX + 0B8h] // context.eip +1, skip INT3 to CALL EDX
SUB EAX,EAX // 0 = continue_exception_frame
RET
 
DB 'copyright 2003 by Hagen Reddmann, ' //

DB 'idea and basics by Ulrich Gerhardt'
 
@@8: PUSH ErrorAddr // delphi's assert handling
CALL OldAssertErrorProc
 
@@9: POP EBX // restore EBX, and let cleanup the compiler
 
{ Remarks:
To let the Delphi debugger do the work properly we MUST working with jumps to absolute addresses.
In such a way as above.
Tricks with RET or equals don't work properly, the debugger don't steps trough the following
sourcecode right after our assertion.
We have to take care to handle the stack correct and to use only registers EAX,EDX,ECX.
These three registers are preserved trough compiler for the assertions.
}
end;
 
procedure InitChoiceAssert(Behaviour: TAssertionBehaviour);
begin
AssertionBehaviour := Behaviour;
if Behaviour <> abDelphi then TAssertErrorProc(AssertErrorProc) := ChoiceAssertErrorHandler
else TAssertErrorProc(AssertErrorProc) := OldAssertErrorProc;
end;
 
initialization
OldAssertErrorProc := AssertErrorProc;
finalization
InitChoiceAssert;
end.

</code></pre&gt

**Hagen Reddmann** · 07.06.2003, 16:00

Oh mann, m�hsam n�hrt sich das Eichh�rnchen beim Posten

Also, obiger Code arbeitet nun einwandfrei. Ich habe noch das Exceptionhandling eingebaut, falls eben kein Debugger present ist. 

Geile Entspannung, das

Gru� Hagen

�brigens, bevor jemand mich korregiert wegen der Aussage das der Exceptionhandler auf Ring0 l�uft. Dies ist nat�rlich falsch. Ich habe da was mit einer "speziellen Methode" der Programmierung verwechselt :

**Hagen Reddmann** · 07.06.2003, 16:31

F�r alle die den Postings nicht so richtig folgen k�nnen. 

Obiger Source installiert einen eigenen Assertition Handler. Normalerweise wird durch den Delphi Assertition handler eine EAssertitionError Esxception ausgel�sst falls die Assertition nicht zutirfft. Angezeigt werden dann der Dateiename und die Position im Quelltext. 

Die Idee von Ulrich war nun das bei der Entwicklung keine Exception ausgel�sst wird sondern das der Debugger der IDE an der Quelltextposition in der die Asertition gemacht wurde stehen bleibt. So als ob man einen Breakpoint gesetzt hat. 

Mit obigem Source ist dies nun m�glich. Dadurch kann man jetzt im Debug-Watch, �berwachte Ausdr�cke, auch alle seine Variablen abchecken. 

Zudem kann man diesen Handler so aktivieren das er den Programmierer fragt was passieren soll. Entweder wird die Anwendung beendet, oder der Debugger an die Assertition herrangef�hrt oder aber der Fehler einfach ignoriert. Das Program l�uft dann so weiter als w�re nichts gewesen. 

Als kleines Beispiel:
<pre>

var
I: Integer;
begin
InitChoiceAssert(abUserChoice); 

I := 1;
Assert(I = 0, 'I <> 0');
Inc(I, I);
if I <> 0 then ;
end; 

</pre>

Ein weiterer Vorteil ist das man dises Verhalten per Program direkt beeinflussen kann. 

Also insgesamt eine sehr sinnvolle Sache. 

Gru� Hagen

PS: wer's testen will, bitte nicht vergessen in den Compileroptionen die Assertitions anzuchecken.<br&gt

**Hagen Reddmann** · 07.06.2003, 16:47

Und noch eins drauf

Kopiert folgenden Code in die Source:

<pre>

<code>procedure Debug(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
var
S: String;
begin
S := Format('Assert %s: %s at line %d on address $%p', [Message, FileName, LineNumber, ErrorAddr]);
OutputDebugString(PChar(S));
end;
 
procedure ChoiceAssertErrorHandler(const Message, Filename: string; LineNumber: Integer; ErrorAddr: Pointer);
asm
PUSH EAX
PUSH EDX
PUSH ECX
PUSH ErrorAddr
CALL Debug
POP ECX
POP EDX
POP EAX
 
PUSH EBX // save EBX
MOV BL,AssertionBehaviour // set BL to default behaviour
CMP BL,abUserChoice
JNZ @@1 // AssertionBehavior <> abUserChoice ??

</code></pre>

Nun wird im Debugger Ereignisprotokoll sogar noch diese Assertion mitprotokolliert.

Gru� Hage

Announcement

DebugBreak und Delphi

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment