Posibilidades de la librería estándar


(Possibilities offered by the standard library)
Zero (el avión)

Las siguientes características están recogidas de la librería estándar. Los ejemplos se muestran en macroensamblador puesto que no depende de ningun lenguaje en particular. Para compilar un ejemplo, guárdese como un fichero de extensión "zm", y compílese con zm.
The following characteristics have been collected from the standard library. The examples are shown in macroassembler as it doesn't depend on any language in particular. In order to compile an example, please store it as a file with "zm" extension and compile it with the zm program.

Indice
(Index)

  1. Manejo de fecha y hora (Date/time management)
  2. Manejo de cadenas de caracteres (String management)
  3. Manejo de valores numéricos (numeric values management)
  4. Manejo de colecciones de objetos
    1. Vector
    2. Map
  5. Manejo de referencia estructural (structural reflection management)

Manejo de fecha y hora


(Time/date management)

La fecha y la hora son manejados conjuntamente por el objeto Time. La hora del sistema (y la fecha), por ejemplo, puede ser obtenida mediante el simple mensaje "System.getCurrentTime()". El objeto Time también contiene métodos para saber si la fecha contenida es válida, si el año de la misma es bisiesto ... etc.
System's time and date are managed by the same object, Time. System's time (and date), for example, can be retrieved by the use of the simple message "System.getCurrentTime()". This object also contains methods meant to know whether the stored date is valid, or if it is a leap year ... etc.

Un programa simple que usa la fecha y la hora puede ser el siguiente:
A simple program which uses date and time can be the following one:

Este programa visualiza la fecha almacenada en la máquina.
This programs shows the date and time stored in the computer.

object FechaDelDia : ConsoleApplication
    method + doIt()
      __this.prepare()

      System.console.write( "Fecha del día: " )
      System.console.write( System.getCurrentTime() )
      System.console.lf()
    return
    endMethod
endObject

Manejo de valores numéricos


(Numeric values management)

Los valores numéricos son representados por los objetos Int y Float. El primero representa a los números enteros y el segundo a los números flotantes. Todos los números son en realidad objetos, incluyendo los literales. Las operaciones más habituales (son métodos en ambos objetos) son las siguientes. Recuérdese que siempre se devuelve un nuevo objeto con el nuevo valor, en lugar de modificar al objeto que ejecuta el método.
Numeric values are represented by Int and Float objects. The first one represents integer values, while the second one represents floating pointer numbers. All numbers are actually objects, including literal ones. More common operations (i.e. methods in both objects) are as follows. Remember that they always return a new object, instead of affecting the object executing the method.

Un programa simple que usa valores numéricos puede ser el siguiente:
A simple program which uses numeric values can be the following one:

Este programa pide un número inicial (op1) y comienza a pedir números (op2) que va sumando al primero. Se muestra la suma acumulada. Para salir, basta introducir un cero.
This program asks for an initial number (op1) and then asks for various other numbers (op2) which are added to the first one and then to the accumulated sum. Just type 0 in in order to finish.

object SumadorSimple
    method + doIt()

      reference op1
      reference op2
      
      System.console.write( "Un sumador simple\n" )
      System.console.write( "Op1: " )
      op1 = Int.parseString( System.console.read() )

      :Loop
        System.console.write( "Op2 (0 para terminar): " )
        op2 = Int.parseString( System.console.read() )

        op1 = op1.sum( op2 )
        System.console.write( op1 )
        System.console.lf()
        
        op2.isEqualTo( 0 )
      jumpOnFalseTo Loop

      System.console.lf()

    return
    endMethod
endObject

Manejo de cadenas


(String management) Las cadenas son manejadas por el objeto
String. Sobre una cadena pueden realizarse las operaciones habituales (que siempre devuelven un nuevo objeto cadena), de concatenación, por medio de concat( x ), de obtención de los x caracteres a la izquierda, con left( x ) ... etc. Todos los objetos heredan el método toString(), que convierte la información contenida en el objeto a cadena. Si no se redefine este objeto, entonces se hereda el de Object, que tan sólo devuelve el nombre del objeto.

