assembly - Mostrar números con DOS

x86-16 integer-division

Question

Me encargaron escribir un programa que muestre la dirección lineal de la PSP de mi programa. Escribí lo siguiente:

        ORG     256

        mov     dx,Msg
        mov     ah,09h          ;DOS.WriteStringToStandardOutput
        int     21h
        mov     ax,ds
        mov     dx,16
        mul     dx              ; -> Linear address is now in DX:AX

        ???

        mov     ax,4C00h        ;DOS.TerminateWithExitCode
        int     21h
; ------------------------------
Msg:    db      ''PSP is at linear address $''

¡Busqué en la API de DOS (usando la lista de interrupciones de Ralph Brown ) y no encontré una sola función para generar un número! ¿Lo extrañé y qué puedo hacer?

Quiero mostrar el número en DX:AX en decimal.

Answer 1

Es cierto que DOS no nos ofrece una función para generar un número directamente.
Primero tendrá que convertir el número usted mismo y luego hacer que DOS lo muestre usando una de las funciones de salida de texto.

Mostrar el número de 16 bits sin firmar que se encuentra en AX

Al abordar el problema de convertir un número, es útil ver cómo los dígitos que forman un número se relacionan entre sí.
Consideremos el número 65535 y su descomposición:

(6 * 10000) + (5 * 1000) + (5 * 100) + (3 * 10) + (5 * 1)

Método 1: división por poderes decrecientes de 10

Procesar el número que va de izquierda a derecha es conveniente porque nos permite mostrar un dígito individual tan pronto como lo extraemos.

• Al dividir el número (65535) por 10000 , obtenemos un cociente de un solo dígito (6) que podemos generar como un carácter de inmediato. También obtenemos un resto (5535) que se convertirá en el dividendo en el siguiente paso.

• Al dividir el resto del paso anterior (5535) por 1000 , obtenemos un cociente de un solo dígito (5) que podemos generar como un personaje de inmediato. También obtenemos un resto (535) que se convertirá en el dividendo en el siguiente paso.

• Al dividir el resto del paso anterior (535) por 100 , obtenemos un cociente de un solo dígito (5) que podemos generar como un personaje de inmediato. También obtenemos un resto (35) que se convertirá en el dividendo en el siguiente paso.

• Al dividir el resto del paso anterior (35) por 10 , obtenemos un cociente de un solo dígito (3) que podemos generar como un personaje de inmediato. También obtenemos un resto (5) que se convertirá en el dividendo en el siguiente paso.

• Al dividir el resto del paso anterior (5) por 1 , obtenemos un cociente de un solo dígito (5) que podemos generar como un personaje de inmediato. Aquí el resto siempre será 0. (Evitar esta tonta división por 1 requiere un código adicional)

    mov     bx,.List
.a: xor     dx,dx
    div     word ptr [bx]  ; -> AX=[0,9] is Quotient, Remainder DX
    xchg    ax,dx
    add     dl,"0"         ;Turn into character [0,9] -> ["0","9"]
    push    ax             ;(1)
    mov     ah,02h         ;DOS.DisplayCharacter
    int     21h            ; -> AL
    pop     ax             ;(1) AX is next dividend
    add     bx,2
    cmp     bx,.List+10
    jb      .a
    ...
.List:
    dw      10000,1000,100,10,1

Aunque este método, por supuesto, producirá el resultado correcto, tiene algunos inconvenientes:

• Considere el número más pequeño 255 y su descomposición:

  (0 * 10000) + (0 * 1000) + (2 * 100) + (5 * 10) + (5 * 1)

  Si tuviéramos que usar el mismo proceso de 5 pasos obtendríamos "00255". Esos 2 ceros iniciales son indeseables y tendríamos que incluir instrucciones adicionales para deshacernos de ellos.

• El divisor cambia con cada paso. Tuvimos que almacenar una lista de divisores en la memoria. El cálculo dinámico de estos divisores es posible pero introduce muchas divisiones adicionales.

• Si quisiéramos aplicar este método para mostrar números aún mayores, digamos 32 bits, y eventualmente querremos hacerlo, las divisiones involucradas se volverían realmente problemáticas.

Por lo tanto, el método 1 no es práctico y, por lo tanto, rara vez se usa.

