• Author / Uploaded
• Jose Manuel Calleja Zamora

Citation preview

Instituto Tecnológico de Lázaro Cárdenas

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 PROGRAMACIÓN EN LENGUAJE ENSAMBLADOR....................................... 4 1.2 EL PROCESADOR Y SUS REGISTROS INTERNOS ............................................................................. 4 1.3 LA MEMORIA PRINCIPAL (RAM) .................................................................................................... 8 1.4 CONCEPTO DE INTERRUPCIÓN...................................................................................................... 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 BÁSICA 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 ARITMÉTICAS ................................................................................................... 29 2.10 MANIPULACIÓN DE PILA ........................................................................................................... 30 2.11 OBTENCION DE CADENA CON REPRESENTACION HEXADECIMAL ............................................ 31 2.12 INSTRUCCIONES LÓGICAS ......................................................................................................... 35 2.13 DESPLAZAMIENTO Y ROTACIÓN ............................................................................................... 36 2.14 OBTENCIÓN 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 Programación Del Puerto Serial .................................................................................................. 55 4.4 Programación Del Puerto Paralelo .............................................................................................. 62 4.5 Programación Híbrida ................................................................................................................. 66 4.6 Programación 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 PROGRAMACIÓN EN LENGUAJE ENSAMBLADOR Definición: El lenguaje ensamblador es un tipo de lenguaje de bajo nivel utilizado para escribir programas informáticos, y constituye la representación más directa del código máquina específico 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 sería 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 más cercano a la máquina la computadora lo procesa más rápido. 2. Eficiencia de tamaño.- Un programa en ensamblador no ocupa mucho espacio en memoria porque no tiene que cargan librerías y demás como son los lenguajes de alto nivel. 3. Flexibilidad.- En lenguaje ensamblador se pueden hacer tareas específicas 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 expansión 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 ejecución, manejar direccionamiento de memoria y proporcionar capacidad aritmética. Los registros son direccionables por medio de un nombre. Los bits por convención, 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 dirección inicial del segmento de código de un programa en el registro CS. Esta dirección de segmento, más un valor de desplazamiento en el registro apuntador de instrucción (IP), indica la dirección de una instrucción que es buscada para su ejecución. Registro DS. La dirección inicial de un segmento de datos de programa es almacenada en el registro DS. En términos sencillos, esta dirección, más un valor de desplazamiento en una instrucción, genera una referencia a la localidad de un byte especifico en el segmento de datos. Registro SS. El registro SS permite la colocación en memoria de una pila, para almacenamiento temporal de direcciones y datos. El DOS almacena la dirección de inicio del segmento de pila de un programa en el registro SS. Esta dirección de segmento, más 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 dirección de segmento apropiada. Registros FS y GS. Son registros extra de segmento en los procesadores 80386 y posteriores.

Registros de propósito 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 aritmética. Por ejemplo, las instrucciones para multiplicar, dividir y traducir suponen el uso del AX. También, algunas operaciones generan código más 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 propósito general que puede ser índice para direccionamiento indexado. También es común emplear el BX para cálculos.

Registro DX. El DX es conocido como el registro de datos. Algunas operaciones de entrada/salida requieren uso, y las operaciones de multiplicación y división 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 dirección de la siguiente instrucción que se ejecuta. El IP está asociado con el registro CS en el sentido de que el IP indica la instrucción actual dentro del segmento de código 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) están 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 automática estos registros.

Registro BP. El BP de 16 bits facilita la referencia de parámetros, los cuales son datos y direcciones transmitidos vía pila.

Registros Índice. Los registros SI y DI están 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 también 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 máquina y el resultado del procesamiento. Muchas instrucciones que piden comparaciones y aritmética cambian el estado de las banderas, algunas cuyas instrucciones pueden realizar pruebas para determinar la acción subsecuente:

OF (Overflow, desbordamiento). Indica desbordamiento de un bit de orden alto (mas a la izquierda) después de una operación aritmética. DF (dirección). Designa la dirección hacia la izquierda o hacia la derecha para mover o comparar cadenas de caracteres.

