DeclareModule FastSplit
   
    Declare.i Fast_Split_To_Array(*pio_to_split, pi_sep.s, Array result.s(1))
   
EndDeclareModule

Module FastSplit
   
    ; *pio_to_split :   Unicode string pointer assumed => 2 bytes size par character
    ; pi_sep        :   Unicode separator assumed, can have several chars (typically #CRLF$)
    ; result        :   will be updated
    ; RETURN        :   result array elements count
    Procedure.i Fast_Split_To_Array(*pio_to_split, pi_sep.s, Array result.s(1))
       
        ; Non printable Unicode char
        #REPLACE_CHAR = $FFFF
       
        ; Macro used here to avoid a costly asm CALL
        Macro Macro_Asm_Set_Array_String_Pointer
            ! mov eax, 4                            ; 4 bytes size assumed for a 32 bits (x86) pointer
            ! mov [p.p_pedx_backup], edx            ; "edx" register backup (can't use "push/pop edx" because PB local vars are "esp" indexed)
            ! mul dword [p.v_current_element]       ; Multiply by current element index and put the result in "eax"/ Beware that "mul" use "edx" register, so the previous backup
            ! mov edx, [p.p_pedx_backup]            ; Get "edx" register value back
            ! add eax, [p.p_parray_string_pointers] ; Add result to get the start address in the original string
            ! mov [eax], edx                        ; Put computed address in the current array index
        EndMacro
       
        ; Exit if nothing to split
        If Len(PeekS(*pio_to_split)) = 0
            ProcedureReturn 0
        EndIf
       
        ; One element array if no separator
        If Len(pi_sep) = 0
            ReDim result(0)
            result(0) = PeekS(*pio_to_split)
            ProcedureReturn 1
        EndIf
       
        ; Local définition of separator (why ? just to show that "pi_sep" should be readonly, no performance hit here)
        Define.s local_sep = pi_sep
       
        ; More than one character in separator => one time performance hit to replace all separator chars by one (#REPLACE_CHAR)
        ; but "ReplaceString" is very well optimized (thanks Fred :) so performance hit is limited
        If Len(local_sep) > 1
            PokeS(*pio_to_split, ReplaceString(PeekS(*pio_to_split), local_sep, Chr(#REPLACE_CHAR)))
            local_sep = Chr(#REPLACE_CHAR)
        EndIf
       
        ; Get the size of zero based result array ("CountString" is very optimized too :)
        Define.i sep_count = CountString(PeekS(*pio_to_split), local_sep)
       
        ; Prepare the result array
        ReDim result(sep_count)
       
        ; No separators found ? Return the original string in an one-element result array
        If sep_count = 0
            result(0) = PeekS(*pio_to_split)
            ProcedureReturn 1
        EndIf
       
        ; Definitions
        Define.i sep = Asc(local_sep) ; Two chars in Unicode, which is assumed here
        Define.i current_element = 0  ; Array current element processing
       
        ; Trick #1 : get the array REAL address
       
        ; In fact, PB here returns the array first element address (but in the MemoryViewer, "@result()" show the real array address)...
        Define *parray_addr = @result()
        Define *parray_string_pointers = PeekI(@*parray_addr) ; ...have to go up to find the real array address, which contains the vTable of strings in array
        Define *pedx_backup                                   ; Our "edx" register backup (see explanations above in the macro)
       
        ! mov ecx, [p.p_pio_to_split]                   ; Load string start address here...
        ! mov edx, [p.p_pio_to_split]                   ; ...and here
       
        Scan:                                           ; Scan loop
        ! mov ax, [ecx]                                 ; Get current char (Unicode => 2 bytes => ax is ok)
        ! cmp ax, 0                                     ; String end ?
        ! jz fastsplit.ll_fast_split_to_array_endscan   ; Exit to EndScan:
       
        ! cmp ax, [p.v_sep]                             ; Separator found ?
        ! jz fastsplit.ll_fast_split_to_array_sepfound  ; Process to SepFound:
       
        NextChar:                                       ; Point to next char
        ! add ecx, 2                                    ; Unicode => 2 bytes increment
        ! jmp fastsplit.ll_fast_split_to_array_scan     ; Loop to Scan:
       
        ; Trick #2 : replace array original pointer by pointer in original string => no string memory allocation
       
        SepFound:                                       ; Separator found
        ! mov word [ecx], 0                             ; Replace separator by 2 zero-bytes (=> string end)
        Macro_Asm_Set_Array_String_Pointer              ; Our killer macro :)
        ! mov edx, ecx                                  ; Point to...
        ! add edx, 2                                    ; ...next char
        ! inc dword [p.v_current_element]               ; Increment array current element
        ! jmp fastsplit.ll_fast_split_to_array_nextchar ; Read next char to NextChar:
       
        EndScan:
        Macro_Asm_Set_Array_String_Pointer              ; Our killer Macro again :) for the last value
       
        ProcedureReturn sep_count + 1                   ; Array elements count (PB ArraySize() return the array upper bound, not necessarily the elements count)
       
    EndProcedure
   
EndModule

If #PB_Compiler_IsMainFile

  If ReadFile(0, "D:\Text20000.txt")
    Debug "Ok"
       While Eof(0) = 0
         txt$  + ReadString(0, #PB_UTF8)+ #CRLF$  ; прочитал 20000 слов в переменную
       Wend
 	 CloseFile(0)
 	EndIf
 	
 	  	
 	; Собственно само выполнение программы тут:
 Define.i elements_count, i
 Dim a.s(0)
 StartTime=ElapsedMilliseconds()
 elements_count = FastSplit::Fast_Split_To_Array(@txt$, " ", a())
 Res.s = "Прошло времени между метками " + Str(ElapsedMilliseconds()-StartTime) + " мсек, элементов " +  elements_count
 MessageRequester ("Ok! ",Res)
 
   
EndIf