Lenguajes de Interfaz

Unidad II: Programación Básica

El lenguaje ensamblador tiene dos formatos de programas, el
completo y el formato reducido o directivas punto. A
continuación presentamos un ejemplo de cada uno:
SSEG SEGMENT STACK
;Definición del stack
SSEG ENDS

ESEG SEGMENT
;Definición de datos extra
ESEG ENDS

DSEG SEGMENT
;Definición de datos
DSEG ENDS

CSEG SEGMENT 'CODE'

;Definición de código
CSEG ENDS
.MODEL ;Especifica el modelo de memoria a usar
.STACK ;Define inicio y fin del stack (default 1024 bytes)
.DATA ;Define inicio y fin del segmento de datos
.CODE ;Define inicio y fin del segmento de código
Una directiva es una pseudoinstrucción (una instrucción no
ejecutable o que no genera código) que son utilizadas para reservar
espacio de memoria, declarar constantes, variables, estructuras de
datos y otras actividades.

Directivas de definición de datos:

DB (BYTE) ;Define un dato de un byte

DW (WORD) ;Define un dato de dos bytes
DD (DWORD) ;Define un dato de cuatro bytes
DF (FWORD) ;Define un dato de seis bytes
DQ (QWORD) ;Define un dato de ocho bytes
DT (TBYTES) ;Define un dato de diez bytes
EQU ;Define una constante
= ;Define un símbolo

Profr. Jaime A. Félix M. 27/05/2018 17:25:20

Ejemplos.-

DefineB BYTE 10, 4, 10H

DefineW WORD 100, -5
DefineD DWORD 3 * 20, 0FFFFDH
DefineQ QWORD 4D47H, 32572
Mensaje BYTE 'hola'
Otros BYTE ?, 52, ?
Arreglo1 BYTE 2 DUP ( 0, 1, 2, ? )
Arreglo2 BYTE 100 DUP ( ? )
Arreglo3 BYTE 3 DUP ( 4 DUP ( 8 ) )

Profr. Jaime A. Félix M. 27/05/2018 17:25:20

Ejemplos de EQU y =

Estas directiva se utilizan para asignar expresiones

constantes a algunos identificadores. La diferencia entre usar
la directiva EQU y el operador = consiste en que los datos
asignados con EQU no podrán variar, mientras los datos
asignados con = sí podrán variar.

Constante EQU 256

Data EQU 7
Alfa EQU Data – 2 ;Se le asigna un 5 a Alfa
Numero = 10

Profr. Jaime A. Félix M. 27/05/2018 17:25:20

 Dibuje el mapa de memoria de las siguientes definiciones de variables
en lenguaje ensamblador. Suponga que la dirección de inicio es la
posición hexadecimal 10001000H.

Primera BYTE 15
Segunda WORD -123
Tercera DWORD 45678
Cuarta QWORD 987654
Nombre BYTE “Juan Pérez”
Longitud EQU $ - Nombre
PrimerVector BYTE 1, 9, 2, 8, 3, 7, 4, 6, 5
SegundoVector WORD 2 DUP ( “Vacio” )
Elementos EQU 10
TercerVector DWORD Elementos DUP ( 0 )
Ultimo WORD -32768

Nota: $ es el contador actual de localidades

Una instrucción en lenguaje ensamblador contiene los
siguientes cuatro campos:

[NOMBRE] OPERADOR [OPERANDOS] [COMENTARIOS]

Nombre.- Este campo es opcional y cuando está presente es

el primer campo de la instrucción. Se utiliza para representar
valores y puede ser usado como:

Etiqueta.- Representa código

Variable.- Representa datos
Símbolo.- Representa constantes
Los nombres se pueden formar con los siguientes caracteres:
A..Z, a..z, 0..9, ?, _, $. Puede empezar con cualquier carácter
excepto dígitos y sólo son válidos los primeros 31 caracteres.

Operador.- Significa cualquier instrucción o directiva del

ensamblador.

Operandos.- Representan los operandos destino y fuente

cuando necesitan ser definidos en la instrucción especificada.

Comentarios.- Los comentarios inician con un punto y coma

