A unas pocas horas de la entrega de la primera fase...

Hola estimados amigos,

Ya casi en la culminación del curso de Compiladores I, les quiero expresar mi satisfacción de haber realizado un buen trabajo en el mismo. En lo personal pienso que puedo dar más aún, algo que intentaré efectuar en la segunda fase de esta interesante asignatura.

El proyecto ya esta casi listo, por ahí nos faltan unos detalles en relación al lexer, los cuales los esperamos dejar terminados de aquí al martes 21, día de entrega del proyecto. Asimismo dicho día, estaremos realizando el tercer y último examen parcial concerniente a este trimestre, el cual con la ayuda de nuestro Señor Jesucristo, tenemos la fe que haremos un buen trabajo.

Recuerdan que en el blog pasado les comente acerca de la manera poco ortodoxa que adopte para resolver el conflicto shift-reduce, relacionado a las producciones que se utilizaban para declarar variables y funciones. Pues desde luego, esa forma no era la correcta, por lo que procedimos a buscar una mejor manera de realizar este trabajo. Lo que hicimos, gracias al consejo de nuestro buen compañero José Palma, fue dejar un mismo tipo de dato tanto para la declaración de variables como para la declaración y definición de funciones. Lógicamente ‘void’ no es un tipo de declaración de variables permisible en micro-C, por lo que en caso de que el usuario quiera utilizar una variable de este tipo, inmediatamente se le enviaría el warning correspondiente. De esta forma el conflicto quedo solucionado, a Dios gracias.

Además, en otro par de cosas, no sabíamos en qué parte del código el parser validaría si el código tenia o no una función main definida. De acá, la decisión trascendental para realizar esa validación, lógicamente fue al momento en que el parser terminará su trabajo, ya que hasta ese instante nos damos cuenta si el usuario definió o no una función main sin parámetros.

Ahora solo resta por nuestra parte, esperar el día de entrega del proyecto y les contaré posteriormente la suerte con la que corrimos en la revisión del mismo.

¡Pasen un buen día!

Perfeccionando la primera entrega...

Hola que tal queridos amigos,

Es un placer como siempre, estar por acá, para charlar un rato acerca del proyecto de Compiladores I.
Como han de suponer, esta semana ha sido de mucho trabajo, particularmente en CUP. Pero gracias a Dios y a la potencia que nos brinda el IDE, Netbeans 5.0, esta tarea se nos ha facilitado enormemente.
El primer gran obstáculo al que nos enfrentamos, ya desde hace varias semanas, pero lógicamente con mas intensidad durante ésta, fueron los conflictos shift-reduce y reduce-reduce encontrados en la gramática de micro-C.
En cuanto al conflicto del “else” ambiguo, CUP lo resolvió a favor del shift en relación al “else”, por lo que aquí no hubo mayor problema.
En donde si nos encontramos con un problema un poco grande, fue en las sentencias destinadas a la declaración de variables y funciones. A continuación les mostramos las producciones correspondientes a esas sentencias:
function_def_header --> return_type identifier “(“ parameters_def “)”
function_declaration --> return_type identifier “(“ parameters_decl “)” “;”
variable_declaration --> type identifier_list “;”
return_type --> type “void”
identifier_list --> identifier identifier_list “,” identifier

