#Heap_Zero_Memory = $8
Procedure.l PbHeap()
  !MOV Eax, dword [_PB_MemoryBase]
  ProcedureReturn
EndProcedure

;Speichert einen neuen String
;String.s [in] : Neuer String
;RETURN : Handle zum String
Procedure.l mNewString(*String)
  Protected hString.l, sString.l, pString.l
  sString = LStrLen_(*String) + 1
  hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString)
  CopyMemory(@String, hString, sString)
  ProcedureReturn hString
EndProcedure

;Reserviert einen String mit einer bestimmten Länge
;Length.l [in] : Länge des zu reservierenden Strings
;RETURN : Handle zum reservierten String
Procedure.l mReserveString(Length.l)
  Protected hString.l
  hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
  ProcedureReturn hString
EndProcedure

;Ändert einen String
;hString.l [in] : Handle zum ursprünglichen String
;String.s [in] : String
;RETURN : Handle zum String (kann sich ändern)
Procedure.l mChangeString(hString.l, *String)
  Protected sString.l
  sString = LStrLen_(*String) + 1
  shString = HeapSize_(PbHeap(), 0, hString)
  If sString < shString
    hString = HeapReAlloc_(PbHeap(), hString, sString, 0)
  ElseIf sString > shString
    GlobalFree_(hString)
    hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString)
  EndIf
  CopyMemory(@String, hString, sString)
  ProcedureReturn hString
EndProcedure

;Kopiert einen String in den anderen
;hString1.l [in] : Handle zum Quellstring
;hString2.l [in] : Handle zum Zielstring
;RETURN : Handle zum Zielstring
Procedure.l mCopyString(hString1.l, hString2.l)
  Protected sString1.l, sString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  If sString1 < sString2
    hString2 = HeapReAlloc_(PbHeap(), 0, hString2, sString1)
  ElseIf sString1 > sString2
    HeapFree_(PbHeap(), 0, hString2)
    hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString1)
  EndIf
  CopyMemory(hString1, hString2, sString1)
  ProcedureReturn hString2
EndProcedure

;Kopiert einen String in einen neuen
;hString1.l [in] : Handle zum Quellstring
;RETURN : Handle zum kopierten String
Procedure mCopyStringEx(hString1.l)
  Protected sString1.l, hString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString1)
  CopyMemory(hString1, hString2, sString1 - 1)
  ProcedureReturn hString2
EndProcedure

;Gibt einen String und den Speicher wieder frei
;hString.l [in] : Handle zum String
;RETURN : #NULL, wenn der String erfolgreich gelöscht wurde
Procedure.l mFreeString(hString.l)
  ProcedureReturn HeapFree_(PbHeap(), 0, hString)
EndProcedure

;Gibt den im Speicher befindlichen String zurück
;hString.l [in] : Handle zum String
;RETURN : String
Procedure.s mValueString(hString.l)
  Protected String.s
  If hString
    String = PeekS(hString)
    ProcedureReturn String
  Else
    ProcedureReturn ""
  EndIf
EndProcedure

;Fügt zwei Strings zu einem neuen String zusammen
;hString1.l [in] : Handle zum ersten String
;hString2.l [in] : Handle zum zweiten String
;RETURN : Handle zum neuen String
Procedure.l mAddString(hString1.l, hString2.l)
  Protected sString1.l, sString2.l, hString.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString1 + sString2 - 1)
  CopyMemory(hString1, hString, sString1 - 1)
  CopyMemory(hString2, hString + sString1 - 1, sString2)
  ProcedureReturn hString
EndProcedure

;Fügt den zweiten String an den ersten String
;hString1.l [in] : Handle zum ersten String
;hString2.l [in] : Handle zum zweiten String
;RETURN : Handle zum ersten String (changed)
Procedure.l mAddStringEx(hString1.l, hString2.l)
  Protected sString1.l, sString2.l, hString.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString1 + sString2 - 1)
  CopyMemory(hString1, hString, sString1 - 1)
  CopyMemory(hString2, hString + sString1 - 1, sString2)
  HeapFree_(PbHeap(), 0, hString1)
  ProcedureReturn hString
EndProcedure

;Vergleicht zwei Strings miteinander
;hString1.l [in] : Handle zum ersten String
;hString2.l [in] : Handle zum zweiten String
;RETURN : 0 = ungleich, 1 = gleich
Procedure.l mCompareString(hString1.l, hString2.l)
  Protected sString1.l, sString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  If sString1 = sString2
    ProcedureReturn CompareMemory(hString1, hString2, sString1)
  Else
    ProcedureReturn 0
  EndIf
