Está en la página 1de 27

5.4. - MACROS.

Cuando un conjunto de instrucciones en ensamblador aparecen frecuentemente repetidas a lo largo de un listado, es conveniente agruparlas bajo un nombre simblico que las sustituir en aquellos puntos donde aparezcan. Esta es la misin de las macros; por el hecho de soportarlas el ensamblador eleva su categora a la de macroensamblador, al ser las macros una herramienta muy cotizada por los programadores.

No conviene confundir las macros con subrutinas: es estas ltimas, el conjunto de instrucciones aparece una sola vez en todo el programa y luego se invoca con CALL. Sin embargo, cada vez que se referencia a una macro, el cdigo que sta representa se expande en el programa definitivo, duplicndose tantas veces como se use la macro. Por ello, aquellas tareas que puedan ser realizadas con subrutinas siempre ser ms conveniente realizarlas con las mismas, con objeto de economizar memoria. Es cierto que las macros son algo ms rpidas que las subrutinas (se ahorra un CALL y un RET) pero la diferencia es tan mnima que en la prctica es despreciable en el 99,99% de los casos. Por ello, es absurdo e irracional realizar ciertas tareas con macros que pueden ser desarrolladas mucho ms eficientemente con subrutinas: es una pena que en muchos manuales de ensamblador an se hable de macros para realizar operaciones sobre cadenas de caracteres, que generaran programas gigantescos con menos de un 1% de velocidad adicional. 5.4.1. - DEFINICIN Y BORRADO DE LAS MACROS. La macro se define por medio de la directiva MACRO. Es necesario definir la macro antes de utilizarla. Una macro puede llamar a otra. Con frecuencia, las macros se colocan juntas en un fichero independiente y luego se mezclan en el programa principal con la directiva INCLUDE:
IF1 INCLUDE fichero.ext ENDIF

La sentencia IF1 asegura que el ensamblador lea el fichero fuente de las macros slo en la primera pasada, para acelerar el ensamblaje y evitar que aparezcan en el listado (generado en la segunda fase). Conviene hacer hincapi en que la definicin de la macro no consume memoria, por lo que en la prctica es indiferente declarar cientos que ninguna macro:
nombre_simblico MACRO [parmetros] ... ... ; instrucciones de la macro ENDM

El nombre simblico es el que permitir en adelante hacer referencia a la macro, y se construye casi con las mismas reglas que los nombres de las variables y dems smbolos. La macro puede contener parmetros de manera opcional. A continuacin vienen las

instrucciones que engloba y, finalmente, la directiva ENDM seala el final de la macro. No se debe repetir el nombre simblico junto a la directiva ENDM, ello provocara un error un tanto curioso y extrao por parte del ensamblador (algo as como Fin del fichero fuente inesperado, falta directiva END), al menos con MASM 5.0 y TASM 2.0. En realidad, y a diferencia de lo que sucede con los dems smbolos, el nombre de una macro puede coincidir con el de una instruccin mquina o una directiva del ensamblador: a partir de ese momento, la instruccin o directiva machacada pierde su significado original. El ensamblador dar adems un aviso de advertencia si se emplea una instruccin o directiva como nombre de macro, aunque tolerar la operacin. Normalmente se las asignar nombres normales, como a las variables. Sin embargo, si alguna vez se redefiniera una instruccin mquina o directiva, para restaurar el significado original del smbolo, la macro puede ser borrada -o simplemente porque ya no va a ser usada a partir de cierto punto del listado, y as ya no consumir espacio en las tablas de macros que mantiene en memoria el ensamblador al ensamblar-. No es necesario borrar las macros antes de redefinirlas. Para borrarlas, la sintaxis es la siguiente: PURGE nombre_simblico[,nombre_simblico,...] 5.4.2. - EJEMPLO DE UNA MACRO SENCILLA. Desde el 286 existe una instruccin muy cmoda que introduce en la pila 8 registros, y otra que los saca (PUSHA y POPA). Quien est acostumbrado a emplearlas, puede crear unas macros que simulen estas instrucciones en los 8086:
SUPERPUSH MACRO PUSH PUSH PUSH PUSH PUSH PUSH PUSH PUSH ENDM AX CX DX BX SP BP SI DI

La creacin de SUPERPOP es anloga, sacando los registros en orden inverso. El orden elegido no es por capricho y se corresponde con el de la instruccin PUSHA original, para compatibilizar. A partir de la definicin de esta macro, tenemos a nuestra disposicin una nueva instruccin mquina (SUPERPUSH) que puede ser usada con libertad dentro de los programas. 5.4.3. - PARMETROS FORMALES Y PARMETROS ACTUALES. Para quien no haya tenido relacin previa con algn lenguaje estructurado de alto nivel, har un breve comentario acerca de lo que son los parmetros formales y actuales en una macro, similar aqu a los procedimientos de los lenguajes de alto nivel.

Cuando se llama a una macro se le pueden pasar opcionalmente un cierto nmero de parmetros de cierto tipo. Estos parmetros se denominan parmetros actuales. En la definicin de la macro, dichos parmetros aparecen asociados a ciertos nombres arbitrarios, cuya nica misin es permitir distinguir unos parmetros de otros e indicar en qu orden son entregados: son los parmetros formales. Cuando el ensamblador expanda la macro al ensamblar, los parmetros formales sern sustituidos por sus correspondientes parmetros actuales. Considerar el siguiente ejemplo:
SUMAR MACRO a,b,total PUSH AX MOV AX,a ADD AX,b MOV total,AX POP AX ENDM .... SUMAR positivos, negativos, total

En el ejemplo, a, b y total son los parmetros formales y positivos, negativos y total son los parmetros actuales. Tanto a como b pueden ser variables, etiquetas, etc. en otro punto del programa; sin embargo, dentro de la macro, se comportan de manera independiente. El parmetro formal total ha coincidido en el ejemplo y por casualidad con su correspondiente actual. El cdigo que genera el ensamblador al expandir la macro ser el siguiente:
PUSH MOV ADD MOV POP AX AX,positivos AX,negativos total,AX AX

