Taller 3 - Fundamentos de Lenguajes Programación

*
Carlos Andres Delgado S, Msc
Marzo de 2019

1. Reglas del taller

1. 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.
2. La entrega del proyecto es únicamente por el enlace suministrado en el campus virtual.
3. Las primeras lı́neas de cada archivo de código fuente, deben tener los integrantes del grupo con sus nombres
y código completos.

2. Lenguaje Univalle GO
GO es un lenguaje de programación compilado inspirado en C, que soporta programación orientada a ob-
jetos y tiene una estructuras de paso de parámetros por valor. En este lenguaje sólo trabajaremos paso por valor.

Los valores expresados son:

1. Números (tenemos varias representaciones)
2. Texto
3. Listas
4. Void (expresión vacı́a)
Los valores denotados son arboles de sintaxis abstracta, es decir en el ambiente almacenamos de esta
forma los valores

La sintaxis y semántica adaptada a la librerı́a SLLGEN.

2.1. Gramática del proyecto

Al final de cada producción aparece el nombre de la variante entre paréntesis.

; ; * * * * * * * * * * * * * * E s p e c i f i c a c i o n e s l é x i c a s * * * * * * * * * * * * * * * * *
<d i g i t o D e c i m a l > : : = <d i g i t o ><d i g i t o >∗
<d i g i t o D e c i m a l > : : = " - " <d i g i t o ><d i g i t o >∗
<d i g i t o O c t a l > : : = " 0 x " ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 ) ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 ) ∗
<d i g i t o O c t a l > : : = " - " " 0 x " ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 ) ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 ) ∗
<h e x a d e c i m a l > : : = " h x " ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | " A " | " B " | " C " | " D " | " E " | " F " )
( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | "A" | "B" | "C" | "D" | "E" | "F")∗
<h e x a d e c i m a l > : : = " - " " h x " ( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | " A " | " B " | " C " | " D " | " E " | " F " )
( 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | "A" | "B" | "C" | "D" | "E" | "F")∗
<f l o t a n t e > : : = <d i g i t o ><d i g i t o >∗" . "<d i g i t o ><d i g i t o >∗
<f l o t a n t e > : : = " - " <d i g i t o ><d i g i t o >∗" . "<d i g i t o ><d i g i t o >∗
<cadena> : : = " < s i m b o l o > < s i m b o l o > * "
<c o m e n t a r i o > : : = " \ \ " ( n o t #\ n e w l i n e )
<e s p a c i o > : : = <w h i t e s p a c e >

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

1
; ;************** Especificaciones gramaticales *****************

<programa> : : = <s t r u c t − d e c l >∗ <e x p r e s i o n > ( a−programa )

<e x p r e s i o n > : : = <b o o l − e x p r e s i o n > ( bool−exp )

::= <i d e n t i f i c a d o r > ( var−exp )
::= <numero> ( num−exp )
::= <cadena> ( cadena−exp )
::= <v a r i a b l e − d e c l > ( decl−exp )
::= " c o n s t " < i d e n t i f i c a d o r > " = " e x p r e s i o n ( const−exp )
::= " 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 > ( set−exp )
::= " ( " <e x p r e s i o n > <p r i m i t i v a > <e x p r e s i o n > " ) " ( prim−exp )
::= " l i s t " <tipo−exp> " ( " (< e x p r e s i o n >) ∗ ( , ) " ) " ( l i s t a − e x p )

; ; C o n d i c i o n a l e s y e s t r u c t u r a s de c o n t r o l
: : = " i f " <e x p r e s i o n > " { " <e x p r e s i o n > " e l s e " <e x p r e s i o n > " { " ( i f − e x p )
::= " switch " "(" i d e n t i f i c a d o r ")" "{" ( " case " expresion expresion ) ∗ " default :" expresion
" } " ( switch−exp )
: : = " 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 > " ; " e x p r e s i o n " ; " e x p r e s i o n " { " e x p r e s i o n " } "
( for−exp )

: : = " w h i l e " <e x p r e s i o n > " { " <e x p r e s i o n > " } " ( while−exp )

; ; S e c u e n c i a c i ó n
: : = " b e g i n " (< e x p r e s i o n >) ∗ ( ; ) " e n d " ( b e g i n - e x p )

;; Funciones
: : = " f u n 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 > <tipo−exp ) ∗ ( , )
expresion " return " expresion ( func−exp )
: : = " c a l l " < i d e n t i f i c a d o r > " ( " <e x p r e s i o n > ∗ ( , ) " ) " ( c a l l − e x p )

; ; I n v o c a c i ó n y l l a m a d o d e o b j e t o s
: : = " n e w " < 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 > ∗ ( , ) " ) " ( new−obj )
: : = " 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 > " ( " <e x p r e s i o n > ∗ ( , ) " ) " ( method−invoke )

<numero−exp >::= d i g i t o D e c i m a l ( decimal−num )

::= d i g i t o O c t a l ( octal−num )
::= d i g i t o H e x a d e c i m a l ( hex−num )
::= f l o t a n t e ( float−num )

<b o o l − e x p r e s i o n >
::= true ( true−exp )
::= f a l s e ( false−exp )

;; Primitivas
<p r i m i t i v a > : : = + ( sum−prim )
: : = − ( minus−prim )
: : = ∗ ( mult−prim )
: : = m o d ( modulo−prim )
: : = & ( concat−prim )
: : = pow ( e l e v a r − p r i m )
: : = < ( menor−prim )
: : = > ( mayor−prim )
: : = <=(menorigual−prim )
: : = >=(mayorigual−prim )
: : = !=( diferent−prim )
:= ==(i g u a l − p r i m )
: : = n o t ( not−prim )
: : = a n d ( and−prim )
: : = o r ( or−prim )
: : = x o r ( xor−prim )
: : = l e n g t h ( length−prim )
: : = n t h ( nth−prim )

;; Tipos
<tipo−exp> : : = i n t ( i n t − t i p o )
::= octal ( octal−tipo )
: : = hex ( hex−tipo )
::= float ( float−tipo )
::= string ( texto−tipo )
::= bool ( bool−tipo )
::= void ( void−tipo )

; ; D e c l a r a c i ó n v a r i a b l e s

<v a r i a b l e − d e c l > : : = " v a r N " < i d e n t i f i c a d o r > " = " <e x p r e s i o n > ( decl1−exp )
: : = " v a r T " < i d e n t i f i c a d o r > <tipo−exp> ( decl2−exp )

;; Objetos ( como estructuras )

<s t r u c t − d e c l > : : = " t y p e " < i d e n t i f i c a d o r > " s t r u c t " " { " <a t r i b u t o s >∗ <metodos >∗ " } " ( obj−decl )

<a t r i b u t o s > : : = <t i p o > < i d e n t i f i c a d o r > ( a t t r − e x p )

<metodos> ::= " m e t h o 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 > <tipo−exp ) ∗ ( , )
<e x p r e s i o n > " r e t u r n " <e x p r e s i o n > ( method−exp )

2
2.2. Estructuras léxicas
Identificadores: Son secuencias de caracteres alfanuméricos que comienzan con una letra
Comentarios: Inician con // y terminan con fin de linea.
Números enteros: Los números son un conjunto de dı́gitos. Se dividen de la siguiente forma:
1. Dı́gitos decimales del 0 al 9
2. Dı́gitos octales del 0 al 7
3. Dı́gitos hexadecimales del 0 al F.
Estos números pueden ser antecedidos por ”para indicar que son negativos.
Números flotantes: Los números son un conjunto de dı́gitos seguidos por un punto y seguidos por un
conjunto de dı́gitos. Estos números pueden ser antecedidos por ”para indicar que son negativos. Única-
mente tenemos números decimales flotantes
Cadenas: Inician con comillas seguidas por un conjunto de dı́gitos o letras y terminadas en comillas.

A continuación se proporciona la especificación léxica:

( define l e x i c a
’ ( ( white−sp
( whitespace ) skip )
( comment
( " %" ( arbno ( n o t #\ n e w l i n e ) ) ) s k i p )
( identificador
( l e t t e r ( arbno ( o r l e t t e r d i g i t " ? " ) ) ) s y m b o l )
( digitoDecimal
( d i g i t ( arbno d i g i t ) ) n u m b e r )
( digitoDecimal
( " - " d i g i t ( arbno d i g i t ) ) n u m b e r )
( digitoOctal
( " 0 x " ( or " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " )
( arbno ( o r " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " ) ) ) s t r i n g )
( digitoOctal
( " - " " 0 x " ( or " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " )
( arbno ( o r " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " ) ) ) s t r i n g )
( digitoHexadecimal
( " hx " ( or " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " " 8 " " 9 " " A " " B " " C " " D " " E " " F " )
( arbno ( o r " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " " 8 " " 9 " " A " " B " " C " " D " " E " " F " ) ) ) s t r i n g )
( digitoHexadecimal
( " - " " hx " ( or " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " " 8 " " 9 " " A " " B " " C " " D " " E " " F " )
( arbno ( o r " 0 " " 1 " " 2 " " 3 " " 4 " " 5 " " 6 " " 7 " " 8 " " 9 " " A " " B " " C " " D " " E " " F " ) ) ) s t r i n g )
( flotante
( d i g i t ( arbno d i g i t ) " . " d i g i t ( arbno d i g i t ) ) n u m b e r )
( flotante
( " - " d i g i t ( arbno d i g i t ) " . " d i g i t ( arbno d i g i t ) ) n u m b e r )
( cadena ( " \ " " ( o r d i g i t l e t t e r ) ( arbno ( o r l e t t e r d i g i t ) ) " \ " " ) s t r i n g )

))

La especificación gramatical es la siguiente:

( define gramatica
’(
( programa ( ( arbno s t r u c t − d e c l ) e x p r e s i o n ) a−programa )
( e x p r e s i o n ( b o o l − e x p r e s i o n ) bool−exp )
( e x p r e s i o n ( i d e n t i f i c a d o r ) var−exp )
( e x p r e s i o n ( numero−exp ) num−exp )
( e x p r e s i o n ( cadena ) cadena−exp )
( e x p r e s i o n ( v a r i a b l e ) decl−exp )
( e x p r e s i o n ( " ( " e x p r e s i o n p r i m i t i v a e x p r e s i o n " ) " ) prim−exp )
( e x p r e s i o n ( " c o n s t " i d e n t i f i c a d o r " = " e x p r e s i o n ) const−exp )
( e x p r e s i o n ( " 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 ) set−exp )
( e x p r e s i o n ( " l i s t " tipo−exp " ( " ( s e p a r a t e d − l i s t e x p r e s i o n " , " ) " ) " ) l i s t a − e x p )

; ; C o n d i c i o n a l e s y e s t r u c t u r a s de c o n t r o l
( e x p r e s i o n ( " if " e x p r e s i o n " { " e x p r e s i o n " else " e x p r e s i o n " } " ) if−exp )
( e x p r e s i o n ( " s w i t c h " " ( " i d e n t i f i c a d o r " ) " " { " ( arbno " c a s e " e x p r e s i o n e x p r e s i o n ) " d e f a u l t "
,→ e x p r e s i o n " } " ) swtich−exp )
( expresion ( " for " i d e n t i f i c a d o r " = " expresion " ; " expresion " ; " expresion " { " expresion " } " )
,→ for−exp )
( expresion ( " while " expresion " { " e x p r e s i o n " } " ) while−exp )

3
 ; ; S e c u e n c i a c i ó n
( e x p r e s i o n ( " b e g i n " ( s e p a r a t e d − l i s t e x p r e s i o n " ; " ) " e n d " ) begin−exp )

;; Funciones
( e x p r e s i o n ( " f u n c " i d e n t i f i c a d o r " ( " ( s e p a r a t e d − l i s t i d e n t i f i c a d o r tipo−exp " , " ) " ) " e x p r e s i o n "
,→ r e t u r n " e x p r e s i o n ) func−exp )
( expresion ( " call " i d e n t i f i c a d o r "(" ( s e pa r a te d − l i st expresion " ," ) ")" ) call−exp )

;; Objetos
( e x p r e s i o n ( " n e w " i d e n t i f i c a d o r " ( " ( s e p a r a t e d − l i s t e x p r e s i o n " , " ) " ) " ) new−obj )
( expresion ( " send " 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 pa r a te d − l is t expresion " ," ) ")" )
,→ method−invoke )

( v a r i a b l e ( " v a r N " i d e n t i f i c a d o r " = " e x p r e s i o n ) decl1−exp )

( v a r i a b l e ( " v a r T " i d e n t i f i c a d o r tipo−exp ) decl2−exp )

( b o o l − e x p r e s i o n ( " t r u e " ) true−exp )

( bool−expresion ( " false " ) false−exp )

( primitiva ( " + " ) sum−prim )

( primitiva ( " - " ) minus−prim )
( primitiva ( " * " ) plus−prim )
( primitiva ( " p o w " ) modulo−prim )
( primitiva ( " & " ) concat−prim )
( primitiva ( " mod " ) elevar−prim )
( primitiva ( " < " ) menor−prim )
( primitiva ( " > " ) mayor−prim )
( primitiva ( " <= " ) m i n o r i g u a l − p r i m )
( primitiva ( " >= " ) mayorigual−prim )
( primitiva ( " != " ) diferent−prim )
( primitiva ( " n o t " ) not−prim )
( primitiva ( " a n d " ) and−prim )
( primitiva ( " o r " ) or−prim )
( primitiva ( " x o r " ) xor−prim )
( primitiva ( " l e n g h t " ) lenght−prim )
( primitiva ( " n t h " ) nth−prim )

( numero−exp ( d i g i t o D e c i m a l ) decimal−num )
( numero−exp ( d i g i t o O c t a l ) octal−num )
( numero−exp ( d i g i t o H e x a d e c i m a l ) hexadecimal−num )
( numero−exp ( f l o t a n t e ) float )

( tipo−exp ( " int " ) int−tipo )

( tipo−exp ( " octal " ) octal−tipo )
( tipo−exp ( " h e x " ) hex−tipo )
( tipo−exp ( " float " ) float−tipo )
( tipo−exp ( " string " ) texto−tipo )
( tipo−exp ( " bool " ) bool−tipo )
( tipo−exp ( " void " ) void−tipo )

( s t r u c t − d e c l ( " t y p e " i d e n t i f i c a d o r " s t r u c t " i d e n t i f i c a d o r " { " ( arbno a t r i b u t o s ) ( arbno metodos ) "
,→ } " ) o b j − d e c l )
( a t r i b u t o s ( tipo−exp i d e n t i f i c a d o r ) a t t r − e x p )
( metodos ( " m e t h o d " i d e n t i f i c a d o r " ( " ( s e p a r a t e d − l i s t i d e n t i f i c a d o r tipo−exp " , " ) " ) " e x p r e s i o n "
,→ r e t u r n " e x p r e s i o n ) method−exp )
)
)

2.3. Estructuras de datos:

2.3.1. Constantes:
Números:
> ( s c a n&p a r s e " 1 1 1 2 1 " )
#( s t r u c t : a−programa ( ) #( s t r u c t : num−exp #( s t r u c t : decimal−num 1 1 1 2 1 ) ) )

> ( s c a n&p a r s e " 0 x 1 2 3 2 3 " )

#( s t r u c t : a−programa ( ) #( s t r u c t : num−exp #( s t r u c t : octal−num ”0 x12323 ” ) )

> ( s c a n&p a r s e " - h x 2 3 2 1 3 1 2 3 " )

#( s t r u c t : a−programa ( ) #( s t r u c t : num−exp #( s t r u c t : hexadecimal−num ”−hx23213123 ” ) ) )

( s c a n&p a r s e " 1 2 3 . 2 3 1 2 3 " )

#( s t r u c t : a−programa ( ) #( s t r u c t : num−exp #( s t r u c t : f l o a t 123.23123) ) )

Booleanos:

> ( s c a n&p a r s e " t r u e " )

#( s t r u c t : a−programa ( ) #( s t r u c t : bool−exp #( s t r u c t : true−exp ) ) )

4
> ( s c a n&p a r s e " f a l s e " )
#( s t r u c t : a−programa ( ) #( s t r u c t : bool−exp #( s t r u c t : f a l s e − e x p ) ) )

Listas:
> ( s c a n&p a r s e " l i s t h e x ( 0 x1 , 0 x2 , 0 x3 , 0 x4 , 0 x 5 ) " )
#( s t r u c t : a−programa
()
#( s t r u c t : l i s t a − e x p
#( s t r u c t : hex−tipo )
(#( s t r u c t : num−exp #( s t r u c t : octal−num ”0 x1 ” ) ) #( s t r u c t : num−exp #( s t r u c t : octal−num ”0 x2 ” ) ) #( s t r u c t
,→ : num−exp #( s t r u c t : octal−num ”0 x3 ” ) ) #( s t r u c t : num−exp #( s t r u c t : octal−num ”0 x4 ” ) ) #( s t r u c t :
,→ num−exp #( s t r u c t : octal−num ”0 x5 ” ) ) ) ) )

Texto:

> ( s c a n&p a r s e " \ " h o l a \ " " )

#( s t r u c t : a−programa ( ) #( s t r u c t : cadena−exp ”\” h o l a \ ” ” ) )

Se utiliza el escape
”para indicar que van comillas.

2.3.2. Variables

> ( s c a n&p a r s e " x " )

#( s t r u c t : a−programa ( ) #( s t r u c t : var−exp x ) )

2.3.3. Primitivas:
Las primitivas pueden operar de acuerdo al tipo de dato que se tiene, las primitivas que se tienen son:

Numéricas: +, −, ∗,pow,mod
Comparación: >, <, <=, >=, ! =, ==
Booleanos: and, or, not, xor

Texto: &, length

Listas: length, nth

>( s c a n&p a r s e " ( 2 m o d 7 ) " )

#( s t r u c t : a−programa ( ) #( s t r u c t : prim−exp #( s t r u c t : num−exp #( s t r u c t : decimal−num 2 ) ) #( s t r u c t :

,→ e l e v a r − p r i m ) #( s t r u c t : num−exp #( s t r u c t : decimal−num 7 ) ) ) )

2.4. Estructuras condicionales y de control

2.4.1. if:

> ( s c a n&p a r s e " i f ( 2 > 4 ) { 4 e l s e x } " )

#( s t r u c t : a−programa ( ) #( s t r u c t : i f − e x p #( s t r u c t : prim−exp #( s t r u c t : num−exp #( s t r u c t : decimal−num 2 ) ) #(

,→ s t r u c t : mayor−prim ) #( s t r u c t : num−exp #( s t r u c t : decimal−num 4 ) ) ) #( s t r u c t : num−exp #( s t r u c t :
,→ decimal−num 4 ) ) #( s t r u c t : var−exp x ) ) )

5
2.4.2. while:

> ( s c a n&p a r s e " w h i l e ( x < 7 ) { s e t x = ( x + 1 ) } " )

#( s t r u c t : a−programa
()
#( s t r u c t : while−exp
#( s t r u c t : prim−exp #( s t r u c t : var−exp x ) #( s t r u c t : menor−prim ) #( s t r u c t : num−exp #( s t r u c t : decimal−num
,→ 7 ) ) )
#( s t r u c t : set−exp x #( s t r u c t : prim−exp #( s t r u c t : var−exp x ) #( s t r u c t : sum−prim ) #( s t r u c t : num−exp #(
,→ s t r u c t : decimal−num 1 ) ) ) ) ) )

