Proyecto final - Fundamentos de Lenguajes Programación

*
Carlos Andres Delgado S, Ing
Mayo de 2018

1. Reglas del proyecto

1. Este proyecto tiene 3 entregas parciales, las fechas están especificadas abajo, estás serán por el campus
virtual. El enlace se cierra a esa hora convenida al docente y no le permitirá enviar después de eso.

2. No se permite división de grupos ni cambios de integrantes de última hora. No se recibirá el taller si esto
va producir conflictos entre los integrantes.
3. No se permite copiar código de Internet ni de sus compañeros. Si se encuentra código copiado el proyecto
será anulado por completo.
4. Entregue un sólo archivo

5. No deje que el enlace del campus se cierre. No se reciben trabajos por correo, no insista. Si el campus
falla, esto será verificado con la DINTEV. Recuerde estar autenticado ya que el curso permite acceso a
invitados
6. Las primeras lı́neas de cada archivo de código fuente, deben tener los integrantes del grupo con sus nombres
y código completos. Si no cumple esto, será sancionado con 0.5 en la nota de la entrega correspondiente.
7. Incluya los ejemplos solicitados. Si no realiza este paso con 0.5 en la nota de la entrega correspondiente.

* carlos.andres.delgado@correounivalle.edu.co

1
2. Introducción
El presente proyecto tiene por objeto enfrentar a los estudiantes del curso:
a la comprensión de todos los conceptos vistos en clase

a la implementación de un interpretador de un lenguaje de programación

al análisis de estructuras sintácticas, de datos y de control de un lenguaje de programación para la
implementación d en interpretador

3. Lenguaje OBLIQ
Obliq[1] es un lenguaje de programación interpretado que soporta programación orientada a objetos y tiene
una estructuras de paso de parámetros por valor. La sintaxis y semántica de Obliq es descrita a continuación:

3.1. Gramática del proyecto

Algunas convenciones:
Lo que va entre < > corresponde a un tipo de dato
Lo que está entre comillas es texto que va en la estructura de la gramática
La gramática inicia en <programa>

<programa> : : = <e x p r e s i o n >

<e x p r e s i o n > : : = <b o o l − e x p r e s i o n >

::= <i d e n t i f i c a d o r >
::= <numero>
::= <c a r a c t e r >
::= <cadena>
::= ok
::= " v a r " { < i d e n t i f i c a d o r > = <e x p r e s i o n > } ?(,) " i n " <e x p r e s i o n > " e n d "
::= " l e t " { < i d e n t i f i c a d o r > = <e x p r e s i o n > } ?(,) " i n " <e x p r e s i o n > " e n d "
::= " l e t r e c " {< i d e n t i f i c a d o r > " ( "{< i d e n t i f i c a d o r >}?(,) " ) " = <e x p r e s i o n >}? " i n " <e x p r e s i o n
,→ > " e n d "
::= " s e t " < i d e n t i f i c a d o r > " : = " <e x p r e s i o n >
::= " b e g i n " <e x p r e s i o n > {< e x p r e s i o n >}∗(;) " e n d "
::= <p r i m i t i v a > " ( "{< e x p r e s i o n >}? " ) "
::= " i f " <b o o l − e x p r e s i o n >
" t h e n " <e x p r e s i o n >
{ " e l s e i f " <b o o l − e x p r e s i o n > " t h e n " <e x p r e s i o n > } ?
" e l s e " <e x p r e s i o n >
" end "
::= " p r o c " " ( "{< i d e n t i f i c a d o r >}?(,) " ) " <e x p r e s i o n > " e n d "
::= " a p p l y " < i d e n t i f i c a d o r > " ( "{< e x p r e s i o n >}?(,) " ) "
::= " m e t h " " ( "< i d e n t i f i c a d o r > " , " {< i d e n t i f i c a d o r >}?(,) " ) " <e x p r e s i o n > " e n d "
::= " f o r " < i d e n t i f i c a d o r > " = " <e x p r e s i o n > " t o " <e x p r e s i o n > " d o " <e x p r e s i o n > " e n d "
::= " o b j e c t " " { " {< i d e n t i f i c a d o r > " = > " <e x p r e s i o n > } ? " } "
::= " g e t " < i d e n t i f i c a d o r >" . "< i d e n t i f i c a d o r >
::= " s e n d " < i d e n t i f i c a d o r >" . "< i d e n t i f i c a d o r > " ( "{< i d e n t i f i c a d o r >}?(,) " ) "
::= " u p d a t e " < i d e n t i f i c a d o r >" . "< i d e n t i f i c a d o r > " : = " <e x p r e s i o n >
::= " c l o n e " " ( "< i d e n t i f i c a d o r > {< i d e n t i f i c a d o r >}?(,) " ) "
::= <numero>

