Ejemplo-Memoria Final 2004 09 07 PDF

CSC (C# Compiler)
Ejercicio de Implementación
Compiladores
Entrega Final
Curso 2003 2004
Septiembre del 2004
Grupo 98
Santiago González Tortosa sgt_fi@yahoo.es
Germán Ramos García g990189@zipi.fi.upm.es
Alberto Fernández Recio afr@iespana.es
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
Compiladores 2
10.8 PRUEBA 8................................................................................................................................ 119

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
TS
LF arbol arbol. sint. LI LI LO

PF AL token AS ASE GCI OC GCF PO
sintactico anotado Optimizado
GE
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 | *K
K  oc3J | *K | /S
Compiladores 6
L=|
M=|
N=|
O=|
P  aH | dH | 
Q  dQ | 
R  xT | XT | dQ | 
T  dxT | 
U|
V  wW | rX
W  rite
X  ead
Los símbolos auxiliares utilizados son los siguientes:
Regla S: a y del
o a: letras, @ o _ (primer carácter de un identificador).
o del: delimitadores (espacios, tabuladores...).
Regla G: oc
o 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,nl
o 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: oc2
o oc2: Otro carácter salvo el * y fin de fichero.
Regla K: oc3
o oc3: Otro carácter salvo * , / y fin de fichero
Regla P: a
o 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 linea
del = Delimitador: Espacio, Tabulador, FL
oc = otro carácter
d = dígito
L = letra
dH = 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 Acciones

0-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-26 E Si n = Palabra_Reservada
25-26 GENERAR_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)
Compiladores 10
<LLA, -> Llave Abierta (“{“) (5)

<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 Elemento
1 +
2 -
3 *
4 /
5 %
Tabla de Operadores Lógicos
Puntero Elemento
1 &&
2 ||
3 !
4 >
5 <
6 ==
7 <=
8 >=
9 !=
Tabla de Operadores de Asignación de Operación
Puntero Elemento
1 +=
2 -=
3 *=
4 /=
Compiladores 11
5 %=
6 ++
7 --
Tabla de Palabras Reservadas
Puntero Elemento
1 IF
2 ELSE
3 RETURN
4 TRUE
5 FALSE
6 VOID
7 STRING
8 SHORT
9 BOOL
10 CLASS
11 REF
12 NEW
13 PUBLIC
14 PRIVATE
15 STATIC
16 SET
17 GET
18 VALUE
19 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);
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 devuelve el tipo de un elemento de una tabla de símbolos determinada.

 int Cambiar_Tipo(TS *tabla,char *nombre, int tipo);
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
 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
 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: numero1
Tipo: SHORT
Valor: 1
------------------------------------------------
Compiladores 16
LEXEMA: identificador1
Tipo: STRING
Valor: 1
------------------------------------------------
LEXEMA: funcion1
Tipo: FUNCION
Valor: 1
Tipo valor devuelto: SHORT
Numero de parametros: 3
Parametros:
Tipo parametro: BOOL
Paso de parametro: NORMAL
Tipo parametro: SHORT
Paso de parametro: POR REFERENCIA
Tipo parametro: BOOL
Paso de parametro: POR REFERENCIA
Este Lexema contiene una SUBTABLA
------------------------------------------------
Tipo: STRING
Valor: 1
------------------------------------------------
 Fichero “funcion1.txt”
LEXEMA: numero2
Tipo: SHORT
Valor: 1
------------------------------------------------
Tipo: STRING
Valor: 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 Sintactico

Sintactico → EO
Clase → ID LLA DeclSentencias LLC
Compiladores 19
Clase → λ
DeclSentencias → DeclSentencia DeclSentencias

DeclSentencias → λ
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 DPC
Sentencia → Tipos [LLA LLC] ID Declaracion
Sentencia → CCW PAA (ID [Var] | ST) [DC DatosWrite] PAC DPC
Var → OP ID [SentMet]
Var → CA Expresión CC
SentenciaS → Sentencia Sentencias

SentenciaS → λ
SentAsig → OAS Valor

SentAsig → AO Expresion
SentMet → PAA (PAC | Var2 PAC)
DatosWrite → DC Valor DatosWrite

DatosWrite → λ
Tipos → (PR_SHORT | PR_STRING | PR_VOID | PR_BOOL)
Valor → CCR PAA PAC

Valor → PR_NEW Tipos CA CE CC
Valor → LLA Primario Valores LLC
Valor → Expresion
Var2 → Expresión Var3
Var3 → DC Expresión Var3

Var3 → λ
Valores → DC Primario Valores

Valores → λ
Primario → ST | OC | CE | PAA Expresión PAC | PR_TRUE | PR_FALSE…

… | PR_VALUE | ID [Var] [SentMet]
Expresion → Condicion [Expresion2]
Compiladores 20
Expresion2 → (OL_AND | OL_OR) Expresion
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 Termino2

Termino2 → λ
Factor → [OL_NOT] Primario
Declaracion → PAA TiposMet PAC DeclMetodo

Declaracion → LLA DeclAtributo LLC
Declaracion → OAS Valor Declaracion
Declaracion → DC Decl2 DPC
Declaracion → DPC
TiposMet → [PR_REF] PR_PARAMS Tipos CA CC ID TiposMet2

TiposMet → [PR_REF] (Tipos | ID) ID TiposMet2
TiposMet2 → DC TiposMet
TiposMet2 → λ
DeclMetodo → LLA SentenciaS LLC
DeclAtributo → PR_GET DeclAtributo2

DeclAtributo → PR_SET DeclAtributo4
DeclAtributo2 → LLA SentenciaS LLC DeclAtributo3
DeclAtributo4 → LLA SentenciaS LLC DeclAtributo5
DeclAtributo3 → PR_SET LLA SentenciaS LLC

DeclAtributo3 → λ
DeclAtributo5 → PR_GET LLA SentenciaS LLC

DeclAtributo5 → λ
Compiladores 21
Decl2 → CA CC ID Decl22 Decl21

Decl2 → ID Decl22 Decl21
Decl22 → OAS Valor

Decl22 → λ
Decl21 → DC Decl2
Decl21 → λ
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.
Compiladores 24
 “value”: el tipo que indique el atributo utilizado en ese

momento (se utiliza una variable global que toma valor
cuando un atributo se define).
 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.
Compiladores 25
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.
 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.
Compiladores 26
 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.
 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 terceto
o El operador1
o 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 0
Terceto de inicio del programa. No recibe ningún operando.
 #define TR_FIN_PROGRAMA 1
Terceto de fin del programa. No recibe ningún operando.
 #define TR_METODO_MAIN 2
Terceto correspondiente con el inicio del método principal “Main”
 #define TR_METODO 3
Terceto 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 4
Terceto correspondiente con el fin de un método. No recibe ningún operando.
 #define TR_ASIGNACION 5
Compiladores 29
Terceto 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
indica el desplazamiento correspondiente a la variable en el registro de
activación correspondiente
 #define TR_REGISTRO_CLASE 6
Crea el registro de activación de una clase. Recibe un operando numérico que
indica el tamaño del registro
 #define TR_CLASE 7
Terceto 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 8
Terceto que indica la posición del código inicial del programa. No recibe ningún
operando.
 #define TR_REGISTRO_METODO 9
Crea 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 10
Terceto de un valor short inmediato. Recibe un operando numérico con el valor.
 #define TR_VALOR_VARIABLE 11
Terceto 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 12
Terceto 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 13
Terceto para escribir enteros. Recibe un operando numérico con el valor a
escribir.
 #define TR_SALTO_METODO 14
Terceto para saltar a un método. Recibe un operando con la etiqueta del método
al que saltar.
 #define TR_INICIO_WRITE_STRING 15
Terceto que indica el inicio de escritura en consola. No recibe ningún operando.
 #define TR_FIN_WRITE_STRING 16
Terceto que indica el final de escritura en consola. No recibe ningún operando.
 #define TR_SUMA 17
Compiladores 30
Terceto que implementa los operadores aritméticos suma y resta. Recibe un

operando indicando si tiene que sumar o restar.
 #define TR_GUARDAR_ESTADO 18
Terceto que indica que se debe guardar el estado del computador. No recibe
ningún operando.
 #define TR_RESTAURAR_ESTADO 19
Terceto que indica que se debe restaurar el estado del computador. No recibe
ningún operando.
 #define TR_VALOR_DEVUELTO 20
Terceto que indica que se debe usar el valor devuelto por el método que termina.
No recibe ningún operando.
 #define TR_INICIO_ARGUMENTOS 21
Terceto que indica el inicio de argumentos para la llamada a un método.
 #define TR_FIN_ARGUMENTOS 22
Terceto que indica el fin de argumentos para la llamada a un método.
 #define TR_ACTIVAR_REGISTRO_CLASE 23
Terceto 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 24
Terceto que indica que se debe seguir usando el registro de la clase actual.
 #define TR_INICIO_IF 25
Terceto que indica el inicio de una sentencia condicional “if-else”. No recibe
ningún operando.
 #define TR_FIN_IF 26
Terceto 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 27
Terceto que indica el inicio de una asignación
 #define TR_COMP_IGUAL 28
Este 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 29
Informa del comienzo del cuerpo “if” de una sentencia condicional “if-else”.
Recibe un operando numérico que proporciona etiquetas
Compiladores 31
 #define TR_CUERPO_ELSE 30
Informa del comienzo del cuerpo “else” de una sentencia condicional “if-else”.
Recibe un operando numérico que proporciona etiquetas
 #define TR_CONSOLE_READ 31
Terceto que implementa la lectura de un un entero por consola. No recibe ningún
operando.
 #define TR_ASIGNACION_VECTOR 32
Terceto 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 33
Terceto que informa el inicio de una variable de tipo vector. No recibe ningún
operando.
 #define TR_FIN_VECTOR 34
Terceto que informa del fin de una variable de tipo vector. No recibe ningún
operando.
 #define TR_VALOR_VARIABLE_VECTOR 35
Terceto 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 0
Indica que no se pasa ningún valor útil.
 #define TR_NUMERO 1
Indica que se pasa un valor numérico.
 #define TR_CADENA 2
Indica que se pasa un valor de cadena.
 #define TR_REF 3
Indica que se pasa una referencia a otro terceto.
Compiladores 32
6.2 El módulo “Intermedio”
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_Llamada
char nomnombre[250]; //utilizado por Intermedio_Informar_Llamada
TS *tinformar; //utilizado por Intermedio_Informar_Llamada
llam_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.
Compiladores 33
 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.
 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.
Compiladores 34
 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
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) //falso
console.write("verdadero\n");
else
console.write("falso\n");
}
}
salida.ter
------------------------------------------------
Direccion: 0
Operacion: TR_INICIO_PROGRAMA
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
Tipo: TR_NUMERO Valor: 1
------------------------------------------------
Direccion: 2
Operacion: TR_METODO_MAIN
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Operacion: TR_ASIGNACION_INFORMATIVA
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
Operacion: TR_VALOR_INMEDIATO
Compiladores 35

------------------------------------------------
Direccion: 5
Operacion: TR_ASIGNACION
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Operacion: TR_INICIO_IF
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
Operacion: TR_VALOR_VARIABLE
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
Operacion: TR_COMP_IGUAL
------------------------------------------------
Direccion: 13
Operacion: TR_CUERPO_IF
------------------------------------------------
Direccion: 14
Operacion: TR_INICIO_WRITE_STRING
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
Operacion: TR_WRITE_STRING
------------------------------------------------
Direccion: 16
Operacion: TR_CUERPO_ELSE
Compiladores 36

------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
Operacion: TR_FIN_IF
------------------------------------------------
Direccion: 20
Operacion: TR_METODO_RET
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 21
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 22
Operacion: TR_REGISTRO_CLASE
------------------------------------------------
Direccion: 23
Operacion: TR_REGISTRO_METODO
------------------------------------------------
Direccion: 24
Operacion: TR_FIN_PROGRAMA
Tipo: TR_NADA
Tipo: 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);
Compiladores 39
fprintf(fdobjeto,"\tMOVE .A,.SP\n");
fprintf(fdobjeto,"\tPUSH .R0\n");
}
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[.IX],.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);
}
Compiladores 40
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.
 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");
}
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 devuelto
Compiladores 41
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 .R0\n"); //aqui va el valor devuelto
fprintf(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");
}
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");
}
Compiladores 42
Saca de la pila los valores de los argumentos porque ya no son necesarios.
 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");
}
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,"\tCMP .R0,.R1\n");
Compiladores 43
if (op==1) //igual
fprintf(fdobjeto,"\tBZ /E%d\n",eti);
else if (op==2) //distinto
fprintf(fdobjeto,"\tBNZ /E%d\n",eti);
else if (op==3) {//mayor
fprintf(fdobjeto,"\tBZ /E%d\n",eti+1); //son iguales
fprintf(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,"\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");
}
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");
}
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;
Compiladores 44
fprintf(fdobjeto,"\t;asignacion vector pos %d\n",n);

fprintf(fdobjeto,"\tPOP .R0\n",n);
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,"\tADD #%d,.A\n",n);
fprintf(fdobjeto,"\tADD .IX,.A\n");
fprintf(fdobjeto,"\tMOVE [.A],.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
Compiladores 46
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 47
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 48
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 49
9 Programa Principal
El programa principal se llama CSC (C Sharp Compiler). Este programa posee las
siguientes opciones:
GNU C Sharp Compiler

Usage: 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 object
Press 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 Salida

Có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 50
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 Desactivado
Generador de Codigo Intermedio Activado
Generador de Codigo Objeto Activado
Fichero Fuente: ..\pruebas\pruebaX.cs
Fichero Salida: salida
Compilando...
Compilacion finalizada correctamente.
10.1 Prueba 1
prueba101.cs
class clase{
short numero3;
void metodo1() {
console.write("Estoy en el metodo1\n");
}
short numero1;
short numero2;
metodo1();
console.write("hola\n");
numero1=4;
numero2=5-2+3-7; //=-1
numero3=6;
numero1=numero3;
numero1=numero2+5-1; //=3
numero3=2-numero3-numero2+numero1+5; //=2-6-(-1)+3+5=5
console.write("n1: {0}\nn2: {1}\nn3: {2}\n", numero1, numero2,
numero3);
console.write("adios\n");
}
}
Compiladores 51
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Operacion: TR_METODO
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
Operacion: TR_GUARDAR_ESTADO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Operacion: TR_ACTIVAR_MISMA_CLASE
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
Operacion: TR_SALTO_METODO
------------------------------------------------
Direccion: 11
Operacion: TR_RESTAURAR_ESTADO
Compiladores 52
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
Operacion: TR_SUMA
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
Operacion: TR_SUMA
------------------------------------------------
Direccion: 23
Compiladores 53

------------------------------------------------
Direccion: 24
Operacion: TR_SUMA
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
Operacion: TR_SUMA
Compiladores 54
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
Operacion: TR_SUMA
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 40
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
Operacion: TR_SUMA
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
Operacion: TR_SUMA
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
Operacion: TR_SUMA
------------------------------------------------
Direccion: 47
------------------------------------------------
Compiladores 55
Direccion: 48
Operacion: TR_SUMA
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
------------------------------------------------
Direccion: 53
------------------------------------------------
Direccion: 54
------------------------------------------------
Direccion: 55
Operacion: TR_WRITE_SHORT
------------------------------------------------
Direccion: 56
------------------------------------------------
Direccion: 57
------------------------------------------------
Direccion: 58
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
Compiladores 56
------------------------------------------------
Direccion: 61
Operacion: TR_FIN_WRITE_STRING
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 62
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 63
------------------------------------------------
Direccion: 64
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 65
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 66
------------------------------------------------
Direccion: 67
------------------------------------------------
Direccion: 68
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
MOVE #INICIO_PILA,.SP
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
MOVE .SP,.R2 ;incio write string
;cuerpo write string Estoy en el metodo1\n
WRSTR /E3
BR /E4
E3: DATA "Estoy en el metodo1\n"
E4: NOP ;fin cuerpo
MOVE .IY,.SP
Compiladores 57
RET
E0:
MOVE .SP,.IY;metodo
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;fin de guardar estado
;Crear registro metodo tamano 0
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
;activar registro misma clase
MOVE #-2[.IY],.R0
PUSH .R0
;Salto a metodo misma clase etiqueta E2
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;fin de restaurar estado
;cuerpo write string hola\n
WRSTR /E5
BR /E6
E5: DATA "hola\n"
E6: NOP ;fin cuerpo
;asignacion informativa
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
Compiladores 58
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
POP .R0 ;operacion aritmetica
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;valor inmediato 7
MOVE #7,.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#1[.IX]
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
Compiladores 59
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
Compiladores 60
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string n1:
WRSTR /E7
BR /E8
E7: DATA "n1: "
E8: NOP ;fin cuerpo
WRINT #0[.IY] ;write short
;cuerpo write string \nn2:
WRSTR /E9
BR /E10
E9: DATA "\nn2: "
E10: NOP ;fin cuerpo
;cuerpo write string \nn3:
WRSTR /E11
BR /E12
E11: DATA "\nn3: "
;cuerpo write string \n
WRSTR /E13
BR /E14
E13: DATA "\n"
MOVE .R2,.SP ;fin write string
;cuerpo write string adios\n
WRSTR /E15
BR /E16
E15: DATA "adios\n"
MOVE .IY,.SP
RET
SALTO:
;Crear registro clase tamano 1
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Compiladores 61
Estoy en el metodo1
hola
n1: 3
n2: -1
n3: 5
adios
10.2 Prueba 2
prueba102.cs
class clase{
short numero3;
short numero1;
short numero2;
numero1=4; //n1=4
numero2=3; //n2=3
numero1+=3+1; //n1=8
numero1-=5-numero2; // =n1=8-2=6
console.write("n1: {0}\n",numero1);
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
Compiladores 62
------------------------------------------------
Direccion: 5
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 6
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Operacion: TR_SUMA
------------------------------------------------
Direccion: 15
Operacion: TR_SUMA
------------------------------------------------
Direccion: 16
Compiladores 63

------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
Operacion: TR_SUMA
------------------------------------------------
Direccion: 21
Operacion: TR_SUMA
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Compiladores 64
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;cuerpo write string hola\n
WRSTR /E2
BR /E3
E2: DATA "hola\n"
E3: NOP ;fin cuerpo
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
Compiladores 65
MOVE .R0,#0[.IX]
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#1[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
Compiladores 66
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string n1:
WRSTR /E4
BR /E5
E4: DATA "n1: "
E5: NOP ;fin cuerpo
WRSTR /E6
BR /E7
E6: DATA "\n"
E7: NOP ;fin cuerpo
;cuerpo write string adios\n
WRSTR /E8
BR /E9
E8: DATA "adios\n"
E9: NOP ;fin cuerpo
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
hola
n1: 6
adios
10.3 Prueba 3
prueba103.cs
class clase{
short numero3;
void metodo1() {
Compiladores 67
void metodo2() {
}

short n1;
n1=5;
metodo1();
n1+=3;
console.write("Estoy en Main {0}\n",n1);
metodo2();
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 6
------------------------------------------------
Direccion: 7
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 68
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 19
------------------------------------------------
Compiladores 69
Direccion: 20
------------------------------------------------
Direccion: 21
Operacion: TR_SUMA
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
Compiladores 70
------------------------------------------------
Direccion: 33
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 34
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 35
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
WRSTR /E3
BR /E4
E4: NOP ;fin cuerpo
MOVE .IY,.SP
RET
E5: NOP ;metodo
MOVE .SP,.IY;metodo
WRSTR /E6
BR /E7
E7: NOP ;fin cuerpo
MOVE .IY,.SP
Compiladores 71
RET
E0:
MOVE .SP,.IY;metodo
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 3
MOVE #3,.R0
Compiladores 72
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Estoy en Main
WRSTR /E8
BR /E9
E8: DATA "Estoy en Main "
E9: NOP ;fin cuerpo
WRSTR /E10
BR /E11
E10: DATA "\n"
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E5
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
Compiladores 73
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Estoy en el metodo1
Estoy en Main 8
Estoy en el metodo2
10.4 Prueba 4
prueba104.cs
class clase{
short numero3;
short metodo1() {
numero3=10;
return 5+numero3;
}

short n1;
n1=metodo1();
n1=3+metodo1()+1;
console.write("Sigo en Main {0}\n",n1);
Compiladores 74
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 6
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
Compiladores 75
Operacion: TR_SUMA
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 13
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 20
Operacion: TR_VALOR_DEVUELTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
Compiladores 76
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
Tipo: TR_NADA
Compiladores 77
Tipo: TR_NADA
------------------------------------------------
Direccion: 35
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 36
Operacion: TR_SUMA
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
Operacion: TR_SUMA
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 46
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 78
------------------------------------------------
Direccion: 47
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
WRSTR /E3
BR /E4
E4: NOP ;fin cuerpo
;valor inmediato 10
MOVE #10,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
Compiladores 79
E0:
MOVE .SP,.IY;metodo
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Estoy en Main
WRSTR /E5
BR /E6
Compiladores 80
E5: DATA "Estoy en Main "

E6: NOP ;fin cuerpo
WRSTR /E7
BR /E8
E7: DATA "\n"
E8: NOP ;fin cuerpo
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
Compiladores 81
ADD .R3,.R0 ;suma

MOVE .A,.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Sigo en Main
WRSTR /E9
BR /E10
E9: DATA "Sigo en Main "
WRSTR /E11
BR /E12
E11: DATA "\n"
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Estoy en el metodo1
Estoy en Main 15
Estoy en el metodo1
Sigo en Main 19
Compiladores 82
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;
}

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: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
Compiladores 83

------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
Operacion: TR_SUMA
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
Compiladores 84

------------------------------------------------
Direccion: 19
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
Operacion: TR_SUMA
------------------------------------------------
Direccion: 23
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 24
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 25
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 30
Compiladores 85
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 33
Operacion: TR_INICIO_ARGUMENTOS
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
------------------------------------------------
Direccion: 36
Operacion: TR_FIN_ARGUMENTOS
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 41
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 42
------------------------------------------------
Compiladores 86
Direccion: 43
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 46
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 47
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
Operacion: TR_SUMA
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 53
------------------------------------------------
Direccion: 54
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 55
Compiladores 87
------------------------------------------------
Direccion: 56
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 57
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 58
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
------------------------------------------------
Direccion: 61
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;cuerpo write string Metodo1: n1=
WRSTR /E3
BR /E4
E3: DATA "Metodo1: n1="
E4: NOP ;fin cuerpo
;cuerpo write string , n2=
WRSTR /E5
Compiladores 88
BR /E6
E5: DATA ", n2="
E6: NOP ;fin cuerpo
WRSTR /E7
BR /E8
E7: DATA "\n"
E8: NOP ;fin cuerpo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;cuerpo write string Metodo1: n1+n2=
WRSTR /E9
BR /E10
E9: DATA "Metodo1: n1+n2="
WRSTR /E11
BR /E12
E11: DATA "\n"
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E0:
MOVE .SP,.IY;metodo
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;asignacion pos 0
POP .R0
Compiladores 89
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;cuerpo write string Estoy en Main\n
WRSTR /E13
BR /E14
E13: DATA "Estoy en Main\n"
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R2 ;incio argumentos
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
MOVE .R2,.SP ;fin argumentos
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
Compiladores 90
;valor devuelto
PUSH .R0
;cuerpo write string Resultado de metodo1:
WRSTR /E15
BR /E16
E15: DATA "Resultado de metodo1: "
WRSTR /E17
BR /E18
E17: DATA "\n"
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
Compiladores 91
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Estoy en Main
Metodo1: n1=5, n2=6
Metodo1: n1+n2=11
Resultado de metodo1: 11
Metodo1: n1=6, n2=6
Metodo1: 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 92
}
}
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);
}

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: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Compiladores 93

