Presentaci

1
Programación de sistemas 2

• Temario.
• Unidad 1. Repaso de sintaxis.
• 1.1 Gramática de un lenguaje.
• 1.2 Descenso recursivo.
• Unidad 2. Semántico.
• 2.1 Forma interna del programa fuente.
• Notación polaca.
• Cuádruplos.
• 2.2 Rutinas semánticas.
• Expresiones aritméticas.
• Estatutos condicionales.
• Unidad 3. Generación de código.
• 3.1 Cuádruplos.
• 3.2 Notación polaca.
• Expresiones aritméticas.
• Expresiones condicionales.
• 3.3 Optimización de código.

2
Repaso

• Gramática.
• Conjunto de reglas que determinan un un lenguaje.
• Sintáxis.
• Verifica que la secuencia de tokens sea válida
  para un lenguaje.
• Tipos de gramática.
• 1. Irrestricta.
• x ? y en donde x tiene por lo menos
  un elemento no terminal.
• 2. Contexto sensitivo o sensitiva al contexto.
• x ? y
• x lt y (en cuanto al número de
  elementos de y)
• y gt 0 (no permite producciones con el
  elemento vacio)
• 3. Libre de contexto.
• x ? y
• x 1 y es un elemento no terminal.
• y gt 0

3
Lineal izquierdo. Es la derivación en donde tan
solo el no terminal de más a la izquierda de
cualquier forma de frase se sustituye a cada
paso. ltSgt ? ltYgt x ltYgt ? ltZgt y ltZgt ?
ltWgt z ltZgt ? ? ltWgt ? w wzyx Lineal
derecha. Es la derivación en donde tan solo el no
terminal de más a la derecha de cualquier forma
de frase se sustituye a cada paso. ltSgt ? x ltYgt
ltYgt ? y ltZgt ltZgt ? z ltWgt ltZgt ?
? ltWgt ? w xyzw Recursiva izquierda. Es la
derivación en donde tan solo el no terminal de
más a la izquierda se sustituye a cada paso
recursivamente es decir a si misma. ltSgt ? ltSgt a
ltSgt d ltSgt ? ltSgt b ltSgt ? c ltSgt ? ltSgt cbaa
4
Recursivo derecho. Es la derivación en donde tan
solo el no terminal de más a la derecha se
sustituye a cada paso recursivamente es decir a
si misma. ltXgt ? ltSgt ltSgt ? a ltSgt d ltSgt ltSgt ?
b ltSgt ltXgt ? c aabc Recursiva central. Es la
derivación en donde tan solo el no terminal del
centro se sustituye a cada paso recursivamente es
decir a si misma. ltXgt ? ltSgt ltSgt ? a ltSgt b ltSgt
? c ltSgt d ltSgt ? e acedb Ejemplos Libre de
contexto. ltSgt ? if ltXgt then ltYgt
x ? y ltXgt ? a ltopgt b
x 1 ltopgt ? gt lt
Y gt 0 ltYgt ? x
ltopAgt y Puede tener
vacio ltopAgt ?
5
Contexto sensitivo. ltSgt ? ltXgt ltYgt x y
ltXgt ? a ltZgt y ? e no permite vacio altZgt ?
b ltWgt ltYgt ? d ltWgt ? c Irrestricta. ltXgt ? ltAgt
ltBgt Sin restricciones. ltAgt ? a ltBgt ?
b Derivación. Consiste en sustituir los elementos
no terminales por sus producciones. Ejemplo ltSgt
? IF ltXgt then ltYgt Se sustituye de izquierda a
derecha ltSgt ? IF a ltOPgt b then ltYgt ltSgt ? IF altb
then ltYgt ltSgt ? IF altb then x ltOPAgt y ltSgt ? IF
altb then xy El resultado es solo con
terminales Componentes de la gramática. GP, S,
V, V o bien GP, S, T, N En
donde Pproducciones. Sproducción
inicial Vlos elementos terminales Vlos
elementos no terminales
6
De el ejemplo anterior........ PS, X, Y, op,
opA SS Va, if, b, then, x, y, , gt,
gt VS, X, Y, op, opA Cómo se representa una
gramática gráficamente? Diagrama de sintáxis.
Dirección Terminales No
terminales Patrones más comunes. a) Secuencia
de símbolos. ltSgt ? a ltXgt b
7
b) Alternativa de símbolos. ltTIPOSgt ?
real char int c) Repetición de
símbolos. ltXgt ? a ltXgt ltXgt ?
a Ejemplos
ltTIPOSgt
real
char
int
8
ltPROGRAMgt ? fun id ltXgt ltTIPOgt ltXgt ? ltPARAMgt
? ltPROGRAMgt ? prac id ltXgt
var
ltPARAMgt
(
id
)

TIPO
X

