Lenguaje de Interfaz Final

Instituto Tecnolgico de Lzaro Crdenas
INGENIERIA EN SISTEMAS COMPUTACIONALES

MATERIA:
LENGUAJE DE INTERFAZ

UNIDADES

ELABORADO POR:
CALLEJA ZAMORA JOS MANUEL

6 SEMESTRE

PROFESOR:
ING. PABLO GONZALEZ REYNALDO

Contenido
UNIDAD 1 INTRODUCCION A LENGUAJE ENSAMBLADOR ...................................................................... 4
1.1 IMPORTANCIA DE LA PROGRAMACIN EN LENGUAJE ENSAMBLADOR ....................................... 4
1.2 EL PROCESADOR Y SUS REGISTROS INTERNOS ............................................................................. 4
1.3 LA MEMORIA PRINCIPAL (RAM) .................................................................................................... 8
1.4 CONCEPTO DE INTERRUPCIN. ..................................................................................................... 9
1.5 LLAMADAS A SERVICIOS DEL SISTEMA........................................................................................ 10
1.6 MODOS DE DIRECCIONAMIENTO. ............................................................................................... 11
1.7 PROCESO DE ENSAMBLADO Y LIGADO ....................................................................................... 15
1.8 DESPLEGADO DE MENSAJES EN EL MONITOR ............................................................................ 16
UNIDAD 2 PROGRAMACION BASICA ..................................................................................................... 23
2.1 ENSAMBLADOR Y LIGADOR A UTILIZAR ...................................................................................... 23
2.2 CICLOS NUMERICOS .................................................................................................................... 24
2.3 CAPTURA BSICA DE CADENAS ................................................................................................... 25
2.4 COMPARACION Y PRUEBA .......................................................................................................... 25
2.5 SALTOS ........................................................................................................................................ 25
2.6 CICLOS DE CONDICIONALES ........................................................................................................ 26
2.7 INCREMENTO Y DECREMENTO ................................................................................................... 27
2.8 CAPTURA DE CADENAS CON FORMATO ..................................................................................... 28
2.9 INSTRUCCIONES ARITMTICAS ................................................................................................... 29
2.10 MANIPULACIN DE PILA ........................................................................................................... 30
2.11 OBTENCION DE CADENA CON REPRESENTACION HEXADECIMAL ............................................ 31
2.12 INSTRUCCIONES LGICAS ......................................................................................................... 35
2.13 DESPLAZAMIENTO Y ROTACIN ............................................................................................... 36
2.14 OBTENCIN DE REPRESENTACION DE CADENAS DECIMAL ...................................................... 38
2.15 CAPTURA Y ALMACENAMIENTO DE DATOS NUMERICOS ......................................................... 40
2.16 OPERACIONES BASICAS SOBRE ARCHIVOS DE DISCO ............................................................... 43
UNIDAD 3 MODULARIZACION ............................................................................................................... 45
3.1 Macros......................................................................................................................................... 45
3.1.1 Internas. ................................................................................................................................... 45
3.1.2 Externas. ................................................................................................................................... 46
3.2 Procedimientos. .......................................................................................................................... 47
3.2.1 Internos. ................................................................................................................................... 47
3.2.2 Externos. .................................................................................................................................. 48
UNIDAD 4 PROGRAMACION DE DISPOSITIVOS ..................................................................................... 49
4.1 El Buffer De Video En Modo Texto .............................................................................................. 49
4.2 Acceso A Discos En Lenguaje Ensamblador ................................................................................ 50
4.3 Programacin Del Puerto Serial .................................................................................................. 55
4.4 Programacin Del Puerto Paralelo .............................................................................................. 62
4.5 Programacin Hbrida ................................................................................................................. 66
4.6 Programacin De Puerto USB (Universal Serial Bus). ................................................................. 67
TRADUCCIONES ..................................................................................................................................... 69
PCASM BOOK .................................................................................................................................... 69
USO DE MACROS ............................................................................................................................... 79
PROGRAMAS ....................................................................................................................................... 148
HOLA MUNDO ................................................................................................................................. 148
SUMATORIA DE NUMEROS DEL 1 AL 20 ......................................................................................... 149
SUMATORIA DE NUMEROS PARES DEL 1 AL 100 ............................................................................ 151
SUMATORIA DE TODOS LOS NUMEROS DEL 1 AL 100 .................................................................... 153
MULTIPLICACION DE 4 NUMEROS .................................................................................................. 155
EL MAYOR DE 4 NUMEROS ............................................................................................................. 159
DETERMINA EL RANGO DE UN NUMERO DADO ............................................................................. 162
LEE UN NUMERO Y LO CLASIFICA DE ACUERDO A CALIFICACION .................................................. 163
SUMA 4 NUMEROS Y SACA EL PROMEDIO ..................................................................................... 165
PROGRAMA QUE LEE NOMBRE Y CALIFICACIONES Y DETERMINA PROMEDIO .............................. 167
RECIBE UN NUMERO Y TE DICE SI ES MULTIPLO DE 2 O NO ........................................................... 169
CALCULA EL AREA DE UN TRIANGULO ............................................................................................ 170
CONTADOR IMPRIME HASTA UN NUMERO DADO ......................................................................... 174
NUMERO PRIMO ............................................................................................................................. 176
APROBADO O REPROBADO ............................................................................................................. 179
SUMA DE NUMERO PARES .............................................................................................................. 181
CALCULO DE PROMEDIO Y CALIFICACION ARRIBA DEL PROMEDIO ............................................... 183
CICLO DECREMENTAL ...................................................................................................................... 186

UNIDAD 1 INTRODUCCION A LENGUAJE ENSAMBLADOR
1.1 IMPORTANCIA DE LA PROGRAMACIN EN LENGUAJE ENSAMBLADOR
Definicin: El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para
escribir programas informticos, y constituye la representacin ms directa del cdigo
mquina especfico para cada arquitectura de microprocesador.

La importancia del lenguaje ensamblador es principalmente que se trabaja
directamente con el microprocesador; por lo cual se debe de conocer el funcionamiento
interno de este, tiene la ventaja de que en l se puede realizar cualquier tipo de
programas que en los lenguajes de alto nivel no lo pueden realizar. Otro punto sera que
los programas en ensamblador ocupan menos espacio en memoria.
Ventajas y desventajas del Lenguaje Ensamblador

Ventajas

1. Como trabaja directamente con el microprocesador al ejecutar un programa, pues
como este lenguaje es el ms cercano a la mquina la computadora lo procesa ms
rpido.
2. Eficiencia de tamao.- Un programa en ensamblador no ocupa mucho espacio en
memoria porque no tiene que cargan libreras y dems como son los lenguajes de
alto nivel.
3. Flexibilidad.- En lenguaje ensamblador se pueden hacer tareas especficas que en
un lenguaje de alto nivel no se pueden llevar acabo porque tienen ciertas limitantes
que no se lo permite.

1.2 EL PROCESADOR Y SUS REGISTROS INTERNOS
El procesador es un elemento importante del hardware de la PC. Es la unidad del
sistema, que contiene una tarjeta de sistema, fuente de poder y ranuras de expansin
para tarjetas opcionales. Los elementos de la tarjeta de sistema son un
microprocesador, memoria de solo lectura (ROM) y memoria de acceso aleatorio
(RAM).

REGISTROS INTERNOS DEL PROCESADOR.
Los registros del procesador se emplean para controlar instrucciones en ejecucin, manejar
direccionamiento de memoria y proporcionar capacidad aritmtica. Los registros son direccionables
por medio de un nombre. Los bits por convencin, se numeran de derecha a izquierda, como en:

... 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0

Registros de segmento

Un registro de segmento tiene 16 bits de longitud y facilita un rea de memoria para
direccionamiento conocida como el segmento actual.

Registro CS. El DOS almacena la direccin inicial del segmento de cdigo de un
programa en el registro CS. Esta direccin de segmento, ms un valor de
desplazamiento en el registro apuntador de instruccin (IP), indica la direccin
de una instruccin que es buscada para su ejecucin.
Registro DS. La direccin inicial de un segmento de datos de programa es
almacenada en el registro DS. En trminos sencillos, esta direccin, ms un
valor de desplazamiento en una instruccin, genera una referencia a la
localidad de un byte especifico en el segmento de datos.
Registro SS. El registro SS permite la colocacin en memoria de una pila, para
almacenamiento temporal de direcciones y datos. El DOS almacena la direccin
de inicio del segmento de pila de un programa en el registro SS. Esta direccin
de segmento, ms un valor de desplazamiento en el registro del apuntador de
pila (SP), indica la palabra actual en la pila que est siendo direccionada.
Registros ES. Algunas operaciones con cadenas de caracteres (datos de caracteres) utilizan
el registro extra de segmento para manejar el direccionamiento de memoria. En este
contexto, el registro ES est asociado con el registro DI (ndice). Un programa que requiere
el uso del registro ES puede inicializarlo con una direccin de segmento apropiada.
Registros FS y GS. Son registros extra de segmento en los procesadores
80386 y posteriores.

Registros de propsito general.

Son nicos en el sentido de que se puede direccionarlos como una palabra o como una
parte de un byte. El ltimo byte de la izquierda es la parte "alta", y el ltimo byte de la
derecha es la parte "baja". Por ejemplo, el registro CX consta de una parte CH (alta) y
una parte Cl (baja), y usted puede referirse a cualquier parte por su nombre.

Registro AX. El registro AX, el acumulador principal, es utilizado para
operaciones que implican entrada/salida y la mayor parte de la aritmtica. Por
ejemplo, las instrucciones para multiplicar, dividir y traducir suponen el uso del
AX. Tambin, algunas operaciones generan cdigo ms eficiente si se refieren
al AX en lugar de a los otros registros.

Registro BX. El BX es conocido como el registro base ya que es el nico registro
de propsito general que puede ser ndice para direccionamiento indexado.
Tambin es comn emplear el BX para clculos.

Registro DX. El DX es conocido como el registro de datos. Algunas operaciones
de entrada/salida requieren uso, y las operaciones de multiplicacin y divisin
con cifras grandes suponen al DX y al AX trabajando juntos.

Registro de Apuntador de Instrucciones.

El registro apuntador de instrucciones (IP) de 16 bits contiene el desplazamiento de direccin de la
siguiente instruccin que se ejecuta. El IP est asociado con el registro CS en el sentido de que el IP
indica la instruccin actual dentro del segmento de cdigo que se est ejecutando actualmente. Los
procesadores 80386 y posteriores tienen un IP ampliado de 32 bits, llamado EIP.

Registros Apuntadores.

Los registros SP (apuntador de la pila) Y BP (apuntador de base) estn asociados con el registro SS y
permiten al sistema accesar datos en el segmento de la pila.

Registro SP. El apuntador de la pila de 16 bits est asociado con el registro SS y proporciona
un valor de desplazamiento que se refiere a la palabra actual que est siendo procesada en la
pila. El sistema maneja de forma automtica estos registros.

Registro BP. El BP de 16 bits facilita la referencia de parmetros, los cuales son datos y
direcciones transmitidos va pila.

Registros ndice.

Los registros SI y DI estn disponibles para direccionamiento indexado y para sumas y restas.

Registro SI. El registro ndice fuente de 16 bits es requerido por algunas operaciones con cadenas (de
caracteres). En este contexto, el SI est asociado con el registro DS.

Registro DI. El registro ndice destino tambin es requerido por algunas operaciones con cadenas de
caracteres. En este contexto, el DI est asociado con el registro ES.

Registro de Banderas.

Sirven para indicar el estado actual de la mquina y el resultado del procesamiento. Muchas
instrucciones que piden comparaciones y aritmtica cambian el estado de las banderas, algunas
cuyas instrucciones pueden realizar pruebas para determinar la accin subsecuente:

OF (Overflow, desbordamiento). Indica desbordamiento de un bit de orden alto (mas a la
izquierda) despus de una operacin aritmtica.
DF (direccin). Designa la direccin hacia la izquierda o hacia la derecha para mover o
comparar cadenas de caracteres.

IF (interrupcin). Indica que una interrupcin externa, como la entrada desde el teclado,
sea procesada o ignorada.
TF (trampa). Permite la operacin del procesador en modo de un paso. Los programas
depuradores, como el DEBUG, activan esta bandera de manera que usted pueda avanzar en
la ejecucin de una sola instruccin a un tiempo, para examinar el efecto de esa instruccin
sobre los registros de memoria.
SF (signo). Contiene el signo resultante de una operacin aritmtica (0 = positivo y 1 =
negativo).
ZF (cero). Indica el resultado de una operacin aritmtica o de comparacin
(0 = resultado diferente de cero y 1 = resultado igual a cero).
AF (acarreo auxiliar). Contiene un acarreo externo del bit 3 en un dato de 8 bits para
aritmtica especializada.
PF (paridad). Indica paridad par o impar de una operacin en datos de 8 bits de bajo orden
(mas a la derecha).
CF (acarreo). Contiene el acarreo de orden ms alto (ms a la izquierda) despus de una
operacin aritmtica; tambin lleva el contenido del ltimo bit en una operacin de
corrimiento o de rotacin.

Las banderas estn en el registro de banderas en las siguientes posiciones:

1.3 LA MEMORIA PRINCIPAL (RAM)
RAM es el acrnimo ingls de Random Access Memory (memoria de acceso aleatorio). Se trata de
una memoria de semiconductor en la que se puede tanto leer como escribir informacin. Es una
memoria voltil, es decir, pierde su contenido al desconectar la energa elctrica. Se utiliza
normalmente como memoria temporal para almacenar resultados intermedios y datos similares no
permanentes.
En estas memorias se accede a cada celda (generalmente se direcciona a nivel de bytes) mediante un
cableado interno, es decir, cada byte tiene un camino prefijado para entrar y salir, a diferencia de otros
tipos de almacenamiento, en las que hay una cabeza lectograbadora que tiene que ubicarse en la
posicin deseada antes de leer el dato deseado.

Se dicen "de acceso aleatorio" porque los diferentes accesos son independientes entre s. Por ejemplo,
si un disco rgido debe hacer dos accesos consecutivos a sectores alejados fsicamente entre s, se
pierde un tiempo en mover la cabeza hasta la pista deseada (o esperar que el sector pase por debajo,
si ambos estn en la misma pista), tiempo que no se pierde en la RAM.

Las RAM se dividen en estticas y dinmicas. Una memoria RAM esttica mantiene su contenido
inalterado mientras est alimentada. La informacin contenida en una memoria RAM dinmica se
degrada con el tiempo, llegando sta a desaparecer, a pesar de estar alimentada. Para evitarlo hay
que restaurar la informacin contenida en sus celdas a intervalos regulares, operacin denominada
refresco.

Las memorias se agrupan en mdulos, que se conectan a la placa base del computador. Segn los tipos
de conectores que lleven los mdulos, se clasifican en Mdulos SIMM (Single In-line Memory
Module), con 30 o 72 contactos, mdulos DIMM (Dual In-line Memory Module), con 168
contactos y mdulos RIMM (RAMBUS In-line Memory Module) con 184 contactos.
1.4 CONCEPTO DE INTERRUPCIN.
Un procesador no puede procesar simultneamente varios trozos de informacin (procesa un trozo
de informacin a la vez), un programa que est siendo ejecutado puede, gracias al pedido de
interrupcin, ser momentneamente suspendido mientras se produce una interrupcin. El programa
interrumpido puede continuar ejecutndose luego. Existen 256 direcciones de interrupcin diferentes.
Una interrupcin se convierte en una interrupcin de hardware cuando es solicitada por uno de los
componentes de hardware del equipo. En efecto, existen varios perifricos en un equipo. Estos
perifricos necesitan generalmente utilizar los recursos del sistema aunque slo sea para comunicarse
con el sistema mismo.