Método 2: división por const 10

Procesar el número que va de derecha a izquierda parece contrario a la intuición, ya que nuestro objetivo es mostrar primero el dígito más a la izquierda. Pero como estás a punto de descubrir, funciona de maravilla.

• Al dividir el número (65535) por 10 , obtenemos un cociente (6553) que se convertirá en el dividendo en el siguiente paso. También obtenemos un resto (5) que todavía no podemos generar, por lo que tendremos que guardarlo en algún lugar. La pila es un lugar conveniente para hacerlo.

• Al dividir el cociente del paso anterior (6553) por 10 , obtenemos un cociente (655) que se convertirá en el dividendo en el siguiente paso. También obtenemos un resto (3) que todavía no podemos generar, por lo que tendremos que guardarlo en algún lugar. La pila es un lugar conveniente para hacerlo.

• Al dividir el cociente del paso anterior (655) por 10 , obtenemos un cociente (65) que se convertirá en el dividendo en el siguiente paso. También obtenemos un resto (5) que todavía no podemos generar, por lo que tendremos que guardarlo en algún lugar. La pila es un lugar conveniente para hacerlo.

• Al dividir el cociente del paso anterior (65) por 10 , obtenemos un cociente (6) que se convertirá en el dividendo en el siguiente paso. También obtenemos un resto (5) que todavía no podemos generar, por lo que tendremos que guardarlo en algún lugar. La pila es un lugar conveniente para hacerlo.

• Al dividir el cociente del paso anterior (6) por 10 , obtenemos un cociente (0) que indica que esta fue la última división. También obtenemos un resto (6) que podríamos obtener como personaje de inmediato, pero abstenerse de hacerlo resulta ser más efectivo y, como antes, lo guardaremos en la pila.

En este punto, la pila contiene nuestros 5 restos, cada uno con un número de un solo dígito en el rango [0,9]. Como la pila es LIFO (último en entrar, primero en salir), el valor que vamos a POP primero es el primer dígito que queremos mostrar. Usamos un bucle separado con 5 POP para mostrar el número completo. Pero en la práctica, dado que queremos que esta rutina también pueda manejar números que tengan menos de 5 dígitos, contaremos los dígitos a medida que lleguen y luego haremos esa cantidad de POP .

    mov     bx,10          ;CONST
    xor     cx,cx          ;Reset counter
.a: xor     dx,dx          ;Setup for division DX:AX / BX
    div     bx             ; -> AX is Quotient, Remainder DX=[0,9]
    push    dx             ;(1) Save remainder for now
    inc     cx             ;One more digit
    test    ax,ax          ;Is quotient zero?
    jnz     .a             ;No, use as next dividend
.b: pop     dx             ;(1)
    add     dl,"0"         ;Turn into character [0,9] -> ["0","9"]
    mov     ah,02h         ;DOS.DisplayCharacter
    int     21h            ; -> AL
    loop    .b

Este segundo método no tiene ninguno de los inconvenientes del primer método:

• Debido a que nos detenemos cuando un cociente se convierte en cero, nunca hay ningún problema con los ceros iniciales feos.
• El divisor es fijo. Eso es bastante fácil.
• Es realmente simple aplicar este método para mostrar números más grandes y eso es precisamente lo que viene después.

Visualización del número de 32 bits sin signo que se encuentra en DX: AX

En 8086 se necesita una cascada de 2 divisiones para dividir el valor de 32 bits en DX:AX por 10.
La primera división divide el dividendo alto (extendido con 0) produciendo un cociente alto. La 2da división divide el dividendo bajo (extendido con el resto de la 1ra división) produciendo el cociente bajo. Es el resto de la segunda división que guardamos en la pila.

Para verificar si la dword en DX:AX es cero, he OR -ed ambas mitades en un registro de cero.

En lugar de contar los dígitos, que requieren un registro, elegí poner un sentinel en la pila. Debido a que este centinela obtiene un valor (10) que ningún dígito puede tener ([0,9]), permite determinar cuándo debe detenerse el bucle de visualización.

Aparte de eso, este fragmento es similar al método 2 anterior.

    mov     bx,10          ;CONST
    push    bx             ;Sentinel
