Hola queridos amigos,

En esta ocasión les vamos a conversar un poco acerca de nuestra experiencia vivida realizando este primer laboratorio del curso de Compiladores I, el cual lleva por nombre “Introducción a JFlex y Cup”. El mismo, como lo describe su titulo nos ayudara a relacionarnos mejor con estas dos herramientas que son muy importantes en las dos primeras fases de un compilador, estamos hablando de JFlex y Cup.

Para comenzar este laboratorio, lo hicimos creando la carpeta “C:\COMPILER_HOME”, en la cual creamos la siguiente ruta “src\minimal”, en esta ubicación íbamos a alojar los archivos correspondientes a la práctica que estábamos realizando. Luego procedimos a descargar el archivo “Examples jflex-cup”, desde la siguiente dirección Web: http://www2.cs.tum.edu/projects/cup, el cual era un documento de texto el cual tenía una especie de división para los archivos minimal.lex, minimal.cup y el readme.
En este paso hubo un poco de confusión al momento de colocarle las extensiones correctas a los diferentes archivos, ya que el .lex se guardó como .cup y viceversa, y al momento de realizar los pasos subsiguientes lógicamente las operaciones no nos proporcionaban los resultados esperados, luego este impase se solucionó satisfactoriamente.

Después, procedimos a descomprimir el archivo jflex-cup.zip el cual venia en el CD proporcionado al inicio del curso, esto se realizó en la carpeta “C:\COMPILER_HOME”.
Posteriormente nos dirigimos a editar los archivos “C:\COMPILER_HOME\start_compiladores.bat” y “C:\COMPILER_HOME\JFlex\bin\jflex.bat” en los cuales realizamos las siguientes ediciones:
En el archivo start_compiladores.bat establecimos las siguientes variables a los siguientes valores:
JFLEX_CUP_HOME=”C:\COMPILER_HOME”
JAVA_HOME=”C:\j2sdk1.4.2_08\bin”

Luego en el archivo “jflex.bat” establecimos la variable de ambiente JFLEX_HOME a la cadena “C:\COMPILER_HOME\JFlex” y la variable JAVA_HOME a la cadena "C:\j2sdk1.4.2_08", esto con el fin, de que al momento de ejecutar estos archivos .bat desde la línea de comandos pudiéramos cargar las variables anteriormente citadas a la sesión actual del usuario dentro del cmd.

Después, para todos los archivos .java ubicados en las siguientes dos rutas: “C:\COMPILER_HOME\Java_cup\java_cup\” y “C:\COMPILER_HOME\Java_cup\java_cup\runtime\” se generaron sus respectivos archivos .class, haciendo uso de la orden javac.

De ahí, desde la ubicación “C:\COMPILER_HOME\src\minimal” ejecutamos el JFlex para generar el archivo Yylex.java, a partir del archivo minimal.lex, en este archivo se encontraban las distintas expresiones regulares que nos ayudaron a detectar posibles errores léxicos en el ejercicio que realizamos. Lo anterior era para generar en otras palabras el analizador léxico, después procedimos a generar el analizador sintáctico mediante la siguiente orden: “java java_cup.Main minimal.cup”, donde a partir del archivo “minimal.cup” y con la ayuda del archivo Main, generamos dicho analizador, el cual entre otras funciones verificaba que el orden de las palabras de nuestra gramática fuera la correcta. Este paso generó dos archivos: “parser.java” y “sym.java”.

El siguiente paso fue, realizar la compilación de estos 3 archivos generados en los pasos recién citados, lo cual creó una carpeta llamada Example, la misma que simboliza el paquete que utilizaran estos tres archivos creados, para realizar su trabajo, dentro de la misma carpeta se generaron unos archivos .class producto del proceso de compilación.

Ya hasta este punto solo faltaba ejecutar el archivo parser, ubicado en la carpeta Example; pero resulta que el comando proporcionado en la guía no funcionaba, por lo que esto significó el principal atraso y problema encontrado en el desarrollo de esta practica de laboratorio.

