Programación en X68000 capítulo 2.2, Instalación del entorno de programación. Sabor Jason Stevens

En el artículo anterior explicaba como instalar el entorno de programación y compilar un Hola Mundo en Sharp X68000 con el toolchain de Lydux.

En aquel artículo prácticamente seguía las instrucciones de Lydux para instalarlo.

En recientes semanas he encontrado otro toolchain que resulta ser mas fiel al original en Sharp X68000 porque utiliza las librerías nativas.

Este otro toolchain se llama GCC 1.30 x68000 y ha sido adaptado por Jason Stevens. Su web es https://virtuallyfun.com/

El enfoque de este toolchain es que utiliza una versión de GCC como la original de los años del Sharp X68000, corriendo el Windows pero el programa ensamblador y el programa enlazador corren son los nativos de X68000 corriendo en un emulador de consola llamado run68 y por tanto podemos usar las librerías originales mientras que el toolchain de Lydux utiliza unas librerías de nueva creación que aunque son prometedoras aún están en desarrollo y contienen algunos bugs.

Por todo ello he decidido continuar por la línea del GCC 1.30 x68000.

Instalar este toolchain es muy diferente. Las instrucciones dadas por Jason Stevens son pocas y son para usarlo en la consola de Windows lanzando gcc directamente o a través de un makefile.

Sin embargo me las he arreglado para hacerlo funcionar con Code::Blocks de forma que se pueda trabajar igual que con el toolchain de Lydux.

Por tanto si no tienes el IDE Code::Blocks, puedes descargarlo en esta url: https://www.codeblocks.org/

Descargar el toolchain.

Ahora descargamos el GCC 1.30 x68000. Lo podemos encontrar en la siguiente URL:

https://sourceforge.net/projects/gcc-1-30-x68000/

Ha día de hoy el fichero se llama x68000-gcc130_21_06_2020.zip.zip, y contiene una carpeta llamada x68000.

En mis ejemplos lo voy a instalar en el raíz de la unidad E: por tanto la ruta será E:\x68000. 

Tu puedes instalarlo donde quieras pero tienes que tener en cuenta la ruta porque hay que usarla en varios sitios.

Configurar el run68.

Ahora vamos a configurar el emulador de consola de X68000, run68. Tenemos que decirle donde puede encontrar algunas carpetas. Para ello editamos el fichero E:\x68000\bin\run68.ini y ponemos las rutas acorde con donde hemos descomprimido la carpeta x68000 del paso anterior.

En mi caso el fichero queda asi:

[all]
mainmemory=12
iothrough
[environment]
PATH=E:\x68000\XBIN;
INCLUDE=E:\x68000\INCLUDE
LIB=E:\x68000\LIB
PASCAL=E:\x68000\PASCAL
TEMP=E:\x68000\temp

Configurar el entorno del GCC.

El compilador de este toolchain se apoya en unas variables de entorno que le dicen también donde encontrar algunas cosas.

El toolchain trae un fichero de ejemplo llamado E:\x68000\env.cmd. Pues igualmente lo abrimos y adaptamos las rutas a donde hemos descomprimido la carpeta x68000.

También vamos a añadir una linea al final que será el comando cmd de modo que al ejecutar este fichero se nos abra una consola

En mi caso el fichero queda así:

title x68000_GCC_1.30
set path=E:\x68000\bin;%PATH%
set TMPDIR=%TEMP%
set GCC_INCLUDE_DIR=E:\x68000\include
set INCLUDE=E:\x68000\include 
set LIB=E:\x68000\lib
set TEMP=E:\x68000\temp
@rem SET GCC_OPTION=LFIOAMP
SET GCC_OPTION=LFOAMP
set GCC_LINK=run68 silk229
set GCC_AS=run68 has060
cmd

Compilación de prueba.

Si ahora haces doble click en el fichero se abre una consola de comandos. Esta consola tiene ya todo lo necesario para compilar el programa de ejemplo de helloworld.