------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 94
------------------------------------------------
Direccion: 18
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 19
Operacion: TR_CLASE
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
------------------------------------------------
Compiladores 95
Direccion: 30
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 36
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 37
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 38
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
------------------------------------------------
Direccion: 41
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 42
Compiladores 96
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
------------------------------------------------
Direccion: 47
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 53
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 54
Compiladores 97

------------------------------------------------
Direccion: 55
Operacion: TR_ACTIVAR_REGISTRO_CLASE
------------------------------------------------
Direccion: 56
------------------------------------------------
Direccion: 57
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 58
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
------------------------------------------------
Direccion: 61
------------------------------------------------
Direccion: 62
------------------------------------------------
Direccion: 63
------------------------------------------------
Direccion: 64
------------------------------------------------
Direccion: 65
------------------------------------------------
Direccion: 66
Tipo: TR_NADA
Compiladores 98
Tipo: TR_NADA
------------------------------------------------
Direccion: 67
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 68
------------------------------------------------
Direccion: 69
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 70
------------------------------------------------
Direccion: 71
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 72
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 73
------------------------------------------------
Direccion: 74
------------------------------------------------
Direccion: 75
------------------------------------------------
Direccion: 76
------------------------------------------------
Direccion: 77
------------------------------------------------
Direccion: 78
Compiladores 99
------------------------------------------------
Direccion: 79
------------------------------------------------
Direccion: 80
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 81
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 82
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 83
------------------------------------------------
Direccion: 84
------------------------------------------------
Direccion: 85
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#1[.IX]
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
Compiladores 100
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Estoy en el Metodo1
WRSTR /E3
BR /E4
E3: DATA "Estoy en el Metodo1 "
E4: NOP ;fin cuerpo
;cuerpo write string ,
WRSTR /E5
BR /E6
E5: DATA ","
E6: NOP ;fin cuerpo
WRSTR /E7
BR /E8
E7: DATA "\n"
E8: NOP ;fin cuerpo
MOVE .IY,.SP
RET
E9: NOP ;clase
E10: NOP ;metodo
MOVE .SP,.IY;metodo
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E11
BR /E12
Compiladores 101

WRSTR /E13
BR /E14
E13: DATA ","
WRSTR /E15
BR /E16
E15: DATA "\n"
MOVE .IY,.SP
RET
E0:
MOVE .SP,.IY;metodo
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Empiezo en Main
WRSTR /E17
BR /E18
E17: DATA "Empiezo en Main "
WRSTR /E19
BR /E20
E19: DATA ","
WRSTR /E21
BR /E22
E21: DATA "\n"
Compiladores 102

;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
;activar registro clase
MOVE #-2[.IY],.R0
ADD #1,.R0
PUSH .A
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E23
BR /E24
Compiladores 103

WRSTR /E25
BR /E26
E25: DATA ","
WRSTR /E27
BR /E28
E27: DATA "\n"
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E10
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
Compiladores 104
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Termino en Main
WRSTR /E29
BR /E30
E29: DATA "Termino en Main "
WRSTR /E31
BR /E32
E31: DATA ","
WRSTR /E33
BR /E34
E33: DATA "\n"
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #3,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Empiezo en Main 1,2

Estoy en el Metodo1 3,4
Sigo en Main 1,2
Termino en Main 5,2
10.7 Prueba 7
prueba107.cs
class prueba {
short var1,var2;
Compiladores 105
public short metodo1() {

short p;
var2=3;
p=4;
console.write("Estoy en el Metodo1 {0},{1}\n",var2,p); //3,4
return 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,6
return num1+p; // 11
}

short num2;
num1=1;
num2=2;
console.write("Empiezo en Main {0},{1}\n",num1,num2); // 1,2
num2=p1.metodo1();
console.write("Sigo en Main {0},{1}\n",num1,num2); // 1,7
num2=metodo2();
console.write("Termino en Main {0},{1}\n",num1,num2); //5,11
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
Compiladores 106
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
Compiladores 107

------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
Operacion: TR_SUMA
------------------------------------------------
Direccion: 21
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 22
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 23
Operacion: TR_CLASE
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Compiladores 108
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 40
Compiladores 109
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
Operacion: TR_SUMA
------------------------------------------------
Direccion: 43
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 44
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 45
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 46
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 47
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Compiladores 110
Direccion: 53
------------------------------------------------
Direccion: 54
------------------------------------------------
Direccion: 55
------------------------------------------------
Direccion: 56
------------------------------------------------
Direccion: 57
------------------------------------------------
Direccion: 58
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 61
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 62
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 63
------------------------------------------------
Direccion: 64
------------------------------------------------
Direccion: 65
Compiladores 111
------------------------------------------------
Direccion: 66
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 67
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 68
------------------------------------------------
Direccion: 69
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 70
------------------------------------------------
Direccion: 71
------------------------------------------------
Direccion: 72
------------------------------------------------
Direccion: 73
------------------------------------------------
Direccion: 74
------------------------------------------------
Direccion: 75
------------------------------------------------
Direccion: 76
------------------------------------------------
Direccion: 77
Compiladores 112
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 78
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 79
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 80
------------------------------------------------
Direccion: 81
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 82
------------------------------------------------
Direccion: 83
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 84
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 85
------------------------------------------------
Direccion: 86
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 87
------------------------------------------------
Direccion: 88
------------------------------------------------
Direccion: 89
Compiladores 113

------------------------------------------------
Direccion: 90
------------------------------------------------
Direccion: 91
------------------------------------------------
Direccion: 92
------------------------------------------------
Direccion: 93
------------------------------------------------
Direccion: 94
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 95
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 96
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 97
------------------------------------------------
Direccion: 98
------------------------------------------------
Direccion: 99
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
Compiladores 114
MOVE .SP,.IY;metodo
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#1[.IX]
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E3
BR /E4
E4: NOP ;fin cuerpo
WRSTR /E5
BR /E6
E5: DATA ","
E6: NOP ;fin cuerpo
WRSTR /E7
BR /E8
E7: DATA "\n"
E8: NOP ;fin cuerpo
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
Compiladores 115
E9: NOP ;clase

E10: NOP ;metodo
MOVE .SP,.IY;metodo
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E11
BR /E12
WRSTR /E13
BR /E14
E13: DATA ","
WRSTR /E15
BR /E16
E15: DATA "\n"
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
Compiladores 116
MOVE .IY,.SP
RET
E0:
MOVE .SP,.IY;metodo
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Empiezo en Main
WRSTR /E17
BR /E18
E17: DATA "Empiezo en Main "
WRSTR /E19
BR /E20
E19: DATA ","
WRSTR /E21
BR /E22
E21: DATA "\n"
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
Compiladores 117
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #1,.R0
PUSH .A
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E23
BR /E24
WRSTR /E25
BR /E26
E25: DATA ","
WRSTR /E27
Compiladores 118
BR /E28
E27: DATA "\n"
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E10
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
Compiladores 119
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Termino en Main
WRSTR /E29
BR /E30
E29: DATA "Termino en Main "
WRSTR /E31
BR /E32
E31: DATA ","
WRSTR /E33
BR /E34
E33: DATA "\n"
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #3,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Empiezo en Main 1,2

Sigo en Main 1,7
Termino en Main 5,11
10.8 Prueba 8
prueba108.cs
class prueba {
public short numero1;

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

return numero1+numero2;
}
}
class prueba2 {
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;
}

