| \input texinfo @c -*-texinfo-*- |
| @c %**start of header |
| @setfilename gnat_rm.info |
| @documentencoding UTF-8 |
| @ifinfo |
| @*Generated by Sphinx 1.3b2.@* |
| @end ifinfo |
| @settitle GNAT Reference Manual |
| @defindex ge |
| @paragraphindent 0 |
| @exampleindent 4 |
| @finalout |
| @dircategory GNU Ada Tools |
| @direntry |
| * gnat_rm: (gnat_rm.info). gnat_rm |
| @end direntry |
| |
| @definfoenclose strong,`,' |
| @definfoenclose emph,`,' |
| @c %**end of header |
| |
| @copying |
| @quotation |
| GNAT Reference Manual , March 24, 2015 |
| |
| AdaCore |
| |
| Copyright @copyright{} 2008-2015, Free Software Foundation |
| @end quotation |
| |
| @end copying |
| |
| @titlepage |
| @title GNAT Reference Manual |
| @insertcopying |
| @end titlepage |
| @contents |
| |
| @c %** start of user preamble |
| |
| @c %** end of user preamble |
| |
| @ifnottex |
| @node Top |
| @top GNAT Reference Manual |
| @insertcopying |
| @end ifnottex |
| |
| @c %**start of body |
| @anchor{gnat_rm doc}@anchor{0} |
| @emph{GNAT, The GNU Ada Development Environment} |
| |
| |
| @include gcc-common.texi |
| GCC version @value{version-GCC}@* |
| AdaCore |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.3 or |
| any later version published by the Free Software Foundation; with no |
| Invariant Sections, with the Front-Cover Texts being "GNAT Reference |
| Manual", and with no Back-Cover Texts. A copy of the license is |
| included in the section entitled @ref{1,,GNU Free Documentation License}. |
| |
| @menu |
| * About This Guide:: |
| * Implementation Defined Pragmas:: |
| * Implementation Defined Aspects:: |
| * Implementation Defined Attributes:: |
| * Standard and Implementation Defined Restrictions:: |
| * Implementation Advice:: |
| * Implementation Defined Characteristics:: |
| * Intrinsic Subprograms:: |
| * Representation Clauses and Pragmas:: |
| * Standard Library Routines:: |
| * The Implementation of Standard I/O:: |
| * The GNAT Library:: |
| * Interfacing to Other Languages:: |
| * Specialized Needs Annexes:: |
| * Implementation of Specific Ada Features:: |
| * Implementation of Ada 2012 Features:: |
| * Obsolescent Features:: |
| * Compatibility and Porting Guide:: |
| * GNU Free Documentation License:: |
| * Index:: |
| |
| @detailmenu |
| --- The Detailed Node Listing --- |
| |
| About This Guide |
| |
| * What This Reference Manual Contains:: |
| * Conventions:: |
| * Related Information:: |
| |
| Implementation Defined Pragmas |
| |
| * Pragma Abort_Defer:: |
| * Pragma Abstract_State:: |
| * Pragma Ada_83:: |
| * Pragma Ada_95:: |
| * Pragma Ada_05:: |
| * Pragma Ada_2005:: |
| * Pragma Ada_12:: |
| * Pragma Ada_2012:: |
| * Pragma Allow_Integer_Address:: |
| * Pragma Annotate:: |
| * Pragma Assert:: |
| * Pragma Assert_And_Cut:: |
| * Pragma Assertion_Policy:: |
| * Pragma Assume:: |
| * Pragma Assume_No_Invalid_Values:: |
| * Pragma Async_Readers:: |
| * Pragma Async_Writers:: |
| * Pragma Attribute_Definition:: |
| * Pragma C_Pass_By_Copy:: |
| * Pragma Check:: |
| * Pragma Check_Float_Overflow:: |
| * Pragma Check_Name:: |
| * Pragma Check_Policy:: |
| * Pragma CIL_Constructor:: |
| * Pragma Comment:: |
| * Pragma Common_Object:: |
| * Pragma Compile_Time_Error:: |
| * Pragma Compile_Time_Warning:: |
| * Pragma Compiler_Unit:: |
| * Pragma Compiler_Unit_Warning:: |
| * Pragma Complete_Representation:: |
| * Pragma Complex_Representation:: |
| * Pragma Component_Alignment:: |
| * Pragma Contract_Cases:: |
| * Pragma Convention_Identifier:: |
| * Pragma CPP_Class:: |
| * Pragma CPP_Constructor:: |
| * Pragma CPP_Virtual:: |
| * Pragma CPP_Vtable:: |
| * Pragma CPU:: |
| * Pragma Debug:: |
| * Pragma Debug_Policy:: |
| * Pragma Default_Scalar_Storage_Order:: |
| * Pragma Default_Storage_Pool:: |
| * Pragma Depends:: |
| * Pragma Detect_Blocking:: |
| * Pragma Disable_Atomic_Synchronization:: |
| * Pragma Dispatching_Domain:: |
| * Pragma Effective_Reads:: |
| * Pragma Effective_Writes:: |
| * Pragma Elaboration_Checks:: |
| * Pragma Eliminate:: |
| * Pragma Enable_Atomic_Synchronization:: |
| * Pragma Export_Function:: |
| * Pragma Export_Object:: |
| * Pragma Export_Procedure:: |
| * Pragma Export_Value:: |
| * Pragma Export_Valued_Procedure:: |
| * Pragma Extend_System:: |
| * Pragma Extensions_Allowed:: |
| * Pragma External:: |
| * Pragma External_Name_Casing:: |
| * Pragma Fast_Math:: |
| * Pragma Favor_Top_Level:: |
| * Pragma Finalize_Storage_Only:: |
| * Pragma Float_Representation:: |
| * Pragma Global:: |
| * Pragma Ident:: |
| * Pragma Ignore_Pragma:: |
| * Pragma Implementation_Defined:: |
| * Pragma Implemented:: |
| * Pragma Implicit_Packing:: |
| * Pragma Import_Function:: |
| * Pragma Import_Object:: |
| * Pragma Import_Procedure:: |
| * Pragma Import_Valued_Procedure:: |
| * Pragma Independent:: |
| * Pragma Independent_Components:: |
| * Pragma Initial_Condition:: |
| * Pragma Initialize_Scalars:: |
| * Pragma Initializes:: |
| * Pragma Inline_Always:: |
| * Pragma Inline_Generic:: |
| * Pragma Interface:: |
| * Pragma Interface_Name:: |
| * Pragma Interrupt_Handler:: |
| * Pragma Interrupt_State:: |
| * Pragma Invariant:: |
| * Pragma Java_Constructor:: |
| * Pragma Java_Interface:: |
| * Pragma Keep_Names:: |
| * Pragma License:: |
| * Pragma Link_With:: |
| * Pragma Linker_Alias:: |
| * Pragma Linker_Constructor:: |
| * Pragma Linker_Destructor:: |
| * Pragma Linker_Section:: |
| * Pragma Lock_Free:: |
| * Pragma Loop_Invariant:: |
| * Pragma Loop_Optimize:: |
| * Pragma Loop_Variant:: |
| * Pragma Machine_Attribute:: |
| * Pragma Main:: |
| * Pragma Main_Storage:: |
| * Pragma No_Body:: |
| * Pragma No_Elaboration_Code_All:: |
| * Pragma No_Inline:: |
| * Pragma No_Return:: |
| * Pragma No_Run_Time:: |
| * Pragma No_Strict_Aliasing:: |
| * Pragma No_Tagged_Streams:: |
| * Pragma Normalize_Scalars:: |
| * Pragma Obsolescent:: |
| * Pragma Optimize_Alignment:: |
| * Pragma Ordered:: |
| * Pragma Overflow_Mode:: |
| * Pragma Overriding_Renamings:: |
| * Pragma Partition_Elaboration_Policy:: |
| * Pragma Part_Of:: |
| * Pragma Passive:: |
| * Pragma Persistent_BSS:: |
| * Pragma Polling:: |
| * Pragma Post:: |
| * Pragma Postcondition:: |
| * Pragma Post_Class:: |
| * Pragma Pre:: |
| * Pragma Precondition:: |
| * Pragma Predicate:: |
| * Pragma Preelaborable_Initialization:: |
| * Pragma Prefix_Exception_Messages:: |
| * Pragma Pre_Class:: |
| * Pragma Priority_Specific_Dispatching:: |
| * Pragma Profile:: |
| * Pragma Profile_Warnings:: |
| * Pragma Propagate_Exceptions:: |
| * Pragma Provide_Shift_Operators:: |
| * Pragma Psect_Object:: |
| * Pragma Pure_Function:: |
| * Pragma Rational:: |
| * Pragma Ravenscar:: |
| * Pragma Refined_Depends:: |
| * Pragma Refined_Global:: |
| * Pragma Refined_Post:: |
| * Pragma Refined_State:: |
| * Pragma Relative_Deadline:: |
| * Pragma Remote_Access_Type:: |
| * Pragma Restricted_Run_Time:: |
| * Pragma Restriction_Warnings:: |
| * Pragma Reviewable:: |
| * Pragma Share_Generic:: |
| * Pragma Shared:: |
| * Pragma Short_Circuit_And_Or:: |
| * Pragma Short_Descriptors:: |
| * Pragma Simple_Storage_Pool_Type:: |
| * Pragma Source_File_Name:: |
| * Pragma Source_File_Name_Project:: |
| * Pragma Source_Reference:: |
| * Pragma SPARK_Mode:: |
| * Pragma Static_Elaboration_Desired:: |
| * Pragma Stream_Convert:: |
| * Pragma Style_Checks:: |
| * Pragma Subtitle:: |
| * Pragma Suppress:: |
| * Pragma Suppress_All:: |
| * Pragma Suppress_Debug_Info:: |
| * Pragma Suppress_Exception_Locations:: |
| * Pragma Suppress_Initialization:: |
| * Pragma Task_Name:: |
| * Pragma Task_Storage:: |
| * Pragma Test_Case:: |
| * Pragma Thread_Local_Storage:: |
| * Pragma Time_Slice:: |
| * Pragma Title:: |
| * Pragma Type_Invariant:: |
| * Pragma Type_Invariant_Class:: |
| * Pragma Unchecked_Union:: |
| * Pragma Unevaluated_Use_Of_Old:: |
| * Pragma Unimplemented_Unit:: |
| * Pragma Universal_Aliasing:: |
| * Pragma Universal_Data:: |
| * Pragma Unmodified:: |
| * Pragma Unreferenced:: |
| * Pragma Unreferenced_Objects:: |
| * Pragma Unreserve_All_Interrupts:: |
| * Pragma Unsuppress:: |
| * Pragma Use_VADS_Size:: |
| * Pragma Validity_Checks:: |
| * Pragma Volatile:: |
| * Pragma Warning_As_Error:: |
| * Pragma Warnings:: |
| * Pragma Weak_External:: |
| * Pragma Wide_Character_Encoding:: |
| |
| Implementation Defined Aspects |
| |
| * Aspect Abstract_State:: |
| * Annotate:: |
| * Aspect Async_Readers:: |
| * Aspect Async_Writers:: |
| * Aspect Contract_Cases:: |
| * Aspect Depends:: |
| * Aspect Dimension:: |
| * Aspect Dimension_System:: |
| * Aspect Effective_Reads:: |
| * Aspect Effective_Writes:: |
| * Aspect Favor_Top_Level:: |
| * Aspect Global:: |
| * Aspect Initial_Condition:: |
| * Aspect Initializes:: |
| * Aspect Inline_Always:: |
| * Aspect Invariant:: |
| * Aspect Invariant'Class:: |
| * Aspect Iterable:: |
| * Aspect Linker_Section:: |
| * Aspect Lock_Free:: |
| * Aspect No_Elaboration_Code_All:: |
| * Aspect No_Tagged_Streams:: |
| * Aspect Object_Size:: |
| * Aspect Obsolescent:: |
| * Aspect Part_Of:: |
| * Aspect Persistent_BSS:: |
| * Aspect Predicate:: |
| * Aspect Pure_Function:: |
| * Aspect Refined_Depends:: |
| * Aspect Refined_Global:: |
| * Aspect Refined_Post:: |
| * Aspect Refined_State:: |
| * Aspect Remote_Access_Type:: |
| * Aspect Scalar_Storage_Order:: |
| * Aspect Shared:: |
| * Aspect Simple_Storage_Pool:: |
| * Aspect Simple_Storage_Pool_Type:: |
| * Aspect SPARK_Mode:: |
| * Aspect Suppress_Debug_Info:: |
| * Aspect Suppress_Initialization:: |
| * Aspect Test_Case:: |
| * Aspect Thread_Local_Storage:: |
| * Aspect Universal_Aliasing:: |
| * Aspect Universal_Data:: |
| * Aspect Unmodified:: |
| * Aspect Unreferenced:: |
| * Aspect Unreferenced_Objects:: |
| * Aspect Value_Size:: |
| * Aspect Warnings:: |
| |
| Implementation Defined Attributes |
| |
| * Attribute Abort_Signal:: |
| * Attribute Address_Size:: |
| * Attribute Asm_Input:: |
| * Attribute Asm_Output:: |
| * Attribute Atomic_Always_Lock_Free:: |
| * Attribute Bit:: |
| * Attribute Bit_Position:: |
| * Attribute Code_Address:: |
| * Attribute Compiler_Version:: |
| * Attribute Constrained:: |
| * Attribute Default_Bit_Order:: |
| * Attribute Default_Scalar_Storage_Order:: |
| * Attribute Deref:: |
| * Attribute Descriptor_Size:: |
| * Attribute Elaborated:: |
| * Attribute Elab_Body:: |
| * Attribute Elab_Spec:: |
| * Attribute Elab_Subp_Body:: |
| * Attribute Emax:: |
| * Attribute Enabled:: |
| * Attribute Enum_Rep:: |
| * Attribute Enum_Val:: |
| * Attribute Epsilon:: |
| * Attribute Fast_Math:: |
| * Attribute Fixed_Value:: |
| * Attribute From_Any:: |
| * Attribute Has_Access_Values:: |
| * Attribute Has_Discriminants:: |
| * Attribute Img:: |
| * Attribute Integer_Value:: |
| * Attribute Invalid_Value:: |
| * Attribute Iterable:: |
| * Attribute Large:: |
| * Attribute Library_Level:: |
| * Attribute Lock_Free:: |
| * Attribute Loop_Entry:: |
| * Attribute Machine_Size:: |
| * Attribute Mantissa:: |
| * Attribute Maximum_Alignment:: |
| * Attribute Mechanism_Code:: |
| * Attribute Null_Parameter:: |
| * Attribute Object_Size:: |
| * Attribute Old:: |
| * Attribute Passed_By_Reference:: |
| * Attribute Pool_Address:: |
| * Attribute Range_Length:: |
| * Attribute Ref:: |
| * Attribute Restriction_Set:: |
| * Attribute Result:: |
| * Attribute Safe_Emax:: |
| * Attribute Safe_Large:: |
| * Attribute Safe_Small:: |
| * Attribute Scalar_Storage_Order:: |
| * Attribute Simple_Storage_Pool:: |
| * Attribute Small:: |
| * Attribute Storage_Unit:: |
| * Attribute Stub_Type:: |
| * Attribute System_Allocator_Alignment:: |
| * Attribute Target_Name:: |
| * Attribute To_Address:: |
| * Attribute To_Any:: |
| * Attribute Type_Class:: |
| * Attribute Type_Key:: |
| * Attribute TypeCode:: |
| * Attribute UET_Address:: |
| * Attribute Unconstrained_Array:: |
| * Attribute Universal_Literal_String:: |
| * Attribute Unrestricted_Access:: |
| * Attribute Update:: |
| * Attribute Valid_Scalars:: |
| * Attribute VADS_Size:: |
| * Attribute Value_Size:: |
| * Attribute Wchar_T_Size:: |
| * Attribute Word_Size:: |
| |
| Standard and Implementation Defined Restrictions |
| |
| * Partition-Wide Restrictions:: |
| * Program Unit Level Restrictions:: |
| |
| Partition-Wide Restrictions |
| |
| * Immediate_Reclamation:: |
| * Max_Asynchronous_Select_Nesting:: |
| * Max_Entry_Queue_Length:: |
| * Max_Protected_Entries:: |
| * Max_Select_Alternatives:: |
| * Max_Storage_At_Blocking:: |
| * Max_Task_Entries:: |
| * Max_Tasks:: |
| * No_Abort_Statements:: |
| * No_Access_Parameter_Allocators:: |
| * No_Access_Subprograms:: |
| * No_Allocators:: |
| * No_Anonymous_Allocators:: |
| * No_Calendar:: |
| * No_Coextensions:: |
| * No_Default_Initialization:: |
| * No_Delay:: |
| * No_Dependence:: |
| * No_Direct_Boolean_Operators:: |
| * No_Dispatch:: |
| * No_Dispatching_Calls:: |
| * No_Dynamic_Attachment:: |
| * No_Dynamic_Priorities:: |
| * No_Entry_Calls_In_Elaboration_Code:: |
| * No_Enumeration_Maps:: |
| * No_Exception_Handlers:: |
| * No_Exception_Propagation:: |
| * No_Exception_Registration:: |
| * No_Exceptions:: |
| * No_Finalization:: |
| * No_Fixed_Point:: |
| * No_Floating_Point:: |
| * No_Implicit_Conditionals:: |
| * No_Implicit_Dynamic_Code:: |
| * No_Implicit_Heap_Allocations:: |
| * No_Implicit_Loops:: |
| * No_Initialize_Scalars:: |
| * No_IO:: |
| * No_Local_Allocators:: |
| * No_Local_Protected_Objects:: |
| * No_Local_Timing_Events:: |
| * No_Long_Long_Integers:: |
| * No_Multiple_Elaboration:: |
| * No_Nested_Finalization:: |
| * No_Protected_Type_Allocators:: |
| * No_Protected_Types:: |
| * No_Recursion:: |
| * No_Reentrancy:: |
| * No_Relative_Delay:: |
| * No_Requeue_Statements:: |
| * No_Secondary_Stack:: |
| * No_Select_Statements:: |
| * No_Specific_Termination_Handlers:: |
| * No_Specification_of_Aspect:: |
| * No_Standard_Allocators_After_Elaboration:: |
| * No_Standard_Storage_Pools:: |
| * No_Stream_Optimizations:: |
| * No_Streams:: |
| * No_Task_Allocators:: |
| * No_Task_Attributes_Package:: |
| * No_Task_Hierarchy:: |
| * No_Task_Termination:: |
| * No_Tasking:: |
| * No_Terminate_Alternatives:: |
| * No_Unchecked_Access:: |
| * No_Use_Of_Entity:: |
| * Simple_Barriers:: |
| * Static_Priorities:: |
| * Static_Storage_Size:: |
| |
| Program Unit Level Restrictions |
| |
| * No_Elaboration_Code:: |
| * No_Entry_Queue:: |
| * No_Implementation_Aspect_Specifications:: |
| * No_Implementation_Attributes:: |
| * No_Implementation_Identifiers:: |
| * No_Implementation_Pragmas:: |
| * No_Implementation_Restrictions:: |
| * No_Implementation_Units:: |
| * No_Implicit_Aliasing:: |
| * No_Obsolescent_Features:: |
| * No_Wide_Characters:: |
| * SPARK_05:: |
| |
| Implementation Advice |
| |
| * RM 1.1.3(20); Error Detection: RM 1 1 3 20 Error Detection. |
| * RM 1.1.3(31); Child Units: RM 1 1 3 31 Child Units. |
| * RM 1.1.5(12); Bounded Errors: RM 1 1 5 12 Bounded Errors. |
| * RM 2.8(16); Pragmas: RM 2 8 16 Pragmas. |
| * RM 2.8(17-19); Pragmas: RM 2 8 17-19 Pragmas. |
| * RM 3.5.2(5); Alternative Character Sets: RM 3 5 2 5 Alternative Character Sets. |
| * RM 3.5.4(28); Integer Types: RM 3 5 4 28 Integer Types. |
| * RM 3.5.4(29); Integer Types: RM 3 5 4 29 Integer Types. |
| * RM 3.5.5(8); Enumeration Values: RM 3 5 5 8 Enumeration Values. |
| * RM 3.5.7(17); Float Types: RM 3 5 7 17 Float Types. |
| * RM 3.6.2(11); Multidimensional Arrays: RM 3 6 2 11 Multidimensional Arrays. |
| * RM 9.6(30-31); Duration'Small: RM 9 6 30-31 Duration'Small. |
| * RM 10.2.1(12); Consistent Representation: RM 10 2 1 12 Consistent Representation. |
| * RM 11.4.1(19); Exception Information: RM 11 4 1 19 Exception Information. |
| * RM 11.5(28); Suppression of Checks: RM 11 5 28 Suppression of Checks. |
| * RM 13.1 (21-24); Representation Clauses: RM 13 1 21-24 Representation Clauses. |
| * RM 13.2(6-8); Packed Types: RM 13 2 6-8 Packed Types. |
| * RM 13.3(14-19); Address Clauses: RM 13 3 14-19 Address Clauses. |
| * RM 13.3(29-35); Alignment Clauses: RM 13 3 29-35 Alignment Clauses. |
| * RM 13.3(42-43); Size Clauses: RM 13 3 42-43 Size Clauses. |
| * RM 13.3(50-56); Size Clauses: RM 13 3 50-56 Size Clauses. |
| * RM 13.3(71-73); Component Size Clauses: RM 13 3 71-73 Component Size Clauses. |
| * RM 13.4(9-10); Enumeration Representation Clauses: RM 13 4 9-10 Enumeration Representation Clauses. |
| * RM 13.5.1(17-22); Record Representation Clauses: RM 13 5 1 17-22 Record Representation Clauses. |
| * RM 13.5.2(5); Storage Place Attributes: RM 13 5 2 5 Storage Place Attributes. |
| * RM 13.5.3(7-8); Bit Ordering: RM 13 5 3 7-8 Bit Ordering. |
| * RM 13.7(37); Address as Private: RM 13 7 37 Address as Private. |
| * RM 13.7.1(16); Address Operations: RM 13 7 1 16 Address Operations. |
| * RM 13.9(14-17); Unchecked Conversion: RM 13 9 14-17 Unchecked Conversion. |
| * RM 13.11(23-25); Implicit Heap Usage: RM 13 11 23-25 Implicit Heap Usage. |
| * RM 13.11.2(17); Unchecked Deallocation: RM 13 11 2 17 Unchecked Deallocation. |
| * RM 13.13.2(17); Stream Oriented Attributes: RM 13 13 2 17 Stream Oriented Attributes. |
| * RM A.1(52); Names of Predefined Numeric Types: RM A 1 52 Names of Predefined Numeric Types. |
| * RM A.3.2(49); Ada.Characters.Handling: RM A 3 2 49 Ada Characters Handling. |
| * RM A.4.4(106); Bounded-Length String Handling: RM A 4 4 106 Bounded-Length String Handling. |
| * RM A.5.2(46-47); Random Number Generation: RM A 5 2 46-47 Random Number Generation. |
| * RM A.10.7(23); Get_Immediate: RM A 10 7 23 Get_Immediate. |
| * RM B.1(39-41); Pragma Export: RM B 1 39-41 Pragma Export. |
| * RM B.2(12-13); Package Interfaces: RM B 2 12-13 Package Interfaces. |
| * RM B.3(63-71); Interfacing with C: RM B 3 63-71 Interfacing with C. |
| * RM B.4(95-98); Interfacing with COBOL: RM B 4 95-98 Interfacing with COBOL. |
| * RM B.5(22-26); Interfacing with Fortran: RM B 5 22-26 Interfacing with Fortran. |
| * RM C.1(3-5); Access to Machine Operations: RM C 1 3-5 Access to Machine Operations. |
| * RM C.1(10-16); Access to Machine Operations: RM C 1 10-16 Access to Machine Operations. |
| * RM C.3(28); Interrupt Support: RM C 3 28 Interrupt Support. |
| * RM C.3.1(20-21); Protected Procedure Handlers: RM C 3 1 20-21 Protected Procedure Handlers. |
| * RM C.3.2(25); Package Interrupts: RM C 3 2 25 Package Interrupts. |
| * RM C.4(14); Pre-elaboration Requirements: RM C 4 14 Pre-elaboration Requirements. |
| * RM C.5(8); Pragma Discard_Names: RM C 5 8 Pragma Discard_Names. |
| * RM C.7.2(30); The Package Task_Attributes: RM C 7 2 30 The Package Task_Attributes. |
| * RM D.3(17); Locking Policies: RM D 3 17 Locking Policies. |
| * RM D.4(16); Entry Queuing Policies: RM D 4 16 Entry Queuing Policies. |
| * RM D.6(9-10); Preemptive Abort: RM D 6 9-10 Preemptive Abort. |
| * RM D.7(21); Tasking Restrictions: RM D 7 21 Tasking Restrictions. |
| * RM D.8(47-49); Monotonic Time: RM D 8 47-49 Monotonic Time. |
| * RM E.5(28-29); Partition Communication Subsystem: RM E 5 28-29 Partition Communication Subsystem. |
| * RM F(7); COBOL Support: RM F 7 COBOL Support. |
| * RM F.1(2); Decimal Radix Support: RM F 1 2 Decimal Radix Support. |
| * RM G; Numerics: RM G Numerics. |
| * RM G.1.1(56-58); Complex Types: RM G 1 1 56-58 Complex Types. |
| * RM G.1.2(49); Complex Elementary Functions: RM G 1 2 49 Complex Elementary Functions. |
| * RM G.2.4(19); Accuracy Requirements: RM G 2 4 19 Accuracy Requirements. |
| * RM G.2.6(15); Complex Arithmetic Accuracy: RM G 2 6 15 Complex Arithmetic Accuracy. |
| * RM H.6(15/2); Pragma Partition_Elaboration_Policy: RM H 6 15/2 Pragma Partition_Elaboration_Policy. |
| |
| Intrinsic Subprograms |
| |
| * Intrinsic Operators:: |
| * Compilation_Date:: |
| * Compilation_Time:: |
| * Enclosing_Entity:: |
| * Exception_Information:: |
| * Exception_Message:: |
| * Exception_Name:: |
| * File:: |
| * Line:: |
| * Shifts and Rotates:: |
| * Source_Location:: |
| |
| Representation Clauses and Pragmas |
| |
| * Alignment Clauses:: |
| * Size Clauses:: |
| * Storage_Size Clauses:: |
| * Size of Variant Record Objects:: |
| * Biased Representation:: |
| * Value_Size and Object_Size Clauses:: |
| * Component_Size Clauses:: |
| * Bit_Order Clauses:: |
| * Effect of Bit_Order on Byte Ordering:: |
| * Pragma Pack for Arrays:: |
| * Pragma Pack for Records:: |
| * Record Representation Clauses:: |
| * Handling of Records with Holes:: |
| * Enumeration Clauses:: |
| * Address Clauses:: |
| * Use of Address Clauses for Memory-Mapped I/O:: |
| * Effect of Convention on Representation:: |
| * Conventions and Anonymous Access Types:: |
| * Determining the Representations chosen by GNAT:: |
| |
| The Implementation of Standard I/O |
| |
| * Standard I/O Packages:: |
| * FORM Strings:: |
| * Direct_IO:: |
| * Sequential_IO:: |
| * Text_IO:: |
| * Wide_Text_IO:: |
| * Wide_Wide_Text_IO:: |
| * Stream_IO:: |
| * Text Translation:: |
| * Shared Files:: |
| * Filenames encoding:: |
| * File content encoding:: |
| * Open Modes:: |
| * Operations on C Streams:: |
| * Interfacing to C Streams:: |
| |
| Text_IO |
| |
| * Stream Pointer Positioning:: |
| * Reading and Writing Non-Regular Files:: |
| * Get_Immediate:: |
| * Treating Text_IO Files as Streams:: |
| * Text_IO Extensions:: |
| * Text_IO Facilities for Unbounded Strings:: |
| |
| Wide_Text_IO |
| |
| * Stream Pointer Positioning: Stream Pointer Positioning<2>. |
| * Reading and Writing Non-Regular Files: Reading and Writing Non-Regular Files<2>. |
| |
| Wide_Wide_Text_IO |
| |
| * Stream Pointer Positioning: Stream Pointer Positioning<3>. |
| * Reading and Writing Non-Regular Files: Reading and Writing Non-Regular Files<3>. |
| |
| The GNAT Library |
| |
| * Ada.Characters.Latin_9 (a-chlat9.ads): Ada Characters Latin_9 a-chlat9 ads. |
| * Ada.Characters.Wide_Latin_1 (a-cwila1.ads): Ada Characters Wide_Latin_1 a-cwila1 ads. |
| * Ada.Characters.Wide_Latin_9 (a-cwila1.ads): Ada Characters Wide_Latin_9 a-cwila1 ads. |
| * Ada.Characters.Wide_Wide_Latin_1 (a-chzla1.ads): Ada Characters Wide_Wide_Latin_1 a-chzla1 ads. |
| * Ada.Characters.Wide_Wide_Latin_9 (a-chzla9.ads): Ada Characters Wide_Wide_Latin_9 a-chzla9 ads. |
| * Ada.Containers.Formal_Doubly_Linked_Lists (a-cfdlli.ads): Ada Containers Formal_Doubly_Linked_Lists a-cfdlli ads. |
| * Ada.Containers.Formal_Hashed_Maps (a-cfhama.ads): Ada Containers Formal_Hashed_Maps a-cfhama ads. |
| * Ada.Containers.Formal_Hashed_Sets (a-cfhase.ads): Ada Containers Formal_Hashed_Sets a-cfhase ads. |
| * Ada.Containers.Formal_Ordered_Maps (a-cforma.ads): Ada Containers Formal_Ordered_Maps a-cforma ads. |
| * Ada.Containers.Formal_Ordered_Sets (a-cforse.ads): Ada Containers Formal_Ordered_Sets a-cforse ads. |
| * Ada.Containers.Formal_Vectors (a-cofove.ads): Ada Containers Formal_Vectors a-cofove ads. |
| * Ada.Containers.Formal_Indefinite_Vectors (a-cfinve.ads): Ada Containers Formal_Indefinite_Vectors a-cfinve ads. |
| * Ada.Containers.Bounded_Holders (a-coboho.ads): Ada Containers Bounded_Holders a-coboho ads. |
| * Ada.Command_Line.Environment (a-colien.ads): Ada Command_Line Environment a-colien ads. |
| * Ada.Command_Line.Remove (a-colire.ads): Ada Command_Line Remove a-colire ads. |
| * Ada.Command_Line.Response_File (a-clrefi.ads): Ada Command_Line Response_File a-clrefi ads. |
| * Ada.Direct_IO.C_Streams (a-diocst.ads): Ada Direct_IO C_Streams a-diocst ads. |
| * Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads): Ada Exceptions Is_Null_Occurrence a-einuoc ads. |
| * Ada.Exceptions.Last_Chance_Handler (a-elchha.ads): Ada Exceptions Last_Chance_Handler a-elchha ads. |
| * Ada.Exceptions.Traceback (a-exctra.ads): Ada Exceptions Traceback a-exctra ads. |
| * Ada.Sequential_IO.C_Streams (a-siocst.ads): Ada Sequential_IO C_Streams a-siocst ads. |
| * Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads): Ada Streams Stream_IO C_Streams a-ssicst ads. |
| * Ada.Strings.Unbounded.Text_IO (a-suteio.ads): Ada Strings Unbounded Text_IO a-suteio ads. |
| * Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads): Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads. |
| * Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads): Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads. |
| * Ada.Text_IO.C_Streams (a-tiocst.ads): Ada Text_IO C_Streams a-tiocst ads. |
| * Ada.Text_IO.Reset_Standard_Files (a-tirsfi.ads): Ada Text_IO Reset_Standard_Files a-tirsfi ads. |
| * Ada.Wide_Characters.Unicode (a-wichun.ads): Ada Wide_Characters Unicode a-wichun ads. |
| * Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads): Ada Wide_Text_IO C_Streams a-wtcstr ads. |
| * Ada.Wide_Text_IO.Reset_Standard_Files (a-wrstfi.ads): Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads. |
| * Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads): Ada Wide_Wide_Characters Unicode a-zchuni ads. |
| * Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads): Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads. |
| * Ada.Wide_Wide_Text_IO.Reset_Standard_Files (a-zrstfi.ads): Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads. |
| * GNAT.Altivec (g-altive.ads): GNAT Altivec g-altive ads. |
| * GNAT.Altivec.Conversions (g-altcon.ads): GNAT Altivec Conversions g-altcon ads. |
| * GNAT.Altivec.Vector_Operations (g-alveop.ads): GNAT Altivec Vector_Operations g-alveop ads. |
| * GNAT.Altivec.Vector_Types (g-alvety.ads): GNAT Altivec Vector_Types g-alvety ads. |
| * GNAT.Altivec.Vector_Views (g-alvevi.ads): GNAT Altivec Vector_Views g-alvevi ads. |
| * GNAT.Array_Split (g-arrspl.ads): GNAT Array_Split g-arrspl ads. |
| * GNAT.AWK (g-awk.ads): GNAT AWK g-awk ads. |
| * GNAT.Bounded_Buffers (g-boubuf.ads): GNAT Bounded_Buffers g-boubuf ads. |
| * GNAT.Bounded_Mailboxes (g-boumai.ads): GNAT Bounded_Mailboxes g-boumai ads. |
| * GNAT.Bubble_Sort (g-bubsor.ads): GNAT Bubble_Sort g-bubsor ads. |
| * GNAT.Bubble_Sort_A (g-busora.ads): GNAT Bubble_Sort_A g-busora ads. |
| * GNAT.Bubble_Sort_G (g-busorg.ads): GNAT Bubble_Sort_G g-busorg ads. |
| * GNAT.Byte_Order_Mark (g-byorma.ads): GNAT Byte_Order_Mark g-byorma ads. |
| * GNAT.Byte_Swapping (g-bytswa.ads): GNAT Byte_Swapping g-bytswa ads. |
| * GNAT.Calendar (g-calend.ads): GNAT Calendar g-calend ads. |
| * GNAT.Calendar.Time_IO (g-catiio.ads): GNAT Calendar Time_IO g-catiio ads. |
| * GNAT.CRC32 (g-crc32.ads): GNAT CRC32 g-crc32 ads. |
| * GNAT.Case_Util (g-casuti.ads): GNAT Case_Util g-casuti ads. |
| * GNAT.CGI (g-cgi.ads): GNAT CGI g-cgi ads. |
| * GNAT.CGI.Cookie (g-cgicoo.ads): GNAT CGI Cookie g-cgicoo ads. |
| * GNAT.CGI.Debug (g-cgideb.ads): GNAT CGI Debug g-cgideb ads. |
| * GNAT.Command_Line (g-comlin.ads): GNAT Command_Line g-comlin ads. |
| * GNAT.Compiler_Version (g-comver.ads): GNAT Compiler_Version g-comver ads. |
| * GNAT.Ctrl_C (g-ctrl_c.ads): GNAT Ctrl_C g-ctrl_c ads. |
| * GNAT.Current_Exception (g-curexc.ads): GNAT Current_Exception g-curexc ads. |
| * GNAT.Debug_Pools (g-debpoo.ads): GNAT Debug_Pools g-debpoo ads. |
| * GNAT.Debug_Utilities (g-debuti.ads): GNAT Debug_Utilities g-debuti ads. |
| * GNAT.Decode_String (g-decstr.ads): GNAT Decode_String g-decstr ads. |
| * GNAT.Decode_UTF8_String (g-deutst.ads): GNAT Decode_UTF8_String g-deutst ads. |
| * GNAT.Directory_Operations (g-dirope.ads): GNAT Directory_Operations g-dirope ads. |
| * GNAT.Directory_Operations.Iteration (g-diopit.ads): GNAT Directory_Operations Iteration g-diopit ads. |
| * GNAT.Dynamic_HTables (g-dynhta.ads): GNAT Dynamic_HTables g-dynhta ads. |
| * GNAT.Dynamic_Tables (g-dyntab.ads): GNAT Dynamic_Tables g-dyntab ads. |
| * GNAT.Encode_String (g-encstr.ads): GNAT Encode_String g-encstr ads. |
| * GNAT.Encode_UTF8_String (g-enutst.ads): GNAT Encode_UTF8_String g-enutst ads. |
| * GNAT.Exception_Actions (g-excact.ads): GNAT Exception_Actions g-excact ads. |
| * GNAT.Exception_Traces (g-exctra.ads): GNAT Exception_Traces g-exctra ads. |
| * GNAT.Exceptions (g-expect.ads): GNAT Exceptions g-expect ads. |
| * GNAT.Expect (g-expect.ads): GNAT Expect g-expect ads. |
| * GNAT.Expect.TTY (g-exptty.ads): GNAT Expect TTY g-exptty ads. |
| * GNAT.Float_Control (g-flocon.ads): GNAT Float_Control g-flocon ads. |
| * GNAT.Formatted_String (g-forstr.ads): GNAT Formatted_String g-forstr ads. |
| * GNAT.Heap_Sort (g-heasor.ads): GNAT Heap_Sort g-heasor ads. |
| * GNAT.Heap_Sort_A (g-hesora.ads): GNAT Heap_Sort_A g-hesora ads. |
| * GNAT.Heap_Sort_G (g-hesorg.ads): GNAT Heap_Sort_G g-hesorg ads. |
| * GNAT.HTable (g-htable.ads): GNAT HTable g-htable ads. |
| * GNAT.IO (g-io.ads): GNAT IO g-io ads. |
| * GNAT.IO_Aux (g-io_aux.ads): GNAT IO_Aux g-io_aux ads. |
| * GNAT.Lock_Files (g-locfil.ads): GNAT Lock_Files g-locfil ads. |
| * GNAT.MBBS_Discrete_Random (g-mbdira.ads): GNAT MBBS_Discrete_Random g-mbdira ads. |
| * GNAT.MBBS_Float_Random (g-mbflra.ads): GNAT MBBS_Float_Random g-mbflra ads. |
| * GNAT.MD5 (g-md5.ads): GNAT MD5 g-md5 ads. |
| * GNAT.Memory_Dump (g-memdum.ads): GNAT Memory_Dump g-memdum ads. |
| * GNAT.Most_Recent_Exception (g-moreex.ads): GNAT Most_Recent_Exception g-moreex ads. |
| * GNAT.OS_Lib (g-os_lib.ads): GNAT OS_Lib g-os_lib ads. |
| * GNAT.Perfect_Hash_Generators (g-pehage.ads): GNAT Perfect_Hash_Generators g-pehage ads. |
| * GNAT.Random_Numbers (g-rannum.ads): GNAT Random_Numbers g-rannum ads. |
| * GNAT.Regexp (g-regexp.ads): GNAT Regexp g-regexp ads. |
| * GNAT.Registry (g-regist.ads): GNAT Registry g-regist ads. |
| * GNAT.Regpat (g-regpat.ads): GNAT Regpat g-regpat ads. |
| * GNAT.Rewrite_Data (g-rewdat.ads): GNAT Rewrite_Data g-rewdat ads. |
| * GNAT.Secondary_Stack_Info (g-sestin.ads): GNAT Secondary_Stack_Info g-sestin ads. |
| * GNAT.Semaphores (g-semaph.ads): GNAT Semaphores g-semaph ads. |
| * GNAT.Serial_Communications (g-sercom.ads): GNAT Serial_Communications g-sercom ads. |
| * GNAT.SHA1 (g-sha1.ads): GNAT SHA1 g-sha1 ads. |
| * GNAT.SHA224 (g-sha224.ads): GNAT SHA224 g-sha224 ads. |
| * GNAT.SHA256 (g-sha256.ads): GNAT SHA256 g-sha256 ads. |
| * GNAT.SHA384 (g-sha384.ads): GNAT SHA384 g-sha384 ads. |
| * GNAT.SHA512 (g-sha512.ads): GNAT SHA512 g-sha512 ads. |
| * GNAT.Signals (g-signal.ads): GNAT Signals g-signal ads. |
| * GNAT.Sockets (g-socket.ads): GNAT Sockets g-socket ads. |
| * GNAT.Source_Info (g-souinf.ads): GNAT Source_Info g-souinf ads. |
| * GNAT.Spelling_Checker (g-speche.ads): GNAT Spelling_Checker g-speche ads. |
| * GNAT.Spelling_Checker_Generic (g-spchge.ads): GNAT Spelling_Checker_Generic g-spchge ads. |
| * GNAT.Spitbol.Patterns (g-spipat.ads): GNAT Spitbol Patterns g-spipat ads. |
| * GNAT.Spitbol (g-spitbo.ads): GNAT Spitbol g-spitbo ads. |
| * GNAT.Spitbol.Table_Boolean (g-sptabo.ads): GNAT Spitbol Table_Boolean g-sptabo ads. |
| * GNAT.Spitbol.Table_Integer (g-sptain.ads): GNAT Spitbol Table_Integer g-sptain ads. |
| * GNAT.Spitbol.Table_VString (g-sptavs.ads): GNAT Spitbol Table_VString g-sptavs ads. |
| * GNAT.SSE (g-sse.ads): GNAT SSE g-sse ads. |
| * GNAT.SSE.Vector_Types (g-ssvety.ads): GNAT SSE Vector_Types g-ssvety ads. |
| * GNAT.Strings (g-string.ads): GNAT Strings g-string ads. |
| * GNAT.String_Split (g-strspl.ads): GNAT String_Split g-strspl ads. |
| * GNAT.Table (g-table.ads): GNAT Table g-table ads. |
| * GNAT.Task_Lock (g-tasloc.ads): GNAT Task_Lock g-tasloc ads. |
| * GNAT.Time_Stamp (g-timsta.ads): GNAT Time_Stamp g-timsta ads. |
| * GNAT.Threads (g-thread.ads): GNAT Threads g-thread ads. |
| * GNAT.Traceback (g-traceb.ads): GNAT Traceback g-traceb ads. |
| * GNAT.Traceback.Symbolic (g-trasym.ads): GNAT Traceback Symbolic g-trasym ads. |
| * GNAT.UTF_32 (g-table.ads): GNAT UTF_32 g-table ads. |
| * GNAT.Wide_Spelling_Checker (g-u3spch.ads): GNAT Wide_Spelling_Checker g-u3spch ads. |
| * GNAT.Wide_Spelling_Checker (g-wispch.ads): GNAT Wide_Spelling_Checker g-wispch ads. |
| * GNAT.Wide_String_Split (g-wistsp.ads): GNAT Wide_String_Split g-wistsp ads. |
| * GNAT.Wide_Wide_Spelling_Checker (g-zspche.ads): GNAT Wide_Wide_Spelling_Checker g-zspche ads. |
| * GNAT.Wide_Wide_String_Split (g-zistsp.ads): GNAT Wide_Wide_String_Split g-zistsp ads. |
| * Interfaces.C.Extensions (i-cexten.ads): Interfaces C Extensions i-cexten ads. |
| * Interfaces.C.Streams (i-cstrea.ads): Interfaces C Streams i-cstrea ads. |
| * Interfaces.Packed_Decimal (i-pacdec.ads): Interfaces Packed_Decimal i-pacdec ads. |
| * Interfaces.VxWorks (i-vxwork.ads): Interfaces VxWorks i-vxwork ads. |
| * Interfaces.VxWorks.IO (i-vxwoio.ads): Interfaces VxWorks IO i-vxwoio ads. |
| * System.Address_Image (s-addima.ads): System Address_Image s-addima ads. |
| * System.Assertions (s-assert.ads): System Assertions s-assert ads. |
| * System.Atomic_Counters (s-atocou.ads): System Atomic_Counters s-atocou ads. |
| * System.Memory (s-memory.ads): System Memory s-memory ads. |
| * System.Multiprocessors (s-multip.ads): System Multiprocessors s-multip ads. |
| * System.Multiprocessors.Dispatching_Domains (s-mudido.ads): System Multiprocessors Dispatching_Domains s-mudido ads. |
| * System.Partition_Interface (s-parint.ads): System Partition_Interface s-parint ads. |
| * System.Pool_Global (s-pooglo.ads): System Pool_Global s-pooglo ads. |
| * System.Pool_Local (s-pooloc.ads): System Pool_Local s-pooloc ads. |
| * System.Restrictions (s-restri.ads): System Restrictions s-restri ads. |
| * System.Rident (s-rident.ads): System Rident s-rident ads. |
| * System.Strings.Stream_Ops (s-ststop.ads): System Strings Stream_Ops s-ststop ads. |
| * System.Unsigned_Types (s-unstyp.ads): System Unsigned_Types s-unstyp ads. |
| * System.Wch_Cnv (s-wchcnv.ads): System Wch_Cnv s-wchcnv ads. |
| * System.Wch_Con (s-wchcon.ads): System Wch_Con s-wchcon ads. |
| |
| Interfacing to Other Languages |
| |
| * Interfacing to C:: |
| * Interfacing to C++:: |
| * Interfacing to COBOL:: |
| * Interfacing to Fortran:: |
| * Interfacing to non-GNAT Ada code:: |
| |
| Implementation of Specific Ada Features |
| |
| * Machine Code Insertions:: |
| * GNAT Implementation of Tasking:: |
| * GNAT Implementation of Shared Passive Packages:: |
| * Code Generation for Array Aggregates:: |
| * The Size of Discriminated Records with Default Discriminants:: |
| * Strict Conformance to the Ada Reference Manual:: |
| |
| GNAT Implementation of Tasking |
| |
| * Mapping Ada Tasks onto the Underlying Kernel Threads:: |
| * Ensuring Compliance with the Real-Time Annex:: |
| |
| Code Generation for Array Aggregates |
| |
| * Static constant aggregates with static bounds:: |
| * Constant aggregates with unconstrained nominal types:: |
| * Aggregates with static bounds:: |
| * Aggregates with non-static bounds:: |
| * Aggregates in assignment statements:: |
| |
| Obsolescent Features |
| |
| * pragma No_Run_Time:: |
| * pragma Ravenscar:: |
| * pragma Restricted_Run_Time:: |
| * pragma Task_Info:: |
| * package System.Task_Info (s-tasinf.ads): package System Task_Info s-tasinf ads. |
| |
| Compatibility and Porting Guide |
| |
| * Writing Portable Fixed-Point Declarations:: |
| * Compatibility with Ada 83:: |
| * Compatibility between Ada 95 and Ada 2005:: |
| * Implementation-dependent characteristics:: |
| * Compatibility with Other Ada Systems:: |
| * Representation Clauses:: |
| * Compatibility with HP Ada 83:: |
| |
| Compatibility with Ada 83 |
| |
| * Legal Ada 83 programs that are illegal in Ada 95:: |
| * More deterministic semantics:: |
| * Changed semantics:: |
| * Other language compatibility issues:: |
| |
| Implementation-dependent characteristics |
| |
| * Implementation-defined pragmas:: |
| * Implementation-defined attributes:: |
| * Libraries:: |
| * Elaboration order:: |
| * Target-specific aspects:: |
| |
| @end detailmenu |
| @end menu |
| |
| @node About This Guide,Implementation Defined Pragmas,Top,Top |
| @anchor{gnat_rm/about_this_guide about-this-guide}@anchor{2}@anchor{gnat_rm/about_this_guide doc}@anchor{3}@anchor{gnat_rm/about_this_guide gnat-reference-manual}@anchor{4}@anchor{gnat_rm/about_this_guide id1}@anchor{5} |
| @chapter About This Guide |
| |
| |
| |
| This manual contains useful information in writing programs using the |
| GNAT compiler. It includes information on implementation dependent |
| characteristics of GNAT, including all the information required by |
| Annex M of the Ada language standard. |
| |
| GNAT implements Ada 95, Ada 2005 and Ada 2012, and it may also be |
| invoked in Ada 83 compatibility mode. |
| By default, GNAT assumes Ada 2012, |
| but you can override with a compiler switch |
| to explicitly specify the language version. |
| (Please refer to the @emph{GNAT User's Guide} for details on these switches.) |
| Throughout this manual, references to 'Ada' without a year suffix |
| apply to all the Ada versions of the language. |
| |
| Ada is designed to be highly portable. |
| In general, a program will have the same effect even when compiled by |
| different compilers on different platforms. |
| However, since Ada is designed to be used in a |
| wide variety of applications, it also contains a number of system |
| dependent features to be used in interfacing to the external world. |
| .. index:: Implementation-dependent features |
| |
| @geindex Portability |
| |
| Note: Any program that makes use of implementation-dependent features |
| may be non-portable. You should follow good programming practice and |
| isolate and clearly document any sections of your program that make use |
| of these features in a non-portable manner. |
| |
| @menu |
| * What This Reference Manual Contains:: |
| * Conventions:: |
| * Related Information:: |
| |
| @end menu |
| |
| @node What This Reference Manual Contains,Conventions,,About This Guide |
| @anchor{gnat_rm/about_this_guide what-this-reference-manual-contains}@anchor{6} |
| @section What This Reference Manual Contains |
| |
| |
| This reference manual contains the following chapters: |
| |
| |
| @itemize * |
| |
| @item |
| @ref{7,,Implementation Defined Pragmas}, lists GNAT implementation-dependent |
| pragmas, which can be used to extend and enhance the functionality of the |
| compiler. |
| |
| @item |
| @ref{8,,Implementation Defined Attributes}, lists GNAT |
| implementation-dependent attributes, which can be used to extend and |
| enhance the functionality of the compiler. |
| |
| @item |
| @ref{9,,Standard and Implementation Defined Restrictions}, lists GNAT |
| implementation-dependent restrictions, which can be used to extend and |
| enhance the functionality of the compiler. |
| |
| @item |
| @ref{a,,Implementation Advice}, provides information on generally |
| desirable behavior which are not requirements that all compilers must |
| follow since it cannot be provided on all systems, or which may be |
| undesirable on some systems. |
| |
| @item |
| @ref{b,,Implementation Defined Characteristics}, provides a guide to |
| minimizing implementation dependent features. |
| |
| @item |
| @ref{c,,Intrinsic Subprograms}, describes the intrinsic subprograms |
| implemented by GNAT, and how they can be imported into user |
| application programs. |
| |
| @item |
| @ref{d,,Representation Clauses and Pragmas}, describes in detail the |
| way that GNAT represents data, and in particular the exact set |
| of representation clauses and pragmas that is accepted. |
| |
| @item |
| @ref{e,,Standard Library Routines}, provides a listing of packages and a |
| brief description of the functionality that is provided by Ada's |
| extensive set of standard library routines as implemented by GNAT. |
| |
| @item |
| @ref{f,,The Implementation of Standard I/O}, details how the GNAT |
| implementation of the input-output facilities. |
| |
| @item |
| @ref{10,,The GNAT Library}, is a catalog of packages that complement |
| the Ada predefined library. |
| |
| @item |
| @ref{11,,Interfacing to Other Languages}, describes how programs |
| written in Ada using GNAT can be interfaced to other programming |
| languages. |
| |
| @item |
| @ref{12,,Specialized Needs Annexes}, describes the GNAT implementation of all |
| of the specialized needs annexes. |
| |
| @item |
| @ref{13,,Implementation of Specific Ada Features}, discusses issues related |
| to GNAT's implementation of machine code insertions, tasking, and several |
| other features. |
| |
| @item |
| @ref{14,,Implementation of Ada 2012 Features}, describes the status of the |
| GNAT implementation of the Ada 2012 language standard. |
| |
| @item |
| @ref{15,,Obsolescent Features} documents implementation dependent features, |
| including pragmas and attributes, which are considered obsolescent, since |
| there are other preferred ways of achieving the same results. These |
| obsolescent forms are retained for backwards compatibility. |
| |
| @item |
| @ref{16,,Compatibility and Porting Guide} presents some guidelines for |
| developing portable Ada code, describes the compatibility issues that |
| may arise between GNAT and other Ada compilation systems (including those |
| for Ada 83), and shows how GNAT can expedite porting applications |
| developed in other Ada environments. |
| |
| @item |
| @ref{1,,GNU Free Documentation License} contains the license for this document. |
| @end itemize |
| |
| @geindex Ada 95 Language Reference Manual |
| |
| @geindex Ada 2005 Language Reference Manual |
| |
| This reference manual assumes a basic familiarity with the Ada 95 language, as |
| described in the |
| @cite{International Standard ANSI/ISO/IEC-8652:1995}. |
| It does not require knowledge of the new features introduced by Ada 2005 or |
| Ada 2012. |
| All three reference manuals are included in the GNAT documentation |
| package. |
| |
| @node Conventions,Related Information,What This Reference Manual Contains,About This Guide |
| @anchor{gnat_rm/about_this_guide conventions}@anchor{17} |
| @section Conventions |
| |
| |
| @geindex Conventions |
| @geindex typographical |
| |
| @geindex Typographical conventions |
| |
| Following are examples of the typographical and graphic conventions used |
| in this guide: |
| |
| |
| @itemize * |
| |
| @item |
| @cite{Functions}, @cite{utility program names}, @cite{standard names}, |
| and @cite{classes}. |
| |
| @item |
| @cite{Option flags} |
| |
| @item |
| @code{File names} |
| |
| @item |
| @cite{Variables} |
| |
| @item |
| @emph{Emphasis} |
| |
| @item |
| [optional information or parameters] |
| |
| @item |
| Examples are described by text |
| |
| @example |
| and then shown this way. |
| @end example |
| |
| @item |
| Commands that are entered by the user are shown as preceded by a prompt string |
| comprising the @code{$} character followed by a space. |
| @end itemize |
| |
| @node Related Information,,Conventions,About This Guide |
| @anchor{gnat_rm/about_this_guide related-information}@anchor{18} |
| @section Related Information |
| |
| |
| See the following documents for further information on GNAT: |
| |
| |
| @itemize * |
| |
| @item |
| @cite{GNAT User's Guide for Native Platforms}, |
| which provides information on how to use the |
| GNAT development environment. |
| |
| @item |
| @cite{Ada 95 Reference Manual}, the Ada 95 programming language standard. |
| |
| @item |
| @cite{Ada 95 Annotated Reference Manual}, which is an annotated version |
| of the Ada 95 standard. The annotations describe |
| detailed aspects of the design decision, and in particular contain useful |
| sections on Ada 83 compatibility. |
| |
| @item |
| @cite{Ada 2005 Reference Manual}, the Ada 2005 programming language standard. |
| |
| @item |
| @cite{Ada 2005 Annotated Reference Manual}, which is an annotated version |
| of the Ada 2005 standard. The annotations describe |
| detailed aspects of the design decision. |
| |
| @item |
| @cite{Ada 2012 Reference Manual}, the Ada 2012 programming language standard. |
| |
| @item |
| @cite{DEC Ada@comma{} Technical Overview and Comparison on DIGITAL Platforms}, |
| which contains specific information on compatibility between GNAT and |
| DEC Ada 83 systems. |
| |
| @item |
| @cite{DEC Ada@comma{} Language Reference Manual}, part number AA-PYZAB-TK, which |
| describes in detail the pragmas and attributes provided by the DEC Ada 83 |
| compiler system. |
| @end itemize |
| |
| @node Implementation Defined Pragmas,Implementation Defined Aspects,About This Guide,Top |
| @anchor{gnat_rm/implementation_defined_pragmas implementation-defined-pragmas}@anchor{7}@anchor{gnat_rm/implementation_defined_pragmas doc}@anchor{19}@anchor{gnat_rm/implementation_defined_pragmas id1}@anchor{1a} |
| @chapter Implementation Defined Pragmas |
| |
| |
| Ada defines a set of pragmas that can be used to supply additional |
| information to the compiler. These language defined pragmas are |
| implemented in GNAT and work as described in the Ada Reference Manual. |
| |
| In addition, Ada allows implementations to define additional pragmas |
| whose meaning is defined by the implementation. GNAT provides a number |
| of these implementation-defined pragmas, which can be used to extend |
| and enhance the functionality of the compiler. This section of the GNAT |
| Reference Manual describes these additional pragmas. |
| |
| Note that any program using these pragmas might not be portable to other |
| compilers (although GNAT implements this set of pragmas on all |
| platforms). Therefore if portability to other compilers is an important |
| consideration, the use of these pragmas should be minimized. |
| |
| @menu |
| * Pragma Abort_Defer:: |
| * Pragma Abstract_State:: |
| * Pragma Ada_83:: |
| * Pragma Ada_95:: |
| * Pragma Ada_05:: |
| * Pragma Ada_2005:: |
| * Pragma Ada_12:: |
| * Pragma Ada_2012:: |
| * Pragma Allow_Integer_Address:: |
| * Pragma Annotate:: |
| * Pragma Assert:: |
| * Pragma Assert_And_Cut:: |
| * Pragma Assertion_Policy:: |
| * Pragma Assume:: |
| * Pragma Assume_No_Invalid_Values:: |
| * Pragma Async_Readers:: |
| * Pragma Async_Writers:: |
| * Pragma Attribute_Definition:: |
| * Pragma C_Pass_By_Copy:: |
| * Pragma Check:: |
| * Pragma Check_Float_Overflow:: |
| * Pragma Check_Name:: |
| * Pragma Check_Policy:: |
| * Pragma CIL_Constructor:: |
| * Pragma Comment:: |
| * Pragma Common_Object:: |
| * Pragma Compile_Time_Error:: |
| * Pragma Compile_Time_Warning:: |
| * Pragma Compiler_Unit:: |
| * Pragma Compiler_Unit_Warning:: |
| * Pragma Complete_Representation:: |
| * Pragma Complex_Representation:: |
| * Pragma Component_Alignment:: |
| * Pragma Contract_Cases:: |
| * Pragma Convention_Identifier:: |
| * Pragma CPP_Class:: |
| * Pragma CPP_Constructor:: |
| * Pragma CPP_Virtual:: |
| * Pragma CPP_Vtable:: |
| * Pragma CPU:: |
| * Pragma Debug:: |
| * Pragma Debug_Policy:: |
| * Pragma Default_Scalar_Storage_Order:: |
| * Pragma Default_Storage_Pool:: |
| * Pragma Depends:: |
| * Pragma Detect_Blocking:: |
| * Pragma Disable_Atomic_Synchronization:: |
| * Pragma Dispatching_Domain:: |
| * Pragma Effective_Reads:: |
| * Pragma Effective_Writes:: |
| * Pragma Elaboration_Checks:: |
| * Pragma Eliminate:: |
| * Pragma Enable_Atomic_Synchronization:: |
| * Pragma Export_Function:: |
| * Pragma Export_Object:: |
| * Pragma Export_Procedure:: |
| * Pragma Export_Value:: |
| * Pragma Export_Valued_Procedure:: |
| * Pragma Extend_System:: |
| * Pragma Extensions_Allowed:: |
| * Pragma External:: |
| * Pragma External_Name_Casing:: |
| * Pragma Fast_Math:: |
| * Pragma Favor_Top_Level:: |
| * Pragma Finalize_Storage_Only:: |
| * Pragma Float_Representation:: |
| * Pragma Global:: |
| * Pragma Ident:: |
| * Pragma Ignore_Pragma:: |
| * Pragma Implementation_Defined:: |
| * Pragma Implemented:: |
| * Pragma Implicit_Packing:: |
| * Pragma Import_Function:: |
| * Pragma Import_Object:: |
| * Pragma Import_Procedure:: |
| * Pragma Import_Valued_Procedure:: |
| * Pragma Independent:: |
| * Pragma Independent_Components:: |
| * Pragma Initial_Condition:: |
| * Pragma Initialize_Scalars:: |
| * Pragma Initializes:: |
| * Pragma Inline_Always:: |
| * Pragma Inline_Generic:: |
| * Pragma Interface:: |
| * Pragma Interface_Name:: |
| * Pragma Interrupt_Handler:: |
| * Pragma Interrupt_State:: |
| * Pragma Invariant:: |
| * Pragma Java_Constructor:: |
| * Pragma Java_Interface:: |
| * Pragma Keep_Names:: |
| * Pragma License:: |
| * Pragma Link_With:: |
| * Pragma Linker_Alias:: |
| * Pragma Linker_Constructor:: |
| * Pragma Linker_Destructor:: |
| * Pragma Linker_Section:: |
| * Pragma Lock_Free:: |
| * Pragma Loop_Invariant:: |
| * Pragma Loop_Optimize:: |
| * Pragma Loop_Variant:: |
| * Pragma Machine_Attribute:: |
| * Pragma Main:: |
| * Pragma Main_Storage:: |
| * Pragma No_Body:: |
| * Pragma No_Elaboration_Code_All:: |
| * Pragma No_Inline:: |
| * Pragma No_Return:: |
| * Pragma No_Run_Time:: |
| * Pragma No_Strict_Aliasing:: |
| * Pragma No_Tagged_Streams:: |
| * Pragma Normalize_Scalars:: |
| * Pragma Obsolescent:: |
| * Pragma Optimize_Alignment:: |
| * Pragma Ordered:: |
| * Pragma Overflow_Mode:: |
| * Pragma Overriding_Renamings:: |
| * Pragma Partition_Elaboration_Policy:: |
| * Pragma Part_Of:: |
| * Pragma Passive:: |
| * Pragma Persistent_BSS:: |
| * Pragma Polling:: |
| * Pragma Post:: |
| * Pragma Postcondition:: |
| * Pragma Post_Class:: |
| * Pragma Pre:: |
| * Pragma Precondition:: |
| * Pragma Predicate:: |
| * Pragma Preelaborable_Initialization:: |
| * Pragma Prefix_Exception_Messages:: |
| * Pragma Pre_Class:: |
| * Pragma Priority_Specific_Dispatching:: |
| * Pragma Profile:: |
| * Pragma Profile_Warnings:: |
| * Pragma Propagate_Exceptions:: |
| * Pragma Provide_Shift_Operators:: |
| * Pragma Psect_Object:: |
| * Pragma Pure_Function:: |
| * Pragma Rational:: |
| * Pragma Ravenscar:: |
| * Pragma Refined_Depends:: |
| * Pragma Refined_Global:: |
| * Pragma Refined_Post:: |
| * Pragma Refined_State:: |
| * Pragma Relative_Deadline:: |
| * Pragma Remote_Access_Type:: |
| * Pragma Restricted_Run_Time:: |
| * Pragma Restriction_Warnings:: |
| * Pragma Reviewable:: |
| * Pragma Share_Generic:: |
| * Pragma Shared:: |
| * Pragma Short_Circuit_And_Or:: |
| * Pragma Short_Descriptors:: |
| * Pragma Simple_Storage_Pool_Type:: |
| * Pragma Source_File_Name:: |
| * Pragma Source_File_Name_Project:: |
| * Pragma Source_Reference:: |
| * Pragma SPARK_Mode:: |
| * Pragma Static_Elaboration_Desired:: |
| * Pragma Stream_Convert:: |
| * Pragma Style_Checks:: |
| * Pragma Subtitle:: |
| * Pragma Suppress:: |
| * Pragma Suppress_All:: |
| * Pragma Suppress_Debug_Info:: |
| * Pragma Suppress_Exception_Locations:: |
| * Pragma Suppress_Initialization:: |
| * Pragma Task_Name:: |
| * Pragma Task_Storage:: |
| * Pragma Test_Case:: |
| * Pragma Thread_Local_Storage:: |
| * Pragma Time_Slice:: |
| * Pragma Title:: |
| * Pragma Type_Invariant:: |
| * Pragma Type_Invariant_Class:: |
| * Pragma Unchecked_Union:: |
| * Pragma Unevaluated_Use_Of_Old:: |
| * Pragma Unimplemented_Unit:: |
| * Pragma Universal_Aliasing:: |
| * Pragma Universal_Data:: |
| * Pragma Unmodified:: |
| * Pragma Unreferenced:: |
| * Pragma Unreferenced_Objects:: |
| * Pragma Unreserve_All_Interrupts:: |
| * Pragma Unsuppress:: |
| * Pragma Use_VADS_Size:: |
| * Pragma Validity_Checks:: |
| * Pragma Volatile:: |
| * Pragma Warning_As_Error:: |
| * Pragma Warnings:: |
| * Pragma Weak_External:: |
| * Pragma Wide_Character_Encoding:: |
| |
| @end menu |
| |
| @node Pragma Abort_Defer,Pragma Abstract_State,,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-abort-defer}@anchor{1b} |
| @section Pragma Abort_Defer |
| |
| |
| @geindex Deferring aborts |
| |
| Syntax: |
| |
| @example |
| pragma Abort_Defer; |
| @end example |
| |
| This pragma must appear at the start of the statement sequence of a |
| handled sequence of statements (right after the @cite{begin}). It has |
| the effect of deferring aborts for the sequence of statements (but not |
| for the declarations or handlers, if any, associated with this statement |
| sequence). |
| |
| @node Pragma Abstract_State,Pragma Ada_83,Pragma Abort_Defer,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-abstract-state}@anchor{1c} |
| @section Pragma Abstract_State |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.4. |
| |
| @node Pragma Ada_83,Pragma Ada_95,Pragma Abstract_State,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ada-83}@anchor{1d} |
| @section Pragma Ada_83 |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ada_83; |
| @end example |
| |
| A configuration pragma that establishes Ada 83 mode for the unit to |
| which it applies, regardless of the mode set by the command line |
| switches. In Ada 83 mode, GNAT attempts to be as compatible with |
| the syntax and semantics of Ada 83, as defined in the original Ada |
| 83 Reference Manual as possible. In particular, the keywords added by Ada 95 |
| and Ada 2005 are not recognized, optional package bodies are allowed, |
| and generics may name types with unknown discriminants without using |
| the @cite{(<>)} notation. In addition, some but not all of the additional |
| restrictions of Ada 83 are enforced. |
| |
| Ada 83 mode is intended for two purposes. Firstly, it allows existing |
| Ada 83 code to be compiled and adapted to GNAT with less effort. |
| Secondly, it aids in keeping code backwards compatible with Ada 83. |
| However, there is no guarantee that code that is processed correctly |
| by GNAT in Ada 83 mode will in fact compile and execute with an Ada |
| 83 compiler, since GNAT does not enforce all the additional checks |
| required by Ada 83. |
| |
| @node Pragma Ada_95,Pragma Ada_05,Pragma Ada_83,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ada-95}@anchor{1e} |
| @section Pragma Ada_95 |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ada_95; |
| @end example |
| |
| A configuration pragma that establishes Ada 95 mode for the unit to which |
| it applies, regardless of the mode set by the command line switches. |
| This mode is set automatically for the @cite{Ada} and @cite{System} |
| packages and their children, so you need not specify it in these |
| contexts. This pragma is useful when writing a reusable component that |
| itself uses Ada 95 features, but which is intended to be usable from |
| either Ada 83 or Ada 95 programs. |
| |
| @node Pragma Ada_05,Pragma Ada_2005,Pragma Ada_95,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ada-05}@anchor{1f} |
| @section Pragma Ada_05 |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ada_05; |
| pragma Ada_05 (local_NAME); |
| @end example |
| |
| A configuration pragma that establishes Ada 2005 mode for the unit to which |
| it applies, regardless of the mode set by the command line switches. |
| This pragma is useful when writing a reusable component that |
| itself uses Ada 2005 features, but which is intended to be usable from |
| either Ada 83 or Ada 95 programs. |
| |
| The one argument form (which is not a configuration pragma) |
| is used for managing the transition from |
| Ada 95 to Ada 2005 in the run-time library. If an entity is marked |
| as Ada_2005 only, then referencing the entity in Ada_83 or Ada_95 |
| mode will generate a warning. In addition, in Ada_83 or Ada_95 |
| mode, a preference rule is established which does not choose |
| such an entity unless it is unambiguously specified. This avoids |
| extra subprograms marked this way from generating ambiguities in |
| otherwise legal pre-Ada_2005 programs. The one argument form is |
| intended for exclusive use in the GNAT run-time library. |
| |
| @node Pragma Ada_2005,Pragma Ada_12,Pragma Ada_05,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2005}@anchor{20} |
| @section Pragma Ada_2005 |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ada_2005; |
| @end example |
| |
| This configuration pragma is a synonym for pragma Ada_05 and has the |
| same syntax and effect. |
| |
| @node Pragma Ada_12,Pragma Ada_2012,Pragma Ada_2005,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ada-12}@anchor{21} |
| @section Pragma Ada_12 |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ada_12; |
| pragma Ada_12 (local_NAME); |
| @end example |
| |
| A configuration pragma that establishes Ada 2012 mode for the unit to which |
| it applies, regardless of the mode set by the command line switches. |
| This mode is set automatically for the @cite{Ada} and @cite{System} |
| packages and their children, so you need not specify it in these |
| contexts. This pragma is useful when writing a reusable component that |
| itself uses Ada 2012 features, but which is intended to be usable from |
| Ada 83, Ada 95, or Ada 2005 programs. |
| |
| The one argument form, which is not a configuration pragma, |
| is used for managing the transition from Ada |
| 2005 to Ada 2012 in the run-time library. If an entity is marked |
| as Ada_201 only, then referencing the entity in any pre-Ada_2012 |
| mode will generate a warning. In addition, in any pre-Ada_2012 |
| mode, a preference rule is established which does not choose |
| such an entity unless it is unambiguously specified. This avoids |
| extra subprograms marked this way from generating ambiguities in |
| otherwise legal pre-Ada_2012 programs. The one argument form is |
| intended for exclusive use in the GNAT run-time library. |
| |
| @node Pragma Ada_2012,Pragma Allow_Integer_Address,Pragma Ada_12,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2012}@anchor{22} |
| @section Pragma Ada_2012 |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ada_2012; |
| @end example |
| |
| This configuration pragma is a synonym for pragma Ada_12 and has the |
| same syntax and effect. |
| |
| @node Pragma Allow_Integer_Address,Pragma Annotate,Pragma Ada_2012,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-allow-integer-address}@anchor{23} |
| @section Pragma Allow_Integer_Address |
| |
| |
| Syntax: |
| |
| @example |
| pragma Allow_Integer_Address; |
| @end example |
| |
| In almost all versions of GNAT, @cite{System.Address} is a private |
| type in accordance with the implementation advice in the RM. This |
| means that integer values, |
| in particular integer literals, are not allowed as address values. |
| If the configuration pragma |
| @cite{Allow_Integer_Address} is given, then integer expressions may |
| be used anywhere a value of type @cite{System.Address} is required. |
| The effect is to introduce an implicit unchecked conversion from the |
| integer value to type @cite{System.Address}. The reverse case of using |
| an address where an integer type is required is handled analogously. |
| The following example compiles without errors: |
| |
| @example |
| pragma Allow_Integer_Address; |
| with System; use System; |
| package AddrAsInt is |
| X : Integer; |
| Y : Integer; |
| for X'Address use 16#1240#; |
| for Y use at 16#3230#; |
| m : Address := 16#4000#; |
| n : constant Address := 4000; |
| p : constant Address := Address (X + Y); |
| v : Integer := y'Address; |
| w : constant Integer := Integer (Y'Address); |
| type R is new integer; |
| RR : R := 1000; |
| Z : Integer; |
| for Z'Address use RR; |
| end AddrAsInt; |
| @end example |
| |
| Note that pragma @cite{Allow_Integer_Address} is ignored if @cite{System.Address} |
| is not a private type. In implementations of @cite{GNAT} where |
| System.Address is a visible integer type, |
| this pragma serves no purpose but is ignored |
| rather than rejected to allow common sets of sources to be used |
| in the two situations. |
| |
| @node Pragma Annotate,Pragma Assert,Pragma Allow_Integer_Address,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-annotate}@anchor{24} |
| @section Pragma Annotate |
| |
| |
| Syntax: |
| |
| @example |
| pragma Annotate (IDENTIFIER [, IDENTIFIER @{, ARG@}] [, entity => local_NAME]); |
| |
| ARG ::= NAME | EXPRESSION |
| @end example |
| |
| This pragma is used to annotate programs. @cite{identifier} identifies |
| the type of annotation. GNAT verifies that it is an identifier, but does |
| not otherwise analyze it. The second optional identifier is also left |
| unanalyzed, and by convention is used to control the action of the tool to |
| which the annotation is addressed. The remaining @cite{arg} arguments |
| can be either string literals or more generally expressions. |
| String literals are assumed to be either of type |
| @cite{Standard.String} or else @cite{Wide_String} or @cite{Wide_Wide_String} |
| depending on the character literals they contain. |
| All other kinds of arguments are analyzed as expressions, and must be |
| unambiguous. The last argument if present must have the identifier |
| @cite{Entity} and GNAT verifies that a local name is given. |
| |
| The analyzed pragma is retained in the tree, but not otherwise processed |
| by any part of the GNAT compiler, except to generate corresponding note |
| lines in the generated ALI file. For the format of these note lines, see |
| the compiler source file lib-writ.ads. This pragma is intended for use by |
| external tools, including ASIS. The use of pragma Annotate does not |
| affect the compilation process in any way. This pragma may be used as |
| a configuration pragma. |
| |
| @node Pragma Assert,Pragma Assert_And_Cut,Pragma Annotate,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-assert}@anchor{25} |
| @section Pragma Assert |
| |
| |
| Syntax: |
| |
| @example |
| pragma Assert ( |
| boolean_EXPRESSION |
| [, string_EXPRESSION]); |
| @end example |
| |
| The effect of this pragma depends on whether the corresponding command |
| line switch is set to activate assertions. The pragma expands into code |
| equivalent to the following: |
| |
| @example |
| if assertions-enabled then |
| if not boolean_EXPRESSION then |
| System.Assertions.Raise_Assert_Failure |
| (string_EXPRESSION); |
| end if; |
| end if; |
| @end example |
| |
| The string argument, if given, is the message that will be associated |
| with the exception occurrence if the exception is raised. If no second |
| argument is given, the default message is @cite{file}:@cite{nnn}, |
| where @cite{file} is the name of the source file containing the assert, |
| and @cite{nnn} is the line number of the assert. A pragma is not a |
| statement, so if a statement sequence contains nothing but a pragma |
| assert, then a null statement is required in addition, as in: |
| |
| @example |
| ... |
| if J > 3 then |
| pragma Assert (K > 3, "Bad value for K"); |
| null; |
| end if; |
| @end example |
| |
| Note that, as with the @cite{if} statement to which it is equivalent, the |
| type of the expression is either @cite{Standard.Boolean}, or any type derived |
| from this standard type. |
| |
| Assert checks can be either checked or ignored. By default they are ignored. |
| They will be checked if either the command line switch @emph{-gnata} is |
| used, or if an @cite{Assertion_Policy} or @cite{Check_Policy} pragma is used |
| to enable @cite{Assert_Checks}. |
| |
| If assertions are ignored, then there |
| is no run-time effect (and in particular, any side effects from the |
| expression will not occur at run time). (The expression is still |
| analyzed at compile time, and may cause types to be frozen if they are |
| mentioned here for the first time). |
| |
| If assertions are checked, then the given expression is tested, and if |
| it is @cite{False} then @cite{System.Assertions.Raise_Assert_Failure} is called |
| which results in the raising of @cite{Assert_Failure} with the given message. |
| |
| You should generally avoid side effects in the expression arguments of |
| this pragma, because these side effects will turn on and off with the |
| setting of the assertions mode, resulting in assertions that have an |
| effect on the program. However, the expressions are analyzed for |
| semantic correctness whether or not assertions are enabled, so turning |
| assertions on and off cannot affect the legality of a program. |
| |
| Note that the implementation defined policy @cite{DISABLE}, given in a |
| pragma @cite{Assertion_Policy}, can be used to suppress this semantic analysis. |
| |
| Note: this is a standard language-defined pragma in versions |
| of Ada from 2005 on. In GNAT, it is implemented in all versions |
| of Ada, and the DISABLE policy is an implementation-defined |
| addition. |
| |
| @node Pragma Assert_And_Cut,Pragma Assertion_Policy,Pragma Assert,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-assert-and-cut}@anchor{26} |
| @section Pragma Assert_And_Cut |
| |
| |
| Syntax: |
| |
| @example |
| pragma Assert_And_Cut ( |
| boolean_EXPRESSION |
| [, string_EXPRESSION]); |
| @end example |
| |
| The effect of this pragma is identical to that of pragma @cite{Assert}, |
| except that in an @cite{Assertion_Policy} pragma, the identifier |
| @cite{Assert_And_Cut} is used to control whether it is ignored or checked |
| (or disabled). |
| |
| The intention is that this be used within a subprogram when the |
| given test expresion sums up all the work done so far in the |
| subprogram, so that the rest of the subprogram can be verified |
| (informally or formally) using only the entry preconditions, |
| and the expression in this pragma. This allows dividing up |
| a subprogram into sections for the purposes of testing or |
| formal verification. The pragma also serves as useful |
| documentation. |
| |
| @node Pragma Assertion_Policy,Pragma Assume,Pragma Assert_And_Cut,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-assertion-policy}@anchor{27} |
| @section Pragma Assertion_Policy |
| |
| |
| Syntax: |
| |
| @example |
| pragma Assertion_Policy (CHECK | DISABLE | IGNORE); |
| |
| pragma Assertion_Policy ( |
| ASSERTION_KIND => POLICY_IDENTIFIER |
| @{, ASSERTION_KIND => POLICY_IDENTIFIER@}); |
| |
| ASSERTION_KIND ::= RM_ASSERTION_KIND | ID_ASSERTION_KIND |
| |
| RM_ASSERTION_KIND ::= Assert | |
| Static_Predicate | |
| Dynamic_Predicate | |
| Pre | |
| Pre'Class | |
| Post | |
| Post'Class | |
| Type_Invariant | |
| Type_Invariant'Class |
| |
| ID_ASSERTION_KIND ::= Assertions | |
| Assert_And_Cut | |
| Assume | |
| Contract_Cases | |
| Debug | |
| Invariant | |
| Invariant'Class | |
| Loop_Invariant | |
| Loop_Variant | |
| Postcondition | |
| Precondition | |
| Predicate | |
| Refined_Post | |
| Statement_Assertions |
| |
| POLICY_IDENTIFIER ::= Check | Disable | Ignore |
| @end example |
| |
| This is a standard Ada 2012 pragma that is available as an |
| implementation-defined pragma in earlier versions of Ada. |
| The assertion kinds @cite{RM_ASSERTION_KIND} are those defined in |
| the Ada standard. The assertion kinds @cite{ID_ASSERTION_KIND} |
| are implementation defined additions recognized by the GNAT compiler. |
| |
| The pragma applies in both cases to pragmas and aspects with matching |
| names, e.g. @cite{Pre} applies to the Pre aspect, and @cite{Precondition} |
| applies to both the @cite{Precondition} pragma |
| and the aspect @cite{Precondition}. Note that the identifiers for |
| pragmas Pre_Class and Post_Class are Pre'Class and Post'Class (not |
| Pre_Class and Post_Class), since these pragmas are intended to be |
| identical to the corresponding aspects). |
| |
| If the policy is @cite{CHECK}, then assertions are enabled, i.e. |
| the corresponding pragma or aspect is activated. |
| If the policy is @cite{IGNORE}, then assertions are ignored, i.e. |
| the corresponding pragma or aspect is deactivated. |
| This pragma overrides the effect of the @emph{-gnata} switch on the |
| command line. |
| |
| The implementation defined policy @cite{DISABLE} is like |
| @cite{IGNORE} except that it completely disables semantic |
| checking of the corresponding pragma or aspect. This is |
| useful when the pragma or aspect argument references subprograms |
| in a with'ed package which is replaced by a dummy package |
| for the final build. |
| |
| The implementation defined assertion kind @cite{Assertions} applies to all |
| assertion kinds. The form with no assertion kind given implies this |
| choice, so it applies to all assertion kinds (RM defined, and |
| implementation defined). |
| |
| The implementation defined assertion kind @cite{Statement_Assertions} |
| applies to @cite{Assert}, @cite{Assert_And_Cut}, |
| @cite{Assume}, @cite{Loop_Invariant}, and @cite{Loop_Variant}. |
| |
| @node Pragma Assume,Pragma Assume_No_Invalid_Values,Pragma Assertion_Policy,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-assume}@anchor{28} |
| @section Pragma Assume |
| |
| |
| Syntax: |
| |
| @example |
| pragma Assume ( |
| boolean_EXPRESSION |
| [, string_EXPRESSION]); |
| @end example |
| |
| The effect of this pragma is identical to that of pragma @cite{Assert}, |
| except that in an @cite{Assertion_Policy} pragma, the identifier |
| @cite{Assume} is used to control whether it is ignored or checked |
| (or disabled). |
| |
| The intention is that this be used for assumptions about the |
| external environment. So you cannot expect to verify formally |
| or informally that the condition is met, this must be |
| established by examining things outside the program itself. |
| For example, we may have code that depends on the size of |
| @cite{Long_Long_Integer} being at least 64. So we could write: |
| |
| @example |
| pragma Assume (Long_Long_Integer'Size >= 64); |
| @end example |
| |
| This assumption cannot be proved from the program itself, |
| but it acts as a useful run-time check that the assumption |
| is met, and documents the need to ensure that it is met by |
| reference to information outside the program. |
| |
| @node Pragma Assume_No_Invalid_Values,Pragma Async_Readers,Pragma Assume,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-assume-no-invalid-values}@anchor{29} |
| @section Pragma Assume_No_Invalid_Values |
| |
| |
| @geindex Invalid representations |
| |
| @geindex Invalid values |
| |
| Syntax: |
| |
| @example |
| pragma Assume_No_Invalid_Values (On | Off); |
| @end example |
| |
| This is a configuration pragma that controls the assumptions made by the |
| compiler about the occurrence of invalid representations (invalid values) |
| in the code. |
| |
| The default behavior (corresponding to an Off argument for this pragma), is |
| to assume that values may in general be invalid unless the compiler can |
| prove they are valid. Consider the following example: |
| |
| @example |
| V1 : Integer range 1 .. 10; |
| V2 : Integer range 11 .. 20; |
| ... |
| for J in V2 .. V1 loop |
| ... |
| end loop; |
| @end example |
| |
| if V1 and V2 have valid values, then the loop is known at compile |
| time not to execute since the lower bound must be greater than the |
| upper bound. However in default mode, no such assumption is made, |
| and the loop may execute. If @cite{Assume_No_Invalid_Values (On)} |
| is given, the compiler will assume that any occurrence of a variable |
| other than in an explicit @cite{'Valid} test always has a valid |
| value, and the loop above will be optimized away. |
| |
| The use of @cite{Assume_No_Invalid_Values (On)} is appropriate if |
| you know your code is free of uninitialized variables and other |
| possible sources of invalid representations, and may result in |
| more efficient code. A program that accesses an invalid representation |
| with this pragma in effect is erroneous, so no guarantees can be made |
| about its behavior. |
| |
| It is peculiar though permissible to use this pragma in conjunction |
| with validity checking (-gnatVa). In such cases, accessing invalid |
| values will generally give an exception, though formally the program |
| is erroneous so there are no guarantees that this will always be the |
| case, and it is recommended that these two options not be used together. |
| |
| @node Pragma Async_Readers,Pragma Async_Writers,Pragma Assume_No_Invalid_Values,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{2a} |
| @section Pragma Async_Readers |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.2. |
| |
| @node Pragma Async_Writers,Pragma Attribute_Definition,Pragma Async_Readers,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-async-writers}@anchor{2b} |
| @section Pragma Async_Writers |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.2. |
| |
| @node Pragma Attribute_Definition,Pragma C_Pass_By_Copy,Pragma Async_Writers,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-attribute-definition}@anchor{2c} |
| @section Pragma Attribute_Definition |
| |
| |
| Syntax: |
| |
| @example |
| pragma Attribute_Definition |
| ([Attribute =>] ATTRIBUTE_DESIGNATOR, |
| [Entity =>] LOCAL_NAME, |
| [Expression =>] EXPRESSION | NAME); |
| @end example |
| |
| If @cite{Attribute} is a known attribute name, this pragma is equivalent to |
| the attribute definition clause: |
| |
| @example |
| for Entity'Attribute use Expression; |
| @end example |
| |
| If @cite{Attribute} is not a recognized attribute name, the pragma is |
| ignored, and a warning is emitted. This allows source |
| code to be written that takes advantage of some new attribute, while remaining |
| compilable with earlier compilers. |
| |
| @node Pragma C_Pass_By_Copy,Pragma Check,Pragma Attribute_Definition,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-c-pass-by-copy}@anchor{2d} |
| @section Pragma C_Pass_By_Copy |
| |
| |
| @geindex Passing by copy |
| |
| Syntax: |
| |
| @example |
| pragma C_Pass_By_Copy |
| ([Max_Size =>] static_integer_EXPRESSION); |
| @end example |
| |
| Normally the default mechanism for passing C convention records to C |
| convention subprograms is to pass them by reference, as suggested by RM |
| B.3(69). Use the configuration pragma @cite{C_Pass_By_Copy} to change |
| this default, by requiring that record formal parameters be passed by |
| copy if all of the following conditions are met: |
| |
| |
| @itemize * |
| |
| @item |
| The size of the record type does not exceed the value specified for |
| @cite{Max_Size}. |
| |
| @item |
| The record type has @cite{Convention C}. |
| |
| @item |
| The formal parameter has this record type, and the subprogram has a |
| foreign (non-Ada) convention. |
| @end itemize |
| |
| If these conditions are met the argument is passed by copy; i.e., in a |
| manner consistent with what C expects if the corresponding formal in the |
| C prototype is a struct (rather than a pointer to a struct). |
| |
| You can also pass records by copy by specifying the convention |
| @cite{C_Pass_By_Copy} for the record type, or by using the extended |
| @cite{Import} and @cite{Export} pragmas, which allow specification of |
| passing mechanisms on a parameter by parameter basis. |
| |
| @node Pragma Check,Pragma Check_Float_Overflow,Pragma C_Pass_By_Copy,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-check}@anchor{2e} |
| @section Pragma Check |
| |
| |
| @geindex Assertions |
| |
| @geindex Named assertions |
| |
| Syntax: |
| |
| @example |
| pragma Check ( |
| [Name =>] CHECK_KIND, |
| [Check =>] Boolean_EXPRESSION |
| [, [Message =>] string_EXPRESSION] ); |
| |
| CHECK_KIND ::= IDENTIFIER | |
| Pre'Class | |
| Post'Class | |
| Type_Invariant'Class | |
| Invariant'Class |
| @end example |
| |
| This pragma is similar to the predefined pragma @cite{Assert} except that an |
| extra identifier argument is present. In conjunction with pragma |
| @cite{Check_Policy}, this can be used to define groups of assertions that can |
| be independently controlled. The identifier @cite{Assertion} is special, it |
| refers to the normal set of pragma @cite{Assert} statements. |
| |
| Checks introduced by this pragma are normally deactivated by default. They can |
| be activated either by the command line option @emph{-gnata}, which turns on |
| all checks, or individually controlled using pragma @cite{Check_Policy}. |
| |
| The identifiers @cite{Assertions} and @cite{Statement_Assertions} are not |
| permitted as check kinds, since this would cause confusion with the use |
| of these identifiers in @cite{Assertion_Policy} and @cite{Check_Policy} |
| pragmas, where they are used to refer to sets of assertions. |
| |
| @node Pragma Check_Float_Overflow,Pragma Check_Name,Pragma Check,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-check-float-overflow}@anchor{2f} |
| @section Pragma Check_Float_Overflow |
| |
| |
| @geindex Floating-point overflow |
| |
| Syntax: |
| |
| @example |
| pragma Check_Float_Overflow; |
| @end example |
| |
| In Ada, the predefined floating-point types (@cite{Short_Float}, |
| @cite{Float}, @cite{Long_Float}, @cite{Long_Long_Float}) are |
| defined to be @emph{unconstrained}. This means that even though each |
| has a well-defined base range, an operation that delivers a result |
| outside this base range is not required to raise an exception. |
| This implementation permission accommodates the notion |
| of infinities in IEEE floating-point, and corresponds to the |
| efficient execution mode on most machines. GNAT will not raise |
| overflow exceptions on these machines; instead it will generate |
| infinities and NaN's as defined in the IEEE standard. |
| |
| Generating infinities, although efficient, is not always desirable. |
| Often the preferable approach is to check for overflow, even at the |
| (perhaps considerable) expense of run-time performance. |
| This can be accomplished by defining your own constrained floating-point subtypes -- i.e., by supplying explicit |
| range constraints -- and indeed such a subtype |
| can have the same base range as its base type. For example: |
| |
| @example |
| subtype My_Float is Float range Float'Range; |
| @end example |
| |
| Here @cite{My_Float} has the same range as |
| @cite{Float} but is constrained, so operations on |
| @cite{My_Float} values will be checked for overflow |
| against this range. |
| |
| This style will achieve the desired goal, but |
| it is often more convenient to be able to simply use |
| the standard predefined floating-point types as long |
| as overflow checking could be guaranteed. |
| The @cite{Check_Float_Overflow} |
| configuration pragma achieves this effect. If a unit is compiled |
| subject to this configuration pragma, then all operations |
| on predefined floating-point types including operations on |
| base types of these floating-point types will be treated as |
| though those types were constrained, and overflow checks |
| will be generated. The @cite{Constraint_Error} |
| exception is raised if the result is out of range. |
| |
| This mode can also be set by use of the compiler |
| switch @emph{-gnateF}. |
| |
| @node Pragma Check_Name,Pragma Check_Policy,Pragma Check_Float_Overflow,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-check-name}@anchor{30} |
| @section Pragma Check_Name |
| |
| |
| @geindex Defining check names |
| |
| @geindex Check names |
| @geindex defining |
| |
| Syntax: |
| |
| @example |
| pragma Check_Name (check_name_IDENTIFIER); |
| @end example |
| |
| This is a configuration pragma that defines a new implementation |
| defined check name (unless IDENTIFIER matches one of the predefined |
| check names, in which case the pragma has no effect). Check names |
| are global to a partition, so if two or more configuration pragmas |
| are present in a partition mentioning the same name, only one new |
| check name is introduced. |
| |
| An implementation defined check name introduced with this pragma may |
| be used in only three contexts: @cite{pragma Suppress}, |
| @cite{pragma Unsuppress}, |
| and as the prefix of a @cite{Check_Name'Enabled} attribute reference. For |
| any of these three cases, the check name must be visible. A check |
| name is visible if it is in the configuration pragmas applying to |
| the current unit, or if it appears at the start of any unit that |
| is part of the dependency set of the current unit (e.g., units that |
| are mentioned in @cite{with} clauses). |
| |
| Check names introduced by this pragma are subject to control by compiler |
| switches (in particular -gnatp) in the usual manner. |
| |
| @node Pragma Check_Policy,Pragma CIL_Constructor,Pragma Check_Name,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-check-policy}@anchor{31} |
| @section Pragma Check_Policy |
| |
| |
| @geindex Controlling assertions |
| |
| @geindex Assertions |
| @geindex control |
| |
| @geindex Check pragma control |
| |
| @geindex Named assertions |
| |
| Syntax: |
| |
| @example |
| pragma Check_Policy |
| ([Name =>] CHECK_KIND, |
| [Policy =>] POLICY_IDENTIFIER); |
| |
| pragma Check_Policy ( |
| CHECK_KIND => POLICY_IDENTIFIER |
| @{, CHECK_KIND => POLICY_IDENTIFIER@}); |
| |
| ASSERTION_KIND ::= RM_ASSERTION_KIND | ID_ASSERTION_KIND |
| |
| CHECK_KIND ::= IDENTIFIER | |
| Pre'Class | |
| Post'Class | |
| Type_Invariant'Class | |
| Invariant'Class |
| |
| The identifiers Name and Policy are not allowed as CHECK_KIND values. This |
| avoids confusion between the two possible syntax forms for this pragma. |
| |
| POLICY_IDENTIFIER ::= ON | OFF | CHECK | DISABLE | IGNORE |
| @end example |
| |
| This pragma is used to set the checking policy for assertions (specified |
| by aspects or pragmas), the @cite{Debug} pragma, or additional checks |
| to be checked using the @cite{Check} pragma. It may appear either as |
| a configuration pragma, or within a declarative part of package. In the |
| latter case, it applies from the point where it appears to the end of |
| the declarative region (like pragma @cite{Suppress}). |
| |
| The @cite{Check_Policy} pragma is similar to the |
| predefined @cite{Assertion_Policy} pragma, |
| and if the check kind corresponds to one of the assertion kinds that |
| are allowed by @cite{Assertion_Policy}, then the effect is identical. |
| |
| If the first argument is Debug, then the policy applies to Debug pragmas, |
| disabling their effect if the policy is @cite{OFF}, @cite{DISABLE}, or |
| @cite{IGNORE}, and allowing them to execute with normal semantics if |
| the policy is @cite{ON} or @cite{CHECK}. In addition if the policy is |
| @cite{DISABLE}, then the procedure call in @cite{Debug} pragmas will |
| be totally ignored and not analyzed semantically. |
| |
| Finally the first argument may be some other identifier than the above |
| possibilities, in which case it controls a set of named assertions |
| that can be checked using pragma @cite{Check}. For example, if the pragma: |
| |
| @example |
| pragma Check_Policy (Critical_Error, OFF); |
| @end example |
| |
| is given, then subsequent @cite{Check} pragmas whose first argument is also |
| @cite{Critical_Error} will be disabled. |
| |
| The check policy is @cite{OFF} to turn off corresponding checks, and @cite{ON} |
| to turn on corresponding checks. The default for a set of checks for which no |
| @cite{Check_Policy} is given is @cite{OFF} unless the compiler switch |
| @emph{-gnata} is given, which turns on all checks by default. |
| |
| The check policy settings @cite{CHECK} and @cite{IGNORE} are recognized |
| as synonyms for @cite{ON} and @cite{OFF}. These synonyms are provided for |
| compatibility with the standard @cite{Assertion_Policy} pragma. The check |
| policy setting @cite{DISABLE} causes the second argument of a corresponding |
| @cite{Check} pragma to be completely ignored and not analyzed. |
| |
| @node Pragma CIL_Constructor,Pragma Comment,Pragma Check_Policy,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-cil-constructor}@anchor{32} |
| @section Pragma CIL_Constructor |
| |
| |
| Syntax: |
| |
| @example |
| pragma CIL_Constructor ([Entity =>] function_LOCAL_NAME); |
| @end example |
| |
| This pragma is used to assert that the specified Ada function should be |
| mapped to the .NET constructor for some Ada tagged record type. |
| |
| See section 4.1 of the |
| @cite{GNAT User's Guide: Supplement for the .NET Platform.} |
| for related information. |
| |
| @node Pragma Comment,Pragma Common_Object,Pragma CIL_Constructor,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-comment}@anchor{33} |
| @section Pragma Comment |
| |
| |
| Syntax: |
| |
| @example |
| pragma Comment (static_string_EXPRESSION); |
| @end example |
| |
| This is almost identical in effect to pragma @cite{Ident}. It allows the |
| placement of a comment into the object file and hence into the |
| executable file if the operating system permits such usage. The |
| difference is that @cite{Comment}, unlike @cite{Ident}, has |
| no limitations on placement of the pragma (it can be placed |
| anywhere in the main source unit), and if more than one pragma |
| is used, all comments are retained. |
| |
| @node Pragma Common_Object,Pragma Compile_Time_Error,Pragma Comment,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-common-object}@anchor{34} |
| @section Pragma Common_Object |
| |
| |
| Syntax: |
| |
| @example |
| pragma Common_Object ( |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Size =>] EXTERNAL_SYMBOL] ); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| @end example |
| |
| This pragma enables the shared use of variables stored in overlaid |
| linker areas corresponding to the use of @cite{COMMON} |
| in Fortran. The single |
| object @cite{LOCAL_NAME} is assigned to the area designated by |
| the @cite{External} argument. |
| You may define a record to correspond to a series |
| of fields. The @cite{Size} argument |
| is syntax checked in GNAT, but otherwise ignored. |
| |
| @cite{Common_Object} is not supported on all platforms. If no |
| support is available, then the code generator will issue a message |
| indicating that the necessary attribute for implementation of this |
| pragma is not available. |
| |
| @node Pragma Compile_Time_Error,Pragma Compile_Time_Warning,Pragma Common_Object,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{35} |
| @section Pragma Compile_Time_Error |
| |
| |
| Syntax: |
| |
| @example |
| pragma Compile_Time_Error |
| (boolean_EXPRESSION, static_string_EXPRESSION); |
| @end example |
| |
| This pragma can be used to generate additional compile time |
| error messages. It |
| is particularly useful in generics, where errors can be issued for |
| specific problematic instantiations. The first parameter is a boolean |
| expression. The pragma is effective only if the value of this expression |
| is known at compile time, and has the value True. The set of expressions |
| whose values are known at compile time includes all static boolean |
| expressions, and also other values which the compiler can determine |
| at compile time (e.g., the size of a record type set by an explicit |
| size representation clause, or the value of a variable which was |
| initialized to a constant and is known not to have been modified). |
| If these conditions are met, an error message is generated using |
| the value given as the second argument. This string value may contain |
| embedded ASCII.LF characters to break the message into multiple lines. |
| |
| @node Pragma Compile_Time_Warning,Pragma Compiler_Unit,Pragma Compile_Time_Error,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-warning}@anchor{36} |
| @section Pragma Compile_Time_Warning |
| |
| |
| Syntax: |
| |
| @example |
| pragma Compile_Time_Warning |
| (boolean_EXPRESSION, static_string_EXPRESSION); |
| @end example |
| |
| Same as pragma Compile_Time_Error, except a warning is issued instead |
| of an error message. Note that if this pragma is used in a package that |
| is with'ed by a client, the client will get the warning even though it |
| is issued by a with'ed package (normally warnings in with'ed units are |
| suppressed, but this is a special exception to that rule). |
| |
| One typical use is within a generic where compile time known characteristics |
| of formal parameters are tested, and warnings given appropriately. Another use |
| with a first parameter of True is to warn a client about use of a package, |
| for example that it is not fully implemented. |
| |
| @node Pragma Compiler_Unit,Pragma Compiler_Unit_Warning,Pragma Compile_Time_Warning,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-compiler-unit}@anchor{37} |
| @section Pragma Compiler_Unit |
| |
| |
| Syntax: |
| |
| @example |
| pragma Compiler_Unit; |
| @end example |
| |
| This pragma is obsolete. It is equivalent to Compiler_Unit_Warning. It is |
| retained so that old versions of the GNAT run-time that use this pragma can |
| be compiled with newer versions of the compiler. |
| |
| @node Pragma Compiler_Unit_Warning,Pragma Complete_Representation,Pragma Compiler_Unit,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-compiler-unit-warning}@anchor{38} |
| @section Pragma Compiler_Unit_Warning |
| |
| |
| Syntax: |
| |
| @example |
| pragma Compiler_Unit_Warning; |
| @end example |
| |
| This pragma is intended only for internal use in the GNAT run-time library. |
| It indicates that the unit is used as part of the compiler build. The effect |
| is to generate warnings for the use of constructs (for example, conditional |
| expressions) that would cause trouble when bootstrapping using an older |
| version of GNAT. For the exact list of restrictions, see the compiler sources |
| and references to Check_Compiler_Unit. |
| |
| @node Pragma Complete_Representation,Pragma Complex_Representation,Pragma Compiler_Unit_Warning,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-complete-representation}@anchor{39} |
| @section Pragma Complete_Representation |
| |
| |
| Syntax: |
| |
| @example |
| pragma Complete_Representation; |
| @end example |
| |
| This pragma must appear immediately within a record representation |
| clause. Typical placements are before the first component clause |
| or after the last component clause. The effect is to give an error |
| message if any component is missing a component clause. This pragma |
| may be used to ensure that a record representation clause is |
| complete, and that this invariant is maintained if fields are |
| added to the record in the future. |
| |
| @node Pragma Complex_Representation,Pragma Component_Alignment,Pragma Complete_Representation,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-complex-representation}@anchor{3a} |
| @section Pragma Complex_Representation |
| |
| |
| Syntax: |
| |
| @example |
| pragma Complex_Representation |
| ([Entity =>] LOCAL_NAME); |
| @end example |
| |
| The @cite{Entity} argument must be the name of a record type which has |
| two fields of the same floating-point type. The effect of this pragma is |
| to force gcc to use the special internal complex representation form for |
| this record, which may be more efficient. Note that this may result in |
| the code for this type not conforming to standard ABI (application |
| binary interface) requirements for the handling of record types. For |
| example, in some environments, there is a requirement for passing |
| records by pointer, and the use of this pragma may result in passing |
| this type in floating-point registers. |
| |
| @node Pragma Component_Alignment,Pragma Contract_Cases,Pragma Complex_Representation,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-component-alignment}@anchor{3b} |
| @section Pragma Component_Alignment |
| |
| |
| @geindex Alignments of components |
| |
| @geindex Pragma Component_Alignment |
| |
| Syntax: |
| |
| @example |
| pragma Component_Alignment ( |
| [Form =>] ALIGNMENT_CHOICE |
| [, [Name =>] type_LOCAL_NAME]); |
| |
| ALIGNMENT_CHOICE ::= |
| Component_Size |
| | Component_Size_4 |
| | Storage_Unit |
| | Default |
| @end example |
| |
| Specifies the alignment of components in array or record types. |
| The meaning of the @cite{Form} argument is as follows: |
| |
| @quotation |
| |
| @geindex Component_Size (in pragma Component_Alignment) |
| @end quotation |
| |
| |
| @table @asis |
| |
| @item @emph{Component_Size} |
| |
| Aligns scalar components and subcomponents of the array or record type |
| on boundaries appropriate to their inherent size (naturally |
| aligned). For example, 1-byte components are aligned on byte boundaries, |
| 2-byte integer components are aligned on 2-byte boundaries, 4-byte |
| integer components are aligned on 4-byte boundaries and so on. These |
| alignment rules correspond to the normal rules for C compilers on all |
| machines except the VAX. |
| |
| @geindex Component_Size_4 (in pragma Component_Alignment) |
| |
| @item @emph{Component_Size_4} |
| |
| Naturally aligns components with a size of four or fewer |
| bytes. Components that are larger than 4 bytes are placed on the next |
| 4-byte boundary. |
| |
| @geindex Storage_Unit (in pragma Component_Alignment) |
| |
| @item @emph{Storage_Unit} |
| |
| Specifies that array or record components are byte aligned, i.e., |
| aligned on boundaries determined by the value of the constant |
| @cite{System.Storage_Unit}. |
| |
| @geindex Default (in pragma Component_Alignment) |
| |
| @item @emph{Default} |
| |
| Specifies that array or record components are aligned on default |
| boundaries, appropriate to the underlying hardware or operating system or |
| both. The @cite{Default} choice is the same as @cite{Component_Size} (natural |
| alignment). |
| @end table |
| |
| If the @cite{Name} parameter is present, @cite{type_LOCAL_NAME} must |
| refer to a local record or array type, and the specified alignment |
| choice applies to the specified type. The use of |
| @cite{Component_Alignment} together with a pragma @cite{Pack} causes the |
| @cite{Component_Alignment} pragma to be ignored. The use of |
| @cite{Component_Alignment} together with a record representation clause |
| is only effective for fields not specified by the representation clause. |
| |
| If the @cite{Name} parameter is absent, the pragma can be used as either |
| a configuration pragma, in which case it applies to one or more units in |
| accordance with the normal rules for configuration pragmas, or it can be |
| used within a declarative part, in which case it applies to types that |
| are declared within this declarative part, or within any nested scope |
| within this declarative part. In either case it specifies the alignment |
| to be applied to any record or array type which has otherwise standard |
| representation. |
| |
| If the alignment for a record or array type is not specified (using |
| pragma @cite{Pack}, pragma @cite{Component_Alignment}, or a record rep |
| clause), the GNAT uses the default alignment as described previously. |
| |
| @node Pragma Contract_Cases,Pragma Convention_Identifier,Pragma Component_Alignment,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-contract-cases}@anchor{3c} |
| @section Pragma Contract_Cases |
| |
| |
| @geindex Contract cases |
| |
| Syntax: |
| |
| @example |
| pragma Contract_Cases ( |
| Condition => Consequence |
| @{,Condition => Consequence@}); |
| @end example |
| |
| The @cite{Contract_Cases} pragma allows defining fine-grain specifications |
| that can complement or replace the contract given by a precondition and a |
| postcondition. Additionally, the @cite{Contract_Cases} pragma can be used |
| by testing and formal verification tools. The compiler checks its validity and, |
| depending on the assertion policy at the point of declaration of the pragma, |
| it may insert a check in the executable. For code generation, the contract |
| cases |
| |
| @example |
| pragma Contract_Cases ( |
| Cond1 => Pred1, |
| Cond2 => Pred2); |
| @end example |
| |
| are equivalent to |
| |
| @example |
| C1 : constant Boolean := Cond1; -- evaluated at subprogram entry |
| C2 : constant Boolean := Cond2; -- evaluated at subprogram entry |
| pragma Precondition ((C1 and not C2) or (C2 and not C1)); |
| pragma Postcondition (if C1 then Pred1); |
| pragma Postcondition (if C2 then Pred2); |
| @end example |
| |
| The precondition ensures that one and only one of the conditions is |
| satisfied on entry to the subprogram. |
| The postcondition ensures that for the condition that was True on entry, |
| the corrresponding consequence is True on exit. Other consequence expressions |
| are not evaluated. |
| |
| A precondition @cite{P} and postcondition @cite{Q} can also be |
| expressed as contract cases: |
| |
| @example |
| pragma Contract_Cases (P => Q); |
| @end example |
| |
| The placement and visibility rules for @cite{Contract_Cases} pragmas are |
| identical to those described for preconditions and postconditions. |
| |
| The compiler checks that boolean expressions given in conditions and |
| consequences are valid, where the rules for conditions are the same as |
| the rule for an expression in @cite{Precondition} and the rules for |
| consequences are the same as the rule for an expression in |
| @cite{Postcondition}. In particular, attributes @cite{'Old} and |
| @cite{'Result} can only be used within consequence expressions. |
| The condition for the last contract case may be @cite{others}, to denote |
| any case not captured by the previous cases. The |
| following is an example of use within a package spec: |
| |
| @example |
| package Math_Functions is |
| ... |
| function Sqrt (Arg : Float) return Float; |
| pragma Contract_Cases ((Arg in 0 .. 99) => Sqrt'Result < 10, |
| Arg >= 100 => Sqrt'Result >= 10, |
| others => Sqrt'Result = 0); |
| ... |
| end Math_Functions; |
| @end example |
| |
| The meaning of contract cases is that only one case should apply at each |
| call, as determined by the corresponding condition evaluating to True, |
| and that the consequence for this case should hold when the subprogram |
| returns. |
| |
| @node Pragma Convention_Identifier,Pragma CPP_Class,Pragma Contract_Cases,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-convention-identifier}@anchor{3d} |
| @section Pragma Convention_Identifier |
| |
| |
| @geindex Conventions |
| @geindex synonyms |
| |
| Syntax: |
| |
| @example |
| pragma Convention_Identifier ( |
| [Name =>] IDENTIFIER, |
| [Convention =>] convention_IDENTIFIER); |
| @end example |
| |
| This pragma provides a mechanism for supplying synonyms for existing |
| convention identifiers. The @cite{Name} identifier can subsequently |
| be used as a synonym for the given convention in other pragmas (including |
| for example pragma @cite{Import} or another @cite{Convention_Identifier} |
| pragma). As an example of the use of this, suppose you had legacy code |
| which used Fortran77 as the identifier for Fortran. Then the pragma: |
| |
| @example |
| pragma Convention_Identifier (Fortran77, Fortran); |
| @end example |
| |
| would allow the use of the convention identifier @cite{Fortran77} in |
| subsequent code, avoiding the need to modify the sources. As another |
| example, you could use this to parameterize convention requirements |
| according to systems. Suppose you needed to use @cite{Stdcall} on |
| windows systems, and @cite{C} on some other system, then you could |
| define a convention identifier @cite{Library} and use a single |
| @cite{Convention_Identifier} pragma to specify which convention |
| would be used system-wide. |
| |
| @node Pragma CPP_Class,Pragma CPP_Constructor,Pragma Convention_Identifier,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-class}@anchor{3e} |
| @section Pragma CPP_Class |
| |
| |
| @geindex Interfacing with C++ |
| |
| Syntax: |
| |
| @example |
| pragma CPP_Class ([Entity =>] LOCAL_NAME); |
| @end example |
| |
| The argument denotes an entity in the current declarative region that is |
| declared as a record type. It indicates that the type corresponds to an |
| externally declared C++ class type, and is to be laid out the same way |
| that C++ would lay out the type. If the C++ class has virtual primitives |
| then the record must be declared as a tagged record type. |
| |
| Types for which @cite{CPP_Class} is specified do not have assignment or |
| equality operators defined (such operations can be imported or declared |
| as subprograms as required). Initialization is allowed only by constructor |
| functions (see pragma @cite{CPP_Constructor}). Such types are implicitly |
| limited if not explicitly declared as limited or derived from a limited |
| type, and an error is issued in that case. |
| |
| See @ref{3f,,Interfacing to C++} for related information. |
| |
| Note: Pragma @cite{CPP_Class} is currently obsolete. It is supported |
| for backward compatibility but its functionality is available |
| using pragma @cite{Import} with @cite{Convention} = @cite{CPP}. |
| |
| @node Pragma CPP_Constructor,Pragma CPP_Virtual,Pragma CPP_Class,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-constructor}@anchor{40} |
| @section Pragma CPP_Constructor |
| |
| |
| @geindex Interfacing with C++ |
| |
| Syntax: |
| |
| @example |
| pragma CPP_Constructor ([Entity =>] LOCAL_NAME |
| [, [External_Name =>] static_string_EXPRESSION ] |
| [, [Link_Name =>] static_string_EXPRESSION ]); |
| @end example |
| |
| This pragma identifies an imported function (imported in the usual way |
| with pragma @cite{Import}) as corresponding to a C++ constructor. If |
| @cite{External_Name} and @cite{Link_Name} are not specified then the |
| @cite{Entity} argument is a name that must have been previously mentioned |
| in a pragma @cite{Import} with @cite{Convention} = @cite{CPP}. Such name |
| must be of one of the following forms: |
| |
| |
| @itemize * |
| |
| @item |
| @strong{function} @cite{Fname} @strong{return} T` |
| |
| @item |
| @strong{function} @cite{Fname} @strong{return} T'Class |
| |
| @item |
| @strong{function} @cite{Fname} (...) @strong{return} T` |
| |
| @item |
| @strong{function} @cite{Fname} (...) @strong{return} T'Class |
| @end itemize |
| |
| where @cite{T} is a limited record type imported from C++ with pragma |
| @cite{Import} and @cite{Convention} = @cite{CPP}. |
| |
| The first two forms import the default constructor, used when an object |
| of type @cite{T} is created on the Ada side with no explicit constructor. |
| The latter two forms cover all the non-default constructors of the type. |
| See the GNAT User's Guide for details. |
| |
| If no constructors are imported, it is impossible to create any objects |
| on the Ada side and the type is implicitly declared abstract. |
| |
| Pragma @cite{CPP_Constructor} is intended primarily for automatic generation |
| using an automatic binding generator tool (such as the @cite{-fdump-ada-spec} |
| GCC switch). |
| See @ref{3f,,Interfacing to C++} for more related information. |
| |
| Note: The use of functions returning class-wide types for constructors is |
| currently obsolete. They are supported for backward compatibility. The |
| use of functions returning the type T leave the Ada sources more clear |
| because the imported C++ constructors always return an object of type T; |
| that is, they never return an object whose type is a descendant of type T. |
| |
| @node Pragma CPP_Virtual,Pragma CPP_Vtable,Pragma CPP_Constructor,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-virtual}@anchor{41} |
| @section Pragma CPP_Virtual |
| |
| |
| @geindex Interfacing to C++ |
| |
| This pragma is now obsolete and, other than generating a warning if warnings |
| on obsolescent features are enabled, is completely ignored. |
| It is retained for compatibility |
| purposes. It used to be required to ensure compoatibility with C++, but |
| is no longer required for that purpose because GNAT generates |
| the same object layout as the G++ compiler by default. |
| |
| See @ref{3f,,Interfacing to C++} for related information. |
| |
| @node Pragma CPP_Vtable,Pragma CPU,Pragma CPP_Virtual,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-vtable}@anchor{42} |
| @section Pragma CPP_Vtable |
| |
| |
| @geindex Interfacing with C++ |
| |
| This pragma is now obsolete and, other than generating a warning if warnings |
| on obsolescent features are enabled, is completely ignored. |
| It used to be required to ensure compatibility with C++, but |
| is no longer required for that purpose because GNAT generates |
| the same object layout as the G++ compiler by default. |
| |
| See @ref{3f,,Interfacing to C++} for related information. |
| |
| @node Pragma CPU,Pragma Debug,Pragma CPP_Vtable,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-cpu}@anchor{43} |
| @section Pragma CPU |
| |
| |
| Syntax: |
| |
| @example |
| pragma CPU (EXPRESSION); |
| @end example |
| |
| This pragma is standard in Ada 2012, but is available in all earlier |
| versions of Ada as an implementation-defined pragma. |
| See Ada 2012 Reference Manual for details. |
| |
| @node Pragma Debug,Pragma Debug_Policy,Pragma CPU,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-debug}@anchor{44} |
| @section Pragma Debug |
| |
| |
| Syntax: |
| |
| @example |
| pragma Debug ([CONDITION, ]PROCEDURE_CALL_WITHOUT_SEMICOLON); |
| |
| PROCEDURE_CALL_WITHOUT_SEMICOLON ::= |
| PROCEDURE_NAME |
| | PROCEDURE_PREFIX ACTUAL_PARAMETER_PART |
| @end example |
| |
| The procedure call argument has the syntactic form of an expression, meeting |
| the syntactic requirements for pragmas. |
| |
| If debug pragmas are not enabled or if the condition is present and evaluates |
| to False, this pragma has no effect. If debug pragmas are enabled, the |
| semantics of the pragma is exactly equivalent to the procedure call statement |
| corresponding to the argument with a terminating semicolon. Pragmas are |
| permitted in sequences of declarations, so you can use pragma @cite{Debug} to |
| intersperse calls to debug procedures in the middle of declarations. Debug |
| pragmas can be enabled either by use of the command line switch @emph{-gnata} |
| or by use of the pragma @cite{Check_Policy} with a first argument of |
| @cite{Debug}. |
| |
| @node Pragma Debug_Policy,Pragma Default_Scalar_Storage_Order,Pragma Debug,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-debug-policy}@anchor{45} |
| @section Pragma Debug_Policy |
| |
| |
| Syntax: |
| |
| @example |
| pragma Debug_Policy (CHECK | DISABLE | IGNORE | ON | OFF); |
| @end example |
| |
| This pragma is equivalent to a corresponding @cite{Check_Policy} pragma |
| with a first argument of @cite{Debug}. It is retained for historical |
| compatibility reasons. |
| |
| @node Pragma Default_Scalar_Storage_Order,Pragma Default_Storage_Pool,Pragma Debug_Policy,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-default-scalar-storage-order}@anchor{46} |
| @section Pragma Default_Scalar_Storage_Order |
| |
| |
| @geindex Default_Scalar_Storage_Order |
| |
| @geindex Scalar_Storage_Order |
| |
| Syntax: |
| |
| @example |
| pragma Default_Scalar_Storage_Order (High_Order_First | Low_Order_First); |
| @end example |
| |
| Normally if no explicit @cite{Scalar_Storage_Order} is given for a record |
| type or array type, then the scalar storage order defaults to the ordinary |
| default for the target. But this default may be overridden using this pragma. |
| The pragma may appear as a configuration pragma, or locally within a package |
| spec or declarative part. In the latter case, it applies to all subsequent |
| types declared within that package spec or declarative part. |
| |
| The following example shows the use of this pragma: |
| |
| @example |
| pragma Default_Scalar_Storage_Order (High_Order_First); |
| with System; use System; |
| package DSSO1 is |
| type H1 is record |
| a : Integer; |
| end record; |
| |
| type L2 is record |
| a : Integer; |
| end record; |
| for L2'Scalar_Storage_Order use Low_Order_First; |
| |
| type L2a is new L2; |
| |
| package Inner is |
| type H3 is record |
| a : Integer; |
| end record; |
| |
| pragma Default_Scalar_Storage_Order (Low_Order_First); |
| |
| type L4 is record |
| a : Integer; |
| end record; |
| end Inner; |
| |
| type H4a is new Inner.L4; |
| |
| type H5 is record |
| a : Integer; |
| end record; |
| end DSSO1; |
| @end example |
| |
| In this example record types L.. have @cite{Low_Order_First} scalar |
| storage order, and record types H.. have @cite{High_Order_First}. |
| Note that in the case of @cite{H4a}, the order is not inherited |
| from the parent type. Only an explicitly set @cite{Scalar_Storage_Order} |
| gets inherited on type derivation. |
| |
| If this pragma is used as a configuration pragma which appears within a |
| configuration pragma file (as opposed to appearing explicitly at the start |
| of a single unit), then the binder will require that all units in a partition |
| be compiled in a similar manner, other than run-time units, which are not |
| affected by this pragma. Note that the use of this form is discouraged because |
| it may significantly degrade the run-time performance of the software, instead |
| the default scalar storage order ought to be changed only on a local basis. |
| |
| @node Pragma Default_Storage_Pool,Pragma Depends,Pragma Default_Scalar_Storage_Order,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-default-storage-pool}@anchor{47} |
| @section Pragma Default_Storage_Pool |
| |
| |
| @geindex Default_Storage_Pool |
| |
| Syntax: |
| |
| @example |
| pragma Default_Storage_Pool (storage_pool_NAME | null); |
| @end example |
| |
| This pragma is standard in Ada 2012, but is available in all earlier |
| versions of Ada as an implementation-defined pragma. |
| See Ada 2012 Reference Manual for details. |
| |
| @node Pragma Depends,Pragma Detect_Blocking,Pragma Default_Storage_Pool,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{48} |
| @section Pragma Depends |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 6.1.5. |
| |
| @node Pragma Detect_Blocking,Pragma Disable_Atomic_Synchronization,Pragma Depends,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-detect-blocking}@anchor{49} |
| @section Pragma Detect_Blocking |
| |
| |
| Syntax: |
| |
| @example |
| pragma Detect_Blocking; |
| @end example |
| |
| This is a standard pragma in Ada 2005, that is available in all earlier |
| versions of Ada as an implementation-defined pragma. |
| |
| This is a configuration pragma that forces the detection of potentially |
| blocking operations within a protected operation, and to raise Program_Error |
| if that happens. |
| |
| @node Pragma Disable_Atomic_Synchronization,Pragma Dispatching_Domain,Pragma Detect_Blocking,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-disable-atomic-synchronization}@anchor{4a} |
| @section Pragma Disable_Atomic_Synchronization |
| |
| |
| @geindex Atomic Synchronization |
| |
| Syntax: |
| |
| @example |
| pragma Disable_Atomic_Synchronization [(Entity)]; |
| @end example |
| |
| Ada requires that accesses (reads or writes) of an atomic variable be |
| regarded as synchronization points in the case of multiple tasks. |
| Particularly in the case of multi-processors this may require special |
| handling, e.g. the generation of memory barriers. This capability may |
| be turned off using this pragma in cases where it is known not to be |
| required. |
| |
| The placement and scope rules for this pragma are the same as those |
| for @cite{pragma Suppress}. In particular it can be used as a |
| configuration pragma, or in a declaration sequence where it applies |
| till the end of the scope. If an @cite{Entity} argument is present, |
| the action applies only to that entity. |
| |
| @node Pragma Dispatching_Domain,Pragma Effective_Reads,Pragma Disable_Atomic_Synchronization,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-dispatching-domain}@anchor{4b} |
| @section Pragma Dispatching_Domain |
| |
| |
| Syntax: |
| |
| @example |
| pragma Dispatching_Domain (EXPRESSION); |
| @end example |
| |
| This pragma is standard in Ada 2012, but is available in all earlier |
| versions of Ada as an implementation-defined pragma. |
| See Ada 2012 Reference Manual for details. |
| |
| @node Pragma Effective_Reads,Pragma Effective_Writes,Pragma Dispatching_Domain,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-effective-reads}@anchor{4c} |
| @section Pragma Effective_Reads |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.2. |
| |
| @node Pragma Effective_Writes,Pragma Elaboration_Checks,Pragma Effective_Reads,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-effective-writes}@anchor{4d} |
| @section Pragma Effective_Writes |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.2. |
| |
| @node Pragma Elaboration_Checks,Pragma Eliminate,Pragma Effective_Writes,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-elaboration-checks}@anchor{4e} |
| @section Pragma Elaboration_Checks |
| |
| |
| @geindex Elaboration control |
| |
| Syntax: |
| |
| @example |
| pragma Elaboration_Checks (Dynamic | Static); |
| @end example |
| |
| This is a configuration pragma that provides control over the |
| elaboration model used by the compilation affected by the |
| pragma. If the parameter is @cite{Dynamic}, |
| then the dynamic elaboration |
| model described in the Ada Reference Manual is used, as though |
| the @emph{-gnatE} switch had been specified on the command |
| line. If the parameter is @cite{Static}, then the default GNAT static |
| model is used. This configuration pragma overrides the setting |
| of the command line. For full details on the elaboration models |
| used by the GNAT compiler, see the chapter on elaboration order handling |
| in the @emph{GNAT User's Guide}. |
| |
| @node Pragma Eliminate,Pragma Enable_Atomic_Synchronization,Pragma Elaboration_Checks,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-eliminate}@anchor{4f} |
| @section Pragma Eliminate |
| |
| |
| @geindex Elimination of unused subprograms |
| |
| Syntax: |
| |
| @example |
| pragma Eliminate ([Entity =>] DEFINING_DESIGNATOR, |
| [Source_Location =>] STRING_LITERAL); |
| @end example |
| |
| The string literal given for the source location is a string which |
| specifies the line number of the occurrence of the entity, using |
| the syntax for SOURCE_TRACE given below: |
| |
| @example |
| SOURCE_TRACE ::= SOURCE_REFERENCE [LBRACKET SOURCE_TRACE RBRACKET] |
| |
| LBRACKET ::= [ |
| RBRACKET ::= ] |
| |
| SOURCE_REFERENCE ::= FILE_NAME : LINE_NUMBER |
| |
| LINE_NUMBER ::= DIGIT @{DIGIT@} |
| @end example |
| |
| Spaces around the colon in a @cite{Source_Reference} are optional. |
| |
| The @cite{DEFINING_DESIGNATOR} matches the defining designator used in an |
| explicit subprogram declaration, where the @cite{entity} name in this |
| designator appears on the source line specified by the source location. |
| |
| The source trace that is given as the @cite{Source_Location} shall obey the |
| following rules. The @cite{FILE_NAME} is the short name (with no directory |
| information) of an Ada source file, given using exactly the required syntax |
| for the underlying file system (e.g. case is important if the underlying |
| operating system is case sensitive). @cite{LINE_NUMBER} gives the line |
| number of the occurrence of the @cite{entity} |
| as a decimal literal without an exponent or point. If an @cite{entity} is not |
| declared in a generic instantiation (this includes generic subprogram |
| instances), the source trace includes only one source reference. If an entity |
| is declared inside a generic instantiation, its source trace (when parsing |
| from left to right) starts with the source location of the declaration of the |
| entity in the generic unit and ends with the source location of the |
| instantiation (it is given in square brackets). This approach is recursively |
| used in case of nested instantiations: the rightmost (nested most deeply in |
| square brackets) element of the source trace is the location of the outermost |
| instantiation, the next to left element is the location of the next (first |
| nested) instantiation in the code of the corresponding generic unit, and so |
| on, and the leftmost element (that is out of any square brackets) is the |
| location of the declaration of the entity to eliminate in a generic unit. |
| |
| Note that the @cite{Source_Location} argument specifies which of a set of |
| similarly named entities is being eliminated, dealing both with overloading, |
| and also appearance of the same entity name in different scopes. |
| |
| This pragma indicates that the given entity is not used in the program to be |
| compiled and built. The effect of the pragma is to allow the compiler to |
| eliminate the code or data associated with the named entity. Any reference to |
| an eliminated entity causes a compile-time or link-time error. |
| |
| The intention of pragma @cite{Eliminate} is to allow a program to be compiled |
| in a system-independent manner, with unused entities eliminated, without |
| needing to modify the source text. Normally the required set of |
| @cite{Eliminate} pragmas is constructed automatically using the gnatelim tool. |
| |
| Any source file change that removes, splits, or |
| adds lines may make the set of Eliminate pragmas invalid because their |
| @cite{Source_Location} argument values may get out of date. |
| |
| Pragma @cite{Eliminate} may be used where the referenced entity is a dispatching |
| operation. In this case all the subprograms to which the given operation can |
| dispatch are considered to be unused (are never called as a result of a direct |
| or a dispatching call). |
| |
| @node Pragma Enable_Atomic_Synchronization,Pragma Export_Function,Pragma Eliminate,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-enable-atomic-synchronization}@anchor{50} |
| @section Pragma Enable_Atomic_Synchronization |
| |
| |
| @geindex Atomic Synchronization |
| |
| Syntax: |
| |
| @example |
| pragma Enable_Atomic_Synchronization [(Entity)]; |
| @end example |
| |
| Ada requires that accesses (reads or writes) of an atomic variable be |
| regarded as synchronization points in the case of multiple tasks. |
| Particularly in the case of multi-processors this may require special |
| handling, e.g. the generation of memory barriers. This synchronization |
| is performed by default, but can be turned off using |
| @cite{pragma Disable_Atomic_Synchronization}. The |
| @cite{Enable_Atomic_Synchronization} pragma can be used to turn |
| it back on. |
| |
| The placement and scope rules for this pragma are the same as those |
| for @cite{pragma Unsuppress}. In particular it can be used as a |
| configuration pragma, or in a declaration sequence where it applies |
| till the end of the scope. If an @cite{Entity} argument is present, |
| the action applies only to that entity. |
| |
| @node Pragma Export_Function,Pragma Export_Object,Pragma Enable_Atomic_Synchronization,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-export-function}@anchor{51} |
| @section Pragma Export_Function |
| |
| |
| @geindex Argument passing mechanisms |
| |
| Syntax: |
| |
| @example |
| pragma Export_Function ( |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Parameter_Types =>] PARAMETER_TYPES] |
| [, [Result_Type =>] result_SUBTYPE_MARK] |
| [, [Mechanism =>] MECHANISM] |
| [, [Result_Mechanism =>] MECHANISM_NAME]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| | "" |
| |
| PARAMETER_TYPES ::= |
| null |
| | TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@} |
| |
| TYPE_DESIGNATOR ::= |
| subtype_NAME |
| | subtype_Name ' Access |
| |
| MECHANISM ::= |
| MECHANISM_NAME |
| | (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@}) |
| |
| MECHANISM_ASSOCIATION ::= |
| [formal_parameter_NAME =>] MECHANISM_NAME |
| |
| MECHANISM_NAME ::= Value | Reference |
| @end example |
| |
| Use this pragma to make a function externally callable and optionally |
| provide information on mechanisms to be used for passing parameter and |
| result values. We recommend, for the purposes of improving portability, |
| this pragma always be used in conjunction with a separate pragma |
| @cite{Export}, which must precede the pragma @cite{Export_Function}. |
| GNAT does not require a separate pragma @cite{Export}, but if none is |
| present, @cite{Convention Ada} is assumed, which is usually |
| not what is wanted, so it is usually appropriate to use this |
| pragma in conjunction with a @cite{Export} or @cite{Convention} |
| pragma that specifies the desired foreign convention. |
| Pragma @cite{Export_Function} |
| (and @cite{Export}, if present) must appear in the same declarative |
| region as the function to which they apply. |
| |
| @cite{internal_name} must uniquely designate the function to which the |
| pragma applies. If more than one function name exists of this name in |
| the declarative part you must use the @cite{Parameter_Types} and |
| @cite{Result_Type} parameters is mandatory to achieve the required |
| unique designation. @cite{subtype_mark`s in these parameters must exactly match the subtypes in the corresponding function specification@comma{} using positional notation to match parameters with subtype marks. The form with an `'Access} attribute can be used to match an |
| anonymous access parameter. |
| |
| @geindex Suppressing external name |
| |
| Special treatment is given if the EXTERNAL is an explicit null |
| string or a static string expressions that evaluates to the null |
| string. In this case, no external name is generated. This form |
| still allows the specification of parameter mechanisms. |
| |
| @node Pragma Export_Object,Pragma Export_Procedure,Pragma Export_Function,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-export-object}@anchor{52} |
| @section Pragma Export_Object |
| |
| |
| Syntax: |
| |
| @example |
| pragma Export_Object |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Size =>] EXTERNAL_SYMBOL] |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| @end example |
| |
| This pragma designates an object as exported, and apart from the |
| extended rules for external symbols, is identical in effect to the use of |
| the normal @cite{Export} pragma applied to an object. You may use a |
| separate Export pragma (and you probably should from the point of view |
| of portability), but it is not required. @cite{Size} is syntax checked, |
| but otherwise ignored by GNAT. |
| |
| @node Pragma Export_Procedure,Pragma Export_Value,Pragma Export_Object,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-export-procedure}@anchor{53} |
| @section Pragma Export_Procedure |
| |
| |
| Syntax: |
| |
| @example |
| pragma Export_Procedure ( |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Parameter_Types =>] PARAMETER_TYPES] |
| [, [Mechanism =>] MECHANISM]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| | "" |
| |
| PARAMETER_TYPES ::= |
| null |
| | TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@} |
| |
| TYPE_DESIGNATOR ::= |
| subtype_NAME |
| | subtype_Name ' Access |
| |
| MECHANISM ::= |
| MECHANISM_NAME |
| | (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@}) |
| |
| MECHANISM_ASSOCIATION ::= |
| [formal_parameter_NAME =>] MECHANISM_NAME |
| |
| MECHANISM_NAME ::= Value | Reference |
| @end example |
| |
| This pragma is identical to @cite{Export_Function} except that it |
| applies to a procedure rather than a function and the parameters |
| @cite{Result_Type} and @cite{Result_Mechanism} are not permitted. |
| GNAT does not require a separate pragma @cite{Export}, but if none is |
| present, @cite{Convention Ada} is assumed, which is usually |
| not what is wanted, so it is usually appropriate to use this |
| pragma in conjunction with a @cite{Export} or @cite{Convention} |
| pragma that specifies the desired foreign convention. |
| |
| @geindex Suppressing external name |
| |
| Special treatment is given if the EXTERNAL is an explicit null |
| string or a static string expressions that evaluates to the null |
| string. In this case, no external name is generated. This form |
| still allows the specification of parameter mechanisms. |
| |
| @node Pragma Export_Value,Pragma Export_Valued_Procedure,Pragma Export_Procedure,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-export-value}@anchor{54} |
| @section Pragma Export_Value |
| |
| |
| Syntax: |
| |
| @example |
| pragma Export_Value ( |
| [Value =>] static_integer_EXPRESSION, |
| [Link_Name =>] static_string_EXPRESSION); |
| @end example |
| |
| This pragma serves to export a static integer value for external use. |
| The first argument specifies the value to be exported. The Link_Name |
| argument specifies the symbolic name to be associated with the integer |
| value. This pragma is useful for defining a named static value in Ada |
| that can be referenced in assembly language units to be linked with |
| the application. This pragma is currently supported only for the |
| AAMP target and is ignored for other targets. |
| |
| @node Pragma Export_Valued_Procedure,Pragma Extend_System,Pragma Export_Value,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-export-valued-procedure}@anchor{55} |
| @section Pragma Export_Valued_Procedure |
| |
| |
| Syntax: |
| |
| @example |
| pragma Export_Valued_Procedure ( |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Parameter_Types =>] PARAMETER_TYPES] |
| [, [Mechanism =>] MECHANISM]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| | "" |
| |
| PARAMETER_TYPES ::= |
| null |
| | TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@} |
| |
| TYPE_DESIGNATOR ::= |
| subtype_NAME |
| | subtype_Name ' Access |
| |
| MECHANISM ::= |
| MECHANISM_NAME |
| | (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@}) |
| |
| MECHANISM_ASSOCIATION ::= |
| [formal_parameter_NAME =>] MECHANISM_NAME |
| |
| MECHANISM_NAME ::= Value | Reference |
| @end example |
| |
| This pragma is identical to @cite{Export_Procedure} except that the |
| first parameter of @cite{LOCAL_NAME}, which must be present, must be of |
| mode @cite{OUT}, and externally the subprogram is treated as a function |
| with this parameter as the result of the function. GNAT provides for |
| this capability to allow the use of @cite{OUT} and @cite{IN OUT} |
| parameters in interfacing to external functions (which are not permitted |
| in Ada functions). |
| GNAT does not require a separate pragma @cite{Export}, but if none is |
| present, @cite{Convention Ada} is assumed, which is almost certainly |
| not what is wanted since the whole point of this pragma is to interface |
| with foreign language functions, so it is usually appropriate to use this |
| pragma in conjunction with a @cite{Export} or @cite{Convention} |
| pragma that specifies the desired foreign convention. |
| |
| @geindex Suppressing external name |
| |
| Special treatment is given if the EXTERNAL is an explicit null |
| string or a static string expressions that evaluates to the null |
| string. In this case, no external name is generated. This form |
| still allows the specification of parameter mechanisms. |
| |
| @node Pragma Extend_System,Pragma Extensions_Allowed,Pragma Export_Valued_Procedure,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-extend-system}@anchor{56} |
| @section Pragma Extend_System |
| |
| |
| @geindex System |
| @geindex extending |
| |
| @geindex DEC Ada 83 |
| |
| Syntax: |
| |
| @example |
| pragma Extend_System ([Name =>] IDENTIFIER); |
| @end example |
| |
| This pragma is used to provide backwards compatibility with other |
| implementations that extend the facilities of package @cite{System}. In |
| GNAT, @cite{System} contains only the definitions that are present in |
| the Ada RM. However, other implementations, notably the DEC Ada 83 |
| implementation, provide many extensions to package @cite{System}. |
| |
| For each such implementation accommodated by this pragma, GNAT provides a |
| package @cite{Aux_`xxx`}, e.g., @cite{Aux_DEC} for the DEC Ada 83 |
| implementation, which provides the required additional definitions. You |
| can use this package in two ways. You can @cite{with} it in the normal |
| way and access entities either by selection or using a @cite{use} |
| clause. In this case no special processing is required. |
| |
| However, if existing code contains references such as |
| @cite{System.`xxx`} where @cite{xxx} is an entity in the extended |
| definitions provided in package @cite{System}, you may use this pragma |
| to extend visibility in @cite{System} in a non-standard way that |
| provides greater compatibility with the existing code. Pragma |
| @cite{Extend_System} is a configuration pragma whose single argument is |
| the name of the package containing the extended definition |
| (e.g., @cite{Aux_DEC} for the DEC Ada case). A unit compiled under |
| control of this pragma will be processed using special visibility |
| processing that looks in package @cite{System.Aux_`xxx`} where |
| @cite{Aux_`xxx`} is the pragma argument for any entity referenced in |
| package @cite{System}, but not found in package @cite{System}. |
| |
| You can use this pragma either to access a predefined @cite{System} |
| extension supplied with the compiler, for example @cite{Aux_DEC} or |
| you can construct your own extension unit following the above |
| definition. Note that such a package is a child of @cite{System} |
| and thus is considered part of the implementation. |
| To compile it you will have to use the @emph{-gnatg} switch |
| for compiling System units, as explained in the |
| GNAT User's Guide. |
| |
| @node Pragma Extensions_Allowed,Pragma External,Pragma Extend_System,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{57} |
| @section Pragma Extensions_Allowed |
| |
| |
| @geindex Ada Extensions |
| |
| @geindex GNAT Extensions |
| |
| Syntax: |
| |
| @example |
| pragma Extensions_Allowed (On | Off); |
| @end example |
| |
| This configuration pragma enables or disables the implementation |
| extension mode (the use of Off as a parameter cancels the effect |
| of the @emph{-gnatX} command switch). |
| |
| In extension mode, the latest version of the Ada language is |
| implemented (currently Ada 2012), and in addition a small number |
| of GNAT specific extensions are recognized as follows: |
| |
| |
| @table @asis |
| |
| @item @emph{Constrained attribute for generic objects} |
| |
| The @cite{Constrained} attribute is permitted for objects of |
| generic types. The result indicates if the corresponding actual |
| is constrained. |
| @end table |
| |
| @node Pragma External,Pragma External_Name_Casing,Pragma Extensions_Allowed,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-external}@anchor{58} |
| @section Pragma External |
| |
| |
| Syntax: |
| |
| @example |
| pragma External ( |
| [ Convention =>] convention_IDENTIFIER, |
| [ Entity =>] LOCAL_NAME |
| [, [External_Name =>] static_string_EXPRESSION ] |
| [, [Link_Name =>] static_string_EXPRESSION ]); |
| @end example |
| |
| This pragma is identical in syntax and semantics to pragma |
| @cite{Export} as defined in the Ada Reference Manual. It is |
| provided for compatibility with some Ada 83 compilers that |
| used this pragma for exactly the same purposes as pragma |
| @cite{Export} before the latter was standardized. |
| |
| @node Pragma External_Name_Casing,Pragma Fast_Math,Pragma External,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-external-name-casing}@anchor{59} |
| @section Pragma External_Name_Casing |
| |
| |
| @geindex Dec Ada 83 casing compatibility |
| |
| @geindex External Names |
| @geindex casing |
| |
| @geindex Casing of External names |
| |
| Syntax: |
| |
| @example |
| pragma External_Name_Casing ( |
| Uppercase | Lowercase |
| [, Uppercase | Lowercase | As_Is]); |
| @end example |
| |
| This pragma provides control over the casing of external names associated |
| with Import and Export pragmas. There are two cases to consider: |
| |
| |
| @itemize * |
| |
| @item |
| Implicit external names |
| |
| Implicit external names are derived from identifiers. The most common case |
| arises when a standard Ada Import or Export pragma is used with only two |
| arguments, as in: |
| |
| @example |
| pragma Import (C, C_Routine); |
| @end example |
| |
| Since Ada is a case-insensitive language, the spelling of the identifier in |
| the Ada source program does not provide any information on the desired |
| casing of the external name, and so a convention is needed. In GNAT the |
| default treatment is that such names are converted to all lower case |
| letters. This corresponds to the normal C style in many environments. |
| The first argument of pragma @cite{External_Name_Casing} can be used to |
| control this treatment. If @cite{Uppercase} is specified, then the name |
| will be forced to all uppercase letters. If @cite{Lowercase} is specified, |
| then the normal default of all lower case letters will be used. |
| |
| This same implicit treatment is also used in the case of extended DEC Ada 83 |
| compatible Import and Export pragmas where an external name is explicitly |
| specified using an identifier rather than a string. |
| |
| @item |
| Explicit external names |
| |
| Explicit external names are given as string literals. The most common case |
| arises when a standard Ada Import or Export pragma is used with three |
| arguments, as in: |
| |
| @example |
| pragma Import (C, C_Routine, "C_routine"); |
| @end example |
| |
| In this case, the string literal normally provides the exact casing required |
| for the external name. The second argument of pragma |
| @cite{External_Name_Casing} may be used to modify this behavior. |
| If @cite{Uppercase} is specified, then the name |
| will be forced to all uppercase letters. If @cite{Lowercase} is specified, |
| then the name will be forced to all lowercase letters. A specification of |
| @cite{As_Is} provides the normal default behavior in which the casing is |
| taken from the string provided. |
| @end itemize |
| |
| This pragma may appear anywhere that a pragma is valid. In particular, it |
| can be used as a configuration pragma in the @code{gnat.adc} file, in which |
| case it applies to all subsequent compilations, or it can be used as a program |
| unit pragma, in which case it only applies to the current unit, or it can |
| be used more locally to control individual Import/Export pragmas. |
| |
| It was primarily intended for use with OpenVMS systems, where many |
| compilers convert all symbols to upper case by default. For interfacing to |
| such compilers (e.g., the DEC C compiler), it may be convenient to use |
| the pragma: |
| |
| @example |
| pragma External_Name_Casing (Uppercase, Uppercase); |
| @end example |
| |
| to enforce the upper casing of all external symbols. |
| |
| @node Pragma Fast_Math,Pragma Favor_Top_Level,Pragma External_Name_Casing,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-fast-math}@anchor{5a} |
| @section Pragma Fast_Math |
| |
| |
| Syntax: |
| |
| @example |
| pragma Fast_Math; |
| @end example |
| |
| This is a configuration pragma which activates a mode in which speed is |
| considered more important for floating-point operations than absolutely |
| accurate adherence to the requirements of the standard. Currently the |
| following operations are affected: |
| |
| |
| @table @asis |
| |
| @item @emph{Complex Multiplication} |
| |
| The normal simple formula for complex multiplication can result in intermediate |
| overflows for numbers near the end of the range. The Ada standard requires that |
| this situation be detected and corrected by scaling, but in Fast_Math mode such |
| cases will simply result in overflow. Note that to take advantage of this you |
| must instantiate your own version of @cite{Ada.Numerics.Generic_Complex_Types} |
| under control of the pragma, rather than use the preinstantiated versions. |
| @end table |
| |
| @node Pragma Favor_Top_Level,Pragma Finalize_Storage_Only,Pragma Fast_Math,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{5b} |
| @section Pragma Favor_Top_Level |
| |
| |
| Syntax: |
| |
| @example |
| pragma Favor_Top_Level (type_NAME); |
| @end example |
| |
| The named type must be an access-to-subprogram type. This pragma is an |
| efficiency hint to the compiler, regarding the use of 'Access or |
| 'Unrestricted_Access on nested (non-library-level) subprograms. The |
| pragma means that nested subprograms are not used with this type, or |
| are rare, so that the generated code should be efficient in the |
| top-level case. When this pragma is used, dynamically generated |
| trampolines may be used on some targets for nested subprograms. |
| See also the No_Implicit_Dynamic_Code restriction. |
| |
| @node Pragma Finalize_Storage_Only,Pragma Float_Representation,Pragma Favor_Top_Level,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-finalize-storage-only}@anchor{5c} |
| @section Pragma Finalize_Storage_Only |
| |
| |
| Syntax: |
| |
| @example |
| pragma Finalize_Storage_Only (first_subtype_LOCAL_NAME); |
| @end example |
| |
| This pragma allows the compiler not to emit a Finalize call for objects |
| defined at the library level. This is mostly useful for types where |
| finalization is only used to deal with storage reclamation since in most |
| environments it is not necessary to reclaim memory just before terminating |
| execution, hence the name. |
| |
| @node Pragma Float_Representation,Pragma Global,Pragma Finalize_Storage_Only,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-float-representation}@anchor{5d} |
| @section Pragma Float_Representation |
| |
| |
| Syntax: |
| |
| @example |
| pragma Float_Representation (FLOAT_REP[, float_type_LOCAL_NAME]); |
| |
| FLOAT_REP ::= VAX_Float | IEEE_Float |
| @end example |
| |
| In the one argument form, this pragma is a configuration pragma which |
| allows control over the internal representation chosen for the predefined |
| floating point types declared in the packages @cite{Standard} and |
| @cite{System}. This pragma is only provided for compatibility and has no effect. |
| |
| The two argument form specifies the representation to be used for |
| the specified floating-point type. The argument must |
| be @cite{IEEE_Float} to specify the use of IEEE format, as follows: |
| |
| |
| @itemize * |
| |
| @item |
| For a digits value of 6, 32-bit IEEE short format will be used. |
| |
| @item |
| For a digits value of 15, 64-bit IEEE long format will be used. |
| |
| @item |
| No other value of digits is permitted. |
| @end itemize |
| |
| @node Pragma Global,Pragma Ident,Pragma Float_Representation,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{5e} |
| @section Pragma Global |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 6.1.4. |
| |
| @node Pragma Ident,Pragma Ignore_Pragma,Pragma Global,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ident}@anchor{5f} |
| @section Pragma Ident |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ident (static_string_EXPRESSION); |
| @end example |
| |
| This pragma is identical in effect to pragma @cite{Comment}. It is provided |
| for compatibility with other Ada compilers providing this pragma. |
| |
| @node Pragma Ignore_Pragma,Pragma Implementation_Defined,Pragma Ident,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-ignore-pragma}@anchor{60} |
| @section Pragma Ignore_Pragma |
| |
| |
| Syntax: |
| |
| @example |
| pragma Ignore_Pragma (pragma_IDENTIFIER); |
| @end example |
| |
| This is a configuration pragma |
| that takes a single argument that is a simple identifier. Any subsequent |
| use of a pragma whose pragma identifier matches this argument will be |
| silently ignored. This may be useful when legacy code or code intended |
| for compilation with some other compiler contains pragmas that match the |
| name, but not the exact implementation, of a @cite{GNAT} pragma. The use of this |
| pragma allows such pragmas to be ignored, which may be useful in @cite{CodePeer} |
| mode, or during porting of legacy code. |
| |
| @node Pragma Implementation_Defined,Pragma Implemented,Pragma Ignore_Pragma,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-implementation-defined}@anchor{61} |
| @section Pragma Implementation_Defined |
| |
| |
| Syntax: |
| |
| @example |
| pragma Implementation_Defined (local_NAME); |
| @end example |
| |
| This pragma marks a previously declared entioty as implementation-defined. |
| For an overloaded entity, applies to the most recent homonym. |
| |
| @example |
| pragma Implementation_Defined; |
| @end example |
| |
| The form with no arguments appears anywhere within a scope, most |
| typically a package spec, and indicates that all entities that are |
| defined within the package spec are Implementation_Defined. |
| |
| This pragma is used within the GNAT runtime library to identify |
| implementation-defined entities introduced in language-defined units, |
| for the purpose of implementing the No_Implementation_Identifiers |
| restriction. |
| |
| @node Pragma Implemented,Pragma Implicit_Packing,Pragma Implementation_Defined,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-implemented}@anchor{62} |
| @section Pragma Implemented |
| |
| |
| Syntax: |
| |
| @example |
| pragma Implemented (procedure_LOCAL_NAME, implementation_kind); |
| |
| implementation_kind ::= By_Entry | By_Protected_Procedure | By_Any |
| @end example |
| |
| This is an Ada 2012 representation pragma which applies to protected, task |
| and synchronized interface primitives. The use of pragma Implemented provides |
| a way to impose a static requirement on the overriding operation by adhering |
| to one of the three implementation kinds: entry, protected procedure or any of |
| the above. This pragma is available in all earlier versions of Ada as an |
| implementation-defined pragma. |
| |
| @example |
| type Synch_Iface is synchronized interface; |
| procedure Prim_Op (Obj : in out Iface) is abstract; |
| pragma Implemented (Prim_Op, By_Protected_Procedure); |
| |
| protected type Prot_1 is new Synch_Iface with |
| procedure Prim_Op; -- Legal |
| end Prot_1; |
| |
| protected type Prot_2 is new Synch_Iface with |
| entry Prim_Op; -- Illegal |
| end Prot_2; |
| |
| task type Task_Typ is new Synch_Iface with |
| entry Prim_Op; -- Illegal |
| end Task_Typ; |
| @end example |
| |
| When applied to the procedure_or_entry_NAME of a requeue statement, pragma |
| Implemented determines the runtime behavior of the requeue. Implementation kind |
| By_Entry guarantees that the action of requeueing will proceed from an entry to |
| another entry. Implementation kind By_Protected_Procedure transforms the |
| requeue into a dispatching call, thus eliminating the chance of blocking. Kind |
| By_Any shares the behavior of By_Entry and By_Protected_Procedure depending on |
| the target's overriding subprogram kind. |
| |
| @node Pragma Implicit_Packing,Pragma Import_Function,Pragma Implemented,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-implicit-packing}@anchor{63} |
| @section Pragma Implicit_Packing |
| |
| |
| @geindex Rational Profile |
| |
| Syntax: |
| |
| @example |
| pragma Implicit_Packing; |
| @end example |
| |
| This is a configuration pragma that requests implicit packing for packed |
| arrays for which a size clause is given but no explicit pragma Pack or |
| specification of Component_Size is present. It also applies to records |
| where no record representation clause is present. Consider this example: |
| |
| @example |
| type R is array (0 .. 7) of Boolean; |
| for R'Size use 8; |
| @end example |
| |
| In accordance with the recommendation in the RM (RM 13.3(53)), a Size clause |
| does not change the layout of a composite object. So the Size clause in the |
| above example is normally rejected, since the default layout of the array uses |
| 8-bit components, and thus the array requires a minimum of 64 bits. |
| |
| If this declaration is compiled in a region of code covered by an occurrence |
| of the configuration pragma Implicit_Packing, then the Size clause in this |
| and similar examples will cause implicit packing and thus be accepted. For |
| this implicit packing to occur, the type in question must be an array of small |
| components whose size is known at compile time, and the Size clause must |
| specify the exact size that corresponds to the number of elements in the array |
| multiplied by the size in bits of the component type (both single and |
| multi-dimensioned arrays can be controlled with this pragma). |
| |
| @geindex Array packing |
| |
| Similarly, the following example shows the use in the record case |
| |
| @example |
| type r is record |
| a, b, c, d, e, f, g, h : boolean; |
| chr : character; |
| end record; |
| for r'size use 16; |
| @end example |
| |
| Without a pragma Pack, each Boolean field requires 8 bits, so the |
| minimum size is 72 bits, but with a pragma Pack, 16 bits would be |
| sufficient. The use of pragma Implicit_Packing allows this record |
| declaration to compile without an explicit pragma Pack. |
| |
| @node Pragma Import_Function,Pragma Import_Object,Pragma Implicit_Packing,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-import-function}@anchor{64} |
| @section Pragma Import_Function |
| |
| |
| Syntax: |
| |
| @example |
| pragma Import_Function ( |
| [Internal =>] LOCAL_NAME, |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Parameter_Types =>] PARAMETER_TYPES] |
| [, [Result_Type =>] SUBTYPE_MARK] |
| [, [Mechanism =>] MECHANISM] |
| [, [Result_Mechanism =>] MECHANISM_NAME]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| |
| PARAMETER_TYPES ::= |
| null |
| | TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@} |
| |
| TYPE_DESIGNATOR ::= |
| subtype_NAME |
| | subtype_Name ' Access |
| |
| MECHANISM ::= |
| MECHANISM_NAME |
| | (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@}) |
| |
| MECHANISM_ASSOCIATION ::= |
| [formal_parameter_NAME =>] MECHANISM_NAME |
| |
| MECHANISM_NAME ::= |
| Value |
| | Reference |
| @end example |
| |
| This pragma is used in conjunction with a pragma @cite{Import} to |
| specify additional information for an imported function. The pragma |
| @cite{Import} (or equivalent pragma @cite{Interface}) must precede the |
| @cite{Import_Function} pragma and both must appear in the same |
| declarative part as the function specification. |
| |
| The @cite{Internal} argument must uniquely designate |
| the function to which the |
| pragma applies. If more than one function name exists of this name in |
| the declarative part you must use the @cite{Parameter_Types} and |
| @cite{Result_Type} parameters to achieve the required unique |
| designation. Subtype marks in these parameters must exactly match the |
| subtypes in the corresponding function specification, using positional |
| notation to match parameters with subtype marks. |
| The form with an @cite{'Access} attribute can be used to match an |
| anonymous access parameter. |
| |
| You may optionally use the @cite{Mechanism} and @cite{Result_Mechanism} |
| parameters to specify passing mechanisms for the |
| parameters and result. If you specify a single mechanism name, it |
| applies to all parameters. Otherwise you may specify a mechanism on a |
| parameter by parameter basis using either positional or named |
| notation. If the mechanism is not specified, the default mechanism |
| is used. |
| |
| @node Pragma Import_Object,Pragma Import_Procedure,Pragma Import_Function,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-import-object}@anchor{65} |
| @section Pragma Import_Object |
| |
| |
| Syntax: |
| |
| @example |
| pragma Import_Object |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Size =>] EXTERNAL_SYMBOL]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| @end example |
| |
| This pragma designates an object as imported, and apart from the |
| extended rules for external symbols, is identical in effect to the use of |
| the normal @cite{Import} pragma applied to an object. Unlike the |
| subprogram case, you need not use a separate @cite{Import} pragma, |
| although you may do so (and probably should do so from a portability |
| point of view). @cite{size} is syntax checked, but otherwise ignored by |
| GNAT. |
| |
| @node Pragma Import_Procedure,Pragma Import_Valued_Procedure,Pragma Import_Object,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-import-procedure}@anchor{66} |
| @section Pragma Import_Procedure |
| |
| |
| Syntax: |
| |
| @example |
| pragma Import_Procedure ( |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Parameter_Types =>] PARAMETER_TYPES] |
| [, [Mechanism =>] MECHANISM]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| |
| PARAMETER_TYPES ::= |
| null |
| | TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@} |
| |
| TYPE_DESIGNATOR ::= |
| subtype_NAME |
| | subtype_Name ' Access |
| |
| MECHANISM ::= |
| MECHANISM_NAME |
| | (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@}) |
| |
| MECHANISM_ASSOCIATION ::= |
| [formal_parameter_NAME =>] MECHANISM_NAME |
| |
| MECHANISM_NAME ::= Value | Reference |
| @end example |
| |
| This pragma is identical to @cite{Import_Function} except that it |
| applies to a procedure rather than a function and the parameters |
| @cite{Result_Type} and @cite{Result_Mechanism} are not permitted. |
| |
| @node Pragma Import_Valued_Procedure,Pragma Independent,Pragma Import_Procedure,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-import-valued-procedure}@anchor{67} |
| @section Pragma Import_Valued_Procedure |
| |
| |
| Syntax: |
| |
| @example |
| pragma Import_Valued_Procedure ( |
| [Internal =>] LOCAL_NAME |
| [, [External =>] EXTERNAL_SYMBOL] |
| [, [Parameter_Types =>] PARAMETER_TYPES] |
| [, [Mechanism =>] MECHANISM]); |
| |
| EXTERNAL_SYMBOL ::= |
| IDENTIFIER |
| | static_string_EXPRESSION |
| |
| PARAMETER_TYPES ::= |
| null |
| | TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@} |
| |
| TYPE_DESIGNATOR ::= |
| subtype_NAME |
| | subtype_Name ' Access |
| |
| MECHANISM ::= |
| MECHANISM_NAME |
| | (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@}) |
| |
| MECHANISM_ASSOCIATION ::= |
| [formal_parameter_NAME =>] MECHANISM_NAME |
| |
| MECHANISM_NAME ::= Value | Reference |
| @end example |
| |
| This pragma is identical to @cite{Import_Procedure} except that the |
| first parameter of @cite{LOCAL_NAME}, which must be present, must be of |
| mode @cite{OUT}, and externally the subprogram is treated as a function |
| with this parameter as the result of the function. The purpose of this |
| capability is to allow the use of @cite{OUT} and @cite{IN OUT} |
| parameters in interfacing to external functions (which are not permitted |
| in Ada functions). You may optionally use the @cite{Mechanism} |
| parameters to specify passing mechanisms for the parameters. |
| If you specify a single mechanism name, it applies to all parameters. |
| Otherwise you may specify a mechanism on a parameter by parameter |
| basis using either positional or named notation. If the mechanism is not |
| specified, the default mechanism is used. |
| |
| Note that it is important to use this pragma in conjunction with a separate |
| pragma Import that specifies the desired convention, since otherwise the |
| default convention is Ada, which is almost certainly not what is required. |
| |
| @node Pragma Independent,Pragma Independent_Components,Pragma Import_Valued_Procedure,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-independent}@anchor{68} |
| @section Pragma Independent |
| |
| |
| Syntax: |
| |
| @example |
| pragma Independent (Local_NAME); |
| @end example |
| |
| This pragma is standard in Ada 2012 mode (which also provides an aspect |
| of the same name). It is also available as an implementation-defined |
| pragma in all earlier versions. It specifies that the |
| designated object or all objects of the designated type must be |
| independently addressable. This means that separate tasks can safely |
| manipulate such objects. For example, if two components of a record are |
| independent, then two separate tasks may access these two components. |
| This may place |
| constraints on the representation of the object (for instance prohibiting |
| tight packing). |
| |
| @node Pragma Independent_Components,Pragma Initial_Condition,Pragma Independent,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-independent-components}@anchor{69} |
| @section Pragma Independent_Components |
| |
| |
| Syntax: |
| |
| @example |
| pragma Independent_Components (Local_NAME); |
| @end example |
| |
| This pragma is standard in Ada 2012 mode (which also provides an aspect |
| of the same name). It is also available as an implementation-defined |
| pragma in all earlier versions. It specifies that the components of the |
| designated object, or the components of each object of the designated |
| type, must be |
| independently addressable. This means that separate tasks can safely |
| manipulate separate components in the composite object. This may place |
| constraints on the representation of the object (for instance prohibiting |
| tight packing). |
| |
| @node Pragma Initial_Condition,Pragma Initialize_Scalars,Pragma Independent_Components,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{6a} |
| @section Pragma Initial_Condition |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.6. |
| |
| @node Pragma Initialize_Scalars,Pragma Initializes,Pragma Initial_Condition,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-initialize-scalars}@anchor{6b} |
| @section Pragma Initialize_Scalars |
| |
| |
| @geindex debugging with Initialize_Scalars |
| |
| Syntax: |
| |
| @example |
| pragma Initialize_Scalars; |
| @end example |
| |
| This pragma is similar to @cite{Normalize_Scalars} conceptually but has |
| two important differences. First, there is no requirement for the pragma |
| to be used uniformly in all units of a partition, in particular, it is fine |
| to use this just for some or all of the application units of a partition, |
| without needing to recompile the run-time library. |
| |
| In the case where some units are compiled with the pragma, and some without, |
| then a declaration of a variable where the type is defined in package |
| Standard or is locally declared will always be subject to initialization, |
| as will any declaration of a scalar variable. For composite variables, |
| whether the variable is initialized may also depend on whether the package |
| in which the type of the variable is declared is compiled with the pragma. |
| |
| The other important difference is that you can control the value used |
| for initializing scalar objects. At bind time, you can select several |
| options for initialization. You can |
| initialize with invalid values (similar to Normalize_Scalars, though for |
| Initialize_Scalars it is not always possible to determine the invalid |
| values in complex cases like signed component fields with non-standard |
| sizes). You can also initialize with high or |
| low values, or with a specified bit pattern. See the GNAT |
| User's Guide for binder options for specifying these cases. |
| |
| This means that you can compile a program, and then without having to |
| recompile the program, you can run it with different values being used |
| for initializing otherwise uninitialized values, to test if your program |
| behavior depends on the choice. Of course the behavior should not change, |
| and if it does, then most likely you have an incorrect reference to an |
| uninitialized value. |
| |
| It is even possible to change the value at execution time eliminating even |
| the need to rebind with a different switch using an environment variable. |
| See the GNAT User's Guide for details. |
| |
| Note that pragma @cite{Initialize_Scalars} is particularly useful in |
| conjunction with the enhanced validity checking that is now provided |
| in GNAT, which checks for invalid values under more conditions. |
| Using this feature (see description of the @emph{-gnatV} flag in the |
| GNAT User's Guide) in conjunction with |
| pragma @cite{Initialize_Scalars} |
| provides a powerful new tool to assist in the detection of problems |
| caused by uninitialized variables. |
| |
| Note: the use of @cite{Initialize_Scalars} has a fairly extensive |
| effect on the generated code. This may cause your code to be |
| substantially larger. It may also cause an increase in the amount |
| of stack required, so it is probably a good idea to turn on stack |
| checking (see description of stack checking in the GNAT |
| User's Guide) when using this pragma. |
| |
| @node Pragma Initializes,Pragma Inline_Always,Pragma Initialize_Scalars,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{6c} |
| @section Pragma Initializes |
| |
| |
| For the description of this pragma, see SPARK 2014 Reference Manual, |
| section 7.1.5. |
| |
| @node Pragma Inline_Always,Pragma Inline_Generic,Pragma Initializes,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{6d} |
| @section Pragma Inline_Always |
| |
| |
| Syntax: |
| |
| @example |
| pragma Inline_Always (NAME [, NAME]); |
| @end example |
| |
| Similar to pragma @cite{Inline} except that inlining is not subject to |
| the use of option @emph{-gnatn} or @emph{-gnatN} and the inlining |
| happens regardless of whether these options are used. |
| |
| @node Pragma Inline_Generic,Pragma Interface,Pragma Inline_Always,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-inline-generic}@anchor{6e} |
| @section Pragma Inline_Generic |
| |
| |
| Syntax: |
| |
| @example |
| pragma Inline_Generic (GNAME @{, GNAME@}); |
| |
| GNAME ::= generic_unit_NAME | generic_instance_NAME |
| @end example |
| |
| This pragma is provided for compatibility with Dec Ada 83. It has |
| no effect in @cite{GNAT} (which always inlines generics), other |
| than to check that the given names are all names of generic units or |
| generic instances. |
| |
| @node Pragma Interface,Pragma Interface_Name,Pragma Inline_Generic,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-interface}@anchor{6f} |
| @section Pragma Interface |
| |
| |
| Syntax: |
| |
| @example |
| pragma Interface ( |
| [Convention =>] convention_identifier, |
| [Entity =>] local_NAME |
| [, [External_Name =>] static_string_expression] |
| [, [Link_Name =>] static_string_expression]); |
| @end example |
| |
| This pragma is identical in syntax and semantics to |
| the standard Ada pragma @cite{Import}. It is provided for compatibility |
| with Ada 83. The definition is upwards compatible both with pragma |
| @cite{Interface} as defined in the Ada 83 Reference Manual, and also |
| with some extended implementations of this pragma in certain Ada 83 |
| implementations. The only difference between pragma @cite{Interface} |
| and pragma @cite{Import} is that there is special circuitry to allow |
| both pragmas to appear for the same subprogram entity (normally it |
| is illegal to have multiple @cite{Import} pragmas. This is useful in |
| maintaining Ada 83/Ada 95 compatibility and is compatible with other |
| Ada 83 compilers. |
| |
| @node Pragma Interface_Name,Pragma Interrupt_Handler,Pragma Interface,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-interface-name}@anchor{70} |
| @section Pragma Interface_Name |
| |
| |
| Syntax: |
| |
| @example |
| pragma Interface_Name ( |
| [Entity =>] LOCAL_NAME |
| [, [External_Name =>] static_string_EXPRESSION] |
| [, [Link_Name =>] static_string_EXPRESSION]); |
| @end example |
| |
| This pragma provides an alternative way of specifying the interface name |
| for an interfaced subprogram, and is provided for compatibility with Ada |
| 83 compilers that use the pragma for this purpose. You must provide at |
| least one of @cite{External_Name} or @cite{Link_Name}. |
| |
| @node Pragma Interrupt_Handler,Pragma Interrupt_State,Pragma Interface_Name,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-handler}@anchor{71} |
| @section Pragma Interrupt_Handler |
| |
| |
| Syntax: |
| |
| @example |
| pragma Interrupt_Handler (procedure_LOCAL_NAME); |
| @end example |
| |
| This program unit pragma is supported for parameterless protected procedures |
| as described in Annex C of the Ada Reference Manual. On the AAMP target |
| the pragma can also be specified for nonprotected parameterless procedures |
| that are declared at the library level (which includes procedures |
| declared at the top level of a library package). In the case of AAMP, |
| when this pragma is applied to a nonprotected procedure, the instruction |
| @cite{IERET} is generated for returns from the procedure, enabling |
| maskable interrupts, in place of the normal return instruction. |
| |
| @node Pragma Interrupt_State,Pragma Invariant,Pragma Interrupt_Handler,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{72} |
| @section Pragma Interrupt_State |
| |
| |
| Syntax: |
| |
| @example |
| pragma Interrupt_State |
| ([Name =>] value, |
| [State =>] SYSTEM | RUNTIME | USER); |
| @end example |
| |
| Normally certain interrupts are reserved to the implementation. Any attempt |
| to attach an interrupt causes Program_Error to be raised, as described in |
| RM C.3.2(22). A typical example is the @cite{SIGINT} interrupt used in |
| many systems for an @code{Ctrl-C} interrupt. Normally this interrupt is |
| reserved to the implementation, so that @code{Ctrl-C} can be used to |
| interrupt execution. Additionally, signals such as @cite{SIGSEGV}, |
| @cite{SIGABRT}, @cite{SIGFPE} and @cite{SIGILL} are often mapped to specific |
| Ada exceptions, or used to implement run-time functions such as the |
| @cite{abort} statement and stack overflow checking. |
| |
| Pragma @cite{Interrupt_State} provides a general mechanism for overriding |
| such uses of interrupts. It subsumes the functionality of pragma |
| @cite{Unreserve_All_Interrupts}. Pragma @cite{Interrupt_State} is not |
| available on Windows or VMS. On all other platforms than VxWorks, |
| it applies to signals; on VxWorks, it applies to vectored hardware interrupts |
| and may be used to mark interrupts required by the board support package |
| as reserved. |
| |
| Interrupts can be in one of three states: |
| |
| |
| @itemize * |
| |
| @item |
| System |
| |
| The interrupt is reserved (no Ada handler can be installed), and the |
| Ada run-time may not install a handler. As a result you are guaranteed |
| standard system default action if this interrupt is raised. |
| |
| @item |
| Runtime |
| |
| The interrupt is reserved (no Ada handler can be installed). The run time |
| is allowed to install a handler for internal control purposes, but is |
| not required to do so. |
| |
| @item |
| User |
| |
| The interrupt is unreserved. The user may install a handler to provide |
| some other action. |
| @end itemize |
| |
| These states are the allowed values of the @cite{State} parameter of the |
| pragma. The @cite{Name} parameter is a value of the type |
| @cite{Ada.Interrupts.Interrupt_ID}. Typically, it is a name declared in |
| @cite{Ada.Interrupts.Names}. |
| |
| This is a configuration pragma, and the binder will check that there |
| are no inconsistencies between different units in a partition in how a |
| given interrupt is specified. It may appear anywhere a pragma is legal. |
| |
| The effect is to move the interrupt to the specified state. |
| |
| By declaring interrupts to be SYSTEM, you guarantee the standard system |
| action, such as a core dump. |
| |
| By declaring interrupts to be USER, you guarantee that you can install |
| a handler. |
| |
| Note that certain signals on many operating systems cannot be caught and |
| handled by applications. In such cases, the pragma is ignored. See the |
| operating system documentation, or the value of the array @cite{Reserved} |
| declared in the spec of package @cite{System.OS_Interface}. |
| |
| Overriding the default state of signals used by the Ada runtime may interfere |
| with an application's runtime behavior in the cases of the synchronous signals, |
| and in the case of the signal used to implement the @cite{abort} statement. |
| |
| @node Pragma Invariant,Pragma Java_Constructor,Pragma Interrupt_State,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{73} |
| @section Pragma Invariant |
| |
| |
| Syntax: |
| |
| @example |
| pragma Invariant |
| ([Entity =>] private_type_LOCAL_NAME, |
| [Check =>] EXPRESSION |
| [,[Message =>] String_Expression]); |
| @end example |
| |
| This pragma provides exactly the same capabilities as the Type_Invariant aspect |
| defined in AI05-0146-1, and in the Ada 2012 Reference Manual. The |
| Type_Invariant aspect is fully implemented in Ada 2012 mode, but since it |
| requires the use of the aspect syntax, which is not available except in 2012 |
| mode, it is not possible to use the Type_Invariant aspect in earlier versions |
| of Ada. However the Invariant pragma may be used in any version of Ada. Also |
| note that the aspect Invariant is a synonym in GNAT for the aspect |
| Type_Invariant, but there is no pragma Type_Invariant. |
| |
| The pragma must appear within the visible part of the package specification, |
| after the type to which its Entity argument appears. As with the Invariant |
| aspect, the Check expression is not analyzed until the end of the visible |
| part of the package, so it may contain forward references. The Message |
| argument, if present, provides the exception message used if the invariant |
| is violated. If no Message parameter is provided, a default message that |
| identifies the line on which the pragma appears is used. |
| |
| It is permissible to have multiple Invariants for the same type entity, in |
| which case they are and'ed together. It is permissible to use this pragma |
| in Ada 2012 mode, but you cannot have both an invariant aspect and an |
| invariant pragma for the same entity. |
| |
| For further details on the use of this pragma, see the Ada 2012 documentation |
| of the Type_Invariant aspect. |
| |
| @node Pragma Java_Constructor,Pragma Java_Interface,Pragma Invariant,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-java-constructor}@anchor{74} |
| @section Pragma Java_Constructor |
| |
| |
| Syntax: |
| |
| @example |
| pragma Java_Constructor ([Entity =>] function_LOCAL_NAME); |
| @end example |
| |
| This pragma is used to assert that the specified Ada function should be |
| mapped to the Java constructor for some Ada tagged record type. |
| |
| See section 7.3.2 of the |
| @cite{GNAT User's Guide: Supplement for the JVM Platform.} |
| for related information. |
| |
| @node Pragma Java_Interface,Pragma Keep_Names,Pragma Java_Constructor,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-java-interface}@anchor{75} |
| @section Pragma Java_Interface |
| |
| |
| Syntax: |
| |
| @example |
| pragma Java_Interface ([Entity =>] abstract_tagged_type_LOCAL_NAME); |
| @end example |
| |
| This pragma is used to assert that the specified Ada abstract tagged type |
| is to be mapped to a Java interface name. |
| |
| See sections 7.1 and 7.2 of the |
| @cite{GNAT User's Guide: Supplement for the JVM Platform.} |
| for related information. |
| |
| @node Pragma Keep_Names,Pragma License,Pragma Java_Interface,Implementation Defined Pragmas |
| @anchor{gnat_rm/implementation_defined_pragmas pragma-keep-names}@anchor{76} |
| @section Pragma Keep_Names |
| |
| |
| Syntax: |
