Uso ANTLR con
diferentes IDEs
Procesadores de Lenguajes
Emilio López y Jaime Urquiza
Guía breve de uso de ANTLR con diferentes IDEs. Se describe el proceso de descarga e instalación.
También se describe cómo se utiliza la herramienta con Eclipse e IntelliJ sin utilizar plugins y utilizándolos.
1
Tabla de contenidos
Descarga e instalación de ANTLR ................................................................................................ 2
Ejemplo de utilización de ANTLR sin usar plugin ....................................................................... 2
Paso 2: incluir la librería de ANTLR .......................................................................................................4
En el IDE Eclipse......................................................................................................................................................................... 4
En el IDE IntelliJ .......................................................................................................................................................................... 7
Paso 7: incluir fichero de prueba como argumento de la ejecución ...................................................9
En el IDE Eclipse......................................................................................................................................................................... 9
En el IDE IntelliJ ........................................................................................................................................................................ 10
Ejemplo de utilización de ANTLR usando plugins .................................................................... 12
Usando Eclipse con plugin .....................................................................................................................12
Descarga e instalación de Eclipse ......................................................................................................................................... 12
Instalar software adicional necesario .................................................................................................................................. 12
Instalar ANTLR 4 IDE ............................................................................................................................................................. 12
Crear un proyecto antlr en Eclipse ..................................................................................................................................... 12
Crear una aplicación para usar los analizadores .............................................................................................................. 13
Flujo de trabajo ........................................................................................................................................................................ 13
Usando IntelliJ con plugin ......................................................................................................................14
Descarga e instalación del plugin.......................................................................................................................................... 14
Flujo de trabajo con el plugin de IntelliJ ............................................................................................................................. 14
Anexo 1. Código de la clase principal ......................................................................................... 18
Descarga e instalación de ANTLR
Si se va a usar el escritorio de desarrollo de MyApps no es necesario instalar nada, la herramienta ANTLR (que es
una librería ejecutable java, un fichero .jar) está almacenada en el directorio C:\Program Files
(x86)\ANTLR, la librería está incluida en el classpath y se va a incluir un comando por lotes llamado antlr4 que
podréis utilizar para ejecutar la herramienta ANTLR desde cualquier ubicación en el ordenador.
Pasamos a explicar el proceso en caso de que sea necesario descargar e instalar ANTLR 4.9.1, que es la última
versión disponible. La descarga se puede realizar desde la web oficial: https://www.antlr.org/download/antlr-4.9.1-
complete.jar.
Para su instalación hay que dar los siguientes pasos:
1. Crear un directorio ANTLR en (por ejemplo) C:\Program Files y dentro de este directorio se guarda
el fichero descargado: antlr-4.9.1-complete.jar
2. Incluir este fichero con su PATH absoluto en la variable de entorno CLASSPATH (si no existe, crearla). En
el caso de este ejemplo el PATH absoluto del fichero sería:
C:\Program Files\ANTLR\antlr-4.9.1-complete.jar
3. En el directorio creado anteriormente (C:\Program Files\ANTLR) crear un fichero llamado
antlr4.bat cuyo contenido sea (teniendo en cuenta este ejemplo):
java -jar C:\Program Files\ANTLR\antlr-4.9.1-complete.jar %*
4. Incluir el directorio creado C:\Program Files\ANTLR\ en la variable de entrono PATH para poder
ejecutar el comando antlr4 desde cualquier otro directorio en el ordenador.
Ejemplo de utilización de ANTLR sin usar plugin
El flujo de trabajo sin usar plugin es el siguiente:
1. Crear un proyecto para una aplicación java en el IDE elegido.
2. Incluir el fichero antlr-4.9.1-complete.jar como librería externa en el proyecto actual (la sección
“Paso 2: incluir la librería de ANTLR” muestra el detalle de cómo hacerlo para Eclipse e IntelliJ)
3. Escribir la especificación en un fichero de extensión .g4 con cualquier editor de texto, incluso el propio
editor del IDE usado. Se recomienda guardar este fichero en el mismo directorio en que se guardarán los
ficheros java de nuestro proyecto. Un ejemplo de especificación sería el fichero Numbers.g4 con el
siguiente contenido:
grammar Numbers;
r : (REAL | NATURAL)+;
REAL : [0-9]+’.’[0-9]+ {System.out.println("<Real>");};
NATURAL : [0-9]+ {System.out.println("<Natural>");};
Donde r es el axioma de la gramática y, REAL y NATURAL los tokens detectados en la misma. Nótese que
el nombre del fichero coincide el nombre dado después de la directiva “grammar” de la especificación.
4. Ejecutar ANTLR desde la línea de comandos dando como argumento de la llamada el fichero Numbers.g4
creado en el paso anterior.
java -jar antlr-4.9.1-complete.jar Numbers.g4
ó
antlr4 numbers.g4
5. El resultado de este paso es la creación del siguiente conjunto de ficheros en el mismo directorio en que
se encuentra el fichero Numbers.g4:
• NumbersLexer.java • Numbers.interp
• NumbersParser.java • Numbers.tokens
• NumbersListener.java • NumbersLexer.interp
• NumbersBaseListener.java • NumbersLexer.tokens
6. Crear en el proyecto java la clase principal (ver ejemplo en Anexo 1) donde se usen las clases
NumbersLexer y NumbersParser generadas por ANTLR en el paso anterior, así como el axioma de
la gramática r. Nótese que los nombres están adaptados al ejemplo.
7. Crear un fichero de texto para probar la aplicación. Se puede usar cualquier editor de texto, incluso el
propio editor del IDE usado. Guardar ese fichero en el directorio raíz del proyecto java. Por ejemplo:
344.12
984
65.3
8. Incluir ese fichero de prueba como argumento de la ejecución del proyecto (la sección “Paso 7: incluir
fichero de prueba como argumento de la ejecución” muestra el detalle de cómo hacerlo para Eclipse
e IntelliJ)
3
9. Ejecutar el proyecto y observar la salida ofrecida por el IDE.
a. ¿Dan errores? ¿pensar por qué aparecen esos errores?
b. Prueba con la siguiente especificación, donde se le ha añadido la última línea y piensa por qué ha
cambiado el resultado.
grammar Numbers;
r : (REAL | NATURAL)+;
REAL : [0-9]+’.’[0-9]+ {System.out.println("<Real>");};
NATURAL : [0-9]+ {System.out.println("<Natural>");};
IGNORE : . -> skip;
Paso 2: incluir la librería de ANTLR
En el IDE Eclipse
Se puede hacer en dos momentos diferentes, cuando se crea el proyecto o una vez ya creado. Cuando se crea el
proyecto:
Seleccionar “Next” y la pestaña “Libraries”
4
Dentro de la pestaña “Libraries” seleccionar a la derecha el botón “Add external JARs…” y seleccionar el fichero
antlr-4.9.1-complete.jar en la ubicación que se haya elegido durante su instalación, en el ejemplo
C:\Program Files\ANTLR.
5
A continuación, seleccionar “Finish”.
También se puede incluir una vez creado el proyecto, para ello hacer click sobre el proyecto con el botón derecho
del ratón y seleccionar la opción “Properties” del menú contextual. A continuación, seleccionar en la parte izquierda
“Java Build Path”
Seleccionar la pestaña “libraries”, en la parte derecha el botón “Add external JARs…” y seleccionar el fichero
antlr-4.9.1-complete.jar en la ubicación que se haya elegido durante su instalación, en el ejemplo
C:\Program Files\ANTLR.
Para finalizar, seleccionar “Apply and Close”.
6
En el IDE IntelliJ
Una vez creado el proyecto, En el menú “File” seleccionar la opción “Project Structure…”
En la siguiente pantalla seleccionar “Libraries” y el botón “+”
Seleccionar la opción “Java” en el menú que aparece.
7
Seleccionar el fichero antlr-4.9.1-complete.jar en la ubicación que se haya elegido durante su instalación
y seleccionar “OK”. En la siguiente ventana:
Seleccionar “OK” y en la siguiente ventana:
Seleccionar de nuevo “OK”. Ahora aparecerá ANTLR como librería externa.
8
Paso 7: incluir fichero de prueba como argumento de la ejecución
En el IDE Eclipse
En el menú “Run” seleccionar la opción “Run Configurations…”.
Hacer doble click en “Java Application” y a continuación, asignar un nombre a esta configuración de ejecución en
“Name:”, seleccionar el Proyecto (“Project”) y la clase principal (“Main class”) anteriormente creada.
9
En la pestaña “(x)= Arguments”
Incluir en el campo “Program arguments” el nombre del fichero de prueba creado anteriormente y seleccionar
“Apply”. A partir de ahora se podrá seleccionar esta configuración de ejecución para probar el proyecto.
En el IDE IntelliJ
Del menú “Run” seleccionar la opción “Run…”
Seleccionar “Edit configurations”
10
En la siguiente ventana seleccionar “+” y “Application.
En el campo de texto “Main class” introducir el nombre de la clase principal creada. Y en el campo “Program
arguments”:
Incluir el nombre del fichero de prueba creado anteriormente y seleccionar “Apply”. A continuación, en la misma
ventana, seleccionar “Close” para cerrar la configuración y ejecutarla más tarde o “Run” para ejecutarla
inmediatamente.
11
Ejemplo de utilización de ANTLR usando plugins
Usando Eclipse con plugin
Existen varias herramientas de desarrollo para utilizar antlr desde un IDE. En esta guía se explica cómo configurar
el IDE Eclipse. Eclipse tiene muchos “sabores”, esta guía se ha preparado con Eclipse for Java developers 2020-12
en Windows y MacOS. Es muy probable que lo explicado sirva también para otras variantes de Eclipse, como STS.
En el repositorio GitHub de ANTLR 4 IDE puedes encontrar toda la información detallada. En la web de ANTLR
se pueden encontrar enlaces para otros IDEs.
Descarga e instalación de Eclipse
Si aún no tienes Eclipse, todo lo que necesitas está aquí:
https://www.eclipse.org/downloads/
En el proceso de instalación puedes elegir la versión de Java a utilizar. Se recomienda utilizar la 1.11.
Instalar software adicional necesario
Desde Eclipse, ve a Help/Install new software… para instalar el siguiente software adicional:
• XText
– Work with:
http://download.eclipse.org/modeling/tmf/xtext/updates/composite/release
s/
– Seleccionar: Xtext Complete SDK. (NOTA: Según la documentación del plugin, debe ser la
versión 2.7.3x, aunque también funciona con la última versión disponible.
• Faceted
– Work with: http://download.eclipse.org/releases/luna
– Seleccionar: Eclipse Faceted Project Framework y Eclipse Faceted Project
Framework JDT Enablement.
Instalar ANTLR 4 IDE
Desde Eclipse, ve a Help/Eclipse Marketplace… y busca antlr. Elige ANTLR 4 IDE e instálalo.
Crear un proyecto antlr en Eclipse
Vamos a crear un proyecto ANTLR.
1. Ve a File/New Project/Project
2. En la pestaña General, elige ANTLR 4 Project. Observa que por defecto crea una carpeta llamada
target y un archivo Hello.g4 con una gramática de ejemplo.
3. Ve a las propiedades del proyecto:
– Ve a Project Facets y haz clic en Convert to faceted form...
– Marca el project facet Java y haz clic en Apply. Haz clic en Ok, deja que el proyecto se
reconstruya y vuelve a abrir las propiedades del proyecto.
– En Java Build Path, haz clic en la pestaña Source y en Add Folder… expande la carpeta
target > generated-sources > antlr4 y selecciona esta carpeta.
– En Java Build Path, en la pestaña Libraries haz clic en Add External JARs…. Busca el
archivo antlr-4.x-complete.jar descargado al principio y añádelo. (NOTA: Si has creado el
12
proyecto como un proyecto Java, debes añadirlo a ClassPath, aunque se recomienda crear el
proyecto como ANTLR 4 Project)
– En ANTLR 4 > Tool, activa Enable project scpecific settings, haz clic en Add y
añade tu archivo antlr*.jar. Activa la casilla de este archivo en la lista.
Si todo ha ido bien, en la Consola de ANTLR deben haber ido apareciendo mensajes, el último de ellos BUILD
SUCCESFUL, y los archivos .java estarán generados en el default package.
Una vez tenemos el proyecto, a medida que modifiquemos los archivos .g4 se irán actualizando los archivos con
el código fuente.
Crear una aplicación para usar los analizadores
Para poder utilizar el código creado, debemos crear una clase principal y compilar el proyecto.
Crea la clase HelloRunner usando default package con el siguiente contenido:
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.tree.*;
public class HelloRunner
{
public static void main( String[] args) throws Exception
{
CharStream input = CharStreams.fromFileName(args[0]);
HelloLexer lexer = new HelloLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
HelloParser parser = new HelloParser(tokens);
ParseTree tree = parser.r(); // begin parsing at rule 'r'
System.out.println(tree.toStringTree(parser)); // print LISP-style tree
}
}
Para ejecutar el programa, es necesario pasar como argumento un archivo de texto como input.
Crea un archivo de texto llamado input.txt con el siguiente contenido:
hello geek
Añádelo como argumento en Run/Run Configurations…
Ejecuta la aplicación. Si todo ha ido bien, deberías tener en la consola el árbol sintáctico en estilo LISP:
(r hello geek)
Flujo de trabajo
Para realizar los ejercicios y prácticas sucesivas, crea un proyecto como se ha descrito antes, teniendo
en cuenta lo siguiente:
1. Crea los archivos .g4 con la especificación. Recuerda que el nombre del archivo debe ser igual al
nombre de la gramática especificada (por ejemplo, grammar Foo; si el archivo se llama Foo.g4.
13
2. Crea los archivos de texto que quieras pasar a la gramática, y añádelos a la configuración.
3. En la función main, asegúrate de que utilizas los nombres de clases adecuados (por ejemplo,
FooLexer, etc.
Usando IntelliJ con plugin
Descarga e instalación del plugin
Descargar el plugin desde el enlace incluido en la página de ANTLR (https://www.antlr.org/tools.html), que nos
llevará a la página de JetBrains donde se descarga la última versión del plugin. Para instalar el plugin, seleccionar
del menú “File” la opción “Settings”. En la siguiente ventana seleccionar “Plugins” en la parte izquierda y en la
parte derecha, en el botón de engranaje y seleccionar “Install Plugin from Disk…”, seleccionar OK, terminar su
instalación y reiniciar el entorno de desarrollo.
Flujo de trabajo con el plugin de IntelliJ
1. Crear un proyecto para una aplicación java en el IDE elegido.
2. Incluir el fichero antlr-4.9.1-complete.jar como librería externa en el proyecto actual (la sección
“Paso 2: incluir la librería de ANTLR” muestra el detalle de cómo hacerlo para Eclipse e IntelliJ)
14
3. Crear un fichero en el directorio “src” del proyecto y asignarle el nombre Numbers.g4
4. El entorno reconocerá inmediatamente que es una especificación ANTLR. Un ejemplo de especificación
sería el fichero Numbers.g4 con el siguiente contenido:
grammar Numbers;
r : (REAL | NATURAL)+;
REAL : [0-9]+’.’[0-9]+ {System.out.println("<Real>");};
NATURAL : [0-9]+ {System.out.println("<Natural>");};
Donde r es el axioma de la gramática y, REAL y NATURAL los tokens detectados en la misma. Nótese que
el nombre del fichero coincide el nombre dado después de la directiva “grammar” de la especificación.
5. Generar el analizador con ANTLR, desde el menú contextual al hacer click derecho en el fichero de la
especificación ANTLR, seleccionar “Generate ANTLR Recognizer”:
15
6. Como resultado, por defecto, ANTLR crea el directorio “gen” con el siguiente conjunto de ficheros:
• NumbersLexer.java • NumbersVisitor.java
• NumbersParser.java • Numbers.interp
• NumbersListener.java • Numbers.tokens
• NumbersBaseListener.java • NumbersLexer.interp
• NumbersBaseVisitor.java • NumbersLexer.tokens
Este comportamiento se puede modificar usando la opción del menú contextual “Configure ANTLR…”.
7. Indicar a IntelliJ que el nuevo directorio almacenará los ficheros fuente del proyecto. En el menú “File”
seleccionar la opción “Project Structure…”.
En la parte derecha de la pantalla, en el menú contextual de la carpeta “gen” seleccionar la opción
“Sources” y la opción “OK”.
8. Crear en el proyecto java, en el directorio “gen” la clase principal (ver ejemplo en Anexo 1) donde se usen
las clases NumbersLexer y NumbersParser generadas por ANTLR en el paso 6, así como el axioma
de la gramática r. Nótese que los nombres están adaptados al ejemplo.
9. Crear un fichero de texto para probar la aplicación en el directorio raíz del proyecto java. Se puede usar
cualquier editor de texto, incluso el propio editor del IDE usado. Por ejemplo:
344.12
984
65.3
10. Incluir ese fichero de prueba como argumento de la ejecución del proyecto (la sección “Paso 7: incluir
fichero de prueba como argumento de la ejecución” muestra el detalle de cómo hacerlo para
Eclipse e IntelliJ)
16
11. Ejecutar el proyecto y observar la salida ofrecida por el IDE.
a. ¿Dan errores? ¿pensar por qué aparecen esos errores?
b. Prueba con la siguiente especificación, donde se le ha añadido la última línea y piensa por qué ha
cambiado el resultado.
grammar Numbers;
r : (REAL | NATURAL)+;
REAL : [0-9]+’.’[0-9]+ {System.out.println("<Real>");};
NATURAL : [0-9]+ {System.out.println("<Natural>");};
IGNORE : . -> skip;
17
Anexo 1. Código de la clase principal
Este código sirve para arrancar el procesador generado, recibe el nombre del fichero a procesar, crea el analizador
léxico NumbersLexer, el sintáctico NumbersParser y arranca el proceso al llamar al axioma de la gramática
(r) de la especificación anasint.r();
import java.io.*;
import org.antlr.v4.runtime.*;
/*
El nombre ClasePrincipal es arbitrario, escoge el que prefieras.
Sustituye Numbers por el nombre del fichero que contiene la especificación de la gramática ANTLR
(extensión .g4)
*/
public class ClasePrincipal {
public static void main(String[] args) {
try{
// Preparar el fichero de entrada para asignarlo al analizador léxico
CharStream input = CharStreams.fromFileName(args[0]);
// Crear el objeto correspondiente al analizador léxico con el fichero de
// entrada
NumbersLexer analex = new NumbersLexer(input);
// Identificar al analizador léxico como fuente de tokens para el
// sintactico
CommonTokenStream tokens = new CommonTokenStream(analex);
// Crear el objeto correspondiente al analizador sintáctico
NumbersParser anasint = new NumbersParser(tokens);
/*
Si se quiere pasar al analizador algún objeto externo con el que trabajar,
este deberá ser de una clase del mismo paquete
Aquí se le llama "sintesis", pero puede ser cualquier nombre.
NumbersParser anasint = new NumbersParser(tokens, new sintesis());
*/
/*
Comenzar el análisis llamando al axioma de la gramática
Atención, sustituye "AxiomaDeLaGramatica" por el nombre del axioma de tu
gramática
*/
anasint.r();
} catch (org.antlr.v4.runtime.RecognitionException e) {
//Fallo al reconocer la entrada
System.err.println("REC " + e.getMessage());
} catch (IOException e) {
//Fallo de entrada/salida
System.err.println("IO " + e.getMessage());
} catch (java.lang.RuntimeException e) {
//Cualquier otro fallo
System.err.println("RUN " + e.getMessage());
}
}
}
Para reutilizar esta clase habrá que cambiar Numbers por el nombre de la gramática g4 y r por el nombre del
axioma de la especificación.
18
