Anteriores 08 PDF

Compiladores I
1 Convocatoria 95/96 (27-I-96)

4 Ing. Informtica. C.P.S. Universidad de Zaragoza
Se desea implementar una calculadora con sintaxis Lisp. El programa debe procesar
una secuencia de listas Lisp tomadas de stdin. Cada lista contiene una expresin
aritmtica (en notacin prefija), y para cada una de ellas se debe escribir el resultado
de su expresin correspondiente. Para simplificar, asumiremos '+' y '*' como nicos
operadores.
Ejemplo: Para un fichero de entrada como el siguiente
(+ 2 4 6 8 10);
(* (+ 1 2 3) (+ 9 7 1))
(+
(* 10 2 3)
25
(* 8 9 (+ 1 1) )
);
(+ 20 -20);
(+ 20);
(* 30);
debe generar la salida

->
->
->
->
->
->
30
102
229
0
20
30
Como se puede ver en el ejemplo, los separadores en la entrada (blancos,

tabuladores, saltos de lnea) no influyen en el resultado.
Ejercicio 1 (1 pto.): Escribir un fuente Lex (Flex) para el reconocimiento de los
tokens fundamentales que permitan resolver, en conjuncin con los Ejercicios 2 y 3,
la calculadora deseada.
Ejercicio 2 (2 ptos.): Escribir una gramtica (en Yacc/Bison) que exprese una
sintaxis (clara y concisa) para las entradas a la calculadora propuesta.
Ejercicio 3 (2 ptos.): Completar la gramtica del ejercicio anterior de manera que
implemente la calculadora. Notar que basta con aadir al resultado del Ejercicio 2
las acciones necesarias.
Nota 1: Si se considera necesario, se puede establecer un nivel de anidamiento
mximo en las listas de listas de 125 niveles.
-1-
Compiladores I
Considrese la siguiente gramtica:

ALS
ALS
AL
NS
NS
==ALS AL
==
==AL
==NUM NS
==NS N
==N
',' NS
'\n'
Se desea saber si se trata de una gramtica SLR o no. Para ello, responder a las
siguientes preguntas.
Ejercicio 4 (2 ptos.): Construir la familia cannica de conjuntos LR(0)
Ejercicio 5 (1.5 ptos.): Construir el autmata a partir de dichos conjuntos
Ejercicio 6 (1.5 ptos.): Se trata de una gramtica SLR o no?
Tiempo total para el examen:
3 horas
-2-
Compiladores I
2 Convocatoria 95/96 (22-VI-96)
Ejercicio 1: Considrese la siguiente gramtica:

S ==[ S
| S1
S1 ==
==[a]
1.1) (1 pto.) Establecer el lenguaje que genera. Es necesario que se justifique,

lo ms formalmente posible, la respuesta dada
1.2) (1.5 ptos.)
Se trata de una gramtica SLR(1)?
1.3) (1 pto.) Se trata de una gramtica LL(1)?
1.4) (0.5 ptos.)
Si no es SLR(1), dar una gramtica equivalente que s lo
sea. Anlogamente, si no es LL(1) dar una gramtica equivalente que s lo
sea.
Ejercicio 2 (1.5 ptos.): Considerar una analizador LR. Para definir una lista no vaca
de identificadores podemos pensar en las siguientes alternativas:
a) listaID:
|
listaID ID
ID
b) listaID:
|
ID listaID
ID
Son igualmente correctas las dos definiciones? En qu se diferencia el

funcionamiento de una y otra? Si ambas son correctas, Cul de ellas es ms
aconsejable? Ejemplificarlo con los sucesivos cambios de estado de la pila del
analizador sintctico para la secuencia de tokens
ID ID ID ID
Ejercicio 3 (2.5 ptos.): "Boxes" es un lenguaje para la descripcin de secuencias de
cajas (planas) que se incluyen unas en otras. La siguiente figura muestra en la parte
izda. un programa fuente en dicho lenguaje, y en su parte dcha. el resultado grfico
de su ejecucin.
-1-
Compiladores I
v 2,3
[
h 1,1
[
---+
++++
]
h 2,1,2
[
++++
---v 1,1
[
+++-+-+
]
]
]
El significado del fuente es el siguiente:

v 2,3: indica que la caja en cuestin se va a dividir verticalmente en dos cajas. La
primera (empezando por la izda.) ocupar 2/5 del total, mientras que la segunda
ocupar los 3/5 restantes. Lo que le sigue entre [....] son las descripciones de las cajas
interiores.
h 1,1: indica que la primera de las subcajas (la que ocupaba los 2/5 de la izda.)
se va a dividir horizontalmente en dos subcajas, ocupando cada una la
mitad del espacio. Para cada una de estas cajas, la secuencia formada por 4
elementos de {'+','-'} indica el color de los lados, empezando por el de ms
a la izda. y girando en el sentido de las agujas del reloj: '+' indica trazo en
negro, mientras que '-' indica que no hay trazo (el lado no se dibuja).
h 2,1,2: indica que la segunda de la subcajas se divide horizontalmente en 3
cajas, que ocupan respectivamente 2/5,1/5,2/5. Y as sucesivamente.
Se pide escribir la gramtica Yacc correspondiente al lenguaje Boxes.
Ejercicio 4: En un afamado centro universitario propusieron una vez el siguiente
interesante ejercicio:
Se desea implementar una calculadora con sintaxis Lisp. El programa debe
procesar una secuencia de listas Lisp tomadas de stdin. Cada lista contiene
una expresin aritmtica (en notacin prefija), y para cada una de ellas se
debe escribir el resultado de su expresin correspondiente. Para simplificar,
asumiremos '+' y '*' como nicos operadores.
-2-
Compiladores I
Ejemplo: Para un fichero de entrada como el siguiente

(+ 2 4 6 8 10);
(* (+ 1 2 3) (+ 9 7 1))
(+
(* 10 2 3)
25
(* 8 9 (+ 1 1) )
);
(+ 20 -20);
(+ 20);
(* 30);
debe generar la salida

->
->
->
->
->
->
30
102
229
0
20
30
Como se puede ver en el ejemplo, los separadores en la entrada (blancos,

tabuladores, saltos de lnea) no influyen en el resultado.
4.1) (1 pto.) Para resolver el problema, algunos de los alumnos plantearon la
siguiente gramtica en Yacc:
listas: listas lista ';'
| lista ';'
;
lista: '(' operador listaSexps ')'
;
listaSexps: listaSumandos
| listaMultiplicandos
;
listaSumandos: elemento
| listaSumandos elemento
;
listaMultiplicandos: elemento
| listaMultiplicandos elemento
;
operador: '+'
| '*'
;
elemento: NUMERO
| lista
;
-3-
Compiladores I
Teniendo presente la necesidad posterior de generar la calculadora (su ejecutable),

Es correcta la gramtica presentada? Justificar la respuesta. En caso de no ser
correcta poner ejemplos de problemas que podran surgir.
4.2) (1 pto.) A la hora de implementar la calculadora deseada, otros plantearon la
siguiente solucin
%{
........
char laOp;
%}
%union{
int val;
......
}
%token NUMERO
%type <val> Sexp
%type <val> lista
%type <val> listaSexps
%type <val> NUMERO
%%
listas: listas lista ';'
{printf("-->%d\n",$2);}
| lista ';'
{printf("-->%d\n",$1);}
;
lista: '('
operador
listaSexps
')'
{$$=$3;}
;
operador: '+'
{laOp='+';}
| '*'
{laOp='*';}
;
listaSexps: listaSexps Sexp
{if(laOp=='+')
$$=$1+$2;
else
$$=$1*$2;
}
| Sexp
{$$=$1;}
;
Sexp: NUMERO
{$$=$1;}
| lista
{$$=$1;}
;
%%
main()
{
yyparse();
}
Es correcta esta solucin? Justificar la respuesta. En caso de no ser correcta, poner

ejemplos de problemas que podran surgir y proponer (escuetamente) usa solucin.
2 horas 30 min.
-4-
Compiladores I
3 Convocatoria 95/96 (3-IX-96)
Ejercicio 1 (3 ptos.): Los identificadores para un determinado lenguaje de

programacin se definen de acuerdo con la siguiente descripcin:
Un identificador puede empezar con una letra o un "underscore" (carcter
"_"), debe estar seguido por 0 ms letras, dgitos o underscores, pero con
las restricciones siguientes:
1) No pueden aparecer dos underscores seguidos
2) Un identificador no puede terminar con un underscore.
Adems, no hay ninguna limitacin en cuanto a la longitud de los
identificadores.
1.1)
(1.5 ptos.) Dibujar el Autmata Finito Determinista que corresponde a

los identificadores descritos anteriormente.
Para etiquetar los arcos, en lugar de utilizar caracteres simples utilizar
las siguientes clases de caracteres:
letra
digito
und
1.2)
[a-zA-Z]
[0-9]
"_"
(1.5 ptos.) Dar una expresin regular correspondiente a los

identificadores descritos anteriormente
Ejercicio 2 (2 ptos.): Considrese el lenguaje libros que se define como sigue:

a)
b)
c)
d)
e)
f)
g)
Un libro es o bien una novela o bien un coleccin de historias cortas

Una novela consiste en un ttulo seguido por uno o ms captulos
Un captulo es un entero seguido por un cuerpo de captulo
Un cuerpo de captulo es una lista de prrafos y/o ilustraciones. La lista
debe incluir al menos un prrafo.
Una colleccin de historias cortas se compone de dos o ms historias
cortas. Dos historias cortas se separan por una pgina en blanco.
Una historia corta consiste en un ttulo seguido de un cuerpo de historia
corta
Un cuerpo de historia corta es lo mismo que un cuerpo de captulo
-1-
Compiladores I
Escribir una gramtica lo ms clara y compacta posible para dicho lenguaje. Utilizar
letras minsculas para los no terminales de la gramtica, as como los siguientes
terminales:
terminal
T
E
P
I
B
lo que denota
un ttulo
un entero
un prrafo
una ilustracin
una pg. en blanco
Ejercicio 3 (2 ptos.): Considrese la siguiente gramtica, donde NUMERO y MAS

son los smbolos terminales:
exp= listaElementos
listaElementos NUMERO
listaElementos exp MAS NUMERO
Razonar sobre si es una gramtica LL(1) o no. En caso de no serlo, dar una gramtica
equivalente que sea LL(1)
Ejercicio 4 (3 ptos.): Considrese la siguiente gramtica que se usa para el
tratamiento de determinado tipo de expresiones:
exp= ter '=' ter
exp= ter
ter= ter '+' fact
ter= ter AND fact
ter= fact
fact= ENTERO
fact= BOOLEANO
fact= '(' exp ')'
Las reglas de tipo para las expresiones de la gramtica son las siguientes:
1)
2)
3)
Slo se pueden sumar enteros; el resultado es un entero.

El operador AND slo se puede aplicar sobre booleanos; el resultado es
un booleano.
El operador de igualdad '=' slo puede aplicarse sobre elementos del
mismo tipo, y su resultado es siempre un booleano.
-2-
Compiladores I
4)
En el caso de que aparezca un error de tipos durante la traduccin (es

decir, se viole alguna de las reglas anteriores), el tipo de la expresin
ser error.
Un fuente Yacc incompleto para el problema planteado puede ser el siguiente:

%{
#include <stdio.h>
#include <string.h>
extern char yytext[];
/*-----------------------------------------------------Se asume que los tipos 'tipos' y 'atrib' se encuentran
definidos, donde corresponda, para su utilizacin.
------------------------------------------------------*/
typedef enum {entero,booleano,error} tipos;

typedef struct{
tipos elTipo;
int elValor;
}atrib;
/*-----------------------------------------------------Aqu cdigo de procedimientos y funciones necesarias
------------------------------------------------------*/
%}
%union{
atrib atributos;
}
%token ENTERO BOOLEANO AND
%type <atributos> exp ter fact
%%
exp : ter '=' ter
{/*-UNO-*/}
| ter
{/*-DOS-*/}
;
ter : ter '+' fact
| ter AND fact
| fact
;
{/*-TRES-*/}
{/*-CUATRO-*/}
{/*-CINCO-*/}
fact : ENTERO
| BOOLEANO
| '(' exp ')'
;
{/*-SEIS-*/}
{/*-SIETE-*/}
{/*-OCHO-*/}
%%
main()
-3-
Compiladores I
{
yyparse();
}
4.1)
(1.5 ptos.) Escribir las partes de cdigo UNO,...,OCHO que permitan

sintetizar el atributo 'elTipo' para el no terminal 'exp', de manera
que satisfaga las reglas de tipo.
4.2)
(1.5 ptos.) Completar las partes de cdigo UNO,...,OCHO que permitan

adems sintetizar el atributo 'elValor' (se debe entender que '+'
corresponde a la suma de enteros, 'AND' a la conjuncin de booleanos y
'=' el operador booleano de igualdad). Se debe asumir que en caso de que
el atributo de tipo sea error el atributo de valor queda indeterminado.
Nota 1: Se asume que el analizador lxico simplemente devuelve el token
correspondiente y deja en yytext el lexema asociado,
convirtiendo las letras minsculas en maysculas.
Nota 2: Por cuestiones de claridad, cada parte de acciones UNO,...,OCHO
slo puede contener una instruccin C. En caso de necesitar ms, se
debe realizar una invocacin a un procedimiento o funcin con los
parmetros adecuados. Por supuesto, tambin debes escribir el
cdigo de estos procedimientos y funciones.
3 horas
-4-
Compiladores I
1 Convocatoria 96/97 (1-II-97)
Ejercicio 1 (3 ptos.): Considrese el siguiente fragmento de fuente Yacc para el

manejo de expresiones
#include "tabla.h"
#include <stdio.h>
void errorSemantico(char *mens)
/* Pre: TRUE
Post: escribe '*mens' en stderr y aborta ejecucin
*/
{
/*se asume ya implementado*/
}
TABSIM laTabla;
%%
%union{
char elID[MAXLONGID];
TIPO_VARIABLE elTipo;
.........
{/*1*/}
}
%token .......
{/*2*/}
%type .......
{/*3*/}
%%
.......
expr:
expSimple
{/*4*/}
| expSimple opRel expSimple
{/*5*/}
;
expSimple:
term
| expSimple opSum term
;
{/*6*/}
{/*7*/}
opRel:
'='
| '<'
| '>'
| tMEI
| tMAI
| tNI
;
{/*corresponde a "<="*/
{/*corresponde a ">="*/
{/*corresponde a "<>"*/
{/*8*/}
{/*9*/}
{/*10*/}
/*11*/}
/*12*/}
/*13*/}
{/*corresponde a "OR"*/
{/*14*/}
{/*15*/}
/*16*/}
opSum:
'+'
| '-'
| tOR
;
opMul:
'*'
| tDIV
| tMOD
| tAND
;
{/*17*/}
{/*corresponde a "DIV"*/ /*18*/}
{/*corresponde a "MOD"*/ /*19*/}
{/*corresponde a "AND"*/ /*20*/}
-1-
Compiladores I
term:
factor
| '+' term
| '-' term
| term opMul factor
;
%prec MASMAS
%prec MENOSMENOS
{/*21*/}
{/*22*/}
{/*23*/}
{/*24*/}
factor:
tCONSTENTERA
| tCONSTCHAR
| tFALSE
| tTRUE
| tIDENTIFICADOR
| tIDENTIFICADOR selCompVect
| tIDENTIFICADOR paramActuales
| '(' expr ')'
| tNOT factor
%prec NEG
;
{/*25*/}
{/*26*/}
{/*27*/}
{/*28*/}
{/*29*/}
{/*30*/}
{/*31*/}
{/*32*/}
{/*33*/}
paramActuales:
'(' listaExpr ')'
;
{/*34*/}
listaExpr:
listaExpr
','
expr
| expr
;
{/*35*/}
{/*36*/}
{/*37*/}
{/*38*/}
selCompVect:
'[' expr ']'
;
{/*39*/}
.......
Considrese, por otra parte, la especificacin para el manejo de la tabla de smbolos

que se entregan en las hojas anexas.
-2-
Compiladores I
El objetivo es completar la gramtica (parcial) anterior con aquellas acciones

semnticas que permitan obtener el tipo de una expresin. Para ello se pide
completar las partes /*1*/ a /*39*/ que se consideren necesarias con el cdigo C
necesario de manera que:
a)
b)
Se sintetice el atributo 'elTipo' para el smbolo 'expr'

Se den mensajes de error semntico (mediante la adecuada invocacin a
'errorSemantico()') en aquellas circunstancias que podais detectar.
No es necesario detectar los errores correspondientes a una inconsistencia
de nmero, tipo y/o clase entre los parmetros actuales y los formales en
una invocacin a una funcin
Notas:
1) Para evitar confusiones, escribir en las hojas que entregueis el nmero
correspondiente a la parte del cdigo y, a continuacin, el cdigo
correspondiente. Por ejemplo:
4)
{$$=$1;}
2)
Por otra parte, si alguna de las partes no contiene cdigo, escribir

nicamente el nmero (para indicar que no se trata de un olvido, sino
simplemente de una parte que no requiere cdigo).
Asumir que el analizador lxico, cuando reconoce un identificador,
adems de devolver el token 'tIDENTIFICADOR' asigna al campo
'elID' de la variable 'yylval' el string correspondiente al nombre
del identificador. Para el resto de los terminales no realiza ninguna accin,
excepto la correspondiente a devolver el token.
Ejercicio 2 (5 ptos.) : Considrese la siguiente gramtica (en negrita los terminales):

S ==( L )
S====a
L ==L , S
L ==S
2.1
2.2
(0.5 ptos.) Qu lenguaje genera dicha gramtica?

(2.5 ptos.) Construir el autmata SLR para dicha gramtica y las tablas
'accion[]' e 'ir_a[]' del anlisis SLR, y concluir si se trata de una
gramtica SLR o no.
-3-
Compiladores I
2.3
(2 ptos.) Evidentemente, se trata de una gramtica no LL(1).

Transformarla en una equivalente que s lo sea, y contruir la tabla del
anlisis sintctico LL(1).
Ejercicio 3 (2 ptos.): Considrese un conjunto finito A={e1,e2,...,ek}. Una lista

"plana" de elementos de A es de la forma [a1,a2,...,ar] donde los ai son
elementos distintos del conjunto A. Tambin se considera como correcta la lista
vaca []. Por otra parte, la posicin que ocupan los elementos dentro de la lista es
significativa, de manera que las listas [e1,e7] y [e7,e1] son distintas. Este ejercicio
pide los siguiente:
3.1
3.2
3.3
(1 pto.) Describir concisa y claramente una gramtica libre de contexto

que reconozca listas planas de elementos distintos de A (no se trata de
escribir toda la gramtica pues k no se ha establecido). Escribir
completamente dicha gramtica para el caso k=3.
(0.5 ptos.) Estimar cuntas producciones tendra dicha gramtica
(0.5 ptos.) Si imponemos que los elementos de una lista se tomen
ordenadamente (es decir, nunca pueden darse situaciones del estilo
[...,e9,...,e3,...]), estimar cuntas producciones tendra una gramtica que
considerara esta restriccin.
3 horas
-4-
Compiladores I
2 Convocatoria 96/97 (4-VII-97)
Ejercicio 1 (6.25 ptos.): Considerar la siguiente gramtica (denominada G), que

