probacionDeTipos PDF

Procesadores de Lenguajes
Ingeniera Tcnica superior de Ingeniera Informtica

Departamento de Lenguajes y Sistemas informticos
Javier Vlez Reyes
jvelez@lsi.uned.es
Departamento de Lenguajes Y Sistemas Informticos
UNED
Anlisis semntico II
Comprobacin de tipos
Javier Vlez Reyes jvelez@lsi.uned.es
Anlisis semntico. Comprobacin de tipos
Objetivos
Objetivos
Aprender qu es la comprobacin de tipos
Entender qu es un sistema de tipos
Conocer los elementos constituyentes de un sistema de tipos
Conocer qu es una expresin de tipos
Aprender a escribir expresiones de tipos
Aprender las diferencias entre comprobacin esttica y dinmica
Entender qu es la equivalencia de tipos
Aprender las diferencias entre los distintos tipos de equivalencia de tipos
Entender qu es y como funciona la conversin de tipos
Entender qu es la sobrecarga y qu tipos de sobrecarga existen
Aprender a implementar un comprobador de tipos
Conocer las principales estructuras de datos y artefactos necesarios
ndice
ndice
Introduccin
Smbolos
Tipos
mbitos de declaracin
El sistema de tipos
Qu es el sistema de tipos?
Tipos primitivos
Constructores de tipos
Equivalencia de tipos
Verificacin de tipos sobre operadores
Verificacin de tipos sobre subprogramas
Construccin de un comprobador de tipos
Qu es un comprobador de tipos
Artefactos de un comprobador de tipos
Apertura de mbito inicial
Declaracin de constantes
Declaracin de tipos
Declaracin de variables
Declaracin de subprogramas
Expresiones
Sentencias
Cierre de mbitos
Temas avanzados de un comprobador de tipos
Inferencia de tipos
Sobrecarga de subprogramas
Recuperacin de errores semnticos
Desarrollo paso a paso
Bibliografa
Introduccin
Anlisis semntico
La fase de anlisis semntico tiene por objetivo analizar los componentes del rbol de
anlisis sintctico que representan el programa con el fin de comprobar que se respetan
ciertas reglas semnticas que dan un significado coherente a las construcciones del
lenguaje
El analizador semntico va
comprobando la coherencia
semntica del rbol de anlisis
sintctico segnse va construyendo
Foco de atencin
Las responsabilidades son
Registrar declaraciones
Inferir tipos
Comprobar tipos
Comprobar correccin semntica
Analizador
semntico
SWhile
WHILE E DO S
E > E
SWhile
WHILE E DO S
E > E


Introduccin
Conceptos esenciales
Los lenguajes modernos se articulan a partir de una estructura de
bloques donde se pueden hacer declaraciones que luego sern
referenciadas a lo largo del programa
CONST MAX = 10;
TYPE TVector = ARRAY [1..10] OF REAL;
VAR v, w : TVector;
i : INTEGER;
PROCEDURE Leer (VAR m: TVector);
VAR i : INTEGER;
FUNCTION Validar (VAR v: INTEGER): INTEGER;
BEGIN
Validar := v mod 10;
END;
BEGIN
FOR i := 1 TO 10 DO
m [i] := Validar (Read (i));
END;
END;
FUNCTION suma (m, n: TVector) : TVector;
VAR i : INTEGER;
vSuma : TVector;
BEGIN
WHILE (i < MAX) DO
vSuma [i] := m[i] + n[i];
INC (i);
END;
suma := vSuma;
END;
BEGIN
Leer (v);
Leer (w);
v := suma (v, w);
END.
Smbolos
Un smbolo de un programa es cualquier elemento con
nombre que el programador haya establecido como
vlido dentro de l a travs de una declaracin
El ejercicio de creacin de un programa consiste en la
declaracin de una coleccin de smbolos con nombres que
representanentidades semnticas utilizadas a lo largo del cdigo
El tipo de smbolos que
pueden declararse en un
programa es una
caracterstica propia del
lenguaje. No obstante puede
identificarse ciertos tipos de
smbolos recurrentes tales
como constantes, variables,
funciones, procedimientos o
parmetros
Algunos lenguajes permiten
elidir la declaracin de los
smbolos y utilizan reglas de
inferencia para determinar los
smbolos que son utilizados a
lo largo del programa
Introduccin
Tipos
Un tipo es un descriptor semntico que permite cualificar
al smbolo al que est vinculado de manera que
condiciona su interpretacin semntica y restringe las
operaciones que se puedenrealizar sobre l
Cada smbolo del lenguaje lleva asociado un tipo. El tipo de un
smbolo se utiliza para proporcionar informacin al compilador de
cmo debe tratar semnticamente al mismo y qu operaciones
debe permitir realizar sobre l
CONST MAX = 10;
VAR v, w : TVector;
i : INTEGER;
VAR i : INTEGER;
BEGIN
END;
BEGIN
FOR i := 1 TO 10 DO
END;
END;
VAR i : INTEGER;
vSuma : TVector;
BEGIN
WHILE (i < MAX) DO
INC (i);
END;
suma := vSuma;
END;
BEGIN
Leer (v);
Leer (w);
v := suma (v, w);
END.
Todo lenguaje dispone de una
coleccin de tipos primitivos y
tambin de ciertos
mecanismos semnticos para
construir nuevos tipos a partir
de otros previamente
definidos
En aquellos lenguajes donde
la tipificacin no es explcita
los smbolos adquieren un
tipo tan pronto como sea
posible aplicando reglas de
inferencia de tipos
Introduccin
mbitos de declaracin y alcance de visibilidad
Un mbito es un bloque acotado sintcticamente dentro
del cual los smbolos all declarados tienen vigencia
Cada smbolo se declara dentro de un bloque acotado por ciertas
construcciones sintcticas. Se entiende que dentro de dicho
bloque la declaracin tiene vigencia y puede ser utilizada
mientras que fuera no existe y pueden declararse otros smbolos
incluso aunque compartanel mismo nombre
En lenguajes estilo Pascal las
construcciones sintcticas que
representan creaciones de
nuevos mbitos, a parte del
global, son nicamente la
declaracin de funciones y
procedimientos
En lenguajes estilo C,
adems de las funciones y el
mbito global, cualquier
bloque de sentencias acotado
entre llaves constituye un
mbito de declaracinnuevo
CONST MAX = 10;
VAR v, w : TVector;
i : INTEGER;
VAR i : INTEGER;
BEGIN
END;
BEGIN
FOR i := 1 TO 10 DO
END;
END;
VAR i : INTEGER;
vSuma : TVector;
BEGIN
WHILE (i < MAX) DO
INC (i);
END;
suma := vSuma;
END;
BEGIN
Leer (v);
Leer (w);
v := suma (v, w);
END.
Introduccin
Los lenguajes de programacin articulan la definicin de programas
a travs de la declaracin de smbolos convenientemente tipificados
que luego son referenciados a lo largo del cdigo
Anidamiento de mbitos
Dadas varias declaraciones diferentes para el mismo
nombre en distintos mbitos anidados, la declaracin que
se aplica a una referencia es aqulla que se encuentre en
el bloque anidado ms prximo a la misma
Cuando dos mbitos se encuentran sintcticamente anidados
uno dentro de otro, desde el ms interno tienen visibilidad todas
las declaraciones de smbolos realizadas en el mbito ms
externo. Si dentro del mbito interno se declara un nuevo smbolo
con el mismo nombre que un smbolo en el mbito externo, la
declaracin que pasa a tener vigencia es la realizada dentro del
mbito interno. Esto es cierto para cualquier nivel de anidamiento
CONST MAX = 10;
VAR v, w : TVector;
i : INTEGER;
VAR i : INTEGER;
BEGIN
END;
BEGIN
FOR i := 1 TO 10 DO
END;
END;
VAR i : INTEGER;
vSuma : TVector;
BEGIN
WHILE (i < MAX) DO
INC (i);
END;
suma := vSuma;
END;
BEGIN
Leer (v);
Leer (w);
v := suma (v, w);
END.
Regla de anidamiento ms cercano
m
b
i
t
o

