PureBasic Forums - English

Code: Select all

Procedure.l IsStrAlpha(*theString)
  ;=========================================================================================
  ; PURPOSE.... determines whether a string contains only alphabetical characters
  
  ; PARAMETER.. *theString - Address of the string to check
  
  ; RETURNS.... 1 if the string contains only alphabetical characters
  ;............ 0 if the string contains any non-alphabetical characters (including spaces)
  ;=========================================================================================
  
  !mov eax, [p.p_theString] ; Get address of string in eax
  !push esi               ; preserve esi
  !mov esi, eax           ; copy address of string to esi
  !cld                    ; makes esi count upwards when lodsw is used (hence fetches next character in string)
  !sub eax, eax           ; clear eax
  
!l_NextChar:  
  !lodsw                  ; get word pointed to by esi in ax - use word for Unicode strings [lodsb for ascii strings]
  !test   al,al           ; check if low byte is zero ie is this end of string?
  !jz  l_IsAlpha          ; if we have reached the end of the string then the string is alphanumeric
  
  !cmp ax, 65             ; A=65 If ax is less than 65 then ax holds a non-alphabetical character
  !jl l_NotAlpha
  !cmp ax, 91             ; Z=90 If ax is less than 91 then ax holds an alphabetical character
  !jl l_NextChar          ; get next character to examine
  
  !cmp ax, 97             ; a=97 If ax is less than 97 then ax holds a non-alphabetical character
  !jl l_NotAlpha           
  !cmp eax, 123           ; 122 = z  If ax is less than 123 then ax holds an alphabetical character
  !jl l_NextChar          ; get next character to examine
  
!l_NotAlpha:              ; string contains a non-alphabetical character
  !pop esi                ; restore esi
  !mov eax, 0
  !jmp l_exit

!l_IsAlpha:               ; string contains an alphabetical character
  !pop esi                ; restore esi
  !mov eax, 1

!l_exit:

  ProcedureReturn
EndProcedure

a$ = "12345"
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

a$ = "thequickbrownfoxjumpsoverthelazydogs"
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

a$="THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG"
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

a$ = "thequickbrownfoxjumpsoverthelazydog9"
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

a$="THEQUICKBROWNFOXJUMPSOVERTHELAZYDOGS9"
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

Code: Select all

Procedure.l IsStrAlpha(*theString)
  CompilerIf #PB_Compiler_Processor = #PB_Processor_x64
    !mov rdx, [p.p_theString]
    !.l0:
    !movzx eax, word [rdx]
    !add rdx, 2
  CompilerElse
    !mov edx, [p.p_theString]
    !.l0:
    !movzx eax, word [edx]
    !add edx, 2
  CompilerEndIf
  !lea ecx, [eax - 65]
  !and ecx, -33
  !cmp ecx, 26
  !jb .l0
  !sub eax, 1
  !shr eax, 31
  ProcedureReturn
EndProcedure

Code: Select all

a$ = "Anfängerfragen" ; German
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

a$="expérience " ; French
Debug "String "+ a$ + " returns " + IsStrAlpha(@a$)

Code: Select all

Procedure.i IsStrAlpha(*p)
  ;
  ; procedure tests if unicode string is comprised of alpha characters only. Returns 1 for alpha, 0 otherwise.
  ; Windows ONLY, using Windows API
  ; *p = pointer to string
  ; PB v.5.72; x.64, Unicode only, Windows 10 Pro
  ;  
  Protected Alpha.i

  Alpha = #True

  While PeekU(*p) <> 0                    ; loop until you reach Null at end of string
    If IsCharAlpha_(PeekU(*p)) = 0
      Alpha = #False
      Break                               ; exit at first non-alpha character
    EndIf
    *p+2                                  ; unicode uses 2 bytes per character
  Wend
  
  ProcedureReturn Alpha

EndProcedure


; TESTING:
; First, a string comprised of Unicode alpha characters:
X$ = "ABCabc" + Chr($00D6) + Chr($00DF) + Chr($0178) + Chr($019B) + Chr($1E40) + Chr($1FAF)

; Next, a string containing symbols as well:
Y$ = "ABCabc" + Chr($00D6) + Chr($00DF) + Chr($0178) + Chr($019B) + Chr($1E40) + Chr($1FAF) + Chr($2605) + Chr($266F)

Debug X$
Debug IsStrAlpha(@X$)
Debug ""
Debug Y$
Debug IsStrAlpha(@Y$)


End

Code: Select all

X$ = "ABCabc Ñ" + Chr($00D6) + Chr($00DF) + Chr($0178) + Chr($019B) + Chr($1E40) + Chr($1FAF)

; Next, a string containing symbols as well:
Y$ = "ABCabc Ñ" + Chr($00D6) + Chr($00DF) + Chr($0178) + Chr($019B) + Chr($1E40) + Chr($1FAF) + Chr($2605) + Chr($266F)

Debug X$
Debug IsStrAlpha(@X$)
Debug ""
Debug Y$
Debug IsStrAlpha(@Y$)

Code: Select all

ABCabc ÑÖߟƛṀᾯ
0

ABCabc ÑÖߟƛṀᾯ★♯
0

Code: Select all

; IsStrAlpha
; Marc56us - 2020/10/02 - PB 5.72 LTS

#RegEx = "[^\p{L}]+" 

If Not CreateRegularExpression(RegEx, #RegEx)
    Debug "RegEx error" : End
EndIf

Procedure.l IsStrAlpha(theString$)
    If MatchRegularExpression(RegEx, theString$)
        ProcedureReturn 0
    Else    
        ProcedureReturn 1   
    EndIf
EndProcedure

Repeat
    Read.s a$
    If a$ = "EOT" : Break : EndIf
    Debug "" + IsStrAlpha(a$) + " - " + a$
ForEver

End

DataSection
    Data.s "12345"
    Data.s "thequickbrownfoxjumpsoverthelazydogs"
    Data.s "THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG"
    Data.s "thequickbrownfoxjumpsoverthelazydog9"
    Data.s "THEQUICKBROWNFOXJUMPSOVERTHELAZYDOGS9"
    Data.s "Anfängerfragen" ; German
    Data.s "expérience"     ; French
    Data.s "ABCabc" + Chr($00D6) + Chr($00DF) + Chr($0178) + Chr($019B) + Chr($1E40) + Chr($1FAF)
    Data.s "ABCabc" + Chr($00D6) + Chr($00DF) + Chr($0178) + Chr($019B) + Chr($1E40) + Chr($1FAF) + Chr($2605) + Chr($266F)
    Data.s "EOT"
EndDataSection

Code: Select all

0 - 12345
1 - thequickbrownfoxjumpsoverthelazydogs
1 - THEQUICKBROWNFOXJUMPSOVERTHELAZYDOG
0 - thequickbrownfoxjumpsoverthelazydog9
0 - THEQUICKBROWNFOXJUMPSOVERTHELAZYDOGS9
1 - Anfängerfragen
1 - expérience
1 - ABCabcÖߟƛṀᾯ
0 - ABCabcÖߟƛṀᾯ★♯