Linux NASM erkennen EOF

Ich versuche zu lernen, die Grundlagen von asm auf linux und ich kann nicht finden, eine sehr gute Referenz. Die NASM docs scheinen davon ausgehen, dass Sie bereits wissen, masm... fand ich keine Beispiele in der Dokumentation der cmp (außerhalb der Intel-instruction-Referenz).

Ich würde ein Programm geschrieben, das liest ein einzelnes byte von stdin und schreibt Sie auf die Standardausgabe. Unten ist meine Modifikation, um zu versuchen, um zu erkennen, EOF auf Standardeingabe und beendet, wenn EOF erreicht ist. Das Problem ist, es nie beendet. Ich habe gerade hält Druck das Letzte Zeichen von stdin Lesen. Das Problem ist entweder in meinem EOF-Erkennung (cmp ecx, EOF) und/oder mein Sprung zu den _exit label ( je _exit ), denke ich.

Was mache ich falsch?

%define EOF     -1

section .bss
        char:   resb    1

section .text
        global  _start

_exit:
        mov     eax,    1       ; exit
        mov     ebx,    0       ; exit status
        int     80h

_start:
        mov     eax,    3       ; sys_read
        mov     ebx,    0       ; stdin
        mov     ecx,    char    ; buffer
        cmp     ecx,    EOF     ; EOF?
        je      _exit
        mov     edx,    1       ; read byte count
        int     80h

        mov     eax,    4       ; sys_write
        mov     ebx,    1       ; stdout
        mov     ecx,    char    ; buffer
        mov     edx,    1       ; write byte count
        int     80h

        jmp     _start

For the sake of sanity, ich habe überprüft EOF -1 ist mit dieser C:

#include <stdio.h>
int main() { printf("%d\n", EOF); }
  • Ich bin nicht vertraut mit NASM, aber ist char einen Zeiger auf ein einzelnes Zeichen? Es sieht aus wie Sie können vergleichen, eine pointer-Adresse des Charakters, um den EOF-Wert. Wenn das der Fall ist, müssen Sie dereferenzieren Sie den Zeiger und dann vergleichen. Die read und write system ruft einen Zeiger auf einen Puffer als argument, nicht einen einzigen Charakter. Auch würde ich umbenennen char auf etwas anderes als ein basic-C-Typ-Namen.
InformationsquelleAutor tMC | 2012-02-23
  1. 6

    Sie vergleichen die Adresse des Puffers, auf EOF (-1) anstelle der Zeichen im Puffer gespeichert.

    Having said that, die read system call nicht zurück, wird der Wert EOF, wenn das Dateiende erreicht ist, aber es gibt null, und klebt nicht alles in den Puffer (siehe man 2 read). Identifizieren Ende der Datei, prüfen Sie einfach den Wert von eax nach dem Aufruf read:

    section .bss
    buf:   resb    1

section .text
    global  _start

_exit:
    mov     eax,    1       ; exit
    mov     ebx,    0       ; exit status
    int     80h

_start:
    mov     eax,    3       ; sys_read
    mov     ebx,    0       ; stdin
    mov     ecx,    buf    ; buffer
    mov     edx,    1       ; read byte count
    int     80h

    cmp     eax, 0
    je      _exit

    mov     eax,    4       ; sys_write
    mov     ebx,    1       ; stdout
    mov     ecx,    buf    ; buffer
    mov     edx,    1       ; write byte count
    int     80h

    jmp     _start

    Wenn Sie nicht wollen, um richtig vergleichen zu können, den Charakter auf einen Wert, Verwendung:

    cmp byte [buf], VALUE

    Außerdem habe ich umbenannt char zu buf. char ist ein basic C-Datentyp und eine schlechte Wahl für einen Variablennamen.

    • Ich versuchte schrittweise, das Programm über gdb und den Inhalt in ecx nie zu ändern scheint. Ich scheint konstant zu bleiben (0x80490c0)
    • Ich aktualisiert meine Antwort nach der Realisierung etwas. Allerdings, das ist richtig, denn Sie speichern die Adresse des Puffers, in ecx, die in diesem Fall im Speicher gespeichert wurde bei 0x80490c0. Der gelesene Wert in der sys_read call ruft gespeicherte memory location. Obwohl Ihr die änderung der Inhalt des Puffers, dessen Speicherort im Speicher bleibt der gleiche. Zu dereferenzieren Sie die Zeiger, und vergleichen Sie es mit einem anderen byte verwenden cmp byte [buf], VALUE.
    InformationsquelleAutor Mr. Shickadance
Schreibe einen Kommentar