desarrollo del ensamblador y el linkador del mc68000 para...

Desarrollo del Ensamblador y el Linkador delMC68000 para un entorno Windows mediante C++

Builder

AUTOR: Miguel Monforte ArtigasDIRECTOR: Enrique Cantó Navarro

FECHA: Febrero / 2002

2

Indice

1 Memoria Descriptiva..........................................................................................3

1.1 Objeto del proyecto.........................................................................................3

1.2 Titular..............................................................................................................3

1.2 Antecedentes...................................................................................................3

1.4 Posibles soluciones y solución adoptada........................................................4

1.5 Diferencias entre programas bajo DOS y bajo Windows...............................5

1.6 Introducción a C++ Buider.............................................................................8

1.7 Descripción general........................................................................................9

1.7.1 Introducción ...........................................................................................9

1.7.2 Esquema Proceso de Ensamblado y Linkado.......................................13

1.7.3 Esquema del Proyecto...........................................................................15

1.7.4 Descripción de las funciones.................................................................20

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

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

4 Pliego de Condiciones........................................................................................53

4.1. Condiciones generales..................................................................................53

4.2. Condiciones económicas..............................................................................58

4.3. Condiciones facultativas...............................................................................61

4.4. Condiciones técnicas....................................................................................61

5 Anexos.................................................................................................................62

5.1. Manual de usuario.........................................................................................62

5.2. Código...........................................................................................................71

3

1 Memoria Descriptiva

1.1 Objeto del proyecto

Este proyecto consiste en la adaptación de un Ensamblador y un Linkador delmicroprocesador de 16 bits (internamente funciona a 32 bits) MC68000 de Motorola deC a C++ Builder, es decir, que tanto el Ensamblador como el Linkador de dichomicroprocesador sea soportado por una plataforma Windows 9X, 2000, etc y no sólofuncione sobre el sistema operativo DOS. El nombre del programa es Ens&Link 68000y consta de una sóla ventana.

1.2 Titular

El titular del presente proyecto es:

-Nombre: Escola Tècnica Superior d’Enginyeria (E.T.S.E.)

Universitat Rovira i Virgili

-Dirección: Av. Països Catalans, 26

Campus Sescelades

43007 Tarragona

Telf: 977559610

1.3 Antecedentes

Hasta el momento en los laboratorios docentes del DEEEA se disponía de unEnsamblador y un Linkador (además de un simulador y un software de interface del PCcon el módulo docente) que tan sólo eran soportados por el sistema operativo DOS. Conel programa generado en este proyecto se ha adaptado el programa escrito en C aplataformas Windows (9X, 2000, etc) mediante el lenguaje C++ builder. Estamodernización y adaptación del software era necesaria debido a que prácticamentetodos el código generado hoy en día se realiza con la finalidad de que funcione con laplataforma standard Windows. El entorno creado es mucho más visual y más flexibleque el ya existente para DOS y conserva todas opciones y recursos de los que disponíasu antecesor. Otra ventaja que cabe destacar es que ambos módulos (el Ensamblador yel Linkador) han sido integrados en un mismo programa y no hace falta efectuar latediosa tarea de ejecutarlos cada vez que queramos ensamblar y linkar por separado.

Cabe decir también que estos 2 elementos, el ensamblador y el linkador, estáprevisto que formen parte en un futuro inmediato de un entorno global de simulacióntanto de la parte hard del microprocesador, como la parte soft. El entorno constaráademás de los presentes y mencionados ensamblador y linkador, de un simulador delmicroprocesador y de un software de comunicaciones que servirá de interface con losPC y estaciones de trabajo del los laboratorios docentes.

4

Figura 1. Esquema Entorno Global del MC68000

1.4 Posibles soluciones y solución adoptada

Se podría haber realizado el proyecto con cualquier tipo de los diversos lenguajesvisuales para Windows existentes en el mercado como por ejemplo: Visual C, VisualBasic, etc, pero finalmente se ha optado por el C++ Builder de Borland por diversasrazones, entre las que podemos destacar su gran potencia heredada del C, la posibilidadde programar en modo orientado a objetos (POO) como en C++ y la última y másimportante debido a que facilita y ahorra mucho tiempo a la hora de programar, es queya incluye clases creadas con lo cual se agiliza en gran medida la generación de códigonuevo y complejo. En resumen, mediante C++ Builder se consigue una programaciónorientada a componentes (POC). Un componente es similar a una clase, pero ademásconsta de propiedades y eventos. Cada componente nuevo ya creado e incluido en elcompilador, no es más que un trozo de código que da origen a un formulario, unaetiqueta, una “listbox”, etc, con lo cual se ahorra, mediante esta standarización el tiempopara programar dichos objetos, lo cual suele ser bastante engorroso y complejo enlenguajes como C++.

5

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 básicas entre un programa que funcionabajo DOS y otro que funciona bajo Windows, ya que es uno de los pilaresfundamentales donde se apoya la razón de ser de este proyecto.

La diferencia básica entre un programa bajo DOS y otro bajo Windows radica en sumodo de ejecución. Mientras que en DOS los programas se ejecutan secuencialmente enWindows dicha ejecución depende de eventos o sucesos que se produzcan.

En Dos, la ejecución de un programa parte de su “main” o programa principal ymientras 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 hacía antes referencia pueden ser provocadospor 3 elementos:

-El usuario

-El sistema

-El programa

la respuesta a estos sucesos depende de las entradas, ya sean: movimientos del ratón,

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 laaplicación que debe encargarse del manejo del suceso. Todas las aplicaciones deWindows tienen una cola de mensajes donde se va almacenando los sucesos que debeprocesar. El sistema operativo (multitarea en el caso de Windows) va cediendo almicroprocesador las diferentes aplicaciones que se encuentran ejecutándose en elordenador a lo largo del tiempo. Cuando se cede el control a la aplicación que tienependientes mensajes para procesar, el sistema operativo va llamando a las diferentesrutinas que se encargarán de procesar el mensaje según sea su tipo.

A continuación se muestra esquemáticamente todo ese proceso:

6

Main( )

Rutina 1

Rutina 2

Rutina 3

Rutina n

Fin

Inicio

Esperar Suceso

Salir?

Fin

ProcesadoSuceso

Rutina 1

Rutina 2

Rutina n

Figura 2. Ejecución de las rutinas bajo DOS (a) y bajo Windows (b)

Los mensajes a los que se hacía antes alusión, son una notificación a la aplicacióncon la finalidad de advertirle de que ha sucedido algo y que debe realizar alguna acción.Cuando se envía un mensaje a una aplicación ésta, inmediatamente ejecutará unafunción. Las aplicaciones de Windows emplean una ventana de “interface” con elusuario. Las aplicaciones se encargan del control del área de trabajo de dichas ventanas.Mientras la cola de mensajes de una aplicación esté vacía, Windows no le cederá elcontrol a ésta, ya que no hay mensajes a procesar en ese momento. Así se optimiza engran medida la utilización de todos los recursos del sistema por parte de todas lasaplicaciones.

Seguidamente se muestra el diagrama de funcionamiento:

7

Entrada

WINDOWS APLICACIÓN A

Cola de Mensajes del Sistema

Cola de Mensajes de Aplicación A

Cola de Mensajes de Aplicación n

WinMain

Función 1

Función n

Figura 3. Sistema de mensajes

Windows comparte recursos entre aplicaciones de ahí que sea multitarea, con lo cuales necesario que cualquier acceso a un recurso por parte de una aplicación se establezcaa través del sistema operativo, pero nunca directamente. Si una aplicación necesitaemplear algún recurso hardware, tendrá que ser a través del sistema operativo. Para quelas aplicaciones sean independientes del hardware empleado, el sistema operativoaccede a éste mediante lo que se llama “drivers” o controladores. Cada fabricante dedispositivos “hard” tiene que poner a disposición los “drivers” pertinentes para queéstos sean completamente compatibles con Windows. Esta independencia hardwareimplica que las aplicaciones sean independientes del hardware empleado, facilitando laprogramación.

El software mediante el cual están realizados mayoritariamente todos “drivers” dedispositivos periféricos son los archivos de extensión “.dll” o librerías de enlacedinámico Windows permite además el uso de éstas. Los ficheros “.dll” son código quepueden usar de forma compartida diferentes aplicaciones. Existen DLL suministradaspor Windows, o bien es posible la programación propia de DLL para su uso pornuestras aplicaciones.

Finalmente cabe añadirse que el sistema operativo Windows proporciona unasinterfaces para la programación de aplicaciones llamadas API las cuales son unconjunto de funciones que tienen que ser empleadas para programar una aplicación quese ejecute bajo Windows.

8

1.6 Introducción a C++ Builder

A continuación se hace una breve introducción al lenguaje seleccionado finalmentepara realizar el proyecto.

El C++ es una extensión o ampliación del lenguaje C y a diferencia de éste último,permite programar en modo orientado a objetos. Antaño, la gran mayoría de lasaplicaciones desarrolladas para Windows eran realizadas en lenguaje C, del mismomodo que las librerías de las funciones de las API. Sin embargo estas aplicacionesfueron construidas pensando en objetos, de forma que lo más conveniente era usar un“interface” basado en objetos, que realice las llamadas a las API de Windows.

Con la finalidad de facilitar la programación orientada a objetos se crearon“frameworks”. Las “framework” son librerías que encapsulan las técnicas deprogramación más empleadas. Una aplicación basada en “framework” en comparación aotra que se basa directamente en llamadas a las API contiene menos código, con lo cuales más óptima desde un punto de vista temporal y es mucho más fácil de crear. Ademásel uso de MFC permite el uso de funciones de los lenguajes C o C++ y el uso directo deAPI.

Los frameworks para Windows que más se han extendido en la actualidad son elMFC (Microsoft), OWL (Borland) y VCL (Borland).

Las librerías VCL, (Visual Component Library) son las que se han utilizado en esteproyecto. Fueron desarrolladas originalmente para el compilador de Pascal de Borland,el Delphi. El nuevo compilador Borland C++ Builder incluye las VCL (además depoder compilar programas basados OWL ,MFC y Delphi). Este “framework” es el másavanzado ya que permite una auténtica programación visual C++ basada encomponentes y formularios que pueden funcionar sin ficheros “.dll” adicionales.Además, como ya se ha dicho antes, permite la creación de aplicaciones de medianacomplejidad para Windows en un tiempo relativamente corto.

9

1.7 Descripción General

1.7.1 Introducción

