Fecha y hora actual: Sábado 24 Ago 2019 04:27
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder al Tema Ir a página 12Siguiente

Índice del Foro > Programación en general > Programando desde 0: 29- Bibliotecas predefinidas ISO

Autor Mensaje
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 22 Sep 2011 19:15

Título del mensaje: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

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.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
pirdy
Usuario Inquieto


Registrado: 11 Feb 2010
Mensajes: 137

Mensaje Publicado: Domingo 25 Sep 2011 16:26

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Muchas gracias profe.
La labor es incontestable.

Llevo unos dias muy ocupado y voy a estarlo un par de semanas mas, despues a ver si vuelvo a ponerme a saco con esto , ya acababa los bucles y empezaba con los arrays, todavia tengo mucho que hacer por aqui y que aprender gracias a vosotros.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
juan alejandro
Usuario Iniciado


Registrado: 07 Ene 2011
Mensajes: 43
Ubicación: Bogotá - Colombia

Mensaje Publicado: Lunes 26 Sep 2011 14:31

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Uff que material!!! Gracias Kyshuo....

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Miércoles 01 Feb 2012 05:39

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

excelente leccion kyshuo!! acabo de darle una primera lectura y está magnífica gracias Ok

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Viernes 23 Mar 2012 05:52

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Hola a todos !!!.
Estimado Kyshuo, quería preguntar si es posible importar alguna rutina en Modula2 para limpiar la pantalla, así como lo hacíamos en Pascal con el procedimiento clrscr.
Desde ya muchas gracias.
Saludos para todos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Jueves 29 Mar 2012 19:08

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Dejo esta respuesta para que quede una constancia de esta duda planteada por Sebastian Marcos. Ambos hemos investigado al respecto de si hay una rutina básica en Modula-2 para limpiar la pantalla tal como lo hacíamos en Pascal pero no la hemos encontrado.

Estuvimos probando con algunas librerías pero no obtuvimos resultados satisfactorios.

En lo que respecta al curso que yo publico no nos hará falta utilizar rutinas de limpieza ya que el foco es otro. Luego con Java tendremos muchas cosas por hacer; lo que estoy haciendo es prepararlos para llegar a eso.

En fin, si quieren limpiar pantalla en Modula no podrán de forma sencilla, así que no se molesten en eso. Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Martes 18 Sep 2012 00:24

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

profesor, si por alguna razón en algún momento quisiera utilizar TODAS las rutinas de una biblioteca para un mismo modulo, entonces, ¿tendría necesariamente que especificarlas todas luego de IMPORT o hay alguna manera de simplemente indicar que usaré todas sus rutinas sin necesidad de usar IMPORT?

Código:
FROM STextIO   IMPORT ReadString,ReadChar, WriteString, WriteChar, WriteLn, SkipLine;
[/b]

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Martes 18 Sep 2012 02:03

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Pues sí la hay, pero yo no la recomiendo mucho. En vez de poner

Código:
  1. FROM Libreria IMPORT ...

pones

Código:
  1. IMPORT Libreria;


Luego, para usar una operación de esa librería tienes que escribir

Código:
  1. Libreria.Operacion

Puedes probar si quieres. En el curso no lo haremos de ese modo ya que esa importación trae consigo un montón más de elementos que no nos interesan.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
sr floyd
Usuario Activo


Registrado: 05 Sep 2011
Mensajes: 196

Mensaje Publicado: Martes 18 Sep 2012 07:51

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

profe una ultima duda en esta lección: en la librería Strings hay un tipo definido por el programador llamado String1:
Código:
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*)


Del cual no tengo ninguna duda de para qué es definido, sin embargo noto la particularidad de que no es usado en ninguno de los procedimeintos que le siguen en dicha librería; distinto es el caso de
Código:
TYPE
  CompareResults = (less, equal, greater);
que es usado en:
Código:
PROCEDURE Compare (stringVal1, stringVal2: ARRAY OF CHAR): CompareResults;


quizás mi pregunta sea parte de un despiste, pero se puede realmente afirmar que no está siendo usado en los procedimientos? en caso de ser así ¿cómo se usaría?¿cuál sería la importancia de definirlo? ¿o es mas bien String1 un tipo global a los procedimientos que le siguen a su definición dentro de los cuales se definiría una o mas variables de ese tipo sin ser vistas en el .DEF de dicha librería?

Volver arriba
Ver perfil del usuario Enviar mensaje privado MSN Messenger
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Martes 18 Sep 2012 14:48

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Esa duda no es trivial, sin embargo a tí como cliente de la librería Strings no debería preocuparte la definición del tipo String1 porque debes señirte sí o sí a las operaciones brindadas.

