EL LENGUAJE

MODULA-2

Programación 2
Curso 2009
InCo
 Módulos
 Los programas (ej:PASCAL) usan en
general funciones y procedimientos “de
biblioteca”
 En Modula-2 las bibliotecas se organizan
en módulos (de biblioteca)
Biblioteca

Módulo
M1 M2 ... Mn
Módulos (2)
 Un módulo contiene un número de entidades de
exportación.
 Entidades posibles:
 Tipos
 Constantes
 Variables
 Procedimientos y funciones
 Exportación: disponibles para ser utilizados por otros
módulos.
 Cada módulo tiene también un nombre.
 Los “programas principales” son también llamados
módulos.
 Se distinguen:
 Módulos de biblioteca
 Módulo Principal.
Módulos (3)
 Estructura de un programa (módulo principal) :

MODULE nombre;
<lista de importaciones>
<declaraciones>
BEGIN
<instrucciones>
END nombre
Importación:

 FROM <nombre> IMPORT <lista_de_nombres>;

 <nombre> debe ser nombre de un módulo de
bibloteca.
 <lista_de_nombres> deben ser entidades exportadas
por el modulo referenciado.

 FROM STextIO IMPORT WriteString, WriteLn;

Ejemplo
 Programa que lee dos naturales y
computa su máximo común divisor.
 Los procedimientos y funciones de E/S
(Entrada/Salida) son importados de módulos
que suponemos definidos.
 ReadCard debe ser un procedimiento con
un solo parámetro de tipo CARDINAL.
 Ejemplo
MODULE módulo;
FROM InOut IMPORT ReadCard,WriteCard,WriteString,
WriteLn;
VAR x, y: CARDINAL;
BEGIN
WriteString(“x =“);ReadCard(x);WriteLn;
WriteString(“y= “);ReadCard(y);WriteLn;
WHILE (x<>y) DO
IF (x>y) THEN x:= x-y;
ELSE y:=y-x;
END;
END; (*while*)
WriteString(“MCSD = “); WriteCard(x,6);WriteLn;
END módulo.
Estructura de programas (M-2)
 Fuerte similitud con Pascal.
 Esquema general:
 Instrucciones operando sobre y modificando estado
de datos
 (Programa = Estructura de Datos + Algoritmos)

 Estructura de Datos
 Conjunto de variables (de estado)
 Cada variable puede contener ciertos valores (datos)
 Estado de una variable x:
 x tiene valor “v” (v es un valor permitido de la variable)
 x está indefinida (no tiene valor)
Estructura de Programas (M-2) (2)
 Expresiones
 Variables y constantes denotan (representan)
valores
 Los valores pueden combinarse a través de
operaciones para computar otros valores
 Instrucciones
 Estructuras de control
 Asignación (x:=e;)
 Secuencia
 Selección
 Iteración
 Procedimientos
Instrucciones
 Asignación
 x:= e;
 Secuencia:
 s1;s2
 Selección:
 IF expresion(BOOLEAN) THEN
s1;
ELSEIF expr THEN s2;
…
ELSEIF expr THEN s(n-1);
ELSE sN;
END
Instrucciones
 Iteración:
 WHILE expr(BOOLEAN) DO
s1;
END

 También FOR y REPEAT

 Procedimientos y Funciones
 En general, mismas reglas que en PASCAL
 Pasaje de parámetros:
 Por Valor
 Por Referencia (VAR)

 Las funciones PUEDEN retornar valores de tipos

estructurados
Datos
 Principio (metodológico)

 No Existe el concepto de “dato” (aislado)

 Los datos están clasificados en TIPO

 Existe primero el concepto de TIPO DE DATOS y

para cada tipo T, tenemos el concepto de dato de
tipo T
Tipos de Datos
 Conocer un tipo de datos es conocer:
 Cuales son los valores de tipo T
 Cuales son las operaciones (primitivas) que se
pueden aplicar a valores del tipo T
 Para definir un tipo de datos deben darse reglas
de:
 Sintaxis
 Cómo se escriben los valores (literales)
 Cómo se escribe la aplicación de cada operación
 Semántica

 Qué valor denota cada literal

 Qué computa cada operación
El sistema de tipos de Modula-2
 Elementales

 Estructurados
