Guía de Instalación y Ejemplos

USAC
Facultad de Ingeniería
Manuel Elias Muhún Esquit
200018480
Jlex es una herramienta desarrollada en Java el cual puede recibir un
archivo de entrada (archivo .lex) dentro del cual se declaran
expresiones regulares y tokens válidos para un lenguaje que
deseamos reconocer. Dicho de otro modo Jlex es una herramienta
para generar analizadores léxicos.

CUP es un generador de parsers para gramáticas tipo LALR(1),

dentro del código del archivo de entrada (archivo .cup) deben existir
declaraciones de producciones y asociación de fragmentos de código
Java. Cuando una producción es reconocida, se genera un archivo
fuente Java, parser.java que contiene una clase parser, con un
método Symbol parser(), el cual es utilizado para analizar un archivo
de entrada que contiene instrucciones validas para el lenguaje que
hemos creado con Jlex & CUP.

Las extensiones de archivos de entrada pueden ser de cualquier tipo,

al final y al cabo son archivos planos.
1. Instalación del JDK de Java (entorno necesario para compilar y ejecu
2. Descarga e instalación de Jlex
3. Descarga e instalación de CUP
4. Ejemplo
5. Funcionamiento
Para poder utilizar Jlex & CUP uno de los primeros pasos
requeridos es la instalación del JDK, el cual es el entorno
necesario para compilar y ejecutar clases Java.

El instalador del JDK se puede descargar desde la página

de SUN (http://java.sun.com/j2se/1.4.2/download.html).

El procedimiento para instalar el JDK en el entorno Windows

es el tradicional doble clic sobre el archivo ejecutable y
luego el botón siguiente hasta llegar al final de la instalación.

Para este ejemplo nos hemos descargado el jdk1.6.0, sin

realizar modificaciones a la carpeta de instalación que
aparece por default aunque es posible instalarla en cualquier
ubicación de nuestro disco duro.
Clic derecho sobre My
Computer (Mi PC), escoger
Properties (Propiedades) y
luego en System Properties
(Propiedades del Sistema)
se debe escoger la pestaña
Advanced.

Presionare el botón
Environment Varialbes
(Variables de Entorno)
Nos posicionamos sobre la
variable de entorno
CLASSPATH, y
presionamos el botón Edit
(Editar).

Si la variable de entorno no
existe, entonces debe ser
creada presionando el
botón New (Nuevo) y
agregar los datos
correspondientes.
Nos ubicamos al final de la cadena dentro de Variable Value
(Valor de la Variable) y agregamos punto y coma, seguido del
Path de ubicación de la carpeta bin de la instalación del JDK, en
ejemplo se agrega la cadena: “;C:\Program
Files\Java\jdk1.6.0\bin” sin las comillas.

Presionamos el botón Ok y agregamos la misma cadena a la

variable Path.
Realizamos los pasos anteriores
para agregar la cadena “;C:\Program
Files\Java\jdk1.6.0\bin” a la variable
Path. Si la variable Path no existe
debe ser creada utilizando el botón
New (Nuevo) e ingresar los datos.

Después de las anteriores

modificaciones al CLASSPATH y al
Path ya podemos utilizar los
comandos de Java (java, javac,
appletviewer, jar, etc.) desde
cualquier carpeta dentro de nuestro
disco duro.
Jlex es una herramienta creada en y para el lenguaje Java que
sirve para crear analizadores léxicos, a continuación
describimos los pasos de su instalación:

1.Descargar el archivo de instalación de Jlex (

http://www.cs.princeton.edu/~appel/modern/java/JLex/), el cual
consiste en un archivo java (Main.java).
2.Ubicar el Main.java en cualquier carpeta de nuestro disco
duro, en este caso creamos la carpeta jlex dentro del bin del
JDK: C:\Program Files\Java\jdk1.6.0\bin\jlex.
3.Abrimos una ventana del D.O.S. dentro de la carpeta jlex y
compilamos el Main.java con la instrucción: javac Main.java,
después de lo cual podemos ver los archivos .class creados
dentro de la carpeta jlex.
C:\Program Files\Java\jdk1.6.0\bin\jlex>javac Main.java
Como se hiso mención en la intro CUP es un generador de
parsers, a continuación describimos los paso para su
instalación.

1.Descargar el archivo de instalación de CUP (

http://www.cs.princeton.edu/~appel/modern/java/CUP/), el cual
consiste en un archivo .zip.
2.Descomprimimos el archivo y podemos ver varios archivos y
carpetas. La carpeta que no interesa es java_cup la cual
podemos ubicar en cualquier lugar de nuestro disco duro, en
este caso lo ubicamos en la carpeta bin de instalación del JDK
similar a como lo hicimos con el Main.java de Jlex.
3.En este caso no es necesario compilar el contenido de la
carpeta ya que estos archivos han sido previamente
compilados, podemos notarlo por las clases que se encuentran
dentro de la carpeta.
Ejemplo del Archivo JLex:
Guardamos el archivo con el nombre lexico.lex en cualquier
carpeta de nuestro disco duro, en este caso en: C:\prueba.
/*Definición del paquete al que pertenece y otros paquetes que puede utilizar
*/

package Ejemplo;

import java_cup.runtime.Symbol;

/*DIRECTIVAS PARA EL ARCHIVO LEX

Para que sea compatible con cup

%cup
Hace la clase publica
%public
Agrega todos los caracteres, para que este disponible la ñ
%full
Para utilizar el atributo line
%line
Para utilizar el atributo char
%char
Coloca el case insensitive, es decir no hace diferencia entre mayusculas y minusculas
%ignorecase
Esto genera el simbolo de final de archivo
%eofval
*/
/*los nombre que aparecen despues de sym. son los nombre que se le dan a los TERMINALES,
despues se debe de especificar el tipo que se devolvera, regularmente String, pero puede
ser cualquier otro tipo y despues convertirlo*/

/*Nota:
Jlex no acepta comentarios debajo de este símbolo de doble porcentaje.
*/

%%

%{
//declaración de variables y código que va ha ser copiado al escaner
public static int linea=1;
public static int pos=0;

/*Nota:
En este bloque se pueden escribir comentarios.
*/
%}

%cup
%full
%line
%char
%ignorecase
%eofval{
return new Symbol(sym.EOF,new String("Fin de Archivo"));
%eofval}

%%
";" {/*aqui puede ir cualqier otro código: algún calculo o asignación*/
return new Symbol(sym.SEMI, new String(yytext()));}
"+" {return new Symbol(sym.PLUS,new String(yytext()));}
"-" {return new Symbol(sym.MINUS,new String(yytext()));}
"/" {return new Symbol(sym.DIVI,new String(yytext()));}
"*" {return new Symbol(sym.TIMES,new String(yytext()));}
"(" {return new Symbol(sym.LPAREN,new String(yytext()));}
")" {return new Symbol(sym.RPAREN,new String(yytext()));}
[0-9]+ {return new Symbol(sym.NUMBER, new Integer(yytext()));}
[ \t\r\n\f] {/* Ignora espacios en blanco, tabuladores, retornos de carro, etc.*/}
"." {return new Symbol(sym.PUNTO);
/*al estar encerrado entre comillas devuelve el token PUNTO cuando lea
un punto de la entrada. Notese la diferencia con la siguiente instruccion
donde el punto aparece sin comillas. Cuando se coloca un punto sin comillas
junto a sus acciones estas acciones serán ejecutadas cada vez que el analizador
lexico encuentre algun lexema que no concuerde con cualquiera de los
componentes lexicos especificados. Por ejemplo, al encontrar un simbolo
como la @ estre imprimira en la shell "Caracter Ilegal: @". la función
yytext() devuelve el ultimo lexema levantado por el analizador lexico.*/
}
. {System.out.println("Caracter Ilegal: "+yytext());}

El código esta comentado para un mejor entendimiento de cada parte o

bloque que lo compone.
Abrimos una ventana de D.O.S. en la carpeta C:\prueba y
ejecutamos la instrucción:

java JLex.Main lexico.lex

Ejemplo del Archivo CUP:
Guardamos el archivo con el nombre sintactico.cup en la misma
carpeta donde guardamos el archivo lex: C:\prueba.
/*Aqui se incluye el nombre del paquete al que va a pertenecer la clase parser.java
y todos los paquetes que se vayan a utilizar dentro del proyecto. Por ejemplo si se
fuera a utilizar la clase ArrayList se debe agregar la linea import Java.util.ArrayList;
*/
package Ejemplo;

import java.io.*;
import java_cup.runtime.*; //Clase que incluye las instrucciones de CUP

/*el bloque que siguie es codigo que se copia a la clase parser.java,

que puede ser utilizado dentro de las acciones semánticas
este código se copia exactamente igual sin revisar errores.
*/
parser code
{:
public static void main(String args[]) throws Exception{
//new parser(new Yylex(new FileInputStream(args[0]))).parse();
new parser(new Yylex(System.in)).parse();
}

//este método sirve para el manejo de errores provisto por CUP

public void syntax_error(Symbol s){
report_error("Error de sintaxis Linea:"+Integer.toString(Yylex.linea+1)+"
Columna:"+Integer.toString(Yylex.pos+1)+" En \""+s.value+"\"",null);
}
:}
//Sección donde se pueden declarar variables, constantes, etc
action code
{: //mis variables
int integer = 1;
:}

/* Declaración de terminales y los tipos que pueden declararse */

//declaración de terminales y sus tipos

terminal String SEMI, PLUS, MINUS, DIVI, TIMES, LPAREN, RPAREN;
terminal Integer NUMBER;
terminal PUNTO;

//Declaracion de no terminales y sus tipos

non terminal expr_list, expr_part;
non terminal Integer expr;

//presedencia de operadores
precedence left PLUS, MINUS;
precedence left TIMES, DIVI;

/*
Gramática: el lado izquierdo es reemplazado por su correspondiente producción
si es un no terminal. las acciones semánticas se colocan entre llaves y dos puntos {::}
Un terminal o no terminal seguido de dos puntos y una letra sirve como un alias del terminal
o no terminal para poder utilizarlo como una variable del tipo que le fue asignado en los blouqes
anteriores.
*/
expr_list ::= expr_list expr_part
|expr_part
;

expr_part ::= expr:e SEMI {: System.out.println("Operacion Exitosa. Resulatado="+e.intValue()); :}

|PUNTO {: System.out.println("Archivo Parseado Exitosamente."); :}
;

expr ::= NUMBER:n {: RESULT=n; :}

|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 DIVI expr:r {: if (r.intValue() != 0) {
RESULT=new Integer(l.intValue() / r.intValue());
}
else{
System.out.println("Error Semantico División por Cero.");
}
:}
|expr:l TIMES expr:r {: RESULT=new Integer(l.intValue() * r.intValue()); :}
|LPAREN expr:e RPAREN {: RESULT=e; :}
|error SEMI {:System.out.println("Error de Sintaxis");:}
;

Al igual que el archivo lex, el archivo cup esta comentado para una
mejor comprensión.
Abrimos una ventana de D.O.S. en la carpeta C:\prueba y
ejecutamos la instrucción:

java java_cup.Main sintactico.cup

Para unir los archivos generados por el Jlex & CUP y obtener
el analizador final ejecutamos la instrucción:

javac -d . parser.java sym.java tok2.lex.java

El analizador que acabamos de crear reconoce expresiones
aritméticas básicas: suma, resta, multiplicación y división. Los
datos de entrada pueden escribirse en un archivo :

Java Ejemplo.parser < entrada.txt

5+3*6;
5+3-4;
(5+10)*2;
8/2-10;
También podemos ingresar expresiones desde consola:

java Ejemplo.parser

E ingresando:

5*5-10+2*5; 1/1-1;
10+3-5; 10/5+13-3;