Desarrollo del Ensamblador y el Linkador del

MC68000 para un entorno Windows mediante C++

Builder

AUTOR: Miguel Monforte Artigas

DIRECTOR: Enrique Cant Navarro

FECHA: Febrero / 2002

Indice

1 Memoria Descriptiva..........................................................................................3
1.1 Objeto del proyecto.........................................................................................3
1.2 Titular..............................................................................................................3
1.2 Antecedentes...................................................................................................3
1.4 Posibles soluciones y solucin adoptada........................................................4
1.5 Diferencias entre programas bajo DOS y bajo Windows...............................5
1.6 Introduccin a C++ Buider.............................................................................8
1.7 Descripcin general........................................................................................9
1.7.1 Introduccin ...........................................................................................9
1.7.2 Esquema Proceso de Ensamblado y Linkado.......................................13
1.7.3 Esquema del Proyecto...........................................................................15
1.7.4 Descripcin de las funciones.................................................................20

2 Presupuesto.......................................................................................................50

3 Conclusiones......................................................................................................51

4 Pliego de Condiciones........................................................................................53
4.1. Condiciones generales..................................................................................53
4.2. Condiciones econmicas..............................................................................58
4.3. Condiciones facultativas...............................................................................61
4.4. Condiciones tcnicas....................................................................................61

5 Anexos.................................................................................................................62
5.1. Manual de usuario.........................................................................................62
5.2. Cdigo...........................................................................................................71

2
1 Memoria Descriptiva

1.1 Objeto del proyecto

Este proyecto consiste en la adaptacin de un Ensamblador y un Linkador del

microprocesador de 16 bits (internamente funciona a 32 bits) MC68000 de Motorola de
C a C++ Builder, es decir, que tanto el Ensamblador como el Linkador de dicho
microprocesador sea soportado por una plataforma Windows 9X, 2000, etc y no slo
funcione sobre el sistema operativo DOS. El nombre del programa es Ens&Link 68000
y consta de una sla ventana.

1.2 Titular

El titular del presente proyecto es:

-Nombre: Escola Tcnica Superior dEnginyeria (E.T.S.E.)
Universitat Rovira i Virgili
-Direccin: Av. Pasos Catalans, 26
Campus Sescelades
43007 Tarragona
Telf: 977559610

1.3 Antecedentes

Hasta el momento en los laboratorios docentes del DEEEA se dispona de un

Ensamblador y un Linkador (adems de un simulador y un software de interface del PC
con el mdulo docente) que tan slo eran soportados por el sistema operativo DOS. Con
el programa generado en este proyecto se ha adaptado el programa escrito en C a
plataformas Windows (9X, 2000, etc) mediante el lenguaje C++ builder. Esta
modernizacin y adaptacin del software era necesaria debido a que prcticamente
todos el cdigo generado hoy en da se realiza con la finalidad de que funcione con la
plataforma standard Windows. El entorno creado es mucho ms visual y ms flexible
que el ya existente para DOS y conserva todas opciones y recursos de los que dispona
su antecesor. Otra ventaja que cabe destacar es que ambos mdulos (el Ensamblador y
el Linkador) han sido integrados en un mismo programa y no hace falta efectuar la
tediosa tarea de ejecutarlos cada vez que queramos ensamblar y linkar por separado.
Cabe decir tambin que estos 2 elementos, el ensamblador y el linkador, est
previsto que formen parte en un futuro inmediato de un entorno global de simulacin
tanto de la parte hard del microprocesador, como la parte soft. El entorno constar
adems de los presentes y mencionados ensamblador y linkador, de un simulador del
microprocesador y de un software de comunicaciones que servir de interface con los
PC y estaciones de trabajo del los laboratorios docentes.

3
Figura 1. Esquema Entorno Global del MC68000

1.4 Posibles soluciones y solucin adoptada

Se podra haber realizado el proyecto con cualquier tipo de los diversos lenguajes
visuales para Windows existentes en el mercado como por ejemplo: Visual C, Visual
Basic, etc, pero finalmente se ha optado por el C++ Builder de Borland por diversas
razones, entre las que podemos destacar su gran potencia heredada del C, la posibilidad
de programar en modo orientado a objetos (POO) como en C++ y la ltima y ms
importante debido a que facilita y ahorra mucho tiempo a la hora de programar, es que
ya incluye clases creadas con lo cual se agiliza en gran medida la generacin de cdigo
nuevo y complejo. En resumen, mediante C++ Builder se consigue una programacin
orientada a componentes (POC). Un componente es similar a una clase, pero adems
consta de propiedades y eventos. Cada componente nuevo ya creado e incluido en el
compilador, no es ms que un trozo de cdigo que da origen a un formulario, una
etiqueta, una listbox, etc, con lo cual se ahorra, mediante esta standarizacin el tiempo
para programar dichos objetos, lo cual suele ser bastante engorroso y complejo en
lenguajes como C++.

4
1.5 Diferencias entre programas bajo DOS y bajo Windows

Antes de explicar en profundidad el desarrollo del proyecto, se introducir

brevemente en qu consisten las diferencias bsicas entre un programa que funciona
bajo DOS y otro que funciona bajo Windows, ya que es uno de los pilares
fundamentales donde se apoya la razn de ser de este proyecto.
La diferencia bsica entre un programa bajo DOS y otro bajo Windows radica en su
modo de ejecucin. Mientras que en DOS los programas se ejecutan secuencialmente en
Windows dicha ejecucin depende de eventos o sucesos que se produzcan.
En Dos, la ejecucin de un programa parte de su main o programa principal y
mientras se est ejecutando ocuapar todos los recursos del sistema, y no los dejar
libres hasta el final, privando as a otras tareas o aplicaciones del uso de dichos recursos.
En Windows, los sucesos a los que se haca antes referencia pueden ser provocados
por 3 elementos:
-El usuario
-El sistema
-El programa
la respuesta a estos sucesos depende de las entradas, ya sean: movimientos del ratn,
cierre de ventanas, datos de entrada por el puerto paralelo, etc.
Cuando se produce un de estos sucesos se provoca un mensaje que se dirige a la
aplicacin que debe encargarse del manejo del suceso. Todas las aplicaciones de
Windows tienen una cola de mensajes donde se va almacenando los sucesos que debe
procesar. El sistema operativo (multitarea en el caso de Windows) va cediendo al
microprocesador las diferentes aplicaciones que se encuentran ejecutndose en el
ordenador a lo largo del tiempo. Cuando se cede el control a la aplicacin que tiene
pendientes mensajes para procesar, el sistema operativo va llamando a las diferentes
rutinas que se encargarn de procesar el mensaje segn sea su tipo.
A continuacin se muestra esquemticamente todo ese proceso:

5
 Main( ) Inicio Rutina 1

Rutina 1 Esperar Procesado

Suceso Suceso Rutina 2

Rutina 2
Salir? Rutina n

Rutina 3

Fin

Rutina n

Fin

Figura 2. Ejecucin de las rutinas bajo DOS (a) y bajo Windows (b)

Los mensajes a los que se haca antes alusin, son una notificacin a la aplicacin
con la finalidad de advertirle de que ha sucedido algo y que debe realizar alguna accin.
Cuando se enva un mensaje a una aplicacin sta, inmediatamente ejecutar una
funcin. Las aplicaciones de Windows emplean una ventana de interface con el
usuario. Las aplicaciones se encargan del control del rea de trabajo de dichas ventanas.
Mientras la cola de mensajes de una aplicacin est vaca, Windows no le ceder el
control a sta, ya que no hay mensajes a procesar en ese momento. As se optimiza en
gran medida la utilizacin de todos los recursos del sistema por parte de todas las
aplicaciones.
Seguidamente se muestra el diagrama de funcionamiento:

6
 WINDOWS APLICACIN A

Entrada
Cola de Mensajes
del Sistema WinMain

Cola de Mensajes
de Aplicacin A Funcin 1

Cola de Mensajes Funcin n

de Aplicacin n

Figura 3. Sistema de mensajes

Windows comparte recursos entre aplicaciones de ah que sea multitarea, con lo cual
es necesario que cualquier acceso a un recurso por parte de una aplicacin se establezca
a travs del sistema operativo, pero nunca directamente. Si una aplicacin necesita
emplear algn recurso hardware, tendr que ser a travs del sistema operativo. Para que
las aplicaciones sean independientes del hardware empleado, el sistema operativo
accede a ste mediante lo que se llama drivers o controladores. Cada fabricante de
dispositivos hard tiene que poner a disposicin los drivers pertinentes para que
stos sean completamente compatibles con Windows. Esta independencia hardware
implica que las aplicaciones sean independientes del hardware empleado, facilitando la
programacin.
El software mediante el cual estn realizados mayoritariamente todos drivers de
dispositivos perifricos son los archivos de extensin .dll o libreras de enlace
dinmico Windows permite adems el uso de stas. Los ficheros .dll son cdigo que
pueden usar de forma compartida diferentes aplicaciones. Existen DLL suministradas
por Windows, o bien es posible la programacin propia de DLL para su uso por
nuestras aplicaciones.
Finalmente cabe aadirse que el sistema operativo Windows proporciona unas
interfaces para la programacin de aplicaciones llamadas API las cuales son un
conjunto de funciones que tienen que ser empleadas para programar una aplicacin que
se ejecute bajo Windows.

7
1.6 Introduccin a C++ Builder

A continuacin se hace una breve introduccin al lenguaje seleccionado finalmente

para realizar el proyecto.
El C++ es una extensin o ampliacin del lenguaje C y a diferencia de ste ltimo,
permite programar en modo orientado a objetos. Antao, la gran mayora de las
aplicaciones desarrolladas para Windows eran realizadas en lenguaje C, del mismo
modo que las libreras de las funciones de las API. Sin embargo estas aplicaciones
fueron construidas pensando en objetos, de forma que lo ms conveniente era usar un
interface basado en objetos, que realice las llamadas a las API de Windows.
Con la finalidad de facilitar la programacin orientada a objetos se crearon
frameworks. Las framework son libreras que encapsulan las tcnicas de
programacin ms empleadas. Una aplicacin basada en framework en comparacin a
otra que se basa directamente en llamadas a las API contiene menos cdigo, con lo cual
es ms ptima desde un punto de vista temporal y es mucho ms fcil de crear. Adems
el uso de MFC permite el uso de funciones de los lenguajes C o C++ y el uso directo de
API.
Los frameworks para Windows que ms se han extendido en la actualidad son el
MFC (Microsoft), OWL (Borland) y VCL (Borland).
Las libreras VCL, (Visual Component Library) son las que se han utilizado en este
proyecto. Fueron desarrolladas originalmente para el compilador de Pascal de Borland,
el Delphi. El nuevo compilador Borland C++ Builder incluye las VCL (adems de
poder compilar programas basados OWL ,MFC y Delphi). Este framework es el ms
avanzado ya que permite una autntica programacin visual C++ basada en
componentes y formularios que pueden funcionar sin ficheros .dll adicionales.
Adems, como ya se ha dicho antes, permite la creacin de aplicaciones de mediana
complejidad para Windows en un tiempo relativamente corto.

8
1.7 Descripcin General

1.7.1 Introduccin

El programa consta de una sla ventana en la cual estn integrados todos los
elementos necesarios para el ensamblado y linkado de ficheros. Para pasar de un
mdulo a otro simplemente basta con hacer clic sobre una de las 2 pestaas. Primero
evidentemente se debe proceder ensamblando el fichero de extensin .asm. Para ello
bastar con introducir el nombre del fichero fuente en su campo correspondiente.
Automticamente los campos de los ficheros destino (.obj) y listado (.lst) se rellenan por
defecto con el mismo nombre aunque naturalmente cabe la posibilidad de modificarlos
posteriormente. A continuacin se hace clic sobre el botn Ensambla situado en el
men principal de la parte superior de la ventana. Al instante obtendremos los
resultados en los memos tanto de informacin (si no hubieran errores), como de errores
(si los hubiera). El fichero .asm contiene un cdigo escrito en lenguaje nemotcnico el
cual al ser ensamblado se transforma directamente a cdigo mquina inteligible por la
mquina. El cdigo generado en este ltimo fichero est en hexadecimal. A
continuacin, una vez creados los ficheros objeto y de listado se puede proceder a su
linkado. Para ello basta una vez ms con presionar la pestaa de la parte
correspondiente al linker. Ahora se tienen ms campos por rellenar. Se puede apreciar
como adems de los campos de destino (cuya extensin es .s28) y de mapa (cuya
extensin es .map), hay otro campo para introducir la posicin de memoria donde se
desea que sea o sean linkado/s nuestro/s fichero/s objeto y finalmente una ListBox por
si se quiere linkar ms de un fichero objeto. Evidentemente antes de introducir dichos
ficheros objeto en la ListBox tendrn que haber sido creados mediante su previo
ensamblado. Una vez introducidos ficheros .obj en la ListBox haremos click sobre el
botn Linka situado en el men superior de la ventana. Al igual que en el caso del
ensamblador sern presentados en los memos de informacin y de error los posibles
avisos o errores cometidos por el usuario.
Para llegar hasta el formulario final se ha seguido un proceso de transformacin
intermedio. Para ello en primer lugar se crearon 2 formularios provisionales, uno de
entrada y otro de salida (cuyos captions poseen el mismo nombre). El programa
entonces era apto para un entorno C++ Builder. Ambos formularios sirvieron de
referencia, una vez finalizado el proyecto, para comparar y confirmar si los mensajes de
salida y entrada, el tipo de errores provocados, etc eran los mismos en los formularios
principales que en el definitivo. Como se ha dicho anteriormente los formularios de
entrada y salida eran meramente formularios de apoyo, ya que consistan simplemente
en 2 objetos de la clase TForm con un memo del tipo TMemo cada uno en su interior y
el mecanismo de entrada y de salida era exactamente igual que el programa ejecutable
sobre DOS, slo que ahora se haca sobre un par de ventanas que podan soportar
Windows. Finalmente se ha decidido no eliminar dichos formularios debido a su gran
utilidad en una futura actualizacin a macroensamblador del presente programa,
simplemente se han configurado en modo invisible por motivos de esttica.

