all documentation

CSC (C# Compiler)

Ejercicio de Implementación

CompiladoresEntrega Final

Curso 2003 - 2004

Septiembre del 2004

Grupo 98Santiago González Tortosa [email protected]án Ramos García [email protected] Fernández Recio [email protected]

Grupo 98 C# Compiler

ÍNDICE

1 INTRODUCCIÓN...............................................................................................................................4

2 ANALIZADOR LÉXICO..................................................................................................................6

2.1 GRAMÁTICA DEL ANALIZADOR LÉXICO.....................................................................................6

2.2 DISEÑO DEL ANALIZADOR LÉXICO.............................................................................................8

2.2.1 Autómata................................................................................................................................8

2.2.2 Flex......................................................................................................................................10

3 TABLA DE SÍMBOLOS.................................................................................................................13

3.1 DISEÑO......................................................................................................................................13

3.2 IMPLEMENTACIÓN.....................................................................................................................14

3.3 EJEMPLO....................................................................................................................................16

4 ANALIZADOR SINTÁCTICO......................................................................................................18

4.1 GRAMÁTICA..............................................................................................................................19

4.2 IMPLEMENTACIÓN.....................................................................................................................22

5 ANALIZADOR SEMÁNTICO.......................................................................................................23

5.1 COMPROBACIÓN DE TIPOS........................................................................................................23

5.2 OTRAS REGLAS SEMÁNTICAS...................................................................................................26

6 GENERADOR DE CÓDIGO INTERMEDIO..............................................................................28

6.1 EL MODULO “TERCETOS”..........................................................................................................28

6.2 EL MÓDULO “INTERMEDIO”......................................................................................................33

7 GENERADOR DE CÓDIGO FINAL............................................................................................38

8 GENERADOR DE ERRORES.......................................................................................................46

9 PROGRAMA PRINCIPAL.............................................................................................................49

10 PRUEBAS.........................................................................................................................................50

10.1 PRUEBA 1..................................................................................................................................50

10.2 PRUEBA 2..................................................................................................................................61

10.3 PRUEBA 3..................................................................................................................................66

10.4 PRUEBA 4..................................................................................................................................73

10.5 PRUEBA 5..................................................................................................................................82

10.6 PRUEBA 6..................................................................................................................................91

10.7 PRUEBA 7................................................................................................................................104

10.8 PRUEBA 8................................................................................................................................119

Compiladores 2


10.9 PRUEBA 9................................................................................................................................141

10.10 PRUEBA 10..............................................................................................................................150

10.11 PRUEBA 11..............................................................................................................................154

10.12 PRUEBA 12..............................................................................................................................162

10.13 PRUEBA 13..............................................................................................................................171

10.14 PRUEBA 14..............................................................................................................................183

10.15 PRUEBA 15..............................................................................................................................186

10.16 PRUEBA 16..............................................................................................................................254

10.17 PRUEBA 17..............................................................................................................................261

10.18 PRUEBA 18..............................................................................................................................267

10.19 PRUEBA 19..............................................................................................................................268

10.20 PRUEBA 20..............................................................................................................................269

10.21 PRUEBA 21..............................................................................................................................270

10.22 PRUEBA 22..............................................................................................................................270

10.23 PRUEBA 23..............................................................................................................................271

10.24 PRUEBA 24..............................................................................................................................272

10.25 PRUEBA 25..............................................................................................................................273

11 ANEXO...........................................................................................................................................275

12 Bibliografía......................................................................................................................................276

Compiladores 3


1 Introducción

Una compilación es una simple traducción que convierte un programa escrito en un lenguaje, llamado fuente, a un programa equivalente en otro lenguaje, llamado objeto. Las técnicas para compilar son independientes del lenguaje fuente y objeto, es decir, siempre es la misma.

El compilador se divide en las siguientes fases:

Analizador Léxico (AL): Lee todos los caracteres del fichero fuente y crea los tokens oportunos, para pasárselos al analizador sintáctico.

Analizador Sintáctico (AS): Verifica la sintaxis del programa fuente utilizando los tokens. Crea un árbol sintáctico y se lo pasa al analizador semántico.

Analizador Semántico (ASE): Revisa la semántica del programa, a partir de un árbol sintáctico. Crea un árbol sintáctico anotado y se lo pasa al generador de código intermedio.

Generador de código intermedio (GCI): Crea código intermedio, a partir del árbol sintáctico anotado, utilizando el lenguaje intermedio (ensamblador en este caso).

Optimizador del código (OC): Toma el código intermedio y lo optimiza. Pasa al generador de código final dicho código intermedio optimizado.

Generador de código final (GCF): A partir del código intermedio optimizado, crea el código objeto final y lo inserta en el fichero objeto.

Junto con estas fases, debemos incluir el tratamiento de errores (gestor de errores) y la tabla de símbolos.

Gestor de errores (GE): Captura y envía por pantalla todos los errores detectados en cada una de las fases anteriores.

Tabla de símbolos (TS): Almacena todas las palabras reservadas e identificadores (variables, funciones, etc.), sus atributos. También da información a cualquiera de las fases que lo pida.

Resumiendo, un esquema de compilador puede ser el siguiente:

Compiladores 4


En nuestro caso tendremos todos estos pasos exceptuando el Optimizador de Código, es decir, pasamos de código intermedio (GCI) a código objeto final (GCF). A continuación veremos cada uno de ellos.

Debemos resaltar que, después de dos anteriores entregas en el curso, en los que hemos estado utilizando distintas alternativas de programación, hemos decidido utilizar para esta última entrega, el programa FLEX para el analizador léxico y ninguna herramienta para el analizador sintáctico y semántico.

Por otro lado, inicialmente pensamos en realizar el compilador diseñándolo orientado a objetos. Sin embargo, debido a problemas con FLEX y C++, hemos optado por realizar todo el compilador utilizando un diseño estructurado.

Compiladores 5


2 Analizador Léxico

En primer lugar, y antes de explicar el diseño de un analizador léxico, comentar una serie de conceptos:

Un token es cada uno de los elementos de un lenguaje con significado propio. Son símbolos terminales del analizador sintáctico.

Un patrón es una regla que describe un conjunto de cadenas de entrada para los cuales se produce como salida el mismo token.

Un lexema es una secuencia de caracteres que concuerda con el patrón de un token.

Una vez claros estos conceptos, podemos definir un analizador léxico como el analizador que pasa de un fichero lleno de caracteres a un conjunto de tokens que ira pasando al analizador sintáctico (uno a uno). Las funciones del analizador léxico, pues, son:

Manejar el fichero fuente. Leer símbolo a símbolo, de principio a fin, sin retroceder, el fichero fuente. Localizar palabras del lenguaje y construir el token. Eliminar caracteres que no aportan ninguna información (comentarios, etc.) Rellenar información en la tabla de símbolos

Utilizando, pues, una Gramática Regular (de tipo 3), y transformándola en un autómata finito determinista, podemos detectar palabras del lenguaje del fichero fuente.

2.1 Gramática del Analizador Léxico

El analizador léxico se apoya para poder hacer la concordancia de lexemas con tokens en una gramática tipo 3. Esta gramática es la siguiente, siendo S el axioma inicial:

S +A | -B | *C | /D | %E | &F | ( | ) | { | } | [ | ] | “G | ; | , | aH | . | delS | !L | >M | <N | =O | dQ | 0R | |U | Console.V

A = | B = | C = | D = | *J | /I | E = | F &G ocG | “H lP | dP | @P | I oc1I | nlS J oc2J | *KK oc3J | *K | /S L = |

Compiladores 6


M = | N = | O = | P aH | dH | Q dQ | R xT | XT | dQ | T dxT | U | V wW | rXW riteX ead

Los símbolos auxiliares utilizados son los siguientes:

Regla S: a y delo a: letras, @ o _ (primer carácter de un identificador).o del: delimitadores (espacios, tabuladores...).

Regla G: oco oc: otro carácter salvo el de fin de fichero,nueva línea y comillas (“) (los string

ocupan una sóla línea).Regla H: l,d

o l: letras mayúsculas y minúsculas.o d: dígitos.

Regla I: oc1,nlo oc1: otro carácter salvo nueva línea (comentarios // de una sóla línea).o nl: carácter de nueva línea.

Regla J: oc2o oc2: Otro carácter salvo el * y fin de fichero.

Regla K: oc3o oc3: Otro carácter salvo * , / y fin de fichero

Regla P: ao a: Mismo valor de la regla S.

Regla R: el símbolo X es no terminal ya que podemos encontrarnos con 0x o 0X.Regla T: dx

o dx: Dígitos hexadecimales.

Se puede observar que es una gramática ambigua y sabemos que los analizadores léxicos no pueden trabajar con gramáticas de estas características. Al construir el autómata finito y el analizador léxico se utilizarán diversas técnicas para evitar cualquier tipo de ambigüedad en el reconocimiento de los tokens.

Compiladores 7


2.2 Diseño del Analizador Léxico

2.2.1 Autómata

El autómata finito determinista creado a partir de la grámatica comentada anteriormente es el siguiente:

Las abreviaturas utilizadas en el autómata son las siguientes:

FL = Fin de lineadel = Delimitador: Espacio, Tabulador, FLoc = otro carácterd = dígitoL = letradH = dígito hexadecimal

Acciones semánticas

Utilización de acciones estándar:

En todas las transiciones se lee el siguiente carácter salvo en las que no necesitamos conocer dicho carácter ya que podemos identificar el token sin ninguna duda (ejemplo los símbolos , . ; etc...). En las transiciones no previstas generamos un error.

Compiladores 8


Concatenamos en aquellas transiciones en las que es necesario conocer el lexema del símbolo leído para poder generar su token. El haber ahorrado estados finales para facilitar la claridad del dibujo nos obliga a concatenar para poder identificar qué operador hemos leído y por tanto el token a generar, los identificadores y palabras reservadas es necesario siempre concatenar y en el caso de los números también.

Utilización de acciones predefinidas:

Transición Acción Semántica Acciones0-1 L Si n = ‘(‘ GENERAR_TOKEN (PAA,_)

Si n = ‘)’ GENERAR_TOKEN (PAC,_)Si n = ‘{‘ GENERAR_TOKEN (LLA,_)Si n = ‘}’ GENERAR_TOKEN (LLC,_)Si n = ‘[‘ GENERAR_TOKEN (CA,_)Si n = ‘]’ GENERAR_TOKEN (CC,_)Si n = ‘;’ GENERAR_TOKEN (DPC,_)Si n = ‘,’ GENERAR_TOKEN (DC,_)Si n = ‘.’ GENERAR_TOKEN (OP,_)

2-3 A Si n = ‘+’ GENERAR_TOKEN (OA,1)Si n = ‘-‘ GENERAR_TOKEN (OA,2)Si n = ‘*’ GENERAR_TOKEN (OA,3)Si n = ‘%’ GENERAR_TOKEN (OA,5)

2-4 B Si n = ‘+=’ GENERAR_TOKEN (AO,1)Si n = ‘-=’ GENERAR_TOKEN (AO,2)Si n = ‘*=’ GENERAR_TOKEN (AO,3)Si n = ‘%=’ GENERAR_TOKEN (AO,5)

5-4 -- GENERAR_TOKEN (AO,4)5-6 -- GENERAR_TOKEN (OA,4)

10-11 -- GENERAR_TOKEN (OL,1)12-13 -- GENERAR_TOKEN (OL,2)14-15 -- GENERAR_TOKEN (ST,n)16-17 C Si n = ‘!’ GENERAR_TOKEN (OL,3)

Si n = ‘>’ GENERAR_TOKEN (OL,4)Si n = ‘<’ GENERAR_TOKEN (OL,5)Si n = ‘=’ GENERAR_TOKEN (OAS,_)

16-18 D Si n = ‘!=’ GENERAR_TOKEN (OL,9)Si n = ‘>=’ GENERAR_TOKEN (OL,8)Si n = ‘<=’ GENERAR_TOKEN (OL,7)Si n = ‘==’ GENERAR_TOKEN (OL,6)

24-2625-26

E Si n = Palabra_ReservadaGENERAR_TOKEN (PR,n)

En otro caso:p := BUSCA (n)Si p = NULL

p := AÑADE (n)GENERAR_TOKEN (ID,p)

19-20 -- GENERAR_TOKEN (CE,n)22-23 -- GENERAR_TOKEN (CE,n)

Compiladores 9


2.2.2 Flex

La implementación de la gramática la realizamos utilizando el programa FLEX (Free LEX). Utilizando varios manuales de Flex, aprendimos a implementar las gramáticas capaces de localizar palabras del lenguaje y construir los tokens de un fichero fuente.

Primeramente, debemos comentar el formato general de un fichero de (F)Lex:

{definiciones}%%{ordenes}%%{subrutinas del usuario}

En cada apartado se realiza la siguiente implementación:

Definiciones: se definen los patrones a utilizar en la gramática. Ordenes: Se define la secuencia de órdenes a ejecurtarse si se encuentra un

lexema que concuerda con uno de los patrones definidos anteriormente. Subrutinas del usuario: funciones y métodos implementados por el usuario, que

realizan una serie de operaciones al lexema. Un ejemplo claro de función es la generación del token.

Utilizando la documentación de Flex, la gramática anterior e implementando las acciones semánticas como funciones, obtenemos el analizador léxico. La implementación se realizó en el fichero lexer2.l, archivo donde se sitúa toda la gramática del analizador.

Para facilitar la labor en el analizador semántico, incluimos como palabras reservadas los comandos Console.Read y Console.Write, aunque no lo incluimos como tal en el diseño del analizador léxico.

Por otro lado, incluimos los tokens “?” y “:” en la implementación del analizador léxico, por si daba tiempo a realizar el Operador Condicional en el compilador. Como no dio tiempo, no lo incluimos en el diseño del analizador léxico.

En definitiva, los tokens implementados con FLEX han sido:

Lista de Tokens

<PR, ptr(tabla)> Palabra Reservada (0)<PR, ptr(tabla)> Palabra Reservada (0)<OA, ptr(tabla)> Operador Aritmético (1)

<OAS, -> Operador de Asignación (“=”) (2)<PAA, -> Paréntesis Abierto (“(“) (3)<PAC, -> Paréntesis Cerrado (“)”) (4)<LLA, -> Llave Abierta (“{“) (5)

Compiladores 10


<LLC, -> Llave Cerrada (“}”) (6)<OL, ptr(tabla)> Operador Lógico (7)

<CE, valor> Constante Entera (8)<AO, ptr(tabla)> Asignación de Operación (9)

<CA, -> Corchete Abierto (“[“) (10)<CC, -> Corchete Cerrado (“]”) (11)<OP, -)> Operador Punto (12)

<OC, ptr(tabla)> Operador Carácter (13)<ST, ptr(tabla)> ID de cadena de caracteres (“…”) (14)<ID, ptr(tabla)> ID (variable o función) (15)

<DPC, -> Delimitador de Punto y Coma (“;”) (16)<DC, -> Delimitador de Coma (“,”) (17)<IC, -> Inicio Condicion (“?”) (18)<FC, -> Inicio Condicion (“:”) (19)

<EOF, -> Fin de Fichero (20)<CCR, -> Comando Console.Read (21)<CCW, -> Comando Console.Write (22)

Tabla de Operadores Aritméticos

Puntero Elemento1 +2 -3 *4 /5 %

Tabla de Operadores Lógicos

Puntero Elemento1 &&2 ||3 !4 >5 <6 ==7 <=8 >=9 !=

Tabla de Operadores de Asignación de Operación

Puntero Elemento1 +=2 -=3 *=4 /=5 %=

Compiladores 11


6 ++7 --

Tabla de Palabras Reservadas

Puntero Elemento1 IF2 ELSE3 RETURN4 TRUE5 FALSE6 VOID7 STRING8 SHORT9 BOOL10 CLASS11 REF12 NEW13 PUBLIC14 PRIVATE15 STATIC16 SET17 GET18 VALUE19 PARAMS

Compiladores 12


3 Tabla de Símbolos

3.1 Diseño

El Diseño de la tabla de símbolos se ha realizado utilizando una metodología estructurada. Para ello, primero definimos la estructura de la tabla de símbolos:

Una tabla de símbolos es un conjunto de elementos ordenados de una forma concreta, en nuestro caso, utilizando listas doblemente enlazadas. Dichos elementos pueden ser:

CLAVE: Palabra reservada (0) SHORT: Tipo entero (1) STRING: Tipo cadena de caracteres (2) BOOL: Tipo booleano (3) VOID: Tipo desconocido (4) CLASE: Tipo clase (o bien instanciación de una clase ya creada) (5) FUNCION: Tipo método (6) LISTA SHORT: Lista de enteros (7) LISTA STRING: Lista de cadena de caracteres (8) LISTA BOOL: Lista de boléanos (9) LISTA VOID : Lista de tipos desconocidos (10) OTRO: Otro tipo (Console.Write, por ejemplo) (11)

Para cada tipo de elemento, se necesitaran, pues, ciertos campos:

pu_pr: Entero que indica si el elemento es publico (1) o privado (0) estatico: Estará a 1 si el elemento es “static” nombre: Nombre del elemento tipo: Entero que indica que tipo de elemento es. tipo_clase: Indica el nombre de la clase al que esta instanciando el elemento num_eltos: Numero de elementos de un elemento lista. valor: Estará a 1 si el elemento tiene valor (esta inicializado) o no. eti: Indica el número de etiqueta asignada al método o clase por el generador de

código intermedio. tipo_valor_devuelto: Indica el tipo del valor devuelto, en caso de que el

elemento sea un método. numero_parametros: Indica el numero de parámetros de un metodo. Parámetros: Lista enlazada de los parametros Subtabla: Direccion donde se situa la subtabla, en caso en que el elemento sea

una clase o un metodo.

La estructura de los parámetros consiste en una lista enlazada de parámetros, los cuales contienen campos: tipo del parámetro y el paso del parámetro, es decir, por valor (1) o por referencia (2).

Compiladores 13


3.2 Implementación

El modulo implementado es tsimbolos, el cual permite la siguiente interfaz de usuario:

TS *Crear_Tabla(TS* padre);Crea una tabla de símbolos, cuyo padre asociado es el argumento de la función.

void Borrar_Tabla(TS *tabla); Borra la tabla de símbolos indicado en el argumento

int Esta_Lexema(TS *tabla,char* nombre); Devuelve 0 si el elemento con el nombre del argumento se encuentra en la tabla del argumento de la funcion. En caso contrario, devuelve -1.

int Insertar_Lexema(TS *tabla,char *nombre, int tipo); Inserta un elemento con el nombre y el tipo indicadas, en la tabla de símbolos indicada en el argumento de la funcion1.

int Insertar_Categoria_Lexema(TS *tabla,char *nombre, int publico, int privado, int estatico);

Inserta las categorías de un elemento determinado en una tabla determinada. Dichas categorías son: publico, privado y estatico. Por defecto siempre es privado.

int Borrar_Lexema(TS *tabla,char *nombre); Borramos un elemento de una tabla de símbolos.

int Dibujar_Tabla(TS *tabla,char *fichero); Imprime por fichero la tabla de símbolos indicada como argumento.

int Insertar_Valor_Lexema(TS *tabla,char *nombre); Activa el campo valor (a 1) del elemento perteneciente a una tabla.

int Insertar_Eti(TS *tabla,char *nombre);Inserta el numero de etiqueta del método o clase.

int Insertar_Tipo_Valor_Devuelto(TS *tabla,char *nombre, int tipo);

Inserta el tipo del valor devuelto del elemento de una tabla de símbolos. Por tanto, dicho lexema debe ser un metodo.

int Insertar_Parametro(TS *tabla,char *nombre, int tipo_par, int paso_par, char *clase);

Inserta un parámetro en la lista de parámetros de un elemento de una tabla de símbolos determinada.

TS *Crear_Subtabla(TS *tabla,char *nombre); Crea una subtabla a partir de un elemento de una tabla de símbolos determinada. Nos devuelve su puntero.

int Dar_Tipo(TS *tabla,char* nombre); Nos devuelve el tipo de un elemento de una tabla de símbolos determinada.

int Cambiar_Tipo(TS *tabla,char *nombre, int tipo);

1 En la mayoría de las funciones de este tipo, devolverán 0 si todo ha salido bien y -1 en caso contrario.

Compiladores 14


Nos permite cambiar el tipo de un elemento de la tabla de símbolos.

int Dar_Valor(TS *tabla,char* nombre); Nos indica si el elemento de la tabla de símbolos esta inicializado con valor o no.

int Dar_Tipo_Valor_Devuelto(TS *tabla,char *nombre); Nos devuelve el tipo del valor devuelto del elemento de una tabla de símbolos determinada. Por tanto, dicho elemento debe ser un metodo.

int Tipo_Clase(TS *tabla,char *nombre, char *clase); Insertamos cual es la clase a la cual el elemento se instancia, dentro de una tabla de símbolos determinada.

char *Dar_Tipo_Clase(TS *tabla,char *nombre);Devuelve la clase a la cual el elemento esta instanaciando.

TS *Padre(TS *tabla); Devuelve el puntero a la tabla de símbolos Padre, de una tabla de símbolos determinada.

TS *Subtabla(TS *tabla,char *nombre); Nos devuelve el puntero a la subtabla de símbolos de un elemento de una tabla de símbolos determinada.

int Insertar_Reservadas(TS *tabla); Inserta todas las palabras reservadas en una tabla de símbolos.

int Dar_Tipo_Parametro(TS *tabla,char *nombre, int i);Devuelve el tipo del parámetro de posición “i” de la lista de parámetros de un elemento de una tabla de símbolos determinada.

TS * Dar_Subtabla_Metodo(TS *t, char *nombre);Devuelve el puntero a una subtabla de un elemento que es un metodo. Dicho elemento se encuentra en una tabla de símbolos determinada.

int Insertar_Tamamo(TS *tabla,char *nombre, int tam);Inserta el tamaño de la lista de un elemento de tipo “Lista” de una tabla de símbolos determinada.

int Es_Publico(TS *tabla, char *nombre);Devuelve 0 si el elemento de la tabla es publico. En caso contrario, devuelve -1.

Compiladores 15


3.3 Ejemplo

A continuación, para comprobar el funcionamiento de la Tabla de Símbolos, incluimos el código de la función main.cpp con su correspondiente solución.

#include “tsimbolos.h"

int main() {

TS *t,*tfuncion;

t = Crear_Tabla(NULL);

Insertar_Lexema(t,"numero1",SHORT);Insertar_Valor_Lexema(t,"numero1");

Insertar_Lexema(t,"identificador1",SHORT);Cambiar_Tipo(t,"identificador1",STRING);Insertar_Valor_Lexema(t,"identificador1");

Insertar_Lexema(t,"funcion1",FUNCION);Insertar_Valor_Lexema(t,"funcion1");Insertar_Tipo_Valor_Devuelto(t,"funcion1",SHORT);Insertar_Parametro(t,"funcion1",BOOL,NORMAL);Insertar_Parametro(t,"funcion1",SHORT,REF);Insertar_Parametro(t,"funcion1",BOOL,REF);

Insertar_Lexema(t,"identificador2",STRING);Insertar_Valor_Lexema(t,"identificador2","apellido");

Insertar_Lexema(t,"numero1",SHORT); //No lo inserta por repetido

tfuncion = Crear_Subtabla(t,"funcion1");Insertar_Lexema(tfuncion,"numero2",SHORT);Insertar_Valor_Lexema(tfuncion,"numero2");Insertar_Lexema(tfuncion,"identificador3",STRING);Insertar_Valor_Lexema(tfuncion,"identificador3");

Dibujar_Tabla(t,"salida.txt");

return 0;}

A continuación representamos su solución, es decir, las tablas de símbolos en ficheros de texto:

Fichero “salida.txt”

LEXEMA: numero1Tipo: SHORTValor: 1------------------------------------------------

LEXEMA: identificador1Tipo: STRINGValor: 1

Compiladores 16


------------------------------------------------

LEXEMA: funcion1Tipo: FUNCIONValor: 1Tipo valor devuelto: SHORTNumero de parametros: 3Parametros:Tipo parametro: BOOLPaso de parametro: NORMALTipo parametro: SHORTPaso de parametro: POR REFERENCIATipo parametro: BOOLPaso de parametro: POR REFERENCIAEste Lexema contiene una SUBTABLA------------------------------------------------

LEXEMA: identificador2Tipo: STRINGValor: 1------------------------------------------------

Fichero “funcion1.txt”

LEXEMA: numero2Tipo: SHORTValor: 1------------------------------------------------

LEXEMA: identificador3Tipo: STRINGValor: 1------------------------------------------------

Compiladores 17


4 Analizador Sintáctico

Dado un conjunto de Tokens (dado por el analizador léxico), el analizador sintáctico debe, utilizando una gramática de tipo LL(1), generar un Autómata Finito No Determinista (AFN), realizar un recorrido descendente recursivo y generar un árbol sintáctico.

Se define una gramática de tipo LL(1) como la gramática que cumple las siguientes propiedades:

Dado A = α|β|γ. Se debe cumplir que: first(α) . first(β) = {} . first(α) . first(γ) = {} . first(β) . first(γ) = {}.

Dado A =(α|)β. Se debe cumplir que:first(α) . first(β) = {}

Dado A =(α|). Se debe cumplir que:first(α) . follow(A) = {}

FIRST(X)

Si es cualquier cadena de símbolos gramaticales, se considera FIRST() como el conjunto de terminales que encabezan las cadenas derivadas de . Si =*=> , entonces también está en FIRST().

Para calcular FIRST(X) para algún símbolo X de la gramática, se aplican las siguientes reglas hasta que no se pueda añadir nada nuevo al conjunto FIRST:

1. Si X es terminal, entonces FIRST(X) es {X}.

2. Si X es no terminal y existe la producción X , entonces añadir a FIRST(X).

3. Si X es no terminal y X Y1 Y2 .. . Yk es una producción entonces, para todo i (con i variando desde 1 hasta k) tal que Y1 , Y2 , ..., Yi-1 sean todos no terminales y FIRST(Y1), FIRST(Y2), ..., FIRST(Yi-1) contengan todos , se añaden todos los símbolos no nulos de FIRST(Yi ) a FIRST(X). Finalmente, si está en FIRST(Yj ) para j = 1, 2, ..., k (o sea, en todos), entonces se añade a FIRST(X). Dicho de otra forma, lo anterior significa que todos los elementos de FIRST(Y1), excepto , pertenecen también a FIRST(X). Si Y1 no deriva , entonces ya ha terminado el cálculo de FIRST(X), pero en caso contrario, es decir, si Y1=*=> , entonces todos los elementos de FIRST(Y2) excepto pertenecen también a FIRST(X), y así sucesivamente. Finalmente, si todos los Yi derivan , entonces se añade a FIRST(X).

Compiladores 18


FOLLOW(A)

Se define FOLLOW(A), para el no terminal A, como el conjunto de terminales a que pueden aparecer inmediatamente a la derecha de A en alguna forma sentencial, es decir, el conjunto de terminales a tal que haya una derivación de la forma S=*=>Aa para algún y . Si A puede ser el símbolo de más a la derecha en alguna forma sentencial, entonces $ está en FOLLOW(A).

Para calcular FOLLOW(A) para un símbolo no terminal A, se aplican las siguientes reglas hasta que no se pueda añadir nada más al conjunto FOLLOW.

1. $ está en FOLLOW(S), siendo S el axioma de G.

2. Si existe una producción A B, entonces todo lo que esté en FIRST(), excepto , está en FOLLOW(B).

3. Si existe la producción A B y FIRST() contiene (es decir, =*=>), o bien si existe una producción A B, entonces todo lo que esté en FOLLOW(A) está en FOLLOW(B).

Se puede considerar el análisis sintáctico descendente como un intento de encontrar una derivación por la izquierda para una cadena de entrada. También se puede considerar como un intento de construir un árbol de análisis sintáctico para la entrada comenzando desde la raíz y creando los nodos del árbol en orden previo.

A continuación representaremos la gramática del Analizador Sintactico.

4.1 Gramática

Primeramente hicimos una gramática sencilla que cumpliera las normas para LL(1). A medida que incluíamos mas reglas, nos iban apareciendo nuevas dependencias. Finalmente, utilizando una serie de técnicas pudimos eliminar dichas dependencias y crear una gramática de tipo LL(1).

Una vez que tuvimos la gramática correcta, la modificamos para que se pareciera al máximo a la gramática utilizada para la implementación. Sustituimos los símbolos terminales por definiciones, que posteriormente comentamos, para que la gramática se parezca lo máximo posible a la implementación.

La gramática es la siguiente:

Sintactico → PR_CLASS Clase SintacticoSintactico → EO

Clase → ID LLA DeclSentencias LLCClase → λ

Compiladores 19


DeclSentencias → DeclSentencia DeclSentenciasDeclSentencias → λ

DeclSetencia → [(PR_PUBLIC | PR_PRIVATE )] [STATIC] Sentencia

Sentencia → ID [Var] (SentAsig DPC | SentMet DPC | DPC | ID Declaracion)Sentencia → PR_IF Expresión ( Sentencia | LLA SentenciaS LLC) … …[PR_ELSE ( Sentencia | LLA SentenciaS LLC)]Sentencia → PR_RETURN Expresión DPCSentencia → Tipos [LLA LLC] ID DeclaracionSentencia → CCW PAA (ID [Var] | ST) [DC DatosWrite] PAC DPC

Var → OP ID [SentMet]Var → CA Expresión CC

SentenciaS → Sentencia SentenciasSentenciaS → λ

SentAsig → OAS ValorSentAsig → AO Expresion

SentMet → PAA (PAC | Var2 PAC)

DatosWrite → DC Valor DatosWriteDatosWrite → λ

Tipos → (PR_SHORT | PR_STRING | PR_VOID | PR_BOOL)

Valor → CCR PAA PACValor → PR_NEW Tipos CA CE CCValor → LLA Primario Valores LLCValor → Expresion

Var2 → Expresión Var3

Var3 → DC Expresión Var3Var3 → λ

Valores → DC Primario ValoresValores → λ

Primario → ST | OC | CE | PAA Expresión PAC | PR_TRUE | PR_FALSE… … | PR_VALUE | ID [Var] [SentMet]

Expresion → Condicion [Expresion2]

Expresion2 → (OL_AND | OL_OR) Expresion

Compiladores 20


Condicion → ExprSimple [Condicion2]

Condicion2 → (OL_MAYOR | OL_MENOR | OL_IGUAL | OL_MEN_IGU … …| OL_MAY_IGU | OL_DIST) ExprSimple

ExprSimple → [(Suma | Resta)] Termino [ExprSimple2]

ExprSimple2 → (Suma | Resta) Termino

Termino → Factor [Termino2]

Termino2 → (Producto | Division | Modulo) Factor Termino2Termino2 → λ

Factor → [OL_NOT] Primario

Declaracion → PAA TiposMet PAC DeclMetodoDeclaracion → LLA DeclAtributo LLCDeclaracion → OAS Valor DeclaracionDeclaracion → DC Decl2 DPCDeclaracion → DPC

TiposMet → [PR_REF] PR_PARAMS Tipos CA CC ID TiposMet2TiposMet → [PR_REF] (Tipos | ID) ID TiposMet2

TiposMet2 → DC TiposMetTiposMet2 → λ

DeclMetodo → LLA SentenciaS LLC

DeclAtributo → PR_GET DeclAtributo2DeclAtributo → PR_SET DeclAtributo4

DeclAtributo2 → LLA SentenciaS LLC DeclAtributo3

DeclAtributo4 → LLA SentenciaS LLC DeclAtributo5

DeclAtributo3 → PR_SET LLA SentenciaS LLCDeclAtributo3 → λ

DeclAtributo5 → PR_GET LLA SentenciaS LLCDeclAtributo5 → λ

Decl2 → CA CC ID Decl22 Decl21Decl2 → ID Decl22 Decl21

Compiladores 21


Decl22 → OAS ValorDecl22 → λ

Decl21 → DC Decl2Decl21 → λ

Cada palabra en negrita es un Símbolo No Terminal, y por tanto genera rama. Cada rectangulo pertenece a un Símbolo No Terminal.

Los símbolos terminales son:

PR – Palabra Reservada OA – Operador Aritmetico OAS – “=” (Operador ASignacion) PAA – “(“ (PAréntesis Abierto) PAC – “)” (PAréntesis Cerrado) LLA – “{“ (LLave Abierta) LLC – “}”(LLave Cerrada) OL – Operador Logico CE – Entero AO – Asignacion con Operador CA – “[“ (Corchete Abierto) CC – “]” (Corchete Cerrado) OP – “.” (Operador Punto) OC – character (Operador Caracter) ST – STring (conjunto de caracteres) ID – IDentificador DPC – “;” (Delimitador Punto y Coma) DC – “,” (Deliminator Coma) EO – Fin de Fichero (EOF) CCR = Console.Read CCW = Console.Write

4.2 Implementación

En la implementación del analizador sintáctico no utilizamos ninguna herramienta, ya que la única valida era COCO/R y no nos convencía del todo para realizar el resto de pasos (analizador semántico, generador de código intermedio, etc.).

Simplemente sustituimos los símbolos no terminales por nombres de función, cuyo cuerpo de la misma es encajar los tokens leidos con cada regla de la gramática. En caso de no encajar, se produce un error, lo que conlleva a avisar al gestor de errores, que mas adelantes hablaremos de el.

Compiladores 22


5 Analizador Semántico

Este apartado lo vamos a dividir en dos subapartados: Por un lado vamos a comentar como se ha realizado la comprobación de tipos y por otro como se han realizado el resto de reglas semánticas.

Primeramente, debemos comentar que todo el análisis semántico se ha realizado por traducción, es decir, utilizando Esquema de Traducción (EDT) y no dirigida por sintaxis, como es lógico en analizadores sintácticos descendentes.

Como es obvio, la inclusión de reglas semánticas se implementa utilizando código en C++. A continuación vemos todas las comprobaciones semánticas realizadas en el compilador.

5.1 Comprobación de Tipos

En la comprobación de tipos, realizamos las siguientes comprobaciones:

Comprobación de tipos en Id: Existen dos posibilidades:

o Declaración de un Id:

Comprobar que dicho Id no esta declarado en la misma tabla de símbolos.

Comprobar que tiene una declaración correcta (tal y como indica el sintactico). Tener en cuenta el tipo de declaración (metodo, clase, variable, atributo).

Insertar en la tabla de símbolos dicho Id con el tipo especifico. En caso de ser un método, insertar el tipo del valor devuelto. En caso de ser una instanciación de una clase, insertar el nombre de la clase instanciada.

o Uso de un Id o Variable (Id con campos):

Debemos comprobar que el Id ya ha sido declarado anteriormente, o bien en la tabla de símbolos, o bien en la tabla de símbolos padre, o bien en la tabla de símbolos de hermanos ya generadas. Debemos devolver el tipo del Id.

En caso de estar el Id después de un operador de asignación (“=”) debemos comprobar que dicha variable ya este inicializada.

Puede darse el caso en que la Variable sea un objeto y se intente acceder a un atributo de dicho objeto (operador “.”). Por tanto, lo primero que debemos mirar a que clase se refiere dicho objeto.

Compiladores 23


Una vez que se sabe la clase, debemos mirar el tipo del atributo de dicha clase. Lo que devolvemos en este caso seria el tipo del atributo. En caso de no tener declarada la clase del objeto, o de no existir el atributo, generaríamos un error.

Puede darse el caso en que se trate de un acceso a un elemento de un vector (operador “[ ]”). Por tanto, debemos asegurarnos de que la Expresión incorporada entre los corchetes sea de tipo Short. En este caso devolvemos el tipo del vector de elementos, es decir, si se trata de un vector de shorts, devolveríamos el tipo short.

Comprobación de tipos en una Expresión:

o Una expresión se divide en un conjunto de condiciones. Una condición se divide en un conjunto de expresiones simples. Una expresión simple se divide en un conjunto de términos. Un término esta formado por un conjunto de factores. Un factor esta formado por un solo elemento Primario (con posible negación). Un elemento primario puede ser de varios tipos.

o La comprobación de tipos para cada una de las partes es:

Expresión: Si hay mas de uno, los tipos de las condiciones deben ser iguales y deben ser de tipo Booleano.

Condición: Si hay mas de una, los tipos de las expresiones simples deben ser iguales. En caso de ser de tipo short, la condición se transforma a tipo booleano. En caso de ser tipo booleano, obligatoriamente los operadores deben ser “==” y “!=”

ExprSimple: Si hay mas de uno, los tipos de los términos deben ser iguales y de tipo Short.

Termino: Si hay mas de uno, los tipos de los factores deben ser iguales y de tipo Short.

Factor: Solo puede haber un elemento primario. Si hay negación, el elemento primario debe ser booleano. Sino la hay, puede ser cualquier tipo.

Primario: puede ser Cadena: tipo string Var (posibilidad de ser llamada a método): el propio tipo

de la variable. Caso de ser un método, el tipo devuelto del mètodo es el tipo del elemento primario.

Decimal: debemos verificar que el decimal no se pase de 216 (16 bits) para que sea de tipo Short

Hexadecimal: Lo mismo que el anterior, pero teniendo en cuenta que es hexadecimal.

“(“ Expresión ”)”: Es el tipo de de propia Expresión. “true”: tipo booleano “false”: tipo booleano. “value”: el tipo que indique el atributo utilizado en ese

momento (se utiliza una variable global que toma valor cuando un atributo se define).

Compiladores 24


Comprobación de tipos en una Sentencia: Toda sentencia devuelve un tipo que indica si la sentencia tiene los tipos correctos (tipo = 0) o no (tipo = -1). Debemos diferencias varios tipos de sentencias:

o Declaraciones: Existen tres tipos de Declaraciones. La declaración será correcta si los tipos de la declaración lo son y coinciden con sus posibles valores.

Atributos: Los atributos tienen un tipo de inicio. En este caso, se utiliza la variable global tipo_value que indica el tipo al elemento primario value.

Métodos: Lo vemos mas adelante. Variables: Debemos tener en cuenta que todas las variables

declaradas en una misma declaración tienen el mismo tipo.

En caso de declarar un objeto, debemos comprobar que la variable que funciona como Tipo, es una variable de tipo clase. Una vez hecho eso, insertamos como clase del objeto el nombre de dicha variable.

Debemos comprobar que todos los valores asignados en la

declaración de cada variable coincidan con el tipo de la propia declaración.

o Asignaciones: Debemos comprobar que el tipo de la Variable coincida, o bien con el tipo del Valor asignado, o bien sea de tipo Consola (lectura de caracteres, de tipo short). Como hemos comentando anteriormente, todas las variables puestas en el lado derecho de la asignación, deben estar inicializadas de valor.

o Sentencias if/then/else: La estructura es de tipo if EXPRESION {sentencias} else {sentencias}. Por tanto, se debe cumplir que la expresión es de tipo booleana (es una condición) y que todas las sentencias tengan correctos sus tipos, para que esta sentencia sea correcta.

o Sentencias de Consola Write: Únicamente debemos verificar que el primer argumento sea de tipo string (sea una cadena de caracteres o una variable) y que pueda contener cualquier variable de cualquier tipo. El tipo de esta sentencia es “otro”.

o Sentencias de Consola Read: Obligatoriamente esta sentencia devuelve un entero, que es el entero leído de entrada estandar.

o Retornos: Los retornos devuelven cualquier Expresión. El tipo de la expresión debe coincidir, o bien con el retorno del método que incluye dicha sentencia, o bien con el tipo del atributo que la incluye (que es donde se suele utilizar este tipo de sentencias). Si coinciden los tipos, la sentencia será correcta.

Compiladores 25


Comprobación de tipos en un Método: En este caso debemos comprobar los siguientes tipos:

o Modificación del tipo del identificador. El tipo insertado anteriormente es el tipo del valor devuelto por el método.

o parámetros: Incluir como nuevas variables (con su tipo correspondiente) en la nueva tabla de símbolos del método declarado.

o Sentencias del interior del Método: Deben ser correctas. Deben estar sus declaraciones en una subtabla del metodo, junto a los parámetros.

Comprobación de tipos en una Clase: Lo único que debemos comprobar es que todas las sentencias son correctas de tipo. También, creamos una nueva subtabla de símbolos para cada clase e insertamos en ella todos los símbolos encontrados en las sentencias de la Clase.

5.2 Otras Reglas Semánticas

Otras comprobaciones que hacemos son las siguientes:

Comprobamos que las variables no se declaran dos veces en el mismo método o clase.

Comprobamos que no se declare un objeto de una clase que este definiéndose en ese momento. También se tiene en cuenta que puede estar declarándose dicho objeto dentro de un método de una clase.

Se tiene en cuenta que los números decimales de tipo Short no excedan el limite de overflow.

Se modifica la cadena de caracteres cambiando los caracteres especiales utilizados en la misma.

Se tiene en cuenta en búsqueda de Identificadores, la herencia en Tabla de Símbolos padres y hermanos ya creados.

En llamadas a métodos de un objeto, comprobamos el número de parámetros y el tipo de cada parámetro.

Comprobamos que solo existe un solo método “MAIN” en todo el programa.

Comprobamos que los usos de variables y métodos de objetos tengan permisos de uso (es decir, sean públicos).

Comprobamos el tipo de cada elemento de la lista asignada a una variable, es decir, por ejemplo: pepe = [3,2,5] comprobamos que todos los elementos son enteros.

Compiladores 26


Comprobamos si no hay sentencias en el uso de llaves. Es obligatorio que como mínimo haya una sentencia entre llaves.

Comprobamos que asignaciones entre variables y llamadas a métodos sean del mismo tipo.

Comprobamos que la palabra reservada Value se use únicamente cuando se encuentra en una declaración de atributo.

Comprobamos que todos los métodos y atributos tengan una sentencia de tipo retorno (return). Solo se permitirá que no exista esta sentencia cuando el tipo de retorno sea VOID.

Comprobamos que no se puede declarar una clase dentro de otra.

Comprobamos que el método Main debe ser publico, de lo contrario no podemos contar con ese método.

Comprobamos que los atributos y las variables estén inicializadas, ya sean desde la propia clase o método, a objetos instanciados.

Compiladores 27


6 Generador de Código Intermedio

El generador de código intermedio hace una representación del programa en un lenguaje intermedio, en nuestro caso en Tercetos. Esto se consigue mediante llamadas a las funciones del generador desde el analizador sintáctico. El generador de código intermedio está dividido en dos partes: Por un lado, el modulo “tercetos”, se encarga de almacenar los tercetos que se van generando y por otro lado, el módulo “intermedio” hace de mediador entre el analizador sintáctico y la generación de tercetos.

6.1 El modulo “tercetos”

Este módulo es el encargado de generar los tercetos y almacenarlos. Inicialmente, este módulo fue planificado para almacenar los tercetos en memoria mediante una lista doblemente enlazada para que luego el optimizador y el generador de código objeto ya tuviesen los tercetos en memoria para analizarlos. Sin embargo, puesto que no hemos implementado ningún optimizador de código y hemos conseguido hacer un generador de código objeto de una pasada secuencial, finalmente decidimos no almacenar los tercetos en memoria y almacenarlos directamente en un fichero de salida cuya única finalidad es comprobar el buen funcionamiento del generador de tercetos.

Las funciones proporcionadas por este módulo son:

La estructura de los tercetos. Esta estructura está preparada para almacenar los tercetos en memoria según se van generando aunque como hemos explicado antes, los tercetos se escriben directamente en un fichero y no se almacenan en memoria. Los tercetos se componen de tres campos:

o La operación correspondiente al tercetoo El operador1o El operador 2

Los operadores se componen a su ven de dos campos: El tipo de operador y el valor. El tipo puede ser numérico, cadena, o una referencia a otro terceto. El valor es una unión capaz de almacenar cualquiera de estos tres valores.

typedef union val_t val;typedef struct op_t op;typedef struct terceto_t terceto;typedef struct cola_terceto_t cola_terceto;

union val_t{int numero;char *cadena;terceto *t;

};

struct op_t{int tipo;val valor;

};

Compiladores 28


struct terceto_t{int operacion;op op1;op op2;terceto *siguiente;terceto *anterior;

};

struct cola_terceto_t{terceto *primero;terceto *ultimo;

};

void Iniciar_Tercetos(char *f);Esta función recibe el nombre del fichero de salida donde se escribirán los tercetos generados. Automáticamente se añadirá la extensión “.ter” al fichero generado. Inicializa el generador de tercetos.

void Generar_Terceto(int operacion,int t1, val v1,int t2, val v2);Esta función genera los tercetos. Recibe la operación del terceto a generar y los 2 tipos y valores de los operadores del terceto.

void Fin_Tercetos();Informa de la finalizacion de generción de tercetos y cierra el fichero.

int Dibujar_Op(FILE *fd,op o);Función auxiliar utilizada por Generar_Terceto para escribir un operador.

Los tipos de tercetos que se pueden generar se encuentran definidos en “types.h” y son los siguientes:

#define TR_INICIO_PROGRAMA 0Terceto de inicio del programa. No recibe ningún operando.

#define TR_FIN_PROGRAMA 1Terceto de fin del programa. No recibe ningún operando.

#define TR_METODO_MAIN 2Terceto correspondiente con el inicio del método principal “Main”

#define TR_METODO 3Terceto correspondiente con el inicio de un método. Recibe un operando numérico que indica el número correspondiente a la etiqueta del método

#define TR_METODO_RET 4Terceto correspondiente con el fin de un método. No recibe ningún operando.

#define TR_ASIGNACION 5Terceto de asignación. Recibe dos operandos numéricos. El primero indica si la variable donde se realiza la asignación es del método o de la clase, y el segundo

Compiladores 29


indica el desplazamiento correspondiente a la variable en el registro de activación correspondiente

#define TR_REGISTRO_CLASE 6Crea el registro de activación de una clase. Recibe un operando numérico que indica el tamaño del registro

#define TR_CLASE 7Terceto correspondiente con el inicio de una clase. Recibe un operando numérico que indica el número correspondiente a la etiqueta de la clase

#define TR_SALTO 8Terceto que indica la posición del código inicial del programa. No recibe ningún operando.

#define TR_REGISTRO_METODO 9Crea el registro de activación de un método. Recibe un operando numérico que indica el tamaño del registro

#define TR_VALOR_INMEDIATO 10Terceto de un valor short inmediato. Recibe un operando numérico con el valor.

#define TR_VALOR_VARIABLE 11Terceto de acceso a una variable. Recibe dos operandos numéricos. El primero indica si la variable es del método o de la clase, y el segundo indica el desplazamiento

#define TR_WRITE_STRING 12Terceto para escribir cadenas. Recibe un operando numérico que le facilita 2 etiquetas auxiliares y un operando cadena con el valor del “string” a escribir.

#define TR_WRITE_SHORT 13Terceto para escribir enteros. Recibe un operando numérico con el valor a escribir.

#define TR_SALTO_METODO 14Terceto para saltar a un método. Recibe un operando con la etiqueta del método al que saltar.

#define TR_INICIO_WRITE_STRING 15Terceto que indica el inicio de escritura en consola. No recibe ningún operando.

#define TR_FIN_WRITE_STRING 16Terceto que indica el final de escritura en consola. No recibe ningún operando.

#define TR_SUMA 17Terceto que implementa los operadores aritméticos suma y resta. Recibe un operando indicando si tiene que sumar o restar.

Compiladores 30


#define TR_GUARDAR_ESTADO 18Terceto que indica que se debe guardar el estado del computador. No recibe ningún operando.

#define TR_RESTAURAR_ESTADO 19Terceto que indica que se debe restaurar el estado del computador. No recibe ningún operando.

#define TR_VALOR_DEVUELTO 20Terceto que indica que se debe usar el valor devuelto por el método que termina. No recibe ningún operando.

#define TR_INICIO_ARGUMENTOS 21Terceto que indica el inicio de argumentos para la llamada a un método.

#define TR_FIN_ARGUMENTOS 22Terceto que indica el fin de argumentos para la llamada a un método.

#define TR_ACTIVAR_REGISTRO_CLASE 23Terceto que indica que se debe activar el registro de otra clase. Recibe dos operandos numéricos que indican la posición del registro de activación de la clase de forma similar que TR_VALOR_VARIABLE.

#define TR_ACTIVAR_MISMA_CLASE 24Terceto que indica que se debe seguir usando el registro de la clase actual.

#define TR_INICIO_IF 25Terceto que indica el inicio de una sentencia condicional “if-else”. No recibe ningún operando.

#define TR_FIN_IF 26Terceto que indica el final de una sentencia condicional “if-else”. Recibe un operando numérico que indica las etiquetas que se debe utilizar.

#define TR_ASIGNACION_INFORMATIVA 27Terceto que indica el inicio de una asignación

#define TR_COMP_IGUAL 28Este terceto indica que se debe hacer una comparación. Recibe dos operandos numéricos. El primero indica el tipo de comparación que se debe realizar y el segundo proporciona etiquetas.

#define TR_CUERPO_IF 29Informa del comienzo del cuerpo “if” de una sentencia condicional “if-else”. Recibe un operando numérico que proporciona etiquetas

#define TR_CUERPO_ELSE 30Informa del comienzo del cuerpo “else” de una sentencia condicional “if-else”. Recibe un operando numérico que proporciona etiquetas

Compiladores 31


#define TR_CONSOLE_READ 31Terceto que implementa la lectura de un un entero por consola. No recibe ningún operando.

#define TR_ASIGNACION_VECTOR 32Terceto de asignación en un vector. Recibe dos operandos numéricos. El primero indica si la variable donde se realiza la asignación es del método o de la clase, y el segundo indica el desplazamiento correspondiente a la variable en el registro de activación correspondiente

#define TR_INICIO_VECTOR 33Terceto que informa el inicio de una variable de tipo vector. No recibe ningún operando.

#define TR_FIN_VECTOR 34Terceto que informa del fin de una variable de tipo vector. No recibe ningún operando.

#define TR_VALOR_VARIABLE_VECTOR 35Terceto de acceso a una variable. Recibe dos operandos numéricos. El primero indica si la variable es del método o de la clase, y el segundo indica el desplazamiento

Para indicar el tipo de operando pasado al terceto se utilizan las siguientes definiciones en el fichero “types.h”:

#define TR_NADA 0Indica que no se pasa ningún valor útil.

#define TR_NUMERO 1Indica que se pasa un valor numérico.

#define TR_CADENA 2Indica que se pasa un valor de cadena.

#define TR_REF 3Indica que se pasa una referencia a otro terceto.

6.2 El módulo “Intermedio”

Compiladores 32


Este módulo proporciona las funciones necesarias para generar los tercetos a partir del analizador sintáctico. Todas las funciones que proporciona son llamadas desde el analizador sintáctico cuando éste tiene información útil para la generación de código intermedio.

Aunque el analizador sintáctico y semántico están preparados para soportar toda la sintaxis del lenguaje C#, el generador de código intermedio y objeto no implementan todas las instrucciones del lenguaje. Es recomendable mirar el anexo para saber lo que está y lo que no está implementado en el generador de código. Así mismo, un programa que utilice alguna instrucción sintácticamente correcta que no esté implementada por el generador de código desembocará en un código objeto erróneo o incompleto y no se mostrará ningún error durante la compilación.

Estructura de llamadas: Está estructura permite al módulo intermedio guardar mediante una pila las llamadas que se van realizando a los atributos o métodos de diferentes clases utilizando el operador “.”.

typedef struct llam_s llam_t;

struct llam_s {char nomclase[250]; //utilizado por Intermedio_Informar_Llamadachar nomnombre[250]; //utilizado por Intermedio_Informar_LlamadaTS *tinformar; //utilizado por Intermedio_Informar_Llamadallam_t *sig;int tipo;

};

int Intermedio_Inicio(char fichero_salida[]);Esta función recibe el nombre del fichero de salida donde se escribirán los tercetos generados. Automáticamente se añadirá la extensión “.ter” al fichero generado. Inicializa el generador de tercetos y el generador de código Intermedio.

terceto *Intermedio_Generar(int operacion,int t1,val v1,int t2, val v2);Esta es la función más utilizada. Sirve para generar un nuevo terceto. Recibe la operación del terceto a generar y los 2 tipos y valores de los operadores del terceto. Desde esta función se llama al generador de código objeto cada vez que se genera un terceto.

int Intermedio_Fin();Finaliza el generador de código Intermedio.

int Intermedio_Etiqueta(int n);Devuelve un número de etiqueta libre. En parámetro n indica el número de etiquetas a reservar. Devuelve el valor de la primera etiqueta. Las siguientes etiquetas reservadas son las consecutivas.

int Intermedio_Tamano_Registro(TS *tabla); Esta función recibe una tabla de símbolos y calcula el tamaño necesario que hay que reservar para crear su registro de activación.

Compiladores 33


int Intermedio_Informar_Clase_Main(TS *t);A través de ésta función se informa al módulo “Intermedio” de la tabla de símbolos correspondiente al método inicial “Main”.

int Intermedio_Posicion(TS *tabla,char *nombre);Esta función recibe una tabla de símbolos y el nombre de un identificador y calcula la posición del identificador en el registro de activación correspondiente.

int Intermedio_Write(int numero,char *cadena);Función que implementa la generación de los tercetos correspondientes a “Console.Write”.

int Intermedio_Informar_Llamada(TS * t1, char *clas, char *nombr);Esta función utiliza la estructura antes explicada para almacenar las llamadas realizadas mediante el operador “.” de modo que si se realizan llamadas recursivas utilizando “.” Queden almacenadas en la estructura.

int Intermedio_Informar_Llamada_Funcion();Lo mismo que antes pero para llamadas a métodos.

int Intermedio_Tipo_Llamada();Devuelve el tipo de llamada en curso: Es decir llamada a atributo o a método.

int Liberar_Informar_Llamada();Como su nombre indica esta función libera una llamada de la pila de llamadas.

int Intermedio_Ultimo_TR();Esta función devuelve el último tipo de terceto generado.

int Intermedio_Salto(int devuelto);Función que implementa la generación de los tercetos correspondientes al salto a un método. El parámetro “devuelto” indica si se va a utilizar o no el valor devuelto por el método.

int Intermedio_Llamada(TS *t,char *nom);Función que implementa la generación de los tercetos correspondientes al salto a un método de otra clase utilizando el operador “.” Recibe la tabla de símbolos actual y el nombre del identificador después del “.”.

int Intermedio_Asignacion_Clase(TS *t,char *nom,int esvector);Función que implementa la generación de los tercetos correspondientes a la asignación a una variable de clase y no del método actual.

int Intermedio_Valor_Variable_Clase(TS *t,char *nom,int esvector);Función que implementa la generación de los tercetos correspondientes al acceso a una variable de clase y no del método actual.

Para finalizar este punto, ponemos un ejemplo de la ejecución del compilador y el resultado del código intermedio:

Línea de comandos

Compiladores 34


C:\CSC\Debug> csc.exe –t ..\pruebas\pruebaT.cs salida

pruebaT.cs

class clase{

public static void Main(){short num1,num2;

num1=5;num2=4;

if (num1>=num2) //falsoconsole.write("verdadero\n");

else console.write("falso\n");

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 5Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 6

Compiladores 35


Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 8Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 9Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 11Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 12Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 13Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 14Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 16Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 17Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_WRITE_STRING

Compiladores 36


Tipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 19Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 20Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 21Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 22Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 23Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 24Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

Compiladores 37


7 Generador de Código Final

El generador de código objeto “traduce” el código intermedio generado por el generador de código intermedio en código ensamblador para el winENS-2001. Cabe destacar que, en nuestro caso, el código objeto se genera al mismo tiempo que el código intermedio, es decir, todo el proceso de compilación se realiza en una pasada. Cada terceto es “traducido” por el módulo “objeto” mediante una función asociada a cada terceto.

Aunque el analizador sintáctico y semántico están preparados para soportar toda la sintaxis del lenguaje C#, el generador de código intermedio y objeto no implementan todas las instrucciones del lenguaje. Es recomendable mirar el anexo para saber lo que está y lo que no está implementado en el generador de código. Así mismo, un programa que utilice alguna instrucción sintácticamente correcta que no esté implementada por el generador de código desembocará en un código objeto erróneo o incompleto y no se mostrará ningún error durante la compilación.

Excepto las dos funciones de inicialización y finalización, todas las funciones de este módulo tienen el mismo nombre que el terceto que implementan precedido por el prefijo “Objeto_”.

Pasamos a describir las funciones de este método detalladamente:

Objeto_Inicializar(char fichero_salida[]);Esta función inicializa el módulo y recibe como parámetro el nombre del fichero donde escribir el código objeto en ensamblador. Automáticamente se añadirá la extensión “.ens” al nombre del fichero.

Objeto_Finalizar();Esta función finaliza el módulo y cierra el fichero de salida.

Objeto_Inicio_Programa(){fprintf(fdobjeto,"MOVE #INICIO_PILA,.SP\n");fprintf(fdobjeto,"BR /SALTO\n");

}Inicializa la pila y salta a “salto” donde comienza el programa.

Objeto_Fin_Programa(){fprintf(fdobjeto,"\tPUSH #INICIO_PILA\n");fprintf(fdobjeto,"\tCALL /E0\n");fprintf(fdobjeto,"HALT\n");fprintf(fdobjeto,"INICIO_PILA:\n");

}Mete en la pila la dirección del registro de activación de la clase del “Main” público que corresponde con el inicio de la pila. Después llama al “Main” que siempre se encuentra en la etiqueta E0. Después finaliza la ejecución y marca el comienzo de la pila.

Compiladores 38


Objeto_Metodo_Main() {fprintf(fdobjeto,"E0:\n");fprintf(fdobjeto,"\tMOVE .SP,.IY;metodo\n");

}Marca el comienzo del método “Main” y guarda el registro de pila en IY. El registro IY se utilizara para acceder a las direcciones que marcan el registro de activación de la clase y el método actual.

Objeto_Metodo(int n) {fprintf(fdobjeto,"E%d: NOP ;metodo\n",n);fprintf(fdobjeto,"\tMOVE .SP,.IY;metodo\n");

}Marca el comienzo de un método y guarda el registro de pila en IY. El registro IY se utilizara para acceder a las direcciones que marcan el registro de activación de la clase y el método actual. El parámetro n indica el número de etiqueta correspondiente al método.

Objeto_Metodo_Ret() {fprintf(fdobjeto,"\tMOVE .IY,.SP\n");fprintf(fdobjeto,"\tRET\n");

}Restaura el valor de la pila y retorna del método actual.

Objeto_Registro_Clase(int numero) {fprintf(fdobjeto,"\t;Crear registro clase tamano %d\n",numero);fprintf(fdobjeto,"\tMOVE .SP,.R0\n");fprintf(fdobjeto,"\tADD #%d,.SP\n",numero);fprintf(fdobjeto,"\tMOVE .A,.SP\n");

}Crea en la pila el registro de activación de una clase. El parámetro numero indica el tamaño del registro.

Objeto_Clase(int n) {fprintf(fdobjeto,"E%d: NOP ;clase\n",n);

}Pone la etiqueta del comienzo de una clase. El parámetro indica el número de etiqueta.

Objeto_Salto() {fprintf(fdobjeto,"SALTO:\n");

}Marca el comienzo del programa principal, donde se crean los registros de activación iniciales y se llama al Main

Objeto_Registro_Metodo(int numero) {fprintf(fdobjeto,"\t;Crear registro metodo tamano %d\n",numero);fprintf(fdobjeto,"\tMOVE .SP,.R0\n");fprintf(fdobjeto,"\tADD #%d,.SP\n",numero);fprintf(fdobjeto,"\tMOVE .A,.SP\n");fprintf(fdobjeto,"\tPUSH .R0\n");

Compiladores 39


}Crea en la pila el registro de activación de un método. El parámetro numero indica el tamaño del registro. Al final mete en la pila el comienzo del registro.

Objeto_Asignacion(int n,int clase) {if (clase==0)

clase=-3;else

clase=-2;fprintf(fdobjeto,"\t;asignacion pos %d\n",n);fprintf(fdobjeto,"\tPOP .R0\n",n);//*fprintf(fdobjeto,"\tMOVE #%d[.IY],.IX\n",clase);fprintf(fdobjeto,"\tMOVE .R0,#%d[.IX]\n",n);

}Hace una asignación. El parámetro clase indica si la variable donde almacenar el valor es del método actual o de la clase actual y el parámetro n indica el desplazamiento dentro del registro de activación. Presupone que el valor esta almacenado en la pila.

Objeto_Valor_Inmediato(int n){

fprintf(fdobjeto,"\t;valor inmediato %d\n",n);fprintf(fdobjeto,"\tMOVE #%d,.R0\n",n);fprintf(fdobjeto,"\tPUSH .R0\n",n);

}Mete un valor inmediato en la pila. El parámetro n es el valor inmediato.

Objeto_Valor_Variable(int n,int clase) {if (clase==0)

clase=-3;else

clase=-2;fprintf(fdobjeto,"\t;valor de variable\n");fprintf(fdobjeto,"\tMOVE #%d[.IY],.IX\n",clase);fprintf(fdobjeto,"\tMOVE #%d[.IX],.R0\n",n);fprintf(fdobjeto,"\tPUSH .R0\n",n);

}Mete un valor de variable en la pila. El parámetro clase indica si la variable es del método actual o de la clase actual y el parámetro n indica el desplazamiento dentro del registro de activación. Almacena el valor en la pila.

Objeto_Write_String(int n,char *s) {fprintf(fdobjeto,"\t;cuerpo write string %s\n",s);fprintf(fdobjeto,"\tWRSTR /E%d\n",n);fprintf(fdobjeto,"\tBR /E%d\n",n+1);fprintf(fdobjeto,"\tE%d: DATA \"%s\"\n",n,s);fprintf(fdobjeto,"\tE%d: NOP ;fin cuerpo\n",n+1);

}Escribe una cadena de caracteres. Recibe en n 2 números de etiquetas para utilizar y en s la cadena que se debe escribir en consola.

Compiladores 40


Objeto_Write_Short(int n) {fprintf(fdobjeto,"\tWRINT #%c[.IY] ;write short\n",n);

}Escribe un Short. Recibe en n el número que se debe escribir en consola.

Objeto_Salto_Metodo(int n) {fprintf(fdobjeto,"\t;Salto a metodo misma clase etiqueta E%d\n",n);fprintf(fdobjeto,"\tCALL /E%d\n",n);fprintf(fdobjeto,"\tDEC .SP\n");fprintf(fdobjeto,"\tPOP .SP\n");

}Salta a un método de la clase actual. Da por hecho que los registros de activación ya están correctos. Después de la llamada restaura el registro de activación anterior guardado en la pila.

Objeto_Inicio_Write_String() {fprintf(fdobjeto,"\tMOVE .SP,.R2 ;incio write string\n");}

Guarda SP en R2 porque a partir de ahora se meterán en la pila los valores que hay que escribir en una cadena. R2 marcará la dirección del primer argumento a escribir.

Objeto_Fin_Write_String() {fprintf(fdobjeto,"\tMOVE .R2,.SP ;fin write string\n");

}Saca de la pila todos los elementos que se han escrito.

Objeto_Suma(int n) {fprintf(fdobjeto,"\tPOP .R0 ;operacion aritmetica\n");fprintf(fdobjeto,"\tPOP .R3\n");if (n==1) fprintf(fdobjeto,"\tADD .R3,.R0 ;suma\n");else if (n==2) fprintf(fdobjeto,"\tSUB .R3,.R0 ;resta\n");fprintf(fdobjeto,"\tMOVE .A,.R0\n");fprintf(fdobjeto,"\tPUSH .R0\n",n);

}Realiza la operación suma (si n=1) o resta (si n=2). Presupone que los valores a sumar están en la pila.

Objeto_Guardar_Estado() {fprintf(fdobjeto,"\t;guardar estado\n");fprintf(fdobjeto,"\tPUSH .SP\n");fprintf(fdobjeto,"\tPUSH .SR\n");fprintf(fdobjeto,"\tPUSH .IX\n");fprintf(fdobjeto,"\tPUSH .IY\n");fprintf(fdobjeto,"\tPUSH .A\n");

// fprintf(fdobjeto,"\tPUSH .R0\n"); //aqui va el valor devueltofprintf(fdobjeto,"\tPUSH .R1\n");fprintf(fdobjeto,"\tPUSH .R2\n");fprintf(fdobjeto,"\tPUSH .R3\n");fprintf(fdobjeto,"\tPUSH .R4\n");

Compiladores 41


fprintf(fdobjeto,"\tPUSH .R5\n");fprintf(fdobjeto,"\tPUSH .R6\n");fprintf(fdobjeto,"\tPUSH .R7\n");fprintf(fdobjeto,"\tPUSH .R8\n");fprintf(fdobjeto,"\tPUSH .R9\n");fprintf(fdobjeto,"\t;fin de guardar estado\n");

}Guarda el estado de los registros del procesador. No guarda R0 porque aquí va el valor devuelto del método en caso de que devuelva algún valor.

Objeto_Restaurar_Estado() {fprintf(fdobjeto,"\t;restaurar estado\n");fprintf(fdobjeto,"\tPOP .R9\n");fprintf(fdobjeto,"\tPOP .R8\n");fprintf(fdobjeto,"\tPOP .R7\n");fprintf(fdobjeto,"\tPOP .R6\n");fprintf(fdobjeto,"\tPOP .R5\n");fprintf(fdobjeto,"\tPOP .R4\n");fprintf(fdobjeto,"\tPOP .R3\n");fprintf(fdobjeto,"\tPOP .R2\n");fprintf(fdobjeto,"\tPOP .R1\n");

// fprintf(fdobjeto,"\tPOP .R0\n"); //aqui va el valor devueltofprintf(fdobjeto,"\tPOP .A\n");fprintf(fdobjeto,"\tPOP .IY\n");fprintf(fdobjeto,"\tPOP .IX\n");fprintf(fdobjeto,"\tPOP .SR\n");fprintf(fdobjeto,"\tPOP .SP\n");fprintf(fdobjeto,"\t;fin de restaurar estado\n");

}Restaura el estado de los registros del procesador. No restaura R0 porque aquí va el valor devuelto del método en caso de que devuelva algún valor.

Objeto_Valor_Devuelto() {fprintf(fdobjeto,"\t;valor devuelto\n");fprintf(fdobjeto,"\tPUSH .R0\n");

}Guarda el valor devuelto por un método en la pila.

Objeto_Inicio_Argumentos() {fprintf(fdobjeto,"\tMOVE .SP,.R2 ;incio argumentos\n");

}Guarda SP en R2 porque a partir de ahora se meterán en la pila los valores de los parámetros que se pasarán a un método.

Objeto_Fin_Argumentos() {fprintf(fdobjeto,"\tMOVE .R2,.SP ;fin argumentos\n");

}Saca de la pila los valores de los argumentos porque ya no son necesarios.

Compiladores 42


Objeto_Activar_Registro_Clase(int n,int clase) {if (clase==0)

clase=-3;else

clase=-2;fprintf(fdobjeto,"\t;activar registro clase\n");fprintf(fdobjeto,"\tMOVE #%d[.IY],.R0\n",clase);fprintf(fdobjeto,"\tADD #%d,.R0\n",n);fprintf(fdobjeto,"\tPUSH .A\n",n);

}Mete un la pila la dirección del registro de activación de una clase. El parámetro clase indica si el registro está en el método actual o en la clase actual y el parámetro n indica el desplazamiento dentro del registro de activación actual. Almacena el valor en la pila.

Objeto_Activar_Misma_Clase() {fprintf(fdobjeto,"\t;activar registro misma clase\n");fprintf(fdobjeto,"\tMOVE #-2[.IY],.R0\n");fprintf(fdobjeto,"\tPUSH .R0\n");

}Mete en la pila la dirección del registro de activación de la clase actual.

Objeto_Inicio_If() {fprintf(fdobjeto,"\tMOVE #0,.R3 ;inicio if\n");

}Mete en R3 un 0. Esto es porque se inicia una comparación lógica. Si alguna comparación resulta falsa, pondrá un uno en R3.

Objeto_Fin_If(int eti) {fprintf(fdobjeto,"\tE%d: NOP; fin if\n",eti+1);

}Pone la etiqueta del final del if.

Objeto_Asignacion_Informativa() {fprintf(fdobjeto,"\t;asignacion informativa\n");

}Indica el inicio de una asignación. Este terceto no necesita ninguna implementación en nuestro generador de código objeto. Sin embargo, hacemos esta función y ponemos un comentario para dar más claridad al código del compilador y al código generado.

Objeto_Comp_Igual(int op,int eti) {fprintf(fdobjeto,"\t;comp igual op %d eti %d\n",op,eti);fprintf(fdobjeto,"\tPOP .R1\n");fprintf(fdobjeto,"\tPOP .R0\n");fprintf(fdobjeto,"\tCMP .R0,.R1\n");if (op==1) //igual

fprintf(fdobjeto,"\tBZ /E%d\n",eti);else if (op==2) //distinto

fprintf(fdobjeto,"\tBNZ /E%d\n",eti);

Compiladores 43


else if (op==3) {//mayorfprintf(fdobjeto,"\tBZ /E%d\n",eti+1); //son igualesfprintf(fdobjeto,"\tBP /E%d\n",eti);

}else if (op==4) //menor

fprintf(fdobjeto,"\tBN /E%d\n",eti);else if (op==5) //mayor igual

fprintf(fdobjeto,"\tBP /E%d\n",eti);else if (op==6) {//menor igual

fprintf(fdobjeto,"\tBN /E%d\n",eti);fprintf(fdobjeto,"\tBZ /E%d\n",eti);

}fprintf(fdobjeto,"\tBR /E%d\n",eti+1);fprintf(fdobjeto,"\tE%d: MOVE #1,.R3; \n",eti);fprintf(fdobjeto,"\tE%d: NOP; fin comp igual\n",eti+1);

}Realiza la comparación. El tipo de comparación lo indica el parámetro op. Si el resultado de la comparación es falso pone el valor un en R3

Objeto_Cuerpo_If(int eti) {fprintf(fdobjeto,"\t;cuerpo if\n");fprintf(fdobjeto,"\tCMP #0,.R3\n");fprintf(fdobjeto,"\tBZ /E%d\n",eti);

}Comprueba si el resultado de las comparaciones lógicas es verdadero (R0=0) y si no es así salta al else.

Objeto_Cuerpo_Else(int eti) {fprintf(fdobjeto,"\t;cuerpo else %d\n",eti);fprintf(fdobjeto,"\tBR /E%d\n",eti+1);fprintf(fdobjeto,"\tE%d: NOP\n",eti);

}Salta al final del if y pone la etiqueta del comienzo del bloque else

Objeto_Console_Read() {fprintf(fdobjeto,"\t;console read\n");fprintf(fdobjeto,"\tININT .R0\n");fprintf(fdobjeto,"\tPUSH .R0\n");

}Lee de la consola un entero y lo mete en la pila.

Objeto_Asignacion_Vector(int n,int clase) {if (clase==0)

clase=-3;else

clase=-2;fprintf(fdobjeto,"\t;asignacion vector pos %d\n",n);fprintf(fdobjeto,"\tPOP .R0\n",n);fprintf(fdobjeto,"\tMOVE #%d[.IY],.IX\n",clase);fprintf(fdobjeto,"\tPOP .A\n");

Compiladores 44


fprintf(fdobjeto,"\tADD #%d,.A\n",n);fprintf(fdobjeto,"\tADD .IX,.A\n");fprintf(fdobjeto,"\tMOVE .R0,[.A]\n");

}Hace una asignación en un vector. El parámetro clase indica si la variable donde almacenar el valor es del método actual o de la clase actual y el parámetro n indica el desplazamiento dentro del registro de activación. Presupone que en la pila esta el desplazamiento del vector y el valor a asignar.

Objeto_Inicio_Vector() {fprintf(fdobjeto,"\t;inicio vector\n");

}Indica el inicio de un vector. Este terceto no necesita ninguna implementación en nuestro generador de código objeto. Sin embargo, hacemos esta función y ponemos un comentario para dar más claridad al código del compilador y al código generado.

Objeto_Fin_Vector() {fprintf(fdobjeto,"\t;Fin vector\n");

}Indica el final de un vector. Este terceto no necesita ninguna implementación en nuestro generador de código objeto. Sin embargo, hacemos esta función y ponemos un comentario para dar más claridad al código del compilador y al código generado.

Objeto_Valor_Variable_Vector(int n,int clase) {if (clase==0)

clase=-3;else

clase=-2;fprintf(fdobjeto,"\t;valor de variable vector\n");fprintf(fdobjeto,"\tMOVE #%d[.IY],.IX\n",clase);fprintf(fdobjeto,"\tPOP .A\n");fprintf(fdobjeto,"\tADD #%d,.A\n",n);fprintf(fdobjeto,"\tADD .IX,.A\n");fprintf(fdobjeto,"\tMOVE [.A],.R0\n",n);fprintf(fdobjeto,"\tPUSH .R0\n",n);

}Mete un valor de variable de un vector en la pila. El parámetro clase indica si la variable es del método actual o de la clase actual y el parámetro n indica el desplazamiento dentro del registro de activación. Almacena el valor en la pila. Presupone que en la pila está el desplazamiento a utilizar en el vector.

Compiladores 45


8 Generador de Errores

El módulo del generador de errores se encarga de almacenar los errores producidos en la compilación de un fichero, junto con los datos importantes de cada error, para que al finalizar el programa se visualicen todos los errores obtenidos. La estructura de un mensaje de error es el siguiente:

"fichero", Line X: Tipo Error: #id_error: mensaje_error

Primeramente indicamos el nombre del fichero que estamos compilando. A continuación la linea donde se ha producido el error. Seguidamente el tipo de error que se ha producido.

Los errores que pueden aparecer en la compilación pueden ser léxicos, sintácticos o semánticos. De ahí que el generador de errores los divida de esta forma: Lexer, Sintactic, Semantic.

Por ultimo, aparece el código del error (para posteriormente consultarlo a un posible manual de explicación de errores) y el respectivo mensaje de error.

Para utilizar el modulo del gestor de errores, se nos facilita la siguiente interfaz de usuario:

int Cuenta_Param(char * linea);Esta función devuelve el número de ocurrencias de %s en el parámetro línea. Es mediante %s como indicamos la posición de los parámetros optativos en el mensaje de error del compilador.

int Almacenar_Error(int cod, int linea, ...);Esta función se utiliza para almacenar un error producido en la compilación de un fichero. Se indica el código del error producido, la línea del fichero donde se ha producido dicho error, y sus posibles argumentos, dependiendo del tipo de error. Por ejemplo, para indicar que una clase esta declarada dos veces, necesitamos el nombre de esa clase para generar el error.

void Imprimir_Sumario();Imprime todo el conjunto de errores almacenados en la compilación del fichero. Los errores los imprime por Standard Error y uno debajo de otro.

char * Devuelve_Error(int cod);Función que dado un código de error devuelve su mensaje de error asociado, en el formato utilizado por el programa y sin hacer ningún tratamiento de los parámetros optativos.

char * Inserta_Parametro(char * cadena, char * param);Mediante esta función sustituiremos cada una de las ocurrencias de %s en el mensaje de error por su valor. El mensaje de error se nos pasará en cadena. El nuevo valor de la cadena retorna de la función. Se debe llamar tantas veces como parámetros optativos tenga el mensaje de error.

Compiladores 46


Los errores que puede generar el gestor de errores son los siguientes:

Léxicos:o “Token not valid”o “not end of Comment”o “not valid”o “ID not valid”

Sintacticos:o "class expected",o "token '{' expected",o "token '}' expected",o "token 'ID' expected",o "token ';' expected",o "token '[' expected",o "token ']' expected",o "'SentAsig' not valid",o "'SentMet' not valid",o "'Sentencia' not valid",o "token '(' expected",o "token ')' expected",o "token 'ID' or 'Tipo' expected",o "token 'Constant Integer' expected",o "'Primario' not valid",o "'Declaracion' not valid",o "'DeclAtributo' not valid",o "expected predefined type",o "token 'OL' expected",o "predefined type necessary"

Semánticos:o "not a main method in file",o "class %s already exists",o "not exists %s lemma",o "types not equal in Sentencia",o "predefined type in list",o "type var not class",o "expressions must be the same type"o "not exists that method", /* the method %s not exists" */o "types not equal in return",o "token %s already exists",o "not exists %s class",o "method %s is private",o "not exist %s atribute in class %s",o "atribute %s is not a list",o "not integer value in expression",o "innecesary '{ }' tokens for sentencias in %s",

Compiladores 47


o param %d of method %s does not have that type",o "differents types of list",o "value is not in atribute",o "expresion must be bool type",o "not bool o short type",o "bool type without correct OL",o "Terminos with differents types OR not SHORT",o "Factor with differents OR not SHORT",o "Primario not BOOL",o "Declaracion not valid with class",o "more than one main method not valid"o "not return val in method",o "types of asignation not equal"o "Var not inicializated"

Compiladores 48


9 Programa Principal

El programa principal se llama CSC (C Sharp Compiler). Este programa posee las siguientes opciones:

GNU C Sharp CompilerUsage: csc [options] <source_file> <output_file>Options: -h, --help display this help -s, --sin display sintactic debug

-t, --ter create intermiddle code -o, --obj create object objectPress any key to continue

De esta forma, se nos facilita la posibilidad de realizar un análisis sintáctico únicamente, o bien solo el paso a código intermedio, o bien solo el paso a código objeto, o bien todos los pasos. Tanto el código intermedio como el código final se escribe en dos ficheros cuyo nombre es el indicado como argumento output_file y con extensión diferente:

Output File SalidaCódigo Intermedio Salida.ter

Código Final Salida.ens

El programa principal se comunica con el analizador lexico mediante la función “read_token()” el cual va leyendo token a token y lo va devolviendo en una estructura de tipo TToken, el cual contiene toda la información necesaria para el uso de dicho token.

El programa principal se comunica con el analizador sintáctico y semántico (ambos códigos juntos) mediante la función “sintactico()”. Y estos a su vez se comunican con los generadores de código intermedio y final mediante las funcione vistas en los apartados anteriores.

Por ultimo, el programa principal, junto con el resto de analizadores y generadores, se comunican con el gestor de errores y la tabla de símbolos utilizando la interfaz de usuario explicada en anteriores apartados.

Compiladores 49


10 Pruebas

En todas las pruebas ejecutamos el compilador con la siguiente línea de comando:

Línea de comandos

C:\CSC\Debug> csc.exe –o ..\pruebas\pruebaX.cs salida

Y el resultado obtenido, a excepción de errores de compilación (que los mostraremos en cada prueba que genere error), es el siguiente:

Línea de comandos

Mostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\pruebaX.csFichero Salida: salidaCompilando...Compilacion finalizada correctamente.

10.1 Prueba 1

prueba101.cs

class clase{

short numero3;

void metodo1() {console.write("Estoy en el metodo1\n");

}

public static void Main(){

short numero1;short numero2;

metodo1();console.write("hola\n");numero1=4;numero2=5-2+3-7; //=-1numero3=6;numero1=numero3;numero1=numero2+5-1; //=3numero3=2-numero3-numero2+numero1+5; //=2-6-(-1)+3+5=5console.write("n1: {0}\nn2: {1}\nn3: {2}\n", numero1, numero2,

numero3);console.write("adios\n");

}}

Compiladores 50


salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 5Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 6Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 8Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 9Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 11Operacion: TR_RESTAURAR_ESTADO

Compiladores 51


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 13Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 14Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 16Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 19Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 20Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 21Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 22Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 23Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 7

Compiladores 52


Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 24Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 25Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 26Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 28Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 29Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 30Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 31Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 32Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 33Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 34Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 35Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1

Compiladores 53


------------------------------------------------Direccion: 36Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 37Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 38Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 39Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 40Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 41Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 42Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 43Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 44Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 45Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 46Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 47Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------

Compiladores 54


Direccion: 48Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 49Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 50Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 51Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 52Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 53Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 54Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 55Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 56Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 57Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 58Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 59Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 50Tipo: TR_NUMERO Valor: 50------------------------------------------------Direccion: 60

Compiladores 55


Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 13Tipo: TR_NUMERO Valor: 13------------------------------------------------Direccion: 61Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 62Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 63Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------Direccion: 64Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 65Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 66Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 67Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 68Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens

MOVE #INICIO_PILA,.SPBR /SALTOE1: NOP ;claseE2: NOP ;metodo

MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string Estoy en el metodo1\nWRSTR /E3BR /E4E3: DATA "Estoy en el metodo1\n"E4: NOP ;fin cuerpoMOVE .IY,.SP

Compiladores 56


RETE0:

MOVE .SP,.IY;metodo;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .SP,.R2 ;incio write string;cuerpo write string hola\nWRSTR /E5BR /E6E5: DATA "hola\n"E6: NOP ;fin cuerpo;asignacion informativa;valor inmediato 4MOVE #4,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]

Compiladores 57


;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;valor inmediato 2MOVE #2,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor inmediato 3MOVE #3,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;valor inmediato 7MOVE #7,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-3[.IY],.IXMOVE .R0,#1[.IX];asignacion informativa;valor inmediato 6MOVE #6,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0

Compiladores 58


PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 2MOVE #2,.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0

Compiladores 59


;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string n1: WRSTR /E7BR /E8E7: DATA "n1: "E8: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nn2: WRSTR /E9BR /E10E9: DATA "\nn2: "E10: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nn3: WRSTR /E11BR /E12E11: DATA "\nn3: "E12: NOP ;fin cuerpoWRINT #2[.IY] ;write short;cuerpo write string \nWRSTR /E13BR /E14E13: DATA "\n"E14: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .SP,.R2 ;incio write string;cuerpo write string adios\nWRSTR /E15BR /E16E15: DATA "adios\n"E16: NOP ;fin cuerpoMOVE .IY,.SPRET

SALTO:;Crear registro clase tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SP;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0PUSH #INICIO_PILACALL /E0

HALTINICIO_PILA:

Ejecución

Compiladores 60


Estoy en el metodo1holan1: 3n2: -1n3: 5adios

10.2 Prueba 2

prueba102.cs

class clase{

short numero3;



console.write("hola\n");numero1=4; //n1=4numero2=3; //n2=3numero1+=3+1; //n1=8numero1-=5-numero2; // =n1=8-2=6console.write("n1: {0}\n",numero1);console.write("adios\n");

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4

Compiladores 61


Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 5Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 6Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 7Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 8Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 9Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 10Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 11Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 12Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 13Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 14Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 15Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 16Operacion: TR_ASIGNACION

Compiladores 62


Tipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 18Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 19Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 20Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 21Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 22Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 23Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 24Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 25Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 26Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 27Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 28Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADA

Compiladores 63


Tipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 30Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 31Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 33Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 34Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 35Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens

MOVE #INICIO_PILA,.SPBR /SALTOE1: NOP ;claseE0:

MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string hola\nWRSTR /E2BR /E3E2: DATA "hola\n"E3: NOP ;fin cuerpo;asignacion informativa;valor inmediato 4MOVE #4,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IX

Compiladores 64


MOVE .R0,#0[.IX];asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-3[.IY],.IXMOVE .R0,#1[.IX];valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 3MOVE #3,.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IX

Compiladores 65


MOVE #0[.IX],.R0PUSH .R0;cuerpo write string n1: WRSTR /E4BR /E5E4: DATA "n1: "E5: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E6BR /E7E6: DATA "\n"E7: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .SP,.R2 ;incio write string;cuerpo write string adios\nWRSTR /E8BR /E9E8: DATA "adios\n"E9: NOP ;fin cuerpoMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

holan1: 6adios

10.3 Prueba 3

prueba103.cs

class clase{

short numero3;


Compiladores 66


}


}

public static void Main(){short n1;

n1=5;metodo1();n1+=3;console.write("Estoy en Main {0}\n",n1);metodo2();

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 5Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 6Operacion: TR_METODOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 7Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA

Compiladores 67


------------------------------------------------Direccion: 8Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 9Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 11Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 13Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 14Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 16Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 17Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 18Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 19Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------

Compiladores 68


Direccion: 20Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 21Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 22Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 23Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 24Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 25Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 26Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 27Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 28Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 30Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 31Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32

Compiladores 69


Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 33Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 34Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 35Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 36Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 37Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 38Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string Estoy en el metodo1\nWRSTR /E3BR /E4E3: DATA "Estoy en el metodo1\n"E4: NOP ;fin cuerpoMOVE .IY,.SPRET

E5: NOP ;metodoMOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string Estoy en el metodo2\nWRSTR /E6BR /E7E6: DATA "Estoy en el metodo2\n"E7: NOP ;fin cuerpoMOVE .IY,.SP

Compiladores 70


RETE0:

MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 3MOVE #3,.R0

Compiladores 71


PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en Main WRSTR /E8BR /E9E8: DATA "Estoy en Main "E9: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E10BR /E11E10: DATA "\n"E11: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E5CALL /E5DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5

Compiladores 72


POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Estoy en el metodo1Estoy en Main 8Estoy en el metodo2

10.4 Prueba 4

prueba104.cs

class clase{

short numero3;

short metodo1() {console.write("Estoy en el metodo1\n");numero3=10;return 5+numero3;

}


n1=metodo1();console.write("Estoy en Main {0}\n",n1);n1=3+metodo1()+1;console.write("Sigo en Main {0}\n",n1);

Compiladores 73


}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 5Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 6Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 7Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 8Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 9Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 10

Compiladores 74


Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 11Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 13Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 14Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 16Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 19Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 20Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 21Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 22Operacion: TR_INICIO_WRITE_STRING

Compiladores 75


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 23Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 24Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 25Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 26Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 27Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 28Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 30Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 31Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 32Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 33Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 34Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADA

Compiladores 76


Tipo: TR_NADA------------------------------------------------Direccion: 35Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 36Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 37Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 38Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 39Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 40Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 41Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 42Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 43Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 44Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 45Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 46Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA

Compiladores 77


------------------------------------------------Direccion: 47Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 48Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 49Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 50Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string Estoy en el metodo1\nWRSTR /E3BR /E4E3: DATA "Estoy en el metodo1\n"E4: NOP ;fin cuerpo;asignacion informativa;valor inmediato 10MOVE #10,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];valor inmediato 5MOVE #5,.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

Compiladores 78


E0:MOVE .SP,.IY;metodo;asignacion informativa;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en Main WRSTR /E5BR /E6

Compiladores 79


E5: DATA "Estoy en Main "E6: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E7BR /E8E7: DATA "\n"E8: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3

Compiladores 80


ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Sigo en Main WRSTR /E9BR /E10E9: DATA "Sigo en Main "E10: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E11BR /E12E11: DATA "\n"E12: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Estoy en el metodo1Estoy en Main 15Estoy en el metodo1Sigo en Main 19

Compiladores 81


10.5 Prueba 5

prueba105.cs

class clase{ short num;

short metodo1(short n1,short n2) {console.write("Metodo1: n1={0}, n2={1}\n",n1,n2);console.write("Metodo1: n1+n2={0}\n",n1+n2);return n1+n2;

}

public static void Main(){num=1;console.write("Estoy en Main\n");console.write("Resultado de metodo1: {0}\n",metodo1(5,6));metodo1(5+num,6);

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 5Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 6Operacion: TR_WRITE_STRING

Compiladores 82


Tipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 7Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 8Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 9Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 10Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 11Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 13Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 14Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 15Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 16Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 17Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 18Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11

Compiladores 83


Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 19Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 20Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 21Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 22Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 23Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 24Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 25Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 26Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 28Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 29Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 30Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 13Tipo: TR_NUMERO Valor: 13

Compiladores 84


------------------------------------------------Direccion: 31Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 33Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 34Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 35Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 36Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 37Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 38Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 39Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 40Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 41Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 42Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------

Compiladores 85


Direccion: 43Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 44Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 17Tipo: TR_NUMERO Valor: 17------------------------------------------------Direccion: 45Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 46Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 47Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 48Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 49Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 50Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 51Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 52Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 53Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 54Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 55

Compiladores 86


Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 56Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 57Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 58Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 59Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 60Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 61Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;cuerpo write string Metodo1: n1=WRSTR /E3BR /E4E3: DATA "Metodo1: n1="E4: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string , n2=WRSTR /E5

Compiladores 87


BR /E6E5: DATA ", n2="E6: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E7BR /E8E7: DATA "\n"E8: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;cuerpo write string Metodo1: n1+n2=WRSTR /E9BR /E10E9: DATA "Metodo1: n1+n2="E10: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E11BR /E12E11: DATA "\n"E12: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

E0:MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;asignacion pos 0POP .R0

Compiladores 88


MOVE #-2[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;cuerpo write string Estoy en Main\nWRSTR /E13BR /E14E13: DATA "Estoy en Main\n"E14: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 5MOVE #5,.R0PUSH .R0;valor inmediato 6MOVE #6,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado

Compiladores 89


;valor devueltoPUSH .R0;cuerpo write string Resultado de metodo1: WRSTR /E15BR /E16E15: DATA "Resultado de metodo1: "E16: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E17BR /E18E17: DATA "\n"E18: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 5MOVE #5,.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;valor inmediato 6MOVE #6,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9

Compiladores 90


POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Estoy en MainMetodo1: n1=5, n2=6Metodo1: n1+n2=11Resultado de metodo1: 11Metodo1: n1=6, n2=6Metodo1: n1+n2=12

10.6 Prueba 6

prueba106.cs

class prueba {

short var1,var2;

public void metodo1() {short p;var2=3;p=4;console.write("Estoy en el Metodo1 {0},{1}\n",var2,p);

Compiladores 91


}}

class clase{ short num1; prueba p1;

void metodo2() {short p;num1=5;p=6;console.write("Estoy en el Metodo2 {0},{1}\n",num1,p);

}

public static void Main(){short num2;

num1=1;num2=2;console.write("Empiezo en Main {0},{1}\n",num1,num2);p1.metodo1();console.write("Sigo en Main {0},{1}\n",num1,num2);metodo2();console.write("Termino en Main {0},{1}\n",num1,num2);

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 5Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1

Compiladores 92


Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 6Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 8Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 9Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 11Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 12Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 13Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 14Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 15Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 16Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 17Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA

Compiladores 93


------------------------------------------------Direccion: 18Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 19Operacion: TR_CLASETipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 20Operacion: TR_METODOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 21Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 22Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 23Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 24Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 25Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 26Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 27Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 28Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 29Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------

Compiladores 94


Direccion: 30Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 31Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 32Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 13Tipo: TR_NUMERO Valor: 13------------------------------------------------Direccion: 33Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 34Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------Direccion: 35Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 36Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 37Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 38Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 39Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 40Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 41Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 42

Compiladores 95


Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 43Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 44Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 45Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 46Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 47Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 17Tipo: TR_NUMERO Valor: 17------------------------------------------------Direccion: 48Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 49Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 19Tipo: TR_NUMERO Valor: 19------------------------------------------------Direccion: 50Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 51Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 21Tipo: TR_NUMERO Valor: 21------------------------------------------------Direccion: 52Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 53Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 54Operacion: TR_REGISTRO_METODO

Compiladores 96


Tipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 55Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 56Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 57Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 58Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 59Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 60Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 61Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 23Tipo: TR_NUMERO Valor: 23------------------------------------------------Direccion: 62Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 63Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 25Tipo: TR_NUMERO Valor: 25------------------------------------------------Direccion: 64Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 65Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 27Tipo: TR_NUMERO Valor: 27------------------------------------------------Direccion: 66Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADA

Compiladores 97


Tipo: TR_NADA------------------------------------------------Direccion: 67Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 68Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 69Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 70Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 71Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 72Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 73Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 74Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 75Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 29Tipo: TR_NUMERO Valor: 29------------------------------------------------Direccion: 76Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 77Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 31Tipo: TR_NUMERO Valor: 31------------------------------------------------Direccion: 78Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49

Compiladores 98


------------------------------------------------Direccion: 79Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 33Tipo: TR_NUMERO Valor: 33------------------------------------------------Direccion: 80Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 81Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 82Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 83Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 84Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 85Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-2[.IY],.IXMOVE .R0,#1[.IX];asignacion informativa;valor inmediato 4MOVE #4,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IX

Compiladores 99


MOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en el Metodo1 WRSTR /E3BR /E4E3: DATA "Estoy en el Metodo1 "E4: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E5BR /E6E5: DATA ","E6: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E7BR /E8E7: DATA "\n"E8: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET

E9: NOP ;claseE10: NOP ;metodo

MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 6MOVE #6,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en el Metodo2 WRSTR /E11BR /E12

Compiladores 100


E11: DATA "Estoy en el Metodo2 "E12: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E13BR /E14E13: DATA ","E14: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E15BR /E16E15: DATA "\n"E16: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET

E0:MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 2MOVE #2,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Empiezo en Main WRSTR /E17BR /E18E17: DATA "Empiezo en Main "E18: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E19BR /E20E19: DATA ","E20: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E21BR /E22E21: DATA "\n"E22: NOP ;fin cuerpo

Compiladores 101


MOVE .R2,.SP ;fin write string;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #1,.R0PUSH .A;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Sigo en Main WRSTR /E23BR /E24E23: DATA "Sigo en Main "E24: NOP ;fin cuerpoWRINT #0[.IY] ;write short

Compiladores 102


;cuerpo write string ,WRSTR /E25BR /E26E25: DATA ","E26: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E27BR /E28E27: DATA "\n"E28: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E10CALL /E10DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0

Compiladores 103


;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Termino en Main WRSTR /E29BR /E30E29: DATA "Termino en Main "E30: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E31BR /E32E31: DATA ","E32: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E33BR /E34E33: DATA "\n"E34: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Empiezo en Main 1,2Estoy en el Metodo1 3,4Sigo en Main 1,2Estoy en el Metodo2 5,6Termino en Main 5,2

10.7 Prueba 7

prueba107.cs

class prueba {

short var1,var2;

Compiladores 104


public short metodo1() {short p;var2=3;p=4;console.write("Estoy en el Metodo1 {0},{1}\n",var2,p); //3,4return var2+p; // 7

}}

class clase{ short num1; prueba p1;

short metodo2() {short p;num1=5;p=6;console.write("Estoy en el Metodo2 {0},{1}\n",num1,p); //5,6return num1+p; // 11

}

public static void Main(){short num2;

num1=1;num2=2;console.write("Empiezo en Main {0},{1}\n",num1,num2); // 1,2num2=p1.metodo1();console.write("Sigo en Main {0},{1}\n",num1,num2); // 1,7num2=metodo2();console.write("Termino en Main {0},{1}\n",num1,num2); //5,11

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4

Compiladores 105


Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 5Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 6Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 8Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 9Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 11Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 12Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 13Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 14Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 15Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 16Operacion: TR_WRITE_STRING

Compiladores 106


Tipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 17Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 19Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 20Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 21Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 22Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 23Operacion: TR_CLASETipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 24Operacion: TR_METODOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 25Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 26Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 27Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 28Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADA

Compiladores 107


Tipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 30Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 31Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 33Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 34Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 35Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 36Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 13Tipo: TR_NUMERO Valor: 13------------------------------------------------Direccion: 37Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 38Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------Direccion: 39Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 40Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0

Compiladores 108


------------------------------------------------Direccion: 41Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 42Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 43Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 44Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 45Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 46Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 47Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 48Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 49Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 50Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 51Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 52Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------

Compiladores 109


Direccion: 53Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 54Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 55Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 17Tipo: TR_NUMERO Valor: 17------------------------------------------------Direccion: 56Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 57Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 19Tipo: TR_NUMERO Valor: 19------------------------------------------------Direccion: 58Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 59Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 21Tipo: TR_NUMERO Valor: 21------------------------------------------------Direccion: 60Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 61Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 62Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 63Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 64Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 65

Compiladores 110


Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 66Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 67Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 68Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 69Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 70Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 71Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 72Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 23Tipo: TR_NUMERO Valor: 23------------------------------------------------Direccion: 73Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 74Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 25Tipo: TR_NUMERO Valor: 25------------------------------------------------Direccion: 75Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 76Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 27Tipo: TR_NUMERO Valor: 27------------------------------------------------Direccion: 77Operacion: TR_FIN_WRITE_STRING

Compiladores 111


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 78Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 79Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 80Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 81Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 82Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 83Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 84Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 85Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 86Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 87Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 88Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 89Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 29

Compiladores 112


Tipo: TR_NUMERO Valor: 29------------------------------------------------Direccion: 90Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 91Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 31Tipo: TR_NUMERO Valor: 31------------------------------------------------Direccion: 92Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 93Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 33Tipo: TR_NUMERO Valor: 33------------------------------------------------Direccion: 94Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 95Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 96Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 97Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 98Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 99Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


Compiladores 113


MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-2[.IY],.IXMOVE .R0,#1[.IX];asignacion informativa;valor inmediato 4MOVE #4,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en el Metodo1 WRSTR /E3BR /E4E3: DATA "Estoy en el Metodo1 "E4: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E5BR /E6E5: DATA ","E6: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E7BR /E8E7: DATA "\n"E8: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

Compiladores 114



MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 6MOVE #6,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en el Metodo2 WRSTR /E11BR /E12E11: DATA "Estoy en el Metodo2 "E12: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E13BR /E14E13: DATA ","E14: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E15BR /E16E15: DATA "\n"E16: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRET

Compiladores 115


MOVE .IY,.SPRET

E0:MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 2MOVE #2,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Empiezo en Main WRSTR /E17BR /E18E17: DATA "Empiezo en Main "E18: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E19BR /E20E19: DATA ","E20: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E21BR /E22E21: DATA "\n"E22: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;asignacion informativa;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7

Compiladores 116


PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #1,.R0PUSH .A;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Sigo en Main WRSTR /E23BR /E24E23: DATA "Sigo en Main "E24: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E25BR /E26E25: DATA ","E26: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E27

Compiladores 117


BR /E28E27: DATA "\n"E28: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;asignacion informativa;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E10CALL /E10DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variable

Compiladores 118


MOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Termino en Main WRSTR /E29BR /E30E29: DATA "Termino en Main "E30: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E31BR /E32E31: DATA ","E32: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E33BR /E34E33: DATA "\n"E34: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Empiezo en Main 1,2Estoy en el Metodo1 3,4Sigo en Main 1,7Estoy en el Metodo2 5,6Termino en Main 5,11

10.8 Prueba 8

prueba108.cs

class prueba {

public short numero1; public short numero2;

Compiladores 119


public short metodo1() {

console.write("Estoy en Metodo1: {0},{1}\n",numero1,numero2);return numero1+numero2;

}}

class prueba2 {

public short numero3;


console.write("Estoy en Metodo22: {0}\n",numero3);return 22;

}

public short metodo2(short n) {

console.write("Estoy en Metodo2: {0},{1}\n",numero3,n);return numero3+n;

}}

class clase{

short s1; prueba p1; prueba p3; prueba2 p2;

short metodo3() {return 5;

}

public static void Main(){short s2;

p1.numero1=2;p1.numero2=3;//s1=p1.numero1; //da error que no deberias1=2+p1.metodo1()+2; // 9s2=1+metodo3()+1; // 7console.write("Estoy en Main: {0},{1},{2},{3}\n",s1,s2,

p1.numero1,p1.numero2);p2.numero3=4;p2.metodo22(); //4p2.metodo2(5); //4,5console.write("Sigo en Main: {0},{1}\n",p2.numero3,s1); // 4,9console.write("Estoy en Main: {0},{1},{2},{3}\n",s1,s2,

p1.numero1,p1.numero2); }}

salida.ter

Compiladores 120


------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 5Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 6Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 7Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 8Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 9Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 10Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 11Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA

Compiladores 121


------------------------------------------------Direccion: 12Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 13Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 14Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 15Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 16Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 17Operacion: TR_CLASETipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 18Operacion: TR_METODOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 19Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 20Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 21Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 22Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 23Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 13Tipo: TR_NUMERO Valor: 13------------------------------------------------

Compiladores 122


Direccion: 24Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 25Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 22Tipo: TR_NUMERO Valor: 22------------------------------------------------Direccion: 26Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 28Operacion: TR_METODOTipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------Direccion: 29Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 30Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 31Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 32Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 33Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 34Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 18Tipo: TR_NUMERO Valor: 18------------------------------------------------Direccion: 35Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 36

Compiladores 123


Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 37Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 38Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 39Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 40Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 41Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 42Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 43Operacion: TR_CLASETipo: TR_NUMERO Valor: 22Tipo: TR_NUMERO Valor: 22------------------------------------------------Direccion: 44Operacion: TR_METODOTipo: TR_NUMERO Valor: 23Tipo: TR_NUMERO Valor: 23------------------------------------------------Direccion: 45Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 46Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 47Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 48Operacion: TR_METODO_MAIN

Compiladores 124


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 49Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 50Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 51Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 52Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 53Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 54Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 55Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 56Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 57Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 58Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 59Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 60Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2

Compiladores 125


Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 61Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 62Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 63Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 64Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 65Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 66Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 67Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 68Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 69Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 70Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 71Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 72Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 23Tipo: TR_NUMERO Valor: 23

Compiladores 126


------------------------------------------------Direccion: 73Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 74Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 75Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 76Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 77Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 78Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 79Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 80Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 81Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 82Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 83Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 84Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------

Compiladores 127


Direccion: 85Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 86Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 87Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 88Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 28Tipo: TR_NUMERO Valor: 28------------------------------------------------Direccion: 89Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 50Tipo: TR_NUMERO Valor: 50------------------------------------------------Direccion: 90Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 30Tipo: TR_NUMERO Valor: 30------------------------------------------------Direccion: 91Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 51Tipo: TR_NUMERO Valor: 51------------------------------------------------Direccion: 92Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 32Tipo: TR_NUMERO Valor: 32------------------------------------------------Direccion: 93Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 94Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 95Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 96Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 97

Compiladores 128


Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 98Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 99Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 100Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 101Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 102Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 103Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 104Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 105Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 106Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 107Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 108Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------Direccion: 109Operacion: TR_RESTAURAR_ESTADO

Compiladores 129


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 110Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 111Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 112Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 113Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------Direccion: 114Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 115Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 36Tipo: TR_NUMERO Valor: 36------------------------------------------------Direccion: 116Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 117Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 38Tipo: TR_NUMERO Valor: 38------------------------------------------------Direccion: 118Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 119Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 120Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 121Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0

Compiladores 130


Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 122Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 123Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 124Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 40Tipo: TR_NUMERO Valor: 40------------------------------------------------Direccion: 125Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 126Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 127Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 128Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 44Tipo: TR_NUMERO Valor: 44------------------------------------------------Direccion: 129Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 50Tipo: TR_NUMERO Valor: 50------------------------------------------------Direccion: 130Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 46Tipo: TR_NUMERO Valor: 46------------------------------------------------Direccion: 131Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 51Tipo: TR_NUMERO Valor: 51------------------------------------------------Direccion: 132Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 133Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA

Compiladores 131


------------------------------------------------Direccion: 134Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 135Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 136Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 137Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 138Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;cuerpo write string Estoy en Metodo1: WRSTR /E3BR /E4E3: DATA "Estoy en Metodo1: "E4: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E5BR /E6E5: DATA ","E6: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E7BR /E8E7: DATA "\n"

Compiladores 132


E8: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en Metodo22: WRSTR /E11BR /E12E11: DATA "Estoy en Metodo22: "E12: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E13BR /E14E13: DATA "\n"E14: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor inmediato 22MOVE #22,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

E15: NOP ;metodoMOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en Metodo2: WRSTR /E16BR /E17E16: DATA "Estoy en Metodo2: "

Compiladores 133


E17: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E18BR /E19E18: DATA ","E19: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E20BR /E21E20: DATA "\n"E21: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET


MOVE .SP,.IY;metodo;valor inmediato 5MOVE #5,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

E0:MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 2MOVE #2,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-2[.IY],.IXMOVE .R0,#1[.IX];asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 2POP .R0MOVE #-2[.IY],.IXMOVE .R0,#2[.IX];asignacion informativa;valor inmediato 2

Compiladores 134


MOVE #2,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #1,.R0PUSH .A;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;valor inmediato 2MOVE #2,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0

Compiladores 135


PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E23CALL /E23DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;valor inmediato 1

Compiladores 136


MOVE #1,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;cuerpo write string Estoy en Main: WRSTR /E24BR /E25E24: DATA "Estoy en Main: "E25: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E26BR /E27E26: DATA ","E27: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string ,WRSTR /E28BR /E29E28: DATA ","E29: NOP ;fin cuerpoWRINT #2[.IY] ;write short;cuerpo write string ,WRSTR /E30BR /E31E30: DATA ","E31: NOP ;fin cuerpoWRINT #3[.IY] ;write short;cuerpo write string \nWRSTR /E32BR /E33E32: DATA "\n"E33: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;asignacion informativa;valor inmediato 4MOVE #4,.R0

Compiladores 137


PUSH .R0;asignacion pos 5POP .R0MOVE #-2[.IY],.IXMOVE .R0,#5[.IX];guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estado;Crear registro metodo tamano 0MOVE .SP,.R0ADD #0,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #5,.R0PUSH .A;Salto a metodo misma clase etiqueta E10CALL /E10DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5

Compiladores 138


PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 5MOVE #5,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #5,.R0PUSH .A;Salto a metodo misma clase etiqueta E15CALL /E15DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #5[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Sigo en Main: WRSTR /E34BR /E35E34: DATA "Sigo en Main: "E35: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E36BR /E37E36: DATA ","E37: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \n

Compiladores 139


WRSTR /E38BR /E39E38: DATA "\n"E39: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;cuerpo write string Estoy en Main: WRSTR /E40BR /E41E40: DATA "Estoy en Main: "E41: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E42BR /E43E42: DATA ","E43: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string ,WRSTR /E44BR /E45E44: DATA ","E45: NOP ;fin cuerpoWRINT #2[.IY] ;write short;cuerpo write string ,WRSTR /E46BR /E47E46: DATA ","E47: NOP ;fin cuerpoWRINT #3[.IY] ;write short;cuerpo write string \nWRSTR /E48BR /E49E48: DATA "\n"E49: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET

SALTO:;Crear registro clase tamano 6MOVE .SP,.R0ADD #6,.SPMOVE .A,.SP;Crear registro metodo tamano 1MOVE .SP,.R0

Compiladores 140


ADD #1,.SPMOVE .A,.SPPUSH .R0PUSH #INICIO_PILACALL /E0

HALTINICIO_PILA:

Ejecución

Estoy en Metodo1: 2,3Estoy en Main: 9,7,2,3Estoy en Metodo22: 4Estoy en Metodo2: 4,5Sigo en Main: 4,9Estoy en Main: 9,7,2,3

10.9 Prueba 9

prueba109.cs

class prueba {



console.write("Estoy en Metodo1: {0}\n",numero1);return 1;

}}

class prueba2 {


public short metodo2(short n) {

console.write("Estoy en Metodo2: {0},{1}\n",n,numero2);return 2;

}}

class clase{

prueba p1; prueba2 p2;


p1.numero1=5;p2.numero2=6;

Compiladores 141


p2.metodo2(p1.numero1); //5,6console.write("Estoy en Main: {0},{1}\n",p1.numero1,p2.numero2);

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 5Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 6Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 7Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 8Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 9Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1

Compiladores 142


------------------------------------------------Direccion: 10Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 11Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_CLASETipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 13Operacion: TR_METODOTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 14Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 16Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 9Tipo: TR_NUMERO Valor: 9------------------------------------------------Direccion: 18Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 19Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 20Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 21Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 13Tipo: TR_NUMERO Valor: 13------------------------------------------------

Compiladores 143


Direccion: 22Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 23Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 24Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 25Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 26Operacion: TR_CLASETipo: TR_NUMERO Valor: 15Tipo: TR_NUMERO Valor: 15------------------------------------------------Direccion: 27Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 28Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 30Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 31Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 33Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 34

Compiladores 144


Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 35Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 36Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 37Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 38Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 39Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 40Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 41Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 42Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 43Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 44Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 45Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 46Operacion: TR_WRITE_SHORT

Compiladores 145


Tipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 47Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 18Tipo: TR_NUMERO Valor: 18------------------------------------------------Direccion: 48Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 49Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 50Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 51Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 52Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 53Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 54Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 55Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IX

Compiladores 146


MOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en Metodo1: WRSTR /E3BR /E4E3: DATA "Estoy en Metodo1: "E4: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E5BR /E6E5: DATA "\n"E6: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor inmediato 1MOVE #1,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Estoy en Metodo2: WRSTR /E9BR /E10E9: DATA "Estoy en Metodo2: "E10: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E11BR /E12E11: DATA ","E12: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E13BR /E14E13: DATA "\n"E14: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;valor inmediato 2MOVE #2,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

E15: NOP ;claseE0:

MOVE .SP,.IY;metodo

Compiladores 147


;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 6MOVE #6,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-2[.IY],.IXMOVE .R0,#1[.IX];guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #1,.R0PUSH .A;Salto a metodo misma clase etiqueta E8CALL /E8DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1

Compiladores 148


POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;cuerpo write string Estoy en Main: WRSTR /E16BR /E17E16: DATA "Estoy en Main: "E17: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string ,WRSTR /E18BR /E19E18: DATA ","E19: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E20BR /E21E20: DATA "\n"E21: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Estoy en Metodo2: 5,6Estoy en Main: 5,6

10.10 Prueba 10

Compiladores 149


prueba110.cs

class prueba {

public short numero1=1;


console.write("Estoy en Metodo1\n");return numero1;

}}

class clase{

short s1; prueba p1;


p1.numero1=5;s1=p1.numero1;

}}

class clase2{ short s1; prueba p1;

public static void prueba2(){

s1=p1.numero1; }}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1

Compiladores 150


------------------------------------------------Direccion: 4Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 5Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 6Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 8Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 9Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 11Operacion: TR_CLASETipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 12Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 13Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 14Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 15Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------

Compiladores 151


Direccion: 16Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 17Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 18Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 19Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 20Operacion: TR_CLASETipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 21Operacion: TR_METODOTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 22Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 23Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 24Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 25Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 26Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 28

Compiladores 152


Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 29Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens

MOVE #INICIO_PILA,.SPBR /SALTOE1: NOP ;clase

;asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]

E2: NOP ;metodoMOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string Estoy en Metodo1\nWRSTR /E3BR /E4E3: DATA "Estoy en Metodo1\n"E4: NOP ;fin cuerpo;valor de variableMOVE #-2[.IY],.IXMOVE #0[.IX],.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

E5: NOP ;claseE0:

MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-2[.IY],.IXMOVE .R0,#1[.IX];asignacion informativa;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX]

Compiladores 153


MOVE .IY,.SPRET


MOVE .SP,.IY;metodo;asignacion informativa;valor de variableMOVE #-2[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-2[.IY],.IXMOVE .R0,#0[.IX]MOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Esta prueba no imprime nada por pantalla

10.11 Prueba 11

prueba111.cs

class clase{

public static void Main(){short num;

num=5;

if (num==1 || num==2 || num==3 ||num == 4) { //if (num==1 || num==2) {

console.write("hola1\n");}else

console.write("adios1\n");

if (num==5) {

Compiladores 154


console.write("hola2\n");}

if (num==1) { console.write("adios2\n");

}

num=3;return;

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 5Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 6Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 8Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1

Compiladores 155


------------------------------------------------Direccion: 9Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 10Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 11Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 12Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 13Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 14Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 15Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 16Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 18Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 19Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 20Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------

Compiladores 156


Direccion: 21Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 12Tipo: TR_NUMERO Valor: 12------------------------------------------------Direccion: 22Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 23Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 24Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 14Tipo: TR_NUMERO Valor: 14------------------------------------------------Direccion: 25Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 26Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 28Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 29Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 30Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 31Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 33

Compiladores 157


Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 34Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 35Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 36Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 37Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 38Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 39Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 22Tipo: TR_NUMERO Valor: 22------------------------------------------------Direccion: 40Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 41Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 42Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 22Tipo: TR_NUMERO Valor: 22------------------------------------------------Direccion: 43Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 22Tipo: TR_NUMERO Valor: 22------------------------------------------------Direccion: 44Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 45Operacion: TR_VALOR_INMEDIATO

Compiladores 158


Tipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 46Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 47Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 48Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 49Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 50Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 51Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 52Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 5MOVE #5,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0

Compiladores 159


PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 4POP .R1POP .R0CMP .R0,.R1BZ /E4BR /E5E4: MOVE #1,.R3; E5: NOP; fin comp igual;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 2MOVE #2,.R0PUSH .R0;comp igual op 1 eti 6POP .R1POP .R0CMP .R0,.R1BZ /E6BR /E7E6: MOVE #1,.R3; E7: NOP; fin comp igual;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 3MOVE #3,.R0PUSH .R0;comp igual op 1 eti 8POP .R1POP .R0CMP .R0,.R1BZ /E8BR /E9E8: MOVE #1,.R3; E9: NOP; fin comp igual;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 4MOVE #4,.R0PUSH .R0;comp igual op 1 eti 10POP .R1POP .R0CMP .R0,.R1BZ /E10BR /E11E10: MOVE #1,.R3; E11: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E2MOVE .SP,.R2 ;incio write string

Compiladores 160


;cuerpo write string hola1\nWRSTR /E12BR /E13E12: DATA "hola1\n"E13: NOP ;fin cuerpo;cuerpo else 2BR /E3E2: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string adios1\nWRSTR /E14BR /E15E14: DATA "adios1\n"E15: NOP ;fin cuerpoE3: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0;comp igual op 1 eti 18POP .R1POP .R0CMP .R0,.R1BZ /E18BR /E19E18: MOVE #1,.R3; E19: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E16MOVE .SP,.R2 ;incio write string;cuerpo write string hola2\nWRSTR /E20BR /E21E20: DATA "hola2\n"E21: NOP ;fin cuerpo;cuerpo else 16BR /E17E16: NOPE17: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 24POP .R1POP .R0CMP .R0,.R1BZ /E24BR /E25E24: MOVE #1,.R3; E25: NOP; fin comp igual;cuerpo if

Compiladores 161


CMP #0,.R3BZ /E22MOVE .SP,.R2 ;incio write string;cuerpo write string adios2\nWRSTR /E26BR /E27E26: DATA "adios2\n"E27: NOP ;fin cuerpo;cuerpo else 22BR /E23E22: NOPE23: NOP; fin if;asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .IY,.SPRETMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

adios1hola2

10.12 Prueba 12

prueba112.cs

class clase{


num=4;//num=0-3;

Compiladores 162


if (num==1)console.write("num es igual a 1\n");

else if (num==2)console.write("num es igual a 2\n");




elseconsole.write("num es >5 o <1\n");

num=3;

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 5Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 6Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7

Compiladores 163


Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 8Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 9Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 10Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 11Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 13Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 14Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 16Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 17Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 18Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 19Operacion: TR_INICIO_WRITE_STRING

Compiladores 164


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 20Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 12Tipo: TR_NUMERO Valor: 12------------------------------------------------Direccion: 21Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 22Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 23Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 24Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 25Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 26Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 14Tipo: TR_NUMERO Valor: 14------------------------------------------------Direccion: 27Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 28Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 18Tipo: TR_NUMERO Valor: 18------------------------------------------------Direccion: 29Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 14Tipo: TR_NUMERO Valor: 14------------------------------------------------Direccion: 30Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 31Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0

Compiladores 165


Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 32Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 33Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 34Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 35Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 36Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 37Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 38Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 39Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 40Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 41Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 42Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 43Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA

Compiladores 166


------------------------------------------------Direccion: 44Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 30Tipo: TR_NUMERO Valor: 30------------------------------------------------Direccion: 45Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 46Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 47Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 32Tipo: TR_NUMERO Valor: 32------------------------------------------------Direccion: 48Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 49Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 50Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 14Tipo: TR_NUMERO Valor: 14------------------------------------------------Direccion: 51Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 52Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 53Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 54Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 55Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------

Compiladores 167


Direccion: 56Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 57Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 58Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 59Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 60Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 4MOVE #4,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 4POP .R1POP .R0CMP .R0,.R1BZ /E4BR /E5E4: MOVE #1,.R3; E5: NOP; fin comp igual;cuerpo ifCMP #0,.R3

Compiladores 168


BZ /E2MOVE .SP,.R2 ;incio write string;cuerpo write string num es igual a 1\nWRSTR /E6BR /E7E6: DATA "num es igual a 1\n"E7: NOP ;fin cuerpo;cuerpo else 2BR /E3E2: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 2MOVE #2,.R0PUSH .R0;comp igual op 1 eti 10POP .R1POP .R0CMP .R0,.R1BZ /E10BR /E11E10: MOVE #1,.R3; E11: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E8MOVE .SP,.R2 ;incio write string;cuerpo write string num es igual a 2\nWRSTR /E12BR /E13E12: DATA "num es igual a 2\n"E13: NOP ;fin cuerpo;cuerpo else 8BR /E9E8: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 3MOVE #3,.R0PUSH .R0;comp igual op 1 eti 16POP .R1POP .R0CMP .R0,.R1BZ /E16BR /E17E16: MOVE #1,.R3; E17: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E14MOVE .SP,.R2 ;incio write string;cuerpo write string num es igual a 3\nWRSTR /E18BR /E19

Compiladores 169


E18: DATA "num es igual a 3\n"E19: NOP ;fin cuerpo;cuerpo else 14BR /E15E14: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 4MOVE #4,.R0PUSH .R0;comp igual op 1 eti 22POP .R1POP .R0CMP .R0,.R1BZ /E22BR /E23E22: MOVE #1,.R3; E23: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E20MOVE .SP,.R2 ;incio write string;cuerpo write string num es igual a 4\nWRSTR /E24BR /E25E24: DATA "num es igual a 4\n"E25: NOP ;fin cuerpo;cuerpo else 20BR /E21E20: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0;comp igual op 1 eti 28POP .R1POP .R0CMP .R0,.R1BZ /E28BR /E29E28: MOVE #1,.R3; E29: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E26MOVE .SP,.R2 ;incio write string;cuerpo write string num es igual a 5\nWRSTR /E30BR /E31E30: DATA "num es igual a 5\n"E31: NOP ;fin cuerpo;cuerpo else 26BR /E27E26: NOP

Compiladores 170


MOVE .SP,.R2 ;incio write string;cuerpo write string num es >5 o <1\nWRSTR /E32BR /E33E32: DATA "num es >5 o <1\n"E33: NOP ;fin cuerpoE27: NOP; fin ifE21: NOP; fin ifE15: NOP; fin ifE9: NOP; fin ifE3: NOP; fin if;asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

num es igual a 4

10.13 Prueba 13

prueba113.cs

class clase{


num=4;

if (num==4) //verdaderoconsole.write("verdadero\n");

else

Compiladores 171


console.write("falso\n");

if (num>5) //falsoconsole.write("verdadero\n");


if (num<5) //verdaderoconsole.write("verdadero\n");


if (num!=4) //falseconsole.write("verdadero\n");


if (num>=4) //verdareroconsole.write("verdadero\n");


if (num<=10) //verdareroconsole.write("verdadero\n");


}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 5

Compiladores 172


Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 6Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 8Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 9Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 10Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 11Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 13Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 14Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 16Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 17Operacion: TR_INICIO_IF

Compiladores 173


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 19Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 20Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 21Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 22Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 23Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 14Tipo: TR_NUMERO Valor: 14------------------------------------------------Direccion: 24Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 25Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 26Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 27Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 28Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0

Compiladores 174


Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 30Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 31Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 32Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 18Tipo: TR_NUMERO Valor: 18------------------------------------------------Direccion: 33Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 34Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 22Tipo: TR_NUMERO Valor: 22------------------------------------------------Direccion: 35Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 18Tipo: TR_NUMERO Valor: 18------------------------------------------------Direccion: 36Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 37Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 38Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 18Tipo: TR_NUMERO Valor: 18------------------------------------------------Direccion: 39Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 40Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 41Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4

Compiladores 175


------------------------------------------------Direccion: 42Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 43Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 44Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 45Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 30Tipo: TR_NUMERO Valor: 30------------------------------------------------Direccion: 46Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 47Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 48Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 32Tipo: TR_NUMERO Valor: 32------------------------------------------------Direccion: 49Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 26Tipo: TR_NUMERO Valor: 26------------------------------------------------Direccion: 50Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 51Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 52Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 53Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------

Compiladores 176


Direccion: 54Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------Direccion: 55Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 56Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 38Tipo: TR_NUMERO Valor: 38------------------------------------------------Direccion: 57Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------Direccion: 58Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 59Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 40Tipo: TR_NUMERO Valor: 40------------------------------------------------Direccion: 60Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------Direccion: 61Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 62Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 63Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 64Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 65Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 66

Compiladores 177


Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 67Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 46Tipo: TR_NUMERO Valor: 46------------------------------------------------Direccion: 68Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 69Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 70Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 71Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 72Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 73Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 74Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 75Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 76Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


Compiladores 178


E0:MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 4MOVE #4,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 4MOVE #4,.R0PUSH .R0;comp igual op 1 eti 4POP .R1POP .R0CMP .R0,.R1BZ /E4BR /E5E4: MOVE #1,.R3; E5: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E2MOVE .SP,.R2 ;incio write string;cuerpo write string verdadero\nWRSTR /E6BR /E7E6: DATA "verdadero\n"E7: NOP ;fin cuerpo;cuerpo else 2BR /E3E2: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string falso\nWRSTR /E8BR /E9E8: DATA "falso\n"E9: NOP ;fin cuerpoE3: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0;comp igual op 3 eti 12POP .R1POP .R0CMP .R0,.R1BZ /E13BP /E12BR /E13E12: MOVE #1,.R3;

Compiladores 179


E13: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E10MOVE .SP,.R2 ;incio write string;cuerpo write string verdadero\nWRSTR /E14BR /E15E14: DATA "verdadero\n"E15: NOP ;fin cuerpo;cuerpo else 10BR /E11E10: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string falso\nWRSTR /E16BR /E17E16: DATA "falso\n"E17: NOP ;fin cuerpoE11: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 5MOVE #5,.R0PUSH .R0;comp igual op 4 eti 20POP .R1POP .R0CMP .R0,.R1BN /E20BR /E21E20: MOVE #1,.R3; E21: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E18MOVE .SP,.R2 ;incio write string;cuerpo write string verdadero\nWRSTR /E22BR /E23E22: DATA "verdadero\n"E23: NOP ;fin cuerpo;cuerpo else 18BR /E19E18: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string falso\nWRSTR /E24BR /E25E24: DATA "falso\n"E25: NOP ;fin cuerpoE19: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 4

Compiladores 180


MOVE #4,.R0PUSH .R0;comp igual op 2 eti 28POP .R1POP .R0CMP .R0,.R1BNZ /E28BR /E29E28: MOVE #1,.R3; E29: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E26MOVE .SP,.R2 ;incio write string;cuerpo write string verdadero\nWRSTR /E30BR /E31E30: DATA "verdadero\n"E31: NOP ;fin cuerpo;cuerpo else 26BR /E27E26: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string falso\nWRSTR /E32BR /E33E32: DATA "falso\n"E33: NOP ;fin cuerpoE27: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 4MOVE #4,.R0PUSH .R0;comp igual op 5 eti 36POP .R1POP .R0CMP .R0,.R1BP /E36BR /E37E36: MOVE #1,.R3; E37: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E34MOVE .SP,.R2 ;incio write string;cuerpo write string verdadero\nWRSTR /E38BR /E39E38: DATA "verdadero\n"E39: NOP ;fin cuerpo;cuerpo else 34BR /E35E34: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string falso\nWRSTR /E40BR /E41

Compiladores 181


E40: DATA "falso\n"E41: NOP ;fin cuerpoE35: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 10MOVE #10,.R0PUSH .R0;comp igual op 6 eti 44POP .R1POP .R0CMP .R0,.R1BN /E44BZ /E44BR /E45E44: MOVE #1,.R3; E45: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E42MOVE .SP,.R2 ;incio write string;cuerpo write string verdadero\nWRSTR /E46BR /E47E46: DATA "verdadero\n"E47: NOP ;fin cuerpo;cuerpo else 42BR /E43E42: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string falso\nWRSTR /E48BR /E49E48: DATA "falso\n"E49: NOP ;fin cuerpoE43: NOP; fin ifMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

verdaderofalsoverdadero

Compiladores 182


falsoverdaderoverdadero

10.14 Prueba 14

prueba114.cs

class clase{


Console.Write("Escribe un numero: ");num=Console.Read();

Console.Write("Has escrito un {0}\n",num);

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 5Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA

Compiladores 183


------------------------------------------------Direccion: 6Operacion: TR_CONSOLE_READTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 8Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 9Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 10Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 11Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 12Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 13Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 14Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 15Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 16Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------

Compiladores 184


Direccion: 18Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string Escribe un numero: WRSTR /E2BR /E3E2: DATA "Escribe un numero: "E3: NOP ;fin cuerpo;asignacion informativa;console readININT .R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Has escrito un WRSTR /E4BR /E5E4: DATA "Has escrito un "E5: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E6BR /E7E6: DATA "\n"E7: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALT

Compiladores 185


INICIO_PILA:

Ejecución

Escribe un numero: 2334Has escrito un 2334

10.15 Prueba 15

prueba115.cs

class aritmetica{

private short mulaux(short a,short b){

if (b==1)return a;

else if (b==0)return 0;

elsereturn a+mulaux(a,b-1);

}

public short mul(short a,short b){//Console.Write("MUL: {0},{1}\n",a,b);if (a>=0) // a es positivo

if (b>=0) // b es positivoreturn mulaux(a,b);

else // b es negativoreturn 0-mulaux(a,0-b);

else // a es negativoif (b>=0) // b es positivo

return 0-mulaux(0-a,b);else // b es negativo

return mulaux(0-a,0-b);

}

private short divaux(short a,short b){

if (b==1)return a;

else if (b>a)return 0;

elsereturn 1+divaux(a-b,b);

}

public short div(short a,short b){//Console.Write("DIV: {0},{1}\n",a,b);if (a>=0) // a es positivo

if (b>=0) // b es positivoreturn divaux(a,b);

Compiladores 186


else // b es negativoreturn 0-divaux(a,0-b);

else // a es negativoif (b>=0) // b es positivo

return 0-divaux(0-a,b);else // b es negativo

return divaux(0-a,0-b);

}

public short mod(short a,short b){//Console.Write("MOD: {0},{1}\n",a,b);return a-mul(div(a,b),b);

}

public short fact(short a){//Console.Write("factorial: {0}\n",a);if (a<0) {

Console.Write("ERROR: factorial negativo");return -1;

}else if (a==0 || a==1)

return 1;else

return mul(a,fact(a-1));

}}

class principal{

aritmetica o;

public static void Main(){short n1;short n2;short op;

Console.Write("\tCALCULADORA\n");Console.Write("Operacines:\n\n");Console.Write("1 .. Multiplicar\n");Console.Write("2 .. Dividir\n");Console.Write("3 .. Resto\n");Console.Write("4 .. Factorial\n");Console.Write("\nIntroduzca la operacion: ");op = Console.Read();

Console.Write("Introduzca el Operando1: ");n1 = Console.Read();if (op!=4) {

Console.Write("Introduzca el Operando2: ");n2 = Console.Read();

}

if (op==1)n1=o.mul(n1,n2);

else if (op==2)n1=o.div(n1,n2);

else if (op==3)

Compiladores 187


n1=o.mod(n1,n2);else if (op==4)

n1=o.fact(n1);else {

Console.Write("Operacion no definida\n");op=0;

}

if (op!=0) Console.Write("Resultado: {0}\n",n1); }}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 3Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 5Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 6Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 7Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 8Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0

Compiladores 188


Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 9Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 11Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 12Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 13Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 14Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 15Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 16Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 19Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 20Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA

Compiladores 189


------------------------------------------------Direccion: 21Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 22Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 23Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 24Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 25Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 26Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 28Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 29Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 30Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 31Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 32Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------

Compiladores 190


Direccion: 33Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 34Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 7Tipo: TR_NUMERO Valor: 7------------------------------------------------Direccion: 35Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 36Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 37Operacion: TR_METODOTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 38Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 39Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 40Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 41Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 42Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 12Tipo: TR_NUMERO Valor: 12------------------------------------------------Direccion: 43Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 44Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 45

Compiladores 191


Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 46Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 47Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 48Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 49Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 50Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 51Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 52Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 53Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 54Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 55Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 56Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 57Operacion: TR_METODO_RET

Compiladores 192


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 58Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 59Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 60Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 61Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 62Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 63Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 64Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 65Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 66Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 67Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 68Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 69Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2

Compiladores 193


Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 70Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 71Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 72Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 73Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 74Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 16Tipo: TR_NUMERO Valor: 16------------------------------------------------Direccion: 75Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 12Tipo: TR_NUMERO Valor: 12------------------------------------------------Direccion: 76Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 77Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 78Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 79Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 80Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 81Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0

Compiladores 194


------------------------------------------------Direccion: 82Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 83Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 84Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 85Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 86Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 87Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 88Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 89Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 90Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 91Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 92Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 93Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------

Compiladores 195


Direccion: 94Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 95Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 96Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 97Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 98Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 99Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 100Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 101Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 102Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 103Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 104Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 105Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 106

Compiladores 196


Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 107Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 108Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 109Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 110Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 111Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 20Tipo: TR_NUMERO Valor: 20------------------------------------------------Direccion: 112Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 12Tipo: TR_NUMERO Valor: 12------------------------------------------------Direccion: 113Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 114Operacion: TR_METODOTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 115Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 116Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 117Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 118Operacion: TR_COMP_IGUAL

Compiladores 197


Tipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 119Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 25Tipo: TR_NUMERO Valor: 25------------------------------------------------Direccion: 120Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 121Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 122Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 25Tipo: TR_NUMERO Valor: 25------------------------------------------------Direccion: 123Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 124Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 125Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 126Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 127Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 29Tipo: TR_NUMERO Valor: 29------------------------------------------------Direccion: 128Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 129Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 130Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 29

Compiladores 198


Tipo: TR_NUMERO Valor: 29------------------------------------------------Direccion: 131Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 132Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 133Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 134Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 135Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 136Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 137Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 138Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 139Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 140Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 141Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 142Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA

Compiladores 199


------------------------------------------------Direccion: 143Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 144Operacion: TR_SUMATipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 145Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 146Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 29Tipo: TR_NUMERO Valor: 29------------------------------------------------Direccion: 147Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 25Tipo: TR_NUMERO Valor: 25------------------------------------------------Direccion: 148Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 149Operacion: TR_METODOTipo: TR_NUMERO Valor: 33Tipo: TR_NUMERO Valor: 33------------------------------------------------Direccion: 150Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 151Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 152Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 153Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 154Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------

Compiladores 200


Direccion: 155Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 156Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 157Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 158Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 159Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 38Tipo: TR_NUMERO Valor: 38------------------------------------------------Direccion: 160Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 161Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 162Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 163Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 164Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 165Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 166Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 167

Compiladores 201


Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 168Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 169Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 170Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 38Tipo: TR_NUMERO Valor: 38------------------------------------------------Direccion: 171Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 172Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 173Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 174Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 175Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 176Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 177Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 178Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 179Operacion: TR_REGISTRO_METODO

Compiladores 202


Tipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 180Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 181Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 182Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 183Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 184Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 185Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 186Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 38Tipo: TR_NUMERO Valor: 38------------------------------------------------Direccion: 187Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------Direccion: 188Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 189Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 190Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 191Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 5

Compiladores 203


Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 192Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 193Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 194Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 195Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 196Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 197Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 198Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 199Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 200Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 201Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 202Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 203Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24

Compiladores 204


------------------------------------------------Direccion: 204Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 205Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 206Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 207Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 208Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 209Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 210Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 211Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 212Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 213Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 214Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 215Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------

Compiladores 205


Direccion: 216Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 217Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 218Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 219Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 220Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 24Tipo: TR_NUMERO Valor: 24------------------------------------------------Direccion: 221Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 222Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 223Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 42Tipo: TR_NUMERO Valor: 42------------------------------------------------Direccion: 224Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 34Tipo: TR_NUMERO Valor: 34------------------------------------------------Direccion: 225Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 226Operacion: TR_METODOTipo: TR_NUMERO Valor: 46Tipo: TR_NUMERO Valor: 46------------------------------------------------Direccion: 227Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 228

Compiladores 206


Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 229Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 230Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 231Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 232Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 233Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 234Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 235Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 236Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 237Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 33Tipo: TR_NUMERO Valor: 33------------------------------------------------Direccion: 238Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 239Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 240Operacion: TR_VALOR_VARIABLE

Compiladores 207


Tipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 241Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 242Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 243Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 244Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 245Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 246Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 247Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 248Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 249Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 250Operacion: TR_METODOTipo: TR_NUMERO Valor: 47Tipo: TR_NUMERO Valor: 47------------------------------------------------Direccion: 251Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 252Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0

Compiladores 208


Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 253Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 254Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 255Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 256Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 257Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 52Tipo: TR_NUMERO Valor: 52------------------------------------------------Direccion: 258Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 259Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 260Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 261Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 262Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 263Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 264Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1

Compiladores 209


------------------------------------------------Direccion: 265Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 266Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 267Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 268Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 54Tipo: TR_NUMERO Valor: 54------------------------------------------------Direccion: 269Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 270Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 271Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 54Tipo: TR_NUMERO Valor: 54------------------------------------------------Direccion: 272Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 273Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 274Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 275Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 276Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------

Compiladores 210


Direccion: 277Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 278Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 279Operacion: TR_SUMATipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 280Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 281Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 282Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 283Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 47Tipo: TR_NUMERO Valor: 47------------------------------------------------Direccion: 284Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 285Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 286Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 287Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 288Operacion: TR_ACTIVAR_MISMA_CLASETipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 289

Compiladores 211


Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 290Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 291Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 292Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 54Tipo: TR_NUMERO Valor: 54------------------------------------------------Direccion: 293Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 294Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 295Operacion: TR_CLASETipo: TR_NUMERO Valor: 60Tipo: TR_NUMERO Valor: 60------------------------------------------------Direccion: 296Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 297Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 298Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 61Tipo: TR_NUMERO Valor: 61------------------------------------------------Direccion: 299Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 300Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 63Tipo: TR_NUMERO Valor: 63------------------------------------------------Direccion: 301Operacion: TR_INICIO_WRITE_STRING

Compiladores 212


Tipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 302Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 65Tipo: TR_NUMERO Valor: 65------------------------------------------------Direccion: 303Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 304Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 67Tipo: TR_NUMERO Valor: 67------------------------------------------------Direccion: 305Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 306Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 69Tipo: TR_NUMERO Valor: 69------------------------------------------------Direccion: 307Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 308Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 71Tipo: TR_NUMERO Valor: 71------------------------------------------------Direccion: 309Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 310Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 73Tipo: TR_NUMERO Valor: 73------------------------------------------------Direccion: 311Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 312Operacion: TR_CONSOLE_READTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 313Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 2

Compiladores 213


Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 314Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 315Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 75Tipo: TR_NUMERO Valor: 75------------------------------------------------Direccion: 316Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 317Operacion: TR_CONSOLE_READTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 318Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 319Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 320Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 321Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 322Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 323Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 77Tipo: TR_NUMERO Valor: 77------------------------------------------------Direccion: 324Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 325Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 81Tipo: TR_NUMERO Valor: 81

Compiladores 214


------------------------------------------------Direccion: 326Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 327Operacion: TR_CONSOLE_READTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 328Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 329Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 77Tipo: TR_NUMERO Valor: 77------------------------------------------------Direccion: 330Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 77Tipo: TR_NUMERO Valor: 77------------------------------------------------Direccion: 331Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 332Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 333Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 334Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 335Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 83Tipo: TR_NUMERO Valor: 83------------------------------------------------Direccion: 336Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 337Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------

Compiladores 215


Direccion: 338Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 339Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 340Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 341Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 342Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 343Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 344Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 345Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 346Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 347Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 348Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 349Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 83Tipo: TR_NUMERO Valor: 83------------------------------------------------Direccion: 350

Compiladores 216


Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 351Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 352Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 353Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 354Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 87Tipo: TR_NUMERO Valor: 87------------------------------------------------Direccion: 355Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 356Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 357Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 358Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 359Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 360Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 361Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 362Operacion: TR_ACTIVAR_REGISTRO_CLASE

Compiladores 217


Tipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 363Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 33Tipo: TR_NUMERO Valor: 33------------------------------------------------Direccion: 364Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 365Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 366Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 367Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 368Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 87Tipo: TR_NUMERO Valor: 87------------------------------------------------Direccion: 369Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 370Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 371Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 372Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 373Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 91Tipo: TR_NUMERO Valor: 91------------------------------------------------Direccion: 374Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADA

Compiladores 218


Tipo: TR_NADA------------------------------------------------Direccion: 375Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 376Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 377Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 378Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 379Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 380Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 381Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 382Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 46Tipo: TR_NUMERO Valor: 46------------------------------------------------Direccion: 383Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 384Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 385Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 386Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0

Compiladores 219


------------------------------------------------Direccion: 387Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 91Tipo: TR_NUMERO Valor: 91------------------------------------------------Direccion: 388Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 389Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 390Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 391Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 392Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 95Tipo: TR_NUMERO Valor: 95------------------------------------------------Direccion: 393Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 394Operacion: TR_GUARDAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 395Operacion: TR_INICIO_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 396Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 397Operacion: TR_FIN_ARGUMENTOSTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 398Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------

Compiladores 220


Direccion: 399Operacion: TR_ACTIVAR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 400Operacion: TR_SALTO_METODOTipo: TR_NUMERO Valor: 47Tipo: TR_NUMERO Valor: 47------------------------------------------------Direccion: 401Operacion: TR_RESTAURAR_ESTADOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 402Operacion: TR_VALOR_DEVUELTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 403Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 404Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 405Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 95Tipo: TR_NUMERO Valor: 95------------------------------------------------Direccion: 406Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 407Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 99Tipo: TR_NUMERO Valor: 99------------------------------------------------Direccion: 408Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 409Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 410Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 411

Compiladores 221


Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 95Tipo: TR_NUMERO Valor: 95------------------------------------------------Direccion: 412Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 91Tipo: TR_NUMERO Valor: 91------------------------------------------------Direccion: 413Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 87Tipo: TR_NUMERO Valor: 87------------------------------------------------Direccion: 414Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 83Tipo: TR_NUMERO Valor: 83------------------------------------------------Direccion: 415Operacion: TR_INICIO_IFTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 416Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 417Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 418Operacion: TR_COMP_IGUALTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 419Operacion: TR_CUERPO_IFTipo: TR_NUMERO Valor: 101Tipo: TR_NUMERO Valor: 101------------------------------------------------Direccion: 420Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 421Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 422Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 105Tipo: TR_NUMERO Valor: 105------------------------------------------------Direccion: 423Operacion: TR_WRITE_SHORT

Compiladores 222


Tipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 424Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 107Tipo: TR_NUMERO Valor: 107------------------------------------------------Direccion: 425Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 426Operacion: TR_CUERPO_ELSETipo: TR_NUMERO Valor: 101Tipo: TR_NUMERO Valor: 101------------------------------------------------Direccion: 427Operacion: TR_FIN_IFTipo: TR_NUMERO Valor: 101Tipo: TR_NUMERO Valor: 101------------------------------------------------Direccion: 428Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 429Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 430Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 431Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 432Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodo

Compiladores 223


MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 5POP .R1POP .R0CMP .R0,.R1BZ /E5BR /E6E5: MOVE #1,.R3; E6: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E3;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 3BR /E4E3: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 1 eti 9POP .R1POP .R0CMP .R0,.R1BZ /E9BR /E10E9: MOVE #1,.R3; E10: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E7;valor inmediato 0MOVE #0,.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 7BR /E8E7: NOP;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;guardar estadoPUSH .SP

Compiladores 224


PUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devuelto

Compiladores 225


PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETE8: NOP; fin ifE4: NOP; fin ifMOVE .IY,.SPRET

E11: NOP ;metodoMOVE .SP,.IY;metodoMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 5 eti 14POP .R1POP .R0CMP .R0,.R1BP /E14BR /E15E14: MOVE #1,.R3; E15: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E12MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 5 eti 18POP .R1POP .R0CMP .R0,.R1BP /E18BR /E19E18: MOVE #1,.R3; E19: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E16;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3

Compiladores 226


PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SPRET;cuerpo else 16BR /E17E16: NOP;valor inmediato 0MOVE #0,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2

Compiladores 227


PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0

Compiladores 228


MOVE .IY,.SPRETE17: NOP; fin if;cuerpo else 12BR /E13E12: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 5 eti 22POP .R1POP .R0CMP .R0,.R1BP /E22BR /E23E22: MOVE #1,.R3; E23: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E20;valor inmediato 0MOVE #0,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0

Compiladores 229


MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 20BR /E21E20: NOP;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 0MOVE #0,.R0PUSH .R0

Compiladores 230


;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E2CALL /E2DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SPRETE21: NOP; fin ifE13: NOP; fin ifMOVE .IY,.SPRET

E24: NOP ;metodoMOVE .SP,.IY;metodoMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IX

Compiladores 231


MOVE #1[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 27POP .R1POP .R0CMP .R0,.R1BZ /E27BR /E28E27: MOVE #1,.R3; E28: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E25;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 25BR /E26E25: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;comp igual op 3 eti 31POP .R1POP .R0CMP .R0,.R1BZ /E32BP /E31BR /E32E31: MOVE #1,.R3; E32: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E29;valor inmediato 0MOVE #0,.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 29BR /E30E29: NOP;valor inmediato 1MOVE #1,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IX

Compiladores 232


PUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E24CALL /E24DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0

Compiladores 233


POP .R0 ;operacion aritmeticaPOP .R3ADD .R3,.R0 ;sumaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETE30: NOP; fin ifE26: NOP; fin ifMOVE .IY,.SPRET

E33: NOP ;metodoMOVE .SP,.IY;metodoMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 5 eti 36POP .R1POP .R0CMP .R0,.R1BP /E36BR /E37E36: MOVE #1,.R3; E37: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E34MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 5 eti 40POP .R1POP .R0CMP .R0,.R1BP /E40BR /E41E40: MOVE #1,.R3; E41: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E38;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4

Compiladores 234


PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E24CALL /E24DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SPRET;cuerpo else 38BR /E39E38: NOP;valor inmediato 0MOVE #0,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3

Compiladores 235


PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E24CALL /E24DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .IY,.SP

Compiladores 236


RETE39: NOP; fin if;cuerpo else 34BR /E35E34: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 5 eti 44POP .R1POP .R0CMP .R0,.R1BP /E44BR /E45E44: MOVE #1,.R3; E45: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E42;valor inmediato 0MOVE #0,.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos

Compiladores 237


;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E24CALL /E24DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 42BR /E43E42: NOP;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variable

Compiladores 238


MOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E24CALL /E24DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SPRETE43: NOP; fin ifE35: NOP; fin ifMOVE .IY,.SPRET

E46: NOP ;metodoMOVE .SP,.IY;metodo;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0

Compiladores 239


;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E33CALL /E33DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5

Compiladores 240


POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E11CALL /E11DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0MOVE .IY,.SPRETMOVE .IY,.SPRET

E47: NOP ;metodoMOVE .SP,.IY;metodoMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IX

Compiladores 241


MOVE #0[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 4 eti 50POP .R1POP .R0CMP .R0,.R1BN /E50BR /E51E50: MOVE #1,.R3; E51: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E48MOVE .SP,.R2 ;incio write string;cuerpo write string ERROR: factorial negativoWRSTR /E52BR /E53E52: DATA "ERROR: factorial negativo"E53: NOP ;fin cuerpo;valor inmediato 1MOVE #1,.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 48BR /E49E48: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 1 eti 56POP .R1POP .R0CMP .R0,.R1BZ /E56BR /E57E56: MOVE #1,.R3; E57: NOP; fin comp igual;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 58POP .R1POP .R0CMP .R0,.R1BZ /E58BR /E59E58: MOVE #1,.R3; E59: NOP; fin comp igual

Compiladores 242


;cuerpo ifCMP #0,.R3BZ /E54;valor inmediato 1MOVE #1,.R0PUSH .R0MOVE .IY,.SPRET;cuerpo else 54BR /E55E54: NOP;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0POP .R0 ;operacion aritmeticaPOP .R3SUB .R3,.R0 ;restaMOVE .A,.R0PUSH .R0

Compiladores 243


MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E47CALL /E47DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro misma claseMOVE #-2[.IY],.R0PUSH .R0;Salto a metodo misma clase etiqueta E11CALL /E11DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estadoMOVE .IY,.SP

Compiladores 244


RETE55: NOP; fin ifE49: NOP; fin ifMOVE .IY,.SPRET

E60: NOP ;claseE0:

MOVE .SP,.IY;metodoMOVE .SP,.R2 ;incio write string;cuerpo write string \tCALCULADORA\nWRSTR /E61BR /E62E61: DATA "\tCALCULADORA\n"E62: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;cuerpo write string Operacines:\n\nWRSTR /E63BR /E64E63: DATA "Operacines:\n\n"E64: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;cuerpo write string 1 .. Multiplicar\nWRSTR /E65BR /E66E65: DATA "1 .. Multiplicar\n"E66: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;cuerpo write string 2 .. Dividir\nWRSTR /E67BR /E68E67: DATA "2 .. Dividir\n"E68: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;cuerpo write string 3 .. Resto\nWRSTR /E69BR /E70E69: DATA "3 .. Resto\n"E70: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;cuerpo write string 4 .. Factorial\nWRSTR /E71BR /E72E71: DATA "4 .. Factorial\n"E72: NOP ;fin cuerpoMOVE .SP,.R2 ;incio write string;cuerpo write string \nIntroduzca la operacion: WRSTR /E73BR /E74E73: DATA "\nIntroduzca la operacion: "E74: NOP ;fin cuerpo;asignacion informativa;console readININT .R0PUSH .R0;asignacion pos 2POP .R0MOVE #-3[.IY],.IXMOVE .R0,#2[.IX]MOVE .SP,.R2 ;incio write string;cuerpo write string Introduzca el Operando1: WRSTR /E75

Compiladores 245


BR /E76E75: DATA "Introduzca el Operando1: "E76: NOP ;fin cuerpo;asignacion informativa;console readININT .R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]MOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;valor inmediato 4MOVE #4,.R0PUSH .R0;comp igual op 2 eti 79POP .R1POP .R0CMP .R0,.R1BNZ /E79BR /E80E79: MOVE #1,.R3; E80: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E77MOVE .SP,.R2 ;incio write string;cuerpo write string Introduzca el Operando2: WRSTR /E81BR /E82E81: DATA "Introduzca el Operando2: "E82: NOP ;fin cuerpo;asignacion informativa;console readININT .R0PUSH .R0;asignacion pos 1POP .R0MOVE #-3[.IY],.IXMOVE .R0,#1[.IX];cuerpo else 77BR /E78E77: NOPE78: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;valor inmediato 1MOVE #1,.R0PUSH .R0;comp igual op 1 eti 85POP .R1POP .R0CMP .R0,.R1BZ /E85

Compiladores 246


BR /E86E85: MOVE #1,.R3; E86: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E83;asignacion informativa;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #0,.R0PUSH .A;Salto a metodo misma clase etiqueta E11CALL /E11DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP

Compiladores 247


;fin de restaurar estado;valor devueltoPUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];cuerpo else 83BR /E84E83: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;valor inmediato 2MOVE #2,.R0PUSH .R0;comp igual op 1 eti 89POP .R1POP .R0CMP .R0,.R1BZ /E89BR /E90E89: MOVE #1,.R3; E90: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E87;asignacion informativa;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2

Compiladores 248


MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #0,.R0PUSH .A;Salto a metodo misma clase etiqueta E33CALL /E33DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];cuerpo else 87BR /E88E87: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;valor inmediato 3MOVE #3,.R0PUSH .R0;comp igual op 1 eti 93POP .R1POP .R0CMP .R0,.R1BZ /E93BR /E94E93: MOVE #1,.R3; E94: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E91;asignacion informativa

Compiladores 249


;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 2MOVE .SP,.R0ADD #2,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #0,.R0PUSH .A;Salto a metodo misma clase etiqueta E46CALL /E46DEC .SPPOP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0

Compiladores 250


;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];cuerpo else 91BR /E92E91: NOPMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;valor inmediato 4MOVE #4,.R0PUSH .R0;comp igual op 1 eti 97POP .R1POP .R0CMP .R0,.R1BZ /E97BR /E98E97: MOVE #1,.R3; E98: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E95;asignacion informativa;guardar estadoPUSH .SPPUSH .SRPUSH .IXPUSH .IYPUSH .APUSH .R1PUSH .R2PUSH .R3PUSH .R4PUSH .R5PUSH .R6PUSH .R7PUSH .R8PUSH .R9;fin de guardar estadoMOVE .SP,.R2 ;incio argumentos;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0MOVE .R2,.SP ;fin argumentos;Crear registro metodo tamano 1MOVE .SP,.R0ADD #1,.SPMOVE .A,.SPPUSH .R0;activar registro claseMOVE #-2[.IY],.R0ADD #0,.R0PUSH .A;Salto a metodo misma clase etiqueta E47CALL /E47DEC .SP

Compiladores 251


POP .SP;restaurar estadoPOP .R9POP .R8POP .R7POP .R6POP .R5POP .R4POP .R3POP .R2POP .R1POP .APOP .IYPOP .IXPOP .SRPOP .SP;fin de restaurar estado;valor devueltoPUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];cuerpo else 95BR /E96E95: NOPMOVE .SP,.R2 ;incio write string;cuerpo write string Operacion no definida\nWRSTR /E99BR /E100E99: DATA "Operacion no definida\n"E100: NOP ;fin cuerpo;asignacion informativa;valor inmediato 0MOVE #0,.R0PUSH .R0;asignacion pos 2POP .R0MOVE #-3[.IY],.IXMOVE .R0,#2[.IX]E96: NOP; fin ifE92: NOP; fin ifE88: NOP; fin ifE84: NOP; fin ifMOVE #0,.R3 ;inicio if;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;valor inmediato 0MOVE #0,.R0PUSH .R0;comp igual op 2 eti 103POP .R1POP .R0CMP .R0,.R1BNZ /E103

Compiladores 252


BR /E104E103: MOVE #1,.R3; E104: NOP; fin comp igual;cuerpo ifCMP #0,.R3BZ /E101MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Resultado: WRSTR /E105BR /E106E105: DATA "Resultado: "E106: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E107BR /E108E107: DATA "\n"E108: NOP ;fin cuerpoMOVE .R2,.SP ;fin write string;cuerpo else 101BR /E102E101: NOPE102: NOP; fin ifMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

CALCULADORAOperacines:

1 .. Multiplicar2 .. Dividir3 .. Resto

Compiladores 253


4 .. Factorial

Introduzca la operacion: 4Introduzca el Operando1: 7Resultado: 5040

10.16 Prueba 16

prueba116.cs

class clase{

short [] w = new short [5];


short numero1;short [] v = new short [10];

v[4]=3;numero1=v[4];w[2]=v[4]; w[2]=numero1; w[2]=6;

Console.Write("Resultados: v[4]={0}, numero1={1}\n",v[4],numero1);

}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_INICIO_VECTORTipo: TR_NADA

Compiladores 254


Tipo: TR_NADA------------------------------------------------Direccion: 4Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 5Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 6Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 8Operacion: TR_ASIGNACION_VECTORTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 9Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_INICIO_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 11Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 12Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 13Operacion: TR_VALOR_VARIABLE_VECTORTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 14Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 15Operacion: TR_INICIO_VECTORTipo: TR_NADATipo: TR_NADA

Compiladores 255


------------------------------------------------Direccion: 16Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 17Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 18Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 19Operacion: TR_INICIO_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 20Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 21Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 22Operacion: TR_VALOR_VARIABLE_VECTORTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 23Operacion: TR_ASIGNACION_VECTORTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 24Operacion: TR_INICIO_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 25Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 26Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------

Compiladores 256


Direccion: 28Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 29Operacion: TR_ASIGNACION_VECTORTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 30Operacion: TR_INICIO_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 31Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 32Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 33Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 34Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 35Operacion: TR_ASIGNACION_VECTORTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 36Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 37Operacion: TR_INICIO_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 38Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 39Operacion: TR_FIN_VECTORTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 40

Compiladores 257


Operacion: TR_VALOR_VARIABLE_VECTORTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 41Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 42Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 43Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 44Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 45Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 49Tipo: TR_NUMERO Valor: 49------------------------------------------------Direccion: 46Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 47Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 48Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 49Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 50Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 5Tipo: TR_NUMERO Valor: 5------------------------------------------------Direccion: 51Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 11Tipo: TR_NUMERO Valor: 11------------------------------------------------Direccion: 52Operacion: TR_FIN_PROGRAMA

Compiladores 258


Tipo: TR_NADATipo: TR_NADA

salida.ens


MOVE .SP,.IY;metodo;inicio vector;valor inmediato 4MOVE #4,.R0PUSH .R0;Fin vector;asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion vector pos 1POP .R0MOVE #-3[.IY],.IXPOP .AADD #1,.AADD .IX,.AMOVE .R0,[.A];asignacion informativa;inicio vector;valor inmediato 4MOVE #4,.R0PUSH .R0;Fin vector;valor de variable vectorMOVE #-3[.IY],.IXPOP .AADD #1,.AADD .IX,.AMOVE [.A],.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];inicio vector;valor inmediato 2MOVE #2,.R0PUSH .R0;Fin vector;asignacion informativa;inicio vector;valor inmediato 4MOVE #4,.R0PUSH .R0;Fin vector;valor de variable vectorMOVE #-3[.IY],.IXPOP .AADD #1,.A

Compiladores 259


ADD .IX,.AMOVE [.A],.R0PUSH .R0;asignacion vector pos 0POP .R0MOVE #-2[.IY],.IXPOP .AADD #0,.AADD .IX,.AMOVE .R0,[.A];inicio vector;valor inmediato 2MOVE #2,.R0PUSH .R0;Fin vector;asignacion informativa;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;asignacion vector pos 0POP .R0MOVE #-2[.IY],.IXPOP .AADD #0,.AADD .IX,.AMOVE .R0,[.A];inicio vector;valor inmediato 2MOVE #2,.R0PUSH .R0;Fin vector;asignacion informativa;valor inmediato 6MOVE #6,.R0PUSH .R0;asignacion vector pos 0POP .R0MOVE #-2[.IY],.IXPOP .AADD #0,.AADD .IX,.AMOVE .R0,[.A]MOVE .SP,.R2 ;incio write string;inicio vector;valor inmediato 4MOVE #4,.R0PUSH .R0;Fin vector;valor de variable vectorMOVE #-3[.IY],.IXPOP .AADD #1,.AADD .IX,.AMOVE [.A],.R0PUSH .R0;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0;cuerpo write string Resultados: v[4]=

Compiladores 260


WRSTR /E2BR /E3E2: DATA "Resultados: v[4]="E3: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string , numero1=WRSTR /E4BR /E5E4: DATA ", numero1="E5: NOP ;fin cuerpoWRINT #1[.IY] ;write short;cuerpo write string \nWRSTR /E6BR /E7E6: DATA "\n"E7: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALTINICIO_PILA:

Ejecución

Resultados: v[4]=3, numero1=3

10.17 Prueba 17

prueba117.cs

class clase{

short numero4=1;


short numero1=1,numero2=2;short numero3=3;

Console.Write("Resultados: numero1={0}\n",numero1);Console.Write("Resultados: numero2={0}\n",numero2);Console.Write("Resultados: numero3={0}\n",numero3);

Compiladores 261


}}

salida.ter

------------------------------------------------Direccion: 0Operacion: TR_INICIO_PROGRAMATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 1Operacion: TR_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 2Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 3Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 4Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 5Operacion: TR_METODO_MAINTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 6Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 7Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 8Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 9Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 10Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2

Compiladores 262


------------------------------------------------Direccion: 11Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 12Operacion: TR_ASIGNACION_INFORMATIVATipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 13Operacion: TR_VALOR_INMEDIATOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 14Operacion: TR_ASIGNACIONTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 15Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 16Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 0Tipo: TR_NUMERO Valor: 0------------------------------------------------Direccion: 17Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 18Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 19Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 4Tipo: TR_NUMERO Valor: 4------------------------------------------------Direccion: 20Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 21Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 22Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------

Compiladores 263


Direccion: 23Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 6Tipo: TR_NUMERO Valor: 6------------------------------------------------Direccion: 24Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 25Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 8Tipo: TR_NUMERO Valor: 8------------------------------------------------Direccion: 26Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 27Operacion: TR_INICIO_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 28Operacion: TR_VALOR_VARIABLETipo: TR_NUMERO Valor: 2Tipo: TR_NUMERO Valor: 2------------------------------------------------Direccion: 29Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 10Tipo: TR_NUMERO Valor: 10------------------------------------------------Direccion: 30Operacion: TR_WRITE_SHORTTipo: TR_NUMERO Valor: 48Tipo: TR_NUMERO Valor: 48------------------------------------------------Direccion: 31Operacion: TR_WRITE_STRINGTipo: TR_NUMERO Valor: 12Tipo: TR_NUMERO Valor: 12------------------------------------------------Direccion: 32Operacion: TR_FIN_WRITE_STRINGTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 33Operacion: TR_METODO_RETTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 34Operacion: TR_SALTOTipo: TR_NADATipo: TR_NADA------------------------------------------------Direccion: 35

Compiladores 264


Operacion: TR_REGISTRO_CLASETipo: TR_NUMERO Valor: 1Tipo: TR_NUMERO Valor: 1------------------------------------------------Direccion: 36Operacion: TR_REGISTRO_METODOTipo: TR_NUMERO Valor: 3Tipo: TR_NUMERO Valor: 3------------------------------------------------Direccion: 37Operacion: TR_FIN_PROGRAMATipo: TR_NADATipo: TR_NADA

salida.ens


;asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX]