Cuando un perifrico desea acceder a un recurso, enva un pedido de interrupcin al procesador para
llamar su atencin. Los perifricos cuentan con un nmero de interrupcin que se denomina IRQ
(Peticiones de Interrupcin. Es como si cada perifrico tirara de un "hilo" que est atado a una
campana para sealarle al equipo que desea que le preste atencin Este "hilo" es, de hecho, una lnea
fsica que conecta cada ranura de expansin as como cada interfaz E/S a la placa madre. Para una
ranura ISA de 8 bits, por ejemplo, hay 8 lneas IRQ que unen ranuras ISA de 8 bits a la placa madre
(IRQ0 a IRQ7). Estos IRQ estn controlados por un "controlador de interrupcin" que se encarga de
cederle la palabra al IRQ que posee la mayor prioridad.

Al aparecer las ranuras de 16 bits, se agregaron IRQ 8 a 15. En consecuencia, fue necesario agregar un
segundo controlador de interrupcin. Los dos grupos de interrupciones estn unidos por IRQ 2 el cual
se conecta (o "produce una cascada") a IRQ 9. En cierto modo, esta cascada "inserta" IRQ 8 a 15 entre
IRQ1 y 3:

Dado que la prioridad va del IRQ inferior al superior y que se insertan IRQ 8 a 15 entre IRQ 1 y 3, el
orden de prioridad es el siguiente:

0 > 1 > 8 > 9 > 10 > 11 > 12 > 13 > 14 > 15 > 3 > 4 > 5 > 6 > 7

1.5 LLAMADAS A SERVICIOS DEL SISTEMA.
Las llamadas al sistema comnmente usan una instruccin especial de la CPU que causa que el
procesador transfiera el control a un cdigo privilegiado. Previamente especificado por el mismo
cdigo. Esto permite al cdigo privilegiado especificar donde va a ser conectado as como el estado
del procesador.

Cuando una llamada al sistema es invocada, la ejecucin del programa que invoca es interrumpida y
sus datos son guardados, normalmente en su PCB (Bloque de Control de Proceso del ingls Process
Control Block), para poder continuar ejecutndose luego. El procesador entonces comienza a
ejecutar las instrucciones de cdigo de alto nivel de privilegio, para realizar la tarea requerida.
Cuando esta finaliza, se retorna al proceso original, y contina su ejecucin. El retorno al proceso
demandante no obligatoriamente es inmediato, depende del tiempo de ejecucin de la llamada al
sistema y del algoritmo de planificacin de CPU.

Las llamadas son peticiones a ejecucin de rutinas y proporcionan la interfaz entre el sistema
operativo y un programa en ejecucin. Estas llamadas son instrucciones de lenguaje ensamblador y
se presentan en los manuales que emplean los programadores de este lenguaje.

Las llamadas al sistema para ejecucin y el control de programas, usualmente incluyen un conjunto
completo de los servicios accesibles por la va del lenguaje de rdenes, tales como: RUN, EXECUTE,
ABORT y planificacin relacionada con el tiempo, adems los usuarios con las llamadas del sistema
pueden suspender, establecer o cambiar atributos del tiempo de ejecucin de uno o ms programas.

Las llamadas del sistema para el gestor de recursos, proporcionan servicios para la asignacin,
reserva y reclamacin de los recursos del sistema. Por ejemplo, existen llamadas del sistema para
extender o reducir la cantidad de memoria poseda por el programa que se llama. Las llamadas del
sistema pueden asignar o reservar otros tipos de objetos del sistema y despus destruir o devolver
su custodia al sistema operativo.

Las llamadas al sistema se pueden agrupar en cinco categoras:

1. Control de proceso (Crear, cargar, ejecutar un proceso, obtener y establecer
atributos, esperar un suceso, liberar memoria, abortar y terminar proceso).

2. Manipulacin de archivos (Crear, abrir, leer, obtener y establecer atributos, cerrar y
eliminar archivos).

3. Manipulacin de perifricos (Solicitar, escribir, leer, obtener y establecer atributos,
liberar perifrico).

4. Manipulacin de la informacin (Obtener fecha y hora, establecer fecha y hora,
obtener y establecer datos del sistema, obtener y establecer atributos).

5. Comunicaciones (Crear conexin, enviar mensajes, recibir mensajes, transferir
informacin del estado y eliminar conexin.
1.6 MODOS DE DIRECCIONAMIENTO.
Los llamados modos de direccionamiento son las diferentes maneras de especificar en informtica un
operando dentro de una instruccin en lenguaje ensamblador.

Un modo de direccionamiento especifica la forma de calcular la direccin de memoria efectiva de un
operando mediante el uso de la informacin contenida en registros y / o constantes, contenida dentro
de una instruccin de la mquina o en otra parte
Las operaciones se hacen entre registros o registros y memoria, pero nunca entre memoria y memoria
(salvo algunas operaciones con cadenas de caracteres). Los modos de direccionamiento determinan
el lugar en que reside un operando, un resultado o la siguiente instruccin a ejecutar segn el caso.

Tenga en cuenta que no existe una forma generalmente aceptada de nombrar a los distintos modos
de direccionamiento. En particular, los distintos autores y fabricantes de equipos pueden dar nombres
diferentes para el modo de hacer frente al mismo, o los mismos nombres, a los diferentes modos de
direccionamiento

Direccionamiento Inmediato.

En este modo el operando es especificado en la instruccin misma. En otras palabras, una instruccin
de modo inmediato tiene un campo de operando en vez de un campo de direccin. El campo del
operando contiene el operando actual que se debe utilizar en conjunto con la operacin especificada
en la instruccin. Las instrucciones de modo inmediato son tiles para inicializar los registros en un
valor constante.

Cuando el campo de direccin especifica un registro del procesador, la instruccin se dice que est en
el modo de registro.

Direccionamiento Directo.

Es directo cuando la instruccin contiene el lugar donde se encuentra el operando. Segn el lugar
donde se encuentra el operando puede ser:
Direccionamiento directo a registro.
Direccionamiento directo a memoria
Direccin completa (p. ej. Z80 sobre 64 Kb con 16 bits)
Direccin sobre una pgina del mapa de memoria; tambin se conoce como
direccionamiento de pgina base.

Direccionamiento Relativo.
La instruccin indica el desplazamiento del operando con respecto a un puntero:
La direccin efectiva es calculada por la unidad de control sumando, o restando, el desplazamiento al
puntero de referencia que suele estar en un registro. Dependiendo del puntero se tienen diferentes
modos de direccionamiento. Direccin efectiva = Reg. Referencia + desplazamiento.

Modo de direccionamiento / Registro de referencia / Clculo direccin efectiva:

Relativo a contador de programa Contador de programa (CP) DE = CP + desplazamiento.
Relativo a registro base Un registro base (R B) DE = RB + desplazamiento.
Relativo a registro ndice Un registro ndice (R I) DE = RI + desplazamiento.
Relativo a pila Registro de pila (SP) DE = SP + desplazamiento.

Ventajas

Las instrucciones son ms compactas.
El cdigo puede cambiar de lugar en el mapa de memoria con cambiar el valor del puntero.
Gran facilidad de manejo de estructuras de datos.

Inconvenientes

Se requiere una operacin adicional para el clculo de la direccin del operando.

Direccionamiento Indirecto.

La posicin indicada por la instruccin no es el operando sino la direccin de memoria en la que se
encuentra, por lo que se necesita un acceso adicional a memoria.

La direccin de memoria se puede dar mediante:

Direccionamiento directo a memoria
Direccionamiento relativo
Es posible que se realicen mltiples niveles de indireccin.
Su utilidad ms comn es la de acceso a diversas informaciones mediante tablas de punteros.

Direccionamiento Implcito.

En este modo de direccionamiento no es necesario poner ninguna direccin de forma explcita, ya que
en el propio cdigo de operacin se conoce la direccin del (de los) operando(s) al (a los) que se desea
acceder o con el (los) que se quiere operar. Requiere que el programador conozca con que operandos
se est trabajando.

Direccionamiento de Registro.

Sirve para especificar operandos que estn en registros.

Direccionamiento Indirecto por Registro.

En este modo el campo de la direccin de la instruccin da la direccin en donde la direccin efectiva
se almacena en la memoria. El control localiza la instruccin de la memoria y utiliza su parte de
direccin para acceder a la memoria de nuevo para leer una direccin efectiva. Unos pocos modos de
direccionamiento requieren que el campo de direccin de la instruccin sea sumado al control de un
registro especificado en el procesador. La direccin efectiva en este modo se obtiene del siguiente
clculo:

Dir. Efectiva = Dir. de la parte de la instruccin + Contenido del registro del procesador.

1.7 PROCESO DE ENSAMBLADO Y LIGADO
Para poder crear un programa se requieren varias herramientas: Primero un editor para crear el
programa fuente. Segundo un compilador que no es ms que un programa que "traduce" el programa
fuente a un programa objeto. Y tercero un enlazador o linker, que genere el programa ejecutable a
partir del programa objeto. El editor puede ser cualquier editor de textos que se tenga a la mano,
como compilador utilizaremos el MASM (macro ensamblador de Microsoft) ya que es el ms comn,
y como enlazador utilizaremos el programa link.

La extensin usada para que MASM reconozca los programas fuente en ensamblador es .ASM; una
vez traducido el programa fuente, el MASM crea un archivo con la extensin .OBJ, este archivo
contiene un "formato intermedio" del programa, llamado as porque an no es ejecutable pero
tampoco es ya un programa en lenguaje fuente. El enlazador genera, a partir de un archivo .OBJ o la
combinacin de varios de estos archivos, un programa ejecutable, cuya extensin es usualmente .EXE
aunque tambin puede ser .COM, dependiendo de la forma en que se ensambl.

1.8 DESPLEGADO DE MENSAJES EN EL MONITOR
Para poder desplegar mensajes en lenguaje ensamblador primero debemos conocer la estructura
del programa en ensamblador.

Comentarios En Lenguaje Ensamblador.

El uso de comentarios a lo largo de un programa puede mejorar su claridad, en especial en
lenguaje ensamblador, donde el propsito de un conjunto de instrucciones con frecuencia no es
claro. Un comentario empieza con punto y coma (;) y, en donde quiera que lo codifique, el
ensamblador supone que todos los caracteres a la derecha de esa lnea son comentarios. Un
comentario puede contener cualquier carcter imprimible, incluyendo el espacio en blanco.

Un comentario puede aparecer solo en una lnea o a continuacin de una instruccin en la misma
lnea, como lo muestran los dos ejemplos siguientes:

Toda esta lnea es un comentario.
ADD AX, BX; Comentario en la misma lnea que la instruccin.

Ya que un comentario aparece solo en un listado de un programa fuente en ensamblador y no
genera cdigo de mquina, puede incluir cualquier cantidad de comentarios sin afectar el
tamao o la ejecucin del programa ensamblado. Otra manera de proporcionar comentarios
es por medio de la directiva COMMENT.

Palabras Reservadas

Ciertas palabras en lenguaje ensamblador estn reservadas para sus propsitos propios, y son
usadas solo bajo condiciones especiales. Por categoras, las palabras reservadas incluyen:

Instrucciones, como MOV y ADD, que son operaciones que la computadora puede
ejecutar.
Directivas como END o SEGMENT, que se emplean para proporcionar comandos al
ensamblador.
Operadores, como FAR y SIZE, que se utilizan en expresiones.
Smbolos predefinidos, como @Data y @Model, que regresan informacin a su programa.

Identificadores.

Un identificador es un nombre que se aplica a elementos en el programa. Los dos tipos de
identificadores son: nombre, que se refiere a la direccin de un elemento de dato y etiqueta, que
se refiere a la direccin de una instruccin.
Un identificador puede usar los siguientes caracteres:

1. Letras del alfabeto: Desde la A hasta la Z(maysculas o minsculas)
2. Dgitos: Desde el 0 al 9 (no puede ser el primer carcter)
3. Caracteres especiales: Signo de interrogacin ( ? ) Subrayado ( _ ), Signo de pesos ( $ ), Arroba
( @ ), Punto ( . ) (no puede ser el primer carcter)

El primer carcter de un identificador debe ser una letra o un carcter especial, excepto punto.
Ya que el ensamblador utiliza algunos smbolos especiales en palabras que inician con el smbolo
@, debe evitar usarlo en sus definiciones.

En consecuencia, en una instruccin tal como:

ADD AX, BX: El ensamblador sabe de forma automtica que AX y BX se refieren a los
registros. Sin embargo, en una instruccin como:
MOV REGSAVE, AX: El ensamblador puede reconocer el nombre REGSAVE solo si se
define en algn lugar del programa.

Identificador, operacin y operando pueden empezar en cualquier columna. Sin embargo, si de
manera consistente se inicia en la misma columna para estas tres entradas se hace un programa
ms legible.

IDENTIFICADOR: Como ya se explic, el termino nombre se aplica al nombre de
un elemento o directiva definida, mientras que el termino etiqueta se aplica al nombre
de una instruccin.
OPERACIN: La operacin, que debe ser codificada, es con mayor frecuencia usada para
la definicin de reas de datos y codificacin de instrucciones. Para un elemento de datos,
una operacin como DB o DW define un campo, rea de trabajo o constante.
OPERANDO: El operando (si existe) proporciona informacin para la operacin que
acta sobre l. Para un elemento de datos, el operando identifica su valor inicial. Por
ejemplo, en la definicin siguiente de un elemento de datos llamado COUNTER, la
operacin DB significa "definir byte", y el operando inicializa su contenido con un valor
cero:

Para una instruccin, un operando indica en donde realizar la accin. Un operando de una
instruccin puede tener una, dos o tal vez ninguna entrada. Aqu estn tres ejemplos:

Directivas Para Listar: Page Y Title.

La directiva PAGE y TITLE ayudan a controlar el formato de un listado de un programa en
ensamblador. Este es su nico fin, y no tienen efecto sobre la ejecucin subsecuente del
programa.

PAGE. Al inicio de un programa, la directiva PAGE designa el nmero mximo de lneas para listar
en una pgina y el nmero mximo de caracteres en una lnea. Su formato general es:

PAGE [longitud][, ancho]

El ejemplo siguiente proporciona 60 lneas por pgina y 132 caracteres por lnea: PAGE 60, 132

El nmero de lneas por pgina puede variar desde 10 hasta 255, mientras que el nmero de
caracteres por lnea desde 60 hasta 132. La omisin de PAGE causa que el ensamblador tome
PAGE 50, 80.

TITLE. Se puede emplear la directiva TITLE para hacer que un ttulo para un programa se imprima
en la lnea 2 de cada pgina en el listado del programa. Puede codificar TITLE de una vez, al inicio
del programa. Su formato general es:

TITLE Texto.

Para el operando texto, una tcnica recomendada es utilizar el nombre del programa como se registra
en el disco. Por ejemplo:

TITLE Prog1 Mi primer programa en ensamblador

Directiva Segment.

Un programa ensamblado en formato .EXE consiste en uno o ms segmentos. Un segmento de
pila define el almacn de la pila, un segmento de datos define los elementos de datos y un
segmento de cdigo proporciona un cdigo ejecutable. Las directivas para definir un segmento,
SEGMENT y ENDS tienen el formato siguiente:

El enunciado SEGMENT define el inicio de un segmento. El nombre del segmento debe estar
presente, ser nico y cumplir las convenciones para nombres del lenguaje. EL enunciado ENDS
indica el final del segmento y contiene el mismo nombre del enunciado SEGMENT. El tamao
mximo de un segmento es de 64K. El operando de un enunciado SEGMENT puede tener tres
tipos de opciones: alineacin, combinar y clase, codificadas en este
formato:nombre SEGMENT alineacin combinar ' clase

TIPO ALINEACION. La entrada alineacin indica el lmite en el que inicia el segmento. Para el
requerimiento tpico, PARA, alinea el segmento con el lmite de un prrafo, de manera que la
direccin inicial es divisible entre 16, o 10H. En ausencia de un operando hace que el ensamblador
por omisin tome PARA.

TIPO COMBINAR. La entrada combinar indica si se combina el segmento con otros segmentos
cuando son enlazados despus de ensamblar. Los tipos de combinar son STACK, COMMON,
PUBLIC y la expresin AT. Por ejemplo, el segmento de la pila por lo comn es definido como:

nombre SEGMENT PARA STACK

Puede utilizar PUBLIC y COMMON en donde tenga el propsito de combinar de forma separada
programas ensamblados cuando los enlaza. En otros casos, donde un programa no es combinado
con otros, puede omitir la opcin o codificar NONE.

TIPO CLASE. La entrada clase, encerrada entre apstrofos, es utilizada para agrupar segmentos
cuando se enlazan. Se utiliza la clase 'code' para el segmento de cdigos, 'data' por segmento de
datos y 'stack' para el segmento de la pila. El ejemplo siguiente define un segmento de pila con
tipos alineacin, combinar y clase:

nombre SEGMENT PARA STACK 'Stack'

Directiva Assume.

Un programa utiliza el registro SS para direccionar la pila, al registro DS para direccionar el
segmento de datos y el registro CS para direccionar el segmento de cdigo. Para este fin, usted
tiene que indicar al ensamblador el propsito de cada segmento en el programa.

La directiva para este propsito es ASSEME, codificada en el segmento de cdigo como sigue:

Operacin Operando.
ASSUME SS:nompila, DS:nomsegdatos, CS: nomsegcodigo,. . .

Los operandos pueden aparecer en cualquier orden. Al igual que otras directivas, ASSUME es solo un
mensaje que ayuda al ensamblador a convertir cdigo simblico a cdigo maquina; an puede tener
que codificar instrucciones que fsicamente cargan direcciones en registros de segmentos en el
momento de la ejecucin.

PAGE 60,132

TITLE P04ASM1 ESTRUCTURA DE UN PROGRAMA
.EXE
;------------------------------------------------------------------------------
STACKSG SEGMENT PARA STACK
'Stack'
...
STACKSG
ENDS
------------------------------------------------------------------------------
DATASG SEGMENT PARA
'Data'
...
DATASG
ENDS
;------------------------------------------------------------------------------
CODESG SEGMENT PARA
'Code'
BEGIN PROC
FAR
ASSUME SS:STACKSG,
DS:DATASG,CS:CODESG
MOV AX, DATASG ;Obtiene la direccin del segmento de datos
MOV DS, AX ;Almacena direccin en
DS
...
MOV AX, 4C00H
;Peticion
INT 21H ;Salida al
DOS
BEGIN
ENDP
CODESG ENDS
END
BEGIN

Directivas Simplificadas De Segmentos

Los ensambladores de Microsoft y de Borland proporcionan algunas formas abreviadas para
definir segmentos. Para usar estas abreviaturas, inicialice el modelo de memoria antes de definir
algn segmento. El formato general (incluyendo el punto inicial) es:

.MODEL modelo de memoria

El modelo de memoria puede ser TINY, SMALL, MEDIUM, COMPACT o LARGE. Los requisitos
para cada modelo son:

Puede utilizar cualquiera de estos modelos para un programa autnomo (esto es, un programa
que no est enlazado con algn otro). El modelo TINY est destinado para uso exclusivo de
programas .COM, los cuales tienen sus datos, cdigo y pila en un segmento.

El modelo SMALL exige que el cdigo quepa en un segmento de 64K y los datos en otro segmento
de 64K. La directiva .MODELL genera automticamente el enunciado ASSUME necesario.

Los formatos generales (incluyendo el punto inicial) para las directivas que define los segmentos de la
pila, de datos y de cdigo son:

.STACK [tamao]
.DATA
.CODE [nombre]

Cada una de estas directivas hace que el ensamblador genere el enunciado SEGMENT necesario
y su correspondiente ENDS. Los nombres por omisin de los segmentos (que usted no tiene que
definir) son STACK, DATA y TEXT (para el segmento de cdigo).

UNIDAD 2 PROGRAMACION BASICA
2.1 ENSAMBLADOR Y LIGADOR A UTILIZAR

Un ensamblador es el programa que convierte un listado de cdigo fuente, escrito en un fichero
de texto, en cdigo objeto, es decir, lenguaje mquina (el que finalmente interpretar el
procesador) en el que slo le faltan las referencias a rutinas externas. El cdigo fuente es un
fichero que contiene la secuencia de instrucciones en lenguaje ensamblador que forma el
programa, as como ciertas directivas o comandos para el propio ensamblador, que ha sido
creado utilizando un editor de texto. El cdigo objeto consta del cdigo en lenguaje mquina y de
la informacin necesaria para enlazarlo con otros mdulos objeto. Con TASM el proceso de
ensamblado se realiza escribiendo lo siguiente en la ventana de comandos:
tasm /zi /l nombre donde nombre es el nombre del fichero .asm con el cdigo fuente. La extensin no
es necesaria ponerla y los parmetros /zi y /l slo son tiles si queremos hacer un proceso de
depuracin (debug) con el Turbo Debugger. Tras la ejecucin de esta lnea se nos crear un fichero
nombre.obj

Linkado y montado

Al construir un programa algunos de sus mdulos pueden colocarse en el mismo mdulo fuente y
ensamblarse juntos, otros pueden estar en mdulos diferentes y ser ensamblados separadamente.
En cualquier caso, los mdulos objeto resultantes, algunos de los cuales pueden estar agrupados
en libreras, deben ser enlazados para formar el mdulo de carga, antes de que se pueda
ejecutar el programa. Adems de dar como salida el mdulo de carga, el linker o enlazador
imprime un mapa de memoria que indica donde sern cargados los mdulos objeto en la memoria.
Despus de crearse el mdulo de carga, ste es cargado por el cargador en la memoria del
ordenador y comienza la ejecucin. Para linkar con TASM escribimos:
tlink /v nombre Tras esto se nos crear el fichero ejecutable (.exe o .com) que el sistema operativo se
encargar de cargar en memoria cuando lo ejecutemos. De nuevo, la extensin no es necesaria
ponerla y el parmetro /v slo es til para el Turbo Debugger.

2.2 CICLOS NUMERICOS

Un bucle es un grupo de instrucciones que se ejecutan cclicamente un nmero concreto de veces.
Para construir bucles disponemos de las siguientes instrucciones:

stas posibilitan el grupo de control ms elemental de nuestros programas.
Un bucle es un bloque de cdigo que se ejecuta varias veces. Hay 4 tipos de bucles bsicos: o Bucles
sin fin o Bucles por conteo, Bucles hasta o Bucles mientras. Las instrucciones de control de bucles son
las siguientes:

INC incrementar

DEC decrementar

LOOP realizar un bucle

LOOPZ, LOOPE realizar un bucle si es cero
LOOPNZ, LOOPNE realizar un bucle si no es cero

JCXZ salta si CX es cero

2.3 CAPTURA BSICA DE CADENAS
Una cadena es una secuencia de bytes contiguos. Las operaciones que se pueden realizar sobre las
cadenas son las siguientes:

2.4 COMPARACION Y PRUEBA
Este grupo es una continuacin del anterior, incluye las siguientes instrucciones:

TEST verifica

CMP compara

2.5 SALTOS

JMP salta

JE, JZ salta si es igual a cero

JNE, JNZ salta si no igual a cero

JS salta si signo negativo

JNS salta si signo no negativo

JP, JPE salta si paridad par

JNP, JOP salta si paridad impar

JO salta si hay capacidad excedida

JNO salta si no hay capacidad excedida

JB, JNAE salta si por abajo (no encima o igual)

JNB, JAE salta si no est por abajo (encima o igual)

JBE, JNA salta si por abajo o igual (no encima)

JNBE, JA salta si no por abajo o igual (encima)

JL, JNGE salta si menor que (no mayor o igual)

JNL, JGE salta si no menor que (mayor o igual)

JLE, JNG salta si menor que o igual (no mayor)

JNLE, JG salta si no menor que o igual (mayor)

2.6 CICLOS DE CONDICIONALES
Ciclo For
La Sintaxis empleada por el ciclo for es la siguiente:

for (valores de entrada ; condicin de terminacin ; iteracin por ciclo)

Las tres partes del ciclo se encuentran separadas por ; (punto y coma)
La primer parte del ciclo especifica valores previos a su inicio.
La segunda parte indica la condicin de terminacin para el ciclo, la cual est directamente relacionada
con los valores iniciales.
Finalmente, la ltima parte especifica cmo sern manipulados los valores iniciales en cada iteracin
del ciclo.

Ciclo IF

Una caracterstica del ciclo if/else es el uso de llaves { }, en el ejemplo anterior pudo notar que no
fueron utilizadas llaves { } para delimitar las condicionales, al no emplearse este mecanismo, se
asume que el ciclo o condicional tendr efecto nicamente en la linea contigua a su inicio. Aunque es
recomendable utilizar llaves ({ } ) para incrementar la legibilidad del cdigo, es importante sealar que
esta sintaxis de no utilizar llaves ({ } ) es vlida y muy comn (Lamentablemente)
Existe otra variacin de if/else que agrupa las condicionales en una sola expresin:
if (expresion Boolean ? operacin verdadera : operacin falsa)

Ciclo While
En este ciclo el cuerpo de instrucciones se ejecuta mientras una condicin permanezca como
verdadera, en el momento en que la condicin se convierte en falsa el ciclo termina.
Su formato general es:
Cargar o inicializar variable de condicin;
While (condicin)
{ Grupo cierto de instrucciones;
Instruccin(es) para salir del ciclo;
};

2.7 INCREMENTO Y DECREMENTO

Las instrucciones del ensamblador
Instrucciones de transferencia Son utilizadas para mover los contenidos de los operandos. Cada
instruccin se puede usar con diferentes modos de direccionamiento.
MOV
MOVS (MOVSB) (MOVSW)
Instruccin MOV
Propsito: Transferencia de datos entre celdas de memoria, registros y acumulador.
Sintaxis:
MOV Destino, Fuente
Donde Destino es el lugar a donde se movern los datos y fuente es el lugar donde se encuentran
dichos datos.
Los diferentes movimientos de datos permitidos para esta instruccin son:
Destino: memoria. Fuente: acumulador
Destino: acumulador. Fuente: memoria
Destino: registro de segmento. Fuente: memoria/registro
Destino: memoria/registro. Fuente: registro de segmento
Destino: registro. Fuente: registro
Destino: registro. Fuente: memoria
Destino: memoria. Fuente: registro
Destino: registro. Fuente: dato inmediato
Destino: memoria. Fuente: dato inmediato

La instruccin MOV y los modos de direccionamiento. He aqu nuestra
primera instruccin:
MOV destino, origen

Efectivamente, sirve para mover. Lo que hace es copiar lo que haya en "origen" en "destino". Lo de
que primero vaya el destino y luego el origen es comn a todas las instrucciones del 8086 que
tengan dos operandos, lo cual crear ms de un quebradero de cabeza al principio.

MOV AX,BL

MOV AX, BX sin embargo hace que el procesador coja el contenido de BX y lo copiara en AX; lo que
haba anteriormente en AX se pierde (puesto que un registro al fin y al cabo es un nmero, en este
caso de
16 bits, y ahora le hemos asignado un nuevo valor), mientras que BX no se ve afectado. Cuando
decimos "mover" en realidad sera ms apropiado "copiar", porque no alteramos en absoluto el
operando origen.

2.8 CAPTURA DE CADENAS CON FORMATO
Permiten el movimiento, comparacin o bsqueda rpida en bloques de datos:

MOVC transferir carcter de una cadena

MOVW transferir palabra de una cadena
CMPC comparar carcter de una cadena

CMPW comparar palabra de una cadena

SCAC buscar carcter de una cadena

SCAW buscar palabra de una cadena

LODC cargar carcter de una cadena

LODW cargar palabra de una cadena

STOC guardar carcter de una cadena

STOW guardar palabra de una cadena

REP repetir

CLD poner a 0 el indicador de direccin

STD poner a 1 el indicador de direccin

2.9 INSTRUCCIONES ARITMTICAS

Instrucciones Aritmticas.

Estas instrucciones son las que realiza directamente el 8086/8088

a. Grupo de adicin:

ADD suma

ADC suma con acarreo

AAA ajuste ASCII para la suma

DAA ajuste decimal para la suma

b. Grupo de sustraccin:

SUB resta

SBB resta con acarreo negativo

AAS ajuste ASCII para la resta

DAS ajuste decimal para la resta

c. Grupo de multiplicacin:

MUL multiplicacin

IMUL multiplicacin entera

AAM ajuste ASCII para la multiplicacin

d. Grupo de divisin:

DIV divisin

IDIV divisin entera

AAD ajuste ASCII para la divisin

e. Conversiones:

CBW pasar octeto a palabra
CWD pasar palabra a doble palabra

NEG negacin
2.10 MANIPULACIN DE PILA
Una de las funciones de la pila del sistema es la de salvaguardar (conservar) datos (la otra es la de
salvaguardar las direcciones de retorno de las llamadas a subrutinas):
PUSH introducir

POP extraer POPF extraer indicadores

PUSHF introducir indicadores

2.11 OBTENCION DE CADENA CON REPRESENTACION HEXADECIMAL
Procesos de Control NOP (Operacin nula). Sintaxis:
NOP
Indicadores:

OF DF IF TF SF ZF AF PF CF
- - - - - - - -
Realiza una operacin nula, es decir, el microprocesador decodifica la instruccin y pasa a la
siguiente. Realmente se trata de la instruccin XCHG AX,AX. ESC (Salida a un coprocesador).
Sintaxis:
ESC cdigo_operacin, origen

Indicadores:

- - - - - - - -

Se utiliza en combinacin con procesadores externos, tales como los coprocesadores de coma flotante o
de E/S, y abre al dispositivo externo el acceso a las direcciones y operandos requeridos. Al mnemnico ESC
le siguen los cdigos de operacin apropiados para el coprocesador as como la instruccin y la direccin
del operando necesario.

Ejemplo:
ESC 21,AX
HLT (Parada hasta interrupcin o reset).
Sintaxis:
HLT

Indicadores:

- - - - - - - -
El procesador se detiene hasta que se restaura el sistema o se recibe una interrupcin. Como en los
PC se producen normalmente 18,2 interrupciones de tipo 8 por segundo (del temporizador) algunos

programadores utilizan HLT para hacer pausas y bucles de retardo. Sin embargo, el mtodo no es
preciso y puede fallar con ciertos controladores de memoria.

LOCK (Bloquea los buses).
Sintaxis:
LOCK

Indicadores:

- - - - - - - -

Es una instruccin que se utiliza en aplicaciones de recursos compartidos para asegurar que
no accede simultneamente a la memoria ms de un procesador. Cuando una instruccin va precedida
por LOCK, el procesador bloquea inmediatamente el bus, introduciendo una seal por la patilla LOCK.

WAIT (Espera).
Sintaxis:
WAIT

Indicadores:

- - - - - - - -

Provoca la espera del procesador hasta que se detecta una seal en la patilla TEST. Ocurre, por
ejemplo, cuando el coprocesador ha terminado una operacin e indica su finalizacin. Suele preceder
a ESC para sincronizar las acciones del procesador y coprocesador.

XLAT (traduccin).
Sintaxis:

XLAT tabla
Indicadores:

- - - - - - - - -

La instruccin XLAT tabla carga en el registro AL el contenido de la posicin [BX][AL], en donde el
registro BX ha de apuntar al comienzo de una tabla. Dicho de otra manera, AL hace de ndice de la
tabla y de almacn destino del contenido de la tabla.

Por ejemplo, el siguiente programa:
DATOS SEGMENT
TABLA DB 2, 3, 5, 8, 16, 23

DATOS ENDS
CODIGO SEGMENT
MOVE BX, OFFSET TABLA ;Inicializa BX con la direccin donde comienza la tabla

MOVE AL, 5

XLAT TABLA
CODIGO ENDS
Hace que al final el contenido de AL sea 16 ya que es el quinto elemento de la tabla y AL
antes de XLAT TABLA contena el valor 5. Otro ejemplo:
MOV BX, OFFSET TABLA
MOV AL, 4
XLAT TABLA

Para finalizar con las instrucciones de transferencia veremos un grupo de tres instrucciones:

LEA o cargar direccin efectiva
LDS o cargar el puntero en DS

LES o cargar el puntero en ES denominadas de transferencia de direcciones.

LEA (carga direccin efectiva). Sintaxis:
LEA destino, origen Indicadores:

- - - - - - - -

Transfiere el desplazamiento del operando fuente al operando destino. Otras instrucciones
pueden a continuacin utilizar el registro como desplazamiento para acceder a los datos que
constituyen el objetivo. El operando destino no puede ser un registro de segmento. En general,
esta instruccin es equivalente a MOV destino, OFFSET fuentey de hecho los buenos
ensambladores (TASM) la codifican como MOV para economizar un byte de memoria. Sin
embargo, LEA es en algunos casos ms potente que MOV al permitir indicar registros de ndice y
desplazamiento para calcular el offset:

En el ejemplo de arriba, el valor depositado en DX es el OFFSET de la etiqueta DATOS ms el registro
SI. Esa sola instruccin es equivalente a estas dos:

MOV DX, OFFSET DATOS ADD
DX, SI
LDS (carga un puntero utilizando DS). Sintaxis:
LDS destino, origen

Indicadores:

- - - - - - - -

Traslada un puntero de 32 bits (direccin completa de memoria compuesta por segmento y
desplazamiento), al destino indicado y a DS. A partir de la direccin indicada por el operando
origen, el procesador toma 4 bytes de la memoria: con los dos primeros forma una palabra que
deposita en destino y, con los otros dos, otra en DS.

Ejemplo:

PUNT DD 12345678H LDS SI,
PUNT
Como resultado de esta instruccin, en DS: SI se hace referencia a la posicin de memoria 1234h:
5678h; 'DD' sirve para definir una variable larga de 4 bytes (denominada PUNT en el ejemplo).

LES (carga un puntero utilizando ES). Sintaxis:
LES destino, origen

Esta instruccin es anloga a LDS, pero utilizando ES en lugar de D

2.12 INSTRUCCIONES LGICAS

Son operaciones bit a bit que trabajan sobre octetos o palabras completas:
NOT negacin

AND producto lgico

OR suma lgica

XOR suma lgica exclusiva

2.13 DESPLAZAMIENTO Y ROTACIN
Instrucciones de Desplazamiento Circular

RCL (Rotacin a la izquierda con acarreo).
Sintaxis:

RCL destino, contador

Indicadores:

x - - - - - - - x

Rotar a la izquierda los bits del operando destino junto con el indicador de acarreo CF el nmero
de bits especificado en el segundo operando. Si el nmero de bits a desplazar es 1, se puede
especificar directamente, en caso contrario el valor debe cargarse en CL y especificar CL como
segundo operando. No es conveniente que CL sea mayor de 7, en bytes; 15, en palabras.

Ejemplos: RCL
AX,1
RCL AL,CL RCL
DI,1
RCR (Rotacin a la derecha con acarreo).

Sintaxis:

RCR destino, contador

Indicadores:

x - - - - - - - x

Rotar a la derecha los bits del operando destino junto con el indicador de acarreo CF el nmero de
bits especificado en el segundo operando. Si el nmero de bits es 1 se puede especificar
directamente; en caso contrario su valor debe cargarse en CL y especificar CL como segundo
operando:

Ejemplos:RCR
BX,CL RCR BX,
ROL (Rotacin a la izquierda).

Sintaxis:

ROL destino, contador

Indicadores:

x - - - - - - - x

Rota a la izquierda los bits del operando destino el nmero de bits especificado en el segundo
operando, que puede ser 1 CL previamente cargado con el valor del nmero de veces.

Ejemplos: ROL
DX,CL ROL AH,1
ROR (Rotacin a la derecha). Sintaxis:
ROR destino, contador

Indicadores:

x - - - - - - - x

Rota a la derecha los bits del operando destino el nmero de bits especificado en el segundo
operando. Si el nmero de bits es 1 se puede poner directamente, en caso contrario debe
ponerse a travs de CL.

Ejemplos: ROR
CL,1
ROR AX,CL

2.14 OBTENCIN DE REPRESENTACION DE CADENAS DECIMAL
Instrucciones de Desplazamiento Lineal

AL/SHL (Desplazamiento aritmtico a la izquierda). Sintaxis:
SAL/SHL destino, contador

Indicadores:

X - - - x x ? x X
Desplaza a la izquierda los bits del operando el nmero de bits especificado en el segundo
operando que debe ser CL si es mayor que 1 los bits desplazados.

SAR (Desplazamiento aritmtico a la derecha). Sintaxis:
SAR destino, contador

Indicadores:

X - - - x x ? x x

Desplaza a la derecha los bits del operando destino el nmero de bits especificado en el segundo
operando. Los bits de la izquierda se rellenan con el bit de signo del primer operando. Si el
nmero de bits a desplazar es 1 se puede especificar directamente, si es mayor se especifica a
travs de CL.

Ejemplos: SAR AX,
CL
SAR BP,1

SHR (Desplazamiento lgico a la derecha). Sintaxis:
SHR destino, contador

Indicadores:

X - - - x x ? x x

Desplaza a la derecha los bits del operando destino el nmero de los bits especificados en el
segundo operando. Los bits de la izquierda se llena con cero. Si el nmero de bits a desplazar es 1
se puede especificar directamente en el caso en que no ocurra se pone el valor en CL:

Ejemplos: SHR
AX,CL SHR CL,1

2.15 CAPTURA Y ALMACENAMIENTO DE DATOS NUMERICOS
Bloques en ensamblador

MODELOS DE MEMORIA.

Los modelos de memoria constituyen las diversas maneras de acceder a la memoria por parte
de los compiladores de C. En el caso del Turbo C se pueden distinguir los siguientes:

TINY: Se emplea en los programas donde es preciso apurar el consumo de memoria hasta el ltimo
byte. Los 4 registros de segmento (CS, DS, ES, SS) estn asignados a la misma direccin, por lo que
existe un total de 64 Kb donde se mezclan cdigo, datos y pila. Los programas de este tipo pueden
convertirse a formato COM.
SMALL: Se utiliza en aplicaciones pequeas. Los segmentos de cdigo y datos son diferentes y no
se solapan. Por ello, hay 64 kb para cdigo y otros 64 Kb a repartir entre datos y pila.

Segmentos Punteros

Modelo Cdigo DatosPila Cdigo Datos

Tiny 64 Kbnear near

Small 64 Kb64 Kbnear near Medium 1 Mb
64 Kbfar near Compact 64 Kb1 Mb near
far Large 1 Mb 1 Mb far far
Huge 1 Mb 1 Mb

(Bloques > 64 Kb) far far

MEDIUM: Este modelo es ideal para programas largos que no manejan demasiados datos. Se utilizan
punteros largos para el cdigo (que puede extenderse hasta 1 Mb) y cortos para los datos: la pila y
los datos juntos no pueden exceder de 64 Kb.

COMPACT: Al contrario que el anterior, este modelo es el apropiado para los programas pequeos
que emplean muchos datos. Por ello, el programa no puede exceder de 64 Kb aunque los datos que
controla pueden alcanzar el Mb, ya que los punteros de datos son de tipo far por defecto.

LARGE: Empleado en las aplicaciones grandes y tambin por los programadores de sistemas que no
tienen paciencia para andar forzando continuamente el tipo de los punteros (para rebasar el lmite
de 64 Kb). Tanto los datos como el cdigo pueden alcanzar el Mb, aunque no se admite que los datos
estticos ocupen ms de 64 Kb. Este modo es el que menos problemas da para manejar la memoria,
no siendo quiz tan lento y pesado como indica el fabricante.

HUGE: Similar al anterior, pero con algunas ventajas: por un lado, todos los punteros son
normalizados automticamente y se admiten datos estticos de ms de 64 Kb. Por otro, y gracias a
esto ltimo, es factible manipular bloques de datos de ms de 64 Kb cada uno, ya que los segmentos
de los punteros se actualizan correctamente. Sin embargo, este modelo es el ms costoso en
tiempo de ejecucin de los programas.

Usando la pila

Una seccin de la memoria del programa es reservado para el uso de una pila. La Intel 80386 y
procesadores superiores contienen un registro llamado puntero a la pila, esp, el cual almacena la
direccin del tope de la pila, la figura 1 de abajo muestra 3 valores enteros, 49, 30 y 72, almacenados
en la pila(cada entero ocupando 4 bytes) con el registro esp apuntando a la direccin del tope de la
pila.

A diferencia de una pila creciendo hacia arriba, en las mquinas Intel crecen hacia abajo. En la Figura
2 muestra las capas de la pila despus de la ejecucin pushl $15.

El puntero de la pila es decrementado de cuatro en cuatro y el nmero
15 es almacenando como lugares de 4 bytes, 1988, 1989, 1990 y 1991

La instruccin popl %eax copia el valor del tope de la pila(4 bytes) a eax e incrementa esp en 4. Qu
sucede si no quieres copiar el valor del tope de la pila a un registro?. Puedes ejecutar la instruccin addl
$4, %esp el cual simplemente incrementa el puntero de la pila.

#Listing 3
.globl main main:

foo:
movl $10, %eax call
foo ret
addl $5, %eax ret

En Listing 3, la instruccin call foo pone la direccin de la instruccin despus de call en la llamada
al programa sobre la pila y va hacia foo. La subrutina termina con ret, el cual transfiere el control a
la instruccin cuya direccin se toma desde el tope de la pila. Obviamente el tope de la pila debe
contener una direccin vlida

2.16 OPERACIONES BASICAS SOBRE ARCHIVOS DE DISCO

ENTRADA Y SALIDA
Funciones que realiza

Vamos a sealar las funciones que debe realizar un computador para ejecutar trabajos de entrada/salida:
- Direccionamiento o seleccin del dispositivo que debe llevar a cabo la operacin
de E/S.
- Transferencia de los datos entre el procesador y el dispositivo (en uno u otro
sentido).
- Sincronizacin y coordinacin de las operaciones.

Esta ltima funcin es necesaria debido a la deferencia de velocidades entre los dispositivos y la CPU
y a la independencia que debe existir entre los perifricos y la CPU (por ejemplo, suelen tener relojes
diferentes).
e define una transferencia elemental de informacin como la transmisin de una sola unidad de
informacin (normalmente un byte) entre el procesador y el perifrico o viceversa. Para efectuar una
transferencia elemental de informacin son precisas las siguientes funciones: - Establecimiento de
una comunicacin fsica entre el procesador y el perifrico para la transmisin de la unidad de
informacin.
- Control de los perifricos, en que se incluyen operaciones como prueba y modificacin del estado del
perifrico. Para realizar estas funciones la CPU gestionar las lneas de control necesarias.

Definiremos una operacin de E/S como el conjunto de acciones necesarias para la transferencia de un
conjunto de datos (es decir, una transferencia completa de datos). Para la realizacin de una operacin
de E/S se deben efectuar las siguientes funciones:
- Recuento de las unidades de informacin transferidas (Normalmente bytes) para reconocer
el fin de operacin.
- Sincronizacin de velocidad entre la CPU y el perifrico.
- Deteccin de errores (e incluso correccin) mediante la utilizacin de los cdigos necesarios (bits de
paridad, cdigos de redundancia cclica, etc.)
- Almacenamiento temporal de la informacin. Es ms eficiente utilizar un buffer

temporal especfico para las operaciones de E/S que utilizan el rea de datos del
programa.
- Conversin de cdigos, conversin serie/paralelo, etc.

Dispositivos externos

Una de las funciones bsicas del ordenador es comunicarse con los dispositivos exteriores,
es decir, el ordenador debe ser capaz de enviar y recibir datos desde este dispositivo. Sin esta
funcin, el ordenador no sera operativo porque sus clculos no seran visibles desde el exterior.

Existe una gran variedad de dispositivos que pueden comunicarse con un ordenador, desde los
dispositivos clsicos (terminales, impresoras, discos, cintas, etc.) hasta convertidores A/D y D/A para
aplicaciones de medida y control de procesos, De todos los posibles perifricos, algunos son de
lectura, otros de escritura y otros de lectura y escritura (es importante resaltar que este hecho
siempre se mira desde el punto de vista del proceso). Por otra parte, existen perifricos de
almacenamiento tambin llamados memorias auxiliares o masivas.

La mayora de los perifricos estn compuestos por una parte mecnica y otra parte electrnica. Estas
partes suelen separarse claramente para
dar una mayor modularidad. A la componente electrnica del perifrico se le suele denominar
controlador del dispositivo o, tambin, adaptador del dispositivo. Si el dispositivo no tiene parte
mecnica (como, por ejemplo, la pantalla de un terminal), el controlador estar formado por la parte
digital del circuito. Frecuentemente los controladores de los dispositivos estn alojados en una placa
de circuito impreso diferenciada del resto del perifrico. En este caso es bastante habitual que un
mismo controlador pueda dar servicio a dispositivos de caractersticas similares.

El principal problema planteado por los perifricos es su gran variedad que tambin afecta a las
velocidades de transmisin. Por tanto, el mayor inconveniente que encontramos en los perifricos
es la diferencia entre sus velocidades de transmisin y la diferencia entre stas y la velocidad de
operacin del ordenador.

UNIDAD 3 MODULARIZACION
3.1 Macros.
Una macro es un grupo de instrucciones repetitivas en un programa que se codifican solo una vez y
pueden utilizarse cuantas veces sea necesario. La principal diferencia entre una macro y un
procedimiento es que en la macro se hace posible el paso de parmetros y en el procedimiento no
(esto es aplicable solo para el TASM, hay otros lenguajes de programacin que si lo
permiten). Al momento de ejecutarse la macro cada parmetro es sustituido por el nombre o valor
especificado al momento de llamarla.

Podemos decir entonces que un procedimiento es una extensin de un determinado
programa, mientras que la macro es un mdulo con funciones especficas que puede ser utilizado por
diferentes programas. Otra diferencia entre una macro y un procedimiento es la forma de llamar a
cada uno, para llamar a un procedimiento se requiere el uso de una directiva, en cambio la llamada a
las macros se realiza como si se tratara de una instruccin del ensamblador.

3.1.1 Internas.

Una macro es un conjunto de instrucciones que se pueden mandar a llamar desde cualquier parte
del programa. Para definir una macro, se utiliza la directiva MACRO. El formato de esta directiva es
: (nombre_de_macro) MACRO (lista_parmetros).Una macro interna es aquella que se declara y se
llaman dentro del mismo programa.

Una macro consta de tres partes esenciales:

a) CABECERA: Contiene el nombre de la macro la pseudo-op MACRO y opcionalmente ,variables ficticias
que sern pasadas desde la macro.

b) CUERPO: Contiene el cdigo real que ser insertado en cualquier programa que llame al nombre de
la macro.