IF (interrupción). Indica que una interrupción externa, como la entrada desde el teclado, sea procesada o ignorada. TF (trampa). Permite la operación del procesador en modo de un paso. Los programas depuradores, como el DEBUG, activan esta bandera de manera que usted pueda avanzar en la ejecución de una sola instrucción a un tiempo, para examinar el efecto de esa instrucción sobre los registros de memoria. SF (signo). Contiene el signo resultante de una operación aritmética (0 = positivo y 1 = negativo). ZF (cero). Indica el resultado de una operación aritmética o de comparación (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 aritmética especializada. PF (paridad). Indica paridad par o impar de una operación en datos de 8 bits de bajo orden (mas a la derecha). CF (acarreo). Contiene el acarreo de orden más alto (más a la izquierda) después de una operación aritmética; también lleva el contenido del último bit en una operación de corrimiento o de rotación.

Las banderas están en el registro de banderas en las siguientes posiciones:

1.3 LA MEMORIA PRINCIPAL (RAM) RAM es el acrónimo inglés de Random Access Memory (memoria de acceso aleatorio). Se trata de una memoria de semiconductor en la que se puede tanto leer como escribir información. Es una memoria volátil, es decir, pierde su contenido al desconectar la energía eléctrica. 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 posición 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 rígido debe hacer dos accesos consecutivos a sectores alejados físicamente entre sí, se pierde un tiempo en mover la cabeza hasta la pista deseada (o esperar que el sector pase por debajo, si ambos están en la misma pista), tiempo que no se pierde en la RAM.

Las RAM se dividen en estáticas y dinámicas. Una memoria RAM estática mantiene su contenido inalterado mientras esté alimentada. La información contenida en una memoria RAM dinámica se degrada con el tiempo, llegando ésta a desaparecer, a pesar de estar alimentada. Para evitarlo hay que restaurar la información contenida en sus celdas a intervalos regulares, operación denominada refresco.

Las memorias se agrupan en módulos, que se conectan a la placa base del computador. Según los tipos de conectores que lleven los módulos, se clasifican en Módulos SIMM (Single In-line Memory Module), con 30 o 72 contactos, módulos DIMM (Dual In-line Memory Module), con 168 contactos y módulos RIMM (RAMBUS In-line Memory Module) con 184 contactos.

1.4 CONCEPTO DE INTERRUPCIÓN. Un procesador no puede procesar simultáneamente varios trozos de información (procesa un trozo de información a la vez), un programa que está siendo ejecutado puede, gracias al pedido de interrupción, ser momentáneamente suspendido mientras se produce una interrupción. El programa interrumpido puede continuar ejecutándose luego. Existen 256 direcciones de interrupción diferentes. Una interrupción se convierte en una interrupción de hardware cuando es solicitada por uno de los componentes de hardware del equipo. En efecto, existen varios periféricos en un equipo. Estos periféricos necesitan generalmente utilizar los recursos del sistema aunque sólo sea para comunicarse con el sistema mismo. Cuando un periférico desea acceder a un recurso, envía un pedido de interrupción al procesador para llamar su atención. Los periféricos cuentan con un número de interrupción que se denomina IRQ (Peticiones de Interrupción. Es como si cada periférico tirara de un "hilo" que está atado a una campana para señalarle al equipo que desea que le preste atención Este "hilo" es, de hecho, una línea física que conecta cada ranura de expansión así como cada interfaz E/S a la placa madre. Para una ranura ISA de 8 bits, por ejemplo, hay 8 líneas IRQ que unen ranuras ISA de 8 bits a la placa madre (IRQ0 a IRQ7). Estos IRQ están controlados por un "controlador de interrupción" 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 interrupción. Los dos grupos de interrupciones están 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 comúnmente usan una instrucción especial de la CPU que causa que el procesador transfiera el control a un código privilegiado. Previamente especificado por el mismo código. Esto permite al código privilegiado especificar donde va a ser conectado así como el estado del procesador.

Cuando una llamada al sistema es invocada, la ejecución del programa que invoca es interrumpida y sus datos son guardados, normalmente en su PCB (Bloque de Control de Proceso del inglés Process Control Block), para poder continuar ejecutándose luego. El procesador entonces comienza a ejecutar las instrucciones de código de alto nivel de privilegio, para realizar la tarea requerida. Cuando esta finaliza, se retorna al proceso original, y continúa su ejecución. El retorno al proceso demandante no obligatoriamente es inmediato, depende del tiempo de ejecución de la llamada al sistema y del algoritmo de planificación de CPU.

Las llamadas son peticiones a ejecución de rutinas y proporcionan la interfaz entre el sistema operativo y un programa en ejecución. 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 ejecución y el control de programas, usualmente incluyen un conjunto completo de los servicios accesibles por la vía del lenguaje de órdenes, tales como: RUN, EXECUTE, ABORT y planificación relacionada con el tiempo, además los usuarios con las llamadas del sistema pueden suspender, establecer o cambiar atributos del tiempo de ejecución de uno o más programas.

Las llamadas del sistema para el gestor de recursos, proporcionan servicios para la asignación, reserva y reclamación de los recursos del sistema. Por ejemplo, existen llamadas del sistema para extender o reducir la cantidad de memoria poseída por el programa que se llama. Las llamadas del sistema pueden asignar o reservar otros tipos de objetos del sistema y después destruir o devolver su custodia al sistema operativo.

Las llamadas al sistema se pueden agrupar en cinco categorías:

1.

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

2.

Manipulación de archivos (Crear, abrir, leer, obtener y establecer atributos, cerrar y eliminar archivos).

3.

Manipulación de periféricos (Solicitar, escribir, leer, obtener y establecer atributos, liberar periférico).

4.

Manipulación de la información (Obtener fecha y hora, establecer fecha y hora, obtener y establecer datos del sistema, obtener y establecer atributos).

5.

Comunicaciones (Crear conexión, enviar mensajes, recibir mensajes, transferir información del estado y eliminar conexión.

1.6 MODOS DE DIRECCIONAMIENTO. Los llamados modos de direccionamiento son las diferentes maneras de especificar en informática un operando dentro de una instrucción en lenguaje ensamblador.

Un modo de direccionamiento especifica la forma de calcular la dirección de memoria efectiva de un operando mediante el uso de la información contenida en registros y / o constantes, contenida dentro de una instrucción de la máquina 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 instrucción a ejecutar según 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 instrucción misma. En otras palabras, una instrucción de modo inmediato tiene un campo de operando en vez de un campo de dirección. El campo del operando contiene el operando actual que se debe utilizar en conjunto con la operación especificada en la instrucción. Las instrucciones de modo inmediato son útiles para inicializar los registros en un valor constante.

Cuando el campo de dirección especifica un registro del procesador, la instrucción se dice que está en el modo de registro.

Direccionamiento Directo. Es directo cuando la instrucción contiene el lugar donde se encuentra el operando. Según el lugar donde se encuentra el operando puede ser:

• • • •

Direccionamiento directo a registro. Direccionamiento directo a memoria Dirección completa (p. ej. Z80 sobre 64 Kb con 16 bits) Dirección sobre una página del mapa de memoria; también se conoce como direccionamiento de página base.

Direccionamiento Relativo. La instrucción indica el desplazamiento del operando con respecto a un puntero: La dirección 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. Dirección efectiva = Reg. Referencia + desplazamiento. Modo de direccionamiento / Registro de referencia / Cálculo dirección 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 más compactas. El código 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 operación adicional para el cálculo de la dirección del operando. Direccionamiento Indirecto. La posición indicada por la instrucción no es el operando sino la dirección de memoria en la que se encuentra, por lo que se necesita un acceso adicional a memoria.

La dirección de memoria se puede dar mediante:

Direccionamiento directo a memoria Direccionamiento relativo Es posible que se realicen múltiples niveles de indirección. Su utilidad más común es la de acceso a diversas informaciones mediante tablas de punteros.

Direccionamiento Implícito. En este modo de direccionamiento no es necesario poner ninguna dirección de forma explícita, ya que en el propio código de operación se conoce la dirección 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 están en registros.

Direccionamiento Indirecto por Registro.

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

Dir. Efectiva = Dir. de la parte de la instrucción + 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 más 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 más común, y como enlazador utilizaremos el programa link.

La extensión 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 extensión .OBJ, este archivo contiene un "formato intermedio" del programa, llamado así porque aún no es ejecutable pero tampoco es ya un programa en lenguaje fuente. El enlazador genera, a partir de un archivo .OBJ o la combinación de varios de estos archivos, un programa ejecutable, cuya extensión es usualmente .EXE aunque también 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 propósito 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 línea son comentarios. Un comentario puede contener cualquier carácter imprimible, incluyendo el espacio en blanco.

Un comentario puede aparecer solo en una línea o a continuación de una instrucción en la misma línea, como lo muestran los dos ejemplos siguientes:

Toda esta línea es un comentario. ADD AX, BX; Comentario en la misma línea que la instrucción.

Ya que un comentario aparece solo en un listado de un programa fuente en ensamblador y no genera código de máquina, puede incluir cualquier cantidad de comentarios sin afectar el tamaño o la ejecución del programa ensamblado. Otra manera de proporcionar comentarios es por medio de la directiva COMMENT. Palabras Reservadas Ciertas palabras en lenguaje ensamblador están reservadas para sus propósitos propios, y son usadas solo bajo condiciones especiales. Por categorías, 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. Símbolos predefinidos, como @Data y @Model, que regresan información 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 dirección de un elemento de dato y etiqueta, que se refiere a la dirección de una instrucción. Un identificador puede usar los siguientes caracteres:

1. Letras del alfabeto: Desde la A hasta la Z(mayúsculas o minúsculas) 2. Dígitos: Desde el 0 al 9 (no puede ser el primer carácter) 3. Caracteres especiales: Signo de interrogación ( ? ) Subrayado ( _ ), Signo de pesos ( $ ), Arroba ( @ ), Punto ( . ) (no puede ser el primer carácter) El primer carácter de un identificador debe ser una letra o un carácter especial, excepto punto. Ya que el ensamblador utiliza algunos símbolos especiales en palabras que inician con el símbolo @, debe evitar usarlo en sus definiciones.

En consecuencia, en una instrucción tal como:

ADD AX, BX: El ensamblador sabe de forma automática que AX y BX se refieren a los registros. Sin embargo, en una instrucción como: MOV REGSAVE, AX: El ensamblador puede reconocer el nombre REGSAVE solo si se define en algún lugar del programa.

Identificador, operación 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 más 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 instrucción. OPERACIÓN: La operación, que debe ser codificada, es con mayor frecuencia usada para la definición de áreas de datos y codificación de instrucciones. Para un elemento de datos, una operación como DB o DW define un campo, área de trabajo o constante. OPERANDO: El operando (si existe) proporciona información para la operación que actúa sobre él. Para un elemento de datos, el operando identifica su valor inicial. Por ejemplo, en la definición siguiente de un elemento de datos llamado COUNTER, la operación DB significa "definir byte", y el operando inicializa su contenido con un valor cero:

Para una instrucción, un operando indica en donde realizar la acción. Un operando de una instrucción puede tener una, dos o tal vez ninguna entrada. Aquí están 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 ejecución subsecuente del programa.

PAGE. Al inicio de un programa, la directiva PAGE designa el número máximo de líneas para listar en una página y el número máximo de caracteres en una línea. Su formato general es:

PAGE [longitud][, ancho]

El ejemplo siguiente proporciona 60 líneas por página y 132 caracteres por línea: PAGE 60, 132

El número de líneas por página puede variar desde 10 hasta 255, mientras que el número de caracteres por línea desde 60 hasta 132. La omisión de PAGE causa que el ensamblador tome PAGE 50, 80.

TITLE. Se puede emplear la directiva TITLE para hacer que un título para un programa se imprima en la línea 2 de cada página 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 técnica 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 más segmentos. Un segmento de pila define el almacén de la pila, un segmento de datos define los elementos de datos y un segmento de código proporciona un código 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 tamaño máximo de un segmento es de 64K. El operando de un enunciado SEGMENT puede tener tres tipos de opciones: alineación, combinar y clase, codificadas en este formato:nombre

SEGMENT

alineación

combinar

' clase ‘

TIPO ALINEACION. La entrada alineación indica el límite en el que inicia el segmento. Para el requerimiento típico, PARA, alinea el segmento con el límite de un párrafo, de manera que la dirección inicial es divisible entre 16, o 10H. En ausencia de un operando hace que el ensamblador por omisión tome PARA.

TIPO COMBINAR. La entrada combinar indica si se combina el segmento con otros segmentos cuando son enlazados después de ensamblar. Los tipos de combinar son STACK, COMMON, PUBLIC y la expresión AT. Por ejemplo, el segmento de la pila por lo común es definido como:

nombre SEGMENT PARA

STACK

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

TIPO CLASE. La entrada clase, encerrada entre apóstrofos, es utilizada para agrupar segmentos cuando se enlazan. Se utiliza la clase 'code' para el segmento de códigos, 'data' por segmento de datos y 'stack' para el segmento de la pila. El ejemplo siguiente define un segmento de pila con tipos alineación, 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 código. Para este fin, usted tiene que indicar al ensamblador el propósito de cada segmento en el programa.

La directiva para este propósito es ASSEME, codificada en el segmento de código como sigue: Operación 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 código simbólico a código maquina; aún puede tener que codificar instrucciones que físicamente cargan direcciones en registros de segmentos en el momento de la ejecución.

•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 dirección del segmento de datos

•MOV

DS, AX

;Almacena dirección en

DS • •MOV

... AX, 4C00H

;Peticion •INT DOS •BEGIN

21H

;Salida al

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 algún 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 autónomo (esto es, un programa que no esté enlazado con algún otro). El modelo TINY está destinado para uso exclusivo de programas .COM, los cuales tienen sus datos, código y pila en un segmento. El modelo SMALL exige que el código quepa en un segmento de 64K y los datos en otro segmento de 64K. La directiva .MODELL genera automáticamente 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 código son:

.STACK [tamaño] .DATA .CODE [nombre]

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

UNIDAD 2 PROGRAMACION BASICA 2.1 ENSAMBLADOR Y LIGADOR A UTILIZAR Un ensamblador es el programa que convierte un listado de código fuente, escrito en un fichero de texto, en código objeto, es decir, lenguaje máquina (el que finalmente interpretará el procesador) en el que sólo le faltan las referencias a rutinas externas. El código 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 código objeto consta del código en lenguaje máquina y de la información necesaria para enlazarlo con otros módulos 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 código fuente. La extensión no es necesaria ponerla y los parámetros /zi y /l sólo son útiles si queremos hacer un proceso de depuración (debug) con el Turbo Debugger. Tras la ejecución de esta línea se nos creará un fichero “nombre.obj Linkado y montado Al construir un programa algunos de sus módulos pueden colocarse en el mismo módulo fuente y ensamblarse juntos, otros pueden estar en módulos diferentes y ser ensamblados separadamente. En cualquier caso, los módulos objeto resultantes, algunos de los cuales pueden estar agrupados en librerías, deben ser enlazados para formar el módulo de carga, antes de que se pueda ejecutar el programa. Además de dar como salida el módulo de carga, el linker o enlazador imprime un mapa de memoria que indica donde serán cargados los módulos objeto en la memoria. Después de crearse el módulo de carga, éste es cargado por el cargador en la memoria del ordenador y comienza la ejecución. 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 extensión no es necesaria ponerla y el parámetro /v sólo es útil para el Turbo Debugger.

2.2 CICLOS NUMERICOS Un bucle es un grupo de instrucciones que se ejecutan cíclicamente un número concreto de veces. Para construir bucles disponemos de las siguientes instrucciones:

Éstas posibilitan el grupo de control más elemental de nuestros programas. Un bucle es un bloque de código que se ejecuta varias veces. Hay 4 tipos de bucles básicos: 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 BÁSICA 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 continuación 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 ; condición de terminación ; iteración 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 condición de terminación para el ciclo, la cual está directamente relacionada con los valores iniciales. Finalmente, la última parte especifica cómo serán manipulados los valores iniciales en cada iteración del ciclo. Ciclo IF Una característica 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 código, es importante señalar que esta sintaxis de no utilizar llaves ({ } ) es válida y muy común (Lamentablemente) Existe otra variación de if/else que agrupa las condicionales en una sola expresión:

if (expresion Boolean ? operación verdadera : operación falsa)

Ciclo While En este ciclo el cuerpo de instrucciones se ejecuta mientras una condición permanezca como verdadera, en el momento en que la condición se convierte en falsa el ciclo termina. Su formato general es: Cargar o inicializar variable de condición; While (condición) { Grupo cierto de instrucciones; Instrucción(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 instrucción se puede usar con diferentes modos de direccionamiento. MOV MOVS (MOVSB) (MOVSW) Instrucción MOV Propósito: Transferencia de datos entre celdas de memoria, registros y acumulador. Sintaxis: MOV Destino, Fuente Donde Destino es el lugar a donde se moverán los datos y fuente es el lugar donde se encuentran dichos datos. Los diferentes movimientos de datos permitidos para esta instrucción 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 instrucción MOV y los modos de direccionamiento. He aquí nuestra primera instrucción:

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 común a todas las instrucciones del 8086 que tengan dos operandos, lo cual creará más 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 había anteriormente en AX se pierde (puesto que un registro al fin y al cabo es un número, 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 sería más apropiado "copiar", porque no alteramos en absoluto el operando origen.

2.8 CAPTURA DE CADENAS CON FORMATO Permiten el movimiento, comparación o búsqueda rápida en bloques de datos:

• MOVC transferir carácter de una cadena • MOVW transferir palabra de una cadena • CMPC comparar carácter de una cadena • CMPW comparar palabra de una cadena • SCAC buscar carácter de una cadena

• SCAW buscar palabra de una cadena • LODC cargar carácter de una cadena • LODW cargar palabra de una cadena • STOC guardar carácter de una cadena • STOW guardar palabra de una cadena • REP repetir • CLD poner a 0 el indicador de dirección • STD poner a 1 el indicador de dirección

2.9 INSTRUCCIONES ARITMÉTICAS Instrucciones Aritméticas. Estas instrucciones son las que realiza directamente el 8086/8088

a. Grupo de adición:

• ADD suma • ADC suma con acarreo • AAA ajuste ASCII para la suma • DAA ajuste decimal para la suma b. Grupo de sustracción:

• SUB resta • SBB resta con acarreo negativo • AAS ajuste ASCII para la resta • DAS ajuste decimal para la resta c. Grupo de multiplicación:

• MUL multiplicación

• IMUL multiplicación entera • AAM ajuste ASCII para la multiplicación d. Grupo de división:

• DIV división • IDIV división entera • AAD ajuste ASCII para la división e. Conversiones:

• CBW pasar octeto a palabra • CWD pasar palabra a doble palabra • NEG negación

2.10 MANIPULACIÓN 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 (Operación nula). Sintaxis: NOP Indicadores: OF DF IF TF SF ZF AF PF CF Realiza una operación nula, es decir, el microprocesador decodifica la instrucción y pasa a la siguiente. Realmente se trata de la instrucción XCHG AX,AX. ESC (Salida a un coprocesador). Sintaxis: ESC código_operación, origen

Indicadores:

OF -

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF

Se utiliza en combinación 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 mnemónico ESC le siguen los códigos de operación apropiados para el coprocesador así como la instrucción y la dirección del operando necesario. Ejemplo: ESC 21,AX HLT (Parada hasta interrupción o reset). Sintaxis: HLT

Indicadores:

OF DF IF TF SF ZF AF PF CF El procesador se detiene hasta que se restaura el sistema o se recibe una interrupción. 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 método no es preciso y puede fallar con ciertos controladores de memoria.

LOCK (Bloquea los buses). Sintaxis: LOCK

Indicadores:

OF -

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF

Es una instrucción que se utiliza en aplicaciones de recursos compartidos para asegurar que no accede simultáneamente a la memoria más de un procesador. Cuando una instrucción va precedida por LOCK, el procesador bloquea inmediatamente el bus, introduciendo una señal por la patilla LOCK.

WAIT

(Espera).

Sintaxis: WAIT

Indicadores:

OF -

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF

Provoca la espera del procesador hasta que se detecta una señal en la patilla TEST. Ocurre, por ejemplo, cuando el coprocesador ha terminado una operación e indica su finalización. Suele preceder a ESC para sincronizar las acciones del procesador y coprocesador.

XLAT Sintaxis:

(traducción).

XLAT tabla Indicadores:

OF -

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF -

La instrucción XLAT tabla carga en el registro AL el contenido de la posición [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 almacén 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 dirección 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 contenía 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 dirección efectiva LDS o cargar el puntero en DS

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

LEA (carga dirección efectiva). Sintaxis: LEA destino, origen Indicadores:

OF -

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF

Transfiere el desplazamiento del operando fuente al operando destino. Otras instrucciones pueden a continuación 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 instrucción 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 más 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 más el registro SI. Esa sola instrucción es equivalente a estas dos:

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

Indicadores:

OF -

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF

Traslada un puntero de 32 bits (dirección completa de memoria compuesta por segmento y desplazamiento), al destino indicado y a DS. A partir de la dirección 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 instrucción, en DS: SI se hace referencia a la posición 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 instrucción es análoga a LDS, pero utilizando ES en lugar de D

2.12 INSTRUCCIONES LÓGICAS Son operaciones bit a bit que trabajan sobre octetos o palabras completas:

• NOT negación • AND producto lógico • OR suma lógica • XOR suma lógica exclusiva

2.13 DESPLAZAMIENTO Y ROTACIÓN Instrucciones de Desplazamiento Circular

RCL (Rotación a la izquierda con acarreo). Sintaxis:

RCL destino, contador

Indicadores:

OF x

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF x

Rotar a la izquierda los bits del operando destino junto con el indicador de acarreo CF el número de bits especificado en el segundo operando. Si el número 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 (Rotación a la derecha con acarreo).

Sintaxis:

RCR destino, contador

Indicadores:

OF x

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF x

Rotar a la derecha los bits del operando destino junto con el indicador de acarreo CF el número de bits especificado en el segundo operando. Si el número 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 (Rotación a la izquierda).

Sintaxis:

ROL destino, contador

Indicadores:

OF x

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF x

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

Ejemplos:

ROL

DX,CL ROL AH,1 ROR (Rotación a la derecha). Sintaxis: ROR destino, contador

Indicadores:

OF x

DF -

IF -

TF -

SF -

ZF -

AF -

PF -

CF x

Rota a la derecha los bits del operando destino el número de bits especificado en el segundo operando. Si el número de bits es 1 se puede poner directamente, en caso contrario debe ponerse a través de CL. Ejemplos:

ROR

CL,1 ROR AX,CL

2.14 OBTENCIÓN DE REPRESENTACION DE CADENAS DECIMAL Instrucciones de Desplazamiento Lineal

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

Indicadores:

OF DF IF TF SF ZF AF PF CF X x x ? x X Desplaza a la izquierda los bits del operando el número de bits especificado en el segundo operando que debe ser CL si es mayor que 1 los bits desplazados.

SAR (Desplazamiento aritmético a la derecha). Sintaxis: SAR destino, contador

Indicadores:

OF X

DF -

IF -

TF -

SF x

ZF x

AF ?

PF x

CF x

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

Ejemplos: SAR AX, CL SAR BP,1

SHR (Desplazamiento lógico a la derecha). Sintaxis: SHR destino, contador

Indicadores:

OF X

DF -

IF -

TF -

SF x

ZF x

AF ?

PF x

CF x

Desplaza a la derecha los bits del operando destino el número de los bits especificados en el segundo operando. Los bits de la izquierda se llena con cero. Si el número 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) están asignados a la misma dirección, por lo que existe un total de 64 Kb donde se mezclan código, datos y pila. Los programas de este tipo pueden convertirse a formato COM. SMALL: Se utiliza en aplicaciones pequeñas. Los segmentos de código y datos son diferentes y no se solapan. Por ello, hay 64 kb para código y otros 64 Kb a repartir entre datos y pila.

Segmentos Punteros

Modelo

Código

DatosPila Código

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 código (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 pequeños 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 también por los programadores de sistemas que no tienen paciencia para andar forzando continuamente el tipo de los punteros (para rebasar el límite de 64 Kb). Tanto los datos como el código pueden alcanzar el Mb, aunque no se admite que los datos estáticos ocupen más 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 automáticamente y se admiten datos estáticos de más de 64 Kb. Por otro, y gracias a esto último, es factible manipular bloques de datos de más de 64 Kb cada uno, ya que los segmentos de los punteros se actualizan correctamente. Sin embargo, este modelo es el más costoso en tiempo de ejecución de los programas.

Usando la pila Una sección 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 dirección 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 dirección del tope de la pila.

A diferencia de una pila creciendo hacia arriba, en las máquinas Intel crecen hacia abajo. En la Figura 2 muestra las capas de la pila después de la ejecución pushl $15.

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

La instrucción 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 instrucción 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 instrucción call foo pone la dirección de la instrucción después 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 instrucción cuya dirección se toma desde el tope de la pila. Obviamente el tope de la pila debe contener una dirección válida

2.16 OPERACIONES BASICAS SOBRE ARCHIVOS DE DISCO ENTRADA Y SALIDA Funciones que realiza Vamos a señalar las funciones que debe realizar un computador para ejecutar trabajos de entrada/salida: - Direccionamiento o selección del dispositivo que debe llevar a cabo la operación de E/S. - Transferencia de los datos entre el procesador y el dispositivo (en uno u otro sentido). - Sincronización y coordinación de las operaciones. Esta última función es necesaria debido a la deferencia de velocidades entre los dispositivos y la CPU y a la independencia que debe existir entre los periféricos y la CPU (por ejemplo, suelen tener relojes diferentes). e define una transferencia elemental de información como la transmisión de una sola unidad de información (normalmente un byte) entre el procesador y el periférico o viceversa. Para efectuar una transferencia elemental de información son precisas las siguientes funciones: - Establecimiento de una comunicación física entre el procesador y el periférico para la transmisión de la unidad de información.

- Control de los periféricos, en que se incluyen operaciones como prueba y modificación del estado del periférico. Para realizar estas funciones la CPU gestionará las líneas de control necesarias. Definiremos una operación 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 realización de una operación de E/S se deben efectuar las siguientes funciones:

- Recuento de las unidades de información transferidas (Normalmente bytes) para reconocer el fin de operación.

- Sincronización de velocidad entre la CPU y el periférico. - Detección de errores (e incluso corrección) mediante la utilización de los códigos necesarios (bits de paridad, códigos de redundancia cíclica, etc.) - Almacenamiento temporal de la información. Es más eficiente utilizar un buffer

temporal específico para las operaciones de E/S que utilizan programa.

el

área

de

datos

del

- Conversión de códigos, conversión serie/paralelo, etc. Dispositivos externos Una de las funciones básicas 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 función, el ordenador no sería operativo porque sus cálculos no serían visibles desde el exterior.

Existe una gran variedad de dispositivos que pueden comunicarse con un ordenador, desde los dispositivos clásicos (terminales, impresoras, discos, cintas, etc.) hasta convertidores A/D y D/A para aplicaciones de medida y control de procesos, De todos los posibles periféricos, 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 periféricos de almacenamiento también llamados memorias auxiliares o masivas.

La mayoría de los periféricos están compuestos por una parte mecánica y otra parte electrónica. Estas partes suelen separarse claramente para dar una mayor modularidad. A la componente electrónica del periférico se le suele denominar controlador del dispositivo o, también, adaptador del dispositivo. Si el dispositivo no tiene parte mecánica (como, por ejemplo, la pantalla de un terminal), el controlador estará formado por la parte digital del circuito. Frecuentemente los controladores de los dispositivos están alojados en una placa de circuito impreso diferenciada del resto del periférico. En este caso es bastante habitual que un mismo controlador pueda dar servicio a dispositivos de características similares.

El principal problema planteado por los periféricos es su gran variedad que también afecta a las velocidades de transmisión. Por tanto, el mayor inconveniente que encontramos en los periféricos es la diferencia entre sus velocidades de transmisión y la diferencia entre éstas y la velocidad de operación 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 parámetros y en el procedimiento no (esto es aplicable solo para el TASM, hay otros lenguajes de programación que si lo permiten). Al momento de ejecutarse la macro cada parámetro es sustituido por el nombre o valor especificado al momento de llamarla.

Podemos decir entonces que un procedimiento es una extensión de un determinado programa, mientras que la macro es un módulo con funciones específicas 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 instrucción 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_parámetros).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 serán pasadas desde la macro.

b) CUERPO: Contiene el código 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 válido que sea único. La directiva MACRO en la primer línea indica al ensamblador que las instrucciones que siguen, hasta ENDM (“fin de la macro”), son parte de la definición de la macro. La directiva ENDM termina la definición de la macro. Las instrucciones entre MACRO y ENDM comprenden el cuerpo de la definición 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 código cuantas veces desee dentro de su programa.

3.1.2 Externas. Una de las facilidades que ofrece el uso de las macros es la creación de bibliotecas, las cuales son grupos de macros que pueden ser incluidas en un programa desde un archivo diferente. La creación de estas bibliotecas es muy sencilla, únicamente tenemos que escribir un archivo con todas las macros que se necesitarán y guardarlo como archivo de texto. Para llamar a estas macros solo es necesario utilizar la instrucción Include , en la parte de nuestro programa donde escribiríamos normalmente las macros, esto es, al principio de nuestro programa (antes de la declaración del modelo de memoria). Suponiendo que se guardó el archivo de las macros con el nombre de MACROS.TXT la instrucción Include se utilizaría de la siguiente forma:

;Inicio del programa Include MACROS.TXT .MODEL SMALL .DATA ;Aqui van los datos .CODE Inicio: ;Aqui se inserta el código 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 ejecución de dichas instrucciones se devuelve el control a la siguiente línea a procesar del código que mando llamar al procedimiento. Un procedimiento se declara una sola vez en el código 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 fáciles 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 codificación más limpia y compacta, es decir el código fuente es más pequeño; también permiten el ahorro de memoria, esto es porque un mismo procedimiento puede ser llamado varias veces en el mismo programa y sólo requiere memoria una vez.

Los procedimientos tienen la desventaja de que reducen la velocidad de ejecución de los programas, esto se debe a la forma en que los procedimientos se ejecutan. A continuación 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 instrucción 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, también 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 módulos 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 públicos en el programa donde se encuentran y que sean llamados como externos en el programa donde serán usados. Cuenta con tres directivas de ensamble: .PUBLIC para declarar los procedimientos como públicos, .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 fácil crear bibliotecas de procedimientos y macros que puedan ser utilizados constantemente por los demás programas, ahorrando con ello tiempo de programación al reutilizar código fuente. Por ejemplo Este programa muestra la forma de utilizar procedimientos y datos externos en los programas por medio de las directivas de inclusión 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 ubicación de la memoria de un dispositivo digital o una computadora que está reservada para el almacenamiento temporal de información. Mientras los datos están 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 práctica, conocida como streaming, requiere de la utilización de un buffer para reducir el riesgo de que se corte la reproducción ante problemas en el ancho de banda.

Abarcando los aspectos más 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 número 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 más bien en bloques de bytes, debido a que el acceso a disco implica movimientos mecánicos además de que el acceso se da por sectores; en este proceso no intervienen el CPU, puesto que solo envía los comandos a la interface que maneja la unidad de disco y ésta es la que se encarga de leer o escribir información 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 información. Los datos se registran sobre la superficie del disco en una serie de circunferencias concéntricas llamadas pistas (track). Varias pistas, una por cada cara del disco (generalmente 2), componen un Clúster. Cada pista está dividida en porciones iguales llamadas sectores (unidad básica de almacenamiento en disco). El tamaño de un sector se mide en bytes, y depende de las características del disco. En esta sección se presentan 3 rutinas que permiten lectura y escritura absoluta de sectores, así como la determinación del espacio libre disponible en un disco.

Rutina _AbsoluteRead: Transfiere el contenido de uno ó más sectores del disco al buffer especificado, accesando directamente a los sectores lógicos. En caso de error, se enciende el bit de acarreo y AX contiene el código del error. Invocación push push push push SEG push

OFFSET 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 más sectores de disco, accesando directamente a los sectores lógicos. En caso de error, se enciende el bit de acarreo y AX contiene el código del error. Invocación: push push push push SEG 255" Delimitadores de texto también tienen un uso especial con el PARA Directiva, como se explica en "PARA Loops y parámetros de longitud variable," más adelante en este capítulo. Operador de Expansión El operador de expansión (%) 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 conversión de las expresiones numéricas en texto El operador de expansión puede convertir números a texto. Las fuerzas de operador

evaluación inmediata de una expresión constante y lo reemplaza con un valor de texto que consta de los dígitos del resultado. Los dígitos se generan en el radix actual (Decimal por omisión). Esta aplicación del operador de expansión es útil al definir una macro de texto, como las siguientes líneas muestran. Observe cómo se puede incluir expresiones con paréntesis para que sean más legibles: un TEXTEQU ; a = "3 + 4" b TEXTEQU% 3 + 4 ; b = "7" c TEXTEQU% (3 + 4) ; c = "7" Al asignar macros de texto, puede utilizar equipara numéricos en la constante expresiones, pero no las macros de texto: num EQU 4 ; num = 4 numstr TEXTEQU ; numstr = un TEXTEQU% 3 + num ; A = b

TEXTEQU% 3 + numstr ; b = El operador de expansión le da flexibilidad a la hora de pasar argumentos a macros. Te permite pasar un valor calculado en lugar del texto literal de una expresión. El siguiente ejemplo ilustra mediante la definición de una macro trabajo Arg MACRO mov ax, arg * 4 ENDM Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 235 de 11 Impreso: 10/02/00 16:22

Página 12 236 Guía del programador que acepta diferentes argumentos: trabajo 2+3 ; Pasa "2 + 3" ; Código: mov ax, 2 + (3 * 4) trabajo

2% + 3 ; Pasa 5 ; Código: 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 expansión. Los paréntesis dentro de la macro puede forzar la evaluación en un orden deseado: trabajo Arg MACRO mov ax, (arg) * 4 ENDM trabajar 2 + 3 ; Código: mov ax, (2 + 3) * 4 trabajo% 2 + 3 ; Código: mov ax, (5) * 4 Varios otros usos para el operador de la expansión se revisan en "Valores que regresan

con funciones de macro ", más adelante en este capítulo. Operador de expansión como primer carácter de una línea El operador de expansión tiene un significado diferente cuando se utiliza como el primer carácter en una línea. En este caso, se indica al ensamblador para expandir las macros de texto y funciones de macro que encuentre en el resto de la línea. Esta característica hace posible el uso de macros de texto con directivas como ECHO, TÍTULO, y el subtítulo, que toman un argumento que consiste en un texto único valor. Por ejemplo, ECHO despliega su argumento en el dispositivo de salida estándar durante el montaje. Tal expansión puede ser útil para las macros de depuración 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 expresión, esta línea se hace eco de ello: Bytes por cada elemento:% (array SIZEOF / array LENGTHOF) Sin embargo, se puede lograr el resultado deseado mediante la asignación del texto de la expresión a una macro de texto y utilizando el operador de expansión en el principio de la línea de fuerza de expansión de la macro de texto. Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 236 de 12 Impreso: 10/02/00 16:22

Página 13 Capítulo 9 Uso de macros 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 sólo poner el% en la a partir de la primera línea de eco, porque% se expande sólo las macros de texto, no equipara numéricos o expresiones constantes. Aquí hay más ejemplos de que el operador de expansión en el inicio de una línea: ; Asumir memmod, lang, y os especificados con la opción / D % SUBTÍTULO Modelo: memmod Idioma: lang Sistema operativo: OS ; Supongamos num definido anteriormente tnum TEXTEQU% num %. ERRE num LE 255, 255> Operador Sustitución Las referencias a un parámetro dentro de una macro a veces puede ser ambigua. En tales casos, el ensamblador no pueden ampliar el argumento de los que había previsto. La operador de sustitución (&) le permite identificar de forma inequívoca cualquier parámetro dentro de un macro. Como ejemplo, considere la siguiente macro: num MACRO errgen, msg Errnum PÚBLICA BYTE errnum "num Error: msg" ENDM Esta macro está abierto a varias interpretaciones: 

Es errnum una palabra distinta o la palabra errar junto al parámetro num ?  Debería 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 interpretación más literal. Es decir, se golosinas errnum como una palabra distinta, y num y msg partes literales de la cadena. El operador de sustitución puede obligar a diferentes interpretaciones. Si volvemos a escribir la macro con el operador &, que se ve así: num MACRO errgen, msg Err PÚBLICO & num

errar & num BYTE "Error & num: & msg" ENDM Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 237 de 13 de Impreso: 10/02/00 16:22

Página 14 238 Guía del programador Cuando se llama con los siguientes argumentos, errgen 5, duro> declaraciones ENDM El texto debe ir entre paréntesis angulares. El siguiente ejemplo ilustra FORC : FORC arg, BYTE '& arg';; Asignar letra mayúscula BYTE '& arg' + 20h;; Asignar letra minúscula

BYTE '& arg' - 40h;; Asignar ordinal de la carta ENDM Observe que el operador de sustitución 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 análisis de tareas. Una frase larga puede ser examinado carácter por carácter. Cada carácter es entonces o bien desecha o pega en un token de cadena, dependiendo de si se trata de un carácter separador. Las nuevas funciones de macro predefinidas y directivas de procesamiento de series que se tratan en la siguiente sección son generalmente más eficiente para estas tareas. Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 245 de 21 de Impreso: 10/02/00 16:22

Página 23 246 Guía del programador Directivas de Cuerda y funciones predefinidas

El ensamblador proporciona cuatro directivas para la manipulación de texto: Directiva Descripción SUBSTR Asigna parte de cadena en un nuevo símbolo. INSTR Las búsquedas de una cadena dentro de otra. SIZESTR Determina el tamaño de una cadena. CATSTR Concatena una o más cadenas de una sola cadena. Estas directivas asignan un valor a un tratamiento que una macro de texto o equate numérico. Para ejemplo, las siguientes líneas num = 7 newstr CATSTR ,% num, ,% 3 + num; "3 + 7 = 10" asignar la cadena "3 + 7 = 10" a newstr . CATSTR y SUBSTR asignación texto de la misma forma que el TEXTEQU Directiva. SIZESTR y INSTR asignación un número en la misma forma que el = operador. Las cuatro directivas de cuerda toman sólo texto valora como argumentos. Utilice el operador de expansión ( % ) cuando se necesita asegurarse de que las constantes y equipara numéricos se expanden para texto, como se muestra en la precedente líneas.

Cada una de las directivas de cuerda tiene una función macro predefinida correspondiente Versión: @ 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 paréntesis. Funciones de macro devuelven valores de texto y pueden aparecer en cualquier contexto donde se espera que el texto. En la siguiente sección, "Devolver valores con Macro Funciones ", dice cómo escribir sus propias funciones de macro. La siguiente ejemplo es equivalente a la anterior CATSTR ejemplo: num = 7 newstr TEXTEQU @ CatStr (,% num, ,% 3 + num) Funciones de macro son a menudo más conveniente que sus contrapartes directiva porque se puede utilizar una función de macro como argumento para una directiva de cadena o de otra función macro. Directivas de cuerda A diferencia, la función macro predefinida nombres distinguen entre mayúsculas y minúsculas cuando se utiliza la opción de línea de comandos / Cp. Cada directiva de cadena y función predefinida actúa 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 expresión constante precedida por % (como en % constexpr ). Consulte el Apéndice B, "gramática de BNF," para obtener una lista de tipos que elemento_texto pueden representar. Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux

Guardado por: Ruth L Silverio Revisión #: 86 Página: 246 de 22 de Impreso: 10/02/00 16:22

Página 24 Capítulo 9 Uso de macros 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 símbolo nombrar . El inicio parámetro especifica la posición 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 carácter. INSTR nombrar INSTR [[ inicio ,]] string , substring @ InStr ( [[ empezar ]], cadena , subcadena ) El INSTR directiva busca un determinado cadena para una aparición de subcadena y le asigna su número de posición para el nombre . La búsqueda distingue entre mayúsculas y minúsculas. El comienzo parámetro es la posición en la cadena para iniciar la búsqueda de subcadena . Si no lo hace especificar inicio , que se supone que es la posición 1, el principio de la cadena. Si INSTR

no encuentra subcadena , asigna la posición 0 a nombre . El INSTR Directiva asigna el valor de posición de nombre como si fuera un valor numérico equiparar. En contraste, el @ InStr devuelve el valor como una cadena de dígitos en el radix actual. El @ InStr función 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 función, sino una función en blanco argumento todavía debe tener una coma. Por ejemplo, pos INSTR , es el mismo que pos = @ InStr (, , ) También puede asignar el valor de retorno de una macro de texto, así: Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 247 de 23 de Impreso: 10/02/00 16:22

Página 25 248 Guía del programador strpos TEXTEQU @ InStr (, , ) SIZESTR nombrar SIZESTR cadena

@ SizeSt r ( cadena ) El SIZESTR Directiva asigna el número de caracteres en la cadena de nombre . Un cadena vacía devuelve una longitud de cero. El SIZESTR Directiva asigna el tamaño valor a un nombre como si se tratara de un EQUATE numérico. Los @ SizeStr función devuelve el valor como una cadena de dígitos de la raíz 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 técnicamente un sinónimo 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: Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 248 de 24 Impreso: 10/02/00 16:22

Página 26 Capítulo 9 Uso de macros 249 ; SaveRegs - Macro para generar una instrucción de inserción para cada

; inscribirse en la lista de argumentos. Guarda cada nombre de registro en el ; macro texto regpushed. regpushed TEXTEQU ;; Inicializar cadena vacía SaveRegs regs MACRO: vararg Reg LOCAL PARA reg, ;; Empuje cada registro empuje reg ;; y añadirlo a la lista regpushed CATSTR , , regpushed ENDM ;; Pele última coma CATSTR regpushed ;; Marque el extremo con> ENDM ; RestoreRegs - Macro para generar una instrucción 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 cómo 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 sólo 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 ampliación versiones de estos mismos dos macros. Devolver valores con funciones de macro Una función macro es un grupo con nombre de declaraciones que devuelve un valor. ¿Cuándo llamar a una función macro, debe incluir la lista de parámetros entre paréntesis, incluso si la lista está vacía. La función siempre devuelve el texto. MASM 6.1 ofrece varias funciones de macro predefinidos para las tareas comunes. La macros predefinidas incluyen @ Environ (ver página 10) y las funciones de cadena @ SizeStr , @ CatSt r , @ substr , y @ InStr (discutido en el párrafo anterior sección). Se definen las funciones de macro exactamente de la misma manera que los procedimientos de macro,

excepto que una función de macro siempre devuelve un valor a través de la EXITM Directiva. He aquí un ejemplo: Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 249 de 25 Impreso: 10/02/00 16:22

Página 27 250 Guía del programador Símbolo macro definida: REQ Símbolo IFDEF EXITM ;; Verdadero ELSE ENDM EXITM ;; Falso ENDIF Esta macro funciona como el definido operador en el lenguaje C. Usted puede utilizarlo para probar el estado definido de varios símbolos diferentes con una sola instrucción, 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 dígitos, pero el SI declaración evalúa valores o expresiones numéricas. No hay conflicto, porque el ensamblador ve el valor devuelto por la función macro exactamente como si el usuario había 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 función macro. Una función macro debe convertir primero un valor numérico como tales una constante, un valor numérico equivale, o el resultado de una expresión-antes numérico devolverlo. La función macro puede utilizar las escuadras o la expansión operador ( % ) para convertir los números a texto. La DEFINIDO macro, por ejemplo, podría haber regresado de su valor como EXITM% -1 He aquí otro ejemplo de una función de macro que utiliza el MIENTRAS directiva para calcular los factoriales: Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 250 de 26 de Impreso: 10/02/00 16:22

Página 28 Capítulo 9 Uso de macros 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 cálculo se cambia a una cadena de texto con la expansión operador ( % ). La factorial macro puede definir los datos, como se muestra aquí: var WORD factorial (4) Esta sentencia inicializa var con el número 24 (el factorial de 4). Uso de las funciones de macro con listas de parámetros de longitud variable Usted puede utilizar el PARA directiva para manejar parámetros de la macro con la vararg atribuir. "PARA Loops y parámetros de longitud variable" en la página 242, explica

cómo hacer esto en casos simples donde los parámetros de las variables que se manipulan secuencialmente, de principio a fin. Sin embargo, a veces puede que tenga que procesar los parámetros en orden inverso o de forma no secuencial. Funciones de macro hacen estos técnicas posibles. Por ejemplo, la siguiente función macro determina el número de argumentos en un vararg parámetro: @ ArgCount arglist MACRO: vararg Recuento LOCAL count = 0 PARA arg, count = count + 1;; Cuente los argumentos ENDM ENDM EXITM% count Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 251 de 27 de Impreso: 10/02/00 16:22

Página 29 252 Guía del programador Usted puede usar

@ ArgCoun t dentro de una macro que tiene un vararg parámetro, como se muestra aquí: trabajar args MACRO: vararg ECHO% Número de argumentos es: @ ArgCount (args) ENDM Otra tarea útil podría ser la de seleccionar un elemento de una lista de argumentos utilizando un índice para indicar el artículo. 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, count = count + 1 Si el índice EQ conteo;; Artículo se encuentra RetStr TEXTEQU ;; Establecer cadena devuelta EXITM ;; y salida IF ENDIF ENDM ENDM EXITM RetStr ;; Salir de la función Usted puede usar

@ Arg I de esta manera: trabajar args MACRO: vararg % 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, txt CATSTR , , txt;; Pegue cada en la lista ENDM ;; Retire la terminación comas ENDM txt SUBSTR txt, 1, @ SizeStr (% txt) - 1 txt CATSTR ¡;; Añadir paréntesis angulares EXITM txt Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio

Página 30 Revisión #: 86 Página: 252 de 28 de

Impreso: 10/02/00 16:22

Página 31 Capítulo 9 Uso de macros 253 He aquí un ejemplo que muestra @ ArgRe v en uso: trabajar args MACRO: vararg % PARA arg, @ ArgRev ();; Proceso en el orden inverso ECHO arg ENDM ENDM Estas tres funciones de macro aparecen en el MACROS.INC archivo de inclusión, que se encuentra en uno de los discos de distribución MASM. Operador de Expansión de Funciones de Macro Esta lista se resume el comportamiento del operador de expansión ( % ) con macro funciones.  Si una función 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 función macro, no se ampliará aún más.  Si utiliza una llamada a una función macro como argumento para otra función macro llamar, un % no es necesario.  Si una función macro es llamada dentro de paréntesis angulares y está precedida por % , se

se ampliará. Técnicas Avanzadas Macro El concepto de sustitución de nombres de macro con el texto macro predefinida es simple en teoría, pero tiene muchas implicaciones y complicaciones. Aquí está un breve resumen de algunas técnicas avanzadas que puede utilizar en macros. Definición de macros dentro de Macros Las macros se pueden definir otras macros, una técnica llamada "macros de anidación." MASM expande las macros, ya que se encuentra con ellas, por lo que las macros anidadas siempre se procesan con el fin de anidación. No se puede hacer referencia a una macro anidada directamente en su programa, ya que el ensamblador comienza la expansión de la macro exterior. En efecto, un anidado macro es local a la macro que lo define. Sólo la cantidad de memoria disponible limita el número de macros de un programa pueden anidar. Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 253 de 29 de Impreso: 10/02/00 16:22

Página 32 254 Guía del programador El siguiente ejemplo muestra cómo una macro puede definir otro. La

macro toma como argumento el nombre de un turno o de operación de rotación, a continuación, crea otra macro que simplifica la instrucción para 8088/86 procesadores. desplaza opname MACRO ;; Macro genera macros opname & s Operando MACRO: REQ, gira: = SI LE gira 2 ;; Uno a la vez es más rápido REPEAT girar;; para 2 o menos operando opname, 1 ENDM ENDM ENDM ELSE ;; Uso de CL es más rápido para mov Cl, gira;; más de 2 operando opname, cl ENDIF Recordemos que el procesador 8086 sólo permite 1 o CL como operando de turno y girar instrucciones. En expansión turnos genera una macro para el turno instrucción que utiliza cualquiera de los operandos es más eficiente. Se crea la totalidad serie de macros, uno para cada operación 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 continuación, 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 código mediante la comprobación para el tipo de discusión con la OPATTR operador. OPATTR devuelve una sola palabra constante que indica el tipo y el alcance de una expresión, como este: OPATTR expresión Si la expresión no es válido 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. Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 254 de 30 Impreso: 10/02/00 16:22

Página 33 Capítulo 9 Uso de macros 255 OPATTR sirve como una versión mejorada del TIPO. operador, que devuelve sólo el byte bajo (bits 0-7) se muestra en la tabla. Bits 11-15 del valor de retorno no están definidos. Poco Ajuste Si la expresión 0

Hace referencia a una etiqueta de código 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 símbolos y es sin error 6 Es en relación 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-básico Una macro puede utilizar OPATTR para determinar si un argumento es una constante, un registro, o un operando de memoria. Con esta información, la macro puede condicionalmente generar el código más eficiente en función de tipo de argumento. Por ejemplo, dado un argumento constante, una macro puede probarlo de 0. Dependiendo el valor del argumento, el código puede seleccionar el método más eficaz para cargar el valorar en un registro: IF CONST mov bx, CONST ; Si CONST> 0, se mueven en BX ELSE sub bx, bx ; Más eficiente si CONST = 0 ENDIF Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio

Revisión #: 86 Página: 255 de 31 Impreso: 10/02/00 16:22

Página 34 256 Guía del programador El segundo método es más rápido 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 técnicas 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 ENDM ENDIF Una macro también puede generar código diferente dependiendo de la asamblea medio ambiente. La macro de texto predefinido @ Cpu devuelve una bandera para procesador escriba. El siguiente ejemplo utiliza la variación constante más eficiente de la PUSH instrucción si el procesador es un 80186 o superior. SI @ Cp U y 00000010y pushc op MACRO;; 80.186 o más 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 código, utilizando pushc

reúne más rápido debido a que el medio ambiente se comprueba una sola vez. Nombre del archivo: LMAPGC09.DOC Pro yecto: Plantilla: MSGRIDA1.DOT Autor: rick Debroux Guardado por: Ruth L Silverio Revisión #: 86 Página: 256 de 32 Impreso: 10/02/00 16:22

Página 35 Capítulo 9 Uso de macros 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: Opción Descripción ASUME Guarda registro de segmento información RADIX Guarda actual default radix LISTADO Guarda la lista y

CREF información 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 técnica importante para el manejo de argumentos variables. MASM 6.1 mangos argumentos variables mucho más limpiamente con la PARA Directiva y el Vararg atributo, como se describe en "Bucles FOR y de longitud variable Parámetros ", anteriormente en este capítulo. 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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- *

.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 * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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,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) mov eax, incrementar 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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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 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 -> ") 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,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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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 mov DX,AX

;shift low to high ;high /high/ low in EDX ;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 EAX,EDX

;mov in all reg ;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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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=11 && eax=28 && eax=70 && eax=80 && eax=90 print chr$("EXCELENTE ",10) .elseif eaxprod print chr$("La calificacion 1 es mayor al promedio",10) .endif mov EDX,num2 .if EDX>prod print chr$("La calificacion 2 es mayor al promedio",10) .endif mov EDX,num3 .if EDX>prod print chr$("La calificacion 3 es mayor al promedio",10) .endif mov EDX,num4 .if EDX>prod print chr$("La calificacion 4 es mayor al promedio",10) .endif mov EDX,num5 .if EDX>prod print chr$("La calificacion 5 es mayor al promedio",10) .endif

ret main endp ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ end start

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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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: ")) mov num2,sval(input("Introducir numero 2: ")) 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 mov num1,sval(input("Introducir numero 1: ")) print chr$("MENOS",10) mov num2,sval(input("Introducir numero 2: ")) xor EAX,EAX mov EAX,num1 sub EAX,num2 mov resultado,EAX print chr$(7,"La resta es: ") print str$(resultado) 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 str$(resultado) print chr$(10) .endif .if menu==4 mov num1,sval(input("Introducir numero 1: ")) print chr$("ENTRE",10) mov num2,sval(input("Introducir numero 2: ")) xor EDX,EDX mov EAX,num1 mov EBX,num2 div EBX mov resultado,EAX print chr$(7,"La division es: ") print str$(resultado) print chr$(10) .endif .endw ret main endp ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ end start

CONTADOR IMPRIME HASTA UN NUMERO DADO

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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 push push push SEG push OFFSET 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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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 chr$(7,"El numero: ") print str$(num) print chr$(7," es REPROBATORIO.") print chr$(10) ret main endp ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ end start

SUMA DE NUMERO PARES

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ comment * ----------------------------------------------------Build this console app with "MAKEIT.BAT" on the PROJECT menu. ----------------------------------------------------- * .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 chr$(7,"Calificacion arriva del promedio: ") print str$(num2) print chr$(10) .endif .if num3>ebx print chr$(7,"Calificacion arriva del promedio: ") print str$(num3) print chr$(10) .endif .if num4 >ebx print chr$(7,"Calificacion arriva del promedio: ") print str$(num4) print chr$(10) .endif .if num5>ebx print chr$(7,"Calificacion arriva del promedio: ") print str$(num5) print chr$(10) .endif

ret main endp ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ end start

CICLO DECREMENTAL

; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ include \masm32\include\masm32rt.inc ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ .data? .data num dd 0 .code start: ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ call main inkey exit ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ main proc cls mov num,10 ciclo: print chr$(7,"El numero: ") print str$(num) print chr$(10) dec num cmp num,0 jnz ciclo ret main endp ; ¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤¤ end start