PDF de programación - Guía práctica de ANTLR 2.7.2

Guía práctica de ANTLR 2.7.2

Versión 1.0 (Septiembre 2003)

Alumno
Enrique José García Cota
(+34) 666901806
[email protected]

Tutor de proyecto
José Antonio Troyano Jiménez
(+34) 954552777
[email protected]

E.T.S. de Ingeniería Informática de la Universidad de Sevilla.

Departamento de Lenguajes y Sistemas Informáticos.

Guía práctica de ANTLR 2.7.2
Agradecimientos

Agradecimientos

Agradezco a mi tutor, Jose Antonio Troyano, que me haya dado total libertad para elegir el
formato del proyecto.
Así mismo quiero agradecer al equipo de desarrollo de ANTLR, y especialmente a Terence Parr,
el tiempo y esfuerzo que han dedicado a desarrollar esta herramienta y mantener satisfecha a una
extensa comunidad de usuarios, comunidad a la que también estoy agradecido.
Estoy muy agradecido a los desarrolladores de la suite de ofimática OpenOffice.org, sin cuyo
procesador de textos (Writer) me habría muy penoso redactar este documento. Este
agradecimiento se extiende a todas las asociaciones y desarrolladores que contribuyen con el
movimiento del software libre, el código abierto y los estándares accesibles por todos, y en
especial a Richard Stallman y la FSF.
Por último deseo mostrar mi gratitud a mi familia y amigos, que me han apoyado en todo
momento, y a Petra, que ha tenido muchísima paciencia.

Índice de contenido

Índice de contenido

Capítulo 1:
Preámbulos.............................................................................................1
Sección 1.1: Introducción..........................................................................................................2
1.1.1: Objetivos – LeLi y antlraux.......................................................................................................... 2
1.1.2: Requisitos.................................................................................................................................... 2
1.1.3: Enfoque....................................................................................................................................... 2
1.1.4: Estructura.................................................................................................................................... 3
1.1.5: Notación...................................................................................................................................... 4
Sección 1.2: Breve repaso a la teoría de compiladores.........................................................6
1.2.1: Conceptos básicos: software y hardware.................................................................................... 6
1.2.2: Un poco de historia...................................................................................................................... 7
1.2.3: Ensambladores y compiladores................................................................................................... 8
1.2.4: Intérpretes y máquinas virtuales................................................................................................. 9
1.2.5: El proceso de compilación.......................................................................................................... 9
1.2.6: “Compiladores de compiladores”............................................................................................... 12
Sección 1.3: Algoritmos de análisis....................................................................................... 15
1.3.1: La sintaxis EBNF....................................................................................................................... 15
1.3.2: “De arriba a abajo”; Analizadores recursivos descendentes..................................................... 19
1.3.3: “De abajo a arriba”; analizadores LR......................................................................................... 23
1.3.4: Comparación entre LR(k) y LL(k).............................................................................................. 25
Sección 1.4: Conclusión..........................................................................................................28

Capítulo 2:
Presentación de ANTLR......................................................................29
Sección 2.1: Introducción........................................................................................................31
2.1.1: ¿Qué es y cómo funciona ANTLR?........................................................................................... 31
2.1.2: Propósito y estructura de éste capítulo..................................................................................... 31
Sección 2.2: Los analizadores en ANTLR..............................................................................33
2.2.1: Especificación de gramáticas con ANTLR................................................................................ 33
2.2.2: La zona de código nativo.......................................................................................................... 34
Sección 2.3: Los flujos de información..................................................................................35
2.3.1: Flujo de caracteres.................................................................................................................... 35
2.3.2: Flujo de Tokens......................................................................................................................... 35
2.3.3: Los ASTs................................................................................................................................... 38
Sección 2.4: Reglas EBNF extendidas...................................................................................44
2.4.1: Introducción............................................................................................................................... 44
2.4.2: Declarando variables locales en una regla................................................................................ 44
2.4.3: Utilizando las etiquetas.............................................................................................................. 46
2.4.4: Pasando parámetros a una regla.............................................................................................. 46
2.4.5: Devolviendo valores en una regla............................................................................................. 47
2.4.6: Utilizando rangos de caracteres en el analizador léxico........................................................... 48
2.4.7: Utilizando patrones árbol en el analizador semántico............................................................... 48
Sección 2.5: Construcción de los ASTs.................................................................................50
2.5.1: Comportamiento por defecto..................................................................................................... 50
2.5.2: El sufijo de enraizamiento (^).................................................................................................... 51
2.5.3: Sufijo de filtrado (!).................................................................................................................... 52
2.5.4: Desactivando la construcción por defecto................................................................................. 53
2.5.5: Construyendo el AST en una acción......................................................................................... 53
2.5.6: Casos en los que la construcción por defecto no basta............................................................ 55
Sección 2.6: Analizadores de la Microcalculadora............................................................... 56
2.6.1: El fichero MicroCalc.g y el paquete microcalc.......................................................................... 56
2.6.2: El analizador léxico................................................................................................................... 56
2.6.3: El analizador sintáctico.............................................................................................................. 57

Guía práctica de ANTLR 2.7.2 v1.0

Enrique José García Cota

I

Índice de contenido

2.6.4: Nivel semántico......................................................................................................................... 58
2.6.5: El fichero MicroCalc.g............................................................................................................... 59
2.6.6: Generando los analizadores de MicroCalc................................................................................ 61
Sección 2.7: Ejecutando Microcalc........................................................................................ 62
2.7.1: La clase Calc............................................................................................................................. 62
2.7.2: Clase Calc refinada................................................................................................................... 63
2.7.3: Utilizando microcalc.................................................................................................................. 65
Sección 2.8: Conclusión..........................................................................................................67

Capítulo 3:
LeLi: un Lenguaje Limitado................................................................68
Sección 3.1: Introducción........................................................................................................69
Sección 3.2: Nivel léxico..........................................................................................................70
3.2.1: Blancos...................................................................................................................................... 70
3.2.2: Comentarios.................................................................................