Bibliotecas predefinidas ISO:
Las bibliotecas que hemos usado hasta ahora, más otras tantas más que usaremos luego, están predefinidas en Modula. Yo dije en algún momento que no haría falta que se las memorizaran. Esto es porque existe una carpeta donde tenemos todos los archivos que se corresponden con ellas y pues, simplemente leyéndolos podemos saber qué procedimientos y funciones nos provee tal o cual biblioteca y cómo se usan. El problema para muchos es que están en inglés, sin embargo yo les pondré aquí las más usadas traduciendo al español lo que hacen.
Dentro de la carpeta donde instalaron el ambiente de desarrollo, probablemente XDS, existe una carpeta llamada DEF donde encontraremos una carpeta llamada ISO. Las demás carpetas también contienen librerías, pero corresponden a estándares no muy difundidos, de modo que su funcionamiento es distinto. Las librerías ISO se crearon como un estándar general y son las más usadas, por eso nos enfocaremos en ellas.
Dentro de la carpeta ISO ustedes encontrarán muchos archivos de texto con extensión .def. Si hacen un poco de memoria recordarán que ya expliqué que los módulos de un programa (ya podemos llamarlos bibliotecas) están compuestos por dos tipos de archivos, uno de definición con extensión .def y otro de implementación con extensión .mod. Los archivos de definición contienen una interfaz pública de la biblioteca, o sea, muestran los tipos, las constantes y las operaciones (procedimientos y funciones) de la biblioteca de modo que podamos usarlas en nuestros programas. NO muestran la implementación de la misma, o sea, no vemos el código fuente. Dicho de otro modo, vemos el QUE, no el COMO; o sea, vemos QUÉ hace la biblioteca, pero no COMO lo hace, ya que no nos interesa.
Es responsabilidad del desarrollador que una biblioteca funcione bien, y pues, este como buen profesional nos dará su garantía de que esto es así. Pueden estar seguros que las bibliotecas ISO funcionan a la perfección porque están hechas por profesionales en ingeniería de software, mantenidas, modificadas, probadas al máximo, etc. Sin embargo, si encontraran por ahí alguna biblioteca hecha por alguien particular, pues podría fallar si ese alguien no la probó como debía.
Todo esto será esclarecido cuando programemos nuestras librerías, pero intento dar un pantallazo de como funciona Modula respecto a sus programas.
Por más información acerca de esto pueden visitar www.modula2.org
Si ustedes abren cualquiera de los archivos .def que está dentro de la carpeta ISO, por ejemplo el archivo SWholeIO, verán que está escrito en lenguaje Modula, por lo tanto, verán que tiene comentarios que explican lo que se necesita saber acerca de la librería, que tiene declaración de tipos y constantes, que comienza con las palabras DEFINITION MODULE y un identificador que es idéntico al nombre del archivo, que luego declara muchos procedimientos y funciones, y que finaliza con un END seguido de su nombre y un punto.
Hasta ahora, los módulos que hemos visto en los ejemplos, corresponden a Modulos Principales, o sea, a la parte central de nuestro programa. Todo programa tiene un único módulo principal. Este se diferencia de cualquier otro modulo porque comienza con el encabezado MODULE. Sin embargo, como ya he dicho, nuestros programas constarán de más de un módulo: el principal y las librerías.
Todo módulo que corresponde a una librería tiene dos archivos: el DEF (de definición) y el MOD (de implementación).
El archivo DEF es justamente lo que ustedes ven de las librerías ISO, y es justamente lo que los programadores de las mismas han puesto a su disposición para utilizar. El MOD de estas librerías no está disponible y no podemos verlo. En un DEF solo van los tipos que se requieren para poder usar la librería, las constantes y los procedimientos y funciones que la librería utiliza. Estos procedimientos y funciones solo llevan su encabezado, o sea, la firma, pero no la implementación ya que esta se hará en el archivo de implementación y se ocultará al público.
Veamos con más detalle esto, utilizando como ejemplo la librería SWholeIO:
Código:
DEFINITION MODULE SWholeIO;
(* Input and output of whole numbers in decimal text form over default
channels. The read result is of the type IOConsts.ReadResults.
*)
(* The text form of a signed whole number is
["+" | "-"], decimal digit, {decimal digit}
The text form of an unsigned whole number isdecimal digit, {decimal digit}
*)
PROCEDURE ReadInt (VAR int: INTEGER);
(* Skips leading spaces, and removes any remaining characters from the default input channel that form part of a signed whole number. The value of this number is assigned to int. The read result is set to the value allRight, outOfRange, wrongFormat, endOfLine, or endOfInput.
*)
PROCEDURE WriteInt (int: INTEGER; width: CARDINAL);
(* Writes the value of int to the default output channel in text form, in a field of the given minimum width.
*)
PROCEDURE ReadCard (VAR card: CARDINAL);
(* Skips leading spaces, and removes any remaining characters from the default input channel that form part of an unsigned whole number. The value of this number is assigned to card. The read result is set to the value allRight, outOfRange, wrongFormat, endOfLine, or endOfInput.
*)
PROCEDURE WriteCard (card: CARDINAL; width: CARDINAL);
(* Writes the value of card to the default output channel in text form, in a field of the given minimum width.
*)
END SWholeIO.
Esta librería únicamente tiene definidas operaciones, o sea, no hay tipos ni constantes. Cada operación corresponde a un procedimiento o una función, las cuales ya hemos utilizado en los ejemplos.
Si miran con atención, por cada operación ustedes ven su nombre y los parámetros que espera. Luego, debajo, tienen comentarios que explican lo que se hace. Por ejemplo, si miramos esta
Código:
PROCEDURE ReadInt (VAR int: INTEGER);
Ven que tiene un único parámetro llamado int del tipo INTEGER. Noten que este parámetro es pasado por referencia, lo cual debería resultarles obvio, ya que este procedimiento modifica la variable que le pasemos como parámetro efectivo guardando en ella el valor leído de la entra estandar.
Si traducimos al español los comentarios debajo de ReadInt tenemos lo siguiente:
Omite los principales espacios, y elimina cualquier resto de los caracteres del canal de entrada por defecto que forman parte de un número entero con signo. El valor de este número se asigna a int. El resultado de la lectura se establece en el valor de allRight, outOfRange, wrongFormat, endOfLine o endOfInput.
Como ven, los programadores se esmeran en explicar qué es lo que hacen sus operaciones. Para este caso concreto, la última parte no nos interesa, o sea, la que habla de allRight y demás. Básicamente nos dice que al resultado de la lectura se le asigna alguno de esos valores:
- allRight: Todo Correcto, o sea, la lectura salió bien.
- outOfRange: Fuera de Rango, o sea, el entero es demasiado grande o demasiado pequeño.
- wrongFormat: Formato Incorrecto, o sea, se ha leído algo que no corresponde a un entero.
- endOfLine: Fin de Línea, o sea, se ha leído un fin de línea antes del dato esperado.
- endOfInput: Fin de Entrada, o sea, se ha leído un fin de entrada antes del dato esperado.
Estos valores están descritos en la librería IOConsts, sin embargo no nos interesan.
Ahora sabemos que si tenemos el archivo de definición de una librería tenemos todo lo que necesitamos de ella. De este modo, si queremos usar el procedimiento ReadInt de la librería SWholeIO solo tenemos que escribirla
Código:
FROM SWholeIO IMPORT ReadInt;
De este modo, ya no deberían tener problemas para hacer nada. Igualmente, mostraré aquí las librerías más utilizadas y que más nos importan a nosotros, traduciendo al español los comentarios necesarios.
----------------------------------------------------------------------------------
Librería CharClass: Clase (tipo) caracteres
Código:
DEFINITION MODULE CharClass;
(* Clasificación de valores del tipo CHAR *)
PROCEDURE IsNumeric (ch: CHAR): BOOLEAN;
(* Retorna TRUE si y solo si ch es un carácter numérico *)
PROCEDURE IsLetter (ch: CHAR): BOOLEAN;
(* Retorna TURE si y solo si ch es una letra *)
PROCEDURE IsUpper (ch: CHAR): BOOLEAN;
(* Retorna TRUE si y solo si ch es una letra mayúscula *)
PROCEDURE IsLower (ch: CHAR): BOOLEAN;
(* Retorna TRUE si y solo si ch es una letra minúscula *)
PROCEDURE IsControl (ch: CHAR): BOOLEAN;
(* Retoran TRUE si y solo si ch representa una función de control *)
PROCEDURE IsWhiteSpace (ch: CHAR): BOOLEAN;
(* Retorna TRUE si y solo si ch representa un espacio o un formato de efectos *)
END CharClass.
----------------------------------------------------------------------------------
Librería RealMath: Matemática de Reales
Código:
<* NEW INTRINSIC+ *>
DEFINITION MODULE RealMath;
(* Funciones matemáticas para el tipo REAL *)
CONST
pi = 3.141592;
exp1 = 2.718281;
PROCEDURE sqrt (x: REAL): REAL;
(* Retorna el valor positivio de la raíz cuadrada de x *)
PROCEDURE exp (x: REAL): REAL;
(* Retorna la exponencial de x *)
PROCEDURE ln (x: REAL): REAL;
(* Retorna el logaritmo neperiano de x *)
(* En ángulo en todas las funciones trigonométricas se toma en radianes *)
PROCEDURE sin (x: REAL): REAL;
(* Retorna el seno de x *)
PROCEDURE cos (x: REAL): REAL;
(* Retorna el coseno x *)
PROCEDURE tan (x: REAL): REAL;
(* Retorna la tangente de x *)
PROCEDURE arcsin (x: REAL): REAL;
(* Retorna el arcoseno de x *)
PROCEDURE arccos (x: REAL): REAL;
(* Retorna el arcocoseno de x *)
PROCEDURE arctan (x: REAL): REAL;
(* Retorna el arcotangente de x *)
PROCEDURE power (base, exponent: REAL): REAL;
(* Retorna la potencia de exponent elevado a base *)
PROCEDURE round (x: REAL): INTEGER;
(* Retorna el valor de x redondeado al entero más cercano *)
PROCEDURE IsRMathException (): BOOLEAN; (*No nos interesa*)
(* Devuelve TRUE si la corrutina actual se encuentra en el estado de ejecución excepcional debido al lanzamiento de una excepción en una rutina de este módulo, FALSO en caso contrario. *)
END RealMath.
---------------------------------------------------------------------------------
Librería STextIO: Entra y salida estándar de texto
Código:
DEFINITION MODULE STextIO;
(* Entrada y salida de caracteres y cadenas (strings) de la entrada y salida estándar. El resultado de lectura es del tipo IOConsts.ReadResults.*)
(* Los siguientes procedimientos no leen saltos de línea *)
PROCEDURE ReadChar (VAR ch: CHAR);
(* Si es posible, remueve un carácter de la entrada estandar, y asigna el valor correspondiente a ch. El resultado de lectura es allRight, endOfLine o endOfInput.*)
PROCEDURE ReadRestLine (VAR s: ARRAY OF CHAR);
(* Remueve todos los caracteres restantes de la entrada estandar antes del fin de linea, copiando a s todo lo que pueda ser tomado como cadena (string). El resultado de lectura es allRight, outOfRange, endOfLine, o endOfInput. *)
PROCEDURE ReadString (VAR s: ARRAY OF CHAR);
(* Remueve solo aquellos caracteres de la entrada estándar antes del fin de línea que puedan ser tomados como una cadena de caracteres (string), y los copia en s. El resultado de lectura es allRight, outOfRange, endOfLine, o endOfInput.*)
PROCEDURE ReadToken (VAR s: ARRAY OF CHAR);
(* Saltea los espacios en blanco y remueve caracteres de la entrada estándar antes del fin de línea, copiando a s todo lo que pueda ser tomado como una cadena de caracteres (string). El resultado de la lectura es allRight, outOfRange, endOfLine, o endOfInput.*)
(* Los siguientes procedimientos leen saltos de línea *)
PROCEDURE SkipLine;
(* Remueve los elementos sucesivos de la entrada estándar hasta, e incluyendo, el salto de línea. En otras palabras, remueve todo lo que hay hasta el salto de línea, incluyéndolo. El resultado es allRight, o endOfInput. *)
(* Procedimientos de salida *)
PROCEDURE WriteChar (ch: CHAR);
(* Escribe el valor de ch en la salida estándar. *)
PROCEDURE WriteLn;
(* Escribe un salto de línea en la salida estándar.*)
PROCEDURE WriteString (s: ARRAY OF CHAR);
(* Escribe la cadena de caracteres (string) contenida en s en la salida estándar. *)
END STextIO.
----------------------------------------------------------------------------------
Librería SRealIO: Entra y salida estándar de reales
Código:
DEFINITION MODULE SRealIO;
(*Operaciones de entrada y salida estándar de números de punto fijo y números de punto flotante*)
PROCEDURE ReadReal (VAR real: REAL);
(* Elimina los espacios en blanco y remueve cualquier carácter de la entrada estandar que forme parte de un número fijo (sin coma) con signo o un número de punto flotante (con coma). El valor de ese número se asigna a real. El resultado de la lectura es allRight, outOfRange, wrongFormat, endOfLine, or endOfInput.*)
PROCEDURE WriteFloat (real: REAL; sigFigs: CARDINAL; width: CARDINAL);
(* Escribe el valor de real en la salida estándar en formato de punto flotante (número con coma), con sigFigs cifras significativas (mínimo número de cifras), en un espacio mínimo dado por width.*)
PROCEDURE WriteEng (real: REAL; sigFigs: CARDINAL; width: CARDINAL);
(* A diferencia de WriteFloat, el número se escala de una a tres cifras en su parte entera, y con un exponente que es múltiplo de tres.*)
PROCEDURE WriteFixed (real: REAL; place: INTEGER; width: CARDINAL);
(* Escribe el valor de real en la salida estánadar en formato de punto fijo (sin coma), redondeado según place en relación al punto decimal, en un espacio mínimo dado por width.*)
PROCEDURE WriteReal (real: REAL; width: CARDINAL);
(* Escriba el valor de real en la salida estándar. El número de cifras significativas dependerá del valor de width dado.)
END SRealIO.
-------------------------------------------------------------------------------
Librería Storage: Almacenamiento
De esta librería ustedes solo deben importar ALLOCATE y DEALLOCATE y nada más, tal como vimos cuando hablé de punteros. De este modo podrán usar NEW y DISPOSE sin problemas. Lo demás no nos interesa, igualmente se los dejo para que sepan que está.
Código:
DEFINITION MODULE Storage;
(*Operaciones para asignaciones y liberaciones dinámicas de almacenamiento*)
IMPORT SYSTEM;
PROCEDURE ALLOCATE (VAR addr: SYSTEM.ADDRESS; amount: CARDINAL);
(* Reserva el espacio necesario para almacenar una variable y asigna la dirección de ese lugar a addr. If no hay espacio suficiente para esto, el valor NIL es asignado a addr.*)
PROCEDURE DEALLOCATE (VAR addr: SYSTEM.ADDRESS; amount: CARDINAL);
(* Libera espacios asignados por ALLOCATE para el almacenamiento de la variable alojada en la dirección addr, y asigna el valor NIL a addr.*)
TYPE
StorageExceptions = (
nilDeallocation, (* primer argumento para DEALLOCATE es NIL *)
pointerToUnallocatedStorage, (* el lugar a liberar no fue reservado por ALLOCATE *)
wrongStorageToUnallocate (* el monto a liberar no es el monto reservado*)
);
PROCEDURE IsStorageException (): BOOLEAN;
(* Retorna TRUE si la corrutina actual es un estado de ejecución excepcional porque del tipo StorageExceptions, FALSO en caso contrario. *)
PROCEDURE StorageException (): StorageExceptions;
(* Si la corrutina actual se encuentra en el estado de ejecución excepcional debido al lanzamiento de una excepción de StorageExceptions, devuelve el valor de enumeración correspondiente, y de otra manera se produce una excepción *)
END Storage.
-----------------------------------------------------------------------------------
Librería Strings: Cadenas de caracteres (ARRAY OF CHAR)
Esta librería contiene todo lo que necesitan para trabajar con cadenas de caracteres, dado que Modula las trata como ARRAY OF CHAR. De este modo ustedes no pueden hacer las cosas como las hacían en Pascal, sin embargo veremos esto con detalle luego de que veamos el resto de las librerías importantes, pero ya sepan que todo lo relacionado a cadenas de caracteres lo harán con esta biblioteca.
Código:
DEFINITION MODULE Strings;
(* Operaciones para la manipulación de cadenas de caracteres (Strings) *)
TYPE
String1 = ARRAY [0..0] OF CHAR;
(* String1 proveido para construir un tipo de valor de una cadena de un único carácter, de modo que se puedan pasar valores CHAR a un parámetro del tipo ARRAY OF CHAR*)
PROCEDURE Length (stringVal: ARRAY OF CHAR): CARDINAL;
(* Retorna el largo de stringVal*)
(* Las siguiente siete operaciones construyen una cadena de caracteres y la pasan al parámetro por referencia. Todas ellas tiene la propiedad de modificar el tamaño del parámetro por referencia para que la asignación sea correcta, de modo que si el largo de la cadena a devolver excede el tamaño esperado se asigna un valor truncado.*)
PROCEDURE Assign (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
(* Copia el contenido de source en destination *)
PROCEDURE Extract (source: ARRAY OF CHAR; startIndex, numberToExtract: CARDINAL; VAR destination: ARRAY OF CHAR);
(* Copia la cantidad de caracteres indicada por numberToExtract de source a destination, comenzando en la posición startIndex de la cadena source.*)
PROCEDURE Delete (VAR stringVar: ARRAY OF CHAR; startIndex, numberToDelete: CARDINAL);
(* Borra la cantidad de caracteres indicada por nmberToDelete de stringVar, starting comenzando desde la posición startIndex. *)
PROCEDURE Insert (source: ARRAY OF CHAR; startIndex: CARDINAL; VAR destination: ARRAY OF CHAR);
(* Inserta source en destination comenzando en la posición startIndex *)
PROCEDURE Replace (source: ARRAY OF CHAR; startIndex: CARDINAL; VAR destination: ARRAY OF CHAR);
(* Copia source en destination, comenzando en la posición startIndex.*)
PROCEDURE Append (source: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
(* Agrega source en destination. *)
PROCEDURE Concat (source1, source2: ARRAY OF CHAR; VAR destination: ARRAY OF CHAR);
(* Concatena (une) source2 con source1 y copia el resultado en destination.*)
(* Los predicados siguientes proporcionan la evaluación preliminar de las condiciones de finalización de las operaciones provistas por los procedimientos anteriores.*)
PROCEDURE CanAssignAll (sourceLength: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si el número de caracteres, indicado por sourceLength, se ajustará en destination; en otro caso retorna FALSE.*)
PROCEDURE CanExtractAll (sourceLength, startIndex, numberToExtract: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si hay la cantidad de caracteres numberToExtract comenzando en la posición startIndex teniendo en cuenta el valor de sourceLength, y si la capacidad de destination es suficiente para guardar numberToExtract caracteres; en otro caso retorna FALSE. *)
PROCEDURE CanDeleteAll (stringLength, startIndex, numberToDelete: CARDINAL): BOOLEAN;
(* Retorna TRUE si hay la cantidad de caracteres numberToDelete comenzando en la posición startIndex teniendo en cuenta el valor de stringLength; en otro caso retorna FALSE. *)
PROCEDURE CanInsertAll (sourceLength, startIndex: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si hay espacio en la cantidad de caracteres, sourceLength, en la cadena destination comenznado en la posicón startIndex; en otro caso retorna FALSE. *)
PROCEDURE CanReplaceAll (sourceLength, startIndex: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si hay espacio para reemplazar una cantidad de sourceLength caracteres en destination, comenznado desde la posición startIndex; en otro caso retorna FALSE.*)
PROCEDURE CanAppendAll (sourceLength: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si hay suficiente espacio en destination para agregar una cadena de largo sourceLength, en otro caso retorna FALSE.*)
PROCEDURE CanConcatAll (source1Length, source2Length: CARDINAL; VAR destination: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si hay sufciente espacio en destination para concatenar dos cadenas de largo sourceLength y source2Length respectivamente; en otro caso retorna FALSE.*)
(* El siguiente tipo y las siguientes operaciones son proveídas para la comparación de cadenas de caracteres, y para la locación de subcadenas dentro de cadenas.*)
TYPE
CompareResults = (less, equal, greater);
PROCEDURE Compare (stringVal1, stringVal2: ARRAY OF CHAR): CompareResults;
(* Retorna less, equal, o greater, según si stringVal1 es léxicamente menor que, igual que, o mayor que stringVal2. *)
PROCEDURE Equal (stringVal1, stringVal2: ARRAY OF CHAR): BOOLEAN;
(* Retorna TRUE si stringVal1 es igual que stringVal2. Es lo mismo que utilizar Compare y obtener el resultado equal*)
PROCEDURE FindNext (pattern, stringToSearch: ARRAY OF CHAR; startIndex: CARDINAL; VAR patternFound: BOOLEAN; VAR posOfPattern: CARDINAL);
(* Busca dentro de stringToSearch alguna ocurrencia de pattern, comenzando a buscar en la posición startIndex hacia delante. Si el valor de la posición inicial indicado por startIndex es menor que el largo de stringToSearch y pattern es encontrado dentro de stringToSearch, patternFound es asignado como TRUE, y posOfPattern contendrá la posición donde pattern comienza en stringToSearch. En otro caso patternFound es asignado como FALSE y posOfPatern no será modificado.*)
PROCEDURE FindPrev (pattern, stringToSearch: ARRAY OF CHAR; startIndex: CARDINAL; VAR patternFound: BOOLEAN; VAR posOfPattern: CARDINAL);
(* Busca dentro de stringToSearch alguna ocurrencia de pattern, comenzando a buscar en la posición startIndex hacia atrás, pero no lee al revés. Si pattern se encuentra dentro de stringToSearch, patternFound es asignado como TRUE y posOfPattern es asignado con la posición de stringToSearch donde pattern comienza a ocurrir, donde posOfPattern estará dentro del rango [0..startIndex]. En otro caso patternFound es asignado como FALSE y posOfPattern no será modificado. *)
PROCEDURE FindDiff (stringVal1, stringVal2: ARRAY OF CHAR;VAR differenceFound: BOOLEAN; VAR posOfDifference: CARDINAL);
(* Compara las cadenas stringVal1 y stringVal2 en busca de diferencias. Si son iguales differenceFound es asignado como FALSE, y TRUE en otro caso. Si differenceFound es TRUE, posOfDifference contendrá la primera posición de la diferencia entre ambas cadenas; en otro caso posOfDifference no cambiará.*)
PROCEDURE Capitalize (VAR stringVar: ARRAY OF CHAR);
(* Deja todos los caracteres de stringVar en mayúscula. *)
END Strings.
------------------------------------------------------------------------------
Librería SWholeIO: Entrada y salida estándar de enteros
Código:
DEFINITION MODULE SWholeIO;
PROCEDURE ReadInt (VAR int: INTEGER);
(* Saltea los espacios en blanco y remueve todo carácter de la entrada estándar que forme parte de un número entero. El valor de este número es asignado a int. El resultado de la lectura es allRight, outOfRange, wrongFormat, endOfLine, or endOfInput. *)
PROCEDURE WriteInt (int: INTEGER; width: CARDINAL);
(* Escribe el valor de int en la salida estándar en formato de texto, en un campo con el ancho mínimo dado por width.*)
PROCEDURE ReadCard (VAR card: CARDINAL);
(* Saltea los espacios en blanco y remueve todo carácter de la entrada estándar que forme parte de un número natural. El valor de este número es a card. El resultado de la lectura es allRight, outOfRange, wrongFormat, endOfLine, or endOfInput. *)
PROCEDURE WriteCard (card: CARDINAL; width: CARDINAL);
(* Escribe el valor de card en la salida estándar en formato de texto, en un campo con el ancho mínimo dado por width.*)
END SWholeIO.
--------------------------------------------------------------------------------
Librería RealStr: Reales y Cadenas de Caracteres
Código:
DEFINITION MODULE RealStr;
IMPORT ConvTypes;
TYPE
float = REAL;
ConvResults = ConvTypes.ConvResults;
(* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
PROCEDURE StrToReal (str: ARRAY OF CHAR; VAR real: float; VAR res: ConvResults);
(* Ignoran todos los espacios en str. Si str contiene caracteres que forman un número real, se asigna este valor al parámetro real.
Se asigna un valor indicando el formato de str al parámetro res.*)
PROCEDURE RealToFloat (real: float; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
(* Convierte el valor de real en un número de punto flotante (con coma), con sigFigs cifras significativas, y copia a str dicho valor.*)
PROCEDURE RealToEng (real: float; sigFigs: CARDINAL; VAR str: ARRAY OF CHAR);
(* Convierte el valor de real en una cadena de caracteres en formato de punto flotante, con sigFigs cifras significativas, y copia el resultado posiblemente truncado a str. El número se escala de uno a tres dígitos en la parte entera y con un exponente que es múltiplo de tres. *)
PROCEDURE RealToFixed (real: float; place: INTEGER; VAR str: ARRAY OF CHAR);
(* Convierte el valor de real en una cadena de caracteres de punto fijo, redondeando según place, y copia el resultado posiblemente truncado a str.*)
PROCEDURE RealToStr (real: float; VAR str: ARRAY OF CHAR);
(* Convierte el valor de real como RealToFixed si el signo y la magnitud se pueden mostrar dentro de la capacidad de str, o de otra manera como RealToFloat, y copia el resultado posiblemente truncado a str. El número de plazas o de dígitos significativos son de aplicación definida. *)
END RealStr.
---------------------------------------------------------------------------------
Librería WholeStr: Enteros y Cadenas de Caracteres
Código:
DEFINITION MODULE WholeStr;
IMPORT ConvTypes;
TYPE
ConvResults = ConvTypes.ConvResults; (* strAllRight, strOutOfRange, strWrongFormat, strEmpty *)
PROCEDURE StrToInt (str: ARRAY OF CHAR; VAR int: INTEGER; VAR res: ConvResults);
(* Ignora todos los espacios en str. Si los caracteres de str forman forman un número entero, se asigna el correspondiente valor a int. Además se asigna el valor indicando el formato a de str a res.*)
PROCEDURE IntToStr (int: INTEGER; VAR str: ARRAY OF CHAR);
(* Convierte el valor de int en una cadena de caracteres y copia el resultado en str.*)
PROCEDURE StrToCard (str: ARRAY OF CHAR; VAR card: CARDINAL; VAR res: ConvResults);
(* Ignora todos los espacios en str. Si los caracteres de str forman un número natural (CARDINAL), se asigna el correspondiente valor a card. Además se asigna el valor indicando el formato a res.*)
PROCEDURE CardToStr (card: CARDINAL; VAR str: ARRAY OF CHAR);
(* Convierte el valor de un natural contenido en card (CARDINAL) en una cadena de caracteres y copia el resultado en str*)
END WholeStr.