forma parte de una gramtica para un lenguaje de programacin imperativo:
%token ID OPAS VAL
%%
sentencias:
sentencia
|
sentencias sentencia
;
sentencia:
etiqueta asignacion
;
etiqueta:
|
;
ID ':'
asignacion:
ID OPAS VAL ';'
;
%%
1.1) (1.0 Ptos.) Determinar si =L(G). Si la respuesta es afirmativa, encontrar

una derivacin para ella. Si es negativa, razonar la respuesta.
1.2) (1.25 Ptos.) Obtener completa la tabla del anlisis LL(1), y deducir a partir
de ella que no se trata de una gramtica de dicha clase.
1.3) (2 Ptos.) Realizar las transformaciones necesarias de la gramtica G hasta
encontrar una gramtica equivalente que s sea LL(1).
1.4) (2 Ptos.) Para la gramtica obtenida en el punto 1.3), escribir en C un
analizador descendente recursivo. Asumir la existencia de una funcin
int yylex()
que realiza el anlisis lxico: devuelve los tokens declarados, salta
separadores (blancos, tabuladores y saltos de lnea) y devuelve el ASCII
de los caracteres que no corresponden a los casos anteriores.
-1-
Compiladores I
Ejercicio 2 (3 ptos.): Con el objetivo de depurar programas se ha decidido

implementar un formateador para ficheros que contienen listas tipo Lisp de enteros
sin signo. Se pide escribir un analizador sintctico, en YACC, que recorra el fichero
de entrada (contiene una secuencia de listas de las que estamos considerando) y las
escriba en forma tabulada por niveles, de acuerdo con el ejemplo. As, si el fichero
de entrada contiene
(1 2 3 4 (5 6
(88 (77
) 7
66) 55 (44
8)
33
(22 11)))
la salida por stdout del analizador debe ser la siguiente

(
1
2
3
4
(
5
6
)
7
8
)
(
88
(
77
66
)
55
(
44
33
(
22
11
)
)
)
-2-
Compiladores I
Nota: definir nicamente el token 'NUMERO' y asumir ya construdo un

analizador lxico que:
* devuelve dicho token cuando reconoce un entero sin signo
* los blancos, tabuladores y saltos de lnea los salta
* para cualquier otro carcter, devuelve su ASCII
Ejercicio 3 (0.75 ptos.): El libro "Pascal: User Manual and Report" de K. Jensen y
N. Wirth, que establece la especificacin ISO Pascal Standard, define un comentario
del lenguaje como (slo vamos a considerar comentarios vlidos aqullos que
empiezan por "(*" y terminan por "*)"):
"(*" seguido de cualquier secuencia de 0 ms caracteres que
no contenga "*)", y terminado por "*)"
Escribir una expresin regular con sintaxis LEX para los comentarios Pascal as
definidos.
2:45 horas
-3-
Compiladores I
Ejercicio 1 (2.5 ptos.): La invocacin a Yacc con una gramtica dada ha generado el
fichero 'y.output' que se muestra en el Anexo 1. Se pide lo siguiente:
1.1) (1.0 Ptos.) Deducir a partir de dicho fichero cul es la gramtica que lo
genera
1.2) (0.5 Ptos.) Razonar por qu no es una gramtica LL(1)
1.3) (1.0 Ptos.) Transformar la gramtica a una equivalente que s lo sea, y
obtener para esta transformada la tabla del anlisis LL(1)
Ejercicio 2 (7.5 ptos.): Se desea construir un intrprete para un lenguaje muy

sencillo. Dicho lenguaje maneja cadenas de caracteres, y es capaz de asignarlas a
variables, realizar la operacin de concatenacin y escribir por salida estandar
expresiones (limitadas como se ver posteriormente) que involucran cadenas.
Un ejemplo de programa en dicho lenguaje sera el siguiente:
vars a b c
start
print("Un refran:")
a="No por mucho "
b=""" madrugar"""
a=a+b
print("a: " + a)
c=b+b+b+" no es sano"
print("res: " + c + " segun el califa")
print("a:")
print(a)
end
que dar como salida

Un refran:
a: No por mucho " madrugar"
res: " madrugar"" madrugar"" madrugar" no es sano segun el califa
a:
No por mucho " madrugar
Detallemos un poco ms sus caractersticas:

a)
b)
las variables que se van a utilizar han de ser declaradas previamente

(mediante la palabra reservada vars), y todas ellas son capaces de
almacenar una cadena de hasta 300 caracteres.
en su representacin externa, una constante de tipo cadena va entre dobles
comillas. Entre ellas puede ir cualquier secuencia de 0 ms caracteres
-1-
Compiladores I
c)
d)
distintos del salto de lnea ('\n'); cuando se desea representar unas

dobles comillas como parte del contenido de la cadena, stas se han de
poner por duplicado (ver la asignacin a la variable b en el
programa de ejemplo).
adems de la asignacin y la escritura, es posible realizar la concatenacin
de cadenas, que se representa externamente mediante el operador '+'.
el lenguaje distingue entre maysculas y minsculas
El ejercicio pide construir el intrprete completo: analizador lxico, sintctico,

tratamiento de aqullos errores semnticos que consideres importantes y la propia
ejecucin del cdigo fuente. Para el tratamiento semntico puedes utilizar la tabla de
smbolos que se especifica en el Anexo 2. Notar que se trata de la que habitualmente
has utilizado en prcticas, en las que se han realizado algunas modificaciones para
poder operar con variables de tipo cadena y su contenido.
3 horas
-2-
Compiladores I
Anexo 1
state 0
$accept
$end
a
+
.
shift 4
shift 3
error
S
A
goto 1
goto 2
_S
goto 5
goto 6
B
D
state 6
B : D_C
state 14
A :
+
(2)
.
(1)
A_
reduce 2
a
+
.
shift 4
shift 3
error
S
A
goto 13
goto 2
a
+
.
shift 4
shift 3
error
goto 14
c
*
.
shift 12
shift 11
error
goto 18
state 16
D : b_
.
.
(4)
reduce 4
state 11
C : *_D C
b
(
.
shift 16
shift 8
error
goto 15
state 12
C : c_
.
reduce 7
-3-
(7)
(9)
reduce 9
state 17
D :
(
(8)
)_
C_
reduce 8
state 18
C :
*
(6)
.
(3)
shift 17
error
state 15
C : * D_C
reduce 3
reduce 1
reduce 9
reduce 9
reduce 5
state 10
B : D C_
goto 9
goto 6
state 5
S : A B_
(5)
(9)
state 9
A : + B_A
shift 7
shift 8
error
state 4
A : a_
)
.
state 8
D : (_S )
state 3
A : +_B A
b
(
.
goto 10
state 13
D : ( S_)
state 2
S : A_B
B
D
c
*
.
$end accept
. error
shift 7
shift 8
error
shift 12
shift 11
error
state 7
B : b_
D : b_
state 1
$accept
S_$end
b
(
.
c
*
.
reduce 6
Compiladores I
Anexo 2
/*======================================================================
Prog.:
tabla.h
Tema:
funciones para manipular una tabla de simbolos para un
lenguaje de bloques
Fecha:
Noviembre-96
Fuente:
J. Neira
Com.:
MODIFICADA PARA EXAMEN SEPTIEMBRE 97 DE COMPI
=======================================================================*/
/*========================================================*/
/*
D E F I N I C I O N E S
*/
/*========================================================*/
#define MAXLONGID
#define TAMANO_TABLA
#define CIERTO
#define FALSO
100
7
/* longitud maxima de un identificador */

/* Numero de entradas en la tabla hash */
1
0
/*========================================================*/
/*
T I P O S
*/
/*========================================================*/
typedef enum {
PROGRAMA,
VARIABLE,
PROCEDIMIENTO,
FUNCION,
PARAMETRO,
RESULTADO
} TIPO_SIMBOLO;
/*categorìas de sìmbolos*/
typedef enum {
ENTERO,
BOOLEANO,
CHAR,
STRING
} TIPO_VARIABLE;
/*tipos de datos*/
typedef enum {
IN,
OUT,
INOUT
} CLASE_SIMBOLO;
/*clases de par'ametros*/
struct UN_SIMBOLO {
TIPO_SIMBOLO tipo;
char identificador[MAXLONGID];
TIPO_VARIABLE variable;
int es_vector;
int minimo;
int maximo;
/* Si vector, indices */
CLASE_SIMBOLO clase;
int nivel;
-4-
Compiladores I
int dir;
int visible;
/* Si variable, direccion; si proc/func,

dir primera instruccion. Sin uso para
pràctica 5. Asignar 0*/
/* Si es un parametro */
lista parametros;
/* Si proc/func, lista de
puntero a los simbolos de los
parametros */
struct UN_SIMBOLO *funcion;
/* Si es resultado de func.,
puntero al simbolo de
la funcion */
char valor[300];
/* valor del s'imbolo.

El programador debe hacer
la transformaci'on adecuada
de valores en funci'on a su tipo*/
};
typedef struct UN_SIMBOLO SIMBOLO;
typedef lista TABSIM[TAMANO_TABLA];
/*========================================================*/
/*
M A C R O S
*/
/*========================================================*/
#define
#define
#define
#define
#define
#define
#define
#define
ES_VARIABLE(e) ((e).tipo == VARIABLE)

ES_PARAMETRO(e) ((e).tipo == PARAMETRO)
ES_PROCEDIMIENTO(e) ((e).tipo == PROCEDIMIENTO)
ES_FUNCION(e) ((e).tipo == FUNCION)
ES_RESULTADO(e) ((e).tipo == RESULTADO)
ES_ENTRADA(e) (((e).tipo == PARAMETRO) && ((e).clase == IN))
ES_SALIDA(e) (((e).tipo == PARAMETRO) && ((e).clase == OUT))
ES_ES(e) (((e).tipo == PARAMETRO) && ((e).clase == INOUT))
/*========================================================*/
/*
F U N C I O N E S
*/
/*========================================================*/
/*========================================================*/
void inicializar_tabla (TABSIM tabla);
/*========================================================
Crea una tabla de simbolos vacia.
IMPORTANTE: Este procedimiento debe invocarse antes de hacer
ninguna operacion con la tabla de simbolos.
========================================================*/
/*========================================================*/
SIMBOLO *buscar_simbolo (TABSIM tabla,
char *identificador);
/*========================================================
Busca en la tabla el simbolo de mayor nivel cuyo
identificador coincida con el del parametro (se distinguen
minusculas y mayusculas). Si existe, devuelve como
resultado un puntero al sìmbolo, de lo contrario devuelve
NULL.
========================================================*/
/*========================================================*/
-5-
Compiladores I
SIMBOLO *introducir_programa (TABSIM tabla,
char *identificador,
int dir);
/*========================================================
Introduce en la tabla un simbolo de tipo PROGRAMA, con el
identificador del parametro, de nivel 0, con la direccion
del parametro. Dado que debe ser el primer simbolo a
introducir, NO SE VERIFICA QUE EL SIMBOLO YA EXISTA.
========================================================*/
/*========================================================*/
SIMBOLO *intenta_introducir_variable (TABSIM tabla,
TIPO_VARIABLE variable,
int nivel,
int dir,
char *val);
/*========================================================
Si existe un simbolo en la tabla del mismo nivel y con el
mismo identificador, devuelve NULL. De lo contrario,
introduce un simbolo de tipo VARIABLE (simple) con los datos
de los argumentos.
========================================================*/
/*========================================================*/
SIMBOLO *intenta_introducir_vector (TABSIM tabla,
int minimo,
int maximo,
int nivel,
int dir);
/*========================================================
introduce un simbolo de tipo VARIABLE (vector) con los datos
de los argumentos.
========================================================*/
/*========================================================*/
SIMBOLO *intenta_introducir_procedimiento (TABSIM tabla,
char *identificador, int nivel, int dir);
/*========================================================
introduce un simbolo de tipo PROCEDIMIENTO con los datos de
los argumentos.
========================================================*/
/*========================================================*/
SIMBOLO *intenta_introducir_funcion (TABSIM tabla,
int nivel,
int dir);
/*========================================================
introduce un simbolo de tipo FUNCION con los datos de los
argumentos.
IMPORTANTE: El resultado de la funcion debera ser
introducido como un simbolo diferente, de tipo RESULTADO y
de nivel + 1.
========================================================*/
-6-
Compiladores I
/*========================================================*/
SIMBOLO *intenta_introducir_resultado (TABSIM tabla,
SIMBOLO *funcion,
int nivel,
int dir);
/*========================================================
introduce un simbolo de tipo RESULTADO con los datos de los
argumentos.
========================================================*/
/*========================================================*/
SIMBOLO *intenta_introducir_parametro_simple (TABSIM tabla,
int clase,
int nivel,
int dir);
/*========================================================
introduce un simbolo de tipo PARAMETRO (simple) con los
datos de los argumentos.
IMPORTANTE: Los parametros NO quedan ligados al
procedimiento o funcion donde estan declarados. Se debe
hacer una lista con los punteros que esta funcion devuelva,
y asociarla con el proc/func correspondiente utilizando el
procedimiento colgar_parametros.
========================================================*/
/*========================================================*/
SIMBOLO *intenta_introducir_parametro_vector (TABSIM tabla,
int minimo,
int maximo,
int clase,
int nivel,
int dir);
/*========================================================
introduce un simbolo de tipo PARAMETRO (vector) con los
datos de los argumentos.
IMPORTANTE: Los parametros NO quedan ligados al
procedimiento o funcion donde estan declarados. Se debe
hacer una lista con los punteros que esta funcion devuelva,
y asociarla con el proc/func correspondiente utilizando el
procedimiento colgar_parametros.
========================================================*/
/*========================================================*/
void colgar_parametros (TABSIM tabla,
SIMBOLO *procfunc,
lista lista);
/*========================================================
Asocia la lista (que debe ser una lista de SIMBOLOS
previamente introducidos, correspondientes a parametros)
-7-
Compiladores I
con el simbolo correspondiente a un procedimiento o
funcion.
========================================================*/
/*========================================================*/
void ocultar_parametros (TABSIM tabla,
int nivel);
/*========================================================
Marca todos los parametros de un nivel como ocultos para que
no puedan ser encontrados por la funcion buscar_simbolo. Se
mantiene la definicion completa del procedimiento/funcion
donde estan declarados para verificacion de invocaciones al
procedimiento/funcion.
========================================================*/
/*========================================================*/
void eliminar_programa (TABSIM tabla);
/*========================================================
Elimina de la tabla todos los simbolos (deberia haber uno
solo) de tipo programa y nivel 0.
========================================================*/
/*========================================================*/
void eliminar_variables (TABSIM tabla,
int nivel);
/*========================================================
Elimina de la tabla todas las variables (simples y vectores)
que sean del nivel del argumento.
IMPORTANTE: No elimina parametros ni valores resultado de
funciones.
========================================================*/
/*========================================================*/
void eliminar_parametros_ocultos (TABSIM tabla,
int nivel);
/*========================================================
Elimina de la tabla todas los parametros que hayan sido
ocultados previamente.
IMPORTANTE: Los procedimientos y funciones donde los
parametros ocultos estaban declarados, deben ser eliminados
para mantener la coherencia de la tabla.
========================================================*/
/*========================================================*/
void eliminar_procedimientos (TABSIM tabla,
int nivel);
/*========================================================
Elimina de la tabla todas los procedimientos de un nivel.
IMPORTANTE: Los parametros ocultos de estos procedimientos
deben ser eliminados para mantener la coherencia de la
tabla.
========================================================*/
/*========================================================*/
void eliminar_funciones (TABSIM tabla,
int nivel);
/*========================================================
Elimina de la tabla todas las funciones de un nivel.
IMPORTANTE: Los parametros ocultos de estas funciones deben
ser eliminados para mantener la coherencia de la tabla.
-8-
Compiladores I
========================================================*/
/*========================================================*/
char *valor(TABSIM tabla,
char *identificador);
/*========================================================
Devuelve un puntero a un string con el contenido del
s'imbolo. Depende del usuario tratar posteriormente de
acuerdo con el tipo. Si el simbolo no se encuentra en
la tabla, el valor queda indefinido
========================================================*/
/*========================================================*/
void mostrar_tabla (TABSIM tabla);
/*========================================================
Muestra en pantalla el contenido de la tabla de simbolos.
Los simbolos aparecen agrupados segun su posicion en la
lista de colision de cada elemento de la tabla hash. Para
cada simbolo se da informacion del nombre de su
identificador, el tipo de simbolo, el tipo de variable, la
clase de variable, el nivel del simbolo y la direccion
asignada.
IMPORTANTE: Para cada procedimiento o funcion se da tambien
informacion de los parametros que le han sido asociados.
Asi que los simbolos de tipo parametro aparecen DOS VECES en
la descripcion del contenido de la tabla. Sinembargo, en la
tabla aparecen una sola vez.
========================================================*/
-9-
Compiladores I
Ejercicio 1 (3.0 ptos.): Considrese la siguiente parte de una gramtica para un

lenguaje de programacin:
%token tTPENTERO tTPCARACTER tTPBOOLEANO
%token tIDENTIFICADOR tVAL tREF
%union{
.....
}
parametrosFormales:
|
'(' listaParametros ')'
;
listaParametros:
listaParametros ';' parametros
|
parametros
;
parametros:
claseParametros declaracionParametros
;
declaracionParametros:
listaID : tipo
;
listaID:
listaID , tIDENTIFICADOR
|
tIDENTIFICADOR
;
tipo:
tTPENTERO
|
tTPCARACTER
|
tTPBOOLEANO
;
claseParametros:
tVAL
|
tREF
;
Asumimos definidos los siguientes tipos:

typedef enum {VALOR,REFERENCIA} clasesDeParametros;
typedef enum {INT,BOOL,CHAR} tiposDeVariables;
typedef .... simbolo,*ptSimbolo;
Se dispone tambin del siguiente procedimiento para insertar un parmetro en la

tabla de smbolos:
ptSimbolo *insertaParametro(
TABLA *laTabla,
char *elID,
clasesDeParametros laClase,
tiposDeVariables elTipo);
-1-
Compiladores I
Se pide definir los atributos y escribir las acciones que se consideren oportunas
para insertar los parmetros en la tabla.
-2-
Compiladores I
Ejercicio 2 (4.0 ptos.): Proveniente de una mala exportacin de datos de una base
de datos, disponemos de dos ficheros de texto: datos.txt y memos.txt. El
primero de ellos contiene la informacin de los campos de una base de
almacenamiento de topnimos; el segundo,
contiene informacin
complementaria para algunos de los registros contenidos en el fichero inicial.
El siguiente ejemplo muestra parte del fichero de datos:
#ABAD DE AYE.,PIA.DEL BENEFICIO#,#ABAD DE AYE.,PIA DEL
BENEFICIO#,1591,#ZARE#,#OIBARRIBAR#,#PRA#,#JUAN DE
SOLA(ZAHARRA)#,#OIBAR#,#K.5(1591)#,1
#ABAD VIEJO,CASA#,#ABBAD
BIEJO,CASSA#,1654,#ZOROKIAIN#,#UNTZITIBAR#,#PRA#,#M.VERA(GAZTEA)
#,#ELO#,#2.K
-BIS(1652-56)#,13059
#ABAD,CORRALES DEL#,#ABBAD,CORRALES
DEL#,1585,#ZARE#,#OIBARRIBAR#,#PRA#,#JUAN DE
SOLA(ZAHARRA)#,#OIBAR#,#K.3-BIS(1585-7)#,2
#ABAD,PIEZA DEL#,#ABBAD,PIEZA
DEL#,1591,#EZPOROGI#,#OIBARRIBAR#,#PRA#,#JUAN
DE SOLA(ZAHARRA)#,#OIBAR#,#K.5(1591)#,3
#ABAD,PIEZAS DEL#,#ABAD,PIAS
DEL#,1591,#EZPOROGI#,#OIBARRIBAR#,#PRA#,#JUAN
DE SOLA(ZAHARRA)#,#OIBAR#,#K.5(15191)#,9900
#ABADIA#,#ABADIA#,1897,#EPAIZ#,#OIBARRIBAR#,##,##,##,#1897KO
KATASTROA#,
#ABADIA DE ABAIZ,PIEZAS DE LA#,#ABADIA DE ABAIZ,PIEZAS DE
LA#,1824,#ESLABA#,#OIBARRIBAR#,#PRA#,#ANTONIO ORTIZ#,#SAN MARTIN
UNX#,#K.84(1824-25)#,9630
La informacin es como sigue. Cada registro de la base contiene 10 campos, de los

cuales el ltimo puede estar vaco en algunas ocasiones. Los campos son los
siguientes:
c1:
forma normalizada del topnimo
c2:
forma antigua del topnimo
c3:
ao del documento que recoge la forma antigua
c4:
pueblo al que hace referencia el documento
c5:
valle donde se ubicaba el pueblo
c6:
archivo en que se ha localizado el documento
c7:
notario que redact el documento con la forma
antigua
c8:
pueblo del notario
c9:
cdigo del documento donde se ha localizado la
forma
c10: ndice que se asigna al registro, y que se
utiliza
para
referenciar
a
la
informacin
complementaria que se encuentra en el fichero
-3-
Compiladores I
memos.txt. No todas las formas tienen este ndice

(fijarse en el registro de ABADIA del ejemplo).
Veamos un ejemplo de registro tomado del fichero anterior:

c1:
c2:
#ABAD VIEJO,CASA#
#ABBAD
BIEJO,CASSA#
c3:
1654
c4:
#ZOROKIAIN#
c5:
#UNTZITIBAR#
c6:
#PRA#
c7:
#M.VERA(GAZTEA)#
c8:
#ELO#
c9:
#2.K
-BIS(1652-56)#
c10: 13059
Notar que:
1) Los campos van separados por una coma
2) Todos los campos, excepto los numricos (ao e ndice), se encuentran
delimitados por # (estos caracteres no forman parte del contenido del campo,
sino que han sido introducidos al exportar los datos de la base antigua, y
debern ser eliminados en el momento de llevar a cabo la transformacin de
formatos)
3) Siempre hay al menos un salto de lnea despus de cada registro
4) Debido a una mala introduccin de datos, algunos campos no numricos
contienen tabuladores y saltos de lnea; en el momento de cambiar los
formatos, los tabuladores y saltos de lnea dentro de campos debern ser
cambiados por un blanco
-4-
Compiladores I
Se pide escribir un programa de acuerdo a las siguientes especificaciones:

1) El programa transforma los datos tomados de stdin (se asume suministrados
de acuerdo al formato del fichero datos.txt descrito anteriormente) y escribe
por stdout los mismos datos, pero transformados de acuerdo al formato que
se describe a continuacin
2) El formato de salida almacena cada registro en una lnea, separando los
campos por tabuladores. Notar que esto exige que los campos originales que
contengan tabuladores o saltos de lnea sean procesados
3) En la salida, el orden de los campos ha de ser el mismo que aparece en la
descripcin del contenido del fichero datos.txt
4) Finalizada la transformacin, el programa debe informar de cuntos registros
han sido procesados
Es necesario desarrollar el fuente Lex que describa el analizador lxico, el fuente
Yacc con la gramtica y las acciones necesarias, y el fichero Make que lleve a
cabo la generacin del ejecutable que realiza lo que se pide. Proponer tambin
la recuperacin de errores sintcticos que considereis oportuna.
Ejercicio 3 (3.0 ptos.): Considerar la siguiente gramtica (en negrita los
terminales):
S P
P E
| q
M n
E ,
| E
O u
| u
E
O
, O
Probar que se trata de una gramtica NO LL(1). Si es posible, realizar las

transformaciones precisas para convertirla en LL(1) y, construyendo la tabla
del anlisis LL(1), demostrar que la gramtica transformada es efectivamente
de esta clase. Es necesario justificar las transformaciones que se realicen. Si no
fuera posible transformarla en LL(1), explicar la razn.
3 horas
-5-
Compiladores I
Ejercicio 1 (6.0 ptos.)

Considrese el autmata que se muestra en la figura (donde el hexgono
representa su estado inicial).
Huesca
t1
t2
Zaragoza
Madrid
t4
t6
t5
t3
Pamplona
Una herramienta grfica que es capaz de dibujar autmatas de esta clase genera
una descripcin textual del autmata, con el fin de que pueda ser utilizada por
otros programas. La descripcin que se acaba de citar, adems de la informacin
estrictamente necesaria, saca otro tipo de informacin que no tiene, en un
principio, nada que ver con la propia descripcin del autmata.
Para el autmata de la figura la salida de la herramenta de edicin se presenta
en el apndice que puedes encontrar al final del enunciado.
Si bien la descripcin contiene informacin redundante, hay que decir que toda
la informacin necesaria para conocer el autmata se encuentra entre las lneas
*** Start of TRG ***
y
*** End of TRG ***
Veamos con ms detalle algunos elementos de la descripcin.
5 Tangible Markings
el autmata tiene 5 estados
From #1 .....
el estado inicial del autmata es siempre el primero en ser descrito
From #5 (1 timed trans)
[ Pamplona ]
-Timed-> t3 -to_tang-> #3
-1-
Compiladores I
el estado 5 se denomina Pamplona y tiene una nica transicin

de salida. Esta transicin se denomina t3 y va al estado 3
El objetivo del ejercicio consiste en realizar un programa que sea capaz de
reconocer, almacenar y procesar un autmata descrito de la manera que se
acaba de comentar. Para ello hay que responder a las siguientes cuestiones:
1)
2)
Definir las estructuras de datos necesarias para poder almacenar la

informacin de un autmata
Escribir (en Yacc) un analizador sintctico para el reconocimiento de
un grafo. Esto requiere lo siguiente:
*
*
3)
escribir (en Lex) un analizador lxico (con las acciones que

consideres oportunas) para ser integrado con el analizador
sintctico que se pide
completar el analizador sintctico con las acciones oportunas
para el almacenamiento del grafo en las estructuras de datos
que has definido en el apartado 1
El programa no slo debe reconocer y almacenar el autmata, sino

que adems debe sacarlo por la salida estandar en el siguiente
formato (se muestra cmo sera la salida para el ejemplo):
estado inicial: Huesca

(Huesca,Madrid,t2)
(Huesca,Zaragoza,t1)
(Madrid,Vitoria,t6)
(Madrid,Pamplona,t5)
(Pamplona,Zaragoza,t4)
(Zaragoza,Madrid,t3)
Determina si la gramtica que has propuesto en el ejercicio anterior es LL(1). Si
no lo es, transformarla en una equivalente que s lo sea.
Sea G=(N,T,S,P) una gramtica libre de contexto. Sea HN el conjunto definido
como sigue: H={ XN | XXP }. Sea por otra parte PH={ XXP | XH }.
Consideremos ahora la gramtica G=(N,T,S,P), donde P=P \ PH.
Probar que G y G son gramticas equivalentes.
-2-
Compiladores I
3 horas
-3-
Compiladores I
Apndice: Descripcin del autmata generada por la herramienta grfica

Place invariants for net COMPIJul98:
S1
S2
S3
S4
S5
ALL places are covered by some P-invariant
Start Reachability Graph construction
0.0u 0.0s 0:00 23% 0+0k 0+3io 0pf+0w
*** Tangible Reachability Graph of net COMPIJul98 ***
5 Tangible Markings
0 Vanishing Markings
0 ECS
Actual Conflict Sets:
Initial marking is #1 :
[ S1 ]
*** Start of TRG ***
5 Tangible Markings
[ Huesca ]
[ Madrid ]
[ Zaragoza ]
[ Vitoria ]

[ Pamplona ]
*** End of TRG ***
!!!!!! The initial marking #1 is not reachable !!!!!!
-4-
Compiladores I

Ejercicio 1 (1.5 ptos.): Considerar las siguientes gramticas:

G1
G2
A =A
A =
A =B
B =B
B =
Probar formalmente que ambas gramticas son equivalentes

Ejercicio 2 (1.5 ptos.): Considerar el siguiente Autmata Finito
Determinista. Dar una expresin regular que corresponda a dicho
autmata.
1
Ejercicio 3 (5.5 ptos.): Considrese la siguiente gramtica:

G:
S =uBDz
B =Bv
B =w
D =EF
E =y
E =
F =x
F =
1) Construir las tablas del anlisis sintctico SLR, y determinar si se trata

de una gramtica SLR o no
2) Comprobar que se trata de una gramtica no LL(1)
3) Transformarla en una gramtica LL(1), y calcular su tabla de anlisis
LL(1)
-1-
Compiladores I

Ejercicio 4 (1.5 ptos.): Considerar el siguiente cdigo C que corresponde

a un analizador sintctico descendente recursivo. Determinar, a partir
del propio cdigo, cul es la gramtica, y decir si el analizador
funcionar correctamente.
enum token
extern enum token getToken(void);
enum token tok;
void advance()
{
tok=getToken();
}
void eat(enum token t)
{
if(tok==t)
advance();
else
error();
}
void S(void)
{
switch(tok){
case IF:
eat(IF); E(); eat(THEN);
S(); eat(ELSE); S(); break;
case BEGIN:
eat(BEGIN); S(); L(); break;
case PRINT:
eat(PRINT); E(); break;
default:
error();
}
}
void L(void)
{
switch(tok){
case END: eat(END); break;
case SEMI: eat(SEMI); S(); L(); break;
default:
error();
}
}
void E(void)
{
eat(NUM); eat(EQ); eat(NUM);
}
3 horas
-2-
Compiladores I

Ejercicio 1 (6.0 ptos.): Considerar las siguientes gramticas (escritas en

sintaxis Yacc):
/* ESTA ES LA GRAMATICA G1 */
%token tkPRINCIPIO tkFIN A
%%
bloqueInst:
tkPRINCIPIO
listaInst
tkFIN
;
listaInst:
| listaInst inst
| inst
;
inst: A
;
%%
/* ESTA ES LA GRAMATICA G2 */
%%
bloqueInst:
tkPRINCIPIO
listaInst
tkFIN
;
listaInst:
| otraListaInst
;
otraListaInst:
otraListaInst inst
| inst
;
inst: A
;
%%
1.1)
1.2)
1.3)
(1.0 Ptos.) Prueba que ambas gramticas son equivalentes

(1.0 Ptos.) A pesar de ser equivalentes, G1 presenta un conflicto
desplazamiento/reduccin que no aparece en G2. Identifica las
circunstancias bajo las que puede ocurrir tal conflicto, y da una
explicacin de por qu ocurre
(1.75 Ptos.) Construye al autmata SLR(1) para G2, as como las
tablas para dicho anlisis.
-1-
Compiladores I
1.4)

(1.75 Ptos.) Construye el autmata y las tablas del anlisis LR(1)

cannico para la siguiente parte de la gramtica
/* ESTA ES LA GRAMATICA G3, que es parte de G2 */

%%
listaInst:
| otraListaInst
;
otraListaInst:
otraListaInst inst
| inst
;
inst: A
;
%%
1.5)
(0.5 Ptos.) A la vista de los anteriores, Cuntos estados tendra el

autmata LALR(1) de G2?
Ejercicio 2 (4.0 ptos.): El ejercicio trata de traducir a C un programa

escrito en un lenguaje para el tratamiento de expresiones de reales. As,
para una entrada como
constante cx = 1.2 ;
constante cy = 2.1 ;
variables x y ;
x = cx + 27;
y = 64;
x = cy * (x + y);
escribir x;
y = 2.0 * x;
escribir 2*y+y;
deber generar una salida como

#include <stdio.h>
#define cx 1.200000
#define cy 2.100000
float x;
float y;
-2-
Compiladores I

void main(){
x = cx + 27.000000;
y = 64.000000;
x = cy * (x + y);
printf("%f\n", x);
y = 2.000000 * x;
printf("%f\n", 2.000000 * y + y);
}
Notar que:
1)
2)
3)
Todas las variables se declaran como globales

Todas las constantes tienen una precisin de 6 dgitos decimales
La salida se tabula con el objeto de hacer ms legible el cdigo
generado
Para ello se utiliza el analizador lxico y la gramtica Yacc que se

adjuntan en los anexos I y II. El ejercicio pide lo siguiente:
2.1)
2.2)
2.3)
(2.5 Ptos.) Completa la gramtica con aquellas acciones que sean

necesarias para la generacin del cdigo C. Para este apartado
podemos suponer que el cdigo de entrada es completamente
correcto, por lo que no es necesario llevar a cabo ninguna poltica
de recuperacin de errores.
(1.0 Ptos) Inserta las estrategias de recuperacin de errores
sintcticos que consideres oportunas. Para cada caso debes
explicar qu errores tratas de corregir.
(0.5 Ptos.) Escribe el fuente para la herramienta make de Unix
de manera que a partir de los ficheros examen.l y examen.y
genere el ejecutable expr2C que traduce el fuente de
expresiones a C.
Para responder a los apartados 2.1) y 2.2) numera en el propio Anexo II

con la gramtica los puntos donde insertaras el cdigo y escribe aparte
dicho cdigo. Por ejemplo:
......
%union{
?????????
}
#1#
%token tkCONSTANTE tkVARIABLES tkESCRIBIR

%token <elVal>tkREAL
-3-
Compiladores I

......
#1#
float elVal;
.......
Notas:
No olvides entregar el Anexo II numerado
El tiempo es parte del examen, por lo que ste se recoger
exactamente 2:30 horas despus de ser entregado
2:30 horas
Anexo I: Fichero examen.l

%{
/* Fichero: examen.l */
#include "y.tab.h"
#define trata(tk) linepos+=yyleng; return((tk))
extern int lineno,linepos;
%}
separadores
([\t ])+
digito
[0-9]
letra
[a-zA-Z]
constEntera
{digito}+
constReal
{constEntera}("."{constEntera})?
identificador {letra}({digito}|{letra})*
%%
{separadores}
{linepos+=yyleng;}
"variables"
{trata(tkVARIABLES);}
"constante"
{trata(tkCONSTANTE);}
"escribir"
{trata(tkESCRIBIR);}
{identificador}
{strcpy(yylval.laCad,yytext);
trata(tkID);}
{constReal}
{sscanf(yytext,"%f",&yylval.elVal);
trata(tkREAL);}
\n
{linepos = 1;lineno++;}
.
{trata(yytext[0]);}
%%
-4-
Compiladores I

Anexo II: Fichero examen.y

%{
/* Fichero: examen.y */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
%}
%union{
?????????
}
%token tkCONSTANTE tkVARIABLES tkESCRIBIR
%token <elVal>tkREAL
%token <laCad>tkID
%%
programa:
parteConstantes
parteVariables
parteInstruciones
;
parteConstantes:
| decConstantes
;
decConstantes:
decConstantes decConstante
| decConstante
;
decConstante:
tkCONSTANTE
tkID
'='
tkREAL
';'
;
parteVariables:
| tkVARIABLES
decVariables
';'
;
decVariables:
decVariables
tkID
| tkID
;
parteInstruciones:
parteInstruciones instruccion
| instruccion
;
-5-
Compiladores I

instruccion:
instAsignacion ';'
| instEscritura ;'
;
instEscritura:
tkESCRIBIR expr
;
instAsignacion:
tkID '=' expr
;
expr:
term
| '+' term
| '-'
| expr opSum term
;
opSum:
'+'
| '-'
;
term:
factor
| term opMul factor
;
opMul:
'*'
| '/'
;
factor:
tkID
| tkREAL
| '(' expr )';
%%
main()
{
yyparse();
}
-6-
Compiladores I
4 Ing. Informtica
C.P.S. Universidad de Zaragoza
Ejercicio 1 (3.0 ptos.): Considrese la siguiente gramtica que se usa para

el tratamiento de determinado tipo de expresiones:
%{
#include <stdio.h>
#include <string.h>
extern char yytext[];
/*-----------------------------------------------------Se asume que los tipos 'tipos' y 'atrib' se encuentran
definidos, donde corresponda, para su utilizacin.
------------------------------------------------------*/
typedef enum {entero,booleano,error} tipos;
typedef struct{
tipos elTipo;
int elValor;
}atrib;
/*-----------------------------------------------------Aqu cdigo de procedimientos y funciones necesarias
------------------------------------------------------*/
%}
%union{
atrib atributos;
}
%token tkENT tkBOOL tkAND
%type <atributos> exp ter fact
%%
exp:
ter '=' ter
{/*-UNO-*/}
| ter
{/*-DOS-*/}
;
ter:
ter '+' fact
{/*-TRES-*/}
| ter tkAND fact {/*-CUATRO-*/}
| fact
{/*-CINCO-*/}
;
fact:
tkENT
| tkBOOL
| '(' exp ')'
;
%%
{/*-SEIS-*/}
{/*-SIETE-*/}
{/*-OCHO-*/}
*
Slo se pueden sumar enteros; el resultado es un entero.

-1-
Compiladores I
4 Ing. Informtica
*
*
*
El operador AND slo se puede aplicar sobre booleanos; el

resultado es un booleano.
El operador de igualdad '=' slo puede aplicarse sobre elementos
del mismo tipo, y su resultado es siempre un booleano.
En el caso de que aparezca un error de tipos durante el anlisis (es
decir, se viole alguna de las reglas anteriores), el tipo de la expresin
ser error.
Completar las partes de cdigo UNO,...,OCHO que permitan sintetizar

los atributos 'elValor' y 'elTipo' para el smbolo 'exp'.
Se debe entender que '+' corresponde a la suma de enteros, 'AND' a la
conjuncin de booleanos y '=' el operador booleano de igualdad. Se debe
asumir que en caso de que el atributo de tipo sea error el atributo de
valor queda indeterminado.
Nota 1: Se asume que el analizador lxico simplemente devuelve el
token correspondiente y deja en yytext el lexema asociado,
convirtiendo las letras minsculas en maysculas: en el caso de
un entero, yytext contendr la secuencia de dgitos que lo
forman; en el caso de un booleano, contendr o bien "TRUE" o
bien "FALSE".
Nota 2: Por cuestiones de claridad, cada parte de acciones UNO,...,
OCHO slo puede contener una instruccin C. En caso de
necesitar ms, se debe realizar una invocacin a un
procedimiento o funcin con los parmetros adecuados. Por
supuesto, tambin debes escribir el cdigo de estos
procedimientos y funciones.
-2-
Compiladores I
4 Ing. Informtica
Ejercicio 2 (3.5 Ptos.): Considerar ahora la siguiente parte de la

