Creacion de un compilador

1. PFM-CIS-IXB
UNIVERSIDAD
NACIONAL
DE LOJA
´Area de la Energ´ıa las Industrias y los Recursos Naturales No
Renovables
Carrera de Ingenier´ıa en Sistemas
COMPILADORES
PROBLEMA: “CONCATENACION
DE PALABRAS”
Noveno B
Alumna:
• Cueva Riofrio, Jessica Mercedes
Docente: Henry, Paz
Loja-Ecuador
Septiembre 2014-Febrero 2015

2. ´Indice
A. DESARROLLO 3
1 . PROBLEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 . ANALIZADOR L´EXICO . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 .1. LIBRERIA jflex.jar . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 .2. ARCHIVO FLEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 . ANALIZADOR SINT´ACTICO . . . . . . . . . . . . . . . . . . . . . . . . 5
3 .1. LIBRER´IA CUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 .2. ARCHIVO CUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
B. Conclusiones 9
C. Recomendaciones 9
2

3. A. DESARROLLO
1 . PROBLEMA
CONCATENACI´ON DE PALABRAS
El compilador resuelve la uni´on de palabras formadas por may´usculas,min´usculas y
n´umeros.
1 La sintaxis que admite el compilador es: (palabra1+palabra2)
2 El par´entesis ( al inicio indica que inicia la expresi´on.
3 El s´ımbolo + indica la concatenaci´on o uni´on de las palabras.
4 El par´entesis ) al final indica el final de la expresi´on.
5 Al momento de unir dos palabras se ignora los espacios.
2 . ANALIZADOR L´EXICO
El analizador l´exico es la base para crear un compilador, para poder generar el ana-
lizador l´exico en nuestro proyecto necesitamos descargar la librer´ıa jFlex.jar, adem´as de
crear el archivo .flex.
2 .1. LIBRERIA jflex.jar
Esta librer´ıa nos permite crear el archivo .java del analizador l´exico sin errores.
La librer´ıa jflex.jar la podemos descargar del siguiente link: http://www.java2s.com/
Code/Jar/j/DownloadJFlexjar.htm
Una vez descargada la libreria jflex.jar la a˜nadimos al proyecto.
2 .2. ARCHIVO FLEX
El archivo .flex es la base para poder construir nuestro analizador l´exico, este archivo
en el compilador se llama analiLex.flex y est´a estructurado por 3 partes:
Secci´on de importaciones
% %
Secci´on de opciones y declaraciones
% %
Secci´on de reglas l´exicas
3

4. Secci´on de importaciones
En esta secci´on colocamos en la primera l´ınea en c´odigo java el paquete en el que
se encuentra nuestro archivo analiLex.flex, luego procedemos a importar las clases que
vamos a utilizar para crear nuestro compilador, en nuestro caso son las siguientes:
Creamos el paquete donde se encuentra el archivo analiLex.flex
/* Codigo de Usuario*/
package archivojflex;
Importamos java cup.runtime.* con la finalidad que exista comunicaci´on instant´anea
con el analizador sint´actico.
import java_cup.runtime.*;
import java.io.Reader;
Secci´on de opciones y declaraciones
Aqu´ı colocamos el nombre de la clase java que va a tomar nuestro analizador l´exico %class
AnalizadorFlex, acceso a la columna y fila de an´alisis CUP %line y %column, habilitamos
la compatibilidad con la interfaz CUP para el generador sint´actico %cup, quedando esta
secci´on de la siguiente manera:
%%
%class AnalizadorFlex
%line
%column
%cup
Declaraciones: son m´etodos en c´odigo java para identificar los s´ımbolos o token del
compilador
%{
private Symbol symbol(int type) {
return new Symbol(type, yyline, yycolumn);
}
private Symbol symbol(int type, Object value) {
return new Symbol(type, yyline, yycolumn, value);
}
%}
Macro declaraciones: son declaraci´on de variables que se utilizaran en la siguiente
secci´on, para determinar las reglas l´exicas del compilador:
4

5. Salto = r|n|rn
Espacio = {Salto} | [ tf]
Dig = 0 | [1-9][0-9]*
Letras = [a-zA-Z_]
Por ´ultimo en nuestro archivo analiLex.flex colocamos la tercera secci´on:
Secci´on de reglas l´exicas
Esta secci´on se refiere a las reglas l´exicas que va a tener el compilador. Las que permi-
ten identificar los s´ımbolos retornando un valor dependiendo del s´ımbolo que ingresemos
y si ingresamos una palabra retornara PALABRA:
%%
/*Seccion de reglas lexicas*/
<YYINITIAL> {
"+" {return new Symbol(sym.MAS);}
"(" {return new Symbol(sym.ABPARENT);}
")" {return new Symbol(sym.CEPARENT);}
({Letras}|{Dig})*{Letras} |({Letras}|{Dig})*{Dig} {return symbol(sym.PALABRA,
new String(yytext()));}
{Espacio} { /* ignora el espacio */ }
}
[ˆ] { throw new Error("Caracter ilegal <"+yytext()+">"); }
Una vez que hayamos construido el archivo analiLex.flex procedemos a generar la clase
AnalizadorLexico.java de la siguiente manera:
1. Creamos en nuestro proyecto una clase ejecutora denominada jlflex 2. Digitamos en
el main lo siguiente:
String [] flex = {"srcarchivosanaliLex.flex"};
jflex.Main.main(flex);
3. Lo ejecutamos
3 . ANALIZADOR SINT´ACTICO
El analizador sint´actico determina la sintaxis que va a tener el compilador, para crear
el analizador sint´actico necesitamos descargar la librer´ıa java-cup.jar, adem´as de la crea-
ci´on del archivo .cup.
5