Las instrucciones PUSH y POP sirven para no alterar el valor de AX y conseguir que la macro se comporte como una caja negra; no es necesario que esto sea as pero es una buena costumbre de programacin para evitar que los programas hagan cosas raras. En general, las macros de este tipo no deberan alterar los registros y, si los cambian, hay que tener muy claro cules. Si se indican ms parmetros de los que una macro necesita, se ignorarn los restantes. En cambio, si faltan, el MASM asumir que son nulos (0) y dar un mensaje de advertencia, el TASM es algo ms rgido y podra dar un error. En general, se trata de situaciones atpicas que deben ser evitadas. Tambin puede darse el caso de que no sea posible expandir la macro. En el ejemplo, no hubiera sido posible ejecutar SUMAR AX,BX,DL porque DL es de 8 bits y la instruccin MOV DL,AX sera ilegal. 5.4.4. - ETIQUETAS DENTRO DE MACROS. VARIABLES LOCALES. Son necesarias normalmente para los saltos condicionales que contengan las macros ms

complejas. Si se pone una etiqueta a donde saltar, la macro slo podra ser empleada una vez en todo el programa para evitar que dicha etiqueta aparezca duplicada. La solucin est en emplear la directiva LOCAL que ha de ir colocada justo despus de la directiva MACRO:
MINIMO MACRO LOCAL MOV CMP JB MOV MOV ENDM dato1, dato2, ya_esta AX,dato1 AX,dato2 ya_esta AX,dato2 resultado,AX resultado ; es dato1 el menor? ; s ; no, es dato2

ya_esta:

En el ejemplo, al invocar la macro dos veces el ensamblador no generar la etiqueta ya_esta sino las etiquetas ??0000, ??0001, ... y as sucesivamente. La directiva LOCAL no slo es til para los saltos condicionales en las macros, tambin permite declarar variables internas a los mismos. Se puede indicar un nmero casi indefinido de etiquetas con la directiva LOCAL, separndolas por comas. 5.4.5. - OPERADORES DE MACROS. * Operador ;; Indica que lo que viene a continuacin es un comentario que no debe aparecer al expansionar la macro. Cuando al ensamblar se genera un listado del programa, las macros suelen aparecer expandidas en los puntos en que se invocan; sin embargo slo aparecern los comentarios normales que comiencen por (;). Los comentarios relacionados con el funcionamiento interno de la macro deberan ir con (;;), los relativos al uso y sintaxis de la misma con (;). Esto es adems conveniente porque durante el ensamblaje son mantenidos en memoria los comentarios de macros (no los del resto del programa) que comienzan por (;), y no conviene desperdiciar memoria... * Operador & Utilizado para concatenar texto o smbolos. Es necesario para lograr que el ensamblador sustituya un parmetro dentro de una cadena de caracteres o como parte de un smbolo:
SALUDO MACRO MOV etiqueta&c: CALL ENDM c AL,"&c" imprimir

Al ejecutar SALUDO A se producir la siguiente expansin:


etiquetaA: MOV CALL AL,"A" imprimir

Si no se hubiera colocado el & se hubiera expandido como MOV AL,"c" Cuando se utilizan estructuras repetitivas REPT, IRP o IRPC (que se vern ms

adelante) existe un problema adicional al intentar crear etiquetas, ya que el ensamblador se come un & al hacer la primera sustitucin, generando la misma etiqueta a menos que se duplique el operador &:
MEMORIA x&i MACRO IRP DB ENDM ENDM x i, <1, 2> i

Si se invoca MEMORIA ET se produce el error de "etiqueta ETi repetida", que se puede salvar aadiendo tantos '&' como niveles de anidamiento halla en las estructuras repetitivas empleadas, como se ejemplifica a continuacin:
MEMORIA x&&i MACRO IRP DB ENDM ENDM DB 1 DB 2 x i, <1, 2> i

Lo que con MEMORIA ET generar correctamente las lneas:


ET1 ET2

* Operador ! o <> Empleado para indicar que el carcter que viene a continuacin debe ser interpretado literalmente y no como un smbolo. Por ello, !; es equivalente a <;>. * Operador % Convierte la expresin que le sigue -generalmente un smbolo- a un nmero; la expresin debe ser una constante (no relocalizable). Slo se emplea en los argumentos de macros. Dada la macro siguiente:
PSUM MACRO %OUT ENDM mensaje, suma * mensaje, suma *

(Evidentemente, el % que precede a OUT forma parte de la directiva y no se trata del % operador que estamos tratando) Supuesta la existencia de estos smbolos:
SIM1 SIM2 PSUM EQU EQU 120 500

Invocando la macro con las siguientes condiciones:


< SIM1 + SIM2 = >, (SIM1+SIM2) %OUT * SIM1 + SIM2 = (SIM1+SIM2) *

Se produce la siguiente expansin: Sin embargo, invocando la macro de la siguiente manera (con %):
PSUM < SIM1 + SIM2 = >, %(SIM1+SIM2)

Se produce la expansin deseada:


%OUT * SIM1 + SIM2 = 620 *

5.4.6. - DIRECTIVAS TILES PARA MACROS. Estas directivas pueden ser empleadas tambin sin las macros, aumentando la comodidad de la programacin, aunque abundan especialmente dentro de las macros. * REPT veces ... ENDM (Repeat) Permite repetir cierto nmero de veces una secuencia de instrucciones. El bloque de instrucciones se delimita con ENDM (no confundirlo con el final de una macro). Por ejemplo:
REPT OUT ENDM OUT OUT 2 DX,AL

Esta secuencia se transformar, al ensamblar, en lo siguiente:


DX,AL DX,AL