Y
ltPARAMgt ? ( ltXgt ltYgt ltTIPOgt ) ltXgt ? var
? ltYgt ? id ltZgt ltZgt ? id ltZgt ltZgt ? ? ltTIPOgt ?
char int real Validar la siguientes
cadenas (var ididreal) ltPARAMgt ? (ltXgt ltYgt
ltTIPOgt) ltPARAMgt ? (var ltYgt ltTIPOgt) ltPARAMgt ?
(var id ltZgt ltTIPOgt) ltPARAMgt ? (var id id ltZgt
ltTIPOgt) ltPARAMgt ? (var id id
ltTIPOgt) ltPARAMgt ? (var id id real)
9
fun id (id char) real ltPROGRAMgt ? fun id ltXgt
ltTIPOgt ltPROGRAMgt ? fun id ltPARAMgt
ltTIPOgt ltPROGRAMgt ? fun id (ltXgt ltYgt ltTIPOgt)
ltTIPOgt ltPROGRAMgt ? fun id (ltYgt ltTIPOgt)
ltTIPOgt ltPROGRAMgt ? fun id ( id ltZgt ltTIPOgt)
ltTIPOgt ltPROGRAMgt ? fun id ( id ltTIPOgt)
ltTIPOgt ltPROGRAMgt ? fun id ( id char ) real
10
Análisis Sintáctico

• Análisis Sintáctico Descendente.
• Análisis Sintáctico por descenso recursivo.
• Análisis Sintáctico recursivo. (predictivo).
• Análisis Sintáctico Ascendente.
• Análisis sintáctico LR-Simple.
• Análisis sintáctico LR-Canónico.
• Análisis sintáctico LALR (lookahead-LR)
• Análisis sintáctico

Buffer de entrada
a b
Y

Z
X
Programa Sintáctico
Salida de producciones
ltXgt --gt ltYgtltZgt ltZgt --gt b ltYgt --gt a

PILA
Tabla de análisis sintáctico predictivo (Matriz
predictiva)
11
Un analizador sintáctico esta guiado por tablas,
tiene un buffer de entrada, una pila, y una tabla
de análisis sintáctico y también una salida. El
buffer de entrada contiene la cadena que se va a
analizar seguida de un símbolo de pesos (), un
símbolo utilizado como delimitador derecho para
indicar el fin de la cadena. La pila contiene
una secuencia de símbolos gramaticales con un
símbolo de pesos en la parte inferior que indica
la base de la pila, al principio la pila contiene
el símbolo inicial de la gramática encima del
signo de pesos. La tabla de análisis sintáctico
es una matriz bidimensional de la forma M A,a
en donde A es un no terminal y donde a es el
símbolo terminal o bien el signo de , se
controla el analizador sintáctico mediante un
programa que se comporta como sigue Sea X el
símbolo superior de la pila y a el símbolo en
curso de la entrada estos dos símbolos
determinan la acción del analizador y tienen las
siguientes acciones 1)Si x a El string
es válido. 2)Si x a ? Se saca x de la pila
Se mueve el apuntador al siguiente símbolo o
analizador en curso. 3)Si x es un no terminal el
programa consulta la entrada de M X,a de la
tabla de la matriz de análisis
sintáctico. Esta entrada será o una producción
de x de la gramática o una entrada de error. Si,
por ejemplo, M X,a es igual a x que produce uvw
osea M X,a X?ltygtltzgt el analizador
sintáctico sustituye la x de la cima de la pila
por ltzgtltygt quedando en la parte de encima de la
ltygt como salida, se sabe que el analizador
sintáctico solo imprime la producción utilizada
ahí se podría utilizar cualquier otro código. Si
M X,a error el analizador sintáctico llama
a una rutina de recuperación de error e indica el
tipo de error que a ocurrido.    
12

• Ventajas
• Programación medianamente corta.
• Medianamente fácil de programar.
• Desventajas.
• Un mantenimiento no sencillo.
• Restricciones.
• Solo para gramáticas libres de contexto.
• Se tiene que eliminar la recursividad izquierda y
  factorizar si es necesario. (No debe haber 2
  elementos en una sola de las casillas de la
  matriz predictiva)
• Ejemplo
• 1) ltEgt ? ltTgt ltEgt
• 2) ltEgt ? ltTgt ltEgt
• 3) ltEgt ? ?
• 4) ltTgt ? ltFgt ltTgt
• 5) ltTgt ? ltFgt ltTgt
• 6) ltTgt ? ?
• 7) ltFgt ? id

13
PILA ENTRADA SALIDA
ltEgt Idid 1) ltEgt ? ltTgtltEgt
ltEgtltTgt Idid 4) ltTgt ? ltFgt ltTgt
ltEgtltTgtltFgt Idid 7) ltFgt ? id
ltEgtltTgt id Id id 6) ltTgt ? ?
ltEgtE 2) ltEgt ? ltTgtltEgt
ltEgtltTgt id 4) ltTgt ? ltFgt ltTgt
ltEgtltTgtltFgt Id 7) ltFgt ? id
ltEgtltTgtid Id
ltEgtltTgt 6) ltTgt ? ?
ltEgtE 3) ltEgt ? ?
Cadena válida
14
 Primeros y siguientes. Se facilita la