(;) y pueden aparecer por sí solos en una línea o al final de
una instrucción.
2.1 Instrucciones lineales.

2.1.1 Movimiento
2.1.2 Pila
2.1.3 Matemáticos
2.1.4 Ajuste
2.1.5 Comparación
MOV Destino, Fuente ;Move

La instrucción MOV transfiere (es decir, copia) el operando fuente al

operando destino. El operando fuentes permanece sin cambios. Los
dos operandos deben ser del mismo tamaño.

Combinaciones válidas:

MOV {Registro/Memoria}, {Registro/Memoria/Inmediato}

Combinaciones no válidas:

Memoria, memoria
Registro segmento, registro segmento
Registro segmento, inmediato
LEA Registro32, Memoria ;Load effective address

Carga en el registro especificado la dirección efectiva de un

operando de memoria.

Ejemplo.-

Men01 BYTE 'Hola'

Men02 BYTE 'Adios'
--------
--------
--------
LEA ESI, Men01
LEA EDI, Men02
 RAM
DS -> H 00000201H
o 00000202H
l 00000203H
a 00000204H
A 00000205H
d 00000206H
i 00000207H
o 00000208H
s 00000209H

ESI = 00000201H
EDI = 00000205H
LDS Registro32, Memoria
LES Registro32, Memoria

Almacena un puntero lejano especificado por el operando

memoria. La parte del segmento se almacena en el registro DS
o ES y la parte del desplazamiento se almacena en Registro32.

Un puntero es una variable que contiene una dirección de

memoria. Comúnmente, esta dirección es la posición de otra
variable de memoria (formato ssss:dddddddd)
Ejemplo.-

Men01 BYTE ‘Hola’

Dir_M FWORD Men01
--------
--------
--------
LDS EAX, Dir_M
LES EBX, Dir_M

Si originalmente DS = 1000H y ES = 2000H

 RAM
DS -> H 01000201H
o 01000202H
l 01000203H
a 01000204H
01H 01000205H
02H 01000206H
00H 01000207H
01H 01000208H
00H 01000209H
10H 0100020AH

Entonces:

EAX = 01000201H y DS = 1000H (con LDS)

EBX = 01000201H y ES = 1000H (con LES)
XCHG Destino, Fuente ;Exchange

La instrucción XCHG intercambia los valores de los operandos

destino y fuente.

Combinaciones válidas:

XCHG {Registro/Memoria}, {Registro/Memoria}

Combinaciones no válidas:

Memoria, memoria
Ejercicio.- Determinar cual de las siguientes instrucciones es
correcta. Indique los errores en las instrucciones incorrectas.

1. MOV EBX, 358

2. MOV AX, BL
3. MOV CX, [EBX + ESI]
4. LEA DH, Dato1
5. MOV AH, 01001101B
6. MOV ESI, ESP
7. LEA DS, Dato2
8. LES AH, BX
9. MOV CX, 5358H
10. XCHG CH, CL
PUSH Fuente
POP Destino
PUSHA
POPA
PUSHAD
POPAD
PUSHF
POPF
PUSHFD
POPFD
La instrucción PUSH coloca el operando fuente en la pila. El
registro ESP es decrementado en 2 o 4 y el operando fuente es
almacenado en la posición SS:ESP. El operando fuente debe
ser un registro o un valor de memoria de 16 o 32 bits.

La instrucción POP saca el valor en el tope de la pila y lo

coloca en el operando destino. El valor en la posición SS:ESP
se copia al operando destino y el registro ESP es incrementado
en 2 o 4. El operando destino debe ser un registro o un valor
de memoria de 16 o 32 bits.
La instrucción PUSHA coloca 8 registros en la pila. Los
registros son colocados en el siguiente orden: AX, CX, DX, BX,
SP, BP, SI, DI.

La instrucción POPA saca los 8 registros de la pila. Los

registros son sacados en orden inverso: DI, SI, BP, SP, BX, DX,
CX, AX.

La instrucción PUSHAD coloca 8 registros en la pila. Los

registros son colocados en el siguiente orden: EAX, ECX, EDX,
EBX, ESP, EBP, ESI, EDI.

