Posibilidades de la librería estándar
(Possibilities offered by the standard library)
Posibilidades de la librería estándar(Possibilities offered by the standard library) |
|
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)
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
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.
sum( x ): suma el valor de x al valor del objeto y
retorna un nuevo objeto con el resultado. substract( x ): resta el valor de x al valor del
objeto y retorna un nuevo objeto con el resultado. isLessThan( x ): devuelve True
si x es mayor que el objeto. Devuelve False
en otro caso. isEqualTo( x ): devuelve True
si x es igual que el objeto. Devuelve False
en otro caso. isLessThan( x ): devuelve True
si x es mayor que el objeto. Devuelve False
en otro caso. isGreaterThan( x ): devuelve True
si x es menor que el objeto. Devuelve False
en otro caso. 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
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
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:
callByName( n, vectorOfArguments ) getAttributeByName( n ) getInfoOnMethodNumber( i ). Devuelve un objeto copia
de MethodInfo. getInfoOnAttributeNumber( i ). Devuelve un objeto
copia de AttributeInfo.
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
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 | 
|