TLP Ex Amenes Juntos

TEORA DE LENGUAJ ES DE PROGRAMACIN
EVALUACIN TERICA

CONVOCATORIA DE J UNIO

23 de Junio de 2010

___ Publicacin de las calificaciones.

Las notas correspondientes a este ejercicio se publicarn en el moodle el 2 de julio.

___ Revisiones. Se realizarn el martes 6 de J ulio en el siguiente horario:

Maanas: 12:00 h. Tardes:16:00h.

___ Puntuacin.
Apartado n1: 2.5 puntos
Cuestin 1.1:1 punto
Cuestin 1.2:0.75 puntos
Cuestin 2.1:1 punto

Cada apartado debe entregarse en hojas separadas. Las cuestiones de un mismo apartado
s pueden contestarse de forma continuada. Tiempo. 2h.30

En este ejercicio hay que responder a diferentes cuestiones acerca de la teora de los
lenguajes de programacin y su aplicacin dentro de la implementacin de lenguajes.
Apartado 1. Cuestiones sobre lenguajes regulares

Cuestin 1.1
Dada la expresin regular aa
*
|abb
*
definida sobre el alfabeto ={a,b} encontrar
directamente un autmata finito determinista que defina el mismo lenguaje. Al
autmata determinista obtenido aplicarle el mtodo de transformacin de las clases de
equivalencia y desarrollar el proceso para obtener el autmata mnimo.

Cuestin 1.2
a-.Definir por medio de una expresin regular las constantes aritmticas enteras con la
siguiente representacin: secuencia de dgitos octales (0-7), al menos un dgito octal,
encabezadas por el dgito cero. Una constante entera puede opcionalmente venir
precedida por el carcter + o -. Ejemplos: +0412, -0012

b-. Escrbase la parte correspondiente de la especificacin javaCC que definira las
constantes carcter en notacin Unicode usada en J ava: se escriben entre apstrofos
viniendo representado el carcter como una secuencia de cuatro dgitos hexadecimales
(0-9,A,B,C,D,E,F) precedidos por la secuencia de escape \u. Ejemplo: \u13EF

Cuestin 1.3
Definir una gramtica regular para especificar cada uno de los siguientes lenguajes:
a-. El lenguaje de los identificadores, definido por aquellas cadenas formadas por una
secuencia de letras minsculas (al menos una) dentro del rango a..d, y precedidos por el
carcter almohadilla #.
b-. L={a (b|c)
n
a | n>=0}: cadenas que comienzan y finalizan por a y entre ambas
pueden aparecer un nmero indeterminado de smbolos b o c en nmero >=0.

Apartado 2. Sobre lenguajes independientes del contexto
Dada la siguiente gramtica:
S A d
A A b c
| a B b
B a b B C
| a b
C c C
| d

Cuestin 2.1
J ustificar porqu no puede ser LL(1). Transformar las reglas de la gramtica que
impiden que pueda ser LL(1) y escribir la nueva gramtica numerando sus reglas.

Cuestin 2.2
Para la gramtica transformada calcular los smbolos directores de cada una de las
reglas reflejando detalladamente el clculo de los iniciales y los seguidores implicados.
Es la gramtica LL(1)?
Apartado 3. Sobre lenguajes de programacin y su especificacin sintctica
Dada la siguiente especificacin lxico-sintctica:
<asi gnaci on> : : = : = <expr esi ones>
<expr esi ones> : : = <expr esi on> <mas_expr esi ones>
<mas_expr esi ones> : : = , <expr esi on> <mas_expr esi ones>
|
<expr esi on> : : = <expr esi n> <oper ador > <expr esi on>
| <el ement o>
<oper ador > : : = < | = | <= | >= | > | <>
 : : = <l et r a> {<l et r a>| <di gi t o>}
<el ement o> : : = <si mbol o> | ( <expr esi on>)
<si mbol o> : : = <l et r a> | <di gi t o>
<l et r a> : : = a| b| . | z
<di gi t o> : : = 0| 1| | 9
Cuestin 3.1
Lista de las diferentes clases de tokens.
Cuestin 3.2
Se desea crear una nueva especificacin a partir de la dada definiendo que un:
<pr ogr ama> : : = <decl ar aci on> <asi gnaci on>

Una <decl ar aci on> es una lista de identificadores seguida del carcter : y
finalizando por la palabra reservada I NTEGER o REAL identificando el tipo. En una
<decl ar aci n>los deben venir separados por el carcter , y al menos deben
declararse dos identificadores.

En la gramtica dada se desea redefinir tambin <si mbol o>como la especificacin de
una constante entera o real con las siguientes especificaciones:
<ct e_ent >: : = <di gi t o> <di gi t o>
<ct e_r eal > : : = <ct e_ent > . <ct e_ent >

Se pide escribir exclusivamente la nueva especificacin sintctica.

Cuestin 3.3
Se desea ahora redefinir <oper ador > como:
<oper ador > : : = <| =| <=| >=| >| <>| +| - | *| /
Estableciendo la siguiente jerarqua:
1- . *, / - jerarqua ms alta
2- . +, -
3- . < , = , <= ,>= ,> , <> -- jerarqua ms baja

Se pide la nueva especificacin sintctica de <expr esi n> que defina
sintcticamente la jerarqua de los operadores considerando la redefinicin de
<s mbol o>realizada en la cuestin 3.2.

Apartado 4. Sobre analizadores sintcticos y gramticas atribuidas
Un lenguaje de programacin se define usando la siguiente BNF:
<pr ogr ama> : : = <decl ar aci on> <cuer po>
<decl ar aci on> : : = <decl ar a_ct e>
<decl ar a_ct e>: : = CONSTANTE i d =<const ant e> ; <ot r a_def >
<ot r a_def > : : = i d = <const ant e> ; <ot r a_def > |
<const ant e> : : = ct e_ent | ct e_r eal
<cuer po> : : = CUERPO <asi gnaci on>
<asi gnaci n> : : = - - - - - - - -

siendo CUERPOy CONSTANTE palabras reservadas.

Cuestin 4.1
Para una implementacin DPR (Descendente Predictiva Recursiva) del analizador
sintctico escribir exclusivamente los mtodos J ava asociados a los no terminales:
<declara_cte>, <otra_def> y <constante>, y la parte de cdigo J ava que se
correspondera exclusivamente con la declaracin de los tokens necesitados en estos
mtodos.

Nota. El tratamiento de los errores sintcticos es simple. La funcin del anlisis lexicogrfico est
implementada dentro de la clase miAnalizadorLexico que dispone del mtodo public int getToken(); que
en cada llamada devuelve la siguiente pieza sintctica de la entrada leda por adelantado con la que
actualizar la variable pieza dentro del sintctico.
En los mtodos pedidos se puede hacer uso directamente del mtodo Emparejar definido en la clase que
implementa el sintctico, e implementado tal y como se ha explicado en Teora sin que sea necesario
codificarlo.

Cuestin 4.2
Si complementamos y hacemos las modificaciones siguientes en la gramtica dada:
<decl ar aci on> : : = <decl ar a_ct e> | <decl ar a_var >
<decl ar a_var > : : = VARI ABLE i d {, i d } : <t i po>
<t i po> : : = I NTEGER | REAL
<asi gnaci n> : : = i d : = <expr esi on>, <expr esi on>
<expr esi on> : : = <oper ando> <oper ador > <oper ando>
<oper ando> : : = <unar i o> <el ement o>
<el ement o> : : = ct e_ent | ct e_r eal | ( <expr esi on> ) | i d
<oper ador > : : = + | - | * | /
<unar i o> : : = + | - |

donde el id en <elemento> es un identificador de variable o de constante
previamente declarado del tipo I NTEGER o REAL.

Si los operadores unarios o binarios no alteran el tipo dentro de una <expr esi on>y se
establece la compatibilidad de tipos:

entero con entero entero | real con entero real | real con real real

Crear la gramtica atribuida que verifique que las dos <expr esi on> en una
<asi gnaci on> son del mismo tipo (las dos enteras o las dos reales) y la
compatibilidad de tipos dentro de <expr esi on>.

Dentro de la especificacin atribuida se puede usar la referencia a la funcin
Ti po ( i d) que devuelve el tipo del i d.

Apartado 1
Cuestin 1.1
a
AFD
a a

b b
C
0
={q
0
} , C
1
={q
1
,q
2
,q
3
}

C
0
={q
0
} , C
1
={q
1
} , C
2
={q
2
} , C
3
={q
3
}

El AFD de partida es mnimo
a

a a

b b

Cuestin 1.2
a) ER =>(+| - | ) 0 ( 0| 1| 2| 3|.| 7)
+
Nota: en est cuestin se ha tomado tambin como resultado correcto, que el smbolo 0
que encabeza las constantes octales forme parte de los uno o ms smbolos que contiene.
b) TOKEN : { <#simbolo : [ 0 9 , A, B, C, D, E, F ] >}
TOKEN : { <cte_car : \ \ u <simbolo><simbolo><simbolo><simbolo> >}
Cuestin 1.3
a) G=( ={ a, b, c, d, #}, N={ S, A}, S, P)
P: S #A
A a A | b A | c A | d A | a | b | c | d
b) G=( ={ a, b , c, }, N={ S, A}, S, P)
P: S a A
A b A | c A | a
C
1
a b
q
1
C
1
C
1

q
2
C
1
--
q
3

--
C
1

C
0
a b
q
0
C
1
--
C
1
a b
q
1
C
2
C
3

C
2
a b
q
2
C
2
--
C
3
a b
q
3
-- C
3

q
0

q
2

q
1

q
3

C
0

C
2

C
1

C
3

Apartado 2. Cuestin 2.1
No puede ser LL(1) porque es recursiva inmediata a izquierdas y tiene prefijos
comunes.
Eliminacin de la recursividad inmediata a izquierdas para:
A Abc | aBb
aplicando la transformacin estudiada obtenemos:
AaBbA
A bcA |
Eliminacin de los prefijos comunes para:
B abBC | ab
aplicando la transformacin estudiada obtenemos:
BabB
B BC |
La gramtica transformada resultante es:
R1 S A d
R2 A aBbA
R3 A bcA
R4 |
R5 B abB
R6 B BC
R7 |
R8 C c C
R9 d
Cuestin 2.2
S.D. (SA d) =Iniciales(Ad) =Iniciales(A)
Iniciales (A)= Iniciales (aBbA) ={a}
S.D. (SAd) ={a}
S.D. (AaBbA) =Iniciales(aBbA) ={a}
S.D. (AbcA) =Iniciales(bcA) = {b}

S.D. (A) =Iniciales( ) U Seguidores(A) = U Seguidores (A)
Seguidores (A) =Seguidores(A)
R2
Seguidores(A)=Iniciales (d) ={d} ---R1
S.D. (A ) ={d}
S.D. (BabB) =Iniciales(abB) ={a}
S.D. (BBC) =Iniciales(BC) =Iniciales(B)=Iniciales(abB)={a}

S.D. (B) =Seguidores(B)
Seguidores (B) =seguidores(B) ---R5
Seguidores (B) =Iniciales (C) U Iniciales (bA)
R6 R2
Iniciales (bA) ={b}
Iniciales(C)=Iniciales(cC) U Iniciales(d)={c,d}
S.D. (B ) ={b,c,d}
S.D. (CcC) =Iniciales(cC) ={c}
S.D. (Cd) =Iniciales(d) ={d}
Los smbolos directores de reglas asociadas al mismo no terminal son disjuntos y la
gramtica es LL(1).
Apartado 3. Cuestin 3.1
tokId id
tokAsign :=
tokComa ,
tokMenor <
tokIgual =
tokMenIgual <=
tokMayIgual >=
tokMayor >
tokDistinto <>
tokAbrePar (
tokCierraPar )
tokDigito
Cuestin 3.2
<programa>::=<declaracion><asignacion>
<declaracion> ::=<listaident>: <tipolista>
<listaident>::=id , id <mas_listaident>
<mas_listaident>::=, id <mas_listaident>|
<tipolista>::=INTEGER | REAL
<asignacion>::=id := <expresiones>
<expresiones>::=<expresion><mas_expresiones>
<mas_expresiones>::=, <expresion><mas_expresiones>|
<expresion>::=<expresion><operador> <expresion>
| <elemento>
<elemento>::=<simbolo>| ( <expresion>)
<simbolo>::=cte_ent | cte_real
<operador>::=<| <=|>| >=| =| <>

Cuestin 3.3
<expresion>::=<expresion><op_relacional><termino>
| <termino>
<termino>::=<termino><op_aditivo><factor>
| <factor>
<factor>::=<factor><op_multiplicativo><elemento>
| <elemento>
<elemento>::=<simbolo>| ( <expresion>)
<op_relacional>::=<| =| <=| >=| >| <>
<op_aditivo>::=+|
<op_multiplicativo>::=* | /
Apartado 4
Cuestin 4.1
Declaracin incluida en la clase Pi ezasSi nt
publ i c st at i c f i nal i nt
P_CONSTANTE = 1,
P_I D = 2,
P_I GUAL = 3,
P_PTOCOMA = 4,
P_CTEENT = 5,
P_CTEREAL = 6,
;
Cdigo de la parte del analizador sintctico descendente-predictivo-recursivo
num campo que contiene la representacin numrica de la pieza (token) en pi eza
voi d anDecl ar aCt e( ) {
i f ( pi eza. num== Pi ezasSi nt . P_CONSTANTE) {
empar ej ar ( Pi ezasSi nt . P_CONSTANTE) ;
empar ej ar ( Pi ezasSi nt . P_I D) ;
empar ej ar ( Pi ezasSi nt . P_I GUAL) ;
anConst ant e( ) ;
empar ej ar ( Pi ezasSi nt . P_PTOCOMA) ;
anOt r aDef ( ) ;
}
el se
er r or Si nt act i co( ) ;
}
voi d anOt r aDef ( ) {
i f ( pi eza. num== Pi ezasSi nt . P_I D) {
anConst ant e( ) ;
anOt r aDef ( ) ;
}
}
voi d anConst ant e( ) {
i f ( pi eza. num== Pi ezasSi nt . P_CTEENT)
empar ej ar ( Pi ezasSi nt . P_CTEENT) ;
el se i f i f ( pi eza. num== Pi ezasSi nt . P_CTEREAL)
empar ej ar ( Pi ezasSi nt . P_CTEREAL) ;
el se
}
Cuestin 4.2
Atributos
Se considera el atributo t i po asociado a los smbolos <expr esi on>, <oper ando>y <el ement o>.
Reglas/Funciones semnticas
<expr esi on> : : = <oper ando> <oper ador > <oper ando>
{
si <oper ando
1
>. t i po = <oper ando
2
>. t i po
entonces <expr esi on>. t i po : = <oper ando
1
>. t i po
en caso contrario <expr esi on>. t i po : = r eal
}
<oper ando> : : = <unar i o> <el ement o>
{
<oper ando>. t i po : = <el ement o>. t i po
}
<el ement o> : : = ct e_ent
{
<el ement o>. t i po : = ent er o
}
<el ement o> : : = ct e_r eal
{
<el ement o>. t i po : = r eal
}
<el ement o> : : = ( <expr esi on> )
{
<el ement o>. t i po : = <expr esi on>. t i po
}
<el ement o> : : = i d
{
<el ement o>. t i po : = Ti po( i d)
}
Condicin/Restriccin semntica
La condicin semntica asociada a la produccin es:
<asi gnaci on> : : = i d : = <expr esi on> , <expr esi on>
condicin semntica:
<expr esi on
1
>. t i po = <expr esi on
2
>. t i po


EVALUACIN TERICA

CONVOCATORIA DE J ULIO

12 de Julio de 2010


Las notas correspondientes a este ejercicio se publicarn en el moodle el 14 de julio al
medioda.

___ Revisiones. Se realizarn el jueves 15 de Julio a las 16h.

___ Tiempo y puntuacin.

Apartado 1: 2.5 puntos
Cuestin 1.1: 1 punto
Cuestin 1.2: 0.75 puntos
Cuestin 3.1: 1.25 punto

Cada apar t ado debe entregarse en hoj as separ adas. Las cuest i ones de un
mismo apartado s pueden contestarse de forma continuada. Tiempo: 2h.30


Apartado 1. Cuestiones sobre lenguajes regulares
Cuestin 1.1
Dada la expresin regular (a|b)
*
a|b(a|b)
*
definida sobre el alfabeto ={a,b} encontrar
un autmata finito que defina el mismo lenguaje.

Cuestin 1.2
a-.Definir por medio de una expresin regular identificadores al estilo de J ava: Un
identificador comienza por una letra minscula, un subrayado o un carcter de tipo de
moneda.(,$). Este carcter inicial puede estar seguido por cualquier nmero de letras
minsculas, dgitos, subrayados o caracteres de tipo de moneda (,$). Ejemplos:
_cuenta33, nombre, p_rimer_o.

b-. Escrbase la parte correspondiente de una especificacin javaCC que definira ciertas
constantes conjunto al estilo Pascal: se escriben entre corchetes rectos y entre ambos
puede aparecer slo una de estas dos definiciones:
-- secuencia, incluso vaca, cualesquiera de constantes carcter del albafeto
separadas cada una por una coma.
-- subrango, representado como .., entre dos constantes carcter cualesquiera
del alfabeto.
Ejemplos: [0..Z], [;, :,{,}]

Cuestin 1.3
Definir una gramtica regular para especificar cada uno de los siguientes
lenguajes:

a-. El lenguaje de las constantes cadena de caracteres definido sobre un alfabeto
limitado. Una constante cadena se representa al estilo J ava delimitada por dobles
comillas () y entre ambas comillas puede venir representada una secuencia
indeterminada (cero o ms) formada por dgitos o cualquiera de las letras minsculas a
y b. Ejemplos: 4abab4, a55b, .

b-. L ={(a|b)
m
c (a|b)
n
| m>0, n=1 n=0}: cadenas que comienzan por secuencias
creadas a partir de a o b con longitud m>0, contienen obligatoriamente una c y
finalizan por a o por b en nmero n que puede ser 0 o 1. Ejemplos: ababbac,
bababbaaca, ac

Apartado 2. Sobre lenguajes independientes del contexto
Cuestin 2.1
Definir la tabla, o diagrama, de transiciones del aut mat a a pi l a correspondiente
al siguiente lenguaje:

L ={a
n
c
n
b
m
| n>=0, m>=0}

Cuestin 2.2
Dada la siguiente gramtica:
S A e
A a B c D
|
B a B c
|
D b b D d
|

Calcular los smbolos directores de cada una de las reglas reflejando detalladamente el
clculo de los iniciales y los seguidores implicados en cada clculo. Es LL(1)?.

Apartado 3. Sobre lenguajes de programacin y su especificacin sintctica
Dada la siguiente especificacin sintctica:
<pr ogr ama> : : = <decl ar ar > <expr >
<decl ar ar > ::= <una_declaracion> |
<expr > : = <t er m> <mas_t er m>
<mas_t er m> : : = <opAdt > <t er m> <mas_term> |
<t er m> : = <f act or > <mas_f act or >
<mas_f act or > : : = <opMul ><f act or > <mas_factor> |
<f act or > : = ct e | i d | ( <expr > )
<opAdt > : : = +| -
<opMul > : : = * | /

Cuestin 3.1
Sobre la gramtica dada desarrollar sistemticamente y de forma razonada cada una de
las transformaciones que permitan si mpl i f i car l a.

Cuestin 3.2
Sobre la definicin de <expr > dada inicialmente se quieren hacer las siguientes
ampliaciones y consideraciones:
Una <expr >puede tener tambin como operadores NOT, AND, OR, con la siguiente
jerarqua:
1. NOT -- jerarqua ms alta
2. *, / , AND
3. +, - , OR - - jerarqua ms baja

NOT es un operador unario y es aplicado a <f act or >. En una <expr >pueden
aparecer tambin como operandos bsicos las constantes lgicas reservadas TRUE y
FALSE.
Se desea crear una nueva especificacin a partir de la dada definiendo que un
<pr ogr ama>es una <expr esi on>precedida de una <decl ar aci on>.
Una <decl ar aci on> es una lista de identificadores, separados cada uno por una
coma, seguida del carcter : y finalizando en uno de los identificadores predefinidos
i nt eger o bool ean.
Se pide escribir la nueva especificacin sintctica.

Un lenguaje de programacin se define en parte usando la siguiente BNF :
<pr ogr ama> : : = <decl ar aci on> BEGI N <expr esi on> END
<decl ar aci on> : : = CONST <una_const > ; <r est o_ct e>
|
<r est o_ct e> : : = i d = <const ant e> ; <r est o_ct e>
|
<una_const > : : = i d = <const ant e>
<const ant e> : : = ct e_ent | FALSE | TRUE
<expr esi on> : : = - - - -

siendo CONST, FALSE, TRUE, BEGI N, END palabras reservadas.

Cuestin 4.1
Para una implementacin DPR (Descendente Predictiva Recursiva) del analizador
sintctico escribir exclusivamente los mtodos J ava asociados a los no terminales:
<una_const>, <resto_cte> y <constante>, y la parte de cdigo J ava que
se correspondera exclusivamente con la declaracin de los tokens necesitados en estos
mtodos.

Nota. El tratamiento de los errores sintcticos es simple. La funcin del anlisis lexicogrfico est
implementada dentro de la clase miAnalizadorLexico que dispone del mtodo publ i c i nt
get Token( ) ; que en cada llamada devuelve la siguiente pieza sintctica de la entrada leda por
adelantado con la que actualizar la variable pi eza dentro del sintctico.
En los mtodos pedidos se puede hacer uso directamente del mtodo Empar ej ar definido en la clase
que implementa el sintctico e implementado tal y como se ha explicado en Teora sin que sea necesario
codificarlo.

Cuestin 4.2
Completando la especificacin anterior para <expr esi on> con:

<pr ogr ama> : : = <decl ar aci on> BEGI N <expr esi on> END
<decl ar aci on> : : = CONST <una_const > ; <r est o_ct e> |
<r est o_ct e> : : = i d = <const ant e> ; <r est o_ct e> |
<una_const > : : = i d = <const ant e>
<const ant e> : : = ct e_ent | FALSE | TRUE
<expr esi on> : : = <val or > <oper ador > <val or >
<oper ador > : : = + | - | OR | AND
<val or > : : = ct e_ent | TRUE | FALSE | i d

donde el id en <val or >es un identificador de constante previamente declarado de
tipo entero o lgico.
Se define que dentro de una <expr esi on> los tipos entero y lgico son
incompatibles.
Teniendo en cuenta el tipo asociado a cada <oper ador >crear la gramtica atribuida
que verifique la compatibiliadad de tipos dentro de <expr esi on>.
Dentro de la especificacin atribuida se pueden usar la referencia a la funcin
Ti po( i d) que devuelve el tipo del i d.
Cuestin 1.1

Cuestin 1.2
a) (a | b | | z | _ | $ | ) (a | b | | z | 0 | | 9 | _ | $ | )*