El programa consta de una sóla ventana en la cual están integrados todos loselementos necesarios para el ensamblado y linkado de ficheros. Para pasar de unmódulo a otro simplemente basta con hacer clic sobre una de las 2 pestañas. Primeroevidentemente se debe proceder ensamblando el fichero de extensión “.asm”. Para ellobastará con introducir el nombre del fichero fuente en su campo correspondiente.Automáticamente los campos de los ficheros destino (.obj) y listado (.lst) se rellenan pordefecto con el mismo nombre aunque naturalmente cabe la posibilidad de modificarlosposteriormente. A continuación se hace clic sobre el botón “Ensambla” situado en elmenú principal de la parte superior de la ventana. Al instante obtendremos losresultados en los memos tanto de información (si no hubieran errores), como de errores(si los hubiera). El fichero “.asm” contiene un código escrito en lenguaje nemotécnico elcual al ser ensamblado se transforma directamente a código máquina inteligible por lamáquina. El código generado en este último fichero está en hexadecimal. Acontinuación, una vez creados los ficheros objeto y de listado se puede proceder a sulinkado. Para ello basta una vez más con presionar la pestaña de la partecorrespondiente al linker. Ahora se tienen más campos por rellenar. Se puede apreciarcomo además de los campos de destino (cuya extensión es .s28) y de mapa (cuyaextensión es .map), hay otro campo para introducir la posición de memoria donde sedesea que sea o sean linkado/s nuestro/s fichero/s objeto y finalmente una ListBox porsi se quiere linkar más de un fichero objeto. Evidentemente antes de introducir dichosficheros objeto en la ListBox tendrán que haber sido creados mediante su previoensamblado. Una vez introducidos ficheros .obj en la ListBox haremos click sobre elbotón Linka situado en el menú superior de la ventana. Al igual que en el caso delensamblador serán presentados en los memos de información y de error los posiblesavisos o errores cometidos por el usuario.

Para llegar hasta el formulario final se ha seguido un proceso de transformaciónintermedio. Para ello en primer lugar se crearon 2 formularios provisionales, uno deentrada y otro de salida (cuyos captions poseen el mismo nombre). El programaentonces era apto para un entorno C++ Builder. Ambos formularios sirvieron dereferencia, una vez finalizado el proyecto, para comparar y confirmar si los mensajes desalida y entrada, el tipo de errores provocados, etc eran los mismos en los formulariosprincipales que en el definitivo. Como se ha dicho anteriormente los formularios deentrada y salida eran meramente formularios de apoyo, ya que consistían simplementeen 2 objetos de la clase TForm con un memo del tipo TMemo cada uno en su interior yel mecanismo de entrada y de salida era exactamente igual que el programa ejecutablesobre DOS, sólo que ahora se hacía sobre un par de ventanas que podían soportarWindows. Finalmente se ha decidido no eliminar dichos formularios debido a su granutilidad en una futura actualización a macroensamblador del presente programa,simplemente se han configurado en modo invisible por motivos de estética.

10

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 unformulario que es otro objeto que contiene al anterior y es de la clase TForm. Elformulario se puede redimensionar en su totalidad. Por el “memo” simplemente salentodos los mensajes que salían en la versión 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.También consta de un “memo” y un formulario que lo contiene, con la pequeñadiferencia de que posee un botón de control que hace la función que en la versión paraDOS tenía el retorno de carro, es decir confirmar que los datos de entrada por parte delusuario son válidos.

Figura 5. Formulario provisional de entrada

11

A continuación se muestra en la Figura 6 el formulario definitivo que integra todaslas partes (entrada y salida). En concreto la de la Figura inferior corresponde a la partedel Ensamblador. Es un formulario bastante más completo y complejo que losprovisionales puesto que consta de más componentes. En primer lugar se puedenobservar 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, yasea del ensamblador en el caso de Ensambla o del linkador en el caso de Linka. Estasfunciones se encuentran como veremos más adelante en fichero “.cpp” asociado a esteformulario, en nuestro caso menuprin.cpp, el cual será comentado más adelante enprofundidad. Además dichos controles se pueden activar haciendo Alt+E en el caso delensamblador y Alt+L en el caso del linkador.

Un poco más abajo de estos controles, se han creado otros 2 correspondientes a laspestañas que hacen posible la elección de la parte que se encarga del ensamblado o de laque se encarga de la de linkado.

Figura 6. Formulario Definitivo. Parte correspondiente al Ensamblador

12

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

Figura 7. Formulario Definitivo. Parte correspondiente al Linkador

A continuación se adjunta un diagrama de flujo donde se puede apreciar todo elproceso de transformación que siguen los diferentes tipos de archivos:

13

1.7.2 Esquema Proceso de Ensamblado y Linkado

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

14

A continuación se pasará a explicar el programa fuente elaborado haciendo especialhincapié en el código 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 estecapítulo en los diferentes archivos de los que consta el programa. El programa globalque contiene a resto de “subarchivos” es un archivo de tipo project cuya extensión es“.bpr”. Este es el tipo de archivo que constituye una aplicación de C++ Builder, esdecir, en él están contenidos toda una serie de ficheros que interactúan entre sí y hacenposible su funcionamiento. Estos pueden constar de 2 tipos de ficheros: “.cpp” yformularios asociados o no a estos archivos. Los formularios son en realidad trozos decódigo que les implementan gráficamente. Sin embargo también se pueden visualizarlos formularios, si como todos los objetos creados en un entorno C++ Builder, mediantela opción “View as Text”, que es una de las opciones que se encuentran al clicar con elbotón derecho sobre el formulario en cuestión, al hacer clic en esa opción se podránobservar todos los objetos contenidos en el formulario, así como todas sus propiedadesprincipales con los valores que se les han asignado o que venían por defecto en unarchivo cuya extensión es .dfm. En ese mismo fichero se pueden variar dichaspropiedades escribiendo los valores que se deseen:

Figura 9. Opciones del formulario

15

A continuación se presenta un esquema gráfico de todos los ficheros que componenel fichero proyecto “.bpr” y después se irán enumerando los archivos que contiene elproyecto, y explicando cada una de las funciones de las que constan. Algunas de ellaspertenecen a los formularios de salida y entrada que se realizaron como provisionales enun principio aunque la mayoría fueron útiles tanto a dichos formularios provisionalescomo al final y definitivo ya que básicamente son funciones de DOS que sonrenombradas para que sean compatibles en un entorno C++ Builder.

1.7.3 Esquema del Proyecto

En primer lugar se expone mediante un diagrama gráfico la interactuación entre losdiferentes ficheros según las funciones que contengan. Básicamente es un esquemajerárquico, donde las funciones de los archivos más prioritarios llaman a funciones deotros archivos más secundarios.

Posteriormente se ha realizado un esquema general con todos los archivos yfunciones que contiene todo el proyecto.

16

FORM2

MAIN_ENS MAIN_LINK

MENUPRIN.cpp

ENS68K.cpp LINKER.cpp

TABLA.cpp

FUNC.cpp

ERRORES.cpp

ARBOLES.cpp

PARSER.cpp

COPYR.cpp SUBF2.cpp

COPYRLINK.cpp

PARSERL.cpp

17

1).Archivos Comunes

-old_iovoid 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 intc,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()

18

-menuprinvoid __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.cppstatic 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.cppvoid copyr()

19