c) FIN: Debe incluir la sentencia ENDM.

El nombre de esta macro es INICIO, aunque es aceptable cualquier otro nombre vlido que sea nico.
La directiva MACRO en la primer lnea indica al ensamblador que las instrucciones que
siguen, hasta ENDM (fin de la macro), son parte de la definicin de la macro. La directiva ENDM
termina la definicin de la macro. Las instrucciones entre MACRO y ENDM comprenden el cuerpo
de la definicin de la macro. Si su programa realiza frecuentemente funciones de entrada/salida,

las macros ofrecen la facilidad de codificar una sola vez un conjunto de instrucciones y reutilizar
el cdigo cuantas veces desee dentro de su programa.

3.1.2 Externas.

Una de las facilidades que ofrece el uso de las macros es la creacin de bibliotecas, las cuales son grupos
de macros que pueden ser incluidas en un programa desde un archivo diferente. La creacin de estas
bibliotecas es muy sencilla, nicamente tenemos que escribir un archivo con todas las macros que se
necesitarn y guardarlo como archivo de texto.

Para llamar a estas macros solo es necesario utilizar la instruccin Include
<Nombre_Del_Archivo>, en la parte de nuestro programa donde escribiramos
normalmente las macros, esto es, al principio de nuestro programa (antes de la declaracin del
modelo de memoria). Suponiendo que se guard el archivo de las macros con el nombre de
MACROS.TXT la instruccin Include se utilizara de la siguiente forma:

;Inicio del programa
Include MACROS.TXT
.MODEL SMALL
.DATA
;Aqui van los datos
.CODE
Inicio:
;Aqui se inserta el cdigo del programa
.STACK
;Se define la pila
End Inicio

3.2 Procedimientos.

Un procedimiento es un conjunto de instrucciones que tienen la finalidad de ejecutar una tarea
especifica dentro de un programa. Los procedimientos son muy similares a las macros.
Un procedimiento es un conjunto de instrucciones a los que podemos dirigir el flujo de nuestro
programa, y una vez terminada la ejecucin de dichas instrucciones se devuelve el control a la
siguiente lnea a procesar del cdigo que mando llamar al procedimiento. Un procedimiento se
declara una sola vez en el cdigo fuente y cuando el programa se ensambla y ejecuta, el
procedimiento se coloca en memoria para que pueda ser utilizado por el programa. Los
procedimientos nos ayudan a crear programas legibles y fciles de modificar. Sintaxis de un
procedimiento Existen dos tipos de procedimientos , los intrasegmentos, que se encuentran
en el mismo segmento de instrucciones y los intersegmentos que pueden ser almacenados
en diferentes segmentos de memoria. Las principales ventajas en el uso de procedimientos son:
permiten una codificacin ms limpia y compacta, es decir el cdigo fuente es ms pequeo; tambin
permiten el ahorro de memoria, esto es porque un mismo procedimiento puede ser llamado varias
veces en el mismo programa y slo requiere memoria una vez.

Los procedimientos tienen la desventaja de que reducen la velocidad de ejecucin de los programas,
esto se debe a la forma en que los procedimientos se ejecutan. A continuacin se presentan los
pasos necesarios para ejecutar un procedimiento:

1.- Se encuentra la llamada Call
2.- El microprocesador almacena en la Pila el contenido del IP
3.- Se coloca en el IP el valor del desplazamiento correspondiente al Procedimiento
4.- El microprocesador ejecuta las instrucciones del procedimiento
5.- El procedimiento termina cuando se encuentra la instruccin Ret
6.- Se saca de la pila el valor original del IP y se continua el flujo del programa

3.2.1 Internos.

Los procedimientos internos son aquellos que se declaran y se llaman dentro del mismo programa,
tambin son llamados procedimientos locales. El listado anterior muestra la forma de utilizar
procedimientos internos.

3.2.2 Externos.

Los procedimientos externos, a diferencia de los internos, se declaran en mdulos o
programas separados al programa donde el procedimiento es llamado, en otras palabras, la llamada
al procedimiento se encuentra en un programa y el procedimiento en otro. Para poder
utilizar procedimientos externos, es necesario que sean declarados como pblicos en el
programa donde se encuentran y que sean llamados como externos en el programa donde sern
usados. Cuenta con tres directivas de ensamble: .PUBLIC para declarar los procedimientos
como pblicos, .EXTERN para indicar que el procedimiento que se va a usar est fuera del programa
y .INCLUDE para enlazar el programa que contiene los procedimientos con el programa que los
llama. Con estas capacidades, es fcil crear bibliotecas de procedimientos y macros que puedan ser
utilizados constantemente por los dems programas, ahorrando con ello tiempo de
programacin al reutilizar cdigo fuente.
Por ejemplo Este programa muestra la forma de utilizar procedimientos y datos externos en los
programas por medio de las directivas de inclusin include y public.

.MODEL TINY
.INCLUDE proc2.ASM ;Incluir el archivo proc2.asm
;el cual contiene la variable de cadena ;Cad1 y los
procedimientos externos ;usados en este
programa.
.DATA
Cad2 db 'Esta es una cadena de prueba 2...',13,10,'$'
.CODE
INICIO: ;Punto de entrada al programa
Mov Dl,20 ;X=20
Mov Dh,10 ;Y=10
Call GotoXY ;GotoXY 20,10
Lea DX,Cad2 ;DX->Cad2 en Proc3.asm
Call Imprime_Cad ;Imprime Cad2
Lea DX,Cad1 ;DX->Cad1 en Proc2.asm
Call Imprime_Cad ;Imprime Cad1
Mov AX,04C00h ;Fin del programa
Int 21h ;
END INICIO
END

UNIDAD 4 PROGRAMACION DE DISPOSITIVOS
4.1 El Buffer De Video En Modo Texto

Buffer: Es la ubicacin de la memoria de un dispositivo digital o una computadora que
est reservada para el almacenamiento temporal de informacin. Mientras los datos
estn en el buffer, aguardan para ser procesados.
Un ejemplo de buffer tiene lugar cuando se intenta ejecutar aplicaciones de audio o video
directamente desde Internet, sin descargarlas a la computadora. Esta prctica, conocida
como streaming, requiere de la utilizacin de un buffer para reducir el riesgo de que se
corte la reproduccin ante problemas en el ancho de banda.

Abarcando los aspectos ms importantes del modo de video: ENDP

prepararPantalla proc near

mov ah, 06h;funcion de limpiar pantalla
mov bh, 80h;Atributos de color de fondo
mov al, 00h;cantidad de Filas a Borrar Enrollar

mov cx, 00h;columna inicial en Ch, Columna Inicial en Cl mov
dx, 30a0h;columna Final en Dh,Columna Final en Dl
int 10h

ret
prepararPantalla endp

para llamarlo debes hacerlo asi:

call prepararPantalla

En los atributos de color de fondo puedes ver un 80h, el primer nmero es el color del
fondo ( el 8) y el segundo es el color del texto ( el 0).
4.2 Acceso A Discos En Lenguaje Ensamblador

Para leer o escribir en un disco, no se realiza byte a byte, sino ms bien en bloques de
bytes, debido a que el acceso a disco implica movimientos mecnicos adems de que el
acceso se da por sectores; en este proceso no intervienen el CPU, puesto que solo enva
los comandos a la interface que maneja la unidad de disco y sta es la que se encarga de
leer o escribir informacin de un rea especial de memoria, llamada DMA; este
proceso es conocido como acceso directo a memoria.

