Introducción

A lo largo de los siguientes meses echaremos un vistazo al paquete z88dk (http://z88dk.sourceforge.net) y aprenderemos a realizar programas con él para nuestro Spectrum. Básicamente se trata de un compilador cruzado de C, que nos permite realizar nuestros programas en este lenguaje en nuestro ordenador de sobremesa (PC con Windows o Linux, SPARC) y crear un fichero que podrá ser ejecutado con un emulador y, mediante las herramientas adecuadas, ser pasado a cinta para ejecutarlo en nuestro Spectrum. Aunque en estos artículos nos centraremos en la máquina objetivo de esta publicación (el Sinclair ZX Spectrum), el z88dk permite desarrollar aplicaciones para una gran cantidad de plataformas, entre ellas Sam Coupé, MSX1, Jupiter ACE, ZX81, y un gran número de ordenadores basados en el procesador Z80.

El paquete incluye una serie de librerías que nos permitirán añadir funcionalidades fácilmente a nuestros programas, siendo las más interesantes las librerías gráficas, que nos capacitarán incluso para programar algún juego. El compilador de C incluido con z88dk no es más que un pequeño compilador que acepta muchas de las características de ANSI C y realiza optimizaciones básicas. Por último, hemos de aclarar que el objetivo de esta serie de artículos no es explicar la sintaxis o el funcionamiento del lenguaje C; es más, al lector se le supondrán una serie de conocimientos básicos sobre el mismo. Como en el artículo de este número nos centraremos en cómo instalar el paquete para distintas plataformas, así como en conocer la forma de compilar y ejecutar los ejemplos, el lector tendrá tiempo de consultar cualquiera de los múltiples tutoriales sobre C existentes en la red. En la Web del Programador (ver sección de enlaces) se pueden encontrar multitud de enlaces relacionados con el tema.

Para descargarnos la última versión estable deberemos dirigirnos a la página de descargas de z88dk (a partir del enlace proporcionado en la página del paquete, ver sección de Links), donde podremos obtener la versión de Linux. Los binarios para Windows se pueden obtener en la página de Dennis Grönign (el enlace también puede ser encontrado en la misma página de z88dk).

El primer paso, una vez descargado el fichero z88dk-src-x.y.tar.gz (donde x.y es la versión del paquete; en el momento de redactar este artículo la última versión estable era la 1.5), es desempaquetarlo en el directorio donde queramos tenerlo instalado:

tar -xvzf z88dk-src-x.y.tar.gz

Una vez hecho esto debemos compilar los distintos binarios y librerías que componen z88dk:

cd z88dk
./build.sh

Para el uso de z88dk debemos darle un valor a una serie de variables de entorno. Podemos hacer esto creando un fichero setpath.sh (al que daremos permisos de ejecución con chmod a+x setpath.sh) con el siguiente contenido:

export Z88DK="{z88dk}/z88dk"
export PATH="$PATH:$Z88DK/bin"
export Z80_OZFILES="$Z88DK/lib/"
export ZCCCFG="$Z88DK/lib/config/"

donde {z88dk} es el directorio donde hemos desempaquetado el tar.gz. Cada vez que vayamos a utilizar z88dk, deberemos ejecutar este fichero mediante el siguiente comando:

source setpath.sh

Con esto hacemos que las variables de entorno queden definidas para el shell actual.

Una herramienta de la que haremos uso en la creación de nuestros programas es bin2tap. Este programa transforma los binarios producidos por el compilador en archivos TAP que pueden ser ejecutados en un emulador. Afortunadamete, este programa viene incluido con z88dk. Desgraciadamente, se incluye sin compilar, y además, tampoco se compila al ejecutar el ./build.sh anteriormente indicado. Para construirlo, nos desplazamos al directorio $Z88DK/support/zx/, y ejecutamos:

cc -o bin2tap bin2tap.c

De esa forma crearemos el ejecutable del programa. Para poder utilizarlo cómodamente, lo copiamos al directorio bin:

mv $Z88DK/support/zx/bin2tap $Z88DK/bin/

Una vez instalado el paquete, y preparado nuestro sistema, pasamos a explicar cómo podemos compilar nuestros programas, y ejecutarlos en cualquier emulador. Para ello nos basamos en los ejemplos situados en el directorio $Z88DK/examples/spectrum.

En el directorio anterior encontramos una serie de archivos .c, conteniendo programas en C que utilizan las librerías de z88dk. En el archivo README tenemos una descripción de qué hace cada uno de ellos. Vamos a compilar y a probar el gfx.c, que incorpora una serie de efectos gráficos y que a priori puede parecer el más espectacular, visualmente hablando. Para ello, según el archivo README, podemos ejecutar:

zcc +zx -o gfx.bin gfx.c -lndos

A continuación hacemos una breve descripción de la sintaxis:

  • Justo después del comando zcc especificamos la máquina destino, es decir, la máquina para la cual se va a producir el binario. En nuestro caso deseamos crear un binario para el ZX Spectrum, así que usamos el modificador +zx (los modificadores correspondientes a cada una de las máquinas soportadas los podemos encontrar en $Z88DK/doc/compile.txt).
  • Con el parámetro -o especificamos el nombre del archivo binario resultante (en nuestro caso, gfx.bin).
  • Después indicamos el nombre del fichero fuente.
  • Por último, con -lndos hacemos que se enlace con la librería ndos (en próximas entregas entraremos en detalle sobre las librerías más útiles y las funcionalidades que ofrecen). Las librerías se encuentran en $Z88DK/libsrc/.

Como se puede observar, la sintaxis es muy parecida al compilador gcc de Linux, así que si ya estamos acostumbrados a programar en C en esta plataforma, no deberíamos tener ningún problema. El archivo resultante, gfx.bin, es un archivo binario (no entenderemos su contenido si lo editamos con un editor de texto). Hay que tener en cuenta que zcc no es el compilador en sí, sino que es un frontend que se encarga de ejecutar el compilador y el ensamblador/enlazador (todas estas aplicaciones se pueden encontrar en el directorio $Z88DK/bin/).

Este archivo binario todavía no puede ser ejecutado en ningún emulador, primero debemos pasarlo a un formato adecuado. Para ello podemos hacer uso de la aplicación bin2tap, que compilamos en el apartado anterior:

bin2tap gfx.bin gfx.tap

¡Y ya podemos probar el programa en nuestro emulador favorito!

Efecto gráfico programado en C para el Spectrum por medio de z88dk

Esta instalación ha sido realizada y probada sobre un PC con Windows 98 Second Edition. Se intentó realizar en un sistema con Windows XP y los ejecutables contenidos en el directorio bin daban el error “xxxxxxx.exe no es un archivo win32 válido” (Esto puede ser debido más al PC en el que el autor tiene instalado el sistema operativo que a problemas de incompatibilidad entre el propio z88dk y Windows XP).

El primer paso que tenemos que llevar a cabo es descargarnos el archivo z88dk-win32-x.y.zip (donde x.y indica la versión de z88dk) que podemos encontrar en la web del proyecto. Una vez descargado, descomprimimos el zip en el directorio c:\z88dk, que va a ser el directorio que usemos por defecto para explicar la instalación, y que podemos cambiar a uno que nos agrade más cambiando la ruta en todas las explicaciones que se dan a continuación.

Un ejemplo de programa donde se hace uso de lectura del teclado

Lo siguiente es añadir la ruta de los ejecutables y las librerías al archivo autoexec.bat. Para esto tenemos dos opciones:

  • 1. Añadir manualmente la ruta, editando el archivo autoexec.bat. Para hacerlo simplemente editamos el archivo autoexec.bat, situado en c:/, con el Bloc de Notas de Windows, o, desde una ventana de MS-DOS con “edit autoexec.bat” y le añadimos las siguientes líneas:
SET Z80_OZFILES=C:\z88dk\Lib\
SET ZCCCFG=C:\z88dk\Lib\Config\
SET PATH=%PATH%;C:\z88dk\Bin
  • 2. Al descomprimir el zip que contiene los archivos del z88dk, hay un archivo llamado SETZ88-W95.inf, situamos el puntero del ratón encima de él, pulsamos el botón derecho y hacemos clic en instalar, con lo cual se añade la ruta automáticamente al archivo autoexec.bat.

Una vez realizada cualquiera de las dos opciones anteriores, reiniciamos el PC para que se actualicen las rutas que acabamos de introducir.

Otro programa de ejemplo incluido con z88dk

Cuando programamos con z88dk, escribimos el código en lenguaje C en archivos de texto plano, con nuestro editor preferido, puede ser el Bloc de Notas que trae Windows perfectamente. Estos archivos se suelen nombrar como programa.c.

Para mostrar brevemente como creamos un archivo interpretable por un emulador de ZX Spectrum, o cargarlos en un ordenador real, vamos a usar uno de los ejemplos que vienen con el z88dk.

  • Lo primero que hacemos es abrir una ventana de MS-DOS y, después, desde ésta nos situamos en la carpeta donde están los ejemplos para el ZX Spectrum:
CD..

Para colocarnos en el directorio raíz de C:

CD z88dk\examples\spectrum

Con eso nos situamos en la carpeta donde están los ejemplos para ZX Spectrum

En esta carpeta encontraremos varios ficheros, concretamente vamos a usar el gfx.c que nos crea unos efectos gráficos en la pantalla del emulador/Spectrum.

  • Ahora tenemos que compilar el programa, para ello vamos a usar el ejecutable ZCC.EXE, que está ubicado en la carpeta BIN, pero no tenemos que entrar en ella para nada, ya que anteriormente añadimos el path. Vamos a compilar, para ello tecleamos en la ventana de MS-DOS:
zcc +zx -o gfx.bin gfx.c -lndos

Al ejecutarlo se crea un archivo .bin en el que tendremos nuestro programa y que necesitaremos pasar a un formato que pueda comprender el emulador, o el programa que usemos para pasarlo a cinta y cargarlo con el ZX Spectrum.

  • Para pasar el archivo .BIN a .TAP, tenemos un programa llamado BIN2TAP.EXE que viene incluido en el kit del z88dk y situado en el directorio \support\zx.

Su uso es muy sencillo, tenemos que tener en la misma carpeta el archivo .BIN y el programa BIN2TAP.exe, también podemos incluir la ruta del bin2tap en el path, eso lo dejamos a nuestra elección.

Ejecutamos:

BIN2TAP gfx.bin gfx.tap

Y ya tenemos nuestro programa preparado para cargarlo en nuestro emulador preferido.

NOTA: en el caso de disponer de una plataforma Windows se recomienda leer también de forma detenida el apartado de compilación y ejecución en Linux donde se explican una serie de conceptos importantes sobre el proceso.