Ensamblador Zero

Resumen

Este archivo es la especificación del código ensamblador para Zero. Una guía del contenido puede encontrarse a continuación.

Lista de miembros por defecto en cualquier objeto
- parent,
- finalize,
- copy.
Variables locales dentro de un método:
Lista completa de mnemotécnicos
- Clasificación de mnemotécnicos:
  1. Creación de objetos: OBJ, ENO.
  2. Creación de métodos: MTH, RET, ENM.
  3. Creación de atributos: ATR
  4. Creación de variables locales: DEF, FLT, STR.
  5. Operación con referencias: ASG, SET.
  6. Salto: JMP, JOT, JOF.
  7. Operación con objetos: MSG, IOF, TRW.
- Mnemotécnicos en orden alfabético:
  1. ASG,
  2. ATR,
  3. DEF,
  4. ENM,
  5. ENO,
  6. FLT,
  7. IOF,
  8. JMP,
  9. JOT,
  10. JOF,
  11. MTH,
  12. MSG,
  13. OBJ,
  14. RET,
  15. SET,
  16. STR,
  17. TRW.

J. Baltasar García Perez-Schofield jbgarcia@uvigo.es Departamento de Informática Universidad de Vigo

Lista de mnemotécnicos:

OBJ: Inicia la definición de un objeto. Debe ir acompañado del nombre del objeto, y del nombre del padre del objeto. El efecto es crear el objeto vacío, a excepción de parent, un atributo que se crea automáticamente con el objeto y que permite que el mecanismo de delegación opere.
El segundo atributo pasado se le asigna al atributo parent, ya comentado. En caso de no existir este parámetro, o en caso de ser incorrecto, se asignará a Object.
Su utilidad por sí misma es escasa, debe emplease con ATR y MTH.
OBJ <nombre_obj> <nombre_obj_existente>

OBJ foo ENO
ENO: Termina la definición de un objeto. El efecto es que el objeto pasa a poder ser empleado, y el ensamblador permite la creación de un nuevo objeto.
ENO

OBJ foo ENO
ATR: Define un atributo para un objeto. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe ir acompañado de un nombre, que será el nombre del atributo. No es posible definir más de un atributo con el mismo nombre. A continuación debe ir acompañado de una referencia a un objeto. En caso de no querer darle ningún valor, debe indicarse Nothing. También es posible darle un valor literal numérico o de cadena directamente. Además, su nombre no puede ser parent.
Entre el nombre del mnemotécnico y el nombre del método se coloca un símbolo '+' o un '-', que se corresponden con atributo público o privado.
ATR <+|-> <nombre> [<nombre_objeto_existente> | <literal_numérico> | <literal_cadena>]

OBJ foo ATR + x 5 ENO
MTH: Define un método para un objeto. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe ir acompañado de un nombre, que será el nombre del método. Además, el número de argumentos, y a continuación, sus nombres, si existen. El efecto de los argumentos es, en la práctica, ser unas variables locales más, que se inicializan con la órden MSG. Existen, siempre, dos variables locales extra, el acumulador, y __this, que es una referencia local que apunta al objeto que ejecuta el método (este objeto puede no ser el que define el método, debido a la delegación).
Entre el nombre del mnemotécnico y el nombre del método se coloca un símbolo '+' o un '-', que se corresponden con método público o privado.
No es posible definir más de un método o atributo con el mismo nombre. El final del método lo marca RET.
MTH <+|-> <nombre_método> [<parametro_formal1>, [<parametro_formal2>, ...]]

OBJ foo MTH + x RET __this ENM ENO
RET: Termina el cuerpo de un método de un objeto. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. El comienzo de un método lo marca MTH, y su final ENM. Puede ir acompañado de una referencia local o de un registro. Si no aparece, entonces se asume que se devuelve el contenido de __rr.
RET [<referencia>]

OBJ foo MTH + self RET __this ENM ENO
JMP: Realiza un salto incondicional de un número de opcodes dado por el argumento.
Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. El comienzo de un método lo marca MTH, y su final ENM.
Esta instrucción no modifica el acumulador.
JMP <número_de_opcodes>

OBJ foo MTH + self JMP 3 STR "Este mensaje nunca sale por pantalla." MSG System.console write __acc RET __this ENM ENO
JOT: Realiza un salto condicional (si hay un True en el acumulador) de un número de opcodes dado por el argumento.
Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. El comienzo de un método lo marca MTH, y su final ENM.
Esta instrucción no modifica el acumulador.
JOT <número_de_opcodes>