gramtica anterior:
%token tkENT
%%
exp:
ter '=' ter
| ter
;
ter:
ter '+' fact
| fact
;
fact:
tkENT
| '(' exp ')'
;
%%
Construir la tabla del anlisis LL(1) para esta gramtica (o una

equivalente en caso de que sea no LL(1)).
-3-
Compiladores I
4 Ing. Informtica
Ejercicio 3 (3.5 Ptos.): La siguiente gramtica es no SLR(1).

Transformarla en una equivalente que sea SLR(1) y construir el autmata
y las tablas para el anlisis SLR(1) de la gramtica transformada
%token tkID tkOPAS tkVAL
%%
insts:
insts inst
| inst
;
inst:
etiq asig
;
etiq:
| tkID ':'
;
asig:
tkID tkOPAS tkVAL
;
%%
2:00 horas
-4-
Compiladores I

Se desea construir un lenguaje elemental para el manejo de cadenas de

caracteres. Para una primera aproximacin, el lenguaje slo es capaz de
escribir expresiones de cadenas (una expresin es una constante de tipo
cadena o bien la concatenacin, mediante el operador +, de dos ms
cadenas). Un ejemplo de programa en dicho lenguaje sera el siguiente:
start
println "Un refran:"
println "No por mucho madrugar " + amanece + "ms temprano"
end
que debera dar como como salida

Un refran:
No por mucho madrugar amanece ms temprano
1. (1.50 Ptos.) Escribir una gramtica Yacc que genere dicho lenguaje,
teniendo en cuenta que el analizador lxico que utiliza es el
mostrado en el anexo
2. (0.75 Ptos.) Generar el rbol de sintaxis para el programa mostrado,
de acuerdo con la gramtica que habeis escrito en el apartado
anterior
3. (0.5 Ptos.) De acuerdo con el analizador lxico. Es correcto
"\\\"Hola\"" como lexema para una cadena? Por qu? Cul
sera el valor de la variable filtrada una vez ejecutada la
instruccin filtra(yytext,filtrada)?
4. (0.5 Ptos.) De acuerdo con el analizador lxico. Es correcto
"\\\"Hola\" como lexema para una cadena ? Por qu? Cul
sera el valor de la variable filtrada una vez ejecutada la
instruccin filtra(yytext,filtrada)?
5. (1.75 Ptos.) Completar la gramtica de manera que, asociado al
smbolo que corresponda a una expresin, se sintetice un atributo
denominado "valExp" con el valor de la expresin (que ser la
cadena resultante de las concatenaciones involucradas en la
expresin, una vez filtradas adecuadamente).
6. (2.0 Ptos.) Construir las tablas y el autmata del anlisis SLR(1) para
la gramtica definida
7. (1.0 Ptos.) Imaginemos que se aade una nueva instruccin al
lenguaje anterior (la instruccin "print" de semntica parecida a la
-1-
Compiladores I

de la instruccin "println", con la salvedad de que no salta de

lnea despus de imprimir su argumento). Razonar sobre cul sera
el tamao del nuevo autmata SLR(1), en comparacin con el
anterior
8. (2.0 Ptos.) Programar en C un analizador sintctico descendente
recursivo para la gramtica (o una transformada equivalente, en el
caso de no fuera LL(1)) que incluye adems la instruccin "print"
descrita en el apartado anterior
2:15 horas
-2-
Compiladores I

Anexo I: Fichero cadenas.l
%{
/*-------------------------------------------------y.tab.h contiene la definicin de los tokens
tkSTART tkEND tkPRINTLN tkCAD
--------------------------------------------------*/
#include "string.h"
#include "y.tab.h"
extern char filtrada[256];
void filtra(char *cOr,char *cDes){
int i = 1,
j = 0;
while(i <= strlen(cOr)-2){
if(cOr[i] != '\\'){
cDes[j] = cOr[i];i++;j++;
}else{
if(i == strlen(cOr) -2){
}else{
if (cOr[i+1] == '"'){
cDes[j] = '"';i += 2;j++;
}else{
}
}
}
}
cDes[j] = '\0';
}
%}
separadores
%%
{separadores}
"start"
"end"
"println"
\"([^\"\t\n]|\\\")*\"
.
%%
([\t \n])+
{}
{return(tkSTART);}
{return(tkEND);}
{return(tkPRINTLN);}
{filtra(yytext,filtrada);
return(tkCAD);}
{return(yytext[0]);}
-3-
Compiladores I

Ejercicio 1 (4.0 ptos.): Se desea implementar una calculadora con sintaxis

Lisp. El programa debe procesar una secuencia de listas Lisp tomadas de
un fichero que se pasa como parmetro de la invocacin. As, si el
programa se llama calcLisp, la invocacin
calcLisp fichCuentas
ejecutar las operaciones indicadas en el fichero de texto denominado

fichCuentas.
El fichero contiene una secuencia de listas separadas entre s mediante
un ;. Cada lista contiene una expresin aritmtica (en notacin prefija),
y para cada una de ellas se debe escribir el resultado de su expresin
correspondiente por stdout. Para simplificar, asumiremos '+' y '*'
como nicos operadores. En el siguiente ejemplo, la columna de la
derecha muestra la salida para la ejecucin con un fichero con el
contenido de la columna izquierda:
(+ 2 4 6 8 10);
(* (+ 1 2 3) (+ 9 7
1))
;
(+
(* 10 2 3)
25
(* 8 9 (+ 1 1) )
);
(+ 20 -20);
(+ 20);
(* 30);
->
->
->
->
->
->
30
102
229
0
20
3
Para resolver el problema se ha considerado la siguiente gramtica (en

sintaxis Yacc):
%start listas
%token NUMERO
%%
listas :
listas lista ';'
| lista ';'
;
-1-
Compiladores I

lista :
'(' op listSE ')'
;
op :
'+'
| '*'
;
listSE :
listSE SE
| SE
;
SE :
NUMERO
| lista
;
%%
A continuacin se muestra tanto el esqueleto del autmata SLR(1) como

la tabla ACCION (sin completar) para esta gramtica.
ACCION
NUMERO
10
15
11
13
12
14
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Escribir los conjuntos de configuraciones de los nodos

Completar la tabla ACCION. Indicar un desplazamiento al nodo k
como d(k) y una reduccin por la produccin nmero k como
r(k) (la numeracin de producciones se indica en la propia
gramtica, reservando la produccin 0 para Slistas)
Nota: utilizar los nombres de smbolos de la
gramtica dada, sin cambiarlos
-2-
Compiladores I

Ejercicio 2 (4.0 ptos.): Escribir un programa en C que implemente la

calculadora descrita. El programa debe tener las siguientes
caractersticas:
debe implementar un anlisis descendente recursivo
la gramtica debe obtenerse mediante transformaciones de la que se
propone, de manera que sea viable la implementacin del programa
Ejercicio3 (2.0 ptos.): Sea
un alfabeto, y sea r una expresin regular
sobre . Vamos a denotar L(r) el lenguaje generado por la expresin r.

Por otro lado, siendo r y s dos expresiones regulares,
rs representa el lenguaje L(rs)={ vw | v L(r) y w[ L(s)},
formado por las concatenaciones de una cadena de r y una de s
r+s representa el lenguaje formado las cadenas de L(r) L(s)
Probar que r(s+t) = rs+rt
Razonar sobre la siguiente afirmacin: rs si, y slo si, r+s
2:15 horas
-3-
Compiladores I

Ejercicio 1 (5.0 ptos.): Lo que sigue son ejemplos de polinomios en una

nica variable X y de coeficientes reales:
( 2.0 X^5+X^25.0X
( -5.0 )
( -1.0 +3.0X^3 )
^6 )
que representan, respectivamente, los polinomios

-5.0X6+2.0X5+X2
-5.0
-3.0X3-1.0
Hay que tener presente que
un polinomio siempre se escribe entre parntesis
los coeficientes que aparezcan, siempre se escriben con parte entera y
parte decimal
los exponentes son siempre no negativos
a veces, puede no aparecer el coeficiente, en cuyo caso debe
entenderse que es 1.0
los distintos monomios pueden aparecer desordenados (es decir, no
siempre los monomios correspondientes a los mayores exponentes
aparecen ms a la izquierda en la lnea)
la nica variable, X, puede aparecer tanto en mayscula como en
minscula
Se nos pide implementar una calculadora que sea capaz de sumar, restar
multiplicar y dividir dos polinomios. As, por ejemplo,
( 2.0 X^5+X^2-
5.0X
^6 ) + (-1.0 +3.0X^3 )
respresenta la suma de los dos polinomios. En concreto, el ejercicio pide

lo siguiente:
1. Dar una estructura de datos para representar polinomios de grado 10
2. Implementar, utilizando Lex y Yacc, la calculadora (de entre las
operaciones, implementar nicamente la suma de polinomios). Su
2:15 horas
Compiladores I

funcionamiento debe ser tal que para la entrada anterior, escriba:

(-5.0X^6+2.0X^5+3.0X^3+1.0X^2-5.0)
La calculadora debe tratar polinomios de grado 10 por lo que en caso
de detectar un monomio de grado mayor debe ignorarlo.
Ejercicio 2 (1.25 ptos.): Razonar sobre si las siguientes afirmaciones son
correctas o no, justificando las respuestas:
Sea G=(N,T,P,S) una gramtica libre de contexto, y consideremos la
gramtica G, obtenida de G mediante la eliminacin de una de sus
producciones. Entonces,
el lenguaje generado por G es siempre un subconjunto del
lenguaje generado por G
es ms, se da la igualdad de ambos lenguajes si, y slo si, la parte
izquierda de la produccin eliminada es un smbolo no derivable.
Ejercicio 3 (1.25 ptos.): Razonar sobre si las siguientes afirmaciones son
correctas o no, justificando la respuesta:
en una tabla del anlisis LL(1) en cada columna hay por lo menos
un elemento distinto de error
para una gramtica dada, el autmata del anlisis LR(1) es
siempre mayor que el del anlisis LALR(1)
Ejercicio 4 (2.5 ptos.): Construir el autmata y las tablas del anlisis
sintctico SLR(1) para la siguiente gramtica:
%start
%token
%%
A :
a A
;
C :
A C
;
B :
b B
|
;
%%
A
a b c d
a C d
B d
c
2:15 horas
Compiladores I

Ejercicio 1 (3.0 ptos.): Considerar la siguiente gramtica:

%token a b c d
%%
S: X;
X: M a;
X: b M c;
X: d c;
X: b d a;
M: d;
%%
Se pide:
Completar el autmata LALR que se muestra a continuacin,
definiendo los conjuntos de configuraciones que deben aparecer en
los nodos
Escribir las tablas ir_a y accin correspondientes al anlisis LALR
2:15 horas
Compiladores I

Ejercicio 2 (1.0 ptos.): Razonar sobre la siguiente afirmacin:

Sea G=(N,T,P,S) una gramtica libre de contexto que contiene
producciones
Siempre es posible encontrar una gramtica
equivalente sin producciones .
Ejercicio 3 (6.0 ptos.):

Escribir una gramtica libre de contexto, LL(1), que reconozca la
siguiente expresin regular:
((a|b)+.(a|b)*)|(yx*y)
Probar que, efectivamente, se trata de una gramtica LL(1)

Implementar, completamente en C, un analizador sintctico para la
expresin anterior
2:15 horas
Compiladores I

Ejercicio 1 (3.5 ptos.): Como parte de una calculadora matemtica

compleja se desea implementar una herramienta capaz de realizar
operaciones de suma y resta de polinomios en la variable X
(mayscula o minscula). Las operaciones a realizar se especifican en un
fichero de texto. El fichero contiene una secuencia de cuaternas
polinomio,operador,polinomio,=, indicando cada una de estas
cuaternas una operacin a realizar, y estando los elementos en cuatro
lneas consecutivas. El fichero contiene al menos una de estas
operaciones. As, por ejemplo, si el fichero denominado misCuentas
contiene
3X^2
+ x
7.0+2.4X^2
+
-1.0 + 29X^5 X^2
=
x 7.0
X^2 + 2X
=
la invocacin calcula
stdout:
misCuentas genera lo siguiente por
-> +29.00 X^5 +4.40 X^2 8.00

-> +1.00 X^2 -1.00 X^1 7.00
Es preciso tener en cuenta los siguientes requisitos:

los polinomios no superan el grado 15
en la entrada, los monomios no tienen por qu estar ordenados por
grado, pudiendo incluso aparecer varios con el mismo grado
los coeficientes son reales, aunque se pueden escribir, como se ve en
el ejemplo, con parte decimal o sin ella, con signo o sin l e, incluso,
no aparecer (en cuyo caso se ha de entender que es 1.0)
los exponentes son naturales
en caso de no aparecer el exponente en un monomio, se entiende que
ste es 1
notar que en la salida se escriben todos los coeficientes con dos
decimales, con signo (pegado al coeficiente).
Compiladores I

Se pide escribir un analizador lxico en Flex, llamado calcula.l, un

analizador sintctico en Bison, llamado calcula.y, y un fuente para
la utilidad make, llamado calculaMakefile, de manera que la
ejecucin make f calculaMakefile genere el ejecutable
calcula, con el comportamiento especificado.
Ejercicio 2 (2.0 ptos.): Responder a las siguientes cuestiones:
Un desarrollador hace la siguiente propuesta a su jefe, responsable
del proyecto de desarrollo de un nuevo compilador: con el objetivo
de poder dar una informacin ms til en el momento de la
recuperacin de errores sintcticos, es conveniente que cada vez que
el analizador lxico encuentre un comentario, en lugar de comrselo,
devuelva un token tkCOM. Es buena la opcin?
Considerar una gramtica cualquiera G que contiene, entre otras, las
siguientes producciones: X , Y . Razonar sobre la siguiente
afirmacin: Todo analizador SLR(1) para G generar un conflicto
reduccin/reduccin entre las producciones anteriores.
Compiladores I


%token a b c d e
%%
S: X;
X: M a;
X: b M c;
X: b d a;
M: e;
%%
Se pide:
Completar el autmata SLR(1) que se muestra a continuacin,
definiendo los conjuntos de configuraciones que deben aparecer en
los nodos
Escribir las tablas ir_a y accin correspondientes al anlisis
SLR(1)
Notas
1. El examen se punta sobre 8; las prcticas se puntan sobre 2
2. Para aqullos que aprobaran las prcticas en el curso anterior, el
examen se puntuar sobre 10.
2:15 horas
Compiladores I

Ejercicio 1 (1.5 ptos.): Transformar la siguiente gramtica en una

equivalente, eliminando las producciones unitarias:
S
A
B
C
D
E
-->
-->
-->
-->
-->
-->
C
b
S
e
E
g
B a | D
b C
c | d d d
A| f | C
| S A B C
h
Ejercicio 2 (2.5 ptos.): Considerar la siguiente gramtica. Es LL(1)? Es

SLR(1)?
S --> A | b A c | d c | b d a
A --> d
Ejercicio 3 (4.0 ptos.): Estamos definiendo un lenguaje capaz de

manipular listas planas de enteros. Una lista de enteros puede ser o bien
una lista vaca o bien una lista no vaca, que es aqulla que en su interior
contiene al menos un entero. Lo que sigue son ejemplos de listas (en el
programa fuente, los comentarios se indican mediante la marca #,
extendindose desde dicho carcter hasta el final de lnea):
()
(1 2 3 4)
(-56 +23
8)
#la lista vaca

#lista con los primeros enteros
#opcionalmente, puede haber signos
#que van pegados al valor absoluto
Lo que sigue es un pequeo ejemplo de fuente en el lenguaje

considerado.
#Fichero: prueba.le
Vars l: lista := (1 2 3); #puede haber inicializacin
lP: lista;
n: entero;
Principio
lP := listaVacia;
#lP=(),l=(1 2 3),n=???
n := primero(l);
#lP=(),l=(1 2 3),n=1
l := ponPrimero(l,n);
#lP=(),l=(1 1 2 3),n=1
lP := ponPrimero(lP,primero(l)); #lP=(1),l=(1 1 2 3),n=1
l := resto(l);
#lP=(1),l=(1 2 3),n=1
lP := resto(l);
#lP=(2 3),l=(1 2 3),n=1
leer(n);
#lP=(2 3),l=(1 2 3),n=N
2:30 horas
Compiladores I

l := resto(resto(lP));
escribir(resto(lP));
escribir(l);
Fin.
#lP=(2
#lP=(2
#lP=(2
#lP=(2
#lP=(2
3),l=(),n=N
3),l=(N),n=N
3),l=(N),n=N,en stdout (3)
3),l=(N N),n=N
3),l=(N N),n=N,en stdout (N N)
El lenguaje tiene las siguientes caractersticas:

1. Las variables a utilizar han de ser declaradas
2. En la declaracin puede haber, opcionalmente, inicializacin de la
variable
3. Los operadores que maneja son los siguientes:
listaVacia:
Pre: TRUE
Post: listaVacia=()
esVacia(l):
Pre: l=(d1 d2 ... dn), n>=0
Post: esVacia=n=0?
primero(expr):
Pre: expr es una expresin de tipo lista,
expr=(d1 d2 ... dn), n>0
Post: primero=d1
resto(expr):
Pre: expr es una expresin de tipo lista,
expr=(d1 d2 ... dn), n>0
Post: resto=(d2 ... dn)
ponPrimero(l,expr):
Pre: expr es una expresin de tipo entero,
expr=N
l=(d1 d2 ... dn), n>=0
Post:ponPrimero=(N d1 d2 ... dn)
:=: asignacin interna, lo mismo para enteros que
para listas
leer: asignacin externa, lo mismo para variables
enteras que para variables de tipo lista
escribir: salida de resultados por stdout, lo mismo
para expresiones enteros que para expresiones de tipo
lista
vamos a asumir, por cuestiones de simplicidad, que
las nicas expresiones de tipo entero son o bien una
constante entera o bien una variable entera (es
decir, no vamos a sumar, restar, ... enteros)
4. Las invocaciones a operadores que no cumplan la precondicin se

considerarn como errores de tipo semntico
2:30 horas
Compiladores I

5. El acceso a una variable sin inicializar tambin se considerar como

error semntico
El ejercicio desarrolla un analizador de fuentes que, adems de llevar a
cabo el anlisis sintctico haga un poco de anlisis semntico (que a
continuacin se va a detallar). Para ello se pide lo siguiente:
1. Escribir el fichero lEnt.l con el fuente Flex del compilador
descrito.
2. Escribir el fichero lEnt.y con el fuente Bison correspondiente al
analizador sintctico, de manera que la invocacin para procesar el
fichero de listas prueba.le sigue el patrn del siguiente ejemplo:
lEnt prueba.le
Adems del anlisis sintctico debe implementar los siguientes