Sin embargo, claramente la definición de ese tipo tiene un propósito y es poder implementar muchas de las operaciones de la librería Strings, cuyo código fuente no conozco porque ha sido ofuscado a propósito.

En concreto, el tipo String1 es usado en la implementación de muchas de las operaciones de Strings.

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Sábado 09 Mar 2013 06:21

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Hola. Pues se me presentó la duda de si en Modula-2 tenemos alguna función semejante a Eoln (End of line) como teníamos en Pascal, con la cual detectábamos el carácter de fin de línea.
Básicamente la busco para leer una cantidad arbitraria de caracteres (o números) introducidos desde la entrada estándar por el usuario.
En las librerías ISO no la he encontrado en principio.

Saludos a todos.

(*****************************************************)

Edito:
Hay una constante llamada EOL (tipo carácter) en la librería InOut dentro de la biblioteca PIM que representa el fin de línea, el detalle es que esta constante me ha servido sólo al usar el procedimiento Read previamente, que se importa también de InOut y lee un carácter. Cuando leo caracteres con ReadChar (de la librería STextIO) no funciona como debería.

A modo de ejemplo:
Código:

WHILE (char <> EOL) DO
  Read(char);
  WriteChar(char);
END;

Este código imprime en la salida los caracteres introducidos (incluyendo los espacios). Sin embargo si cambio Read por ReadChar entra en un bucle infinito. ¿Es una especie de incompatibilidad entre librerías?

Me gustaría ver si se puede hacer algo parecido pero con números..., sin hacer una conversión de caracteres a números (leer como caracteres y convertirlos a sus correspondientes valores numéricos).

Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Kyshuo Ayame
Moderador Global


Registrado: 07 Ene 2011
Mensajes: 1043

Mensaje Publicado: Sábado 09 Mar 2013 21:21

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Amigo Sebastián, alguna vez a mí me surgió esa duda y no encontré mucho en las librerías del XDS por lo que opté por una solución casera:

Básicamente lo que hice fue esto:

Código:
  1. ReadChar(a);
  2. WriteCard(ORD(a));


Con eso, al ejecutar el programa das simplemente ENTER para ingresar un fin de línea, luego verás que te imprime el ORDINAL del caracter de fin de línea el cual es 0.

Dado que ya sabes el ordinal de dicho caracter es fácil saber entonces cuando has leído el fin de línea:

Código:
  1. IF (ORD(miCaracter=0) THEN...
  2.  

O bien

Código:
  1. IF (miCaracter=CHR(0)) THEN...
  2.  

Y listo. También te puedes programar una función simple que haga esto, o declarar el ordinal 0 como una constante.

Un saludo.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Sábado 09 Mar 2013 21:54

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Excelente. Muchas gracias amigo.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Emirona07
Usuario Iniciado


Registrado: 10 Mar 2013
Mensajes: 11

Mensaje Publicado: Domingo 10 Mar 2013 20:46

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Buenas tardes.

Tengo una consulta que me surgió al leer tus tutoriales (los cuales te agradezco ya que me están facilitando mucho en el estudio del curso de Programación 2 de la FING).

¿Existe alguna función para calcular el valor de un número elevado al cuadrado? Hablo del SQR de Pascal.

Muchas gracias.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Sebastián Marcos
Usuario Inquieto


Registrado: 04 Oct 2011
Mensajes: 133

Mensaje Publicado: Domingo 10 Mar 2013 23:18

Título del mensaje: Re: Programando desde 0: 29- Bibliotecas predefinidas ISO

Responder citando

Hola. Puedes utilizar la función power que se importa del módulo LongMath (dentro de la biblioteca ISO ;-)), cuyo encabezado es:
Código:
PROCEDURE power (base, exponent: LONGREAL): LONGREAL;
  (* Returns the value of the number base raised to the power exponent *)


Saludos.

Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema Ir a página 12Siguiente
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

Buenas desde el sur del sur =)

Maugarni Preséntate a la comunidad 1 Jueves 22 Ago 2019 14:09 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Hola desde bcn

Dav2k6 Preséntate a la comunidad 2 Miércoles 26 Jun 2019 19:22 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Existen problemas al descargar musica desde you...

SusanaP Tu PC 2 Martes 26 Mar 2019 19:22 Ver último mensaje
El foro no contiene ningún mensaje nuevo

hola!! los saludo desde argentina

mery Preséntate a la comunidad 2 Jueves 13 Dic 2018 17:28 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Llamada a web service desde form

mrrobot2 Programación Web en general 1 Martes 14 Nov 2017 00:50 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,