Para ello lanzamos el siguiente comando:

gcc -O hello.c

Como resultado obtenemos el fichero hello.x el cual ya se podría ejecutar en un Sharp X68000.

Aunque no lo vemos el compilador esta haciendo uso también del ensamblador has060 y del linkador silk229 que son programas de X68000 que están corriendo en el emulador de consola run68.

Configurar el idioma Japones en la consola.

Ahora quisiera ilustrar algo. Lancemos el comando run68 has060

Esto debería sacarnos la descripción del programa y los parámetros que usa pero si bien podemos identificar los parámetros, la descripción de estos es un galimatias.

Esto es porque al ser el programa has060 original del Sharp X68000 el cual es un ordenador japones, la salida que produce es en japones, lo cual esta bien porque hoy en día podemos copiar lo que sea que diga y pegarlo en un traductor de internet y enterarnos de qué pone.

El problema es que no lo estamos viendo en japones tampoco. Esto es porque el encoding que esta configurado para esta terminal esta en latin1 y necesitamos uno que muestre los caracteres japoneses.

Para arreglar esto lo que tenemos que hacer es añadir chcp 932 antes del comando cmd en nuestro fichero E:\x68000\env.cmd

Si ahora le hacemos doble click otra vez y volvemos a correr el comando run68 has060

Ahora ya podemos ver el mensaje correctamente en japones.

Una cosa que llama la atención usando este encoding es que el símbolo \ se ha convertido en el símbolo del yen ¥. Es el día a día del japones.

Lo de poner la consola en japones es porque de momento no he conseguido que Code::Blocks saque los caracteres japoneses, por tanto si sale un mensaje de error en japones, no se va a ver bien y no lo voy a poder copiar para traducirlo.

Por tanto lo que hago es ejecutar el mismo comando de compilación que Code::Blocks en esta consola, y ahí si estará en japones y lo podré traducir.

Cuando consiga mostrar el japones en Code::blocks volveré a aquí y lo editaré.

Configurar Code::Blocks.

Hasta aquí ya podríamos compilar pequeños programas de un solo fichero. Si quisiéramos añadir módulos habría que lanzar comandos mas largos incluyendo esos módulos y luego linkándolos entre sí y ya nos haría falta un makefile para automatizar eso y se va del alcance de este tutorial.

Por eso es que vamos a configurar Code::Blocks. Para ello vamos a Settings→compiller…

Vamos a copiar el compilador GNU GCC Compiler del desplegable. Nos saldrá un dialogo para ponerle un nombre. El nombre tiene que ser "X68000 GCC Compiler".

Es importante que se respete el nombre porque a el hará referencia una plantilla que usaremos para crear proyectos.

Ahora nos movemos a la pestaña Linker settings

En esta pestaña pulsamos el botón añadir y nos saldrá un dialogo para seleccionar ficheros.

Tenemos que seleccionar los ficheros E:\x68000\lib\libdos.a y E:\x68000\lib\libiocs.a

Estas dos librerías son para acceder desde C a las funciones nativas del sistema operativo Human68k del Sharp X68000.

Ahora nos movemos a la pestaña Search directories y en la sub pestaña Compiler vamos a añadir con el botón Add el directorio E:\x68000\include.

Esto es para que el compilador tenga acceso a los ficheros de cabecera como puedan ser stdio.h, stdlib.h o los de las librerías de antes libdos.h y libiocs.h.

Por último vamos a Toolchain Executables

En esta pestaña tenemos un botón donde podemos intentar un Auto-detect pero al menos a mi no me funciona con esto.

En vez de eso vamos a ir a la sub pestaña Program Files y manualmente vamos a buscar el fichero E:\x68000\bin\gcc.exe para C compiler, C++ compiler y para Linker for dynamic libs.

El campo Linker for static libs probablemente contendrá algo como ar.exe. Lo quitamos y lo dejamos vacío.