-TABLA.cppstatic 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(voi

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.cppstatic 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.cppstruct 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

20

static void coger_expresion(long int *);

static void nivel1(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.cppvoid error(tipo)

3).LINKADOR

-linker.cppstatic 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.cppmarc(le, to, ri, bo, s)

elimarc(le, to, ri, bo, s)

21

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.cppcopyrlink()

-Parserl.cppstatic void coger_expresion(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 Descripción de las funciones

Hay 2 archivos que son comunes a todo el proyecto. En ellos se encuentran funcionesde 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 librerías donde se incluyenalgunas funciones que se han creado y otras standard que ya venían implementadas.Además todas los funciones que se han creado nuevas renombrándolas y modificando

22

su contenido se han ido escribiendo en su fichero de cabecera, en este caso “old_io.h”,para que no se produzcan errores de compilación. En un fichero de cabecera siempredeben incluirse todas las funciones de las que hace uso su archivo “.cpp” asociado. Acontinuación viene definido un array de caracteres llamado “cadena” => charcadena[1024] q consta de 1024 elementos de tipo “char”. Dicho array se emplea paraalmacenar o copiar los nombres de otras cadenas de caracteres. A continuación estándefinidas algunas funciones relativas al ensamblador:

1.-Funciones relativas al Ensamblador:

-void old_sleep(int a) => Esta función es una modificación de la original sleep(inta). Se ha modificado debido a que era una función propia de DOS, la cual no puedefuncionar en un entorno de C++ Builder. Lo mismo se ha hecho con todas las funcionesde DOS que podían dar problemas al compilador de builder. En este caso simplementese renombra la función y se modifica para que no haga nada. Anteriormente en vez demodificar este tipo de funciones para que no hicieran nada, se hacía que escribieran enun formulario de salida provisional su propio nombre para comprobar queefectivamente se ejecutaban y el programa llegaba allí.

-void old_textattr(int newattr) => Esta función, al igual que la anterior,únicamente funciona en la plataforma DOS. Su finalidad era modificar los atributos deltexto mostrado por pantalla. Se han renombrado y posteriormente modificado para queno haga nada, puesto que los atributos de texto en un entorno C++ builder funcionan deotro modo.

-void old_gotoxy(int x, int y) => Nuevamente se está frente a una funciónpropia del sistema operativo DOS cuya utilidad es la de situar las coordenadas en unpunto determinado de la pantalla, algo totalmente improcedente en los formularios.

-void old_clrscr() => Al igual que las anteriores esta función proviene de lafunción original “clrscr()” propia de DOS para limpiar la pantalla antes de presentardatos por pantalla. En C++ builder se utilizarán otros métodos para limpiar tanto“memos” de información y de errores, como la “ListBox” y las “Labels”. También estafunción ha sido renombrada para que no haga nada.

-int old_cprintf(char *c1,char *c2) => “cprintf()” es una función de DOS quemuestra datos por pantalla. Su funcionalidad no es válida en un entorno C++ Builder,con lo cual ha sido sustituida por old_cprintf y modificada totalmente. A esta función sele pasan en este caso 2 punteros a carácter. Mediante la función “sprintf()” se copiaránlas cadenas de caracteres que son apuntadas por los punteros antes mencionados a lacadena de caracteres llamada “cadena”. La función “sprintf()” tan sólo se encarga decopiar 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 sietefunciones realizan exactamente el mismo papel que la anterior, sólo que a cada una lepasamos los argumentos pertinentes dependiendo de los que les sean enviados a estas.

23

-int old_cprintf(char *c1) => Esta función escribe en el memo del formulario desalida cadenas de caracteres. Por primera vez en esta función nos encontramos objetos.

FormSalida->Texto->Lines->Add(c1);

Por ejemplo en la línea superior se ven los comandos necesarios para presentar porformulario una cadena de caracteres. Cabe observar como la acción que se quiereimplementar recae sobre el último fragmento de código, en este caso:

Lines->Add(c1)

Pero a pesar de ello, se tiene que referirse a ella partiendo desde el conjunto másgrande al que pertenece, en este caso el formulario “Form2” que es el formularioprincipal, pasando por los diversos elementos o conjuntos más pequeños que también lacontienen y que a su vez están contenidos (como todos los elementos) en un formularioprincipal o global que es como ya se ha dicho antes “Form2”. En este caso el elementoinmediatamente 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 poseenuna propiedad llamada “Lines” que a su vez es un objeto del tipo “TStrings”. “Lines” asu vez tiene un método (uno de los muchos que tiene) llamado “Add()”, que sirve paraañadir líneas de texto. En la siguiente figura se puede apreciar claramente este concepto:

Figura 10. Esquema de la jerarquía de estos objetos en concreto

24

La diferencia entre un método y una propiedad es que los métodos son funcionesque se evalúan cuando previamente se le han pasado unos argumentos, exactamenteigual que una función normal y corriente. En cambio, una propiedad es una variablea la que directamente se le asigna un valor, por ejemplo la altura del texto que seescribe. Cada clase de objeto tiene multiples funciones, métodos y eventos. Unevento es como un método pero que se ejecuta como su propio nombre indica,cuando se produce o provoca un evento o acción, por ejemplo hacer clic en unformulario, cerrar un ventana, etc, en ese momento, se ejecutará la función que sehaya implementado para tal suceso.

-int old_cputs(const char *org) => Esta función mediante la función“strcpy()” copia una cadena de caracteres que se le pasa como parámetro a otracadena (simplemente hace una copia), después mediante la función strlen(org) seaverigua la longitud de la cadena, es decir, cuantos caracteres tiene incluido elcarácter final de línea. Una vez hecho esto se asigna dicho valor a una variable detipo entero llamada “ret”. A continuación volvemos a emplear la estructura decódigo:

FormSalida->Texto->Lines->Add(cadena);

Una vez más la usamos para presentar por pantalla cadenas de caracteres.

A continuación mediante el conjunto de comandos siguiente, se activa un método deltipo de objetos “TMemo” que únicamente se encarga de forzar al control para queescriba lo que se le ha ordenado antes (es simplemente para asegurar). Finalmenteretorna el número de caracteres de que consta nuestra cadena mediante “ret”.

FormSalida->Texto->Update();

-char *old_gets(char *s) => Esta función hace referencia al formulario de entraday obtiene la información que le entra el usuario por teclado para que sea procesadaposteriormente.

Mediante la siguiente línea de código, se limpia el memo del formulario de entradade posible basura o de datos que se ha introducido anteriormente:

FormEntrada->Entrada->Text="";

En segundo lugar, con la línea siguiente, lo único que se hace es decirle al programaque sólo esa ventana o formulario esté activo hasta que no introduzcamos los datos enél, ya que de lo contrario podrían producirse errores si el usuario intenta introducir datosen otra ventana y además el programa de todos modos no va a poder seguir su flujo deejecución normal si no se introduce la información que requiere por el formularioasignado por el programador para tal fin:

FormEntrada->ShowModal();

A continuación tenemos la línea que realmente copia la información que necesitanuestro programa para procesarla posteriormente:

strcpy(s,FormEntrada->Entrada->Text.c_str());

En esta línea se copia el “ansistring” que el usuario introduce por teclado a unacadena de caracteres llamada “s”. La razón 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

25

“ansistring” es una cadena de caracteres, pero que además en su cabecera contiene elnúmero de caracteres de dicha cadena excluyendo su carácter 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 paraintroducir el nombre del fichero de extensión “.asm”.

2.-Funciones relativas al Linkador:

Ahora se pasará a explicar las nuevas funciones de entrada y salida del linkador. Enel linkador no se ha creado otro formulario de salida y otro de entrada. Ya que se haaprovechado el mismo que se ha creado para el ensamblador. La verificación yconfirmación de los mensajes, información, “warnings”, número de errores, etc delprograma final y definitivo se ha hecho comparándolos directamente con los obtenidosen el formulario provisional de salida. También se ha tenido en cuenta la posibilidad deactualización posterior del linkador. En las funciones siguientes del linkador,simplemente se han renombrado todas las funciones y se ha modificado el contenido delas mismas para que impriman su nombre en el formulario de salida para confirmar queel programa llega allí donde se encuentran y no se atascan antes , entre medio odespués. El motivo de su renombramiento y posterior modificación es al igual queocurría con las funciones del ensamblador por causas de compatibilidad de los sistemasoperativos, ya que las funciones que había antes son exclusivamente para DOS y no sonportables a un entorno Windows. Dichas funciones únicamente se encargaban deaspectos gráficos o estéticos, de producir sonidos cuando sugía algun error, etc. Dichasfunciones 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 )

26

-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 más importante encuanto a que contiene todas las funciones que se ejecutan cuando ocurre cualquierevento en el formulario. Todo formulario, por el hecho de ser creado lleva asociado unarchivo de extensión “.cpp” donde se encuentran todas las funciones que hacenreferencia a dicho formulario. En el proyecto este formulario es el único, ya que tantoensamblador como linkador se encuentran en la misma ventana y se pueden seleccionarcon tan sólo presionar en sus solapas respectivas, pero puede darse el caso de que hayanmás formularios con otras opciones o dedicados a otras tareas, en ese caso, hay que ir almenú del compilador y hacer clic en “project”, y seguidamente ir a “opciones”. Sepodrá ver el siguiente cuadro de diálogo:

Figura 11. Algunas opciones del compilador

27

En “Main form” se ha de introducir el nombre del primer formulario que ha de salirpor pantalla en momento que se ejecute el programa. En este caso se han creado variosformularios teniendo en cuenta los formularios provisionales de entrada y salida, pero elprograma definitivo tan sólo consta de uno principal.

A continuación 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 extensión “.h” de los formulariosde salida y entrada provisionales y por supuesto el archivo “old_io.h”, ya que senecesitarán las funciones de entrada y salida que se han implementado para losformularios provisionales. También es básico 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á alusión a algunas de las funciones contenidas en ellos.Después de las librerías se tiene la siguiente declaración, 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 función principal por excelencia. Al hacer clic sobre el control “Ensambla” seejecuta esta función. En primer lugar, mediante la siguiente línea, se muestranmostramos los mensajes pertinentes en el “memo” de salida provisional:

FormSalida->Show()

“Show()” es un método de la clase “TForm” cuya función consiste en mostrar porpantalla el contenido del formulario en cuestión. A continuación viene la parte másimportante de la función:

try

{

Form2->Memo2->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 encaso de que no fuera posible por causa de algún error, con el comando “catch” selanzaría una excepción al sistema para avisar de que ha acabado de ejecutarse elprograma con éxito o bien algo ha ido mal. En este caso, “try” contiene entre suscorchetes en primer lugar el método “Clear()” para limpiar los “memos” del formularioantes de que se ejecute el programa, por si hay algún resto de alguna ejecución anterior.A continuación se intentará ejecutar el “main”, en este caso la función principal del

28

ensamblador contenida en el fichero “ENS68K.cpp” (por eso se ha incluido el ficherode cabecera correspondiente a este archivo, más arriba). Si se produjera algún tipo deerror, como por ejemplo una entrada de argumentos errónea por parte del usuario, etcentonces se lanzaría una excepción como se ha dicho anteriormente. En este caso laexcepción se producirá por causas de un error e imprimiría un mensaje en la pantallamediante la función renombrada “old_cprintf”, pero también puede producirse paraavisar al programador de que el programa ha finalizado con éxito, como veremos másadelante conforme vayamos analizando el código 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) => Todasestas funciones se encargan de mostrar en el “memo” de errores los mensajes deposibles errores. Todas poseen la misma estructura, lo único que varía son losargumentos que se les pasan. Mediante la función “sprintf()” se copia una cadena decaracteres al “string” “cadena”, para posteriormente mostrarla en el “memo” mediantela acción:

Memo1->Lines->Add(cadena)

Como ya hemos dicho anteriormente “Add()” es un método de objetos de la clase“Tstring” y actúa como tal sobre “strings”. En este caso “Memo1” es el nombre que sele ha puesto al “memo” de errores para referirnos a él en el código. No hay queconfundir “Name” con “Caption”, ya que el primero es el nombre con el que elprograma conoce a una variable a la hora de operar con él, etc y “Caption” es el nombreque 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 losmensajes 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 función que las anteriores,pero con la particularidad de que escriben sobre el “memo” de información. En el“memo” de información se muestran mensajes como el número de pasadas que se hanhecho al ensamblar, avisos sobre la reubicabilidad o no del código en ensamblador, etc.En este caso, “Memo2” es el nombre del “memo” de información.

29

-void __fastcall TForm2::FuenteChange(TObject *Sender) => Mediante estafunción se copia simultaneamente el nombre introducido en la etiqueta del ficherofuente, a los campos donde se debe introducir el nombre del fichero de destino y el delistado. La razón de ser de esta función es porque normalmente los nombres de losficheros destino y listado suelen tener el mismo nombre que el fichero fuente. Sinembargo, en caso de que el usuario deseara que los nombres de esos campos fuerandistintos a los del fichero fuente, podrían cambiarlos posteriormente sin ningúnproblema.

Destino->Text=Fuente->Text Listado->Text=Fuente->Text

Para implementar dicha función, simplemente se hace que la propiedad “Text” de losobjetos de tipo “TEdit”, es decir, las etiquetas o labels adquieran el valor de lapropiedad “Text” de la etiqueta del fichero fuente.

-void __fastcall TForm2::FormResize(TObject *Sender) => Mediante estafunción se hace que el formulario del programa sea totalmente redimensionable.Cuando se dice totalmente redimensionable, se hace refierencia a que no sólo la ventanaen si es redimensionable, si no que los elementos u objetos contenidos en él también loson, puesto que no tendría mucho sentido lo contrario, y además no quedaría bien desdeel punto de vista estético.

En primer lugar se definen 2 “Offsets” iguales, uno para el eje o componente X yotro para el Y, que son las distancias desde los extremos del formulario hasta los memosde información y de errores.

A continuación mediante el siguiente comando, se está diciendo que si la propiedadActivePage 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 línea siguiente, cuando presionamos la pestaña del“linker” activamos esa parte:

else if(Pestanas->ActivePage==Linker)

A continuación se define la altura del extremo superior del formulario a las etiquetas.El resto de código se encarga de adecuar las medidas de los formularios según los“offsets” que se han definido y la dimensión que le da el usuario al hacerla más grandeo más pequeña. Dicha dimensión viene dada mediante “ClientHeight” y “ClientWidth”.Ambas son propiedades del objeto “Pestanas” y hacen referencia al area que ocupa elusuario con su ventana. Tanto la anchura como la altura viene dado en “pixels”.

Con la parte que se obtiene al hacer clic sobre la pestaña del “linker”, exactamente lomismo.

-void __fastcall TForm2::PestanasChange(TObject *Sender) => En estafunción se actualizan las partes según se haga clic en una pestaña o en otra. En primerlugar se selecciona, como en la función anterior. El ensamblador mediante la línea decomando:

if(Pestanas->ActivePage==Ens68K)

30

En cambio el linkador lo seleccionamos mediante:

else if(Pestanas->ActivePage==Linker)

A continuación en el código contenido tras esas líneas de comandos, se asignan a los“memos” de información y de errores de ambas partes otros nombres para que el códigodel programa principal pueda distinguir a los memos de errores y de información delensamblador por un lado:

Memo1=Memo1_Ens68K;

Memo2=Memo2_Ens68K;

y a los memos de errores y de información de la parte que hace referencia allinkador por otro:

Memo1=Memo1_Linker;

Memo2=Memo2_Linker;

Esta función se ejecuta cada vez que presionamos en una de las pestañas y justodespués de ejecutarse, mediante la línea situada más abajo, lo que hacemos es actualizarla ubicación de todas las etiquetas y memos a la posición que poseían justo antes decambiar de parte, ya sea de ensamblador a linkador o viceversa:

FormResize(this);

Si no estuviera este comando, al hacer clic sobre una de las pestañas para pasar a laotra parte, se tendría que la situación de las “Labels” sería la que había al principio deejecutar el programa por defecto, y por tanto incorrecta ya que deben estar, tanto lasetiquetas como los “memos” en el mismo lugar donde se encontraban justo antes decambiar de parte.

El argumento “this” que contiene el último FormResize hace referencia al formularioprincipal. También se podría haber puesto el nombre (“Name”) del formulario.

-void __fastcall TForm2::Linka1Click(TObject *Sender) => A continuaciónviene la función principal del linkador. Esta función se ejecuta cada vez que se presionasobre el control “Linka” del menú que se encuentra en la parte superior formularioprincipal.

En primer lugar mediante la siguiente línea, escribimos en el formulario de salidaprovisional:

FormSalida->Show();

Seguidamente y dentro de “try”, con los comandos que vienen a continuación,limpiamos los memos de ambas partes antes de que se ejecute la función principal:



Y finalmente ejecutamos el “main”:

main_link();

Si dentro de “try” se ha provocado alguna excepción, como en este caso, elcomando “catch” se encargará de detectarla y mostrarla por pantalla. En este casomostraremos:

31

old_cprintf("SE HA PRODUCIDO UNA EXCEPCION: %s\n",msg);

Como ya se ha dicho anteriormente, el hecho de que se lance una excepciónmediante “Throw” (en el caso de C++ Builder) no significa que sea forzosamente frutode un error, sino que se trata simplemente de un aviso para indicar que se ha finalizadocon éxito un programa, o bien también puede indicar que se ha producido un error.

-void __fastcall TForm2::objChange(TObject *Sender) => Esta función aligual 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 albergarán losficheros de extensión “.s28” y “.map”. Los comandos, como se puede apreciar son losmismos, con la diferencia de que son las etiquetas “s28” y “map” las que copiaran elnombre 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 había para DOS está preparado para linkar más de un fichero objeto.Por ello se ha provisto al formulario de una “ListBox” donde se puedan añadir yalmacenar los sucesivos archivos de extensión “.obj” que se quieran añadir. Además delnombre del fichero, la “ListBox” también puede guardar la dirección de memoria dondese quiere linkar el archivo. En caso de que el archivo en código ensamblador seareubicable, es decir que su código fuente en ensamblador (.asm) no posea la directiva“ABSOLUTE”, por el “memo” de errores del linkador se instará a introducir ladirección de memoria donde se desea linkar dicho fichero.

En primer lugar, se define un “Ansistring” llamado “línea”. Después se mira si se haintroducido alguna dirección en la etiqueta dispuesta para ello, cuyo nombre es “Edit1”.Para ello simplemente se mira la longitud del “Ansistring” introducido en “Edit1”. Sidicha longitud es igual a 0, es decir, si no hay nada escrito, entonces simplemente seescribirá en la “ListBox” el nombre del fichero a linkar sin especificar la dirección dememoria 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 condición anterior, se ejecutaría el siguientefragmento de código:

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 posición del carácter dentro del “ansistring”. Mediante

32

“sscanf()” se coge la posición de memoria que se introducirá en la etiqueta “Edit1”.Seguidamente se almacenará en el “ansistring” “linea”, el nombre del fichero que sequiere linkar junto con su posición de memoria, separados ambos por una “@” queindica que el número que lleva pegado a ella es una dirección de memoria. En esamisma asignación se convierte la posición de entero a hexadecimal mediante la función“IntToHex”, ya que el ensamblador trabaja con este tipo de numeración. Finalmente seañade el “ansistring” “linea” a la “ListBox”.

-void __fastcall TForm2::kitarClick(TObject *Sender) => La siguiente yúltima función de este archivo, se encarga de limpiar la “ListBox” en caso de que elusuario desee linkar ficheros diferentes a los que ya había introducido anteriormente.Para ello simplemente asignamos una cadena vacía a la propiedad “Items” del objeto“ListObj”.

b).Archivos relativos al Ensamblador

