Nuestro primer parser con ANTLR (Paso a paso)

En el post anterior vimos qué es ANTLR y para qué sirve.

Ahora vamos a construir nuestro primer parser desde cero.

No te preocupes si nunca usaste ANTLR. Vamos paso por paso.

Paso 1: Crear un proyecto Maven

Creamos un proyecto vacío:

mvn archetype:generate \

  -DgroupId=com.assembly \

  -DartifactId=mate \

  -DarchetypeArtifactId=maven-archetype-quickstart \

  -DinteractiveMode=false

La estructura debería quedar así:

mate

│

├── pom.xml

│

└── src

    ├── main

    │   └── java

    └── test

Paso 2: Agregar ANTLR

Abrimos el pom.xml y agregamos:

<dependencies>

    <dependency>

        <groupId>org.antlr</groupId>

        <artifactId>antlr4-runtime</artifactId>

        <version>4.13.2</version>

    </dependency>

</dependencies>

Paso 3: Instalar el plugin de ANTLR

Ahora agregamos:

<build>

    <plugins>

        <plugin>

            <groupId>org.antlr</groupId>

            <artifactId>antlr4-maven-plugin</artifactId>

            <version>4.13.2</version>

            <executions>

                <execution>

                    <goals>

                        <goal>antlr4</goal>

                    </goals>

                </execution>

            </executions>

        </plugin>

    </plugins>

</build>

Este plugin será el encargado de generar código Java a partir de nuestras gramáticas.

Paso 4: Crear la carpeta de gramáticas

Creamos:

src/main/antlr4

Quedando:

src

└── main

    ├── antlr4

    └── java

Paso 5: Crear nuestra primera gramática

Creamos:

src/main/antlr4/Mate.g4

Contenido:

grammar Mate;

program

    : 'hola' EOF

    ;

Nuestro lenguaje, por ahora, solamente acepta una palabra:

hola

Nada más.

Es el lenguaje más inútil de la historia.

Pero funciona.

Paso 6: Generar el parser

Ejecutamos:

mvn generate-sources

Si todo salió bien veremos algo parecido a:

Generating grammar...

Y aparecerá una carpeta nueva:

target/generated-sources/antlr4

Dentro encontraremos:

MateLexer.java

MateParser.java

MateListener.java

MateBaseListener.java

Estas clases fueron generadas automáticamente por ANTLR.

Nosotros no escribimos una sola línea de ellas.

Paso 7: Crear una clase de prueba

Creamos:

package com.mate;

import org.antlr.v4.runtime.*;

public class Main {

    public static void main(String[] args) {

        String source = "hola";

        var lexer =

            new MateLexer(

                CharStreams.fromString(source));

        var tokens =

            new CommonTokenStream(lexer);

        var parser =

            new MateParser(tokens);

        parser.program();

        System.out.println("Programa válido");

    }

}

Paso 8: Ejecutar

Corremos:

mvn compile exec:java

Resultado:

Programa válido

¿Qué pasa si el programa es inválido?

Probemos:

String source = "chau";

Ahora obtenemos:

line 1:0 mismatched input 'chau' expecting 'hola'

ANTLR detectó correctamente que nuestro programa no cumple la gramática.

¿Qué acaba de pasar?

Definimos una regla:

program

    : 'hola' EOF

    ;

ANTLR generó automáticamente:

• Un lexer
• Un parser
• Clases auxiliares

Y nuestro programa pudo validar si un texto respetaba o no esa regla.