PS Apuntes U1 2 3 4 Rev A2008

Instituto Tecnolgico de la Laguna
Ingenieria en Sistemas Computacionales

Apuntes de

PROGRAMACION DE SISTEMAS II

por
Ing. Luis Fernando Gil Vzquez

Enero de 2008

ITL Programacin de Sistemas II Ing. Fernando Gil
Pag. 2

T e m a r i o

I Analisis Sintactico

1.1 Introduccion ( repaso de sintaxis )
1.2 Gramatica de un lenguaje
1.3 Ambiguedad
1.4 Gramaticas recursivas
1.5 Factorizacion por la izquierda
1.6 Tipos de Parser
1.6.1 Parser Descendente
1.6.2 Parser Ascendente
1.7 Parser predictivo recursivo
1.8 Parser predictivo no recursivo
1.9 Parser de corrimiento reduccin
1.10 Parser L-R

II Semantica

2.1 Introduccion a la semantica
2.2 Definiciones dirigidas por la sintaxis
2.3 Forma interna del programa fuente
2.3.1 Notacion polaca
2.3.2 Cuadruplos
2.4 Rutinas semanticas
2.4.1 Expresiones aritmeticas
2.4.2 Estatutos condicionales
2.4.3 Estructuras repetitivas

III Generacion de Codigo Intermedio

3.1 Codigos Intermedios
3.2 Ejemplos de traduccin a codigo
3.3 Cuadruplos
3.4 Notacion polaca
3.4.1 Expresiones aritmeticas
3.4.2 Expresiones condicionales
3.5 Diseno de un generador de codigo intermedio
3.6 Manejo de errores
3.7 Generacion de codigo
3.8 Optimizacion de codigo

IV Administracin de la Memoria Principal

4.1 Introduccion
4.2 Fases de la administracin de memoria
4.3 Administracion estatica de memoria
4.4 Administracion de la memoria basada en pilas
Pag. 3
4.5 Paginacion
4.6 Segmentacion
4.7 Administracion de la memoria basada en monton con elementos de tamano fijo
4.8 Administracion de la memoria basada en monton con elementos de tamano
variable.

B i b l i o g r a f i a

COMPILADORES: PRINCIPIOS, TECNICAS Y HERRAMIENTAS
Alfred V. Aho, R. SEIT, J.D. Ullman
Addison - Wesley

COMPILADORES, CONCEPTOS FUNDAMENTALES
Teufel Schmidt Teufel
Addison Wesley

COMPILADORES: TRADUCTORES Y COMPILADORES CON LEX / YACC, JFLEX / CUP y JAVACC
Sergio Rojas y Miguel Angel Mora
Universidad de Malaga
( PDF )
Pag. 4

UNIDAD I

Analisis Sintactico

1.1 Introduccion ( repaso de sintaxis )

Concepto de Traductor

Un traductor es un programa que convierte un programa fuente a un objeto o programa objeto. El programa
fuente puede estar en algn lenguaje de programacin dado. El programa objeto esta en el otro lenguaje de
programacin.

Tipos de Traductores

Ensambladores
Interpretes
Compiladores
Preprocesadores

Concepto de Compilador

If(A>0)
{
C=B+D;
}

Lenguaje de Alto Nivel

COMPILADOR
Mov AH 0 1000 1000
ADD BH o 1110 1111
JMP ETQ

Lenguaje Lenguaje
Ensamblador Maquina
Cdigo
Fuente
TRADUCTOR
DE
LENGUAJE
Cdigo
Objeto
Lenguaje y Lenguaje x
Pag. 5

Estructura de un compilador

Analizador Lexicografico
Analizador Sintctico
Analizador Semntico
Generador de Codigo Intermedio
Optimizacin de Codigo
Generador de Codigo (Objeto)
Manejador de Errores
Administrad
or de la
Tabla de
Smbolos
Programa Objeto
Programa Fuente
Pag. 6

Considere el siguiente programa valido en un cierto lenguaje de programacin:

Variables area, base, altura : real;
rea := base * ( altura / 2 );

La correspondiente salida en cada etapa del compilador seria:

Anlisis Lxico Leer el programa carcter por carcter y lo descompone en smbolos basicos llamados
TOKENS. Ejemplo:

Variables id
1
, id
2
, id
3
: real delim
id
1
opasig id
2
oparit id
3
oparit num delim

Anlisis Sintctico Verifica que los tokens vengan en la secuencia correcta de acuerdo a las reglas
gramaticales del lenguaje. Construye un arbol sintactico. Ejemplo:

rbol sintctico

Anlisis Semntico Su principal tarea es verificar la compatibilidad de tipos de datos
1 area .
2 base ..
3 altura ..

1 area real
2 base real
3 altura real

area *
base /
altura 2
= :

Tabla de Smbolos
Tabla de Smbolos
Determina el tipo de dato de cada
identificador y lo agrega a la tabla de
simbolos.
Pag. 7

Generador Codigo Intermedio Produce un programa en un lenguaje intermedio equivalente al programa
fuente. Ejemplo de Lenguaje Intermedio : Codigo 3 direcciones (C3D).
Ejemplo:
t
1
= entero a real (2)
t
2
= altura / t
1
t
3
= base * t
2
rea = t
3

Optimizador de Codigo Busca mejorar el codigo intermedio producido anteriormente, ya sea para que se
ejecute mas rapido o tenga un tamano mas compacto. Ejemplo:

t
1
= altura / 2.00
t
2
= base * t
1
rea = t
2

o bien

t
1
= altura / 2.00
rea = base * t
1

Generador de Codigo Objeto Puede producir el codigo en lenguaje ensamblador o lenguaje maquina.
Ejemplo

real *
real
/
real entero
= :

100h

104h

108h

R1 altura/2
R2 base
Lenguaje Ensamblador
Uso de registros
area

base

altura
Mov R1, [108h]
Div R1, 02
Mov R2, [104h]
Mul R1, R2
Mov [100h], R1
Luego verifica la compatibilidad de tipos en la asignacion:
1. real / entero produce un resultado de tipo real
2. real * real produce un resultado de tipo real
3. Finalmente se asigna un resultado de tipo real a
una variable de tipo real.

Real := Real

Como los tipos son compatibles, entonces esta
sentencia de asignacin es valida semanticam.
Pag. 8

1.2 Gramatica de un lenguaje

Concepto de Gramatica

Es una notacin que sirve para especificar la sintaxis de un lenguaje. La gramtica define si una secuencia
arbitraria de smbolos es correcta o no. Decimos que una frase correcta ser aceptada por el lenguaje.

Definicin Formal de una Gramatica

G = < Vn, Vt, P, S>

Donde:
Vn = Conjunto de smbolos no_terminales.
Vt = Conjunto de smbolos terminales.
P = Conjunto de reglas de produccin.
S = Smbolo inicial.

S C Vn tambin Vn Vt = O

1. Los no terminales son variables sintcticas que denotan conjunto de cadenas.
Ejemplo:

expresin puede reemplazarse por algo como a > b
proposicion puede reemplazarse por algo como call suma

2. Los smbolos terminales son smbolos basicos dentro del lenguaje, tambien llamados tokens y
son con los que se forman las cadenas.

Ejemplo: if, then, else, +, *, ; .

3. Un no_terminal debe de asignarse como smbolo inicial.

4. Las reglas de produccin especifican como pueden condicionarse los terminales o no terminales
para formar cadenas.

Regla de produccin es de la forma:
u
Se lee
u produce a
u deriva a
u es un no_terminal.
denota terminales y no_terminales

if expression then proposicin
variable sintactica
Pag. 9
Ejemplo: Considere los siguientes reglas de produccin

EXPR EXPR OP EXPR
EXPR ( EXPR )
EXPR id
OP + | - | * | /
EXPR - EXPR

defina formalmente la gramtica de este lenguaje:

Ejemplo: Demostrar que ( id + id ) es una construccin sintacticamente valida para la gramatica anterior.

1. Dado que los componentes lxicos de la entrada pertenecen a Vt, es una frase lxicamente valida.

2. Ahora verificamos si la secuencia de los componentes de entrada es correcta.

EXPR - EXPR
- (EXPR)
- (EXPR OP EXPR)
- (id OP EXPR)
- (id + EXPR)
- (id + id)

--Por lo tanto es sintacticamente valida

La derivacin anterior tambin se puede representar con un rbol sintctico:

Pag. 10
Cada nodo se etiqueta con un no_terminal.