E0:MOVE .SP,.IY;metodo;asignacion informativa;valor inmediato 1MOVE #1,.R0PUSH .R0;asignacion pos 0POP .R0MOVE #-3[.IY],.IXMOVE .R0,#0[.IX];asignacion informativa;valor inmediato 2MOVE #2,.R0PUSH .R0;asignacion pos 1POP .R0MOVE #-3[.IY],.IXMOVE .R0,#1[.IX];asignacion informativa;valor inmediato 3MOVE #3,.R0PUSH .R0;asignacion pos 2POP .R0MOVE #-3[.IY],.IXMOVE .R0,#2[.IX]MOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #0[.IX],.R0PUSH .R0

Compiladores 265


;cuerpo write string Resultados: numero1=WRSTR /E2BR /E3E2: DATA "Resultados: numero1="E3: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E4BR /E5E4: DATA "\n"E5: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #1[.IX],.R0PUSH .R0;cuerpo write string Resultados: numero2=WRSTR /E6BR /E7E6: DATA "Resultados: numero2="E7: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E8BR /E9E8: DATA "\n"E9: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .SP,.R2 ;incio write string;valor de variableMOVE #-3[.IY],.IXMOVE #2[.IX],.R0PUSH .R0;cuerpo write string Resultados: numero3=WRSTR /E10BR /E11E10: DATA "Resultados: numero3="E11: NOP ;fin cuerpoWRINT #0[.IY] ;write short;cuerpo write string \nWRSTR /E12BR /E13E12: DATA "\n"E13: NOP ;fin cuerpoMOVE .R2,.SP ;fin write stringMOVE .IY,.SPRET