Strings are managed through the String object. The typical operations can be performed over a string (remember that all methods return a new string object), such as concatenation, by means of concat( x ), obtaining x number of characters by the left, with left( x ) ... etc. All objects inherit the toString() method from Object, meant to return the information contained inside the object in textual form. If this method is not redefined inside a new object, then the one present in Object is executed, which only returns its name.

Un programa simple que usa cadenas puede ser el siguiente:
A simple program which uses strings can be the following one:

Este programa pide una cadena y la muestra a la inversa.
This programs asks for a string and then shows it up reversed.

object Reverser
    method + doIt( str )
     reference toret = ""
     reference i = str.length()
    
     :Loop
       i = i.substract( 1 )
     
       toret = toret.concat( str.sub( i, 1 ) )
       i.isEqualTo( 0 )
     jumpOnFalseTo Loop

     return toret
    endMethod
endObject

object Reverse
    method + doIt()
     System.console.write( "Reverse\nIntroduzca una cadena: " )
     reference str = System.console.read()
     System.console.lf()
     System.console.write( Reverser.doIt( str ) )
     System.console.lf()
     return
    endMethod
endObject

Manejo de las posibilidades de reflexión estructural


(Management of the structural reflection capabilities)

La reflexión estructural es la capacidad de un objeto de inspeccionar sus miembros (métodos y atributos, esta parte se denomina introspección e incluso está presente en lenguajes como Java), más la capacidad de incluso cambiarlos, en tiempo de ejecución.

Structural reflection is the capability of an object for examining its members (attributes and methods, this part is also called 'introspection', even present in languages such as Java) and even change them, in execution time.

En Zero, esto se permite mediante los métodos heredados desde Object, que son los del tipo getAttributeNumberByName(), getMethodNumberByName() ... que convierten un nombre de método o atributo en un identificador numérico que puede ser empleado para manejarlos. Por ejemplo, getAttributeNumber( i ) devuelve el objeto al que apunta el atributo i-ésimo. El número de métodos y atributos viene dado por getNumberOfAttributes() y getNumberOfMethods(). Así, los métodos y atributos pueden ser eliminados, (p. ej. deleteAttributeNumber( i ) ), y obtener su nombre a partir del identificador numérico, (p. ej. getMethodNumberByName( nombre ) ), así como añadirlos de la misma forma. En el caso particular de los métodos, es posible obtener los opcodes de un método getListOfOpcodesOfMethod( i ), añadir métodos (sin cuerpo), addMethod( nombre ), e incluso compilar opcodes a un método ya existente: compileToMethod( num, opcodes ).

In Zero, this can be achieved by using the methods inherited in each object from Object, such as getAttributeNumberByName(), getMethodNumberByName() ..., which convert the name of a method or attribute into a numeric identifier which can be more easily managed. For example, getAttributeNumber( i ) return the object pointed by the attribute number 'i'. The number of attributes and methods is given by getNumberOfAttributes() y getNumberOfMethods(). Also, methods and attributes can be erased (for instance deleteAttributeNumber( i ) ), and its name can be taken by means of the numeric identifier (for instance getMethodNumberByName( name ) ), and finally it is also possible to add new ones. In the particular case of methods, it is possible to obtain the list of opcodes in a method by calling getListOfOpcodesOfMethod( i ), add new methods with addMethod( name ), and even compile opcodes to an existing method: compileToMethod( num, opcodes ).

Existe otra familia de métodos de más alto nivel que permiten:
There exists another family of upper level of abstraction, allowing:

Un programa simple que usa estas capacidades puede ser el siguiente:
A simple program which uses these capabilities can be the following one:

Este programa crea dos métodos para el objeto PruebaCompilador, uno que símplemente imprime "¡Hola, Mundo!" y otro que calcula el doble de otro número. Ambos son llamados.
This program creates a couple of methods for the PruebaCompilador object, one of them just prints "¡Hola, mundo!" ["Hello, World !"] on the console and the another one multiplies a number by two. Both of them are called.