Los hijos de este nodo se etiquetan de izquierda a derecha con los smbolos del lado derecho de la
produccin.

Las hojas se etiquetan con terminales y ledos de izquierda a derecha constituyen la frase o
construccin analizada.

Ejercicio: Verificar si las siguientes cadenas de entrada son sintacticamente validas para la gramatica anterior,
trazando el arbol sintactico unicamente.

a. ( ( id * id ) / id + id )
b. (-(-id))
c. id + ( id * ( id id ) )
d. ( ( + id + id ) )

rbol Sintctico (de Parse)
-
(
id
EXPR
+ id
EXPR
EXPR
) EXPR
OP EXPR
Pag. 11

1.3 Ambiguedad

1. Gramticas ambiguas. Condiciones no deseables
2. Recursiva por la izquierda en una gramtica

Gramtica Ambigua:

Es aquella que produce mas de un rbol sintctico para la misma sentencia de entrada. Cada rbol dara un
significado diferente a la misma sentencia lo que dificulta la construccion del compilador.

Ejemplo: Considere la gramtica

E E + E | ( E ) | - E | id | E * E

Demostrar que es ambigua analizando la siguiente entrada id + id * id

1.4 Gramaticas Recursivas

Derivacin por la izquierda:

Una derivacin se denomina por la izquierda si siempre se decide remplazar el no_terminal de mas a la
izquierda en el lado derecho de la produccin.

E E * E
E + E * E
id + E * E
id + id * E
id + id * id

Gramtica Recursiva por la izquierda:

La reglas de produccin son de la forma:

A A

Arbol 1
E
E * E
id E + E
id id
Arbol 2
E
E + E
id E * E
id id
Pag. 12
A C Vn
y
es cualquier cadena de smbolos terminales y no_terminales

Es decir, el no Terminal de mas a la izquierda en el lado derecho de la produccin es el mismo que el smbolo
en el lado izquierdo.

Las reglas de produccin recursivas por la izquierda se van expandiendo a la izquierda

A A
A
A
A

( dibuje el arbol sintactico para mejor apreciacin de la expansion a la izquierda )

Eliminacin de recursividad por la izquierda

Las producciones recursivas por la izquierda AA | pueden sustituirse por las producciones no recursivas
por la izquierda
A A
A A | c

sin modificar el conjunto de cadenas derivadas de A. independientemente entre /m de cuantas producciones de
A, se pueden eliminar de ellas la reecursin directa por la izquierda mediante la siguiente tecnica:

1. Se agrupan las producciones de A en forma: AA
1
|A
2
|A
n
|
1
|
2
|
3

donde ninguna i comienza con una A. despus se sustituyen las producciones de A por:

A
1
A |
2
A |.|
n
A
A
1
A |
2
A |.|
n
A | c

Ejemplo: Eliminar la recursividad por la izquierda de las siguientes producciones de E:

E E + E | E * E | ( E ) | - E | id

las producciones E + E y E * E son recursivas por la izquierda ya que el primer smbolo de mas a la
izquierda E es el mismo que el smbolo en el lado izquierdo de la produccin.

En este caso
1
=

+ E
2
=

* E
1
= ( E )
2
= - E
3
= id

Las producciones sin recursividad izquierda quedarian:

E -> ( E ) E | - E E | id E
E -> + E E | * E E

Ejercicio. Considere la siguiente gramatica para expresiones aritmeticas y elimine la recursividad izquierda.

:
:
Pag. 13
E -> E + T | T
T -> T * F | F
F -> ( E ) | id

1.5 Factorizacion por la Izquierda

Es una trasformacin gramatical til y adecuada para el anlisis sintctico predictivo.

Considere el siguiente caso

S -> if expr then prop | if expr then prop else prop

En el que existe un prefijo comun para las dos producciones de S, cuando no esta claro cual de las dos
producciones alternativas se utilizara para ampliar un No-terminal S, se pueden reescribir las producciones de
S, para retrasar la decisin hasta haber visto lo suficiente de la entrada como para elegir la opcin correcta.

En general si A
1
|
2
y la entrada comienza con una cadena no vaca derivada de no se sabe si
expandir a:
1
o
2
pero factorizadas por la izquierda las producciones originales se convierten en:

A A
A
1
|
2

Ejemplo: Factorizar las producciones S -> if expr then prop | if expr then prop else prop

El prefijo comun = if expr then prop y
1
= c y
2
= else prop
Factorizando quedaria:

S -> if expr then prop S
S -> c | else prop

Ejercicio. Disee y especifique formalmente una gramatica para la declaracion de variables int, float y char
del lenguaje C. Dicha gramatica no debe ser recursiva izquierda y debera estar factorizada por la izquierda.
Pag. 14

1.6 Tipos de Parser

Recursivo con retroceso ( backtrack )
Parser Descendente
- Recursivo
Predictivo
- No Recursivo

Parser Ascendente - L R
Desplazamiento -
Reduccion
- Por precedencia de operadores

1.6.1 Parser Descendente ( Top Down )

La construccin del arbol de anlisis sintctico para la entrada se comienza desde la raiz y se crean los
nodos del arbol hasta llegar a las hojas.

La construccion descendente de un arbol de anlisis sintctico se hace siempre empezando por la raiz
etiquetada con el smbolo inicial.

1.6.2 Parser Ascendente ( Bottom - Up )

Construye el arbol sintactico para una cadena de entrada empezando por las hojas y avanzando hacia la
raiz.

Se puede considerar este proceso como de reducir una cadena W al smbolo inicial de la gramatica.

1.7 Parser Predictivo Recursivo

Este mtodo de anlisis descendente utiliza el smbolo de preanalisis para determinar sin ambigedad la
produccin correcta para cada smbolo No-Terminal.

Consta de un conjunto de procedimiento o rutinas recursivas para procesar la entrada.

A cada No-Terminal de la gramtica se le asocia un procedimiento.

La secuencia de llamadas a procedimientos define implcitamente un rbol de anlisis sintactico de la entrada.

La implementacin del procedimiento de una produccin se realiza como la siguiente:
1) Cada terminal del lado derecho se empareja con el smbolo de preanalisis
Pag. 15
2) Cada no terminal de la derecha proporciona una llamada a su procedimento.
3) El procedimiento emparejar recibe un argumento t el cual si concuerda con el smbolo de
preanalisis entonces avanza hacia el siguiente componente lexico de entrada.

Ejemplo: Disear el algoritmo de parser predictivo recursivo de la gramatica cuya producciones son:

tipo -> simple | id | array [ simple ] of tipo
simple -> integer | char | num puntopunto num

calculamos :
PRIMEROS ( tipo ) = { PRIMEROS ( simple ), , array }
PRIMEROS ( simple ) = { integer, char, num }

Procedure tipo
begin
If preanalisis IN { integer, char, num } then
simple
Else
If preanalisis = then
begin
emparejar ( );
emparejar ( id );
end
Else
If preanalisis = array then
begin
emparejar ( array );
emparejar ( [ );
simple;
emparejar ( ] );
emparejar ( of );
tipo;
end
Else
error ;
end;

Procedure simple
begin
If preanalisis = integer then
emparejar ( interger )
Else
If preanalisis = char then
emparejar ( char )
Else
If preanalisis = num then
begin
emparejar ( num );
emparejar ( puntopunto );
emparejar ( num );
end
Else
error;
end;

Procedure emparejar ( t : complex )
Pag. 16
begin
If preanalisis = t then
Preanalisis := sigcomplex
Else
error ;
end;

Ejercicio: Disear el algoritmo de parser predictivo recursivo de la gramatica para declaracion de variables
int, float y char en C.

1.8 Parser Predictivo No Recursivo

La tabla M es de la forma M[X, a] donde X= No Terminal, a= terminal

X = Smbolo en la cima de la pila
a = Smbolo en curso de la entrada (preanalisis)

Tres casos;

1. Si X = a = $; Fin, xito del analisis.
2. Si X = a = $; Sacar X de la pila y mover el apuntador de la entrada al siguiente smbolo.
3. Si X es no terminal consultar M[X, a]:
Si M [X,a] = {XUVM} entonces sustituir X de la pila por MVU (U hasta arriba de la pila).

Si M [X,a] = error el parser invoca al manejador de errores.
X
Y

Z
$
Pila
Programa para anlisis
Sintctico
predictivo
Buffer de entrada
a + b $
Salida
Tabla de
anlisis
Sintactico M
Fig. Modelo de un parser predictivo no recursivo
Pag. 17