construcción de una analizador sintáctico
predictivo con 2 funciones asociadas a una
gramática (G). Estas funciones P y S permiten
rellenar siempre que sea posible las entradas de
una tabla de análisis sintáctico predictivo para
una gramática. También se puede utilizar los
conjuntos de componentes léxicos devueltos por la
función S como componentes léxicos de
sincronización durante la recuperación de
errores.  Si a es una cadena de símbolos
gramaticales se considera primeros de a como el
conjunto de terminales que inician las cadenas
derivadas de a.  Si a ? e entonces el vacío
también está en primeros de a.  Se define
siguientes de A para el no terminal de A, como el
conjunto de terminales de A que pueden aparecer
inmediatamente a la derecha de A en alguna forma
de frase, es decir, el conjunto de terminales de
A tal que halla una derivación de la forma S ?
aAaß para algún a y ß.  Primeros.  Primero (a)
es el conjunto de símbolos terminales que inician
cualquier derivación de a.   Cálculo a)     Si X
es un símbolo terminal, entonces primeros (a) X
b)     Si X es un símbolo no terminal, entonces
para cada producción del tipo x ? ß1,
ß2........ ßn 1)    Incluir primeros de (ßi) el
primeros de (X) 2)    De i1 hasta n-1 Si e está
incluido en primeros de (ßi) incluir en primeros
de (ßi1). 3)    Tomando como base el punto
anterior, si vacío está incluido en primeros de
(ßi) hasta primeros de (ßn) incluir vacio en
primeros de (X).
15
Ejemplo ltSgt ? ltEgt a ltEgt ? op ltEgt ? ? PltSgt
PltEgt op, ? PltEgt op, ? Siguientes. X ?
YZ  1)     Si X es la primera producción de la
gramática se incluye en siguientes de X. 2)    
Los siguientes de Y son a)    Si Z es un
terminal se incluyen los primeros (Z) en
siguientes (Y) a excepción del vacío. b)    Si Z
es un no terminal se incluyen los primeros (Z) en
siguientes de Y a excepción del vacío. 3)     Los
siguientes de Z son, si Z es el último término de
la producción, se incluyen los siguientes de esa
producción en siguientes de Z.   No se incluye el
vacío en vez de esto se incluyen los siguientes
de la producción que genera el vacío. Ejemplo
1) ltEgt ? ltTgt ltEgt 2) ltEgt ? ltTgt ltEgt 3) ltEgt
? ? 4) ltTgt ? ltFgt ltTgt 5) ltTgt ? ltFgt ltTgt 6)
ltTgt ? ? 7) ltFgt ? id 8) ltFgt ? (ltEgt)
16

• Primeros.
• P(ltEgt) P(ltTgt) id, (
• P(ltEgt) , ?
• P(ltTgt) P(ltFgt) id, (
• P(ltTgt) , ?
• P(ltFgt) id, (
• Siguientes.
• S(lt Egt) , )
• S(ltEgt) S(ltEgt), S(ltEgt) , )
• S(ltTgt) P(ltEgt) , S(ltEgt) , , )
• S(ltTgt) S(ltTgt), S(ltTgt) , , )
• S(ltFgt) P(ltTgt) , S(ltTgt) , , ,
  )
• Construcción de la matriz predictiva.
• Para cada producción A ? ? realizar lo siguiente
• a) Para cada símbolo terminal en primero de (?)
  agregar A ? ? en MA, ?
• b) Si ? esta contenido en primero (?), entonces
  para cada símbolo terminal

17
V V id ( )
ltEgt error 1 1 error error error
ltEgt 3 error error 3 2 error
ltTgt error 4 4 error error error
ltTgt 6 error error 6 6 5
ltFgt error 7 8 error error error
PILA ENTRADA SALIDA (producciones)
ltEgt Ididid 1
ltEgtltTgt Ididid 4
ltEgtltTgtltFgt Ididid 7
ltEgtltTgtid Id idid 5
ltEgtltTgtltFgt idid 7
ltEgtltTgtid idid 6
ltEgt 2
ltEgtltTgt id 4
ltEgtltTgtltFgt Id 7
ltEgtltTgtid Id 6
ltEgt 3
Cadena válida
18
Ejercicio Realizar primeros, siguientes, matriz
predictiva y validar las siguientes
cadenas bmdm, fd, fdm 1) ltAgt ? ltBgt d ltAgt 2)
ltAgt ? m 3) ltBgt ? ltCgt ltDgt 4) ltCgt ? b ltAgt 5) ltCgt
? ? 6) ltDgt ? f checar
gramatica 7) ltDgt ? g Primeros. P(ltAgt)
P(ltBgt), m, b, m, ? P(ltBgt) P(ltCgt) b,
? P(ltCgt) b, ? P(ltDgt) f,
g Siguientes. S(ltAgt) S(ltAgt), S(ltCgt) f, g,
S(ltBgt) d S(ltCgt) P(ltDgt) f, g S(ltDgt)
S(ltBgt) d
T N b m d f G
ltAgt 1 2 error 1 1 error
ltBgt 3 error error 3 3 error
ltCgt 4 error error 5 5 error
ltDgt error error error 6 7 error
19
bmdm
PILA ENTRADA SALIDA
ltAgt bmdm 1
ltAgtdltBgt bmdm 3
ltAgtdltDgtltCgt bmdm 4
ltAgtdltDgtltAgtb bmdm 2
ltAgtdltDgtm mdm error
fd
PILA ENTRADA SALIDA
ltAgt fd 1
ltAgtdltBgt fd 3
ltAgtdltDgtltCgt fd 5
ltAgtdltDgt fd 6
ltAgtdf fd
ltAgt Cadena no válida
20
fdm
PILA ENTRADA SALIDA
ltAgt fdm 1
ltAgtdltBgt fdm 3
ltAgtdltDgtltCgt fdm 5
ltAgtdltDgt fdm 6
ltAgtdf m 2
m m Cadena válida
1) ltSgt ? if ltCONDgt then ltOPERACIONgt else ltASIGgt
end 2) ltCONDgt ? id ltORgt id 3) ltORgt ? gt 4) ltORgt
? lt 5) ltOPERACIONgt ? id ltOAgt id 6) ltOAgt ? 7)
ltOAgt ? - 8) ltOAgt ? 9) ltASIGgt ? id ltAgt
id 10) ltAgt ? Para la gramática anterior
validar la siguiente cadena if id lt id
21
Primeros. P(ltSgt) if P(ltCONDgt) id
P(ltORgt) gt, lt P(ltOPERACIONgt) id
P(ltOAgt) , -, P(ltASIGgt) id P(ltAgt)
Siguientes. S(ltSgt) S(ltCONDgt)
then S(ltORgt) id S(ltOPERACIONgt) else
S(ltOAgt) id S(ltASIGgt) end S(ltAgt)
id
If then else end id gt lt -
1 1 error error error error error error error error error error error
2 error error error error 2 error error error error error error error
3 error error error error error 3 4 error error error error error
4 error error error error 5 error error error error error error error
5 error error error error error error error 6 7 8 error error
6 error error error error 9 error error error error error error error
7 error error error error error error error error error error 10 error
22
PILA ENTRADA SALIDA
ltSgt If id lt id then 1
endltASIGgtelseltOPERACIONgtthenltCONDgtif id lt id then 2
endltASIGgtelseltOPERACIONgtthen idltORgt id lt id then 4
endltASIGgtelseltOPERACIONgtthen id error