HALT

Compiladores 266


INICIO_PILA:

Ejecución

Resultados: numero1=1Resultados: numero2=2Resultados: numero3=3

10.18 Prueba 18

Esta prueba se encarga de tratar un error sintactico. Dicho error se detecta cuando encontramos la declaracion de un atributo en el que hemos incluido el metodo especial get y, sin embargo, no el set.

prueba1.cs

class clase{

short numero3;


} short atributo{

get{

numero3=2;}

}



metodo1();console.write("hola\n");numero1=4;numero2=5-2+3-7; //=-1numero3=6;numero1=numero3;numero1=numero2+5-1; //=3numero3=2-numero3-numero2+numero1+5; //=2-6-(-1)+3+5=5console.write("n1: {0}\nn2: {1}\nn3: {2}\n",numero1,numero2,

numero3);console.write("adios\n");

}}

Línea de comandos

Compiladores 267


C:\CSC\Debug> csc.exe –o ..\pruebas\prueba1.cs salidaMostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba1.csFichero Salida: salidaCompilando..."..\pruebas\prueba1.cs", Line 15: Sintactic Error: #21: Atribute not validGenerador de Codigo: ERROR: Metodo Main no encontrado

10.19 Prueba 19

En esta prueba podemos observar que se produce un error de tipo semántico debido a la asignación. Se intenta asignar un string a una variable de tipo short, y eso no es correcto.