EndProcedure

;Um einen Speicherbereich nach einem Byte zu durchsuchen von Stefan Moebius (dt. Forum)
Procedure FindByte(*Address, Laenge, Byte.b)
  !CLD
  !MOV Edi, [Esp]
  !MOV AL, [Esp + 8]
  !MOV Ecx, [Esp + 4]
  !REPNZ SCASB
  !SUB Edi, [Esp]
  !MOV Eax, Edi
  ProcedureReturn
EndProcedure

;Sucht einen String in einem anderen
;hString1.l [in] : Handle zum String, in dem gesucht werden soll
;hString2.l [in] : Handle zum String, der gesucht werden soll
;Begin.l [in] : Position, ab der gesucht werden soll
;RETURN : Position des zweiten Strings im ersten
Procedure.l mFindString(hString1.l, hString2.l, Begin.l)
  Protected sString1.l, sString2.l, eString1.l, eString2.l
  Protected *z1.Byte, *z2.Byte, Position.l, Offset.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  
  If sString2 > sString1 Or sString2 = 0 Or Begin > sString1 - 1
    ProcedureReturn 0
  Else
    eString1 = hString1 + sString1 - 1
    *z2 = hString2
    *z1 = hString1 + Begin - 1
    Offset = Begin - 1
     
    Repeat
      Position = FindByte(*z1, sString1, *z2\b) + Offset
      
      If Position <= sString1
        *z1 + Position - 1 - Offset
        
        If CompareMemory(*z1, hString2, sString2 - 1)
          ProcedureReturn Position
        Else
          *z1 + 1
          Offset + Position
          If *z1 = eString1 - sString2 + 1 : ProcedureReturn 0 : EndIf
        EndIf
      Else
        ProcedureReturn 0
      EndIf
    ForEver
  EndIf
EndProcedure

;Gibt eine bestimmte Anzahl von Zeichen vom Anfang eines Strings als einen neuen String zurück
;hString1.l [in] : Handle zum String
;Length.l [in] : Anzahl der Zeichen
;RETURN : Handle zum ausgeschnittenen String
Procedure.l mLeft(hString1.l, Length.l)
  Protected sString1.l, hString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  If sString1 - 1 < Length
    Length = sString1 - 1
  EndIf
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
  CopyMemory(hString1, hString2, Length)
  ProcedureReturn hString2
EndProcedure

;Vergleicht den Anfang des ersten Strings mit einem zweiten String
;hString1.l [in] : Handle zum ersten String
;hString2.l [in] : Handle zum zweiten String
;RETURN : 0 = ungleich, 1 = gleich
Procedure.l mLeftCompare(hString1.l, hString2.l)
  Protected sString1.l, sString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  If sString2 > sString1
    ProcedureReturn #FALSE
  EndIf
  ProcedureReturn CompareMemory(hString1, hString2, sString2 - 1)
EndProcedure

;Gibt eine bestimmte Anzahl von Zeichen vom Ende eines Strings als einen neuen String zurück
;hString1.l [in] : Handle zum String
;Length.l [in] : Anzahl der Zeichen
;RETURN : Handle zum ausgeschnittenen String
Procedure.l mRight(hString1.l, Length.l)
  Protected sString1.l, hString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  If sString1 - 1 < Length
    Length = sString1 - 1
  EndIf
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
  CopyMemory(hString1 + sString1 - Length - 1, hString2, Length)
  ProcedureReturn hString2
EndProcedure

;Vergleicht das Ende des ersten Strings mit einem zweiten String
;hString1.l [in] : Handle zum ersten String
;hString2.l [in] : Handle zum zweiten String
;RETURN : 0 = ungleich, 1 = gleich
Procedure.l mRightCompare(hString1.l, hString2.l)
  Protected sString1.l, sString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  If sString2 > sString1
    ProcedureReturn #FALSE
  EndIf
  ProcedureReturn CompareMemory(hString1 + sString1 - sString2, hString2, sString2)
EndProcedure

