Este documento describe el proceso de instalación y uso de las herramientas JLex y CUP para generar un compilador aritmético básico. Explica cómo instalar el JDK, JLex, CUP y NetBeans, y luego crear archivos JLex y CUP para generar analizadores léxico y sintáctico. Finalmente integra las clases generadas en un proyecto de NetBeans para crear una calculadora funcional.

1. 1
Universidad de San Carlos de Guatemala
Facultad de Ingeniería
Escuela de Ciencias y Sistemas
Organización de Lenguajes y Compiladores 1
Manual de Instalación y generación
de archivos de salida de JLex y CUP
Autor: Rubén Coloma
Email: rubencoloma3@hotmail.com
Febrero de 2010

2. 2
Contenido
1. Instalación del JDK....................................................................................................................... 4
2. Instalación de CUP....................................................................................................................... 5
3. Instalación de JLex ....................................................................................................................... 6
4. Instalación de NetBeans .............................................................................................................. 7
5. Un ejemplo de cómo utilizar JLex y CUP ..................................................................................... 8

3. 3
Introducción
JLex y CUP es una herramienta ampliamente utilizada para la programación de
sistemas informáticos ya que permite generar compiladores a través de gramáticas
independientes del contexto mediante analizadores ascendentes, aunado al gran
potencial que brinda el lenguaje de programación Java.
Este manual tiene como objetivo explicar el proceso de instalación y utilización de
esta herramienta, mas no entrar en detalles de cómo se programan; gramáticas y
analizadores sintácticos con ella, es decir describe como utilizarla para generar
compiladores a través de un ejemplo sencillo. Es importante tomar en cuenta que se
describe una de tantas formas de cómo se puede llevar a cabo esta tarea, ya que existen
muchas otras formas.
Lea detenidamente este documento y siga cada uno de los pasos que se describen
ya que de ello depende que pueda o no generar una salida correcta.

4. 4
1. Instalación del JDK
Lo primero que se necesita es tener instalado el JDK en el equipo, independientemente si
se trata de Windows o una distribución de Linux. Descargar el JDK, o a utilizar otro del que ya
tengamos el instalador. En este manual se utilizará el JDK 1.6.0_03. Es importante tener presente
el lugar en donde se va instalar el JDK ya que el código programado en JLex y CUP se compila
desde consola a través de comandos que nos proporciona Java, por lo cual es aconsejable que en
una instalación en Windows este se instale directamente en el disco duro, y en Linux se trate de
una ruta que no tenga espacios en blanco.
Figura 1
Ubicación de JDK en Windows
En caso de una instalación en Linux personalmente ubico el JDK en
/home/usuario/jdk1.6.0_03.