9
 Como se puede apreciar en la Figura 4, el formulario provisional de salida est
constituido nicamente de un memo que es un objeto de la clase TMemo, y de un
formulario que es otro objeto que contiene al anterior y es de la clase TForm. El
formulario se puede redimensionar en su totalidad. Por el memo simplemente salen
todos los mensajes que salan en la versin del ensamblador para DOS.

Figura 4. Formulario provisional de salida

El formulario de entrada es similar al anterior como puede apreciarse en la Figura 5.

Tambin consta de un memo y un formulario que lo contiene, con la pequea
diferencia de que posee un botn de control que hace la funcin que en la versin para
DOS tena el retorno de carro, es decir confirmar que los datos de entrada por parte del
usuario son vlidos.

Figura 5. Formulario provisional de entrada

10
 A continuacin se muestra en la Figura 6 el formulario definitivo que integra todas
las partes (entrada y salida). En concreto la de la Figura inferior corresponde a la parte
del Ensamblador. Es un formulario bastante ms completo y complejo que los
provisionales puesto que consta de ms componentes. En primer lugar se pueden
observar en la parte superior 2 controles, los cuales son objetos de la clase
TmenuItem y al hacer clic sobre ellos ejecutan la rutina principal correspondiente, ya
sea del ensamblador en el caso de Ensambla o del linkador en el caso de Linka. Estas
funciones se encuentran como veremos ms adelante en fichero .cpp asociado a este
formulario, en nuestro caso menuprin.cpp, el cual ser comentado ms adelante en
profundidad. Adems dichos controles se pueden activar haciendo Alt+E en el caso del
ensamblador y Alt+L en el caso del linkador.
Un poco ms abajo de estos controles, se han creado otros 2 correspondientes a las
pestaas que hacen posible la eleccin de la parte que se encarga del ensamblado o de la
que se encarga de la de linkado.

Figura 6. Formulario Definitivo. Parte correspondiente al Ensamblador

11
 Como se puede apreciar en la figura 7, el linkador se compone de 3 labels que son
objetos de la clase Tlabel y al igual que el ensamblador, posee 2 memos, que son
objetos de la clase Tmemo y que muestran los diferentes warnings o mensajes de
salida y errores dependiendo de lo que el usuario introduzca por teclado en las etiquetas
de entrada.

Figura 7. Formulario Definitivo. Parte correspondiente al Linkador

A continuacin se adjunta un diagrama de flujo donde se puede apreciar todo el

proceso de transformacin que siguen los diferentes tipos de archivos:

12
1.7.2 Esquema Proceso de Ensamblado y Linkado

Figura 8. Diagrama de flujo del proceso de ensamblado y linkado

13
 A continuacin se pasar a explicar el programa fuente elaborado haciendo especial
hincapi en el cdigo que hace referencia a la parte visual y al aspecto de Entrada/Salida
(I/O) tanto del Ensamblador como del Linkador. Para ello se ha estructurado este
captulo en los diferentes archivos de los que consta el programa. El programa global
que contiene a resto de subarchivos es un archivo de tipo project cuya extensin es
.bpr. Este es el tipo de archivo que constituye una aplicacin de C++ Builder, es
decir, en l estn contenidos toda una serie de ficheros que interactan entre s y hacen
posible su funcionamiento. Estos pueden constar de 2 tipos de ficheros: .cpp y
formularios asociados o no a estos archivos. Los formularios son en realidad trozos de
cdigo que les implementan grficamente. Sin embargo tambin se pueden visualizar
los formularios, si como todos los objetos creados en un entorno C++ Builder, mediante
la opcin View as Text, que es una de las opciones que se encuentran al clicar con el
botn derecho sobre el formulario en cuestin, al hacer clic en esa opcin se podrn
observar todos los objetos contenidos en el formulario, as como todas sus propiedades
principales con los valores que se les han asignado o que venan por defecto en un
archivo cuya extensin es .dfm. En ese mismo fichero se pueden variar dichas
propiedades escribiendo los valores que se deseen:

Figura 9. Opciones del formulario

14
 A continuacin se presenta un esquema grfico de todos los ficheros que componen
el fichero proyecto .bpr y despus se irn enumerando los archivos que contiene el
proyecto, y explicando cada una de las funciones de las que constan. Algunas de ellas
pertenecen a los formularios de salida y entrada que se realizaron como provisionales en
un principio aunque la mayora fueron tiles tanto a dichos formularios provisionales
como al final y definitivo ya que bsicamente son funciones de DOS que son
renombradas para que sean compatibles en un entorno C++ Builder.

1.7.3 Esquema del Proyecto

En primer lugar se expone mediante un diagrama grfico la interactuacin entre los

diferentes ficheros segn las funciones que contengan. Bsicamente es un esquema
jerrquico, donde las funciones de los archivos ms prioritarios llaman a funciones de
otros archivos ms secundarios.
Posteriormente se ha realizado un esquema general con todos los archivos y
funciones que contiene todo el proyecto.

15
 FORM2

MENUPRIN.cpp

MAIN_ENS MAIN_LINK

ENS68K.cpp LINKER.cpp

COPYR.cpp
SUBF2.cpp

TABLA.cpp
COPYRLINK.cpp

FUNC.cpp
PARSERL.cpp

ERRORES.cpp

ARBOLES.cpp

PARSER.cpp

16
1).Archivos Comunes

-old_io
void old_sleep(int a
int old_cprintf(char *c1)
int old_cprintf(char *c1,char*c2)
int old_cprintf(char *c1,int c2)
int old_cprintf(char *c1,char*c2,char *c3)
int old_cprintf(char *c1,char*c2,int i3,char *c4)
int old_cprintf(char *c1,char*c2,int i3)
int old_cprintf(char *c1,char*c2,char *c3,char *c4)
int old_cprintf(char *c1,int i2,char *c3,char *c4)
int old_cprintf(char *c1,char* c2,int i3,char *c4,int i5)
int old_cputs(const char *org)
void old_textattr(int newattr)
void old_gotoxy(int x, int y)
void old_clrscr()
char *old_gets(char *s)
void old_cco(unsigned char car, unsigned char atrib)
void old_music(int a,int b)
void old_rectan(int a, int b, int c, int d)
void old_scr_cursoff()
void old_top(int a,int c,int b)
void old_vert(int a,int b,int d)
void old_bot(int a,int c,int d)
void old_scr_rowcol(int a,int b)
void old_scr_curson()
void old_int86()
void old_marc(int le,int to, int ri, int bo, char s)
void old_elimarc(int le,int to, int ri, int bo, char s)
void old_puttext(int le,int to, int ri, int bo, char s)
void old_window(int a,int b,int c,int d)
void old_sedit(char cap,char str,unsigned char mvoid
old_scroll2(char c)
void old_miss2(char s)
void old_prom2()
void old_cprint(char str,unsigned char atr )
void old_cfill(unsigned int a,unsigned int b,unsigned int
c,unsigned
int d,unsigned char at)
void old_rectan(int a, int b, int c, int d,char t, char at)
void old_pit()
void old_epit()

17
-menuprin
void __fastcall TForm2::Ens68000Click(TObject *Sender)
void __fastcall TForm2::Printf_Error(char* c1)
void __fastcall TForm2::Printf_Error(char* c1,char *c2)
void __fastcall TForm2::Printf_Error(char* c1,char *c2,char *c3)
void __fastcall TForm2::Printf_Error(char *c1,char*c2,int i3,char
*c4)
void __fastcall TForm2::Printf_Error(char *c1,char*c2,int i3,char
*c4, int i4)
void __fastcall TForm2::Printf_Error(char *c1,char*c2,int i3)
void __fastcall TForm2::Printf_mens(char* c1)
void __fastcall TForm2::Printf_mens(char* c1,char *c2)
void __fastcall TForm2::Printf_mens(char* c1,char *c2,char *c3)
void __fastcall TForm2::Printf_mens(char *c1,char*c2,int i3,char
*c4)
void __fastcall TForm2::Printf_mens(char *c1,char*c2,int i3)
void __fastcall TForm2::Printf_mens(char *c1,char*c2,int i3,char
*c4, int i4)
void __fastcall TForm2::FuenteChange(TObject *Sender)
void __fastcall TForm2::FormResize(TObject *Sender)
void __fastcall TForm2::PestanasChange(TObject *Sender)
void __fastcall TForm2::Linka1Click(TObject *Sender)
void __fastcall TForm2::objChange(TObject *Sender)
void __fastcall TForm2::AnadirClick(TObject *Sender)
void __fastcall TForm2::kitarClick(TObject *Sender)

2).Ensamblador

-ENS68K.cpp
static int lee_linea(char *s,FILE *ff);
static void imprtitulo(void);
static int trans(char *,char *,int *);
static void mostrar_pantalla_ayuda(void);
char *treutabs(char *,char *);
void ini();
int old_main(int argc,char *argv)

-COPYR.cpp
void copyr()

18
 -TABLA.cpp
static int
tipo1(void),add(void),adda(void),addi(void),addq(void),and(void),
andi(void),asr(void),bra(void),bchg(void),chk(void),neg(void),
cmp(void),cmpm(void),nbcd(void),endd(void),eor(void),equ(void),
exg(void),ext(void),exter(void),glob(void),jmp(void),lea(void),
link(void),move(void),movea(void),movem(void),movep(void),
moveq(void),page(void),nada(void),or(void),org(void),rel(void),

stop(void),sub(void),swap(void),title(void),trap(void),unlk(void),

abso(void),dc(void),ds(void),dbcc(void),scc(void),high(void),low(v
oi
d);
static int buscar_tabla(void);
static void stcat(void);
static void invertir (char *);
static int mascara(char *,char *linea);
static int sp(long int);
static void opp_a_op(void);

-FUNC.cpp
static struct operando registro (char *,int);
char *coger_palabra(line,palabra,label)
char *cogeyanal(line,err,externo,aa)
int tipo2(valor,aa,ensamblado,operando)
int tipo3(valor,aa,ensamblado)
int masde4bits(a)
int masde8bits(a)
int masde16bits(a)
int esta_en (c,s)
long int hexdec(expresion,err)
long int bindec(expresion,err)

-ARBOLES.cpp
struct arbol *buscar_rama(struct arbol *a,char *label)
void eliminar_rama(a,label)
struct arbol *insarbol(struct arbol *r,struct arbol *a,char
*label,int *error,long int dato,int tipodevariable)
void listar_arbol (a,i)

-PARSER.cpp

19
static void coger_expresion(long int *);
static void nivel1(long int *);
static void nivel2(long int *);
static void nivel3(long int *);
static void nivel4(long int *);
static void nivel5(long int *);
static void nivel6(long int *);
static void primitiva(long int *);
static void arit (char ,long int *,long int *);
static void unitario (char,long int *);
static void coger_termino(void);
static esdelimitador(char);
static long int valor(char *);

-ERRORES.cpp
void error(tipo)

3).LINKADOR

-linker.cpp
static void insertarabs(struct lista *);
static void insertarreu(struct lista *);
static void listar(struct lista *);
static void listar_arbol (struct etiqueta *);
static void comprobar_externas(struct etiqueta *);
static void s28(char *);
static void volcars28(void);
static void nexit(int,char *);
static void sexit(void);
static int cogerfichero(char *,int);
static int buscarlista(struct lista *,char *);
static int insertar_etiqueta(struct etiqueta **,char *,char *);
static int checksum(char*);
static long int cogerposicion(void);
static struct etiqueta *buscar_etiqueta(struct etiqueta *,char *);
int copyrlink();
long int hexdec(char *);

-Subf2.cpp
marc(le, to, ri, bo, s)
elimarc(le, to, ri, bo, s)

20
 int old_sedit(cap,str,m)
scroll2(c)
miss2(s)
rom2()
cfill(a,b,c,d,at)
pit()
epit()
old_rectan(a,b,c,d,t,at)
old_top(x1,x2,y)
old_bot(x1,x2,y)
old_vert(x,y1,y2)
-copyrlink.cpp
copyrlink()

-Parserl.cpp
static void coger_expresion(long int *);
static void nivel1(long int *);
static void nivel2(long int *);
static void nivel3(long int *);
static void nivel4(long int *);
static void nivel5(long int *);
static void nivel6(long int *);
static void primitiva(long int *);
static void arit (char ,long int *,long int *);
static void unitario (char,long int *);
static void coger_token(void);
static esdelimitador(char);
static long int valor(char *);
static int esta_en (char,char *);

1.7.4 Descripcin de las funciones

Hay 2 archivos que son comunes a todo el proyecto. En ellos se encuentran funciones
de ambas partes, tanto linkador como ensamblador:

a).Archivos Comunes al Ensamblador y al linkador

