type - La web de Sistemas Operativos (SOPA)

Introducción al lenguaje Ada95
1
© José Miguel Santos Espino – Alexis Quesada Arencibia
Historia
n
n
n
n
Concurso de ideas del Departamento de
Defensa norteamericano (1974)
Primer estándar: Ada 83
Utilizado en la industria militar,
aeroespacial, sistemas empotrados, etc.
Ada influye en lenguajes posteriores
(c++, ObjectPascal, etc.)
2
© José Miguel Santos Espino – Alexis Quesada Arencibia
Historia(2)
n
n
n
Segundo estándar: Ada 95
Actualiza el lenguaje: orientación a
objetos, monitores (objetos protegidos),
anexos especializados ...
La aparición de Linux provoca una
expansión de Ada como lenguaje de
uso general: compilador gratuito GNAT
3
© José Miguel Santos Espino – Alexis Quesada Arencibia
4
Elementos del lenguaje
n
Tipos de datos
n
Concurrencia
n
Estructuras algorítmicas
n
Orientación a objetos
n
Subprogramas
n
Biblioteca estándar
n
Excepciones
n
Anexos especializados
n
Paquetes
n
Genéricos
© José Miguel Santos Espino – Alexis Quesada Arencibia
Objetivos principales
n
Legibilidad
n
n
Tipado fuerte
n
n
Facilitar lectura. Evitar notación concisa
Impedir confusión entre conceptos
lógicamente distintos.
Construcción de grandes programas
n
Mecanismos de encapsulado para
compilación separada
5
© José Miguel Santos Espino – Alexis Quesada Arencibia
Objetivos principales (2)
n
Manejo de excepciones
n
n
Abstracción de datos
n
n
Mayor transportabilidad y mejor mantenibilidad
Procesamiento paralelo
n
n
Control de los errores
Mecanismos para permitir ejecutar actividades
(tareas) de forma paralela
Unidades genéricas
n
Especialmente útil para la creación de bibliotecas
6
© José Miguel Santos Espino – Alexis Quesada Arencibia
Un programa en Ada
n
Programa pral. + Servicios de otras
unidades de biblioteca
--Ejemplo de programa
with Text_IO; --cláusula de contexto
procedure hola is --procedimiento principal
--Parte de declaraciones
begin
--Cuerpo de sentencias ejecutables
Text_IO.Put_Line(“Hola, mundo”);
end hola;
7
© José Miguel Santos Espino – Alexis Quesada Arencibia
Un programa en Ada (2)
-- ejemplo de programa
with Text_IO;
use Text_IO;
procedure hola is
saludo: STRING :=(“hola, mundo”);
begin
for i in 1..10 loop
Put_Line(SALUDO);
end loop;
end hola;
8
© José Miguel Santos Espino – Alexis Quesada Arencibia
Algunos detalles
n
n
n
n
No distingue mayúsculas de minúsculas
Se pueden usar acentos y eñes en los
identificadores
Comprobación muy estricta de tipos
Las sentencias siempre terminan en
punto y coma
9
© José Miguel Santos Espino – Alexis Quesada Arencibia
Elementos léxicos
n
Comentarios con doble guión: -- texto
n
Identificadores tipo Pascal
n
Cadenas entre “comillas dobles”
n
Caracteres con ‘comilla simple’
n
Números (literales numéricos)
n
n
Enteros
Reales
10
© José Miguel Santos Espino – Alexis Quesada Arencibia
Elementos léxicos
n
Más sobre literales numéricos
n
Se pueden emplear separadores
n
n
Literales enteros y reales con exponente
n
n
9.84E2 19E2
Se puede expresar la base
n
n
123_456_789
2#1001001#
Un literal con base también puede tener exponente)
n
12#40#E3 (es 4 x 12 x 123)
11
© José Miguel Santos Espino – Alexis Quesada Arencibia
12
Tipos de Datos
Elementales
Accesos
Compuestos
Arrays
Escalares
Discretos
Enumeración
Tagged
records
Tasks
Protected
objects
Reales
Enteros
Enteros con
signo
Records
Modulares
Coma
flotante
Coma Fija
Decimales
Ordinarios
Tipos Numéricos
© José Miguel Santos Espino – Alexis Quesada Arencibia
Variables y asignaciones
n
“nombre_de_variable : tipo”
x : INTEGER; --una variable de tipo integer llamada x
x, y, z : INTEGER;
n
Asignación :=
x, y, z : INTEGER := 0;
13
© José Miguel Santos Espino – Alexis Quesada Arencibia
Declaración de constantes
n
n
= variable pero poniendo la palabra
reservada “constant”
En el caso de constantes numéricas se
puede omitir el tipo (declaración de
número)
c : constant INTEGER := 10; --Declaración de la
--constante c
pi: constant := 3.1416; --Declaración del número pi
14
© José Miguel Santos Espino – Alexis Quesada Arencibia
Declaración de tipos
n
type nombre is definición;
n
type nombre is new definición;
n
subtype nombre is definición;
type byte is range 0..255;
subtype byte is INTEGER range 0..255;
type Mienterocorto is new INTEGER range 0..255;
15
© José Miguel Santos Espino – Alexis Quesada Arencibia
16
Tipos predefinidos
n
n
Un tipo está caracterizado por un
conjunto de valores y un conjunto de
operaciones
Paquete STANDAR
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos enteros
n
integer
n
natural (de 0 en adelante)
n
positive (de 1 en adelante)
n
mod N (entero sin signo, rango 0..N-1)
n
Se puede imponer una restricción al tipo
integer (range)
p: INTEGER range 1..10;
x: INTEGER range 1..I+J;
t: mod 10; --Entero rango 0..9
17
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos enteros (2)
n
Algunas implementaciones:
n
n
n
n
long_integer
short_integer
OJO, el rango de valores de estos tipos
depende de la implementación
¿Como hacer programas más “transportables” ?
n
Atributos
n
Son valores asociados a tipos u objetos que suelen usarse
para devolver propiedades de un tipo de datos o efectuar
operaciones predefinidas sobre un tipo
18
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos enteros (3)
n
Atributos: tipo’atributo(params)
n
Por ejemplo:
subtype NATURAL is INTEGER range 0..INTEGER’LAST;
subtype POSITIVE is INTEGER range 1..INTEGER’LAST;
19
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos enumerados
type COLOR is (Rojo, Ambar, Verde);
type DIA is (lun, mar, mie, jue, vie, sap, dom);
subtype LABORABLE is DIA range lun..vie; --Restricciones
--Hay un tipo enumeración predefinido, el CHARACTER
type CHARACTER is (nul,...,’A’,’B’,...,del);
20
© José Miguel Santos Espino – Alexis Quesada Arencibia
21
Atributos típicos
n
Atributos aplicables a todos los tipos
escalares (enteros y enumerados)
n
T’First
n
T’Max(e1,e2)
n
T’Last
n
T’Min(e1,e2)
n
T’Range
n
T’Pos(e)
n
T’Length
n
T’Val(e)
n
T’Succ(e)
n
T’Value(string)
n
T’Pred(e)
n
T’Image(e)
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplos de atributos
type DIAS is (lun, mar, mie, jue, vie, sap, dom);
subtype LABORABLE is DIAS range lun..vie; --Restricciones
for dia in lun..sap loop
Text_IO.Put(DIAS’IMAGE(dia));
end loop;
hoy := lunes;
mañana := DIAS’SUCC(hoy);
ayer := DIAS’PRED(hoy); -- error
if hoy<mañana then
Text_IO.Put(“Hoy es menor que mañana”);
end if;
22
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplos de atributos (2)
x : INTEGER;
begin
Text_IO.Get (cadena);
x := INTEGER’VALUE (cadena);
Text_IO.Put (INTEGER’IMAGE(x));
end;
23
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipo booleano
n
El tipo booleano es un tipo enumerado
predefinido cuya declaración puede
entenderse como
type BOOLEAN is (FALSE,TRUE)
24
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos reales
n
Tipo predefinido: FLOAT
n
Algunas implementaciones:
n
n
n
Short_Float;
Long_Float;
El programador también puede definir sus
propios reales
n
n
Coma fija
Coma flotante
25
© José Miguel Santos Espino – Alexis Quesada Arencibia
Coma fija y coma flotante
--Coma flotante
type rflotante is digits 5 [range –1.0..1.0];
--se exigen una precisión de al menos 5 digitos
--significativos
--Coma fija ordinario
type rfija1 is delta 0.01 range –1.0..1.0;
--Se especifica un error absoluto (0.01)
--Coma fija decimal
type rfija2 is delta 0.01 digits 5;
26
© José Miguel Santos Espino – Alexis Quesada Arencibia
Conversión de tipos
n
Ada => Tipado fuerte
n
n
No permite nunca mezclar tipos diferentes
Conversión
n
Nuevo_Tipo(Expresión_Tipo_Original)
27
© José Miguel Santos Espino – Alexis Quesada Arencibia
Operadores
n
Los típicos y además:
n
n
n
n
n
exponenciación: a**b
modulo: a mod b
resto: a rem b
valor absoluto: abs a
Comprobaciones de pertenencia aplicables
a todos los tipos escalares:
n
in, not in (aunque técnicamente no son
operadores)
28
© José Miguel Santos Espino – Alexis Quesada Arencibia
Arrays
n
Nombre_Array: array (tipo_discreto) of Tipo_Elemento;
A: array (INTEGER range 1..6) of REAL;
AA: array (INTEGER range 0..2, INTEGER range 0..3) of REAL;
N: INTEGER := 5;
B: array (INTEGER range 1..N) of BOOLEAN;
HORAS_TRABAJADAS: array (DIA) of REAL;
29
© José Miguel Santos Espino – Alexis Quesada Arencibia
Arrays (2)
n
Recordando atributos
n
n
n
n
n
n
n
n
AA’FIRST(1) es 0
AA’FIRST(2) es 0
AA’LAST(1) es 2
AA’LAST(2) es 3
AA’LENGTH(1) es 3
AA’LENGHT(2) es 4
AA’RANGE(1) es 0..2
AA’RANGE(2) es 0..3
30
© José Miguel Santos Espino – Alexis Quesada Arencibia
Inicialización de arrays
n
Agregados (forma literal de un valor
formación)
n
n
n
(0.0, 0.0, 0.0)
Un agregado debe ser completo
Se puede declarar una formación como
constante en cuyo caso el valor inicial
es, evidentemente, obligatorio
31
© José Miguel Santos Espino – Alexis Quesada Arencibia
Inicialización de arrays (2)
A: array (1..6) of REAL := (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
AA: array (0..2,0..3) of REAL := ((0.0, 0.0, 0.0, 0.0),
(0.0, 0.0, 0.0, 0.0),
(0.0, 0.0, 0.0, 0.0));
MAÑANA: constant array (DIA) of DIA :=
(mar, mie, jue, vie, sap, dom, lun);
32
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos arrays
n
n
type Nombre is array (tipo_discreto) of Tipo_Elemento;
Además en Ada se introduce el concepto de array
irrestringido (no se dan las restricciones de los índices)
type VECTOR is array (1..6) of REAL;
type VECTOR is array (INTEGER range <>) of REAL;
V:VECTOR(1..5);
type MATRIZ is array (INTEGER range <>, INTEGER range <>)
of REAL;
--Los límites pueden ser cualquier expresión y se evalúa
--cuando se encuentra la restricción del índice
M: MATRIZ(1..N,1..N);
33
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos arrays (2)
n
Otra forma dar los limites: arrays
contantes
n
Los límites se deducen a partir del valor inicial
(el límite infierior sería S’FIRST siendo S el
subtipo del índice)
type L is array (DIAS range <>) of DIAS;
SIGUIENTE_DIA_LABORABLE: constant L :=
(mar, mie, jue, vie, lun);
--OJO !!!
type MATRIZ is array (INTEGER range <>, INTEGER range <>)
of REAL;
MIMATRIZ: constant MATRIZ := ((1.0, 0.0), (0.0, 1.0));
34
© José Miguel Santos Espino – Alexis Quesada Arencibia
Agregado por nombre
n
Agregados por posición
n
n
(0.0, 0.0, 0.0)
Agregados por nombre (no importa el orden)
n
(1=>0.0, 2=>0.0, 3=>0.0)
type MATRIZ is array (INTEGER range <>, INTEGER range <>)
of REAL;
MIMATRIZ: constant MATRIZ := (1=>(1=>1.0, 2=>0.0),
2=>(1=>1.0, 2=>0.0));
DIA_TRABAJO: constant array(DIA) of BOOLEAN :=
(lu..vie=>TRUE, sab|dom=>false);
35
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más detalles sobre agregados
n
n
Uso de others (última opción)
No se puede mezclar en un mismo agregado
notación por nombre y por posición (ojo si en
el caso de los distintos niveles en un
agregado multidimensional)
MIMATRIZ: constant array(1..5,1..2) of REAL:=
(1=>(1=>1.0, 2=>0.0),
2=>(1.0, 0.0),
others=>(others=>0.0)));
36
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más sobre arrays
n
Asignación
n
n
Igual tipo y el mismo número de elementos
Igualdad y desigualdad (igual tipo)
n
= número de componentes y además
componentes iguales
V:VECTOR(1..5);
W:VECTOR(0..4);
...
V:=W; --V y W son del mismo tipo y ambos tienen 5 comp.
37
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más sobre arrays (2)
n
Se puede hacer referencia a un trozo de
un array monodimensional => rodajas
V:VECTOR(1..5);
W:VECTOR(0..4);
V(1..2) := W(3..4);
38
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más sobre arrays (3)
n
Operaciones sobre arrays de una
dimensión
n
n
n
n
n
and, or, xor, not => arrays booleanos
=, /= (ya vimos la regla),
>, >=, >, >= (orden lexicográfico)
Operadores binarios => mismo tipo y
mismo número de componentes
Nuevo operador: & (concatenación de
formaciones de una dimensión)
39
© José Miguel Santos Espino – Alexis Quesada Arencibia
Strings
n
Es un array de caracteres
n
type STRING is array (POSITIVE range <>) of CHARACTER
S: STRING(1..7);
G: constant STRING := (‘H’,’O’,’L’,’A’);
--Notación alternativa y más cómoda
G: constant STRING := “hola”;
40
© José Miguel Santos Espino – Alexis Quesada Arencibia
Registros
type FECHA is
record
DIA: INTEGER range 1..31
MES: NOMBRE_MES; --lo suponemos definido
AÑO: INTEGER;
end record;
F:FECHA;
F.DIA:=4;
G:FECHA:=(4,JUL,1776);
H:= (MES=>JUL,DIA=>4,AÑO=>1976);
41
© José Miguel Santos Espino – Alexis Quesada Arencibia
Estructuras algorítmicas
n
Sentencias simples
n
Bloque begin..end
n
Sentencias condicionales: if, case
n
Sentencias iterativas: for, while, loop
n
Subprogramas: function, procedure
42
© José Miguel Santos Espino – Alexis Quesada Arencibia
Sentencias simples
n
Asignación: var := expr;
n
Sentencia nula: null;
n
Llamada a procedimiento:
n
proc(parm1,parm2,...);
43
© José Miguel Santos Espino – Alexis Quesada Arencibia
Bloque begin..end
[nombre_de_bloque:]
declare
i:INTEGER:=0; --las declaraciones van aquí
begin
i:=i+1;
--Las sentencias van aquí
exception
--manejo de exepciones
end [nombre_de_bloque];
44
© José Miguel Santos Espino – Alexis Quesada Arencibia
45
Ambito
declare
i:INTEGER:=0;
begin
...
declare
k:INTEGER:=i;
i:INTEGER:=0;
begin
...
end;
...
end;
ámbito de la I
externa
visibilidad de la ámbito de la I visibilidad de la
I externa
interna
I interna
© José Miguel Santos Espino – Alexis Quesada Arencibia
46
Ambito (2)
externo:
declare
I:INTEGER:=0;
begin
...
declare
K:INTEGER:=I;
I:INTEGER;
J:INTEGER:=externo.I;
begin
...
end;
...
end;
--nos referimos a la I externa
© José Miguel Santos Espino – Alexis Quesada Arencibia
Sentencias condicionales
if expr then
sentencia
[elsif sentencia]
[elsif sentencia]
...
[else sentencia]
end if;
case expr is
when caso =>
sentencias
...
[when others => sent]
end case;
expr: sólo tipos discretos
caso: valor, rango, o lista
de valores v1|v2|v3...
Todos los casos han de
estar contemplados
47
© José Miguel Santos Espino – Alexis Quesada Arencibia
Sentencias iterativas
while expr loop
sentencia
end loop;
for ident in [reverse] rango loop
sentencia
end loop;
loop
sentencia
end loop;
48
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplos de for
for i in 1..10 loop
put(“hola, i=“);put(i);new_line;
end loop;
for i in reverse 1..10
for i in lunes..viernes
for i in dias range lunes..miercoles
for i in dias’first..dias’last
for i in laborables
49
© José Miguel Santos Espino – Alexis Quesada Arencibia
Exit y goto
loop
if una_condición then
exit;
end if;
-- o también
exit when otra_condición;
end loop;
if condición then
goto Pabajo;
end if;
...
<<Pabajo>>
Put (“Código después de la etiqueta”);
50
© José Miguel Santos Espino – Alexis Quesada Arencibia
Subprogramas
n
Procedimientos
n
n
n
n
Funciones
n
n
modo del parámetro: in, out o in out
paso de parámetros por posición o por nombre
parámetros por omisión (default)
los parámetros siempre son in (no se pueden
modificar)
Se permite sobrecarga, recursividad y
anidamiento
51
© José Miguel Santos Espino – Alexis Quesada Arencibia
Procedimientos
n
Modo de acceso a los parámetros:
n
n
n
in: el parámetro funciona como una constante
out: el parámetro funciona como una variable sin
inicializar
in out: el parámetro funciona como una variable
inicializada
procedure nombre (decl1;decl2;...) is
declaraciones locales (variables, tipos,
subtipos, procedimientos,...)
begin
cuerpo del procedimiento
end nombre;
52
© José Miguel Santos Espino – Alexis Quesada Arencibia
Funciones
n
Sólo admite parámetros in
function nombre (params) return tipo is
declaraciones locales (variables, tipos,
subtipos, procedimientos,...)
begin
cuerpo de la función
end nombre;
53
© José Miguel Santos Espino – Alexis Quesada Arencibia
54
Declaraciones, ámbito y visibilidad
procedure F(...);
procedure G(...) is
begin
F(...);
end G;
procedure F(...) is
begin
G(...);
end F;
procedure P is
I:INTEGER:=0;
procedure Q is
k:INTEGER:=I;
I:INTEGER;
J:INTEGER;
begin
...
end Q
begin
...
Q(...);
end P;
© José Miguel Santos Espino – Alexis Quesada Arencibia
Estructura general de un
programa en Ada
n
n
Programa Ada: unidades distribuidas en
uno o varios ficheros.
Unidades
n
n
n
n
Subprogramas
Paquetes
Tareas
Objetos protegidos
55
© José Miguel Santos Espino – Alexis Quesada Arencibia
Paquetes
n
n
n
En general un programa Ada se compone de
un conjunto de paquetes y un programa
principal
La cláusula de contexto with sirve para
declarar que se se van a usar los servicios de
un paquete
Paquete:
n
n
Especificación (*.ads)
Implemetación(*.adb)
56
© José Miguel Santos Espino – Alexis Quesada Arencibia
Formato general de un paquete
package nombre_paquete is
parte visible
declaraciones (variables, tipos,
subtipos, procedimientos,...)
private
declaraciones privadas
end nombre_paquete;
package body nombre_paquete is
más declaraciones y desarrollo del paquete
begin
secuencia de sentencias
end nombre_paquete;
57
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más sobre paquetes
n
n
n
n
Los entes declarados dentro del paquete
tienen el mismo tiempo de vida que el paquete
en sí
Los paquetes se pueden declarar en cualquier
parte declarativa, es decir, en un bloque,
subprograma o en otro paquete
Acceso a los elementos de un paquete:
Cláusula “use” o bien notación “.”
Un paquete puede consistir sólo en una
especificación
58
© José Miguel Santos Espino – Alexis Quesada Arencibia
Tipos private y limited private
n
n
n
Al poner un tipo como “private” su definición
queda oculta
El usuario del paquete sólo podrá utilizar con él
las operaciones declaradas en la parte pública
del paquete, además de :=, = y /=
Si se pone como “limited private” entonces se
deshabilitan también :=, = y /=
59
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplo
package Manejo_De_Claves is
type Clave is private;
Clavenula : constant Clave;
procedure Tomar_Clave(C : out Clave);
function "<"(X, Y : in Clave) return Boolean;
private
Max : constant := 2 ** 16 - l;
type Clave is range 0 .. Max;
Clavenula : constant Clave := 0;
end Manejo_De_Claves;
60
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplo (2)
package body Manejo_De_Claves is
procedure Tomar_Clave(C : out Clave) is
begin
Cuerpo del procedimiento
end Tomar_Clave;
function "<"(X, Y : in Clave) return Boolean is
begin
Cuerpo del operador
end "<";
end Manejo_De_Claves;
61
© José Miguel Santos Espino – Alexis Quesada Arencibia
Renombrado
n
Se puede aplicar a variables, constantes,
excepciones, subprogramas y paquetes
procedure TomaClave(C:out Clave) renames
Manejo_de_Claves.Tomar_Clave;
function “*”(X,Y:VECTOR) return REAL renames ESCALAR;
function DIEZ return CIFRA_ROMANA renames ‘X’;
package P renames PILA;
62
© José Miguel Santos Espino – Alexis Quesada Arencibia
Unidades genéricas
n
Unidades con parámetros que se pueden
concretar para diferentes instancias de la
unidad
generic
type TElemento is private;
procedure Algo(Elemento:in TElemento) is
Declaraciones
begin
Acciones
end Algo;
63
© José Miguel Santos Espino – Alexis Quesada Arencibia
Unidades genéricas (2)
n
Para utilizar el procedimiento “Algo” primero se
deberán crear instancias para los tipos
apropiados
...
procedure Algo_Entero is new Algo(integer);
procedure Algo_Carácter is new Algo(character);
...
Algo_Entero(30);
Algo_Carácter(‘a’);
...
64
© José Miguel Santos Espino – Alexis Quesada Arencibia
Paquetes genéricos (PG)
n
Los paquetes genéricos son los que
soportan la genericidad de los tipos
abstractos de datos en este lenguaje
65
© José Miguel Santos Espino – Alexis Quesada Arencibia
Formato general de un PG
generic
zona de declaración de parámetros formales
package nombre_paquete_generico is
zona de uso de los parámetros formales
end nombre_paquete_generico;
package body nombre_paquete_generico is
desarrollo del paquete
end nombre_paquete_generico;
66
© José Miguel Santos Espino – Alexis Quesada Arencibia
Formato general de un PG (2)
n
La forma de usar un paquete genérico es
crear una instancia del PG en la que se
especifiquen todos los parámetros formales
requeridos
package nombre_instancia is new
nombre_paquete generico (parametros actuales, ...);
67
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplo
generic
MAX:POSITIVE;
type ITEM is private;
package PILA is
procedure PONER(X:ITEM);
function QUITAR return ITEM;
end PILA;
package body PILA is
P: array (1..MAX) of ITEM;
CIMA: INTEGER range 0..MAX;
--cuerpo de PONER y QUITAR
begin
CIMA:=0;
end PILA;
68
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplo (2)
...
declare
package MI_PILA is new PILA(100,REAL);
use MI_PILA;
begin
...
PONER(X);
...
Y:=QUITAR;
...
end;
69
© José Miguel Santos Espino – Alexis Quesada Arencibia
Parámetros formales en PG
n
n
n
Los parámetros formales pueden ser:
objetos, tipos, subprogramas o
paquetes
Los parámetros de un PG pueden tener
un valor por defecto
Se declaran de distinta forma según su
naturaleza
70
© José Miguel Santos Espino – Alexis Quesada Arencibia
Manejo de Excepciones
n
En Ada, cuando se producen errores
durante la ejecución de un programa se
elevará una excepción
71
© José Miguel Santos Espino – Alexis Quesada Arencibia
Excepciones predefinidas
n
CONSTRAINT_ERROR
n
n
NUMERIC_ERROR
n
n
Generalmente algo fuera de rango
Errores numéricos (p.ej. división por 0)
PROGRAM_ERROR
n
Errores estructura de control (p.ej. se llega
al “end” de una función, se llama a un
programa cuyo cuerpo no se ha definido,..)
72
© José Miguel Santos Espino – Alexis Quesada Arencibia
Excepciones predefinidas (2)
n
STORAGE_ERROR
n
n
Falta de espacio de memoria
TASKING_ERROR
n
Errores relacionados con tareas
73
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ejemplo
begin
--secuencia de sentencias
exception
when NUMERIC_ERROR|CONSTRAINT_ERROR =>
Put(“Numeric o constraint error”);
...
when STORAGE_ERROR =>
Put(“Falta de memoria”);
...
when others =>
Put(“Se produjo otro tipo de error”);
...
end;
74
© José Miguel Santos Espino – Alexis Quesada Arencibia
¿ Dónde se tratan ?
n
Los manejadores de excepciones
pueden aparecer al final de:
n
n
n
n
n
un
un
un
un
bloque
cuerpo de subprograma
cuerpo de paquete o
cuerpo de tarea
No puede devolverse nunca el control a
la unidad donde se elevó la excepción
75
© José Miguel Santos Espino – Alexis Quesada Arencibia
Propagación de excepciones
n
Si una unidad no proporciona un manejador para
una determinada excepción, ésta se propaga
dinámicamente
n
n
n
Se termina la ejecución de la unidad
La excepción se eleva al punto donde se invocó a
dicha unidad y así sucesivamente
Por tanto, las excepciones se propagan
dinámicamente y no estáticamente
76
© José Miguel Santos Espino – Alexis Quesada Arencibia
Excepciones definidas por el
Programador
n
Es posible lanzar una excepción:
n
n
Sintaxis de declaración de excepciones:
n
n
raise EXCEPCION;
Miexcepción: exception;
Las reglas de manejo y propagación son
idénticas a las excepciones predefinidas
77
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más sobre excepciones
n
n
Las acciones llevadas a cabo por el
manejador pueden tener que realizarse
en varias capas
A veces es conveniente manejar una
excepción y luego propagar esa misma
excepción (raise)
78
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ámbito de las excepciones
n
n
Las excepciones siguen las mismas
reglas de ámbito que otras entidades
Una excepción puede propagarse fuera
de su ámbito, aunque a partir de ahí
solo puede manejarse anónimamente
mediante others
79
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ámbito de las excepciones (2)
n
n
Una excepción elevada en una
declaración se propaga un nivel hacia
fuera
Si un subprograma termina debido a
una excepción, no podemos suponer
nada sobre los parámetros reales out o
in out
80
© José Miguel Santos Espino – Alexis Quesada Arencibia
Punteros (access types)
n
Dos clases de punteros:
n
n
n
n
n
punteros para memoria dinámica
punteros generales
Los punteros (access), por defecto, sólo sirven para
trabajar con memoria dinámica
Si se quiere trabajar con punteros a objetos
estáticos, hay que usar punteros generales (access
all)
Para poder tomar la dirección de un objeto, éste
debe haber sido declarado expresamente como
“aliased”.
81
© José Miguel Santos Espino – Alexis Quesada Arencibia
Punteros de memoria dinámica
type cosa is
record
c1,c2:integer;
end record;
type ptr_cosa is access cosa; -- tipo puntero
ptr : ptr_cosa;
c : cosa;
ptr := new cosa’(20,30);
-- creación dinámica
ptr.c1 := 15;
-- acceso a un campo
ptr.all := c;
-- acceso a todo el objeto
82
© José Miguel Santos Espino – Alexis Quesada Arencibia
Punteros generales
type cosa is
record
c1,c2:integer;
end record;
type ptr_cosa is access all cosa;
ptr : ptr_cosa;
cosa1 : aliased cosa;
cosa2 : cosa;
ptr := new cosa’(20,30);
ptr := cosa1’access; -- correcto
ptr := cosa2’access; -- ERROR
ptr := cosa2’Unchecked_access; -- correcto
83
© José Miguel Santos Espino – Alexis Quesada Arencibia
84
Borrado de memoria dinámica
n
n
El lenguaje Ada permite recolección de basura
(pero ningún compilador la soporta)
Borrado explícito con
Ada.Unchecked_Deallocation
with Ada.Unchecked_Deallocation;
...
procedure Free is new
Ada.Unchecked_Deallocation(cosa,ptr_cosa);
...
Free(ptr);
© José Miguel Santos Espino – Alexis Quesada Arencibia
Parámetros “access”
n
n
Un parámetro de un procedimiento puede ser
in, out o access.
En este último caso, el parámetro se
comporta como un tipo puntero
procedure P (X:access Cosa);
...
c: aliased cosa;
P(c’access);
85
© José Miguel Santos Espino – Alexis Quesada Arencibia
Un apunte más sobre punteros
n
Se puede imponer una restricción de
lectura a un puntero de forma que no
pueda modificar el objeto al que apunta
type Punt_Const_Int is access constant integer;
ptr: Punt_Const_Int;
i: aliased integer;
ptr=i’access;
ptr.all:=3; --error, no se puede modificar i a
--través de ptr
86
© José Miguel Santos Espino – Alexis Quesada Arencibia
Entrada / Salida
n
Funciones básicas
n
n
n
n
get(X), put(X) siendo X de tipo character, string,
integer, float, enumeration
get_line(S,L), put_line(s), siendo S de tipo string
y L la longitud leida
new_line, skip_line
Para realizar E/S de ristras o caracteres basta
incluir la cláusula de contexto “with TEXT_IO”
87
© José Miguel Santos Espino – Alexis Quesada Arencibia
Entrada / Salida (2)
n
n
Para realizar E/S de los tipos escalares es
necesario crear una instancia del paquete
para este tipo
En cualquier caso hay que utilizar la cláusula
“with TEXT_IO”, puesto que estos paquetes
se encuentran en dicha librería
package
package
package
package
package
package
Día_IO is new Enumeration_IO(Dia);
Mientero_IO is new Integer_IO(Mientero);
rf_IO is new Float_IO(rf);
rfija1_IO is new Fixed_IO(rfija1);
rfija2_IO is new Decimal_IO(rfija1);
Natural_IO is new Modular_IO(rfija1);
88
© José Miguel Santos Espino – Alexis Quesada Arencibia
Más sobre cadenas
n
Ada ofrece tres tipos posibles de ristras
de caracteres
n
Ristras de tamaño fijo (ya hemos hablado de
ellas: strings)
n
n
Ristras de tamaño limitado
n
n
with Ada.Strings.Fixed
with Ada.Strings.Bounded
Ristras de tamaño dinámico
n
with Ada.Strings.Unbounded
89
© José Miguel Santos Espino – Alexis Quesada Arencibia
Ficheros
n
Ficheros de texto
n
n
with Text_IO
Ficheros uniformes
n
Ficheros secuenciales
n
n
Ficheros de acceso directo
n
n
with Sequential_IO;
with Direct_IO;
Existe un cuarto paquete que contiene las
declaraciones de las excepciones usadas en
estos tres paquetes (IO_EXCEPTIONS)
90
© José Miguel Santos Espino – Alexis Quesada Arencibia
Funciones numéricas
n
Paquete Ada.Numerics
n
Funciones matemáticas elementales (sqrt,
log, sin, cos,...)
n
n
Ada.Numerics.Generic_Elementary_Functions
Números aleatorios
n
Discretos
n
n
Ada.Numerics.Discrete_Random
Coma flotante
n
Ada.Numerics.Float_Random
91
© José Miguel Santos Espino – Alexis Quesada Arencibia
Pragmas
n
Algunas veces es necesario hacer una
“observación” al margen al compilador
n
n
n
pragma nombre(params);
En general, se pueden colocar en cualquier punto
donde pueda haber declaraciones o sentencias
(aunque algunos pragmas pueden tener
restricciones en este sentido)
Algunos pragmas:
n
Inline, Interface, Optimize, Priority, ...
92