OBJ foo MTH + foe DEF cadTodoVaBien STR "Si puede leer esto, es que todo va bien" ASG cadTodoVaBien IOF Float JOT 2 MSG System.console write cadTodoVaBien RET __this ENM ENO
JOF: Realiza un salto condicional (si hay un False en el acumulador) de un número de opcodes dado por el argumento.
Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. El comienzo de un método lo marca MTH, y su final ENM.
Esta instrucción no modifica el acumulador.
JOF <número_de_opcodes>

OBJ foo MTH + foe DEF cadTodoVaBien STR "Si puede leer esto, es que todo va bien" ASG cadTodoVaBien IOF String JOF 2 MSG System.console write cadTodoVaBien RET __this ENM ENO
ENM: Termina un método para un objeto. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. El comienzo de un método lo marca MTH, y el final del cuerpo principal RET. El propósito de existir esta división es poder atender las excepciones que se produzcan. En caso de haber código entre un RET y un ENM, éste sólo se ejecuta en caso de que se produzca una excepción.
RET <referencia>

OBJ foo MTH + self RET __this ENM ENO
FLT: Crea un objeto de la librería estándar que contendrá el valor literal especificado. Ése objeto será apuntado por el acumulador. En caso de no haber memoria suficiente, el acumulador contendrá una referencia a Nothing, y se lanzará la excepción ENotEnoughMemory. En concreto, FLT trata con números en punto flotante. Dado que Zero es un lenguaje orientado a objetos puro, ésta es la única forma de incluir valores que no son objetos en un programa. En caso de no existir memoria suficiente para el nuevo objeto, se provoca la excep Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe estar además entre un MTH y un RET. No es posible definir una referencia local con el nombre __this, ni con el nombre del acumulador.
FLT <literal_flotante>

OBJ foo MTH + foe DEF PI FLT 3.1415927 ASG PI MSG System.console write PI RET __this ENM ENO
STR: Crea un objeto de la librería estándar que contendrá el valor literal especificado. Ése objeto será apuntado por el acumulador. En caso de no haber memoria suficiente, el acumulador contendrá una referencia a Nothing, y se lanzará la excepción ENotEnoughMemory. Dado que Zero es un lenguaje orientado a objetos puro, ésta es la única forma de incluir valores que no son objetos en un programa. En concreto, STR trata con cadenas de caracteres. La cadena puede ocupar varias líneas, si bien debe estar encerrada entre comillas dobles. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe estar además entre un MTH y un RET. No es posible definir una referencia local con el nombre __this, ni con el nombre del acumulador.
STR <nombre_variable> "<literal>"

OBJ foo MTH + foe DEF cadHolaMundo STR "¡Hola, Mundo!" ASG cadHolaMundo MSG System.console write cadHolaMundo RET __this ENM ENO
TRW: El propósito de esta instrucción es provocar una excepción. Se trata de crear una copia de un objeto especificado, colocar una referencia al mismo en el acumulador y en el registro de excepciones, y hacer un salto a la ejecución más allá de la instrucción RET. El conjunto de instrucciones especificado para el trato de excepciones estará entre ésta instrucción y la ENM. Acepta un único argumento, que es una referencia al objeto excepción a generar.
Si esta instrucción se encuentra en una zona de gestión de excepciones, (entre RET y ENM, como ya se ha dicho), entonces la excepción pasa al control de excepciones del método que hubiera sido llamado. En caso de no existir tal método, el trabajo se encarga a la máquina virtual.
Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe estar además entre un MTH y un ENM.
TRW <referencia>

OBJ foo MTH + foe STR "Introduzca un número: " MSG System.console read MSG __acc toFloat MSG System.console write __acc RET STR "Era necesario introducir un número." MSG System.console write __acc ENM ENO
IOF: Esta instrucción coloca True en el acumulador si la referencia en el acumulador señala a un objeto que es hijo en la cadena de herencia (mediante parent), del objeto que es pasado como parámetro. En caso contrario, coloca False en el acumulador.
Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO.
Si va acompañada, además, de un registro, entonces la referencia a comrpobar no se toma del acumulador, sino de ese registro.
Debe estar además entre un MTH y un RET.
IOF <referencia> [<nombre_registro>]

OBJ foo MTH + foe DEF cadTodoVaBien STR "Si puede leer esto, es que todo va bien" ASG cadTodoVaBien IOF String JOF 2 MSG System.console write cadTodoVaBien RET __this ENM ENO
DEF: Define una referencia local dentro de un método para un objeto. Debe acompañarse con un nombre. La referencia local puede contener una referencia a un objeto. Se garantiza la inicialización a Nothing. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe estar además entre un MTH y un RET. No es posible definir una referencia local con el nombre __this, ni con el nombre del acumulador.
Esta instrucción NO modifica el acumulador.
DEF <nombre_variable_local>

