Programación de sistemas 2

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. • Unidad 4. Administración de la memoria principal. • 4.1 Paginación. • 4.2 Segmentación. • 4.3 Paginación-Segmentación.

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 <= y (en cuanto al número de elementos de y) • y > 0 (no permite producciones con el elemento vacio) • 3. Libre de contexto. • x  y • x = 1 y es un elemento no terminal. • y >= 0 • Tipos de gramática libre de contexto. • Lineal izquierdo. • Lineal derecho • Recursiva izquierdo • Recursiva derecho • Recursiva central

3. <S> <S> a a <S> <S> b c <S> x <Y> <S> <Z> y x <Y> z <W> w y <Z> z <W> w 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. <S>  <Y> x <Y>  <Z> y <Z>  <W> z <Z>  <W>  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. <S>  x <Y> <Y>  y <Z> <Z>  z <W> <Z>  <W>  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. <S>  <S> a | <S> d <S>  <S> b <S>  c <S>  <S> cbaa

4. <X> <S> a <S> a <S> <S> b c <X> <S> a b <S> c d <S> e 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. <X>  <S> <S>  a <S> | d <S> <S>  b <S> <X>  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. <X>  <S> <S>  a <S> b <S>  c <S> d <S>  e acedb Ejemplos: Libre de contexto. <S>  if <X> then <Y> x  y <X>  a <op> b | x | = 1 <op>  > | < | Y | >= 0 <Y>  x <opA> y Puede tener vacio <opA>  =

5. Contexto sensitivo. <S>  <X> <Y> x ≤ y <X>  a <Z> y ≠ ε no permite vacio a<Z>  b <W> <Y>  d <W>  c Irrestricta. <X>  <A> <B> Sin restricciones. <A>  a <B>  b Derivación. Consiste en sustituir los elementos no terminales por sus producciones. Ejemplo: <S>  IF <X> then <Y> Se sustituye de izquierda a derecha <S>  IF a <OP> b then <Y> <S>  IF a<b then <Y> <S>  IF a<b then x <OPA> y <S>  IF a<b then x=y El resultado es solo con terminales Componentes de la gramática. G={P, S, V, V’} o bien G={P, S, T, N} En donde: P=producciones. S=producción inicial V=los elementos terminales V’=los elementos no terminales

6. <S> a X b De el ejemplo anterior........ P={S, X, Y, op, opA} S={S} V={a, if, b, then, x, y, =, >, >} V’={S, 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. <S>  a <X> b

7. <X> a <PROGRAM> PARAM fun id ; TIPO proc id PARAM b) Alternativa de símbolos. <TIPOS>  real | char | int c) Repetición de símbolos. <X>  a <X> <X>  a Ejemplos: <TIPOS> real char int

8. <PROGRAM>  fun id <X> ; <TIPO> <X>  <PARAM> |  <PROGRAM>  prac id <X> var <PARAM> ( id : TIPO ) X ; Y <PARAM>  ( <X> <Y> : <TIPO> ) <X>  var |  <Y>  id <Z> <Z>  ; id <Z> <Z>  <TIPO>  char | int | real Validar la siguientes cadenas: (var id;id:real) <PARAM>  (<X> <Y> : <TIPO>) <PARAM>  (var <Y> : <TIPO>) <PARAM>  (var id <Z> : <TIPO>) <PARAM>  (var id ; id <Z> : <TIPO>) <PARAM>  (var id ; id : <TIPO>) <PARAM>  (var id ; id : real)

9. fun id (id : char); real <PROGRAM>  fun id <X> ; <TIPO> <PROGRAM>  fun id <PARAM> ; <TIPO> <PROGRAM>  fun id (<X> <Y> : <TIPO>) ; <TIPO> <PROGRAM>  fun id (<Y> : <TIPO>) ; <TIPO> <PROGRAM>  fun id ( id <Z> : <TIPO>) ; <TIPO> <PROGRAM>  fun id ( id : <TIPO>) ; <TIPO> <PROGRAM>  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 Programa Sintáctico Salida de producciones <X> --> <Y>+<Z> <Z> --> b <Y> --> 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→<y>+<z>} el analizador sintáctico sustituye la x de la cima de la pila por <z>+<y> quedando en la parte de encima de la “<y>” 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) <E> <T> <E’> • 2) <E’>  + <T> <E’> • 3) <E’>   • 4) <T> <F> <T’> • 5) <T’>  * <F> <T’> • 6) <T’>  • 7) <F>  id • 8) <F>  (<E>) • Validar la siguiente cadena: • Id + id • A continuación se dará una corrida a la gramática para saber si la cadena es 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 α es una cadena de símbolos gramaticales se considera primeros de α como el conjunto de terminales que inician las cadenas derivadas de α.  Si α → ε entonces el vacío también está en primeros de α.  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 → αAaβ para algún α y β. Primeros.  Primero (α) es el conjunto de símbolos terminales que inician cualquier derivación de α. Cálculo: a)Si X es un símbolo terminal, entonces primeros (α) = 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 i=1 hasta n-1 Si ε está incluido en primeros de (βi) incluir en primeros de (βi+1). 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: <S> <E> a <E>  op <E>  P<S> = {P<E>} = {op, } P<E> = {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) <E> <T> <E’> 2) <E’>  + <T> <E’> 3) <E’>  4) <T> <F> <T’> 5) <T’>  * <F> <T’> 6) <T’>  7) <F>  id 8) <F>  (<E>)