• Técnicas de análisis ascendentes para
  analizadores sintácticos.
• LR- Simple
• LR- Canónico
• LALR
• Constituyen un árbol de derivación para un string
  de entrada, iniciando por las
• y avanzando a la raíz.
• Ventajas.
• Se detectan errores tan pronto como se van
  obteniendo las entradas.
• No importan la recursividad de las gramáticas ni
  deben estar factorizadas.
• Desventajas.
• Cuesta más trabajo implementar la técnica.

23
Método LR-Simple.
Entrada

0

Programa Analizador LR
SALIDA
PILA
TABLA DE ACCIONES
TABLA DE SALTOS
En este método la pila almacena símbolos
terminales y no terminales en el tope de la pila
siempre se debe encontrar un estado (que va a ser
el estado actual del analizador). Cada espacio
resume la información contenida en la pila. La
combinación del símbolo de estado en el tope se
la pila y el símbolo de estado En el tope de la
pila y el símbolo de entrada actual se utiliza
para indexar la tabla de acciones a la tabla de
saltos, inicialmente la pila contiene el estado
cero.
24
Agregar apuntes pag 90 libro de fundamentos de
compiladores
25

• Tabla de acciones.
• Es un arreglo bidimensional con un arreglo para
  cada posible estado y una
• columna para cada símbolo terminal de la
  gramática y para el signo de pesos.
• Cada casilla de la tabla contienen las
  siguientes acciones.
• ACC. Aceptación.
• ERR. Error.
• SN. Desplazamiento en introducción del estado no
  terminal de la pila.
• RN. LA reducción utilizando la producción no
  terminal.
• Tabla de saltos.
• Es un arreglo bidimensional con un renglón para
  cada posible estado y una
• columna para cada símbolo no terminal de la
  gramática, cada casilla contiene
• un estado.

TABLA DE ACCIONES TERMINALES
TABLA DE SALTOS NO TERMINALES
id / x y z w
0 error error error error ACC 1 error error error
1 error error error error error error 2 error error
2 error error error error error 3 error error 4
3 error error S1 error error error 5 error error
4 R1 error error error S2 error error error error
5 R3 error error R2 error error error error error
etc error error error error error error error error error
26
Ejemplo Método LR. 0) ltEgt ?. ltEgt 1) ltEgt
?.ltEgtltTgt 2) ltEgt ?.ltTgt 3) ltTgt ?.ltTgt ltFgt 4)
ltTgt ?. ltFgt 5) ltFgt ?.id 6) ltFgt
?.(ltEgt) Primeros. P(ltEgt) P(ltEgt) id, (
P(ltEgt) P(ltEgt), P(ltTgt) id, ( P(ltTgt)
P(ltTgt), P(ltFgt) id, ( P(ltFgt) id, (
Siguientes. S(ltEgt) S(ltEgt) S(ltEgt),
, ) ,, ) S(ltTgt) S(ltEgt), ,,
), S(ltFgt) ,, ),
27
, , )
R2
ltEgt ? ltTgt. ltTgt ? ltTgt. ltFgt
Sig E
S7

