27 - Un nuevo ambiente de desarrollo

[Vlady_18]

En esta lección les explicaré el uso básico del ambiente de desarrollo que utilizaremos para trabajar en Modula 2, así como la creación del clásico "Hola Mundo".


La lección será extensa ya que hay varias cosas que ver de golpe y no he tenido otro remedio que juntarlo. La razón es simple, si dejo algo por el camino el proceso de creación de un programita simple quedará truncado y no podrán continuar. No tiene sentido que tengan que esperar a la siguiente lección para crear un "Hola Mundo".


La complejidad inicial no estará en sí en el nuevo lenguaje, aunque habrá cambios radicales en algunos aspectos, sino en el uso del nuevo ambiente de desarrollo, ya que la forma de trabajar que tiene Modula 2 hace necesarias ciertas acciones sobre los archivos de nuestros códigos fuente.


Lean todo con cuidado. Los programas "Hola Mundo" tienen justamente esa finalidad:

• Chocar contra el nuevo lenguaje.
• Chocar contra el nuevo ambiente de desarrollo.
• Ver que todo ha quedado instalado correctamente y es posible compilar.

Vallamos a ello:


Ambiente de desarrollo Native-XDS


Dado que comenzaremos a trabajar con un método de programación diferente, más complejo y más exigente, hace falta trabajar con un compilador más “inteligente”. Esto es, que el compilador sea capaz de traducir un código dispuesto en distintos módulos individuales reconociendo los enlaces que existen entre los unos y los otros, formando así un entorno global que será traducido a ceros y unos para formar un programa ejecutable.


De este modo abandonaremos el viejo y querido Free Pascal y abordaremos al Native-XDS. Al igual que el anterior compilador, este es de licencia gratuita, por lo que podemos usarlo sin problemas, sin claves y sin estar violando ninguna ley ni derechos de autor.


Para descargar el ambiente de desarrollo deben visitar


http://www.excelsior-usa.com/xdsx86.html


donde podrán ver opciones de descarga del compilador tanto para sistemas operativos Windows como para Linux, en versión para arquitecturas x86. Si alguien utiliza procesadores de 64 bits no se hagan problema, el Native-XDS funcionará correctamente y sin problemas, incluso sobre Windows 7 .


En en enlace que les dejé siempre tendrán las últimas versiones del compilador. Recuerden que en la página


http://www.excelsior-usa.com


existe mucha información acerca de este ambiente de desarrollo y otros más, y siempre se mantiene en actualización.


Una vez descargado el Native-XDSx86 deben instalarlo. Esto es muy fácil de hacer por lo que no redactaré las instrucciones aquí, solo deben presionar NEXT hasta que la instalación finalice y ya está, no hay que configurar más nada.


-------------------------------------------------------------------------------------


Utilizando Native XDSx86 para crear nuestro programa “Hola mundo”


Antes que nada debo comenzar explicándoles qué es un proyecto:


Un programa en el lenguaje Modula2 está generalmente compuesto por varios archivos (puede no estarlo), donde cada uno de ellos es llamado módulo. Generalmente se utiliza la palabra proyecto para designar el conjunto de módulos que componen un programa.


Un proyecto en Modula2 esta compuesto por dos clases de módulos: los módulos de definición y los módulos de implementación. Por cada módulo de implementación existe un correspondiente módulo de definición, con la excepción del módulo principal (esto lo comprenderán mejor cuando comencemos a trabajar), que es el que contiene el programa principal del proyecto. Este último no tiene módulo de definición asociado.


Los módulos de definición son archivos con extensión .def y los de implementación y principal tienen extensión .mod. O sea que ya no tendremos archivos de extensión .pas.


------------------------------------------------------------------------------------


Creando un proyecto básico en Modula2:


Consideren que se desea crear un proyecto, de nombre HolaMundo, compuesto solo por un módulo principal que será llamado HolaMundo.mod. Lo primero que se debe hacer es abrir el entorno de desarrollo, que de aquí en más en este documento será nombrado por lo general como XDS, el cual se inicia en Windows desde