;Gibt eine bestimmte Anzahl von Zeichen aus der Mitte eines Strings als einen neuen String zurück
;hString1.l [in] : Handle zum String
;Position.l [in] : Position im String
;Length.l [in] : Anzahl der Zeichen
;RETURN : Handle zum ausgeschnittenen String
Procedure.l mMid(hString1.l, Position.l, Length.l)
  Protected sString1.l, hString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  If sString1 < Length + Position
    If sString1 - 1 < Position
      hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, 1)
      ProcedureReturn hString2
    EndIf
    Length = sString1 - Position
  EndIf
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
  CopyMemory(hString1 + Position - 1, hString2, Length)
  ProcedureReturn hString2
EndProcedure

;Vergleicht die Mitte des ersten Strings mit einem zweiten String
;hString1.l [in] : Handle zum ersten String
;Position.l [in] : Position im ersten String
;hString2.l [in] : Handle zum zweiten String
;RETURN : 0 = ungleich, 1 = gleich
Procedure.l mMidCompare(hString1.l, Position.l, hString2.l)
  Protected sString1.l, sString2.l
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  sString2 = HeapSize_(PbHeap(), 0, hString2)
  If sString2 + Position - 1 > sString1
    ProcedureReturn #FALSE
  EndIf
  ProcedureReturn CompareMemory(hString1 + Position - 1, hString2, sString2 - 1)
EndProcedure

;Gibt alle Zeichen ab einer bestimmten Position im String als einen neuen String zurück
;hString1.l [in] : Handle zum String
;Position.l [in] : Position im String
;RETURN : Handle zum ausgeschnittenen String
Procedure.l mMidEnd(hString1.l, Position.l)
  Protected sString1.l, hString2.l
  sString1.l = HeapSize_(PbHeap(), 0, hString1)
  If sString1 - 1 < Position
    hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, 1)
    ProcedureReturn hString2
  EndIf
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString1 - Position + 1)
  CopyMemory(hString1 + Position - 1, hString2, sString1 - Position)
  ProcedureReturn hString2
EndProcedure

;Gibt die Länge eines Strings zurück
;hString.l [in] : Handle zum String
;RETURN : Länge des Strings
Procedure.l mLen(hString.l)
  Protected sString.l
  sString = HeapSize_(PbHeap(), 0, hString)
  ProcedureReturn sString - 1
EndProcedure

;Gibt die Länge eines Strings bis zum Nullbyte zurück
;hString.l [in] : Handle zum String
;RETURN : Länge bis zum Nullbyte
Procedure.l mLenZero(hString.l)
  Protected Length.l
  Length = LStrLen_(hString)
  ProcedureReturn Length
EndProcedure

;Gibt den ASCII-Code des ersten Zeichens eines Strings zurück
;hString.l [in] : Handle zum String
;RETURN : ASCII-Code des ersten Zeichens
Procedure.l mAsc(hString.l)
  Protected sString.l
  sString = HeapSize_(PbHeap(), 0, hString)
  If sString - 1
    ProcedureReturn PeekB(hString) & $FF
  EndIf
  ProcedureReturn 256
EndProcedure

;Gibt den ASCII-Code eines bestimmten Zeichens im String zurück
;hString.l [in] : Handle zum String
;Position.l [in] : Zeichen im String
;RETURN : ASCII-Code des Zeichens
Procedure.l mAscPosition(hString.l, Position.l)
  Protected sString.l
  sString = HeapSize_(PbHeap(), 0, hString)
  If Position > sString - 1
    ProcedureReturn 256
  EndIf
  ProcedureReturn PeekB(hString + Position - 1) & $FF
EndProcedure

;Erstellt einen String mit einem Zeichen, das einen bestimmten ASCII-Codo hat
;ASCII.l [in] : ASCII-Code
;RETURN : Handle zum neuen String
Procedure.l mChr(ASCII.l)
  Protected hString.l
  hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, 2)
  PokeB(hString, ASCII)
  ProcedureReturn hString
EndProcedure

;Procedure um einen Speicherbereich zu füllen von Stefan Moebius (dt. Forum)
Procedure MemBFill(Adr,AnzBytes,Byt.b) 
  !CLD 
  !MOV Edi,[Esp+0] 
  
  !MOV AL,[Esp+8] 
  !SHL Eax,8 
  !MOV AL,[Esp+8] 
  !SHL Eax,8 
  !MOV AL,[Esp+8] 
  !SHL Eax,8 
  !MOV AL,[Esp+8] 
  !MOV Esi,Eax 
  
  !MOV Eax,[Esp+4] 
  !XOR Edx,Edx 
  !MOV Ebx,4 
  !DIV Ebx 
  
  !MOV Ecx,Eax 
  !MOV Eax,Esi 
  !REP STOSD 
  !CMP Edx,0 
  !JE EndeB 
  
  !MOV Ecx,Edx 
  !REP STOSB 
  !EndeB: 
