seminario de lenguajes a – opción ada seminario de lenguajes a – opción ada – raúl...

Seminario de Lenguajes A – Opción Ada

Seminario de Lenguajes A – Opción Ada – Raúl Champredonde 1

• Packages– Unidad de compilación que permite la

especificación de grupos de entidades lógicamente relacionadas:• Colección de tipos, variables y/o constantes,

subprogramas, packages• Combinación de los anteriores• Tipos de datos abstractos y datos abstractos

– Dos partes• Especificación• Cuerpo



• Packages– Especificación

• Cada package tiene una especificación pero no necesariamente un cuerpo

• En la especificación se encuentran las declaraciones públicas

package Rational_Numbers is type Rational is record Numerator: integer; Denominator: Positive; end record; function "="(X,Y: Rational) return boolean; function "/"(X,Y: integer) return Rational; function "+"(X,Y: Rational) return Rational; function "-"(X,Y: Rational) return Rational; function "*"(X,Y: Rational) return Rational; function "/"(X,Y: Rational) return Rational;end Rational_Numbers;



• Packages– Cuerpo

• En el cuerpo se encuentra la parte “no pública del package

• Implementa las declaraciones de la especificación• El cuerpo es obligatorio cuando

– La especificación tiene declaraciones que requieren un cuerpo

– Se requiere inicialización



• Packages– Cuerpo

package body Rational_Numbers is procedure Same_Denominator(X, Y: in out Rational) is begin -- reduces X and Y to the same denominator: -- ... end Same_Denominator; function "="(X,Y: Rational) return Boolean is U : Rational := X; V : Rational := Y; begin Same_Denominator(U, V); return U.Numerator = V.Numerator; end "="; function "/"(X, Y: Integer) return Rational is begin if Y > 0 then return (Numerator => X, Denominator => Y); else return (Numerator => -X, Denominator => -Y); end if; end "/"; function "+"(X, Y: Rational) return Rational is ... end "+"; function "-"(X, Y: Rational) return Rational is ... end "-"; function "*"(X, Y: Rational) return Rational is ... end "*"; function "/"(X, Y: Rational) return Rational is ... end "/";end Rational_Numbers;



• Packages– Uso de un package (with y use)

with Rational_Numbers;procedure Use_Rational_Numbers is R1, R2: Rational_Numbers.Rational;begin R1 := Rational_Numbers."/"(1, 2); R2 := Rational_Numbers."/"(2, 4);end Use_Rational_Numbers;

with Rational_Numbers;use Rational_Numbers;procedure Use_Rational_Numbers is R1, R2: Rational;begin R1 := 1 / 2; R2 := 2 / 4;end Use_Rational_Numbers;

– Posibles conflictos con la cláusula use



• Packages– Tipos privados

• Parte privada del package = mayor abstracción

package StackInt is type Stack is private; procedure Push(S: in out Stack; I: in integer); procedure Pop(S: in out Stack; I: out integer); function IsEmpty(S: in Stack) return boolean; -- ...private type Nodo; type Stack is access Nodo; type Nodo is record Valor: integer; Siguiente: Stack; end record;end StackInt;



• Packages– Tipos privados

package body StackInt is procedure Push(S: in out Stack; I: in integer) is begin S := new Nodo'(I, S); end Push; procedure Pop(S: in out Stack; I: out integer) is begin if S /= null then I := S.Valor; S := S.Siguiente; end if; end Pop; function IsEmpty(S: in Stack) return boolean is begin return S = null; end IsEmpty; -- ....end StackInt;



• Packages– En el programa se puede:

• Tipos comunes (ej: Rational_Numbers):– Declarar variables y constantes– Asignar– Comparar por igualdad– Operaciones definidas por el package– Acceder a la estructura, referenciar campos, elementos, etc.

• Tipos privados (ej: StackInt):– Declarar variables y constantes– Asignar– Comparar por igualdad– Operaciones definidas por el package



• Packages– Tipos privados limitados

package StackInt is type Stack is limited private; procedure Push(S: in out Stack; I: in integer); procedure Pop(S: in out Stack; I: out integer); function IsEmpty(S: in Stack) return boolean; -- ...private type Nodo; type Stack is access Nodo; type Nodo is record Valor: integer; Siguiente: Stack; end record;end StackInt;

– En el programa se puede • Declarar variables y constantes• Operaciones definidas por el package



• Packages– Inicialización

package body PkgImagen is -- ....begin -- abrir archivo de imagen -- leer contenido del archivo y cargarlo en una variable Imagen

-- cerrar archivoend PkgImagen;



• Excepciones– Terminación normal y anormal– Mecanismo de tratamiento y recuperación de errores en

tiempo de ejecución y situaciones excepcionales– Ejemplos: división por cero, overflow, indice de un arreglo que excede

sus límites, fin de archivo, etc.

procedure Clase7_Excepciones1 is subtype Rango is integer range 1..10; Vector: array (Rango) of integer := (...........); I: integer; package IIO is new Integer_IO(integer); use IIO;begin loop Get(I); (posible Data_error) exit when I = 0; Put(Vector(I)); (posible

Constraint_error) end loop;end Clase7_Excepciones1;



• Excepciones– Algunas excepciones predefinidas son:

• Constraint_error– Se produce cuando el programa viola alguna forma de

restricción (restricciones de rango, restricciones de índice, restricciones de discriminante, etc.)

• Data_Error– Se produce cuando se lee un valor que no se corresponde

con el tipo de la variable sobre la cual se lee

• Storage_error– Se produce cuando hay una cantidad de memoria

insuficiente para satisfacer los requerimientos de memoria en tiempo de ejecución de un programa



• Excepciones– Cómo atrapar y manejar un error?

• Manejadores de excepcionesbegin Sentencia 1; ...... Sentencia N;exception when Constraint_error => Sentencias; when others => Sentencias;end;

– Los manejadores de excepciones pueden aparecer en:• Bloques begin/end, cuerpo de subprograma, package o task

– Qué pasa luego de manejar un error?• Dos esquemas. En Ada termina anormalmente la unidad en

ejecución y devuelve el control a la unidad llamadora



• Excepciones– Qué pasa si la unidad no define un manejador?

• => Propagación

procedure P is procedure Q is begin .... end Q;begin ... Q; ...exception when constraint_error => ......end P;

se “propaga” alllamador



• Excepciones– Propagación automática

procedure P is procedure Q is begin .... exception when constraint_error => .... end Q;begin ... Q; ...exception when constraint_error => ......end P;

(1) se maneja y vuelve al punto de llamado

(2) se maneja y termina



• Excepciones– La propagación

sigue la cadena dinámica

procedure P is procedure R is begin .... (1)

end R; procedure Q is begin ....

R; (2) ....

exception when constraint_error => ....

end Q;begin ...

Q; (3) ...

exception when constraint_error => ......

end P;

P

Q

R



• Excepciones– Propagación por programa

begin Sentencia 1; Sentencia 2; ....... Sentencia N;exception when Constraint_error => Sentencias; raise;end;



• Excepciones– Ejemplo procedure Clase7_Excepciones1 is

subtype Rango is integer range 1..10; Vector: array (Rango) of integer := (...........); I: integer; package IIO is new Integer_IO(integer); use IIO;

begin loop Get(I); exit when I = 0; Put(Vector(I)); end loop;end Clase7_Excepciones1;

begin loop begin Get(I); exit when I = 0; Put(Vector(I)); exception when Data_error => Put("El valor ingresado no es entero"); when Constraint_error => Put("El valor debe estar en 1..10"); end; end loop;end Clase7_Excepciones2;



• Excepciones– Generación de excepción por programa

• El programador puede generar cualquier excepción por programa

Get(PossiblePrice);

if PossiblePrice <= MinPrice or

PossiblePrice > MaxPrice then

raise Data_Error;

end if;



• Excepciones– Declaración de excepciones

• El programador puede declarar sus propias excepcionesPrice_error: exception;--------------------------------

Get(PossiblePrice);

if PossiblePrice <= MinPrice or

PossiblePrice > MaxPrice then

raise Price_Error;

end if;--------------------------------

exception

when Price_Error =>

...............



• Excepciones– Declaración de excepciones. Ejemplo

package StackInt2 is type Stack is private; procedure Push(S: in out Stack; I: in integer); procedure Pop(S: in out Stack; I: out integer); Overflow, Underflow: exception; .....end StackInt2;

begin loop I := I + 1; Push(S, I); end loop;exception when Overflow => Put_Line("llena");end;begin loop Pop(S, I); Put(I); end loop;exception when Underflow => Put_Line("Vacia");end;

procedure Push(S: in out Stack; I: in integer) isbegin if S.CantNodos = MaxCount then raise Overflow; end if; .....end Push;procedure Pop(S: in out Stack; I: out integer) isbegin if S.CantNodos = 0 then raise Underflow; end if; .....end Pop;



• Excepciones– Alcance de una excepción

• Es igual que para cualquier identificadorprocedure P is E: exception; procedure Q is begin raise E; end Q; procedure R is E: exception; begin Q; exception when E => -- excepción E local end R;begin R;exception when E => -- excepción E globalend P;



• Excepciones en Javapublic void writeList() { PrintWriter out = null; try { System.out.println("Entering try statement"); out = new PrintWriter(new FileWriter("OutFile.txt")); for (int i = 0; i < SIZE; i++) out.println("Value at: " + i + " = " + victor.elementAt(i));

} catch (ArrayIndexOutOfBoundsException e) { System.err.println("Caught " + "ArrayIndexOutOfBoundsException: " + e.getMessage());

} catch (IOException e) { System.err.println("Caught IOException: " + e.getMessage());}




} finally { if (out != null) { System.out.println("Closing PrintWriter"); out.close(); } else { System.out.println("PrintWriter not open"); } }}




} catch (ArrayIndexOutOfBoundsException e) { System.err.println("Caught " + "ArrayIndexOutOfBoundsException: " + e.getMessage());

} catch (IOException e) { System.err.println("Caught IOException: " + e.getMessage());

} finally { if (out != null) { System.out.println("Closing PrintWriter"); out.close(); } else { System.out.println("PrintWriter not open"); } }}



• Excepciones en Delphi

Zero := 0;try

dummy := 10 / Zero;except

on EZeroDivide do MessageDlg('Can not divide by zero!', mtError, [mbOK], 0) ;

end;



• Excepciones en Delphi

AboutBox := TAboutBox.Create(nil) ;try AboutBox.ShowModal;finally AboutBox.Release;end;

seminario de lenguajes a – opción ada seminario de lenguajes a – opción ada – raúl...

Documents