b) TOKEN :
{<conjunto : [ <secuencia>| <subrango>] >}
TOKEN :
{<#secuencia : ( <caracter> ( , <caracter> )* )? >}
TOKEN :
{<#subrango : <caracter> .. <caracter> >}
TOKEN :
{<#caracter : ~[ ] >}

Cuestin 1.3 a)
{ }
{ }
( , , , )
", , ,0,1,2,3,4,5,6,7,8,9
,
"
"| | |0 | |9
G N S P
a b
N S A
S A
P
A aA bA A A
=
=
=
=

b)
{ }
{ }
( , , , )
, ,
, ,
| | |
| |
G N S P
a b c
N S A B
S aS bS aA bA
P A cB
B a b
=
=
=

a,b
q
1

a
b
a,b

q
0

q
3
q
4

q
2

SOLUCIN - EJERCICIO 2 DE TLP CONVOCATORIA DE JULIO
Apartado 2
Cuestin 2.1 (1,25 puntos)
Diagrama de transicin
a, #, a#
a, a ; aa c, a; b, #;#
$, #; $, #; $, #;

c, a ; b, #; #

b, #;#
Funciones de transicin
(q
0,
a, #) (q
0 ,
a#) , (q
0,
a, a) (q
0 ,
aa) , (q
0,
$ , #) (q
0 ,
)
(q
0,
c, a) (q
1
, )
(q
0,
b, #) (q
2 ,
#)
(q
1
, c, a) (q
1 ,
) , (q
1,
$, #) (q
1 ,
)
(q
1
, b, #) (q
2 ,
#)
(q
2
, b, #) (q
2 ,
#) , (q
2
, $, #) (q
2 ,
)
reconocimiento por vaciado de pila
Nota: se ha tomado el smbolo $ como finalizador de palabra
SAe Dir(SAe)= Ini (Ae)= Ini(A) U Ini ( e)= {a, e}
AaBcD Dir(AaBcD)= Ini (aBcD)= {a}
| Dir(A)= Seg (A)= Ini (e)={e} cumple la condicin LL(1)
BaBc Dir(BaBc)= Ini (aBc)= {a}
| Dir(B)= Seg (B)= Ini(cD) U Ini (c)={c} cumple la condicin LL(1)
DbbDd Dir(DbbDd)= Ini (bbDd)= {b}
| Dir(D)=Seg (D) =Seg (A) U Ini(d)={e, d} cumple la condicin LL(1)
La gramtica dada es LL (1)

q
1
q
2
q
0

Apartado 3.
Cuestin 3.1. Hay que eliminar primero smbolos muertos y luego sobre la gramtica
resultante anterior smbolos inaccesibles.
Eliminando smbolos muertos.
Paso 1. Considerar no terminales que derivan directamente una cadena de terminales.
Vi vos = {<opAdt>,<opMul>,<declarar>,<mas_term>,<mas_factor>, <factor>,
<constante>}
Paso 2 y siguientes. Considerar no terminales no incluidos en Vivos que derivan una
cadena de terminales y/o no terminales Vi vos.
Vi vos = {<opAdt>,<opMul>,<declarar>,<mas_term>,<mas_factor>, <factor>,
<constante>,<term>, <expr>, <programa>}
El no terminal <una_ decl ar aci on> est muer t o y la gramtica resultante es:
<decl ar ar > : : =
<mas_term> ::= <opAdt> <term> <mas_term> |
<mas_factor> ::= <opMul><factor> <mas_factor> |
<opAdt > : : = +| -
<opMul > : : = * | /
Eliminando smbolos inaccesibles.
Paso 1. Son accesibles los derivados del smbolo inicial.
Accesi bl es ={<programa>,<declarar>, <expr>}
Paso 2 y siguientes. Son accesibles todos los smbolos cuyo no terminal izquierdo sea
accesible.
Accesi bl es = {<programa>,<declarar>, <expr>, <term>, <mas_term>, <factor>,
<mas_factor>, <opAdt>, +, -, cte, id, (, ), <opMul>, *, /}
El no terminal <const ant e> es i naccesi bl e y la gramtica resultante
simplificada es:
<decl ar ar > : : =
<opAdt > : : = +| -
<opMul > : : = * | /

Cuestin 3.2
La gramtica sintctica pedida es:
<decl ar ar > : : = i d {, i d} : i d
<f act or > : = ct e | i d | ( <expr > ) | TRUE | FALSE| NOT <f act or >
<opAdt > : : = +| - | OR
<opMul > : : = * | / | AND
Apartado 4
Cuestin 4.1
Declaracin incluida en la clase Pi ezasSi nt
P_FALSE = 1,
P_TRUE = 2,
P_I D = 3,
P_I GUAL = 4,
P_PTOCOMA = 5,
P_CTEENT = 6,
;
Cdigo de la parte del analizador sintctico descendente-predictivo-recursivo
num campo que contiene la representacin numrica de la pieza (token) en pi eza
voi d anUnaConst ( ) {
anConst ant e( ) ;
}
el se
}
voi d anRest oCt e( ) {
anConst ant e( ) ;
anRest oCt e( ) ;
}
}
voi d anConst ant e( ) {
i f ( pi eza. num== Pi ezasSi nt . P_CTEENT)
empar ej ar ( Pi ezasSi nt . P_CTEENT) ;
el se i f ( pi eza. num== Pi ezasSi nt . P_FALSE)
empar ej ar ( Pi ezasSi nt . P_FALSE) ;
el se i f ( pi eza. num== Pi ezasSi nt . P_TRUE)
empar ej ar ( Pi ezasSi nt . P_TRUE) ;
el se
}
Cuestin 4.2
Atributos
Se considera el atributo t i po asociado a los smbolos <val or > y <oper ador >.
Reglas/Funciones semnticas
<val or > : : = ct e_ent
{
<val or >. t i po : = entero
}
<val or > : : = TRUE
{
<val or >. t i po : = logico
}
<val or > : : = FALSE
{
<val or >. t i po : = logico
}
<val or > : : = i d
{
<val or >. t i po : = Ti po( i d)
}
<oper ador > : : = +
{
<oper ador >. t i po : = entero
}
<oper ador > : : = -
{
<oper ador >. t i po : = entero
}
<oper ador > : : = OR
{
<oper ador >. t i po : = logico
}
<oper ador > : : = AND
{
<oper ador >. t i po : = logico
}
Condicin/Restriccin semntica
La condicin semntica asociada a la produccin es:
<expr esi on> : : = <val or > <oper ador > <val or >
condicin semntica:
si <val or
1
>. t i po = <val or
2
>. t i po y <val or
1
>. t i po = <oper ador >. t i po
entonces "<expr esi on> es compatible"
en caso contrario "<expr esi on> es incompatible"


EVALUACIN TERICA


17 de Junio de 2011


Las notas correspondientes a este ejercicio se publicarn en el moodle el 27 de J unio a
ltima hora de la tarde.

___ Revisiones. Se realizarn el mircoles 29 de Junio a las 16h.


Apartado 2: 1 punto
Apartado 3: 1puntos
Apartado 4 2 puntos
Cuestin 4.1: 2 puntos
Apartado 5 1.5 puntos
Apartado 6 3 puntos

Cada apar t ado debe entregarse en hoj as separ adas. Las cuest i ones de un
Apartado 1. Cuestin sobre autmatas regulares
Cuestin 1.1
Dada la expresin regular a
*
b(c
*
a)
*
definida sobre el alfabeto ={a,b,c} encontrar
directamente un autmata finito determinista que defina el mismo lenguaje. A partir
del autmata determinista obtener el autmata mnimo.

Apartado 2. Cuestiones sobre expresiones regulares
Cuestin 2.1
Definir una expresin regular sobre ={a,b,0,1} para el lenguaje formado por cadenas
de longitud par o impar tales que comienzan por un smbolo numrico {0,1} y siguen
cumpliendo que en sus posiciones impares tienen smbolos numricos {0|1} y en sus
posiciones pares smbolos alfabticos {a|b}. La longitud de las cadenas es igual o mayor
a 1. Ejemplos: 1, 1b0, 1a0b, 0a0b1, ...

Cuestin 2.2
Especificar en JavaCC la siguiente representacin para directorios y/o ficheros de un
determinado sistema operativo. La representacin comienza por un smbolo alfabtico
{A,B,C,D,E} identificando el disco seguido de la pareja de smbolos :\ y a
continuacin puede, o no, venir un nmero indeterminado (uno o ms) subdirectorios
separados cada uno por el smbolo \.
La representacin anterior de subdirectorios puede, o no, finalizar con el nombre de un
fichero, con o sin extensin, separado de la especificacin de subdirectorios por el
smbolo \.
Un nombre de subdirectorio es una secuencia de caracteres alfanumricos.
Un nombre de fichero es una secuencia de smbolos alfabticos. Si se especifica una
extensin sta viene separada del nombre del fichero por el smbolo ., y est formada
por tres smbolos alfanumricos.
Los caracteres alfabticos siempre deben estar en minsculas en los nombres de
subdirectorios y en el nombre del fichero.
Ejemplos: A:\raiz\main\javacc, D:\indice.txt, D:\juan\programa\practica.j01, .

Apartado 3. Cuestiones sobre gramticas regulares
Cuestin 3.1
Escribir una gramtica regular para el lenguaje L ={ a
n
(b
m
|c
k
) d
i
| n, m, k >=0, i>=1}:
cadenas que pueden tener al principio un nmero indeterminado de a, seguidas por: o un
nmero indeterminado de b o un nmero indeterminado de c, y que finalizan en un
nmero indeterminado de d. Ejemplos correctos: aad, aabd, aaccd, bbdd, ccd, ddd,
Ejemplos incorrectos: aabcd, aabcbd, aaccbbd, aab, cc, bb,

Cuestin 3.2
Escribir una gramtica regular que especifique identificadores de un lenguaje de
programacin. Los identificadores se definen como una secuencia de una o ms
alternancias precedidas por la cadena ID y finalizadas por la cadena FIN. Una
alternancia es una pareja de un carcter alfabtico {a..z} y un carcter numrico {0..9},
que puede comenzar indistintamente por un carcter alfabtico o numrico. Ejemplos:
IDa2FIN, ID3ba5FIN, IDa67ck4FIN,
Apartado 4. Sobre propiedades de gramticas independientes del contexto
Cuestin 4.1
Sea la gramtica
R S d
S A B
| B A
A a P A
| P Q
B b Q B
| Q P
P x y P
|
Q y x Q
|

clculo de todos los iniciales y de los seguidores implicados. es la gramtica LL(1)?.

Apartado 5. Sobre lenguajes independientes de contexto.
Cuestin 5.1
Sea L el lenguaje definido sobre el alfabeto = { a, <, >, =} formado por las cadenas
que tienen uno o ms smbolos a a izquierda y derecha de uno de los smbolos de
relacin <, > = cumplindose que: las cadenas con el smbolo = tienen igual nmero de
a en ambos lados, las cadenas con el smbolo < tienen un nmero de a menor a su
izquierda que a su derecha, y las cadenas con el smbolo > tienen un nmero de a
mayor a su izquierda que a su derecha. Ejemplo de cadenas que pertenecen al lenguaje:
{a=a, aa=aa, aaa<aaaa, aaaa>aa, }. Ejemplos de cadenas que no pertenecen a L:
{, a=, a>aaaa, aa=a, aaaaa<aa, }.
Definir una gramtica que especifique el lenguaje L.

La siguiente gramtica especifica la sintaxis de un lenguaje para codificar grupos de
nombres (identificadores) delimitados por los pares de smbolos #/ y /#; el smbolo
terminal id representa la pieza sintctica (token) identificador.
<Rel aci on> : : = #/ <Gr upos> / #
<Gr upos> : : = <UnGr upo> <MasGr upos>
<MasGr upos> : : = ; <UnGr upo> <MasGr upos>
|
<UnGr upo> : : = i d <MasNombr es>
<MasNombr es> : : = i d <MasNombr es>
|

Cuestin 6.1
1. Obtngase una relacin de las piezas sintcticas (tokens) del lenguaje.
2. Escrbase en J ava la declaracin de las piezas sintcticas para la comunicacin entre
los analizadores lexicogrfico y sintctico.
3. Codifquense en J ava los mtodos de anlisis sintctico descendente-predictivo-
recursivo para el lenguaje indicado.

Nota. La funcin del anlisis lexicogrfico est implementada mediante el mtodo obt ener Pi eza( )
(o bien get Next Token( ) ) que, en cada llamada, deja anotada en la variable pi eza la siguiente pieza
sintctica (token) encontrada en la entrada. Es posible (tal y como se ha explicado en Teora) efectuar la
llamada a obt ener Pi eza (o get Next Token) a travs del mtodo empar ej ar ( ) que puede usarse
sin necesidad de codificarlo. El tratamiento de los errores sintcticos es simple y se realiza mediante una
llamada al mtodo er r or Si nt act i co( ) .

Cuestin 6.2
La gramtica del lenguaje para el que se ha pedido el analizador sintctico D-P-R
permite generar <Gr upos>de nombres; y en cada grupo <UnGr upo> hay uno o ms
nombres, por ejemplo son palabras de ese lenguaje:
- pal abr a con un gr upo: #/ i d i d / #
- pal abr a con dos gr upos: #/ i d i d; i d / #
- pal abr a con t r es gr upos: #/ i d; i d i d i d; i d i d / #

Tomando como base la gramtica dada, obtngase una gramtica de atributos que asocie
al smbolo inicial <Rel aci on>el valor t r ue cuando los <Gr upos>cumplan la
condicin de que los nombres de un mismo <UnGr upo>tienen el mismo tipo; en caso
de no verificarse esta condicin, el valor asociado ser f al se.
Ejemplo de palabra que cumple la condicin:
#/ x y; a b / #
x, y i dent i f i cador es de t i po ent er o
a, b i dent i f i cador es de t i po car ct er
Ejemplo de palabra que no cumple la condicin porque el <UnGrupo> definido por y
z no cumple la condicin:
#/ x ; y z; a b / #
x i dent i f i cador de t i po r eal
y i dent i f i cador de t i po l gi co
z i dent i f i cador de t i po ent er o
a, b i dent i f i cador es de t i po car ct er

Para conseguir el tipo de un nombre (identificador) se usa el mtodo t i poDe( i d)
que, aplicado a un identificador, devuelve su tipo.
Apartado 1 (1,5 puntos)
c
a
c c a
b a
a

Clculo del AFD mnimo: C
0
={ q
0
, q
2
}, C
1
={ q
1
, q
3
}
C
0
a b c C
1
a b c
q
0
C
0
C
1
- q
1
C
1
- C
0

q
2
C
1
- C
0
q
3
C
1
- C
0

C
0
=q
0
, C
1
=q
2
, C
2
={ q
1
, q
3
}
C
0
a b c C
1
a b c C
2
a b c
q
0
C
0
C
2
- q
2
C
2
- C
1
q
1
C
2
- C
1

q
3
C
2
- C
1

AFD mnimo obtenido
a a c

b c
a

Apartado 5 (1,5 puntos)
S a A a
A a A a | =
| a B
| C a
B a B | >
C C a | <
C
2

q
1

q
2

q
3
q
0

C
1

C
0

Cuest i on 2. 1

( 0| 1) ( ( a| b) ( 0| 1) ) *( a| b| )

Cuest i on 2. 2

TOKEN: { < # al f abet : [ " a" - " z" ] > }
TOKEN: { < # di gi t o : [ "0"- "9"] > }
TOKEN: { < # al f anum: <al f abet > | <di gi t o> > }
TOKEN: { < # di sco : [ " A" - " E" ] > }
TOKEN: { < # nom_subdi r : ( <al f anum>) + > }
TOKEN: { < # nom_f i ch : ( <al f abet >) + ( " . " <al f anum> <al f anum> <al f anum>) ?
> }
TOKEN: { < pat h : <di sco> " : \ \ " ( <nom_subdi r > ( " \ \ " <nom_subdi r >) *) ?
( " \ \ " <nom_f i ch>) ? > }
Apartado 3

Cuestin 3.1

=
=
=
=
|
|
|
| | |
} , , , {
} , , , {
) , , , (
dD D
dD cC C
dD bB B
dD cC bB aS S
P
D C B S N
d c b a
P S N G

Cuestin 3.2

=
=
=
=
N
I
F
| ... | | | ... |
9 | ... | 0 | 9 | ... | 0
9 | ... | 0 | | ... |
D
I
} , , , , , , , {
} 9 ,..., 0 , ,..., , N F, , D I, {
) , , , (
Z
Z Y
Y E
zE aE zA aA C
E E A A B
C C zB aB A
A X
X S
P
Z Y X E C B A S N
z a
P S N G

Tambin se admite como solucin vlida cualquier gramtica regular que,
adems de generar correctamente los identificadores pedidos, obtenga las
cadenas ID y FIN directamente usando dos producciones regulares.
Apartado 4.
S.D. (RSd) =Iniciales(Sd) =Iniciales(S) U Iniciales(d)
S=>*
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Iniciales (S)=Iniciales(AB) U Iniciales(BA)
Iniciales (AB)=Iniciales(A) U Iniciales(B) ={a,b,x,y}
A=>*
Iniciales (A)=Iniciales(aPA) U Iniciales(PQ) ={a,x,y}
Iniciales (PQ)=Iniciales(P) U Iniciales(Q) ={x,y}
P=>*
Iniciales (P)=Iniciales(x y P)={x}
Iniciales (Q)=Iniciales( y x P)={y}
Iniciales (B)=Iniciales(bQB) U Iniciales(QP) ={b,y,x}
Iniciales (QP)=Iniciales(Q) U Iniciales(P)={y,x}
Iniciales (BA)=Iniciales(B) U Iniciales(A)={a,b,x,y}
B=>*
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S.D. (RSd) ={a,b,d,x,y}
S.D. (SAB) =
Iniciales(AB)USeguidores(S)=Iniciales(A)UIniciales(B)USeguidores(S)
AB=>* A=>*
Seguidores(S)=Iniciales(d) ={d}
R1
S.D. (SAB) ={a,b,d,x,y}
S.D. (SBA) =
Iniciales(BA)USeguidores(S)=Iniciales(B)UIniciales(A)USeguidores(S)
AB=>* B=>*
S.D. (SBA) ={a,b,d,x,y}
S.D. (Aa P A) =Iniciales(a P A) ={a}
S.D. (A P Q) =Iniciales(P Q ) U Seguidores(A)
PQ=>*
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Seguidores (A) =Iniciales(B) U Seguidores(S) U Seguidores(S) USeguidores(A)
R2 R2 R3 R4
={b,d,x,y}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S.D. (A P Q) ={x,y} U {b,y,x} U{d}={b,d,x,y}
S.D. (Bb Q B) =Iniciales(b Q B) ={b}
S.D. (B Q P) =Iniciales(Q P ) U Seguidores(B)
Q P=>*
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Seguidores (B) =Seguidores(S) U Iniciales (A)U Seguidores(S) U Seguidores(B)
R2 R3 R3 R6
={a,d,x,y}
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S.D. (B Q P) ={y,x} U {d} U{a,x,y}={a,d,x,y}
S.D. (Px y P) =Iniciales(x y P )={x}
S.D. (P ) =Seguidores(P)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Seguidores (P) =
Iniciales (A) U Seguidores(A) U Iniciales(Q) U Seguidores(A) U Seguidores(B)
R4 R4 R5 R5 R7
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S.D. (P ) ={a,x,y} U {b,d,x,y} U{y} U {a,d,x,y}={a,b,d,x,y}

S.D. (Q y x Q) =Iniciales(y x Q) ={y}
S.D. (Q ) =Seguidores(Q)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Seguidores (Q) =
Seguidores(A) U Iniciales(B) U Seguidores(B) U Iniciales(P)U Seguidores(B)
R5 R6 R6 R7 R7
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
S.D. (Q ) ={b,d,x,y} U {b,y,x} U{a,d,x,y}U {x}={a,b,d,x,y}

La gramtica no es LL(1): existen reglas asociadas al mismo no terminal izquierdo con
smbolos directores comunes, por ejemplo R2 y R3.
Cuestin 6.1
1) Relacin de las piezas sintcticas del lenguaje
- marca de inicio #/
- marca de final / #
- separador punto y coma ;
- identificador i d
2) Declaraciones de valores constantes incluidas en la clase Pi eza
publ i c st at i c f i nal i nt P_I D = 0, P_PTOCOMA = 1, P_I NI CI O = 2, P_FI NAL = 3;
3) Cdigo de los mtodos
voi d anRel aci on( ) {
i f ( pi eza. numer o == Pi eza. P_I NI CI O) {
empar ej ar ( Pi eza. P_I NI CI O) ;
anGr upos( ) ;
empar ej ar ( Pi eza. P_FI NAL) ;
} el se er r or Si nt act i co( ) ;
}
voi d anGr upos( ) {
i f ( pi eza. numer o == Pi eza. P_I D) {
anUnGr upo( ) ;
anMasGr upos( ) ;
}
voi d anMasGr upos( ) {
i f ( pi eza. numer o == Pi eza. P_PTOCOMA) {
empar ej ar ( Pi eza. P_PTOCOMA) ;
anUnGr upo( ) ;
anMasGr upos( ) ;
}}
voi d anUnGr upo( ) {
empar ej ar ( Pi eza. P_I D) ;
anMasNombr es( ) ;
}
voi d anMasNombr es( ) {
anMasNombr es( ) ;
}}
Cuestin 6.2
Atributos
- estaB que est asociado a los smbolos <UnGr upo>, <MasGr upos>, <Gr upos>y <Rel aci on>
toma el valor t r ue si la condicin estudiada se cumple para todos los grupos que se derivan del corres-
pondiente smbolo
- t que est asociado al smbolo <MasNombr es> : en caso de que todos los identificadores que se
derivan de este smbolo tengan el mismo tipo, el atributo indica dicho tipo comn; en caso contrario, toma
el valor especial tipoDispar; como valor inicial (representativo de que todava no se ha considerado ningn
identificador) se da el valor especial tipoAusente
<Rel aci on> : : = #/ <Gr upos> / #
{ <Rel aci on>. estaB <Gr upos>. estaB }
<Gr upos> : : = <UnGr upo> <MasGr upos>
{ <Gr upos>. estaB <UnGr upo>. estaB AND <MasGr upos>. estaB }
<MasGr upos
1
> : : = ; <UnGr upo> <MasGr upos
2
>
{ <MasGr upos
1
>. estaB <UnGr upo>. estaB AND <MasGr upos
2
>. estaB }
<MasGrupos> ::=
{ <MasGr upos>. estaB TRUE }
<UnGr upo> : : = i d <MasNombr es>
{ si <MasNombr es>. t = tipoAusente, entonces
<UnGr upo>. estaB TRUE
si no <UnGr upo>. estaB t i poDe( i d) = <MasNombr es>. t }
<MasNombr es
1
> : : = i d <MasNombr es
2
>
{ si <MasNombr es
2
>. t = tipoAusente, entonces
<MasNombr es
1
>. t t i poDe( i d)
si no, si <MasNombr es
2
>. t = t i poDe( i d) , entonces
<MasNombr es
1
>. t <MasNombr es
2
>. t

si no <MasNombr es
1
>. t tipoDispar }
<MasNombres> ::=
{ <MasNombr es>. t tipoAusente }


EVALUACIN TERICA


12 de julio de 2011


Las notas correspondientes a este ejercicio se publicarn en el moodle el 19 de julio a

___ Revisiones. Las revisiones de las prcticas y del examen se realizarn el jueves 21 de
julio a las 16h.


Apartado 1: 2 puntos
Apartado 3: 1.5puntos
Apartado 6 3 puntos

Cada apartado debe entregarse en hojas separadas. Las cuest i ones de un

Apartado 1. Cuestiones sobre autmatas y gramticas regulares
Cuestin 1.1
Se considera el alfabeto ={a,b}. Definir un autmata finito determinista que
reconozca el lenguaje formal L formado por las cadenas que o continen la subpalabra
ab o contienen la subpalabra ba, pero no ambas a la vez.

Cuestin 1.2
Sea L un lenguaje cualquiera y sea L
R
={w
R
| w L} el lenguaje formado por todas las
palabras de L escritas en orden inverso. Se pide:
a-. Hallar el lenguaje L generado por la gramtica G =( , N, S, P ) , con ={a, b, c}
N={S, A} y P ={ S aA | bS, A aA | c }.
b-. Sea L el lenguaje del apartado anterior. Escribir una gramtica regular que genere
el lenguaje L
R
.

Apartado 2. Cuestin sobre expresiones regulares en javaCC
Cuestin 2.1
Escribir una especificacin javaCC para reconocer la definicin del siguiente patrn:
cadenas de caracteres en las cuales las cinco vocales aparecen ni cament e una
vez y en orden alfabtico, antes y/o despus de una vocal puede aparecer una secuencia
de cero o ms caracteres que no sean alfanumricos. Ejemplos: aeiou, .a.ei..o.u.,
#a++e**i+o=u##,

Apartado 3. Sobre propiedades de gramticas independientes del contexto
Cuestin 3.1
Sea la gramtica
R1 S a S
R2 | A b
R3 A B C D
R4 | C B
R5 B f S
R6 |
R7 C d S
R8 |
R9 D e S


Apartado 4. Sobre lenguajes independientes de contexto.
Cuestin 4.1
1. Obtngase un autmata a pila que acepte el mismo lenguaje que el generado por la
gramtica que se da a continuacin; para obtener el autmata ha de considerarse la
transformacin que pasa de una gramtica al autmata a pila que hace un
reconocimiento descendente (top-down) del lenguaje definido.
Gramtica:
S A B | B A
A a B a |
B b A b |
2. Escrbanse las ci nco primeras conf i gur aci ones por las que pasara el
autmata generado tratando de reconocer la palabra abba.

Apartado 5. Sobre especificacin de lenguajes de programacin
Cuestin 5.1
Escribir una gramtica en notacin BNF Estandard que especifique exclusivamente
la sintaxis, gr amt i ca si nt ct i ca, para la siguiente definicin de un lenguaje de
programacin. Hay que razonar tambin cuales son las piezas sintcticas bsicas
correspondientes a la gramtica sintctica:

Un programa es un grupo de sentencias delimitadas entre las palabras reservadas
BEGIN, al principio, y END. En un programa se pueden escribir 0 o ms sentencias y
las sentencias van separadas por un ;.

Una sentencia puede ser una sentencia condicional, una sentencia de asignacin o una
sentencia compuesta.

Una sentencia condicional se escribe comenzando por la palabra reservada IF, va
seguida de una expresin y finaliza por una sentencia.

Una expresin se define como dos trminos relacionados por un operador de relacin, o
como simplemente un trmino. Los seis operadores de relacin se escriben: <, <=, >,
>=, =,<>.

Un trmino es un identificador de constante o variable, o las palabras reservadas TRUE
o FALSE que representan los dos valores lgicos.

Una sentencia de asignacin es un identificador seguido del smbolo propio de
asignacin := y seguido de una expresin.

Una sentencia compuesta es una secuencia de 0 o ms sentencias delimitadas entre las
palabras reservadas BEGIN, al principio, y END, al final.

Cuestin 6.1
Dada la siguiente gramtica definiendo caractersticas lxicas y sintcticas de un
lenguaje, en donde las palabras en maysculas representan palabras reservadas:

<pr ogr ama> : : = <decl ar aci on_ct e> ; <decl ar aci on_var > ; <sent enci as>
<decl ar aci on_var > : : = <l i st a>
<l i st a> : : = , <l i st a> | : 
<decl ar aci on_ct e> : : = = <expr esi n_ct e> ; <r est o_ct e>
<r est o_ct e> : : = = <expr esi n_ct e> ; <r est o_ct e> |
<expr esi on_ct e> : : = <s mbol o> | <numer o> | TRUE | FALSE
 : : = <l et r a> <r est o_l et r a>
<r est o_l et r a> : : = <di gi t o> <r est o_l et r a> |
<numer o> : : = <ent er a>
| <ent er a> . <ent er a>
| <ent er a> . <ent er a> E <ent er a>
<ent er a> : : = <di gi t o> <r est o_ent er a>
<r est o_ent er a> : : = <di gi t o> <r est o_ent er a> |
<si mbol o> : : = <l i t er al > | 
<l i t er al > : : = <car act er > <ot r o_car >
<ot r o_car > : : = <car act er > <ot r o_car > |
<di gi t o> : : = 0 | 1 | 2 | . . | 9

y donde <car act er > representa cualquier carcter del alfabeto.

1. Escrbase en J ava la declaracin de las piezas sintcticas para la comunicacin entre
los analizadores lexicogrfico y sintctico.
2. Codifquense en J ava los mtodos de anlisis sintctico descendente-predictivo-
recursivo para los no terminales <l i st a>, <r est o_ct e>y <expr esi on_ct e>.

sin necesidad de codificarlo. El tratamiento de los errores sintcticos es simple y se realiza mediante una
llamada al mtodo er r or Si nt act i co( ) .

Cuestin 6.2
La siguiente gramtica define un lenguaje de programacin en el que se pueden declarar
constantes y variables:
<pr ogr ama> : : = <decl ar aci on_ct e> ; <decl ar aci on_var >; <sent enci as>
<decl ar aci on_var >: : = i d <l i st a>
<l i st a> : : = , i d <l i st a> | : i d
<decl ar aci on_ct e> : : = i d = <const ant e> ; <r est o_ct e>
<resto_cte>::= id = <constante> ; <resto_cte> |
<const ant e> : : = i d | ct e_ent | ct e_r eal
<sent enci as>: : = FOR
( i d=<const ant e> ; <const ant e> ; <const ant e>) <sent _si mpl e> ;
<sent _si mpl e>: : = WRI TE ( <const ant e> ) ;

donde el i d en <const ant e> debe ser un identificador de clase constante
previamente declarado.

Tomando como base la gramtica dada, definir una gramtica de atributos que
especifique tambin la siguiente restriccin semntica relativa a la sentencia FOR: las
diferentes <const ant e> tienen que ser del mismo tipo, el valor de la primera debe
ser menor o igual que el de la segunda, y el tipo del i d debe coincidir con el tipo de las
diferentes <const ant e>y ser de clase variable.
que, aplicado a un identificador, devuelve su tipo. Para conseguir la clase de un nombre
se usa el mtodo cl aseDe( i d) que, aplicado a un identificador, devuelve su clase.
Para conseguir el valor asociado a un terminal t er m se usa el mtodo
val or De( t er m) que devuelve el valor correspondiente al terminal.
Apartado 1.
Cuestin 1.1 (1 punto)

Cuestin 1.2 (1 punto)
a) El lenguaje L puede ser representado mediante:
i. la expresin regular b*a
+
c
ii. la siguiente descripcin: son las palabras formadas por una secuencia de
0 ms bes seguida de una secuencia de 1 ms aes seguida de una c.
iii. o mediante la notacin: {b
m
a
n
c | m0, n1}
b) El lenguaje L
R
de las palabras escritas en orden inverso a las de L se
corresponde, pues, con la expresin regular ca
+
b*. Una gramtica regular que lo
genera es: G
R
=( , N, S, P) , con
= {a, b, c},
N = {S, A, B} y
P :
S - > cA
A - > aA | aB
B - > bB |
Apartado 2.
TOKEN: { < # noalfanumerico : ~ [A-Z, a-z, 0-9]> }
TOKEN: { < patron : (<noalfanumerico>)* a (<noalfanumerico>)* e (<noalfanumerico>)* i
(<noalfanumerico>)* o (<noalfanumerico>)* u (<noalfanumerico>)* >}

Apartado 5.
Piezas sintcticas bsicas: sern aquellas secuencias de caracteres con significado propio en el lenguaje
que puedan ser reconocidas por el analizador lxico, es decir que su definicin pueda ser especificada por
medio de un mecanismo regular, en base a esta idea para la definicin sintctica que se pide el lxico
estara formado por:
Lxico:
- pieza reservada BEGIN
- pieza reservada END
- pieza reservada IF
- pieza reservada TRUE
- pieza reservada FALSE
- pieza identificador
- pieza separador punto y coma
- pieza operador menor
- pieza operador menor o igual
- pieza operador mayor
- pieza operador mayor o igual
- pieza operador igual
- operador distinto
- pieza correspondiente al conjunto de caracteres := tambin con significado propio en este
lenguaje
Gramtica sintctica:
<pr ogr ama> : : = BEGI N <gr upo> END
<gr upo> : : = <sent enci a> <r est o_sent enci as>
|
<r est o_sent enci as> : : = ; <sent enci a> <r est o_sent enci a>
|
<sent enci a> : : = <sent _condi ci onal >
| <sent _asi gnaci on>
| <sent _compuest a>
<sent _condi ci onal > : : = I F <expr esi on> <sent enci a>
<expr esi on> : : = <t er mi no> <op_r el > <t er mi no> | <t er mi no>
<op_r el > : : = < | <= | > | >= | = | <>
<t er mi no> : : = i d | TRUE | FALSE
<sent _asi gnaci on> : : = i d : = <expr esi on>
<sent _compuest a> : : = BEGI N <secuenci a> END
<secuenci a> : : = <sent enci a> <mas_secuenci a>
|
<mas_secuenci a> : : = <sent enci a> <mas_secuenci a>
|

Apartado 3

Cuestin 3.1

} { ) ( ) (
} , , { ) ( ) ( ) ( ) ( ) (
} { ) ( ) (
} , , { ) ( ) ( ) (
) ( ) ( ) ( ) (
} { ) ( ) (
} , , { ) ( ) ( ) (
) ( ) ( ) ( ) ( ) ( ) (
} , , { ) ( ) ( ) ( ) ( ) (
} , , , {
} { ) ( ) ( ) (
} { ) ( ) ( ) (
} { ) ( ) ( ) ( ) (
} { ) ( ) ( ) ( ) ( ) ( ) (
} { ) ( ) (
e eS Inic eS D Dir
b f e A Seg B Inic D Inic C Seg C Dir
d dS Inic dS C Dir
b e d A Seg D Inic C Inic
A Seg CD Inic B Seg B Dir
f S f Inic S f B Dir
b f d b Inic B Inic C Inic
A Seg B Inic C Inic A Seg CB Inic CB A Dir
e d f D Inic C Inic B Inic BCD Inic BCD A Dir
b e d f
b eS Inic dS Inic S f Inic
b D Inic C Inic B Inic
b CB Inic D Inic C Inic B Inic
b CB Inic BCD Inic b Inic A Inic Ab Inic Ab S Dir
a aS Inic aS S Dir
= =
= = =
= =
= =
= =
= =
= =
= =
= = =
=
=
=
=
= = =
= =

-------------------------------------------------------------------------------------

La gramtica NO es ) 1 ( LL puesto que

= } , { ) ( ) ( d f CB A Dir BCD A Dir

Apartado 4
Cuestin 1 (1 punto)
, S; AB
, S; BA
, A; aBa
, A;
, #, S# ,B; bAb
, B;
b, b;
$, #; a, a;

Cuestin 2 (0,5puntos)
Nota: En el ejercicio slo se pedan cuatro pasos de configuracin, pero en la solucin se
proporcionan todos.

( q
0
, abba$, #) (q
1
, abba$, S#) (q
1
, abba$, AB#) ( q
1
, abba$, B#) 1)
( q
1
, abba$, aBaB#) 2)

1) ( q
1
, abba$, B#) ( q
1
, abba$, #)
( q
1
, abba$, bAb#)

2) ( q
1
, bba$, BaB#) ( q
1
, bba$, aB#)
( q
1
, bba$, bAbaB#) ( q
1
, ba$, AbaB#) ( 21

21) ( q
1
, ba$, baB#) ( q
1
, a$, aB#) (q
1
, $, B#) ( q
1
, $, bAb#)
( q
1
, ba$, aBabaB#) ( q
1
, $, #) (q
1,
,)

( q
0
, abba$, #) (q
1
, abba$, S#) (q
1
, abba$, BA#) ( q
1
, abba$, bAbA#)
( q
1
, abba$, A#) 3)

3) ( q
1
, abba$, #)
( q
1
, abba$, aBa#) (q
1
, bba$, Ba#) 31)

31) ( q
1
, bba$, a#)
( q
1
, bba$, bAba#) (q
1
, ba$, Aba#) 311)

311) ( q
1
, ba$, ba#) (q
1
, a$, a#) (q
1
, $, #) (q
1,
,)
( q
1
, ba$, aBaba#)

q
0
q
1

Apartado 6
Cuestin 6.1
1) Declaraciones de valores constantes incluidas en la clase Pi eza
PR_FALSE = 0,
PR_TRUE = 1,
P_I D = 2,
P_CTEENT = 3,
P_CTEDEC = 4,
P_CTELI T = 5,
P_COMA = 6,
P_PTOCOMA = 7,
P_I GUAL = 8,
P_DOSPTOS = 9;
2) Cdigo de los mtodos
voi d anLi st a( ) {
i f ( pi eza. numer o == Pi eza. P_COMA) {
empar ej ar ( Pi eza. P_COMA) ;
anLi st a( ) ;
}
el se i f ( pi eza. numer o == Pi eza. P_DOSPTOS) {
empar ej ar ( Pi eza. P_DOSPTOS) ;
}
el se
}
voi d anRest oCt e( ) {
empar ej ar ( Pi eza. P_I GUAL) ;
anExpr esi onCt e( ) ;
anRest oCt e( ) ;
}
}
voi d anExpr esi onCt e( ) {
i f ( pi eza. numer o == Pi eza. P_I D | |
pi eza. numer o == Pi eza. P_CTELI T )
anSi mbol o( ) ;
el se i f ( pi eza. numer o == Pi eza. P_CTEENT | |
pi eza. numer o == Pi eza. P_CTEDEC )
anNumer o( ) ;
el se i f ( pi eza. numer o == Pi eza. PR_TRUE)
empar ej ar ( Pi eza. PR_TRUE) ;
el se i f ( pi eza. numer o == Pi eza. PR_FALSE)
empar ej ar ( Pi eza. PR_FALSE) ;
el se
}
Cuestin 6.2
Atributos asociados al smbolo <Const ant e>
- t i poC indica el tipo de la constante que se deriva de ese smbolo no terminal
- val or C indica el valor de la constante que se deriva de ese smbolo no terminal
[ Notaciones:
asignacin
operadores de comparacin entre dos valores =, <=
operador lgico (conjuncin) AND ]
Funciones semnticas
<Const ant e> : : = i d
{ val or C val or De( i d)
t i poC t i poDe( i d) }
<Const ant e> : : = ct e_ent
{ val or C val or De( ct e_ent )
t i poC tEntero }
<Const ant e> : : = ct e_r eal
{ val or C val or De( ct e_r eal )
t i poC tReal }
Condiciones semnticas
<Sent enci as> : : =
FOR ( i d = <const ant e> ; <const ant e> ; <const ant e> ) <sent _si mpl e> ;
{ cl aseDe( i d) = clVariable AND
t i poC
1
= t i poC
2
AND t i poC
1
= t i poC
3
AND
val or C
1
<= val or C
2
AND
t i poDe( i d) = t i poC
1
}
<Const ant e> : : = i d
{ cl aseDe( i d) = clConstante }


EVALUACIN TERICA


19 de junio de 2012

___ Publicacin de las calificaciones
Las notas correspondientes a este ejercicio se publicarn en el moodle el 25 de junio a
___ Revisiones
Se realizarn el mircoles 27 de junio a las 16h.

___ Tiempo y puntuacin

Cada apar t ado debe entregarse en hoj as separ adas. Tiempo: 2h.50

Apartado 1
Cuestin 1.1
Los lenguajes L
1
y L
2
estn definidos sobre el alfabeto ={a,b}. L
1
est definido por la
expresin regular (a|b)*b| y L
2
por a(a|b)*|. A partir de estos lenguajes encontrar
directamente un autmata finito determinista que defina los lenguajes L
3
y L
4
:

L
3:
Lenguaje definido por todas las palabras que perteneciendo a L
1
tienen una longitud
par (longitud mnima: 2).

L
4
: Lenguaje definido por todas las palabras que perteneciendo a L
2
tienen un nmero
impar de smbolos a.

Cuestin 1.2
Un identificador de un lenguaje se escribe con smbolos del alfabeto ={x,y,z,0,1,2},
con las siguientes condiciones:
- empieza por una letra
- tiene una o ms letras y cero o ms nmeros
- un nmero siempre va precedido por una letra
- un nmero siempre va seguido por una letra, excepto cuando es el ltimo carcter del
identificador
Son identificadores bien escritos: x, xxx, y1, z0z, xx0y1zz; y mal escritos: 1,
x012z, x0y12z0.
Escrbase una expresin regular, o definicin regular, que denote estos identificadores.

Apartado 2
Cuestin 2.1
Escribir una especificacin en javaCC para definir la siguiente clase de comentario en
un lenguaje de programacin con formato libre: comienzan por el par de smbolos \\, a
continuacin aparece una secuencia de cero o ms smbolos cualesquiera que no sean
numricos. Un comentario puede finalizar , o no, por la secuencia del smbolo = y una
nota. Una nota est formada por un dgito, seguido de un punto, seguido de dos cifras
decimales y debe estar en el intervalo 5.50 a 6.89.
Comentarios son: \ \ j p- eui - com=5. 50, \ \ j a. al um. eui . upm=6. 80, \ \ j l ui s; coi ; es

Cuestin 2.2
Un lenguaje L viene definido usando la siguiente notacin matemtica:
L ={a
n
b c
m
| n tiene longitud par (el 0 se considera par) y m tiene longitud impar}
Ejemplos de cadenas correctas: aabc, bc, aaaabc,
Ejemplos incorrectos: abc, bcc, aabcc, aaabcc,

Escribir una gramtica que especifique L. Cul es el tipo de este lenguaje?.

Apartado 3
Cuestin 3.1
Escribir una gramtica que especifique el siguiente lenguaje:
L ={c
n
a
i
b
j
c
k
a
n

| i =j +k con n,i ,j ,k >=0}

Cuestin 3.2
Obtener el autmata a pila correspondiente a la siguiente gramtica y representar 5
movimientos a partir de la configuracin inicial para la cadena w = a+a*a:

E T C
C + T C |
T F D
D * F D|
F ( E ) | a

Apartado 4
Cuestin 4.1
Sea la gramtica
S a b A c
A C B
| B d B
B a b
|
C e f
|


Cuestin 4.2
Un lenguaje L con formato libre tiene la siguiente definicin:
Un programa en L comienza por una parte de identificacin formada por la palabra
reservada BLOQUE seguida del identificador del mismo; le sigue una segunda parte
formada por una secuencia (0 o ms) sentencias de lectura, escritura o declaracin,
pudiendo estar mezcladas en cualquier orden y estando toda la secuencia de sentencias
delimitada siempre por los smbolos { y }. Toda sentencia finaliza por el smbolo ;.
Un identificador es una secuencia (1 o ms) de caracteres alfabticos.
Una sentencia de escritura est formada por la palabra reservada ESCRIBIR seguida de
una constante entera o real delimitada entre parntesis.
Una constante real es una secuencia de uno o ms dgitos numricos, seguida del
carcter punto y finalizada por cero o ms dgitos numricos. Una constante entera es
una secuencia de uno o ms dgitos numricos.
Una sentencia de lectura est formada por la palabra reservada LEER seguida de un
identificador delimitado por los smbolos ( y ).
Una declaracin est formada por un tipo representado por las palabras reservadas
INTEGER o BOOLEAN seguido de uno o ms identificadores separados por el smbolo
,.
1-. Determinar la lista de tokens para el lenguaje L.
2-. Escribir una gramtica en notacin BNF estndar especificando la sintaxis del
lenguaje.
Apartado 5
Cuestin 5.1
La siguiente gramtica especifica la sintaxis de una lista de grupos de elementos; los
smbolos i d, cE y cR representan respectivamente, un identificador, una constante
entera y una constante real; las palabras LI STA y FI NAL son reservadas; la secuencia
de caracteres / / / representa un separador entre grupos
<Li st aGr upos> : : = LI STA <Rel aci on> FI NAL
<Rel aci on> : : = <UnGr upo> <LosGr upos>
|
<LosGr upos> : : = / / / <UnGr upo> <LosGr upos>
|
<UnGr upo> : : = <El ement o> <Rest oGr upo>
<Rest oGr upo> : : = ; <El ement o> <Rest oGr upo>
|
<El ement o> : : = i d
| cE
| cR
Escrbase en J ava un analizador D-P-R para el lenguaje descrito.

sin necesidad de codificarlo tal como se ha definido en clase. El tratamiento de los errores sintcticos es
simple y se realiza mediante una llamada al mtodo er r or Si nt act i co( ) .

Cuestin 5.2
Se considera el lenguaje descrito por la gramtica de la cuestin anterior; son ejemplos
de palabras generadas por esa gramtica:

LISTA FINAL
LISTA x; 23; 1.0 /// y /// 451 FINAL
LISTA xyz /// 0.50 /// 4; 40 FINAL
LISTA xyz /// 0.50; yz /// 4; 40; z FINAL

Tomando como base la gramtica dada, obtngase una gramtica de atributos que asocie
al smbolo inicial <Li st aGr upos> el valor lgico true cuando se cumpla la
condicin de que en todos los grupos <UnGr upo>de la lista <Li st aGr upos>hay al
menos un identificador. As, en los tres primeros ejemplos citados el valor asociado ha
de ser false y en el cuarto ha de ser true.

Apartado 1

Cuestin 1.1

3
= {
termina en , || 2 y || es par}

4
= {
comienza por y ||
es impar}

Cuestin 1.2

( | | )
+
(0 | 1 | 2)( | | )
+
( | 0 | 1 | 2)

SOLUCIN APARTADO 2
Cuestin 2.1
TOKEN : { < comentario : \\\\ (<smbolo>) * ( = <nota>) ? > }
TOKEN : { < #smbolo : ~[0-9]> }
TOKEN : { < #nota : (5. <digito59> <digito09>|6. <digito08> <digito09>) > }
TOKEN : { < #digito59 : [5-9] > }
TOKEN : { < #digito08 : [0-8] > }
TOKEN : { < #digito09 : [0-9] > }
Cuestin 2.2
Una gramtica que genera el lenguaje L es la siguiente:
G = ( = {a, b, c}, N={S, A, B, C}, S, P)
P:
S a A |b B
A a S
B c C
C c B|
Es una gramtica de Tipo 3 y el lenguaje L es de Tipo 3.
Apartado 3
Cuestin 3.1
La gramtica tipo 2 que define el lenguaje es:

S c S a | T
T a T c | R
R a R b |

Cuestin 3.2
, E; TC
, C; +TC
, C;
, T; FD
, D;
, D; *FD
, F; ( E)
, F; a
, #; E#
+, +;
$, #; *, *;
( , ( ;
) , ) ;
a, a;

Las cinco primeras configuraciones:

( q
0
, a+a*a$, #) ( q
1
, a+a*a$, E#) ( q
1
, a+a*a$, TC#) ( q
1
, a+a*a$, FDC#)

( q
1
, a+a*a$, ( E) DC#) ERROR
( q
1
, a+a*a$, aDC#) ( q
1
, +a*a$, DC#)
q
0
q
1

Apartado 4.
Cuestin 4.1
Aunque en este caso concreto no es necesario, siempre es buena prctica para el clculo de
directores aadir la produccin:
SS$ (por si se necesitara calcular los Seg(S))
Smbolos anulables:
B, por tanto B es anulable.
C, por tanto C es anulable.
ABC, por tanto A es anulable.
S no es anulable.
Clculo detallado de directores:
Dir(SabAc) = Inic(abAc) = (abAC no anulable)
= {a}
Dir(ACB) = Inic(CB)Seg(A) (CB anulable)
Inic(CB) = Inic(C)Inic(B) (C anulable)
Inic(C) = Inic(ef)Inic() = Inic(ef) = {e}
Inic(B) = Inic(ab)Inic() = Inic(ab) = {a}
Inic(CB) = {e}{a} = {a,e}
Seg(A) = Inic(c) (c no anulable)
= {c}
Dir(ACB) = {a,e}{c} = {a,c,e}
Dir(ABdB) = Inic(BdB) = (Bdb no anuluble)
= Inic(B)Inic(dB) (B anulable)
Inic(dB) = {d}
Dir(ABdB) = {a}{d} = {a,d}
Dir(Bab) = Inic(ab) = (ab no anulable)
= {a}
Dir(B) = Inic()Seg(B) = ( anulable)
= Seg(B)
Seg(B) = Inic()Seg(A) (2 prod.)
Inic(dB) (3 prod. 1 aparicin)
Inic()Seg(A) = (3 prod. 2 aparicin)
= Seg(A)Inic(dB)
Inic(dB) = {d}
Seg(B) = {c}{d} = {c,d}
Dir(B) = {c,d}
Dir(Cef) = Inic(ef) = (ef no anulable)
= {e}
Dir(C) = Inic()Seg(C) = ( anulable)
= Seg(C)
Seg(C) = Inic(B)Seg(A) = (B anulable)
= {a}{c} = {a,c}
Dir(C) = {a,c}
La gramtica es LL(1)?
Puesto que
Dir(ACB) Dir(ABdB) = {a,c,e} {a,d} = {a}
entonces la gramtica NO es LL(1)
Cuestin 4.2
Lista de tokens (14 en total):
{ } BLOQUE ident ; ESCRIBIR ( ) cte_entera cte_real LEER INTEGER
BOOLEAN ,
Especificacin sintctica en BNF:
<programa> ::= <identificacion> '{' <seq_sentencias> '}'
<identificacion> ::= BLOQUE ident
<seq_sentencias> ::= <sentencia> ; <seq_sentencias>
|
<sentencia> ::= <sent_lectura>
| <sent_escritura>
| <declaracion>
<sent_escritura> ::= ESCRIBIR ( <par_escritura> )
<par_escritura> ::= cte_entera
| cte_real
<sent_lectura> ::= LEER ( ident )
<declaracion> ::= <tipo> ident <mas_idents>
<tipo> ::= INTEGER
| BOOLEAN
<mas_idents> ::= , ident <mas_idents>
|
Apartado 5
Cuestin 5.1
Declaraciones contenidas en la clase Pi eza
PR_Fi nal = 0, / / palabra reservada
PR_Li st a = 1, / / palabra reservada
P_I D = 2, / / identificador
P_CE = 3, / / constante entera
P_CR = 4, / / constante real
P_SEPARA = 5, / / smbolo sepatrador / / /
P_PTOCOMA = 6; / / smbolo punto y coma ;
publ i c i nt numer o; / / campo para la representacin numrica de la pieza sintctica
Declaracin de la variable para la comunicacin entre los analizadores
Pi eza pi eza
Cdigo de los mtodos
voi d anLi st aGr upos( ) {
i f ( pi eza. numer o == Pi eza. PR_Li st a) {
empar ej ar ( Pi eza. PR_Li st a) ;
anRel aci on( ) ;
empar ej ar ( Pi eza. PR_Fi nal ) ;
}
el se
}
voi d anRel aci on( ) {
pi eza. numer o == Pi eza. P_CE | |
pi eza. numer o == Pi eza. P_CR ) {
anUnGr upo( ) ;
anLosGr upos( ) ;
}
}
voi d anLosGr upos( ) {
i f ( pi eza. numer o == Pi eza. P_SEPARA) {
empar ej ar ( Pi eza. P_SEPARA) ;
anUnGr upo( ) ;
anLosGr upos( ) ;
}
}
voi d anUnGr upo( ) {
pi eza. numer o == Pi eza. P_CE | |
pi eza. numer o == Pi eza. P_CR ) {
anEl ement o( ) ;
anRest oGr upo( ) ;
}
el se
}
voi d anRest oGr upo( ) {
i f ( pi eza. numer o == Pi eza. P_PTOCOMA) {
anEl ement o( ) ;
anRest oGr upo( ) ;
}
}
voi d anEl ement o( ) {
i f ( pi eza. numer o == Pi eza. P_I D)
el se i f ( pi eza. numer o == Pi eza. P_CE)
empar ej ar ( Pi eza. P_CE) ;
el se i f ( pi eza. numer o == Pi eza. P_CR)
empar ej ar ( Pi eza. P_CR) ;
el se
}
Cuestin 5.2
Atributos
- esI d asociado al smbolo <El ement o>
toma el valor TRUE si el elemento que se deriva de l es un identificador
- hayI d asociado a los smbolos <UnGr upo> y <Rest oGr upo>
toma el valor TRUE si entre los elementos derivados de cada uno de ellos existe algn identificador
- conI d asociado a los smbolos <LosGr upos>, <Rel aci on> y <Li st aGr upos>
toma el valor TRUE si en todos los grupos que se derivan de cada uno de ellos se verifica que al menos
hay un identificador
Funciones semnticas
Notacin: (asignacin de un valor) AND (operador lgico conjuncin)
<Li st aGr upos> : : = Li st a <Rel aci on> Fi nal
{ <Rel aci on>. conI d <Real aci on>. conI d }
<Rel aci on> : : = <UnGr upo> <LosGr upos>
{ <Rel aci on>. conI d <UnGr upo>. hayI d AND <LosGr upos>. conI d }
<Rel aci on> : : =
{ <Rel aci on>. conI d FALSE }
<LosGr upos> : : = / / / <UnGr upo> <LosGr upos>
{ <LosGr upos>
1
. conI d <UnGr upo>. hayI d AND <LosGr upos>
2
. conI d }
<LosGr upos> : : =
{ <LosGr upos>. conI d TRUE }
<UnGr upo> : : = <El ement o> <Rest oGr upo>
{ si <El ement o>. esI d, entonces
<UnGr upo>. hayI d TRUE
si no
<UnGr upo>. hayI d <Rest oGr upo>. hayI d }
<Rest oGr upo> : : = ; <El ement o> <Rest oGr upo>
{ si <El ement o>. esI d, entonces
<Rest oGr upo>
1
. hayI d TRUE
si no
<Rest oGr upo>
1
. hayI d <Rest oGr upo>
2
. hayI d }
<Rest oGr upo> : : =
{ <Rest oGr upo>. hayI d FALSE }
<El ement o> : : = i d
{ <El ement o>. esI d TRUE }
<El ement o> : : = cE
{ <El ement o>. esI d FALSE }
<El ement o> : : = cR
{ <El ement o>. esI d FALSE }
Condicin semntica
<Li st aGr upos> : : = Li st a <Rel aci on> Fi nal
{ <Li st aGr upos>. conI d }


EVALUACIN TERICA


10 de julio de 2012

___ Publicacin de las calificaciones
Las notas correspondientes a este ejercicio se publicarn en el moodle el 17 de julio a
___ Revisiones
Se realizarn el jueves 19 de julio a las 16h.

___ Tiempo y puntuacin
Apartado 2: 1 punto
Apartado 4: 2.5puntos

Cada apar t ado debe entregarse en hoj as separ adas. Tiempo: 2h.45


Apartado 1
Cuestin 1.1
Encontrar directamente un autmata finito determinista para cada uno de los siguientes
lenguajes L
1
y L
2
definidos sobre el alfabeto ={a,b} y especificado cada uno por la
correspondiente expresin regular:
L
1
: (a|bb)(b|aa)*

L
2
: (a|b)*(b|aa)

Cuestin 1.2
Definir la tabla, o diagrama de transiciones, del autmata a pila correspondiente al
siguiente lenguaje L:
L ={a
n
b
m
c
p
a
p
| n>m; m, p>0}

Apartado 2
Cuestin 2.1
Para cada uno de los siguientes cuatro lenguajes escribir tres ejemplos de cadenas
vlidas siempre que sea posible y razonar si son regulares:

a) L
1
={a
n
b
m

| n>mo bi en n<m; n,m>=0}
b) L
2
={a
n
b
m

| n>=mo bi en n<=m; n,m>=0}
c) L
3
={a
n
b
m

| n>my t ambi n n<m; n,m>=0}
d) L
4
={a
n
b
m

| n>=my t ambi n n<=m; n,m>=0}

Apartado 3
Cuestin 3.1
El lenguaje L sobre el alfabeto ={a,b} viene definido por la siguiente notacin
matemtica indicando el asterisco repeticiones de 0 o ms veces:

L ={ a* ( b a a* )* b* }
Ejemplos de cadenas correctas: , aa, ababa, abaaaa, abaaabaab, b, bbb
Ejemplos incorrectos: bba, aabbabaa, aababba, ,
Escribir una gramtica regular que especifique L.

Cuestin 3.2
Se considera la gramtica G ={{A}, {a,b}, A, P} cuyas producciones P son:
A A b| a A b | a b

a-. Escribir el rbol de derivacin para la cadena aabbbbb de longitud 7 y para otras dos
cadenas con longitud 6 y 8.
b-. Probar que la gramtica es ambigua.
c-. Dada la siguiente gramtica:
S A S |
A A b| a A b | a b

Encontrar otra gramtica equivalente que no sea ambigua que defina el mismo lenguaje.
Apartado 4
Cuestin 4.1
Escribir una especificacin en javaCC que denote la siguiente clase de elemento
lxico: cadenas formadas por cualquier smbolo del alfabeto en las que siempre aparece
al menos una vez la cadena TLP o tlp en cualquier posicin de la cadena.
Ejemplos de cadenas correctas: TLP; aBc<tlp=DTLPe; tlp!=yalgo; antesdeTLP;
Ejemplos de cadenas incorrectas: aBc[; ymas, ymuchasmas;
Modificar la especificacin anterior para que la cadena TLP o tlp pueda aparecer, o
no, slo una vez en la palabra.

Cuestin 4.2
Empleando el concepto de produccin anulable realizar paso a paso la transformacin
que permita eliminar las producciones vacas de la siguiente gramtica, justificando
detalladamente cada uno de los pasos:
S A B C B
A C D
B C b
C a |
D b D |

Cuestin 4.3
Escrbase una gramtica de contexto independiente (tipo2) que genere el lenguaje L:

L ={0
n
(0 1)
n+1
(0 0 1)
k

| n>=0, k>0}

Apartado 5
Cuestin 5.1
La siguiente gramtica especifica en un <programa> la sintaxis de una
<decl ar aci n>; los smbolos i d, ct e_ent y ct e_r eal representan
respectivamente, un identificador, una constante entera y una constante real; las
palabras DEFI NI CI ON, VARI ABLE, CONSTANTE, I NTEGER, FLOAT,
BOOLEAN, TRUE, FALSE son reservadas, y las dos ltimas representan los dos
valores lgicos:

<pr ogr ama> : : = DEFI NI CI ON i d <cuer po>
<cuer po> : : = <decl ar aci on> ; <cuer po>
|
<decl ar aci on> : : = VARI ABLE i d <val or > : <t i po>
| CONSTANTE i d = <una_ct e>
<t i po> : : = I NTEGER | FLOAT | BOOLEAN
<val or > : : = = <una_ct e>
|
<una_ct e> : : = i d
| <const ant e>
<const ant e> : : = ct e_ent
| ct e_r eal
| TRUE
| FALSE
1- Determinar la lista de tokens para este trozo de lenguaje.
2- Escrbase en J ava un analizador D-P-R para la parte del lenguaje correspondiente a
<cuer po>, <decl ar aci on>y <una_ct e>declarando los correspondientes tokens
necesitados.

sin necesidad de codificarlo tal como se ha definido en clase. El tratamiento de los errores sintcticos es
simple y se realiza mediante una llamada al mtodo er r or Si nt act i co( ) .

Cuestin 5.2
Se considera el lenguaje descrito por la gramtica de la cuestin anterior en donde el i d
de <una_ct e>representa un identificador de constante previamente declarado; son
ejemplos de palabras generadas por la gramtica:

DEFINICION primera
VARIABLE esta : INTEGER; VARIABLE esa: FLOAT ;

DEFINICION segunda
VARIABLE esta =10 : INTEGER ; VARIABLE otra =10.0 : FLOAT ;

DEFINICION tercera
VARIABLE esta =10 : INTEGER ; VARIABLE esa =10 : FLOAT ;

DEFINICION cuarta
CONSTANTE cien=100.0 ;
VARIABLE esta =cien : INTEGER ; VARIABLE esa =100 : FLOAT ;

Tomando como base la gramtica de la cuestin anterior escribir una gramtica
atribuida que especifique que un <pr ogr ama>cumple la condicin de que en toda
<decl ar aci n> si la variable ha sido inicializada con un <val or > existe
compatibilidad de tipo, mismo tipo, entre el tipo del <val or >y el <t i po>declarado
para la variable. As, en los ejemplos de palabras generadas por la gramtica, los dos
primeros programas cumplen la condicin y los dos ltimos no.
que, aplicado a un identificador, devuelve su tipo.
Apartado1
AFD equivalente a la expresin regular dada ER =>(a|bb)(b|aa)*

AFD equivalente a la expresin regular dada ER =>(a|b)*(b|aa)

Cuestin 2 (1 punto)
AP con llegada a estado final que reconoce el lenguaje L={a
n
b
m
c
p
a
p
| n>m; m, p>0}

b, a;
c,a;ca b,a;
$,a; a,c;
q0 q1 q2 q3 q3
c,c;cc a,c;
q4
a,#; a#
a,a;aa

b
a a
b
q0 q1
q2

b
a
q3
a
b

b
a
a
b
q0 q1 q2

a
b
q3

Apartado 3

Cuestin 3.1

Por ejemplo, la gramtica regular = ( = {, }, = {, , }, , ) con producciones
=
| | |

|

satisface que (
) = ().

Cuestin 3.2

a) Los rboles de derivacin pedidos vienen dados a partir de la siguientes derivaciones:
Cadena :
Cadena de longitud 6:
Cadena de longitud 8:

b) Por ejemplo, la cadena tiene dos derivaciones (ms a la izquierda) distintas.

Intuitivamente, el problema es que la regla puede usarse antes o despus para
generar smbolos adicionales.
c) La gramtica dada es obviamente ambigua por el apartado b). Para evitar la ambigedad,
lo ms fcil es introducir una nueva variable que se encargue de generar los smbolos
adicionales.
|
|
|

Apartado 4.
Cuestin 4.1
a-.
TOKEN: {<# alfabeto : ~[] > }
TOKEN: {<definicin: (<alfabeto>)* (TLP|tlp) (<alfabeto>)* > }
b.-
Considerando que puede aparecer TLP:
TOKEN: {< # finalizacion_1: ( | (T)+ | (T)+ L ) >}
TOKEN: {<#lado_1:(~[T]| (T)+(~[T,L])|(T)+ L (~[P]) )*
<finalizacion_1> >}
TOKEN: {< def_1 : <lado_1> (TLP)? <lado_1> >}
o bien considerando que puede aparecer tlp:
TOKEN: {< # finalizacion_2: ( | (t)+ | (t)+ l ) >}
TOKEN: {< #lado_2 : (~[t] | (t)+ ~[t,l] | (t)+ l ~[p])*
<finalizacin_2> >}
TOKEN: {< def_2 : <lado_2> (tlp)? <lado_2> >}
Cuestin 4.2
Si P representa las producciones de la gramtica inicial:
S A B C B
A C D
B C b
C a |
D b D |
Usando el concepto de produccin anulable que determina no terminal anulable:
Etapa 0. Determinar no terminales anulables.
Directos:
anulables = {C, D}
Indirectos:
anulables = {C, D, A}
Etapa 1. Establecer que P
1
sern las producciones de la gramtica equivalente.
Paso 0: Inicializacin de P
1
con P
Pasos intermedios: Seleccionar una regla donde aparecen anulables y generar nuevas reglas a
partir de ella estudiando combinaciones de los no terminales anulables en las cuales alguno de
ellos puede ser sustituido por :
[S A B C B], aadir las reglas: S A B B | B C B| B B
[A C D], aadir las reglas: A C | D|
[B C b], aadir la regla: B b
[D b D], aadir la regla: D b
Etapa 2. Integrar las reglas eliminando producciones vacas.
S A B C B | A B B | B C B| B B
A C D | C | D
B C b | b
C a
D b D | b

Cuestin 4.3
S A B
A 0 S 0 1|
B 0 1 D
D 0 0 1 D| 0 0 1
Apartado 5
Cuestin 5.1
Lista de las piezas sintcticas (token) de la especificacin dada
- pal. reservada DEFI NI CI ON - pal. reservada VARI ABLE
- pal. reservada CONSTANTE - pal. reservada I NTEGER
- pal. reservada FLOAT - pal. reservada BOOLEAN
- pal. reservada FALSE - pal. reservada TRUE
- identificador i d - constante entera ct e_ent
- constante real ct e_r eal - smbolo punto y coma ;
- smbolo dos puntos : - smbolo igual =
Declaraciones contenidas en la clase Pi eza (piezas sintcticas/tokens presentes en el cdigo)
PR_CONSTANTE = 1, / / palabra reservada
PR_FALSE = 3, / / palabra reservada
PR_TRUE = 6, / / palabra reservada
PR_VARI ABLE = 7, / / palabra reservada
P_I D = 8, / / identificador
P_CENT = 9, / / constante entera
P_CDEC = 10, / / constante real
P_PTOCOMA = 11, / / smbolo punto y coma
P_I GUAL = 12, / / smbolo igual
P_DOSPTOS = 13, / / smbolo dos puntos

publ i c i nt numer o; / / campo para la representacin numrica de la pieza sintctica
Declaracin de la variable para la comunicacin entre los analizadores
Pi eza pi eza
Cdigo de los mtodos
voi d anCuer po( ) {
i f ( pi eza. numer o == Pi eza. PR_VARI ABLE | |
pi eza. numer o == Pi eza. PR_CONSTANTE ) {
anDecl ar aci on( ) ;
anCuer po( ) ;
}
}
voi d anDecl ar aci on( ) {
i f ( pi eza. numer o == Pi eza. PR_VARI ABLE) {
empar ej ar ( Pi eza. PR_VARI ABLE) ;
anVal or ( ) ;
empar ej ar ( Pi eza. P_DOSPTOS) ;
anTi po( ) ;
}
el se i f ( pi eza. numer o == Pi eza. PR_CONSTANTE) {
empar ej ar ( Pi eza. PR_CONSTANTE) ;
empar ej ar ( Pi eza. P_I GUAL) ;
anUnaCt e( ) ;
}
el se
}
voi d anUnaCt e( ) {
i f ( pi eza. numer o == Pi eza. P_I D)
el se i f ( pi eza. numer o == Pi eza. P_CENT | |
pi eza. numer o == Pi eza. P_CDEC | |
pi eza. numer o == Pi eza. PR_FALSE | |
pi eza. numer o == Pi eza. PR_TRUE )
anConst ant e( ) ;
el se
}
Cuestin 5.2
Atributos
t x asociado a los smbolos <t i po>, <val or >, <una_ct e>y <const ant e>; toma uno de los si-
guientes valores, con el significado que se indica
ent valor presente de tipo entero
dec valor presente de tipo real
log valor presente de tipo lgico
dis valor presente de tipo distinto de los tres anteriores
aus valor ausente (inexistente)
comp asociado a los smbolos <pr ogr ama>, <cuer po>y <decl ar aci on>; toma el valor true
cuando el smbolo no terminal asociado cumple la condicin de compatibilidad de tipos estudiada
Funciones semnticas [ Notacin: (asignacin) AND (operador lgico) = (igualdad) ]
{ <pr ogr ama>. comp <cuer po>. comp }
<cuer po> : : = <decl ar aci on> ; <cuer po>
{ <cuer po>
1
. comp <decl ar aci on>. comp AND <cuer po>
2
. comp }
<cuer po> : : =
{ <cuer po>. comp true }
<decl ar aci on> : : = VARI ABLE i d <val or > : <t i po>
{ si <val or >. t x = aus, entonces
<decl ar aci on>. comp true
si no, si <val or >. t x = dis, entonces
<decl ar aci on>. comp false,
si no
<decl ar aci on>. comp <val or >. t x = <t i po>. t x }
<t i po> : : = I NTEGER
{ <t i po>. t x ent }
<t i po> : : = FLOAT
{ <t i po>. t x dec }
<t i po> : : = BOOLEAN
{ <t i po>. t x log }
<val or > : : = = <una_ct e>
{ <val or >. t x <una_ct e>. t x }
<val or > : : =
{ <val or >. t x aus }
<una_ct e> : : = i d
{ si t i poI d( i d) devuelve tipo entero, entonces
<una_ct e>. t x ent
si no, si t i poI d( i d) devuelve tipo real, entonces
<una_ct e>. t x dec
si no, si t i poI d( i d) devuelve tipo lgico, entonces
<una_ct e>. t x log
si no
<una_ct e>. t x dis }
<una_ct e> : : = <const ant e>
{ <una_ct e>. t x <const ant e>. t x }
<const ant e> : : = ct e_ent
{ <const ant e>. t x ent }
<const ant e> : : = ct e_r eal
{ <const ant e>. t x dec }
<const ant e> : : = TRUE
{ <const ant e>. t x log }
<const ant e> : : = FALSE
{ <const ant e>. t x log }
Condicin semntica
{ <pr ogr ama>. comp }

TLP Ex Amenes Juntos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

TLP Ex Amenes Juntos

Enviado por

Direitos autorais:

Formatos disponíveis

TEORA DE LENGUAJ ES DE PROGRAMACIN

Você também pode gostar