ANTLR, una (otra) herramienta para el reconocimiento del lenguaje

ANTLR (ANother Tool for Language Recognition) es una herramienta que permite generar analizadores léxicos y sintácticos a partir de una gramática.

En lugar de escribir manualmente todo el código necesario para interpretar un lenguaje, simplemente describimos las reglas del mismo y ANTLR genera automáticamente gran parte de la infraestructura necesaria.

Como lo dice la página oficial:

• Es un potente generador de analizadores sintácticos para leer, procesar, ejecutar o traducir texto estructurado o archivos binarios. 
• Se utiliza ampliamente para crear lenguajes, herramientas y marcos de trabajo. 
• A partir de una gramática, genera un analizador sintáctico capaz de construir y recorrer árboles de análisis.

Nota: Esta herramienta es un paso para el análisis léxico y el parseo. No te generará un compilador completo, pero sí te da la base más difícil: el análisis léxico y sintáctico. Tú debes implementar las fases de semántica y generación de código.

Miremos ahora cómo obtenerlo.

Descargando ANTLR

Existen opciones de descarga para: Java, C#, Python, JavaScript, TypeScript, Go, C++, Swift, PHP y DART: https://www.antlr.org/download.html

En Java:

Si usas Maven para crear un proyecto Java, esta es la dependencia que deberás agregar en el ``pom.xml``:

<dependency> 
  <groupId>org.antlr</groupId> 
  <artifactId>antlr4</artifactId> 
  <version>4.13.2</version> 
</dependency> 

En Python

Abrimos una terminal y tecleamos:

$ pip install antlr4-tools
# En algunos casos pedirá está instalación
$ pip install antlr4-python3-runtime

Podemos validar con:

$ antlr4 -version

Cómo podríamos generar un compilador

Como se dijo, ANTLR no te generará un compilador completo, solo las primeras fases (análisis léxico y parseo).

1. Definir la gramática

Escribes un archivo .g4 que describe las reglas léxicas (tokens) y sintácticas (estructura) de tu lenguaje.

Ejemplo: palabras clave, operadores, estructuras como if, while, funciones, etc.

2. Generar el parser y lexer

ANTLR convierte la gramática en clases de lexer y parser en el lenguaje que elijas (Java, C#, Python, Go, etc.).

Estas clases pueden leer código fuente y producir un árbol sintáctico.

3. Construir el AST (Árbol de Sintaxis Abstracta)

A partir del árbol generado por ANTLR, puedes crear un AST más simplificado y orientado a la semántica del lenguaje.

4. Análisis semántico

Validar tipos, variables, funciones, reglas de alcance, etc.

Aquí defines las reglas que van más allá de la sintaxis.

5. Generación de código o interpretación

Puedes traducir el AST a otro lenguaje (por ejemplo, bytecode de la JVM, C, LLVM IR) o ejecutar directamente como intérprete.

ANTLR en un ejemplo

Supongamos que quieres un lenguaje sencillo con expresiones matemáticas:

Calc.g4

grammar Calc;

expr: term (( '+' | '-' ) term)* ;
term: factor (( '*' | '/' ) factor)* ;
factor: INT ;

INT: [0-9]+ ;
WS: [ \t\r\n]+ -> skip ;

Con esto, ANTLR te genera un parser que reconoce expresiones como 3 + 4 * 5 . Luego, tú decides si las evalúas directamente (intérprete) o las traduces a otro lenguaje (compilador).

Generando el lexer y parser

Usaremos la herramienta ANTLR en Python:

$ antlr4 Calc.g4 -Dlanguage=Python3

Esto generará los siguientes archivos:

.antlr
Calc.g4
Calc.interp
Calc.tokens
CalcLexer.interp
CalcLexer.py
CalcLexer.tokens
CalcListener.py
CalcParser.py
__pycache__

Si queremos emplear otro lenguaje habrá que especificarlo (por default es Java):

$ antlr4 -Dlanguage=CSharp Calc.g4

Probando con Python

Creamos un archivo Python para probarlo:

test_calc.py

import sys
from antlr4 import *
from CalcLexer import CalcLexer
from CalcParser import CalcParser

def main():
    # Ejemplo de entrada
    input_stream = InputStream("3+4*5")

    # Lexer y parser
    lexer = CalcLexer(input_stream)
    stream = CommonTokenStream(lexer)
    parser = CalcParser(stream)

    # Parsear la regla inicial (expr)
    tree = parser.expr()

    # Mostrar el árbol sintáctico
    print(tree.toStringTree(recog=parser))

if __name__ == "__main__":
    main()

Ejecutar:

$ python test_calc.py

Salida:

(expr (expr 3) + (expr (expr 4) * (expr 5)))

Podríamos continuar pero considero que esta entendido.

Continuaremos en la siguiente entrega.

Enlaces:

https://emanuelpeg.blogspot.com/2026/06/antlr-el-primer-paso-para-construir-un.html
https://www.antlr.org/
https://emanuelpeg.blogspot.com/2026/07/nuestro-primer-parser-con-antlr-paso.html