.a: mov     cx,ax          ;Temporarily store LowDividend in CX
    mov     ax,dx          ;First divide the HighDividend
    xor     dx,dx          ;Setup for division DX:AX / BX
    div     bx             ; -> AX is HighQuotient, Remainder is re-used
    xchg    ax,cx          ;Temporarily move it to CX restoring LowDividend
    div     bx             ; -> AX is LowQuotient, Remainder DX=[0,9]
    push    dx             ;(1) Save remainder for now
    mov     dx,cx          ;Build true 32-bit quotient in DX:AX
    or      cx,ax          ;Is the true 32-bit quotient zero?
    jnz     .a             ;No, use as next dividend
    pop     dx             ;(1a) First pop (Is digit for sure)
.b: add     dl,"0"         ;Turn into character [0,9] -> ["0","9"]
    mov     ah,02h         ;DOS.DisplayCharacter
    int     21h            ; -> AL
    pop     dx             ;(1b) All remaining pops
    cmp     dx,bx          ;Was it the sentinel?
    jb      .b             ;Not yet

Visualización del número firmado de 32 bits contenido en DX: AX

El procedimiento es el siguiente:

Primero averigüe si el número firmado es negativo probando el bit de signo.
Si es así, niegue el número y genere un carácter "-", pero tenga cuidado de no destruir el número en DX:AX en el proceso.

El resto del fragmento es el mismo que para un número sin signo.

    test    dx,dx          ;Sign bit is bit 15 of high word
    jns     .a             ;It''s a positive number
    neg     dx             ;/
    neg     ax             ; | Negate DX:AX
    sbb     dx,0           ;/
    push    ax dx          ;(1)
    mov     dl,"-"
    mov     ah,02h         ;DOS.DisplayCharacter
    int     21h            ; -> AL
    pop     dx ax          ;(1)
.a: mov     bx,10          ;CONST
    push    bx             ;Sentinel
.b: mov     cx,ax          ;Temporarily store LowDividend in CX
    mov     ax,dx          ;First divide the HighDividend
    xor     dx,dx          ;Setup for division DX:AX / BX
    div     bx             ; -> AX is HighQuotient, Remainder is re-used
    xchg    ax,cx          ;Temporarily move it to CX restoring LowDividend
    div     bx             ; -> AX is LowQuotient, Remainder DX=[0,9]
    push    dx             ;(2) Save remainder for now
    mov     dx,cx          ;Build true 32-bit quotient in DX:AX
    or      cx,ax          ;Is the true 32-bit quotient zero?
    jnz     .b             ;No, use as next dividend
    pop     dx             ;(2a) First pop (Is digit for sure)
.c: add     dl,"0"         ;Turn into character [0,9] -> ["0","9"]
    mov     ah,02h         ;DOS.DisplayCharacter
    int     21h            ; -> AL
    pop     dx             ;(2b) All remaining pops
    cmp     dx,bx          ;Was it the sentinel?
    jb      .c             ;Not yet

¿Necesitaré rutinas separadas para diferentes tamaños de números?

En un programa en el que necesita mostrar ocasionalmente AL , AX o DX:AX , puede incluir la versión de 32 bits y usar los siguientes pequeños wrappers para los tamaños más pequeños:

; IN (al) OUT ()
DisplaySignedNumber8:
    push    ax
    cbw                    ;Promote AL to AX
    call    DisplaySignedNumber16
    pop     ax
    ret
; -------------------------
; IN (ax) OUT ()
DisplaySignedNumber16:
    push    dx
    cwd                    ;Promote AX to DX:AX
    call    DisplaySignedNumber32
    pop     dx
    ret
; -------------------------
; IN (dx:ax) OUT ()
DisplaySignedNumber32:
    push    ax bx cx dx
    ...

Alternativamente, si no le importa el golpeteo de los registros AX y DX use esta solución de caída:

; IN (al) OUT () MOD (ax,dx)
DisplaySignedNumber8:
    cbw
; ---   ---   ---   ---   -
; IN (ax) OUT () MOD (ax,dx)
DisplaySignedNumber16:
    cwd
; ---   ---   ---   ---   -
; IN (dx:ax) OUT () MOD (ax,dx)
DisplaySignedNumber32:
    push    bx cx
    ...