short s2;
p1.numero1=2;
p1.numero2=3;
//s1=p1.numero1; //da error que no deberia
s1=2+p1.metodo1()+2; // 9
s2=1+metodo3()+1; // 7
console.write("Estoy en Main: {0},{1},{2},{3}\n",s1,s2,
p1.numero1,p1.numero2);
p2.numero3=4;
p2.metodo22(); //4
p2.metodo2(5); //4,5
console.write("Sigo en Main: {0},{1}\n",p2.numero3,s1); // 4,9
console.write("Estoy en Main: {0},{1},{2},{3}\n",s1,s2,
p1.numero1,p1.numero2);
}
}
salida.ter
Compiladores 121
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 122
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Operacion: TR_SUMA
------------------------------------------------
Direccion: 15
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 16
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 17
Operacion: TR_CLASE
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
------------------------------------------------
Compiladores 123
Direccion: 24
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
------------------------------------------------
Direccion: 36
Compiladores 124
------------------------------------------------
Direccion: 37
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
Operacion: TR_SUMA
------------------------------------------------
Direccion: 41
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 42
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 43
Operacion: TR_CLASE
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 47
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 48
Compiladores 125
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 49
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 53
------------------------------------------------
Direccion: 54
------------------------------------------------
Direccion: 55
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 56
------------------------------------------------
Direccion: 57
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 58
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
Compiladores 126

------------------------------------------------
Direccion: 61
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 62
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 63
Operacion: TR_SUMA
------------------------------------------------
Direccion: 64
------------------------------------------------
Direccion: 65
Operacion: TR_SUMA
------------------------------------------------
Direccion: 66
------------------------------------------------
Direccion: 67
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 68
------------------------------------------------
Direccion: 69
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 70
------------------------------------------------
Direccion: 71
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 72
Compiladores 127
------------------------------------------------
Direccion: 73
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 74
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 75
Operacion: TR_SUMA
------------------------------------------------
Direccion: 76
------------------------------------------------
Direccion: 77
Operacion: TR_SUMA
------------------------------------------------
Direccion: 78
------------------------------------------------
Direccion: 79
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 80
------------------------------------------------
Direccion: 81
------------------------------------------------
Direccion: 82
------------------------------------------------
Direccion: 83
------------------------------------------------
Direccion: 84
------------------------------------------------
Compiladores 128
Direccion: 85
------------------------------------------------
Direccion: 86
------------------------------------------------
Direccion: 87
------------------------------------------------
Direccion: 88
------------------------------------------------
Direccion: 89
------------------------------------------------
Direccion: 90
------------------------------------------------
Direccion: 91
------------------------------------------------
Direccion: 92
------------------------------------------------
Direccion: 93
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 94
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 95
------------------------------------------------
Direccion: 96
------------------------------------------------
Direccion: 97
Compiladores 129
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 98
------------------------------------------------
Direccion: 99
------------------------------------------------
Direccion: 100
------------------------------------------------
Direccion: 101
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 102
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 103
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 104
------------------------------------------------
Direccion: 105
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 106
------------------------------------------------
Direccion: 107
------------------------------------------------
Direccion: 108
------------------------------------------------
Direccion: 109
Compiladores 130
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 110
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 111
------------------------------------------------
Direccion: 112
------------------------------------------------
Direccion: 113
------------------------------------------------
Direccion: 114
------------------------------------------------
Direccion: 115
------------------------------------------------
Direccion: 116
------------------------------------------------
Direccion: 117
------------------------------------------------
Direccion: 118
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 119
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 120
------------------------------------------------
Direccion: 121
Compiladores 131

------------------------------------------------
Direccion: 122
------------------------------------------------
Direccion: 123
------------------------------------------------
Direccion: 124
------------------------------------------------
Direccion: 125
------------------------------------------------
Direccion: 126
------------------------------------------------
Direccion: 127
------------------------------------------------
Direccion: 128
------------------------------------------------
Direccion: 129
------------------------------------------------
Direccion: 130
------------------------------------------------
Direccion: 131
------------------------------------------------
Direccion: 132
------------------------------------------------
Direccion: 133
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 132
------------------------------------------------
Direccion: 134
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 135
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 136
------------------------------------------------
Direccion: 137
------------------------------------------------
Direccion: 138
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;cuerpo write string Estoy en Metodo1:
WRSTR /E3
BR /E4
E3: DATA "Estoy en Metodo1: "
E4: NOP ;fin cuerpo
WRSTR /E5
BR /E6
E5: DATA ","
E6: NOP ;fin cuerpo
WRSTR /E7
BR /E8
E7: DATA "\n"
Compiladores 133
E8: NOP ;fin cuerpo

;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E9: NOP ;clase
E10: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E11
BR /E12
WRSTR /E13
BR /E14
E13: DATA "\n"
;valor inmediato 22
MOVE #22,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E15: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E16
BR /E17
Compiladores 134

WRSTR /E18
BR /E19
E18: DATA ","
WRSTR /E20
BR /E21
E20: DATA "\n"
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E22: NOP ;clase
E23: NOP ;metodo
MOVE .SP,.IY;metodo
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E0:
MOVE .SP,.IY;metodo
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#1[.IX]
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 2
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#2[.IX]
;valor inmediato 2
Compiladores 135
MOVE #2,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #1,.R0
PUSH .A
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
Compiladores 136
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E23
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;valor inmediato 1
Compiladores 137
MOVE #1,.R0
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;cuerpo write string Estoy en Main:
WRSTR /E24
BR /E25
E24: DATA "Estoy en Main: "
WRSTR /E26
BR /E27
E26: DATA ","
WRSTR /E28
BR /E29
E28: DATA ","
WRSTR /E30
BR /E31
E30: DATA ","
WRSTR /E32
BR /E33
E32: DATA "\n"
;valor inmediato 4
MOVE #4,.R0
Compiladores 138
PUSH .R0
;asignacion pos 5
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#5[.IX]
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #5,.R0
PUSH .A
CALL /E10
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
Compiladores 139
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #5,.R0
PUSH .A
CALL /E15
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor de variable
MOVE #-2[.IY],.IX
MOVE #5[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Sigo en Main:
WRSTR /E34
BR /E35
E34: DATA "Sigo en Main: "
WRSTR /E36
BR /E37
E36: DATA ","
Compiladores 140
WRSTR /E38
BR /E39
E38: DATA "\n"
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
WRSTR /E40
BR /E41
WRSTR /E42
BR /E43
E42: DATA ","
WRSTR /E44
BR /E45
E44: DATA ","
WRSTR /E46
BR /E47
E46: DATA ","
WRSTR /E48
BR /E49
E48: DATA "\n"
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #6,.SP
MOVE .A,.SP
MOVE .SP,.R0
Compiladores 141
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Estoy en Metodo1: 2,3

Estoy en Main: 9,7,2,3
Estoy en Metodo22: 4
Sigo en Main: 4,9
Estoy 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 142
p2.metodo2(p1.numero1); //5,6
console.write("Estoy en Main: {0},{1}\n",p1.numero1,p2.numero2);
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 9
Compiladores 143
------------------------------------------------
Direccion: 10
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
Operacion: TR_CLASE
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
------------------------------------------------
Compiladores 144
Direccion: 22
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 25
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 26
Operacion: TR_CLASE
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
Compiladores 145
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 35
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
------------------------------------------------
Direccion: 41
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 42
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
Compiladores 146

------------------------------------------------
Direccion: 47
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 51
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 52
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 53
------------------------------------------------
Direccion: 54
------------------------------------------------
Direccion: 55
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-2[.IY],.IX
Compiladores 147
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E3
BR /E4
E4: NOP ;fin cuerpo
WRSTR /E5
BR /E6
E5: DATA "\n"
E6: NOP ;fin cuerpo
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E7: NOP ;clase
E8: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
WRSTR /E9
BR /E10
WRSTR /E11
BR /E12
E11: DATA ","
WRSTR /E13
BR /E14
E13: DATA "\n"
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E15: NOP ;clase
E0:
MOVE .SP,.IY;metodo
Compiladores 148
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#1[.IX]
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #1,.R0
PUSH .A
CALL /E8
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
Compiladores 149
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
WRSTR /E16
BR /E17
WRSTR /E18
BR /E19
E18: DATA ","
WRSTR /E20
BR /E21
E20: DATA "\n"
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución

Estoy en Main: 5,6
10.10 Prueba 10
Compiladores 150
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: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Compiladores 151
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 11
Operacion: TR_CLASE
------------------------------------------------
Direccion: 12
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 13
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
------------------------------------------------
Compiladores 152
Direccion: 16
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 20
Operacion: TR_CLASE
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 26
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
Compiladores 153
------------------------------------------------
Direccion: 29
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
E2: NOP ;metodo
MOVE .SP,.IY;metodo
;cuerpo write string Estoy en Metodo1\n
WRSTR /E3
BR /E4
E3: DATA "Estoy en Metodo1\n"
E4: NOP ;fin cuerpo
;valor de variable
MOVE #-2[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E5: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#1[.IX]
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
Compiladores 154
MOVE .IY,.SP
RET
E6: NOP ;clase
E7: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-2[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-2[.IY],.IX
MOVE .R0,#0[.IX]
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
Esta prueba no imprime nada por pantalla
10.11 Prueba 11
prueba111.cs
class clase{

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 155
console.write("hola2\n");
}
if (num==1) {
console.write("adios2\n");
}
num=3;
return;
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
Compiladores 156
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Compiladores 157
Direccion: 21
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
Compiladores 158
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 45
Compiladores 159

------------------------------------------------
Direccion: 46
------------------------------------------------
Direccion: 47
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 48
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 49
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
MOVE #0,.R3 ;inicio if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
Compiladores 160
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;comp igual op 1 eti 4
POP .R1
POP .R0
CMP .R0,.R1
BZ /E4
BR /E5
E4: MOVE #1,.R3;
E5: NOP; fin comp igual
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E6
BR /E7
E6: MOVE #1,.R3;
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E8
BR /E9
E8: MOVE #1,.R3;
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E10
BR /E11
E10: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E2
Compiladores 161
;cuerpo write string hola1\n

WRSTR /E12
BR /E13
E12: DATA "hola1\n"
;cuerpo else 2
BR /E3
E2: NOP
;cuerpo write string adios1\n
WRSTR /E14
BR /E15
E14: DATA "adios1\n"
E3: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E18
BR /E19
E18: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E16
;cuerpo write string hola2\n
WRSTR /E20
BR /E21
E20: DATA "hola2\n"
;cuerpo else 16
BR /E17
E16: NOP
E17: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E24
BR /E25
E24: MOVE #1,.R3;
;cuerpo if
Compiladores 162
CMP #0,.R3
BZ /E22
;cuerpo write string adios2\n
WRSTR /E26
BR /E27
E26: DATA "adios2\n"
;cuerpo else 22
BR /E23
E22: NOP
E23: NOP; fin if
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
adios1
hola2
10.12 Prueba 12
prueba112.cs
class clase{

short num;
num=4;
//num=0-3;
Compiladores 163
if (num==1)
console.write("num es igual a 1\n");
else if (num==2)
else if (num==3)
else if (num==4)
else if (num==5)
else
console.write("num es >5 o <1\n");
num=3;
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
Compiladores 164
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
Compiladores 165
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 31
Compiladores 166

------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
------------------------------------------------
Direccion: 43
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 167
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 47
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
------------------------------------------------
Direccion: 53
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 54
------------------------------------------------
Direccion: 55
------------------------------------------------
Compiladores 168
Direccion: 56
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 57
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 58
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E4
BR /E5
E4: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
Compiladores 169
BZ /E2
;cuerpo write string num es igual a 1\n
WRSTR /E6
BR /E7
E6: DATA "num es igual a 1\n"
E7: NOP ;fin cuerpo
;cuerpo else 2
BR /E3
E2: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E10
BR /E11
E10: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E8
WRSTR /E12
BR /E13
;cuerpo else 8
BR /E9
E8: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E16
BR /E17
E16: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E14
WRSTR /E18
BR /E19
Compiladores 170

;cuerpo else 14
BR /E15
E14: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E22
BR /E23
E22: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E20
WRSTR /E24
BR /E25
;cuerpo else 20
BR /E21
E20: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E28
BR /E29
E28: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E26
WRSTR /E30
BR /E31
;cuerpo else 26
BR /E27
E26: NOP
Compiladores 171

;cuerpo write string num es >5 o <1\n
WRSTR /E32
BR /E33
E32: DATA "num es >5 o <1\n"
E27: NOP; fin if
E21: NOP; fin if
E15: NOP; fin if
E9: NOP; fin if
E3: NOP; fin if
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
num es igual a 4
10.13 Prueba 13
prueba113.cs
class clase{

short num;
num=4;
if (num==4) //verdadero
else
Compiladores 172
if (num>5) //falso
else
if (num<5) //verdadero
else
if (num!=4) //false
else
if (num>=4) //verdarero
else
if (num<=10) //verdarero
else
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Compiladores 173
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
Compiladores 174
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
------------------------------------------------
Direccion: 22
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 26
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
Compiladores 175

------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
------------------------------------------------
Direccion: 33
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
------------------------------------------------
Direccion: 36
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 40
------------------------------------------------
Direccion: 41
Compiladores 176
------------------------------------------------
Direccion: 42
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
------------------------------------------------
Direccion: 47
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 48
------------------------------------------------
Direccion: 49
------------------------------------------------
Direccion: 50
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
------------------------------------------------
Direccion: 53
------------------------------------------------
Compiladores 177
Direccion: 54
------------------------------------------------
Direccion: 55
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 56
------------------------------------------------
Direccion: 57
------------------------------------------------
Direccion: 58
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
------------------------------------------------
Direccion: 61
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 62
------------------------------------------------
Direccion: 63
------------------------------------------------
Direccion: 64
------------------------------------------------
Direccion: 65
------------------------------------------------
Direccion: 66
Compiladores 178
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 67
------------------------------------------------
Direccion: 68
------------------------------------------------
Direccion: 69
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 70
------------------------------------------------
Direccion: 71
------------------------------------------------
Direccion: 72
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 73
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 74
------------------------------------------------
Direccion: 75
------------------------------------------------
Direccion: 76
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
Compiladores 179
E0:
MOVE .SP,.IY;metodo
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E4
BR /E5
E4: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E2
;cuerpo write string verdadero\n
WRSTR /E6
BR /E7
E6: DATA "verdadero\n"
E7: NOP ;fin cuerpo
;cuerpo else 2
BR /E3
E2: NOP
;cuerpo write string falso\n
WRSTR /E8
BR /E9
E8: DATA "falso\n"
E9: NOP ;fin cuerpo
E3: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E13
BP /E12
BR /E13
E12: MOVE #1,.R3;
Compiladores 180

;cuerpo if
CMP #0,.R3
BZ /E10
WRSTR /E14
BR /E15
;cuerpo else 10
BR /E11
E10: NOP
WRSTR /E16
BR /E17
E16: DATA "falso\n"
E11: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 5
MOVE #5,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BN /E20
BR /E21
E20: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E18
WRSTR /E22
BR /E23
;cuerpo else 18
BR /E19
E18: NOP
WRSTR /E24
BR /E25
E24: DATA "falso\n"
E19: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 4
Compiladores 181
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BNZ /E28
BR /E29
E28: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E26
WRSTR /E30
BR /E31
;cuerpo else 26
BR /E27
E26: NOP
WRSTR /E32
BR /E33
E32: DATA "falso\n"
E27: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E36
BR /E37
E36: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E34
WRSTR /E38
BR /E39
;cuerpo else 34
BR /E35
E34: NOP
WRSTR /E40
BR /E41
Compiladores 182
E40: DATA "falso\n"

E35: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 10
MOVE #10,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BN /E44
BZ /E44
BR /E45
E44: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E42
WRSTR /E46
BR /E47
;cuerpo else 42
BR /E43
E42: NOP
WRSTR /E48
BR /E49
E48: DATA "falso\n"
E43: NOP; fin if
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
verdadero
falso
verdadero
Compiladores 183
falso
verdadero
verdadero
10.14 Prueba 14
prueba114.cs
class clase{

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

num=Console.Read();
Console.Write("Has escrito un {0}\n",num);
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 184
------------------------------------------------
Direccion: 6
Operacion: TR_CONSOLE_READ
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 9
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 14
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 15
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
------------------------------------------------
Compiladores 185
Direccion: 18
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;cuerpo write string Escribe un numero:
WRSTR /E2
BR /E3
E2: DATA "Escribe un numero: "
E3: NOP ;fin cuerpo
;console read
ININT .R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Has escrito un
WRSTR /E4
BR /E5
E4: DATA "Has escrito un "
E5: NOP ;fin cuerpo
WRSTR /E6
BR /E7
E6: DATA "\n"
E7: NOP ;fin cuerpo
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
Compiladores 186
INICIO_PILA:
Ejecución
Escribe un numero: 2334

Has 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;
else
return 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 positivo
return mulaux(a,b);
else // b es negativo
return 0-mulaux(a,0-b);
else // a es negativo
return 0-mulaux(0-a,b);
return mulaux(0-a,0-b);
private short divaux(short a,short b){
if (b==1)
return a;
else if (b>a)
return 0;
else
return 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
return divaux(a,b);
Compiladores 187
return 0-divaux(a,0-b);
else // a es negativo
return 0-divaux(0-a,b);
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;

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 188
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: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
------------------------------------------------
Direccion: 3
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
------------------------------------------------
Direccion: 6
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
Compiladores 189

------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
------------------------------------------------
Direccion: 11
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 12
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 190
------------------------------------------------
Direccion: 21
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
Operacion: TR_SUMA
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
------------------------------------------------
Direccion: 28
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 31
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 32
Operacion: TR_SUMA
------------------------------------------------
Compiladores 191
Direccion: 33
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
------------------------------------------------
Direccion: 36
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 37
------------------------------------------------
Direccion: 38
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 39
------------------------------------------------
Direccion: 40
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
------------------------------------------------
Direccion: 43
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
Compiladores 192
------------------------------------------------
Direccion: 46
------------------------------------------------
Direccion: 47
------------------------------------------------
Direccion: 48
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 49
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 53
------------------------------------------------
Direccion: 54
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 55
------------------------------------------------
Direccion: 56
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 57
Compiladores 193
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 58
------------------------------------------------
Direccion: 59
------------------------------------------------
Direccion: 60
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 61
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 62
------------------------------------------------
Direccion: 63
------------------------------------------------
Direccion: 64
------------------------------------------------
Direccion: 65
Operacion: TR_SUMA
------------------------------------------------
Direccion: 66
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 67
------------------------------------------------
Direccion: 68
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 69
Compiladores 194

------------------------------------------------
Direccion: 70
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 71
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 72
Operacion: TR_SUMA
------------------------------------------------
Direccion: 73
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 74
------------------------------------------------
Direccion: 75
------------------------------------------------
Direccion: 76
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 77
------------------------------------------------
Direccion: 78
------------------------------------------------
Direccion: 79
------------------------------------------------
Direccion: 80
------------------------------------------------
Direccion: 81
Compiladores 195
------------------------------------------------
Direccion: 82
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 83
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 84
------------------------------------------------
Direccion: 85
------------------------------------------------
Direccion: 86
Operacion: TR_SUMA
------------------------------------------------
Direccion: 87
------------------------------------------------
Direccion: 88
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 89
------------------------------------------------
Direccion: 90
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 91
------------------------------------------------
Direccion: 92
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 93
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Compiladores 196
Direccion: 94
Operacion: TR_SUMA
------------------------------------------------
Direccion: 95
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 96
------------------------------------------------
Direccion: 97
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 98
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 99
------------------------------------------------
Direccion: 100
------------------------------------------------
Direccion: 101
Operacion: TR_SUMA
------------------------------------------------
Direccion: 102
------------------------------------------------
Direccion: 103
------------------------------------------------
Direccion: 104
Operacion: TR_SUMA
------------------------------------------------
Direccion: 105
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 106
Compiladores 197
------------------------------------------------
Direccion: 107
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 108
------------------------------------------------
Direccion: 109
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 110
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 111
------------------------------------------------
Direccion: 112
------------------------------------------------
Direccion: 113
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 114
------------------------------------------------
Direccion: 115
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 116
------------------------------------------------
Direccion: 117
------------------------------------------------
Direccion: 118
Compiladores 198

------------------------------------------------
Direccion: 119
------------------------------------------------
Direccion: 120
------------------------------------------------
Direccion: 121
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 122
------------------------------------------------
Direccion: 123
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 124
------------------------------------------------
Direccion: 125
------------------------------------------------
Direccion: 126
------------------------------------------------
Direccion: 127
------------------------------------------------
Direccion: 128
------------------------------------------------
Direccion: 129
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 130
Compiladores 199

------------------------------------------------
Direccion: 131
------------------------------------------------
Direccion: 132
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 133
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 134
------------------------------------------------
Direccion: 135
------------------------------------------------
Direccion: 136
Operacion: TR_SUMA
------------------------------------------------
Direccion: 137
------------------------------------------------
Direccion: 138
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 139
------------------------------------------------
Direccion: 140
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 141
------------------------------------------------
Direccion: 142
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 200
------------------------------------------------
Direccion: 143
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 144
Operacion: TR_SUMA
------------------------------------------------
Direccion: 145
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 146
------------------------------------------------
Direccion: 147
------------------------------------------------
Direccion: 148
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 149
------------------------------------------------
Direccion: 150
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 151
------------------------------------------------
Direccion: 152
------------------------------------------------
Direccion: 153
------------------------------------------------
Direccion: 154
------------------------------------------------
Compiladores 201
Direccion: 155
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 156
------------------------------------------------
Direccion: 157
------------------------------------------------
Direccion: 158
------------------------------------------------
Direccion: 159
------------------------------------------------
Direccion: 160
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 161
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 162
------------------------------------------------
Direccion: 163
------------------------------------------------
Direccion: 164
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 165
------------------------------------------------
Direccion: 166
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 167
Compiladores 202
------------------------------------------------
Direccion: 168
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 169
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 170
------------------------------------------------
Direccion: 171
------------------------------------------------
Direccion: 172
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 173
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 174
------------------------------------------------
Direccion: 175
------------------------------------------------
Direccion: 176
------------------------------------------------
Direccion: 177
Operacion: TR_SUMA
------------------------------------------------
Direccion: 178
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 179
Compiladores 203

------------------------------------------------
Direccion: 180
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 181
------------------------------------------------
Direccion: 182
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 183
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 184
Operacion: TR_SUMA
------------------------------------------------
Direccion: 185
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 186
------------------------------------------------
Direccion: 187
------------------------------------------------
Direccion: 188
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 189
------------------------------------------------
Direccion: 190
------------------------------------------------
Direccion: 191
Compiladores 204

------------------------------------------------
Direccion: 192
------------------------------------------------
Direccion: 193
------------------------------------------------
Direccion: 194
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 195
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 196
------------------------------------------------
Direccion: 197
------------------------------------------------
Direccion: 198
Operacion: TR_SUMA
------------------------------------------------
Direccion: 199
------------------------------------------------
Direccion: 200
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 201
------------------------------------------------
Direccion: 202
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 203
Compiladores 205
------------------------------------------------
Direccion: 204
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 205
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 206
Operacion: TR_SUMA
------------------------------------------------
Direccion: 207
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 208
------------------------------------------------
Direccion: 209
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 210
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 211
------------------------------------------------
Direccion: 212
------------------------------------------------
Direccion: 213
Operacion: TR_SUMA
------------------------------------------------
Direccion: 214
------------------------------------------------
Direccion: 215
------------------------------------------------
Compiladores 206
Direccion: 216
Operacion: TR_SUMA
------------------------------------------------
Direccion: 217
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 218
------------------------------------------------
Direccion: 219
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 220
------------------------------------------------
Direccion: 221
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 222
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 223
------------------------------------------------
Direccion: 224
------------------------------------------------
Direccion: 225
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 226
------------------------------------------------
Direccion: 227
------------------------------------------------
Direccion: 228
Compiladores 207
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 229
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 230
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 231
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 232
------------------------------------------------
Direccion: 233
------------------------------------------------
Direccion: 234
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 235
------------------------------------------------
Direccion: 236
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 237
------------------------------------------------
Direccion: 238
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 239
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 240
Compiladores 208

------------------------------------------------
Direccion: 241
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 242
------------------------------------------------
Direccion: 243
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 244
------------------------------------------------
Direccion: 245
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 246
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 247
Operacion: TR_SUMA
------------------------------------------------
Direccion: 248
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 249
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 250
------------------------------------------------
Direccion: 251
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 252
Compiladores 209

------------------------------------------------
Direccion: 253
------------------------------------------------
Direccion: 254
------------------------------------------------
Direccion: 255
------------------------------------------------
Direccion: 256
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 257
------------------------------------------------
Direccion: 258
------------------------------------------------
Direccion: 259
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 260
------------------------------------------------
Direccion: 261
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 262
------------------------------------------------
Direccion: 263
------------------------------------------------
Direccion: 264
Compiladores 210
------------------------------------------------
Direccion: 265
------------------------------------------------
Direccion: 266
------------------------------------------------
Direccion: 267
------------------------------------------------
Direccion: 268
------------------------------------------------
Direccion: 269
------------------------------------------------
Direccion: 270
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 271
------------------------------------------------
Direccion: 272
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 273
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 274
------------------------------------------------
Direccion: 275
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 276
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Compiladores 211
Direccion: 277
------------------------------------------------
Direccion: 278
------------------------------------------------
Direccion: 279
Operacion: TR_SUMA
------------------------------------------------
Direccion: 280
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 281
------------------------------------------------
Direccion: 282
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 283
------------------------------------------------
Direccion: 284
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 285
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 286
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 287
------------------------------------------------
Direccion: 288
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 289
Compiladores 212
------------------------------------------------
Direccion: 290
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 291
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 292
------------------------------------------------
Direccion: 293
------------------------------------------------
Direccion: 294
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 295
Operacion: TR_CLASE
------------------------------------------------
Direccion: 296
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 297
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 298
------------------------------------------------
Direccion: 299
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 300
------------------------------------------------
Direccion: 301
Compiladores 213
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 302
------------------------------------------------
Direccion: 303
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 304
------------------------------------------------
Direccion: 305
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 306
------------------------------------------------
Direccion: 307
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 308
------------------------------------------------
Direccion: 309
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 310
------------------------------------------------
Direccion: 311
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 312
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 313
Compiladores 214

------------------------------------------------
Direccion: 314
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 315
------------------------------------------------
Direccion: 316
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 317
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 318
------------------------------------------------
Direccion: 319
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 320
------------------------------------------------
Direccion: 321
------------------------------------------------
Direccion: 322
------------------------------------------------
Direccion: 323
------------------------------------------------
Direccion: 324
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 325
Compiladores 215
------------------------------------------------
Direccion: 326
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 327
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 328
------------------------------------------------
Direccion: 329
------------------------------------------------
Direccion: 330
------------------------------------------------
Direccion: 331
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 332
------------------------------------------------
Direccion: 333
------------------------------------------------
Direccion: 334
------------------------------------------------
Direccion: 335
------------------------------------------------
Direccion: 336
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 337
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Compiladores 216
Direccion: 338
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 339
------------------------------------------------
Direccion: 340
------------------------------------------------
Direccion: 341
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 342
------------------------------------------------
Direccion: 343
------------------------------------------------
Direccion: 344
------------------------------------------------
Direccion: 345
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 346
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 347
------------------------------------------------
Direccion: 348
------------------------------------------------
Direccion: 349
------------------------------------------------
Direccion: 350
Compiladores 217
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 351
------------------------------------------------
Direccion: 352
------------------------------------------------
Direccion: 353
------------------------------------------------
Direccion: 354
------------------------------------------------
Direccion: 355
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 356
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 357
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 358
------------------------------------------------
Direccion: 359
------------------------------------------------
Direccion: 360
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 361
------------------------------------------------
Direccion: 362
Compiladores 218

------------------------------------------------
Direccion: 363
------------------------------------------------
Direccion: 364
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 365
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 366
------------------------------------------------
Direccion: 367
------------------------------------------------
Direccion: 368
------------------------------------------------
Direccion: 369
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 370
------------------------------------------------
Direccion: 371
------------------------------------------------
Direccion: 372
------------------------------------------------
Direccion: 373
------------------------------------------------
Direccion: 374
Tipo: TR_NADA
Compiladores 219
Tipo: TR_NADA
------------------------------------------------
Direccion: 375
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 376
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 377
------------------------------------------------
Direccion: 378
------------------------------------------------
Direccion: 379
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 380
------------------------------------------------
Direccion: 381
------------------------------------------------
Direccion: 382
------------------------------------------------
Direccion: 383
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 384
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 385
------------------------------------------------
Direccion: 386
Compiladores 220
------------------------------------------------
Direccion: 387
------------------------------------------------
Direccion: 388
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 389
------------------------------------------------
Direccion: 390
------------------------------------------------
Direccion: 391
------------------------------------------------
Direccion: 392
------------------------------------------------
Direccion: 393
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 394
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 395
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 396
------------------------------------------------
Direccion: 397
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 398
------------------------------------------------
Compiladores 221
Direccion: 399
------------------------------------------------
Direccion: 400
------------------------------------------------
Direccion: 401
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 402
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 403
------------------------------------------------
Direccion: 404
------------------------------------------------
Direccion: 405
------------------------------------------------
Direccion: 406
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 407
------------------------------------------------
Direccion: 408
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 409
------------------------------------------------
Direccion: 410
------------------------------------------------
Direccion: 411
Compiladores 222
------------------------------------------------
Direccion: 412
------------------------------------------------
Direccion: 413
------------------------------------------------
Direccion: 414
------------------------------------------------
Direccion: 415
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 416
------------------------------------------------
Direccion: 417
------------------------------------------------
Direccion: 418
------------------------------------------------
Direccion: 419
------------------------------------------------
Direccion: 420
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 421
------------------------------------------------
Direccion: 422
------------------------------------------------
Direccion: 423
Compiladores 223

------------------------------------------------
Direccion: 424
------------------------------------------------
Direccion: 425
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 426
------------------------------------------------
Direccion: 427
------------------------------------------------
Direccion: 428
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 429
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 430
------------------------------------------------
Direccion: 431
------------------------------------------------
Direccion: 432
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E2: NOP ;metodo
MOVE .SP,.IY;metodo
Compiladores 224

;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E5
BR /E6
E5: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E3
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 3
BR /E4
E3: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E9
BR /E10
E9: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E7
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 7
BR /E8
E7: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;guardar estado
PUSH .SP
Compiladores 225
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
Compiladores 226
PUSH .R0
POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
E8: NOP; fin if
E4: NOP; fin if
MOVE .IY,.SP
RET
E11: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E14
BR /E15
E14: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E12
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E18
BR /E19
E18: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E16
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
Compiladores 227
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
RET
;cuerpo else 16
BR /E17
E16: NOP
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
Compiladores 228
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
Compiladores 229
MOVE .IY,.SP
RET
E17: NOP; fin if
;cuerpo else 12
BR /E13
E12: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E22
BR /E23
E22: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E20
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
Compiladores 230

MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 20
BR /E21
E20: NOP
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
Compiladores 231
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E2
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
RET
E21: NOP; fin if
E13: NOP; fin if
MOVE .IY,.SP
RET
E24: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
Compiladores 232
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E27
BR /E28
E27: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E25
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 25
BR /E26
E25: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E32
BP /E31
BR /E32
E31: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E29
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 29
BR /E30
E29: NOP
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
Compiladores 233
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E24
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
Compiladores 234

POP .R3
ADD .R3,.R0 ;suma
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
E30: NOP; fin if
E26: NOP; fin if
MOVE .IY,.SP
RET
E33: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E36
BR /E37
E36: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E34
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E40
BR /E41
E40: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E38
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
Compiladores 235
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E24
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
RET
;cuerpo else 38
BR /E39
E38: NOP
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
Compiladores 236
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E24
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
Compiladores 237
RET
E39: NOP; fin if
;cuerpo else 34
BR /E35
E34: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BP /E44
BR /E45
E44: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E42
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
Compiladores 238

MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E24
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 42
BR /E43
E42: NOP
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
Compiladores 239
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E24
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
RET
E43: NOP; fin if
E35: NOP; fin if
MOVE .IY,.SP
RET
E46: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
Compiladores 240
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E33
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
Compiladores 241
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E11
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
MOVE .IY,.SP
RET
MOVE .IY,.SP
RET
E47: NOP ;metodo
MOVE .SP,.IY;metodo
;valor de variable
MOVE #-3[.IY],.IX
Compiladores 242
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BN /E50
BR /E51
E50: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E48
;cuerpo write string ERROR: factorial negativo
WRSTR /E52
BR /E53
E52: DATA "ERROR: factorial negativo"
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 48
BR /E49
E48: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E56
BR /E57
E56: MOVE #1,.R3;
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E58
BR /E59
E58: MOVE #1,.R3;
Compiladores 243
;cuerpo if
CMP #0,.R3
BZ /E54
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
MOVE .IY,.SP
RET
;cuerpo else 54
BR /E55
E54: NOP
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R3
SUB .R3,.R0 ;resta
MOVE .A,.R0
PUSH .R0
Compiladores 244

MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E47
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
PUSH .R0
CALL /E11
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
MOVE .IY,.SP
Compiladores 245
RET
E55: NOP; fin if
E49: NOP; fin if
MOVE .IY,.SP
RET
E60: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;cuerpo write string \tCALCULADORA\n
WRSTR /E61
BR /E62
E61: DATA "\tCALCULADORA\n"
;cuerpo write string Operacines:\n\n
WRSTR /E63
BR /E64
E63: DATA "Operacines:\n\n"
;cuerpo write string 1 .. Multiplicar\n
WRSTR /E65
BR /E66
E65: DATA "1 .. Multiplicar\n"
;cuerpo write string 2 .. Dividir\n
WRSTR /E67
BR /E68
E67: DATA "2 .. Dividir\n"
;cuerpo write string 3 .. Resto\n
WRSTR /E69
BR /E70
E69: DATA "3 .. Resto\n"
;cuerpo write string 4 .. Factorial\n
WRSTR /E71
BR /E72
E71: DATA "4 .. Factorial\n"
;cuerpo write string \nIntroduzca la operacion:
WRSTR /E73
BR /E74
E73: DATA "\nIntroduzca la operacion: "
;console read
ININT .R0
PUSH .R0
;asignacion pos 2
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#2[.IX]
;cuerpo write string Introduzca el Operando1:
WRSTR /E75
Compiladores 246
BR /E76
E75: DATA "Introduzca el Operando1: "
;console read
ININT .R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BNZ /E79
BR /E80
E79: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E77
;cuerpo write string Introduzca el Operando2:
WRSTR /E81
BR /E82
E81: DATA "Introduzca el Operando2: "
;console read
ININT .R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#1[.IX]
;cuerpo else 77
BR /E78
E77: NOP
E78: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E85
Compiladores 247
BR /E86
E85: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E83
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #0,.R0
PUSH .A
CALL /E11
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
Compiladores 248

;valor devuelto
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;cuerpo else 83
BR /E84
E83: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E89
BR /E90
E89: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E87
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
Compiladores 249
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #0,.R0
PUSH .A
CALL /E33
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;cuerpo else 87
BR /E88
E87: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E93
BR /E94
E93: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E91
Compiladores 250
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #2,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #0,.R0
PUSH .A
CALL /E46
DEC .SP
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
Compiladores 251
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;cuerpo else 91
BR /E92
E91: NOP
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BZ /E97
BR /E98
E97: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E95
;guardar estado
PUSH .SP
PUSH .SR
PUSH .IX
PUSH .IY
PUSH .A
PUSH .R1
PUSH .R2
PUSH .R3
PUSH .R4
PUSH .R5
PUSH .R6
PUSH .R7
PUSH .R8
PUSH .R9
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
PUSH .R0
MOVE #-2[.IY],.R0
ADD #0,.R0
PUSH .A
CALL /E47
DEC .SP
Compiladores 252
POP .SP
;restaurar estado
POP .R9
POP .R8
POP .R7
POP .R6
POP .R5
POP .R4
POP .R3
POP .R2
POP .R1
POP .A
POP .IY
POP .IX
POP .SR
POP .SP
;valor devuelto
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;cuerpo else 95
BR /E96
E95: NOP
;cuerpo write string Operacion no definida\n
WRSTR /E99
BR /E100
E99: DATA "Operacion no definida\n"
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
;asignacion pos 2
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#2[.IX]
E96: NOP; fin if
E92: NOP; fin if
E88: NOP; fin if
E84: NOP; fin if
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
;valor inmediato 0
MOVE #0,.R0
PUSH .R0
POP .R1
POP .R0
CMP .R0,.R1
BNZ /E103
Compiladores 253
BR /E104
E103: MOVE #1,.R3;
;cuerpo if
CMP #0,.R3
BZ /E101
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Resultado:
WRSTR /E105
BR /E106
E105: DATA "Resultado: "
WRSTR /E107
BR /E108
E107: DATA "\n"
;cuerpo else 101
BR /E102
E101: NOP
E102: NOP; fin if
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #0,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #3,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_PILA:
Ejecución
CALCULADORA
Operacines:
1 .. Multiplicar
2 .. Dividir
3 .. Resto
Compiladores 254
4 .. Factorial
Introduzca la operacion: 4
Introduzca el Operando1: 7
Resultado: 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: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
Operacion: TR_INICIO_VECTOR
Tipo: TR_NADA
Compiladores 255
Tipo: TR_NADA
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Operacion: TR_FIN_VECTOR
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
Operacion: TR_ASIGNACION_VECTOR
------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 13
Operacion: TR_VALOR_VARIABLE_VECTOR
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
Tipo: TR_NADA
Tipo: TR_NADA
Compiladores 256
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 18
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 19
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 20
------------------------------------------------
Direccion: 21
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 22
------------------------------------------------
Direccion: 23
------------------------------------------------
Direccion: 24
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Compiladores 257
Direccion: 28
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 33
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 34
------------------------------------------------
Direccion: 35
------------------------------------------------
Direccion: 36
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 37
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 38
------------------------------------------------
Direccion: 39
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 40
Compiladores 258
------------------------------------------------
Direccion: 41
------------------------------------------------
Direccion: 42
------------------------------------------------
Direccion: 43
------------------------------------------------
Direccion: 44
------------------------------------------------
Direccion: 45
------------------------------------------------
Direccion: 46
------------------------------------------------
Direccion: 47
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 48
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 49
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 50
------------------------------------------------
Direccion: 51
------------------------------------------------
Direccion: 52
Compiladores 259
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
E0:
MOVE .SP,.IY;metodo
;inicio vector
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;Fin vector
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion vector pos 1
POP .R0
MOVE #-3[.IY],.IX
POP .A
ADD #1,.A
ADD .IX,.A
MOVE .R0,[.A]
;inicio vector
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;Fin vector
;valor de variable vector
MOVE #-3[.IY],.IX
POP .A
ADD #1,.A
ADD .IX,.A
MOVE [.A],.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;inicio vector
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;Fin vector
;inicio vector
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;Fin vector
MOVE #-3[.IY],.IX
POP .A
ADD #1,.A
Compiladores 260
ADD .IX,.A
MOVE [.A],.R0
PUSH .R0
POP .R0
MOVE #-2[.IY],.IX
POP .A
ADD #0,.A
ADD .IX,.A
MOVE .R0,[.A]
;inicio vector
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;Fin vector
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
POP .R0
MOVE #-2[.IY],.IX
POP .A
ADD #0,.A
ADD .IX,.A
MOVE .R0,[.A]
;inicio vector
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;Fin vector
;valor inmediato 6
MOVE #6,.R0
PUSH .R0
POP .R0
MOVE #-2[.IY],.IX
POP .A
ADD #0,.A
ADD .IX,.A
MOVE .R0,[.A]
;inicio vector
;valor inmediato 4
MOVE #4,.R0
PUSH .R0
;Fin vector
MOVE #-3[.IY],.IX
POP .A
ADD #1,.A
ADD .IX,.A
MOVE [.A],.R0
PUSH .R0
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
;cuerpo write string Resultados: v[4]=
Compiladores 261
WRSTR /E2
BR /E3
E2: DATA "Resultados: v[4]="
E3: NOP ;fin cuerpo
;cuerpo write string , numero1=
WRSTR /E4
BR /E5
E4: DATA ", numero1="
E5: NOP ;fin cuerpo
WRSTR /E6
BR /E7
E6: DATA "\n"
E7: NOP ;fin cuerpo
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #5,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #11,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
INICIO_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);
Compiladores 262
}
}
salida.ter
------------------------------------------------
Direccion: 0
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 1
Operacion: TR_CLASE
------------------------------------------------
Direccion: 2
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 3
------------------------------------------------
Direccion: 4
------------------------------------------------
Direccion: 5
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 6
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 7
------------------------------------------------
Direccion: 8
------------------------------------------------
Direccion: 9
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 10
Compiladores 263
------------------------------------------------
Direccion: 11
------------------------------------------------
Direccion: 12
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 13
------------------------------------------------
Direccion: 14
------------------------------------------------
Direccion: 15
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 16
------------------------------------------------
Direccion: 17
------------------------------------------------
Direccion: 18
------------------------------------------------
Direccion: 19
------------------------------------------------
Direccion: 20
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 21
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 22
------------------------------------------------
Compiladores 264
Direccion: 23
------------------------------------------------
Direccion: 24
------------------------------------------------
Direccion: 25
------------------------------------------------
Direccion: 26
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 27
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 28
------------------------------------------------
Direccion: 29
------------------------------------------------
Direccion: 30
------------------------------------------------
Direccion: 31
------------------------------------------------
Direccion: 32
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 33
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 34
Operacion: TR_SALTO
Tipo: TR_NADA
Tipo: TR_NADA
------------------------------------------------
Direccion: 35
Compiladores 265
------------------------------------------------
Direccion: 36
------------------------------------------------
Direccion: 37
Tipo: TR_NADA
Tipo: TR_NADA
salida.ens
BR /SALTO
E1: NOP ;clase
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
E0:
MOVE .SP,.IY;metodo
;valor inmediato 1
MOVE #1,.R0
PUSH .R0
;asignacion pos 0
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#0[.IX]
;valor inmediato 2
MOVE #2,.R0
PUSH .R0
;asignacion pos 1
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#1[.IX]
;valor inmediato 3
MOVE #3,.R0
PUSH .R0
;asignacion pos 2
POP .R0
MOVE #-3[.IY],.IX
MOVE .R0,#2[.IX]
;valor de variable
MOVE #-3[.IY],.IX
MOVE #0[.IX],.R0
PUSH .R0
Compiladores 266
;cuerpo write string Resultados: numero1=

WRSTR /E2
BR /E3
E2: DATA "Resultados: numero1="
E3: NOP ;fin cuerpo
WRSTR /E4
BR /E5
E4: DATA "\n"
E5: NOP ;fin cuerpo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #1[.IX],.R0
PUSH .R0
WRSTR /E6
BR /E7
E7: NOP ;fin cuerpo
WRSTR /E8
BR /E9
E8: DATA "\n"
E9: NOP ;fin cuerpo
;valor de variable
MOVE #-3[.IY],.IX
MOVE #2[.IX],.R0
PUSH .R0
WRSTR /E10
BR /E11
WRSTR /E12
BR /E13
E12: DATA "\n"
MOVE .IY,.SP
RET
SALTO:
MOVE .SP,.R0
ADD #1,.SP
MOVE .A,.SP
MOVE .SP,.R0
ADD #3,.SP
MOVE .A,.SP
PUSH .R0
PUSH #INICIO_PILA
CALL /E0
HALT
Compiladores 267
INICIO_PILA:
Ejecución
Resultados: numero1=1
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;
void metodo1() {
}
short atributo{
get
{
numero3=2;
}
}
short numero1;
short numero2;
metodo1();
numero1=4;
numero2=5-2+3-7; //=-1
numero3=6;
numero1=numero3;
numero1=numero2+5-1; //=3
numero3=2-numero3-numero2+numero1+5; //=2-6-(-1)+3+5=5
console.write("n1: {0}\nn2: {1}\nn3: {2}\n",numero1,numero2,
numero3);
}
}
Línea de comandos
Compiladores 268
C:\CSC\Debug> csc.exe –o ..\pruebas\prueba1.cs salida

