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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [aspects.ads] - Blame information for rev 706

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                              A S P E C T S                               --
6
--                                                                          --
7
--                                 S p e c                                  --
8
--                                                                          --
9
--          Copyright (C) 2010-2012, Free Software Foundation, Inc.         --
10
--                                                                          --
11
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
12
-- terms of the  GNU General Public License as published  by the Free Soft- --
13
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
14
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
15
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
16
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
17
--                                                                          --
18
-- As a special exception under Section 7 of GPL version 3, you are granted --
19
-- additional permissions described in the GCC Runtime Library Exception,   --
20
-- version 3.1, as published by the Free Software Foundation.               --
21
--                                                                          --
22
-- You should have received a copy of the GNU General Public License and    --
23
-- a copy of the GCC Runtime Library Exception along with this program;     --
24
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
25
-- <http://www.gnu.org/licenses/>.                                          --
26
--                                                                          --
27
-- GNAT was originally developed  by the GNAT team at  New York University. --
28
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
29
--                                                                          --
30
------------------------------------------------------------------------------
31
 
32
--  This package defines the aspects that are recognized by GNAT in aspect
33
--  specifications. It also contains the subprograms for storing/retrieving
34
--  aspect specifications from the tree. The semantic processing for aspect
35
--  specifications is found in Sem_Ch13.Analyze_Aspect_Specifications.
36
 
37
with Namet;  use Namet;
38
with Snames; use Snames;
39
with Types;  use Types;
40
 
41
package Aspects is
42
 
43
   --  Type defining recognized aspects
44
 
45
   type Aspect_Id is
46
     (No_Aspect,                            -- Dummy entry for no aspect
47
      Aspect_Address,
48
      Aspect_Alignment,
49
      Aspect_Attach_Handler,
50
      Aspect_Bit_Order,
51
      Aspect_Component_Size,
52
      Aspect_Constant_Indexing,
53
      Aspect_CPU,
54
      Aspect_Default_Component_Value,
55
      Aspect_Default_Iterator,
56
      Aspect_Default_Value,
57
      Aspect_Dimension,                     -- GNAT
58
      Aspect_Dimension_System,              -- GNAT
59
      Aspect_Dispatching_Domain,
60
      Aspect_Dynamic_Predicate,
61
      Aspect_External_Tag,
62
      Aspect_Implicit_Dereference,
63
      Aspect_Input,
64
      Aspect_Interrupt_Priority,
65
      Aspect_Invariant,
66
      Aspect_Iterator_Element,
67
      Aspect_Machine_Radix,
68
      Aspect_Object_Size,                   -- GNAT
69
      Aspect_Output,
70
      Aspect_Post,
71
      Aspect_Postcondition,
72
      Aspect_Pre,
73
      Aspect_Precondition,
74
      Aspect_Predicate,                     -- GNAT
75
      Aspect_Priority,
76
      Aspect_Read,
77
      Aspect_Simple_Storage_Pool,           -- GNAT
78
      Aspect_Size,
79
      Aspect_Small,
80
      Aspect_Static_Predicate,
81
      Aspect_Storage_Pool,
82
      Aspect_Storage_Size,
83
      Aspect_Stream_Size,
84
      Aspect_Suppress,
85
      Aspect_Synchronization,
86
      Aspect_Test_Case,                     -- GNAT
87
      Aspect_Type_Invariant,
88
      Aspect_Unsuppress,
89
      Aspect_Value_Size,                    -- GNAT
90
      Aspect_Variable_Indexing,
91
      Aspect_Warnings,
92
      Aspect_Write,
93
 
94
      --  The following aspects correspond to library unit pragmas
95
 
96
      Aspect_All_Calls_Remote,
97
      Aspect_Compiler_Unit,                 -- GNAT
98
      Aspect_Elaborate_Body,
99
      Aspect_Preelaborate,
100
      Aspect_Preelaborate_05,               -- GNAT
101
      Aspect_Pure,
102
      Aspect_Pure_05,                       -- GNAT
103
      Aspect_Pure_12,                       -- GNAT
104
      Aspect_Remote_Call_Interface,
105
      Aspect_Remote_Types,
106
      Aspect_Shared_Passive,
107
      Aspect_Universal_Data,                -- GNAT
108
 
109
      --  Remaining aspects have a static boolean value that turns the aspect
110
      --  on or off. They all correspond to pragmas, but are only converted to
111
      --  the pragmas where the value is True. A value of False normally means
112
      --  that the aspect is ignored, except in the case of derived types where
113
      --  the aspect value is inherited from the parent, in which case, we do
114
      --  not allow False if we inherit a True value from the parent.
115
 
116
      Aspect_Ada_2005,                      -- GNAT
117
      Aspect_Ada_2012,                      -- GNAT
118
      Aspect_Asynchronous,
119
      Aspect_Atomic,
120
      Aspect_Atomic_Components,
121
      Aspect_Discard_Names,
122
      Aspect_Favor_Top_Level,               -- GNAT
123
      Aspect_Independent,
124
      Aspect_Independent_Components,
125
      Aspect_Inline,
126
      Aspect_Inline_Always,                 -- GNAT
127
      Aspect_Interrupt_Handler,
128
      Aspect_No_Return,
129
      Aspect_Pack,
130
      Aspect_Persistent_BSS,                -- GNAT
131
      Aspect_Preelaborable_Initialization,
132
      Aspect_Pure_Function,                 -- GNAT
133
      Aspect_Remote_Access_Type,            -- GNAT
134
      Aspect_Shared,                        -- GNAT (equivalent to Atomic)
135
      Aspect_Simple_Storage_Pool_Type,      -- GNAT
136
      Aspect_Suppress_Debug_Info,           -- GNAT
137
      Aspect_Unchecked_Union,
138
      Aspect_Universal_Aliasing,            -- GNAT
139
      Aspect_Unmodified,                    -- GNAT
140
      Aspect_Unreferenced,                  -- GNAT
141
      Aspect_Unreferenced_Objects,          -- GNAT
142
      Aspect_Volatile,
143
      Aspect_Volatile_Components);