EndProcedure 

;Erstellt einen String mit einer bestimmten Anzahl an Leerzeichen
;Length.l [in] : Anzahl an Leerzeichen
;RETURN : Handle zum neuen String
Procedure.l mSpace(Length.l)
  Protected hString.l
  hString = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
  RtlFillMemory_(hString, Length, $20)
  ProcedureReturn hString
EndProcedure

;Vergleicht den ASCII-Code eines bestimmten Zeichens mit dem gefragten
;hString.l [in] : Handle zum String
;Position.l [in] : Position im String
;ASCII.l [in] : Zu vergleichender ASCII-Code
;RETURN : 0 = ungleich, 1 = gleich
Procedure.l mCompareChar(hString.l, Position.l, ASCII.l)
  Protected sString.l, *z.Byte
  sString = HeapSize_(PbHeap(), 0, hString)
  If sString - 1 < Position
    ProcedureReturn #FALSE
  EndIf
  *z = hString + Position - 1
  If *z\b & $FF = ASCII
    ProcedureReturn #TRUE
  Else
    ProcedureReturn #FALSE
  EndIf
EndProcedure

;Gibt ein durch ein Trennzeichen getrenntes Feld in einem String an einer bestimmten Position
;in einem neuen String zurück
;hString1.l [in] : Handle zum Ausgangsstring
;Index.l [in] : Feldindex
;ASCII.l [in] : Trennzeichen als ASCII-Code
;RETURN : Handle zum ausgeschnittenen String
Procedure.l mStringField(hString1.l, Index.l, ASCII.l)
  Protected aktIndex.l, *z.BYTE, Begin.l
  Protected hString2.l, vContinue.l
  aktIndex = 1
  *z = hString1
  Begin = hString1 - 1
  vContinue = #True
  While vContinue
    If *z\b & $FF = ASCII
      Begin = *z
      aktIndex + 1
    EndIf
    *z + 1
    If aktIndex = Index
      If *z\b & $FF = ASCII Or *z\b = 0
        vContinue = #False
      EndIf
     Else
       If *z\b = 0
         hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, 1)
         ProcedureReturn hString2
       EndIf
    EndIf
  Wend
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, *z - Begin - 1)
  CopyMemory(Begin + 1, hString2, *z - Begin - 1)
  ProcedureReturn hString2
EndProcedure

;Löscht die Leerzeichen vom Anfang und vom Ende des Strings und gibt das Handle
;des Strings zurück (dabei wird das Handle zum eingegangenen String ungültig)
;hString1.l [in] : String, der getrimmt werden soll
;RETURN : Handle zum getrimmten String
Procedure.l mTrim(hString1.l)
  Protected sString1.l, *z.Byte, Begin.l, Ends.l
  Protected hString2
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  *z = hString1
  While *z\b = 32 And *z\b
    *z + 1
  Wend
  Begin = *z - hString1
  *z = hString1 + sString1 - 2
  While *z\b = 32 And *z >= hString1
    *z - 1
  Wend
  Ends = hString1 + sString1 - 2 - *z
  If Begin = Ends
    If Begin = sString1 - 1
      Ends = 0
    EndIf
  EndIf
  hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, sString1 - (Begin + Ends))
  HeapFree_(PbHeap(), 0, hString1)
  CopyMemory(hString1 + Begin, hString2, sString1 - (Begin + Ends))
  ProcedureReturn hString2
EndProcedure

;Setzt hinter den angegebenen String soviele Zeichen mit einem bestimmten ASCII-Code,
;sodass die gewünschte Länge erreicht ist (das Handle des eingegangenen Strings wird
;ungültig)
;hString1.l [in] : Handle zum String
;Length.l [in] : Länge, die aufgefüllt werden muss
;ASCII.l [in] : ASCII-Code für die Zeichen
;RETURN : Handle zum formatierten String
Procedure mLSet(hString1.l, Length.l, ASCII.l)
  Protected sString1.l, *z.Byte
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  If sString1 - 1 > Length
    hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
    CopyMemory(hString1, hString2, Length)
    HeapFree_(PbHeap(), 0, hString1)
    ProcedureReturn hString2
  Else
    hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
    CopyMemory(hString1, hString2, sString1 - 1)
    HeapFree_(PbHeap(), 0, hString1)
    For *z = hString2 + sString1 - 1 To hString2 + Length - 1
      *z\b = ASCII
    Next
    ProcedureReturn hString2
  EndIf
