JLex y Cup EN NETBEANS Y WINDOWS Vista

Posteare en esta ocasion la manera de empezar a trabajar con las herramientas de Analisis lexico y sintactico jlex y cup en Netbeans y Windows vista por medio de un simple analizador que lo que va a realizar es leer un archivo de entrada y reconocer las palabras que encuentre por medio de unas palabras reservadas que le vamos a indicar. Todo esto se realizo en el Sistema Operativo Windows vista.

Primero que todo, si quieren saltarse toda la explicacion que daré del programa y quieren bajar el proyecto en netbeans completo, descarguenlo de aca: storagestart.divshare.com/launch.php?proyecto1.zip

para ver los pasos a seguir para empezar a usar desde cero jlex y cup en su pc realizen lo siguiente:

CONFIGURACION DE LAS VARIABLES DE ENTORNO

No olviden que primero tienen que configurar sus variables de entorno, si no saben como hacerlos , simplemente abrimos un terminal cmd , nos situamos dentro de la carpeta bin , la que se encuentre en la ruta c:\Archivos\java\jdk1.5.1\bin escribiendo cd c:\Archivos\java\jdk1.5.1\bin, como se ve en el ejemplo siguiente:

ya estando alli situados, escribimos lo siguiente

set CLASSPATH=c:\Archivos\java\jdk1.5.1\bin;%CLASSPATH%

set PATH=c:\Archivos\java\jdk1.5.1\bin;%PATH%

 lo mismo para el path.

dependiendo de donde tiene su carpeta bin del jdk.

INSTALACION DE JLEX

Luego lo primero que hay que hacer es bajar la clase Main.java la cual nos sirve para instala

r jlex, la pueden conseguir del siguiente enlace : JLEX si se dan cuenta alli esta como Main.java, pero si no saben descargarla pues mas facil que copien todo ese codigo, lo peguen en un archivo txt y lo guarden como Main.java, ahora ya tienen su clase Main.java con el codigo fuente de JLex, osea el analisis lexico, pero ahora falta compilar esa clase, entonces lo proximo es irse a su carpeta /bin dentro de la ruta de java, que por lo regular es C:/Archivos de programa/java/jdk1.5.11_0/bin

 

 

ya estando dentro de /bin crear una nueva carpeta llamada JLex, dentro de esta carpeta copiar la clase Main.java que acabamos de conseguir, ose la ruta seria /bin/JLex/Main.java luego hay que compilar las clases de JLex, abrin una terminal cmd , en inicio/ejecutar/ luego escriben cmd, les aparecera una terminal, teclean cd C:/Archivos de programa/java/jdk…../bin , esto los colocara en el directorio bin, luego compilan Jlex, para esto teclean javac JLex/Main.java,

esto les generara los .class dentro de la carpeta Jlex, que necesita JLex para trabajar correctamente.

INSTALACION DE CUP

Ahora colocar en esta misma carpeta bin la carpeta java_cup que pueden descargar de aca java_cup .

si no sirve ese link vayan a la pagina de cup, que es http://www2.cs.tum.edu/projects/cup/ y descarguen cup.zip de alli

luego de descargarla, la descomprimen, y en las tres carpetas que aparecen eligen la que se llama java_cup.

Como ven la colocamos la carpeta en la ruta del bin:

la razon por la cual se colocan estas carpetas JLex y java_cup en esta ruta bin es porque mas adelante a la hora de querer procesar sus archivos de entrada .lex y .cup necesitan usar el comando java JLex.Main miarchivo.lex y java java_cup.Main miarchivo. cup, entonces para que esos comandos funcionen tiene java que ver que las carpetas JLex y java_cup esten registradas en su ruta, osea la ruta bin del jdk, c:\Archivos\java\jdk1.5.1\bin, si java no encuentra esas carpetas en esa ruta les dara error, pero recuerden que solo la carpeta JLex tienen que compilar a mano ya que la java_cup ya viene compilada con sus .class dentro. pero eso lo pueden ver mas adelante a la hora que lo realizemos.

Ahora que ya tiene eso, crean un nuevo proyecto en Netbeans, en mi caso le llame proyecto1.

luego se van a la carpeta de su proyecto en Netbeans, para este ejemplo seria proyecto1/src/proyecto1