Empleando smbolos definidos con (=) y apoyndose adems en las macros se puede llegar a crear pseudo-instrucciones muy potentes:
SUCESION MACRO n num = 0 REPT n DB num num = num + 1 ENDM ENDM DB DB DB 0 1 2

; fin de REPT ; fin de macro

La sentencia SUCESION 3 provocar la siguiente expansin:

* IRP simbolo_control, <arg1, arg2, ..., arg_n> ... ENDM (Indefinite repeat) Es relativamente similar a la instruccin FOR de los lenguajes de alto nivel. Los ngulos (<) y (>) son obligatorios. El smbolo de control va tomando sucesivamente los valores (no necesariamente numricos) arg1, arg2, ... y recorre en cada pasada todo el bloque de instrucciones hasta alcanzar el ENDM (no confundirlo con fin de macro) sustituyendo simbolo_control por esos valores en todos los lugares en que aparece:
IRP DB ENDM DB DB DB i, <1,2,3> 0, i, i*i

Al expansionarse, este conjunto de instrucciones se convierte en lo siguiente:


0, 1, 1 0, 2, 4 0, 3, 9

Nota: Todo lo encerrado entre los ngulos se considera un nico parmetro. Un (;) dentro de los ngulos no se interpreta como el inicio de un comentario sino como un elemento ms. Por otra parte, al emplear macros anidadas, deben indicarse tantos smbolos angulares '<' y '>' consecutivos como niveles de anidamiento existan. Lgicamente, dentro de una macro tambin resulta bastante til la estructura IRP:
TETRAOUT MACRO PUSH PUSH MOV IRP MOV OUT ENDM POP POP ENDM PUSH PUSH MOV MOV OUT MOV OUT MOV OUT MOV OUT POP POP p1, p2, p3, p4, valor AX DX AL,valor cn, <p1, p2, p3, p4> DX, cn DX, AL ; fin de IRP DX AX ; fin de macro AX DX AL, 17 DX, 318h DX, AL DX, 1C9h DX, AL DX, 2D1h DX, AL DX, 1A4h DX,AL DX AX

Al ejecutar TETRAOUT 318h, 1C9h, 2D1h, 1A4h, 17 se obtendr:

Cuando se pasan listas como parmetros hay que encerrarlas entre '<' y '>' al llamar, para no confundirlas con elementos independientes. Por ejemplo, supuesta la macro INCD:
INCD MACRO IRP INC ENDM DEC ENDM lista, p i, <lista> i ; fin de IRP p ; fin de macro

Se comprende la necesidad de utilizar los ngulos: INCD AX, BX, CX, DX se expandir:
INC DEC INC INC INC DEC AX BX ; CX y DX se ignoran (4 parmetros) AX BX CX DX

INCD <AX, BX, CX>, DX se expandir:

; (2 parmetros)

* IRPC simbolo_control, <c1c2 ... cn> ... ENDM (Indefinite repeat character)

Esta directiva es similar a la anterior, con una salvedad: los elementos situados entre los ngulos (<) y (>) -ahora opcionales, por cierto- son caracteres ASCII y no van separados por comas:
IRPC DB ENDM DB DB DB INICIALIZA MACRO IRPC DB ENDM ENDM DB DB DB DB i, <813> i

El bloque anterior generar al expandirse:


8 1 3 a, b, c, d iter, <&a&b&c&d> iter ; fin de IRPC ; fin de macro 7 1 4 0

Ejemplo de utilizacin dentro de una macro (en combinacin con el operador &):

Al ejecutar INICIALIZA 7, 1, 4, 0 se produce la siguiente expansin:

* EXITM Sirve para abortar la ejecucin de un bloque MACRO, REPT, IRP IRPC. Normalmente se utiliza apoyndose en una directiva condicional (IF...ELSE...ENDIF). Al salir del bloque, se pasa al nivel inmediatamente superior (que puede ser otro bloque de estos). Como ejemplo, la siguiente macro reserva n bytes de memoria a cero hasta un mximo de 100, colocando un byte 255 al final del bloque reservado:
MALLOC MACRO n maximo=100 REPT n IF maximo EQ 0 ; ya van 100? EXITM ; abandonar REPT ENDIF maximo = maximo - 1 DB 0 ; reservar byte ENDM DB 255 ; byte de fin de bloque ENDM

5.4.7. - MACROS AVANZADAS CON NUMERO VARIABLE DE PARMETROS. Como se vio al estudiar la directiva IF, existe la posibilidad de chequear condicionalmente la presencia de un parmetro por medio de IFNB, o su ausencia con IFB. Uniendo esto a la potencia de IRP es posible crear macros extraordinariamente verstiles. Como ejemplo, valga la siguiente macro, destinada a introducir en la pila un nmero variable de parmetros (hasta 10): es especialmente til en los programas que gestionan interrupciones:
XPUSH MACRO R1,R2,R3,R4,R5,R6,R7,R8,R9,R10 IRP reg, <R1,R2,R3,R4,R5,R6,R7,R8,R9,R10>

IFNB <reg> PUSH reg ENDIF ENDM ENDM

; fin de IRP ; fin de XPUSH

Por ejemplo, la instruccin:


XPUSH AX,BX,DS,ES,VAR1 AX AX DS ES VAR1

Se expandir en:
PUSH PUSH PUSH PUSH PUSH

El ejemplo anterior es ilustrativo del mecanismo de comprobacin de presencia de parmetros. Sin embargo, este ejemplo puede ser optimizado notablemente empleando una lista como nico parmetro:
XPUSH MACRO lista IRP i, <lista> PUSH i ENDM ENDM MACRO lista IRP i, <lista> POP i ENDM ENDM

XPOP

La ventaja es el nmero indefinido de parmetros soportados (no slo 10). Un ejemplo de uso puede ser el siguiente:
XPUSH XPOP <AX, BX, CX> <CX, BX, AX> AX BX CX CX BX AX