El sistema de almacenamiento en disco constituye el soporte externo de la informacin.
Los datos se registran sobre la superficie del disco en una serie de circunferencias
concntricas llamadas pistas (track).
Varias pistas, una por cada cara del disco (generalmente 2), componen un Clster. Cada pista est
dividida en porciones iguales llamadas sectores (unidad bsica de almacenamiento en disco). El tamao
de un sector se mide en bytes, y depende de las caractersticas del disco. En esta seccin se presentan 3
rutinas que permiten lectura y escritura absoluta de sectores, as como la determinacin del espacio libre
disponible en un disco.

Rutina _AbsoluteRead: Transfiere el contenido de uno ms sectores del disco al buffer
especificado, accesando directamente a los sectores lgicos. En caso de error, se
enciende el bit de acarreo y AX contiene el cdigo del error.
Invocacin push <unidad de
disco> push <nmero de
sectores a leer> push <prime
r sector a leer> push
SEG <buffer>
push

OFFSET <buffer> call
_AbsoluteRead
PUBLIC _AbsoluteRead

_AbsoluteRead PROC NEAR

ARG Buffer:DWORD,Start:WORD,NumSect:WORD,Drive:BYTE= ArgLen push bp
;
salvar
BP
mov
bp,sp
; permitir acceso a los argumentos
push bx
; salvar
registros
push cx
push dx
push ds
mov
al,Drive
; lectura absoluta de
disco mov
cx,NumSect mov
dx,Start lds
bx,Buffer
i
n
t

2
5
h

p
o
p

b
x

p
o
p

d
s
; recuperar registros
p
o
p
d
x
p
o
p
c
x
p
o
p
b
x
p
o
p
b
p
r
e
t
A
r
g
L
e
n
_AbsoluteRead ENDP

Rutina _AbsoluteWrite: Transfiere el contenido del buffer especificado a uno o ms
sectores de disco, accesando directamente a los sectores lgicos. En caso de error, se
enciende el bit de acarreo y AX contiene el cdigo del error.
Invocacin: push <unidad de disco> push <nmero de sectores a escribir> push <primer sector a escribir>
push SEG <buffer
push OFFSET <buffer> call _AbsoluteWrite
PUBLIC _Absolut
eWrite
_AbsoluteWrit
e
PROC NEAR
ARG Buffer:DWORD,Start:WORD,NumSect:WORD,Drive:BYTE= ArgLen push bp
;
salvar
BP
mov
bp,sp
; permitir acceso a los argumentos
push bx
; salvar
registros
push cx
push dx
push ds
mov
al,Drive
; escritura absoluta a
disco mov
cx,NumSect mov
dx,Start lds bx,Buffer
i
n
t

2

6
h

p
o
p

b
x

p
o
p

d
s
; recuperar registros
pop dx
pop cx
pop bx
pop bp
ret
ArgLen
_Absolut
eWrite
ENDP
Rutina _FreeDiskSpace: Devuelve en DX:AX el espacio libre en disco (en Kb). En caso de error,
se enciende el bit de accarreo.

Invocacin:
push <unidad de disco>
call _FreeDiskSpace
PUBLIC _FreeDiskSpace
_FreeDiskSpace
PROC NEAR

ARG Drive:BYTE= ArgLen
push bp
; salvar

mov bp,sp
; permitir acceso a los argumentos push bx
; salvar registros
push cx mov ah,36h ;
funcin 36h mov
dl,Drive int 21h ; del
DOS mul cx ; DX:AX=
bytes por cluster
mov cx,1024 ; CX= 1
Kb div cx
; DX:AX= Kb por cluster
mul bx ; DX:AX= Kb libres
en el disco pop cx ;
recuperar registros pop
bx pop bp ret ArgLen
_FreeDiskSpace

4.3 Programacin Del Puerto Serial