prueba2.cs

class clase{

short numero3;



console.write("hola\n");numero1="hola"; //n1=4numero2=3; //n2=3numero1+=3+1; //n1=8numero1-=5-numero2; // =n1=8-2=6console.write("n1: {0}\n",numero1);console.write("adios\n");

}}

Línea de comandos

C:\CSC\Debug> csc.exe –o ..\pruebas\prueba2.cs salidaMostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba2.csFichero Salida: salidaCompilando..."..\pruebas\prueba2.cs", Line 12: Semantic Error: #104: types not equal in Sentencia"..\pruebas\prueba2.cs", Line 12: Sintactic Error: #3: token '}' expectedGenerador de Codigo: ERROR: Metodo Main no encontrado

Compiladores 268


10.20 Prueba 20

Esta prueba detecta que no se permiten shorts con rango superior a 65535. En caso de serlo, se produce un error léxico.

prueba3.cs

class clase{

short numero3=66666666;


}


}


n1=5;metodo1();n1+=3;console.write("Estoy en Main {0}\n",n1);metodo2();

}}

Línea de comandos

C:\CSC\Debug> csc.exe –o ..\pruebas\prueba3.cs salidaMostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba3.csFichero Salida: salidaCompilando..."..\pruebas\prueba3.cs", Line 4: Lexer Error: #150: Short Token not valid"..\pruebas\prueba3.cs", Line 4: Sintactic Error: #15: 'Primario' not validGenerador de Codigo: ERROR: Metodo Main no encontrado

