En lenguaje ensamblador, es mejor escribir el código completo del programa. ¡La clave es que el código de las dos subrutinas debe estar comentado! ! ! ¡Gracias! Buscando puntuaciones altas
;?Los primeros cinco dígitos ingresados son el bit de signo. Cuando el bit de signo es 0, es un número positivo; de lo contrario, es un número negativo.
;?Los últimos cuatro. los dígitos son cálculos de parámetros El número, el resultado de salida es el mismo que el anterior
supongamos cs: codesg, ds: datasg, ss: stacksg
datasg?segment
input1 db '¿Entrada?¿primer?número !?', '$'
input2 db '¿Entrada?¿segundo?número!?', '$'
resultado db '¿resultado? is?:?', '$'
;? El número 21 interrumpe la rutina número 10 para almacenar los datos de entrada
add1 db 6 ;?
db ;?Realmente recibido El número de caracteres, excluyendo el último retorno de carro
db 6?dup?(?);?Almacena los caracteres ingresados, terminando con el retorno de carro
add2 db 6
db ?
db 6?dup?(?)
num dw ;?Almacenamiento de resultados intermedios
firmar db ;?Dos números El bit de signo de la suma
suma dw 10?dup?(?);?La suma de dos números
datasg?ends
stacksg?segmento
stacksg?ends
codesg?segmento inicio: mov ax, datasg
mov ds, hacha
lea dx, input1
mov ah, 9
int 21h
;? Leer el primer sumando
mov dx, offset?add1
mov ah, 10
int 21h
; ?Tomar la posición del cursor, ah es Fila, al es columna
mov ah, 3
mov bh, 0
int 10h
;? Establecer la posición del cursor
mov ah, 2
mov bh, 0
inc dh
mov dl, 0
int 10h
lea dx, input2
mov ah, 9
int 21h
;?Leer el segundo sumando
mov dx, offset?add2
mov ah, 10
int 21h
;? Obtener la posición del cursor, ah es la fila, al es la columna
mov ah, 3
mov bh, 0
int 10h
;?Establecer posición del cursor
mov ah, 2
mov bh, 0
inc dh
mov dl, 0
int 10h
<
/p>
lea bx, add1
mov ax, [bx 1]
mov ah, 0
dec ax;? , Obtener el número de números
empujar ax;?Empujar el número de caracteres
agregar bx, 3
empujar bx;?Empujar la primera dirección del string
call DeciToBina
lea bx, add1
mov dl, [bx 2];? Obtener el bit de signo del número de entrada
cmp dl, '0'
jz posi1
neg ax ;?El bit de signo no es 0, lo que significa un número negativo, por lo que el complemento es un número negativo
posi1:
lea bx, num
mov [bx], ax;? Guardar el primer número
lea bx, add2
mov ax, [ bx 1]
mov ah, 0
dec ax
empujar ax;? p>
agregar bx, 3
empujar bx;? Empujar la primera dirección de la cadena
llamar a DeciToBina
lea bx, agregar2
mov dl, [bx 2]
cmp dl, '0'
jz posi2
neg ax
posi2 :
lea bx, num
add [bx], ax;? Guardar el resultado de sumar dos números
lea dx, result
mov ah, 9
int 21h
lea bx, num
mov ax, [bx];? suma de dos números
empujar ax;?Guardar una copia de seguridad
;?El bit de signo del resultado de la prueba
y ax, 1000000000000000b;?Tomar el más alto bit
neg ax
sbb ax, ax
neg ax;? El valor de ax es 0 o 1
agregar ax, 30h;? Convertir a código ascii de 0 o 1
lea bx, sign
mov [bx], al; Almacenar el bit de signo
pop ax;? Sacar la copia de seguridad
cmp byte?ptr?[bx], 30h;? ¿El resultado de la prueba es un número positivo?
jz posi
neg ax;? Si no es positivo, entonces toma el valor absoluto del complemento
posi:
push ax;?Push en el segundo parámetro, ¿cuál es el valor absoluto del número hexadecimal a convertir?
p>lea di, sum
push di;? Empuje el primer parámetro y reciba el búfer de el resultado
llama a BinaToDeci
lea dx, firma
mov ah, 9
int 21h
mov hacha, 4c00h
int 21h
;?******** ************************************************** * *************
;?Función: convierte números hexadecimales en caracteres decimales para la salida
;?Forma: void?BinaToDeci(?[ buff],?int?), empuje hacia la pila de derecha a izquierda
;?Parámetro 1: ¿El primer parámetro?[buff]: La dirección del buffer para recibir el resultado
;?Parámetro 2: El segundo parámetro int?: el número hexadecimal a convertir
;?Valor de retorno: Ninguno, guardado directamente en la memoria
?******* **************************************** *********** **************
BinaToDeci proc
push pb
mov bp, sp
push ax
push bx
push cx
push dx
mov cx, 0 ;? Inicializa el contador y registra el número de ciclos, es decir, el número de dígitos decimales
mov ax, [bp 6];? Saque el número hexadecimal entrante que se va a convertir y solo agregue 6 al llamar en el segmento, llamada entre segmentos suma 8
;? Calcula cada dígito decimal y guárdalo en la pila
bina_next:
xor dx, dx
mov bx , 10
div bx
push dx
inc cx
cmp ax, 0
jz bina_end
jmp bina_next
bina_end:
mov bx, [bp 4];? ¿Eliminar el búfer que contiene números decimales Primera dirección del área?
;? Convierte cada dígito decimal en código ascii y lo almacena en el área de memoria especificada
bina_next2:
pop ax
p>agregar ax, 30h
mov byte?ptr?[bx], al
inc bx
bucle bina_next2
;?La cadena termina con '$', que se utiliza para llamar a la rutina No. 9 en medio de la rutina No. 21
mov byte?ptr?[bx],'$'< / p>
pop dx
pop cx
pop bx
pop hacha
mov sp, bp
pop bp
ret 4
BinaToDeci endp
;?****************** ************************************************* ***** **
;?************************************ ****** *************************
*******
;?Función: convierte caracteres decimales en números hexadecimales para realizar cálculos
;?Forma: void?DeciToBina(?[ buff],?int?) , empujado a la pila de derecha a izquierda
;?Parámetro 1: ¿El primer parámetro?[buff]: la primera dirección del búfer donde se coloca la cadena de dígitos decimales
p >
;?Parámetro 2: el segundo parámetro int?: el número de caracteres en la cadena decimal
;?Valor de retorno: número hexadecimal
;?**** ************************************************** ************************
DeciToBina proc
push bp
mov bp, sp
empujar bx
empujar cx
empujar dx
empujar si
mov bx, [ bp 4 ];?Obtener la primera dirección del búfer de cadena decimal
mov cx, [bp 6];?El número de caracteres en el búfer de cadena decimal
xor ax, ax
p>
;?Revierta el código ascii a un número y guárdelo en la pila
deci_next:
mov al, byte?ptr?[bx ] ;? Tomar los caracteres en el buffer en secuencia
sub al, 30h
push ax
inc bx
loop deci_next
mov cx, [bp 6];? Obtener el número de caracteres nuevamente
xor ax, ax
xor dx, dx
mov bx, 1;? usado como multiplicador
xor si, si
;? multiplica cada bit y luego acumula para obtener un valor hexadecimal
;? resultado = Lugar de las unidades*1 Lugar de las decenas*10 Lugar de las centenas*100 Lugar de las millares*1000
deci_next1:
pop ax;? p>
mul bx;? Multiplicar
sumar si, ax;? Acumular el resultado
;? Calcular el multiplicador para la siguiente multiplicación
mov ax, bx
mov bx, 10
mul bx
mov bx, ax
bucle deci_next1
;? Almacenar el resultado en ax como valor de retorno
mov ax, si
pop si
pop dx
pop cx
pop bx
mov sp, bp
pop bp
ret 4
DeciToBina endp
;?********************************* *********** **********************************
codesg?ends
end?start?<
/p>
============================================= == =========
prueba masm5 aprobada