Hola amigos, placer saludarles este día. A continuación les presentaremos la resolución de los ejercicios 6.1 y 6.2 del libro del “Dragón”.

6.1 Escríbanse expresiones de tipos para los siguientes tipos.
a) Una matriz de apuntadores a reales, donde los índices de la matriz varían de 1 a 100.

array(1..100, pointer(real))


b) Una matriz bidimensional de enteros (es decir, una matriz de matrices) cuyas filas estén indizadas de 0 a 9 y cuyas columnas estén indizadas de -10 a 10.

array((0..9,-10..10), integer)

c) Funciones cuyos dominios sean funciones desde enteros a apuntadores a enteros y cuyos rangos sean registros que consten de un entero y un carácter.

integer x pointer(integer) à record(int)x(char)


6.2 Supóngase que se tienen las siguientes declaraciones en C:

typedef struct {
int a, b;
} NODO, *APNODO;
NODO aa[100];
APNODO bb(x, y) int x; NODO y { … }

Escríbanse expresiones de tipo para los tipos de aa y bb.

Expresión de tipo para aa:
array(1..100, record((a x integer) x (b x integer)))

Expresión de tipo para bb:
integer x record((a x integer) x (b x integer))
à pointer(record((a x integer) x (b x integer)))



Para resolver la tarea, tuvimos que leer las secciones 6.1 y 6.2 del capitulo 6 del libro del “Dragón”, donde en un inicio no comprendíamos muy bien cómo escribir expresiones de tipo para los tipos de un lenguaje determinado, ya que al inicio resulta un poco confuso tanto tipo y tipo, pero luego después de 2 o 3 leídas obtuvimos los resultados deseados.

Además, quiero platicarles un poco acerca de la segunda fase de micro-C. La labor que nos encontramos realizando actualmente, es la comprobación de tipos, a continuación les presentamos algunos puntos que se han validado hasta el momento.
§ No permitir definir una función con un número diferente de parámetros al que se especifico durante su declaración.
§ Que al definir una función se especifiquen el mismo número y tipo de parámetros especificados al momento de su declaración.
§ No permitir más de 4 parámetros en una función, tanto en su declaración como en su definición.

Esto último lo realizamos ya que para albergar los parámetros de las funciones solo tenemos 4 registros disponibles, los cuales son: $a0 .. $a3.

Actualmente nos encontramos validando las llamadas a funciones, donde las expresiones (producción: expression) que se reciben como parámetros, deben corresponder a los tipos de los parámetros esperados por una función. El trabajo se ha tornado un poco largo, ya que las expresiones son una buena cantidad, por lo tanto su verificación de tipos no es una tarea tan corta.

En relación al retorno de una función tipo void, nos ha saltado una duda. Si el cuerpo de dicha función debe llevar forzosamente un return ; o también seria permitido no colocar ningún statement return. Espero aclarar mi duda en los próximos días.
Esto ha sido todo por hoy, espero verlos si no es posible durante esta semana, si, con seguridad el próximo fin de semana.

Iniciando la segunda fase de Micro-C...

Hola que tal amigos, un placer estar nuevamente con ustedes, para comenzar la segunda fase de nuestro proyecto de Compiladores. En esta ocasión les mostraremos los resultados obtenidos en la realización del primer trabajo de laboratorio asignado en esta nueva clase de Compiladores II.

La primera actividad que se nos encomendó fue ejecutar paso a paso el programa suma.s en el software SPIM, el cuál es un simulador de una maquina MIPS. Para realizar este trabajo lo hicimos de la siguiente manera:
Primero cargamos el archivo suma.s, luego utilizando la tecla F10 o la opción Simulator - Single Step ejecutamos paso a paso el programa suma.s. En el transcurso de la ejecución del mismo observamos como iban cambiando los valores en cada uno de los registros.
Además, esta primera tarea fue muy productiva porque nos ayudo a comprender la forma de realizar llamadas al sistema. Las cuales se hacen con la ayuda del registro $v0, en el cual se almacena el numero que representa el tipo de llamada que se quiere realizar.
Entre las llamadas al sistema que realiza suma.s están, la solicitud de entrada desde el teclado, de los dos números a sumar. Y posteriormente la salida hacia la pantalla del resultado correspondiente.



