Intel x86 Assembly Language & Microarchitecture MS-DOS, TASM/MASM function to read a 16-bit unsigned integer


Read a 16-bit unsigned integer from input.

This function uses the interrupt service Int 21/AH=0Ah for reading a buffered string.
The use of a buffered string let the user review what they had typed before passing it to the program for processing.
Up to six digits are read (as 65535 = 216 - 1 has six digits).

Besides performing the standard conversion from numeral to number this function also detects invalid input and overflow (number too big to fit 16 bits).

Return values

The function return the number read in AX. The flags ZF, CF, OF tell if the operation completed successfully or not and why.

NoneThe 16-bit integerSetNot SetNot Set
Invalid inputThe partially converted number, up to the last valid digit encounteredNot SetSetNot Set
Overflow7fffhNot SetSetSet

The ZF can be used to quickly tell valid vs invalid inputs apart.


call read_uint16
jo _handle_overflow            ;Number too big (Optional, the test below will do)
jnz _handle_invalid            ;Number format is invalid

;Here AX is the number read


  ;If the number is correctly converted:
  ;   ZF = 1, CF = 0, OF = 0
  ;   AX = number
  ;If the user input an invalid digit:
  ;   ZF = 0, CF = 1, OF = 0
  ;   AX = Partially converted number
  ;If the user input a number too big
  ;   ZF = 0, CF = 1, OF = 1
  ;   AX = 07fffh
  ;ZF/CF can be used to discriminate valid vs invalid inputs
  ;OF can be used to discrimate the invalid inputs (overflow vs invalid digit)
    push bp   
    mov bp, sp

    ;This code is an example in Stack Overflow Documentation project.
    ;x86/Converting Decimal strings to integers

    ;Create the buffer structure on the stack

    sub sp, 06h                ;Reserve 6 byte on the stack (5 + CR)
    push 0006h                 ;Header

    push ds
    push bx
    push cx
    push dx

    ;Set DS = SS

    mov ax, ss
    mov ds, ax                           

    ;Call Int 21/AH=0A

    lea dx, [bp-08h]            ;Address of the buffer structure
    mov ah, 0ah
    int 21h

    ;Start converting

    lea si, [bp-06h]
    xor ax, ax
    mov bx, 10
    xor cx, cx


    ;Get current char

    mov cl, BYTE PTR [si]
    inc si

    ;Check if end of string

    cmp cl, CR_CHAR
    je _r_ui16_end                      ;ZF = 1, CF = 0, OF = 0
    ;Convert char into digit and check

    sub cl, '0'
    jb _r_ui16_carry_end                ;ZF = 0, CF = 1, OF = X -> 0
    cmp cl, 9
    ja _r_ui16_carry_end                ;ZF = 0, CF = 0 -> 1, OF = X -> 0

    ;Update the partial result (taking care of overflow)

    ;AX = AX * 10
    mul bx

    ;DX:AX = DX:AX + CX
    add ax, cx
    adc dx, 0
    test dx, dx
   jz _r_ui16_convert            ;No overflow
    ;set OF and CF
    mov ax, 8000h
    dec ax                           

   jmp _r_ui16_end                      ;ZF = 0, CF = 1, OF = 1

    or bl, 1                ;Clear OF and ZF
    stc                     ;Set carry
    ;ZF = 0, CF = 1, OF = 0

    ;Don't mess with flags hereafter!

    pop dx
    pop cx
    pop bx
    pop ds

    mov sp, bp

    pop bp

    CR_CHAR EQU 0dh

NASM porting

To port the code to NASM remove the PTR keyword from memory accesses (e.g. mov cl, BYTE PTR [si] becomes mov cl, BYTE [si])