EndProcedure

;Setzt vor den angegebenen String soviele Zeichen mit einem bestimmten ASCII-Code,
;sodass die gewünschte Länge erreicht ist (das Handle des eingegangenen Strings wird
;ungültig)
;hString1.l [in] : Handle zum String
;Length.l [in] : Länge, die aufgefüllt werden muss
;ASCII.l [in] : ASCII-Code für die Zeichen
;RETURN : Handle zum formatierten String
Procedure mRSet(hString1.l, Length.l, ASCII.l)
  Protected sString1.l, *z.Byte
  sString1 = HeapSize_(PbHeap(), 0, hString1)
  If sString1 - 1 > Length
    hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
    CopyMemory(hString1, hString2, Length)
    HeapFree_(PbHeap(), 0, hString1)
    ProcedureReturn hString2
  Else
    hString2 = HeapAlloc_(PbHeap(), #Heap_Zero_Memory, Length + 1)
    CopyMemory(hString1, hString2 + Length - sString1 + 1, sString1 - 1)
    HeapFree_(PbHeap(), 0, hString1)
    For *z = hString2 To hString2 + Length - sString1
      *z\b = ASCII
    Next
    ProcedureReturn hString2
  EndIf
EndProcedure

;Setzt an einer bestimmten Position in einem String ein Zeichen
;hString.l [in] : Handle zum String
;Position.l [in] : Position des Zeichens im String
;ASCII.l [in] : ASCII-Code des Zeichens
;RETURN : #False = Position außerhalb des Bereichs, #True = Zeichen gesetzt
Procedure mSetChar(hString.l, Position.l, ASCII.l)
  Protected sString.l, *z.Byte
  sString = HeapSize_(PbHeap(), 0, hString)
  If sString - 1 < Position Or Position < 1
    ProcedureReturn #False
  EndIf
  *z = hString + Position - 1
  *z\b = ASCII
  ProcedureReturn #True
EndProcedure

;Sucht das nächste Nullbyte und setzt ein Zeichen an die Stelle, wenn es nicht
;das letzte Nullbyte im reservierten String ist
;hString.l [in] : Handle zum String
;ASCII.l [in] : ASCII-Code des Zeichens
;RETURN : #False = Letztes Zeichen ist erreicht, #True = Zeichen gesetzt
Procedure mSetCharEx(hString.l, ASCII.l)
  Protected *z.Byte, sString.l
  sString = HeapSize_(PbHeap(), 0, hString)
  *z = hString + LStrLen_(hString) - 1
  If *z - hString = sString - 1
    ProcedureReturn #False
  EndIf
  *z\b = ASCII
  ProcedureReturn #True
EndProcedure

; Procedure mRemoveString(hString1.l, hString2.l)
;   Protected sString1.l, sString2.l, Begin.l, Ends.l, Quit.l
;   sString1 = HeapSize_(PbHeap(), 0, hString1)
;   sString2 = HeapSize_(PbHeap(), 0, hString2)
;   If sString2 > sString1
;     ProcedureReturn #False
;   EndIf
;   Repeat
;     Begin = mFindString(hString1, hString2, Begin + 1)
;     If Begin
;     Else
;       
;     EndIf
;   Until Quit
; EndProcedure
; 
; Procedure mLCase(hString.l)
; EndProcedure
; 
; Procedure mUCase(hString.l)
; EndProcedure

;- Code

If ReadFile(0, "c:\frunlog.txt")
  s2 = mReserveString(Lof())
  ReadData(s2, Lof())
  CloseFile(0)
EndIf
Debug mValueString(s2)

End

#Repeats = 1000000

string$ = "Das ist mein String. Es ist ein ganz normaler String. Er dient zu " 
string$ + "Demonstartionszwecken und darf daher auch abartig sein. Was auch " 
string$ + "immer man jetzt darunter verstehen mag :-) <aaachen>"
s1 = mNewString(@string$)

Test.s = "Suche nach 'Das'" + Chr(13)

s2 = mNewString(@"Das")
time.l = gettickcount_()
For a.l = 1 To #Repeats
  mFindString(s1, s2, 1)
Next
Test = Test + "- NTQ: " + Str(gettickcount_() - time) + Chr(13)
time.l = gettickcount_()
For a.l = 1 To #Repeats
  FindString(string$, "Das", 1)
Next
Test =  Test + "- PB: " + Str(gettickcount_() - time) + Chr(13) 

Test = Test + "Suche nach 'mag'" + Chr(13)
s2 = mChangeString(s2, @"mag")
time.l = gettickcount_()
For a.l = 1 To #Repeats
  mFindString(s1, s2, 1)
Next
Test.s = Test + "- NTQ: " + Str(gettickcount_() - time) + Chr(13)

time.l = gettickcount_()
For a.l = 1 To #Repeats
  FindString(string$, "mag", 1)
Next
Test.s = Test + "- PB: " + Str(gettickcount_() - time) + Chr(13)

Test = Test + "Suche nach 'das kanste lange suchen'" + Chr(13)
s2 = mChangeString(s2, @"das kanste lange suchen")
time.l = gettickcount_()
For a.l = 1 To #Repeats
  mFindString(s1, s2, 1)
Next
Test.s = Test + "- NTQ: " + Str(gettickcount_() - time) + Chr(13)

time.l = gettickcount_()
For a.l = 1 To #Repeats
  FindString(string$, "das kanste lange suchen", 1)
Next
Test.s = Test + "- PB: " + Str(gettickcount_() - time) + Chr(13)



MessageRequester("Test-Info", Test, 0)
End
;{Beispiel
Debug " -- String s1, s2 und s3 --"
s1 = mNewString(@"abcdefghabcd")
s2 = mNewString(@"abc")
s3 = mNewString(@"Heute lernen wir das abc")
Debug mValueString(s1)
Debug mValueString(s2)
Debug mValueString(s3)

Debug " -- Position von s2 in s1 ab Pos 2 --"
Debug mFindString(s1, s2, 2)
Debug " -- Wert an Pos 9 mit Länge 4 in s1 --"
Debug mValueString(mMid(s1, 9, 4))

Debug " (s2 in s4 kopieren)"
;s4 = mNewString("")
s4 = mCopyStringEx(s2)

Debug " -- RSet(s2, 10, 45) --"
s2 = mRSet(s2, 10, 45) ;45 = "-"
Debug mValueString(s2)

Debug " -- 3.Wort in s3 --"
Debug mValueString(mStringField(s3, 3, 32))
Debug " -- Ist an Pos 6 in s3 = Leerzeichen? --"
Debug mCompareChar(s3, 6, 32) ;32 = " "
Debug " -- Ist an Pos 7 in s3 = L? --"
Debug mCompareChar(s3, 7, 76) ;76 = "L"
Debug " -- ASCII-Code an Pos 7 in s3 --"
Debug mAscPosition(s3, 7)
Debug " -- Ist rechter Teil von s3 = s4? --"
Debug mRightCompare(s3, s4)

Debug " -- s5 = s3 + s1 --"
s5 = mAddString(s3, s1)
Debug mValueString(s5)

Debug " (s6 = 100 Zeichen reserviert)"
s6 = mReserveString(100)
Debug " -- Erstes Zeichen mit ASCII-Code 65 in s6 --"
mSetChar(s6, 1, 65)
Debug mValueString(s6)
Debug " -- Zweites Zeichen mit ASCII-Code 98 --"
mSetChar(s6, 2, 98)
Debug mValueString(s6)
Debug " -- Zeichen mit ASCII-Code 67 anhängen --"
mSetCharEx(s6, 67)
Debug mValueString(s6)
Debug " -- Anzahl Zeichen von s6 bis Nullbyte --"
Debug mLenZero(s6)
Debug " -- Länge von s6 --"
Debug mLen(s6)
;}
; jaPBe Version=1.3.10.10
; FoldLines=000100040009000F00140018001E002A0030003C00410047004C004E0053005B
; FoldLines=00610069006F0078007E0087008A0093009A00BA00C000C900CF00D700DD00E6
; FoldLines=00EC00F400FB0108010F0117011D0127012C013001350139013E0145014B0152
; FoldLines=0157015C015F017A017F0184018B0197019F01BA01C001D701E001F101FA020B
; FoldLines=0212021B0222022B028302B7
; Build=0
; FirstLine=209
; CursorPosition=581
; ExecutableFormat=Windows
; EOF