Alli copian la carpeta de JLex que teniamos en la ruta de jdk, la carpeta JLEX que acabamos de crear, tambien copian la carpeta java_cup que habiamos bajado anteriormente, SI mas adelante les da problemas o si no consiguieron la carpeta java_cup vayan al sitio oficial de cup y descarguenla de alli

la idea es tener JLex y main_cup en su carpeta de proyecto proyecto1/src/proyecto1 para cuando compilemos mas adelante encuentre la ruta. si no funcionan los que descargaron aca prueben con otros, que a veces difiere de la version de java que tengan.

Asumiendo que ya lograron todo eso, pues construimos nuestros archivos lex y cup de ejemplo, en este caso le llamaremos _scanner.txt al de lex y _parser.txt al que contendra el ejemplo cup. La estructura de mi archivo _scanner.txt la detallo a continuacion:

Si se fijan esto contiene las directivas JLex, para reconocer los tokens, punto y coma, dos puntos,coma, punto coma, parentesis, dos puntos, diagonal , asi como la frase alfanumerica que acepta letras o números o el simbolo _, que es la expresion regular (“_”|{ALPHA_NUMERIC})(“_”|{ALPHA_NUMERIC})*, lo que va a hacer esta aplicacion es que en base a mi archivo de entrada va a desplegar un mensaje dependiendo de que token (caracter) encuentre.

Si no logran ver bien el codigo anterior aca lo pongo

package proyecto1;

import java_cup.runtime.*;

import javax.swing.*;

import java.util.*;

import proyecto1.*;

%%

%class Yylex

%{String literal;

String temp_include;

%}

%{

int columna=1;

%}

%public

%cup

%line

%full

%unicode

%ignorecase

%char

%{

public String sourceFilename;

StringBuffer string = new StringBuffer();

int ultimoEstado = 0;

public void init(){};

%}

%eofval{

{return new Symbol(sym.EOF, null); }

%eofval}

ALPHA=[A-Za-z]

DIGITO=[0-9]

ALPHA_NUMERIC={ALPHA}|{DIGITO}

NEW_LINE=(\n|\r)

WHITE_SPACE=([\ |\t|\f])

LineTerminator = \r|\n|\r\n

InputCharacter = [^\r\n]