-old_io.cpp
En la parte superior de este archivo se definen las libreras donde se incluyen
algunas funciones que se han creado y otras standard que ya venan implementadas.
Adems todas los funciones que se han creado nuevas renombrndolas y modificando
21
su contenido se han ido escribiendo en su fichero de cabecera, en este caso old_io.h,
para que no se produzcan errores de compilacin. En un fichero de cabecera siempre
deben incluirse todas las funciones de las que hace uso su archivo .cpp asociado. A
continuacin viene definido un array de caracteres llamado cadena => char
cadena[1024] q consta de 1024 elementos de tipo char. Dicho array se emplea para
almacenar o copiar los nombres de otras cadenas de caracteres. A continuacin estn
definidas algunas funciones relativas al ensamblador:
1.-Funciones relativas al Ensamblador:
-void old_sleep(int a) => Esta funcin es una modificacin de la original sleep(int
a). Se ha modificado debido a que era una funcin propia de DOS, la cual no puede
funcionar en un entorno de C++ Builder. Lo mismo se ha hecho con todas las funciones
de DOS que podan dar problemas al compilador de builder. En este caso simplemente
se renombra la funcin y se modifica para que no haga nada. Anteriormente en vez de
modificar este tipo de funciones para que no hicieran nada, se haca que escribieran en
un formulario de salida provisional su propio nombre para comprobar que
efectivamente se ejecutaban y el programa llegaba all.
-void old_textattr(int newattr) => Esta funcin, al igual que la anterior,
nicamente funciona en la plataforma DOS. Su finalidad era modificar los atributos del
texto mostrado por pantalla. Se han renombrado y posteriormente modificado para que
no haga nada, puesto que los atributos de texto en un entorno C++ builder funcionan de
otro modo.
-void old_gotoxy(int x, int y) => Nuevamente se est frente a una funcin
propia del sistema operativo DOS cuya utilidad es la de situar las coordenadas en un
punto determinado de la pantalla, algo totalmente improcedente en los formularios.
-void old_clrscr() => Al igual que las anteriores esta funcin proviene de la
funcin original clrscr() propia de DOS para limpiar la pantalla antes de presentar
datos por pantalla. En C++ builder se utilizarn otros mtodos para limpiar tanto
memos de informacin y de errores, como la ListBox y las Labels. Tambin esta
funcin ha sido renombrada para que no haga nada.
-int old_cprintf(char *c1,char *c2) => cprintf() es una funcin de DOS que
muestra datos por pantalla. Su funcionalidad no es vlida en un entorno C++ Builder,
con lo cual ha sido sustituida por old_cprintf y modificada totalmente. A esta funcin se
le pasan en este caso 2 punteros a carcter. Mediante la funcin sprintf() se copiarn
las cadenas de caracteres que son apuntadas por los punteros antes mencionados a la
cadena de caracteres llamada cadena. La funcin sprintf() tan slo se encarga de
copiar una cadena de caracteres a un string u otra cadena de caracteres.
-int old_cprintf(char *c1,int c2),
-int old_cprintf(char *c1,char*c2,char *c3),
-int old_cprintf(char *c1,char*c2,int i3,char *c4),
-int old_cprintf(char *c1,char*c2,int i3),
-int old_cprintf(char *c1,char*c2,char *c3,char *c4),
-int old_cprintf(char *c1,int i2,char *c3,char *c4),
-int old_cprintf(char *c1,char* c2,int i3,char *c4,int i5) => Estas siete
funciones realizan exactamente el mismo papel que la anterior, slo que a cada una le
pasamos los argumentos pertinentes dependiendo de los que les sean enviados a estas.

22
-int old_cprintf(char *c1) => Esta funcin escribe en el memo del formulario de
salida cadenas de caracteres. Por primera vez en esta funcin nos encontramos objetos.
FormSalida->Texto->Lines->Add(c1);
Por ejemplo en la lnea superior se ven los comandos necesarios para presentar por
formulario una cadena de caracteres. Cabe observar como la accin que se quiere
implementar recae sobre el ltimo fragmento de cdigo, en este caso:
Lines->Add(c1)
Pero a pesar de ello, se tiene que referirse a ella partiendo desde el conjunto ms
grande al que pertenece, en este caso el formulario Form2 que es el formulario
principal, pasando por los diversos elementos o conjuntos ms pequeos que tambin la
contienen y que a su vez estn contenidos (como todos los elementos) en un formulario
principal o global que es como ya se ha dicho antes Form2. En este caso el elemento
inmediatamente inferior al formulario principal Form2 es un memo cuyo caption
es Texto. Texto es un objeto de la clase TMemo y los objetos de esta clase poseen
una propiedad llamada Lines que a su vez es un objeto del tipo TStrings. Lines a
su vez tiene un mtodo (uno de los muchos que tiene) llamado Add(), que sirve para
aadir lneas de texto. En la siguiente figura se puede apreciar claramente este concepto:

Figura 10. Esquema de la jerarqua de estos objetos en concreto

23
 La diferencia entre un mtodo y una propiedad es que los mtodos son funciones
que se evalan cuando previamente se le han pasado unos argumentos, exactamente
igual que una funcin normal y corriente. En cambio, una propiedad es una variable
a la que directamente se le asigna un valor, por ejemplo la altura del texto que se
escribe. Cada clase de objeto tiene multiples funciones, mtodos y eventos. Un
evento es como un mtodo pero que se ejecuta como su propio nombre indica,
cuando se produce o provoca un evento o accin, por ejemplo hacer clic en un
formulario, cerrar un ventana, etc, en ese momento, se ejecutar la funcin que se
haya implementado para tal suceso.

-int old_cputs(const char *org) => Esta funcin mediante la funcin

strcpy() copia una cadena de caracteres que se le pasa como parmetro a otra
cadena (simplemente hace una copia), despus mediante la funcin strlen(org) se
averigua la longitud de la cadena, es decir, cuantos caracteres tiene incluido el
carcter final de lnea. Una vez hecho esto se asigna dicho valor a una variable de
tipo entero llamada ret. A continuacin volvemos a emplear la estructura de
cdigo:
FormSalida->Texto->Lines->Add(cadena);
Una vez ms la usamos para presentar por pantalla cadenas de caracteres.
A continuacin mediante el conjunto de comandos siguiente, se activa un mtodo del
tipo de objetos TMemo que nicamente se encarga de forzar al control para que
escriba lo que se le ha ordenado antes (es simplemente para asegurar). Finalmente
retorna el nmero de caracteres de que consta nuestra cadena mediante ret.
FormSalida->Texto->Update();
-char *old_gets(char *s) => Esta funcin hace referencia al formulario de entrada
y obtiene la informacin que le entra el usuario por teclado para que sea procesada
posteriormente.
Mediante la siguiente lnea de cdigo, se limpia el memo del formulario de entrada
de posible basura o de datos que se ha introducido anteriormente:
FormEntrada->Entrada->Text="";
En segundo lugar, con la lnea siguiente, lo nico que se hace es decirle al programa
que slo esa ventana o formulario est activo hasta que no introduzcamos los datos en
l, ya que de lo contrario podran producirse errores si el usuario intenta introducir datos
en otra ventana y adems el programa de todos modos no va a poder seguir su flujo de
ejecucin normal si no se introduce la informacin que requiere por el formulario
asignado por el programador para tal fin:
FormEntrada->ShowModal();
A continuacin tenemos la lnea que realmente copia la informacin que necesita
nuestro programa para procesarla posteriormente:
strcpy(s,FormEntrada->Entrada->Text.c_str());
En esta lnea se copia el ansistring que el usuario introduce por teclado a una
cadena de caracteres llamada s. La razn por la que se pone Text.c_str() y no
Text, es porque se trata de un ansistring y no de un string nornal y corriente. Un

24
ansistring es una cadena de caracteres, pero que adems en su cabecera contiene el
nmero de caracteres de dicha cadena excluyendo su carcter final de cadena (\0).
Finalmente se retorna la cadena copiada en s.
Naturalmente este formulario de entrada es el que se emplea en este caso para
introducir el nombre del fichero de extensin .asm.

2.-Funciones relativas al Linkador:

Ahora se pasar a explicar las nuevas funciones de entrada y salida del linkador. En
el linkador no se ha creado otro formulario de salida y otro de entrada. Ya que se ha
aprovechado el mismo que se ha creado para el ensamblador. La verificacin y
confirmacin de los mensajes, informacin, warnings, nmero de errores, etc del
programa final y definitivo se ha hecho comparndolos directamente con los obtenidos
en el formulario provisional de salida. Tambin se ha tenido en cuenta la posibilidad de
actualizacin posterior del linkador. En las funciones siguientes del linkador,
simplemente se han renombrado todas las funciones y se ha modificado el contenido de
las mismas para que impriman su nombre en el formulario de salida para confirmar que
el programa llega all donde se encuentran y no se atascan antes , entre medio o
despus. El motivo de su renombramiento y posterior modificacin es al igual que
ocurra con las funciones del ensamblador por causas de compatibilidad de los sistemas
operativos, ya que las funciones que haba antes son exclusivamente para DOS y no son
portables a un entorno Windows. Dichas funciones nicamente se encargaban de
aspectos grficos o estticos, de producir sonidos cuando suga algun error, etc. Dichas
funciones son las siguientes:

-void old_cco(unsigned char car, unsigned char atrib)

-void old_music(int a,int b)
-void old_rectan(int a, int b, int c, int d)
-void old_scr_cursoff()
-void old_top(int a,int c,int b)
-void old_vert(int a,int b,int d)
-void old_bot(int a,int c,int d)
-void old_scr_rowcol(int a,int b)
-void old_scr_curson()
-void old_int86()
-void old_marc(int le,int to, int ri, int bo, char s)
-void old_elimarc(int le,int to, int ri, int bo, char s)
-void old_puttext(int le,int to, int ri, int bo, char s)
-void old_window(int a,int b,int c,int d)
-void old_sedit(char cap,char str,unsigned char m)
-void old_scroll2(char c)
-void old_miss2(char s)
-void old_prom2()
-void old_cprint(char str,unsigned char atr )

25
 -void old_cfill(unsigned int a,unsigned int b,unsigned int
c,unsigned int d,unsigned char at)
-void old_rectan(int a, int b, int c, int d,char t, char at)
-void old_pit()
-void old_epit()

-menuprin.cpp

Este es el archivo asociado al formulario principal Form2. Es el ms importante en

cuanto a que contiene todas las funciones que se ejecutan cuando ocurre cualquier
evento en el formulario. Todo formulario, por el hecho de ser creado lleva asociado un
archivo de extensin .cpp donde se encuentran todas las funciones que hacen
referencia a dicho formulario. En el proyecto este formulario es el nico, ya que tanto
ensamblador como linkador se encuentran en la misma ventana y se pueden seleccionar
con tan slo presionar en sus solapas respectivas, pero puede darse el caso de que hayan
ms formularios con otras opciones o dedicados a otras tareas, en ese caso, hay que ir al
men del compilador y hacer clic en project, y seguidamente ir a opciones. Se
podr ver el siguiente cuadro de dilogo:

Figura 11. Algunas opciones del compilador

26
 En Main form se ha de introducir el nombre del primer formulario que ha de salir
por pantalla en momento que se ejecute el programa. En este caso se han creado varios
formularios teniendo en cuenta los formularios provisionales de entrada y salida, pero el
programa definitivo tan slo consta de uno principal.
A continuacin se pasa a explicar el contenido de este archivo:
En primer lugar se tienen los archivos de cabecera en la parte superior del archivo.
Como puede observarse se encuentran los archivos de extensin .h de los formularios
de salida y entrada provisionales y por supuesto el archivo old_io.h, ya que se
necesitarn las funciones de entrada y salida que se han implementado para los
formularios provisionales. Tambin es bsico para que no de errores el compilador,
incluir los fichero de cabecera tanto del linkador como del ensamblador ("ens.h" y
"linker.h") ya que se har alusin a algunas de las funciones contenidas en ellos.
Despus de las libreras se tiene la siguiente declaracin, en la cual definimos que
Form2 es un puntero a objetos de la clase TForm2:
TForm2 *Form2
Seguidamente se citan y explican las funciones del fichero:

-void __fastcall TForm2::Ens68000Click(TObject *Sender)

Es la funcin principal por excelencia. Al hacer clic sobre el control Ensambla se
ejecuta esta funcin. En primer lugar, mediante la siguiente lnea, se muestran
mostramos los mensajes pertinentes en el memo de salida provisional:
FormSalida->Show()
Show() es un mtodo de la clase TForm cuya funcin consiste en mostrar por
pantalla el contenido del formulario en cuestin. A continuacin viene la parte ms
importante de la funcin:

try
{
Form2->Memo2->Clear();
Form2->Memo1->Clear();
old_main(argc,argv);
}
catch(char *msg)
{
old_cprintf("FINAL ENS68K: %s\n",msg);
}

Siempre que se ejecuta el main asociado a un formulario se sigue este sistema.

Mediante try se indica que lo contenido entre sus corchetes tratar de ejecutarse y en
caso de que no fuera posible por causa de algn error, con el comando catch se
lanzara una excepcin al sistema para avisar de que ha acabado de ejecutarse el
programa con xito o bien algo ha ido mal. En este caso, try contiene entre sus
corchetes en primer lugar el mtodo Clear() para limpiar los memos del formulario
antes de que se ejecute el programa, por si hay algn resto de alguna ejecucin anterior.
A continuacin se intentar ejecutar el main, en este caso la funcin principal del
27
ensamblador contenida en el fichero ENS68K.cpp (por eso se ha incluido el fichero
de cabecera correspondiente a este archivo, ms arriba). Si se produjera algn tipo de
error, como por ejemplo una entrada de argumentos errnea por parte del usuario, etc
entonces se lanzara una excepcin como se ha dicho anteriormente. En este caso la
excepcin se producir por causas de un error e imprimira un mensaje en la pantalla
mediante la funcin renombrada old_cprintf, pero tambin puede producirse para
avisar al programador de que el programa ha finalizado con xito, como veremos ms
adelante conforme vayamos analizando el cdigo en profundidad.

-void __fastcall TForm2::Printf_Error(char* c1)

-void __fastcall TForm2::Printf_Error(char* c1)
-void __fastcall TForm2::Printf_Error(char* c1,char *c2)
-void __fastcall TForm2::Printf_Error(char* c1,char *c2,char *c3)
-void __fastcall TForm2::Printf_Error(char *c1,char*c2,int i3,char
*c4)
-void __fastcall TForm2::Printf_Error(char *c1,char*c2,int i3,char
*c4, int i4)
-void __fastcall TForm2::Printf_Error(char *c1,char*c2,int i3) => Todas
estas funciones se encargan de mostrar en el memo de errores los mensajes de
posibles errores. Todas poseen la misma estructura, lo nico que vara son los
argumentos que se les pasan. Mediante la funcin sprintf() se copia una cadena de
caracteres al string cadena, para posteriormente mostrarla en el memo mediante
la accin:
Memo1->Lines->Add(cadena)
Como ya hemos dicho anteriormente Add() es un mtodo de objetos de la clase
Tstring y acta como tal sobre strings. En este caso Memo1 es el nombre que se
le ha puesto al memo de errores para referirnos a l en el cdigo. No hay que
confundir Name con Caption, ya que el primero es el nombre con el que el
programa conoce a una variable a la hora de operar con l, etc y Caption es el nombre
que el usuario ve por pantalla si es que el tipo de objeto lo permite. En el caso del
memo no lo permite ya que se modifica en todo momento su contenido con los
mensajes que lanza el programa por pantalla.

-void __fastcall TForm2::Printf_mens(char* c1)