2.4.3. for:

> ( s c a n&p a r s e " f o r x = 3 ; ( x < 7 ) ; s e t x = ( x + 1 ) { s e t y = ( y * 2 ) } " )

#( s t r u c t : a−programa
()
#( s t r u c t : for−exp
x
#( s t r u c t : num−exp #( s t r u c t : decimal−num 3 ) )
#( s t r u c t : prim−exp #( s t r u c t : var−exp x ) #( s t r u c t : menor−prim ) #( s t r u c t : num−exp #( s t r u c t : decimal−num
,→ 7 ) ) )
#( s t r u c t : set−exp x #( s t r u c t : prim−exp #( s t r u c t : var−exp x ) #( s t r u c t : sum−prim ) #( s t r u c t : num−exp #(
,→ s t r u c t : decimal−num 1 ) ) ) )
#( s t r u c t : set−exp y #( s t r u c t : prim−exp #( s t r u c t : var−exp y ) #( s t r u c t : plus−prim ) #( s t r u c t : num−exp #(
,→ s t r u c t : decimal−num 2 ) ) ) ) ) )

2.4.4. switch:

> ( s c a n&p a r s e " s w i t c h ( x ) {

case 1 -0 x2323
case 2 32323
default 3232323} " )
#( s t r u c t : a−programa
()
#( s t r u c t : swtich−exp
x
(#( s t r u c t : num−exp #( s t r u c t : decimal−num 1 ) ) #( s t r u c t : num−exp #( s t r u c t : decimal−num 2 ) ) )
(#( s t r u c t : num−exp #( s t r u c t : octal−num ”−0x2323 ” ) ) #( s t r u c t : num−exp #( s t r u c t : decimal−num 3 2 3 2 3 ) ) )
#( s t r u c t : num−exp #( s t r u c t : decimal−num 3 2 3 2 3 2 3 ) ) ) )

2.5. Creación de variables:

( s c a n&p a r s e " v a r N a = 3 " )

#( s t r u c t : a−programa ( ) #( s t r u c t : decl−exp #( s t r u c t : decl1−exp a #( s t r u c t : num−exp #( s t r u c t : decimal−num
,→ 3 ) ) ) ) )