-ENS68K.cpp

Este es el módulo principal del programa que hace referencia a la parte delensamblador. Desde aquí se llama a otros submódulos del ensamblador.

En primer lugar se tienen los archivos de cabecera en la parte superior. Entre ellosestán “old_io.cpp” y “menuprin.cpp” que ya se ha comentado antes y que es donde seencuentran todas las funciones de interfaz con el usuario entre otras. También cabedestacar la librería standard “vcl.h” (Visual Component Library), ya que en ella seencuentran todas las funciones que hacen referencia a los elementos gráficos, controlesy objetos que ya vienen creados en el entorno C++ Builder. Las librerías contenidasentre <> son las que ya vienen implementadas y las que vienen entre “” son los archivoscreados por la persona que realice el proyecto y que contienen funciones que seemplearán en este fichero.

Seguidamente se declaran las variables globales empleadas en este módulo, algunasde las cuales son inicializadas.

A continuación se definen todos los posibles mensajes que se mostrarán en los“memos” de error y de información dependiendo de los errores que tenga el archivo aensamblar o de los datos que introduzca el usuario por teclado. Dichos mensajes sealmacenarán en un “array” de punteros a carácter:

char *mensaje_ens68k[]

Después se definen las funciones que se emplearán en este módulo.

Ahora se pasará a explicar las funciones que conforman este fichero:

-int old_main(int argc,char *argv[]) => Luego viene ya el “main” o funciónprincipal, la cual se ejecutará cuando se la llame desde el módulo “menuprin.cpp” comoya se ha dicho antes, haciendo clic en el control “Ensambla”. El “main” delensamblador 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 módulo, ambos

33

poseían el mismo nombre. Como se puede apreciar, a esta función se le pasan 2argumentos:

-int argc

-char *argv[]

el primero de ellos indica el número de argumentos y el segundo el argumento en sí,es decir los nombres o comandos que se introducirán. A diferencia de la versión quehabía para DOS, el presente programa se hace con esta información a través de lasetiquetas que se han creado para introducir los nombres de los diferentes ficheros. Enconcreto, la forma en la que se le dice cual es el nombre del fichero fuente es a través dela línea de comandos:

strcpy(fuente,Form2->Fuente->Text.c_str());

Mediante “strcpy()” se copia el “ansistring” introducido en la etiqueta “Fuente” a unacadena de cadena de caracteres llamada también “fuente”. Si al entrar el nombre delfichero se produce algún error, entonces se lanza una excepción para indicar que se haproducido tal error:

if(!strlen(fuente))

{

old_clrscr();

copyr();

throw "ENS1";

}

Con el código: “!strlen(fuente)” miramos si la longitud de la cadena introducida esigual a cero, si es así se entrará en el bucle que lanza la excepción. El “throw” sustituye,como se explicó brevemente al principio del proyecto, a “exit()” que es la manera delanzar una excepción en DOS.

Seguidamente mediante las siguientes líneas de código, lo que se hace es comprobarsi el usuario ha introducido la extensión del fichero, en este caso “.asm”. En caso de queno lo haya hecho, se añade la extensión automáticamente gracias a la función “strcat()”:

if (!strchr(fuente,'.'))

strcat (fuente,".asm");

Para hacerse con el nombre que se le quiere dar al fichero objeto, se hace algosimilar, 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 elusuario ha introducido la extensión correspondiente a éste. En este caso “.obj”:

if (!strchr(destino,'.'))

strcat (destino,".obj");

El resto de la función principal se encarga de realizar una primera pasada por elensamblador. El programa llena la tabla de símbolos y calcula la longitud de cada unade las instrucciones mientras detecta posibles errores de sintaxis o “labels” mal situadaso incorrectas.

Por el “memo” de información se avisará cuando se haya concluido la primerapasada.

34

En la segunda pasada se realiza la codificación de las instrucciones. Como la tabla desímbolos está completa, se resuelven las llamadas a las etiquetas. Si se da el caso de quelas etiquetas que no existan, éstas se considerarán externas al módulo y se prepararánpara resolverse en el linkador.

Al igual que antes se advertirá de que ha tenido lugar una segunda pasada por el“memo” de información 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 instrucción a ensamblar contenidaen el fichero “.asm”.

En esta segunda pasada se procede al tratamiento de las directivas. Es prácticamenteigual que en la primera pasada, con la salvedad de que ahora se graban en el ficheroobjeto.

-static int lee_linea(char *s,FILE *ff) => Esta función lee una linea delfichero que especifiquemos sin importar si la línea acaba en “\n” o si acaba en “\r\n”. Lavariable “n” limita el número de caracteres que se pueden leer por línea. En este cason=255 como máximo.

-static void imprtitulo(void) => Esta función graba en el fichero de listado elnombre del programa , el número de página y un título que se puede especificar con ladirectiva “TITLE” , en la cabecera de la página. Si no es la primera página saltará una.

-static int trans (char *entrada,char *salida,int *error) => Esta funcióncoge un “string”, que serán los parámetros de una directiva del tipo DC y los analizadevolviendo otra cadena que serán una serie de dígitos hexadecimalesequivalentes 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 espaciospara evitar caracteres indeseados en los “old_cprintf”, pero no modifica “s” para evitaralterar las funciones que emplean punteros sobre “s”.

-void ini() => Esta función es básica para que el programa ensamble tantas vecescomo se quiera, ya que si se omite sólo ensamblaría bien la primera vez. Lo único quese hace en su interior es inicializar las variables que deben ser inicializadas con uncierto valor justo antes de ejecutarse el programa.

-COPYR.cpp

En este archivo tan sólo contiene una función:

-void copyr();

35

cuya única misión es mostrar en el memo de información un mensaje depresentación.

-TABLA.cpp

Este módulo contiene el ensamblador de líneas y las tablas que utiliza éste,conteniendo los nombres de los nemotécnicos , y otros valores necesarios para elensamblado. En este caso no se incluyen los archivos de cabecera de los componentesvisuales (vcl.h), ni el de funciones de entrada y salida, ni tampoco el que contiene lasfunciones asociadas a nuestro formulario, debido a que todas las funciones contenidasen este archivo son puramente relativas al funcionamiento del ensamblador en sí. Enresumen, la misión de las funciones contenidas en este archivo es la decodificación delas instrucciones del motorola 68000.

A continuación se definen las constantes que nos indicarán si un nemotécnico, undireccionamiento o un tamaño son incorrectos, el número de nemotécnicosimplementados, etc.

Seguidamente se definen las funciones empleadas, donde se encuentran todas lasinstrucciones ensamblador del MC68000. Luego vienen dadas varias tablas donde seencuentran los nombres de todas las instrucciones, los tamaños correspondientes a cadainstrucción, una tabla de valores y finalmente una tabla con el número de operandos quepuede tener cada instrucción y otra con la longitud que pueden tener dichos operandos.

A continuación, después de declarar todas las variables globales vienen las funcionesimplementadas:

-int decodifica(char *s,char *e) => La función decodifica es un ensamblador delíneas. Devuelve el error cometido como resultado de la función y el ensamblado nosdevuelve la línea ensamblada. En la variable global “segunda_pasada” se debeespecificar si estamos en la primera o en la segunda pasada.