Tipos Elementales
 Los valores no se pueden descomponer
en partes (básicos, atómicos)

 BOOLEAN
 INTEGER

 CARDINAL

 REAL

 CHAR

 Enumeraciones

 Subrangos
Tipos Elementales
 El tipo INTEGER:
 Valores: un rango de enteros (depende de la
versión del lenguaje)
 Literales: se usa la notación decimal (octal y hexa)

 Operadores
 Aritméticos: +, -, *, DIV, MOD
 Relaciones: <, <=, =, <> (#), >, >=, siguiendo casi las
mismas reglas que en Pascal.
Tipos Elementales
 El tipo CARDINAL:
 Tiene como valores números naturales (enteros no
negativos) hasta un máximo.
 Para hallar ese máximo se utiliza la función
estándar MAX(T) (donde T es el tipo básico)
aplicado al tipo CARDINAL.
Tipos Elementales
 Algunas diferencias con PASCAL:
 +, -, * sobrecargados (igual que en PASCAL)

 Pero NO se pueden combinar por medio de estas operaciones

valores de <> tipo.
 2+3.1 : incorrecto
 x+y es incorrecto con x:CARDINAL e y:INTEGER

 Existen funciones de conversión:

CAST(INTEGER,…) CARDINAL
CAST(CARDINAL,…)
INTEGER
CAST(REAL,…)

CAST(INTEGER,…) REAL
Tipos Elementales
 Excepción: valores de tipos subrangos se
pueden combinar con valores del tipo
base del subrango.
Tipos Estructurados
 Vectores y Matrices (“arreglos”)
 ARRAY <tipoindice> OF <tipo>
 Mismas reglas que en PASCAL
 Indice: [i]
 miArreglo[i], miArray[2];
 Literales: {}

TYPE TipoArray = ARRAY [0..2] OF CARDINAL

…
a: TipoArray;
…
a:= TipoArray{1,2,3};
Tipos Estructurados (2)
 Registros
 RECORD
c1: t1;
…
cn: tn;
END

 Mismas reglas que en PASCAL

 Selección: _._ (rec.f)
 Literales: {} (similar al caso de array)
Tipos Estructurados
 Uniones discriminadas (registros con variantes)

 RECORD
nombre, apellido: Nombre;
CASE: estado: EstadoCIvil OF
soltero:
casado: cant_hijos: CARDINAL;
fecha_matrimonio: Fecha
END

 El enumerado que se utiliza en el case debe definirse

previamente.
Tipos Estructurados
 Punteros
 Se verán mas adelante

 Utilizados en ESTRUCTURAS DINAMICAS.

Vectores Abiertos
 Se pueden declarar parámetros formales sin especificar
el tipo índice:
 PROCEDURE P(s: ARRAY OF CHAR)

 En este caso, vectores de CHAR de cualquier tamaño

pueden pasarse como argumentos efectivos de P
correspondiendo al parámetro formal s.

 En el cuerpo del PROCEDURE, ‘s’ tiene primer índice 0

y existe la función predefinida HIGH que permite calcular
el índice máximo.
(como si fuera s:ARRAY[0..HIGH(s)] OF CHAR;)
Para que módulos?

 Abstracción / Descomposición
 Se descompone el programa en módulos.
 Debe acordarse cual es la comunicación entre
ellos.
 Que entidades importan/exportan
 En caso que sean procedimientos, especificar QUE deben
hacer (y no es necesario conocer COMO)
Para que módulos?
 Los módulos pueden desarrollarse y compilarse
separadamente.
 Para obtener una versión ejecutable debe efectuarse el
proceso de linking.
 Cambios en la implementación de entidades importadas
no obligan a recompilar todo el sistema.
 Solo se recompila el módulo de implementación y se
reconecta todo el sistema.
 Naturalmente, los “códigos incompletos” generados por
el compilador son también mantenidos en archivos.
Modulo de Biblioteca
 Módulo de Definición

 Módulo de Implementación
 Modulo de definición
 DEFINITION MODULE nombre;
<lista de importaciones>
<lista de declaraciones sintácticas (i)>
END

 Las entidades declaradas en (i) son las exportadas por el módulo,

pueden ser:
 Tipos
 Constantes
 Variables
 Subprogramas (solo se declara el cabezal y no el cuerpo)

 Ejemplo:
PROCEDURE: ReadCArd(VAR x:CARDINAL)

 En general, basta declarar la mínima información necesaria para verificar

el uso correcto de la entidad solo desde el punto de vista sintáctico
 En particular, los tipos exportados pueden ser declarados solo con un
nombre (Tipos Opacos a ver más adelante …)
Módulo de implementación
 IMPLEMENTATION MODULE nombre;
<lista de importaciones>
<declaraciones (ii)>
END

 Cada entidad declarada en el módulo de definición es

implementada en el correspondiente módulo de implementación.

 En particular, en este ultimo es donde se proveen los cuerpos de los

subprogramas exportados.

 En el proceso de compilación de un módulo principal.

 El compilador usa la información de los módulos de definición

 El linker usa los módulos de implementación.

 Compilación y creación del ejecutable
(linking)
Bibiloteca de Módulos

[1] [2]

Conector Código Objeto

Compilador Ejecutable
“Linker”
Módulo Código Objeto
Principal “desconectado”

Errores de
compilación
 Compilación y creación del ejecutable
(linking)
 [1]: El compilador no accede al código objeto de
los módulos referenciados.

 Solo utiliza declaraciones que permitan verificar

el uso correcto de las entidades importadas,
desde el punto de vista sintáctico

 Por ello, la salida del compilador no esta lista

para ser ejecutada.
 Compilación y creación del ejecutable
(linking)
 Para construir los ejecutables es necesario completar el
código objeto del programa con el correspondiente a las
entidades importadas.

 Esto ultimo lo realiza el “conector” (linker) accediendo

[2] otra vez a las bibliotecas.

 Cada módulo de biblioteca se compone de dos partes

 Modulo de Definición
 Modulo de Implementación.
Instalación del compilador
 En el curso se trabajará con el compilador
Native XDS-x86 para Windows.

 El instalador del compilador del entorno se

puede obtener de la pagina de
Excelsior.(ver sitio P2 e instructivo)
Compilar desde línea de comandos
 El enfoque modular del lenguaje permite la compilación de cada
módulo como una entidad independiente

 Sin necesidad de compilar cada uno de los módulos que

constituyen el proyecto

 Un módulo de implementación se compila ingresando el siguiente

comando:

 xc =compile archivo1.mod
 xc =c archivo1.mod (abreviación)

 El resultado es un archivo con el mismo nombre que el módulo pero

con extensión “.obj”

 Este archivo es denominado el código objeto del módulo.

Compilar desde línea de comandos (2)

 Un módulo de definición se compila con:

 xc =c archivo1.def

 En este caso no se genera código objeto sino un archivo

con extensión “.sym”

 Para compilar un módulo es necesario disponer de los

archivos .sym de todos los módulos de definición
importados directa o indirectamente.

 Los módulos de implementación no se requieren.

Compilación de proyectos
 Cuando se trabaja con proyectos con muchos módulos,
la compilación independiente resulta incómoda

 Es posible establecer relaciones de dependencia entre

módulos de acuerdo a las importaciones.

 Estas relaciones indican a que módulos podría afectar la

modificación y recompilación de un módulo.

 El compilador cuenta con un modo de funcionamiento

que maneja esto automáticamente.

 En este modo solo se compilan aquellos módulos

necesarios de acuerdo a las dependencias.
Compilación de proyectos (2)
 Para compilar el módulo archivo1.mod y todos
aquellos de los que depende y hayan sido
modificados desde la última compilación:
 xc =make archivo1.mod
 xc =m archivo1.mod (abreviación)

 SI el archivo que se pasa por parámetro es un

módulo principal, se ejecuta automáticamente el
linker.
 Es decir:
 xc =m principal.mod
Compilará todos los módulos necesarios e invocará a xlink para
generar el ejecutable principal.exe
Creación del ejecutable (linking)
 Para la construcción del programa ejecutable se
requieren todos los archivos que resultan del proceso de
compilación de los módulos (.obj y .sym)

 No se requieren los archivos de código fuente (.mod y

.def)

 El proceso de linking se invoca con el siguiente

comando:
 xlink principal.obj archivo1.obj archivo2.obj
archivoN.obj xds.25i.lib xstart.lib import32.lib

 El resultado es un ejecutable “principal.exe”

 Compilación y creación del ejecutable
(linking)
Bibiloteca de Módulos

[1] [2]

Conector Código Objeto

Compilador Ejecutable
“Linker”
Módulo Código Objeto
Principal “desconectado”

Errores de
compilación
Creación del ejecutable (linking) (2)

 Los archivos “.lib” son librerías que agrupan

varios .obj

 Las librerías “xds25i.lib”, “xstart.lib” e

“import32.lib” se distribuyen junto con el
compilador (podría requerirse la ruta completa).

 Contienen código de soporte para los

programas, como por ejemplo rutinas de las
bibliotecas estándar.
 DEFINITION MODULE STextIO;

(* Input and output of character and string types over default channels. The
read result
is of the type IOConsts.ReadResults.
*)

(* The following procedures do not read past line marks *)

PROCEDURE ReadChar (VAR ch: CHAR);

(* If possible, removes a character from the default input stream, and assigns
the
corresponding value to ch. The read result is set to allRight, endOfLine or
endOfInput.
*)

PROCEDURE ReadRestLine (VAR s: ARRAY OF CHAR);

(* Removes any remaining characters from the default input stream before the
next line
mark, copying to s as many as can be accommodated as a string value. The
read result
is set to the value allRight, outOfRange, endOfLine, or endOfInput.
*)

PROCEDURE ReadString (VAR s: ARRAY OF CHAR);

(* Removes only those characters from the default input stream before the next
line mark
that can be accommodated in s as a string value, and copies them to s. The
read result
is set to the value allRight, endOfLine, or endOfInput.
*)
DEFINITION MODULE RealMath;
(* Mathematical functions for the type REAL *)

CONST
pi = 3.141592;
exp1 = 2.718281;

PROCEDURE sqrt (x: REAL): REAL;

(* Returns the positive square root of x *)

PROCEDURE exp (x: REAL): REAL;

(* Returns the exponential of x *)

PROCEDURE ln (x: REAL): REAL;

(* Returns the natural logarithm of x *)
(* The angle in all trigonometric functions is measured in radians *)

…
PROCEDURE power (base, exponent: REAL): REAL;
(* Returns the value of the number base raised to the power exponent *)

PROCEDURE round (x: REAL): INTEGER;

(* Returns the value of x rounded to the nearest integer *)

PROCEDURE IsRMathException (): BOOLEAN;

(* Returns TRUE if the current coroutine is in the exceptional execution state
because of the raising of an exception in a routine from this module;
otherwise
returns FALSE.
*)

END RealMath.
 Algunas diferencias entre PIM y
estándar ISO
 Existen varias definiciones del lenguaje Modula-2, cada
compilador utiliza una de ellas.

 En cursos anteriores se utilizo la llamada PIM, que viene

de “Programming in Modula2” (libro de Wirth)

 En este curso se utilizara el estándar ISO.

 Algunas particularidades:

 FROM modulo IMPORT; se puede utilizar en PIM para importar

todo lo exportado por el módulo “modulo”. En ISO se debe
mencionar explícitamente la lista de elementos a importar

 WriteLine y ReadLine NO están disponibles en ISO

 CompareStr se reemplaza por Compare

 Algunas diferencias entre PIM y
estándar ISO (2)
 Mas diferencias:
 Copy para manejo de strings se reemplaza por Extract.

 StringToCard (y similares) se reemplaza por StrToCard del

módulo WholeStr.

 La declaración de un tipo enumerado dentro de una

declaración record-case no es válida. Debe declararse antes
el enumerado.

 Se utiliza la función CAST, del modulo SYSTEM, para

convertir valores (excepto literales numéricos) a otro tipo. No
se permite la conversión del tipo al estilo PIM como
 CARDINAL(x)
 Algunas diferencias entre PIM y
estándar ISO (3)
 Para obtener más información sobre este estándar
puede consultarse:
 La documentación que se distribuye con el compilador
 http://www.modula2.org/reference

 En el laboratorio SOLO se utilizará la definición ISO.

 Se desaconseja la utilización de compiladores diferentes

al Native XDS-x86.

 En los ejercicios de practico, parciales y exámenes, se

admitirán ambas definiciones
PREGUNTAS?