x86 NASM - пример кода исальфы * С ПЕЧАТЬЮ *

Question

как я могу сделать isalpha в спазме, который принимает argv0 и печатает его на тот случай, если isalpha возвращает true, т.е. он содержит буквы , ноя не хочу изменить или удалить то, что не является буквами.

Я нашел некоторые случаи здесь в stackoverflow , но Я не смог чтобы изменить их, чтобы начать, так как я новичок в сборке.

ПРИМЕР ISALPHA I SAW

Пожалуйста, не могли бы вы помочь мне использовать этот код вместе спечатать, используя чистый нос, без функций c.

Я также сделал этот пример кода, я не знаю, является ли это полезным раздел .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

---

Ну, изначально я хотел код, который проверял бы, удовлетворяет ли ввод isalpha (), и если это так, выведите его "без изменения того, что не является альфа" , но я пришел кВ заключение, для проверки лучше удалить даже то, что не алфавитно.

Вот код C, который я использовал в качестве каркаса:

#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;
}

и сборкаКод, который я придумал в результате, я чрезвычайно новичок в сборке, например, за 1 месяц изучаю несколько вещей, поэтому я буду чрезвычайно признателен за предложения о вещах, которые я мог бы сделать лучше или лучше

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

обратите внимание, что в случае кода ассемблера, в отличие от C one, все буквы преобразуются в вывод в нижний регистр, Я не смог бы справиться с этим, и я буду благодарен, если кто-нибудьможно сделать это исправление , чтобы код сборки не менял регистр букв в выводе.

---