aspectos del anlisis semntico: el programa debe comprobar,
abortando en caso de detectar algn error
que toda variable que aparezca en la parte izquierda de una
asignacin haya sido declarada previamente.
que en cada asignacin tanto la variable en la parte izquierda
como la expresin en la parte derecha sean del mismo tipo (o
bien ambas son enteros, o bien ambas son de tipo lista).
que en toda expresin, toda variable utilizada ha sido
previamente inicializada.
Nota 1: por simplificar, se puede suponer que en el programa no se
van a manejar nunca ms de 1250 variables, y que los
identificadores no son de ms de 25 caracteres
2:30 horas
Compiladores I

Ejercicio 1 (1.0ptos.): Probar que la siguiente gramtica es LL(1), pero no

SLR(1)
S --> A a A b
S --> B b B a
A -->
B -->
Ejercicio 2 (1.5 ptos.): El Anexo-I muestra el algoritmo para el anlisis

LL(1) basado en el uso de la tabla de anlisis. Dada una secuencia de
terminales, el algoritmo emite la secuencia de producciones aplicadas
para su derivacin, o error si no es capaz de encontrarla. Vamos a
denotar n el nmero de no terminales de la gramtica, y || la longitud
de la secuencia de entrada. Se sabe que, en el caso de que el algoritmo d
respuesta afirmativa, el coste de ejecucin del algoritmo es
(||),(n||). En el clculo de este coste se han considerado como
operaciones de coste constante las siguientes:
obtener la cima de la pila
apilar y desapilar smbolos gramaticales
obtener el siguiente terminal de la sencuencia de entrada
consultar el valor en la tabla correspondiente a un par (no terminal,
terminal)
emitir una produccin
Consideremos ahora la siguiente gramtica:
X1
X2
X3
X4
....
Xn-1
Xn
-->
-->
-->
-->
X2
a2
a3
a4
X2 X2
| X3
| X4
| X5
--> an-1 | Xn
--> an
El ejercicio pide escribir dos frases del lenguaje generado por la

gramtica anterior, 1 y 2, tal que los costes de ejecucin del algoritmo
de reconocimiento sean, respectivamente, del orden de |1| y n|2|.
Cul puede ser el coste del algoritmo, en el mejor y el peor caso, cuando
se aplica a una frase que no es reconocida por el anlisis LL(1)?
2:45 horas
Compiladores I

Nota: en todos los casos, la respuesta debe ser razonada.

Ejercicio 3 (5.5) ptos.): Se desea construir un intrprete para un lenguaje
muy sencillo. Dicho lenguaje maneja cadenas de caracteres, y es capaz de
asignarlas a variables, realizar la operacin de concatenacin y escribir
por salida estndar expresiones que involucran cadenas.
vars a b c;
start
print("Un refran:");
a="No por mucho ";
b=""" madrugar""";
a=a+b;
print("a: " + a);
c=b+b+b+" no es sano";
print("res: " + c + " por mucho que te empees");
print("a:");
print(a);
end
cuya ejecucin dar como salida

Un refran:
a: No por mucho " madrugar"
res: " madrugar"" madrugar"" madrugar" no es sano por mucho que te empees
a:
No por mucho " madrugar
Detallemos un poco ms sus caractersticas:

1. las variables que se van a utilizar han de ser declaradas previamente
(mediante la palabra reservada vars), y todas ellas son capaces de
almacenar una cadena de hasta 300 caracteres.
2. en su representacin externa, una constante de tipo cadena va entre
dobles comillas. Entre ellas puede ir cualquier secuencia de 0 ms
caracteres distintos del salto de lnea o tabulador ('\n','\t') ;
cuando se desea representar unas dobles comillas como parte del
contenido de la cadena, stas se han de poner por duplicado (ver la
asignacin a la variable b en el programa de ejemplo).
2:45 horas
Compiladores I

3. adems de la asignacin y la escritura, es posible realizar la

concatenacin de cadenas, que se representa externamente mediante
el operador '+'.
4. el lenguaje distingue entre maysculas y minsculas
El ejercicio pide construir el intrprete completo: analizador lxico en
Flex, sintctico en Bison con las acciones necesarias para que el cdigo
sea ejecutado. El intrprete debe ser tal que, si el programa fuente
anterior se llama entradaCadenas.cadla invocacin sea
trataCadenas entradaCadenas.cad
Se valorar, adems, el hecho de que el programa detecte algunos

errores semnticos importantes.
2:45 horas
Compiladores I

Anexo-I
M:Nx(T{})2P:tabla de anlisis sintctico LL(1)
La frase a analizar termina con $
Post: Muestra la secuencia de producciones aplicadas en
el anlisis o ERROR
Pre:
Variables p:pila de smbolos gramaticales

sigTok,X:token
Principio
pilaVacia(p);sigTok=yylex()
push(p,$,S)
--S es el smbolo inicial de la gramtica
Repetir
X=cima(p)
Si X es terminal X=$
Si X=sigTok
pop(p)
sigTok=yylex()
Si no
errorSintctico()
FSi
Si no
Si M[X,sigTok]= XY1... Yk
pop(p)
push(p,YkYk-1... Y1)
emitir produccin XY1... Yk
Si no
errorSintctico()
FSi
FSi
Hasta Que X=$
Fin
2:45 horas
Compiladores I

Ejercicio 1 (1.25 ptos.): Considerar los siguientes fuentes

/*-----------------------------prueba.l
------------------------------*/
%{
#include "y.tab.h"
%}
%%
[a-zA-Z]+ {return(tkID);}
.
\n
%%
/*-----------------------------prueba.y
------------------------------*/
%{
#include <stdio.h>
extern char *yytext;
%}
%token tkID
%%
F: tkID
{printf("0: %s\n",yytext);}
'.'
| tkID
'('
')'
'.'
;
%%
int main(){
yyparse();
}
Explicar razonadamente cules sern las salidas de la ejecucin del

programa generado a partir de dichos fuentes para las siguientes
entradas:
UNO.
UNO().
2:45 horas
Compiladores I

Ejercicio 2 (1.25 ptos.): Escribir una gramtica libre de contexto que

genere el subconjunto del lenguaje generado por la expresin regular
a*b* que contengan ms veces la a que la b. Razonar sobre la correccin
de la solucin dada.
%%
A:
|
;
B:
|
|
;
%%
A B
B
B '*'
'(' A ')'
'x'
Se pide:
1. Construir el autmata y las tablas del anlisis LALR(1)
2. Tranformarla en una equivalente que sea LL(1), y calcular la tabla
del anlisis LL(1) de la transformada
Ejercicio 4 (3.0 ptos.): Un grafo dirigido se define como una estructura
compuesta por dos tipos de elementos, arcos y nodos. Los arcos son
pares formados por nodos. Tanto arcos como nodos pueden tener
informacin asociada.
La figura 2 muestra la descripcin textual del grafo de la figura 1 (que en
este caso es un autmata finito) que genera una herramienta para la
manipulacin de grafos dirigidos.
2:45 horas
Compiladores I

0-9
0-9
0-9
.
4
0-9
0-9
Figura 1: Un autmata
numeroReal
graph [
node [
id 1
parameter
]
node [
id 2
parameter
]
node [
id 3
parameter
]
node [
id 4
parameter
]
node [
id 5
parameter
]
edge [
source 1
target 2
parameter
]
edge [
source 1
target 4
parameter "."
"inicial"
""
"final"
""
"final"
"0-9"
]
]
edge [
source 2
target 2
parameter
]
edge [
source 2
target 3
parameter
]
edge [
source 3
target 3
parameter
]
edge [
source 4
target 5
parameter
]
edge [
source 5
target 5
parameter
]
"0-9"
"."
"0-9"
"0-9"
"0-9"
Figura 2: Descripcin textual del autmata de la figura 1
2:45 horas
Compiladores I

El ejercicio pide lo siguiente:

1. Definir las estructuras de datos necesarias para almacenar la
informacin asociada a un grafo, de acuerdo con lo que se deduce
del ejemplo anterior
2. Escribir los fuentes flex y bison necesarios para poder generar el
programa grafo que lee y almacena la descripcin de un grafo a
partir de un fichero de entrada cuyo nombre se pasa como
parmetro en la invocacin del programa
Nota: se puede asumir que trabajaremos siempre con grafos
de no ms de 300 nodos y no ms de 3000 arcos.
2:45 horas
Compiladores I

Ejercicio 1 (1.0 ptos.): Demostrar que toda gramtica libre de contexto

sin producciones epsilon y tal que cada alternativa empieza siempre por
un terminal distinto es siempre LL(1).
Ejercicio 2 (3.0 ptos.): Considerar la siguiente gramtica
%token a
%%
S: a S a | a a;
1. Qu lenguaje genera?
2. Construir el autmata y las tablas del anlisis LALR(1).
3. Est claro que no es una gramtica LL(1). Tranformarla en una
equivalente que s lo sea, y probar formalmente que la transformada
es de la clase LL(1).
Ejercicio 3 (4.0 ptos.): Los anexos I y II contienen los fuentes
(incompletos) Flex y Bison de un programa para la evaluacin del tipo
de expresiones aritmticas sencillas. En lugar de hacer una evaluacin
al vuelo del atributo TIPO, se va a hacer mediante la construccin y
posterior evaluacin del rbol de sintaxis correspondiente a la expresin.
El tipo de una operacin binaria (+, -, *, /) se determina como sigue a
partir de los tipos de sus operandos: si ambos operandos son enteros, el
resultado es ENTERO; si ambos son reales, el resultado es REAL; si son
de tipos distintos, el tipo del resultado es DESCONOCIDO. Las figuras 1
y 2 muestran un ejemplo de rbol de sintaxis para una expresin una vez
ha sido generado y despus de sintetizar el atributo de tipo,
respectivamente. Para ello se utiliza el TAD especfico definido en el
anexo III.
El ejercicio pide:
Completar los puntos /* 1 */ a / * 8 */ de los anexos I y II de forma
que se genere el rbol de sintaxis.
Escribir el cdigo de la funcin
TIPOS_ESCALARES evaluaTipo(ptArbolSintaxis p)
que, dado un rbol de sintaxis, sintetiza el tipo en cada uno de sus

nodos, teniendo en cuenta las reglas para tipos que se han establecido
arriba.
2:30 horas
Compiladores I

