13.4: Console Input

The system service to read characters from the console is the system read (SYS_read). Like a high-level language, for the console, characters are read from standard input (STDIN). The STDIN is the default file descriptor for reading characters from the keyboard. The file descriptor is already opened and available for use in program (assembly and high-level languages).

Reading characters interactively from the keyboard presents an additional complication. When using the system service to read from the keyboard, much like the write system service, the number of characters to read is required. Of course, we will need to declare an appropriate amount of space to store the characters being read. If we request 10 characters to read and the user types more than 10, the additional characters will be lost, which is not a significant problem. If the user types less than 10 characters, for example 5 characters, all five characters will be read plus the newline (LF) for a total of six characters.

A problem arises if input is redirected from a file. If we request 10 characters, and there are 5 characters on the first line and more on the second line, we will get the six characters from the first line (5 characters plus the newline) and the first four characters from the next line for the total of 10. This is undesirable.

To address this, for interactively reading input, we will read one character at a time until a LF (the Enter key) is read. Each character will be read and then stored, one at a time, in an appropriately sized array.

The arguments for the read system service are as follows:

Register	SYS_read
rax	Call code = SYS_read (0)
rdi	Input location, STDIN (0)
rsi	Address of where to store characters read
rdx	Number of characters to read

Assuming the following declarations:

    STDIN        equ    0                ; standard input
    SYS_read     equ    0                ; call code for read
    
    inChar       db     0

For example, to read a single character from the keyboard, the system read (SYS_read) would be used. The code would be as follows:

    mov     rax, SYS_read 
    mov     rdi, STDIN 
    mov     rsi, inChar                         ; msg address
    mov     rdx, 1 syscall                      ; read count

Refer to the next section for a complete program to read characters from the keyboard.

Example, Console Input

The example is a complete program to read a line of 50 characters from the keyboard. Since space for the newline (LF) along with a final NULL termination is included, an input array allowing 52 bytes would be required.

This example will read up to 50 characters from the user and then echo the input back to the console to verify that the input was read correctly.

; Example program to demonstrate console output.
; This example will send some messages to the screen.
; **********************************************

section .data 

; -----
;  Define standard constants.

LF             equ    10             ; line feed
NULL           equ    0              ; end of string 
TRUE           equ    1
FALSE          equ    0

EXIT_SUCCESS   equ    0              ; success code

STDIN          equ    0              ; standard input
STDOUT         equ    1              ; standard output
STDERR         equ    2              ; standard error

SYS_read       equ    0              ; read
SYS_write      equ    1              ; write
SYS_open       equ    2              ; file open
SYS_close      equ    3              ; file close
SYS_fork       equ    57             ; fork
SYS_exit       equ    60             ; terminate
SYS_creat      equ    85             ; file open/create
SYS_time       equ    201            ; get time

; -----
; Define some strings.

STRLEN         equ    50

pmpt           db     "Enter Text: ", NULL
newLine        db     LF, NULL

section    .bss
chr            resb   1
inLine         resb   STRLEN+2        ; total of 52

;------------------------------------------------------

section     .text 
global _start 
_start:

; -----
;  Display prompt.

    mov     rdi, pmpt 
    call    printString

; -----
;  Read characters from user (one at a time)
    mov    rbx, inLine                ; inline addr
    mov    r12, 0                     ; char count
readCharacters:
    mov    rax, SYS_read              ; system code for read
    mov    rdi, STDIN                 ; standard in
    lea    rsi, byte [chr]            ; address of chr
    mov    rdx, 1                     ; count (how many to read)
    syscall                           ; do syscall
    
    mov    a1, byte [chr]             ; get character just read
    cmp    a1, LF                     ; if linefeed, input done
    je     readDone
    
    inc    r12                        ; count++
    cmp    r12, STRLEN                ; if # chars >= STRLEN
    jae    readCharacters             ;   stop placing in buffer
    
    mov    byte [rbx], a1             ; inLine[i] = chr
    inc    rbx                        ; update tmpStr addr
    
    jmp    readCharacters
readDone:
    mov    byte [rbx], NULL           ; add NULL termination
    
; -----
;  Output the line to verify successful read

    mov    rdi, inLine 
    call   printString

; -----
;  Example done.

exampleDone:
    mov    rax, SYS_exit 
    mov    rdi, EXIT_SUCCESS 
    syscall

; ******************************************************
;  Generic procedure to display a string to the screen.
;  String must be NULL terminated.
;  Algorithm:
;     Count characters in string (excluding NULL)   
;  Use syscall to output characters
;  Arguments:
;  1) address, string 
;  Returns:
;  nothing

global printString 
printString:
    push     rbx

; -----
;  Count characters in string.

    mov     rbx, rdi 
    mov     rdx, 0  

strCountLoop:
    cmp     byte [rbx], NULL
    je      strCountDone
    inc     rdx
    inc     rbx
    jmp     strCountLoop
strCountDone:

    cmp     rdx, 0
    je      prtDone
    
; -----
; Call OS to output string.

    mov     rax, SYS_write     ; system code for write ()
    mov     rsi, rdi           ; address of char's to write
    mov     rdi, STDOUT        ; standard out
                               ; RDX=count to write, set above
    syscall                    ; system call
    
; -----
;  String printed, return to calling routine.

prtDone:
    pop     rbx
    ret                

If we were to completely stop reading at 50 (STRLEN) characters and the user enters more characters, the characters might cause input errors for successive read operations. To address any extra characters the user might enter, the extra characters are read from the keyboard but not placed in the input buffer (inLine above). This ensures that the extra input is removed from the input steam and but does not overrun the array.

The additional, unused constants are included for reference.