Algoritmo Parser Predictivo No Recursivo

Apuntar ae al primer smbolo de w$;
Repeat
Sea X el smbolo en el tope de la pila y a el smbolo apuntado por ae ;
Si X es terminal o $ entonces
Si X = a entonces
Saca X de la pila y avanzar ae
Sino
Error ()
Sino /* X es un no terminal */
Si M [ X, a ] = X y
1
y
2
.y
k
entonces
Extraer X de la pila
Meter y
k,
y
k-1,
y
k-2, .
y
1
en la pila con y
1
en la cima.
Emitir la produccin X y
1
,y
2
.y
k

Sino
Error ()
Hasta X = $ /*pila vaca*/

Ejemplo: considere la siguiente tabla gramatical M para analizar la entrada id + id * id

Smbolo de entrada No terminal
Id + * ( ) $
E ETE ETE
E E+TE Evacio Evacio
T TFT TFT
T Tvacio T*FT Tvacio Tvacio
F Fid F(E)

PILA

$E
$ET
$ETF
$ETid
$ET
$E
$ET+
$ET
$ETF
$ETid
$ET
$ETF*
$ETF
$ETid
$ET
$E
$
ENTRADA

id + id * id $
id + id * id $
id + id * id $
id + id * id $
+ id * id $
+ id * id $
+ id * id $
id * id $
id * id $
id * id $
* id $
* id $
id $
id $
$
$
$
SALIDA

ETE
TFT
Fid

Tc
E+TE

TFT
Fid

T*FT

Fid

Tc
Ec

Ejercicio: Con la misma tabla M anterior analizar sintacticamente la entrada id * ( id + id )

Pag. 18

1.9 Parser Corrimiento - Reduccion

Se pueden considerar este proceso como de reducir una cadena W al smbolo inicial de la gramtica.

En cada paso de reduccin se sustituye una subcadena determinada para que concuerde con el lado derecho
de la produccin por el smbolo del lado izquierdo de dicha produccin. Y si en cada paso se elige
correctamente la subcadena, se traza una derivacin por la derecha en sentido inverso.

Ejemplo: considere la gramatica

SaABe
AAbc
Ab
Bd

La frase abbcde se puede reducir a S.
Se examina abbcde buscando una subcadena que concuerde con el lado derecho de una produccin:
Elegimos la b que se sita mas a la izquierda y se sustituye en este caso por A del lado izquierdo de la
produccin Ab y se obtiene la cadena aAbcde y asi sucesivamente.

El rbol sintctico ascendente quedara:

Ejercicio: Construya un arbol ascendente usando la gramatica anterior y la entrada abbcbcbcde

1.10 Parser L - R

Es un parse ascendente
L significa que analiza la entrada empezando por la izquierda
R significa que las derivaciones son por la derecha
B
d
e
A
A
b
a
b
c
Pag. 19

Algoritmo Parser L-R

Entrada: cadena W, tabla de anlisis sintctico para la gramtica G.
Salida: si W esta en L(G), un anlisis ascendente de W sino error.
Mtodo: Inicialmente s
0
esta en la pila y W $ en la entrada

Apuntar ae al primer smbolo de la entrada;
Repetir por simpre
Begin
Sea s el estado en la cima de la pila y a el smbolo apuntado por ae;
IF accion [ s, a ] = desplazar s THEN
Begin
Meter a y despues s en la cima de la pila;
Avanzar ae;
End
Else IF accion [ s, a ] = reducir AB THEN
Begin
Sacar 2* | | simbolos de la pila;
Sea s el estado que esta ahora en la cima;
Meter A y despus ir_a [ s, A ] en la cima ;
Desplegar la produccin A;
End
Else IF accion [ s, a ] = aceptar THEN
Return
Else
Error()
End

S
m

X
m

S
m-1

X
m-1

Programa de anlisis
Sintctico L-R
accin
IR-A
Salida
Entrada
a
1

a
i
a
n

$
Tabla de anlisis Sintctico
Pag. 20

Ejemplo: considere la siguiente gramtica para expresiones numricas con + y *

E E + T
E T
T T * F
T F
F ( E )
F id

TABLA DE ANALISIS SINTACTICO
ACCION Ir-a ESTADO
id + * ( ) $ E T F
0
1
2
3
4
5
6
7
8
9
10
11
D5

D5

D5
D5

D6
R2
R4

R6

D6
R1
R3
R5

D7
R4

R6

D7
R3
R5
D4

D4

D4
D4

R2
R4

R6

D11
R1
R3
R5

Acepta
R2
R4

R6

R1
R3
R5
1

8
2

2

9

3

3

3
10

Simbologa: Di = Desplazar y meter en la pila el estado i .
Rj = Reducir por la produccin j.
Celda en blanco significa error.

Analizar la entrada id * id + id

Buffer De entrada:
Id * Id + Id $

Salida:
Fid
TF
Fid
TT*F
ET
Fid
TF
EE+T

Pag. 21

El arbol sintactico equivalente es :

Ejercicio: Hacer un analisis sintactico L R basada en la gramatica anterior para la entrada
( id + id ) * ( id + id )

E
E
+
T
F
id
T
T
*
F
id
F
id
Pag. 22
TABLA DE SMBOLOS

UNIDAD II

Analisis Semantico

2.1 Introduccion

Analizador Semntico.

Verifica que el significado de las construcciones del lenguaje tengan sentido.

Tareas del analizador semntico:
1) Comprobacin de Tipos.
2) Comprobacin de parmetros.
3) Generacin de cdigo intermedio.

Ejemplo:

A : float ;
B : string ;
.
.
.
A := B + 5 ;

Analizador Lxico

id
1
: float ;
id
2
: string ;
.
.
.
id
1
:= id
2
op num ;

Lexema Complex Tipo ...
1 A id ?
2 B id ?
3 5 num ?
Pag. 23


Analizador Semntico

Hasta aqu la entrada es lexica y sintacticamente valida, ahora se analiza desde el punto de vista semantico:

Un compilador puede necesitar tener en cuenta muchas caractersticas adems del cdigo generado para la
construccin de entrada. Para realizar un anlisis semntico a cada construccin del lenguaje se le asocia una
serie de atributos as como de acciones o reglas semnticas.

Un atributo es informacin asociada a un terminal o a un no-terminal, y puede representar una cadena o una
posicin de memoria.

Regla Semntica: Accin o conjunto de acciones(algoritmo) para calcular el valor de los atributos.
:=
A +
B 5
real

cadena + entero = ERROR_TIPO

id
2
.entrada num
cadena entero
(1) ERROR_TIPO
id
1
.entrada +
:=
ERROR_TIPO = No hay compatibilidad de tipos
Pag. 24

Los analizadores semnticos se construyen asociando una serie de atributos y acciones o reglas semnticas a
cada construccin del lenguaje.

Dos formas de asociarlo:

1) Definicin dirigida por la sintxis.
2) Esquema de traduccin.

En ambos casos es til definir un conjunto de atributos a los smbolos gramaticales del lenguaje.

Dos tipos de atributos:

1) Sintetizados.
2) Heredados.

2.2 Definiciones dirigidas por la sintaxis

El concepto Definicin dirigida por la sintxis se utiliza para especificar las traducciones para las
construcciones del lenguaje(sentencias) en funcin de atributos asociados con sus componentes sintcticos.

Una definicin dirigida por la sintxis usa una gramtica para especificar la estructura sintctica de la entrada.
A cada smbolo de la gramtica se le asocia un conjunto de atributos y a cada produccin un conjunto de reglas
semnticas, para calcular los valores de los atributos asociados con los smbolos que aparecen en esa
produccin.

Las definiciones dirigidas por la sintxis no solo se utilizan para la comprobacin de tipos, se puede usar para
transformar una sentencia o cadena de entrada a cualquier forma de salida.

Ejemplo: Definicin dirigida por la sintxis para traducir expresiones infijas a postfijas:

Definicin
dirigida por
la sintxis

Gramtica

=
Reglas
Semnticas

+
PRODUCCION
expr expr
1
+ trmino

expr expr
1
- trmino

expr trmino
termino0
termino 1

termino 9

REGLA SEMNTICA
expr.t := expr
1
.t

|| trmino.t
|| +

expr.t := expr
1
.t

|| trmino.t
|| -
expr.t := trmino.t

termino.t := 0
termino.t := 1