Que al expandirse queda:


PUSH PUSH PUSH POP POP POP

http://atc.ugr.es/docencia/udigital/05.html

5.- MACROS Y PROCEDIMIENTOS.


La manera ms fcil de modularizar un programa es dividirlo en dos o ms partes. Para esto, es necesario que datos, smbolos, y dems valores de un mdulo sean reconocidos por el otro u otros mdulos. Para este tipo de declaraciones globales existen dos directivas: PUBLIC nombre,,, programas. que hace la variable, etiqueta o smbolo absoluto disponible para todos los

EXTRN nombre:tipo,,, que especifica una variable, etiqueta o smbolo externos identificados por nombre y tipo (que puede ser BYTE, WORD, DWORD, QWORD, TBYTE, NEAR, FAR, o ABS, ste ltimo para nmeros absolutos). El siguiente ejemplo ilustra el uso de las directivas. El primer listado corresponde al mdulo principal, mientras que el segundo al mdulo que contiene una rutina. Ambos mdulos son archivos que se editan por separado, se ensamblan por separado, pero se ligan juntos. MODULO PRINCIPAL: MAIN.ASM
NAME main PUBLIC exit EXTRN print:near stack stack data data code start: mov ax,data mov ds,ax jmp print exit: mov ah,4ch int 21h ENDS END start ; carga localizacion del segmento ; en el registro DS ; va a PRINT en el otro modulo SEGMENT word stack 'STACK' DW 64 DUP(?) ENDS SEGMENT word public 'DATA' ENDS SEGMENT byte public 'CODE' ASSUME cs:code, ds:data

code

SUBMODULO: TASK.ASM
NAME task PUBLIC print EXTRN exit:near data entrada salida data code print: mov mov mov mov mov mov int mov ah,06h ; Funcion para borrar pantalla al,0 ; todas las lineas cx,0 ; de 0,0 dh,24d dl,79d bh,0 ; atributo en lineas vacias 10h ; Servicio de e/s video dx, OFFSET entrada SEGMENT word public 'DATA' DB "Entrando a un submodulo....",13,10,"$" DB ".......saliendo del submodulo.",01,07,13,10,"$" ENDS SEGMENT byte public 'CODE' ASSUME cs:code, ds:data

code

mov int mov int jmp ENDS END

ah,09h 21h dx, OFFSET salida 21h exit ; Regresa al otro modulo

La declaracin de macros se hace a travs de las directivas MACRO y ENDM. Su sintaxis es: nombre MACRO [parmetros,,,] declaraciones ENDM parmetros son los valores que se substituirn en la macro cada vez que se haga referencia a sta. Para la definicin de procedimientos se emplean las directivas PROC y ENDP. Su sintaxis es: nombre PROC [distancia] sentencias nombre ENDP distancia, que puede ser NEAR (defecto) o FAR permiten indicar el tipo de acciones a realizar en brincos y llamados a subrutinas. nombre se puede usar como direccin en llamados o brincos

http://homepage.mac.com/eravila/asmix862.html#II.5

UNIDAD VII PROCEDIMIENTOS


7.1. DEFINICION.

El segmento de cdigo contiene el cdigo ejecutable de un programa. Tambin tiene uno o mas procedimientos, definidos con la directiva PROC. Un segmento que tiene solo un procedimiento puede aparecer como sigue:

NOMBRE

OPERACION

OPERANDO

COMENTARIO

Nombre del segmento

SEGMENT

PARA

nomproc

PROC . . .

FAR

;Un ;procedimiento ;dentro ;del segmento ;de cdigo

nomproc nomsegmento

ENDP ENDS

El nombre del procedimiento debe estar presente, ser nico y seguir las reglas para la formacin de nombres del lenguaje. El operando far en este caso esta relacionado con la ejecucin del programa. Cuando usted solicita la ejecucin de un programa, el cargador de programas del DOS utiliza este nombre de procedimiento como el punto de entrada para la primera instruccin a ejecutar.

La directiva ENDP indica el fin de un procedimiento y contiene el mismo nombre que el enunciado PROC para permitir que el ensamblador relacione a los dos. Ya que los procedimientos deben estar por completo dentro de un segmento, ENDP define el final de un procedimiento antes que ENDS defina el final de un segmento. 7.2. LLAMADA DE PROCEDIMIENTOS.

Hasta ahora los segmentos de cdigo han consistido solo en un procedimiento, codificado como:

BEGIN PROC FAR . . . BEGIN ENDP

En este caso el operador FAR informa al sistema que la direccin indicada es el punto de entrada para la ejecucin del programa, mientras que la directiva ENDP define el final del procedimiento. Sin embargo, un segmento de cdigo puede tener cualquier numero de procedimientos, todos distinguidos por PROC y ENDP. Un procedimiento llamado (o subrutina) es una seccin de cdigo que realiza una tarea definida y clara (tal como ubicar el cursor o bien obtener entrada del teclado).

La organizacin de un programa en procedimientos proporciona los beneficios siguientes:

1. Reduce la cantidad de cdigo, ya que un procedimiento comn puede ser llamado desde cualquier lugar en el segmento de cdigo.

2. Fortalece la mejor organizacin del programa.

3. Facilita la depuracin del programa, ya que los errores pueden ser aislados con mayor claridad.

4. Ayuda en el mantenimiento progresivo de programas, ya que los procedimientos son identificados de forma rpida para su modificacin.

Operaciones CALL y RET

La instruccin CALL transfiere el control a un procedimiento llamado, y la instruccin RET regresa del procedimiento llamado al procedimiento original que hizo la llamada. RET debe ser la ultima instruccin en un procedimiento llamado. Los formatos generales para CALL y RET son:

El cdigo objeto particular que CALL y RET generan depende de si la operacin implica un procedimiento NEAR (cercano) o un procedimiento FAR (lejano).

