Universidad Nacional de Piura

Facultad De Ingeniera Industrial

Escuela Profesional de Ingeniera Informtica

Desarrollo de un compilador

Trabajo realizado en la Asignatura de Teora de

Compiladores.
Docente
: Luis Caldern Pinedo
Integrantes : Odar Bentez Josu

Zeta Chira Miguel

Domnguez castillo Victor
Rivas condolo josue

Desarrollo
de un
compilador
de una

calculadora
basica

PRESENTACIN
En el presente documento se explicara que es un compilador y la manera de usar el
compilador que fue hecho por Estudiantes como proyecto, de la especialidad de
INFORMATICA para la asignatura de: Teora de Compiladores, adems del
funcionamiento.

El desarrollo de este se basara en utilizar operadores bsicos

I.

MARCO
TEORC
O
Compilador

Es aquel traductor que tiene como entrada una sentencia en lenguaje formal y como
salida tiene un fichero ejecutable, es decir, realiza una traduccin de un cdigo de alto
nivel a cdigo mquina (tambin se entiende por compilador aquel programa que
proporciona un fichero objeto en lugar del ejecutable final)

Compilador de UNA CALCULADORA BSICA

Nuestro Compilador se encarga de ingresar nmeros enteros con operadores bsicos
para crear una calculadora bsica.

Estructura del COMPILADOR

ANALISIS LEXICO
Se encarga de buscar los componentes lxicos o palabras que componen el programa
fuente segn la tabla de smbolos declarado.

Lexemas: secuencia de caracteres en el programa fuente.

Tokens: smbolo abstracto que representa un tipo de unidad lxica; por ejemplo,
una palabra clave especfica o una secuencia de caracteres de entrada que
denotan un identificador.

Tabla de Smbolos
Tabla de smbolos es una estructura de datos que posee informacin sobre los
identificadores definidos por el usuario, ya sean constantes, variables, tipos u otros.
Tabla de smbolos es una estructura de datos que usa el proceso de traduccin de un
lenguaje de programacin, por un compilador o un intrprete, donde cada smbolo en el
cdigo fuente de un programa est asociado con informacin tal como la ubicacin, el
tipo de datos y el mbito de cada variable, constante o procedimiento.
Expresiones Regulares
Son normas que definen el conjunto de posibles secuencias de caracteres que se utilizan
para formar lexemas.
Letra

A|B|C|D||Z |a|b|c|d||z |

Digito

0|1|2|3|4|5|6|7|8|9

Identificador letra (letra | digito) *

TABLA DE SIMBOLOS

+
*
/
(
)

suma
resta
multiplicacin
divisin
Abre Parntesis
Cierra Parntesis

Fase de anlisis sintctico

Trabaja con una gramtica de contexto libre y genera el rbol
sintctico que reconoce su sentencia de entrada. En nuestro caso las categoras

gramaticales del anlisis lxico son los terminales de la gramtica. Para el ejemplo que
nos ocupa podemos partir de la gramtica:

rbol
De manera que el anlisis sintctico intenta generar un rbol sintctico que encaje con la
sentencia de entrada. Para nuestro ejemplo, dicho rbol sintctico existe y es el de la
figura El rbol puede representarse tal y como aparece en esta figura, o bien invertido.
Un rbol es una coleccin de elementos llamados nodos, uno de los cuales se distingue
como raz, junto con una relacin (de paternidad) que impone una estructura jerrquica
sobre los nodos. Un nodo como un elemento de una lista se puede representar por
cualquier tipo. Regularmente se representa como un nodo por medio de una letra, una
cadena de caracteres o dgitos

es aqul mecanismo de compilacin en el que el control lo lleva el analizador sintctico,

y todas las dems fases estn sometidas a l.

ANLISIS SEMNTICO

Esta fase revisa el rbol sintctico junto con los atributos y la tabla de
smbolos para tratar de encontrar errores semnticos. Para todo esto se
analizan los operadores y operando de expresiones y proposiciones.
Finalmente rene la informacin necesaria sobre los tipos de datos para la
fase posterior de generacin de cdigo.

En compiladores de un solo paso, las llamadas a las rutinas semnticas se realizan

directamente desde el analizador sintctico y son dichas rutinas las que llaman al
generador de cdigo. El instrumento ms utilizado para conseguirlo es la gramtica de
atributos.
En compiladores de dos o ms pasos, el anlisis semntico se realiza
independientemente de la generacin de cdigo, pasndose informacin a travs de un
archivo intermedio, que normalmente contiene informacin sobre el rbol sintctico en
forma lineal (para facilitar su manejo y hacer posible su almacenamiento en memoria
auxiliar).

Etapa de sntesis
En la etapa anterior se ha controlado que el programa de entrada es correcto. Por tanto,
el compilador ya se encuentra en disposicin de generar el cdigo mquina equivalente
semnticamente al programa fuente. Para ello se parte de las estructuras generadas en
dicha etapa anterior: rbol sintctico y tabla de smbolos.
Generacin De Cdigo Intermedio
Despus de la etapa de anlisis, se suele generar una representacin intermedia explcita
del programa fuente. Dicha representacin intermedia se puede considerar como un
programa para una mquina abstracta.

Operadores
En el pseudocdigo se mantiene la precedencia de operadores, lo cual significa que los
operadores con mayor precedencia se ejecutan antes que aquellos de menor precedencia
siempre y cuando no haya parntesis. A continuacin se muestran los operadores que se
utilizan en el pseudocdigo:
Operadores
Procedencia
Multiplicativos
* , /
Aditivos
+,Igualdad
==, !=
And lgico
.y.
Or Lgico
.o.
Asignacin
=
Relacionales
>, >=, <, <=
Operadores del pseudocdigo