La instrucción POPAD saca los 8 registros de la pila. Los

registros son sacados en orden inverso: EDI, ESI, EBP, ESP,
EBX, EDX, ECX, EAX.
La instrucción PUSHF coloca el registro de banderas en la pila.

La instrucción POPF saca el valor de 16 bits de la pila y lo

coloca en el registro de banderas.

La instrucción PUSHFD coloca el registro de banderas

extendido en la pila.

La instrucción POPFD saca el valor de 32 bits de la pila y lo

coloca en el registro de banderas extendido.
El lenguaje ensamblador maneja tres tipos de instrucciones
aritméticas:

1. Aritmética binaria
2. Aritmética empacada en BCD
3. Aritmética desempacada en BCD
 Investigar que son los números BCD.

 1 Hoja manuscrita.

 Fecha:
a).- Adición entera:

ADD Destino, Fuente ;Add

ADC Destino, Fuente ;Add with carry

La instrucción ADD suma el operando fuente con el

operando destino y deja el resultado en el operando destino.

La instrucción ADC suma el operando fuente, el

operando destino y el valor de la bandera de acarreo y deja el
resultado en el operando destino.
Combinaciones válidas:

ADD/ADC {Registro/Memoria},{Registro/Memoria/Inmediato}

Combinaciones no válidas:

Memoria, memoria

Banderas afectadas: OSZAPC

b).- Substracción entera:

SUB Destino, Fuente ;Subtract

SBB Destino, Fuente ;Subtract with borrow

La instrucción SUB resta el operando fuente del

operando destino y deja el resultado en el operando destino.

La instrucción SBB toma en cuenta el valor de la

bandera de acarreo antes de hacer la resta.
Combinaciones válidas:

SUB/SBB {Registro/Memoria}, {Registro/Memoria/Inmediato}

Combinaciones no válidas:

Memoria, memoria

Banderas afectadas: OSZAPC

El comportamiento de estas dos instrucciones es como sigue:

SUB => Operando destino

+ (Complemento a dos de operando fuente)
-------------------------------------
Operando destino

SBB => Operando destino

+ (Complemento a dos de operando fuente + CF)
------------------------------------------
Operando destino
c).- Instrucciones con operando simple:

NEG Operando ;Negation (2 - complement)

INC Operando ;Increment
DEC Operando ;Decrement

La instrucción NEG obtiene el complemento a dos del

operando. La instrucción INC incrementa en 1 el operando. La
instrucción DEC decrementa en 1 el operando.

Combinaciones válidas:

NEG/INC/DEC {Registro/Memoria}
d).- Extensión del signo:

CBW ;Convert byte to word

CWD ;Convert word to doubleword
CWDE ;Convert word to doubleword
CDQ ;Convert doubleword to quadword
CDQE ;Cobvert doubleword to quadword

La instrucción CBW convierte el valor del byte en el

registro AL en la palabra en el registro AX, extendiendo el
valor del signo de AL a todos los bits de AH.
La instrucción CWD convierte el valor de la palabra en el
registro AX en una palabra doble en los registros DX:AX,
extendiendo el bit del signo de AX a todos los bits de DX.

La instrucción CWDE convierte el valor de la palabra en el

registro AX en una palabra doble en el registro EAX,
extendiendo el bit del signo de AX a los 16 bits altos de EAX.

La instrucción CDQ convierte el valor de la palabra doble en el

registro EAX en una palabra cuádruple en los registros
EDX:EAX, extendiendo el bit del signo de EAX a todos los bits
de EDX.

La instrucción CDQE convierte el valor de la palabra doble en

el registro EAX en una palabra cuádruple en el registro RAX,
extendiendo el bit del signo de EAX a los 32 bits altos de RAX.
e).- Multiplicación y división:

La multiplicación y división en el lenguaje ensamblador se

realizan usando el siguiente formato:

Multiplicación:

AL AX EAX
X operando de 8 bits X operando de 16 bits X operando de 32 bits
AX DX:AX EDX:EAX
 División:

AL AX
Operando de 8 bits AX Operando de 16 bits DX:AX
AH DX