-void __fastcall TForm2::Printf_mens(char* c1,char *c2)
-void __fastcall TForm2::Printf_mens(char* c1,char *c2,char *c3)
-void __fastcall TForm2::Printf_mens(char *c1,char*c2,int i3,char *c4)
-void __fastcall TForm2::Printf_mens(char *c1,char*c2,int i3)
-void __fastcall TForm2::Printf_mens(char *c1,char*c2,int i3,char *c4,
int i4) => Estas funciones realizan exactamente la misma funcin que las anteriores,
pero con la particularidad de que escriben sobre el memo de informacin. En el
memo de informacin se muestran mensajes como el nmero de pasadas que se han
hecho al ensamblar, avisos sobre la reubicabilidad o no del cdigo en ensamblador, etc.
En este caso, Memo2 es el nombre del memo de informacin.

28
-void __fastcall TForm2::FuenteChange(TObject *Sender) => Mediante esta
funcin se copia simultaneamente el nombre introducido en la etiqueta del fichero
fuente, a los campos donde se debe introducir el nombre del fichero de destino y el de
listado. La razn de ser de esta funcin es porque normalmente los nombres de los
ficheros destino y listado suelen tener el mismo nombre que el fichero fuente. Sin
embargo, en caso de que el usuario deseara que los nombres de esos campos fueran
distintos a los del fichero fuente, podran cambiarlos posteriormente sin ningn
problema.
Destino->Text=Fuente->Text
Listado->Text=Fuente->Text

Para implementar dicha funcin, simplemente se hace que la propiedad Text de los
objetos de tipo TEdit, es decir, las etiquetas o labels adquieran el valor de la
propiedad Text de la etiqueta del fichero fuente.

-void __fastcall TForm2::FormResize(TObject *Sender) => Mediante esta

funcin se hace que el formulario del programa sea totalmente redimensionable.
Cuando se dice totalmente redimensionable, se hace refierencia a que no slo la ventana
en si es redimensionable, si no que los elementos u objetos contenidos en l tambin lo
son, puesto que no tendra mucho sentido lo contrario, y adems no quedara bien desde
el punto de vista esttico.
En primer lugar se definen 2 Offsets iguales, uno para el eje o componente X y
otro para el Y, que son las distancias desde los extremos del formulario hasta los memos
de informacin y de errores.
A continuacin mediante el siguiente comando, se est diciendo que si la propiedad
ActivePage del objeto Pestanas de la clase derivada TPageControl es igual a
Ens68K se activar la parte correspodiente al ensamblador.
if(Pestanas->ActivePage==Ens68K)
Del mismo modo, mediante la lnea siguiente, cuando presionamos la pestaa del
linker activamos esa parte:
else if(Pestanas->ActivePage==Linker)
A continuacin se define la altura del extremo superior del formulario a las etiquetas.
El resto de cdigo se encarga de adecuar las medidas de los formularios segn los
offsets que se han definido y la dimensin que le da el usuario al hacerla ms grande
o ms pequea. Dicha dimensin viene dada mediante ClientHeight y ClientWidth.
Ambas son propiedades del objeto Pestanas y hacen referencia al area que ocupa el
usuario con su ventana. Tanto la anchura como la altura viene dado en pixels.
Con la parte que se obtiene al hacer clic sobre la pestaa del linker, exactamente lo
mismo.

-void __fastcall TForm2::PestanasChange(TObject *Sender) => En esta

funcin se actualizan las partes segn se haga clic en una pestaa o en otra. En primer
lugar se selecciona, como en la funcin anterior. El ensamblador mediante la lnea de
comando:
if(Pestanas->ActivePage==Ens68K)

29
 En cambio el linkador lo seleccionamos mediante:
else if(Pestanas->ActivePage==Linker)
A continuacin en el cdigo contenido tras esas lneas de comandos, se asignan a los
memos de informacin y de errores de ambas partes otros nombres para que el cdigo
del programa principal pueda distinguir a los memos de errores y de informacin del
ensamblador por un lado:
Memo1=Memo1_Ens68K;
Memo2=Memo2_Ens68K;

y a los memos de errores y de informacin de la parte que hace referencia al

linkador por otro:
Memo1=Memo1_Linker;
Memo2=Memo2_Linker;
Esta funcin se ejecuta cada vez que presionamos en una de las pestaas y justo
despus de ejecutarse, mediante la lnea situada ms abajo, lo que hacemos es actualizar
la ubicacin de todas las etiquetas y memos a la posicin que posean justo antes de
cambiar de parte, ya sea de ensamblador a linkador o viceversa:
FormResize(this);
Si no estuviera este comando, al hacer clic sobre una de las pestaas para pasar a la
otra parte, se tendra que la situacin de las Labels sera la que haba al principio de
ejecutar el programa por defecto, y por tanto incorrecta ya que deben estar, tanto las
etiquetas como los memos en el mismo lugar donde se encontraban justo antes de
cambiar de parte.
El argumento this que contiene el ltimo FormResize hace referencia al formulario
principal. Tambin se podra haber puesto el nombre (Name) del formulario.

-void __fastcall TForm2::Linka1Click(TObject *Sender) => A continuacin

viene la funcin principal del linkador. Esta funcin se ejecuta cada vez que se presiona
sobre el control Linka del men que se encuentra en la parte superior formulario
principal.
En primer lugar mediante la siguiente lnea, escribimos en el formulario de salida
provisional:
FormSalida->Show();
Seguidamente y dentro de try, con los comandos que vienen a continuacin,
limpiamos los memos de ambas partes antes de que se ejecute la funcin principal:
Form2->Memo2->Clear();
Form2->Memo1->Clear();

Y finalmente ejecutamos el main:

main_link();
Si dentro de try se ha provocado alguna excepcin, como en este caso, el
comando catch se encargar de detectarla y mostrarla por pantalla. En este caso
mostraremos:

30
 old_cprintf("SE HA PRODUCIDO UNA EXCEPCION: %s\n",msg);
Como ya se ha dicho anteriormente, el hecho de que se lance una excepcin
mediante Throw (en el caso de C++ Builder) no significa que sea forzosamente fruto
de un error, sino que se trata simplemente de un aviso para indicar que se ha finalizado
con xito un programa, o bien tambin puede indicar que se ha producido un error.

-void __fastcall TForm2::objChange(TObject *Sender) => Esta funcin al

igual que en la parte del ensamblador, copia el nombre que se introduce en la Label
del fichero objeto al resto de campos, en este caso a las etiquetas que albergarn los
ficheros de extensin .s28 y .map. Los comandos, como se puede apreciar son los
mismos, con la diferencia de que son las etiquetas s28 y map las que copiaran el
nombre del fichero objeto introducido en su correspondiente Label:
s28->Text=obj->Text;
map->Text=obj->Text;

-void __fastcall TForm2::AnadirClick(TObject *Sender) => El programa,

al igual que el que haba para DOS est preparado para linkar ms de un fichero objeto.
Por ello se ha provisto al formulario de una ListBox donde se puedan aadir y
almacenar los sucesivos archivos de extensin .obj que se quieran aadir. Adems del
nombre del fichero, la ListBox tambin puede guardar la direccin de memoria donde
se quiere linkar el archivo. En caso de que el archivo en cdigo ensamblador sea
reubicable, es decir que su cdigo fuente en ensamblador (.asm) no posea la directiva
ABSOLUTE, por el memo de errores del linkador se instar a introducir la
direccin de memoria donde se desea linkar dicho fichero.
En primer lugar, se define un Ansistring llamado lnea. Despus se mira si se ha
introducido alguna direccin en la etiqueta dispuesta para ello, cuyo nombre es Edit1.
Para ello simplemente se mira la longitud del Ansistring introducido en Edit1. Si
dicha longitud es igual a 0, es decir, si no hay nada escrito, entonces simplemente se
escribir en la ListBox el nombre del fichero a linkar sin especificar la direccin de
memoria debido a que no es reubicable el fichero y por tanto su correspondiente archivo
.asm contiene la directiva ABSOLUTE:
if(Form2->Edit1->Text.Length()==0)
linea=Form2->obj->Text;
En caso de que no se cumpliera la condicin anterior, se ejecutara el siguiente
fragmento de cdigo:
else
{
long int posi;
sscanf(Form2->Edit1->Text.c_str(),"%lx",&posi);
linea=Form2->obj>Text+AnsiString("@")+AnsiString::IntToHex(posi,6);
}
Form2->ListObj->Items->Add(linea);
}
En l, como se puede observar, primero se declara una variable de tipo long int,
llamada posi, que indicar la posicin del carcter dentro del ansistring. Mediante

31
sscanf() se coge la posicin de memoria que se introducir en la etiqueta Edit1.
Seguidamente se almacenar en el ansistring linea, el nombre del fichero que se
quiere linkar junto con su posicin de memoria, separados ambos por una @ que
indica que el nmero que lleva pegado a ella es una direccin de memoria. En esa
misma asignacin se convierte la posicin de entero a hexadecimal mediante la funcin
IntToHex, ya que el ensamblador trabaja con este tipo de numeracin. Finalmente se
aade el ansistring linea a la ListBox.

-void __fastcall TForm2::kitarClick(TObject *Sender) => La siguiente y

ltima funcin de este archivo, se encarga de limpiar la ListBox en caso de que el
usuario desee linkar ficheros diferentes a los que ya haba introducido anteriormente.
Para ello simplemente asignamos una cadena vaca a la propiedad Items del objeto
ListObj.

b).Archivos relativos al Ensamblador

-ENS68K.cpp

Este es el mdulo principal del programa que hace referencia a la parte del
ensamblador. Desde aqu se llama a otros submdulos del ensamblador.
En primer lugar se tienen los archivos de cabecera en la parte superior. Entre ellos
estn old_io.cpp y menuprin.cpp que ya se ha comentado antes y que es donde se
encuentran todas las funciones de interfaz con el usuario entre otras. Tambin cabe
destacar la librera standard vcl.h (Visual Component Library), ya que en ella se
encuentran todas las funciones que hacen referencia a los elementos grficos, controles
y objetos que ya vienen creados en el entorno C++ Builder. Las libreras contenidas
entre <> son las que ya vienen implementadas y las que vienen entre son los archivos
creados por la persona que realice el proyecto y que contienen funciones que se
emplearn en este fichero.
Seguidamente se declaran las variables globales empleadas en este mdulo, algunas
de las cuales son inicializadas.
A continuacin se definen todos los posibles mensajes que se mostrarn en los
memos de error y de informacin dependiendo de los errores que tenga el archivo a
ensamblar o de los datos que introduzca el usuario por teclado. Dichos mensajes se
almacenarn en un array de punteros a carcter:
char *mensaje_ens68k[]
Despus se definen las funciones que se emplearn en este mdulo.
Ahora se pasar a explicar las funciones que conforman este fichero:

-int old_main(int argc,char *argv[]) => Luego viene ya el main o funcin

principal, la cual se ejecutar cuando se la llame desde el mdulo menuprin.cpp como
ya se ha dicho antes, haciendo clic en el control Ensambla. El main del
ensamblador ha sido renombrado a old_main para que no sea confundido con el
main del linkador, puesto que antes de ser fusionados en un solo mdulo, ambos
32
posean el mismo nombre. Como se puede apreciar, a esta funcin se le pasan 2
argumentos:
-int argc
-char *argv[]
el primero de ellos indica el nmero de argumentos y el segundo el argumento en s,
es decir los nombres o comandos que se introducirn. A diferencia de la versin que
haba para DOS, el presente programa se hace con esta informacin a travs de las
etiquetas que se han creado para introducir los nombres de los diferentes ficheros. En
concreto, la forma en la que se le dice cual es el nombre del fichero fuente es a travs de
la lnea de comandos:
strcpy(fuente,Form2->Fuente->Text.c_str());
Mediante strcpy() se copia el ansistring introducido en la etiqueta Fuente a una
cadena de cadena de caracteres llamada tambin fuente. Si al entrar el nombre del
fichero se produce algn error, entonces se lanza una excepcin para indicar que se ha
producido tal error:
if(!strlen(fuente))
{
old_clrscr();
copyr();
throw "ENS1";
}
Con el cdigo: !strlen(fuente) miramos si la longitud de la cadena introducida es
igual a cero, si es as se entrar en el bucle que lanza la excepcin. El throw sustituye,
como se explic brevemente al principio del proyecto, a exit() que es la manera de
lanzar una excepcin en DOS.
Seguidamente mediante las siguientes lneas de cdigo, lo que se hace es comprobar
si el usuario ha introducido la extensin del fichero, en este caso .asm. En caso de que
no lo haya hecho, se aade la extensin automticamente gracias a la funcin strcat():
if (!strchr(fuente,'.'))
strcat (fuente,".asm");
Para hacerse con el nombre que se le quiere dar al fichero objeto, se hace algo
similar, con la salvedad de que el nombre de la etiqueta de donde se consigue el
ansistring es la realizada para ficheros .obj:
strcpy(destino,Form2->Destino->Text.c_str());
Al igual como pasaba con el fichero fuente, en el fichero objeto se comprobar si el
usuario ha introducido la extensin correspondiente a ste. En este caso .obj:
if (!strchr(destino,'.'))
strcat (destino,".obj");
El resto de la funcin principal se encarga de realizar una primera pasada por el
ensamblador. El programa llena la tabla de smbolos y calcula la longitud de cada una
de las instrucciones mientras detecta posibles errores de sintaxis o labels mal situadas
o incorrectas.
Por el memo de informacin se avisar cuando se haya concluido la primera
pasada.

33
 En la segunda pasada se realiza la codificacin de las instrucciones. Como la tabla de
smbolos est completa, se resuelven las llamadas a las etiquetas. Si se da el caso de que
las etiquetas que no existan, stas se considerarn externas al mdulo y se prepararn
para resolverse en el linkador.
Al igual que antes se advertir de que ha tenido lugar una segunda pasada por el
memo de informacin del ensamblador.
Se tiene que tener en cuenta que al principio de cada pasada se inicializa el PC
(program counter), para pasar a contener la primera instruccin a ensamblar contenida
en el fichero .asm.
En esta segunda pasada se procede al tratamiento de las directivas. Es prcticamente
igual que en la primera pasada, con la salvedad de que ahora se graban en el fichero
objeto.