Inicio/Programas/Native XDS-x86/XDS Environment


o un camino similar dependiendo del directorio elegido durante la instalación.


Al abrir XDS se despliega la siguiente pantalla:





Como podrán observar ya no tenemos esa cosa azul horrible, sino que ahora es algo más parecido a un editor de texto común, aunque no muy avanzado.


Para crear el proyecto, se debe ir al menú Project ---> New como se muestra a continuación:





Se desplegará una pantalla como la siguiente:





A continuación describo solo lo que deben saber al momento de crear sus proyectos. Existe mucho más de lo que explicaré, pero no hace falta para los efectos de este curso y por lo tanto describirlo solo los hará confundir más sus ideas.


Veamos la pantalla que apareció:





En este recuadro de texto se configura cual será el directorio de trabajo para el proyecto a crear y el nombre que se le dará al mismo.


[img]http://i44.servimg.com/u/f44/11/94/64/85/im510.png[/im]


En otras palabras, se debe indicar la ruta donde se desea que el proyecto sea creado y cuál será su nombre. Para esto, se puede editar directamente el cuadro de texto indicando la ruta y nombre del proyecto, o se puede usar el botón Browse, para elegir a través del explorador el directorio deseado y a continuación se completa con el nombre del proyecto.


Para el ejemplo de este instructivo, el proyecto será creado en el directorio C:\CursoBasico\ProyectoHM. El nombre del proyecto, como ya se mencionó es HolaMundo. El cuadro de texto se verá como se muestra a continuación:





Para indicar el nombre del proyecto ustedes solo deben cambiar el *.prj y poner NombreDelProyecto.prj.


IMPORTANTE


1 - La ruta elegida para el directorio de trabajo NO debe contener espacios en blancos ni tildes.
Será bueno que ustedes chequeen esto ya que varía entre una versión y otra del compilador, pero lo mejor es que respeten esta norma.


2 - La ruta del directorio de trabajo debe ser una ruta válida. En el caso del ejemplo, deben estar creados los directorios C:\CursoBasico\Proyecto. Dicho de otra manera, la carpeta donde vayan a crear el proyecto debe existir previamente, no lo olviden. Si no existe, créenla ustedes antes de intentar generar un proyecto.


--------------------


De todo lo demás que hay a la vista, lo otro que nos interesa es





La opción Create directories indica que se deben crear los directorios que permiten ordenar los distintos tipos de archivos que componen el proyecto. Deben dejar marcada esta opción.


Create RED file indica al XDS que cree automáticamente el archivo de extensión RED. Este es un archivo de configuración que usa el compilador de Modula2 para buscar las rutas de los directorios donde se encuentran los archivos que componen el proyecto. Es recomendable dejar marcada esta opción. Mas adelante se verá en detalle el contenido y utilidad de este archivo.


Finalmente la opción Create main module indica al XDS que cree el módulo principal del proyecto. NO deben dejar marcada esta opción ya que puede darnos algún problema más adelante. Crearemos el módulo principal manualmente en todos los casos.


Presionamos OK y volveremos a la pantalla anterior





solo que ahora en la barra de título veremos la ruta de nuestro proyecto.


---------------------------------------------------------------------


Módulo principal del proyecto:


Si han seguido todos los pasos anteriores entonces debemos crear el módulo principal del proyecto. Dicho módulo consta de un único archivo que será el que controle al programa. De este modo todo proyecto siempre tendrá el módulo principal, el cual será único, pudiendo luego tener otros tantos. Ahora crearemos un programa simple que imprima en pantalla el texto Hola mundo, tal como lo hicimos en pascal. Si un programa tiene un único módulo este será el módulo principal.


Para eso debemos crear un nuevo archivo. Para eso vamos a File → New o presionamos el botón New de la barra de herramientas. Ahí nos aparece un cuadro en blanco listo para escribir. Lo primero que hacemos es guardar el archivo. Para eso vamos a File → Save o presionamos sobre el botón Save en la barra de herramientas.