16. Primeros. • P(<E>) = {P(<T>)} = {id, ( } • P(<E’>) = {+, } • P(<T>) = {P(<F>)} = {id, ( } • P(<T’>) = { *, } • P(<F>) = {id, ( } • Siguientes. • S(< E>) = { $, )} • S(<E’>) = {S(<E>), S(<E’>) } = { $, ) } • S(<T>) = {P(<E’>)} = { +, S(<E’>)} = { +, $, ) } • S(<T’>) = {S(<T>), S(<T’>)} = { +, $, ) } • S(<F>) = {P(<T’>)} = { *, S(<T’>) } = { *, +, $, ) } • 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 M[A, ] • b) Si  esta contenido en primero (), entonces para cada símbolo terminal • en sig (A), agregar M en [A,$] • 2. Cada espacio de la matriz indefinido hace error. • A continuación se muestra un ejemplo de cómo construir la matriz predictiva, se utilizó • la gramática anterior para obtener los first y los follows.

18. Ejercicio: Realizar primeros, siguientes, matriz predictiva y validar las siguientes cadenas: bmdm, fd, fdm 1) <A>  <B> d <A> 2) <A>  m 3) <B>  <C> <D> 4) <C>  b <A> 5) <C>  6) <D>  f checar gramatica 7) <D>  g Primeros. P(<A>) = {P(<B>), m, } = {b, m, } P(<B>) = {P(<C>)} = {b, } P(<C>) = {b, } P(<D>) = {f, g} Siguientes. S(<A>) = {S(<A>), S(<C>)} = {f, g, $} S(<B>) = {d} S(<C>) = {P(<D>)} = {f, g} S(<D>) = {S(<B>)} = {d}

19. bmdm fd

20. fdm 1) <S>  if <COND> then <OPERACION> else <ASIG> end 2) <COND>  id <OR> id 3) <OR>  > 4) <OR>  < 5) <OPERACION>  id <OA> id 6) <OA>  + 7) <OA>  - 8) <OA>  * 9) <ASIG>  id <A> id 10) <A>  := Para la gramática anterior validar la siguiente cadena: if id < id

21. Primeros. P(<S>) = { if } P(<COND>) = { id } P(<OR>) = { >, < } P(<OPERACION>) = { id } P(<OA>) = { +, -, * } P(<ASIG>) = { id } P(<A>) = { := } Siguientes. S(<S>) = { $ } S(<COND>) = { then } S(<OR>) = { id } S(<OPERACION>) = { else } S(<OA>) = { id } S(<ASIG>) = { end } S(<A>) = { id }

22. 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. 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

26. <E> 1 <E’> .<E> <E>  .<E> + <T> <E>  .<T> <T>  .<T> * <F> <T>  .<F> <F>  .id <F>  .(<E>) <E> 0 1 <T> 2 <T> 2 <F> 3 id S4 ( S5 Ejemplo Método LR. 0) <E’> . <E> 1) <E> .<E>+<T> 2) <E> .<T> 3) <T> .<T>* <F> 4) <T> .<F> 5) <F> .id 6) <F> .(<E>) Primeros. P(<E’>) = {P(<E>) } = { id, ( } P(<E>) = {P(<E>), P(<T>)} = { id, ( } P(<T>) = {P(<T>), P(<F>)} = { id, ( } P(<F>) = { id, ( } Siguientes. S(<E’>) = { $ } S(<E>) = {S(<E’>), +, ) } = { $,+, ) } S(<T>) = {S(<E>), *} = { $,+, ), * } S(<F>) = { $,+, ), * }

27. $ <E’>  <E>. <E>  <E>. + <T> ACC Sig E’ + S6 <E> 8 <E> 8 5 2 3 4 1 <T> 2 <T> 2 <F> 3 id S4 ( S5 +, $, ) <E>  <T>. <T>  <T>. * <F> R2 Sig E * S7 $, +, ), * <T>  <F>. R4 <F>  id. $, +, ), * R5 Sig F <F>  (.<E>) <E>  .<E> + <T> <E>  .<T> <T>  .<T> * <F> <T>  .<F> <F>  .id <F>  .(<E>)