OBJ foo MTH + self DEF aux SET __this ; AC = __this ASG aux ; aux = AC RET aux ENM ENO
ASG: Permite asignar el contenido del acumulador (una referencia a un objeto) a una referencia local, u otro registro. Debe acompañarse con un nombre, el de la referencia local. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe estar además entre un MTH y un RET.
Esta instrucción NO modifica necesariamente el acumulador (es decir, a no ser que el destino sea el propio acumulador, éste no es modificado).
ASG [<nombre_registro>] <nombre_variable_local> | <nombre_atributo> | <nombre_registro>

OBJ foo MTH + self DEF aux SET __this ; AC = __this ASG aux ; aux = AC RET aux ENM ENO
SET: Permite asignar una referencia al acumulador u otro registro. Debe acompañarse con un nombre de una referencia local, y, opcionalmente, un nombre de registro. De no incluirse éste último, se asume el uso del acumulador. Debe estar dentro de la definición de un objeto, es decir, entre un OBJ y un ENO. Debe estar además entre un MTH y un RET.
SET [<nombre_registro>] <referencia>

OBJ foo MTH + self DEF aux SET __this ; AC = __this ASG aux ; aux = AC RET aux ENM ENO
MSG: Permite ejecutar un método (mandar un mensaje) de un objeto. Debe acompañarse con un nombre de un objeto y el nombre del método a ejecutar.
En caso de no encontrar el objeto, se lanza la excepción EObjectNotFound, y en caso de no encontrar el método, EMethodNotFound
A continuación se especifica el número de argumentos, y de ser este número mayor que cero, los argumentos uno por uno. Si está dentro de un objeto, el resultado del método queda guardado en el acumulador.
MSG <referencia> <desplazamiento> <nombre_método> [<referencia1> [<referencia2>...]]

OBJ foo MTH + createChar DEF litA STR "A" ASG litA DEF aux MSG String new ; __acc = new String ASG aux ; aux = AC MSG aux assign litA MSG System.console write aux RET aux STR "No hay suficiente memoria para crear objetos." MSG System.console write __acc ENM ENO MSG foo createChar

Lista de atributos y variables locales por defecto:

A continuación, se muestran una serie de atributos que se crean por defecto dentro de cada objeto, y variables locales que se crean dentro de cada método.

El registro acumulador
El acumulador es una referencia local más, que existe en todos y cada uno de los métodos de un objeto. Su nombre es el siguiente:

__acc

Es empleado por la mayoría de las instrucciones ensamblador de Zero. Puede ser accedido normalmente, pero lo más probable es que emplear esta variable local directamente no sirva de mucho.
Registros de propósito general
Además del acumulador, exsiten otros registros, que están disponibles en todos y cada uno de los métodos de un objeto cualquiera. Sus nombres son los siguientes:

__gp1 __gp2 __gp3 __gp4
__rr
__rr es una referencia local más, que existe en todos y cada uno de los métodos de un objeto. Su nombre es el siguiente:

__rr

Guarda la referencia que será devuelta al final del método, con RET.
__this
__this es una referencia local más, que existe en todos y cada uno de los métodos de un objeto. Su nombre es el siguiente:

__this

Simboliza el objeto que está ejecutando el método.
__exc
__exc es una referencia local más, que existe en todos y cada uno de los métodos de un objeto. Su nombre es el siguiente:

__exc

Simboliza el objeto que se lanzará como excepción.
parent
parent es un atributo más dentro de un objeto, que existe en todos y cada uno de los objetos en Zero. Se inicializa por defecto a Object.
Su nombre es el siguiente:

parent

Apunta al siguiente objeto al que el sistema debe ir cuando se está intentando localizar un método (al estarse ejecutando una llamada MSG). Ésta búsqueda de objeto en objeto se conoce como delegación.
Object copy(String nombre)
copy es un método más dentro de un objeto, que existe en todos y cada uno de los objetos en Zero, ya que lo heredan de Object. Su nombre es el siguiente:

copy()

Acepta un argumento que es el nombre del objeto.
Nothing finalize()
finalize es un método más dentro de un objeto, que existe en todos y cada uno de los objetos en Zero, ya que lo heredan de Object. Su nombre es el siguiente:

finalize

Se ejecuta cuando un objeto es eliminado.

J. Baltasar García Perez-Schofield jbgarcia@uvigo.es