144
 
145
   --  The following array indicates aspects that accept 'Class
146
 
147
   Class_Aspect_OK : constant array (Aspect_Id) of Boolean :=
148
                       (Aspect_Invariant     => True,
149
                        Aspect_Pre           => True,
150
                        Aspect_Predicate     => True,
151
                        Aspect_Post          => True,
152
                        others               => False);
153
 
154
   --  The following array indicates aspects that a subtype inherits from
155
   --  its base type. True means that the subtype inherits the aspect from
156
   --  its base type. False means it is not inherited.
157
 
158
   Base_Aspect : constant array (Aspect_Id) of Boolean :=
159
                   (Aspect_Atomic                  => True,
160
                    Aspect_Atomic_Components       => True,
161
                    Aspect_Discard_Names           => True,
162
                    Aspect_Independent_Components  => True,
163
                    Aspect_Iterator_Element        => True,
164
                    Aspect_Constant_Indexing       => True,
165
                    Aspect_Default_Iterator        => True,
166
                    Aspect_Type_Invariant          => True,
167
                    Aspect_Unchecked_Union         => True,
168
                    Aspect_Variable_Indexing       => True,
169
                    Aspect_Volatile                => True,
170
                    others                         => False);
171
 
172
   --  The following array identifies all implementation defined aspects
173
 
174
   Impl_Defined_Aspects : constant array (Aspect_Id) of Boolean :=