( s c a n&p a r s e " v a r T a i n t " )

#( s t r u c t : a−programa ( ) #( s t r u c t : decl−exp #( s t r u c t : decl2−exp a #( s t r u c t : i n t − t i p o ) ) ) )

2.6. Funciones
2.6.1. Creación:

( s c a n&p a r s e " f u n c p ( a int , b s t r i n g , c h e x ) s e t x = 4 r e t u r n x " )

#( s t r u c t : a−programa ( ) #( s t r u c t : func−exp p ( a b c ) (#( s t r u c t : i n t − t i p o ) #( s t r u c t : t e x t o − t i p o ) #( s t r u c t :
,→ hex−tipo ) ) #( s t r u c t : set−exp x #( s t r u c t : num−exp #( s t r u c t : decimal−num 4 ) ) ) #( s t r u c t : var−exp x ) ) )

2.6.2. Invocación:

6
> ( s c a n&p a r s e " c a l l p (1 , 2 , 3 ) " )
#( s t r u c t : a−programa ( ) #( s t r u c t : c a l l − e x p p (#( s t r u c t : num−exp #( s t r u c t : decimal−num 1 ) ) #( s t r u c t :
,→ num−exp #( s t r u c t : decimal−num 2 ) ) #( s t r u c t : num−exp #( s t r u c t : decimal−num 3 ) ) ) ) )