-static int lee_linea(char *s,FILE *ff) => Esta funcin lee una linea del
fichero que especifiquemos sin importar si la lnea acaba en \n o si acaba en \r\n. La
variable n limita el nmero de caracteres que se pueden leer por lnea. En este caso
n=255 como mximo.

-static void imprtitulo(void) => Esta funcin graba en el fichero de listado el

nombre del programa , el nmero de pgina y un ttulo que se puede especificar con la
directiva TITLE , en la cabecera de la pgina. Si no es la primera pgina saltar una.

-static int trans (char *entrada,char *salida,int *error) => Esta funcin
coge un string, que sern los parmetros de una directiva del tipo DC y los analiza
devolviendo otra cadena que sern una serie de dgitos hexadecimales
equivalentes a la cadena de entrada.

-static void mostrar_pantalla_ayuda() => Muestra ayuda por pantalla

-char *treutabs(char *sin,char *s) => Sustituye las tabulaciones por 8 espacios
para evitar caracteres indeseados en los old_cprintf, pero no modifica s para evitar
alterar las funciones que emplean punteros sobre s.

-void ini() => Esta funcin es bsica para que el programa ensamble tantas veces
como se quiera, ya que si se omite slo ensamblara bien la primera vez. Lo nico que
se hace en su interior es inicializar las variables que deben ser inicializadas con un
cierto valor justo antes de ejecutarse el programa.

-COPYR.cpp

En este archivo tan slo contiene una funcin:

-void copyr();

34
 cuya nica misin es mostrar en el memo de informacin un mensaje de
presentacin.

-TABLA.cpp

Este mdulo contiene el ensamblador de lneas y las tablas que utiliza ste,
conteniendo los nombres de los nemotcnicos , y otros valores necesarios para el
ensamblado. En este caso no se incluyen los archivos de cabecera de los componentes
visuales (vcl.h), ni el de funciones de entrada y salida, ni tampoco el que contiene las
funciones asociadas a nuestro formulario, debido a que todas las funciones contenidas
en este archivo son puramente relativas al funcionamiento del ensamblador en s. En
resumen, la misin de las funciones contenidas en este archivo es la decodificacin de
las instrucciones del motorola 68000.
A continuacin se definen las constantes que nos indicarn si un nemotcnico, un
direccionamiento o un tamao son incorrectos, el nmero de nemotcnicos
implementados, etc.
Seguidamente se definen las funciones empleadas, donde se encuentran todas las
instrucciones ensamblador del MC68000. Luego vienen dadas varias tablas donde se
encuentran los nombres de todas las instrucciones, los tamaos correspondientes a cada
instruccin, una tabla de valores y finalmente una tabla con el nmero de operandos que
puede tener cada instruccin y otra con la longitud que pueden tener dichos operandos.
A continuacin, despus de declarar todas las variables globales vienen las funciones
implementadas:

-int decodifica(char *s,char *e) => La funcin decodifica es un ensamblador de

lneas. Devuelve el error cometido como resultado de la funcin y el ensamblado nos
devuelve la lnea ensamblada. En la variable global segunda_pasada se debe
especificar si estamos en la primera o en la segunda pasada.

-int buscar_tabla() => Esta funcin busca en la tabla de instrucciones la instruccin

correspondiente a un numero dado.

-procesar(int (*f) ()) => A esta funcin simplemente se le pasa como argumento
un puntero a funcin que devuelve un entero y nos devuelve exactamente lo mismo.

-static int
tipo1(void),add(void),adda(void),addi(void),addq(void),and(void),
andi(void),asr(void),bra(void),bchg(void),chk(void),neg(void),
cmp(void),cmpm(void),nbcd(void),endd(void),eor(void),equ(void),
exg(void),ext(void),exter(void),glob(void),jmp(void),lea(void),

35
link(void),move(void),movea(void),movem(void),movep(void),
moveq(void),page(void),nada(void),or(void),org(void),rel(void),
stop(void),sub(void),swap(void),title(void),trap(void),unlk(void),
abso(void),dc(void),ds(void),dbcc(void),scc(void),high(void),low(voi
d) => Todas estas funciones se encargan de decodificar las instrucciones del
MC68000 y buscar en las tablas el nmero de operandos, su longitud, la longitud de
las diferentes instrucciones, etc.

-static void invertir (char *) => Invierte la mscara de registros en los

direccionamientos en que es necesaria esta inversin.

-static int mascara(char *,char *linea) => Crea la mscara de registros en la

instruccin MOVEM y devuelve si ha habido algn error 35 que es el error en la lista
de registros.

-static void opp_a_op(void) => Esta funcin actualiza el valor de los operandos,
dndoles los valores que se les hayan introducido en el programa en ensamblador.

-FUNC.cpp

Este mdulo contiene una serie de funciones de apoyo para el ensamblador de lineas,
para extraer operandos, nemotcnicos y para descifrar los operandos y codificarlos. Al
igual que en el archivo anterior, aqu tampoco se citarn el archivo de cabecera que
contiene los componentes visuales ni los que contienen las funciones de interfaz con el
usuario o las relativas directamente a nuestro formulario.
A continuacin se pasa a explicar cada una de las funciones que conforman este
archivo:
-char *coger_palabra(line,palabra,label) => Esta funcin devuelve en
palabra la primera palabra de una linea, en linea la posicin dentro de la lnea donde
empezar a buscar los parmetros la funcin correspondiente, y finalmente label dice
si lo que ha encontrado es una label o no. En size devuelve 1 si la instruccin es
de tamao byte, 2 si es de tamao word y 3 si es de tamao long word. Si no se
ha especificado un tamao devuelve 4 y si hay un error size pasa a valer 16. Cabe
destacar que una etiqueta no debe llevar ningn punto.
Lo que hace en primer lugar esta funcin es elimar espacios, despus una vez llega a
una palabra, se hace con ella y lo primero que hace es comprobar si es una etiqueta o es
cualquier otra instruccin. En caso de que efectivamente sea una etiqueta la funcin
habr finalizado su tarea, de lo contrario, si se trata de una instruccin, la funcin
averiguar el tamao de la misma. Finalmente se hace que line apunte a la prxima
palabra de la lnea.

36
-char *cogeyanal(line,err,externo,aa) => La funcin cogeyanal devuelve
como resultado un apuntador al prximo carcter despus del operando y en err el
error cometido. En operando quedar el operando que se anda buscando. En aa
quedar el tipo de direccionamiento que utiliza.
El tipo de direccionamiento puede ser:
1 = Registro direcciones
2 = Ind registro e indice
3 = Inmediato
4 = Registro Indirecto
5 = Predecremento
6 = Postincremento
7 = Registro datos
8 = Relativo al PC
9 = Relativo al PC con ndice
10= Registro Ind. con offset
11= Direccin absoluta
12= CCR
13= SR
14= USP (+error =8)
En primer lugar la funcin mira si la instruccin contiene algn operando. A
continuacin, segn si lleva o no parntesis descartar unos modos de direccionamiento
u otros o si se introducen ms parntesis de los necesarios, en cuyo caso emitir un
error. Adems tambin se buscan posibles errores de sintaxis, se mira si un operando es
o no un registro y se vigila que los tamaos de los operandos sean los correctos.

-static struct operando registro (char *reg,int l) => Mira si hay datos en
el registro y el tamao que tienen estos, ya sea byte, word o long word.

-int tipo2(valor,aa,ensamblado,operando) => En esta funcin se va copiando a

un array de punteros a carcter los valores que se van ensamblando.

-int tipo3(valor,aa,ensamblado) => En esta funcin exactamente igual que en la

anterior, slo que ahora se miran los tamaos de las etiquetas de nuestro archivo .asm
para vigilar que no ocupen ms memoria de la que deberan.

-int masde4bits(a),
-int masde8bits(a),
-int masde16bits(a) => Mediante estas 3 funciones se identifica el tamao de los
operandos.

37
-long int hexdec(expresion,err) => Esta funcin se encarga de convertir valores
de hexadecimal a decimal, ya que las direcciones de los registros y datos vienen
codificadas de esa manera.
-long int bindec(expresion,err) => Esta funcin se encarga de convertir valores
de binario a decimal, puesto que el usuario o programador puede introducir las
direcciones directamente en binario poniendo previamente al nmero el smbolo #.

-ARBOLES.cpp

Este mdulo contiene las funciones de manejo de los rboles binarios utilizados en
este ensamblador para almacenar y recuperar las etiquetas , sus valores y el tipo de
etiqueta que es. Tampoco en este caso se incluyen las libreras visuales ni los archivos
que contienen las rutinas de interfaz. En la declaracin de variables, se puede apreciar
que en:
static char ti[][24]
se almacenan los mensajes que se pueden presentar por el memo de informacin
del ensamblador relativos a las etiquetas.
A continuacin se explican las funciones contenidas en este archivo:
-struct arbol *buscar_rama(struct arbol *a,char *label) => Esta funcin
busca dentro de una estructura de rbol binario, en el cual se tendrn las etiquetas del
programa, una determinada etiqueta, devolvindonos un puntero a la rama que estamos
buscando. Se trata de una funcin recursiva. Esta funcin es llamada cada vez que es
necesario recuperar el valor de una etiqueta.

-void eliminar_rama(a,label) => Esta funcin elimina de una estructura de rbol

binario donde se tendrn las etiquetas del programa una determinada etiqueta. Esta
funcin es llamada por las funciones equ, high y low del mdulo TABLA.cpp
cuando no se puede resolver el valor de una etiqueta.

-struct arbol *insarbol(struct arbol *r,struct arbol *a,char

*label,int *error,long int dato,int tipodevariable) => Esta funcin inserta
dentro de una estructura de rbol binario, en la que se tendrn las etiquetas del
programa una determinada etiqueta, devolvindose un puntero a la raz del rbol. Es una
funcin recursiva.

-void listar_arbol (a,i) => Esta funcin inserta dentro de una estructura de rbol
binario, en la que se tendrn las etiquetas del programa, una determinada etiqueta,
devolvindose un puntero a la raiz del rbol. Al igual que en el caso anterior, se trata de
una funcin recursiva.

38
-PARSER.cpp

Este mdulo contiene un parser del tipo recursivo descendente para descifrar y
evaluar expresiones matemticas y lgicas con nmeros en binario, decimal y
hexadecimal as como con etiquetas previamente definidas.
Tampoco esta vez se declaran las libreras de componentes visuales ni los archivos
de cabecera con las funciones de entrada/salida (I/O). Luego se declaran las variables
globales y las funciones empleadas en este mdulo.
A continuacin se pasa a explicar dichas funciones:

-static void coger_expresion(resultado) => Esta es la funcin a la que se llama

para resolver una expresin. Es llamada por la funcin hallar_valor() que
inicializa el PARSER y lo prepara para funcionar correctamente.

-static void nivel1(resultado),

-static void nivel2(resultado),
-static void nivel3(resultado),
-static void nivel4(resultado),
-static void nivel5(resultado),
-static void nivel6(resultado) => Estas funciones evalan trozos de la
expresin a evaluar teniendo en cuenta los niveles de prioridad del lgebra.

-static void primitiva(resultado) => Esta funcin utiliza las variables globales
tipo_termino y termino para hallar el valor de termino. La variable
tipo_termino debe ser o VARIABLE o NUMERO , sino es as hay un error de
sintaxis en la expresin.

-static void arit (o,r,h) => Esta funcin realiza una operacin especificada en la
variable o sobre los trminos r y h. Esta operacin debe ser una de las operaciones
vlidas implementadas en este PARSER.

-static void unitario (o,r) => Esta funcin se utiliza para implementar el "NOT"
lgico y el cambio de signo.

-static void coger_termino() => Esta funcin se encarga de extraer uno a uno los
trminos que forman la expresin a evaluar. Extrae los trminos de la expresin
almacenada en p y los coloca en termino.

39
-static esdelimitador(c) => Esta funcin devuelve un 1 si el carcter que se le
pasa es un delimitador, y un 0 si no lo es.

-long int hallar_valor (palabra,longitud,err,reubicable,externo) => Esta

funcin es la funcin principal del PARSER ya que es la funcin a la cual se llama
para resolver una expresin desde el exterior de este mdulo. Se encarga de llamar a las
distintas funciones del PARSER y de devolver el valor, mensajes y errores.

-static long int valor (puntero) => Esta funcin halla el valor de un smbolo y
el tipo de smbolo que es.

-ERRORES.cpp

Este mdulo contiene los mensajes de error del ensamblador. En este caso puede
verse como s que contiene las libreras de componentes visuales (vcl.h) as como el
archivo que contiene las nuevas funciones de entrada/salida, ya que se emiten mensajes
en los memos y finalmente la que hace referencia al formulario, ya que los mensajes
saldrn en un objeto contenido en l. La variable que almacena estos mensajes es un
array de punteros a carcter:
*terror[]
Tan slo contiene la funcin:
-void error(tipo) => Esta funcin se llama cada vez que el ensamblador encuen-
tra un error y nos muestra una descripcin del error cometido por la pantalla. Cada vez
que se llama a esta funcin se incrementa la variable global errores que contiene el
nmero total de errores cometidos durante el ensamblado. Cabe destacar adems que
mediante, las lneas siguientes, se muestran los mensajes de error por el memo de
errores del ensamblador:
Form2->Show();
Form2->Printf_Error("** %s **\n\r",terror[tipo+idioma*NE]);

b).Archivos relativos al Linkador

-LINKER.cpp

Este es el mdulo principal del programa que hace referencia a la parte del linkador.
Desde aqu se llama a otros submdulos del linkador.
En primer lugar se tienen los archivos de cabecera en la parte superior. Entre ellos
estn old_io.cpp y menuprin.cpp que ya se ha comentado antes y que es donde se
encuentran todas las funciones de interfaz con el usuario entre otras. Tambin cabe
destacar la librera standard vcl.h (Visual Component Library), ya que en ella se
encuentran todas las funciones que hacen referencia a los elementos grficos, controles
y objetos que ya vienen creados en el entorno C++ Builder.