Dicho comando era el siguiente: “java -classpath .:$CLASSPATH Example.parser”. Después de analizar bien la orden, al parecer ésta ejecuta el archivo parser.class que se encuentra dentro del paquete Example, que al fin y al cabo es una carpeta. Pero debido al uso de la opción –classpath, Java iba a buscar el archivo parser a la siguiente ruta: C:\COMPILER_HOME\Java_cup ya que éste era el valor que tenía la variable de ambiente CLASSPATH, pero en dicho camino no se encontraba ubicada la carpeta Example, sino que ésta estaba en la siguiente dirección: “C:\COMPILER_HOME\src\minimal\”, por lo que se optó por usar la orden siguiente: java Example.parser, y finalmente funcionó.

En los cambios que se solicitaron hacer en este laboratorio, estaban la modificación del archivo minimal.lex con el objetivo de que solamente acepte números menores a 64.
Originalmente el archivo aceptaba cualquier tipo números, positivos por supuesto; Para hacer lo que se solicitaba, procedimos a editar el archivo minimal.lex, en la sección que corresponde a la declaración de las reglas léxicas.
Las líneas de código que se agregaron fueron las siguientes:

[0-9][0-5][0-9][6][0-3](-)[0-9]+ { return new Symbol(sym.NUMBER, new Integer(yytext())); }
[6][4-9][7-9][0-9][1-9][0-9][0-9]+ { System.err.println("Numero fuera de rango(0-63): "+yytext()); }

En la primera línea, podemos ver una expresión regular que solo acepta números menores a 64, inclusive hasta números negativos que antes no se permitía, y en la siguiente línea miramos otra expresión regular que engloba todos los números mayores o iguales a 64, en donde se enviaría un mensaje al usuario indicando que el número no está en el rango correcto.
En esta parte se tuvo que pensar con un poco de detención en la expresión regular, la cual se mira bastante fácil, pero la elaboración de la misma nos llevó un poco de tiempo. Y también nos llevó otro tanto de tiempo entender cómo es que trabajaba jflex con respecto a la validación de la sintaxis.

El segundo inciso que se nos solicito modificar, fue cambiar el carácter terminal de “;” por la tecla Enter, cuyo carácter es “\r”. Este cambio fue un poco más fácil porque ya conocíamos mejor al archivo minimal.lex. La línea que se modificó fue también en la sección de las reglas léxicas que mencionamos anteriormente, y ésta fue :

“;" { return new Symbol(sym.SEMI); }

Y después de la modificación quedó de la siguiente manera:
"\r" { return new Symbol(sym.SEMI); }

Y esta última parte fue la culminación de la practica de laboratorio que nos llevo por lo menos dos días, aunque el mismo estaba pactado para una hora. Pero nos llevamos esa cantidad de tiempo debido a que no conocíamos muy bien tanto las herramientas JFlex como Cup.

A continuación se adjuntan algunas imágenes para ilustrar la práctica realizada.

Aquí se puede apreciar el error que ocurría cuando se ejecutaba el archivo parser.class ubicado en la carpeta Example, que posteriormente fue solucionado.

A continuación les mostramos dos imagenes en dónde podemos observar el resultado de los cambios realizados al analizador léxico, y el uso de la tecla ENTER, en lugar del ";" para indicar el final de línea.

En la primera imágen se observa que al realizar la operación 3*64, el analizador léxico nos muestra un error que nos indica que el número 64 no es un número válido, ya que los números válidos solo son los menores a 64.

En la segunda imágen, apreciamos que ahora ya no utilizamos el caractér ";" para indicar la resolución de una operación, simplemente basta con presionar la tecla ENTER para lograrlo.

Una semana de reconocimiento y análisis

Muy buenas tardes estimados amigos,

Ya entrando un poco en calor en la construcción del compilador para micro-C, podemos decir que durante toda esta semana que esta culminando este día se ha realizado una labor de reconocimiento y análisis de este bonito proyecto de la clase de Compiladores I, y que lógicamente será culminado en la clase de Compiladores II, si Dios así nos lo permite.