2.7. Secuenciación y estado

> ( s c a n&p a r s e " b e g i n s e t x = 3 ; s e t y = ( x + 1 ) ; y e n d " )

#( s t r u c t : a−programa
()

3. Evaluación
En este taller se solicita:

1. (30 puntos:) Primitivas. Recuerde que hay de distinto tipo. Ejemplo:

#I n t e r p r e t a d o r : (4 + 5)
9
#I n t e r p r e t a d o r : ( hx4E + hx12 )
hx60
#I n t e r p r e t a d o r : ( 0 x7 ∗ 0 x5 )
0 x43
#I n t e r p r e t a d o r : (0 > 7)
false
#I n t e r p r e d a d o r : ( 0 != 3 )
true

Las operaciones numéricas deben permitir trabajar con flotantes, hexadecimales y octales. Si no las realiza
el punto no será válido
2. (30 puntos:) Estructuras de control
#I n t e r p r e t a d o r : i f ( 2 > 4 ) { 4 e l s e 3 }
4
#I n t e r p r e t a d o r : s w i t c h ( x ) {
c a s e 1 −0x2323
c a s e 2 32323
d e f a u l t 32 32 323}
// Supongamos que x v a l e 32
3232323
#I n t e r p r e t a d o r : f o r x = 3 ; ( x < 7 ) ; s e t x = ( x +1) { s e t y = ( y ∗ 2 ) }
// S e t e s una o p e r a c i o n de e f e c t o , e n t o n c e s d e v u e l v e v o i d
#( s t r u c t : v o i d − t i p o )
#I n t e r p r e t a d o r : w h i l e ( x < 7 ) { s e t x = ( x + 1 ) }
#( s t r u c t : v o i d − t i p o )