10.21 Prueba 21

Esta prueba simplemente detecta que no existe un metodo main, o que si existe no tiene los campos public y static necesarios.

prueba4.cs

Compiladores 269


class clase{

short numero3;

short metodo1() {console.write("Estoy en el metodo1\n");numero3=10;return 5+numero3;

}

public void main(){short n1;

n1=metodo1();console.write("Estoy en main {0}\n",n1);n1=3+metodo1()+1;console.write("Sigo en main {0}\n",n1);

}}

Línea de comandos

Mostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba4.csFichero Salida: salidaCompilando..."..\pruebas\prueba4.cs", Line 23: Semantic Error: #101: not a main method in fileGenerador de Codigo: ERROR: Metodo Main no encontrado

10.22 Prueba 22

Esta prueba demuestra que el compilador controla si el metodo declarado debe devolver algo o no. En caso se ser de tipo void, el compilador permite poner return o no.

prueba5.cs

class clase{ short num;

short metodo1(short n1,short n2) {console.write("Metodo1: n1={0}, n2={1}\n",n1,n2);console.write("Metodo1: n1+n2={0}\n",n1+n2);

}

public static void Main(){num=1;console.write("Estoy en Main\n");console.write("Resultado de metodo1: {0}\n",metodo1(5,6));metodo1(5+num,6);

Compiladores 270


}}