Puerto serial, puerto COM, puerto de comunicaciones y puerto RS-232 ("Recomendad
Standard-232"), hacen referencia al mismo puerto. Se le llama serial, porque permite el
envo de datos, uno detrs de otro.
El puerto serie nos permite la facilidad de conectar nuestro ordenador personal

a cualquier
desarrollo realizado con microcontrolador.

Puerto Serial para la comunicacin en puerto serial debemos tomar en cuenta que existe
un dispositivo transmisor y un dispositivo receptor el cual se encuentra comunicado a
travs de una sola lnea de comunicacin, por lo tanto los nmeros binarios que se

transmiten se codifican a travs de un tren de pulsos. Dicha codificacin de los pulsos
deber ser interpretado por el dispositivo receptor, para ello se deben establecer
parmetros de hardware por los que se deber de transmitir la seal. De manera
general en MATLAB se deben realizar 2 procedimientos para configurar y manipular el
puerto serial. El primer paso es configuracin y el segundo es abrir el puerto serial.

PUERTO

Puerto serial COM integrado en la tarjeta
principal ("motherboard").

Smbolo del puerto COM.
Conector hembra serial del cable del
dispositivo.

caractersticas del puerto serial COM

En el mbito de la electrnica comercial se le denomina como conector
DB9 ("D-subminiature type B, 9 pin"), esto es D-subminiatura tipo B, con 9
Se utilizaba principalmente para la conexin del ratn (Mouse), algunos tipos
antiguos de escneres y actualmente para dispositivos como PDAs ("Personal
Digital Assistant") asistentes personales digitales.
Cada puerto, permite conectar solamente 1 dispositivo.
Para conectar y desconectar los dispositivos, as como para que la
computadora los reconozca de manera correcta, es necesario apagar y reiniciar la
computadora.
Terminales elctricas del puerto serial

El puerto serial cuenta con 9 contactos tipo pin; se muestran las lneas elctricas y su
descripcin bsica
1.- DCD (Detecta la portadora)

2.- RxD (Recibe datos)
3.- TxD (Transmite datos)
4.- DTR (Terminal de datos listo)
5.- SG (Tierra)
Esquema de las lneas del puerto serial COM.

6.- DSR (Equipo de datos listo)

7.- RTS (Solicita enviar)
8.- CTS (Disponible para enviar)
9.- RI (Indica llamada)
El uso principal que se le asignaba era para conectar el ratn (Mouse), e incluso
escneres, pero con la salida al mercado del puerto USB se dej de utilizar con este fin. Un
uso actual es para conectar algunos tipos de PDAs, agendas electrnicas, conexiones
directas entre computadoras ("Laplink"), dispositivos electrnicos para prcticas
acadmicas y colectoras de datos.

Para programar cualquier microcontrolador necesitas dos elementos:

Tipos de Comunicaciones Seriales:

La Existen dos tipos de comunicaciones seriales: la sncrona y asncrona .En la comunicacin serial
sincrona adems de una lnea sobre la cual se transmitirn indicaran cuando un datos es vlido.

Ejemplos de este tipo de comunicacin son:

I2C
ONE WIRE
SPI
En la comunicacin serial asncrona, no son necesarios los pulsos de reloj.

La duracin de cada bit esta determinada por la velocidad con la cual se realiza la
transferencia de datos.
La siguiente figura muestra la estructura de una carcter que se trasmite en forma

Pasos para poder enviar datos a travs del Puerto Serial:
Insertar el control MS Comm sobre la forma:
Establecer las siguientes propiedades:
ComPort:
Settings:
Handshaking:
Abrir el puerto, si este ya est abierto por otra aplicacin, entonces se debe cerrar esa aplicacin, para
despus volverlo a abrir el puerto con una aplicacin en

Visual Basic, esto se hace utilizando la siguiente instruccin: MSComm1.Portopen = true

Definir el tamao del buffer receptor, esto se hace con la propiedad InputLen MSComm1.InputLen =
1024

Enviar los datos que se desean
Cuando la aplicacin se termine se debe cerrar el puerto.

Aplicacin #1

1. Cree un Nuevo proyecto Form1 (es creado por default).

2. Seleccione del men Project ,verifique que el control MicrosoftComm, este en la barra
de herramientas
3. Agregue el control MSCOMM a la forma.

4. Agregue 2 controles Command Buttons a la forma. Agregue el siguiente cdigo a sus
respetivos controles:
Option Explicit
Const Xon = &H11

Const Xoff = &H13

Private Sub Form_Load()

Form1.Caption = "Primera aplicacin con el Puerto Serial

With MSComm1

.Handshaking = 2 - comRTS

.RThreshold = 1

.RTSEnable = True

.Settings = "9600,n,8,1"

.SThreshold = 1

.PortOpen = True

End With

Command1.Caption = "&Send Xoff"
Command2.Caption = "Send &Xon"
End Sub
Private Sub Command1_Click()

MSComm1.Output = "123456789" & Chr$(Xoff)
End Sub

Private Sub Command2_Click()

MSComm1.Output = "987654321" & Chr$(Xon)
End Sub

Private Sub Form_Unload(Cancel As Integer)
MSComm1.PortOpen = False
End Sub

c
l
e
a
r
a
l
l
;
c
l
o
s
e
a
l
l
;
c
l
c
;

PS = serial('COM1')

set(PS,'Baudrate',9600);%Se configura la velocidad a 9600 bps
set(PS,'StopBits',1);%Se configura el bit de paro
set(PS,'DataBit',8);%Se configura que el dato es de 8 bits
set(PS,'Parity','none');%Se configura la paridad
set(PS,'Terminator','CL/RF');%"c" carcter con que se
finaliza el envo set(PS,'OutputBufferSize',1);%"n" es
el nmero de bytes a enviar
set(PS,'InputBufferSize',1);%"n" es el nmero de
bytes a recibir set(PS,'Timeout',5);% 5 Segundos de
tiempo de espera.
fopen(PS)

Para leer los datos del puerto serial se debe poner la instruccin

variable = fread(PS,1,'uint8');

Para escribir el dato en el puerto serial se ocupa la siguiente instruccin
Fwrite (PS,variable,'uint16'); Finalmente, nunca vez que lees del puerto o escribes en el se debe de
cerrar a travs de las instrucciones

Close (PS);
Delete
(PS);
Clear PS;

UART.- Decodifica serial a paralelo.

DSP .- Dispositivo Digital Programable.
4.4 Programacin Del Puerto Paralelo

Conocido tambin con el nombre de CENTRONICS INTERFACE transmite los datos en
paralelo mediante un bus de 8 lneas ms las lneas de control del protocolo y del estado
de la impresora, esto nos permite disponer de varias lneas digitales que podremos
controlar independientemente y de forma inmediata mediante las instrucciones
de control de puertos (por ejemplo: outportb(), inportb() en C++). Esto hace
que podamos, de forma muy sencilla, controlar directamente dispositivos
electrnicos como pueden ser Leds, microreles, pulsadores, etc...

El puerto paralelo tiene dos inconvenientes fundamentales; el primero es que cada vez
menos PC los llevan incorporado y el segundo es que cuando trabajamos con un
sistema operativo Windows XP, NT y 2000, necesitamos un driver que nos permita
acceder a los puertos.

Descripcin Fsica Del Conector.

El puerto paralelo del pc dispone de un conector subD de 25 pines hembra al que normalmente
conectamos un cable Centronics de impresora que en un extremo tiene el conector SubD
25 pines macho y por el otro un conector Centronics de 36 pines. La asignacin de pines, tanto
en el conector D-25 como en el Centronics es la siguiente:

Pin

(ND- N(Ce Pntronics) in Lnea Puerto SPP Direccin Registro(bit) 25)

1

1 -Strobe
Entrada/

Salida
Control(0)
2 2 D0 Salida Datos(0)
10 10 -Ack Entrada Estado(6)

11 11 Busy Entrada Estado(7)
12 12 Paper-out Entrada Estado(5)
13 13 Select Entrada Estado(4)

14

14 -Auto-Linefeed
Entrada/

Salida
Control(1)
15 32 -Error Entrada Estado(3)

16

31 -Initialize
Entrada/

Salida
Control(2)

17

36 -SelecPrinter
Entrada/

Salida
Control(3)
18
19 -30 GND TIERRA

25

Acceso A Los Puertos.

Para el control de estas lneas utilizamos tres puertos que estn direccionados segn la siguiente
tabla:

Puerto Direccin Direccin
LPT1 LPT2
Datos 378H 278H
Estado 379H 279H

*FELIPE CAMPOS AVILES
Con estas dos tablas podemos modificar o leer cualquiera de las lneas del puerto paralelo
mediante el uso de las instrucciones de acceso a puerto, para C++ estas son outportb e inportb,
para Delphi no hay, por lo que tendrs que usar los dos procedimientos siguientes:

// Envia el valor almacenado en num a puerto.
Procedure EnviaByte(puerto:word;num:Byte); begin
asm
Mov DX,puerto Mov
AL,num
Out DX,AL end;
end;

// Lee el valor actual de puerto.
Control 37AH 27AH

Function RecibeByte(puerto:word):Byte; begin
asm
Mov DX,puerto
IN Al,DX
Mov @Result,Al end;
end;

Este es un programa para enviar distintas secuencias al puerto paralelo y as

tener efectos con Leds.

; Programacin en Ensamblador
; Ejemplo de escritura en puertos
; VILLARREAL ROMERO MAGDALENA
; mag_fairy.sweet@hotmail.com
; Este programa tiene como funcin demostrar como se puede escribir datos en un
; puerto, en este caso usamos el puerto paralelo del PC el cual es sencillo
; de visualizar conectando 8 leds a los pines 2 a 9 cada uno en serie con una ;
resistencia de 220 ohms, los datos visualizados corresponden a las valores
; ASCII de la tecla presionada.
; el programa termina cuando se presiona *
;Declaracin del segmento de pila
STACK SEGMENT PARA STACK 'STACK'
DB 256 DUP(0) ;256 BYTES DE ESPACIO EN EL STACK
STACK ENDS
ASSUME CS:COD ,DS:COD
COD SEGMENT
; Mensajes
MES1 DB 'EJEMPLO DE ACCESO A PUERTOS VILLARREAL ROMERO MAGDALENA JULIO 15 DE
2013','$'
MES2 DB 'OPRIMA * PARA SALIR','$'

MES3 DB 'ADIOS','$'
MENSAJE DW 0 MAIN
PROC FAR
*FELIPE CAMPOS AVILES
MOV AX,CS
MOV DS,AX
; Escribir mensaje inicial
; EJEMPLO DE ACCESO A PUERTOS VILLARREAL ROMERO MAGDALENA JULIO 15 DE 2013
; OPRIMA * PARA SALIR
MOV MENSAJE,OFFSET MES1 CALL
ESCRIBIR
MOV MENSAJE,OFFSET MES2
CALL ESCRIBIR
;Bucle principal que captura los caracteres del teclado y enva su valor ASCII
; al bus de datos del puerto paralelo el corresponde a la direccin 378h bucle:
; LEE EL CARACTER DEL TECLADO
MOV AH,1
MOV DL,0FFH

INT 21H
; Verifica si el carcter corresponde al * para salir del programa CMP
AL,'*' ;Compara el valor de AL con el valor ASCII del asterisco
JE ADIOS ;si la anterior comparacin dio igual saltar a adis
MOV DX,378H ; DIRECCION DEL PUERTO PARALELO
; El comando OUT tiene como funcin escribir en el puerto cuya direccin de 16 bits
;se encuentra almacenada en DX, el valor a escribir de 8 bits se almacena en AL OUT
DX,AL
JMP bucle
MAIN ENDP
;Rutina para desplegar mensajes
ESCRIBIR PROC NEAR
PUSH AX
PUSH DX
MOV AH,09H
MOV DX,MENSAJE
INT 21H

MOV AH,06
MOV DL,0DH
INT 21H
MOV AH,06H
MOV DL,0AH
INT 21H
POP DX
POP AX
RET
ESCRIBIR ENDP
; Rutina de salida
ADIOS:
;Se escribe un return o alimentacion de linea
MOV AH,06
MOV DL,0DH
INT 21H
MOV AH,06H
MOV DL,0AH
INT 21H
; Se escribe adis.
MOV MENSAJE,OFFSET MES3
CALL ESCRIBIR
; La funcio 4CH de la inte 21HF devuelve el control al sistema operativo
MOV AH,4CH
INT 21H
COD ENDS
END MAIN

4.5 Programacin Hbrida

La programacin hbrida proporciona un mecanismo por medio
del cual podemos aprovechar las ventajas del lenguaje
ensamblador y los lenguajes de alto nivel, todo esto con el fin
escribir programas ms rpidos y eficientes.
En esta seccin se mostrar la forma para crear programas hbridos
utilizando el lenguaje ensamblador y Turbo Pascal.
Turbo Pascal permite escribir procedimientos y funciones en
cdigo ensamblador e incluirlas como parte de los programas en
lenguaje Pascal; para esto, Turbo Pascal cuenta con dos palabras
reservadas:
Assembler y Asm.
Assembler permite indicarle a Turbo Pascal que la rutina o procedimiento que
Se est escribiendo est totalmente escrita en cdigo ensamblador.
EJEMPLO:
Procedimiento hbrido: }
Procedure Limpia_Pantalla; Assembler;
Asm
Mov AX,0600h
Mov BH,18h
Mov 78
CX,0000h Mov DX,184Fh Int 10h
End;

El procedimiento del listado 23 utiliza la funcin 06h de la Int
10h del BIOS para limpiar la pantalla, este procedimiento es
anlogo al procedimiento ClrScr de la unidad CRT de Turbo
Pascal.

4.6 Programacin De Puerto USB (Universal Serial Bus).

Lnea serial universal de transporte de datos. Es un conector rectangular de 4 terminales que
permite la transmisin de datos entre una gran gama de dispositivos externos
(perifricos) con la computadora; por ello es considerado puerto;
mientras que la definicin de la Real Academia Espaola de la lengua es "toma de conexin
universal de uso frecuente en las computadoras".

Smbolo de USB El puerto USB 1.0 reemplaz totalmente al Gameport. Caractersticas del
puerto USB

La versin USB 1.0 Aparece en el mercado, junto con el
lanzamiento del microprocesador Intel Pentium II en
1997.
Cada puerto, permite conectar hasta 127 dispositivos
externos, pero solo se recomiendan como mximo 8,
porque se satura la lnea del puerto y se ralentiza el
sistema al tener que administrarse todos
simultneamente.
Cuenta con tecnologa "Plug&Play" la cual permite
conectar, desconectar y reconocer dispositivos sin
necesidad de reiniciar apagar la computadora.
Las versiones USB 1.X y USB 2.0 transmiten en un medio
unidireccional los datos, esto es solamente se enva
recibe datos en un sentido a la vez, mientras que la
versin USB 3 cuenta con un medio Duplex que permite
enviar y recibir datos de manera simultnea.
A pesar de que el puerto USB 3, est actualmente
integrado ya en algunas placas de nueva generacin, an
no hay dispositivos comerciales/populares para esta
tecnologa.

Hay 2 formas de medir la velocidad de transmisin de datos del puerto USB:

1. En MegaBytes
/segundo (MB/s).

2. En Megabits por
segundo (Mbps).

Un error tpico, es creer que lo anterior es lo mismo, debido a que los
fabricantes manejan en sus descripciones de producto la segunda cantidad,
pero no es as. Existe una equivalencia para realizar la trasformacin de
velocidades con una simple "regla de tres":
8 Mbps (Megabits por segundo) = 1 MB/s (MegaByte/segundo)

Ejemplo: si el fabricante de una memoria USB, seala que
su producto tiene una velocidad de transmisin de hasta 480
Mbps, entonces:

Velocidad en MB/s = (480 Mbps X 1 MB/s) / 8 Mbps

Velocidad en MB/s = (480 MB/s) / 8

Velocidad en MB/s = 60 MB/s

Uso
Especfico
del puerto
USB.

Se utilizan para conectar todo tipo de dispositivos, tales como memorias USB, cmaras
fotogrficas digitales, videocmaras digitales, dispositivos para captura de video,
reproductores MP3, impresoras, reproductores MP4, discos duros externos, grabadores de
CD-DVD externos, conexin directa entre computadoras (Laplink), reproductores iPOD de

Apple, etc., mientras que la versin USB 3 tendr el objetivo de aumentar de manera radical
las velocidades de transmisin entre los anteriores dispositivos con las computadoras.

TRADUCCIONES
PCASM BOOK
1.2.2 El CPU
La Unidad Central de Procesamiento (CPU ) es el
dispositivo fsico que lleva a cabo las instrucciones.
Las instrucciones que realizan las CPU son
generalmente muy simple .
Las instrucciones pueden requerir los datos que
actan sobre estar en lugares especiales de
almacenamiento en la CPU y esta llamada registros.
La CPU puede acceder a los datos en los registros
mucho ms rpido que los datos en la memoria . Sin
embargo , el nmero de registros en una CPU es
limitado, por lo que el programador debe tener cuidado
de mantener los datos utilizados en la actualidad slo
en los registros .
Las instrucciones de un tipo de CPU ejecuta
conforman el lenguaje de mquina de la CPU.
Programas de la mquina tienen una estructura mucho
ms bsico que las lenguas higherlevel . Instrucciones
en lenguaje mquina se codifican como nmeros en
bruto , no en los formatos de texto amistosos. Una CPU
debe ser capaz de decodificar el propsito de una
instruccin muy rpidamente para funcionar de
manera eficiente . El lenguaje de mquina est
diseada con este objetivo en mente , para no ser
fcilmente descifrado por los seres humanos . Los
programas escritos en otros idiomas deben ser
convertidos al lenguaje de mquina nativo de la CPU
para ejecutarse en el ordenador. Un compilador es un

programa que traduce programas escritos en un
lenguaje de programacin en el lenguaje de mquina
de una arquitectura de computadora en particular . En
general, todo tipo de CPU tiene su propio lenguaje de
mquina nica. Esta es una razn por la cual los
programas escritos para un Mac no se pueden ejecutar
en un PC de tipo IBM .
Los equipos utilizan un reloj para sincronizar la ejecucin de las
instrucciones.
Los impulsos del reloj a una frecuencia fija (conocida como la velocidad de
reloj). Cuando usted compra una computadora 1.5 GHz, 1.5 GHz es la
frecuencia de reloj. El reloj no hace un seguimiento de los minutos y los
segundos. Simplemente late a un ritmo constante. La electrnica de la CPU
utiliza los latidos para llevar a cabo sus operaciones de forma correcta, como
la forma de los latidos de una ayuda del metrnomo se toca msica en el ritmo
correcto. El nmero de beats (o como se les suele llamarse ciclos) una
instruccin requiere depende de la generacin de la CPU y del modelo. El
nmero de ciclos depende de las instrucciones que se le han y otros factores
tambin.
1.2.3 La familia 80x86 de CPUs
De tipo IBM PC contienen una CPU de la familia 80x86
de Intel (o un clon de uno ) . Los de la CPU en esta
familia todos tienen algunas caractersticas comunes,
como un lenguaje de la mquina base. Sin embargo ,
los miembros ms recientes mejoran en gran medida
las caractersticas.8088,8086 : Estos CPU de desde el
punto de vista de programacin son idnticos. Eran la
CPU del utilizado en el primer PC. Ofrecen varios
registros de 16 bits : AX , BX , CX , DX , SI, DI , BP ,
SP, CS , DS, SS , ES, IP , BANDERAS . Ellos slo
admiten un mximo de un megabyte de memoria y slo
funcionan en modo real. En este modo , un programa
puede acceder a cualquier direccin de memoria ,
incluso la memoria de otros programas ! Esto hace que
la depuracin y la seguridad muy difcil ! Adems, la

memoria de programa tiene que ser dividido en
segmentos . Cada segmento no puede ser mayor que
64 KB .
80286 : Esta CPU se utiliza en la clase PC de AT. Se
aade algunas nuevas instrucciones al lenguaje
mquina de base de la 8088/86 . Sin embargo , su
nueva funcin principal es el modo protegido de 16 bits
. En este modo , se puede acceder a un mximo de 16
megabytes y proteger los programas de acceso a la
memoria de cada uno. Sin embargo , los programas
siguen divididos en segmentos que no podra ser ms
grande que 64 KB .
80386 : Esta CPU mejorado en gran medida el 80286
. En primer lugar, se extiende a muchos de los registros
de celebrar 32 -bits ( EAX , EBX , ECX , EDX , ESI ,
EDI, EBP , ESP, EIP ) y aade dos nuevos registros
de 16 bits FS y GS . Tambin agrega un nuevo modo
protegido de 32 bits. En este modo , se puede acceder
a un mximo de 4 gigabytes. Los programas se dividen
a su vez en segmentos, pero ahora cada segmento
tambin puede ser de hasta 4 gigabytes de tamao !
80486/Pentium/Pentium Pro : Estos miembros de la
familia 80x86 aadir muy pocas novedades. Aceleran
principalmente por la ejecucin de las instrucciones.
Pentium MMX : Este procesador aade las
instrucciones MMX ( MultiMedia extensiones) para el
Pentium . Estas instrucciones pueden acelerar las
operaciones de grficos comunes.
Pentium II: Este es el procesador Pentium Pro con las
instrucciones MMX agreg. ( El Pentium III es
esencialmente slo un Pentium II ms rpido . )
1.2.4 8.086 registros de 16 bits

El 8086 CPU original contemplaba cuatro de 16 bits
registros de propsito general : AX , BX , CX y DX .
Cada uno de estos registros se puede descomponer
en dos registros de 8 bits . Por ejemplo , el registro AX
podra descomponerse en la AH y AL registra como
figura 1.5 muestra . El registro AH contiene los
superiores ( o alto) con 8 bits de AX y AL contiene los
8 bits inferiores de AX .
A menudo AH y AL se utilizan como registros de un
byte independientes , sin embargo , es importante
darse cuenta de que no son independientes de AX.
Cambiar AX de valor cambiar AH y AL y viceversa.
Los registros de propsito general se utilizan en
muchas de las instrucciones de movimiento de datos y
aritmticas .
Hay dos registros ndice de 16 bits : SI y DI . A menudo se
utilizan como punteros , pero puede ser utilizado por muchas
de las mismas tareas que en general registros . Sin
embargo, no se pueden descomponer en registros de 8 bits
.
Los registros de BP y SP 16 bits se utilizan para
apuntar a los datos en la mquina pila lengua y se
llama el puntero base y Stack Pointer, respectivamente
. Estos sern discutidos ms adelante.
Los registros CS , DS , SS y ES 16 bits son los
registros de segmento . ellos denotar lo que la
memoria se utiliza para las diferentes partes de un
programa . gradas CS para el cdigo de segmento ,
DS para el segmento de datos , SS de Pila de
segmentos y ES para

Segmento Extra. ES se utiliza como un registro de
segmento temporal. Los detalles de estos registros se
encuentran en las secciones 1.2.6 y 1.2.7 .
El puntero de instrucciones ( IP) registro se utiliza con
el registro CS para realizar un seguimiento de la
direccin de la siguiente instruccin a ejecutar por el
De la CPU. Normalmente , como se ejecuta una
instruccin , IP es avanzado para que apunte a la
siguiente instruccin en la memoria. El registro de
banderas almacena informacin importante sobre los
resultados de una instruccin anterior. Estos
resultados se almacenan como bits individuales en el
registrarse. Por ejemplo , el bit Z es 1 si el resultado de
la instruccin anterior fue cero o 0 si no es cero . No
todas las instrucciones que modifican los bits de
banderas, consulte la tabla en el apndice para ver
como instrucciones individuales afectan el registro de
banderas .
1.2.5 80.386 registros de 32 bits
Los procesadores 80386 y posteriores han ampliado
los registros. Por ejemplo, el registro AX 16 bits se
extiende a ser de 32-bits. Para ser compatible hacia
atrs, AX todava se refiere al registro de 16 bits y EAX
se utiliza para referirse a la extendida registro de 32
bits. AX es los 16 bits ms bajos de EAX igual al es el
8-bits ms bajos de AX (y
EAX). No hay manera de acceder a los 16 bits superiores de EAX directamente.
Los otros registros extendidos son EBX, ECX, EDX, ESI y EDI.
Muchos de los otros registros se extienden tambin.
BP se convierte en EBP; SP se convierte en ESP;
BANDERAS convierte EFLAGS e IP se convierte EIP.
Sin embargo, a diferencia del ndice y registros de
propsito general, en modo protegido de 32 bits (vase

ms adelante) se utilizan slo las versiones extendidas
de estos registros.
Los registros de segmento siguen siendo de 16 bits en
el 80386. Tambin hay dos nuevos registros de
segmento: FS y GS. Sus nombres no significan nada.
Son registros de segmentos temporales adicionales
(como EN).
Una de las definiciones de la palabra trmino se refiere
al tamao de los registros de datos de la CPU. Para la
familia 80x86, el trmino es ahora un poco confuso. En
la Tabla 1.2, se ve que la palabra se define como 2
bytes (o 16 bits). Se le ha dado este significado cuando
el 8086 fue lanzado primero. Cuando el 80386 fue
desarrollado, se decidi dejar la definicin de la
palabra sin cambios, a pesar de que el tamao del
registro cambi.
1.2.6 Modo Real
En modo real , la memoria se limita a slo un megabyte ( 220 bytes ) .
Rango de direcciones Vlido desde (en hexadecimal )
00000 a FFFFF . Estas direcciones requieren un 20 -
el nmero de bit . Obviamente , un nmero de 20 bits
no se ajusta a ninguno de los registros de la 8086 de
16 bits. Intel soluciona este problema, mediante el uso
de dos valores de 16 bits para determinar una
direccin. El primer valor de 16 bits se llama el selector
. Valores de selectores deben ser almacenados en los
registros de segmento . El segundo valor de 16 bits se
llama el desplazamiento . La direccin fsica que hace
referencia un selector de 32 bits : offset par es
calculado por la frmula 16 selector + offset
Multiplicar por 16 en hexadecimal es fcil, slo tiene
que aadir un 0 a la derecha del nmero . Por ejemplo

, las direcciones fsicas que se hace referencia por
047C : 0048 viene dada por :
047C0
0048
04808
En efecto , el valor del selector es un nmero del prrafo (
vase el Cuadro 1.2 ) . Direcciones Bienes segmentados
tienen desventajas :
Un solo valor del selector slo puede hacer
referencia a 64K de memoria (el lmite superior de la
16 bits de desplazamiento ) . Qu pasa si un
programa tiene ms de 64 KB de cdigo? Un valor
nico en CS no se puede utilizar para toda la ejecucin
del programa. El programa debe ser dividido en
secciones (denominadas segmentos) de menos de 64
KB de tamao. Cuando la ejecucin se mueve desde
un segmento a otro, el valor de CS debe ser cambiado.
Problemas similares ocurren con grandes cantidades
de datos y los registro DS.
Esto puede ser muy incmodo!
Cada byte en la memoria no tiene una direccin
segmentada nica. El 04808 direccin fsica puede
hacer referencia a 047C: 0048, 047D: 0038, 047E:
0028 o 047B: 0058. Esto puede complicar la
comparacin de direcciones segmentados. 1.2.7 de 16
bits en modo protegido
En el modo de 16 bits protegido del 80286, los valores
de selector se interpretan completamente diferente
que en modo real. En el modo real, un valor de selector
es un nmero del prrafo de la memoria fsica. En el
modo protegido, un valor de selector es un ndice en
una tabla de descriptores. En ambos modos, los

programas se dividen en segmentos. En el modo real,
estos segmentos estn en posiciones fijas en la
memoria fsica y el valor del selector de puntos marca
el nmero de prrafo del principio del segmento. En el
modo protegido, los segmentos no estn en posiciones
fijas en la memoria fsica. De hecho, que no tienen que
estar en la memoria en absoluto!
El modo protegido usa una tcnica llamada memoria
virtual. La idea bsica de un sistema de memoria virtual
es slo para mantener los datos y el cdigo en la
memoria que los programas estn utilizando
actualmente. Otros datos y el cdigo se almacenan
temporalmente en el disco hasta que se necesiten de
nuevo. En el modo protegido de 16 bits, los segmentos
se mueven entre la memoria y el disco, segn sea
necesario. Cuando un segmento se devuelve a la
memoria desde el disco, es muy probable que se
puede poner en un rea diferente de la memoria que
estaba antes de ser movido en el disco. Todo esto se
hace de forma transparente por el sistema operativo.
El programa no tiene que ser escrito de manera
diferente para la memoria virtual para trabajar.
En el modo protegido, cada segmento se le asigna una
entrada en una tabla de descriptores. Esta entrada
tiene toda la informacin que el sistema necesita saber
sobre el segmento. Esta informacin incluye: es
actualmente en la memoria, y si en la memoria,
dnde est; permisos de acceso (por ejemplo, de
slo lectura). El ndice de la entrada del segmento es
el valor del selector que se almacena en registros de
segmento.
Una gran desventaja de modo protegido de 16 bits es
que las compensaciones son todava cantidades de 16

bits. Como consecuencia de esto, tamaos de
segmento son todava limitados Toat ms de 64K. Esto
hace que el uso de grandes matrices problemtica!
1.2.8 de 32 bits en modo protegido
El 80386 introdujo el modo protegido de 32 bits. Hay dos
diferencias principales entre 386 de 32 bits y 286 modos de 16
bits protegidas:
1. Las compensaciones se expandieron a ser de 32-
bits. Esto permite un desplazamiento en un rango de
hasta 4 millones de dlares. Por lo tanto, los
segmentos pueden tener tamaos de hasta 4
gigabytes.
2. Los segmentos pueden ser divididos en unidades
de 4K de tamao ms pequeos llamados pginas. El
sistema de memoria virtual trabaja con pginas ahora
en lugar de segmentos.
Esto significa que slo las partes del segmento pueden
estar en la memoria en cualquier momento. En 286 el
modo de 16 bits, o bien todo el segmento est en la
memoria o nada de esto es. Esto no es prctico Con
los segmentos de mayor tamao que el modo de 32
bits permite. En Windows 3.x, modo estndar se
refiere a 286 modo protegido de 16 bits y el modo
mejorado se refiere al modo de 32 bits. Windows 9X,
Windows NT/2000/XP, OS / 2 y Linux todos se
ejecutan en modo protegido de 32 bits paginado.
1.2.9 Interrupciones
A veces el flujo normal de un programa debe ser
interrumpido para procesar los eventos que requieren
una respuesta rpida. El hardware de un ordenador
proporciona un mecanismo llamado interrumpe para
controlar estos eventos. Por ejemplo, cuando se
mueve el ratn, el hardware del ratn interrumpe el

programa en curso para manejar el movimiento del
ratn (para mover el cursor del ratn, etc) Control
causa interrupciones para ser pasado a un manejador
de interrupciones. El manejador de interrupciones son
rutinas que procesan la interrupcin. Cada tipo de
interrupcin se le asigna un nmero entero. Al
comienzo de la memoria fsica, una tabla de vectores
de interrupcin reside que contiene las direcciones
segmentados de los controladores de interrupcin. El
nmero de interrupciones es esencialmente un ndice
en esta tabla.
Las interrupciones externas son criados desde fuera
del CPU. (El ratn es un ejemplo de este tipo.) Muchos
de los dispositivos de E / S plantean interrupciones
(por ejemplo, teclado, temporizador, unidades de
disco, CD-ROM y tarjetas de sonido). Interrupciones
internas son criados desde el interior de la CPU, ya sea
de un error o de la instruccin de interrupcin.
Interrupciones de error tambin se llaman trampas.
Interrupciones generadas a partir de la instruccin de
interrupcin se llaman interrupciones de software.
DOS utiliza este tipo de interrupciones para
implementar su API (Interfaz de Programacin de
Aplicaciones). Sistemas operativos ms modernos
(como Windows y UNIX) utilizan una interfaz de C
basado.
Muchos controladores de interrupcin devuelven el
control al programa interrumpido cuando terminen.
Restauran todos los registros a los mismos valores que
tenan antes de producirse la interrupcin. As, el
programa interrumpido se ejecuta como si nada
hubiera pasado (salvo que perdi algunos ciclos de

CPU). Trampas generalmente no regresan. A menudo
abortar el programa.
USO DE MACROS
Pgina 1
225
CAPTULO 9
Uso de macros
Una "macro" es un nombre simblico que le das a una serie de personajes (una macro de
texto)
oa una o ms sentencias (un procedimiento o funcin macro). Como el ensamblador
evala cada lnea de su programa, que analiza el cdigo fuente de los nombres de
previamente definido macros. Cuando encuentra uno, se sustituye el texto de la macro de
el nombre de la macro. De esta manera, se puede evitar escribir el mismo cdigo varias
lugares en su programa.
Este captulo describe los siguientes tipos de macros:

Macros de texto, que se expanden al texto de una declaracin de origen.

Procedimientos de macro, que se expanden a una o ms completos y declaraciones
opcionalmente puede tener parmetros.

Repita los bloques, los cuales generan un grupo de sentencias un nmero determinado de
veces o hasta que una condicin especificada sea verdadera.

Funciones de macro, que se parecen procedimientos macro y pueden utilizarse como texto
macros, sino que tambin devuelve un valor.

Macro funciones predefinidas y directivas de cuerda, que realizan cadena

operaciones.
En este captulo se explica cmo utilizar macros para sustituciones simples de cdigo y cmo
escribir macros sofisticadas con listas de parmetros y repetir los bucles. Tambin
describe cmo utilizar estas caractersticas en conjunto con los smbolos locales, macro
operadores y funciones de macro predefinidas.
Nombre del archivo: LMAPGC09.DOC
Pro yecto:
Plantilla: MSGRIDA1.DOT
Autor: rick Debroux
Guardado por: Ruth L Silverio
Revisin #: 86
Pgina: 225 de 1
Impreso: 10/02/00 16:22

Pgina 2
226
Gua del programador
Macros de texto
Usted puede dar a una secuencia de caracteres de un nombre simblico y luego use el nombre
en lugar del texto ms adelante en el cdigo fuente. El texto con el nombre se llama un texto
macro.
La directiva TEXTEQU define una macro de texto, como muestran estos ejemplos:
nombrar TEXTEQU <text>
nombrar TEXTEQU macroId | textmacro
nombrar TEXTEQU% constexpr
En las lneas anteriores, el texto es una secuencia de caracteres entre parntesis angulares,
macroId es una funcin de macro previamente definida, textmacro es una previamente

macro texto definido y% constexpr es una expresin que se evala como texto.
He aqu algunos ejemplos:
msg
TEXTEQU <algn <texto
; Texto asignado al smbolo
cadena
TEXTEQU msg
; Macro de texto asignado a smbolo
msg
TEXTEQU <algn otra <texto
; Nuevo texto asignado a smbolo
valor TEXTEQU% (3 + num); La representacin de texto de resolverse
; expresin asignada a smbolo
La primera lnea de texto asigna al smbolo
msg
. La segunda lnea es igual al texto de
la
msg
macro de texto con una nueva macro de texto llamado
cadena
. La tercera lnea asigna
nuevo texto
msg
. Aunque
msg
tiene un nuevo texto,
cadena

conserva su texto original
valor. La cuarta lnea asigna a 7
valor
si
num
es igual a 4. Si una macro de texto
se expande a otra macro de texto (o la funcin macro, como se comenta en la pgina 248), el
resultante macro texto se expandir de forma recursiva.
Macros de texto son tiles para nombrar las cadenas de texto que no se evalan en
nmeros enteros. Por ejemplo, puede utilizar una macro de texto para nombrar de punto
flotante
constante o una expresin entre corchetes. He aqu algunos ejemplos prcticos:
pi
TEXTEQU <3.1416>
; Flotante constante
WPT
TEXTEQU <word PTR>
; Secuencia de palabras clave
arg1
TEXTEQU <[pb 4]>
; Expresin entre corchetes
Procedimientos Macro
Si su programa tiene que realizar la misma tarea varias veces, usted puede evitar
tecleando repetidamente las mismas declaraciones cada vez escribiendo un procedimiento
macro.
Piense en los procedimientos de macro (comnmente llamados macros) como el
procesamiento de textos
mecanismos que generan de forma automtica texto repetido.

Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 226 de 2
Impreso: 10/02/00 16:22

Pgina 3
Captulo 9 Uso de macros
227
En esta seccin se utiliza el trmino "procedimiento de macro" en lugar de "macro" cuando
necesario distinguir entre un procedimiento y una funcin de macro macro.
Funciones de macro se describen en "Devolver valores con funciones de macro."
Conforme al uso comn, en este captulo de vez en cuando habla de "el que llama" una
macro, un trmino que merece un examen ms detallado. Es natural pensar en un programa
llamar a un procedimiento de macro en la misma forma en que se llama a una subrutina
normales
procedimiento, ya que parecen funcionar de forma idntica. Sin embargo, una macro es
simplemente un representante para el cdigo real. Cada vez que un nombre de macro
aparece en su
programa, por lo que en realidad hace todo el cdigo de la macro representa. Una macro no
hacer que el procesador de servir como vector fuera a una nueva ubicacin al igual que un
procedimiento normal.
Por lo tanto, la expresin "llamar a una macro" puede implicar el efecto, pero no lo hace
describir con precisin lo que realmente ocurre.
Crear procedimientos Macro

Puede definir un procedimiento macro sin parmetros colocando el deseado
declaraciones entre las directivas MACRO y ENDM:
Nombre de la macro
declaraciones
ENDM
Por ejemplo, supongamos que desea un programa para que suene cuando se encuentra con
cierta
errores. Se podra definir una
bip
macro de la siguiente manera:
MACRO pitido
mov ah, 2
;; Seleccione la funcin de impresin de Char DOS
dl mov, 7
;; Seleccione ASCII 7 (campana)
int 21h
;; Llama al DOS
ENDM
Los dobles y comas marcan el comienzo de los comentarios de macro. Macro
comentarios aparecen en un archivo de lista nica en la definicin inicial de la macro, no en el
punto donde se hace referencia a la macro y se expandi. Listados suelen ser ms fciles de
leer si los comentarios no se expanden en varias ocasiones. Sin embargo, los comentarios
regulares
(Los que tienen un solo punto y coma) se enumeran en expansiones de macros. Vase el
Apndice C
para la inclusin de archivos y ejemplos de cmo las macros se expanden en los listados.
Una vez definida una macro, puede llamar a cualquier lugar en el programa mediante el uso
de la
El nombre de la macro como una declaracin. El ejemplo siguiente se llama al

bip
macro de dos
veces si un indicador de error se ha establecido.
. SI error; Si la bandera de error es cierto
un pitido; ejecutar macro dos veces
bip
. ENDIF
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 227 de 3
Impreso: 10/02/00 16:22

Pgina 4
228
Gua del programador
Durante el montaje, las instrucciones de la macro sustituir la referencia macro. La
lista demuestra el expediente:
. SI
error
0017
80 3E 0000 R 00
*
cmp

error, 000h
001c
74 0C
*
je
@ C0001
bip
001E
B4 02
1
mov
ah, 2
0020
B2 07
1
mov
dl, 7
0022
CD 21
1
int
21h
bip
0024
B4 02
1
mov

ah, 2
0026
B2 07
1
mov
dl, 7
0028
CD 21
1
int
21h
. ENDIF
002A
* @ C0001:
Esto contrasta con los resultados de la definicin
bip
como un procedimiento mediante el PROC
Directiva y luego llamar con la instruccin CALL.
Muchas de estas tareas pueden ser manejados, ya sea como una macro o un procedimiento.
Al decidir
el mtodo a utilizar, debe elegir entre velocidad y tamao. Para repetitivo
tareas, un procedimiento produce un cdigo ms pequeo, porque las instrucciones
fsicamente
aparecer slo una vez en el programa montado. Sin embargo, cada llamada a la
procedimiento consiste en la sobrecarga adicional de una llamada y la instruccin RET.
Las macros no requieren un cambio en el flujo del programa y as se ejecutan ms
rpidamente, pero
generar el mismo cdigo varias veces en lugar de una sola vez.

Pasar argumentos a macros
Mediante la definicin de los parmetros de las macros, puede definir una tarea general y
luego
ejecutar variaciones de la misma al pasar argumentos diferentes cada vez que se llama a la
macro. La sintaxis completa de un procedimiento macro incluye una lista de parmetros:
nombrar ParameterList MACRO
declaraciones
ENDM
El ParameterList puede contener cualquier nmero de parmetros. Utilice comas para
separe cada parmetro de la lista. No puede utilizar palabras reservadas como parmetro
nombres a menos que deshabilite la palabra clave con la opcin NOKEYWORD. Usted
Tambin debe establecer el modo de compatibilidad con OPCIN M510 o el / Zm
opcin de lnea de comandos.
Para pasar argumentos a una macro, coloque los argumentos despus del nombre de la macro
cuando
se llama a la macro:
arglist macroname
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 228 de 4
Impreso: 10/02/00 16:22

Pgina 5

229
Las delicias de ensamblador como un elemento todo el texto entre comillas coincidentes en
un arglist.
La
bip
macro introducida en la seccin anterior utiliza la interrupcin de MS-DOS
a escribir slo el carcter de campana (ASCII 7). Podemos reescribir la macro con un
parmetro que acepta cualquier personaje:
WriteChar caracteres MACRO
mov ah, 2
dl mov, carbn de lea
;; Seleccione caracteres ASCII
int 21h
;; Llama al DOS
ENDM
Cada vez que se expande la macro, el ensamblador reemplaza cada instancia de
carbn de lea
con el valor del argumento dado. La macro reescrito ahora escribe cualquier personaje para
la pantalla, no slo ASCII de 7:
WriteChar 7; Causas ordenador emita un sonido
WriteChar 'A'; Escribe la A a la pantalla
Si pasa ms argumentos que los que hay parmetros, los argumentos adicionales
generar una advertencia (a menos que utilice la palabra clave vararg; consulte la pgina 242).
Si
se pasa menos argumentos que el procedimiento macro espera, el ensamblador
asigna cadenas vacas a los parmetros restantes (a menos que haya especificado

valores por defecto). Esto puede provocar errores. Por ejemplo, una referencia a la
WriteChar
macro sin resultados de argumentos en la lnea siguiente:
dl mov,
El ensamblador genera un error para la declaracin expandido pero no para la
definicin de la macro o la llamada a la macro.
Puedes hacer las macros ms flexible, dejando fuera los argumentos o agregar
argumentos adicionales. La siguiente seccin le dice algunas de las formas en que sus macros
pueden
manejar argumentos faltantes o adicionales.
Especificar los parmetros requeridos y predeterminados
Parmetros macro pueden tener atributos especiales para hacerlos ms flexibles y
mejorar la gestin de errores. Puede hacer que los parmetros necesarios, darles forma
predeterminada
valores, o varan su nmero. Los parmetros variables se utilizan casi exclusivamente
con la Directiva para, por lo que se tratan en "Bucles FOR y de longitud variable
Parmetros ", ms adelante en este captulo.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 229 de 5
Impreso: 10/02/00 16:22

Pgina 6
230

Gua del programador
La sintaxis de un parmetro requerido es:
parmetro: REQ
Por ejemplo, se puede reescribir la
WriteChar
macro para requerir la
carbn de lea
parmetro:
WriteChar caracteres MACRO: REQ
mov ah, 2
int 21h
;; Llama al DOS
ENDM
Si la llamada no incluye un argumento coincidente, el ensamblador informa del error
en la lnea que contiene la referencia macro. REQ por lo tanto puede mejorar error
la presentacin de informes.
Tambin puede adaptarse a los parmetros que faltan al especificar un valor por defecto,
de esta manera:
parmetro: = textValue
Suponga que usted utiliza a menudo
WriteChar
a pitar imprimiendo ASCII 7. El
macro siguiente definicin utiliza el signo igual para decirle al ensamblador para asumir la
parmetro

carbn de lea
es 7 menos que se especifique lo contrario:
WriteChar caracteres MACRO: = <7>
mov ah, 2
int 21h
;; Llama al DOS
ENDM
Si una referencia a esta macro no incluye el argumento
carbn de lea
, El ensamblador
llena el espacio en blanco con el valor por defecto de 7 y los macro pitidos cuando se le llama.
Encierre el valor predeterminado del parmetro entre corchetes angulares por lo que el
ensamblador
reconoce el valor proporcionado como un valor de texto. Esto se explica en detalle en "Texto
Los delimitadores y el Operador Literal-Character ", ms adelante en este captulo.
Argumentos que faltan tambin se pueden manejar con la IFB, IFNB,. ERRB y
directivas. ERRNB. Se describen en la seccin "Directivas condicionales"
en el captulo 1 y en la Ayuda. Aqu es un poco ms compleja macro que utiliza algunos
de estas tcnicas:
Pro yecto:
Autor: rick Debroux

Revisin #: 86
Pgina: 230 de 6
Impreso: 10/02/00 16:22

Pgina 7
231
MACRO distancia de desplazamiento: REQ, attrib: = <7>, Tcol, Trow, bcol, frente
IFNB <tcol>;; No haga caso de los argumentos si est en blanco
mov
cl, Tcol
ENDIF
<TRow> IFNB
ch mov, trow
ENDIF
<bcol> IFNB
dl mov, bcol
ENDIF
<brow> IFNB
dh mov, frente
ENDIF
IFDIFI <ATTRIB>, <bh>;; No mueva BH sobre s mismo
mov
bh, attrib
ENDIF
SI LE distancia 0;; Rollos negativos para arriba, positiva hacia abajo
mov

hacha, 0600H + (- (distancia) Y 0FFh)
ELSE
mov ax, 0700h + (distancia Y 0FFh)
ENDM
ENDIF
int 10h
En esta macro, la
distancia
parmetro es necesario. La
attrib
parmetro tiene
un valor por defecto de 7 (blanco sobre negro), pero la macro tambin pone a prueba para
asegurarse de que la
argumento correspondiente no est BH, ya que sera ineficiente (aunque legal)
cargar un registro en s mismo. La directiva IFNB se utiliza para probar para el blanco
argumentos. Estos son ignorados para permitir al usuario manipular filas y columnas
directamente en los registros CX y DX en tiempo de ejecucin.
A continuacin se muestran dos formas vlidas para llamar a la macro:
; Supongamos DL y CL ya cargado
diciembre dh
; Decrementamos fila superior
inc ch
; Fila inferior Incremento
Desplcese -3
; Blanco Desplcese en dinmica negro
; ventana de tres lneas
De desplazamiento 5, 17h, 2, 2, 14, 12; Blanco Desplcese en azul constante

; ventanilla cinco lneas
Esta macro puede generar cdigo completamente diferente, en funcin de sus argumentos.
En este sentido, no es comparable a un procedimiento, que siempre tiene el mismo
cdigo, independientemente de los argumentos.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 231 de 7
Impreso: 10/02/00 16:22

Pgina 8
232
Gua del programador
Definir smbolos locales en Macros
Usted puede hacer un smbolo local a una macro al identificarlo en el inicio de la
macro con la directiva LOCAL. Cualquier identificador puede ser declarada local.
Usted puede elegir si desea que equipara numricos y macros de texto a ser locales
o global. Si un smbolo se usar slo dentro de una macro determinada, puede
declararlo local para que el nombre estar disponible para otras declaraciones fuera
la macro.
Debe declarar como locales las etiquetas dentro de una macro, ya que puede ocurrir una
etiqueta
slo una vez en la fuente. La directiva local hace un caso especial de la
etiquetar cada vez que aparezca macro. Esto evita que la redefinicin de la etiqueta cuando

la expansin de la macro. Tambin le permite reutilizar la etiqueta en otro lugar de su
cdigo.
Debe declarar todos los smbolos locales inmediatamente despus de la MACRO
declaracin (aunque las lneas en blanco y los comentarios pueden preceder el smbolo local).
Separe cada smbolo con una coma. Puede adjuntar comentarios a la LOCAL
declaracin y la lista de mltiples declaraciones local en la macro. He aqu un ejemplo
macro que declara etiquetas locales:
factor de potencia MACRO: REQ, exponente: REQ
LOCAL
de nuevo, gotzero;; Smbolos locales
sub
dx, dx
;; Claro superior
mov ax, 1
;; Multiplique por uno en primer bucle
mov cx, exponente;; Conteo de carga
jcxz gotzero;; Hecho si es cero exponente
bx mov, el factor;; El factor de carga
nuevo:
mul bx
;; Multiplicar factor por exponente
bucle de nuevo
;; Resultado en AX
gotzero:
ENDM
Si las etiquetas
de nuevo

y
gotzero
no fueron declaradas local, el macro hara
trabajar la primera vez que se llama, pero sera generar errores de redefinicin en
las llamadas posteriores. MASM implementa etiquetas locales mediante la generacin de
distintos nombres
para ellos cada vez que la macro se llama. Esto se puede ver en el listado de archivos. La
etiquetas en el
potencia
macro podra ser ampliado para
?? 0000
y
?? 0001
en la
primera convocatoria y para
?? 0002
y
?? 0003
en el segundo.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 232 de 8
Impreso: 10/02/00 16:22

Pgina 9
233
Usted debe evitar el uso de etiquetas annimas en las macros (ver "Las etiquetas annimos"
en el Captulo 7). Aunque legal, pueden producir resultados no deseados si expande un
macro cerca de otro sello en el anonimato. Por ejemplo, considere lo que sucede en el
siguiente:
Actualizar arg1 MACRO
@ @ :.
.
.
loop @ B
ENDM
@ @:
.
.
.
jcxz
@ F
Update hacha
En expansin
Actualizacin
pone otra etiqueta annima entre el salto y su
objetivo. La lnea
jcxz @ F
en consecuencia, salta al principio del bucle en lugar de a travs del bucle-exactamente

lo contrario de lo que pretende el programador.
Variables Asamblea en tiempo y Operadores Macro
En la creacin de macros, se le suele asignar y modificar los valores asignados a los smbolos.
Piense en estos smbolos como variables en tiempo de montaje. Al igual que las variables de
memoria,
son smbolos que representan valores. Pero ya que las macros se procesan en
tiempo de montaje, cualquier smbolo modificado de una macro debe resolverse como una
constante
por el extremo del conjunto.
Los tres tipos de variables en tiempo de la asamblea son:

Parmetros de macro

Macros de texto

Las funciones macro
Cuando el ensamblador se expande una macro, que procesa los smbolos en el orden
se muestra aqu. MASM primero reemplaza parmetros de macro con el texto de su actual
argumentos, luego se expande macros de texto.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 233 de 9
Impreso: 10/02/00 16:22

Pgina 10
234
Gua del programador
Parmetros de macro son similares a los parmetros del procedimiento en algunos aspectos,
pero que
tambin tienen diferencias importantes. En un procedimiento, un parmetro tiene un tipo y
un
ubicacin de memoria. Su valor puede ser modificada dentro del procedimiento. En una
macro, un
parmetro es un marcador de posicin para el texto argumento. El valor slo se puede
asignar
a otra seal o utilizado directamente; no se puede modificar. El mayo macro
interpretar el texto argumento que recibe ya sea como un valor numrico o como un texto
valor.
Es importante entender la diferencia entre los valores de texto y numrica
valores. Los valores numricos se pueden procesar con operadores aritmticos y asignados
que equipara numricos. Los valores de texto se pueden procesar con funciones de macro y
asignado a las macros de texto.
Operadores de macro suelen ser tiles en el tratamiento de variables en tiempo de montaje.
Tabla 9.1 muestra los operadores de macro que MASM proporciona.
Tabla 9.1 MASM Operadores Macro
Smbolo
Nombre
Descripcin
<>
Los delimitadores de texto
Abre y cierra una cadena literal.
!

Operador Literal-Character
Se usa para tratar el siguiente carcter como un carcter literal,
incluso si normalmente tendra otro significado.
%
Operador de Expansin
Hace que el ensamblador para expandir una constante
expresin o texto macro.
Y
Operador Sustitucin
Le dice al ensamblador para reemplazar una macro
parmetro o de texto Nombre de macro, con su
valor real.
Las siguientes secciones explican estos operadores en detalle.
Los delimitadores de texto y el Operador Literal-Character
Los corchetes angulares (<>) son delimitadores de texto. Un valor de texto es por lo general
delimitada
al asignar una macro de texto. Usted puede hacer esto con TEXTEQU, como antes
muestran, o con las directivas SUBSTR y CATSTR discuten en "String
Directivas y funciones predefinidas, "ms adelante en este captulo.
Por delimitar el texto de argumentos de la macro, se puede pasar de texto que incluye
espacios, comas, puntos y comas y otros caracteres especiales. La siguiente
ejemplo expande una macro llamada
trabajo
de dos maneras diferentes:
trabajar <1, 2, 3, 4, 5>; Pasa una discusin con 13 caracteres,
; incluyendo comas y espacios
trabajar 1, 2, 3, 4, 5; Pasa cinco argumentos, cada uno

; 1 con carcter
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 234 de 10
Impreso: 10/02/00 16:22

Pgina 11
235
El operador literal-character (!) Le permite incluir corchetes angulares como parte de un
delimitado por valor de texto, as que el compilador no los interpreta como delimitadores. La
ensamblador trata el carcter que sigue! literalmente y no como un especial
carcter, as:
errstr TEXTEQU <expresin !> 255>; errstr = "Expression> 255"
Delimitadores de texto tambin tienen un uso especial con el PARA Directiva, como se explica
en
"PARA Loops y parmetros de longitud variable," ms adelante en este captulo.
Operador de Expansin
El operador de expansin (%) expande macros de texto o convierte constante
expresiones en sus representaciones de texto. Se lleva a cabo estas tareas de manera
diferente en
diferentes contextos, como se discute en la siguiente.
La conversin de las expresiones numricas en texto
El operador de expansin puede convertir nmeros a texto. Las fuerzas de operador

evaluacin inmediata de una expresin constante y lo reemplaza con un valor de texto
que consta de los dgitos del resultado. Los dgitos se generan en el radix actual
(Decimal por omisin).
Esta aplicacin del operador de expansin es til al definir una macro de texto,
como las siguientes lneas muestran. Observe cmo se puede incluir expresiones con
parntesis para que sean ms legibles:
un
TEXTEQU <3 + 4>
; a = "3 + 4"
b
TEXTEQU% 3 + 4
; b = "7"
c
TEXTEQU% (3 + 4)
; c = "7"
Al asignar macros de texto, puede utilizar equipara numricos en la constante
expresiones, pero no las macros de texto:
num
EQU 4
; num = 4
numstr
TEXTEQU <4>
; numstr = <4>
un
TEXTEQU% 3 + num
; A = <7>
b

TEXTEQU% 3 + numstr
; b = <7>
El operador de expansin le da flexibilidad a la hora de pasar argumentos a macros.
Te permite pasar un valor calculado en lugar del texto literal de una expresin.
El siguiente ejemplo ilustra mediante la definicin de una macro
trabajo
Arg MACRO
mov ax, arg * 4
ENDM
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 235 de 11
Impreso: 10/02/00 16:22

Pgina 12
236
Gua del programador
que acepta diferentes argumentos:
trabajo
2 + 3
; Pasa "2 + 3"
; Cdigo: mov ax, 2 + (3 * 4)
trabajo

2% + 3
; Pasa 5
; Cdigo: mov ax, 5 * 4
trabajo
2 + num
; Pasa "2 + num"
trabajo
% 2 + num
; Pasa "6"
trabajo
2 + numstr
; Pasa "2 + numstr"
trabajo
% 2 + numstr
; Pasa "6"
Debe tener en cuenta la precedencia de operadores cuando se utiliza el operador de
expansin.
Los parntesis dentro de la macro puede forzar la evaluacin en un orden deseado:
trabajo
Arg MACRO
mov ax, (arg) * 4
ENDM
trabajar 2 + 3
; Cdigo: mov ax, (2 + 3) * 4
trabajo% 2 + 3
; Cdigo: mov ax, (5) * 4
Varios otros usos para el operador de la expansin se revisan en "Valores que regresan

con funciones de macro ", ms adelante en este captulo.
Operador de expansin como primer carcter de una lnea
El operador de expansin tiene un significado diferente cuando se utiliza como el primer
carcter
en una lnea. En este caso, se indica al ensamblador para expandir las macros de texto y
funciones de macro que encuentre en el resto de la lnea.
Esta caracterstica hace posible el uso de macros de texto con directivas como ECHO,
TTULO, y el subttulo, que toman un argumento que consiste en un texto nico
valor. Por ejemplo, ECHO despliega su argumento en el dispositivo de salida estndar
durante el montaje. Tal expansin puede ser til para las macros de depuracin y
expresiones, pero el requisito de que su argumento sea un nico valor de texto puede
tener resultados inesperados. Considere este ejemplo:
ECHO Bytes por cada elemento:% (array SIZEOF / array LENGTHOF)
En lugar de evaluar la expresin, esta lnea se hace eco de ello:
Bytes por cada elemento:% (array SIZEOF / array LENGTHOF)
Sin embargo, se puede lograr el resultado deseado mediante la asignacin del texto de la
expresin a una macro de texto y utilizando el operador de expansin en el
principio de la lnea de fuerza de expansin de la macro de texto.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 236 de 12
Impreso: 10/02/00 16:22

Pgina 13
237
TEXTEQU temp% (array SIZEOF / array LENGTHOF)
% ECHO Bytes por cada elemento: temp
Tenga en cuenta que usted no puede conseguir los mismos resultados con slo poner el% en
la
a partir de la primera lnea de eco, porque% se expande slo las macros de texto, no
equipara numricos o expresiones constantes.
Aqu hay ms ejemplos de que el operador de expansin en el inicio de una lnea:
; Asumir memmod, lang, y os especificados con la opcin / D
% SUBTTULO Modelo: memmod Idioma: lang Sistema operativo: OS
; Supongamos num definido anteriormente
tnum TEXTEQU% num
%. ERRE num LE 255, <Failed porque tnum !> 255>
Operador Sustitucin
Las referencias a un parmetro dentro de una macro a veces puede ser ambigua. En tales
casos, el ensamblador no pueden ampliar el argumento de los que haba previsto. La
operador de sustitucin (&) le permite identificar de forma inequvoca cualquier parmetro
dentro de un
macro.
Como ejemplo, considere la siguiente macro:
num MACRO errgen, msg
Errnum PBLICA
BYTE errnum "num Error: msg"
ENDM
Esta macro est abierto a varias interpretaciones:

Es
errnum
una palabra distinta o la palabra
errar
junto al parmetro
num
?

Debera
num
y
msg
dentro de la cadena de ser tratado, literalmente, como parte de la cadena
o como argumentos?
En cada caso, el ensamblador elige la interpretacin ms literal. Es decir, se
golosinas
errnum
como una palabra distinta, y
num
y
msg
partes literales de la cadena.
El operador de sustitucin puede obligar a diferentes interpretaciones. Si volvemos a escribir
la
macro con el operador &, que se ve as:
num MACRO errgen, msg
Err PBLICO & num

errar & num BYTE "Error & num: & msg"
ENDM
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 237 de 13 de
Impreso: 10/02/00 16:22

Pgina 14
238
Gua del programador
Cuando se llama con los siguientes argumentos,
errgen 5, duro> <Unreadable
la macro ahora genera este cdigo:
Err5 PBLICA
BYTE Err5 "Error 5: disco ilegible"
Cuando encuentra el operador y, el ensamblador interpreta texto subsiguiente como una
nombre del parmetro hasta la siguiente y o hasta que el siguiente carcter separador (tal
como un
espacio, tabulador o coma). Por lo tanto, el ensamblador analiza correctamente la expresin
err & num
porque
num
est delimitada por & y un espacio. La expresin tambin podra

ser escrito como
err & num y
, Que a su vez identifica de forma inequvoca
num
como un
parmetro.
La norma tambin funciona a la inversa. Puede delimitar un parmetro de referencia con y en
al final en lugar de al principio. Por ejemplo, si
num
es 5, la expresin
num y 12
se resuelve como "512".
El ensamblador procesa los operadores de sustitucin de izquierda a derecha. Esto puede
tener
resultados inesperados cuando se est pegando a dos parmetros de la macro. Para
ejemplo, si
arg1
tiene el valor
var
y
arg2
tiene el valor
3
, Usted podra pegar
juntos con esta declaracin:
Y arg1 arg2 && y BYTE "Texto"
La eliminacin de los operadores de sustitucin de ms, se podra esperar que los siguientes
son

equivalentes:
Y arg1 y arg2 BYTE "Texto"
Sin embargo, esta realidad produce el smbolo
vararg2,
porque en el procesamiento
de izquierda a derecha, los socios de ensamblador tanto la primera como la segunda y
smbolos con el primer parmetro. El ensamblador sustituye
Y arg1 y
por
var
,
productor
vararg2
. La
arg2
Nunca se evala. La abreviatura correcta es:
arg1 arg2 && BYTE "Texto"
que produce el smbolo deseado
var3
. El smbolo
arg1 arg2 &&
se sustituye
por
var y arg2
, Que se sustituye por
var3
.

El operador de sustitucin tambin es necesario si desea sustituir una macro de texto
entre comillas. Por ejemplo,
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 238 de 14
Impreso: 10/02/00 16:22

Pgina 15
239
arg TEXTEQU <hello>
% Echo Esto es una cadena "& arg"; Produce: Esto es una cadena "hola"
% Echo Esta es una "arg" string; Produce: Se trata de un "arg" string
Tambin puede utilizar el operador de sustitucin en las lneas que empiezan con la expansin
smbolo de operador (%), incluso fuera de macros (ver pgina 236). Puede ser necesario
utilizar el operador de sustitucin para pegar los nombres de texto de macro a personajes
adyacentes
o nombres de smbolos, como se muestra aqu:
<var> TEXTEQU texto
valor TEXTEQU% 5
% ECHO textValue es texto && valor
Esto se hace eco del mensaje
textValue es var5

Sustitucin de macros siempre se produce antes de la evaluacin del control de alto nivel
estructuras. Por tanto, el ensamblador puede confundir un operador bit a prueba (&) en su
macro para un operador de sustitucin. Usted puede garantizar que el ensamblador
correctamente
reconoce un operador bit a prueba encerrando sus operandos entre parntesis, como se
muestra
aqu:
MACRO prueba de x
. SI ax == y X; Y x sustituido con valor de parmetro
mov ax, 10
. ELSEIF hacha y (x); Y es AND bit a bit
mov ax, 20
. ENDIF
ENDM
Las reglas para el uso del operador de sustitucin han cambiado significativamente desde
MASM 5.1, por lo que el comportamiento macro ms consistente y flexible. Si usted tiene
macros escritas para MASM 5.1 o una versin anterior, puede especificar el antiguo
comportamiento
utilizando OLDMACROS o M510 con la directiva OPCIN (ver pgina 24).
Definicin de Bloques Repita con las Directivas de bucle
Un "bloque de repeticin" es una macro sin nombre definido con una directiva de bucle. El
bucle
Directiva genera las instrucciones dentro del bloque de la repeticin de un nmero
determinado de
veces o hasta una determinada condicin sea verdadera.
MASM proporciona varias directivas de asa, que permiten especificar el nmero de
iteraciones del bucle de diferentes maneras. Algunas directivas de asa tambin pueden
aceptar los argumentos
para cada iteracin. Aunque por lo general se especifica el nmero de iteraciones en el

directiva, puede utilizar la directiva EXITM para salir del lazo anticipadamente.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 239 de 15
Impreso: 10/02/00 16:22

Pgina 16
240
Gua del programador
Repita los bloques se pueden usar macros fuera, pero con frecuencia aparecen en el interior
definiciones de macros para realizar alguna operacin repetida en la macro. Desde repeticin
bloques son propios macros, terminan con la directiva ENDM.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 240 de 16
Impreso: 10/02/00 16:22

Pgina 17

241
En esta seccin se explican los siguientes cuatro directivas loop: REPEAT, WHILE,
FOR, y FORC. En las versiones de MASM anteriores a 6.0, REPEAT fue llamado
REPETIR PARA fue llamado PIR, y FORC fue llamado IRPC. MASM 6.1
reconoce los nombres antiguos.
El ensamblador evala bloques de repeticin en slo el primer pase. Usted debe
por lo tanto, evitar el uso de luces de direcciones como contadores de bucles, como en este
ejemplo:
REPEAT (OFFSET label1 - label2 OFFSET); No hagas esto!
Dado que la distancia entre dos etiquetas puede cambiar en el montaje subsiguiente
que pasa como el ensamblador optimiza el cdigo, usted no debe suponer que la direccin
luces permanecen constantes entre las pasadas.
Nota REPEAT y directivas Aunque no se deben confundir con el
REPEAT y directivas while (vase "directivas Loop-Generacin" en el Captulo
7), lo que generar instrucciones del bucle y salte para el control del programa en tiempo de
ejecucin.
Loops REPEAT
REPEAT es la directiva de bucle simple. En l se especifica el nmero de veces que
generar las sentencias dentro de la macro. La sintaxis es:
Constexpr REPEAT
declaraciones
ENDM
El constexpr puede ser una constante o una expresin constante, y no debe contener
reenviar referencias. Desde el bloque de repeticin se expande en el tiempo de montaje, el
nmero de iteraciones debe ser conocida a continuacin.
He aqu un ejemplo de un bloque de repeticin utilizada para generar datos. Se inicializa una
matriz
contiene valores ASCII secuenciales para todas las letras maysculas.

alfa ETIQUETA BYTE
; Nombra los datos generados
letter =
'A'
; Inicializar contador
REPEAT 26
;; Repita el procedimiento para cada letra
BYTE
carta
;; Asignar cdigo ASCII para la letra
carta
= Carta + 1
;; Incrementar contador
ENDM
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 241 de 17 de
Impreso: 10/02/00 16:22

Pgina 18
242
Gua del programador
Aqu hay otro uso de REPEAT, esta vez dentro de una macro:

pitido iter MACRO: = <3>
mov ah, 2
;; Funcin de salida de caracteres
dl mov, 7
;; Personaje de Bell
Iter REPEAT
;; Repetir el numero especificado por macro
int 21h
;; Llama al DOS
ENDM
ENDM
MIENTRAS Loops
La directiva MIENTRAS es similar a la repeticin, pero el bucle contina mientras un
condicin dada es cierta. La sintaxis es:
Mientras que la expresin
declaraciones
ENDM
La expresin debe ser un valor que se puede calcular en tiempo de montaje.
Normalmente, la expresin utiliza operadores relacionales, pero puede ser cualquier
expresin
que evala a cero (false) o distinto de cero (verdadero). Por lo general, la condicin cambia
durante la evaluacin de la macro para que el bucle no intentar generar una
infinita cantidad de cdigo. Sin embargo, usted puede utilizar la directiva EXITM romper
fuera del bucle.
El siguiente bloque de repeticin se utiliza la directiva MIENTRAS asignar las variables
inicializado a valores calculados. Esta es una tcnica comn para generar
las operaciones de bsqueda mesas. (Una tabla de consulta es cualquier lista de resultados
precalculados, como una tabla

de pago de intereses o valores trigonomtricos o logaritmos. Programas optimizados
para la velocidad a menudo utilizan las tablas de bsqueda, ya que el clculo de un valor a
menudo toma ms
tiempo de mirar hacia arriba en una tabla.)
BYTE cubos ETIQUETA;; Nombra los datos generados
root = 1
;; Inicialice raz
cube = root * root * raz;; Calcular primer cubo
MIENTRAS cubo LE 32767;; Repita hasta que el resultado es demasiado grande
Cubo PALABRA
;; Asignar cubo
raz
= Root + 1
;; Calcular el prximo raz y el cubo
cubo
= Root * root * root
ENDM
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 242 de 18
Impreso: 10/02/00 16:22

Pgina 19

243
PARA Loops y parmetros de longitud variable
Con la directiva para que pueda recorrer una lista de argumentos, trabajando en
cada uno de ellos a su vez. Tiene la siguiente sintaxis:
PARA parmetro, <argumentlist>
declaraciones
ENDM
El parmetro es un marcador de posicin que representa el nombre de cada argumento en el
interior
el bloque FOR. La lista de argumentos debe contener argumentos separados por comas y
siempre deben ir entre parntesis angulares. He aqu un ejemplo de un bloque PARA:
serie ETIQUETA BYTE
PARA
Arg, <1,2,3,4,5,6,7,8,9,10>
DUP arg BYTE (arg)
ENDM
En la primera iteracin, la
arg
parmetro se reemplaza con el primer argumento, la
valor 1. En la segunda iteracin,
arg
se sustituye con 2. El resultado es una matriz
con el primer byte inicializado a 1, los prximos 2 bytes inicializados a 2, el prximo 3
bytes inicializa a 3, y as sucesivamente.
La lista de argumentos se da especficamente en este ejemplo, pero en algunos casos la lista
debe ser generada como una macro de texto. El valor de la macro de texto debe incluir el

corchetes angulares.
arglist TEXTEQU <<3,6,9 >> ; Generar lista como texto macro
% PARA arg, arglist
.
; Haga algo para arg
.
.
ENDM
Observe el uso del operador de carcter literal ( ! ) para identificar corchetes angulares como
caracteres, no delimitadores. Consulte "delimitadores de texto (<>) y el Literal-Character
Operador ", anteriormente en este captulo.
El POR directiva tambin proporciona una manera conveniente para procesar macros con una
nmero variable de argumentos. Para ello, agregue vararg para el ltimo parmetro
para indicar que un parmetro denominado nica tendr el valor real de todos
argumentos adicionales. Por ejemplo, la siguiente definicin de la macro incluye la
los atributos requeridos por tres parmetros es posible, por defecto y variable.
Rarg MACRO trabajo: REQ, darg: = <5>, Varg: vararg
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 243 de 19 de
Impreso: 10/02/00 16:22

Pgina 20
244
Gua del programador
El argumento de la variable siempre debe ser el ltimo. Si esta macro se llama con el
declaracin
trabajar 4, 6, 7, a, b
el primer argumento es recibido como el valor 4, el segundo se sustituye por el
valor predeterminado 5, y los cuatro ltimos se reciben como argumento nico
<6, 7,
a, b>
. Este es el mismo formato esperado por el PARA Directiva. El POR
directiva descartes espacios iniciales pero reconoce los espacios finales.
La macro siguiente ilustra argumentos variables:
mostrar chr MACRO: vararg
mov ah, 02h
PARA arg, <chr>
mov
dl, arg
int
21h
ENDM
ENDM
Cuando se llama con
mostrar 'O', 'K', 13, 10
la macro muestra cada uno de los caracteres especificados de una en una.
El parmetro de una PARA bucle puede tener el atributo requerido o por defecto. Usted
puede modificar el

show
macro para argumentar en blanco generan errores:
mov ah, 02h
PARA arg: REQ, <chr>
mov
dl, arg
int
21h
ENDM
ENDM
La macro ahora genera un error si se llama con
mostrar 'O', 'K', 13, 10
Pro yecto:
Autor: rick Debroux

Pgina 21
Revisin #: 86
Pgina: 244 de 20
Impreso: 10/02/00 16:22

Pgina 22
245

Otro enfoque sera utilizar un argumento por defecto:
mov ah, 02h
PARA arg: = <''>, <chr>
mov
dl, arg
int
21h
ENDM
ENDM
Ahora llamar a la macro con
mostrar 'O', 'K', 13, 10
inserta el carcter predeterminado, un espacio, para el argumento en blanco.
FORC Loops
El FORC directiva es similar a PARA, pero toma una cadena de texto en lugar de un
lista de argumentos. Las declaraciones se montan una vez para cada carcter
(Incluyendo espacios) en la cadena, la sustitucin de un carcter diferente para el
parmetro cada vez a travs.
La sintaxis es la siguiente:
FORC parmetro , < texto >
declaraciones
ENDM
El texto debe ir entre parntesis angulares. El siguiente ejemplo ilustra
FORC :
FORC arg, <ABCDEFGHIJKLMNOPQRSTUVWXYZ>
BYTE '& arg';; Asignar letra mayscula
BYTE '& arg' + 20h;; Asignar letra minscula

BYTE '& arg' - 40h;; Asignar ordinal de la carta
ENDM
Observe que el operador de sustitucin debe ser utilizado dentro de las comillas para
asegurar que
arg
se expande a un personaje en lugar de tratarse como un literal
cadena.
Con versiones de MASM anteriores a la 6.0, FORC se utiliza a menudo para complejo
anlisis de tareas. Una frase larga puede ser examinado carcter por carcter. Cada
carcter es entonces o bien desecha o pega en un token de cadena, dependiendo de
si se trata de un carcter separador. Las nuevas funciones de macro predefinidas y
directivas de procesamiento de series que se tratan en la siguiente seccin son generalmente
ms
eficiente para estas tareas.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 245 de 21 de
Impreso: 10/02/00 16:22

Pgina 23
246
Gua del programador
Directivas de Cuerda y funciones predefinidas

El ensamblador proporciona cuatro directivas para la manipulacin de texto:
Directiva
Descripcin
SUBSTR
Asigna parte de cadena en un nuevo smbolo.
INSTR
Las bsquedas de una cadena dentro de otra.
SIZESTR
Determina el tamao de una cadena.
CATSTR
Concatena una o ms cadenas de una sola cadena.
Estas directivas asignan un valor a un tratamiento que una macro de texto o equate numrico.
Para
ejemplo, las siguientes lneas
num =
7
newstr CATSTR <3 +>,% num, <=>,% 3 + num; "3 + 7 = 10"
asignar la cadena
"3 + 7 = 10"
a
newstr
. CATSTR y SUBSTR asignacin
texto de la misma forma que el TEXTEQU Directiva. SIZESTR y INSTR asignacin
un nmero en la misma forma que el = operador. Las cuatro directivas de cuerda toman slo
texto valora como argumentos. Utilice el operador de expansin ( % ) cuando se necesita
asegurarse de que las constantes y equipara numricos se expanden para texto, como se
muestra en la
precedente lneas.

Cada una de las directivas de cuerda tiene una funcin macro predefinida correspondiente
Versin: @ substr , InStr @ , @ SizeSt r Y @ CatSt r . funciones de macro son
similar a las directivas de la secuencia, pero usted debe escribir sus argumentos en
parntesis. Funciones de macro devuelven valores de texto y pueden aparecer en cualquier
contexto
donde se espera que el texto. En la siguiente seccin, "Devolver valores con Macro
Funciones ", dice cmo escribir sus propias funciones de macro. La siguiente
ejemplo es equivalente a la anterior CATSTR ejemplo:
num =
7
newstr TEXTEQU @ CatStr (<3 +>,% num, <=>,% 3 + num)
Funciones de macro son a menudo ms conveniente que sus contrapartes directiva
porque se puede utilizar una funcin de macro como argumento para una directiva de cadena
o de
otra funcin macro. Directivas de cuerda A diferencia, la funcin macro predefinida
nombres distinguen entre maysculas y minsculas cuando se utiliza la opcin de lnea de
comandos / Cp.
Cada directiva de cadena y funcin predefinida acta sobre una cadena, que puede ser
cualquier
elemento_texto . El elemento_texto puede ser texto entre corchetes angulares (<>), el nombre
de
una macro de texto o una expresin constante precedida por % (como en % constexpr ).
Consulte el Apndice B, "gramtica de BNF," para obtener una lista de tipos que
elemento_texto pueden
representar.
Pro yecto:
Autor: rick Debroux

Revisin #: 86
Pgina: 246 de 22 de
Impreso: 10/02/00 16:22

Pgina 24
247
Las siguientes secciones resumen la sintaxis para cada una de las directivas de cuerda
y funciones. Las explicaciones se centran en las directivas, pero las funciones de trabajo
el mismo, excepto donde se indique.
SUBSTR
nombrar SUBSTR cadena , iniciar [[, longitud]]
@ Substr ( cadena , iniciar [[, longitud ]])
El SUBSTR Directiva asigna una subcadena de una determinada cadena en el smbolo
nombrar . El inicio parmetro especifica la posicin en la cadena , empezando por 1, para
comenzar la subcadena. La longitud proporciona la longitud de la subcadena. Si no lo hace
especificar la longitud , SUBSTR devuelve el resto de la cadena, incluyendo el inicio
carcter.
INSTR
nombrar INSTR [[ inicio ,]] string , substring
@ InStr ( [[ empezar ]], cadena , subcadena )
El INSTR directiva busca un determinado cadena para una aparicin de subcadena
y le asigna su nmero de posicin para el nombre . La bsqueda distingue entre maysculas y
minsculas. El comienzo
parmetro es la posicin en la cadena para iniciar la bsqueda de subcadena . Si no lo hace
especificar inicio , que se supone que es la posicin 1, el principio de la cadena. Si INSTR

no encuentra subcadena , asigna la posicin 0 a nombre .
El INSTR Directiva asigna el valor de posicin de nombre como si fuera un valor numrico
equiparar. En contraste, el @ InStr devuelve el valor como una cadena de dgitos en el
radix actual.
El @ InStr funcin tiene una sintaxis ligeramente diferente que el INSTR Directiva.
Se puede omitir el primer argumento y su coma asociado de la Directiva.
Puede dejar el primer argumento en blanco con la funcin, sino una funcin en blanco
argumento todava debe tener una coma. Por ejemplo,
pos INSTR <person>, <son>
es el mismo que
pos = @ InStr (, <person>, <son>)
Tambin puede asignar el valor de retorno de una macro de texto, as:
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 247 de 23 de
Impreso: 10/02/00 16:22

Pgina 25
248
Gua del programador
strpos TEXTEQU @ InStr (, <person>, <son>)
SIZESTR
nombrar SIZESTR cadena

@ SizeSt r ( cadena )
El SIZESTR Directiva asigna el nmero de caracteres en la cadena de nombre . Un
cadena vaca devuelve una longitud de cero. El SIZESTR Directiva asigna el tamao
valor a un nombre como si se tratara de un EQUATE numrico. Los @ SizeStr funcin devuelve
el valor como una cadena de dgitos de la raz actual.
CATSTR
nombrar CATSTR string [, string ] ...
@ CatStr ( string [, string ] ... )
El CATSTR Directiva concatena una lista de valores de texto en un solo valor de texto
y lo asigna al nombre . TEXTEQU es tcnicamente un sinnimo de CATSTR .
TEXTEQU se utiliza normalmente para las tareas de una sola cuerda, mientras CATSTR es
utilizado para multistring concatenaciones.
El siguiente ejemplo se empuja y aparece un conjunto de registros, que ilustran varios
usos de las directivas y funciones de cadena:
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 248 de 24
Impreso: 10/02/00 16:22

Pgina 26
249
; SaveRegs - Macro para generar una instruccin de insercin para cada

; inscribirse en la lista de argumentos. Guarda cada nombre de registro en el
; macro texto regpushed.
regpushed TEXTEQU <>
;; Inicializar cadena vaca
SaveRegs regs MACRO: vararg
Reg LOCAL
PARA reg, <regs>
;; Empuje cada registro
empuje reg
;; y aadirlo a la lista
regpushed CATSTR <reg>, <,>, regpushed
ENDM
;; Pele ltima coma
CATSTR regpushed <<>, regpushed!;; Marcar comienzo de la lista con <
regpushed SUBSTR regpushed, 1, @ SizeStr (regpushed)
CATSTR regpushed regpushed, <! >>;; Marque el extremo con>
ENDM
; RestoreRegs - Macro para generar una instruccin pop para los registros
; salvado por la macro SaveRegs. Restaura un grupo de registros.
RestoreRegs MACRO
Reg LOCAL
% PARA reg, regpushed
;; Pop cada registro
pop reg
ENDM
ENDM
Observe cmo la

SaveRegs
macro guarda su resultado en la
regpushed
texto macro
para su uso posterior por el
RestoreRegs
macro. En este caso, una macro de texto se utiliza como un
variable global. Por el contrario, la
reg
texto de la macro se utiliza slo en
RestoreRegs
.
Se declara LOCAL por lo que no tendr el nombre
reg
Del nombre global
espacio. El archivo MACROS.INC proporcionado con MASM 6.1 incluye la ampliacin
versiones de estos mismos dos macros.
Devolver valores con funciones de macro
Una funcin macro es un grupo con nombre de declaraciones que devuelve un valor. Cundo
llamar a una funcin macro, debe incluir la lista de parmetros entre parntesis, incluso
si la lista est vaca. La funcin siempre devuelve el texto.
MASM 6.1 ofrece varias funciones de macro predefinidos para las tareas comunes. La
macros predefinidas incluyen @ Environ (ver pgina 10) y las funciones de cadena
@ SizeStr , @ CatSt r , @ substr , y @ InStr (discutido en el prrafo anterior
seccin).
Se definen las funciones de macro exactamente de la misma manera que los procedimientos
de macro,

excepto que una funcin de macro siempre devuelve un valor a travs de la EXITM
Directiva. He aqu un ejemplo:
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 249 de 25
Impreso: 10/02/00 16:22

Pgina 27
250
Gua del programador
Smbolo macro definida: REQ
Smbolo IFDEF
EXITM <-1>
;; Verdadero
ELSE
ENDM
EXITM <0>
;; Falso
ENDIF
Esta macro funciona como el definido operador en el lenguaje C. Usted puede utilizarlo para
probar el estado definido de varios smbolos diferentes con una sola instruccin, como
se muestra aqu:
SI SE DEFINE (DOS) y no se definen (XENIX)

;; Haga algo
ENDIF
Observe que la macro devuelve valores enteros como cadenas de dgitos, pero el SI
declaracin evala valores o expresiones numricas. No hay conflicto, porque
el ensamblador ve el valor devuelto por la funcin macro exactamente como si el
usuario haba introducido los valores directamente en el programa:
SI Y NO -1 0
Devolver valores con EXITM
El valor de retorno tiene que ser un texto, un texto equivale nombre, o el resultado de otra
funcin macro. Una funcin macro debe convertir primero un valor numrico como tales
una constante, un valor numrico equivale, o el resultado de una expresin-antes numrico
devolverlo. La funcin macro puede utilizar las escuadras o la expansin
operador ( % ) para convertir los nmeros a texto. La
DEFINIDO
macro, por ejemplo,
podra haber regresado de su valor como
EXITM% -1
He aqu otro ejemplo de una funcin de macro que utiliza el MIENTRAS directiva para
calcular los factoriales:
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 250 de 26 de
Impreso: 10/02/00 16:22

Pgina 28
251
factorial
Num MACRO: REQ
LOCAL
i, el factor
= factor num
i = 1
Mientras que el factor GT 1
i = i * factor de
Factor = Factor - 1
ENDM
EXITM% i
ENDM
El resultado entero del clculo se cambia a una cadena de texto con la expansin
operador ( % ). La
factorial
macro puede definir los datos, como se muestra aqu:
var WORD factorial (4)
Esta sentencia inicializa
var
con el nmero 24 (el factorial de 4).
Uso de las funciones de macro con listas de parmetros de longitud variable
Usted puede utilizar el PARA directiva para manejar parmetros de la macro con la vararg
atribuir. "PARA Loops y parmetros de longitud variable" en la pgina 242, explica

cmo hacer esto en casos simples donde los parmetros de las variables que se manipulan
secuencialmente, de principio a fin. Sin embargo, a veces puede que tenga que procesar
los parmetros en orden inverso o de forma no secuencial. Funciones de macro hacen estos
tcnicas posibles.
Por ejemplo, la siguiente funcin macro determina el nmero de argumentos
en un vararg parmetro:
@ ArgCount arglist MACRO: vararg
Recuento LOCAL
count = 0
PARA arg, <arglist>
count = count + 1;; Cuente los argumentos
ENDM
ENDM
EXITM% count
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 251 de 27 de
Impreso: 10/02/00 16:22

Pgina 29
252
Gua del programador
Usted puede usar

@ ArgCoun t
dentro de una macro que tiene un vararg parmetro, como
se muestra aqu:
trabajar args MACRO: vararg
ECHO% Nmero de argumentos es: @ ArgCount (args)
ENDM
Otra tarea til podra ser la de seleccionar un elemento de una lista de argumentos utilizando
un
ndice para indicar el artculo. La siguiente macro simplifica esto.
@ Arg I ndice MACRO: REQ, arglist: vararg
Recuento LOCAL, RetStr
RetStr TEXTEQU <>
;; Inicialice conteo
count = 0
;; Inicializar cadena devuelta
PARA arg, <arglist>
count = count + 1
Si el ndice EQ conteo;; Artculo se encuentra
RetStr TEXTEQU <arg>;; Establecer cadena devuelta
EXITM
;; y salida IF
ENDIF
ENDM
ENDM
EXITM RetStr
;; Salir de la funcin
Usted puede usar

@ Arg I
de esta manera:
% ECHO tercer argumento es: @ ArgI (3, args)
ENDM
Por ltimo, es posible que tenga que procesar argumentos en orden inverso. La siguiente
macro devuelve una nueva lista de argumentos en el orden inverso.
@ ArgRe v MACRO arglist: REQ
Txt LOCAL, arg
txt TEXTEQU <>
% PARA arg, <arglist>
txt CATSTR <arg>, <,>, txt;; Pegue cada en la lista
ENDM
;; Retire la terminacin comas
ENDM
txt SUBSTR txt, 1, @ SizeStr (% txt) - 1
txt CATSTR <<>, txt, <>> ;; Aadir parntesis angulares
EXITM txt
Pro yecto:
Autor: rick Debroux

Pgina 30
Revisin #: 86
Pgina: 252 de 28 de

Impreso: 10/02/00 16:22

Pgina 31
253
He aqu un ejemplo que muestra
@ ArgRe v
en uso:
% PARA arg, @ ArgRev (<args>);; Proceso en el orden inverso
ECHO arg
ENDM
ENDM
Estas tres funciones de macro aparecen en el MACROS.INC archivo de inclusin, que se
encuentra
en uno de los discos de distribucin MASM.
Operador de Expansin de Funciones de Macro
Esta lista se resume el comportamiento del operador de expansin ( % ) con macro
funciones.

Si una funcin de macro est precedido por un % , que se ampliar. Sin embargo, si se
se expande a una macro de texto o una llamada a una funcin macro, no se ampliar an ms.

Si utiliza una llamada a una funcin macro como argumento para otra funcin macro
llamar, un % no es necesario.

Si una funcin macro es llamada dentro de parntesis angulares y est precedida por % , se

se ampliar.
Tcnicas Avanzadas Macro
El concepto de sustitucin de nombres de macro con el texto macro predefinida es simple en
teora, pero tiene muchas implicaciones y complicaciones. Aqu est un breve resumen
de algunas tcnicas avanzadas que puede utilizar en macros.
Definicin de macros dentro de Macros
Las macros se pueden definir otras macros, una tcnica llamada "macros de anidacin." MASM
expande las macros, ya que se encuentra con ellas, por lo que las macros anidadas siempre se
procesan
con el fin de anidacin. No se puede hacer referencia a una macro anidada directamente en su
programa,
ya que el ensamblador comienza la expansin de la macro exterior. En efecto, un anidado
macro es local a la macro que lo define. Slo la cantidad de memoria disponible
limita el nmero de macros de un programa pueden anidar.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 253 de 29 de
Impreso: 10/02/00 16:22

Pgina 32
254
Gua del programador
El siguiente ejemplo muestra cmo una macro puede definir otro. La

macro toma como argumento el nombre de un turno o de operacin de rotacin, a
continuacin,
crea otra macro que simplifica la instruccin para 8088/86 procesadores.
desplaza opname MACRO
;; Macro genera macros
opname & s
Operando MACRO: REQ, gira: = <1>
SI LE gira 2
;; Uno a la vez es ms rpido
REPEAT girar;; para 2 o menos
operando opname, 1
ENDM
ENDM
ENDM
ELSE
;; Uso de CL es ms rpido para
mov
Cl, gira;; ms de 2
operando opname, cl
ENDIF
Recordemos que el procesador 8086 slo permite 1 o CL como operando de turno y
girar instrucciones. En expansin
turnos
genera una macro para el turno
instruccin que utiliza cualquiera de los operandos es ms eficiente. Se crea la totalidad
serie de macros, uno para cada operacin de desplazamiento, as:
; Llame macro varias veces para hacer nuevas macros

turnos
ror
; Genera Rors
turnos
rol
; Genera rols
turnos
shr
; Genera SHRs
turnos
SHL
; Genera SHL
turnos
RCL
; Genera RCLS
turnos
rcr
; Genera RCRS
turnos
sal
; Genera sals
turnos
sar
; Genera sars
A continuacin, utilice las nuevas macros para reemplazar las instrucciones de desplazamiento,
as:
SHR hacha, 5

rols bx, 3
Las pruebas para detectar Argument Type y Medio Ambiente
Las macros se pueden ampliar los bloques condicionales de cdigo mediante la comprobacin
para el tipo de discusin con
la OPATTR operador. OPATTR devuelve una sola palabra constante que indica
el tipo y el alcance de una expresin, como este:
OPATTR expresin
Si la expresin no es vlido o es delantero referencia-, OPATTR devuelve un 0.
De lo contrario, el valor de retorno incorpora los indicadores de bits se muestran en la
siguiente tabla.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 254 de 30
Impreso: 10/02/00 16:22

Pgina 33
255
OPATTR sirve como una versin mejorada del TIPO. operador, que devuelve
slo el byte bajo (bits 0-7) se muestra en la tabla. Bits 11-15 del valor de retorno
no estn definidos.
Poco
Ajuste Si la expresin
0

Hace referencia a una etiqueta de cdigo de
1
Es una variable de memoria o tiene una etiqueta de datos reubicable
2
Es un valor inmediato
3
Utiliza la memoria de direccionamiento directo
4
Es un valor de registro
5
Las referencias no indefinidos smbolos y es sin error
6
Es en relacin con SS
7
Hace referencia a una etiqueta externa
8
-
10
Tiene los siguientes tipos idioma:

000-No tipo de lenguaje

001-C

010-SYSCALL

011-STDCALL

100-Pascal

101-FORTRAN

110-bsico
Una macro puede utilizar OPATTR para determinar si un argumento es una constante, un
registro,
o un operando de memoria. Con esta informacin, la macro puede condicionalmente
generar el cdigo ms eficiente en funcin de tipo de argumento.
Por ejemplo, dado un argumento constante, una macro puede probarlo de 0. Dependiendo
el valor del argumento, el cdigo puede seleccionar el mtodo ms eficaz para cargar el
valorar en un registro:
IF CONST
mov
bx, CONST
; Si CONST> 0, se mueven en BX
ELSE
sub
bx, bx
; Ms eficiente si CONST = 0
ENDIF
Pro yecto:
Autor: rick Debroux

Revisin #: 86
Pgina: 255 de 31
Impreso: 10/02/00 16:22

Pgina 34
256
Gua del programador
El segundo mtodo es ms rpido que el primero, sin embargo, tiene el mismo resultado (con
la
subproducto de cambiar las banderas de procesador).
La macro siguiente ilustra algunas de las tcnicas que utilizan OPATTR cargando un
frente a un registro de desplazamiento especificada:
MACRO carga reg: REQ, adr: REQ
IF (OPATTR (adr)) Y 00010000y;; Registrar
IFDIFI reg, adr
;; No cargue registro
mov
reg, adr;; sobre s mismo
ENDIF
ELSEIF (OPATTR (adr)) Y 00000100y
mov reg, adr
;; Constante
ELSEIF (TIPO (adr) BYTE EQ) OR (TIPO (adr) SBYTE EQ)
mov reg, adr OFFSET;; Bytes
ELSEIF (SIZE (TIPO (adr)) EQ 2
mov reg, adr
;; Cerca de puntero

ELSEIF (SIZE (TIPO (adr)) EQ 4
mov reg, WORD PTR adr [0];; Puntero del Lejano
mov ds, WORD PTR adr [2]
ELSE
. ERR <Illegal argument>
ENDM
ENDIF
Una macro tambin puede generar cdigo diferente dependiendo de la asamblea
medio ambiente. La macro de texto predefinido @ Cpu devuelve una bandera para
procesador
escriba. El siguiente ejemplo utiliza la variacin constante ms eficiente de la
PUSH instruccin si el procesador es un 80186 o superior.
SI @ Cp U y 00000010y
pushc op MACRO;; 80.186 o ms alto
empujar op
ELSE
ENDM
pushc op MACRO;; 8088/8086
mov ax, op
empujar hacha
ENDM
ENDIF
Otra macro puede utilizar ahora
pushc
en lugar de la prueba condicional para
propio tipo de procesador. Aunque cualquiera de los casos produce el mismo cdigo,
utilizando
pushc

rene ms rpido debido a que el medio ambiente se comprueba una sola vez.
Pro yecto:
Autor: rick Debroux
Revisin #: 86
Pgina: 256 de 32
Impreso: 10/02/00 16:22

Pgina 35
257
Puede probar el idioma y el sistema operativo utilizando el @ Interface texto
macro. El modelo de memoria se puede probar con el modelo @ , @ DataSize ,
o
@ CodeSize macros de texto.
Puede guardar los contextos dentro de macros con PUSHCONTEXT y
POPCONTEXT . Las opciones para estas palabras clave son:
Opcin
Descripcin
ASUME
Guarda registro de segmento
informacin RADIX
Guarda actual
default radix LISTADO
Guarda la lista y

CREF informacin CPU
Guarda
CPU y el procesador actual TODO
Todo de lo anterior
Uso de macros recursivas
Las macros pueden llamarse a s mismos. En MASM 5.1 y versiones anteriores, la recursividad es
una tcnica importante para el manejo de argumentos variables. MASM 6.1 mangos argumentos
variables mucho ms limpiamente con la PARA Directiva y el
Vararg atributo, como se describe en "Bucles FOR y de longitud variable
Parmetros ", anteriormente en este captulo. Sin embargo, la recursividad est libre puede ser
til para algunas macros.

PROGRAMAS
HOLA MUNDO

;
include \masm32\include\masm32rt.inc
;
comment * -----------------------------------------------------

Build this console app with
"MAKEIT.BAT" on the PROJECT menu.
----------------------------------------------------- *
.data?
value dd ?
.data
item dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls
print "Hola Mundo",13,10
ret
main endp
;
end start

SUMATORIA DE NUMEROS DEL 1 AL 20

;
;

comment * -----------------------------------------------------
----------------------------------------------------- *

.data?
value dd ?

.data
item dd 0
incrementar dd 0
sumar dd 0
.code

start:

;

call main
inkey
exit

;

main proc

cls
print chr$("Programa de ejemplo suma.",10)
mov ax,1
xor ecx,ecx;xor=0
ciclo:
mov ecx,sumar
add ecx,eax
inc eax
mov incrementar,eax
mov sumar,ecx
print chr$("incrementando em -->")
mov eax,incrementar
sub eax,1
print str$(eax)
print chr$("la suma es -->")
mov ecx,sumar
print str$(ecx)
print chr$(10)
mov eax,incrementar
cmp eax,20
jle ciclo
print chr$(7,"la suma de los numeros del 1 al 20 es")

mov ecx,sumar
print str$(ecx)
print chr$(7,10)
print chr$(7,10)
inkey
exit
ret

main endp

;

end start

SUMATORIA DE NUMEROS PARES DEL 1 AL 100

;
include \masm32\include\masm32rt.inc;

comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
.data
item dd 0
incrementar dd 0

sumar dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls
mov ax,2
xor eax,eax;xor consigo mismo siempre el resultado en cero (0)
ciclo:
mov ecx,sumar
inc eax
inc eax
add ecx,eax
mov incrementar,eax
mov sumar,ecx
print chr$("Incrementado en -> ")
mov eax, incrementar
print str$(eax)
sub eax,1
print chr$(" la suma es -> ")
mov ecx,sumar
print str$(ecx)
print chr$(10)
cmp eax,98
jle ciclo ;jle -> salta si es menor o igual o salta si no es mas grande
print chr$(7,"La suma de los numeros del 1 al 100 es ")
mov ecx, sumar
print str$(ecx)
print chr$(7,10)
print chr$(7,10)
inkey
exit
ret
main endp
;
end start

SUMATORIA DE TODOS LOS NUMEROS DEL 1 AL 100

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
.data
item dd 0
incrementar dd 0
sumar dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls
mov ax,1
xor ecx, ecx ;xor consigo mismo siempre el resultado en cero (0)
ciclo:
mov ecx,sumar

add ecx,eax
inc eax
mov incrementar,eax
mov sumar,ecx
print chr$("Incrementado en -> ")
sub eax,1
print str$(eax)
print chr$(" la suma es -> ")
mov ecx,sumar
print str$(ecx)
print chr$(10)
cmp eax,100
jle ciclo ;jle -> salta si es menor o igual o salta si no es mas grande
print chr$(7,"La suma de los numeros del 1 al 100 es ")
mov ecx, sumar
print str$(ecx)
print chr$(7,10)
print chr$(7,10)
inkey
exit
ret
main endp
;
end start

MULTIPLICACION DE 4 NUMEROS

;
;

comment * -----------------------------------------------------
----------------------------------------------------- *

.data?
value dd ?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?

.data
item dd 0
sum dd 0
prod dd 0
prod2 dd 0

.code

start:

;

call main
inkey
exit

;

main proc

cls
mov EAX,sval(input("Enter first number: "))
mov num1,EAX
mov EAX,sval(input("Enter second number: "))
mov num2,EAX
mov EAX,sval(input("Enter third number: "))
mov num3,EAX
mov EAX,sval(input("Enter fourth number: "))
mov num4,EAX

mov EAX,num1
mov EBX,num2
mul BL ;8 bit x 8 bit------- AX / 16bit

mov EBX,num3
mul BX ;16 bit x 16 bit------/DX:AX

shl EDX, 16 ;shift low to high ;high /high/ low in EDX
mov DX,AX ;mov in all reg

mov ECX,num4 ;32 bitx32bit------EAX xECX------EDX:EAX
mul CX
mov prod2,EAX ; for printing

;/////
mov EAX,num1
mov EBX,num2
mul BL ;8bitx8bit------- AX / 16bit

mov EBX,num3
mul BX ;16bit x 16bit------/DX:AX

shl EDX,16 ;shift low to high ;high /high/ low in EDX

mov DX,AX ;mov in all reg
mov EAX,EDX ;prepare EAX for 32 bitx32bit

mov ECX,num4
mul ECX ;32 bitx32bit------EAX xECX------EDX:EAX
mov prod2,EAX ; for printing
print chr$(7,"la multiplicacion es: ")
print str$(prod2)
print chr$(10)
ret

main endp

;
end start

DIVISION DE 2 NUMEROS

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
num1 dd ?
num2 dd ?

.data

r dd 0

.code
start:
;
call main
inkey
exit
;
main proc

cls
mov eax,sval(input("Numero 1: "))
mov num1,eax
mov eax,sval(input("Numero 2: "))
mov num2,eax

mov eax,num1
mov ebx,num2
xor edx,edx
div ebx

mov r,eax
print chr$(7,"La division es : ")
print str$(r)
print chr$(10)

ret

main endp

;

end start

EL MAYOR DE 4 NUMEROS

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?
.data
item dd 0
sum dd 0
prod dd 0
prod2 dd 0
aux dd 0
.code
start:
;

call main
inkey
exit

;

main proc

cls
mov EAX,sval(input("Teclea el primer numero: "))
mov num1,EAX
mov EAX,sval(input("teclea el segundo numero: "))
mov num2,EAX
mov EAX,sval(input("Teclea el tercer numero: "))
mov num3,EAX
mov EAX,sval(input("teclea el cuarto numero: "))
mov num4,EAX

print chr$(" ",10)

;--------------------------PRIMER------------------------------

mov eax,num1
cmp eax,num2
jnb mayor

cmp eax,num2
jna menor

menor:
mov eax,num2
mov aux,eax

mayor:
mov aux,eax
;---------------------Segunda------------------
mov eax,aux
cmp eax,num3
jnb mayor2

cmp eax,num3
jna menor2

menor2:
mov eax,num3
mov aux,eax

mayor2:

mov aux,eax
;---------------------tercero-----------------
mov eax,aux
cmp eax,num4
jnb mayor3

cmp eax,num4
jna menor3

menor3:
mov eax,num4
mov aux,eax

mayor3:
mov aux,eax

;-------------------------------------------------------------------------------------
print chr$("--------------------------------resultado----------------------",10)
print chr$(" ",10)
print chr$("El numero mayor es: ")
mov ecx,aux
print str$(ecx)
print chr$(10)
print chr$(" ",10)
print chr$("---------------------FIN-----------------",10)

inkey
exit
ret
main endp
;
end start

DETERMINA EL RANGO DE UN NUMERO DADO

;
;

comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
rango dd ?
.data
item dd 0
.code
start:

;
call main
inkey
exit
;
main proc
cls
mov EAX,sval(input("Teclea RANGO: "))
mov rango,EAX

.if eax>=1 && eax<=10

print chr$("Rango entre 1 y 10",10)
.elseif eax>=11 && eax<=27
.elseif eax>=28 && eax<=36
.else
print chr$("FUERA DE RANGO",10)
.endif

ret

main endp

;

end start
LEE UN NUMERO Y LO CLASIFICA DE ACUERDO A CALIFICACION

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
.data
item dd 0

.code
start:
;
call main
inkey
exit

;

main proc

cls
mov EAX,sval(input("Teclea la calificacion: "))

.if eax>=70 && eax<80
print chr$("REGULAR",10)
.elseif eax>=80 && eax<90
print chr$("BUENO",10)
.elseif eax>=90
print chr$("EXCELENTE ",10)
.elseif eax<70
print chr$("ESTA REPROBADO",10)
.endif

ret

main endp

;

end start

SUMA 4 NUMEROS Y SACA EL PROMEDIO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?
.data
item dd 0
sum dd 0
prod dd 0
prod2 dd 0
aux dd 0
.code
start:
;
call main
inkey
exit
;
main proc

cls
mov num1,sval(input("Teclea el primer numero: "))
mov num2,sval(input("teclea el segundo numero: "))
mov num3,sval(input("Teclea el tercer numero: "))
mov num4,sval(input("teclea el cuarto numero: "))
;SUMA
add EAX,num1
add EAX,num2
add EDX,num3
add EAX,num4
mov sum,EAX
;imprima suma
print chr$(7,"la suma es: ")
print str$(sum)
print chr$(10)
;DIVISION
xor EDX,EDX
mov EAX,sum
mov EBX,4
div EBX

mov prod,EAX
print chr$(7,"la promedio es: ")
print str$(prod)
print chr$(10)
ret
main endp
;
end start

PROGRAMA QUE LEE NOMBRE Y CALIFICACIONES Y DETERMINA PROMEDIO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
nombre dd ?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?
num5 dd ?
.data
item dd 0
prod dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls

COMMENT JOSE MANUEL CALLEJA ZAMORA
mov nombre,sval(input("Ingrese el nombre del alumno: "))
mov num1,sval(input("Teclea calificacion 1: "))
mov num2,sval(input("teclea calificacion 2: "))
mov num3,sval(input("Teclea calificacion 3: "))
;SUMA
Xor EAX,EAX
add EAX,num1
add EAX,num2
add EAX,num3
add EAX,num4
add EAX,num5
;DIVISION PARA PROMEDIO
xor EDX,EDX
mov EBX,5
div EBX

mov prod,EAX
print chr$(7,"El promedio es: ")
print str$(prod)
print chr$(10)
;COMPARACION
mov EDX,num1
.if EDX>prod
print chr$("La calificacion 1 es mayor al promedio",10)
.endif
mov EDX,num2
.if EDX>prod
.endif
mov EDX,num3
.if EDX>prod
.endif
mov EDX,num4
.if EDX>prod
.endif
mov EDX,num5
.if EDX>prod
.endif

ret

main endp
;
end start

RECIBE UN NUMERO Y TE DICE SI ES MULTIPLO DE 2 O NO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
num dd ?
.data
item dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls

COMMENT JOSE MANUEL CALLEJA ZAMORA
mov num,sval(input("Teclea numero: "))
;DIVISION ENTRE DOS
xor EDX,EDX
mov EAX,num
mov EBX,2
div EBX
;COMPARACION DEL RESIDUO EDX
.if EDX==0
print chr$("El numero SI es multiplo de 2",10)
.else
print chr$("El numero NO es multiplo de 2",10)
.endif
ret
main endp
;
end start

CALCULA EL AREA DE UN TRIANGULO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?

num1 dd ?
num2 dd ?
.data
item dd 0
area dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls
mov num1,sval(input("Introducir Base: "))
mov num2,sval(input("Introducir Altura: "))
xor EAX,EAX
;multiplicacion
mov EAX,num1
mov EBX,num2
mul EBX
;division
xor EDX,EDX
mov EBX,2
div EBX
mov area,EAX
print chr$(7,"El area es: ")
print str$(area)
print chr$(10)
ret
main endp
;

end start

MENU: SUMA, RESTA, MULTIPLICACION Y DIVISION

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *

.data?
value dd ?
menu dd ?
num1 dd ?
num2 dd ?
.data
item dd 0
resultado dd 0
.code

start:

;

call main
inkey
exit

;

main proc

cls
.while menu!=5
print chr$(10)
print chr$("1.-Suma",10)
print chr$("2.-Resta",10)
print chr$("3.-Multiplicacion",10)
print chr$("4.-Division",10)
print chr$("5.-Salir",10)
mov menu,sval(input("Que desea hacer: "))

.if menu==1
mov num1,sval(input("Introducir numero 1: "))
xor EAX,EAX
add EAX,num1
add EAX,num2
mov resultado,EAX
print chr$(7,"La suma es: ")
print str$(resultado)
print chr$(10)

.endif

.if menu==2
print chr$("MENOS",10)
xor EAX,EAX
mov EAX,num1
sub EAX,num2
mov resultado,EAX
print chr$(7,"La resta es: ")
print chr$(10)
.endif

.if menu==3
mov EAX,sval(input("Introducir numero 1: "))
mov EBX,sval(input("Introducir numero 2: "))
mul EBX

mov resultado,EAX
print chr$(7,"La multiplicacion es: ")
print chr$(10)
.endif

.if menu==4
print chr$("ENTRE",10)

xor EDX,EDX
mov EAX,num1
mov EBX,num2
div EBX
mov resultado,EAX
print chr$(7,"La division es: ")
print chr$(10)

.endif
.endw
ret
main endp
;
end start

CONTADOR IMPRIME HASTA UN NUMERO DADO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
value dd ?
numero dd ?
.data
item dd 0
sali dd 0
impre dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls
mov numero,sval(input("introduzca el numero N: "))

salto:
inc sali
mov impre,0
impresion:
inc impre
print str$(impre)
print " "
mov eax,impre
cmp eax,sali
jnz impresion
print " ",10
mov eax,sali
cmp eax,numero
jnz salto
ret
main endp
;
end start

NUMERO PRIMO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
numero dd ?
.data
cero dd 0
uno dd 1
dos dd 2
.code
start:
;
call main
inkey
exit
;
main proc

cls
print chr$("VERIFICADOR DE NUMEROS PRIMOS")
print chr$(10)
print chr$(10)
mov eax, sval(input("Introduzca el numero a evaluar: "))

mov numero, eax

cmp eax,cero
je neutro

cmp eax,uno
je primo

cmp eax,dos
je primo

mov ebx, dos

ciclo:
mov eax,numero
xor edx,edx
div ebx
inc ebx
test edx,edx
je noprimo
cmp numero,ebx
je primo
jl ciclo
neutro:
print chr$("El cero es numero neutro")
print chr$(10)
ret

noprimo:
print chr$("El numero ")
print str$(numero)
print chr$(" no es primo")
print chr$(10)
ret
primo:
print chr$("El numero ")
print str$(numero)
print chr$(" si es primo")
print chr$(10)
ret
main endp
;
end start

SUMA Y RESTA

include\masm32\include\masm32rt.inc
.data

.code

start:

push <G>
push <10>
push <1>
push SEG<buffer>
push OFFSET<buffer>
call _AbsoluteRead

PUBLIC _AbsoluteRead
PROC NEAR
ARG Buffer:DWORD,Start:WORD,NumSelect:WORD,Drive:BYTE=ArgLen
push bp ;salvar BP
mov bp,sp ;permitir acceso a los argumentos
push bx ;salvar registros
push cx
push dx
push ds

mov al,Drive ;lectura absoluta de disco
mov cx,NumeSelect
mov dx,Start
lds bx,Buffer

int 25h
pop bx

pop ds ;recuperar registros
pop dx
pop cx
pop bx
pop bp
ret ArgLen
ENDP
APROBADO O REPROBADO

;
;

comment * -----------------------------------------------------
----------------------------------------------------- *

.data?
value dd ?
num dd ?

.data
item dd 0

.code

start:

;

call main
inkey
exit

;

main proc

cls
mov EAX,sval(input("Numero a evaluar: "))
mov num,EAX
cmp num,69
jle ciclomenor

cmp num,70
jnb ciclomayor
ciclomayor:
print chr$(7,"El numero: ")
print str$(num)
print chr$(7," es APROBATORIO.")
print chr$(10)
ret

ciclomenor:
print str$(num)
print chr$(7," es REPROBATORIO.")
print chr$(10)

ret

main endp

;

end start

SUMA DE NUMERO PARES

;
;

comment * -----------------------------------------------------
----------------------------------------------------- *

.data?
num dd ?

.data
resul dd 0
cont dd 0
suma dd 0

.code

start:

;

call main
inkey
exit

;

main proc

cls
ciclo:
mov eax,sval(input("Numero PAR a sumar: "))
mov num,eax
mov ebx,2
xor edx,edx
div ebx
mov resul,edx
cmp resul,0
jne ciclo

ciclo2:
mov ebx,num
mov eax,suma
inc cont
inc cont
add eax,cont
mov suma,eax
print str$(cont)
print chr$(7,", ")
cmp cont,ebx
jnae ciclo2
print chr$(10)
print chr$(7,"La suma es: ")
print str$(suma)
print chr$(10)

ret

main endp

;

end start

CALCULO DE PROMEDIO Y CALIFICACION ARRIBA DEL PROMEDIO

;
;
comment * -----------------------------------------------------
----------------------------------------------------- *
.data?
num1 dd ?
num2 dd ?
num3 dd ?
num4 dd ?
num5 dd ?
nombre dd ?

.data
sum dd 0
prom dd 0

.code

start:

;

call main
inkey
exit

;

main proc

cls
print "Programa Promedio( Escala 0 a 100)",10
mov eax,sval(input("Nombre del alumno: "))
mov nombre,eax

mov eax,sval(input("Primer dato: "))
mov num1,eax
mov eax,sval(input("Segundo dato: "))
mov num2,eax
mov eax,sval(input("Tercer dato: "))
mov num3,eax
mov eax,sval(input("Cuarto dato: "))
mov num4,eax
mov eax,sval(input("Quinto dato: "))
mov num5,eax

mov eax,num1
add eax,num2
add eax,num3
add eax,num4
add eax,num5
mov sum,eax
mov ebx,5
xor edx,edx
div ebx
mov prom,eax
mov ebx,prom

print "Promedio: "
print str$(prom)
print chr$(10)

.if num1 >ebx
print chr$(7,"Calificacion arriva del promedio: ")
print str$(num1)
print chr$(10)
.endif
.if num2>ebx
print str$(num2)
print chr$(10)
.endif
.if num3>ebx
print str$(num3)
print chr$(10)
.endif
.if num4 >ebx
print str$(num4)
print chr$(10)
.endif
.if num5>ebx
print str$(num5)
print chr$(10)
.endif

ret

main endp

;

end start

CICLO DECREMENTAL

;
;
.data?
.data
num dd 0
.code
start:
;
call main
inkey
exit
;
main proc
cls
mov num,10
ciclo:
print str$(num)
print chr$(10)
dec num
cmp num,0
jnz ciclo
ret
main endp
;
end start

Lenguaje de Interfaz Final

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Lenguaje de Interfaz Final

Încărcat de

Drepturi de autor:

Formate disponibile

Instituto Tecnolgico de Lzaro Crdenas

INGENIERIA EN SISTEMAS COMPUTACIONALES

S-ar putea să vă placă și