Haga ejemplos que devuelvan un valor, para esto use begin.

3. (25 puntos:) Funciones y secuenciación.

#I n t e r p r e t a d o r : f u n c p ( a i n t , b s t r i n g , c hex ) b e g i n varN x = a ; s e t x = ( ( x + 1 ) +(b+c ) ) ; set

,→ x = ( x ∗ 2 ) end r e t u r n ( x+2)
#( s t r u c t : v o i d − t i p o )
#I n t e r p r e t a d o r : c a l l p ( 1 , 2 , 3 )
14

Para las funciones piense en una forma de cómo representarlas, no se requiere una clausura ya que existe
un sólo ambiente por todo el código, pero requerimos alguna forma de poder utilizarlas.
4. (15 puntos:) La representación de ambientes es de alcance global, es decir que existe un ambiente por
todo el código, sin embargo usted debe considerar para la variable de control en el for y el alcance de
variables dentro de las funciones.

Diseñe una representación de ambiente y genere un ambiente inicial con 3 variables con cualquier va-
lor desee darle. Explique las razones de realzar su representación.

7
// Supongamos que tenemos que x = 3
#I n t e r p r e t a d o r x
3
#I n t e r p r e t a d o r varN x = 3
" Error : x ya existe "
#I n t e r p r e t a d o r s e t x = 0 x4
#( s t r u c t : v o i d − t i p o )
#I n t e r p r e t a d o r x
0 x4