175
                            (Aspect_Ada_2005                 => True,
176
                             Aspect_Ada_2012                 => True,
177
                             Aspect_Compiler_Unit            => True,
178
                             Aspect_Dimension                => True,
179
                             Aspect_Dimension_System         => True,
180
                             Aspect_Favor_Top_Level          => True,
181
                             Aspect_Inline_Always            => True,
182
                             Aspect_Object_Size              => True,
183
                             Aspect_Persistent_BSS           => True,
184
                             Aspect_Predicate                => True,
185
                             Aspect_Preelaborate_05          => True,
186
                             Aspect_Pure_05                  => True,
187
                             Aspect_Pure_12                  => True,
188
                             Aspect_Pure_Function            => True,
189
                             Aspect_Remote_Access_Type       => True,
190
                             Aspect_Shared                   => True,
191
                             Aspect_Simple_Storage_Pool      => True,
192
                             Aspect_Simple_Storage_Pool_Type => True,
193
                             Aspect_Suppress_Debug_Info      => True,
194
                             Aspect_Test_Case                => True,
195
                             Aspect_Universal_Data           => True,
196
                             Aspect_Universal_Aliasing       => True,
197
                             Aspect_Unmodified               => True,
198
                             Aspect_Unreferenced             => True,
199
                             Aspect_Unreferenced_Objects     => True,
200
                             Aspect_Value_Size               => True,
201
                             others                          => False);
202
 
203
   --  The following array indicates aspects for which multiple occurrences of
204
   --  the same aspect attached to the same declaration are allowed.
205
 
206
   No_Duplicates_Allowed : constant array (Aspect_Id) of Boolean :=
207
                             (Aspect_Test_Case => False,
208
                              others           => True);
209
 
210
   --  The following array indicates type aspects that are inherited and apply
211
   --  to the class-wide type as well.
212
 
213
   Inherited_Aspect : constant array (Aspect_Id) of Boolean :=
214
                        (Aspect_Constant_Indexing    => True,
215
                         Aspect_Default_Iterator     => True,
216
                         Aspect_Implicit_Dereference => True,
217
                         Aspect_Iterator_Element     => True,
218
                         Aspect_Remote_Types         => True,
219
                         Aspect_Variable_Indexing    => True,
220
                         others                      => False);
221
 
222
   --  The following subtype defines aspects corresponding to library unit
223
   --  pragmas, these can only validly appear as aspects for library units,
224
   --  and result in a corresponding pragma being inserted immediately after
225
   --  the occurrence of the aspect.
226
 
227
   subtype Library_Unit_Aspects is
228
     Aspect_Id range Aspect_All_Calls_Remote .. Aspect_Universal_Data;
229
 
230
   --  The following subtype defines aspects accepting an optional static
231
   --  boolean parameter indicating if the aspect should be active or
232
   --  cancelling. If the parameter is missing the effective value is True,
233
   --  enabling the aspect. If the parameter is present it must be a static
234
   --  expression of type Standard.Boolean. If the value is True, then the
235
   --  aspect is enabled. If it is False, the aspect is disabled.
236
 
237
   subtype Boolean_Aspects is
238
     Aspect_Id range Aspect_Ada_2005 .. Aspect_Id'Last;
239
 
240
   subtype Pre_Post_Aspects is
241
     Aspect_Id range Aspect_Post .. Aspect_Precondition;
242
 
243
   --  The following type is used for indicating allowed expression forms
244
 
245
   type Aspect_Expression is
246
     (Optional,               -- Optional boolean expression
247
      Expression,             -- Required expression
248
      Name);                  -- Required name
249
 
250
   --  The following array indicates what argument type is required
251
 
252
   Aspect_Argument : constant array (Aspect_Id) of Aspect_Expression :=