-int buscar_tabla() => Esta función busca en la tabla de instrucciones la instruccióncorrespondiente a un numero dado.

-procesar(int (*f) ()) => A esta función simplemente se le pasa como argumentoun puntero a función 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),

36

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 número de operandos, su longitud, la longitud de

las diferentes instrucciones, etc.

-static void invertir (char *) => Invierte la máscara de registros en losdireccionamientos en que es necesaria esta inversión.

-static int mascara(char *,char *linea) => Crea la máscara de registros en lainstrucción “MOVEM” y devuelve si ha habido algún error 35 que es el error en la listade registros.

-static void opp_a_op(void) => Esta función actualiza el valor de los operandos,dándoles los valores que se les hayan introducido en el programa en ensamblador.

-FUNC.cpp

Este módulo contiene una serie de funciones de apoyo para el ensamblador de lineas,para extraer operandos, nemotécnicos y para descifrar los operandos y codificarlos. Aligual que en el archivo anterior, aquí tampoco se citarán el archivo de cabecera quecontiene los componentes visuales ni los que contienen las funciones de interfaz con elusuario o las relativas directamente a nuestro formulario.

A continuación se pasa a explicar cada una de las funciones que conforman estearchivo:

-char *coger_palabra(line,palabra,label) => Esta función devuelve en“palabra” la primera palabra de una linea, en “linea” la posición dentro de la línea dondeempezará a buscar los parámetros la función correspondiente, y finalmente “label” dicesi lo que ha encontrado es una “label” o no. En “size” devuelve “1” si la instrucción esde tamaño “byte”, 2 si es de tamaño “word” y 3 si es de tamaño “long word”. Si no seha especificado un tamaño devuelve 4 y si hay un error “size” pasa a valer 16. Cabedestacar que una etiqueta no debe llevar ningún punto.

Lo que hace en primer lugar esta función es elimar espacios, después una vez llega auna palabra, se hace con ella y lo primero que hace es comprobar si es una etiqueta o escualquier otra instrucción. En caso de que efectivamente sea una etiqueta la funciónhabrá finalizado su tarea, de lo contrario, si se trata de una instrucción, la funciónaveriguará el tamaño de la misma. Finalmente se hace que “line” apunte a la próximapalabra de la línea.

37

-char *cogeyanal(line,err,externo,aa) => La función “cogeyanal” devuelvecomo resultado un apuntador al próximo carácter después del operando y en “err” elerror 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= Dirección absoluta

12= CCR

13= SR

14= USP (+error =8)

En primer lugar la función mira si la instrucción contiene algún operando. Acontinuación, según si lleva o no paréntesis descartará unos modos de direccionamientou otros o si se introducen más paréntesis de los necesarios, en cuyo caso emitirá unerror. Además también se buscan posibles errores de sintaxis, se mira si un operando eso no un registro y se vigila que los tamaños de los operandos sean los correctos.

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

-int tipo2(valor,aa,ensamblado,operando) => En esta función se va copiando aun “array” de punteros a carácter los valores que se van ensamblando.

-int tipo3(valor,aa,ensamblado) => En esta función exactamente igual que en laanterior, sólo que ahora se miran los tamaños de las etiquetas de nuestro archivo “.asm”para vigilar que no ocupen más memoria de la que deberían.

-int masde4bits(a),

-int masde8bits(a),

-int masde16bits(a) => Mediante estas 3 funciones se identifica el tamaño de losoperandos.

38

-long int hexdec(expresion,err) => Esta función se encarga de convertir valoresde hexadecimal a decimal, ya que las direcciones de los registros y datos vienencodificadas de esa manera.

-long int bindec(expresion,err) => Esta función se encarga de convertir valoresde binario a decimal, puesto que el usuario o programador puede introducir lasdirecciones directamente en binario poniendo previamente al número el símbolo “#”.

-ARBOLES.cpp

Este módulo contiene las funciones de manejo de los árboles binarios utilizados eneste ensamblador para almacenar y recuperar las etiquetas , sus valores y el tipo deetiqueta que es. Tampoco en este caso se incluyen las librerías visuales ni los archivosque contienen las rutinas de interfaz. En la declaración de variables, se puede apreciarque en:

static char ti[][24]

se almacenan los mensajes que se pueden presentar por el “memo” de informacióndel ensamblador relativos a las etiquetas.

A continuación se explican las funciones contenidas en este archivo:

-struct arbol *buscar_rama(struct arbol *a,char *label) => Esta funciónbusca dentro de una estructura de árbol binario, en el cual se tendrán las etiquetas delprograma, una determinada etiqueta, devolviéndonos un puntero a la rama que estamosbuscando. Se trata de una función recursiva. Esta función es llamada cada vez que esnecesario recuperar el valor de una etiqueta.

-void eliminar_rama(a,label) => Esta función elimina de una estructura de árbolbinario donde se tendrán las etiquetas del programa una determinada etiqueta. Estafunción es llamada por las funciones “equ”, “high” y “low” del módulo “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 función insertadentro de una estructura de árbol binario, en la que se tendrán las etiquetas delprograma una determinada etiqueta, devolviéndose un puntero a la raíz del árbol. Es unafunción recursiva.

-void listar_arbol (a,i) => Esta función inserta dentro de una estructura de árbolbinario, en la que se tendrán las etiquetas del programa, una determinada etiqueta,devolviéndose un puntero a la raiz del árbol. Al igual que en el caso anterior, se trata deuna función recursiva.

39

-PARSER.cpp

Este módulo contiene un “parser” del tipo recursivo descendente para descifrar yevaluar expresiones matemáticas y lógicas con números en binario, decimal yhexadecimal así como con etiquetas previamente definidas.

Tampoco esta vez se declaran las librerías de componentes visuales ni los archivosde cabecera con las funciones de entrada/salida (I/O). Luego se declaran las variablesglobales y las funciones empleadas en este módulo.

A continuación se pasa a explicar dichas funciones:

-static void coger_expresion(resultado) => Esta es la función a la que se llamapara resolver una expresión. Es llamada por la función “hallar_valor()” queinicializa el “PARSER” y lo prepara para funcionar correctamente.

-static void nivel1(resultado),





-static void nivel6(resultado) => Estas funciones evalúan trozos de laexpresión a evaluar teniendo en cuenta los niveles de prioridad del álgebra.

-static void primitiva(resultado) => Esta función 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 desintaxis en la expresión.

-static void arit (o,r,h) => Esta función realiza una operación especificada en lavariable o sobre los términos “r” y “h”. Esta operación debe ser una de las operacionesválidas implementadas en este “PARSER”.

-static void unitario (o,r) => Esta función se utiliza para implementar el "NOT"lógico y el cambio de signo.

-static void coger_termino() => Esta función se encarga de extraer uno a uno lostérminos que forman la expresión a evaluar. Extrae los términos de la expresiónalmacenada en “p” y los coloca en “termino”.

40

-static esdelimitador(c) => Esta función devuelve un “1” si el carácter que se lepasa es un delimitador, y un “0” si no lo es.

-long int hallar_valor (palabra,longitud,err,reubicable,externo) => Estafunción es la función principal del “PARSER” ya que es la función a la cual se llamapara resolver una expresión desde el exterior de este módulo. Se encarga de llamar a lasdistintas funciones del “PARSER” y de devolver el valor, mensajes y errores.

-static long int valor (puntero) => Esta función halla el valor de un símbolo yel tipo de símbolo que es.

-ERRORES.cpp

Este módulo contiene los mensajes de error del ensamblador. En este caso puedeverse como sí que contiene las librerías de componentes visuales (vcl.h) así como elarchivo que contiene las nuevas funciones de entrada/salida, ya que se emiten mensajesen los “memos” y finalmente la que hace referencia al formulario, ya que los mensajessaldrán en un objeto contenido en él. La variable que almacena estos mensajes es unarray de punteros a carácter:

*terror[]

Tan sólo contiene la función:

-void error(tipo) => Esta función se llama cada vez que el ensamblador encuen-tra un error y nos muestra una descripción del error cometido por la pantalla. Cada vezque se llama a esta función se incrementa la variable global “errores” que contiene elnúmero total de errores cometidos durante el ensamblado. Cabe destacar además quemediante, las líneas siguientes, se muestran los mensajes de error por el “memo” deerrores del ensamblador:

Form2->Show();

Form2->Printf_Error("** %s **\n\r",terror[tipo+idioma*NE]);

b).Archivos relativos al Linkador

-LINKER.cpp

Este es el módulo principal del programa que hace referencia a la parte del linkador.Desde aquí se llama a otros submódulos del linkador.

En primer lugar se tienen los archivos de cabecera en la parte superior. Entre ellosestán “old_io.cpp” y “menuprin.cpp” que ya se ha comentado antes y que es donde seencuentran todas las funciones de interfaz con el usuario entre otras. También cabedestacar la librería standard “vcl.h” (Visual Component Library), ya que en ella seencuentran todas las funciones que hacen referencia a los elementos gráficos, controlesy objetos que ya vienen creados en el entorno C++ Builder.

41

A continuación se declaran las variables globales y las funciones empleadas. Una delas variables es la siguiente:

char *mensaje_linker[]

Se trata de un “array” o vector de punteros a carácter que almacenan las direccionesdonde se encuentran los mensajes tanto de información como de posibles errores dellinkador.

Seguidamente se describen todas las funciones que componen este módulo:

-int main_link() => Es la función principal del “linker” y se ejecutará cuando se lallame desde el módulo “menuprin.cpp” como ya se ha dicho antes, haciendo clic en elcontrol “Linka”. También aquí ha sido renombrada la función principal para que no seaconfundida con el “main” del ensamblador.

En primer lugar, la variable “a” que es del tipo “register int”, toma el valor que lepasa la función “coger_fichero()” y es en esta función donde se consigue el nombre delfichero que se desea linkar. “coger_fichero()” es la función contigua a la presente, y seestudiará posteriormente en profundidad. Si la función “coger_fichero()”, la cual retornaun entero, le devuelve un entero diferente de 0, entonces significa que no ha habidoerrores. A continuación la función mira si es reubicable el fichero de extensión “.asm”.Si es reubicable y el usuario no le ha introducido ninguna dirección donde linkarlo, elprograma mostrará en el “memo” de información del linkador un “warning” o aviso alprogramador, para que introduzca una dirección de memoria. La variable “pos” es laque contiene el valor de dicha dirección, y la función “cogerposicion()” la que se loproporciona. Si de lo contrario el fichero “.asm” posee la directiva “ABSOLUTE”,entonces el programa no pedirá al usuario ninguna posición de memoria.

Mientras no hay ningún 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 denuestro fichero objeto) sea diferente de 0, el programa seguirá pidiendo nombres defichero para linkar. En la presente versión para C++ Builder los datos son introducidosprimero en la “Label” o etiqueta correspondiente al fichero objeto, y posteriormentemediante el control “Añadir” se introduce en la “ListBox”.

Luego el programa se hace con todas las etiquetas tanto globales como locales yexternas, y asigna un valor absoluto a las etiquetas reubicables. Después comprueba queno estén repetidas.