Línea de comandos

Mostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba5.csFichero Salida: salidaCompilando..."..\pruebas\prueba5.cs", Line 10: Semantic Error: #128: not return val in method"..\pruebas\prueba5.cs", Line 10: Sintactic Error: #3: token '}' expectedGenerador de Codigo: ERROR: Metodo Main no encontrado

10.23 Prueba 23

En esta prueba de demuestra que el compilador es capaz de saber en que momento se esta ejecutando la palabra especial value. Por tanto, el compilador generará error, cuando dicha palabra no se situe dentro de la declaracion de un atributo.

prueba6.cs

class prueba {

public short numero1=1;



}}

class clase{



p1.numero1=5;s1=p1.numero1; p1.numero1 = value;

}}

class clase2{ short s1; prueba p1;

Compiladores 271



s1=p1.numero1; // Debe dar error y con razon!!!! }}

Línea de comandos

Mostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba6.csFichero Salida: salidaCompilando..."..\pruebas\prueba6.cs", Line 22: Semantic Error: #119: value is not in atribute"..\pruebas\prueba6.cs", Line 22: Sintactic Error: #9: 'SentMet' not valid"..\pruebas\prueba6.cs", Line 22: Sintactic Error: #3: token '}' expectedGenerador de Codigo: ERROR: Metodo Main no encontrado

10.24 Prueba 24

Esta prueba, algo mas compleja, nos comprueba que efectivamente, cada objeto instanciado de una clase, si sus variables no estan inicializadas, en dicho objeto tampoco lo estaran. Por lo que, si se utilizan en una asignación, el compilador generará un error.

prueba7.cs

class prueba {




}}