, , ),
ltTgt ? ltFgt.
R4
ltFgt ? id.
, , ),
R5
Sig F
ltFgt ? (.ltEgt) ltEgt ? .ltEgt ltTgt ltEgt ? .ltTgt ltTgt ?
.ltTgt ltFgt ltTgt ? .ltFgt ltFgt ? .id ltFgt ? .(ltEgt)
28
T
6
ltEgt ? ltEgt .ltTgt ltTgt ? .ltTgt ltFgt ltTgt ? .ltFgt ltFgt
? .id ltFgt ? .(ltEgt)
9
T
9
F
3
id
S4
(
S5
F
ltTgt ? ltTgt .ltFgt ltFgt ? .id ltFgt ? .(ltEgt)
10
7
id
S4
(
S5
)
ltFgt ? (ltEgt.) ltEgt? ltEgt . ltTgt
S11

S6
, , )
ltEgt? ltEgt ltTgt. ltTgt? ltTgt . ltFgt
R1
Sig. E

S7
, , ),
R3
ltTgt ? ltTgt ltFgt.
10
Sig. T
, , ),
ltFgt ? (ltEgt).
R6
Sig. F
29
TABLA DE ACCIONES TERMINALES
TABLA DE SALTOS NO TERMINALES
) ( id E T F
0 error error S5 S4 error error 1 2 3
1 S6 error error error error ACC error error error
2 R2 R2 error error S7 R2 error error error
3 R4 R4 error error R4 R4 error error error
4 R5 R5 error error R5 R5 error error error
5 error error S5 S4 error error 8 2 3
6 error error S5 S4 error error error 9 3
7 error error S5 S4 error error error error 10
8 S6 11 error error error error error error error
9 R1 R1 error error error R1 error error error
10 R3 R3 error error R3 R3 error error error
11 R6 R6 error error R6 R6 error error error


30
Verificar si la siguiente cadena es válida id
id
PILA ENTRADA SALIDA
0 id id S4
0id4 id R5 F ? id
0F3 id R4 T ? F
0T2 id R2 E ? T
0E1 id S6 desplaza
0E16 Id S4 desplaza
0E26id4 R5 F ? id
0E16F3 R4 T ? F
0E16T9 R1 E ? E T
0E1 ACC

• Eliminación de la recursividad por la izquierda.
• A ? Aa B
• Ejemplo
• Aquellas que no contengan al elemento recursivo
  se agrega una producción nueva (A) al lado
  derecho.
• A ? BA
• Aquellas producciones que si contengan al
  elemento recursivo se pasa el elemento recursivo
  como la producción nueva al lado derecho y se
  agrega una producción de la misma que produce e.
• A ? a A 1) A ? BA
• A ? e 2) A ? aA
• 3) A ? e

31
Ejemplos Gramatica original. S ? Aa b A ?
Ac Sd e
Eliminación de la recursividad. S ? Aa b A ?
bd A A ? e A ? cA A ? adA A ? e
Eliminación de la recursividad. 1) E ? T E 2)
E ? T E 3) E ? e 4) T ? F T 5) T ? F
T 6) T ? e 7) F ? id
Gramatica original. 1) E ? E T 2) E
? T 3) T ? T F 4) T ? F 5) F
? id 6) F ? (E)
32
Generación de código intermedio

• El código intermedio forma un lenguaje de bajo
  nivel, sin llegar al nivel más
• primitivo.
• Tipos de código intermedio.
• CONVERTIDA
• Notación polaca. ABCD ABCD
• Triplos. ABCD
• Cuádruplos. ABCD

oper op1 op2
C D
B T1
A R2
oper op1 op2 res
C D T1
B T1 T2
A T2
33
Triplos. Este tipo de código utiliza
instrucciones en un formato de 3 campos.
Oper Op1 Op2
En donde Oper Código de operación. Op1
Operando 1 Op2 Operando 2 Ejemplo A B
1
ltSgt
3
OP1
2

-
TRIPLO
B
A

A B
Pila de operandos
Pila de operadores
34

• Acciones.
• 1 Insertar en la pila de operandos.
• PUSH_pilaop(pos_act) id ó cte
• pos_act1
• 2 Insertar en la pila de operadores.
• PUSH_pilaoper(pos_act) ó
• pos_act1
• 3 Genera triplo de la siguiente forma.
• Op2 tope pila_op ? sacar
• Op1 tope pila_op ? sacar
• Oper tope pila_oper ? sacar
• Comparación de los diversos modos expuestos.
• En cuanto a la cantidad de memoria que requiere
  para su almacenamiento
• podríamos ordenarlos de mayor a menor.
• Notación polaca.
• Código P.
• Triplos.
• Cuádruplos.

35

• Si lo que se requiere es convertir el código
  intermedio a código objeto,
• ordenado de menor a mayor grado de dificultad .
• Cuádruplos.
• Triplos.
• Código P.
• Notación polaca.
• Las ventajas de los modelos que vamos a estudiar
  para generar el código
• intermedio es que su implementación podrá ser
  modular.
• Ejercicio.
• AB-CD

ltSgt
1
2
4
id

OP2
ltOP2gt
ltOP1gt
3
1
OP1
id

cte
-
36
TEMP2
D
TEMP
C
B
A
Oper Op1 Op2
- B C
TEMP D
A TEMP2