laExp
(EXPR,*,*,
(OP_BIN,*,*,
(EXPR,*,*,
,NULL)
(TERMINO,*,*,
,NULL)
(FACTOR,*,*,
,NULL)
,NULL)
(TERMINO,*,*,
,NULL)
(FACTOR,*,*,
,NULL)
(CONST_REAL,*,*,NULL,NULL)
(CONST_ENT,*,*,NULL,NULL)
Figura 1: rbol de sintaxis decorado para la entrada 3 + 4.5, previo

a la evaluacin del atributo de tipo.
2:30 horas
Compiladores I

laExp
(EXPR,DESCONOCIDO,*,
,NULL)
(OP_BIN,DESCONOCIDO,*,
(EXPR,ENTERO,*,
,NULL)
(TERMINO,ENTERO,*,
,NULL)
(FACTOR,ENTERO,*,
,NULL)
(TERMINO,REAL,*,
,NULL)
(FACTOR,REAL,*,
,NULL)
(CONST_REAL,REAL,*,NULL,NULL)
(CONST_ENT,ENTERO,*,NULL,NULL)
Figura 2: rbol de sintaxis decorado para la entrada 3 + 4.5 una vez

que se ha evaluado el atributo de tipo.
2:30 horas
Compiladores I

ANEXO-I
%{
#include "y.tab.h"
#include "arbolSintaxisExp.h"
%}
/*EXPRESIONES REGULARES*/
separadores
[\t ]+
digito
[0-9]
letra
[a-zA-Z]
constEntera
{digito}+
constReal
{constEntera}"."{constEntera}
%%
{separadores} {/*nada*/}
{constReal} {
/* 1 */
return(tkREAL);}
{constEntera}
{
/* 2 */
return(tkENTERO);}
\n
{/*nada*/}
.
%%
2:30 horas
Compiladores I

ANEXO-II
%{
#include <stdio.h>
#include <stdlib.h>
ptArbolSintaxis laExp;
%}
%union{
ptArbolSintaxis elArbol;
}
%token <elArbol>tkREAL
%token <elArbol>tkENTERO
%type <elArbol>expr
%type <elArbol>term
%type <elArbol>factor
%type <elArbol>term
%left '-' '+'
%left '*' '/'
%%
expr:
term
{ /* 3 */ }
| expr opSum term
{ /* 4 */ }
;
opSum:
'+'
| '-'
;
term:
factor
{ /* 5 */ }
| term opMul factor
{ /* 6 */ }
;
opMul:
'*'
| '/'
;
factor:
tkREAL
{ /* 7 */ }
| tkENTERO
{ /* 8 */ }
;
%%
int main()
{ TIPOS_ESCALARES elTipoFinal;
yyparse();
elTipoFinal = evaluaTipo(laExp);
printf("Tipo de la expresin: ");
muestraTipo(elTipoFinal);
liberaArbol(laExp);
exit(0);
2:30 horas
Compiladores I

ANEXO-III
/*================================================================
Fichero: arbolSintaxisExp.h
Tema:
TAD para el manejo de rboles de sintaxis de expresiones
simples
Version: 1.0
Fecha:
Jumio-02
Autor:
Joaquin
Com.:
Ejercicio para construir rboles de sintaxis
=================================================================*/
typedef enum {
OP_UN,OP_BIN,CONST_ENT,CONST_REAL,EXPR,TERMINO,FACTOR
} CLASE_DE_NODO;
typedef enum {ENTERO,REAL,DESCONOCIDO} TIPOS_ESCALARES;
typedef struct NODO {
CLASE_DE_NODO laClaseDeNodo;
TIPOS_ESCALARES elTipo;
union {
float valReal;
int valEnt;
} elValor;
struct NODO *expDcha;
struct NODO *expIzda;
} arbolSintaxis,*ptArbolSintaxis;
ptArbolSintaxis creaArbol(CLASE_DE_NODO laClase);
/* Pre:
Post: creaArbol = (laClase,*,*,NULL,NULL)
*/
void liberaArbol(ptArbolSintaxis p);
/* Pre:
p = (lC,eT,eV,eI,eD)
Post: p = NULL, la memoria ocupada por los elementos
del rbol se ha liberado
*/
void ponElTipo(ptArbolSintaxis p,TIPOS_ESCALARES t);
/* Pre:
Post: p = (lC,t,eV,eI,eD)
*/
void ponValorReal(ptArbolSintaxis p,float r);
/* Pre:
Post: p = (lC,eT,r,eI,eD)
*/
void ponValorEntero(ptArbolSintaxis p,int n);
/* Pre:
Post: p = (lC,eT,n,eI,eD)
*/
void ponExpIzda(ptArbolSintaxis p,ptArbolSintaxis e);
/* Pre:
Post: p = (lC,eT,eV,e,eD)
*/
void ponExpDcha(ptArbolSintaxis p,ptArbolSintaxis e);
/* Pre:
Post: p = (lC,eT,eV,eI,e)
*/
void ponClaseDeNodo(ptArbolSintaxis p,CLASE_DE_NODO c);
2:30 horas
Compiladores I

/* Pre:
Post: p = (c,eT,eV,eI,eD)
*/
CLASE_DE_NODO dameLaClaseDeNodo(ptArbolSintaxis p);
/* Pre:
Post: dameLaClaseDeNodo = lC
*/
TIPOS_ESCALARES dameElTipo(ptArbolSintaxis p);
/* Pre:
Post: dameElTipo = eT
*/
ptArbolSintaxis dameSubexpIzda(ptArbolSintaxis p);
/* Pre:
Post: dameSubexpIzda = eI
*/
ptArbolSintaxis dameSubexpDcha(ptArbolSintaxis p);
/* Pre:
Post: dameSubexpDcha = eD
*/
TIPOS_ESCALARES evaluaTipo(ptArbolSintaxis p);
/* Pre:
Post: sintetiza el atributo elTipo para cada uno de los nodos del
rbol,
evaluaTipo = el tipo del nodo raz (ver enunciado)
*/
void muestraTipo(TIPOS_ESCALARES t);
/* Pre:
Post: imprime en stdout informacin sobre el tipo t
*/
2:30 horas
Compiladores I

Ejercicio 1 (2.0 ptos.): Considerar la siguiente gramtica para el

tratamiento de un subconjunto muy simple de expresiones:
exp:
exp:
exp:
exp:
tkENTERO;
tkID;
exp '+' exp;
tkID '(' exp ')';
Asumiendo que la funcin yylex (definida como int yylex()tal y

como la genera Flex) devuelve el siguiente token, escribir en C un
analizador descendente recursivo que reconozca el mismo lenguaje que
la gramtica dada.
Ejercicio 2 (2.0 ptos.): Escribir el algoritmo que se especifica a
continuacin, y estimar su coste de ejecucin:
Funcin derivaEpsilon(E G: GLC) Dev (dE:booleano)
--Pre: G=(N,T,P,S) es una gramtica libre de contexto
--Post: dE = e L(G)?
2:00 horas
Compiladores I

Ejercicio 3 (2.0 ptos.): Razonar sobre la verdad o falsedad de las

siguientes afirmaciones:
Sea G una gramtica libre de contexto tal que contiene las producciones
X a , Y a.
un analizador SLR(1) siempre encontrar un conflicto
reduccin/reduccin cuando a se encuentre en la cima de la
pila.
un analizador SLR(1) nunca encontrar un conflicto
reduccin/reduccin cuando a se encuentre en la cima de la
pila.
Ejercicio 4 (2.0 ptos.): Considerar la siguiente gramtica, ampliada de la
propuesta en el primer ejercicio,
SP: exp;
exp: tkENTERO;
exp: tkID;
exp: exp '+' exp;
exp: tkID '(' exp ')';
Construir las tablas del anlisis SLR(1), y determinar si la gramtica

pertenece a dicha clase o no.
2:00 horas
Compiladores I

Ejercicio 1 (3.0 ptos.): Lo que sigue son ejemplos de polinomios en una

( 2.0X^5+X^2-5.0X^6 )
( -5.0 )
( -1.0 +1.0X^3 )
-5.0X6+2.0X5+X2
-5.0
X3-1.0
En la descripcin de un polinomio hay que tener presente que:
1. un polinomio siempre se escribe entre parntesis.
2. los coeficientes que aparezcan siempre se escriben con parte entera
y parte decimal.
3. el signo y el valor absoluto de un coeficiente nunca llevan
separadores entre ellos.
4. los exponentes son siempre no negativos.
5. a veces, puede no aparecer el coeficiente, en cuyo caso debe
entenderse que es 1.0.
6. los distintos monomios pueden aparecer desordenados (es
decir, no siempre los monomios correspondientes a los mayores
exponentes aparecen ms a la izquierda en la lnea).
7. la nica variable, X, puede aparecer tanto en mayscula como
en minscula.
Como parte del desarrollo de un programa que trabaja con
polinomios se nos ha suministrado el siguiente cdigo.
typedef float tpPolinomio[11];
int elToken;
. . .
int main(){
tpPolinomio elPol;
inicializaPol(&elPol); /*todo ceros*/
elToken = yylex();
02:45
Compiladores I

polinomio(&elPol);
escribePol(&elPol);
fprintf(stdout,Anlisis correcto\n);
}

Dar una gramtica LL(1) para la parte de anlisis sintctico
Mediante la construccin de la tabla del anlisis LL(1), comprobar
que la gramtica propuesta es, efectivamente, de dicha clase.
Completar el cdigo incompleto que se ha mostrado arriba. Para
ello, hay que escribir el fuente Flex para la parte del anlisis lxico e
implementar un analizador sintctico descedente recursivo. Las
acciones semnticas se limitarn a rellenar los datos del polinomio.
Su funcionamiento debe ser tal que para una entrada como
( 2.0X^5
+X^2 -5.0X^6 )
escriba
-5.0X^6+2.0X^5+1.0X^2
La calculadora debe tratar polinomios de grado 10, por lo que en
caso de detectar un monomio de grado mayor debe simplemente
ignorarlo.
Ejercicio 2 (3.0 ptos.): Para una gramtica, descrita en el fichero bison
denominado examen.y, la invocacin a bison con la opcin -v ha
generado el fichero examen.output con la descripcin (parcial) del
autmata LALR(1). El contenido de dicho fichero es el mostrado en el
Anexo I. En la descripcin de un nodo del autmata no se almacena el
conjunto de configuraciones completo, sino la informacin necesaria
para poder completar el correspondiente conjunto de configuraciones.
Deducir cul es la gramtica original en el fichero examen.y.
Dibujar completo el autmata LALR(1) correspondiente a dicha
gramtica.
Construir completas las tablas del anlisis LALR(1) correspondiente
a la gramtica considerada.
Determinar si la gramtica dada es de la clase LALR(1). En caso de
no serlo, transformarla en una equivalente que s lo sea.
02:45
Compiladores I

Ejercicio3 (2.0 ptos.): Sea
un alfabeto, y sea r una expresin regular
sobre . Vamos a denotar L(r) el lenguaje generado por la expresin r.

Por otro lado, siendo r y s dos expresiones regulares,
rs representa el lenguaje L(rs)={ vw | v L(r) y w L(s)}, formado
por las concatenaciones de una cadena de r y una de s
r+s representa el lenguaje formado las cadenas de L(r) L(s)
siendo n un nmero natural, rn representa el lenguaje generado la
concatenacin de n cadenas del lenguaje generado por r
siendo n un nmero natural, nr representa el lenguaje generado la
(r+r+...n veces...+r)
El ejercicio pide razonar sobre la correccin o incorreccin de las
siguientes afirmaciones, donde r, s, t son expresiones regulares:
r(s+t) = rs+rt
rs si, y slo si, r+s
(r+s)2 = r2 + s2 + 2rs
02:45
Compiladores I

ANEXO-I
state 0
0 $accept: . S $end
q
','
S
A
C
shift, and go to state 1

go to state 3
go to state 4
go to state 5
state 1
3 A: q .
$default
reduce using rule 3 (A)
state 2
5 C: ',' . D
u
go to state 7
state 3
0 $accept: S . $end
$end
state 4
1 S: A . B
n
go to state 10
state 5
02:45
Compiladores I

2 A: C .
6 C: C .
n
n
$default

[reduce using rule 6 (C)]
state 6
7 D: u .
8 | u . ',' D
','
$default
reduce using rule 7 (D)
state 7
5 C: ',' D .
$default
reduce using rule 5 (C)
state 8
0 $accept: S $end .
$default
accept
state 9
4 B: n . C
','
C

go to state 12
state 10
1 S: A B .
$default
reduce using rule 1 (S)
state 11
02:45
Compiladores I

8 D: u ',' . D
u
go to state 13
state 12
4 B: n C .
6 C: C .
$end
$end
$default
reduce using rule 4 (B)

[reduce using rule 6 (C)]
reduce using rule 4 (B)
state 13
8 D: u ',' D .
$default
reduce using rule 8 (D)
02:45
Compiladores I


%token a b c
%%
S: A a A b S;
S: B b B a;
S: c;
A: ;
B: ;
%%
El ejercicio pide:
Qu lenguaje genera?
Obtener la tabla del anlisis LL(1), y concluir si se trata de una
gramtica de esa clase.
Obtener el autmata y las tablas del anlisis LALR(1), y determinar
si se trata de una gramtica de la clase LALR (1) o no.
Ejercicio 2 (2.0 ptos.): Considerar la siguiente gramtica libre de
contexto, denominada G:
%token
%%
S: b A
A: a b
B: b a
a b
| a B |;
a S;
b S;
El ejercicio pide:
Se trata de una gramtica regular ? (una gramtica es regular si el
lenguaje que genera es un lenguaje regular).
Si es una gramtica regular, dar un autmata finito determinista
mnimo cuyo lenguaje sea el mismo que el generado por dicha
gramtica. Dar tambin la expresin regular correspondiente a
dicho autmata.
02:15
Compiladores I

Ejercicio 3 (3.5 ptos.): Los anexos I y II contienen los fuentes

(incompletos) Flex y Bison de un programa para la evaluacin del tipo
de expresiones aritmticas sencillas. En lugar de hacer una evaluacin
al vuelo del atributo TIPO, se va a hacer mediante la construccin y
posterior evaluacin del rbol de sintaxis correspondiente a la
expresin. El tipo de una operacin binaria (+, -, *, /) se determina a
partir de los tipos de sus operandos como sigue: si ambos operandos
son enteros, el resultado es ENTERO; si ambos son reales, el resultado
es REAL; si son de tipos distintos, el tipo del resultado es
DESCONOCIDO. Las figuras 1 y 2 muestran un ejemplo de rbol de
sintaxis para una expresin una vez ha sido generado y despus de
sintetizar el atributo de tipo, respectivamente. Para ello se utiliza el
TAD especfico definido en el Anexo III.
El ejercicio pide:
Completar los puntos /* 1 */ a / * 8 */ de los anexos I y II de

forma que se genere el rbol de sintaxis.
Escribir el cdigo de la funcin

TIPOS_ESCALARES evaluaTipo(ptArbolSintaxis p)
que, dado un rbol de sintaxis, sintetiza el tipo en cada uno de sus

nodos, teniendo en cuenta las reglas para tipos que se han
establecido arriba.
02:15
Compiladores I

laExp
(EXPR,?,?,
(OP_BIN,?,?,
(EXPR,?,?,
(TERMINO,?,?,
(FACTOR,?,?,
,NULL)
,NULL)
,NULL)
,NULL)
(TERMINO,?,?,
(FACTOR,?,?,
,NULL)
,NULL)
(CONST_REAL,?,?,NULL,NULL)
(CONST_ENT,?,?,NULL,NULL)
Figura 1: rbol de sintaxis decorado para la entrada 3 + 4.5,

previo a la evaluacin del atributo de tipo.
02:15
Compiladores I

laExp
(EXPR,DESCONOCIDO,?,
,NULL)
(OP_BIN,DESCONOCIDO,?,
(EXPR,ENTERO,?,
,NULL)
(TERMINO,ENTERO,?,
,NULL)
(FACTOR,ENTERO,?,
,NULL)
(TERMINO,REAL,?,
,NULL)
(FACTOR,REAL,?,
,NULL)
(CONST_REAL,REAL,?,NULL,NULL)
(CONST_ENT,ENTERO,?,NULL,NULL)
Figura 2: rbol de sintaxis decorado para la entrada 3 + 4.5 una

vez que se ha evaluado el atributo de tipo.
02:15
Compiladores I

ANEXO-I
%{
#include "y.tab.h"
%}
/*EXPRESIONES REGULARES*/
separadores
[\t ]+
digito
[0-9]
letra
[a-zA-Z]
constEntera
{digito}+
constReal
{constEntera}"."{constEntera}
%%
{separadores} {/*nada*/}
{constReal} {
/* 1 */
return(tkREAL);}
{constEntera}
{
/* 2 */
return(tkENTERO);}
\n
{/*nada*/}
.
%%
02:15
Compiladores I

ANEXO-II
%{
#include <stdio.h>
#include <stdlib.h>
ptArbolSintaxis laExp;
%}
%union{
ptArbolSintaxis elArbol;
}
%token <elArbol>tkREAL
%token <elArbol>tkENTERO
%type <elArbol>expr
%type <elArbol>term
%type <elArbol>factor
%type <elArbol>term
%left '-' '+'
%left '*' '/'
%%
expr:
term
{ /* 3 */ }
| expr opSum term
{ /* 4 */ }
;
opSum:
'+'
| '-'
;
term:
factor
{ /* 5 */ }
| term opMul factor
{ /* 6 */ }
;
opMul:
'*'
| '/'
;
factor:
tkREAL
{ /* 7 */ }
| tkENTERO
{ /* 8 */ }
;
%%
int main(){
TIPOS_ESCALARES elTipoFinal;
yyparse();
elTipoFinal = evaluaTipo(laExp);
02:15
Compiladores I

printf("Tipo de la expresin: ");

muestraTipo(elTipoFinal);
liberaArbol(laExp);
exit(0);
}
02:15
Compiladores I

ANEXO-III
/*============================================================
Fichero: arbolSintaxisExp.h
Tema:
TAD para el manejo de rboles de sintaxis de
expresiones simples
Version: 1.0
Fecha:
Junio-02
Autor:
J.E.
Com.:
Ejercicio para construir rboles de sintaxis
============================================================*/
typedef enum {
OP_UN,OP_BIN,CONST_ENT,CONST_REAL,EXPR,TERMINO,FACTOR
} CLASE_DE_NODO;
typedef enum {ENTERO,REAL,DESCONOCIDO} TIPOS_ESCALARES;
typedef struct NODO {
CLASE_DE_NODO laClaseDeNodo;
TIPOS_ESCALARES elTipo;
union {
float valReal;
int valEnt;
} elValor;
struct NODO *expDcha;
struct NODO *expIzda;
} arbolSintaxis,*ptArbolSintaxis;
ptArbolSintaxis creaArbol(CLASE_DE_NODO laClase);

/* Pre:
Post: creaArbol = (laClase,*,*,NULL,NULL)
*/
void liberaArbol(ptArbolSintaxis p);
/* Pre:
Post: p = NULL, la memoria ocupada por los elementos
del rbol se ha liberado
*/
void ponElTipo(ptArbolSintaxis p,TIPOS_ESCALARES t);
/* Pre:
Post: p = (lC,t,eV,eI,eD)
*/
void ponValorReal(ptArbolSintaxis p,float r);
/* Pre:
Post: p = (lC,eT,r,eI,eD)
*/
void ponValorEntero(ptArbolSintaxis p,int n);
/* Pre:
Post: p = (lC,eT,n,eI,eD)
*/
void ponExpIzda(ptArbolSintaxis p,ptArbolSintaxis e);
/* Pre:
02:15
Compiladores I

Post: p = (lC,eT,eV,e,eD)
*/
void ponExpDcha(ptArbolSintaxis p,ptArbolSintaxis e);
/* Pre:
Post: p = (lC,eT,eV,eI,e)
*/
void ponClaseDeNodo(ptArbolSintaxis p,CLASE_DE_NODO c);
/* Pre:
Post: p = (c,eT,eV,eI,eD)
*/
CLASE_DE_NODO dameLaClaseDeNodo(ptArbolSintaxis p);
/* Pre:
Post: dameLaClaseDeNodo = lC
*/
TIPOS_ESCALARES dameElTipo(ptArbolSintaxis p);
/* Pre:
Post: dameElTipo = eT
*/
ptArbolSintaxis dameSubexpIzda(ptArbolSintaxis p);
/* Pre:
Post: dameSubexpIzda = eI
*/
ptArbolSintaxis dameSubexpDcha(ptArbolSintaxis p);
/* Pre:
Post: dameSubexpDcha = eD
*/
TIPOS_ESCALARES evaluaTipo(ptArbolSintaxis p);
/* Pre:
Post: sintetiza el atributo "elTipo" para cada uno de
los nodos del rbol,
evaluaTipo = el tipo del nodo raz (ver enunciado)
*/
void muestraTipo(TIPOS_ESCALARES t);
/* Pre:
Post: imprime en stdout informacin sobre el tipo t
*/
02:15
Compiladores I

Ejercicio 1 (3.5 ptos.): Consideremos la siguiente definicin de

expresin regular para un alfabeto
es la e.r. cuyo lenguaje es L()={}
Si a , a es la e.r. cuyo lenguaje es L(a)={a}

Sean r,s dos e.r. con lenguajes L(r) y L(s),
respectivamente
r+s es la e.r. cuyo lenguaje es L(r)L(s)
r.s es la e.r. cuyo lenguaje es L(r)L(s)
r* es la e.r. cuyo lenguaje es (L(r))*
(r) es la e.r. cuyo lenguaje es L(r)
La figura muestra un esquema del diseo de lo que se pretende hacer.
nomFich
generaReconocedor
nomFich_ER
nomFichER
Los elementos son los siguientes:
nomFich es el nombre de un fichero fsico que contiene los

caracteres que componen el alfabeto de un lenguaje regular, siendo
el carcter # reservado para representar .
generaReconocedor es el nombre de un programa (puede ser

un programa hecho en C, o un script que realice varias invocaciones
a programas o servicios, o lo que se considere oportuno) que genera
el ejecutable nomFich_ER.
02:45
Compiladores I

Esta aplicacin lee de entrada estndar una supuesta expresin

regular basada en el alfabeto en nomFich y dice si se trata de una
expresin regular para dicho alfabeto o no.
Veamos un par de casos de uso. Supongamos que el fichero de texto

AB contiene la secuencia de caracteres 01. La ejecucin de
generaReconocedor AB
deber generar el ejecutable AB_ER de manera que la invocacin

AB_ER < ent1
siendo el contenido de ent1 (0.0|1*)* debe decir que es una

expresin regular correcta, mientras que la invocacin
AB_ER < ent2
siendo el contenido de ent2 *0.0

expresin regular correcta.
debe decir que no es una

genere el siguiente lenguaje, probando la correccin de la solucin
propuesta: L(G)={ambn|m>=n>=0}.
Ejercicio 3 (3.5 ptos.): Considerar la siguiente gramtica. Construir las
tablas del anlisis LL(1), SLR(1) y LALR(1), y determinar si se trata de
una gramtica de cada una de esas clases.
S --> A | b A c | d c | b d a
A --> d
02:45
Compiladores I
2 Convocatoria 03-04 (06-07-04)


Para la siguiente gramtica construir el autmata y las tablas SLR(1).
E -> '(' L ')' | a ;
L -> E L | E ;
Construir el autmata y las tablas SLR(1)

Transformar la gramtica en una equivalente que sea LL(1), y
construir para ella la tabla del anlisis LL(1).
Ejercicio 2 (2.0 ptos.): Responder a las siguientes cuestiones
Es la siguiente gramtica ambigua? Razonar la respuesta.
A -> a A a |
Es la siguiente gramtica ambigua? Razonar la respuesta.

A -> A A | ( A ) |
Ejercicio 3 (3.0 ptos.): Se desea construir un lenguaje elemental para el

manejo de cadenas de caracteres. Para una primera aproximacin, el
lenguaje slo es capaz de escribir expresiones de cadenas. Las
expresiones se forman mediante cadenas y los operadores +
(concatenacin de cadenas) y - (resta de cadenas; para que sta sea
correcta, el segundo operando debe ser un sufijo del primero).
start
println "UNO:"
println "ab" + cdefg - "fg"
end
que debera dar como como salida

UNO:
abcde
2:30 horas
Compiladores I
2 Convocatoria 03-04 (06-07-04)

1. Escribir una gramtica Bison que genere dicho lenguaje, teniendo

en cuenta que el analizador lxico que utiliza es el mostrado en el
anexo.
2. Completar la gramtica de manera que, asociado al smbolo que
corresponda a una expresin, se sintetice un atributo denominado
"valExp" con el valor de la expresin. Los aspectos semnticos que
se consideren sin especificar debern ser completados de manera
justificada.
Anexo I: Fichero cadenas.l

%{
/*-------------------------------------------------y.tab.h contiene la definicin de los tokens
tkSTART tkEND tkPRINTLN tkCAD
--------------------------------------------------*/
#include "y.tab.h"
separadores
([\t \n])+
%%
{separadores}
{}
"start"
{return(tkSTART);}
"end"
{return(tkEND);}
"println"
{return(tkPRINTLN);}
\"[^\"\t\n]*\"
{return(tkCAD);}
.
%%
2:30 horas
Compiladores I
1 Convocatoria 03/04 (30-01-04)

Ejercicio 1 (3.5 ptos.): Considrese la siguiente gramtica (est escrita en

sintaxis Bison), que se usa para el tratamiento de determinado tipo de
expresiones:
%token ENTERO AND BOOLEANO
%%
exp: ter expP ;
expP: | '=' ter;
ter: fact terP ;
terP:
| '+' fact terP | AND fact terP;
fact: ENTERO | BOOLEANO | '(' exp ')' ;
1. Slo se pueden sumar enteros; el resultado es un entero.
2. El operador AND slo se puede aplicar sobre booleanos; el
resultado es un booleano.
3. El operador de igualdad '=' slo puede aplicarse sobre elementos
del mismo tipo, y su resultado es siempre un booleano.
4. En el caso de que aparezca un error de tipos durante la traduccin
(es decir, se viole alguna de las reglas anteriores), el tipo de la
expresin ser error.
La gramtica considerada es LL(1). El ejercicio pide escribir un
analizador descendente recursivo que sintentice el tipo de la expresin
y, en caso de ser ste correcto, tambin su valor. Para ello hay que:
escribir un fuente Flex apropiado, entendiendo que debe devolver
BOOLEANO cuando encuentra true o false (sin distinguir maysculas
de minsculas) y ENTERO cuando encuentra una secuencia de uno o
ms dgitos (no vamos a considerar la posibilidad de enteros con
signo). Adems, se salta los separadores habituales. En cualquier otro
caso devuelve el primer carcter encontrado.
completar el fuente C que sigue, de manera que lleve a cabo el anlisis
solicitado. Ntese que esto implica desarrollar tambin el cdigo del
procedimiento "evaluaExp", as como las macros "EL_TIPO" y
2:30 horas
Compiladores I
1 Convocatoria 03/04 (30-01-04)

"EL_VALOR". En el Anexo-I se adjunta la especificacin de un TAD

para el manejo de rboles n-arios, limitados a un mximo de hijos.
Vamos a asumir que los fuentes son lxica y sintcticamente correctos.
include "arbNArio.h"
typedef enum {ENT,BOOL,ERROR} tipos;
int elToken;
int main(){
arbolN aSConcreta;
elToken = yylex();
exp(&aSConcreta);
evaluaExp(&aSConcreta); /*completa los atributos necesarios*/
switch(EL_TIPO(aSConcreta)){
case BOOL: printf(
"Tipo: booleano. Valor: %1d\n",EL_VAL(aSConcreta));
break;
case ENT: printf(
"Tipo: entero Valor: %1d \n", EL_ VAL(aSConcreta));
break;
case ERROR: printf(
"Tipo: error Valor: indefinido\n");
break;
}
liberaArbol(&aSConcreta);
exit(1);
Ejercicio 2 (1.0 ptos.): Sea G una gramtica libre de contexto, y sea A uno
de sus smbolos no terminales. Si
A --> A1 | A2 | ... | An
son todas las producciones recursivas por la izquierda a partir de A y

A --> 1 | 2 | ... | m
son el resto de producciones que tienen A en la parte izquierda, dar una

transformacin de G que, mediante la adicin de un nico nuevo no
terminal Z, genere una gramtica equivalente sin recursividad por la
izquierda. Razonar sobre la correccin de la solucin propuesta.
2:30 horas
Compiladores I
1 Convocatoria 03/04 (30-01-04)


genere el siguiente lenguaje, probando la correccin de la solucin
m n
propuesta: L(G)={a b |m>=n>0}. Mostrar el rbol de derivacin
3 2
para a b .
Ejercicio 4 (2.5 ptos.): Para la siguiente gramtica, se pide construir el
autmata y las tablas del anlisis LALR(1), y concluir si se trata de una
gramtica de esa clase o no.
%token I
%%
e: I
| I '(' e ')'
| I '[' e ']'
| e '+' I
;
%%
2:30 horas
Compiladores I
1 Convocatoria 03/04 (30-01-04)

Anexo-I
/*********************************************************
Fichero: arbNArio.h
Tema:
especificacin TAD arbol n-ario genrico
Fecha:
Septiembre-03
Uso:
Para usar en COMPI
**********************************************************/
#define MAX_HIJOS 12
/*ningn arbol sint. con sentido comn

tendr ms de MAX_HIJOS hijos*/
typedef void *ELEMENTO; /*para colgar la informacin del nodo*/
struct NODO;
typedef struct NODO *bosque[MAX_HIJOS];
typedef bosque *ptBosque;
typedef struct NODO{
ELEMENTO dato;
int nHijos;
bosque losHijos;
} nodo,*arbolN,**ptArbolN;
void creaArbolUnitario(ELEMENTO e,ptArbolN ptA,int tamDato);
/*
Pre: TRUE
Post: *a = <e,[]>
Com: e se copia
*/
int numHijos(arbolN a);
/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: numHijos = n
*/
ptBosque losHijos(arbolN a);
/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: *losHijos = [a_1...a_n]
Com: es un puntero a los hijos
*/
ELEMENTO raizC(arbolN a,int tamDato);
/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: *raiz = D', D'=D
Com: raiz es una copia del contenido de la raz
*/
2:30 horas
Compiladores I
1 Convocatoria 03/04 (30-01-04)

ELEMENTO raiz(arbolN a);

/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: *raiz = D
Com: es un puntero al contenido de la raz
*/
arbolN hijo(arbolN a,int i);
/*
Pre: *a = <D,[a_1...a_n]>,1<=i<=n
Post: hijo = a_i
Com: un puntero al hijo i-simo
*/
void liberaArbol(ptArbolN a);
/*
Pre: *a = <D,[a_1...a_n]>
Post: *a = <>
*/
void eliminaHijo(arbolN a,int i);
/*
Pre: *a = <D,[a_1...a_n]>,1<=i<=n
Post: *a = <D,[a_1...a_{i-1},a_{i+1}...,a_n]>
Com: a_i es eliminado fsicamente
*/
void ponHijo(arbolN a,int i,arbolN h);
/*
Pre: *a = <D,[a_1...a_n]>,1<=i<=n+1
Post: *a = <D,[a_1...a_{i-1},h,a_{i+1}...,a_n]>
*/
void copiaArbol(arbolN a,ptArbolN p,int tamDato);
/*
Pre: *a = <D,[a_1...a_n]>
Post: *p = <D,[a_1...a_n]>
Com: duplica el rbol *a y lo asigna a *p
*/
2:30 horas
Compiladores I
3 Convocatoria 03/04 (02-09-04)

Ejercicio 1 (2.0 ptos.): Dar un mtodo que elimine todas la producciones

unitarias (aqullas de la forma X-->Y, siende X e Y no terminales) de una
gramtica libre de contexto, dando lugar a una gramtica equivalente sin
producciones simples. Probar que la gramtica obtenida es,
efectivamente, equivalente a la original.
Ejercicio 2 (3.5 ptos.): Considrese la siguiente gramtica simplificada
para declaraciones de variables en C:
dec: tipo var_list
tipo: int | float
var_list: ident ',' var_list | ident
Si se trata de una gramtica LL(1), construir su tabla de anlisis LL(1). Si

no lo es, transformarla en una equivalente que s lo sea, y construir la
tabla LL(1) de la gramtica transformada.
Para la gramtica LL(1) obtenida, implementar un analizador sintctico
en C que, adems, lea de la entrada estndar el fuente C y saque por la
salida estndar el cdigo la declaracin equivalente en Ada. As, por
ejemplo, para la entrada
int a,b,c
salida debera ser

a,b,c: integer
Ejercicio 3 (2.5 ptos.): Construir el autmata y las tablas del anlisis

LR(1) para la siguiente gramtica
A --> ( A ) | a
2:30 horas
Compiladores I
1 Convocatoria 04/05 (02-02-05)


1) S A b
2) S E c
3) S b A c
4) S b E
5) A a
6) E a
1.A) Se pide completar el siguiente autmata, que se corresponde al anlisis

