Pues eso, aquí te dejo una pequeña lista de compiladores gratuitos para FORTH, esta lista me la ha facilitado ChatGPT (DEC 15 Version), podría haberlo buscado en GOOGLE, pero… Más que nada, para ver si ChatGPT/OpenAI sabía algo de este vetusto lenguaje, que por lo que puedo ver aún sigue vigente, se ve que hay muchos jubilados por ahí… 😉
La pregunta ha sido:
Hola, ¿puedes decirme qué compiladores gratuitos hay para el lenguaje FORTH?
Y esta ha sido su respuesta: (en itálica las faltas de ortografía)
Hola, sí, hay varios compiladores gratuitos para el lenguaje FORTH disponibles. Algunos ejemplos incluyen:
Gforth: Es un compilador FORTH estandar y gratuito disponible para una variedad de sistemas operativos, incluyendo Windows, Linux, macOS y varios sistemas Unix. Gforth es compatible con la norma FORTH-83, así como con varias extensiones.
SwiftForth: Es un compilador FORTH gratuito para Windows, macOS y Linux. Viene con una interfaz de línea de comandos y una ventana de depuración, así como una serie de herramientas de desarrollo adicionales, como un editor de código integrado y una ventana de registro de sistema.
pForth: es un compilador FORTH gratuito para Windows y Linux que tambien incluye una interfaz de línea de comandos y una ventana de depuración. Es fácil de usar y se puede ejecutar en una variedad de plataformas.
Win32Forth: es un compilador FORTH gratuito para Windows con una interfaz gráfica de usuario. También incluye una ventana de depuración, un editor de código integrado y una ventana de registro de sistema.
4tH es otro compilador FORTH gratuito y multi plataforma, con ejecutar tanto en Windows, Linux y macOS.
Es importante mencionar que estos son solo algunos ejemplos y puede haber muchos más opciones disponibles. Te recomendaría investigar un poco para encontrar el compilador que mejor se adapte a tus necesidades específicas.
La pregunta la hice en español y la respuesta la ha dado en español. Pero le he dicho que lo traduzca al inglés.
Por favor, ¿puedes traducir tu respuesta al inglés? gracias
Y aquí su respuesta con la traducción dada por ChatGPT:
Sure, here is my response translated to English:
Hello, yes, there are several free compilers available for the FORTH language. Some examples include:
Gforth: It is a standard and free FORTH compiler available for a variety of operating systems, including Windows, Linux, macOS, and several Unix systems. Gforth is compliant with the FORTH-83 standard, as well as various extensions.
SwiftForth: It’s a free FORTH compiler for Windows, macOS, and Linux. It comes with a command-line interface and a debugging window, as well as a number of additional development tools, such as an integrated code editor and a system log window.
pForth: It’s a free FORTH compiler for Windows and Linux that also includes a command-line interface and a debugging window. It is easy to use and can be run on a variety of platforms.
Win32Forth: It’s a free FORTH compiler for Windows with a graphical user interface. It also includes a debugging window, an integrated code editor, and a system log window.
4tH is another free and multi-platform FORTH compiler, running in Windows, Linux and macOS.
It’s worth noting that these are just a few examples and there may be many more options available. I would recommend researching a bit to find the compiler that best suits your specific needs.
Aquí tienes los enlaces a las páginas principales y a las de descargas.
Pues eso… que en estos días me ha dado por retomar un viejo amigo (lenguaje de programación) que usé por primera vez en los años 80 (sobre el 84 u 85) en mi Commodore-64, me refiero al lenguaje FORTH.
Ya no lo recuerdo, pero creo que era un «cartucho» que se insertaba en el C-64, el FORTH 64, de eso estoy seguro, porque he encontrado esta página con el manual y esa imagen (ver la captura de aquí abajo) sí que la recuerdo.
Manual de Forth 64 para Commodore
La cuestión es que, en aquellos años, el BASIC del Commodore, primero del VIC-20, después del C-64, era… ¿cómo decirlo? muy GO-TerO, es decir, que no tenía DO/LOOP, WHILE, UNTIL y lo que se hacía era el clásico GOTO. Y este lenguaje, FORTH, lo recuerdo como el primero en el que no usé un GOTO, entre otras cosas porque no existe la palabra GOTO en Forth. 😉
La verdad es que no tengo nada de aquello, porque llegué hasta comprar un libro de Forth, pero para el BBC Micro, y de algo me sirvió. No recuerdo detalles, pero recuerdo que era «emocionante» programar en ese lenguaje, sobre todo en aquellos tiempos que lo más que teníamos a nuestra disposición eran los GOSUB, y eso de que pudieras crear tus propias palabras (WORD es el término de Forth para las «subrutinas»), pues… ¡era una pasada!
Hablando de DO, LOOP, WHILE y UNTIL y el Commodore 64, también por aquellos años ochenta me fabriqué en «código máquina» (CM para el C-64) unas extensiones para BASIC, entre ellas el DO-LOOP UNTIL y DO-LOOP WHILE. Con el C-64 y el C-128 (pero menos) hice cosillas «curiosas» en ensamblador para el Commodore 64, en fin… chocheando que está ya uno… jajaja… en fin-bis.
Volviendo al Forth, decirte que lo mismo publico algunas cosillas de las que estoy haciendo, en este caso ya son para ANS-FORTH, el estándar, que estoy haciendo con Gforth de GNU (abajo tienes el enlace) para no olvidarme… aunque ahora ha cambiado un poco, sigue siendo un «peñazo» el tema de los números y las cadenas…
Lo más curioso de este lenguaje es que usa la notación polaca inversa, y que todo lo maneja poniendo y sacando cosas de la pila (stack), que es de tipo LIFO (last-in first-out, el último en entrar es el primero en salir), de forma que si quieres sumar dos números lo harás de esta forma:
7 3 + y para mostrarlo escribes un punto para ver el resultado.
Y si quieres hacer algo como: (3 + 2 ) * 8, tendrás que hacerlo, por ejemplo, de esta otra:
8 2 3 + * .
Y te mostrará 40, 5 * 8.
Los pasos que sigue son:
1- Pone el 8 en la pila 2- Pone el 2 en la pila 3- Pone el 3 en la pila 4- Pone el + en la pila y 5- Suma dos valores que haya en la pila y pone el resultado (5) 6- Pone el * en la pila 7- Multiplica dos valores de la pila y pone el resultado (40) 8- El punto muestra el valor que haya en la pila.
En FORTH no se usan los paréntesis ni hay nivel de precedencia, todo se maneja con el orden en que esté en la pila.
El ejemplo anterior se puede escribir también así:
2 3 + 8 *
Imagina cómo lo hace en este caso.
Solo comentarte que cuando pulsas intro es cuando empieza la acción, es decir, no hace nada mientras estás escribiendo las cosas para que se pongan en la pila.
Como te comento abajo, los de GNU han hecho una versión de Gforth para Android (ver la captura con el clásico HOLA-MUNDO).
GFORTH funcionando en un Pixel 4a de Android
Y poco más puedo decirte, salvo ponerte el código del HOLA-MUNDO que he hecho para el Android 😉
: HOLA-MUNDO ( -- muestra el mensaje )
." Hola Mundo de GFORTH!"
;
Ahí abajo te dejo unos cuantos enlaces sobre FORTH por si quieres echarle un vistazo.
Y esto es todo… ah, y ¡Felices Fiestas! aunque sea en el día de los Reyes Magos 😉
Pues eso… probando con el código que he hecho con Java (desde el IntelliJ IDEA) he querido compilar el código a .exe, pero no sé cómo hacerlo… solo me he quedado en crear un fichero .jar y ese poder ejecutarlo con el «java» desde la línea de comandos.
Versión de Java instalado
Al intentar hacerlo me he topado con un par de problemas, al menos desde mi máquina con el Visual Studio 2019 instalado (aparte del Visual Studio 2022), aclaro esto porque se ve que el Visual Studio 2019 tiene instalada una versión del JDK más antigua, concretamente la versión 1.8.0_302 y el código que he usado en las pruebas con records y expresiones swicht necesita al menos el JDK 17 (JDK = Java Development Kit).
Para poder usar el código que he publicado en varios de los repositorios (y los gists) de GitHub, instalé el JDK 19 (el último a la hora de escribir esto y también cuando empecé a hacer las pruebas en noviembre), pero la versión del JDK que está primero en la variable PATH es la carpeta bin de la versión 1.8, por tanto, al usar cualquiera de los comandos de Java (java para ejecutar los .jar o javac para compilar el código) me daba error.
Cuando se instala el JDK (al menos desde Visual Studio) se crea una variable de entorno que se llama JAVA_HOME con el path del directorio donde está instalado el JDK de Java. En mi equipo el path indicado es: C:\Program Files\Microsoft\jdk-11.0.12.7-hotspot. Que como te puedes imaginar es la versión 11 del JDK. Esa versión tampoco soporta las expresiones swicht ni los records (aunque sí los tipos genéricos).
Así que… la solución es instalar un JDK que soporte esas dos «cosillas» que necesito en mi código.
Instalar un nuevo JDK de Java
Como la última versión que hay actualmente es la 19, esa es la que descargué (desde el propio IDE de IntelliJ IDEA), pero que puedes descargar desde la página de OpenJDK.
A fecha de hoy (27 de noviembre) el último JDK de Java es el 19, pero también puedes descargar versiones anteriores, aunque… ¿para qué? si con el último te aseguras que lo tienes todo 😉 Quiero comentarte que desde esa página puedes descargar la versión del JDK para distintos sistemas operativos. En mi caso descargué el de Windows.
Si quieres usar otra versión anterior, por ejemplo, la implementación del Java SE 17 también valdría, puedes hacerlo desde los enlaces de la parte izquierda de la página del enlace que te he puesto en el párrafo anterior.
Para usarlo, te descargas el zip, lo extraes en una carpeta (normalmente en la carpeta .jdks del directorio de %USERPROFILE% (la carpeta predeterminada del usuario de Windows).
En mi caso, ahí tengo el JDK 19 (instalado por IntelliJ IDEA) y el JDK 17 que me lo descargué para comprobar que con esa versión también funciona.
Lo que hice a continuación es añadir variables de entorno para acceder fácilmente a esos directorios, concretamente he creado dos variables de entorno, una para el JDK 19 y otra para el JDK 17.
Para hacer esto, abre las opciones avanzadas del sistema (Advanced System Settings) y acceder a las variables de entorno (Environment Variables). Para acceder, pulsa con el botón secundario en This PC > Settings y en el panel derecho (estoy usando Windows 11) pulsa en Advanced System Settings o bien en buscar escribe «Advanced System Settings» o desde la línea de comandos (o desde run) escribe control sysdm.cpl y selecciona la ficha «Advanced»
Una vez tengas las variables de entorno (ver la figura 1), pulsa en el botón New de la parte superior y en el cuadro de diálogo escribe JAVA_HOME19 y en el path escribe el directorio en el que está ese JDK, en mi caso escribí %USERPROFILE%\.jdks\openjdk-19.0.1 y después se puso el path que corresponde.
Figura 1. Las variables de entorno
No es necesario que pongas los dos paths a los dos JDK, yo solo los he puesto para comprobar que la versión 17 también servía.
Una vez que tengas esto, abre la terminal o la línea de comandos y escribe %JAVA_HOME19%\bin\java --version para comprobar la versión del JDK de Java instalado.
Microsoft Windows [Version 10.0.22000.1281]
(c) Microsoft Corporation. All rights reserved.
C:\Users\Guille>%JAVA_HOME19%\bin\java --version
openjdk 19.0.1 2022-10-18
OpenJDK Runtime Environment (build 19.0.1+10-21)
OpenJDK 64-Bit Server VM (build 19.0.1+10-21, mixed mode, sharing)
Puedes escribir tanto java --version como java -version, el resultado prácticamente es el mismo, pero no igual; además de que -version se muestra en el stream de error y –version en el stream de salida.
Te aclaro que todo esto es por si el Java que tienes instalado es anterior a la versión 17, cosa que ocurrirá si tienes Visual Studio instalado y has indicado que quieres crear aplicaciones de Xamarin o .NET MAUI que instalan los JDK de Java.
En cualquier caso, antes de ahcer todo lo aquí explicado, comprueba con java -version (sin indicar ningún path y con un solo guión, ya que las versiones anteriores no reconocen el parámetro --version) qué versión tienes y si es la 17 o superior, pues… ¡todo hecho!
En mi caso me muestra esto, así que, necesito instalar un JDK más reciente.
Microsoft Windows [Version 10.0.22000.1281]
(c) Microsoft Corporation. All rights reserved.
C:\Users\Guille>java -version
openjdk version "1.8.0_302"
OpenJDK Runtime Environment (Temurin)(build 1.8.0_302-b08)
OpenJDK 64-Bit Server VM (Temurin)(build 25.302-b08, mixed mode)
Al compilar el código te explicaré para qué he creado la variable de entorno %JAVA_HOME19%, ya que no he querido añadir el path al directorio bin del JDK en la variable de entorno PATH para que no afecte a lo que Visual Studio necesita.
El código de prueba
Para esto que te comentaré en este post, voy a usar el código publicado en el gist Evaluar.java (gist = trozo de código publicado en GitHub).
En ese código, utilizo la expresión switch (no confundir con la sentencia switch) y los records con tipos genéricos para simular una tuple de 2 valores, (tuple = una estructura de datos que consiste en múltiples partes).
Nota: En el lenguaje Java no existe el «tipo tuple» aunque hay implementaciones que, si lo tienen, como por ejemplo JavaTuples de Maven (en esta página puedes ver algunos ejemplos de JavaTuples), pero no en el JDK oficial (al menos a día de hoy).
Como en mi código necesitaba que una función devolviese dos valores, lo simulé con un record de tipo genérico. Este es el código:
/** * Tuple de dos valores para usar al buscar un operador y la posición del mismo. * * @param operador Un valor del tipo T1. * @param position Un valor del tipo T2. * @param <T1> El tipo (por referencia) del primer parámetro. * @param <T2> El tipo (por referencia) del segundo parámetro. */ record TuplePair<T1, T2>(T1 operador, T2 position) {
}
Compilar el código JAVA y crear el fichero .jar
Descarga el fichero ese de prueba, en el que utilizo 3 clases (2 clases y un record) ambos definidos dentro de la clase Evaluar (fichero Evaluar.java) y cópialo en cualquier carpeta de tu equipo.
Todo lo que aquí te explico también serviría si la clase ConsoleColor está definida en un fichero independiente, aunque el record (TuplePair) debe estar definido dentro de la clase Evaluar, ya que se accede directamente a los campos privados del record en vez de a métodos públicos. Esos campos privados son accesibles desde la clase Evaluar porque el record está definido «dentro» de esa clase.
Compilar el código con javac
Para compilar el código usamos javac indicando los ficheros .java a compilar, opcionalmente le podemos indicar en qué directorio queremos que se creen los ficheros compilados (con extensión .class) y la codificación de esos ficheros, por ejemplo:
En este caso, los ficheros .java están en la misma carpeta desde la que se ejecuta javac.exe y le indicamos que la carpeta para los ficheros .class generados sean en la misma carpeta, (en realidad ese comando u opción -d lo podríamos haber obviado) y que el enconding de los ficheros es UTF-8.
Si el código de los ficheros .java está en otra carpeta, por ejemplo, la carpeta src dentro del directorio actual, y queremos que los ficheros .class se guarden en la carpeta actual, podríamos escribir:
Con esto le estamos indicando que utilice el fichero evaluar.jar, que el método main está en la clase Evaluar y por último los parámetros que queremos pasarle al programa.
Otra forma de usar el código compilado (sin necesidad de que el fichero .jar esté presente, aunque sí los ficheros .class) es:
%JAVA_HOME19%\bin\java Evaluar 25+(2*3)+5!
Aquí le indicamos que use el el método main de la clase Evaluar y pase los parámetros indicados como argumentos del programa.
Crear y usar el .jar con un manifiesto que indica dónde encontrar el método main
Pero lo mejor es crear un fichero de manifiesto donde se le indique al comando jar.exe dónde está (o cuál es) el método main que queremos usar.
Para ello creamos un fichero de texto con el siguiente contenido:
Main-Class: Evaluar
Después de Main-Class: indicaremos el nombre de la clase en la que está definido el método main. Recuerda que el nombre de la clase distingue entre mayúsculas y minúsculas.
Esto lo podemos crear directamente desde la línea de comandos escribiendo lo siguiente:
echo Main-Class: Evaluar > manifiesto.txt
Una vez que tenemos ese fichero del manifiesto, podemos crear el fichero .jar de esta forma:
Si esto último lo hacemos con un .jar sin manifiesto obtendríamos el siguiente error:
no main manifest attribute, in evaluar.jar
Nota: El nombre del fichero manifiesto puede ser el que quieras y con la extensión que quieras. Aunque el nombre recomendado es MANIFEST.MF.
De hecho, si abres un fichero .jar (que en realidad es como un fichero comprimido) puedes ver que la estructura en la que se incluye una carpeta llamada META-INF con el manifiesto, incluso si no indicamos un manifiesto esa carpeta y el correspondiente fichero MANIFEST.MF se crea, aunque sin indicar qué clase contiene el método main.
El contenido del MANIFEST.MF, del .jar que hemos generado, sería este si se ha indicado dónde está el método main):
