Informe compilador divisor

CIS-IXB-001
UNIVERSIDAD
NACIONAL
DE LOJA
´Area de la Energ´ıa las Industrias y los Recursos Naturales No Renovables
Carrera de Ingenier´ıa en Sistemas
“COMPILADOR DIVISOR DE
CANTIDADES”
MODULO IX B
Autores:
SORAYA ISAMAR LARA TAPIA
Docente:
ING. HENRY PAZ
Fecha:
13 FEBRERO 2014
Loja-Ecuador
Septiembre 2014 - Julio 2015
1

Índice
1. Problema: 3
1.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2. Autómata 3
3. Desarrollo 3
4. JFlex 3
4.1. Código de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.2. Directivas JFLex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
4.3. Reglas léxicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
5. CUP 7
5.1. Definición de paquete e importación de paquetes necesarios. . . . . . . . . 7
5.2. Código de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5.3. Declaración de s´ımbolos terminales y no terminales. . . . . . . . . . . . . . 11
5.4. Definición del s´ımbolo inicial de la gramática y las reglas de producción . . 11
6. Sym 13
7. Control de errores 14
8. Funcionamiento del compilador 14
9. Ejecución de Errores 15
10.Conclusiones 19
11.Recomendaciones 19
12.Referencia del código fuente 20
13.Bibliográfica 21
2

1. Problema:
Un compilador que permita dividir en partes iguales el total de una cantidad de dinero
para un numero determinado de personas las cuales tienen que ser diferentes de cero.
1.1. Ejemplos
El Ingreso de datos debe ser: 35/7; y el resultado obtenido sera igual 2,833333
2. Autómata
A continuación presentamos la representación del autómata que es la estructura del
compilador Figura 1.
Figura 1: Autómata del compilador
3. Desarrollo
Para el desarrollo del compilador se esa utilizando la librer´ıa JFLEX y CUP que son
la parte léxica y sintáctica del compilador.
4. JFlex
Es desarrollada en Java, la cual genera un programa en Java a partir de una especifi-
cación en el que se indican los tokens permitidos por nuestro lenguaje.
Un archivo de especificación para JFLex esta organizado en tres secciones, separadas
por: “ % % ”.
3

4.1. Código de usuario.
En esta sección se crean las clases necesarias para nuestro analizador léxico, las cuales
serán copiadas directamente al inicio del archivo de salida y se importan los paquetes
necesarios. Primero se declara el nombre del paquete en el cual esta contenido y la librer´ıas
a utilizar. Figura 2.
Figura 2: Código de usuario
4.2. Directivas JFLex.
En esta sección se incluyen algunas reglas propias de JFLex. También se pueden definir
macros, que resuman ciertas expresiones regulares que nos serán útiles al momento de
identificar tokens en la siguiente sección, y estados. Figura 3.
Figura 3: Directivas de Jflex
4

Cambiamos el nombre de la clase del analizador a Lexer. % class AnalizadorLexico
Realizamos la activación del contador de lineas, variable yyline y el contador de co-
lumna, variable yycolumn.
%line
%column
Luego hay que activar la compatibilidad con Java CUP para analizadores sintacticos.
% cup
Generamos un java cup.Symbol para guardar el tipo de token encontrado.
private Symbol symbol(int type) {
return new Symbol(type, yyline, yycolumn);
}
También generamos un Symbol para el tipo de token encontrado junto con su valor.
private Symbol symbol(int type, Object value) {
return new Symbol(type, yyline, yycolumn, value);
}
Las Macro declaraciones Figura 4.
Figura 4: Las Macro declaraciones
Un salto de linea es un n, r.
Salto = r|n|rn
Espacio es un espacio en blanco, tabulador t, salto de linea o avance de pagina f,
normalmente son ignorados.
Espacio = {Salto} | [ tf]
para que reconozca números enteros:
Entero = 0 | [1-9][0-9]*
5

