x86 NASM - example code of an isalpha *WITH PRINTING*

Question

how can i make an isalpha in nasm that takes the argv0 and prints it just in case it isalpha returns true, ie it contains letters, but i do not want to modify or delete what is not letters.

I found some cases here in the stackoverflow, but I was not able to modify them to start, since I'm a beginner in assembly.

ISALPHA EXAMPLE I SAW

Please, could you help me use this code along with a print using pure nasm, without c functions.

I also made this example code, I do not know if it is usable section .text
global _start

    _start:                                                                                                                                       
            push ebp                                                                                                                              
            mov ebp, esp                                                                                                                          

            mov ebx, [ebp+12]                                                                                                                     
            cmp ebx, 0x00                                                                                                                         
            jz exit                                                                                                                               
            mov eax, ebx                                                                                                                          

    strlen:                                                                                                                                       

            cmp byte [eax], 0x00                                                                                                                  
            jz result
            inc eax
            jmp strlen

    result:

            sub eax, ebx
            mov ecx, eax

    isalpha:

            mov dl, [ebx]
            or dl, 0x20
            sub dl, 'a'
            cmp dl, 'z'-'a'
            jna print
            inc ebx
            dec ecx
            jnz isalpha

    print:

            lea edx, [eax+1]
            mov ecx, ebx
            mov BYTE [ecx+eax], 0xA
            mov ebx, 0x1
            mov eax, 0x4
            int 0x80

    exit:
            mov eax, 0x1
            mov ebx, 0x0
            int 0x80

Answer 1

---

Well, initially I wanted a code that would check if the input satisfies isalpha() and if it do, print it "without modifying what is not alpha", but in I came to the conclusion, it is better to remove even that which is not alphabetic, for the sake of testing.

here is the C code I used as a skeleton:

#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char **argv, char **envp) {
    if (argv[1] == NULL) {
            printf("usage: %s string\n", argv[0]);
            return 1;
    }
    for (int c = 0; c < strlen(argv[1]); c++)
    {
       if (isalpha(argv[1][c]))
       {
            write(1, argv[1] + c, 1);
       }
    }
    write(1, "\n", 1);
    return 0;
}

and the assembly code that I came up with as a result, I'm extremely beginner in assembly, like 1 month learning a few things, so I'll be extremely grateful for suggestions of things I could do better or different

section .text                                                                                                                            [25/1709]
global _start                                                                                                                                     

_start:                                                                                                                                           

    push 0                                                                                                                                        
    mov ebp, esp                                                                                                                                  

    mov ebx, [ebp+12]                                                                                                                             
    cmp ebx, 0x00                                                                                                                                 
    jz exit                                                                                                                                       
    mov ecx, ebx                                                                                                                                  

strlen:                                                                                                                                           

    cmp byte [ecx], 0x00                                                                                                                          
    jz result                                                                                                                                     
    inc ecx                                                                                                                                       
    jmp strlen                                                                                                                                    

result:                                                                                                                                           

    sub ecx, ebx                                                                                                                                  

isalpha:                                                                                                                                          

    mov eax, [ebx]

    or al, 0x20
    sub al, 'a'
    cmp al, 'z'-'a'
    ja notalpha
    add al, 'a'

    push ecx
    push ebx
    push eax

    mov edx, 0x01
    mov ecx, esp
    mov ebx, 0x01
    mov eax, 0x04
    int 0x80

    pop eax
    pop ebx
    pop ecx

notalpha:

    inc ebx
    dec ecx
    jnz isalpha

exit:

    mov eax, 0x01
    mov ebx, 0x00
    int 0x80

note that in the assembly code case, unlike C one, the letters are all converted to lower-case in the output, I could not manage this out and I'll be grateful if anyone can do this correction so the assembly code do not change the letters case in the output.

---