Fichero Fuente: ..\pruebas\prueba1.cs
Compilando...
"..\pruebas\prueba1.cs", Line 15: Sintactic Error: #21: Atribute not
valid
Generador 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;
short numero1;
short numero2;
numero1="hola"; //n1=4
numero2=3; //n2=3
numero1+=3+1; //n1=8
numero1-=5-numero2; // =n1=8-2=6
console.write("n1: {0}\n",numero1);
}
}
Línea de comandos

Compilando...
"..\pruebas\prueba2.cs", Line 12: Semantic Error: #104: types not
equal in Sentencia
"..\pruebas\prueba2.cs", Line 12: Sintactic Error: #3: token '}'
expected
Compiladores 269
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;
void metodo1() {
}
void metodo2() {
}

short n1;
n1=5;
metodo1();
n1+=3;
metodo2();
}
}
Línea de comandos

Compilando...
"..\pruebas\prueba3.cs", Line 4: Lexer Error: #150: Short Token not
valid
"..\pruebas\prueba3.cs", Line 4: Sintactic Error: #15: 'Primario' not
valid
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 270
class clase{
short numero3;
short metodo1() {
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

Compilando...
"..\pruebas\prueba4.cs", Line 23: Semantic Error: #101: not a main
method in file
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);
}

num=1;
console.write("Estoy en Main\n");
console.write("Resultado de metodo1: {0}\n",metodo1(5,6));
metodo1(5+num,6);
Compiladores 271
}
}
Línea de comandos