6. 3 .1. LIBRER´IA CUP
La librer´ıa java-cup.jar la podemos descargar del siguiente link: http://www2.cs.tum.
edu/projects/cup/.
Una vez descargada la librer´ıa java-cup.jar la a˜nadimos al proyecto en el que estamos
trabajando.
3 .2. ARCHIVO CUP
El archivo palabras.cup es la base para construir el analizador sint´actico y sem´antico,
est´a conformado por 5 partes que son las siguientes:
1 Especificaciones de “package” e “imports”.
2 Componentes de c´odigo de usuario.
3 Declaraci´on de s´ımbolos terminales y no terminales.
4 Declaraciones de precedencia.
5 Especificaci´on de la gram´atica.
1. Especificaciones de “package” e “imports”.
En esta parte se colocan: el paquete en el que se encuentra el archivo palabras.cup e
importaciones de clases de la librer´ıa java-cup.jar a utilizar en el proyecto, ademas estas
importaciones son necesaria dentro del c´odigo.
package ejemplocup;
import java_cup.runtime.*;
import java.io.FileReader;
2. Componentes de c´odigo de usuario
En el parser code{: :} de esta secci´on ponemos el c´odigo java de las acciones que va a
realizar el compilador, es decir, en este caso se realizaran dos m´etodos para la captura de
errores (n´umero de fila, n´umero de columna, el texto del error).
parser code {:
/* Reporte de error encontrado. */
public void report_error(String message, Object info) {
StringBuilder m = new StringBuilder("Error");
if (info instanceof java_cup.runtime.Symbol) {
java_cup.runtime.Symbol s = ((java_cup.runtime.Symbol) info);
if (s.left >= 0) {
6

7. m.append(" in line "+(s.left+1));
if (s.right >= 0)
m.append(", column "+(s.right+1));
}
}
if("#5".equals(info.toString())){
message=("Revise PARENTESIS del INICIO");
}
if("#0".equals(info.toString())){
message=("Revise PARENTESIS del FINAL");
}
if("#4".equals(info.toString())){
message=("Falta simbolo de SUMA");
}
m.append(" : "+message);
System.err.println(m);
}
public void report_fatal_error(String message, Object info) {
report_error(message, info);
System.exit(1);
}
:};
3. Declaraci´on de s´ımbolos terminales y no terminales
En los terminales colocamos los tokens o s´ımbolos que sirven para formar la expresi´on
gramatical del compilador.
/* Declaraci´on de s´ımbolos terminales y no terminales */
terminal MAS, ABPARENT, CEPARENT;
terminal String PALABRA;
En los no terminales se colocan las variables que van a componer la expresi´on grama-
tical, en este caso se hace de la siguiente manera:
non terminal Object expr_list, expr_part;
non terminal String palabra, expr;
donde:
expr list: es de tipo Object porque almacena un conjunto de expr part .
expr part: es de tipo Object porque almacena dos expr encerradas en par´entesis
expr
7

8. expr: es de tipo String porque almacena la uni´on o concatenaci´on de dos palabras
ejemplo palabra + palabra
palabra : es de tipo String, y es una palabra normal
4.Declaraciones de precedencia
Esta parte es opcional, en este caso no las necesitamos.
Por ´ultimo realizamos la quinta secci´on o parte del archivo palabras.cup.
5. Especificaci´on de la gram´atica
/*Expresiones gramaticales*/
expr_list ::= expr_list expr_part
|
expr_part
;
expr_part ::= ABPARENT expr:e CEPARENT
{:
System.out.println("");
:}
;
expr ::= palabra:e MAS palabra:v
{:
System.out.print("Concatenado: "+e+v);
:}
;
palabra ::= PALABRA:e
{:
RESULT = e;
:}
;
Una vez construido el archivo palabras.cup procedemos a generar AnalizadorSin-
tac.java de la siguiente manera:
1. Creamos en nuestro proyecto una clase ejecutora denominada MainCup
2. Digitamos en el main lo siguiente:
8

9. String [] option=new String [5];
option[0]="-destdir";
option[1]="src" +File.separator+"archivos";
option[2]="-parser";
option[3]="AnalizadorSintac";
option[4]="src"+File.separator+"archivos"+File.separator+"palabras.cup";
try {
java_cup.Main.main(option);
} catch (Exception e) {
System.out.println("Error en: "+ e);
}
3. Lo ejecutamos
El c´odigo del compilador para la concatenaci´on de palabras lo podr´an encontrar en el
siguiente link: https://github.com/mechasjessy/CompiladorConcatencion/
B. Conclusiones
- Para crear compiladores de debe tener conocimiento e investigar la estructura de
cada archivo (Lex y Cup).
- El compilador esta compuesto por: analizador l´exico, analizador sint´actico y ana-
lizador sem´antico, de los cuales se debe tener un conocimiento de la funci´on que
realizan estos en el compilador.
- Hay que tener muy en claro el compilador que deseamos construir para no tener
problemas en el transcurso de la construcci´on de los analizadores.
C. Recomendaciones
- Nunca olvidar a˜nadir las librer´ıas jflex.jar y java-cup.jar al proyecto.
- En los archivo lex y cup en la primera parte no olvidar colocar el nombre de la
carpeta donde se va a generar el java de nuestros analizadores.
9

10. Referencias
[1] “Breve Introducci´on a CUP”. Fundamentos de Ordenadores I. Disponible en: http:
//www.it.uc3m.es/˜luis/fo1/p/CUP.html
[2] R. A. Vega Castro.(Octubre-2008). “Integraci´on de JFlex y CUP”. Disponible en:
http://www.rafaelvega.com/wp-content/uploads/Articulo.pdf
[3] Open Fecks. Estructura del Archivo JLex. Disponible en: https://openfecks.
wordpress.com/jlex-y-cup/plantilla-archivo-jlex/
10