assembly - Cómo usar cadenas en emu8086

emulation

Question

Necesito ayuda con cadenas en emu8086. He inicializado una cadena:

str1 db "0neWord"

Y tengo una cadena vacía:

str2 db ?

Ahora necesito verificar todas las letras en str1 y copiarlas en str2 , pero si la letra en str1 es 0, necesito reemplazarla con O. Si no, solo necesito copiar la letra.

¿Cómo puedo hacer esto?

Answer 1

Hay múltiples formas de hacerlo. Aquí hay unos ejemplos:

1) Con instrucciones de cuerda:

.model small
.data
str1 db "0neWord$"
size equ $-str1
str2 db size dup ('''')
.code
main:
mov ax, @data
mov ds, ax
mov cx, size
cld ; DF might have been set, but we want lodsb to go forwards
lea si, str1
mov ax, 0
mov bx, 0
copyStr:
lodsb ;str1 to al
cmp al, ''0''
je alterChar
mov str2[bx], al
jmp continue
alterChar:
mov str2[bx], ''o''
continue:
inc bx
loop copyStr
mov str2[bx], ''$''
mov ah, 09h
lea dx, str2
int 21h
mov ah, 04ch
int 21h
end main

2) Sin instrucciones de cuerda:

.model small
.data
str1 db "0neWord$"
str2 db ?
.code
main:
mov ax, @data
mov ds, ax
mov si, 0
call copyStr
mov ah, 09h
lea dx, str2
int 21h
mov ah, 04ch
int 21h
copyStr proc
mov bx, 0
compute:
mov bl, str1 [si]
cmp bl, ''0''
je alterChar
mov str2[si], bl
jmp continue
alterChar:
mov str2 [si], ''o''
continue:
inc si
cmp str1[si], ''$''
je return
jmp compute
return:
mov str2[si], ''$''
ret
copyStr endp
end main

Instrucciones de LODSB puedes aprender más sobre las instrucciones de cuerdas desde here

3) Con lodsb / stosb y simplificado / optimizado:

.model small
.data
str1 db "0neWord$"
size equ $-str1
str2 db size dup ('''')
.code
main:
mov ax, @data
mov ds, ax
mov es, ax ; stosb stores to [es:di]
mov si, OFFSET str1
mov di, OFFSET str2
cld ; make sure stosb/lodsb go forwards
; copy SI to DI, including the terminating ''$''
copyStr: ; do {
lodsb ; str1 to al
cmp al, ''0''
je alterChar
doneAlteration:
stosb ; al to str2
cmp al, ''$''
jne copyStr ; } while(c != ''$'')
mov ah, 09h ; print implicit-length string
mov dx, OFFSET str2
int 21h
mov ah, 04ch ; exit
int 21h
alterChar:
mov al, ''o''
;jmp doneAlteration
stosb
jmp copyStr
end main

Answer 2

str2 db ? No es una cadena vacía. db significa "definir byte" , y eso ? significa un solo byte no inicializado.

El db "0neWord" es la conveniencia del ensamblador, se compilará en series de bytes definidos como ''0'', ''n'', ''e'', ..., ''d'' . No existe el tipo de "cadena" en el ensamblador, todo se compila en código de máquina, que se puede ver como una serie de bytes. El "tipo" de datos almacenados en la memoria depende de las instrucciones utilizadas para acceder a ellos, pero en la memoria todo es solo una serie de bytes y puede verse como tal.

Probablemente sea un buen momento para que compruebe la documentación del depurador emu8086 y mire la memoria en la dirección str1 después de cargar el código en el depurador, para ver cómo se compiló.

Tan pronto como copie el segundo byte de str1 a str2 , comenzará a sobrescribir alguna memoria que no esperaba sobrescribir.

Para asignar un búfer de memoria de tamaño fijo, puede usar, por ejemplo, str2 db 100 DUP(?) Haciendo 100 veces ? definición a db , reservando así 100 bytes de memoria allí, los siguientes bytes de código de máquina en la misma sección se compilarán más allá de la dirección str2+100 .

Para hacer cualquier cosa con str1 "cadena" necesita saber:

1) su dirección en la memoria, el ensamblador x86 tiene muchas formas de obtenerlo, pero las dos más sencillas son:

• mov <r16>,OFFSET str1 (r16 es cualquier registro 16b)
• lea <r16>,[str1] (hace lo mismo en este caso)

2) su tamaño o estructura. No colocó ninguna estructura allí, como las cadenas terminadas en nulo tienen un byte con valor 0 al final, o DOS int 21h, ah=9 para mostrar la cadena espera que la cadena termine con el signo de dólar ''$'' , etc. Por lo tanto, necesita Al menos tamaño. Y la directiva EQU del ensamblador, y la "posición actual" se pueden usar para calcular el tamaño de str1 esta manera:

str1 db "0neWord"
str1size EQU $-str1 ; "$" is assemblers "current_address" counter

Hm, intenté verificar esto primero, leyendo algunos documentos, pero es muy difícil para mí encontrar una buena documentación completa de emu8086 (encontré algo como "referencia", y me falta por completo la descripción de las directivas del ensamblador).

Me pregunto por qué tanta gente todavía aterriza en esto, en lugar de linux + nasm / similar, que son completamente gratuitos, de código abierto y documentados.

Esperemos que emu8086 funcione como MASM / TASM y que todavía recuerde esa sintaxis correctamente, entonces la definición de tamaño mencionada anteriormente debería funcionar. De lo contrario, consulte sus ejemplos / documentos.

Finalmente, cuando tiene dirección, tamaño y un búfer de destino lo suficientemente grande (de nuevo para cargar su dirección, puede usar OFFSET o lea en emu8086), puede codificar su tarea, por ejemplo, de esta manera:

 ; pseudo code follows, replace it by actual x86 instructions
; and registers as you wish
; ("r16_something" means one of 16b register, r8 is 8b register)
lea r16_str1,[str1] ; load CPU with address of str1
mov r16_counter,str1size ; load CPU with str1 size value
lea r16_str2,[str2] ; load address of target buffer
loop_per_character:
mov r8_char,[r16_str1] ; read single character
cmp r8_char,''0''
jne skip_non_ascii_zero_char
; the character is equal to ASCII ''0'' character (value 48)
mov r8_char,''O'' ; replace it with ''O''
skip_non_ascii_zero_char:
; here the character was modified as needed, write it to str2 buffer
mov [r16_str2],r8_char
; make both str1/2 pointers to point to next character
inc r16_str1
inc r16_str2
; count down the counter, and loop until zero is reached
dec r16_counter
jnz loop_per_character
; the memory starting at "str2" should now contain
; modified copy of "str1"
; ... add exit instructions ...

Hmm ... resulta que el "pseudocódigo" es un código x86 completo, solo tiene que asignar registros reales a los pseudocódigos y reemplazarlos en todas partes en la fuente.

Traté de poner comentarios muy extensos (desde mi punto de vista), para que pueda entender cada instrucción utilizada. Debe consultar cada uno con la guía de referencia de instrucciones de Intel, leerlo en forma cruzada con cualquier tutorial / lección que tenga disponible para ensamblar, hasta que sienta que comprende lo que es registro, memoria, etc.

También depure la instrucción de código por instrucción, verificando el estado de la CPU (valores de registro, indicadores) y el contenido de la memoria después de cada instrucción, para tener una idea de cómo funciona.