253
                       (No_Aspect                      => Optional,
254
                        Aspect_Address                 => Expression,
255
                        Aspect_Alignment               => Expression,
256
                        Aspect_Attach_Handler          => Expression,
257
                        Aspect_Bit_Order               => Expression,
258
                        Aspect_Component_Size          => Expression,
259
                        Aspect_Constant_Indexing       => Name,
260
                        Aspect_CPU                     => Expression,
261
                        Aspect_Default_Component_Value => Expression,
262
                        Aspect_Default_Iterator        => Name,
263
                        Aspect_Default_Value           => Expression,
264
                        Aspect_Dimension               => Expression,
265
                        Aspect_Dimension_System        => Expression,
266
                        Aspect_Dispatching_Domain      => Expression,
267
                        Aspect_Dynamic_Predicate       => Expression,
268
                        Aspect_External_Tag            => Expression,
269
                        Aspect_Implicit_Dereference    => Name,
270
                        Aspect_Input                   => Name,
271
                        Aspect_Interrupt_Priority      => Expression,
272
                        Aspect_Invariant               => Expression,
273
                        Aspect_Iterator_Element        => Name,
274
                        Aspect_Machine_Radix           => Expression,
275
                        Aspect_Object_Size             => Expression,
276
                        Aspect_Output                  => Name,
277
                        Aspect_Post                    => Expression,
278
                        Aspect_Postcondition           => Expression,
279
                        Aspect_Pre                     => Expression,
280
                        Aspect_Precondition            => Expression,
281
                        Aspect_Predicate               => Expression,
282
                        Aspect_Priority                => Expression,
283
                        Aspect_Read                    => Name,
284
                        Aspect_Simple_Storage_Pool     => Name,
285
                        Aspect_Size                    => Expression,
286
                        Aspect_Small                   => Expression,
287
                        Aspect_Static_Predicate        => Expression,
288
                        Aspect_Storage_Pool            => Name,
289
                        Aspect_Storage_Size            => Expression,
290
                        Aspect_Stream_Size             => Expression,
291
                        Aspect_Suppress                => Name,
292
                        Aspect_Synchronization         => Name,
293
                        Aspect_Test_Case               => Expression,
294
                        Aspect_Type_Invariant          => Expression,
295
                        Aspect_Unsuppress              => Name,
296
                        Aspect_Value_Size              => Expression,
297
                        Aspect_Variable_Indexing       => Name,
298
                        Aspect_Warnings                => Name,
299
                        Aspect_Write                   => Name,
300
 
301
                        Library_Unit_Aspects           => Optional,
302
                        Boolean_Aspects                => Optional);
303
 
304
   -----------------------------------------
305
   -- Table Linking Names and Aspect_Id's --
306
   -----------------------------------------
307
 
308
   --  Table linking aspect names and id's
309
 