Llamada y regreso cercanos. Una llamada (CALL) a un procedimiento dentro del mismo segmento es cercana y realiza lo siguiente:

* Disminuye el SP en 2 (una palabra) * Mete el IP (que contiene el desplazamiento de la instruccin que sigue al CALL) en la pila. * Inserta la direccin del desplazamiento del procedimiento llamado en el IP (esta operacin vaca el resultado de la instruccin previamente procesada),

Un RET que regresa desde un procedimiento cercano realiza lo siguiente:

* Saca el antiguo valor de IP de la pila y lo enva al IP (lo cual tambin vaca el resultado de la instruccin previamente procesada). * Incrementa el SP en 2.

Ahora el CS:IP apunta a la instruccin que sigue al CALL original en la llamada del procedimiento, en donde se reasume la ejecucin.

Llamada y regreso lejanos. Una llamada (CALL) lejana llama a un procedimiento etiquetado con FAR, tal vez en un segmento de cdigo separado. Un CALL lejano mete a la pila al CS y al IP, y RET los saca de la pila.

page 60,132

TITLE

P08CALLP (EXE) Llamada a procedimientos .MODEL .STACK .DATA SMALL 64

;--------------------------------------------------------------------.CODE BEGIN PROC CALL ; ... MOV INT 21H BEGIN ENDP ;--------------------------------------------------------------------B10 PROC CALL ; ... RET B10 ENDP ;De regreso ;Quien llama NEAR C10 ;Llama a C10 AX,4C00H ;Salida a DOS FAR B10 ;Llama a B10

;--------------------------------------------------------------------END BEGIN

UNIDAD VIII MACROS


8.1. INTRODUCCION.

Para cada instruccin simblica que usted codifica, el ensamblador genera una instruccin de lenguaje de maquina. El ensamblador tiene facilidades que el programador puede utilizar para definir macros. Primero hay que definir un nombre especifico para la macro, junto con el conjunto de instrucciones en lenguaje ensamblador que la macro va a generar. Despus, siempre que necesite codificar el conjunto de instrucciones, solo hay que codificar el nombre de la macro y el ensamblador genera de forma automtica las instrucciones que han sido definidas en la macro.

Las macros son tiles para los siguientes propsitos:

* Simplificar y reducir la cantidad de codificacin repetitiva. * Reducir errores causados por la codificacin repetitiva. * Linealizar un programa en lenguaje ensamblador para hacerlo mas legible.
8.2. DEFINICION DE UNA MACRO. Una definicin de macro aparece antes de que cualquier definicin de segmento. Examinemos una definicin de una macro sencilla que inicializa los registros de segmento para un programa.EXE:

INICIAREGS

MACRO MOV AX, @data MOV DS, AX MOV ES, AX ENDM

;Define macro ; } Cuerpo de ; } la definicin ; } de la macro ; Fin de la macro

El nombre de esta macro es INICIAREGS, aunque es aceptable cualquier otro nombre valido que sea nico. La directiva MACRO en la primer lnea indica al ensamblador que las instrucciones que siguen, hasta ENDM ("fin de la macro"), son parte de la definicin de la macro. La directiva ENDM termina la definicin de la macro. Los nombres a que se hace referencia en la definicin de la macro, @data, AX, DS y ES,

deben estar definidos en alguna parte del programa o deben ser dados a conocer de alguna otra forma al ensamblador. En forma subsecuente se puede usar la macro-instruccion INICIAREGS en el segmento de cdigo en donde quiera inicializar los registros. Cuando el ensamblador encuentra la macrainstruccion INICIAREGS, busca en una tabla de instrucciones simblicas y, a falta de una entrada, busca macroinstrucciones. Ya que el programa contiene una definicin de la macro INICIAREGS, el ensamblador sustituye el cuerpo de la definicin generando instrucciones: la expansin de la macro. Un programa usara la macroinstruccion INICIAREGS solo una vez, aunque otras macros estn diseadas para ser utilizadas cualquier numero de veces y cada vez el ensamblador genera la misma expansin 8.3. MANEJO DE PARAMETROS. Para hacer una macro flexible, puede definir nombres en ella como argumentos mudos (ficticios).La definicin de la macro siguiente, llamada DESPLEGAR_MSG, proporciona el uso de la funcin 09H del DOS para desplegar cualquier mensaje. Cuando se usa la macroinstruccin el programador tiene que proporcionar el nombre del mensaje, el cual hace referencia a un rea de datos terminada por un signo de dlar.

DESPLEGAR_MSG

MACRO MENSAJE ; Argumento mudo MOV AH, 09H LEA DX, MENSAJE INT 21H ENDM ; Fin de la macro

Un argumento mudo en una definicin de macro indica al ensamblador que haga coincidir su nombre con cualquier aparicin del mismo nombre en el cuerpo de la macro. Por ejemplo, el argumento mudo MENSAJE tambin aparece en la instruccin LEA. Cuando utiliza la macroinstruccin DESPLEGAR_MSG, usted proporciona un parmetro como el nombre real del mensaje que ser desplegado, por ejemplo:

DESPLEGAR_MSG

MENSAJE2

En este caso, MENSAJE2 tiene que estar apropiadamente definido en el segmento de dato. El parmetro en la microinstruccin corresponde al argumento mudo en la definicin original de la macro: Definicin de macro: DESPLEGAR_MSG MACRO MENSAJE Macroinstruccin: DESPLEGAR_MSG MENSAJE2 (Argumento) (Parametro)

El ensamblador ya ha hecho corresponder el argumento en la definicin original de la macro

