Antlr

ANTLR (ANother Tool for Language Recognition – otra herramienta para reconocimiento de lenguajes) es una herramienta creada principalmente por Terence Parr, que opera sobre lenguajes, proporcionando un marco para construir reconocedores (parsers), intérpretes, compiladores y traductores de lenguajes a partir de las descripciones gramaticales de los mismos (conteniendo acciones semánticas a realizarse en varios lenguajes de programación).

ANTLR cae dentro de la categoría de meta-programas, por ser un programa que escribe otros programas. Partiendo de la descripción formal de la gramática de un lenguaje, ANTLR genera un programa que determina si una sentencia o palabra pertenece a dicho lenguaje (reconocedor), utilizando algoritmos LL(*) de parsing. Si a dicha gramática, se le añaden acciones escritas en un lenguaje de programación, el reconocedor se transforma en un traductor o intérprete.

Además, ANTLR proporciona facilidades para la creación de estructuras intermedias de análisis (como ser ASTs – Abstract Sintax Tree), para recorrer dichas estructuras, y provee mecanismos para recuperarse automáticamente de errores y realizar reportes de los mismos.

ANTLR es un proyecto bajo licencia BSD, viniendo con todo el código fuente disponible, y preparado para su instalación bajo plataformas Linux, Windows y Mac OS X.

ANTLRWorks es un entorno de desarrollo con interfaz gráfica que permite el desarrollo de gramáticas para la versión 3.0 o superior de ANTLR. Consiste en una aplicación independiente Java, que se puede ejecutar directamente desde un jar. De quererse incorporar las funcionalidade de ANTLR en ambientes de desarrollo ya existentes, existen plug-ins que se pueden bajar directamente de la web del autor, habilitando el poder trabajar en IntelliJ, gUnit, Eclipse, NetBeans, etc.

Actualmente ANTLR genera código Java, C, C++, C#, Python, Perl, Delphi, Ada95, JavaScript y Objective-C. Otros lenguajes como Ruby, php, etc. son generados por medio de extensiones planteadas por la comunidad.

Ejemplo

grammar SimpleCalc;



tokens {

 PLUS     = '+' ;

 MINUS = '-' ;

}



@members {

 public static void main(String[] args) throws Exception {

 SimpleCalcLexer lex = new SimpleCalcLexer(new ANTLRFileStream(args[0]));

 CommonTokenStream tokens = new CommonTokenStream(lex);

 SimpleCalcParser parser = new SimpleCalcParser(tokens);

 try {

 parser.expr();

 } catch (RecognitionException e)  {

 e.printStackTrace();

 }

 }

}



/*------------------------------------------------------------------

 * PARSER RULES

 *------------------------------------------------------------------*/

expr      : ID '=' op {System.out.println($ID.text +"="+ $op.value);};

op          returns [int value]

 :   e=factor {$value = $e.value;}

 (   PLUS e=factor {$value += $e.value;}

 |   MINUS e=factor {$value -= $e.value;}

 )*

 ;

factor    returns [int value]

: NUMBER {$value = Integer.parseInt($NUMBER.text);};



/*------------------------------------------------------------------

 * LEXER RULES

 *------------------------------------------------------------------*/



ID  :   ('a'..'z'|'A'..'Z')+ ;

NUMBER             : (DIGIT)+ ;

WHITESPACE : ( '\t' | ' ' | '\r' | '\n'| '\u000C' )+   { $channel = HIDDEN; } ;

fragment DIGIT                : '0'..'9' ;

 

La primera parte es la cabecera del fichero. Aquí hemos de prestar atención de darle el mismo nombre que tiene el fichero. ¿Os recuerda a java esto, no? Pues básicamente la idea es la misma. La clase debe llamarse igual que el nombre del fichero, sino, no compilará.

El segundo bloque es la declaración de tokens. Aquí debemos añadir todos los elementos que queremos que reconozca nuestra gramática. En nuestro caso el signo + y el signo –

El tercer bloque @ members contiene el código java de nuestra aplicación. En nuestro caso hemos colocado un main. De hecho el programa funcionará igual sin este código el problema es que no podremos llegar a ver nada si el texto de entrada es aceptado. Lo que hace este código es leer un fichero de texto especificado en la línea de comandos cuando arrancamos nuestro compilador, eso es args[0]. Dentro del bloque try, llamamos a la primera regla del programa (parser.expr()), esto desencadenará el inicio del programa.

El cuarto bloque es las reglas del parser, es decir puramente la gramática. Aquí podemos ver como una expresión es un ID (identificador, o nombre de variable) el token igual ´=´ (si, ya sé que lo podríamos haber definido en el apartado de tokens, pero para que vierais que también podemos ponerlo directamente aquí) y una operación (la definimos más abajo). Lo que vemos entre { } es el código java que he escrito yo. Basicamente nos imprimirá por pantalla las expresiones que vaya reconociendo.
La siguiente regla es la operación. Tenemos un factor OPERANDO factor. El factor en nuestro caso será un entero, lo podemos ver en la tercera regla. Lo que hace es almacenar en una variable valor temporal, el resultado de sumar o restar los dos factores.
La tercera regla, almacena en una variable llamada value el resultado de parsear la lectura del fichero a un Entero.

El cuarto bloque es la declaración de los tipos en nuestro caso un ID (identificador de variable) es cualquier nombre de la a-Z que contenga al menos una letra. Esto es debido a la cláusula positiva de Klenee (+).
El mismo razonamiento para los números, para los espacios en blanco y los dígitos.

Me he dejando por comentar un par de cosas adrede, porque quería que quedaran claras. Los campos disponen de varios valores (como si fueran una struct) estos son .value y .text.

Se entiende que value es un entero y text un campo para almacenar strings, como los ID.