En Ada, cuando se produce algún error durante la ejecución de un programa, se eleva una
excepción. Dicha excepción puede provocar la terminación abrupta del programa, pero se puede controlar y realizar las acciones pertinentes. También se pueden definir nuevas excepciones que indiquen distintos tipos de error.
Excepciones predefinidas
En
Ada, dentro del
paquete Standard, existen unas excepciones predefinidas, éstas son:
Constraint_Error cuando se intenta violar una restricción impuesta en una declaración, tal como indexar más allá de los límites de un array o asignar a una variable un valor fuera del rango de su
subtipo. Program_Error se produce cuando se intenta violar la estructura de control, como cuando una función termina sin devolver un valor. Storage_Error es elevada cuando se requiere más memoria de la disponible. Tasking_Error cuando hay errores en la comunicación y manejo de tareas. Numeric_Error en Ada 83 se podía presentar cuando ocurría un error aritmético. A partir del estándar
Ada 95, desaparece por motivos de portabilidad y pasa a ser un
renombrado de Constraint_Error. Por ejemplo, en Ada 83 al dividir entre cero podía saltar Constraint_Error o Numeric_Error (dependiendo del compilador). En Ada 95 este error siempre levanta Constraint_Error.
Manejador de excepciones
Cuando se espere que pueda presentarse alguna excepción en parte del código del programa, se puede escribir un manejador de excepciones en las construcciones que lo permitan (bloques o cuerpos de subprogramas, paquetes o tareas), aunque siempre está el recurso de incluir un bloque en cualquier lugar del código. Su sintaxis sería:
manejador_excepción ::=
when [ identificador : ] elección_excepción { | elección_excepción } =>
secuencia_sentencias
elección_excepción ::= identificador |
others
La palabra reservada others indica cualquier otra excepción y debe ser la única y última opción.
A la sentencia que comienza por when, se le denomina manejador de excepción.
Por ejemplo, en un bloque:
begin
-- ...
exception
when Constraint_Error =>
Put ("Error de rango.");
when Program_Error | Tasking_Error =>
Put ("Error de flujo.");
when others =>
Put ("Otro error.");
end;
En el momento en el que se produzca la elevación de Constraint_Error durante la ejecución de la secuencia de sentencias entre begin y exception, inmediatamente se interrumpe el flujo de control y se transfiere éste a la secuencia de sentencias que siguen a la palabra reservada => del manejador correspondiente.
Otro ejemplo con una función:
function Mañana (Hoy: TDía)
return TDía
is
begin
return TDía'Succ(Hoy);
exception
when Constraint_Error =>
return TDía'First;
end Mañana;
Nótese que no se puede devolver nunca el control a la unidad donde se elevó la excepción. Cuando se termina la secuencia de sentencias del manejador, termina también la ejecución de dicha unidad.
Si no se controla una excepción, ésta se propaga dinámicamente por las sucesivas unidades invocantes hasta que se maneje en otra o directamente termina la ejecución del programa proporcionando un mensaje con la excepción provocada por pantalla.
Declaración y elevación de excepciones
Normalmente, es probable prever una situación de error que no se encuentra entre las excepciones predefinidas, por ello, se puede declarar excepciones. Por ejemplo:
Error:
exception;
Con lo que se puede elevar dicha excepción en el momento pertinente mediante la sentencia raise, cuya sintaxis es:
elevación_excepción ::=
raise [ identificador ] ;
Por ejemplo, en un paquete de manejo de una pila estática de números enteros:
package Pila_enteros
is
ErrorPilaEnteros:
exception;
procedure Poner (X: Integer);
function Quitar
return Integer;
end Pila_enteros;
package body Pila_enteros
is
Max:
constant := 100;
Pila:
array (1..Max)
of Integer;
Cima: Integer
range 0..Max;
procedure Poner (X: Integer)
is
begin
if Cima = Max
then
raise ErrorPilaEnteros;
-- Se eleva la excepción.
end if;
Cima := Cima + 1;
P(Cima) := X;
end Poner;
function Quitar
return Integer
is
begin
if Cima = 0
then
raise ErrorPilaEnteros;
-- Se eleva la excepción.
end if;
Cima := Cima - 1;
return Pila(Cima+1);
end Quitar;
begin
Cima := 0;
end Pila_enteros;
Obsérvese que no hace falta else en la sentencias if, pues al elevar la excepción, finaliza la ejecución del subprograma.
Ahora se podría escribir:
declare
use Pila_enteros;
begin
Poner (5);
-- ...
exception
when ErrorPilaEnteros =>
-- ... Manipulación incorrecta de la pila.
when others =>
-- ...
end;
Si se quiere que dicha excepción no se propague más allá de la unidad en la que se elevó pero no se quiere manejar, se puede emplear una única sentencia vacía (null) dentro de su manejador correspondiente:
procedure Vaciar_pila_enteros
is
Basura: Integer;
use Pila_enteros;
begin
loop
Basura := Quitar;
end loop;
exception
when ErrorPilaEnteros =>
null;
end Vaciar_pila_enteros;
Aunque esto no evitaría que se terminara la ejecución de la unidad.
En el caso en el que se quiera propagar una excepción después de haber ejecutado las sentencias pertinentes, se incluiría una sentencia raise dentro del manejador:
-- ...
exception
when ErrorPilaEnteros =>
Put ("Pila utilizada incorrectamente.");
Vaciar_pila_enteros;
raise ErrorProcesamieto;
-- Se propaga otra excepción.
end;
En este caso se propaga otra excepción, pero podría haber sido la misma simplemente con raise, sin crear una nueva ocurrencia de la excepción, por ejemplo:
-- ...
exception
when FalloEnVálvula =>
Put ("Se ha producido un fallo en la válvula.");
raise;
-- Se propaga la misma excepción del manejador.
end;
Así, se puede realizar un manejo de la excepción en varias capas, realizando sucesivas acciones en cada una de ellas. Dicha sentencia raise sin argumentos debe ser invocada directamente en el manejador, no es posible invocarla en un procedimiento llamado por el manejador.
Información de la excepción
Ada proporciona información sobre una determinada excepción haciendo uso del
paquete predefinido Ada.Exceptions y tras obtener la ocurrencia de la excepción mediante esta notación:
when Ocurrencia : ErrorSensor =>
Put_Line (Ada.Exceptions.Exception_Information (Ocurrencia));
Manual de referencia de Ada
En Ada, cuando se produce algún error durante la ejecución de un programa, se eleva una
excepción. Dicha excepción puede provocar la terminación abrupta del programa, pero se puede controlar y realizar las acciones pertinentes. También se pueden definir nuevas excepciones que indiquen distintos tipos de error.
Excepciones predefinidas
En
Ada, dentro del
paquete Standard, existen unas excepciones predefinidas, éstas son:
Constraint_Error cuando se intenta violar una restricción impuesta en una declaración, tal como indexar más allá de los límites de un array o asignar a una variable un valor fuera del rango de su
subtipo. Program_Error se produce cuando se intenta violar la estructura de control, como cuando una función termina sin devolver un valor. Storage_Error es elevada cuando se requiere más memoria de la disponible. Tasking_Error cuando hay errores en la comunicación y manejo de tareas. Numeric_Error en Ada 83 se podía presentar cuando ocurría un error aritmético. A partir del estándar
Ada 95, desaparece por motivos de portabilidad y pasa a ser un
renombrado de Constraint_Error. Por ejemplo, en Ada 83 al dividir entre cero podía saltar Constraint_Error o Numeric_Error (dependiendo del compilador). En Ada 95 este error siempre levanta Constraint_Error.
Manejador de excepciones
Cuando se espere que pueda presentarse alguna excepción en parte del código del programa, se puede escribir un manejador de excepciones en las construcciones que lo permitan (bloques o cuerpos de subprogramas, paquetes o tareas), aunque siempre está el recurso de incluir un bloque en cualquier lugar del código. Su sintaxis sería:
manejador_excepción ::=
when [ identificador : ] elección_excepción { | elección_excepción } =>
secuencia_sentencias
elección_excepción ::= identificador |
others
La palabra reservada others indica cualquier otra excepción y debe ser la única y última opción.
A la sentencia que comienza por when, se le denomina manejador de excepción.
Por ejemplo, en un bloque:
begin
-- ...
exception
when Constraint_Error =>
Put ("Error de rango.");
when Program_Error | Tasking_Error =>
Put ("Error de flujo.");
when others =>
Put ("Otro error.");
end;
En el momento en el que se produzca la elevación de Constraint_Error durante la ejecución de la secuencia de sentencias entre begin y exception, inmediatamente se interrumpe el flujo de control y se transfiere éste a la secuencia de sentencias que siguen a la palabra reservada => del manejador correspondiente.
Otro ejemplo con una función:
function Mañana (Hoy: TDía)
return TDía
is
begin
return TDía'Succ(Hoy);
exception
when Constraint_Error =>
return TDía'First;
end Mañana;
Nótese que no se puede devolver nunca el control a la unidad donde se elevó la excepción. Cuando se termina la secuencia de sentencias del manejador, termina también la ejecución de dicha unidad.
Si no se controla una excepción, ésta se propaga dinámicamente por las sucesivas unidades invocantes hasta que se maneje en otra o directamente termina la ejecución del programa proporcionando un mensaje con la excepción provocada por pantalla.
Declaración y elevación de excepciones
Normalmente, es probable prever una situación de error que no se encuentra entre las excepciones predefinidas, por ello, se puede declarar excepciones. Por ejemplo:
Error:
exception;
Con lo que se puede elevar dicha excepción en el momento pertinente mediante la sentencia raise, cuya sintaxis es:
elevación_excepción ::=
raise [ identificador ] ;
Por ejemplo, en un paquete de manejo de una pila estática de números enteros:
package Pila_enteros
is
ErrorPilaEnteros:
exception;
procedure Poner (X: Integer);
function Quitar
return Integer;
end Pila_enteros;
package body Pila_enteros
is
Max:
constant := 100;
Pila:
array (1..Max)
of Integer;
Cima: Integer
range 0..Max;
procedure Poner (X: Integer)
is
begin
if Cima = Max
then
raise ErrorPilaEnteros;
-- Se eleva la excepción.
end if;
Cima := Cima + 1;
P(Cima) := X;
end Poner;
function Quitar
return Integer
is
begin
if Cima = 0
then
raise ErrorPilaEnteros;
-- Se eleva la excepción.
end if;
Cima := Cima - 1;
return Pila(Cima+1);
end Quitar;
begin
Cima := 0;
end Pila_enteros;
Obsérvese que no hace falta else en la sentencias if, pues al elevar la excepción, finaliza la ejecución del subprograma.
Ahora se podría escribir:
declare
use Pila_enteros;
begin
Poner (5);
-- ...
exception
when ErrorPilaEnteros =>
-- ... Manipulación incorrecta de la pila.
when others =>
-- ...
end;
Si se quiere que dicha excepción no se propague más allá de la unidad en la que se elevó pero no se quiere manejar, se puede emplear una única sentencia vacía (null) dentro de su manejador correspondiente:
procedure Vaciar_pila_enteros
is
Basura: Integer;
use Pila_enteros;
begin
loop
Basura := Quitar;
end loop;
exception
when ErrorPilaEnteros =>
null;
end Vaciar_pila_enteros;
Aunque esto no evitaría que se terminara la ejecución de la unidad.
En el caso en el que se quiera propagar una excepción después de haber ejecutado las sentencias pertinentes, se incluiría una sentencia raise dentro del manejador:
-- ...
exception
when ErrorPilaEnteros =>
Put ("Pila utilizada incorrectamente.");
Vaciar_pila_enteros;
raise ErrorProcesamieto;
-- Se propaga otra excepción.
end;
En este caso se propaga otra excepción, pero podría haber sido la misma simplemente con raise, sin crear una nueva ocurrencia de la excepción, por ejemplo:
-- ...
exception
when FalloEnVálvula =>
Put ("Se ha producido un fallo en la válvula.");
raise;
-- Se propaga la misma excepción del manejador.
end;
Así, se puede realizar un manejo de la excepción en varias capas, realizando sucesivas acciones en cada una de ellas. Dicha sentencia raise sin argumentos debe ser invocada directamente en el manejador, no es posible invocarla en un procedimiento llamado por el manejador.
Información de la excepción
Ada proporciona información sobre una determinada excepción haciendo uso del
paquete predefinido Ada.Exceptions y tras obtener la ocurrencia de la excepción mediante esta notación:
when Ocurrencia : ErrorSensor =>
Put_Line (Ada.Exceptions.Exception_Information (Ocurrencia));
Manual de referencia de Ada