-

TEMP
TEMP2
TRIPLO
Pila de operandos
Pila de operandores
Acciones. 1 Insertar en pila_operandos. PUSH
pila_op(pos_act) id pos_act 1 2 Insertar en
pila de operadores. PUSH pila_oper(pos_act)
ó ó pos_act1 3 Mientras el tope de la
pila_operadores sea igual a un ó un entonces
generar triplo temporal. Op2 tope pila_op
? sacar Op1 tope pila_op ? sacar Oper
tope pila_oper ? sacar TEMP OP, OP1, OP2 ?
TEMP OP1, OPER, OP2 Insertar en pila de
operandos p_operandos(pos_act) TEMP
pos_act 1
37
4 Generar triplo Op2 tope pila_op ? sacar de
la pila Op1 tope pila_op ? sacar de la
pila Oper tope pila_oper ? sacar de la
pila Realizar el siguiente ejercicio tomando en
cuenta los diagramas de sintaxis y las acciones
del ejercicio anterior. XABCD
TEMP2
D
TEMP1
C
TEMP
B
A
X
A B
TEMP
TEMP C
TEMP1




TEMP1 D
TEMP2
X TEMP2
TRIPLO
Pila de operandos
Pila de operadores
38
Generación de cuádruplos para operaciones
aritméticas. Cuádruplos. Estructura de tipo
registro que tiene 4 campos que son llamados
operador, operando1, operando2, resultado. En
donde Operador código interno para la
operación. Operando1 y operando 2 valor o
variables que intervienen en la
operación. Resultado registro donde se guarda el
resultado. Nota Op1 y Op2 normalmente son
apuntadores a una tabla de símbolos y su valor
puede ser nulo. Ejemplo C1
Ejemplo (AB) (CD)
Oper Op1 Op2 Res
C 1
nulo
ltSgt
OPER1
39
R2
D
C
R1
B
A





Oper Op1 Op2 R
A B R1
C D R2
R1 R2 R3
Pila_op
Pila_oper
Acciones. 1 Insertar en la pila de
operandos. PUSH Pila_operandos (pos_act)
id pos_act1 2 Insertar en la pila de
operadores. PUSH Pila_operadores (pos_act) ó
ó ó / pos_act1 3 Insertar en pila de
operadores. PUSH Pila_operadores(pos_act)
marca fondo falso pos_act1 4 Mientras que el
tope de la pila sea ó ó ó / entonces
Generar cuádruplo Op2 tope Pila_operandos ?
sacar de la pila Op1 tope
Pila_operandos ? sacar de la pila Operador
tope Pila_operadores ? sacar de la
pila Resultado Resultado de operaciones Rn
1 Resul Op1 Oper Op2
40
e Insertar en la pila de operandos PUSH
Pila_operandos (pos_act) Rn 1 Pos_act
1 5 Sacar Pila_operadores la marca de fondo
falso. POP -Pila_operadores(pos_act)
M.F.F Ejemplo WA B
Cuádruplos
R1
B
A
W
A B R1


W R1
Pila operandos
Pila operadores
41
Acciones. 1 Insertar en la pila de
operandos. PUSH Pila_operandos (pos_act)
id pos_act 1 2 Insertar en pila de
operadores. PUSH Pila_operadores (pos_act) ó
ó pos_act 1 3 Mientras el tope de la pila
de operadores sea igual a ó Generar
cuádruplo. Op2 Tope Pila_operandos ?
sacar Op1 Tope Pila_operandos ? sacar Oper
Tope Pila_operadores ? sacar Res
Resultado Obt Rn 1 Res Op1 Oper Op2 Rn
1 e Insertar en la pila de operandos PUSH
pila_operandos (pos_act) Rn 1 pos_act
1 4 Generar cuádruplo (Asignación). Op2
nulo Op1 Tope pila_operandos ? sacar de la
pila Oper Tope pila_operadores ? sacar de la
pila Res Tope pila_operandos ? sacar de la
pila
42
Ejemplo W A / B C
3
ltOP1gt
OP2
2

-
C
B
A
W

/

/ A B R1
R1 C R2
R2 W
Pila de operandos
Pila de operadores
Acciones. 1 Insertar en la pila de
operandos PUSH pila_operandos (pos_act)
id pos_act 1
43
2 Inserta en la pila de operadores. PUSH
pila_operadores (pos_act) ó ó / ó ó
3 Mientras que el tope de la pila de operadores
se igual a ó ó / ó ó Generar
cuádruplo. Op2 Tope Pila_operandos ?
sacar Op1 Tope Pila_operandos ? sacar Oper
Tope Pila_operadores ? sacar Res
Resultado Obt Rn 1 Res Op1 Oper Op2
Inseratar en la pila de operandos PUSH
pila_operandos (pos_act) Rn 1 pos_act
1 4. Generar cuádruplo (Asignación) Op2
nulo Op1 Tope pila_operandos ?sacar de la
pila Oper Tope pila_operadores ? sacar de la
pila Res Tope pila_operandos ? sacar de la
pila
44
Generación de código para estatutos. Se requiere
una nueva pila una pila de saltos además nuevas
instrucciones para el código como son SF Salto
en falso. SV Salto verdadero. SI Salto
incondicional. Nota Normalmente al generar un
salto, aun no sabemos la dirección a la cual será
el salto entonces dejamos la dirección pendiente
por rellenar utilizando. Rellenar(dirección a
rellenar, valor con que se rellenará) Además
utilizaremos un contador el cual contendrá la
dirección del siguiente cuádruplo a
analizar. Estatuto IF THEN ELSE
ltEgt
ltOP1gt
3
ltOP2gt
1
OP1
id
OP1
2
2
lt

