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

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [gcc/] [ada/] [s-interr-dummy.adb] - Blame information for rev 516

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-2008, AdaCore                     --
--                                                                          --
-- GNARL 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 2,  or (at your option) any later ver- --
-- sion. GNARL 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.  See the GNU General Public License --
-- for  more details.  You should have  received  a copy of the GNU General --
-- Public License  distributed with GNARL; see file COPYING.  If not, write --
-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
-- Boston, MA 02110-1301, USA.                                              --
--                                                                          --
-- As a special exception,  if other files  instantiate  generics from this --
-- unit, or you link  this unit with other files  to produce an executable, --
-- this  unit  does not  by itself cause  the resulting  executable  to  be --
-- covered  by the  GNU  General  Public  License.  This exception does not --
-- however invalidate  any other reasons why  the executable file  might be --
-- covered by the  GNU Public License.                                      --
--                                                                          --
-- 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/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc3/] [gcc/] [ada/] [s-interr-dummy.adb] - Blame information for rev 516

Line No.	Rev	Author	Line
1	281	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-2008, AdaCore --`
11			`-- --`
12			`-- GNARL 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 2, or (at your option) any later ver- --`
15			`-- sion. GNARL 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. See the GNU General Public License --`
18			`-- for more details. You should have received a copy of the GNU General --`
19			`-- Public License distributed with GNARL; see file COPYING. If not, write --`
20			`-- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --`
21			`-- Boston, MA 02110-1301, USA. --`
22			`-- --`
23			`-- As a special exception, if other files instantiate generics from this --`
24			`-- unit, or you link this unit with other files to produce an executable, --`
25			`-- this unit does not by itself cause the resulting executable to be --`
26			`-- covered by the GNU General Public License. This exception does not --`
27			`-- however invalidate any other reasons why the executable file might be --`
28			`-- covered by the GNU Public License. --`
29			`-- --`
30			`-- GNARL was developed by the GNARL team at Florida State University. --`
31			`-- Extensive contributions were provided by Ada Core Technologies, Inc. --`
32			`-- --`
33			`------------------------------------------------------------------------------`
34
35			`-- This version is for systems that do not support interrupts (or signals)`
36
37			`package body System.Interrupts is`
38
39			`pragma Warnings (Off); -- kill warnings on unreferenced formals`
40
41			`use System.Tasking;`
42
43			`-----------------------`
44			`-- Local Subprograms --`
45			`-----------------------`
46
47			`procedure Unimplemented;`
48			`-- This procedure raises a Program_Error with an appropriate message`
49			`-- indicating that an unimplemented feature has been used.`
50
51			`--------------------`
52			`-- Attach_Handler --`
53			`--------------------`
54
55			`procedure Attach_Handler`
56			`(New_Handler : Parameterless_Handler;`
57			`Interrupt : Interrupt_ID;`
58			`Static : Boolean := False)`
59			`is`
60			`begin`
61			`Unimplemented;`
62			`end Attach_Handler;`
63
64			`-----------------------------`
65			`-- Bind_Interrupt_To_Entry --`
66			`-----------------------------`
67
68			`procedure Bind_Interrupt_To_Entry`
69			`(T : Task_Id;`
70			`E : Task_Entry_Index;`
71			`Int_Ref : System.Address)`
72			`is`
73			`begin`
74			`Unimplemented;`
75			`end Bind_Interrupt_To_Entry;`
76
77			`---------------------`
78			`-- Block_Interrupt --`
79			`---------------------`
80
81			`procedure Block_Interrupt (Interrupt : Interrupt_ID) is`
82			`begin`
83			`Unimplemented;`
84			`end Block_Interrupt;`
85
86			`---------------------`
87			`-- Current_Handler --`
88			`---------------------`
89
90			`function Current_Handler`
91			`(Interrupt : Interrupt_ID) return Parameterless_Handler`
92			`is`
93			`begin`
94			`Unimplemented;`
95			`return null;`
96			`end Current_Handler;`
97
98			`--------------------`
99			`-- Detach_Handler --`
100			`--------------------`
101
102			`procedure Detach_Handler`
103			`(Interrupt : Interrupt_ID;`
104			`Static : Boolean := False)`
105			`is`
106			`begin`
107			`Unimplemented;`
108			`end Detach_Handler;`
109
110			`------------------------------`
111			`-- Detach_Interrupt_Entries --`
112			`------------------------------`
113
114			`procedure Detach_Interrupt_Entries (T : Task_Id) is`
115			`begin`
116			`Unimplemented;`
117			`end Detach_Interrupt_Entries;`
118
119			`----------------------`
120			`-- Exchange_Handler --`
121			`----------------------`
122
123			`procedure Exchange_Handler`
124			`(Old_Handler : out Parameterless_Handler;`
125			`New_Handler : Parameterless_Handler;`
126			`Interrupt : Interrupt_ID;`
127			`Static : Boolean := False)`
128			`is`
129			`begin`
130			`Old_Handler := null;`
131			`Unimplemented;`
132			`end Exchange_Handler;`
133
134			`--------------`
135			`-- Finalize --`
136			`--------------`
137
138			`procedure Finalize (Object : in out Static_Interrupt_Protection) is`
139			`begin`
140			`Unimplemented;`
141			`end Finalize;`
142
143			`-------------------------------------`
144			`-- Has_Interrupt_Or_Attach_Handler --`
145			`-------------------------------------`
146
147			`function Has_Interrupt_Or_Attach_Handler`
148			`(Object : access Dynamic_Interrupt_Protection)`
149			`return Boolean`
150			`is`
151			`pragma Warnings (Off, Object);`
152			`begin`
153			`Unimplemented;`
154			`return True;`
155			`end Has_Interrupt_Or_Attach_Handler;`
156
157			`function Has_Interrupt_Or_Attach_Handler`
158			`(Object : access Static_Interrupt_Protection)`
159			`return Boolean`
160			`is`
161			`pragma Warnings (Off, Object);`
162			`begin`
163			`Unimplemented;`
164			`return True;`
165			`end Has_Interrupt_Or_Attach_Handler;`
166
167			`----------------------`
168			`-- Ignore_Interrupt --`
169			`----------------------`
170
171			`procedure Ignore_Interrupt (Interrupt : Interrupt_ID) is`
172			`begin`
173			`Unimplemented;`
174			`end Ignore_Interrupt;`
175
176			`----------------------`
177			`-- Install_Handlers --`
178			`----------------------`
179
180			`procedure Install_Handlers`
181			`(Object : access Static_Interrupt_Protection;`
182			`New_Handlers : New_Handler_Array)`
183			`is`
184			`begin`
185			`Unimplemented;`
186			`end Install_Handlers;`
187
188			`---------------------------------`
189			`-- Install_Restricted_Handlers --`
190			`---------------------------------`
191
192			`procedure Install_Restricted_Handlers (Handlers : New_Handler_Array) is`
193			`begin`
194			`Unimplemented;`
195			`end Install_Restricted_Handlers;`
196
197			`----------------`
198			`-- Is_Blocked --`
199			`----------------`
200
201			`function Is_Blocked (Interrupt : Interrupt_ID) return Boolean is`
202			`begin`
203			`Unimplemented;`
204			`return True;`
205			`end Is_Blocked;`
206
207			`-----------------------`
208			`-- Is_Entry_Attached --`
209			`-----------------------`
210
211			`function Is_Entry_Attached (Interrupt : Interrupt_ID) return Boolean is`
212			`begin`
213			`Unimplemented;`
214			`return True;`
215			`end Is_Entry_Attached;`
216
217			`-------------------------`
218			`-- Is_Handler_Attached --`
219			`-------------------------`
220
221			`function Is_Handler_Attached (Interrupt : Interrupt_ID) return Boolean is`
222			`begin`
223			`Unimplemented;`
224			`return True;`
225			`end Is_Handler_Attached;`
226
227			`----------------`
228			`-- Is_Ignored --`
229			`----------------`
230
231			`function Is_Ignored (Interrupt : Interrupt_ID) return Boolean is`
232			`begin`
233			`Unimplemented;`
234			`return True;`
235			`end Is_Ignored;`
236
237			`-----------------`
238			`-- Is_Reserved --`
239			`-----------------`
240
241			`function Is_Reserved (Interrupt : Interrupt_ID) return Boolean is`
242			`begin`
243			`Unimplemented;`
244			`return True;`
245			`end Is_Reserved;`
246
247			`---------------`
248			`-- Reference --`
249			`---------------`
250
251			`function Reference (Interrupt : Interrupt_ID) return System.Address is`
252			`begin`
253			`Unimplemented;`
254			`return Interrupt'Address;`
255			`end Reference;`
256
257			`--------------------------------`
258			`-- Register_Interrupt_Handler --`
259			`--------------------------------`
260
261			`procedure Register_Interrupt_Handler`
262			`(Handler_Addr : System.Address)`
263			`is`
264			`begin`
265			`Unimplemented;`
266			`end Register_Interrupt_Handler;`
267
268			`-----------------------`
269			`-- Unblock_Interrupt --`
270			`-----------------------`
271
272			`procedure Unblock_Interrupt (Interrupt : Interrupt_ID) is`
273			`begin`
274			`Unimplemented;`
275			`end Unblock_Interrupt;`
276
277			`------------------`
278			`-- Unblocked_By --`
279			`------------------`
280
281			`function Unblocked_By (Interrupt : Interrupt_ID)`
282			`return System.Tasking.Task_Id is`
283			`begin`
284			`Unimplemented;`
285			`return null;`
286			`end Unblocked_By;`
287
288			`------------------------`
289			`-- Unignore_Interrupt --`
290			`------------------------`
291
292			`procedure Unignore_Interrupt (Interrupt : Interrupt_ID) is`
293			`begin`
294			`Unimplemented;`
295			`end Unignore_Interrupt;`
296
297			`-------------------`
298			`-- Unimplemented; --`
299			`-------------------`
300
301			`procedure Unimplemented is`
302			`begin`
303			`raise Program_Error with "interrupts/signals not implemented";`
304			`end Unimplemented;`
305
306			`end System.Interrupts;`