Ejercicio 1

Una excepción es una condición o suceso anormal en la ejecución de un programa y no

puede ser manejada en el contexto local, es decir que la unidad está incapacitada para
proceder de una manera tal que se llegue a una terminación normal. No significa
necesariamente que estamos ante un error catastrófico.

Ejercicio 2

Un lenguaje para tratar excepciones debería proveer:

- La posibilidad (sintaxis necesaria) de definir manejadores de excepciones que son

unidades especiales que tratarán las excepciones.
- Una forma de declarar las excepciones
- Una forma de alcanzarlas, invocarlas.
- Y además proveer un criterio de continuación.

No todos los lenguajes proveen un mecanismo para manejar excepciones. Pascal por
ejemplo.

Ejercicio 3

Cuando un lenguaje no provee mecanismos para manejar errores una excepción

detiene la ejecución del programa y no puede continuar.

Existe la opción por parte del programador (en un lenguaje que no provee manejador
de excepciones):

o Inventar un valor que el llamado recibe en lugar de un valor válido, o retornar

un valor de estado al llamador.
o Todo esto aplicado sobre estructuras condicionales if - else permitiendo optar
la ejecución normal del programa o ejecutar otras instrucciones.
o Para esto se debería tener un control sobre los valores-resultados por ejemplo,
0 o 1, pasados como parámetros en cada unidad, teniendo que comprobarse
para poder continuar.

Ejercicio 4

a) Modelos: de Terminación y de Reasunción.

b) Explicación:
a. Modelo de Terminación:
i. Se termina la ejecución de la unidad que alcanza la excepción y se
transfiere el control al manejador.
 ii. Conceptualmente significa que no puede reanudarse la acción que
alcanzó la excepción.
iii. Adoptado por lenguajes como ADA y CLU.
b. Modelo de Reasunción:
i. Se maneja la excepción y se devuelve el control al punto siguiente
donde se invocó a la excepción, permitiendo la continuación de la
ejecución de la unidad.
ii. Este mecanismo es flexible y potente, pero difícil de dominar por
programadores inexpertos.
iii. Es adoptado por PL/1.

El mecanismo de Reasunción es más inseguro pues puede quitar el síntoma de un

error sin quitar la causa del mismo: ejemplo, se puede tratar la excepción provocada
por un valor erróneo generando arbitrariamente un valor aceptable.

Por definición, las excepciones son condiciones anómalas que no puede ser manejada
por el procedimiento, lo cual supone que una unidad no está capacitada para
continuar la ejecución y debe terminar.

Ejercicio 5

- Propagación de los errores en ADA:

o Modelo por TERMINACIÓN.
o Si la unidad que alcanza una excepción tiene un manejador para la misma:
1- Se le transfiere inmediatamente el control
2- Se saltan las acciones que siguen al punto donde se alcanzó la
excepción
3- Se ejecuta el manejador
4- Termina la unidad
o Si la unidad no tiene un manejador:
1- Se propaga la excepción hacia arriba de la cadena dinámica de
llamadas de subprogramas
2- Hasta el subprograma que haya sido llamado más recientemente y que
contenga un manejador para ella
3- O hasta un manejador definido por el sistema si no está presente un
manejador definido por el programa
4- Dentro de un manejador: si el nombre de la excepción no se encuentra
entonces se relevanta la misma excepción que se está manejando.
o Una vez que una excepción ha sido procesada, la unidad termina la ejecución
en forma normal y transfiere el control a quien lo llamó.
o Si dicha unidad es un bloque, termina su ejecución y se vuelve a alcanzar
implícitamente la excepción en la unidad que lo engloba.
 o Si es un cuerpo de un subprograma, se hace el retorno desde el mismo y se
realcanza implícitamente la excepción en el punto de llamada.
o Si es el cuerpo de un package, y no hay un manejador, se propaga la excepción
a la unidad que contiene a dicho package.
o Las excepciones son levantadas con la palabra clave raise [nombre_excepción].
o Un manejador puede el mismo procesar parcialmente una excepción y luego
propagarla a un manejador que esté más arriba ejecutando el enunciado raise
sin un nombre de excepción. Ej.: begin … raise X; end.
o Una excepción puede propagarse fuera de su propio ámbito, aunque a partir
de ahí sólo puede manejarse anónimamente mediante others. Ej.: exception …
when others => raise; end;
o Es posible que una excepción se propague hacia fuera de su ámbito, y luego
vuelva a su ámbito, donde puede ser manejada de nuevo por su nombre.
Cuando se utiliza packages y sus procedures definidos.
o Excepciones con el mismo nombre se enmascaran entre sí.
o Se pueden declarar bloques Declare donde al final puede haber manejadores.
o Hay excepciones predefinidas, estas NO deben declararse.

- Propagación de los errores en CLU:

o Modelo de TERMINACIÓN a nivel de sentencia.
o El proceso que levanta la excepción SIEMPRE termina, aunque tenga
manejadores.
o Las excepciones sólo se pueden alcanzar en procedimientos y han de
colocarse en la cabecera del mismo.
o Hay excepciones predefinidas, que NO deben declararse.
o Se alcanza una excepción explícitamente por medio de la instrucción signal.
o CLU tiene propagación dinámica de UN nivel, es decir que termina el proceso
que levanta la excepción, y busca un llamador inmediato.
o Es decir:
1- Sale dinámicamente (una vez) a buscar el manejador terminado ese
bloque (sentencia).
2- Si NO lo encuentra, busca estáticamente en las sentencias que
contiene esa sentencia, por ejemplo un if o un while.
3- Para volver a propagar dinámicamente se usa resignal.
o Cuando se alcanza un excepción:
1- El procedimiento devuelve el control al llamante inmediato, que es el
responsable de proporcionar el manejador para la excepción
2- Es decir, el procedimiento que alcanza la excepción NO puede ser
reanudado.
3- Cuando se acaba la ejecución del manejador, el control pasa a la
sentencia siguiente a la que está ligado dicho manejador.
4- Si NO hay un manejador asociado a la llamada al proceso, entonces se
busca el manejador en las sentencias que contienen a ese llamado en
forma estática.
 5- Si no encuentra un manejador termina todo en failure.
o El manejador está ligado estrictamente al punto de llamada.
o El manejador se relaciona con la sentencia por medio de la cláusula except.
o Existe un resignal que permite propagar una vez más en forma dinámica la
excepción que se está manejando, solo se puede hacer una sola vez.
o Las excepciones pueden devolver parámetros a sus manejadores, con el
consiguiente ahorro de variables globales.
o CLU no permite mecanismos para inhabilitar excepciones.
o La implementación de CLU asocia cada procedimiento con una tabla de
manejadores.
- Propagación de los errores en PL1:
o Utiliza criterio de REASUNCIÓN.
o Cada vez que se produce la excepción:
1- La maneja el manejador y
2- Devuelve el control a la sentencia siguiente de donde se levantó.
o Los manejadores se ligan dinámicamente con las excepciones. Una excepción
siempre estará ligada con el último manejador definido.
o El alcance de un manejador:
1- Termina cuando finaliza la ejecución de la unidad donde fue
declarado.
2- De una excepción, se acota cuando se define otro manejador para esa
excepción y se restaura cuando se desactivan los manejadores que lo
enmascararon.
o No se permite que se pasen parámetros a los manejadores.
o Provocan programas difíciles de escribir y comprender, y necesidad de
variables globales.
o La excepciones:
1- Son llamadas CONDITIONS
2- Se alcanzan explícitamente: Signal condition (Nombre-excepción)
o Los manejadores
1- Se declaran: ON CONDITION (Nombre-excepción) Manejador.
2- Pueden ser una instrucción o un bloque.
3- Se apilan a medida que se encuentran definidas en el programa, luego
se busca desde la primera posición de la pila.
4- Pueden aparecer en cualquier parte de un bloque.
o El lenguaje PL1, tiene una serie de excepciones ya predefinidas con su
manejador asociado: Built-in exceptions. Por ejemplo zerodivide.
o A las Built-in:
1- Se les puede redefinir los manejadores de la siguiente manera:
 ON Nombre-Built-in Begin … End
2- Se las puede habilitar y deshabilitar explícitamente.
3- Se habilitan por defecto.
4- Se deshabilita anteponiendo NO Nombre de la built-in al bloque,
instrucción o procedimiento al que va a afectar. Ej.: NOZERODIVIDE.
Ejercicio 6

Procedure Manejador;
Begin ... end;

Procedure P(X:Proc);
begin
....
if Error then X;
....
end;

Procedure A;
begin
....
P(Manejador);
….
end;

Este código simula el manejo de excepciones del modelo REASUNCIÓN utilizado por
PL1, ya que ante un error, ejecuta las sentencias definidas y luego sigue su ejecución en la
próxima sentencia.

Para encuadrar con los lenguajes que utilizan el modelo de TERMINACIÓN, se

necesitaría que las sentencias que no se ejecutan para manejar un error se encuentren dentro
de un else, así existirán 2 caminos alternativos: el camino if que ejecute sentencias en caso de
error y un else donde continua la ejecución normal del programa. Así luego del if finaliza la
ejecución del proceso.
Ejercicio 7

Program Principal;
var x:int; b1,b2:boolean;
Procedure P (b1:boolean);
var x:int;
Procedure Manejador1
begin
x:=x + 1; //2
end;
begin
x:=1;
if b1=true then Manejador1;
x:=x+4; //6
end;
Procedure Manejador2;
begin
x:=x * 100; //400
end;
Begin
x:=4;
b:=true;
b1:=false;
if b1=false then Manejador2;
P(b);
write (x); //imprime: 400
End.

a) Implementación en PL/1:

Procedure Main
Var x:int; b1, b2:boolean;

Procedure P (b1:boolean);
Var x:int;
Begin
On condition (verdadero) begin
X:=x+1 //2
end;
X:=1;
If b1=true then signal (verdadero);
X:=x+4; //6
End P
On condition (falso) begin
X:=x*100; //400
end;
x:=4; b:=true; b1:=false
if b1==false then signal (falso);
P(b);
 Write(x) //imprime:400
End Main
b) En ADA:

Procedure Main
x: int; b,b1:boolean;
e:exception;

Procedure A(b1:boolean)
Begin
If(b1==false) then raise e;
Exception
When e Begin
x:=x*100;
End
End A;

Procedure C()
e:exception;
begin
x:=x+1;
raise e;
End C;

Procedure B(b:boolean)
x:int;
Begin
x:=1;
if(b==true) then ProcedureC();
Exception when others Begin
x:=x+4;
End
End B;

Begin
x:=4; b:=true; b1:=false;
A(b1);
B(b);
Write(x);
End Main;
Ejercicio 8

a) Ejecución:
a. Manejadores que ejecuta: (Main) Except tipo1.
b. Valores de variables: z=0 (m=0)

Ejercicio 9

Java:
o Las excepciones son objetos que pueden ser alcanzados y manejados por
manejadores adicionales al bloque donde se produjo la excepción.
o Cada excepcion está representada por una instancia de la clase Throwable o
de una de sus subclases (Error y Exception)
o La gestión de excepciones se lleva a cabo mediante 5 palabras clave: try, catch,
throw, throws, finally.
o Tratamiento:
1- Detectar e informar sobre el error: un método detecta esta condición
anómala que le impide continuar su ejecución y finaliza “lanzando” un
objeto Exception.
2- Recoger el error y tratarlo: captura (try-catch), un método recibe un
objeto Exception y luego se decide actuar en función del tipo de error

Python:
o Su estructura es: Try, Except, Else, Finally.
o Un conjunto de excepcioens pueden ser manejadas por un mismo manejador:
except(exp1, exp2, ..): sentencias.
o Puede aparecer un except SIN nombre de excepción, pero solo al final (actúa
como comodín): except: sentencias.
o Si no se encuentra un manejador en su bloque “try except”:
1- Busca estáticamente.
2- Busca dinámicamente.
3- Si no encuentra se corta el proceso y larga mensaje estándar de error.
4- Levanta excepciones explícitamente con “raise”

Ejercicio 12

- Primer cuadro (7, 6, 1)

- Ultimo cuadro (8)