Como todos los inicios en la elaboración de cualquier proyecto, las cosas no son tan fáciles como uno quisiera, ya que en nuestro caso particular, las herramientas que vamos a utilizar no las conocemos en lo absoluto, claro, estamos hablando de Eclipse, Jflex y Cup.
Anteriormente habíamos trabajado con el poderoso IDE Netbeans y con JCreator, pero esperamos que Eclipse no sea tan diferente a los anteriores, y nuestro periodo de adaptación no sea tan extenso.

Lo primero que hicimos fue instalar la Virtual Machine(VM) para Java versión 1.4.2_08 junto con Eclipse, en nuestra PC teníamos una versión mas actual de esta VM pero para evitar problemas de compatibilidad y otras cosas mas, optamos por instalar la versión proporcionada por el catedrático de la asignatura. Posteriormente descomprimimos el IDE Eclipse, ya que éste no posee un instalador para realizar su respectiva instalación, es decir, como que ya viene instalado.
Luego procedimos de manera similar con JFlex y Cup, el primero, que nos servirá para generar código Java que nos ayudara a realizar el análisis léxico del código fuente de micro-C, y el segundo que será usado durante la etapa del análisis Sintáctico, especialmente en el manejo de los AST(Abstract Syntax Tree), hasta el momento no conocemos mucho al respecto, por lo que no seria prudente ahondar mucho en el tema.

Por otra parte, hemos experimentado algunos problemas, principalmente en el uso de la herramienta JFlex, la cual aun no podemos utilizarla ya que tenemos algunos inconvenientes al ejecutarla desde la línea de comandos. Por lo que investigaremos más al respecto.

En cuanto a las fuentes de información que hemos utilizado, se encuentran el libro “Traductores y Compiladores en Java” en su versión PDF, y el manual que viene junto al JFlex, el cual aun no le hemos podido sacar el máximo provecho ya que lastimosamente la herramienta no la hemos podido ejecutar aún.

Para compartirles un poco mas sobre el error que me ocurre al ejecutar JFlex, les diré que cuando digito lo siguiente en la línea de comandos: “jflex standalone.flex” se me presenta el siguiente error el cual cito textualmente a continuación: “Unable to access jarfile \lib\JFlex.jar”, la verdad no sé si el problema es que el .jar esta mal generado, lo cual no creo ya que este .jar es el que venia en el CD que se nos proporcionó en clase. O por otro parte, si he cometido algún error en la edición del archivo JFlex.bat que esta localizado en la carpeta /bin de JFlex, cuyos pasos para realizar la edición del mismo se encuentran en el manual de JFlex. Si alguien sabe de esto les agradecería su colaboración.

Y para finalizar, esperamos que esta semana próxima, podamos avanzar mas en el proyecto, ya que considero que estamos muy atrasados.

Hasta luego, que tengan una buena semana!

¿Qué espero del curso de Compiladores I y II?

En relación al curso de Compiladores I y II, las expectativas son grandes, ya que resulta interesante conocer cómo es la forma en que se traducen las instrucciones de un lenguaje de programación cualquiera a un código que pueda ser ejecutado por la computadora, muchas veces conocido como “código de máquina”. Además, en lo personal, es una de las últimas clases que cursaré previo a la culminación de mi carrera, y en dónde tendré que aplicar muchos de los conocimientos adquiridos en clases anteriores. Por lo que esto le da un toque especial a este curso.
Respecto a nuestro catedrático, todos sabemos que es una persona muy capaz, y trataremos de aprovechar al máximo su experiencia en pro de nuestra formación académica y profesional.

¿Por qué se enseña Compiladores en las carreras de Ciencias de la Computación?

Aunque la mayoría de los profesionales de la informática, quizá nunca harán en su vida un compilador, es muy importante que conozcan un poco acerca de ellos. Conocer la forma en que se construye un compilador le será de mucha utilidad al momento en que este profesional de la informática tenga que elegir una herramienta de desarrollo o lenguaje de programación para realizar un determinado proyecto, sin lugar a dudas, esto le ayudará a tomar una decisión mas concienzuda al respecto.

También, como dijimos recien, muchos de los conceptos aprendidos en las carreras de Ciencias de la Computacion son de mucha utilidad en la construcción de compiladores, por lo que la enseñanza de este tipo de programas es muy importante para poner en práctica todo lo aprendido en cursos anteriores.