40
 A continuacin se declaran las variables globales y las funciones empleadas. Una de
las variables es la siguiente:
char *mensaje_linker[]
Se trata de un array o vector de punteros a carcter que almacenan las direcciones
donde se encuentran los mensajes tanto de informacin como de posibles errores del
linkador.
Seguidamente se describen todas las funciones que componen este mdulo:

-int main_link() => Es la funcin principal del linker y se ejecutar cuando se la

llame desde el mdulo menuprin.cpp como ya se ha dicho antes, haciendo clic en el
control Linka. Tambin aqu ha sido renombrada la funcin principal para que no sea
confundida con el main del ensamblador.
En primer lugar, la variable a que es del tipo register int, toma el valor que le
pasa la funcin coger_fichero() y es en esta funcin donde se consigue el nombre del
fichero que se desea linkar. coger_fichero() es la funcin contigua a la presente, y se
estudiar posteriormente en profundidad. Si la funcin coger_fichero(), la cual retorna
un entero, le devuelve un entero diferente de 0, entonces significa que no ha habido
errores. A continuacin la funcin mira si es reubicable el fichero de extensin .asm.
Si es reubicable y el usuario no le ha introducido ninguna direccin donde linkarlo, el
programa mostrar en el memo de informacin del linkador un warning o aviso al
programador, para que introduzca una direccin de memoria. La variable pos es la
que contiene el valor de dicha direccin, y la funcin cogerposicion() la que se lo
proporciona. Si de lo contrario el fichero .asm posee la directiva ABSOLUTE,
entonces el programa no pedir al usuario ninguna posicin de memoria.
Mientras no hay ningn error en la entrada de los datos, es decir, mientras a
contenga un entero distinto de 0 y la longitud de la cadena entrada (el nombre de
nuestro fichero objeto) sea diferente de 0, el programa seguir pidiendo nombres de
fichero para linkar. En la presente versin para C++ Builder los datos son introducidos
primero en la Label o etiqueta correspondiente al fichero objeto, y posteriormente
mediante el control Aadir se introduce en la ListBox.
Luego el programa se hace con todas las etiquetas tanto globales como locales y
externas, y asigna un valor absoluto a las etiquetas reubicables. Despus comprueba que
no estn repetidas.
Si se produce algn error al ejecutarse el proceso, se lanza una excepcin mediante
Throw para indicar que hay algo incorrecto o que ha acabado exitosamente la
ejecucin.
Seguidamente se lee del fichero .asm y se sustituyen las etiquetas no resueltas en el
ensamblador. Inmediatamente despus se crea el fichero de destino cuya extensin es
.s28.

-int cogerfichero(f,tipo) => Mediante esta funcin se coge el nombre de los

ficheros. Se estudia la variable tipo que puede tener los valores 0, 3 4.
Si tipo== 0 se trata de un fichero de extensin .obj.
Si tipo== 3 se trata de un fichero de extensin .s28.

41
 Si tipo== 4 se trata de un fichero de extensin .map.
Esta parte se ha implementado mediante un switch:

switch (tipo)
case 0: if(indice_obj+1>Form2->ListObj->Items->Count)
*f=0;
else
{
AnsiString todo=Form2->ListObj->Items->Strings[indice_obj];
AnsiString dato;
int posarroba=todo.AnsiPos("@");
if(posarroba==0)
dato=todo;
else

dato=todo.SubString(1,posarroba-1);
strcpy(f,dato.c_str());
indice_obj++;
}
break;
case 3: strcpy(f,Form2->s28->Text.c_str());
break;
default: strcpy(f,Form2->map->Text.c_str());
}

En primer lugar se mira si se han acabado de coger los diferentes nombres de los
ficheros a linkar en la ListBox. Para ello se observa cual es el ndice actual de la
ListBox, es decir, se averigua por qu Item va, y se compara con el nmero de
Items totales de la ListBox para ver si ha acabado. Si es as, el contenido del
puntero *f se inicializar a 0 para la prxima vez que se linke.
Si no es as, es decir si se tiene la lnea de ms abajo, entonces significa que el
programa no ha terminado de coger el nombre de todos los ficheros de la ListBox:
indice_obj+1<Form2->ListObj->Items->Count
Items es una propiedad de objetos del tipo TListBox, la cual a su vez posee
distintas propiedades para manipular los strings o cadenas de caracteres contenidos en
la ListBox. Count es una de las propiedades de Items e indica el nmero de
strings totales que posee una ListBox.
Si el programa no ha terminado de coger los nombres de todos los ficheros de la
ListBox entonces mediante la siguiente lnea de cdigo, se coge todo el ansistring
de la ListBox que toque en ese momento:
todo=Form2->ListObj->Items->Strings[indice_obj]
todo es un objeto de la clase ansistring. A continuacin se mira si el ansistring
actual contiene el carcter @. En caso de que el fichero .asm sea reubicable, el

42
ansistring de la ListBox contendr una @ a causa de la funcin que se ha
implementado anteriormente contenida en el archivo menuprin.cpp. Si contiene la
@ mediante la siguiente lnea de cdigo, se conseguir el ndice o la situacin donde
se encuentra dicho carcter:
posarroba=todo.AnsiPos("@")
Ansipos es un mtodo de objetos de la clase ansistring que retorna la posicin
de un determinado carcter que contiene un ansistring. Si dicho carcter no est
contenido en el ansistring entonces retornar un "0". Si no encuentra la @ significa
que el usuario no ha insertado una posicin de memoria donde ensamblar el fichero, en
cuyo caso el programa nicamente se har con el nombre del fichero asignando al
tambin ansistring dato el ansistring todo. Sin embargo, si el ansistring
todo si que contiene el carcter @ mediante la siguiente lnea de cdigo, se coge el
nombre del fichero.
dato=todo.SubString(1,posarroba-1)
Substring es otro mtodo de los objetos de la clase ansistring que coge un
substring existente dentro de otro ansistring. En esta parte slo coge el nombre del
fichero y no la posicin de memoria. Lo que indica que substring se coge dentro del
ansistring es la posicin de inicio y de final, en este caso la posicin inicial es el
primer carcter y la final, una posicin justo antes de la @ con lo cual abarca todo el
nombre del fichero .obj.
Finalmente a partir de los siguientes comandos, se copia el ansistring
dato.c_str() que contiene el nombre del fichero a la variable f y luego se incrementa
el ndice indice_obj para que el siguiente elemento de la ListBox sea procesado:
strcpy(f,dato.c_str());
indice_obj++;
Si el usuario introduce una posicin de memoria, sta se procesa en la funcin:
void __fastcall TForm2::AnadirClick(TObject *Sender)
como ya se ha explicado en el apartado referente a las funciones de las que se
compone el archivo menuprin.cpp.
En las otras opciones que componen nuestro switch:
case 3: strcpy(f,Form2->s28->Text.c_str());
break;
default: strcpy(f,Form2->map->Text.c_str());
simplemente se copian los ansistrings que contienen los ficheros .s28 y .map a
las variables corespondientes con las que trabaja el programa a la hora de procesar dicha
informacin.
Seguidamente se asigna a la variable i el nmero de caracteres que contiene el
ansistring, es decir, la longitud del nombre del fichero. Si i igual a 0, en la versin
para DOS se sala del bucle infinito, es decir, ya no segua pidiendo nombres el
programa.
A continuacin, en el trozo de cdigo siguiente, mediante la funcin strchr() se
busca el carcter . en la cadena f, y si no la encuentra le concatena o aade la
extensin .s28 a partir de la funcin strcat().
if (!strchr(f,'.'))
strcat (f,".S28");

43
 Es decir, que si el usuario no introduce la extensin, sta es aadida automticamente
por el programa. En el ejemplo de arriba era el caso que haca referencia a ficheros de
extensin .s28; pero tambin se hace esto con los otros 2 tipos de ficheros de la forma
siguiente:
if (!strchr(f,'.')) strcat (f,".MAP")
if (!strchr(f,'.')) strcat (f,".OBJ")

Luego, mediante la funcin siguiente, se busca en una lista los diferentes archivos
.obj a linkar y se mira que no haya ninguno repetido:
buscarlista(ficheros,f)
El resto de cdigo de la funcin principal se encarga de linkar dichos ficheros.

-long int cogerposicion() => Esta funcin es la que coge la posicin de

memoria en caso de que el fichero sea reubicable.
En primer lugar, mediante la linea de cdigo siguiente, asignamos al ansistring
todo todo el ansistring que se encuentre en la posicin de la ListBox que toque:
todo=Form2->ListObj->Items->Strings[indice_obj-1]
Seguidamente a partir de:
posarroba=todo.AnsiPos("@")
se averigua la posicin donde se encuentra el carcter @ el cual queda almacenado
en la variable posarroba.
Si no contuviera la @ dicho ansistring, es decir, si el mtodo Ansipos()
devuelve un 0, entonces se mostrara por el memo un mesaje de error, advirtiendo de
que ese fichero no es reubicable y a continuacin se lanzara una excepcin mediante
throw y se imprimira el texto: LINK3 el cual identifica a dicha excepcin.
Sin embargo, si se encuentra el carcter @, entonces primero se averigua la
longitud de la posicin, es decir, los caracteres que ocupa. Para ello se resta a la
longitud total de la cadena, la longitud que hay desde el primer carcter de todo el
ansistring hasta donde se encuentra la @, sta inclusive, y de esta forma lo que
queda es la longitud del substring que contiene la posicin de memoria y que ser
almacenada en la variable longdato.
Finalmente mediante el mtodo Substring() se almacena en el ansistring dato,
la posicin de memoria. La variable longdato dice el nmero de caracteres que se
deben coger de todo el ansistring.

-long int hexdec(expresion) => Esta funcin convierte un nmero de hexadecimal

a decimal, y hace referencia a las posiciones de memoria que se utilizarn para linkar,
ya que stas vienen en hexadecimal por defecto.

-int buscarlista(struct lista *lista,char *fichero) => Esta funcin se

llama en la funcin principal del linkador y se encarga de buscar los ficheros a linkar,
como ya se ha dicho anteriormente.

44
-void insertarabs(e) => Esta funcin tiene por misin hacer que un archivo
reubicable se convierta en absoluto en la direccin que haya introducido el usuario en la
Label correspondiente.

-void insertarreu(e) => Esta funcin realiza la misma funcin que la anterior, pero
con ms de un fichero, es decir los ubica a todos a partir de la direccin que introduzca
el usuario.

-void listar(l) => Esta funcin simplemente se encarga de listar todos los ficheros a
linkar.

-int insertar_etiqueta(r,etiqueta,valor) => Inserta etiquetas en los archivos,

como su propio nombre indica.

-void listar_arbol (a) => Lista el rbol de ficheros a linkar.

-void comprobar_externas (a) => Esta funcin comprueba etiquetas externas, es

decir, por ejemplo puede ocurrir que en un archivo .asm en cierta zona del cdigo, se
quiera saltar a una etiqueta externa a ese cdigo, es decir, perteneciente a otro archivo
que tambin se va a linkar.

-struct etiqueta *buscar_etiqueta(struct etiqueta *a,char *etiqueta) =>

Esta funcin simplemente busca etiquetas en archivos.

-void sexit() => Esta cadena finaliza la funcin mostrando el copyright. Esto en la
versin anterior para DOS, ya que ahora ya no ocurre eso.

-void nexit(int ne, char mis[]) => Esta funcin es la opuesta a la anterior, ya
que sale del programa pero lanzando una excepcin mediante throw, que en este caso
avisa de que se ha producido algn error. Para que podamos identificar esta excepcin y
diferenciarla de las dems, se imprimir: ENS1.

-int esta_en (c,s),

-void s28(s),
-void volcars28(),
-int checksum(char *a) => Son funciones para DOS que realizan operaciones
sencillas tales como retornar el valor que se les pasa, comprobar si el nombre de un
fichero posee la extensin .s28, volcar un nombre de fichero, etc.

45
-Subf2.cpp

Este fichero nicamente contiene funciones exclusivamente para DOS, e intiles para
el nuevo entorno. Simplemente se ocupan del entorno grfico y la presentacin
mediante la creacin de marcos, etc. Tambin hay implementadas pequeas funciones
que mediante la funcin Sound() emiten un sonido para indicar que se ha producido
algn error, pasndoles como argumentos la frecuencia a la que queremos que suene y
la duracin de tal sonido. Tampoco este ltimo tipo de funciones sirve con C++ Builder.
Lo nico que se ha hecho una vez ms es renombrarlas y hacer que muestren por el
memo provisional de salida su nombre, para comprobar que efectivamente el
programa llega all.
A continuacin se citan:

-marc(le, to, ri, bo, s) => Crea marcos de presentacin.

-elimarc(le, to, ri, bo, s) => Elimina dichos marcos.
-int old_sedit(cap,str,m) => Esta funcin edita por sustitucin, un string
aceptando entradas segn un parmetro pasado.
Donde:
0 => ASCII
1 => HEXA
2 => NUMERIC
-scroll2(c),
-miss2(s),
-rom2(),
-cfill(a,b,c,d,at) => Estas 4 funciones son nicamente de video, y son exclusivas
de DOS.

-pit() => Emite un sonido en caso de error.

-epit() => Realiza la misma funcin que la anterior.

-old_rectan(a,b,c,d,t,at),
-old_top(x1,x2,y),
-old_bot(x1,x2,y),
-old_vert(x,y1,y2) => Estas 4 funciones tan slo realizan funciones grficas
exclusivas de DOS.

46
-Copyrlink.cpp

Este archivo contiene nicamente una funcin que muestra el copyright:

-copyrlink().

-Parserl.cpp

Este archivo contiene funciones utilizadas a la hora de linkar los ficheros .obj.
Simplemente realizan sencillas operaciones aritmticas o lgicas.

-static void coger_expresion(long int *) => Coge una expresin y la procesa.

-static void nivel1(long int *) => Esta funcin hace la OR y la XOR lgicas.

-static void nivel2(long int *) => Esta funcin hace la AND lgica.

-static void nivel3(long int *) => Esta funcin suma o resta 2 trminos.

-static void nivel4(long int *) => Esta funcin multiplica o divide.