28. 9 11 8 T 6 <E>  <E> + .<T> <T> .<T> * <F> <T> .<F> <F> .id <F> .(<E>) 9 T 9 F 3 id S4 ( S5 F <T>  <T> * .<F> <F> .id <F> .(<E>) 10 7 id S4 ( S5 ) <F>  (<E>.) <E> <E> .+ <T> S11 + S6 $, +, ) <E> <E> + <T>. <T> <T> .* <F> R1 Sig. E * S7 $, +, ), * <T>  <T> * <F>. R3 10 Sig. T $, +, ), * <F>  (<E>). R6 Sig. F

29. TABLA DE ACCIONES TERMINALES TABLA DE SALTOS NO TERMINALES

30. Verificar si la siguiente cadena es válida: id + id$ • Eliminación de la recursividad por la izquierda. • A  Aα | 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 ε. • A’ α A’ 1) A  BA’ • A’ ε 2) A’ αA’ • 3) A’ ε

31. Ejemplos: Gramatica original. S  Aa | b A  Ac | Sd | ε Eliminación de la recursividad. S  Aa | b A  bd A’ A ε A’  cA’ A’  adA’ A’ ε Eliminación de la recursividad. 1) E  T E’ 2) E’  + T E’ 3) E’ ε 4) T  F T’ 5) T’ * F T’ 6) T’ ε 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. A:=B+C*D ABCD*+:= • Triplos. A:=B+C*D • Cuádruplos. A:=B+C*D • Código P. A:=B+C*D Cargar B • Cargar C • Cargar D • Multiplicar , Suma • almacena A

33. <OP1> id cte Triplos. Este tipo de código utiliza instrucciones en un formato de 3 campos. En donde: Oper = Código de operación. Op1 = Operando 1 Op2 = Operando 2 Ejemplo: A + B 1 <S> 3 OP1 2 + - TRIPLO Pila de operandos Pila de operadores

34. Acciones. • 1 Insertar en la pila de operandos. • PUSH_pilaop(pos_act) = id ó cte • pos_act+1 • 2 Insertar en la pila de operadores. • PUSH_pilaoper(pos_act) = + ó – • pos_act+1 • 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. • En cuanto a la velocidad de su ejecución de menor a mayor. • Cuádruplos. • Triplos y código P. • Notación polaca.

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. • A:=B-C+D <S> 1 2 4 id := OP2 <OP2> <OP1> 3 1 OP1 id + cte -

36. TEMP= TEMP2 = TRIPLO = Pila de operandores Pila de operandos 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_act+1 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. X:=A+B+C*D TEMP TEMP1 TEMP2 TRIPLO Pila de operadores Pila de operandos

38. 4 4 <OPER2> <OPER1> OPER2 EST 2 2 * + 1 <EST> - / id 5 ( OPER1 ) 3 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: C:=1 Ejemplo: (A*B) + (C*D) nulo <S> OPER1

39. Pila_op Pila_oper Acciones. 1 Insertar en la pila de operandos. PUSH Pila_operandos (pos_act) = id pos_act+1 2 Insertar en la pila de operadores. PUSH Pila_operadores (pos_act) = + ó – ó * ó / pos_act+1 3 Insertar en pila de operadores. PUSH Pila_operadores(pos_act) = marca fondo falso pos_act+1 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. 3 <S> <OP1> 1 2 4 OP2 id := OP1 2 + <OP2> 1 - id Cte_num 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: W:=A + B Cuádruplos 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. 3 <OP2> EST <S> 1 / 2 4 id := OP1 * <EST> 1 id Constante Ejemplo: W:= A / B +C 3 <OP1> OP2 2 + - 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. <S> 1 2 4 id := OP2 5 6 7 <X> 8 9 10 if then else endif E S S 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 <E> <OP1> 3 <OP2> 1 OP1 id OP1 2 2 < * cte > /

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 A>B then A:=B*C Else A:=C*D endif Pila operandos Pila operadores Pila de saltos

47. <S> 1 2 4 id := OP2 <E> OP1 2 >= <= > < <OP1> 1 id cte Estatuto REPEAT 5 6 <X> Repeat S Until E 3 <OP2> 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. X 1 Y 2 Z 3 := = = := + 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: X=1 Y=2 Z=3 Repeat X:=Y + Z Z:=Y + 1 Until Z ≥ 10 Y=0 Pila de operandos X Y Z R1 Z Y 1 R2 Z 10 R3 Pila de operadores 4 Pila de saltos

49. 1 Estatuto FOR. <FOR> 2 3 4 5 6 7 8 9 FOR id := EXP TO EXP do S endfor 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 = > 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 A:=A+1 i:=i+1 endfor Pila de operandos Pila de operadores >  SV <  SF Pila de saltos