310
   Aspect_Names : constant array (Aspect_Id) of Name_Id := (
311
     No_Aspect                           => No_Name,
312
     Aspect_Ada_2005                     => Name_Ada_2005,
313
     Aspect_Ada_2012                     => Name_Ada_2012,
314
     Aspect_Address                      => Name_Address,
315
     Aspect_Alignment                    => Name_Alignment,
316
     Aspect_All_Calls_Remote             => Name_All_Calls_Remote,
317
     Aspect_Asynchronous                 => Name_Asynchronous,
318
     Aspect_Atomic                       => Name_Atomic,
319
     Aspect_Atomic_Components            => Name_Atomic_Components,
320
     Aspect_Attach_Handler               => Name_Attach_Handler,
321
     Aspect_Bit_Order                    => Name_Bit_Order,
322
     Aspect_Compiler_Unit                => Name_Compiler_Unit,
323
     Aspect_Component_Size               => Name_Component_Size,
324
     Aspect_Constant_Indexing            => Name_Constant_Indexing,
325
     Aspect_CPU                          => Name_CPU,
326
     Aspect_Default_Iterator             => Name_Default_Iterator,
327
     Aspect_Default_Value                => Name_Default_Value,
328
     Aspect_Default_Component_Value      => Name_Default_Component_Value,
329
     Aspect_Dimension                    => Name_Dimension,
330
     Aspect_Dimension_System             => Name_Dimension_System,
331
     Aspect_Discard_Names                => Name_Discard_Names,
332
     Aspect_Dispatching_Domain           => Name_Dispatching_Domain,
333
     Aspect_Dynamic_Predicate            => Name_Dynamic_Predicate,
334
     Aspect_Elaborate_Body               => Name_Elaborate_Body,
335
     Aspect_External_Tag                 => Name_External_Tag,
336
     Aspect_Favor_Top_Level              => Name_Favor_Top_Level,
337
     Aspect_Implicit_Dereference         => Name_Implicit_Dereference,
338
     Aspect_Independent                  => Name_Independent,
339
     Aspect_Independent_Components       => Name_Independent_Components,
340
     Aspect_Inline                       => Name_Inline,
341
     Aspect_Inline_Always                => Name_Inline_Always,
342
     Aspect_Input                        => Name_Input,
343
     Aspect_Interrupt_Handler            => Name_Interrupt_Handler,
344
     Aspect_Interrupt_Priority           => Name_Interrupt_Priority,
345
     Aspect_Invariant                    => Name_Invariant,
346
     Aspect_Iterator_Element             => Name_Iterator_Element,
347
     Aspect_Machine_Radix                => Name_Machine_Radix,
348
     Aspect_No_Return                    => Name_No_Return,
349
     Aspect_Object_Size                  => Name_Object_Size,
350
     Aspect_Output                       => Name_Output,
351
     Aspect_Pack                         => Name_Pack,
352
     Aspect_Persistent_BSS               => Name_Persistent_BSS,
353
     Aspect_Post                         => Name_Post,
354
     Aspect_Postcondition                => Name_Postcondition,
355
     Aspect_Pre                          => Name_Pre,
356
     Aspect_Precondition                 => Name_Precondition,
357
     Aspect_Predicate                    => Name_Predicate,
358
     Aspect_Preelaborable_Initialization => Name_Preelaborable_Initialization,
359
     Aspect_Preelaborate                 => Name_Preelaborate,
360
     Aspect_Preelaborate_05              => Name_Preelaborate_05,
361
     Aspect_Priority                     => Name_Priority,
362
     Aspect_Pure                         => Name_Pure,
363
     Aspect_Pure_05                      => Name_Pure_05,
364
     Aspect_Pure_12                      => Name_Pure_12,
365
     Aspect_Pure_Function                => Name_Pure_Function,
366
     Aspect_Read                         => Name_Read,
367
     Aspect_Remote_Access_Type           => Name_Remote_Access_Type,
368
     Aspect_Remote_Call_Interface        => Name_Remote_Call_Interface,
369
     Aspect_Remote_Types                 => Name_Remote_Types,
370
     Aspect_Shared                       => Name_Shared,
371
     Aspect_Shared_Passive               => Name_Shared_Passive,
372
     Aspect_Simple_Storage_Pool          => Name_Simple_Storage_Pool,
373
     Aspect_Simple_Storage_Pool_Type     => Name_Simple_Storage_Pool_Type,
374
     Aspect_Size                         => Name_Size,
375
     Aspect_Small                        => Name_Small,
376
     Aspect_Static_Predicate             => Name_Static_Predicate,
377
     Aspect_Storage_Pool                 => Name_Storage_Pool,
378
     Aspect_Storage_Size                 => Name_Storage_Size,
379
     Aspect_Stream_Size                  => Name_Stream_Size,
380
     Aspect_Suppress                     => Name_Suppress,
381
     Aspect_Suppress_Debug_Info          => Name_Suppress_Debug_Info,
382
     Aspect_Synchronization              => Name_Synchronization,
383
     Aspect_Test_Case                    => Name_Test_Case,
384
     Aspect_Type_Invariant               => Name_Type_Invariant,
385
     Aspect_Unchecked_Union              => Name_Unchecked_Union,
386
     Aspect_Universal_Aliasing           => Name_Universal_Aliasing,
387
     Aspect_Universal_Data               => Name_Universal_Data,
388
     Aspect_Unmodified                   => Name_Unmodified,
389
     Aspect_Unreferenced                 => Name_Unreferenced,
390
     Aspect_Unreferenced_Objects         => Name_Unreferenced_Objects,
391
     Aspect_Unsuppress                   => Name_Unsuppress,
392
     Aspect_Value_Size                   => Name_Value_Size,
393
     Aspect_Variable_Indexing            => Name_Variable_Indexing,
394
     Aspect_Volatile                     => Name_Volatile,
395
     Aspect_Volatile_Components          => Name_Volatile_Components,
396
     Aspect_Warnings                     => Name_Warnings,
397
     Aspect_Write                        => Name_Write);