5. 5
2. Instalación de CUP
Dentro de la carpeta Fuentes (que se encuentra adjunta a este manual o se puede
descargar de http://www.cs.princeton.edu/~appel/modern/java/CUP/) hay una carpeta llamada
FuenteCup y esta a su vez tiene un archivo llamado java_cup_v10k.zip, al descomprimir el archivo
encontraremos los que se muestran en la Figura 2.
Figura 2
Contenido de la carpeta java_cup_v10k
Copiar la carpeta java_cup (señalada en la figura 2) y pegarla dentro del JDK. En el caso de
Windows seria en C:/ jdk1.6.0_03/, y en Linux seria en /home/usuario/jdk1.6.0_03. Con esto
hemos instalado CUP.

6. 6
3. Instalación de JLex
A. Dentro del JDK crear un directorio llamado JLex.
B. Copiar el archivo Main.java que se encuentra dentro de la carpeta FuenteJLex (la
cual esta adjunta a este manual o se puede descargar de
http://www.cs.princeton.edu/~appel/modern/java/JLex/) dentro de la nueva
carpeta que se acaba de crear dentro del JDK.
C. Ahora se debe compilar el archivo Main.java, para lo cual hay que ejecutar una
serie de comandos en consola.
a. Abrir una nueva consola (ya sea en Windows o Linux) y ubicarse dentro
del JDK con el comando cd, tal como se muestra a continuación:
Windows:
C:> cd C:jdk1.6.0_03bin
Linux:
root@localhost# cd /home/usuario/jdk1.6.0_03
b. El siguiente paso consiste en compilar el archive Main.java para lo cual
ejecutamos el comando:
Windows:
C:jdk1.6.0_03bin> javac C:jdk1.6.0_03JLexMain.java
Linux:
root@localhost# ./bin/javac /JLex/Main.java
Si todo salió bien se habrá compilado la clase Main.Java, y la carpeta JLex tendrá 27
elementos aproximadamente, con lo cual se ha terminado el proceso de instalación de JLex.

7. 7
4. Instalación de NetBeans
Para poder unir los archivos generados con JLex y CUP con el proyecto, se necesita contar
con un IDE de Java que facilite la tarea de compilación y construcción, así mismo la integración del
compilador. En este manual se utiliza NetBeans 6.0.1, y como ya se tiene instalado el JDK
únicamente se instala el entorno de desarrollo, sin embargo se puede utilizar cualquier otra
versión de NetBeans ya que técnicamente no debería dar ningún problema.
En el proceso de instalación es sumamente importante verificar que NetBeans haga
referencia a la carpeta en la que se encuentra el JDK así como se muestra en la figura 3.
Figura 3
Ubicación de JDK al instalar NetBeans
Es recomendable descargar separadamente el JDK y NetBeans, así mismo instalar
separadamente para tener un mejor control sobre la herramienta. Por otra parte este proceso es
exactamente igual para la plataforma Windows y Linux.

8. 8
5. Un ejemplo de cómo utilizar JLex y CUP
Lo que se ha hecho hasta el momento es instalar el JDK, JLex, CUP, y NetBeans, pero para
poder generar los archivos analizadores léxicos y sintáctico e integrar estos archivos a un proyecto
de NetBeans se muestra un ejemplo paso por paso. El ejemplo consiste en una calculadora
aritmética básica de suma, resta, multiplicación y división.
1. Crear un proyecto en NetBeans con el nombre calculadora, como se describe a
continuación.
Clic en menú File.
Seleccionar la opción New Project.
Se desplegara una ventana. En la sección Categories seleccionar la opción Java, y
en la sección Projects seleccionar la opción JavaApplication y dar clic en el botón
“Next >”.
En el campo “Project Name:“ ingresar Calculadora y dar clic en el botón “Finish”.
Vea la figura 4.
Figura 4
Ubicación de JDK al instalar NetBeans

9. 9
Después de llevar a cabo los pasos descritos anteriormente se debe haber creado dentro
del proyecto un package con el nombre calculadora, tal como se muestra en la figura 5. Es
importante tener presente el nombre del Package ya que este debe ir también en los archivos de
JLex y CUP, ya que las clases generadas se agregaran a esta Package.
Figura 5
Package Calculadora
2. Crear una carpeta en el disco duro (C:), o en la carpeta de usuario (/home/usuario/) con
el nombre “compilador” (es aconsejable evitar espacios en blanco en la ruta de archivos
por cuestiones prácticas), vea la figura 6.
Figura 6
Ubicación de la carpeta compilador

10. 10
3. Crear un archivo con el nombre calc_lex.java. Este será el archivo que servirá para generar
el scanner o analizador léxico. Abrir el archivo con un editor de texto y colocar lo que se
muestra en el Texto 1.
package calculadora;
import java_cup.runtime.Symbol;
%%
%public
%class Lexico
%cup
%%
"+" { return new Symbol(Simbolos.PLUS); }
"-" { return new Symbol(Simbolos.MINUS); }
"*" { return new Symbol(Simbolos.TIMES); }
"/" { return new Symbol(Simbolos.DIV); }
"(" { return new Symbol(Simbolos.LPAREN); }
")" { return new Symbol(Simbolos.RPAREN); }
[0-9]+ { return new Symbol(Simbolos.NUMBER, new Integer(yytext())); }
[ trfn] { /* ignore white space. */ }
. { System.err.println("Illegal character: "+yytext()); }
Texto 1
Contenido del archivo calc_lex.java
4. Crear un archivo con el nombre calc_cup.java. Este será el archivo que servirá para
generar el parser o analizador sintáctico. Abrir el archivo con un editor de texto y colocar
lo que se muestra en el Texto 2.
5. El siguiente paso consiste en compilar los dos archivos creados para generar las clases en
Java que servirán como un pequeño compilador que funcionara como una calculadora.
Para esto abrir una consola y ejecutar los siguientes pasos.
Ubicarse en la carpeta del JDK a nivel de consola
Windows:
C:> cd C:jdk1.6.0_03
Linux:
root@localhost# cd /home/usuario/jdk1.6.0_03

11. 11
package calculadora;
import java_cup.runtime.*;
parser code
{::}
terminal PLUS, MINUS, TIMES, DIV, LPAREN, RPAREN;
terminal Integer NUMBER;
non terminal root;
non terminal Integer expr;
precedence left PLUS, MINUS;
precedence left TIMES, DIV;
start with root;
root ::= expr:e {: System.out.println(" = "+e+";"); :}
;
expr ::= NUMBER:n
{: RESULT=new Integer(n.intValue()); :}
| expr:l PLUS expr:r
{: RESULT=new Integer(l.intValue() + r.intValue()); :}
| expr:l MINUS expr:r
{: RESULT=new Integer(l.intValue() - r.intValue()); :}
| expr:l TIMES expr:r
{: RESULT=new Integer(l.intValue() * r.intValue()); :}
| expr:l DIV expr:r
{: RESULT=new Integer(l.intValue() / r.intValue()); :}
| LPAREN expr:e RPAREN
{: RESULT=e; :}
;
Texto 2
Contenido del archivo calc_cup.java
Compilar archivo JLex: Ejecutar el siguiente comando en consola.
$ <RUTA DE JAVA> JLex.Main <RUTA DEL ARCHIVO JLEX>
Lo cual debería quedar como se muestra a continuación.

12. 12
Windows:
C:jdk1.6.0_03> C:jdk1.6.0_03binjava JLex.Main C:compiladorcalc_lex.java
Linux:
root@localhost# ./bin/java JLex.Main /home/usuario/compilador/calc_lex.java
Lo cual debe generar una salida como la que se muestra a en la figura 7.
Figura 7
Salida obtenida al compilar calc_lex.java
En la carpeta compilador se debió haber generado un archivo con nombre
calc_lex.java.java, renombrarlo por Lexico.java. Hay que tomar en cuenta que al incluir la
línea
%class Lexico
En el archivo JLex se está indicando que la clase escáner va tener el nombre
Lexico.java. En caso de no colocarle esta línea es aconsejable renombrarlo a Yylex.java.
Compilar archivo CUP1: Para ello se debe ejecutar un comando el cual se describe a
continuación:
-parser <nombre>
Le da nombre al parser.
-symbols <nombre>
Le da nombre a la clase de símbolos.
1
Para ejecutar este comando también es necesario encontrarse ubicado en la carpeta del JDK a nivel de
consola.

13. 13
Si no se especifican los parámetros descritos anteriormente las clases generadas por CUP
tendrán los nombres sym.java para la clase de símbolos y parser.java para el parser, pero es
aconsejable se le dé un nombre propio a cada clase por si en dado caso el proyecto necesita tener
más de un parser (o compilador).
Se debe tener presente que el nombre que se va poner en el archivo sym o symbols tiene
relevancia en el archivo JLex ya que en la especificación de los símbolos se hace referencia al
nombre que tendrá el archivo o clase de símbolos. Por ejemplo en el caso del símbolo PLUS se
tiene la siguiente especificación:
"+" { return new Symbol(Simbolos.PLUS); }
Como se puede dar cuenta en la definición del símbolo se especifica el nombre de la clase
que lo contendrá, entonces este nombre varía según el que se le especifica en el comando de
compilación de CUP. En caso de que no se le cambie nombre al archivo de símbolos la línea luciría
como se muestra a continuación.
"+" { return new Symbol(sym.PLUS); }
Esto se repite para todos los símbolos especificados. En este manual se asume que se
renombrarán todos los archivos de salida.
El comando debería quedar de la siguiente forma (si se renombran los archivos del parser
y sym):
Windows:
C:jdk1.6.0_03> C:jdk1.6.0_03binjava java_cup.Main –parser Parser
–symbols Simbolos C:compiladorcalc_cup.java
Linux:
root@localhost#./bin/java java_cup.Main –parser Parser –symbols Simbolos
/home/usuario/compilador/calc_cup.java
Si no se renombran los archivos del parser y sym, el comando debería quedar de la
siguiente forma:
Windows:
C:jdk1.6.0_03> C:jdk1.6.0_03binjava java_cup.Main
C:compiladorcalc_cup.java
Linux:
root@localhost#./bin/java java_cup.Main
/home/usuario/compilador/calc_cup.java

14. 14
En caso que se haya cambiado el nombre de los archivos, la salida debería ser como la que
se muestra en la figura 8.
Figura 8
Salida obtenida al compilar calc_cup.java
Los archivos generados se deben encontrar en la carpeta del JDK.
6. Después de terminar el paso anterior se tendrán tres archivos de salida:
Lexico.java en la carpeta compilador.
Simbolos.java y Parser.java en el JDK.
Seleccionar los tres archivos, cortarlos y pegarlos en la carpeta calculadora del
proyecto creado en NetBeans, es decir hay que pegarlos en /calculadora/src/calculadora,
con lo cual se han integrado las clases generadas al proyecto.
7. Seleccionar la carpeta java_cup que tiene las fuentes de CUP (puede ser la que se
encuentra en el JDK) copiarla y pegarla en /calculadora/src. Esto se hace por que las
clases Símbolos y Parser necesitan funcionalidad de CUP para llevar a cabo el análisis
sintáctico de los archivos de entrada.
En la ficha Project de NetBeans el proyecto se debe ver como se muestra en la figura 9.

15. 15
Figura 9
Apariencia del proyecto posterior a la integración de los archivos.
La figura en forma de llaves para desatornillar indica que las clases no han sido
compiladas, entonces se da clic derecho la clase Lexico.java y se selecciona la opción Compile File,
repetir esto para los dos archivos restantes (Parser y Simbolos).
Ahora lo que resta es instanciar la clase Parser en el Main.java del proyecto para utilizar el
compilador generado dentro del proyecto. El proyecto funcionará de la siguiente manera; el
usuario va ejecutar el archivo .jar del proyecto desde línea de comandos, y ahí mismo va introducir
una operación aritmética, y el programa dará como salida el resultado de la operación. Para ello la
clase Main.java debe quedar como se muestra en el Texto 3.
Para terminar hay que dar clic en el menú Build, y seleccionar la opción Clear and Build
Main Project. Con esto se ha terminado el proyecto, ir a la carpeta calculadoradist en la cual se
encuentra el archivo calculadora.jar, copiarlo y pegarlo en el C: o /home/usuario y ejecutar el
siguiente comando:
Windows:
C:> java -jar C:calculadora.jar 5+8
Linux:
root@localhost#./bin/java -jar /home/usuario/calculadora.jar 5+8

16. 16
package calculadora;
import java.io.StringReader;
public class Main
{
public static void main(String[] args)
{
Lexico Escaner = null;
Parser oParser = null; // Con 'P' al inicio.
try
{
Escaner = new Lexico(new StringReader(args[0]));
oParser = new Parser(Escaner);
oParser.parse();
}
catch (Exception ex)
{
System.out.println(ex.toString());
}
}
}
Texto 3
Contenido del archivo Main.java
Lo cual dará como salida el resultado que se muestra en la figura 10.
Con esto se concluye el ejercicio y el objetivo de este manual.