con la instruccin LEA en el cuerpo de la macro. Ahora sustituye el (los) parmetro( de la macroinstruccin MENSAJE2 por la presencia de MENSAJE en la instruccin LEA y la sustituye por cualquier otra aparicin de MENSAJE. Un argumento mudo puede contener cualquier nombre valido, incluyendo un nombre de registro tal como CX. Puede definir una macro con cualquier numero de argumentos mudos, separados por coma, hasta la columna 120 de una lnea. El ensamblador sustituye los parmetros de la macro instruccin por los argumentos mudos en la definicin de la macro, entrada por entrada, de izquierda a derecha 8.4. MANEJO DE ETIQUETAS LOCALES. Algunas macros necesitan que se definan elementos de datos y etiquetas de instrucciones dentro de la definicin de la macro. Si utiliza la macro mas de una vez en el mismo programa y el ensamblador define los elementos de datos para cada aparicin, los nombres duplicados haran que el ensamblador genere un mensaje de error. Para asegurar que cada nombre generado es nico, hay que codificar la directiva LOCAL inmediatamente despus de la instruccin MACRO. Su formato general es: LOCAL Etiqueta1, Etiqueta2...Etiquet an

8.5.BIBLIOTECAS DE MACROS. Definir una macro y usarla solo una vez en un programa no es muy productivo. El enfoque habitual es catalogar las macros en una biblioteca en disco bajo un nombre descriptivo, como MACRO.LIB. Usted solo tiene que reunir todas las definiciones de sus macros en un archivo y almacenar el archivo en disco:

Macro1 MACRO .... ENDM Macro2 MACRO .... ENDM

Para usar cualquiera de las macros catalogadas, en lugar de codificar las definiciones MACRO al inicio del programa utilice la directiva INCLUDE as:

INCLUDE Macro1 Macro2

C: MACRO.LIB

El ensamblador accesa el archivo llamado MACRO en la unidad C e incluye ambas definiciones de macro, Macro1 y Macro2, en el programa. El listado ensamblado contendr

una copia de las definiciones de las macros. La Directiva PURGE. La ejecucin de una instruccin INCLUDE hace que el ensamblador incluya todas las definiciones de macros que estn especificadas en la biblioteca. Sin embargo, suponga que una biblioteca contiene las macros SUMA, RESTA, DIVIDE, pero que el programa solo necesita SUMA. La directiva PURGE permite que usted "elimine" la macros RESTA y DIVIDE que no necesita del ensamblado actual:

IF1 INCLUDE C:\MACRO.LIB ENDIF PURGE RESTA, DIVIDE

;Incluye la biblioteca completa

;Elimina la macros no necesarias

Una operacin PURGE facilita solo el ensamblado de un programa y no tiene efecto sobre las macros almacenadas en la biblioteca

http://www.portalhacker.net/index.php?topic=73143.28

http://es.scribd.com/doc/23105148/Unidad-III-Ensamblador
LLAMADA DE PROCEDIMIENTOS. Hasta ahora los segmentos de cdigo han consistido solo en un procedimiento, codificado como: BEGIN PROC . . . BEGIN ENDP FAR

En este caso el operador FAR informa al sistema que la direccin indicada es el punto de entrada para la ejecucin del programa, mientras que la directiva ENDP define el final del procedimiento. Sin embargo, un segmento de cdigo puede tener cualquier numero de procedimientos, todos distinguidos por PROC y ENDP. Un procedimiento llamado (o subrutina) es una seccin de cdigo que realiza una tarea definida y clara (tal como ubicar el cursor o bien obtener entrada del teclado). La organizacin de un programa en procedimientos proporciona los beneficios siguientes: 1. Reduce la cantidad de cdigo, ya que un procedimiento comn puede ser llamado desde cualquier lugar en el segmento de cdigo. 2. Fortalece la mejor organizacin del programa. 3. Facilita la depuracin del programa, ya que los errores pueden ser aislados con mayor claridad. 4. Ayuda en el mantenimiento progresivo de programas, ya que los procedimientos son identificados de forma rpida para su modificacin.

Operaciones CALL y RET La instruccin CALL transfiere el control a un procedimiento llamado, y la instruccin RET regresa del procedimiento llamado al procedimiento original que hizo la llamada. RET debe ser la ultima instruccin en un procedimiento llamado. El cdigo objeto particular que CALL y RET generan depende de si la operacin implica un procedimiento NEAR (cercano) o un procedimiento FAR (lejano). Llamada y regreso cercanos. Una llamada (CALL) a un procedimiento dentro del mismo segmento es cercana y realiza lo siguiente: Disminuye el SP en 2 (una palabra) Mete el IP (que contiene el desplazamiento de la instruccin que sigue al CALL) en la pila. Inserta la direccin del desplazamiento del procedimiento llamado en el IP (esta operacin vaca el resultado de la instruccin previamente procesada), Un RET que regresa desde un procedimiento cercano realiza lo siguiente: Saca el antiguo valor de IP de la pila y lo enva al IP (lo cual tambin vaca el resultado de la instruccin previamente procesada). Incrementa el SP en 2. Ahora el CS:IP apunta a la instruccin que sigue al CALL original en la llamada del procedimiento, en donde se reasume la ejecucin. Llamada y regreso lejanos. Una llamada (CALL) lejana llama a un procedimiento etiquetado con FAR, tal vez en un segmento de cdigo separado. Un CALL lejano mete a la pila al CS y al IP, y RET los saca de la pila. page 60,132 TITLE P08CALLP (EXE) Llamada a procedimientos .MODEL SMALL .STACK 64 .DATA ;--------------------------------------------------------------------.CODE BEGIN PROC FAR CALL B10 ;Llama a B10 ; ... MOV AX,4C00H ;Salida a DOS INT 21H BEGIN ENDP ;--------------------------------------------------------------------B10 PROC NEAR CALL C10 ;Llama a C10 ; ... RET ;De regreso B10 ENDP ;Quien llama ;--------------------------------------------------------------------END BEGIN DEFINICIN DE UNA MACRO. Una definicin de macro aparece antes de que cualquier definicin de segmento. Examinemos una definicin de una macro sencilla que inicializa los registros de segmento para un programa.EXE:

INICIAREGS

MACRO MOV AX, @data MOV DS, AX MOV ES, AX ENDM

;Define macro ; } Cuerpo de ; } la definicin ; } de la macro ; Fin de la macro