398
 
399
   function Get_Aspect_Id (Name : Name_Id) return Aspect_Id;
400
   pragma Inline (Get_Aspect_Id);
401
   --  Given a name Nam, returns the corresponding aspect id value. If the name
402
   --  does not match any aspect, then No_Aspect is returned as the result.
403
 
404
   ---------------------------------------------------
405
   -- Handling of Aspect Specifications in the Tree --
406
   ---------------------------------------------------
407
 
408
   --  Several kinds of declaration node permit aspect specifications in Ada
409
   --  2012 mode. If there was room in all the corresponding declaration nodes,
410
   --  we could just have a field Aspect_Specifications pointing to a list of
411
   --  nodes for the aspects (N_Aspect_Specification nodes). But there isn't
412
   --  room, so we adopt a different approach.
413
 
414
   --  The following subprograms provide access to a specialized interface
415
   --  implemented internally with a hash table in the body, that provides
416
   --  access to aspect specifications.
417
 
418
   function Permits_Aspect_Specifications (N : Node_Id) return Boolean;
419
   --  Returns True if the node N is a declaration node that permits aspect
420
   --  specifications in the grammar. It is possible for other nodes to have
421
   --  aspect specifications as a result of Rewrite or Replace calls.
422
 
423
   function Aspect_Specifications (N : Node_Id) return List_Id;
424
   --  Given a node N, returns the list of N_Aspect_Specification nodes that
425
   --  are attached to this declaration node. If the node is in the class of
426
   --  declaration nodes that permit aspect specifications, as defined by the
427
   --  predicate above, and if their Has_Aspects flag is set to True, then this
428
   --  will always be a non-empty list. If this flag is set to False, then
429
   --  No_List is returned. Normally, the only nodes that have Has_Aspects set
430
   --  True are the nodes for which Permits_Aspect_Specifications would return
431
   --  True (i.e. the declaration nodes defined in the RM as permitting the
432
   --  presence of Aspect_Specifications). However, it is possible for the
433
   --  flag Has_Aspects to be set on other nodes as a result of Rewrite and
434
   --  Replace calls, and this function may be used to retrieve the aspect
435
   --  specifications for the original rewritten node in such cases.
436
 
437
   procedure Set_Aspect_Specifications (N : Node_Id; L : List_Id);
438
   --  The node N must be in the class of declaration nodes that permit aspect
439
   --  specifications and the Has_Aspects flag must be False on entry. L must
440
   --  be a non-empty list of N_Aspect_Specification nodes. This procedure sets
441
   --  the Has_Aspects flag to True, and makes an entry that can be retrieved
442
   --  by a subsequent Aspect_Specifications call. It is an error to call this
443
   --  procedure with a node that does not permit aspect specifications, or a
444
   --  node that has its Has_Aspects flag set True on entry, or with L being an
445
   --  empty list or No_List.
446
 
447
   function Find_Aspect (Ent : Entity_Id; A : Aspect_Id) return Node_Id;
448
   --  Find value of a given aspect from aspect list of entity
449
 
450
   procedure Move_Aspects (From : Node_Id; To : Node_Id);
451
   --  Moves aspects from 'From' node to 'To' node. Has_Aspects (To) must be
452
   --  False on entry. If Has_Aspects (From) is False, the call has no effect.
453
   --  Otherwise the aspects are moved and on return Has_Aspects (To) is True,
454
   --  and Has_Aspects (From) is False.
455
 
456
   function Same_Aspect (A1 : Aspect_Id; A2 : Aspect_Id) return Boolean;
457
   --  Returns True if A1 and A2 are (essentially) the same aspect. This is not
458
   --  a simple equality test because e.g. Post and Postcondition are the same.
459
   --  This is used for detecting duplicate aspects.
460
 
461
   procedure Tree_Write;
462
   --  Writes contents of Aspect_Specifications hash table to the tree file
463
 
464
   procedure Tree_Read;
465
   --  Reads contents of Aspect_Specifications hash table from the tree file
466
 
467
end Aspects;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.