Pero primero miremos el directorio de nuestro proyecto:





Como podrán ver hay cuatro nuevas carpetas y además algunos archivos. Nosotros debemos guardar nuestro archivo dentro de la carpeta SRC teniendo en cuenta que debe tener el mismo nombre que el proyecto y su extensión ha de ser .mod. O sea , para este caso guardaremos nuestro archivo dentro de SRC y le pondremos como nombre HolaMundo.mod. Es importante respetar mayúsculas y minúsculas.


SRC es abreviación de Sources que en inglés significa Recursos. La carpeta SRC contendrá siempre los recursos que el compilador utilizará para crear los programas, esto es, los archivos de código fuente. Todos los archivos de código fuente (extensión .mod) siempre irán guardados dentro de SRC.


Ahora es tiempo entonces de escribir dentro de nuestro archivo. Veamos el código para nuestro programa HolaMundo, aquí ya estaremos introduciéndonos a Modula2:

MODULE HolaMundo;


FROM STextIO IMPORT WriteString;


BEGIN
    WriteString(“Hola mundo”);
END HolaMundo.

Antes de ver cómo compilar esto, analicemos línea a línea lo que significa cada cosa y comparemos esto con Pascal de modo que les sea sencillo comprenderlo.


En pascal lo primero que escribíamos en el código de un programa era

PROGRAM NombreDelPrograma;

En Modula2, el módulo principal comienza con

MODULE NombreDelModulo;

donde además NombreDelModulo es un identificador que debe ser exactamente igual al nombre con el que guardamos el archivo. O sea, como nuestro archivo se llama HolaMundo.mod, nuestro módulo se llama HolaMundo.


Otro dato muy importante es que, a diferencia de pascal, Modula2 es un lenguaje Case Sensitive, o sea, es sensible a mayúsculas y minúsculas. Esto es que no es lo mismo escribir
MODULE, Module, module, mOdUlE o cualquier otra variante. La palabra reservada es MODULE, así en mayúsculas, si ustedes no respetan eso entonces el compilador no la reconocerá. Esto es también para los identificadores. En pascal, era exactamente lo mismo ponerle a una variable Abuela, abuela, AbueLa, abuelA, o como fuera, para pascal todas eran la misma palabra. Ahora en Modula2 ustedes pueden ponerle a una variable el nombre Abuela y a otra el nombre abuela ya que ambos identificadores son diferentes. Esto es muy distinto a lo que estamos acostumbrados. Modula2 diferencia mayúsculas y minúsculas tanto para los identificadores como para sus instrucciones.


En la línea 3 de nuestro programa tenemos la instrucción

FROM STextIO IMPORT WriteString;

Lo que he hecho aquí es importar el procedimiento WriteString desde la librería STextIO. Y aquí ustedes dirán “¿Que has hecho qué?”.


En Pascal, para escribir texto en pantalla simplemente invocábamos a los procedimientos WriteLn o Wirite y listo. Bastaba solo con escribir su nombre en cualquier parte del código y poner entre paréntesis lo que queríamos que apareciera. Esto es porque dichos procedimientos estaban importados por defecto en el lenguaje, o sea, siempre estaba cargada la información acerca de WriteLn y Write, fuera que nosotros los usáramos o no.


Sin embargo, como les mostré cuando importamos el procedimiento ClrScr desde la librería CRT en pascal, hay cosas que no están disponibles por defecto en el lenguaje, sino que si las queremos utilizar tenemos que especificarlo importando esa información para que quede disponible. Importar información es hacer que el programa quede más pesado porque hay más cosas que codificar. Por esto el procedimiento ClrScr no estaba disponible por defecto, sino que el programador decidía cuando quería utilizarlo en un programa importándolo.


Imaginen que hacer un lenguaje que tenga todo importado por defecto sería hacer un lenguaje pesado y que cree programas lentos, que cargan mucha información innecesaria al ejecutarse, información que no hace falta.