EAX
Operando de 32 bits EDX:EAX
EDX
 MUL Operando ;Multiplicación sin signo
IMUL Operando ;Multiplicación con signo
DIV Operando ;División sin signo
IDIV Operando ;División con signo

Nota.- Operando debe ser registro o memoria.

Números BCD.-

BCD BINARIO
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
Los números BCD pueden ser empacados o desempacados. En
los números BCD empacados se pueden almacenar dos dígitos
en un byte (8 bits) y en los números BCD desempacados sólo
se puede almacenar un dígito por byte.

Ejemplo.-

BCD Empacado BCD

Desempacado
18 1 8

0001 1000 00000001 00001000

Suma en BCD empacada.-

a) 24 00100100
+ 13 00010011
---- ---------
37 00110111

b) 19 00011001
+ 24 00100100
--- ---------
3D 00111101

Nota.- Cuando un dígito está en el rango de A – F hay que sumar un

6.
 00111101
00000110
---------
43 01000011

c) 19 00011001
+28 00101000
--- ---------
mal 41 01000001

Nota.- Cuando se activa la bandera de AF (acarreo auxiliar)

hay que sumar un 6.
 01000001
00000110
---------
47 01000111
Resta en BCD empacada.-

a) 24 00100100
-13 00010011
--- ---------
00100100
11101101 (Complemento a dos del 13 BCD)
---------
11 00010001
b) 24 00100100
-18 00011000
--- ---------
00100100
11101000 (Complemento a dos del 18 BCD)
---------
0C 00001100

Nota.- Cuando un dígito está en el rango de A – F hay que

restar un 6.
00001100
11111010 (Complemento a dos del 6)
---------
06 00000110
c) 11 00010001
-09 00001001
--- ---------
00010001
11110111 (Complemento a dos del 09 BCD)
---------
mal 08 00001000

Nota.- Cuando se activa la bandera de AF (acarreo auxiliar)

hay que restar un 6.
00001000
11111010 (Complemento a dos del 6)
---------
02 00000010
 DAA ;Decimal adjust after addition
DAS ;Decimal adjust after subtraction

La instrucción DAA ajusta el registro AL después de

una suma en BCD empacada. La instrucción DAS ajusta el
registro AL después de una resta en BCD empacada.

Ejemplo.-

MOV AL, 89H

MOV AH, 32H
ADD AL, AH
DAA
 AAA ;ASCII adjust after addition
AAS ;ASCII adjust after subtraction
AAM ;ASCII adjust after multiply
AAD ;ASCII adjust before division

Las instrucciones AAA, AAS y AAM ajustan al registro

AL después de una suma, resta o multiplicación en BCD
desempacada. La instrucción AAD ajusta el registro AL antes
de una división en BCD desempaca.
 CMP Operando1, Operando2 ;Compare
TEST Operando1, Operando2 ;Test

La instrucción CMP compara dos operandos como una

prueba para un salto condicional subsecuente. CMP hace la
comparación restando el operando2 del operando1 y
estableciendo el registro de banderas de acuerdo al resultado.

La instrucción CMP es lo mismo que la instrucción SUB,

excepto que el resultado no es almacenado.
 La instrucción TEST prueba bits específicos de un
operando y establece el registro de banderas de acuerdo al
resultado, para ser usados en un salto condicional
subsecuente.

La instrucción TEST es lo mismo que la instrucción

AND, excepto que el resultado no es almacenado.

Combinaciones válidas:

CMP/TEST {Registro/Memoria}, {Registro/Memoria/Inmediato}

2.2 Saltos.

2.2.1 Incondicional
2.2.2 Condicional
 JMP Destino ;Jump

La instrucción JMP transfiere el control del programa a

la dirección especificada por el operando destino.

Nota.- El operando destino puede ser una etiqueta, un

registro o un valor de memoria.

Ejemplos.-

JMP Etiqueta
JMP SHORT Etiqueta ;Salta distancias de –128 bytes a 127 bytes
JMP NEAR PTR Etiqueta ;Salta distancias de –32,768 bytes a 32,767 bytes
JMP FAR PTR Etiqueta ;Salta a otro segmento
Antes de ver las instrucciones de transferencia condicional, se darán
los significados de las iniciales utilizadas en estas instrucciones:

A => Above ;Usadas con

B => Below ;números sin signo
N => Not
E => Equal
G => Greater than ;Usadas con
L => Less than ;números con signo

S => Sign
C => Carry
O => Overflow
P => Parity
A continuación vienen las treinta instrucciones de salto condicional y
las banderas que deben ser verificadas antes de saltar:

Instrucción Bandera verificada

JB/JNAE CF = 1
JAE/JNB CF = 0
JBE/JNA CF = 1 o ZF = 1
JA/JNBE CF = 0 y ZF = 0
JE/JZ ZF = 1
JNE/JNZ ZF = 0
JL/JNGE SF <> OF
JGE/JNL SF = OF
JLE/JNG ZF = 1 o SF <> OF
JG/JNLE ZF = 0 y SF = OF
 La siguiente tabla describe el significado de las cuatro banderas utilizadas en el salto condicional:

OF (Overflow)
1 – El resultado esta fuera del rango de los números con signo
0 – El resultado esta dentro del rango de los números con signo

 CF (Carry)
Acarreo del (prestamo del ) bit de mayor orden.

1 – El resultado esta fuera del rango de números sin signo

0 – El resultado está dentro del rango de números sin signo

 SF (Sign)
El bit de mayor orden del resultado.

1 – Número con signo negativo.

0 – Número con signo positivo.

 ZF (Zero)

1 – El resultado es cero.
0 – El resultado es diferente de cero.
Instrucción Bandera verificada
JS SF = 1
JNS SF = 0
JC CF = 1
JNC CF = 0
JO OF = 1
JNO OF = 0
JP/JPE PF = 1
JNP/JPO PF = 0

Nota.- Los saltos condicionales son cortos (-128 a 127 bytes) o

cercanos (-32,768 a 32,767 bytes) en procesadores 386/486/586.
2.3 Tipos de ciclos.
 LOOP Etiqueta
LOOPNZ/LOOPNE Etiqueta ;Ciclos
LOOPZ/LOOPE Etiqueta ;condicionales

La instrucción LOOP decrementa automáticamente el registro ECX. Si

el registro ECX no es cero, salta a la dirección especificada por etiqueta.

Las instrucciones LOOPNZ/LOOPNE decrementan automáticamente

el registro ECX. Si el registro ECX no es cero y la bandera de cero (ZF) está
apagada, salta a la dirección especificada por etiqueta.

Las instrucciones LOOPZ/LOOPE decrementan automáticamente el

registro ECX. Si el registro ECX no es cero y la bandera de cero (ZF) está
encendida, salta a la dirección especificada por etiqueta.

Nota.- Etiqueta sólo puede especificar un salto corto (de –128 bytes).
Nota.- Ninguna instrucción de ciclo afecta el registro de banderas.
Ejemplos.-
a)
MOV ECX, N
CICLO:
------
------
------
LOOP CICLO

b)
MOV ESI, -1
MOV ECX, 100
CICLO:
INC ESI
CMP Tabla[ESI], 10
LOOPNE CICLO
;Busca en el arreglo
;Tabla el valor 10
2.4 Operadores lógicos.
 AND Destino, Fuente ;AND lógico
OR Destino, Fuente ;OR
XOR Destino, Fuente ;OR exclusivo
NOT Destino ;Negación (complemento a 1)

Las instrucciones lógicas efectúan las operaciones lógicas

correspondientes con los bits de los operandos destino y fuente; y deja el
resultado en los bits del operando destino.

Combinaciones válidas:

AND/OR/XOR {Registro/Memoria}, {Registro/Memoria/Inmediato}

NOT {Registro/Memoria}
Las tablas de verdad de las instrucciones lógicas son las siguientes:

AND: D F D OR: D F D XOR: D F D NOT: D D

0 0 0 0 0 0 0 0 0 0 1
0 1 0 0 1 1 0 1 1 1 0
1 0 0 1 0 1 1 0 1
1 1 1 1 1 1 1 1 0
Uso de las instrucciones lógicas:

Prender un bit.-
AH = 11110000
Poner un 1 en el tercer bit
OR AH, 00001000B

Apagar un bit.-
AH = 10101010
Poner un 0 en el séptimo bit
AND AH, 01111111B
Uso de las instrucciones lógicas:
Preguntar si un bit está prendido o apagado.-
AH = 11001100
¿El bit #2 está prendido?
AND AH, 00000100B
JNZ PRENDIDO
JZ APAGADO

Uso de XOR.-
La instrucción XOR tiene la característica que después de haberla aplicado
dos veces con el mismo valor, se recupera el valor original:
AH= 11111111
XOR 01010101
RES. 10101010
XOR 01010101
ORIG. 11111111
2.5 Desplazamientos.

2.5.1 Lineal
2.5.2 Circular
 SHL Destino , Contador
SAL Destino , Contador
SHR Destino , Contador
SAR Destino , Contador

Estas instrucciones desplazan los bits en el operando destino el número de

veces especificado por el operando Contador. SAL y SHL desplazan los bits a
la izquierda. SAR y SHR desplazan los bits a la derecha.

Nota.- Destino puede ser un registro valor de memoria de 8, 16 o 32 bits.

Contador debe ser una constante entre 1 y 31 o el registro CL.
Comportamiento:

SHL CF DESTINO 0

SAL CF DESTINO 0

SHR 0 DESTINO CF

SAR DESTINO CF

Nota.- Desplazar un número a la izquierda es igual a multiplicar por 2.

Desplazar un número a la derecha es igual a dividirlo entre 2.
 RCL Destino , Contador
ROL Destino , Contador
RCR Destino , Contador
ROR Destino , Contador

Estas instrucciones rotan los bits del operando destino el número de

veces especificado por el operando contador. RCL y ROL rotan los bits a la
izquierda RCR y ROR rotan los bits a la derecha.

Nota.- Destino puede ser un registro o valor de 8, 16 o 32 bits. Contador

debe ser una constante entre 1 y 32 bits o el registro CL.
Comportamiento:

ROL CF DESTINO

ROR DESTINO CF

RCL CF DESTINO

RCR DESTINO CF
2.6 Procesos de control.

2.6.1 Banderas
2.6.2 Cadenas
CLC ;Clear carry
CMC ;Complement carry
STC ;Set carry
CLD ;Clear direction
STD ;Set direction
CLI ;Clear interrupt
STI ;Set interrupt
LAHF ;Load AH flags
SAHF ;Set AH flags
Bandera de acarreo
CLC => CF = 0
CMC => CF <> CF
STC => CF = 1

Bandera de dirección
CLD => DF = 0
STD => DF = 1

Bandera de interrupción
CLI => IF = 0
STI => IF = 1

Parte baja del registro de banderas

LAHF => AH = Flags (parte baja)
SAHF => Flags (parte baja) = AH
 PUSHAD ; Salvar todos los registros
LEA ESI, Cadena
MOV BYTE PTR [ESI], ' ' ; Positivo, no lleva signo
MOV EAX, Numero
TEST EAX, 80000000H
JZ Inicio
; Numero negativo
; Poner signo e invertir
MOV BYTE PTR [ESI], '-'
NEG EAX
Inicio:
INC ESI ; Siguiente posición después del signo
MOV ECX, 0 ; Contador de caracteres
MOV EBX, 10 ; Dividir entre 10
Repetir:
INC ECX
CDQ ; EDX:EAX <- EAX
DIV EBX
PUSH EDX ; Residuo en la pila
CMP EAX, 0 ; ¿Seguir dividiendo?
JNE Repetir
; ECX tiene el total de caracteres
MOV Contador, ECX
INC Contador ; Por el signo
; Sacar los residuos de la pila y convertirlos en caracteres
Sacar:
POP EDX
OR DL, 30H ; Convertir caracter a ASCII
MOV [ESI], DL
INC ESI
LOOP Sacar
; Fin. Cadena tiene el número y Contador el total de caracteres
POPAD ; Recuperar todos los registros
 PUSHAD