termino.t := 9

Pag. 25

Infija 9 5 + 2

Postfija 9 5 2 +

operando operando operador

Tipos de atributos.

sintetizados
Tipos
heredados

Sintetizados. Su valor esta en funcin de los atributos en nodos hijos.

Donde:

u,b,c son atributos
si u := I { b , c )
.
. . u es sintetizado
A.a
B.b C.c
expr.t="95-2"

expr.t="95-" + termino.t="2"

expr.t="9" - termino.t="5" '2'

termino.t="9" '5'

'9'

Pag. 26

Heredados. Su valor esta en funcin de los atributos en nodos padres y/o hermanos.

Definicin dirigida por la sintxis para la declaracin de identificadores integer y real

Ejemplo: Analizar la siguiente sentencia de entrada:

int num

Analizador Lxico

int id

PRODUCCION
D T L

T int

T real

L L
1
, id

L id

Atriboto

L.h

T.tipo
REGLA SEMNTICA
L.h := T.tipo

T.tipo := integer

T.tipo := real

L
1
.h := L.h
anadetipo(id.entrada,L.h)

anadetipo(id.entrada,L.h)

Tipo de Atriboto

heredado

sintetizado

Donde:

u,b,c son atributos
si c := I { b , u )
.
. . c es heredado
A.a
B.b C.c
Pag. 27


Analizador Semntico

Ejercicios:

1. Similar al ejemplo anterior, evaluar la siguiente sentencia de entrada:

real a, b, c

2. La siguiente gramtica genera expresiones separadas mediante el operador aritmtico + a constantes
enteras y reales. Cuando se suman 2 enteros el tipo obtenido es un entero de lo contrario es real:

E E + T | T
T num.num | num

Dar una definicin dirigida por la sintxis para determinar el tipo de cada expresin.

Ejercicio. Dar una Definicin Dirigida por la Sintaxis para registrar en la tabla de simbolos el tipo de dato
de los identificadores, en la sentencia DECLARAR de DBTec.
D
T L
int id
T.tipo
=integer
L.h
=integer

int id.entrada
= 1

D.tipo
=integer

Pag. 28
Acciones Semnticas

Equivalente a un
smbolo gramatical

2.3 Esquemas de traduccin.

Un esquema de traduccin es una gramtica independiente de modelo en la que se asocian atributos con los
smbolos gramaticales y se insertan acciones semnticas encerradas entre llaves dentro de los lados derechos de
las producciones. Los esquemas de traduccin son una notacin til para especificar la traduccin durante el
anlisis sintctico.

Ejemplo: El siguiente esquema de traduccin transforma expresiones infijas con suma y resta en expresiones
postfijas :

E T R
R oparit T { printf(oparit.lexema) } R
1
| c
T num { printf(num.lexema) }

Definicin dirigida por la
sintxis
Esquema de traduccin
ENFOQUE DEL DISEO
DEL ANALIZADOR
Semntico
Gramtica + Reglas
Semnticas.

No aplican un orden
estricto de
evaluacin.
Gramtica + Acciones
Semnticas.
Indican el punto
preciso en que se
debe evaluar la
accin.
Pag. 29

Las acciones encerradas entre llaves se consideran como smbolos terminales, lo cual es conveniente para
establecer cuando se deben ejecutar las acciones. Es decir, los esquemas de traduccin establecen el orden
preciso en que de deban evaluar las acciones semnticas.

Ejercicio. Disear como esquema de traduccin el registro del tipo de dato en la tabla de smbolos de los
identificadores en la sentencia de declaracin de DBTec.

2.4 Comprobacin de tipos.

Un Comprobador de Tipos se asegura de que el tipo de una construccin coincida con el previsto en su
contexto. Por ejemplo, el operador mod en Pascal exige operndoos de tipo entero, de igual manera debe
asegurarse de que la indizacin que se haga sobre una matriz sea con un ndice entero, y de que a una funcin
definida por el usuario se aplique el nmero y tipo correcto de argumentos.

Un compilador debe comprobar si el programa fuente sigue las convenciones sintcticas y semnticas del
lenguaje fuente. Dicha comprobacin puede ser de dos tipos:

1. Esttica. La comprobacin ocurre al compilador.
Cadena de
componentes
lxicos

Analizador
Sintctico
rbol Sintctico

Comprobador de
tipos
Generador de
cdigo
intermedio
Representacin
intermedia
rbol Sintctico
1ig.
Uhicocin de un
comprohodor de tipos
Anolizodor
Semntico
T R
num {printf(num.lexema)} oparit {printf(oparit.lexema)}
E
Pag. 30
2. Dinmica. La comprobacin se realiza al ejecutar el programa

En la comprobacin Esttica existen las siguientes ventajas:

i. Facilita la depuracin de programas ya que verifica los errores posibles.
ii. No requiere guardar toda la informacin acerca de los objetos de datos.

En la comprobacin Dinmica su ventaja principal es la flexibilidad que permite en el diseo de lenguaje ya
que:

a) No requiere una definicin previa del tipo de dato para las variables.
b) El tipo de dato asociado al nombre de la variable puede cambiar durante su ejecucin.

Comprobacin Esttica

Lenguajes orientados a los tipos ( ej. Pascal )

Comprobacin Dinmica

FoxPro
al momento de la ejecucin ....
store 100 to vcalif [ vcalif toma el tipo int]
store reprobados to vcalif [vcalif toma el tipo cadena]
vprom = vcalif / 100 [Error_tipo]

2.5 Expresiones de tipo.

Es o bien un tipo bsico (booleano,char,integer,real) o una expresin que se forma aplicando un operador
llamado constructor de tipos a otras expresiones de tipo

1. Tipo Bsico.

Un tipo bsico es por si solo una expresin de tipo; al conjunto de tipos bsicos se agregan el tipo bsico
especial error_tipo, el cual seala el error durante la comprobacin de tipos. Adems un tipo bsico vaco que
indica la ausencia de valor y permite que se compruebe las proposiciones que no requieren un tipo de dato
especfico.

id := x * a
real := real * char
S if E then S
1

<------- {ERROR_TIPO}
S.tipo
if E.tipo then S
1
.tipo
BOOEAN VACO
VACO

Pag. 31

2. Constructor de tipos.

Un constructor de tipos aplicado a expresiones de tipo es tambin una expresin de tipos.
Los constructores de tipos incluyen:

i. MATRICES:

Si T es una expresin de tipo, entonces:

array ( I , T )

es una expresin de tipo que indica el tipo de una matriz con elementos de tipo T y un conjunto de ndices I,
donde I es un rango de enteros.

Ejemplo:
var A : array [ 1...10 ] of integer

Cul es la expresin de tipo para A ?

array ( 1...10 , integer )

ii. PRODUCTOS:

Si T
1
y T
2
son expresiones de tipo entonces su producto cartesiano:

T
1
x T
2

es tambin una expresin de tipo. Este tipo de constructor se utiliza para definir los tipos de elementos
individuales de un tipo del mayor nivel.

Ejemplo:
var A : array [ 1...10 ] of integer

su expresin de tipo como producto seria:

int x int . . . x int ( hasta 10 veces )

Pag. 32

iii. REGISTROS:

El constructor de tipos record se aplicar a una tabla formada con nombres de compras y tipos de datos.

Ejemplo:
type fila = record
direccion : integer;
lexema : array[1...15] of char;
end;

La expresin de tipo para la declaracin del tipo fila es:

record (int x array ( 1...15 , char )

iv. APUNTADORES

Si T es una expresin de tipo, entonces:

pointer ( T )

es una expresin de tipo que indica el tipo " apuntador a un objeto de tipo T ".

Ejemplo:
var i : integer

La expresin de tipo para i sera:

pointer ( int )

v. FUNCIONES.

Indica el tipo de una funcin que transforma un dominio de tipo D a un rango tipo R. La expresin de tipo:
D R

indicar el tipo de funcin. Por ejemplo, la funcin predefinida "mod" de pascal tiene un dominio de tipo:

int x int

es decir, un par de enteros y rango de tipo:

int

entonces la expresin de tipo completa es:

int x int int
Pag. 33

Ejemplo:
function ( a , b : char ) : integer

char x char pointer ( int )

Ejercicio. Dar la expresin de tipo para:

o int *miArreglo [10]

o void func ( char *c, int i, flota f )

o byte triDi [5][10][15]

o class miClase
{
int i;
bool b;
double d [20];
void m1 ( );
bool m2 ( double d );
}

Pag. 34

2.6 Comprobador de tipos de ejemplo.

Este esta diseado como un esquema de traduccin que sintetiza el tipo de cada expresin:

Ejemplo: Hacer la comprobacin de tipo del siguiente programa

x : char ;
y : integer ;
x : = Hola muchachos ;
if y > 5 then
y : = x ;
P D ; S
D D ; D
D id : T {anadetipo(id.entrada),T.tipo);}
T char {T.tipo:=char;}
T integer {T.tipo:=integer;}
T T
1
{T.tipo:=pointer(T
1
.tipo);}
T array[num] of T
1
{T.tipo:=array(num.entrada,T
1
.tipo);}
S id:=E {S.tipo:=if buscatipo(id.entrada)==E.tipo then VACIO;
else ERROR_TIPO;}
S if B then S
1
{S.tipo:=if B.tipo==BOOLEAN AND S
1
.tipo==VACIO then
VACIO;
else ERROR_TIPO;}
S while B do S
1
{S.tipo:=if B.tipo==BOOLEAN AND S
1
.tipo==VACIO then
VACIO;
else ERROR_TIPO;}

S S
1
; S
2
{S.tipo:=if S
1
.tipo== VACIO AND S
2
.tipo==VACIO then
VACIO;
else ERROR_TIPO;}
E literal {E.tipo:=char;}
E num {E.tipo:=integer;}
E id {E.tipo:= buscatipo(id.entrada);}
E E
1
mod E
2
{E.tipo:=if E
1
.tipo==integer AND E
2
.tipo==integer then
integer;
else ERROR_TIPO;}

E T {E.tipo := T.tipo }
E
1
E
2
+ T {E
1
.tipo := if E
2
.tipo = integer AND T.tipo = integer then
Integer
Else ERROR_TIPO }
T F {T.tipo := F.tipo }

T
1
T
2
* F {T.tipo := if T
2
.tipo = integer AND F.tipo = integer then
Integer
Else ERROR_TIPO }
F (E) {F.tipo := E.tipo }
F id {F.tipo := buscaTipo ( id.entrada ) }
F num {F.tipo := integer }
E E
1
oprel E
2
{E.tipo:=if E
1
.tipo == E
2
.tipo then BOOLEAN
else ERROR_TIPO;}
Pag. 35

Analizador Lxico

id
1
: char;
id
2
: integer;
id
1
:= literal
3
;
if id
2
oprel num
4
then
id
2
:=id
1
;

Analizador Sintctico Semntico

P
D
1
; S
1

D
2
; D
3
S
2
; S
3

id
1
: T
1
id
2
: T
2
id
1
:= E
1
if B then S
4

char integer literal
4
id
2
:= E
2

id
1

Pag. 36
Recorrido del rbol (Comprobador de Tipos)

ATRIBUTOS

Smbolo

Tipo
p
D
1

D
2

D
1

T
1
char
T
2
integer
S
1
ERROR_TIPO
S
2
VACIO
S
3
ERROR_TIPO
E
1
char
S
4
ERROR_TIPO
E
2
char
B BOOLEAN

.
. . ERROR_TIPO (No hay compatibilidad de tipos)

2.7 Diseo de un traductor predictivo

Algoritmo :

1. Para cada no-terminal A
1
constryase una funcin que tenga un parmetro formal para cada atributo
heredado de A y que devuelva los atributos sintetizados de A. La funcin para A tiene una variable local
para cada atributo de cada smbolo gramatical que aparezca en una produccin para A.

2. El cdigo para el no-terminal A decide que produccin utiliza basndose en el smbolo en curso de
entrada.

3. El cdigo asociado con cada produccin hace lo siguiente:

a) Para el smbolo terminal X con atributos sintetizados x guarde el valor de x en la variable declarada
X.x despus emparjese X.

b) Para el no-terminal B genrese una asignacin
Esquema de traduccin con
una gramtica adecuada para
l analisis predictivo
Traductor
predictivo
Algoritmo
Pag. 37

c := B ( b
1
, b
2
,... b
n
)

Donde: b
1
,b
2
,...b
n
son las variables para los atributos heredados de B.
c es la variable para el atributo sintetizado de B.

c) Para el caso de una accin semntica cpiese el cdigo de la accin dentro del analizador sintctico,
sustituyendo cada referencia a un atributo por la variable correspondiente a dicho atributo.

Ejemplo: Implementar la siguiente produccin que sirve para declarar un identificador y su correspondiente
tipo de dato. La accion semntica 4 sirve para registrar el tipo de dato del identificador en la tabla de smbolos.

V -> id : T {4}

{4} = { anadeTipo ( id.entrada, T.tipo )
V.tipo := VACIO
}

El pseudocodigo que implementa el procedimiento del smbolo V seria:

void V ( TAtributos _V )
{
TAtributos _T; // Atributos del smbolo T
TAtributos id; // Atributos del smbolo id
String complex; // Smbolo de preAnalisis

complex = be.preAnalisis.complex; // Obtiene una copia del simbolo de preAnalisis
if ( PRIMEROS ( complex, V ) )
{
id = be.preAnalisis; // Salva los atributos del smbolo id
emparejar ( id );
emparejar ( : );
T ( _T );

// Accion semntica 4 -------------------------------

ts.anadeTipo ( id.entrada, _T.tipo );
_V.tipo = VACIO;

// fin de la accion semntica 4 ------------------------
}
else
error ( ); // error sintactico
}

Pag. 38

Ejemplo: Considere la siguiente produccin que genera la sentencia SQL

S -> DELETE FROM id WHERE C { 1 }

{1} = { S.tipo := if buscaTipo ( id.entrada ) = TABLA AND C.tipo = bolean then vacio
else error_tipo }

El pseudocodigo que implementa el procedimiento del smbolo S seria:

procedure S ( TAtributosSS _S )
begin
TAtributosSS _C // Atributos del simbolo C ( tanto heredados como sintetizados )
TAtributosSS id // Atributos del simbolo id ( )

If preAnalisis = DELETE then
Begin
emparejar ( DELETE )
emparejar ( FROM )

// Salvamos los atributos de id antes de emparejarlo. Solo salvamos el atributo entrada
// porque es el unico que se utiliza de id en las acciones semnticas de esta produccin.
id.entrada := preAnalisis.entrada
emparejar ( id )
emparejar ( WHERE )

// Invocamos el procedimiento de C pasandole sus atributos heredados y
// despus de la llamada nos devolvera sus atributos sintetizados
C ( _C )

// Accion semntica 1
If buscaTipo ( id.entrada ) = TABLA AND _C.tipo = boolean then
begin
_S.tipo := VACIO
end
else
begin
_S.tipo := ERROR_TIPO
error ( ) // Error Semantico
end
//Fin de la Accion semntica 1
End
Else
error ( ) // Error Sintactico
end;

Pag. 39
2.8 Manejo de errores semanticos

Libro: Compiladores. Conceptos fundamentales
Capitulo: 6
Tema: 6.5 Errores semanticos, pag. 126

2.9 Caso de estudio

Comprobador de Tipos de Lenguaje PROGRA

Las acciones semanticas se representan entre llaves de la forma {n}, donde n es el numero del bloque en la tabla de
acciones.

P -> D C {1}
D -> V ; D {2} | {3}
V -> id : T {4}
T -> caracter {5} | entero {6} | real {7}| &T {8} | arreglo [ num ] of T {9}
C -> inicio S fin {10}
S -> Z ; S {11} | {12}
Z -> id {13} A {14} := E {15}
Z -> I L {16}
I -> si B entonces inicio S fin {17}
L -> sino inicio S fin {18} | {19}
Z -> mientras B hacer inicio S fin {20}
E -> H {21} R {22}
R -> oparit H {23} R {24} | {25}
H -> ( E ) {26} | -E {27} | id {28} A {29} | num {30} | num.num {31} | literal {32}
A -> [ E ] {33} | & {34} | {35}
B -> X {36} W {37}
W -> O X {38} W {39} | Y X {40} W {41} | {42}
X -> ( X ) {43} | id {44} oprel F {45} | cierto {46} | falso {47}
F -> id {48} A {49} | num {50} | num.num {51} | literal {52}

