1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2024, Free Software Foundation, Inc. --
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. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 -- Pragma handling is isolated in a separate package
27 -- (logically this processing belongs in chapter 4)
29 with Namet
; use Namet
;
31 with Snames
; use Snames
;
32 with Types
; use Types
;
36 -- The following table lists all pragmas that emulate an Ada 2012 aspect
38 Aspect_Specifying_Pragma
: constant array (Pragma_Id
) of Boolean :=
39 (Pragma_Abstract_State
=> True,
40 Pragma_All_Calls_Remote
=> True,
41 Pragma_Always_Terminates
=> True,
42 Pragma_Annotate
=> True,
43 Pragma_Async_Readers
=> True,
44 Pragma_Async_Writers
=> True,
45 Pragma_Asynchronous
=> True,
46 Pragma_Atomic
=> True,
47 Pragma_Atomic_Components
=> True,
48 Pragma_Attach_Handler
=> True,
49 Pragma_Constant_After_Elaboration
=> True,
50 Pragma_Contract_Cases
=> True,
51 Pragma_Convention
=> True,
53 Pragma_CUDA_Device
=> True,
54 Pragma_CUDA_Global
=> True,
55 Pragma_Default_Initial_Condition
=> True,
56 Pragma_Default_Storage_Pool
=> True,
57 Pragma_Depends
=> True,
58 Pragma_Discard_Names
=> True,
59 Pragma_Dispatching_Domain
=> True,
60 Pragma_Effective_Reads
=> True,
61 Pragma_Effective_Writes
=> True,
62 Pragma_Elaborate_Body
=> True,
63 Pragma_Exceptional_Cases
=> True,
64 Pragma_Export
=> True,
65 Pragma_Extensions_Visible
=> True,
66 Pragma_Favor_Top_Level
=> True,
68 Pragma_Global
=> True,
69 Pragma_GNAT_Annotate
=> True,
70 Pragma_Import
=> True,
71 Pragma_Independent
=> True,
72 Pragma_Independent_Components
=> True,
73 Pragma_Initial_Condition
=> True,
74 Pragma_Initializes
=> True,
75 Pragma_Inline
=> True,
76 Pragma_Inline_Always
=> True,
77 Pragma_Interrupt_Handler
=> True,
78 Pragma_Interrupt_Priority
=> True,
79 Pragma_Invariant
=> True,
80 Pragma_Linker_Section
=> True,
81 Pragma_Lock_Free
=> True,
82 Pragma_No_Elaboration_Code_All
=> True,
83 Pragma_No_Return
=> True,
84 Pragma_Obsolescent
=> True,
86 Pragma_Part_Of
=> True,
87 Pragma_Persistent_BSS
=> True,
89 Pragma_Post_Class
=> True,
90 Pragma_Postcondition
=> True,
92 Pragma_Pre_Class
=> True,
93 Pragma_Precondition
=> True,
94 Pragma_Predicate
=> True,
95 Pragma_Preelaborable_Initialization
=> True,
96 Pragma_Preelaborate
=> True,
97 Pragma_Priority
=> True,
99 Pragma_Pure_Function
=> True,
100 Pragma_Refined_Depends
=> True,
101 Pragma_Refined_Global
=> True,
102 Pragma_Refined_Post
=> True,
103 Pragma_Refined_State
=> True,
104 Pragma_Relative_Deadline
=> True,
105 Pragma_Remote_Access_Type
=> True,
106 Pragma_Remote_Call_Interface
=> True,
107 Pragma_Remote_Types
=> True,
108 Pragma_Secondary_Stack_Size
=> True,
109 Pragma_Shared
=> True,
110 Pragma_Shared_Passive
=> True,
111 Pragma_Simple_Storage_Pool_Type
=> True,
112 Pragma_SPARK_Mode
=> True,
113 Pragma_Storage_Size
=> True,
114 Pragma_Subprogram_Variant
=> True,
115 Pragma_Suppress
=> True,
116 Pragma_Suppress_Debug_Info
=> True,
117 Pragma_Suppress_Initialization
=> True,
118 Pragma_Test_Case
=> True,
119 Pragma_Thread_Local_Storage
=> True,
120 Pragma_Type_Invariant
=> True,
121 Pragma_Unchecked_Union
=> True,
122 Pragma_Universal_Aliasing
=> True,
123 Pragma_Unmodified
=> True,
124 Pragma_Unreferenced
=> True,
125 Pragma_Unreferenced_Objects
=> True,
126 Pragma_Unsuppress
=> True,
127 Pragma_Volatile
=> True,
128 Pragma_Volatile_Components
=> True,
129 Pragma_Volatile_Full_Access
=> True,
130 Pragma_Warnings
=> True,
133 -- The following table lists all pragmas that act as an assertion
136 Assertion_Expression_Pragma
: constant array (Pragma_Id
) of Boolean :=
137 (Pragma_Always_Terminates
=> True,
138 Pragma_Assert
=> True,
139 Pragma_Assert_And_Cut
=> True,
140 Pragma_Assume
=> True,
141 Pragma_Check
=> True,
142 Pragma_Compile_Time_Error
=> True,
143 Pragma_Contract_Cases
=> True,
144 Pragma_Default_Initial_Condition
=> True,
145 Pragma_Exceptional_Cases
=> True,
146 Pragma_Initial_Condition
=> True,
147 Pragma_Invariant
=> True,
148 Pragma_Loop_Invariant
=> True,
149 Pragma_Loop_Variant
=> True,
151 Pragma_Post_Class
=> True,
152 Pragma_Postcondition
=> True,
154 Pragma_Pre_Class
=> True,
155 Pragma_Precondition
=> True,
156 Pragma_Predicate
=> True,
157 Pragma_Refined_Post
=> True,
158 Pragma_Subprogram_Variant
=> True,
159 Pragma_Test_Case
=> True,
160 Pragma_Type_Invariant
=> True,
161 Pragma_Type_Invariant_Class
=> True,
164 -- Should to following constant arrays be renamed to better suit their
165 -- use as a predicate (e.g. Is_Pragma_*) ???
167 -- The following table lists all the implementation-defined pragmas that
168 -- should apply to the anonymous object produced by the analysis of a
169 -- single protected or task type. The table should be synchronized with
170 -- Aspect_On_Anonymous_Object_OK in unit Aspects.
172 Pragma_On_Anonymous_Object_OK
: constant array (Pragma_Id
) of Boolean :=
173 (Pragma_Depends
=> True,
174 Pragma_Global
=> True,
175 Pragma_Part_Of
=> True,
178 -- The following table lists all the implementation-defined pragmas that
179 -- may apply to a body stub (no language defined pragmas apply). The table
180 -- should be synchronized with Aspect_On_Body_Or_Stub_OK in unit Aspects.
182 Pragma_On_Body_Or_Stub_OK
: constant array (Pragma_Id
) of Boolean :=
183 (Pragma_Refined_Depends
=> True,
184 Pragma_Refined_Global
=> True,
185 Pragma_Refined_Post
=> True,
186 Pragma_SPARK_Mode
=> True,
187 Pragma_Warnings
=> True,
190 -- The following table lists all pragmas which are significant in SPARK and
191 -- as a result get translated into verification conditions. The table is an
192 -- amalgamation of the pragmas listed in SPARK RM 16.1 and internally added
195 Pragma_Significant_In_SPARK
: constant array (Pragma_Id
) of Boolean :=
196 (Pragma_All_Calls_Remote
=> False,
197 Pragma_Asynchronous
=> False,
198 Pragma_Default_Storage_Pool
=> False,
199 Pragma_Discard_Names
=> False,
200 Pragma_Dispatching_Domain
=> False,
201 Pragma_Priority_Specific_Dispatching
=> False,
202 Pragma_Remote_Call_Interface
=> False,
203 Pragma_Remote_Types
=> False,
204 Pragma_Shared_Passive
=> False,
205 Pragma_Task_Dispatching_Policy
=> False,
206 Pragma_Unmodified
=> False,
207 Pragma_Unreferenced
=> False,
208 Pragma_Warnings
=> False,
211 -- The following table lists all pragmas which are relevant to the analysis
212 -- of subprogram bodies.
214 Pragma_Significant_To_Subprograms
: constant array (Pragma_Id
) of Boolean :=
215 (Pragma_Always_Terminates
=> True,
216 Pragma_Contract_Cases
=> True,
217 Pragma_Depends
=> True,
218 Pragma_Exceptional_Cases
=> True,
219 Pragma_Extensions_Visible
=> True,
220 Pragma_Ghost
=> True,
221 Pragma_Global
=> True,
222 Pragma_Inline
=> True,
223 Pragma_Inline_Always
=> True,
225 Pragma_Post_Class
=> True,
226 Pragma_Postcondition
=> True,
228 Pragma_Pre_Class
=> True,
229 Pragma_Precondition
=> True,
231 Pragma_Pure_Function
=> True,
232 Pragma_Refined_Depends
=> True,
233 Pragma_Refined_Global
=> True,
234 Pragma_Refined_Post
=> True,
235 Pragma_Refined_State
=> True,
236 Pragma_Side_Effects
=> True,
237 Pragma_Subprogram_Variant
=> True,
238 Pragma_Volatile
=> True,
239 Pragma_Volatile_Function
=> True,
242 -- The following table lists all pragmas which are relevant to the analysis
243 -- of subprogram bodies and should be analyzed first, because the analysis
244 -- of other pragmas relevant to subprogram bodies depend on them.
246 Pragma_Significant_To_Subprograms_Analyzed_First
:
247 constant array (Pragma_Id
) of Boolean :=
248 (Pragma_Extensions_Visible
=> True,
255 procedure Analyze_Pragma
(N
: Node_Id
);
256 -- Analyze procedure for pragma reference node N
258 procedure Analyze_Pragmas_If_Present
(Decl
: Node_Id
; Id
: Pragma_Id
);
259 -- Inspect the list of pragmas after declaration Decl and look for a pragma
260 -- that matches Id. If found, analyze the pragma.
262 procedure Analyze_Always_Terminates_In_Decl_Part
264 Freeze_Id
: Entity_Id
:= Empty
);
265 -- Perform full analysis of delayed pragma Always_Terminates. Freeze_Id is
266 -- the entity of [generic] package body or [generic] subprogram body which
267 -- caused "freezing" of the related contract where the pragma resides.
269 procedure Analyze_Contract_Cases_In_Decl_Part
271 Freeze_Id
: Entity_Id
:= Empty
);
272 -- Perform full analysis of delayed pragma Contract_Cases. Freeze_Id is the
273 -- entity of [generic] package body or [generic] subprogram body which
274 -- caused "freezing" of the related contract where the pragma resides.
276 procedure Analyze_Depends_In_Decl_Part
(N
: Node_Id
);
277 -- Perform full analysis of delayed pragma Depends. This routine is also
278 -- capable of performing basic analysis of pragma Refined_Depends.
280 procedure Analyze_Exceptional_Cases_In_Decl_Part
282 Freeze_Id
: Entity_Id
:= Empty
);
283 -- Perform full analysis of delayed pragma Exceptional_Cases. Freeze_Id is
284 -- the entity of [generic] package body or [generic] subprogram body which
285 -- caused "freezing" of the related contract where the pragma resides.
287 procedure Analyze_External_Property_In_Decl_Part
289 Expr_Val
: out Boolean);
290 -- Perform full analysis of delayed pragmas Async_Readers, Async_Writers,
291 -- Effective_Reads, Effective_Writes and No_Caching. Flag Expr_Val contains
292 -- the Boolean argument of the pragma or a default True if no argument
295 procedure Analyze_Global_In_Decl_Part
(N
: Node_Id
);
296 -- Perform full analysis of delayed pragma Global. This routine is also
297 -- capable of performing basic analysis of pragma Refined_Global.
299 procedure Analyze_Initial_Condition_In_Decl_Part
(N
: Node_Id
);
300 -- Perform full analysis of delayed pragma Initial_Condition
302 procedure Analyze_Initializes_In_Decl_Part
(N
: Node_Id
);
303 -- Perform full analysis of delayed pragma Initializes
305 procedure Analyze_Part_Of_In_Decl_Part
307 Freeze_Id
: Entity_Id
:= Empty
);
308 -- Perform full analysis of delayed pragma Part_Of. Freeze_Id is the entity
309 -- of [generic] package body or [generic] subprogram body which caused the
310 -- "freezing" of the related contract where the pragma resides.
312 procedure Analyze_Pre_Post_Condition_In_Decl_Part
314 Freeze_Id
: Entity_Id
:= Empty
);
315 -- Perform full analysis of pragmas Precondition and Postcondition.
316 -- Freeze_Id denotes the entity of [generic] package body or [generic]
317 -- subprogram body which caused "freezing" of the related contract where
318 -- the pragma resides.
320 procedure Analyze_Refined_Depends_In_Decl_Part
(N
: Node_Id
);
321 -- Preform full analysis of delayed pragma Refined_Depends. This routine
322 -- uses Analyze_Depends_In_Decl_Part as a starting point, then performs
323 -- various consistency checks between Depends and Refined_Depends.
325 procedure Analyze_Refined_Global_In_Decl_Part
(N
: Node_Id
);
326 -- Perform full analysis of delayed pragma Refined_Global. This routine
327 -- uses Analyze_Global_In_Decl_Part as a starting point, then performs
328 -- various consistency checks between Global and Refined_Global.
330 procedure Analyze_Refined_State_In_Decl_Part
332 Freeze_Id
: Entity_Id
:= Empty
);
333 -- Perform full analysis of delayed pragma Refined_State. Freeze_Id denotes
334 -- the entity of [generic] package body or [generic] subprogram body which
335 -- caused "freezing" of the related contract where the pragma resides.
337 procedure Analyze_Subprogram_Variant_In_Decl_Part
339 Freeze_Id
: Entity_Id
:= Empty
);
340 -- Perform full analysis of delayed pragma Subprogram_Variant. Freeze_Id is
341 -- the entity of [generic] package body or [generic] subprogram body which
342 -- caused "freezing" of the related contract where the pragma resides.
344 procedure Analyze_Test_Case_In_Decl_Part
(N
: Node_Id
);
345 -- Perform preanalysis of pragma Test_Case
347 function Build_Pragma_Check_Equivalent
349 Subp_Id
: Entity_Id
:= Empty
;
350 Inher_Id
: Entity_Id
:= Empty
;
351 Keep_Pragma_Id
: Boolean := False) return Node_Id
;
352 -- Transform a pre- or [refined] postcondition denoted by Prag into an
353 -- equivalent pragma Check. When the pre- or postcondition is inherited,
354 -- the routine replaces the references of all formals of Inher_Id
355 -- and primitive operations of its controlling type by references
356 -- to the corresponding entities of Subp_Id and the descendant type.
357 -- Keep_Pragma_Id is True when the newly created pragma should be
358 -- in fact of the same kind as the source pragma Prag. This is used
359 -- in GNATprove_Mode to generate the inherited pre- and postconditions.
361 procedure Check_Applicable_Policy
(N
: Node_Id
);
362 -- N is either an N_Aspect or an N_Pragma node. There are two cases. If
363 -- the name of the aspect or pragma is not one of those recognized as
364 -- an assertion kind by an Assertion_Policy pragma, then the call has
365 -- no effect. Note that in the case of a pragma derived from an aspect,
366 -- the name we use for the purpose of this procedure is the aspect name,
367 -- which may be different from the pragma name (e.g. Precondition for
368 -- Pre aspect). In addition, 'Class aspects are recognized (and the
369 -- corresponding special names used in the processing).
371 -- If the name is a valid assertion kind name, then the Check_Policy pragma
372 -- chain is checked for a matching entry (or for an Assertion entry which
373 -- matches all possibilities). If a matching entry is found then the policy
374 -- is checked. If it is On or Check, then the Is_Checked flag is set in
375 -- the aspect or pragma node. If it is Off, Ignore, or Disable, then the
376 -- Is_Ignored flag is set in the aspect or pragma node. Additionally for
377 -- policy Disable, the Is_Disabled flag is set.
379 -- If no matching Check_Policy pragma is found then the effect depends on
380 -- whether -gnata was used, if so, then the call has no effect, otherwise
381 -- Is_Ignored (but not Is_Disabled) is set True.
383 procedure Check_External_Properties
389 -- Flags AR, AW, ER and EW denote the static values of external properties
390 -- Async_Readers, Async_Writers, Effective_Reads and Effective_Writes. Item
391 -- is the related variable or state. Ensure legality of the combination and
392 -- issue an error for an illegal combination.
394 function Check_Kind
(Nam
: Name_Id
) return Name_Id
;
395 -- This function is used in connection with pragmas Assert, Check,
396 -- and assertion aspects and pragmas, to determine if Check pragmas
397 -- (or corresponding assertion aspects or pragmas) are currently active
398 -- as determined by the presence of -gnata on the command line (which
399 -- sets the default), and the appearance of pragmas Check_Policy and
400 -- Assertion_Policy as configuration pragmas either in a configuration
401 -- pragma file, or at the start of the current unit, or locally given
402 -- Check_Policy and Assertion_Policy pragmas that are currently active.
404 -- The value returned is one of the names Check, Ignore, Disable (On
405 -- returns Check, and Off returns Ignore).
407 -- Note: for assertion kinds Pre'Class, Post'Class, Invariant'Class,
408 -- and Type_Invariant'Class, the name passed is Name_uPre, Name_uPost,
409 -- Name_uInvariant, or Name_uType_Invariant, which corresponds to _Pre,
410 -- _Post, _Invariant, or _Type_Invariant, which are special names used
411 -- in identifiers to represent these attribute references.
413 procedure Check_Missing_Part_Of
(Item_Id
: Entity_Id
);
414 -- Determine whether the placement within the state space of an abstract
415 -- state, variable or package instantiation denoted by Item_Id requires the
416 -- use of indicator/option Part_Of. If this is the case, emit an error.
418 procedure Collect_Inherited_Class_Wide_Conditions
(Subp
: Entity_Id
);
419 -- In GNATprove mode, when analyzing an overriding subprogram, check
420 -- whether the overridden operations have class-wide pre/postconditions,
421 -- and generate the corresponding pragmas. The pragmas are inserted after
422 -- the subprogram declaration, together with those generated for other
423 -- aspects of the subprogram.
425 procedure Collect_Subprogram_Inputs_Outputs
426 (Subp_Id
: Entity_Id
;
427 Synthesize
: Boolean := False;
428 Subp_Inputs
: in out Elist_Id
;
429 Subp_Outputs
: in out Elist_Id
;
430 Global_Seen
: out Boolean);
431 -- Subsidiary to the analysis of pragmas Depends, Global, Refined_Depends
432 -- and Refined_Global. Collect all inputs and outputs of subprogram Subp_Id
433 -- in lists Subp_Inputs (inputs) and Subp_Outputs (outputs). The inputs and
434 -- outputs are gathered from:
435 -- 1) The formal parameters of the subprogram
436 -- 2) The generic formal parameters of the generic subprogram
437 -- 3) The current instance of a concurrent type
438 -- 4) The items of pragma [Refined_]Global
440 -- 5) The items of pragma [Refined_]Depends if there is no pragma
441 -- [Refined_]Global present and flag Synthesize is set to True.
442 -- If the subprogram has no inputs and/or outputs, then the returned list
443 -- is No_Elist. Flag Global_Seen is set when the related subprogram has
444 -- pragma [Refined_]Global.
446 function Delay_Config_Pragma_Analyze
(N
: Node_Id
) return Boolean;
447 -- N is a pragma appearing in a configuration pragma file. Most such
448 -- pragmas are analyzed when the file is read, before parsing and analyzing
449 -- the main unit. However, the analysis of certain pragmas results in
450 -- adding information to the compiled main unit, and this cannot be done
451 -- till the main unit is processed. Such pragmas return True from this
452 -- function and in Frontend pragmas where Delay_Config_Pragma_Analyze is
453 -- True have their analysis delayed until after the main program is parsed
456 function Find_Related_Package_Or_Body
458 Do_Checks
: Boolean := False) return Node_Id
;
459 -- Subsidiary to the analysis of pragmas
464 -- Find the declaration of the related package [body] subject to pragma
465 -- Prag. The return value is either N_Package_Declaration, N_Package_Body,
466 -- or Empty if the placement of the pragma is illegal. If flag Do_Checks is
467 -- set, the routine reports duplicate pragmas.
469 function Find_Related_Declaration_Or_Body
471 Do_Checks
: Boolean := False) return Node_Id
;
472 -- Subsidiary to the analysis of pragmas
477 -- Extensions_Visible
480 -- Max_Entry_Queue_Length
493 -- Subprogram_Variant
496 -- as well as attributes 'Old and 'Result. Find the declaration of the
497 -- related entry, subprogram or task type [body] subject to pragma Prag.
498 -- If flag Do_Checks is set, the routine reports duplicate pragmas and
499 -- detects improper use of refinement pragmas in stand alone expression
502 function Get_Argument
504 Context_Id
: Entity_Id
:= Empty
) return Node_Id
;
505 -- Obtain the argument of pragma Prag depending on context and the nature
506 -- of the pragma. The argument is extracted in the following manner:
508 -- When the pragma is generated from an aspect, return the corresponding
509 -- aspect when Context_Id denotes a generic unit.
511 -- Otherwise return the first argument of Prag
513 -- Context denotes the entity of the function, package or procedure where
516 function Get_SPARK_Mode_From_Annotation
517 (N
: Node_Id
) return SPARK_Mode_Type
;
518 -- Given an aspect or pragma SPARK_Mode node, return corresponding mode id
520 procedure Initialize
;
521 -- Initializes data structures used for pragma processing. Must be called
522 -- before analyzing each new main source program.
524 function Is_Config_Static_String
(Arg
: Node_Id
) return Boolean;
525 -- This is called for a configuration pragma that requires either string
526 -- literal or a concatenation of string literals. We cannot use normal
527 -- static string processing because it is too early in the case of the
528 -- pragma appearing in a configuration pragmas file. If Arg is of an
529 -- appropriate form, then this call obtains the string (doing any necessary
530 -- concatenations) and places it in Name_Buffer, setting Name_Len to its
531 -- length, and then returns True. If it is not of the correct form, then an
532 -- appropriate error message is posted, and False is returned.
534 function Is_Elaboration_SPARK_Mode
(N
: Node_Id
) return Boolean;
535 -- Determine whether pragma SPARK_Mode appears in the statement part of a
538 function Is_Enabled_Pragma
(Prag
: Node_Id
) return Boolean;
539 -- Determine whether a Boolean-like SPARK pragma Prag is enabled. To be
540 -- considered enabled, the pragma must either:
541 -- * Appear without its Boolean expression
542 -- * The Boolean expression evaluates to "True"
544 -- Boolean-like SPARK pragmas differ from pure Boolean Ada pragmas in that
545 -- their optional Boolean expression must be static and cannot benefit from
546 -- forward references. The following are Boolean-like SPARK pragmas:
549 -- Constant_After_Elaboration
552 -- Extensions_Visible
555 function Is_Non_Significant_Pragma_Reference
(N
: Node_Id
) return Boolean;
556 -- The node N is a node for an entity and the issue is whether the
557 -- occurrence is a reference for the purposes of giving warnings about
558 -- unreferenced variables. This function returns True if the reference is
559 -- not a reference from this point of view (e.g. the occurrence in a pragma
560 -- Pack) and False if it is a real reference (e.g. the occurrence in a
563 function Is_Pragma_String_Literal
(Par
: Node_Id
) return Boolean;
564 -- Given an N_Pragma_Argument_Association node, Par, which has the form of
565 -- an operator symbol, determines whether or not it should be treated as an
566 -- string literal. This is called by Sem_Ch6.Analyze_Operator_Symbol. If
567 -- True is returned, the argument is converted to a string literal. If
568 -- False is returned, then the argument is treated as an entity reference
571 function Is_Private_SPARK_Mode
(N
: Node_Id
) return Boolean;
572 -- Determine whether pragma SPARK_Mode appears in the private part of a
575 function Is_Valid_Assertion_Kind
(Nam
: Name_Id
) return Boolean;
576 -- Returns True if Nam is one of the names recognized as a valid assertion
577 -- kind by the Assertion_Policy pragma. Note that the 'Class cases are
578 -- represented by the corresponding special names Name_uPre, Name_uPost,
579 -- Name_uInvariant, and Name_uType_Invariant (_Pre, _Post, _Invariant,
580 -- and _Type_Invariant).
582 procedure Process_Compilation_Unit_Pragmas
(N
: Node_Id
);
583 -- Called at the start of processing compilation unit N to deal with any
584 -- special issues regarding pragmas. In particular, we have to deal with
585 -- Suppress_All at this stage, since it can appear after the unit instead
586 -- of before (actually we allow it to appear anywhere).
588 procedure Relocate_Pragmas_To_Anonymous_Object
591 -- Relocate all pragmas that appear in the visible declarations of task or
592 -- protected type declaration Typ_Decl after the declaration of anonymous
593 -- object Obj_Decl. Table Pragmas_On_Anonymous_Object_OK contains the list
594 -- of candidate pragmas.
596 procedure Relocate_Pragmas_To_Body
597 (Subp_Body
: Node_Id
;
598 Target_Body
: Node_Id
:= Empty
);
599 -- Resocate all pragmas that follow and apply to subprogram body Subp_Body
600 -- to its own declaration list. Candidate pragmas are classified in table
601 -- Pragma_On_Body_Or_Stub_OK. If Target_Body is set, the pragma are moved
602 -- to the declarations of Target_Body. This formal should be set when
603 -- dealing with subprogram body stubs or expression functions.
605 procedure Set_Encoded_Interface_Name
(E
: Entity_Id
; S
: Node_Id
);
606 -- This routine is used to set an encoded interface name. The node S is
607 -- an N_String_Literal node for the external name to be set, and E is an
608 -- entity whose Interface_Name field is to be set. In the normal case where
609 -- S contains a name that is a valid C identifier, then S is simply set as
610 -- the value of the Interface_Name. Otherwise it is encoded as needed by
611 -- particular operating systems. See the body for details of the encoding.
613 procedure Set_Overflow_Mode
(N
: Node_Id
);
614 -- Sets Sem.Scope_Suppress according to the overflow modes specified in
615 -- the pragma Overflow_Mode passed in argument. This should only be called
616 -- after N has been successfully analyzed.
618 function Test_Case_Arg
621 From_Aspect
: Boolean := False) return Node_Id
;
622 -- Obtain argument "Name", "Mode", "Ensures" or "Requires" from Test_Case
623 -- pragma Prag as denoted by Arg_Nam. When From_Aspect is set, an attempt
624 -- is made to retrieve the argument from the corresponding aspect if there
625 -- is one. The returned argument has several formats:
627 -- N_Pragma_Argument_Association if retrieved directly from the pragma
629 -- N_Component_Association if retrieved from the corresponding aspect and
630 -- the argument appears in a named association form.
632 -- An arbitrary expression if retrieved from the corresponding aspect and
633 -- the argument appears in positional form.
635 -- Empty if there is no such argument
637 procedure Validate_Compile_Time_Warning_Errors
;
638 -- This routine is called after calling the back end to validate pragmas
639 -- Compile_Time_Error and Compile_Time_Warning for size and alignment
640 -- appropriateness. The reason it is called that late is to take advantage
641 -- of any back-annotation of size and alignment performed by the back end.