Comentarios
Para esto se usara lo siguiente:
// : Comentario de una sola lnea
/* */ : Comentario de varias lneas.

Bloques de cdigo
La ejecucin de sentencias siempre se da de forma secuencial ejecutando instruccin
por instruccin. Un bloque de cdigo es aquel conjunto de sentencias que se encuentran
delimitadas por las palabras reservadas inicio y fin.
La utilizacin de estos delimitadores de bloques es de gran importancia dentro de las
estructuras de control (las cuales se detallan ms adelante), debido a que indican y
delimitan el conjunto de lneas de cdigo que pertenecen a cada uno de los bloques de
ejecucin de las sentencias de control.

GRAMTICA
Las fases del traductor, una vez que se reconoce si una cadena pertenece al lenguaje
definido, posteriormente se tiene que analizar la lnea de cdigo que representa desde el
primer smbolo encontrado hasta el retorno de lnea.

smbolos terminales generales

Terminales que no tienen un valor son listados primero, los terminales

que
tienen un valor como los enteros son listados en la segunda o
demas lineas. */
terminal
PARENDER;

SEMI, OP_SUMA, OP_RESTA, OP_MULT, PARENIZQ,

terminal Integer ENTERO;

SIMBOLOS NO TERMINALES
Primero se lista los no terminales que tienen un valor Object y
despues
se lista los no terminales que tienen un entero. Un Object se refiere
a que
no tienen tipo, pudiendo ser entero o String. */
non terminal Object

expr_list, expr_part;

non terminal Integer

expr, factor, termino;

Creador de Analizadores Lxicos JFLEX

JFLEX: Es un generador de analizadores lexicogrficos, como extensin a la
herramienta JLex est desarrollado en Java y genera cdigo Java.
Los programas escritos para JFlex tienen un formato parecido a los escritos en PCLex;
de hecho todos los patrones regulares admisibles en Lex tambin son admitidos por
JFlex,

CODIGO EN JAVA DE LA CALCULADORA BASICA

/*
* To change this license header, choose License Headers in Project
Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package ejemplocup;

import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
* @author arturo
*/
public class EjemploCUP {

public final static int GENERAR = 1;

public final static int EJECUTAR = 2;
public final static int SALIR = 3;

/**
* Es un menu para elegir entre generar el analizador lexico y sintactico, o
* ejecutarlos sobre un archivo de pruebas.
*
* @param args the command line arguments
*/
public static void main(String[] args) {
java.util.Scanner in = new Scanner(System.in);
int valor = 0;
do {
System.out.println("Elija una opcion: ");
System.out.println("1) Generar");
System.out.println("2) Ejecutar");
System.out.println("3) Salir");
System.out.print("Opcion: ");
valor = in.nextInt();

switch (valor) {
/* Generamos el analizador lexico y sintactico.
lcalc.flex contiene la definicion del analizador lexico
ycalc.cup contiene la definicion del analizador sintactico
*/
case GENERAR: {
System.out.println("\n*** Generando ***\n");
String archLexico = "";
String archSintactico = "";
if (args.length > 0) {
System.out.println("\n*** Procesando archivos custom
***\n");
archLexico = args[0];
archSintactico = args[1];
} else {
System.out.println("\n*** Procesando archivo default ***\n");
archLexico = "alexico.flex";
archSintactico = "asintactico.cup";
}
String[] alexico = {archLexico};
String[] asintactico = {"-parser", "AnalizadorSintactico",
archSintactico};
jflex.Main.main(alexico);
try {
java_cup.Main.main(asintactico);
} catch (Exception ex) {
Logger.getLogger(EjemploCUP.class.getName()).log(Level.SEVERE, null, ex);
}
//movemos los archivos generados
boolean mvAL = moverArch("AnalizadorLexico.java");
boolean mvAS = moverArch("AnalizadorSintactico.java");
boolean mvSym= moverArch("sym.java");

if(mvAL && mvAS && mvSym){

System.exit(0);
}
System.out.println("Generado!");
break;
}
case EJECUTAR: {
/* Ejecutamos el analizador lexico y sintactico
sobre un archivo de pruebas.
*/
String[] archivoPrueba = {"test.txt"};
AnalizadorSintactico.main(archivoPrueba);
System.out.println("Ejecutado!");
break;
}
case SALIR: {
System.out.println("Adios!");
break;
}
default: {
System.out.println("Opcion no valida!");
break;
}
}
} while (valor != 3);

public static boolean moverArch(String archNombre) {

boolean efectuado = false;
File arch = new File(archNombre);
if (arch.exists()) {

System.out.println("\n*** Moviendo " + arch + " \n***");

Path currentRelativePath = Paths.get("");
String nuevoDir = currentRelativePath.toAbsolutePath().toString()
+ File.separator + "src" + File.separator
+ "ejemplocup" + File.separator + arch.getName();
File archViejo = new File(nuevoDir);
archViejo.delete();
if (arch.renameTo(new File(nuevoDir))) {
System.out.println("\n*** Generado " + archNombre + "***\n");
efectuado = true;
} else {
System.out.println("\n*** No movido " + archNombre + " ***\n");
}

} else {
System.out.println("\n*** Codigo no existente ***\n");
}
return efectuado;
}
}