TABLA DE ACCIONES
Accion
Semantica
Codigo de la Accion Semantica # Error
de Tipos
1 P.tipo := if D.tipo = vacio AND C.tipo = vacio then vacio else error_tipo; 1
2 D.tipo := if V.tipo = vacio AND D.tipo = vacio then vacio else error_tipo; 2
3 D.tipo := vacio;
4 aadetipo ( id.entrada, T.tipo );
V.tipo := vacio;

5 T.tipo := char;
6 T.tipo := integer;
7 T.tipo := real;
8 T.tipo := pointer ( T
1
.tipo );
9 T.tipo := array ( num, T
1
.tipo );
10 C.tipo := S.tipo;
11 S.tipo := if Z.tipo = vacio AND S.tipo = vacio then vacio else error_tipo; 3
12 S.tipo := vacio;
13 A.h := buscatipo ( id.entrada );
14 E.h := A.tipo;
15 Z.tipo := if E.h = E.tipo then vacio
else if E.h = real AND E.tipo = integer then vacio
else error_tipo;
4
Pag. 40
16 Z.tipo := if I.tipo = vacio AND L.tipo = vacio then vacio else error_tipo; 5
17 I.tipo := if B.tipo = boolean then S.tipo else error_tipo; 6
18 L.tipo := S.tipo;
19 L.tipo := vacio;
20 Z.tipo := if B.tipo = boolean then S.tipo else error_tipo; 7
21 R.h := H.tipo;
22 E.tipo := R.tipo;
23 R
1
.h := if R.h = char OR H.tipo = char then
if R.h = char AND H.tipo = char AND oparit.lexema = + then char
else error_tipo;
else
if R.h = H.tipo then H.tipo
else if R.h = real OR H.tipo = real then real
else error_tipo;

8

9
24 R.tipo := R
1
.tipo;
25 R.tipo := R.h;
26 H.tipo := E.tipo;
27 H.tipo := E.tipo;
29 H.tipo := A.tipo;
30 H.tipo := integer;
31 H.tipo := real;
32 H.tipo := char;
33 A.tipo := if E.tipo = integer AND A.h = array ( s, t ) then t else error_tipo; 10
34 A.tipo := if A.h = pointer ( t ) then t else error_tipo; 11
35 A.tipo := A.h;
36 W.h := X.tipo;
37 B.tipo := W.tipo;
38 W
1
.h := if W.h = boolean AND X.tipo = boolean then boolean else error_tipo; 12
39 W.tipo := W
1
.tipo;
40 W
1
.h := if W.h = boolean AND X.tipo = boolean then boolean else error_tipo; 13
41 W.tipo := W
1
.tipo;
42 W.tipo := W.h;
43 X.tipo := X
1
.tipo;
44 F.h := buscatipo ( id.entrada );
45 X.tipo := if F.h = F.tipo then boolean else error_tipo; 14
46 X.tipo := boolean;
47 X.tipo := boolean;
49 F.tipo := A.tipo;
50 F.tipo := integer;
51 F.tipo := real;
52 F.tipo := char;

Pag. 41

Ejercicios: Analizar los siguientes programas escritos en lenguaje PROGRA hasta la etapa de analisis
semantico.

1.
x : carcter ;
y : entero ;
z : arreglo [ 10 ] de entero ;

inicio
x := hola inges ;
mientras y < 10 hacer
inicio
z [ y ] := 0;
fin;
fin.

2.
x : real ;
y : entero ;

inicio
si x > 3.14 Y y = 0 entonces
inicio
y := x + 1;
fin;
fin.

Pag. 42

UNIDAD III

Generacion de Codigo Intermedio

3.1 Introduccion

Un compilador en su etapa inicial traduce un programa fuente a una representacin intermedia a partir de la
cual la etapa final genera el cdigo objeto.

Analizador Semntico
Comprobador (Esttico de tipos)
Generador de cdigo intermedio
Generador de cdigo intermedio ptimo

Cdigo Objeto

Cdigo intermedio
Pag. 43

3.2 Codigos Intermedios

Cdigos Intermedios:

rbol Sintctico.
Notacin Postfija.
Cdigo de 3 direcciones.

Cdigo de 3 direcciones ( C3D ) .

Recibe este nombre porque participan al mximo 3 variables y normalmente utiliza un operador.

La secuencia de producciones tiene la siguiente forma general:

x : = y op z

donde:

x, y, z Son nombres, variables, constantes, o variables
temporales.

op Es cualquier operador lgico aritmtico.

Ejemplo:

La expresin x + y * z se traduce a C3D como:

t1 := y * z
t2 := x + t1
donde:

t1 y t2 Son variables temporales creadas por el
compilador.

Esta descomposicin de expresiones aritmticas complejas y de proposiciones del flujo de control anidadas
hacia el cdigo de 3 direcciones deseables para generar el cdigo objeto y para la optimizacin. Se llama de 3
direcciones porque cada proposicin contiene generalmente contiene ese nmero de direcciones: 2 para
operndoos y una para el resultado.

El C3D es tambin una representacin lineal izada de un rbol sintctico.

Ejemplo:
a := b * - c + b * - c
Pag. 44

C3D seria:
t
1
:= - c
t
2
:= b * t
1

t
3
:= - c
t
4
:= b * t
3

a := t
2
+ t
4

Ejercicio: Representar el C3D de la siguiente asignacin:

x := ( - b + RAIZ ( b ^ 2 4 * a * c )) / (2 * a )
:=
u +

b - b -

c c
Pag. 45

Tipos de proposiciones de 3 direcciones.

Las proposiciones de 3 direcciones son anlogas al ensamblador; las ms comunes son:

a) Asignacin de la forma:

x := y op z

b) Asignacin de la forma:

x := op y

c) Proposiciones de copia de la forma:

x := y

d) Salto incondicional:

goto E

e) Saltos condicionales, como:

if x oprel y goto E

f) Llamadas a procedimientos.
param x
call p,m

as como:
return y

g) Asociaciones con ndices de la forma:

x := y [ i ]
x [ i ] := y

h) Asociaciones de direcciones y apuntadores de la forma

x := & y
x := * y
* x := y

# de argumentos Nombre del procedimiento
Pag. 46
3.3 Proposiciones de asignacin.

Esquema de traduccin para convertir asignaciones a C3D:

S id := E { p:=busca(id.nombre)
if p = nil then emite(p ":=" E.Lugar)
else ERROR}
E E
1
+ E
2
{ E.Lugar:=tempnuevo()
emite(E.Lugar ":=" E
1
.Lugar "+" E
2
.Lugar)}
E - E
1
emite(E.Lugar ":=" "-" E
2
.Lugar)}
E E
1
* E
2
emite(E.Lugar ":=" E
1
.Lugar "*" E
2
.Lugar)}
E ( E
1
) { E.Lugar:= E
1
.Lugar}
E id { p:=busca(id.nombre)
if p = nil then E.Lugar:=p
else ERROR}

Como parte de la traduccin de las asignaciones a C3D, se muestra como se pueden buscar los nombres en la
tabla de smbolos. El lexema correspondiente al nombre representado como "id" viene dado por el atributo
"id.nombre". La operacin "busca (id.nombre)" comprueba si existe una entrada para este caso del nombre en
la tabla de smbolos, si es as se devuelve el apuntador a la entrada, y en caso contrario "busca (id.nombre)"
devuelve "nil".

Se usa el procedimiento "emite" para escribir el C3D a un archivo de salida.

Finalmente la funcin "tempnuevo()" devuelve una secuencia de nombres distintos(t
1
, t
2
, t
3
...) en respuestas a
sucesivas llamadas.

Ejemplo: Dada a := b * - c + b * - c generar el C3D equivalente al esquema de traduccin anterior:

Analizador Lxico

id
1
:= id
2
* -id
3
+ id
2
* -id
3

Esguemo de troduccin:

S id := E
E E
1
+ E
2

E - E
1

E E
1
* E
2

E ( E
1
)
E id
Pag. 47
Analizador Sintctico - Semntico

Recorrido en Profundidad.

Smbolo

Lugar
E
1
t
5

E
2
t
2

E
3
[ 2 ]
E
4
t
1

E
5
[ 3 ]
E
6
t
4

E
7
[ 2 ]
E
8
t
3

E
9
[ 3 ]

id
3
id
3

id
2
- E
7
id
2
- E
8

E
2
+ E
6

S
id
1
:= E
1

E
3
* E
4
E
7
* E
8

