URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [s-interr-dummy.adb] - Blame information for rev 713

Go to most recent revision | Details | Compare with Previous | View Log


------------------------------------------------------------------------------
--                                                                          --
--                  GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS                --
--                                                                          --
--                     S Y S T E M . I N T E R R U P T S                    --
--                                                                          --
--                                  B o d y                                 --
--                                                                          --
--             Copyright (C) 1991-1994, Florida State University            --
--                     Copyright (C) 1995-2010, AdaCore                     --
--                                                                          --
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
-- terms of the  GNU General Public License as published  by the Free Soft- --
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
--                                                                          --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception,   --
-- version 3.1, as published by the Free Software Foundation.               --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
-- GNARL was developed by the GNARL team at Florida State University.       --
-- Extensive contributions were provided by Ada Core Technologies, Inc.     --
--                                                                          --
------------------------------------------------------------------------------
 
--  This version is for systems that do not support interrupts (or signals)
 
package body System.Interrupts is
 
   pragma Warnings (Off); -- kill warnings on unreferenced formals
 
   use System.Tasking;
 
   -----------------------
   -- Local Subprograms --
   -----------------------
 
   procedure Unimplemented;
   --  This procedure raises a Program_Error with an appropriate message
   --  indicating that an unimplemented feature has been used.
 
   --------------------
   -- Attach_Handler --
   --------------------
 
   procedure Attach_Handler
     (New_Handler : Parameterless_Handler;
      Interrupt   : Interrupt_ID;
      Static      : Boolean := False)
   is
   begin
      Unimplemented;
   end Attach_Handler;
 
   -----------------------------
   -- Bind_Interrupt_To_Entry --
   -----------------------------
 
   procedure Bind_Interrupt_To_Entry
     (T       : Task_Id;
      E       : Task_Entry_Index;
      Int_Ref : System.Address)
   is
   begin
      Unimplemented;
   end Bind_Interrupt_To_Entry;
 
   ---------------------
   -- Block_Interrupt --
   ---------------------
 
   procedure Block_Interrupt (Interrupt : Interrupt_ID) is
   begin
      Unimplemented;
   end Block_Interrupt;
 
   ---------------------
   -- Current_Handler --
   ---------------------
 
   function Current_Handler
     (Interrupt : Interrupt_ID) return Parameterless_Handler
   is
   begin
      Unimplemented;
      return null;
   end Current_Handler;
 
   --------------------
   -- Detach_Handler --
   --------------------
 
   procedure Detach_Handler
     (Interrupt : Interrupt_ID;
      Static    : Boolean := False)
   is
   begin
      Unimplemented;
   end Detach_Handler;
 
   ------------------------------
   -- Detach_Interrupt_Entries --
   ------------------------------
 
   procedure Detach_Interrupt_Entries (T : Task_Id) is
   begin
      Unimplemented;
   end Detach_Interrupt_Entries;
 
   ----------------------
   -- Exchange_Handler --
   ----------------------
 
   procedure Exchange_Handler
     (Old_Handler : out Parameterless_Handler;
      New_Handler : Parameterless_Handler;
      Interrupt   : Interrupt_ID;
      Static      : Boolean := False)
   is
   begin
      Old_Handler := null;
      Unimplemented;
   end Exchange_Handler;
 
   --------------
   -- Finalize --
   --------------
 
   procedure Finalize (Object : in out Static_Interrupt_Protection) is
   begin
      Unimplemented;
   end Finalize;
 
   -------------------------------------
   -- Has_Interrupt_Or_Attach_Handler --
   -------------------------------------
 
   function Has_Interrupt_Or_Attach_Handler
     (Object : access Dynamic_Interrupt_Protection)
      return   Boolean
   is
      pragma Warnings (Off, Object);
   begin
      Unimplemented;
      return True;
   end Has_Interrupt_Or_Attach_Handler;
 
   function Has_Interrupt_Or_Attach_Handler
     (Object : access Static_Interrupt_Protection)
      return   Boolean
   is
      pragma Warnings (Off, Object);
   begin
      Unimplemented;
      return True;
   end Has_Interrupt_Or_Attach_Handler;
 
   ----------------------
   -- Ignore_Interrupt --
   ----------------------
 
   procedure Ignore_Interrupt (Interrupt : Interrupt_ID) is
   begin
      Unimplemented;
   end Ignore_Interrupt;
 
   ----------------------
   -- Install_Handlers --
   ----------------------
 
   procedure Install_Handlers
     (Object       : access Static_Interrupt_Protection;
      New_Handlers : New_Handler_Array)
   is
   begin
      Unimplemented;
   end Install_Handlers;
 
   ---------------------------------
   -- Install_Restricted_Handlers --
   ---------------------------------
 
   procedure Install_Restricted_Handlers (Handlers : New_Handler_Array) is
   begin
      Unimplemented;
   end Install_Restricted_Handlers;
 
   ----------------
   -- Is_Blocked --
   ----------------
 
   function Is_Blocked (Interrupt : Interrupt_ID) return Boolean is
   begin
      Unimplemented;
      return True;
   end Is_Blocked;
 
   -----------------------
   -- Is_Entry_Attached --
   -----------------------
 
   function Is_Entry_Attached (Interrupt : Interrupt_ID) return Boolean is
   begin
      Unimplemented;
      return True;
   end Is_Entry_Attached;
 
   -------------------------
   -- Is_Handler_Attached --
   -------------------------
 
   function Is_Handler_Attached (Interrupt : Interrupt_ID) return Boolean is
   begin
      Unimplemented;
      return True;
   end Is_Handler_Attached;
 
   ----------------
   -- Is_Ignored --
   ----------------
 
   function Is_Ignored (Interrupt : Interrupt_ID) return Boolean is
   begin
      Unimplemented;
      return True;
   end Is_Ignored;
 
   -----------------
   -- Is_Reserved --
   -----------------
 
   function Is_Reserved (Interrupt : Interrupt_ID) return Boolean is
   begin
      Unimplemented;
      return True;
   end Is_Reserved;
 
   ---------------
   -- Reference --
   ---------------
 
   function Reference (Interrupt : Interrupt_ID) return System.Address is
   begin
      Unimplemented;
      return Interrupt'Address;
   end Reference;
 
   --------------------------------
   -- Register_Interrupt_Handler --
   --------------------------------
 
   procedure Register_Interrupt_Handler
     (Handler_Addr : System.Address)
   is
   begin
      Unimplemented;
   end Register_Interrupt_Handler;
 
   -----------------------
   -- Unblock_Interrupt --
   -----------------------
 
   procedure Unblock_Interrupt (Interrupt : Interrupt_ID) is
   begin
      Unimplemented;
   end Unblock_Interrupt;
 
   ------------------
   -- Unblocked_By --
   ------------------
 
   function Unblocked_By (Interrupt : Interrupt_ID)
     return System.Tasking.Task_Id is
   begin
      Unimplemented;
      return null;
   end Unblocked_By;
 
   ------------------------
   -- Unignore_Interrupt --
   ------------------------
 
   procedure Unignore_Interrupt (Interrupt : Interrupt_ID) is
   begin
      Unimplemented;
   end Unignore_Interrupt;
 
   -------------------
   -- Unimplemented; --
   -------------------
 
   procedure Unimplemented is
   begin
      raise Program_Error with "interrupts/signals not implemented";
   end Unimplemented;
 