class clase{



p1.numero1=5;s1=p1.numero1;

}}

class clase2{

Compiladores 272




s1=p1.numero1; // Debe dar error y con razon!!!! }}

Línea de comandos

Mostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba7.csFichero Salida: salidaCompilando..."..\pruebas\prueba7.cs", Line 31: Semantic Error: #131: var no inicializated"..\pruebas\prueba7.cs", Line 31: Sintactic Error: #9: 'SentMet' not valid"..\pruebas\prueba7.cs", Line 31: Sintactic Error: #3: token '}' expectedGenerador de Codigo: ERROR: Metodo Main no encontrado

10.25 Prueba 25

Esta prueba se encarga de demostrar que el compilador revisa cada elemento asignado a una variable lista, verificando si todos los elementos son del mismo tipo que la propia variable lista. En este caso, intentamos insertar “hola” en una lista de shorts.

prueba8.cs

class clase{

short [] w = new short [5];


short numero1;short [] v = new short [10];

v[4]=3;v = {5,"hola"};numero1=v[4];w[2]=v[4]; //da error sintactico que no deberiaw[2]=numero1; //da error sintactico que no deberiaw[2]=6; //da error sintactico que no deberia

Console.Write("Resultados: v[4]={0}, numero1={1}\n",v[4],numero1);

}

Compiladores 273


}

