This is gnat_rm.info, produced by makeinfo version 7.1 from gnat_rm.texi. GNAT Reference Manual , Dec 21, 2023 AdaCore Copyright © 2008-2024, Free Software Foundation INFO-DIR-SECTION GNU Ada Tools START-INFO-DIR-ENTRY * gnat_rm: (gnat_rm.info). gnat_rm END-INFO-DIR-ENTRY Generated by Sphinx 5.3.0.  File: gnat_rm.info, Node: GNAT language extensions, Next: Security Hardening Features, Prev: Implementation of Ada 2012 Features, Up: Top 17 GNAT language extensions *************************** The GNAT compiler implements a certain number of language extensions on top of the latest Ada standard, implementing its own extended superset of Ada. There are two sets of language extensions: * The first is the curated set. The features in that set are features that we consider being worthy additions to the Ada language, and that we want to make available to users early on. * The second is the experimental set. It includes the first, but also experimental features, that are here because they’re still in an early prototyping phase. * Menu: * How to activate the extended GNAT Ada superset:: * Curated Extensions:: * Experimental Language Extensions::  File: gnat_rm.info, Node: How to activate the extended GNAT Ada superset, Next: Curated Extensions, Up: GNAT language extensions 17.1 How to activate the extended GNAT Ada superset =================================================== There are two ways to activate the extended GNAT Ada superset: * The *note Pragma Extensions_Allowed: 67. To activate the curated set of extensions, you should use pragma Extensions_Allowed (On) As a configuration pragma, you can either put it at the beginning of a source file, or in a ‘.adc’ file corresponding to your project. * The ‘-gnatX’ option, that you can pass to the compiler directly, will activate the curated subset of extensions. Attention: You can activate the extended set of extensions by using either the ‘-gnatX0’ command line flag, or the pragma ‘Extensions_Allowed’ with ‘All’ as an argument. However, it is not recommended you use this subset for serious projects, and is only means as a playground/technology preview.  File: gnat_rm.info, Node: Curated Extensions, Next: Experimental Language Extensions, Prev: How to activate the extended GNAT Ada superset, Up: GNAT language extensions 17.2 Curated Extensions ======================= * Menu: * Local Declarations Without Block:: * Conditional when constructs:: * Case pattern matching:: * Fixed lower bounds for array types and subtypes:: * Prefixed-view notation for calls to primitive subprograms of untagged types:: * Expression defaults for generic formal functions:: * String interpolation:: * Constrained attribute for generic objects:: * Static aspect on intrinsic functions::  File: gnat_rm.info, Node: Local Declarations Without Block, Next: Conditional when constructs, Up: Curated Extensions 17.2.1 Local Declarations Without Block --------------------------------------- A basic_declarative_item may appear at the place of any statement. This avoids the heavy syntax of block_statements just to declare something locally. Link to the original RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-local-vars-without-block.md’ For example: if X > 5 then X := X + 1; Squared : constant Integer := X**2; X := X + Squared; end if;  File: gnat_rm.info, Node: Conditional when constructs, Next: Case pattern matching, Prev: Local Declarations Without Block, Up: Curated Extensions 17.2.2 Conditional when constructs ---------------------------------- This feature extends the use of ‘when’ as a way to condition a control-flow related statement, to all control-flow related statements. To do a conditional return in a procedure the following syntax should be used: procedure P (Condition : Boolean) is begin return when Condition; end; This will return from the procedure if ‘Condition’ is true. When being used in a function the conditional part comes after the return value: function Is_Null (I : Integer) return Boolean is begin return True when I = 0; return False; end; In a similar way to the ‘exit when’ a ‘goto ... when’ can be employed: procedure Low_Level_Optimized is Flags : Bitmapping; begin Do_1 (Flags); goto Cleanup when Flags (1); Do_2 (Flags); goto Cleanup when Flags (32); -- ... <> -- ... end; To use a conditional raise construct: procedure Foo is begin raise Error when Imported_C_Func /= 0; end; An exception message can also be added: procedure Foo is begin raise Error with "Unix Error" when Imported_C_Func /= 0; end; Link to the original RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-conditional-when-constructs.rst’  File: gnat_rm.info, Node: Case pattern matching, Next: Fixed lower bounds for array types and subtypes, Prev: Conditional when constructs, Up: Curated Extensions 17.2.3 Case pattern matching ---------------------------- The selector for a case statement (but not yet for a case expression) may be of a composite type, subject to some restrictions (described below). Aggregate syntax is used for choices of such a case statement; however, in cases where a “normal” aggregate would require a discrete value, a discrete subtype may be used instead; box notation can also be used to match all values. Consider this example: type Rec is record F1, F2 : Integer; end record; procedure Caser_1 (X : Rec) is begin case X is when (F1 => Positive, F2 => Positive) => Do_This; when (F1 => Natural, F2 => <>) | (F1 => <>, F2 => Natural) => Do_That; when others => Do_The_Other_Thing; end case; end Caser_1; If ‘Caser_1’ is called and both components of X are positive, then ‘Do_This’ will be called; otherwise, if either component is nonnegative then ‘Do_That’ will be called; otherwise, ‘Do_The_Other_Thing’ will be called. In addition, pattern bindings are supported. This is a mechanism for binding a name to a component of a matching value for use within an alternative of a case statement. For a component association that occurs within a case choice, the expression may be followed by ‘is ’. In the special case of a “box” component association, the identifier may instead be provided within the box. Either of these indicates that the given identifier denotes (a constant view of) the matching subcomponent of the case selector. Attention: Binding is not yet supported for arrays or subcomponents thereof. Consider this example (which uses type ‘Rec’ from the previous example): procedure Caser_2 (X : Rec) is begin case X is when (F1 => Positive is Abc, F2 => Positive) => Do_This (Abc) when (F1 => Natural is N1, F2 => ) | (F1 => , F2 => Natural is N1) => Do_That (Param_1 => N1, Param_2 => N2); when others => Do_The_Other_Thing; end case; end Caser_2; This example is the same as the previous one with respect to determining whether ‘Do_This’, ‘Do_That’, or ‘Do_The_Other_Thing’ will be called. But for this version, ‘Do_This’ takes a parameter and ‘Do_That’ takes two parameters. If ‘Do_This’ is called, the actual parameter in the call will be ‘X.F1’. If ‘Do_That’ is called, the situation is more complex because there are two choices for that alternative. If ‘Do_That’ is called because the first choice matched (i.e., because ‘X.F1’ is nonnegative and either ‘X.F1’ or ‘X.F2’ is zero or negative), then the actual parameters of the call will be (in order) ‘X.F1’ and ‘X.F2’. If ‘Do_That’ is called because the second choice matched (and the first one did not), then the actual parameters will be reversed. Within the choice list for single alternative, each choice must define the same set of bindings and the component subtypes for for a given identifer must all statically match. Currently, the case of a binding for a nondiscrete component is not implemented. If the set of values that match the choice(s) of an earlier alternative overlaps the corresponding set of a later alternative, then the first set shall be a proper subset of the second (and the later alternative will not be executed if the earlier alternative “matches”). All possible values of the composite type shall be covered. The composite type of the selector shall be an array or record type that is neither limited nor class-wide. Currently, a “when others =>” case choice is required; it is intended that this requirement will be relaxed at some point. If a subcomponent’s subtype does not meet certain restrictions, then the only value that can be specified for that subcomponent in a case choice expression is a “box” component association (which matches all possible values for the subcomponent). This restriction applies if: - the component subtype is not a record, array, or discrete type; or - the component subtype is subject to a non-static constraint or has a predicate; or: - the component type is an enumeration type that is subject to an enumeration representation clause; or - the component type is a multidimensional array type or an array type with a nonstatic index subtype. Support for casing on arrays (and on records that contain arrays) is currently subject to some restrictions. Non-positional array aggregates are not supported as (or within) case choices. Likewise for array type and subtype names. The current implementation exceeds compile-time capacity limits in some annoyingly common scenarios; the message generated in such cases is usually “Capacity exceeded in compiling case statement with composite selector type”. Link to the original RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-pattern-matching.rst’  File: gnat_rm.info, Node: Fixed lower bounds for array types and subtypes, Next: Prefixed-view notation for calls to primitive subprograms of untagged types, Prev: Case pattern matching, Up: Curated Extensions 17.2.4 Fixed lower bounds for array types and subtypes ------------------------------------------------------ Unconstrained array types and subtypes can be specified with a lower bound that is fixed to a certain value, by writing an index range that uses the syntax ‘ .. <>’. This guarantees that all objects of the type or subtype will have the specified lower bound. For example, a matrix type with fixed lower bounds of zero for each dimension can be declared by the following: type Matrix is array (Natural range 0 .. <>, Natural range 0 .. <>) of Integer; Objects of type ‘Matrix’ declared with an index constraint must have index ranges starting at zero: M1 : Matrix (0 .. 9, 0 .. 19); M2 : Matrix (2 .. 11, 3 .. 22); -- Warning about bounds; will raise CE Similarly, a subtype of ‘String’ can be declared that specifies the lower bound of objects of that subtype to be ‘1’: subtype String_1 is String (1 .. <>); If a string slice is passed to a formal of subtype ‘String_1’ in a call to a subprogram ‘S’, the slice’s bounds will “slide” so that the lower bound is ‘1’. Within ‘S’, the lower bound of the formal is known to be ‘1’, so, unlike a normal unconstrained ‘String’ formal, there is no need to worry about accounting for other possible lower-bound values. Sliding of bounds also occurs in other contexts, such as for object declarations with an unconstrained subtype with fixed lower bound, as well as in subtype conversions. Use of this feature increases safety by simplifying code, and can also improve the efficiency of indexing operations, since the compiler statically knows the lower bound of unconstrained array formals when the formal’s subtype has index ranges with static fixed lower bounds. Link to the original RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-fixed-lower-bound.rst’  File: gnat_rm.info, Node: Prefixed-view notation for calls to primitive subprograms of untagged types, Next: Expression defaults for generic formal functions, Prev: Fixed lower bounds for array types and subtypes, Up: Curated Extensions 17.2.5 Prefixed-view notation for calls to primitive subprograms of untagged types ---------------------------------------------------------------------------------- When operating on an untagged type, if it has any primitive operations, and the first parameter of an operation is of the type (or is an access parameter with an anonymous type that designates the type), you may invoke these operations using an ‘object.op(...)’ notation, where the parameter that would normally be the first parameter is brought out front, and the remaining parameters (if any) appear within parentheses after the name of the primitive operation. This same notation is already available for tagged types. This extension allows for untagged types. It is allowed for all primitive operations of the type independent of whether they were originally declared in a package spec or its private part, or were inherited and/or overridden as part of a derived type declaration occuring anywhere, so long as the first parameter is of the type, or an access parameter designating the type. For example: generic type Elem_Type is private; package Vectors is type Vector is private; procedure Add_Element (V : in out Vector; Elem : Elem_Type); function Nth_Element (V : Vector; N : Positive) return Elem_Type; function Length (V : Vector) return Natural; private function Capacity (V : Vector) return Natural; -- Return number of elements that may be added without causing -- any new allocation of space type Vector is ... with Type_Invariant => Vector.Length <= Vector.Capacity; ... end Vectors; package Int_Vecs is new Vectors(Integer); V : Int_Vecs.Vector; ... V.Add_Element(42); V.Add_Element(-33); pragma Assert (V.Length = 2); pragma Assert (V.Nth_Element(1) = 42); Link to the original RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-prefixed-untagged.rst’  File: gnat_rm.info, Node: Expression defaults for generic formal functions, Next: String interpolation, Prev: Prefixed-view notation for calls to primitive subprograms of untagged types, Up: Curated Extensions 17.2.6 Expression defaults for generic formal functions ------------------------------------------------------- The declaration of a generic formal function is allowed to specify an expression as a default, using the syntax of an expression function. Here is an example of this feature: generic type T is private; with function Copy (Item : T) return T is (Item); -- Defaults to Item package Stacks is type Stack is limited private; procedure Push (S : in out Stack; X : T); -- Calls Copy on X function Pop (S : in out Stack) return T; -- Calls Copy to return item private -- ... end Stacks; Link to the original RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-expression-functions-as-default-for-generic-formal-function-parameters.rst’  File: gnat_rm.info, Node: String interpolation, Next: Constrained attribute for generic objects, Prev: Expression defaults for generic formal functions, Up: Curated Extensions 17.2.7 String interpolation --------------------------- The syntax for string literals is extended to support string interpolation. Within an interpolated string literal, an arbitrary expression, when enclosed in ‘{ ... }’, is expanded at run time into the result of calling ‘'Image’ on the result of evaluating the expression enclosed by the brace characters, unless it is already a string or a single character. Here is an example of this feature where the expressions ‘Name’ and ‘X + Y’ will be evaluated and included in the string. procedure Test_Interpolation is X : Integer := 12; Y : Integer := 15; Name : String := "Leo"; begin Put_Line (f"The name is {Name} and the sum is {X + Y}."); end Test_Interpolation; In addition, an escape character (‘\’) is provided for inserting certain standard control characters (such as ‘\t’ for tabulation or ‘\n’ for newline) or to escape characters with special significance to the interpolated string syntax, namely ‘"’, ‘{’, ‘}’,and ‘\’ itself. escaped_character meaning ‘\a’ ALERT ‘\b’ BACKSPACE ‘\f’ FORM FEED ‘\n’ LINE FEED ‘\r’ CARRIAGE RETURN ‘\t’ CHARACTER TABULATION ‘\v’ LINE TABULATION ‘\0’ NUL ‘\\’ ‘\’ ‘\"’ ‘"’ ‘\{’ ‘{’ ‘\}’ ‘}’ Note that, unlike normal string literals, doubled characters have no special significance. So to include a double-quote or a brace character in an interpolated string, they must be preceded by a ‘\’. For example: Put_Line (f"X = {X} and Y = {Y} and X+Y = {X+Y};\n" & f" a double quote is \" and" & f" an open brace is \{"); Finally, a syntax is provided for creating multi-line string literals, without having to explicitly use an escape sequence such as ‘\n’. For example: Put_Line (f"This is a multi-line" "string literal" "There is no ambiguity about how many" "spaces are included in each line"); Here is a link to the original RFC : ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-string-interpolation.rst’  File: gnat_rm.info, Node: Constrained attribute for generic objects, Next: Static aspect on intrinsic functions, Prev: String interpolation, Up: Curated Extensions 17.2.8 Constrained attribute for generic objects ------------------------------------------------ The ‘Constrained’ attribute is permitted for objects of generic types. The result indicates whether the corresponding actual is constrained.  File: gnat_rm.info, Node: Static aspect on intrinsic functions, Prev: Constrained attribute for generic objects, Up: Curated Extensions 17.2.9 ‘Static’ aspect on intrinsic functions --------------------------------------------- The Ada 202x ‘Static’ aspect can be specified on Intrinsic imported functions and the compiler will evaluate some of these intrinsics statically, in particular the ‘Shift_Left’ and ‘Shift_Right’ intrinsics.  File: gnat_rm.info, Node: Experimental Language Extensions, Prev: Curated Extensions, Up: GNAT language extensions 17.3 Experimental Language Extensions ===================================== * Menu: * Pragma Storage_Model:: * Simpler accessibility model::  File: gnat_rm.info, Node: Pragma Storage_Model, Next: Simpler accessibility model, Up: Experimental Language Extensions 17.3.1 Pragma Storage_Model --------------------------- This feature proposes to redesign the concepts of Storage Pools into a more efficient model allowing higher performances and easier integration with low footprint embedded run-times. It also extends it to support distributed memory models, in particular to support interactions with GPU. Here is a link to the full RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-storage-model.rst’  File: gnat_rm.info, Node: Simpler accessibility model, Prev: Pragma Storage_Model, Up: Experimental Language Extensions 17.3.2 Simpler accessibility model ---------------------------------- The goal of this feature is to restore a common understanding of accessibility rules for implementers and users alike. The new rules should both be effective at preventing errors and feel natural and compatible in an Ada environment while removing dynamic accessibility checking. Here is a link to the full RFC: ‘https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-simpler-accessibility.md’  File: gnat_rm.info, Node: Security Hardening Features, Next: Obsolescent Features, Prev: GNAT language extensions, Up: Top 18 Security Hardening Features ****************************** This chapter describes Ada extensions aimed at security hardening that are provided by GNAT. The features in this chapter are currently experimental and subject to change. * Menu: * Register Scrubbing:: * Stack Scrubbing:: * Hardened Conditionals:: * Hardened Booleans:: * Control Flow Redundancy::  File: gnat_rm.info, Node: Register Scrubbing, Next: Stack Scrubbing, Up: Security Hardening Features 18.1 Register Scrubbing ======================= GNAT can generate code to zero-out hardware registers before returning from a subprogram. It can be enabled with the ‘-fzero-call-used-regs=`choice'’ command-line option, to affect all subprograms in a compilation, and with a ‘Machine_Attribute’ pragma, to affect only specific subprograms. procedure Foo; pragma Machine_Attribute (Foo, "zero_call_used_regs", "used"); -- Before returning, Foo scrubs only call-clobbered registers -- that it uses itself. function Bar return Integer; pragma Machine_Attribute (Bar, "zero_call_used_regs", "all"); -- Before returning, Bar scrubs all call-clobbered registers. function Baz return Integer; pragma Machine_Attribute (Bar, "zero_call_used_regs", "leafy"); -- Before returning, Bar scrubs call-clobbered registers, either -- those it uses itself, if it can be identified as a leaf -- function, or all of them otherwise. For usage and more details on the command-line option, on the ‘zero_call_used_regs’ attribute, and on their use with other programming languages, see ‘Using the GNU Compiler Collection (GCC)’.  File: gnat_rm.info, Node: Stack Scrubbing, Next: Hardened Conditionals, Prev: Register Scrubbing, Up: Security Hardening Features 18.2 Stack Scrubbing ==================== GNAT can generate code to zero-out stack frames used by subprograms. It can be activated with the ‘Machine_Attribute’ pragma, on specific subprograms and variables, or their types. (This attribute always applies to a type, even when it is associated with a subprogram or a variable.) function Foo returns Integer; pragma Machine_Attribute (Foo, "strub"); -- Foo and its callers are modified so as to scrub the stack -- space used by Foo after it returns. Shorthand for: -- pragma Machine_Attribute (Foo, "strub", "at-calls"); procedure Bar; pragma Machine_Attribute (Bar, "strub", "internal"); -- Bar is turned into a wrapper for its original body, -- and they scrub the stack used by the original body. Var : Integer; pragma Machine_Attribute (Var, "strub"); -- Reading from Var in a subprogram enables stack scrubbing -- of the stack space used by the subprogram. Furthermore, if -- Var is declared within a subprogram, this also enables -- scrubbing of the stack space used by that subprogram. Given these declarations, Foo has its type and body modified as follows: function Foo ( : in out System.Address) returns Integer is -- ... begin <__strub_update> (); -- Updates the stack WaterMark. -- ... end; whereas its callers are modified from: X := Foo; to: declare : System.Address; begin <__strub_enter> (); -- Initialize . X := Foo (); <__strub_leave> (); -- Scrubs stack up to . end; As for Bar, because it is strubbed in internal mode, its callers are not modified. Its definition is modified roughly as follows: procedure Bar is : System.Address; procedure Strubbed_Bar ( : in out System.Address) is begin <__strub_update> (); -- Updates the stack WaterMark. -- original Bar body. end Strubbed_Bar; begin <__strub_enter> (); -- Initialize . Strubbed_Bar (); <__strub_leave> (); -- Scrubs stack up to . end Bar; There are also ‘-fstrub=`choice'’ command-line options to control default settings. For usage and more details on the command-line options, on the ‘strub’ attribute, and their use with other programming languages, see ‘Using the GNU Compiler Collection (GCC)’. Note that Ada secondary stacks are not scrubbed. The restriction ‘No_Secondary_Stack’ avoids their use, and thus their accidental preservation of data that should be scrubbed. Attributes ‘Access’ and ‘Unconstrained_Access’ of variables and constants with ‘strub’ enabled require types with ‘strub’ enabled; there is no way to express an access-to-strub type otherwise. ‘Unchecked_Access’ bypasses this constraint, but the resulting access type designates a non-strub type. VI : aliased Integer; pragma Machine_Attribute (VI, "strub"); XsVI : access Integer := VI'Access; -- Error. UXsVI : access Integer := VI'Unchecked_Access; -- OK, -- UXsVI does *not* enable strub in subprograms that -- dereference it to obtain the UXsVI.all value. type Strub_Int is new Integer; pragma Machine_Attribute (Strub_Int, "strub"); VSI : aliased Strub_Int; XsVSI : access Strub_Int := VSI'Access; -- OK, -- VSI and XsVSI.all both enable strub in subprograms that -- read their values. Every access-to-subprogram type, renaming, and overriding and overridden dispatching operations that may refer to a subprogram with an attribute-modified interface must be annotated with the same interface-modifying attribute. Access-to-subprogram types can be explicitly converted to different strub modes, as long as they are interface-compatible (i.e., adding or removing ‘at-calls’ is not allowed). For example, a ‘strub’-‘disabled’ subprogram can be turned ‘callable’ through such an explicit conversion: type TBar is access procedure; type TBar_Callable is access procedure; pragma Machine_Attribute (TBar_Callable, "strub", "callable"); -- The attribute modifies the procedure type, rather than the -- access type, because of the extra argument after "strub", -- only applicable to subprogram types. Bar_Callable_Ptr : constant TBar_Callable := TBar_Callable (TBar'(Bar'Access)); procedure Bar_Callable renames Bar_Callable_Ptr.all; pragma Machine_Attribute (Bar_Callable, "strub", "callable"); Note that the renaming declaration is expanded to a full subprogram body, it won’t be just an alias. Only if it is inlined will it be as efficient as a call by dereferencing the access-to-subprogram constant Bar_Callable_Ptr.  File: gnat_rm.info, Node: Hardened Conditionals, Next: Hardened Booleans, Prev: Stack Scrubbing, Up: Security Hardening Features 18.3 Hardened Conditionals ========================== GNAT can harden conditionals to protect against control-flow attacks. This is accomplished by two complementary transformations, each activated by a separate command-line option. The option ‘-fharden-compares’ enables hardening of compares that compute results stored in variables, adding verification that the reversed compare yields the opposite result, turning: B := X = Y; into: B := X = Y; declare NotB : Boolean := X /= Y; -- Computed independently of B. begin if B = NotB then <__builtin_trap>; end if; end; The option ‘-fharden-conditional-branches’ enables hardening of compares that guard conditional branches, adding verification of the reversed compare to both execution paths, turning: if X = Y then X := Z + 1; else Y := Z - 1; end if; into: if X = Y then if X /= Y then -- Computed independently of X = Y. <__builtin_trap>; end if; X := Z + 1; else if X /= Y then -- Computed independently of X = Y. null; else <__builtin_trap>; end if; Y := Z - 1; end if; These transformations are introduced late in the compilation pipeline, long after boolean expressions are decomposed into separate compares, each one turned into either a conditional branch or a compare whose result is stored in a boolean variable or temporary. Compiler optimizations, if enabled, may also turn conditional branches into stored compares, and vice-versa, or into operations with implied conditionals (e.g. MIN and MAX). Conditionals may also be optimized out entirely, if their value can be determined at compile time, and occasionally multiple compares can be combined into one. It is thus difficult to predict which of these two options will affect a specific compare operation expressed in source code. Using both options ensures that every compare that is neither optimized out nor optimized into implied conditionals will be hardened. The addition of reversed compares can be observed by enabling the dump files of the corresponding passes, through command-line options ‘-fdump-tree-hardcmp’ and ‘-fdump-tree-hardcbr’, respectively. They are separate options, however, because of the significantly different performance impact of the hardening transformations. For usage and more details on the command-line options, see ‘Using the GNU Compiler Collection (GCC)’. These options can be used with other programming languages supported by GCC.  File: gnat_rm.info, Node: Hardened Booleans, Next: Control Flow Redundancy, Prev: Hardened Conditionals, Up: Security Hardening Features 18.4 Hardened Booleans ====================== Ada has built-in support for introducing boolean types with alternative representations, using representation clauses: type HBool is new Boolean; for HBool use (16#5a#, 16#a5#); for HBool'Size use 8; When validity checking is enabled, the compiler will check that variables of such types hold values corresponding to the selected representations. There are multiple strategies for where to introduce validity checking (see ‘-gnatV’ options). Their goal is to guard against various kinds of programming errors, and GNAT strives to omit checks when program logic rules out an invalid value, and optimizers may further remove checks found to be redundant. For additional hardening, the ‘hardbool’ ‘Machine_Attribute’ pragma can be used to annotate boolean types with representation clauses, so that expressions of such types used as conditions are checked even when compiling with ‘-gnatVT’: pragma Machine_Attribute (HBool, "hardbool"); function To_Boolean (X : HBool) returns Boolean is (Boolean (X)); is compiled roughly like: function To_Boolean (X : HBool) returns Boolean is begin if X not in True | False then raise Constraint_Error; elsif X in True then return True; else return False; end if; end To_Boolean; Note that ‘-gnatVn’ will disable even ‘hardbool’ testing. Analogous behavior is available as a GCC extension to the C and Objective C programming languages, through the ‘hardbool’ attribute, with the difference that, instead of raising a Constraint_Error exception, when a hardened boolean variable is found to hold a value that stands for neither True nor False, the program traps. For usage and more details on that attribute, see ‘Using the GNU Compiler Collection (GCC)’.  File: gnat_rm.info, Node: Control Flow Redundancy, Prev: Hardened Booleans, Up: Security Hardening Features 18.5 Control Flow Redundancy ============================ GNAT can guard against unexpected execution flows, such as branching into the middle of subprograms, as in Return Oriented Programming exploits. In units compiled with ‘-fharden-control-flow-redundancy’, subprograms are instrumented so that, every time they are called, basic blocks take note as control flows through them, and, before returning, subprograms verify that the taken notes are consistent with the control-flow graph. The performance impact of verification on leaf subprograms can be much higher, while the averted risks are much lower on them. Instrumentation can be disabled for leaf subprograms with ‘-fhardcfr-skip-leaf’. Functions with too many basic blocks, or with multiple return points, call a run-time function to perform the verification. Other functions perform the verification inline before returning. Optimizing the inlined verification can be quite time consuming, so the default upper limit for the inline mode is set at 16 blocks. Command-line option ‘--param hardcfr-max-inline-blocks=’ can override it. Even though typically sparse control-flow graphs exhibit run-time verification time nearly proportional to the block count of a subprogram, it may become very significant for generated subprograms with thousands of blocks. Command-line option ‘--param hardcfr-max-blocks=’ can set an upper limit for instrumentation. For each block that is marked as visited, the mechanism checks that at least one of its predecessors, and at least one of its successors, are also marked as visited. Verification is performed just before a subprogram returns. The following fragment: if X then Y := F (Z); return; end if; gets turned into: type Visited_Bitmap is array (1..N) of Boolean with Pack; Visited : aliased Visited_Bitmap := (others => False); -- Bitmap of visited blocks. N is the basic block count. [...] -- Basic block #I Visited(I) := True; if X then -- Basic block #J Visited(J) := True; Y := F (Z); CFR.Check (N, Visited'Access, CFG'Access); -- CFR is a hypothetical package whose Check procedure calls -- libgcc's __hardcfr_check, that traps if the Visited bitmap -- does not hold a valid path in CFG, the run-time -- representation of the control flow graph in the enclosing -- subprogram. return; end if; -- Basic block #K Visited(K) := True; Verification would also be performed before tail calls, if any front-ends marked them as mandatory or desirable, but none do. Regular calls are optimized into tail calls too late for this transformation to act on it. In order to avoid adding verification after potential tail calls, which would prevent tail-call optimization, we recognize returning calls, i.e., calls whose result, if any, is returned by the calling subprogram to its caller immediately after the call returns. Verification is performed before such calls, whether or not they are ultimately optimized to tail calls. This behavior is enabled by default whenever sibcall optimization is enabled (see ‘-foptimize-sibling-calls’); it may be disabled with ‘-fno-hardcfr-check-returning-calls’, or enabled with ‘-fhardcfr-check-returning-calls’, regardless of the optimization, but the lack of other optimizations may prevent calls from being recognized as returning calls: -- CFR.Check here, with -fhardcfr-check-returning-calls. P (X); -- CFR.Check here, with -fno-hardcfr-check-returning-calls. return; or: -- CFR.Check here, with -fhardcfr-check-returning-calls. R := F (X); -- CFR.Check here, with -fno-hardcfr-check-returning-calls. return R; Any subprogram from which an exception may escape, i.e., that may raise or propagate an exception that isn’t handled internally, is conceptually enclosed by a cleanup handler that performs verification, unless this is disabled with ‘-fno-hardcfr-check-exceptions’. With this feature enabled, a subprogram body containing: -- ... Y := F (X); -- May raise exceptions. -- ... raise E; -- Not handled internally. -- ... gets modified as follows: begin -- ... Y := F (X); -- May raise exceptions. -- ... raise E; -- Not handled internally. -- ... exception when others => CFR.Check (N, Visited'Access, CFG'Access); raise; end; Verification may also be performed before No_Return calls, whether all of them, with ‘-fhardcfr-check-noreturn-calls=always’; all but internal subprograms involved in exception-raising or -reraising or subprograms explicitly marked with both ‘No_Return’ and ‘Machine_Attribute’ ‘expected_throw’ pragmas, with ‘-fhardcfr-check-noreturn-calls=no-xthrow’ (default); only nothrow ones, with ‘-fhardcfr-check-noreturn-calls=nothrow’; or none, with ‘-fhardcfr-check-noreturn-calls=never’. When a No_Return call returns control to its caller through an exception, verification may have already been performed before the call, if ‘-fhardcfr-check-noreturn-calls=always’ or ‘-fhardcfr-check-noreturn-calls=no-xthrow’ is in effect. The compiler arranges for already-checked No_Return calls without a preexisting handler to bypass the implicitly-added cleanup handler and thus the redundant check, but a local exception or cleanup handler, if present, will modify the set of visited blocks, and checking will take place again when the caller reaches the next verification point, whether it is a return or reraise statement after the exception is otherwise handled, or even another No_Return call. The instrumentation for hardening with control flow redundancy can be observed in dump files generated by the command-line option ‘-fdump-tree-hardcfr’. For more details on the control flow redundancy command-line options, see ‘Using the GNU Compiler Collection (GCC)’. These options can be used with other programming languages supported by GCC.  File: gnat_rm.info, Node: Obsolescent Features, Next: Compatibility and Porting Guide, Prev: Security Hardening Features, Up: Top 19 Obsolescent Features *********************** This chapter describes features that are provided by GNAT, but are considered obsolescent since there are preferred ways of achieving the same effect. These features are provided solely for historical compatibility purposes. * Menu: * 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.  File: gnat_rm.info, Node: pragma No_Run_Time, Next: pragma Ravenscar, Up: Obsolescent Features 19.1 pragma No_Run_Time ======================= The pragma ‘No_Run_Time’ is used to achieve an affect similar to the use of the “Zero Foot Print” configurable run time, but without requiring a specially configured run time. The result of using this pragma, which must be used for all units in a partition, is to restrict the use of any language features requiring run-time support code. The preferred usage is to use an appropriately configured run-time that includes just those features that are to be made accessible.  File: gnat_rm.info, Node: pragma Ravenscar, Next: pragma Restricted_Run_Time, Prev: pragma No_Run_Time, Up: Obsolescent Features 19.2 pragma Ravenscar ===================== The pragma ‘Ravenscar’ has exactly the same effect as pragma ‘Profile (Ravenscar)’. The latter usage is preferred since it is part of the new Ada 2005 standard.  File: gnat_rm.info, Node: pragma Restricted_Run_Time, Next: pragma Task_Info, Prev: pragma Ravenscar, Up: Obsolescent Features 19.3 pragma Restricted_Run_Time =============================== The pragma ‘Restricted_Run_Time’ has exactly the same effect as pragma ‘Profile (Restricted)’. The latter usage is preferred since the Ada 2005 pragma ‘Profile’ is intended for this kind of implementation dependent addition.  File: gnat_rm.info, Node: pragma Task_Info, Next: package System Task_Info s-tasinf ads, Prev: pragma Restricted_Run_Time, Up: Obsolescent Features 19.4 pragma Task_Info ===================== The functionality provided by pragma ‘Task_Info’ is now part of the Ada language. The ‘CPU’ aspect and the package ‘System.Multiprocessors’ offer a less system-dependent way to specify task affinity or to query the number of processors. Syntax pragma Task_Info (EXPRESSION); This pragma appears within a task definition (like pragma ‘Priority’) and applies to the task in which it appears. The argument must be of type ‘System.Task_Info.Task_Info_Type’. The ‘Task_Info’ pragma provides system dependent control over aspects of tasking implementation, for example, the ability to map tasks to specific processors. For details on the facilities available for the version of GNAT that you are using, see the documentation in the spec of package System.Task_Info in the runtime library.  File: gnat_rm.info, Node: package System Task_Info s-tasinf ads, Prev: pragma Task_Info, Up: Obsolescent Features 19.5 package System.Task_Info (‘s-tasinf.ads’) ============================================== This package provides target dependent functionality that is used to support the ‘Task_Info’ pragma. The predefined Ada package ‘System.Multiprocessors’ and the ‘CPU’ aspect now provide a standard replacement for GNAT’s ‘Task_Info’ functionality.  File: gnat_rm.info, Node: Compatibility and Porting Guide, Next: GNU Free Documentation License, Prev: Obsolescent Features, Up: Top 20 Compatibility and Porting Guide ********************************** This chapter 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. * Menu: * 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::  File: gnat_rm.info, Node: Writing Portable Fixed-Point Declarations, Next: Compatibility with Ada 83, Up: Compatibility and Porting Guide 20.1 Writing Portable Fixed-Point Declarations ============================================== The Ada Reference Manual gives an implementation freedom to choose bounds that are narrower by ‘Small’ from the given bounds. For example, if we write type F1 is delta 1.0 range -128.0 .. +128.0; then the implementation is allowed to choose -128.0 .. +127.0 if it likes, but is not required to do so. This leads to possible portability problems, so let’s have a closer look at this, and figure out how to avoid these problems. First, why does this freedom exist, and why would an implementation take advantage of it? To answer this, take a closer look at the type declaration for ‘F1’ above. If the compiler uses the given bounds, it would need 9 bits to hold the largest positive value (and typically that means 16 bits on all machines). But if the implementation chooses the +127.0 bound then it can fit values of the type in 8 bits. Why not make the user write +127.0 if that’s what is wanted? The rationale is that if you are thinking of fixed point as a kind of ‘poor man’s floating-point’, then you don’t want to be thinking about the scaled integers that are used in its representation. Let’s take another example: type F2 is delta 2.0**(-15) range -1.0 .. +1.0; Looking at this declaration, it seems casually as though it should fit in 16 bits, but again that extra positive value +1.0 has the scaled integer equivalent of 2**15 which is one too big for signed 16 bits. The implementation can treat this as: type F2 is delta 2.0**(-15) range -1.0 .. +1.0-(2.0**(-15)); and the Ada language design team felt that this was too annoying to require. We don’t need to debate this decision at this point, since it is well established (the rule about narrowing the ranges dates to Ada 83). But the important point is that an implementation is not required to do this narrowing, so we have a potential portability problem. We could imagine three types of implementation: a. those that narrow the range automatically if they can figure out that the narrower range will allow storage in a smaller machine unit, b. those that will narrow only if forced to by a ‘'Size’ clause, and c. those that will never narrow. Now if we are language theoreticians, we can imagine a fourth approach: to narrow all the time, e.g. to treat type F3 is delta 1.0 range -10.0 .. +23.0; as though it had been written: type F3 is delta 1.0 range -9.0 .. +22.0; But although technically allowed, such a behavior would be hostile and silly, and no real compiler would do this. All real compilers will fall into one of the categories (a), (b) or (c) above. So, how do you get the compiler to do what you want? The answer is give the actual bounds you want, and then use a ‘'Small’ clause and a ‘'Size’ clause to absolutely pin down what the compiler does. E.g., for ‘F2’ above, we will write: My_Small : constant := 2.0**(-15); My_First : constant := -1.0; My_Last : constant := +1.0 - My_Small; type F2 is delta My_Small range My_First .. My_Last; and then add for F2'Small use my_Small; for F2'Size use 16; In practice all compilers will do the same thing here and will give you what you want, so the above declarations are fully portable. If you really want to play language lawyer and guard against ludicrous behavior by the compiler you could add Test1 : constant := 1 / Boolean'Pos (F2'First = My_First); Test2 : constant := 1 / Boolean'Pos (F2'Last = My_Last); One or other or both are allowed to be illegal if the compiler is behaving in a silly manner, but at least the silly compiler will not get away with silently messing with your (very clear) intentions. If you follow this scheme you will be guaranteed that your fixed-point types will be portable.  File: gnat_rm.info, Node: Compatibility with Ada 83, Next: Compatibility between Ada 95 and Ada 2005, Prev: Writing Portable Fixed-Point Declarations, Up: Compatibility and Porting Guide 20.2 Compatibility with Ada 83 ============================== Ada 95 and the subsequent revisions Ada 2005 and Ada 2012 are highly upwards compatible with Ada 83. In particular, the design intention was that the difficulties associated with moving from Ada 83 to later versions of the standard should be no greater than those that occur when moving from one Ada 83 system to another. However, there are a number of points at which there are minor incompatibilities. The ‘Ada 95 Annotated Reference Manual’ contains full details of these issues as they relate to Ada 95, and should be consulted for a complete treatment. In practice the following subsections treat the most likely issues to be encountered. * Menu: * Legal Ada 83 programs that are illegal in Ada 95:: * More deterministic semantics:: * Changed semantics:: * Other language compatibility issues::  File: gnat_rm.info, Node: Legal Ada 83 programs that are illegal in Ada 95, Next: More deterministic semantics, Up: Compatibility with Ada 83 20.2.1 Legal Ada 83 programs that are illegal in Ada 95 ------------------------------------------------------- Some legal Ada 83 programs are illegal (i.e., they will fail to compile) in Ada 95 and later versions of the standard: * 'Character literals' Some uses of character literals are ambiguous. Since Ada 95 has introduced ‘Wide_Character’ as a new predefined character type, some uses of character literals that were legal in Ada 83 are illegal in Ada 95. For example: for Char in 'A' .. 'Z' loop ... end loop; The problem is that ‘A’ and ‘Z’ could be from either ‘Character’ or ‘Wide_Character’. The simplest correction is to make the type explicit; e.g.: for Char in Character range 'A' .. 'Z' loop ... end loop; * 'New reserved words' The identifiers ‘abstract’, ‘aliased’, ‘protected’, ‘requeue’, ‘tagged’, and ‘until’ are reserved in Ada 95. Existing Ada 83 code using any of these identifiers must be edited to use some alternative name. * 'Freezing rules' The rules in Ada 95 are slightly different with regard to the point at which entities are frozen, and representation pragmas and clauses are not permitted past the freeze point. This shows up most typically in the form of an error message complaining that a representation item appears too late, and the appropriate corrective action is to move the item nearer to the declaration of the entity to which it refers. A particular case is that representation pragmas cannot be applied to a subprogram body. If necessary, a separate subprogram declaration must be introduced to which the pragma can be applied. * 'Optional bodies for library packages' In Ada 83, a package that did not require a package body was nevertheless allowed to have one. This lead to certain surprises in compiling large systems (situations in which the body could be unexpectedly ignored by the binder). In Ada 95, if a package does not require a body then it is not permitted to have a body. To fix this problem, simply remove a redundant body if it is empty, or, if it is non-empty, introduce a dummy declaration into the spec that makes the body required. One approach is to add a private part to the package declaration (if necessary), and define a parameterless procedure called ‘Requires_Body’, which must then be given a dummy procedure body in the package body, which then becomes required. Another approach (assuming that this does not introduce elaboration circularities) is to add an ‘Elaborate_Body’ pragma to the package spec, since one effect of this pragma is to require the presence of a package body. * 'Numeric_Error is the same exception as Constraint_Error' In Ada 95, the exception ‘Numeric_Error’ is a renaming of ‘Constraint_Error’. This means that it is illegal to have separate exception handlers for the two exceptions. The fix is simply to remove the handler for the ‘Numeric_Error’ case (since even in Ada 83, a compiler was free to raise ‘Constraint_Error’ in place of ‘Numeric_Error’ in all cases). * 'Indefinite subtypes in generics' In Ada 83, it was permissible to pass an indefinite type (e.g, ‘String’) as the actual for a generic formal private type, but then the instantiation would be illegal if there were any instances of declarations of variables of this type in the generic body. In Ada 95, to avoid this clear violation of the methodological principle known as the ‘contract model’, the generic declaration explicitly indicates whether or not such instantiations are permitted. If a generic formal parameter has explicit unknown discriminants, indicated by using ‘(<>)’ after the subtype name, then it can be instantiated with indefinite types, but no stand-alone variables can be declared of this type. Any attempt to declare such a variable will result in an illegality at the time the generic is declared. If the ‘(<>)’ notation is not used, then it is illegal to instantiate the generic with an indefinite type. This is the potential incompatibility issue when porting Ada 83 code to Ada 95. It will show up as a compile time error, and the fix is usually simply to add the ‘(<>)’ to the generic declaration.  File: gnat_rm.info, Node: More deterministic semantics, Next: Changed semantics, Prev: Legal Ada 83 programs that are illegal in Ada 95, Up: Compatibility with Ada 83 20.2.2 More deterministic semantics ----------------------------------- * 'Conversions' Conversions from real types to integer types round away from 0. In Ada 83 the conversion Integer(2.5) could deliver either 2 or 3 as its value. This implementation freedom was intended to support unbiased rounding in statistical applications, but in practice it interfered with portability. In Ada 95 the conversion semantics are unambiguous, and rounding away from 0 is required. Numeric code may be affected by this change in semantics. Note, though, that this issue is no worse than already existed in Ada 83 when porting code from one vendor to another. * 'Tasking' The Real-Time Annex introduces a set of policies that define the behavior of features that were implementation dependent in Ada 83, such as the order in which open select branches are executed.  File: gnat_rm.info, Node: Changed semantics, Next: Other language compatibility issues, Prev: More deterministic semantics, Up: Compatibility with Ada 83 20.2.3 Changed semantics ------------------------ The worst kind of incompatibility is one where a program that is legal in Ada 83 is also legal in Ada 95 but can have an effect in Ada 95 that was not possible in Ada 83. Fortunately this is extremely rare, but the one situation that you should be alert to is the change in the predefined type ‘Character’ from 7-bit ASCII to 8-bit Latin-1. * 'Range of type ''Character''' The range of ‘Standard.Character’ is now the full 256 characters of Latin-1, whereas in most Ada 83 implementations it was restricted to 128 characters. Although some of the effects of this change will be manifest in compile-time rejection of legal Ada 83 programs it is possible for a working Ada 83 program to have a different effect in Ada 95, one that was not permitted in Ada 83. As an example, the expression ‘Character'Pos(Character'Last)’ returned ‘127’ in Ada 83 and now delivers ‘255’ as its value. In general, you should look at the logic of any character-processing Ada 83 program and see whether it needs to be adapted to work correctly with Latin-1. Note that the predefined Ada 95 API has a character handling package that may be relevant if code needs to be adapted to account for the additional Latin-1 elements. The desirable fix is to modify the program to accommodate the full character set, but in some cases it may be convenient to define a subtype or derived type of Character that covers only the restricted range.  File: gnat_rm.info, Node: Other language compatibility issues, Prev: Changed semantics, Up: Compatibility with Ada 83 20.2.4 Other language compatibility issues ------------------------------------------ * '-gnat83' switch All implementations of GNAT provide a switch that causes GNAT to operate in Ada 83 mode. In this mode, some but not all compatibility problems of the type described above are handled automatically. For example, the new reserved words introduced in Ada 95 and Ada 2005 are treated simply as identifiers as in Ada 83. However, in practice, it is usually advisable to make the necessary modifications to the program to remove the need for using this switch. See the ‘Compiling Different Versions of Ada’ section in the ‘GNAT User’s Guide’. * Support for removed Ada 83 pragmas and attributes A number of pragmas and attributes from Ada 83 were removed from Ada 95, generally because they were replaced by other mechanisms. Ada 95 and Ada 2005 compilers are allowed, but not required, to implement these missing elements. In contrast with some other compilers, GNAT implements all such pragmas and attributes, eliminating this compatibility concern. These include ‘pragma Interface’ and the floating point type attributes (‘Emax’, ‘Mantissa’, etc.), among other items.  File: gnat_rm.info, Node: Compatibility between Ada 95 and Ada 2005, Next: Implementation-dependent characteristics, Prev: Compatibility with Ada 83, Up: Compatibility and Porting Guide 20.3 Compatibility between Ada 95 and Ada 2005 ============================================== Although Ada 2005 was designed to be upwards compatible with Ada 95, there are a number of incompatibilities. Several are enumerated below; for a complete description please see the ‘Annotated Ada 2005 Reference Manual’, or section 9.1.1 in ‘Rationale for Ada 2005’. * 'New reserved words.' The words ‘interface’, ‘overriding’ and ‘synchronized’ are reserved in Ada 2005. A pre-Ada 2005 program that uses any of these as an identifier will be illegal. * 'New declarations in predefined packages.' A number of packages in the predefined environment contain new declarations: ‘Ada.Exceptions’, ‘Ada.Real_Time’, ‘Ada.Strings’, ‘Ada.Strings.Fixed’, ‘Ada.Strings.Bounded’, ‘Ada.Strings.Unbounded’, ‘Ada.Strings.Wide_Fixed’, ‘Ada.Strings.Wide_Bounded’, ‘Ada.Strings.Wide_Unbounded’, ‘Ada.Tags’, ‘Ada.Text_IO’, and ‘Interfaces.C’. If an Ada 95 program does a ‘with’ and ‘use’ of any of these packages, the new declarations may cause name clashes. * 'Access parameters.' A nondispatching subprogram with an access parameter cannot be renamed as a dispatching operation. This was permitted in Ada 95. * 'Access types, discriminants, and constraints.' Rule changes in this area have led to some incompatibilities; for example, constrained subtypes of some access types are not permitted in Ada 2005. * 'Aggregates for limited types.' The allowance of aggregates for limited types in Ada 2005 raises the possibility of ambiguities in legal Ada 95 programs, since additional types now need to be considered in expression resolution. * 'Fixed-point multiplication and division.' Certain expressions involving ‘*’ or ‘/’ for a fixed-point type, which were legal in Ada 95 and invoked the predefined versions of these operations, are now ambiguous. The ambiguity may be resolved either by applying a type conversion to the expression, or by explicitly invoking the operation from package ‘Standard’. * 'Return-by-reference types.' The Ada 95 return-by-reference mechanism has been removed. Instead, the user can declare a function returning a value from an anonymous access type.  File: gnat_rm.info, Node: Implementation-dependent characteristics, Next: Compatibility with Other Ada Systems, Prev: Compatibility between Ada 95 and Ada 2005, Up: Compatibility and Porting Guide 20.4 Implementation-dependent characteristics ============================================= Although the Ada language defines the semantics of each construct as precisely as practical, in some situations (for example for reasons of efficiency, or where the effect is heavily dependent on the host or target platform) the implementation is allowed some freedom. In porting Ada 83 code to GNAT, you need to be aware of whether / how the existing code exercised such implementation dependencies. Such characteristics fall into several categories, and GNAT offers specific support in assisting the transition from certain Ada 83 compilers. * Menu: * Implementation-defined pragmas:: * Implementation-defined attributes:: * Libraries:: * Elaboration order:: * Target-specific aspects::  File: gnat_rm.info, Node: Implementation-defined pragmas, Next: Implementation-defined attributes, Up: Implementation-dependent characteristics 20.4.1 Implementation-defined pragmas ------------------------------------- Ada compilers are allowed to supplement the language-defined pragmas, and these are a potential source of non-portability. All GNAT-defined pragmas are described in *note Implementation Defined Pragmas: 7, and these include several that are specifically intended to correspond to other vendors’ Ada 83 pragmas. For migrating from VADS, the pragma ‘Use_VADS_Size’ may be useful. For compatibility with HP Ada 83, GNAT supplies the pragmas ‘Extend_System’, ‘Ident’, ‘Inline_Generic’, ‘Interface_Name’, ‘Passive’, ‘Suppress_All’, and ‘Volatile’. Other relevant pragmas include ‘External’ and ‘Link_With’. Some vendor-specific Ada 83 pragmas (‘Share_Generic’, ‘Subtitle’, and ‘Title’) are recognized, thus avoiding compiler rejection of units that contain such pragmas; they are not relevant in a GNAT context and hence are not otherwise implemented.  File: gnat_rm.info, Node: Implementation-defined attributes, Next: Libraries, Prev: Implementation-defined pragmas, Up: Implementation-dependent characteristics 20.4.2 Implementation-defined attributes ---------------------------------------- Analogous to pragmas, the set of attributes may be extended by an implementation. All GNAT-defined attributes are described in *note Implementation Defined Attributes: 8, and these include several that are specifically intended to correspond to other vendors’ Ada 83 attributes. For migrating from VADS, the attribute ‘VADS_Size’ may be useful. For compatibility with HP Ada 83, GNAT supplies the attributes ‘Bit’, ‘Machine_Size’ and ‘Type_Class’.  File: gnat_rm.info, Node: Libraries, Next: Elaboration order, Prev: Implementation-defined attributes, Up: Implementation-dependent characteristics 20.4.3 Libraries ---------------- Vendors may supply libraries to supplement the standard Ada API. If Ada 83 code uses vendor-specific libraries then there are several ways to manage this in Ada 95 and later versions of the standard: * If the source code for the libraries (specs and bodies) are available, then the libraries can be migrated in the same way as the application. * If the source code for the specs but not the bodies are available, then you can reimplement the bodies. * Some features introduced by Ada 95 obviate the need for library support. For example most Ada 83 vendors supplied a package for unsigned integers. The Ada 95 modular type feature is the preferred way to handle this need, so instead of migrating or reimplementing the unsigned integer package it may be preferable to retrofit the application using modular types.  File: gnat_rm.info, Node: Elaboration order, Next: Target-specific aspects, Prev: Libraries, Up: Implementation-dependent characteristics 20.4.4 Elaboration order ------------------------ The implementation can choose any elaboration order consistent with the unit dependency relationship. This freedom means that some orders can result in Program_Error being raised due to an ‘Access Before Elaboration’: an attempt to invoke a subprogram before its body has been elaborated, or to instantiate a generic before the generic body has been elaborated. By default GNAT attempts to choose a safe order (one that will not encounter access before elaboration problems) by implicitly inserting ‘Elaborate’ or ‘Elaborate_All’ pragmas where needed. However, this can lead to the creation of elaboration circularities and a resulting rejection of the program by gnatbind. This issue is thoroughly described in the 'Elaboration Order Handling in GNAT' appendix in the ‘GNAT User’s Guide’. In brief, there are several ways to deal with this situation: * Modify the program to eliminate the circularities, e.g., by moving elaboration-time code into explicitly-invoked procedures * Constrain the elaboration order by including explicit ‘Elaborate_Body’ or ‘Elaborate’ pragmas, and then inhibit the generation of implicit ‘Elaborate_All’ pragmas either globally (as an effect of the '-gnatE' switch) or locally (by selectively suppressing elaboration checks via pragma ‘Suppress(Elaboration_Check)’ when it is safe to do so).  File: gnat_rm.info, Node: Target-specific aspects, Prev: Elaboration order, Up: Implementation-dependent characteristics 20.4.5 Target-specific aspects ------------------------------ Low-level applications need to deal with machine addresses, data representations, interfacing with assembler code, and similar issues. If such an Ada 83 application is being ported to different target hardware (for example where the byte endianness has changed) then you will need to carefully examine the program logic; the porting effort will heavily depend on the robustness of the original design. Moreover, Ada 95 (and thus Ada 2005 and Ada 2012) are sometimes incompatible with typical Ada 83 compiler practices regarding implicit packing, the meaning of the Size attribute, and the size of access values. GNAT’s approach to these issues is described in *note Representation Clauses: 47a.  File: gnat_rm.info, Node: Compatibility with Other Ada Systems, Next: Representation Clauses, Prev: Implementation-dependent characteristics, Up: Compatibility and Porting Guide 20.5 Compatibility with Other Ada Systems ========================================= If programs avoid the use of implementation dependent and implementation defined features, as documented in the ‘Ada Reference Manual’, there should be a high degree of portability between GNAT and other Ada systems. The following are specific items which have proved troublesome in moving Ada 95 programs from GNAT to other Ada 95 compilers, but do not affect porting code to GNAT. (As of January 2007, GNAT is the only compiler available for Ada 2005; the following issues may or may not arise for Ada 2005 programs when other compilers appear.) * 'Ada 83 Pragmas and Attributes' Ada 95 compilers are allowed, but not required, to implement the missing Ada 83 pragmas and attributes that are no longer defined in Ada 95. GNAT implements all such pragmas and attributes, eliminating this as a compatibility concern, but some other Ada 95 compilers reject these pragmas and attributes. * 'Specialized Needs Annexes' GNAT implements the full set of special needs annexes. At the current time, it is the only Ada 95 compiler to do so. This means that programs making use of these features may not be portable to other Ada 95 compilation systems. * 'Representation Clauses' Some other Ada 95 compilers implement only the minimal set of representation clauses required by the Ada 95 reference manual. GNAT goes far beyond this minimal set, as described in the next section.  File: gnat_rm.info, Node: Representation Clauses, Next: Compatibility with HP Ada 83, Prev: Compatibility with Other Ada Systems, Up: Compatibility and Porting Guide 20.6 Representation Clauses =========================== The Ada 83 reference manual was quite vague in describing both the minimal required implementation of representation clauses, and also their precise effects. Ada 95 (and thus also Ada 2005) are much more explicit, but the minimal set of capabilities required is still quite limited. GNAT implements the full required set of capabilities in Ada 95 and Ada 2005, but also goes much further, and in particular an effort has been made to be compatible with existing Ada 83 usage to the greatest extent possible. A few cases exist in which Ada 83 compiler behavior is incompatible with the requirements in Ada 95 (and thus also Ada 2005). These are instances of intentional or accidental dependence on specific implementation dependent characteristics of these Ada 83 compilers. The following is a list of the cases most likely to arise in existing Ada 83 code. * 'Implicit Packing' Some Ada 83 compilers allowed a Size specification to cause implicit packing of an array or record. This could cause expensive implicit conversions for change of representation in the presence of derived types, and the Ada design intends to avoid this possibility. Subsequent AI’s were issued to make it clear that such implicit change of representation in response to a Size clause is inadvisable, and this recommendation is represented explicitly in the Ada 95 (and Ada 2005) Reference Manuals as implementation advice that is followed by GNAT. The problem will show up as an error message rejecting the size clause. The fix is simply to provide the explicit pragma ‘Pack’, or for more fine tuned control, provide a Component_Size clause. * 'Meaning of Size Attribute' The Size attribute in Ada 95 (and Ada 2005) for discrete types is defined as the minimal number of bits required to hold values of the type. For example, on a 32-bit machine, the size of ‘Natural’ will typically be 31 and not 32 (since no sign bit is required). Some Ada 83 compilers gave 31, and some 32 in this situation. This problem will usually show up as a compile time error, but not always. It is a good idea to check all uses of the ‘Size attribute when porting Ada 83 code. The GNAT specific attribute Object_Size can provide a useful way of duplicating the behavior of some Ada 83 compiler systems. * 'Size of Access Types' A common assumption in Ada 83 code is that an access type is in fact a pointer, and that therefore it will be the same size as a System.Address value. This assumption is true for GNAT in most cases with one exception. For the case of a pointer to an unconstrained array type (where the bounds may vary from one value of the access type to another), the default is to use a ‘fat pointer’, which is represented as two separate pointers, one to the bounds, and one to the array. This representation has a number of advantages, including improved efficiency. However, it may cause some difficulties in porting existing Ada 83 code which makes the assumption that, for example, pointers fit in 32 bits on a machine with 32-bit addressing. To get around this problem, GNAT also permits the use of ‘thin pointers’ for access types in this case (where the designated type is an unconstrained array type). These thin pointers are indeed the same size as a System.Address value. To specify a thin pointer, use a size clause for the type, for example: type X is access all String; for X'Size use Standard'Address_Size; which will cause the type X to be represented using a single pointer. When using this representation, the bounds are right behind the array. This representation is slightly less efficient, and does not allow quite such flexibility in the use of foreign pointers or in using the Unrestricted_Access attribute to create pointers to non-aliased objects. But for any standard portable use of the access type it will work in a functionally correct manner and allow porting of existing code. Note that another way of forcing a thin pointer representation is to use a component size clause for the element size in an array, or a record representation clause for an access field in a record. See the documentation of Unrestricted_Access in the GNAT RM for a full discussion of possible problems using this attribute in conjunction with thin pointers.  File: gnat_rm.info, Node: Compatibility with HP Ada 83, Prev: Representation Clauses, Up: Compatibility and Porting Guide 20.7 Compatibility with HP Ada 83 ================================= All the HP Ada 83 pragmas and attributes are recognized, although only a subset of them can sensibly be implemented. The description of pragmas in *note Implementation Defined Pragmas: 7. indicates whether or not they are applicable to GNAT. * 'Default floating-point representation' In GNAT, the default floating-point format is IEEE, whereas in HP Ada 83, it is VMS format. * 'System' the package System in GNAT exactly corresponds to the definition in the Ada 95 reference manual, which means that it excludes many of the HP Ada 83 extensions. However, a separate package Aux_DEC is provided that contains the additional definitions, and a special pragma, Extend_System allows this package to be treated transparently as an extension of package System.  File: gnat_rm.info, Node: GNU Free Documentation License, Next: Index, Prev: Compatibility and Porting Guide, Up: Top 21 GNU Free Documentation License ********************************* Version 1.3, 3 November 2008 Copyright 2000, 2001, 2002, 2007, 2008 Free Software Foundation, Inc ‘https://fsf.org/’ Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. 'Preamble' The purpose of this License is to make a manual, textbook, or other functional and useful document “free” in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others. This License is a kind of “copyleft”, which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software. We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference. '1. APPLICABILITY AND DEFINITIONS' This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The 'Document', below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as “'you'”. You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law. A “'Modified Version'” of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language. A “'Secondary Section'” is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them. The “'Invariant Sections'” are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none. The “'Cover Texts'” are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words. A “'Transparent'” copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not “Transparent” is called 'Opaque'. Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only. The “'Title Page'” means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, “Title Page” means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text. The “'publisher'” means any person or entity that distributes copies of the Document to the public. A section “'Entitled XYZ'” means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as “'Acknowledgements'”, “'Dedications'”, “'Endorsements'”, or “'History'”.) To “'Preserve the Title'” of such a section when you modify the Document means that it remains a section “Entitled XYZ” according to this definition. The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License. '2. VERBATIM COPYING' You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3. You may also lend copies, under the same conditions stated above, and you may publicly display copies. '3. COPYING IN QUANTITY' If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects. If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages. If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public. It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document. '4. MODIFICATIONS' You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version: A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission. B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement. C. State on the Title page the name of the publisher of the Modified Version, as the publisher. D. Preserve all the copyright notices of the Document. E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices. F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below. G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document’s license notice. H. Include an unaltered copy of this License. I. Preserve the section Entitled “History”, Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled “History” in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence. J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the “History” section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission. K. For any section Entitled “Acknowledgements” or “Dedications”, Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein. L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles. M. Delete any section Entitled “Endorsements”. Such a section may not be included in the Modified Version. N. Do not retitle any existing section to be Entitled “Endorsements” or to conflict in title with any Invariant Section. O. Preserve any Warranty Disclaimers. If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles. You may add a section Entitled “Endorsements”, provided it contains nothing but endorsements of your Modified Version by various parties—for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard. You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one. The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version. '5. COMBINING DOCUMENTS' You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers. The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work. In the combination, you must combine any sections Entitled “History” in the various original documents, forming one section Entitled “History”; likewise combine any sections Entitled “Acknowledgements”, and any sections Entitled “Dedications”. You must delete all sections Entitled “Endorsements”. '6. COLLECTIONS OF DOCUMENTS' You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects. You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document. '7. AGGREGATION WITH INDEPENDENT WORKS' A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an “aggregate” if the copyright resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document. If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document’s Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate. '8. TRANSLATION' Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail. If a section in the Document is Entitled “Acknowledgements”, “Dedications”, or “History”, the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title. '9. TERMINATION' You may not copy, modify, sublicense, or distribute the Document except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, or distribute it is void, and will automatically terminate your rights under this License. However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, receipt of a copy of some or all of the same material does not give you any rights to use it. '10. FUTURE REVISIONS OF THIS LICENSE' The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See ‘https://www.gnu.org/copyleft/’. Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License “or any later version” applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation. If the Document specifies that a proxy can decide which future versions of this License can be used, that proxy’s public statement of acceptance of a version permanently authorizes you to choose that version for the Document. '11. RELICENSING' “Massive Multiauthor Collaboration Site” (or “MMC Site”) means any World Wide Web server that publishes copyrightable works and also provides prominent facilities for anybody to edit those works. A public wiki that anybody can edit is an example of such a server. A “Massive Multiauthor Collaboration” (or “MMC”) contained in the site means any set of copyrightable works thus published on the MMC site. “CC-BY-SA” means the Creative Commons Attribution-Share Alike 3.0 license published by Creative Commons Corporation, a not-for-profit corporation with a principal place of business in San Francisco, California, as well as future copyleft versions of that license published by that same organization. “Incorporate” means to publish or republish a Document, in whole or in part, as part of another Document. An MMC is “eligible for relicensing” if it is licensed under this License, and if all works that were first published under this License somewhere other than this MMC, and subsequently incorporated in whole or in part into the MMC, (1) had no cover texts or invariant sections, and (2) were thus incorporated prior to November 1, 2008. The operator of an MMC Site may republish an MMC contained in the site under CC-BY-SA on the same site at any time before August 1, 2009, provided the MMC is eligible for relicensing. 'ADDENDUM: How to use this License for your documents' To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page: Copyright © YEAR YOUR NAME. 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, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled “GNU Free Documentation License”. If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “with … Texts.” line with this: with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST. If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation. If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.  File: gnat_rm.info, Node: Index, Prev: GNU Free Documentation License, Up: Top Index ***** [index] * Menu: * ___lock file (for shared passive packages): GNAT Implementation of Shared Passive Packages. (line 72) * -gnat12 option (gcc): Implementation of Ada 2012 Features. (line 6) * -gnatR (gcc): Determining the Representations chosen by GNAT. (line 6) * Abort_Signal: Attribute Abort_Signal. (line 6) * Abstract_State: Aspect Abstract_State. (line 6) * Access: Attribute Unrestricted_Access. (line 6) * Access values: Attribute Has_Access_Values. (line 6) * Accuracy: RM G 2 4 19 Accuracy Requirements. (line 17) * Accuracy requirements: RM G 1 2 49 Complex Elementary Functions. (line 17) * Ada 2005 Language Reference Manual: What This Reference Manual Contains. (line 79) * Ada 2012 implementation status: Implementation of Ada 2012 Features. (line 6) * Ada 83 attributes: Attribute Emax. (line 6) * Ada 83 attributes <1>: Attribute Epsilon. (line 6) * Ada 83 attributes <2>: Attribute Large. (line 6) * Ada 83 attributes <3>: Attribute Mantissa. (line 6) * Ada 83 attributes <4>: Attribute Safe_Emax. (line 6) * Ada 83 attributes <5>: Attribute Safe_Large. (line 6) * Ada 83 attributes <6>: Attribute Safe_Small. (line 6) * Ada 83 attributes <7>: Attribute Small. (line 6) * Ada 95 Language Reference Manual: What This Reference Manual Contains. (line 79) * Ada Extensions: Pragma Extensions_Allowed. (line 6) * Ada_2012 configuration pragma: Implementation of Ada 2012 Features. (line 6) * Ada.Characters.Handling: RM A 1 52 Names of Predefined Numeric Types. (line 13) * Ada.Characters.Latin_9 (a-chlat9.ads): Ada Characters Latin_9 a-chlat9 ads. (line 6) * Ada.Characters.Wide_Latin_1 (a-cwila1.ads): Ada Characters Wide_Latin_1 a-cwila1 ads. (line 6) * Ada.Characters.Wide_Latin_9 (a-cwila9.ads): Ada Characters Wide_Latin_9 a-cwila9 ads. (line 6) * Ada.Characters.Wide_Wide_Latin_1 (a-chzla1.ads): Ada Characters Wide_Wide_Latin_1 a-chzla1 ads. (line 6) * Ada.Characters.Wide_Wide_Latin_9 (a-chzla9.ads): Ada Characters Wide_Wide_Latin_9 a-chzla9 ads. (line 6) * Ada.Command_Line.Environment (a-colien.ads): Ada Command_Line Environment a-colien ads. (line 6) * Ada.Command_Line.Remove (a-colire.ads): Ada Command_Line Remove a-colire ads. (line 6) * Ada.Command_Line.Response_File (a-clrefi.ads): Ada Command_Line Response_File a-clrefi ads. (line 6) * Ada.Containers.Bounded_Holders (a-coboho.ads): Ada Containers Bounded_Holders a-coboho ads. (line 6) * Ada.Direct_IO.C_Streams (a-diocst.ads): Ada Direct_IO C_Streams a-diocst ads. (line 6) * Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads): Ada Exceptions Is_Null_Occurrence a-einuoc ads. (line 6) * Ada.Exceptions.Last_Chance_Handler (a-elchha.ads): Ada Exceptions Last_Chance_Handler a-elchha ads. (line 6) * Ada.Exceptions.Traceback (a-exctra.ads): Ada Exceptions Traceback a-exctra ads. (line 6) * Ada.Sequential_IO.C_Streams (a-siocst.ads): Ada Sequential_IO C_Streams a-siocst ads. (line 6) * Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads): Ada Streams Stream_IO C_Streams a-ssicst ads. (line 6) * Ada.Strings.Unbounded.Text_IO (a-suteio.ads): Ada Strings Unbounded Text_IO a-suteio ads. (line 6) * Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads): Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads. (line 6) * Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads): Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads. (line 6) * Ada.Task_Initialization (a-tasini.ads): Ada Task_Initialization a-tasini ads. (line 6) * Ada.Text_IO.C_Streams (a-tiocst.ads): Ada Text_IO C_Streams a-tiocst ads. (line 6) * Ada.Text_IO.Reset_Standard_Files (a-tirsfi.ads): Ada Text_IO Reset_Standard_Files a-tirsfi ads. (line 6) * Ada.Wide_Characters.Unicode (a-wichun.ads): Ada Wide_Characters Unicode a-wichun ads. (line 6) * Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads): Ada Wide_Text_IO C_Streams a-wtcstr ads. (line 6) * Ada.Wide_Text_IO.Reset_Standard_Files (a-wrstfi.ads): Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads. (line 6) * Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads): Ada Wide_Wide_Characters Unicode a-zchuni ads. (line 6) * Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads): Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads. (line 6) * Ada.Wide_Wide_Text_IO.Reset_Standard_Files (a-zrstfi.ads): Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads. (line 6) * Address: RM 13 5 3 7-8 Bit Ordering. (line 16) * Address <1>: RM 13 7 37 Address as Private. (line 10) * Address Clause: Address Clauses. (line 6) * Address clauses: RM 13 2 6-8 Packed Types. (line 27) * Address image: System Address_Image s-addima ads. (line 6) * Address of subprogram code: Attribute Code_Address. (line 6) * Address_Size: Attribute Address_Size. (line 6) * AI-0002 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1133) * AI-0003 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 231) * AI-0007 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1000) * AI-0008 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 250) * AI-0009 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 735) * AI-0012 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 868) * AI-0015 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 581) * AI-0017 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1028) * AI-0019 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1017) * AI-0026 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 678) * AI-0030 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 708) * AI-0031 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1065) * AI-0032 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 590) * AI-0033 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 967) * AI-0034 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 805) * AI-0035 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 814) * AI-0037 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 456) * AI-0038 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1106) * AI-0039 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 878) * AI-0040 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 788) * AI-0042 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 698) * AI-0043 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 835) * AI-0044 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1115) * AI-0046 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 558) * AI-0050 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 618) * AI-0056 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1078) * AI-0058 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 610) * AI-0060 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1036) * AI-0062 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 637) * AI-0064 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 670) * AI-0065 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1008) * AI-0070 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 389) * AI-0072 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 745) * AI-0073 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 378) * AI-0076 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 335) * AI-0077 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 771) * AI-0078 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 920) * AI-0079 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 41) * AI-0080 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 77) * AI-0087 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 652) * AI-0088 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 486) * AI-0091 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 49) * AI-0093 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 260) * AI-0095 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 887) * AI-0096 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 267) * AI-0097 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 352) * AI-0098 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 415) * AI-0099 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 661) * AI-0100 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 60) * AI-0102 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 309) * AI-0103 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 602) * AI-0104 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 506) * AI-0106 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 860) * AI-0108 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 753) * AI-0109 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 993) * AI-0112 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 850) * AI-0114 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1045) * AI-0116 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 896) * AI-0118 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 565) * AI-0120 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 241) * AI-0122 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 780) * AI-0123 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 466) * AI-0125 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 629) * AI-0126 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 343) * AI-0127 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1125) * AI-0128 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 221) * AI-0129 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 760) * AI-0132 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 796) * AI-0134 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 542) * AI-0137 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1088) * AI-0139-2 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 533) * AI-0146 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 904) * AI-0147 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 440) * AI-0152 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1209) * AI-0157 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 514) * AI-0158 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 318) * AI-0161 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 975) * AI-0162 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 407) * AI-0163 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 69) * AI-0171 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1184) * AI-0173 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 328) * AI-0176 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 33) * AI-0177 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 954) * AI-0178 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 644) * AI-0179 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 523) * AI-0181 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 278) * AI-0182 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 289) * AI-0183 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 84) * AI-0185 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1056) * AI-0188 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 497) * AI-0189 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1172) * AI-0190 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1162) * AI-0193 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 945) * AI-0194 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 984) * AI-0195 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 930) * AI-0196 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 573) * AI-0198 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 369) * AI-0199 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 424) * AI-0200 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 842) * AI-0201 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 721) * AI-0203 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 362) * AI-0205 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 691) * AI-0206 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1202) * AI-0207 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 550) * AI-0208 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 397) * AI-0210 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1194) * AI-0211 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1155) * AI-0214 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 300) * AI-0219 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 826) * AI-0220 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 432) * AI05-0216 (Ada 2012 feature): Implementation of Ada 2012 Features. (line 1144) * Alignment: Pragma Optimize_Alignment. (line 6) * Alignment <1>: Attribute Maximum_Alignment. (line 6) * Alignment <2>: Attribute System_Allocator_Alignment. (line 6) * Alignment <3>: Alignment Clauses. (line 83) * Alignment <4>: Alignment Clauses. (line 87) * Alignment Clause: Alignment Clauses. (line 6) * Alignment clauses: RM 13 3 14-19 Address Clauses. (line 37) * Alignments of components: Pragma Component_Alignment. (line 6) * allocator: Attribute System_Allocator_Alignment. (line 6) * Alternative Character Sets: RM 2 8 17-19 Pragmas. (line 16) * AltiVec: GNAT Altivec g-altive ads. (line 6) * AltiVec <1>: GNAT Altivec Conversions g-altcon ads. (line 6) * AltiVec <2>: GNAT Altivec Vector_Operations g-alveop ads. (line 6) * AltiVec <3>: GNAT Altivec Vector_Types g-alvety ads. (line 6) * AltiVec <4>: GNAT Altivec Vector_Views g-alvevi ads. (line 6) * Always_Terminates: Aspect Always_Terminates. (line 6) * Annex E: GNAT Implementation of Shared Passive Packages. (line 12) * Annotate: Aspect Annotate. (line 6) * Anonymous access types: Conventions and Anonymous Access Types. (line 6) * Argument passing mechanisms: Pragma Export_Function. (line 6) * argument removal: Ada Command_Line Remove a-colire ads. (line 6) * Array packing: Pragma Implicit_Packing. (line 35) * Array splitter: GNAT Array_Split g-arrspl ads. (line 6) * Arrays: RM 3 5 7 17 Float Types. (line 24) * Arrays <1>: GNAT Dynamic_Tables g-dyntab ads. (line 6) * Arrays <2>: GNAT Table g-table ads. (line 6) * as private type: RM 13 5 3 7-8 Bit Ordering. (line 15) * Asm_Input: Attribute Asm_Input. (line 6) * Asm_Output: Attribute Asm_Output. (line 6) * Assert_Failure: System Assertions s-assert ads. (line 6) * Assertions: Pragma Check. (line 6) * Assertions <1>: Pragma Check_Policy. (line 6) * Assertions <2>: System Assertions s-assert ads. (line 6) * Async_Readers: Aspect Async_Readers. (line 6) * Async_Writers: Aspect Async_Writers. (line 6) * Atomic Synchronization: Pragma Disable_Atomic_Synchronization. (line 6) * Atomic Synchronization <1>: Pragma Enable_Atomic_Synchronization. (line 6) * Atomic_Always_Lock_Free: Attribute Atomic_Always_Lock_Free. (line 6) * Attribute: Address Clauses. (line 73) * Attribute Loop_Entry: Pragma Unevaluated_Use_Of_Old. (line 6) * Attribute Old: Pragma Unevaluated_Use_Of_Old. (line 6) * AWK: GNAT AWK g-awk ads. (line 6) * Biased representation: Biased Representation. (line 6) * Big endian: Attribute Default_Bit_Order. (line 6) * Big endian <1>: Attribute Default_Scalar_Storage_Order. (line 6) * Binary search: GNAT Binary_Search g-binsea ads. (line 6) * Bind environment: GNAT Bind_Environment g-binenv ads. (line 6) * Bit: Attribute Bit. (line 6) * Bit ordering: RM 13 5 2 5 Storage Place Attributes. (line 15) * bit ordering: Bit_Order Clauses. (line 6) * Bit_Order Clause: Bit_Order Clauses. (line 6) * Bit_Position: Attribute Bit_Position. (line 6) * Boolean_Entry_Barriers: Simple_Barriers. (line 12) * Bounded Buffers: GNAT Bounded_Buffers g-boubuf ads. (line 6) * Bounded errors: RM 1 1 3 31 Child Units. (line 11) * Bounded-length strings: RM A 3 2 49 Ada Characters Handling. (line 12) * Branch Prediction: GNAT Branch_Prediction g-brapre ads. (line 6) * Bubble sort: GNAT Bubble_Sort g-bubsor ads. (line 6) * Bubble sort <1>: GNAT Bubble_Sort_A g-busora ads. (line 6) * Bubble sort <2>: GNAT Bubble_Sort_G g-busorg ads. (line 6) * byte ordering: Effect of Bit_Order on Byte Ordering. (line 6) * Byte swapping: GNAT Byte_Swapping g-bytswa ads. (line 6) * C: RM B 2 12-13 Package Interfaces. (line 22) * C Streams: Ada Direct_IO C_Streams a-diocst ads. (line 6) * C Streams <1>: Ada Sequential_IO C_Streams a-siocst ads. (line 6) * C Streams <2>: Ada Streams Stream_IO C_Streams a-ssicst ads. (line 6) * C Streams <3>: Ada Text_IO C_Streams a-tiocst ads. (line 6) * C Streams <4>: Ada Wide_Text_IO C_Streams a-wtcstr ads. (line 6) * C Streams <5>: Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads. (line 6) * C streams: Interfaces C Streams i-cstrea ads. (line 6) * Calendar: GNAT Calendar g-calend ads. (line 6) * Calendar <1>: GNAT Calendar Time_IO g-catiio ads. (line 6) * casing: Pragma External_Name_Casing. (line 6) * Casing of External names: Pragma External_Name_Casing. (line 6) * Casing utilities: GNAT Case_Util g-casuti ads. (line 6) * CGI (Common Gateway Interface): GNAT CGI g-cgi ads. (line 6) * CGI (Common Gateway Interface) cookie support: GNAT CGI Cookie g-cgicoo ads. (line 6) * CGI (Common Gateway Interface) debugging: GNAT CGI Debug g-cgideb ads. (line 6) * Character handling (''GNAT.Case_Util''): GNAT Case_Util g-casuti ads. (line 6) * Character Sets: RM 2 8 17-19 Pragmas. (line 17) * Check names: Pragma Check_Name. (line 6) * Check pragma control: Pragma Check_Policy. (line 6) * Checks: Pragma Post. (line 6) * Checks <1>: Pragma Postcondition. (line 6) * Checks <2>: Pragma Post_Class. (line 6) * Checks <3>: Pragma Pre. (line 6) * Checks <4>: Pragma Precondition. (line 6) * Checks <5>: Pragma Pre_Class. (line 6) * Checks <6>: RM 11 4 1 19 Exception Information. (line 23) * Child Units: RM 1 1 3 20 Error Detection. (line 12) * COBOL: RM B 3 63-71 Interfacing with C. (line 58) * COBOL support: RM E 5 28-29 Partition Communication Subsystem. (line 18) * Code_Address: Attribute Code_Address. (line 6) * Command line: Ada Command_Line Remove a-colire ads. (line 6) * Command line <1>: Ada Command_Line Response_File a-clrefi ads. (line 6) * Command line <2>: Ada Command_Line Response_File a-clrefi ads. (line 6) * Command line <3>: GNAT Command_Line g-comlin ads. (line 6) * Compatibility (between Ada 83 and Ada 95 / Ada 2005 / Ada 2012): Compatibility with Ada 83. (line 6) * Compatibility between Ada 95 and Ada 2005: Compatibility between Ada 95 and Ada 2005. (line 6) * Compilation_Date: Compilation_Date. (line 6) * Compilation_ISO_Date: Compilation_ISO_Date. (line 6) * Compilation_Time: Compilation_Time. (line 6) * Compiler Version: GNAT Compiler_Version g-comver ads. (line 6) * Compiler_Version: Attribute Compiler_Version. (line 6) * complex arithmetic: RM G 2 4 19 Accuracy Requirements. (line 16) * Complex arithmetic accuracy: RM G 2 4 19 Accuracy Requirements. (line 17) * Complex elementary functions: RM G 1 1 56-58 Complex Types. (line 53) * Complex types: RM G Numerics. (line 15) * Component Clause: Record Representation Clauses. (line 11) * Component_Size (in pragma Component_Alignment): Pragma Component_Alignment. (line 21) * Component_Size Clause: Component_Size Clauses. (line 6) * Component_Size clauses: RM 13 3 50-56 Size Clauses. (line 39) * Component_Size_4 (in pragma Component_Alignment): Pragma Component_Alignment. (line 31) * configuration pragma Ada_2012: Implementation of Ada 2012 Features. (line 6) * Constant_After_Elaboration: Aspect Constant_After_Elaboration. (line 6) * Constrained: Attribute Constrained. (line 6) * Containers: RM A 10 7 23 Get_Immediate. (line 19) * Contract cases: Pragma Contract_Cases. (line 6) * Contract_Cases: Aspect Contract_Cases. (line 6) * control: Pragma Check_Policy. (line 6) * Controlling assertions: Pragma Check_Policy. (line 6) * Convention: Effect of Convention on Representation. (line 6) * Convention for anonymous access types: Conventions and Anonymous Access Types. (line 6) * Conventions: Conventions. (line 6) * Conventions <1>: Pragma Convention_Identifier. (line 6) * Conversion: System Wch_Cnv s-wchcnv ads. (line 6) * Cookie support in CGI: GNAT CGI Cookie g-cgicoo ads. (line 6) * CRC32: GNAT CRC32 g-crc32 ads. (line 6) * Current exception: GNAT Current_Exception g-curexc ads. (line 6) * Current time: GNAT Time_Stamp g-timsta ads. (line 6) * Cyclic Redundancy Check: GNAT CRC32 g-crc32 ads. (line 6) * Debug pools: GNAT Debug_Pools g-debpoo ads. (line 6) * Debugging: GNAT Debug_Pools g-debpoo ads. (line 6) * Debugging <1>: GNAT Debug_Utilities g-debuti ads. (line 6) * Debugging <2>: GNAT Exception_Traces g-exctra ads. (line 6) * debugging with Initialize_Scalars: Pragma Initialize_Scalars. (line 6) * DEC Ada 83: Pragma Extend_System. (line 6) * Dec Ada 83 casing compatibility: Pragma External_Name_Casing. (line 6) * Decimal radix support: RM F 7 COBOL Support. (line 15) * Decoding strings: GNAT Decode_String g-decstr ads. (line 6) * Decoding strings <1>: GNAT Decode_UTF8_String g-deutst ads. (line 6) * Decoding UTF-8 strings: GNAT Decode_UTF8_String g-deutst ads. (line 6) * default: Alignment Clauses. (line 83) * Default (in pragma Component_Alignment): Pragma Component_Alignment. (line 43) * default settings: Pragma Optimize_Alignment. (line 6) * Default_Bit_Order: Attribute Default_Bit_Order. (line 6) * Default_Initial_Condition: Aspect Default_Initial_Condition. (line 6) * Default_Scalar_Storage_Order: Pragma Default_Scalar_Storage_Order. (line 6) * Default_Scalar_Storage_Order <1>: Attribute Default_Scalar_Storage_Order. (line 6) * Default_Storage_Pool: Pragma Default_Storage_Pool. (line 6) * Deferring aborts: Pragma Abort_Defer. (line 6) * defining: Pragma Check_Name. (line 6) * Defining check names: Pragma Check_Name. (line 6) * Depends: Aspect Depends. (line 6) * Deref: Attribute Deref. (line 6) * Descriptor: Attribute Descriptor_Size. (line 6) * Descriptor_Size: Attribute Descriptor_Size. (line 6) * determination of: Determining the Representations chosen by GNAT. (line 6) * Dimension: Aspect Dimension. (line 6) * Dimension_System: Aspect Dimension_System. (line 6) * Directory operations: GNAT Directory_Operations g-dirope ads. (line 6) * Directory operations iteration: GNAT Directory_Operations Iteration g-diopit ads. (line 6) * Disable_Controlled: Aspect Disable_Controlled. (line 6) * Discriminants: Attribute Has_Discriminants. (line 6) * Distribution Systems Annex: GNAT Implementation of Shared Passive Packages. (line 12) * Dope vector: Attribute Descriptor_Size. (line 6) * Dump Memory: GNAT Memory_Dump g-memdum ads. (line 6) * Duration'Small: RM 3 6 2 11 Multidimensional Arrays. (line 14) * effect on representation: Effect of Convention on Representation. (line 6) * Effective_Reads: Aspect Effective_Reads. (line 6) * Effective_Writes: Aspect Effective_Writes. (line 6) * Elab_Body: Attribute Elab_Body. (line 6) * Elab_Spec: Attribute Elab_Spec. (line 6) * Elab_Subp_Body: Attribute Elab_Subp_Body. (line 6) * Elaborated: Attribute Elaborated. (line 6) * Elaboration control: Pragma Elaboration_Checks. (line 6) * Elimination of unused subprograms: Pragma Eliminate. (line 6) * Emax: Attribute Emax. (line 6) * Enabled: Attribute Enabled. (line 6) * Enclosing_Entity: Enclosing_Entity. (line 6) * Encoding strings: GNAT Encode_String g-encstr ads. (line 6) * Encoding strings <1>: GNAT Encode_UTF8_String g-enutst ads. (line 6) * Encoding UTF-8 strings: GNAT Encode_UTF8_String g-enutst ads. (line 6) * Endianness: Attribute Scalar_Storage_Order. (line 6) * Endianness <1>: GNAT Byte_Swapping g-bytswa ads. (line 6) * Entry queuing policies: RM D 3 17 Locking Policies. (line 12) * Enum_Rep: Attribute Enum_Rep. (line 6) * Enum_Val: Attribute Enum_Val. (line 6) * enumeration: RM 13 3 71-73 Component Size Clauses. (line 23) * Enumeration representation clauses: RM 13 3 71-73 Component Size Clauses. (line 24) * Enumeration values: RM 3 5 4 29 Integer Types. (line 12) * Environment entries: Ada Command_Line Environment a-colien ads. (line 6) * Epsilon: Attribute Epsilon. (line 6) * Error detection: Implementation Advice. (line 28) * exception: Pragma Prefix_Exception_Messages. (line 6) * Exception: GNAT Most_Recent_Exception g-moreex ads. (line 6) * exception <1>: System Assertions s-assert ads. (line 6) * Exception actions: GNAT Exception_Actions g-excact ads. (line 6) * Exception information: RM 10 2 1 12 Consistent Representation. (line 18) * Exception retrieval: GNAT Current_Exception g-curexc ads. (line 6) * Exception traces: GNAT Exception_Traces g-exctra ads. (line 6) * Exception_Information': Exception_Information. (line 6) * Exception_Message: Pragma Prefix_Exception_Messages. (line 6) * Exception_Message <1>: Exception_Message. (line 6) * Exception_Name: Exception_Name. (line 6) * Exceptions: GNAT Exceptions g-except ads. (line 6) * exceptions: GNAT Exceptions g-except ads. (line 6) * Export: RM A 18 Containers. (line 17) * Export <1>: Address Clauses. (line 116) * extendable: GNAT Dynamic_Tables g-dyntab ads. (line 6) * extendable <1>: GNAT Table g-table ads. (line 6) * extending: Pragma Extend_System. (line 6) * extensions for unbounded strings: Ada Strings Unbounded Text_IO a-suteio ads. (line 6) * extensions for unbounded wide strings: Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads. (line 6) * extensions for unbounded wide wide strings: Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads. (line 6) * Extensions_Visible: Aspect Extensions_Visible. (line 6) * External Names: Pragma External_Name_Casing. (line 6) * Fast_Math: Attribute Fast_Math. (line 6) * Favor_Top_Level: Aspect Favor_Top_Level. (line 6) * File: File. (line 6) * File locking: GNAT Lock_Files g-locfil ads. (line 6) * Finalization_Size: Attribute Finalization_Size. (line 6) * Fixed_Value: Attribute Fixed_Value. (line 6) * Float types: RM 3 5 5 8 Enumeration Values. (line 15) * Floating-point overflow: Pragma Check_Float_Overflow. (line 6) * Floating-Point Processor: GNAT Float_Control g-flocon ads. (line 6) * foreign: GNAT Threads g-thread ads. (line 6) * Foreign threads: GNAT Threads g-thread ads. (line 6) * Forking a new process: Mapping Ada Tasks onto the Underlying Kernel Threads. (line 53) * Formal container for vectors: Ada Containers Bounded_Holders a-coboho ads. (line 6) * Formatted String: GNAT Formatted_String g-forstr ads. (line 6) * Fortran: RM B 4 95-98 Interfacing with COBOL. (line 28) * From_Any: Attribute From_Any. (line 6) * Get_Immediate: RM A 5 2 46-47 Random Number Generation. (line 21) * Get_Immediate <1>: Get_Immediate. (line 6) * Get_Immediate <2>: Interfaces VxWorks IO i-vxwoio ads. (line 6) * Get_Immediate <3>: Interfaces VxWorks IO i-vxwoio ads. (line 6) * Ghost: Aspect Ghost. (line 6) * Ghost_Predicate: Aspect Ghost_Predicate. (line 6) * Global: Aspect Global. (line 6) * global: System Pool_Global s-pooglo ads. (line 6) * Global storage pool: System Pool_Global s-pooglo ads. (line 6) * GNAT Extensions: Pragma Extensions_Allowed. (line 6) * GNAT.Altivec (g-altive.ads): GNAT Altivec g-altive ads. (line 6) * GNAT.Altivec.Conversions (g-altcon.ads): GNAT Altivec Conversions g-altcon ads. (line 6) * GNAT.Altivec.Vector_Operations (g-alveop.ads): GNAT Altivec Vector_Operations g-alveop ads. (line 6) * GNAT.Altivec.Vector_Types (g-alvety.ads): GNAT Altivec Vector_Types g-alvety ads. (line 6) * GNAT.Altivec.Vector_Views (g-alvevi.ads): GNAT Altivec Vector_Views g-alvevi ads. (line 6) * GNAT.Array_Split (g-arrspl.ads): GNAT Array_Split g-arrspl ads. (line 6) * GNAT.AWK (g-awk.ads): GNAT AWK g-awk ads. (line 6) * GNAT.Binary_Search (g-binsea.ads): GNAT Binary_Search g-binsea ads. (line 6) * GNAT.Bind_Environment (g-binenv.ads): GNAT Bind_Environment g-binenv ads. (line 6) * GNAT.Bounded_Buffers (g-boubuf.ads): GNAT Bounded_Buffers g-boubuf ads. (line 6) * GNAT.Bounded_Mailboxes (g-boumai.ads): GNAT Bounded_Mailboxes g-boumai ads. (line 6) * GNAT.Branch_Prediction (g-brapre.ads): GNAT Branch_Prediction g-brapre ads. (line 6) * GNAT.Bubble_Sort (g-bubsor.ads): GNAT Bubble_Sort g-bubsor ads. (line 6) * GNAT.Bubble_Sort_A (g-busora.ads): GNAT Bubble_Sort_A g-busora ads. (line 6) * GNAT.Bubble_Sort_G (g-busorg.ads): GNAT Bubble_Sort_G g-busorg ads. (line 6) * GNAT.Byte_Order_Mark (g-byorma.ads): GNAT Byte_Order_Mark g-byorma ads. (line 6) * GNAT.Byte_Swapping (g-bytswa.ads): GNAT Byte_Swapping g-bytswa ads. (line 6) * GNAT.Calendar (g-calend.ads): GNAT Calendar g-calend ads. (line 6) * GNAT.Calendar.Time_IO (g-catiio.ads): GNAT Calendar Time_IO g-catiio ads. (line 5) * GNAT.Case_Util (g-casuti.ads): GNAT Case_Util g-casuti ads. (line 6) * GNAT.CGI (g-cgi.ads): GNAT CGI g-cgi ads. (line 6) * GNAT.CGI.Cookie (g-cgicoo.ads): GNAT CGI Cookie g-cgicoo ads. (line 6) * GNAT.CGI.Debug (g-cgideb.ads): GNAT CGI Debug g-cgideb ads. (line 6) * GNAT.Command_Line (g-comlin.ads): GNAT Command_Line g-comlin ads. (line 6) * GNAT.Compiler_Version (g-comver.ads): GNAT Compiler_Version g-comver ads. (line 6) * GNAT.CRC32 (g-crc32.ads): GNAT CRC32 g-crc32 ads. (line 6) * GNAT.Ctrl_C (g-ctrl_c.ads): GNAT Ctrl_C g-ctrl_c ads. (line 6) * GNAT.Current_Exception (g-curexc.ads): GNAT Current_Exception g-curexc ads. (line 6) * GNAT.Debug_Pools (g-debpoo.ads): GNAT Debug_Pools g-debpoo ads. (line 6) * GNAT.Debug_Utilities (g-debuti.ads): GNAT Debug_Utilities g-debuti ads. (line 6) * GNAT.Decode_String (g-decstr.ads): GNAT Decode_String g-decstr ads. (line 6) * GNAT.Decode_UTF8_String (g-deutst.ads): GNAT Decode_UTF8_String g-deutst ads. (line 6) * GNAT.Directory_Operations (g-dirope.ads): GNAT Directory_Operations g-dirope ads. (line 6) * GNAT.Directory_Operations.Iteration (g-diopit.ads): GNAT Directory_Operations Iteration g-diopit ads. (line 6) * GNAT.Dynamic_HTables (g-dynhta.ads): GNAT Dynamic_HTables g-dynhta ads. (line 6) * GNAT.Dynamic_Tables (g-dyntab.ads): GNAT Dynamic_Tables g-dyntab ads. (line 6) * GNAT.Encode_String (g-encstr.ads): GNAT Encode_String g-encstr ads. (line 6) * GNAT.Encode_UTF8_String (g-enutst.ads): GNAT Encode_UTF8_String g-enutst ads. (line 6) * GNAT.Exception_Actions (g-excact.ads): GNAT Exception_Actions g-excact ads. (line 6) * GNAT.Exception_Traces (g-exctra.ads): GNAT Exception_Traces g-exctra ads. (line 6) * GNAT.Exceptions (g-except.ads): GNAT Exceptions g-except ads. (line 6) * GNAT.Expect (g-expect.ads): GNAT Expect g-expect ads. (line 6) * GNAT.Expect.TTY (g-exptty.ads): GNAT Expect TTY g-exptty ads. (line 6) * GNAT.Float_Control (g-flocon.ads): GNAT Float_Control g-flocon ads. (line 6) * GNAT.Formatted_String (g-forstr.ads): GNAT Formatted_String g-forstr ads. (line 6) * GNAT.Generic_Fast_Math_Functions (g-gfmafu.ads): GNAT Generic_Fast_Math_Functions g-gfmafu ads. (line 6) * GNAT.Heap_Sort (g-heasor.ads): GNAT Heap_Sort g-heasor ads. (line 6) * GNAT.Heap_Sort_A (g-hesora.ads): GNAT Heap_Sort_A g-hesora ads. (line 6) * GNAT.Heap_Sort_G (g-hesorg.ads): GNAT Heap_Sort_G g-hesorg ads. (line 6) * GNAT.HTable (g-htable.ads): GNAT HTable g-htable ads. (line 6) * GNAT.IO (g-io.ads): GNAT IO g-io ads. (line 6) * GNAT.IO_Aux (g-io_aux.ads): GNAT IO_Aux g-io_aux ads. (line 6) * GNAT.Lock_Files (g-locfil.ads): GNAT Lock_Files g-locfil ads. (line 6) * GNAT.MBBS_Discrete_Random (g-mbdira.ads): GNAT MBBS_Discrete_Random g-mbdira ads. (line 6) * GNAT.MBBS_Float_Random (g-mbflra.ads): GNAT MBBS_Float_Random g-mbflra ads. (line 6) * GNAT.MD5 (g-md5.ads): GNAT MD5 g-md5 ads. (line 6) * GNAT.Memory_Dump (g-memdum.ads): GNAT Memory_Dump g-memdum ads. (line 6) * GNAT.Most_Recent_Exception (g-moreex.ads): GNAT Most_Recent_Exception g-moreex ads. (line 6) * GNAT.OS_Lib (g-os_lib.ads): GNAT OS_Lib g-os_lib ads. (line 6) * GNAT.Perfect_Hash_Generators (g-pehage.ads): GNAT Perfect_Hash_Generators g-pehage ads. (line 6) * GNAT.Random_Numbers (g-rannum.ads): GNAT Random_Numbers g-rannum ads. (line 6) * GNAT.Regexp (g-regexp.ads): GNAT Regexp g-regexp ads. (line 6) * GNAT.Registry (g-regist.ads): GNAT Registry g-regist ads. (line 6) * GNAT.Regpat (g-regpat.ads): GNAT Regpat g-regpat ads. (line 6) * GNAT.Rewrite_Data (g-rewdat.ads): GNAT Rewrite_Data g-rewdat ads. (line 6) * GNAT.Secondary_Stack_Info (g-sestin.ads): GNAT Secondary_Stack_Info g-sestin ads. (line 6) * GNAT.Semaphores (g-semaph.ads): GNAT Semaphores g-semaph ads. (line 6) * GNAT.Serial_Communications (g-sercom.ads): GNAT Serial_Communications g-sercom ads. (line 6) * GNAT.SHA1 (g-sha1.ads): GNAT SHA1 g-sha1 ads. (line 6) * GNAT.SHA224 (g-sha224.ads): GNAT SHA224 g-sha224 ads. (line 6) * GNAT.SHA256 (g-sha256.ads): GNAT SHA256 g-sha256 ads. (line 6) * GNAT.SHA384 (g-sha384.ads): GNAT SHA384 g-sha384 ads. (line 6) * GNAT.SHA512 (g-sha512.ads): GNAT SHA512 g-sha512 ads. (line 6) * GNAT.Signals (g-signal.ads): GNAT Signals g-signal ads. (line 6) * GNAT.Sockets (g-socket.ads): GNAT Sockets g-socket ads. (line 6) * GNAT.Source_Info (g-souinf.ads): GNAT Source_Info g-souinf ads. (line 6) * GNAT.Spelling_Checker (g-speche.ads): GNAT Spelling_Checker g-speche ads. (line 6) * GNAT.Spelling_Checker_Generic (g-spchge.ads): GNAT Spelling_Checker_Generic g-spchge ads. (line 6) * GNAT.Spitbol (g-spitbo.ads): GNAT Spitbol g-spitbo ads. (line 6) * GNAT.Spitbol.Patterns (g-spipat.ads): GNAT Spitbol Patterns g-spipat ads. (line 6) * GNAT.Spitbol.Table_Boolean (g-sptabo.ads): GNAT Spitbol Table_Boolean g-sptabo ads. (line 6) * GNAT.Spitbol.Table_Integer (g-sptain.ads): GNAT Spitbol Table_Integer g-sptain ads. (line 6) * GNAT.Spitbol.Table_VString (g-sptavs.ads): GNAT Spitbol Table_VString g-sptavs ads. (line 6) * GNAT.SSE (g-sse.ads): GNAT SSE g-sse ads. (line 6) * GNAT.SSE.Vector_Types (g-ssvety.ads): GNAT SSE Vector_Types g-ssvety ads. (line 6) * GNAT.String_Hash (g-strhas.ads): GNAT String_Hash g-strhas ads. (line 6) * GNAT.String_Split (g-strspl.ads): GNAT String_Split g-strspl ads. (line 6) * GNAT.Strings (g-string.ads): GNAT Strings g-string ads. (line 6) * GNAT.Table (g-table.ads): GNAT Table g-table ads. (line 6) * GNAT.Task_Lock (g-tasloc.ads): GNAT Task_Lock g-tasloc ads. (line 6) * GNAT.Threads (g-thread.ads): GNAT Threads g-thread ads. (line 6) * GNAT.Time_Stamp (g-timsta.ads): GNAT Time_Stamp g-timsta ads. (line 6) * GNAT.Traceback (g-traceb.ads): GNAT Traceback g-traceb ads. (line 6) * GNAT.Traceback.Symbolic (g-trasym.ads): GNAT Traceback Symbolic g-trasym ads. (line 6) * GNAT.UTF_32 (g-utf_32.ads): GNAT UTF_32 g-utf_32 ads. (line 6) * GNAT.UTF_32_Spelling_Checker (g-u3spch.ads): GNAT UTF_32_Spelling_Checker g-u3spch ads. (line 6) * GNAT.Wide_Spelling_Checker (g-wispch.ads): GNAT Wide_Spelling_Checker g-wispch ads. (line 6) * GNAT.Wide_String_Split (g-wistsp.ads): GNAT Wide_String_Split g-wistsp ads. (line 6) * GNAT.Wide_Wide_Spelling_Checker (g-zspche.ads): GNAT Wide_Wide_Spelling_Checker g-zspche ads. (line 6) * GNAT.Wide_Wide_String_Split (g-zistsp.ads): GNAT Wide_Wide_String_Split g-zistsp ads. (line 6) * handling long command lines: Ada Command_Line Response_File a-clrefi ads. (line 6) * Handling of Records with Holes: Handling of Records with Holes. (line 6) * Has_Access_Values: Attribute Has_Access_Values. (line 6) * Has_Discriminants: Attribute Has_Discriminants. (line 6) * Has_Tagged_Values: Attribute Has_Tagged_Values. (line 6) * Hash functions: GNAT Perfect_Hash_Generators g-pehage ads. (line 6) * Hash functions <1>: GNAT String_Hash g-strhas ads. (line 6) * Hash tables: GNAT Dynamic_HTables g-dynhta ads. (line 6) * Hash tables <1>: GNAT HTable g-htable ads. (line 6) * Heap usage: RM 13 9 14-17 Unchecked Conversion. (line 34) * I/O interfacing: Interfaces VxWorks IO i-vxwoio ads. (line 6) * IBM Packed Format: Interfaces Packed_Decimal i-pacdec ads. (line 6) * Image: System Address_Image s-addima ads. (line 6) * Img: Attribute Img. (line 6) * Immediate_Reclamation: Immediate_Reclamation. (line 6) * Implementation-dependent features: About This Guide. (line 24) * implicit: RM 13 9 14-17 Unchecked Conversion. (line 33) * Import: Address Clauses. (line 121) * Initial_Condition: Aspect Initial_Condition. (line 6) * Initialization: Pragma Suppress_Initialization. (line 6) * Initialized: Attribute Initialized. (line 6) * Initializes: Aspect Initializes. (line 6) * Inline_Always: Aspect Inline_Always. (line 6) * Input/Output facilities: GNAT IO g-io ads. (line 6) * Input/Output facilities <1>: GNAT IO_Aux g-io_aux ads. (line 6) * Integer maps: GNAT Spitbol Table_Integer g-sptain ads. (line 6) * Integer types: RM 3 5 2 5 Alternative Character Sets. (line 23) * Integer_Value: Attribute Integer_Value. (line 6) * Interfaces: RM B 1 39-41 Pragma Export. (line 34) * Interfaces.C.Extensions (i-cexten.ads): Interfaces C Extensions i-cexten ads. (line 6) * Interfaces.C.Streams (i-cstrea.ads): Interfaces C Streams i-cstrea ads. (line 6) * Interfaces.Packed_Decimal (i-pacdec.ads): Interfaces Packed_Decimal i-pacdec ads. (line 6) * Interfaces.VxWorks (i-vxwork.ads): Interfaces VxWorks i-vxwork ads. (line 6) * Interfaces.VxWorks.Int_Connection (i-vxinco.ads): Interfaces VxWorks Int_Connection i-vxinco ads. (line 6) * Interfaces.VxWorks.IO (i-vxwoio.ads): Interfaces VxWorks IO i-vxwoio ads. (line 6) * interfacing: Interfaces C Streams i-cstrea ads. (line 6) * interfacing <1>: Interfaces VxWorks i-vxwork ads. (line 6) * interfacing <2>: Interfaces VxWorks Int_Connection i-vxinco ads. (line 6) * Interfacing to C++: Pragma CPP_Virtual. (line 6) * Interfacing to C++ <1>: Pragma Propagate_Exceptions. (line 6) * Interfacing to VxWorks: Interfaces VxWorks i-vxwork ads. (line 6) * Interfacing to VxWorks <1>: Interfaces VxWorks Int_Connection i-vxinco ads. (line 6) * Interfacing to VxWorks' I/O: Interfaces VxWorks IO i-vxwoio ads. (line 6) * interfacing with: RM B 2 12-13 Package Interfaces. (line 21) * interfacing with <1>: RM B 3 63-71 Interfacing with C. (line 57) * interfacing with <2>: RM B 4 95-98 Interfacing with COBOL. (line 27) * Interfacing with ''Text_IO'': Ada Text_IO C_Streams a-tiocst ads. (line 6) * Interfacing with ''Wide_Text_IO'': Ada Wide_Text_IO C_Streams a-wtcstr ads. (line 6) * Interfacing with ''Wide_Wide_Text_IO'': Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads. (line 6) * Interfacing with C++: Pragma CPP_Class. (line 6) * Interfacing with C++ <1>: Pragma CPP_Constructor. (line 6) * Interfacing with C++ <2>: Pragma CPP_Vtable. (line 6) * Interfacing with Direct_IO: Ada Direct_IO C_Streams a-diocst ads. (line 6) * Interfacing with Sequential_IO: Ada Sequential_IO C_Streams a-siocst ads. (line 6) * Interfacing with Stream_IO: Ada Streams Stream_IO C_Streams a-ssicst ads. (line 6) * Interrupt: GNAT Ctrl_C g-ctrl_c ads. (line 6) * Interrupt support: RM C 1 10-16 Access to Machine Operations. (line 39) * Interrupts: RM C 3 1 20-21 Protected Procedure Handlers. (line 16) * Intrinsic operator: Intrinsic Operators. (line 6) * Intrinsic Subprograms: Intrinsic Subprograms. (line 6) * Invalid representations: Pragma Assume_No_Invalid_Values. (line 6) * Invalid values: Pragma Assume_No_Invalid_Values. (line 6) * Invalid_Value: Attribute Invalid_Value. (line 6) * Invariant: Aspect Invariant. (line 6) * Invariant'Class: Aspect Invariant’Class. (line 6) * IO support: Ada Strings Unbounded Text_IO a-suteio ads. (line 6) * IO support <1>: Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads. (line 6) * IO support <2>: Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads. (line 6) * Iterable: Aspect Iterable. (line 6) * Iterable <1>: Attribute Iterable. (line 6) * Large: Attribute Large. (line 6) * Latin_1 constants for Wide_Character: Ada Characters Wide_Latin_1 a-cwila1 ads. (line 6) * Latin_1 constants for Wide_Wide_Character: Ada Characters Wide_Wide_Latin_1 a-chzla1 ads. (line 6) * Latin_9 constants for Character: Ada Characters Latin_9 a-chlat9 ads. (line 6) * Latin_9 constants for Wide_Character: Ada Characters Wide_Latin_9 a-cwila9 ads. (line 6) * Latin_9 constants for Wide_Wide_Character: Ada Characters Wide_Wide_Latin_9 a-chzla9 ads. (line 6) * Latin-1: Changed semantics. (line 12) * Library_Level: Attribute Library_Level. (line 6) * License checking: Pragma License. (line 6) * Line: Line. (line 6) * Linker_Section: Aspect Linker_Section. (line 6) * Little endian: Attribute Default_Bit_Order. (line 6) * Little endian <1>: Attribute Default_Scalar_Storage_Order. (line 6) * local: System Pool_Local s-pooloc ads. (line 6) * Local storage pool: System Pool_Local s-pooloc ads. (line 6) * Local_Restrictions: Aspect Local_Restrictions. (line 6) * Lock_Free: Aspect Lock_Free. (line 6) * Locking: GNAT Task_Lock g-tasloc ads. (line 6) * Locking Policies: RM C 7 2 30 The Package Task_Attributes. (line 17) * Locking using files: GNAT Lock_Files g-locfil ads. (line 6) * Loop_Entry: Attribute Loop_Entry. (line 6) * Machine Code insertions: Machine Code Insertions. (line 6) * Machine operations: RM B 5 22-26 Interfacing with Fortran. (line 34) * Machine_Size: Attribute Machine_Size. (line 6) * Mailboxes: GNAT Bounded_Mailboxes g-boumai ads. (line 6) * Mantissa: Attribute Mantissa. (line 6) * Maps: GNAT Spitbol Table_Integer g-sptain ads. (line 6) * Maps <1>: GNAT Spitbol Table_VString g-sptavs ads. (line 6) * Mathematical functions: GNAT Generic_Fast_Math_Functions g-gfmafu ads. (line 6) * Max_Asynchronous_Select_Nesting: Max_Asynchronous_Select_Nesting. (line 6) * Max_Entry_Queue_Depth: Max_Entry_Queue_Length. (line 13) * Max_Entry_Queue_Length: Max_Entry_Queue_Length. (line 6) * Max_Integer_Size: Attribute Max_Integer_Size. (line 6) * Max_Protected_Entries: Max_Protected_Entries. (line 6) * Max_Queue_Length: Aspect Max_Queue_Length. (line 6) * Max_Select_Alternatives: Max_Select_Alternatives. (line 6) * Max_Storage_At_Blocking: Max_Storage_At_Blocking. (line 6) * Max_Task_Entries: Max_Task_Entries. (line 6) * Max_Tasks: Max_Tasks. (line 6) * maximum: Attribute Maximum_Alignment. (line 6) * Maximum_Alignment: Attribute Maximum_Alignment. (line 6) * Maximum_Alignment attribute: Alignment Clauses. (line 21) * Mechanism_Code: Attribute Mechanism_Code. (line 6) * Memory allocation: System Memory s-memory ads. (line 6) * Memory corruption debugging: GNAT Debug_Pools g-debpoo ads. (line 6) * Memory-mapped I/O: Use of Address Clauses for Memory-Mapped I/O. (line 6) * Message Digest MD5: GNAT MD5 g-md5 ads. (line 6) * monotonic: RM D 7 21 Tasking Restrictions. (line 13) * multidimensional: RM 3 5 7 17 Float Types. (line 23) * Multidimensional arrays: RM 3 5 7 17 Float Types. (line 24) * Multiprocessor interface: System Multiprocessors s-multip ads. (line 6) * Multiprocessor interface <1>: System Multiprocessors Dispatching_Domains s-mudido ads. (line 6) * Named assertions: Pragma Check. (line 6) * Named assertions <1>: Pragma Check_Policy. (line 6) * Named numbers: Attribute Universal_Literal_String. (line 6) * No_Abort_Statements: No_Abort_Statements. (line 6) * No_Access_Parameter_Allocators: No_Access_Parameter_Allocators. (line 6) * No_Access_Subprograms: No_Access_Subprograms. (line 6) * No_Allocators: No_Allocators. (line 6) * No_Anonymous_Allocators: No_Anonymous_Allocators. (line 6) * No_Asynchronous_Control: No_Asynchronous_Control. (line 6) * No_Caching: Aspect No_Caching. (line 6) * No_Calendar: No_Calendar. (line 6) * No_Coextensions: No_Coextensions. (line 6) * No_Default_Initialization: No_Default_Initialization. (line 6) * No_Delay: No_Delay. (line 6) * No_Dependence: No_Dependence. (line 6) * No_Direct_Boolean_Operators: No_Direct_Boolean_Operators. (line 6) * No_Dispatch: No_Dispatch. (line 6) * No_Dispatching_Calls: No_Dispatching_Calls. (line 6) * No_Dynamic_Accessibility_Checks: No_Dynamic_Accessibility_Checks. (line 6) * No_Dynamic_Attachment: No_Dynamic_Attachment. (line 6) * No_Dynamic_Interrupts: No_Dynamic_Attachment. (line 11) * No_Dynamic_Priorities: No_Dynamic_Priorities. (line 6) * No_Dynamic_Sized_Objects: No_Dynamic_Sized_Objects. (line 6) * No_Elaboration_Code: No_Elaboration_Code. (line 6) * No_Elaboration_Code_All: Aspect No_Elaboration_Code_All. (line 6) * No_Entry_Calls_In_Elaboration_Code: No_Entry_Calls_In_Elaboration_Code. (line 6) * No_Entry_Queue: No_Entry_Queue. (line 6) * No_Enumeration_Maps: No_Enumeration_Maps. (line 6) * No_Exception_Handlers: No_Exception_Handlers. (line 6) * No_Exception_Propagation: No_Exception_Propagation. (line 6) * No_Exception_Registration: No_Exception_Registration. (line 6) * No_Exceptions: No_Exceptions. (line 6) * No_Finalization: No_Finalization. (line 6) * No_Fixed_Point: No_Fixed_Point. (line 6) * No_Floating_Point: No_Floating_Point. (line 6) * No_Implementation_Aspect_Specifications: No_Implementation_Aspect_Specifications. (line 6) * No_Implementation_Attributes: No_Implementation_Attributes. (line 6) * No_Implementation_Identifiers: No_Implementation_Identifiers. (line 6) * No_Implementation_Pragmas: No_Implementation_Pragmas. (line 6) * No_Implementation_Restrictions: No_Implementation_Restrictions. (line 6) * No_Implementation_Units: No_Implementation_Units. (line 6) * No_Implicit_Aliasing: No_Implicit_Aliasing. (line 6) * No_Implicit_Conditionals: No_Implicit_Conditionals. (line 6) * No_Implicit_Dynamic_Code: No_Implicit_Dynamic_Code. (line 6) * No_Implicit_Heap_Allocations: No_Implicit_Heap_Allocations. (line 6) * No_Implicit_Loops: No_Implicit_Loops. (line 6) * No_Implicit_Protected_Object_Allocations: No_Implicit_Protected_Object_Allocations. (line 6) * No_Implicit_Task_Allocations: No_Implicit_Task_Allocations. (line 6) * No_Initialize_Scalars: No_Initialize_Scalars. (line 6) * No_Inline: Aspect No_Inline. (line 6) * No_IO: No_IO. (line 6) * No_Local_Allocators: No_Local_Allocators. (line 6) * No_Local_Protected_Objects: No_Local_Protected_Objects. (line 6) * No_Local_Tagged_Types: No_Local_Tagged_Types. (line 6) * No_Local_Timing_Events: No_Local_Timing_Events. (line 6) * No_Long_Long_Integers: No_Long_Long_Integers. (line 6) * No_Multiple_Elaboration: No_Multiple_Elaboration. (line 6) * No_Nested_Finalization: No_Nested_Finalization. (line 6) * No_Obsolescent_Features: No_Obsolescent_Features. (line 6) * No_Protected_Type_Allocators: No_Protected_Type_Allocators. (line 6) * No_Protected_Types: No_Protected_Types. (line 6) * No_Recursion: No_Recursion. (line 6) * No_Reentrancy: No_Reentrancy. (line 6) * No_Relative_Delay: No_Relative_Delay. (line 6) * No_Requeue: No_Requeue_Statements. (line 10) * No_Requeue_Statements: No_Requeue_Statements. (line 6) * No_Secondary_Stack: No_Secondary_Stack. (line 6) * No_Select_Statements: No_Select_Statements. (line 6) * No_Specific_Termination_Handlers: No_Specific_Termination_Handlers. (line 6) * No_Specification_of_Aspect: No_Specification_of_Aspect. (line 6) * No_Standard_Allocators_After_Elaboration: No_Standard_Allocators_After_Elaboration. (line 6) * No_Standard_Storage_Pools: No_Standard_Storage_Pools. (line 6) * No_Stream_Optimizations: No_Stream_Optimizations. (line 6) * No_Streams: No_Streams. (line 6) * No_Tagged_Streams: Aspect No_Tagged_Streams. (line 6) * No_Tagged_Type_Registration: No_Tagged_Type_Registration. (line 6) * No_Task_Allocators: No_Task_Allocators. (line 6) * No_Task_At_Interrupt_Priority: No_Task_At_Interrupt_Priority. (line 6) * No_Task_Attributes: No_Task_Attributes_Package. (line 9) * No_Task_Attributes_Package: No_Task_Attributes_Package. (line 6) * No_Task_Hierarchy: No_Task_Hierarchy. (line 6) * No_Task_Parts: Aspect No_Task_Parts. (line 6) * No_Task_Termination: No_Task_Termination. (line 6) * No_Tasking: No_Tasking. (line 6) * No_Terminate_Alternatives: No_Terminate_Alternatives. (line 6) * No_Unchecked_Access: No_Unchecked_Access. (line 6) * No_Unchecked_Conversion: No_Unchecked_Conversion. (line 6) * No_Unchecked_Deallocation: No_Unchecked_Deallocation. (line 6) * No_Use_Of_Attribute: No_Use_Of_Attribute. (line 6) * No_Use_Of_Entity: No_Use_Of_Entity. (line 6) * No_Use_Of_Pragma: No_Use_Of_Pragma. (line 6) * No_Wide_Characters: No_Wide_Characters. (line 6) * Null_Occurrence: Ada Exceptions Is_Null_Occurrence a-einuoc ads. (line 6) * Null_Occurrence <1>: Ada Exceptions Last_Chance_Handler a-elchha ads. (line 6) * Null_Parameter: Attribute Null_Parameter. (line 6) * Numerics: RM F 1 2 Decimal Radix Support. (line 11) * Object_Size: Aspect Object_Size. (line 6) * Object_Size <1>: Attribute Object_Size. (line 6) * Object_Size <2>: Value_Size and Object_Size Clauses. (line 6) * Obsolescent: Aspect Obsolescent. (line 6) * obtaining most recent: GNAT Most_Recent_Exception g-moreex ads. (line 6) * of an address: System Address_Image s-addima ads. (line 6) * of bits: Bit_Order Clauses. (line 6) * of bytes: Effect of Bit_Order on Byte Ordering. (line 6) * of compiler: GNAT Compiler_Version g-comver ads. (line 6) * of objects: Value_Size and Object_Size Clauses. (line 6) * Old: Attribute Old. (line 6) * on ''Address'': RM 13 7 37 Address as Private. (line 10) * Operating System interface: GNAT OS_Lib g-os_lib ads. (line 6) * Operations: RM 13 7 37 Address as Private. (line 10) * operations of: RM 13 7 37 Address as Private. (line 9) * ordering: Bit_Order Clauses. (line 6) * ordering <1>: Effect of Bit_Order on Byte Ordering. (line 6) * Overlaying of objects: Address Clauses. (line 170) * Package ''Interrupts'': RM C 3 1 20-21 Protected Procedure Handlers. (line 17) * Package Interfaces: RM B 1 39-41 Pragma Export. (line 35) * Package Task_Attributes: RM C 5 8 Pragma Discard_Names. (line 12) * Packed Decimal: Interfaces Packed_Decimal i-pacdec ads. (line 6) * Packed types: RM 13 1 21-24 Representation Clauses. (line 38) * Parameters: Attribute Mechanism_Code. (line 6) * Parameters <1>: Attribute Passed_By_Reference. (line 6) * Parsing: GNAT AWK g-awk ads. (line 6) * Parsing <1>: GNAT Bounded_Buffers g-boubuf ads. (line 6) * Parsing <2>: GNAT Bounded_Mailboxes g-boumai ads. (line 6) * Part_Of: Aspect Part_Of. (line 6) * Partition communication subsystem: RM D 8 47-49 Monotonic Time. (line 23) * Partition interfacing functions: System Partition_Interface s-parint ads. (line 6) * Passed_By_Reference: Attribute Passed_By_Reference. (line 6) * passing: Attribute Null_Parameter. (line 6) * Passing by copy: Pragma C_Pass_By_Copy. (line 6) * passing mechanism: Attribute Mechanism_Code. (line 6) * passing mechanism <1>: Attribute Mechanism_Code. (line 6) * Pattern matching: GNAT Regexp g-regexp ads. (line 6) * Pattern matching <1>: GNAT Regpat g-regpat ads. (line 6) * Pattern matching <2>: GNAT Spitbol Patterns g-spipat ads. (line 6) * PCS: RM D 8 47-49 Monotonic Time. (line 22) * Persistent_BSS: Aspect Persistent_BSS. (line 6) * Pool_Address: Attribute Pool_Address. (line 6) * Portability: About This Guide. (line 24) * Post: Pragma Post. (line 6) * Post <1>: Pragma Post_Class. (line 6) * Postcondition: Pragma Postcondition. (line 6) * postconditions: Pragma Post. (line 6) * postconditions <1>: Pragma Postcondition. (line 6) * postconditions <2>: Pragma Post_Class. (line 6) * Pragma: Representation Clauses and Pragmas. (line 6) * pragma Ada_2012: Implementation of Ada 2012 Features. (line 6) * Pragma Component_Alignment: Pragma Component_Alignment. (line 6) * Pragma Pack (for arrays): Pragma Pack for Arrays. (line 6) * Pragma Pack (for records): Pragma Pack for Records. (line 6) * Pragma Pack (for type Natural): Pragma Pack for Arrays. (line 79) * Pragma Pack warning: Pragma Pack for Arrays. (line 79) * pragma Shared_Passive: GNAT Implementation of Shared Passive Packages. (line 6) * Pragmas: Pragma Rename_Pragma. (line 6) * Pragmas <1>: RM 1 1 5 12 Bounded Errors. (line 12) * Pre: Pragma Pre. (line 6) * Pre_Class: Pragma Pre_Class. (line 6) * Pre-elaboration requirements: RM C 3 2 25 Package Interrupts. (line 14) * preconditions: Pragma Pre. (line 6) * Preconditions: Pragma Precondition. (line 6) * preconditions <1>: Pragma Precondition. (line 6) * preconditions <2>: Pragma Pre_Class. (line 6) * Predicate: Aspect Predicate. (line 6) * Preemptive abort: RM D 4 16 Entry Queuing Policies. (line 10) * Prefix_Exception_Messages: Pragma Prefix_Exception_Messages. (line 6) * Protected procedure handlers: RM C 3 28 Interrupt Support. (line 14) * Pure: GNAT Exceptions g-except ads. (line 6) * Pure packages: GNAT Exceptions g-except ads. (line 6) * Pure_Barriers: Pure_Barriers. (line 6) * Pure_Function: Aspect Pure_Function. (line 6) * Random number generation: RM A 4 4 106 Bounded-Length String Handling. (line 10) * Random number generation <1>: GNAT MBBS_Discrete_Random g-mbdira ads. (line 6) * Random number generation <2>: GNAT MBBS_Float_Random g-mbflra ads. (line 6) * Random number generation <3>: GNAT Random_Numbers g-rannum ads. (line 6) * Range_Length: Attribute Range_Length. (line 6) * Rational compatibility: Pragma Overriding_Renamings. (line 6) * Rational Profile: Pragma Implicit_Packing. (line 6) * Rational profile: Pragma Overriding_Renamings. (line 6) * Rational profile <1>: Pragma Use_VADS_Size. (line 6) * Read attribute: RM 13 13 2 1 6 Stream Oriented Attributes. (line 22) * Real-Time Systems Annex compliance: Ensuring Compliance with the Real-Time Annex. (line 6) * Record Representation Clause: Record Representation Clauses. (line 6) * Record representation clauses: RM 13 4 9-10 Enumeration Representation Clauses. (line 15) * records: RM 13 4 9-10 Enumeration Representation Clauses. (line 14) * Refined_Depends: Aspect Refined_Depends. (line 6) * Refined_Global: Aspect Refined_Global. (line 6) * Refined_Initialization: Aspect Relaxed_Initialization. (line 6) * Refined_Post: Aspect Refined_Post. (line 6) * Refined_State: Aspect Refined_State. (line 6) * Regular expressions: GNAT Regexp g-regexp ads. (line 6) * Regular expressions <1>: GNAT Regpat g-regpat ads. (line 6) * Remote_Access_Type: Aspect Remote_Access_Type. (line 6) * Removing command line arguments: Ada Command_Line Remove a-colire ads. (line 6) * representation: Representation Clauses and Pragmas. (line 6) * Representation: Determining the Representations chosen by GNAT. (line 6) * Representation <1>: System Wch_Cnv s-wchcnv ads. (line 6) * Representation Clause: Representation Clauses and Pragmas. (line 6) * Representation clauses: RM 11 5 28 Suppression of Checks. (line 10) * Representation clauses <1>: RM 13 3 71-73 Component Size Clauses. (line 24) * Representation clauses <2>: RM 13 4 9-10 Enumeration Representation Clauses. (line 15) * Representation Clauses: Representation Clauses and Pragmas. (line 6) * representation of: Attribute Universal_Literal_String. (line 6) * Representation of enums: Attribute Enum_Rep. (line 6) * Representation of enums <1>: Attribute Enum_Val. (line 6) * Representation of wide characters: System Wch_Cnv s-wchcnv ads. (line 6) * Representation Pragma: Representation Clauses and Pragmas. (line 6) * response file: Ada Command_Line Response_File a-clrefi ads. (line 6) * Response file for command line: Ada Command_Line Response_File a-clrefi ads. (line 6) * Restriction_Set: Attribute Restriction_Set. (line 6) * Restrictions: Attribute Restriction_Set. (line 6) * Restrictions definitions: System Rident s-rident ads. (line 6) * Result: Attribute Result. (line 6) * Return values: Attribute Mechanism_Code. (line 6) * Rewrite data: GNAT Rewrite_Data g-rewdat ads. (line 6) * Rotate_Left: Shifts and Rotates. (line 6) * Rotate_Right: Shifts and Rotates. (line 6) * Run-time restrictions access: System Restrictions s-restri ads. (line 6) * Safe_Emax: Attribute Safe_Emax. (line 6) * Safe_Large: Attribute Safe_Large. (line 6) * Safe_Small: Attribute Safe_Small. (line 6) * Scalar storage order: Attribute Scalar_Storage_Order. (line 6) * Scalar_Storage_Order: Pragma Default_Scalar_Storage_Order. (line 6) * Scalar_Storage_Order <1>: Aspect Scalar_Storage_Order. (line 6) * Scalar_Storage_Order <2>: Attribute Scalar_Storage_Order. (line 6) * Secondary Stack Info: GNAT Secondary_Stack_Info g-sestin ads. (line 6) * Secondary_Stack_Size: Aspect Secondary_Stack_Size. (line 6) * Secure Hash Algorithm SHA-1: GNAT SHA1 g-sha1 ads. (line 6) * Secure Hash Algorithm SHA-224: GNAT SHA224 g-sha224 ads. (line 6) * Secure Hash Algorithm SHA-256: GNAT SHA256 g-sha256 ads. (line 6) * Secure Hash Algorithm SHA-384: GNAT SHA384 g-sha384 ads. (line 6) * Secure Hash Algorithm SHA-512: GNAT SHA512 g-sha512 ads. (line 6) * Semaphores: GNAT Semaphores g-semaph ads. (line 6) * Sequential elaboration policy: RM G 2 6 15 Complex Arithmetic Accuracy. (line 13) * Serial_Communications: GNAT Serial_Communications g-sercom ads. (line 6) * Sets of strings: GNAT Spitbol Table_Boolean g-sptabo ads. (line 6) * setting for not-first subtype: Attribute Value_Size. (line 6) * Shared: Aspect Shared. (line 6) * Shared passive packages: GNAT Implementation of Shared Passive Packages. (line 6) * SHARED_MEMORY_DIRECTORY environment variable: GNAT Implementation of Shared Passive Packages. (line 35) * Shift operators: Pragma Provide_Shift_Operators. (line 6) * Shift_Left: Shifts and Rotates. (line 6) * Shift_Right: Shifts and Rotates. (line 6) * Shift_Right_Arithmetic: Shifts and Rotates. (line 6) * Side_Effects: Aspect Side_Effects. (line 6) * Signals: GNAT Signals g-signal ads. (line 6) * simple: Pragma Simple_Storage_Pool_Type. (line 6) * simple <1>: Attribute Simple_Storage_Pool. (line 6) * Simple I/O: GNAT IO g-io ads. (line 6) * Simple storage pool: Pragma Simple_Storage_Pool_Type. (line 6) * Simple storage pool <1>: Attribute Simple_Storage_Pool. (line 6) * Simple_Barriers: Simple_Barriers. (line 6) * Simple_Storage_Pool: Aspect Simple_Storage_Pool. (line 6) * Simple_Storage_Pool <1>: Attribute Simple_Storage_Pool. (line 6) * Simple_Storage_Pool_Type: Aspect Simple_Storage_Pool_Type. (line 6) * Size: Pragma Use_VADS_Size. (line 6) * Size <1>: Attribute Object_Size. (line 6) * Size <2>: Attribute VADS_Size. (line 6) * Size <3>: Attribute Value_Size. (line 6) * Size <4>: Size of Variant Record Objects. (line 6) * size: Size of Variant Record Objects. (line 6) * Size <5>: Value_Size and Object_Size Clauses. (line 6) * Size Clause: Size Clauses. (line 6) * Size clauses: RM 13 3 29-35 Alignment Clauses. (line 40) * Size for biased representation: Biased Representation. (line 6) * Size of ''Address'': Attribute Address_Size. (line 6) * Small: Attribute Small. (line 6) * Small <1>: Attribute Small_Denominator. (line 6) * Small <2>: Attribute Small_Numerator. (line 6) * Small_Denominator: Attribute Small_Denominator. (line 6) * Small_Numerator: Attribute Small_Numerator. (line 6) * Sockets: GNAT Sockets g-socket ads. (line 6) * Sorting: GNAT Bubble_Sort g-bubsor ads. (line 6) * Sorting <1>: GNAT Bubble_Sort_A g-busora ads. (line 6) * Sorting <2>: GNAT Bubble_Sort_G g-busorg ads. (line 6) * Sorting <3>: GNAT Heap_Sort g-heasor ads. (line 6) * Sorting <4>: GNAT Heap_Sort_A g-hesora ads. (line 6) * Sorting <5>: GNAT Heap_Sort_G g-hesorg ads. (line 6) * Source Information: GNAT Source_Info g-souinf ads. (line 6) * Source_Location: Source_Location. (line 6) * SPARK_05: SPARK_05. (line 6) * SPARK_Mode: Aspect SPARK_Mode. (line 6) * Spawn capability: GNAT OS_Lib g-os_lib ads. (line 6) * Spell checking: GNAT Spelling_Checker g-speche ads. (line 6) * Spell checking <1>: GNAT Spelling_Checker_Generic g-spchge ads. (line 6) * Spell checking <2>: GNAT UTF_32_Spelling_Checker g-u3spch ads. (line 6) * Spell checking <3>: GNAT Wide_Spelling_Checker g-wispch ads. (line 6) * Spell checking <4>: GNAT Wide_Wide_Spelling_Checker g-zspche ads. (line 6) * SPITBOL interface: GNAT Spitbol g-spitbo ads. (line 6) * SPITBOL pattern matching: GNAT Spitbol Patterns g-spipat ads. (line 6) * SPITBOL Tables: GNAT Spitbol Table_Boolean g-sptabo ads. (line 6) * SPITBOL Tables <1>: GNAT Spitbol Table_Integer g-sptain ads. (line 6) * SPITBOL Tables <2>: GNAT Spitbol Table_VString g-sptavs ads. (line 6) * Static_Dispatch_Tables: Static_Dispatch_Tables. (line 6) * Static_Priorities: Static_Priorities. (line 6) * Static_Storage_Size: Static_Storage_Size. (line 6) * Storage place attributes: RM 13 5 1 17-22 Record Representation Clauses. (line 44) * Storage pool: Pragma Simple_Storage_Pool_Type. (line 6) * Storage pool <1>: Attribute Simple_Storage_Pool. (line 6) * Storage pool <2>: System Pool_Global s-pooglo ads. (line 6) * Storage pool <3>: System Pool_Local s-pooloc ads. (line 6) * Storage_Size Clause: Storage_Size Clauses. (line 6) * Storage_Unit: Attribute Storage_Unit. (line 6) * Storage_Unit (in pragma Component_Alignment): Pragma Component_Alignment. (line 37) * Stream files: Treating Text_IO Files as Streams. (line 6) * Stream operations: System Strings Stream_Ops s-ststop ads. (line 6) * Stream oriented attributes: RM 13 11 2 17 Unchecked Deallocation. (line 10) * Stream oriented attributes <1>: RM 13 13 2 1 6 Stream Oriented Attributes. (line 21) * String decoding: GNAT Decode_String g-decstr ads. (line 6) * String encoding: GNAT Encode_String g-encstr ads. (line 6) * String maps: GNAT Spitbol Table_VString g-sptavs ads. (line 6) * String splitter: GNAT String_Split g-strspl ads. (line 6) * String stream operations: System Strings Stream_Ops s-ststop ads. (line 6) * Stub_Type: Attribute Stub_Type. (line 6) * Subprogram address: Attribute Code_Address. (line 6) * subtypes: Alignment Clauses. (line 87) * Suppress_Debug_Info: Aspect Suppress_Debug_Info. (line 6) * Suppress_Initialization: Aspect Suppress_Initialization. (line 6) * Suppressing external name: Pragma Export_Function. (line 59) * Suppressing external name <1>: Pragma Export_Procedure. (line 44) * Suppressing external name <2>: Pragma Export_Valued_Procedure. (line 49) * Suppressing initialization: Pragma Suppress_Initialization. (line 6) * suppression of: Pragma Suppress_Initialization. (line 6) * suppression of <1>: RM 11 4 1 19 Exception Information. (line 22) * Suppression of checks: RM 11 4 1 19 Exception Information. (line 23) * synonyms: Pragma Convention_Identifier. (line 6) * synonyms <1>: Pragma Rename_Pragma. (line 6) * System: Pragma Extend_System. (line 6) * System_Allocator_Alignment: Attribute System_Allocator_Alignment. (line 6) * System.Address_Image (s-addima.ads): System Address_Image s-addima ads. (line 6) * System.Assertions (s-assert.ads): System Assertions s-assert ads. (line 6) * System.Atomic_Counters (s-atocou.ads): System Atomic_Counters s-atocou ads. (line 6) * System.Memory (s-memory.ads): System Memory s-memory ads. (line 6) * System.Multiprocessors (s-multip.ads): System Multiprocessors s-multip ads. (line 6) * System.Multiprocessors.Dispatching_Domains (s-mudido.ads): System Multiprocessors Dispatching_Domains s-mudido ads. (line 6) * System.Partition_Interface (s-parint.ads): System Partition_Interface s-parint ads. (line 6) * System.Pool_Global (s-pooglo.ads): System Pool_Global s-pooglo ads. (line 6) * System.Pool_Local (s-pooloc.ads): System Pool_Local s-pooloc ads. (line 6) * System.Restrictions (s-restri.ads): System Restrictions s-restri ads. (line 6) * System.Rident (s-rident.ads): System Rident s-rident ads. (line 6) * System.Strings.Stream_Ops (s-ststop.ads): System Strings Stream_Ops s-ststop ads. (line 6) * System.Unsigned_Types (s-unstyp.ads): System Unsigned_Types s-unstyp ads. (line 6) * System.Wch_Cnv (s-wchcnv.ads): System Wch_Cnv s-wchcnv ads. (line 6) * System.Wch_Con (s-wchcon.ads): System Wch_Con s-wchcon ads. (line 6) * Table implementation: GNAT Dynamic_Tables g-dyntab ads. (line 6) * Table implementation <1>: GNAT Table g-table ads. (line 6) * Tagged values: Attribute Has_Tagged_Values. (line 6) * Target_Name: Attribute Target_Name. (line 6) * Task locking: GNAT Task_Lock g-tasloc ads. (line 6) * Task specific storage: Pragma Thread_Local_Storage. (line 6) * Task synchronization: GNAT Task_Lock g-tasloc ads. (line 6) * Task_Attributes: Pragma Thread_Local_Storage. (line 6) * Task_Attributes <1>: RM C 5 8 Pragma Discard_Names. (line 11) * Tasking restrictions: RM D 6 9-10 Preemptive Abort. (line 18) * Test cases: Pragma Test_Case. (line 6) * Test_Case: Aspect Test_Case. (line 6) * testing for: Attribute Has_Access_Values. (line 6) * testing for <1>: Attribute Has_Discriminants. (line 6) * testing for <2>: Attribute Has_Tagged_Values. (line 6) * testing for <3>: Ada Exceptions Is_Null_Occurrence a-einuoc ads. (line 6) * testing for <4>: Ada Exceptions Last_Chance_Handler a-elchha ads. (line 6) * Text_IO: Ada Strings Unbounded Text_IO a-suteio ads. (line 6) * Text_IO <1>: Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads. (line 6) * Text_IO <2>: Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads. (line 6) * Text_IO <3>: GNAT IO_Aux g-io_aux ads. (line 6) * Text_IO extensions: Text_IO Extensions. (line 6) * Text_IO for unbounded strings: Text_IO Facilities for Unbounded Strings. (line 6) * Text_IO operations: Text_IO Facilities for Unbounded Strings. (line 6) * Text_IO resetting standard files: Ada Text_IO Reset_Standard_Files a-tirsfi ads. (line 6) * Thread_Local_Storage: Aspect Thread_Local_Storage. (line 6) * Threads: GNAT Threads g-thread ads. (line 6) * Time: RM D 7 21 Tasking Restrictions. (line 14) * Time <1>: GNAT Calendar Time_IO g-catiio ads. (line 6) * Time stamp: GNAT Time_Stamp g-timsta ads. (line 6) * TLS (Thread Local Storage): Pragma Thread_Local_Storage. (line 6) * To_Address: Attribute To_Address. (line 6) * To_Address <1>: Address Clauses. (line 73) * To_Any: Attribute To_Any. (line 6) * Trace back facilities: GNAT Traceback g-traceb ads. (line 6) * Trace back facilities <1>: GNAT Traceback Symbolic g-trasym ads. (line 5) * Traceback for Exception Occurrence: Ada Exceptions Traceback a-exctra ads. (line 6) * trampoline: No_Implicit_Dynamic_Code. (line 6) * Type_Class: Attribute Type_Class. (line 6) * Type_Key: Attribute Type_Key. (line 6) * TypeCode: Attribute TypeCode. (line 6) * typographical: Conventions. (line 6) * Typographical conventions: Conventions. (line 6) * Unbounded_String: Text_IO Facilities for Unbounded Strings. (line 6) * Unbounded_String <1>: Ada Strings Unbounded Text_IO a-suteio ads. (line 6) * Unbounded_Wide_String: Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads. (line 6) * Unbounded_Wide_Wide_String: Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads. (line 6) * Unchecked conversion: RM 13 7 1 16 Address Operations. (line 14) * Unchecked deallocation: RM 13 11 23-25 Implicit Heap Usage. (line 32) * Unconstrained_Array: Attribute Unconstrained_Array. (line 6) * Unevaluated_Use_Of_Old: Pragma Unevaluated_Use_Of_Old. (line 6) * Unicode: GNAT Decode_String g-decstr ads. (line 6) * Unicode <1>: GNAT Decode_UTF8_String g-deutst ads. (line 6) * Unicode <2>: GNAT Encode_String g-encstr ads. (line 6) * Unicode <3>: GNAT Encode_UTF8_String g-enutst ads. (line 6) * Unicode categorization: Ada Wide_Characters Unicode a-wichun ads. (line 6) * Unicode categorization <1>: Ada Wide_Wide_Characters Unicode a-zchuni ads. (line 6) * Unions in C: Pragma Unchecked_Union. (line 6) * Universal_Aliasing: Aspect Universal_Aliasing. (line 6) * Universal_Literal_String: Attribute Universal_Literal_String. (line 6) * unmodified: Pragma Unmodified. (line 6) * Unmodified: Aspect Unmodified. (line 6) * unreferenced: Pragma Unreferenced. (line 6) * unreferenced <1>: Pragma Unreferenced_Objects. (line 6) * Unreferenced: Aspect Unreferenced. (line 6) * Unreferenced_Objects: Aspect Unreferenced_Objects. (line 6) * unrestricted: Attribute Unrestricted_Access. (line 6) * Unrestricted_Access: Attribute Unrestricted_Access. (line 6) * unused: Pragma Unused. (line 6) * Update: Attribute Update. (line 6) * used for objects: Attribute Object_Size. (line 6) * User_Aspect: Aspect User_Aspect. (line 6) * UTF-8: GNAT Decode_String g-decstr ads. (line 6) * UTF-8 <1>: GNAT Decode_UTF8_String g-deutst ads. (line 6) * UTF-8 <2>: GNAT Encode_String g-encstr ads. (line 6) * UTF-8 <3>: GNAT Encode_UTF8_String g-enutst ads. (line 6) * UTF-8 representation: GNAT Byte_Order_Mark g-byorma ads. (line 6) * UTF-8 string decoding: GNAT Decode_UTF8_String g-deutst ads. (line 6) * UTF-8 string encoding: GNAT Encode_UTF8_String g-enutst ads. (line 6) * VADS compatibility: Pragma Use_VADS_Size. (line 6) * VADS compatibility <1>: Attribute VADS_Size. (line 6) * VADS_Size: Attribute VADS_Size. (line 6) * Valid_Scalars: Attribute Valid_Scalars. (line 6) * Valid_Value: Attribute Valid_Value. (line 6) * Value_Size: Aspect Value_Size. (line 6) * Value_Size <1>: Attribute Value_Size. (line 6) * Value_Size <2>: Value_Size and Object_Size Clauses. (line 6) * variant record objects: Size of Variant Record Objects. (line 6) * Variant record objects: Size of Variant Record Objects. (line 6) * Version: GNAT Compiler_Version g-comver ads. (line 6) * Volatile_Full_Access: Aspect Volatile_Full_Access. (line 6) * Volatile_Function: Aspect Volatile_Function. (line 6) * VxWorks: Interfaces VxWorks i-vxwork ads. (line 6) * VxWorks <1>: Interfaces VxWorks Int_Connection i-vxinco ads. (line 6) * VxWorks <2>: Interfaces VxWorks IO i-vxwoio ads. (line 6) * VxWorks <3>: Interfaces VxWorks IO i-vxwoio ads. (line 6) * VxWorks <4>: Interfaces VxWorks IO i-vxwoio ads. (line 6) * Warnings: Pragma Unmodified. (line 6) * Warnings <1>: Pragma Unreferenced. (line 6) * Warnings <2>: Pragma Unreferenced_Objects. (line 6) * Warnings <3>: Pragma Unused. (line 6) * Warnings <4>: Aspect Warnings. (line 6) * Wchar_T_Size: Attribute Wchar_T_Size. (line 6) * when passed by reference: Attribute Passed_By_Reference. (line 6) * Wide characte representations: GNAT Byte_Order_Mark g-byorma ads. (line 6) * Wide Character: System Wch_Cnv s-wchcnv ads. (line 6) * Wide character codes: GNAT UTF_32 g-utf_32 ads. (line 6) * Wide character decoding: GNAT Decode_UTF8_String g-deutst ads. (line 6) * Wide character encoding: GNAT Decode_String g-decstr ads. (line 6) * Wide character encoding <1>: GNAT Encode_String g-encstr ads. (line 6) * Wide character encoding <2>: GNAT Encode_UTF8_String g-enutst ads. (line 6) * Wide String: System Wch_Cnv s-wchcnv ads. (line 6) * Wide_Character: Ada Wide_Characters Unicode a-wichun ads. (line 6) * Wide_String splitter: GNAT Wide_String_Split g-wistsp ads. (line 6) * Wide_Text_IO resetting standard files: Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads. (line 6) * Wide_Wide_Character: Ada Wide_Wide_Characters Unicode a-zchuni ads. (line 6) * Wide_Wide_String splitter: GNAT Wide_Wide_String_Split g-zistsp ads. (line 6) * Wide_Wide_Text_IO resetting standard files: Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads. (line 6) * Windows Registry: GNAT Registry g-regist ads. (line 6) * Word_Size: Attribute Word_Size. (line 6) * Write attribute: RM 13 13 2 1 6 Stream Oriented Attributes. (line 22) * XDR representation: RM 13 13 2 1 6 Stream Oriented Attributes. (line 22) * Zero address: Attribute Null_Parameter. (line 6)