cte
gt
/
45
Acciones. 1 Insertar en la pila de
operandos. PUSH pila_operandos(pos_actual)
id pos_act 1 2 Insertar en pila de
operadores. PUSH pila_oper(pos_actual) ó ó
pos_act 1 3 Mientras el tope de la pila de
operadores sea igual a ó ó entonces
Generar cuádruplo Op2 tope pila_operandos
? sacar Op1 tope pila_operandos ?
sacar Oper tope pila_operadores ? sacar Res
result Rn 1 Insertar en la pila de
operandos PUSH pila_operandos (pos_act)
Rn pos_act 1 4 Generar cuádruplo de
asignación. Res Tope pila_operandos Op1
Tope pila_operandos Op2 Nulo Oper Tope
pila_operadores 5 Insertar en pila de operadores
(pos_act) Marca fondo falso 6 Generar
cuádruplo Op2 tope pila_operandos ?
sacar Op1 tope pila_operandos ? sacar Oper
tope pila_operadores ? sacar Res result
Rn 1 Insertar Rn en pila de operandos.
46
7 Salto en falso con lo que esta en el tope
pila_operandos y gurdar la dirección de
cuádruplos en pila_saltos. 8 Salto incondicional
(SI_ _) Rellenar (TOPE_saltos, cont 1) e
inseratr la dirección de SI en P.saltos. 9.
Rellenar (TOPE-saltos, cont 1) 10. Sacar
marca de fondo falso de pila_operadores. Ejemplo
If AgtB then ABC Else
ACD endif
Pila operandos
A B R1 A B C R2 A C D R2
Pila operadores
gt
Pila de saltos
2 5
oper op1 op2 Res
1 gt A B R1
2 SF R1 6
3 B C R2
4 A - R2
5 SI 8
6 C D R3
7 A - R3
47
Estatuto REPEAT
5
6
ltXgt
Repeat
S
Until
E
3
ltOP2gt
OP1

/
Acciones. 1, 2, 3, 4. Son igual a las anteriores
del if. 5. PUSH pila_saltos (la dirección
del siguiente cuádruplo a analizar)
cont 6 Generar cuádruplo y SF de la sig
forma Op2 Tope pila_operandos Op1 Tope
pila_operandos Oper Tope pila_operadores Rn
Rn 1 e insertar en pila_op
48
Generar un SF con lo que está en el tope
pila_operandos y rellenar la dirección de este
salto con tope pila_saltos y sacar. Ejemplo X1 Y
2 Z3 Repeat XY Z ZY
1 Until Z 10 Y0
10
Z
R2
1
Y
Z
R1
Z
Y
X
Pila de operandos
R3
Pila de operadores
gt
4
Pila de saltos
oper op1 op2 Rn
1 X - 1
2 Y - 2
3 Z - 3
4 Y Z R1
5 X - R1
6 Y 1 R2
7 Z - R2
8 gt Z 10 R3
9 SF R3 4
10 Y 0
49
Estatuto FOR.
ltFORgt
2
9
6
8
4
5
7
3
FOR
id

EXP
TO
do
S
endfor
EXP
Acciones. 1 Insertar en la pila de operandos el
siguiente id. 2 Insertar el id en
pila_operandos 3 Insertar el en la pila de
operadores. 4 Insertar EXP y generar cuádruplo(s)
de la sig forma Res Top_pila de operandos ?
sacar de la pila Op1 Top_pila de
operandos ? sacar de la pila Op2
Nulo Oper Top_pila de operadores ?
sacar de la pila 5 Insertar en la pila de saltos
(el siguiente cuádruplo a analizar ) . Cont
1 6 Insertar la EXP (id) p_oper y generar
cuádruplo de la siguiente forma Op2 tope
pila_operandos. (POP) Op1 tope pila_operandos.
(POP) Oper gt Res Rn 1 e insertar Rn 1
en la pila de operandos. 7 Hacer un salto
verdadero con tope pila_operandos i dejar la
dirección pendiente por rellenar, e insertar pila
de saltos su dirección. 8 Generar
cuádruplos. 9 Hacer un SI con TOP 1
(pila_saltos) y rellenar. Rellenar
(top_pila_saltos, cont 1)
50
Ejemplo For i 0 to 10 do AA1
ii1 endfor
oper op1 op2 Res
1 i 0
2 gt i 10 R1
3 SV R1 9
4 A 1 R2
5 R2 A
6 I 1 R3
7 R3 i
8 SI 2
9
Pila de operandos
i i 0 10 R1 A 1 A R2 i 1
Pila de operadores

gt ? SV lt ? SF
Pila de saltos
2 3
51
Estatuto CASE
ltCASEgt
1
2
3
case
EXP
of
OPC