En Modula2, dada la forma de trabajo que tiene este lenguaje, no existe prácticamente nada importado por defecto, sino que nosotros tendremos que hacer las importaciones de cada cosa que necesitemos. Las importaciones se hacen luego de la declaración del módulo, y su sintaxis es

FROM NombreLibreria IMPORT proc1, proc2, proc3, … , procN;

La palabra FROM es reservada, al igual que IMPORT.


Una librería es una unidad de programa que contiene muchos procedimientos y funciones, sí, procedimientos y funciones tales como los que ustedes programaban en pascal. Estos procedimientos y funciones tienen encabezados y obviamente esperan cierto tipo de parámetros. Modula2 nos obligará a conocer sus librerías y para ellas sus procedimientos y funciones. Pero esto lo iremos viendo de a poco, ya que se entenderá mejor cuando comencemos a programar nuestras propias librerías porque de eso se trata Modula2, librerías y más librerías.


NOTA: Las librerías no solo contienen Procedimientos y Funciones, sino que también nos proveerán de tipos y constantes que podemos usar.


Como ya dije, Modula2 es Case Sensitive, por lo tanto el nombre de la librería es exactamente STextIO, y no es lo mismo poner stextio o Stextio, o cualquier variante. Lo mismo con el procedimiento WriteString, ese es su nombre, y no vale poner writestring o writeString o WRITESTRING ¿se entiende?


La librería STextIO contiene rutinas para la entrada y salida de texto. STextIO es abreviación de Standard Text Input Output (Entrada y Salida Estándar de Texto).


El procedimiento WriteString únicamente imprime texto en pantalla, o sea, algo del tipo String, una cadena de caracteres. No podemos pasar números u otros tipos de datos como parámetro de un WriteString. Además solo admite un único campo, esto es que, no podemos ingresar distintos campos separados por comas como hacíamos en pascal con WriteLn y Write.


En pascal, ustedes escribían los Strings encerrados entre comillas simples, por ejemplo

WriteLn('Hola mundo');