Las producciones anteriores provocaban que el parser se confundiera al validar si lo que él veía en determinado momento era, ó la declaración de una variable ó la declaración o definición de una función. Por lo que, en sentencias como la definición del main, el parser creía que era la declaración de una variable, y cuando el lexer le devolvía el token “(“, mostraba un error.
Yo me imagino que esto se producía, ya que el parser, como es un analizador sintáctico de gramáticas “botton-up”, él comienza a ver los prefijos viables y como ustedes pueden apreciar existen varios prefijos viables que conducen a diferentes caminos. Pero como les digo, es una opinión muy particular.

La única solución que pudimos encontrar para acabar con este conflicto fue, redefiniendo la gramática que recién les mostramos. No sabemos si la decisión tomada fue correcta o no, pero de no haberlo hecho, creo que todavía estuviéramos tratando de arreglar esta gramática y no hubieramos avanzado en el resto del proyecto. La solución tomada fue, que el tipo de datos de retorno para las funciones, utilizado durante la declaración y la definición de éstas, fuera “INT”, “CHAR” y “void”. Y el tipo de datos para la declaración de variables se quedo tal y como estaba con “char”, “int”.

Si usted amigo lector, tiene la solución a los conflictos antes mencionados sin echar mano a las modificaciones que realice, agradecería que lo hicieran de nuestro conocimiento, sin duda les estaremos muy agradecidos.

Luego de solucionados los conflictos en la gramática, comprender la forma en que realizaba su labor el parser, no fue tarea fácil. A pesar de que ya habíamos estudiado en el curso un poco de teoría acerca de los analizadores LALR, la comprensión del parser no fue nada fácil. Para poder llegar a entender bien, la forma en que funciona el parser, tuvimos que hacer uso del buen debugger que posee Netbeans, al ejecutar nuestro analizador sintáctico sobre un texto de código de micro-C. Una vez asimilado lo anterior, la tarea correspondiente a los ítems a presentar durante esta primera entrega, fue muchísimo mas tranquila.

Muchísimo mas tranquila dentro de lo que cabe, ya que todavía no hemos finalizado; pero el panorama luce más despejado definitivamente.
Entre los ítems que nos faltan, están:
La validación de que todo programa escrito en micro-C, debe poseer una función main. El problema radica, en que, no encontramos en qué parte del código tenemos que hacer esta validación, si al final de la compilación o en el transcurso de la misma. Miramos más viable, la primera opción, ya que no podemos mostrar el mensaje de error sin haber terminado de analizar la totalidad del código fuente. Pero seguiremos pensando en la forma en que lo vamos a hacer.

Bueno, y acá finalizamos por los momentos. Pero estaremos por estos rumbos próximamente.

Que tengan un buen día!

Muy buenas tardes,

Como siempre, es un placer saludarles a todos ustedes, nuevamente con las pilas bien puestas para comentarles de nuestros últimos avances en la construcción de Micro-C.

Esta ha sido una semana dedicada un tanto a la parte grafica del compilador, y otro tanto a la gramática del mismo.
Ha sido difícil, sin duda comprender la forma en que trabaja CUP, hemos estado leyendo y leyendo el libro Traductores y Compiladores, en el cual se encuentran muy buenos ejemplos del uso de JFlex y CUP, pero aún no asimilamos muy bien algunos conceptos.

A su vez, hemos tenido muchos problemas con la gramática, ya que CUP nos dice que nuestra gramática tiene algunos conflictos tanto reduce-reduce como shift-reduce, por lo que, tenemos problemas para generar el archivo parser.java. La gramática se ha copiado tal y como está en la especificación del proyecto, y sin embargo CUP no, nos la acepta. Es decir, esto nos tiene un poco incómodos porque no hemos podido avanzar como se tenia planificado, por lo que, nos hemos concentrado en otras áreas como: un poco de trabajo en la parte gráfica, y otro poco en refinar el lexer que todavía no nos convence del todo.

Pero a una semana de la fecha de entrega del proyecto, esto va a ser bastante difícil, pero no imposible. Dios mediante, todo nos salga bien.

He platicado con muchas personas que han cursado este curso en otras ocasiones, y me han compartido que, las dos ultimas semanas previas a la entrega del proyecto es donde se esfuerzan más programando, ya que hasta ese momento es que logran asimilar, talvez no la totalidad, pero si un buen porcentaje de cómo realizar el proyecto. Creo que en esta etapa nos encontramos nosotros, por lo que esta semana será, como dicen trascendental, para salir avante con micro-C.

Por lo momentos es todo, y espero verlos pronto por acá.