Línea de comandos

Mostrar Debug Sintactico DesactivadoGenerador de Codigo Intermedio ActivadoGenerador de Codigo Objeto ActivadoFichero Fuente: ..\pruebas\prueba8.csFichero Salida: salidaCompilando..."..\pruebas\prueba8.cs", Line 13: Semantic Error: #118: differents types of list"..\pruebas\prueba8.cs", Line 13: Sintactic Error: #9: 'SentMet' not valid"..\pruebas\prueba8.cs", Line 13: Sintactic Error: #3: token '}' expectedGenerador de Codigo: ERROR: Metodo Main no encontrado

Compiladores 274


11 Anexo

Características Implementadas en el Generador de código:

Variables enteras y su declaración en clases y métodos. Inicialización de variables enteras durante su declaración en métodos pero no en

clases. Constantes enteras y cadenas de caracteres (entre comillas). Definición de clases, con atributos, propiedades y métodos. Sentencias: asignaciones, llamadas a métodos y retorno de los métodos. Los

métodos sólo pueden retornar “void” o “short”. Y solo pueden recibir como parámetros tipo short que se pasan por valor.

Comentarios Operaciones de entrada/salida por terminal: “Console.Write” y “Conlole.Read”.

No está implementado “Console.ReadLine” puesto que no están implementadas las variables “String”

Operadores Aritméticos: +, -. No están implementados: *, /, % Operadores Relacionales: >, <, >=, <=, ==, != Operadores Lógicos: ||. No están implementados: &&, ! Vectores de Short. No está implementada la inicialización de los vectores

durante su declaración, es decir short [] v = {2,3,4}. Paso de Argumentos por Valor. No esta implementado el paso de parámetros por

Referencia. Sentencia condicional “if-else”. No están implementadas las sentencias “while”,

“do-while”, “for” ni “switch-case”. Asignación con Operación +=, -=. No están implementados el resto de

operadores especiales

Compiladores 275


12 Bibliografía

Apuntes de Compiladores, Grupo 41M, Cuarto Curso. Facultad de Informática Universidad Politécnica de Madrid

Compiladores: Principios, técnicas y herramientas Alfred V. Aho, Ravi SEIT & Jeffrey D. UllmanAddison Wesley Longman (Pearson)

The Compiler Generator Coco/R: User ManualHanspeter Mössenböck Johannes Kepler University Linz Institute of System Software February 2004

M. E. Lesk and E. Schmidt, LEX - Lexical Analyzer Generator

Compiladores 276

all documentation

Documents

Transcript of all documentation