P
[ |
[ |
[ |
[ |
[ 1 |

SALIAS C

t
1
:= -[ 3 ]
t
2
:= [ 2 ] * t
1

t
3
:= -[ 3 ]
t
4
:= [ 2 ] * t
3
t
5
:= t
2
+ t
4

[ 1 ]:= t
5

Pag. 48

3.4 Generacin de C3D para proposiciones del flujo del control

S if E then S
1
| if E then S
1
else S
2
| while E do S
1

En esta gramtica anterior el NO-TERMINAL "E" se asocia a una expresin booleana y con 2 etiquetas:
"E.verdadera" y "E.falsa". "E.verdadera" es la etiqueta a la que fluye el flujo de control si "E" es verdadera y
"E.falsa" es la etiqueta a la que fluye el flujo de control si "E" es falsa.

"S.siguiente" es una etiqueta que asocia la primera instruccin de 3 direcciones que se ejecuta despus del
cdigo correspondiente a.

La idea bsica de traduccin es la siguiente:

Suponga que "E" es de la forma a < b entonces el cdigo generado es de la forma:

if a < b goto E.verdadera
goto E.falsa

a) if then

b) if then - else

E.verdadera :
E.codigo
S
1
.codigo
E.falsa :
a E.verdadera
a E.falsa
goto S.siguiente
S
2
.codigo
...
E.verdadera :
E.codigo
S
1
.codigo

...

E.falsa :
a E.verdadera
a E.falsa

Pag. 49

c) while do

3.5 Definiciones dirigidas por la sintxis para las proposiciones de flujo de
control

a E.falsa
S.comienzo :
E.codigo
S
1
.codigo
E.verdadera :

a E.verdadera
goto S.comienzo
...

E.falsa :
Producciones:

S iI I then S1

S iI I then S1 else S

S while I do S1
Reglas semnticas:

E.verdadera:=etiqnueva();
E.falsa:= S.siguiente;
S.codigo:= E.codigo||emite(E.verdadera':')
||S
1
.codigo;

E.falsa:=etiqnueva();
S
1
.siguiente:= S.siguiente;
S
2
.siguiente:= S.siguiente;
S.codigo:= E.codigo||emite(E.verdadera':')
||S
1
.codigo||emite('goto'S.siguiente)
||emite(E.falsa':') ||S
2
.codigo;

S.comienzo:=etiqnueva();
E.falsa:= S.siguiente;
S
1
.siguiente:= S.comienzo;
S.codigo:= emite(S.comienzo':')|| E.codigo
|| emite(E.verdadera':')||S
1
.codigo
|| emite('goto' S.comienzo);

Pag. 50
Ejemplo: Producir el C3D para el siguiente programa escrito en lenguaje "PROGRA"

mientras x > 10 hacer
inicio
y:= 1;
fin

Analizador Lxico

mientras id
1
oprel num
2
hacer
inicio
id
3
:= num
4
;
fin

Analizador Sintctico - Semntico

num
4

num
2
H R
X W Z
2
; S
2

S
mientras B hacer inicio S fin
id
1
oprel F id
3
A:= E
Pag. 51

Recorrido de Profundidad.

Smbolo

Lugar verdadera falsa Siguiente comienzo h
Z
1
etiq2 etiq1
B etiq3 etiq2
X etiq3 etiq2
F [ 2 ]
W etiq3 etiq2
S
1
etiq1
Z
2

A
E [ 4 ]
H [ 4 ]
R [ 4 ]
S
2

3.6 Traduccin a flujo de control de expresiones booleanas.

if E then S
1
else S
2

while E do S
1

expresin booleana

Suponga que E es de la forma "E
1
OR E
2
". Si E
1
es verdadera entonces se sabe inmediatamente que E misma es
verdadera, as que E
1
.verdadera es lo mismo que E.verdadera. Si E
1
es falsa entonces se debe evaluar E
2
, as
que se convierte E
1
.falsa en etiqueta de la primera proposicin en el cdigo de E
2
.

Las salidas con verdadero y falso de E
2
se pueden se pueden igualar a las salidas con verdadero y falso de E
respectivamente aplicando consideraciones analgicas a las traducciones de "E
1
AND E
2
". Para la expresin de
la forma "NOT E
2
" solo se intercambian las salidas con verdadero y falso de E
1
para obtenerse las salidas con
verdadero y falso de E.
P
[ |
[ 1 |
[ q |
[ |

SALIAS C

etiq1: if [1]>[2] goto etiq3
goto etiq2
etiq3:
etiq3: [3]:=[4]
goto etiq2
etiq2

L
[ |

Pag. 52

Ejemplo: Generar el C3D del siguiente codigo en lenguaje PROGRA:

Si a >= 5 Y a <= 10 entonces
inicio
a := 0;
fin
Sino
inicio
a := 100;
fin

Producciones:

I I1 OR I

I I1 AN I

I NOT I1

I { I1 )

I id1 oprel id

I troe

Reglos semnticos:

E
1
.verdadera:= E.verdadera;
E
1
.falsa:= etiqnueva();
E
2
E
2
.falsa:= E.falsa;
E.codigo:= E
1
.codigo||emite(E
1
.falsa':')
||E
2
.codigo;

E
1
.verdadera:=etiqnueva();
E
1
.falsa:= E.falsa;
E
2
E
2
.falsa:= E.falsa;
E.codigo:= E
1
.codigo||emite(E
1
.verdadera ':')
||E
2
.codigo;

E
1
.verdadera:= E.falsa;
E
1
.falsa:= E.verdadera;
E.codigo:= E
1
.codigo

E
1
E
1
.falsa:= E.falsa;
E.codigo:= E
1
.codigo

E.codigo:= emite('if' id
1
.Lugar oprel.lexema
id
1
.Lugar 'goto' E.verdadera)||
emite('goto' E.falsa)

E.codigo:= emite('goto' E.verdadera)
emite('goto' E.falsa)

Pag. 53

Analisis Lxico

Si id
1
oprel num
2
Y id
1
oprel num
3
entonces
inicio
id
1
:= num
4
;
fin
Sino
inicio
id
1
:= num
5
;
fin

Analisis Sintctico - Semntico

Pag. 54

Recorrido de Profundidad.

Smbolo

Lugar verdadera falsa siguiente comienzo h
Z
1
etiq1
I etiq2
B etiq3 etiq2
X
1
etiq3 etiq2
W
1
etiq4 etiq2
F
1
[ 2 ]
X
2
etiq3 etiq2
W
2
etiq2
F
2
[ 3 ]
S
1
etiq2
S
2

Z
2

A
1
nil
E
1
[ 4 ]
H
1
[ 4 ]
R
1
[ 4 ] [ 4 ]
L etiq1 etiq2
S
3

Z
3

A
2
nil
E
2
[ 5 ]
H
2
[ 5 ]
R
2
[ 5 ] [ 5 ]
S
4

SALIAS C

if [1]>=[2] goto etiq3
goto etiq2
etiq3:
if [1]<=[3] goto etiq4
goto etiq2
etiq4 :
[1]:=[4]
goto etiq1
etiq2:
[1]:=[5]
etiq1:
P
[ |
[ 1 |
[ |
[ 1 |
[ q |
[ 1 |
[ g |

[ 1 |

P
[ 1 |
[ 1 |

Pag. 55

3.7 Caso de Estudio

Generador de Codigo Intermedio para Lenguaje PROGRA

P -> D C
D -> V ; D |
V -> id : T
T -> caracter | entero | real | &T | arreglo [ num ] of T
C -> inicio S fin
S -> Z ; S |
Z -> id A := E {1}
Z -> {19} I {20} L {21}
I -> si {22} B entonces inicio S fin
L -> sino inicio {23} S fin | {24}
Z -> mientras {16} B {17} hacer inicio S fin {18}
E -> H {5} R {6}
R -> oparit H {7} R {8} | {9}
H -> ( E ) {10} | -E {11} | id A {12} | num {13} | num.num {14} | literal {15}
A -> [ E ] {2} | & {3} | {4}
B -> {25} X {26} W
W -> O {27} X {28} W | Y {29} X {28} W | {30}
X -> ( {33} X ) | id oprel F {31} | cierto {32} | falso
F -> id A {37} | num {34} | num.num {35} | literal {36}

TABLA DE ACCIONES
Accion
Semantica
Codigo de la Accion Semantica # Error
del GCI
1 p := id.entrada;
if p <> nil then
begin
u := if A.lugar = nil then p else p || , || A.lugar;
emite ( u := E.lugar );
end
else error;

101
2 A.lugar := E.lugar;
3 A.lugar := nil;
4 A.lugar := nil;
5 R.h := H.lugar;
6 E.lugar := R.lugar;
7 R
1
.h := tempnuevo;
emite ( R
1
.h := R.h oparit.lexema H.lugar );

8 R.lugar := R
1
.lugar;
9 R.lugar := R.h;
10 H.lugar := E.lugar;
11 H.lugar := tempnuevo;
emite ( H.lugar := menosu E.lugar );

12 p := id.entrada;
if p <> nil then
begin
H.lugar := u;
end
else error;

102
13 p := num.entrada;
Pag. 56
if p <> nil then H.lugar := p else error; 103
14 p := num.num.entrada;
if p <> nil then H.lugar := p else error;

104
15 p := literal.entrada;
if p <> nil then H.lugar := p else error;

105
16 Z.comienzo := etiqnueva;
Z.siguiente := etiqnueva;
B.verdadera := etiqnueva;
B.falsa := Z.siguiente;
S.siguiente := Z.comienzo;
emite ( Z.comienzo : );

17 emite ( B.verdadera : );
18 emite ( goto Z.comienzo );
emite ( B.falsa : );

19 Z.siguiente := etiqnueva;
I.siguiente := etiqnueva;

20 L.h := I.siguiente;
L.siguiente := Z.siguiente;

21 emite ( L.siguiente : );
22 B.verdadero := etiqnueva;
B.falsa := I.siguiente;
S.siguiente := I.siguiente;

23 emite ( goto L.siguiente );
emite ( L.h : );

24 L.siguiente := L.h;
25 X.verdadero := B.verdadero;
X.falso := B.falsa;

26 W.verdadero := X.verdadero;
W.falsa := X.falsa;

27 X.verdadero := W.verdadero;
X.falsa := W.falsa;
W.falsa := etiqnueva;
emite ( goto W.falsa );
emite ( W.falsa : );

28 W
1
.verdadero := X.verdadero;
W
1
.falsa := X.falsa;

29 X.verdadero := W.verdadero;
X.falsa := W.falsa;
W.verdadero := etiqnueva;
emite ( goto X.falsa );
emite ( X.verdadero : );
X.verdadero := W.verdadero;

30 emite ( goto W.falsa );
emite ( W.verdadera : );

31 p := id.entrada;
if p <> nil then emite ( if p oprel.lexema F.lugar goto X.verdadera )
else error;

106
32 emite ( goto X.verdadera );
33 X
1
.verdadera := X.verdadera;
X
1
.falsa := X.falsa;

34 p := num.entrada;
if p <> nil then F.lugar := p else error;

107
35 p := num.num.entrada;

108
36 p := literal.entrada;

109
37 p := id.entrada;
Pag. 57
if p <> nil then
begin
F.lugar := u;
end
else error;

110

Pag. 58

UNIDAD IV

Administracin
de la Memoria Principal

4.1 Organizacin de la memoria

Durante la ejecucin la memoria debe subdividirse para almacenar:

1) Cdigo objeto Generado
2) Objetos de datos
3) Espacio para operaciones y procedimientos

Fig. 4.1 Subdivisin
tpica de la memoria
principal al momento
de ejecucin.

El cdigo generado tiene un tamao fijo determinado en el momento de la compilacin, de este modo la
asignacin de memoria para este elemento resulta esttica y se deja en un lugar en el cual no afecte el
uso de la memoria.

De manera similar se puede conocer el tamao de algunos datos en el momento de la compilacin y por
tanto estos pueden ir colocados en una zona esttica.

Los datos cuyas direcciones estn contenidas en la activacin de un procedimiento se puede asociar y
colocar en una pila.

Un rea distinta de la memoria para el momento de la ejecucin se llama montculo, en el cual la
memoria se gestiona solicitndola y devolvindola.

Cdigo
Datos Estticos
Pila
.
.
.
Montculo
Pag. 59

4.2 Registro de Activacin de un Procedimiento

La informacin necesaria para una sola ejecucin de un procedimiento se consigue utilizando un bloque
contiguo de memoria llamado registro de activacin, que consta de lo siguiente.

Registro de Activacin
Del Procedimiento
Autor de la llamada

Registro de Activacin
Del Procedimiento
Receptor de la llamada

Temporales

Los valores temporales como los que surgen durante la evaluacin de expresiones se almacenan en esta
posicin.

Datos Locales

Guarda los datos locales a una ejecucin de un procedimiento.

Estado de la memoria guardado

Contiene informacin sobre el estado del procesamiento. Esta informacin incluye los valores del
contador de programa y los registros de la maquina que deben reponerse cuando el control regrese del
procedimiento.

Enlace de Acceso (opcional)

Se utiliza para hacer referencia a los datos guardados en otros registros de activacin.

Enlace de Control (opcional)
Parmetros y valor
devuelto
Enlaces y estado
guardado
Datos Temporales y
Locales
Parmetros y valor
devuelto
Enlaces y estado de
guardado
Datos Temporales y
Locales
Pag. 60

Apunta al registro de activacin del autor de la llamada.

Parmetros Actuales

Es utilizado por el procedimiento autor de la llamada para proporcionar parmetros al procedimiento
que recibe la llamada. Para estos parmetros existe espacio en el registro de activacin, pero en la
prctica los parmetros se pasan en los registros de la maquina para mayor eficiencia.

Valor Devuelto

Este campo es utilizado por el procesamiento que recibe la llamada para devolver un valor al
procedimiento autor de la llamada. En la prctica este valor se suele trasladar en un registro para una
mayor eficiencia.

4.3 Implementacin de la Definicin y la invocacin de Procedimientos

Considere la siguiente definicin de procedimientos en Pascal:

Function FN(x:real; y:integer):real
Const
Max = 20;
Var
M : array[1Max] of real;
N : integer;
Begin
.
.
.
N = Max;
X := 2 * x + M[5];
.
.
.
End;

Pag. 61
Segmento de
cdigo para
(esttica)
Registro de
Activacin para
FN (dinmica)
FN
X
Y
M
N
Punto de retorno y otros datos del sistema
Resultado de la funcin
Parmetros
Variables locales
4.4 Estructura de la Activacin del Procedimiento

Solo existe en la memoria una sola copia del cdigo de fin, por eso usa memoria esttica.

El registro de activacin se crea por cada llamada a la funcin FN.

Prologo
Preposiciones en
cdigo ejecutable
Eplogo
20
2
5
1
Cdigo

Datos estticos
Pila
.
.
.
Montculo

FN
X
Y
M[1]
.
.
.
M[20]
Bloque de
cdigo
ejecutable
Constantes
Pag. 62
Segmento de cdigo
para FN
Segmento de cdigo
para FN
Segmento de cdigo
para FN
Segmento de cdigo
para FN
Almacenamiento esttico
Almacenamiento esttico
1 Activacin de FN
2 Activacin de FN
Ultima Activacin de FN
I1:
I2:
I3:
I6:
I4:
I5:
Segmentos
de cdigo
(almacena
miento
esttico)

El segmento de cdigo compartido, los registros de activacin se crean en forma separada sobre
diferentes llamadas al procedimiento.

4.5 Implementacin de la Ejecucin

Para evitar la confusin no podemos hablar simplemente de la ejecucin de una proposicin particular S
en el procedimiento, sino hay que hablar de la ejecucin de S durante la activacin R del procedimiento.

Entonces para conocer el punto en el cual el procedimiento se ejecuta se requieren dos apuntadores:

AIA Apuntador a instruccin actual
AAA Apuntador a ambiente actual

Programa Principal

.
.
.
Llama A
.
.
.
Llama B
.
.
.
Llama A
.
.
.
Fin
Constantes
.
.
.
Llama B
.
.
.
Regreso
Constantes
.
.
.
.
.
.
.
Regreso
Constantes
Pag. 63
R1: R2: R3:
Punto de regreso
AIA
AAA
Variables apuntadoras definidas
por el sistema

Cada vez que se ejecuta un procedimiento se crea un registro de activacin.

::
-
-
Variables
locales
etc.
I1
R1
Variables
locales
etc.
I4
R2
Variables
locales
etc.
I6 I5
R2 R3

PS Apuntes U1 2 3 4 Rev A2008

Cargado por

Información del documento

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

PS Apuntes U1 2 3 4 Rev A2008

Cargado por

Copyright:

Formatos disponibles

Instituto Tecnolgico de la Laguna

Ingenieria en Sistemas Computacionales

También podría gustarte