object PruebaCompilador
  method + doIt()
    reference instr1 = "STR \"¡Hola, Mundo!\"\nMSG System.console write __acc\nRET"
    reference instr2 = "INT 2\nMSG x multiplyBy __acc\nRET __acc"
    reference args1 = VectorInstance.copy( "" )
    reference args2 = VectorInstance.copy( "" )
    reference x = 4
    
    ! Crear un nuevo método llamado f, en este mismo objeto
    __this.addMethod( "f", args1 )
    
    ! Crear un nuevo método llamado "doble" en este mismo objeto
    args2.add( "x" );
    __this.addMethod( "doble", args2 );
    ! Compilarle los opcodes
    __this.compileToMethod( __this.getMethodNumberByName( "doble" ), instr2 )
    __this.compileToMethod( __this.getMethodNumberByName( "f" ), instr1 )
    ! Llamar a los métodos (inexistentes al compilar esto)
    __this.f()
    System.console.lf()
    
    System.console.write( "El doble de " )
    System.console.write( x )
    System.console.write( " es " )
    x = __this.doble( x )
    System.console.write( x )
    System.console.write( "." )
    System.console.lf()
  return
  endMethod
endObject

Manejo de colecciones de objetos


(Management of collections of objects)

Las colecciones de objetos como vectores son básicas en cualquier programa. Permiten reunir objetos en torno a una única estructura de datos para un acceso más sencillo. Un ejemplo podría ser una lista de nombres, o una agenda de contactos. Existen dos tipos de colecciones: Vector y Map. El primero permite el acceso directo a una lista de objetos enumerada por un índice, mientras que el segundo asocia una cadena (String) con cualquier objeto.

Collections of objects such as vectors are basic in any program. They allow to put various objects together in a single data structure for a simpler access. An example could be a list of names, or a contact list. There are two kind of collections, Vector and Map. The first one allows direct access to a list of objects indexed by a number, while the second one associates a String with any object.

Todas las colecciones de objetos derivan del objeto DataStructure, que incorpora los métodos que suponen el contrato mínimo para cualquiera de ellas. Además, está la posibilidad de utilizar un procesador, es decir un objeto que derive del objeto Processor. Todos los objetos DataStructure incorporan un método process() que acepta como parámetro un objeto de los anteriores. Cuando es llamado, este método aplica el método doIt() a cada uno de los elementos de la estructura.

All object collections derive from the object DataStructure, which incorpores all methods that involve the minimum contract for all of them. Also, there is the possibility of employing a Processor. All DataStructure objects have a method called process(), which is called with a Processor object passed as parameter. When it is called, this method applies the doIt() method of the Processor object to each element in the structure.

Un programa simple que usa estas capacidades puede ser el siguiente:
A simple program which uses these capabilities can be the following one:

Este programa pide una serie de cadenas por teclado, y las introduce un vector. Cuando se pulsa enter sin introducir ningún valor, devuelve los elementos introducidos en orden inverso.
This program asks for a number of strings, inserting them in a vector. When a string is introduced without any value (i.e. "enter" is pressed), it displays the elements introduced in inverse order.

object Stack : ConsoleApplication
  method + doIt()
    reference v = VectorInstance.copy( "" )
    reference elem;
    reference size;
    
    System.console.write( "Pila\n" )
    
    :Loop
      System.console.write( "\nIntroduzca un elemento (\"\" para salir): " )
      elem = System.console.read()
      v.add( elem )
      size = elem.length()
      size.isEqualTo( 0 )
    jumpOnFalseTo Loop
    size = v.size()
    :Loop2
      size = size.substract( 1 )
      System.console.write( v.get( size ) )
      System.console.lf()
      
      size.isEqualTo( 0 )
    jumpOnFalseTo Loop2
  return
  endMethod
endObject


J. Baltasar García Perez-Schofield  jbgarcia@uvigo.es  Departamento de Informática  Universidad de Vigo Zero (el avión)