<b o o l − e x p r e s i o n >
::= true
::= f a l s e
: : = <b o o l − p r i m i t i v a > " ( "{< e x p r e s i o n >}?(,) " ) "
: : = <bool−oper> " ( "{<b o o l − e x p r e s i o n >}?(,) " ) "

<p r i m i t i v a > : : = +|−|∗| %|&

<b o o l − p r i m i t i v a > : : = < | > | <= | >= | is

<bool−oper> : : = n o t | a n d | o r

2
3.2. Estructuras sintácticas
Identificadores: Son secuencias de caracteres alfanuméricos que comienzan con una letra

Definiciones: Comienzan con lalet, let rec o var seguido de una lista de ligaduras a expresiones, separados
por comas
Expresiones: En Obliq, casi todas las estructuras sintácticas son una expresión y todas las expresio-
nes producen un valor. Las expresiones pueden ser calificadas en Identificadores, datos, constructores u
operaciones
Comentarios: Inician con (* y terminan con *)

3.3. Estructuras de datos:

Constantes:

true,false booleanos
0,1, 1 enteros
‘a’ caracteres
“abc” cadenas
ok valor vacı́o

Operadores:

bool: not, and, or

int: +,-,*, %,<,<=,>,>=, is
text: &

La primitiva is retorna verdadero si dos expresiones son iguales (es lo mismo que == de C++ o Java).
La primitiva & concatena dos textos
Objetos: Los objetos son una colección de campos xi =>ai donde xi es un nombre de campo y ai es una
expresión:
o b j e c t { x1 => a , x2 => a2 , . . . , xn => an }

Para seleccionar el campo de un objeto se escriba a.x donde a es un objeto y x es el campo.

