Monday, May 22, 2006

Culminando Analisis Semantico

En esta ocasion hablare sobre el avance que he tenido en el análisis semantico que incluye el chequeo de espresiones de tipos en asignaciones, sumas, restas, comparaciones etc.
Tambien el chequeo de numero y tipo de los parametros de una funcion cuando esta es llamada, ademas del chequeo de los returns, break y continue.

Para esta parte me auxilie bastante de la tarea realizada en minimal.cup en la que propagabamos
las expresiones y generamos el codigo MIPS.
En nuestro caso empecé a propagar desde factor que es la produccion como más basica tuplas Variables conteniendo el valor de la expresion y el tipo. Con esta tecnica empecé a verificar los tipos a la hora de realizar sumas por ejemplo, verificando que los tipos de cada una de las expresiones sea iguales y a la vez de tipo int, ya que de tipo char no es permitido.

El chequeo de tipos en expresiones, el chequeo de numero y tipos de parametros en llamadas a funciones ya lo tengo culminado solo me faltaria la verificacion del tipo de retorno y validar que un break y un continue este solo dentro de una estructura while.

Creo que voy un poco atrazado con respecto al tiempo de entrega de l proyecto ya que se esta acercando, espero que nos pueda dar el ingeniero una prorroguita :)

Monday, May 15, 2006

Tarea SSA form

Pues SSA form optimiza el código intermedio generado por la gramatica de un lenguaje especifico, en nuestro caso el Micro-C usando cada variable dentro del programa una unica vez.
Esto lo hace dividiendo la variable en distintas versiones, es decir colocando subindices dependiendo del número de veces que se usa dicha variable dentro del codigo fuente del programa.

Por ejemplo:
En este caso lavariable V fue renombrada a V1 y V2 permitiendo hacer uso de estas variables una sola vez en cada asignacion.

Para nuestro proyecto podriamos utilizar esta representacion de la siguiente forma:
Si tuvieramos el siguiente segmento de codigo:

a=50;
b=1;
h=0;

if(a>b)
h=h+1;
else
h=h*2;

print(h);

La Representacion en SSA Form es la siguiente:

a0=50;
b0=1;
h0=0;

if(a0>b0) goto verdadero
h1=h0*2
verdadero: h2=h0+1;

print(Φ(h2,h1));

En este segmento primeramente se renombran las variables a, b y h para utlizarlas exactamente una sola vez en cada uso, despues al evaluar el if la variable h puede tomar dos posibles los cuales no sabemos. Para saberlo utilizamos la funcion Φ que nos trae el valor de h
que fue utilizado anteriormente.
Esta tecnica de optimizacion para codigo intermedio nos permite hacer mas eficiente y optimizado el codigo intermedio que posteriormente sera traducido a codigo objeto.

Monday, May 08, 2006

Parametros Variables en C

Existe una librería de C llamada stdarg.h la cual contiene un pequeño conjunto de macros y un tipo de datos preparado para definir funciones que trabajen con listas de argumentos variables, donde nosotros en la/s llamada/s indicaremos el número de argumentos (parámetros actuales) que necesitemos. Las herramientas que stdarg.h nos aporta son:
  • va_list : es el tipo de dato utilizado para declarar la variable que será utilizada con las macros que ofrece stdarg.h. Define un puntero a la lista de argumentos variable y en entornos como Dev-C++ o el compilador GCC se trata de un alias de un puntero a caracter (typedef char * va_list;).
  • void va_start (va_list ap, last); : macro que se encarga de inicializar una variable pa (parámetro de argumentos) para poder utilizarla con el par de macros restantes. last es un argumento fijo que hay que pasar siempre a la función, como primer parámetro, ya que le sirve como referencia a va_start para saber dónde localizar la lista de argumentos variables (estos argumentos estarán en posiciones de memoria adyacentes a last, de ahí a que se le deba pasar siempre un argumento “estático” a la función).
  • type va_arg (va_list ap, type); : macro con la que recorreremos la lista de argumentos variable. Devuelve el contenido del siguiente de estos argumentos.
  • void va_end (va_list ap); : macro encargada de finalizar el uso de la variable ap previamente inicializada con va_start.
Para la declaracion de la funcion que recibe los parametros variables se emplea un parámetro fijo inicial pasado por valor y, seguidamente, el operador especial ... ("puntos suspensivos") que indica la lista de argumentos variable.

int myfunc (int size, ...);
Indicando el tamaño de la lista o la cantidad de parametros o un puntero a la primer posicion de la lista como en el caso de printf y scanf

A continuacion muestro un ejemplo en c utilizando parámetros variables en c


double multiSuma(int operandos, ...) {

double resultado = 0.0;
va_list pa;

va_start(pa, operandos);

while (operandos--) {
resultado += va_arg(pa, double);
}

va_end(pa);

return resultado;
}

Este simplemente recibe la cantidad de operandos a sumar, primero declara el
va_list pa; seguidamente lo inicializa con el numero de operandos a sumar con el va_start. Por ultimo dentro del while realiza la suma recorriendo la lista con el va_arg y retorna el valor al final. Tambien se utiliza el va_end para finalizar el uso de la variable.

Monday, May 01, 2006

Generando código MIPS

La modificacion para el minimal.cup realizado en el laboratorio 1 de compiladores I, para que pudiera generar codigo MIPS desde la gramática fue la siguiente:

En cada una de las expresiones de la gramática:
- expr PLUS expr //Suma
- expr DIV expr //divide
- expr MIN expr // Resta
- expr TIMES expr //Multiplica

Escribí en un archivo llamado "salida.s" lo siguiente:
f1.writeBytes("li $s1,"+l.intValue()+"\n li $s2,"+r.intValue()+"\n");
f1.writeBytes("add $s0, $s1, $s2"); // Esta línea depende de la operacion que se //requiera(En este caso suma)
Donde f1 es un object RandomAccessFile que me permite escribir en el archivo salida.s

Básicamente estoy tomando el valor propagado en la gramática la cuál ya contiene implícita las reglas de asociatividad y precedencia, seguidamente cargo en los primeros dos registros libres que encuentro los valores y guardo en un tercero el valor del resultado, además despues de cada operación libero los registros utilizados en cada operación.

Me parece que es un buen ejercicio para el proyecto en el cuál generaremos primero el código intermedio y despues el código en MIPS.