LastPos Varianten

[Amateurprofi]

Oder noch mal deutlich schneller so:
(Nicht wirklich optimiert und nur flüchtig überprüft)

Delphi-Quellcode:

FUNCTION LastPosA(const SearchFor,SearchIn:AnsiString):integer;
asm
               test     eax,eax
               je       @Ret
               test     edx,edx
               je       @ReturnZero
               cmp      eax,edx
               je       @ReturnOne              // Strings identisch
               push     ebp
               push     ebx
               push     edi
               push     esi
               mov      ecx,[eax-4]             // Length(SearchFor)
               mov      ebp,[edx-4]             // Length(SearchIn)
               sub      ebp,ecx
               js       @Fail                   // SearchFor länger als Searchin
               mov      bl,[eax]                // erstes Zeichen aus SearchFor
               sub      ecx,1
               je       @CharLoop
               lea      eax,[eax+ecx+1]         // hinter SearchFor
               neg      ecx
@OuterLoop:    cmp      [edx+ebp],bl
               je       @FirstFound
@NextOuter:    sub      ebp,1
               jns      @OuterLoop
               jmp      @Fail
@FirstFound:   lea      edi,[edx+ebp+1]
               sub      edi,ecx
               mov      esi,ecx
@InnerLoop:    mov      bh,[eax+esi]
               cmp      bh,[edi+esi]
               jne      @NextOuter
               add      esi,1
               jne      @InnerLoop
               jmp      @Found
@CharLoop:     cmp      [edx+ebp],bl
               je       @Found
               sub      ebp,1
               jns      @CharLoop
@Fail:         xor      eax,eax
               jmp      @End
@ReturnZero:   xor      eax,eax
               jmp      @Ret
@ReturnOne:    mov      eax,1
               jmp      @Ret
@Found:        lea      eax,[ebp+1]
@End:          pop      esi
               pop      edi
               pop      ebx
               pop      ebp
@Ret:
end;

[relocate]

@Bjoerk

Ich kann zwar etwas Assembler, aber um so eine Funktion zu entwickeln/verbessern reicht es kaum.
Die Delphi Variante von dir ist auf meinem AMD aber langsamer als die Assembler Variante, auf einem Intelprozessor (aber kein P4) ist sie schneller.

@Amateurprofi
Diese Variante ist wirklich fix, die schnellste auf meinem Intel und AMD Rechner.

Vielen Dank!

Es ist echt erstaunlich manchmal.