Si se produce algún error al ejecutarse el proceso, se lanza una excepción mediante“Throw” para indicar que hay algo incorrecto o que ha acabado exitosamente laejecución.

Seguidamente se lee del fichero “.asm” y se sustituyen las etiquetas no resueltas en elensamblador. Inmediatamente después se crea el fichero de destino cuya extensión es“.s28”.

-int cogerfichero(f,tipo) => Mediante esta función se coge el nombre de losficheros. Se estudia la variable “tipo” que puede tener los valores 0, 3 ó 4.

Si “tipo”== 0 se trata de un fichero de extensión “.obj”.

Si “tipo”== 3 se trata de un fichero de extensión “.s28”.

42

Si “tipo”== 4 se trata de un fichero de extensión “.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 losficheros 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 número de“Items” totales de la “ListBox” para ver si ha acabado. Si es así, el contenido delpuntero “*f” se inicializará a “0” para la próxima vez que se linke.

Si no es así, es decir si se tiene la línea de más abajo, entonces significa que elprograma 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 poseedistintas propiedades para manipular los “strings” o cadenas de caracteres contenidos enla “ListBox”. “Count” es una de las propiedades de “Items” e indica el número 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 línea de código, 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 continuación se mira si el “ansistring”actual contiene el carácter “@”. En caso de que el fichero “.asm” sea reubicable, el

43

“ansistring” de la “ListBox” contendrá una “@” a causa de la función que se haimplementado anteriormente contenida en el archivo “menuprin.cpp”. Si contiene la“@” mediante la siguiente línea de código, se conseguirá el índice o la situación dondese encuentra dicho carácter:

posarroba=todo.AnsiPos("@")

“Ansipos” es un método de objetos de la clase “ansistring” que retorna la posiciónde un determinado carácter que contiene un “ansistring”. Si dicho carácter no estácontenido en el “ansistring” entonces retornará un "0". Si no encuentra la “@” significaque el usuario no ha insertado una posición de memoria donde ensamblar el fichero, encuyo caso el programa únicamente se hará con el nombre del fichero asignando altambién “ansistring” “dato” el “ansistring” “todo”. Sin embargo, si el “ansistring”“todo” si que contiene el carácter “@” mediante la siguiente línea de código, se coge elnombre del fichero.

dato=todo.SubString(1,posarroba-1)

“Substring” es otro método de los objetos de la clase “ansistring” que coge un“substring” existente dentro de otro “ansistring”. En esta parte sólo coge el nombre delfichero y no la posición de memoria. Lo que indica que “substring” se coge dentro del“ansistring” es la posición de inicio y de final, en este caso la posición inicial es elprimer carácter y la final, una posición justo antes de la “@” con lo cual abarca todo elnombre 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 incrementael í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 posición de memoria, ésta se procesa en la función:

void __fastcall TForm2::AnadirClick(TObject *Sender)

como ya se ha explicado en el apartado referente a las funciones de las que secompone 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” alas variables corespondientes con las que trabaja el programa a la hora de procesar dichainformación.

Seguidamente se asigna a la variable “i” el número de caracteres que contiene el“ansistring”, es decir, la longitud del nombre del fichero. Si “i” igual a 0, en la versiónpara DOS se salía del bucle infinito, es decir, ya no seguía pidiendo nombres elprograma.

A continuación, en el trozo de código siguiente, mediante la función “strchr()” sebusca el carácter ‘.’ en la cadena “f”, y si no la encuentra le concatena o añade laextensión “.s28” a partir de la función “strcat()”.

if (!strchr(f,'.'))

strcat (f,".S28");

44

Es decir, que si el usuario no introduce la extensión, ésta es añadida automáticamentepor el programa. En el ejemplo de arriba era el caso que hacía referencia a ficheros deextensión “.s28”; pero también se hace esto con los otros 2 tipos de ficheros de la formasiguiente:

if (!strchr(f,'.')) strcat (f,".MAP")

if (!strchr(f,'.')) strcat (f,".OBJ")

Luego, mediante la función 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 código de la función principal se encarga de linkar dichos ficheros.

-long int cogerposicion() => Esta función es la que coge la posición dememoria en caso de que el fichero sea reubicable.

En primer lugar, mediante la linea de código siguiente, asignamos al “ansistring”“todo” todo el “ansistring” que se encuentre en la posición de la “ListBox” que toque:

todo=Form2->ListObj->Items->Strings[indice_obj-1]

Seguidamente a partir de:

posarroba=todo.AnsiPos("@")

se averigua la posición donde se encuentra el carácter “@” el cual queda almacenadoen la variable “posarroba”.

Si no contuviera la “@” dicho “ansistring”, es decir, si el método “Ansipos()”devuelve un 0, entonces se mostraría por el “memo” un mesaje de error, advirtiendo deque ese fichero no es reubicable y a continuación se lanzaría una excepción mediante“throw” y se imprimiría el texto: “LINK3” el cual identifica a dicha excepción.

Sin embargo, si se encuentra el carácter “@”, entonces primero se averigua lalongitud de la posición, es decir, los caracteres que ocupa. Para ello se resta a lalongitud total de la cadena, la longitud que hay desde el primer carácter de todo el“ansistring” hasta donde se encuentra la “@”, ésta inclusive, y de esta forma lo quequeda es la longitud del “substring” que contiene la posición de memoria y que seráalmacenada en la variable “longdato”.

Finalmente mediante el método “Substring()” se almacena en el “ansistring” “dato”,la posición de memoria. La variable “longdato” dice el número de caracteres que sedeben coger de todo el “ansistring”.

-long int hexdec(expresion) => Esta función convierte un número de hexadecimala decimal, y hace referencia a las posiciones de memoria que se utilizarán para linkar,ya que éstas vienen en hexadecimal por defecto.

-int buscarlista(struct lista *lista,char *fichero) => Esta función sellama en la función principal del linkador y se encarga de buscar los ficheros a linkar,como ya se ha dicho anteriormente.

45

-void insertarabs(e) => Esta función tiene por misión hacer que un archivoreubicable se convierta en absoluto en la dirección que haya introducido el usuario en la“Label” correspondiente.

-void insertarreu(e) => Esta función realiza la misma función que la anterior, perocon más de un fichero, es decir los ubica a todos a partir de la dirección que introduzcael usuario.

-void listar(l) => Esta función simplemente se encarga de listar todos los ficheros alinkar.

-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 función comprueba etiquetas externas, esdecir, por ejemplo puede ocurrir que en un archivo “.asm” en cierta zona del código, sequiera saltar a una etiqueta externa a ese código, es decir, perteneciente a otro archivoque también se va a linkar.

-struct etiqueta *buscar_etiqueta(struct etiqueta *a,char *etiqueta) =>Esta función simplemente busca etiquetas en archivos.

-void sexit() => Esta cadena finaliza la función mostrando el “copyright”. Esto en laversión anterior para DOS, ya que ahora ya no ocurre eso.

-void nexit(int ne, char mis[]) => Esta función es la opuesta a la anterior, yaque sale del programa pero lanzando una excepción mediante “throw”, que en este casoavisa de que se ha producido algún error. Para que podamos identificar esta excepción ydiferenciarla de las demás, se imprimirá: “ENS1”.

-int esta_en (c,s),

-void s28(s),

-void volcars28(),

-int checksum(char *a) => Son funciones para DOS que realizan operacionessencillas tales como retornar el valor que se les pasa, comprobar si el nombre de unfichero posee la extensión “.s28”, volcar un nombre de fichero, etc.

46

-Subf2.cpp

Este fichero únicamente contiene funciones exclusivamente para DOS, e inútiles parael nuevo entorno. Simplemente se ocupan del entorno gráfico y la presentaciónmediante la creación de marcos, etc. También hay implementadas pequeñas funcionesque mediante la función “Sound()” emiten un sonido para indicar que se ha producidoalgún error, pasándoles como argumentos la frecuencia a la que queremos que suene yla duración de tal sonido. Tampoco este último tipo de funciones sirve con C++ Builder.Lo único que se ha hecho una vez más es renombrarlas y hacer que muestren por el“memo” provisional de salida su nombre, para comprobar que efectivamente elprograma llega allí.

A continuación se citan:

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

-elimarc(le, to, ri, bo, s) => Elimina dichos marcos.

-int old_sedit(cap,str,m) => Esta función edita por sustitución, un “string”aceptando entradas según un parámetro 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 exclusivasde DOS.

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

-epit() => Realiza la misma función 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 sólo realizan funciones gráficasexclusivas de DOS.

47

-Copyrlink.cpp

Este archivo contiene únicamente una función que muestra el “copyright”:

-copyrlink().

-Parserl.cpp

Este archivo contiene funciones utilizadas a la hora de linkar los ficheros “.obj”.Simplemente realizan sencillas operaciones aritméticas o lógicas.

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

-static void nivel1(long int *) => Esta función hace la OR y la XOR lógicas.

-static void nivel2(long int *) => Esta función hace la AND lógica.

-static void nivel3(long int *) => Esta función suma o resta 2 términos.

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

-static void nivel5(long int *) => Esta función realiza el + o – unitario y lanegación lógica “Not”.

-static void nivel6(long int *) => Se emplea para las expresiones quie vienendadas entre paréntesis.

-static void primitiva(long int *) => Realiza pequeñas operaciones aritméticaspara comprobar si un fichero es reubicable o de lo contrario es ilegal su ubicación.

-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.

48

-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 unarchivo en concreto que se desea linkar.

-int buscar_etiqueta_global(a,etiqueta) => Al igual que la anterior, buscaetiquetas, pero no sólo en un archivo en concreto, sino en todos los que se desea linkar.

49

2 Presupuesto

Material Cantidad Precio/Unidad(ptas)

Total (ptas)

Compilador paraC++ Builder Standar

1 35.583 35.583

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

Horas deprogramación

120 4.000 480.000

TOTAL 515.583

50

3 Conclusiones

La realización de este proyecto era necesaria desde un punto de vista decompatibilidad con la mayoría de los sistemas, puesto que la gran mayoria utilizan en laactulidad sistemas operativos tipo Windows de Microsft en sus diferentes versiones. Elprograma del proyecto es portable y funciona sobre cualquier plataforma Windows.Además tiene la ventaja de que al ser Windows un sistema operativo multitarea, sepueden tener multiples tareas en activo además del presente programa.

Otra particularidad a destacar es que se ha fusionado en una sola ventana 2aplicaciones de gran importancia desde un punto de vista operativo, puesto que tanto elensamblador como el linkador se encuentran en la misma ventana o formularioprincipal, 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 amboselementos se encuentren implementados en el mismo entorno no es casual, ya que en unfuturo próximo se pretende fusionar todos los elementos que constituyen lasherramientas básicas de simulación, programación e “interface” del MC68000 demotorola con el PC. Se integrarán adémas de los 2 que configuran este proyecto, elSIM68K, que constituye el software de simulación, y finalmente el ITF68K queconstituye el software de comunicaciones.