end System.Interrupts;

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [s-interr-dummy.adb] - Blame information for rev 713

Line No.	Rev	Author	Line
1	706	jeremybenn	`------------------------------------------------------------------------------`
2			`-- --`
3			`-- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --`
4			`-- --`
5			`-- S Y S T E M . I N T E R R U P T S --`
6			`-- --`
7			`-- B o d y --`
8			`-- --`
9			`-- Copyright (C) 1991-1994, Florida State University --`
10			`-- Copyright (C) 1995-2010, AdaCore --`
11			`-- --`
12			`-- GNAT is free software; you can redistribute it and/or modify it under --`
13			`-- terms of the GNU General Public License as published by the Free Soft- --`
14			`-- ware Foundation; either version 3, or (at your option) any later ver- --`
15			`-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --`
16			`-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --`
17			`-- or FITNESS FOR A PARTICULAR PURPOSE. --`
18			`-- --`
19			`-- As a special exception under Section 7 of GPL version 3, you are granted --`
20			`-- additional permissions described in the GCC Runtime Library Exception, --`
21			`-- version 3.1, as published by the Free Software Foundation. --`
22			`-- --`
23			`-- You should have received a copy of the GNU General Public License and --`
24			`-- a copy of the GCC Runtime Library Exception along with this program; --`
25			`-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --`
26			`-- <http://www.gnu.org/licenses/>. --`
27			`-- --`
28			`-- GNARL was developed by the GNARL team at Florida State University. --`
29			`-- Extensive contributions were provided by Ada Core Technologies, Inc. --`
30			`-- --`
31			`------------------------------------------------------------------------------`
32
33			`-- This version is for systems that do not support interrupts (or signals)`
34
35			`package body System.Interrupts is`
36
37			`pragma Warnings (Off); -- kill warnings on unreferenced formals`
38
39			`use System.Tasking;`
40
41			`-----------------------`
42			`-- Local Subprograms --`
43			`-----------------------`
44
45			`procedure Unimplemented;`
46			`-- This procedure raises a Program_Error with an appropriate message`
47			`-- indicating that an unimplemented feature has been used.`
48
49			`--------------------`
50			`-- Attach_Handler --`
51			`--------------------`
52
53			`procedure Attach_Handler`
54			`(New_Handler : Parameterless_Handler;`
55			`Interrupt : Interrupt_ID;`
56			`Static : Boolean := False)`
57			`is`
58			`begin`
59			`Unimplemented;`
60			`end Attach_Handler;`
61
62			`-----------------------------`
63			`-- Bind_Interrupt_To_Entry --`
64			`-----------------------------`
65
66			`procedure Bind_Interrupt_To_Entry`
67			`(T : Task_Id;`
68			`E : Task_Entry_Index;`
69			`Int_Ref : System.Address)`
70			`is`
71			`begin`
72			`Unimplemented;`
73			`end Bind_Interrupt_To_Entry;`
74
75			`---------------------`
76			`-- Block_Interrupt --`
77			`---------------------`
78
79			`procedure Block_Interrupt (Interrupt : Interrupt_ID) is`
80			`begin`
81			`Unimplemented;`
82			`end Block_Interrupt;`
83
84			`---------------------`
85			`-- Current_Handler --`
86			`---------------------`
87
88			`function Current_Handler`
89			`(Interrupt : Interrupt_ID) return Parameterless_Handler`
90			`is`
91			`begin`
92			`Unimplemented;`
93			`return null;`
94			`end Current_Handler;`
95
96			`--------------------`
97			`-- Detach_Handler --`
98			`--------------------`
99
100			`procedure Detach_Handler`
101			`(Interrupt : Interrupt_ID;`
102			`Static : Boolean := False)`
103			`is`
104			`begin`
105			`Unimplemented;`
106			`end Detach_Handler;`
107
108			`------------------------------`
109			`-- Detach_Interrupt_Entries --`
110			`------------------------------`
111
112			`procedure Detach_Interrupt_Entries (T : Task_Id) is`
113			`begin`
114			`Unimplemented;`
115			`end Detach_Interrupt_Entries;`
116
117			`----------------------`
118			`-- Exchange_Handler --`
119			`----------------------`
120
121			`procedure Exchange_Handler`
122			`(Old_Handler : out Parameterless_Handler;`
123			`New_Handler : Parameterless_Handler;`
124			`Interrupt : Interrupt_ID;`
125			`Static : Boolean := False)`
126			`is`
127			`begin`
128			`Old_Handler := null;`
129			`Unimplemented;`
130			`end Exchange_Handler;`
131
132			`--------------`
133			`-- Finalize --`
134			`--------------`
135
136			`procedure Finalize (Object : in out Static_Interrupt_Protection) is`
137			`begin`
138			`Unimplemented;`
139			`end Finalize;`
140
141			`-------------------------------------`
142			`-- Has_Interrupt_Or_Attach_Handler --`
143			`-------------------------------------`
144
145			`function Has_Interrupt_Or_Attach_Handler`
146			`(Object : access Dynamic_Interrupt_Protection)`
147			`return Boolean`
148			`is`
149			`pragma Warnings (Off, Object);`
150			`begin`
151			`Unimplemented;`
152			`return True;`
153			`end Has_Interrupt_Or_Attach_Handler;`
154
155			`function Has_Interrupt_Or_Attach_Handler`
156			`(Object : access Static_Interrupt_Protection)`
157			`return Boolean`
158			`is`
159			`pragma Warnings (Off, Object);`
160			`begin`
161			`Unimplemented;`
162			`return True;`
163			`end Has_Interrupt_Or_Attach_Handler;`
164
165			`----------------------`
166			`-- Ignore_Interrupt --`
167			`----------------------`
168
169			`procedure Ignore_Interrupt (Interrupt : Interrupt_ID) is`
170			`begin`
171			`Unimplemented;`
172			`end Ignore_Interrupt;`
173
174			`----------------------`
175			`-- Install_Handlers --`
176			`----------------------`
177
178			`procedure Install_Handlers`
179			`(Object : access Static_Interrupt_Protection;`
180			`New_Handlers : New_Handler_Array)`
181			`is`
182			`begin`
183			`Unimplemented;`
184			`end Install_Handlers;`
185
186			`---------------------------------`
187			`-- Install_Restricted_Handlers --`
188			`---------------------------------`
189
190			`procedure Install_Restricted_Handlers (Handlers : New_Handler_Array) is`
191			`begin`
192			`Unimplemented;`
193			`end Install_Restricted_Handlers;`
194
195			`----------------`
196			`-- Is_Blocked --`
197			`----------------`
198
199			`function Is_Blocked (Interrupt : Interrupt_ID) return Boolean is`
200			`begin`
201			`Unimplemented;`
202			`return True;`
203			`end Is_Blocked;`
204
205			`-----------------------`
206			`-- Is_Entry_Attached --`
207			`-----------------------`
208
209			`function Is_Entry_Attached (Interrupt : Interrupt_ID) return Boolean is`
210			`begin`
211			`Unimplemented;`
212			`return True;`
213			`end Is_Entry_Attached;`
214
215			`-------------------------`
216			`-- Is_Handler_Attached --`
217			`-------------------------`
218
219			`function Is_Handler_Attached (Interrupt : Interrupt_ID) return Boolean is`
220			`begin`
221			`Unimplemented;`
222			`return True;`
223			`end Is_Handler_Attached;`
224
225			`----------------`
226			`-- Is_Ignored --`
227			`----------------`
228
229			`function Is_Ignored (Interrupt : Interrupt_ID) return Boolean is`
230			`begin`
231			`Unimplemented;`
232			`return True;`
233			`end Is_Ignored;`
234
235			`-----------------`
236			`-- Is_Reserved --`
237			`-----------------`
238
239			`function Is_Reserved (Interrupt : Interrupt_ID) return Boolean is`
240			`begin`
241			`Unimplemented;`
242			`return True;`
243			`end Is_Reserved;`
244
245			`---------------`
246			`-- Reference --`
247			`---------------`
248
249			`function Reference (Interrupt : Interrupt_ID) return System.Address is`
250			`begin`
251			`Unimplemented;`
252			`return Interrupt'Address;`
253			`end Reference;`
254
255			`--------------------------------`
256			`-- Register_Interrupt_Handler --`
257			`--------------------------------`
258
259			`procedure Register_Interrupt_Handler`
260			`(Handler_Addr : System.Address)`
261			`is`
262			`begin`
263			`Unimplemented;`
264			`end Register_Interrupt_Handler;`
265
266			`-----------------------`
267			`-- Unblock_Interrupt --`
268			`-----------------------`
269
270			`procedure Unblock_Interrupt (Interrupt : Interrupt_ID) is`
271			`begin`
272			`Unimplemented;`
273			`end Unblock_Interrupt;`
274
275			`------------------`
276			`-- Unblocked_By --`
277			`------------------`
278
279			`function Unblocked_By (Interrupt : Interrupt_ID)`
280			`return System.Tasking.Task_Id is`
281			`begin`
282			`Unimplemented;`
283			`return null;`
284			`end Unblocked_By;`
285
286			`------------------------`
287			`-- Unignore_Interrupt --`
288			`------------------------`
289
290			`procedure Unignore_Interrupt (Interrupt : Interrupt_ID) is`
291			`begin`
292			`Unimplemented;`
293			`end Unignore_Interrupt;`
294
295			`-------------------`
296			`-- Unimplemented; --`
297			`-------------------`
298
299			`procedure Unimplemented is`
300			`begin`
301			`raise Program_Error with "interrupts/signals not implemented";`
302			`end Unimplemented;`
303
304			`end System.Interrupts;`