-static void nivel5(long int *) => Esta funcin realiza el + o unitario y la

negacin lgica Not.

-static void nivel6(long int *) => Se emplea para las expresiones quie vienen
dadas entre parntesis.

-static void primitiva(long int *) => Realiza pequeas operaciones aritmticas

para comprobar si un fichero es reubicable o de lo contrario es ilegal su ubicacin.

-static void arit (char ,long int *,long int *)

-static void unitario (char,long int *)

-static void coger_token(void)

-static esdelimitador(char)

-static long int valor(char *) => Retorna el valor de un puntero.

47
-static int esta_en (char,char *)

-long int hallar_valor (palabra,err)

-struct etiqueta *buscar_etiqueta_local(etiqueta *a,char *etiqueta) =>

Como su propio nombre indica se encarga de buscar una determinada etiqueta en un
archivo en concreto que se desea linkar.

-int buscar_etiqueta_global(a,etiqueta) => Al igual que la anterior, busca

etiquetas, pero no slo en un archivo en concreto, sino en todos los que se desea linkar.

48
2 Presupuesto

Material Cantidad Precio/Unidad Total (ptas)

(ptas)
Compilador para 1 35.583 35.583
C++ Builder Standar

Trabajo Cantidad (horas) Precio/Hora (ptas) Total (ptas)

Horas de 120 4.000 480.000
programacin

TOTAL 515.583

49
3 Conclusiones

La realizacin de este proyecto era necesaria desde un punto de vista de

compatibilidad con la mayora de los sistemas, puesto que la gran mayoria utilizan en la
actulidad sistemas operativos tipo Windows de Microsft en sus diferentes versiones. El
programa del proyecto es portable y funciona sobre cualquier plataforma Windows.
Adems tiene la ventaja de que al ser Windows un sistema operativo multitarea, se
pueden tener multiples tareas en activo adems del presente programa.
Otra particularidad a destacar es que se ha fusionado en una sola ventana 2
aplicaciones de gran importancia desde un punto de vista operativo, puesto que tanto el
ensamblador como el linkador se encuentran en la misma ventana o formulario
principal, lo cual facilita enormemente el pasar de uno a otro. Para pasar de uno a otro,
simplemente debemos hacer clic en su ventana correspondiente. El hecho de que ambos
elementos se encuentren implementados en el mismo entorno no es casual, ya que en un
futuro prximo se pretende fusionar todos los elementos que constituyen las
herramientas bsicas de simulacin, programacin e interface del MC68000 de
motorola con el PC. Se integrarn admas de los 2 que configuran este proyecto, el
SIM68K, que constituye el software de simulacin, y finalmente el ITF68K que
constituye el software de comunicaciones.
El hecho de que se haya elegido el lenguaje C++ Buider se basa en mltiples
razones. Entre ellas cabe destacar que es un lenguaje que ha heredado toda la potencia
del C y la posibilidad de programar en cierta medida a bajo nivel, y del C++ la
posibilidad de programar en modo orientado a objetos, lo cual facilita enormemente la
programacin ya que tenemos la alternativa de crear estructuras como hacamos antao
en C, pero con la posibilidad de insertar funciones en su interior. Finalmente, adems de
esas capacidades, el C++ Builder posee multitud de clases ya creadas que facilitan en
gran medida la creacin de aplicaciones medianamente complejas para Windows en
poco tiempo. Este tipo de programacin se ha standarizado y ha pasado a denominarse
Programacin Orientada a Componentes (POC). Ejemplos de dichas clases ya creadas
pueden ser los que hemos utilizado bsicamente en el proyecto: formularios, labels o
etiquetas, mens, listbox, y un largo etc.
En resumen se ha realizado una adaptacin de ambos programas, linkador y
ensamblador, a C++ Builder siguiendo todo un proceso que garantizara que no hubiera
errores. El cdigo original se ha intentado modificar lo menos posible, aunque esto ha
sido inevitable a la hora de modificar las funciones de entrada/salida o interface con el
usuario. Por supuesto todos los archivos que hacen refencia al nuevo entorno creado
para Windows han tenido que ser creados en su totalidad puesto que las plataformas de
DOS y Windows son totalmente distintas en cuanto al modo de tratar la informacin de
entrada y salida y sobretodo a la hora de procesar los eventos, como se ha explicado al
principio de l proyecto.
En el proceso seguido para elaborar el proyecto al que se acaba de hacer referencia,
se han seguido varias pautas. En primer lugar se han identificado las funciones de la
versin para DOS que no seran portables a la nueva plataforma Windows. Entre dichas
funciones se han diferenciado principalmente 2 tipos: unas, las cuales su ausencia no
provocara error alguno en el funcionamiento de la nueva versin, debido a que eran
exclusivas de DOS y simplemente tenan la funcin de crear un entorno grfico para
presentaciones por pantalla a partir de marcos, etc o de emitir sonidos para advertir de

50
que se ha producido algn error ya sea por la introduccin errnea de los datos por el
usuario o por el propio programa; y en segundo lugar las funciones de entrada y salida
que hacen posible la interaccin con el usuario. Estas ltimas consisten bsicamente en
funciones encargadas de coger los nombres de los ficheros a linkar o ensamblar, de las
etiquetas dispuestas para ellos, de conseguir la posicin la posicin de memoria donde
se desea linkar dichos archivos, de mostrar a travs de los memos del formulario
principal los errores o warnings que se han producido, etc.
Despus de esta primera fase de reconocimiento, se ha pasado a renombrar las
funciones que se comentaba antes. Algunas han sido simplemente renombradas y otras
renombradas y completamente modificadas.
El primer tipo de funciones para DOS al que se ha hecho referencia antes, las cuales
en realidad no tienen ninguna utilidad para el nuevo entorno creado, se han conservado
por diversas razones: en primer lugar lo que se ha hecho con estas funciones es hacer
que muestren su nombre por un formulario provisional de salida, de esta forma se poda
comparar y verificar que los mensajes que salan en nuestro formulario final y definitivo
eran correctos, y en segundo lugar, como ya se ha dicho anteriormente, se pretende
realizar un macroensamblador a partir de este proyecto, con lo cual dichas funciones
resultarn muy tiles.
El segundo tipo de funciones, son bsicas para el interface con el usuario. Estas no
slo han sido renombradas sino que en la mayora de los casos, ntegramente
modificadas. Por poner un ejemplo en las funciones principales del ensamblador y el
linkador contenidas en los ficheros ENS68K.cpp y Linker.cpp se encuentran los
cdigos encargados de hacerse con los nombres de los ficheros a linkar o ensamblar. En
ambos casos esto se haca por teclado. Antes de proceder a su modificacin para su
posterior adaptacin, se ha estudiado detalladamente el proceso y camino de estos datos
por parte de la versin para DOS. Finalmente se han adaptado y acondicionado para que
pudieran ser compatibles con C++ Builder.

51
 4 Pliego de Condiciones

4.1. GENERALIDADES

4.1.1. CONDICIONES GENERALES.

El presente pliego de condiciones tiene como objetivo definir a la empresa

programadora el alcance del trabajo y la ejecucin cualitativa del mismo.
El trabajo informtica consistir en la creacin del programa y todas las pruebas
oportunas para asegurar la fiabilidad del mismo.
El alcance del trabajo de las empresa Programadora incluye el diseo y preparacin
de todo el material necesario para la adquisicin e instalacin del programa.

4.1.2. REGLAMENTOS Y NORMAS.

Todas las unidades del programa se ejecutarn cumpliendo las prescripciones

indicadas en los Reglamentos y Normas Tcnicas de obligado cumplimiento para este
tipo de instalaciones, tanto de mbito nacional, autonmico como municipal, as como,
todas las otras que se establezcan en la Memoria Descriptiva.

Se adaptarn adems, a las presentes condiciones particulares que complementarn

las indicadas por los Reglamentos y Normas citadas.

4.1.3. EJECUCION DEL PROGRAMA.

4.1.3.1. COMIENZO:
La Empresa Programadora comenzar a crear el programa en el termino que figura
en el contrato establecido con la Empresa Usuaria, o en su defecto a los quince das de
la adjudicacin definitiva o la firma del contrato.

la Empresa Programadora est obligada a notificar por escrito o personalmente en

forma directa a la Empresa Usuaria la fecha de comienzo de la realizacin del
Programa.

52
 4.1.3.2. PLAZO DE EJECUCIN:

El programa se ejecutar en el terminio que se estipule en el contrato suscrito con la

Empresa Usuaria o en su defecto en el que figure en las condiciones de este pliego.

Cuando la Empresa Programadora, de acuerdo, con alguno de los extremos

contenidos en el presente Pliego de Condiciones, o bien en el contrato establecido con la
Empresa Usuaria, solicite una inspeccin para poder realizar algn trabajo ulterior que
est condicionado por la misma, vendr obligada a tener preparada para dicha
inspeccin, una cantidad de obra que corresponda a un ritmo normal de trabajo.

Cuando el ritmo de trabajo establecido por el Contratista, no sea normal, o bien a

peticin de una de las partes, se podr convenir una programacin de inspecciones
obligatorias de acuerdo con el plan de obra.

4.1.4. INTERPRETACIN Y DESARROLLO DEL PROGRAMA.

La interpretacin tcnica del Programa, corresponde al Tcnico Director. La

Empresa Programadora est obligada a someter a ste a cualquier duda, aclaracin o
contradiccin que surja durante la ejecucin de Programa por causa de una mala
interpretacin, o circunstancias ajenas, siempre con la suficiente antelacin en funcin
de la importancia del asunto.

La Empresa Programadora se hace responsable de cualquier error de la ejecucin

motivada por la omisin de sta obligacin y consecuentemente deber rehacer a su
costa los trabajos que correspondan a la correcta interpretacin del Proyecto.

La Empresa Programadora est obligada realizar todo cuanto se necesario para la

buena ejecucin del Programa, an cuando no se halle explcitamente expresado en el
Pliego de Condiciones o en los documentos del Proyecto.

La Empresa Programadora notificar por escrito o personalmente en forma directa al

Tcnico Director y con suficiente antelacin las fechas en que quedarn preparadas para
inspeccin, cada una de las partes de Programa para las cuales se ha indicado la
necesidad o conveniencia de las mismas.

53
 4.1.5. TRABAJOS COMPLEMENTARIOS.

La Empresa Programadora tiene la obligacin de realizar todos los trabajos

complementarios que sean indispensables para ejecutar cualquier parte del Programa
especificadas en cualquiera de los documentos del Proyecto, aunque en el, no figuren
explcitamente mencionadas dichos trabajos complementarios. Todo ello sin variacin
del importe contratado.

4.1.6. MODIFICACIONES.

La Empresa Programadora est obligada a realizar los trabajos que se le encarguen

resultantes de modificaciones del Programa, tanto en aumento como disminucin o
simplemente variaciones, siempre y cuando el importe de las mismas no altere en ms o
menos de un 25% del valor contratado.

La valoracin de las mismas se har de acuerdo, con los valores establecidos en el

presupuesto entregado por la Empresa Programadora y que ha sido tomado como base
del contrato. El Tcnico Director del Programa est facultado para introducir las
modificaciones de acuerdo con su criterio, en cualquier parte del Programa, durante la
creacin, siempre que cumplan las condiciones tcnicas referidas en el Proyecto y de
modo que ello no vare el importe total del Programa.

4.1.7. PROGRAMA DEFECTUOSO.

Cuando la Empresa Programadora halle cualquier parte del Programa defectuosa que
no se ajuste a lo especificado en el Proyecto o en este Pliego de Condiciones, el Tcnico
Director podr aceptarlo o rechazarlo; en el primer caso, ste fijar el precio que crea
justo con arreglo a las diferencias que hubiera, estando obligada la Empresa
Programadora a aceptar dicha valoracin, en el otro caso, se reconstruir a expensas de
la Empresa Programadora la parte mal ejecutada sin que ello sea motivo de reclamacin
econmica o de ampliacin del plazo de ejecucin.

4.1.8. MEDIOS AUXILIARES

Sern de la Empresa Programadora todos los medios y mquinas auxiliares que sean
necesarias para la ejecucin del Programa.

54
 4.1.9. CONSERVACIN DEL PROGRAMA.

Es obligacin de la Empresa Programadora la conservacin en perfecto estado del

programa hasta la fecha de recepcin definitiva por la Empresa Usuaria, y corren a su
cargo los gastos derivados de ello.

4.1.10. RECEPCIN DEL PROGRAMA.

4.1.10.1. RECEPCIN PROVISIONAL:

Una vez terminado el Programa, tendr lugar la recepcin provisional y para ello se
practicar en ellas un detenido reconocimiento por el Tcnico Director y la Empresa
Usuaria en presencia de la Empresa Programadora, levantando acta y empezando a
correr desde ese da el plazo de garanta si se halla en estado de ser admitido.

De no ser admitido se har constar en el acta y se darn instrucciones a la Empresa

Programadora para subsanar los defectos observados, fijndose un plazo para ello,
expirando el cual se proceder a un nuevo reconocimiento a fin de proceder a la
recepcin provisional.

4.1.10.2. LICENCIA Y DERECHOS.

Una vez efectuada la recepcin provisional se le entregar a la Empresa Usuaria una

licencia de derecho de uso del programa, una copia del Programa y un Manual de
Instalacin y Uso. Esta licencia da derecho a instalar el programa en un ordenador. Por
cada licencia de derecho de uso que se disponga, slo puede haber una copia en uso, es
decir instalada en un ordenador.
No se podr copiar, instalar en otro ordenador, ejecutar en pblico o aiq ' uilar la
copia entregada del programa sin la previa autorizacin de la Empresa Programadora.
Si se quiere instalar el Programa en otro ordenador se tendr que desinstalar
previamente del primero.

El Programa solo se puede vender, tal cual, sin modificarlo, completamente con la
licencia de derecho de uso del Programa, la copia del Programa y el Manual de
Instalacin y Uso.

55
 4.1.10.3. PLAZO DE GARANTA.

El plazo de garanta ser como mnimo de un ao, contado desde la fecha de la

recepcin provisional, o bien el que se establezca en el contrato tambin contado desde
la misma fecha. Durante este perodo queda a cargo de la Empresa Programadora la
conservacin del Programa y el arreglo de los errores observados.