El hecho de que se haya elegido el lenguaje C++ Buider se basa en múltiplesrazones. Entre ellas cabe destacar que es un lenguaje que ha heredado toda la potenciadel C y la posibilidad de programar en cierta medida a bajo nivel, y del C++ laposibilidad de programar en modo orientado a objetos, lo cual facilita enormemente laprogramación ya que tenemos la alternativa de crear estructuras como hacíamos antañoen C, pero con la posibilidad de insertar funciones en su interior. Finalmente, además deesas capacidades, el C++ Builder posee multitud de clases ya creadas que facilitan engran medida la creación de aplicaciones medianamente complejas para Windows enpoco tiempo. Este tipo de programación se ha standarizado y ha pasado a denominarseProgramación Orientada a Componentes (POC). Ejemplos de dichas clases ya creadaspueden ser los que hemos utilizado básicamente en el proyecto: formularios, “labels” oetiquetas, menús, “listbox”, y un largo etc.

En resumen se ha realizado una adaptación de ambos programas, linkador yensamblador, a C++ Builder siguiendo todo un proceso que garantizara que no hubieraerrores. El código original se ha intentado modificar lo menos posible, aunque esto hasido inevitable a la hora de modificar las funciones de entrada/salida o “interface” con elusuario. Por supuesto todos los archivos que hacen refencia al nuevo entorno creadopara Windows han tenido que ser creados en su totalidad puesto que las plataformas deDOS y Windows son totalmente distintas en cuanto al modo de tratar la información deentrada y salida y sobretodo a la hora de procesar los eventos, como se ha explicado alprincipio 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 laversión para DOS que no serían portables a la nueva plataforma Windows. Entre dichasfunciones se han diferenciado principalmente 2 tipos: unas, las cuales su ausencia noprovocaría error alguno en el funcionamiento de la nueva versión, debido a que eranexclusivas de DOS y simplemente tenían la función de crear un entorno gráfico parapresentaciones por pantalla a partir de marcos, etc o de emitir sonidos para advertir de

51

que se ha producido algún error ya sea por la introducción errónea de los datos por elusuario o por el propio programa; y en segundo lugar las funciones de entrada y salidaque hacen posible la interacción con el usuario. Estas últimas consisten básicamente enfunciones encargadas de coger los nombres de los ficheros a linkar o ensamblar, de lasetiquetas dispuestas para ellos, de conseguir la posición la posición de memoria dondese desea linkar dichos archivos, de mostrar a través de los “memos” del formularioprincipal los errores o “warnings” que se han producido, etc.

Después de esta primera fase de reconocimiento, se ha pasado a renombrar lasfunciones que se comentaba antes. Algunas han sido simplemente renombradas y otrasrenombradas y completamente modificadas.

El primer tipo de funciones para DOS al que se ha hecho referencia antes, las cualesen realidad no tienen ninguna utilidad para el nuevo entorno creado, se han conservadopor diversas razones: en primer lugar lo que se ha hecho con estas funciones es hacerque muestren su nombre por un formulario provisional de salida, de esta forma se podíacomparar y verificar que los mensajes que salían en nuestro formulario final y definitivoeran correctos, y en segundo lugar, como ya se ha dicho anteriormente, se pretenderealizar un macroensamblador a partir de este proyecto, con lo cual dichas funcionesresultarán muy útiles.

El segundo tipo de funciones, son básicas para el “interface” con el usuario. Estas nosólo han sido renombradas sino que en la mayoría de los casos, íntegramentemodificadas. Por poner un ejemplo en las funciones principales del ensamblador y ellinkador contenidas en los ficheros “ENS68K.cpp” y “Linker.cpp” se encuentran loscódigos encargados de hacerse con los nombres de los ficheros a linkar o ensamblar. Enambos casos esto se hacía por teclado. Antes de proceder a su modificación para suposterior adaptación, se ha estudiado detalladamente el proceso y camino de estos datospor parte de la versión para DOS. Finalmente se han adaptado y acondicionado para quepudieran ser compatibles con C++ Builder.

52

4 Pliego de Condiciones

4.1. GENERALIDADES

4.1.1. CONDICIONES GENERALES.

· El presente pliego de condiciones tiene como objetivo definir a la empresaprogramadora el alcance del trabajo y la ejecución cualitativa del mismo.

· El trabajo informática consistirá en la creación del programa y todas las pruebasoportunas para asegurar la fiabilidad del mismo.

· El alcance del trabajo de las empresa Programadora incluye el diseño y preparaciónde todo el material necesario para la adquisición e instalación del programa.

4.1.2. REGLAMENTOS Y NORMAS.

Todas las unidades del programa se ejecutarán cumpliendo las prescripcionesindicadas en los Reglamentos y Normas Técnicas de obligado cumplimiento para estetipo de instalaciones, tanto de ámbito nacional, autonómico como municipal, así como,todas las otras que se establezcan en la Memoria Descriptiva.

Se adaptarán además, a las presentes condiciones particulares que complementaránlas 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 figuraen el contrato establecido con la Empresa Usuaria, o en su defecto a los quince días dela adjudicación definitiva o la firma del contrato.

la Empresa Programadora está obligada a notificar por escrito o personalmente enforma directa a la Empresa Usuaria la fecha de comienzo de la realización delPrograma.

53

4.1.3.2. PLAZO DE EJECUCIÓN:

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 extremoscontenidos en el presente Pliego de Condiciones, o bien en el contrato establecido con laEmpresa Usuaria, solicite una inspección para poder realizar algún trabajo ulterior queesté condicionado por la misma, vendrá obligada a tener preparada para dichainspección, 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 apetición de una de las partes, se podrá convenir una programación de inspeccionesobligatorias de acuerdo con el plan de obra.

4.1.4. INTERPRETACIÓN Y DESARROLLO DEL PROGRAMA.

La interpretación técnica del Programa, corresponde al Técnico Director. LaEmpresa Programadora está obligada a someter a éste a cualquier duda, aclaración ocontradicción que surja durante la ejecución de¡ Programa por causa de una malainterpretación, o circunstancias ajenas, siempre con la suficiente antelación en funciónde la importancia del asunto.

La Empresa Programadora se hace responsable de cualquier error de la ejecuciónmotivada por la omisión de ésta obligación y consecuentemente deberá rehacer a sucosta los trabajos que correspondan a la correcta interpretación del Proyecto.

La Empresa Programadora está obligada realizar todo cuanto se necesario para labuena ejecución del Programa, aún cuando no se halle explícitamente expresado en elPliego de Condiciones o en los documentos del Proyecto.

La Empresa Programadora notificará por escrito o personalmente en forma directa alTécnico Director y con suficiente antelación las fechas en que quedarán preparadas parainspección, cada una de las partes de¡ Programa para las cuales se ha indicado lanecesidad o conveniencia de las mismas.

54

4.1.5. TRABAJOS COMPLEMENTARIOS.

La Empresa Programadora tiene la obligación de realizar todos los trabajoscomplementarios que sean indispensables para ejecutar cualquier parte del Programaespecificadas en cualquiera de los documentos del Proyecto, aunque en el, no figurenexplícitamente mencionadas dichos trabajos complementarios. Todo ello sin variacióndel importe contratado.

4.1.6. MODIFICACIONES.

La Empresa Programadora está obligada a realizar los trabajos que se le encarguenresultantes de modificaciones del Programa, tanto en aumento como disminución osimplemente variaciones, siempre y cuando el importe de las mismas no altere en más omenos de un 25% del valor contratado.

La valoración de las mismas se hará de acuerdo, con los valores establecidos en elpresupuesto entregado por la Empresa Programadora y que ha sido tomado como basedel contrato. El Técnico Director del Programa está facultado para introducir lasmodificaciones de acuerdo con su criterio, en cualquier parte del Programa, durante lacreación, siempre que cumplan las condiciones técnicas referidas en el Proyecto y demodo que ello no varíe el importe total del Programa.

4.1.7. PROGRAMA DEFECTUOSO.

Cuando la Empresa Programadora halle cualquier parte del Programa defectuosa queno se ajuste a lo especificado en el Proyecto o en este Pliego de Condiciones, el TécnicoDirector podrá aceptarlo o rechazarlo; en el primer caso, éste fijará el precio que creajusto con arreglo a las diferencias que hubiera, estando obligada la EmpresaProgramadora a aceptar dicha valoración, en el otro caso, se reconstruirá a expensas dela Empresa Programadora la parte mal ejecutada sin que ello sea motivo de reclamacióneconómica o de ampliación del plazo de ejecución.

4.1.8. MEDIOS AUXILIARES

Serán de la Empresa Programadora todos los medios y máquinas auxiliares que seannecesarias para la ejecución del Programa.

55

4.1.9. CONSERVACIÓN DEL PROGRAMA.

Es obligación de la Empresa Programadora la conservación en perfecto estado delprograma hasta la fecha de recepción definitiva por la Empresa Usuaria, y corren a sucargo los gastos derivados de ello.

4.1.10. RECEPCIÓN DEL PROGRAMA.

4.1.10.1. RECEPCIÓN PROVISIONAL:

Una vez terminado el Programa, tendrá lugar la recepción provisional y para ello sepracticará en ellas un detenido reconocimiento por el Técnico Director y la EmpresaUsuaria en presencia de la Empresa Programadora, levantando acta y empezando acorrer desde ese día el plazo de garantía si se halla en estado de ser admitido.

De no ser admitido se hará constar en el acta y se darán instrucciones a la EmpresaProgramadora para subsanar los defectos observados, fijándose un plazo para ello,expirando el cual se procederá a un nuevo reconocimiento a fin de proceder a larecepción provisional.

4.1.10.2. LICENCIA Y DERECHOS.

Una vez efectuada la recepción provisional se le entregará a la Empresa Usuaria unalicencia de derecho de uso del programa, una copia del Programa y un Manual deInstalación y Uso. Esta licencia da derecho a instalar el programa en un ordenador. Porcada licencia de derecho de uso que se disponga, sólo puede haber una copia en uso, esdecir instalada en un ordenador.

No se podrá copiar, instalar en otro ordenador, ejecutar en público o aiq ' uilar lacopia entregada del programa sin la previa autorización de la Empresa Programadora.Si se quiere instalar el Programa en otro ordenador se tendrá que desinstalarpreviamente del primero.

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

56

4.1.10.3. PLAZO DE GARANTÍA.

El plazo de garantía será como mínimo de un año, contado desde la fecha de larecepción provisional, o bien el que se establezca en el contrato también contado desdela misma fecha. Durante este período queda a cargo de la Empresa Programadora laconservación del Programa y el arreglo de los errores observados.

4.1.10.4. RECEPCIÓN DEFINITIVA.

Se realizará después de transcurrido el plazo de garantía de igual forma que laprovisional. A partir de esta fecha cesará la obligación de la Empresa Programadora deconservar y reparar a su cargo los defectos observados.

4.1.11. CONTRATACIÓN DE LA EMPRESA PROGRAMADORA.

4.1.1 1.1. MODO DE CONTRATACIÓN.

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

4.1.11.2. PRESENTACIÓN.

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

4.1.11.3. SELECCIÓN.

La empresa escogida será anunciada la semana siguiente a la conclusión del plazo deentrega. Dicha empresa será escogida de mutuo acuerdo entre la Empresa Usuaria y elDirector Técnico, sin posible reclamación por parte de las otras empresas concursantes.

4.1.12. FIANZA.