n
i
v
e
l

0
m
b
i
t
o

n
i
v
e
l

1
m
b
i
t
o

n
i
v
e
l

1
m
b
i
t
o

n
i
v
e
l

2
Introduccin
Qu es la comprobacin de tipos?
La labor de comprobacin de tipos consiste en conferir a las construcciones sintcticas del lenguaje la
semntica de tipificacin que acabamos de describir y en realizar todo tipo de comprobaciones de dicha
ndole. Por su naturaleza, sin embargo, sta se encuentra repartida entre la fase de anlisis semntico
y la generacinde cdigo intermedio
Anlisis semntico
Generacin cdigo
intermedio
S
WHILE E DO S
E > E
S
WHILE E DO S
E > E
LD a t1
LD b t2
GRT t3 t1 t2
BRZ t3 L1
I. Comprobaciones estticas
II. Comprobaciones dinmicas
Las comprobaciones estticas recogen el compendio de todas aquellas
tareas de carcter semntico que, por su naturaleza, pueden ser realizadas
directamente durante la fase de compilacin mediante el uso de los
artefactos y mecanismos propios de dicha fase. Este tipo de
comprobaciones son beneficiosas puesto que confieren seguridad a la
ejecucindel programa
Las comprobaciones dinmicas son aquellas que no se realizan durante la
fase de compilacin y se delegan al momento de la ejecucin del programa.
Ello requiere generar cdigo ejecutable especficamente diseado para
realizar tales comprobaciones. Los lenguajes con una carga excesiva de
comprobaciones dinmicas generan programas ms largos, lentos e
inseguros en ejecucin
Tipos de comprobaciones semnticas
Tema 7
Tema 8-9

