CAPÍTULO 6:
MACROS E PROCEDIMENTOS
Conteúdo
6.1.Procedimentos
6.2.Macros
6.1.Procedimentos
6.1.1.Definição de procedimento
6.1.2.Sintaxe de um procedimento
--------------- // ---------------
6.1.1.Definição de um procedimento
Um procedimento é uma coleção de instruções para as quais é possível
direcionar o curso de nosso programa, e uma vez que a execução destas
instruções do procedimento tenha acabado, o controle retorna para linha que
segue á que chamou o procedimento.
Procedimentos nos ajudam a criar programas legíveis e fáceis de modificar.
Quando se invoca um procedimento, o endereço da próxima instrução do
programa é mantido na pilha, de onde é recuperado quando do retorno do
procedimento.
--------------- // ---------------
6.1.2.Sintaxe de um procedimento
Há dois tipos de procedimentos, os intrasegments, que se localizam no mesmo
segmento da instrução que o chama, e os inter segments, que podem se
localizar em diferentes segmentos de memória.
Quando os procedimentos intrasegments são usados, o valor de IP é armazenado
na pilha e quando os procedimentos inter segments são usados o valor de
CS:IP é armazenado. Lembre-se que o registrador CS indica qual o segmento de
código.
A diretiva que chama um procedimento é como segue:
CALL NomedoProcedimento
As partes que compõem um procedimento são as seguintes:
Declaração do procedimento
Código do procedimento
Diretiva de retorno
Término do procedimento
Por exemplo, se quisermos uma rotina que soma dois bytes armazenados em AH e
AL, e o resultado da soma em BX:
Soma Proc Near ; Declaração do Procedimento
Mov BX, 0 ; Conteúdo do Procedimento...
Mov BL, AH
Mov AH, 00
Add BX, AX
Ret ; Diretiva de retorno
Soma EndP ; Fim do Procedimento
Na declaração, a primeira palavra, Soma, corresponde ao nome do
procedimento. Proc declara-o e a palavra Near indica que o procedimento é do
tipo intrasegment, ou seja, no mesmo segmento. A diretiva Ret carrega IP com
o endereço armazenado na pilha para retornar ao programa que chamou.
Finalmente, Soma EndP indica o fim do procedimento.
Para declarar um procedimento inter segment, basta substituir a palavra Near
para FAR.
A chamada deste procedimento é feito de modo idêntico:
Call Soma
Macros oferecem uma grande flexibilidade na programação, comparadas aos
procedimentos.
--------------- // ---------------
6.2.Macros
6.2.1.Definição de uma Macro
6.2.2.Sintaxe de uma Macro
6.2.3.Bibliotecas de Macros
6.2.1.Definição de uma Macro
Uma macro é um grupo de instruções repetitivas em um programa que são
codificadas apenas uma vez e, assim, poupam espaço, podendo ser utilizadas
tantas vezes quantas forem necessário.
A principal diferença entre uma macro e um procedimento é que numa macro é
possível a passagem de parâmetros e num procedimento não. No momento em que
a macro é executada, cada parâmetro é substituído pelo nome ou valor
especificado na hora da chamada.
Podemos dizer, desta forma, que um procedimento é uma extensão de um
determinado programa, enquanto que uma macro é um módulo que especifica
funções que podem ser utilizadas por diferentes programas.
Uma outra diferença entre uma macro e um procedimento é o modo de chamada de
cada um. Para chamar um procedimento, se faz necessário a diretiva CALL, por
outro lado, para chamada de macros é feita com se fosse uma instrução normal
da linguagem assembly.
--------------- // ---------------
6.2.2.Sintaxe de uma Macro
As partes que compõem uma macro são as seguintes:
Declaração da macro
Código da macro
Diretiva de término da macro
A declaração da macro é feita como se segue:
NomeMacro MACRO [parâmetro1, parâmetro2...]
Do mesmo modo que temos a funcionalidade dos parâƒmetros, é possível também a
criação de uma macro que não os possua.
A diretiva de término da macro é: ENDM
Um exemplo de uma macro para colocar o cursor numa determinada posição da
tela:
Pos MACRO Linha, Coluna
PUSH AX
PUSH BX
PUSH DX
MOV AH, 02H
MOV DH, Linha
MOV DL, Coluna
MOV BH, 0
INT 10H
POP DX
POP BX
POP AX
ENDM
Para usar uma macro basta chamá-la pelo seu nome, tal como se fosse qualquer
instrução na linguagem assembly:
Pos 8, 6
--------------- // ---------------
6.2.3.Biblioteca de Macros
Uma das facilidades oferecidas pelo uso de macros é a criação de
bibliotecas, que são grupo de macros, podendo ser incluídas num programa
originárias de arquivos diferentes.
A criação destas bibliotecas é muito simples. Criamos um arquivo com todas
as macros que serão necessárias e o salvamos como um arquivo texto.
Para incluir uma biblioteca num programa, basta colocar a seguinte instrução
Include NomedoArquivo na parte inicial do programa, antes da declaração do
modelo de memória.
Supondo que o arquivo de macros tenha sido salvo com o nome de MACROS.TXT, a
instrução Include seria utilizada do seguinte modo:
;Início do programa
Include MACROS.TXT
.MODEL SMALL
.DATA
;Os dados vão aqui
.CODE
Inicio:
;O código do programa começa aqui
.STACK
;A pilha ‚ declarada
End Inicio
;Fim do programa
*********************************************************************************