st = [^\\\n\"]+ | [\\][\\] | “\\\”" | “\\\’” |”\\t”| “\\n” | “\\r” |”\\b” |”\n”

FRASE=(“_”|{ALPHA_NUMERIC})(“_”|{ALPHA_NUMERIC})*

%%

[\n] { yychar=0;}

[ \t\r\n\f] { /* ignore white space. */ }

\’ { /* ignore apostrofos. */ }

<YYINITIAL> {WHITE_SPACE} {/*no hace nada, aumenta una columna*/yychar++; }

<YYINITIAL> {NEW_LINE} {yychar=0; yyline=0}

<YYINITIAL>”(” { return new Symbol(sym.OPEN, yyline, yychar, yytext());}

<YYINITIAL>”)” { return new Symbol(sym.CLOSE, yyline, yychar, yytext());}

<YYINITIAL>”;” { return new Symbol(sym.PUNTOCOMA, yyline, yychar, yytext());}

<YYINITIAL>”:” { return new Symbol(sym.DOSPUNTOS, yyline, yychar, yytext());}

<YYINITIAL>”,” { return new Symbol(sym.COMA, yyline, yychar, yytext());}

<YYINITIAL>”/” { return new Symbol(sym.DIAGONAL, yyline, yychar, yytext());}

<YYINITIAL>”=” { return new Symbol(sym.EQUALS, yyline, yychar, yytext());}

<YYINITIAL>{FRASE} { return new Symbol(sym.FRASE, yyline, yychar, yytext());}

. {

System.out.println(“error lexico en la fila “+yyline +” y en la columna ” + yychar);

interfaz.rotular(“error lexico :”+ yytext()+” en la fila “+yyline +” y en la columna ” + yychar);

}

Ahora vamos a ver la estructura que voy a usar en mi gramatica, osea en mi archivo _parser.txt , la detallo a continuacion:

Este archivo lo que contiene es mi gramatica sencilla, solo que acepte infinitas sentencias separadas de espacios en blanco.

Si no logran ver aca coloco el codigo anterior

package proyecto1;

import java.io.*;

import java.lang.*;

import java_cup.runtime.*;

import java_cup.runtime.Symbol;

import java.util.ArrayList;

import java.util.*;

import proyecto1.*;

action code{:

void print(String msj)

{System.out.println(msj);}

:}

parser code {:

public void syntax_error(Symbol cur_token){

System.out.println(“va a ingresar el error sintactico “+ cur_token.value);

interfaz.rotular(“va a ingresar el error sintactico “+ cur_token.value);

}

public void unrecovered_syntax_error(Symbol s) throws java.lang.Exception{

interfaz.rotular(“errror YA no se recupera”);

System.out.println(“error YA no se recupera”);

}

public void semantic(Symbol cur_token,String n)

{

System.out.println(“error semantico “);

}

public void semantic(String msg, Object obj) {

}

:};

//////////////////////////////////////////////////////////////////

///////simbolos terminales generales//////////////////

////////////

//////////////////////////////////////////////////////////////////

terminal COMA,PUNTOCOMA,DIAGONAL,DOSPUNTOS, OPEN,CLOSE,EQUALS;

terminal FRASE;

////////////////////////////////////////////////////////////////////

////////////////////////SIMBOLOS NO TERMINALES /////////////////////

/////////////////////////////////////////////////////////////////////

non terminal START, INICIO;

non terminal String SIMBOLO;

 

//////////////////////////inicio de la gramatica ///////////////////////////////////

 

start with START;

START ::= START INICIO

| INICIO

;

INICIO::= FRASE:d {: interfaz.rotular(“Se reconocio una frase alfanumerica : “+ d.toString());:}

| SIMBOLO :d {:interfaz.rotular(“Se reconocio el token “+d.toString());:}

;

SIMBOLO ::= COMA:d {: RESULT =d.toString();:}

| PUNTOCOMA :d {: RESULT =d.toString();:}

| DIAGONAL:d {: RESULT =d.toString();:}

| DOSPUNTOS:d {: RESULT =d.toString();:}

| EQUALS:d {: RESULT =d.toString();:}

| OPEN:d {: RESULT =d.toString();:}

| CLOSE:d {: RESULT =d.toString();:}

;

/****************************Fin de la gramatica************************************************

*/

 

Este archivo contiene la gramatica del proyecto, tal como se indica.

Entonces estos dos archivos, el _scanner.txt y _parser.txt los coloco en el directorio proyecto1/src/proyecto1 de mi proyecto en Netbeans, osea aca:

si se fijan alli aparece la clase Main.java ,esas se creo al hacer el proyecto de Netbeans, y tambien aparecen mi carpeta JLex que copie aca, la que contiene todos los .class que habiamos compilado anteriormente y tambien aparece la carpeta java_cup que contiene todos los .class que habiamos bajado anteriormente , y aparecen tambien nuestros archivos _scanner.txt y _parser.txt.

Ahora lo siguiente es compilar a mano estos archivos para generar las clases Yylex.java sym.java y parser.java que va a usar Netbeans mas adelante, para hacer esto nos vamos a nuestra terminal, nos colocamos en este directorio que mostre, osea a proyecto1/src/proyecto1, para colocarnos alli colocamos en consola el comando cd C:/Users/documents/NetbeansProyect/proyecto1/src/proyecto1

Esto en mi caso, en el caso de ustedes coloque luego de cd la ruta de sus archivos de prueba _scanner.txt y _parser.txt, ya estando colocados dentro de esa ruta, compilamos el archivo _scanner.txt usando los siguientes comandos: java JLex.Main _scanner.txt

aca ilustro esto:

Esto procesa los comandos anteriores y crea la clase _scanner.txt.java,

este archivo lo renombro a Yylex.java para que pueda funcionar el proyecto

quedaria asi:

Ahora compilo mi archivo _parser.txt, el que contiene mi gramatica, para eso ingreso el comando java java_cup.Main _parser.txt

 

Esto procesa mi archivo _parser.txt reconociendo los terminales y no terminales que declaremos, tambien generara las clases parser.java y sym.java , necesarias para que Netbeans pueda trabajar, ya que Netbeans las llama en sus metodos.

Algo importante es que no tiene que generar ningun tipo de error los procesos anteriores, si da un error en consola es porque tienen algo malo en sus archivos lex y cup. revisen en la parte de sus files que no haya ninguna clase marcada en rojo, todo tiene que estar limpio :

como veran ya tenemos todo generado, ahora lo siguiente es crear una clase de tipo Frame, que vamos a llamar interfaz.java

 

Esta fila va a contener la interfaz grafica de la aplicacion, Ahora nos vamos a la clase Main.java, osea la que contiene el metodo public static void Main( String args), dentro de esta clase creamos un metodo llamado Main(), o,sea uno constructor este no es el principal el (string args) que viene por default sino es uno consructor que hacemos a mano, alli colocamos lo siguiente

Este metodo lo que hace es escanear y parsear un archivo llamado entrada.txt , el cual mas adelante crearé desde mi interfaz grafica en Netbeans. Noten que las palabras Parser y Yylex que ponemos arriba no son mas que las referencias a las clases Yylex y Parser que creamos anteriormente.

El codigo de la anterior imagen (clase main) es:

package proyecto1;

import java.io.*;

import javax.swing.*;

/**

*

* @author HOME

*/

public class Main {

Main() {

String path;

parser ThisParser;

Yylex ThisScanner;

path=”entrada.txt”;

try

{ ThisScanner= new Yylex (new FileReader (path));

ThisParser=new parser (ThisScanner);

ThisParser.parse ();

interfaz.rotular( “end of scanner”);

}catch(Exception e)

{interfaz.rotular(“se arruino en el proceso “+e.toString());}

}

public static void main(String[] args) {

new interfaz().setVisible(true);

}

}

 

Ahora lo siguiente es irse a la javax swing form class llamada interfaz que habiamos creado, arrastramos del palette un jTextArea1, para escribir el texto , y un boton,

Ahora en esa clase ponemos hasta arriba import java.io.*;import javax.swing.*;

Esta clase interfaz.java lo que va a hacer es que cuando presionamos el boton scan, inmediatamente va a crear un archivo de texto llamado entrada.txt en la carpeta del proyecto1, entonces ese archivo de texto creado va a contener todo el texto que esta en mi jTextArea de la izquierda, para asi cuando ejecuto el boton, al mismo tiempo que se guarda , ese mismo archivo se usa para cuando llamemos al metodo Main(), y ese mismo sea el que escanee y parsee. el codigo que puse dentro del boton scan es el siguiente:

Donde el metodo guardar() es:

public void guardar() {

String uno=new String();

uno=jTextArea1.getText();

try {

File file1 = new File(“entrada.txt”);

BufferedWriter output = new BufferedWriter(new FileWriter(file1));

output.write(uno);

output.close();

}

catch(Exception e) {

JOptionPane.showMessageDialog(null, “No se pudo guardar archivo de entrada debido a “+ e.toString());

}

}  

 

 

y el metodo new Main() es el que detalle mas arriba .

Ahora arrastramos otro JtextArea2, que nos va a servir para desplegar los resultados.

pongan los jtextareas como publicos y estáticos en sus propiedades, sino no va a dejar llamarlos

Ahora finalmente colocamos en esta mi clase interfaz.java los siguientes dos metodos para que funcione bien:

El codigo de los anteriores metodos es:

public static void rotular(String name){jTextArea2.setText( jTextArea2.getText()+name+”\n”);}public static void rotular2(String name){jTextArea1.setText( jTextArea1.getText()+name+”\n”);}

Ahora solo nos queda debuggear el proyecto y probarlo, nos vamos al menu ayuda, le damos cargar archivo, lo que nos va a mostrar unos comandos de prueba en el tablero, y luego presionamos scan.

nos damos cuenta nos muestra los tokens encontrados, su valor y también los posibles errores lexicos que encuentra con su linea y columna

Nota: el menu ayuda solo esta disponible si bajaron el proyecto completo. si lo hicieron a mano tendran que ingresar los tokens a mano,

Espero que les haya servido de algo esta guia, si quieren ingresar nuevos valores que reconozca jlex en la gramatica , van a tener que seguir todos estos pasos para que funcion en su pc Jlex y cup, adios.

Y asi, despues de tanto al fin tenemos nuestro traductor hecho en Jlex y cup Y Netbeans en Windows vista.La verdad es que este tipo de cosas salen mejor en Linux.

y ya teniendo esto ya pueden realizar el tipico ejemplo de la suma y resta (calculadora) , solo es cuestion de cambiarle la gramatica del archivo cup y modificar el lex