Introduccin
Tipos de comprobaciones semnticas estticas
I. Gestin de declaraciones
III. Inferencia de tipos
Se encarga de registrar todas las declaraciones realizadas por el
programador a lo largo de los distintos mbitos. Esta tarea implica el
registro de tipos y la comprobacin de que no se produce ninguna colisin
de nombres con los identificadores de otras declaraciones
En lenguajes sin tipificacin de variables o con sobrecarga se aplican
tareas de inferencia de tipos en el nivel gramatical de las expresiones para
resolver el tipo de datos de la expresin resultante en funcin del
contexto de evaluacin
II. Verificacin de tipos
Comprueba la compatibilidad de tipos de todas las expresiones del cdigo
fuente recuperando la informacin durante la gestin de declaraciones.
Adems se asegura de que no existe en el programa ninguna referencia a
ningnsmbolo no declarado
Qu es la comprobacin de tipos?
La labor de comprobacin de tipos consiste en conferir a las construcciones sintcticas del lenguaje la
semntica de tipificacin que acabamos de describir y en realizar todo tipo de comprobaciones de dicha
ndole. Por su naturaleza, sin embargo, sta se encuentra repartida entre la fase de anlisis semntico
y la generacinde cdigo intermedio
CONST MAX = 10;
VAR v, w : TVector;
i : INTEGER;
WHILE (i < MAX) DO ...
v := suma (v, w);
CONST MAX = 10;
Sistemas de tipos
El documento que recoge toda la informacin relativa a la tipificacin de un lenguaje de programacin,
desde sus tipos primitivos, hasta sus tipos estructurados pasando por sus reglas de combinacin
operacional, recibe el nombre de sistema de tipos
El sistema de tipos de un lenguaje es una especificacin de alto nivel que
describe de forma precisa el conjunto de reglas y restricciones semnticas de
tipificacinque se aplicansobre las construcciones sintcticas del lenguaje
Niveles de tipificacin
El sistema de tipos de un lenguaje condiciona, de manera directa, la seguridad de los programas en
tiempo de ejecucin. En efecto, cuantas ms comprobaciones se hagan en tiempo de compilacin,
menor ser la probabilidad de fallo en ejecucin. El nivel de construccin del sistema de tipos
permite clasificar a los lenguajes en 2 categoras
Niveles de
tipificacin
Lenguajes fuertemente tipificados
Lenguajes dbilmente tipificados
La tipificacin fuerte implica un nivel de construccin elevado y es
propia de lenguajes de programacin seguros como Pascal, Ada o
Modula
La tipificacin dbil implica pocas restricciones en el sistema de tipos
y delega la mayor parte de la comprobacin al tiempo de ejecucin.
Es propia de lenguajes de scriptingcomo Groovy o J avascript
Sistemas de tipos
El documento que recoge toda la informacin relativa a la tipificacin de un lenguaje de programacin,
desde sus tipos primitivos, hasta sus tipos estructurados pasando por sus reglas de combinacin
operacional, recibe el nombre de sistema de tipos
Expresiones de tipos
Para definir el sistema de tipos de un lenguaje de manera formal, sistemtica e independientemente
de las sintaxis propia del mismo se utilizan expresiones de tipos. Cada tipo primitivo tiene una
expresin de tipo asociada. Cada constructor de tipo tiene tambin una expresin de tipo. Cada tipo
definido mediante la composicin de constructores de tipos y tipos primitivos tiene a su vez una
expresinde tipos
Una expresin de tipos es un mecanismo formal utilizado por los sistemas
de tipos para representar el tipo de una construccin sintctica propia del
lenguaje
El sistema de tipos de un lenguaje es una especificacin de alto nivel que
describe de forma precisa el conjunto de reglas y restricciones semnticas de
tipificacinque se aplicansobre las construcciones sintcticas del lenguaje
Sistemas de tipos
Elementos de un sistema de tipos
La descripcin del sistema de tipos de un lenguaje de programacin se articula, fundamentalmente,
mediante la definicin de los tipos primitivos y constructores compuestos, sus reglas de composicin,
las operaciones permitidas sobre cada uno de ellos y el tipo de resultado que provocan
Tipos primitivos
Expresin de tipos Tipo
Byte
Integer
Word
Real
Double
Boolean
Char
String
Representacin numrica corta sin signo
Representacin numrica con signo
Representacin numrica larga sin signo
Representacin flotante corta con signo
Representacin flotante larga con signo
Representacin lgica
Representacin de carcter
Representacin de cadena
Descripcin Rango
0 a 255
-32768 a 32767
0 a 65535
2.9E-39 a 1.7E38
5.0E-324 a 1.7E308
False, True
ASCII
-
ENTERO
ENTERO
ENTERO
REAL
REAL
LOGICO
CARCTER
CADENA
Operaciones
+ * / mod = > < <>
+ * / mod = > < <>
+ * / mod = > < <>
+ * / = > < <>
+ * / = > < <>
AND OR XOR NOT
-
-
Los tipos primitivos de un lenguaje determinan la coleccin de tipos de datos originales que el
lenguaje pone a disposicin del programador para componer estructuras de datos ms complejas. La
variedad de tipos primitivas es una caracterstica propia del lenguaje pero en general se distinguen
cuatro categoras: ordinales, reales, lgicos y de carcter
Sistemas de tipos
Expresin de tipos Ejemplo
TVector = ARRAY [1..10] OF INTEGER Representa una formacin lineal de
elementos de un mismo tipo de base
Descripcin
ARRAY (1..10, ENTERO)
Los constructores de tipos son mecanismos sintcticos del lenguaje que permiten combinar otras
construcciones de tipos, primitivos o compuestos, para generar estructuras ms complejas. Los tipos
as generados se llaman tipos complejos, tipos compuestos o tipos definidos por el usuario
TPunto = RECORD BEGIN
X: INTEGER;
Y: INTEGER
END;
Representa una estructura de datos
constituida por una coleccin de
campos con nombre de distinto tipo
RECORD ( (X x ENTERO) x (Y x ENTERO) )
^ TPunto Representa un puntero a un rea de
memoria reservada para almacenar
datos de un determinado tipo de base
POINTER (TPunto)
TConjunto = SET OF INTEGER Representa un conjunto no ordenado
de elemento de un mismo tipos de
datos de base
SET (ENTERO)
Sistemas de tipos
Expresin de tipos Ejemplo
FUNCTION suma (m, n: TVector):
Tvector;
Representa una declaracin de funcin
con parmetros y tipo de retorno
definido
Descripcin
(Tvector x TVector) TVector
PROCEDURE Leer ( n: TVector); Representa una declaracin de
procedimiento con parmetros
definidos
(Tvector) TVector
(INTEGER; INTEGER) Representa una tupla de datos
constituida por una coleccin ordenada
de datos de distinto tipo
(ENTERO) x (ENTERO)
TPalos = (OROS, COPAS,
ESPADAS, BASTOS);
Representa una coleccin de etiquetas
que se comportan como constantes
simblicas de valor numrico
ENUM (OROS, COPAS, ESPADAS, BASTOS)
Sistemas de tipos
Ejercicios
Una vez que se conoce la expresin de tipos de los
principales tipos del lenguaje y de los constructores
de tipos pueden construirse las expresiones de
tipos para diferentes tipos definidos por el usuario
TPEntero = ^ INTEGER;
TMatriz = ARRAY [1..3][1..6];
TPersona = RECORD
BEGIN
nombre: STRING;
edad : INTEGER;
END;
FUNCTION mayor (a, b: INTEGER): INTEGER;
FUNCTION ordenar (p: TPEntero) : TPEntero;
TLista = RECORD
BEGIN
vector: ARRAY [1..10] OF INTEGER;
longitud: INTEGER;
END;
TTabla = ARRAY [1..100] OF ^TLista;
TCjtoTablas = SET OF ^TTabla;
Sistemas de tipos
De cara a realizar comprobaciones estticas, resulta interesante definir la equivalencia entre dos tipos
complejos del lenguaje. Esta definicin puede formularse en trminos del nombre que reciben sendos
tipos dentro del cdigo o entre las expresiones de tipos subyacentes. Esto permite distinguir entre
dos formas de entender la equivalencia lo cual es una caracterstica intrnseca del lenguaje
I. Equivalencia nominal
TYPE
T1 = ARRAY [1..10] OF INTEGER;
T3 = T1
Se dice que dos tipos de datos T
1
y T
2
son
nominalmente equivalentes si responden a
una misma entrada dentro del registro de
tipos realizado por el compilador durante la
gestinde declaraciones
T1
T2
T3
Equivalente
No equivalente
Equivalente
No equivalente
Equivalente
No Equivalente
Equivalente
No equivalente
Equivalente
T1 T2 T3
Sistemas de tipos
II. Equivalencia estructural
TYPE
T3 = T1
Se dice que dos tipos de datos son
estructuralmente equivalentes si son el
mismo tipo bsico o estn formadas
mediante la aplicacin del mismo
constructor de tipos sobre expresiones de
tipos estructuralmente equivalentes
T1
T2
T3
Equivalente
Equivalente
Equivalente
Equivalente
Equivalente
Equivalente
Equivalente
Equivalente
Equivalente
T1 T2 T3
Sistemas de tipos
II. Equivalencia estructural
boolean equivale (TypeIF s, TypeIF t) {
if (s == t) return true;
if ((s == ARRAY (s
1
, s
2
) && t == ARRAY (t
1
,t
2
)) ||
(s == (s
1
x s
2
) && t == (t
1
x t
2
)) ||
(s == (s
1
s
2
) && t == (t
1
t
2
)))
return equivale (s
1
,t
1
) && equivale (t
2
, t
2
);
if ((s == Pointer (s
1
) && t == Pointer (t
1
)) ||
(s == Set (s
1
) && t == Set (t
1
))
return equivale (s
1
,t
1
);
return false
}
Se dice que dos tipos de datos son
estructuralmente equivalentes si son el
mismo tipo bsico o estn formadas
mediante la aplicacin del mismo
constructor de tipos sobre expresiones de
tipos estructuralmente equivalentes
Ojo con las definiciones de
tipos recursivos

Sistemas de tipos
La mayora de operadores de un lenguaje de programacin pueden operarse satisfactoriamente
sobre un subconjunto de tipos primitivos del lenguaje. Esto desencadena una serie de conceptos tan
interrelacionados entre si que conviene abordarlos conjuntamente
I. Sobrecarga de operadores
2 + 3
4.2 + 3.8
En estos ejemplos en Pascal puede verse como
el sistema de tipos del lenguaje, define el
operador suma de forma sobrecargada ya que
puede ser evaluado en el contexto de 2
subexpresiones de tipo entero o tipo flotante,
entre otros. Otros lenguajes, como Fortran
utilizan por el contrario operadores diferentes
Se dice que un operador est
sobrecargado cuando se puede utilizar
para operar sobre un subconjunto de tipos
de datos primitivos del lenguaje
2 + 3
4.2 +. 3.8
Pascal Fortran
La capacidad de poder utilizar un mismo
operador para articular diferentes operaciones
en funcin de los tipos de datos involucrados se
llama sobrecarga de operadores. Es frecuente
sobrecargar los operadores aritmticos y
relacionales de un lenguaje
Sistemas de tipos
II. Compatibilidad de tipos
2 + 3.5
4.2 * 3
En los ejemplos en Pascal puede verse como
los operadores sobrecargados suma (+) y
producto (*) definen los tipos entero y real como
compatibles entre s, mientras que en C resultan
compatibles el tipo carcter, entero y flotante
con respecto a los mismos operadores
Se dice que dos tipos son compatibles
entre si, con respecto a un operador, si son
equivalentes o si se pueden operar
satisfactoriamente a travs de dicho
operador
a + 3.5
4.2 * 3
Pascal C
La capacidad de sobrecarga de los operadores
de un lenguaje, introduce el concepto de
compatibilidad de tipos, que se aplica cuando
dichos tipos pueden ser satisfactoriamente
operados a travs de un operador sobrecargado
Sistemas de tipos
III. Coercin de tipos
2 + 3.5
4.2 * 3
En los ejemplos de Pascal ambas operaciones
operan entre reales y por tanto los operandos
enteros se convierten a real. Igual ocurre con la
primera expresin en C que convierte el carcter
a a entero y de ah a flotante para poder
operarse. Estas conversiones se llaman
implcitas. Sin embargo la ultima fuerza a
convertir el flotante a entero con perdida de
informacin. Esta conversin es explcita
La coercin de tipos es el proceso
mediante el cual el sistema de tipos
convierte la subexpresin menos restrictiva
hacia la ms restrictiva cuando ambas son
de distinto tipo
a + 3.5
(int) 4.2 * 3
Pascal C
La compatibilidad de tipos permite operar
expresiones de tipos diferentes pero
comnmente fuerza conversiones de tipo hacia
el tipo ms restrictivo. Este efecto recibe el
nombre de conversino coercinde tipos
Sistemas de tipos
Byte
Integer
Word
Real
Double
Error
Error
Error
Byte
Integer
Word
Real
Double
Boolean
Char
String
...
Byte Integer Word Real Double Boolean Char String
Integer
Integer
Word
Real
Double
Error
Error
Error
Word
Word
Word
Real
Double
Error
Error
Error
Real
Real
Real
Real
Double
Error
Error
Error
Double
Double
Double
Double
Double
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
+
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
Error
operador
tipos
Coercin o error
Matriz de compatibilidad para el operador +
Constructores
de tipos
Sistemas de tipos
Verificacin de tipos sobre subprogramas
La sobrecarga es un trmino que puede ser igualmente aplicado sobre los procedimientos y
funciones declarados en un programa. Esto permite soportar diferentes implementaciones de un
mismo subprograma con igual identificador pero diferente, nmero, tipo u orden de parmetros
formales en su declaracin. La implementacin invocada depender de los tipos aplicados en la
expresinde llamada
El procedimiento de suma est
sobrecargado. La sobrecarga de
subprogramas es ms propia de
lenguajes orientados a objetos que
de lenguajes estructurados. En ese
contexto se llama polimorfismo
La sobrecarga de subprogramas es la capacidad de un lenguaje de
permitir la declaracin de varios procedimientos o funciones con el mismo
nombre pero distinto, nmero, tipo u orden de parmetros formales
TYPE TVector = ARRAY [1..10] OF INTEGER
TMatriz = ARRAY [1..10][1..5] OF INTEGER
VAR v, w: Tvector; m, n : TMatriz;
PROCEDURE sumar (v, w: TVector; VAR r:TVector); ...
PROCEDURE sumar (m, n: TMatriz; VAR r:TMatriz); ...

Construccin de comprobadores de tipos en la prctica
Qu es un comprobador de tipos?
Una vez descritas las responsabilidades y caractersticas de un sistema de tipos, es preciso
implementarlo en la practica a travs de los mecanismos proporcionados por los esquemas de
traduccin dirigidos por la sintaxis. A la parte de un compilador que implementa el sistema de tipos se le
llama comprobador de tipos
Un comprobador de tipos es la parte del compilador que se encarga de
implementar el sistema de tipos del lenguaje a travs de mecanismos de
traduccindirigida por la sintaxis
expresion ::= expresion:e1 MAS expresion:e2
{: t1 = <<recuperar tipo de e1>>
t2 = <<recuperar tipo de e2>>
<<Comprobar la compatibilidad de t1 y t2 para +>>
No: <<Error semntico>>
si: <<otras acciones semnticas>>
:}
Ejemplo
En el caso de las expresiones es
necesario recuperar el tipo de cada
subexpresin y comprobar su
compatibilidad con respecto al
operador que las combina. Si no
son compatibles se emite un
mensaje de error semntico

Antes de comenzar con la descripcin de la implementacin del comprobador de tipos para cada parte
de la gramtica de un lenguaje es necesario presentar la coleccin de artefactos que sern utilizados
dentro de la misma. A continuacindescribimos aquellos que aparecenen el framework de soporte
ScopeManager
SymbolTable Scope TypeTable
Consltese el documento
directrices de implementacin
SymbolIF TypeIF
SymbolBase SymbolBase
SymbolConstant
SymbolVariable SymbolFunction
SymbolProcedure
SymbolParameter
TypeSimple
TypeRecord
TypeUnion
TypeArray
TypeEnum
TypeSet
TypePointer
TypeProcedure
TypeFunction
SemanticErrorManager
Tipos primitivos y constructores de tipos
Las clases que implementan el interfaz TypeIF representan los tipos primitivos del lenguaje y cada
uno de los constructores de tipos del mismo. El primer paso es determinar los atributos y mtodos
necesarios para caracterizarlos (entendemos que los nombres de cada clase son autoexplicativos)
TypeBase
-String name
-ScopeIF scope
+ String getName ()
+ void setName (String name)
+ ScopeIF getScope ()
+ void setScope (ScopeIF scope)
+ int getSize()
+ boolean equals ()
+ hashcode ()
+ toString ()
Todos los tipos contienen un nombre y un mbito de
declaracin por tanto pueden factorizarse en la clase
abstracta TypeBase e implementar sendos mtodos
de consulta y modificacin
Propiedad name y scope
Para mantener limpio el cdigo del esquema de
traduccin en Cup se recomienda implementar la
equivalencia de tipos nominal o estructural en este
mtodo
Sobrescritura de mtodos de Object
Igualmente se recomienda la implementacin de los
mtodos hashcode y toString heredados de clase
Object. Consulte tema 6 para obtener detalles
Tipos primitivos y constructores de tipos
Las clases que implementan el interfaz TypeIF representan los tipos primitivos del lenguaje y cada
uno de los constructores de tipos del mismo. El primer paso es determinar los atributos y mtodos
necesarios para caracterizarlos (entendemos que los nombres de cada clase son autoexplicativos)
TypeSimple
TypeRecord
TypeUnion
TypeEnum TypeSet TypePointer TypeProcedure
-String name
-ScopeIF scope
-int size
TypeArray
-String name
-ScopeIF scope
-int min
-int max
-TypeIF base
-String name
-Map <String, TypeIF> fields
-ScopeIF scope
-String name
-TypeIF base
-ScopeIF scope
-String name
-List <String> values
-ScopeIF scope
-String name
-ScopeIF scope
-TypeIF base
-String name
-List <TypeIF> parameters
-ScopeIF scope
TypeFunction
-TypeIF rType
-ScopeIF scope
-String name
-Map <String, TypeIF> baseFields
-Map <String, Map<String, TypeIF>> variants
-ScopeIF scope
Smbolos
Las clases que implementan la interfaz SymbolIF representan smbolos que han sido declarados por
el usuario programador dentro del lenguaje. Para cada tipo de smbolo tambin conviene identificar
los atributos propios que lo caracterizande manera preliminar
SymbolBase
-String name
-TypeIF type
-ScopeIF scope
+ String getName ()
+ void setName (String name)
+ ScopeIF getScope ()
+ void setScope (ScopeIF scope)
+ TypeIF getType ()
+ void setType (TypeIF type)
+ boolean equals ()
+ hashcode ()
+ toString ()
Todos los smbolos contienen un nombre y un mbito
de declaracin por tanto pueden factorizarse en la
clase abstracta SymbolBase e implementar sendos
mtodos de consulta y modificacin
Propiedad name y scope
Propiedad Tipo
De forma similar, todos los smbolos declarados tienen
un tipo, ya sea declarado explcitamente o inferido
luego el tipo es otra propiedad que puede factorizarse
en esta clase
Sobrescritura de mtodos de Object
Igualmente se recomienda la implementacin de los
mtodos hashcode y toString heredados de clase
Object. Consulte tema 6 para obtener detalles
Smbolos
Las clases que implementan la interfaz SymbolIF representan smbolos que han sido declarados por
el usuario programador dentro del lenguaje. Para cada tipo de smbolo tambin conviene identificar
los atributos propios que lo caracterizande manera preliminar
SymbolProcedure SymbolConstant SymbolParameter SymbolVariable
-String name
-TypeIF type
-ScopeIF scope
-Integer Address
-String name
-TypeIF type
-ScopeIF scope
-String name
-TypeIF type
-ScopeIF scope
-String name
-TypeIF type
-Number value
-ScopeIF scope
SymbolFunction
-String name
-TypeIF Type
-ScopeIF scope
Al igual que en el caso de los tipos, estas
definiciones sern potencialmente
extendidas cuando avancemos en la
construccin del compilador

Gestor de errores semnticos y trazabilidad
Cuando se detecta un error semntico durante el proceso de compilacin, el comprobador de tipos
debe emitir un mensaje de error. El gestor de errores proporciona mtodos para informar de errores
recuperables y no recuperables as como para trazar la ejecucin del comprobador semntico
SemanticErrorManager
+ void semantiDebug (String message)
+ void semanticInfo (String message)
+ void semanticWarn (String message)
+ void semanticError (String message)
+ void semanticFatal (String message)
exp ::= exp:e1 MAS exp:e2 {:
TypeIF t1 = <<obtener tipo e1>>
TypeIF t2 = <<obtener tipo e2>>
semanticErrorManager.semanticDebug (Tipo de e1: + t1);
semanticErrorManager.semanticDebug (Tipo de e2: + t2);
if (t1.isCompatible (t2, TypeIF.MAS)) {
...
} else semanticErrorManager.semanticFatalError (tipos incompatibles);
:}
Tablas de tipos
Una tabla de tipos es una estructura de datos de tabla hash donde se registran todas las
declaraciones de tipos realizadas por el usuario programador en un determinado mbito
TypeTable
Private ScopeIF scope;
private Map <String, TypeIF> tTable;
public TypeTable (ScopeIF scope) {
this.scope = scope;
tTable = new HashMap<String, TypeIF> ();
}
public TypeIF getType (String id) {
return tTable.get (id);
}
public void addType (TypeIF type) {
String id = type.getName ();
addType (id, type); }
TypeTable (contina)
public void addType (String id, TypeIF type){
type.setScope (this.scope);
tTable.put (id, type);
}
public boolean containsType (String id) {
return tTable.containsKey (id);
}
public boolean containsType (TypeIF type) {
String id = type.getName ();
return containsType (id);
}
...
Tablas de smbolos
Una tabla de smbolos es una estructura de datos de tabla hash donde se registran todas las
declaraciones (no tipos) realizadas por el usuario programador enun determinado mbito
SymbolTable
Private ScopeIF scope;
private Map <String, SymbolIF> sTable;
public SymbolTable() {
sTable = new HashMap<String, SymbolIF> ();
}
public SymbolIF getSymbol (String id) {
return sTable.get (id);
}
public void addSymbol (SymbolIF symbol) {
String id = symbol.getName ();
addSymbol (id, symbol);
}
SymbolTable(contina)
public void addSymbol (String id, SymbolIF symbol){
symbol.setScope (this.scope);
sTable.put (id, symbol);
}
public boolean containsSymbol (String id) {
return sTable.containsKey (id);
}
public boolean containsSymbol (SymbolIF symbol) {
String id = symbol.getName ();
return containsSymbol (id);
}
...
mbitos de declaracin
El mbito es un artefacto que representa un mbito de declaracin dentro de un programa.
Estructuralmente es un contenedor que mantiene una referencia a la tabla de smbolos y la tabla de
tipos asociada con dicho mbito
Scope
-String name
-int id
-int level
-symbolTable
-typeTable
+ String getName ()
+ int getId ()
+ int getLevel ()
+ SymbolTableIF getSymbolTable ()
+ TypeTableIF getTypeTable ()
Nombre del mbito
En bloques con nombre, como
procedimientos y funciones,
contiene el nombre del bloque
Identificador de mbito
Cada mbito dispone de un
identificador nico asignado,
correlativamente, por construccin
Nivel de anidamiento del mbito
El nivel de anidamiento indica el
grado de profundidad en el que se
encuentra el bloque sintctico
asociado al mbito comenzando
por 0 para el mbito global
Tabla de smbolos y tipos
Cada mbito contiene una
referencia a una tabla de
smbolos y otra de tipos
inicialmente vaca asignadas
por construccin
Gestor de mbitos
El gestor de mbitos es un artefacto que mantiene una relacin de todos los mbitos creados durante
el proceso de compilacin. Este objeto es una nica instancia en el compilador y sirve para gestionar
la bsqueda de smbolos y tipos a travs de los mbitos activos
ScopeManager
+ void openScope ()
+ void openScope (String name)
+ void closeScope ()
+ ScopeIF getCurrentScope ()
+ ScopeIF getScope (int level)
+ List<ScopeIF> getAllScopes ()
+ SymbolIF searchSymbol ()
+ TypeIF searchType ()
+ boolean containsSymbol (String id)
+ boolean ContainsType (String id)
Crea un nuevo mbito,
annimo o con nombre.
Aplicable cuando se entra en
un bloque
Cierra un mbito. Aplicable
cuando se abandona un bloque
Recupera el ltimo mbito
abierto o aqul en cierto nivel
de profundidad de los
actualmente abiertos
Recupera todos los mbitos
creados (abiertos o cerrados)
durante el proceso de
compilacin. til en la generacin
de cdigo final Busca smbolos o tipos a lo
largo de los mbitos activos,
comenzando por el ms
reciente y avanzando en la
jerarqua de mbitos padre
Indica si un smbolo o tipo se
encuentra declarado dentro de
algn mbito activo
Gestor de mbitos
La manera de gestionar los mbitos activos es a travs de una pila de mbitos interna. Cada
operacin openScope crea un nuevo objeto Scope y lo apila sobre la pila. Cada operacin
closeScope, saca el mbito de la cima de la pila
CONST MAX = 10;
VAR v, w : TVector;
i : INTEGER;
...
BEGIN
END;
...
ScopeManager
Global [0]
Ejemplo
...
VAR i : INTEGER;
...
ScopeManager
Global [0]
Leer[1]
ScopeManager
Global [0]
Leer[1]
Validar[2]

Gestor de mbitos
La manera de gestionar los mbitos activos es a travs de una pila de mbitos interna. Cada
operacin openScope crea un nuevo objeto Scope y lo apila sobre la pila. Cada operacin
closeScope, saca el mbito de la cima de la pila
...
BEGIN
FOR i := 1 TO 10 DO
END;
END;
ScopeManager
Ejemplo
...
VAR i : INTEGER;
vSuma : TVector;
BEGIN
...
ScopeManager
Global [0]
suma[1]
...
BEGIN
Leer (v);
Leer (w);
v := suma (v, w);
END.
ScopeManager
Global [0] Global [0]
Leer[1]

Implementacin de un comprobador de tipos sencillo en cup
Una vez conocidos los artefactos necesarios para implementar un comprobador de tipos, podemos
describir la forma del esquema de traduccin para cada seccin de una gramtica. En nuestros
ejemplos utilizaremos una estilo Pascal aunque es fcilmente trasladable a C. Como cup no admite
atributos heredados la solucin propuesta se ver someramente condicionada por este hecho
Apertura del mbito inicial
program ::= cabecera cuerpo;
cabecera ::= PROGRAM ID:id PYC {:
String name = id.getLexema ();
scopeManager.openScope (name);
// Insertar todos los TypeSimple en la TT
:};
cuerpo ::= declaraciones bSentencias; {:
scopeManager.closeScope (); :}
declaraciones ::= bConstantes
bTipos
bVariables
dSubprogramas;
bConstantes ::= CONST dConstantes | ;
bTipos ::= TYPE dTipos | ;
bVariables ::= VAR dVariables | ;
dConstantes ::= dConstantes dConstante
| dConstante;
dConstante ::= ID:id IGUAL rNumero:rn {:
ScopeIF scope = scopeManager.getCurrentScope ();
SymbolTable sTable = scope.getSymbolTable ();
Object value = rn.getValue ();
if (sTable.containsSymbol (name)) {
semanticErrorManager.semanticFatalError (...);
} else {
TypeIF type;
if (value instanceof Integer) type = TypeSimple.ENTERO;
if (value instanceof Float) type = TypeSimple.REAL;
if (value instanceof Boolean) type = TypeSimple.LOGICO;
SymbolConstant sC = new SymbolConstant (name, value, type);
sTable.add (sC);
:};
rNumero ::= NUM:n {:
RESULT = new RNumero (n.getValue ()); :}
Declaracin de constantes
Declaracin de constantes Declaracin de tipos
| ID:id {:
if (scopeManager.containsSymbol (name)) {
SymbolIF s = scopeManager.searchSymbol (name);
if (s instanceof SymbolConstant) {
SymbolConstant sC = (SymbolConstant) s;
Object value = sC.getValue();
RESULT = new RNumero (value);
} else
} else
:};
dTipos ::= dTipos dTipo
| dTipo;
dTipo ::= ID:id IGUAL tipo:t {:
TypeIF type = t.getType ();
type.setName (name);
TypeTableIF tTable = scope.getTypeTable ();
tTable.addType (name, type);
:};
tipo ::= dArray:t {: RESULT = new Tipo (t.getType()); :}
| dRecord:t {: RESULT = new Tipo (t.getType()); :}
| rTipo:t {: RESULT = new Tipo (t.getType()); :};
rTipo ::= INTEGER {: RESULT = new RTipo (TypeSimple.ENTERO); :}
| REAL {: RESULT = new RTipo (TypeSimple.REAL); :}
Declaracin de tipos Declaracin de tipos
| ID:id {:
if (scopeManager.containsType (name)) {
TypeIF type = scopeManager.searchType (name);
RESULT = new Rtipo (type);
} else
:}
dArray ::= ARRAY rArray:t PYC {:
RESULT = new dArray (t.getType ());
:};
rArray ::= CI rNumero::n1 DD rNumero:n2 CD rArray:t
{: Object min = n1.getValue ();
Object max = n2.getValue ();
TypeIF tBase = t.getType ();
TypeIF tArray = new TypeArray (min, max, tBase);
RESULT = new RArray (tArray); :}
| OF rTipo:t {: RESULT = new RArray (t.getType()); :};
dRecord ::= RECORD BEGIN bCampos:t END {:
RESULT = new DRecord (t.getTypeRecord ());
:};
bCampos ::= bCampos:t1 lCampos:t2 PYC {:
TypeRecord tR1 = t1.getTypeRecord ();
TypeRecord tR2 = t2.getTypeRecord ();
TypeRecord tR = new TypeRecord ();
if (tr2.constainsSome (tR1)) semanticErrorManager.semanti...
else { tR.addAllFields (tR1);
tR.addAllFields (tR2);
RESULT = new BCampos (tR); }
:}
| lCampos:t {:
TypeRecord tR = t.getTypeRecord ();
RESULT = new BCampos (tR); :};
:};
Declaracin de tipos Declaracin de variables
lCampos ::= ID:id DP rTipo:t {:
TypeRecord tR = new TypeRecord ();
tR.addField (name, type);
RESULT = new LCampos (tR, type);
:}
| ID:id COMA lCampos:t {:
TypeRecord tR = t.getTypeRecord ();
if (!(tR.containsField (name))) {
tR.addField (name, type);
} else
:}
dVariables ::= dVariables dVariable
| dVariable;
dVariable ::= ID:id DP rTipo:t {:
if (!(sTable.containsSymbol (name))) {
SymbolVariable sV = new SymbolVariable (name, type);
sTable.addSymbol (name, sV);
RESULT = new DVariables (type);
} else semanticErrorManager.semanticFatalError (...);
:}
| ID:id COMA dVariables:t {:
<<igual que en la regla anterior>>
:};
Declaracin de subprogramas Declaracin de subprogramas
dSubprogramas ::= dSubprogramas dSubprograma | ;
dSubprograma ::= dProcedimiento | dFuncion;
dProcedimiento ::= pCabecera cuerpo;
dFuncion ::= fCabecera cuerpo;
fCabecera ::= FUNCTION ID:id PI pFormales:pfs PD DP
rTipo:t {: String name = id.getLexema ();
if ((!scopeManager.containsSymbol (name)) &&
(scopeManager.containsType (name))) {
ScopeIF pScope = scopeManager.getCurrentScope ();
SymbolTableIF psTable = pScope.getSymbolTable ();
TypeTableIF ptTable = pScope.getTypeTable ();
TypeFunction tF = new TypeFunction (name);
SymbolFunction sF = new SymbolFunction (name, tF);
ScopeIF scope = scopeManager.openScope (name);
SymbolTableIF sTable = scope.getSymbolTable ();
for (SymbolParameter p : pfs.getParameters()) {
sTable.addSymbol (p.getName (), p);
tF.addParameterType (p.getType ()); }
tF.setReturnType (t.getType ());
ptTable.addType (name, tF);
psTable.addSymbol (name, sF);
} else semanticErrorManager.semanticFatalError (...); :}
pFormales ::= lPFormales:lpf {:
List <SymbolParameter> lp = lpf.getParameters ();
RESULT = new PFormales (lp);
:}
| {: RESULT = new pFormales (); :} ;
lPFormales ::= lPFormales:lpf PYC dPFormales:dpf {:
List <SymbolParameter> lp = dpf.getParameters ();
lpf.addAllParameters (lp);
RESULT = lpf;
:} | dPFormales:dpf {:
List <SymbolParameter> lp = dpf.getParameters ();
RESULT = new LPFormales (lp); :};
Declaracin de subprogramas Expresiones
dPFormales ::= ID:id PD rTipo:t PYC {:
String n = id.getLexema ();
SymbolParameter sp = new SymbolParameter (n,type);
RESULT = new DPFormales (sp, type);
:}
| ID:id COMA dPFormales:dpf {:
String n = id.getLexema ();
TypeIF type = dpf.getType ();
SymbolParameter sp = new SymbolParameter(n,type);
dpf.addParameter (sp, type);
RESULT = dpf;
:};
pCabecera ::= FUNCTION ID:id PI pFormales:pfs PD {:
<< igual que en fCabecera pero sin tipo de
retorno e insertandoun Symbol/Type Procedure
en vez de un Symbol/Type Function >> :};
TypeIF t1 = e1.getType ();
TypeIF t2 = e2.getType ();
if (t1.isCompatible (t2, TypeSimple.MAS)) {
TypeIF t = t1.cast (t2, TypeSimple.MAS);
RESULT = new Exp (t);
} else semanticErrorManager.semanticFatalError (...);
:}
| exp MENOS exp {:...:}
| exp POR exp {:...:}
| exp DIV exp {:...:}
| rNumero:rn {:
Object value = rn.getValue ();
TypeIF type;
RESULT = new Exp (type); :}
Expresiones Expresiones
| PI exp:e PD {:
TypeIF type = e.getType ();
RESULT = new Exp (type);
:}
| fCall:fc {:
TypeIF type = fc.getType ();
:}
| referencia:ref {:
TypeIF type = ref.getType ();
:}
referencia ::= ID:id {:
if (scopeManager.contains (name)) {
SymbolIF sId = scopeManager.searchSymbol (name);
TypeIF type = sId.getType ();
RESULT = new Referencia (type);
} else SemanticErrorManager.semanticFactalError (...);
:}
| referencia:r PTO ID:id {:
TypeIF rType = r.getType ();
if (rType instanceof TypeRecord) {
TypeRecord tRec = (TypeRecord) rType;
if (tRec.containsField (name)) {
Type innerType = tRec.getType (name);
RESULT = new Referencia (innerType);
:}
Expresiones Expresiones
| referencia:r CI exp:e CD {:
TypeIF eType = e.getType ();
if (eType.equals(TypeIF.ENTERO)) {
Type rType = r.getType ();
if (rType instanceof TypeArray) {
TypeArray arrayType = (TypeArray) rType;
Type innerType = arrayType.getBaseType ();
RESULT = new Reference (innerType);
} else SemanticErrorManager.semanticFatal...;
} else SemanticErrorManager.semanticFatal...;
:}
fCall ::= ID:id PI pActuales:pa PD {:
SymbolIF s = scopeManager.searchSymbol (name);
if (s instanceof SymbolFunction) {
SymbolFunction sf = (SymbolFunction)s;
TypeFunction tF = sF.getType ();
List <TypeIF> aParams = pa.getParameterTypes ();
List <TypeIF> fParams = tF.getParameters ();
if (aParams.equals(fParams)) {
TypeIF returnType = tF.getReturnType ();
RESULT = new Fcall (returnType);
} else SemanticErrorManager.semanticFatalError (...);
:};
pActuales ::= pActuales:pa COMA exp:e {:
TypeIF type = e.getType();
pa.addParameterType (type);
RESULT = pa;
:}
| exp:e {: TypeIF type = e.getType ();
RESULT = new PActuales (type); :};
Sentencias Sentencias
cuerpo ::= BEGIN lSentencias END PYC;
lSentencias ::= lSentencias sentencia | ;
sentencia ::= sentenciaIf |
sentenciaWhile |
sentenciaAsignacion |
pCall |
cuerpo;
sentenciaIf ::= IF PI exp:e PD THEN sentencia
ELSE sentencia {:
TypeIF type = e.getType ();
if (!(type instanceof TypeSimple.LOGICO))
:}
SentenciaWhile ::= WHILE PI exp:e PD DO sentencia {:
<<igual que sentenciaIf>>
:}
sentenciaAsignacin ::= referencia:r IGUAL exp:e PYC {:
TypeIF eType = e.getType ();
TypeIF rType = r.getType ();
if (rType instanceof TypeFunction ||
rType instanceof TypeProcedure) {
rType = rType.getReturnType ();
ScopeIF currentScope = scopeManager.getCurrentScope();
if (!r.getScope().equals(currentScope))
}
if (!(rType.isCompatible (eType, TypeIF.IGUAL)))
:}
pCall ::= ID:id PI pActuales:pa PD PYC; {:
<<igual que fCall>>
:}
Una vez esbozado el esquema de traduccin en cup para un comprobador de tipos sencillo sobre una
gramtica estilo Pascal, estamos en disposicin de tratar algunos temas avanzados de inters que
discutimos a continuacin
Inferencia de tipos
La inferencia de tipos es el proceso por el cual un comprobador de tipos infiere el tipo de una
construccin gramatical a partir de su contexto. Esto es especialmente til en lenguajes sin tipificacin
explcita
Ejemplo I
dConstante ::= ID:id IGUAL numero:n {:
...
Object value = n.getValue ();
TypeIF type;
if (value instanceof Boolean) type = TypeSimple.LOGICO;
SymbolConstant sC = new SymbolConstant (name, value, type);
sTable.add (sC);
:};
dConstante
ID
numero
=
(3.5)
El caso ms sencillo de inferencia de tipos
se produce en la declaracin de
constantes. En efecto, el tipo de la
constante no se declara explcitamente sino
que se infiere del valor asignado a la misma
en la declaracin

Inferencia de tipos
explcita
Ejemplo II
exp ::= ID:id {:
if (!scopeManager.containsSymbol (name)) {
SymbolVariable sV = new SymbolVariable ();
sv.setTypes (TypeSimple.ALL);
sTable.addSymbol (name, sV);
}
RESULT = new Exp (sV, TypeSimple.ALL);
:}
exp
exp
exp
+
En el caso de lenguajes sin tipificacin, la
construccin sintctica infiere que los
nicos posibles valores para ID son los
numricos, descartando Boolean, Char y
String
(3.5)
{Real}
numero ID
{Byte, Word, Integer,
Real, Double}
Inferencia de tipos
explcita
Ejemplo II
TypeIF t1 = e1.getTypes ();
TypeIF t2 = e2.getTypes ();
t1.removeIncompatibles (t2, TypeIF.MAS);
t2.removeIncompatibles (t1, typeIF.MAS);
SymbolVariable e1Var = e1.getVariable();
SymbolVariable e2Var = e2.getVariable();
if (e1Var != null) e1Var.setTypes (t1);
if (e2Var != null) e1Var.setTypes (t2);
if (t1.isEmpty() || t2.isEmpty) semanticErrorManager...;
else { Types types = new Types (t1);
types.addAllTypes (t2);
RESULT = new Exp (types); }
:}
exp
exp
exp
+
En el caso de lenguajes sin tipificacin, la
construccin sintctica infiere que los
nicos posibles valores para ID son los
numricos, descartando Boolean, Char y
String
(3.5)
{Real}
numero ID
{Byte, Word, Integer,
Real, Double}
Sobrecarga de subprogramas
Como ya se coment anteriormente, existen lenguajes que dan soporte a la sobrecarga de
subprogramas. Es decir permiten declarar varias versiones de funciones o procedimiento con igual
nombre pero distinto numero, tipo u orden de parmetros. La implementacin de esta capacidad se
estudiar para funciones ya que para procedimientos resulta similar
En la declaracin
fCabecera ::= FUNCTION ID:id PI pFormales:pfs PD DP
rTipo:t {:
TypeIF t = <<tipo para esta versin de la funcin>>
TypeFunction tFun = <<buscar el tipo por name>>
tFun.addSignature (t);
...
:}
fCall ::= ID:id PI pActuales:pa PD {:
TypeIF t = scopeManager.searchType (name);
if (t instance of TypeFunction) {
TypeFunction tF = (TypeFunction) t;
List<List<TypeIF>> signatures = tF.getSignatures ();
for (<<cada signatura>>) {
<<proceder como antes comprobando que alguna
signatura encaja con la llamada actual>>
}
}
}
Ahora cada TypeFunction contiene una
coleccin de signaturas (una lista interna de
lo que antes era TypeFunction). Al declarar
una nueva funcin ha de aadirse a la lista
En la invocacin
Recuperacin de errores semnticos
La recuperacin de errores semnticos es algo menos frecuente que la de errores sintcticos. Sin
embargo es posible realizarlo mediante una extensin conveniente del esquema de traduccin dirigido
por la sintaxis. En concreto se utilizan para expresiones y sentencias dos nuevos valores para el
atributo de tipo: error y correcto.
sentencia
IF
THEN
exp
Boolean = tipo. exp
sentencia
exp >
true 4
.tipo = ENTERO
.tipo = Correcto
.tipo = error
.tipo = error
Los errores se almacenan como formas de
tipo y se van acumulando para indicar qu
partes del rbol de anlisis sintctico
contiene error

1. Implementacin de artefactos en cdigo abierto
1. Implementacin de la tabla de smbolos
2. Implementacin de la tabla de tipos
3. Implementacin de todas las clases TypeIF necesarias
4. Implementacin de todas las clases SymbolIF necesarias
5. Incorporacin de atributos y constructores necesarios en cada no terminal
2. Implementacin de las acciones semnticas del comprobador de tipos
1. Acciones para declaraciones
2. Acciones para expresiones
3. Acciones para sentencia
3. Prueba del comprobador de tipos
1. Ejecutar finalTestCase
2. Comprobar en la traza el estado de cada tabla de smbolos y tipo
3. Comprobar que se emiten los mensajes de error semntica ante cdigos incorrectos
Se debe reflexionar cuida-
dosamente acerca de qu
atributos son necesarios para
caracterizar cada tipo y
smbolo del lenguaje y cada
elemento no gramatical
Desarrollo paso a paso
La fase de anlisis semntico requiere de la implementacin del comprador de tipos del lenguaje que
siga las directrices del sistema de tipos del lenguaje. En esta ltima seccin hemos descrito cmo se
implementa un comprobador de tipos sencillos. Ahora damos la secuencia de pasos a realizar
Bibliografa
Material de estudio
Bibliografa bsica
Construccin de compiladores: principios y prctica
Kenneth C. Louden International Thomson Editores,
2004 ISBN 970-686-299-4
Bibliografa
Material de estudio
Bibliografa complementaria
Compiladores: Principios, tcnicas y herramientas.
Segunda Edicin Aho, Lam, Sethi, Ullman
Addison Wesley, Pearson Educacin, Mxico 2008
Diseo de compiladores. A. Garrido, J . Iesta, F. Moreno
y J . Prez. 2002. Edita Universidad de Alicante

probacionDeTipos PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

probacionDeTipos PDF

Cargado por

Copyright:

Formatos disponibles

Procesadores de Lenguajes

Ingeniera Tcnica superior de Ingeniera Informtica

Javier Vlez Reyes jvelez@lsi.uned.es

Javier Vlez Reyes jvelez@lsi.uned.es

Javier Vlez Reyes jvelez@lsi.uned.es

Javier Vlez Reyes jvelez@lsi.uned.es

Javier Vlez Reyes jvelez@lsi.uned.es

Javier Vlez Reyes jvelez@lsi.uned.es

Javier Vlez Reyes jvelez@lsi.uned.es

También podría gustarte