verzweifle an fließkommazahlen....:-(

[himitsu]

Ich muß wohl wirklich endlich mal den Fehler finden, damit ich mein kleines UCC komlett veröffentlichen kann. -.-''

Na ja, darin hab ich zwar nichts direkt für's Double, aber LargeWord macht's ja och

Delphi-Quellcode:

var 
  pd: PDouble; 
  d: Double; 
  i: integer; 
begin  
  i := FindData(PLargeWord(@d)^, pd, 100000) + 1;

Das Ergebnis der Funktion kann man mit dem von POS vergleichen, nur daß der Index hier bei 0 anfängt.
nichts gefunden: -1
Index der ersten Übereinstimmung: >=0


So und hier noch die entsprechende Funktion:

Delphi-Quellcode:

Function FindData(SerarchWord: LargeWord; Data: Pointer; Count: LongInt): LongInt;
  ASM
    PUSH    EBX
    TEST    &Data, &Data
    JE      @Exit
    TEST    &Count, &Count
    JLE     @Exit
    MOV     ECX, &Count
    MOV     EBX, DWORD PTR [&SerarchWord]
    MOV     EDX, DWORD PTR [&SerarchWord + 4]
    JMP     @InLoop

    @Loop:
    ADD     &Data, 8
    DEC     ECX
    JECXZ   @Exit
    @InLoop:
    CMP     EBX, [&Data]
    JNE     @Loop
    CMP     EDX, [&Data + 4]
    JNE     @Loop
    POP     EDX
    SUB     EAX, EDX
    SHR     EAX, 3
    POP     EBX
    POP     EBP
    RET

    @Exit:
    MOV     EAX, -1
    POP     EBX
  End;

Falls nötig, dann kann LargeWord auch in Int64 geändert werden.

Und wenn es jemanden interessiert, folgendes stünde och noch zur Verfügung.

Delphi-Quellcode:

Function FindData(SerarchWord: Byte;      Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: Word;      Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: LongWord;  Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: LargeWord; Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: ShortInt;  Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: SmallInt;  Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: LongInt;   Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchWord: LargeInt;  Data: Pointer; Count: LongInt): LongInt; Overload;
Function FindData(SerarchData: Pointer;   Data: Pointer; Count: LongInt; ElementSize: LongInt): LongInt; Overload;

PosEx wird es nicht vorläufig nicht geben, da dieses ja eigentlich nicht benötigt wird:

Code:

i := FindData(PLargeWord(@d)^, pd [color=#ff0000]+ Offset[/color], 100000 [color=#ff0000]- Offset[/color]) + 1;

[DJ_Tom]

Code:

Function FindData(SerarchWord: LargeWord; Data: Pointer; Count: LongInt): LongInt;

also verstehe ich das jetzt richtig das is ne funktion mit der ich prüfen kann ob ein largeword in dem pointer x enthalten ist?! und der rückgabewert sagt mir wo ich das im pointer finde???

aber das is noch nicht direkt zum durchsuchen von speicherbereichen von ext. programmen gedacht?

also das was ich hier z.b. machen will:

Code:

readprocessmemory(HandleWindow, ptr($FFFFF),@buffer, sizeof(buffer), bytesread);

[himitsu]

Richtig erkannt.
Und da man dieser Funktion ja jeden beliebigen Pointer übergeben kann, ist es auch dafür verwendbar, es muß nur ein Lesezugrif auf den entsprechenden Speicherbereich möglich sein.

Außerdem holst du dir ja mit ReadProcessMemory eine Kopie des Speichers, der anderen Anwendung, in dein eigenes Programm und greifst dann auf diese Kopie (Buffer) zu.

Delphi-Quellcode:

ReadProcessMemory(HandleWindow, Ptr($FFFFF), @Buffer, SizeOf(buffer), BytesRead);
i := FindData(PLargeWord(@d)^, @Buffer, BytesRead div 8);

[DJ_Tom]

hmmm ja aber das hieße ich müßte um einen kompletten bereich durchzugehen folgendes machen:

Code:

var buffer:double;
...

     a:=$FFFFFF;
     repeat
           ReadProcessMemory(HandleWindow, Ptr($a), @Buffer, SizeOf(buffer), BytesRead);
           i := FindData(PLargeWord(@d)^, @Buffer, BytesRead div 8);

           if i > -1 then
           begin
               //gefunden
           end;

           inc(a);
     until a = $FFFFFFF;

aber das dauert doch ewig um die range durchzugehen....

kann man das nicht irgendwie optimieren

[himitsu]

Im Grunde nicht, aber du holst dir ja jedesmal nur 8 Byte ab.
Was dann diesem Code entsprechen täte :zwinker:

Delphi-Quellcode:

var buffer:double; 
... 

     a:=$FFFFFF; 
     repeat 
           ReadProcessMemory(HandleWindow, Ptr($a), @Buffer, SizeOf(buffer), BytesRead); 

           if d = buffer then 
           begin 
               //gefunden 
           end; 

           inc(a, 8); 
     until a = $FFFFFFF;

Versuch es mal damit:

Code:

[color=#ff0000]var buffer: packed Array[0..131071] of double;[/color] // 131072 * 8 = 1 MB
... 

     a:=$FFFFFF; 
     repeat 
           ReadProcessMemory(HandleWindow, Ptr($a), @Buffer, SizeOf(buffer), BytesRead); 
           i := FindData(PLargeWord(@d)^, @Buffer, BytesRead div 8); 

           if i > -1 then 
           begin 
               //gefunden 
           end; 

           inc(a, SizeOf(buffer)); 
     until a = $FFFFFFF;

[DJ_Tom]

wenn ich das so nehme meckert er schon beim PLargeWord das würde er net kennen...ändere ich das auf pint64 z.b. funzt es nicht...

[himitsu]

Na ja, das Problem ist ja, daß es LargeWord nicht in jeder Delphi-Version gibt und wenn doch, dann meist unter 'nem anderem Namen -.-''
Und in meinem UCC hab ich dann die ganzen Typen vom Namen her auf ein einheitliches System gebracht. (daher gibt's halt abundzu mal kleine Problemchen, wenn ich daraus etwas exportiere)

Hier also mal meine Definitionen für den Unsigned 64 Bit-Integer:

Delphi-Quellcode:

Type
  LargeWord  = {$IFDEF DELPHI_6_UP} System.UInt64 {$ELSE} Type System.Int64 {$ENDIF};
  PLargeWord = ^LargeWord;

Und mit dem Incementieren hast'e natürlich Recht da muß dann natürlich zum nächsten "Block" gesprungen werden. (hab meinen letzen Beitrag entsprechend geändert)

[DJ_Tom]

hmmm jetzt hab ich das problem das er am ende deiner funktion mit ner zugriffsverletzung raus geht....

[himitsu]

hmmm, hatte bisher noch keine Probleme damit.

Aber wann und wo kommt den welche Fehlermeldung?

[DJ_Tom]

also sobald er die funktion das erste mal durchläuft, wobei bytesread=0 ist...

ASM
PUSH EBX
TEST &Data, &Data
JE @Exit
TEST &Count, &Count
=> JLE @Exit

bis dahin läuft er


dann gehts zum exit

@Exit:
=> POP &Data
MOV EAX, -1
POP EBX
end;

und dann kommt:

"Zugriffsverletzung bei 0x6b88a780: Lesen von Adresse 0x6b88a780" Prozeß angehalten.

wenn ich dann von hand weiter gehe im debugger kommt irgendwann die fehlermeldung anbei...