LEA ESI, Cadena
MOV EAX, 0
MOV EBX, 10
MOV EDI, 0 ; Positivo
;Saltar blancos y tabuladores
Saltar:
CMP BYTE PTR [ESI], 32 ; Espacio en blanco
JE SiguienteEspacio
CMP BYTE PTR [ESI], 9 ; Tabulador
JNE VerificarSigno
SiguienteEspacio:
INC ESI
JMP Saltar
;El signo solo puede ser el primer caracter
VerificarSigno:
CMP BYTE PTR [ESI], '-'
JNE Empezar
MOV EDI, 1 ; Negativo
INC ESI
; Convertir dígitos a números

; Salir cuando no sea dígito

Empezar:
CMP BYTE PTR [ESI], '0'

JB Terminar ; Si es menor que 0

CMP BYTE PTR [ESI], '9'
JA Terminar ; Si es mayor que 0

MUL EBX
MOV DL, [ESI]
AND EDX, 0000000FH ; Convertir dígito a número
ADD EAX, EDX
INC ESI
JMP Empezar
; Si tenía signo, negar el número
Terminar: CMP EDI, 0
JE Salir

NEG EAX
; Dejarlo en número
Salir: MOV Numero, EAX
POPAD
1. E.U.P.E. que lea un número desde el teclado y determine si el número es
primo o no primo y muestre un mensaje indicando el resultado.

2. E.U.P.E. que imprima los 10 primeros números de la serie de fibonnacci.

3. E.U.P.E que lea un número binario de 8 bits, obtenga su equivalente en

decimal y lo muestre en pantalla.
4. E.U.P.E. que lea un número y despliegue los valores que genera la
conjetura ULAM que dice lo siguiente:

a) Inicie con cualquier número entero positivo.

b) Si es par divídalo entre dos. Si es impar multiplique por tres y sume
uno.
c) Repita el iniciso b) hasta que el número generado sea 1.

5. E.U.P.E. que defina un string de caracteres en minúsculas y lo convierta

en mayúsculas.
 Un string es una secuencia de bytes o
palabras. Los strings pueden ser usados
para mantener alguna información ya sea en
bytes o palabras, por ejemplo un string de
bytes puede almacenar caracteres.

Cuando se usan los strings como

datos, muchas operaciones pueden ser
realizadas ya que el procesador cuenta con
instrucciones que ejecutan las operaciones
básicas directamente.
 Los strings son almacenados en los
segmentos de datos y extra. Para definirlos se
utilizan las directivas BYTE y WORD, y los datos que
contienen podrán ser constantes o variables:

Ejemplos:

string BYTE 100 DUP("*")

ceros WORD 50 DUP("0")
lista BYTE "abcde”
Nota.- A los strings definidos con el operador
DUP se les puede aplicar el operador LENGTH para
conocer el número de elementos que contienen.

Ejemplo:

MOV AX, Length string

MOV CL, Length ceros
Las instrucciones para manipular un string se llaman
primitivas, las cuales se utilizan con un sufijo ( B o W ) que
especifica el tamaño del dato que se procesa. Estas primitivas
provocan que los registros índices ( ESI o EDI ) sean
incrementados en 1 o 2 automáticamente, dependiendo del
estado actual de la bandera de dirección ( DF ).

Las instrucciones son las siguientes:

LODS ; Load String

LODSB/LODSW

Carga el elemento apuntado por DS:ESI en el registro

AL o AX y actualiza ESI.
STOS ; Store String
STOSB/STOSW

Almacena el contenido del registro AL o AX en la

dirección apuntada por ES:EDI y actualiza EDI.

MOVS ;Move string

MOVSB/MOVSW

Mueve el elemento apuntado por DS:ESI a la memoria

apuntada por ES:EDI y actualiza ESI y EDI.
CMPS ;Compare String
CMPSB/CMPSW

Compara los elementos apuntados por ES:EDI y DS:ESI

y actualiza ESI y EDI.

SCAS ;Scan string

SCASB/SCASW

Explora el string apuntado por ES:EDI y actualiza el