En el contrato se establecerá la fianza que la Empresa Programadora deberá depositaren garantía del cumplimiento de¡ mismo, o, se convendrá una retención sobre los pagosrealizados a cuenta de Programa realizado.

57

De no estipularse la fianza en el contrato se entiende que se adopta como garantíauna retención del 5% sobre los pagos a cuenta citados.

En el caso de que la Empresa Programadora se negase a hacer por su cuenta lostrabajos para ultimar el Programa en las condiciones contratadas, o a atender la garantía,la Empresa Usuaria podrá ordenar ejecutarlas a un tercero, abonando su importe concargo a la retención o fianza, sin perjuicio de las acciones legales a que tenga derecho laEmpresa Usuaria si el importe de la fianza no bastase.

La fianza retenida se abonará a la Empresa Programadora en un plazo no superior atreinta días una vez firmada el acta de recepción definitiva del Programa.

4.2. CONDICIONES ECONÓMICAS.

4.2.1. ABONO DEL PROGRAMA.

En el contrato se deberá fijar detalladamente la forma y plazos que se abonarán laspartes realizadas del Programa. Las liquidaciones parciales que puedan establecersetendrán carácter de documentos provisionales a buena cuenta, sujetos a lascertificaciones que resulten de la liquidación final. No suponiendo, dichas liquidaciones,aprobación ni recepción del trabajo que comprenden.

Terminado el Programa se procederá a la liquidación final que se efectuará deacuerdo con los criterios establecidos en el contrato.

4.2.2. PRECIOS.

La Empresa Programadora presentará, al formalizarse el contrato, relación de losprecios de las unidades del Programa que integran el proyecto, los cuales de seraceptados tendrán valor contractual y se aplicará a las posibles variaciones que puedanhaber.

Estos precios unitarios, se entiende que comprenden la ejecución total de la unidaddel Programa, incluyendo todos los trabajos aún los complementarios y los materialesasí como la parte proporcional de imposición fiscal, las cargas laborales y otros gastosrepercutibles.

58

En caso de tener que realizarse unidades de Programa no previstas en el proyecto, sefijará su precio entre el Técnico Director y la Empresa Programadora antes de iniciar elPrograma y se presentará a la Empresa Usuaria para su aceptación o no.

4.2.3. REVISIÓN DE PRECIOS.

En el contrato se establecerá si la Empresa Programadora tiene derecho a revisión deprecios y la fórmula a aplicar para. calcularla. En defecto de esta última, se aplicará ajuicio del Técnico Director alguno de los criterios oficiales aceptados.

4.2.4. PENALIZACIONES.

Por retraso en los plazos de entrega de¡ Programa, se podrán establecer tablas depenalización cuyas cuantías y demoras se fijarán en el contrato.

4.2.5. CONTRATO.

El contrato se formalizará mediante documento privado, que podrá elevarse aescritura pública a petición de cualquiera de las partes. Comprenderá la adquisición detodos los materiales, transporte, mano de obra, medios auxiliares para la ejecución delPrograma proyectado en el plazo estipulado, así como la reconstrucción de las unidadesdefectuosas, la realización de las partes complementarias y las derivadas de lasmodificaciones que se introduzcan durante la ejecución, éstas últimas en los términosprevistos.

La totalidad de los documentos que componen el Proyecto Técnico del Programaserán 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 ejecución del Programa en lascondiciones establecidas en el proyecto y en el contrato. Como consecuencia de ellovendrá obligado a la eliminación de lo mal ejecutado y a su reconstruccióncorrectamente sin que sirva de excusa el que el Técnico Director haya examinado yreconocido el Programa.

La Empresa Programadora es la única responsable de todas las contravenciones queella o su personal cometan durante la ejecución del Programa u operaciones

59

relacionadas con el mismo. También es responsable de los daños que por errores,inexperiencia o empleo de métodos inadecuados se produzcan en la Empresa Usuaria.

la Empresa Programadora es la única responsable del incumplimiento de lasdisposiciones vigentes en la materia laboral respecto de su personal.

4.2.7. RESCISIÓN DEL CONTRATO

4.2.7.1. CAUSAS DE RESCISIÓN.

Se consideraran causas suficientes para la rescisión del contrato las siguientes:

· Primero: Muerte o incapacitación de La Empresa Programadora.

· Segunda: La quiebra de la Empresa Programadora.

· Tercera: Modificación del proyecto cuando produzca alteración en más omenos 25% del valor contratado.

· Cuarta: Modificación de las unidades de Programa en número superior al40% del original.

· Quinta : La no iniciación de la programación en el plazo estipulado cuandosea por causas ajenas a la Empresa Programadora.

· Sexta : La suspensión de la programación ya iniciada siempre que el plazode suspensión sea mayor de seis meses.

· Séptima: Incumplimiento de las condiciones del Contrato cuando impliquemala fe.

· Octava : Terminación del plazo de ejecución del Programa sin habersellegado a completar éste.

· Novena : Actuación de mala fe en la ejecución de los trabajos.

· Décima: Destajar o subcontratar la totalidad o parte del Programa a tercerossin la autorización del Técnico Director y la Empresa Usuaria.

4.2.8. LIQUIDACIÓN EN EL CASO DE RESCISIÓN DEL CONTRATO.

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

60

Cuando se rescinda el contrato llevará implícito la retención de la fianza para obtenerlos posibles gastos de conservación de el período de garantía y los derivados delmantenimiento hasta la fecha de nueva adjudicación.

4.3. CONDICIONES FACULTATIVAS.

4.3.1. PERSONAL.

La Empresa Programadora tendrá al frente de la realización del Programa unencargado con autoridad sobre los demás operarios y conocimientos acreditados ysuficientes para la ejecución del Programa.

El encargado recibirá, cumplirá y transmitirá las instrucciones y ordenes del TécnicoDirector de la obra.

La Empresa Programadora tendrá el número y clase de operarios que haga falta parael volumen y naturaleza de los trabajos que se realicen, los cuales serán de reconocidaaptitud y experimentados en el oficio. La Empresa Programadora estará obligada aseparar de la programación, a aquel personal que a juicio del Técnico Director nocumpla con sus obligaciones, realice el trabajo defectuosamente, bien por falta deconocimientos o por obrar de mala fe.

4.4. CONDICIONES TÉCNICAS

4.4.1. REQUERIMIENTOS DE HARDWARE

Para que el Programa pueda funcionar con cierta agilidad se aconseja tener comomínimo el siguiente Hardware:

PC 486 con coprocessador a 66 Mhz como mínimo 8 Mb de RAM como mínimo 3Mb de espacio libre en el disco duro. Ratón Microsoft o compatible.

Monitor SVGA con una resolución de 800 * 600 píxeles como mínimo.

4.4.2. REQUERIMIENTOS DE SOFTWARE

Para que pueda funcionar el Programa se tendrá que tener instalado en el ordenadorcomo mínimo el Software siguiente con sus respectivas licencias.

· Microsoft Windows 95 o posterior.

61

Manual de usuario del Ens&Link 68000

62

1 Introducción

En el presente manual se explica el modo de utilización del programa Ens&Link68000 para sistema operativo Windows. Ambos programas se encuentran en una mismaventana para optimizar el espacio y hacer menos engorroso su manejo. Para seleccionaruno u otro programa basta con presionar sobre su correspondiente solapa. Como podránapreciar, su uso es extremadamente sencillo e intuitivo.

2 Descripción de manejo

2.1 Ens68K

Fig1. Parte correspondiente al Ens68K

Como se puede observar en la Fig1, el formulario o ventana que constituye laparte relativa al ensamblador está formada por 3 “labels” o etiquetas para introducir elnombre de los ficheros a ensamblar, y de 2 “memos” de salida para visualizar posibleserrores o simplemente mensajes informativos (“warnings”).

63

Lo primero que haremos antes de linkar el código que hemos generado seráensamblarlo. Para ello clicaremos previamente sobre la pestaña superior donde poneEns68K. A continuación seguiremos los siguientes pasos:

Fig2.Introducción de los nombres de los archivos

1. En primer lugar, como se puede apreciar en la Fig2, tendremos que rellenar elcampo donde pone Fuente, el cual como su propio nombre indica, correspondeal fichero fuente del fichero que deseamos ensamblar. Por defecto y paraahorrar tiempo al usuario, los campos de los ficheros Destino y Listado serellenan automáticamente con el mismo nombre que el usuario ha introducidoen el campo del fichero Fuente. En caso de que el usuario desee que losnombres de los ficheros Destino y Listado tengan un nombre diferente puedemodificarlos posteriormente sin que el resto permanezca alterado. Si poralguna razon se omite la extensión de los diferente archivos a introducir, elprograma los añadirá internamente.

64

Fig3. Resultados del ensamblado

2. A continuación simplemente haremos clic sobre el botón “Ensambla” yesperaremos el resultado del ensamblado. La misma ventana consta de 2“memos” de mensajes tanto de posibles errores como de información.

3. A continuación se exponen los posibles mensajes de error e informaciones quese pueden visualizar en ambas ventanitas:

Mensajes de Información:

- "ENSAMBLADOR PARA MC68000"

-"EL FICHERO FUENTE %s NO EXISTE"

-"PRIMERA PASADA"

-"LINEA"

-"LINEAS ENSAMBLADAS"

-"SEGUNDA PASADA"

65

-"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

66

Una vez ensamblado se habrá generado un fichero cuya extensión será “.obj”(fichero objeto).

A continuación tendremos que linkar los archivos “.obj” creados siguiendo lossiguientes pasos:

Fig5. Introducción de los nombres de los ficheros “.obj”

1. En el campo “Objeto” tendremos que introducir el nombre de dicho fichero taly como se puede apreciar en Fig5. Podemos querer linkar varios archivos, ypara tal fin se ha dispuesto la “ListBox”.

67

Fig6. Introducción de los nombres de los ficheros en la “ListBox”

2. A continuación deberemos apretar el botón añadir para que el nombre delfichero “.obj” quede almacenado en la ListBox. La ListBox es una pequeñaventana donde vamos almacenando sucesivamente los ficheros objeto quedeseamos linkar, ya que en muchas ocasiones son más de uno. Podemosapreciar como nuevamente el resto de campos se rellenan automáticamente,tanto el fichero de Destino (cuya extensión es .s28), como el Mapa (cuyaextensión es .map) y al igual que en el Ens68K, podemos modificarposteriormente el nombre de los ficheros .s28 y .map. Además tenemos laposibilidad de que el programa linke a partir de una posición de memoriaintroducida por el usuario. En cuanto a esto último tenemos que vigilar que 2archivos .obj no sean linkados en la misma posición de memoria, ya queprovocaría un error de ensamblado que será indicado por el programa en sucorrespondiente “memo” destinado a errores.

68

Fig7. Resultado del linkado de archivos

3. Finalmente, para linkar los archivos introducidos en la ListBox apretaremos elcontrol Linka y se obtendrá si no ha habido ningún error, un resultado similaral de la Fig7.

4. A continuación se exponen los posibles mensajes de error e información quepueden aparecer en las ventanas:

Mensajes de Información:

-"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"

69

-"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"

desarrollo del ensamblador y el linkador del mc68000 para...

Documents