El nombre de esta macro es INICIAREGS, aunque es aceptable cualquier otro nombre valido que sea nico. La directiva MACRO en la primer lnea indica al ensamblador que las instrucciones que siguen, hasta ENDM ("fin de la macro"), son parte de la definicin de la macro. La directiva ENDM termina la definicin de la macro. Los nombres a que se hace referencia en la definicin de la macro, @data, AX, DS y ES, deben estar definidos en alguna parte del programa o deben ser dados a conocer de alguna otra forma al ensamblador. En forma subsecuente se puede usar la macro-instruccion INICIAREGS en el segmento de cdigo en donde quiera inicializar los registros. Cuando el ensamblador encuentra la macra-instruccion INICIAREGS, busca en una tabla de instrucciones simblicas y, a falta de una entrada, busca macroinstrucciones. Ya que el programa contiene una definicin de la macro INICIAREGS, el ensamblador sustituye el cuerpo de la definicin generando instrucciones: la expansin de la macro. Un programa usara la macroinstruccion INICIAREGS solo una vez, aunque otras macros estn diseadas para ser utilizadas cualquier numero de veces y cada vez el ensamblador genera la misma expansin.

Para hacer una macro flexible, puede definir nombres en ella como argumentos mudos (ficticios).La definicin de la macro siguiente, llamada DESPLEGAR_MSG, proporciona el uso de la funcin 09H del DOS para desplegar cualquier mensaje. Cuando se usa la macroinstruccin el programador tiene que proporcionar el nombre del mensaje, el cual hace referencia a un rea de datos terminada por un signo de dlar. DESPLEGAR_MSG MACRO MENSAJE ; Argumento mudo MOV AH, 09H LEA DX, MENSAJE INT 21H ENDM ; Fin de la macro

Un argumento mudo en una definicin de macro indica al ensamblador que haga coincidir su nombre con cualquier aparicin del mismo nombre en el cuerpo de la macro. Por ejemplo, el argumento mudo MENSAJE tambin aparece en la instruccin LEA Si alguien necesita el PDF aqui se los dejo: http://www.carlosnuel.com/tutorial-de-lenguaje-ensamblador-en-espanol-con-ejemplos.html

http://foro.elhacker.net/asm/tutorial_asm_basico_ejemplos-t102701.0.html

PRACTICA # 5 MACROS OBJETIVO : El alumno disear un programa de gran complejidad que utilice macros, procedimientos y mltiples mdulos con el fin de promover los buenos hbitos de programacin e incrementar la modularidad de los programas.

INTRODUCCION A MACROS El ensamblador tiene facilidades que el programador puede usar para definir macros. Usted define un nombre especfico para la macro, junto con el conjunto de instrucciones en lenguaje ensamblador que la macro va a generar. Despus siempre que necesite codificar el conjunto de instrucciones, slo codifique el nombre de la macro y el ensamblador genera de manera automtica las instrucciones que usted defini. Los macros son tiles para los siguientes propsitos: Simplificar y reducir la cantidad de codificacin repetitiva. Reducir errores causados por la codificacin repetitiva. Linealizar un programa en lenguaje ensamblador para hacerlo ms legible.

Ejemplos de funciones que pueden ser implementadas por macros son operaciones de entrada/salida que cargan registros y realizan interrupciones, conversiones de informacin ASCII y binaria, aritmtica de palabras mltiples, rutinas para el manejo de cadenas de caracteres y divisin por sustraccin. MACROS La directiva MACRO se utiliza para dar un nombre simblico a un bloque de cdigo. Se utiliza ese nombre simblico cada vez que se quiere ejecutar el bloque de cdigo correspondiente. Un nombre simblico es un smbolo, como las etiquetas y nombres de variables, que representa un valor. Cuando se ensambla un programa, MASM reemplaza cada ocurrencia del nombre del Macro con el bloque de cdigo que tiene asociado. Esto es similar a la operacin "copyand-paste" que encontramos en los editores. Una ventaja que presentan los Macros sobre los procedimientos y funciones es su capacidad para aceptar parametros.

La sintaxis de los Macros es: nombre_del_macro MACRO arg_1, arg_2, ... , arg_n : : ; cdigo del Macro ENDM A continuacin se muestran un ejemplo de declaracin de Macros con parmetros.

GOTOXY MACRO X, Y mov ah, 2 mov bh, 0 ;nmero de pgina de vdeo mov dh, Y ;rengln mov dl, X ;columna

int 10h ENDM Si se deja un parmetro en blanco, MASM reemplaza cada ocurrencia del parmetro con un espacio en blanco. Si se especifica que un parmetro es obligatorio, entonces MASM mostrar un mensaje de error si falta un parmetro. Se utiliza la directiva REQ para indicar que un parmetro es obligatorio.

GOTOXY MACRO X:REQ, Y:REQ : ENDM Tambin se pueden dar valores por default a los parmetros de un macro para que en caso de que el programador omita uno, se tome este otro. GOTOXY MACRO X:=<1>, Y:=<1> mov ah, 2 mov bh, 0 ; nmero de pgina de video mov dh, Y ; renglon mov dl, X ; columna int 10h ENDM Si se necesita colocar una etiqueta dentro de un Macro esta debe declarase LOCAL para evitar un error tipo "Redefinition of a symbol". GETCHR MACRO LOCAL termina mov ah, 1 int 21h cmp al, 0 jnz termina int 21h termina: ENDM