Sin embargo, en Modula2 es lo mismo usar comillas simples (') como comillas dobles (“), de este modo estas sentencias equivalen a lo mismo:

WriteString(“Hola mundo”);
WriteString('Hola mundo');
WriteString('Hola mundo”);
WriteString(“Hola mundo');

Entonces, con la importación que hemos hecho le decimos al lenguaje que queremos tener disponible el procedimiento WriteString para usarlo dentro de nuestro código. Basta importarlo una sola vez para que nos quede disponible en cualquier parte de nuestro código.


Bien, entonces vamos a la línea 5 donde tenemos la palabra reservada BEGIN. Al igual que en pascal, BEGIN indica el comienzo del código del programa. Ahora, dado que mayúsculas y minúsculas no son lo mismo, no podemos poner Begin, begin ni nada parecido, solo BEGIN. De aquí en adelante no haré más la aclaración de mayúsculas y minúsculas, las palabras reservadas, procedimientos, funciones e identificadores que les presente deberán escribirse TAL CUAL se los muestro. Lo mismo con los nombres que ustedes usen en sus programas, deben siempre escribirlos de la misma manera.


En la línea 6 usamos WriteString para imprimir texto en pantalla y en la línea 7 damos el final del programa. En pascal, esto último se hacía solo escribendo END seguido de un punto (.). Sin embargo, ahora en Modula, debemos escribir

END NombreDelModulo.

NOTAS:

• El punto y coma (;) cumple la misma función de separado que cumplía en pascal.
• Al igual que en pascal, luego de la palabra BEGIN no va un punto y coma, eso es un error de sintaxis.
• El END final de un módulo es el único que finaliza en punto, solo que en Modula2 debemos además agregar el nombre del módulo antes del punto. No hacerlo es un error de sintaxis.
• Debemos importar todas las rutinas que vamos a utilizar. No hacerlo es un error de sintaxis ya que el compilador nos dirá que no reconoce el identificador especificado. Por ejemplo, si no importamos WriteString desde STextIO pero lo usamos para mostrar texto, el compilador dirá que no reconoce el identificador WriteString.

-------------------------------------------


Agregar el módulo principal al proyecto:


Habiendo aclarado lo que a sintaxis y funcionamiento refiere, debemos compilar nuestro archivo para poder correrlo (ejecutarlo). Dado que el compilador está diseñado para crear programas que trabajen con archivos múltiples, debemos siempre agregar esos archivos al proyecto, sea un único archivo o un millón. Si no hacemos esto no podremos ni compilar ni correr el programa.


En el menú Proyect → File List podemos habilitar la lista de los archivos que componen nuestro proyecto. Al hacer click allí se abrirá a la izquierda un cuadro que muestra dicha lista. Si nuestro archivo HolaMundo.mod aparece allí, no hay más problema y ya podemos compilar, sino, debemos agregarlo manualmente, que es lo más común.


Esto que explicaré lo emplearemos para usar en nuestro proyectos los
archivos que vamos creando, así como para agregar archivos creados anteriormente en otros proyectos y que nos pueden resultar útiles. Dado que estaremos constantemente programando librerías, siempre es posible utilizar en nuestros proyectos nuevos algo que ya hemos hecho en proyectos anteriores. Bastará con copiar los archivos necesarios hacia los directorios adecuados y luego agregarlos con este procedimiento. No se asusten que todo lo veremos en detalle en su debido momento. Ahora agreguemos entonces nuestro archivo HolaMundo.mod:


Vamos a Proyect → Modify y vemos una ventana como la que sigue:





Si en el cuadro de la derecha (el que tiene renglones) no aparece nada, es porque nuestro proyecto no tiene todavía archivos asignados y por lo tanto no podrá utilizar nada. Si por casualidad ustedes vieran allí su archivo HolaMundo.mod no tendrán que hacer esto porque ya estaría agregado. Verifiquen que la opción Module list en el recuadro de la izquierda está seleccionada, si no es así, selecciónenla ustedes mismos.


En este ejemplo vamos a agregar un nuevo archivo a nuestro proyecto, para esto presionamos el botón Add. Con eso se les habilitará en el cuadro con renglones un campo de texto para que escriban la dirección en la cual se encuentra el archivo que agregaremos. Si la recuerdan y les parece más rápido pueden escribirla, sino simplemente presionan el botón Browse y buscan manualmente el archivo que quieren agregar. En este ejemplo agregaremos HolaMundo.mod, así que vamos al directorio C:\CursoBasico\ProyectoHM\SRC y elegimos el archivo.





Si hemos elegido mal podemos presionar en Edit para modificar o Remove para eliminar. Esto eliminaría el archivo de la lista, NO el archivo del disco duro. Hacemos click en OK.


Ahora vamos a Tools → Update file list lo cual recarga la lista de archivos y reconoce lo nuevo que hemos agregado. Si no lo hacen, entonces no podrán usar los nuevos archivos aunque ya los hayan agregado a la lista. Ahora sí verán su archivo en el cuadro de la izquierda.
Pueden compilar el archivo por sí solo desde Tools → Compile HolaMundo.mod, o compilar para generar el ejecutable mediante Tools → Build all.


Esta última opción, cuando el proyecto consta de más de un módulo, los compila a todos a la vez realizando los enlaces entre ellos, lo que se conoce como Linking o Link-editar. Si todos funcionan bien el ejecutable se generará, si alguno falla la compilación se detendrá. En este caso, como es un único archivo no habrá mayores problemas.


Pueden correr el ejecutable haciendo doble click sobre él. Se genera en la carpeta donde está alojado el proyecto. También pueden hacerlo desde el menú Debug → Run o desde el botón Run de la barra de herramientas. Esto re-linkea los archivos y re-compila el programa.




Muy bien, con esto hemos creado nuestro primer programa en Modula2. En principio parece todo mucho más complicado que en pascal, pero realmente no lo es tanto. Todo responde al trabajo con programas complejos, y ya verán que bueno resulta para esto.


Hasta la siguiente lección.