Compilador concatenacion

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

Índice
A. DESARROLLO 3
1 . PROBLEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 . ANALIZADOR LÉXICO . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 .1. LIBRERIA jflex.jar . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 .2. ARCHIVO FLEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3 . ANALIZADOR SINTÁCTICO . . . . . . . . . . . . . . . . . . . . . . . . 5
3 .1. LIBRERÍA CUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 .2. ARCHIVO CUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
B. Conclusiones 9
C. Recomendaciones 9
2

A. DESARROLLO
1 . PROBLEMA
CONCATENACIÓN DE PALABRAS
El compilador resuelve la unión de palabras formadas por mayúsculas,minúsculas y
números.
1 La sintaxis que admite el compilador es: (palabra1+palabra2)
2 El paréntesis ( al inicio indica que inicia la expresión.
3 El s´ımbolo + indica la concatenación o unión de las palabras.
4 El paréntesis ) al final indica el final de la expresión.
5 Al momento de unir dos palabras se ignora los espacios.
2 . ANALIZADOR LÉXICO
El analizador léxico es la base para crear un compilador, para poder generar el ana-
lizador léxico en nuestro proyecto necesitamos descargar la librer´ıa jFlex.jar, además de
crear el archivo .flex.
2 .1. LIBRERIA jflex.jar
Esta librer´ıa nos permite crear el archivo .java del analizador léxico 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ñadimos al proyecto.
2 .2. ARCHIVO FLEX
El archivo .flex es la base para poder construir nuestro analizador léxico, este archivo
en el compilador se llama analiLex.flex y está estructurado por 3 partes:
Sección de importaciones
% %
Sección de opciones y declaraciones
% %
Sección de reglas léxicas
3

Sección de importaciones
En esta sección colocamos en la primera l´ınea en código 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ón instantánea
con el analizador sintáctico.
import java_cup.runtime.*;
import java.io.Reader;
Sección de opciones y declaraciones
Aqu´ı colocamos el nombre de la clase java que va a tomar nuestro analizador léxico %class
AnalizadorFlex, acceso a la columna y fila de análisis CUP %line y %column, habilitamos
la compatibilidad con la interfaz CUP para el generador sintáctico %cup, quedando esta
sección de la siguiente manera:
%%
%class AnalizadorFlex
%line
%column
%cup
Declaraciones: son métodos en código 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ón de variables que se utilizaran en la siguiente
sección, para determinar las reglas léxicas del compilador:
4

Salto = r|n|rn
Espacio = {Salto} | [ tf]
Dig = 0 | [1-9][0-9]*
Letras = [a-zA-Z_]
Por último en nuestro archivo analiLex.flex colocamos la tercera sección:
Sección de reglas léxicas
Esta sección se refiere a las reglas léxicas 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ÁCTICO
El analizador sintáctico determina la sintaxis que va a tener el compilador, para crear
el analizador sintáctico necesitamos descargar la librer´ıa java-cup.jar, además de la crea-
ción del archivo .cup.
5

3 .1. LIBRERÍA 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ñadimos al proyecto en el que estamos
trabajando.
3 .2. ARCHIVO CUP
El archivo palabras.cup es la base para construir el analizador sintáctico y semántico,
está conformado por 5 partes que son las siguientes:
1 Especificaciones de “package” e “imports”.
2 Componentes de código de usuario.
3 Declaración de s´ımbolos terminales y no terminales.
4 Declaraciones de precedencia.
5 Especificación de la gramática.
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ódigo.
package ejemplocup;
import java_cup.runtime.*;
import java.io.FileReader;
2. Componentes de código de usuario
En el parser code{: :} de esta sección ponemos el código java de las acciones que va a
realizar el compilador, es decir, en este caso se realizaran dos métodos para la captura de
errores (número de fila, número 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

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");
}
message=("Revise PARENTESIS del FINAL");
}
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ón de s´ımbolos terminales y no terminales
En los terminales colocamos los tokens o s´ımbolos que sirven para formar la expresión
gramatical del compilador.
/* Declaración 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ón 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éntesis
expr
7

expr: es de tipo String porque almacena la unión o concatenación 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 último realizamos la quinta sección o parte del archivo palabras.cup.
5. Especificación de la gramática
/*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

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ódigo del compilador para la concatenación de palabras lo podrán 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éxico, analizador sintáctico y ana-
lizador semántico, de los cuales se debe tener un conocimiento de la función 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ón de los analizadores.
C. Recomendaciones
- Nunca olvidar añadir 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

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

Compilador concatenacion

Más contenido relacionado

Similar a Compilador concatenacion (20)

Último (20)

Compilador concatenacion