EDI.
Compara el elemento del string con el registro AL o AX
y actualiza las banderas después de cada comparación.
Nota.- La actualización de los registros ESI y EDI podrá ser un
incremento o un decremento de 1 o 2 de acuerdo a si fue
definida como BYTE o WORD, dependiendo de la bandera de
dirección, tal como se muestra:

Si DF=0 incrementa 1 o 2 a los registros que

intervienen en la operación ( ESI / EDI ).

Si DF=1 decrementa 1 o 2 a los registros que

intervienen en la operación ( ESI / EDI ).
 OPERANDOS DE LAS PRIMITIVAS DE STRINGS.

PRIMITIVA PRIMER OPERANDO SEGUNDO OPERANDO

LODS AL o AX DS:ESI
STOS ES:EDI AL o AX
MOVS ES:EDI DS:ESI
CMPS DS:ESI ES:EDI
SCAS AL o AX ES:EDI
 En los programas de modo protegido, el registro
ESI es automáticamente un desplazamiento en el
segmento direccionado por el registro DS y el
registro EDI es automáticamente un
desplazamiento en el segmento direccionado por
el registro ES.

 Los registros DS y ES son siempre establecidos al

mismo valor y no se pueden cambiar.

 Nota: En modo real, por otra parte, los registros

DS y ES son frecuentemente manipulados por los
programadores de lenguaje ensamblador.
Ejemplos:

Copiar 13 bytes de Dato1 a Dato2

Dato1 BYTE 'string fuente'

Dato2 BYTE 13 DUP( ? )
----
----
----
LEA EDI , Apunta_D2
LEA ESI , Apunta_D1
CLD
MOV ECX , 13
CICLO: MOVSB
LOOP CICLO
Buscar el carácter $ en un string
Var1 BYTE 'Este es un mensaje.' , '$'
Long_V EQU $-Var1
----
----
----
LEA EDI , Var1
MOV AL , '$'
MOV ECX , Long_V
CICLO: SCASB
LOOPNE CICLO
JE SI_ESTA
NO_ESTA: ----
----
SI_ESTA: ----
----
 Frecuentemente las instrucciones de strings requieren
repetirse una serie de veces, por tal motivo se han incluido
tres instrucciones para efectuar las repeticiones sin necesidad
de usar ciclos para controlarlas. Tales instrucciones son:

REP => Mientras ECX > 0

REPE / REPZ => ECX >0 y ZF = 1

REPNE / REPNZ => ECX > 0 y ZF = 0

Ej.-
Copia un string byte por byte

String1 BYTE 'Hola a todos'

Long_S1 EQU $-String1
String2 BYTE 12 DUP (' ')
----
----
----
LEA ESI , String1
LEA EDI , String2
----
----
----
CLD
REP MOVSB
Compara un String de N caracteres

LEA ESI , fuente

LEA EDI , destino
CLD
MOV ECX , N
REPE CMPSB
JE IGUALES
JA MAYOR
JB MENOR
----
----
----
c) Copiar un string de atrás hacia adelante.

String1 BYTE 'Hola'

----
----
----
LEA ESI , String1 + SIZE String1 – TYPE STRING1
LEA EDI , String2 + SIZE String2 – TYPE STRING2
STD
MOV ECX , Long_S1
REP MOVSB
----
----
----

SIZE => Regresa el número de bytes asignados.

TYPE => 1.- BYTE , 2.- WORD
d) Buscar un carácter diferente de blanco en un string-

MOV AL , " "

LEA EDI , String
CLD
MOV ECX , Long_S
REPE SCASB
JE NO_HAY
JMP SI_HAY
1.- E.U.P.E. que lea dos strings y los compare, despliegue un mensaje
indicando si son iguales o no.

2.- E.U.P.E. que obtenga un substring. Lea del teclado los datos (string,
posición inicial y número de caracteres a obtener). Despliegue en pantalla su
resultado.

3.- E.U.P.E. que encuentre la posición de un carácter. Lea del teclado el string
y el carácter a buscar, en caso de no encontrarlo enviar un mensaje.

4.- Obtener los N caracteres más a la derecha de un string, lea el string y la N

del teclado.