4.1.10.4. RECEPCIN DEFINITIVA.

Se realizar despus de transcurrido el plazo de garanta de igual forma que la

provisional. A partir de esta fecha cesar la obligacin de la Empresa Programadora de
conservar y reparar a su cargo los defectos observados.

4.1.11. CONTRATACIN DE LA EMPRESA PROGRAMADORA.

4.1.1 1.1. MODO DE CONTRATACIN.

El conjunto del Programa lo realizar la empresa escogida por concurso-subasta.

4.1.11.2. PRESENTACIN.

Las empresas seleccionadas para dicho concurso debern presentar sus proyectos en
sobre lacrado, antes del 15 de Febrero de 2002 en el domicilio de la Empresa Usuaria.

4.1.11.3. SELECCIN.

La empresa escogida ser anunciada la semana siguiente a la conclusin del plazo de

entrega. Dicha empresa ser escogida de mutuo acuerdo entre la Empresa Usuaria y el
Director Tcnico, sin posible reclamacin por parte de las otras empresas concursantes.

4.1.12. FIANZA.

En el contrato se establecer la fianza que la Empresa Programadora deber depositar

en garanta del cumplimiento de mismo, o, se convendr una retencin sobre los pagos
realizados a cuenta de Programa realizado.

56
 De no estipularse la fianza en el contrato se entiende que se adopta como garanta
una retencin del 5% sobre los pagos a cuenta citados.

En el caso de que la Empresa Programadora se negase a hacer por su cuenta los

trabajos para ultimar el Programa en las condiciones contratadas, o a atender la garanta,
la Empresa Usuaria podr ordenar ejecutarlas a un tercero, abonando su importe con
cargo a la retencin o fianza, sin perjuicio de las acciones legales a que tenga derecho la
Empresa Usuaria si el importe de la fianza no bastase.

La fianza retenida se abonar a la Empresa Programadora en un plazo no superior a

treinta das una vez firmada el acta de recepcin definitiva del Programa.

4.2. CONDICIONES ECONMICAS.

4.2.1. ABONO DEL PROGRAMA.

En el contrato se deber fijar detalladamente la forma y plazos que se abonarn las

partes realizadas del Programa. Las liquidaciones parciales que puedan establecerse
tendrn carcter de documentos provisionales a buena cuenta, sujetos a las
certificaciones que resulten de la liquidacin final. No suponiendo, dichas liquidaciones,
aprobacin ni recepcin del trabajo que comprenden.

Terminado el Programa se proceder a la liquidacin final que se efectuar de

acuerdo con los criterios establecidos en el contrato.

4.2.2. PRECIOS.

La Empresa Programadora presentar, al formalizarse el contrato, relacin de los

precios de las unidades del Programa que integran el proyecto, los cuales de ser
aceptados tendrn valor contractual y se aplicar a las posibles variaciones que puedan
haber.

Estos precios unitarios, se entiende que comprenden la ejecucin total de la unidad

del Programa, incluyendo todos los trabajos an los complementarios y los materiales
as como la parte proporcional de imposicin fiscal, las cargas laborales y otros gastos
repercutibles.

57
 En caso de tener que realizarse unidades de Programa no previstas en el proyecto, se
fijar su precio entre el Tcnico Director y la Empresa Programadora antes de iniciar el
Programa y se presentar a la Empresa Usuaria para su aceptacin o no.

4.2.3. REVISIN DE PRECIOS.

En el contrato se establecer si la Empresa Programadora tiene derecho a revisin de

precios y la frmula a aplicar para. calcularla. En defecto de esta ltima, se aplicar a
juicio del Tcnico Director alguno de los criterios oficiales aceptados.

4.2.4. PENALIZACIONES.

Por retraso en los plazos de entrega de Programa, se podrn establecer tablas de

penalizacin cuyas cuantas y demoras se fijarn en el contrato.

4.2.5. CONTRATO.

El contrato se formalizar mediante documento privado, que podr elevarse a

escritura pblica a peticin de cualquiera de las partes. Comprender la adquisicin de
todos los materiales, transporte, mano de obra, medios auxiliares para la ejecucin del
Programa proyectado en el plazo estipulado, as como la reconstruccin de las unidades
defectuosas, la realizacin de las partes complementarias y las derivadas de las
modificaciones que se introduzcan durante la ejecucin, stas ltimas en los trminos
previstos.

La totalidad de los documentos que componen el Proyecto Tcnico del Programa

sern incorporados al contrato y tanto el contratista como la Empresa Usuaria deber
firmarlos en testimonio de que los conocen y aceptan.

4.2.6. RESPONSABILIDADES.

La Empresa Programadora es la responsable de la ejecucin del Programa en las

condiciones establecidas en el proyecto y en el contrato. Como consecuencia de ello
vendr obligado a la eliminacin de lo mal ejecutado y a su reconstruccin
correctamente sin que sirva de excusa el que el Tcnico Director haya examinado y
reconocido el Programa.

La Empresa Programadora es la nica responsable de todas las contravenciones que

ella o su personal cometan durante la ejecucin del Programa u operaciones

58
relacionadas con el mismo. Tambin es responsable de los daos que por errores,
inexperiencia o empleo de mtodos inadecuados se produzcan en la Empresa Usuaria.

la Empresa Programadora es la nica responsable del incumplimiento de las

disposiciones vigentes en la materia laboral respecto de su personal.

4.2.7. RESCISIN DEL CONTRATO

4.2.7.1. CAUSAS DE RESCISIN.

Se consideraran causas suficientes para la rescisin del contrato las siguientes:

Primero: Muerte o incapacitacin de La Empresa Programadora.

Segunda: La quiebra de la Empresa Programadora.
Tercera: Modificacin del proyecto cuando produzca alteracin en ms o
menos 25% del valor contratado.
Cuarta: Modificacin de las unidades de Programa en nmero superior al
40% del original.
Quinta : La no iniciacin de la programacin en el plazo estipulado cuando
sea por causas ajenas a la Empresa Programadora.
Sexta : La suspensin de la programacin ya iniciada siempre que el plazo
de suspensin sea mayor de seis meses.
Sptima: Incumplimiento de las condiciones del Contrato cuando implique
mala fe.
Octava : Terminacin del plazo de ejecucin del Programa sin haberse
llegado a completar ste.
Novena : Actuacin de mala fe en la ejecucin de los trabajos.
Dcima: Destajar o subcontratar la totalidad o parte del Programa a terceros
sin la autorizacin del Tcnico Director y la Empresa Usuaria.

4.2.8. LIQUIDACIN EN EL CASO DE RESCISIN DEL CONTRATO.

Siempre que se rescinda el Contrato por causas anteriores o bien por acuerdo de
ambas partes, se abonar a la Empresa Programadora las unidades de Programa ya
terminadas.

59
 Cuando se rescinda el contrato llevar implcito la retencin de la fianza para obtener
los posibles gastos de conservacin de el perodo de garanta y los derivados del
mantenimiento hasta la fecha de nueva adjudicacin.

4.3. CONDICIONES FACULTATIVAS.

4.3.1. PERSONAL.

La Empresa Programadora tendr al frente de la realizacin del Programa un

encargado con autoridad sobre los dems operarios y conocimientos acreditados y
suficientes para la ejecucin del Programa.

El encargado recibir, cumplir y transmitir las instrucciones y ordenes del Tcnico

Director de la obra.

La Empresa Programadora tendr el nmero y clase de operarios que haga falta para
el volumen y naturaleza de los trabajos que se realicen, los cuales sern de reconocida
aptitud y experimentados en el oficio. La Empresa Programadora estar obligada a
separar de la programacin, a aquel personal que a juicio del Tcnico Director no
cumpla con sus obligaciones, realice el trabajo defectuosamente, bien por falta de
conocimientos o por obrar de mala fe.

4.4. CONDICIONES TCNICAS

4.4.1. REQUERIMIENTOS DE HARDWARE

Para que el Programa pueda funcionar con cierta agilidad se aconseja tener como
mnimo el siguiente Hardware:
PC 486 con coprocessador a 66 Mhz como mnimo 8 Mb de RAM como mnimo 3
Mb de espacio libre en el disco duro. Ratn Microsoft o compatible.

Monitor SVGA con una resolucin de 800 * 600 pxeles como mnimo.

4.4.2. REQUERIMIENTOS DE SOFTWARE

Para que pueda funcionar el Programa se tendr que tener instalado en el ordenador
como mnimo el Software siguiente con sus respectivas licencias.
Microsoft Windows 95 o posterior.

60
Manual de usuario del Ens&Link 68000

61
1 Introduccin

En el presente manual se explica el modo de utilizacin del programa Ens&Link

68000 para sistema operativo Windows. Ambos programas se encuentran en una misma
ventana para optimizar el espacio y hacer menos engorroso su manejo. Para seleccionar
uno u otro programa basta con presionar sobre su correspondiente solapa. Como podrn
apreciar, su uso es extremadamente sencillo e intuitivo.

2 Descripcin de manejo

2.1 Ens68K

Fig1. Parte correspondiente al Ens68K

Como se puede observar en la Fig1, el formulario o ventana que constituye la

parte relativa al ensamblador est formada por 3 labels o etiquetas para introducir el
nombre de los ficheros a ensamblar, y de 2 memos de salida para visualizar posibles
errores o simplemente mensajes informativos (warnings).

62
 Lo primero que haremos antes de linkar el cdigo que hemos generado ser
ensamblarlo. Para ello clicaremos previamente sobre la pestaa superior donde pone
Ens68K. A continuacin seguiremos los siguientes pasos:

Fig2.Introduccin de los nombres de los archivos

1. En primer lugar, como se puede apreciar en la Fig2, tendremos que rellenar el

campo donde pone Fuente, el cual como su propio nombre indica, corresponde
al fichero fuente del fichero que deseamos ensamblar. Por defecto y para
ahorrar tiempo al usuario, los campos de los ficheros Destino y Listado se
rellenan automticamente con el mismo nombre que el usuario ha introducido
en el campo del fichero Fuente. En caso de que el usuario desee que los
nombres de los ficheros Destino y Listado tengan un nombre diferente puede
modificarlos posteriormente sin que el resto permanezca alterado. Si por
alguna razon se omite la extensin de los diferente archivos a introducir, el
programa los aadir internamente.

63
Fig3. Resultados del ensamblado

2. A continuacin simplemente haremos clic sobre el botn Ensambla y

esperaremos el resultado del ensamblado. La misma ventana consta de 2
memos de mensajes tanto de posibles errores como de informacin.
3. A continuacin se exponen los posibles mensajes de error e informaciones que
se pueden visualizar en ambas ventanitas:

Mensajes de Informacin:

- "ENSAMBLADOR PARA MC68000"

-"EL FICHERO FUENTE %s NO EXISTE"
-"PRIMERA PASADA"
-"LINEA"
-"LINEAS ENSAMBLADAS"
-"SEGUNDA PASADA"

64
 -"TABLA DE SIMBOLOS"
-"PAGINA"
-"FICHERO DE AYUDA HELP.HLP NO ENCONTRADO"
-"MEMORIA INSUFICIENTE"

Mensajes de Error:

-"PARAMETROS ERRONEOS"
-"ERROR AL CREAR EL FICHERO OBJETO %s"
-"ERROR AL CREAR EL FICHERO DE LISTADO %s",
-"ERRORES"

2.2 Link68K

Fig4. Parte correspondiente al Link68K

65
 Una vez ensamblado se habr generado un fichero cuya extensin ser .obj
(fichero objeto).
A continuacin tendremos que linkar los archivos .obj creados siguiendo los
siguientes pasos:

Fig5. Introduccin de los nombres de los ficheros .obj

1. En el campo Objeto tendremos que introducir el nombre de dicho fichero tal

y como se puede apreciar en Fig5. Podemos querer linkar varios archivos, y
para tal fin se ha dispuesto la ListBox.

66
Fig6. Introduccin de los nombres de los ficheros en la ListBox

2. A continuacin deberemos apretar el botn aadir para que el nombre del

fichero .obj quede almacenado en la ListBox. La ListBox es una pequea
ventana donde vamos almacenando sucesivamente los ficheros objeto que
deseamos linkar, ya que en muchas ocasiones son ms de uno. Podemos
apreciar como nuevamente el resto de campos se rellenan automticamente,
tanto el fichero de Destino (cuya extensin es .s28), como el Mapa (cuya
extensin es .map) y al igual que en el Ens68K, podemos modificar
posteriormente el nombre de los ficheros .s28 y .map. Adems tenemos la
posibilidad de que el programa linke a partir de una posicin de memoria
introducida por el usuario. En cuanto a esto ltimo tenemos que vigilar que 2
archivos .obj no sean linkados en la misma posicin de memoria, ya que
provocara un error de ensamblado que ser indicado por el programa en su
correspondiente memo destinado a errores.

67
Fig7. Resultado del linkado de archivos

3. Finalmente, para linkar los archivos introducidos en la ListBox apretaremos el

control Linka y se obtendr si no ha habido ningn error, un resultado similar
al de la Fig7.
4. A continuacin se exponen los posibles mensajes de error e informacin que
pueden aparecer en las ventanas:

Mensajes de Informacin:

-"LINKER 68000"
-"MEMORIA INSUFICIENTE"
-"ETIQUETA GLOBAL '%s' DECLARADA EN DOS MODULOS"
-"NO SE PUEDE EVALUAR LA EXPRESION '%s'"
-"LISTADO DE ETIQUETAS
-"TIPO MODULO ETIQUETA VALOR"
-"FICHERO OBJETO '%s' REPETIDO"
-"EL FICHERO OBJETO '%s' NO EXISTE"

68
 -"MODULO NOMBRE SEGMENTO INICIO FINAL"
-"LOCAL "
-"GLOBAL
-"ETIQUETA EXTERNA NO RESUELTA"
-"FORMATO DEL FICHERO '%s' INCORRECTO"

Mensajes de Error:

-"NUMERO DE ERRORES"
-"ERROR AL ABRIR EL FICHERO"
-"SEGMENTOS DEL PROGRAMA SOLAPADOS"

69