SLR(1).
Estado 0
Estado 1
Estado 6
Estado 2
Estado 3
Estado 4
Estado 5
Estado 7
Estado 8
Estado 9
Estado 10
Compiladores I
1 Convocatoria 04/05 (02-02-05)

1.B) Completar la siguiente tabla de anlisis SLR(1).

a
b
c
$
Estado0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Estado 7
Estado 8
Estado 9
Estado 10
1.C) Como conclusin, determinar si se trata de una gramtica SLR(1). En

caso de respuesta negativa, explicar las causas de los conflictos producidos.
1.D) Se pide por ltimo completar la secuencia de estados por los que pasara
el anlisis SLR(1) cuando se aplica el procesamiento de la secuencia bac.
(Nota: en caso de conflicto, debe asumirse que el analizador aplica las
mismas reglas que por defecto aplica Bison.)
pila
rbol
entrada
accin
Compiladores I
1 Convocatoria 04/05 (02-02-05)

Ejercicio 2 (1.5 ptos.): Considrese la siguiente gramtica G:

S var A | B
A id A num | B
B id B num |
2.A) Para ella, construir completa la tabla del anlisis LL(1), y concluir si se
trata de una gramtica de esa clase o no.
2.B) Transformar dicha gramtica en una equivalente sin (una gramtica
G se dice sin cuando cumple que si no es del lenguaje, no hay ninguna
produccin epsilon, y si es del lenguaje, la gramtica contiene S -> como
nica produccin epsilon).
Ejercicio 3 (2.0 ptos.): Sea L un lenguaje independiente de contexto (es decir,
generado por una gramtica independiente libre- de contexto). Probar que
L* es tambin un lenguaje independiente de contexto.
Ejercicio 4 (2.0 ptos.): Se desea implementar un programa que procese lotes
de futuras transacciones bancarias sobre una cuenta concreta y determine si
dicho lote es aceptable o no. Un lote es aceptable si en ningn momento entra
en nmeros rojos (es decir, la cantidad de la cuenta es inferior a cero). Las
transacciones pueden ser de dos tipos: ingresos o cargos de cantidades
naturales (es decir, cantidades mayores o iguales a 0). El fichero de entrada
para un lote de transacciones tiene el siguiente formato: la primera lnea
establece el saldo actual de una cuenta mediante el trmino "Saldo
inicial:", seguido de un entero no negativo, que indica el saldo. La lneas
siguientes representan transacciones: valores negativos representan cargos,
valores positivos indican ingresos. Un ejemplo de fichero de lote de
transacciones a procesar puede ser el siguiente:
Saldo inicial: 34567
+ 1000
-300
500
+100
Si suponemos que el fichero anterior se denomina "miFichero", la ejecucin

del programa de validacin, denominado "procesaTransacciones", sera
Compiladores I
1 Convocatoria 04/05 (02-02-05)

procesaTransacciones < miFichero
que debe dar como salida

Lote correcto. Saldo final: 34867
En el caso de un lote incorrecto da un mensaje de error en cuanto encuentre

una transaccin incorrecta, como en el ejemplo siguiente (fichero
"miOtroFichero"):
Saldo inicial: 1000
-300
+500
-2000
+300
procesaTransacciones < miOtroFichero
debera dar como resultado:

Transaccin incorrecta: -2000.
No se admiten estados de saldo negativo.
Para realizar el ejercicio se puede usar (modificar si fuera necesario) el

siguiente fuente Flex ("procesaTransacciones.l"):
%{
#include <stdio.h>
#include "procesaTransacciones.tab.h"
%}
%option case-insensitive
separador
[\t\n ]+
digito
[0-9]
cteInt
{digito}+
%%
{separador}
{/*Saltarlo*/}
"Saldo inicial:"
{return(tkSALDO);}
{cteInt}
{yylval.valCant = atoi(yytext);
return(tkCANTIDAD);}
"+"
{return yytext[0];}
"-"
{return yytext[0];}
.
{return yytext[0];}
%%
El
ejercicio
pide
completar
el
siguiente
fuente
Bison
("procesaTransacciones.y") con las acciones necesarias para que su
comportamiento sea el especificado. (Nota: no est permitido utilizar
Compiladores I
1 Convocatoria 04/05 (02-02-05)

ninguna variable auxiliar, debiendo trabajar exclusivamente con los atributos

definidos. En caso de usar variables adicionales, el ejercicio se puntuar
sobre 1.0 puntos.)
%{
#include <stdio.h>
#include <string.h>
%}
%union{
struct{
int valTrans;
int estado;
}atribCantidad;
int valCant;
}
%start S
%token <valCant>tkCANTIDAD
%token tkSALDO
%type <atribCantidad>cantidad
%type <valCant>listaOperaciones
%%
S: tkSALDO
cantidad
listaOperaciones
;
listaOperaciones:
cantidad
listaOperaciones
| cantidad
;
cantidad:
tkCANTIDAD
| '+' tkCANTIDAD
| '-' tkCANTIDAD
;
%%
int main(){
yyparse();
exit(0);
}
Compiladores I
1 Convocatoria 04/05 (02-02-05)

Ejercicio 1 (2.0 ptos.): Escribir una gramtica libre de contexto, de la clase

LL(1), que genere el mismo lenguaje que la expresin regular
(a|c+|ba|bc)* b+
Probar que, efectivamente, es de dicha clase.
Ejercicio 2 (2.5 ptos.): Dada la siguiente gramtica, se debe construir el
autmata LR(1) y las tablas del anlisis LR(1):
S: a a A| a A c| c;
A: A b | b a;
Se pide:
2A) Rellenar el contenido de los estados del autmata LR(1).
Estado 0
Estado 1
Estado 11
Estado 3
Estado 6
Estado 2
Estado 5
Estado 4
a
Estado 7
Estado 8
Estado 10
Estado 9
Estado 13
Estado 12
2B) Completar el contenido de las tablas "accin" e "ir_a" correspondientes al

anlisis LR(1), y determinar si se trata de una gramtica de la clase LR(1).
Compiladores I
1 Convocatoria 04/05 (02-02-05)

Estado 0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Estado 7
Estado 8
Estado 9
Estado 10
Estado 11
Estado 12
Estado 13
2C) Realizar los pasos necesarios para analizar la cadena de entrada aacb.
Compiladores I
Pila
1 Convocatoria 04/05 (02-02-05)

rbol
entrada
Accin
Ejercicio 3 (1.0 ptos.): Justifica si es verdad o no la siguiente afirmacin:

Toda gramtica SLR(1) es tambin LL(1).
Ejercicio 4 (1.0 ptos.): Determinar si el lenguaje generado por la siguiente

gramtica es finito o infinito. Razonar, tan formalmente como sea posible, la
respuesta.
S --> a a A | B
B --> a A | b
a --> b B
Compiladores I
1 Convocatoria 04/05 (02-02-05)

Ejercicio 5 (1.5 ptos.): Sea el siguiente analizador lxico

(procesaArbolesBinarios.l)
y
el
siguiente
analizador
sintctico
(procesaArbolesBinarios.y) para rboles binarios de nmeros enteros:
%{
#include <stdio.h>
#include procesaArbolesBinarios.tab.h
%}
%option case-insensitive
separador
[\t \n]+
digito
[0-9]
cteEntera
{digito}+
%%
{separador}
{cteEntera}
nil
%%
{/*saltarlo*/}
{yylval.valCant = atoi(yytext); return tkNumero;}
{return tkNil}
%{
#include <stdio.h>
%}
%union{
struct{
. . .
/*completar con ms atributos, si se considera necesario */
int estaOrdenado; /*1 si est ordenado, 0 en caso contrario */
}atributosArbol;
int valCant;
}
%start arbol
%token <valCant> tkNumero
%token tkNil
%type <atributosArbol> arbol
%%
arbol:
tkNumero arbol arbol
|
tkNil
%%
int main(){
yyparse();
exit(0);
}
{ . . . };
{ . . . };
Completar el fuente Bison con los atributos y acciones necesarias para

sintetizar el atributo estaOrdenado: los valores en el subrbol izquierdo
han de ser <= que el valor del nmero actual, y los valores en el subrbol
derecho han de ser >= que el valor del nmero actual. As, (2 (1 nil
nil) (3 nil nil) ) est ordenado, pero ( 1 (2 nil nil) (3 nil
nil) ) no lo est.
Compiladores I
2 Convocatoria 05/06 (28-09-06)


S a a A| a A c| c;
A A b | b a;
1.A) Se pide completar el siguiente autmata, que se corresponde al

anlisis LR Cannico.
Estado 0
Estado 1
Estado 6
Estado 2
Estado 3
Estado 8
Estado 4
Estado 5
Estado 7
Estado 9
Estado 10
1.B) Completar la siguiente tabla de anlisis LR Cannico.

a
Estado 0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Compiladores I
2 Convocatoria 05/06 (28-09-06)

Estado 7
Estado 8
Estado 9
Estado 10
1.C) Como conclusin, determinar si se trata de una gramtica LR

Cannica. En caso de respuesta negativa, explicar las causas de los
conflictos producidos.
1.D) Se pide por ltimo completar la secuencia de estados por los que
pasara el anlisis LR Cannico cuando se aplica el procesamiento de la
secuencia b a c (Nota: en caso de conflicto, debe asumirse que el
analizador aplica las mismas reglas que aplica Bison).
pila
rbol
entrada
accin
Compiladores I
2 Convocatoria 05/06 (28-09-06)

Ejercicio 2 (*.* ptos.): Es la siguiente gramtica ambigua? Justificar la

respuesta.
S a A a | b B b |
A b A | b
B a B | a
Ejercicio 3 (*.* ptos.): Escribir una gramtica libre de contexto, de la clase

LL(1), que genere el mismo lenguaje que la expresin regular:
((a+b*c)| (b*c))+ (a+b*c)
Ejercicio 4 (*.* ptos.): Lo que sigue son ejemplos de polinomios en una

2.0 X^5+X^2 -5.0
-1.0 +3.0X^3
5.0X
^6

-5.0X6+2.0X5+X2
-5.0
-3.0X3-1.0
Hay que tener presente que
los coeficientes que aparezcan, siempre se escriben con parte entera y
parte decimal
los exponentes son siempre no negativos
a veces, puede no aparecer el coeficiente, en cuyo caso debe
entenderse que es 1.0
los distintos monomios pueden aparecer desordenados (es decir, no
siempre los monomios correspondientes a los mayores exponentes
aparecen ms a la izquierda en la lnea)
Compiladores I
2 Convocatoria 05/06 (28-09-06)

la nica variable, X, puede aparecer tanto en mayscula como en

minscula
Se nos pide implementar , usando Flex y Bison, un programa que sea
capaz de leer un polinomio, terminado con un carcter "\n", lo
almacene en una variable de tipo polinomio (typedef int
polinomio[10]), y que a continuacin lo escriba, multiplicado por 2.0.
Por ejemplo, si la entrada es
2.0 X^5+X^2-
5.0X
^6
debera escribir por stdout lo siguiente:

+4.0X^5+2.0X^2-10.0X^6
El programa debe tratar polinomios de grado 10, por lo que, en caso de
detectar un monomio de grado mayor, debe ignorarlo.
Ejercicio 4 (*.* ptos.):
4.A) Dada la siguiente gramtica especificada en Bison y que describe la
sintaxis de Bison, construir un analizador lxico en Flex que permita
realizar el anlisis sintctico. El analizador lxico no debe tener en cuenta
errores lxicos, ni estrategias de recuperacin.
%start spec
%token
%token
%token
%token
%token
%%
spec:
tkIDENT /*incluye identificadores de terminales y no terminales*/

tkIDENTDP /* identificador (solo terminal) seguido de : */
tkACCIONC /* se refiere a una accin C delimitada entre llaves */
tkMARCA /* los smbolos %% */
tkPREC /* la secuencia %prec */
tkMARCA reglas
;
reglas: tkIDENTDP
| reglas
resto
regla
prec
;
regla:
tkDENTDP resto prec

| '|' resto prec
;
resto:
| resto tkIDENT
| resto accion
;
accion: tkACCIONC
Compiladores I
2 Convocatoria 05/06 (28-09-06)

;
prec:
| tkPREC tkIDENT
| tkPREC tkIDENT accion
| prec ';'
;
%%
int main(int argc, char *argv[]){
FILE *fin;
extern FILE *yyin;
if (argc == 2) {
if ((fin = fopen(argv[1],"r")) == NULL) {
fprintf(stderr,"ERROR: no se pudo abrir el fichero!\n");
exit(-1);
}
} else {
fprintf(stderr, "La invocacion debe ser: %s <fichero_fuente>\n,
argv[0]);
exit(1);
}
yyin = fin;
yyparse();
exit(0);
}
4.B) Partiendo de la gramtica en Bison, completarla (escribiendo las

acciones necesarias, etc.), para que en el anlisis de fuentes Bison
determine cul es la primera regla de mayor longitud y escriba por la
salida estndar el nmero de orden de la regla y su longitud. Se entiende
que la longitud de una regla se define como el nmero de terminales y
no terminales que tiene en la parte derecha.
Compiladores I
2 Convocatoria 05/06 (28-09-06)

Ejercicio 1 (3 ptos.): Considrese la siguiente gramtica:

S L = R| R
L * R | d
R L
1.A) Se pide completar el siguiente autmata, que se corresponde al

anlisis LR Cannico.
Estado 7
Estado 0
Estado 1
Estado 3
R
Estado 8
Estado 4
*
Estado 13
Estado 8
Estado 9
Estado 5
Estado 2
Estado 10
Estado 6
Estado 11
Estado 12
03:00
Compiladores I
2 Convocatoria 05/06 (28-09-06)

1.B) Completar la siguiente tabla de anlisis LR Cannico.

=
Estado 0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Estado 7
Estado 8
Estado 9
Estado 10
Estado 11
Estado 12
Estado 13
1.C) Como conclusin, determinar si se trata de una gramtica LR

Cannica. En caso de respuesta negativa, explicar las causas de los
conflictos producidos.
1.D) Se pide por ltimo completar la secuencia de estados por los que
pasara el anlisis LR Cannico cuando se aplica el procesamiento de la
secuencia d = d (Nota: en caso de conflicto, debe asumirse que el
analizador aplica las mismas reglas que aplica Bison).
03:00
Compiladores I
2 Convocatoria 05/06 (28-09-06)