De acuerdo, a la segunda actividad a realizar, la cual consiste en ejecutar la instrucción addi $v0, $zero, 4, dicha instrucción realiza una suma inmediata de 4 + 0, y el resultado lo almacena en el registro $v0. Dicho resultado se puede apreciar en la figura de arriba, en la segunda fila del primer componente de la ventana de PCSpim. Además, podemos ver la ubicación del apuntador del programa, el cual esta localizado en la quinta fila del segundo componente de la ventana de PCSpim.
La tercera actividad consistió en imprimir el producto de los dos números que ingreso el usuario, esto lo realizamos utilizando las siguientes líneas de código:

#Se escribe el mensaje de string para mostrar el producto entre los dos números
addi $v0, $zero, 4
la $a0, cad3
syscall
mul $s2, $s0, $s1 #Se multiplican ambos números
#Se escribe el resultado
addi $v0, $zero, 1
add $a0, $zero, $s2
syscall

En la primera instrucción almacenamos en $v0 el valor 4, para indicar a SPIM que vamos visualizar una cadena string en pantalla, la cadena se encuentra en cad3; con esto mostramos el mensaje "El producto de ambos es: "
A continuación, multiplicamos el contenido de $s0 y $s1, el resultado lo almacenamos en $s2. Y para finalizar mostramos $s2 en pantalla, el resultado lo vemos a continuación:


Respecto a la cuarta y última actividad asignada en esta práctica de laboratorio, ésta la hicimos con la ayuda del documento que se encuentra en la siguiente dirección en la Internet:
http://www.caip.rutgers.edu/%7Eemmalily/teaching_files/examples.html
En donde encontramos ejemplos de cómo realizar comparaciones entre variables(registros). Las ordenes importantes para realizar las comparaciones fueron beq y blt; la primera compara el contenido en dos registros y nos dice si dicho contenido es igual, en caso de serlo entonces se realiza un branch a una etiqueta que se especifica en la instrucción, mientras tanto blt realiza la misma labor que la primera orden solo con la excepción que la comparación no se basa en si son iguales o no, sino en qué si uno es mayor que el otro.

El código utilizado para realizar ésta actividad lo colocamos a continuación:

beq $s0, $s1, equals
blt $s0, $s1, s1Mayor
blt $s1, $s0, s0Mayor
s1Mayor:
#Se escribe el mensaje de string para mostrar el número mayor
addi $v0, $zero, 4
la $a0, cad5
syscall
#Se escribe el número mayor
addi $v0, $zero, 1
add $a0, $zero, $s1
syscall
b equals #saltar a etiqueta equals

s0Mayor:
#Se escribe el mensaje de string para mostrar el número mayor
addi $v0, $zero, 4
la $a0, cad5
syscall
addi $v0, $zero, 1
add $a0, $zero, $s0
syscall

equals:
#Se escribe un return al final
addi $v0, $zero, 4
la $a0, cr
syscall
#Fin del programa
addi $v0, $zero, 10
syscall

Además colocamos una corrida en la consola de PCSpim:


La experiencia vivida al realizar este laboratorio fue de mucho provecho, porque se aprendió a realizar algunas de las operaciones más básicas en el simulador SPIM, como sumas, multiplicaciones, comparaciones, visualización de mensajes, entre otras. Con la lectura que realizamos al documento Appendix A.pdf, conocimos la mayoría de los comandos de este simulador, y aunque hemos quedado con algunas dudas, tenemos la confianza que las despejaremos, si no todas, una gran mayoría, en el transcurso de la semana.

Las dificultades encontradas no fueron tantas, gracias a Dios todas las cosas salieron bien, por ahí, no entendíamos inicialmente las llamadas al sistema(syscall) pero poco a poco fuimos comprendiendo su funcionamiento al analizar detenidamente la ejecución del programa en el simulador PCSpim.
Igualmente, al inicio de la práctica no entendíamos la forma de realizar la ejecución paso a paso de nuestro programa, pero después de varias pruebas, a Dios gracias llego a buen término el asunto.

Bueno señores, y con esta me despido. Sin duda, que el laboratorio fue de mucho provecho, como recién dije al principio, y definitivamente, hemos quedado listos para comenzar esta segunda etapa de nuestro proyecto: el compilador micro-C.