La invocación de un método se realiza con send a.m(b1,b2,...,bndonde a es el objeto, m es el método

y b1,b2,...,bn son los argumentos

La clonación de un objeto se hace con: clone(a1,...,an). Es implica herencia múltiple, ya que un

clone retorna un objeto que recoge los campos y métodos de a1,...,an, deben realizar algunas validaciones
para tratar cuando se tienen campos y métodos con el mismo nombre

Internamente en un objeto se utiliza:

• update: Para cambiar el valor de un campo (es un set básicamente)
• get: Para obtener el valor de un campo.
Estos operadores únicamente son válidos dentro de objetos

3.4. Estructuras de control

Definiciones:
v a r x1 = a1 , . . . , xn = an i n <e x p r e s i o n > e n d
l e t x1 = a1 , . . . , xn = an i n <e x p r e s i o n > e n d
l e t r e c x1=p1 , . . . , xn= pn i n <e x p r e s i o n > e n d

3
 • Una definición var introduce una colección de identificadores actualizables y sus valores iniciales
• Una definición let introduce una colección de identificadores no actualizables y sus valores iniciales
• Una definición let rec introducción una colección de procedimientos (no actualizables) recursivos

Asignación:
s e t x := a

Donde x es un identificador y a es una expresión. Por ejemplo:

s e t x := +(x , 1 )

Tenga presente que la asignación no puede realizarse en definiciones tipo let ni let rec.
Secuenciación:
a1 ; a 2 ; . . . ; a n

Un conjunto de expresiones puede ser evaluado secuencialmente, separándolos con “punto y coma”. Ejem-
plo:
v a r x = 3 i n b e g i n s e t x :=+(x 2 ) ; s e t x :=+( x 1) ; x end end

Debe retornar 6. El cual es la ultima expresión en la secuenciación.

Procedimientos y métodos:
p r o c ( x1 , . . . , xn ) b e n d
meth ( s , x1 , . . . , xn ) b e n d

En donde b es una expresión y xi son los argumentos y s es el self (del objeto invocado). El s es obligatorio.
Los proc son procedimiento y los meth son los métodos en los objetos.

Condicionales:
i f a1 t h e n a2 elsif a3 t h e n a4 . . . else a n end

Iteraciones:
for x = a t o a2 d o a3 e n d

Donde a1 y a2 son expresiones que son números y a3 es una expresión.

4
4. Evaluación
Este proyecto tendrá entregas parciales en los enlaces respectivos del campus virtual y una sustentación
corta utilizando la librerı́a SLLGEN de Dr Racket. Este debe sustentado y cada persona del grupo obtendrá
una nota entre 0 y 1 (por sustentación), la cual se multiplicará por la nota total en el proyecto. Este proyecto
tiene 3 entregas.

4.1. Entrega 1 Mayo 6

1. (5 puntos) Definiciones léxicas y gramaticales

2. (5 puntos) Funcionamiento de las constantes
3. (5 puntos) Funcionamiento de los operadores de texto, booleanos y enteros
4. (5 puntos) Condicionales: if.

Entrega 3 pruebas de cada operador. Dejelas comentadas en el archivo.

4.2. Entrega 2 Mayo 20

5. (10 puntos) Planteamiento del ambiente y funcionamiento de las estructuras de control: var, let y letrec.
En este punto se tendrá en consideración la abstracción del ambiente para funcionar con var y let, utilizando
un sólo Datatype

6. (15 puntos) Procedimientos y su evaluación: Funcionamiento del proc.

7. (5 puntos) Secuenciación.

Entrega 3 pruebas de cada operador. Déjelas comentadas en el archivo. El interpretador tiene un ambiente
inicial con 3 variables y un procedimiento, dé valores a su gusto.

4.3. Entrega 3 Junio 03

9. (15 puntos) Objetos: Representación y creación.

10. (10 puntos) Objetos: Invocación de métodos y selección de campos

11. (20 puntos) Objetos: Clonación.

12. (10 puntos) Iteradores: for.

Entregue pruebas con 3 objetos que cumplan algun proposito especifico. Genere al menos 3 objetos clonados.

Referencias
[1] Cardelli, L. A language with distributed scope. In Proceedings of the 22Nd ACM SIGPLAN-SIGACT
Symposium on Principles of Programming Languages (New York, NY, USA, 1995), POPL ’95, ACM,
pp. 286–297.

Anexos
Factorial
let rec
Fact ( n )= i f i s ( n 0 ) t h e n 1 e l s e ∗ ( n a p p l y Fact (−(n 1 ) ) ) e n d
in
a p p l y Fact ( 5 )
end

5
Números primos
l e t primo =
o b j e c t { m =>
meth ( s , n )
begin
n;
let
s0 = clone ( s )
in
update s .m :=
meth ( s1 , n1 )
i f i s ( %(n1 n ) 0 ) t h e n
ok
else
s e n d s 0 .m( n1 )
end
end
end
end
end
}
muestra los primos ¡100
in
f o r i = 2 t o 100 d o s e n d primo .m( i ) e n d
end

6
Calculadora
let c a l c =
object {
a r g => 0 ,
a c c => 0 ,
entra un nuevo argumento
e n t e r =>
meth ( s , n )
begin
update s . a r g := n ;
s
end
end ,
la suma
add =>
meth ( s )
begin
update s . a c c := send s . e q u a l s ;
update s . e q u a l s := meth ( s ) +( g e t s . a c c g e t s . a r g ) e n d ;
s
end
end ,
la resta
sub =>
meth ( s )
begin
update s . a c c := send s . e q u a l s ;
update s . e q u a l s := meth ( s ) −( g e t s . a c c g e t s . a r g ) e n d ;
s
end
end ,
el resultado
e q u a l s =>
meth ( s )
g e t s . a r g end ,
inicializar
r e s e t =>
meth ( s )
begin
update s . a r g := 0;
update s . a c c := 0;
update s . e q u a l s := meth ( s ) g e t s . a r g e n d ; s e n d
end
}
in
begin
send c a l c . r e s e t ( ) ;
send c a l c . e n t e r ( 3 ) ;
send c a l c . e q u a l s ( ) ; 3
send c a l c . r e s e t ( ) ;
send c a l c . e n t e r ( 3 ) ;
s e n d c a l c . sub ( ) ;
send c a l c . e n t e r ( 2 ) ;
send c a l c . e q u a l s ( ) ; 1
send c a l c . r e s e t ( ) ;
send c a l c . e n t e r ( 3 ) ;
s e n d c a l c . add ( ) ;
send c a l c . e q u a l s ( ) ; 6
send c a l c . r e s e t ( ) ;
send c a l c . e n t e r ( 3 ) ;
s e n d c a l c . add ( ) ;
s e n d c a l c . add ( ) ;
send c a l c . e q u a l s ; 9 ;
ok
end
end