pila
rbol
entrada
accin
03:00
Compiladores I
2 Convocatoria 05/06 (28-09-06)

Ejercicio 2 (1 pto.): Es la siguiente gramtica ambigua? Justificar la

respuesta.
S a A a | b B b |
A b A | b
B a B | a
Ejercicio 3 (1 pto.): Escribir una gramtica libre de contexto que genere el

mismo lenguaje que la expresin regular:
((a+b*c)| (b*c))+ (a+b*c)
Ejercicio 4 (3 ptos.):
Las siguientes especificaciones (en FLEX y BISON) tienen como objetivo
realizar conjuntamente el anlisis sintctico de fuentes simplificados de
BISON.
4.A) Notar que el fuente FLEX no est completo porque no devuelve el
token tkACCIONESC. Completar la especificacin FLEX para que salte
las acciones C y le proporcione al analizador sintctico el token
tkACCIONESC.
%{
#include <stdio.h>
#include "y.tab.h"
%}
ID
[a-zA-Z]([a-zA-Z0-9]|_[a-zA-Z0-9])*
%%
(\t|\n|" ")+
{}
{ID}
"'".|\n"'"
"%%"
{ return tkID; }
{ return tkID; }
{ return tkMARCA;}
***** completar aqu lo que solicita el ejercicio *****

.
{ return yytext[0]; }
03:00
Compiladores I
2 Convocatoria 05/06 (28-09-06)

%{
#include <stdio.h>
%}
%token
tkID
%%
....
spec :
tkMARCA
;
reglas :
regla
| reglas
;
tkACCIONESC tkMARCA
reglas
regla
regla :
parteIzq ':' listaPartesDchas ';'
;
parteIzq :
noTerminal
;
listaPartesDchas :
parteDcha
| listaPartesDchas '|' parteDcha
;
parteDcha :
simbGramMasAcciones
| parteDcha simbGramMasAcciones
;
simbGramMasAcciones:
accionesc
| noTerminal accionesc
| terminal accionesc
;
accionesc :
| '{' tkACCIONESC '}'
;
noTerminal:
tkID;
;
terminal:
tkID;
;
%%
FILE *fin;
extern FILE *yyin;
if (argc == 2) {
if ((fin = fopen(argv[1],"r")) == NULL) {
fprintf(stderr,"ERROR: no se pudo abrir el fichero!\n");
exit(-1);
03:00
Compiladores I
2 Convocatoria 05/06 (28-09-06)

}
} else {
fprintf(stderr, "La invocacion debe ser: %s <fichero_fuente>\n,
argv[0]);
exit(1);
}
yyin = fin;
yyparse();
exit(0);
}
4.B) Partiendo del fuente BISON suministrado, completadlo (escribiendo

las acciones necesarias, etc.), para que en el anlisis de fuentes BISON
determine cul es la primera regla de longitud mxima y escriba por la
salida estndar el nmero de orden de la regla y su longitud. Se entiende
que la longitud de una regla se define como el nmero de terminales y
no terminales que tiene en la parte derecha (en caso de que la parte
derecha sea , se considera de longitud 0).
03:00
Compiladores I
1 Convocatoria 06/07 (12-02-07)

1) S A
2) S x b
3) A a A b
4) A B
5) B x
1.A) Se pide completar el siguiente autmata, que se corresponde al anlisis
SLR(1).
Estado 0
Estado 1
Estado 2
A
Estado 3
Estado 4
Estado 5
Estado 6
Estado 9
Estado 7
Estado 8
1.B) Como conclusin, determinar si se trata de una gramtica SLR(1). En

caso de respuesta negativa, explicar las causas de los conflictos producidos.
Compiladores I
1 Convocatoria 06/07 (12-02-07)

1.C) Completar la siguiente tabla de anlisis SLR(1).

a
Estado 0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Estado 7
Estado 8
Estado 9
1.D) Se pide por ltimo completar la secuencia de estados por los que pasara
el anlisis SLR(1) cuando se aplica el procesamiento de la secuencia a x b.
entrada
pila
rbol
accin
Compiladores I
1 Convocatoria 06/07 (12-02-07)

Ejercicio 2 (1.0 ptos.): Considrese la siguiente gramtica G. Determinar si se

trata de una gramtica ambigua o no. Justificar la respuesta.
S a S
| a S b S
|
Ejercicio 3 (1.0 pto.): Consderese el alfabeto ={a b c}. Una cadena w de longitud
mayor o igual a 1 se dice que es un palndromo si se lee igual de derecha a izquierda
que de izquierda a derecha. El ejercicio pide escribir una gramtica independiente de
contexto G=(N,T,S,P) que genere como lenguaje el conjunto de palndromos de .
Ejercicio 4 (1.0 ptos.): Considrese la siguiente gramtica G:
S a S
| S b
| a
| b
Probar que ninguna cadena w perteneciente al lenguaje generado por la
gramtica, L(G), puede contener la cadena b a como subcadena.
Compiladores I
1 Convocatoria 06/07 (12-02-07)

Ejercicio 5 (3 ptos.): Construir una calculadora que realice la suma y la

multiplicacin de nmeros complejos, de manera que lea un fichero de texto
con expresiones y escriba por la salida estndar los resultados de las
evaluaciones. La calculadora se ejecutar pasndole como nico parmetro el
nombre del fichero de texto que contiene las expresiones.
Por ejemplo, asumamos que tenemos un fichero de texto
"miFicheroDeExpresionesComplejas", cuyo contenido es:
(+2+4i)+(-3-i)*(-4-5i)
(-4-i)*(-2-3i)*(-1-i)*(+1+10i)
(+1+i)+(-1+i)+(+100+i)
(-12.4+i)+(-1.7-i)
La ejecucin de
> calculadorai miFicheroDeExpresionesComplejas
generar la salida:
Resultado:
9.0+23.0i
Resultado:
199.0+71.0i
Resultado:
100.0+3.0i
Resultado:
-14.1+0.0i
Notar que cada lnea de resultado se corresponde con una de las lneas de
expresiones.
A partir del fuente Bison que se proporciona a continuacin se pide:
5.A) Escribir el fuente Flex que le proporcione los tokens necesarios y le
permita realizar la evaluacin de expresiones complejas.
5.B) Completar el fuente Bison dado, para que realice los clculos y muestre el
resultado por la salida estndar.
% token
tkREAL
% token
tkNUMEROI /* el nmero i*/
% left '+' '-'
% left '*'
%%
calc_expresiones: calc_expresiones '\n' expresion ;
Compiladores I
1 Convocatoria 06/07 (12-02-07)

calc_expresiones: expresion ;
expresion: expresion '+' expresion
| expresion '*' expresion

| '(' termino ')'
;
termino: '-' parte_real '+' parte_imaginaria
| '-' parte_real '-' parte_imaginaria
| '+' parte_real '+' parte_imaginaria
| '+' parte_real '-' parte_imaginaria
;
parte_real: tkREAL ;
parte_imaginaria: tkREAL tkNUMEROI
| tkNUMEROI
;
%%
int main (int argc, char* argv[]){
/* Completar el programa principal tambin */
}
Compiladores I Duracin 3h 15min.

2 Convocatoria 06/07 (04-09-07)

E ( L ) | a
L L ,E | E
1.A) Se pide completar el siguiente autmata y tablas, que se corresponde al

anlisis SLR(1). Como conclusin, determinar si se trata de una gramtica
SLR(1). En caso de respuesta negativa, explicar las causas de los conflictos
producidos.
(
Estado 0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Estado 7

2 Convocatoria 06/07 (04-09-07)
Estado 8
1.B) Se pide completar el siguiente autmata y tablas, que se corresponde al

anlisis LALR(1). Como conclusin, determinar si se trata de una gramtica
LALR (1). En caso de respuesta negativa, explicar las causas de los conflictos
producidos.
(
Estado 0
Estado 1
Estado 2
Estado 3
Estado 4
Estado 5
Estado 6
Estado 7
Estado 8

2 Convocatoria 06/07 (04-09-07)
Ejercicio 2 (3.5 ptos.):

2.A) Considrense las siguientes gramticas:
/*G1*/
%token tkDEC tkID tkBEGIN tkEND
P: D S ;
D: D V | ;
S: S I | ;
V : tkDEC tkID ; ;
V : tkDEC tkID ( P ) ; ;
V : tkDEC [ D ] tkID ; ;
I : tkID ; ;
I : tkBEGIN P tkEND ;
*/G2*/
%token tkDEC tkID tkBEGIN tkEND
P: D S ;
D: D V | ;
S: S I | ;
V : tkDEC tkID ; ;
V : tkDEC tkID [ P ] ; ;
V : tkDEC ( D ) tkID ; ;
I : tkID ; ;
I : tkBEGIN P tkEND ;
Determinar si las siguientes frases (en que la correspondencia entre lexemas y

tokens es la que dice la intuicin) pertenecen al lenguaje generado por
alguna de las gramticas G1 G2. En caso afirmativo, dar un rbol de
derivacin para cada una de ellas. En caso de respuesta negativa, dar alguna
razn.
decl id ( begin id ; [ id ] end )
decl id ( decl [ decl id ; ] id ; ) ;
2.B) Responder, de manera justificada, a las siguientes preguntas:

1. Puede una gramtica LL(1) ser ambigua?
2. Toda gramtica sin smbolos intiles con un ciclo de producciones unitarias es
ambigua
2.C) Considrese la siguiente gramtica para el procesamiento de listas de

nombres.
*/G3*/
%token tkNOM
lN: lN tkNOM ;
lN: tkNOM ;

2 Convocatoria 06/07 (04-09-07)
Suponiendo que deseamos construir un analizador ascendente mediante

cualquiera de las tcnicas estudiadas en el curso, determinar si esta tarea es
viable sin transformar la gramtica. Razonar adecuadamente la respuesta.
Ejercicio 3 (2.5 ptos.): Los siguientes ejemplos son tuplas de nmeros

naturales junto con su representacin en forma de rbol n-ario.
(2 5 4)
(2 (3 6 6) 1)
Un patrn de tuplas de nmeros naturales es una tupla en la que sus

elementos son o bien nmeros naturales o bien el smbolo *+, como, por
ejemplo, ( 2 5 * ).
Se trata de construir un programa que recorra un fichero de texto que
contiene una tupla o un patrn y lo almacene en un bol n-ario. Para ello, se
ha programado el analizador lxico suministrado en el Anexo-I. El ejercicio
pide completar el programa, parcialmente desarrollado en el Anexo-II, de
manera que:
5.A) Se implemente el procedimiento
void analizadorDescendenteRecursivo(ptArbolN a)
ste utiliza un analizador sintctico descendente recursivo de manera que
devuelve en el parmetro a el rbol que representa la tupla o el patrn.
5.B) Se implemente la funcin
int esPatron(arbolN a)
para que, dado un rbol n-ario correspondiente a una tupla o un partn
determine si es un patrn o no.

2 Convocatoria 06/07 (04-09-07)
Anexo-I: Analizador lxico suministrado
%{
#include "declaraciones.h"
extern int yylval;
%}
DIGITO
[0-9]
%%
{DIGITO}+
{ yylval = atoi(yytext);
return tkNATURAL;
}
"("|")"|"*"
{ return yytext[0];
}
{}
{ fprintf(stderr, "Lexical Error: %s\n", yytext );
exit(1);
}
[ \t]+
.
%%
>> declaraciones.h
#ifndef _DECLARACIONES_H
#define tkNATURAL 256
int yylval;
#endif

2 Convocatoria 06/07 (04-09-07)
Anexo-II: Desarrollo parcial del programa a construir
#include "arbNArio.h"
#include <stdio.h>
#include "declaraciones.h"
int elToken;
extern int yylval;
extern FILE* yyin;
void analizadorDescendenteRecursivo(ptArbolN a) {
// completar...
}
int esPatron(arbolN a) {
// completar...
}
arbolN miArbol;
if (argc == 2) {
yyin = fopen(argv[1], "r");
elToken = yylex();
analizadorDescendenteRecursivo(&miArbol);
if (esPatron(miArbol)) {
fprintf(stdout, "Es Patron\n");
} else {
fprintf(stdout, "No es Patron\n");
}
liberaArbol(&miArbol);
exit(0);
} else {
fprintf(stderr,"Err.-> %s ficheroTuplas", argv[0]);
exit(1);
}
}

2 Convocatoria 06/07 (04-09-07)
Anexo III : Especificacin de un TAD para rboles n-arios genricos en C

/*********************************************************
Fichero: arbNArio.h
Tema:
especificacin TAD arbol n-ario genrico
Fecha:
Septiembre-03
Uso:
Para usar en COMPI
**********************************************************/
#include "arbNArio.h"
#define MAX_HIJOS 12 /*ningn arbol sint. con sentido
comn tendr ms de MAX_HIJOS hijos*/
typedef void *ELEMENTO; /*para colgar la informacin del nodo*/
struct NODO;
typedef struct NODO *bosque[MAX_HIJOS];
typedef bosque *ptBosque;
typedef struct NODO{
ELEMENTO dato;
int nHijos;
bosque losHijos;
} nodo,*arbolN,**ptArbolN;
void creaArbolUnitario(ELEMENTO e,ptArbolN ptA,int tamDato);
/*
Pre: TRUE
Post: *a = <e,[]>
Com: e se copia
*/
int numHijos(arbolN a);
/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: numHijos = n
*/
ptBosque losHijos(arbolN a);
/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: *losHijos = [a_1...a_n]
Com: es un puntero a los hijos
*/
ELEMENTO raizC(arbolN a,int tamDato);

/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: *raiz = D', D'=D
Com: raiz es una copia del contenido de la raz
*/
ELEMENTO raiz(arbolN a);
/*
Pre: *a = <D,[a_1...a_n]>,0<=n
Post: *raiz = D
Com: es un puntero al contenido de la raz

2 Convocatoria 06/07 (04-09-07)
*/
arbolN hijo(arbolN a,int i);
/*
Pre: *a = <D,[a_1...a_n]>,1<=i<=n
Post: hijo = a_i
Com: un puntero al hijo i-simo
*/
void liberaArbol(ptArbolN a);
/*
Pre: *a = <D,[a_1...a_n]>
Post: *a = <>
*/
void eliminaHijo(arbolN a,int i);
/*
Pre: *a = <D,[a_1...a_n]>,1<=i<=n
Post: *a = <D,[a_1...a_{i-1},a_{i+1}...,a_n]>
Com: a_i es eliminado fsicamente
*/
void ponHijo(arbolN a,int i,arbolN h);
/*
Pre: *a = <D,[a_1...a_n]>,1<=i<=n+1
Post: *a = <D,[a_1...a_{i-1},h,a_{i+1}...,a_n]>
*/
void copiaArbol(arbolN a,ptArbolN p,int tamDato);
/*
Pre: *a = <D,[a_1...a_n]>
Post: *p = <D,[a_1...a_n]>
Com: duplica el rbol *a y lo asigna a *p
*/

Anteriores 08 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Anteriores 08 PDF

Uploaded by

Copyright:

Available Formats

Compiladores I

1 Convocatoria 95/96 (27-I-96)

debe generar la salida

Como se puede ver en el ejemplo, los separadores en la entrada (blancos,

Considrese la siguiente gramtica:

Tiempo total para el examen:

Ejercicio 1: Considrese la siguiente gramtica:

1.1) (1 pto.) Establecer el lenguaje que genera. Es necesario que se justifique,

Son igualmente correctas las dos definiciones? En qu se diferencia el

El significado del fuente es el siguiente:

Ejemplo: Para un fichero de entrada como el siguiente

debe generar la salida

Como se puede ver en el ejemplo, los separadores en la entrada (blancos,

Teniendo presente la necesidad posterior de generar la calculadora (su ejecutable),

Es correcta esta solucin? Justificar la respuesta. En caso de no ser correcta, poner

Ejercicio 1 (3 ptos.): Los identificadores para un determinado lenguaje de

(1.5 ptos.) Dibujar el Autmata Finito Determinista que corresponde a

(1.5 ptos.) Dar una expresin regular correspondiente a los

Ejercicio 2 (2 ptos.): Considrese el lenguaje libros que se define como sigue:

Un libro es o bien una novela o bien un coleccin de historias cortas

Ejercicio 3 (2 ptos.): Considrese la siguiente gramtica, donde NUMERO y MAS

Slo se pueden sumar enteros; el resultado es un entero.

En el caso de que aparezca un error de tipos durante la traduccin (es

Un fuente Yacc incompleto para el problema planteado puede ser el siguiente:

typedef enum {entero,booleano,error} tipos;

(1.5 ptos.) Escribir las partes de cdigo UNO,...,OCHO que permitan

(1.5 ptos.) Completar las partes de cdigo UNO,...,OCHO que permitan

Tiempo total para el examen:

Ejercicio 1 (3 ptos.): Considrese el siguiente fragmento de fuente Yacc para el

Considrese, por otra parte, la especificacin para el manejo de la tabla de smbolos

El objetivo es completar la gramtica (parcial) anterior con aquellas acciones

Se sintetice el atributo 'elTipo' para el smbolo 'expr'

Por otra parte, si alguna de las partes no contiene cdigo, escribir

Ejercicio 2 (5 ptos.) : Considrese la siguiente gramtica (en negrita los terminales):

(0.5 ptos.) Qu lenguaje genera dicha gramtica?

(2 ptos.) Evidentemente, se trata de una gramtica no LL(1).

Ejercicio 3 (2 ptos.): Considrese un conjunto finito A={e1,e2,...,ek}. Una lista

(1 pto.) Describir concisa y claramente una gramtica libre de contexto

Tiempo total para el examen:

Ejercicio 1 (6.25 ptos.): Considerar la siguiente gramtica (denominada G), que

1.1) (1.0 Ptos.) Determinar si =L(G). Si la respuesta es afirmativa, encontrar

Ejercicio 2 (3 ptos.): Con el objetivo de depurar programas se ha decidido

la salida por stdout del analizador debe ser la siguiente

Nota: definir nicamente el token 'NUMERO' y asumir ya construdo un

Tiempo total para el examen:

Ejercicio 2 (7.5 ptos.): Se desea construir un intrprete para un lenguaje muy

que dar como salida

Detallemos un poco ms sus caractersticas:

las variables que se van a utilizar han de ser declaradas previamente

distintos del salto de lnea ('\n'); cuando se desea representar unas

El ejercicio pide construir el intrprete completo: analizador lxico, sintctico,

/* longitud maxima de un identificador */

/* Si variable, direccion; si proc/func,

struct UN_SIMBOLO *funcion;

/* valor del s'imbolo.

ES_VARIABLE(e) ((e).tipo == VARIABLE)

Ejercicio 1 (3.0 ptos.): Considrese la siguiente parte de una gramtica para un

Asumimos definidos los siguientes tipos:

Se dispone tambin del siguiente procedimiento para insertar un parmetro en la

La informacin es como sigue. Cada registro de la base contiene 10 campos, de los

memos.txt. No todas las formas tienen este ndice

Veamos un ejemplo de registro tomado del fichero anterior:

Se pide escribir un programa de acuerdo a las siguientes especificaciones: