aboutsummaryrefslogtreecommitdiff
blob: fe76d1871e7c6a00f8abe3f7f242c24290403ecb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
--  Copyright 2009-2016 Free Software Foundation, Inc.
--
--  This program is free software; you can redistribute it and/or modify
--  it under the terms of the GNU General Public License as published by
--  the Free Software Foundation; either version 3 of the License, or
--  (at your option) any later version.
--
--  This program is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--  GNU General Public License for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with this program.  If not, see <http://www.gnu.org/licenses/>.

procedure Foo is

   task type Caller is
      entry Initialize;
      entry Call_Break_Me;
      entry Finalize;
   end Caller;
   type Caller_Ptr is access Caller;

   procedure Break_Me is
   begin
      null;
   end Break_Me;

   task body Caller is
   begin
      accept Initialize do
         null;
      end Initialize;
      accept Call_Break_Me do
         Break_Me;
      end Call_Break_Me;
      accept Finalize do
         null;
      end Finalize;
   end Caller;

   Task_List : array (1 .. 3) of Caller_Ptr;

begin

   --  Start all our tasks, and call the "Initialize" entry to make
   --  sure all of them have now been started.  We call that entry
   --  immediately after having created the task in order to make sure
   --  that we wait for that task to be created before we try to create
   --  another one.  That way, we know that the order in our Task_List
   --  corresponds to the order in the GNAT runtime.
   for J in Task_List'Range loop
      Task_List (J) := new Caller;
      Task_List (J).Initialize;
   end loop;

   --  Next, call their Call_Break_Me entry of each task, using the same
   --  order as the order used to create them.
   for J in Task_List'Range loop  -- STOP_HERE
      Task_List (J).Call_Break_Me;
   end loop;

   --  And finally, let all the tasks die...
   for J in Task_List'Range loop
      Task_List (J).Finalize;
   end loop;
end Foo;