4.3. Reglas léxicas
Esta sección contiene expresiones regulares y acciones. Las acciones son código en
Java Figura 5. que se ejecutara cuando se encuentre una entrada valida para la expresión
regular correspondiente.
Figura 5: Reglas léxicas
YYINITIAL es el estado inicial del analizador léxico al escanear. Las expresiones
regulares solo serán comparadas si se encuentra en ese estado inicial. Es decir, cada vez
que se encuentra una coincidencia el scanner vuelve al estado inicial.
<YYINITIAL> {
/* Regresa que el token FINLINEA declarado en la clase sym fue encontrado.*/
";" { System.out.print(yytext()+" FinLinea "+" ["+yyline+","
+yycolumn+"] n");
return symbol(sym.FINLINEA);}
/*Regresa que el token OP_DIVISION declarado en la clase sym fue encontrado.*/
"/" { System.out.print( yytext()+" dividido "+" ["+yyline+","
+yycolumn+"] n");
return symbol(sym.OP_DIVISION);}
/* Regresa que el token OP_CERO declarado en la clase sym fue encontrado.*/
"0" { System.out.print( yytext()+" cero "+" ["+yyline+","
+yycolumn+"] n");
return symbol(sym.OP_CERO);}
/* Si se encuentra un número, se imprime, se regresa un token numero
que representa un entero y el valor que se obtuvo de la cadena yytext
al convertirla a double. yytext es el token encontrado. */
6

{Entero} { System.out.print(yytext()+" numero "+" ["+yyline+","
+yycolumn+"] n");
return symbol(sym.ENTERO, new Double(yytext())); }
/* Se ignora si se encuentra el espacio en blanco */
{Espacio} { /* Ignora el espacio */ }
}
/* Si el carácter ingresado no coincide con ninguna regla
Entonces se marca un token ilegal */
[ˆ] { System.err.println("El caracter ingresado es
invaido <"+yytext()+">"+"posicion"+"("+yyline+" "+yycolumn+")"); }
5. CUP
Para construir un compilador el segundo paso que debemos dar es el de desarrollar el
analizador sintáctico de nuestro lenguaje.
CUP desarrollada en Java para crear analizadores sintácticos. Genera dos clases en
Java, por default sym y parser, a partir de una especificación en la que se indica una
gramática formal as´ı como también se asocian una serie de acciones a los s´ımbolos apare-
cidos en cada regla gramatical. La clase sym esta constituida por los s´ımbolos terminales
declarados en la gramática,la cual es utilizada para hacer referencia a los mismos.
5.1. Definición de paquete e importación de paquetes necesa-
rios.
En este sección se incluyen las construcciones para indicar que las clases Java generadas
a partir de este archivo pertenecen a un determinado paquete y/o también importar las
clases Java necesarias. Figura 6.
Figura 6: Paquetes e importaciones
package ejemplocup;
import java_cup.runtime.*;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
7

5.2. Código de usuario.
En esta sección se puede incluir código Java del analizador sintáctico que se va a obte-
ner con CUP. En la primera parte tenemos el código para reportar los errores generados
al realizar un dato erróneo figura 7.
Figura 7: Método report error
Luego tenemos el método Main donde se llama al analizador léxico y presenta la
gramática ingresada, también esta el método Divisor que es que realiza la operación que
recibe como entrada dos cantidades y devuelve una cantidad tipo double figura 8.
8

Figura 8: Metodo Main y división
/* Código del parser, se copia ´ıntegramente a la clase final.
Agregamos el manejo de errores, el método de divisor y el main*/
parser code {:
/* Reporte de error encontrado. */
/* Creamos el meto report_error el cual recibe un mensaje y un objeto */
public void report_error(String message, Object info) {
/* Declaramos un StringBufer el cual contendrá el mensaje*/
StringBuilder m = new StringBuilder("Error");
/*Agregamos un if el cual se analiza el objeto recibido instanceof
Sirve para conocer si un objeto de un tipo java_cup.runtime.Symbol*/
if (info instanceof java_cup.runtime.Symbol) {
//imprimimos objeto info para conocer su identificador
System.out.println("INFO ="+info);
/* Declaramos la variable s de tipo java_cup.runtime.Symbol
Donde se almacena el castin del info*/
java_cup.runtime.Symbol s = ((java_cup.runtime.Symbol) info);
/*if nos va a obtener la l´ınea y columna donde se encuentra el symbol*/
if (s.left >= 0) {
//agregamos al mensaje la l´ınea
m.append(" linea "+(s.left+1));
if (s.right >= 0)
//agregamos al mensaje la columna
m.append(", columna "+((s.right+1)-1));
}
/*Este if verifica el identificador es igual a 2 entonces
9

se trata del fin de l´ınea*/
if(s.sym==2){ message="está mal o no existe el fin de l´ınea"; }
/*Este if verifica el identificador es igual a 3
entonces se trata del OP_DIVISION*/
if(s.sym==3){message="tiene q existir numerador";}
entonces se trata del ENTERO*/
if(s.sym==5){message="no puede existir dos numeros
continuos sin el operador";}
entonces se trata del OP_CERO*/
if(s.sym==4){message="El numero para el cual se
divide debe ser mayor a cero ";}
}
//al mensaje le agregamos (:) para una comprensión mejor
m.append(" : "+message);
//imprimimos el error
System.err.println(m);
}
/* Método main para garantizar la ejecución del analizador léxico y
sintáctico, Además que se pase como parámetro la tabla de s´ımbolos
correspondiente. */
public static void main(String[] args){
try {
AnalizadorSintactico asin = new AnalizadorSintactico(
new AnalizadorLexico( new FileReader(args[0])));
Object result = asin.parse().value;
} catch (Exception ex) {
// Imprimimos que existe un error al realizar la ejecución
System.err.println("ERROR EN EL INGRESO DE DATOS");
}
}
/*Realizamos el método divisor que nos devuelve un double al
realizar la Operación y recibe como para metro dos números */
public Double division(Double num1, Double mun2) {
// Variable para almacenar el resultado
Double todo;
//ejecución de la operación
todo= num1/mun2;
// Retornamos el valor de la operación
return todo;
}
:};
10

5.3. Declaración de s´ımbolos terminales y no terminales.
En esta sección se declaran los s´ımbolos terminales y no terminales figura 9. de la
gramática que define el analizador sintáctico que deseamos producir. Tanto los s´ımbolos
no terminales como los s´ımbolos terminales pueden tener asociado un objeto Java de una
cierta clase.
Figura 9: Declaración de terminales y no terminales
/* ---Declaración de s´ımbolos terminales y no terminales--- */
/* Terminales (tokens obtenidos por el analizador lexico).*/
terminal FINLINEA, OP_DIVISION, OP_CERO;
terminal Double ENTERO;
/* No terminales usados en la sección gramatical.e lista los no terminales que tien
un valor Object queNo tienen tipo, pudiendo ser entero o String. */
non terminal Object expr1, expr2;
non terminal Object sentencia;
5.4. Definición del s´ımbolo inicial de la gramática y las reglas
de producción
Las reglas de producción tienen esta sintaxis:
expresion ::= expresion <sımbolo terminal> expresion { : código java: } ;
Se pueden definir todas las reglas de producción que tengan un mismo s´ımbolo no
terminal figure 10. como antecedente separado por el s´ımbolo |.
11

Figura 10: Sección Gramatical
/* ------------------- Seccion de la gramatica ------------------------ */
/* La | sirve para indicar que es una producción u otra. Debemos pasar
de s´ımbolos no terminales a s´ımbolos terminales. Una gramática que no Termina en s´ı
nunca se finaliza Su procesado.*/
expr1 ::= expr1 expr2
|
expr2
;
/* En esta expresión se llama a la expresión sentencia para poder imprimir el Resul
expr2 ::= sentencia:e
{:
System.out.println(" igual "+e);
:}
;
/*Puede ser una expresión que inicia por numero op_divido, de esa forma
se realiza Una división. En RESULT se almacena el valor de las acciones y
se pasa al siguiente nivel de la gramática.
*/
sentencia ::=
12

//sentencia incorrecta de la operación
ENTERO:n OP_DIVISION ENTERO:m
{:
// Código para obtener el objeto info del fin de l´ınea
CUP$AnalizadorSintactico$result = parser.getSymbolFactory().
newSymbol("sentencia",2,((java_cup.runtime.Symbol)
CUP$AnalizadorSintactico$stack.elementAt(CUP$
AnalizadorSintactico$top-2))((java_cup.runtime.Symbol)
CUP$AnalizadorSintactico$stack.peek()), RESULT);
// Llamamos al método report_error y enviamos el
//mensaje y el objeto tipo info
parser.report_error("Falta fin", CUP$AnalizadorSintactico$result);
:}
// o podemos tener la sentencia correcta
|
ENTERO:n OP_DIVISION ENTERO:m FINLINEA
{:
//El RESULT almacena el resultado de haber llamado el método división
RESULT=parser.division(n.doubleValue(), m.doubleValue());
:} ;
6. Sym
En esta clase java se generan los Tokens declarados y utilizados en la sección sintáctica
figura 11.
Figura 11: Codigo java de la clase sym
package ejemplocup; /** CUP generated class containing symbol constants. */
public class sym { /* terminals */
public static final int OP_CERO = 4;
public static final int FINLINEA = 2;
13

public static final int error = 1;
public static final int OP_DIVISION = 3;
public static final int EOF = 0;
public static final int ENTERO = 5;}
7. Control de errores
En la sección de errores podemos observar que el control se realiza en la parte de el
analizador sintáctico en el método de report error figura 12.
Figura 12: Errores sintácticos
Y la parte de control de caracteres se realiza en la sección léxica Figura 13.
Figura 13: Errores léxicos
14

8. Funcionamiento del compilador
Lo que primero hacemos es escoger la opción 1 Figura 14. Generar del menú en la cual
se generan la clase sym, AnalizadorLexico y AnalizadorSintactico en código java.
Figura 14: Genración de clase sym, AnalizadorLexico y AnalizadorSintactico
Luego realizamos el ingreso de caracteres validos y escogemos la opción 2 del menú para
la ejecución de los datos ingresados. Ingresamos: 43/9; Figura 15.
Figura 15: Ejecución correcta
15

9. Ejecuci´on de Errores
Ahora vamos a presentar el control de algunos errores al ingresar datos errores como
entrada.
1. Cuando falta ﬁn de linea ”43/9”. Figura 16.
Figura 16: Falta Fin de linea
2. Cuando se ingresa dos cantidades seguidas y sin operador ”4 3 / 9;”. Figura 17.
Figura 17: Sin operador
16

3. Cuando dividimos para cero ”43 /0;”Figura 18.
Figura 18: Denominador cero
4. Cuando no existe denominar el error interpreta como ﬁn de linea al s´ımbolo del
divisor ”43 /;”Figura 19.
Figura 19: Sin denominador
17

5. Cuando no existe numerador /9;”Figura 20.
Figura 20: Sin numerador
6. Cuando se ingresa mal un car´acter ”43/hola;”Figura 21.
Figura 21: Caracteres inv´alidos
18

10. Conclusiones
Con la construcción del compilador se pudo ampliar el conocimiento y elaboración
de copiladores, dejando atrás los t´ıpicos ejemplos y centrándonos en colaborar para
ampliar el estudio de esta materia.
El código Jflex es la parte léxica de un compilador donde se realizan las macro
declaraciones y los métodos que guardan los Tokens también esta la parte de reglas
léxicas que es donde se buscan las coincidencias de los datos ingresado.
La realización del autómata sera la gu´ıa para realizar la parte gramatical del código
Cup.
11. Recomendaciones
Al momento de Realizar la parte léxica declara de % line % column para poder
activar el contador de lineas y columnas para facilitar el reporte de errores.
Las expresiones regulares y acciones de código Jflex deben ser realizadas con pre-
caución pues es la parte en que el scanner encontrara las coincidencias.
En el código Cup realizar el control de errores para el correcto funcionamiento del
compilador.
19

12. Referencia del c´odigo fuente
La c´odigo de este compilador se lo puede encontrar en: https://code.google.com/
p/compiladoresdivisor/source/browse/trunk/EjemploCUP.zip
20

13. Bibliográfica
Referencias
[1] Antonio De Miguel Vicenti.2007 Çompilador de Pascal”. Disponible en:
http%3A%2F%2Fplg07082.googlecode.com%2Fsvn%2Ftrunk%2FDocumentaci%
25C3%25B3n%2FDOCUMENTACION%2520ENTREGA%2520FINAL%2FDOCUMENTACION%
2FANALISIS%2520LEXICO%2FDocumentacion%2520Analizador%2520Lexico.
pdf&ei=0gOOVNemE43asASVqYL4Bw&usg=AFQjCNEAOrPRo7wH_L7KLJ4bvbjCwvKzlQ
[2] Carlos III de Madrid, Departamento de ingenier´ıa telematoca, ” Fundamentos de
Ordenadores I: Breve Introducción a CUP” Disponible en: http://www.it.uc3m.
es/luis/fo1/p/CUP.html
[3] Compiladores: principios, técnicas y herramientas. A.V. Aho, R. Sethi, J.D. Ull-
man. Addison-Wesley Iberoamerica. 1990. Disponible en: http://loscompiladores.
wordpress.com/category/analizador-sintactico/
[4] Enrique Arangurenn. .A
nalizador Sintáctico”, 2011. Disponible en: http://
loscompiladores.wordpress.com/category/analizador-sintactico/
[5] Open(fecks();). .Estructura Archivo JFLex”. Disponible en: http://openfecks.
wordpress.com/jFlex-y-cup/plantilla-archivo-jFlex/
[6] Salvador Sanchez, Daniel Rodrıguez, Departamento de Ciencias de Universidad
de Alcala, ”Procesadores de Lenguaje” Disponible en:http://www.cc.uah.es/ie/
docencia/ProcesadoresDeLenguaje/CUP.pdf
21

Informe compilador divisor

Más contenido relacionado

La actualidad más candente (20)

Similar a Informe compilador divisor (20)

Último (20)

Informe compilador divisor