Por último, para el campo Make program buscamos el fichero E:\x68000\bin\MAKE.EXE

El poner los tres primeros campos apuntando al fichero gcc.exe es porque esta versión de gcc sabe que tiene que llamar a run68 has060 y luego a run68 silk229 en esas fases de la compilación.

Configurando lanzador de Code::Blocks

A este punto el compilador ya esta conigurado en Code::Blocks… pero no va a funcionar.

Esto es porque como ya dije al principio GCC se sirve de unas variables de entorno que son las que le dicen donde encontrar varias cosas y por eso tuvimos que hacer ese fichero E:\x68000\env.cmd para ser capaces de compilar en consola.

Por tanto tenemos que hacer lo mismo para Code::Blocks. Que arranque con esas variables de entorno.

Para ello vamos a copiar el fichero E:\x68000\env.cmd y lo vamos a llamar E:\x68000\CodeBlocks.cmd.

Ahora lo vamos a abrir y vamos a cambiar la linea que pone cmd por la este comando:

cmd /c start "" "C:\Program Files\CodeBlocks\codeblocks.exe"

De modo que quede así:

title x68000_GCC_1.30
set path=E:\x68000\bin;%PATH%
set TMPDIR=%TEMP%
set GCC_INCLUDE_DIR=E:\x68000\include
set INCLUDE=E:\x68000\include 
set LIB=E:\x68000\lib
set TEMP=E:\x68000\temp
@rem SET GCC_OPTION=LFIOAMP
SET GCC_OPTION=LFOAMP
set GCC_LINK=run68 silk229
set GCC_AS=run68 has060
cmd /c start "" "C:\Program
Files\CodeBlocks\codeblocks.exe"

haciendo doble click en este batch abrimos el Code::Blocks con las variables de entorno y gcc puede compilar.

Configurando el asistente de creación de proyectos.

Lo último que tenemos que hacer ya es configurar una plantilla que nos ayude a crear un proyecto con este toolchain directamente sin tener que configurar nada más que el nombre y la ruta.

Para esto he hecho yo mismo una plantilla inspirada en la de Lydux del artículo anterior y la tengo colgada en mi github.

Puedes descargar el zip de la url: https://github.com/FedericoTech/X68KTutorials/blob/main/x68000_gcc_template.zip

Cuando descargues el fichero x68000_gcc_template.zip dentro contiene una carpeta llamada x68000_gcc. La tienes que pegar en la carpeta C:\Program Files\CodeBlocks\share\CodeBlocks\templates\wizard que es donde se guardan los asistentes de creación de proyectos de Code::Blocks.

Por último tienes que abrir el fichero C:\Program Files\CodeBlocks\share\CodeBlocks\templates\wizard\config.script que es un fichero en un lenguaje parecido al javascript, y dentro de la función RegisterWizards pones esta linea:

RegisterWizard(wizProject, _T("x68000_gcc"), _T("X68000 GCC Project"), _T("Embedded Systems"));

En alguna zona como se muestra en la imagen:

Por este paso es que es importante que se respete el nombre del compilador cuando lo copiamos unos pasos mas atrás.

Creando un proyecto.

Ahora podemos arrancar Code::Blocks lanzándolo con el fichero E:\x68000\CodeBlocks.cmd.

Por cierto que no hace falta que ese fichero este en esa ruta. Puede estar donde quieras ya que tiene la rotas absolutas.

Ahora creamos un proyecto X68000 GCC como en la imagen.

Ya solo hay que seguir el asistente dando un nombre al proyecto y se creará con un Hola Mundo de ejemplo.

A partir de aquí ya se pueden compilar programas.

La plantilla genera ficheros ejecutables .X en la carpeta default\.

Esta carpeta se puede montar como un disquete en el emulador y lanzarlo. Igual que como está descrito en el artículo anterior.

Que lo disfruteis.