EST
else
5
EST
4
endcase
6

• Acciones.
• 1 Insertar EXP en la pila de operandos.
• 2 Insertar OPC en la pila de operandos y hacer un
  cuadruplo de la siguiente forma
• Op2 Top_pila de operandos ? sacar de pila
• Op1 Top_pila operandos ? utilizar y no sacar
  de la pila
• Oper
• Res Rn 1 e insertar en pila_operandos.
• Hacer un SF con Top_pila_operandos y dejar
  dirección pendiente por rellenar e insertar la
  dirección del SF en la pila de saltos.
• 3 Generar cuádruplos de resultantes.
• Hacer un salto incondicional y dejar la
  dirección pendiente por rellenar e insertar la
  dirección del SI en la pila_saltos.
• Rellenar(top 1 pila_saltos, cont 1) y
  Rellenar (top 1 ,cont).
• 4 Generar cuádruplos.
• 6. Rellenar (top_pila_saltos, cont 1)
• 5 Sacar lo que está en la pila de operandos.

52
Ejemplo Case A of 1 read(B) 2
AAB Else write(A)
A
oper op1 op2 Res
1 A 1 R1
2 SF R1 5
3 Read X
4 SI 9
5 A 2 R2
6 SF R2 10
7 A B R3
8 A NULO R3
9 SI 11
10 Write A
R3
B
A
A
R2
2
X
R1
1
A
9
6
4
2
Write


read
Pila operadores
Pila saltos
Pila operandos
53
Estatuto WHILE
ltWHILEgt
8
6
7
5
while
E
do
S
enddo
3

• Acciones.
• 1, 2, 3, 4. Igual
• PUSH pila_saltos(el siguiente cuádruplo a
  analizar) cont 1
• Generar cuádruplo e insertar Rn en la pila.
• Generar un salto en falso con tope de pila de
  operandos dejar la dirección pendiente por
  rellenar e insertar la dirección en la pila de
  saltos.
• Generar un salto incondicional con lo que está en
  el (top-1 pila_saltos) y
• rellenar (pila_saltos, cont1)

54
Ejemplo While Xlt5 do XYZ Enddo x0
oper op1 op2 Res
1 lt X 5 R1
2 SF R1 6
3 Y Z R2
4 R2 X
5 SI 1
6 X 0
R2
Z
Y
X
R1
5
X


lt
2
1
Pila de saltos
Pila de operandos
Pila de operadores
55
Análisis Semántico
Para incluir los tipos de las variables en la
tabla de símbolos podemos efectuar las siguientes
acciones.
1
2
ltVgt
id

TIPO

Acciones. 1 PUSH pila_operandos (dirección de la
variable). 2 Poner el tipo a todas las variables
que se metieron en la pila de operandos y
sacarlas de la pila.
1,3 Real
1,2 Real
1,1 entero
1
2
3
4
Id1 1, 1 Id2 1, 2 Id3 1, 3
entero real real
1
Reglas semánticas. Utilizaremos como referencia
las reglas semánticas de las expresiones en
Pascal, para esto construiremos una tabla
donde E entero R real C caracter S
string B booleano x error semántico
56
Op1 Op2 , , - / div mod relac and or
E E E R E B X
E R R R X B X
R E R R X B X
R R R R X B X
C C X X X B X
C S X X X B X
S C X X X B X
S S X X X B X
B B X X X B B

• En esta tabla se omitieron un conjunto de
  combinaciones que con cualquier operación produce
  error, como por ejemplo ENTERO con STRING.
• Ya que un traductor es un autómata (con
  funcionamiento automático), es conveniente que el
  análisis semántico también se automatice. Las
  claves para automatizar el análisis semántico
  son
• Utilizar acciones para verificación semántica.
• Escoger una estructura de datos que permita
  accesarla directamente, encontrar el resultado de
  una operación y descubrir si ésta es o no válida.
• De hecho estas claves están vigentes para todo el
  proceso de traducción, en cuanto
• a utilizar acciones y estructuras de datos
  automáticas.
• Para el análisis semántico no se recomienda usar
  la tabla mostrada anteriormente,
• debido a que su acceso no es automático y le
  faltan muchas combinaciones.

57
Acciones para verificación semántica. Para
mostrar un ejemplo de cómo diseñar las acciones
de verificación semántica, utilizaremos un
subconjunto de expresiones aritméticas. Estas
acciones se deberán de añadir a las acciones de
generación de código, y no modificar nada de lo
ya visto en generación de código. Para realizar
la verificación semántica se requerirá de una
pila de tipos.

• Acciones.
• PUSH pila_tipos (tipo de la variable).
• 2,3. No llevan acción semántica.

58

• Si tipos del TOP y TOP 1 de la pila de tipos
  son permitidos en la operación a generar
  ENTONCES
• POP pila_tipos POP pila_tipos
• PUSH pila_tipos (resultado de la operación)
• SI NO
• Marcar error semántico, y aplicar acción
  correctiva que podría ser
• POP pila_tipos POP pila_tipos
• PUSH pila_tipos (posible resultado de la
  operación)
• Igual a 4
• No llevan acción semántica.