INCLUIR (INCLUDE) DESDE UNA BIBLIOTECA DE MACROS Definir una macro y usarla una sola vez en un programa no es muy productivo. El enfoque habitual es catalogar las macros en una biblioteca en disco bajo un nombre descriptivo. Usted solo tiene que reunir todas las definiciones de sus macros en un archivo y almacenar el archivo en disco. Para usar cualquiera de las macros catalogadas, en lugar de codificar las definiciones MACRO al inicio del programa utilice la directiva INCLUDE as: INCLUDE .. C:MACRO.LIB

El ensamblador accesa el archivo llamado MACRO.LIB en la unidad C e incluye todas las definiciones de macro. El listado ensamblado contendr una copia de las declaraciones de las macros.

Ejemplo

El listado muestra un programa donde se utilizan los conceptos de esta practica. .MODEL SMALL .STACK .DATA ; variables diaDireccion DW ? ; direccion del dia seleccionado dia DB ? ; numero de dia ; mensajes pregunta DB "Que dia de hoy (1-7)? $" error DB "ERROR: No existe ese dia!$" lunes DB "LUNES$" martes DB "MARTES$" miercoles DB "MIERCOLES$" jueves DB "JUEVES$" viernes DB "VIERNES$" sabado DB "SABADO$" domingo DB "DOMINGO$" GOTOXY MACRO X:=<0>, Y:=<0>, PAGINA:=<0> mov ah, 2 ; posicionar el cursor mov bh, PAGINA mov dh, Y ; renglon mov dl, X ; columna int 10h ; servicio del BIOS ENDM .CODE ; establecer el segmento de datos mov ax, @DATA mov ds, ax ; borrar pantalla mov ah, 6 mov al, 0 ; toda la pantalla mov bh, 7 ; letras blancas fondo negro mov cx, 0 ; reng=0 col=0 mov dh, 24 ; reng=24 mov dl, 80 ; col=80 int 10h GOTOXY ; posicionar cursor

Listado Prog5.asm

inicio:

; mostrar pregunta mov ah, 9 mov dx, OFFSET pregunta int 21h ; leer respuesta mov ah, 1 int 21h mov dia, al ; guardar respuesta ; verificar respuesta

cmp dia, '1' jne ES_MARTES ; la respuesta fue LUNES mov dx, OFFSET lunes mov dia, 1 jmp MUESTRA ES_MARTES: cmp dia, '2' jne ES_MIERCOLES ; la respuesta fue MARTES mov dx, OFFSET martes mov dia, 2 jmp MUESTRA ES_MIERCOLES: cmp dia, '3' jne ES_JUEVES ; la respuesta fue MIERCOLES mov dx, OFFSET miercoles mov dia, 3 jmp MUESTRA ES_JUEVES: cmp dia, '4' jne ES_VIERNES ; la respuesta fue JUEVES mov dx, OFFSET jueves mov dia, 4 jmp MUESTRA ES_VIERNES: cmp dia, '5' jne ES_SABADO ; la respuesta fue VIERNES mov dx, OFFSET viernes mov dia, 5 jmp MUESTRA ES_SABADO: cmp dia, '6' jne ES_DOMINGO ; la respuesta fue SABADO mov dx, OFFSET sabado mov dia, 6 jmp MUESTRA ES_DOMINGO: cmp dia, '7' jne ES_ERROR ; la respuesta fue DOMINGO mov dx, OFFSET domingo mov dia, 7 jmp MUESTRA ES_ERROR: ; no escribio un numero de 1-7 ; muestra un mensaje de error GOTOXY 0, 2 mov dx, OFFSET error mov ah, 9 int 21h jmp fin ; termina el programa

muestra:

mov diaDireccion, dx ; copia la direccion del dia mov ch, 0 mov cl, dia ; se repetira segun el numero del dia ; muestra el nombre del dia GOTOXY 1, cl mov dx, diaDireccion ; restaura el mensaje mov ah, 9 int 21h loop otra_vez GOTOXY 0, 23 ; termina el programa mov ax, 4c00h int 21h END inicio

otra_vez:

fin:

Ejercicios
A. Elaborar un programa (PRACT5A.ASM) que dibuje un triangulo de asteriscos (minimo de 8 renglones) en el centro de la pantalla. Para el dibujo se deben utilizar ciclos anidados. Al principio del programa se debe explicar el funcionamiento del mismo en tres lneas, leer un Enter (validado), despus limpiar la pantalla y mostrar el dibujo. Leer un Enter para terminar. Utilizar los macros que se elaboraron. B. Escribir un macro para las siguientes operaciones: GOTOXY(X,Y) CLRSCR() GETCH(LETRA) PUTCHAR(LETRA) Cada Macro deber tener parmetros por default con valores consistentes con las operaciones ms comunes. El nombre de los macros y de sus parmetros deber indicar el tipo de operacin que realiza. Ningn macro podr hacer referencia a alguna variable externa al macro. Como encabezado, cada Macro deber tener una descripcin de su funcionamiento, de sus parmetros y donde sea aplicable, el rango que podrn tomar estos. Adems, se deber indicar si al utilizar este macro se modifica alguno de los registros, esto es, los efectos secundarios que tendr el uso del macro. C. Elaborar un programa (PRACT5B.ASM) que dibuje una portada. El cuadro externo ser del tamao de la pantalla, el fondo de color gris claro y la letra de color azul fuerte, debe tener lnea doble. Los datos a imprimir son: universidad, nombre de la facultad, carrera, materia, nombre del alumno, matricula, lugar y fecha. Los datos deben estar centrados en la pantalla, el lugar y la fecha deben imprimirse en la esquina inferior derecha. Escribir los dos siguientes procedimientos: xyputs(x,y,cadena) Coloca la cadena en la coordenada (x,y) centrar(y,cadena) Coloca la cadena centrada en el rengln y Utilizar los procedimientos elaborados en este programa.

http://yaqui.mxl.uabc.mx/~martinez/cinco_a.html

http://sites.google.com/site/apoyoitsoehmaterial/lenguaje-ensamblador