Compilando...
"..\pruebas\prueba5.cs", Line 10: Semantic Error: #128: not return val
in method
expected
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;
return numero1;
}
}
class clase{
short s1;
prueba p1;
p1.numero1=5;
s1=p1.numero1;
p1.numero1 = value;
}
}
class clase2{
short s1;
prueba p1;
Compiladores 272
s1=p1.numero1; // Debe dar error y con razon!!!!

}
}
Línea de comandos

Compilando...
"..\pruebas\prueba6.cs", Line 22: Semantic Error: #119: value is not
in atribute
"..\pruebas\prueba6.cs", Line 22: Sintactic Error: #9: 'SentMet' not
valid
expected
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 {
return numero1;
}
}
class clase{
short s1;
prueba p1;
p1.numero1=5;
s1=p1.numero1;
}
}
class clase2{
Compiladores 273
short s1;
prueba p1;
s1=p1.numero1; // Debe dar error y con razon!!!!

}
}
Línea de comandos

Compilando...
"..\pruebas\prueba7.cs", Line 31: Semantic Error: #131: var no
inicializated
valid
expected
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 deberia
w[2]=numero1; //da error sintactico que no deberia
w[2]=6; //da error sintactico que no deberia
Console.Write("Resultados: v[4]={0},
numero1={1}\n",v[4],numero1);
Compiladores 274
Línea de comandos

Compilando...
"..\pruebas\prueba8.cs", Line 13: Semantic Error: #118: differents
types of list
valid
expected
Compiladores 275
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 276
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. Ullman
Addison Wesley Longman (Pearson)
 The Compiler Generator Coco/R: User Manual

Hanspeter Mössenböck
Johannes Kepler University Linz
Institute of System Software
February 2004
 M. E. Lesk and E. Schmidt, LEX - Lexical Analyzer Generator
Compiladores 277

Ejemplo-Memoria Final 2004 09 07 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejemplo-Memoria Final 2004 09 07 PDF

Cargado por

Copyright:

Formatos disponibles

CSC (C# Compiler)

Septiembre del 2004

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

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

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

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

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

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

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

El compilador se divide en las siguientes fases:

 Analizador Sintáctico (AS): Verifica la sintaxis del programa fuente utilizando

 Analizador Semántico (ASE): Revisa la semántica del programa, a partir de un

 Generador de código intermedio (GCI): Crea código intermedio, a partir del

 Optimizador del código (OC): Toma el código intermedio y lo optimiza. Pasa al

 Generador de código final (GCF): A partir del código intermedio optimizado,

 Tabla de símbolos (TS): Almacena todas las palabras reservadas e

Resumiendo, un esquema de compilador puede ser el siguiente:

LF arbol arbol. sint. LI LI LO

En nuestro caso tendremos todos estos pasos exceptuando el Optimizador de Código, es

Por otro lado, inicialmente pensamos en realizar el compilador diseñándolo orientado a

 Un token es cada uno de los elementos de un lenguaje con significado propio.

 Manejar el fichero fuente.

2.1 Gramática del Analizador Léxico

Los símbolos auxiliares utilizados son los siguientes:

2.2 Diseño del Analizador Léxico

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

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

Utilización de acciones estándar:

Concatenamos en aquellas transiciones en las que es necesario conocer el lexema del

Utilización de acciones predefinidas:

Transición Acción Semántica Acciones

La implementación de la gramática la realizamos utilizando el programa FLEX (Free

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

En cada apartado se realiza la siguiente implementación:

 Definiciones: se definen los patrones a utilizar en la gramática.

Utilizando la documentación de Flex, la gramática anterior e implementando las

Para facilitar la labor en el analizador semántico, incluimos como palabras reservadas

En definitiva, los tokens implementados con FLEX han sido:

<PR, ptr(tabla)> Palabra Reservada (0)

<LLA, -> Llave Abierta (“{“) (5)

Tabla de Operadores Aritméticos

Tabla de Operadores Lógicos

Tabla de Operadores de Asignación de Operación

Tabla de Palabras Reservadas

El Diseño de la tabla de símbolos se ha realizado utilizando una metodología

Una tabla de símbolos es un conjunto de elementos ordenados de una forma concreta,

 CLAVE: Palabra reservada (0)

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

 pu_pr: Entero que indica si el elemento es publico (1) o privado (0)

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

 int Insertar_Tipo_Valor_Devuelto(TS *tabla,char *nombre, int

Nos devuelve el tipo de un elemento de una tabla de símbolos determinada.

 int Tipo_Clase(TS *tabla,char *nombre, char *clase);

A continuación, para comprobar el funcionamiento de la Tabla de Símbolos, incluimos

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

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

Dado un conjunto de Tokens (dado por el analizador léxico), el analizador sintáctico

Dado A = α|β|γ. Se debe cumplir que:

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

Dado A =(α|). Se debe cumplir que:

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

 int Insertar_Tipo_Valor_Devuelto(TS tabla,char nombre, int

 int Tipo_Clase(TS tabla,char nombre, char *clase);