Signal handler blocks proteced type

[Lutz Donnerhacke <lutz@iks-jena.de>]

The following test program shows a strange behavior:

A protected type with a signal handler is instantiated in order to catch a
signal. If the signal is not catched, everything works fine. If the signal
was delivered, the inner scope will not be terminated, because the protected
type can not be finalized.

Why?

Ok, there is a zombie afterwards.
\f
with Ada.Text_IO;  use Ada.Text_IO;
with Ints;

procedure t is
begin
   Put_Line("Enviroment started.");
   declare
      i : Ints.Int;
   begin
      Put_Line("Waiting.");
      delay 2.0;
      if i.Found then
         Put_Line("Catched.");
      else
         Put_Line("Nothing.");
      end if;
   end;
   Put_Line("Enviroment stopped.");
end t;
\f
Example:
$ ./t
Enviroment started.
Waiting.
Nothing.
Enviroment stopped.

$ ./t & sleep 1; kill -1 %1; sleep 3
[1] 2366
Enviroment started.
Waiting.
Catched.
$ jobs
[1]+  Running                 ./t &
$ pstree
     |-sh-+-pstree
     |    `-t---(t)

\f
with Ada.Interrupts.Names;   use Ada.Interrupts.Names;

package Ints is
   protected type Int is
      procedure Signal;
      pragma Attach_Handler(Signal, SIGHUP);
      procedure Reset;
      function Found return Boolean;
   private
      catched : Boolean := False;
   end Int;
end Ints;
\f
package body Ints is
   protected body Int is
      procedure Signal is
      begin
	 catched := True;   
      end Signal;
      
      procedure Reset is
      begin
	 catched := False;   
      end Reset;
      
      function Found return Boolean is
      begin
	 return catched;   
      end Found;
   end Int;
end Ints;