MAIN.MAC - CABECERA PRINCIPAL
Primero y ante todo decir que el código que voy a implementar no usa muchas directivas ya creadas en MASM y TASM. Debido a que yo daba clases de Ensamblador y a que comencé con ASM, preferí inicialmente crear directivas propias a usar las que tenía el compilado TASM 2.0. (rutina en vez de proc, modelo en vez de model, _data en vez de .data... etc). De esta forma podía demostrar que realmente las directivas eran definibles.
Por eso, aunque muchos digan que lo que estoy haciendo ya está construido en el compilador, quiero que vean que muchas de las directivas del TASM 2.0 son prescindibles, y que un buen programador puede usar un pequeño compilador y realizar cualquier tarea.
Esto es importante para los que hemos tenido que compilar con otros compiladores mucho más simples, por ejemplo para otros microprocesadores, y en los que hemos querido aplicar las mismas reglas de programación que con el 8086.
Por eso ruego paciencia. Primero aplicaré mis directivas, y veremos como resulta un código casi idéntico al del ensamblador TASM 2.0. Así veremos, sin necesidad de desensamblar, lo que realmente hacen esas directivas, que simplifican el código, pero que ocultan cosas, al programador, que se deben conocer y entender.
Sin embargo, si pensamos usar standares y acoplarnos a códigos de alto nivel, nos conviene usar las directivas incorporadas en el compilador TASM, para compatibilizar de forma sencilla el código con otros lenguajes de alto nivel.
Por eso a partir de la entrada 50 del blog haré una comparativa de las dos formas y comenzaré a aplicar directamente el código TASM 2.0.
FUNCIONES ACOPLADAS EN MAIN.MAC
Todo lo que iré poniendo ahora será para generar ficheros .exe. Más adelante, Cuando hayamos implementado programas ya con las directivas del TAM completas, lo generaremos en .com.
Como siempre habrá una cabecera ".mac", bueno ".inc" si se desea, con las macros y definiciones de las funciones. Cuando simplifique los programas a versión completa las llamaré ".inc" para distinguirlas.
En esta cabecera, como cabecera de inicialización de programa incluyo algunas sentencias de precompilación, que servirán para asignar memoria, segmentos, pila y por supuesto la estructura de lista de argumentos.
Rutina (equivale a proc+ arg en TASM)
Permite crear estructura para el paso de parámetros través de pila, de esta manera será muy sencillo declarar una función y pasarla hasta 10 variables . Declara al tiempo la función como publica, al modo que lo hace "C", pero sin apenas darnos cuenta. Se verá mejor cuando coloque la función Graphics.
_modelo (equivale a model en TASM)
Sirve para definir el tipo de programa .com o .exe. si no se usa es .exe. Esto se usará paa definr los segmetos
EN esta macro creamos una constante que podemos identificar en la macro _data, para asignar la zona de datos a DS o CS, según el programa sea . com o .exe. Esto no evitará tener que utilizar dos librerías (una para como y otra para exe) , si no queremos tener que compilar todas las librerías cada vez que hagamos un programa.
Pero sí nos permitirá tener un programa único para cada librería y una de muy forma simple compilarlo para uno y otro modo.
_code (equivale a .code en TASM)
Nos define el comienzo de la zona de código.
_data (equivale a .data en TASM)
Nos define el comienzo de la zona de datos. Puede estar antes o después del code, aunque en las funciones es recomendable que esté detrás.
_end (equivalente a end en TASM)
Cierra el programa en caso un programa se debe indicar el nombre de la rutina principal
_stack (equivale a .stack en TASM)
Nos inicializa la pila al tamaño indicado en NUMERO
Todas estas macros crean un entorno de trabajo equivalente al estandar de TASM y MASM, pero sin usar su directivas. Como solo usa if y macro con ellas puede crearse el entrono equivalente a TASM pero en el compilador inicial ASM. Todas estas macros pueden ser eliminadas y substituidas por las directivas equivalentes del TASM 2.0. Cosa que haremos más adelante.
Con estas macros podemos ver como se pueden crear no solo llamadas a funciones sino nuevas directivas de compilación. A partir de la entrada 50 del blog veremos como crear con las macros directivas de PROGRAMACIÓN ESTRUCTURADA tales como FOR o WHILE.
Otras macros más interesantes aún pues no las tiene el TASM son:
dim - Permite crear una variable compleja tomando una estructura como plantilla.
asigdata - Nos permitirá reasignar una zona de memoria al segmento de datos.
of_reg- devuelve la dirección del registro indicado de una tabla que se encuentre en memoria, creada bajo una estructura.
exit- Fin de programa con salida al sistema.
encriptar y desencriptar- Funciones especiales que permitirán encriptar parte de los datos del programa, de manera que no sean legibles mediante un Dump del código, pero si sean legibles una vez inicializado el programa.
string, char, integer Definición de los tres tipos de variables más importantes. Serán usadas en la inicialización de los datos, por lo que están incluidas en el main como definición de variables.
main - comienzo del programa. Es la encargada de llamar a la linea de comandos si se definieron parámetros y la encargada de asignar la zona de datos si se definió con la macro _data. Así mismo prepara el PSP para que la salvar la dirección de vuelta al sistema.
Dentro del
main existe una directiva por la cual si no se ha añadido la cabecera
argum.mac, y por lo tanto no se ha definido la variable externa
_line_comand, no se llamará a la función de la librería correspondiente. De esta forma, si no necesitamos argumentos no consumiremos código innecesario.
Main parece una forma de iniciar el programa pero es mucho más, en realidad inicializa el programa., reserva la memoria, recoge los argumentos de la línea de comando, y prepara la ejecución. Por ello tomé este nombre para crear una rutina especial, a la que llamaré siempre al inicio del programa ejecutable. Se encargará de inicializar la memoria, la pila del sistema y recoger los argumentos de la linea de comandos, para que posteriormente mediante argv y argc tratarlos.
En el caso del main no incluimos la función directamente en la cabecera, pues en este caso el tamaño de la función supera al código de llamada.
Esta rutina no tendrá argumentos, y será llamada simplemente main.
Con esta cabecera estamos creando un entorno de trabajo equivalente al TASM completo, pero sin usar sus directivas más complejas.
MAIN.MAC
; Copyright (C) 2013 José Ángel Moneo Fernández
; This program is free software: you can redistribute it and/or modify
; it under the terms of the GNU General Public License as published by
; the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version.
; This program is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
; GNU General Public License for more details.
; You should have received a copy of the GNU General Public License
; along with this program. If not, see <http://www.gnu.org/licenses/>.
;Declaracion de una rutina (función) con paso de variables
Esta macro crea una estructura de compilación para ser usada posteriormente en la recogida de los datos pasados a la función.
;define modelo .com o .exe para definir forma de colocar assume en _data
_modelo macro tipo
tipo equ 1
endm
rutina macro nombre,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10
nombre&p struc
dd ?
irp arg,<arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10>
ifnb <arg>
arg dw ?
endif
endm
nombre&p ends
public nombre
nombre proc near
push bp
mov bp,sp
endm
_end macro nombre
ends
end nombre
endm
;genera la cabecera de datos
_data macro
ifndef com
ends ;asegura el cierre del segmento anterior
data segment byte public 'data'
endif
endm
_code macro
code segment byte public 'code'
assume cs:code
ifdef com
assume ds:code
else
assume ds:data ; esto nos obliga a definir siempre un data aunque sea vacío
endif
endm
;genera una pila con el tama¤o indicado
_stack macro NUMERO
pila segment byte stack 'stack'
db NUMERO dup (0)
pila ends
assume ss:pila
endm
;coloca en pila de direccion del PSP para salir al dos y llama
;a la gesti¢n de la linea de comandos si se ha usado parametros
main macro
push ds
xor ax, ax
push ax
ifdef _lin_comand
call _lin_comand
endif
ifdef data
asigdata data
endif
endm
;asigna un nuevo segmento de datos de trabajo
asigdata macro etiq
assume ds:etiq
mov ax, etiq
mov ds, ax
endm
;dimensiona una tabla de numero de elementos con una estructura regis
dim macro tablas,regis,numero
tablas regis numero dup (<>)
endm
; devuelve la direccion de un registro en una tabla en memoria
of_reg macro dest,lista,numero
mov dest,offset lista[numero*type(lista)]
endm
;Sale al sistema devolviendo un codigo
exit macro codigo
mov ah,4ch
ifdif <codigo>,<al>
mov al,codigo
endif
int 21h
endm
;encripta una zona de datos con un codigo dado
encriptar macro inicio,bytes,codigo
ifndef _encriptar
extrn _encriptar:near
endif
xor ax,ax
push ax
mov ax,codigo
push ax
mov ax,bytes
push ax
lea ax,inicio
push ax
call _encriptar
add sp,8
endm
;desencripta una zona de datos con un codigo dado
desencriptar macro inicio,bytes,codigo
ifndef _encriptar
extrn _encriptar:near
endif
mov ax,28h
push ax
mov ax,codigo
push ax
mov ax,bytes
push ax
lea ax,inicio
push ax
call _encriptar
add sp,8
endm
;define una cadena de entrada de texto para el scanf
string macro nombre,long
nombre db long+1,0,long+2 dup (0)
endm
char macro var,ini
ifb <ini>
var db ?
else
var db ini
endif
endm
integer macro var,ini
ifb <ini>
var dd ?
else
var dd ini
endif
endm